Не окрашиваются грани куба

// Directx.cpp: определяет точку входа для приложения.
//
 
#include "stdafx.h"
#include "Directx.h"
#include <Windows.h>
#pragma comment( lib, "d3dx9.lib" )
#include "dxfunc.h"
#include "d3d9.h"
#include "d3dx9.h"
#define MAX_LOADSTRING 100
 
// Глобальные переменные:
HINSTANCE hInst;                                // текущий экземпляр
TCHAR szTitle[MAX_LOADSTRING];                  // Текст строки заголовка
TCHAR szWindowClass[MAX_LOADSTRING];            // имя класса главного окна
 
//переменные DirectX
IDirect3D9 *pD3D = NULL;
IDirect3DDevice9 *pD3DDevice = NULL;
IDirect3DVertexBuffer9 * vBuffer01;
IDirect3DVertexBuffer9 * vBuffer;
IDirect3DIndexBuffer9 * iBuffer01;
IDirect3DIndexBuffer9 * iBuffer;
int iWidth = 800;
int iHeight = 600;
float ViewAngle = 0;
const int iVertsNum = 24;
const int iVertsPlaneNum = 4;
const int iIdxNum = 36;
const int iPointsNum =12;
 
 
 
struct sVertex {
    float х, у, z; 
    DWORD color;
} ;
 
// Отправить объявления функций, включенных в этот модуль кода:
ATOM                MyRegisterClass(HINSTANCE hInstance);
BOOL                InitInstance(HINSTANCE, int);
LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK    About(HWND, UINT, WPARAM, LPARAM);
 
