PRODUCTIONNEUH

#pragma warning (disable:4996)
#pragma comment (lib, "d3d11.lib")

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

using namespace Gdiplus;
using namespace std;

namespace D3DProject1
{
    UINT windowStyle = WS_OVERLAPPEDWINDOW;
    HWND hMainWindow;
    HINSTANCE hCurrentInstance;
    IDXGISwapChain* swapchain;
    ID3D11RenderTargetView* backbuffer;
    ID3D11Device* dev;
    ID3D11DeviceContext* devcon;
    ID3D11VertexShader* vs;
    ID3D11PixelShader* ps;
    int viewportWidth = 800;
    int viewportHeight = 600;

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

    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*& pRenderTarget)
    {
        ID3D11Texture2D* pBackBuffer;
        swapchain->GetBuffer(0, __uuidof(ID3D11Texture2D), (void**)&pBackBuffer);
        dev->CreateRenderTargetView(pBackBuffer, NULL, &pRenderTarget);
        devcon->OMSetRenderTargets(1, &pRenderTarget, NULL);
        pBackBuffer->Release();
    }

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

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

    void InitRenderingPipeline()
    {
        ID3D10Blob* vsBlob;
        ID3D10Blob* psBlob;
        D3DX11CompileFromFile(L"shaders.shader", 0, 0, "VertexShader", "vs_4_0", 0, 0, 0, &vsBlob, 0, 0);
        D3DX11CompileFromFile(L"shaders.shader", 0, 0, "PixelShader", "ps_4_0", 0, 0, 0, &psBlob, 0, 0);

        dev->CreateVertexShader(vsBlob->GetBufferPointer(), vsBlob->GetBufferSize(), NULL, &vs);
        dev->CreatePixelShader(psBlob->GetBufferPointer(), psBlob->GetBufferSize(), NULL, &ps);

        devcon->VSSetShader(vs, 0, 0);
        devcon->PSSetShader(ps, 0, 0);
    }

    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();
    }

    void RenderFrame()
    {

    }

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

    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);
                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);
}