Что за ошибки?

#include <d3d11.h>
#include <d3dx11.h>
#include "resource.h"
#include <windows.h>
#include <xnamath.h>
#include <d3d9.h>
#include <d3dx9.h>
//#include "resource1.h"
struct SimpleVertex
{
    XMFLOAT3 pos;
};
HINSTANCE               g_hInst = NULL;
HWND                    g_hWnd = NULL;
D3D_DRIVER_TYPE         g_driverType = D3D_DRIVER_TYPE_NULL;
D3D_FEATURE_LEVEL       g_featureLevel = D3D_FEATURE_LEVEL_11_0;
ID3D11Device*           g_pd3dDevice = NULL;        
ID3D11DeviceContext*    g_pImmediateContext = NULL; 
IDXGISwapChain*         g_pSwapChain = NULL;        
ID3D11RenderTargetView* g_pRenderTargetView = NULL; 
ID3D11VertexShader*     g_pVertexShader = NULL;
ID3D11PixelShader*      g_pPixelShader = NULL;
ID3D11InputLayout*      g_pVertexLayout = NULL;
ID3D11Buffer*           g_pVertexBuffer = NULL;
HRESULT InitWindow(HINSTANCE hInstance, int nCmdShow); 
HRESULT InitDevice();   
HRESULT InitGeomety();
void CleanupDevice();
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);     
void Render();  
int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLine, int nCmdShow)
{
    UNREFERENCED_PARAMETER(hPrevInstance);
    UNREFERENCED_PARAMETER(lpCmdLine);
    if (FAILED(InitWindow(hInstance, nCmdShow)))
        return 0;
    if (FAILED(InitDevice()))
    {
        CleanupDevice();
        return 0;
    }
    if (FAILED(InitGeomety()))
    {
        CleanupDevice();
        return;
    }
    MSG msg = { 0 };
    while (WM_QUIT != msg.message)
    {
        if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
        else    
        {
            Render();           }
    }
    CleanupDevice();
    return (int)msg.wParam;
}
HRESULT InitWindow(HINSTANCE hInstance, int nCmdShow)
{
    
    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 = NULL;
    wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
    wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
    wcex.lpszMenuName = NULL;
    wcex.lpszClassName = L"WindowClass";
    wcex.hIconSm = LoadIcon(wcex.hInstance, (LPCTSTR)IDI_ICON1);
    if (!RegisterClassEx(&wcex))
        return E_FAIL;
    // Создание окна
    g_hInst = hInstance;
    RECT rc = { 0, 0, 320, 210 };
    AdjustWindowRect(&rc, WS_OVERLAPPEDWINDOW, FALSE);
    g_hWnd = CreateWindow(L"WindowClass", L" Создание устройств Direct3D", WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT, CW_USEDEFAULT, rc.right - rc.left, rc.bottom - rc.top, NULL, NULL, hInstance, NULL);
    if (!g_hWnd)
        return E_FAIL;
    ShowWindow(g_hWnd, nCmdShow);
    return S_OK;
}
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    PAINTSTRUCT ps;
    HDC hdc;
    switch (message)
    {
    case WM_PAINT:
        hdc = BeginPaint(hWnd, &ps);
        EndPaint(hWnd, &ps);
        break;
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
    }
    return 0;
}
HRESULT CompileShaderFromFile(WCHAR* szFileName,LPCSTR szEntryPoint, LPCSTR szShaderModel,ID3DBlob**ppBlobOut )
{
    HRESULT hr = S_OK;
    DWORD dwShaderFlags /*= D3DCOMPILE_ENABLE_STRICTNESS*/;
    ID3DBlob* pErrorBlob;
    hr = D3DX11CompileFromFile(szFileName, 0, 0, szEntryPoint, szShaderModel, dwShaderFlags, 0, 0, ppBlobOut, &pErrorBlob, 0);
    if (FAILED(hr))
    {
        if (pErrorBlob != NULL)
            OutputDebugStringA((char*)pErrorBlob->GetBufferPointer());
        if (pErrorBlob) pErrorBlob->Release();
    }
    if (pErrorBlob) pErrorBlob->Release();
    return S_OK;
}
HRESULT InitDevice()
{
    HRESULT hr = S_OK;
    RECT rc;
    GetClientRect(g_hWnd, &rc);
    UINT width = rc.right - rc.left;    
    UINT height = rc.bottom - rc.top;
    UINT createDeviceFlags = 0;
#ifdef _DEBUG
    createDeviceFlags |=D3D11_CREATE_DEVICE_DEBUG;
#endif
    
    D3D_DRIVER_TYPE driverTypes[] =
    {
        D3D_DRIVER_TYPE_HARDWARE,
        D3D_DRIVER_TYPE_WARP,
        D3D_DRIVER_TYPE_REFERENCE,
    };
    UINT numDriverTypes = ARRAYSIZE(driverTypes);
    D3D_FEATURE_LEVEL featureLevels[] =
    {
        D3D_FEATURE_LEVEL_11_0,
        D3D_FEATURE_LEVEL_10_1,
        D3D_FEATURE_LEVEL_10_0,
        D3D_FEATURE_LEVEL_9_3,
        D3D_FEATURE_LEVEL_9_2,
        D3D_FEATURE_LEVEL_9_1,
    };
    UINT numFeatureLevels = ARRAYSIZE(featureLevels);
    DXGI_SWAP_CHAIN_DESC sd;        
    ZeroMemory(&sd, sizeof(sd));    
    sd.BufferCount = 1;         
    sd.BufferDesc.Width = width;        
    sd.BufferDesc.Height = height;      
    sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;  
    sd.BufferDesc.RefreshRate.Numerator = 75;           
    sd.BufferDesc.RefreshRate.Denominator = 1;
    sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;   
    sd.OutputWindow = g_hWnd;                           
    sd.SampleDesc.Count = 1;
    sd.SampleDesc.Quality = 0;
    sd.Windowed = TRUE;                     
    for (UINT driverTypeIndex = 0; driverTypeIndex < numDriverTypes; driverTypeIndex++)
    {
        g_driverType = driverTypes[driverTypeIndex];
        hr = D3D11CreateDeviceAndSwapChain(NULL, g_driverType, NULL, createDeviceFlags, featureLevels, numFeatureLevels,
            D3D11_SDK_VERSION, &sd, &g_pSwapChain, &g_pd3dDevice, &g_featureLevel, &g_pImmediateContext);
        if (SUCCEEDED(hr)) 
            break;
    }
    if (FAILED(hr))
        return hr;
    ID3D11Texture2D* pBackBuffer = NULL;
    hr = g_pSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&pBackBuffer);
    if (FAILED(hr)) return hr;
    hr = g_pd3dDevice->CreateRenderTargetView(pBackBuffer, NULL, &g_pRenderTargetView);
    pBackBuffer->Release();
    if (FAILED(hr)) return hr;
    g_pImmediateContext->OMSetRenderTargets(1, &g_pRenderTargetView, NULL);
    D3D11_VIEWPORT vp;
    vp.Width = (FLOAT)width;
    vp.Height = (FLOAT)height;
    vp.MinDepth = 0.0f;
    vp.MaxDepth = 1.0f;
    vp.TopLeftX = 0;
    vp.TopLeftY = 0;
    g_pImmediateContext->RSSetViewports(1, &vp);
    return S_OK;
}
HRESULT initGeometry()
{
    HRESULT hr = S_OK;
    ID3DBlob* pVSBlob = NULL;
    hr = CompileShaderFromFile(L"my_first_vertex_shader.fx","VS","vs_4_0",&pVSBlob);
    if (FAILED(hr))
    {
        MessageBox(0, L"Не возможно скомпилировать файл FX. Пожалуйста, запустите программу содержащий файл FX.", L"Ошибка!!!", MB_OK);
        return hr;
    }
    hr = g_pd3dDevice->CreateVertexShader(pVSBlob->GetBufferPointer(), pVSBlob->GetBufferSize(), 0, &g_pVertexShader);
    if (FAILED(hr))
    {
        pVSBlob->Release();
        return hr;
    }
    D3D11_INPUT_ELEMENT_DESC layout[] =
    {
        { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
    };
    UINT numElements = ARRAYSIZE(layout);
    hr = g_pd3dDevice->CreateInputLayout(layout, numElements, pVSBlob->GetBufferPointer(), pVSBlob->GetBufferSize(), &g_pVertexLayout);
    pVSBlob->Release();
    if (FAILED(hr)) return hr;
    g_pImmediateContext->IASetInputLayout(g_pVertexLayout);
    ID3DBlob* pPSBlob = NULL;
    hr = CompileShaderFromFile(L"my_first_pixel_shader.fx", "PS", "vs_4_0", &pPSBlob);
    if (FAILED(hr))
    {
        MessageBox(0, L"Не возможно скомпилировать файл FX. Пожалуйста, запустите программу содержащий файл FX.", L"Ошибка!!!", MB_OK);
        return hr;
    }
    hr = g_pd3dDevice->CreatePixelShader(pPSBlob->GetBufferPointer(),pPSBlob->GetBufferSize,0,&g_pPixelShader);
    pPSBlob->Release();
    if (FAILED(hr)) return hr;
    SimpleVertex vertices[3];
    vertices[0].pos.x = 0.0f; vertices[0].pos.y = 0.5f; vertices[0].pos.z = 0.5f;
    vertices[1].pos.x = 0.5f; vertices[1].pos.y = -0.5f; vertices[1].pos.z = 0.5f;
    vertices[2].pos.x = -0.5f; vertices[2].pos.x = -0.5f; vertices[2].pos.z = 0.5f;
    D3D11_BUFFER_DESC bd;
    ZeroMemory(&bd, sizeof(bd));
    bd.Usage = D3D11_USAGE_DEFAULT;
    bd.ByteWidth = sizeof(SimpleVertex)*3;
    bd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
    bd.CPUAccessFlags = 0;
    D3D11_SUBRESOURCE_DATA InitData;
    ZeroMemory(&InitData, sizeof(InitData));
    InitData.pSysMem = vertices;
    hr = g_pd3dDevice->CreateBuffer(&bd, &InitData, &g_pVertexBuffer);
    if (FAILED(hr)) return hr;
    UINT stride = sizeof(SimpleVertex);
    UINT offset = 0;
    g_pImmediateContext->IASetVertexBuffers(0, 1, &g_pVertexBuffer, &stride, &offset);
    g_pImmediateContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
    return S_OK;
}
void Render()
{
    float ClearColor[4] = { 0.0f, 0.0f, 1.0f, 1.0f }; 
    g_pImmediateContext->ClearRenderTargetView(g_pRenderTargetView, ClearColor);
    g_pImmediateContext->VSSetShader(g_pVertexShader, 0, 0);
    g_pImmediateContext->PSSetShader(g_pPixelShader, 0, 0);
    g_pImmediateContext->Draw(3, 0);
    g_pSwapChain->Present(0, 0);
}
void CleanupDevice()
{
    if (g_pImmediateContext) g_pImmediateContext->ClearState();
    if (g_pVertexBuffer) g_pVertexBuffer->Release();
    if (g_pVertexLayout) g_pVertexLayout->Release();
    if (g_pVertexShader) g_pVertexShader->Release();
    if (g_pPixelShader)  g_pPixelShader->Release();
    if (g_pRenderTargetView) g_pRenderTargetView->Release();
    if (g_pSwapChain) g_pSwapChain->Release();
    if (g_pImmediateContext) g_pImmediateContext->Release();
    if (g_pd3dDevice) g_pd3dDevice->Release();
}