package vendor:directx/d3d12

Source

AUTO_BREADCRUMB_NODE :: struct {
	pCommandListDebugNameA:  cstring,
	pCommandListDebugNameW:  [^]u16,
	pCommandQueueDebugNameA: cstring,
	pCommandQueueDebugNameW: [^]u16,
	pCommandList:            ^IGraphicsCommandList,
	pCommandQueue:           ^ICommandQueue,
	BreadcrumbCount:         u32,
	pLastBreadcrumbValue:    ^u32,
	pCommandHistory:         ^AUTO_BREADCRUMB_OP,
	pNext:                   ^AUTO_BREADCRUMB_NODE,
}

AUTO_BREADCRUMB_NODE1 :: struct {
	pCommandListDebugNameA:  cstring,
	pCommandListDebugNameW:  [^]u16,
	pCommandQueueDebugNameA: cstring,
	pCommandQueueDebugNameW: [^]u16,
	pCommandList:            ^IGraphicsCommandList,
	pCommandQueue:           ^ICommandQueue,
	BreadcrumbCount:         u32,
	pLastBreadcrumbValue:    ^u32,
	pCommandHistory:         ^AUTO_BREADCRUMB_OP,
	pNext:                   ^AUTO_BREADCRUMB_NODE1,
	BreadcrumbContextsCount: u32,
	pBreadcrumbContexts:     ^DRED_BREADCRUMB_CONTEXT,
}

AUTO_BREADCRUMB_OP :: enum i32 {
	SETMARKER                                        = 0, 
	BEGINEVENT                                       = 1, 
	ENDEVENT                                         = 2, 
	DRAWINSTANCED                                    = 3, 
	DRAWINDEXEDINSTANCED                             = 4, 
	EXECUTEINDIRECT                                  = 5, 
	DISPATCH                                         = 6, 
	COPYBUFFERREGION                                 = 7, 
	COPYTEXTUREREGION                                = 8, 
	COPYRESOURCE                                     = 9, 
	COPYTILES                                        = 10, 
	RESOLVESUBRESOURCE                               = 11, 
	CLEARRENDERTARGETVIEW                            = 12, 
	CLEARUNORDEREDACCESSVIEW                         = 13, 
	CLEARDEPTHSTENCILVIEW                            = 14, 
	RESOURCEBARRIER                                  = 15, 
	EXECUTEBUNDLE                                    = 16, 
	PRESENT                                          = 17, 
	RESOLVEQUERYDATA                                 = 18, 
	BEGINSUBMISSION                                  = 19, 
	ENDSUBMISSION                                    = 20, 
	DECODEFRAME                                      = 21, 
	PROCESSFRAMES                                    = 22, 
	ATOMICCOPYBUFFERUINT                             = 23, 
	ATOMICCOPYBUFFERUINT64                           = 24, 
	RESOLVESUBRESOURCEREGION                         = 25, 
	WRITEBUFFERIMMEDIATE                             = 26, 
	DECODEFRAME1                                     = 27, 
	SETPROTECTEDRESOURCESESSION                      = 28, 
	DECODEFRAME2                                     = 29, 
	PROCESSFRAMES1                                   = 30, 
	BUILDRAYTRACINGACCELERATIONSTRUCTURE             = 31, 
	EMITRAYTRACINGACCELERATIONSTRUCTUREPOSTBUILDINFO = 32, 
	COPYRAYTRACINGACCELERATIONSTRUCTURE              = 33, 
	DISPATCHRAYS                                     = 34, 
	INITIALIZEMETACOMMAND                            = 35, 
	EXECUTEMETACOMMAND                               = 36, 
	ESTIMATEMOTION                                   = 37, 
	RESOLVEMOTIONVECTORHEAP                          = 38, 
	SETPIPELINESTATE1                                = 39, 
	INITIALIZEEXTENSIONCOMMAND                       = 40, 
	EXECUTEEXTENSIONCOMMAND                          = 41, 
	DISPATCHMESH                                     = 42, 
	ENCODEFRAME                                      = 43, 
	RESOLVEENCODEROUTPUTMETADATA                     = 44, 
}

AXIS_SHADING_RATE :: enum i32 {
	_1X = 0, 
	_2X = 1, 
	_4X = 2, 
}

BACKGROUND_PROCESSING_MODE :: enum i32 {
	ALLOWED                      = 0, 
	ALLOW_INTRUSIVE_MEASUREMENTS = 1, 
	DISABLE_BACKGROUND_WORK      = 2, 
	DISABLE_PROFILING_BY_SYSTEM  = 3, 
}

BLEND :: enum i32 {
	ZERO             = 1, 
	ONE              = 2, 
	SRC_COLOR        = 3, 
	INV_SRC_COLOR    = 4, 
	SRC_ALPHA        = 5, 
	INV_SRC_ALPHA    = 6, 
	DEST_ALPHA       = 7, 
	INV_DEST_ALPHA   = 8, 
	DEST_COLOR       = 9, 
	INV_DEST_COLOR   = 10, 
	SRC_ALPHA_SAT    = 11, 
	BLEND_FACTOR     = 14, 
	INV_BLEND_FACTOR = 15, 
	SRC1_COLOR       = 16, 
	INV_SRC1_COLOR   = 17, 
	SRC1_ALPHA       = 18, 
	INV_SRC1_ALPHA   = 19, 
}

BLEND_DESC :: struct {
	AlphaToCoverageEnable:  sys_windows.BOOL,
	IndependentBlendEnable: sys_windows.BOOL,
	RenderTarget:           [8]RENDER_TARGET_BLEND_DESC,
}

BLEND_OP :: enum i32 {
	ADD          = 1, 
	SUBTRACT     = 2, 
	REV_SUBTRACT = 3, 
	MIN          = 4, 
	MAX          = 5, 
}

BOOL :: sys_windows.BOOL

BOX :: struct {
	left:   u32,
	top:    u32,
	front:  u32,
	right:  u32,
	bottom: u32,
	back:   u32,
}

BUFFER_RTV :: struct {
	FirstElement: u64,
	NumElements:  u32,
}

BUFFER_SRV :: struct {
	FirstElement:        u64,
	NumElements:         u32,
	StructureByteStride: u32,
	Flags:               BUFFER_SRV_FLAGS,
}

BUFFER_SRV_FLAG :: enum u32 {
	RAW = 0, 
}

BUFFER_SRV_FLAGS :: distinct bit_set[BUFFER_SRV_FLAG; u32]

BUFFER_UAV :: struct {
	FirstElement:         u64,
	NumElements:          u32,
	StructureByteStride:  u32,
	CounterOffsetInBytes: u64,
	Flags:                BUFFER_UAV_FLAGS,
}

BUFFER_UAV_FLAG :: enum u32 {
	RAW = 0, 
}

BUFFER_UAV_FLAGS :: distinct bit_set[BUFFER_UAV_FLAG; u32]

BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC :: struct {
	DestAccelerationStructureData:    u64,
	Inputs:                           BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS,
	SourceAccelerationStructureData:  u64,
	ScratchAccelerationStructureData: u64,
}

BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS :: struct {
	Type:        RAYTRACING_ACCELERATION_STRUCTURE_TYPE,
	Flags:       RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS,
	NumDescs:    u32,
	DescsLayout: ELEMENTS_LAYOUT,
	using _:     struct #raw_union {
		InstanceDescs:   u64,
		pGeometryDescs:  ^RAYTRACING_GEOMETRY_DESC,
		ppGeometryDescs: [^]^RAYTRACING_GEOMETRY_DESC,
	},
}

BUILD_RAYTRACING_ACCELERATION_STRUCTURE_TOOLS_VISUALIZATION_HEADER :: struct {
	Type:     RAYTRACING_ACCELERATION_STRUCTURE_TYPE,
	NumDescs: u32,
}

CACHED_PIPELINE_STATE :: struct {
	pCachedBlob:           rawptr,
	CachedBlobSizeInBytes: uint,
}

CBUFFER_TYPE :: enum i32 {
	CBUFFER            = 0, 
	TBUFFER            = 1, 
	INTERFACE_POINTERS = 2, 
	RESOURCE_BIND_INFO = 3, 
}

CLEAR_FLAG :: enum u32 {
	DEPTH   = 0, 
	STENCIL = 1, 
}

CLEAR_FLAGS :: distinct bit_set[CLEAR_FLAG; u32]

CLEAR_VALUE :: struct {
	Format: directx_dxgi.FORMAT,
	using _: struct #raw_union {
		Color:        [4]f32,
		DepthStencil: DEPTH_STENCIL_VALUE,
	},
}

COLOR_WRITE_ENABLE :: enum i32 {
	RED   = 0, 
	GREEN = 1, 
	BLUE  = 2, 
	ALPHA = 3, 
}

COLOR_WRITE_ENABLE_MASK :: distinct bit_set[COLOR_WRITE_ENABLE; u32]

COMMAND_LIST_FLAG :: enum u32 {
}

COMMAND_LIST_FLAGS :: distinct bit_set[COMMAND_LIST_FLAG; u32]

COMMAND_LIST_SUPPORT_FLAG :: enum u32 {
	DIRECT        = 0, 
	BUNDLE        = 1, 
	COMPUTE       = 2, 
	COPY          = 3, 
	VIDEO_DECODE  = 4, 
	VIDEO_PROCESS = 5, 
	VIDEO_ENCODE  = 6, 
}

COMMAND_LIST_SUPPORT_FLAGS :: distinct bit_set[COMMAND_LIST_SUPPORT_FLAG; u32]

COMMAND_LIST_TYPE :: enum i32 {
	DIRECT        = 0, 
	BUNDLE        = 1, 
	COMPUTE       = 2, 
	COPY          = 3, 
	VIDEO_DECODE  = 4, 
	VIDEO_PROCESS = 5, 
	VIDEO_ENCODE  = 6, 
}

COMMAND_POOL_FLAG :: enum u32 {
}

COMMAND_POOL_FLAGS :: distinct bit_set[COMMAND_POOL_FLAG; u32]

COMMAND_QUEUE_DESC :: struct {
	Type:     COMMAND_LIST_TYPE,
	Priority: i32,
	Flags:    COMMAND_QUEUE_FLAGS,
	NodeMask: u32,
}

COMMAND_QUEUE_FLAG :: enum u32 {
	DISABLE_GPU_TIMEOUT = 0, 
}

COMMAND_QUEUE_FLAGS :: distinct bit_set[COMMAND_QUEUE_FLAG; u32]

COMMAND_QUEUE_PRIORITY :: enum i32 {
	NORMAL          = 0, 
	HIGH            = 100, 
	GLOBAL_REALTIME = 10000, 
}

COMMAND_RECORDER_FLAG :: enum u32 {
}

COMMAND_RECORDER_FLAGS :: distinct bit_set[COMMAND_RECORDER_FLAG; u32]

COMMAND_SIGNATURE_DESC :: struct {
	ByteStride:       u32,
	NumArgumentDescs: u32,
	pArgumentDescs:   ^INDIRECT_ARGUMENT_DESC,
	NodeMask:         u32,
}

COMPARISON_FUNC :: enum i32 {
	NEVER         = 1, 
	LESS          = 2, 
	EQUAL         = 3, 
	LESS_EQUAL    = 4, 
	GREATER       = 5, 
	NOT_EQUAL     = 6, 
	GREATER_EQUAL = 7, 
	ALWAYS        = 8, 
}

COMPUTE_PIPELINE_STATE_DESC :: struct {
	pRootSignature: ^IRootSignature,
	CS:             SHADER_BYTECODE,
	NodeMask:       u32,
	CachedPSO:      CACHED_PIPELINE_STATE,
	Flags:          PIPELINE_STATE_FLAGS,
}

CONSERVATIVE_RASTERIZATION_MODE :: enum i32 {
	OFF = 0, 
	ON  = 1, 
}

CONSERVATIVE_RASTERIZATION_TIER :: enum i32 {
	NOT_SUPPORTED = 0, 
	_1            = 1, 
	_2            = 2, 
	_3            = 3, 
}

CONSTANT_BUFFER_VIEW_DESC :: struct {
	BufferLocation: u64,
	SizeInBytes:    u32,
}

CPU_DESCRIPTOR_HANDLE :: struct {
	ptr: uint,
}

CPU_PAGE_PROPERTY :: enum i32 {
	UNKNOWN       = 0, 
	NOT_AVAILABLE = 1, 
	WRITE_COMBINE = 2, 
	WRITE_BACK    = 3, 
}

CROSS_NODE_SHARING_TIER :: enum i32 {
	NOT_SUPPORTED = 0, 
	_1_EMULATED   = 1, 
	_1            = 2, 
	_2            = 3, 
	_3            = 4, 
}

CULL_MODE :: enum i32 {
	NONE  = 1, 
	FRONT = 2, 
	BACK  = 3, 
}

DEBUG_COMMAND_LIST_GPU_BASED_VALIDATION_SETTINGS :: struct {
	ShaderPatchMode: GPU_BASED_VALIDATION_SHADER_PATCH_MODE,
}

DEBUG_COMMAND_LIST_PARAMETER_TYPE :: enum i32 {
	DEBUG_COMMAND_LIST_PARAMETER_GPU_BASED_VALIDATION_SETTINGS = 0, 
}

DEBUG_DEVICE_GPU_BASED_VALIDATION_SETTINGS :: struct {
	MaxMessagesPerCommandList: u32,
	DefaultShaderPatchMode:    GPU_BASED_VALIDATION_SHADER_PATCH_MODE,
	PipelineStateCreateFlags:  GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS,
}

DEBUG_DEVICE_GPU_SLOWDOWN_PERFORMANCE_FACTOR :: struct {
	SlowdownFactor: f32,
}

DEBUG_DEVICE_PARAMETER_TYPE :: enum i32 {
	FEATURE_FLAGS                   = 0, 
	GPU_BASED_VALIDATION_SETTINGS   = 1, 
	GPU_SLOWDOWN_PERFORMANCE_FACTOR = 2, 
}

