package vendor:directx/d3d11

Source

AES_CTR_IV :: struct {
	IV:    u64,
	Count: u64,
}

APP_DEPRECATED_HRESULT :: sys_windows.HRESULT

ASYNC_GETDATA_FLAG :: enum u32 {
	DONOTFLUSH = 0, 
}

ASYNC_GETDATA_FLAGS :: distinct bit_set[ASYNC_GETDATA_FLAG; u32]

AUTHENTICATED_CHANNEL_TYPE :: enum i32 {
	D3D11           = 1, 
	DRIVER_SOFTWARE = 2, 
	DRIVER_HARDWARE = 3, 
}

AUTHENTICATED_CONFIGURE_ACCESSIBLE_ENCRYPTION_INPUT :: struct {
	Parameters:     AUTHENTICATED_CONFIGURE_INPUT,
	EncryptionGuid: sys_windows.GUID,
}

AUTHENTICATED_CONFIGURE_CRYPTO_SESSION_INPUT :: struct {
	Parameters:          AUTHENTICATED_CONFIGURE_INPUT,
	DecoderHandle:       sys_windows.HANDLE,
	CryptoSessionHandle: sys_windows.HANDLE,
	DeviceHandle:        sys_windows.HANDLE,
}

AUTHENTICATED_CONFIGURE_INITIALIZE_INPUT :: struct {
	Parameters:             AUTHENTICATED_CONFIGURE_INPUT,
	StartSequenceQuery:     u32,
	StartSequenceConfigure: u32,
}

AUTHENTICATED_CONFIGURE_INPUT :: struct {
	omac:           OMAC,
	ConfigureType:  sys_windows.GUID,
	hChannel:       sys_windows.HANDLE,
	SequenceNumber: u32,
}

AUTHENTICATED_CONFIGURE_OUTPUT :: struct {
	omac:           OMAC,
	ConfigureType:  sys_windows.GUID,
	hChannel:       sys_windows.HANDLE,
	SequenceNumber: u32,
	ReturnCode:     sys_windows.HRESULT,
}

AUTHENTICATED_CONFIGURE_PROTECTION_INPUT :: struct {
	Parameters:  AUTHENTICATED_CONFIGURE_INPUT,
	Protections: AUTHENTICATED_PROTECTION_FLAGS,
}

AUTHENTICATED_CONFIGURE_SHARED_RESOURCE_INPUT :: struct {
	Parameters:    AUTHENTICATED_CONFIGURE_INPUT,
	ProcessType:   AUTHENTICATED_PROCESS_IDENTIFIER_TYPE,
	ProcessHandle: sys_windows.HANDLE,
	AllowAccess:   sys_windows.BOOL,
}

AUTHENTICATED_PROCESS_IDENTIFIER_TYPE :: enum i32 {
	UNKNOWN = 0, 
	DWM     = 1, 
	HANDLE  = 2, 
}

AUTHENTICATED_PROTECTION_FLAG :: enum u32 {
	ProtectionEnabled           = 0, 
	OverlayOrFullscreenRequired = 1, 
	Reserved                    = 2, 
}

AUTHENTICATED_PROTECTION_FLAGS :: distinct bit_set[AUTHENTICATED_PROTECTION_FLAG; u32]

AUTHENTICATED_QUERY_ACCESSIBILITY_ENCRYPTION_GUID_COUNT_OUTPUT :: struct {
	Output:              AUTHENTICATED_QUERY_OUTPUT,
	EncryptionGuidCount: u32,
}

AUTHENTICATED_QUERY_ACCESSIBILITY_ENCRYPTION_GUID_INPUT :: struct {
	Input:               AUTHENTICATED_QUERY_INPUT,
	EncryptionGuidIndex: u32,
}

AUTHENTICATED_QUERY_ACCESSIBILITY_ENCRYPTION_GUID_OUTPUT :: struct {
	Output:              AUTHENTICATED_QUERY_OUTPUT,
	EncryptionGuidIndex: u32,
	EncryptionGuid:      sys_windows.GUID,
}

AUTHENTICATED_QUERY_ACCESSIBILITY_OUTPUT :: AUTHENTICATED_QUERY_ACESSIBILITY_OUTPUT

AUTHENTICATED_QUERY_ACESSIBILITY_OUTPUT :: struct {
	Output:                          AUTHENTICATED_QUERY_OUTPUT,
	BusType:                         BUS_TYPE,
	AccessibleInContiguousBlocks:    sys_windows.BOOL,
	AccessibleInNonContiguousBlocks: sys_windows.BOOL,
}

AUTHENTICATED_QUERY_CHANNEL_TYPE_OUTPUT :: struct {
	Output:      AUTHENTICATED_QUERY_OUTPUT,
	ChannelType: AUTHENTICATED_CHANNEL_TYPE,
}

AUTHENTICATED_QUERY_CRYPTO_SESSION_INPUT :: struct {
	Input:         AUTHENTICATED_QUERY_INPUT,
	DecoderHandle: sys_windows.HANDLE,
}

AUTHENTICATED_QUERY_CRYPTO_SESSION_OUTPUT :: struct {
	Output:              AUTHENTICATED_QUERY_OUTPUT,
	DecoderHandle:       sys_windows.HANDLE,
	CryptoSessionHandle: sys_windows.HANDLE,
	DeviceHandle:        sys_windows.HANDLE,
}

AUTHENTICATED_QUERY_CURRENT_ACCESSIBILITY_ENCRYPTION_OUTPUT :: struct {
	Output:         AUTHENTICATED_QUERY_OUTPUT,
	EncryptionGuid: sys_windows.GUID,
}

AUTHENTICATED_QUERY_DEVICE_HANDLE_OUTPUT :: struct {
	Output:       AUTHENTICATED_QUERY_OUTPUT,
	DeviceHandle: sys_windows.HANDLE,
}

AUTHENTICATED_QUERY_INPUT :: struct {
	QueryType:      sys_windows.GUID,
	hChannel:       sys_windows.HANDLE,
	SequenceNumber: u32,
}

AUTHENTICATED_QUERY_OUTPUT :: struct {
	omac:           OMAC,
	QueryType:      sys_windows.GUID,
	hChannel:       sys_windows.HANDLE,
	SequenceNumber: u32,
	ReturnCode:     sys_windows.HRESULT,
}

AUTHENTICATED_QUERY_OUTPUT_ID_COUNT_INPUT :: struct {
	Input:               AUTHENTICATED_QUERY_INPUT,
	DeviceHandle:        sys_windows.HANDLE,
	CryptoSessionHandle: sys_windows.HANDLE,
}

AUTHENTICATED_QUERY_OUTPUT_ID_COUNT_OUTPUT :: struct {
	Output:              AUTHENTICATED_QUERY_OUTPUT,
	DeviceHandle:        sys_windows.HANDLE,
	CryptoSessionHandle: sys_windows.HANDLE,
	OutputIDCount:       u32,
}

AUTHENTICATED_QUERY_OUTPUT_ID_INPUT :: struct {
	Input:               AUTHENTICATED_QUERY_INPUT,
	DeviceHandle:        sys_windows.HANDLE,
	CryptoSessionHandle: sys_windows.HANDLE,
	OutputIDIndex:       u32,
}

AUTHENTICATED_QUERY_OUTPUT_ID_OUTPUT :: struct {
	Output:              AUTHENTICATED_QUERY_OUTPUT,
	DeviceHandle:        sys_windows.HANDLE,
	CryptoSessionHandle: sys_windows.HANDLE,
	OutputIDIndex:       u32,
	OutputID:            u64,
}

AUTHENTICATED_QUERY_PROTECTION_OUTPUT :: struct {
	Output:          AUTHENTICATED_QUERY_OUTPUT,
	ProtectionFlags: AUTHENTICATED_PROTECTION_FLAGS,
}

AUTHENTICATED_QUERY_RESTRICTED_SHARED_RESOURCE_PROCESS_COUNT_OUTPUT :: struct {
	Output:                               AUTHENTICATED_QUERY_OUTPUT,
	RestrictedSharedResourceProcessCount: u32,
}

AUTHENTICATED_QUERY_RESTRICTED_SHARED_RESOURCE_PROCESS_INPUT :: struct {
	Input:        AUTHENTICATED_QUERY_INPUT,
	ProcessIndex: u32,
}

AUTHENTICATED_QUERY_RESTRICTED_SHARED_RESOURCE_PROCESS_OUTPUT :: struct {
	Output:            AUTHENTICATED_QUERY_OUTPUT,
	ProcessIndex:      u32,
	ProcessIdentifier: AUTHENTICATED_PROCESS_IDENTIFIER_TYPE,
	ProcessHandle:     sys_windows.HANDLE,
}

AUTHENTICATED_QUERY_UNRESTRICTED_PROTECTED_SHARED_RESOURCE_COUNT_OUTPUT :: struct {
	Output:                                   AUTHENTICATED_QUERY_OUTPUT,
	UnrestrictedProtectedSharedResourceCount: u32,
}

BIND_FLAG :: enum u32 {
	VERTEX_BUFFER    = 0, 
	INDEX_BUFFER     = 1, 
	CONSTANT_BUFFER  = 2, 
	SHADER_RESOURCE  = 3, 
	STREAM_OUTPUT    = 4, 
	RENDER_TARGET    = 5, 
	DEPTH_STENCIL    = 6, 
	UNORDERED_ACCESS = 7, 
	DECODER          = 9, 
	VIDEO_ENCODER    = 10, 
}

BIND_FLAGS :: distinct bit_set[BIND_FLAG; u32]

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,
}

BUFFEREX_SRV :: struct {
	FirstElement: u32,
	NumElements:  u32,
	Flags:        BUFFEREX_SRV_FLAGS,
}

BUFFEREX_SRV_FLAG :: enum u32 {
	RAW = 0, 
}

BUFFEREX_SRV_FLAGS :: distinct bit_set[BUFFEREX_SRV_FLAG; u32]

BUFFER_DESC :: struct {
	ByteWidth:           u32,
	Usage:               USAGE,
	BindFlags:           BIND_FLAGS,
	CPUAccessFlags:      CPU_ACCESS_FLAGS,
	MiscFlags:           RESOURCE_MISC_FLAGS,
	StructureByteStride: u32,
}

BUFFER_RTV :: struct {
	using _: struct #raw_union {
		FirstElement:  u32,
		ElementOffset: u32,
	},
	using _: struct #raw_union {
		NumElements:  u32,
		ElementWidth: u32,
	},
}

BUFFER_SRV :: struct {
	using _: struct #raw_union {
		FirstElement:  u32,
		ElementOffset: u32,
	},
	using _: struct #raw_union {
		NumElements:  u32,
		ElementWidth: u32,
	},
}

BUFFER_UAV :: struct {
	FirstElement: u32,
	NumElements:  u32,
	Flags:        BUFFER_UAV_FLAGS,
}

BUFFER_UAV_FLAG :: enum u32 {
	RAW     = 0, 
	APPEND  = 1, 
	COUNTER = 2, 
}

BUFFER_UAV_FLAGS :: distinct bit_set[BUFFER_UAV_FLAG; u32]

BUS_TYPE :: enum i32 {
	OTHER                                  = 0, 
	PCI                                    = 1, 
	PCIX                                   = 2, 
	PCIEXPRESS                             = 3, 
	AGP                                    = 4, 
	NSIDE_OF_CHIPSET                       = 65536, 
	RACKS_ON_MOTHER_BOARD_TO_CHIP          = 131072, 
	RACKS_ON_MOTHER_BOARD_TO_SOCKET        = 196608, 
	AUGHTER_BOARD_CONNECTOR                = 262144, 
	AUGHTER_BOARD_CONNECTOR_INSIDE_OF_NUAE = 327680, 
	ON_STANDARD                            = -2147843648, 
}

CBLEND_DESC :: struct {
	using d3d11_blend_desc: BLEND_DESC,
}

CBOX :: struct {
	using d3d11_box: BOX,
}

CBUFFER_DESC :: struct {
	using d3d11_buffer_desc: BUFFER_DESC,
}

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

CCOUNTER_DESC :: struct {
	using d3d11_counter_desc: COUNTER_DESC,
}

CDEFAULT :: struct {
	_: u8,
}

CDEPTH_STENCIL_DESC :: struct {
	using d3d11_depth_stencil_desc: DEPTH_STENCIL_DESC,
}

CDEPTH_STENCIL_VIEW_DESC :: struct {
	using d3d11_depth_stencil_view_desc: DEPTH_STENCIL_VIEW_DESC,
}

CLASS_INSTANCE_DESC :: struct {
	InstanceId:               u32,
	InstanceIndex:            u32,
	TypeId:                   u32,
	ConstantBuffer:           u32,
	BaseConstantBufferOffset: u32,
	BaseTexture:              u32,
	BaseSampler:              u32,
	Created:                  sys_windows.BOOL,
}

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

CLEAR_FLAGS :: distinct bit_set[CLEAR_FLAG; u32]

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

COLOR_WRITE_ENABLE_MASK :: distinct bit_set[COLOR_WRITE_ENABLE; u32]

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

COMPONENT_MASK :: distinct bit_set[COMPONENT_MASK_ELEMENT; u32]

COMPONENT_MASK_ELEMENT :: enum u32 {
	X = 1, 
	Y = 2, 
	Z = 4, 
	W = 8, 
}

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

