vkd3d-shader/hlsl: Set the "has_point_size" flag for vertex shaders outputting point sizes.

That's what the d3d-asm target expects in shader_print_dcl_usage(), and
what vkd3d_shader_scan() requires to create correct descriptor
information.

ChangeLog.md

@@ -1,3 +1,83 @@
+# What's new in vkd3d 1.17 (21 August 2025)
+
+### libvkd3d
+
+  - The EnumerateMetaCommands() method of the ID3D12Device5 interface is
+    implemented.
+
+### libvkd3d-shader
+
+  - Several new features and improvements for the HLSL source type:
+    - Initial thread group shared memory support.
+    - Improved support for geometry shaders: shader model 5 multiple output
+      streams, as well as SV_IsFrontFace, SV_RenderTargetArrayIndex, and
+      SV_ViewportArrayIndex outputs.
+    - Structure variable input/output semantics are propagated to the
+      constituent structure fields.
+    - Shader entry point return values are allocated before any other outputs
+      in the output signature. This matches d3dcompiler/fxc more closely.
+    - Hull shader control point pass-through.
+    - Reflection information can be retrieved using vkd3d_shader_scan().
+    - Improved preprocessor handling of comments inside include directives, as
+      well as inclusion of empty files.
+    - Memory barrier intrinsics are supported in shader model 4 target
+      profiles. Previous these were only supported in shader model 5 target
+      profiles.
+    - Parser support for the noise() intrinsic. Although the intrinsic itself
+      isn't implemented, parser support for the intrinsic is required to allow
+      compilation of any other shaders in the same source file to succeed as
+      well.
+    - Parser support for StructuredBuffer resources.
+
+  - Various new features and improvements for the effects (FX) source type:
+    - Shader blob assignments and FXLVM value expressions in ‘fx_2_0’ effects.
+    - Nameless structure types.
+    - Explicit constant buffer bind points and constant packing offsets.
+    - The ‘d3ds_noiseswiz’, ‘ge’, ‘lt’, and ‘noise’ FXLVM operations.
+
+  - The experimental Metal Shading Language (MSL) target supports the
+    following features:
+    - Texture sampling and gather operations.
+    - Loops and switches.
+    - Screen-space partial derivatives.
+    - Various integer arithmetic and comparison operations.
+    - Indirect addressing of constant buffers.
+    - Indexable temporary registers.
+    - Fragment shader output sample coverage masks.
+    - SV_Position and SV_SampleIndex fragment shader inputs.
+    - SV_VertexID inputs.
+
+  - When the experimental MSL target is enabled, the ‘dxbc-dxil’ source type
+    can be used in combination with the ‘msl’ target type to convert DXIL
+    shaders to MSL.
+
+  - The new ‘tx’ source type can be used in combination with the ‘d3d-asm’
+    target type to disassemble D3DX ‘tx_1_0’ texture shaders.
+
+  - The FX target takes alignment and padding into account in ‘fx_4_0’ buffer
+    size calculations.
+
+  - The SPIR-V target is capable of outputting OpSource and OpLine debug
+    information.
+
+  - The core grammar for the experimental SPIR-V disassembler has been updated
+    to the ‘vulkan-sdk-1.4.313.0’ release.
+
+  - New interfaces:
+    - The VKD3D_SHADER_SOURCE_TX source type specifies D3DX ‘tx_1_0’ texture
+      shaders.
+
+### vkd3d-compiler
+
+  - The new ‘tx’ source type specifies D3DX ‘tx_1_0’ texture shaders.
+
+### demos
+
+  - The new vkd3d-teapot demo uses tessellation shaders to render a version of
+    Martin Newell's famous teapot. It should be noted that current versions of
+    MoltenVK unfortunately do not support all features required to execute
+    this demo correctly.
+
 # What's new in vkd3d 1.16 (20 May 2025)
 
 ### libvkd3d

Makefile.am

@@ -140,6 +140,7 @@ vkd3d_shader_tests = \
 	tests/hlsl/fog.shader_test \
 	tests/hlsl/for.shader_test \
 	tests/hlsl/frac.shader_test \
+	tests/hlsl/frexp.shader_test \
 	tests/hlsl/function-cast.shader_test \
 	tests/hlsl/function-overload.shader_test \
 	tests/hlsl/function-return.shader_test \
@@ -199,6 +200,7 @@ vkd3d_shader_tests = \
 	tests/hlsl/multiple-rt.shader_test \
 	tests/hlsl/nested-arrays.shader_test \
 	tests/hlsl/nointerpolation.shader_test \
+	tests/hlsl/noise.shader_test \
 	tests/hlsl/non-const-indexing.shader_test \
 	tests/hlsl/normalize.shader_test \
 	tests/hlsl/null.shader_test \
@@ -214,6 +216,8 @@ vkd3d_shader_tests = \
 	tests/hlsl/pointer-cast.shader_test \
 	tests/hlsl/pow.shader_test \
 	tests/hlsl/precise-modifier.shader_test \
+	tests/hlsl/primitive-id.shader_test \
+	tests/hlsl/ps1-sampler.shader_test \
 	tests/hlsl/rasteriser-ordered-views.shader_test \
 	tests/hlsl/rcp.shader_test \
 	tests/hlsl/reflect.shader_test \
@@ -223,6 +227,7 @@ vkd3d_shader_tests = \
 	tests/hlsl/register-reservations-resources.shader_test \
 	tests/hlsl/register-reservations-space.shader_test \
 	tests/hlsl/return-implicit-conversion.shader_test \
+	tests/hlsl/return-semantics.shader_test \
 	tests/hlsl/return.shader_test \
 	tests/hlsl/round.shader_test \
 	tests/hlsl/rt-array-index.shader_test \
@@ -237,6 +242,7 @@ vkd3d_shader_tests = \
 	tests/hlsl/sampler.shader_test \
 	tests/hlsl/saturate.shader_test \
 	tests/hlsl/scope.shader_test \
+	tests/hlsl/semantic-cascading.shader_test \
 	tests/hlsl/shade-mode.shader_test \
 	tests/hlsl/shader-interstage-interface.shader_test \
 	tests/hlsl/shader-point-size.shader_test \
@@ -299,6 +305,7 @@ vkd3d_shader_tests = \
 	tests/hlsl/vector-indexing-uniform.shader_test \
 	tests/hlsl/vector-indexing.shader_test \
 	tests/hlsl/vertex-shader-ops.shader_test \
+	tests/hlsl/vp-array-index.shader_test \
 	tests/hlsl/wave-ops-float.shader_test \
 	tests/hlsl/wave-ops-int.shader_test \
 	tests/hlsl/wave-ops-uint.shader_test \
@@ -325,6 +332,7 @@ vkd3d_test_headers = \
 
 vkd3d_demos = \
 	demos/vkd3d-gears \
+	demos/vkd3d-teapot \
 	demos/vkd3d-triangle
 
 vkd3d_demos_headers = \
@@ -419,7 +427,7 @@ libvkd3d_shader_la_SOURCES = \
 	libs/vkd3d-shader/vkd3d_shader_main.c \
 	libs/vkd3d-shader/vkd3d_shader_private.h
 libvkd3d_shader_la_CFLAGS = $(AM_CFLAGS) -DLIBVKD3D_SHADER_SOURCE -I$(srcdir)/libs/vkd3d-shader @SPIRV_TOOLS_CFLAGS@
-libvkd3d_shader_la_LDFLAGS = $(AM_LDFLAGS) -version-info 15:0:14
+libvkd3d_shader_la_LDFLAGS = $(AM_LDFLAGS) -version-info 16:0:15
 libvkd3d_shader_la_LIBADD = libvkd3d-common.la @SPIRV_TOOLS_LIBS@ -lm
 if HAVE_LD_VERSION_SCRIPT
 libvkd3d_shader_la_LDFLAGS += -Wl,--version-script=$(srcdir)/libs/vkd3d-shader/vkd3d_shader.map
@@ -454,7 +462,7 @@ libvkd3d_la_SOURCES = \
 	libs/vkd3d/vkd3d_shaders.h \
 	libs/vkd3d/vulkan_procs.h
 libvkd3d_la_CFLAGS = $(AM_CFLAGS) -DLIBVKD3D_SOURCE
-libvkd3d_la_LDFLAGS = $(AM_LDFLAGS) -version-info 17:0:16
+libvkd3d_la_LDFLAGS = $(AM_LDFLAGS) -version-info 18:0:17
 libvkd3d_la_LIBADD = libvkd3d-common.la libvkd3d-shader.la @DL_LIBS@ @PTHREAD_LIBS@
 if HAVE_LD_VERSION_SCRIPT
 libvkd3d_la_LDFLAGS += -Wl,--version-script=$(srcdir)/libs/vkd3d/vkd3d.map
@@ -467,7 +475,7 @@ libvkd3d_utils_la_SOURCES = \
 	libs/vkd3d-utils/vkd3d_utils_main.c \
 	libs/vkd3d-utils/vkd3d_utils_private.h
 libvkd3d_utils_la_CFLAGS = $(AM_CFLAGS) -DLIBVKD3D_UTILS_SOURCE
-libvkd3d_utils_la_LDFLAGS = $(AM_LDFLAGS) -version-info 7:2:6
+libvkd3d_utils_la_LDFLAGS = $(AM_LDFLAGS) -version-info 7:3:6
 libvkd3d_utils_la_LIBADD = libvkd3d-common.la libvkd3d-shader.la libvkd3d.la @PTHREAD_LIBS@
 if HAVE_LD_VERSION_SCRIPT
 libvkd3d_utils_la_LDFLAGS += -Wl,--version-script=$(srcdir)/libs/vkd3d-utils/vkd3d_utils.map
@@ -549,6 +557,18 @@ demos_vkd3d_gears_CFLAGS = $(DEMOS_CFLAGS)
 demos_vkd3d_gears_LDADD = $(DEMOS_LDADD) -lm
 demos/vkd3d_gears-gears.$(OBJEXT): demos/gears.hlsl
 
+teapot_shaders = \
+	demos/teapot.hlsl \
+	demos/text.hlsl
+demos_vkd3d_teapot_SOURCES = \
+	$(teapot_shaders) \
+	demos/etl16-unicode.h \
+	demos/teapot.c \
+	demos/teapot.h
+demos_vkd3d_teapot_CFLAGS = $(DEMOS_CFLAGS)
+demos_vkd3d_teapot_LDADD = $(DEMOS_LDADD) -lm
+demos/vkd3d_teapot-teapot.$(OBJEXT): $(teapot_shaders)
+
 demos_vkd3d_triangle_SOURCES = demos/triangle.c demos/triangle.hlsl
 demos_vkd3d_triangle_CFLAGS = $(DEMOS_CFLAGS)
 demos_vkd3d_triangle_LDADD = $(DEMOS_LDADD)
@@ -657,6 +677,7 @@ endif
 if BUILD_DEMOS
 CROSS32_EXEFILES += $(vkd3d_demos:demos/vkd3d-%=demos/%.cross32.exe)
 demos/gears.cross32.exe: demos/gears.hlsl
