// example how to set up D3D11 rendering

// set to 0 to create resizable window
#define WINDOW_WIDTH 1280
#define WINDOW_HEIGHT 720

// do you need depth buffer?
#define WINDOW_DEPTH 1

// do you need stencil buffer?
#define WINDOW_STENCIL 0

// use sRGB or MSAA for color buffer
// set 0 to disable, or 1 to enable sRGB
// typical values for MSAA are 2, 4, 8, 16, ...
// when enabled, D3D11 cannot use more modern lower-latency flip swap effect on Windows 8.1/10
// instead you can use sRGB/MSAA render target and copy it to non-sRGB window
#define WINDOW_SRGB 0
#define WINDOW_MSAA 0

// do you need vsync?
#define WINDOW_VSYNC 1

// keep this enabled when debugging
#define USE_DEBUG_MODE 1

#define COBJMACROS
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <d3d11_1.h>
#include <dxgi1_4.h>
#include <d3dcompiler.h>
#include <stddef.h>

#pragma comment (lib, "user32.lib")
#pragma comment (lib, "dxgi.lib")
#pragma comment (lib, "d3d11.lib")
#pragma comment (lib, "dxguid.lib")

#define SAFE_RELEASE(release, obj) if (obj) release##_Release(obj)

#define LOG_AND_RETURN_ERROR(hr, msg) do \
{                                        \
    if (FAILED(hr))                      \
    {                                    \
        LogWin32Error(hr, msg);          \
        return hr;                       \
    }                                    \
} while (0)

struct Vertex
{
    float x, y;
    float r, g, b;
};

static const struct Vertex vertices[] =
{
    {  0.0f,  0.5f, 1.f, 0.f, 0.f },
    {  0.5f, -0.5f, 0.f, 1.f, 0.f },
    { -0.5f, -0.5f, 0.f, 0.f, 1.f },
};

// You can compile shader to bytecode at build time, this will increase startup
// performance and also will avoid dependency on d3dcompiler dll file.
// To do so, put the shader source in shader.hlsl file and run these two commands:

// fxc.exe /nologo /T vs_4_0_level_9_0 /E vs /O3 /WX /Zpc /Ges /Fh d3d11_vshader.h /Vn d3d11_vshader /Qstrip_reflect /Qstrip_debug /Qstrip_priv shader.hlsl
// fxc.exe /nologo /T ps_4_0_level_9_0 /E ps /O3 /WX /Zpc /Ges /Fh d3d11_pshader.h /Vn d3d11_pshader /Qstrip_reflect /Qstrip_debug /Qstrip_priv shader.hlsl

// then set next setting to 1
#define USE_PRECOMPILED_SHADERS 0

#if USE_PRECOMPILED_SHADERS
#include "d3d11_vshader.h"
#include "d3d11_pshader.h"
#else
#pragma comment (lib, "d3dcompiler.lib")
static const char d3d11_shader[] =
    "struct VS_INPUT                                \n"
    "{                                              \n"
    "  float2 pos : POSITION;                       \n"
    "  float3 col : COLOR0;                         \n"
    "};                                             \n"
    "                                               \n"
    "struct PS_INPUT                                \n"
    "{                                              \n"
    "  float4 pos : SV_POSITION;                    \n"
    "  float3 col : COLOR0;                         \n"
    "};                                             \n"
    "                                               \n"
    "PS_INPUT vs(VS_INPUT input)                    \n"
    "{                                              \n"
    "  PS_INPUT output;                             \n"
    "  output.pos = float4(input.pos.xy, 0.f, 1.f); \n"
    "  output.col = input.col;                      \n"
    "  return output;                               \n"
    "}                                              \n"
    "                                               \n"
    "float4 ps(PS_INPUT input) : SV_Target          \n"
    "{                                              \n"
    "  return float4(input.col, 1.f);               \n"
    "}                                              \n";
#endif

// is window visible?
// if this is 0 you can skip rendering part in your code to save time
static int render_occluded;

