Матричные преобразования!

// Draw.cpp : Defines the entry point for the application.
//
 
#include "stdafx.h"
#include "Draw.h"
#include <d3d9.h>
#include <strsafe.h>
 
#pragma comment(lib,"d3d9.lib")
#define MAX_LOADSTRING 100
#define D3DFVF_VERTEX (D3DFVF_XYZRHW|D3DFVF_DIFFUSE)
 
// Global Variables:
HINSTANCE hInst;                                // current instance
TCHAR szTitle[MAX_LOADSTRING];                  // The title bar text
TCHAR szWindowClass[MAX_LOADSTRING];            // the main window class name
 
LPDIRECT3D9                 g_pD3D = NULL;                      //используется для создания Direct устройства;
LPDIRECT3DDEVICE9           g_pd3dDevice = NULL;                //устройство рендеринга
LPDIRECT3DVERTEXBUFFER9     g_VerBuf = NULL;                    //вертикс буфер для вершин
 
struct VERTEX
    {
        FLOAT x,y,z,rhw;
        DWORD color;
    };
 
// Forward declarations of functions included in this code module:
ATOM                MyRegisterClass(HINSTANCE hInstance);
BOOL                InitInstance(HINSTANCE, int);
LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK    About(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK    EnterDlg(HWND, UINT, WPARAM, LPARAM);
HRESULT             InitD3D(HWND hwnd);
VOID                CleanUp();
VOID                Render();
HRESULT             InitVertexBuffer();
int             SetTransformMatrix(int A[4][2],int x, int y);
 
void DrawFigure(HDC,int x, int y, float scale);
 
int vertexs[4][2] = 
    {
        {300, 200},
        {500, 200},
        {500, 400},
        {300, 400}
    };
 
 
static int x = 300, y = 200;
float scale = 1.0; // координаты левой верхней точки фигуры по умолчанию и масштаб
 
int APIENTRY _tWinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPTSTR    lpCmdLine,
                     int       nCmdShow)
{
    UNREFERENCED_PARAMETER(hPrevInstance);
    UNREFERENCED_PARAMETER(lpCmdLine);
 
    // TODO: Place code here.
    MSG msg;
    HACCEL hAccelTable;
 
    // Initialize global strings
    LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
    LoadString(hInstance, IDC_DRAW, szWindowClass, MAX_LOADSTRING);
    MyRegisterClass(hInstance);
 
    // Perform application initialization:
    if (!InitInstance (hInstance, nCmdShow))
    {
        return FALSE;
    }
 
    hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_DRAW));
    
    
    // Main message loop:
    while (GetMessage(&msg, NULL, 0, 0))
    {
        if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }
 
    return (int) msg.wParam;
}
 
 
 
//
//  FUNCTION: MyRegisterClass()
//
//  PURPOSE: Registers the window class.
//
//  COMMENTS:
//
//    This function and its usage are only necessary if you want this code
//    to be compatible with Win32 systems prior to the 'RegisterClassEx'
//    function that was added to Windows 95. It is important to call this function
//    so that the application will get 'well formed' small icons associated
//    with it.
//
ATOM MyRegisterClass(HINSTANCE hInstance)
{
    WNDCLASSEX 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_DRAW));
    wcex.hCursor        = LoadCursor(NULL, IDC_ARROW);
    wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);
    wcex.lpszMenuName   = MAKEINTRESOURCE(IDC_DRAW);
    wcex.lpszClassName  = szWindowClass;
    wcex.hIconSm        = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));
 
    return RegisterClassEx(&wcex);
}
 
//
//   FUNCTION: InitInstance(HINSTANCE, int)
//
//   PURPOSE: Saves instance handle and creates main window
//
//   COMMENTS:
//
//        In this function, we save the instance handle in a global variable and
//        create and display the main program window.
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
   HWND hWnd;
 
   hInst = hInstance; // Store instance handle in our global variable
 
   hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
      CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);
    
   //инициализация D3D устройства
    
   if (!hWnd)
   {
      return FALSE;
   }
    
   if (SUCCEEDED(InitD3D(hWnd)))
    {   
        if (SUCCEEDED(InitVertexBuffer()))
        {
            ShowWindow(hWnd, nCmdShow);
            UpdateWindow(hWnd);
        }
   }
 
   return TRUE;
}
 
//
//  FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)
//
//  PURPOSE:  Processes messages for the main window.
//
//  WM_COMMAND  - process the application menu
//  WM_PAINT    - Paint the main window
//  WM_DESTROY  - post a quit message and return
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    int wmId, wmEvent;
    PAINTSTRUCT ps;
    HDC hdc;
    
 
    switch (message)
    {
    case WM_COMMAND:
        wmId    = LOWORD(wParam);
        wmEvent = HIWORD(wParam);
        // Parse the menu selections:
        switch (wmId)
        {
        case IDM_ABOUT:
            DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
            break;
        case IDM_EXIT:
            DestroyWindow(hWnd);
            break;
        case ID_ENTERCOORDINATES:
            DialogBox(hInst, MAKEINTRESOURCE(IDD_DIALOG1), hWnd, EnterDlg);
            InvalidateRect(hWnd, 0, true);
            break;  
        default:
            return DefWindowProc(hWnd, message, wParam, lParam);
        }
        break;
    case WM_PAINT:
        Render();
    //  ValidateRect( hWnd, NULL );
        hdc = BeginPaint(hWnd, &ps);
    //  Rectangle(hdc,x1,100,200,200);
    //  DrawFigure(hdc,x,y, scale);
        // TODO: Add any drawing code here...
        EndPaint(hWnd, &ps);
        break;
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
    }
    return 0;
}
 
