Поворот массива на n градус от заданной точки

///----------------------------------------------------------------------------|
/// Поворот массива на n градус от заданной точки.                             |
///----------------------------------------------------------------------------|
/// DevC++ MinGW GCC 8.1-32bit
/// Подключить либу ".../Dev-Cpp/MinGW64/x86_64-w64-mingw32/lib32/libgdi32.a"
///----------------------------------------------------------------------------:
#include <iostream>
#include <cmath>
#include <iomanip>
#include <conio.h>
#include <windows.h>
 
struct smystart
{   smystart()
    {   setlocale(0, "");
        system("mode 80,54");
        hCon = GetStdHandle(STD_OUTPUT_HANDLE);
    }
    
    HANDLE hCon;
    void set_cursor_xy(SHORT x, SHORT y)
    {   COORD coord = {x, y};
        SetConsoleCursorPosition(hCon, coord);
    }
}mystart;
 
const float PI_2 = 6.28f;
 
#define FORi(n) for(int i = 0; i < n; ++i)
#define FORj(n) for(int j = 0; j < n; ++j)
#define LOG(n)  std::cout  << std::setw(6) << #n << " = " << n << "\n"
#define BANNER  std::cout  << 
 
///----------------------------------------------------------------------------|
/// Двумерный динамический массив инкапсулированный в структуре.
///----------------------------------------------------------------------------:
template<class T>
class carr
{
public:
    carr(int _r, int _c) : arr(NULL), row(_r), column(_c)
    {   arr = create_arr(row, column);
    }
    
   ~carr()
    {   delete_arr(arr);
    }
    
    //------------------------------------------------------resize(int r, int c)
    void resize(int _r, int _c)
    {   row    = _r;
        column = _c;
        if(arr != NULL) 
        {   delete_arr   (arr);
            create_arr(row, column);
        }
    }
    
    //-----------------------------------------------------------init_one(T val)
    void init_one(T _val)
    {   FORi(row)
            FORj(column)
                arr[i][j] = _val;
    }
    
    int row_()
    {   return row;
    }
    int column_()
    {   return column;
    }
    
    //-------------------------------------------------------------------show():
    void show()
    {   //std::cout << "\n";
        LOG(row);
        LOG(column);
        FORi(row)
        {   FORj(column)
            {   if(arr[i][j] != -777)
                std::cout << std::setw(5) 
                          << std::setprecision(4) 
                          << std::setfill(' ') << arr[i][j] << " \t";
                else 
                std::cout << std::setw(5) 
                          << std::setprecision(4) 
                          << std::setfill(' ') << " empty\t";
            }
            std::cout << "\n";
        }
        std::cout << "\n";
    }
    
    void show_M()
    {   FORi(row)
        {   FORj(column)
            {   std::cout << arr[i][j];
            }
            std::cout << "\n";
        }
        //std::cout << "\n";
    }
 
    T* operator [](const int i)const {return arr[i];}
    
protected:
    T** arr;
    int row, column;
    
    //--------------------------------------------------------------create_arr()
    T** create_arr(int r, int c)
    {   T** _arr;
        _arr = new T*[r];
        FORi(r)
        {   _arr[i] = new T[c];
        }
        return _arr;
    }
    
    //--------------------------------------------------------------delete_arr()
    void delete_arr(T**& p)
    {   FORi(row)
        {   delete[] p[i];
        }
        delete[] p;
        p = NULL;
    }
    
};
 
///----------------------------------------------------------------------------|
/// Модерируем carr под задачу.
///----------------------------------------------------------------------------:
template<class T>
class cmymatrix : public carr<T>
{
public:
    cmymatrix(int r, int c) : carr<T>(r, c) {}
    
    using carr<T>::row;
    using carr<T>::column;
    using carr<T>::arr;
    