static IDXGISwapChain* render_swapchain;
static ID3D11Device* render_device;
static ID3D11DeviceContext* render_context;
static ID3D11DeviceContext1* render_context1;
static ID3D11RenderTargetView* render_window_rtview;
#if WINDOW_DEPTH || WINDOW_STENCIL
static ID3D11DepthStencilView* render_window_dpview;
#endif
static HANDLE render_frame_latency_wait;

static ID3D11RasterizerState* render_raster_state;
static ID3D11DepthStencilState* render_depthstencil_state;
static ID3D11BlendState* render_blend_state;
static ID3D11PixelShader* render_pixel_shader;
static ID3D11VertexShader* render_vertex_shader;
static ID3D11InputLayout* render_input_layout;
static ID3D11Buffer* render_vertex_buffer;

static void LogWin32Error(DWORD err, const char* msg)
{
    OutputDebugStringA(msg);
    OutputDebugStringA("!\n");

    LPWSTR str;
    if (FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL,
        err, MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL), (LPWSTR)&str, 0, NULL))
    {
        OutputDebugStringW(str);
        LocalFree(str);
    }
}
static void LogWin32LastError(const char* msg)
{
    LogWin32Error(GetLastError(), msg);
}

static HRESULT FatalDeviceLostError()
{
    MessageBoxW(NULL, L"Cannot recreate D3D11 device, it is reset or removed!", L"Error", MB_ICONEXCLAMATION);
    return E_FAIL;
}

// called when device & all d3d resources needs to be released
// can happen multiple times (e.g. after device is removed/reset)
static void RenderDestroy()
{
    if (render_context)
    {
        ID3D11DeviceContext_ClearState(render_context);
    }

    SAFE_RELEASE(ID3D11Buffer, render_vertex_buffer);
    SAFE_RELEASE(ID3D11InputLayout, render_input_layout);
    SAFE_RELEASE(ID3D11VertexShader, render_vertex_shader);
    SAFE_RELEASE(ID3D11PixelShader, render_pixel_shader);
    SAFE_RELEASE(ID3D11RasterizerState, render_raster_state);
    SAFE_RELEASE(ID3D11DepthStencilState, render_depthstencil_state);
    SAFE_RELEASE(ID3D11BlendState, render_blend_state);

#if WINDOW_DEPTH || WINDOW_STENCIL
    SAFE_RELEASE(ID3D11DepthStencilView, render_window_dpview);
#endif
    SAFE_RELEASE(ID3D11RenderTargetView, render_window_rtview);
    SAFE_RELEASE(ID3D11DeviceContext, render_context);
    SAFE_RELEASE(ID3D11Device, render_device);
    SAFE_RELEASE(IDXGISwapChain, render_swapchain);

    render_context1 = NULL;
    render_frame_latency_wait = NULL;
}