CONTENT_PROTECTION_CAPS :: enum i32 {
	SOFTWARE                                  = 1, 
	HARDWARE                                  = 2, 
	PROTECTION_ALWAYS_ON                      = 4, 
	PARTIAL_DECRYPTION                        = 8, 
	CONTENT_KEY                               = 16, 
	FRESHEN_SESSION_KEY                       = 32, 
	ENCRYPTED_READ_BACK                       = 64, 
	ENCRYPTED_READ_BACK_KEY                   = 128, 
	SEQUENTIAL_CTR_IV                         = 256, 
	ENCRYPT_SLICEDATA_ONLY                    = 512, 
	DECRYPTION_BLT                            = 1024, 
	HARDWARE_PROTECT_UNCOMPRESSED             = 2048, 
	HARDWARE_PROTECTED_MEMORY_PAGEABLE        = 4096, 
	HARDWARE_TEARDOWN                         = 8192, 
	HARDWARE_DRM_COMMUNICATION                = 16384, 
	HARDWARE_DRM_COMMUNICATION_MULTI_THREADED = 32768, 
}

COUNTER :: enum i32 {
	DEVICE_DEPENDENT_0 = 1073741824, 
}

COUNTER_DESC :: struct {
	Counter:   COUNTER,
	MiscFlags: RESOURCE_MISC_FLAGS,
}

COUNTER_INFO :: struct {
	LastDeviceDependentCounter: COUNTER,
	NumSimultaneousCounters:    u32,
	NumDetectableParallelUnits: u8,
}

COUNTER_TYPE :: enum i32 {
	FLOAT32 = 0, 
	UINT16  = 1, 
	UINT32  = 2, 
	UINT64  = 3, 
}

CPU_ACCESS_FLAG :: enum u32 {
	WRITE = 16, 
	READ  = 17, 
}

CPU_ACCESS_FLAGS :: distinct bit_set[CPU_ACCESS_FLAG; u32]

CQUERY_DESC :: struct {
	using d3d11_query_desc: QUERY_DESC,
}

CRASTERIZER_DESC :: struct {
	using d3d11_rasterizer_desc: RASTERIZER_DESC,
}

CREATE_DEVICE_FLAG :: enum u32 {
	SINGLETHREADED                                = 0, 
	DEBUG                                         = 1, 
	SWITCH_TO_REF                                 = 2, 
	PREVENT_INTERNAL_THREADING_OPTIMIZATIONS      = 3, 
	BGRA_SUPPORT                                  = 5, 
	DEBUGGABLE                                    = 6, 
	PREVENT_ALTERING_LAYER_SETTINGS_FROM_REGISTRY = 7, 
	DISABLE_GPU_TIMEOUT                           = 8, 
	VIDEO_SUPPORT                                 = 11, 
}

CREATE_DEVICE_FLAGS :: distinct bit_set[CREATE_DEVICE_FLAG; u32]

CRECT :: struct {
	using d3d11_rect: sys_windows.RECT,
}

CRENDER_TARGET_VIEW_DESC :: struct {
	using d3d11_render_target_view_desc: RENDER_TARGET_VIEW_DESC,
}

CSAMPLER_DESC :: struct {
	using d3d11_sampler_desc: SAMPLER_DESC,
}

CSHADER_RESOURCE_VIEW_DESC :: struct {
	using d3d11_shader_resource_view_desc: SHADER_RESOURCE_VIEW_DESC,
}

CTEXTURE1D_DESC :: struct {
	using d3d11_texture1d_desc: TEXTURE1D_DESC,
}

CTEXTURE2D_DESC :: struct {
	using d3d11_texture2d_desc: TEXTURE2D_DESC,
}

CTEXTURE3D_DESC :: struct {
	using d3d11_texture3d_desc: TEXTURE3D_DESC,
}

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

CUNORDERED_ACCESS_VIEW_DESC :: struct {
	using d3d11_unordered_access_view_desc: UNORDERED_ACCESS_VIEW_DESC,
}

CVIDEO_DEFAULT :: struct {
	_: u8,
}

CVIEWPORT :: struct {
	using d3d11_viewport: VIEWPORT,
}

DEBUG_FEATURE :: enum u32 {
	FLUSH_PER_RENDER_OP           = 0, 
	FINISH_PER_RENDER_OP          = 1, 
	FEATURE_PRESENT_PER_RENDER_OP = 2, 
}

DEBUG_FEATURES :: distinct bit_set[DEBUG_FEATURE; u32]

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_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, 
}

DEVICE_CONTEXT_TYPE :: enum i32 {
	IMMEDIATE = 0, 
	DEFERRED  = 1, 
}

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

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

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 {
	DEPTH   = 0, 
	STENCIL = 1, 
}

DSV_FLAGS :: distinct bit_set[DSV_FLAG; u32]

ENCRYPTED_BLOCK_INFO :: struct {
	NumEncryptedBytesAtBeginning: u32,
	NumBytesInSkipPattern:        u32,
	NumBytesInEncryptPattern:     u32,
}

FEATURE :: enum i32 {
	THREADING                      = 0, 
	DOUBLES                        = 1, 
	FORMAT_SUPPORT                 = 2, 
	FORMAT_SUPPORT2                = 3, 
	D3D10_X_HARDWARE_OPTIONS       = 4, 
	OPTIONS                        = 5, 
	ARCHITECTURE_INFO              = 6, 
	D3D9_OPTIONS                   = 7, 
	SHADER_MIN_PRECISION_SUPPORT   = 8, 
	D3D9_SHADOW_SUPPORT            = 9, 
	OPTIONS1                       = 10, 
	D3D9_SIMPLE_INSTANCING_SUPPORT = 11, 
	MARKER_SUPPORT                 = 12, 
	D3D9_OPTIONS1                  = 13, 
	OPTIONS2                       = 14, 
	OPTIONS3                       = 15, 
	GPU_VIRTUAL_ADDRESS_SUPPORT    = 16, 
	OPTIONS4                       = 17, 
	SHADER_CACHE                   = 18, 
	OPTIONS5                       = 19, 
}

FEATURE_DATA_ARCHITECTURE_INFO :: struct {
	TileBasedDeferredRenderer: sys_windows.BOOL,
}

FEATURE_DATA_D3D10_X_HARDWARE_OPTIONS :: struct {
	ComputeShaders_Plus_RawAndStructuredBuffers_Via_Shader_4_x: sys_windows.BOOL,
}

FEATURE_DATA_D3D9_OPTIONS :: struct {
	FullNonPow2TextureSupport: sys_windows.BOOL,
}

FEATURE_DATA_D3D9_OPTIONS1 :: struct {
	FullNonPow2TextureSupported:                                 sys_windows.BOOL,
	DepthAsTextureWithLessEqualComparisonFilterSupported:        sys_windows.BOOL,
	SimpleInstancingSupported:                                   sys_windows.BOOL,
	TextureCubeFaceRenderTargetWithNonCubeDepthStencilSupported: sys_windows.BOOL,
}

FEATURE_DATA_D3D9_SHADOW_SUPPORT :: struct {
	SupportsDepthAsTextureWithLessEqualComparisonFilter: sys_windows.BOOL,
}

FEATURE_DATA_D3D9_SIMPLE_INSTANCING_SUPPORT :: struct {
	SimpleInstancingSupported: sys_windows.BOOL,
}

FEATURE_DATA_DOUBLES :: struct {
	DoublePrecisionFloatShaderOps: sys_windows.BOOL,
}

FEATURE_DATA_FORMAT_SUPPORT :: struct {
	InFormat:         directx_dxgi.FORMAT,
	OutFormatSupport: u32,
}

FEATURE_DATA_FORMAT_SUPPORT2 :: struct {
	InFormat:          directx_dxgi.FORMAT,
	OutFormatSupport2: u32,
}

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

FEATURE_DATA_MARKER_SUPPORT :: struct {
	Profile: sys_windows.BOOL,
}

FEATURE_DATA_OPTIONS :: struct {
	OutputMergerLogicOp:                    sys_windows.BOOL,
	UAVOnlyRenderingForcedSampleCount:      sys_windows.BOOL,
	DiscardAPIsSeenByDriver:                sys_windows.BOOL,
	FlagsForUpdateAndCopySeenByDriver:      sys_windows.BOOL,
	ClearView:                              sys_windows.BOOL,
	CopyWithOverlap:                        sys_windows.BOOL,
	ConstantBufferPartialUpdate:            sys_windows.BOOL,
	ConstantBufferOffsetting:               sys_windows.BOOL,
	MapNoOverwriteOnDynamicConstantBuffer:  sys_windows.BOOL,
	MapNoOverwriteOnDynamicBufferSRV:       sys_windows.BOOL,
	MultisampleRTVWithForcedSampleCountOne: sys_windows.BOOL,
	SAD4ShaderInstructions:                 sys_windows.BOOL,
	ExtendedDoublesShaderInstructions:      sys_windows.BOOL,
	ExtendedResourceSharing:                sys_windows.BOOL,
}

FEATURE_DATA_OPTIONS1 :: struct {
	TiledResourcesTier:                    TILED_RESOURCES_TIER,
	MinMaxFiltering:                       sys_windows.BOOL,
	ClearViewAlsoSupportsDepthOnlyFormats: sys_windows.BOOL,
	MapOnDefaultBuffers:                   sys_windows.BOOL,
}

FEATURE_DATA_OPTIONS2 :: struct {
	PSSpecifiedStencilRefSupported: sys_windows.BOOL,
	TypedUAVLoadAdditionalFormats:  sys_windows.BOOL,
	ROVsSupported:                  sys_windows.BOOL,
	ConservativeRasterizationTier:  CONSERVATIVE_RASTERIZATION_TIER,
	TiledResourcesTier:             TILED_RESOURCES_TIER,
	MapOnDefaultTextures:           sys_windows.BOOL,
	StandardSwizzle:                sys_windows.BOOL,
	UnifiedMemoryArchitecture:      sys_windows.BOOL,
}

FEATURE_DATA_OPTIONS3 :: struct {
	VPAndRTArrayIndexFromAnyShaderFeedingRasterizer: sys_windows.BOOL,
}

FEATURE_DATA_OPTIONS5 :: struct {
	SharedResourceTier: SHARED_RESOURCE_TIER,
}

FEATURE_DATA_SHADER_CACHE :: struct {
	SupportFlags: SHADER_CACHE_SUPPORT_FLAGS,
}

FEATURE_DATA_SHADER_MIN_PRECISION_SUPPORT :: struct {
	PixelShaderMinPrecision:          u32,
	AllOtherShaderStagesMinPrecision: u32,
}

FEATURE_DATA_THREADING :: struct {
	DriverConcurrentCreates: sys_windows.BOOL,
	DriverCommandLists:      sys_windows.BOOL,
}

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, 
}

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_SUPPORT :: enum i32 {
	// TODO: make bit_set
	BUFFER                      = 1, 
	IA_VERTEX_BUFFER            = 2, 
	IA_INDEX_BUFFER             = 4, 
	SO_BUFFER                   = 8, 
	TEXTURE1D                   = 16, 
	TEXTURE2D                   = 32, 
	TEXTURE3D                   = 64, 
	TEXTURECUBE                 = 128, 
	SHADER_LOAD                 = 256, 
	SHADER_SAMPLE               = 512, 
	SHADER_SAMPLE_COMPARISON    = 1024, 
	SHADER_SAMPLE_MONO_TEXT     = 2048, 
	MIP                         = 4096, 
	MIP_AUTOGEN                 = 8192, 
	RENDER_TARGET               = 16384, 
	BLENDABLE                   = 32768, 
	DEPTH_STENCIL               = 65536, 
	CPU_LOCKABLE                = 131072, 
	MULTISAMPLE_RESOLVE         = 262144, 
	DISPLAY                     = 524288, 
	CAST_WITHIN_BIT_LAYOUT      = 1048576, 
	MULTISAMPLE_RENDERTARGET    = 2097152, 
	MULTISAMPLE_LOAD            = 4194304, 
	SHADER_GATHER               = 8388608, 
	BACK_BUFFER_CAST            = 16777216, 
	TYPED_UNORDERED_ACCESS_VIEW = 33554432, 
	SHADER_GATHER_COMPARISON    = 67108864, 
	DECODER_OUTPUT              = 134217728, 
	VIDEO_PROCESSOR_OUTPUT      = 268435456, 
	VIDEO_PROCESSOR_INPUT       = 536870912, 
	VIDEO_ENCODER               = 1073741824, 
}

FORMAT_SUPPORT2 :: enum i32 {
	// TODO: make bit_set
	UAV_ATOMIC_ADD                               = 1, 
	UAV_ATOMIC_BITWISE_OPS                       = 2, 
	UAV_ATOMIC_COMPARE_STORE_OR_COMPARE_EXCHANGE = 4, 
	UAV_ATOMIC_EXCHANGE                          = 8, 
	UAV_ATOMIC_SIGNED_MIN_OR_MAX                 = 16, 
	UAV_ATOMIC_UNSIGNED_MIN_OR_MAX               = 32, 
	UAV_TYPED_LOAD                               = 64, 
	UAV_TYPED_STORE                              = 128, 
	OUTPUT_MERGER_LOGIC_OP                       = 256, 
	TILED                                        = 512, 
	SHAREABLE                                    = 1024, 
	MULTIPLANE_OVERLAY                           = 16384, 
}

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:        SHADER_REQUIRES_FLAGS,
	Name:                        cstring,
	FunctionParameterCount:      i32,
	HasReturn:                   sys_windows.BOOL,
	Has10Level9VertexShader:     sys_windows.BOOL,
	Has10Level9PixelShader:      sys_windows.BOOL,
}

GUID :: sys_windows.GUID

HANDLE :: sys_windows.HANDLE

HMODULE :: sys_windows.HMODULE

HRESULT :: sys_windows.HRESULT

