Release 1.17.

We largely ignore the target type when preprocessing, but still
dereference options.target_type in a couple of places. E.g. when setting
info.target_type. We could add more checks for options.preprocess_only
to account for that, but it seems more robust to make sure
options.target_type is never NULL.

.editorconfig

@@ -0,0 +1,16 @@
+# https://editorconfig.org/
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+indent_style = space
+indent_size = 4
+tab_width = 8
+trim_trailing_whitespace = true
+max_line_length = 120
+insert_final_newline = true
+
+[Makefile*]
+indent_style = tab
+indent_size = 8

AUTHORS

@@ -3,6 +3,8 @@ Alexandre Julliard
 Alistair Leslie-Hughes
 Andrew Eikum
 Andrey Gusev
+Anna (navi) Figueiredo Gomes
+Arkadiusz Hiler
 Atharva Nimbalkar
 Biswapriyo Nath
 Brendan Shanks
@@ -14,6 +16,7 @@ Elizabeth Figura
 Ethan Lee
 Evan Tang
 Fabian Maurer
+Feifan He
 Florian Weimer
 Francisco Casas
 Francois Gouget
@@ -33,8 +36,10 @@ Petrichor Park
 Philip Rebohle
 Rémi Bernon
 Robin Kertels
+Shaun Ren
 Stefan Dösinger
 Sven Hesse
 Victor Chiletto
 Vinson Lee
+Yuxuan Shui
 Zhiyi Zhang

COPYING

