Перспективное преобразование координат

typedef struct { float x, y, z; } Point3D;

void AxonomProj(int n, Point3D* figure, Point3D* proj)
{
    float alp = ProjectionAlpha;
    float beta = ProjectionBeta;
    for (int i = 0; i<n; i++)
    {
        proj[i].x = figure[i].x * cos(alp) - figure[i].y * sin(alp);
        proj[i].y = figure[i].x * sin(alp) * cos(beta) + figure[i].y * cos(alp)* cos(beta) - figure[i].z * sin(beta);
        proj[i].z = figure[i].x * sin(alp) * sin(beta) + figure[i].y * cos(alp)* sin(beta) + figure[i].z * cos(beta);
    }
}

void PerspectiveProj(int n, Point3D* figure, Point3D* proj)
{
//перспективное преобразование
}

// lab3.cpp: определяет точку входа для приложения.
//
 
#include "stdafx.h"
#include "lab3.h"
#include <math.h>
 
#define MAX_LOADSTRING 100
 
// Глобальные переменные:
HINSTANCE hInst;                                // текущий экземпляр
WCHAR szTitle[MAX_LOADSTRING];                  // Текст строки заголовка
WCHAR szWindowClass[MAX_LOADSTRING];            // имя класса главного окна
 
// Отправить объявления функций, включенных в этот модуль кода:
ATOM                MyRegisterClass(HINSTANCE hInstance);
BOOL                InitInstance(HINSTANCE, int);
LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK    About(HWND, UINT, WPARAM, LPARAM);
 
int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
                     _In_opt_ HINSTANCE hPrevInstance,
                     _In_ LPWSTR    lpCmdLine,
                     _In_ int       nCmdShow)
{
    UNREFERENCED_PARAMETER(hPrevInstance);
    UNREFERENCED_PARAMETER(lpCmdLine);
 
    // TODO: разместите код здесь.
 
    // Инициализация глобальных строк
    LoadStringW(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
    LoadStringW(hInstance, IDC_LAB3, szWindowClass, MAX_LOADSTRING);
    MyRegisterClass(hInstance);
 
    // Выполнить инициализацию приложения:
    if (!InitInstance (hInstance, nCmdShow))
    {
        return FALSE;
    }
 
    HACCEL hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_LAB3));
 
    MSG msg;
 
    // Цикл основного сообщения:
    while (GetMessage(&msg, nullptr, 0, 0))
    {
        if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }
 
    return (int) msg.wParam;
}
 
 
 
//
//  ФУНКЦИЯ: MyRegisterClass()
//
//  НАЗНАЧЕНИЕ: регистрирует класс окна.
//
ATOM MyRegisterClass(HINSTANCE hInstance)
{
    WNDCLASSEXW wcex;
 
    wcex.cbSize = sizeof(WNDCLASSEX);
 
    wcex.style          = CS_HREDRAW | CS_VREDRAW;
    wcex.lpfnWndProc    = WndProc;
    wcex.cbClsExtra     = 0;
    wcex.cbWndExtra     = 0;
    wcex.hInstance      = hInstance;
    wcex.hIcon          = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_LAB3));
    wcex.hCursor        = LoadCursor(nullptr, IDC_ARROW);
    wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);
    wcex.lpszMenuName   = MAKEINTRESOURCEW(IDC_LAB3);
    wcex.lpszClassName  = szWindowClass;
    wcex.hIconSm        = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));
 
    return RegisterClassExW(&wcex);
}
 
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
   hInst = hInstance; // Сохранить дескриптор экземпляра в глобальной переменной
 
   HWND hWnd = CreateWindowW(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
      CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, nullptr, nullptr, hInstance, nullptr);
 
   if (!hWnd)
   {
      return FALSE;
   }
 
   ShowWindow(hWnd, nCmdShow);
   UpdateWindow(hWnd);
 
   return TRUE;
}
 
int mov_x = 0, mov_y = 0;
bool left_button = false, right_button = false;
int xlPos = 0, ylPos = 0;
int xmPos = 0, ymPos = 0;
int rot_x = 0, rot_y = 0;
int size = 0;
 
 
 
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
    case WM_LBUTTONDOWN:
        left_button = true;
        xlPos = LOWORD(lParam);
        ylPos = HIWORD(lParam);
        size = 0;
        break;
    case WM_LBUTTONUP:
        left_button = false;
        break;
    case WM_MOUSEMOVE:
        if (left_button)
        {
            rot_x += LOWORD(lParam) - xlPos;
            xlPos = LOWORD(lParam);
            rot_y += HIWORD(lParam) - ylPos;
            ylPos = HIWORD(lParam);
            RedrawWindow(hWnd, NULL, NULL, RDW_INVALIDATE);
        }
        if (right_button)
        {
            mov_x += LOWORD(lParam) - xmPos;
            xmPos = LOWORD(lParam);
            mov_y += HIWORD(lParam) - ymPos;
            ymPos = HIWORD(lParam);
            RedrawWindow(hWnd, NULL, NULL, RDW_INVALIDATE);
        }
        break;
    case WM_RBUTTONDOWN:
        right_button = true;
        xmPos = LOWORD(lParam);
        ymPos = HIWORD(lParam);
        size = 0;
        break;
    case WM_RBUTTONUP:
        right_button = false;
        break;
    case WM_MOUSEWHEEL:
        size = int(HIWORD(wParam));
        if (size > 32768) size = size - 65536;
        RedrawWindow(hWnd, NULL, NULL, RDW_INVALIDATE);
        break;
    case WM_COMMAND:
        {
            int wmId = LOWORD(wParam);
            // Разобрать выбор в меню:
            switch (wmId)
            {
            case IDM_ABOUT:
                DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
                break;
            case IDM_EXIT:
                DestroyWindow(hWnd);
                break;
            default:
                return DefWindowProc(hWnd, message, wParam, lParam);
            }
        }
        break;
    case WM_PAINT:
        {
            //PAINTSTRUCT ps;
            //HDC hdc = BeginPaint(hWnd, &ps);
            PaintStudyExample(hWnd);
            //EndPaint(hWnd, &ps);
        }
        break;
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
    }
    return 0;
}
 