IAsynchronous :: struct #raw_union {
	id3d11devicechild:         IDeviceChild,
	using id3d11asynchronous_vtable: ^IAsynchronous_VTable,
}

IAsynchronous_VTable :: struct {
	using id3d11devicechild_vtable: IDeviceChild_VTable,
	GetDataSize:              proc "stdcall" (this: ^IAsynchronous) -> u32,
}

IAuthenticatedChannel :: struct #raw_union {
	id3d11devicechild:                 IDeviceChild,
	using id3d11authenticatedchannel_vtable: ^IAuthenticatedChannel_VTable,
}

IAuthenticatedChannel_VTable :: struct {
	using id3d11devicechild_vtable: IDeviceChild_VTable,
	GetCertificateSize:       proc "stdcall" (this: ^IAuthenticatedChannel, pCertificateSize: ^u32) -> sys_windows.HRESULT,
	GetCertificate:           proc "stdcall" (this: ^IAuthenticatedChannel, CertificateSize: u32, pCertificate: cstring) -> sys_windows.HRESULT,
	GetChannelHandle:         proc "stdcall" (this: ^IAuthenticatedChannel, pChannelHandle: ^sys_windows.HANDLE),
}

IBlendState :: struct #raw_union {
	id3d11devicechild:       IDeviceChild,
	using id3d11blendstate_vtable: ^IBlendState_VTable,
}

IBlendState_VTable :: struct {
	using id3d11devicechild_vtable: IDeviceChild_VTable,
	GetDesc:                  proc "stdcall" (this: ^IBlendState, pDesc: ^BLEND_DESC),
}

IBlob :: directx_d3d_compiler.ID3D10Blob

IBuffer :: struct #raw_union {
	id3d11resource:      IResource,
	using id3d11buffer_vtable: ^IBuffer_VTable,
}

IBuffer_VTable :: struct {
	using id3d11resource_vtable: IResource_VTable,
	GetDesc:               proc "stdcall" (this: ^IBuffer, pDesc: ^BUFFER_DESC),
}

IClassInstance :: struct #raw_union {
	id3d11devicechild:          IDeviceChild,
	using id3d11classinstance_vtable: ^IClassInstance_VTable,
}

IClassInstance_VTable :: struct {
	using id3d11devicechild_vtable: IDeviceChild_VTable,
	GetClassLinkage:          proc "stdcall" (this: ^IClassInstance, ppLinkage: ^^IClassLinkage),
	GetDesc:                  proc "stdcall" (this: ^IClassInstance, pDesc: ^CLASS_INSTANCE_DESC),
	GetInstanceName:          proc "stdcall" (this: ^IClassInstance, pInstanceName: cstring, pBufferLength: ^uint),
	GetTypeName:              proc "stdcall" (this: ^IClassInstance, pTypeName: cstring, pBufferLength: ^uint),
}

IClassLinkage :: struct #raw_union {
	id3d11devicechild:         IDeviceChild,
	using id3d11classlinkage_vtable: ^IClassLinkage_VTable,
}

IClassLinkage_VTable :: struct {
	using id3d11devicechild_vtable: IDeviceChild_VTable,
	GetClassInstance:         proc "stdcall" (this: ^IClassLinkage, pClassInstanceName: cstring, InstanceIndex: u32, ppInstance: ^^IClassInstance) -> sys_windows.HRESULT,
	CreateClassInstance:      proc "stdcall" (this: ^IClassLinkage, pClassTypeName: cstring, ConstantBufferOffset: u32, ConstantVectorOffset: u32, TextureOffset: u32, SamplerOffset: u32, ppInstance: ^^IClassInstance) -> sys_windows.HRESULT,
}

ICommandList :: struct #raw_union {
	id3d11devicechild:        IDeviceChild,
	using id3d11commandlist_vtable: ^ICommandList_VTable,
}

ICommandList_VTable :: struct {
	using id3d11devicechild_vtable: IDeviceChild_VTable,
	GetContextFlags:          proc "stdcall" (this: ^ICommandList) -> u32,
}

IComputeShader :: struct {
	using id3d11devicechild: IDeviceChild,
}

ICounter :: struct #raw_union {
	id3d11asynchronous:   IAsynchronous,
	using id3d11counter_vtable: ^ICounter_VTable,
}

ICounter_VTable :: struct {
	using id3d11asynchronous_vtable: IAsynchronous_VTable,
	GetDesc:                   proc "stdcall" (this: ^ICounter, pDesc: ^COUNTER_DESC),
}

ICryptoSession :: struct #raw_union {
	id3d11devicechild:          IDeviceChild,
	using id3d11cryptosession_vtable: ^ICryptoSession_VTable,
}

ICryptoSession_VTable :: struct {
	using id3d11devicechild_vtable: IDeviceChild_VTable,
	GetCryptoType:            proc "stdcall" (this: ^ICryptoSession, pCryptoType: ^sys_windows.GUID),
	GetDecoderProfile:        proc "stdcall" (this: ^ICryptoSession, pDecoderProfile: ^sys_windows.GUID),
	GetCertificateSize:       proc "stdcall" (this: ^ICryptoSession, pCertificateSize: ^u32) -> sys_windows.HRESULT,
	GetCertificate:           proc "stdcall" (this: ^ICryptoSession, CertificateSize: u32, pCertificate: cstring) -> sys_windows.HRESULT,
	GetCryptoSessionHandle:   proc "stdcall" (this: ^ICryptoSession, pCryptoSessionHandle: ^sys_windows.HANDLE),
}

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,
}

ID3DUserDefinedAnnotation :: struct #raw_union {
	iunknown: sys_windows.IUnknown,
	using vtable: ^ID3DUserDefinedAnnotation_VTable,
}

ID3DUserDefinedAnnotation_VTable :: struct {
	using iunknown_vtable: sys_windows.IUnknown_VTable,
	BeginEvent:      proc "stdcall" (this: ^ID3DUserDefinedAnnotation, Name: [^]u16) -> i32,
	EndEvent:        proc "stdcall" (this: ^ID3DUserDefinedAnnotation) -> i32,
	SetMarker:       proc "stdcall" (this: ^ID3DUserDefinedAnnotation, Name: [^]u16),
	GetStatus:       proc "stdcall" (this: ^ID3DUserDefinedAnnotation) -> sys_windows.BOOL,
}

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

IDebug_VTable :: struct {
	using iunkown_vtable:       sys_windows.IUnknown_VTable,
	SetFeatureMask:             proc "stdcall" (this: ^IDebug, mask: DEBUG_FEATURES) -> sys_windows.HRESULT,
	GetFeatureMask:             proc "stdcall" (this: ^IDebug) -> DEBUG_FEATURES,
	SetPresentPerRenderOpDelay: proc "stdcall" (this: ^IDebug, Milliseconds: u32) -> sys_windows.HRESULT,
	GetPresentPerRenderOpDelay: proc "stdcall" (this: ^IDebug) -> u32,
	SetSwapChain:               proc "stdcall" (this: ^IDebug, pSwapChain: ^directx_dxgi.ISwapChain) -> sys_windows.HRESULT,
	GetSwapChain:               proc "stdcall" (this: ^IDebug, ppSwapChain: ^^directx_dxgi.ISwapChain) -> sys_windows.HRESULT,
	ValidateContext:            proc "stdcall" (this: ^IDebug, pContext: ^IDeviceContext) -> sys_windows.HRESULT,
	ReportLiveDeviceObjects:    proc "stdcall" (this: ^IDebug, Flags: RLDO_FLAGS) -> sys_windows.HRESULT,
	ValidateContextForDispatch: proc "stdcall" (this: ^IDebug, pContext: ^IDeviceContext) -> sys_windows.HRESULT,
}

IDepthStencilState :: struct #raw_union {
	id3d11devicechild:              IDeviceChild,
	using id3d11depthstencilstate_vtable: ^IDepthStencilState_VTable,
}

IDepthStencilState_VTable :: struct {
	using id3d11devicechild_vtable: IDeviceChild_VTable,
	GetDesc:                  proc "stdcall" (this: ^IDepthStencilState, pDesc: ^DEPTH_STENCIL_DESC),
}

IDepthStencilView :: struct #raw_union {
	id3d11view:                    IView,
	using id3d11depthstencilview_vtable: ^IDepthStencilView_VTable,
}

IDepthStencilView_VTable :: struct {
	using id3d11view_vtable: IView_VTable,
	GetDesc:           proc "stdcall" (this: ^IDepthStencilView, pDesc: ^DEPTH_STENCIL_VIEW_DESC),
}

IDevice :: struct #raw_union {
	iunknown:            sys_windows.IUnknown,
	using id3d11device_vtable: ^IDevice_VTable,
}

IDeviceChild :: struct #raw_union {
	iunknown:                 sys_windows.IUnknown,
	using id3d11devicechild_vtable: ^IDeviceChild_VTable,
}

IDeviceChild_VTable :: struct {
	using iunknown_vtable:   sys_windows.IUnknown_VTable,
	GetDevice:               proc "stdcall" (this: ^IDeviceChild, ppDevice: ^^IDevice),
	GetPrivateData:          proc "stdcall" (this: ^IDeviceChild, guid: ^sys_windows.GUID, pDataSize: ^u32, pData: rawptr) -> sys_windows.HRESULT,
	SetPrivateData:          proc "stdcall" (this: ^IDeviceChild, guid: ^sys_windows.GUID, DataSize: u32, pData: rawptr) -> sys_windows.HRESULT,
	SetPrivateDataInterface: proc "stdcall" (this: ^IDeviceChild, guid: ^sys_windows.GUID, pData: ^sys_windows.IUnknown) -> sys_windows.HRESULT,
}

IDeviceContext :: struct #raw_union {
	id3d11devicechild:          IDeviceChild,
	using id3d11devicecontext_vtable: ^IDeviceContext_VTable,
}