    void load_data()
    {   
        char data[][32] =
        {   "0 0 0 0 0 0 0 0 0 0 0 0 0 0 0",
            "0 1 1 1 1 1 1 1 1 1 1 1 1 1 0",
            "0 1 0 0 0 0 0 0 0 0 0 0 0 1 0",
            "0 1 0 0 0 0 0 0 0 0 0 0 0 1 0",
            "0 1 0 0 0 0 0 0 0 0 0 0 0 1 0",
            "0 1 0 0 0 0 0 0 0 0 0 0 0 1 0",
            "0 1 0 0 0 0 0 0 0 0 0 0 0 1 0",
            "0 1 0 0 0 0 0 * 0 0 0 0 0 1 0",
            "0 1 0 0 0 0 0 0 0 0 0 0 0 1 0",
            "0 1 0 0 0 0 0 0 0 0 0 0 0 1 0",
            "0 1 0 0 0 0 0 0 0 0 0 0 0 1 0",
            "0 1 0 0 0 0 0 0 0 0 0 0 0 1 0",
            "0 1 0 0 0 0 0 0 0 0 0 0 0 1 0",
            "0 1 0 0 0 0 0 0 0 0 0 0 1 1 0",
            "0 1 1 1 1 1 1 1 1 1 1 1 1 0 0",
            "0 0 0 0 0 0 0 0 0 0 0 0 0 0 0"
        };
        FORi(row)
            FORj(column)
                if(data[i][j] == '1') arr[i][j] = true;
                else                  arr[i][j] = false;
    }
    
    void cls()
    {   FORi(row)
            FORj(column)
                arr[i][j] = false;
    }
    
    void show()
    {   FORi(row)
        {   FORj(column)
                if(arr[i][j]) std::cout << "O";
                else          std::cout << " ";
            std::cout << "\n";
        }
    }
};
 
///----------------------------------------------------------------------------|
/// Класс для рисования гексы.
///----------------------------------------------------------------------------:
struct sGexagon
{   sGexagon(float r) : radius (r),
                        deltax (0.f),
                        deltay (0.f),
                        rot    (0.f),
                        DELT_PI(PI_2/6),
                        side_  (6)
    {       hWnd     = GetConsoleWindow();
            hDC      = GetDC(hWnd);
            cP       = CreatePen(PS_SOLID, 7, RGB(0,255,0));
            cP_black = CreatePen(PS_SOLID, 7, RGB(0,0,0));
        SelectObject(hDC, cP);
    }
    
    sGexagon()        : deltax (0.f),
                        deltay (0.f),
                        rot    (0.f),
                        DELT_PI(PI_2/6),
                        side_  (6)
    {       hWnd     = GetConsoleWindow();
            hDC      = GetDC(hWnd);
            cP       = CreatePen(PS_SOLID, 7, RGB(0,255,0));
            cP_black = CreatePen(PS_SOLID, 7, RGB(0,0,0));
        SelectObject(hDC, cP);
    }
    
    struct sPlot
    {   float x;
        float y;
    };
    
    void draw()
    {   POINT pp; 
 
        sPlot p = get(0);
        for(int i = 0; i < side_; i++)
        {   MoveToEx(hDC, p.x, p.y,  &pp);
            p = get(i+1);
            LineTo(hDC, p.x, p.y);
        }
    }
    
    void move(float x, float y)
    {   deltax = x;
        deltay = y;
    }
    
    void color(int r, int g, int b)
    {   /// TODO: закрыть предыдущий пен?!
        DeleteObject(cP);
        cP = CreatePen(PS_SOLID, 7, RGB(r,g,b));
        SelectObject(hDC, cP);
    }
    
    void cls()
    {   SelectObject(hDC, cP_black);
        draw();
        SelectObject(hDC, cP);
    }
 
    void side(int n)
    {   DELT_PI = PI_2/n;
        side_   = n;
    }
    
    float rot;
protected:
    float radius;
    float deltax, deltay;
    HWND  hWnd;
    HDC   hDC;
    HPEN  cP, cP_black;
    float DELT_PI;
    int   side_;
    
    sPlot get(int a)
    {   sPlot p;
        p.x = radius * sin(DELT_PI*a + rot) + deltax;
        p.y = radius * cos(DELT_PI*a + rot) + deltay;
        return p;
    }
};
 
///----------------------------------------------------------------------------|
/// Был использован класс sGexagon взятый из другой задачи без всяких изменений.
///----------------------------------------------------------------------------:
class sDraw_plot : protected sGexagon
{
public: 
    
    void draw_plot(sPlot p)
    {   POINT pp;
        p.x = p.x * 6 + 300;
        p.y = p.y * 6 + 120;
        MoveToEx(hDC, p.x, p.y,  &pp);
        LineTo(hDC, p.x, p.y);
    }
    