DEBUG_FEATURE :: distinct bit_set[DEBUG_FEATURE_FLAG; u32]

DEBUG_FEATURE_FLAG :: enum i32 {
	ALLOW_BEHAVIOR_CHANGING_DEBUG_AIDS     = 0, 
	CONSERVATIVE_RESOURCE_STATE_TRACKING   = 1, 
	DISABLE_VIRTUALIZED_BUNDLES_VALIDATION = 2, 
	EMULATE_WINDOWS7                       = 3, 
}

DEPTH_STENCILOP_DESC :: struct {
	StencilFailOp:      STENCIL_OP,
	StencilDepthFailOp: STENCIL_OP,
	StencilPassOp:      STENCIL_OP,
	StencilFunc:        COMPARISON_FUNC,
}

DEPTH_STENCIL_DESC :: struct {
	DepthEnable:      sys_windows.BOOL,
	DepthWriteMask:   DEPTH_WRITE_MASK,
	DepthFunc:        COMPARISON_FUNC,
	StencilEnable:    sys_windows.BOOL,
	StencilReadMask:  u8,
	StencilWriteMask: u8,
	FrontFace:        DEPTH_STENCILOP_DESC,
	BackFace:         DEPTH_STENCILOP_DESC,
}

DEPTH_STENCIL_DESC1 :: struct {
	DepthEnable:           sys_windows.BOOL,
	DepthWriteMask:        DEPTH_WRITE_MASK,
	DepthFunc:             COMPARISON_FUNC,
	StencilEnable:         sys_windows.BOOL,
	StencilReadMask:       u8,
	StencilWriteMask:      u8,
	FrontFace:             DEPTH_STENCILOP_DESC,
	BackFace:              DEPTH_STENCILOP_DESC,
	DepthBoundsTestEnable: sys_windows.BOOL,
}

DEPTH_STENCIL_VALUE :: struct {
	Depth:   f32,
	Stencil: u8,
}

DEPTH_STENCIL_VIEW_DESC :: struct {
	Format:        directx_dxgi.FORMAT,
	ViewDimension: DSV_DIMENSION,
	Flags:         DSV_FLAGS,
	using _:       struct #raw_union {
		Texture1D:        TEX1D_DSV,
		Texture1DArray:   TEX1D_ARRAY_DSV,
		Texture2D:        TEX2D_DSV,
		Texture2DArray:   TEX2D_ARRAY_DSV,
		Texture2DMS:      TEX2DMS_DSV,
		Texture2DMSArray: TEX2DMS_ARRAY_DSV,
	},
}

DEPTH_WRITE_MASK :: enum i32 {
	ZERO = 0, 
	ALL  = 1, 
}

DESCRIPTOR_HEAP_DESC :: struct {
	Type:           DESCRIPTOR_HEAP_TYPE,
	NumDescriptors: u32,
	Flags:          DESCRIPTOR_HEAP_FLAGS,
	NodeMask:       u32,
}

DESCRIPTOR_HEAP_FLAG :: enum u32 {
	SHADER_VISIBLE = 0, 
}

DESCRIPTOR_HEAP_FLAGS :: distinct bit_set[DESCRIPTOR_HEAP_FLAG; u32]

DESCRIPTOR_HEAP_TYPE :: enum i32 {
	CBV_SRV_UAV = 0, 
	SAMPLER     = 1, 
	RTV         = 2, 
	DSV         = 3, 
}

DESCRIPTOR_RANGE :: struct {
	RangeType:                         DESCRIPTOR_RANGE_TYPE,
	NumDescriptors:                    u32,
	BaseShaderRegister:                u32,
	RegisterSpace:                     u32,
	OffsetInDescriptorsFromTableStart: u32,
}

DESCRIPTOR_RANGE1 :: struct {
	RangeType:                         DESCRIPTOR_RANGE_TYPE,
	NumDescriptors:                    u32,
	BaseShaderRegister:                u32,
	RegisterSpace:                     u32,
	Flags:                             DESCRIPTOR_RANGE_FLAGS,
	OffsetInDescriptorsFromTableStart: u32,
}

DESCRIPTOR_RANGE_FLAG :: enum u32 {
	DESCRIPTORS_VOLATILE                            = 0, 
	DATA_VOLATILE                                   = 1, 
	DATA_STATIC_WHILE_SET_AT_EXECUTE                = 2, 
	DATA_STATIC                                     = 3, 
	DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS = 16, 
}

DESCRIPTOR_RANGE_FLAGS :: distinct bit_set[DESCRIPTOR_RANGE_FLAG; u32]

DESCRIPTOR_RANGE_TYPE :: enum i32 {
	SRV     = 0, 
	UAV     = 1, 
	CBV     = 2, 
	SAMPLER = 3, 
}

DEVICE_REMOVED_EXTENDED_DATA :: struct {
	Flags:                   DRED_FLAGS,
	pHeadAutoBreadcrumbNode: ^AUTO_BREADCRUMB_NODE,
}

DEVICE_REMOVED_EXTENDED_DATA1 :: struct {
	DeviceRemovedReason:   sys_windows.HRESULT,
	AutoBreadcrumbsOutput: DRED_AUTO_BREADCRUMBS_OUTPUT,
	PageFaultOutput:       DRED_PAGE_FAULT_OUTPUT,
}

DEVICE_REMOVED_EXTENDED_DATA2 :: struct {
	DeviceRemovedReason:   sys_windows.HRESULT,
	AutoBreadcrumbsOutput: DRED_AUTO_BREADCRUMBS_OUTPUT1,
	PageFaultOutput:       DRED_PAGE_FAULT_OUTPUT1,
}

DEVICE_REMOVED_EXTENDED_DATA3 :: struct {
	DeviceRemovedReason:   sys_windows.HRESULT,
	AutoBreadcrumbsOutput: DRED_AUTO_BREADCRUMBS_OUTPUT1,
	PageFaultOutput:       DRED_PAGE_FAULT_OUTPUT2,
	DeviceState:           DRED_DEVICE_STATE,
}

DISCARD_REGION :: struct {
	NumRects:         u32,
	pRects:           ^sys_windows.RECT,
	FirstSubresource: u32,
	NumSubresources:  u32,
}

DISPATCH_ARGUMENTS :: struct {
	ThreadGroupCountX: u32,
	ThreadGroupCountY: u32,
	ThreadGroupCountZ: u32,
}

DISPATCH_MESH_ARGUMENTS :: struct {
	ThreadGroupCountX: u32,
	ThreadGroupCountY: u32,
	ThreadGroupCountZ: u32,
}

DISPATCH_RAYS_DESC :: struct {
	RayGenerationShaderRecord: GPU_VIRTUAL_ADDRESS_RANGE,
	MissShaderTable:           GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE,
	HitGroupTable:             GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE,
	CallableShaderTable:       GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE,
	Width:                     u32,
	Height:                    u32,
	Depth:                     u32,
}

DRAW_ARGUMENTS :: struct {
	VertexCountPerInstance: u32,
	InstanceCount:          u32,
	StartVertexLocation:    u32,
	StartInstanceLocation:  u32,
}

DRAW_INDEXED_ARGUMENTS :: struct {
	IndexCountPerInstance: u32,
	InstanceCount:         u32,
	StartIndexLocation:    u32,
	BaseVertexLocation:    i32,
	StartInstanceLocation: u32,
}

DRED_ALLOCATION_NODE :: struct {
	ObjectNameA:    cstring,
	ObjectNameW:    ^i16,
	AllocationType: DRED_ALLOCATION_TYPE,
	pNext:          ^DRED_ALLOCATION_NODE,
}

DRED_ALLOCATION_NODE1 :: struct {
	ObjectNameA:    cstring,
	ObjectNameW:    ^i16,
	AllocationType: DRED_ALLOCATION_TYPE,
	pNext:          ^DRED_ALLOCATION_NODE1,
	pObject:        ^sys_windows.IUnknown,
}

DRED_ALLOCATION_TYPE :: enum i32 {
	COMMAND_QUEUE            = 19, 
	COMMAND_ALLOCATOR        = 20, 
	PIPELINE_STATE           = 21, 
	COMMAND_LIST             = 22, 
	FENCE                    = 23, 
	DESCRIPTOR_HEAP          = 24, 
	HEAP                     = 25, 
	QUERY_HEAP               = 27, 
	COMMAND_SIGNATURE        = 28, 
	PIPELINE_LIBRARY         = 29, 
	VIDEO_DECODER            = 30, 
	VIDEO_PROCESSOR          = 32, 
	RESOURCE                 = 34, 
	PASS                     = 35, 
	CRYPTOSESSION            = 36, 
	CRYPTOSESSIONPOLICY      = 37, 
	PROTECTEDRESOURCESESSION = 38, 
	VIDEO_DECODER_HEAP       = 39, 
	COMMAND_POOL             = 40, 
	COMMAND_RECORDER         = 41, 
	STATE_OBJECT             = 42, 
	METACOMMAND              = 43, 
	SCHEDULINGGROUP          = 44, 
	VIDEO_MOTION_ESTIMATOR   = 45, 
	VIDEO_MOTION_VECTOR_HEAP = 46, 
	VIDEO_EXTENSION_COMMAND  = 47, 
	VIDEO_ENCODER            = 48, 
	VIDEO_ENCODER_HEAP       = 49, 
	INVALID                  = -1, 
}

DRED_AUTO_BREADCRUMBS_OUTPUT :: struct {
	pHeadAutoBreadcrumbNode: ^AUTO_BREADCRUMB_NODE,
}

DRED_AUTO_BREADCRUMBS_OUTPUT1 :: struct {
	pHeadAutoBreadcrumbNode: ^AUTO_BREADCRUMB_NODE1,
}

DRED_BREADCRUMB_CONTEXT :: struct {
	BreadcrumbIndex: u32,
	pContextString:  [^]u16,
}

DRED_DEVICE_STATE :: enum i32 {
	UNKNOWN   = 0, 
	HUNG      = 3, 
	FAULT     = 6, 
	PAGEFAULT = 7, 
}

DRED_ENABLEMENT :: enum i32 {
	SYSTEM_CONTROLLED = 0, 
	FORCED_OFF        = 1, 
	FORCED_ON         = 2, 
}

DRED_FLAG :: enum u32 {
	FORCE_ENABLE            = 0, 
	DISABLE_AUTOBREADCRUMBS = 1, 
}

DRED_FLAGS :: distinct bit_set[DRED_FLAG; u32]

DRED_PAGE_FAULT_FLAG :: enum u32 {
}

DRED_PAGE_FAULT_FLAGS :: bit_set[DRED_PAGE_FAULT_FLAG; u32]

DRED_PAGE_FAULT_OUTPUT :: struct {
	PageFaultVA:                    u64,
	pHeadExistingAllocationNode:    ^DRED_ALLOCATION_NODE,
	pHeadRecentFreedAllocationNode: ^DRED_ALLOCATION_NODE,
}

DRED_PAGE_FAULT_OUTPUT1 :: struct {
	PageFaultVA:                    u64,
	pHeadExistingAllocationNode:    ^DRED_ALLOCATION_NODE1,
	pHeadRecentFreedAllocationNode: ^DRED_ALLOCATION_NODE1,
}

DRED_PAGE_FAULT_OUTPUT2 :: struct {
	PageFaultVA:                    u64,
	pHeadExistingAllocationNode:    ^DRED_ALLOCATION_NODE1,
	pHeadRecentFreedAllocationNode: ^DRED_ALLOCATION_NODE1,
	PageFaultFlags:                 bit_set[DRED_PAGE_FAULT_FLAG; u32],
}

DRED_VERSION :: enum i32 {
	_1_0 = 1, 
	_1_1 = 2, 
	_1_2 = 3, 
	_1_3 = 4, 
}

DRIVER_MATCHING_IDENTIFIER_STATUS :: enum i32 {
	COMPATIBLE_WITH_DEVICE = 0, 
	UNSUPPORTED_TYPE       = 1, 
	UNRECOGNIZED           = 2, 
	INCOMPATIBLE_VERSION   = 3, 
	INCOMPATIBLE_TYPE      = 4, 
}

DRIVER_TYPE :: enum i32 {
	UNKNOWN   = 0, 
	HARDWARE  = 1, 
	REFERENCE = 2, 
	NULL      = 3, 
	SOFTWARE  = 4, 
	WARP      = 5, 
}

DSV_DIMENSION :: enum i32 {
	UNKNOWN          = 0, 
	TEXTURE1D        = 1, 
	TEXTURE1DARRAY   = 2, 
	TEXTURE2D        = 3, 
	TEXTURE2DARRAY   = 4, 
	TEXTURE2DMS      = 5, 
	TEXTURE2DMSARRAY = 6, 
}

DSV_FLAG :: enum u32 {
	READ_ONLY_DEPTH   = 0, 
	READ_ONLY_STENCIL = 1, 
}

DSV_FLAGS :: distinct bit_set[DSV_FLAG; u32]

DXIL_LIBRARY_DESC :: struct {
	DXILLibrary: SHADER_BYTECODE,
	NumExports:  u32,
	pExports:    ^EXPORT_DESC,
}

DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION :: struct {
	SubobjectToAssociate: ^i16,
	NumExports:           u32,
	pExports:             [^]^i16,
}

ELEMENTS_LAYOUT :: enum i32 {
	ARRAY             = 0, 
	ARRAY_OF_POINTERS = 1, 
}

EXISTING_COLLECTION_DESC :: struct {
	pExistingCollection: ^IStateObject,
	NumExports:          u32,
	pExports:            ^EXPORT_DESC,
}

EXPORT_DESC :: struct {
	Name:           [^]u16,
	ExportToRename: [^]u16,
	Flags:          EXPORT_FLAGS,
}