IDeviceContext_VTable :: struct {
	using id3d11devicechild_vtable:            IDeviceChild_VTable,
	VSSetConstantBuffers:                      proc "stdcall" (this: ^IDeviceContext, StartSlot: u32, NumBuffers: u32, ppConstantBuffers: [^]^IBuffer),
	PSSetShaderResources:                      proc "stdcall" (this: ^IDeviceContext, StartSlot: u32, NumViews: u32, ppShaderResourceViews: [^]^IShaderResourceView),
	PSSetShader:                               proc "stdcall" (this: ^IDeviceContext, pPixelShader: ^IPixelShader, ppClassInstances: [^]^IClassInstance, NumClassInstances: u32),
	PSSetSamplers:                             proc "stdcall" (this: ^IDeviceContext, StartSlot: u32, NumSamplers: u32, ppSamplers: [^]^ISamplerState),
	VSSetShader:                               proc "stdcall" (this: ^IDeviceContext, pVertexShader: ^IVertexShader, ppClassInstances: [^]^IClassInstance, NumClassInstances: u32),
	DrawIndexed:                               proc "stdcall" (this: ^IDeviceContext, IndexCount: u32, StartIndexLocation: u32, BaseVertexLocation: i32),
	Draw:                                      proc "stdcall" (this: ^IDeviceContext, VertexCount: u32, StartVertexLocation: u32),
	Map:                                       proc "stdcall" (this: ^IDeviceContext, pResource: ^IResource, Subresource: u32, MapType: MAP, MapFlags: MAP_FLAGS, pMappedResource: ^MAPPED_SUBRESOURCE) -> sys_windows.HRESULT,
	Unmap:                                     proc "stdcall" (this: ^IDeviceContext, pResource: ^IResource, Subresource: u32),
	PSSetConstantBuffers:                      proc "stdcall" (this: ^IDeviceContext, StartSlot: u32, NumBuffers: u32, ppConstantBuffers: [^]^IBuffer),
	IASetInputLayout:                          proc "stdcall" (this: ^IDeviceContext, pInputLayout: ^IInputLayout),
	IASetVertexBuffers:                        proc "stdcall" (this: ^IDeviceContext, StartSlot: u32, NumBuffers: u32, ppVertexBuffers: [^]^IBuffer, pStrides: [^]u32, pOffsets: [^]u32),
	IASetIndexBuffer:                          proc "stdcall" (this: ^IDeviceContext, pIndexBuffer: ^IBuffer, Format: directx_dxgi.FORMAT, Offset: u32),
	DrawIndexedInstanced:                      proc "stdcall" (this: ^IDeviceContext, IndexCountPerInstance: u32, InstanceCount: u32, StartIndexLocation: u32, BaseVertexLocation: i32, StartInstanceLocation: u32),
	DrawInstanced:                             proc "stdcall" (this: ^IDeviceContext, VertexCountPerInstance: u32, InstanceCount: u32, StartVertexLocation: u32, StartInstanceLocation: u32),
	GSSetConstantBuffers:                      proc "stdcall" (this: ^IDeviceContext, StartSlot: u32, NumBuffers: u32, ppConstantBuffers: [^]^IBuffer),
	GSSetShader:                               proc "stdcall" (this: ^IDeviceContext, pShader: ^IGeometryShader, ppClassInstances: [^]^IClassInstance, NumClassInstances: u32),
	IASetPrimitiveTopology:                    proc "stdcall" (this: ^IDeviceContext, Topology: PRIMITIVE_TOPOLOGY),
	VSSetShaderResources:                      proc "stdcall" (this: ^IDeviceContext, StartSlot: u32, NumViews: u32, ppShaderResourceViews: [^]^IShaderResourceView),
	VSSetSamplers:                             proc "stdcall" (this: ^IDeviceContext, StartSlot: u32, NumSamplers: u32, ppSamplers: [^]^ISamplerState),
	Begin:                                     proc "stdcall" (this: ^IDeviceContext, pAsync: ^IAsynchronous),
	End:                                       proc "stdcall" (this: ^IDeviceContext, pAsync: ^IAsynchronous),
	GetData:                                   proc "stdcall" (this: ^IDeviceContext, pAsync: ^IAsynchronous, pData: rawptr, DataSize: u32, GetDataFlags: u32) -> sys_windows.HRESULT,
	SetPredication:                            proc "stdcall" (this: ^IDeviceContext, pPredicate: ^IPredicate, PredicateValue: sys_windows.BOOL),
	GSSetShaderResources:                      proc "stdcall" (this: ^IDeviceContext, StartSlot: u32, NumViews: u32, ppShaderResourceViews: [^]^IShaderResourceView),
	GSSetSamplers:                             proc "stdcall" (this: ^IDeviceContext, StartSlot: u32, NumSamplers: u32, ppSamplers: [^]^ISamplerState),
	OMSetRenderTargets:                        proc "stdcall" (this: ^IDeviceContext, NumViews: u32, ppRenderTargetViews: [^]^IRenderTargetView, pDepthStencilView: ^IDepthStencilView),
	OMSetRenderTargetsAndUnorderedAccessViews: proc "stdcall" (this: ^IDeviceContext, NumRTVs: u32, ppRenderTargetViews: [^]^IRenderTargetView, pDepthStencilView: ^IDepthStencilView, UAVStartSlot: u32, NumUAVs: u32, ppUnorderedAccessViews: [^]^IUnorderedAccessView, pUAVInitialCounts: [^]u32),
	OMSetBlendState:                           proc "stdcall" (this: ^IDeviceContext, pBlendState: ^IBlendState, BlendFactor: ^[4]f32, SampleMask: u32),
	OMSetDepthStencilState:                    proc "stdcall" (this: ^IDeviceContext, pDepthStencilState: ^IDepthStencilState, StencilRef: u32),
	SOSetTargets:                              proc "stdcall" (this: ^IDeviceContext, NumBuffers: u32, ppSOTargets: [^]^IBuffer, pOffsets: [^]u32),
	DrawAuto:                                  proc "stdcall" (this: ^IDeviceContext),
	DrawIndexedInstancedIndirect:              proc "stdcall" (this: ^IDeviceContext, pBufferForArgs: ^IBuffer, AlignedByteOffsetForArgs: u32),
	DrawInstancedIndirect:                     proc "stdcall" (this: ^IDeviceContext, pBufferForArgs: ^IBuffer, AlignedByteOffsetForArgs: u32),
	Dispatch:                                  proc "stdcall" (this: ^IDeviceContext, ThreadGroupCountX: u32, ThreadGroupCountY: u32, ThreadGroupCountZ: u32),
	DispatchIndirect:                          proc "stdcall" (this: ^IDeviceContext, pBufferForArgs: ^IBuffer, AlignedByteOffsetForArgs: u32),
	RSSetState:                                proc "stdcall" (this: ^IDeviceContext, pRasterizerState: ^IRasterizerState),
	RSSetViewports:                            proc "stdcall" (this: ^IDeviceContext, NumViewports: u32, pViewports: [^]VIEWPORT),
	RSSetScissorRects:                         proc "stdcall" (this: ^IDeviceContext, NumRects: u32, pRects: [^]sys_windows.RECT),
	CopySubresourceRegion:                     proc "stdcall" (this: ^IDeviceContext, pDstResource: ^IResource, DstSubresource: u32, DstX: u32, DstY: u32, DstZ: u32, pSrcResource: ^IResource, SrcSubresource: u32, pSrcBox: ^BOX),
	CopyResource:                              proc "stdcall" (this: ^IDeviceContext, pDstResource: ^IResource, pSrcResource: ^IResource),
	UpdateSubresource:                         proc "stdcall" (this: ^IDeviceContext, pDstResource: ^IResource, DstSubresource: u32, pDstBox: ^BOX, pSrcData: rawptr, SrcRowPitch: u32, SrcDepthPitch: u32),
	CopyStructureCount:                        proc "stdcall" (this: ^IDeviceContext, pDstBuffer: ^IBuffer, DstAlignedByteOffset: u32, pSrcView: ^IUnorderedAccessView),
	ClearRenderTargetView:                     proc "stdcall" (this: ^IDeviceContext, pRenderTargetView: ^IRenderTargetView, ColorRGBA: ^[4]f32),
	ClearUnorderedAccessViewUint:              proc "stdcall" (this: ^IDeviceContext, pUnorderedAccessView: ^IUnorderedAccessView, Values: ^[4]u32),
	ClearUnorderedAccessViewFloat:             proc "stdcall" (this: ^IDeviceContext, pUnorderedAccessView: ^IUnorderedAccessView, Values: ^[4]f32),
	ClearDepthStencilView:                     proc "stdcall" (this: ^IDeviceContext, pDepthStencilView: ^IDepthStencilView, ClearFlags: CLEAR_FLAGS, Depth: f32, Stencil: u8),
	GenerateMips:                              proc "stdcall" (this: ^IDeviceContext, pShaderResourceView: ^IShaderResourceView),
	SetResourceMinLOD:                         proc "stdcall" (this: ^IDeviceContext, pResource: ^IResource, MinLOD: f32),
	GetResourceMinLOD:                         proc "stdcall" (this: ^IDeviceContext, pResource: ^IResource) -> f32,
	ResolveSubresource:                        proc "stdcall" (this: ^IDeviceContext, pDstResource: ^IResource, DstSubresource: u32, pSrcResource: ^IResource, SrcSubresource: u32, Format: directx_dxgi.FORMAT),
	ExecuteCommandList:                        proc "stdcall" (this: ^IDeviceContext, pCommandList: ^ICommandList, RestoreContextState: sys_windows.BOOL),
	HSSetShaderResources:                      proc "stdcall" (this: ^IDeviceContext, StartSlot: u32, NumViews: u32, ppShaderResourceViews: [^]^IShaderResourceView),
	HSSetShader:                               proc "stdcall" (this: ^IDeviceContext, pHullShader: ^IHullShader, ppClassInstances: [^]^IClassInstance, NumClassInstances: u32),
	HSSetSamplers:                             proc "stdcall" (this: ^IDeviceContext, StartSlot: u32, NumSamplers: u32, ppSamplers: [^]^ISamplerState),
	HSSetConstantBuffers:                      proc "stdcall" (this: ^IDeviceContext, StartSlot: u32, NumBuffers: u32, ppConstantBuffers: [^]^IBuffer),
	DSSetShaderResources:                      proc "stdcall" (this: ^IDeviceContext, StartSlot: u32, NumViews: u32, ppShaderResourceViews: [^]^IShaderResourceView),
	DSSetShader:                               proc "stdcall" (this: ^IDeviceContext, pDomainShader: ^IDomainShader, ppClassInstances: [^]^IClassInstance, NumClassInstances: u32),
	DSSetSamplers:                             proc "stdcall" (this: ^IDeviceContext, StartSlot: u32, NumSamplers: u32, ppSamplers: [^]^ISamplerState),
	DSSetConstantBuffers:                      proc "stdcall" (this: ^IDeviceContext, StartSlot: u32, NumBuffers: u32, ppConstantBuffers: [^]^IBuffer),
	CSSetShaderResources:                      proc "stdcall" (this: ^IDeviceContext, StartSlot: u32, NumViews: u32, ppShaderResourceViews: [^]^IShaderResourceView),
	CSSetUnorderedAccessViews:                 proc "stdcall" (this: ^IDeviceContext, StartSlot: u32, NumUAVs: u32, ppUnorderedAccessViews: [^]^IUnorderedAccessView, pUAVInitialCounts: [^]u32),
	CSSetShader:                               proc "stdcall" (this: ^IDeviceContext, pComputeShader: ^IComputeShader, ppClassInstances: [^]^IClassInstance, NumClassInstances: u32),
	CSSetSamplers:                             proc "stdcall" (this: ^IDeviceContext, StartSlot: u32, NumSamplers: u32, ppSamplers: [^]^ISamplerState),
	CSSetConstantBuffers:                      proc "stdcall" (this: ^IDeviceContext, StartSlot: u32, NumBuffers: u32, ppConstantBuffers: [^]^IBuffer),
	VSGetConstantBuffers:                      proc "stdcall" (this: ^IDeviceContext, StartSlot: u32, NumBuffers: u32, ppConstantBuffers: [^]^IBuffer),
	PSGetShaderResources:                      proc "stdcall" (this: ^IDeviceContext, StartSlot: u32, NumViews: u32, ppShaderResourceViews: [^]^IShaderResourceView),
	PSGetShader:                               proc "stdcall" (this: ^IDeviceContext, ppPixelShader: ^^IPixelShader, ppClassInstances: [^]^IClassInstance, pNumClassInstances: ^u32),
	PSGetSamplers:                             proc "stdcall" (this: ^IDeviceContext, StartSlot: u32, NumSamplers: u32, ppSamplers: [^]^ISamplerState),
	VSGetShader:                               proc "stdcall" (this: ^IDeviceContext, ppVertexShader: ^^IVertexShader, ppClassInstances: [^]^IClassInstance, pNumClassInstances: ^u32),
	PSGetConstantBuffers:                      proc "stdcall" (this: ^IDeviceContext, StartSlot: u32, NumBuffers: u32, ppConstantBuffers: [^]^IBuffer),
	IAGetInputLayout:                          proc "stdcall" (this: ^IDeviceContext, ppInputLayout: ^^IInputLayout),
	IAGetVertexBuffers:                        proc "stdcall" (this: ^IDeviceContext, StartSlot: u32, NumBuffers: u32, ppVertexBuffers: [^]^IBuffer, pStrides: [^]u32, pOffsets: [^]u32),
	IAGetIndexBuffer:                          proc "stdcall" (this: ^IDeviceContext, pIndexBuffer: ^^IBuffer, Format: ^directx_dxgi.FORMAT, Offset: ^u32),
	GSGetConstantBuffers:                      proc "stdcall" (this: ^IDeviceContext, StartSlot: u32, NumBuffers: u32, ppConstantBuffers: [^]^IBuffer),
	GSGetShader:                               proc "stdcall" (this: ^IDeviceContext, ppGeometryShader: ^^IGeometryShader, ppClassInstances: [^]^IClassInstance, pNumClassInstances: ^u32),
	IAGetPrimitiveTopology:                    proc "stdcall" (this: ^IDeviceContext, pTopology: ^PRIMITIVE_TOPOLOGY),
	VSGetShaderResources:                      proc "stdcall" (this: ^IDeviceContext, StartSlot: u32, NumViews: u32, ppShaderResourceViews: [^]^IShaderResourceView),
	VSGetSamplers:                             proc "stdcall" (this: ^IDeviceContext, StartSlot: u32, NumSamplers: u32, ppSamplers: [^]^ISamplerState),
	GetPredication:                            proc "stdcall" (this: ^IDeviceContext, ppPredicate: ^^IPredicate, pPredicateValue: ^sys_windows.BOOL),
	GSGetShaderResources:                      proc "stdcall" (this: ^IDeviceContext, StartSlot: u32, NumViews: u32, ppShaderResourceViews: [^]^IShaderResourceView),
	GSGetSamplers:                             proc "stdcall" (this: ^IDeviceContext, StartSlot: u32, NumSamplers: u32, ppSamplers: [^]^ISamplerState),
	OMGetRenderTargets:                        proc "stdcall" (this: ^IDeviceContext, NumViews: u32, ppRenderTargetViews: [^]^IRenderTargetView, ppDepthStencilView: ^^IDepthStencilView),
	OMGetRenderTargetsAndUnorderedAccessViews: proc "stdcall" (this: ^IDeviceContext, NumRTVs: u32, ppRenderTargetViews: [^]^IRenderTargetView, ppDepthStencilView: ^^IDepthStencilView, UAVStartSlot: u32, NumUAVs: u32, ppUnorderedAccessViews: [^]^IUnorderedAccessView),
	OMGetBlendState:                           proc "stdcall" (this: ^IDeviceContext, ppBlendState: ^^IBlendState, BlendFactor: ^[4]f32, pSampleMask: ^COLOR_WRITE_ENABLE_MASK),
	OMGetDepthStencilState:                    proc "stdcall" (this: ^IDeviceContext, ppDepthStencilState: ^^IDepthStencilState, pStencilRef: ^u32),
	SOGetTargets:                              proc "stdcall" (this: ^IDeviceContext, NumBuffers: u32, ppSOTargets: [^]^IBuffer),
	RSGetState:                                proc "stdcall" (this: ^IDeviceContext, ppRasterizerState: ^^IRasterizerState),
	RSGetViewports:                            proc "stdcall" (this: ^IDeviceContext, pNumViewports: ^u32, pViewports: [^]VIEWPORT),
	RSGetScissorRects:                         proc "stdcall" (this: ^IDeviceContext, pNumRects: ^u32, pRects: [^]sys_windows.RECT),
	HSGetShaderResources:                      proc "stdcall" (this: ^IDeviceContext, StartSlot: u32, NumViews: u32, ppShaderResourceViews: [^]^IShaderResourceView),
	HSGetShader:                               proc "stdcall" (this: ^IDeviceContext, ppHullShader: ^^IHullShader, ppClassInstances: [^]^IClassInstance, pNumClassInstances: ^u32),
	HSGetSamplers:                             proc "stdcall" (this: ^IDeviceContext, StartSlot: u32, NumSamplers: u32, ppSamplers: [^]^ISamplerState),
	HSGetConstantBuffers:                      proc "stdcall" (this: ^IDeviceContext, StartSlot: u32, NumBuffers: u32, ppConstantBuffers: [^]^IBuffer),
	DSGetShaderResources:                      proc "stdcall" (this: ^IDeviceContext, StartSlot: u32, NumViews: u32, ppShaderResourceViews: [^]^IShaderResourceView),
	DSGetShader:                               proc "stdcall" (this: ^IDeviceContext, ppDomainShader: ^^IDomainShader, ppClassInstances: [^]^IClassInstance, pNumClassInstances: ^u32),
	DSGetSamplers:                             proc "stdcall" (this: ^IDeviceContext, StartSlot: u32, NumSamplers: u32, ppSamplers: [^]^ISamplerState),
	DSGetConstantBuffers:                      proc "stdcall" (this: ^IDeviceContext, StartSlot: u32, NumBuffers: u32, ppConstantBuffers: [^]^IBuffer),
	CSGetShaderResources:                      proc "stdcall" (this: ^IDeviceContext, StartSlot: u32, NumViews: u32, ppShaderResourceViews: [^]^IShaderResourceView),
	CSGetUnorderedAccessViews:                 proc "stdcall" (this: ^IDeviceContext, StartSlot: u32, NumUAVs: u32, ppUnorderedAccessViews: [^]^IUnorderedAccessView),
	CSGetShader:                               proc "stdcall" (this: ^IDeviceContext, ppComputeShader: ^^IComputeShader, ppClassInstances: [^]^IClassInstance, pNumClassInstances: ^u32),
	CSGetSamplers:                             proc "stdcall" (this: ^IDeviceContext, StartSlot: u32, NumSamplers: u32, ppSamplers: [^]^ISamplerState),
	CSGetConstantBuffers:                      proc "stdcall" (this: ^IDeviceContext, StartSlot: u32, NumBuffers: u32, ppConstantBuffers: [^]^IBuffer),
	ClearState:                                proc "stdcall" (this: ^IDeviceContext),
	Flush:                                     proc "stdcall" (this: ^IDeviceContext),
	GetType:                                   proc "stdcall" (this: ^IDeviceContext) -> DEVICE_CONTEXT_TYPE,
	GetContextFlags:                           proc "stdcall" (this: ^IDeviceContext) -> u32,
	FinishCommandList:                         proc "stdcall" (this: ^IDeviceContext, RestoreDeferredContextState: sys_windows.BOOL, ppCommandList: ^^ICommandList) -> sys_windows.HRESULT,
}

