9 files changed, 802 insertions, 25 deletions

diff --git a/dxg/CMakeLists.txt b/dxg/CMakeLists.txt
index b7607c0..1040276 100644
--- a/dxg/CMakeLists.txt
+++ b/dxg/CMakeLists.txt
@@ -2,22 +2,53 @@ cmake_minimum_required(VERSION 3.20)
 
 project(dxg)
 
+# Agility SDK.
+# Give AGILITY_SDK_BIN PARENT_SCOPE so that it is accessible from the
+# install_agility_sdk function below.
+set(AGILITY_SDK_DIR "../contrib/microsoft.direct3d.d3d12.1.618.4/build/native")
+set(AGILITY_SDK_BIN "${AGILITY_SDK_DIR}/bin/x64" PARENT_SCOPE)
+
+add_subdirectory(shaders)
+
 add_library(dxg
     include/dxg/dxcommon.h
-    src/dxg.c)
+    include/dxg/dxg.h
+    include/dxg/imm.h
+    src/dxcommon.c
+    src/imm.c)
+
+# exe must export these so that D3D12.dll can find and load D3D12Core.dll and
+# other DLLs from the Agility SDK.
+target_compile_definitions(dxg PRIVATE
+    AGILITY_SDK_VERSION=618 # Must match AGILITY_SDK_DIR above.
+    AGILITY_SDK_INSTALL=u8".\\\\D3D12\\\\") # Binaries will be copied to this subdirectory.
 
-# target_sources(dxg PUBLIC
-#     FILE_SET cxx_modules TYPE CXX_MODULES FILES
-#     asset.ixx
-#     dxcommon.ixx
-#     dxg.ixx
-#     imm.ixx)
+# Use BEFORE so that the D3D headers in the Agility SDK are picked before the
+# ones in the Windows SDK.
+target_include_directories(dxg BEFORE PUBLIC
+    include
+    ${AGILITY_SDK_DIR}/include)
 
-target_include_directories(dxg PUBLIC
-    include)
+target_link_directories(dxg BEFORE PUBLIC
+    ${AGILITY_SDK_DIR}/bin/x64)
 
 target_link_libraries(dxg PUBLIC
     DirectX-Headers
     D3D12.lib
     DXGI.lib
     DXGUID.lib) # For IID_Xyz symbols
+
+target_link_libraries(dxg PRIVATE
+    shaders)
+
+# Function to copy Agility SDK binaries to the D3D12\ directory next to the exe.
+# exe targets must call this function.
+function(install_agility_sdk exe_path)
+    cmake_path(APPEND d3d12_path ${exe_path} "D3D12")
+    if(NOT EXISTS ${d3d12_path})
+        message("D3D12 path = ${d3d12_path}")
+        message("AGILITY_SDK_BIN = ${AGILITY_SDK_BIN}")
+        file(MAKE_DIRECTORY ${d3d12_path})
+        file(COPY ${AGILITY_SDK_BIN}/ DESTINATION ${d3d12_path})
+    endif()
+endfunction()
diff --git a/dxg/include/dxg/dxcommon.h b/dxg/include/dxg/dxcommon.h
index bfcdbe8..96cf3a5 100644
--- a/dxg/include/dxg/dxcommon.h
+++ b/dxg/include/dxg/dxcommon.h
@@ -5,16 +5,57 @@
 #include <directx/d3dx12.h>
 
 #include <assert.h>
+#include <stdbool.h>
 #include <stdio.h>