@@ -1,4 +1,4 @@
-Copyright 2016-2024 the Vkd3d project authors (see the file AUTHORS for a
+Copyright 2016-2025 the Vkd3d project authors (see the file AUTHORS for a
 complete list)
 
 Vkd3d is free software; you can redistribute it and/or modify it under

ChangeLog.md

@@ -1,3 +1,481 @@
+# 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
+
+  - DXIL shaders are supported in the default configuration. Previously this
+    required building vkd3d with the ‘-DVKD3D_SHADER_UNSUPPORTED_DXIL’
+    preprocessor option. The also raises the maximum supported shader model to
+    version 6.0.
+
+  - Graphics pipeline state objects can be created from shaders with embedded
+    root signatures. This was already possible for compute pipeline state
+    objects.
+
+  - The SetEventOnMultipleFenceCompletion() method of the ID3D12Device1
+    interface is implemented.
+
+  - When the VK_KHR_zero_initialize_workgroup_memory extension is supported,
+    libvkd3d supports zero-initialising compute shader thread group shared
+    memory.
+
+  - The VK_KHR_maintenance2 extension is now explicitly required. libvkd3d
+    already unconditionally used features provided by this extension, but
+    unfortunately didn't explicitly require it. Support for this extension is
+    widespread, and the extension is part of Vulkan 1.1.
+
+### libvkd3d-shader
+
+  - The previously experimental support for compiling DXIL shaders is now a
+    supported feature and enabled by default. Please note that this feature is
+    nevertheless still far from perfect.
+
+  - New features for the HLSL source type:
+    - Initial support for geometry shaders.
+    - Indirect addressing in shader model 1-3 target profiles.
+    - Modulus and truncation operations in shader model 1-3 target profiles.
+    - Vectorised output code.
+    - Further improved constant folding and propagation.
+    - The following intrinsic functions are supported:
+      - AllMemoryBarrier()
+      - AllMemoryBarrierWithGroupSync()
+      - DeviceMemoryBarrier()
+      - DeviceMemoryBarrierWithGroupSync()
+      - GroupMemoryBarrier()
+      - GroupMemoryBarrierWithGroupSync()
+    - The ‘.Length’ Texture object property.
+    - The ‘SV_RenderTargetArrayIndex’ and ‘SV_ViewportArrayIndex’ semantics in
+      tessellation shaders.
+
+  - Disassembler support for binary ‘fx_2_0’ effects.
+
+  - Experimental built-in support for disassembling SPIR-V shaders, enabled by
+    building vkd3d with the ‘-DVKD3D_SHADER_UNSUPPORTED_SPIRV_PARSER’
+    preprocessor option. When enabled, the built-in SPIR-V disassembler is
+    used instead of SPIRV-Tools for the ‘spirv-text’ target type, as well as
+    for the debug output enabled by the VKD3D_SHADER_DEBUG environment
+    variable.
+
+  - The experimental OpenGL Shading Language (GLSL) target supports indirect
+    addressing of constant buffers.
+
+  - The experimental Metal Shading Language (MSL) target supports texture
+    loads.
+
+  - New interfaces:
+    - The VKD3D_SHADER_COMPILE_OPTION_FEATURE_ZERO_INITIALIZE_WORKGROUP_MEMORY
+      flag indicates support for zero-initialising workgroup memory in the
+      SPIR-V target environment.
+    - The VKD3D_SHADER_COMPONENT_INT64 enumeration value indicates a 64-bit
+      signed integer value.
+    - The VKD3D_SHADER_COMPONENT_FLOAT16 enumeration value indicates a 16-bit
+      IEEE floating-point value.
+    - The VKD3D_SHADER_COMPONENT_UINT16 enumeration value indicates a 16-bit
+      unsigned integer value.
+    - The VKD3D_SHADER_COMPONENT_INT16 enumeration value indicates a 16-bit
+      signed integer value.
+    - When targeting VKD3D_SHADER_API_1_16, the
+      VKD3D_SHADER_RESOURCE_DATA_NONE enumeration value is returned for the
+      ‘resource_data_type’ field in the vkd3d_shader_descriptor_info structure
+      for sampler descriptors. VKD3D_SHADER_API_1_15 and before use the
+      VKD3D_SHADER_RESOURCE_DATA_UINT enumeration value for this.
+
+### demos
+
+  - The vkd3d demos now work on both the Microsoft Windows and Apple macOS
+    builds. The macOS versions of the vkd3d demos are completely new in vkd3d
+    1.16, while the Windows demos could previously be built, but only worked
+    on Wine. Note that the vkd3d demos produced by a Windows build of vkd3d
+    are distinct from those produced by the ‘make crosstest’ target: the
+    former are Vulkan applications using vkd3d, while the latter are Direct3D
+    12 applications.
+
+  - The vkd3d demos have basic support for DPI scaling.
+
+### build
+
+  - Perl and the ‘JSON’ Perl module have been added as build dependencies.
+    These are used for the experimental built-in SPIR-V disassembler, as well
+    as for the macOS versions of the vkd3d demos.
+
+# What's new in vkd3d 1.15 (19 February 2025)
+
+### libvkd3d
+
+  - New interfaces:
+    - vkd3d_queue_signal_on_cpu() allows a Direct3D 12 fence to be signalled
+      when all preceding work on a Direct3D 12 command queue has been submitted
+      to the corresponding Vulkan queue.
+
+### libvkd3d-shader
+
+  - New features for the HLSL source type:
+    - ‘InputPatch’ and ‘OutputPatch’ tessellation shader objects. This was the
+      main feature required by most tessellation shaders that was still missing,
+      and tessellation shaders should be considered generally usable now.
+    - Unrolling of loops containing conditional jumps.
+    - Improved function overload resolution. Previously the compiler was unable
+      to decide between multiple function overloads with the same number of
+      parameters.
+    - The parser is able to continue parsing in a larger number of error cases.
+      This allows more issues in the input to be reported during a single
+      compilaton attempt.
+    - The following intrinsic functions are supported:
+      - GatherCmp()
+      - GatherCmpAlpha(), GatherCmpBlue(), GatherCmpGreen(), and GatherCmpRed()
+      - InterlockedAdd(), InterlockedAnd(), InterlockedCompareExchange(),
+        InterlockedCompareStore(), InterlockedExchange(), InterlockedMax(),
+        InterlockedMin(), InterlockedOr(), and InterlockedXor()
+      - isinf()
+    - Separate resource and sampler support for shader model 1-3 target
+      profiles.
+    - Casts on the left hand side of assignments.
+    - Reassociation and redistribution of constants in binary expressions, to
+      facilitate constant folding.
+    - Packing of interstage I/O variables with the ‘SV_IsFrontFace’,
+      ‘SV_PrimitiveID’, ‘SV_RenderTargetArrayIndex’, ‘SV_SampleIndex’, and
+      ‘SV_ViewPortArrayIndex’ semantics matches d3dcompiler/fxc more closely.
+    - Parser support for the ‘LineStream’, ‘PointStream’, and ‘TriangleStream’
+      Stream-Output objects.
+
+  - A number of instructions have been implemented for the experimental MSL
+    target. Although more and more shaders are starting to work, support is
+    still fairly limited. For example, shader resource views and unordered
+    access views are still entirely unsupported.
+
+  - Shader code generation for fixed-function fog. Like the existing shader code
+    generation for other fixed-function features, this is mainly relevant for
+    executing shader model 1-3 sources in modern target environments like
+    Vulkan.
+
+  - The ‘fx’ parser can parse binary effects containing inline shader blobs.
+
+  - Internal validator support for validating I/O signatures, as well as I/O
+    source and destination parameters. The validator is enabled by the
+    ‘force_validation’ option, specified through the VKD3D_SHADER_CONFIG
+    environment variable.
+
+  - Internal validator support for validating the number of indices used with a
+    register, as well as basic bounds checking for static indices.
+
+  - New interfaces:
+    - The vkd3d_shader_scan_hull_shader_tessellation_info structure extends the
+      vkd3d_shader_compile_info structure, and can be used to retrieve the
+      output primitive type and partitioning mode used by a hull shader. This
+      information is particularly useful for specifying
+      vkd3d_shader_spirv_domain_shader_target_info structures when targetting
+      SPIR-V in OpenGL environments.
+    - The VKD3D_SHADER_PARAMETER_NAME_FOG_FRAGMENT_MODE shader parameter
+      specifies the kind of fog to generate in a fragment shader.
+    - The VKD3D_SHADER_PARAMETER_NAME_FOG_COLOUR shader parameter
+      specifies the fog colour.
+    - The VKD3D_SHADER_PARAMETER_NAME_FOG_END shader parameter
+      specifies the ‘end’ parameter used for linear fog generation.
+    - The VKD3D_SHADER_PARAMETER_NAME_FOG_SCALE shader parameter
+      specifies the ‘scale’ parameter used for fog generation.
+    - The VKD3D_SHADER_PARAMETER_NAME_FOG_SOURCE shader parameter
+      specifies the kind of fog coordinate to output from a pre-rasterisation
+      shader.
+
+### vkd3d-compiler
+
+  - The new ‘dxbc-fx’ source type specifies an effect binary embedded in a DXBC
+    container. This is a convenience feature;
+    ‘vkd3d-compiler -x dxbc-fx blob.dxbc’ is equivalent to
+    ‘vkd3d-dxbc -x t:FX10 blob.dxbc | vkd3d-compiler -x fx’.
+
+# What's new in vkd3d 1.14 (21 November 2024)
+
+### libvkd3d
+
+  - Depth bounds can be changed dynamically using the OMSetDepthBounds() method
+    of the ID3D12GraphicsCommandList1 interface.
+
+  - The new VKD3D_CAPS_OVERRIDE environment variable can be used to override the
+    value of capabilities like the maximum feature level and resource binding
+    tier reported to applications.
+
+### libvkd3d-shader
+
+  - New features for the HLSL source type:
+    - Interstage I/O variable packing matches d3dcompiler/fxc more closely.
+    - The following intrinsic functions are supported:
+      - dst()
+      - f32tof16()
+      - mad()
+      - modf()
+      - sincos()
+    - ‘discard’ support for shader model 1-3 target profiles.
+    - The ‘SV_SampleIndex’ input semantic for fragment shaders.
+    - The ‘SV_GroupIndex’ input semantic for compute shaders.
+    - The ‘earlydepthstencil’ function attribute.
+    - Constant folding of expressions like ‘x && c’ and ‘x || c’, where ‘c’ is a
+      constant.
+    - Preprocessor support for namespaces in macro identifiers. I.e., syntax
+      like ‘#define NAME1::NAME2::NAME3 1’ works as intended now.
+    - Structure inheritance. Multiple inheritance is not supported.
+    - Register assignments for unused constant buffers are allowed to overlap
+      register assignments for used constant buffers.
+    - Instruction count reflection data for shader model 4+ target profiles.
+      This data is contained in the ‘STAT’ DXBC section, and can be queried with
+      the GetDesc() method of the ID3D11ShaderReflection and
+      ID3D12ShaderReflection interfaces. Note that the ID3D12ShaderReflection
+      implementation provided by vkd3d-utils does not currently correctly report
+      this information.
+    - ‘unorm’ and ‘snorm’ resource format modifiers. For example,
+      ‘Texture2D<unorm float4> t;’
+    - Parser support for ‘ByteAddressBuffer’ resources, as well as their
+      Load()/Load2()/Load3()/Load4() methods.
+    - Parser support for ‘RWByteAddressBuffer’ resources, as well as their
+      Store()/Store2()/Store3()/Store4() methods.
+    - Parser support for the ‘compile’ keyword, as well as the CompileShader()
+      and ConstructGSWithSO() intrinsic functions. Actual compilation of
+      embedded shaders is not implemented yet, but parser support is sufficient
+      for allowing compilation of HLSL sources containing this syntax to succeed
+      when targetting shader target profiles like ‘vs_5_0’ or ‘ps_5_0’.
+    - Initial support for tessellation shaders. Only the most trivial shaders
+      are supported in this release. Perhaps most notably, both ‘InputPatch’ and
+      ‘OutputPatch’ are not implemented yet.
+
+  - The new ‘fx’ source type can be used in combination with the ‘d3d-asm’
+    target type to disassemble binary effects.
+
+  - More complete support for fx_2_0 binary effect output, including support for
+    annotations, default values, as well as object initialiser data used for e.g.
+    string, texture, and shader objects.
+
+  - A significant number of instructions have been implemented for the
+    experimental GLSL target. The GLSL output currently targets version 4.40
+    without extensions, but the intention is to make this configurable in a
+    future release of vkd3d.
+
+  - Experimental support for Metal Shading Language (MSL) output, enabled by
+    building vkd3d with the ‘-DVKD3D_SHADER_UNSUPPORTED_MSL’ preprocessor
+    option. The current release is only able to compile the most basic shaders
+    when targetting MSL. Being an experimental feature, both the ABI and API may
+    change in future releases; the feature may even go away completely.
+    Nevertheless, we hope our users find this feature useful, and welcome
+    feedback and contributions.
+
+  - Shader code generation for various legacy fixed-function features, including
+    clip planes, point sizes, and point sprites. This is mainly relevant for
+    executing shader model 1-3 sources in modern target environments like
+    Vulkan, because those target environments do not implement equivalent
+    fixed-function features.
+
+  - The amount of shader validation done by the internal validator has been
+    greatly extended. The validator is enabled by the ‘force_validation’ option,
+    specified through the VKD3D_SHADER_CONFIG environment variable.
+
+  - New interfaces:
+    - The VKD3D_SHADER_COMPILE_OPTION_DOUBLE_AS_FLOAT_ALIAS flag specifies that
+      the ‘double’ type behaves as an alias for the ‘float’ type in HLSL sources
+      with shader model 1-3 target profiles.
+    - The VKD3D_SHADER_PARAMETER_DATA_TYPE_FLOAT32_VEC4 enumeration value
+      specifies that a shader parameter contains a 4-dimensional vector of
+      32-bit floating-point data.
+    - The VKD3D_SHADER_PARAMETER_NAME_CLIP_PLANE_MASK shader parameter specifies
+      which clip planes are enabled.
+    - The VKD3D_SHADER_PARAMETER_NAME_CLIP_PLANE_[0-7] shader parameters specify
+      the corresponding clip planes.
+    - The VKD3D_SHADER_PARAMETER_NAME_POINT_SIZE shader parameter specifies the
+      point size to output when the source shader does not explicitly output a
+      point size.
+    - The VKD3D_SHADER_PARAMETER_NAME_POINT_SIZE_MIN shader parameter specifies
+      the minimum point size to clamp point size outputs to.
+    - The VKD3D_SHADER_PARAMETER_NAME_POINT_SIZE_MAX shader parameter specifies
+      the maximum point size to clamp point size outputs to.
+    - The VKD3D_SHADER_PARAMETER_NAME_POINT_SPRITE shader parameter specifies
+      whether texture coordinate inputs in fragment shaders should be replaced
+      with point coordinates.
+    - The VKD3D_SHADER_SOURCE_FX source type specifies binary Direct3D effects.
+    - The VKD3D_SHADER_TARGET_MSL target type specifies Metal Shading Language
+      shaders.
+
+### libvkd3d-utils
+
+  - The GetDesc() method of the ID3D12ShaderReflection interface returned by
+    D3DReflect() returns shader version information.
+
+  - New interfaces:
+    - D3DCompile2VKD3D() is a variant of D3DCompile2() that allows targeting the
+      behaviour of a specific d3dcompiler version.
+
+### vkd3d-compiler
+
+  - The ‘--alias-double-as-float’ option specifies that the ‘double’ type
+    behaves as an alias for the ‘float’ type in HLSL sources with shader model
+    1-3 target profiles.
+
+  - The ‘fx’ source type specifies binary Direct3D effects.
+
+  - The ‘msl’ target type specifies Metal Shading Language shaders.
+
+# What's new in vkd3d 1.13 (29 August 2024)
+
+### libvkd3d
+
+  - The ID3D12CommandList6 interface is supported.
+
+  - Block-compressed textures can be created with unaligned dimensions. This
+    corresponds to
+    D3D12_FEATURE_D3D12_OPTIONS8.UnalignedBlockTexturesSupported.
+
+  - Some minor issues pointed out by the Vulkan validation layers have been
+    addressed. These are not known to affect applications in practice, but
+    should make libvkd3d slightly more well-behaved.
+
+### libvkd3d-shader
+
+  - New features for the HLSL source type:
+    - Basic loop unrolling support. Some of the more complicated cases like
+      loops containing conditional jumps are still unsupported.
+    - Initialisation values for global variables, function parameters, and
+      annotation variables are parsed and stored in output formats supporting
+      them.
+    - Shader model 5.1 register spaces are supported when using the
+      corresponding target profiles, as well as shader model 5.1 reflection
+      data.
+    - Register reservations support expressions as offsets. For example:
+      ‘float f : register(c0[1 + 1 * 2]);’
+    - The tex1D(), tex2D(), tex3D(), and texCUBE() intrinsic function variants
+      with explicit derivatives are supported.
+    - The following intrinsic functions are supported:
+      - asint()
+      - f16tof32()
+      - faceforward()
+      - GetRenderTargetSampleCount()
+      - rcp()
+      - tex2Dbias()
+      - tex1Dgrad(), tex2Dgrad(), tex3Dgrad(), and texCUBEgrad()
+    - The sin() and cos() intrinsic functions are supported in shader model
+      1-3 profiles. These were already supported in shader model 4+ profiles.
+    - The following features specific to effects target profiles:
+      - Types supported in version 4.0+:
+        - BlendState
+        - ComputeShader, DomainShader, GeometryShader, and HullShader
+        - DepthStencilState
+        - RasterizerState
+      - State application functions implemented for version 4.0+ effects:
+        - OMSetRenderTargets()
+        - SetBlendState()
+        - SetComputeShader(), SetDomainShader(), SetGeometryShader(),
+          SetHullShader(), SetPixelShader(), and SetVertexShader()
+        - SetDepthStencilState()
+        - SetRasterizerState()
+      - String types. These are mainly used for annotations.
+      - Annotations on global variables.
+      - Support for the ‘Texture’ field of the ‘SamplerState’ type.
+      - Support for NULL values.
+    - Stores to swizzled matrix variables.
+    - The ‘unsigned’ type modifier is supported. (For example,
+      ‘unsigned int’.) Note that ‘uint’ and related types were already
+      supported.
+    - ‘ConstantBuffer<>’ types.
+    - The ‘SV_Coverage’ output semantic for fragment shaders.
+
+  - The experimental DXIL source type supports quad group operations.
+
+  - The Direct3D shader model 2-3 ‘texldb’ instruction is correctly disassembled
+    when outputting Direct3D shader assembly.
+
+  - New interfaces:
+    - The vkd3d_shader_parameter_info structure extends the
+      vkd3d_shader_compile_info structure, and can be used to specify shader
+      parameters. This is a more generic version of the shader parameter
+      interface for SPIR-V targets in struct vkd3d_shader_spirv_target_info.
+    - The VKD3D_SHADER_PARAMETER_DATA_TYPE_FLOAT32 enumeration value specifies
+      that a shader parameter contains 32-bit floating-point data.
+    - The VKD3D_SHADER_PARAMETER_NAME_ALPHA_TEST_FUNC shader parameter
+      specifies the alpha test function.
+    - The VKD3D_SHADER_PARAMETER_NAME_ALPHA_TEST_REF shader parameter
+      specifies the alpha test reference value.
+    - The VKD3D_SHADER_PARAMETER_NAME_FLAT_INTERPOLATION shader parameter
+      specifies the interpolation mode for colour inputs in Direct3D shader
+      model 1-3 fragment shaders.
+    - The VKD3D_SHADER_PARAMETER_TYPE_BUFFER enumeration value specifies that
+      the value of a shader parameter is provided at run-time through a buffer
+      resource.
+
 # What's new in vkd3d 1.12 (28 May 2024)
 
 ### libvkd3d

Doxyfile.in

@@ -10,6 +10,7 @@ OPTIMIZE_OUTPUT_FOR_C  = YES
 EXTRACT_STATIC         = YES
 QUIET                  = YES
 WARN_IF_UNDOCUMENTED   = NO
+WARN_IF_INCOMPLETE_DOC = NO
 LATEX_BATCHMODE        = YES
 
 INPUT                  = @srcdir@/include/vkd3d.h \

Makefile.am

@@ -2,6 +2,12 @@ ACLOCAL_AMFLAGS = -I m4
 AM_CFLAGS = @VKD3D_CFLAGS@
 AM_CPPFLAGS = -I$(srcdir)/include -I$(srcdir)/include/private -I$(builddir)/include/private
 AM_LDFLAGS = -no-undefined
+VKD3D_PERL = $(PERL) -w
+
+objc_headers = \
+	include/private/appkit.h \
+	include/private/foundation.h \
+	include/private/quartzcore.h
 
 widl_headers = \
 	include/vkd3d_d3d12.h \
@@ -48,8 +54,8 @@ vkd3d_cross_tests = \
 vkd3d_shader_tests = \
 	tests/hlsl/abs.shader_test \
 	tests/hlsl/all.shader_test \
+	tests/hlsl/alpha-test.shader_test \
 	tests/hlsl/angle-unit.shader_test \
-	tests/hlsl/annotations.shader_test \
 	tests/hlsl/any.shader_test \
 	tests/hlsl/arithmetic-float-uniform.shader_test \
 	tests/hlsl/arithmetic-float.shader_test \
@@ -60,8 +66,11 @@ vkd3d_shader_tests = \
 	tests/hlsl/array-parameters.shader_test \
 	tests/hlsl/array-size-expr.shader_test \
 	tests/hlsl/asfloat.shader_test \
+	tests/hlsl/asint.shader_test \
 	tests/hlsl/asuint.shader_test \
 	tests/hlsl/attributes.shader_test \
+	tests/hlsl/barriers.shader_test \
+	tests/hlsl/bitwise-assignment.shader_test \
 	tests/hlsl/bitwise.shader_test \
 	tests/hlsl/bool-cast.shader_test \
 	tests/hlsl/bool-semantics.shader_test \
@@ -78,37 +87,57 @@ vkd3d_shader_tests = \
 	tests/hlsl/ceil.shader_test \
 	tests/hlsl/cf-cond-types.shader_test \
 	tests/hlsl/clamp.shader_test \
-	tests/hlsl/clip-distance.shader_test \
+	tests/hlsl/clip-cull-distance.shader_test \
+	tests/hlsl/clip-planes.shader_test \
 	tests/hlsl/clip.shader_test \
 	tests/hlsl/combined-samplers.shader_test \
 	tests/hlsl/comma.shader_test \
 	tests/hlsl/compute.shader_test \
 	tests/hlsl/conditional.shader_test \
 	tests/hlsl/const.shader_test \
+	tests/hlsl/constructgswithso.shader_test \
 	tests/hlsl/coverage.shader_test \
 	tests/hlsl/cross.shader_test \
 	tests/hlsl/d3dcolor-to-ubyte4.shader_test \
 	tests/hlsl/ddxddy.shader_test \
 	tests/hlsl/default-values.shader_test \
+	tests/hlsl/depth-bounds.shader_test \
 	tests/hlsl/depth-out.shader_test \
 	tests/hlsl/determinant.shader_test \
 	tests/hlsl/discard.shader_test \
 	tests/hlsl/distance.shader_test \
 	tests/hlsl/dot.shader_test \
 	tests/hlsl/duplicate-modifiers.shader_test \
+	tests/hlsl/early-depth-stencil.shader_test \
+	tests/hlsl/effect-annotations-fx_2.shader_test \
+	tests/hlsl/effect-annotations-fx_4.shader_test \
+	tests/hlsl/effect-assignments-fx_5.shader_test \
 	tests/hlsl/effect-compile.shader_test \
+	tests/hlsl/effect-initial-values-fx_2.shader_test \
+	tests/hlsl/effect-initial-values-fx_4.shader_test \
+	tests/hlsl/effect-pass-states-fx_4.shader_test \
+	tests/hlsl/effect-pass-states-fx_5.shader_test \
 	tests/hlsl/effect-shader-objects-fx_2.shader_test \
 	tests/hlsl/effect-shader-objects-fx_5.shader_test \
 	tests/hlsl/effect-technique-fx_2.shader_test \
 	tests/hlsl/effect-technique-fx_4.shader_test \
 	tests/hlsl/effect-technique-fx_5.shader_test \
 	tests/hlsl/effect-variables-fx_2.shader_test \
+	tests/hlsl/effect-variables-fx_4.shader_test \
+	tests/hlsl/effect-variables-fx_4_1.shader_test \
+	tests/hlsl/effect-variables-fx_5.shader_test \
 	tests/hlsl/entry-point-semantics.shader_test \
+	tests/hlsl/eval-attrib.shader_test \
 	tests/hlsl/exp.shader_test \
 	tests/hlsl/expr-indexing.shader_test \
+	tests/hlsl/f16tof32.shader_test \
+	tests/hlsl/f32tof16.shader_test \
+	tests/hlsl/faceforward.shader_test \
+	tests/hlsl/ffp-point-size.shader_test \
 	tests/hlsl/float-comparison.shader_test \
 	tests/hlsl/floor.shader_test \
 	tests/hlsl/fmod.shader_test \
+	tests/hlsl/fog.shader_test \
 	tests/hlsl/for.shader_test \
 	tests/hlsl/frac.shader_test \
 	tests/hlsl/function-cast.shader_test \
@@ -117,13 +146,17 @@ vkd3d_shader_tests = \
 	tests/hlsl/function.shader_test \
 	tests/hlsl/fwidth.shader_test \
 	tests/hlsl/fxgroup-syntax.shader_test \
+	tests/hlsl/gather-cmp.shader_test \
 	tests/hlsl/gather-offset.shader_test \
 	tests/hlsl/gather.shader_test \
+	tests/hlsl/geometry-shader-syntax.shader_test \
 	tests/hlsl/geometry.shader_test \
 	tests/hlsl/get-sample-pos.shader_test \
 	tests/hlsl/getdimensions.shader_test \
 	tests/hlsl/half.shader_test \
 	tests/hlsl/hard-copy-prop.shader_test \
+	tests/hlsl/hull-shader-attributes.shader_test \
+	tests/hlsl/hull-shader-syntax.shader_test \
 	tests/hlsl/initializer-flatten.shader_test \
 	tests/hlsl/initializer-implicit-array.shader_test \
 	tests/hlsl/initializer-invalid-arg-count.shader_test \
@@ -136,13 +169,18 @@ vkd3d_shader_tests = \
 	tests/hlsl/initializer-static-array.shader_test \
 	tests/hlsl/initializer-struct.shader_test \
 	tests/hlsl/instance-id.shader_test \
+	tests/hlsl/interface-packing.shader_test \
 	tests/hlsl/intrinsic-override.shader_test \
 	tests/hlsl/invalid.shader_test \
 	tests/hlsl/inverse-trig.shader_test \
 	tests/hlsl/is-front-face.shader_test \
+	tests/hlsl/isinf.shader_test \
 	tests/hlsl/ldexp.shader_test \
+	tests/hlsl/length-property.shader_test \
 	tests/hlsl/length.shader_test \
 	tests/hlsl/lerp.shader_test \
+	tests/hlsl/lhs-cast.shader_test \
+	tests/hlsl/lhs-partial-assignment.shader_test \
 	tests/hlsl/lit.shader_test \
 	tests/hlsl/load-level.shader_test \
 	tests/hlsl/log.shader_test \
@@ -156,22 +194,31 @@ vkd3d_shader_tests = \
 	tests/hlsl/matrix-semantics.shader_test \
 	tests/hlsl/max-min.shader_test \
 	tests/hlsl/minimum-precision.shader_test \
+	tests/hlsl/modf.shader_test \
 	tests/hlsl/mul.shader_test \
 	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 \
 	tests/hlsl/numeric-constructor-truncation.shader_test \
 	tests/hlsl/numeric-types.shader_test \
 	tests/hlsl/numthreads.shader_test \
 	tests/hlsl/object-field-offsets.shader_test \
 	tests/hlsl/object-parameters.shader_test \
 	tests/hlsl/object-references.shader_test \
+	tests/hlsl/patch-syntax.shader_test \
+	tests/hlsl/pixel-position.shader_test \
+	tests/hlsl/point-sprite.shader_test \
 	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 \
 	tests/hlsl/refract.shader_test \
 	tests/hlsl/register-reservations-numeric.shader_test \
@@ -179,28 +226,39 @@ 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 \
+	tests/hlsl/rt-format-mismatch.shader_test \
 	tests/hlsl/rt-get-sample-info.shader_test \
 	tests/hlsl/sample-bias.shader_test \
 	tests/hlsl/sample-cmp.shader_test \
 	tests/hlsl/sample-grad.shader_test \
 	tests/hlsl/sample-level.shader_test \
 	tests/hlsl/sampler-offset.shader_test \
+	tests/hlsl/sampler-state.shader_test \
 	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 \
 	tests/hlsl/shape.shader_test \
 	tests/hlsl/side-effects.shader_test \
 	tests/hlsl/sign.shader_test \
 	tests/hlsl/single-numeric-initializer.shader_test \
 	tests/hlsl/sm1-const-allocation.shader_test \
 	tests/hlsl/sm1-const-folding.shader_test \
+	tests/hlsl/sm1-interstage-interface.shader_test \
 	tests/hlsl/sm6-ternary.shader_test \
 	tests/hlsl/sm6-uav-rwtexture.shader_test \
 	tests/hlsl/smoothstep.shader_test \
 	tests/hlsl/sqrt.shader_test \
 	tests/hlsl/srv-buffers.shader_test \
+	tests/hlsl/srv-byteaddressbuffer.shader_test \
+	tests/hlsl/srv-structuredbuffer.shader_test \
 	tests/hlsl/state-block-function-syntax.shader_test \
 	tests/hlsl/state-block-syntax.shader_test \
 	tests/hlsl/static-initializer.shader_test \
@@ -209,12 +267,15 @@ vkd3d_shader_tests = \
 	tests/hlsl/strings.shader_test \
 	tests/hlsl/struct-array.shader_test \
 	tests/hlsl/struct-assignment.shader_test \
+	tests/hlsl/struct-inheritance.shader_test \
 	tests/hlsl/struct-semantics.shader_test \
+	tests/hlsl/struct-syntax.shader_test \
 	tests/hlsl/switch.shader_test \
 	tests/hlsl/swizzle-constant-prop.shader_test \
 	tests/hlsl/swizzle-matrix.shader_test \
 	tests/hlsl/swizzles.shader_test \
 	tests/hlsl/ternary.shader_test \
+	tests/hlsl/tessellation-patch-vars.shader_test \
 	tests/hlsl/tessellation.shader_test \
 	tests/hlsl/texture-load-offset.shader_test \
 	tests/hlsl/texture-load-typed.shader_test \
@@ -236,9 +297,14 @@ vkd3d_shader_tests = \
 	tests/hlsl/unbounded-array-5.1.shader_test \
 	tests/hlsl/uniform-parameters.shader_test \
 	tests/hlsl/uniform-semantics.shader_test \
+	tests/hlsl/uninitialized-varyings.shader_test \
+	tests/hlsl/unorm-snorm.shader_test \
+	tests/hlsl/unroll.shader_test \
+	tests/hlsl/unsigned.shader_test \
 	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 \
@@ -260,18 +326,24 @@ vkd3d_test_headers = \
 	tests/dxcompiler.h \
 	tests/shader_runner.h \
 	tests/utils.h \
-	tests/vulkan_procs.h
+	tests/vulkan_procs.h \
+	tests/vulkan_utils.h
 
 vkd3d_demos = \
 	demos/vkd3d-gears \
+	demos/vkd3d-teapot \
 	demos/vkd3d-triangle
 
 vkd3d_demos_headers = \
 	demos/demo.h \
+	demos/demo_d3d12.h \
+	demos/demo_macos.h \
+	demos/demo_vkd3d.h \
 	demos/demo_win32.h \
 	demos/demo_xcb.h
 
-BUILT_SOURCES = $(widl_headers) \
+BUILT_SOURCES = $(objc_headers) $(widl_headers) \
+	include/private/spirv_grammar.h \
 	include/private/vkd3d_version.h
 
 noinst_LTLIBRARIES = libvkd3d-common.la
@@ -330,6 +402,7 @@ nodist_libvkd3d_shader_la_SOURCES = $(vkd3d_shader_yyfiles)
 libvkd3d_shader_la_SOURCES = \
 	include/private/list.h \
 	include/private/rbtree.h \
+	include/private/spirv_grammar.h \
 	include/private/vkd3d_common.h \
 	include/private/vkd3d_memory.h \
 	include/vkd3d_shader.h \
@@ -345,6 +418,7 @@ libvkd3d_shader_la_SOURCES = \
 	libs/vkd3d-shader/hlsl_codegen.c \
 	libs/vkd3d-shader/hlsl_constant_ops.c \
 	libs/vkd3d-shader/ir.c \
+	libs/vkd3d-shader/msl.c \
 	libs/vkd3d-shader/preproc.h \
 	libs/vkd3d-shader/spirv.c \
 	libs/vkd3d-shader/tpf.c \
@@ -352,7 +426,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 11:0:10
+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
@@ -387,7 +461,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 13:0:12
+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
@@ -400,7 +474,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 6:1:5
+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
@@ -432,15 +506,20 @@ LDADD = libvkd3d.la libvkd3d-shader.la libvkd3d-utils.la
 AM_DEFAULT_SOURCE_EXT = .c
 
 TEST_EXTENSIONS = .shader_test
+TEST_CPPFLAGS = -I$(builddir)/tests
 
 if BUILD_TESTS
 check_PROGRAMS = $(vkd3d_tests) $(vkd3d_cross_tests) tests/shader_runner
 dist_check_SCRIPTS = tests/test-driver.sh
 TESTS = $(vkd3d_tests) $(vkd3d_cross_tests) $(vkd3d_shader_tests)
+tests_d3d12_CPPFLAGS = $(AM_CPPFLAGS) $(TEST_CPPFLAGS)
 tests_d3d12_LDADD = $(LDADD) @PTHREAD_LIBS@ @DL_LIBS@
+tests_d3d12_invalid_usage_CPPFLAGS = $(AM_CPPFLAGS) $(TEST_CPPFLAGS)
 tests_d3d12_invalid_usage_LDADD = $(LDADD) @DL_LIBS@
+tests_hlsl_d3d12_CPPFLAGS = $(AM_CPPFLAGS) $(TEST_CPPFLAGS)
 tests_hlsl_d3d12_LDADD = $(LDADD) @DL_LIBS@
-tests_shader_runner_CFLAGS = $(AM_CFLAGS) -I$(builddir)/tests @OPENGL_CFLAGS@
+tests_shader_runner_CPPFLAGS = $(AM_CPPFLAGS) $(TEST_CPPFLAGS)
+tests_shader_runner_CFLAGS = $(AM_CFLAGS) @OPENGL_CFLAGS@
 tests_shader_runner_LDADD = $(LDADD) @OPENGL_LIBS@ @DL_LIBS@
 tests_shader_runner_SOURCES = \
 	tests/shader_runner.c \
@@ -449,8 +528,18 @@ tests_shader_runner_SOURCES = \
 	tests/shader_runner_d3d12.c \
 	tests/shader_runner_gl.c \
 	tests/shader_runner_vulkan.c
+if HAVE_METAL
+tests_shader_runner_OBJCFLAGS = $(AM_CFLAGS)
+tests_shader_runner_SOURCES += tests/shader_runner_metal.m
+tests_shader_runner_LINK = $(OBJCLINK) -framework Foundation -framework Metal
+else
+tests_shader_runner_LINK = $(LINK)
+endif
+tests_vkd3d_api_CPPFLAGS = $(AM_CPPFLAGS) $(TEST_CPPFLAGS)
 tests_vkd3d_api_LDADD = libvkd3d.la @DL_LIBS@
-tests_vkd3d_shader_api_LDADD = libvkd3d-shader.la
+tests_vkd3d_shader_api_CPPFLAGS = $(AM_CPPFLAGS) $(TEST_CPPFLAGS)
+tests_vkd3d_shader_api_CFLAGS = $(AM_CFLAGS) @OPENGL_CFLAGS@
+tests_vkd3d_shader_api_LDADD = libvkd3d-shader.la @OPENGL_LIBS@ @DL_LIBS@
 SHADER_TEST_LOG_COMPILER = tests/shader_runner
 SHADER_TEST_LOG_DRIVER = $(srcdir)/tests/test-driver.sh
 endif
@@ -458,20 +547,45 @@ endif
 EXTRA_DIST += $(vkd3d_shader_tests)
 
 if BUILD_DEMOS
-DEMOS_LDADD = $(LDADD) libvkd3d-shader.la @DL_LIBS@ @DEMO_LIBS@
-DEMOS_CFLAGS = $(AM_CFLAGS) @DEMO_CFLAGS@
+DEMOS_LDADD = $(LDADD) @DL_LIBS@ @DEMO_LIBS@
+DEMOS_CFLAGS = $(AM_CFLAGS) @DEMO_CFLAGS@ -I$(srcdir)/demos -Wa,-I$(srcdir)/demos
 bin_PROGRAMS += $(vkd3d_demos)
 
-demos_vkd3d_gears_SOURCES = demos/gears.c demos/gears_hlsl.h
+demos_vkd3d_gears_SOURCES = demos/gears.c demos/gears.hlsl
 demos_vkd3d_gears_CFLAGS = $(DEMOS_CFLAGS)
 demos_vkd3d_gears_LDADD = $(DEMOS_LDADD) -lm
+demos/vkd3d_gears-gears.$(OBJEXT): demos/gears.hlsl
 
-demos_vkd3d_triangle_SOURCES = demos/triangle.c demos/triangle_hlsl.h
+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)
+demos/vkd3d_triangle-triangle.$(OBJEXT): demos/triangle.hlsl
 endif
 
 noinst_HEADERS = $(vkd3d_test_headers) $(vkd3d_demos_headers)