IDevice_VTable :: struct {
	using iunknown_vtable:                sys_windows.IUnknown_VTable,
	CreateBuffer:                         proc "stdcall" (this: ^IDevice, pDesc: ^BUFFER_DESC, pInitialData: ^SUBRESOURCE_DATA, ppBuffer: ^^IBuffer) -> sys_windows.HRESULT,
	CreateTexture1D:                      proc "stdcall" (this: ^IDevice, pDesc: ^TEXTURE1D_DESC, pInitialData: ^SUBRESOURCE_DATA, ppTexture1D: ^^ITexture1D) -> sys_windows.HRESULT,
	CreateTexture2D:                      proc "stdcall" (this: ^IDevice, pDesc: ^TEXTURE2D_DESC, pInitialData: ^SUBRESOURCE_DATA, ppTexture2D: ^^ITexture2D) -> sys_windows.HRESULT,
	CreateTexture3D:                      proc "stdcall" (this: ^IDevice, pDesc: ^TEXTURE3D_DESC, pInitialData: ^SUBRESOURCE_DATA, ppTexture3D: ^^ITexture3D) -> sys_windows.HRESULT,
	CreateShaderResourceView:             proc "stdcall" (this: ^IDevice, pResource: ^IResource, pDesc: ^SHADER_RESOURCE_VIEW_DESC, ppSRView: ^^IShaderResourceView) -> sys_windows.HRESULT,
	CreateUnorderedAccessView:            proc "stdcall" (this: ^IDevice, pResource: ^IResource, pDesc: ^UNORDERED_ACCESS_VIEW_DESC, ppUAView: ^^IUnorderedAccessView) -> sys_windows.HRESULT,
	CreateRenderTargetView:               proc "stdcall" (this: ^IDevice, pResource: ^IResource, pDesc: ^RENDER_TARGET_VIEW_DESC, ppRTView: ^^IRenderTargetView) -> sys_windows.HRESULT,
	CreateDepthStencilView:               proc "stdcall" (this: ^IDevice, pResource: ^IResource, pDesc: ^DEPTH_STENCIL_VIEW_DESC, ppDepthStencilView: ^^IDepthStencilView) -> sys_windows.HRESULT,
	CreateInputLayout:                    proc "stdcall" (this: ^IDevice, pInputElementDescs: [^]INPUT_ELEMENT_DESC, NumElements: u32, pShaderBytecodeWithInputSignature: rawptr, BytecodeLength: uint, ppInputLayout: ^^IInputLayout) -> sys_windows.HRESULT,
	CreateVertexShader:                   proc "stdcall" (this: ^IDevice, pShaderBytecode: rawptr, BytecodeLength: uint, pClassLinkage: ^IClassLinkage, ppVertexShader: ^^IVertexShader) -> sys_windows.HRESULT,
	CreateGeometryShader:                 proc "stdcall" (this: ^IDevice, pShaderBytecode: rawptr, BytecodeLength: uint, pClassLinkage: ^IClassLinkage, ppGeometryShader: ^^IGeometryShader) -> sys_windows.HRESULT,
	CreateGeometryShaderWithStreamOutput: proc "stdcall" (this: ^IDevice, pShaderBytecode: rawptr, BytecodeLength: uint, pSODeclaration: ^SO_DECLARATION_ENTRY, NumEntries: u32, pBufferStrides: [^]u32, NumStrides: u32, RasterizedStream: u32, pClassLinkage: ^IClassLinkage, ppGeometryShader: ^^IGeometryShader) -> sys_windows.HRESULT,
	CreatePixelShader:                    proc "stdcall" (this: ^IDevice, pShaderBytecode: rawptr, BytecodeLength: uint, pClassLinkage: ^IClassLinkage, ppPixelShader: ^^IPixelShader) -> sys_windows.HRESULT,
	CreateHullShader:                     proc "stdcall" (this: ^IDevice, pShaderBytecode: rawptr, BytecodeLength: uint, pClassLinkage: ^IClassLinkage, ppHullShader: ^^IHullShader) -> sys_windows.HRESULT,
	CreateDomainShader:                   proc "stdcall" (this: ^IDevice, pShaderBytecode: rawptr, BytecodeLength: uint, pClassLinkage: ^IClassLinkage, ppDomainShader: ^^IDomainShader) -> sys_windows.HRESULT,
	CreateComputeShader:                  proc "stdcall" (this: ^IDevice, pShaderBytecode: rawptr, BytecodeLength: uint, pClassLinkage: ^IClassLinkage, ppComputeShader: ^^IComputeShader) -> sys_windows.HRESULT,
	CreateClassLinkage:                   proc "stdcall" (this: ^IDevice, ppLinkage: ^^IClassLinkage) -> sys_windows.HRESULT,
	CreateBlendState:                     proc "stdcall" (this: ^IDevice, pBlendStateDesc: ^BLEND_DESC, ppBlendState: ^^IBlendState) -> sys_windows.HRESULT,
	CreateDepthStencilState:              proc "stdcall" (this: ^IDevice, pDepthStencilDesc: ^DEPTH_STENCIL_DESC, ppDepthStencilState: ^^IDepthStencilState) -> sys_windows.HRESULT,
	CreateRasterizerState:                proc "stdcall" (this: ^IDevice, pRasterizerDesc: ^RASTERIZER_DESC, ppRasterizerState: ^^IRasterizerState) -> sys_windows.HRESULT,
	CreateSamplerState:                   proc "stdcall" (this: ^IDevice, pSamplerDesc: ^SAMPLER_DESC, ppSamplerState: ^^ISamplerState) -> sys_windows.HRESULT,
	CreateQuery:                          proc "stdcall" (this: ^IDevice, pQueryDesc: ^QUERY_DESC, ppQuery: ^^IQuery) -> sys_windows.HRESULT,
	CreatePredicate:                      proc "stdcall" (this: ^IDevice, pPredicateDesc: ^QUERY_DESC, ppPredicate: ^^IPredicate) -> sys_windows.HRESULT,
	CreateCounter:                        proc "stdcall" (this: ^IDevice, pCounterDesc: ^COUNTER_DESC, ppCounter: ^^ICounter) -> sys_windows.HRESULT,
	CreateDeferredContext:                proc "stdcall" (this: ^IDevice, ContextFlags: u32, ppDeferredContext: ^^IDeviceContext) -> sys_windows.HRESULT,
	OpenSharedResource:                   proc "stdcall" (this: ^IDevice, hResource: sys_windows.HANDLE, ReturnedInterface: ^sys_windows.GUID, ppResource: ^rawptr) -> sys_windows.HRESULT,
	CheckFormatSupport:                   proc "stdcall" (this: ^IDevice, Format: directx_dxgi.FORMAT, pFormatSupport: ^u32) -> sys_windows.HRESULT,
	CheckMultisampleQualityLevels:        proc "stdcall" (this: ^IDevice, Format: directx_dxgi.FORMAT, SampleCount: u32, pNumQualityLevels: [^]u32) -> sys_windows.HRESULT,
	CheckCounterInfo:                     proc "stdcall" (this: ^IDevice, pCounterInfo: ^COUNTER_INFO),
	CheckCounter:                         proc "stdcall" (this: ^IDevice, pDesc: ^COUNTER_DESC, pType: ^COUNTER_TYPE, pActiveCounters: ^u32, szName: cstring, pNameLength: ^u32, szUnits: cstring, pUnitsLength: ^u32, szDescription: cstring, pDescriptionLength: ^u32) -> sys_windows.HRESULT,
	CheckFeatureSupport:                  proc "stdcall" (this: ^IDevice, Feature: FEATURE, pFeatureSupportData: rawptr, FeatureSupportDataSize: u32) -> sys_windows.HRESULT,
	GetPrivateData:                       proc "stdcall" (this: ^IDevice, guid: ^sys_windows.GUID, pDataSize: ^u32, pData: rawptr) -> sys_windows.HRESULT,
	SetPrivateData:                       proc "stdcall" (this: ^IDevice, guid: ^sys_windows.GUID, DataSize: u32, pData: rawptr) -> sys_windows.HRESULT,
	SetPrivateDataInterface:              proc "stdcall" (this: ^IDevice, guid: ^sys_windows.GUID, pData: ^sys_windows.IUnknown) -> sys_windows.HRESULT,
	GetFeatureLevel:                      proc "stdcall" (this: ^IDevice) -> FEATURE_LEVEL,
	GetCreationFlags:                     proc "stdcall" (this: ^IDevice) -> u32,
	GetDeviceRemovedReason:               proc "stdcall" (this: ^IDevice) -> sys_windows.HRESULT,
	GetImmediateContext:                  proc "stdcall" (this: ^IDevice, ppImmediateContext: ^^IDeviceContext),
	SetExceptionMode:                     proc "stdcall" (this: ^IDevice, RaiseFlags: RAISE_FLAGS) -> sys_windows.HRESULT,
	GetExceptionMode:                     proc "stdcall" (this: ^IDevice) -> u32,
}

IDomainShader :: struct {
	using id3d11devicechild: IDeviceChild,
}

IFunctionLinkingGraph :: struct #raw_union {
	iunknown:                          sys_windows.IUnknown,
	using id3d11functionlinkinggraph_vtable: ^IFunctionLinkingGraph_VTable,
}

IFunctionLinkingGraph_VTable :: struct {
	using iunknown_vtable: sys_windows.IUnknown_VTable,
	CreateModuleInstance: proc "stdcall" (this: ^IFunctionLinkingGraph, ppModuleInstance: ^^directx_d3d_compiler.ID3D11ModuleInstance, ppErrorBuffer: ^^directx_d3d_compiler.ID3D10Blob) -> sys_windows.HRESULT,
	SetInputSignature:    proc "stdcall" (this: ^IFunctionLinkingGraph, pInputParameters: [^]PARAMETER_DESC, cInputParameters: u32, ppInputNode: ^^ILinkingNode) -> sys_windows.HRESULT,
	SetOutputSignature:   proc "stdcall" (this: ^IFunctionLinkingGraph, pOutputParameters: [^]PARAMETER_DESC, cOutputParameters: u32, ppOutputNode: ^^ILinkingNode) -> sys_windows.HRESULT,
	CallFunction:         proc "stdcall" (this: ^IFunctionLinkingGraph, pModuleInstanceNamespace: cstring, pModuleWithFunctionPrototype: ^directx_d3d_compiler.ID3D11Module, pFunctionName: cstring, ppCallNode: ^^ILinkingNode) -> sys_windows.HRESULT,
	PassValue:            proc "stdcall" (this: ^IFunctionLinkingGraph, pSrcNode: ^ILinkingNode, SrcParameterIndex: i32, pDstNode: ^ILinkingNode, DstParameterIndex: i32) -> sys_windows.HRESULT,
	PassValueWithSwizzle: proc "stdcall" (this: ^IFunctionLinkingGraph, pSrcNode: ^ILinkingNode, SrcParameterIndex: i32, pSrcSwizzle: ^u8, pDstNode: ^ILinkingNode, DstParameterIndex: i32, pDstSwizzle: ^u8) -> sys_windows.HRESULT,
	GetLastError:         proc "stdcall" (this: ^IFunctionLinkingGraph, ppErrorBuffer: ^^directx_d3d_compiler.ID3D10Blob) -> sys_windows.HRESULT,
	GenerateHlsl:         proc "stdcall" (this: ^IFunctionLinkingGraph, uFlags: u32, ppBuffer: ^^directx_d3d_compiler.ID3D10Blob) -> sys_windows.HRESULT,
}

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

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

