mz_d3d12.h

#ifndef MZ_D3D12_INCLUDED_
#define MZ_D3D12_INCLUDED_

#include "mz_tinywin.h"

typedef struct IUnknown IUnknown;
typedef struct ID3DBlob ID3DBlob;
typedef struct ID3D12Object ID3D12Object;
typedef struct ID3D12DeviceChild ID3D12DeviceChild;
typedef struct ID3D12RootSignature ID3D12RootSignature;
typedef struct ID3D12Pageable ID3D12Pageable;
typedef struct ID3D12Heap ID3D12Heap;
typedef struct ID3D12Resource ID3D12Resource;
typedef struct ID3D12CommandAllocator ID3D12CommandAllocator;
typedef struct ID3D12Fence ID3D12Fence;
typedef struct ID3D12PipelineState ID3D12PipelineState;
typedef struct ID3D12DescriptorHeap ID3D12DescriptorHeap;
typedef struct ID3D12QueryHeap ID3D12QueryHeap;
typedef struct ID3D12CommandSignature ID3D12CommandSignature;
typedef struct ID3D12CommandList ID3D12CommandList;
typedef struct ID3D12GraphicsCommandList ID3D12GraphicsCommandList;
typedef struct ID3D12CommandQueue ID3D12CommandQueue;
typedef struct ID3D12Device ID3D12Device;
typedef struct ID3D12Debug ID3D12Debug;
typedef struct ID3D12Debug1 ID3D12Debug1;

typedef struct IDXGIOutput IDXGIOutput;
typedef struct IDXGIAdapter IDXGIAdapter;
typedef struct IDXGIAdapter1 IDXGIAdapter1;
typedef struct IDXGISwapChain IDXGISwapChain;
typedef struct IDXGISwapChain1 IDXGISwapChain1;
typedef struct IDXGISwapChain3 IDXGISwapChain3;
typedef struct IDXGIFactory4 IDXGIFactory4;

#define DXGI_CREATE_FACTORY_DEBUG 0x01
#define D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES 0xffffffff
#define D3D12_DEFAULT_DEPTH_BIAS 0
#define D3D12_DEFAULT_DEPTH_BIAS_CLAMP 0.0f
#define D3D12_DEFAULT_SLOPE_SCALED_DEPTH_BIAS 0.0f
#define D3D12_DEFAULT_STENCIL_READ_MASK 0xff
#define D3D12_DEFAULT_STENCIL_WRITE_MASK 0xff

typedef enum DXGI_FORMAT {
  DXGI_FORMAT_UNKNOWN = 0,
  DXGI_FORMAT_R32G32B32A32_TYPELESS = 1,
  DXGI_FORMAT_R32G32B32A32_FLOAT = 2,
  DXGI_FORMAT_R32G32B32A32_UINT = 3,
  DXGI_FORMAT_R32G32B32A32_SINT = 4,
  DXGI_FORMAT_R32G32B32_TYPELESS = 5,
  DXGI_FORMAT_R32G32B32_FLOAT = 6,
  DXGI_FORMAT_R32G32B32_UINT = 7,
  DXGI_FORMAT_R32G32B32_SINT = 8,
  DXGI_FORMAT_R16G16B16A16_TYPELESS = 9,
  DXGI_FORMAT_R16G16B16A16_FLOAT = 10,
  DXGI_FORMAT_R16G16B16A16_UNORM = 11,
  DXGI_FORMAT_R16G16B16A16_UINT = 12,
  DXGI_FORMAT_R16G16B16A16_SNORM = 13,
  DXGI_FORMAT_R16G16B16A16_SINT = 14,
  DXGI_FORMAT_R32G32_TYPELESS = 15,
  DXGI_FORMAT_R32G32_FLOAT = 16,
  DXGI_FORMAT_R32G32_UINT = 17,
  DXGI_FORMAT_R32G32_SINT = 18,
  DXGI_FORMAT_R32G8X24_TYPELESS = 19,
  DXGI_FORMAT_D32_FLOAT_S8X24_UINT = 20,
  DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS = 21,
  DXGI_FORMAT_X32_TYPELESS_G8X24_UINT = 22,
  DXGI_FORMAT_R10G10B10A2_TYPELESS = 23,
  DXGI_FORMAT_R10G10B10A2_UNORM = 24,
  DXGI_FORMAT_R10G10B10A2_UINT = 25,
  DXGI_FORMAT_R11G11B10_FLOAT = 26,
  DXGI_FORMAT_R8G8B8A8_TYPELESS = 27,
  DXGI_FORMAT_R8G8B8A8_UNORM = 28,
  DXGI_FORMAT_R8G8B8A8_UNORM_SRGB = 29,
  DXGI_FORMAT_R8G8B8A8_UINT = 30,
  DXGI_FORMAT_R8G8B8A8_SNORM = 31,
  DXGI_FORMAT_R8G8B8A8_SINT = 32,
  DXGI_FORMAT_R16G16_TYPELESS = 33,
  DXGI_FORMAT_R16G16_FLOAT = 34,
  DXGI_FORMAT_R16G16_UNORM = 35,
  DXGI_FORMAT_R16G16_UINT = 36,
  DXGI_FORMAT_R16G16_SNORM = 37,
  DXGI_FORMAT_R16G16_SINT = 38,
  DXGI_FORMAT_R32_TYPELESS = 39,
  DXGI_FORMAT_D32_FLOAT = 40,
  DXGI_FORMAT_R32_FLOAT = 41,
  DXGI_FORMAT_R32_UINT = 42,
  DXGI_FORMAT_R32_SINT = 43,
  DXGI_FORMAT_R24G8_TYPELESS = 44,
  DXGI_FORMAT_D24_UNORM_S8_UINT = 45,
  DXGI_FORMAT_R24_UNORM_X8_TYPELESS = 46,
  DXGI_FORMAT_X24_TYPELESS_G8_UINT = 47,
  DXGI_FORMAT_R8G8_TYPELESS = 48,
  DXGI_FORMAT_R8G8_UNORM = 49,
  DXGI_FORMAT_R8G8_UINT = 50,
  DXGI_FORMAT_R8G8_SNORM = 51,
  DXGI_FORMAT_R8G8_SINT = 52,
  DXGI_FORMAT_R16_TYPELESS = 53,
  DXGI_FORMAT_R16_FLOAT = 54,
  DXGI_FORMAT_D16_UNORM = 55,
  DXGI_FORMAT_R16_UNORM = 56,
  DXGI_FORMAT_R16_UINT = 57,
  DXGI_FORMAT_R16_SNORM = 58,
  DXGI_FORMAT_R16_SINT = 59,
  DXGI_FORMAT_R8_TYPELESS = 60,
  DXGI_FORMAT_R8_UNORM = 61,
  DXGI_FORMAT_R8_UINT = 62,
  DXGI_FORMAT_R8_SNORM = 63,
  DXGI_FORMAT_R8_SINT = 64,
  DXGI_FORMAT_A8_UNORM = 65,
  DXGI_FORMAT_R1_UNORM = 66,
  DXGI_FORMAT_R9G9B9E5_SHAREDEXP = 67,
  DXGI_FORMAT_R8G8_B8G8_UNORM = 68,
  DXGI_FORMAT_G8R8_G8B8_UNORM = 69,
  DXGI_FORMAT_BC1_TYPELESS = 70,
  DXGI_FORMAT_BC1_UNORM = 71,
  DXGI_FORMAT_BC1_UNORM_SRGB = 72,
  DXGI_FORMAT_BC2_TYPELESS = 73,
  DXGI_FORMAT_BC2_UNORM = 74,
  DXGI_FORMAT_BC2_UNORM_SRGB = 75,
  DXGI_FORMAT_BC3_TYPELESS = 76,
  DXGI_FORMAT_BC3_UNORM = 77,
  DXGI_FORMAT_BC3_UNORM_SRGB = 78,
  DXGI_FORMAT_BC4_TYPELESS = 79,
  DXGI_FORMAT_BC4_UNORM = 80,
  DXGI_FORMAT_BC4_SNORM = 81,
  DXGI_FORMAT_BC5_TYPELESS = 82,
  DXGI_FORMAT_BC5_UNORM = 83,
  DXGI_FORMAT_BC5_SNORM = 84,
  DXGI_FORMAT_B5G6R5_UNORM = 85,
  DXGI_FORMAT_B5G5R5A1_UNORM = 86,
  DXGI_FORMAT_B8G8R8A8_UNORM = 87,
  DXGI_FORMAT_B8G8R8X8_UNORM = 88,
  DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM = 89,
  DXGI_FORMAT_B8G8R8A8_TYPELESS = 90,
  DXGI_FORMAT_B8G8R8A8_UNORM_SRGB = 91,
  DXGI_FORMAT_B8G8R8X8_TYPELESS = 92,
  DXGI_FORMAT_B8G8R8X8_UNORM_SRGB = 93,
  DXGI_FORMAT_BC6H_TYPELESS = 94,
  DXGI_FORMAT_BC6H_UF16 = 95,
  DXGI_FORMAT_BC6H_SF16 = 96,
  DXGI_FORMAT_BC7_TYPELESS = 97,
  DXGI_FORMAT_BC7_UNORM = 98,
  DXGI_FORMAT_BC7_UNORM_SRGB = 99,
  DXGI_FORMAT_AYUV = 100,
  DXGI_FORMAT_Y410 = 101,
  DXGI_FORMAT_Y416 = 102,
  DXGI_FORMAT_NV12 = 103,
  DXGI_FORMAT_P010 = 104,
  DXGI_FORMAT_P016 = 105,
  DXGI_FORMAT_420_OPAQUE = 106,
  DXGI_FORMAT_YUY2 = 107,
  DXGI_FORMAT_Y210 = 108,
  DXGI_FORMAT_Y216 = 109,
  DXGI_FORMAT_NV11 = 110,
  DXGI_FORMAT_AI44 = 111,
  DXGI_FORMAT_IA44 = 112,
  DXGI_FORMAT_P8 = 113,
  DXGI_FORMAT_A8P8 = 114,
  DXGI_FORMAT_B4G4R4A4_UNORM = 115,
  DXGI_FORMAT_P208 = 130,
  DXGI_FORMAT_V208 = 131,
  DXGI_FORMAT_V408 = 132,
  DXGI_FORMAT_FORCE_UINT = 0xffffffff
} DXGI_FORMAT;

typedef struct DXGI_SAMPLE_DESC {
  u32 Count;
  u32 Quality;
} DXGI_SAMPLE_DESC;

typedef u64 D3D12_GPU_VIRTUAL_ADDRESS;

typedef enum D3D_FEATURE_LEVEL {
  D3D_FEATURE_LEVEL_9_1 = 0x9100,
  D3D_FEATURE_LEVEL_9_2 = 0x9200,
  D3D_FEATURE_LEVEL_9_3 = 0x9300,
  D3D_FEATURE_LEVEL_10_0 = 0xa000,
  D3D_FEATURE_LEVEL_10_1 = 0xa100,
  D3D_FEATURE_LEVEL_11_0 = 0xb000,
  D3D_FEATURE_LEVEL_11_1 = 0xb100,
  D3D_FEATURE_LEVEL_12_0 = 0xc000,
  D3D_FEATURE_LEVEL_12_1 = 0xc100
} D3D_FEATURE_LEVEL;

typedef enum D3D12_HEAP_TYPE {
  D3D12_HEAP_TYPE_DEFAULT = 1,
  D3D12_HEAP_TYPE_UPLOAD = 2,
  D3D12_HEAP_TYPE_READBACK = 3,
  D3D12_HEAP_TYPE_CUSTOM = 4
} D3D12_HEAP_TYPE;

typedef enum D3D12_CPU_PAGE_PROPERTY {
  D3D12_CPU_PAGE_PROPERTY_UNKNOWN = 0,
  D3D12_CPU_PAGE_PROPERTY_NOT_AVAILABLE = 1,
  D3D12_CPU_PAGE_PROPERTY_WRITE_COMBINE = 2,
  D3D12_CPU_PAGE_PROPERTY_WRITE_BACK = 3
} D3D12_CPU_PAGE_PROPERTY;

typedef enum D3D12_MEMORY_POOL {
  D3D12_MEMORY_POOL_UNKNOWN = 0,
  D3D12_MEMORY_POOL_L0 = 1,
  D3D12_MEMORY_POOL_L1 = 2
} D3D12_MEMORY_POOL;

typedef struct D3D12_HEAP_PROPERTIES {
  D3D12_HEAP_TYPE Type;
  D3D12_CPU_PAGE_PROPERTY CPUPageProperty;
  D3D12_MEMORY_POOL MemoryPoolPreference;
  u32 CreationNodeMask;
  u32 VisibleNodeMask;
} D3D12_HEAP_PROPERTIES;

typedef enum D3D12_HEAP_FLAGS {
  D3D12_HEAP_FLAG_NONE = 0,
  D3D12_HEAP_FLAG_SHARED = 0x1,
  D3D12_HEAP_FLAG_DENY_BUFFERS = 0x4,
  D3D12_HEAP_FLAG_ALLOW_DISPLAY = 0x8,
  D3D12_HEAP_FLAG_SHARED_CROSS_ADAPTER = 0x20,
  D3D12_HEAP_FLAG_DENY_RT_DS_TEXTURES = 0x40,
  D3D12_HEAP_FLAG_DENY_NON_RT_DS_TEXTURES = 0x80,
  D3D12_HEAP_FLAG_HARDWARE_PROTECTED = 0x100,
  D3D12_HEAP_FLAG_ALLOW_ALL_BUFFERS_AND_TEXTURES = 0,
  D3D12_HEAP_FLAG_ALLOW_ONLY_BUFFERS = 0xc0,
  D3D12_HEAP_FLAG_ALLOW_ONLY_NON_RT_DS_TEXTURES = 0x44,
  D3D12_HEAP_FLAG_ALLOW_ONLY_RT_DS_TEXTURES = 0x84
} D3D12_HEAP_FLAGS;

typedef struct D3D12_HEAP_DESC {
  u64 SizeInBytes;
  D3D12_HEAP_PROPERTIES Properties;
  u64 Alignment;
  D3D12_HEAP_FLAGS Flags;
} D3D12_HEAP_DESC;

typedef struct D3D12_RANGE {
  u64 Begin;
  u64 End;
} D3D12_RANGE;

typedef enum D3D12_RESOURCE_DIMENSION {
  D3D12_RESOURCE_DIMENSION_UNKNOWN = 0,
  D3D12_RESOURCE_DIMENSION_BUFFER = 1,
  D3D12_RESOURCE_DIMENSION_TEXTURE1D = 2,
  D3D12_RESOURCE_DIMENSION_TEXTURE2D = 3,
  D3D12_RESOURCE_DIMENSION_TEXTURE3D = 4
} D3D12_RESOURCE_DIMENSION;

typedef enum D3D12_TEXTURE_LAYOUT {
  D3D12_TEXTURE_LAYOUT_UNKNOWN = 0,
  D3D12_TEXTURE_LAYOUT_ROW_MAJOR = 1,
  D3D12_TEXTURE_LAYOUT_64KB_UNDEFINED_SWIZZLE = 2,
  D3D12_TEXTURE_LAYOUT_64KB_STANDARD_SWIZZLE = 3
} D3D12_TEXTURE_LAYOUT;

typedef enum D3D12_RESOURCE_FLAGS {
  D3D12_RESOURCE_FLAG_NONE = 0,
  D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET = 0x1,
  D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL = 0x2,
  D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS = 0x4,
  D3D12_RESOURCE_FLAG_DENY_SHADER_RESOURCE = 0x8,
  D3D12_RESOURCE_FLAG_ALLOW_CROSS_ADAPTER = 0x10,
  D3D12_RESOURCE_FLAG_ALLOW_SIMULTANEOUS_ACCESS = 0x20
} D3D12_RESOURCE_FLAGS;

typedef struct D3D12_RESOURCE_DESC {
  D3D12_RESOURCE_DIMENSION Dimension;
  u64 Alignment;
  u64 Width;
  u32 Height;
  u16 DepthOrArraySize;
  u16 MipLevels;
  DXGI_FORMAT Format;
  DXGI_SAMPLE_DESC SampleDesc;
  D3D12_TEXTURE_LAYOUT Layout;
  D3D12_RESOURCE_FLAGS Flags;
} D3D12_RESOURCE_DESC;

typedef struct D3D12_BOX {
  u32 left;
  u32 top;
  u32 front;
  u32 right;
  u32 bottom;
  u32 back;
} D3D12_BOX;

typedef enum D3D12_DESCRIPTOR_HEAP_TYPE {
  D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV = 0,
  D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER = (D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV + 1),
  D3D12_DESCRIPTOR_HEAP_TYPE_RTV = (D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER + 1),
  D3D12_DESCRIPTOR_HEAP_TYPE_DSV = (D3D12_DESCRIPTOR_HEAP_TYPE_RTV + 1),
  D3D12_DESCRIPTOR_HEAP_TYPE_NUM_TYPES = (D3D12_DESCRIPTOR_HEAP_TYPE_DSV + 1)
} D3D12_DESCRIPTOR_HEAP_TYPE;

typedef enum D3D12_DESCRIPTOR_HEAP_FLAGS {
  D3D12_DESCRIPTOR_HEAP_FLAG_NONE = 0,
  D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE = 0x1
} D3D12_DESCRIPTOR_HEAP_FLAGS;

typedef struct D3D12_DESCRIPTOR_HEAP_DESC {
  D3D12_DESCRIPTOR_HEAP_TYPE Type;
  u32 NumDescriptors;
  D3D12_DESCRIPTOR_HEAP_FLAGS Flags;
  u32 NodeMask;
} D3D12_DESCRIPTOR_HEAP_DESC;

typedef struct D3D12_CPU_DESCRIPTOR_HANDLE {
  u64 ptr;
} D3D12_CPU_DESCRIPTOR_HANDLE;

typedef struct D3D12_GPU_DESCRIPTOR_HANDLE {
  u64 ptr;
} D3D12_GPU_DESCRIPTOR_HANDLE;

typedef RECT D3D12_RECT;

typedef struct D3D12_DISCARD_REGION {
  u32 NumRects;
  const D3D12_RECT *pRects;
  u32 FirstSubresource;
  u32 NumSubresources;
} D3D12_DISCARD_REGION;

typedef enum D3D12_COMMAND_LIST_TYPE {
  D3D12_COMMAND_LIST_TYPE_DIRECT = 0,
  D3D12_COMMAND_LIST_TYPE_BUNDLE = 1,
  D3D12_COMMAND_LIST_TYPE_COMPUTE = 2,
  D3D12_COMMAND_LIST_TYPE_COPY = 3
} D3D12_COMMAND_LIST_TYPE;

typedef struct D3D12_SUBRESOURCE_FOOTPRINT {
  DXGI_FORMAT Format;
  u32 Width;
  u32 Height;
  u32 Depth;
  u32 RowPitch;
} D3D12_SUBRESOURCE_FOOTPRINT;

typedef struct D3D12_PLACED_SUBRESOURCE_FOOTPRINT {
  u64 Offset;
  D3D12_SUBRESOURCE_FOOTPRINT Footprint;
} D3D12_PLACED_SUBRESOURCE_FOOTPRINT;

typedef enum D3D12_TEXTURE_COPY_TYPE {
  D3D12_TEXTURE_COPY_TYPE_SUBRESOURCE_INDEX = 0,
  D3D12_TEXTURE_COPY_TYPE_PLACED_FOOTPRINT = 1
} D3D12_TEXTURE_COPY_TYPE;

typedef struct D3D12_TEXTURE_COPY_LOCATION {
  ID3D12Resource *pResource;
  D3D12_TEXTURE_COPY_TYPE Type;
  union {
    D3D12_PLACED_SUBRESOURCE_FOOTPRINT PlacedFootprint;
    u32 SubresourceIndex;
  };
} D3D12_TEXTURE_COPY_LOCATION;

typedef struct D3D12_TILED_RESOURCE_COORDINATE {
  u32 X;
  u32 Y;
  u32 Z;
  u32 Subresource;
} D3D12_TILED_RESOURCE_COORDINATE;

typedef struct D3D12_TILE_REGION_SIZE {
  u32 NumTiles;
  i32 UseBox;
  u32 Width;
  u16 Height;
  u16 Depth;
} D3D12_TILE_REGION_SIZE;

typedef enum D3D12_TILE_RANGE_FLAGS {
  D3D12_TILE_RANGE_FLAG_NONE = 0,
  D3D12_TILE_RANGE_FLAG_NULL = 1,
  D3D12_TILE_RANGE_FLAG_SKIP = 2,
  D3D12_TILE_RANGE_FLAG_REUSE_SINGLE_TILE = 4
} D3D12_TILE_RANGE_FLAGS;

typedef struct D3D12_SUBRESOURCE_TILING {
  u32 WidthInTiles;
  u16 HeightInTiles;
  u16 DepthInTiles;
  u32 StartTileIndexInOverallResource;
} D3D12_SUBRESOURCE_TILING;

typedef struct D3D12_TILE_SHAPE {
  u32 WidthInTexels;
  u32 HeightInTexels;
  u32 DepthInTexels;
} D3D12_TILE_SHAPE;

typedef enum D3D12_TILE_MAPPING_FLAGS {
  D3D12_TILE_MAPPING_FLAG_NONE = 0,
  D3D12_TILE_MAPPING_FLAG_NO_HAZARD = 0x1
} D3D12_TILE_MAPPING_FLAGS;

typedef enum D3D12_TILE_COPY_FLAGS {
  D3D12_TILE_COPY_FLAG_NONE = 0,
  D3D12_TILE_COPY_FLAG_NO_HAZARD = 0x1,
  D3D12_TILE_COPY_FLAG_LINEAR_BUFFER_TO_SWIZZLED_TILED_RESOURCE = 0x2,
  D3D12_TILE_COPY_FLAG_SWIZZLED_TILED_RESOURCE_TO_LINEAR_BUFFER = 0x4
} D3D12_TILE_COPY_FLAGS;

typedef enum D3D12_RESOURCE_STATES {
  D3D12_RESOURCE_STATE_COMMON = 0,
  D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER = 0x1,
  D3D12_RESOURCE_STATE_INDEX_BUFFER = 0x2,
  D3D12_RESOURCE_STATE_RENDER_TARGET = 0x4,
  D3D12_RESOURCE_STATE_UNORDERED_ACCESS = 0x8,
  D3D12_RESOURCE_STATE_DEPTH_WRITE = 0x10,
  D3D12_RESOURCE_STATE_DEPTH_READ = 0x20,
  D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE = 0x40,
  D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE = 0x80,
  D3D12_RESOURCE_STATE_STREAM_OUT = 0x100,
  D3D12_RESOURCE_STATE_INDIRECT_ARGUMENT = 0x200,
  D3D12_RESOURCE_STATE_COPY_DEST = 0x400,
  D3D12_RESOURCE_STATE_COPY_SOURCE = 0x800,
  D3D12_RESOURCE_STATE_RESOLVE_DEST = 0x1000,
  D3D12_RESOURCE_STATE_RESOLVE_SOURCE = 0x2000,
  D3D12_RESOURCE_STATE_GENERIC_READ = (((((0x1 | 0x2) | 0x40) | 0x80) | 0x200) | 0x800),
  D3D12_RESOURCE_STATE_PRESENT = 0,
  D3D12_RESOURCE_STATE_PREDICATION = 0x200
} D3D12_RESOURCE_STATES;

typedef enum D3D12_RESOURCE_BARRIER_TYPE {
  D3D12_RESOURCE_BARRIER_TYPE_TRANSITION = 0,
  D3D12_RESOURCE_BARRIER_TYPE_ALIASING = (D3D12_RESOURCE_BARRIER_TYPE_TRANSITION + 1),
  D3D12_RESOURCE_BARRIER_TYPE_UAV = (D3D12_RESOURCE_BARRIER_TYPE_ALIASING + 1)
} D3D12_RESOURCE_BARRIER_TYPE;

typedef struct D3D12_RESOURCE_TRANSITION_BARRIER {
  ID3D12Resource *pResource;
  u32 Subresource;
  D3D12_RESOURCE_STATES StateBefore;
  D3D12_RESOURCE_STATES StateAfter;
} D3D12_RESOURCE_TRANSITION_BARRIER;

typedef struct D3D12_RESOURCE_ALIASING_BARRIER {
  ID3D12Resource *pResourceBefore;
  ID3D12Resource *pResourceAfter;
} D3D12_RESOURCE_ALIASING_BARRIER;

typedef struct D3D12_RESOURCE_UAV_BARRIER {
  ID3D12Resource *pResource;
} D3D12_RESOURCE_UAV_BARRIER;

typedef enum D3D12_RESOURCE_BARRIER_FLAGS {
  D3D12_RESOURCE_BARRIER_FLAG_NONE = 0,
  D3D12_RESOURCE_BARRIER_FLAG_BEGIN_ONLY = 0x1,
  D3D12_RESOURCE_BARRIER_FLAG_END_ONLY = 0x2
} D3D12_RESOURCE_BARRIER_FLAGS;

typedef struct D3D12_RESOURCE_BARRIER {
  D3D12_RESOURCE_BARRIER_TYPE Type;
  D3D12_RESOURCE_BARRIER_FLAGS Flags;
  union {
    D3D12_RESOURCE_TRANSITION_BARRIER Transition;
    D3D12_RESOURCE_ALIASING_BARRIER Aliasing;
    D3D12_RESOURCE_UAV_BARRIER UAV;
  };
} D3D12_RESOURCE_BARRIER;

typedef enum D3D12_INPUT_CLASSIFICATION {
  D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA = 0,
  D3D12_INPUT_CLASSIFICATION_PER_INSTANCE_DATA = 1
} D3D12_INPUT_CLASSIFICATION;

typedef struct D3D12_INPUT_ELEMENT_DESC {
  const char *SemanticName;
  u32 SemanticIndex;
  DXGI_FORMAT Format;
  u32 InputSlot;
  u32 AlignedByteOffset;
  D3D12_INPUT_CLASSIFICATION InputSlotClass;
  u32 InstanceDataStepRate;
} D3D12_INPUT_ELEMENT_DESC;

typedef enum D3D12_FILL_MODE {
  D3D12_FILL_MODE_WIREFRAME = 2,
  D3D12_FILL_MODE_SOLID = 3
} D3D12_FILL_MODE;