// called any time device needs to be created
// can happen multiple times (e.g. after device is removed/reset)
static HRESULT RenderCreate(HWND wnd)
{
    HRESULT hr;
    D3D_FEATURE_LEVEL level;

    // device, context
    {
        UINT flags = D3D11_CREATE_DEVICE_SINGLETHREADED;
#if USE_DEBUG_MODE
        flags |= D3D11_CREATE_DEVICE_DEBUG;
#endif

        if (FAILED(hr = D3D11CreateDevice(
            NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, flags, NULL, 0, D3D11_SDK_VERSION,
            &render_device, &level, &render_context)))
        {
            if (FAILED(hr = D3D11CreateDevice(
                NULL, D3D_DRIVER_TYPE_WARP, NULL, flags, NULL, 0, D3D11_SDK_VERSION,
                &render_device, &level, &render_context)))
            {
                LOG_AND_RETURN_ERROR(hr, "D3D11CreateDevice failed");
            }
        }

        hr = ID3D11DeviceContext_QueryInterface(render_context, &IID_ID3D11DeviceContext1, &render_context1);
        if (SUCCEEDED(hr))
        {
            // using ID3D11DeviceContext1 to discard render target
            ID3D11DeviceContext_Release(render_context);
            render_context = (ID3D11DeviceContext*)render_context1;
        }
    }

    // swap chain
    {
        IDXGIFactory* factory;
        if (FAILED(hr = CreateDXGIFactory(&IID_IDXGIFactory, &factory)))
        {
            LOG_AND_RETURN_ERROR(hr, "CreateDXGIFactory failed");
        }

        DXGI_SWAP_CHAIN_DESC desc =
        {
            .BufferDesc =
            {
#if WINDOW_SRGB
                .Format = DXGI_FORMAT_R8G8B8A8_UNORM_SRGB,
#else
                .Format = DXGI_FORMAT_R8G8B8A8_UNORM,
#endif
                .RefreshRate =
                {
                    .Numerator = 60,
                    .Denominator = 1,
                },
            },
            .SampleDesc =
            {
#if WINDOW_MSAA
                .Count = WINDOW_MSAA,
#else
                .Count = 1,
#endif
                .Quality = 0,
            },
            .BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT,
            .OutputWindow = wnd,
            .Windowed = TRUE,
        };

#if !WINDOW_SRGB && !WINDOW_MSAA
        // Windows 10 and up
        desc.BufferCount = 2;
        desc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD;
        desc.Flags = DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT;
        if (FAILED(IDXGIFactory_CreateSwapChain(factory, (IUnknown*)render_device, &desc, &render_swapchain)))
        {
            // Windows 8.1
            desc.BufferCount = 2;
            desc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;
            desc.Flags = DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT;
            hr = IDXGIFactory_CreateSwapChain(factory, (IUnknown*)render_device, &desc, &render_swapchain);
        }
#else
        hr = E_FAIL;
#endif
        if (FAILED(hr))
        {
            // older Windows
            desc.BufferCount = 1;
            desc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
            desc.Flags = 0;
            hr = IDXGIFactory_CreateSwapChain(factory, (IUnknown*)render_device, &desc, &render_swapchain);
            LOG_AND_RETURN_ERROR(hr, "IDXGIFactory::CreateSwapChain failed");
        }

        if (desc.Flags & DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT)
        {
            IDXGISwapChain2* swapchain2;
            if (SUCCEEDED(hr = IDXGISwapChain_QueryInterface(render_swapchain, &IID_IDXGISwapChain2, &swapchain2)))
            {
                // using IDXGISwapChain2 for frame latency control
                render_frame_latency_wait = IDXGISwapChain2_GetFrameLatencyWaitableObject(swapchain2);
                IDXGISwapChain2_Release(swapchain2);
            }
        }

        hr = IDXGIFactory_MakeWindowAssociation(factory, wnd, DXGI_MWA_NO_WINDOW_CHANGES | DXGI_MWA_NO_ALT_ENTER);
        LOG_AND_RETURN_ERROR(hr, "IDXGIFactory::MakeWindowAssociation failed");

        IDXGIFactory_Release(factory);
    }

    // rasterizer state
    {
        D3D11_RASTERIZER_DESC desc =
        {
            .FillMode = D3D11_FILL_SOLID,
            .CullMode = D3D11_CULL_BACK,
            .FrontCounterClockwise = FALSE,
            .DepthBias = 0,
            .DepthBiasClamp = 0,
            .SlopeScaledDepthBias = 0.f,
            .DepthClipEnable = TRUE,
            .ScissorEnable = FALSE,
            .MultisampleEnable = WINDOW_MSAA > 0,
            .AntialiasedLineEnable = FALSE,
        };

        hr = ID3D11Device_CreateRasterizerState(render_device, &desc, &render_raster_state);
        LOG_AND_RETURN_ERROR(hr, "ID3D11Device::CreateRasterizerState failed");
    }

#if WINDOW_DEPTH || WINDOW_STENCIL
    // depth & stencil state
    {
        D3D11_DEPTH_STENCIL_DESC desc =
        {
            .DepthEnable = WINDOW_DEPTH ? TRUE : FALSE,
            .DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL,
            .DepthFunc = D3D11_COMPARISON_LESS,
            .StencilEnable = FALSE, // if you need stencil, set up it here
            .StencilReadMask = 0,
            .StencilWriteMask = 0,
        };

        hr = ID3D11Device_CreateDepthStencilState(render_device, &desc, &render_depthstencil_state);
        LOG_AND_RETURN_ERROR(hr, "ID3D11Device::CreateDepthStencilState failed");
    }
#endif

    // blend state
    {
        D3D11_BLEND_DESC desc =
        {
            .AlphaToCoverageEnable = FALSE,
            .IndependentBlendEnable = FALSE,
            .RenderTarget =
            {
                {
                    .BlendEnable = FALSE,
                    .SrcBlend = D3D11_BLEND_SRC_ALPHA,
                    .DestBlend = D3D11_BLEND_INV_SRC_ALPHA,
                    .BlendOp = D3D11_BLEND_OP_ADD,
                    .SrcBlendAlpha = D3D11_BLEND_SRC_ALPHA,
                    .DestBlendAlpha = D3D11_BLEND_INV_SRC_ALPHA,
                    .BlendOpAlpha = D3D11_BLEND_OP_ADD,
                    .RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL,
                },
            },
        };

        hr = ID3D11Device_CreateBlendState(render_device, &desc, &render_blend_state);
        LOG_AND_RETURN_ERROR(hr, "ID3D11Device::CreateBlendState failed");
    }

#if !USE_PRECOMPILED_SHADERS
    UINT shader_flags = D3DCOMPILE_ENABLE_STRICTNESS | D3DCOMPILE_WARNINGS_ARE_ERRORS
#if USE_DEBUG_MODE
        | D3DCOMPILE_OPTIMIZATION_LEVEL0 | D3DCOMPILE_SKIP_OPTIMIZATION | D3DCOMPILE_DEBUG;
#else
        | D3DCOMPILE_OPTIMIZATION_LEVEL3;
#endif
#endif

    // vertex shader & input layout
    {
        D3D11_INPUT_ELEMENT_DESC layout[] =
        {
            { "POSITION", 0, DXGI_FORMAT_R32G32_FLOAT,    0, offsetof(struct Vertex, x), D3D11_INPUT_PER_VERTEX_DATA, 0 },
            { "COLOR",    0, DXGI_FORMAT_R32G32B32_FLOAT, 0, offsetof(struct Vertex, r), D3D11_INPUT_PER_VERTEX_DATA, 0 },
        };

        ID3DBlob* code = NULL;
        const void* vshader;
        size_t vshader_size;

#if USE_PRECOMPILED_SHADERS
        vshader = d3d11_vshader;
        vshader_size = sizeof(d3d11_vshader);
#else
        ID3DBlob* error;
        hr = D3DCompile(d3d11_shader, sizeof(d3d11_shader)-1, NULL, NULL, NULL,
            "vs", "vs_4_0_level_9_0", shader_flags, 0, &code, &error);
        if (FAILED(hr))
        {
            const void* data = ID3D10Blob_GetBufferPointer(error);
            size_t size = ID3D10Blob_GetBufferSize(error);
            char msg[1024];
            lstrcpynA(msg, data, (int)size);
            msg[size] = 0;
            OutputDebugStringA(msg);
            ID3D10Blob_Release(error);
            LOG_AND_RETURN_ERROR(hr, "D3DCompile vs failed");
        }
        vshader = ID3D10Blob_GetBufferPointer(code);
        vshader_size = ID3D10Blob_GetBufferSize(code);
#endif

        hr = ID3D11Device_CreateVertexShader(render_device, vshader, vshader_size, NULL, &render_vertex_shader);
        if (FAILED(hr))
        {
            SAFE_RELEASE(ID3D10Blob, code);
            LOG_AND_RETURN_ERROR(hr, "ID3D11Device::CreateVertexShader failed");
        }

        hr = ID3D11Device_CreateInputLayout(render_device, layout, _countof(layout),
            vshader, vshader_size, &render_input_layout);
        SAFE_RELEASE(ID3D10Blob, code);
        LOG_AND_RETURN_ERROR(hr, "ID3D11Device::CreateInputLayout failed");
    }

    // pixel shader
    {
        ID3DBlob* code = NULL;
        const void* pshader;
        size_t pshader_size;

#if USE_PRECOMPILED_SHADERS
        pshader = d3d11_pshader;
        pshader_size = sizeof(d3d11_pshader);
#else
        ID3DBlob* error;
        hr = D3DCompile(d3d11_shader, sizeof(d3d11_shader)-1, NULL, NULL, NULL,
            "ps", "ps_4_0_level_9_0", shader_flags, 0, &code, &error);
        if (FAILED(hr))
        {
            const void* data = ID3D10Blob_GetBufferPointer(error);
            size_t size = ID3D10Blob_GetBufferSize(error);
            char msg[1024];
            lstrcpynA(msg, data, (int)size);
            msg[size] = 0;
            OutputDebugStringA(msg);
            ID3D10Blob_Release(error);
            LOG_AND_RETURN_ERROR(hr, "D3DCompile ps failed");
        }
        pshader = ID3D10Blob_GetBufferPointer(code);
        pshader_size = ID3D10Blob_GetBufferSize(code);
#endif

        hr = ID3D11Device_CreatePixelShader(render_device, pshader, pshader_size, NULL, &render_pixel_shader);
        SAFE_RELEASE(ID3D10Blob, code);
        LOG_AND_RETURN_ERROR(hr, "ID3D11Device::CreatePixelShader failed");
    }

    // vertex buffer
    {
        D3D11_BUFFER_DESC desc =
        {
            .ByteWidth = sizeof(vertices),
            .Usage = D3D11_USAGE_IMMUTABLE,
            .BindFlags = D3D11_BIND_VERTEX_BUFFER,
        };

        D3D11_SUBRESOURCE_DATA data =
        {
            .pSysMem = vertices,
        };

        hr = ID3D11Device_CreateBuffer(render_device, &desc, &data, &render_vertex_buffer);
        LOG_AND_RETURN_ERROR(hr, "ID3D11Device::CreateBuffer failed");
    }

    return S_OK;
}