IFunctionReflection :: struct {
	using 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,
}

IGeometryShader :: struct {
	using id3d11devicechild: IDeviceChild,
}

IHullShader :: struct {
	using id3d11devicechild: IDeviceChild,
}

IID :: sys_windows.GUID

IInfoQueue :: struct #raw_union {
	iunknown:               sys_windows.IUnknown,
	using id3d11infoqueue_vtable: ^IInfoQueue_VTable,
}

IInfoQueue_VTable :: struct {
	using iunkown_vtable:                         sys_windows.IUnknown_VTable,
	SetMessageCountLimit:                         proc "stdcall" (this: ^IInfoQueue, MessageCountLimit: u64) -> sys_windows.HRESULT,
	ClearStoredMessages:                          proc "stdcall" (this: ^IInfoQueue),
	GetMessage:                                   proc "stdcall" (this: ^IInfoQueue, MessageIndex: u64, pMessage: ^MESSAGE, pMessageByteLength: ^uint) -> sys_windows.HRESULT,
	GetNumMessagesAllowedByStorageFilter:         proc "stdcall" (this: ^IInfoQueue) -> u64,
	GetNumMessagesDeniedByStorageFilter:          proc "stdcall" (this: ^IInfoQueue) -> u64,
	GetNumStoredMessages:                         proc "stdcall" (this: ^IInfoQueue) -> u64,
	GetNumStoredMessagesAllowedByRetrievalFilter: proc "stdcall" (this: ^IInfoQueue) -> u64,
	GetNumMessagesDiscardedByMessageCountLimit:   proc "stdcall" (this: ^IInfoQueue) -> u64,
	GetMessageCountLimit:                         proc "stdcall" (this: ^IInfoQueue) -> u64,
	AddStorageFilterEntries:                      proc "stdcall" (this: ^IInfoQueue, pFilter: ^INFO_QUEUE_FILTER) -> sys_windows.HRESULT,
	GetStorageFilter:                             proc "stdcall" (this: ^IInfoQueue, pFilter: ^INFO_QUEUE_FILTER, pFilterByteLength: ^uint) -> sys_windows.HRESULT,
	ClearStorageFilter:                           proc "stdcall" (this: ^IInfoQueue),
	PushEmptyStorageFilter:                       proc "stdcall" (this: ^IInfoQueue) -> sys_windows.HRESULT,
	PushCopyOfStorageFilter:                      proc "stdcall" (this: ^IInfoQueue) -> sys_windows.HRESULT,
	PushStorageFilter:                            proc "stdcall" (this: ^IInfoQueue, pFilter: ^INFO_QUEUE_FILTER) -> sys_windows.HRESULT,
	PopStorageFilter:                             proc "stdcall" (this: ^IInfoQueue),
	GetStorageFilterStackSize:                    proc "stdcall" (this: ^IInfoQueue) -> u64,
	AddRetrievalFilterEntries:                    proc "stdcall" (this: ^IInfoQueue, pFilter: ^INFO_QUEUE_FILTER) -> sys_windows.HRESULT,
	GetRetrievalFilter:                           proc "stdcall" (this: ^IInfoQueue, pFilter: ^INFO_QUEUE_FILTER, pFilterByteLength: ^uint) -> sys_windows.HRESULT,
	ClearRetrievalFilter:                         proc "stdcall" (this: ^IInfoQueue),
	PushEmptyRetrievalFilter:                     proc "stdcall" (this: ^IInfoQueue) -> sys_windows.HRESULT,
	PushCopyOfRetrievalFilter:                    proc "stdcall" (this: ^IInfoQueue) -> sys_windows.HRESULT,
	PushRetrievalFilter:                          proc "stdcall" (this: ^IInfoQueue, pFilter: ^INFO_QUEUE_FILTER) -> sys_windows.HRESULT,
	PopRetrievalFilter:                           proc "stdcall" (this: ^IInfoQueue),
	GetRetrievalFilterStackSize:                  proc "stdcall" (this: ^IInfoQueue) -> u64,
	AddMessage:                                   proc "stdcall" (this: ^IInfoQueue, Category: MESSAGE_CATEGORY, Severity: MESSAGE_SEVERITY, ID: MESSAGE_ID, pDescription: cstring) -> sys_windows.HRESULT,
	AddApplicationMessage:                        proc "stdcall" (this: ^IInfoQueue, Severity: MESSAGE_SEVERITY, pDescription: cstring) -> sys_windows.HRESULT,
	SetBreakOnCategory:                           proc "stdcall" (this: ^IInfoQueue, Category: MESSAGE_CATEGORY, bEnable: sys_windows.BOOL) -> sys_windows.HRESULT,
	SetBreakOnSeverity:                           proc "stdcall" (this: ^IInfoQueue, Severity: MESSAGE_SEVERITY, bEnable: sys_windows.BOOL) -> sys_windows.HRESULT,
	SetBreakOnID:                                 proc "stdcall" (this: ^IInfoQueue, ID: MESSAGE_ID, bEnable: sys_windows.BOOL) -> sys_windows.HRESULT,
	GetBreakOnCategory:                           proc "stdcall" (this: ^IInfoQueue, Category: MESSAGE_CATEGORY) -> sys_windows.BOOL,
	GetBreakOnSeverity:                           proc "stdcall" (this: ^IInfoQueue, Severity: MESSAGE_SEVERITY) -> sys_windows.BOOL,
	GetBreakOnID:                                 proc "stdcall" (this: ^IInfoQueue, ID: MESSAGE_ID) -> sys_windows.BOOL,
	SetMuteDebugOutput:                           proc "stdcall" (this: ^IInfoQueue, bMute: sys_windows.BOOL),
	GetMuteDebugOutput:                           proc "stdcall" (this: ^IInfoQueue) -> sys_windows.BOOL,
}

IInputLayout :: struct {
	using id3d11devicechild: IDeviceChild,
}

ILibraryReflection :: struct #raw_union {
	iunknown:                       sys_windows.IUnknown,
	using id3d11libraryreflection_vtable: ^ILibraryReflection_VTable,
}

ILibraryReflection_VTable :: struct {
	using iunknown_vtable: sys_windows.IUnknown_VTable,
	GetDesc:            proc "stdcall" (this: ^ILibraryReflection, pDesc: ^LIBRARY_DESC) -> sys_windows.HRESULT,
	GetFunctionByIndex: proc "stdcall" (this: ^ILibraryReflection, FunctionIndex: i32) -> ^IFunctionReflection,
}

ILinkingNode :: struct {
	using iunknown: sys_windows.IUnknown,
}

IModule :: directx_d3d_compiler.ID3D11Module

IModuleInstance :: directx_d3d_compiler.ID3D11ModuleInstance

INFO_QUEUE_FILTER :: struct {
	AllowList: INFO_QUEUE_FILTER_DESC,
	DenyList:  INFO_QUEUE_FILTER_DESC,
}

INFO_QUEUE_FILTER_DESC :: struct {
	NumCategories: u32,
	pCategoryList: ^MESSAGE_CATEGORY,
	NumSeverities: u32,
	pSeverityList: ^MESSAGE_SEVERITY,
	NumIDs:        u32,
	pIDList:       ^MESSAGE_ID,
}

INPUT_CLASSIFICATION :: enum i32 {
	VERTEX_DATA   = 0, 
	INSTANCE_DATA = 1, 
}

INPUT_ELEMENT_DESC :: struct {
	SemanticName:         cstring,
	SemanticIndex:        u32,
	Format:               directx_dxgi.FORMAT,
	InputSlot:            u32,
	AlignedByteOffset:    u32,
	InputSlotClass:       INPUT_CLASSIFICATION,
	InstanceDataStepRate: u32,
}

INT :: i32

INTERPOLATION_MODE :: enum i32 {
	UNDEFINED                     = 0, 
	CONSTANT                      = 1, 
	LINEAR                        = 2, 
	LINEAR_CENTROID               = 3, 
	LINEAR_NOPERSPECTIVE          = 4, 
	LINEAR_NOPERSPECTIVE_CENTROID = 5, 
	LINEAR_SAMPLE                 = 6, 
	LINEAR_NOPERSPECTIVE_SAMPLE   = 7, 
}

IPixelShader :: struct {
	using id3d11devicechild: IDeviceChild,
}

IPredicate :: struct {
	using id3d11query: IQuery,
}

IQuery :: struct #raw_union {
	id3d11asynchronous: IAsynchronous,
	using id3d11query_vtable: ^IQuery_VTable,
}

IQuery_VTable :: struct {
	using id3d11asynchronous_vtable: IAsynchronous_VTable,
	GetDesc:                   proc "stdcall" (this: ^IQuery, pDesc: ^QUERY_DESC),
}

IRasterizerState :: struct #raw_union {
	id3d11devicechild:            IDeviceChild,
	using id3d11rasterizerstate_vtable: ^IRasterizerState_VTable,
}

IRasterizerState_VTable :: struct {
	using id3d11devicechild_vtable: IDeviceChild_VTable,
	GetDesc:                  proc "stdcall" (this: ^IRasterizerState, pDesc: ^RASTERIZER_DESC),
}

IRenderTargetView :: struct #raw_union {
	id3d11view:                    IView,
	using id3d11rendertargetview_vtable: ^IRenderTargetView_VTable,
}

IRenderTargetView_VTable :: struct {
	using id3d11view_vtable: IView_VTable,
	GetDesc:           proc "stdcall" (this: ^IRenderTargetView, pDesc: ^RENDER_TARGET_VIEW_DESC),
}

IResource :: struct #raw_union {
	id3d11devicechild:     IDeviceChild,
	using id3d11resource_vtable: ^IResource_VTable,
}

IResource_VTable :: struct {
	using id3d11devicechild_vtable: IDeviceChild_VTable,
	GetType:                  proc "stdcall" (this: ^IResource, pResourceDimension: ^RESOURCE_DIMENSION),
	SetEvictionPriority:      proc "stdcall" (this: ^IResource, EvictionPriority: u32),
	GetEvictionPriority:      proc "stdcall" (this: ^IResource) -> u32,
}

ISamplerState :: struct #raw_union {
	id3d11devicechild:         IDeviceChild,
	using id3d11samplerstate_vtable: ^ISamplerState_VTable,
}

ISamplerState_VTable :: struct {
	using id3d11devicechild_vtable: IDeviceChild_VTable,
	GetDesc:                  proc "stdcall" (this: ^ISamplerState, pDesc: ^SAMPLER_DESC),
}

IShaderReflection :: struct #raw_union {
	iunknown:                      sys_windows.IUnknown,
	using id3d11shaderreflection_vtable: ^IShaderReflection_VTable,
}

IShaderReflectionConstantBuffer :: struct {
	using vtable: ^IShaderReflectionConstantBuffer_VTable,
}

IShaderReflectionConstantBuffer_VTable :: struct {
	GetDesc:            proc "stdcall" (this: ^IShaderReflectionConstantBuffer, pDesc: ^SHADER_BUFFER_DESC) -> sys_windows.HRESULT,
	GetVariableByIndex: proc "stdcall" (this: ^IShaderReflectionConstantBuffer, Index: u32) -> ^IShaderReflectionVariable,
	GetVariableByName:  proc "stdcall" (this: ^IShaderReflectionConstantBuffer, Name: cstring) -> ^IShaderReflectionVariable,
}

IShaderReflectionType :: struct {
	using vtable: ^IShaderReflectionType_VTable,
}

IShaderReflectionType_VTable :: struct {
	GetDesc:              proc "stdcall" (this: ^IShaderReflectionType, pDesc: ^SHADER_TYPE_DESC) -> sys_windows.HRESULT,
	GetMemberTypeByIndex: proc "stdcall" (this: ^IShaderReflectionType, Index: u32) -> ^IShaderReflectionType,
	GetMemberTypeByName:  proc "stdcall" (this: ^IShaderReflectionType, Name: cstring) -> ^IShaderReflectionType,
	GetMemberTypeName:    proc "stdcall" (this: ^IShaderReflectionType, Index: u32) -> cstring,
	IsEqual:              proc "stdcall" (this: ^IShaderReflectionType, pType: ^IShaderReflectionType) -> sys_windows.HRESULT,
	GetSubType:           proc "stdcall" (this: ^IShaderReflectionType) -> ^IShaderReflectionType,
	GetBaseClass:         proc "stdcall" (this: ^IShaderReflectionType) -> ^IShaderReflectionType,
	GetNumInterfaces:     proc "stdcall" (this: ^IShaderReflectionType) -> u32,
	GetInterfaceByIndex:  proc "stdcall" (this: ^IShaderReflectionType, uIndex: u32) -> ^IShaderReflectionType,
	IsOfType:             proc "stdcall" (this: ^IShaderReflectionType, pType: ^IShaderReflectionType) -> sys_windows.HRESULT,
	ImplementsInterface:  proc "stdcall" (this: ^IShaderReflectionType, pBase: ^IShaderReflectionType) -> sys_windows.HRESULT,
}

IShaderReflectionVariable :: struct {
	using vtable: ^IShaderReflectionVariable_VTable,
}

