D3DProject1/main.cpp

#pragma warning (disable:4996)

#pragma comment (lib, "d3d11.lib")
#pragma comment (lib, "d3dx11.lib")
#pragma comment (lib, "d3dx10.lib")

#include <Windows.h>
#include <D3D11.h>
#include <D3DX11.h>
#include <D3DX10.h>
#include <gdiplus.h>
#include <string>
#include <vector>

using namespace Gdiplus;
using namespace std;

namespace D3DProject1
{
    UINT windowStyle = WS_OVERLAPPEDWINDOW;
    HWND hMainWindow;
    HINSTANCE hCurrentInstance;
    IDXGISwapChain* swapchain;
    ID3D11RenderTargetView* backbuffer;
    ID3D11Device* dev;
    ID3D11DeviceContext* devcon;
    ID3D10Blob* vsBlob;
    ID3D10Blob* psBlob;
    ID3D11VertexShader* vs;
    ID3D11PixelShader* ps;
    ID3D11Buffer* vertexBuffer;
    ID3D11InputLayout *vertexBufferLayout;
    int numberOfVertices = 0;
    int viewportWidth = 800;
    int viewportHeight = 600;
    wstring shadersFile = L"Shaders.fx";

    wchar_t* W(wstring str)
    {
        wchar_t* result = new wchar_t[str.size()];
        wcscpy(result, str.c_str());
        return result;
    }

    char* S(string str)
    {
        char* result = new char[str.size()];
        strcpy(result, str.c_str());
        return result;
    }

    struct Vertex
    {
        float X, Y, Z;
        D3DXCOLOR Color;
    };

