gitlab_snippets/mmozeiko/win32_d3d11.c

774 lines
25 KiB
C
Raw Normal View History

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