IShaderReflectionVariable_VTable :: struct {
	GetDesc:          proc "stdcall" (this: ^IShaderReflectionVariable, pDesc: ^SHADER_VARIABLE_DESC) -> sys_windows.HRESULT,
	GetType:          proc "stdcall" (this: ^IShaderReflectionVariable) -> ^IShaderReflectionType,
	GetBuffer:        proc "stdcall" (this: ^IShaderReflectionVariable) -> ^IShaderReflectionConstantBuffer,
	GetInterfaceSlot: proc "stdcall" (this: ^IShaderReflectionVariable, uArrayIndex: u32) -> u32,
}

IShaderReflection_VTable :: struct {
	using iunknown_vtable:         sys_windows.IUnknown_VTable,
	GetDesc:                       proc "stdcall" (this: ^IShaderReflection, pDesc: ^SHADER_DESC) -> sys_windows.HRESULT,
	GetConstantBufferByIndex:      proc "stdcall" (this: ^IShaderReflection, Index: u32) -> ^IShaderReflectionConstantBuffer,
	GetConstantBufferByName:       proc "stdcall" (this: ^IShaderReflection, Name: cstring) -> ^IShaderReflectionConstantBuffer,
	GetResourceBindingDesc:        proc "stdcall" (this: ^IShaderReflection, ResourceIndex: u32, pDesc: ^SHADER_INPUT_BIND_DESC) -> sys_windows.HRESULT,
	GetInputParameterDesc:         proc "stdcall" (this: ^IShaderReflection, ParameterIndex: u32, pDesc: ^SIGNATURE_PARAMETER_DESC) -> sys_windows.HRESULT,
	GetOutputParameterDesc:        proc "stdcall" (this: ^IShaderReflection, ParameterIndex: u32, pDesc: ^SIGNATURE_PARAMETER_DESC) -> sys_windows.HRESULT,
	GetPatchConstantParameterDesc: proc "stdcall" (this: ^IShaderReflection, ParameterIndex: u32, pDesc: ^SIGNATURE_PARAMETER_DESC) -> sys_windows.HRESULT,
	GetVariableByName:             proc "stdcall" (this: ^IShaderReflection, Name: cstring) -> ^IShaderReflectionVariable,
	GetResourceBindingDescByName:  proc "stdcall" (this: ^IShaderReflection, Name: cstring, pDesc: ^SHADER_INPUT_BIND_DESC) -> sys_windows.HRESULT,
	GetMovInstructionCount:        proc "stdcall" (this: ^IShaderReflection) -> u32,
	GetMovcInstructionCount:       proc "stdcall" (this: ^IShaderReflection) -> u32,
	GetConversionInstructionCount: proc "stdcall" (this: ^IShaderReflection) -> u32,
	GetBitwiseInstructionCount:    proc "stdcall" (this: ^IShaderReflection) -> u32,
	GetGSInputPrimitive:           proc "stdcall" (this: ^IShaderReflection) -> PRIMITIVE,
	IsSampleFrequencyShader:       proc "stdcall" (this: ^IShaderReflection) -> sys_windows.BOOL,
	GetNumInterfaceSlots:          proc "stdcall" (this: ^IShaderReflection) -> u32,
	GetMinFeatureLevel:            proc "stdcall" (this: ^IShaderReflection, pLevel: ^FEATURE_LEVEL) -> sys_windows.HRESULT,
	GetThreadGroupSize:            proc "stdcall" (this: ^IShaderReflection, pSizeX: ^u32, pSizeY: ^u32, pSizeZ: ^u32) -> u32,
	GetRequiresFlags:              proc "stdcall" (this: ^IShaderReflection) -> SHADER_REQUIRES_FLAGS,
}

IShaderResourceView :: struct #raw_union {
	id3d11view:                      IView,
	using id3d11shaderresourceview_vtable: ^IShaderResourceView_VTable,
}

IShaderResourceView_VTable :: struct {
	using id3d11view_vtable: IView_VTable,
	GetDesc:           proc "stdcall" (this: ^IShaderResourceView, pDesc: ^SHADER_RESOURCE_VIEW_DESC),
}

ITexture1D :: struct #raw_union {
	id3d11resource:         IResource,
	using id3d11texture1d_vtable: ^ITexture1D_VTable,
}

ITexture1D_VTable :: struct {
	using id3d11resource_vtable: IResource_VTable,
	GetDesc:               proc "stdcall" (this: ^ITexture1D, pDesc: ^TEXTURE1D_DESC),
}

ITexture2D :: struct #raw_union {
	id3d11resource:         IResource,
	using id3d11texture2d_vtable: ^ITexture2D_VTable,
}

ITexture2D_VTable :: struct {
	using id3d11resource_vtable: IResource_VTable,
	GetDesc:               proc "stdcall" (this: ^ITexture2D, pDesc: ^TEXTURE2D_DESC),
}

ITexture3D :: struct #raw_union {
	id3d11resource:         IResource,
	using id3d11texture3d_vtable: ^ITexture3D_VTable,
}

ITexture3D_VTable :: struct {
	using id3d11resource_vtable: IResource_VTable,
	GetDesc:               proc "stdcall" (this: ^ITexture3D, pDesc: ^TEXTURE3D_DESC),
}

IUnknown :: sys_windows.IUnknown

IUnknown_VTable :: sys_windows.IUnknown_VTable

IUnorderedAccessView :: struct #raw_union {
	id3d11view:                       IView,
	using id3d11unorderedaccessview_vtable: ^IUnorderedAccessView_VTable,
}

IUnorderedAccessView_VTable :: struct {
	using id3d11view_vtable: IView_VTable,
	GetDesc:           proc "stdcall" (this: ^IUnorderedAccessView, pDesc: ^UNORDERED_ACCESS_VIEW_DESC),
}

IVertexShader :: struct {
	using id3d11devicechild: IDeviceChild,
}

IVideoContext :: struct #raw_union {
	id3d11devicechild:         IDeviceChild,
	using id3d11videocontext_vtable: ^IVideoContext_VTable,
}

IVideoContext_VTable :: struct {
	using id3d11devicechild_vtable:            IDeviceChild_VTable,
	GetDecoderBuffer:                          proc "stdcall" (this: ^IVideoContext, pDecoder: ^IVideoDecoder, Type: VIDEO_DECODER_BUFFER_TYPE, pBufferSize: ^u32, ppBuffer: ^rawptr) -> sys_windows.HRESULT,
	ReleaseDecoderBuffer:                      proc "stdcall" (this: ^IVideoContext, pDecoder: ^IVideoDecoder, Type: VIDEO_DECODER_BUFFER_TYPE) -> sys_windows.HRESULT,
	DecoderBeginFrame:                         proc "stdcall" (this: ^IVideoContext, pDecoder: ^IVideoDecoder, pView: ^IVideoDecoderOutputView, ContentKeySize: u32, pContentKey: rawptr) -> sys_windows.HRESULT,
	DecoderEndFrame:                           proc "stdcall" (this: ^IVideoContext, pDecoder: ^IVideoDecoder) -> sys_windows.HRESULT,
	SubmitDecoderBuffers:                      proc "stdcall" (this: ^IVideoContext, pDecoder: ^IVideoDecoder, NumBuffers: u32, pBufferDesc: ^VIDEO_DECODER_BUFFER_DESC) -> sys_windows.HRESULT,
	DecoderExtension:                          proc "stdcall" (this: ^IVideoContext, pDecoder: ^IVideoDecoder, pExtensionData: ^VIDEO_DECODER_EXTENSION) -> sys_windows.HRESULT,
	VideoProcessorSetOutputTargetRect:         proc "stdcall" (this: ^IVideoContext, pVideoProcessor: ^IVideoProcessor, Enable: sys_windows.BOOL, pRect: ^sys_windows.RECT),
	VideoProcessorSetOutputBackgroundColor:    proc "stdcall" (this: ^IVideoContext, pVideoProcessor: ^IVideoProcessor, YCbCr: sys_windows.BOOL, pColor: ^VIDEO_COLOR),
	VideoProcessorSetOutputColorSpace:         proc "stdcall" (this: ^IVideoContext, pVideoProcessor: ^IVideoProcessor, pColorSpace: ^VIDEO_PROCESSOR_COLOR_SPACE),
	VideoProcessorSetOutputAlphaFillMode:      proc "stdcall" (this: ^IVideoContext, pVideoProcessor: ^IVideoProcessor, AlphaFillMode: VIDEO_PROCESSOR_ALPHA_FILL_MODE, StreamIndex: u32),
	VideoProcessorSetOutputConstriction:       proc "stdcall" (this: ^IVideoContext, pVideoProcessor: ^IVideoProcessor, Enable: sys_windows.BOOL, Size: sys_windows.SIZE),
	VideoProcessorSetOutputStereoMode:         proc "stdcall" (this: ^IVideoContext, pVideoProcessor: ^IVideoProcessor, Enable: sys_windows.BOOL),
	VideoProcessorSetOutputExtension:          proc "stdcall" (this: ^IVideoContext, pVideoProcessor: ^IVideoProcessor, pExtensionGuid: ^sys_windows.GUID, DataSize: u32, pData: rawptr) -> sys_windows.HRESULT,
	VideoProcessorGetOutputTargetRect:         proc "stdcall" (this: ^IVideoContext, pVideoProcessor: ^IVideoProcessor, Enabled: ^sys_windows.BOOL, pRect: ^sys_windows.RECT),
	VideoProcessorGetOutputBackgroundColor:    proc "stdcall" (this: ^IVideoContext, pVideoProcessor: ^IVideoProcessor, pYCbCr: ^sys_windows.BOOL, pColor: ^VIDEO_COLOR),
	VideoProcessorGetOutputColorSpace:         proc "stdcall" (this: ^IVideoContext, pVideoProcessor: ^IVideoProcessor, pColorSpace: ^VIDEO_PROCESSOR_COLOR_SPACE),
	VideoProcessorGetOutputAlphaFillMode:      proc "stdcall" (this: ^IVideoContext, pVideoProcessor: ^IVideoProcessor, pAlphaFillMode: ^VIDEO_PROCESSOR_ALPHA_FILL_MODE, pStreamIndex: ^u32),
	VideoProcessorGetOutputConstriction:       proc "stdcall" (this: ^IVideoContext, pVideoProcessor: ^IVideoProcessor, pEnabled: ^sys_windows.BOOL, pSize: ^sys_windows.SIZE),
	VideoProcessorGetOutputStereoMode:         proc "stdcall" (this: ^IVideoContext, pVideoProcessor: ^IVideoProcessor, pEnabled: ^sys_windows.BOOL),
	VideoProcessorGetOutputExtension:          proc "stdcall" (this: ^IVideoContext, pVideoProcessor: ^IVideoProcessor, pExtensionGuid: ^sys_windows.GUID, DataSize: u32, pData: rawptr) -> sys_windows.HRESULT,
	VideoProcessorSetStreamFrameFormat:        proc "stdcall" (this: ^IVideoContext, pVideoProcessor: ^IVideoProcessor, StreamIndex: u32, FrameFormat: VIDEO_FRAME_FORMAT),
	VideoProcessorSetStreamColorSpace:         proc "stdcall" (this: ^IVideoContext, pVideoProcessor: ^IVideoProcessor, StreamIndex: u32, pColorSpace: ^VIDEO_PROCESSOR_COLOR_SPACE),
	VideoProcessorSetStreamOutputRate:         proc "stdcall" (this: ^IVideoContext, pVideoProcessor: ^IVideoProcessor, StreamIndex: u32, OutputRate: VIDEO_PROCESSOR_OUTPUT_RATE, RepeatFrame: sys_windows.BOOL, pCustomRate: ^directx_dxgi.RATIONAL),
	VideoProcessorSetStreamSourceRect:         proc "stdcall" (this: ^IVideoContext, pVideoProcessor: ^IVideoProcessor, StreamIndex: u32, Enable: sys_windows.BOOL, pRect: ^sys_windows.RECT),
	VideoProcessorSetStreamDestRect:           proc "stdcall" (this: ^IVideoContext, pVideoProcessor: ^IVideoProcessor, StreamIndex: u32, Enable: sys_windows.BOOL, pRect: ^sys_windows.RECT),
	VideoProcessorSetStreamAlpha:              proc "stdcall" (this: ^IVideoContext, pVideoProcessor: ^IVideoProcessor, StreamIndex: u32, Enable: sys_windows.BOOL, Alpha: f32),
	VideoProcessorSetStreamPalette:            proc "stdcall" (this: ^IVideoContext, pVideoProcessor: ^IVideoProcessor, StreamIndex: u32, Count: u32, pEntries: [^]u32),
	VideoProcessorSetStreamPixelAspectRatio:   proc "stdcall" (this: ^IVideoContext, pVideoProcessor: ^IVideoProcessor, StreamIndex: u32, Enable: sys_windows.BOOL, pSourceAspectRatio: ^directx_dxgi.RATIONAL, pDestinationAspectRatio: ^directx_dxgi.RATIONAL),
	VideoProcessorSetStreamLumaKey:            proc "stdcall" (this: ^IVideoContext, pVideoProcessor: ^IVideoProcessor, StreamIndex: u32, Enable: sys_windows.BOOL, Lower: f32, Upper: f32),
	VideoProcessorSetStreamStereoFormat:       proc "stdcall" (this: ^IVideoContext, pVideoProcessor: ^IVideoProcessor, StreamIndex: u32, Enable: sys_windows.BOOL, Format: VIDEO_PROCESSOR_STEREO_FORMAT, LeftViewFrame0: sys_windows.BOOL, BaseViewFrame0: sys_windows.BOOL, FlipMode: VIDEO_PROCESSOR_STEREO_FLIP_MODE, MonoOffset: i32),
	VideoProcessorSetStreamAutoProcessingMode: proc "stdcall" (this: ^IVideoContext, pVideoProcessor: ^IVideoProcessor, StreamIndex: u32, Enable: sys_windows.BOOL),
	VideoProcessorSetStreamFilter:             proc "stdcall" (this: ^IVideoContext, pVideoProcessor: ^IVideoProcessor, StreamIndex: u32, Filter: VIDEO_PROCESSOR_FILTER, Enable: sys_windows.BOOL, Level: i32),
	VideoProcessorSetStreamExtension:          proc "stdcall" (this: ^IVideoContext, pVideoProcessor: ^IVideoProcessor, StreamIndex: u32, pExtensionGuid: ^sys_windows.GUID, DataSize: u32, pData: rawptr) -> sys_windows.HRESULT,
	VideoProcessorGetStreamFrameFormat:        proc "stdcall" (this: ^IVideoContext, pVideoProcessor: ^IVideoProcessor, StreamIndex: u32, pFrameFormat: ^VIDEO_FRAME_FORMAT),
	VideoProcessorGetStreamColorSpace:         proc "stdcall" (this: ^IVideoContext, pVideoProcessor: ^IVideoProcessor, StreamIndex: u32, pColorSpace: ^VIDEO_PROCESSOR_COLOR_SPACE),
	VideoProcessorGetStreamOutputRate:         proc "stdcall" (this: ^IVideoContext, pVideoProcessor: ^IVideoProcessor, StreamIndex: u32, pOutputRate: ^VIDEO_PROCESSOR_OUTPUT_RATE, pRepeatFrame: ^sys_windows.BOOL, pCustomRate: ^directx_dxgi.RATIONAL),
	VideoProcessorGetStreamSourceRect:         proc "stdcall" (this: ^IVideoContext, pVideoProcessor: ^IVideoProcessor, StreamIndex: u32, pEnabled: ^sys_windows.BOOL, pRect: ^sys_windows.RECT),
	VideoProcessorGetStreamDestRect:           proc "stdcall" (this: ^IVideoContext, pVideoProcessor: ^IVideoProcessor, StreamIndex: u32, pEnabled: ^sys_windows.BOOL, pRect: ^sys_windows.RECT),
	VideoProcessorGetStreamAlpha:              proc "stdcall" (this: ^IVideoContext, pVideoProcessor: ^IVideoProcessor, StreamIndex: u32, pEnabled: ^sys_windows.BOOL, pAlpha: ^f32),
	VideoProcessorGetStreamPalette:            proc "stdcall" (this: ^IVideoContext, pVideoProcessor: ^IVideoProcessor, StreamIndex: u32, Count: u32, pEntries: [^]u32),
	VideoProcessorGetStreamPixelAspectRatio:   proc "stdcall" (this: ^IVideoContext, pVideoProcessor: ^IVideoProcessor, StreamIndex: u32, pEnabled: ^sys_windows.BOOL, pSourceAspectRatio: ^directx_dxgi.RATIONAL, pDestinationAspectRatio: ^directx_dxgi.RATIONAL),
	VideoProcessorGetStreamLumaKey:            proc "stdcall" (this: ^IVideoContext, pVideoProcessor: ^IVideoProcessor, StreamIndex: u32, pEnabled: ^sys_windows.BOOL, pLower: ^f32, pUpper: ^f32),
	VideoProcessorGetStreamStereoFormat:       proc "stdcall" (this: ^IVideoContext, pVideoProcessor: ^IVideoProcessor, StreamIndex: u32, pEnable: ^sys_windows.BOOL, pFormat: ^VIDEO_PROCESSOR_STEREO_FORMAT, pLeftViewFrame0: ^sys_windows.BOOL, pBaseViewFrame0: ^sys_windows.BOOL, pFlipMode: ^VIDEO_PROCESSOR_STEREO_FLIP_MODE, MonoOffset: ^i32),
	VideoProcessorGetStreamAutoProcessingMode: proc "stdcall" (this: ^IVideoContext, pVideoProcessor: ^IVideoProcessor, StreamIndex: u32, pEnabled: ^sys_windows.BOOL),
	VideoProcessorGetStreamFilter:             proc "stdcall" (this: ^IVideoContext, pVideoProcessor: ^IVideoProcessor, StreamIndex: u32, Filter: VIDEO_PROCESSOR_FILTER, pEnabled: ^sys_windows.BOOL, pLevel: ^i32),
	VideoProcessorGetStreamExtension:          proc "stdcall" (this: ^IVideoContext, pVideoProcessor: ^IVideoProcessor, StreamIndex: u32, pExtensionGuid: ^sys_windows.GUID, DataSize: u32, pData: rawptr) -> sys_windows.HRESULT,
	VideoProcessorBlt:                         proc "stdcall" (this: ^IVideoContext, pVideoProcessor: ^IVideoProcessor, pView: ^IVideoProcessorOutputView, OutputFrame: u32, StreamCount: u32, pStreams: [^]VIDEO_PROCESSOR_STREAM) -> sys_windows.HRESULT,
	NegotiateCryptoSessionKeyExchange:         proc "stdcall" (this: ^IVideoContext, pCryptoSession: ^ICryptoSession, DataSize: u32, pData: rawptr) -> sys_windows.HRESULT,
	EncryptionBlt:                             proc "stdcall" (this: ^IVideoContext, pCryptoSession: ^ICryptoSession, pSrcSurface: ^ITexture2D, pDstSurface: ^ITexture2D, IVSize: u32, pIV: rawptr),
	DecryptionBlt:                             proc "stdcall" (this: ^IVideoContext, pCryptoSession: ^ICryptoSession, pSrcSurface: ^ITexture2D, pDstSurface: ^ITexture2D, pEncryptedBlockInfo: ^ENCRYPTED_BLOCK_INFO, ContentKeySize: u32, pContentKey: rawptr, IVSize: u32, pIV: rawptr),
	StartSessionKeyRefresh:                    proc "stdcall" (this: ^IVideoContext, pCryptoSession: ^ICryptoSession, RandomNumberSize: u32, pRandomNumber: rawptr),
	FinishSessionKeyRefresh:                   proc "stdcall" (this: ^IVideoContext, pCryptoSession: ^ICryptoSession),
	GetEncryptionBltKey:                       proc "stdcall" (this: ^IVideoContext, pCryptoSession: ^ICryptoSession, KeySize: u32, pReadbackKey: rawptr) -> sys_windows.HRESULT,
	NegotiateAuthenticatedChannelKeyExchange:  proc "stdcall" (this: ^IVideoContext, pChannel: ^IAuthenticatedChannel, DataSize: u32, pData: rawptr) -> sys_windows.HRESULT,
	QueryAuthenticatedChannel:                 proc "stdcall" (this: ^IVideoContext, pChannel: ^IAuthenticatedChannel, InputSize: u32, pInput: rawptr, OutputSize: u32, pOutput: rawptr) -> sys_windows.HRESULT,
	ConfigureAuthenticatedChannel:             proc "stdcall" (this: ^IVideoContext, pChannel: ^IAuthenticatedChannel, InputSize: u32, pInput: rawptr, pOutput: ^AUTHENTICATED_CONFIGURE_OUTPUT) -> sys_windows.HRESULT,
	VideoProcessorSetStreamRotation:           proc "stdcall" (this: ^IVideoContext, pVideoProcessor: ^IVideoProcessor, StreamIndex: u32, Enable: sys_windows.BOOL, Rotation: VIDEO_PROCESSOR_ROTATION),
	VideoProcessorGetStreamRotation:           proc "stdcall" (this: ^IVideoContext, pVideoProcessor: ^IVideoProcessor, StreamIndex: u32, pEnable: ^sys_windows.BOOL, pRotation: ^VIDEO_PROCESSOR_ROTATION),
}