+dist_noinst_SCRIPTS = libs/vkd3d-shader/make_spirv demos/make_objc
+
+VKD3D_V_PERL = $(vkd3d_v_perl_@AM_V@)
+vkd3d_v_perl_ = $(vkd3d_v_perl_@AM_DEFAULT_V@)
+vkd3d_v_perl_0 = @echo "  PERL    " $@;
+vkd3d_v_perl_1 =
+
+CLEANFILES += $(objc_headers)
+${objc_headers}: %.h: demos/make_objc %.json
+	@$(MKDIR_P) $(@D)
+	$(VKD3D_V_PERL)$(VKD3D_PERL) $^ > $@.tmp && mv $@.tmp $@
 
 VKD3D_V_WIDL = $(vkd3d_v_widl_@AM_V@)
 vkd3d_v_widl_ = $(vkd3d_v_widl_@AM_DEFAULT_V@)
@@ -481,7 +595,11 @@ vkd3d_v_widl_1 =
 if HAVE_WIDL
 CLEANFILES += $(widl_headers)
 endif
-EXTRA_DIST += $(widl_headers) $(widl_headers:.h=.idl)
+EXTRA_DIST += \
+	$(widl_headers) \
+	$(widl_headers:.h=.idl) \
+	$(objc_headers:.h=.json) \
+	include/private/spirv.core.grammar.json
 $(widl_headers): %.h: %.idl
 if HAVE_WIDL
 	$(VKD3D_V_WIDL)$(WIDL) -I$(srcdir)/include -h -o $@ $<
