#include <d3dx9.h>
#include "DXUtil.h"
#include <iostream>

LPDIRECT3D9         g_pD3D = NULL;
LPDIRECT3DDEVICE9   g_pd3dDevice = NULL;
LPDIRECT3DVERTEXBUFFER9 g_pVB = NULL;

struct Vertex
{
     float x, y, z;
     float color;
};

#define VERTEXFVF (D3DFVF_XYZ | D3DFVF_DIFFUSE)

void InitBuffer()
{
     D3DXMATRIX matProjection;
     BYTE *Ptr;

     Vertex Verts[4] = {
         {-50.0f,  50.0f, 0.0f, 0xffffffff},
         { 50.0f,  50.0f, 0.0f, 0xffffffff},
         {-50.0f, -50.0f, 0.0f, 0xffffffff},
         { 50.0f, -50.0f, 0.0f, 0xffffffff}
     };

     D3DXMatrixOrthoLH(&matProjection, 800, 600, 0, 10);
     g_pd3dDevice->SetTransform(D3DTS_PROJECTION, &matProjection);

     g_pd3dDevice->SetRenderState(D3DRS_LIGHTING, FALSE);
     g_pd3dDevice->SetRenderState(D3DRS_ZENABLE, TRUE);

     g_pd3dDevice->CreateVertexBuffer(sizeof(Vertex)*4, 0, VERTEXFVF, D3DPOOL_DEFAULT, &g_pVB, NULL);
     g_pVB->Lock(0,0, (void**)&Ptr, 0);
     memcpy(Ptr, Verts, sizeof(Verts));
     g_pVB->Unlock();
}

HRESULT InitD3D( HWND hWnd, bool vsync)
{
     if(NULL == (g_pD3D = Direct3DCreate9(D3D_SDK_VERSION)))
         return E_FAIL;

     D3DPRESENT_PARAMETERS d3dpp;
     ZeroMemory(&d3dpp, sizeof(d3dpp));
     d3dpp.Windowed         = TRUE;
     d3dpp.SwapEffect       = D3DSWAPEFFECT_DISCARD;
     d3dpp.BackBufferFormat = D3DFMT_UNKNOWN;
     d3dpp.EnableAutoDepthStencil = TRUE;
     d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
     d3dpp.BackBufferWidth  = GetSystemMetrics(SM_CXSCREEN);
     d3dpp.BackBufferHeight = GetSystemMetrics(SM_CYSCREEN);
     d3dpp.BackBufferCount = 3;

     d3dpp.PresentationInterval = !vsync ? D3DPRESENT_INTERVAL_IMMEDIATE : D3DPRESENT_INTERVAL_ONE;

     if(FAILED(g_pD3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd,
                    D3DCREATE_HARDWARE_VERTEXPROCESSING,
                    &d3dpp, &g_pd3dDevice)))
     {
         return E_FAIL;
     }

     g_pd3dDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW);
     g_pd3dDevice->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE);

     return S_OK;
}

VOID Cleanup()
{
     if( g_pVB != NULL )
         g_pVB->Release();

     if( g_pd3dDevice != NULL )
         g_pd3dDevice->Release();

     if( g_pD3D != NULL )
         g_pD3D->Release();
}

float x, y;

int GetKeyUpState(DWORD button)
{
     return ((GetAsyncKeyState(button) & 0x8000) ? 0 : 1);
}

int GetKeyDownState(DWORD button)
{
     return ((GetAsyncKeyState(button) & 0x8000) ? 1 : 0);
}

int GetFPS()
{
     DWORD dwCurrentTime;
     DWORD dwElapsedTime;

     static DWORD dwLastUpdateTime;
     static DWORD dwFrames;
     static int fps;

     dwFrames++;
     dwCurrentTime = GetTickCount();
     dwElapsedTime = dwCurrentTime - dwLastUpdateTime;

     if(dwElapsedTime >= 1000)
     {
         fps = dwFrames * 1000.0 / dwElapsedTime;
         dwFrames = 0;
         dwLastUpdateTime = dwCurrentTime;
     }

     return fps;
}