IVideoDecoder :: struct #raw_union {
	id3d11devicechild:         IDeviceChild,
	using id3d11videodecoder_vtable: ^IVideoDecoder_VTable,
}

IVideoDecoderOutputView :: struct #raw_union {
	id3d11view:                          IView,
	using id3d11videodecoderoutputview_vtable: ^IVideoDecoderOutputView_VTable,
}

IVideoDecoderOutputView_VTable :: struct {
	using id3d11view_vtable: IView_VTable,
	GetDesc:           proc "stdcall" (this: ^IVideoDecoderOutputView, pDesc: ^VIDEO_DECODER_OUTPUT_VIEW_DESC),
}

IVideoDecoder_VTable :: struct {
	using id3d11devicechild_vtable: IDeviceChild_VTable,
	GetCreationParameters:    proc "stdcall" (this: ^IVideoDecoder, pVideoDesc: ^VIDEO_DECODER_DESC, pConfig: ^VIDEO_DECODER_CONFIG) -> sys_windows.HRESULT,
	GetDriverHandle:          proc "stdcall" (this: ^IVideoDecoder, pDriverHandle: ^sys_windows.HANDLE) -> sys_windows.HRESULT,
}

IVideoDevice :: struct #raw_union {
	iunknown:                 sys_windows.IUnknown,
	using id3d11videodevice_vtable: ^IVideoDevice_VTable,
}

IVideoDevice_VTable :: struct {
	using iunknown_vtable:          sys_windows.IUnknown_VTable,
	CreateVideoDecoder:             proc "stdcall" (this: ^IVideoDevice, pVideoDesc: ^VIDEO_DECODER_DESC, pConfig: ^VIDEO_DECODER_CONFIG, ppDecoder: ^^IVideoDecoder) -> sys_windows.HRESULT,
	CreateVideoProcessor:           proc "stdcall" (this: ^IVideoDevice, pEnum: ^IVideoProcessorEnumerator, RateConversionIndex: u32, ppVideoProcessor: ^^IVideoProcessor) -> sys_windows.HRESULT,
	CreateAuthenticatedChannel:     proc "stdcall" (this: ^IVideoDevice, ChannelType: AUTHENTICATED_CHANNEL_TYPE, ppAuthenticatedChannel: ^^IAuthenticatedChannel) -> sys_windows.HRESULT,
	CreateCryptoSession:            proc "stdcall" (this: ^IVideoDevice, pCryptoType: ^sys_windows.GUID, pDecoderProfile: ^sys_windows.GUID, pKeyExchangeType: ^sys_windows.GUID, ppCryptoSession: ^^ICryptoSession) -> sys_windows.HRESULT,
	CreateVideoDecoderOutputView:   proc "stdcall" (this: ^IVideoDevice, pResource: ^IResource, pDesc: ^VIDEO_DECODER_OUTPUT_VIEW_DESC, ppVDOVView: ^^IVideoDecoderOutputView) -> sys_windows.HRESULT,
	CreateVideoProcessorInputView:  proc "stdcall" (this: ^IVideoDevice, pResource: ^IResource, pEnum: ^IVideoProcessorEnumerator, pDesc: ^VIDEO_PROCESSOR_INPUT_VIEW_DESC, ppVPIView: ^^IVideoProcessorInputView) -> sys_windows.HRESULT,
	CreateVideoProcessorOutputView: proc "stdcall" (this: ^IVideoDevice, pResource: ^IResource, pEnum: ^IVideoProcessorEnumerator, pDesc: ^VIDEO_PROCESSOR_OUTPUT_VIEW_DESC, ppVPOView: ^^IVideoProcessorOutputView) -> sys_windows.HRESULT,
	CreateVideoProcessorEnumerator: proc "stdcall" (this: ^IVideoDevice, pDesc: ^VIDEO_PROCESSOR_CONTENT_DESC, ppEnum: ^^IVideoProcessorEnumerator) -> sys_windows.HRESULT,
	GetVideoDecoderProfileCount:    proc "stdcall" (this: ^IVideoDevice) -> u32,
	GetVideoDecoderProfile:         proc "stdcall" (this: ^IVideoDevice, Index: u32, pDecoderProfile: ^sys_windows.GUID) -> sys_windows.HRESULT,
	CheckVideoDecoderFormat:        proc "stdcall" (this: ^IVideoDevice, pDecoderProfile: ^sys_windows.GUID, Format: directx_dxgi.FORMAT, pSupported: ^sys_windows.BOOL) -> sys_windows.HRESULT,
	GetVideoDecoderConfigCount:     proc "stdcall" (this: ^IVideoDevice, pDesc: ^VIDEO_DECODER_DESC, pCount: ^u32) -> sys_windows.HRESULT,
	GetVideoDecoderConfig:          proc "stdcall" (this: ^IVideoDevice, pDesc: ^VIDEO_DECODER_DESC, Index: u32, pConfig: ^VIDEO_DECODER_CONFIG) -> sys_windows.HRESULT,
	GetContentProtectionCaps:       proc "stdcall" (this: ^IVideoDevice, pCryptoType: ^sys_windows.GUID, pDecoderProfile: ^sys_windows.GUID, pCaps: ^VIDEO_CONTENT_PROTECTION_CAPS) -> sys_windows.HRESULT,
	CheckCryptoKeyExchange:         proc "stdcall" (this: ^IVideoDevice, pCryptoType: ^sys_windows.GUID, pDecoderProfile: ^sys_windows.GUID, Index: u32, pKeyExchangeType: ^sys_windows.GUID) -> sys_windows.HRESULT,
	SetPrivateData:                 proc "stdcall" (this: ^IVideoDevice, guid: ^sys_windows.GUID, DataSize: u32, pData: rawptr) -> sys_windows.HRESULT,
	SetPrivateDataInterface:        proc "stdcall" (this: ^IVideoDevice, guid: ^sys_windows.GUID, pData: ^sys_windows.IUnknown) -> sys_windows.HRESULT,
}

IVideoProcessor :: struct #raw_union {
	id3d11devicechild:           IDeviceChild,
	using id3d11videoprocessor_vtable: ^IVideoProcessor_VTable,
}