typedef enum D3D12_PRIMITIVE_TOPOLOGY {
  D3D_PRIMITIVE_TOPOLOGY_UNDEFINED = 0,
  D3D_PRIMITIVE_TOPOLOGY_POINTLIST = 1,
  D3D_PRIMITIVE_TOPOLOGY_LINELIST = 2,
  D3D_PRIMITIVE_TOPOLOGY_LINESTRIP = 3,
  D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST = 4,
  D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP = 5,
  D3D_PRIMITIVE_TOPOLOGY_LINELIST_ADJ = 10,
  D3D_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ = 11,
  D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ = 12,
  D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ = 13,
  D3D_PRIMITIVE_TOPOLOGY_1_CONTROL_POINT_PATCHLIST = 33,
  D3D_PRIMITIVE_TOPOLOGY_2_CONTROL_POINT_PATCHLIST = 34,
  D3D_PRIMITIVE_TOPOLOGY_3_CONTROL_POINT_PATCHLIST = 35,
  D3D_PRIMITIVE_TOPOLOGY_4_CONTROL_POINT_PATCHLIST = 36,
  D3D_PRIMITIVE_TOPOLOGY_5_CONTROL_POINT_PATCHLIST = 37,
  D3D_PRIMITIVE_TOPOLOGY_6_CONTROL_POINT_PATCHLIST = 38,
  D3D_PRIMITIVE_TOPOLOGY_7_CONTROL_POINT_PATCHLIST = 39,
  D3D_PRIMITIVE_TOPOLOGY_8_CONTROL_POINT_PATCHLIST = 40,
  D3D_PRIMITIVE_TOPOLOGY_9_CONTROL_POINT_PATCHLIST = 41,
  D3D_PRIMITIVE_TOPOLOGY_10_CONTROL_POINT_PATCHLIST = 42,
  D3D_PRIMITIVE_TOPOLOGY_11_CONTROL_POINT_PATCHLIST = 43,
  D3D_PRIMITIVE_TOPOLOGY_12_CONTROL_POINT_PATCHLIST = 44,
  D3D_PRIMITIVE_TOPOLOGY_13_CONTROL_POINT_PATCHLIST = 45,
  D3D_PRIMITIVE_TOPOLOGY_14_CONTROL_POINT_PATCHLIST = 46,
  D3D_PRIMITIVE_TOPOLOGY_15_CONTROL_POINT_PATCHLIST = 47,
  D3D_PRIMITIVE_TOPOLOGY_16_CONTROL_POINT_PATCHLIST = 48,
  D3D_PRIMITIVE_TOPOLOGY_17_CONTROL_POINT_PATCHLIST = 49,
  D3D_PRIMITIVE_TOPOLOGY_18_CONTROL_POINT_PATCHLIST = 50,
  D3D_PRIMITIVE_TOPOLOGY_19_CONTROL_POINT_PATCHLIST = 51,
  D3D_PRIMITIVE_TOPOLOGY_20_CONTROL_POINT_PATCHLIST = 52,
  D3D_PRIMITIVE_TOPOLOGY_21_CONTROL_POINT_PATCHLIST = 53,
  D3D_PRIMITIVE_TOPOLOGY_22_CONTROL_POINT_PATCHLIST = 54,
  D3D_PRIMITIVE_TOPOLOGY_23_CONTROL_POINT_PATCHLIST = 55,
  D3D_PRIMITIVE_TOPOLOGY_24_CONTROL_POINT_PATCHLIST = 56,
  D3D_PRIMITIVE_TOPOLOGY_25_CONTROL_POINT_PATCHLIST = 57,
  D3D_PRIMITIVE_TOPOLOGY_26_CONTROL_POINT_PATCHLIST = 58,
  D3D_PRIMITIVE_TOPOLOGY_27_CONTROL_POINT_PATCHLIST = 59,
  D3D_PRIMITIVE_TOPOLOGY_28_CONTROL_POINT_PATCHLIST = 60,
  D3D_PRIMITIVE_TOPOLOGY_29_CONTROL_POINT_PATCHLIST = 61,
  D3D_PRIMITIVE_TOPOLOGY_30_CONTROL_POINT_PATCHLIST = 62,
  D3D_PRIMITIVE_TOPOLOGY_31_CONTROL_POINT_PATCHLIST = 63,
  D3D_PRIMITIVE_TOPOLOGY_32_CONTROL_POINT_PATCHLIST = 64
} D3D12_PRIMITIVE_TOPOLOGY;

typedef enum D3D12_PRIMITIVE_TOPOLOGY_TYPE {
  D3D12_PRIMITIVE_TOPOLOGY_TYPE_UNDEFINED = 0,
  D3D12_PRIMITIVE_TOPOLOGY_TYPE_POINT = 1,
  D3D12_PRIMITIVE_TOPOLOGY_TYPE_LINE = 2,
  D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE = 3,
  D3D12_PRIMITIVE_TOPOLOGY_TYPE_PATCH = 4
} D3D12_PRIMITIVE_TOPOLOGY_TYPE;

typedef struct D3D12_SO_DECLARATION_ENTRY {
  u32 Stream;
  const char *SemanticName;
  u32 SemanticIndex;
  u8 StartComponent;
  u8 ComponentCount;
  u8 OutputSlot;
} D3D12_SO_DECLARATION_ENTRY;

typedef enum D3D12_CULL_MODE {
  D3D12_CULL_MODE_NONE = 1,
  D3D12_CULL_MODE_FRONT = 2,
  D3D12_CULL_MODE_BACK = 3
} D3D12_CULL_MODE;

typedef struct D3D12_VIEWPORT {
  f32 TopLeftX;
  f32 TopLeftY;
  f32 Width;
  f32 Height;
  f32 MinDepth;
  f32 MaxDepth;
} D3D12_VIEWPORT;

typedef enum D3D12_COMPARISON_FUNC {
  D3D12_COMPARISON_FUNC_NEVER = 1,
  D3D12_COMPARISON_FUNC_LESS = 2,
  D3D12_COMPARISON_FUNC_EQUAL = 3,
  D3D12_COMPARISON_FUNC_LESS_EQUAL = 4,
  D3D12_COMPARISON_FUNC_GREATER = 5,
  D3D12_COMPARISON_FUNC_NOT_EQUAL = 6,
  D3D12_COMPARISON_FUNC_GREATER_EQUAL = 7,
  D3D12_COMPARISON_FUNC_ALWAYS = 8
} D3D12_COMPARISON_FUNC;

typedef enum D3D12_DEPTH_WRITE_MASK {
  D3D12_DEPTH_WRITE_MASK_ZERO = 0,
  D3D12_DEPTH_WRITE_MASK_ALL = 1
} D3D12_DEPTH_WRITE_MASK;

typedef enum D3D12_STENCIL_OP {
  D3D12_STENCIL_OP_KEEP = 1,
  D3D12_STENCIL_OP_ZERO = 2,
  D3D12_STENCIL_OP_REPLACE = 3,
  D3D12_STENCIL_OP_INCR_SAT = 4,
  D3D12_STENCIL_OP_DECR_SAT = 5,
  D3D12_STENCIL_OP_INVERT = 6,
  D3D12_STENCIL_OP_INCR = 7,
  D3D12_STENCIL_OP_DECR = 8
} D3D12_STENCIL_OP;

typedef struct D3D12_DEPTH_STENCILOP_DESC {
  D3D12_STENCIL_OP StencilFailOp;
  D3D12_STENCIL_OP StencilDepthFailOp;
  D3D12_STENCIL_OP StencilPassOp;
  D3D12_COMPARISON_FUNC StencilFunc;
} D3D12_DEPTH_STENCILOP_DESC;

typedef struct D3D12_DEPTH_STENCIL_DESC {
  i32 DepthEnable;
  D3D12_DEPTH_WRITE_MASK DepthWriteMask;
  D3D12_COMPARISON_FUNC DepthFunc;
  i32 StencilEnable;
  u8 StencilReadMask;
  u8 StencilWriteMask;
  D3D12_DEPTH_STENCILOP_DESC FrontFace;
  D3D12_DEPTH_STENCILOP_DESC BackFace;
} D3D12_DEPTH_STENCIL_DESC;

typedef enum D3D12_BLEND {
  D3D12_BLEND_ZERO = 1,
  D3D12_BLEND_ONE = 2,
  D3D12_BLEND_SRC_COLOR = 3,
  D3D12_BLEND_INV_SRC_COLOR = 4,
  D3D12_BLEND_SRC_ALPHA = 5,
  D3D12_BLEND_INV_SRC_ALPHA = 6,
  D3D12_BLEND_DEST_ALPHA = 7,
  D3D12_BLEND_INV_DEST_ALPHA = 8,
  D3D12_BLEND_DEST_COLOR = 9,
  D3D12_BLEND_INV_DEST_COLOR = 10,
  D3D12_BLEND_SRC_ALPHA_SAT = 11,
  D3D12_BLEND_BLEND_FACTOR = 14,
  D3D12_BLEND_INV_BLEND_FACTOR = 15,
  D3D12_BLEND_SRC1_COLOR = 16,
  D3D12_BLEND_INV_SRC1_COLOR = 17,
  D3D12_BLEND_SRC1_ALPHA = 18,
  D3D12_BLEND_INV_SRC1_ALPHA = 19
} D3D12_BLEND;

typedef enum D3D12_BLEND_OP {
  D3D12_BLEND_OP_ADD = 1,
  D3D12_BLEND_OP_SUBTRACT = 2,
  D3D12_BLEND_OP_REV_SUBTRACT = 3,
  D3D12_BLEND_OP_MIN = 4,
  D3D12_BLEND_OP_MAX = 5
} D3D12_BLEND_OP;

typedef enum D3D12_COLOR_WRITE_ENABLE {
  D3D12_COLOR_WRITE_ENABLE_RED = 1,
  D3D12_COLOR_WRITE_ENABLE_GREEN = 2,
  D3D12_COLOR_WRITE_ENABLE_BLUE = 4,
  D3D12_COLOR_WRITE_ENABLE_ALPHA = 8,
  D3D12_COLOR_WRITE_ENABLE_ALL = D3D12_COLOR_WRITE_ENABLE_RED | D3D12_COLOR_WRITE_ENABLE_GREEN |
                                 D3D12_COLOR_WRITE_ENABLE_BLUE | D3D12_COLOR_WRITE_ENABLE_ALPHA
} D3D12_COLOR_WRITE_ENABLE;

typedef enum D3D12_LOGIC_OP {
  D3D12_LOGIC_OP_CLEAR = 0,
  D3D12_LOGIC_OP_SET = (D3D12_LOGIC_OP_CLEAR + 1),
  D3D12_LOGIC_OP_COPY = (D3D12_LOGIC_OP_SET + 1),
  D3D12_LOGIC_OP_COPY_INVERTED = (D3D12_LOGIC_OP_COPY + 1),
  D3D12_LOGIC_OP_NOOP = (D3D12_LOGIC_OP_COPY_INVERTED + 1),
  D3D12_LOGIC_OP_INVERT = (D3D12_LOGIC_OP_NOOP + 1),
  D3D12_LOGIC_OP_AND = (D3D12_LOGIC_OP_INVERT + 1),
  D3D12_LOGIC_OP_NAND = (D3D12_LOGIC_OP_AND + 1),
  D3D12_LOGIC_OP_OR = (D3D12_LOGIC_OP_NAND + 1),
  D3D12_LOGIC_OP_NOR = (D3D12_LOGIC_OP_OR + 1),
  D3D12_LOGIC_OP_XOR = (D3D12_LOGIC_OP_NOR + 1),
  D3D12_LOGIC_OP_EQUIV = (D3D12_LOGIC_OP_XOR + 1),
  D3D12_LOGIC_OP_AND_REVERSE = (D3D12_LOGIC_OP_EQUIV + 1),
  D3D12_LOGIC_OP_AND_INVERTED = (D3D12_LOGIC_OP_AND_REVERSE + 1),
  D3D12_LOGIC_OP_OR_REVERSE = (D3D12_LOGIC_OP_AND_INVERTED + 1),
  D3D12_LOGIC_OP_OR_INVERTED = (D3D12_LOGIC_OP_OR_REVERSE + 1)
} D3D12_LOGIC_OP;

typedef struct D3D12_RENDER_TARGET_BLEND_DESC {
  i32 BlendEnable;
  i32 LogicOpEnable;
  D3D12_BLEND SrcBlend;
  D3D12_BLEND DestBlend;
  D3D12_BLEND_OP BlendOp;
  D3D12_BLEND SrcBlendAlpha;
  D3D12_BLEND DestBlendAlpha;
  D3D12_BLEND_OP BlendOpAlpha;
  D3D12_LOGIC_OP LogicOp;
  u8 RenderTargetWriteMask;
} D3D12_RENDER_TARGET_BLEND_DESC;

typedef struct D3D12_BLEND_DESC {
  i32 AlphaToCoverageEnable;
  i32 IndependentBlendEnable;
  D3D12_RENDER_TARGET_BLEND_DESC RenderTarget[8];
} D3D12_BLEND_DESC;

typedef enum D3D12_CONSERVATIVE_RASTERIZATION_MODE {
  D3D12_CONSERVATIVE_RASTERIZATION_MODE_OFF = 0,
  D3D12_CONSERVATIVE_RASTERIZATION_MODE_ON = 1
} D3D12_CONSERVATIVE_RASTERIZATION_MODE;

typedef struct D3D12_RASTERIZER_DESC {
  D3D12_FILL_MODE FillMode;
  D3D12_CULL_MODE CullMode;
  i32 FrontCounterClockwise;
  i32 DepthBias;
  f32 DepthBiasClamp;
  f32 SlopeScaledDepthBias;
  i32 DepthClipEnable;
  i32 MultisampleEnable;
  i32 AntialiasedLineEnable;
  u32 ForcedSampleCount;
  D3D12_CONSERVATIVE_RASTERIZATION_MODE ConservativeRaster;
} D3D12_RASTERIZER_DESC;

typedef enum D3D12_QUERY_HEAP_TYPE {
  D3D12_QUERY_HEAP_TYPE_OCCLUSION = 0,
  D3D12_QUERY_HEAP_TYPE_TIMESTAMP = 1,
  D3D12_QUERY_HEAP_TYPE_PIPELINE_STATISTICS = 2,
  D3D12_QUERY_HEAP_TYPE_SO_STATISTICS = 3
} D3D12_QUERY_HEAP_TYPE;

typedef struct D3D12_QUERY_HEAP_DESC {
  D3D12_QUERY_HEAP_TYPE Type;
  u32 Count;
  u32 NodeMask;
} D3D12_QUERY_HEAP_DESC;

typedef enum D3D12_QUERY_TYPE {
  D3D12_QUERY_TYPE_OCCLUSION = 0,
  D3D12_QUERY_TYPE_BINARY_OCCLUSION = 1,
  D3D12_QUERY_TYPE_TIMESTAMP = 2,
  D3D12_QUERY_TYPE_PIPELINE_STATISTICS = 3,
  D3D12_QUERY_TYPE_SO_STATISTICS_STREAM0 = 4,
  D3D12_QUERY_TYPE_SO_STATISTICS_STREAM1 = 5,
  D3D12_QUERY_TYPE_SO_STATISTICS_STREAM2 = 6,
  D3D12_QUERY_TYPE_SO_STATISTICS_STREAM3 = 7
} D3D12_QUERY_TYPE;

typedef enum D3D12_PREDICATION_OP {
  D3D12_PREDICATION_OP_EQUAL_ZERO = 0,
  D3D12_PREDICATION_OP_NOT_EQUAL_ZERO = 1
} D3D12_PREDICATION_OP;

typedef struct D3D12_QUERY_DATA_PIPELINE_STATISTICS {
  u64 IAVertices;
  u64 IAPrimitives;
  u64 VSInvocations;
  u64 GSInvocations;
  u64 GSPrimitives;
  u64 CInvocations;
  u64 CPrimitives;
  u64 PSInvocations;
  u64 HSInvocations;
  u64 DSInvocations;
  u64 CSInvocations;
} D3D12_QUERY_DATA_PIPELINE_STATISTICS;

typedef struct D3D12_QUERY_DATA_SO_STATISTICS {
  u64 NumPrimitivesWritten;
  u64 PrimitivesStorageNeeded;
} D3D12_QUERY_DATA_SO_STATISTICS;

typedef struct D3D12_STREAM_OUTPUT_BUFFER_VIEW {
  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation;
  u64 SizeInBytes;
  D3D12_GPU_VIRTUAL_ADDRESS BufferFilledSizeLocation;
} D3D12_STREAM_OUTPUT_BUFFER_VIEW;

typedef struct D3D12_DRAW_ARGUMENTS {
  u32 VertexCountPerInstance;
  u32 InstanceCount;
  u32 StartVertexLocation;
  u32 StartInstanceLocation;
} D3D12_DRAW_ARGUMENTS;

typedef struct D3D12_DRAW_INDEXED_ARGUMENTS {
  u32 IndexCountPerInstance;
  u32 InstanceCount;
  u32 StartIndexLocation;
  i32 BaseVertexLocation;
  u32 StartInstanceLocation;
} D3D12_DRAW_INDEXED_ARGUMENTS;

typedef struct D3D12_DISPATCH_ARGUMENTS {
  u32 ThreadGroupCountX;
  u32 ThreadGroupCountY;
  u32 ThreadGroupCountZ;
} D3D12_DISPATCH_ARGUMENTS;

typedef struct D3D12_VERTEX_BUFFER_VIEW {
  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation;
  u32 SizeInBytes;
  u32 StrideInBytes;
} D3D12_VERTEX_BUFFER_VIEW;

typedef struct D3D12_INDEX_BUFFER_VIEW {
  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation;
  u32 SizeInBytes;
  DXGI_FORMAT Format;
} D3D12_INDEX_BUFFER_VIEW;

typedef enum D3D12_INDIRECT_ARGUMENT_TYPE {
  D3D12_INDIRECT_ARGUMENT_TYPE_DRAW = 0,
  D3D12_INDIRECT_ARGUMENT_TYPE_DRAW_INDEXED = (D3D12_INDIRECT_ARGUMENT_TYPE_DRAW + 1),
  D3D12_INDIRECT_ARGUMENT_TYPE_DISPATCH = (D3D12_INDIRECT_ARGUMENT_TYPE_DRAW_INDEXED + 1),
  D3D12_INDIRECT_ARGUMENT_TYPE_VERTEX_BUFFER_VIEW = (D3D12_INDIRECT_ARGUMENT_TYPE_DISPATCH + 1),
  D3D12_INDIRECT_ARGUMENT_TYPE_INDEX_BUFFER_VIEW =
      (D3D12_INDIRECT_ARGUMENT_TYPE_VERTEX_BUFFER_VIEW + 1),
  D3D12_INDIRECT_ARGUMENT_TYPE_CONSTANT = (D3D12_INDIRECT_ARGUMENT_TYPE_INDEX_BUFFER_VIEW + 1),
  D3D12_INDIRECT_ARGUMENT_TYPE_CONSTANT_BUFFER_VIEW = (D3D12_INDIRECT_ARGUMENT_TYPE_CONSTANT + 1),
  D3D12_INDIRECT_ARGUMENT_TYPE_SHADER_RESOURCE_VIEW =
      (D3D12_INDIRECT_ARGUMENT_TYPE_CONSTANT_BUFFER_VIEW + 1),
  D3D12_INDIRECT_ARGUMENT_TYPE_UNORDERED_ACCESS_VIEW =
      (D3D12_INDIRECT_ARGUMENT_TYPE_SHADER_RESOURCE_VIEW + 1)
} D3D12_INDIRECT_ARGUMENT_TYPE;

typedef struct D3D12_INDIRECT_ARGUMENT_DESC {
  D3D12_INDIRECT_ARGUMENT_TYPE Type;
  union {
    struct {
      u32 Slot;
    } VertexBuffer;
    struct {
      u32 RootParameterIndex;
      u32 DestOffsetIn32BitValues;
      u32 Num32BitValuesToSet;
    } Constant;
    struct {
      u32 RootParameterIndex;
    } ConstantBufferView;
    struct {
      u32 RootParameterIndex;
    } ShaderResourceView;
    struct {
      u32 RootParameterIndex;
    } UnorderedAccessView;
  };
} D3D12_INDIRECT_ARGUMENT_DESC;

typedef struct D3D12_COMMAND_SIGNATURE_DESC {
  u32 ByteStride;
  u32 NumArgumentDescs;
  const D3D12_INDIRECT_ARGUMENT_DESC *pArgumentDescs;
  u32 NodeMask;
} D3D12_COMMAND_SIGNATURE_DESC;

typedef enum D3D12_CLEAR_FLAGS {
  D3D12_CLEAR_FLAG_DEPTH = 0x1,
  D3D12_CLEAR_FLAG_STENCIL = 0x2
} D3D12_CLEAR_FLAGS;

typedef enum D3D12_COMMAND_QUEUE_FLAGS {
  D3D12_COMMAND_QUEUE_FLAG_NONE = 0,
  D3D12_COMMAND_QUEUE_FLAG_DISABLE_GPU_TIMEOUT = 0x1
} D3D12_COMMAND_QUEUE_FLAGS;

typedef enum D3D12_COMMAND_QUEUE_PRIORITY {
  D3D12_COMMAND_QUEUE_PRIORITY_NORMAL = 0,
  D3D12_COMMAND_QUEUE_PRIORITY_HIGH = 100
} D3D12_COMMAND_QUEUE_PRIORITY;

typedef struct D3D12_COMMAND_QUEUE_DESC {
  D3D12_COMMAND_LIST_TYPE Type;
  i32 Priority;
  D3D12_COMMAND_QUEUE_FLAGS Flags;
  u32 NodeMask;
} D3D12_COMMAND_QUEUE_DESC;

typedef struct D3D12_SHADER_BYTECODE {
  const void *pShaderBytecode;
  u64 BytecodeLength;
} D3D12_SHADER_BYTECODE;

typedef struct D3D12_STREAM_OUTPUT_DESC {
  const D3D12_SO_DECLARATION_ENTRY *pSODeclaration;
  u32 NumEntries;
  const u32 *pBufferStrides;
  u32 NumStrides;
  u32 RasterizedStream;
} D3D12_STREAM_OUTPUT_DESC;

typedef struct D3D12_INPUT_LAYOUT_DESC {
  const D3D12_INPUT_ELEMENT_DESC *pInputElementDescs;
  u32 NumElements;
} D3D12_INPUT_LAYOUT_DESC;

typedef enum D3D12_INDEX_BUFFER_STRIP_CUT_VALUE {
  D3D12_INDEX_BUFFER_STRIP_CUT_VALUE_DISABLED = 0,
  D3D12_INDEX_BUFFER_STRIP_CUT_VALUE_0xFFFF = 1,
  D3D12_INDEX_BUFFER_STRIP_CUT_VALUE_0xFFFFFFFF = 2
} D3D12_INDEX_BUFFER_STRIP_CUT_VALUE;

typedef struct D3D12_CACHED_PIPELINE_STATE {
  const void *pCachedBlob;
  u64 CachedBlobSizeInBytes;
} D3D12_CACHED_PIPELINE_STATE;

typedef enum D3D12_PIPELINE_STATE_FLAGS {
  D3D12_PIPELINE_STATE_FLAG_NONE = 0,
  D3D12_PIPELINE_STATE_FLAG_TOOL_DEBUG = 0x1
} D3D12_PIPELINE_STATE_FLAGS;

typedef struct D3D12_GRAPHICS_PIPELINE_STATE_DESC {
  ID3D12RootSignature *pRootSignature;
  D3D12_SHADER_BYTECODE VS;
  D3D12_SHADER_BYTECODE PS;
  D3D12_SHADER_BYTECODE DS;
  D3D12_SHADER_BYTECODE HS;
  D3D12_SHADER_BYTECODE GS;
  D3D12_STREAM_OUTPUT_DESC StreamOutput;
  D3D12_BLEND_DESC BlendState;
  u32 SampleMask;
  D3D12_RASTERIZER_DESC RasterizerState;
  D3D12_DEPTH_STENCIL_DESC DepthStencilState;
  D3D12_INPUT_LAYOUT_DESC InputLayout;
  D3D12_INDEX_BUFFER_STRIP_CUT_VALUE IBStripCutValue;
  D3D12_PRIMITIVE_TOPOLOGY_TYPE PrimitiveTopologyType;
  u32 NumRenderTargets;
  DXGI_FORMAT RTVFormats[8];
  DXGI_FORMAT DSVFormat;
  DXGI_SAMPLE_DESC SampleDesc;
  u32 NodeMask;
  D3D12_CACHED_PIPELINE_STATE CachedPSO;
  D3D12_PIPELINE_STATE_FLAGS Flags;
} D3D12_GRAPHICS_PIPELINE_STATE_DESC;

typedef struct D3D12_COMPUTE_PIPELINE_STATE_DESC {
  ID3D12RootSignature *pRootSignature;
  D3D12_SHADER_BYTECODE CS;
  u32 NodeMask;
  D3D12_CACHED_PIPELINE_STATE CachedPSO;
  D3D12_PIPELINE_STATE_FLAGS Flags;
} D3D12_COMPUTE_PIPELINE_STATE_DESC;

typedef enum D3D12_FEATURE {
  D3D12_FEATURE_D3D12_OPTIONS = 0,
  D3D12_FEATURE_ARCHITECTURE = 1,
  D3D12_FEATURE_FEATURE_LEVELS = 2,
  D3D12_FEATURE_FORMAT_SUPPORT = 3,
  D3D12_FEATURE_MULTISAMPLE_QUALITY_LEVELS = 4,
  D3D12_FEATURE_FORMAT_INFO = 5,
  D3D12_FEATURE_GPU_VIRTUAL_ADDRESS_SUPPORT = 6,
  D3D12_FEATURE_SHADER_MODEL = 7,
  D3D12_FEATURE_D3D12_OPTIONS1 = 8,
  D3D12_FEATURE_ROOT_SIGNATURE = 12
} D3D12_FEATURE;

typedef enum D3D12_SHADER_MIN_PRECISION_SUPPORT {
  D3D12_SHADER_MIN_PRECISION_SUPPORT_NONE = 0,
  D3D12_SHADER_MIN_PRECISION_SUPPORT_10_BIT = 0x1,
  D3D12_SHADER_MIN_PRECISION_SUPPORT_16_BIT = 0x2
} D3D12_SHADER_MIN_PRECISION_SUPPORT;