// Message handler for about box.
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;
}
 
INT_PTR CALLBACK EnterDlg(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)
        {   
            x = (int) GetDlgItemInt(hDlg,IDC_EDIT1, NULL, true);
            y = (int) GetDlgItemInt(hDlg,IDC_EDIT2, NULL, true);
            scale = (float) GetDlgItemInt(hDlg,IDC_EDIT3, NULL, true);
//          SetTransformMatrix(vertexs[4][2],x,y);
            //SetDlgItemInt(hDlg, IDC_EDIT1, x1, true);
            EndDialog(hDlg, LOWORD(wParam));
            return (INT_PTR)TRUE;
        }
        break;
    }
    return (INT_PTR)FALSE;
}
 
 
void DrawFigure(HDC hDC, int x, int y, float scale)
{
    HPEN hPen = CreatePen(PS_SOLID,2,RGB(255,0,0));
    HPEN hOldPen = (HPEN)SelectObject(hDC, hPen);
    
    MoveToEx(hDC, vertexs[3][2], vertexs[3][1], 0);
    for (int i = 0; i<4;i++)
        {   
            for (int j = 0; j<1;j++)
                LineTo(hDC,vertexs[i][j],vertexs[i][j+1]);
        }
/*  MoveToEx(hDC, x*scale, y*scale, 0);
    LineTo(hDC,x+200*scale,y*scale);
    LineTo(hDC,x+200*scale,y+200*scale);
    LineTo(hDC,x*scale,y+200*scale);
    LineTo(hDC,x*scale,y*scale);
    MoveToEx(hDC, x*scale, y+200*scale, 0);
    LineTo(hDC,x+70*scale,y+100*scale);
    LineTo(hDC,x+100*scale,y*scale);
    LineTo(hDC,x+130*scale,y+100*scale);
    LineTo(hDC,x+200*scale,y+200*scale);
    LineTo(hDC,x+100*scale,y+150*scale);
    LineTo(hDC,x*scale,y+200*scale);
*/  SelectObject(hDC,hOldPen);
    DeleteObject(hPen);
}
 
HRESULT InitD3D(HWND hwnd)
{
    if (NULL == (g_pD3D = Direct3DCreate9(D3D_SDK_VERSION)))
        return E_FAIL;
 
    D3DPRESENT_PARAMETERS d3dprm;
    ZeroMemory(&d3dprm, sizeof(d3dprm));
    d3dprm.Windowed = TRUE;
    d3dprm.SwapEffect = D3DSWAPEFFECT_DISCARD;
    d3dprm.BackBufferFormat = D3DFMT_UNKNOWN;
    
    if (FAILED(g_pD3D->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hwnd, 
                                     D3DCREATE_SOFTWARE_VERTEXPROCESSING,
                                     &d3dprm, &g_pd3dDevice)))
    {
        return E_FAIL;
    }
 
    return S_OK;    
}
 
VOID CleanUp()
{
    if (g_pd3dDevice != NULL)
        {g_pd3dDevice->Release();}
    if (g_pD3D != NULL)
        {g_pD3D->Release();}
}
 
VOID Render()
{
    if (g_pd3dDevice == NULL)
            return;
    g_pd3dDevice->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0,255,255), 1.0f, 0);
 
    if (SUCCEEDED (g_pd3dDevice->BeginScene()) )
    {   
        
        //устнанавливаем источник
        g_pd3dDevice->SetStreamSource(0,g_VerBuf,0, sizeof(VERTEX));
        
        //выбираем формат вертикса
        g_pd3dDevice->SetFVF(D3DFVF_VERTEX);
        
        //рисуем...
        g_pd3dDevice->DrawPrimitive(D3DPT_TRIANGLELIST,0,1); 
 
        g_pd3dDevice->EndScene();
    }
 
    g_pd3dDevice->Present(NULL,NULL,NULL,NULL); //выводим содержимое бэкбуфера на экран
}
 
HRESULT InitVertexBuffer()
{   
    // инициализируем точки нашей фигуры
 
    VERTEX vertexs[] = 
    {
        {300.0f, 200.0f,0.0f, 1.0f, 0xffff0000},
        {500.0f, 200.0f,0.0f, 1.0f, 0xffff00ff},
        {500.0f, 400.0f,0.0f, 1.0f, 0xff00ff00},
        {300.0f, 400.0f,0.0f, 1.0f, 0xffff0000}
    };
 
    //создаем вертикс буфер
 
    if(FAILED(g_pd3dDevice->CreateVertexBuffer(3*sizeof(VERTEX),0,D3DFVF_VERTEX, D3DPOOL_DEFAULT,&g_VerBuf, NULL)))
 
        return E_FAIL;
 
    //лочим буфер, заполняем буфер и разлочиваем его
    
    VOID *pVertexs;
    if (FAILED(g_VerBuf->Lock(0,sizeof(vertexs),(void**)&pVertexs,0)))
 
        return E_FAIL;
    memcpy(pVertexs, vertexs, sizeof(vertexs));
    g_VerBuf->Unlock();
    
    return S_OK;
}
 
int     SetTransformMatrix(int A[4][2],int Sx, int Sy)
{    
    int ResMtrix[4][2]; 
    int S[2][2] = 
                        {
                            {Sx, 0},
                            {0, Sy}
                        };
 
    for (int i = 0; i<4; i++)
        for (int j = 0; j<2; j++)
            for (int n = 0; n<2; n++)
            {
                ResMtrix[i][n] += A[i][j]*S[j][n];
            }
 
    return ResMtrix[4][2];
}