EXPORT_FLAG :: enum u32 {
}

EXPORT_FLAGS :: distinct bit_set[EXPORT_FLAG; u32]

FEATURE :: enum i32 {
	OPTIONS                               = 0, 
	ARCHITECTURE                          = 1, 
	FEATURE_LEVELS                        = 2, 
	FORMAT_SUPPORT                        = 3, 
	MULTISAMPLE_QUALITY_LEVELS            = 4, 
	FORMAT_INFO                           = 5, 
	GPU_VIRTUAL_ADDRESS_SUPPORT           = 6, 
	SHADER_MODEL                          = 7, 
	OPTIONS1                              = 8, 
	PROTECTED_RESOURCE_SESSION_SUPPORT    = 10, 
	ROOT_SIGNATURE                        = 12, 
	ARCHITECTURE1                         = 16, 
	OPTIONS2                              = 18, 
	SHADER_CACHE                          = 19, 
	COMMAND_QUEUE_PRIORITY                = 20, 
	OPTIONS3                              = 21, 
	EXISTING_HEAPS                        = 22, 
	OPTIONS4                              = 23, 
	SERIALIZATION                         = 24, 
	CROSS_NODE                            = 25, 
	OPTIONS5                              = 27, 
	OPTIONS6                              = 30, 
	QUERY_META_COMMAND                    = 31, 
	OPTIONS7                              = 32, 
	PROTECTED_RESOURCE_SESSION_TYPE_COUNT = 33, 
	PROTECTED_RESOURCE_SESSION_TYPES      = 34, 
	OPTIONS8                              = 36, 
	OPTIONS9                              = 37, 
	WAVE_MMA                              = 38, 
}

FEATURE_DATA_ARCHITECTURE :: struct {
	NodeIndex:         u32,
	TileBasedRenderer: sys_windows.BOOL,
	UMA:               sys_windows.BOOL,
	CacheCoherentUMA:  sys_windows.BOOL,
}

FEATURE_DATA_ARCHITECTURE1 :: struct {
	NodeIndex:         u32,
	TileBasedRenderer: sys_windows.BOOL,
	UMA:               sys_windows.BOOL,
	CacheCoherentUMA:  sys_windows.BOOL,
	IsolatedMMU:       sys_windows.BOOL,
}

FEATURE_DATA_COMMAND_QUEUE_PRIORITY :: struct {
	CommandListType:            COMMAND_LIST_TYPE,
	Priority:                   u32,
	PriorityForTypeIsSupported: sys_windows.BOOL,
}

FEATURE_DATA_CROSS_NODE :: struct {
	SharingTier:              CROSS_NODE_SHARING_TIER,
	AtomicShaderInstructions: sys_windows.BOOL,
}

FEATURE_DATA_EXISTING_HEAPS :: struct {
	Supported: sys_windows.BOOL,
}

FEATURE_DATA_FEATURE_LEVELS :: struct {
	NumFeatureLevels:         u32,
	pFeatureLevelsRequested:  ^FEATURE_LEVEL,
	MaxSupportedFeatureLevel: FEATURE_LEVEL,
}

FEATURE_DATA_FORMAT_INFO :: struct {
	Format:     directx_dxgi.FORMAT,
	PlaneCount: u8,
}

FEATURE_DATA_FORMAT_SUPPORT :: struct {
	Format:   directx_dxgi.FORMAT,
	Support1: FORMAT_SUPPORT1,
	Support2: FORMAT_SUPPORT2,
}

FEATURE_DATA_GPU_VIRTUAL_ADDRESS_SUPPORT :: struct {
	MaxGPUVirtualAddressBitsPerResource: u32,
	MaxGPUVirtualAddressBitsPerProcess:  u32,
}

FEATURE_DATA_MULTISAMPLE_QUALITY_LEVELS :: struct {
	Format:           directx_dxgi.FORMAT,
	SampleCount:      u32,
	Flags:            MULTISAMPLE_QUALITY_LEVEL_FLAGS,
	NumQualityLevels: u32,
}

FEATURE_DATA_OPTIONS :: struct {
	DoublePrecisionFloatShaderOps:                                              sys_windows.BOOL,
	OutputMergerLogicOp:                                                        sys_windows.BOOL,
	MinPrecisionSupport:                                                        SHADER_MIN_PRECISION_SUPPORT,
	TiledResourcesTier:                                                         TILED_RESOURCES_TIER,
	ResourceBindingTier:                                                        RESOURCE_BINDING_TIER,
	PSSpecifiedStencilRefSupported:                                             sys_windows.BOOL,
	TypedUAVLoadAdditionalFormats:                                              sys_windows.BOOL,
	ROVsSupported:                                                              sys_windows.BOOL,
	ConservativeRasterizationTier:                                              CONSERVATIVE_RASTERIZATION_TIER,
	MaxGPUVirtualAddressBitsPerResource:                                        u32,
	StandardSwizzle64KBSupported:                                               sys_windows.BOOL,
	CrossNodeSharingTier:                                                       CROSS_NODE_SHARING_TIER,
	CrossAdapterRowMajorTextureSupported:                                       sys_windows.BOOL,
	VPAndRTArrayIndexFromAnyShaderFeedingRasterizerSupportedWithoutGSEmulation: sys_windows.BOOL,
	ResourceHeapTier:                                                           RESOURCE_HEAP_TIER,
}

FEATURE_DATA_OPTIONS1 :: struct {
	WaveOps:                       sys_windows.BOOL,
	WaveLaneCountMin:              u32,
	WaveLaneCountMax:              u32,
	TotalLaneCount:                u32,
	ExpandedComputeResourceStates: sys_windows.BOOL,
	Int64ShaderOps:                sys_windows.BOOL,
}

FEATURE_DATA_OPTIONS2 :: struct {
	DepthBoundsTestSupported:        sys_windows.BOOL,
	ProgrammableSamplePositionsTier: PROGRAMMABLE_SAMPLE_POSITIONS_TIER,
}

FEATURE_DATA_OPTIONS3 :: struct {
	CopyQueueTimestampQueriesSupported: sys_windows.BOOL,
	CastingFullyTypedFormatSupported:   sys_windows.BOOL,
	WriteBufferImmediateSupportFlags:   COMMAND_LIST_SUPPORT_FLAGS,
	ViewInstancingTier:                 VIEW_INSTANCING_TIER,
	BarycentricsSupported:              sys_windows.BOOL,
}

FEATURE_DATA_OPTIONS4 :: struct {
	MSAA64KBAlignedTextureSupported: sys_windows.BOOL,
	SharedResourceCompatibilityTier: SHARED_RESOURCE_COMPATIBILITY_TIER,
	Native16BitShaderOpsSupported:   sys_windows.BOOL,
}

FEATURE_DATA_OPTIONS5 :: struct {
	SRVOnlyTiledResourceTier3: sys_windows.BOOL,
	RenderPassesTier:          RENDER_PASS_TIER,
	RaytracingTier:            RAYTRACING_TIER,
}

FEATURE_DATA_OPTIONS6 :: struct {
	AdditionalShadingRatesSupported:                      sys_windows.BOOL,
	PerPrimitiveShadingRateSupportedWithViewportIndexing: sys_windows.BOOL,
	VariableShadingRateTier:                              VARIABLE_SHADING_RATE_TIER,
	ShadingRateImageTileSize:                             u32,
	BackgroundProcessingSupported:                        sys_windows.BOOL,
}

FEATURE_DATA_OPTIONS7 :: struct {
	MeshShaderTier:      MESH_SHADER_TIER,
	SamplerFeedbackTier: SAMPLER_FEEDBACK_TIER,
}

FEATURE_DATA_OPTIONS8 :: struct {
	UnalignedBlockTexturesSupported: sys_windows.BOOL,
}

FEATURE_DATA_OPTIONS9 :: struct {
	MeshShaderPipelineStatsSupported:                  sys_windows.BOOL,
	MeshShaderSupportsFullRangeRenderTargetArrayIndex: sys_windows.BOOL,
	AtomicInt64OnTypedResourceSupported:               sys_windows.BOOL,
	AtomicInt64OnGroupSharedSupported:                 sys_windows.BOOL,
	DerivativesInMeshAndAmplificationShadersSupported: sys_windows.BOOL,
	WaveMMATier:                                       WAVE_MMA_TIER,
}

FEATURE_DATA_PROTECTED_RESOURCE_SESSION_SUPPORT :: struct {
	NodeIndex: u32,
	Support:   PROTECTED_RESOURCE_SESSION_SUPPORT_FLAGS,
}

FEATURE_DATA_PROTECTED_RESOURCE_SESSION_TYPES :: struct {
	NodeIndex: u32,
	Count:     u32,
	pTypes:    ^sys_windows.GUID,
}

FEATURE_DATA_PROTECTED_RESOURCE_SESSION_TYPE_COUNT :: struct {
	NodeIndex: u32,
	Count:     u32,
}

FEATURE_DATA_QUERY_META_COMMAND :: struct {
	CommandId:                  sys_windows.GUID,
	NodeMask:                   u32,
	pQueryInputData:            rawptr,
	QueryInputDataSizeInBytes:  uint,
	pQueryOutputData:           rawptr,
	QueryOutputDataSizeInBytes: uint,
}

FEATURE_DATA_ROOT_SIGNATURE :: struct {
	HighestVersion: ROOT_SIGNATURE_VERSION,
}

FEATURE_DATA_SERIALIZATION :: struct {
	NodeIndex:             u32,
	HeapSerializationTier: HEAP_SERIALIZATION_TIER,
}

FEATURE_DATA_SHADER_CACHE :: struct {
	SupportFlags: SHADER_CACHE_SUPPORT_FLAGS,
}

FEATURE_DATA_SHADER_MODEL :: struct {
	HighestShaderModel: SHADER_MODEL,
}

FEATURE_DATA_WAVE_MMA :: struct {
	InputDataType:            WAVE_MMA_INPUT_DATATYPE,
	M:                        WAVE_MMA_DIMENSION,
	N:                        WAVE_MMA_DIMENSION,
	Supported:                sys_windows.BOOL,
	K:                        u32,
	AccumDataTypes:           WAVE_MMA_ACCUM_DATATYPE,
	RequiredWaveLaneCountMin: u32,
	RequiredWaveLaneCountMax: u32,
}

FEATURE_LEVEL :: enum i32 {
	_1_0_CORE = 4096, 
	_9_1      = 37120, 
	_9_2      = 37376, 
	_9_3      = 37632, 
	_10_0     = 40960, 
	_10_1     = 41216, 
	_11_0     = 45056, 
	_11_1     = 45312, 
	_12_0     = 49152, 
	_12_1     = 49408, 
	_12_2     = 49664, 
}

FENCE_FLAG :: enum u32 {
	SHARED               = 0, 
	SHARED_CROSS_ADAPTER = 1, 
	NON_MONITORED        = 2, 
}

FENCE_FLAGS :: distinct bit_set[FENCE_FLAG; u32]

FILL_MODE :: enum i32 {
	WIREFRAME = 2, 
	SOLID     = 3, 
}

FILTER :: enum i32 {
	MIN_MAG_MIP_POINT                          = 0, 
	MIN_MAG_POINT_MIP_LINEAR                   = 1, 
	MIN_POINT_MAG_LINEAR_MIP_POINT             = 4, 
	MIN_POINT_MAG_MIP_LINEAR                   = 5, 
	MIN_LINEAR_MAG_MIP_POINT                   = 16, 
	MIN_LINEAR_MAG_POINT_MIP_LINEAR            = 17, 
	MIN_MAG_LINEAR_MIP_POINT                   = 20, 
	MIN_MAG_MIP_LINEAR                         = 21, 
	ANISOTROPIC                                = 85, 
	COMPARISON_MIN_MAG_MIP_POINT               = 128, 
	COMPARISON_MIN_MAG_POINT_MIP_LINEAR        = 129, 
	COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT  = 132, 
	COMPARISON_MIN_POINT_MAG_MIP_LINEAR        = 133, 
	COMPARISON_MIN_LINEAR_MAG_MIP_POINT        = 144, 
	COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR = 145, 
	COMPARISON_MIN_MAG_LINEAR_MIP_POINT        = 148, 
	COMPARISON_MIN_MAG_MIP_LINEAR              = 149, 
	COMPARISON_ANISOTROPIC                     = 213, 
	MINIMUM_MIN_MAG_MIP_POINT                  = 256, 
	MINIMUM_MIN_MAG_POINT_MIP_LINEAR           = 257, 
	MINIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT     = 260, 
	MINIMUM_MIN_POINT_MAG_MIP_LINEAR           = 261, 
	MINIMUM_MIN_LINEAR_MAG_MIP_POINT           = 272, 
	MINIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR    = 273, 
	MINIMUM_MIN_MAG_LINEAR_MIP_POINT           = 276, 
	MINIMUM_MIN_MAG_MIP_LINEAR                 = 277, 
	MINIMUM_ANISOTROPIC                        = 341, 
	MAXIMUM_MIN_MAG_MIP_POINT                  = 384, 
	MAXIMUM_MIN_MAG_POINT_MIP_LINEAR           = 385, 
	MAXIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT     = 388, 
	MAXIMUM_MIN_POINT_MAG_MIP_LINEAR           = 389, 
	MAXIMUM_MIN_LINEAR_MAG_MIP_POINT           = 400, 
	MAXIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR    = 401, 
	MAXIMUM_MIN_MAG_LINEAR_MIP_POINT           = 404, 
	MAXIMUM_MIN_MAG_MIP_LINEAR                 = 405, 
	MAXIMUM_ANISOTROPIC                        = 469, 
}

FILTER_REDUCTION_TYPE :: enum i32 {
	STANDARD   = 0, 
	COMPARISON = 1, 
	MINIMUM    = 2, 
	MAXIMUM    = 3, 
}