typedef enum D3D12_TILED_RESOURCES_TIER {
  D3D12_TILED_RESOURCES_TIER_NOT_SUPPORTED = 0,
  D3D12_TILED_RESOURCES_TIER_1 = 1,
  D3D12_TILED_RESOURCES_TIER_2 = 2,
  D3D12_TILED_RESOURCES_TIER_3 = 3
} D3D12_TILED_RESOURCES_TIER;

typedef enum D3D12_RESOURCE_BINDING_TIER {
  D3D12_RESOURCE_BINDING_TIER_1 = 1,
  D3D12_RESOURCE_BINDING_TIER_2 = 2,
  D3D12_RESOURCE_BINDING_TIER_3 = 3
} D3D12_RESOURCE_BINDING_TIER;

typedef enum D3D12_CONSERVATIVE_RASTERIZATION_TIER {
  D3D12_CONSERVATIVE_RASTERIZATION_TIER_NOT_SUPPORTED = 0,
  D3D12_CONSERVATIVE_RASTERIZATION_TIER_1 = 1,
  D3D12_CONSERVATIVE_RASTERIZATION_TIER_2 = 2,
  D3D12_CONSERVATIVE_RASTERIZATION_TIER_3 = 3
} D3D12_CONSERVATIVE_RASTERIZATION_TIER;

typedef enum D3D12_FORMAT_SUPPORT1 {
  D3D12_FORMAT_SUPPORT1_NONE = 0,
  D3D12_FORMAT_SUPPORT1_BUFFER = 0x1,
  D3D12_FORMAT_SUPPORT1_IA_VERTEX_BUFFER = 0x2,
  D3D12_FORMAT_SUPPORT1_IA_INDEX_BUFFER = 0x4,
  D3D12_FORMAT_SUPPORT1_SO_BUFFER = 0x8,
  D3D12_FORMAT_SUPPORT1_TEXTURE1D = 0x10,
  D3D12_FORMAT_SUPPORT1_TEXTURE2D = 0x20,
  D3D12_FORMAT_SUPPORT1_TEXTURE3D = 0x40,
  D3D12_FORMAT_SUPPORT1_TEXTURECUBE = 0x80,
  D3D12_FORMAT_SUPPORT1_SHADER_LOAD = 0x100,
  D3D12_FORMAT_SUPPORT1_SHADER_SAMPLE = 0x200,
  D3D12_FORMAT_SUPPORT1_SHADER_SAMPLE_COMPARISON = 0x400,
  D3D12_FORMAT_SUPPORT1_SHADER_SAMPLE_MONO_TEXT = 0x800,
  D3D12_FORMAT_SUPPORT1_MIP = 0x1000,
  D3D12_FORMAT_SUPPORT1_RENDER_TARGET = 0x4000,
  D3D12_FORMAT_SUPPORT1_BLENDABLE = 0x8000,
  D3D12_FORMAT_SUPPORT1_DEPTH_STENCIL = 0x10000,
  D3D12_FORMAT_SUPPORT1_MULTISAMPLE_RESOLVE = 0x40000,
  D3D12_FORMAT_SUPPORT1_DISPLAY = 0x80000,
  D3D12_FORMAT_SUPPORT1_CAST_WITHIN_BIT_LAYOUT = 0x100000,
  D3D12_FORMAT_SUPPORT1_MULTISAMPLE_RENDERTARGET = 0x200000,
  D3D12_FORMAT_SUPPORT1_MULTISAMPLE_LOAD = 0x400000,
  D3D12_FORMAT_SUPPORT1_SHADER_GATHER = 0x800000,
  D3D12_FORMAT_SUPPORT1_BACK_BUFFER_CAST = 0x1000000,
  D3D12_FORMAT_SUPPORT1_TYPED_UNORDERED_ACCESS_VIEW = 0x2000000,
  D3D12_FORMAT_SUPPORT1_SHADER_GATHER_COMPARISON = 0x4000000,
  D3D12_FORMAT_SUPPORT1_DECODER_OUTPUT = 0x8000000,
  D3D12_FORMAT_SUPPORT1_VIDEO_PROCESSOR_OUTPUT = 0x10000000,
  D3D12_FORMAT_SUPPORT1_VIDEO_PROCESSOR_INPUT = 0x20000000,
  D3D12_FORMAT_SUPPORT1_VIDEO_ENCODER = 0x40000000
} D3D12_FORMAT_SUPPORT1;

typedef enum D3D12_FORMAT_SUPPORT2 {
  D3D12_FORMAT_SUPPORT2_NONE = 0,
  D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_ADD = 0x1,
  D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_BITWISE_OPS = 0x2,
  D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_COMPARE_STORE_OR_COMPARE_EXCHANGE = 0x4,
  D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_EXCHANGE = 0x8,
  D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_SIGNED_MIN_OR_MAX = 0x10,
  D3D12_FORMAT_SUPPORT2_UAV_ATOMIC_UNSIGNED_MIN_OR_MAX = 0x20,
  D3D12_FORMAT_SUPPORT2_UAV_TYPED_LOAD = 0x40,
  D3D12_FORMAT_SUPPORT2_UAV_TYPED_STORE = 0x80,
  D3D12_FORMAT_SUPPORT2_OUTPUT_MERGER_LOGIC_OP = 0x100,
  D3D12_FORMAT_SUPPORT2_TILED = 0x200,
  D3D12_FORMAT_SUPPORT2_MULTIPLANE_OVERLAY = 0x4000
} D3D12_FORMAT_SUPPORT2;

typedef enum D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS {
  D3D12_MULTISAMPLE_QUALITY_LEVELS_FLAG_NONE = 0,
  D3D12_MULTISAMPLE_QUALITY_LEVELS_FLAG_TILED_RESOURCE = 0x1
} D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS;

typedef enum D3D12_CROSS_NODE_SHARING_TIER {
  D3D12_CROSS_NODE_SHARING_TIER_NOT_SUPPORTED = 0,
  D3D12_CROSS_NODE_SHARING_TIER_1_EMULATED = 1,
  D3D12_CROSS_NODE_SHARING_TIER_1 = 2,
  D3D12_CROSS_NODE_SHARING_TIER_2 = 3
} D3D12_CROSS_NODE_SHARING_TIER;

typedef enum D3D12_RESOURCE_HEAP_TIER {
  D3D12_RESOURCE_HEAP_TIER_1 = 1,
  D3D12_RESOURCE_HEAP_TIER_2 = 2
} D3D12_RESOURCE_HEAP_TIER;

typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS {
  i32 DoublePrecisionFloatShaderOps;
  i32 OutputMergerLogicOp;
  D3D12_SHADER_MIN_PRECISION_SUPPORT MinPrecisionSupport;
  D3D12_TILED_RESOURCES_TIER TiledResourcesTier;
  D3D12_RESOURCE_BINDING_TIER ResourceBindingTier;
  i32 PSSpecifiedStencilRefSupported;
  i32 TypedUAVLoadAdditionalFormats;
  i32 ROVsSupported;
  D3D12_CONSERVATIVE_RASTERIZATION_TIER ConservativeRasterizationTier;
  u32 MaxGPUVirtualAddressBitsPerResource;
  i32 StandardSwizzle64KBSupported;
  D3D12_CROSS_NODE_SHARING_TIER CrossNodeSharingTier;
  i32 CrossAdapterRowMajorTextureSupported;
  i32 VPAndRTArrayIndexFromAnyShaderFeedingRasterizerSupportedWithoutGSEmulation;
  D3D12_RESOURCE_HEAP_TIER ResourceHeapTier;
} D3D12_FEATURE_DATA_D3D12_OPTIONS;

typedef struct D3D12_FEATURE_DATA_D3D12_OPTIONS1 {
  i32 WaveOps;
  u32 WaveLaneCountMin;
  u32 WaveLaneCountMax;
  u32 TotalLaneCount;
  i32 ExpandedComputeResourceStates;
  i32 Int64ShaderOps;
} D3D12_FEATURE_DATA_D3D12_OPTIONS1;

typedef enum D3D_ROOT_SIGNATURE_VERSION {
  D3D_ROOT_SIGNATURE_VERSION_1 = 0x1,
  D3D_ROOT_SIGNATURE_VERSION_1_0 = 0x1,
  D3D_ROOT_SIGNATURE_VERSION_1_1 = 0x2
} D3D_ROOT_SIGNATURE_VERSION;

typedef struct D3D12_FEATURE_DATA_ROOT_SIGNATURE {
  D3D_ROOT_SIGNATURE_VERSION HighestVersion;
} D3D12_FEATURE_DATA_ROOT_SIGNATURE;

typedef struct D3D12_FEATURE_DATA_ARCHITECTURE {
  u32 NodeIndex;
  i32 TileBasedRenderer;
  i32 UMA;
  i32 CacheCoherentUMA;
} D3D12_FEATURE_DATA_ARCHITECTURE;

typedef struct D3D12_FEATURE_DATA_FEATURE_LEVELS {
  u32 NumFeatureLevels;
  const D3D_FEATURE_LEVEL *pFeatureLevelsRequested;
  D3D_FEATURE_LEVEL MaxSupportedFeatureLevel;
} D3D12_FEATURE_DATA_FEATURE_LEVELS;

typedef enum D3D_SHADER_MODEL {
  D3D_SHADER_MODEL_5_1 = 0x51,
  D3D_SHADER_MODEL_6_0 = 0x60
} D3D_SHADER_MODEL;

typedef struct D3D12_FEATURE_DATA_SHADER_MODEL {
  D3D_SHADER_MODEL HighestShaderModel;
} D3D12_FEATURE_DATA_SHADER_MODEL;

typedef struct D3D12_FEATURE_DATA_FORMAT_SUPPORT {
  DXGI_FORMAT Format;
  D3D12_FORMAT_SUPPORT1 Support1;
  D3D12_FORMAT_SUPPORT2 Support2;
} D3D12_FEATURE_DATA_FORMAT_SUPPORT;

typedef struct D3D12_FEATURE_DATA_MULTISAMPLE_QUALITY_LEVELS {
  DXGI_FORMAT Format;
  u32 SampleCount;
  D3D12_MULTISAMPLE_QUALITY_LEVEL_FLAGS Flags;
  u32 NumQualityLevels;
} D3D12_FEATURE_DATA_MULTISAMPLE_QUALITY_LEVELS;

typedef struct D3D12_FEATURE_DATA_FORMAT_INFO {
  DXGI_FORMAT Format;
  u8 PlaneCount;
} D3D12_FEATURE_DATA_FORMAT_INFO;

struct D3D12_FEATURE_DATA_GPU_VIRTUAL_ADDRESS_SUPPORT {
  u32 MaxGPUVirtualAddressBitsPerResource;
  u32 MaxGPUVirtualAddressBitsPerProcess;
} D3D12_FEATURE_DATA_GPU_VIRTUAL_ADDRESS_SUPPORT;

typedef struct D3D12_RESOURCE_ALLOCATION_INFO {
  u64 SizeInBytes;
  u64 Alignment;
} D3D12_RESOURCE_ALLOCATION_INFO;

typedef enum D3D12_SHADER_COMPONENT_MAPPING {
  D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_0 = 0,
  D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_1 = 1,
  D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_2 = 2,
  D3D12_SHADER_COMPONENT_MAPPING_FROM_MEMORY_COMPONENT_3 = 3,
  D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_0 = 4,
  D3D12_SHADER_COMPONENT_MAPPING_FORCE_VALUE_1 = 5
} D3D12_SHADER_COMPONENT_MAPPING;

#define D3D12_ENCODE_SHADER_4_COMPONENT_MAPPING(Src0, Src1, Src2, Src3)                            \
  (((Src0)&0x7) | (((Src1)&0x7) << 3) | (((Src2)&0x7) << (3 * 2)) | (((Src3)&0x7) << (3 * 3)) |    \
   (1 << (3 * 4)))
#define D3D12_DECODE_SHADER_4_COMPONENT_MAPPING(ComponentToExtract, Mapping)                       \
  ((D3D12_SHADER_COMPONENT_MAPPING)(Mapping >> (3 * ComponentToExtract) & 0x7))
#define D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING D3D12_ENCODE_SHADER_4_COMPONENT_MAPPING(0, 1, 2, 3)

typedef enum D3D12_BUFFER_SRV_FLAGS {
  D3D12_BUFFER_SRV_FLAG_NONE = 0,
  D3D12_BUFFER_SRV_FLAG_RAW = 0x1
} D3D12_BUFFER_SRV_FLAGS;

typedef struct D3D12_BUFFER_SRV {
  u64 FirstElement;
  u32 NumElements;
  u32 StructureByteStride;
  D3D12_BUFFER_SRV_FLAGS Flags;
} D3D12_BUFFER_SRV;

typedef struct D3D12_TEX1D_SRV {
  u32 MostDetailedMip;
  u32 MipLevels;
  f32 ResourceMinLODClamp;
} D3D12_TEX1D_SRV;

typedef struct D3D12_TEX1D_ARRAY_SRV {
  u32 MostDetailedMip;
  u32 MipLevels;
  u32 FirstArraySlice;
  u32 ArraySize;
  f32 ResourceMinLODClamp;
} D3D12_TEX1D_ARRAY_SRV;

typedef struct D3D12_TEX2D_SRV {
  u32 MostDetailedMip;
  u32 MipLevels;
  u32 PlaneSlice;
  f32 ResourceMinLODClamp;
} D3D12_TEX2D_SRV;

typedef struct D3D12_TEX2D_ARRAY_SRV {
  u32 MostDetailedMip;
  u32 MipLevels;
  u32 FirstArraySlice;
  u32 ArraySize;
  u32 PlaneSlice;
  f32 ResourceMinLODClamp;
} D3D12_TEX2D_ARRAY_SRV;

typedef struct D3D12_TEX3D_SRV {
  u32 MostDetailedMip;
  u32 MipLevels;
  f32 ResourceMinLODClamp;
} D3D12_TEX3D_SRV;

typedef struct D3D12_TEXCUBE_SRV {
  u32 MostDetailedMip;
  u32 MipLevels;
  f32 ResourceMinLODClamp;
} D3D12_TEXCUBE_SRV;

typedef struct D3D12_TEXCUBE_ARRAY_SRV {
  u32 MostDetailedMip;
  u32 MipLevels;
  u32 First2DArrayFace;
  u32 NumCubes;
  f32 ResourceMinLODClamp;
} D3D12_TEXCUBE_ARRAY_SRV;

typedef struct D3D12_TEX2DMS_SRV {
  u32 UnusedField_NothingToDefine;
} D3D12_TEX2DMS_SRV;

typedef struct D3D12_TEX2DMS_ARRAY_SRV {
  u32 FirstArraySlice;
  u32 ArraySize;
} D3D12_TEX2DMS_ARRAY_SRV;

typedef enum D3D12_SRV_DIMENSION {
  D3D12_SRV_DIMENSION_UNKNOWN = 0,
  D3D12_SRV_DIMENSION_BUFFER = 1,
  D3D12_SRV_DIMENSION_TEXTURE1D = 2,
  D3D12_SRV_DIMENSION_TEXTURE1DARRAY = 3,
  D3D12_SRV_DIMENSION_TEXTURE2D = 4,
  D3D12_SRV_DIMENSION_TEXTURE2DARRAY = 5,
  D3D12_SRV_DIMENSION_TEXTURE2DMS = 6,
  D3D12_SRV_DIMENSION_TEXTURE2DMSARRAY = 7,
  D3D12_SRV_DIMENSION_TEXTURE3D = 8,
  D3D12_SRV_DIMENSION_TEXTURECUBE = 9,
  D3D12_SRV_DIMENSION_TEXTURECUBEARRAY = 10
} D3D12_SRV_DIMENSION;

typedef struct D3D12_SHADER_RESOURCE_VIEW_DESC {
  DXGI_FORMAT Format;
  D3D12_SRV_DIMENSION ViewDimension;
  u32 Shader4ComponentMapping;
  union {
    D3D12_BUFFER_SRV Buffer;
    D3D12_TEX1D_SRV Texture1D;
    D3D12_TEX1D_ARRAY_SRV Texture1DArray;
    D3D12_TEX2D_SRV Texture2D;
    D3D12_TEX2D_ARRAY_SRV Texture2DArray;
    D3D12_TEX2DMS_SRV Texture2DMS;
    D3D12_TEX2DMS_ARRAY_SRV Texture2DMSArray;
    D3D12_TEX3D_SRV Texture3D;
    D3D12_TEXCUBE_SRV TextureCube;
    D3D12_TEXCUBE_ARRAY_SRV TextureCubeArray;
  };
} D3D12_SHADER_RESOURCE_VIEW_DESC;

typedef enum D3D12_FILTER {
  D3D12_FILTER_MIN_MAG_MIP_POINT = 0,
  D3D12_FILTER_MIN_MAG_POINT_MIP_LINEAR = 0x1,
  D3D12_FILTER_MIN_POINT_MAG_LINEAR_MIP_POINT = 0x4,
  D3D12_FILTER_MIN_POINT_MAG_MIP_LINEAR = 0x5,
  D3D12_FILTER_MIN_LINEAR_MAG_MIP_POINT = 0x10,
  D3D12_FILTER_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x11,
  D3D12_FILTER_MIN_MAG_LINEAR_MIP_POINT = 0x14,
  D3D12_FILTER_MIN_MAG_MIP_LINEAR = 0x15,
  D3D12_FILTER_ANISOTROPIC = 0x55,
  D3D12_FILTER_COMPARISON_MIN_MAG_MIP_POINT = 0x80,
  D3D12_FILTER_COMPARISON_MIN_MAG_POINT_MIP_LINEAR = 0x81,
  D3D12_FILTER_COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT = 0x84,
  D3D12_FILTER_COMPARISON_MIN_POINT_MAG_MIP_LINEAR = 0x85,
  D3D12_FILTER_COMPARISON_MIN_LINEAR_MAG_MIP_POINT = 0x90,
  D3D12_FILTER_COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x91,
  D3D12_FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT = 0x94,
  D3D12_FILTER_COMPARISON_MIN_MAG_MIP_LINEAR = 0x95,
  D3D12_FILTER_COMPARISON_ANISOTROPIC = 0xd5,
  D3D12_FILTER_MINIMUM_MIN_MAG_MIP_POINT = 0x100,
  D3D12_FILTER_MINIMUM_MIN_MAG_POINT_MIP_LINEAR = 0x101,
  D3D12_FILTER_MINIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT = 0x104,
  D3D12_FILTER_MINIMUM_MIN_POINT_MAG_MIP_LINEAR = 0x105,
  D3D12_FILTER_MINIMUM_MIN_LINEAR_MAG_MIP_POINT = 0x110,
  D3D12_FILTER_MINIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x111,
  D3D12_FILTER_MINIMUM_MIN_MAG_LINEAR_MIP_POINT = 0x114,
  D3D12_FILTER_MINIMUM_MIN_MAG_MIP_LINEAR = 0x115,
  D3D12_FILTER_MINIMUM_ANISOTROPIC = 0x155,
  D3D12_FILTER_MAXIMUM_MIN_MAG_MIP_POINT = 0x180,
  D3D12_FILTER_MAXIMUM_MIN_MAG_POINT_MIP_LINEAR = 0x181,
  D3D12_FILTER_MAXIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT = 0x184,
  D3D12_FILTER_MAXIMUM_MIN_POINT_MAG_MIP_LINEAR = 0x185,
  D3D12_FILTER_MAXIMUM_MIN_LINEAR_MAG_MIP_POINT = 0x190,
  D3D12_FILTER_MAXIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 0x191,
  D3D12_FILTER_MAXIMUM_MIN_MAG_LINEAR_MIP_POINT = 0x194,
  D3D12_FILTER_MAXIMUM_MIN_MAG_MIP_LINEAR = 0x195,
  D3D12_FILTER_MAXIMUM_ANISOTROPIC = 0x1d5
} D3D12_FILTER;

typedef enum D3D12_FILTER_TYPE {
  D3D12_FILTER_TYPE_POINT = 0,
  D3D12_FILTER_TYPE_LINEAR = 1
} D3D12_FILTER_TYPE;

typedef enum D3D12_FILTER_REDUCTION_TYPE {
  D3D12_FILTER_REDUCTION_TYPE_STANDARD = 0,
  D3D12_FILTER_REDUCTION_TYPE_COMPARISON = 1,
  D3D12_FILTER_REDUCTION_TYPE_MINIMUM = 2,
  D3D12_FILTER_REDUCTION_TYPE_MAXIMUM = 3
} D3D12_FILTER_REDUCTION_TYPE;

#define D3D12_ENCODE_BASIC_FILTER(min, mag, mip, reduction)                                        \
  ((D3D12_FILTER)((((min)&0x3) << 4) | (((mag)&0x3) << 2) | ((mip)&0x3) | (((reduction)&0x3) << 7)))
#define D3D12_ENCODE_ANISOTROPIC_FILTER(reduction)                                                 \
  ((D3D12_FILTER)(0x40 |                                                                           \
                  D3D12_ENCODE_BASIC_FILTER(D3D12_FILTER_TYPE_LINEAR, D3D12_FILTER_TYPE_LINEAR,    \
                                            D3D12_FILTER_TYPE_LINEAR, reduction)))
#define D3D12_DECODE_MIN_FILTER(D3D12Filter) ((D3D12_FILTER_TYPE)(((D3D12Filter) >> 4) & 0x3))
#define D3D12_DECODE_MAG_FILTER(D3D12Filter) ((D3D12_FILTER_TYPE)(((D3D12Filter) >> 2) & 0x3))
#define D3D12_DECODE_MIP_FILTER(D3D12Filter) ((D3D12_FILTER_TYPE)(((D3D12Filter) >> 0) & 0x3))
#define D3D12_DECODE_FILTER_REDUCTION(D3D12Filter)                                                 \
  ((D3D12_FILTER_REDUCTION_TYPE)(((D3D12Filter) >> 7) & 0x3))
#define D3D12_DECODE_IS_COMPARISON_FILTER(D3D12Filter)                                             \
  (D3D12_DECODE_FILTER_REDUCTION(D3D12Filter) == D3D12_FILTER_REDUCTION_TYPE_COMPARISON)
#define D3D12_DECODE_IS_ANISOTROPIC_FILTER(D3D12Filter)                                            \
  (((D3D12Filter)&0x40) && (D3D12_FILTER_TYPE_LINEAR == D3D12_DECODE_MIN_FILTER(D3D12Filter)) &&   \
   (D3D12_FILTER_TYPE_LINEAR == D3D12_DECODE_MAG_FILTER(D3D12Filter)) &&                           \
   (D3D12_FILTER_TYPE_LINEAR == D3D12_DECODE_MIP_FILTER(D3D12Filter)))

typedef enum D3D12_TEXTURE_ADDRESS_MODE {
  D3D12_TEXTURE_ADDRESS_MODE_WRAP = 1,
  D3D12_TEXTURE_ADDRESS_MODE_MIRROR = 2,
  D3D12_TEXTURE_ADDRESS_MODE_CLAMP = 3,
  D3D12_TEXTURE_ADDRESS_MODE_BORDER = 4,
  D3D12_TEXTURE_ADDRESS_MODE_MIRROR_ONCE = 5
} D3D12_TEXTURE_ADDRESS_MODE;

typedef struct D3D12_SAMPLER_DESC {
  D3D12_FILTER Filter;
  D3D12_TEXTURE_ADDRESS_MODE AddressU;
  D3D12_TEXTURE_ADDRESS_MODE AddressV;
  D3D12_TEXTURE_ADDRESS_MODE AddressW;
  f32 MipLODBias;
  u32 MaxAnisotropy;
  D3D12_COMPARISON_FUNC ComparisonFunc;
  f32 BorderColor[4];
  f32 MinLOD;
  f32 MaxLOD;
} D3D12_SAMPLER_DESC;

typedef struct D3D12_CONSTANT_BUFFER_VIEW_DESC {
  D3D12_GPU_VIRTUAL_ADDRESS BufferLocation;
  u32 SizeInBytes;
} D3D12_CONSTANT_BUFFER_VIEW_DESC;

typedef enum D3D12_BUFFER_UAV_FLAGS {
  D3D12_BUFFER_UAV_FLAG_NONE = 0,
  D3D12_BUFFER_UAV_FLAG_RAW = 0x1
} D3D12_BUFFER_UAV_FLAGS;

typedef struct D3D12_BUFFER_UAV {
  u64 FirstElement;
  u32 NumElements;
  u32 StructureByteStride;
  u64 CounterOffsetInBytes;
  D3D12_BUFFER_UAV_FLAGS Flags;
} D3D12_BUFFER_UAV;

typedef struct D3D12_TEX1D_UAV {
  u32 MipSlice;
} D3D12_TEX1D_UAV;

typedef struct D3D12_TEX1D_ARRAY_UAV {
  u32 MipSlice;
  u32 FirstArraySlice;
  u32 ArraySize;
} D3D12_TEX1D_ARRAY_UAV;

typedef struct D3D12_TEX2D_UAV {
  u32 MipSlice;
  u32 PlaneSlice;
} D3D12_TEX2D_UAV;

typedef struct D3D12_TEX2D_ARRAY_UAV {
  u32 MipSlice;
  u32 FirstArraySlice;
  u32 ArraySize;
  u32 PlaneSlice;
} D3D12_TEX2D_ARRAY_UAV;

typedef struct D3D12_TEX3D_UAV {
  u32 MipSlice;
  u32 FirstWSlice;
  u32 WSize;
} D3D12_TEX3D_UAV;

typedef enum D3D12_UAV_DIMENSION {
  D3D12_UAV_DIMENSION_UNKNOWN = 0,
  D3D12_UAV_DIMENSION_BUFFER = 1,
  D3D12_UAV_DIMENSION_TEXTURE1D = 2,
  D3D12_UAV_DIMENSION_TEXTURE1DARRAY = 3,
  D3D12_UAV_DIMENSION_TEXTURE2D = 4,
  D3D12_UAV_DIMENSION_TEXTURE2DARRAY = 5,
  D3D12_UAV_DIMENSION_TEXTURE3D = 8
} D3D12_UAV_DIMENSION;

typedef struct D3D12_UNORDERED_ACCESS_VIEW_DESC {
  DXGI_FORMAT Format;
  D3D12_UAV_DIMENSION ViewDimension;
  union {
    D3D12_BUFFER_UAV Buffer;
    D3D12_TEX1D_UAV Texture1D;
    D3D12_TEX1D_ARRAY_UAV Texture1DArray;
    D3D12_TEX2D_UAV Texture2D;
    D3D12_TEX2D_ARRAY_UAV Texture2DArray;
    D3D12_TEX3D_UAV Texture3D;
  };
} D3D12_UNORDERED_ACCESS_VIEW_DESC;