// Обработчик сообщений для окна "О программе".
INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    UNREFERENCED_PARAMETER(lParam);
    switch (message)
    {
    case WM_INITDIALOG:
        return (INT_PTR)TRUE;
 
    case WM_COMMAND:
        if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
        {
            EndDialog(hDlg, LOWORD(wParam));
            return (INT_PTR)TRUE;
        }
        break;
    }
    return (INT_PTR)FALSE;
}
 
 
typedef struct {float x, y, z;} Point3D;
typedef struct { int a, b; } Edge;
 
const int AmountVertices = 8;
 
 
Point3D fig_v[AmountVertices] = { { 0,0,0 },{ 1,0,0 },{ 1,1,0 },{ 0,1,0 },{ 0,0,1 },{ 1,0,1 },{ 1,1,1 },{ 0,1,1 } };
 
Point3D fig_t[AmountVertices], fig_p[AmountVertices];
const int AmountEdges = 12;
Edge fig_e[AmountEdges] = { { 0,1 },{ 1,2 },{ 2,3 },{ 3,0 },{ 0,4 },{1,5},{2,6},{3,7}, { 4,5 },{ 5,6 },{ 6,7 },{ 7,4 } };
float FigureSize = 100.0;
Point3D FigurePlace = { 0, 0, 0 };
float FigureRotateAlpha = 0.5;
float FigureRotateBeta = 0.5;
float ProjectionAlpha = 0.0;
float ProjectionBeta = 0.0;
POINT ProjectionCenter = { 400,300 };
 
void TransformFigure(int n, Point3D* figure, Point3D* t_figure)
{
    float size = FigureSize;
    Point3D move = FigurePlace;
    float alp = FigureRotateAlpha, beta = FigureRotateBeta;
    for (int i = 0; i<n; i++)
    {
        t_figure[i].x = size * (figure[i].x * cos(alp) - figure[i].y * sin(alp)) + move.x;
        t_figure[i].y = size * (figure[i].x * sin(alp) * cos(beta) + figure[i].y * cos(alp)* cos(beta)- figure[i].z * sin(beta)) + move.y;
        t_figure[i].z = size * (figure[i].x * sin(alp) * sin(beta)+ figure[i].y * cos(alp)* sin(beta)+ figure[i].z * cos(beta)) + move.z;
    }
}
 
void AxonomProj(int n, Point3D* figure, Point3D* proj)
{
    float alp = ProjectionAlpha;
    float beta = ProjectionBeta;
    for (int i = 0; i<n; i++)
    {
        proj[i].x = figure[i].x * cos(alp) - figure[i].y * sin(alp);
        proj[i].y = figure[i].x * sin(alp) * cos(beta) + figure[i].y * cos(alp)* cos(beta) - figure[i].z * sin(beta);
        proj[i].z = figure[i].x * sin(alp) * sin(beta) + figure[i].y * cos(alp)* sin(beta) + figure[i].z * cos(beta);
    }
}
 
void PerspectiveProj(int n, Point3D* figure, Point3D* proj)
{
    //перспективное преобразование
}
 
void DrawFigure(HDC hdc, int n, Point3D* proj, int m, Edge* lines)
{
    int x1,y1, x2,y2;
    Point3D p1,p2;
    for (int j = 0; j<m; j++)
    {
        p1 = proj[lines[j].a];
        p2 = proj[lines[j].b];
        x1 = p1.x + ProjectionCenter.x;
        y1 = p1.y + ProjectionCenter.y;
        MoveToEx(hdc, x1, y1, NULL);
        x2 = p2.x + ProjectionCenter.x;
        y2 = p2.y + ProjectionCenter.y;
        LineTo(hdc, x2, y2);
    } 
}
 
void PaintStudyExample(HWND hWnd)
{
    HDC hdc;
    PAINTSTRUCT ps;
    RECT rc;
    int d, mx, my, nx, ny, nc;
    float phi, nr;
    POINT draw[AmountVertices];
    POINT temp;
 
    hdc = BeginPaint(hWnd, &ps);
    if (hdc == NULL) return;
    GetClientRect(hWnd, &rc);
    Rectangle(hdc, rc.left, rc.top, rc.right, rc.bottom);
    int cx = rc.right - rc.left;
    int cy = rc.bottom - rc.top;
    if (cx>cy) { d = cy / 2; } else {d=cx/2;};
    mx = cx / 2;
    my = cy / 2;
 
    FigureRotateAlpha = float(rot_x) / 100;
    FigureRotateBeta = float(rot_y) / 100.0;
    FigurePlace.x = float(mov_x);
    FigurePlace.y = float(mov_y);
    FigureSize += float(size) / 12;
    TransformFigure(AmountVertices, fig_v, fig_t);
    AxonomProj(AmountVertices, fig_t, fig_p);
    PerspectiveProj(AmountVertices, fig_t, fig_p);
    DrawFigure(hdc, AmountVertices, fig_p, AmountEdges, fig_e);
 
    EndPaint(hWnd, &ps);
}