// Функция инициализации Direct3D
HRESULT DX3DInit(IDirect3D9 **ppiD3D9,IDirect3DDevice9 **ppiD3DDevice9,HWND hWnd,DWORD iWidth,DWORD iHeight, BOOL bFullScreen)
{
    // Инициализация
    if((*ppiD3D9 = Direct3DCreate9(D3D_SDK_VERSION)) == NULL)
        return E_FAIL;
    // Заполняем основные параметры
    D3DPRESENT_PARAMETERS d3dpp;
    ZeroMemory(&d3dpp, sizeof(d3dpp));
    d3dpp.BackBufferWidth = iWidth;
    d3dpp.BackBufferHeight = iHeight;
    // Запрос на отображение в полноэкранном режиме
    int iRes;
    if (!bFullScreen)
        iRes=MessageBox(hWnd, L"Use fullscreen mode?",
        L"Screen", MB_YESNO | MB_ICONQUESTION);
    else
        iRes = IDYES;
    if(iRes == IDYES)
    {
        //////////////////////////////////////////////////////////
        // Полноэкранный режим
        //////////////////////////////////////////////////////////
        // Установка параметров полноэкранного режима
        d3dpp.BackBufferFormat = D3DFMT_R5G6B5;
        d3dpp.SwapEffect = D3DSWAPEFFECT_FLIP;
        d3dpp.Windowed = FALSE;
        d3dpp.FullScreen_RefreshRateInHz = D3DPRESENT_RATE_DEFAULT;
        d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_DEFAULT;
 
        
    }
    else
    {
        //////////////////////////////////////////////////////////
        // Оконный режим
        //////////////////////////////////////////////////////////
        RECT wndRect;
        RECT clientRect;
        GetWindowRect(hWnd, &wndRect);
        GetClientRect(hWnd, &clientRect);
        int iWinWidth = iWidth + (wndRect.right-wndRect.left) -
            (clientRect.right-clientRect.left);
        int iWinHeight = iHeight + (wndRect.bottom-wndRect.top) -
            (clientRect.bottom-clientRect.top);
        MoveWindow(hWnd, wndRect.left, wndRect.top,
            iWinWidth, iWinHeight, TRUE);
        // Получить формат пикселя
        D3DDISPLAYMODE d3ddm;
        (*ppiD3D9)->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &d3ddm);
        // Установка параметров
        d3dpp.BackBufferFormat = d3ddm.Format;
        d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
        d3dpp.Windowed = TRUE;  
    }
    // Создать 3D устройство
    DWORD Flags= D3DCREATE_MIXED_VERTEXPROCESSING |
        D3DCREATE_MULTITHREADED;
    HRESULT hRes;
    if(FAILED(hRes = (*ppiD3D9)->CreateDevice(
        D3DADAPTER_DEFAULT,
        D3DDEVTYPE_HAL, hWnd, Flags,
        &d3dpp, ppiD3DDevice9)))
        return hRes;
    // Установить перспективу
    float Aspect =(float)d3dpp.BackBufferWidth / (float)d3dpp.BackBufferHeight;
    D3DXMATRIX matProjection;
    D3DXMatrixPerspectiveFovLH(&matProjection, D3DX_PI/4.0f,
        Aspect, 0.1f, 1000.0f);
    (*ppiD3DDevice9)->SetTransform(D3DTS_PROJECTION, &matProjection);
    
    return S_OK;
}
void CreateQuad()
{
    HRESULT hRes;
const sVertex svVortexList[] = {
    // Грань 1
    {-0.5f, -0.5f, -0.5f,  D3DCOLOR_XRGB(255,  0, 0)}, //A1
    {-0.5f, 0.5f, -0.5f,   D3DCOLOR_XRGB(255,  0, 0)}, //B1
    {0.5f, -0.5f, -0.5f,   D3DCOLOR_XRGB(255,  0, 0)}, //C1
    {0.5f, 0.5f, -0.5f,    D3DCOLOR_XRGB(255,  0, 0)}, //D1
    
    // Грань 2
    {0.5f, -0.5f, -0.5f,  D3DCOLOR_XRGB(0,  255,  0)}, //A2
    {0.5f, 0.5f, -0.5f,   D3DCOLOR_XRGB(0,  255,  0)}, //B2
    {0.5f, -0.5f, 0.5f,   D3DCOLOR_XRGB(0,  255,  0)}, //C2
    {0.5f, 0.5f, 0.5f,    D3DCOLOR_XRGB(0,  255,  0)}, //D2
 
    // Грань 3
    {0.5f, -0.5f, 0.5f,   D3DCOLOR_XRGB(0,  0,   255)}, //A3
    {0.5f, 0.5f, 0.5f,    D3DCOLOR_XRGB(0,  0,   255)}, //B3
    {-0.5f, -0.5f, 0.5f,  D3DCOLOR_XRGB(0,  0,   255)}, //C3
    {-0.5f, 0.5f, 0.5f,   D3DCOLOR_XRGB(0,  0,   255)}, //D3
 
    // Грань 4
    {-0.5f, -0.5f, 0.5f,  D3DCOLOR_XRGB(255,   255,  0)}, //A4
    {-0.5f, 0.5f, 0.5f,   D3DCOLOR_XRGB(255,   255,  0)}, //B4
    {-0.5f, -0.5f, -0.5f, D3DCOLOR_XRGB(255,   255,  0)}, //C4
    {-0.5f, 0.5f, -0.5f,  D3DCOLOR_XRGB(255,   255,  0)}, //D4
 
    // Грань 5
    {-0.5f, 0.5f, -0.5f,  D3DCOLOR_XRGB(255,  0,   255)}, //A5
    {-0.5f, 0.5f, 0.5f,   D3DCOLOR_XRGB(255,  0,   255)}, //B5
    {0.5f, 0.5f, -0.5f,   D3DCOLOR_XRGB(255,  0,   255)}, //C5
    {0.5f, 0.5f, 0.5f,    D3DCOLOR_XRGB(255,  0,   255)}, //D5
 
    // Грань 6
    {0.5f, -0.5f, -0.5f,  D3DCOLOR_XRGB(0,   255,   255)}, //A6
    {0.5f, -0.5f, 0.5f,   D3DCOLOR_XRGB(0,   255,   255)}, //B6
    {-0.5f, -0.5f, -0.5f, D3DCOLOR_XRGB(0,   255,   255)}, //C6
    {-0.5f, -0.5f, 0.5f,  D3DCOLOR_XRGB(0,   255,   255)}, //D6
  };
 
void * pBuf;
  // Создание буфера вершин
    hRes = pD3DDevice->CreateVertexBuffer(sizeof(sVertex) * iVertsNum, D3DUSAGE_WRITEONLY,
        D3DFVF_XYZ | D3DFVF_DIFFUSE, D3DPOOL_DEFAULT, &vBuffer/*указатель на буфер с вершинами*/, 0);
    if (FAILED(hRes))
        return;
    // Блокировка буфера вершин и заполнение вершинного буфера
    hRes = vBuffer->Lock(0, sizeof(sVertex) * iVertsNum, &pBuf, 0); //Блокировка
    if (FAILED(hRes))
        return;
    memcpy(pBuf, svVortexList, sizeof(sVertex) * iVertsNum); //Копирование значение всех точек в буфер
    vBuffer->Unlock(); //Разблокирование буфера
    // Массив индексов построения треугольника
    const unsigned short Idxes[]={
        0,1,2,2,1,3,
        4,5,6,6,5,7,
        8,9,10,10,9,11,
        12,13,14,14,13,15,
        16,17,18,18,17,19,
        20,21,22,22,21,23,
    };
    
    // создание индексного буфера
    hRes = pD3DDevice->CreateIndexBuffer( sizeof(short) * iIdxNum,
        D3DUSAGE_WRITEONLY, D3DFMT_INDEX16, D3DPOOL_DEFAULT,&iBuffer, 0);
    if (FAILED(hRes))
        return;
    // Блокировка буфера индексов и заполнение индексного буфера
    hRes = iBuffer->Lock(0, sizeof(short) * iIdxNum, &pBuf, 0); //Блокировка
    if (FAILED(hRes))
        return;
    memcpy(pBuf, Idxes, sizeof(short) * iIdxNum);
    iBuffer->Unlock();//Разблокирование буфера
}
 
 void SetView() {
    D3DMATRIX View = {
        1, 0, 0, 0,
        0, 1, 0, 0,
        0, 0, 1, 0,
        0, 0, 5, 1,
    };
    pD3DDevice->SetTransform(D3DTS_VIEW, &View);
}
 