FILTER_TYPE :: enum i32 {
	POINT  = 0, 
	LINEAR = 1, 
}

FORMAT_SUPPORT1 :: distinct bit_set[FORMAT_SUPPORT1_FLAG; u32]

FORMAT_SUPPORT1_FLAG :: enum i32 {
	BUFFER                      = 0, 
	IA_VERTEX_BUFFER            = 1, 
	IA_INDEX_BUFFER             = 2, 
	SO_BUFFER                   = 3, 
	TEXTURE1D                   = 4, 
	TEXTURE2D                   = 5, 
	TEXTURE3D                   = 6, 
	TEXTURECUBE                 = 7, 
	SHADER_LOAD                 = 8, 
	SHADER_SAMPLE               = 9, 
	SHADER_SAMPLE_COMPARISON    = 10, 
	SHADER_SAMPLE_MONO_TEXT     = 11, 
	MIP                         = 12, 
	RENDER_TARGET               = 14, 
	BLENDABLE                   = 15, 
	DEPTH_STENCIL               = 16, 
	MULTISAMPLE_RESOLVE         = 18, 
	DISPLAY                     = 19, 
	CAST_WITHIN_BIT_LAYOUT      = 20, 
	MULTISAMPLE_RENDERTARGET    = 21, 
	MULTISAMPLE_LOAD            = 22, 
	SHADER_GATHER               = 23, 
	BACK_BUFFER_CAST            = 24, 
	TYPED_UNORDERED_ACCESS_VIEW = 25, 
	SHADER_GATHER_COMPARISON    = 26, 
	DECODER_OUTPUT              = 27, 
	VIDEO_PROCESSOR_OUTPUT      = 28, 
	VIDEO_PROCESSOR_INPUT       = 29, 
	VIDEO_ENCODER               = 30, 
}

FORMAT_SUPPORT2 :: distinct bit_set[FORMAT_SUPPORT2_FLAG; u32]

FORMAT_SUPPORT2_FLAG :: enum i32 {
	UAV_ATOMIC_ADD                               = 0, 
	UAV_ATOMIC_BITWISE_OPS                       = 1, 
	UAV_ATOMIC_COMPARE_STORE_OR_COMPARE_EXCHANGE = 2, 
	UAV_ATOMIC_EXCHANGE                          = 3, 
	UAV_ATOMIC_SIGNED_MIN_OR_MAX                 = 4, 
	UAV_ATOMIC_UNSIGNED_MIN_OR_MAX               = 5, 
	UAV_TYPED_LOAD                               = 6, 
	UAV_TYPED_STORE                              = 7, 
	OUTPUT_MERGER_LOGIC_OP                       = 8, 
	TILED                                        = 9, 
	MULTIPLANE_OVERLAY                           = 14, 
	SAMPLER_FEEDBACK                             = 15, 
}

FUNCTION_DESC :: struct {
	Version:                     u32,
	Creator:                     cstring,
	Flags:                       u32,
	ConstantBuffers:             u32,
	BoundResources:              u32,
	InstructionCount:            u32,
	TempRegisterCount:           u32,
	TempArrayCount:              u32,
	DefCount:                    u32,
	DclCount:                    u32,
	TextureNormalInstructions:   u32,
	TextureLoadInstructions:     u32,
	TextureCompInstructions:     u32,
	TextureBiasInstructions:     u32,
	TextureGradientInstructions: u32,
	FloatInstructionCount:       u32,
	IntInstructionCount:         u32,
	UintInstructionCount:        u32,
	StaticFlowControlCount:      u32,
	DynamicFlowControlCount:     u32,
	MacroInstructionCount:       u32,
	ArrayInstructionCount:       u32,
	MovInstructionCount:         u32,
	MovcInstructionCount:        u32,
	ConversionInstructionCount:  u32,
	BitwiseInstructionCount:     u32,
	MinFeatureLevel:             FEATURE_LEVEL,
	RequiredFeatureFlags:        u64,
	Name:                        cstring,
	FunctionParameterCount:      i32,
	HasReturn:                   sys_windows.BOOL,
	Has10Level9VertexShader:     sys_windows.BOOL,
	Has10Level9PixelShader:      sys_windows.BOOL,
}

GLOBAL_ROOT_SIGNATURE :: struct {
	pGlobalRootSignature: ^IRootSignature,
}

GPU_BASED_VALIDATION_FLAG :: enum u32 {
	DISABLE_STATE_TRACKING = 0, 
}

GPU_BASED_VALIDATION_FLAGS :: distinct bit_set[GPU_BASED_VALIDATION_FLAG; u32]

GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAG :: enum u32 {
	FRONT_LOAD_CREATE_TRACKING_ONLY_SHADERS        = 0, 
	FRONT_LOAD_CREATE_UNGUARDED_VALIDATION_SHADERS = 1, 
	FRONT_LOAD_CREATE_GUARDED_VALIDATION_SHADERS   = 2, 
}

GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS :: distinct bit_set[GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAG; u32]

GPU_BASED_VALIDATION_SHADER_PATCH_MODE :: enum i32 {
	NONE                                        = 0, 
	STATE_TRACKING_ONLY                         = 1, 
	UNGUARDED_VALIDATION                        = 2, 
	GUARDED_VALIDATION                          = 3, 
	NUM_GPU_BASED_VALIDATION_SHADER_PATCH_MODES = 4, 
}

GPU_DESCRIPTOR_HANDLE :: struct {
	ptr: u64,
}

GPU_VIRTUAL_ADDRESS :: u64

GPU_VIRTUAL_ADDRESS_AND_STRIDE :: struct {
	StartAddress:  u64,
	StrideInBytes: u64,
}

GPU_VIRTUAL_ADDRESS_RANGE :: struct {
	StartAddress: u64,
	SizeInBytes:  u64,
}

GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE :: struct {
	StartAddress:  u64,
	SizeInBytes:   u64,
	StrideInBytes: u64,
}

GRAPHICS_PIPELINE_STATE_DESC :: struct {
	pRootSignature:        ^IRootSignature,
	VS:                    SHADER_BYTECODE,
	PS:                    SHADER_BYTECODE,
	DS:                    SHADER_BYTECODE,
	HS:                    SHADER_BYTECODE,
	GS:                    SHADER_BYTECODE,
	StreamOutput:          STREAM_OUTPUT_DESC,
	BlendState:            BLEND_DESC,
	SampleMask:            u32,
	RasterizerState:       RASTERIZER_DESC,
	DepthStencilState:     DEPTH_STENCIL_DESC,
	InputLayout:           INPUT_LAYOUT_DESC,
	IBStripCutValue:       INDEX_BUFFER_STRIP_CUT_VALUE,
	PrimitiveTopologyType: PRIMITIVE_TOPOLOGY_TYPE,
	NumRenderTargets:      u32,
	RTVFormats:            [8]directx_dxgi.FORMAT,
	DSVFormat:             directx_dxgi.FORMAT,
	SampleDesc:            directx_dxgi.SAMPLE_DESC,
	NodeMask:              u32,
	CachedPSO:             CACHED_PIPELINE_STATE,
	Flags:                 PIPELINE_STATE_FLAGS,
}

GRAPHICS_STATES :: enum i32 {
	NONE                    = 0, 
	IA_VERTEX_BUFFERS       = 1, 
	IA_INDEX_BUFFER         = 2, 
	IA_PRIMITIVE_TOPOLOGY   = 4, 
	DESCRIPTOR_HEAP         = 8, 
	GRAPHICS_ROOT_SIGNATURE = 16, 
	COMPUTE_ROOT_SIGNATURE  = 32, 
	RS_VIEWPORTS            = 64, 
	RS_SCISSOR_RECTS        = 128, 
	PREDICATION             = 256, 
	OM_RENDER_TARGETS       = 512, 
	OM_STENCIL_REF          = 1024, 
	OM_BLEND_FACTOR         = 2048, 
	PIPELINE_STATE          = 4096, 
	SO_TARGETS              = 8192, 
	OM_DEPTH_BOUNDS         = 16384, 
	SAMPLE_POSITIONS        = 32768, 
	VIEW_INSTANCE_MASK      = 65536, 
}

GUID :: sys_windows.GUID

HANDLE :: sys_windows.HANDLE

HEAP_DESC :: struct {
	SizeInBytes: u64,
	Properties:  HEAP_PROPERTIES,
	Alignment:   u64,
	Flags:       HEAP_FLAGS,
}

HEAP_FLAG :: enum u32 {
	SHARED                  = 0, 
	DENY_BUFFERS            = 2, 
	ALLOW_DISPLAY           = 3, 
	SHARED_CROSS_ADAPTER    = 5, 
	DENY_RT_DS_TEXTURES     = 6, 
	DENY_NON_RT_DS_TEXTURES = 7, 
	HARDWARE_PROTECTED      = 8, 
	ALLOW_WRITE_WATCH       = 9, 
	ALLOW_SHADER_ATOMICS    = 10, 
	CREATE_NOT_RESIDENT     = 11, 
	CREATE_NOT_ZEROED       = 12, 
}

HEAP_FLAGS :: distinct bit_set[HEAP_FLAG; u32]

HEAP_PROPERTIES :: struct {
	Type:                 HEAP_TYPE,
	CPUPageProperty:      CPU_PAGE_PROPERTY,
	MemoryPoolPreference: MEMORY_POOL,
	CreationNodeMask:     u32,
	VisibleNodeMask:      u32,
}

HEAP_SERIALIZATION_TIER :: enum i32 {
	_0  = 0, 
	_10 = 10, 
}

HEAP_TYPE :: enum i32 {
	DEFAULT  = 1, 
	UPLOAD   = 2, 
	READBACK = 3, 
	CUSTOM   = 4, 
}

HIT_GROUP_DESC :: struct {
	HitGroupExport:           ^i16,
	Type:                     HIT_GROUP_TYPE,
	AnyHitShaderImport:       ^i16,
	ClosestHitShaderImport:   ^i16,
	IntersectionShaderImport: ^i16,
}

HIT_GROUP_TYPE :: enum i32 {
	TRIANGLES            = 0, 
	PROCEDURAL_PRIMITIVE = 1, 
}

HIT_KIND :: enum i32 {
	TRIANGLE_FRONT_FACE = 254, 
	TRIANGLE_BACK_FACE  = 255, 
}

HMODULE :: sys_windows.HMODULE

HRESULT :: sys_windows.HRESULT

HWND :: sys_windows.HWND

IBlob :: directx_d3d_compiler.ID3D10Blob

ICommandAllocator :: struct #raw_union {
	id3d12pageable:                IPageable,
	using id3d12commandallocator_vtable: ^ICommandAllocator_VTable,
}

ICommandAllocator_VTable :: struct {
	using id3d12devicechild_vtable: IDeviceChild_VTable,
	Reset:                    proc "stdcall" (this: ^ICommandAllocator) -> sys_windows.HRESULT,
}

ICommandList :: struct #raw_union {
	id3d12devicechild:        IDeviceChild,
	using id3d12commandlist_vtable: ^ICommandList_VTable,
}

ICommandList_VTable :: struct {
	using id3d12devicechild_vtable: IDeviceChild_VTable,
	GetType:                  proc "stdcall" (this: ^ICommandList) -> COMMAND_LIST_TYPE,
}

ICommandQueue :: struct #raw_union {
	id3d12pageable:            IPageable,
	using id3d12commandqueue_vtable: ^ICommandQueue_VTable,
}

ICommandQueue_VTable :: struct {
	using id3d12devicechild_vtable: IDeviceChild_VTable,
	UpdateTileMappings:       proc "stdcall" (this: ^ICommandQueue, pResource: ^IResource, NumResourceRegions: u32, pResourceRegionStartCoordinates: [^]TILED_RESOURCE_COORDINATE, pResourceRegionSizes: [^]TILE_REGION_SIZE, pHeap: ^IHeap, NumRanges: u32, pRangeFlags: [^]TILE_RANGE_FLAGS, pHeapRangeStartOffsets: [^]u32, pRangeTileCounts: [^]u32, Flags: TILE_MAPPING_FLAGS),
	CopyTileMappings:         proc "stdcall" (this: ^ICommandQueue, pDstResource: ^IResource, pDstRegionStartCoordinate: ^TILED_RESOURCE_COORDINATE, pSrcResource: ^IResource, pSrcRegionStartCoordinate: ^TILED_RESOURCE_COORDINATE, pRegionSize: ^TILE_REGION_SIZE, Flags: TILE_MAPPING_FLAGS),
	ExecuteCommandLists:      proc "stdcall" (this: ^ICommandQueue, NumCommandLists: u32, ppCommandLists: [^]^ICommandList),
	SetMarker:                proc "stdcall" (this: ^ICommandQueue, Metadata: u32, pData: rawptr, Size: u32),
	BeginEvent:               proc "stdcall" (this: ^ICommandQueue, Metadata: u32, pData: rawptr, Size: u32),
	EndEvent:                 proc "stdcall" (this: ^ICommandQueue),
	Signal:                   proc "stdcall" (this: ^ICommandQueue, pFence: ^IFence, Value: u64) -> sys_windows.HRESULT,
	Wait:                     proc "stdcall" (this: ^ICommandQueue, pFence: ^IFence, Value: u64) -> sys_windows.HRESULT,
	GetTimestampFrequency:    proc "stdcall" (this: ^ICommandQueue, pFrequency: ^u64) -> sys_windows.HRESULT,
	GetClockCalibration:      proc "stdcall" (this: ^ICommandQueue, pGpuTimestamp: ^u64, pCpuTimestamp: ^u64) -> sys_windows.HRESULT,
	GetDesc:                  proc "stdcall" (this: ^ICommandQueue, pRetVal: ^COMMAND_QUEUE_DESC) -> ^COMMAND_QUEUE_DESC,
}

ICommandSignature :: struct {
	id3d12pageable: IPageable,
}