+#include <stdlib.h>
+
+#define COUNTOF(ARR) (sizeof(ARR) / sizeof(ARR[0]))
+
+// MSVC currently has neither aligned_alloc nor alignof.
+//#define ALLOC(TYPE, COUNT) (TYPE*)aligned_alloc(alignof(TYPE), sizeof(TYPE) * (COUNT))
+
+typedef struct alloc_t {
+    void* base; // The result of malloc(). Pass this to free().
+    void* ptr;  // Aligned pointer within the allocation.
+} alloc_t;
+
+static inline bool is_pow2_or_0(size_t x) { return (x & (x - 1)) == 0; }
+
+static inline void* align(void* address, size_t alignment) {
+  assert(is_pow2_or_0(alignment));
+  const size_t mask = alignment - 1;
+  return (void*)(((uintptr_t)address + mask) & ~mask);
+}
+
+static inline alloc_t alloc_aligned(size_t size, size_t alignment) {
+    void* base = malloc(size + (alignment - 1));
+    return (alloc_t){.base = base, .ptr = align(base, alignment)};
+}
+
+static inline free_aligned(alloc_t* alloc) {
+    assert(alloc);
+    free(alloc->base);
+    *alloc = (alloc_t){0};
+}
+
+#define ALIGNOF(TYPE) _Alignof(TYPE)
+#define ALLOC(TYPE, COUNT) alloc_aligned(sizeof(TYPE) * (COUNT), ALIGNOF(TYPE))
+#define FREE(ALLOC) free_aligned(&(ALLOC))
+
+#ifndef NDEBUG
+#define DEBUG_PRINT OutputDebugStringA
+#else
+#define DEBUG_PRINT
+#endif
 
 #define TRAP(ERROR) { \
-    fprintf(stderr, "Error in file:[%s] line:%d: %s", __FILE__, __LINE__, ERROR);\
+    fprintf(stderr, "Error in file:[%s] line:%d: %s\n", __FILE__, __LINE__, ERROR);\
     assert(false);\
     __debugbreak();\
 }
 
 #define TRAP_HRESULT(RESULT) { \
-    fprintf(stderr, "HRESULT: %u", RESULT);\
+    fprintf(stderr, "HRESULT: 0x%x - ", RESULT);\
     TRAP("API call failed")\
 }
 
@@ -31,25 +72,52 @@
     }\
 }
 
+#define MIN(A, B) ((A) < (B) ? (A) : (B))
+
 #define CD3DX12_CPU_DESCRIPTOR_HANDLE(HANDLE, INDEX, SIZE) \
     (D3D12_CPU_DESCRIPTOR_HANDLE){HANDLE.ptr + (INDEX * SIZE)}
 
 #define OFFSET_HANDLE(HANDLE, OFFSET, SIZE) \
     (D3D12_CPU_DESCRIPTOR_HANDLE){HANDLE.ptr + (OFFSET * SIZE)}
 
-static inline D3D12_RESOURCE_BARRIER CD3DX12_RESOURCE_BARRIER_Transition(
-    _In_ ID3D12Resource*  pResource,
-    D3D12_RESOURCE_STATES stateBefore,
-    D3D12_RESOURCE_STATES stateAfter) {
-    return (D3D12_RESOURCE_BARRIER){
-        .Type                   = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION,
-        .Flags                  = D3D12_RESOURCE_BARRIER_FLAG_NONE,
-        .Transition.pResource   = pResource,
-        .Transition.StateBefore = stateBefore,
-        .Transition.StateAfter  = stateAfter,
-        .Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES};
-}
-
 typedef enum SampleMask {
     PointSampling = 0xffffffff
 } SampleMask;