@@ -513,6 +631,10 @@ libvkd3d.pc: $(srcdir)/libs/vkd3d/libvkd3d.pc.in Makefile
 		-e 's![@]PACKAGE_VERSION[@]!$(PACKAGE_VERSION)!g' \
 		$< > $@
 
+include/private/spirv_grammar.h: libs/vkd3d-shader/make_spirv include/private/spirv.core.grammar.json
+	@$(MKDIR_P) $(@D)
+	$(VKD3D_V_PERL)$(VKD3D_PERL) $^ > $@.tmp && mv $@.tmp $@
+
 include/private/vkd3d_version.h: dummy-vkd3d-version
 	@$(MKDIR_P) include/private
 	version=`(GIT_DIR=$(top_srcdir)/.git git rev-parse --short HEAD 2>/dev/null || echo '') \
@@ -521,7 +643,7 @@ include/private/vkd3d_version.h: dummy-vkd3d-version
 		&& (echo $$version | cmp -s - $@) \
 		|| echo $$version >$@ || ($(RM) $@ && exit 1)
 .SILENT: include/private/vkd3d_version.h
-CLEANFILES += include/private/vkd3d_version.h
+CLEANFILES += include/private/spirv_grammar.h include/private/vkd3d_version.h
 
 .PHONY: dummy-vkd3d-version
 dummy-vkd3d-version:
@@ -529,7 +651,7 @@ dummy-vkd3d-version:
 ## Cross-compile tests
 cross_implibs = crosslibs/d3d12
 CROSS_CPPFLAGS = -I$(srcdir)/include -I$(srcdir)/include/private -I$(builddir)/include -I$(builddir)/tests
-CROSS_CFLAGS = -g -O2 -Wall -municode ${CROSS_CPPFLAGS} \
+CROSS_CFLAGS = -g -O2 -Wall -municode ${CROSS_CPPFLAGS} -Wa,-I$(srcdir)/demos \
 	-D_WIN32_WINNT=0x0600 -D__USE_MINGW_ANSI_STDIO=0 -DVKD3D_CROSSTEST=1
 EXTRA_DIST += $(cross_implibs:=.cross32.def) $(cross_implibs:=.cross64.def)
 EXTRA_DIST += tests/driver.c tests/shader_runner_d3d11.c tests/shader_runner_d3d9.c
@@ -553,6 +675,9 @@ CROSS32_EXEFILES += $(vkd3d_cross_tests:=.cross32.exe)
 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
 
 CROSS32_FILES = $(CROSS32_EXEFILES)
@@ -600,6 +725,9 @@ CROSS64_EXEFILES += $(vkd3d_cross_tests:=.cross64.exe)
 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
 
 CROSS64_FILES = $(CROSS64_EXEFILES)

README

@@ -9,7 +9,8 @@ similar, but not identical, to Direct3D 12.
 Building vkd3d
 ==============
 
-Vkd3d depends on SPIRV-Headers and Vulkan-Headers (>= 1.3.228).
+Vkd3d depends on SPIRV-Headers and Vulkan-Headers (>= 1.3.228), as well as Perl
+and libjson-perl.
 
 Vkd3d generates some of its headers from IDL files. If you are using the
 release tarballs, then these headers are pre-generated and are included. If
@@ -19,10 +20,20 @@ available or is not recent (>= 3.21), then you can build Wine with `make
 tools/widl/widl' to avoid building all of Wine. You can then point vkd3d's
 configure at that widl binary with `WIDL="/path/to/widl"'.
 
-For release builds, you may want to define NDEBUG. If you do not need debug log
-messages, you may also consider VKD3D_NO_TRACE_MESSAGES and
-VKD3D_NO_DEBUG_MESSAGES. For example, you can pass `CPPFLAGS="-DNDEBUG
--DVKD3D_NO_TRACE_MESSAGES"' to configure.
+For release builds, you may want to disable debug log messages defining
+preprocessor macros VKD3D_NO_TRACE_MESSAGES and VKD3D_NO_DEBUG_MESSAGES.
+See the `Preprocessor definitions' section below for more details.
+
+================
+Developing vkd3d
+================
+
+Development of vkd3d happens on the Wine GitLab instance
+(https://gitlab.winehq.org/wine/vkd3d/). Contributors are encouraged
+to submit their patches using the merge request tool.
+
+Each merge request is automatically tested with the GitLab CI
+system. See gitlab/README in the Git tree for more details.
 
 ===========
 Using vkd3d
@@ -39,8 +50,8 @@ Environment variables
 =====================
 
 Most of the environment variables used by vkd3d are for debugging purposes. The
-environment variables are not considered a part of API and might be changed or
-removed in the future versions of vkd3d.
+environment variables are not considered a stable interface and might be changed
+or removed in future versions of vkd3d.
 
 Some of debug variables are lists of elements. Elements must be separated by
 commas or semicolons.
@@ -65,6 +76,14 @@ commas or semicolons.
  * VKD3D_DISABLE_EXTENSIONS - a list of Vulkan extensions that libvkd3d should
    not use even if available.
 
+ * VKD3D_CAPS_OVERRIDE - a list of Direct3D 12 capabilities for which the
+   default value detected by vkd3d should be overridden, in the form
+   `capability1=value1,capability2=value2'. This doesn't change the vkd3d
+   behaviour, only the information reported to the application. The following
+   capabilities can currently be overridden:
+    * feature_level (allowed values: 11.0, 11.1, 12.0, 12.1, 12.2)
+    * resource_binding_tier (allowed values: 1, 2, 3)
+
  * VKD3D_SHADER_CONFIG - a list of options that change the behavior of
    libvkd3d-shader.
     * force_validation - Enable (additional) validation of libvkd3d-shader's
@@ -78,6 +97,10 @@ commas or semicolons.
  * VKD3D_TEST_DEBUG - enables additional debug messages in tests. Set to 0, 1
    or 2.
 
+ * VKD3D_TEST_DETAILED - enables printing detailed output when running the test
+   suite, reporting specific shader_test lines that trigger XFAIL and SKIP even
+   on tests that overall PASS. Set to 0, or 1.
+
  * VKD3D_TEST_FILTER - a filter string. Only the tests whose names matches the
    filter string will be run, e.g. VKD3D_TEST_FILTER=clear_render_target.
    Useful for debugging or developing new tests.
@@ -101,13 +124,90 @@ code for adding DXBC checksums, so the official release should be installed
 from:
 https://github.com/microsoft/DirectXShaderCompiler/releases
 
-================
-Developing vkd3d
-================
+========================
+Preprocessor definitions
+========================
 