int speed = 200;

VOID Render()
{
     FLOAT fElapsedAppTime = DXUtil_Timer(TIMER_GETELAPSEDTIME);
     FLOAT fps = GetFPS();

     std::cout << "DT: " << fElapsedAppTime << std::endl;
     std::cout << "FPS: " << fps << std::endl;

     D3DXMATRIX matWorld;

     if(GetKeyDownState(VK_LEFT)) x -= speed * fElapsedAppTime;
     if(GetKeyDownState(VK_RIGHT)) x += speed * fElapsedAppTime;

     D3DXMatrixTranslation(&matWorld, x, y, 0);
     g_pd3dDevice->SetTransform(D3DTS_WORLD, &matWorld);

     if( NULL == g_pd3dDevice )
         return;

     g_pd3dDevice->Clear( 0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB( 200, 200, 200 ), 1.0f, 0 );

     g_pd3dDevice->BeginScene();

     g_pd3dDevice->SetStreamSource(0, g_pVB, 0, sizeof(Vertex));
     g_pd3dDevice->SetFVF(VERTEXFVF);

     g_pd3dDevice->DrawPrimitive(D3DPT_TRIANGLESTRIP, 0, 2);

     g_pd3dDevice->EndScene();

     g_pd3dDevice->Present( NULL, NULL, NULL, NULL );
}

LRESULT WINAPI MsgProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam )
{
     switch( msg )
     {
         case WM_DESTROY:
             PostQuitMessage( 0 );
             return 0;
     }

     return DefWindowProc( hWnd, msg, wParam, lParam );
}

INT WINAPI WinMain( HINSTANCE hInst, HINSTANCE, LPSTR, INT )
{
     WNDCLASSEX wc =
     {
         sizeof( WNDCLASSEX ), CS_CLASSDC, MsgProc, 0L, 0L,
         GetModuleHandle( NULL ), NULL, NULL, NULL, NULL,
         "D3D Test", NULL
     };
     RegisterClassEx( &wc );

     HWND hWnd = CreateWindow( "D3D Test", "Test",
                    WS_OVERLAPPEDWINDOW, 100, 100, 800, 600,
                    NULL, NULL, wc.hInstance, NULL );

     if( SUCCEEDED(InitD3D(hWnd, false)))
     {
         InitBuffer();
         ShowWindow( hWnd, SW_SHOWDEFAULT );
         UpdateWindow( hWnd );

         MSG msg;
         while(msg.message != WM_QUIT)
         {
             if (PeekMessage(&msg,NULL,0,0,PM_REMOVE))
             {
                 TranslateMessage(&msg);
                 DispatchMessage(&msg);
             }
             else Render();
         }
     }

     Cleanup();

     UnregisterClass( "D3D Test", wc.hInstance );
     return 0;
}

LRESULT CALLBACK WinProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
      PAINTSTRUCT ps;
      RECT rect;

      static int x=0, y=0;

      switch (msg)
      {
          case WM_CREATE:
              SetTimer(hwnd, TIMER_VK, 100,0);
          break;
          case WM_KEYDOWN:
              if(wParam==VK_DOWN)y=y+5;
              if(wParam==VK_UP)y=y-5;
              if(wParam==VK_LEFT)x=x-5;
              if(wParam==VK_RIGHT)x=x+5;
          break;
          case WM_TIMER:
          switch (wParam)
          {
          case TIMER_VK:
              GetClientRect(hwnd,&rect);
              InvalidateRect(hwnd, &rect, TRUE);
          break;
          }
          break;
          case WM_PAINT:
              hdc=BeginPaint(hwnd, &ps);
              Ellipse(hdc, x+20,y+20,x+10,y+10);
              Ellipse(hdc, 250,250,230,230);
              EndPaint(hwnd, &ps);
          break;
          case WM_DESTROY:
              PostQuitMessage(0);
              KillTimer(hwnd,TIMER_VK);
      }
      return DefWindowProc(hwnd,msg,wParam,lParam);
}