ID3DDestructionNotifier :: struct #raw_union {
	iunknown:                       sys_windows.IUnknown,
	using id3ddestructionnotifier_vtable: ^ID3DDestructionNotifier_VTable,
}

ID3DDestructionNotifier_VTable :: struct {
	using iunknown_vtable:         sys_windows.IUnknown_VTable,
	RegisterDestructionCallback:   proc "stdcall" (this: ^ID3DDestructionNotifier, callbackFn: PFN_DESTRUCTION_CALLBACK, pData: rawptr, pCallbackID: ^u32) -> sys_windows.HRESULT,
	UnregisterDestructionCallback: proc "stdcall" (this: ^ID3DDestructionNotifier, callbackID: u32) -> sys_windows.HRESULT,
}

IDebug :: struct #raw_union {
	iunknown:           sys_windows.IUnknown,
	using id3d12debug_vtable: ^IDebug_VTable,
}

IDebug1 :: struct #raw_union {
	iunknown:            sys_windows.IUnknown,
	using id3d12debug1_vtable: ^IDebug1_VTable,
}

IDebug1_VTable :: struct {
	using iunknown_vtable:                       sys_windows.IUnknown_VTable,
	EnableDebugLayer:                            proc "stdcall" (this: ^IDebug1),
	SetEnableGPUBasedValidation:                 proc "stdcall" (this: ^IDebug1, Enable: sys_windows.BOOL),
	SetEnableSynchronizedCommandQueueValidation: proc "stdcall" (this: ^IDebug1, Enable: sys_windows.BOOL),
}

IDebug2 :: struct #raw_union {
	iunknown:            sys_windows.IUnknown,
	using id3d12debug2_vtable: ^IDebug2_VTable,
}

IDebug2_VTable :: struct {
	using iunknown_vtable:      sys_windows.IUnknown_VTable,
	SetGPUBasedValidationFlags: proc "stdcall" (this: ^IDebug2, Flags: GPU_BASED_VALIDATION_FLAGS),
}

IDebug3 :: struct #raw_union {
	id3d12debug:         IDebug,
	using id3d12debug3_vtable: ^IDebug3_VTable,
}

IDebug3_VTable :: struct {
	using id3d12debug_vtable:                    IDebug_VTable,
	SetEnableGPUBasedValidation:                 proc "stdcall" (this: ^IDebug3, Enable: sys_windows.BOOL),
	SetEnableSynchronizedCommandQueueValidation: proc "stdcall" (this: ^IDebug3, Enable: sys_windows.BOOL),
	SetGPUBasedValidationFlags:                  proc "stdcall" (this: ^IDebug3, Flags: GPU_BASED_VALIDATION_FLAGS),
}

IDebug4 :: struct #raw_union {
	id3d12debug3:        IDebug3,
	using id3d12debug4_vtable: ^IDebug4_VTable,
}

IDebug4_VTable :: struct {
	using id3d12debug3_vtable: IDebug3_VTable,
	DisableDebugLayer:   proc "stdcall" (this: ^IDebug4),
}

IDebug5 :: struct #raw_union {
	id3d12debug4:        IDebug4,
	using id3d12debug5_vtable: ^IDebug5_VTable,
}

IDebug5_VTable :: struct {
	using id3d12debug4_vtable: IDebug4_VTable,
	SetEnableAutoName:   proc "stdcall" (this: ^IDebug5, Enable: sys_windows.BOOL),
}

IDebugCommandList :: struct #raw_union {
	iunknown:                      sys_windows.IUnknown,
	using id3d12debugcommandlist_vtable: ^IDebugCommandList_VTable,
}

IDebugCommandList1 :: struct #raw_union {
	iunknown:                       sys_windows.IUnknown,
	using id3d12debugcommandlist1_vtable: ^IDebugCommandList1_VTable,
}

IDebugCommandList1_VTable :: struct {
	using iunknown_vtable: sys_windows.IUnknown_VTable,
	AssertResourceState: proc "stdcall" (this: ^IDebugCommandList1, pResource: ^IResource, Subresource: u32, State: u32) -> sys_windows.BOOL,
	SetDebugParameter:   proc "stdcall" (this: ^IDebugCommandList1, Type: DEBUG_COMMAND_LIST_PARAMETER_TYPE, pData: rawptr, DataSize: u32) -> sys_windows.HRESULT,
	GetDebugParameter:   proc "stdcall" (this: ^IDebugCommandList1, Type: DEBUG_COMMAND_LIST_PARAMETER_TYPE, pData: rawptr, DataSize: u32) -> sys_windows.HRESULT,
}

IDebugCommandList2 :: struct #raw_union {
	id3d12debugcommandlist:         IDebugCommandList,
	using id3d12debugcommandlist2_vtable: ^IDebugCommandList2_VTable,
}

IDebugCommandList2_VTable :: struct {
	using id3d12debugcommandlist_vtable: IDebugCommandList_VTable,
	SetDebugParameter:             proc "stdcall" (this: ^IDebugCommandList2, Type: DEBUG_COMMAND_LIST_PARAMETER_TYPE, pData: rawptr, DataSize: u32) -> sys_windows.HRESULT,
	GetDebugParameter:             proc "stdcall" (this: ^IDebugCommandList2, Type: DEBUG_COMMAND_LIST_PARAMETER_TYPE, pData: rawptr, DataSize: u32) -> sys_windows.HRESULT,
}

IDebugCommandList_VTable :: struct {
	using iunknown_vtable: sys_windows.IUnknown_VTable,
	AssertResourceState: proc "stdcall" (this: ^IDebugCommandList, pResource: ^IResource, Subresource: u32, State: u32) -> sys_windows.BOOL,
	SetFeatureMask:      proc "stdcall" (this: ^IDebugCommandList, Mask: DEBUG_FEATURE) -> sys_windows.HRESULT,
	GetFeatureMask:      proc "stdcall" (this: ^IDebugCommandList) -> DEBUG_FEATURE,
}

IDebugCommandQueue :: struct #raw_union {
	iunknown:                       sys_windows.IUnknown,
	using id3d12debugcommandqueue_vtable: ^IDebugCommandQueue_VTable,
}

IDebugCommandQueue_VTable :: struct {
	using iunknown_vtable: sys_windows.IUnknown_VTable,
	AssertResourceState: proc "stdcall" (this: ^IDebugCommandQueue, pResource: ^IResource, Subresource: u32, State: u32) -> sys_windows.BOOL,
}

IDebugDevice :: struct #raw_union {
	iunknown:                 sys_windows.IUnknown,
	using id3d12debugdevice_vtable: ^IDebugDevice_VTable,
}

IDebugDevice1 :: struct #raw_union {
	iunknown:                  sys_windows.IUnknown,
	using id3d12debugdevice1_vtable: ^IDebugDevice1_VTable,
}

IDebugDevice1_VTable :: struct {
	using iunknown_vtable:   sys_windows.IUnknown_VTable,
	SetDebugParameter:       proc "stdcall" (this: ^IDebugDevice1, Type: DEBUG_DEVICE_PARAMETER_TYPE, pData: rawptr, DataSize: u32) -> sys_windows.HRESULT,
	GetDebugParameter:       proc "stdcall" (this: ^IDebugDevice1, Type: DEBUG_DEVICE_PARAMETER_TYPE, pData: rawptr, DataSize: u32) -> sys_windows.HRESULT,
	ReportLiveDeviceObjects: proc "stdcall" (this: ^IDebugDevice1, Flags: RLDO_FLAGS) -> sys_windows.HRESULT,
}

IDebugDevice2 :: struct #raw_union {
	id3d12debugdevice:         IDebugDevice,
	using id3d12debugdevice2_vtable: ^IDebugDevice2_VTable,
}

IDebugDevice2_VTable :: struct {
	using id3d12debugdevice_vtable: IDebugDevice_VTable,
	SetDebugParameter:        proc "stdcall" (this: ^IDebugDevice2, Type: DEBUG_DEVICE_PARAMETER_TYPE, pData: rawptr, DataSize: u32) -> sys_windows.HRESULT,
	GetDebugParameter:        proc "stdcall" (this: ^IDebugDevice2, Type: DEBUG_DEVICE_PARAMETER_TYPE, pData: rawptr, DataSize: u32) -> sys_windows.HRESULT,
}

IDebugDevice_VTable :: struct {
	using iunknown_vtable:   sys_windows.IUnknown_VTable,
	SetFeatureMask:          proc "stdcall" (this: ^IDebugDevice, Mask: DEBUG_FEATURE) -> sys_windows.HRESULT,
	GetFeatureMask:          proc "stdcall" (this: ^IDebugDevice) -> DEBUG_FEATURE,
	ReportLiveDeviceObjects: proc "stdcall" (this: ^IDebugDevice, Flags: RLDO_FLAGS) -> sys_windows.HRESULT,
}

IDebug_VTable :: struct {
	using iunknown_vtable: sys_windows.IUnknown_VTable,
	EnableDebugLayer: proc "stdcall" (this: ^IDebug),
}

IDescriptorHeap :: struct #raw_union {
	id3d12pageable:              IPageable,
	using id3d12descriptorheap_vtable: ^IDescriptorHeap_VTable,
}

IDescriptorHeap_VTable :: struct {
	using id3d12devicechild_vtable:     IDeviceChild_VTable,
	GetDesc:                            proc "stdcall" (this: ^IDescriptorHeap, desc: ^DESCRIPTOR_HEAP_DESC),
	GetCPUDescriptorHandleForHeapStart: proc "stdcall" (this: ^IDescriptorHeap, handle: ^CPU_DESCRIPTOR_HANDLE),
	GetGPUDescriptorHandleForHeapStart: proc "stdcall" (this: ^IDescriptorHeap, handle: ^GPU_DESCRIPTOR_HANDLE),
}

IDevice :: struct #raw_union {
	id3d12object:        IObject,
	using id3d12device_vtable: ^IDevice_VTable,
}

IDevice1 :: struct #raw_union {
	id3d12device:         IDevice,
	using id3d12device1_vtable: ^IDevice1_VTable,
}

IDevice1_VTable :: struct {
	using id3d12device_vtable:         IDevice_VTable,
	CreatePipelineLibrary:             proc "stdcall" (this: ^IDevice1, pLibraryBlob: rawptr, BlobLength: uint, riid: ^sys_windows.GUID, ppPipelineLibrary: ^rawptr) -> sys_windows.HRESULT,
	SetEventOnMultipleFenceCompletion: proc "stdcall" (this: ^IDevice1, ppFences: [^]^IFence, pFenceValues: [^]u64, NumFences: u32, Flags: MULTIPLE_FENCE_WAIT_FLAGS, hEvent: sys_windows.HANDLE) -> sys_windows.HRESULT,
	SetResidencyPriority:              proc "stdcall" (this: ^IDevice1, NumObjects: u32, ppObjects: [^]^IPageable, pPriorities: [^]RESIDENCY_PRIORITY) -> sys_windows.HRESULT,
}

IDevice2 :: struct #raw_union {
	id3d12device1:        IDevice1,
	using id3d12device2_vtable: ^IDevice2_VTable,
}

IDevice2_VTable :: struct {
	using id3d12device1_vtable: IDevice1_VTable,
	CreatePipelineState:  proc "stdcall" (this: ^IDevice2, pDesc: ^PIPELINE_STATE_STREAM_DESC, riid: ^sys_windows.GUID, ppPipelineState: ^rawptr) -> sys_windows.HRESULT,
}

IDevice3 :: struct #raw_union {
	id3d12device2:        IDevice2,
	using id3d12device3_vtable: ^IDevice3_VTable,
}

IDevice3_VTable :: struct {
	using id3d12device2_vtable:      IDevice2_VTable,
	OpenExistingHeapFromAddress:     proc "stdcall" (this: ^IDevice3, pAddress: rawptr, riid: ^sys_windows.GUID, ppvHeap: ^rawptr) -> sys_windows.HRESULT,
	OpenExistingHeapFromFileMapping: proc "stdcall" (this: ^IDevice3, hFileMapping: sys_windows.HANDLE, riid: ^sys_windows.GUID, ppvHeap: ^rawptr) -> sys_windows.HRESULT,
	EnqueueMakeResident:             proc "stdcall" (this: ^IDevice3, Flags: RESIDENCY_FLAGS, NumObjects: u32, ppObjects: [^]^IPageable, pFenceToSignal: ^IFence, FenceValueToSignal: u64) -> sys_windows.HRESULT,
}

IDevice4 :: struct #raw_union {
	id3d12device3:        IDevice3,
	using id3d12device4_vtable: ^IDevice4_VTable,
}

IDevice4_VTable :: struct {
	using id3d12device3_vtable:     IDevice3_VTable,
	CreateCommandList1:             proc "stdcall" (this: ^IDevice4, nodeMask: u32, type: COMMAND_LIST_TYPE, flags: COMMAND_LIST_FLAGS, riid: ^sys_windows.GUID, ppCommandList: ^rawptr) -> sys_windows.HRESULT,
	CreateProtectedResourceSession: proc "stdcall" (this: ^IDevice4, pDesc: ^PROTECTED_RESOURCE_SESSION_DESC, riid: ^sys_windows.GUID, ppSession: ^rawptr) -> sys_windows.HRESULT,
	CreateCommittedResource1:       proc "stdcall" (this: ^IDevice4, pHeapProperties: ^HEAP_PROPERTIES, HeapFlags: HEAP_FLAGS, pDesc: ^RESOURCE_DESC, InitialResourceState: RESOURCE_STATES, pOptimizedClearValue: ^CLEAR_VALUE, pProtectedSession: ^IProtectedResourceSession, riidResource: ^sys_windows.GUID, ppvResource: ^rawptr) -> sys_windows.HRESULT,
	CreateHeap1:                    proc "stdcall" (this: ^IDevice4, pDesc: ^HEAP_DESC, pProtectedSession: ^IProtectedResourceSession, riid: ^sys_windows.GUID, ppvHeap: ^rawptr) -> sys_windows.HRESULT,
	CreateReservedResource1:        proc "stdcall" (this: ^IDevice4, pDesc: ^RESOURCE_DESC, InitialState: RESOURCE_STATES, pOptimizedClearValue: ^CLEAR_VALUE, pProtectedSession: ^IProtectedResourceSession, riid: ^sys_windows.GUID, ppvResource: ^rawptr) -> sys_windows.HRESULT,
	GetResourceAllocationInfo1:     proc "stdcall" (this: ^IDevice4, RetVal: ^RESOURCE_ALLOCATION_INFO, visibleMask: u32, numResourceDescs: u32, pResourceDescs: [^]RESOURCE_DESC, pResourceAllocationInfo1: ^RESOURCE_ALLOCATION_INFO1),
}

