Immediate-mode renderer, triangle demo, shader compilation in cmake, Agility SDKHEADmain

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