+
+D3D12_RESOURCE_BARRIER CD3DX12_RESOURCE_BARRIER_Transition(
+    ID3D12Resource*       pResource,
+    D3D12_RESOURCE_STATES stateBefore,
+    D3D12_RESOURCE_STATES stateAfter);
+D3D12_RASTERIZER_DESC CD3DX12_RASTERIZER_DESC_DEFAULT();
+D3D12_BLEND_DESC CD3DX12_BLEND_DESC_DEFAULT();
+
+void dxg_wait(ID3D12Fence*, HANDLE fenceEvent, UINT64 fenceValue);
+
+// -----------------------------------------------------------------------------
+// Command Recorder
+// -----------------------------------------------------------------------------
+
+// Currently handling graphics command lists only.
+// Add compute when needed.
+typedef struct CommandRecorder {
+    ID3D12GraphicsCommandList* pCmdList;
+    ID3D12CommandAllocator*    pCmdAllocator;
+} CommandRecorder;
+
+HRESULT dxg_cmdrec_init(CommandRecorder*, ID3D12Device*);
+void    dxg_cmdrec_destroy(CommandRecorder*);
+HRESULT dxg_cmdrec_reset(CommandRecorder*);
+
+// -----------------------------------------------------------------------------
+// Upload Buffer
+// -----------------------------------------------------------------------------
+
+typedef struct UploadBuffer {
+    ID3D12Resource* pUploadBuffer;
+    size_t          size;
+} UploadBuffer;
+
+void dxg_upload_buffer_init(UploadBuffer*, ID3D12Device*, size_t size);
+void dxg_upload_buffer_destroy(UploadBuffer*, ID3D12Device*);
+void dxg_upload_buffer_load(UploadBuffer*, const void* pData, size_t bytes, ID3D12Resource* pDstBuffer);
+bool dxg_upload_buffer_done(UploadBuffer*);
diff --git a/dxg/include/dxg/dxg.h b/dxg/include/dxg/dxg.h
new file mode 100644
index 0000000..0982d9c
--- /dev/null
+++ b/dxg/include/dxg/dxg.h
@@ -0,0 +1,4 @@
+#pragma once
+
+#include <dxg/dxcommon.h>
+#include <dxg/imm.h>
diff --git a/dxg/include/dxg/imm.h b/dxg/include/dxg/imm.h
new file mode 100644
index 0000000..fdee725
--- /dev/null
+++ b/dxg/include/dxg/imm.h
@@ -0,0 +1,13 @@
+#pragma once
+
+#include <dxg/dxcommon.h>
+
+#include <stddef.h>
+
+typedef struct DxgImm DxgImm;
+
+DxgImm* dxg_imm_init(ID3D12Device* pDevice, ID3D12CommandQueue*, DXGI_FORMAT swapChainRtvFormat, DXGI_SAMPLE_DESC swapChainSampleDesc, size_t bufferSizeVerts);
+void    dxg_imm_destroy(DxgImm**);
+void    dxg_imm_set_graphics_state(DxgImm*, const D3D12_VIEWPORT*, D3D12_CPU_DESCRIPTOR_HANDLE hBackBufferView, D3D12_CPU_DESCRIPTOR_HANDLE hDepthStencilView);
+void    dxg_imm_flush(DxgImm*);
+void    dxg_imm_draw_triangles(DxgImm*, const float* pVerts, size_t numTris);
diff --git a/dxg/shaders/CMakeLists.txt b/dxg/shaders/CMakeLists.txt
new file mode 100644
index 0000000..c6ec687
--- /dev/null
+++ b/dxg/shaders/CMakeLists.txt
@@ -0,0 +1,98 @@
+set(SHADER_MODEL "6_5")
+set(DXC ${PROJECT_SOURCE_DIR}/../contrib/dxc_2025_07_14/bin/x64/dxc.exe)
+set(SHADERS_PATH ${CMAKE_CURRENT_SOURCE_DIR})
+set(BUILD_DIR "${CMAKE_CURRENT_BINARY_DIR}")
+
+# Compile HLSL to binary DXIL.
+#
+# This defines a custom command so that the shader is compiled at cmake build
+# instead of configure.
+#
+# hlsl_file:   "foo.hlsl"; just the file name, not the path.
+# shader_type: "vs", "ps", "cs", etc.
+# entry_point: "main", etc.
+function(compile_shader hlsl_file shader_type entry_point dxil_file)
+    #string(REPLACE ".hlsl" ".dxil" dxil_file ${hlsl_file})
+    set(hlsl_path "${SHADERS_PATH}/${hlsl_file}")
+    set(dxil_path "${BUILD_DIR}/${dxil_file}")
+    set(target_profile "${shader_type}_${SHADER_MODEL}")
+    message("COMPILING ${dxil_path}")
+    message("DXC = ${DXC}")
+    add_custom_command(
+        OUTPUT ${dxil_path}
+        COMMAND ${DXC} -T ${target_profile} -E ${entry_point} ${hlsl_path} -Fo ${dxil_path}
+        WORKING_DIRECTORY ${BUILD_DIR}
+        DEPENDS ${hlsl_path}
+        COMMENT "Generating ${dxil_path}")
+endfunction()
+
+# Inline a binary file into C code.
+# This is a workaround for the lack of C23 #embed in MSVC.
+#
+# identifier: Identifier to use for the global array that will contain the file,
+#             the generated file names, and the cmake target.
+# file_path:  Path to the binary file to embed.
+#
+# Reference: https://github.com/andoalon/embed-binaries
+function(generate_c file_path identifier out_header_path out_source_path)
+        file(READ "${file_path}" file_contents HEX)
+        string(LENGTH "${file_contents}" file_contents_length)
+        math(EXPR file_bytes "${file_contents_length} / 2")
+
+        set(bytes_per_line 32)
+    string(REPEAT "[0-9a-f]" ${bytes_per_line} column_pattern)
+    string(REGEX REPLACE "(${column_pattern})" "\\1\n" code "${file_contents}")
+    string(REGEX REPLACE "([0-9a-f][0-9a-f])" "0x\\1," code "${code}")
+
+        set(declaration "const uint8_t ${identifier}[${file_bytes}]")
+
+    string(APPEND header "#pragma once\n\n#include <stdint.h>\n\nextern ${declaration}\;\n")
+    string(APPEND implementation "#include \"${identifier}.h\"\n\n${declaration} = {\n${code}}\;\n")
+
+    file(WRITE "${BUILD_DIR}/${identifier}.h" ${header})
+    file(WRITE "${BUILD_DIR}/${identifier}.c" ${implementation})
+endfunction()
+
+# Create a target that embeds the given DXIL file in a C header/source.
+# Like compile_shader, this just adds the target so that the embedding is done
+# at cmake build and not configure.
+function(create_c_target dxil_file identifier)
+    set(dxil_path "${BUILD_DIR}/${dxil_file}")
+    string(REPLACE ".dxil" ".h" header_path ${dxil_path})
+    string(REPLACE ".dxil" ".c" source_path ${dxil_path})
+    add_custom_command(
+        OUTPUT "${header_path}" "${source_path}"
+        COMMAND ${CMAKE_COMMAND} -D dxil_path=${dxil_path} -D identifier=${identifier} -D out_header_path=${header_path} -D out_source_path=${source_path} -P ${CMAKE_CURRENT_LIST_FILE}
+        WORKING_DIRECTORY ${BUILD_DIR}
+        DEPENDS ${dxil_path}
+        COMMENT "Generating ${source_path}"
+    )
+endfunction()
+
+# Running in script mode.
+# https://stackoverflow.com/questions/51427538/cmake-test-if-i-am-in-scripting-mode
+#
+# When running in script mode, we embed the binary DXIL into a generated C file.
+if(CMAKE_SCRIPT_MODE_FILE AND NOT CMAKE_PARENT_LIST_FILE)
+    foreach(variable "dxil_path" "identifier" "out_header_path" "out_source_path")
+        if (NOT DEFINED ${variable})
+            message(FATAL_ERROR "'${variable}' is not defined")
+        endif()
+    endforeach()
+    generate_c("${dxil_path}" ${identifier} "${out_header_path}" "${out_source_path}")
+else()
+    compile_shader("imm.hlsl" "vs" "vs" "imm_vs.dxil")
+    compile_shader("imm.hlsl" "ps" "ps" "imm_ps.dxil")
+
+    create_c_target("imm_vs.dxil" "imm_vs")
+    create_c_target("imm_ps.dxil" "imm_ps")
+
+    add_library(shaders
+        "${BUILD_DIR}/imm_ps.c"
+        "${BUILD_DIR}/imm_ps.h"
+        "${BUILD_DIR}/imm_vs.c"
+        "${BUILD_DIR}/imm_vs.h")
+
+    target_include_directories(shaders PUBLIC
+        ${BUILD_DIR})
+endif()
diff --git a/dxg/shaders/imm.hlsl b/dxg/shaders/imm.hlsl
new file mode 100644
index 0000000..da6b1f6
--- /dev/null
+++ b/dxg/shaders/imm.hlsl
@@ -0,0 +1,23 @@
+struct VertexIn {
+    float3 position : POSITION;
+};
+
+struct VertexOut {
+    float4 position : SV_POSITION;
+};
+
+struct PixelOut {
+    float4 color : SV_TARGET;
+};
+
+VertexOut vs(VertexIn vin) {
+    VertexOut vout;
+    vout.position = float4(vin.position, 1.0f);
+    return vout;
+}
+
+PixelOut ps(VertexOut vout) {
+    PixelOut pixel;
+    pixel.color = float4(0.9f, 0.2f, 0.9f, 1.0f);
+    return pixel;
+}
diff --git a/dxg/src/dxcommon.c b/dxg/src/dxcommon.c
new file mode 100644
index 0000000..ecc9a88
--- /dev/null
+++ b/dxg/src/dxcommon.c
@@ -0,0 +1,173 @@
+#include <dxg/dxcommon.h>
+
+// Required so that D3D12.dll can find and load D3D12Core.dll and other DLLs
+// from the Agility SDK. The macro comes from CMakeLists.txt.
+__declspec(dllexport) extern const UINT  D3D12SDKVersion = AGILITY_SDK_VERSION;
+__declspec(dllexport) extern const char* D3D12SDKPath    = AGILITY_SDK_INSTALL;
+D3D12_RESOURCE_BARRIER CD3DX12_RESOURCE_BARRIER_Transition(
+    ID3D12Resource*       pResource,
+    D3D12_RESOURCE_STATES stateBefore,
+    D3D12_RESOURCE_STATES stateAfter) {
+    return (D3D12_RESOURCE_BARRIER){
+        .Type                   = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION,
+        .Flags                  = D3D12_RESOURCE_BARRIER_FLAG_NONE,
+        .Transition.pResource   = pResource,
+        .Transition.StateBefore = stateBefore,
+        .Transition.StateAfter  = stateAfter,
+        .Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES};
+}
+
+D3D12_RASTERIZER_DESC CD3DX12_RASTERIZER_DESC_DEFAULT() {
+    return (D3D12_RASTERIZER_DESC){
+        .FillMode              = D3D12_FILL_MODE_SOLID,
+        .CullMode              = D3D12_CULL_MODE_BACK,
+        .FrontCounterClockwise = FALSE,
+        .DepthBias             = D3D12_DEFAULT_DEPTH_BIAS,
+        .DepthBiasClamp        = D3D12_DEFAULT_DEPTH_BIAS_CLAMP,
+        .SlopeScaledDepthBias  = D3D12_DEFAULT_SLOPE_SCALED_DEPTH_BIAS,
+        .DepthClipEnable       = TRUE,
+        .MultisampleEnable     = FALSE,
+        .AntialiasedLineEnable = FALSE,
+        .ForcedSampleCount     = 0,
+        .ConservativeRaster    = D3D12_CONSERVATIVE_RASTERIZATION_MODE_OFF};
+}
+
+D3D12_BLEND_DESC CD3DX12_BLEND_DESC_DEFAULT() {
+    const D3D12_RENDER_TARGET_BLEND_DESC defaultRenderTargetBlendDesc = {
+        FALSE, FALSE,
+        D3D12_BLEND_ONE, D3D12_BLEND_ZERO, D3D12_BLEND_OP_ADD,
+        D3D12_BLEND_ONE, D3D12_BLEND_ZERO, D3D12_BLEND_OP_ADD,
+        D3D12_LOGIC_OP_NOOP,
+        D3D12_COLOR_WRITE_ENABLE_ALL,
+    };
+    D3D12_BLEND_DESC desc = {
+        .AlphaToCoverageEnable  = FALSE,
+        .IndependentBlendEnable = FALSE,
+    };
+    for (UINT i = 0; i < D3D12_SIMULTANEOUS_RENDER_TARGET_COUNT; ++i) {
+        desc.RenderTarget[i] = defaultRenderTargetBlendDesc;
+    }
+    return desc;
+}
+
+void dxg_wait(ID3D12Fence* pFence, HANDLE fenceEvent, UINT64 fenceValue) {
+    assert(pFence);
+    // Wait for commands to finish execution.
+    // It is possible that execution has already finished by the time we
+    // get here, so first check the fence's completed value.
+    if (pFence->lpVtbl->GetCompletedValue(pFence) < fenceValue) {
+        // GPU Signal still pending. Configure a Windows event and wait for it.
+        // The event fires when the GPU signals.
+        //
+        // Indicate that the fence event is to be fired when the fence reaches
+        // the given fence value.
+        TrapIfFailed(pFence->lpVtbl->SetEventOnCompletion(pFence, fenceValue, fenceEvent));
+        // Will wake up when the fence takes on the given fence value.
+        WaitForSingleObject(fenceEvent, INFINITE);
+    }
+}
+
+// -----------------------------------------------------------------------------
+// Command Recorder
+// -----------------------------------------------------------------------------
+
+HRESULT dxg_cmdrec_init(CommandRecorder* pRec, ID3D12Device* pDevice) {
+    assert(pRec);
+    assert(pDevice);
+
+    HRESULT result = S_OK;
+
+    const D3D12_COMMAND_LIST_TYPE type = D3D12_COMMAND_LIST_TYPE_DIRECT;
+
+    if ((result = pDevice->lpVtbl->CreateCommandAllocator(
+        pDevice, type, &IID_ID3D12CommandAllocator, &pRec->pCmdAllocator)) != S_OK) {
+        return result;
+    }
+
+    if ((result = pDevice->lpVtbl->CreateCommandList(
+        pDevice, 0, type, pRec->pCmdAllocator, NULL, &IID_ID3D12CommandList, &pRec->pCmdList)) != S_OK) {
+        return result;
+    }
+
+    // Command lists start open. Close it for API convenience.
+    if ((result = pRec->pCmdList->lpVtbl->Close(pRec->pCmdList)) != S_OK) {
+        return result;
+    }
+
+    return result;
+}
+
+void dxg_cmdrec_destroy(CommandRecorder* pRec) {
+    assert(pRec);
+    SafeRelease(pRec->pCmdList);
+    SafeRelease(pRec->pCmdAllocator);
+}
+
+HRESULT dxg_cmdrec_reset(CommandRecorder* pRec) {
+    assert(pRec);
+    assert(pRec->pCmdAllocator);
+    assert(pRec->pCmdList);
+    HRESULT result = S_OK;
+    if ((result = pRec->pCmdAllocator->lpVtbl->Reset(pRec->pCmdAllocator)) != S_OK) {
+        return result;
+    }
+    if ((result = pRec->pCmdList->lpVtbl->Reset(pRec->pCmdList, pRec->pCmdAllocator, NULL)) != S_OK) {
+        return result;
+    }
+    return result;
+}
+
+// -----------------------------------------------------------------------------
+// Upload Buffer
+// -----------------------------------------------------------------------------
+
+void dxg_upload_buffer_init(UploadBuffer* pBuf, ID3D12Device* pDevice, size_t size) {
+    assert(pBuf);
+    assert(pDevice);
+
+    pBuf->size = size;
+
+    const D3D12_HEAP_PROPERTIES props = {
+        .Type                 = D3D12_HEAP_TYPE_UPLOAD,
+        .CPUPageProperty      = D3D12_CPU_PAGE_PROPERTY_WRITE_COMBINE,
+        .MemoryPoolPreference = D3D12_MEMORY_POOL_L0,
+        .CreationNodeMask     = 0,
+        .VisibleNodeMask      = 0
+    };
+    // Constant buffers need to be aligned to 256 bytes. Other types of buffers
+    // do not have this requirement. To make the upload buffer general, use the
+    // worst-case alignment.
+    const D3D12_RESOURCE_DESC desc = {
+        .Dimension        = D3D12_RESOURCE_DIMENSION_BUFFER,
+        .Alignment        = 256,
+        .Width            = size,
+        .Height           = 0,
+        .DepthOrArraySize = 0,
+        .MipLevels        = 0,
+        .Format           = DXGI_FORMAT_UNKNOWN,
+        .SampleDesc       = (DXGI_SAMPLE_DESC){0},
+        .Layout           = D3D12_TEXTURE_LAYOUT_UNKNOWN,
+        .Flags            = D3D12_RESOURCE_FLAG_NONE
+    };
+    TrapIfFailed(pDevice->lpVtbl->CreateCommittedResource(
+        pDevice,
+        &props,
+        D3D12_HEAP_FLAG_NONE,
+        &desc,
+        D3D12_RESOURCE_STATE_COPY_SOURCE,
+        NULL,
+        &IID_ID3D12Resource,
+        &pBuf->pUploadBuffer));
+}
+
+void dxg_upload_buffer_destroy(UploadBuffer* pBuf, ID3D12Device* pDevice) {
+    assert(pDevice);
+    assert(pBuf);
+    SafeRelease(pBuf->pUploadBuffer);
+}
+
+void dxg_upload_buffer_load(UploadBuffer* pBuf, const void* pData, size_t bytes, ID3D12Resource* pDstBuffer) {
+    assert(pBuf);
+    assert(pData);
+    assert(pDstBuffer);
+}
diff --git a/dxg/src/dxg.c b/dxg/src/dxg.c
deleted file mode 100644
index e985d3d..0000000
--- a/dxg/src/dxg.c
+++ /dev/null
@@ -1 +0,0 @@
-int x = 2;
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);
+}