IDevice5 :: struct #raw_union {
	id3d12device4:        IDevice4,
	using id3d12device5_vtable: ^IDevice5_VTable,
}

IDevice5_VTable :: struct {
	using id3d12device4_vtable:                     IDevice4_VTable,
	CreateLifetimeTracker:                          proc "stdcall" (this: ^IDevice5, pOwner: ^ILifetimeOwner, riid: ^sys_windows.GUID, ppvTracker: ^rawptr) -> sys_windows.HRESULT,
	RemoveDevice:                                   proc "stdcall" (this: ^IDevice5),
	EnumerateMetaCommands:                          proc "stdcall" (this: ^IDevice5, pNumMetaCommands: ^u32, pDescs: [^]META_COMMAND_DESC) -> sys_windows.HRESULT,
	EnumerateMetaCommandParameters:                 proc "stdcall" (this: ^IDevice5, CommandId: ^sys_windows.GUID, Stage: META_COMMAND_PARAMETER_STAGE, pTotalStructureSizeInBytes: ^u32, pParameterCount: ^u32, pParameterDescs: [^]META_COMMAND_PARAMETER_DESC) -> sys_windows.HRESULT,
	CreateMetaCommand:                              proc "stdcall" (this: ^IDevice5, CommandId: ^sys_windows.GUID, NodeMask: u32, pCreationParametersData: rawptr, CreationParametersDataSizeInBytes: uint, riid: ^sys_windows.GUID, ppMetaCommand: ^rawptr) -> sys_windows.HRESULT,
	CreateStateObject:                              proc "stdcall" (this: ^IDevice5, pDesc: ^STATE_OBJECT_DESC, riid: ^sys_windows.GUID, ppStateObject: ^rawptr) -> sys_windows.HRESULT,
	GetRaytracingAccelerationStructurePrebuildInfo: proc "stdcall" (this: ^IDevice5, pDesc: ^BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INPUTS, pInfo: ^RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO),
	CheckDriverMatchingIdentifier:                  proc "stdcall" (this: ^IDevice5, SerializedDataType: SERIALIZED_DATA_TYPE, pIdentifierToCheck: ^SERIALIZED_DATA_DRIVER_MATCHING_IDENTIFIER) -> DRIVER_MATCHING_IDENTIFIER_STATUS,
}

IDevice6 :: struct #raw_union {
	id3d12device5:        IDevice5,
	using id3d12device6_vtable: ^IDevice6_VTable,
}

IDevice6_VTable :: struct {
	using id3d12device5_vtable:  IDevice5_VTable,
	SetBackgroundProcessingMode: proc "stdcall" (this: ^IDevice6, Mode: BACKGROUND_PROCESSING_MODE, MeasurementsAction: MEASUREMENTS_ACTION, hEventToSignalUponCompletion: sys_windows.HANDLE, pbFurtherMeasurementsDesired: ^sys_windows.BOOL) -> sys_windows.HRESULT,
}

IDevice7 :: struct #raw_union {
	id3d12device6:        IDevice6,
	using id3d12device7_vtable: ^IDevice7_VTable,
}

IDevice7_VTable :: struct {
	using id3d12device6_vtable:      IDevice6_VTable,
	AddToStateObject:                proc "stdcall" (this: ^IDevice7, pAddition: ^STATE_OBJECT_DESC, pStateObjectToGrowFrom: ^IStateObject, riid: ^sys_windows.GUID, ppNewStateObject: ^rawptr) -> sys_windows.HRESULT,
	CreateProtectedResourceSession1: proc "stdcall" (this: ^IDevice7, pDesc: ^PROTECTED_RESOURCE_SESSION_DESC1, riid: ^sys_windows.GUID, ppSession: ^rawptr) -> sys_windows.HRESULT,
}

IDevice8 :: struct #raw_union {
	id3d12device7:        IDevice7,
	using id3d12device8_vtable: ^IDevice8_VTable,
}

IDevice8_VTable :: struct {
	using id3d12device7_vtable:               IDevice7_VTable,
	GetResourceAllocationInfo2:               proc "stdcall" (this: ^IDevice8, RetVal: ^RESOURCE_ALLOCATION_INFO, visibleMask: u32, numResourceDescs: u32, pResourceDescs: [^]RESOURCE_DESC1, pResourceAllocationInfo1: ^RESOURCE_ALLOCATION_INFO1),
	CreateCommittedResource2:                 proc "stdcall" (this: ^IDevice8, pHeapProperties: ^HEAP_PROPERTIES, HeapFlags: HEAP_FLAGS, pDesc: ^RESOURCE_DESC1, InitialResourceState: RESOURCE_STATES, pOptimizedClearValue: ^CLEAR_VALUE, pProtectedSession: ^IProtectedResourceSession, riidResource: ^sys_windows.GUID, ppvResource: ^rawptr) -> sys_windows.HRESULT,
	CreatePlacedResource1:                    proc "stdcall" (this: ^IDevice8, pHeap: ^IHeap, HeapOffset: u64, pDesc: ^RESOURCE_DESC1, InitialState: RESOURCE_STATES, pOptimizedClearValue: ^CLEAR_VALUE, riid: ^sys_windows.GUID, ppvResource: ^rawptr) -> sys_windows.HRESULT,
	CreateSamplerFeedbackUnorderedAccessView: proc "stdcall" (this: ^IDevice8, pTargetedResource: ^IResource, pFeedbackResource: ^IResource, DestDescriptor: CPU_DESCRIPTOR_HANDLE),
	GetCopyableFootprints1:                   proc "stdcall" (this: ^IDevice8, pResourceDesc: ^RESOURCE_DESC1, FirstSubresource: u32, NumSubresources: u32, BaseOffset: u64, pLayouts: [^]PLACED_SUBRESOURCE_FOOTPRINT, pNumRows: ^u32, pRowSizeInBytes: ^u64, pTotalBytes: ^u64),
}

IDevice9 :: struct #raw_union {
	id3d12device8:        IDevice8,
	using id3d12device9_vtable: ^IDevice9_VTable,
}

IDevice9_VTable :: struct {
	using id3d12device8_vtable: IDevice8_VTable,
	CreateShaderCacheSession: proc "stdcall" (this: ^IDevice9, pDesc: ^SHADER_CACHE_SESSION_DESC, riid: ^sys_windows.GUID, ppvSession: ^rawptr) -> sys_windows.HRESULT,
	ShaderCacheControl:       proc "stdcall" (this: ^IDevice9, Kinds: bit_set[SHADER_CACHE_KIND_FLAG; u32], Control: bit_set[SHADER_CACHE_CONTROL_FLAG; u32]) -> sys_windows.HRESULT,
	CreateCommandQueue1:      proc "stdcall" (this: ^IDevice9, pDesc: ^COMMAND_QUEUE_DESC, CreatorID: ^sys_windows.GUID, riid: ^sys_windows.GUID, ppCommandQueue: ^rawptr) -> sys_windows.HRESULT,
}

IDeviceChild :: struct #raw_union {
	id3d12object:             IObject,
	using id3d12devicechild_vtable: ^IDeviceChild_VTable,
}

IDeviceChild_VTable :: struct {
	using id3d12object_vtable: IObject_VTable,
	GetDevice:           proc "stdcall" (this: ^IDeviceChild, riid: ^sys_windows.GUID, ppvDevice: ^rawptr) -> sys_windows.HRESULT,
}

IDeviceRemovedExtendedData :: struct #raw_union {
	iunknown:                               sys_windows.IUnknown,
	using id3d12deviceremovedextendeddata_vtable: ^IDeviceRemovedExtendedData_VTable,
}

IDeviceRemovedExtendedData1 :: struct #raw_union {
	id3d12deviceremovedextendeddata:         IDeviceRemovedExtendedData,
	using id3d12deviceremovedextendeddata1_vtable: ^IDeviceRemovedExtendedData1_VTable,
}

IDeviceRemovedExtendedData1_VTable :: struct {
	using id3d12deviceremovedextendeddata_vtable: IDeviceRemovedExtendedData_VTable,
	GetAutoBreadcrumbsOutput1:              proc "stdcall" (this: ^IDeviceRemovedExtendedData1, pOutput: ^DRED_AUTO_BREADCRUMBS_OUTPUT1) -> sys_windows.HRESULT,
	GetPageFaultAllocationOutput1:          proc "stdcall" (this: ^IDeviceRemovedExtendedData1, pOutput: ^DRED_PAGE_FAULT_OUTPUT1) -> sys_windows.HRESULT,
}

IDeviceRemovedExtendedData2 :: struct #raw_union {
	id3d12deviceremovedextendeddata1:        IDeviceRemovedExtendedData1,
	using id3d12deviceremovedextendeddata2_vtable: ^IDeviceRemovedExtendedData2_VTable,
}

IDeviceRemovedExtendedData2_VTable :: struct {
	using id3d12deviceremovedextendeddata1_vtable: IDeviceRemovedExtendedData1_VTable,
	GetPageFaultAllocationOutput2:           proc "stdcall" (this: ^IDeviceRemovedExtendedData2, pOutput: ^DRED_PAGE_FAULT_OUTPUT2) -> sys_windows.HRESULT,
	GetDeviceState:                          proc "stdcall" (this: ^IDeviceRemovedExtendedData2) -> DRED_DEVICE_STATE,
}

IDeviceRemovedExtendedDataSettings :: struct #raw_union {
	iunknown:                                       sys_windows.IUnknown,
	using id3d12deviceremovedextendeddatasettings_vtable: ^IDeviceRemovedExtendedDataSettings_VTable,
}

IDeviceRemovedExtendedDataSettings1 :: struct #raw_union {
	id3d12deviceremovedextendeddatasettings:         IDeviceRemovedExtendedDataSettings,
	using id3d12deviceremovedextendeddatasettings1_vtable: ^IDeviceRemovedExtendedDataSettings1_VTable,
}

IDeviceRemovedExtendedDataSettings1_VTable :: struct {
	using id3d12deviceremovedextendeddatasettings_vtable: IDeviceRemovedExtendedDataSettings_VTable,
	SetBreadcrumbContextEnablement:                 proc "stdcall" (this: ^IDeviceRemovedExtendedDataSettings1, Enablement: DRED_ENABLEMENT),
}

IDeviceRemovedExtendedDataSettings_VTable :: struct {
	using iunknown_vtable:        sys_windows.IUnknown_VTable,
	SetAutoBreadcrumbsEnablement: proc "stdcall" (this: ^IDeviceRemovedExtendedDataSettings, Enablement: DRED_ENABLEMENT),
	SetPageFaultEnablement:       proc "stdcall" (this: ^IDeviceRemovedExtendedDataSettings, Enablement: DRED_ENABLEMENT),
	SetWatsonDumpEnablement:      proc "stdcall" (this: ^IDeviceRemovedExtendedDataSettings, Enablement: DRED_ENABLEMENT),
}

IDeviceRemovedExtendedData_VTable :: struct {
	using iunknown_vtable:        sys_windows.IUnknown_VTable,
	GetAutoBreadcrumbsOutput:     proc "stdcall" (this: ^IDeviceRemovedExtendedData, pOutput: ^DRED_AUTO_BREADCRUMBS_OUTPUT) -> sys_windows.HRESULT,
	GetPageFaultAllocationOutput: proc "stdcall" (this: ^IDeviceRemovedExtendedData, pOutput: ^DRED_PAGE_FAULT_OUTPUT) -> sys_windows.HRESULT,
}