typedef struct D3D12_BUFFER_RTV {
  u64 FirstElement;
  u32 NumElements;
} D3D12_BUFFER_RTV;

typedef struct D3D12_TEX1D_RTV {
  u32 MipSlice;
} D3D12_TEX1D_RTV;

typedef struct D3D12_TEX1D_ARRAY_RTV {
  u32 MipSlice;
  u32 FirstArraySlice;
  u32 ArraySize;
} D3D12_TEX1D_ARRAY_RTV;

typedef struct D3D12_TEX2D_RTV {
  u32 MipSlice;
  u32 PlaneSlice;
} D3D12_TEX2D_RTV;

typedef struct D3D12_TEX2DMS_RTV {
  u32 UnusedField_NothingToDefine;
} D3D12_TEX2DMS_RTV;

typedef struct D3D12_TEX2D_ARRAY_RTV {
  u32 MipSlice;
  u32 FirstArraySlice;
  u32 ArraySize;
  u32 PlaneSlice;
} D3D12_TEX2D_ARRAY_RTV;

typedef struct D3D12_TEX2DMS_ARRAY_RTV {
  u32 FirstArraySlice;
  u32 ArraySize;
} D3D12_TEX2DMS_ARRAY_RTV;

typedef struct D3D12_TEX3D_RTV {
  u32 MipSlice;
  u32 FirstWSlice;
  u32 WSize;
} D3D12_TEX3D_RTV;

typedef enum D3D12_RTV_DIMENSION {
  D3D12_RTV_DIMENSION_UNKNOWN = 0,
  D3D12_RTV_DIMENSION_BUFFER = 1,
  D3D12_RTV_DIMENSION_TEXTURE1D = 2,
  D3D12_RTV_DIMENSION_TEXTURE1DARRAY = 3,
  D3D12_RTV_DIMENSION_TEXTURE2D = 4,
  D3D12_RTV_DIMENSION_TEXTURE2DARRAY = 5,
  D3D12_RTV_DIMENSION_TEXTURE2DMS = 6,
  D3D12_RTV_DIMENSION_TEXTURE2DMSARRAY = 7,
  D3D12_RTV_DIMENSION_TEXTURE3D = 8
} D3D12_RTV_DIMENSION;

typedef struct D3D12_RENDER_TARGET_VIEW_DESC {
  DXGI_FORMAT Format;
  D3D12_RTV_DIMENSION ViewDimension;
  union {
    D3D12_BUFFER_RTV Buffer;
    D3D12_TEX1D_RTV Texture1D;
    D3D12_TEX1D_ARRAY_RTV Texture1DArray;
    D3D12_TEX2D_RTV Texture2D;
    D3D12_TEX2D_ARRAY_RTV Texture2DArray;
    D3D12_TEX2DMS_RTV Texture2DMS;
    D3D12_TEX2DMS_ARRAY_RTV Texture2DMSArray;
    D3D12_TEX3D_RTV Texture3D;
  };
} D3D12_RENDER_TARGET_VIEW_DESC;

typedef struct D3D12_TEX1D_DSV {
  u32 MipSlice;
} D3D12_TEX1D_DSV;

typedef struct D3D12_TEX1D_ARRAY_DSV {
  u32 MipSlice;
  u32 FirstArraySlice;
  u32 ArraySize;
} D3D12_TEX1D_ARRAY_DSV;

typedef struct D3D12_TEX2D_DSV {
  u32 MipSlice;
} D3D12_TEX2D_DSV;

typedef struct D3D12_TEX2D_ARRAY_DSV {
  u32 MipSlice;
  u32 FirstArraySlice;
  u32 ArraySize;
} D3D12_TEX2D_ARRAY_DSV;

typedef struct D3D12_TEX2DMS_DSV {
  u32 UnusedField_NothingToDefine;
} D3D12_TEX2DMS_DSV;

typedef struct D3D12_TEX2DMS_ARRAY_DSV {
  u32 FirstArraySlice;
  u32 ArraySize;
} D3D12_TEX2DMS_ARRAY_DSV;

typedef enum D3D12_DSV_FLAGS {
  D3D12_DSV_FLAG_NONE = 0,
  D3D12_DSV_FLAG_READ_ONLY_DEPTH = 0x1,
  D3D12_DSV_FLAG_READ_ONLY_STENCIL = 0x2
} D3D12_DSV_FLAGS;

typedef enum D3D12_DSV_DIMENSION {
  D3D12_DSV_DIMENSION_UNKNOWN = 0,
  D3D12_DSV_DIMENSION_TEXTURE1D = 1,
  D3D12_DSV_DIMENSION_TEXTURE1DARRAY = 2,
  D3D12_DSV_DIMENSION_TEXTURE2D = 3,
  D3D12_DSV_DIMENSION_TEXTURE2DARRAY = 4,
  D3D12_DSV_DIMENSION_TEXTURE2DMS = 5,
  D3D12_DSV_DIMENSION_TEXTURE2DMSARRAY = 6
} D3D12_DSV_DIMENSION;

typedef struct D3D12_DEPTH_STENCIL_VIEW_DESC {
  DXGI_FORMAT Format;
  D3D12_DSV_DIMENSION ViewDimension;
  D3D12_DSV_FLAGS Flags;
  union {
    D3D12_TEX1D_DSV Texture1D;
    D3D12_TEX1D_ARRAY_DSV Texture1DArray;
    D3D12_TEX2D_DSV Texture2D;
    D3D12_TEX2D_ARRAY_DSV Texture2DArray;
    D3D12_TEX2DMS_DSV Texture2DMS;
    D3D12_TEX2DMS_ARRAY_DSV Texture2DMSArray;
  };
} D3D12_DEPTH_STENCIL_VIEW_DESC;

typedef struct D3D12_DEPTH_STENCIL_VALUE {
  f32 Depth;
  u8 Stencil;
} D3D12_DEPTH_STENCIL_VALUE;

typedef struct D3D12_CLEAR_VALUE {
  DXGI_FORMAT Format;
  union {
    f32 Color[4];
    D3D12_DEPTH_STENCIL_VALUE DepthStencil;
  };
} D3D12_CLEAR_VALUE;

typedef enum D3D12_FENCE_FLAGS {
  D3D12_FENCE_FLAG_NONE = 0,
  D3D12_FENCE_FLAG_SHARED = 0x1,
  D3D12_FENCE_FLAG_SHARED_CROSS_ADAPTER = 0x2
} D3D12_FENCE_FLAGS;

typedef struct D3D12_PACKED_MIP_INFO {
  u8 NumStandardMips;
  u8 NumPackedMips;
  u32 NumTilesForPackedMips;
  u32 StartTileIndexInOverallResource;
} D3D12_PACKED_MIP_INFO;

typedef struct D3D12_SUBRESOURCE_DATA {
  const void *pData;
  i64 RowPitch;
  i64 SlicePitch;
} D3D12_SUBRESOURCE_DATA;

typedef struct D3D12_MEMCPY_DEST {
  void *pData;
  u64 RowPitch;
  u64 SlicePitch;
} D3D12_MEMCPY_DEST;

// IUnknown
typedef struct IUnknown_vtable {
  // IUnknown
  i32(__stdcall *QueryInterface)(IUnknown *self, const GUID *guid, void **out_object);
  u32(__stdcall *AddRef)(IUnknown *self);
  u32(__stdcall *Release)(IUnknown *self);
} IUnknown_vtable;

struct IUnknown {
  const IUnknown_vtable *vtbl;
};

#define IUnknown_QueryInterface(self, ...) ((self)->vtbl->QueryInterface(self, __VA_ARGS__))
#define IUnknown_AddRef(self, ...) ((self)->vtbl->AddRef(self, __VA_ARGS__))
#define IUnknown_Release(self, ...) ((self)->vtbl->Release(self, __VA_ARGS__))

// ID3DBlob
typedef struct ID3DBlob_vtable {
  // IUnknown
  i32(__stdcall *QueryInterface)(ID3DBlob *self, const GUID *guid, void **out_object);
  u32(__stdcall *AddRef)(ID3DBlob *self);
  u32(__stdcall *Release)(ID3DBlob *self);
  // ID3DBlob
  void *(__stdcall *GetBufferPointer)(ID3DBlob *self);
  u64(__stdcall *GetBufferSize)(ID3DBlob *self);
} ID3DBlob_vtable;

struct ID3DBlob {
  const ID3DBlob_vtable *vtbl;
};

#define ID3DBlob_QueryInterface(self, ...) ((self)->vtbl->QueryInterface(self, __VA_ARGS__))
#define ID3DBlob_AddRef(self, ...) ((self)->vtbl->AddRef(self, __VA_ARGS__))
#define ID3DBlob_Release(self, ...) ((self)->vtbl->Release(self, __VA_ARGS__))
#define ID3DBlob_GetBufferPointer(self, ...) ((self)->vtbl->GetBufferPointer(self, __VA_ARGS__))
#define ID3DBlob_GetBufferSize(self, ...) ((self)->vtbl->GetBufferSize(self, __VA_ARGS__))

// ID3D12Object
typedef struct ID3D12Object_vtable {
  // IUnknown
  i32(__stdcall *QueryInterface)(ID3D12Object *self, const GUID *guid, void **out_object);
  u32(__stdcall *AddRef)(ID3D12Object *self);
  u32(__stdcall *Release)(ID3D12Object *self);
  // ID3D12Object
  i32(__stdcall *GetPrivateData)(ID3D12Object *self, const GUID *guid, u32 *out_data_size,
                                 void *out_data);
  i32(__stdcall *SetPrivateData)(ID3D12Object *self, const GUID *guid, u32 data_size,
                                 const void *data);
  i32(__stdcall *SetPrivateDataInterface)(ID3D12Object *self, const GUID *guid,
                                          const IUnknown *data);
  i32(__stdcall *SetName)(ID3D12Object *self, const u16 *name);
} ID3D12Object_vtable;

struct ID3D12Object {
  const ID3D12Object_vtable *vtbl;
};

#define ID3D12Object_QueryInterface(self, ...) ((self)->vtbl->QueryInterface(self, __VA_ARGS__))
#define ID3D12Object_AddRef(self, ...) ((self)->vtbl->AddRef(self, __VA_ARGS__))
#define ID3D12Object_Release(self, ...) ((self)->vtbl->Release(self, __VA_ARGS__))
#define ID3D12Object_GetPrivateData(self, ...) ((self)->vtbl->GetPrivateData(self, __VA_ARGS__))
#define ID3D12Object_SetPrivateData(self, ...) ((self)->vtbl->SetPrivateData(self, __VA_ARGS__))
#define ID3D12Object_SetPrivateDataInterface(self, ...)                                            \
  ((self)->vtbl->SetPrivateDataInterface(self, __VA_ARGS__))
#define ID3D12Object_SetName(self, ...) ((self)->vtbl->SetName(self, __VA_ARGS__))

// ID3D12DeviceChild
typedef struct ID3D12DeviceChild_vtable {
  // IUnknown
  i32(__stdcall *QueryInterface)(ID3D12DeviceChild *self, const GUID *guid, void **out_object);
  u32(__stdcall *AddRef)(ID3D12DeviceChild *self);
  u32(__stdcall *Release)(ID3D12DeviceChild *self);
  // ID3D12Object
  i32(__stdcall *GetPrivateData)(ID3D12DeviceChild *self, const GUID *guid, u32 *out_data_size,
                                 void *out_data);
  i32(__stdcall *SetPrivateData)(ID3D12DeviceChild *self, const GUID *guid, u32 data_size,
                                 const void *data);
  i32(__stdcall *SetPrivateDataInterface)(ID3D12DeviceChild *self, const GUID *guid,
                                          const IUnknown *data);
  i32(__stdcall *SetName)(ID3D12DeviceChild *self, const u16 *name);
  // ID3D12DeviceChild
  i32(__stdcall *GetDevice)(ID3D12DeviceChild *self, const GUID *guid, void **out_device);
} ID3D12DeviceChild_vtable;

struct ID3D12DeviceChild {
  const ID3D12DeviceChild_vtable *vtbl;
};

#define ID3D12DeviceChild_QueryInterface(self, ...)                                                \
  ((self)->vtbl->QueryInterface(self, __VA_ARGS__))
#define ID3D12DeviceChild_AddRef(self, ...) ((self)->vtbl->AddRef(self, __VA_ARGS__))
#define ID3D12DeviceChild_Release(self, ...) ((self)->vtbl->Release(self, __VA_ARGS__))
#define ID3D12DeviceChild_GetPrivateData(self, ...)                                                \
  ((self)->vtbl->GetPrivateData(self, __VA_ARGS__))
#define ID3D12DeviceChild_SetPrivateData(self, ...)                                                \
  ((self)->vtbl->SetPrivateData(self, __VA_ARGS__))
#define ID3D12DeviceChild_SetPrivateDataInterface(self, ...)                                       \
  ((self)->vtbl->SetPrivateDataInterface(self, __VA_ARGS__))
#define ID3D12DeviceChild_SetName(self, ...) ((self)->vtbl->SetName(self, __VA_ARGS__))
#define ID3D12DeviceChild_GetDevice(self, ...) ((self)->vtbl->GetDevice(self, __VA_ARGS__))

// ID3D12RootSignature
typedef struct ID3D12RootSignature_vtable {
  // IUnknown
  i32(__stdcall *QueryInterface)(ID3D12RootSignature *self, const GUID *guid, void **out_object);
  u32(__stdcall *AddRef)(ID3D12RootSignature *self);
  u32(__stdcall *Release)(ID3D12RootSignature *self);
  // ID3D12Object
  i32(__stdcall *GetPrivateData)(ID3D12RootSignature *self, const GUID *guid, u32 *out_data_size,
                                 void *out_data);
  i32(__stdcall *SetPrivateData)(ID3D12RootSignature *self, const GUID *guid, u32 data_size,
                                 const void *data);
  i32(__stdcall *SetPrivateDataInterface)(ID3D12RootSignature *self, const GUID *guid,
                                          const IUnknown *data);
  i32(__stdcall *SetName)(ID3D12RootSignature *self, const u16 *name);
  // ID3D12DeviceChild
  i32(__stdcall *GetDevice)(ID3D12RootSignature *self, const GUID *guid, void **out_device);
} ID3D12RootSignature_vtable;

struct ID3D12RootSignature {
  const ID3D12RootSignature_vtable *vtbl;
};

#define ID3D12RootSignature_QueryInterface(self, ...)                                              \
  ((self)->vtbl->QueryInterface(self, __VA_ARGS__))
#define ID3D12RootSignature_AddRef(self, ...) ((self)->vtbl->AddRef(self, __VA_ARGS__))
#define ID3D12RootSignature_Release(self, ...) ((self)->vtbl->Release(self, __VA_ARGS__))
#define ID3D12RootSignature_GetPrivateData(self, ...)                                              \
  ((self)->vtbl->GetPrivateData(self, __VA_ARGS__))
#define ID3D12RootSignature_SetPrivateData(self, ...)                                              \
  ((self)->vtbl->SetPrivateData(self, __VA_ARGS__))
#define ID3D12RootSignature_SetPrivateDataInterface(self, ...)                                     \
  ((self)->vtbl->SetPrivateDataInterface(self, __VA_ARGS__))
#define ID3D12RootSignature_SetName(self, ...) ((self)->vtbl->SetName(self, __VA_ARGS__))
#define ID3D12RootSignature_GetDevice(self, ...) ((self)->vtbl->GetDevice(self, __VA_ARGS__))

// ID3D12Pageable
typedef struct ID3D12Pageable_vtable {
  // IUnknown
  i32(__stdcall *QueryInterface)(ID3D12Pageable *self, const GUID *guid, void **out_object);
  u32(__stdcall *AddRef)(ID3D12Pageable *self);
  u32(__stdcall *Release)(ID3D12Pageable *self);
  // ID3D12Object
  i32(__stdcall *GetPrivateData)(ID3D12Pageable *self, const GUID *guid, u32 *out_data_size,
                                 void *out_data);
  i32(__stdcall *SetPrivateData)(ID3D12Pageable *self, const GUID *guid, u32 data_size,
                                 const void *data);
  i32(__stdcall *SetPrivateDataInterface)(ID3D12Pageable *self, const GUID *guid,
                                          const IUnknown *data);
  i32(__stdcall *SetName)(ID3D12Pageable *self, const u16 *name);
  // ID3D12DeviceChild
  i32(__stdcall *GetDevice)(ID3D12Pageable *self, const GUID *guid, void **out_device);
} ID3D12Pageable_vtable;

struct ID3D12Pageable {
  const ID3D12Pageable_vtable *vtbl;
};

#define ID3D12Pageable_QueryInterface(self, ...) ((self)->vtbl->QueryInterface(self, __VA_ARGS__))
#define ID3D12Pageable_AddRef(self, ...) ((self)->vtbl->AddRef(self, __VA_ARGS__))
#define ID3D12Pageable_Release(self, ...) ((self)->vtbl->Release(self, __VA_ARGS__))
#define ID3D12Pageable_GetPrivateData(self, ...) ((self)->vtbl->GetPrivateData(self, __VA_ARGS__))
#define ID3D12Pageable_SetPrivateData(self, ...) ((self)->vtbl->SetPrivateData(self, __VA_ARGS__))
#define ID3D12Pageable_SetPrivateDataInterface(self, ...)                                          \
  ((self)->vtbl->SetPrivateDataInterface(self, __VA_ARGS__))
#define ID3D12Pageable_SetName(self, ...) ((self)->vtbl->SetName(self, __VA_ARGS__))
#define ID3D12Pageable_GetDevice(self, ...) ((self)->vtbl->GetDevice(self, __VA_ARGS__))

// ID3D12Heap
typedef struct ID3D12Heap_vtable {
  // IUnknown
  i32(__stdcall *QueryInterface)(ID3D12Heap *self, const GUID *guid, void **out_object);
  u32(__stdcall *AddRef)(ID3D12Heap *self);
  u32(__stdcall *Release)(ID3D12Heap *self);
  // ID3D12Object
  i32(__stdcall *GetPrivateData)(ID3D12Heap *self, const GUID *guid, u32 *out_data_size,
                                 void *out_data);
  i32(__stdcall *SetPrivateData)(ID3D12Heap *self, const GUID *guid, u32 data_size,
                                 const void *data);
  i32(__stdcall *SetPrivateDataInterface)(ID3D12Heap *self, const GUID *guid, const IUnknown *data);
  i32(__stdcall *SetName)(ID3D12Heap *self, const u16 *name);
  // ID3D12DeviceChild
  i32(__stdcall *GetDevice)(ID3D12Heap *self, const GUID *guid, void **out_device);
  // ID3D12Pageable
  // ID3D12Heap
  D3D12_HEAP_DESC *(__stdcall *GetDesc)(ID3D12Heap *self, D3D12_HEAP_DESC *out_heap_desc);
} ID3D12Heap_vtable;

struct ID3D12Heap {
  const ID3D12Heap_vtable *vtbl;
};

#define ID3D12Heap_QueryInterface(self, ...) ((self)->vtbl->QueryInterface(self, __VA_ARGS__))
#define ID3D12Heap_AddRef(self, ...) ((self)->vtbl->AddRef(self, __VA_ARGS__))
#define ID3D12Heap_Release(self, ...) ((self)->vtbl->Release(self, __VA_ARGS__))
#define ID3D12Heap_GetPrivateData(self, ...) ((self)->vtbl->GetPrivateData(self, __VA_ARGS__))
#define ID3D12Heap_SetPrivateData(self, ...) ((self)->vtbl->SetPrivateData(self, __VA_ARGS__))
#define ID3D12Heap_SetPrivateDataInterface(self, ...)                                              \
  ((self)->vtbl->SetPrivateDataInterface(self, __VA_ARGS__))
#define ID3D12Heap_SetName(self, ...) ((self)->vtbl->SetName(self, __VA_ARGS__))
#define ID3D12Heap_GetDevice(self, ...) ((self)->vtbl->GetDevice(self, __VA_ARGS__))
#define ID3D12Heap_GetDesc(self, ...) ((self)->vtbl->GetDesc(self, __VA_ARGS__))

// ID3D12Resource
typedef struct ID3D12Resource_vtable {
  // IUnknown
  i32(__stdcall *QueryInterface)(ID3D12Resource *self, const GUID *guid, void **out_object);
  u32(__stdcall *AddRef)(ID3D12Resource *self);
  u32(__stdcall *Release)(ID3D12Resource *self);
  // ID3D12Object
  i32(__stdcall *GetPrivateData)(ID3D12Resource *self, const GUID *guid, u32 *out_data_size,
                                 void *out_data);
  i32(__stdcall *SetPrivateData)(ID3D12Resource *self, const GUID *guid, u32 data_size,
                                 const void *data);
  i32(__stdcall *SetPrivateDataInterface)(ID3D12Resource *self, const GUID *guid,
                                          const IUnknown *data);
  i32(__stdcall *SetName)(ID3D12Resource *self, const u16 *name);
  // ID3D12DeviceChild
  i32(__stdcall *GetDevice)(ID3D12Resource *self, const GUID *guid, void **out_device);
  // ID3D12Pageable
  // ID3D12Resource
  i32(__stdcall *Map)(ID3D12Resource *self, u32 subresource, const D3D12_RANGE *read_range,
                      void **out_data);
  void(__stdcall *Unmap)(ID3D12Resource *self, u32 subresource, const D3D12_RANGE *written_range);
  D3D12_RESOURCE_DESC *(__stdcall *GetDesc)(ID3D12Resource *self,
                                            D3D12_RESOURCE_DESC *out_resource_desc);
  D3D12_GPU_VIRTUAL_ADDRESS(__stdcall *GetGPUVirtualAddress)
  (ID3D12Resource *self);
  i32(__stdcall *WriteToSubresource)(ID3D12Resource *self, u32 dst_subresource,
                                     const D3D12_BOX *dst_box, const void *src_data,
                                     u32 src_row_pitch, u32 src_depth_pitch);
  i32(__stdcall *ReadFromSubresource)(ID3D12Resource *self, void *dst_data, u32 dst_row_pitch,
                                      u32 dst_depth_pitch, u32 src_subresource,
                                      const D3D12_BOX *src_box);
  i32(__stdcall *GetHeapProperties)(ID3D12Resource *self, D3D12_HEAP_PROPERTIES *out_properties,
                                    D3D12_HEAP_FLAGS *out_flags);
} ID3D12Resource_vtable;

struct ID3D12Resource {
  const ID3D12Resource_vtable *vtbl;
};

#define ID3D12Resource_QueryInterface(self, ...) ((self)->vtbl->QueryInterface(self, __VA_ARGS__))
#define ID3D12Resource_AddRef(self, ...) ((self)->vtbl->AddRef(self, __VA_ARGS__))
#define ID3D12Resource_Release(self, ...) ((self)->vtbl->Release(self, __VA_ARGS__))
#define ID3D12Resource_GetPrivateData(self, ...) ((self)->vtbl->GetPrivateData(self, __VA_ARGS__))
#define ID3D12Resource_SetPrivateData(self, ...) ((self)->vtbl->SetPrivateData(self, __VA_ARGS__))
#define ID3D12Resource_SetPrivateDataInterface(self, ...)                                          \
  ((self)->vtbl->SetPrivateDataInterface(self, __VA_ARGS__))
#define ID3D12Resource_SetName(self, ...) ((self)->vtbl->SetName(self, __VA_ARGS__))
#define ID3D12Resource_GetDevice(self, ...) ((self)->vtbl->GetDevice(self, __VA_ARGS__))
#define ID3D12Resource_Map(self, ...) ((self)->vtbl->Map(self, __VA_ARGS__))
#define ID3D12Resource_Unmap(self, ...) ((self)->vtbl->Unmap(self, __VA_ARGS__))
#define ID3D12Resource_GetDesc(self, ...) ((self)->vtbl->GetDesc(self, __VA_ARGS__))
#define ID3D12Resource_GetGPUVirtualAddress(self, ...)                                             \
  ((self)->vtbl->GetGPUVirtualAddress(self, __VA_ARGS__))
#define ID3D12Resource_WriteToSubresource(self, ...)                                               \
  ((self)->vtbl->WriteToSubresource(self, __VA_ARGS__))
#define ID3D12Resource_ReadFromSubresource(self, ...)                                              \
  ((self)->vtbl->ReadFromSubresource(self, __VA_ARGS__))
#define ID3D12Resource_GetHeapProperties(self, ...)                                                \
  ((self)->vtbl->GetHeapProperties(self, __VA_ARGS__))

// ID3D12CommandAllocator
typedef struct ID3D12CommandAllocator_vtable {
  // IUnknown
  i32(__stdcall *QueryInterface)(ID3D12CommandAllocator *self, const GUID *guid, void **out_object);
  u32(__stdcall *AddRef)(ID3D12CommandAllocator *self);
  u32(__stdcall *Release)(ID3D12CommandAllocator *self);
  // ID3D12Object
  i32(__stdcall *GetPrivateData)(ID3D12CommandAllocator *self, const GUID *guid, u32 *out_data_size,
                                 void *out_data);
  i32(__stdcall *SetPrivateData)(ID3D12CommandAllocator *self, const GUID *guid, u32 data_size,
                                 const void *data);
  i32(__stdcall *SetPrivateDataInterface)(ID3D12CommandAllocator *self, const GUID *guid,
                                          const IUnknown *data);
  i32(__stdcall *SetName)(ID3D12CommandAllocator *self, const u16 *name);
  // ID3D12DeviceChild
  i32(__stdcall *GetDevice)(ID3D12CommandAllocator *self, const GUID *guid, void **out_device);
  // ID3D12Pageable
  // ID3D12CommandAllocator
  i32(__stdcall *Reset)(ID3D12CommandAllocator *self);
} ID3D12CommandAllocator_vtable;

struct ID3D12CommandAllocator {
  const ID3D12CommandAllocator_vtable *vtbl;
};

#define ID3D12CommandAllocator_QueryInterface(self, ...)                                           \
  ((self)->vtbl->QueryInterface(self, __VA_ARGS__))
#define ID3D12CommandAllocator_AddRef(self, ...) ((self)->vtbl->AddRef(self, __VA_ARGS__))
#define ID3D12CommandAllocator_Release(self, ...) ((self)->vtbl->Release(self, __VA_ARGS__))
#define ID3D12CommandAllocator_GetPrivateData(self, ...)                                           \
  ((self)->vtbl->GetPrivateData(self, __VA_ARGS__))
