1 files changed, 368 insertions, 0 deletions
diff --git a/dxg/src/imm.c b/dxg/src/imm.c
new file mode 100644
index 0000000..28baa99
--- /dev/null
+++ b/dxg/src/imm.c
@@ -0,0 +1,368 @@
+/* Immediate-mode renderer.
+Geometry is given by client code and buffered in an upload-heap buffer stored
+in host memory.
+When the buffer fills up or the client is done, a draw call is issued. The draw
+call reads directly from the buffer in host memory; there is no intermediate
+buffer copy.
+The renderer double-buffers two host-side buffers so that the client can
+continue specifying more data into a second buffer while the contents of the
+first buffer are rendered.
+If the first buffer is still being rendered while the client loops around, then
+the client must wait before issuing further geometry.
+Once the render of the first buffer completes, the process starts again,
+ping-ponging between the two buffers.*/
+#include <dxg/imm.h>
+#include <dxg/dxcommon.h>
+#include <imm_vs.h> // generated
+#include <imm_ps.h> // generated
+#define WIN32_LEAN_AND_MEAN
+#include <Windows.h> // OutputDebugStringA
+#include <stdint.h>
+#include <stdlib.h>
+static ID3D12Resource* create_buffer(ID3D12Device* pDevice, size_t size) {
+    assert(pDevice);
+    const D3D12_HEAP_PROPERTIES props = {
+        .Type                 = D3D12_HEAP_TYPE_UPLOAD,
+        .CPUPageProperty      = D3D12_CPU_PAGE_PROPERTY_UNKNOWN,
+        .MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN,
+        .CreationNodeMask     = 0,
+        .VisibleNodeMask      = 0
+    };
+    const D3D12_RESOURCE_DESC desc = {
+        .Dimension        = D3D12_RESOURCE_DIMENSION_BUFFER,
+        .Alignment        = D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT,
+        .Width            = size,
+        .Height           = 1,
+        .DepthOrArraySize = 1,
+        .MipLevels        = 1,
+        .Format           = DXGI_FORMAT_UNKNOWN,
+        .SampleDesc       = {.Count = 1, .Quality = 0},
+        .Layout           = D3D12_TEXTURE_LAYOUT_ROW_MAJOR,
+        .Flags            = D3D12_RESOURCE_FLAG_NONE
+    };
+    ID3D12Resource* pBuffer = NULL;
+    TrapIfFailed(pDevice->lpVtbl->CreateCommittedResource(
+        pDevice,
+        &props,
+        D3D12_HEAP_FLAG_NONE,
+        &desc,
+        D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER,
+        NULL,
+        &IID_ID3D12Resource,
+        &pBuffer));
+    return pBuffer;
+}
+typedef struct GraphicsState {
+    D3D12_VIEWPORT              viewport;
+    D3D12_CPU_DESCRIPTOR_HANDLE hBackBufferView;
+    D3D12_CPU_DESCRIPTOR_HANDLE hDepthStencilView;
+} GraphicsState;
+// Set of per-draw resources. The renderer cycles between sets per draw.
+typedef struct ResourceSet {
+    ID3D12Resource* pVertexBuffer;
+    CommandRecorder cmdRec;
+} ResourceSet;
+typedef struct DxgImm {
+    ID3D12Device*        pDevice;
+    ID3D12CommandQueue*  pCmdQueue;
+    ID3D12PipelineState* pPipelineState;
+    ID3D12RootSignature* pRootSignature;
+    GraphicsState        graphicsState;
+    ResourceSet          resources[2];
+    int                  cur; // Index to current resource set. New geometry written here.
+    float*               pCurrentBufferData; // Mapped region of current buffer.
+    size_t               bufferSizeVerts; // Num verts per buffer.
+    ID3D12Fence*         pFence;
+    HANDLE               fenceEvent;
+    uint64_t             fenceValue;
+    size_t               vertsWritten; // Verts written to current buffer.
+    bool                 wait; // Whether the next draw should wait.
+} DxgImm;
+static inline size_t vertex_size_bytes() {
+    return 3 * sizeof(float);
+}
+static inline size_t verts_byte_count(size_t numVerts) {
+    return numVerts * vertex_size_bytes();
+}
+static inline size_t dxg_imm_verts_left(const DxgImm* imm) {
+    assert(imm);
+    assert(imm->bufferSizeVerts >= imm->vertsWritten);
+    return imm->bufferSizeVerts - imm->vertsWritten;
+}
+static void dxg_imm_copy_verts(DxgImm* imm, const float* pVerts, size_t count) {
+    assert(imm);
+    assert(pVerts);
+    assert(count <= dxg_imm_verts_left(imm));
+    memcpy(&imm->pCurrentBufferData[imm->vertsWritten], pVerts, verts_byte_count(count));
+    imm->vertsWritten += count;
+}
+// Set up the current resource set for drawing.
+static void dxg_imm_set_up_resource_set(DxgImm* imm) {
+    assert(imm);
+    ResourceSet* const pResources = &imm->resources[imm->cur];
+    TrapIfFailed(pResources->pVertexBuffer->lpVtbl->Map(
+        pResources->pVertexBuffer, 0, NULL, &imm->pCurrentBufferData));
+    dxg_cmdrec_reset(&pResources->cmdRec);
+}
+// Move on to the next resource set.
+static ID3D12Resource* dxg_imm_next_resource_set(DxgImm* imm) {
+    assert(imm);
+    ResourceSet* const pResources = &imm->resources[imm->cur];
+    // Unmap the current buffer.
+    // TODO: Do we actually need to do this or can we leave it mapped? If the
+    // latter, then we could just map both buffers and let them be.
+    pResources->pVertexBuffer->lpVtbl->Unmap(pResources->pVertexBuffer, 0, NULL);
+    // Move on to the next resource set.
+    imm->cur = (imm->cur + 1) & 1;
+    imm->vertsWritten = 0;
+    // Set up the new resource set.
+    dxg_imm_set_up_resource_set(imm);
+}
+// Wait for the current buffer to be available for writing.
+static void dxg_imm_wait(DxgImm* imm) {
+    assert(imm);
+    assert(imm->wait);
+    // We only need to wait upon the first round around both buffers.
+    // First Signal is on fence value 1, 0 is not actually Signaled.
+    if (imm->fenceValue > 2) { // TODO: Do we need this check?
+        // The last buffer (not current) was Signaled with fenceValue - 1.
+        // The current buffer was therefore Signaled two fence values ago, or
+        // fenceValue - 2.
+        dxg_wait(imm->pFence, imm->fenceEvent, imm->fenceValue - 2);
+    }
+    imm->wait = false;
+}
+// Draw the current buffer.
+static void dxg_imm_draw(DxgImm* imm) {
+    assert(imm);
+    ResourceSet* const pResourceSet = &imm->resources[imm->cur];
+    ID3D12Resource* const pCurrentBuffer = pResourceSet->pVertexBuffer;
+    ID3D12GraphicsCommandList* const pCmdList = pResourceSet->cmdRec.pCmdList;
+    const D3D12_VIEWPORT* const pViewport = &imm->graphicsState.viewport;
+    const D3D12_RECT scissor = {
+        .bottom = pViewport->Height,
+        .left   = 0,
+        .right  = pViewport->Width,
+        .top    = 0,
+    };
+    const D3D12_VERTEX_BUFFER_VIEW vertexBufferView = {
+        .BufferLocation = pCurrentBuffer->lpVtbl->GetGPUVirtualAddress(pCurrentBuffer),
+        .SizeInBytes    = verts_byte_count(imm->vertsWritten),
+        .StrideInBytes  = vertex_size_bytes(),
+    };
+    pCmdList->lpVtbl->RSSetViewports(pCmdList, 1, pViewport);
+    pCmdList->lpVtbl->RSSetScissorRects(pCmdList, 1, &scissor);
+    pCmdList->lpVtbl->OMSetRenderTargets(
+        pCmdList, 1, &imm->graphicsState.hBackBufferView, false, &imm->graphicsState.hDepthStencilView);
+    pCmdList->lpVtbl->SetPipelineState(pCmdList, imm->pPipelineState);
+    pCmdList->lpVtbl->SetGraphicsRootSignature(pCmdList, imm->pRootSignature);
+    pCmdList->lpVtbl->IASetPrimitiveTopology(pCmdList, D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
+    pCmdList->lpVtbl->IASetVertexBuffers(pCmdList, 0, 1, &vertexBufferView);
+    pCmdList->lpVtbl->DrawInstanced(pCmdList, imm->vertsWritten, 1, 0, 0);
+    pCmdList->lpVtbl->Close(pCmdList);
+    ID3D12CommandList* const cmdLists[] = {(ID3D12CommandList*)pCmdList};
+    ID3D12CommandQueue* const pCmdQueue = imm->pCmdQueue;
+    pCmdQueue->lpVtbl->ExecuteCommandLists(pCmdQueue, 1, cmdLists);
+}
+DxgImm* dxg_imm_init(ID3D12Device* pDevice, ID3D12CommandQueue* pCmdQueue, DXGI_FORMAT swapChainRtvFormat, DXGI_SAMPLE_DESC swapChainSampleDesc, size_t bufferSizeVerts) {
+    assert(pDevice);
+    assert(pCmdQueue);
+    DxgImm* imm = calloc(1, sizeof(DxgImm));
+    if (!imm) {
+        return 0;
+    }
+    imm->pDevice         = pDevice;
+    imm->pCmdQueue       = pCmdQueue;
+    imm->bufferSizeVerts = bufferSizeVerts;
+    imm->fenceValue      = 0;
+    // TODO: Move this to the application side.
+    const D3D_SHADER_MODEL model = D3D_SHADER_MODEL_6_5;
+    D3D12_FEATURE_DATA_SHADER_MODEL shaderModel = { model };
+    HRESULT result = pDevice->lpVtbl->CheckFeatureSupport(
+        pDevice, D3D12_FEATURE_SHADER_MODEL, &shaderModel, sizeof(shaderModel));
+    if (FAILED(result) || (shaderModel.HighestShaderModel < model)) {
+        DEBUG_PRINT("ERROR: Shader Model 6.5 is not supported!\n");
+        TrapIfFailed(result);
+    }
+    const D3D12_SHADER_BYTECODE vs_bytecode = {
+        .pShaderBytecode = imm_vs,
+        .BytecodeLength  = sizeof(imm_vs)
+    };
+    const D3D12_SHADER_BYTECODE ps_bytecode = {
+        .pShaderBytecode = imm_ps,
+        .BytecodeLength  = sizeof(imm_ps)
+    };
+    // TODO: Find out how many root parameters to use.
+    // Let's do bindless rendering to keep things flexible.
+    const D3D12_ROOT_SIGNATURE_DESC rootsig_desc = {
+        .NumParameters     = 0,
+        .pParameters       = NULL,
+        .NumStaticSamplers = 0,
+        .pStaticSamplers   = NULL,
+        .Flags             = D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT
+    };
+    ID3DBlob* pRootSignature = NULL;
+    ID3DBlob* pErrors = NULL;
+    result = D3D12SerializeRootSignature(
+        &rootsig_desc,
+        D3D_ROOT_SIGNATURE_VERSION_1,
+        &pRootSignature,
+        &pErrors);
+    if (FAILED(result)) {
+        if (pErrors) {
+            DEBUG_PRINT(pErrors->lpVtbl->GetBufferPointer(pErrors));
+        }
+        TrapIfFailed(result);
+    }
+    TrapIfFailed(imm->pDevice->lpVtbl->CreateRootSignature(
+        imm->pDevice,
+        0,
+        pRootSignature->lpVtbl->GetBufferPointer(pRootSignature),
+        pRootSignature->lpVtbl->GetBufferSize(pRootSignature),
+        &IID_ID3D12RootSignature,
+        &imm->pRootSignature));
+    const D3D12_INPUT_ELEMENT_DESC input_layout[] = {
+        { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 }
+    };
+    const D3D12_INPUT_LAYOUT_DESC input_layout_desc = {
+        .pInputElementDescs = input_layout,
+        .NumElements        = COUNTOF(input_layout)
+    };
+    const D3D12_GRAPHICS_PIPELINE_STATE_DESC gpso = {
+        .pRootSignature        = imm->pRootSignature,
+        .VS                    = vs_bytecode,
+        .PS                    = ps_bytecode,
+        .BlendState            = CD3DX12_BLEND_DESC_DEFAULT(),
+        .SampleMask            = PointSampling,
+        .RasterizerState       = CD3DX12_RASTERIZER_DESC_DEFAULT(),
+        .InputLayout           = input_layout_desc,
+        .PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE,
+        .NumRenderTargets      = 1,
+        .RTVFormats            = {swapChainRtvFormat},
+        .SampleDesc            = swapChainSampleDesc
+    };
+    TrapIfFailed(imm->pDevice->lpVtbl->CreateGraphicsPipelineState(
+        imm->pDevice, &gpso, &IID_ID3D12PipelineState, &imm->pPipelineState));
+    const size_t bufferSize = verts_byte_count(bufferSizeVerts);
+    for (int i = 0; i < 2; ++i) {
+        imm->resources[i].pVertexBuffer = create_buffer(pDevice, bufferSize);
+        if (!imm->resources[i].pVertexBuffer) {
+            dxg_imm_destroy(&imm);
+        }
+        TrapIfFailed(dxg_cmdrec_init(&imm->resources[i].cmdRec, pDevice));
+    }
+    imm->cur = 0;
+    dxg_imm_set_up_resource_set(imm);
+    TrapIfFailed(pDevice->lpVtbl->CreateFence(
+        pDevice, imm->fenceValue, D3D12_FENCE_FLAG_NONE, &IID_ID3D12Fence, &imm->pFence));
+    if ((imm->fenceEvent = CreateEvent(NULL, FALSE, FALSE, NULL)) == NULL) {
+        TrapIfFailed(HRESULT_FROM_WIN32(GetLastError()));
+    }
+    return imm;
+}
+void dxg_imm_destroy(DxgImm** ppImm) {
+    assert(ppImm);
+    DxgImm* imm = *ppImm;
+    if (imm) {
+        for (int i = 0; i < 2; ++i) {
+            SafeRelease(imm->resources[i].pVertexBuffer);
+            dxg_cmdrec_destroy(&imm->resources[i].cmdRec);
+        }
+        SafeRelease(imm->pRootSignature);
+        SafeRelease(imm->pPipelineState);
+        SafeRelease(imm->pFence);
+        if (imm->fenceEvent != NULL) {
+            CloseHandle(imm->fenceEvent);
+        }
+        free(imm);
+        *ppImm = 0;
+    }
+}
+void dxg_imm_set_graphics_state(
+        DxgImm* imm,
+        const D3D12_VIEWPORT* pViewport,
+        D3D12_CPU_DESCRIPTOR_HANDLE hBackBufferView,
+        D3D12_CPU_DESCRIPTOR_HANDLE hDepthStencilView) {
+    assert(imm);
+    assert(pViewport);
+    assert(hBackBufferView.ptr);
+    assert(hDepthStencilView.ptr);
+    imm->graphicsState = (GraphicsState) {
+        .viewport          = *pViewport,
+        .hBackBufferView   = hBackBufferView,
+        .hDepthStencilView = hDepthStencilView,
+    };
+}
+void dxg_imm_flush(DxgImm* imm) {
+    assert(imm);
+    if (imm->vertsWritten > 0) {
+        dxg_imm_draw(imm);
+        // Signal the fence so that the current buffer can be reused once the
+        // draw has finished.
+        ID3D12CommandQueue* pCmdQueue = imm->pCmdQueue;
+        imm->fenceValue++;
+        pCmdQueue->lpVtbl->Signal(pCmdQueue, imm->pFence, imm->fenceValue);
+        // Next draw should Wait for the next buffer. Wait lazily on the next
+        // draw to avoid a stall here.
+        imm->wait = true;
+        dxg_imm_next_resource_set(imm);
+    }
+}
+void dxg_imm_draw_triangles(DxgImm* imm, const float* pVerts, size_t numTris) {
+    assert(imm);
+    assert(pVerts);
+    // TODO: This could be a loop to handle the case where the max buffer
+    // capacity cannot hold numTris. Or maybe we should rely on the caller
+    // to specify a big enough capacity, but that makes the API less
+    // friendly.
+    size_t triCapacity = dxg_imm_verts_left(imm) / 3;
+    if (triCapacity == 0) {
+        dxg_imm_flush(imm);
+    }
+    // If we just flushed the previous buffer, then we have to wait on the next
+    // one. The wait is done here, and not inside the branch above, because the
+    // client code can also flush the buffer.
+    if (imm->wait) {
+        dxg_imm_wait(imm);
+    }
+    // Re-evaluate capacity. It must be >0 now.
+    triCapacity = dxg_imm_verts_left(imm) / 3;
+    assert(triCapacity > 0);
+    const size_t numVerts = MIN(triCapacity, numTris) * 3;
+    dxg_imm_copy_verts(imm, pVerts, numVerts);
+}

diff --git a/dxg/src/imm.c b/dxg/src/imm.c new file mode 100644 index 0000000..28baa99 --- /dev/null +++ b/dxg/src/imm.c
@@ -0,0 +1,368 @@
	1	/* Immediate-mode renderer.
	2
	3	Geometry is given by client code and buffered in an upload-heap buffer stored
	4	in host memory.
	5	When the buffer fills up or the client is done, a draw call is issued. The draw
	6	call reads directly from the buffer in host memory; there is no intermediate
	7	buffer copy.
	8	The renderer double-buffers two host-side buffers so that the client can
	9	continue specifying more data into a second buffer while the contents of the
	10	first buffer are rendered.
	11	If the first buffer is still being rendered while the client loops around, then
	12	the client must wait before issuing further geometry.
	13	Once the render of the first buffer completes, the process starts again,
	14	ping-ponging between the two buffers.*/
	15	#include <dxg/imm.h>
	16	#include <dxg/dxcommon.h>
	17
	18	#include <imm_vs.h> // generated
	19	#include <imm_ps.h> // generated
	20
	21	#define WIN32_LEAN_AND_MEAN
	22	#include <Windows.h> // OutputDebugStringA
	23
	24	#include <stdint.h>
	25	#include <stdlib.h>
	26
	27	static ID3D12Resource* create_buffer(ID3D12Device* pDevice, size_t size) {
	28	assert(pDevice);
	29	const D3D12_HEAP_PROPERTIES props = {
	30	.Type = D3D12_HEAP_TYPE_UPLOAD,
	31	.CPUPageProperty = D3D12_CPU_PAGE_PROPERTY_UNKNOWN,
	32	.MemoryPoolPreference = D3D12_MEMORY_POOL_UNKNOWN,
	33	.CreationNodeMask = 0,
	34	.VisibleNodeMask = 0
	35	};
	36	const D3D12_RESOURCE_DESC desc = {
	37	.Dimension = D3D12_RESOURCE_DIMENSION_BUFFER,
	38	.Alignment = D3D12_DEFAULT_RESOURCE_PLACEMENT_ALIGNMENT,
	39	.Width = size,
	40	.Height = 1,
	41	.DepthOrArraySize = 1,
	42	.MipLevels = 1,
	43	.Format = DXGI_FORMAT_UNKNOWN,
	44	.SampleDesc = {.Count = 1, .Quality = 0},
	45	.Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR,
	46	.Flags = D3D12_RESOURCE_FLAG_NONE
	47	};
	48	ID3D12Resource* pBuffer = NULL;
	49	TrapIfFailed(pDevice->lpVtbl->CreateCommittedResource(
	50	pDevice,
	51	&props,
	52	D3D12_HEAP_FLAG_NONE,
	53	&desc,
	54	D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER,
	55	NULL,
	56	&IID_ID3D12Resource,
	57	&pBuffer));
	58	return pBuffer;
	59	}
	60
	61	typedef struct GraphicsState {
	62	D3D12_VIEWPORT viewport;
	63	D3D12_CPU_DESCRIPTOR_HANDLE hBackBufferView;
	64	D3D12_CPU_DESCRIPTOR_HANDLE hDepthStencilView;
	65	} GraphicsState;
	66
	67	// Set of per-draw resources. The renderer cycles between sets per draw.
	68	typedef struct ResourceSet {
	69	ID3D12Resource* pVertexBuffer;
	70	CommandRecorder cmdRec;
	71	} ResourceSet;
	72
	73	typedef struct DxgImm {
	74	ID3D12Device* pDevice;
	75	ID3D12CommandQueue* pCmdQueue;
	76	ID3D12PipelineState* pPipelineState;
	77	ID3D12RootSignature* pRootSignature;
	78	GraphicsState graphicsState;
	79	ResourceSet resources[2];
	80	int cur; // Index to current resource set. New geometry written here.
	81	float* pCurrentBufferData; // Mapped region of current buffer.
	82	size_t bufferSizeVerts; // Num verts per buffer.
	83	ID3D12Fence* pFence;
	84	HANDLE fenceEvent;
	85	uint64_t fenceValue;
	86	size_t vertsWritten; // Verts written to current buffer.
	87	bool wait; // Whether the next draw should wait.
	88	} DxgImm;
	89
	90	static inline size_t vertex_size_bytes() {
	91	return 3 * sizeof(float);
	92	}
	93
	94	static inline size_t verts_byte_count(size_t numVerts) {
	95	return numVerts * vertex_size_bytes();
	96	}
	97
	98	static inline size_t dxg_imm_verts_left(const DxgImm* imm) {
	99	assert(imm);
	100	assert(imm->bufferSizeVerts >= imm->vertsWritten);
	101	return imm->bufferSizeVerts - imm->vertsWritten;
	102	}
	103
	104	static void dxg_imm_copy_verts(DxgImm* imm, const float* pVerts, size_t count) {
	105	assert(imm);
	106	assert(pVerts);
	107	assert(count <= dxg_imm_verts_left(imm));
	108	memcpy(&imm->pCurrentBufferData[imm->vertsWritten], pVerts, verts_byte_count(count));
	109	imm->vertsWritten += count;
	110	}
	111
	112	// Set up the current resource set for drawing.
	113	static void dxg_imm_set_up_resource_set(DxgImm* imm) {
	114	assert(imm);
	115	ResourceSet* const pResources = &imm->resources[imm->cur];
	116	TrapIfFailed(pResources->pVertexBuffer->lpVtbl->Map(
	117	pResources->pVertexBuffer, 0, NULL, &imm->pCurrentBufferData));
	118	dxg_cmdrec_reset(&pResources->cmdRec);
	119	}
	120
	121	// Move on to the next resource set.
	122	static ID3D12Resource* dxg_imm_next_resource_set(DxgImm* imm) {
	123	assert(imm);
	124	ResourceSet* const pResources = &imm->resources[imm->cur];
	125	// Unmap the current buffer.
	126	// TODO: Do we actually need to do this or can we leave it mapped? If the
	127	// latter, then we could just map both buffers and let them be.
	128	pResources->pVertexBuffer->lpVtbl->Unmap(pResources->pVertexBuffer, 0, NULL);
	129	// Move on to the next resource set.
	130	imm->cur = (imm->cur + 1) & 1;
	131	imm->vertsWritten = 0;
	132	// Set up the new resource set.
	133	dxg_imm_set_up_resource_set(imm);
	134	}
	135
	136	// Wait for the current buffer to be available for writing.
	137	static void dxg_imm_wait(DxgImm* imm) {
	138	assert(imm);
	139	assert(imm->wait);
	140	// We only need to wait upon the first round around both buffers.
	141	// First Signal is on fence value 1, 0 is not actually Signaled.
	142	if (imm->fenceValue > 2) { // TODO: Do we need this check?
	143	// The last buffer (not current) was Signaled with fenceValue - 1.
	144	// The current buffer was therefore Signaled two fence values ago, or
	145	// fenceValue - 2.
	146	dxg_wait(imm->pFence, imm->fenceEvent, imm->fenceValue - 2);
	147	}
	148	imm->wait = false;
	149	}
	150
	151	// Draw the current buffer.
	152	static void dxg_imm_draw(DxgImm* imm) {
	153	assert(imm);
	154	ResourceSet* const pResourceSet = &imm->resources[imm->cur];
	155	ID3D12Resource* const pCurrentBuffer = pResourceSet->pVertexBuffer;
	156	ID3D12GraphicsCommandList* const pCmdList = pResourceSet->cmdRec.pCmdList;
	157	const D3D12_VIEWPORT* const pViewport = &imm->graphicsState.viewport;
	158	const D3D12_RECT scissor = {
	159	.bottom = pViewport->Height,
	160	.left = 0,
	161	.right = pViewport->Width,
	162	.top = 0,
	163	};
	164	const D3D12_VERTEX_BUFFER_VIEW vertexBufferView = {
	165	.BufferLocation = pCurrentBuffer->lpVtbl->GetGPUVirtualAddress(pCurrentBuffer),
	166	.SizeInBytes = verts_byte_count(imm->vertsWritten),
	167	.StrideInBytes = vertex_size_bytes(),
	168	};
	169	pCmdList->lpVtbl->RSSetViewports(pCmdList, 1, pViewport);
	170	pCmdList->lpVtbl->RSSetScissorRects(pCmdList, 1, &scissor);
	171	pCmdList->lpVtbl->OMSetRenderTargets(
	172	pCmdList, 1, &imm->graphicsState.hBackBufferView, false, &imm->graphicsState.hDepthStencilView);
	173	pCmdList->lpVtbl->SetPipelineState(pCmdList, imm->pPipelineState);
	174	pCmdList->lpVtbl->SetGraphicsRootSignature(pCmdList, imm->pRootSignature);
	175	pCmdList->lpVtbl->IASetPrimitiveTopology(pCmdList, D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
	176	pCmdList->lpVtbl->IASetVertexBuffers(pCmdList, 0, 1, &vertexBufferView);
	177	pCmdList->lpVtbl->DrawInstanced(pCmdList, imm->vertsWritten, 1, 0, 0);
	178	pCmdList->lpVtbl->Close(pCmdList);
	179	ID3D12CommandList* const cmdLists[] = {(ID3D12CommandList*)pCmdList};
	180	ID3D12CommandQueue* const pCmdQueue = imm->pCmdQueue;
	181	pCmdQueue->lpVtbl->ExecuteCommandLists(pCmdQueue, 1, cmdLists);
	182	}
	183
	184	DxgImm* dxg_imm_init(ID3D12Device* pDevice, ID3D12CommandQueue* pCmdQueue, DXGI_FORMAT swapChainRtvFormat, DXGI_SAMPLE_DESC swapChainSampleDesc, size_t bufferSizeVerts) {
	185	assert(pDevice);
	186	assert(pCmdQueue);
	187
	188	DxgImm* imm = calloc(1, sizeof(DxgImm));
	189	if (!imm) {
	190	return 0;
	191	}
	192
	193	imm->pDevice = pDevice;
	194	imm->pCmdQueue = pCmdQueue;
	195	imm->bufferSizeVerts = bufferSizeVerts;
	196	imm->fenceValue = 0;
	197
	198	// TODO: Move this to the application side.
	199	const D3D_SHADER_MODEL model = D3D_SHADER_MODEL_6_5;
	200	D3D12_FEATURE_DATA_SHADER_MODEL shaderModel = { model };
	201	HRESULT result = pDevice->lpVtbl->CheckFeatureSupport(
	202	pDevice, D3D12_FEATURE_SHADER_MODEL, &shaderModel, sizeof(shaderModel));
	203	if (FAILED(result) \|\| (shaderModel.HighestShaderModel < model)) {
	204	DEBUG_PRINT("ERROR: Shader Model 6.5 is not supported!\n");
	205	TrapIfFailed(result);
	206	}
	207
	208	const D3D12_SHADER_BYTECODE vs_bytecode = {
	209	.pShaderBytecode = imm_vs,
	210	.BytecodeLength = sizeof(imm_vs)
	211	};
	212
	213	const D3D12_SHADER_BYTECODE ps_bytecode = {
	214	.pShaderBytecode = imm_ps,
	215	.BytecodeLength = sizeof(imm_ps)
	216	};
	217
	218	// TODO: Find out how many root parameters to use.
	219	// Let's do bindless rendering to keep things flexible.
	220	const D3D12_ROOT_SIGNATURE_DESC rootsig_desc = {
	221	.NumParameters = 0,
	222	.pParameters = NULL,
	223	.NumStaticSamplers = 0,
	224	.pStaticSamplers = NULL,
	225	.Flags = D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT
	226	};
	227
	228	ID3DBlob* pRootSignature = NULL;
	229	ID3DBlob* pErrors = NULL;
	230	result = D3D12SerializeRootSignature(
	231	&rootsig_desc,
	232	D3D_ROOT_SIGNATURE_VERSION_1,
	233	&pRootSignature,
	234	&pErrors);
	235	if (FAILED(result)) {
	236	if (pErrors) {
	237	DEBUG_PRINT(pErrors->lpVtbl->GetBufferPointer(pErrors));
	238	}
	239	TrapIfFailed(result);
	240	}
	241
	242	TrapIfFailed(imm->pDevice->lpVtbl->CreateRootSignature(
	243	imm->pDevice,
	244	0,
	245	pRootSignature->lpVtbl->GetBufferPointer(pRootSignature),
	246	pRootSignature->lpVtbl->GetBufferSize(pRootSignature),
	247	&IID_ID3D12RootSignature,
	248	&imm->pRootSignature));
	249
	250	const D3D12_INPUT_ELEMENT_DESC input_layout[] = {
	251	{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 }
	252	};
	253	const D3D12_INPUT_LAYOUT_DESC input_layout_desc = {
	254	.pInputElementDescs = input_layout,
	255	.NumElements = COUNTOF(input_layout)
	256	};
	257
	258	const D3D12_GRAPHICS_PIPELINE_STATE_DESC gpso = {
	259	.pRootSignature = imm->pRootSignature,
	260	.VS = vs_bytecode,
	261	.PS = ps_bytecode,
	262	.BlendState = CD3DX12_BLEND_DESC_DEFAULT(),
	263	.SampleMask = PointSampling,
	264	.RasterizerState = CD3DX12_RASTERIZER_DESC_DEFAULT(),
	265	.InputLayout = input_layout_desc,
	266	.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE,
	267	.NumRenderTargets = 1,
	268	.RTVFormats = {swapChainRtvFormat},
	269	.SampleDesc = swapChainSampleDesc
	270	};
	271	TrapIfFailed(imm->pDevice->lpVtbl->CreateGraphicsPipelineState(
	272	imm->pDevice, &gpso, &IID_ID3D12PipelineState, &imm->pPipelineState));
	273
	274	const size_t bufferSize = verts_byte_count(bufferSizeVerts);
	275	for (int i = 0; i < 2; ++i) {
	276	imm->resources[i].pVertexBuffer = create_buffer(pDevice, bufferSize);
	277	if (!imm->resources[i].pVertexBuffer) {
	278	dxg_imm_destroy(&imm);
	279	}
	280	TrapIfFailed(dxg_cmdrec_init(&imm->resources[i].cmdRec, pDevice));
	281	}
	282	imm->cur = 0;
	283	dxg_imm_set_up_resource_set(imm);
	284
	285	TrapIfFailed(pDevice->lpVtbl->CreateFence(
	286	pDevice, imm->fenceValue, D3D12_FENCE_FLAG_NONE, &IID_ID3D12Fence, &imm->pFence));
	287
	288	if ((imm->fenceEvent = CreateEvent(NULL, FALSE, FALSE, NULL)) == NULL) {
	289	TrapIfFailed(HRESULT_FROM_WIN32(GetLastError()));
	290	}
	291
	292	return imm;
	293	}
	294
	295	void dxg_imm_destroy(DxgImm** ppImm) {
	296	assert(ppImm);
	297	DxgImm* imm = *ppImm;
	298	if (imm) {
	299	for (int i = 0; i < 2; ++i) {
	300	SafeRelease(imm->resources[i].pVertexBuffer);
	301	dxg_cmdrec_destroy(&imm->resources[i].cmdRec);
	302	}
	303	SafeRelease(imm->pRootSignature);
	304	SafeRelease(imm->pPipelineState);
	305	SafeRelease(imm->pFence);
	306	if (imm->fenceEvent != NULL) {
	307	CloseHandle(imm->fenceEvent);
	308	}
	309	free(imm);
	310	*ppImm = 0;
	311	}
	312	}
	313
	314	void dxg_imm_set_graphics_state(
	315	DxgImm* imm,
	316	const D3D12_VIEWPORT* pViewport,
	317	D3D12_CPU_DESCRIPTOR_HANDLE hBackBufferView,
	318	D3D12_CPU_DESCRIPTOR_HANDLE hDepthStencilView) {
	319	assert(imm);
	320	assert(pViewport);
	321	assert(hBackBufferView.ptr);
	322	assert(hDepthStencilView.ptr);
	323	imm->graphicsState = (GraphicsState) {
	324	.viewport = *pViewport,
	325	.hBackBufferView = hBackBufferView,
	326	.hDepthStencilView = hDepthStencilView,
	327	};
	328	}
	329
	330	void dxg_imm_flush(DxgImm* imm) {
	331	assert(imm);
	332	if (imm->vertsWritten > 0) {
	333	dxg_imm_draw(imm);
	334	// Signal the fence so that the current buffer can be reused once the
	335	// draw has finished.
	336	ID3D12CommandQueue* pCmdQueue = imm->pCmdQueue;
	337	imm->fenceValue++;
	338	pCmdQueue->lpVtbl->Signal(pCmdQueue, imm->pFence, imm->fenceValue);
	339	// Next draw should Wait for the next buffer. Wait lazily on the next
	340	// draw to avoid a stall here.
	341	imm->wait = true;
	342	dxg_imm_next_resource_set(imm);
	343	}
	344	}
	345
	346	void dxg_imm_draw_triangles(DxgImm* imm, const float* pVerts, size_t numTris) {
	347	assert(imm);
	348	assert(pVerts);
	349	// TODO: This could be a loop to handle the case where the max buffer
	350	// capacity cannot hold numTris. Or maybe we should rely on the caller
	351	// to specify a big enough capacity, but that makes the API less
	352	// friendly.
	353	size_t triCapacity = dxg_imm_verts_left(imm) / 3;
	354	if (triCapacity == 0) {
	355	dxg_imm_flush(imm);
	356	}
	357	// If we just flushed the previous buffer, then we have to wait on the next
	358	// one. The wait is done here, and not inside the branch above, because the
	359	// client code can also flush the buffer.
	360	if (imm->wait) {
	361	dxg_imm_wait(imm);
	362	}
	363	// Re-evaluate capacity. It must be >0 now.
	364	triCapacity = dxg_imm_verts_left(imm) / 3;
	365	assert(triCapacity > 0);
	366	const size_t numVerts = MIN(triCapacity, numTris) * 3;
	367	dxg_imm_copy_verts(imm, pVerts, numVerts);
	368	}