IDevice_VTable :: struct {
	using id3d12object_vtable:        IObject_VTable,
	GetNodeCount:                     proc "stdcall" (this: ^IDevice) -> u32,
	CreateCommandQueue:               proc "stdcall" (this: ^IDevice, pDesc: ^COMMAND_QUEUE_DESC, riid: ^sys_windows.GUID, ppCommandQueue: ^rawptr) -> sys_windows.HRESULT,
	CreateCommandAllocator:           proc "stdcall" (this: ^IDevice, type: COMMAND_LIST_TYPE, riid: ^sys_windows.GUID, ppCommandAllocator: ^rawptr) -> sys_windows.HRESULT,
	CreateGraphicsPipelineState:      proc "stdcall" (this: ^IDevice, pDesc: ^GRAPHICS_PIPELINE_STATE_DESC, riid: ^sys_windows.GUID, ppPipelineState: ^rawptr) -> sys_windows.HRESULT,
	CreateComputePipelineState:       proc "stdcall" (this: ^IDevice, pDesc: ^COMPUTE_PIPELINE_STATE_DESC, riid: ^sys_windows.GUID, ppPipelineState: ^rawptr) -> sys_windows.HRESULT,
	CreateCommandList:                proc "stdcall" (this: ^IDevice, nodeMask: u32, type: COMMAND_LIST_TYPE, pCommandAllocator: ^ICommandAllocator, pInitialState: ^IPipelineState, riid: ^sys_windows.GUID, ppCommandList: ^rawptr) -> sys_windows.HRESULT,
	CheckFeatureSupport:              proc "stdcall" (this: ^IDevice, Feature: FEATURE, pFeatureSupportData: rawptr, FeatureSupportDataSize: u32) -> sys_windows.HRESULT,
	CreateDescriptorHeap:             proc "stdcall" (this: ^IDevice, pDescriptorHeapDesc: ^DESCRIPTOR_HEAP_DESC, riid: ^sys_windows.GUID, ppvHeap: ^rawptr) -> sys_windows.HRESULT,
	GetDescriptorHandleIncrementSize: proc "stdcall" (this: ^IDevice, DescriptorHeapType: DESCRIPTOR_HEAP_TYPE) -> u32,
	CreateRootSignature:              proc "stdcall" (this: ^IDevice, nodeMask: u32, pBlobWithRootSignature: rawptr, blobLengthInBytes: uint, riid: ^sys_windows.GUID, ppvRootSignature: ^rawptr) -> sys_windows.HRESULT,
	CreateConstantBufferView:         proc "stdcall" (this: ^IDevice, pDesc: ^CONSTANT_BUFFER_VIEW_DESC, DestDescriptor: CPU_DESCRIPTOR_HANDLE),
	CreateShaderResourceView:         proc "stdcall" (this: ^IDevice, pResource: ^IResource, pDesc: ^SHADER_RESOURCE_VIEW_DESC, DestDescriptor: CPU_DESCRIPTOR_HANDLE),
	CreateUnorderedAccessView:        proc "stdcall" (this: ^IDevice, pResource: ^IResource, pCounterResource: ^IResource, pDesc: ^UNORDERED_ACCESS_VIEW_DESC, DestDescriptor: CPU_DESCRIPTOR_HANDLE),
	CreateRenderTargetView:           proc "stdcall" (this: ^IDevice, pResource: ^IResource, pDesc: ^RENDER_TARGET_VIEW_DESC, DestDescriptor: CPU_DESCRIPTOR_HANDLE),
	CreateDepthStencilView:           proc "stdcall" (this: ^IDevice, pResource: ^IResource, pDesc: ^DEPTH_STENCIL_VIEW_DESC, DestDescriptor: CPU_DESCRIPTOR_HANDLE),
	CreateSampler:                    proc "stdcall" (this: ^IDevice, pDesc: ^SAMPLER_DESC, DestDescriptor: CPU_DESCRIPTOR_HANDLE),
	CopyDescriptors:                  proc "stdcall" (this: ^IDevice, NumDestDescriptorRanges: u32, pDestDescriptorRangeStarts: [^]CPU_DESCRIPTOR_HANDLE, pDestDescriptorRangeSizes: [^]u32, NumSrcDescriptorRanges: u32, pSrcDescriptorRangeStarts: [^]CPU_DESCRIPTOR_HANDLE, pSrcDescriptorRangeSizes: [^]u32, DescriptorHeapsType: DESCRIPTOR_HEAP_TYPE),
	CopyDescriptorsSimple:            proc "stdcall" (this: ^IDevice, NumDescriptors: u32, DestDescriptorRangeStart: CPU_DESCRIPTOR_HANDLE, SrcDescriptorRangeStart: CPU_DESCRIPTOR_HANDLE, DescriptorHeapsType: DESCRIPTOR_HEAP_TYPE),
	GetResourceAllocationInfo:        proc "stdcall" (this: ^IDevice, RetVal: ^RESOURCE_ALLOCATION_INFO, visibleMask: u32, numResourceDescs: u32, pResourceDescs: [^]RESOURCE_DESC),
	GetCustomHeapProperties:          proc "stdcall" (this: ^IDevice, nodeMask: u32, heapType: HEAP_TYPE) -> HEAP_PROPERTIES,
	CreateCommittedResource:          proc "stdcall" (this: ^IDevice, pHeapProperties: ^HEAP_PROPERTIES, HeapFlags: HEAP_FLAGS, pDesc: ^RESOURCE_DESC, InitialResourceState: RESOURCE_STATES, pOptimizedClearValue: ^CLEAR_VALUE, riidResource: ^sys_windows.GUID, ppvResource: ^rawptr) -> sys_windows.HRESULT,
	CreateHeap:                       proc "stdcall" (this: ^IDevice, pDesc: ^HEAP_DESC, riid: ^sys_windows.GUID, ppvHeap: ^rawptr) -> sys_windows.HRESULT,
	CreatePlacedResource:             proc "stdcall" (this: ^IDevice, pHeap: ^IHeap, HeapOffset: u64, pDesc: ^RESOURCE_DESC, InitialState: RESOURCE_STATES, pOptimizedClearValue: ^CLEAR_VALUE, riid: ^sys_windows.GUID, ppvResource: ^rawptr) -> sys_windows.HRESULT,
	CreateReservedResource:           proc "stdcall" (this: ^IDevice, pDesc: ^RESOURCE_DESC, InitialState: RESOURCE_STATES, pOptimizedClearValue: ^CLEAR_VALUE, riid: ^sys_windows.GUID, ppvResource: ^rawptr) -> sys_windows.HRESULT,
	CreateSharedHandle:               proc "stdcall" (this: ^IDevice, pObject: ^IDeviceChild, pAttributes: ^sys_windows.SECURITY_ATTRIBUTES, Access: u32, Name: [^]u16, pHandle: ^sys_windows.HANDLE) -> sys_windows.HRESULT,
	OpenSharedHandle:                 proc "stdcall" (this: ^IDevice, NTHandle: sys_windows.HANDLE, riid: ^sys_windows.GUID, ppvObj: ^rawptr) -> sys_windows.HRESULT,
	OpenSharedHandleByName:           proc "stdcall" (this: ^IDevice, Name: [^]u16, Access: u32, pNTHandle: ^sys_windows.HANDLE) -> sys_windows.HRESULT,
	MakeResident:                     proc "stdcall" (this: ^IDevice, NumObjects: u32, ppObjects: [^]^IPageable) -> sys_windows.HRESULT,
	Evict:                            proc "stdcall" (this: ^IDevice, NumObjects: u32, ppObjects: [^]^IPageable) -> sys_windows.HRESULT,
	CreateFence:                      proc "stdcall" (this: ^IDevice, InitialValue: u64, Flags: FENCE_FLAGS, riid: ^sys_windows.GUID, ppFence: ^rawptr) -> sys_windows.HRESULT,
	GetDeviceRemovedReason:           proc "stdcall" (this: ^IDevice) -> sys_windows.HRESULT,
	GetCopyableFootprints:            proc "stdcall" (this: ^IDevice, pResourceDesc: ^RESOURCE_DESC, FirstSubresource: u32, NumSubresources: u32, BaseOffset: u64, pLayouts: [^]PLACED_SUBRESOURCE_FOOTPRINT, pNumRows: [^]u32, pRowSizeInBytes: [^]u64, pTotalBytes: ^u64),
	CreateQueryHeap:                  proc "stdcall" (this: ^IDevice, pDesc: ^QUERY_HEAP_DESC, riid: ^sys_windows.GUID, ppvHeap: ^rawptr) -> sys_windows.HRESULT,
	SetStablePowerState:              proc "stdcall" (this: ^IDevice, Enable: sys_windows.BOOL) -> sys_windows.HRESULT,
	CreateCommandSignature:           proc "stdcall" (this: ^IDevice, pDesc: ^COMMAND_SIGNATURE_DESC, pRootSignature: ^IRootSignature, riid: ^sys_windows.GUID, ppvCommandSignature: ^rawptr) -> sys_windows.HRESULT,
	GetResourceTiling:                proc "stdcall" (this: ^IDevice, pTiledResource: ^IResource, pNumTilesForEntireResource: ^u32, pPackedMipDesc: ^PACKED_MIP_INFO, pStandardTileShapeForNonPackedMips: ^TILE_SHAPE, pNumSubresourceTilings: ^u32, FirstSubresourceTilingToGet: u32, pSubresourceTilingsForNonPackedMips: ^SUBRESOURCE_TILING),
	GetAdapterLuid:                   proc "stdcall" (this: ^IDevice) -> sys_windows.LUID,
}

IFence :: struct #raw_union {
	id3d12pageable:     IPageable,
	using id3d12fence_vtable: ^IFence_VTable,
}

IFence1 :: struct #raw_union {
	id3d12fence:         IFence,
	using id3d12fence1_vtable: ^IFence1_VTable,
}

IFence1_VTable :: struct {
	id3d12fence_vtable: IFence_VTable,
	GetCreationFlags:   proc "stdcall" (this: ^IFence1) -> FENCE_FLAGS,
}

IFence_VTable :: struct {
	using id3d12devicechild_vtable: IDeviceChild_VTable,
	GetCompletedValue:        proc "stdcall" (this: ^IFence) -> u64,
	SetEventOnCompletion:     proc "stdcall" (this: ^IFence, Value: u64, hEvent: sys_windows.HANDLE) -> sys_windows.HRESULT,
	Signal:                   proc "stdcall" (this: ^IFence, Value: u64) -> sys_windows.HRESULT,
}

IFunctionParameterReflection :: struct {
	using id3d12functionparameterreflection_vtable: ^IFunctionParameterReflection_VTable,
}

IFunctionParameterReflection_VTable :: struct {
	GetDesc: proc "stdcall" (this: ^IFunctionParameterReflection, pDesc: ^PARAMETER_DESC) -> sys_windows.HRESULT,
}

IFunctionReflection :: struct {
	using id3d12functionreflection_vtable: ^IFunctionReflection_VTable,
}

IFunctionReflection_VTable :: struct {
	GetDesc:                      proc "stdcall" (this: ^IFunctionReflection, pDesc: ^FUNCTION_DESC) -> sys_windows.HRESULT,
	GetConstantBufferByIndex:     proc "stdcall" (this: ^IFunctionReflection, BufferIndex: u32) -> ^IShaderReflectionConstantBuffer,
	GetConstantBufferByName:      proc "stdcall" (this: ^IFunctionReflection, Name: cstring) -> ^IShaderReflectionConstantBuffer,
	GetResourceBindingDesc:       proc "stdcall" (this: ^IFunctionReflection, ResourceIndex: u32, pDesc: ^SHADER_INPUT_BIND_DESC) -> sys_windows.HRESULT,
	GetVariableByName:            proc "stdcall" (this: ^IFunctionReflection, Name: cstring) -> ^IShaderReflectionVariable,
	GetResourceBindingDescByName: proc "stdcall" (this: ^IFunctionReflection, Name: cstring, pDesc: ^SHADER_INPUT_BIND_DESC) -> sys_windows.HRESULT,
	GetFunctionParameter:         proc "stdcall" (this: ^IFunctionReflection, ParameterIndex: i32) -> ^IFunctionParameterReflection,
}

IGraphicsCommandList :: struct #raw_union {
	id3d12commandlist:                ICommandList,
	using id3d12graphicscommandlist_vtable: ^IGraphicsCommandList_VTable,
}

IGraphicsCommandList1 :: struct #raw_union {
	id3d12graphicscommandlist:         IGraphicsCommandList,
	using id3d12graphicscommandlist1_vtable: ^IGraphicsCommandList1_VTable,
}

IGraphicsCommandList1_VTable :: struct {
	using id3d12graphicscommandlist_vtable: IGraphicsCommandList_VTable,
	AtomicCopyBufferUINT:             proc "stdcall" (this: ^IGraphicsCommandList1, pDstBuffer: ^IResource, DstOffset: u64, pSrcBuffer: ^IResource, SrcOffset: u64, Dependencies: u32, ppDependentResources: [^]^IResource, pDependentSubresourceRanges: [^]SUBRESOURCE_RANGE_UINT64),
	AtomicCopyBufferUINT64:           proc "stdcall" (this: ^IGraphicsCommandList1, pDstBuffer: ^IResource, DstOffset: u64, pSrcBuffer: ^IResource, SrcOffset: u64, Dependencies: u32, ppDependentResources: [^]^IResource, pDependentSubresourceRanges: [^]SUBRESOURCE_RANGE_UINT64),
	OMSetDepthBounds:                 proc "stdcall" (this: ^IGraphicsCommandList1, Min: f32, Max: f32),
	SetSamplePositions:               proc "stdcall" (this: ^IGraphicsCommandList1, NumSamplesPerPixel: u32, NumPixels: u32, pSamplePositions: [^]SAMPLE_POSITION),
	ResolveSubresourceRegion:         proc "stdcall" (this: ^IGraphicsCommandList1, pDstResource: ^IResource, DstSubresource: u32, DstX: u32, DstY: u32, pSrcResource: ^IResource, SrcSubresource: u32, pSrcRect: ^sys_windows.RECT, Format: directx_dxgi.FORMAT, ResolveMode: RESOLVE_MODE),
	SetViewInstanceMask:              proc "stdcall" (this: ^IGraphicsCommandList1, Mask: u32),
}

IGraphicsCommandList2 :: struct #raw_union {
	id3d12graphicscommandlist1:        IGraphicsCommandList1,
	using id3d12graphicscommandlist2_vtable: ^IGraphicsCommandList2_VTable,
}

IGraphicsCommandList2_VTable :: struct {
	using id3d12graphicscommandlist1_vtable: IGraphicsCommandList1_VTable,
	WriteBufferImmediate:              proc "stdcall" (this: ^IGraphicsCommandList2, Count: u32, pParams: [^]WRITEBUFFERIMMEDIATE_PARAMETER, pModes: [^]WRITEBUFFERIMMEDIATE_MODE),
}

IGraphicsCommandList3 :: struct #raw_union {
	id3d12graphicscommandlist2:        IGraphicsCommandList2,
	using id3d12graphicscommandlist3_vtable: ^IGraphicsCommandList3_VTable,
}

IGraphicsCommandList3_VTable :: struct {
	using id3d12graphicscommandlist2_vtable: IGraphicsCommandList2_VTable,
	SetProtectedResourceSession:       proc "stdcall" (this: ^IGraphicsCommandList3, pProtectedResourceSession: ^IProtectedResourceSession),
}