// called when device is reset or removed, recreate it
static HRESULT RecreateDevice(HWND wnd)
{
    RenderDestroy();
    HRESULT hr = RenderCreate(wnd);
    if (FAILED(hr))
    {
        RenderDestroy();
    }
    return hr;
}

// called when window is resized
static HRESULT RenderResize(HWND wnd, int width, int height)
{
    if (width == 0 || height == 0)
    {
        return S_OK;
    }

    if (render_window_rtview)
    {
        ID3D11DeviceContext_OMSetRenderTargets(render_context, 0, NULL, NULL);
        ID3D11RenderTargetView_Release(render_window_rtview);
        render_window_rtview = NULL;
    }

#if WINDOW_DEPTH || WINDOW_STENCIL
    if (render_window_dpview)
    {
        ID3D11DepthStencilView_Release(render_window_dpview);
        render_window_dpview = NULL;
    }
#endif

    UINT flags = render_frame_latency_wait ? DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT : 0;
    HRESULT hr = IDXGISwapChain_ResizeBuffers(render_swapchain, 0, width, height, DXGI_FORMAT_UNKNOWN, flags);
    if (hr == DXGI_ERROR_DEVICE_REMOVED || hr == DXGI_ERROR_DEVICE_RESET || hr == DXGI_ERROR_DRIVER_INTERNAL_ERROR)
    {
        if (FAILED(RecreateDevice(wnd)))
        {
            return FatalDeviceLostError();
        }
    }
    else
    {
        LOG_AND_RETURN_ERROR(hr, "IDXGISwapChain::ResizeBuffers failed");
    }

    ID3D11Texture2D* window_buffer;
    hr = IDXGISwapChain_GetBuffer(render_swapchain, 0, &IID_ID3D11Texture2D, &window_buffer);
    LOG_AND_RETURN_ERROR(hr, "IDXGISwapChain::GetBuffer failed");

    hr = ID3D11Device_CreateRenderTargetView(render_device, (ID3D11Resource*)window_buffer, NULL, &render_window_rtview);
    ID3D11Texture2D_Release(window_buffer);
    LOG_AND_RETURN_ERROR(hr, "ID3D11Device::CreateRenderTargetView failed");

#if WINDOW_DEPTH || WINDOW_STENCIL
    {
        D3D11_TEXTURE2D_DESC desc =
        {
            .Width = width,
            .Height = height,
            .MipLevels = 1,
            .ArraySize = 1,
             .Format = (WINDOW_STENCIL || ID3D11Device_GetFeatureLevel(render_device) < D3D_FEATURE_LEVEL_10_0)
                       ? DXGI_FORMAT_D24_UNORM_S8_UINT : DXGI_FORMAT_D32_FLOAT,
            .SampleDesc =
            {
#if WINDOW_MSAA
                .Count = WINDOW_MSAA,
#else
                .Count = 1,
#endif
                .Quality = 0,
            },
            .Usage = D3D11_USAGE_DEFAULT,
            .BindFlags = D3D11_BIND_DEPTH_STENCIL,
        };

        ID3D11Texture2D* depth_stencil;
        hr = ID3D11Device_CreateTexture2D(render_device, &desc, NULL, &depth_stencil);
        LOG_AND_RETURN_ERROR(hr, "ID3D11Device::CreateTexture2D failed");

        hr = ID3D11Device_CreateDepthStencilView(render_device, (ID3D11Resource*)depth_stencil, NULL, &render_window_dpview);
        ID3D11Texture2D_Release(depth_stencil);
        LOG_AND_RETURN_ERROR(hr, "ID3D11Device::CreateDepthStencilView failed");
    }
#endif

    D3D11_VIEWPORT viewport =
    {
        .TopLeftX = 0.f,
        .TopLeftY = 0.f,
        .Width = (float)width,
        .Height = (float)height,
        .MinDepth = 0.f,
        .MaxDepth = 1.f,
    };
    ID3D11DeviceContext_RSSetViewports(render_context, 1, &viewport);

    return S_OK;
}