#define ID3D12CommandAllocator_SetPrivateData(self, ...)                                           \
  ((self)->vtbl->SetPrivateData(self, __VA_ARGS__))
#define ID3D12CommandAllocator_SetPrivateDataInterface(self, ...)                                  \
  ((self)->vtbl->SetPrivateDataInterface(self, __VA_ARGS__))
#define ID3D12CommandAllocator_SetName(self, ...) ((self)->vtbl->SetName(self, __VA_ARGS__))
#define ID3D12CommandAllocator_GetDevice(self, ...) ((self)->vtbl->GetDevice(self, __VA_ARGS__))
#define ID3D12CommandAllocator_Reset(self, ...) ((self)->vtbl->Reset(self, __VA_ARGS__))

// ID3D12Fence
typedef struct ID3D12Fence_vtable {
  // IUnknown
  i32(__stdcall *QueryInterface)(ID3D12Fence *self, const GUID *guid, void **out_object);
  u32(__stdcall *AddRef)(ID3D12Fence *self);
  u32(__stdcall *Release)(ID3D12Fence *self);
  // ID3D12Object
  i32(__stdcall *GetPrivateData)(ID3D12Fence *self, const GUID *guid, u32 *out_data_size,
                                 void *out_data);
  i32(__stdcall *SetPrivateData)(ID3D12Fence *self, const GUID *guid, u32 data_size,
                                 const void *data);
  i32(__stdcall *SetPrivateDataInterface)(ID3D12Fence *self, const GUID *guid,
                                          const IUnknown *data);
  i32(__stdcall *SetName)(ID3D12Fence *self, const u16 *name);
  // ID3D12DeviceChild
  i32(__stdcall *GetDevice)(ID3D12Fence *self, const GUID *guid, void **out_device);
  // ID3D12Pageable
  // ID3D12Fence
  u64(__stdcall *GetCompletedValue)(ID3D12Fence *self);
  i32(__stdcall *SetEventOnCompletion)(ID3D12Fence *self, u64 value, void *event);
  i32(__stdcall *Signal)(ID3D12Fence *self, u64 value);
} ID3D12Fence_vtable;

struct ID3D12Fence {
  const ID3D12Fence_vtable *vtbl;
};

#define ID3D12Fence_QueryInterface(self, ...) ((self)->vtbl->QueryInterface(self, __VA_ARGS__))
#define ID3D12Fence_AddRef(self, ...) ((self)->vtbl->AddRef(self, __VA_ARGS__))
#define ID3D12Fence_Release(self, ...) ((self)->vtbl->Release(self, __VA_ARGS__))
#define ID3D12Fence_GetPrivateData(self, ...) ((self)->vtbl->GetPrivateData(self, __VA_ARGS__))
#define ID3D12Fence_SetPrivateData(self, ...) ((self)->vtbl->SetPrivateData(self, __VA_ARGS__))
#define ID3D12Fence_SetPrivateDataInterface(self, ...)                                             \
  ((self)->vtbl->SetPrivateDataInterface(self, __VA_ARGS__))
#define ID3D12Fence_SetName(self, ...) ((self)->vtbl->SetName(self, __VA_ARGS__))
#define ID3D12Fence_GetDevice(self, ...) ((self)->vtbl->GetDevice(self, __VA_ARGS__))
#define ID3D12Fence_GetCompletedValue(self, ...)                                                   \
  ((self)->vtbl->GetCompletedValue(self, __VA_ARGS__))
#define ID3D12Fence_SetEventOnCompletion(self, ...)                                                \
  ((self)->vtbl->SetEventOnCompletion(self, __VA_ARGS__))
#define ID3D12Fence_Signal(self, ...) ((self)->vtbl->Signal(self, __VA_ARGS__))

// ID3D12PipelineState
typedef struct ID3D12PipelineState_vtable {
  // IUnknown
  i32(__stdcall *QueryInterface)(ID3D12PipelineState *self, const GUID *guid, void **out_object);
  u32(__stdcall *AddRef)(ID3D12PipelineState *self);
  u32(__stdcall *Release)(ID3D12PipelineState *self);
  // ID3D12Object
  i32(__stdcall *GetPrivateData)(ID3D12PipelineState *self, const GUID *guid, u32 *out_data_size,
                                 void *out_data);
  i32(__stdcall *SetPrivateData)(ID3D12PipelineState *self, const GUID *guid, u32 data_size,
                                 const void *data);
  i32(__stdcall *SetPrivateDataInterface)(ID3D12PipelineState *self, const GUID *guid,
                                          const IUnknown *data);
  i32(__stdcall *SetName)(ID3D12PipelineState *self, const u16 *name);
  // ID3D12DeviceChild
  i32(__stdcall *GetDevice)(ID3D12PipelineState *self, const GUID *guid, void **out_device);
  // ID3D12Pageable
  // ID3D12PipelineState
  i32(__stdcall *GetCachedBlob)(ID3D12PipelineState *self, ID3DBlob **out_blob);
} ID3D12PipelineState_vtable;

struct ID3D12PipelineState {
  const ID3D12PipelineState_vtable *vtbl;
};

#define ID3D12PipelineState_QueryInterface(self, ...)                                              \
  ((self)->vtbl->QueryInterface(self, __VA_ARGS__))
#define ID3D12PipelineState_AddRef(self, ...) ((self)->vtbl->AddRef(self, __VA_ARGS__))
#define ID3D12PipelineState_Release(self, ...) ((self)->vtbl->Release(self, __VA_ARGS__))
#define ID3D12PipelineState_GetPrivateData(self, ...)                                              \
  ((self)->vtbl->GetPrivateData(self, __VA_ARGS__))
#define ID3D12PipelineState_SetPrivateData(self, ...)                                              \
  ((self)->vtbl->SetPrivateData(self, __VA_ARGS__))
#define ID3D12PipelineState_SetPrivateDataInterface(self, ...)                                     \
  ((self)->vtbl->SetPrivateDataInterface(self, __VA_ARGS__))
#define ID3D12PipelineState_SetName(self, ...) ((self)->vtbl->SetName(self, __VA_ARGS__))
#define ID3D12PipelineState_GetDevice(self, ...) ((self)->vtbl->GetDevice(self, __VA_ARGS__))
#define ID3D12PipelineState_GetCachedBlob(self, ...)                                               \
  ((self)->vtbl->GetCachedBlob(self, __VA_ARGS__))

// ID3D12DescriptorHeap
typedef struct ID3D12DescriptorHeap_vtable {
  // IUnknown
  i32(__stdcall *QueryInterface)(ID3D12DescriptorHeap *self, const GUID *guid, void **out_object);
  u32(__stdcall *AddRef)(ID3D12DescriptorHeap *self);
  u32(__stdcall *Release)(ID3D12DescriptorHeap *self);
  // ID3D12Object
  i32(__stdcall *GetPrivateData)(ID3D12DescriptorHeap *self, const GUID *guid, u32 *out_data_size,
                                 void *out_data);
  i32(__stdcall *SetPrivateData)(ID3D12DescriptorHeap *self, const GUID *guid, u32 data_size,
                                 const void *data);
  i32(__stdcall *SetPrivateDataInterface)(ID3D12DescriptorHeap *self, const GUID *guid,
                                          const IUnknown *data);
  i32(__stdcall *SetName)(ID3D12DescriptorHeap *self, const u16 *name);
  // ID3D12DeviceChild
  i32(__stdcall *GetDevice)(ID3D12DescriptorHeap *self, const GUID *guid, void **out_device);
  // ID3D12Pageable
  // ID3D12DescriptorHeap
  D3D12_DESCRIPTOR_HEAP_DESC *(__stdcall *GetDesc)(ID3D12DescriptorHeap *self,
                                                   D3D12_DESCRIPTOR_HEAP_DESC *out_desc);
  D3D12_CPU_DESCRIPTOR_HANDLE *(__stdcall *GetCPUDescriptorHandleForHeapStart)(
      ID3D12DescriptorHeap *self, D3D12_CPU_DESCRIPTOR_HANDLE *out_handle);
  D3D12_GPU_DESCRIPTOR_HANDLE *(__stdcall *GetGPUDescriptorHandleForHeapStart)(
      ID3D12DescriptorHeap *self, D3D12_GPU_DESCRIPTOR_HANDLE *out_handle);
} ID3D12DescriptorHeap_vtable;

struct ID3D12DescriptorHeap {
  const ID3D12DescriptorHeap_vtable *vtbl;
};

#define ID3D12DescriptorHeap_QueryInterface(self, ...)                                             \
  ((self)->vtbl->QueryInterface(self, __VA_ARGS__))
#define ID3D12DescriptorHeap_AddRef(self, ...) ((self)->vtbl->AddRef(self, __VA_ARGS__))
#define ID3D12DescriptorHeap_Release(self, ...) ((self)->vtbl->Release(self, __VA_ARGS__))
#define ID3D12DescriptorHeap_GetPrivateData(self, ...)                                             \
  ((self)->vtbl->GetPrivateData(self, __VA_ARGS__))
#define ID3D12DescriptorHeap_SetPrivateData(self, ...)                                             \
  ((self)->vtbl->SetPrivateData(self, __VA_ARGS__))
#define ID3D12DescriptorHeap_SetPrivateDataInterface(self, ...)                                    \
  ((self)->vtbl->SetPrivateDataInterface(self, __VA_ARGS__))
#define ID3D12DescriptorHeap_SetName(self, ...) ((self)->vtbl->SetName(self, __VA_ARGS__))
#define ID3D12DescriptorHeap_GetDevice(self, ...) ((self)->vtbl->GetDevice(self, __VA_ARGS__))
#define ID3D12DescriptorHeap_GetDesc(self, ...) ((self)->vtbl->GetDesc(self, __VA_ARGS__))
#define ID3D12DescriptorHeap_GetCPUDescriptorHandleForHeapStart(self, ...)                         \
  ((self)->vtbl->GetCPUDescriptorHandleForHeapStart(self, __VA_ARGS__))
#define ID3D12DescriptorHeap_GetGPUDescriptorHandleForHeapStart(self, ...)                         \
  ((self)->vtbl->GetGPUDescriptorHandleForHeapStart(self, __VA_ARGS__))

// ID3D12QueryHeap
typedef struct ID3D12QueryHeap_vtable {
  // IUnknown
  i32(__stdcall *QueryInterface)(ID3D12QueryHeap *self, const GUID *guid, void **out_object);
  u32(__stdcall *AddRef)(ID3D12QueryHeap *self);
  u32(__stdcall *Release)(ID3D12QueryHeap *self);
  // ID3D12Object
  i32(__stdcall *GetPrivateData)(ID3D12QueryHeap *self, const GUID *guid, u32 *out_data_size,
                                 void *out_data);
  i32(__stdcall *SetPrivateData)(ID3D12QueryHeap *self, const GUID *guid, u32 data_size,
                                 const void *data);
  i32(__stdcall *SetPrivateDataInterface)(ID3D12QueryHeap *self, const GUID *guid,
                                          const IUnknown *data);
  i32(__stdcall *SetName)(ID3D12QueryHeap *self, const u16 *name);
  // ID3D12DeviceChild
  i32(__stdcall *GetDevice)(ID3D12QueryHeap *self, const GUID *guid, void **out_device);
  // ID3D12Pageable
  // ID3D12QueryHeap
} ID3D12QueryHeap_vtable;

struct ID3D12QueryHeap {
  const ID3D12QueryHeap_vtable *vtbl;
};

#define ID3D12QueryHeap_QueryInterface(self, ...) ((self)->vtbl->QueryInterface(self, __VA_ARGS__))
#define ID3D12QueryHeap_AddRef(self, ...) ((self)->vtbl->AddRef(self, __VA_ARGS__))
#define ID3D12QueryHeap_Release(self, ...) ((self)->vtbl->Release(self, __VA_ARGS__))
#define ID3D12QueryHeap_GetPrivateData(self, ...) ((self)->vtbl->GetPrivateData(self, __VA_ARGS__))
#define ID3D12QueryHeap_SetPrivateData(self, ...) ((self)->vtbl->SetPrivateData(self, __VA_ARGS__))
#define ID3D12QueryHeap_SetPrivateDataInterface(self, ...)                                         \
  ((self)->vtbl->SetPrivateDataInterface(self, __VA_ARGS__))
#define ID3D12QueryHeap_SetName(self, ...) ((self)->vtbl->SetName(self, __VA_ARGS__))
#define ID3D12QueryHeap_GetDevice(self, ...) ((self)->vtbl->GetDevice(self, __VA_ARGS__))

// ID3D12CommandSignature
typedef struct ID3D12CommandSignature_vtable {
  // IUnknown
  i32(__stdcall *QueryInterface)(ID3D12CommandSignature *self, const GUID *guid, void **out_object);
  u32(__stdcall *AddRef)(ID3D12CommandSignature *self);
  u32(__stdcall *Release)(ID3D12CommandSignature *self);
  // ID3D12Object
  i32(__stdcall *GetPrivateData)(ID3D12CommandSignature *self, const GUID *guid, u32 *out_data_size,
                                 void *out_data);
  i32(__stdcall *SetPrivateData)(ID3D12CommandSignature *self, const GUID *guid, u32 data_size,
                                 const void *data);
  i32(__stdcall *SetPrivateDataInterface)(ID3D12CommandSignature *self, const GUID *guid,
                                          const IUnknown *data);
  i32(__stdcall *SetName)(ID3D12CommandSignature *self, const u16 *name);
  // ID3D12DeviceChild
  i32(__stdcall *GetDevice)(ID3D12CommandSignature *self, const GUID *guid, void **out_device);
  // ID3D12Pageable
  // ID3D12CommandSignature
} ID3D12CommandSignature_vtable;

struct ID3D12CommandSignature {
  const ID3D12CommandSignature_vtable *vtbl;
};

#define ID3D12CommandSignature_QueryInterface(self, ...)                                           \
  ((self)->vtbl->QueryInterface(self, __VA_ARGS__))
#define ID3D12CommandSignature_AddRef(self, ...) ((self)->vtbl->AddRef(self, __VA_ARGS__))
#define ID3D12CommandSignature_Release(self, ...) ((self)->vtbl->Release(self, __VA_ARGS__))
#define ID3D12CommandSignature_GetPrivateData(self, ...)                                           \
  ((self)->vtbl->GetPrivateData(self, __VA_ARGS__))
#define ID3D12CommandSignature_SetPrivateData(self, ...)                                           \
  ((self)->vtbl->SetPrivateData(self, __VA_ARGS__))
#define ID3D12CommandSignature_SetPrivateDataInterface(self, ...)                                  \
  ((self)->vtbl->SetPrivateDataInterface(self, __VA_ARGS__))
#define ID3D12CommandSignature_SetName(self, ...) ((self)->vtbl->SetName(self, __VA_ARGS__))
#define ID3D12CommandSignature_GetDevice(self, ...) ((self)->vtbl->GetDevice(self, __VA_ARGS__))

// ID3D12CommandList
typedef struct ID3D12CommandList_vtable {
  // IUnknown
  i32(__stdcall *QueryInterface)(ID3D12CommandList *self, const GUID *guid, void **out_object);
  u32(__stdcall *AddRef)(ID3D12CommandList *self);
  u32(__stdcall *Release)(ID3D12CommandList *self);
  // ID3D12Object
  i32(__stdcall *GetPrivateData)(ID3D12CommandList *self, const GUID *guid, u32 *out_data_size,
                                 void *out_data);
  i32(__stdcall *SetPrivateData)(ID3D12CommandList *self, const GUID *guid, u32 data_size,
                                 const void *data);
  i32(__stdcall *SetPrivateDataInterface)(ID3D12CommandList *self, const GUID *guid,
                                          const IUnknown *data);
  i32(__stdcall *SetName)(ID3D12CommandList *self, const u16 *name);
  // ID3D12DeviceChild
  i32(__stdcall *GetDevice)(ID3D12CommandList *self, const GUID *guid, void **out_device);
  // ID3D12CommandList
  D3D12_COMMAND_LIST_TYPE(__stdcall *GetType)(ID3D12CommandList *self);
} ID3D12CommandList_vtable;

struct ID3D12CommandList {
  const ID3D12CommandList_vtable *vtbl;
};

#define ID3D12CommandList_QueryInterface(self, ...)                                                \
  ((self)->vtbl->QueryInterface(self, __VA_ARGS__))
#define ID3D12CommandList_AddRef(self, ...) ((self)->vtbl->AddRef(self, __VA_ARGS__))
#define ID3D12CommandList_Release(self, ...) ((self)->vtbl->Release(self, __VA_ARGS__))
#define ID3D12CommandList_GetPrivateData(self, ...)                                                \
  ((self)->vtbl->GetPrivateData(self, __VA_ARGS__))
#define ID3D12CommandList_SetPrivateData(self, ...)                                                \
  ((self)->vtbl->SetPrivateData(self, __VA_ARGS__))
#define ID3D12CommandList_SetPrivateDataInterface(self, ...)                                       \
  ((self)->vtbl->SetPrivateDataInterface(self, __VA_ARGS__))
#define ID3D12CommandList_SetName(self, ...) ((self)->vtbl->SetName(self, __VA_ARGS__))
#define ID3D12CommandList_GetDevice(self, ...) ((self)->vtbl->GetDevice(self, __VA_ARGS__))
#define ID3D12CommandList_GetType(self, ...) ((self)->vtbl->GetType(self, __VA_ARGS__))

// ID3D12GraphicsCommandList
typedef struct ID3D12GraphicsCommandList_vtable {
  // IUnknown
  i32(__stdcall *QueryInterface)(ID3D12GraphicsCommandList *self, const GUID *guid,
                                 void **out_object);
  u32(__stdcall *AddRef)(ID3D12GraphicsCommandList *self);
  u32(__stdcall *Release)(ID3D12GraphicsCommandList *self);
  // ID3D12Object
  i32(__stdcall *GetPrivateData)(ID3D12GraphicsCommandList *self, const GUID *guid,
                                 u32 *out_data_size, void *out_data);
  i32(__stdcall *SetPrivateData)(ID3D12GraphicsCommandList *self, const GUID *guid, u32 data_size,
                                 const void *data);
  i32(__stdcall *SetPrivateDataInterface)(ID3D12GraphicsCommandList *self, const GUID *guid,
                                          const IUnknown *data);
  i32(__stdcall *SetName)(ID3D12GraphicsCommandList *self, const u16 *name);
  // ID3D12DeviceChild
  i32(__stdcall *GetDevice)(ID3D12GraphicsCommandList *self, const GUID *guid, void **out_device);
  // ID3D12CommandList
  D3D12_COMMAND_LIST_TYPE(__stdcall *GetType)(ID3D12GraphicsCommandList *self);
  // ID3D12GraphicsCommandList
  i32(__stdcall *Close)(ID3D12GraphicsCommandList *self);
  i32(__stdcall *Reset)(ID3D12GraphicsCommandList *self, ID3D12CommandAllocator *allocator,
                        ID3D12PipelineState *initial_state);
  void(__stdcall *ClearState)(ID3D12GraphicsCommandList *self, ID3D12PipelineState *pipeline_state);
  void(__stdcall *DrawInstanced)(ID3D12GraphicsCommandList *self, u32 vertex_count_per_instance,
                                 u32 instance_count, u32 start_vertex_location,
                                 u32 start_instance_location);
  void(__stdcall *DrawIndexedInstanced)(ID3D12GraphicsCommandList *self,
                                        u32 index_count_per_instance, u32 instance_count,
                                        u32 start_index_location, i32 base_vertex_location,
                                        u32 start_instance_location);
  void(__stdcall *Dispatch)(ID3D12GraphicsCommandList *self, u32 thread_group_count_x,
                            u32 thread_group_count_y, u32 thread_group_count_z);
  void(__stdcall *CopyBufferRegion)(ID3D12GraphicsCommandList *self, ID3D12Resource *dst_buffer,
                                    u64 dst_offset, ID3D12Resource *src_buffer, u64 src_offset,
                                    u64 num_bytes);
  void(__stdcall *CopyTextureRegion)(ID3D12GraphicsCommandList *self,
                                     const D3D12_TEXTURE_COPY_LOCATION *dst, u32 dst_x, u32 dst_y,
                                     u32 dst_z, const D3D12_TEXTURE_COPY_LOCATION *src,
                                     const D3D12_BOX *src_box);
  void(__stdcall *CopyResource)(ID3D12GraphicsCommandList *self, ID3D12Resource *dst,
                                ID3D12Resource *src);
  void(__stdcall *CopyTiles)(ID3D12GraphicsCommandList *self, ID3D12Resource *tiled_resource,
                             const D3D12_TILED_RESOURCE_COORDINATE *tile_region_start_coordinate,
                             const D3D12_TILE_REGION_SIZE *tile_region_size, ID3D12Resource *buffer,
                             u64 buffer_start_offset_in_bytes, D3D12_TILE_COPY_FLAGS flags);
  void(__stdcall *ResolveSubresource)(ID3D12GraphicsCommandList *self, ID3D12Resource *dst_resource,
                                      u32 dst_subresource, ID3D12Resource *src_resource,
                                      u32 src_subresource, DXGI_FORMAT format);
  void(__stdcall *IASetPrimitiveTopology)(ID3D12GraphicsCommandList *self,
                                          D3D12_PRIMITIVE_TOPOLOGY primitive_topology);
  void(__stdcall *RSSetViewports)(ID3D12GraphicsCommandList *self, u32 num_viewports,
                                  const D3D12_VIEWPORT *viewports);
  void(__stdcall *RSSetScissorRects)(ID3D12GraphicsCommandList *self, u32 num_rects,
                                     const D3D12_RECT *rects);
  void(__stdcall *OMSetBlendFactor)(ID3D12GraphicsCommandList *self, const f32 blend_factor[4]);
  void(__stdcall *OMSetStencilRef)(ID3D12GraphicsCommandList *self, u32 stencil_ref);
  void(__stdcall *SetPipelineState)(ID3D12GraphicsCommandList *self,
                                    ID3D12PipelineState *pipeline_state);
  void(__stdcall *ResourceBarrier)(ID3D12GraphicsCommandList *self, u32 num_barriers,
                                   const D3D12_RESOURCE_BARRIER *barriers);
  void(__stdcall *ExecuteBundle)(ID3D12GraphicsCommandList *self,
                                 ID3D12GraphicsCommandList *command_list);
  void(__stdcall *SetDescriptorHeaps)(ID3D12GraphicsCommandList *self, u32 num_heaps,
                                      ID3D12DescriptorHeap *const *heaps);
  void(__stdcall *SetComputeRootSignature)(ID3D12GraphicsCommandList *self,
                                           ID3D12RootSignature *root_signature);
  void(__stdcall *SetGraphicsRootSignature)(ID3D12GraphicsCommandList *self,
                                            ID3D12RootSignature *root_signature);
  void(__stdcall *SetComputeRootDescriptorTable)(ID3D12GraphicsCommandList *self,
                                                 u32 root_parameter_index,
                                                 D3D12_GPU_DESCRIPTOR_HANDLE base_descriptor);
  void(__stdcall *SetGraphicsRootDescriptorTable)(ID3D12GraphicsCommandList *self,
                                                  u32 root_parameter_index,
                                                  D3D12_GPU_DESCRIPTOR_HANDLE base_descriptor);
  void(__stdcall *SetComputeRoot32BitConstant)(ID3D12GraphicsCommandList *self,
                                               u32 root_parameter_index, u32 src_data,
                                               u32 dest_offset_in_32bit_values);
  void(__stdcall *SetGraphicsRoot32BitConstant)(ID3D12GraphicsCommandList *self,
                                                u32 root_parameter_index, u32 src_data,
                                                u32 dest_offset_in_32bit_values);
  void(__stdcall *SetComputeRoot32BitConstants)(ID3D12GraphicsCommandList *self,
                                                u32 root_parameter_index,
                                                u32 num_32bit_values_to_set, const void *src_data,
                                                u32 dest_offset_in_32bit_values);
  void(__stdcall *SetGraphicsRoot32BitConstants)(ID3D12GraphicsCommandList *self,
                                                 u32 root_parameter_index,
                                                 u32 num_32bit_values_to_set, const void *src_data,
                                                 u32 dest_offset_in_32bit_values);
  void(__stdcall *SetComputeRootConstantBufferView)(ID3D12GraphicsCommandList *self,
                                                    u32 root_parameter_index,
                                                    D3D12_GPU_VIRTUAL_ADDRESS buffer_location);
  void(__stdcall *SetGraphicsRootConstantBufferView)(ID3D12GraphicsCommandList *self,
                                                     u32 root_parameter_index,
                                                     D3D12_GPU_VIRTUAL_ADDRESS buffer_location);
  void(__stdcall *SetComputeRootShaderResourceView)(ID3D12GraphicsCommandList *self,
                                                    u32 root_parameter_index,
                                                    D3D12_GPU_VIRTUAL_ADDRESS buffer_location);
  void(__stdcall *SetGraphicsRootShaderResourceView)(ID3D12GraphicsCommandList *self,
                                                     u32 root_parameter_index,
                                                     D3D12_GPU_VIRTUAL_ADDRESS buffer_location);
  void(__stdcall *SetComputeRootUnorderedAccessView)(ID3D12GraphicsCommandList *self,
                                                     u32 root_parameter_index,
                                                     D3D12_GPU_VIRTUAL_ADDRESS buffer_location);
  void(__stdcall *SetGraphicsRootUnorderedAccessView)(ID3D12GraphicsCommandList *self,
                                                      u32 root_parameter_index,
                                                      D3D12_GPU_VIRTUAL_ADDRESS buffer_location);
  void(__stdcall *IASetIndexBuffer)(ID3D12GraphicsCommandList *self,
                                    const D3D12_INDEX_BUFFER_VIEW *view);
  void(__stdcall *IASetVertexBuffers)(ID3D12GraphicsCommandList *self, u32 start_slot,
                                      u32 num_views, const D3D12_VERTEX_BUFFER_VIEW *views);
  void(__stdcall *SOSetTargets)(ID3D12GraphicsCommandList *self, u32 start_slot, u32 num_views,
                                const D3D12_STREAM_OUTPUT_BUFFER_VIEW *views);
  void(__stdcall *OMSetRenderTargets)(ID3D12GraphicsCommandList *self,
                                      u32 num_render_target_descriptors,
                                      const D3D12_CPU_DESCRIPTOR_HANDLE *render_target_descriptors,
                                      i32 single_handle_to_descriptor_range,
                                      const D3D12_CPU_DESCRIPTOR_HANDLE *depth_stencil_descriptor);
  void(__stdcall *ClearDepthStencilView)(ID3D12GraphicsCommandList *self,
                                         D3D12_CPU_DESCRIPTOR_HANDLE depth_stencil_view,
                                         D3D12_CLEAR_FLAGS clear_flags, f32 depth, u8 stencil,
                                         u32 num_rects, const D3D12_RECT *rects);
  void(__stdcall *ClearRenderTargetView)(ID3D12GraphicsCommandList *self,
                                         D3D12_CPU_DESCRIPTOR_HANDLE render_target_view,
                                         const f32 color_rgba[4], u32 num_rects,
                                         const D3D12_RECT *rects);
  void(__stdcall *ClearUnorderedAccessViewUint)(
      ID3D12GraphicsCommandList *self, D3D12_GPU_DESCRIPTOR_HANDLE view_gpu_handle_in_current_heap,
      D3D12_CPU_DESCRIPTOR_HANDLE view_cpu_handle, ID3D12Resource *resource, const u32 values[4],
      u32 num_rects, const D3D12_RECT *rects);
  void(__stdcall *ClearUnorderedAccessViewFloat)(
      ID3D12GraphicsCommandList *self, D3D12_GPU_DESCRIPTOR_HANDLE view_gpu_handle_in_current_heap,
      D3D12_CPU_DESCRIPTOR_HANDLE view_cpu_handle, ID3D12Resource *resource, const f32 values[4],
      u32 num_rects, const D3D12_RECT *rects);
  void(__stdcall *DiscardResource)(ID3D12GraphicsCommandList *self, ID3D12Resource *resource,
                                   const D3D12_DISCARD_REGION *region);
  void(__stdcall *BeginQuery)(ID3D12GraphicsCommandList *self, ID3D12QueryHeap *query_heap,
                              D3D12_QUERY_TYPE type, u32 index);
  void(__stdcall *EndQuery)(ID3D12GraphicsCommandList *self, ID3D12QueryHeap *query_heap,
                            D3D12_QUERY_TYPE type, u32 index);
  void(__stdcall *ResolveQueryData)(ID3D12GraphicsCommandList *self, ID3D12QueryHeap *query_heap,
                                    D3D12_QUERY_TYPE type, u32 start_index, u32 num_queries,
                                    ID3D12Resource *destination_buffer,
                                    u64 aligned_destination_buffer_offset);
  void(__stdcall *SetPredication)(ID3D12GraphicsCommandList *self, ID3D12Resource *buffer,
                                  u64 aligned_buffer_offset, D3D12_PREDICATION_OP operation);
  void(__stdcall *SetMarker)(ID3D12GraphicsCommandList *self, u32 metadata, const void *data,
                             u32 size);
  void(__stdcall *BeginEvent)(ID3D12GraphicsCommandList *self, u32 metadata, const void *data,
                              u32 size);
  void(__stdcall *EndEvent)(ID3D12GraphicsCommandList *self);
  void(__stdcall *ExecuteIndirect)(ID3D12GraphicsCommandList *self,
                                   ID3D12CommandSignature *command_signature, u32 max_command_count,
                                   ID3D12Resource *argument_buffer, u64 argument_buffer_offset,
                                   ID3D12Resource *count_buffer, u64 count_buffer_offset);
} ID3D12GraphicsCommandList_vtable;