+demos/teapot.cross32.exe: $(teapot_shaders)
 demos/triangle.cross32.exe: demos/triangle.hlsl
 endif
 
@@ -706,6 +727,7 @@ endif
 if BUILD_DEMOS
 CROSS64_EXEFILES += $(vkd3d_demos:demos/vkd3d-%=demos/%.cross64.exe)
 demos/gears.cross64.exe: demos/gears.hlsl
+demos/teapot.cross64.exe: $(teapot_shaders)
 demos/triangle.cross64.exe: demos/triangle.hlsl
 endif
 

configure.ac

@@ -1,5 +1,5 @@
 AC_PREREQ([2.69])
-AC_INIT([vkd3d],[1.16])
+AC_INIT([vkd3d],[1.17])
 
 AC_CONFIG_AUX_DIR([bin])
 AC_CONFIG_MACRO_DIR([m4])

demos/demo.h

@@ -38,6 +38,7 @@
 #define COBJMACROS
 #include <vkd3d_d3d12.h>
 #include <inttypes.h>
+#include <math.h>
 
 #ifdef __WIN32__
 #define DEMO_ASM_PUSHSECTION ".section rdata\n\t"
@@ -79,14 +80,27 @@
     extern const uint8_t name[]; \
     __asm__(DEMO_EMBED_ASM(DEMO_ASM_NAME(name), file))
 
+#if defined(__GNUC__) || defined(__clang__)
+# ifdef __MINGW_PRINTF_FORMAT
+#  define DEMO_PRINTF_FUNC(fmt, args) __attribute__((format(__MINGW_PRINTF_FORMAT, fmt, args)))
+# else
+#  define DEMO_PRINTF_FUNC(fmt, args) __attribute__((format(printf, fmt, args)))
+# endif
+#else
+# define DEMO_PRINTF_FUNC(fmt, args)
+#endif
+
 #define ARRAY_SIZE(x) (sizeof(x) / sizeof(*x))
 
-#define DEMO_KEY_UNKNOWN    0x0000
-#define DEMO_KEY_ESCAPE     0xff1b
-#define DEMO_KEY_LEFT       0xff51
-#define DEMO_KEY_UP         0xff52
-#define DEMO_KEY_RIGHT      0xff53
-#define DEMO_KEY_DOWN       0xff54
+#define DEMO_KEY_UNKNOWN        0x0000
+#define DEMO_KEY_ESCAPE         0xff1b
+#define DEMO_KEY_LEFT           0xff51
+#define DEMO_KEY_UP             0xff52
+#define DEMO_KEY_RIGHT          0xff53
+#define DEMO_KEY_DOWN           0xff54
+#define DEMO_KEY_KP_ADD         0xffab
+#define DEMO_KEY_KP_SUBTRACT    0xffad
+#define DEMO_KEY_F1             0xffbe
 
 struct demo_vec3
 {
@@ -98,6 +112,26 @@ struct demo_vec4
     float x, y, z, w;
 };
 
+struct demo_uvec2
+{
+    uint32_t x, y;
+};
+
+struct demo_uvec4
+{
+    uint32_t x, y, z, w;
+};
+
+struct demo_matrix
+{
+    float m[4][4];
+};
+
+struct demo_patch
+{
+    uint16_t p[4][4];
+};
+
 struct demo_swapchain_desc
 {
     unsigned int width;
@@ -115,6 +149,36 @@ static inline void demo_vec3_set(struct demo_vec3 *v, float x, float y, float z)
     v->z = z;
 }
 