int APIENTRY _tWinMain(HINSTANCE hInstance,
    HINSTANCE hPrevInstance,
    LPTSTR    lpCmdLine,
    int       nCmdShow)
{
    UNREFERENCED_PARAMETER(hPrevInstance);
    UNREFERENCED_PARAMETER(lpCmdLine);
 
 
    MSG msg;
    HACCEL hAccelTable;
 
    // Инициализация глобальных строк
    LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
    LoadString(hInstance, IDC_DIRECTX, szWindowClass, MAX_LOADSTRING);
    MyRegisterClass(hInstance);
 
    // Выполнить инициализацию приложения:
    if (!InitInstance (hInstance, nCmdShow))
    {
        return FALSE;
    }
 
    //Создание 3D объекта
    CreateQuad();
    SetView();
    hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_DIRECTX));
    // Цикл основного сообщения:
    while (GetMessage(&msg, NULL, 0, 0))
    {
        if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }
 
    return (int) msg.wParam;
}
 
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_DIRECTX));
    wcex.hCursor        = LoadCursor(NULL, IDC_ARROW);
    wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);
    wcex.lpszMenuName   = MAKEINTRESOURCE(IDC_DIRECTX);
    wcex.lpszClassName  = szWindowClass;
    wcex.hIconSm        = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));
 
    return RegisterClassEx(&wcex);
}
 
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
    HWND hWnd;
 
    hInst = hInstance; // Сохранить дескриптор экземпляра в глобальной переменной
 
    hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);
 
    if (!hWnd)
    {
        return FALSE;
    }
    // Вызов функции инициализации
    // Если результат работы функции не равен S_OK,
    // то произошла ошибка
    if (DX3DInit(&pD3D, &pD3DDevice, hWnd, 800, 600, FALSE)!=S_OK)
    {
        MessageBox(hWnd, L"Ошибка инициализации DirectX",
            L"Error", MB_OK);
        return FALSE;
    }
    
 
    ShowWindow(hWnd, nCmdShow);
    UpdateWindow(hWnd);
 
    return TRUE;
}
 
void DrawScene() { // Выставляем матрицу мира для объекта в мировых координатах 
    ViewAngle+=0.01; 
    float b = ViewAngle; 
    // Определение матрицы мира 
    D3DMATRIX World = 
    { 
          cos(b)*cos(b), cos(b)*sin(b), sin(b),0,
         -sin(b),cos(b),0,0,
               -sin(b)*cos(b),-sin(b)*sin(b), cos(b),0,
        0,0,0,1,
    }; 
    // Устанавливаем матрицу мира 
    pD3DDevice->SetTransform(D3DTS_WORLD, &World); 
    SetView();
    // Определяем вершинный формат 
    pD3DDevice->SetFVF(D3DFVF_XYZ | D3DFVF_DIFFUSE); 
    // Устанавливаем вершинный буфер 
    pD3DDevice->SetStreamSource(0, vBuffer, 0, sizeof(sVertex)); 
    // Устанавливаем индексный буфер 
    pD3DDevice->SetIndices(iBuffer); 
    // убери отсюда комментарии, чтобы куб был в виде треугольников 
    //pD3DDevice->SetRenderState(D3DRS_FILLMODE, D3DFILL_WIREFRAME);
    // вывод объекта 
    pD3DDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, iVertsNum, 0, iPointsNum); 
}
 
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);
        // Разобрать выбор в меню:
        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:
        //hdc = BeginPaint(hWnd, &ps);
        // TODO: добавьте любой код отрисовки...
        // Очистка поверхности 
        RECT r;
        SetRect(&r, 0, 0, iWidth, iHeight);
        pD3DDevice->Clear(1, (D3DRECT*)&r, D3DCLEAR_TARGET,
            D3DCOLOR_XRGB(255,255,255), 1.0, 0);
        // Подготовка изображения во вторичном буфере
        pD3DDevice->BeginScene();
        DrawScene();
        pD3DDevice->EndScene();
        // Отображение
        pD3DDevice->Present(NULL, NULL, 0, NULL);
        break;
        //EndPaint(hWnd, &ps);
        //break;
    case WM_DESTROY:
        if (pD3DDevice)
            {
            pD3DDevice->Release();
            pD3DDevice = NULL;
            }
        if (pD3D)
            {
            pD3D->Release();
            pD3D = NULL;
            }
 
        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;
}