// called at end of frame
static HRESULT RenderPresent(HWND wnd)
{
    HRESULT hr = S_OK;
    if (render_occluded)
    {
        hr = IDXGISwapChain_Present(render_swapchain, 0, DXGI_PRESENT_TEST);
        if (SUCCEEDED(hr) && hr != DXGI_STATUS_OCCLUDED)
        {
            // DXGI window is back to normal, resuming rendering
            render_occluded = 0;
        }
    }

    if (!render_occluded)
    {
        hr = IDXGISwapChain_Present(render_swapchain, WINDOW_VSYNC, 0);
    }

    if (hr == DXGI_ERROR_DEVICE_RESET || hr == DXGI_ERROR_DEVICE_REMOVED)
    {
        if (FAILED(RecreateDevice(wnd)))
        {
            return FatalDeviceLostError();
        }

        RECT rect;
        if (!GetClientRect(wnd, &rect))
        {
            LogWin32LastError("GetClientRect failed");
        }
        else
        {
            RenderResize(wnd, rect.right - rect.left, rect.bottom - rect.top);
        }
    }
    else if (hr == DXGI_STATUS_OCCLUDED)
    {
        // DXGI window is occluded, skipping rendering
        render_occluded = 1;
    }
    else
    {
        LOG_AND_RETURN_ERROR(hr, "IDXGISwapChain::Present failed");
    }

    if (render_occluded)
    {
        Sleep(10);
    }
    else
    {
        if (render_context1)
        {
            ID3D11DeviceContext1_DiscardView(render_context1, (ID3D11View*)render_window_rtview);
        }
    }

    return S_OK;
}