#pragma comment(lib, "d3d9.lib")
#pragma comment(lib, "d3dx9.lib")
#include <windows.h>
#include "d3d9.h"
#include <d3dx9.h>

#include <mmsystem.h>//заголовочный файл для работы с системными функциями

//***********************************************************
LPDIRECT3D9 g_pD3D = NULL; //объявление главного объекта
LPDIRECT3DDEVICE9 pDirect3DDevice; //объявление девайса
LPDIRECT3DVERTEXBUFFER9 pVertBuff = NULL; //объявление вертекс буффера

VOID Matrix();

struct CUSTOMVERTEX//структура определяющая формат вершин
{
     float x, y, z; //координаты вершины
     DWORD color; //цвет вершыны
};

#define D3DFVF_CUSTOMVERTEX (D3DFVF_XYZ | D3DFVF_DIFFUSE)//формат содержания вершин

// ИНИЦИАЛИЗАЦИЯ Direct3D
HRESULT InitD3D(HWND hwnd)
{
     if(NULL == (g_pD3D = Direct3DCreate9(D3D_SDK_VERSION))) //создаётся основной указатель на интерфейс IDirect3D9
     return E_FAIL;

     D3DDISPLAYMODE Disp; //структура для соответствия текущих установок дисплея
     if(FAILED(g_pD3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &Disp))) //получаем текущий формат дисплея
         return E_FAIL;

     //параметры показа
     D3DPRESENT_PARAMETERS d3dpp; //обект параметров представления Direct3DParametr
     ZeroMemory(&d3dpp, sizeof(d3dpp)); //очищает создаваемую структуру от мусора
     d3dpp.Windowed = true; //видеорежим используемый нашим приложением
     d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD; //параметр опредиления размеров буфера
     d3dpp.BackBufferFormat = Disp.Format; //формат поверхности заднего буфера

     //создание девайса
     if(FAILED(g_pD3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hwnd,
                    D3DCREATE_HARDWARE_VERTEXPROCESSING, &d3dpp, &pDirect3DDevice)))//обект интерфейса устройства
         return E_FAIL;

     pDirect3DDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
     pDirect3DDevice->SetRenderState(D3DRS_LIGHTING, FALSE);

return S_OK;
}

///////////////////////////////////////////////////////////////////////////////////////////////////
void RenderD3D()
{
     if(pDirect3DDevice==NULL)
         return;

     pDirect3DDevice->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(100,100,100), 1.0f, 0);
     pDirect3DDevice->BeginScene(); //начало сцены
     Matrix();
     //здесь происходит отрисовка сцены
     pDirect3DDevice->SetStreamSource(0, pVertBuff, 0, sizeof(CUSTOMVERTEX));
     //Установка формата вершин
     pDirect3DDevice->SetFVF(D3DFVF_CUSTOMVERTEX);
     pDirect3DDevice->DrawPrimitive(D3DPT_TRIANGLELIST, 0, 2);

     pDirect3DDevice->EndScene(); //конец сцены

     pDirect3DDevice->Present(NULL, NULL, NULL, NULL); //показать все
}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////

HRESULT InitVertBuff()
{
     //проектируем вертексный буфер
     CUSTOMVERTEX Vertex[] =
     {
         {1.0f, -1.0f, 0.0f,  0x00000ff}, //A
         {-1.0f, -1.0f, 0.0f, 0xff000ff}, //B
         {-1.0f, 1.0f, 0.0f,  0x00000ff}, //C
         //X Y Z
         {-1.0f, 1.0f, 0.0f, 0x00000ff}, //C
         {1.0f, 1.0f, 0.0f,  0xff000ff}, //D
         {1.0f, -1.0f, 0.0f, 0x00000ff}, //A
     };

     // | - кол-во вершин прямо пропорционально числу перед sizeof
     if(FAILED(pDirect3DDevice->CreateVertexBuffer(6*sizeof(CUSTOMVERTEX), 0,
                    D3DFVF_CUSTOMVERTEX, D3DPOOL_DEFAULT, &pVertBuff, NULL)))
         return E_FAIL;

     void *pVB; //временный указатель на указатель вертекс буфера

     if(FAILED(pVertBuff->Lock(0, sizeof(Vertex), (void**)&pVB, 0))) //Блоктровка буфера
         return E_FAIL;

     memcpy(pVB, Vertex, sizeof(Vertex)); //копирование данных

     pVertBuff->Unlock(); //Разблокировка буфера

return S_OK;
}