    void cls_plot(sPlot& p)
    {   SelectObject(hDC, cP_black);
        draw_plot(p);
        SelectObject(hDC, cP);
    }
};
 
///----------------------------------------------------------------------------|
/// Градусы в радианы.(для удобства управления).
///----------------------------------------------------------------------------:
float to_rad(float gradus){ return 6.28f * gradus / 360;}
 
///----------------------------------------------------------------------------|
/// Класс для рисования массива точек.
///----------------------------------------------------------------------------:
class cAnimation_array
{   
        cmymatrix<bool>& source;
        cmymatrix<bool>  trans;
        cmymatrix<bool>  rot;
        
    sDraw_plot graf;
    
public:
    cAnimation_array(cmymatrix<bool>& _source) :  source(_source),
                                                  rot  (48,64),
                                                  trans(16,32)
    {   alfa = 0.f;
        rot.cls();
        
        while(true)
        {   mystart.set_cursor_xy(0, 52);
            std::cout << "Пауза: дави Escape...     ";
            mystart.set_cursor_xy(0, 53);
            std::cout << " ...                      ";
            
            while(IsKeyDown(VK_ESCAPE))
            {   mystart.set_cursor_xy(0, 3);
                std::cout << "Угол поворота(градусы) = " << alfa << "    ";
        
                cls();
                draw();
                Sleep(20);
            }
            
            mystart.set_cursor_xy(0, 52);
            std::cout << "Продолжить: дави ПРОБЕЛ...";
            
            mystart.set_cursor_xy(0, 53);
            std::cout << "Микроскоп: дави \"2\"...     ";
            
            while(IsKeyDown(VK_SPACE))
            {   if(!IsKeyDown('2'))
                {   mystart.set_cursor_xy(0, 36);
                    trans.carr::show_M();
                    mystart.set_cursor_xy(0, 53);
                    std::cout << "Поворот искомой матрицы   ";
                }
                Sleep(20);
            }
        }
    }
    
    float alfa;
    
    void draw()
    {   alfa += 1.f;
        if(alfa > 760.) alfa -= 760.;
    
        FORi(source.row)
        {   FORj(source.column)
                if(source[i][j])
                {   sGexagon::sPlot _coord = get_coord(i, j);
                    graf.draw_plot(_coord);
                    
                    int x = (int)_coord.x;
                    int y = (int)_coord.y;
                    
                    //if((y > 0) && (y < 64) && (x > 0) && (x < 64))
                        rot[y+16][x+8] = true;
                }
        }
        
        FORi(source.row)
        {   FORj(source.column)
                trans[i][j] = rot[i+16][j+8];
        }
        
        
        mystart.set_cursor_xy(1, 4);
        //rot.cmymatrix::show();
        rot.cmymatrix::show();
        //_getch();
    }
    
    void cls()
    {   rot.cls();
        FORi(source.row)
        {   FORj(source.column)
                if(source[i][j])
                {   sGexagon::sPlot _coord = get_coord(i, j);
                    graf.cls_plot(_coord);
                }
        }
    }
    
    ///------------------------------------------------------------------------|
    /// "сам цпу-шейдер"
    /// Вот этой функцией я кручу:
    /// как видите это та же функция, что и выше в моем посте на скрине :)
    ///------------------------------------------------------------------------:
    sGexagon::sPlot get_coord(int row, int column)
    {   sGexagon::sPlot coord;
        
        float a = to_rad(alfa);
    
        coord.x = cos(a)*(column-16) - sin(a)*(row-8) + 16.0f;
        coord.y = sin(a)*(column-16) + cos(a)*(row-8) + 8.0f;
        
        return coord;
    }
    
    inline bool IsKeyDown(int Key)
    {   return (GetKeyState(Key) & 0x8000) == 0;
    }
};
 
///----------------------------------------------------------------------------|
/// Старт.
///----------------------------------------------------------------------------:
int main()
{   BANNER
        "///------------------------------------------------|\n"<<
        "/// Поворот массива на n градус.                   |\n"<<
        "///------------------------------------------------:\n";
 
    cmymatrix<bool> source(16, 32);
    source.load_data();
    //source.show();
    
    cAnimation_array animarr(source);
    
    _getch();
    return 0;
}