    D3D11_INPUT_ELEMENT_DESC VertexIED[] =
    {
        { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
        { "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 }
    };

    void CreateWC(wstring name, WNDPROC OnMessage)
    {
        WNDCLASSEX wc;
        ZeroMemory(&wc, sizeof(wc));

        wc.cbSize = sizeof(WNDCLASSEX);
        wc.style = CS_HREDRAW | CS_VREDRAW;
        wc.lpfnWndProc = OnMessage;
        wc.hInstance = hCurrentInstance;
        wc.hCursor = LoadCursor(NULL, IDC_ARROW);
        wc.hbrBackground = (HBRUSH)COLOR_WINDOW;
        wc.lpszClassName = W(name);

        RegisterClassEx(&wc);
    }

    Size AdjustWndSzToViewportSz(int viewportWidth, int viewportHeight, UINT wndStyle = windowStyle)
    {
        RECT wr = { 0, 0, viewportWidth, viewportHeight };
        AdjustWindowRect(&wr, wndStyle, FALSE);
        return Size(wr.right - wr.left, wr.bottom - wr.top);
    }

    DXGI_SWAP_CHAIN_DESC CreateSCD(HWND hWnd, int width, int height)
    {
        DXGI_SWAP_CHAIN_DESC scd;
        ZeroMemory(&scd, sizeof(DXGI_SWAP_CHAIN_DESC));

        scd.BufferCount = 1;
        scd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
        scd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
        scd.BufferDesc.Width = width;
        scd.BufferDesc.Height = height;
        scd.OutputWindow = hWnd;
        scd.SampleDesc.Count = 4;
        scd.Windowed = TRUE;
        scd.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;

        return scd;
    }

    void InitD3DDeviceAndSwapChain(DXGI_SWAP_CHAIN_DESC& scd, IDXGISwapChain*& sc, ID3D11Device*& dev, ID3D11DeviceContext*& devCon)
    {
        D3D11CreateDeviceAndSwapChain
        (
            NULL,
            D3D_DRIVER_TYPE_HARDWARE,
            NULL,
            NULL,
            NULL,
            NULL,
            D3D11_SDK_VERSION,
            &scd,
            &swapchain,
            &dev,
            NULL,
            &devcon
        );
    }

    D3D11_VIEWPORT CreateViewport(int width, int height)
    {
        D3D11_VIEWPORT viewport;
        ZeroMemory(&viewport, sizeof(D3D11_VIEWPORT));

        viewport.TopLeftX = 0;
        viewport.TopLeftY = 0;
        viewport.Width = width;
        viewport.Height = height;

        return viewport;
    }

    void SetRenderTarget(ID3D11RenderTargetView*& renderTarget)
    {
        ID3D11Texture2D* pBackBuffer;
        swapchain->GetBuffer(0, __uuidof(ID3D11Texture2D), (void**)&pBackBuffer);
        dev->CreateRenderTargetView(pBackBuffer, NULL, &renderTarget);
        devcon->OMSetRenderTargets(1, &renderTarget, NULL);
        pBackBuffer->Release();
    }

    void ClearRenderTarget(ID3D11RenderTargetView*& renderTarget)
    {
        devcon->ClearRenderTargetView(backbuffer, D3DXCOLOR(0.3f, 0.2f, 0.4f, 1.0f));
    }

    void SwapSCBuffers(IDXGISwapChain*& swapChain)
    {
        swapChain->Present(0, 0);
    }

    void LoadVertexShader(wstring filename, string shaderName, string version, ID3D11VertexShader*& shader, ID3D10Blob*& blob)
    {
        D3DX11CompileFromFile(W(filename), 0, 0, S(shaderName), S(version), 0, 0, 0, &blob, 0, 0);
        dev->CreateVertexShader(blob->GetBufferPointer(), blob->GetBufferSize(), NULL, &shader);
    }

    void LoadPixelShader(wstring filename, string shaderName, string version, ID3D11PixelShader*& shader, ID3D10Blob*& blob)
    {
        D3DX11CompileFromFile(W(filename), 0, 0, S(shaderName), S(version), 0, 0, 0, &blob, 0, 0);
        dev->CreatePixelShader(blob->GetBufferPointer(), blob->GetBufferSize(), NULL, &shader);
    }

    ID3D11InputLayout* CreateInputLayout(D3D11_INPUT_ELEMENT_DESC* ied, ID3D10Blob* vsBlob)
    {
        ID3D11InputLayout* layout;
        dev->CreateInputLayout(ied, 2, vsBlob->GetBufferPointer(), vsBlob->GetBufferSize(), &layout);
        return layout;
    }

    void InitRenderingPipeline()
    {
        LoadVertexShader(shadersFile, "VShader", "vs_4_0", vs, vsBlob);
        LoadPixelShader(shadersFile, "PShader", "ps_4_0", ps, psBlob);
        devcon->VSSetShader(vs, 0, 0);
        devcon->PSSetShader(ps, 0, 0);
    }

    D3D11_BUFFER_DESC CreateBD(int vertexCount)
    {
        D3D11_BUFFER_DESC bd;
        ZeroMemory(&bd, sizeof(bd));

        bd.Usage = D3D11_USAGE_DYNAMIC;
        bd.ByteWidth = sizeof(Vertex) * vertexCount;
        bd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
        bd.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;

        return bd;
    }

    void CreateVertexBuffer(ID3D11Buffer*& buffer, int size)
    {
        auto bd = CreateBD(size);
        dev->CreateBuffer(&bd, NULL, &buffer);
    }

    void WriteVertexBuffer(ID3D11Buffer*& buffer, vector<Vertex>& vertices)
    {
        D3D11_MAPPED_SUBRESOURCE ms;
        devcon->Map(buffer, NULL, D3D11_MAP_WRITE_DISCARD, NULL, &ms);
        memcpy(ms.pData, &vertices[0], sizeof(Vertex) * vertices.size());
        devcon->Unmap(buffer, NULL);
    }

    void LoadGeometry()
    {
        vector<Vertex> vertices =
        {
            { -0.45f, -0.5f, 0.0f, D3DXCOLOR(0.0f, 0.0f, 1.0f, 1.0f) },
            { 0.0f, 0.5f, 0.0f, D3DXCOLOR(1.0f, 0.0f, 0.0f, 1.0f) },
            { 0.45f, -0.5, 0.0f, D3DXCOLOR(0.0f, 1.0f, 0.0f, 1.0f) },
        };

        numberOfVertices = vertices.size();

        CreateVertexBuffer(vertexBuffer, numberOfVertices);
        WriteVertexBuffer(vertexBuffer, vertices);

        vertexBufferLayout = CreateInputLayout(VertexIED, vsBlob);
        devcon->IASetInputLayout(vertexBufferLayout);
    }

    void InitD3D(HWND hWnd = hMainWindow)
    {
        auto scd = CreateSCD(hWnd, viewportWidth, viewportHeight);
        InitD3DDeviceAndSwapChain(scd, swapchain, dev, devcon);
        SetRenderTarget(backbuffer);
        auto viewport = CreateViewport(viewportWidth, viewportHeight);
        devcon->RSSetViewports(1, &viewport);
        InitRenderingPipeline();
        LoadGeometry();
    }

    void RenderFrame()
    {
        devcon->Draw(numberOfVertices, 0);
    }

    void ReleaseD3D()
    {
        vs->Release();
        ps->Release();
        swapchain->SetFullscreenState(FALSE, NULL);
        swapchain->Release();
        backbuffer->Release();
        dev->Release();
        devcon->Release();
    }

    void SelectVertexBuffer(ID3D11Buffer*& buffer)
    {
        UINT stride = sizeof(Vertex);
        UINT offset = 0;
        devcon->IASetVertexBuffers(0, 1, &buffer, &stride, &offset);
        devcon->IASetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
    }

    LRESULT CALLBACK OnMessage(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
    {
        switch (message)
        {
            case WM_DESTROY:
                ReleaseD3D();
                ExitProcess(0);
                break;
        }
        return DefWindowProc(hWnd, message, wParam, lParam);
    }

    HWND CreateWnd(int width, int height, wstring title, UINT wndStyle = windowStyle)
    {
        CreateWC(title, OnMessage);
        HWND hWnd = CreateWindow
        (
            W(title),
            W(title),
            wndStyle,
            300,
            300,
            width,
            height,
            NULL,
            NULL,
            hCurrentInstance,
            NULL
        );
        ShowWindow(hWnd, SW_RESTORE);
        return hWnd;
    }

    void InitMessageLoop()
    {
        MSG msg;
        while (true)
        {
            if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
            {
                TranslateMessage(&msg);
                DispatchMessage(&msg);
            }
            else
            {
                ClearRenderTarget(backbuffer);
                SelectVertexBuffer(vertexBuffer);
                RenderFrame();
                SwapSCBuffers(swapchain);
            }
        }
    }

    int WinMain(HINSTANCE hInstance, string cmdLine, int showCmd)
    {
        hCurrentInstance = hInstance;
        Size wndSz = AdjustWndSzToViewportSz(viewportWidth, viewportHeight);
        hMainWindow = CreateWnd(wndSz.Width, wndSz.Height, L"D3DProject1 Main Window");
        InitD3D(hMainWindow);
        InitMessageLoop();
        return 0;
    }
}

int CALLBACK WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR cmdLine, int showCmd)
{
    return D3DProject1::WinMain(hInstance, cmdLine, showCmd);
}