+static inline void demo_vec3_subtract(struct demo_vec3 *v, const struct demo_vec3 *a, const struct demo_vec3 *b)
+{
+    demo_vec3_set(v, a->x - b->x, a->y - b->y, a->z - b->z);
+}
+
+static inline float demo_vec3_dot(const struct demo_vec3 *a, const struct demo_vec3 *b)
+{
+    return a->x * b->x + a->y * b->y + a->z * b->z;
+}
+
+static inline float demo_vec3_length(const struct demo_vec3 *v)
+{
+    return sqrtf(demo_vec3_dot(v, v));
+}
+
+static inline void demo_vec3_scale(struct demo_vec3 *v, const struct demo_vec3 *a, float s)
+{
+    demo_vec3_set(v, a->x * s, a->y * s, a->z *s);
+}
+
+static inline void demo_vec3_normalise(struct demo_vec3 *v, const struct demo_vec3 *a)
+{
+    demo_vec3_scale(v, a, 1.0f / demo_vec3_length(a));
+}
+
+static inline void demo_vec3_cross(struct demo_vec3 *v, const struct demo_vec3 *a, const struct demo_vec3 *b)
+{
+    demo_vec3_set(v, a->y * b->z - a->z * b->y, a->z * b->x - a->x * b->z, a->x * b->y - a->y * b->x);
+}
+
 static inline void demo_vec4_set(struct demo_vec4 *v, float x, float y, float z, float w)
 {
     v->x = x;
@@ -123,6 +187,60 @@ static inline void demo_vec4_set(struct demo_vec4 *v, float x, float y, float z,
     v->w = w;
 }
 
+static inline void demo_matrix_look_at_rh(struct demo_matrix *m, const struct demo_vec3 *eye,
+        const struct demo_vec3 *ref, const struct demo_vec3 *up)
+{
+    struct demo_vec3 f, s, t, u;
+
+    demo_vec3_subtract(&f, eye, ref);
+    demo_vec3_normalise(&f, &f);
+    demo_vec3_cross(&s, up, &f);
+    demo_vec3_normalise(&s, &s);
+    demo_vec3_cross(&u, &f, &s);
+    demo_vec3_set(&t, demo_vec3_dot(&s, eye), demo_vec3_dot(&u, eye), demo_vec3_dot(&f, eye));
+
+    *m = (struct demo_matrix)
+    {{
+        { s.x,  u.x,  f.x, 0.0f},
+        { s.y,  u.y,  f.y, 0.0f},
+        { s.z,  u.z,  f.z, 0.0f},
+        {-t.x, -t.y, -t.z, 1.0f},
+    }};
+}
+
+static inline void demo_matrix_multiply(struct demo_matrix *out,
+        const struct demo_matrix *a, const struct demo_matrix *b)
+{
+    unsigned int i, j;
+
+    for (i = 0; i < 4; ++i)
+    {
+        for (j = 0; j < 4; ++j)
+        {
+            out->m[i][j] = a->m[i][0] * b->m[0][j]
+                    + a->m[i][1] * b->m[1][j]
+                    + a->m[i][2] * b->m[2][j]
+                    + a->m[i][3] * b->m[3][j];
+        }
+    }
+}
+
+static inline void demo_matrix_perspective_rh(struct demo_matrix *m, float w, float h, float z_near, float z_far)
+{
+    float sx = 2.0 * z_near / w;
+    float sy = 2.0 * z_near / h;
+    float sz = z_far / (z_near - z_far);
+    float d = z_near * sz;
+
+    *m = (struct demo_matrix)
+    {{
+        {  sx, 0.0f, 0.0f,  0.0f},
+        {0.0f,   sy, 0.0f,  0.0f},
+        {0.0f, 0.0f,   sz, -1.0f},
+        {0.0f, 0.0f,    d,  0.0f},
+    }};
+}
+
 static inline void demo_rasterizer_desc_init_default(D3D12_RASTERIZER_DESC *desc)
 {
     desc->FillMode = D3D12_FILL_MODE_SOLID;

demos/demo_d3d12.h

@@ -70,6 +70,8 @@ static inline void demo_window_cleanup(struct demo_window *window)
 struct demo_swapchain
 {
     IDXGISwapChain3 *swapchain;
+    unsigned int buffer_count;
+    char device_name[128];
 };
 
 static inline void demo_cleanup(struct demo *demo)
@@ -97,6 +99,11 @@ static inline void demo_get_dpi(struct demo *demo, double *dpi_x, double *dpi_y)
     demo_win32_get_dpi(demo, dpi_x, dpi_y);
 }
 
+static inline const char *demo_get_platform_name(void)
+{
+    return "Direct3D 12";
+}
+
 static inline void demo_process_events(struct demo *demo)
 {
     demo_win32_process_events(demo);
@@ -137,9 +144,14 @@ static inline struct demo_swapchain *demo_swapchain_create(ID3D12CommandQueue *c
     struct demo_window_win32 *window_win32 = CONTAINING_RECORD(window, struct demo_window_win32, w);
     DXGI_SWAP_CHAIN_DESC1 swapchain_desc;
     struct demo_swapchain *swapchain;
+    DXGI_ADAPTER_DESC adapter_desc;
     IDXGISwapChain1 *swapchain1;
     IDXGIFactory2 *factory;
+    IDXGIAdapter *adapter;
+    ID3D12Device *device;
+    unsigned int i;
     HRESULT hr;
+    LUID luid;
 
     if (!(swapchain = malloc(sizeof(*swapchain))))
         return NULL;
@@ -147,6 +159,27 @@ static inline struct demo_swapchain *demo_swapchain_create(ID3D12CommandQueue *c
     if (FAILED(CreateDXGIFactory1(&IID_IDXGIFactory2, (void **)&factory)))
         goto fail;
 
+    if (FAILED(ID3D12CommandQueue_GetDevice(command_queue, &IID_ID3D12Device, (void **)&device)))
+        goto fail;
+    luid = ID3D12Device_GetAdapterLuid(device);
+    ID3D12Device_Release(device);
+
+    sprintf(swapchain->device_name, "Unknown");
+    for (i = 0; IDXGIFactory2_EnumAdapters(factory, i, &adapter) == S_OK; ++i)
+    {
+        hr = IDXGIAdapter_GetDesc(adapter, &adapter_desc);
+        IDXGIAdapter_Release(adapter);
+        if (FAILED(hr))
+            continue;
+
+        if (adapter_desc.AdapterLuid.LowPart == luid.LowPart
+                && adapter_desc.AdapterLuid.HighPart == luid.HighPart)
+        {
+            snprintf(swapchain->device_name, ARRAY_SIZE(swapchain->device_name), "%ls", adapter_desc.Description);
+            break;
+        }
+    }
+
     memset(&swapchain_desc, 0, sizeof(swapchain_desc));
     swapchain_desc.BufferCount = desc->buffer_count;
     swapchain_desc.Width = desc->width;
@@ -162,6 +195,7 @@ static inline struct demo_swapchain *demo_swapchain_create(ID3D12CommandQueue *c
     if (FAILED(hr))
         goto fail;
 
+    swapchain->buffer_count = desc->buffer_count;
     hr = IDXGISwapChain1_QueryInterface(swapchain1, &IID_IDXGISwapChain3, (void **)&swapchain->swapchain);
     IDXGISwapChain1_Release(swapchain1);
     if (FAILED(hr))
@@ -174,6 +208,11 @@ fail:
     return NULL;
 }
 
+static inline const char *demo_swapchain_get_device_name(struct demo_swapchain *swapchain)
+{
+    return swapchain->device_name;
+}
+
 static inline unsigned int demo_swapchain_get_current_back_buffer_index(struct demo_swapchain *swapchain)
 {
     return IDXGISwapChain3_GetCurrentBackBufferIndex(swapchain->swapchain);
@@ -190,6 +229,11 @@ static inline ID3D12Resource *demo_swapchain_get_back_buffer(struct demo_swapcha
     return buffer;
 }
 
+static inline unsigned int demo_swapchain_get_back_buffer_count(struct demo_swapchain *swapchain)
+{
+    return swapchain->buffer_count;
+}
+
 static inline void demo_swapchain_present(struct demo_swapchain *swapchain)
 {
     IDXGISwapChain3_Present(swapchain->swapchain, 1, 0);

demos/demo_macos.h

@@ -176,12 +176,19 @@ static demo_key demo_key_from_nsevent(id event)
 {
     enum vkey
     {
-        kVK_ANSI_A      = 0x00,
-        kVK_Escape      = 0x35,
-        kVK_LeftArrow   = 0x7b,
-        kVK_RightArrow  = 0x7c,
-        kVK_DownArrow   = 0x7d,
-        kVK_UpArrow     = 0x7e,
+        kVK_ANSI_A              = 0x00,
+        kVK_ANSI_F              = 0x03,
+        kVK_ANSI_W              = 0x0d,
+        kVK_ANSI_Equal          = 0x18,
+        kVK_ANSI_Minus          = 0x1b,
+        kVK_Escape              = 0x35,
+        kVK_ANSI_KeypadPlus     = 0x45,
+        kVK_ANSI_KeypadMinus    = 0x4e,
+        kVK_F1                  = 0x7a,
+        kVK_LeftArrow           = 0x7b,
+        kVK_RightArrow          = 0x7c,
+        kVK_DownArrow           = 0x7d,
+        kVK_UpArrow             = 0x7e,
     } vkey;
     size_t i;
 
@@ -192,12 +199,19 @@ static demo_key demo_key_from_nsevent(id event)
     }
     lookup[] =
     {
-        {kVK_ANSI_A,        'a'},
-        {kVK_Escape,        DEMO_KEY_ESCAPE},
-        {kVK_LeftArrow,     DEMO_KEY_LEFT},
-        {kVK_RightArrow,    DEMO_KEY_RIGHT},
-        {kVK_UpArrow,       DEMO_KEY_UP},
-        {kVK_DownArrow,     DEMO_KEY_DOWN},
+        {kVK_ANSI_A,            'a'},
+        {kVK_ANSI_F,            'f'},
+        {kVK_ANSI_W,            'w'},
+        {kVK_ANSI_Equal,        '='},
+        {kVK_ANSI_Minus,        '-'},
+        {kVK_Escape,            DEMO_KEY_ESCAPE},
+        {kVK_ANSI_KeypadPlus,   DEMO_KEY_KP_ADD},
+        {kVK_ANSI_KeypadMinus,  DEMO_KEY_KP_SUBTRACT},
+        {kVK_F1,                DEMO_KEY_F1},
+        {kVK_LeftArrow,         DEMO_KEY_LEFT},
+        {kVK_RightArrow,        DEMO_KEY_RIGHT},
+        {kVK_DownArrow,         DEMO_KEY_DOWN},
+        {kVK_UpArrow,           DEMO_KEY_UP},
     };
 
     vkey = NSEvent_keyCode(event);

demos/demo_vkd3d.h

@@ -28,7 +28,7 @@
 #ifdef HAVE_XCB
 # define VK_USE_PLATFORM_XCB_KHR
 #endif
-#define VKD3D_UTILS_API_VERSION VKD3D_API_VERSION_1_16
+#define VKD3D_UTILS_API_VERSION VKD3D_API_VERSION_1_17
 #include <vkd3d.h>
 #include <vkd3d_utils.h>
 #ifdef HAVE_XCB
@@ -59,6 +59,7 @@ DECLARE_VK_PFN(vkCreateXcbSurfaceKHR)
 DECLARE_VK_PFN(vkDestroyFence)
 DECLARE_VK_PFN(vkDestroySurfaceKHR)
 DECLARE_VK_PFN(vkDestroySwapchainKHR)
+DECLARE_VK_PFN(vkGetPhysicalDeviceProperties)
 DECLARE_VK_PFN(vkGetPhysicalDeviceSurfaceCapabilitiesKHR)
 DECLARE_VK_PFN(vkGetPhysicalDeviceSurfaceFormatsKHR)
 DECLARE_VK_PFN(vkGetPhysicalDeviceSurfaceSupportKHR)
@@ -228,6 +229,7 @@ static void load_vulkan_procs(void)
     LOAD_VK_PFN(vkDestroyFence)
     LOAD_VK_PFN(vkDestroySurfaceKHR)
     LOAD_VK_PFN(vkDestroySwapchainKHR)
+    LOAD_VK_PFN(vkGetPhysicalDeviceProperties)
     LOAD_VK_PFN(vkGetPhysicalDeviceSurfaceCapabilitiesKHR)
     LOAD_VK_PFN(vkGetPhysicalDeviceSurfaceFormatsKHR)
     LOAD_VK_PFN(vkGetPhysicalDeviceSurfaceSupportKHR)
@@ -239,6 +241,7 @@ static void load_vulkan_procs(void)
 
 struct demo_swapchain
 {
+    VkPhysicalDeviceProperties vk_device_properties;
     VkSurfaceKHR vk_surface;
     VkSwapchainKHR vk_swapchain;
     VkFence vk_fence;
@@ -310,6 +313,11 @@ static inline void demo_get_dpi(struct demo *demo, double *dpi_x, double *dpi_y)
     demo->get_dpi(demo, dpi_x, dpi_y);
 }
 
+static inline const char *demo_get_platform_name(void)
+{
+    return "vkd3d";
+}
+
 static inline void demo_process_events(struct demo *demo)
 {
     demo->process_events(demo);
@@ -392,9 +400,13 @@ static inline struct demo_swapchain *demo_swapchain_create(ID3D12CommandQueue *c
     if (vkGetPhysicalDeviceSurfaceCapabilitiesKHR(vk_physical_device, vk_surface, &surface_caps) < 0)
         goto fail;
 
-    if ((surface_caps.maxImageCount && desc->buffer_count > surface_caps.maxImageCount)
-            || desc->buffer_count < surface_caps.minImageCount
-            || desc->width > surface_caps.maxImageExtent.width || desc->width < surface_caps.minImageExtent.width
+    image_count = desc->buffer_count;
+    if (image_count < surface_caps.minImageCount)
+        image_count = surface_caps.minImageCount;
+    else if (surface_caps.maxImageCount && image_count > surface_caps.maxImageCount)
+        image_count = surface_caps.maxImageCount;
+
+    if (desc->width > surface_caps.maxImageExtent.width || desc->width < surface_caps.minImageExtent.width
             || desc->height > surface_caps.maxImageExtent.height || desc->height < surface_caps.minImageExtent.height
             || !(surface_caps.supportedCompositeAlpha & VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR))
         goto fail;
@@ -432,7 +444,7 @@ static inline struct demo_swapchain *demo_swapchain_create(ID3D12CommandQueue *c
     vk_swapchain_desc.pNext = NULL;
     vk_swapchain_desc.flags = 0;
     vk_swapchain_desc.surface = vk_surface;
-    vk_swapchain_desc.minImageCount = desc->buffer_count;
+    vk_swapchain_desc.minImageCount = image_count;
     vk_swapchain_desc.imageFormat = format;
     vk_swapchain_desc.imageColorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR;
     vk_swapchain_desc.imageExtent.width = desc->width;
@@ -471,6 +483,7 @@ static inline struct demo_swapchain *demo_swapchain_create(ID3D12CommandQueue *c
         free(vk_images);
         goto fail;
     }
+    vkGetPhysicalDeviceProperties(vk_physical_device, &swapchain->vk_device_properties);
     swapchain->vk_surface = vk_surface;
     swapchain->vk_swapchain = vk_swapchain;
     swapchain->vk_fence = vk_fence;
@@ -540,6 +553,11 @@ fail:
     return NULL;
 }
 
+static inline const char *demo_swapchain_get_device_name(struct demo_swapchain *swapchain)
+{
+    return swapchain->vk_device_properties.deviceName;
+}
+
 static inline unsigned int demo_swapchain_get_current_back_buffer_index(struct demo_swapchain *swapchain)
 {
     return swapchain->current_buffer;
@@ -555,6 +573,11 @@ static inline ID3D12Resource *demo_swapchain_get_back_buffer(struct demo_swapcha
     return resource;
 }
 
+static inline unsigned int demo_swapchain_get_back_buffer_count(struct demo_swapchain *swapchain)
+{
+    return swapchain->buffer_count;
+}
+
 static inline void demo_swapchain_present(struct demo_swapchain *swapchain)
 {
     VkPresentInfoKHR present_desc;

demos/demo_win32.h

@@ -127,18 +127,23 @@ static demo_key demo_key_from_win32_vkey(DWORD vkey)
     }
     lookup[] =
     {
-        {VK_ESCAPE, DEMO_KEY_ESCAPE},
-        {VK_LEFT,   DEMO_KEY_LEFT},
-        {VK_RIGHT,  DEMO_KEY_RIGHT},
-        {VK_UP,     DEMO_KEY_UP},
-        {VK_DOWN,   DEMO_KEY_DOWN},
+        {VK_OEM_MINUS,  '-'},
+        {VK_OEM_PLUS,   '='},
+        {VK_ESCAPE,     DEMO_KEY_ESCAPE},
+        {VK_LEFT,       DEMO_KEY_LEFT},
+        {VK_UP,         DEMO_KEY_UP},
+        {VK_RIGHT,      DEMO_KEY_RIGHT},
+        {VK_DOWN,       DEMO_KEY_DOWN},
+        {VK_ADD,        DEMO_KEY_KP_ADD},
+        {VK_SUBTRACT,   DEMO_KEY_KP_SUBTRACT},
+        {VK_F1,         DEMO_KEY_F1},
     };
     unsigned int i;
 
     if (vkey >= '0' && vkey <= '9')
         return vkey;
     if (vkey >= 'A' && vkey <= 'Z')
-        return vkey;
+        return vkey + 0x20;
 
     for (i = 0; i < ARRAY_SIZE(lookup); ++i)
     {

demos/etl16-unicode.h

@@ -0,0 +1,145 @@
+/*
+ * Copyright 2025 Henri Verbeet
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+/* The glyph data is derived from etl16-unicode.bdf as found on
+ * ftp://ftp.ring.gr.jp/pub/X/opengroup/contrib/fonts/etl-unicode.tar.gz
+ * with the following license:
+ *
+ *     Public domain font. Share and enjoy.
+ */
+
+/* Each line in etl16_unicode[] below contains the bitmap data for a single
+ * 8x16 glyph, starting at ASCII 0x20 (space). Each byte corresponds to a
+ * single line in the glyph.
+ *
+ * The BDF bitmap data is essentially the same format we're using here, so we
+ * could have extracted the glyphs manually, or perhaps using a small script.
+ * However, bdf2psf can do most of the work for us, by creating a PSF1 font
+ * from the BDF.
+ *
+ * A PSF1 font has a 4 byte header, followed by at least 256 glyphs.
+ * For a 8x16 font, each glyph consists of 16 bytes, one byte for each row.
+ *
+ * We're not interested in control characters or extended ASCII, so we skip
+ * the first 0x4 (header) + 0x20 (control characters) * 0x10 = 516 bytes, and
+ * extract the next (0x80 - 0x20) * 0x10 = 1536 bytes:
+ *
+ *     bdf2psf etl16-unicode.bdf standard.equivalents ascii.set 256 /dev/stdout | xxd -i -c 16 -s 516 -l 1536
+ *
+ * and we're done.
+ */
+
+static const uint8_t etl16_unicode[] =
+{
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 0x08, 0x08, 0x00, 0x00,
+    0x00, 0x00, 0x66, 0x22, 0x22, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x12, 0x12, 0x12, 0x7e, 0x24, 0x24, 0x7e, 0x48, 0x48, 0x48, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x08, 0x3e, 0x49, 0x48, 0x38, 0x0e, 0x09, 0x49, 0x3e, 0x08, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x31, 0x4a, 0x4a, 0x34, 0x08, 0x08, 0x16, 0x29, 0x29, 0x46, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x1c, 0x22, 0x22, 0x22, 0x1c, 0x39, 0x45, 0x42, 0x46, 0x39, 0x00, 0x00,
+    0x00, 0x00, 0x18, 0x08, 0x08, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x04, 0x08, 0x08, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x08, 0x08, 0x04, 0x00,
+    0x00, 0x00, 0x00, 0x20, 0x10, 0x10, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x10, 0x10, 0x20, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x49, 0x2a, 0x1c, 0x2a, 0x49, 0x08, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x08, 0x7f, 0x08, 0x08, 0x08, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x08, 0x08, 0x10,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x02, 0x02, 0x04, 0x08, 0x08, 0x10, 0x10, 0x20, 0x40, 0x40, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x18, 0x24, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x24, 0x18, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x08, 0x18, 0x28, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x3e, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x3c, 0x42, 0x42, 0x02, 0x0c, 0x10, 0x20, 0x40, 0x40, 0x7e, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x3c, 0x42, 0x42, 0x02, 0x1c, 0x02, 0x02, 0x42, 0x42, 0x3c, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x04, 0x0c, 0x14, 0x24, 0x44, 0x44, 0x7e, 0x04, 0x04, 0x04, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x7e, 0x40, 0x40, 0x40, 0x7c, 0x02, 0x02, 0x02, 0x42, 0x3c, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x1c, 0x20, 0x40, 0x40, 0x7c, 0x42, 0x42, 0x42, 0x42, 0x3c, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x7e, 0x02, 0x02, 0x04, 0x04, 0x04, 0x08, 0x08, 0x08, 0x08, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x3c, 0x42, 0x42, 0x42, 0x3c, 0x42, 0x42, 0x42, 0x42, 0x3c, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x3c, 0x42, 0x42, 0x42, 0x3e, 0x02, 0x02, 0x02, 0x04, 0x38, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x18, 0x08, 0x08, 0x10, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x04, 0x08, 0x10, 0x20, 0x10, 0x08, 0x04, 0x02, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x20, 0x10, 0x08, 0x04, 0x08, 0x10, 0x20, 0x40, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x3c, 0x42, 0x42, 0x02, 0x04, 0x08, 0x08, 0x00, 0x08, 0x08, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x1c, 0x22, 0x4a, 0x56, 0x52, 0x52, 0x52, 0x4e, 0x20, 0x1e, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x18, 0x24, 0x24, 0x42, 0x42, 0x7e, 0x42, 0x42, 0x42, 0x42, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x7c, 0x42, 0x42, 0x42, 0x7c, 0x42, 0x42, 0x42, 0x42, 0x7c, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x3c, 0x42, 0x42, 0x40, 0x40, 0x40, 0x40, 0x42, 0x42, 0x3c, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x78, 0x44, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x44, 0x78, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x7e, 0x40, 0x40, 0x40, 0x7c, 0x40, 0x40, 0x40, 0x40, 0x7e, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x7e, 0x40, 0x40, 0x40, 0x7c, 0x40, 0x40, 0x40, 0x40, 0x40, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x3c, 0x42, 0x42, 0x40, 0x40, 0x4e, 0x42, 0x42, 0x46, 0x3a, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x42, 0x42, 0x42, 0x42, 0x7e, 0x42, 0x42, 0x42, 0x42, 0x42, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x3e, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x3e, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x1f, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x44, 0x44, 0x38, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x42, 0x44, 0x48, 0x50, 0x60, 0x60, 0x50, 0x48, 0x44, 0x42, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x7e, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x42, 0x42, 0x66, 0x66, 0x5a, 0x5a, 0x42, 0x42, 0x42, 0x42, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x42, 0x62, 0x62, 0x52, 0x52, 0x4a, 0x4a, 0x46, 0x46, 0x42, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x3c, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x3c, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x7c, 0x42, 0x42, 0x42, 0x7c, 0x40, 0x40, 0x40, 0x40, 0x40, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x3c, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x5a, 0x66, 0x3c, 0x03, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x7c, 0x42, 0x42, 0x42, 0x7c, 0x48, 0x44, 0x44, 0x42, 0x42, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x3c, 0x42, 0x42, 0x40, 0x30, 0x0c, 0x02, 0x42, 0x42, 0x3c, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x7f, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x3c, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x41, 0x41, 0x41, 0x22, 0x22, 0x22, 0x14, 0x14, 0x08, 0x08, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x42, 0x42, 0x42, 0x42, 0x5a, 0x5a, 0x66, 0x66, 0x42, 0x42, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x42, 0x42, 0x24, 0x24, 0x18, 0x18, 0x24, 0x24, 0x42, 0x42, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x41, 0x41, 0x22, 0x22, 0x14, 0x08, 0x08, 0x08, 0x08, 0x08, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x7e, 0x02, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x40, 0x7e, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0e, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x0e, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x40, 0x40, 0x20, 0x10, 0x10, 0x08, 0x08, 0x04, 0x02, 0x02, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x70, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x70, 0x00,
+    0x00, 0x00, 0x18, 0x24, 0x42, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0x00,
+    0x00, 0x00, 0x18, 0x10, 0x10, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x42, 0x02, 0x3e, 0x42, 0x42, 0x46, 0x3a, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x40, 0x40, 0x40, 0x5c, 0x62, 0x42, 0x42, 0x42, 0x42, 0x62, 0x5c, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x42, 0x40, 0x40, 0x40, 0x40, 0x42, 0x3c, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x02, 0x02, 0x02, 0x3a, 0x46, 0x42, 0x42, 0x42, 0x42, 0x46, 0x3a, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x42, 0x42, 0x7e, 0x40, 0x40, 0x42, 0x3c, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0c, 0x10, 0x10, 0x10, 0x7c, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x3a, 0x44, 0x44, 0x44, 0x38, 0x20, 0x3c, 0x42, 0x42, 0x3c,
+    0x00, 0x00, 0x00, 0x40, 0x40, 0x40, 0x5c, 0x62, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x08, 0x08, 0x00, 0x18, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x3e, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x04, 0x04, 0x00, 0x0c, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x48, 0x30,
+    0x00, 0x00, 0x00, 0x00, 0x40, 0x40, 0x44, 0x48, 0x50, 0x60, 0x50, 0x48, 0x44, 0x42, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x18, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x3e, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0x49, 0x49, 0x49, 0x49, 0x49, 0x49, 0x49, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5c, 0x62, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x3c, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5c, 0x62, 0x42, 0x42, 0x42, 0x42, 0x62, 0x5c, 0x40, 0x40,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3a, 0x46, 0x42, 0x42, 0x42, 0x42, 0x46, 0x3a, 0x02, 0x02,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5c, 0x62, 0x42, 0x40, 0x40, 0x40, 0x40, 0x40, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x42, 0x40, 0x30, 0x0c, 0x02, 0x42, 0x3c, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x10, 0x10, 0x7c, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x0c, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x46, 0x3a, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x42, 0x42, 0x42, 0x24, 0x24, 0x24, 0x18, 0x18, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x41, 0x49, 0x49, 0x49, 0x49, 0x49, 0x49, 0x36, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x42, 0x42, 0x24, 0x18, 0x18, 0x24, 0x42, 0x42, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x42, 0x42, 0x42, 0x42, 0x42, 0x26, 0x1a, 0x02, 0x02, 0x3c,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x7e, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x0c, 0x10, 0x10, 0x08, 0x08, 0x10, 0x10, 0x08, 0x08, 0x10, 0x10, 0x0c, 0x00,
+    0x00, 0x00, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
+    0x00, 0x00, 0x00, 0x30, 0x08, 0x08, 0x10, 0x10, 0x08, 0x08, 0x10, 0x10, 0x08, 0x08, 0x30, 0x00,
+    0x00, 0x00, 0x00, 0x31, 0x49, 0x46, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0xfc, 0x1b, 0x26, 0xef, 0xc8, 0xe0, 0x43, 0x20, 0x89, 0x58, 0x62, 0x5e, 0x79, 0xba, 0xee, 0x7e,
+};

demos/gears.c

@@ -45,7 +45,6 @@
 #include <sys/time.h>
 #include <assert.h>
 #include <stdio.h>
-#include <math.h>
 #include "demo.h"
 
 DEMO_EMBED(gears_hlsl, "gears.hlsl");
@@ -59,7 +58,7 @@ struct cxg_fence
 
 struct cxg_cb_data
 {
-    float mvp_matrix[16];
+    struct demo_matrix mvp_matrix;
     float normal_matrix[12];
 };
 
@@ -120,14 +119,17 @@ struct cx_gears
     ID3D12Device *device;
     ID3D12CommandQueue *command_queue;
     struct demo_swapchain *swapchain;
+    struct
+    {
+        ID3D12Resource *render_target;
+        ID3D12CommandAllocator *command_allocator;
+        ID3D12GraphicsCommandList *command_list;
+    } *swapchain_images;
     ID3D12DescriptorHeap *rtv_heap, *dsv_heap;
     unsigned int rtv_descriptor_size;
-    ID3D12Resource *render_targets[3];
-    ID3D12CommandAllocator *command_allocator[3];
 
     ID3D12RootSignature *root_signature;
     ID3D12PipelineState *pipeline_state_smooth, *pipeline_state_flat;
-    ID3D12GraphicsCommandList *command_list[3];
     ID3D12Resource *ds, *cb, *vb[2], *ib;
     D3D12_VERTEX_BUFFER_VIEW vbv[2];
     D3D12_INDEX_BUFFER_VIEW ibv;
@@ -142,7 +144,7 @@ struct cx_gears
 
 static void cxg_populate_command_list(struct cx_gears *cxg, unsigned int rt_idx)
 {
-    ID3D12GraphicsCommandList *command_list = cxg->command_list[rt_idx];
+    ID3D12GraphicsCommandList *command_list = cxg->swapchain_images[rt_idx].command_list;
     static const float clear_colour[] = {0.0f, 0.0f, 0.0f, 1.0f};
 
     D3D12_CPU_DESCRIPTOR_HANDLE rtv_handle, dsv_handle;
@@ -150,10 +152,11 @@ static void cxg_populate_command_list(struct cx_gears *cxg, unsigned int rt_idx)
     HRESULT hr;
     size_t i;
 
-    hr = ID3D12CommandAllocator_Reset(cxg->command_allocator[rt_idx]);
+    hr = ID3D12CommandAllocator_Reset(cxg->swapchain_images[rt_idx].command_allocator);
     assert(SUCCEEDED(hr));
 
-    hr = ID3D12GraphicsCommandList_Reset(command_list, cxg->command_allocator[rt_idx], cxg->pipeline_state_flat);
+    hr = ID3D12GraphicsCommandList_Reset(command_list,
+            cxg->swapchain_images[rt_idx].command_allocator, cxg->pipeline_state_flat);
     assert(SUCCEEDED(hr));
 
     ID3D12GraphicsCommandList_SetGraphicsRootSignature(command_list, cxg->root_signature);
@@ -165,7 +168,7 @@ static void cxg_populate_command_list(struct cx_gears *cxg, unsigned int rt_idx)
 
     barrier.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION;
     barrier.Flags = D3D12_RESOURCE_BARRIER_FLAG_NONE;
-    barrier.Transition.pResource = cxg->render_targets[rt_idx];
+    barrier.Transition.pResource = cxg->swapchain_images[rt_idx].render_target;
     barrier.Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES;
     barrier.Transition.StateBefore = D3D12_RESOURCE_STATE_PRESENT;
     barrier.Transition.StateAfter = D3D12_RESOURCE_STATE_RENDER_TARGET;
@@ -226,44 +229,24 @@ static void cxg_wait_for_previous_frame(struct cx_gears *cxg)
 
 static void cxg_update_mvp(struct cx_gears *cxg)
 {
+    struct demo_matrix projection, world;
     float s1 = sinf(cxg->theta);
     float c1 = cosf(cxg->theta);
     float s2 = sinf(cxg->phi);
     float c2 = cosf(cxg->phi);
     float z_offset = -40.0f;
-    float z_max = 60.0f;
-    float z_min = 5.0f;
-    float sx = z_min;
-    float sy = z_min * cxg->aspect_ratio;
-    float sz = -((z_max + z_min) / (z_max - z_min));
-    float d = (-2.0f * z_max * z_min) / (z_max - z_min);
-    unsigned int i, j;
-    float world[] =
-    {
-          c1,  s2 * s1, c2 * -s1, 0.0f,
-        0.0f,       c2,       s2, 0.0f,
-          s1, -s2 * c1,  c2 * c1, 0.0f,
-        0.0f,     0.0f, z_offset, 1.0f,
-    };
-    float projection[] =
-    {
-          sx, 0.0f, 0.0f,  0.0f,
-        0.0f,   sy, 0.0f,  0.0f,
-        0.0f, 0.0f,   sz, -1.0f,
-        0.0f, 0.0f,    d,  0.0f,
-    };
 
-    for (i = 0; i < 4; ++i)
-    {
-        for (j = 0; j < 4; ++j)
-        {
-            cxg->cb_data->mvp_matrix[i * 4 + j] = projection[j] * world[i * 4]
-                    + projection[j +  4] * world[i * 4 + 1]
-                    + projection[j +  8] * world[i * 4 + 2]
-                    + projection[j + 12] * world[i * 4 + 3];
-        }
-    }
-    memcpy(cxg->cb_data->normal_matrix, world, sizeof(cxg->cb_data->normal_matrix));
+    world = (struct demo_matrix)
+    {{
+        {  c1,  s2 * s1, c2 * -s1, 0.0f},
+        {0.0f,       c2,       s2, 0.0f},
+        {  s1, -s2 * c1,  c2 * c1, 0.0f},
+        {0.0f,     0.0f, z_offset, 1.0f},
+    }};
+    demo_matrix_perspective_rh(&projection, 2.0f, 2.0f / cxg->aspect_ratio, 5.0f, 60.0f);
+
+    demo_matrix_multiply(&cxg->cb_data->mvp_matrix, &world, &projection);
+    memcpy(cxg->cb_data->normal_matrix, &world, sizeof(cxg->cb_data->normal_matrix));
 }
 
 static void cxg_render_frame(struct cx_gears *cxg)
@@ -295,7 +278,7 @@ static void cxg_render_frame(struct cx_gears *cxg)
     demo_vec4_set(&cxg->instance_data[2].transform, cosf(a), sinf(a), -3.1f,  4.2f);
 
     ID3D12CommandQueue_ExecuteCommandLists(cxg->command_queue, 1,
-            (ID3D12CommandList **)&cxg->command_list[cxg->rt_idx]);
+            (ID3D12CommandList **)&cxg->swapchain_images[cxg->rt_idx].command_list);
     demo_swapchain_present(cxg->swapchain);
     cxg_wait_for_previous_frame(cxg);
 }
@@ -304,16 +287,14 @@ static void cxg_destroy_pipeline(struct cx_gears *cxg)
 {
     unsigned int i;
 
-    for (i = 0; i < ARRAY_SIZE(cxg->command_allocator); ++i)
-    {
-        ID3D12CommandAllocator_Release(cxg->command_allocator[i]);
-    }
-    for (i = 0; i < ARRAY_SIZE(cxg->render_targets); ++i)
-    {
-        ID3D12Resource_Release(cxg->render_targets[i]);
-    }
     ID3D12DescriptorHeap_Release(cxg->dsv_heap);
     ID3D12DescriptorHeap_Release(cxg->rtv_heap);
+    for (i = 0; i < demo_swapchain_get_back_buffer_count(cxg->swapchain); ++i)
+    {
+        ID3D12CommandAllocator_Release(cxg->swapchain_images[i].command_allocator);
+        ID3D12Resource_Release(cxg->swapchain_images[i].render_target);
+    }
+    free(cxg->swapchain_images);
     demo_swapchain_destroy(cxg->swapchain);
     ID3D12CommandQueue_Release(cxg->command_queue);
     ID3D12Device_Release(cxg->device);
@@ -325,7 +306,7 @@ static void cxg_load_pipeline(struct cx_gears *cxg)
     D3D12_CPU_DESCRIPTOR_HANDLE rtv_handle;
     D3D12_DESCRIPTOR_HEAP_DESC heap_desc;
     D3D12_COMMAND_QUEUE_DESC queue_desc;
-    unsigned int i;
+    unsigned int i, rt_count;
     HRESULT hr;
 
     hr = D3D12CreateDevice(NULL, D3D_FEATURE_LEVEL_11_0, &IID_ID3D12Device, (void **)&cxg->device);
@@ -338,16 +319,19 @@ static void cxg_load_pipeline(struct cx_gears *cxg)
             &IID_ID3D12CommandQueue, (void **)&cxg->command_queue);
     assert(SUCCEEDED(hr));
 
-    swapchain_desc.buffer_count = ARRAY_SIZE(cxg->render_targets);
+    swapchain_desc.buffer_count = 3;
     swapchain_desc.format = DXGI_FORMAT_B8G8R8A8_UNORM;
     swapchain_desc.width = cxg->width;
     swapchain_desc.height = cxg->height;
     cxg->swapchain = demo_swapchain_create(cxg->command_queue, cxg->window, &swapchain_desc);
     assert(cxg->swapchain);
+    rt_count = demo_swapchain_get_back_buffer_count(cxg->swapchain);
+    cxg->swapchain_images = calloc(rt_count, sizeof(*cxg->swapchain_images));
+    assert(cxg->swapchain_images);
     cxg->rt_idx = demo_swapchain_get_current_back_buffer_index(cxg->swapchain);
 
     memset(&heap_desc, 0, sizeof(heap_desc));
-    heap_desc.NumDescriptors = ARRAY_SIZE(cxg->render_targets);
+    heap_desc.NumDescriptors = rt_count;
     heap_desc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_RTV;
     heap_desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE;
     hr = ID3D12Device_CreateDescriptorHeap(cxg->device, &heap_desc,
@@ -357,10 +341,10 @@ static void cxg_load_pipeline(struct cx_gears *cxg)
     cxg->rtv_descriptor_size = ID3D12Device_GetDescriptorHandleIncrementSize(cxg->device,
             D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
     rtv_handle = ID3D12DescriptorHeap_GetCPUDescriptorHandleForHeapStart(cxg->rtv_heap);
-    for (i = 0; i < ARRAY_SIZE(cxg->render_targets); ++i)
+    for (i = 0; i < rt_count; ++i)
     {
-        cxg->render_targets[i] = demo_swapchain_get_back_buffer(cxg->swapchain, i);
-        ID3D12Device_CreateRenderTargetView(cxg->device, cxg->render_targets[i], NULL, rtv_handle);
+        cxg->swapchain_images[i].render_target = demo_swapchain_get_back_buffer(cxg->swapchain, i);
+        ID3D12Device_CreateRenderTargetView(cxg->device, cxg->swapchain_images[i].render_target, NULL, rtv_handle);
         rtv_handle.ptr += cxg->rtv_descriptor_size;
     }
 
@@ -371,10 +355,10 @@ static void cxg_load_pipeline(struct cx_gears *cxg)
             &IID_ID3D12DescriptorHeap, (void **)&cxg->dsv_heap);
     assert(SUCCEEDED(hr));
 
-    for (i = 0; i < ARRAY_SIZE(cxg->command_allocator); ++i)
+    for (i = 0; i < rt_count; ++i)
     {
         hr = ID3D12Device_CreateCommandAllocator(cxg->device, D3D12_COMMAND_LIST_TYPE_DIRECT,
-                &IID_ID3D12CommandAllocator, (void **)&cxg->command_allocator[i]);
+                &IID_ID3D12CommandAllocator, (void **)&cxg->swapchain_images[i].command_allocator);
         assert(SUCCEEDED(hr));
     }
 }
@@ -397,8 +381,8 @@ static void cxg_destroy_assets(struct cx_gears *cxg)
     ID3D12Resource_Unmap(cxg->cb, 0, NULL);
     ID3D12Resource_Release(cxg->cb);
     ID3D12Resource_Release(cxg->ds);
-    for (i = 0; i < ARRAY_SIZE(cxg->command_list); ++i)
-        ID3D12GraphicsCommandList_Release(cxg->command_list[i]);
+    for (i = 0; i < demo_swapchain_get_back_buffer_count(cxg->swapchain); ++i)
+        ID3D12GraphicsCommandList_Release(cxg->swapchain_images[i].command_list);
     ID3D12PipelineState_Release(cxg->pipeline_state_smooth);
     ID3D12PipelineState_Release(cxg->pipeline_state_flat);
     ID3D12RootSignature_Release(cxg->root_signature);
@@ -727,13 +711,13 @@ static void cxg_load_assets(struct cx_gears *cxg)
     ID3D10Blob_Release(ps_flat);
     ID3D10Blob_Release(ps_smooth);
 
-    for (i = 0; i < ARRAY_SIZE(cxg->command_list); ++i)
+    for (i = 0; i < demo_swapchain_get_back_buffer_count(cxg->swapchain); ++i)
     {
         hr = ID3D12Device_CreateCommandList(cxg->device, 0, D3D12_COMMAND_LIST_TYPE_DIRECT,
-                cxg->command_allocator[i], cxg->pipeline_state_flat,
-                &IID_ID3D12GraphicsCommandList, (void **)&cxg->command_list[i]);
+                cxg->swapchain_images[i].command_allocator, cxg->pipeline_state_flat,
+                &IID_ID3D12GraphicsCommandList, (void **)&cxg->swapchain_images[i].command_list);
         assert(SUCCEEDED(hr));
-        hr = ID3D12GraphicsCommandList_Close(cxg->command_list[i]);
+        hr = ID3D12GraphicsCommandList_Close(cxg->swapchain_images[i].command_list);
         assert(SUCCEEDED(hr));
     }
 
@@ -808,7 +792,6 @@ static void cxg_key_press(struct demo_window *window, demo_key key, void *user_d
     switch (key)
     {
         case 'a':
-        case 'A':
             cxg->animate = !cxg->animate;
             break;
         case DEMO_KEY_ESCAPE:
@@ -850,6 +833,7 @@ static int cxg_main(void)
     unsigned int width = 300, height = 300;
     struct cx_gears cxg;
     double dpi_x, dpi_y;
+    size_t i;
 
     memset(&cxg, 0, sizeof(cxg));
     if (!demo_init(&cxg.demo, &cxg))
@@ -880,10 +864,13 @@ static int cxg_main(void)
 
     cxg_load_pipeline(&cxg);
     cxg_load_assets(&cxg);
-    cxg_populate_command_list(&cxg, 0);
-    cxg_populate_command_list(&cxg, 1);
-    cxg_populate_command_list(&cxg, 2);
+    for (i = 0; i < demo_swapchain_get_back_buffer_count(cxg.swapchain); ++i)
+    {
+        cxg_populate_command_list(&cxg, i);
+    }
 
+    printf("vkd3d-gears: Running on \"%s\" using %s.\n",
+            demo_swapchain_get_device_name(cxg.swapchain), demo_get_platform_name());
     demo_process_events(&cxg.demo);
 
     cxg_wait_for_previous_frame(&cxg);

demos/teapot.h

@@ -0,0 +1,129 @@
+/*
+ * Copyright 2025 Henri Verbeet
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+/* Teapot data adapted from freeglut's fg_teapot_data.h with the following license:
+ *
+ *     Permission is hereby granted, free of charge, to any person obtaining a
+ *     copy of this software and associated documentation files (the "Software"),
+ *     to deal in the Software without restriction, including without limitation
+ *     the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ *     and/or sell copies of the Software, and to permit persons to whom the
+ *     Software is furnished to do so, subject to the following conditions:
+ *
+ *     The above copyright notice and this permission notice shall be included
+ *     in all copies or substantial portions of the Software.
+ *
+ *     THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ *     OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ *     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ *     PAWEL W. OLSZTA BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ *     IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ *     CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * The data is of course ultimately derived from Martin Newell's famous
+ * teapot, also known as the Utah teapot.
+ */
+
+/* Rim, body, lid, and bottom data must be rotated along all four quadrants;
+ * handle and spout data is flipped (negate y values) only. */
+
+static const struct demo_patch teapot_rotate_patches[] =
+{
+    {{{  0,   1,   2,   3}, {  4,   5,   6,   7}, {  8,   9,  10,  11}, { 12,  13,  14,  15}}}, /* rim    */
+    {{{ 12,  13,  14,  15}, { 16,  17,  18,  19}, { 20,  21,  22,  23}, { 24,  25,  26,  27}}}, /* body   */
+    {{{ 24,  25,  26,  27}, { 28,  29,  30,  31}, { 32,  33,  34,  35}, { 36,  37,  38,  39}}},
+    {{{ 40,  40,  40,  40}, { 43,  44,  45,  46}, { 47,  47,  47,  47}, { 48,  49,  50,  51}}}, /* lid    */
+    {{{ 48,  49,  50,  51}, { 52,  53,  54,  55}, { 56,  57,  58,  59}, { 60,  61,  62,  63}}},
+    {{{ 64,  64,  64,  64}, { 65,  66,  67,  68}, { 69,  70,  71,  72}, { 39,  38,  37,  36}}}, /* bottom */
+},
+teapot_flip_patches[] =
+{
+    {{{ 73,  74,  75,  76}, { 77,  78,  79,  80}, { 81,  82,  83,  84}, { 85,  86,  87,  88}}}, /* handle */
+    {{{ 85,  86,  87,  88}, { 89,  90,  91,  92}, { 93,  94,  95,  96}, { 97,  98,  99, 100}}},
+    {{{101, 102, 103, 104}, {105, 106, 107, 108}, {109, 110, 111, 112}, {113, 114, 115, 116}}}, /* spout  */
+    {{{113, 114, 115, 116}, {117, 118, 119, 120}, {121, 122, 123, 124}, {125, 126, 127, 128}}},
+};
+
+static const struct demo_vec3 teapot_control_points[] =
+{
+    { 1.40000f,  0.00000f,  2.40000f}, { 1.40000f, -0.78400f,  2.40000f},
+    { 0.78400f, -1.40000f,  2.40000f}, { 0.00000f, -1.40000f,  2.40000f},
+    { 1.33750f,  0.00000f,  2.53125f}, { 1.33750f, -0.74900f,  2.53125f},
+    { 0.74900f, -1.33750f,  2.53125f}, { 0.00000f, -1.33750f,  2.53125f},
+    { 1.43750f,  0.00000f,  2.53125f}, { 1.43750f, -0.80500f,  2.53125f},
+    { 0.80500f, -1.43750f,  2.53125f}, { 0.00000f, -1.43750f,  2.53125f},
+    { 1.50000f,  0.00000f,  2.40000f}, { 1.50000f, -0.84000f,  2.40000f},
+    { 0.84000f, -1.50000f,  2.40000f}, { 0.00000f, -1.50000f,  2.40000f},
+    { 1.75000f,  0.00000f,  1.87500f}, { 1.75000f, -0.98000f,  1.87500f},
+    { 0.98000f, -1.75000f,  1.87500f}, { 0.00000f, -1.75000f,  1.87500f},
+    { 2.00000f,  0.00000f,  1.35000f}, { 2.00000f, -1.12000f,  1.35000f},
+    { 1.12000f, -2.00000f,  1.35000f}, { 0.00000f, -2.00000f,  1.35000f},
+    { 2.00000f,  0.00000f,  0.90000f}, { 2.00000f, -1.12000f,  0.90000f},
+    { 1.12000f, -2.00000f,  0.90000f}, { 0.00000f, -2.00000f,  0.90000f},
+    { 2.00000f,  0.00000f,  0.45000f}, { 2.00000f, -1.12000f,  0.45000f},
+    { 1.12000f, -2.00000f,  0.45000f}, { 0.00000f, -2.00000f,  0.45000f},
+    { 1.50000f,  0.00000f,  0.22500f}, { 1.50000f, -0.84000f,  0.22500f},
+    { 0.84000f, -1.50000f,  0.22500f}, { 0.00000f, -1.50000f,  0.22500f},
+    { 1.50000f,  0.00000f,  0.15000f}, { 1.50000f, -0.84000f,  0.15000f},
+    { 0.84000f, -1.50000f,  0.15000f}, { 0.00000f, -1.50000f,  0.15000f},
+    { 0.00000f,  0.00000f,  3.15000f}, { 0.00000f, -0.00200f,  3.15000f},
+    { 0.00200f,  0.00000f,  3.15000f}, { 0.80000f,  0.00000f,  3.15000f},
+    { 0.80000f, -0.45000f,  3.15000f}, { 0.45000f, -0.80000f,  3.15000f},
+    { 0.00000f, -0.80000f,  3.15000f}, { 0.00000f,  0.00000f,  2.85000f},
+    { 0.20000f,  0.00000f,  2.70000f}, { 0.20000f, -0.11200f,  2.70000f},
+    { 0.11200f, -0.20000f,  2.70000f}, { 0.00000f, -0.20000f,  2.70000f},
+    { 0.40000f,  0.00000f,  2.55000f}, { 0.40000f, -0.22400f,  2.55000f},
+    { 0.22400f, -0.40000f,  2.55000f}, { 0.00000f, -0.40000f,  2.55000f},
+    { 1.30000f,  0.00000f,  2.55000f}, { 1.30000f, -0.72800f,  2.55000f},
+    { 0.72800f, -1.30000f,  2.55000f}, { 0.00000f, -1.30000f,  2.55000f},
+    { 1.30000f,  0.00000f,  2.40000f}, { 1.30000f, -0.72800f,  2.40000f},
+    { 0.72800f, -1.30000f,  2.40000f}, { 0.00000f, -1.30000f,  2.40000f},
+    { 0.00000f,  0.00000f,  0.00000f}, { 0.00000f, -1.42500f,  0.00000f},
+    { 0.79800f, -1.42500f,  0.00000f}, { 1.42500f, -0.79800f,  0.00000f},
+    { 1.42500f,  0.00000f,  0.00000f}, { 0.00000f, -1.50000f,  0.07500f},
+    { 0.84000f, -1.50000f,  0.07500f}, { 1.50000f, -0.84000f,  0.07500f},
+    { 1.50000f,  0.00000f,  0.07500f}, {-1.60000f,  0.00000f,  2.02500f},
+    {-1.60000f, -0.30000f,  2.02500f}, {-1.50000f, -0.30000f,  2.25000f},
+    {-1.50000f,  0.00000f,  2.25000f}, {-2.30000f,  0.00000f,  2.02500f},
+    {-2.30000f, -0.30000f,  2.02500f}, {-2.50000f, -0.30000f,  2.25000f},
+    {-2.50000f,  0.00000f,  2.25000f}, {-2.70000f,  0.00000f,  2.02500f},
+    {-2.70000f, -0.30000f,  2.02500f}, {-3.00000f, -0.30000f,  2.25000f},
+    {-3.00000f,  0.00000f,  2.25000f}, {-2.70000f,  0.00000f,  1.80000f},
+    {-2.70000f, -0.30000f,  1.80000f}, {-3.00000f, -0.30000f,  1.80000f},
+    {-3.00000f,  0.00000f,  1.80000f}, {-2.70000f,  0.00000f,  1.57500f},
+    {-2.70000f, -0.30000f,  1.57500f}, {-3.00000f, -0.30000f,  1.35000f},
+    {-3.00000f,  0.00000f,  1.35000f}, {-2.50000f,  0.00000f,  1.12500f},
+    {-2.50000f, -0.30000f,  1.12500f}, {-2.65000f, -0.30000f,  0.93750f},
+    {-2.65000f,  0.00000f,  0.93750f}, {-2.00000f,  0.00000f,  0.90000f},
+    {-2.00000f, -0.30000f,  0.90000f}, {-1.90000f, -0.30000f,  0.60000f},
+    {-1.90000f,  0.00000f,  0.60000f}, { 1.70000f,  0.00000f,  1.42500f},
+    { 1.70000f, -0.66000f,  1.42500f}, { 1.70000f, -0.66000f,  0.60000f},
+    { 1.70000f,  0.00000f,  0.60000f}, { 2.60000f,  0.00000f,  1.42500f},
+    { 2.60000f, -0.66000f,  1.42500f}, { 3.10000f, -0.66000f,  0.82500f},
+    { 3.10000f,  0.00000f,  0.82500f}, { 2.30000f,  0.00000f,  2.10000f},
+    { 2.30000f, -0.25000f,  2.10000f}, { 2.40000f, -0.25000f,  2.02500f},
+    { 2.40000f,  0.00000f,  2.02500f}, { 2.70000f,  0.00000f,  2.40000f},
+    { 2.70000f, -0.25000f,  2.40000f}, { 3.30000f, -0.25000f,  2.40000f},
+    { 3.30000f,  0.00000f,  2.40000f}, { 2.80000f,  0.00000f,  2.47500f},
+    { 2.80000f, -0.25000f,  2.47500f}, { 3.52500f, -0.25000f,  2.49375f},
+    { 3.52500f,  0.00000f,  2.49375f}, { 2.90000f,  0.00000f,  2.47500f},
+    { 2.90000f, -0.15000f,  2.47500f}, { 3.45000f, -0.15000f,  2.51250f},
+    { 3.45000f,  0.00000f,  2.51250f}, { 2.80000f,  0.00000f,  2.40000f},
+    { 2.80000f, -0.15000f,  2.40000f}, { 3.20000f, -0.15000f,  2.40000f},
+    { 3.20000f,  0.00000f,  2.40000f}
+};

demos/teapot.hlsl

@@ -0,0 +1,265 @@
+/*
+ * Copyright 2025 Henri Verbeet
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#define M_PI 3.14159265
+
+cbuffer teapot_cb : register(b0)
+{
+    float4x4 mvp_matrix;
+    float3 eye;
+    float level;
+    uint wireframe, flat;
+};
+
+struct control_point
+{
+    float4 position : SV_POSITION;
+};
+
+struct patch_constant_data
+{
+    float edges[4] : SV_TessFactor;
+    float inside[2] : SV_InsideTessFactor;
+};
+
+struct gs_in
+{
+    float4 position : SV_POSITION;
+    float3 pos : POSITION;
+    float3 normal : NORMAL;
+};
+
+struct ps_in
+{
+    float4 position : SV_POSITION;
+    float3 pos : POSITION;
+    float3 normal : NORMAL;
+    float2 barycentric : BARYCENTRIC;
+};
+
+float4 vs_main(float4 position : POSITION, uint id : SV_InstanceID) : SV_POSITION
+{
+    /* Mirror/flip patches based on the instance ID. */
+    position.w = -1.0;
+    if (id & 1)
+        position.yw = -position.yw;
+    if (id & 2)
+        position.xw = -position.xw;
+
+    return position;
+}
+
+struct patch_constant_data patch_constant(InputPatch<control_point, 16> input)
+{
+    struct patch_constant_data output;
+
+    output.edges[0] = level;
+    output.edges[1] = level;
+    output.edges[2] = level;
+    output.edges[3] = level;
+    output.inside[0] = level;
+    output.inside[1] = level;
+
+    return output;
+}
+
+[domain("quad")]
+[outputcontrolpoints(16)]
+[outputtopology("triangle_ccw")]
+[partitioning("integer")]
+[patchconstantfunc("patch_constant")]
+struct control_point hs_main(InputPatch<control_point, 16> input, uint i : SV_OutputControlPointID)
+{
+    /* Reorder mirrored/flipped control points. */
+    if (input[0].position.w < 0.0)
+    {
+        uint u = i % 4, v = i / 4;
+        return input[v * 4 + (3 - u)];
+    }
+
+    return input[i];
+}
+
+float3 eval_quadratic(float3 p0, float3 p1, float3 p2, float t)
+{
+    return lerp(lerp(p0, p1, t), lerp(p1, p2, t), t);
+}
+
+float3 eval_cubic(float3 p0, float3 p1, float3 p2, float3 p3, float t)
+{
+    return lerp(eval_quadratic(p0, p1, p2, t),
+            eval_quadratic(p1, p2, p3, t), t);
+}
+
+struct gs_in eval_patch(float2 t, float4 p[16])
+{
+    float3 position, normal, q[4], u, v;
+    struct gs_in o;
+
+    q[0] = eval_cubic( p[0].xyz,  p[1].xyz,  p[2].xyz,  p[3].xyz, t.x);
+    q[1] = eval_cubic( p[4].xyz,  p[5].xyz,  p[6].xyz,  p[7].xyz, t.x);
+    q[2] = eval_cubic( p[8].xyz,  p[9].xyz, p[10].xyz, p[11].xyz, t.x);
+    q[3] = eval_cubic(p[12].xyz, p[13].xyz, p[14].xyz, p[15].xyz, t.x);
+    u = eval_quadratic(q[0], q[1], q[2], t.y) - eval_quadratic(q[1], q[2], q[3], t.y);
+
+    q[0] = eval_cubic(p[0].xyz, p[4].xyz,  p[8].xyz, p[12].xyz, t.y);
+    q[1] = eval_cubic(p[1].xyz, p[5].xyz,  p[9].xyz, p[13].xyz, t.y);
+    q[2] = eval_cubic(p[2].xyz, p[6].xyz, p[10].xyz, p[14].xyz, t.y);
+    q[3] = eval_cubic(p[3].xyz, p[7].xyz, p[11].xyz, p[15].xyz, t.y);
+    v = eval_quadratic(q[0], q[1], q[2], t.x) - eval_quadratic(q[1], q[2], q[3], t.x);
+
+    position = eval_cubic(q[0], q[1], q[2], q[3], t.x);
+    o.position = mul(mvp_matrix, float4(position, 1.0));
+    o.pos = position;
+
+    /* The patches for the bottom of the teapot and the top of its lid are
+     * degenerate. Technically this isn't the right way to deal with that, but
+     * it's easy and gets the right result for these patches. */
+    if (length(v) == 0.0)
+        normal = cross(p[4].xyz - p[0].xyz, p[7].xyz - p[3].xyz);
+    else
+        normal = cross(u, v);
+    o.normal = normalize(normal);
+
+    return o;
+}
+
+[domain("quad")]
+struct gs_in ds_main(struct patch_constant_data input,
+        float2 tess_coord : SV_DomainLocation, const OutputPatch<control_point, 16> patch)
+{
+    return eval_patch(tess_coord, patch);
+}
+
+[maxvertexcount(3)]
+void gs_main(triangle struct gs_in i[3], inout TriangleStream<struct ps_in> stream)
+{
+    struct ps_in v[3];
+    float3 n;
+
+    v[0].position = i[0].position;
+    v[0].pos = i[0].pos;
+    v[0].normal = i[0].normal;
+    v[0].barycentric = float2(1.0, 0.0);
+
+    v[1].position = i[1].position;
+    v[1].pos = i[1].pos;
+    v[1].normal = i[1].normal;
+    v[1].barycentric = float2(0.0, 1.0);
+
+    v[2].position = i[2].position;
+    v[2].pos = i[2].pos;
+    v[2].normal = i[2].normal;
+    v[2].barycentric = float2(0.0, 0.0);
+
+    if (flat)
+    {
+        n = normalize(cross(i[1].pos - i[0].pos, i[2].pos - i[0].pos));
+        v[0].normal = n;
+        v[1].normal = n;
+        v[2].normal = n;
+    }
+
+    stream.Append(v[0]);
+    stream.Append(v[1]);
+    stream.Append(v[2]);
+}
+
+/* Lambertian diffuse. */
+float3 brdf_lambert(float3 diffuse)
+{
+    return diffuse / M_PI;
+}
+
+/* The Schlick Fresnel approximation:
+ *
+ *     R(θ) ≈ R₀ + (1 - R₀)(1 - c̅o̅s̅ θ)⁵
+ */
+float3 fresnel_schlick(float3 r0, float cos_theta)
+{
+    return lerp(r0, 1.0, pow(1.0 - cos_theta, 5.0));
+}
+
+float g1(float cos_theta, float alpha_sq)
+{
+    return cos_theta + sqrt(alpha_sq + (cos_theta - alpha_sq * cos_theta) * cos_theta);
+}
+
+/* Trowbridge-Reitz, "Average irregularity representation of a rough surface for ray reflection".
+ * Also known as "GGX".
+ *
+ *     G1(θ) = 2 / (1 + sqrt(α² + (1 - α²)c̅o̅s̅² θ))
+ *     G(θᵢ, θₒ) = G1(θᵢ) * G1(θₒ)
+ *
+ * This returns G / (4 c̅o̅s̅ θᵢ c̅o̅s̅ θₒ)
+ */
+float geometric_att_trowbridge_reitz(float cos_theta_i, float cos_theta_o, float alpha_sq)
+{
+    return 1.0 / (g1(cos_theta_i, alpha_sq) * g1(cos_theta_o, alpha_sq));
+}
+
+/* Trowbridge-Reitz, "Average irregularity representation of a rough surface for ray reflection".
+ * Also known as "GGX".
+ *
+ *     D(θ) = α² / π((cos² θ)(α² - 1) + 1)²
+ */
+float ndf_trowbridge_reitz(float cos_theta_h, float alpha_sq)
+{
+    float f = (cos_theta_h * alpha_sq - cos_theta_h) * cos_theta_h + 1.0;
+    return alpha_sq / (M_PI * f * f);
+}
+
+float4 ps_main(struct ps_in i) : SV_TARGET
+{
+    float3 barycentric, diffuse, diffuse_colour, radiance, specular, f, h, n, v;
+    float alpha, alpha_sq, cos_theta_h, cos_theta_i, cos_theta_o, d, g, wire;
+    float3 light_dir = normalize(float3(5.0, 5.0, 10.0));
+    float3 light_colour = float3(1.0, 0.95, 0.88);
+    float3 light_irradiance = 5.0 * light_colour;
+    float3 base_colour = float3(0.8, 0.8, 0.8);
+    float3 f0 = float3(0.04, 0.04, 0.04);
+    float3 ambient = 0.3 * light_colour;
+    float roughness = 0.2;
+    float metallic = 0.3;
+
+    n = normalize(i.normal);
+    v = normalize(eye - i.pos);
+    h = normalize(light_dir + v);
+    cos_theta_h = dot(n, h);
+    cos_theta_i = saturate(dot(n, light_dir));
+    cos_theta_o = saturate(dot(n, v));
+
+    diffuse_colour = base_colour * (float3(1.0, 1.0, 1.0) - f0) * (1.0 - metallic);
+    alpha = roughness * roughness;
+    alpha_sq = alpha * alpha;
+
+    /* Cook-Torrance. The division by (4 c̅o̅s̅ θᵢ c̅o̅s̅ θₒ) is folded into G. */
+    f = fresnel_schlick(lerp(f0, base_colour, metallic), dot(v, h));
+    g = geometric_att_trowbridge_reitz(cos_theta_i, cos_theta_o, alpha_sq);
+    d = ndf_trowbridge_reitz(cos_theta_h, alpha_sq);
+    diffuse = (1.0 - f) * brdf_lambert(diffuse_colour);
+    specular = f * g * d;
+    radiance = (diffuse + specular) * light_irradiance * cos_theta_i;
+    radiance += ambient * base_colour;
+
+    barycentric = float3(i.barycentric, 1.0 - (i.barycentric.x + i.barycentric.y));
+    barycentric /= fwidth(barycentric);
+    wire = wireframe ? min(min(barycentric.x, barycentric.y), barycentric.z) : 1.0;
+
+    return float4(lerp(float3(1.00, 0.69, 0.0), saturate(radiance), saturate(wire)), 1.0);
+}

demos/text.hlsl

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2025 Henri Verbeet
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+cbuffer text_cb : register(b0)
+{
+    uint4 screen_size;
+    uint4 glyphs[96];
+};
+
+Buffer<uint> text : register(t0);
+
+struct text_run
+{
+    float4 colour : COLOUR;
+    uint2 position : POSITION;
+    uint start_idx : IDX;           /* The start offset of the run in the "text" Buffer. */
+    uint char_count : COUNT;
+    uint reverse : REVERSE;
+    float scale : SCALE;
+};
+
+struct ps_in
+{
+    float4 position : SV_POSITION;
+    float2 texcoord : TEXCOORD;
+    uint start_idx : IDX;           /* The start offset of the run in the "text" Buffer. */
+    uint reverse : REVERSE;
+    float4 colour : COLOUR;
+};
+
+struct ps_in vs_main(struct text_run t, uint id : SV_VertexID)
+{
+    float2 pixel, pos, size;
+    struct ps_in o;
+
+    pixel = float2(2.0, 2.0) / float2(screen_size.x, screen_size.y);
+    pos = pixel * t.position - float2(1.0, 1.0);
+    size = pixel * t.scale * float2(t.char_count * 9.0, 16.0);
+
+    o.position.x = (id & 0x1) * size.x + pos.x;
+    o.position.y = ((id >> 1) & 0x1) * size.y + pos.y;
+    o.position.z = 0.0;
+    o.position.w = 1.0;
+
+    o.texcoord.x = (id & 0x1) * t.char_count;
+    o.texcoord.y = (~id >> 1) & 0x1;
+
+    o.start_idx = t.start_idx;
+    o.reverse = t.reverse;
+    o.colour = t.colour;
+
+    return o;
+}
+
+float4 ps_main(struct ps_in i) : SV_TARGET
+{
+    uint idx, glyph_id, row;
+    uint4 glyph;
+    uint2 texel;
+
+    /* We determine the current character based on the start offset and texture
+     * coordinate. We then lookup the corresponding glyph in glyphs[]. */
+    idx = i.start_idx + i.texcoord.x;
+    glyph_id = text[idx] - 0x20;
+    glyph = glyphs[glyph_id];
+
+    /* Find the row within the glyph bitmap, and then the pixel within that row.
+     * Note that we apply dot stretching here; a single pixel in the source
+     * glyph results in two pixels in the output. */
+    texel = frac(i.texcoord.xy) * float2(9, 16);
+    row = (glyph[texel.y / 4] >> (8 * (texel.y % 4))) & 0xff;
+    if (!(i.reverse ^ (((row | (row << 1)) >> (8 - texel.x)) & 0x1)))
+        discard;
+
+    /* Scan line gaps. */
+    if (uint(i.position.y) & 1)
+        return float4(i.colour.xyz * (screen_size.z >= 2 ? 0.5 : 0.8), 1.0);
+
+    return i.colour;
+}

demos/triangle.c

@@ -72,7 +72,7 @@ struct cx_triangle
     struct demo_swapchain *swapchain;
     ID3D12DescriptorHeap *rtv_heap;
     unsigned int rtv_descriptor_size;
-    ID3D12Resource *render_targets[3];
+    ID3D12Resource **render_targets;
     ID3D12CommandAllocator *command_allocator;
 
     ID3D12RootSignature *root_signature;
@@ -164,10 +164,11 @@ static void cxt_destroy_pipeline(struct cx_triangle *cxt)
     unsigned int i;
 
     ID3D12CommandAllocator_Release(cxt->command_allocator);
-    for (i = 0; i < ARRAY_SIZE(cxt->render_targets); ++i)
+    for (i = 0; i < demo_swapchain_get_back_buffer_count(cxt->swapchain); ++i)
     {
         ID3D12Resource_Release(cxt->render_targets[i]);
     }
+    free(cxt->render_targets);
     ID3D12DescriptorHeap_Release(cxt->rtv_heap);
     demo_swapchain_destroy(cxt->swapchain);
     ID3D12CommandQueue_Release(cxt->command_queue);
@@ -180,7 +181,7 @@ static void cxt_load_pipeline(struct cx_triangle *cxt)
     D3D12_DESCRIPTOR_HEAP_DESC rtv_heap_desc;
     D3D12_CPU_DESCRIPTOR_HANDLE rtv_handle;
     D3D12_COMMAND_QUEUE_DESC queue_desc;
-    unsigned int i;
+    unsigned int i, rt_count;
     HRESULT hr;
 
     hr = D3D12CreateDevice(NULL, D3D_FEATURE_LEVEL_11_0, &IID_ID3D12Device, (void **)&cxt->device);
@@ -193,16 +194,19 @@ static void cxt_load_pipeline(struct cx_triangle *cxt)
             &IID_ID3D12CommandQueue, (void **)&cxt->command_queue);
     assert(SUCCEEDED(hr));
 
-    swapchain_desc.buffer_count = ARRAY_SIZE(cxt->render_targets);
+    swapchain_desc.buffer_count = 3;
     swapchain_desc.format = DXGI_FORMAT_B8G8R8A8_UNORM;
     swapchain_desc.width = cxt->width;
     swapchain_desc.height = cxt->height;
     cxt->swapchain = demo_swapchain_create(cxt->command_queue, cxt->window, &swapchain_desc);
     assert(cxt->swapchain);
+    rt_count = demo_swapchain_get_back_buffer_count(cxt->swapchain);
+    cxt->render_targets = calloc(rt_count, sizeof(*cxt->render_targets));
+    assert(cxt->render_targets);
     cxt->frame_idx = demo_swapchain_get_current_back_buffer_index(cxt->swapchain);
 
     memset(&rtv_heap_desc, 0, sizeof(rtv_heap_desc));
-    rtv_heap_desc.NumDescriptors = ARRAY_SIZE(cxt->render_targets);
+    rtv_heap_desc.NumDescriptors = rt_count;
     rtv_heap_desc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_RTV;
     rtv_heap_desc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE;
     hr = ID3D12Device_CreateDescriptorHeap(cxt->device, &rtv_heap_desc,
@@ -212,7 +216,7 @@ static void cxt_load_pipeline(struct cx_triangle *cxt)
     cxt->rtv_descriptor_size = ID3D12Device_GetDescriptorHandleIncrementSize(cxt->device,
             D3D12_DESCRIPTOR_HEAP_TYPE_RTV);
     rtv_handle = ID3D12DescriptorHeap_GetCPUDescriptorHandleForHeapStart(cxt->rtv_heap);
-    for (i = 0; i < ARRAY_SIZE(cxt->render_targets); ++i)
+    for (i = 0; i < rt_count; ++i)
     {
         cxt->render_targets[i] = demo_swapchain_get_back_buffer(cxt->swapchain, i);
         ID3D12Device_CreateRenderTargetView(cxt->device, cxt->render_targets[i], NULL, rtv_handle);
@@ -396,6 +400,8 @@ static int cxt_main(void)
     cxt_load_pipeline(&cxt);
     cxt_load_assets(&cxt);
 
+    printf("vkd3d-triangle: Running on \"%s\" using %s.\n",
+            demo_swapchain_get_device_name(cxt.swapchain), demo_get_platform_name());
     demo_process_events(&cxt.demo);
 
     cxt_wait_for_previous_frame(&cxt);

gitlab/build.yml

@@ -158,8 +158,7 @@ build-mac:
     - mkdir artifacts
     - export PATH="/opt/homebrew/opt/bison/bin:/opt/homebrew/opt/flex/bin:$PATH"
     - export VK_DRIVER_FILES="$PWD/image/moltenvk/MoltenVK_icd.json"
-    # Currently disabled because it has too many failures
-    #- export SONAME_LIBDXCOMPILER="$PWD/image/dxc/libdxcompiler.dylib"
+    - export SONAME_LIBDXCOMPILER="$PWD/image/dxc/libdxcompiler.dylib"
     - system_profiler SPSoftwareDataType SPHardwareDataType > artifacts/systeminfo.txt
     - vulkaninfo > artifacts/vulkaninfo.txt
     - git rebase $CI_MERGE_REQUEST_DIFF_BASE_SHA --exec ./gitlab/build-mac

gitlab/image.yml

@@ -41,12 +41,10 @@ image-mac:
     - mkdir image/dxc
     - mkdir image/moltenvk
 
-    # The specified commit includes an update to the DirectXShaderCompiler's
-    # CMakeList.txt which makes it compatible with cmake (4+).
-    - git clone https://github.com/microsoft/DirectXShaderCompiler.git
+    - git clone --recursive --branch v1.8.2502 https://github.com/microsoft/DirectXShaderCompiler.git
     - cd DirectXShaderCompiler
-    - git checkout 3035d316c35289b68e8fc9d8cf21d86a204fb0e2
-    - git submodule update --init --recursive
+    # Include a fix for CMake 4+.
+    - git cherry-pick 3035d316c35289b68e8fc9d8cf21d86a204fb0e2
     - mkdir build
     - cd build
     - cmake .. -C ../cmake/caches/PredefinedParams.cmake -D CMAKE_BUILD_TYPE=Release

include/.gitignore

@@ -1,9 +1,14 @@
 config.h
 config.h.in
+private/appkit.h
+private/foundation.h
+private/quartzcore.h
+private/spirv_grammar.h
 private/vkd3d_version.h
 stamp-h1
 vkd3d_d3d12.h
 vkd3d_d3d12sdklayers.h
+vkd3d_d3d12shader.h
 vkd3d_d3dcommon.h
 vkd3d_d3dx9shader.h
 vkd3d_dxgi.h