// this is where rendering happens
static void RenderFrame()
{
    if (!render_occluded)
    {
        if (render_frame_latency_wait)
        {
            WaitForSingleObjectEx(render_frame_latency_wait, INFINITE, TRUE);
        }

#if WINDOW_DEPTH || WINDOW_STENCIL
        ID3D11DeviceContext_OMSetRenderTargets(render_context, 1, &render_window_rtview, render_window_dpview);
        ID3D11DeviceContext_OMSetDepthStencilState(render_context, render_depthstencil_state, 0);
        ID3D11DeviceContext_ClearDepthStencilView(render_context, render_window_dpview, D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL, 1.f, 0);
#else
        ID3D11DeviceContext_OMSetRenderTargets(render_context, 1, &render_window_rtview, NULL);
#endif

        // clear background
        FLOAT clear_color[] = { 100.f/255.f, 149.f/255.f, 237.f/255.f, 1.f };
        ID3D11DeviceContext_ClearRenderTargetView(render_context, render_window_rtview, clear_color);

        // draw a triangle
        const UINT stride = sizeof(struct Vertex);
        const UINT offset = 0;
        ID3D11DeviceContext_IASetInputLayout(render_context, render_input_layout);
        ID3D11DeviceContext_IASetVertexBuffers(render_context, 0, 1, &render_vertex_buffer, &stride, &offset);
        ID3D11DeviceContext_IASetPrimitiveTopology(render_context, D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
        ID3D11DeviceContext_VSSetShader(render_context, render_vertex_shader, NULL, 0);
        ID3D11DeviceContext_PSSetShader(render_context, render_pixel_shader, NULL, 0);
        ID3D11DeviceContext_RSSetState(render_context, render_raster_state);
        ID3D11DeviceContext_OMSetBlendState(render_context, render_blend_state, NULL, ~0U);
        ID3D11DeviceContext_Draw(render_context, _countof(vertices), 0);
    }
}

static LRESULT CALLBACK WindowProc(HWND wnd, UINT msg, WPARAM wparam, LPARAM lparam)
{
    switch (msg)
    {
    case WM_CREATE:
       if (FAILED(RenderCreate(wnd)))
       {
           return -1;
       }
       return 0;

    case WM_DESTROY:
        RenderDestroy(wnd);
        PostQuitMessage(0);
        return 0;

    case WM_SIZE:
        if (FAILED(RenderResize(wnd, LOWORD(lparam), HIWORD(lparam))))
        {
            DestroyWindow(wnd);
        }
        return 0;
    }
    return DefWindowProcW(wnd, msg, wparam, lparam);
}

int WINAPI WinMain(HINSTANCE instance, HINSTANCE prev_instance, LPSTR cmd_line, int cmd_show)
{
    WNDCLASSEXW wc =
    {
        .cbSize = sizeof(wc),
        .lpfnWndProc = WindowProc,
        .hInstance = instance,
        .hIcon = LoadIconA(NULL, IDI_APPLICATION),
        .hCursor = LoadCursorA(NULL, IDC_ARROW),
        .lpszClassName = L"d3d11_window_class",
    };

    if (!RegisterClassExW(&wc))
    {
        LogWin32LastError("RegisterClassEx failed");
    }
    else
    {
        int width = CW_USEDEFAULT;
        int height = CW_USEDEFAULT;

        DWORD exstyle = WS_EX_APPWINDOW;
        DWORD style = WS_OVERLAPPEDWINDOW;

        if (WINDOW_WIDTH && WINDOW_HEIGHT)
        {
            style &= ~WS_THICKFRAME & ~WS_MAXIMIZEBOX;
    
            RECT rect = { 0, 0, WINDOW_WIDTH, WINDOW_HEIGHT };
            if (!AdjustWindowRectEx(&rect, style, FALSE, exstyle))
            {
                LogWin32LastError("AdjustWindowRectEx failed");
                style = WS_OVERLAPPEDWINDOW;
            }
            else
            {
                width = rect.right - rect.left;
                height = rect.bottom - rect.top;
            }
        }

        HWND wnd = CreateWindowExW(exstyle, wc.lpszClassName, L"D3D11 Window",
            style | WS_VISIBLE, CW_USEDEFAULT, CW_USEDEFAULT, width, height,
            NULL, NULL, wc.hInstance, NULL);
        if (!wnd)
        {
            LogWin32LastError("CreateWindow failed");
        }
        else
        {
            for (;;)
            {
                MSG msg;
                if (PeekMessageW(&msg, NULL, 0, 0, PM_REMOVE))
                {
                    if (msg.message == WM_QUIT)
                    {
                        break;
                    }
                    TranslateMessage(&msg);
                    DispatchMessageW(&msg);
                    continue;
                }

                RenderFrame();

                if (FAILED(RenderPresent(wnd)))
                {
                    break;
                }
            }
        }

        UnregisterClassW(wc.lpszClassName, wc.hInstance);
    }

    return 0;
}