IGraphicsCommandList4 :: struct #raw_union {
	id3d12graphicscommandlist3:        IGraphicsCommandList3,
	using id3d12graphicscommandlist4_vtable: ^IGraphicsCommandList4_VTable,
}

IGraphicsCommandList4_VTable :: struct {
	using id3d12graphicscommandlist3_vtable:          IGraphicsCommandList3_VTable,
	BeginRenderPass:                                  proc "stdcall" (this: ^IGraphicsCommandList4, NumRenderTargets: u32, pRenderTargets: [^]RENDER_PASS_RENDER_TARGET_DESC, pDepthStencil: ^RENDER_PASS_DEPTH_STENCIL_DESC, Flags: RENDER_PASS_FLAGS),
	EndRenderPass:                                    proc "stdcall" (this: ^IGraphicsCommandList4),
	InitializeMetaCommand:                            proc "stdcall" (this: ^IGraphicsCommandList4, pMetaCommand: ^IMetaCommand, pInitializationParametersData: rawptr, InitializationParametersDataSizeInBytes: uint),
	ExecuteMetaCommand:                               proc "stdcall" (this: ^IGraphicsCommandList4, pMetaCommand: ^IMetaCommand, pExecutionParametersData: rawptr, ExecutionParametersDataSizeInBytes: uint),
	BuildRaytracingAccelerationStructure:             proc "stdcall" (this: ^IGraphicsCommandList4, pDesc: ^BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC, NumPostbuildInfoDescs: u32, pPostbuildInfoDescs: [^]RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC),
	EmitRaytracingAccelerationStructurePostbuildInfo: proc "stdcall" (this: ^IGraphicsCommandList4, pDesc: ^RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_DESC, NumSourceAccelerationStructures: u32, pSourceAccelerationStructureData: ^u64),
	CopyRaytracingAccelerationStructure:              proc "stdcall" (this: ^IGraphicsCommandList4, DestAccelerationStructureData: u64, SourceAccelerationStructureData: u64, Mode: RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE),
	SetPipelineState1:                                proc "stdcall" (this: ^IGraphicsCommandList4, pStateObject: ^IStateObject),
	DispatchRays:                                     proc "stdcall" (this: ^IGraphicsCommandList4, pDesc: ^DISPATCH_RAYS_DESC),
}

IGraphicsCommandList5 :: struct #raw_union {
	id3d12graphicscommandlist4:        IGraphicsCommandList4,
	using id3d12graphicscommandlist5_vtable: ^IGraphicsCommandList5_VTable,
}

IGraphicsCommandList5_VTable :: struct {
	using id3d12graphicscommandlist4_vtable: IGraphicsCommandList4_VTable,
	RSSetShadingRate:                  proc "stdcall" (this: ^IGraphicsCommandList5, baseShadingRate: SHADING_RATE, combiners: ^SHADING_RATE_COMBINER),
	RSSetShadingRateImage:             proc "stdcall" (this: ^IGraphicsCommandList5, shadingRateImage: ^IResource),
}

IGraphicsCommandList6 :: struct #raw_union {
	id3d12graphicscommandlist5:        IGraphicsCommandList5,
	using id3d12graphicscommandlist6_vtable: ^IGraphicsCommandList6_VTable,
}

IGraphicsCommandList6_VTable :: struct {
	using id3d12graphicscommandlist5_vtable: IGraphicsCommandList5_VTable,
	DispatchMesh:                      proc "stdcall" (this: ^IGraphicsCommandList6, ThreadGroupCountX: u32, ThreadGroupCountY: u32, ThreadGroupCountZ: u32),
}

IGraphicsCommandList_VTable :: struct {
	using id3d12commandlist_vtable:     ICommandList_VTable,
	Close:                              proc "stdcall" (this: ^IGraphicsCommandList) -> sys_windows.HRESULT,
	Reset:                              proc "stdcall" (this: ^IGraphicsCommandList, pAllocator: ^ICommandAllocator, pInitialState: ^IPipelineState) -> sys_windows.HRESULT,
	ClearState:                         proc "stdcall" (this: ^IGraphicsCommandList, pPipelineState: ^IPipelineState),
	DrawInstanced:                      proc "stdcall" (this: ^IGraphicsCommandList, VertexCountPerInstance: u32, InstanceCount: u32, StartVertexLocation: u32, StartInstanceLocation: u32),
	DrawIndexedInstanced:               proc "stdcall" (this: ^IGraphicsCommandList, IndexCountPerInstance: u32, InstanceCount: u32, StartIndexLocation: u32, BaseVertexLocation: i32, StartInstanceLocation: u32),
	Dispatch:                           proc "stdcall" (this: ^IGraphicsCommandList, ThreadGroupCountX: u32, ThreadGroupCountY: u32, ThreadGroupCountZ: u32),
	CopyBufferRegion:                   proc "stdcall" (this: ^IGraphicsCommandList, pDstBuffer: ^IResource, DstOffset: u64, pSrcBuffer: ^IResource, SrcOffset: u64, NumBytes: u64),
	CopyTextureRegion:                  proc "stdcall" (this: ^IGraphicsCommandList, pDst: ^TEXTURE_COPY_LOCATION, DstX: u32, DstY: u32, DstZ: u32, pSrc: ^TEXTURE_COPY_LOCATION, pSrcBox: ^BOX),
	CopyResource:                       proc "stdcall" (this: ^IGraphicsCommandList, pDstResource: ^IResource, pSrcResource: ^IResource),
	CopyTiles:                          proc "stdcall" (this: ^IGraphicsCommandList, pTiledResource: ^IResource, pTileRegionStartCoordinate: ^TILED_RESOURCE_COORDINATE, pTileRegionSize: ^TILE_REGION_SIZE, pBuffer: ^IResource, BufferStartOffsetInBytes: u64, Flags: TILE_COPY_FLAGS),
	ResolveSubresource:                 proc "stdcall" (this: ^IGraphicsCommandList, pDstResource: ^IResource, DstSubresource: u32, pSrcResource: ^IResource, SrcSubresource: u32, Format: directx_dxgi.FORMAT),
	IASetPrimitiveTopology:             proc "stdcall" (this: ^IGraphicsCommandList, PrimitiveTopology: PRIMITIVE_TOPOLOGY),
	RSSetViewports:                     proc "stdcall" (this: ^IGraphicsCommandList, NumViewports: u32, pViewports: [^]VIEWPORT),
	RSSetScissorRects:                  proc "stdcall" (this: ^IGraphicsCommandList, NumRects: u32, pRects: [^]sys_windows.RECT),
	OMSetBlendFactor:                   proc "stdcall" (this: ^IGraphicsCommandList, BlendFactor: ^[4]f32),
	OMSetStencilRef:                    proc "stdcall" (this: ^IGraphicsCommandList, StencilRef: u32),
	SetPipelineState:                   proc "stdcall" (this: ^IGraphicsCommandList, pPipelineState: ^IPipelineState),
	ResourceBarrier:                    proc "stdcall" (this: ^IGraphicsCommandList, NumBarriers: u32, pBarriers: [^]RESOURCE_BARRIER),
	ExecuteBundle:                      proc "stdcall" (this: ^IGraphicsCommandList, pCommandList: ^IGraphicsCommandList),
	SetDescriptorHeaps:                 proc "stdcall" (this: ^IGraphicsCommandList, NumDescriptorHeaps: u32, ppDescriptorHeaps: [^]^IDescriptorHeap),
	SetComputeRootSignature:            proc "stdcall" (this: ^IGraphicsCommandList, pRootSignature: ^IRootSignature),
	SetGraphicsRootSignature:           proc "stdcall" (this: ^IGraphicsCommandList, pRootSignature: ^IRootSignature),
	SetComputeRootDescriptorTable:      proc "stdcall" (this: ^IGraphicsCommandList, RootParameterIndex: u32, BaseDescriptor: GPU_DESCRIPTOR_HANDLE),
	SetGraphicsRootDescriptorTable:     proc "stdcall" (this: ^IGraphicsCommandList, RootParameterIndex: u32, BaseDescriptor: GPU_DESCRIPTOR_HANDLE),
	SetComputeRoot32BitConstant:        proc "stdcall" (this: ^IGraphicsCommandList, RootParameterIndex: u32, SrcData: u32, DestOffsetIn32BitValues: u32),
	SetGraphicsRoot32BitConstant:       proc "stdcall" (this: ^IGraphicsCommandList, RootParameterIndex: u32, SrcData: u32, DestOffsetIn32BitValues: u32),
	SetComputeRoot32BitConstants:       proc "stdcall" (this: ^IGraphicsCommandList, RootParameterIndex: u32, Num32BitValuesToSet: u32, pSrcData: rawptr, DestOffsetIn32BitValues: u32),
	SetGraphicsRoot32BitConstants:      proc "stdcall" (this: ^IGraphicsCommandList, RootParameterIndex: u32, Num32BitValuesToSet: u32, pSrcData: rawptr, DestOffsetIn32BitValues: u32),
	SetComputeRootConstantBufferView:   proc "stdcall" (this: ^IGraphicsCommandList, RootParameterIndex: u32, BufferLocation: u64),
	SetGraphicsRootConstantBufferView:  proc "stdcall" (this: ^IGraphicsCommandList, RootParameterIndex: u32, BufferLocation: u64),
	SetComputeRootShaderResourceView:   proc "stdcall" (this: ^IGraphicsCommandList, RootParameterIndex: u32, BufferLocation: u64),
	SetGraphicsRootShaderResourceView:  proc "stdcall" (this: ^IGraphicsCommandList, RootParameterIndex: u32, BufferLocation: u64),
	SetComputeRootUnorderedAccessView:  proc "stdcall" (this: ^IGraphicsCommandList, RootParameterIndex: u32, BufferLocation: u64),
	SetGraphicsRootUnorderedAccessView: proc "stdcall" (this: ^IGraphicsCommandList, RootParameterIndex: u32, BufferLocation: u64),
	IASetIndexBuffer:                   proc "stdcall" (this: ^IGraphicsCommandList, pView: ^INDEX_BUFFER_VIEW),
	IASetVertexBuffers:                 proc "stdcall" (this: ^IGraphicsCommandList, StartSlot: u32, NumViews: u32, pViews: [^]VERTEX_BUFFER_VIEW),
	SOSetTargets:                       proc "stdcall" (this: ^IGraphicsCommandList, StartSlot: u32, NumViews: u32, pViews: [^]STREAM_OUTPUT_BUFFER_VIEW),
	OMSetRenderTargets:                 proc "stdcall" (this: ^IGraphicsCommandList, NumRenderTargetDescriptors: u32, pRenderTargetDescriptors: [^]CPU_DESCRIPTOR_HANDLE, RTsSingleHandleToDescriptorRange: sys_windows.BOOL, pDepthStencilDescriptor: ^CPU_DESCRIPTOR_HANDLE),
	ClearDepthStencilView:              proc "stdcall" (this: ^IGraphicsCommandList, DepthStencilView: CPU_DESCRIPTOR_HANDLE, ClearFlags: CLEAR_FLAGS, Depth: f32, Stencil: u8, NumRects: u32, pRects: [^]sys_windows.RECT),
	ClearRenderTargetView:              proc "stdcall" (this: ^IGraphicsCommandList, RenderTargetView: CPU_DESCRIPTOR_HANDLE, ColorRGBA: ^[4]f32, NumRects: u32, pRects: [^]sys_windows.RECT),
	ClearUnorderedAccessViewUint:       proc "stdcall" (this: ^IGraphicsCommandList, ViewGPUHandleInCurrentHeap: GPU_DESCRIPTOR_HANDLE, ViewCPUHandle: CPU_DESCRIPTOR_HANDLE, pResource: ^IResource, Values: ^[4]u32, NumRects: u32, pRects: [^]sys_windows.RECT),
	ClearUnorderedAccessViewFloat:      proc "stdcall" (this: ^IGraphicsCommandList, ViewGPUHandleInCurrentHeap: GPU_DESCRIPTOR_HANDLE, ViewCPUHandle: CPU_DESCRIPTOR_HANDLE, pResource: ^IResource, Values: ^[4]f32, NumRects: u32, pRects: [^]sys_windows.RECT),
	DiscardResource:                    proc "stdcall" (this: ^IGraphicsCommandList, pResource: ^IResource, pRegion: ^DISCARD_REGION),
	BeginQuery:                         proc "stdcall" (this: ^IGraphicsCommandList, pQueryHeap: ^IQueryHeap, Type: QUERY_TYPE, Index: u32),
	EndQuery:                           proc "stdcall" (this: ^IGraphicsCommandList, pQueryHeap: ^IQueryHeap, Type: QUERY_TYPE, Index: u32),
	ResolveQueryData:                   proc "stdcall" (this: ^IGraphicsCommandList, pQueryHeap: ^IQueryHeap, Type: QUERY_TYPE, StartIndex: u32, NumQueries: u32, pDestinationBuffer: ^IResource, AlignedDestinationBufferOffset: u64),
	SetPredication:                     proc "stdcall" (this: ^IGraphicsCommandList, pBuffer: ^IResource, AlignedBufferOffset: u64, Operation: PREDICATION_OP),
	SetMarker:                          proc "stdcall" (this: ^IGraphicsCommandList, Metadata: u32, pData: rawptr, Size: u32),
	BeginEvent:                         proc "stdcall" (this: ^IGraphicsCommandList, Metadata: u32, pData: rawptr, Size: u32),
	EndEvent:                           proc "stdcall" (this: ^IGraphicsCommandList),
	ExecuteIndirect:                    proc "stdcall" (this: ^IGraphicsCommandList, pCommandSignature: ^ICommandSignature, MaxCommandCount: u32, pArgumentBuffer: ^IResource, ArgumentBufferOffset: u64, pCountBuffer: ^IResource, CountBufferOffset: u64),
}