-Development of vkd3d happens on the Wine GitLab instance
-(https://gitlab.winehq.org/wine/vkd3d/). Contributors are encouraged
-to submit their patches using the merge request tool.
+A number of preprocessor definitions can be used at compilation time to control
+the behaviour of the generated binary. You can pass something like
+`CPPFLAGS="-DVKD3D_VAR1 -DVKD3D_VAR2"' to the configure script. The preprocessor
+variables are not considered a stable interface and might be changed or removed
+in future versions of vkd3d.
 
-Each merge request is automatically tested with the GitLab CI
-system. See gitlab/README in the Git tree for more details.
+ * VKD3D_NO_TRACE_MESSAGES - do not emit trace messages in the debug log; this
+   can be useful in release builds to reduce the size of the binary and make it
+   slightly faster.
+
+ * VKD3D_NO_DEBUG_MESSAGES - do not emit warn and fixme messages in the debug
+   log; this will further optimise the binary, but may omit messages that could
+   help debug problems with vkd3d.
+
+ * VKD3D_NO_ERROR_MESSAGES - do not emit error messages; this will optimise the
+   binary even more, but may omit very important messages, so it is not
+   recommended in most circumstances.
+
+ * VKD3D_ABORT_ON_ERR - abort the process as soon as an error message is
+   emitted; this can be useful for developers to make error conditions as
+   conspicuous as possible.
+
+ * VKD3D_SHADER_UNSUPPORTED_GLSL - enable GLSL (GL Shading Language) support in
+   vkd3d-shader, which is disabled by default because it is not considered ready
+   for release yet. Please note that this feature is not currently supported,
+   and it might change in a non-compatible way before it is released.
+
+ * VKD3D_SHADER_UNSUPPORTED_MSL - enable MSL (Metal Shading Language) support in
+   vkd3d-shader, which is disabled by default because it is not considered ready
+   for release yet. Please note that this feature is not currently supported,
+   and it might change in a non-compatible way before it is released.
+
+ * VKD3D_SHADER_UNSUPPORTED_SPIRV_PARSER - enable SPIR-V parser support in
+   vkd3d-shader, which is disabled by default because it is not considered ready
+   for release yet. Please note that this feature is not currently supported,
+   and it might change in a non-compatible way before it is released.
+
+============================
+Testing with the Agility SDK
+============================
+
+Traditionally Microsoft have released the Direct3D 12 development files,
+including the debug layer runtime, as part of the larger Windows SDK.
+In 2021 the DirectX 12 Agility SDK was introduced, which may be updated
+independently of the Windows SDK. If you plan to run the vkd3d
+crosstests with Microsoft's debug layer you might want to get it from
+the Agility SDK, both because it's probably going to be more up-to-date
+and because the Agility SDK is a couple dozens of megabytes versus the
+gigabytes of the Windows SDK.
+
+In order to build the vkd3d crosstests with Agility SDK support, follow
+these steps:
+
+ * The Agility SDK is distributed at [1]: select your preferred
+   version (likely the most recent one) and note the number in column
+   D3D12SDKVersion, which you're going to need later.
+
+ [1] https://devblogs.microsoft.com/directx/directx12agility/
+
+ * You also need to enable the "Graphics Tools" optional feature in Windows.
+   Open the "Settings" applications, then look for "Apps", "Optional features",
+   "View features" and install "Graphics Tools".
+
+ * Configure vkd3d with something like:
+   'CROSSCC64="x86_64-w64-mingw32-gcc -DVKD3D_AGILITY_SDK_VERSION=<version>"',
+   as well as the equivalent CROSSCC32 variable for the 32-bit
+   crosstests. You'll have to replace '<version>' with the
+   D3D12SDKVersion number you noted above. Then build the crosstests
+   with 'make crosstest' as usual.
+
+ * Download the Agility SDK NuGet package, which is essentially a ZIP
+   file with a .nupkg extension. Extract d3d12core.dll and
+   d3d12sdklayers.dll for your architecture, and put them in the
+   directory containing the crosstest executables.
+
+ * Now you can run the crosstests, possibly with arguments
+   '--validate' and '--gbv' to enable the debug layers. They will use
+   the runtime from the Agility SDK.
+
+ * It's also possible to use '-DVKD3D_AGILITY_SDK_PATH=/path/to/sdk/' to
+   specify the directory to load the Agility SDK DLLs from at runtime.
+   If relative, the path is intended to be relative to the executable
+   path. If unspecified the path defaults to './'.

configure.ac

@@ -1,13 +1,15 @@
 AC_PREREQ([2.69])
-AC_INIT([vkd3d],[1.12])
+AC_INIT([vkd3d],[1.17])
 
 AC_CONFIG_AUX_DIR([bin])
 AC_CONFIG_MACRO_DIR([m4])
 AC_CONFIG_HEADERS(include/config.h)
 
+AC_ARG_VAR([PERL], [The Perl 5 language interpreter])
 AC_ARG_VAR([WIDL], [widl IDL compiler])
 AC_ARG_VAR([CROSSCC32], [32-bit Windows cross compiler])
 AC_ARG_VAR([CROSSCC64], [64-bit Windows cross compiler])
+AC_ARG_WITH([metal], AS_HELP_STRING([--with-metal], [Build with the Metal library (default: test)]))
 AC_ARG_WITH([ncurses], AS_HELP_STRING([--with-ncurses], [Build with the ncurses library (default: test)]))
 AC_ARG_WITH([opengl], AS_HELP_STRING([--with-opengl], [Build with the OpenGL library (default: test)]))
 AC_ARG_WITH([spirv-tools], AS_HELP_STRING([--with-spirv-tools],
@@ -31,6 +33,11 @@ AC_PROG_MKDIR_P
 VKD3D_PROG_WIDL(3, 21)
 AS_IF([test "x$WIDL" = "xno"], [AC_MSG_WARN([widl is required to build header files.])])
 
+AC_CHECK_PROGS([PERL], [perl], [none])
+AS_IF([test "$PERL" = "none"], [AC_MSG_ERROR([no suitable perl found. Please install the 'perl-base' package.])])
+VKD3D_CHECK_PERL_MODULE([JSON],
+                        [AC_MSG_ERROR([perl module 'JSON' not found. Please install the 'libjson-perl' package.])])
+
 AC_CHECK_PROGS([FLEX], [flex], [none])
 AS_IF([test "$FLEX" = "none"], [AC_MSG_ERROR([no suitable flex found. Please install the 'flex' package.])])
 AC_ARG_VAR([LFLAGS], [extra flags for flex])
@@ -134,6 +141,16 @@ AS_IF([test "x$SONAME_LIBDXCOMPILER" = "x"],
       [VKD3D_CHECK_SONAME([dxcompiler], [DxcCreateInstance], [HAVE_DXCOMPILER=yes], [HAVE_DXCOMPILER=no], [$DXCOMPILER_LIBS])],
       [AC_DEFINE_UNQUOTED([SONAME_LIBDXCOMPILER],["$SONAME_LIBDXCOMPILER"],[Define to the shared object name of the dxcompiler library.])])
 
+AS_IF([test "x$with_metal" != "xno"],
+      [AC_MSG_CHECKING([for Metal])]
+      [AC_PREPROC_IFELSE([AC_LANG_PROGRAM([#include <Metal/Metal.h>])],
+                         [AC_MSG_RESULT([yes])
+                          AC_PROG_OBJC
+                          AC_DEFINE([HAVE_METAL], [1], [Define to 1 if you have Metal.])
+                          with_metal=yes],
+                         [AC_MSG_RESULT([no])
+                          AM_CONDITIONAL([am__fastdepOBJC], [false])
+                          with_metal=no])])
 AS_IF([test "x$with_ncurses" != "xno"],
       [PKG_CHECK_MODULES([NCURSES], [ncurses],
                          [AC_DEFINE([HAVE_NCURSES], [1], [Define to 1 if you have ncurses.]) with_ncurses=yes],
@@ -162,25 +179,32 @@ VKD3D_CHECK_FUNC([HAVE_SYNC_ADD_AND_FETCH], [__sync_add_and_fetch], [__sync_add_
 VKD3D_CHECK_FUNC([HAVE_SYNC_BOOL_COMPARE_AND_SWAP], [__sync_bool_compare_and_swap], [__sync_bool_compare_and_swap((int *)0, 0, 0)])
 VKD3D_CHECK_FUNC([HAVE_ATOMIC_EXCHANGE_N], [__atomic_exchange_n], [__atomic_exchange_n((int *)0, 0, 0)])
 AC_CHECK_FUNCS([gettid])
+AC_CHECK_FUNCS([pthread_threadid_np])
 
 dnl Makefiles
 case $host_os in
   mingw32*)
-      AC_SUBST([DEMO_LIBS],["-ld3d12 -ldxgi -lgdi32"])
+      AC_SUBST([DEMO_LIBS],["-lgdi32"])
       AC_SUBST([DEMO_CFLAGS],["-municode"])
       ;;
+  darwin*)
+      AC_SUBST([DEMO_LIBS],["-framework Foundation -framework AppKit -framework QuartzCore"])
+      AC_SUBST([DEMO_CFLAGS],[""])
+      ;;
   *) AS_IF([test "x$enable_demos" = "xyes" -a "x$HAVE_XCB" != "xyes"],
       [AC_MSG_ERROR([libxcb is required for demos.])])
       AC_SUBST([DEMO_LIBS],[$XCB_LIBS])
       AC_SUBST([DEMO_CFLAGS],[$XCB_CFLAGS])
       ;;
 esac
+VKD3D_CHECK_CFLAGS([-fno-lto], [DEMO_CFLAGS="$DEMO_CFLAGS -fno-lto"])
 AM_CONDITIONAL([BUILD_DEMOS], [test "x$enable_demos" = "xyes"])
 AM_CONDITIONAL([BUILD_DOC], [test $DX_FLAG_doc = 1])
 AM_CONDITIONAL([BUILD_TESTS], [test "x$enable_tests" != "xno"])
 AM_CONDITIONAL([HAVE_WIDL], [test "x$WIDL" != "xno"])
 AM_CONDITIONAL([HAVE_CROSSTARGET32], [test "x$CROSSTARGET32" != "xno"])
 AM_CONDITIONAL([HAVE_CROSSTARGET64], [test "x$CROSSTARGET64" != "xno"])
+AM_CONDITIONAL([HAVE_METAL], [test "${host_os#darwin}" != "$host_os"])
 
 AC_CONFIG_FILES([Makefile])
 AC_OUTPUT
@@ -197,11 +221,12 @@ AS_ECHO(["
 
   widl: ${WIDL}
 
+  Have dxcompiler: ${HAVE_DXCOMPILER}
+  Have Metal: ${with_metal}
   Have ncurses: ${with_ncurses}
   Have OpenGL: ${with_opengl}
   Have SPIRV-Tools: ${with_spirv_tools}
   Have xcb: ${HAVE_XCB}
-  Have dxcompiler: ${HAVE_DXCOMPILER}
 
   Building demos: ${enable_demos}
   Building tests: ${enable_tests}

demos/demo.h

@@ -38,15 +38,69 @@
 #define COBJMACROS
 #include <vkd3d_d3d12.h>
 #include <inttypes.h>
+#include <math.h>
+
+#ifdef __WIN32__
+#define DEMO_ASM_PUSHSECTION ".section rdata\n\t"
+#define DEMO_ASM_POPSECTION ".text\n\t"
+#define DEMO_ASM_OBJECT_TYPE(name)
+#elif defined(__APPLE__)
+#define DEMO_ASM_PUSHSECTION ".pushsection __TEXT,__const\n\t"
+#define DEMO_ASM_POPSECTION ".popsection\n\t"
+#define DEMO_ASM_OBJECT_TYPE(name)
+#else
+#define DEMO_ASM_PUSHSECTION ".pushsection .rodata\n\t"
+#define DEMO_ASM_POPSECTION ".popsection\n\t"
+#define DEMO_ASM_OBJECT_TYPE(name) ".type "name", @object\n\t"
+#endif
+
+#if (defined(__WIN32__) && defined(__i386__)) || defined(__APPLE__)
+#define DEMO_ASM_NAME(name) "_"#name
+#else
+#define DEMO_ASM_NAME(name) #name
+#endif
+
+#define DEMO_EMBED_ASM(name, file) \
+    DEMO_ASM_PUSHSECTION \
+    ".global "name"\n\t" \
+    DEMO_ASM_OBJECT_TYPE(name) \
+    ".balign 8\n\t" \
+    name":\n\t" \
+    ".incbin \""file"\"\n\t" \
+    name"_end:\n\t" \
+    ".global "name"_size\n\t" \
+    DEMO_ASM_OBJECT_TYPE(name"_size") \
+    ".balign 8\n\t" \
+    name"_size:\n\t" \
+    ".int "name"_end - "name"\n\t" \
+    DEMO_ASM_POPSECTION
+
+#define DEMO_EMBED(name, file) \
+    extern const unsigned int name##_size; \
+    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
 {
@@ -58,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;
@@ -75,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;
@@ -83,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;
@@ -138,9 +296,11 @@ static inline HRESULT demo_create_root_signature(ID3D12Device *device,
     return hr;
 }
 
-#ifdef _WIN32
-#include "demo_win32.h"
+#ifdef VKD3D_CROSSTEST
+#include "demo_d3d12.h"
 #else
-#define INFINITE VKD3D_INFINITE
-#include "demo_xcb.h"
+# ifndef _WIN32
+#  define INFINITE VKD3D_INFINITE
+# endif
+#include "demo_vkd3d.h"
 #endif

demos/demo_d3d12.h

@@ -0,0 +1,261 @@
+/*
+ * Copyright 2016 Józef Kucia for CodeWeavers
+ * Copyright 2016 Henri Verbeet for CodeWeavers
+ *
+ * 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
+ */
+
+#include <vkd3d_dxgi1_4.h>
+#include <vkd3d_d3dcompiler.h>
+#include <stdbool.h>
+#include <stdio.h>
+
+struct demo_win32
+{
+    UINT (*GetDpiForSystem)(void);
+};
+
+struct demo
+{
+    union
+    {
+        struct demo_win32 win32;
+    } u;
+
+    size_t window_count;
+
+    void *user_data;
+    void (*idle_func)(struct demo *demo, void *user_data);
+};
+
+struct demo_window
+{
+    struct demo *demo;
+
+    void *user_data;
+    void (*expose_func)(struct demo_window *window, void *user_data);
+    void (*key_press_func)(struct demo_window *window, demo_key key, void *user_data);
+};
+
+static inline bool demo_window_init(struct demo_window *window, struct demo *demo, void *user_data)
+{
+    window->demo = demo;
+    window->user_data = user_data;
+    window->expose_func = NULL;
+    window->key_press_func = NULL;
+    ++demo->window_count;
+
+    return true;
+}
+
+static inline void demo_window_cleanup(struct demo_window *window)
+{
+    --window->demo->window_count;
+}
+
+#include "demo_win32.h"
+
+struct demo_swapchain
+{
+    IDXGISwapChain3 *swapchain;
+    unsigned int buffer_count;
+    char device_name[128];
+};
+
+static inline void demo_cleanup(struct demo *demo)
+{
+    demo_win32_cleanup(demo);
+}
+
+static inline bool demo_init(struct demo *demo, void *user_data)
+{
+    if (!demo_win32_init(&demo->u.win32))
+    {
+        fprintf(stderr, "Failed to initialise demo.\n");
+        return false;
+    }
+
+    demo->window_count = 0;
+    demo->user_data = user_data;
+    demo->idle_func = NULL;
+
+    return true;
+}
+
+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);
+}
+
+static inline void demo_set_idle_func(struct demo *demo,
+        void (*idle_func)(struct demo *demo, void *user_data))
+{
+    demo->idle_func = idle_func;
+}
+
+static inline void demo_window_destroy(struct demo_window *window)
+{
+    demo_window_win32_destroy(window);
+}
+
+static inline struct demo_window *demo_window_create(struct demo *demo, const char *title,
+        unsigned int width, unsigned int height, void *user_data)
+{
+    return demo_window_win32_create(demo, title, width, height, user_data);
+}
+
+static inline void demo_window_set_expose_func(struct demo_window *window,
+        void (*expose_func)(struct demo_window *window, void *user_data))
+{
+    window->expose_func = expose_func;
+}
+
+static inline void demo_window_set_key_press_func(struct demo_window *window,
+        void (*key_press_func)(struct demo_window *window, demo_key key, void *user_data))
+{
+    window->key_press_func = key_press_func;
+}
+
+static inline struct demo_swapchain *demo_swapchain_create(ID3D12CommandQueue *command_queue,
+        struct demo_window *window, const struct demo_swapchain_desc *desc)
+{
+    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;
+
+    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;
+    swapchain_desc.Height = desc->height;
+    swapchain_desc.Format = desc->format;
+    swapchain_desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
+    swapchain_desc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD;
+    swapchain_desc.SampleDesc.Count = 1;
+
+    hr = IDXGIFactory2_CreateSwapChainForHwnd(factory, (IUnknown *)command_queue,
+            window_win32->window, &swapchain_desc, NULL, NULL, &swapchain1);
+    IDXGIFactory2_Release(factory);
+    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))
+        goto fail;
+
+    return swapchain;
+
+fail:
+    free(swapchain);
+    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);
+}
+
+static inline ID3D12Resource *demo_swapchain_get_back_buffer(struct demo_swapchain *swapchain, unsigned int index)
+{
+    ID3D12Resource *buffer;
+
+    if (FAILED(IDXGISwapChain3_GetBuffer(swapchain->swapchain, index,
+            &IID_ID3D12Resource, (void **)&buffer)))
+        return NULL;
+
+    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);
+}
+
+static inline void demo_swapchain_destroy(struct demo_swapchain *swapchain)
+{
+    IDXGISwapChain3_Release(swapchain->swapchain);
+    free(swapchain);
+}
+
+static inline HANDLE demo_create_event(void)
+{
+    return CreateEventA(NULL, FALSE, FALSE, NULL);
+}
+
+static inline unsigned int demo_wait_event(HANDLE event, unsigned int ms)
+{
+    return WaitForSingleObject(event, ms);
+}
+
+static inline void demo_destroy_event(HANDLE event)
+{
+    CloseHandle(event);
+}

demos/demo_macos.h

@@ -0,0 +1,324 @@
+/*
+ * 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
+ */
+
+typedef long NSInteger;
+typedef unsigned long NSUInteger;
+
+typedef struct NSPoint
+{
+    double x, y;
+} NSPoint;
+
+typedef struct NSRect
+{
+    double x, y;
+    double w, h;
+} NSRect;
+
+#define BOOL OBJC_BOOL
+#include "private/appkit.h"
+#include "private/foundation.h"
+#include "private/quartzcore.h"
+#undef BOOL
+
+extern const id NSDefaultRunLoopMode;
+
+enum NSBackingStoreType
+{
+    NSBackingStoreBuffered = 2,
+};
+
+enum NSEventType
+{
+    NSEventTypeKeyDown = 0xa,
+    NSEventTypeApplicationDefined = 0xf,
+};
+
+enum NSWindowStyleMask
+{
+    NSWindowStyleMaskBorderless             = 0x0000,
+    NSWindowStyleMaskTitled                 = 0x0001,
+    NSWindowStyleMaskClosable               = 0x0002,
+    NSWindowStyleMaskMiniaturizable         = 0x0004,
+    NSWindowStyleMaskResizable              = 0x0008,
+    NSWindowStyleMaskUtilityWindow          = 0x0010,
+    NSWindowStyleMaskDocModalWindow         = 0x0040,
+    NSWindowStyleMaskNonactivatingPanel     = 0x0080,
+    NSWindowStyleMaskUnifiedTitleAndToolbar = 0x1000,
+    NSWindowStyleMaskHUDWindow              = 0x2000,
+    NSWindowStyleMaskFullScreen             = 0x4000,
+    NSWindowStyleMaskFullSizeContentView    = 0x8000,
+};
+
+enum
+{
+    DemoWindowDestroyed,
+};
+
+struct demo_window_macos
+{
+    struct demo_window w;
+    id window;
+    id layer;
+};
+
+static struct demo_window_macos *demo_macos_find_macos_window(struct demo *demo, id window)
+{
+    size_t i;
+
+    for (i = 0; i < demo->window_count; ++i)
+    {
+        struct demo_window_macos *window_macos = CONTAINING_RECORD(demo->windows[i], struct demo_window_macos, w);
+
+        if (window_macos->window == window)
+            return window_macos;
+    }
+
+    return NULL;
+}
+
+static VkSurfaceKHR demo_window_macos_create_vk_surface(struct demo_window *window, VkInstance vk_instance)
+{
+    struct demo_window_macos *window_macos = CONTAINING_RECORD(window, struct demo_window_macos, w);
+    struct VkMetalSurfaceCreateInfoEXT surface_desc;
+    VkSurfaceKHR vk_surface;
+    id l, v;
+
+    l = window_macos->layer = CAMetalLayer_layer();
+    CAMetalLayer_setContentsScale(l, NSScreen_backingScaleFactor(NSScreen_mainScreen()));
+    v = NSWindow_contentView(window_macos->window);
+    NSView_setLayer(v, l);
+    NSView_setWantsLayer(v, true);
+
+    surface_desc.sType = VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT;
+    surface_desc.pNext = NULL;
+    surface_desc.flags = 0;
+    surface_desc.pLayer = l;
+    if (vkCreateMetalSurfaceEXT(vk_instance, &surface_desc, NULL, &vk_surface) < 0)
+        return VK_NULL_HANDLE;
+
+    return vk_surface;
+}
+
+static void demo_window_macos_destroy(struct demo_window *window)
+{
+    struct demo_window_macos *window_macos = CONTAINING_RECORD(window, struct demo_window_macos, w);
+
+    NSWindow_close(window_macos->window);
+}
+
+static void demo_window_macos_destroyed(struct demo_window_macos *window_macos)
+{
+    CAMetalLayer_release(window_macos->layer);
+    NSWindow_release(window_macos->window);
+    demo_window_cleanup(&window_macos->w);
+    free(window_macos);
+}
+
+static struct demo_window *demo_window_macos_create(struct demo *demo,
+        const char *title, unsigned int width, unsigned int height, void *user_data)
+{
+    unsigned long style = NSWindowStyleMaskTitled | NSWindowStyleMaskClosable;
+    struct demo_window_macos *window_macos;
+    NSRect r = {0, 0, width, height};
+    double scale;
+    id w, s;
+
+    if (!(window_macos = malloc(sizeof(*window_macos))))
+        return NULL;
+
+    if (!demo_window_init(&window_macos->w, demo, user_data,
+            demo_window_macos_create_vk_surface, demo_window_macos_destroy))
+    {
+        free(window_macos);
+        return NULL;
+    }
+
+    s = NSScreen_mainScreen();
+    scale = NSScreen_backingScaleFactor(s);
+    r.w /= scale;
+    r.h /= scale;
+
+    w = window_macos->window = class_createInstance(objc_getClass("DemoWindow"), 0);
+    NSWindow_initWithContentRect(w, r, style, NSBackingStoreBuffered, true, s);
+    NSWindow_setReleasedWhenClosed(w, false);
+    NSWindow_setDelegate(w, w);
+    NSWindow_center(w);
+    NSWindow_setTitle(w, NSString_stringWithUTF8String(title));
+
+    NSWindow_makeKeyAndOrderFront(w, nil);
+    window_macos->layer = nil;
+
+    return &window_macos->w;
+}
+
+static void demo_macos_get_dpi(struct demo *demo, double *dpi_x, double *dpi_y)
+{
+    *dpi_x = *dpi_y = 96.0 * NSScreen_backingScaleFactor(NSScreen_mainScreen());
+}
+
+static demo_key demo_key_from_nsevent(id event)
+{
+    enum vkey
+    {
+        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;
+
+    static const struct
+    {
+        enum vkey vkey;
+        demo_key demo_key;
+    }
+    lookup[] =
+    {
+        {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);
+    for (i = 0; i < ARRAY_SIZE(lookup); ++i)
+    {
+        if (lookup[i].vkey == vkey)
+            return lookup[i].demo_key;
+    }
+
+    return DEMO_KEY_UNKNOWN;
+}
+
+static void demo_macos_process_events(struct demo *demo)
+{
+    struct demo_window_macos *window_macos;
+    struct demo_window *window;
+    id a, event;
+    size_t i;
+
+    for (i = 0; i < demo->window_count; ++i)
+    {
+        if ((window = demo->windows[i])->expose_func)
+            window->expose_func(window, window->user_data);
+    }
+
+    a = NSApplication_sharedApplication();
+    while (demo->window_count)
+    {
+        if (!demo->idle_func)
+        {
+            if (!(event = NSApplication_nextEventMatchingMask(a, ~(uint64_t)0,
+                    NSDate_distantFuture(), NSDefaultRunLoopMode, true)))
+                break;
+        }
+        else if (!(event = NSApplication_nextEventMatchingMask(a, ~(uint64_t)0, nil, NSDefaultRunLoopMode, true)))
+        {
+            demo->idle_func(demo, demo->user_data);
+            continue;
+        }
+
+        switch (NSEvent_type(event))
+        {
+            case NSEventTypeKeyDown:
+                if (NSMenu_performKeyEquivalent(NSApplication_mainMenu(a), event))
+                    continue;
+                if (!(window_macos = demo_macos_find_macos_window(demo, NSEvent_window(event)))
+                        || !window_macos->w.key_press_func)
+                    break;
+                window_macos->w.key_press_func(&window_macos->w,
+                        demo_key_from_nsevent(event), window_macos->w.user_data);
+                continue;
+
+            case NSEventTypeApplicationDefined:
+                if (NSEvent_subtype(event) != DemoWindowDestroyed
+                        || !(window_macos = demo_macos_find_macos_window(demo, NSEvent_window(event))))
+                    break;
+                demo_window_macos_destroyed(window_macos);
+                continue;
+        }
+
+        NSApplication_sendEvent(a, event);
+    }
+}
+
+static void DemoWindow_windowWillClose(id window, SEL sel, id notification)
+{
+    id event;
+
+    event = NSEvent_otherEventWithType(NSEventTypeApplicationDefined, (NSPoint){0.0, 0.0},
+            0, 0.0, NSWindow_windowNumber(window), nil, DemoWindowDestroyed, 0, 0);
+    NSApplication_postEvent(NSApplication_sharedApplication(), event, true);
+}
+
+static void demo_macos_cleanup(struct demo *demo)
+{
+}
+
+static bool demo_macos_init(struct demo_macos *macos)
+{
+    id application, item, menu, submenu;
+    Class c;
+
+    if ((c = objc_allocateClassPair(objc_getClass("NSWindow"), "DemoWindow", 0)))
+    {
+        class_addMethod(c, sel_registerName("windowWillClose:"), (IMP)DemoWindow_windowWillClose, "v@:@");
+        objc_registerClassPair(c);
+    }
+
+    application = NSApplication_sharedApplication();
+    NSApplication_setActivationPolicy(application, 0);
+
+    menu = NSMenu_new();
+
+    submenu = NSMenu_new();
+    NSMenu_addItemWithTitle(submenu, NSString_stringWithUTF8String("Quit"),
+            sel_registerName("terminate:"), NSString_stringWithUTF8String("q"));
+
+    item = NSMenuItem_new();
+    NSMenuItem_setSubmenu(item, submenu);
+    NSMenu_release(submenu);
+    NSMenu_addItem(menu, item);
+    NSMenuItem_release(item);
+
+    NSApplication_setMainMenu(application, menu);
+    NSMenu_release(menu);
+
+    NSApplication_finishLaunching(application);
+
+    return true;
+}

demos/demo_win32.h

@@ -17,85 +17,108 @@
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  */
 
-#include <vkd3d_dxgi1_4.h>
-#include <vkd3d_d3dcompiler.h>
-#include <stdbool.h>
-#include <stdio.h>
+#define DEMO_WIN32_WINDOW_CLASS_NAME L"demo_wc"
 
-#define DEMO_WINDOW_CLASS_NAME L"demo_wc"
-
-struct demo
+struct demo_window_win32
 {
-    size_t window_count;
-    bool quit;
+    struct demo_window w;
 
-    void *user_data;
-    void (*idle_func)(struct demo *demo, void *user_data);
-};
-
-struct demo_window
-{
     HINSTANCE instance;
-    HWND hwnd;
-    struct demo *demo;
-    void *user_data;
-    void (*expose_func)(struct demo_window *window, void *user_data);
-    void (*key_press_func)(struct demo_window *window, demo_key key, void *user_data);
+    HWND window;
 };
 
-struct demo_swapchain
+#ifndef VKD3D_CROSSTEST
+static VkSurfaceKHR demo_window_win32_create_vk_surface(struct demo_window *window, VkInstance vk_instance)
 {
-    IDXGISwapChain3 *swapchain;
-};
+    struct demo_window_win32 *window_win32 = CONTAINING_RECORD(window, struct demo_window_win32, w);
+    struct VkWin32SurfaceCreateInfoKHR surface_desc;
+    VkSurfaceKHR vk_surface;
 
-static inline struct demo_window *demo_window_create(struct demo *demo, const char *title,
+    surface_desc.sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
+    surface_desc.pNext = NULL;
+    surface_desc.flags = 0;
+    surface_desc.hinstance = window_win32->instance;
+    surface_desc.hwnd = window_win32->window;
+    if (vkCreateWin32SurfaceKHR(vk_instance, &surface_desc, NULL, &vk_surface) < 0)
+        return VK_NULL_HANDLE;
+
+    return vk_surface;
+}
+#endif
+
+static void demo_window_win32_destroy(struct demo_window *window)
+{
+    struct demo_window_win32 *window_win32 = CONTAINING_RECORD(window, struct demo_window_win32, w);
+
+    DestroyWindow(window_win32->window);
+}
+
+static void demo_window_win32_destroyed(struct demo_window *window)
+{
+    struct demo_window_win32 *window_win32 = CONTAINING_RECORD(window, struct demo_window_win32, w);
+
+    demo_window_cleanup(&window_win32->w);
+    free(window_win32);
+}
+
+static struct demo_window *demo_window_win32_create(struct demo *demo, const char *title,
         unsigned int width, unsigned int height, void *user_data)
 {
+    struct demo_window_win32 *window_win32;
     RECT rect = {0, 0, width, height};
-    struct demo_window *window;
     int title_size;
     WCHAR *title_w;
     DWORD style;
 
-    if (!(window = malloc(sizeof(*window))))
+    if (!(window_win32 = malloc(sizeof(*window_win32))))
         return NULL;
 
+#ifdef VKD3D_CROSSTEST
+    if (!demo_window_init(&window_win32->w, demo, user_data))
+#else
+    if (!demo_window_init(&window_win32->w, demo, user_data,
+            demo_window_win32_create_vk_surface, demo_window_win32_destroy))
+#endif
+    {
+        free(window_win32);
+        return NULL;
+    }
+
     title_size = MultiByteToWideChar(CP_UTF8, 0, title, -1, NULL, 0);
     if (!(title_w = calloc(title_size, sizeof(*title_w))))
     {
-        free(window);
+        demo_window_cleanup(&window_win32->w);
+        free(window_win32);
         return NULL;
     }
     MultiByteToWideChar(CP_UTF8, 0, title, -1, title_w, title_size);
 
-    window->instance = GetModuleHandle(NULL);
-    window->user_data = user_data;
-    window->expose_func = NULL;
-    window->key_press_func = NULL;
+    window_win32->instance = GetModuleHandle(NULL);
 
     style = WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX | WS_VISIBLE;
     AdjustWindowRect(&rect, style, FALSE);
-    window->hwnd = CreateWindowExW(0, DEMO_WINDOW_CLASS_NAME, title_w, style, CW_USEDEFAULT, CW_USEDEFAULT,
-            rect.right - rect.left, rect.bottom - rect.top, NULL, NULL, window->instance, NULL);
+    window_win32->window = CreateWindowExW(0, DEMO_WIN32_WINDOW_CLASS_NAME, title_w, style, CW_USEDEFAULT,
+            CW_USEDEFAULT, rect.right - rect.left, rect.bottom - rect.top, NULL, NULL, window_win32->instance, NULL);
     free(title_w);
-    if (!window->hwnd)
+    if (!window_win32->window)
     {
-        free(window);
+        demo_window_cleanup(&window_win32->w);
+        free(window_win32);
         return NULL;
     }
-    SetWindowLongPtrW(window->hwnd, GWLP_USERDATA, (LONG_PTR)window);
-    window->demo = demo;
-    ++demo->window_count;
+    SetWindowLongPtrW(window_win32->window, GWLP_USERDATA, (LONG_PTR)window_win32);
 
-    return window;
+    return &window_win32->w;
 }
 
-static inline void demo_window_destroy(struct demo_window *window)
+static void demo_win32_get_dpi(struct demo *demo, double *dpi_x, double *dpi_y)
 {
-    DestroyWindow(window->hwnd);
+    struct demo_win32 *win32 = &demo->u.win32;
+
+    *dpi_x = *dpi_y = win32->GetDpiForSystem();
 }
 
-static inline demo_key demo_key_from_vkey(DWORD vkey)
+static demo_key demo_key_from_win32_vkey(DWORD vkey)
 {
     static const struct
     {
@@ -104,18 +127,23 @@ static inline demo_key demo_key_from_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)
     {
@@ -126,46 +154,33 @@ static inline demo_key demo_key_from_vkey(DWORD vkey)
     return DEMO_KEY_UNKNOWN;
 }
 
-static inline LRESULT CALLBACK demo_window_proc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)
+static LRESULT CALLBACK demo_win32_window_proc(HWND window, UINT message, WPARAM wparam, LPARAM lparam)
 {
-    struct demo_window *window = (void *)GetWindowLongPtrW(hwnd, GWLP_USERDATA);
+    struct demo_window_win32 *window_win32 = (void *)GetWindowLongPtrW(window, GWLP_USERDATA);
 
     switch (message)
     {
         case WM_PAINT:
-            if (window && window->expose_func)
-                window->expose_func(window, window->user_data);
+            if (window_win32 && window_win32->w.expose_func)
+                window_win32->w.expose_func(&window_win32->w, window_win32->w.user_data);
             return 0;
 
         case WM_KEYDOWN:
-            if (!window->key_press_func)
+            if (!window_win32->w.key_press_func)
                 break;
-            window->key_press_func(window, demo_key_from_vkey(wparam), window->user_data);
+            window_win32->w.key_press_func(&window_win32->w,
+                    demo_key_from_win32_vkey(wparam), window_win32->w.user_data);
             return 0;
 
         case WM_DESTROY:
-            if (!--window->demo->window_count)
-                window->demo->quit = true;
-            free(window);
+            demo_window_win32_destroyed(&window_win32->w);
             return 0;
     }
 
-    return DefWindowProcW(hwnd, message, wparam, lparam);
+    return DefWindowProcW(window, message, wparam, lparam);
 }
 
-static inline void demo_window_set_key_press_func(struct demo_window *window,
-        void (*key_press_func)(struct demo_window *window, demo_key key, void *user_data))
-{
-    window->key_press_func = key_press_func;
-}
-
-static inline void demo_window_set_expose_func(struct demo_window *window,
-        void (*expose_func)(struct demo_window *window, void *user_data))
-{
-    window->expose_func = expose_func;
-}
-
-static inline void demo_process_events(struct demo *demo)
+static void demo_win32_process_events(struct demo *demo)
 {
     MSG msg = {0};
 
@@ -186,18 +201,28 @@ static inline void demo_process_events(struct demo *demo)
             break;
         TranslateMessage(&msg);
         DispatchMessageW(&msg);
-        if (demo->quit)
+        if (!demo->window_count)
             PostQuitMessage(0);
     }
 }
 
-static inline bool demo_init(struct demo *demo, void *user_data)
+static void demo_win32_cleanup(struct demo *demo)
+{
+    UnregisterClassW(DEMO_WIN32_WINDOW_CLASS_NAME, GetModuleHandle(NULL));
+}
+
+static inline UINT demo_win32_GetDpiForSystem(void)
+{
+    return 96;
+}
+
+static bool demo_win32_init(struct demo_win32 *win32)
 {
     WNDCLASSEXW wc;
 
     wc.cbSize = sizeof(wc);
     wc.style = CS_HREDRAW | CS_VREDRAW;
-    wc.lpfnWndProc = demo_window_proc;
+    wc.lpfnWndProc = demo_win32_window_proc;
     wc.cbClsExtra = 0;
     wc.cbWndExtra = 0;
     wc.hInstance = GetModuleHandle(NULL);
@@ -205,110 +230,15 @@ static inline bool demo_init(struct demo *demo, void *user_data)
     wc.hCursor = LoadCursorW(NULL, IDC_ARROW);
     wc.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
     wc.lpszMenuName = NULL;
-    wc.lpszClassName = DEMO_WINDOW_CLASS_NAME;
+    wc.lpszClassName = DEMO_WIN32_WINDOW_CLASS_NAME;
     wc.hIconSm = LoadIconW(NULL, IDI_WINLOGO);
     if (!RegisterClassExW(&wc))
         return false;
 
-    demo->window_count = 0;
-    demo->quit = false;
-    demo->user_data = user_data;
-    demo->idle_func = NULL;
+    if ((win32->GetDpiForSystem = (void *)GetProcAddress(GetModuleHandleA("user32"), "GetDpiForSystem")))
+        SetProcessDPIAware();
+    else
+        win32->GetDpiForSystem = demo_win32_GetDpiForSystem;
 
     return true;
 }
-
-static inline void demo_cleanup(struct demo *demo)
-{
-    UnregisterClassW(DEMO_WINDOW_CLASS_NAME, GetModuleHandle(NULL));
-}
-
-static inline void demo_set_idle_func(struct demo *demo,
-        void (*idle_func)(struct demo *demo, void *user_data))
-{
-    demo->idle_func = idle_func;
-}
-
-static inline struct demo_swapchain *demo_swapchain_create(ID3D12CommandQueue *command_queue,
-        struct demo_window *window, const struct demo_swapchain_desc *desc)
-{
-    DXGI_SWAP_CHAIN_DESC1 swapchain_desc;
-    struct demo_swapchain *swapchain;
-    IDXGISwapChain1 *swapchain1;
-    IDXGIFactory2 *factory;
-    HRESULT hr;
-
-    if (!(swapchain = malloc(sizeof(*swapchain))))
-        return NULL;
-
-    if (FAILED(CreateDXGIFactory1(&IID_IDXGIFactory2, (void **)&factory)))
-        goto fail;
-
-    memset(&swapchain_desc, 0, sizeof(swapchain_desc));
-    swapchain_desc.BufferCount = desc->buffer_count;
-    swapchain_desc.Width = desc->width;
-    swapchain_desc.Height = desc->height;
-    swapchain_desc.Format = desc->format;
-    swapchain_desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
-    swapchain_desc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD;
-    swapchain_desc.SampleDesc.Count = 1;
-
-    hr = IDXGIFactory2_CreateSwapChainForHwnd(factory, (IUnknown *)command_queue,
-            window->hwnd, &swapchain_desc, NULL, NULL, &swapchain1);
-    IDXGIFactory2_Release(factory);
-    if (FAILED(hr))
-        goto fail;
-
-    hr = IDXGISwapChain1_QueryInterface(swapchain1, &IID_IDXGISwapChain3, (void **)&swapchain->swapchain);
-    IDXGISwapChain1_Release(swapchain1);
-    if (FAILED(hr))
-        goto fail;
-
-    return swapchain;
-
-fail:
-    free(swapchain);
-    return NULL;
-}
-
-static inline unsigned int demo_swapchain_get_current_back_buffer_index(struct demo_swapchain *swapchain)
-{
-    return IDXGISwapChain3_GetCurrentBackBufferIndex(swapchain->swapchain);
-}
-
-static inline ID3D12Resource *demo_swapchain_get_back_buffer(struct demo_swapchain *swapchain, unsigned int index)
-{
-    ID3D12Resource *buffer;
-
-    if (FAILED(IDXGISwapChain3_GetBuffer(swapchain->swapchain, index,
-            &IID_ID3D12Resource, (void **)&buffer)))
-        return NULL;
-
-    return buffer;
-}
-
-static inline void demo_swapchain_present(struct demo_swapchain *swapchain)
-{
-    IDXGISwapChain3_Present(swapchain->swapchain, 1, 0);
-}
-
-static inline void demo_swapchain_destroy(struct demo_swapchain *swapchain)
-{
-    IDXGISwapChain3_Release(swapchain->swapchain);
-    free(swapchain);
-}
-
-static inline HANDLE demo_create_event(void)
-{
-    return CreateEventA(NULL, FALSE, FALSE, NULL);
-}
-
-static inline unsigned int demo_wait_event(HANDLE event, unsigned int ms)
-{
-    return WaitForSingleObject(event, ms);
-}
-
-static inline void demo_destroy_event(HANDLE event)
-{
-    CloseHandle(event);
-}

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,10 +45,9 @@
 #include <sys/time.h>
 #include <assert.h>
 #include <stdio.h>
-#include <math.h>
 #include "demo.h"
 
-#include "gears_hlsl.h"
+DEMO_EMBED(gears_hlsl, "gears.hlsl");
 
 struct cxg_fence
 {
@@ -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);
@@ -681,11 +665,14 @@ static void cxg_load_assets(struct cx_gears *cxg)
     hr = demo_create_root_signature(cxg->device, &root_signature_desc, &cxg->root_signature);
     assert(SUCCEEDED(hr));
 
-    hr = D3DCompile(gears_hlsl, strlen(gears_hlsl), NULL, NULL, NULL, "vs_main", "vs_5_0", 0, 0, &vs, NULL);
+    hr = D3DCompile(gears_hlsl, gears_hlsl_size, "gears.hlsl",
+            NULL, NULL, "vs_main", "vs_5_0", 0, 0, &vs, NULL);
     assert(SUCCEEDED(hr));
-    hr = D3DCompile(gears_hlsl, strlen(gears_hlsl), NULL, NULL, NULL, "ps_main_flat", "ps_5_0", 0, 0, &ps_flat, NULL);
+    hr = D3DCompile(gears_hlsl, gears_hlsl_size, "gears.hlsl",
+            NULL, NULL, "ps_main_flat", "ps_5_0", 0, 0, &ps_flat, NULL);
     assert(SUCCEEDED(hr));
-    hr = D3DCompile(gears_hlsl, strlen(gears_hlsl), NULL, NULL, NULL, "ps_main_smooth", "ps_5_0", 0, 0, &ps_smooth, NULL);
+    hr = D3DCompile(gears_hlsl, gears_hlsl_size, "gears.hlsl",
+            NULL, NULL, "ps_main_smooth", "ps_5_0", 0, 0, &ps_smooth, NULL);
     assert(SUCCEEDED(hr));
 
     memset(&pso_desc, 0, sizeof(pso_desc));
@@ -724,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));
     }
 
@@ -805,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:
@@ -846,12 +832,17 @@ 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))
         return EXIT_FAILURE;
     demo_set_idle_func(&cxg.demo, cxg_idle);
 
+    demo_get_dpi(&cxg.demo, &dpi_x, &dpi_y);
+    width *= dpi_x / 96.0;
+    height *= dpi_y / 96.0;
     cxg.window = demo_window_create(&cxg.demo, "Vkd3d Gears", width, height, &cxg);
     demo_window_set_key_press_func(cxg.window, cxg_key_press);
     demo_window_set_expose_func(cxg.window, cxg_expose);
@@ -873,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/gears.hlsl

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2016 Henri Verbeet for CodeWeavers
+ *
+ * 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 gear_block : register(b0)
+{
+    float4x4 mvp_matrix;
+    float3x3 normal_matrix;
+};
+
+struct vs_in
+{
+    float4 position : POSITION;
+    float3 normal : NORMAL;
+    float3 diffuse : DIFFUSE;
+    float4 transform : TRANSFORM;
+};
+
+struct vs_out
+{
+    float4 position : SV_POSITION;
+    float4 colour : COLOR;
+};
+
+struct vs_out vs_main(struct vs_in i)
+{
+    const float3 l_pos = float3(5.0, 5.0, 10.0);
+    float3 dir, normal;
+    float4 position;
+    struct vs_out o;
+    float att;
+
+    position.x = i.transform.x * i.position.x - i.transform.y * i.position.y + i.transform.z;
+    position.y = i.transform.x * i.position.y + i.transform.y * i.position.x + i.transform.w;
+    position.zw = i.position.zw;
+
+    o.position = mul(mvp_matrix, position);
+    dir = normalize(l_pos - o.position.xyz / o.position.w);
+
+    normal.x = i.transform.x * i.normal.x - i.transform.y * i.normal.y;
+    normal.y = i.transform.x * i.normal.y + i.transform.y * i.normal.x;
+    normal.z = i.normal.z;
+    att = 0.2 + dot(dir, normalize(mul(normal_matrix, normal)));
+
+    o.colour.xyz = i.diffuse.xyz * att;
+    o.colour.w = 1.0;
+
+    return o;
+}
+
+float4 ps_main_smooth(float4 position : SV_POSITION, float4 colour : COLOR) : SV_TARGET
+{
+    return colour;
+}
+
+float4 ps_main_flat(float4 position : SV_POSITION, nointerpolation float4 colour : COLOR) : SV_TARGET
+{
+    return colour;
+}

demos/gears_hlsl.h

@@ -1,56 +0,0 @@
-static const char gears_hlsl[] =
-"cbuffer gear_block : register(b0)\n"
-"{\n"
-"    float4x4 mvp_matrix;\n"
-"    float3x3 normal_matrix;\n"
-"};\n"
-"\n"
-"struct vs_in\n"
-"{\n"
-"    float4 position : POSITION;\n"
-"    float3 normal : NORMAL;\n"
-"    float3 diffuse : DIFFUSE;\n"
-"    float4 transform : TRANSFORM;\n"
-"};\n"
-"\n"
-"struct vs_out\n"
-"{\n"
-"    float4 position : SV_POSITION;\n"
-"    float4 colour : COLOR;\n"
-"};\n"
-"\n"
-"struct vs_out vs_main(struct vs_in i)\n"
-"{\n"
-"    const float3 l_pos = float3(5.0, 5.0, 10.0);\n"
-"    float3 dir, normal;\n"
-"    float4 position;\n"
-"    struct vs_out o;\n"
-"    float att;\n"
-"\n"
-"    position.x = i.transform.x * i.position.x - i.transform.y * i.position.y + i.transform.z;\n"
-"    position.y = i.transform.x * i.position.y + i.transform.y * i.position.x + i.transform.w;\n"
-"    position.zw = i.position.zw;\n"
-"\n"
-"    o.position = mul(mvp_matrix, position);\n"
-"    dir = normalize(l_pos - o.position.xyz / o.position.w);\n"
-"\n"
-"    normal.x = i.transform.x * i.normal.x - i.transform.y * i.normal.y;\n"
-"    normal.y = i.transform.x * i.normal.y + i.transform.y * i.normal.x;\n"
-"    normal.z = i.normal.z;\n"
-"    att = 0.2 + dot(dir, normalize(mul(normal_matrix, normal)));\n"
-"\n"
-"    o.colour.xyz = i.diffuse.xyz * att;\n"
-"    o.colour.w = 1.0;\n"
-"\n"
-"    return o;\n"
-"}\n"
-"\n"
-"float4 ps_main_smooth(float4 position : SV_POSITION, float4 colour : COLOR) : SV_TARGET\n"
-"{\n"
-"    return colour;\n"
-"}\n"
-"\n"
-"float4 ps_main_flat(float4 position : SV_POSITION, nointerpolation float4 colour : COLOR) : SV_TARGET\n"
-"{\n"
-"    return colour;\n"
-"}\n";

demos/make_objc

@@ -0,0 +1,151 @@
+#!/usr/bin/perl -w
+#
+# 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 Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+use strict;
+use warnings;
+use JSON;
+use open ':utf8';
+binmode STDOUT, ':utf8';
+
+sub method_name($)
+{
+    shift->{selector} =~ s/(:.*)//r;
+}
+
+sub method_parameters($$)
+{
+    my ($method, $method_type) = @_;
+
+    my $parameters = join ", ", $method_type eq "class" ? () : "id self",
+            map {"$_->{type} $_->{name}"} @{$method->{parameters}};
+
+    length $parameters ? $parameters : "void";
+}
+
+sub send_function($)
+{
+    shift->{'return-float'} ? "vkd3d_objc_msgSend_fpret" : "objc_msgSend";
+}
+
+sub invocation_type($$)
+{
+    my ($method, $method_type) = @_;
+
+    "$method->{'return-type'} (*)(" . join(", ", $method_type eq "class" ? "Class" : "id", "SEL",
+            map {$_->{type}} @{$method->{parameters}}) . ")";
+}
+
+sub invocation_parameters($$$)
+{
+    my ($method, $interface_name, $method_type) = @_;
+
+    join ", ", $method_type eq "class" ? "objc_getClass(\"$interface_name\")" : "self",
+            "sel_registerName(\"$method->{selector}\")", map {$_->{name}} @{$method->{parameters}};
+}
+
+sub invocation($$$)
+{
+    my ($method, $interface_name, $method_type) = @_;
+
+    ($method->{'return-type'} eq "void" ? "" : "return ")
+            . "((${\invocation_type $method, $method_type})f)"
+            . "(${\invocation_parameters $method, $interface_name, $method_type});";
+}
+
+sub print_method($$$)
+{
+    my ($method, $interface_name, $method_type) = @_;
+
+    print "static inline $method->{'return-type'} "
+            . "${interface_name}_${\method_name $method}(${\method_parameters $method, $method_type})\n";
+    print "{\n";
+    print "    void *f = ${\send_function $method};\n";
+    print "    ${\invocation $method, $interface_name, $method_type}\n";
+    print "}\n\n";
+}
+
+sub print_property($$)
+{
+    my ($property, $interface_name) = @_;
+
+    my $method =
+    {
+        'return-type' => $property->{type},
+        'return-float' => $property->{float},
+        selector => $property->{getter} // $property->{name},
+    };
+    my $method_type = $property->{class} ? "class" : "instance";
+
+    print_method $method, $interface_name, $method_type;
+    if (!$property->{readonly})
+    {
+        $method->{'return-type'} = "void";
+        $method->{'return-float'} = 0;
+        $method->{selector} = "set${\ucfirst $property->{name}}:";
+        $method->{parameters} = [$property];
+        print_method $method, $interface_name, $method_type;
+    }
+}
+
+sub print_interface(_)
+{
+    my ($interface) = @_;
+
+    print_method $_, $interface->{name}, "class" foreach (@{$interface->{'class-methods'}});
+    print_method $_, $interface->{name}, "instance" foreach (@{$interface->{'instance-methods'}});
+    print_property $_, $interface->{name} foreach (@{$interface->{properties}});
+}
+
+sub print_header($)
+{
+    my ($grammar) = @_;
+
+    my $guard = "__VKD3D_${\uc $grammar->{name}}_H__";
+
+    print "/*\n";
+    print " * This file is automatically generated.\n";
+    print " * The original source is covered by the following license:\n";
+    print " *\n";
+    print map {" * $_" =~ s/ +$//r . "\n"} @{$grammar->{copyright}};
+    print " */\n\n";
+
+    print "#ifndef $guard\n";
+    print "#define $guard\n\n";
+
+    print "#include <objc/objc-runtime.h>\n\n";
+
+    print "#ifdef __arm64__\n";
+    print "# define vkd3d_objc_msgSend_fpret objc_msgSend\n";
+    print "#else\n";
+    print "# define vkd3d_objc_msgSend_fpret objc_msgSend_fpret\n";
+    print "#endif /* __arm64__ */\n\n";
+
+    print_interface foreach (@{$grammar->{interfaces}});
+
+    print "#undef vkd3d_objc_msgSend_fpret\n\n";
+
+    print "#endif /* $guard */\n";
+}
+
+die "No input file specified.\n" unless @ARGV;
+print_header do
+{
+    local $/;
+    open my $fh, '<', $ARGV[0] or die $!;
+    decode_json <$fh>;
+};