/////////////////////////////////////////////////
VOID Matrix()
{
     D3DXMATRIX MatrixWorld;
     D3DXMATRIX MatrixView;
     D3DXMATRIX MatrixProjection;

     UINT Time = timeGetTime() % 5000;
     FLOAT Angle = Time*(2.0*D3DX_PI)/5000.0f;

     D3DXMatrixRotationY(&MatrixWorld, Angle);
     pDirect3DDevice->SetTransform(D3DTS_WORLD, &MatrixWorld);

     D3DXMatrixLookAtLH(&MatrixView,&D3DXVECTOR3(0.0f,0.0f,-8.0f), &D3DXVECTOR3(0.0f,0.0f,0.0f), &D3DXVECTOR3(0.0f,1.0f,0.0f));
     pDirect3DDevice->SetTransform( D3DTS_VIEW, &MatrixView );

     D3DXMatrixPerspectiveFovLH(&MatrixProjection, D3DX_PI/4, 1.0f, 1.0f, 100.0f);

     pDirect3DDevice->SetTransform(D3DTS_PROJECTION,&MatrixProjection);
}

#include "render.h"

LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)//здесь происходит обработка сообщений
{
     switch (msg)
     {
         case WM_DESTROY:
         {
             PostQuitMessage(0);
             return 0;
         }
     }
     return DefWindowProc(hwnd, msg, wparam, lparam);
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)//ГЛАВНАЯ ФУНКЦИЯ
{
     WNDCLASSEX wc; //создание класса окна
     HWND hwnd; //создаём дискриптор окна
     MSG msg; //идентификатор сообщения

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

     wc.cbSize = sizeof(WNDCLASSEX); // Размер всей структуры
     wc.style = CS_VREDRAW | CS_HREDRAW | CS_OWNDC | CS_DBLCLKS; //Задание стиля окн
     wc.lpfnWndProc = WndProc; //Наша функция обработки событий
     wc.cbClsExtra = 0;
     wc.cbWndExtra = 0;
     wc.hInstance = hInstance; //Экземпляр приложения
     wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
     wc.hCursor = LoadCursor(NULL, IDC_ARROW);
     wc.hbrBackground = (HBRUSH)GetStockObject(GRAY_BRUSH); //цвет фона
     wc.lpszMenuName = NULL; //имя меню
     wc.lpszClassName = "TEST_WIN32"; //Имя класса окна
     wc.hIconSm = LoadIcon(NULL, IDI_APPLICATION);

     //Регистрация созданного класса
     RegisterClassEx(&wc); // Иконка в заголовке окна

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

     //Создание окна
     if(!(hwnd = CreateWindowEx(NULL, "TEST_WIN32", "База для DirectX", WS_OVERLAPPEDWINDOW | WS_VISIBLE,
                    CW_USEDEFAULT, CW_USEDEFAULT, 800, 600, NULL, NULL, hInstance, NULL)))
                    return 0;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     if(SUCCEEDED(InitD3D(hwnd)))
     {
         if(SUCCEEDED(InitVertBuff()))
         {
         ShowWindow(hwnd, nCmdShow); // Вывод окна
         UpdateWindow(hwnd); // Апдейт окна
         ZeroMemory(&msg, sizeof(msg));

             while(msg.message != WM_QUIT)
             {
                 if(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
                 {
                 TranslateMessage(&msg); // преобразование клав. ввода
                 DispatchMessage(&msg); // обработка и пересылка сообщ. в WinProc
                 }
                 else
                 RenderD3D(); //РЕНДЕР
             }
         }
     }
     return 0;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////