struct ID3D12GraphicsCommandList {
  const ID3D12GraphicsCommandList_vtable *vtbl;
};

#define ID3D12GraphicsCommandList_QueryInterface(self, ...)                                        \
  ((self)->vtbl->QueryInterface(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_AddRef(self, ...) ((self)->vtbl->AddRef(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_Release(self, ...) ((self)->vtbl->Release(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_GetPrivateData(self, ...)                                        \
  ((self)->vtbl->GetPrivateData(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_SetPrivateData(self, ...)                                        \
  ((self)->vtbl->SetPrivateData(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_SetPrivateDataInterface(self, ...)                               \
  ((self)->vtbl->SetPrivateDataInterface(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_SetName(self, ...) ((self)->vtbl->SetName(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_GetDevice(self, ...) ((self)->vtbl->GetDevice(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_GetType(self, ...) ((self)->vtbl->GetType(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_Close(self, ...) ((self)->vtbl->Close(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_Reset(self, ...) ((self)->vtbl->Reset(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_ClearState(self, ...)                                            \
  ((self)->vtbl->ClearState(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_DrawInstanced(self, ...)                                         \
  ((self)->vtbl->DrawInstanced(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_DrawIndexedInstanced(self, ...)                                  \
  ((self)->vtbl->DrawIndexedInstanced(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_Dispatch(self, ...) ((self)->vtbl->Dispatch(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_CopyBufferRegion(self, ...)                                      \
  ((self)->vtbl->CopyBufferRegion(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_CopyTextureRegion(self, ...)                                     \
  ((self)->vtbl->CopyTextureRegion(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_CopyResource(self, ...)                                          \
  ((self)->vtbl->CopyResource(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_CopyTiles(self, ...) ((self)->vtbl->CopyTiles(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_ResolveSubresource(self, ...)                                    \
  ((self)->vtbl->ResolveSubresource(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_IASetPrimitiveTopology(self, ...)                                \
  ((self)->vtbl->IASetPrimitiveTopology(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_RSSetViewports(self, ...)                                        \
  ((self)->vtbl->RSSetViewports(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_RSSetScissorRects(self, ...)                                     \
  ((self)->vtbl->RSSetScissorRects(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_OMSetBlendFactor(self, ...)                                      \
  ((self)->vtbl->OMSetBlendFactor(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_OMSetStencilRef(self, ...)                                       \
  ((self)->vtbl->OMSetStencilRef(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_SetPipelineState(self, ...)                                      \
  ((self)->vtbl->SetPipelineState(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_ResourceBarrier(self, ...)                                       \
  ((self)->vtbl->ResourceBarrier(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_ExecuteBundle(self, ...)                                         \
  ((self)->vtbl->ExecuteBundle(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_SetDescriptorHeaps(self, ...)                                    \
  ((self)->vtbl->SetDescriptorHeaps(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_SetComputeRootSignature(self, ...)                               \
  ((self)->vtbl->SetComputeRootSignature(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_SetGraphicsRootSignature(self, ...)                              \
  ((self)->vtbl->SetGraphicsRootSignature(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_SetComputeRootDescriptorTable(self, ...)                         \
  ((self)->vtbl->SetComputeRootDescriptorTable(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_SetGraphicsRootDescriptorTable(self, ...)                        \
  ((self)->vtbl->SetGraphicsRootDescriptorTable(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_SetComputeRoot32BitConstant(self, ...)                           \
  ((self)->vtbl->SetComputeRoot32BitConstant(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_SetGraphicsRoot32BitConstant(self, ...)                          \
  ((self)->vtbl->SetGraphicsRoot32BitConstant(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_SetComputeRoot32BitConstants(self, ...)                          \
  ((self)->vtbl->SetComputeRoot32BitConstants(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_SetGraphicsRoot32BitConstants(self, ...)                         \
  ((self)->vtbl->SetGraphicsRoot32BitConstants(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_SetComputeRootConstantBufferView(self, ...)                      \
  ((self)->vtbl->SetComputeRootConstantBufferView(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_SetGraphicsRootConstantBufferView(self, ...)                     \
  ((self)->vtbl->SetGraphicsRootConstantBufferView(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_SetComputeRootShaderResourceView(self, ...)                      \
  ((self)->vtbl->SetComputeRootShaderResourceView(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_SetGraphicsRootShaderResourceView(self, ...)                     \
  ((self)->vtbl->SetGraphicsRootShaderResourceView(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_SetComputeRootUnorderedAccessView(self, ...)                     \
  ((self)->vtbl->SetComputeRootUnorderedAccessView(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_SetGraphicsRootUnorderedAccessView(self, ...)                    \
  ((self)->vtbl->SetGraphicsRootUnorderedAccessView(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_IASetIndexBuffer(self, ...)                                      \
  ((self)->vtbl->IASetIndexBuffer(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_IASetVertexBuffers(self, ...)                                    \
  ((self)->vtbl->IASetVertexBuffers(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_SOSetTargets(self, ...)                                          \
  ((self)->vtbl->SOSetTargets(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_OMSetRenderTargets(self, ...)                                    \
  ((self)->vtbl->OMSetRenderTargets(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_ClearDepthStencilView(self, ...)                                 \
  ((self)->vtbl->ClearDepthStencilView(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_ClearRenderTargetView(self, ...)                                 \
  ((self)->vtbl->ClearRenderTargetView(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_ClearUnorderedAccessViewUint(self, ...)                          \
  ((self)->vtbl->ClearUnorderedAccessViewUint(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_ClearUnorderedAccessViewFloat(self, ...)                         \
  ((self)->vtbl->ClearUnorderedAccessViewFloat(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_DiscardResource(self, ...)                                       \
  ((self)->vtbl->DiscardResource(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_BeginQuery(self, ...)                                            \
  ((self)->vtbl->BeginQuery(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_EndQuery(self, ...) ((self)->vtbl->EndQuery(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_ResolveQueryData(self, ...)                                      \
  ((self)->vtbl->ResolveQueryData(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_SetPredication(self, ...)                                        \
  ((self)->vtbl->SetPredication(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_SetMarker(self, ...) ((self)->vtbl->SetMarker(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_BeginEvent(self, ...)                                            \
  ((self)->vtbl->BeginEvent(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_EndEvent(self, ...) ((self)->vtbl->EndEvent(self, __VA_ARGS__))
#define ID3D12GraphicsCommandList_ExecuteIndirect(self, ...)                                       \
  ((self)->vtbl->ExecuteIndirect(self, __VA_ARGS__))

// ID3D12CommandQueue
typedef struct ID3D12CommandQueue_vtable {
  // IUnknown
  i32(__stdcall *QueryInterface)(ID3D12CommandQueue *self, const GUID *guid, void **out_object);
  u32(__stdcall *AddRef)(ID3D12CommandQueue *self);
  u32(__stdcall *Release)(ID3D12CommandQueue *self);
  // ID3D12Object
  i32(__stdcall *GetPrivateData)(ID3D12CommandQueue *self, const GUID *guid, u32 *out_data_size,
                                 void *out_data);
  i32(__stdcall *SetPrivateData)(ID3D12CommandQueue *self, const GUID *guid, u32 data_size,
                                 const void *data);
  i32(__stdcall *SetPrivateDataInterface)(ID3D12CommandQueue *self, const GUID *guid,
                                          const IUnknown *data);
  i32(__stdcall *SetName)(ID3D12CommandQueue *self, const u16 *name);
  // ID3D12DeviceChild
  i32(__stdcall *GetDevice)(ID3D12CommandQueue *self, const GUID *guid, void **out_device);
  // ID3D12Pageable
  // ID3D12CommandQueue
  void(__stdcall *UpdateTileMappings)(
      ID3D12CommandQueue *self, ID3D12Resource *resource, u32 num_resource_regions,
      const D3D12_TILED_RESOURCE_COORDINATE *resource_region_start_coordinates,
      const D3D12_TILE_REGION_SIZE *resource_region_sizes, ID3D12Heap *heap, u32 num_ranges,
      const D3D12_TILE_RANGE_FLAGS *range_flags, const u32 *heap_range_start_offsets,
      const u32 *range_tile_counts, D3D12_TILE_MAPPING_FLAGS flags);
  void(__stdcall *CopyTileMappings)(
      ID3D12CommandQueue *self, ID3D12Resource *dst_resource,
      const D3D12_TILED_RESOURCE_COORDINATE *dst_region_start_coordinate,
      ID3D12Resource *src_resource,
      const D3D12_TILED_RESOURCE_COORDINATE *src_region_start_coordinate,
      const D3D12_TILE_REGION_SIZE *region_size, D3D12_TILE_MAPPING_FLAGS flags);
  void(__stdcall *ExecuteCommandLists)(ID3D12CommandQueue *self, u32 num_command_lists,
                                       ID3D12CommandList *const *command_lists);
  void(__stdcall *SetMarker)(ID3D12CommandQueue *self, u32 metadata, const void *data, u32 size);
  void(__stdcall *BeginEvent)(ID3D12CommandQueue *self, u32 metadata, const void *data, u32 size);
  void(__stdcall *EndEvent)(ID3D12CommandQueue *self);
  i32(__stdcall *Signal)(ID3D12CommandQueue *self, ID3D12Fence *fence, u64 value);
  i32(__stdcall *Wait)(ID3D12CommandQueue *self, ID3D12Fence *fence, u64 value);
  i32(__stdcall *GetTimestampFrequency)(ID3D12CommandQueue *self, u64 *out_frequency);
  i32(__stdcall *GetClockCalibration)(ID3D12CommandQueue *self, u64 *out_gpu_timestamp,
                                      u64 *out_cpu_timestamp);
  D3D12_COMMAND_QUEUE_DESC *(__stdcall *GetDesc)(ID3D12CommandQueue *self,
                                                 D3D12_COMMAND_QUEUE_DESC *out_desc);
} ID3D12CommandQueue_vtable;

struct ID3D12CommandQueue {
  const ID3D12CommandQueue_vtable *vtbl;
};

#define ID3D12CommandQueue_QueryInterface(self, ...)                                               \
  ((self)->vtbl->QueryInterface(self, __VA_ARGS__))
#define ID3D12CommandQueue_AddRef(self, ...) ((self)->vtbl->AddRef(self, __VA_ARGS__))
#define ID3D12CommandQueue_Release(self, ...) ((self)->vtbl->Release(self, __VA_ARGS__))
#define ID3D12CommandQueue_GetPrivateData(self, ...)                                               \
  ((self)->vtbl->GetPrivateData(self, __VA_ARGS__))
#define ID3D12CommandQueue_SetPrivateData(self, ...)                                               \
  ((self)->vtbl->SetPrivateData(self, __VA_ARGS__))
#define ID3D12CommandQueue_SetPrivateDataInterface(self, ...)                                      \
  ((self)->vtbl->SetPrivateDataInterface(self, __VA_ARGS__))
#define ID3D12CommandQueue_SetName(self, ...) ((self)->vtbl->SetName(self, __VA_ARGS__))
#define ID3D12CommandQueue_GetDevice(self, ...) ((self)->vtbl->GetDevice(self, __VA_ARGS__))
#define ID3D12CommandQueue_UpdateTileMappings(self, ...)                                           \
  ((self)->vtbl->UpdateTileMappings(self, __VA_ARGS__))
#define ID3D12CommandQueue_CopyTileMappings(self, ...)                                             \
  ((self)->vtbl->CopyTileMappings(self, __VA_ARGS__))
#define ID3D12CommandQueue_ExecuteCommandLists(self, ...)                                          \
  ((self)->vtbl->ExecuteCommandLists(self, __VA_ARGS__))
#define ID3D12CommandQueue_SetMarker(self, ...) ((self)->vtbl->SetMarker(self, __VA_ARGS__))
#define ID3D12CommandQueue_BeginEvent(self, ...) ((self)->vtbl->BeginEvent(self, __VA_ARGS__))
#define ID3D12CommandQueue_EndEvent(self, ...) ((self)->vtbl->EndEvent(self, __VA_ARGS__))
#define ID3D12CommandQueue_Signal(self, ...) ((self)->vtbl->Signal(self, __VA_ARGS__))
#define ID3D12CommandQueue_Wait(self, ...) ((self)->vtbl->Wait(self, __VA_ARGS__))
#define ID3D12CommandQueue_GetTimestampFrequency(self, ...)                                        \
  ((self)->vtbl->GetTimestampFrequency(self, __VA_ARGS__))
#define ID3D12CommandQueue_GetClockCalibration(self, ...)                                          \
  ((self)->vtbl->GetClockCalibration(self, __VA_ARGS__))
#define ID3D12CommandQueue_GetDesc(self, ...) ((self)->vtbl->GetDesc(self, __VA_ARGS__))

// ID3D12Device
typedef struct ID3D12Device_vtable {
  // IUnknown
  i32(__stdcall *QueryInterface)(ID3D12Device *self, const GUID *guid, void **out_object);
  u32(__stdcall *AddRef)(ID3D12Device *self);
  u32(__stdcall *Release)(ID3D12Device *self);
  // ID3D12Object
  i32(__stdcall *GetPrivateData)(ID3D12Device *self, const GUID *guid, u32 *out_data_size,
                                 void *out_data);
  i32(__stdcall *SetPrivateData)(ID3D12Device *self, const GUID *guid, u32 data_size,
                                 const void *data);
  i32(__stdcall *SetPrivateDataInterface)(ID3D12Device *self, const GUID *guid,
                                          const IUnknown *data);
  i32(__stdcall *SetName)(ID3D12Device *self, const u16 *name);
  // ID3D12Device
  u32(__stdcall *GetNodeCount)(ID3D12Device *self);
  i32(__stdcall *CreateCommandQueue)(ID3D12Device *self, const D3D12_COMMAND_QUEUE_DESC *desc,
                                     const GUID *guid, void **out_command_queue);
  i32(__stdcall *CreateCommandAllocator)(ID3D12Device *self, D3D12_COMMAND_LIST_TYPE type,
                                         const GUID *guid, void **out_command_allocator);
  i32(__stdcall *CreateGraphicsPipelineState)(ID3D12Device *self,
                                              const D3D12_GRAPHICS_PIPELINE_STATE_DESC *desc,
                                              const GUID *guid, void **out_pipeline_state);
  i32(__stdcall *CreateComputePipelineState)(ID3D12Device *self,
                                             const D3D12_COMPUTE_PIPELINE_STATE_DESC *desc,
                                             const GUID *guid, void **out_pipeline_state);
  i32(__stdcall *CreateCommandList)(ID3D12Device *self, u32 node_mask, D3D12_COMMAND_LIST_TYPE type,
                                    ID3D12CommandAllocator *command_allocator,
                                    ID3D12PipelineState *initial_state, const GUID *guid,
                                    void **out_command_list);
  i32(__stdcall *CheckFeatureSupport)(ID3D12Device *self, D3D12_FEATURE feature,
                                      void *out_feature_support_data,
                                      u32 feature_support_data_size);
  i32(__stdcall *CreateDescriptorHeap)(ID3D12Device *self, const D3D12_DESCRIPTOR_HEAP_DESC *desc,
                                       const GUID *guid, void **out_heap);
  u32(__stdcall *GetDescriptorHandleIncrementSize)(ID3D12Device *self,
                                                   D3D12_DESCRIPTOR_HEAP_TYPE type);
  i32(__stdcall *CreateRootSignature)(ID3D12Device *self, u32 node_mask,
                                      const void *blob_with_root_signature,
                                      u64 blob_length_in_bytes, const GUID *guid,
                                      void **root_signature);
  void(__stdcall *CreateConstantBufferView)(ID3D12Device *self,
                                            const D3D12_CONSTANT_BUFFER_VIEW_DESC *desc,
                                            D3D12_CPU_DESCRIPTOR_HANDLE dest_descriptor);
  void(__stdcall *CreateShaderResourceView)(ID3D12Device *self, ID3D12Resource *resource,
                                            const D3D12_SHADER_RESOURCE_VIEW_DESC *desc,
                                            D3D12_CPU_DESCRIPTOR_HANDLE dest_descriptor);
  void(__stdcall *CreateUnorderedAccessView)(ID3D12Device *self, ID3D12Resource *resource,
                                             ID3D12Resource *counter_resource,
                                             const D3D12_UNORDERED_ACCESS_VIEW_DESC *desc,
                                             D3D12_CPU_DESCRIPTOR_HANDLE dest_descriptor);
  void(__stdcall *CreateRenderTargetView)(ID3D12Device *self, ID3D12Resource *resource,
                                          const D3D12_RENDER_TARGET_VIEW_DESC *desc,
                                          D3D12_CPU_DESCRIPTOR_HANDLE dest_descriptor);
  void(__stdcall *CreateDepthStencilView)(ID3D12Device *self, ID3D12Resource *resource,
                                          const D3D12_DEPTH_STENCIL_VIEW_DESC *desc,
                                          D3D12_CPU_DESCRIPTOR_HANDLE dest_descriptor);
  void(__stdcall *CreateSampler)(ID3D12Device *self, const D3D12_SAMPLER_DESC *desc,
                                 D3D12_CPU_DESCRIPTOR_HANDLE dest_descriptor);
  void(__stdcall *CopyDescriptors)(ID3D12Device *self, u32 num_dest_descriptor_ranges,
                                   const D3D12_CPU_DESCRIPTOR_HANDLE *dest_descriptor_range_starts,
                                   const u32 *dest_descriptor_range_sizes,
                                   u32 num_src_descriptor_ranges,
                                   const D3D12_CPU_DESCRIPTOR_HANDLE *src_descriptor_range_starts,
                                   const u32 *src_descriptor_range_sizes,
                                   D3D12_DESCRIPTOR_HEAP_TYPE descriptor_heaps_type);
  void(__stdcall *CopyDescriptorsSimple)(ID3D12Device *self, u32 num_descriptors,
                                         D3D12_CPU_DESCRIPTOR_HANDLE dest_descriptor_range_start,
                                         D3D12_CPU_DESCRIPTOR_HANDLE src_descriptor_range_start,
                                         D3D12_DESCRIPTOR_HEAP_TYPE descriptor_heaps_type);
  D3D12_RESOURCE_ALLOCATION_INFO *(__stdcall *GetResourceAllocationInfo)(
      ID3D12Device *self, u32 visible_mask, u32 num_resource_descs,
      const D3D12_RESOURCE_DESC *resource_descs, D3D12_RESOURCE_ALLOCATION_INFO *out_alloc_info);
  D3D12_HEAP_PROPERTIES *(__stdcall *GetCustomHeapProperties)(
      ID3D12Device *self, u32 node_mask, D3D12_HEAP_TYPE heap_type,
      D3D12_HEAP_PROPERTIES *out_heap_properties);
  i32(__stdcall *CreateCommittedResource)(
      ID3D12Device *self, const D3D12_HEAP_PROPERTIES *heap_properties, D3D12_HEAP_FLAGS heap_flags,
      const D3D12_RESOURCE_DESC *desc, D3D12_RESOURCE_STATES initial_resource_state,
      const D3D12_CLEAR_VALUE *optimized_clear_value, const GUID *guid, void **out_resource);
  i32(__stdcall *CreateHeap)(ID3D12Device *self, const D3D12_HEAP_DESC *desc, const GUID *guid,
                             void **out_heap);
  i32(__stdcall *CreatePlacedResource)(ID3D12Device *self, ID3D12Heap *heap, u64 heap_offset,
                                       const D3D12_RESOURCE_DESC *desc,
                                       D3D12_RESOURCE_STATES initial_resource_state,
                                       const D3D12_CLEAR_VALUE *optimized_clear_value,
                                       const GUID *guid, void **out_resource);
  i32(__stdcall *CreateReservedResource)(ID3D12Device *self, const D3D12_RESOURCE_DESC *desc,
                                         D3D12_RESOURCE_STATES initial_resource_state,
                                         const D3D12_CLEAR_VALUE *optimized_clear_value,
                                         const GUID *guid, void **out_resource);
  i32(__stdcall *CreateSharedHandle)(ID3D12Device *self, ID3D12DeviceChild *object,
                                     const SECURITY_ATTRIBUTES *attributes, u32 access, u16 *name,
                                     void **out_handle);
  i32(__stdcall *OpenSharedHandle)(ID3D12Device *self, void *nt_handle, const GUID *guid,
                                   void **out_object);
  i32(__stdcall *OpenSharedHandleByName)(ID3D12Device *self, u16 *name, u32 access,
                                         void **out_nt_handle);
  i32(__stdcall *MakeResident)(ID3D12Device *self, u32 num_objects, ID3D12Pageable *const *objects);
  i32(__stdcall *Evict)(ID3D12Device *self, u32 num_objects, ID3D12Pageable *const *objects);
  i32(__stdcall *CreateFence)(ID3D12Device *self, u64 initial_value, D3D12_FENCE_FLAGS flags,
                              const GUID *guid, void **out_fence);
  i32(__stdcall *GetDeviceRemovedReason)(ID3D12Device *self);
  void(__stdcall *GetCopyableFootprints)(ID3D12Device *self, const D3D12_RESOURCE_DESC *desc,
                                         u32 first_subresource, u32 num_subresources,
                                         u64 base_offset,
                                         D3D12_PLACED_SUBRESOURCE_FOOTPRINT *out_layouts,
                                         u32 *out_num_rows, u64 *out_row_size_in_bytes,
                                         u64 *out_total_bytes);
  i32(__stdcall *CreateQueryHeap)(ID3D12Device *self, const D3D12_QUERY_HEAP_DESC *desc,
                                  const GUID *guid, void **out_heap);
  i32(__stdcall *SetStablePowerState)(ID3D12Device *self, i32 enable);
  i32(__stdcall *CreateCommandSignature)(ID3D12Device *self,
                                         const D3D12_COMMAND_SIGNATURE_DESC *desc,
                                         ID3D12RootSignature *root_signature, const GUID *guid,
                                         void **out_command_signature);
  void(__stdcall *GetResourceTiling)(
      ID3D12Device *self, ID3D12Resource *tiled_resource, u32 *out_num_tiles_for_entire_resource,
      D3D12_PACKED_MIP_INFO *out_packed_mip_desc,
      D3D12_TILE_SHAPE *out_standard_tile_shape_for_non_packed_mips,
      u32 *out_num_subresource_tilings, u32 first_subresource_tiling_to_get,
      D3D12_SUBRESOURCE_TILING *out_subresource_tiling_for_non_packed_mips);
  i64(__stdcall *GetAdapterLuid)(ID3D12Device *self);
} ID3D12Device_vtable;

struct ID3D12Device {
  const ID3D12Device_vtable *vtbl;
};

#define ID3D12Device_QueryInterface(self, ...) ((self)->vtbl->QueryInterface(self, __VA_ARGS__))
#define ID3D12Device_AddRef(self, ...) ((self)->vtbl->AddRef(self, __VA_ARGS__))
#define ID3D12Device_Release(self, ...) ((self)->vtbl->Release(self, __VA_ARGS__))
#define ID3D12Device_GetPrivateData(self, ...) ((self)->vtbl->GetPrivateData(self, __VA_ARGS__))
#define ID3D12Device_SetPrivateData(self, ...) ((self)->vtbl->SetPrivateData(self, __VA_ARGS__))
#define ID3D12Device_SetPrivateDataInterface(self, ...)                                            \
  ((self)->vtbl->SetPrivateDataInterface(self, __VA_ARGS__))
#define ID3D12Device_SetName(self, ...) ((self)->vtbl->SetName(self, __VA_ARGS__))
#define ID3D12Device_GetNodeCount(self, ...) ((self)->vtbl->GetNodeCount(self, __VA_ARGS__))
#define ID3D12Device_CreateCommandQueue(self, ...)                                                 \
  ((self)->vtbl->CreateCommandQueue(self, __VA_ARGS__))
#define ID3D12Device_CreateCommandAllocator(self, ...)                                             \
  ((self)->vtbl->CreateCommandAllocator(self, __VA_ARGS__))
#define ID3D12Device_CreateGraphicsPipelineState(self, ...)                                        \
  ((self)->vtbl->CreateGraphicsPipelineState(self, __VA_ARGS__))
#define ID3D12Device_CreateComputePipelineState(self, ...)                                         \
  ((self)->vtbl->CreateComputePipelineState(self, __VA_ARGS__))
#define ID3D12Device_CreateCommandList(self, ...)                                                  \
  ((self)->vtbl->CreateCommandList(self, __VA_ARGS__))
#define ID3D12Device_CheckFeatureSupport(self, ...)                                                \
  ((self)->vtbl->CheckFeatureSupport(self, __VA_ARGS__))
#define ID3D12Device_CreateDescriptorHeap(self, ...)                                               \
  ((self)->vtbl->CreateDescriptorHeap(self, __VA_ARGS__))
#define ID3D12Device_GetDescriptorHandleIncrementSize(self, ...)                                   \
  ((self)->vtbl->GetDescriptorHandleIncrementSize(self, __VA_ARGS__))
#define ID3D12Device_CreateRootSignature(self, ...)                                                \
  ((self)->vtbl->CreateRootSignature(self, __VA_ARGS__))
#define ID3D12Device_CreateConstantBufferView(self, ...)                                           \
  ((self)->vtbl->CreateConstantBufferView(self, __VA_ARGS__))
#define ID3D12Device_CreateShaderResourceView(self, ...)                                           \
  ((self)->vtbl->CreateShaderResourceView(self, __VA_ARGS__))
#define ID3D12Device_CreateUnorderedAccessView(self, ...)                                          \
  ((self)->vtbl->CreateUnorderedAccessView(self, __VA_ARGS__))
#define ID3D12Device_CreateRenderTargetView(self, ...)                                             \
  ((self)->vtbl->CreateRenderTargetView(self, __VA_ARGS__))
#define ID3D12Device_CreateDepthStencilView(self, ...)                                             \
  ((self)->vtbl->CreateDepthStencilView(self, __VA_ARGS__))
#define ID3D12Device_CreateSampler(self, ...) ((self)->vtbl->CreateSampler(self, __VA_ARGS__))
#define ID3D12Device_CopyDescriptors(self, ...) ((self)->vtbl->CopyDescriptors(self, __VA_ARGS__))
#define ID3D12Device_CopyDescriptorsSimple(self, ...)                                              \
  ((self)->vtbl->CopyDescriptorsSimple(self, __VA_ARGS__))
#define ID3D12Device_GetResourceAllocationInfo(self, ...)                                          \
  ((self)->vtbl->GetResourceAllocationInfo(self, __VA_ARGS__))
#define ID3D12Device_GetCustomHeapProperties(self, ...)                                            \
  ((self)->vtbl->GetCustomHeapProperties(self, __VA_ARGS__))
#define ID3D12Device_CreateCommittedResource(self, ...)                                            \
  ((self)->vtbl->CreateCommittedResource(self, __VA_ARGS__))
#define ID3D12Device_CreateHeap(self, ...) ((self)->vtbl->CreateHeap(self, __VA_ARGS__))
#define ID3D12Device_CreatePlacedResource(self, ...)                                               \
  ((self)->vtbl->CreatePlacedResource(self, __VA_ARGS__))
#define ID3D12Device_CreateReservedResource(self, ...)                                             \
  ((self)->vtbl->CreateReservedResource(self, __VA_ARGS__))
#define ID3D12Device_CreateSharedHandle(self, ...)                                                 \
  ((self)->vtbl->CreateSharedHandle(self, __VA_ARGS__))
#define ID3D12Device_OpenSharedHandle(self, ...) ((self)->vtbl->OpenSharedHandle(self, __VA_ARGS__))
#define ID3D12Device_OpenSharedHandleByName(self, ...)                                             \
  ((self)->vtbl->OpenSharedHandleByName(self, __VA_ARGS__))
#define ID3D12Device_MakeResident(self, ...) ((self)->vtbl->MakeResident(self, __VA_ARGS__))
#define ID3D12Device_Evict(self, ...) ((self)->vtbl->Evict(self, __VA_ARGS__))
#define ID3D12Device_CreateFence(self, ...) ((self)->vtbl->CreateFence(self, __VA_ARGS__))
#define ID3D12Device_GetDeviceRemovedReason(self, ...)                                             \
  ((self)->vtbl->GetDeviceRemovedReason(self, __VA_ARGS__))
#define ID3D12Device_GetCopyableFootprints(self, ...)                                              \
  ((self)->vtbl->GetCopyableFootprints(self, __VA_ARGS__))
#define ID3D12Device_CreateQueryHeap(self, ...) ((self)->vtbl->CreateQueryHeap(self, __VA_ARGS__))
#define ID3D12Device_SetStablePowerState(self, ...)                                                \
  ((self)->vtbl->SetStablePowerState(self, __VA_ARGS__))
#define ID3D12Device_CreateCommandSignature(self, ...)                                             \
  ((self)->vtbl->CreateCommandSignature(self, __VA_ARGS__))
#define ID3D12Device_GetResourceTiling(self, ...)                                                  \
  ((self)->vtbl->GetResourceTiling(self, __VA_ARGS__))
#define ID3D12Device_GetAdapterLuid(self, ...) ((self)->vtbl->GetAdapterLuid(self, __VA_ARGS__))

// ID3D12Debug
typedef struct ID3D12Debug_vtable {
  // IUnknown
  i32(__stdcall *QueryInterface)(ID3D12Debug *self, const GUID *guid, void **out_object);
  u32(__stdcall *AddRef)(ID3D12Debug *self);
  u32(__stdcall *Release)(ID3D12Debug *self);
  // ID3D12Debug
  void(__stdcall *EnableDebugLayer)(ID3D12Debug *self);
} ID3D12Debug_vtable;

struct ID3D12Debug {
  const ID3D12Debug_vtable *vtbl;
};

#define ID3D12Debug_QueryInterface(self, ...) ((self)->vtbl->QueryInterface(self, __VA_ARGS__))
#define ID3D12Debug_AddRef(self, ...) ((self)->vtbl->AddRef(self, __VA_ARGS__))
#define ID3D12Debug_Release(self, ...) ((self)->vtbl->Release(self, __VA_ARGS__))
#define ID3D12Debug_EnableDebugLayer(self, ...) ((self)->vtbl->EnableDebugLayer(self, __VA_ARGS__))

// ID3D12Debug1
typedef struct ID3D12Debug1_vtable {
  // IUnknown
  i32(__stdcall *QueryInterface)(ID3D12Debug1 *self, const GUID *guid, void **out_object);
  u32(__stdcall *AddRef)(ID3D12Debug1 *self);
  u32(__stdcall *Release)(ID3D12Debug1 *self);
  // ID3D12Debug1
  void(__stdcall *EnableDebugLayer)(ID3D12Debug1 *self);
  void(__stdcall *SetEnableGPUBasedValidation)(ID3D12Debug1 *self, i32 enable);
  void(__stdcall *SetEnableSynchronizedCommandQueueValidation)(ID3D12Debug1 *self, i32 enable);
} ID3D12Debug1_vtable;

struct ID3D12Debug1 {
  const ID3D12Debug1_vtable *vtbl;
};

#define ID3D12Debug1_QueryInterface(self, ...) ((self)->vtbl->QueryInterface(self, __VA_ARGS__))
#define ID3D12Debug1_AddRef(self, ...) ((self)->vtbl->AddRef(self, __VA_ARGS__))
#define ID3D12Debug1_Release(self, ...) ((self)->vtbl->Release(self, __VA_ARGS__))
#define ID3D12Debug1_EnableDebugLayer(self, ...) ((self)->vtbl->EnableDebugLayer(self, __VA_ARGS__))
#define ID3D12Debug1_SetEnableGPUBasedValidation(self, ...)                                        \
  ((self)->vtbl->SetEnableGPUBasedValidation(self, __VA_ARGS__))
#define ID3D12Debug1_SetEnableSynchronizedCommandQueueValidation(self, ...)                        \
  ((self)->vtbl->SetEnableSynchronizedCommandQueueValidation(self, __VA_ARGS__))

typedef struct DXGI_RGB {
  f32 Red;
  f32 Green;
  f32 Blue;
} DXGI_RGB;

typedef struct DXGI_RGBA {
  f32 Red;
  f32 Green;
  f32 Blue;
  f32 Alpha;
} DXGI_RGBA;

typedef struct DXGI_GAMMA_CONTROL {
  DXGI_RGB Scale;
  DXGI_RGB Offset;
  DXGI_RGB GammaCurve[1025];
} DXGI_GAMMA_CONTROL;

typedef struct DXGI_GAMMA_CONTROL_CAPABILITIES {
  i32 ScaleAndOffsetSupported;
  f32 MaxConvertedValue;
  f32 MinConvertedValue;
  u32 NumGammaControlPoints;
  f32 ControlPointPositions[1025];
} DXGI_GAMMA_CONTROL_CAPABILITIES;

typedef struct DXGI_RATIONAL {
  u32 Numerator;
  u32 Denominator;
} DXGI_RATIONAL;

typedef enum DXGI_MODE_SCANLINE_ORDER {
  DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED = 0,
  DXGI_MODE_SCANLINE_ORDER_PROGRESSIVE = 1,
  DXGI_MODE_SCANLINE_ORDER_UPPER_FIELD_FIRST = 2,
  DXGI_MODE_SCANLINE_ORDER_LOWER_FIELD_FIRST = 3
} DXGI_MODE_SCANLINE_ORDER;

typedef enum DXGI_MODE_SCALING {
  DXGI_MODE_SCALING_UNSPECIFIED = 0,
  DXGI_MODE_SCALING_CENTERED = 1,
  DXGI_MODE_SCALING_STRETCHED = 2
} DXGI_MODE_SCALING;

typedef enum DXGI_MODE_ROTATION {
  DXGI_MODE_ROTATION_UNSPECIFIED = 0,
  DXGI_MODE_ROTATION_IDENTITY = 1,
  DXGI_MODE_ROTATION_ROTATE90 = 2,
  DXGI_MODE_ROTATION_ROTATE180 = 3,
  DXGI_MODE_ROTATION_ROTATE270 = 4
} DXGI_MODE_ROTATION;

typedef struct DXGI_MODE_DESC {
  u32 Width;
  u32 Height;
  DXGI_RATIONAL RefreshRate;
  DXGI_FORMAT Format;
  DXGI_MODE_SCANLINE_ORDER ScanlineOrdering;
  DXGI_MODE_SCALING Scaling;
} DXGI_MODE_DESC;

typedef struct DXGI_OUTPUT_DESC {
  u16 DeviceName[32];
  D3D12_RECT DesktopCoordinates;
  i32 AttachedToDesktop;
  DXGI_MODE_ROTATION Rotation;
  void *Monitor;
} DXGI_OUTPUT_DESC;

typedef struct DXGI_SURFACE_DESC {
  u32 Width;
  u32 Height;
  DXGI_FORMAT Format;
  DXGI_SAMPLE_DESC SampleDesc;
} DXGI_SURFACE_DESC;

typedef struct DXGI_MAPPED_RECT {
  i32 Pitch;
  u8 *pBits;
} DXGI_MAPPED_RECT;

typedef struct DXGI_FRAME_STATISTICS {
  u32 PresentCount;
  u32 PresentRefreshCount;
  u32 SyncRefreshCount;
  i64 SyncQPCTime;
  i64 SyncGPUTime;
} DXGI_FRAME_STATISTICS;

typedef struct DXGI_ADAPTER_DESC {
  u16 Description[128];
  u32 VendorId;
  u32 DeviceId;
  u32 SubSysId;
  u32 Revision;
  u64 DedicatedVideoMemory;
  u64 DedicatedSystemMemory;
  u64 SharedSystemMemory;
  i64 AdapterLuid;
} DXGI_ADAPTER_DESC;

typedef struct DXGI_ADAPTER_DESC1 {
  u16 Description[128];
  u32 VendorId;
  u32 DeviceId;
  u32 SubSysId;
  u32 Revision;
  u64 DedicatedVideoMemory;
  u64 DedicatedSystemMemory;
  u64 SharedSystemMemory;
  i64 AdapterLuid;
  u32 Flags;
} DXGI_ADAPTER_DESC1;

#define DXGI_USAGE_SHADER_INPUT 0x00000010UL
#define DXGI_USAGE_RENDER_TARGET_OUTPUT 0x00000020UL
#define DXGI_USAGE_BACK_BUFFER 0x00000040UL
#define DXGI_USAGE_SHARED 0x00000080UL
#define DXGI_USAGE_READ_ONLY 0x00000100UL
#define DXGI_USAGE_DISCARD_ON_PRESENT 0x00000200UL
#define DXGI_USAGE_UNORDERED_ACCESS 0x00000400UL
typedef u32 DXGI_USAGE;

typedef enum DXGI_SWAP_EFFECT {
  DXGI_SWAP_EFFECT_DISCARD = 0,
  DXGI_SWAP_EFFECT_SEQUENTIAL = 1,
  DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL = 3,
  DXGI_SWAP_EFFECT_FLIP_DISCARD = 4
} DXGI_SWAP_EFFECT;

typedef struct DXGI_SWAP_CHAIN_DESC {
  DXGI_MODE_DESC BufferDesc;
  DXGI_SAMPLE_DESC SampleDesc;
  DXGI_USAGE BufferUsage;
  u32 BufferCount;
  void *OutputWindow;
  i32 Windowed;
  DXGI_SWAP_EFFECT SwapEffect;
  u32 Flags;
} DXGI_SWAP_CHAIN_DESC;

typedef enum DXGI_SCALING {
  DXGI_SCALING_STRETCH = 0,
  DXGI_SCALING_NONE = 1,
  DXGI_SCALING_ASPECT_RATIO_STRETCH = 2
} DXGI_SCALING;

typedef enum DXGI_ALPHA_MODE {
  DXGI_ALPHA_MODE_UNSPECIFIED = 0,
  DXGI_ALPHA_MODE_PREMULTIPLIED = 1,
  DXGI_ALPHA_MODE_STRAIGHT = 2,
  DXGI_ALPHA_MODE_IGNORE = 3,
  DXGI_ALPHA_MODE_FORCE_DWORD = 0xffffffff
} DXGI_ALPHA_MODE;

typedef struct DXGI_SWAP_CHAIN_DESC1 {
  u32 Width;
  u32 Height;
  DXGI_FORMAT Format;
  i32 Stereo;
  DXGI_SAMPLE_DESC SampleDesc;
  DXGI_USAGE BufferUsage;
  u32 BufferCount;
  DXGI_SCALING Scaling;
  DXGI_SWAP_EFFECT SwapEffect;
  DXGI_ALPHA_MODE AlphaMode;
  u32 Flags;
} DXGI_SWAP_CHAIN_DESC1;

typedef struct DXGI_SWAP_CHAIN_FULLSCREEN_DESC {
  DXGI_RATIONAL RefreshRate;
  DXGI_MODE_SCANLINE_ORDER ScanlineOrdering;
  DXGI_MODE_SCALING Scaling;
  i32 Windowed;
} DXGI_SWAP_CHAIN_FULLSCREEN_DESC;

typedef struct DXGI_PRESENT_PARAMETERS {
  u32 DirtyRectsCount;
  D3D12_RECT *pDirtyRects;
  D3D12_RECT *pScrollRect;
  POINT *pScrollOffset;
} DXGI_PRESENT_PARAMETERS;

typedef struct DXGI_MATRIX_3X2_F {
  f32 _11;
  f32 _12;
  f32 _21;
  f32 _22;
  f32 _31;
  f32 _32;
} DXGI_MATRIX_3X2_F;

typedef enum DXGI_COLOR_SPACE_TYPE {
  DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709 = 0,
  DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709 = 1,
  DXGI_COLOR_SPACE_RGB_STUDIO_G22_NONE_P709 = 2,
  DXGI_COLOR_SPACE_RGB_STUDIO_G22_NONE_P2020 = 3,
  DXGI_COLOR_SPACE_RESERVED = 4,
  DXGI_COLOR_SPACE_YCBCR_FULL_G22_NONE_P709_X601 = 5,
  DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P601 = 6,
  DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P601 = 7,
  DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P709 = 8,
  DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P709 = 9,
  DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_LEFT_P2020 = 10,
  DXGI_COLOR_SPACE_YCBCR_FULL_G22_LEFT_P2020 = 11,
  DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020 = 12,
  DXGI_COLOR_SPACE_YCBCR_STUDIO_G2084_LEFT_P2020 = 13,
  DXGI_COLOR_SPACE_RGB_STUDIO_G2084_NONE_P2020 = 14,
  DXGI_COLOR_SPACE_YCBCR_STUDIO_G22_TOPLEFT_P2020 = 15,
  DXGI_COLOR_SPACE_YCBCR_STUDIO_G2084_TOPLEFT_P2020 = 16,
  DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P2020 = 17,
  DXGI_COLOR_SPACE_CUSTOM = 0xFFFFFFFF
} DXGI_COLOR_SPACE_TYPE;

typedef struct IDXGISwapChain_vtable {
  // IUnknown
  i32(__stdcall *QueryInterface)(IDXGISwapChain *self, const GUID *guid, void **out_object);
  u32(__stdcall *AddRef)(IDXGISwapChain *self);
  u32(__stdcall *Release)(IDXGISwapChain *self);
  // IDXGIObject
  i32(__stdcall *SetPrivateData)(IDXGISwapChain *self, const GUID *guid, u32 data_size,
                                 const void *data);
  i32(__stdcall *SetPrivateDataInterface)(IDXGISwapChain *self, const GUID *guid,
                                          const IUnknown *data);
  i32(__stdcall *GetPrivateData)(IDXGISwapChain *self, const GUID *guid, u32 *out_data_size,
                                 void *out_data);
  i32(__stdcall *GetParent)(IDXGISwapChain *self, const GUID *guid, void **out_parent);
  // IDXGIDeviceSubObject
  i32(__stdcall *GetDevice)(IDXGISwapChain *self, const GUID *guid, void **out_device);
  // IDXGISwapChain
  i32(__stdcall *Present)(IDXGISwapChain *self, u32 sync_interval, u32 flags);
  i32(__stdcall *GetBuffer)(IDXGISwapChain *self, u32 buffer, const GUID *guid, void **out_surface);
  i32(__stdcall *SetFullscreenState)(IDXGISwapChain *self, i32 fullscreen, IDXGIOutput *target);
  i32(__stdcall *GetFullscreenState)(IDXGISwapChain *self, i32 *out_fullscreen,
                                     IDXGIOutput **out_target);
  i32(__stdcall *GetDesc)(IDXGISwapChain *self, DXGI_SWAP_CHAIN_DESC *out_desc);
  i32(__stdcall *ResizeBuffers)(IDXGISwapChain *self, u32 buffer_count, u32 width, u32 height,
                                DXGI_FORMAT new_format, u32 swap_chain_flags);
  i32(__stdcall *ResizeTarget)(IDXGISwapChain *self, const DXGI_MODE_DESC *new_target_parameters);
  i32(__stdcall *GetContainingOutput)(IDXGISwapChain *self, IDXGIOutput **out_output);
  i32(__stdcall *GetFrameStatistics)(IDXGISwapChain *self, DXGI_FRAME_STATISTICS *out_stats);
  i32(__stdcall *GetLastPresentCount)(IDXGISwapChain *self, u32 *out_last_present_count);
} IDXGISwapChain_vtable;

struct IDXGISwapChain {
  const IDXGISwapChain_vtable *vtbl;
};

#define IDXGISwapChain_QueryInterface(self, ...) ((self)->vtbl->QueryInterface(self, __VA_ARGS__))
#define IDXGISwapChain_AddRef(self, ...) ((self)->vtbl->AddRef(self, __VA_ARGS__))
#define IDXGISwapChain_Release(self, ...) ((self)->vtbl->Release(self, __VA_ARGS__))
#define IDXGISwapChain_SetPrivateData(self, ...) ((self)->vtbl->SetPrivateData(self, __VA_ARGS__))
#define IDXGISwapChain_SetPrivateDataInterface(self, ...)                                          \
  ((self)->vtbl->SetPrivateDataInterface(self, __VA_ARGS__))
#define IDXGISwapChain_GetPrivateData(self, ...) ((self)->vtbl->GetPrivateData(self, __VA_ARGS__))
#define IDXGISwapChain_GetParent(self, ...) ((self)->vtbl->GetParent(self, __VA_ARGS__))
#define IDXGISwapChain_GetDevice(self, ...) ((self)->vtbl->GetDevice(self, __VA_ARGS__))
#define IDXGISwapChain_Present(self, ...) ((self)->vtbl->Present(self, __VA_ARGS__))
#define IDXGISwapChain_GetBuffer(self, ...) ((self)->vtbl->GetBuffer(self, __VA_ARGS__))
#define IDXGISwapChain_SetFullscreenState(self, ...)                                               \
  ((self)->vtbl->SetFullscreenState(self, __VA_ARGS__))
#define IDXGISwapChain_GetFullscreenState(self, ...)                                               \
  ((self)->vtbl->GetFullscreenState(self, __VA_ARGS__))
#define IDXGISwapChain_GetDesc(self, ...) ((self)->vtbl->GetDesc(self, __VA_ARGS__))
#define IDXGISwapChain_ResizeBuffers(self, ...) ((self)->vtbl->ResizeBuffers(self, __VA_ARGS__))
#define IDXGISwapChain_ResizeTarget(self, ...) ((self)->vtbl->ResizeTarget(self, __VA_ARGS__))
#define IDXGISwapChain_GetContainingOutput(self, ...)                                              \
  ((self)->vtbl->GetContainingOutput(self, __VA_ARGS__))
#define IDXGISwapChain_GetFrameStatistics(self, ...)                                               \
  ((self)->vtbl->GetFrameStatistics(self, __VA_ARGS__))
#define IDXGISwapChain_GetLastPresentCount(self, ...)                                              \
  ((self)->vtbl->GetLastPresentCount(self, __VA_ARGS__))

typedef struct IDXGISwapChain3_vtable {
  // IUnknown
  i32(__stdcall *QueryInterface)(IDXGISwapChain3 *self, const GUID *guid, void **out_object);
  u32(__stdcall *AddRef)(IDXGISwapChain3 *self);
  u32(__stdcall *Release)(IDXGISwapChain3 *self);
  // IDXGIObject
  i32(__stdcall *SetPrivateData)(IDXGISwapChain3 *self, const GUID *guid, u32 data_size,
                                 const void *data);
  i32(__stdcall *SetPrivateDataInterface)(IDXGISwapChain3 *self, const GUID *guid,
                                          const IUnknown *data);
  i32(__stdcall *GetPrivateData)(IDXGISwapChain3 *self, const GUID *guid, u32 *out_data_size,
                                 void *out_data);
  i32(__stdcall *GetParent)(IDXGISwapChain3 *self, const GUID *guid, void **out_parent);
  // IDXGIDeviceSubObject
  i32(__stdcall *GetDevice)(IDXGISwapChain3 *self, const GUID *guid, void **out_device);
  // IDXGISwapChain
  i32(__stdcall *Present)(IDXGISwapChain3 *self, u32 sync_interval, u32 flags);
  i32(__stdcall *GetBuffer)(IDXGISwapChain3 *self, u32 buffer, const GUID *guid,
                            void **out_surface);
  i32(__stdcall *SetFullscreenState)(IDXGISwapChain3 *self, i32 fullscreen, IDXGIOutput *target);
  i32(__stdcall *GetFullscreenState)(IDXGISwapChain3 *self, i32 *out_fullscreen,
                                     IDXGIOutput **out_target);
  i32(__stdcall *GetDesc)(IDXGISwapChain3 *self, DXGI_SWAP_CHAIN_DESC *out_desc);
  i32(__stdcall *ResizeBuffers)(IDXGISwapChain3 *self, u32 buffer_count, u32 width, u32 height,
                                DXGI_FORMAT new_format, u32 swap_chain_flags);
  i32(__stdcall *ResizeTarget)(IDXGISwapChain3 *self, const DXGI_MODE_DESC *new_target_parameters);
  i32(__stdcall *GetContainingOutput)(IDXGISwapChain3 *self, IDXGIOutput **out_output);
  i32(__stdcall *GetFrameStatistics)(IDXGISwapChain3 *self, DXGI_FRAME_STATISTICS *out_stats);
  i32(__stdcall *GetLastPresentCount)(IDXGISwapChain3 *self, u32 *out_last_present_count);
  // IDXGISwapChain2
  i32(__stdcall *GetDesc1)(IDXGISwapChain3 *self, DXGI_SWAP_CHAIN_DESC1 *out_desc);
  i32(__stdcall *GetFullscreenDesc)(IDXGISwapChain3 *self,
                                    DXGI_SWAP_CHAIN_FULLSCREEN_DESC *out_desc);
  i32(__stdcall *GetHwnd)(IDXGISwapChain3 *self, void **out_hwnd);
  i32(__stdcall *GetCoreWindow)(IDXGISwapChain3 *self, const GUID *guid, void **out_window);
  i32(__stdcall *Present1)(IDXGISwapChain3 *self, u32 sync_interval, u32 flags,
                           const DXGI_PRESENT_PARAMETERS *params);
  i32(__stdcall *IsTemporaryMonoSupported)(IDXGISwapChain3 *self);
  i32(__stdcall *GetRestrictToOutput)(IDXGISwapChain3 *self, IDXGIOutput **out_restrict_to_output);
  i32(__stdcall *SetBackgroundColor)(IDXGISwapChain3 *self, const DXGI_RGBA *color);
  i32(__stdcall *GetBackgroundColor)(IDXGISwapChain3 *self, DXGI_RGBA *out_color);
  i32(__stdcall *SetRotation)(IDXGISwapChain3 *self, DXGI_MODE_ROTATION rotation);
  i32(__stdcall *GetRotation)(IDXGISwapChain3 *self, DXGI_MODE_ROTATION *out_rotation);
  i32(__stdcall *SetSourceSize)(IDXGISwapChain3 *self, u32 width, u32 height);
  i32(__stdcall *GetSourceSize)(IDXGISwapChain3 *self, u32 *out_width, u32 *out_height);
  i32(__stdcall *SetMaximumFrameLatency)(IDXGISwapChain3 *self, u32 max_latency);
  i32(__stdcall *GetMaximumFrameLatency)(IDXGISwapChain3 *self, u32 *out_max_latency);
  void *(__stdcall *GetFrameLatencyWaitableObject)(IDXGISwapChain3 *self);
  i32(__stdcall *SetMatrixTransform)(IDXGISwapChain3 *self, const DXGI_MATRIX_3X2_F *matrix);
  i32(__stdcall *GetMatrixTransform)(IDXGISwapChain3 *self, DXGI_MATRIX_3X2_F *out_matrix);
  // IDXGISwapChain3
  u32(__stdcall *GetCurrentBackBufferIndex)(IDXGISwapChain3 *self);
  i32(__stdcall *CheckColorSpaceSupport)(IDXGISwapChain3 *self, DXGI_COLOR_SPACE_TYPE color_space,
                                         u32 *out_support);
  i32(__stdcall *SetColorSpace1)(IDXGISwapChain3 *self, DXGI_COLOR_SPACE_TYPE color_space);
  i32(__stdcall *ResizeBuffers1)(IDXGISwapChain3 *self, u32 buffer_count, u32 width, u32 height,
                                 DXGI_FORMAT format, u32 swap_chain_flags,
                                 const u32 *creation_node_mask, IUnknown *const *present_queue);
} IDXGISwapChain3_vtable;

struct IDXGISwapChain3 {
  const IDXGISwapChain3_vtable *vtbl;
};

#define IDXGISwapChain3_QueryInterface(self, ...) ((self)->vtbl->QueryInterface(self, __VA_ARGS__))
#define IDXGISwapChain3_AddRef(self, ...) ((self)->vtbl->AddRef(self, __VA_ARGS__))
#define IDXGISwapChain3_Release(self, ...) ((self)->vtbl->Release(self, __VA_ARGS__))
#define IDXGISwapChain3_SetPrivateData(self, ...) ((self)->vtbl->SetPrivateData(self, __VA_ARGS__))
#define IDXGISwapChain3_SetPrivateDataInterface(self, ...)                                         \
  ((self)->vtbl->SetPrivateDataInterface(self, __VA_ARGS__))
#define IDXGISwapChain3_GetPrivateData(self, ...) ((self)->vtbl->GetPrivateData(self, __VA_ARGS__))
#define IDXGISwapChain3_GetParent(self, ...) ((self)->vtbl->GetParent(self, __VA_ARGS__))
#define IDXGISwapChain3_GetDevice(self, ...) ((self)->vtbl->GetDevice(self, __VA_ARGS__))
#define IDXGISwapChain3_Present(self, ...) ((self)->vtbl->Present(self, __VA_ARGS__))
#define IDXGISwapChain3_GetBuffer(self, ...) ((self)->vtbl->GetBuffer(self, __VA_ARGS__))
#define IDXGISwapChain3_SetFullscreenState(self, ...)                                              \
  ((self)->vtbl->SetFullscreenState(self, __VA_ARGS__))
#define IDXGISwapChain3_GetFullscreenState(self, ...)                                              \
  ((self)->vtbl->GetFullscreenState(self, __VA_ARGS__))
#define IDXGISwapChain3_GetDesc(self, ...) ((self)->vtbl->GetDesc(self, __VA_ARGS__))
#define IDXGISwapChain3_ResizeBuffers(self, ...) ((self)->vtbl->ResizeBuffers(self, __VA_ARGS__))
#define IDXGISwapChain3_ResizeTarget(self, ...) ((self)->vtbl->ResizeTarget(self, __VA_ARGS__))
#define IDXGISwapChain3_GetContainingOutput(self, ...)                                             \
  ((self)->vtbl->GetContainingOutput(self, __VA_ARGS__))
#define IDXGISwapChain3_GetFrameStatistics(self, ...)                                              \
  ((self)->vtbl->GetFrameStatistics(self, __VA_ARGS__))
#define IDXGISwapChain3_GetLastPresentCount(self, ...)                                             \
  ((self)->vtbl->GetLastPresentCount(self, __VA_ARGS__))
#define IDXGISwapChain3_GetDesc1(self, ...) ((self)->vtbl->GetDesc1(self, __VA_ARGS__))
#define IDXGISwapChain3_GetFullscreenDesc(self, ...)                                               \
  ((self)->vtbl->GetFullscreenDesc(self, __VA_ARGS__))
#define IDXGISwapChain3_GetHwnd(self, ...) ((self)->vtbl->GetHwnd(self, __VA_ARGS__))
#define IDXGISwapChain3_GetCoreWindow(self, ...) ((self)->vtbl->GetCoreWindow(self, __VA_ARGS__))
#define IDXGISwapChain3_Present1(self, ...) ((self)->vtbl->Present1(self, __VA_ARGS__))
#define IDXGISwapChain3_IsTemporaryMonoSupported(self, ...)                                        \
  ((self)->vtbl->IsTemporaryMonoSupported(self, __VA_ARGS__))
#define IDXGISwapChain3_GetRestrictToOutput(self, ...)                                             \
  ((self)->vtbl->GetRestrictToOutput(self, __VA_ARGS__))
#define IDXGISwapChain3_SetBackgroundColor(self, ...)                                              \
  ((self)->vtbl->SetBackgroundColor(self, __VA_ARGS__))
#define IDXGISwapChain3_GetBackgroundColor(self, ...)                                              \
  ((self)->vtbl->GetBackgroundColor(self, __VA_ARGS__))
#define IDXGISwapChain3_SetRotation(self, ...) ((self)->vtbl->SetRotation(self, __VA_ARGS__))
#define IDXGISwapChain3_GetRotation(self, ...) ((self)->vtbl->GetRotation(self, __VA_ARGS__))
#define IDXGISwapChain3_SetSourceSize(self, ...) ((self)->vtbl->SetSourceSize(self, __VA_ARGS__))
#define IDXGISwapChain3_GetSourceSize(self, ...) ((self)->vtbl->GetSourceSize(self, __VA_ARGS__))
#define IDXGISwapChain3_SetMaximumFrameLatency(self, ...)                                          \
  ((self)->vtbl->SetMaximumFrameLatency(self, __VA_ARGS__))
#define IDXGISwapChain3_GetMaximumFrameLatency(self, ...)                                          \
  ((self)->vtbl->GetMaximumFrameLatency(self, __VA_ARGS__))
#define IDXGISwapChain3_GetFrameLatencyWaitableObject(self, ...)                                   \
  ((self)->vtbl->GetFrameLatencyWaitableObject(self, __VA_ARGS__))
#define IDXGISwapChain3_SetMatrixTransform(self, ...)                                              \
  ((self)->vtbl->SetMatrixTransform(self, __VA_ARGS__))
#define IDXGISwapChain3_GetMatrixTransform(self, ...)                                              \
  ((self)->vtbl->GetMatrixTransform(self, __VA_ARGS__))
#define IDXGISwapChain3_GetCurrentBackBufferIndex(self, ...)                                       \
  ((self)->vtbl->GetCurrentBackBufferIndex(self, __VA_ARGS__))
#define IDXGISwapChain3_CheckColorSpaceSupport(self, ...)                                          \
  ((self)->vtbl->CheckColorSpaceSupport(self, __VA_ARGS__))
#define IDXGISwapChain3_SetColorSpace1(self, ...) ((self)->vtbl->SetColorSpace1(self, __VA_ARGS__))
#define IDXGISwapChain3_ResizeBuffers1(self, ...) ((self)->vtbl->ResizeBuffers1(self, __VA_ARGS__))

typedef struct IDXGIFactory4_vtable {
  // IUnknown
  i32(__stdcall *QueryInterface)(IDXGIFactory4 *self, const GUID *guid, void **out_object);
  u32(__stdcall *AddRef)(IDXGIFactory4 *self);
  u32(__stdcall *Release)(IDXGIFactory4 *self);
  // IDXGIObject
  i32(__stdcall *SetPrivateData)(IDXGIFactory4 *self, const GUID *guid, u32 data_size,
                                 const void *data);
  i32(__stdcall *SetPrivateDataInterface)(IDXGIFactory4 *self, const GUID *guid,
                                          const IUnknown *data);
  i32(__stdcall *GetPrivateData)(IDXGIFactory4 *self, const GUID *guid, u32 *out_data_size,
                                 void *out_data);
  i32(__stdcall *GetParent)(IDXGIFactory4 *self, const GUID *guid, void **out_parent);
  // IDXGIFactory
  i32(__stdcall *EnumAdapters)(IDXGIFactory4 *self, u32 adapter, IDXGIAdapter **out_adapter);
  i32(__stdcall *MakeWindowAssociation)(IDXGIFactory4 *self, void *hwnd, u32 flags);
  i32(__stdcall *GetWindowAssociation)(IDXGIFactory4 *self, void **out_hwnd);
  i32(__stdcall *CreateSwapChain)(IDXGIFactory4 *self, IUnknown *device, DXGI_SWAP_CHAIN_DESC *desc,
                                  IDXGISwapChain **out_swap_chain);
  i32(__stdcall *CreateSoftwareAdapter)(IDXGIFactory4 *self, void *mod, IDXGIAdapter **out_adapter);
  i32(__stdcall *EnumAdapters1)(IDXGIFactory4 *self, u32 adapter, IDXGIAdapter1 **out_adapter);
  i32(__stdcall *IsCurrent)(IDXGIFactory4 *self);
  i32(__stdcall *IsWindowedStereoEnabled)(IDXGIFactory4 *self);
  i32(__stdcall *CreateSwapChainForHwnd)(IDXGIFactory4 *self, IUnknown *device, void *hwnd,
                                         const DXGI_SWAP_CHAIN_DESC1 *desc,
                                         const DXGI_SWAP_CHAIN_FULLSCREEN_DESC *fullscreen_desc,
                                         IDXGIOutput *restrict_to_output,
                                         IDXGISwapChain1 **out_swap_chain);
  i32(__stdcall *CreateSwapChainForCoreWindow)(IDXGIFactory4 *self, IUnknown *device,
                                               IUnknown *window, const DXGI_SWAP_CHAIN_DESC1 *desc,
                                               IDXGIOutput *restrict_to_output,
                                               IDXGISwapChain1 **out_swap_chain);
  i32(__stdcall *GetSharedResourceAdapterLuid)(IDXGIFactory4 *self, void *resource, i64 *out_luid);
  i32(__stdcall *RegisterStereoStatusWindow)(IDXGIFactory4 *self, void *hwnd, u32 msg,
                                             u32 *out_cookie);
  i32(__stdcall *RegisterStereoStatusEvent)(IDXGIFactory4 *self, void *event, u32 *out_cookie);
  void(__stdcall *UnregisterStereoStatus)(IDXGIFactory4 *self, u32 cookie);
  i32(__stdcall *RegisterOcclusionStatusWindow)(IDXGIFactory4 *self, void *hwnd, u32 msg,
                                                u32 *out_cookie);
  i32(__stdcall *RegisterOcclusionStatusEvent)(IDXGIFactory4 *self, void *event, u32 *out_cookie);
  void(__stdcall *UnregisterOcclusionStatus)(IDXGIFactory4 *self, u32 cookie);
  i32(__stdcall *CreateSwapChainForComposition)(IDXGIFactory4 *self, IUnknown *device,
                                                const DXGI_SWAP_CHAIN_DESC1 *desc,
                                                IDXGIOutput *restrict_to_output,
                                                IDXGISwapChain1 **out_swap_chain);
  u32(__stdcall *GetCreationFlags)(IDXGIFactory4 *self);
  // IDXGIFactory4
  i32(__stdcall *EnumAdapterByLuid)(IDXGIFactory4 *self, i64 adapter_luid, const GUID *guid,
                                    void **out_adapter);
  i32(__stdcall *EnumWarpAdapter)(IDXGIFactory4 *self, const GUID *guid, void **out_adapter);
} IDXGIFactory4_vtable;

struct IDXGIFactory4 {
  const IDXGIFactory4_vtable *vtbl;
};

#define IDXGIFactory4_QueryInterface(self, ...) ((self)->vtbl->QueryInterface(self, __VA_ARGS__))
#define IDXGIFactory4_AddRef(self, ...) ((self)->vtbl->AddRef(self, __VA_ARGS__))
#define IDXGIFactory4_Release(self, ...) ((self)->vtbl->Release(self, __VA_ARGS__))
#define IDXGIFactory4_SetPrivateData(self, ...) ((self)->vtbl->SetPrivateData(self, __VA_ARGS__))
#define IDXGIFactory4_SetPrivateDataInterface(self, ...)                                           \
  ((self)->vtbl->SetPrivateDataInterface(self, __VA_ARGS__))
#define IDXGIFactory4_GetPrivateData(self, ...) ((self)->vtbl->GetPrivateData(self, __VA_ARGS__))
#define IDXGIFactory4_GetParent(self, ...) ((self)->vtbl->GetParent(self, __VA_ARGS__))
#define IDXGIFactory4_EnumAdapters(self, ...) ((self)->vtbl->EnumAdapters(self, __VA_ARGS__))
#define IDXGIFactory4_MakeWindowAssociation(self, ...)                                             \
  ((self)->vtbl->MakeWindowAssociation(self, __VA_ARGS__))
#define IDXGIFactory4_GetWindowAssociation(self, ...)                                              \
  ((self)->vtbl->GetWindowAssociation(self, __VA_ARGS__))
#define IDXGIFactory4_CreateSwapChain(self, ...) ((self)->vtbl->CreateSwapChain(self, __VA_ARGS__))
#define IDXGIFactory4_CreateSoftwareAdapter(self, ...)                                             \
  ((self)->vtbl->CreateSoftwareAdapter(self, __VA_ARGS__))
#define IDXGIFactory4_EnumAdapters1(self, ...) ((self)->vtbl->EnumAdapters1(self, __VA_ARGS__))
#define IDXGIFactory4_IsCurrent(self, ...) ((self)->vtbl->IsCurrent(self, __VA_ARGS__))
#define IDXGIFactory4_IsWindowedStereoEnabled(self, ...)                                           \
  ((self)->vtbl->IsWindowedStereoEnabled(self, __VA_ARGS__))
#define IDXGIFactory4_CreateSwapChainForHwnd(self, ...)                                            \
  ((self)->vtbl->CreateSwapChainForHwnd(self, __VA_ARGS__))
#define IDXGIFactory4_CreateSwapChainForCoreWindow(self, ...)                                      \
  ((self)->vtbl->CreateSwapChainForCoreWindow(self, __VA_ARGS__))
#define IDXGIFactory4_GetSharedResourceAdapterLuid(self, ...)                                      \
  ((self)->vtbl->GetSharedResourceAdapterLuid(self, __VA_ARGS__))
#define IDXGIFactory4_RegisterStereoStatusWindow(self, ...)                                        \
  ((self)->vtbl->RegisterStereoStatusWindow(self, __VA_ARGS__))
#define IDXGIFactory4_RegisterStereoStatusEvent(self, ...)                                         \
  ((self)->vtbl->RegisterStereoStatusEvent(self, __VA_ARGS__))
#define IDXGIFactory4_UnregisterStereoStatus(self, ...)                                            \
  ((self)->vtbl->UnregisterStereoStatus(self, __VA_ARGS__))
#define IDXGIFactory4_RegisterOcclusionStatusWindow(self, ...)                                     \
  ((self)->vtbl->RegisterOcclusionStatusWindow(self, __VA_ARGS__))
#define IDXGIFactory4_RegisterOcclusionStatusEvent(self, ...)                                      \
  ((self)->vtbl->RegisterOcclusionStatusEvent(self, __VA_ARGS__))
#define IDXGIFactory4_UnregisterOcclusionStatus(self, ...)                                         \
  ((self)->vtbl->UnregisterOcclusionStatus(self, __VA_ARGS__))
#define IDXGIFactory4_CreateSwapChainForComposition(self, ...)                                     \
  ((self)->vtbl->CreateSwapChainForComposition(self, __VA_ARGS__))
#define IDXGIFactory4_GetCreationFlags(self, ...)                                                  \
  ((self)->vtbl->GetCreationFlags(self, __VA_ARGS__))
#define IDXGIFactory4_EnumAdapterByLuid(self, ...)                                                 \
  ((self)->vtbl->EnumAdapterByLuid(self, __VA_ARGS__))
#define IDXGIFactory4_EnumWarpAdapter(self, ...) ((self)->vtbl->EnumWarpAdapter(self, __VA_ARGS__))

extern const GUID IID_ID3D12GraphicsCommandList;
extern const GUID IID_ID3D12CommandQueue;
extern const GUID IID_ID3D12Device;
extern const GUID IID_ID3D12DescriptorHeap;
extern const GUID IID_ID3D12Resource;
extern const GUID IID_ID3D12RootSignature;
extern const GUID IID_ID3D12CommandAllocator;
extern const GUID IID_ID3D12Fence;
extern const GUID IID_ID3D12PipelineState;
extern const GUID IID_ID3D12Debug;
extern const GUID IID_ID3D12Debug1;
extern const GUID IID_IDXGIFactory4;
extern const GUID IID_IDXGISwapChain3;

typedef i32(__stdcall *CreateDXGIFactory2_t)(u32 flags, const GUID *guid, void **out_object);

typedef i32(__stdcall *D3D12CreateDevice_t)(IUnknown *adapter, D3D_FEATURE_LEVEL min_feature_level,
                                            const GUID *guid, void **out_object);
typedef i32(__stdcall *D3D12GetDebugInterface_t)(const GUID *guid, void **out_object);

extern CreateDXGIFactory2_t CreateDXGIFactory2;
extern D3D12CreateDevice_t D3D12CreateDevice;
extern D3D12GetDebugInterface_t D3D12GetDebugInterface;

void mzd3d12_load_api(void);

inline D3D12_RASTERIZER_DESC mzd3d12_rasterizer_desc(void) {
  return (D3D12_RASTERIZER_DESC){
      .FillMode = D3D12_FILL_MODE_SOLID,
      .CullMode = D3D12_CULL_MODE_BACK,
      .FrontCounterClockwise = 0,
      .DepthBias = D3D12_DEFAULT_DEPTH_BIAS,
      .DepthBiasClamp = D3D12_DEFAULT_DEPTH_BIAS_CLAMP,
      .SlopeScaledDepthBias = D3D12_DEFAULT_SLOPE_SCALED_DEPTH_BIAS,
      .DepthClipEnable = 1,
      .MultisampleEnable = 0,
      .AntialiasedLineEnable = 0,
      .ForcedSampleCount = 0,
      .ConservativeRaster = D3D12_CONSERVATIVE_RASTERIZATION_MODE_OFF,
  };
}

inline D3D12_BLEND_DESC mzd3d12_blend_desc(void) {
  D3D12_RENDER_TARGET_BLEND_DESC rt_blend_desc = {
      .BlendEnable = 0,
      .LogicOpEnable = 0,
      .SrcBlend = D3D12_BLEND_ONE,
      .DestBlend = D3D12_BLEND_ZERO,
      .BlendOp = D3D12_BLEND_OP_ADD,
      .SrcBlendAlpha = D3D12_BLEND_ONE,
      .DestBlendAlpha = D3D12_BLEND_ZERO,
      .BlendOpAlpha = D3D12_BLEND_OP_ADD,
      .LogicOp = D3D12_LOGIC_OP_NOOP,
      .RenderTargetWriteMask = 0x0f,
  };
  return (D3D12_BLEND_DESC){
      .AlphaToCoverageEnable = FALSE,
      .IndependentBlendEnable = FALSE,
      .RenderTarget = {rt_blend_desc, rt_blend_desc, rt_blend_desc, rt_blend_desc, rt_blend_desc,
                       rt_blend_desc, rt_blend_desc, rt_blend_desc},
  };
}

inline D3D12_RESOURCE_DESC mzd3d12_resource_desc_buffer(u64 size) {
  return (D3D12_RESOURCE_DESC){
      .Dimension = D3D12_RESOURCE_DIMENSION_BUFFER,
      .Alignment = 0,
      .Width = size,
      .Height = 1,
      .DepthOrArraySize = 1,
      .MipLevels = 1,
      .Format = DXGI_FORMAT_UNKNOWN,
      .SampleDesc =
          (DXGI_SAMPLE_DESC){
              .Count = 1,
              .Quality = 0,
          },
      .Layout = D3D12_TEXTURE_LAYOUT_ROW_MAJOR,
      .Flags = D3D12_RESOURCE_FLAG_NONE,
  };
}

inline D3D12_DEPTH_STENCIL_DESC mzd3d12_depth_stencil_desc(void) {
  D3D12_DEPTH_STENCILOP_DESC ds_op_desc = {
      .StencilFailOp = D3D12_STENCIL_OP_KEEP,
      .StencilDepthFailOp = D3D12_STENCIL_OP_KEEP,
      .StencilPassOp = D3D12_STENCIL_OP_KEEP,
      .StencilFunc = D3D12_COMPARISON_FUNC_ALWAYS,
  };
  return (D3D12_DEPTH_STENCIL_DESC){
      .DepthEnable = 1,
      .DepthWriteMask = D3D12_DEPTH_WRITE_MASK_ALL,
      .DepthFunc = D3D12_COMPARISON_FUNC_LESS,
      .StencilEnable = 0,
      .StencilReadMask = D3D12_DEFAULT_STENCIL_READ_MASK,
      .StencilWriteMask = D3D12_DEFAULT_STENCIL_WRITE_MASK,
      .FrontFace = ds_op_desc,
      .BackFace = ds_op_desc,
  };
}

#endif // #ifndef MZ_D3D12_INCLUDED_

#ifdef MZ_D3D12_IMPLEMENTATION

const GUID IID_ID3D12Debug = {
    0x344488b7, 0x6846, 0x474b, {0xb9, 0x89, 0xf0, 0x27, 0x44, 0x82, 0x45, 0xe0}};
const GUID IID_ID3D12Debug1 = {
    0xaffaa4ca, 0x63fe, 0x4d8e, {0xb8, 0xad, 0x15, 0x90, 0x00, 0xaf, 0x43, 0x04}};
const GUID IID_IDXGISwapChain = {
    0x310d36a0, 0xd2e7, 0x4c0a, {0xaa, 0x04, 0x6a, 0x9d, 0x23, 0xb8, 0x88, 0x6a}};
const GUID IID_IDXGISwapChain3 = {
    0x94d99bdb, 0xf1f8, 0x4ab0, {0xb2, 0x36, 0x7d, 0xa0, 0x17, 0x0e, 0xda, 0xb1}};
const GUID IID_IDXGIFactory4 = {
    0x1bc6ea02, 0xef36, 0x464f, {0xbf, 0x0c, 0x21, 0xca, 0x39, 0xe5, 0x16, 0x8a}};
const GUID IID_ID3D12GraphicsCommandList = {
    0x5b160d0f, 0xac1b, 0x4185, {0x8b, 0xa8, 0xb3, 0xae, 0x42, 0xa5, 0xa4, 0x55}};
const GUID IID_ID3D12CommandQueue = {
    0x0ec870a6, 0x5d7e, 0x4c22, {0x8c, 0xfc, 0x5b, 0xaa, 0xe0, 0x76, 0x16, 0xed}};
const GUID IID_ID3D12Device = {
    0x189819f1, 0x1db6, 0x4b57, {0xbe, 0x54, 0x18, 0x21, 0x33, 0x9b, 0x85, 0xf7}};
const GUID IID_ID3D12DescriptorHeap = {
    0x8efb471d, 0x616c, 0x4f49, {0x90, 0xf7, 0x12, 0x7b, 0xb7, 0x63, 0xfa, 0x51}};
const GUID IID_ID3D12Resource = {
    0x696442be, 0xa72e, 0x4059, {0xbc, 0x79, 0x5b, 0x5c, 0x98, 0x04, 0x0f, 0xad}};
const GUID IID_ID3D12RootSignature = {
    0xc54a6b66, 0x72df, 0x4ee8, {0x8b, 0xe5, 0xa9, 0x46, 0xa1, 0x42, 0x92, 0x14}};
const GUID IID_ID3D12CommandAllocator = {
    0x6102dee4, 0xaf59, 0x4b09, {0xb9, 0x99, 0xb4, 0x4d, 0x73, 0xf0, 0x9b, 0x24}};
const GUID IID_ID3D12Fence = {
    0x0a753dcf, 0xc4d8, 0x4b91, {0xad, 0xf6, 0xbe, 0x5a, 0x60, 0xd9, 0x5a, 0x76}};
const GUID IID_ID3D12PipelineState = {
    0x765a30f3, 0xf624, 0x4c6f, {0xa8, 0x28, 0xac, 0xe9, 0x48, 0x62, 0x24, 0x45}};

CreateDXGIFactory2_t CreateDXGIFactory2;
D3D12CreateDevice_t D3D12CreateDevice;
D3D12GetDebugInterface_t D3D12GetDebugInterface;

void mzd3d12_load_api(void) {
  MZ_ASSERT(MessageBox);

  void *__stdcall LoadLibraryA(const char *dll_name);
  void *__stdcall GetProcAddress(void *dll, const char *proc);

  void *d3d12_dll = LoadLibraryA("d3d12.dll");
  if (!d3d12_dll) {
    MessageBox(NULL,
               "Program requires Windows 10 machine with DirectX 12 support "
               "(D3D_FEATURE_LEVEL_11_1 or better).",
               "Error", 0);
    ExitProcess(1);
  }
  D3D12CreateDevice = (D3D12CreateDevice_t)GetProcAddress(d3d12_dll, "D3D12CreateDevice");
  D3D12GetDebugInterface =
      (D3D12GetDebugInterface_t)GetProcAddress(d3d12_dll, "D3D12GetDebugInterface");

  void *dxgi_dll = LoadLibraryA("dxgi.dll");
  CreateDXGIFactory2 = (CreateDXGIFactory2_t)GetProcAddress(dxgi_dll, "CreateDXGIFactory2");
}

#undef MZ_D3D12_IMPLEMENTATION
#endif // #ifdef MZ_D3D12_IMPLEMENTATION