package vendor:vulkan

⌘K
Ctrl+K
or
/

    Overview

    Vulkan wrapper generated from "https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/master/include/vulkan/vulkan_core.h"

    Vulkan wrapper generated from "https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/master/include/vulkan/vulkan_core.h"

    Vulkan wrapper generated from "https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/master/include/vulkan/vulkan_core.h"

    Vulkan wrapper generated from "https://raw.githubusercontent.com/KhronosGroup/Vulkan-Headers/master/include/vulkan/vulkan_core.h"

    Index

    Types (2267)
    Constants (941)
    Variables (611)
    Procedure Groups (1)

    Types

    AabbPositionsKHR ¶

    AabbPositionsKHR :: struct {
    	minX: f32,
    	minY: f32,
    	minZ: f32,
    	maxX: f32,
    	maxY: f32,
    	maxZ: f32,
    }

    AccelerationStructureBuildGeometryInfoKHR ¶

    AccelerationStructureBuildGeometryInfoKHR :: struct {
    	sType:                    StructureType,
    	pNext:                    rawptr,
    	type:                     AccelerationStructureTypeKHR,
    	flags:                    BuildAccelerationStructureFlagsKHR,
    	mode:                     BuildAccelerationStructureModeKHR,
    	srcAccelerationStructure: AccelerationStructureKHR,
    	dstAccelerationStructure: AccelerationStructureKHR,
    	geometryCount:            u32,
    	pGeometries:              [^]AccelerationStructureGeometryKHR,
    	ppGeometries:             ^[^]AccelerationStructureGeometryKHR,
    	scratchData:              DeviceOrHostAddressKHR,
    }

    AccelerationStructureBuildRangeInfoKHR ¶

    AccelerationStructureBuildRangeInfoKHR :: struct {
    	primitiveCount:  u32,
    	primitiveOffset: u32,
    	firstVertex:     u32,
    	transformOffset: u32,
    }

    AccelerationStructureBuildSizesInfoKHR ¶

    AccelerationStructureBuildSizesInfoKHR :: struct {
    	sType:                     StructureType,
    	pNext:                     rawptr,
    	accelerationStructureSize: DeviceSize,
    	updateScratchSize:         DeviceSize,
    	buildScratchSize:          DeviceSize,
    }

    AccelerationStructureBuildTypeKHR ¶

    AccelerationStructureBuildTypeKHR :: enum i32 {
    	HOST           = 0, 
    	DEVICE         = 1, 
    	HOST_OR_DEVICE = 2, 
    }
     

    Enums

    AccelerationStructureCaptureDescriptorDataInfoEXT ¶

    AccelerationStructureCaptureDescriptorDataInfoEXT :: struct {
    	sType:                   StructureType,
    	pNext:                   rawptr,
    	accelerationStructure:   AccelerationStructureKHR,
    	accelerationStructureNV: AccelerationStructureNV,
    }

    AccelerationStructureCompatibilityKHR ¶

    AccelerationStructureCompatibilityKHR :: enum i32 {
    	COMPATIBLE   = 0, 
    	INCOMPATIBLE = 1, 
    }

    AccelerationStructureCreateFlagKHR ¶

    AccelerationStructureCreateFlagKHR :: enum Flags {
    	DEVICE_ADDRESS_CAPTURE_REPLAY        = 0, 
    	DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT = 3, 
    	MOTION_NV                            = 2, 
    }

    AccelerationStructureCreateFlagsKHR ¶

    AccelerationStructureCreateFlagsKHR :: distinct bit_set[AccelerationStructureCreateFlagKHR; Flags]

    AccelerationStructureCreateInfoKHR ¶

    AccelerationStructureCreateInfoKHR :: struct {
    	sType:         StructureType,
    	pNext:         rawptr,
    	createFlags:   AccelerationStructureCreateFlagsKHR,
    	buffer:        Buffer,
    	offset:        DeviceSize,
    	size:          DeviceSize,
    	type:          AccelerationStructureTypeKHR,
    	deviceAddress: DeviceAddress,
    }

    AccelerationStructureCreateInfoNV ¶

    AccelerationStructureCreateInfoNV :: struct {
    	sType:         StructureType,
    	pNext:         rawptr,
    	compactedSize: DeviceSize,
    	info:          AccelerationStructureInfoNV,
    }

    AccelerationStructureDeviceAddressInfoKHR ¶

    AccelerationStructureDeviceAddressInfoKHR :: struct {
    	sType:                 StructureType,
    	pNext:                 rawptr,
    	accelerationStructure: AccelerationStructureKHR,
    }

    AccelerationStructureGeometryAabbsDataKHR ¶

    AccelerationStructureGeometryAabbsDataKHR :: struct {
    	sType:  StructureType,
    	pNext:  rawptr,
    	data:   DeviceOrHostAddressConstKHR,
    	stride: DeviceSize,
    }

    AccelerationStructureGeometryInstancesDataKHR ¶

    AccelerationStructureGeometryInstancesDataKHR :: struct {
    	sType:           StructureType,
    	pNext:           rawptr,
    	arrayOfPointers: b32,
    	data:            DeviceOrHostAddressConstKHR,
    }

    AccelerationStructureGeometryKHR ¶

    AccelerationStructureGeometryKHR :: struct {
    	sType:        StructureType,
    	pNext:        rawptr,
    	geometryType: GeometryTypeKHR,
    	geometry:     AccelerationStructureGeometryDataKHR,
    	flags:        GeometryFlagsKHR,
    }

    AccelerationStructureGeometryMotionTrianglesDataNV ¶

    AccelerationStructureGeometryMotionTrianglesDataNV :: struct {
    	sType:      StructureType,
    	pNext:      rawptr,
    	vertexData: DeviceOrHostAddressConstKHR,
    }

    AccelerationStructureGeometryTrianglesDataKHR ¶

    AccelerationStructureGeometryTrianglesDataKHR :: struct {
    	sType:         StructureType,
    	pNext:         rawptr,
    	vertexFormat:  Format,
    	vertexData:    DeviceOrHostAddressConstKHR,
    	vertexStride:  DeviceSize,
    	maxVertex:     u32,
    	indexType:     IndexType,
    	indexData:     DeviceOrHostAddressConstKHR,
    	transformData: DeviceOrHostAddressConstKHR,
    }

    AccelerationStructureInfoNV ¶

    AccelerationStructureInfoNV :: struct {
    	sType:         StructureType,
    	pNext:         rawptr,
    	type:          AccelerationStructureTypeKHR,
    	flags:         BuildAccelerationStructureFlagsKHR,
    	instanceCount: u32,
    	geometryCount: u32,
    	pGeometries:   [^]GeometryNV,
    }

    AccelerationStructureInstanceKHR ¶

    AccelerationStructureInstanceKHR :: struct {
    	transform:                                      TransformMatrixKHR,
    	instanceCustomIndexAndMask:                     u32,
    	// Most significant byte is mask
    	instanceShaderBindingTableRecordOffsetAndFlags: u32,
    	// Most significant byte is flags
    	accelerationStructureReference:                 u64,
    }

    AccelerationStructureKHR ¶

    AccelerationStructureKHR :: distinct u64

    AccelerationStructureMatrixMotionInstanceNV ¶

    AccelerationStructureMatrixMotionInstanceNV :: struct {
    	transformT0:                                    TransformMatrixKHR,
    	transformT1:                                    TransformMatrixKHR,
    	instanceCustomIndexAndMask:                     u32,
    	// Most significant byte is mask
    	instanceShaderBindingTableRecordOffsetAndFlags: u32,
    	// Most significant byte is flags
    	accelerationStructureReference:                 u64,
    }

    AccelerationStructureMemoryRequirementsInfoNV ¶

    AccelerationStructureMemoryRequirementsInfoNV :: struct {
    	sType:                 StructureType,
    	pNext:                 rawptr,
    	type:                  AccelerationStructureMemoryRequirementsTypeNV,
    	accelerationStructure: AccelerationStructureNV,
    }

    AccelerationStructureMemoryRequirementsTypeNV ¶

    AccelerationStructureMemoryRequirementsTypeNV :: enum i32 {
    	OBJECT         = 0, 
    	BUILD_SCRATCH  = 1, 
    	UPDATE_SCRATCH = 2, 
    }

    AccelerationStructureMotionInfoFlagNV ¶

    AccelerationStructureMotionInfoFlagNV :: enum u32 {
    }

    AccelerationStructureMotionInfoFlagsNV ¶

    AccelerationStructureMotionInfoFlagsNV :: distinct bit_set[AccelerationStructureMotionInfoFlagNV; Flags]

    AccelerationStructureMotionInfoNV ¶

    AccelerationStructureMotionInfoNV :: struct {
    	sType:        StructureType,
    	pNext:        rawptr,
    	maxInstances: u32,
    	flags:        AccelerationStructureMotionInfoFlagsNV,
    }

    AccelerationStructureMotionInstanceDataNV ¶

    AccelerationStructureMotionInstanceDataNV :: struct #raw_union {
    	staticInstance:       AccelerationStructureInstanceKHR,
    	matrixMotionInstance: AccelerationStructureMatrixMotionInstanceNV,
    	srtMotionInstance:    AccelerationStructureSRTMotionInstanceNV,
    }

    AccelerationStructureMotionInstanceFlagNV ¶

    AccelerationStructureMotionInstanceFlagNV :: enum u32 {
    }

    AccelerationStructureMotionInstanceFlagsNV ¶

    AccelerationStructureMotionInstanceFlagsNV :: distinct bit_set[AccelerationStructureMotionInstanceFlagNV; Flags]

    AccelerationStructureMotionInstanceTypeNV ¶

    AccelerationStructureMotionInstanceTypeNV :: enum i32 {
    	STATIC        = 0, 
    	MATRIX_MOTION = 1, 
    	SRT_MOTION    = 2, 
    }

    AccelerationStructureNV ¶

    AccelerationStructureNV :: distinct u64

    AccelerationStructureSRTMotionInstanceNV ¶

    AccelerationStructureSRTMotionInstanceNV :: struct {
    	transformT0:                                    SRTDataNV,
    	transformT1:                                    SRTDataNV,
    	instanceCustomIndexAndMask:                     u32,
    	// Most significant byte is mask
    	instanceShaderBindingTableRecordOffsetAndFlags: u32,
    	// Most significant byte is flags
    	accelerationStructureReference:                 u64,
    }

    AccelerationStructureTrianglesOpacityMicromapEXT ¶

    AccelerationStructureTrianglesOpacityMicromapEXT :: struct {
    	sType:            StructureType,
    	pNext:            rawptr,
    	indexType:        IndexType,
    	indexBuffer:      DeviceOrHostAddressConstKHR,
    	indexStride:      DeviceSize,
    	baseTriangle:     u32,
    	usageCountsCount: u32,
    	pUsageCounts:     [^]MicromapUsageEXT,
    	ppUsageCounts:    ^[^]MicromapUsageEXT,
    	micromap:         MicromapEXT,
    }

    AccelerationStructureTypeKHR ¶

    AccelerationStructureTypeKHR :: enum i32 {
    	TOP_LEVEL       = 0, 
    	BOTTOM_LEVEL    = 1, 
    	GENERIC         = 2, 
    	TOP_LEVEL_NV    = 0, 
    	BOTTOM_LEVEL_NV = 1, 
    }

    AccelerationStructureVersionInfoKHR ¶

    AccelerationStructureVersionInfoKHR :: struct {
    	sType:        StructureType,
    	pNext:        rawptr,
    	pVersionData: ^u8,
    }

    AccessFlag ¶

    AccessFlag :: enum Flags {
    	INDIRECT_COMMAND_READ                     = 0, 
    	INDEX_READ                                = 1, 
    	VERTEX_ATTRIBUTE_READ                     = 2, 
    	UNIFORM_READ                              = 3, 
    	INPUT_ATTACHMENT_READ                     = 4, 
    	SHADER_READ                               = 5, 
    	SHADER_WRITE                              = 6, 
    	COLOR_ATTACHMENT_READ                     = 7, 
    	COLOR_ATTACHMENT_WRITE                    = 8, 
    	DEPTH_STENCIL_ATTACHMENT_READ             = 9, 
    	DEPTH_STENCIL_ATTACHMENT_WRITE            = 10, 
    	TRANSFER_READ                             = 11, 
    	TRANSFER_WRITE                            = 12, 
    	HOST_READ                                 = 13, 
    	HOST_WRITE                                = 14, 
    	MEMORY_READ                               = 15, 
    	MEMORY_WRITE                              = 16, 
    	TRANSFORM_FEEDBACK_WRITE_EXT              = 25, 
    	TRANSFORM_FEEDBACK_COUNTER_READ_EXT       = 26, 
    	TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT      = 27, 
    	CONDITIONAL_RENDERING_READ_EXT            = 20, 
    	COLOR_ATTACHMENT_READ_NONCOHERENT_EXT     = 19, 
    	ACCELERATION_STRUCTURE_READ_KHR           = 21, 
    	ACCELERATION_STRUCTURE_WRITE_KHR          = 22, 
    	FRAGMENT_DENSITY_MAP_READ_EXT             = 24, 
    	FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR = 23, 
    	COMMAND_PREPROCESS_READ_NV                = 17, 
    	COMMAND_PREPROCESS_WRITE_NV               = 18, 
    	SHADING_RATE_IMAGE_READ_NV                = 23, 
    	ACCELERATION_STRUCTURE_READ_NV            = 21, 
    	ACCELERATION_STRUCTURE_WRITE_NV           = 22, 
    }

    AccessFlag2 ¶

    AccessFlag2 :: enum Flags64 {
    	INDIRECT_COMMAND_READ                     = 0, 
    	INDIRECT_COMMAND_READ_KHR                 = 0, 
    	INDEX_READ                                = 1, 
    	INDEX_READ_KHR                            = 1, 
    	VERTEX_ATTRIBUTE_READ                     = 2, 
    	VERTEX_ATTRIBUTE_READ_KHR                 = 2, 
    	UNIFORM_READ                              = 3, 
    	UNIFORM_READ_KHR                          = 3, 
    	INPUT_ATTACHMENT_READ                     = 4, 
    	INPUT_ATTACHMENT_READ_KHR                 = 4, 
    	SHADER_READ                               = 5, 
    	SHADER_READ_KHR                           = 5, 
    	SHADER_WRITE                              = 6, 
    	SHADER_WRITE_KHR                          = 6, 
    	COLOR_ATTACHMENT_READ                     = 7, 
    	COLOR_ATTACHMENT_READ_KHR                 = 7, 
    	COLOR_ATTACHMENT_WRITE                    = 8, 
    	COLOR_ATTACHMENT_WRITE_KHR                = 8, 
    	DEPTH_STENCIL_ATTACHMENT_READ             = 9, 
    	DEPTH_STENCIL_ATTACHMENT_READ_KHR         = 9, 
    	DEPTH_STENCIL_ATTACHMENT_WRITE            = 10, 
    	DEPTH_STENCIL_ATTACHMENT_WRITE_KHR        = 10, 
    	TRANSFER_READ                             = 11, 
    	TRANSFER_READ_KHR                         = 11, 
    	TRANSFER_WRITE                            = 12, 
    	TRANSFER_WRITE_KHR                        = 12, 
    	HOST_READ                                 = 13, 
    	HOST_READ_KHR                             = 13, 
    	HOST_WRITE                                = 14, 
    	HOST_WRITE_KHR                            = 14, 
    	MEMORY_READ                               = 15, 
    	MEMORY_READ_KHR                           = 15, 
    	MEMORY_WRITE                              = 16, 
    	MEMORY_WRITE_KHR                          = 16, 
    	SHADER_SAMPLED_READ                       = 32, 
    	SHADER_SAMPLED_READ_KHR                   = 32, 
    	SHADER_STORAGE_READ                       = 33, 
    	SHADER_STORAGE_READ_KHR                   = 33, 
    	SHADER_STORAGE_WRITE                      = 34, 
    	SHADER_STORAGE_WRITE_KHR                  = 34, 
    	VIDEO_DECODE_READ_KHR                     = 35, 
    	VIDEO_DECODE_WRITE_KHR                    = 36, 
    	VIDEO_ENCODE_READ_KHR                     = 37, 
    	VIDEO_ENCODE_WRITE_KHR                    = 38, 
    	TRANSFORM_FEEDBACK_WRITE_EXT              = 25, 
    	TRANSFORM_FEEDBACK_COUNTER_READ_EXT       = 26, 
    	TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT      = 27, 
    	CONDITIONAL_RENDERING_READ_EXT            = 20, 
    	COMMAND_PREPROCESS_READ_NV                = 17, 
    	COMMAND_PREPROCESS_WRITE_NV               = 18, 
    	FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR = 23, 
    	SHADING_RATE_IMAGE_READ_NV                = 23, 
    	ACCELERATION_STRUCTURE_READ_KHR           = 21, 
    	ACCELERATION_STRUCTURE_WRITE_KHR          = 22, 
    	ACCELERATION_STRUCTURE_READ_NV            = 21, 
    	ACCELERATION_STRUCTURE_WRITE_NV           = 22, 
    	FRAGMENT_DENSITY_MAP_READ_EXT             = 24, 
    	COLOR_ATTACHMENT_READ_NONCOHERENT_EXT     = 19, 
    	DESCRIPTOR_BUFFER_READ_EXT                = 41, 
    	INVOCATION_MASK_READ_HUAWEI               = 39, 
    	SHADER_BINDING_TABLE_READ_KHR             = 40, 
    	MICROMAP_READ_EXT                         = 44, 
    	MICROMAP_WRITE_EXT                        = 45, 
    	OPTICAL_FLOW_READ_NV                      = 42, 
    	OPTICAL_FLOW_WRITE_NV                     = 43, 
    }

    AccessFlags ¶

    AccessFlags :: distinct bit_set[AccessFlag; Flags]
    Related Constants

    AccessFlags2 ¶

    AccessFlags2 :: distinct bit_set[AccessFlag2; Flags64]

    AcquireNextImageInfoKHR ¶

    AcquireNextImageInfoKHR :: struct {
    	sType:      StructureType,
    	pNext:      rawptr,
    	swapchain:  SwapchainKHR,
    	timeout:    u64,
    	semaphore:  Semaphore,
    	fence:      Fence,
    	deviceMask: u32,
    }

    AcquireProfilingLockFlagKHR ¶

    AcquireProfilingLockFlagKHR :: enum Flags {
    }

    AcquireProfilingLockFlagsKHR ¶

    AcquireProfilingLockFlagsKHR :: distinct bit_set[AcquireProfilingLockFlagKHR; Flags]

    AcquireProfilingLockInfoKHR ¶

    AcquireProfilingLockInfoKHR :: struct {
    	sType:   StructureType,
    	pNext:   rawptr,
    	flags:   AcquireProfilingLockFlagsKHR,
    	timeout: u64,
    }

    AllocationCallbacks ¶

    AllocationCallbacks :: struct {
    	pUserData:             rawptr,
    	pfnAllocation:         ProcAllocationFunction,
    	pfnReallocation:       ProcReallocationFunction,
    	pfnFree:               ProcFreeFunction,
    	pfnInternalAllocation: ProcInternalAllocationNotification,
    	pfnInternalFree:       ProcInternalFreeNotification,
    }

    AmigoProfilingSubmitInfoSEC ¶

    AmigoProfilingSubmitInfoSEC :: struct {
    	sType:               StructureType,
    	pNext:               rawptr,
    	firstDrawTimestamp:  u64,
    	swapBufferTimestamp: u64,
    }

    ApplicationInfo ¶

    ApplicationInfo :: struct {
    	sType:              StructureType,
    	pNext:              rawptr,
    	pApplicationName:   cstring,
    	applicationVersion: u32,
    	pEngineName:        cstring,
    	engineVersion:      u32,
    	apiVersion:         u32,
    }

    AttachmentDescription ¶

    AttachmentDescription :: struct {
    	flags:          AttachmentDescriptionFlags,
    	format:         Format,
    	samples:        SampleCountFlags,
    	loadOp:         AttachmentLoadOp,
    	storeOp:        AttachmentStoreOp,
    	stencilLoadOp:  AttachmentLoadOp,
    	stencilStoreOp: AttachmentStoreOp,
    	initialLayout:  ImageLayout,
    	finalLayout:    ImageLayout,
    }

    AttachmentDescription2 ¶

    AttachmentDescription2 :: struct {
    	sType:          StructureType,
    	pNext:          rawptr,
    	flags:          AttachmentDescriptionFlags,
    	format:         Format,
    	samples:        SampleCountFlags,
    	loadOp:         AttachmentLoadOp,
    	storeOp:        AttachmentStoreOp,
    	stencilLoadOp:  AttachmentLoadOp,
    	stencilStoreOp: AttachmentStoreOp,
    	initialLayout:  ImageLayout,
    	finalLayout:    ImageLayout,
    }

    AttachmentDescriptionFlag ¶

    AttachmentDescriptionFlag :: enum Flags {
    	MAY_ALIAS = 0, 
    }

    AttachmentDescriptionFlags ¶

    AttachmentDescriptionFlags :: distinct bit_set[AttachmentDescriptionFlag; Flags]

    AttachmentDescriptionStencilLayout ¶

    AttachmentDescriptionStencilLayout :: struct {
    	sType:                StructureType,
    	pNext:                rawptr,
    	stencilInitialLayout: ImageLayout,
    	stencilFinalLayout:   ImageLayout,
    }

    AttachmentLoadOp ¶

    AttachmentLoadOp :: enum i32 {
    	LOAD      = 0, 
    	CLEAR     = 1, 
    	DONT_CARE = 2, 
    	NONE_EXT  = 1000400000, 
    }

    AttachmentReference ¶

    AttachmentReference :: struct {
    	attachment: u32,
    	layout:     ImageLayout,
    }

    AttachmentReference2 ¶

    AttachmentReference2 :: struct {
    	sType:      StructureType,
    	pNext:      rawptr,
    	attachment: u32,
    	layout:     ImageLayout,
    	aspectMask: ImageAspectFlags,
    }

    AttachmentReferenceStencilLayout ¶

    AttachmentReferenceStencilLayout :: struct {
    	sType:         StructureType,
    	pNext:         rawptr,
    	stencilLayout: ImageLayout,
    }

    AttachmentSampleCountInfoAMD ¶

    AttachmentSampleCountInfoAMD :: struct {
    	sType:                         StructureType,
    	pNext:                         rawptr,
    	colorAttachmentCount:          u32,
    	pColorAttachmentSamples:       [^]SampleCountFlags,
    	depthStencilAttachmentSamples: SampleCountFlags,
    }

    AttachmentSampleLocationsEXT ¶

    AttachmentSampleLocationsEXT :: struct {
    	attachmentIndex:     u32,
    	sampleLocationsInfo: SampleLocationsInfoEXT,
    }

    AttachmentStoreOp ¶

    AttachmentStoreOp :: enum i32 {
    	STORE     = 0, 
    	DONT_CARE = 1, 
    	NONE      = 1000301000, 
    }

    BaseInStructure ¶

    BaseInStructure :: struct {
    	sType: StructureType,
    	pNext: ^BaseInStructure,
    }

    BaseOutStructure ¶

    BaseOutStructure :: struct {
    	sType: StructureType,
    	pNext: ^BaseOutStructure,
    }

    BindAccelerationStructureMemoryInfoNV ¶

    BindAccelerationStructureMemoryInfoNV :: struct {
    	sType:                 StructureType,
    	pNext:                 rawptr,
    	accelerationStructure: AccelerationStructureNV,
    	memory:                DeviceMemory,
    	memoryOffset:          DeviceSize,
    	deviceIndexCount:      u32,
    	pDeviceIndices:        [^]u32,
    }

    BindBufferMemoryDeviceGroupInfo ¶

    BindBufferMemoryDeviceGroupInfo :: struct {
    	sType:            StructureType,
    	pNext:            rawptr,
    	deviceIndexCount: u32,
    	pDeviceIndices:   [^]u32,
    }

    BindBufferMemoryInfo ¶

    BindBufferMemoryInfo :: struct {
    	sType:        StructureType,
    	pNext:        rawptr,
    	buffer:       Buffer,
    	memory:       DeviceMemory,
    	memoryOffset: DeviceSize,
    }

    BindImageMemoryDeviceGroupInfo ¶

    BindImageMemoryDeviceGroupInfo :: struct {
    	sType:                        StructureType,
    	pNext:                        rawptr,
    	deviceIndexCount:             u32,
    	pDeviceIndices:               [^]u32,
    	splitInstanceBindRegionCount: u32,
    	pSplitInstanceBindRegions:    [^]Rect2D,
    }

    BindImageMemoryInfo ¶

    BindImageMemoryInfo :: struct {
    	sType:        StructureType,
    	pNext:        rawptr,
    	image:        Image,
    	memory:       DeviceMemory,
    	memoryOffset: DeviceSize,
    }

    BindImageMemorySwapchainInfoKHR ¶

    BindImageMemorySwapchainInfoKHR :: struct {
    	sType:      StructureType,
    	pNext:      rawptr,
    	swapchain:  SwapchainKHR,
    	imageIndex: u32,
    }

    BindImagePlaneMemoryInfo ¶

    BindImagePlaneMemoryInfo :: struct {
    	sType:       StructureType,
    	pNext:       rawptr,
    	planeAspect: ImageAspectFlags,
    }

    BindIndexBufferIndirectCommandNV ¶

    BindIndexBufferIndirectCommandNV :: struct {
    	bufferAddress: DeviceAddress,
    	size:          u32,
    	indexType:     IndexType,
    }

    BindShaderGroupIndirectCommandNV ¶

    BindShaderGroupIndirectCommandNV :: struct {
    	groupIndex: u32,
    }

    BindSparseInfo ¶

    BindSparseInfo :: struct {
    	sType:                StructureType,
    	pNext:                rawptr,
    	waitSemaphoreCount:   u32,
    	pWaitSemaphores:      [^]Semaphore,
    	bufferBindCount:      u32,
    	pBufferBinds:         [^]SparseBufferMemoryBindInfo,
    	imageOpaqueBindCount: u32,
    	pImageOpaqueBinds:    [^]SparseImageOpaqueMemoryBindInfo,
    	imageBindCount:       u32,
    	pImageBinds:          [^]SparseImageMemoryBindInfo,
    	signalSemaphoreCount: u32,
    	pSignalSemaphores:    [^]Semaphore,
    }

    BindVertexBufferIndirectCommandNV ¶

    BindVertexBufferIndirectCommandNV :: struct {
    	bufferAddress: DeviceAddress,
    	size:          u32,
    	stride:        u32,
    }

    BindVideoSessionMemoryInfoKHR ¶

    BindVideoSessionMemoryInfoKHR :: struct {
    	sType:           StructureType,
    	pNext:           rawptr,
    	memoryBindIndex: u32,
    	memory:          DeviceMemory,
    	memoryOffset:    DeviceSize,
    	memorySize:      DeviceSize,
    }

    BlendFactor ¶

    BlendFactor :: enum i32 {
    	ZERO                     = 0, 
    	ONE                      = 1, 
    	SRC_COLOR                = 2, 
    	ONE_MINUS_SRC_COLOR      = 3, 
    	DST_COLOR                = 4, 
    	ONE_MINUS_DST_COLOR      = 5, 
    	SRC_ALPHA                = 6, 
    	ONE_MINUS_SRC_ALPHA      = 7, 
    	DST_ALPHA                = 8, 
    	ONE_MINUS_DST_ALPHA      = 9, 
    	CONSTANT_COLOR           = 10, 
    	ONE_MINUS_CONSTANT_COLOR = 11, 
    	CONSTANT_ALPHA           = 12, 
    	ONE_MINUS_CONSTANT_ALPHA = 13, 
    	SRC_ALPHA_SATURATE       = 14, 
    	SRC1_COLOR               = 15, 
    	ONE_MINUS_SRC1_COLOR     = 16, 
    	SRC1_ALPHA               = 17, 
    	ONE_MINUS_SRC1_ALPHA     = 18, 
    }

    BlendOp ¶

    BlendOp :: enum i32 {
    	ADD                    = 0, 
    	SUBTRACT               = 1, 
    	REVERSE_SUBTRACT       = 2, 
    	MIN                    = 3, 
    	MAX                    = 4, 
    	ZERO_EXT               = 1000148000, 
    	SRC_EXT                = 1000148001, 
    	DST_EXT                = 1000148002, 
    	SRC_OVER_EXT           = 1000148003, 
    	DST_OVER_EXT           = 1000148004, 
    	SRC_IN_EXT             = 1000148005, 
    	DST_IN_EXT             = 1000148006, 
    	SRC_OUT_EXT            = 1000148007, 
    	DST_OUT_EXT            = 1000148008, 
    	SRC_ATOP_EXT           = 1000148009, 
    	DST_ATOP_EXT           = 1000148010, 
    	XOR_EXT                = 1000148011, 
    	MULTIPLY_EXT           = 1000148012, 
    	SCREEN_EXT             = 1000148013, 
    	OVERLAY_EXT            = 1000148014, 
    	DARKEN_EXT             = 1000148015, 
    	LIGHTEN_EXT            = 1000148016, 
    	COLORDODGE_EXT         = 1000148017, 
    	COLORBURN_EXT          = 1000148018, 
    	HARDLIGHT_EXT          = 1000148019, 
    	SOFTLIGHT_EXT          = 1000148020, 
    	DIFFERENCE_EXT         = 1000148021, 
    	EXCLUSION_EXT          = 1000148022, 
    	INVERT_EXT             = 1000148023, 
    	INVERT_RGB_EXT         = 1000148024, 
    	LINEARDODGE_EXT        = 1000148025, 
    	LINEARBURN_EXT         = 1000148026, 
    	VIVIDLIGHT_EXT         = 1000148027, 
    	LINEARLIGHT_EXT        = 1000148028, 
    	PINLIGHT_EXT           = 1000148029, 
    	HARDMIX_EXT            = 1000148030, 
    	HSL_HUE_EXT            = 1000148031, 
    	HSL_SATURATION_EXT     = 1000148032, 
    	HSL_COLOR_EXT          = 1000148033, 
    	HSL_LUMINOSITY_EXT     = 1000148034, 
    	PLUS_EXT               = 1000148035, 
    	PLUS_CLAMPED_EXT       = 1000148036, 
    	PLUS_CLAMPED_ALPHA_EXT = 1000148037, 
    	PLUS_DARKER_EXT        = 1000148038, 
    	MINUS_EXT              = 1000148039, 
    	MINUS_CLAMPED_EXT      = 1000148040, 
    	CONTRAST_EXT           = 1000148041, 
    	INVERT_OVG_EXT         = 1000148042, 
    	RED_EXT                = 1000148043, 
    	GREEN_EXT              = 1000148044, 
    	BLUE_EXT               = 1000148045, 
    }

    BlendOverlapEXT ¶

    BlendOverlapEXT :: enum i32 {
    	UNCORRELATED = 0, 
    	DISJOINT     = 1, 
    	CONJOINT     = 2, 
    }

    BlitImageInfo2 ¶

    BlitImageInfo2 :: struct {
    	sType:          StructureType,
    	pNext:          rawptr,
    	srcImage:       Image,
    	srcImageLayout: ImageLayout,
    	dstImage:       Image,
    	dstImageLayout: ImageLayout,
    	regionCount:    u32,
    	pRegions:       [^]ImageBlit2,
    	filter:         Filter,
    }

    BorderColor ¶

    BorderColor :: enum i32 {
    	FLOAT_TRANSPARENT_BLACK = 0, 
    	INT_TRANSPARENT_BLACK   = 1, 
    	FLOAT_OPAQUE_BLACK      = 2, 
    	INT_OPAQUE_BLACK        = 3, 
    	FLOAT_OPAQUE_WHITE      = 4, 
    	INT_OPAQUE_WHITE        = 5, 
    	FLOAT_CUSTOM_EXT        = 1000287003, 
    	INT_CUSTOM_EXT          = 1000287004, 
    }

    Buffer ¶

    Buffer :: distinct u64

    BufferCaptureDescriptorDataInfoEXT ¶

    BufferCaptureDescriptorDataInfoEXT :: struct {
    	sType:  StructureType,
    	pNext:  rawptr,
    	buffer: Buffer,
    }

    BufferCopy ¶

    BufferCopy :: struct {
    	srcOffset: DeviceSize,
    	dstOffset: DeviceSize,
    	size:      DeviceSize,
    }

    BufferCopy2 ¶

    BufferCopy2 :: struct {
    	sType:     StructureType,
    	pNext:     rawptr,
    	srcOffset: DeviceSize,
    	dstOffset: DeviceSize,
    	size:      DeviceSize,
    }

    BufferCreateFlag ¶

    BufferCreateFlag :: enum Flags {
    	SPARSE_BINDING                       = 0, 
    	SPARSE_RESIDENCY                     = 1, 
    	SPARSE_ALIASED                       = 2, 
    	PROTECTED                            = 3, 
    	DEVICE_ADDRESS_CAPTURE_REPLAY        = 4, 
    	DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT = 5, 
    	DEVICE_ADDRESS_CAPTURE_REPLAY_EXT    = 4, 
    	DEVICE_ADDRESS_CAPTURE_REPLAY_KHR    = 4, 
    }

    BufferCreateFlags ¶

    BufferCreateFlags :: distinct bit_set[BufferCreateFlag; Flags]

    BufferCreateInfo ¶

    BufferCreateInfo :: struct {
    	sType:                 StructureType,
    	pNext:                 rawptr,
    	flags:                 BufferCreateFlags,
    	size:                  DeviceSize,
    	usage:                 BufferUsageFlags,
    	sharingMode:           SharingMode,
    	queueFamilyIndexCount: u32,
    	pQueueFamilyIndices:   [^]u32,
    }

    BufferDeviceAddressCreateInfoEXT ¶

    BufferDeviceAddressCreateInfoEXT :: struct {
    	sType:         StructureType,
    	pNext:         rawptr,
    	deviceAddress: DeviceAddress,
    }

    BufferDeviceAddressInfo ¶

    BufferDeviceAddressInfo :: struct {
    	sType:  StructureType,
    	pNext:  rawptr,
    	buffer: Buffer,
    }

    BufferImageCopy ¶

    BufferImageCopy :: struct {
    	bufferOffset:      DeviceSize,
    	bufferRowLength:   u32,
    	bufferImageHeight: u32,
    	imageSubresource:  ImageSubresourceLayers,
    	imageOffset:       Offset3D,
    	imageExtent:       Extent3D,
    }

    BufferImageCopy2 ¶

    BufferImageCopy2 :: struct {
    	sType:             StructureType,
    	pNext:             rawptr,
    	bufferOffset:      DeviceSize,
    	bufferRowLength:   u32,
    	bufferImageHeight: u32,
    	imageSubresource:  ImageSubresourceLayers,
    	imageOffset:       Offset3D,
    	imageExtent:       Extent3D,
    }

    BufferMemoryBarrier ¶

    BufferMemoryBarrier :: struct {
    	sType:               StructureType,
    	pNext:               rawptr,
    	srcAccessMask:       AccessFlags,
    	dstAccessMask:       AccessFlags,
    	srcQueueFamilyIndex: u32,
    	dstQueueFamilyIndex: u32,
    	buffer:              Buffer,
    	offset:              DeviceSize,
    	size:                DeviceSize,
    }

    BufferMemoryBarrier2 ¶

    BufferMemoryBarrier2 :: struct {
    	sType:               StructureType,
    	pNext:               rawptr,
    	srcStageMask:        PipelineStageFlags2,
    	srcAccessMask:       AccessFlags2,
    	dstStageMask:        PipelineStageFlags2,
    	dstAccessMask:       AccessFlags2,
    	srcQueueFamilyIndex: u32,
    	dstQueueFamilyIndex: u32,
    	buffer:              Buffer,
    	offset:              DeviceSize,
    	size:                DeviceSize,
    }

    BufferMemoryRequirementsInfo2 ¶

    BufferMemoryRequirementsInfo2 :: struct {
    	sType:  StructureType,
    	pNext:  rawptr,
    	buffer: Buffer,
    }

    BufferOpaqueCaptureAddressCreateInfo ¶

    BufferOpaqueCaptureAddressCreateInfo :: struct {
    	sType:                StructureType,
    	pNext:                rawptr,
    	opaqueCaptureAddress: u64,
    }

    BufferUsageFlag ¶

    BufferUsageFlag :: enum Flags {
    	TRANSFER_SRC                                     = 0, 
    	TRANSFER_DST                                     = 1, 
    	UNIFORM_TEXEL_BUFFER                             = 2, 
    	STORAGE_TEXEL_BUFFER                             = 3, 
    	UNIFORM_BUFFER                                   = 4, 
    	STORAGE_BUFFER                                   = 5, 
    	INDEX_BUFFER                                     = 6, 
    	VERTEX_BUFFER                                    = 7, 
    	INDIRECT_BUFFER                                  = 8, 
    	SHADER_DEVICE_ADDRESS                            = 17, 
    	VIDEO_DECODE_SRC_KHR                             = 13, 
    	VIDEO_DECODE_DST_KHR                             = 14, 
    	TRANSFORM_FEEDBACK_BUFFER_EXT                    = 11, 
    	TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT            = 12, 
    	CONDITIONAL_RENDERING_EXT                        = 9, 
    	ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_KHR = 19, 
    	ACCELERATION_STRUCTURE_STORAGE_KHR               = 20, 
    	SHADER_BINDING_TABLE_KHR                         = 10, 
    	VIDEO_ENCODE_DST_KHR                             = 15, 
    	VIDEO_ENCODE_SRC_KHR                             = 16, 
    	SAMPLER_DESCRIPTOR_BUFFER_EXT                    = 21, 
    	RESOURCE_DESCRIPTOR_BUFFER_EXT                   = 22, 
    	PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_EXT           = 26, 
    	MICROMAP_BUILD_INPUT_READ_ONLY_EXT               = 23, 
    	MICROMAP_STORAGE_EXT                             = 24, 
    	RAY_TRACING_NV                                   = 10, 
    	SHADER_DEVICE_ADDRESS_EXT                        = 17, 
    	SHADER_DEVICE_ADDRESS_KHR                        = 17, 
    }

    BufferUsageFlags ¶

    BufferUsageFlags :: distinct bit_set[BufferUsageFlag; Flags]

    BufferView ¶

    BufferView :: distinct u64

    BufferViewCreateFlag ¶

    BufferViewCreateFlag :: enum u32 {
    }

    BufferViewCreateFlags ¶

    BufferViewCreateFlags :: distinct bit_set[BufferViewCreateFlag; Flags]

    BufferViewCreateInfo ¶

    BufferViewCreateInfo :: struct {
    	sType:  StructureType,
    	pNext:  rawptr,
    	flags:  BufferViewCreateFlags,
    	buffer: Buffer,
    	format: Format,
    	offset: DeviceSize,
    	range:  DeviceSize,
    }

    BuildAccelerationStructureFlagKHR ¶

    BuildAccelerationStructureFlagKHR :: enum Flags {
    	ALLOW_UPDATE                           = 0, 
    	ALLOW_COMPACTION                       = 1, 
    	PREFER_FAST_TRACE                      = 2, 
    	PREFER_FAST_BUILD                      = 3, 
    	LOW_MEMORY                             = 4, 
    	MOTION_NV                              = 5, 
    	ALLOW_OPACITY_MICROMAP_UPDATE_EXT      = 6, 
    	ALLOW_DISABLE_OPACITY_MICROMAPS_EXT    = 7, 
    	ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT = 8, 
    	ALLOW_DISPLACEMENT_MICROMAP_UPDATE_NV  = 9, 
    	ALLOW_DATA_ACCESS                      = 11, 
    	ALLOW_UPDATE_NV                        = 0, 
    	ALLOW_COMPACTION_NV                    = 1, 
    	PREFER_FAST_TRACE_NV                   = 2, 
    	PREFER_FAST_BUILD_NV                   = 3, 
    	LOW_MEMORY_NV                          = 4, 
    }

    BuildAccelerationStructureFlagsKHR ¶

    BuildAccelerationStructureFlagsKHR :: distinct bit_set[BuildAccelerationStructureFlagKHR; Flags]

    BuildAccelerationStructureModeKHR ¶

    BuildAccelerationStructureModeKHR :: enum i32 {
    	BUILD  = 0, 
    	UPDATE = 1, 
    }

    BuildMicromapFlagEXT ¶

    BuildMicromapFlagEXT :: enum Flags {
    	PREFER_FAST_TRACE = 0, 
    	PREFER_FAST_BUILD = 1, 
    	ALLOW_COMPACTION  = 2, 
    }

    BuildMicromapFlagsEXT ¶

    BuildMicromapFlagsEXT :: distinct bit_set[BuildMicromapFlagEXT; Flags]

    BuildMicromapModeEXT ¶

    BuildMicromapModeEXT :: enum i32 {
    	BUILD = 0, 
    }

    CAMetalLayer ¶

    CAMetalLayer :: struct {}

    CalibratedTimestampInfoEXT ¶

    CalibratedTimestampInfoEXT :: struct {
    	sType:      StructureType,
    	pNext:      rawptr,
    	timeDomain: TimeDomainEXT,
    }

    CheckpointData2NV ¶

    CheckpointData2NV :: struct {
    	sType:             StructureType,
    	pNext:             rawptr,
    	stage:             PipelineStageFlags2,
    	pCheckpointMarker: rawptr,
    }

    CheckpointDataNV ¶

    CheckpointDataNV :: struct {
    	sType:             StructureType,
    	pNext:             rawptr,
    	stage:             PipelineStageFlags,
    	pCheckpointMarker: rawptr,
    }

    ChromaLocation ¶

    ChromaLocation :: enum i32 {
    	COSITED_EVEN     = 0, 
    	MIDPOINT         = 1, 
    	COSITED_EVEN_KHR = 0, 
    	MIDPOINT_KHR     = 1, 
    }

    ClearAttachment ¶

    ClearAttachment :: struct {
    	aspectMask:      ImageAspectFlags,
    	colorAttachment: u32,
    	clearValue:      ClearValue,
    }

    ClearColorValue ¶

    ClearColorValue :: struct #raw_union {
    	float32: [4]f32,
    	int32:   [4]i32,
    	uint32:  [4]u32,
    }

    ClearDepthStencilValue ¶

    ClearDepthStencilValue :: struct {
    	depth:   f32,
    	stencil: u32,
    }

    ClearRect ¶

    ClearRect :: struct {
    	rect:           Rect2D,
    	baseArrayLayer: u32,
    	layerCount:     u32,
    }

    ClearValue ¶

    ClearValue :: struct #raw_union {
    	color:        ClearColorValue,
    	depthStencil: ClearDepthStencilValue,
    }

    CoarseSampleLocationNV ¶

    CoarseSampleLocationNV :: struct {
    	pixelX: u32,
    	pixelY: u32,
    	sample: u32,
    }

    CoarseSampleOrderCustomNV ¶

    CoarseSampleOrderCustomNV :: struct {
    	shadingRate:         ShadingRatePaletteEntryNV,
    	sampleCount:         u32,
    	sampleLocationCount: u32,
    	pSampleLocations:    [^]CoarseSampleLocationNV,
    }

    CoarseSampleOrderTypeNV ¶

    CoarseSampleOrderTypeNV :: enum i32 {
    	DEFAULT      = 0, 
    	CUSTOM       = 1, 
    	PIXEL_MAJOR  = 2, 
    	SAMPLE_MAJOR = 3, 
    }

    ColorBlendAdvancedEXT ¶

    ColorBlendAdvancedEXT :: struct {
    	advancedBlendOp:  BlendOp,
    	srcPremultiplied: b32,
    	dstPremultiplied: b32,
    	blendOverlap:     BlendOverlapEXT,
    	clampResults:     b32,
    }

    ColorBlendEquationEXT ¶

    ColorBlendEquationEXT :: struct {
    	srcColorBlendFactor: BlendFactor,
    	dstColorBlendFactor: BlendFactor,
    	colorBlendOp:        BlendOp,
    	srcAlphaBlendFactor: BlendFactor,
    	dstAlphaBlendFactor: BlendFactor,
    	alphaBlendOp:        BlendOp,
    }

    ColorComponentFlag ¶

    ColorComponentFlag :: enum Flags {
    	R = 0, 
    	G = 1, 
    	B = 2, 
    	A = 3, 
    }

    ColorComponentFlags ¶

    ColorComponentFlags :: distinct bit_set[ColorComponentFlag; Flags]

    ColorSpaceKHR ¶

    ColorSpaceKHR :: enum i32 {
    	SRGB_NONLINEAR              = 0, 
    	DISPLAY_P3_NONLINEAR_EXT    = 1000104001, 
    	EXTENDED_SRGB_LINEAR_EXT    = 1000104002, 
    	DISPLAY_P3_LINEAR_EXT       = 1000104003, 
    	DCI_P3_NONLINEAR_EXT        = 1000104004, 
    	BT709_LINEAR_EXT            = 1000104005, 
    	BT709_NONLINEAR_EXT         = 1000104006, 
    	BT2020_LINEAR_EXT           = 1000104007, 
    	HDR10_ST2084_EXT            = 1000104008, 
    	DOLBYVISION_EXT             = 1000104009, 
    	HDR10_HLG_EXT               = 1000104010, 
    	ADOBERGB_LINEAR_EXT         = 1000104011, 
    	ADOBERGB_NONLINEAR_EXT      = 1000104012, 
    	PASS_THROUGH_EXT            = 1000104013, 
    	EXTENDED_SRGB_NONLINEAR_EXT = 1000104014, 
    	DISPLAY_NATIVE_AMD          = 1000213000, 
    	COLORSPACE_SRGB_NONLINEAR   = 0, 
    	DCI_P3_LINEAR_EXT           = 1000104003, 
    }

    CommandBuffer ¶

    CommandBuffer :: distinct rawptr

    CommandBufferAllocateInfo ¶

    CommandBufferAllocateInfo :: struct {
    	sType:              StructureType,
    	pNext:              rawptr,
    	commandPool:        CommandPool,
    	level:              CommandBufferLevel,
    	commandBufferCount: u32,
    }

    CommandBufferBeginInfo ¶

    CommandBufferBeginInfo :: struct {
    	sType:            StructureType,
    	pNext:            rawptr,
    	flags:            CommandBufferUsageFlags,
    	pInheritanceInfo: ^CommandBufferInheritanceInfo,
    }

    CommandBufferInheritanceConditionalRenderingInfoEXT ¶

    CommandBufferInheritanceConditionalRenderingInfoEXT :: struct {
    	sType:                      StructureType,
    	pNext:                      rawptr,
    	conditionalRenderingEnable: b32,
    }

    CommandBufferInheritanceInfo ¶

    CommandBufferInheritanceInfo :: struct {
    	sType:                StructureType,
    	pNext:                rawptr,
    	renderPass:           RenderPass,
    	subpass:              u32,
    	framebuffer:          Framebuffer,
    	occlusionQueryEnable: b32,
    	queryFlags:           QueryControlFlags,
    	pipelineStatistics:   QueryPipelineStatisticFlags,
    }

    CommandBufferInheritanceRenderPassTransformInfoQCOM ¶

    CommandBufferInheritanceRenderPassTransformInfoQCOM :: struct {
    	sType:      StructureType,
    	pNext:      rawptr,
    	transform:  SurfaceTransformFlagsKHR,
    	renderArea: Rect2D,
    }

    CommandBufferInheritanceRenderingInfo ¶

    CommandBufferInheritanceRenderingInfo :: struct {
    	sType:                   StructureType,
    	pNext:                   rawptr,
    	flags:                   RenderingFlags,
    	viewMask:                u32,
    	colorAttachmentCount:    u32,
    	pColorAttachmentFormats: [^]Format,
    	depthAttachmentFormat:   Format,
    	stencilAttachmentFormat: Format,
    	rasterizationSamples:    SampleCountFlags,
    }

    CommandBufferInheritanceViewportScissorInfoNV ¶

    CommandBufferInheritanceViewportScissorInfoNV :: struct {
    	sType:              StructureType,
    	pNext:              rawptr,
    	viewportScissor2D:  b32,
    	viewportDepthCount: u32,
    	pViewportDepths:    [^]Viewport,
    }

    CommandBufferLevel ¶

    CommandBufferLevel :: enum i32 {
    	PRIMARY   = 0, 
    	SECONDARY = 1, 
    }

    CommandBufferResetFlag ¶

    CommandBufferResetFlag :: enum Flags {
    	RELEASE_RESOURCES = 0, 
    }

    CommandBufferResetFlags ¶

    CommandBufferResetFlags :: distinct bit_set[CommandBufferResetFlag; Flags]

    CommandBufferSubmitInfo ¶

    CommandBufferSubmitInfo :: struct {
    	sType:         StructureType,
    	pNext:         rawptr,
    	commandBuffer: CommandBuffer,
    	deviceMask:    u32,
    }

    CommandBufferUsageFlag ¶

    CommandBufferUsageFlag :: enum Flags {
    	ONE_TIME_SUBMIT      = 0, 
    	RENDER_PASS_CONTINUE = 1, 
    	SIMULTANEOUS_USE     = 2, 
    }

    CommandBufferUsageFlags ¶

    CommandBufferUsageFlags :: distinct bit_set[CommandBufferUsageFlag; Flags]

    CommandPool ¶

    CommandPool :: distinct u64

    CommandPoolCreateFlag ¶

    CommandPoolCreateFlag :: enum Flags {
    	TRANSIENT            = 0, 
    	RESET_COMMAND_BUFFER = 1, 
    	PROTECTED            = 2, 
    }

    CommandPoolCreateFlags ¶

    CommandPoolCreateFlags :: distinct bit_set[CommandPoolCreateFlag; Flags]

    CommandPoolCreateInfo ¶

    CommandPoolCreateInfo :: struct {
    	sType:            StructureType,
    	pNext:            rawptr,
    	flags:            CommandPoolCreateFlags,
    	queueFamilyIndex: u32,
    }

    CommandPoolResetFlag ¶

    CommandPoolResetFlag :: enum Flags {
    	RELEASE_RESOURCES = 0, 
    }

    CommandPoolResetFlags ¶

    CommandPoolResetFlags :: distinct bit_set[CommandPoolResetFlag; Flags]

    CommandPoolTrimFlag ¶

    CommandPoolTrimFlag :: enum u32 {
    }

    CommandPoolTrimFlags ¶

    CommandPoolTrimFlags :: distinct bit_set[CommandPoolTrimFlag; Flags]

    CompareOp ¶

    CompareOp :: enum i32 {
    	NEVER            = 0, 
    	LESS             = 1, 
    	EQUAL            = 2, 
    	LESS_OR_EQUAL    = 3, 
    	GREATER          = 4, 
    	NOT_EQUAL        = 5, 
    	GREATER_OR_EQUAL = 6, 
    	ALWAYS           = 7, 
    }

    ComponentSwizzle ¶

    ComponentSwizzle :: enum i32 {
    	IDENTITY = 0, 
    	ZERO     = 1, 
    	ONE      = 2, 
    	R        = 3, 
    	G        = 4, 
    	B        = 5, 
    	A        = 6, 
    }

    ComponentTypeNV ¶

    ComponentTypeNV :: enum i32 {
    	FLOAT16 = 0, 
    	FLOAT32 = 1, 
    	FLOAT64 = 2, 
    	SINT8   = 3, 
    	SINT16  = 4, 
    	SINT32  = 5, 
    	SINT64  = 6, 
    	UINT8   = 7, 
    	UINT16  = 8, 
    	UINT32  = 9, 
    	UINT64  = 10, 
    }

    CompositeAlphaFlagKHR ¶

    CompositeAlphaFlagKHR :: enum Flags {
    	OPAQUE          = 0, 
    	PRE_MULTIPLIED  = 1, 
    	POST_MULTIPLIED = 2, 
    	INHERIT         = 3, 
    }

    CompositeAlphaFlagsKHR ¶

    CompositeAlphaFlagsKHR :: distinct bit_set[CompositeAlphaFlagKHR; Flags]

    ComputePipelineCreateInfo ¶

    ComputePipelineCreateInfo :: struct {
    	sType:              StructureType,
    	pNext:              rawptr,
    	flags:              PipelineCreateFlags,
    	stage:              PipelineShaderStageCreateInfo,
    	layout:             PipelineLayout,
    	basePipelineHandle: Pipeline,
    	basePipelineIndex:  i32,
    }

    ConditionalRenderingBeginInfoEXT ¶

    ConditionalRenderingBeginInfoEXT :: struct {
    	sType:  StructureType,
    	pNext:  rawptr,
    	buffer: Buffer,
    	offset: DeviceSize,
    	flags:  ConditionalRenderingFlagsEXT,
    }

    ConditionalRenderingFlagEXT ¶

    ConditionalRenderingFlagEXT :: enum Flags {
    	INVERTED = 0, 
    }

    ConditionalRenderingFlagsEXT ¶

    ConditionalRenderingFlagsEXT :: distinct bit_set[ConditionalRenderingFlagEXT; Flags]

    ConformanceVersion ¶

    ConformanceVersion :: struct {
    	major:    u8,
    	minor:    u8,
    	subminor: u8,
    	patch:    u8,
    }

    ConservativeRasterizationModeEXT ¶

    ConservativeRasterizationModeEXT :: enum i32 {
    	DISABLED      = 0, 
    	OVERESTIMATE  = 1, 
    	UNDERESTIMATE = 2, 
    }

    CooperativeMatrixPropertiesNV ¶

    CooperativeMatrixPropertiesNV :: struct {
    	sType: StructureType,
    	pNext: rawptr,
    	MSize: u32,
    	NSize: u32,
    	KSize: u32,
    	AType: ComponentTypeNV,
    	BType: ComponentTypeNV,
    	CType: ComponentTypeNV,
    	DType: ComponentTypeNV,
    	scope: ScopeNV,
    }

    CopyAccelerationStructureModeKHR ¶

    CopyAccelerationStructureModeKHR :: enum i32 {
    	CLONE       = 0, 
    	COMPACT     = 1, 
    	SERIALIZE   = 2, 
    	DESERIALIZE = 3, 
    	CLONE_NV    = 0, 
    	COMPACT_NV  = 1, 
    }

    CopyBufferInfo2 ¶

    CopyBufferInfo2 :: struct {
    	sType:       StructureType,
    	pNext:       rawptr,
    	srcBuffer:   Buffer,
    	dstBuffer:   Buffer,
    	regionCount: u32,
    	pRegions:    [^]BufferCopy2,
    }

    CopyBufferToImageInfo2 ¶

    CopyBufferToImageInfo2 :: struct {
    	sType:          StructureType,
    	pNext:          rawptr,
    	srcBuffer:      Buffer,
    	dstImage:       Image,
    	dstImageLayout: ImageLayout,
    	regionCount:    u32,
    	pRegions:       [^]BufferImageCopy2,
    }

    CopyCommandTransformInfoQCOM ¶

    CopyCommandTransformInfoQCOM :: struct {
    	sType:     StructureType,
    	pNext:     rawptr,
    	transform: SurfaceTransformFlagsKHR,
    }

    CopyDescriptorSet ¶

    CopyDescriptorSet :: struct {
    	sType:           StructureType,
    	pNext:           rawptr,
    	srcSet:          DescriptorSet,
    	srcBinding:      u32,
    	srcArrayElement: u32,
    	dstSet:          DescriptorSet,
    	dstBinding:      u32,
    	dstArrayElement: u32,
    	descriptorCount: u32,
    }

    CopyImageInfo2 ¶

    CopyImageInfo2 :: struct {
    	sType:          StructureType,
    	pNext:          rawptr,
    	srcImage:       Image,
    	srcImageLayout: ImageLayout,
    	dstImage:       Image,
    	dstImageLayout: ImageLayout,
    	regionCount:    u32,
    	pRegions:       [^]ImageCopy2,
    }

    CopyImageToBufferInfo2 ¶

    CopyImageToBufferInfo2 :: struct {
    	sType:          StructureType,
    	pNext:          rawptr,
    	srcImage:       Image,
    	srcImageLayout: ImageLayout,
    	dstBuffer:      Buffer,
    	regionCount:    u32,
    	pRegions:       [^]BufferImageCopy2,
    }

    CopyMemoryIndirectCommandNV ¶

    CopyMemoryIndirectCommandNV :: struct {
    	srcAddress: DeviceAddress,
    	dstAddress: DeviceAddress,
    	size:       DeviceSize,
    }

    CopyMemoryToImageIndirectCommandNV ¶

    CopyMemoryToImageIndirectCommandNV :: struct {
    	srcAddress:        DeviceAddress,
    	bufferRowLength:   u32,
    	bufferImageHeight: u32,
    	imageSubresource:  ImageSubresourceLayers,
    	imageOffset:       Offset3D,
    	imageExtent:       Extent3D,
    }

    CopyMemoryToMicromapInfoEXT ¶

    CopyMemoryToMicromapInfoEXT :: struct {
    	sType: StructureType,
    	pNext: rawptr,
    	src:   DeviceOrHostAddressConstKHR,
    	dst:   MicromapEXT,
    	mode:  CopyMicromapModeEXT,
    }

    CopyMicromapInfoEXT ¶

    CopyMicromapInfoEXT :: struct {
    	sType: StructureType,
    	pNext: rawptr,
    	src:   MicromapEXT,
    	dst:   MicromapEXT,
    	mode:  CopyMicromapModeEXT,
    }

    CopyMicromapModeEXT ¶

    CopyMicromapModeEXT :: enum i32 {
    	CLONE       = 0, 
    	SERIALIZE   = 1, 
    	DESERIALIZE = 2, 
    	COMPACT     = 3, 
    }

    CopyMicromapToMemoryInfoEXT ¶

    CopyMicromapToMemoryInfoEXT :: struct {
    	sType: StructureType,
    	pNext: rawptr,
    	src:   MicromapEXT,
    	dst:   DeviceOrHostAddressKHR,
    	mode:  CopyMicromapModeEXT,
    }

    CoverageModulationModeNV ¶

    CoverageModulationModeNV :: enum i32 {
    	NONE  = 0, 
    	RGB   = 1, 
    	ALPHA = 2, 
    	RGBA  = 3, 
    }

    CoverageReductionModeNV ¶

    CoverageReductionModeNV :: enum i32 {
    	MERGE    = 0, 
    	TRUNCATE = 1, 
    }

    CuFunctionCreateInfoNVX ¶

    CuFunctionCreateInfoNVX :: struct {
    	sType:  StructureType,
    	pNext:  rawptr,
    	module: CuModuleNVX,
    	pName:  cstring,
    }

    CuFunctionNVX ¶

    CuFunctionNVX :: distinct u64

    CuLaunchInfoNVX ¶

    CuLaunchInfoNVX :: struct {
    	sType:          StructureType,
    	pNext:          rawptr,
    	function:       CuFunctionNVX,
    	gridDimX:       u32,
    	gridDimY:       u32,
    	gridDimZ:       u32,
    	blockDimX:      u32,
    	blockDimY:      u32,
    	blockDimZ:      u32,
    	sharedMemBytes: u32,
    	paramCount:     int,
    	pParams:        [^]rawptr,
    	extraCount:     int,
    	pExtras:        [^]rawptr,
    }

    CuModuleCreateInfoNVX ¶

    CuModuleCreateInfoNVX :: struct {
    	sType:    StructureType,
    	pNext:    rawptr,
    	dataSize: int,
    	pData:    rawptr,
    }

    CuModuleNVX ¶

    CuModuleNVX :: distinct u64

    CullModeFlag ¶

    CullModeFlag :: enum Flags {
    	FRONT = 0, 
    	BACK  = 1, 
    }

    CullModeFlags ¶

    CullModeFlags :: distinct bit_set[CullModeFlag; Flags]
    Related Constants

    D3D12FenceSubmitInfoKHR ¶

    D3D12FenceSubmitInfoKHR :: struct {
    	sType:                      StructureType,
    	pNext:                      rawptr,
    	waitSemaphoreValuesCount:   u32,
    	pWaitSemaphoreValues:       [^]u64,
    	signalSemaphoreValuesCount: u32,
    	pSignalSemaphoreValues:     [^]u64,
    }

    DWORD ¶

    DWORD :: u32

    DebugMarkerMarkerInfoEXT ¶

    DebugMarkerMarkerInfoEXT :: struct {
    	sType:       StructureType,
    	pNext:       rawptr,
    	pMarkerName: cstring,
    	color:       [4]f32,
    }

    DebugMarkerObjectNameInfoEXT ¶

    DebugMarkerObjectNameInfoEXT :: struct {
    	sType:       StructureType,
    	pNext:       rawptr,
    	objectType:  DebugReportObjectTypeEXT,
    	object:      u64,
    	pObjectName: cstring,
    }

    DebugMarkerObjectTagInfoEXT ¶

    DebugMarkerObjectTagInfoEXT :: struct {
    	sType:      StructureType,
    	pNext:      rawptr,
    	objectType: DebugReportObjectTypeEXT,
    	object:     u64,
    	tagName:    u64,
    	tagSize:    int,
    	pTag:       rawptr,
    }

    DebugReportCallbackCreateInfoEXT ¶

    DebugReportCallbackCreateInfoEXT :: struct {
    	sType:       StructureType,
    	pNext:       rawptr,
    	flags:       DebugReportFlagsEXT,
    	pfnCallback: ProcDebugReportCallbackEXT,
    	pUserData:   rawptr,
    }

    DebugReportCallbackEXT ¶

    DebugReportCallbackEXT :: distinct u64

    DebugReportFlagEXT ¶

    DebugReportFlagEXT :: enum Flags {
    	INFORMATION         = 0, 
    	WARNING             = 1, 
    	PERFORMANCE_WARNING = 2, 
    	ERROR               = 3, 
    	DEBUG               = 4, 
    }

    DebugReportFlagsEXT ¶

    DebugReportFlagsEXT :: distinct bit_set[DebugReportFlagEXT; Flags]

    DebugReportObjectTypeEXT ¶

    DebugReportObjectTypeEXT :: enum i32 {
    	UNKNOWN                        = 0, 
    	INSTANCE                       = 1, 
    	PHYSICAL_DEVICE                = 2, 
    	DEVICE                         = 3, 
    	QUEUE                          = 4, 
    	SEMAPHORE                      = 5, 
    	COMMAND_BUFFER                 = 6, 
    	FENCE                          = 7, 
    	DEVICE_MEMORY                  = 8, 
    	BUFFER                         = 9, 
    	IMAGE                          = 10, 
    	EVENT                          = 11, 
    	QUERY_POOL                     = 12, 
    	BUFFER_VIEW                    = 13, 
    	IMAGE_VIEW                     = 14, 
    	SHADER_MODULE                  = 15, 
    	PIPELINE_CACHE                 = 16, 
    	PIPELINE_LAYOUT                = 17, 
    	RENDER_PASS                    = 18, 
    	PIPELINE                       = 19, 
    	DESCRIPTOR_SET_LAYOUT          = 20, 
    	SAMPLER                        = 21, 
    	DESCRIPTOR_POOL                = 22, 
    	DESCRIPTOR_SET                 = 23, 
    	FRAMEBUFFER                    = 24, 
    	COMMAND_POOL                   = 25, 
    	SURFACE_KHR                    = 26, 
    	SWAPCHAIN_KHR                  = 27, 
    	DEBUG_REPORT_CALLBACK_EXT      = 28, 
    	DISPLAY_KHR                    = 29, 
    	DISPLAY_MODE_KHR               = 30, 
    	VALIDATION_CACHE_EXT           = 33, 
    	SAMPLER_YCBCR_CONVERSION       = 1000156000, 
    	DESCRIPTOR_UPDATE_TEMPLATE     = 1000085000, 
    	CU_MODULE_NVX                  = 1000029000, 
    	CU_FUNCTION_NVX                = 1000029001, 
    	ACCELERATION_STRUCTURE_KHR     = 1000150000, 
    	ACCELERATION_STRUCTURE_NV      = 1000165000, 
    	BUFFER_COLLECTION_FUCHSIA      = 1000366000, 
    	DEBUG_REPORT                   = 28, 
    	VALIDATION_CACHE               = 33, 
    	DESCRIPTOR_UPDATE_TEMPLATE_KHR = 1000085000, 
    	SAMPLER_YCBCR_CONVERSION_KHR   = 1000156000, 
    }

    DebugUtilsLabelEXT ¶

    DebugUtilsLabelEXT :: struct {
    	sType:      StructureType,
    	pNext:      rawptr,
    	pLabelName: cstring,
    	color:      [4]f32,
    }

    DebugUtilsMessageSeverityFlagEXT ¶

    DebugUtilsMessageSeverityFlagEXT :: enum Flags {
    	VERBOSE = 0, 
    	INFO    = 4, 
    	WARNING = 8, 
    	ERROR   = 12, 
    }

    DebugUtilsMessageSeverityFlagsEXT ¶

    DebugUtilsMessageSeverityFlagsEXT :: distinct bit_set[DebugUtilsMessageSeverityFlagEXT; Flags]

    DebugUtilsMessageTypeFlagEXT ¶

    DebugUtilsMessageTypeFlagEXT :: enum Flags {
    	GENERAL                = 0, 
    	VALIDATION             = 1, 
    	PERFORMANCE            = 2, 
    	DEVICE_ADDRESS_BINDING = 3, 
    }

    DebugUtilsMessageTypeFlagsEXT ¶

    DebugUtilsMessageTypeFlagsEXT :: distinct bit_set[DebugUtilsMessageTypeFlagEXT; Flags]

    DebugUtilsMessengerCallbackDataEXT ¶

    DebugUtilsMessengerCallbackDataEXT :: struct {
    	sType:            StructureType,
    	pNext:            rawptr,
    	flags:            DebugUtilsMessengerCallbackDataFlagsEXT,
    	pMessageIdName:   cstring,
    	messageIdNumber:  i32,
    	pMessage:         cstring,
    	queueLabelCount:  u32,
    	pQueueLabels:     [^]DebugUtilsLabelEXT,
    	cmdBufLabelCount: u32,
    	pCmdBufLabels:    [^]DebugUtilsLabelEXT,
    	objectCount:      u32,
    	pObjects:         [^]DebugUtilsObjectNameInfoEXT,
    }

    DebugUtilsMessengerCallbackDataFlagEXT ¶

    DebugUtilsMessengerCallbackDataFlagEXT :: enum u32 {
    }

    DebugUtilsMessengerCallbackDataFlagsEXT ¶

    DebugUtilsMessengerCallbackDataFlagsEXT :: distinct bit_set[DebugUtilsMessengerCallbackDataFlagEXT; Flags]

    DebugUtilsMessengerCreateFlagEXT ¶

    DebugUtilsMessengerCreateFlagEXT :: enum u32 {
    }

    DebugUtilsMessengerCreateFlagsEXT ¶

    DebugUtilsMessengerCreateFlagsEXT :: distinct bit_set[DebugUtilsMessengerCreateFlagEXT; Flags]

    DebugUtilsMessengerCreateInfoEXT ¶

    DebugUtilsMessengerCreateInfoEXT :: struct {
    	sType:           StructureType,
    	pNext:           rawptr,
    	flags:           DebugUtilsMessengerCreateFlagsEXT,
    	messageSeverity: DebugUtilsMessageSeverityFlagsEXT,
    	messageType:     DebugUtilsMessageTypeFlagsEXT,
    	pfnUserCallback: ProcDebugUtilsMessengerCallbackEXT,
    	pUserData:       rawptr,
    }

    DebugUtilsMessengerEXT ¶

    DebugUtilsMessengerEXT :: distinct u64

    DebugUtilsObjectNameInfoEXT ¶

    DebugUtilsObjectNameInfoEXT :: struct {
    	sType:        StructureType,
    	pNext:        rawptr,
    	objectType:   ObjectType,
    	objectHandle: u64,
    	pObjectName:  cstring,
    }

    DebugUtilsObjectTagInfoEXT ¶

    DebugUtilsObjectTagInfoEXT :: struct {
    	sType:        StructureType,
    	pNext:        rawptr,
    	objectType:   ObjectType,
    	objectHandle: u64,
    	tagName:      u64,
    	tagSize:      int,
    	pTag:         rawptr,
    }

    DecompressMemoryRegionNV ¶

    DecompressMemoryRegionNV :: struct {
    	srcAddress:          DeviceAddress,
    	dstAddress:          DeviceAddress,
    	compressedSize:      DeviceSize,
    	decompressedSize:    DeviceSize,
    	decompressionMethod: Flags64,
    }

    DedicatedAllocationBufferCreateInfoNV ¶

    DedicatedAllocationBufferCreateInfoNV :: struct {
    	sType:               StructureType,
    	pNext:               rawptr,
    	dedicatedAllocation: b32,
    }

    DedicatedAllocationImageCreateInfoNV ¶

    DedicatedAllocationImageCreateInfoNV :: struct {
    	sType:               StructureType,
    	pNext:               rawptr,
    	dedicatedAllocation: b32,
    }

    DedicatedAllocationMemoryAllocateInfoNV ¶

    DedicatedAllocationMemoryAllocateInfoNV :: struct {
    	sType:  StructureType,
    	pNext:  rawptr,
    	image:  Image,
    	buffer: Buffer,
    }

    DeferredOperationKHR ¶

    DeferredOperationKHR :: distinct u64

    DependencyFlag ¶

    DependencyFlag :: enum Flags {
    	BY_REGION         = 0, 
    	DEVICE_GROUP      = 2, 
    	VIEW_LOCAL        = 1, 
    	FEEDBACK_LOOP_EXT = 3, 
    	VIEW_LOCAL_KHR    = 1, 
    	DEVICE_GROUP_KHR  = 2, 
    }

    DependencyFlags ¶

    DependencyFlags :: distinct bit_set[DependencyFlag; Flags]

    DependencyInfo ¶

    DependencyInfo :: struct {
    	sType:                    StructureType,
    	pNext:                    rawptr,
    	dependencyFlags:          DependencyFlags,
    	memoryBarrierCount:       u32,
    	pMemoryBarriers:          [^]MemoryBarrier2,
    	bufferMemoryBarrierCount: u32,
    	pBufferMemoryBarriers:    [^]BufferMemoryBarrier2,
    	imageMemoryBarrierCount:  u32,
    	pImageMemoryBarriers:     [^]ImageMemoryBarrier2,
    }

    DescriptorAddressInfoEXT ¶

    DescriptorAddressInfoEXT :: struct {
    	sType:   StructureType,
    	pNext:   rawptr,
    	address: DeviceAddress,
    	range:   DeviceSize,
    	format:  Format,
    }

    DescriptorBindingFlag ¶

    DescriptorBindingFlag :: enum Flags {
    	UPDATE_AFTER_BIND               = 0, 
    	UPDATE_UNUSED_WHILE_PENDING     = 1, 
    	PARTIALLY_BOUND                 = 2, 
    	VARIABLE_DESCRIPTOR_COUNT       = 3, 
    	UPDATE_AFTER_BIND_EXT           = 0, 
    	UPDATE_UNUSED_WHILE_PENDING_EXT = 1, 
    	PARTIALLY_BOUND_EXT             = 2, 
    	VARIABLE_DESCRIPTOR_COUNT_EXT   = 3, 
    }

    DescriptorBindingFlags ¶

    DescriptorBindingFlags :: distinct bit_set[DescriptorBindingFlag; Flags]

    DescriptorBufferBindingInfoEXT ¶

    DescriptorBufferBindingInfoEXT :: struct {
    	sType:   StructureType,
    	pNext:   rawptr,
    	address: DeviceAddress,
    	usage:   BufferUsageFlags,
    }

    DescriptorBufferBindingPushDescriptorBufferHandleEXT ¶

    DescriptorBufferBindingPushDescriptorBufferHandleEXT :: struct {
    	sType:  StructureType,
    	pNext:  rawptr,
    	buffer: Buffer,
    }

    DescriptorBufferInfo ¶

    DescriptorBufferInfo :: struct {
    	buffer: Buffer,
    	offset: DeviceSize,
    	range:  DeviceSize,
    }

    DescriptorDataEXT ¶

    DescriptorDataEXT :: struct #raw_union {
    	pSampler:              ^Sampler,
    	pCombinedImageSampler: ^DescriptorImageInfo,
    	pInputAttachmentImage: ^DescriptorImageInfo,
    	pSampledImage:         ^DescriptorImageInfo,
    	pStorageImage:         ^DescriptorImageInfo,
    	pUniformTexelBuffer:   ^DescriptorAddressInfoEXT,
    	pStorageTexelBuffer:   ^DescriptorAddressInfoEXT,
    	pUniformBuffer:        ^DescriptorAddressInfoEXT,
    	pStorageBuffer:        ^DescriptorAddressInfoEXT,
    	accelerationStructure: DeviceAddress,
    }

    DescriptorGetInfoEXT ¶

    DescriptorGetInfoEXT :: struct {
    	sType: StructureType,
    	pNext: rawptr,
    	type:  DescriptorType,
    	data:  DescriptorDataEXT,
    }

    DescriptorImageInfo ¶

    DescriptorImageInfo :: struct {
    	sampler:     Sampler,
    	imageView:   ImageView,
    	imageLayout: ImageLayout,
    }

    DescriptorPool ¶

    DescriptorPool :: distinct u64

    DescriptorPoolCreateFlag ¶

    DescriptorPoolCreateFlag :: enum Flags {
    	FREE_DESCRIPTOR_SET   = 0, 
    	UPDATE_AFTER_BIND     = 1, 
    	HOST_ONLY_EXT         = 2, 
    	UPDATE_AFTER_BIND_EXT = 1, 
    	HOST_ONLY_VALVE       = 2, 
    }

    DescriptorPoolCreateFlags ¶

    DescriptorPoolCreateFlags :: distinct bit_set[DescriptorPoolCreateFlag; Flags]

    DescriptorPoolCreateInfo ¶

    DescriptorPoolCreateInfo :: struct {
    	sType:         StructureType,
    	pNext:         rawptr,
    	flags:         DescriptorPoolCreateFlags,
    	maxSets:       u32,
    	poolSizeCount: u32,
    	pPoolSizes:    [^]DescriptorPoolSize,
    }

    DescriptorPoolInlineUniformBlockCreateInfo ¶

    DescriptorPoolInlineUniformBlockCreateInfo :: struct {
    	sType:                         StructureType,
    	pNext:                         rawptr,
    	maxInlineUniformBlockBindings: u32,
    }

    DescriptorPoolResetFlag ¶

    DescriptorPoolResetFlag :: enum u32 {
    }

    DescriptorPoolResetFlags ¶

    DescriptorPoolResetFlags :: distinct bit_set[DescriptorPoolResetFlag; Flags]

    DescriptorPoolSize ¶

    DescriptorPoolSize :: struct {
    	type:            DescriptorType,
    	descriptorCount: u32,
    }

    DescriptorSet ¶

    DescriptorSet :: distinct u64

    DescriptorSetAllocateInfo ¶

    DescriptorSetAllocateInfo :: struct {
    	sType:              StructureType,
    	pNext:              rawptr,
    	descriptorPool:     DescriptorPool,
    	descriptorSetCount: u32,
    	pSetLayouts:        [^]DescriptorSetLayout,
    }

    DescriptorSetBindingReferenceVALVE ¶

    DescriptorSetBindingReferenceVALVE :: struct {
    	sType:               StructureType,
    	pNext:               rawptr,
    	descriptorSetLayout: DescriptorSetLayout,
    	binding:             u32,
    }

    DescriptorSetLayout ¶

    DescriptorSetLayout :: distinct u64

    DescriptorSetLayoutBinding ¶

    DescriptorSetLayoutBinding :: struct {
    	binding:            u32,
    	descriptorType:     DescriptorType,
    	descriptorCount:    u32,
    	stageFlags:         ShaderStageFlags,
    	pImmutableSamplers: [^]Sampler,
    }

    DescriptorSetLayoutBindingFlagsCreateInfo ¶

    DescriptorSetLayoutBindingFlagsCreateInfo :: struct {
    	sType:         StructureType,
    	pNext:         rawptr,
    	bindingCount:  u32,
    	pBindingFlags: [^]DescriptorBindingFlags,
    }

    DescriptorSetLayoutCreateFlag ¶

    DescriptorSetLayoutCreateFlag :: enum Flags {
    	UPDATE_AFTER_BIND_POOL          = 1, 
    	PUSH_DESCRIPTOR_KHR             = 0, 
    	DESCRIPTOR_BUFFER_EXT           = 4, 
    	EMBEDDED_IMMUTABLE_SAMPLERS_EXT = 5, 
    	HOST_ONLY_POOL_EXT              = 2, 
    	UPDATE_AFTER_BIND_POOL_EXT      = 1, 
    	HOST_ONLY_POOL_VALVE            = 2, 
    }

    DescriptorSetLayoutCreateFlags ¶

    DescriptorSetLayoutCreateFlags :: distinct bit_set[DescriptorSetLayoutCreateFlag; Flags]

    DescriptorSetLayoutCreateInfo ¶

    DescriptorSetLayoutCreateInfo :: struct {
    	sType:        StructureType,
    	pNext:        rawptr,
    	flags:        DescriptorSetLayoutCreateFlags,
    	bindingCount: u32,
    	pBindings:    [^]DescriptorSetLayoutBinding,
    }

    DescriptorSetLayoutHostMappingInfoVALVE ¶

    DescriptorSetLayoutHostMappingInfoVALVE :: struct {
    	sType:            StructureType,
    	pNext:            rawptr,
    	descriptorOffset: int,
    	descriptorSize:   u32,
    }

    DescriptorSetLayoutSupport ¶

    DescriptorSetLayoutSupport :: struct {
    	sType:     StructureType,
    	pNext:     rawptr,
    	supported: b32,
    }

    DescriptorSetVariableDescriptorCountAllocateInfo ¶

    DescriptorSetVariableDescriptorCountAllocateInfo :: struct {
    	sType:              StructureType,
    	pNext:              rawptr,
    	descriptorSetCount: u32,
    	pDescriptorCounts:  [^]u32,
    }

    DescriptorSetVariableDescriptorCountLayoutSupport ¶

    DescriptorSetVariableDescriptorCountLayoutSupport :: struct {
    	sType:                      StructureType,
    	pNext:                      rawptr,
    	maxVariableDescriptorCount: u32,
    }

    DescriptorType ¶

    DescriptorType :: enum i32 {
    	SAMPLER                    = 0, 
    	COMBINED_IMAGE_SAMPLER     = 1, 
    	SAMPLED_IMAGE              = 2, 
    	STORAGE_IMAGE              = 3, 
    	UNIFORM_TEXEL_BUFFER       = 4, 
    	STORAGE_TEXEL_BUFFER       = 5, 
    	UNIFORM_BUFFER             = 6, 
    	STORAGE_BUFFER             = 7, 
    	UNIFORM_BUFFER_DYNAMIC     = 8, 
    	STORAGE_BUFFER_DYNAMIC     = 9, 
    	INPUT_ATTACHMENT           = 10, 
    	INLINE_UNIFORM_BLOCK       = 1000138000, 
    	ACCELERATION_STRUCTURE_KHR = 1000150000, 
    	ACCELERATION_STRUCTURE_NV  = 1000165000, 
    	SAMPLE_WEIGHT_IMAGE_QCOM   = 1000440000, 
    	BLOCK_MATCH_IMAGE_QCOM     = 1000440001, 
    	MUTABLE_EXT                = 1000351000, 
    	INLINE_UNIFORM_BLOCK_EXT   = 1000138000, 
    	MUTABLE_VALVE              = 1000351000, 
    }

    DescriptorUpdateTemplate ¶

    DescriptorUpdateTemplate :: distinct u64

    DescriptorUpdateTemplateCreateFlag ¶

    DescriptorUpdateTemplateCreateFlag :: enum u32 {
    }

    DescriptorUpdateTemplateCreateFlags ¶

    DescriptorUpdateTemplateCreateFlags :: distinct bit_set[DescriptorUpdateTemplateCreateFlag; Flags]

    DescriptorUpdateTemplateCreateInfo ¶

    DescriptorUpdateTemplateCreateInfo :: struct {
    	sType:                      StructureType,
    	pNext:                      rawptr,
    	flags:                      DescriptorUpdateTemplateCreateFlags,
    	descriptorUpdateEntryCount: u32,
    	pDescriptorUpdateEntries:   [^]DescriptorUpdateTemplateEntry,
    	templateType:               DescriptorUpdateTemplateType,
    	descriptorSetLayout:        DescriptorSetLayout,
    	pipelineBindPoint:          PipelineBindPoint,
    	pipelineLayout:             PipelineLayout,
    	set:                        u32,
    }

    DescriptorUpdateTemplateEntry ¶

    DescriptorUpdateTemplateEntry :: struct {
    	dstBinding:      u32,
    	dstArrayElement: u32,
    	descriptorCount: u32,
    	descriptorType:  DescriptorType,
    	offset:          int,
    	stride:          int,
    }

    DescriptorUpdateTemplateType ¶

    DescriptorUpdateTemplateType :: enum i32 {
    	DESCRIPTOR_SET       = 0, 
    	PUSH_DESCRIPTORS_KHR = 1, 
    	DESCRIPTOR_SET_KHR   = 0, 
    }

    Device ¶

    Device :: distinct rawptr
    Related Procedures With Parameters

    DeviceAddress ¶

    DeviceAddress :: distinct u64

    DeviceAddressBindingCallbackDataEXT ¶

    DeviceAddressBindingCallbackDataEXT :: struct {
    	sType:       StructureType,
    	pNext:       rawptr,
    	flags:       DeviceAddressBindingFlagsEXT,
    	baseAddress: DeviceAddress,
    	size:        DeviceSize,
    	bindingType: DeviceAddressBindingTypeEXT,
    }

    DeviceAddressBindingFlagEXT ¶

    DeviceAddressBindingFlagEXT :: enum Flags {
    	INTERNAL_OBJECT = 0, 
    }

    DeviceAddressBindingFlagsEXT ¶

    DeviceAddressBindingFlagsEXT :: distinct bit_set[DeviceAddressBindingFlagEXT; Flags]

    DeviceAddressBindingTypeEXT ¶

    DeviceAddressBindingTypeEXT :: enum i32 {
    	BIND   = 0, 
    	UNBIND = 1, 
    }

    DeviceBufferMemoryRequirements ¶

    DeviceBufferMemoryRequirements :: struct {
    	sType:       StructureType,
    	pNext:       rawptr,
    	pCreateInfo: ^BufferCreateInfo,
    }

    DeviceCreateFlag ¶

    DeviceCreateFlag :: enum u32 {
    }

    DeviceCreateFlags ¶

    DeviceCreateFlags :: distinct bit_set[DeviceCreateFlag; Flags]

    DeviceCreateInfo ¶

    DeviceCreateInfo :: struct {
    	sType:                   StructureType,
    	pNext:                   rawptr,
    	flags:                   DeviceCreateFlags,
    	queueCreateInfoCount:    u32,
    	pQueueCreateInfos:       [^]DeviceQueueCreateInfo,
    	enabledLayerCount:       u32,
    	ppEnabledLayerNames:     [^]cstring,
    	enabledExtensionCount:   u32,
    	ppEnabledExtensionNames: [^]cstring,
    	pEnabledFeatures:        [^]PhysicalDeviceFeatures,
    }

    DeviceDeviceMemoryReportCreateInfoEXT ¶

    DeviceDeviceMemoryReportCreateInfoEXT :: struct {
    	sType:           StructureType,
    	pNext:           rawptr,
    	flags:           DeviceMemoryReportFlagsEXT,
    	pfnUserCallback: ProcDeviceMemoryReportCallbackEXT,
    	pUserData:       rawptr,
    }

    DeviceDiagnosticsConfigCreateInfoNV ¶

    DeviceDiagnosticsConfigCreateInfoNV :: struct {
    	sType: StructureType,
    	pNext: rawptr,
    	flags: DeviceDiagnosticsConfigFlagsNV,
    }

    DeviceDiagnosticsConfigFlagNV ¶

    DeviceDiagnosticsConfigFlagNV :: enum Flags {
    	ENABLE_SHADER_DEBUG_INFO      = 0, 
    	ENABLE_RESOURCE_TRACKING      = 1, 
    	ENABLE_AUTOMATIC_CHECKPOINTS  = 2, 
    	ENABLE_SHADER_ERROR_REPORTING = 3, 
    }

    DeviceDiagnosticsConfigFlagsNV ¶

    DeviceDiagnosticsConfigFlagsNV :: distinct bit_set[DeviceDiagnosticsConfigFlagNV; Flags]

    DeviceEventInfoEXT ¶

    DeviceEventInfoEXT :: struct {
    	sType:       StructureType,
    	pNext:       rawptr,
    	deviceEvent: DeviceEventTypeEXT,
    }

    DeviceEventTypeEXT ¶

    DeviceEventTypeEXT :: enum i32 {
    	DISPLAY_HOTPLUG = 0, 
    }

    DeviceFaultAddressInfoEXT ¶

    DeviceFaultAddressInfoEXT :: struct {
    	addressType:      DeviceFaultAddressTypeEXT,
    	reportedAddress:  DeviceAddress,
    	addressPrecision: DeviceSize,
    }

    DeviceFaultAddressTypeEXT ¶

    DeviceFaultAddressTypeEXT :: enum i32 {
    	NONE                        = 0, 
    	READ_INVALID                = 1, 
    	WRITE_INVALID               = 2, 
    	EXECUTE_INVALID             = 3, 
    	INSTRUCTION_POINTER_UNKNOWN = 4, 
    	INSTRUCTION_POINTER_INVALID = 5, 
    	INSTRUCTION_POINTER_FAULT   = 6, 
    }

    DeviceFaultCountsEXT ¶

    DeviceFaultCountsEXT :: struct {
    	sType:            StructureType,
    	pNext:            rawptr,
    	addressInfoCount: u32,
    	vendorInfoCount:  u32,
    	vendorBinarySize: DeviceSize,
    }

    DeviceFaultInfoEXT ¶

    DeviceFaultInfoEXT :: struct {
    	sType:             StructureType,
    	pNext:             rawptr,
    	description:       [256]u8,
    	pAddressInfos:     [^]DeviceFaultAddressInfoEXT,
    	pVendorInfos:      [^]DeviceFaultVendorInfoEXT,
    	pVendorBinaryData: rawptr,
    }

    DeviceFaultVendorBinaryHeaderVersionEXT ¶

    DeviceFaultVendorBinaryHeaderVersionEXT :: enum i32 {
    	ONE = 1, 
    }

    DeviceFaultVendorBinaryHeaderVersionOneEXT ¶

    DeviceFaultVendorBinaryHeaderVersionOneEXT :: struct {
    	headerSize:            u32,
    	headerVersion:         DeviceFaultVendorBinaryHeaderVersionEXT,
    	vendorID:              u32,
    	deviceID:              u32,
    	driverVersion:         u32,
    	pipelineCacheUUID:     [16]u8,
    	applicationNameOffset: u32,
    	applicationVersion:    u32,
    	engineNameOffset:      u32,
    	engineVersion:         u32,
    	apiVersion:            u32,
    }

    DeviceFaultVendorInfoEXT ¶

    DeviceFaultVendorInfoEXT :: struct {
    	description:     [256]u8,
    	vendorFaultCode: u64,
    	vendorFaultData: u64,
    }

    DeviceGroupBindSparseInfo ¶

    DeviceGroupBindSparseInfo :: struct {
    	sType:               StructureType,
    	pNext:               rawptr,
    	resourceDeviceIndex: u32,
    	memoryDeviceIndex:   u32,
    }

    DeviceGroupCommandBufferBeginInfo ¶

    DeviceGroupCommandBufferBeginInfo :: struct {
    	sType:      StructureType,
    	pNext:      rawptr,
    	deviceMask: u32,
    }

    DeviceGroupDeviceCreateInfo ¶

    DeviceGroupDeviceCreateInfo :: struct {
    	sType:               StructureType,
    	pNext:               rawptr,
    	physicalDeviceCount: u32,
    	pPhysicalDevices:    [^]PhysicalDevice,
    }

    DeviceGroupPresentCapabilitiesKHR ¶

    DeviceGroupPresentCapabilitiesKHR :: struct {
    	sType:       StructureType,
    	pNext:       rawptr,
    	presentMask: [32]u32,
    	modes:       DeviceGroupPresentModeFlagsKHR,
    }

    DeviceGroupPresentInfoKHR ¶

    DeviceGroupPresentInfoKHR :: struct {
    	sType:          StructureType,
    	pNext:          rawptr,
    	swapchainCount: u32,
    	pDeviceMasks:   [^]u32,
    	mode:           DeviceGroupPresentModeFlagsKHR,
    }

    DeviceGroupPresentModeFlagKHR ¶

    DeviceGroupPresentModeFlagKHR :: enum Flags {
    	LOCAL              = 0, 
    	REMOTE             = 1, 
    	SUM                = 2, 
    	LOCAL_MULTI_DEVICE = 3, 
    }

    DeviceGroupPresentModeFlagsKHR ¶

    DeviceGroupPresentModeFlagsKHR :: distinct bit_set[DeviceGroupPresentModeFlagKHR; Flags]

    DeviceGroupRenderPassBeginInfo ¶

    DeviceGroupRenderPassBeginInfo :: struct {
    	sType:                 StructureType,
    	pNext:                 rawptr,
    	deviceMask:            u32,
    	deviceRenderAreaCount: u32,
    	pDeviceRenderAreas:    [^]Rect2D,
    }

    DeviceGroupSubmitInfo ¶

    DeviceGroupSubmitInfo :: struct {
    	sType:                         StructureType,
    	pNext:                         rawptr,
    	waitSemaphoreCount:            u32,
    	pWaitSemaphoreDeviceIndices:   [^]u32,
    	commandBufferCount:            u32,
    	pCommandBufferDeviceMasks:     [^]u32,
    	signalSemaphoreCount:          u32,
    	pSignalSemaphoreDeviceIndices: [^]u32,
    }

    DeviceGroupSwapchainCreateInfoKHR ¶

    DeviceGroupSwapchainCreateInfoKHR :: struct {
    	sType: StructureType,
    	pNext: rawptr,
    	modes: DeviceGroupPresentModeFlagsKHR,
    }

    DeviceImageMemoryRequirements ¶

    DeviceImageMemoryRequirements :: struct {
    	sType:       StructureType,
    	pNext:       rawptr,
    	pCreateInfo: ^ImageCreateInfo,
    	planeAspect: ImageAspectFlags,
    }

    DeviceMemory ¶

    DeviceMemory :: distinct u64

    DeviceMemoryOpaqueCaptureAddressInfo ¶

    DeviceMemoryOpaqueCaptureAddressInfo :: struct {
    	sType:  StructureType,
    	pNext:  rawptr,
    	memory: DeviceMemory,
    }

    DeviceMemoryOverallocationCreateInfoAMD ¶

    DeviceMemoryOverallocationCreateInfoAMD :: struct {
    	sType:                  StructureType,
    	pNext:                  rawptr,
    	overallocationBehavior: MemoryOverallocationBehaviorAMD,
    }

    DeviceMemoryReportCallbackDataEXT ¶

    DeviceMemoryReportCallbackDataEXT :: struct {
    	sType:          StructureType,
    	pNext:          rawptr,
    	flags:          DeviceMemoryReportFlagsEXT,
    	type:           DeviceMemoryReportEventTypeEXT,
    	memoryObjectId: u64,
    	size:           DeviceSize,
    	objectType:     ObjectType,
    	objectHandle:   u64,
    	heapIndex:      u32,
    }

    DeviceMemoryReportEventTypeEXT ¶

    DeviceMemoryReportEventTypeEXT :: enum i32 {
    	ALLOCATE          = 0, 
    	FREE              = 1, 
    	IMPORT            = 2, 
    	UNIMPORT          = 3, 
    	ALLOCATION_FAILED = 4, 
    }

    DeviceMemoryReportFlagEXT ¶

    DeviceMemoryReportFlagEXT :: enum u32 {
    }

    DeviceMemoryReportFlagsEXT ¶

    DeviceMemoryReportFlagsEXT :: distinct bit_set[DeviceMemoryReportFlagEXT; Flags]

    DeviceOrHostAddressConstKHR ¶

    DeviceOrHostAddressConstKHR :: struct #raw_union {
    	deviceAddress: DeviceAddress,
    	hostAddress:   rawptr,
    }

    DeviceOrHostAddressKHR ¶

    DeviceOrHostAddressKHR :: struct #raw_union {
    	deviceAddress: DeviceAddress,
    	hostAddress:   rawptr,
    }

    DevicePrivateDataCreateInfo ¶

    DevicePrivateDataCreateInfo :: struct {
    	sType:                       StructureType,
    	pNext:                       rawptr,
    	privateDataSlotRequestCount: u32,
    }

    DeviceQueueCreateFlag ¶

    DeviceQueueCreateFlag :: enum Flags {
    	PROTECTED = 0, 
    }

    DeviceQueueCreateFlags ¶

    DeviceQueueCreateFlags :: distinct bit_set[DeviceQueueCreateFlag; Flags]

    DeviceQueueCreateInfo ¶

    DeviceQueueCreateInfo :: struct {
    	sType:            StructureType,
    	pNext:            rawptr,
    	flags:            DeviceQueueCreateFlags,
    	queueFamilyIndex: u32,
    	queueCount:       u32,
    	pQueuePriorities: [^]f32,
    }

    DeviceQueueGlobalPriorityCreateInfoKHR ¶

    DeviceQueueGlobalPriorityCreateInfoKHR :: struct {
    	sType:          StructureType,
    	pNext:          rawptr,
    	globalPriority: QueueGlobalPriorityKHR,
    }

    DeviceQueueInfo2 ¶

    DeviceQueueInfo2 :: struct {
    	sType:            StructureType,
    	pNext:            rawptr,
    	flags:            DeviceQueueCreateFlags,
    	queueFamilyIndex: u32,
    	queueIndex:       u32,
    }

    DeviceSize ¶

    DeviceSize :: distinct u64

    Device_VTable ¶

    Device_VTable :: struct {
    	AcquireFullScreenExclusiveModeEXT:                      ProcAcquireFullScreenExclusiveModeEXT,
    	AcquireNextImage2KHR:                                   ProcAcquireNextImage2KHR,
    	AcquireNextImageKHR:                                    ProcAcquireNextImageKHR,
    	AcquirePerformanceConfigurationINTEL:                   ProcAcquirePerformanceConfigurationINTEL,
    	AcquireProfilingLockKHR:                                ProcAcquireProfilingLockKHR,
    	AllocateCommandBuffers:                                 ProcAllocateCommandBuffers,
    	AllocateDescriptorSets:                                 ProcAllocateDescriptorSets,
    	AllocateMemory:                                         ProcAllocateMemory,
    	BeginCommandBuffer:                                     ProcBeginCommandBuffer,
    	BindAccelerationStructureMemoryNV:                      ProcBindAccelerationStructureMemoryNV,
    	BindBufferMemory:                                       ProcBindBufferMemory,
    	BindBufferMemory2:                                      ProcBindBufferMemory2,
    	BindBufferMemory2KHR:                                   ProcBindBufferMemory2KHR,
    	BindImageMemory:                                        ProcBindImageMemory,
    	BindImageMemory2:                                       ProcBindImageMemory2,
    	BindImageMemory2KHR:                                    ProcBindImageMemory2KHR,
    	BindOpticalFlowSessionImageNV:                          ProcBindOpticalFlowSessionImageNV,
    	BindVideoSessionMemoryKHR:                              ProcBindVideoSessionMemoryKHR,
    	BuildAccelerationStructuresKHR:                         ProcBuildAccelerationStructuresKHR,
    	BuildMicromapsEXT:                                      ProcBuildMicromapsEXT,
    	CmdBeginConditionalRenderingEXT:                        ProcCmdBeginConditionalRenderingEXT,
    	CmdBeginDebugUtilsLabelEXT:                             ProcCmdBeginDebugUtilsLabelEXT,
    	CmdBeginQuery:                                          ProcCmdBeginQuery,
    	CmdBeginQueryIndexedEXT:                                ProcCmdBeginQueryIndexedEXT,
    	CmdBeginRenderPass:                                     ProcCmdBeginRenderPass,
    	CmdBeginRenderPass2:                                    ProcCmdBeginRenderPass2,
    	CmdBeginRenderPass2KHR:                                 ProcCmdBeginRenderPass2KHR,
    	CmdBeginRendering:                                      ProcCmdBeginRendering,
    	CmdBeginRenderingKHR:                                   ProcCmdBeginRenderingKHR,
    	CmdBeginTransformFeedbackEXT:                           ProcCmdBeginTransformFeedbackEXT,
    	CmdBeginVideoCodingKHR:                                 ProcCmdBeginVideoCodingKHR,
    	CmdBindDescriptorBufferEmbeddedSamplersEXT:             ProcCmdBindDescriptorBufferEmbeddedSamplersEXT,
    	CmdBindDescriptorBuffersEXT:                            ProcCmdBindDescriptorBuffersEXT,
    	CmdBindDescriptorSets:                                  ProcCmdBindDescriptorSets,
    	CmdBindIndexBuffer:                                     ProcCmdBindIndexBuffer,
    	CmdBindInvocationMaskHUAWEI:                            ProcCmdBindInvocationMaskHUAWEI,
    	CmdBindPipeline:                                        ProcCmdBindPipeline,
    	CmdBindPipelineShaderGroupNV:                           ProcCmdBindPipelineShaderGroupNV,
    	CmdBindShadersEXT:                                      ProcCmdBindShadersEXT,
    	CmdBindShadingRateImageNV:                              ProcCmdBindShadingRateImageNV,
    	CmdBindTransformFeedbackBuffersEXT:                     ProcCmdBindTransformFeedbackBuffersEXT,
    	CmdBindVertexBuffers:                                   ProcCmdBindVertexBuffers,
    	CmdBindVertexBuffers2:                                  ProcCmdBindVertexBuffers2,
    	CmdBindVertexBuffers2EXT:                               ProcCmdBindVertexBuffers2EXT,
    	CmdBlitImage:                                           ProcCmdBlitImage,
    	CmdBlitImage2:                                          ProcCmdBlitImage2,
    	CmdBlitImage2KHR:                                       ProcCmdBlitImage2KHR,
    	CmdBuildAccelerationStructureNV:                        ProcCmdBuildAccelerationStructureNV,
    	CmdBuildAccelerationStructuresIndirectKHR:              ProcCmdBuildAccelerationStructuresIndirectKHR,
    	CmdBuildAccelerationStructuresKHR:                      ProcCmdBuildAccelerationStructuresKHR,
    	CmdBuildMicromapsEXT:                                   ProcCmdBuildMicromapsEXT,
    	CmdClearAttachments:                                    ProcCmdClearAttachments,
    	CmdClearColorImage:                                     ProcCmdClearColorImage,
    	CmdClearDepthStencilImage:                              ProcCmdClearDepthStencilImage,
    	CmdControlVideoCodingKHR:                               ProcCmdControlVideoCodingKHR,
    	CmdCopyAccelerationStructureKHR:                        ProcCmdCopyAccelerationStructureKHR,
    	CmdCopyAccelerationStructureNV:                         ProcCmdCopyAccelerationStructureNV,
    	CmdCopyAccelerationStructureToMemoryKHR:                ProcCmdCopyAccelerationStructureToMemoryKHR,
    	CmdCopyBuffer:                                          ProcCmdCopyBuffer,
    	CmdCopyBuffer2:                                         ProcCmdCopyBuffer2,
    	CmdCopyBuffer2KHR:                                      ProcCmdCopyBuffer2KHR,
    	CmdCopyBufferToImage:                                   ProcCmdCopyBufferToImage,
    	CmdCopyBufferToImage2:                                  ProcCmdCopyBufferToImage2,
    	CmdCopyBufferToImage2KHR:                               ProcCmdCopyBufferToImage2KHR,
    	CmdCopyImage:                                           ProcCmdCopyImage,
    	CmdCopyImage2:                                          ProcCmdCopyImage2,
    	CmdCopyImage2KHR:                                       ProcCmdCopyImage2KHR,
    	CmdCopyImageToBuffer:                                   ProcCmdCopyImageToBuffer,
    	CmdCopyImageToBuffer2:                                  ProcCmdCopyImageToBuffer2,
    	CmdCopyImageToBuffer2KHR:                               ProcCmdCopyImageToBuffer2KHR,
    	CmdCopyMemoryIndirectNV:                                ProcCmdCopyMemoryIndirectNV,
    	CmdCopyMemoryToAccelerationStructureKHR:                ProcCmdCopyMemoryToAccelerationStructureKHR,
    	CmdCopyMemoryToImageIndirectNV:                         ProcCmdCopyMemoryToImageIndirectNV,
    	CmdCopyMemoryToMicromapEXT:                             ProcCmdCopyMemoryToMicromapEXT,
    	CmdCopyMicromapEXT:                                     ProcCmdCopyMicromapEXT,
    	CmdCopyMicromapToMemoryEXT:                             ProcCmdCopyMicromapToMemoryEXT,
    	CmdCopyQueryPoolResults:                                ProcCmdCopyQueryPoolResults,
    	CmdCuLaunchKernelNVX:                                   ProcCmdCuLaunchKernelNVX,
    	CmdDebugMarkerBeginEXT:                                 ProcCmdDebugMarkerBeginEXT,
    	CmdDebugMarkerEndEXT:                                   ProcCmdDebugMarkerEndEXT,
    	CmdDebugMarkerInsertEXT:                                ProcCmdDebugMarkerInsertEXT,
    	CmdDecodeVideoKHR:                                      ProcCmdDecodeVideoKHR,
    	CmdDecompressMemoryIndirectCountNV:                     ProcCmdDecompressMemoryIndirectCountNV,
    	CmdDecompressMemoryNV:                                  ProcCmdDecompressMemoryNV,
    	CmdDispatch:                                            ProcCmdDispatch,
    	CmdDispatchBase:                                        ProcCmdDispatchBase,
    	CmdDispatchBaseKHR:                                     ProcCmdDispatchBaseKHR,
    	CmdDispatchIndirect:                                    ProcCmdDispatchIndirect,
    	CmdDraw:                                                ProcCmdDraw,
    	CmdDrawClusterHUAWEI:                                   ProcCmdDrawClusterHUAWEI,
    	CmdDrawClusterIndirectHUAWEI:                           ProcCmdDrawClusterIndirectHUAWEI,
    	CmdDrawIndexed:                                         ProcCmdDrawIndexed,
    	CmdDrawIndexedIndirect:                                 ProcCmdDrawIndexedIndirect,
    	CmdDrawIndexedIndirectCount:                            ProcCmdDrawIndexedIndirectCount,
    	CmdDrawIndexedIndirectCountAMD:                         ProcCmdDrawIndexedIndirectCountAMD,
    	CmdDrawIndexedIndirectCountKHR:                         ProcCmdDrawIndexedIndirectCountKHR,
    	CmdDrawIndirect:                                        ProcCmdDrawIndirect,
    	CmdDrawIndirectByteCountEXT:                            ProcCmdDrawIndirectByteCountEXT,
    	CmdDrawIndirectCount:                                   ProcCmdDrawIndirectCount,
    	CmdDrawIndirectCountAMD:                                ProcCmdDrawIndirectCountAMD,
    	CmdDrawIndirectCountKHR:                                ProcCmdDrawIndirectCountKHR,
    	CmdDrawMeshTasksEXT:                                    ProcCmdDrawMeshTasksEXT,
    	CmdDrawMeshTasksIndirectCountEXT:                       ProcCmdDrawMeshTasksIndirectCountEXT,
    	CmdDrawMeshTasksIndirectCountNV:                        ProcCmdDrawMeshTasksIndirectCountNV,
    	CmdDrawMeshTasksIndirectEXT:                            ProcCmdDrawMeshTasksIndirectEXT,
    	CmdDrawMeshTasksIndirectNV:                             ProcCmdDrawMeshTasksIndirectNV,
    	CmdDrawMeshTasksNV:                                     ProcCmdDrawMeshTasksNV,
    	CmdDrawMultiEXT:                                        ProcCmdDrawMultiEXT,
    	CmdDrawMultiIndexedEXT:                                 ProcCmdDrawMultiIndexedEXT,
    	CmdEndConditionalRenderingEXT:                          ProcCmdEndConditionalRenderingEXT,
    	CmdEndDebugUtilsLabelEXT:                               ProcCmdEndDebugUtilsLabelEXT,
    	CmdEndQuery:                                            ProcCmdEndQuery,
    	CmdEndQueryIndexedEXT:                                  ProcCmdEndQueryIndexedEXT,
    	CmdEndRenderPass:                                       ProcCmdEndRenderPass,
    	CmdEndRenderPass2:                                      ProcCmdEndRenderPass2,
    	CmdEndRenderPass2KHR:                                   ProcCmdEndRenderPass2KHR,
    	CmdEndRendering:                                        ProcCmdEndRendering,
    	CmdEndRenderingKHR:                                     ProcCmdEndRenderingKHR,
    	CmdEndTransformFeedbackEXT:                             ProcCmdEndTransformFeedbackEXT,
    	CmdEndVideoCodingKHR:                                   ProcCmdEndVideoCodingKHR,
    	CmdExecuteCommands:                                     ProcCmdExecuteCommands,
    	CmdExecuteGeneratedCommandsNV:                          ProcCmdExecuteGeneratedCommandsNV,
    	CmdFillBuffer:                                          ProcCmdFillBuffer,
    	CmdInsertDebugUtilsLabelEXT:                            ProcCmdInsertDebugUtilsLabelEXT,
    	CmdNextSubpass:                                         ProcCmdNextSubpass,
    	CmdNextSubpass2:                                        ProcCmdNextSubpass2,
    	CmdNextSubpass2KHR:                                     ProcCmdNextSubpass2KHR,
    	CmdOpticalFlowExecuteNV:                                ProcCmdOpticalFlowExecuteNV,
    	CmdPipelineBarrier:                                     ProcCmdPipelineBarrier,
    	CmdPipelineBarrier2:                                    ProcCmdPipelineBarrier2,
    	CmdPipelineBarrier2KHR:                                 ProcCmdPipelineBarrier2KHR,
    	CmdPreprocessGeneratedCommandsNV:                       ProcCmdPreprocessGeneratedCommandsNV,
    	CmdPushConstants:                                       ProcCmdPushConstants,
    	CmdPushDescriptorSetKHR:                                ProcCmdPushDescriptorSetKHR,
    	CmdPushDescriptorSetWithTemplateKHR:                    ProcCmdPushDescriptorSetWithTemplateKHR,
    	CmdResetEvent:                                          ProcCmdResetEvent,
    	CmdResetEvent2:                                         ProcCmdResetEvent2,
    	CmdResetEvent2KHR:                                      ProcCmdResetEvent2KHR,
    	CmdResetQueryPool:                                      ProcCmdResetQueryPool,
    	CmdResolveImage:                                        ProcCmdResolveImage,
    	CmdResolveImage2:                                       ProcCmdResolveImage2,
    	CmdResolveImage2KHR:                                    ProcCmdResolveImage2KHR,
    	CmdSetAlphaToCoverageEnableEXT:                         ProcCmdSetAlphaToCoverageEnableEXT,
    	CmdSetAlphaToOneEnableEXT:                              ProcCmdSetAlphaToOneEnableEXT,
    	CmdSetAttachmentFeedbackLoopEnableEXT:                  ProcCmdSetAttachmentFeedbackLoopEnableEXT,
    	CmdSetBlendConstants:                                   ProcCmdSetBlendConstants,
    	CmdSetCheckpointNV:                                     ProcCmdSetCheckpointNV,
    	CmdSetCoarseSampleOrderNV:                              ProcCmdSetCoarseSampleOrderNV,
    	CmdSetColorBlendAdvancedEXT:                            ProcCmdSetColorBlendAdvancedEXT,
    	CmdSetColorBlendEnableEXT:                              ProcCmdSetColorBlendEnableEXT,
    	CmdSetColorBlendEquationEXT:                            ProcCmdSetColorBlendEquationEXT,
    	CmdSetColorWriteMaskEXT:                                ProcCmdSetColorWriteMaskEXT,
    	CmdSetConservativeRasterizationModeEXT:                 ProcCmdSetConservativeRasterizationModeEXT,
    	CmdSetCoverageModulationModeNV:                         ProcCmdSetCoverageModulationModeNV,
    	CmdSetCoverageModulationTableEnableNV:                  ProcCmdSetCoverageModulationTableEnableNV,
    	CmdSetCoverageModulationTableNV:                        ProcCmdSetCoverageModulationTableNV,
    	CmdSetCoverageReductionModeNV:                          ProcCmdSetCoverageReductionModeNV,
    	CmdSetCoverageToColorEnableNV:                          ProcCmdSetCoverageToColorEnableNV,
    	CmdSetCoverageToColorLocationNV:                        ProcCmdSetCoverageToColorLocationNV,
    	CmdSetCullMode:                                         ProcCmdSetCullMode,
    	CmdSetCullModeEXT:                                      ProcCmdSetCullModeEXT,
    	CmdSetDepthBias:                                        ProcCmdSetDepthBias,
    	CmdSetDepthBiasEnable:                                  ProcCmdSetDepthBiasEnable,
    	CmdSetDepthBiasEnableEXT:                               ProcCmdSetDepthBiasEnableEXT,
    	CmdSetDepthBounds:                                      ProcCmdSetDepthBounds,
    	CmdSetDepthBoundsTestEnable:                            ProcCmdSetDepthBoundsTestEnable,
    	CmdSetDepthBoundsTestEnableEXT:                         ProcCmdSetDepthBoundsTestEnableEXT,
    	CmdSetDepthClampEnableEXT:                              ProcCmdSetDepthClampEnableEXT,
    	CmdSetDepthClipEnableEXT:                               ProcCmdSetDepthClipEnableEXT,
    	CmdSetDepthClipNegativeOneToOneEXT:                     ProcCmdSetDepthClipNegativeOneToOneEXT,
    	CmdSetDepthCompareOp:                                   ProcCmdSetDepthCompareOp,
    	CmdSetDepthCompareOpEXT:                                ProcCmdSetDepthCompareOpEXT,
    	CmdSetDepthTestEnable:                                  ProcCmdSetDepthTestEnable,
    	CmdSetDepthTestEnableEXT:                               ProcCmdSetDepthTestEnableEXT,
    	CmdSetDepthWriteEnable:                                 ProcCmdSetDepthWriteEnable,
    	CmdSetDepthWriteEnableEXT:                              ProcCmdSetDepthWriteEnableEXT,
    	CmdSetDescriptorBufferOffsetsEXT:                       ProcCmdSetDescriptorBufferOffsetsEXT,
    	CmdSetDeviceMask:                                       ProcCmdSetDeviceMask,
    	CmdSetDeviceMaskKHR:                                    ProcCmdSetDeviceMaskKHR,
    	CmdSetDiscardRectangleEXT:                              ProcCmdSetDiscardRectangleEXT,
    	CmdSetDiscardRectangleEnableEXT:                        ProcCmdSetDiscardRectangleEnableEXT,
    	CmdSetDiscardRectangleModeEXT:                          ProcCmdSetDiscardRectangleModeEXT,
    	CmdSetEvent:                                            ProcCmdSetEvent,
    	CmdSetEvent2:                                           ProcCmdSetEvent2,
    	CmdSetEvent2KHR:                                        ProcCmdSetEvent2KHR,
    	CmdSetExclusiveScissorEnableNV:                         ProcCmdSetExclusiveScissorEnableNV,
    	CmdSetExclusiveScissorNV:                               ProcCmdSetExclusiveScissorNV,
    	CmdSetExtraPrimitiveOverestimationSizeEXT:              ProcCmdSetExtraPrimitiveOverestimationSizeEXT,
    	CmdSetFragmentShadingRateEnumNV:                        ProcCmdSetFragmentShadingRateEnumNV,
    	CmdSetFragmentShadingRateKHR:                           ProcCmdSetFragmentShadingRateKHR,
    	CmdSetFrontFace:                                        ProcCmdSetFrontFace,
    	CmdSetFrontFaceEXT:                                     ProcCmdSetFrontFaceEXT,
    	CmdSetLineRasterizationModeEXT:                         ProcCmdSetLineRasterizationModeEXT,
    	CmdSetLineStippleEXT:                                   ProcCmdSetLineStippleEXT,
    	CmdSetLineStippleEnableEXT:                             ProcCmdSetLineStippleEnableEXT,
    	CmdSetLineWidth:                                        ProcCmdSetLineWidth,
    	CmdSetLogicOpEXT:                                       ProcCmdSetLogicOpEXT,
    	CmdSetLogicOpEnableEXT:                                 ProcCmdSetLogicOpEnableEXT,
    	CmdSetPatchControlPointsEXT:                            ProcCmdSetPatchControlPointsEXT,
    	CmdSetPerformanceMarkerINTEL:                           ProcCmdSetPerformanceMarkerINTEL,
    	CmdSetPerformanceOverrideINTEL:                         ProcCmdSetPerformanceOverrideINTEL,
    	CmdSetPerformanceStreamMarkerINTEL:                     ProcCmdSetPerformanceStreamMarkerINTEL,
    	CmdSetPolygonModeEXT:                                   ProcCmdSetPolygonModeEXT,
    	CmdSetPrimitiveRestartEnable:                           ProcCmdSetPrimitiveRestartEnable,
    	CmdSetPrimitiveRestartEnableEXT:                        ProcCmdSetPrimitiveRestartEnableEXT,
    	CmdSetPrimitiveTopology:                                ProcCmdSetPrimitiveTopology,
    	CmdSetPrimitiveTopologyEXT:                             ProcCmdSetPrimitiveTopologyEXT,
    	CmdSetProvokingVertexModeEXT:                           ProcCmdSetProvokingVertexModeEXT,
    	CmdSetRasterizationSamplesEXT:                          ProcCmdSetRasterizationSamplesEXT,
    	CmdSetRasterizationStreamEXT:                           ProcCmdSetRasterizationStreamEXT,
    	CmdSetRasterizerDiscardEnable:                          ProcCmdSetRasterizerDiscardEnable,
    	CmdSetRasterizerDiscardEnableEXT:                       ProcCmdSetRasterizerDiscardEnableEXT,
    	CmdSetRayTracingPipelineStackSizeKHR:                   ProcCmdSetRayTracingPipelineStackSizeKHR,
    	CmdSetRepresentativeFragmentTestEnableNV:               ProcCmdSetRepresentativeFragmentTestEnableNV,
    	CmdSetSampleLocationsEXT:                               ProcCmdSetSampleLocationsEXT,
    	CmdSetSampleLocationsEnableEXT:                         ProcCmdSetSampleLocationsEnableEXT,
    	CmdSetSampleMaskEXT:                                    ProcCmdSetSampleMaskEXT,
    	CmdSetScissor:                                          ProcCmdSetScissor,
    	CmdSetScissorWithCount:                                 ProcCmdSetScissorWithCount,
    	CmdSetScissorWithCountEXT:                              ProcCmdSetScissorWithCountEXT,
    	CmdSetShadingRateImageEnableNV:                         ProcCmdSetShadingRateImageEnableNV,
    	CmdSetStencilCompareMask:                               ProcCmdSetStencilCompareMask,
    	CmdSetStencilOp:                                        ProcCmdSetStencilOp,
    	CmdSetStencilOpEXT:                                     ProcCmdSetStencilOpEXT,
    	CmdSetStencilReference:                                 ProcCmdSetStencilReference,
    	CmdSetStencilTestEnable:                                ProcCmdSetStencilTestEnable,
    	CmdSetStencilTestEnableEXT:                             ProcCmdSetStencilTestEnableEXT,
    	CmdSetStencilWriteMask:                                 ProcCmdSetStencilWriteMask,
    	CmdSetTessellationDomainOriginEXT:                      ProcCmdSetTessellationDomainOriginEXT,
    	CmdSetVertexInputEXT:                                   ProcCmdSetVertexInputEXT,
    	CmdSetViewport:                                         ProcCmdSetViewport,
    	CmdSetViewportShadingRatePaletteNV:                     ProcCmdSetViewportShadingRatePaletteNV,
    	CmdSetViewportSwizzleNV:                                ProcCmdSetViewportSwizzleNV,
    	CmdSetViewportWScalingEnableNV:                         ProcCmdSetViewportWScalingEnableNV,
    	CmdSetViewportWScalingNV:                               ProcCmdSetViewportWScalingNV,
    	CmdSetViewportWithCount:                                ProcCmdSetViewportWithCount,
    	CmdSetViewportWithCountEXT:                             ProcCmdSetViewportWithCountEXT,
    	CmdSubpassShadingHUAWEI:                                ProcCmdSubpassShadingHUAWEI,
    	CmdTraceRaysIndirect2KHR:                               ProcCmdTraceRaysIndirect2KHR,
    	CmdTraceRaysIndirectKHR:                                ProcCmdTraceRaysIndirectKHR,
    	CmdTraceRaysKHR:                                        ProcCmdTraceRaysKHR,
    	CmdTraceRaysNV:                                         ProcCmdTraceRaysNV,
    	CmdUpdateBuffer:                                        ProcCmdUpdateBuffer,
    	CmdWaitEvents:                                          ProcCmdWaitEvents,
    	CmdWaitEvents2:                                         ProcCmdWaitEvents2,
    	CmdWaitEvents2KHR:                                      ProcCmdWaitEvents2KHR,
    	CmdWriteAccelerationStructuresPropertiesKHR:            ProcCmdWriteAccelerationStructuresPropertiesKHR,
    	CmdWriteAccelerationStructuresPropertiesNV:             ProcCmdWriteAccelerationStructuresPropertiesNV,
    	CmdWriteBufferMarker2AMD:                               ProcCmdWriteBufferMarker2AMD,
    	CmdWriteBufferMarkerAMD:                                ProcCmdWriteBufferMarkerAMD,
    	CmdWriteMicromapsPropertiesEXT:                         ProcCmdWriteMicromapsPropertiesEXT,
    	CmdWriteTimestamp:                                      ProcCmdWriteTimestamp,
    	CmdWriteTimestamp2:                                     ProcCmdWriteTimestamp2,
    	CmdWriteTimestamp2KHR:                                  ProcCmdWriteTimestamp2KHR,
    	CompileDeferredNV:                                      ProcCompileDeferredNV,
    	CopyAccelerationStructureKHR:                           ProcCopyAccelerationStructureKHR,
    	CopyAccelerationStructureToMemoryKHR:                   ProcCopyAccelerationStructureToMemoryKHR,
    	CopyMemoryToAccelerationStructureKHR:                   ProcCopyMemoryToAccelerationStructureKHR,
    	CopyMemoryToMicromapEXT:                                ProcCopyMemoryToMicromapEXT,
    	CopyMicromapEXT:                                        ProcCopyMicromapEXT,
    	CopyMicromapToMemoryEXT:                                ProcCopyMicromapToMemoryEXT,
    	CreateAccelerationStructureKHR:                         ProcCreateAccelerationStructureKHR,
    	CreateAccelerationStructureNV:                          ProcCreateAccelerationStructureNV,
    	CreateBuffer:                                           ProcCreateBuffer,
    	CreateBufferView:                                       ProcCreateBufferView,
    	CreateCommandPool:                                      ProcCreateCommandPool,
    	CreateComputePipelines:                                 ProcCreateComputePipelines,
    	CreateCuFunctionNVX:                                    ProcCreateCuFunctionNVX,
    	CreateCuModuleNVX:                                      ProcCreateCuModuleNVX,
    	CreateDeferredOperationKHR:                             ProcCreateDeferredOperationKHR,
    	CreateDescriptorPool:                                   ProcCreateDescriptorPool,
    	CreateDescriptorSetLayout:                              ProcCreateDescriptorSetLayout,
    	CreateDescriptorUpdateTemplate:                         ProcCreateDescriptorUpdateTemplate,
    	CreateDescriptorUpdateTemplateKHR:                      ProcCreateDescriptorUpdateTemplateKHR,
    	CreateEvent:                                            ProcCreateEvent,
    	CreateFence:                                            ProcCreateFence,
    	CreateFramebuffer:                                      ProcCreateFramebuffer,
    	CreateGraphicsPipelines:                                ProcCreateGraphicsPipelines,
    	CreateImage:                                            ProcCreateImage,
    	CreateImageView:                                        ProcCreateImageView,
    	CreateIndirectCommandsLayoutNV:                         ProcCreateIndirectCommandsLayoutNV,
    	CreateMicromapEXT:                                      ProcCreateMicromapEXT,
    	CreateOpticalFlowSessionNV:                             ProcCreateOpticalFlowSessionNV,
    	CreatePipelineCache:                                    ProcCreatePipelineCache,
    	CreatePipelineLayout:                                   ProcCreatePipelineLayout,
    	CreatePrivateDataSlot:                                  ProcCreatePrivateDataSlot,
    	CreatePrivateDataSlotEXT:                               ProcCreatePrivateDataSlotEXT,
    	CreateQueryPool:                                        ProcCreateQueryPool,
    	CreateRayTracingPipelinesKHR:                           ProcCreateRayTracingPipelinesKHR,
    	CreateRayTracingPipelinesNV:                            ProcCreateRayTracingPipelinesNV,
    	CreateRenderPass:                                       ProcCreateRenderPass,
    	CreateRenderPass2:                                      ProcCreateRenderPass2,
    	CreateRenderPass2KHR:                                   ProcCreateRenderPass2KHR,
    	CreateSampler:                                          ProcCreateSampler,
    	CreateSamplerYcbcrConversion:                           ProcCreateSamplerYcbcrConversion,
    	CreateSamplerYcbcrConversionKHR:                        ProcCreateSamplerYcbcrConversionKHR,
    	CreateSemaphore:                                        ProcCreateSemaphore,
    	CreateShaderModule:                                     ProcCreateShaderModule,
    	CreateShadersEXT:                                       ProcCreateShadersEXT,
    	CreateSharedSwapchainsKHR:                              ProcCreateSharedSwapchainsKHR,
    	CreateSwapchainKHR:                                     ProcCreateSwapchainKHR,
    	CreateValidationCacheEXT:                               ProcCreateValidationCacheEXT,
    	CreateVideoSessionKHR:                                  ProcCreateVideoSessionKHR,
    	CreateVideoSessionParametersKHR:                        ProcCreateVideoSessionParametersKHR,
    	DebugMarkerSetObjectNameEXT:                            ProcDebugMarkerSetObjectNameEXT,
    	DebugMarkerSetObjectTagEXT:                             ProcDebugMarkerSetObjectTagEXT,
    	DeferredOperationJoinKHR:                               ProcDeferredOperationJoinKHR,
    	DestroyAccelerationStructureKHR:                        ProcDestroyAccelerationStructureKHR,
    	DestroyAccelerationStructureNV:                         ProcDestroyAccelerationStructureNV,
    	DestroyBuffer:                                          ProcDestroyBuffer,
    	DestroyBufferView:                                      ProcDestroyBufferView,
    	DestroyCommandPool:                                     ProcDestroyCommandPool,
    	DestroyCuFunctionNVX:                                   ProcDestroyCuFunctionNVX,
    	DestroyCuModuleNVX:                                     ProcDestroyCuModuleNVX,
    	DestroyDeferredOperationKHR:                            ProcDestroyDeferredOperationKHR,
    	DestroyDescriptorPool:                                  ProcDestroyDescriptorPool,
    	DestroyDescriptorSetLayout:                             ProcDestroyDescriptorSetLayout,
    	DestroyDescriptorUpdateTemplate:                        ProcDestroyDescriptorUpdateTemplate,
    	DestroyDescriptorUpdateTemplateKHR:                     ProcDestroyDescriptorUpdateTemplateKHR,
    	DestroyDevice:                                          ProcDestroyDevice,
    	DestroyEvent:                                           ProcDestroyEvent,
    	DestroyFence:                                           ProcDestroyFence,
    	DestroyFramebuffer:                                     ProcDestroyFramebuffer,
    	DestroyImage:                                           ProcDestroyImage,
    	DestroyImageView:                                       ProcDestroyImageView,
    	DestroyIndirectCommandsLayoutNV:                        ProcDestroyIndirectCommandsLayoutNV,
    	DestroyMicromapEXT:                                     ProcDestroyMicromapEXT,
    	DestroyOpticalFlowSessionNV:                            ProcDestroyOpticalFlowSessionNV,
    	DestroyPipeline:                                        ProcDestroyPipeline,
    	DestroyPipelineCache:                                   ProcDestroyPipelineCache,
    	DestroyPipelineLayout:                                  ProcDestroyPipelineLayout,
    	DestroyPrivateDataSlot:                                 ProcDestroyPrivateDataSlot,
    	DestroyPrivateDataSlotEXT:                              ProcDestroyPrivateDataSlotEXT,
    	DestroyQueryPool:                                       ProcDestroyQueryPool,
    	DestroyRenderPass:                                      ProcDestroyRenderPass,
    	DestroySampler:                                         ProcDestroySampler,
    	DestroySamplerYcbcrConversion:                          ProcDestroySamplerYcbcrConversion,
    	DestroySamplerYcbcrConversionKHR:                       ProcDestroySamplerYcbcrConversionKHR,
    	DestroySemaphore:                                       ProcDestroySemaphore,
    	DestroyShaderEXT:                                       ProcDestroyShaderEXT,
    	DestroyShaderModule:                                    ProcDestroyShaderModule,
    	DestroySwapchainKHR:                                    ProcDestroySwapchainKHR,
    	DestroyValidationCacheEXT:                              ProcDestroyValidationCacheEXT,
    	DestroyVideoSessionKHR:                                 ProcDestroyVideoSessionKHR,
    	DestroyVideoSessionParametersKHR:                       ProcDestroyVideoSessionParametersKHR,
    	DeviceWaitIdle:                                         ProcDeviceWaitIdle,
    	DisplayPowerControlEXT:                                 ProcDisplayPowerControlEXT,
    	EndCommandBuffer:                                       ProcEndCommandBuffer,
    	ExportMetalObjectsEXT:                                  ProcExportMetalObjectsEXT,
    	FlushMappedMemoryRanges:                                ProcFlushMappedMemoryRanges,
    	FreeCommandBuffers:                                     ProcFreeCommandBuffers,
    	FreeDescriptorSets:                                     ProcFreeDescriptorSets,
    	FreeMemory:                                             ProcFreeMemory,
    	GetAccelerationStructureBuildSizesKHR:                  ProcGetAccelerationStructureBuildSizesKHR,
    	GetAccelerationStructureDeviceAddressKHR:               ProcGetAccelerationStructureDeviceAddressKHR,
    	GetAccelerationStructureHandleNV:                       ProcGetAccelerationStructureHandleNV,
    	GetAccelerationStructureMemoryRequirementsNV:           ProcGetAccelerationStructureMemoryRequirementsNV,
    	GetAccelerationStructureOpaqueCaptureDescriptorDataEXT: ProcGetAccelerationStructureOpaqueCaptureDescriptorDataEXT,
    	GetBufferDeviceAddress:                                 ProcGetBufferDeviceAddress,
    	GetBufferDeviceAddressEXT:                              ProcGetBufferDeviceAddressEXT,
    	GetBufferDeviceAddressKHR:                              ProcGetBufferDeviceAddressKHR,
    	GetBufferMemoryRequirements:                            ProcGetBufferMemoryRequirements,
    	GetBufferMemoryRequirements2:                           ProcGetBufferMemoryRequirements2,
    	GetBufferMemoryRequirements2KHR:                        ProcGetBufferMemoryRequirements2KHR,
    	GetBufferOpaqueCaptureAddress:                          ProcGetBufferOpaqueCaptureAddress,
    	GetBufferOpaqueCaptureAddressKHR:                       ProcGetBufferOpaqueCaptureAddressKHR,
    	GetBufferOpaqueCaptureDescriptorDataEXT:                ProcGetBufferOpaqueCaptureDescriptorDataEXT,
    	GetCalibratedTimestampsEXT:                             ProcGetCalibratedTimestampsEXT,
    	GetDeferredOperationMaxConcurrencyKHR:                  ProcGetDeferredOperationMaxConcurrencyKHR,
    	GetDeferredOperationResultKHR:                          ProcGetDeferredOperationResultKHR,
    	GetDescriptorEXT:                                       ProcGetDescriptorEXT,
    	GetDescriptorSetHostMappingVALVE:                       ProcGetDescriptorSetHostMappingVALVE,
    	GetDescriptorSetLayoutBindingOffsetEXT:                 ProcGetDescriptorSetLayoutBindingOffsetEXT,
    	GetDescriptorSetLayoutHostMappingInfoVALVE:             ProcGetDescriptorSetLayoutHostMappingInfoVALVE,
    	GetDescriptorSetLayoutSizeEXT:                          ProcGetDescriptorSetLayoutSizeEXT,
    	GetDescriptorSetLayoutSupport:                          ProcGetDescriptorSetLayoutSupport,
    	GetDescriptorSetLayoutSupportKHR:                       ProcGetDescriptorSetLayoutSupportKHR,
    	GetDeviceAccelerationStructureCompatibilityKHR:         ProcGetDeviceAccelerationStructureCompatibilityKHR,
    	GetDeviceBufferMemoryRequirements:                      ProcGetDeviceBufferMemoryRequirements,
    	GetDeviceBufferMemoryRequirementsKHR:                   ProcGetDeviceBufferMemoryRequirementsKHR,
    	GetDeviceFaultInfoEXT:                                  ProcGetDeviceFaultInfoEXT,
    	GetDeviceGroupPeerMemoryFeatures:                       ProcGetDeviceGroupPeerMemoryFeatures,
    	GetDeviceGroupPeerMemoryFeaturesKHR:                    ProcGetDeviceGroupPeerMemoryFeaturesKHR,
    	GetDeviceGroupPresentCapabilitiesKHR:                   ProcGetDeviceGroupPresentCapabilitiesKHR,
    	GetDeviceGroupSurfacePresentModes2EXT:                  ProcGetDeviceGroupSurfacePresentModes2EXT,
    	GetDeviceGroupSurfacePresentModesKHR:                   ProcGetDeviceGroupSurfacePresentModesKHR,
    	GetDeviceImageMemoryRequirements:                       ProcGetDeviceImageMemoryRequirements,
    	GetDeviceImageMemoryRequirementsKHR:                    ProcGetDeviceImageMemoryRequirementsKHR,
    	GetDeviceImageSparseMemoryRequirements:                 ProcGetDeviceImageSparseMemoryRequirements,
    	GetDeviceImageSparseMemoryRequirementsKHR:              ProcGetDeviceImageSparseMemoryRequirementsKHR,
    	GetDeviceMemoryCommitment:                              ProcGetDeviceMemoryCommitment,
    	GetDeviceMemoryOpaqueCaptureAddress:                    ProcGetDeviceMemoryOpaqueCaptureAddress,
    	GetDeviceMemoryOpaqueCaptureAddressKHR:                 ProcGetDeviceMemoryOpaqueCaptureAddressKHR,
    	GetDeviceMicromapCompatibilityEXT:                      ProcGetDeviceMicromapCompatibilityEXT,
    	GetDeviceProcAddr:                                      ProcGetDeviceProcAddr,
    	GetDeviceQueue:                                         ProcGetDeviceQueue,
    	GetDeviceQueue2:                                        ProcGetDeviceQueue2,
    	GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI:          ProcGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI,
    	GetDynamicRenderingTilePropertiesQCOM:                  ProcGetDynamicRenderingTilePropertiesQCOM,
    	GetEventStatus:                                         ProcGetEventStatus,
    	GetFenceFdKHR:                                          ProcGetFenceFdKHR,
    	GetFenceStatus:                                         ProcGetFenceStatus,
    	GetFenceWin32HandleKHR:                                 ProcGetFenceWin32HandleKHR,
    	GetFramebufferTilePropertiesQCOM:                       ProcGetFramebufferTilePropertiesQCOM,
    	GetGeneratedCommandsMemoryRequirementsNV:               ProcGetGeneratedCommandsMemoryRequirementsNV,
    	GetImageDrmFormatModifierPropertiesEXT:                 ProcGetImageDrmFormatModifierPropertiesEXT,
    	GetImageMemoryRequirements:                             ProcGetImageMemoryRequirements,
    	GetImageMemoryRequirements2:                            ProcGetImageMemoryRequirements2,
    	GetImageMemoryRequirements2KHR:                         ProcGetImageMemoryRequirements2KHR,
    	GetImageOpaqueCaptureDescriptorDataEXT:                 ProcGetImageOpaqueCaptureDescriptorDataEXT,
    	GetImageSparseMemoryRequirements:                       ProcGetImageSparseMemoryRequirements,
    	GetImageSparseMemoryRequirements2:                      ProcGetImageSparseMemoryRequirements2,
    	GetImageSparseMemoryRequirements2KHR:                   ProcGetImageSparseMemoryRequirements2KHR,
    	GetImageSubresourceLayout:                              ProcGetImageSubresourceLayout,
    	GetImageSubresourceLayout2EXT:                          ProcGetImageSubresourceLayout2EXT,
    	GetImageViewAddressNVX:                                 ProcGetImageViewAddressNVX,
    	GetImageViewHandleNVX:                                  ProcGetImageViewHandleNVX,
    	GetImageViewOpaqueCaptureDescriptorDataEXT:             ProcGetImageViewOpaqueCaptureDescriptorDataEXT,
    	GetMemoryFdKHR:                                         ProcGetMemoryFdKHR,
    	GetMemoryFdPropertiesKHR:                               ProcGetMemoryFdPropertiesKHR,
    	GetMemoryHostPointerPropertiesEXT:                      ProcGetMemoryHostPointerPropertiesEXT,
    	GetMemoryRemoteAddressNV:                               ProcGetMemoryRemoteAddressNV,
    	GetMemoryWin32HandleKHR:                                ProcGetMemoryWin32HandleKHR,
    	GetMemoryWin32HandleNV:                                 ProcGetMemoryWin32HandleNV,
    	GetMemoryWin32HandlePropertiesKHR:                      ProcGetMemoryWin32HandlePropertiesKHR,
    	GetMicromapBuildSizesEXT:                               ProcGetMicromapBuildSizesEXT,
    	GetPastPresentationTimingGOOGLE:                        ProcGetPastPresentationTimingGOOGLE,
    	GetPerformanceParameterINTEL:                           ProcGetPerformanceParameterINTEL,
    	GetPipelineCacheData:                                   ProcGetPipelineCacheData,
    	GetPipelineExecutableInternalRepresentationsKHR:        ProcGetPipelineExecutableInternalRepresentationsKHR,
    	GetPipelineExecutablePropertiesKHR:                     ProcGetPipelineExecutablePropertiesKHR,
    	GetPipelineExecutableStatisticsKHR:                     ProcGetPipelineExecutableStatisticsKHR,
    	GetPipelinePropertiesEXT:                               ProcGetPipelinePropertiesEXT,
    	GetPrivateData:                                         ProcGetPrivateData,
    	GetPrivateDataEXT:                                      ProcGetPrivateDataEXT,
    	GetQueryPoolResults:                                    ProcGetQueryPoolResults,
    	GetQueueCheckpointData2NV:                              ProcGetQueueCheckpointData2NV,
    	GetQueueCheckpointDataNV:                               ProcGetQueueCheckpointDataNV,
    	GetRayTracingCaptureReplayShaderGroupHandlesKHR:        ProcGetRayTracingCaptureReplayShaderGroupHandlesKHR,
    	GetRayTracingShaderGroupHandlesKHR:                     ProcGetRayTracingShaderGroupHandlesKHR,
    	GetRayTracingShaderGroupHandlesNV:                      ProcGetRayTracingShaderGroupHandlesNV,
    	GetRayTracingShaderGroupStackSizeKHR:                   ProcGetRayTracingShaderGroupStackSizeKHR,
    	GetRefreshCycleDurationGOOGLE:                          ProcGetRefreshCycleDurationGOOGLE,
    	GetRenderAreaGranularity:                               ProcGetRenderAreaGranularity,
    	GetSamplerOpaqueCaptureDescriptorDataEXT:               ProcGetSamplerOpaqueCaptureDescriptorDataEXT,
    	GetSemaphoreCounterValue:                               ProcGetSemaphoreCounterValue,
    	GetSemaphoreCounterValueKHR:                            ProcGetSemaphoreCounterValueKHR,
    	GetSemaphoreFdKHR:                                      ProcGetSemaphoreFdKHR,
    	GetSemaphoreWin32HandleKHR:                             ProcGetSemaphoreWin32HandleKHR,
    	GetShaderBinaryDataEXT:                                 ProcGetShaderBinaryDataEXT,
    	GetShaderInfoAMD:                                       ProcGetShaderInfoAMD,
    	GetShaderModuleCreateInfoIdentifierEXT:                 ProcGetShaderModuleCreateInfoIdentifierEXT,
    	GetShaderModuleIdentifierEXT:                           ProcGetShaderModuleIdentifierEXT,
    	GetSwapchainCounterEXT:                                 ProcGetSwapchainCounterEXT,
    	GetSwapchainImagesKHR:                                  ProcGetSwapchainImagesKHR,
    	GetSwapchainStatusKHR:                                  ProcGetSwapchainStatusKHR,
    	GetValidationCacheDataEXT:                              ProcGetValidationCacheDataEXT,
    	GetVideoSessionMemoryRequirementsKHR:                   ProcGetVideoSessionMemoryRequirementsKHR,
    	ImportFenceFdKHR:                                       ProcImportFenceFdKHR,
    	ImportFenceWin32HandleKHR:                              ProcImportFenceWin32HandleKHR,
    	ImportSemaphoreFdKHR:                                   ProcImportSemaphoreFdKHR,
    	ImportSemaphoreWin32HandleKHR:                          ProcImportSemaphoreWin32HandleKHR,
    	InitializePerformanceApiINTEL:                          ProcInitializePerformanceApiINTEL,
    	InvalidateMappedMemoryRanges:                           ProcInvalidateMappedMemoryRanges,
    	MapMemory:                                              ProcMapMemory,
    	MapMemory2KHR:                                          ProcMapMemory2KHR,
    	MergePipelineCaches:                                    ProcMergePipelineCaches,
    	MergeValidationCachesEXT:                               ProcMergeValidationCachesEXT,
    	QueueBeginDebugUtilsLabelEXT:                           ProcQueueBeginDebugUtilsLabelEXT,
    	QueueBindSparse:                                        ProcQueueBindSparse,
    	QueueEndDebugUtilsLabelEXT:                             ProcQueueEndDebugUtilsLabelEXT,
    	QueueInsertDebugUtilsLabelEXT:                          ProcQueueInsertDebugUtilsLabelEXT,
    	QueuePresentKHR:                                        ProcQueuePresentKHR,
    	QueueSetPerformanceConfigurationINTEL:                  ProcQueueSetPerformanceConfigurationINTEL,
    	QueueSubmit:                                            ProcQueueSubmit,
    	QueueSubmit2:                                           ProcQueueSubmit2,
    	QueueSubmit2KHR:                                        ProcQueueSubmit2KHR,
    	QueueWaitIdle:                                          ProcQueueWaitIdle,
    	RegisterDeviceEventEXT:                                 ProcRegisterDeviceEventEXT,
    	RegisterDisplayEventEXT:                                ProcRegisterDisplayEventEXT,
    	ReleaseFullScreenExclusiveModeEXT:                      ProcReleaseFullScreenExclusiveModeEXT,
    	ReleasePerformanceConfigurationINTEL:                   ProcReleasePerformanceConfigurationINTEL,
    	ReleaseProfilingLockKHR:                                ProcReleaseProfilingLockKHR,
    	ReleaseSwapchainImagesEXT:                              ProcReleaseSwapchainImagesEXT,
    	ResetCommandBuffer:                                     ProcResetCommandBuffer,
    	ResetCommandPool:                                       ProcResetCommandPool,
    	ResetDescriptorPool:                                    ProcResetDescriptorPool,
    	ResetEvent:                                             ProcResetEvent,
    	ResetFences:                                            ProcResetFences,
    	ResetQueryPool:                                         ProcResetQueryPool,
    	ResetQueryPoolEXT:                                      ProcResetQueryPoolEXT,
    	SetDebugUtilsObjectNameEXT:                             ProcSetDebugUtilsObjectNameEXT,
    	SetDebugUtilsObjectTagEXT:                              ProcSetDebugUtilsObjectTagEXT,
    	SetDeviceMemoryPriorityEXT:                             ProcSetDeviceMemoryPriorityEXT,
    	SetEvent:                                               ProcSetEvent,
    	SetHdrMetadataEXT:                                      ProcSetHdrMetadataEXT,
    	SetLocalDimmingAMD:                                     ProcSetLocalDimmingAMD,
    	SetPrivateData:                                         ProcSetPrivateData,
    	SetPrivateDataEXT:                                      ProcSetPrivateDataEXT,
    	SignalSemaphore:                                        ProcSignalSemaphore,
    	SignalSemaphoreKHR:                                     ProcSignalSemaphoreKHR,
    	TrimCommandPool:                                        ProcTrimCommandPool,
    	TrimCommandPoolKHR:                                     ProcTrimCommandPoolKHR,
    	UninitializePerformanceApiINTEL:                        ProcUninitializePerformanceApiINTEL,
    	UnmapMemory:                                            ProcUnmapMemory,
    	UnmapMemory2KHR:                                        ProcUnmapMemory2KHR,
    	UpdateDescriptorSetWithTemplate:                        ProcUpdateDescriptorSetWithTemplate,
    	UpdateDescriptorSetWithTemplateKHR:                     ProcUpdateDescriptorSetWithTemplateKHR,
    	UpdateDescriptorSets:                                   ProcUpdateDescriptorSets,
    	UpdateVideoSessionParametersKHR:                        ProcUpdateVideoSessionParametersKHR,
    	WaitForFences:                                          ProcWaitForFences,
    	WaitForPresentKHR:                                      ProcWaitForPresentKHR,
    	WaitSemaphores:                                         ProcWaitSemaphores,
    	WaitSemaphoresKHR:                                      ProcWaitSemaphoresKHR,
    	WriteAccelerationStructuresPropertiesKHR:               ProcWriteAccelerationStructuresPropertiesKHR,
    	WriteMicromapsPropertiesEXT:                            ProcWriteMicromapsPropertiesEXT,
    }
     

    Device Procedure VTable

    Related Procedures With Parameters

    DirectDriverLoadingFlagLUNARG ¶

    DirectDriverLoadingFlagLUNARG :: enum u32 {
    }

    DirectDriverLoadingFlagsLUNARG ¶

    DirectDriverLoadingFlagsLUNARG :: distinct bit_set[DirectDriverLoadingFlagLUNARG; Flags]

    DirectDriverLoadingInfoLUNARG ¶

    DirectDriverLoadingInfoLUNARG :: struct {
    	sType:                  StructureType,
    	pNext:                  rawptr,
    	flags:                  DirectDriverLoadingFlagsLUNARG,
    	pfnGetInstanceProcAddr: ProcGetInstanceProcAddrLUNARG,
    }

    DirectDriverLoadingListLUNARG ¶

    DirectDriverLoadingListLUNARG :: struct {
    	sType:       StructureType,
    	pNext:       rawptr,
    	mode:        DirectDriverLoadingModeLUNARG,
    	driverCount: u32,
    	pDrivers:    [^]DirectDriverLoadingInfoLUNARG,
    }

    DirectDriverLoadingModeLUNARG ¶

    DirectDriverLoadingModeLUNARG :: enum i32 {
    	DIRECT_DRIVER_LOADING_MODE_EXCLUSIVE_LUNARG = 0, 
    	DIRECT_DRIVER_LOADING_MODE_INCLUSIVE_LUNARG = 1, 
    }

    DiscardRectangleModeEXT ¶

    DiscardRectangleModeEXT :: enum i32 {
    	INCLUSIVE = 0, 
    	EXCLUSIVE = 1, 
    }

    DispatchIndirectCommand ¶

    DispatchIndirectCommand :: struct {
    	x: u32,
    	y: u32,
    	z: u32,
    }

    DisplayEventInfoEXT ¶

    DisplayEventInfoEXT :: struct {
    	sType:        StructureType,
    	pNext:        rawptr,
    	displayEvent: DisplayEventTypeEXT,
    }

    DisplayEventTypeEXT ¶

    DisplayEventTypeEXT :: enum i32 {
    	FIRST_PIXEL_OUT = 0, 
    }

    DisplayKHR ¶

    DisplayKHR :: distinct u64

    DisplayModeCreateFlagKHR ¶

    DisplayModeCreateFlagKHR :: enum u32 {
    }

    DisplayModeCreateFlagsKHR ¶

    DisplayModeCreateFlagsKHR :: distinct bit_set[DisplayModeCreateFlagKHR; Flags]

    DisplayModeCreateInfoKHR ¶

    DisplayModeCreateInfoKHR :: struct {
    	sType:      StructureType,
    	pNext:      rawptr,
    	flags:      DisplayModeCreateFlagsKHR,
    	parameters: DisplayModeParametersKHR,
    }

    DisplayModeKHR ¶

    DisplayModeKHR :: distinct u64

    DisplayModeParametersKHR ¶

    DisplayModeParametersKHR :: struct {
    	visibleRegion: Extent2D,
    	refreshRate:   u32,
    }

    DisplayModeProperties2KHR ¶

    DisplayModeProperties2KHR :: struct {
    	sType:                 StructureType,
    	pNext:                 rawptr,
    	displayModeProperties: DisplayModePropertiesKHR,
    }

    DisplayModePropertiesKHR ¶

    DisplayModePropertiesKHR :: struct {
    	displayMode: DisplayModeKHR,
    	parameters:  DisplayModeParametersKHR,
    }

    DisplayNativeHdrSurfaceCapabilitiesAMD ¶

    DisplayNativeHdrSurfaceCapabilitiesAMD :: struct {
    	sType:               StructureType,
    	pNext:               rawptr,
    	localDimmingSupport: b32,
    }

    DisplayPlaneAlphaFlagKHR ¶

    DisplayPlaneAlphaFlagKHR :: enum Flags {
    	OPAQUE                  = 0, 
    	GLOBAL                  = 1, 
    	PER_PIXEL               = 2, 
    	PER_PIXEL_PREMULTIPLIED = 3, 
    }

    DisplayPlaneAlphaFlagsKHR ¶

    DisplayPlaneAlphaFlagsKHR :: distinct bit_set[DisplayPlaneAlphaFlagKHR; Flags]

    DisplayPlaneCapabilities2KHR ¶

    DisplayPlaneCapabilities2KHR :: struct {
    	sType:        StructureType,
    	pNext:        rawptr,
    	capabilities: DisplayPlaneCapabilitiesKHR,
    }

    DisplayPlaneCapabilitiesKHR ¶

    DisplayPlaneCapabilitiesKHR :: struct {
    	supportedAlpha: DisplayPlaneAlphaFlagsKHR,
    	minSrcPosition: Offset2D,
    	maxSrcPosition: Offset2D,
    	minSrcExtent:   Extent2D,
    	maxSrcExtent:   Extent2D,
    	minDstPosition: Offset2D,
    	maxDstPosition: Offset2D,
    	minDstExtent:   Extent2D,
    	maxDstExtent:   Extent2D,
    }

    DisplayPlaneInfo2KHR ¶

    DisplayPlaneInfo2KHR :: struct {
    	sType:      StructureType,
    	pNext:      rawptr,
    	mode:       DisplayModeKHR,
    	planeIndex: u32,
    }

    DisplayPlaneProperties2KHR ¶

    DisplayPlaneProperties2KHR :: struct {
    	sType:                  StructureType,
    	pNext:                  rawptr,
    	displayPlaneProperties: DisplayPlanePropertiesKHR,
    }

    DisplayPlanePropertiesKHR ¶

    DisplayPlanePropertiesKHR :: struct {
    	currentDisplay:    DisplayKHR,
    	currentStackIndex: u32,
    }

    DisplayPowerInfoEXT ¶

    DisplayPowerInfoEXT :: struct {
    	sType:      StructureType,
    	pNext:      rawptr,
    	powerState: DisplayPowerStateEXT,
    }

    DisplayPowerStateEXT ¶

    DisplayPowerStateEXT :: enum i32 {
    	OFF     = 0, 
    	SUSPEND = 1, 
    	ON      = 2, 
    }

    DisplayPresentInfoKHR ¶

    DisplayPresentInfoKHR :: struct {
    	sType:      StructureType,
    	pNext:      rawptr,
    	srcRect:    Rect2D,
    	dstRect:    Rect2D,
    	persistent: b32,
    }

    DisplayProperties2KHR ¶

    DisplayProperties2KHR :: struct {
    	sType:             StructureType,
    	pNext:             rawptr,
    	displayProperties: DisplayPropertiesKHR,
    }

    DisplayPropertiesKHR ¶

    DisplayPropertiesKHR :: struct {
    	display:              DisplayKHR,
    	displayName:          cstring,
    	physicalDimensions:   Extent2D,
    	physicalResolution:   Extent2D,
    	supportedTransforms:  SurfaceTransformFlagsKHR,
    	planeReorderPossible: b32,
    	persistentContent:    b32,
    }

    DisplaySurfaceCreateFlagKHR ¶

    DisplaySurfaceCreateFlagKHR :: enum u32 {
    }

    DisplaySurfaceCreateFlagsKHR ¶

    DisplaySurfaceCreateFlagsKHR :: distinct bit_set[DisplaySurfaceCreateFlagKHR; Flags]

    DisplaySurfaceCreateInfoKHR ¶

    DisplaySurfaceCreateInfoKHR :: struct {
    	sType:           StructureType,
    	pNext:           rawptr,
    	flags:           DisplaySurfaceCreateFlagsKHR,
    	displayMode:     DisplayModeKHR,
    	planeIndex:      u32,
    	planeStackIndex: u32,
    	transform:       SurfaceTransformFlagsKHR,
    	globalAlpha:     f32,
    	alphaMode:       DisplayPlaneAlphaFlagsKHR,
    	imageExtent:     Extent2D,
    }

    DrawIndexedIndirectCommand ¶

    DrawIndexedIndirectCommand :: struct {
    	indexCount:    u32,
    	instanceCount: u32,
    	firstIndex:    u32,
    	vertexOffset:  i32,
    	firstInstance: u32,
    }

    DrawIndirectCommand ¶

    DrawIndirectCommand :: struct {
    	vertexCount:   u32,
    	instanceCount: u32,
    	firstVertex:   u32,
    	firstInstance: u32,
    }

    DrawMeshTasksIndirectCommandEXT ¶

    DrawMeshTasksIndirectCommandEXT :: struct {
    	groupCountX: u32,
    	groupCountY: u32,
    	groupCountZ: u32,
    }

    DrawMeshTasksIndirectCommandNV ¶

    DrawMeshTasksIndirectCommandNV :: struct {
    	taskCount: u32,
    	firstTask: u32,
    }

    DriverId ¶

    DriverId :: enum i32 {
    	AMD_PROPRIETARY               = 1, 
    	AMD_OPEN_SOURCE               = 2, 
    	MESA_RADV                     = 3, 
    	NVIDIA_PROPRIETARY            = 4, 
    	INTEL_PROPRIETARY_WINDOWS     = 5, 
    	INTEL_OPEN_SOURCE_MESA        = 6, 
    	IMAGINATION_PROPRIETARY       = 7, 
    	QUALCOMM_PROPRIETARY          = 8, 
    	ARM_PROPRIETARY               = 9, 
    	GOOGLE_SWIFTSHADER            = 10, 
    	GGP_PROPRIETARY               = 11, 
    	BROADCOM_PROPRIETARY          = 12, 
    	MESA_LLVMPIPE                 = 13, 
    	MOLTENVK                      = 14, 
    	COREAVI_PROPRIETARY           = 15, 
    	JUICE_PROPRIETARY             = 16, 
    	VERISILICON_PROPRIETARY       = 17, 
    	MESA_TURNIP                   = 18, 
    	MESA_V3DV                     = 19, 
    	MESA_PANVK                    = 20, 
    	SAMSUNG_PROPRIETARY           = 21, 
    	MESA_VENUS                    = 22, 
    	MESA_DOZEN                    = 23, 
    	MESA_NVK                      = 24, 
    	IMAGINATION_OPEN_SOURCE_MESA  = 25, 
    	AMD_PROPRIETARY_KHR           = 1, 
    	AMD_OPEN_SOURCE_KHR           = 2, 
    	MESA_RADV_KHR                 = 3, 
    	NVIDIA_PROPRIETARY_KHR        = 4, 
    	INTEL_PROPRIETARY_WINDOWS_KHR = 5, 
    	INTEL_OPEN_SOURCE_MESA_KHR    = 6, 
    	IMAGINATION_PROPRIETARY_KHR   = 7, 
    	QUALCOMM_PROPRIETARY_KHR      = 8, 
    	ARM_PROPRIETARY_KHR           = 9, 
    	GOOGLE_SWIFTSHADER_KHR        = 10, 
    	GGP_PROPRIETARY_KHR           = 11, 
    	BROADCOM_PROPRIETARY_KHR      = 12, 
    }

    DrmFormatModifierProperties2EXT ¶

    DrmFormatModifierProperties2EXT :: struct {
    	drmFormatModifier:               u64,
    	drmFormatModifierPlaneCount:     u32,
    	drmFormatModifierTilingFeatures: FormatFeatureFlags2,
    }

    DrmFormatModifierPropertiesEXT ¶

    DrmFormatModifierPropertiesEXT :: struct {
    	drmFormatModifier:               u64,
    	drmFormatModifierPlaneCount:     u32,
    	drmFormatModifierTilingFeatures: FormatFeatureFlags,
    }

    DrmFormatModifierPropertiesList2EXT ¶

    DrmFormatModifierPropertiesList2EXT :: struct {
    	sType:                        StructureType,
    	pNext:                        rawptr,
    	drmFormatModifierCount:       u32,
    	pDrmFormatModifierProperties: [^]DrmFormatModifierProperties2EXT,
    }

    DrmFormatModifierPropertiesListEXT ¶

    DrmFormatModifierPropertiesListEXT :: struct {
    	sType:                        StructureType,
    	pNext:                        rawptr,
    	drmFormatModifierCount:       u32,
    	pDrmFormatModifierProperties: [^]DrmFormatModifierPropertiesEXT,
    }

    DynamicState ¶

    DynamicState :: enum i32 {
    	VIEWPORT                                = 0, 
    	SCISSOR                                 = 1, 
    	LINE_WIDTH                              = 2, 
    	DEPTH_BIAS                              = 3, 
    	BLEND_CONSTANTS                         = 4, 
    	DEPTH_BOUNDS                            = 5, 
    	STENCIL_COMPARE_MASK                    = 6, 
    	STENCIL_WRITE_MASK                      = 7, 
    	STENCIL_REFERENCE                       = 8, 
    	CULL_MODE                               = 1000267000, 
    	FRONT_FACE                              = 1000267001, 
    	PRIMITIVE_TOPOLOGY                      = 1000267002, 
    	VIEWPORT_WITH_COUNT                     = 1000267003, 
    	SCISSOR_WITH_COUNT                      = 1000267004, 
    	VERTEX_INPUT_BINDING_STRIDE             = 1000267005, 
    	DEPTH_TEST_ENABLE                       = 1000267006, 
    	DEPTH_WRITE_ENABLE                      = 1000267007, 
    	DEPTH_COMPARE_OP                        = 1000267008, 
    	DEPTH_BOUNDS_TEST_ENABLE                = 1000267009, 
    	STENCIL_TEST_ENABLE                     = 1000267010, 
    	STENCIL_OP                              = 1000267011, 
    	RASTERIZER_DISCARD_ENABLE               = 1000377001, 
    	DEPTH_BIAS_ENABLE                       = 1000377002, 
    	PRIMITIVE_RESTART_ENABLE                = 1000377004, 
    	VIEWPORT_W_SCALING_NV                   = 1000087000, 
    	DISCARD_RECTANGLE_EXT                   = 1000099000, 
    	DISCARD_RECTANGLE_ENABLE_EXT            = 1000099001, 
    	DISCARD_RECTANGLE_MODE_EXT              = 1000099002, 
    	SAMPLE_LOCATIONS_EXT                    = 1000143000, 
    	RAY_TRACING_PIPELINE_STACK_SIZE_KHR     = 1000347000, 
    	VIEWPORT_SHADING_RATE_PALETTE_NV        = 1000164004, 
    	VIEWPORT_COARSE_SAMPLE_ORDER_NV         = 1000164006, 
    	EXCLUSIVE_SCISSOR_ENABLE_NV             = 1000205000, 
    	EXCLUSIVE_SCISSOR_NV                    = 1000205001, 
    	FRAGMENT_SHADING_RATE_KHR               = 1000226000, 
    	LINE_STIPPLE_EXT                        = 1000259000, 
    	VERTEX_INPUT_EXT                        = 1000352000, 
    	PATCH_CONTROL_POINTS_EXT                = 1000377000, 
    	LOGIC_OP_EXT                            = 1000377003, 
    	COLOR_WRITE_ENABLE_EXT                  = 1000381000, 
    	TESSELLATION_DOMAIN_ORIGIN_EXT          = 1000455002, 
    	DEPTH_CLAMP_ENABLE_EXT                  = 1000455003, 
    	POLYGON_MODE_EXT                        = 1000455004, 
    	RASTERIZATION_SAMPLES_EXT               = 1000455005, 
    	SAMPLE_MASK_EXT                         = 1000455006, 
    	ALPHA_TO_COVERAGE_ENABLE_EXT            = 1000455007, 
    	ALPHA_TO_ONE_ENABLE_EXT                 = 1000455008, 
    	LOGIC_OP_ENABLE_EXT                     = 1000455009, 
    	COLOR_BLEND_ENABLE_EXT                  = 1000455010, 
    	COLOR_BLEND_EQUATION_EXT                = 1000455011, 
    	COLOR_WRITE_MASK_EXT                    = 1000455012, 
    	RASTERIZATION_STREAM_EXT                = 1000455013, 
    	CONSERVATIVE_RASTERIZATION_MODE_EXT     = 1000455014, 
    	EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT = 1000455015, 
    	DEPTH_CLIP_ENABLE_EXT                   = 1000455016, 
    	SAMPLE_LOCATIONS_ENABLE_EXT             = 1000455017, 
    	COLOR_BLEND_ADVANCED_EXT                = 1000455018, 
    	PROVOKING_VERTEX_MODE_EXT               = 1000455019, 
    	LINE_RASTERIZATION_MODE_EXT             = 1000455020, 
    	LINE_STIPPLE_ENABLE_EXT                 = 1000455021, 
    	DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT      = 1000455022, 
    	VIEWPORT_W_SCALING_ENABLE_NV            = 1000455023, 
    	VIEWPORT_SWIZZLE_NV                     = 1000455024, 
    	COVERAGE_TO_COLOR_ENABLE_NV             = 1000455025, 
    	COVERAGE_TO_COLOR_LOCATION_NV           = 1000455026, 
    	COVERAGE_MODULATION_MODE_NV             = 1000455027, 
    	COVERAGE_MODULATION_TABLE_ENABLE_NV     = 1000455028, 
    	COVERAGE_MODULATION_TABLE_NV            = 1000455029, 
    	SHADING_RATE_IMAGE_ENABLE_NV            = 1000455030, 
    	REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV  = 1000455031, 
    	COVERAGE_REDUCTION_MODE_NV              = 1000455032, 
    	ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT     = 1000524000, 
    	CULL_MODE_EXT                           = 1000267000, 
    	FRONT_FACE_EXT                          = 1000267001, 
    	PRIMITIVE_TOPOLOGY_EXT                  = 1000267002, 
    	VIEWPORT_WITH_COUNT_EXT                 = 1000267003, 
    	SCISSOR_WITH_COUNT_EXT                  = 1000267004, 
    	VERTEX_INPUT_BINDING_STRIDE_EXT         = 1000267005, 
    	DEPTH_TEST_ENABLE_EXT                   = 1000267006, 
    	DEPTH_WRITE_ENABLE_EXT                  = 1000267007, 
    	DEPTH_COMPARE_OP_EXT                    = 1000267008, 
    	DEPTH_BOUNDS_TEST_ENABLE_EXT            = 1000267009, 
    	STENCIL_TEST_ENABLE_EXT                 = 1000267010, 
    	STENCIL_OP_EXT                          = 1000267011, 
    	RASTERIZER_DISCARD_ENABLE_EXT           = 1000377001, 
    	DEPTH_BIAS_ENABLE_EXT                   = 1000377002, 
    	PRIMITIVE_RESTART_ENABLE_EXT            = 1000377004, 
    }

    Event ¶

    Event :: distinct u64

    EventCreateFlag ¶

    EventCreateFlag :: enum Flags {
    	DEVICE_ONLY     = 0, 
    	DEVICE_ONLY_KHR = 0, 
    }

    EventCreateFlags ¶

    EventCreateFlags :: distinct bit_set[EventCreateFlag; Flags]

    EventCreateInfo ¶

    EventCreateInfo :: struct {
    	sType: StructureType,
    	pNext: rawptr,
    	flags: EventCreateFlags,
    }

    ExportFenceCreateInfo ¶

    ExportFenceCreateInfo :: struct {
    	sType:       StructureType,
    	pNext:       rawptr,
    	handleTypes: ExternalFenceHandleTypeFlags,
    }

    ExportFenceWin32HandleInfoKHR ¶

    ExportFenceWin32HandleInfoKHR :: struct {
    	sType:       StructureType,
    	pNext:       rawptr,
    	pAttributes: [^]sys_windows.SECURITY_ATTRIBUTES,
    	dwAccess:    u32,
    	name:        [^]u16,
    }

    ExportMemoryAllocateInfo ¶

    ExportMemoryAllocateInfo :: struct {
    	sType:       StructureType,
    	pNext:       rawptr,
    	handleTypes: ExternalMemoryHandleTypeFlags,
    }

    ExportMemoryAllocateInfoNV ¶

    ExportMemoryAllocateInfoNV :: struct {
    	sType:       StructureType,
    	pNext:       rawptr,
    	handleTypes: ExternalMemoryHandleTypeFlagsNV,
    }

    ExportMemoryWin32HandleInfoKHR ¶

    ExportMemoryWin32HandleInfoKHR :: struct {
    	sType:       StructureType,
    	pNext:       rawptr,
    	pAttributes: [^]sys_windows.SECURITY_ATTRIBUTES,
    	dwAccess:    u32,
    	name:        [^]u16,
    }

    ExportMemoryWin32HandleInfoNV ¶

    ExportMemoryWin32HandleInfoNV :: struct {
    	sType:       StructureType,
    	pNext:       rawptr,
    	pAttributes: [^]sys_windows.SECURITY_ATTRIBUTES,
    	dwAccess:    u32,
    }

    ExportMetalBufferInfoEXT ¶

    ExportMetalBufferInfoEXT :: struct {
    	sType:     StructureType,
    	pNext:     rawptr,
    	memory:    DeviceMemory,
    	mtlBuffer: rawptr,
    }

    ExportMetalCommandQueueInfoEXT ¶

    ExportMetalCommandQueueInfoEXT :: struct {
    	sType:           StructureType,
    	pNext:           rawptr,
    	queue:           Queue,
    	mtlCommandQueue: rawptr,
    }

    ExportMetalDeviceInfoEXT ¶

    ExportMetalDeviceInfoEXT :: struct {
    	sType:     StructureType,
    	pNext:     rawptr,
    	mtlDevice: rawptr,
    }

    ExportMetalIOSurfaceInfoEXT ¶

    ExportMetalIOSurfaceInfoEXT :: struct {
    	sType:     StructureType,
    	pNext:     rawptr,
    	image:     Image,
    	ioSurface: IOSurfaceRef,
    }

    ExportMetalObjectCreateInfoEXT ¶

    ExportMetalObjectCreateInfoEXT :: struct {
    	sType:            StructureType,
    	pNext:            rawptr,
    	exportObjectType: ExportMetalObjectTypeFlagsEXT,
    }

    ExportMetalObjectTypeFlagEXT ¶

    ExportMetalObjectTypeFlagEXT :: enum Flags {
    	METAL_DEVICE        = 0, 
    	METAL_COMMAND_QUEUE = 1, 
    	METAL_BUFFER        = 2, 
    	METAL_TEXTURE       = 3, 
    	METAL_IOSURFACE     = 4, 
    	METAL_SHARED_EVENT  = 5, 
    }

    ExportMetalObjectTypeFlagsEXT ¶

    ExportMetalObjectTypeFlagsEXT :: distinct bit_set[ExportMetalObjectTypeFlagEXT; Flags]

    ExportMetalObjectsInfoEXT ¶

    ExportMetalObjectsInfoEXT :: struct {
    	sType: StructureType,
    	pNext: rawptr,
    }

    ExportMetalSharedEventInfoEXT ¶

    ExportMetalSharedEventInfoEXT :: struct {
    	sType:          StructureType,
    	pNext:          rawptr,
    	semaphore:      Semaphore,
    	event:          Event,
    	mtlSharedEvent: rawptr,
    }

    ExportMetalTextureInfoEXT ¶

    ExportMetalTextureInfoEXT :: struct {
    	sType:      StructureType,
    	pNext:      rawptr,
    	image:      Image,
    	imageView:  ImageView,
    	bufferView: BufferView,
    	plane:      ImageAspectFlags,
    	mtlTexture: rawptr,
    }

    ExportSemaphoreCreateInfo ¶

    ExportSemaphoreCreateInfo :: struct {
    	sType:       StructureType,
    	pNext:       rawptr,
    	handleTypes: ExternalSemaphoreHandleTypeFlags,
    }

    ExportSemaphoreWin32HandleInfoKHR ¶

    ExportSemaphoreWin32HandleInfoKHR :: struct {
    	sType:       StructureType,
    	pNext:       rawptr,
    	pAttributes: [^]sys_windows.SECURITY_ATTRIBUTES,
    	dwAccess:    u32,
    	name:        [^]u16,
    }

    ExtensionProperties ¶

    ExtensionProperties :: struct {
    	extensionName: [256]u8,
    	specVersion:   u32,
    }

    Extent2D ¶

    Extent2D :: struct {
    	width:  u32,
    	height: u32,
    }

    Extent3D ¶

    Extent3D :: struct {
    	width:  u32,
    	height: u32,
    	depth:  u32,
    }

    ExternalBufferProperties ¶

    ExternalBufferProperties :: struct {
    	sType:                    StructureType,
    	pNext:                    rawptr,
    	externalMemoryProperties: ExternalMemoryProperties,
    }

    ExternalFenceFeatureFlag ¶

    ExternalFenceFeatureFlag :: enum Flags {
    	EXPORTABLE     = 0, 
    	IMPORTABLE     = 1, 
    	EXPORTABLE_KHR = 0, 
    	IMPORTABLE_KHR = 1, 
    }

    ExternalFenceFeatureFlags ¶

    ExternalFenceFeatureFlags :: distinct bit_set[ExternalFenceFeatureFlag; Flags]

    ExternalFenceHandleTypeFlag ¶

    ExternalFenceHandleTypeFlag :: enum Flags {
    	OPAQUE_FD            = 0, 
    	OPAQUE_WIN32         = 1, 
    	OPAQUE_WIN32_KMT     = 2, 
    	SYNC_FD              = 3, 
    	OPAQUE_FD_KHR        = 0, 
    	OPAQUE_WIN32_KHR     = 1, 
    	OPAQUE_WIN32_KMT_KHR = 2, 
    	SYNC_FD_KHR          = 3, 
    }

    ExternalFenceHandleTypeFlags ¶

    ExternalFenceHandleTypeFlags :: distinct bit_set[ExternalFenceHandleTypeFlag; Flags]

    ExternalFenceProperties ¶

    ExternalFenceProperties :: struct {
    	sType:                         StructureType,
    	pNext:                         rawptr,
    	exportFromImportedHandleTypes: ExternalFenceHandleTypeFlags,
    	compatibleHandleTypes:         ExternalFenceHandleTypeFlags,
    	externalFenceFeatures:         ExternalFenceFeatureFlags,
    }

    ExternalImageFormatProperties ¶

    ExternalImageFormatProperties :: struct {
    	sType:                    StructureType,
    	pNext:                    rawptr,
    	externalMemoryProperties: ExternalMemoryProperties,
    }

    ExternalImageFormatPropertiesNV ¶

    ExternalImageFormatPropertiesNV :: struct {
    	imageFormatProperties:         ImageFormatProperties,
    	externalMemoryFeatures:        ExternalMemoryFeatureFlagsNV,
    	exportFromImportedHandleTypes: ExternalMemoryHandleTypeFlagsNV,
    	compatibleHandleTypes:         ExternalMemoryHandleTypeFlagsNV,
    }

    ExternalMemoryBufferCreateInfo ¶

    ExternalMemoryBufferCreateInfo :: struct {
    	sType:       StructureType,
    	pNext:       rawptr,
    	handleTypes: ExternalMemoryHandleTypeFlags,
    }

    ExternalMemoryFeatureFlag ¶

    ExternalMemoryFeatureFlag :: enum Flags {
    	DEDICATED_ONLY     = 0, 
    	EXPORTABLE         = 1, 
    	IMPORTABLE         = 2, 
    	DEDICATED_ONLY_KHR = 0, 
    	EXPORTABLE_KHR     = 1, 
    	IMPORTABLE_KHR     = 2, 
    }

    ExternalMemoryFeatureFlagNV ¶

    ExternalMemoryFeatureFlagNV :: enum Flags {
    	DEDICATED_ONLY = 0, 
    	EXPORTABLE     = 1, 
    	IMPORTABLE     = 2, 
    }

    ExternalMemoryFeatureFlags ¶

    ExternalMemoryFeatureFlags :: distinct bit_set[ExternalMemoryFeatureFlag; Flags]

    ExternalMemoryFeatureFlagsNV ¶

    ExternalMemoryFeatureFlagsNV :: distinct bit_set[ExternalMemoryFeatureFlagNV; Flags]

    ExternalMemoryHandleTypeFlag ¶

    ExternalMemoryHandleTypeFlag :: enum Flags {
    	OPAQUE_FD                       = 0, 
    	OPAQUE_WIN32                    = 1, 
    	OPAQUE_WIN32_KMT                = 2, 
    	D3D11_TEXTURE                   = 3, 
    	D3D11_TEXTURE_KMT               = 4, 
    	D3D12_HEAP                      = 5, 
    	D3D12_RESOURCE                  = 6, 
    	DMA_BUF_EXT                     = 9, 
    	ANDROID_HARDWARE_BUFFER_ANDROID = 10, 
    	HOST_ALLOCATION_EXT             = 7, 
    	HOST_MAPPED_FOREIGN_MEMORY_EXT  = 8, 
    	ZIRCON_VMO_FUCHSIA              = 11, 
    	RDMA_ADDRESS_NV                 = 12, 
    	OPAQUE_FD_KHR                   = 0, 
    	OPAQUE_WIN32_KHR                = 1, 
    	OPAQUE_WIN32_KMT_KHR            = 2, 
    	D3D11_TEXTURE_KHR               = 3, 
    	D3D11_TEXTURE_KMT_KHR           = 4, 
    	D3D12_HEAP_KHR                  = 5, 
    	D3D12_RESOURCE_KHR              = 6, 
    }

    ExternalMemoryHandleTypeFlagNV ¶

    ExternalMemoryHandleTypeFlagNV :: enum Flags {
    	OPAQUE_WIN32     = 0, 
    	OPAQUE_WIN32_KMT = 1, 
    	D3D11_IMAGE      = 2, 
    	D3D11_IMAGE_KMT  = 3, 
    }

    ExternalMemoryHandleTypeFlags ¶

    ExternalMemoryHandleTypeFlags :: distinct bit_set[ExternalMemoryHandleTypeFlag; Flags]

    ExternalMemoryHandleTypeFlagsNV ¶

    ExternalMemoryHandleTypeFlagsNV :: distinct bit_set[ExternalMemoryHandleTypeFlagNV; Flags]

    ExternalMemoryImageCreateInfo ¶

    ExternalMemoryImageCreateInfo :: struct {
    	sType:       StructureType,
    	pNext:       rawptr,
    	handleTypes: ExternalMemoryHandleTypeFlags,
    }

    ExternalMemoryImageCreateInfoNV ¶

    ExternalMemoryImageCreateInfoNV :: struct {
    	sType:       StructureType,
    	pNext:       rawptr,
    	handleTypes: ExternalMemoryHandleTypeFlagsNV,
    }

    ExternalMemoryProperties ¶

    ExternalMemoryProperties :: struct {
    	externalMemoryFeatures:        ExternalMemoryFeatureFlags,
    	exportFromImportedHandleTypes: ExternalMemoryHandleTypeFlags,
    	compatibleHandleTypes:         ExternalMemoryHandleTypeFlags,
    }

    ExternalSemaphoreFeatureFlag ¶

    ExternalSemaphoreFeatureFlag :: enum Flags {
    	EXPORTABLE     = 0, 
    	IMPORTABLE     = 1, 
    	EXPORTABLE_KHR = 0, 
    	IMPORTABLE_KHR = 1, 
    }

    ExternalSemaphoreFeatureFlags ¶

    ExternalSemaphoreFeatureFlags :: distinct bit_set[ExternalSemaphoreFeatureFlag; Flags]

    ExternalSemaphoreHandleTypeFlag ¶

    ExternalSemaphoreHandleTypeFlag :: enum Flags {
    	OPAQUE_FD            = 0, 
    	OPAQUE_WIN32         = 1, 
    	OPAQUE_WIN32_KMT     = 2, 
    	D3D12_FENCE          = 3, 
    	SYNC_FD              = 4, 
    	ZIRCON_EVENT_FUCHSIA = 7, 
    	D3D11_FENCE          = 3, 
    	OPAQUE_FD_KHR        = 0, 
    	OPAQUE_WIN32_KHR     = 1, 
    	OPAQUE_WIN32_KMT_KHR = 2, 
    	D3D12_FENCE_KHR      = 3, 
    	SYNC_FD_KHR          = 4, 
    }

    ExternalSemaphoreHandleTypeFlags ¶

    ExternalSemaphoreHandleTypeFlags :: distinct bit_set[ExternalSemaphoreHandleTypeFlag; Flags]

    ExternalSemaphoreProperties ¶

    ExternalSemaphoreProperties :: struct {
    	sType:                         StructureType,
    	pNext:                         rawptr,
    	exportFromImportedHandleTypes: ExternalSemaphoreHandleTypeFlags,
    	compatibleHandleTypes:         ExternalSemaphoreHandleTypeFlags,
    	externalSemaphoreFeatures:     ExternalSemaphoreFeatureFlags,
    }

    Fence ¶

    Fence :: distinct u64

    FenceCreateFlag ¶

    FenceCreateFlag :: enum Flags {
    	SIGNALED = 0, 
    }

    FenceCreateFlags ¶

    FenceCreateFlags :: distinct bit_set[FenceCreateFlag; Flags]

    FenceCreateInfo ¶

    FenceCreateInfo :: struct {
    	sType: StructureType,
    	pNext: rawptr,
    	flags: FenceCreateFlags,
    }

    FenceGetFdInfoKHR ¶

    FenceGetFdInfoKHR :: struct {
    	sType:      StructureType,
    	pNext:      rawptr,
    	fence:      Fence,
    	handleType: ExternalFenceHandleTypeFlags,
    }

    FenceGetWin32HandleInfoKHR ¶

    FenceGetWin32HandleInfoKHR :: struct {
    	sType:      StructureType,
    	pNext:      rawptr,
    	fence:      Fence,
    	handleType: ExternalFenceHandleTypeFlags,
    }

    FenceImportFlag ¶

    FenceImportFlag :: enum Flags {
    	TEMPORARY     = 0, 
    	TEMPORARY_KHR = 0, 
    }

    FenceImportFlags ¶

    FenceImportFlags :: distinct bit_set[FenceImportFlag; Flags]

    Filter ¶

    Filter :: enum i32 {
    	NEAREST   = 0, 
    	LINEAR    = 1, 
    	CUBIC_EXT = 1000015000, 
    	CUBIC_IMG = 1000015000, 
    }

    FilterCubicImageViewImageFormatPropertiesEXT ¶

    FilterCubicImageViewImageFormatPropertiesEXT :: struct {
    	sType:             StructureType,
    	pNext:             rawptr,
    	filterCubic:       b32,
    	filterCubicMinmax: b32,
    }

    Flags ¶

    Flags :: distinct u32
     

    Base types

    Flags64 ¶

    Flags64 :: distinct u64

    Format ¶

    Format :: enum i32 {
    	UNDEFINED                                      = 0, 
    	R4G4_UNORM_PACK8                               = 1, 
    	R4G4B4A4_UNORM_PACK16                          = 2, 
    	B4G4R4A4_UNORM_PACK16                          = 3, 
    	R5G6B5_UNORM_PACK16                            = 4, 
    	B5G6R5_UNORM_PACK16                            = 5, 
    	R5G5B5A1_UNORM_PACK16                          = 6, 
    	B5G5R5A1_UNORM_PACK16                          = 7, 
    	A1R5G5B5_UNORM_PACK16                          = 8, 
    	R8_UNORM                                       = 9, 
    	R8_SNORM                                       = 10, 
    	R8_USCALED                                     = 11, 
    	R8_SSCALED                                     = 12, 
    	R8_UINT                                        = 13, 
    	R8_SINT                                        = 14, 
    	R8_SRGB                                        = 15, 
    	R8G8_UNORM                                     = 16, 
    	R8G8_SNORM                                     = 17, 
    	R8G8_USCALED                                   = 18, 
    	R8G8_SSCALED                                   = 19, 
    	R8G8_UINT                                      = 20, 
    	R8G8_SINT                                      = 21, 
    	R8G8_SRGB                                      = 22, 
    	R8G8B8_UNORM                                   = 23, 
    	R8G8B8_SNORM                                   = 24, 
    	R8G8B8_USCALED                                 = 25, 
    	R8G8B8_SSCALED                                 = 26, 
    	R8G8B8_UINT                                    = 27, 
    	R8G8B8_SINT                                    = 28, 
    	R8G8B8_SRGB                                    = 29, 
    	B8G8R8_UNORM                                   = 30, 
    	B8G8R8_SNORM                                   = 31, 
    	B8G8R8_USCALED                                 = 32, 
    	B8G8R8_SSCALED                                 = 33, 
    	B8G8R8_UINT                                    = 34, 
    	B8G8R8_SINT                                    = 35, 
    	B8G8R8_SRGB                                    = 36, 
    	R8G8B8A8_UNORM                                 = 37, 
    	R8G8B8A8_SNORM                                 = 38, 
    	R8G8B8A8_USCALED                               = 39, 
    	R8G8B8A8_SSCALED                               = 40, 
    	R8G8B8A8_UINT                                  = 41, 
    	R8G8B8A8_SINT                                  = 42, 
    	R8G8B8A8_SRGB                                  = 43, 
    	B8G8R8A8_UNORM                                 = 44, 
    	B8G8R8A8_SNORM                                 = 45, 
    	B8G8R8A8_USCALED                               = 46, 
    	B8G8R8A8_SSCALED                               = 47, 
    	B8G8R8A8_UINT                                  = 48, 
    	B8G8R8A8_SINT                                  = 49, 
    	B8G8R8A8_SRGB                                  = 50, 
    	A8B8G8R8_UNORM_PACK32                          = 51, 
    	A8B8G8R8_SNORM_PACK32                          = 52, 
    	A8B8G8R8_USCALED_PACK32                        = 53, 
    	A8B8G8R8_SSCALED_PACK32                        = 54, 
    	A8B8G8R8_UINT_PACK32                           = 55, 
    	A8B8G8R8_SINT_PACK32                           = 56, 
    	A8B8G8R8_SRGB_PACK32                           = 57, 
    	A2R10G10B10_UNORM_PACK32                       = 58, 
    	A2R10G10B10_SNORM_PACK32                       = 59, 
    	A2R10G10B10_USCALED_PACK32                     = 60, 
    	A2R10G10B10_SSCALED_PACK32                     = 61, 
    	A2R10G10B10_UINT_PACK32                        = 62, 
    	A2R10G10B10_SINT_PACK32                        = 63, 
    	A2B10G10R10_UNORM_PACK32                       = 64, 
    	A2B10G10R10_SNORM_PACK32                       = 65, 
    	A2B10G10R10_USCALED_PACK32                     = 66, 
    	A2B10G10R10_SSCALED_PACK32                     = 67, 
    	A2B10G10R10_UINT_PACK32                        = 68, 
    	A2B10G10R10_SINT_PACK32                        = 69, 
    	R16_UNORM                                      = 70, 
    	R16_SNORM                                      = 71, 
    	R16_USCALED                                    = 72, 
    	R16_SSCALED                                    = 73, 
    	R16_UINT                                       = 74, 
    	R16_SINT                                       = 75, 
    	R16_SFLOAT                                     = 76, 
    	R16G16_UNORM                                   = 77, 
    	R16G16_SNORM                                   = 78, 
    	R16G16_USCALED                                 = 79, 
    	R16G16_SSCALED                                 = 80, 
    	R16G16_UINT                                    = 81, 
    	R16G16_SINT                                    = 82, 
    	R16G16_SFLOAT                                  = 83, 
    	R16G16B16_UNORM                                = 84, 
    	R16G16B16_SNORM                                = 85, 
    	R16G16B16_USCALED                              = 86, 
    	R16G16B16_SSCALED                              = 87, 
    	R16G16B16_UINT                                 = 88, 
    	R16G16B16_SINT                                 = 89, 
    	R16G16B16_SFLOAT                               = 90, 
    	R16G16B16A16_UNORM                             = 91, 
    	R16G16B16A16_SNORM                             = 92, 
    	R16G16B16A16_USCALED                           = 93, 
    	R16G16B16A16_SSCALED                           = 94, 
    	R16G16B16A16_UINT                              = 95, 
    	R16G16B16A16_SINT                              = 96, 
    	R16G16B16A16_SFLOAT                            = 97, 
    	R32_UINT                                       = 98, 
    	R32_SINT                                       = 99, 
    	R32_SFLOAT                                     = 100, 
    	R32G32_UINT                                    = 101, 
    	R32G32_SINT                                    = 102, 
    	R32G32_SFLOAT                                  = 103, 
    	R32G32B32_UINT                                 = 104, 
    	R32G32B32_SINT                                 = 105, 
    	R32G32B32_SFLOAT                               = 106, 
    	R32G32B32A32_UINT                              = 107, 
    	R32G32B32A32_SINT                              = 108, 
    	R32G32B32A32_SFLOAT                            = 109, 
    	R64_UINT                                       = 110, 
    	R64_SINT                                       = 111, 
    	R64_SFLOAT                                     = 112, 
    	R64G64_UINT                                    = 113, 
    	R64G64_SINT                                    = 114, 
    	R64G64_SFLOAT                                  = 115, 
    	R64G64B64_UINT                                 = 116, 
    	R64G64B64_SINT                                 = 117, 
    	R64G64B64_SFLOAT                               = 118, 
    	R64G64B64A64_UINT                              = 119, 
    	R64G64B64A64_SINT                              = 120, 
    	R64G64B64A64_SFLOAT                            = 121, 
    	B10G11R11_UFLOAT_PACK32                        = 122, 
    	E5B9G9R9_UFLOAT_PACK32                         = 123, 
    	D16_UNORM                                      = 124, 
    	X8_D24_UNORM_PACK32                            = 125, 
    	D32_SFLOAT                                     = 126, 
    	S8_UINT                                        = 127, 
    	D16_UNORM_S8_UINT                              = 128, 
    	D24_UNORM_S8_UINT                              = 129, 
    	D32_SFLOAT_S8_UINT                             = 130, 
    	BC1_RGB_UNORM_BLOCK                            = 131, 
    	BC1_RGB_SRGB_BLOCK                             = 132, 
    	BC1_RGBA_UNORM_BLOCK                           = 133, 
    	BC1_RGBA_SRGB_BLOCK                            = 134, 
    	BC2_UNORM_BLOCK                                = 135, 
    	BC2_SRGB_BLOCK                                 = 136, 
    	BC3_UNORM_BLOCK                                = 137, 
    	BC3_SRGB_BLOCK                                 = 138, 
    	BC4_UNORM_BLOCK                                = 139, 
    	BC4_SNORM_BLOCK                                = 140, 
    	BC5_UNORM_BLOCK                                = 141, 
    	BC5_SNORM_BLOCK                                = 142, 
    	BC6H_UFLOAT_BLOCK                              = 143, 
    	BC6H_SFLOAT_BLOCK                              = 144, 
    	BC7_UNORM_BLOCK                                = 145, 
    	BC7_SRGB_BLOCK                                 = 146, 
    	ETC2_R8G8B8_UNORM_BLOCK                        = 147, 
    	ETC2_R8G8B8_SRGB_BLOCK                         = 148, 
    	ETC2_R8G8B8A1_UNORM_BLOCK                      = 149, 
    	ETC2_R8G8B8A1_SRGB_BLOCK                       = 150, 
    	ETC2_R8G8B8A8_UNORM_BLOCK                      = 151, 
    	ETC2_R8G8B8A8_SRGB_BLOCK                       = 152, 
    	EAC_R11_UNORM_BLOCK                            = 153, 
    	EAC_R11_SNORM_BLOCK                            = 154, 
    	EAC_R11G11_UNORM_BLOCK                         = 155, 
    	EAC_R11G11_SNORM_BLOCK                         = 156, 
    	ASTC_4x4_UNORM_BLOCK                           = 157, 
    	ASTC_4x4_SRGB_BLOCK                            = 158, 
    	ASTC_5x4_UNORM_BLOCK                           = 159, 
    	ASTC_5x4_SRGB_BLOCK                            = 160, 
    	ASTC_5x5_UNORM_BLOCK                           = 161, 
    	ASTC_5x5_SRGB_BLOCK                            = 162, 
    	ASTC_6x5_UNORM_BLOCK                           = 163, 
    	ASTC_6x5_SRGB_BLOCK                            = 164, 
    	ASTC_6x6_UNORM_BLOCK                           = 165, 
    	ASTC_6x6_SRGB_BLOCK                            = 166, 
    	ASTC_8x5_UNORM_BLOCK                           = 167, 
    	ASTC_8x5_SRGB_BLOCK                            = 168, 
    	ASTC_8x6_UNORM_BLOCK                           = 169, 
    	ASTC_8x6_SRGB_BLOCK                            = 170, 
    	ASTC_8x8_UNORM_BLOCK                           = 171, 
    	ASTC_8x8_SRGB_BLOCK                            = 172, 
    	ASTC_10x5_UNORM_BLOCK                          = 173, 
    	ASTC_10x5_SRGB_BLOCK                           = 174, 
    	ASTC_10x6_UNORM_BLOCK                          = 175, 
    	ASTC_10x6_SRGB_BLOCK                           = 176, 
    	ASTC_10x8_UNORM_BLOCK                          = 177, 
    	ASTC_10x8_SRGB_BLOCK                           = 178, 
    	ASTC_10x10_UNORM_BLOCK                         = 179, 
    	ASTC_10x10_SRGB_BLOCK                          = 180, 
    	ASTC_12x10_UNORM_BLOCK                         = 181, 
    	ASTC_12x10_SRGB_BLOCK                          = 182, 
    	ASTC_12x12_UNORM_BLOCK                         = 183, 
    	ASTC_12x12_SRGB_BLOCK                          = 184, 
    	G8B8G8R8_422_UNORM                             = 1000156000, 
    	B8G8R8G8_422_UNORM                             = 1000156001, 
    	G8_B8_R8_3PLANE_420_UNORM                      = 1000156002, 
    	G8_B8R8_2PLANE_420_UNORM                       = 1000156003, 
    	G8_B8_R8_3PLANE_422_UNORM                      = 1000156004, 
    	G8_B8R8_2PLANE_422_UNORM                       = 1000156005, 
    	G8_B8_R8_3PLANE_444_UNORM                      = 1000156006, 
    	R10X6_UNORM_PACK16                             = 1000156007, 
    	R10X6G10X6_UNORM_2PACK16                       = 1000156008, 
    	R10X6G10X6B10X6A10X6_UNORM_4PACK16             = 1000156009, 
    	G10X6B10X6G10X6R10X6_422_UNORM_4PACK16         = 1000156010, 
    	B10X6G10X6R10X6G10X6_422_UNORM_4PACK16         = 1000156011, 
    	G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16     = 1000156012, 
    	G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16      = 1000156013, 
    	G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16     = 1000156014, 
    	G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16      = 1000156015, 
    	G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16     = 1000156016, 
    	R12X4_UNORM_PACK16                             = 1000156017, 
    	R12X4G12X4_UNORM_2PACK16                       = 1000156018, 
    	R12X4G12X4B12X4A12X4_UNORM_4PACK16             = 1000156019, 
    	G12X4B12X4G12X4R12X4_422_UNORM_4PACK16         = 1000156020, 
    	B12X4G12X4R12X4G12X4_422_UNORM_4PACK16         = 1000156021, 
    	G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16     = 1000156022, 
    	G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16      = 1000156023, 
    	G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16     = 1000156024, 
    	G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16      = 1000156025, 
    	G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16     = 1000156026, 
    	G16B16G16R16_422_UNORM                         = 1000156027, 
    	B16G16R16G16_422_UNORM                         = 1000156028, 
    	G16_B16_R16_3PLANE_420_UNORM                   = 1000156029, 
    	G16_B16R16_2PLANE_420_UNORM                    = 1000156030, 
    	G16_B16_R16_3PLANE_422_UNORM                   = 1000156031, 
    	G16_B16R16_2PLANE_422_UNORM                    = 1000156032, 
    	G16_B16_R16_3PLANE_444_UNORM                   = 1000156033, 
    	G8_B8R8_2PLANE_444_UNORM                       = 1000330000, 
    	G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16      = 1000330001, 
    	G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16      = 1000330002, 
    	G16_B16R16_2PLANE_444_UNORM                    = 1000330003, 
    	A4R4G4B4_UNORM_PACK16                          = 1000340000, 
    	A4B4G4R4_UNORM_PACK16                          = 1000340001, 
    	ASTC_4x4_SFLOAT_BLOCK                          = 1000066000, 
    	ASTC_5x4_SFLOAT_BLOCK                          = 1000066001, 
    	ASTC_5x5_SFLOAT_BLOCK                          = 1000066002, 
    	ASTC_6x5_SFLOAT_BLOCK                          = 1000066003, 
    	ASTC_6x6_SFLOAT_BLOCK                          = 1000066004, 
    	ASTC_8x5_SFLOAT_BLOCK                          = 1000066005, 
    	ASTC_8x6_SFLOAT_BLOCK                          = 1000066006, 
    	ASTC_8x8_SFLOAT_BLOCK                          = 1000066007, 
    	ASTC_10x5_SFLOAT_BLOCK                         = 1000066008, 
    	ASTC_10x6_SFLOAT_BLOCK                         = 1000066009, 
    	ASTC_10x8_SFLOAT_BLOCK                         = 1000066010, 
    	ASTC_10x10_SFLOAT_BLOCK                        = 1000066011, 
    	ASTC_12x10_SFLOAT_BLOCK                        = 1000066012, 
    	ASTC_12x12_SFLOAT_BLOCK                        = 1000066013, 
    	PVRTC1_2BPP_UNORM_BLOCK_IMG                    = 1000054000, 
    	PVRTC1_4BPP_UNORM_BLOCK_IMG                    = 1000054001, 
    	PVRTC2_2BPP_UNORM_BLOCK_IMG                    = 1000054002, 
    	PVRTC2_4BPP_UNORM_BLOCK_IMG                    = 1000054003, 
    	PVRTC1_2BPP_SRGB_BLOCK_IMG                     = 1000054004, 
    	PVRTC1_4BPP_SRGB_BLOCK_IMG                     = 1000054005, 
    	PVRTC2_2BPP_SRGB_BLOCK_IMG                     = 1000054006, 
    	PVRTC2_4BPP_SRGB_BLOCK_IMG                     = 1000054007, 
    	R16G16_S10_5_NV                                = 1000464000, 
    	ASTC_4x4_SFLOAT_BLOCK_EXT                      = 1000066000, 
    	ASTC_5x4_SFLOAT_BLOCK_EXT                      = 1000066001, 
    	ASTC_5x5_SFLOAT_BLOCK_EXT                      = 1000066002, 
    	ASTC_6x5_SFLOAT_BLOCK_EXT                      = 1000066003, 
    	ASTC_6x6_SFLOAT_BLOCK_EXT                      = 1000066004, 
    	ASTC_8x5_SFLOAT_BLOCK_EXT                      = 1000066005, 
    	ASTC_8x6_SFLOAT_BLOCK_EXT                      = 1000066006, 
    	ASTC_8x8_SFLOAT_BLOCK_EXT                      = 1000066007, 
    	ASTC_10x5_SFLOAT_BLOCK_EXT                     = 1000066008, 
    	ASTC_10x6_SFLOAT_BLOCK_EXT                     = 1000066009, 
    	ASTC_10x8_SFLOAT_BLOCK_EXT                     = 1000066010, 
    	ASTC_10x10_SFLOAT_BLOCK_EXT                    = 1000066011, 
    	ASTC_12x10_SFLOAT_BLOCK_EXT                    = 1000066012, 
    	ASTC_12x12_SFLOAT_BLOCK_EXT                    = 1000066013, 
    	G8B8G8R8_422_UNORM_KHR                         = 1000156000, 
    	B8G8R8G8_422_UNORM_KHR                         = 1000156001, 
    	G8_B8_R8_3PLANE_420_UNORM_KHR                  = 1000156002, 
    	G8_B8R8_2PLANE_420_UNORM_KHR                   = 1000156003, 
    	G8_B8_R8_3PLANE_422_UNORM_KHR                  = 1000156004, 
    	G8_B8R8_2PLANE_422_UNORM_KHR                   = 1000156005, 
    	G8_B8_R8_3PLANE_444_UNORM_KHR                  = 1000156006, 
    	R10X6_UNORM_PACK16_KHR                         = 1000156007, 
    	R10X6G10X6_UNORM_2PACK16_KHR                   = 1000156008, 
    	R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR         = 1000156009, 
    	G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR     = 1000156010, 
    	B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR     = 1000156011, 
    	G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR = 1000156012, 
    	G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR  = 1000156013, 
    	G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR = 1000156014, 
    	G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR  = 1000156015, 
    	G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR = 1000156016, 
    	R12X4_UNORM_PACK16_KHR                         = 1000156017, 
    	R12X4G12X4_UNORM_2PACK16_KHR                   = 1000156018, 
    	R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR         = 1000156019, 
    	G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR     = 1000156020, 
    	B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR     = 1000156021, 
    	G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR = 1000156022, 
    	G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR  = 1000156023, 
    	G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR = 1000156024, 
    	G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR  = 1000156025, 
    	G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR = 1000156026, 
    	G16B16G16R16_422_UNORM_KHR                     = 1000156027, 
    	B16G16R16G16_422_UNORM_KHR                     = 1000156028, 
    	G16_B16_R16_3PLANE_420_UNORM_KHR               = 1000156029, 
    	G16_B16R16_2PLANE_420_UNORM_KHR                = 1000156030, 
    	G16_B16_R16_3PLANE_422_UNORM_KHR               = 1000156031, 
    	G16_B16R16_2PLANE_422_UNORM_KHR                = 1000156032, 
    	G16_B16_R16_3PLANE_444_UNORM_KHR               = 1000156033, 
    	G8_B8R8_2PLANE_444_UNORM_EXT                   = 1000330000, 
    	G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT  = 1000330001, 
    	G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT  = 1000330002, 
    	G16_B16R16_2PLANE_444_UNORM_EXT                = 1000330003, 
    	A4R4G4B4_UNORM_PACK16_EXT                      = 1000340000, 
    	A4B4G4R4_UNORM_PACK16_EXT                      = 1000340001, 
    }

    FormatFeatureFlag ¶

    FormatFeatureFlag :: enum Flags {
    	SAMPLED_IMAGE                                                               = 0, 
    	STORAGE_IMAGE                                                               = 1, 
    	STORAGE_IMAGE_ATOMIC                                                        = 2, 
    	UNIFORM_TEXEL_BUFFER                                                        = 3, 
    	STORAGE_TEXEL_BUFFER                                                        = 4, 
    	STORAGE_TEXEL_BUFFER_ATOMIC                                                 = 5, 
    	VERTEX_BUFFER                                                               = 6, 
    	COLOR_ATTACHMENT                                                            = 7, 
    	COLOR_ATTACHMENT_BLEND                                                      = 8, 
    	DEPTH_STENCIL_ATTACHMENT                                                    = 9, 
    	BLIT_SRC                                                                    = 10, 
    	BLIT_DST                                                                    = 11, 
    	SAMPLED_IMAGE_FILTER_LINEAR                                                 = 12, 
    	TRANSFER_SRC                                                                = 14, 
    	TRANSFER_DST                                                                = 15, 
    	MIDPOINT_CHROMA_SAMPLES                                                     = 17, 
    	SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER                                = 18, 
    	SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER               = 19, 
    	SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT               = 20, 
    	SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE     = 21, 
    	DISJOINT                                                                    = 22, 
    	COSITED_CHROMA_SAMPLES                                                      = 23, 
    	SAMPLED_IMAGE_FILTER_MINMAX                                                 = 16, 
    	VIDEO_DECODE_OUTPUT_KHR                                                     = 25, 
    	VIDEO_DECODE_DPB_KHR                                                        = 26, 
    	ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR                                    = 29, 
    	SAMPLED_IMAGE_FILTER_CUBIC_EXT                                              = 13, 
    	FRAGMENT_DENSITY_MAP_EXT                                                    = 24, 
    	FRAGMENT_SHADING_RATE_ATTACHMENT_KHR                                        = 30, 
    	VIDEO_ENCODE_INPUT_KHR                                                      = 27, 
    	VIDEO_ENCODE_DPB_KHR                                                        = 28, 
    	SAMPLED_IMAGE_FILTER_CUBIC_IMG                                              = 13, 
    	TRANSFER_SRC_KHR                                                            = 14, 
    	TRANSFER_DST_KHR                                                            = 15, 
    	SAMPLED_IMAGE_FILTER_MINMAX_EXT                                             = 16, 
    	MIDPOINT_CHROMA_SAMPLES_KHR                                                 = 17, 
    	SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_KHR                            = 18, 
    	SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_KHR           = 19, 
    	SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_KHR           = 20, 
    	SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_KHR = 21, 
    	DISJOINT_KHR                                                                = 22, 
    	COSITED_CHROMA_SAMPLES_KHR                                                  = 23, 
    }

    FormatFeatureFlag2 ¶

    FormatFeatureFlag2 :: enum Flags64 {
    	SAMPLED_IMAGE                                                               = 0, 
    	SAMPLED_IMAGE_KHR                                                           = 0, 
    	STORAGE_IMAGE                                                               = 1, 
    	STORAGE_IMAGE_KHR                                                           = 1, 
    	STORAGE_IMAGE_ATOMIC                                                        = 2, 
    	STORAGE_IMAGE_ATOMIC_KHR                                                    = 2, 
    	UNIFORM_TEXEL_BUFFER                                                        = 3, 
    	UNIFORM_TEXEL_BUFFER_KHR                                                    = 3, 
    	STORAGE_TEXEL_BUFFER                                                        = 4, 
    	STORAGE_TEXEL_BUFFER_KHR                                                    = 4, 
    	STORAGE_TEXEL_BUFFER_ATOMIC                                                 = 5, 
    	STORAGE_TEXEL_BUFFER_ATOMIC_KHR                                             = 5, 
    	VERTEX_BUFFER                                                               = 6, 
    	VERTEX_BUFFER_KHR                                                           = 6, 
    	COLOR_ATTACHMENT                                                            = 7, 
    	COLOR_ATTACHMENT_KHR                                                        = 7, 
    	COLOR_ATTACHMENT_BLEND                                                      = 8, 
    	COLOR_ATTACHMENT_BLEND_KHR                                                  = 8, 
    	DEPTH_STENCIL_ATTACHMENT                                                    = 9, 
    	DEPTH_STENCIL_ATTACHMENT_KHR                                                = 9, 
    	BLIT_SRC                                                                    = 10, 
    	BLIT_SRC_KHR                                                                = 10, 
    	BLIT_DST                                                                    = 11, 
    	BLIT_DST_KHR                                                                = 11, 
    	SAMPLED_IMAGE_FILTER_LINEAR                                                 = 12, 
    	SAMPLED_IMAGE_FILTER_LINEAR_KHR                                             = 12, 
    	SAMPLED_IMAGE_FILTER_CUBIC                                                  = 13, 
    	SAMPLED_IMAGE_FILTER_CUBIC_EXT                                              = 13, 
    	TRANSFER_SRC                                                                = 14, 
    	TRANSFER_SRC_KHR                                                            = 14, 
    	TRANSFER_DST                                                                = 15, 
    	TRANSFER_DST_KHR                                                            = 15, 
    	SAMPLED_IMAGE_FILTER_MINMAX                                                 = 16, 
    	SAMPLED_IMAGE_FILTER_MINMAX_KHR                                             = 16, 
    	MIDPOINT_CHROMA_SAMPLES                                                     = 17, 
    	MIDPOINT_CHROMA_SAMPLES_KHR                                                 = 17, 
    	SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER                                = 18, 
    	SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_KHR                            = 18, 
    	SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER               = 19, 
    	SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_KHR           = 19, 
    	SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT               = 20, 
    	SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_KHR           = 20, 
    	SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE     = 21, 
    	SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_KHR = 21, 
    	DISJOINT                                                                    = 22, 
    	DISJOINT_KHR                                                                = 22, 
    	COSITED_CHROMA_SAMPLES                                                      = 23, 
    	COSITED_CHROMA_SAMPLES_KHR                                                  = 23, 
    	STORAGE_READ_WITHOUT_FORMAT                                                 = 31, 
    	STORAGE_READ_WITHOUT_FORMAT_KHR                                             = 31, 
    	STORAGE_WRITE_WITHOUT_FORMAT                                                = 32, 
    	STORAGE_WRITE_WITHOUT_FORMAT_KHR                                            = 32, 
    	SAMPLED_IMAGE_DEPTH_COMPARISON                                              = 33, 
    	SAMPLED_IMAGE_DEPTH_COMPARISON_KHR                                          = 33, 
    	VIDEO_DECODE_OUTPUT_KHR                                                     = 25, 
    	VIDEO_DECODE_DPB_KHR                                                        = 26, 
    	ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR                                    = 29, 
    	FRAGMENT_DENSITY_MAP_EXT                                                    = 24, 
    	FRAGMENT_SHADING_RATE_ATTACHMENT_KHR                                        = 30, 
    	VIDEO_ENCODE_INPUT_KHR                                                      = 27, 
    	VIDEO_ENCODE_DPB_KHR                                                        = 28, 
    	LINEAR_COLOR_ATTACHMENT_NV                                                  = 38, 
    	WEIGHT_IMAGE_QCOM                                                           = 34, 
    	WEIGHT_SAMPLED_IMAGE_QCOM                                                   = 35, 
    	BLOCK_MATCHING_QCOM                                                         = 36, 
    	BOX_FILTER_SAMPLED_QCOM                                                     = 37, 
    	OPTICAL_FLOW_IMAGE_NV                                                       = 40, 
    	OPTICAL_FLOW_VECTOR_NV                                                      = 41, 
    	OPTICAL_FLOW_COST_NV                                                        = 42, 
    }

    FormatFeatureFlags ¶

    FormatFeatureFlags :: distinct bit_set[FormatFeatureFlag; Flags]

    FormatFeatureFlags2 ¶

    FormatFeatureFlags2 :: distinct bit_set[FormatFeatureFlag2; Flags64]

    FormatProperties ¶

    FormatProperties :: struct {
    	linearTilingFeatures:  FormatFeatureFlags,
    	optimalTilingFeatures: FormatFeatureFlags,
    	bufferFeatures:        FormatFeatureFlags,
    }

    FormatProperties2 ¶

    FormatProperties2 :: struct {
    	sType:            StructureType,
    	pNext:            rawptr,
    	formatProperties: FormatProperties,
    }

    FormatProperties3 ¶

    FormatProperties3 :: struct {
    	sType:                 StructureType,
    	pNext:                 rawptr,
    	linearTilingFeatures:  FormatFeatureFlags2,
    	optimalTilingFeatures: FormatFeatureFlags2,
    	bufferFeatures:        FormatFeatureFlags2,
    }

    FragmentShadingRateAttachmentInfoKHR ¶

    FragmentShadingRateAttachmentInfoKHR :: struct {
    	sType:                          StructureType,
    	pNext:                          rawptr,
    	pFragmentShadingRateAttachment: ^AttachmentReference2,
    	shadingRateAttachmentTexelSize: Extent2D,
    }

    FragmentShadingRateCombinerOpKHR ¶

    FragmentShadingRateCombinerOpKHR :: enum i32 {
    	KEEP    = 0, 
    	REPLACE = 1, 
    	MIN     = 2, 
    	MAX     = 3, 
    	MUL     = 4, 
    }

    FragmentShadingRateNV ¶

    FragmentShadingRateNV :: enum i32 {
    	_1_INVOCATION_PER_PIXEL      = 0, 
    	_1_INVOCATION_PER_1X2_PIXELS = 1, 
    	_1_INVOCATION_PER_2X1_PIXELS = 4, 
    	_1_INVOCATION_PER_2X2_PIXELS = 5, 
    	_1_INVOCATION_PER_2X4_PIXELS = 6, 
    	_1_INVOCATION_PER_4X2_PIXELS = 9, 
    	_1_INVOCATION_PER_4X4_PIXELS = 10, 
    	_2_INVOCATIONS_PER_PIXEL     = 11, 
    	_4_INVOCATIONS_PER_PIXEL     = 12, 
    	_8_INVOCATIONS_PER_PIXEL     = 13, 
    	_16_INVOCATIONS_PER_PIXEL    = 14, 
    	NO_INVOCATIONS               = 15, 
    }

    FragmentShadingRateTypeNV ¶

    FragmentShadingRateTypeNV :: enum i32 {
    	FRAGMENT_SIZE = 0, 
    	ENUMS         = 1, 
    }

    Framebuffer ¶

    Framebuffer :: distinct u64

    FramebufferAttachmentImageInfo ¶

    FramebufferAttachmentImageInfo :: struct {
    	sType:           StructureType,
    	pNext:           rawptr,
    	flags:           ImageCreateFlags,
    	usage:           ImageUsageFlags,
    	width:           u32,
    	height:          u32,
    	layerCount:      u32,
    	viewFormatCount: u32,
    	pViewFormats:    [^]Format,
    }

    FramebufferAttachmentsCreateInfo ¶

    FramebufferAttachmentsCreateInfo :: struct {
    	sType:                    StructureType,
    	pNext:                    rawptr,
    	attachmentImageInfoCount: u32,
    	pAttachmentImageInfos:    [^]FramebufferAttachmentImageInfo,
    }

    FramebufferCreateFlag ¶

    FramebufferCreateFlag :: enum Flags {
    	IMAGELESS     = 0, 
    	IMAGELESS_KHR = 0, 
    }

    FramebufferCreateFlags ¶

    FramebufferCreateFlags :: distinct bit_set[FramebufferCreateFlag; Flags]

    FramebufferCreateInfo ¶

    FramebufferCreateInfo :: struct {
    	sType:           StructureType,
    	pNext:           rawptr,
    	flags:           FramebufferCreateFlags,
    	renderPass:      RenderPass,
    	attachmentCount: u32,
    	pAttachments:    [^]ImageView,
    	width:           u32,
    	height:          u32,
    	layers:          u32,
    }

    FramebufferMixedSamplesCombinationNV ¶

    FramebufferMixedSamplesCombinationNV :: struct {
    	sType:                 StructureType,
    	pNext:                 rawptr,
    	coverageReductionMode: CoverageReductionModeNV,
    	rasterizationSamples:  SampleCountFlags,
    	depthStencilSamples:   SampleCountFlags,
    	colorSamples:          SampleCountFlags,
    }

    FrontFace ¶

    FrontFace :: enum i32 {
    	COUNTER_CLOCKWISE = 0, 
    	CLOCKWISE         = 1, 
    }

    FullScreenExclusiveEXT ¶

    FullScreenExclusiveEXT :: enum i32 {
    	DEFAULT                = 0, 
    	ALLOWED                = 1, 
    	DISALLOWED             = 2, 
    	APPLICATION_CONTROLLED = 3, 
    }

    GeneratedCommandsInfoNV ¶

    GeneratedCommandsInfoNV :: struct {
    	sType:                  StructureType,
    	pNext:                  rawptr,
    	pipelineBindPoint:      PipelineBindPoint,
    	pipeline:               Pipeline,
    	indirectCommandsLayout: IndirectCommandsLayoutNV,
    	streamCount:            u32,
    	pStreams:               [^]IndirectCommandsStreamNV,
    	sequencesCount:         u32,
    	preprocessBuffer:       Buffer,
    	preprocessOffset:       DeviceSize,
    	preprocessSize:         DeviceSize,
    	sequencesCountBuffer:   Buffer,
    	sequencesCountOffset:   DeviceSize,
    	sequencesIndexBuffer:   Buffer,
    	sequencesIndexOffset:   DeviceSize,
    }

    GeneratedCommandsMemoryRequirementsInfoNV ¶

    GeneratedCommandsMemoryRequirementsInfoNV :: struct {
    	sType:                  StructureType,
    	pNext:                  rawptr,
    	pipelineBindPoint:      PipelineBindPoint,
    	pipeline:               Pipeline,
    	indirectCommandsLayout: IndirectCommandsLayoutNV,
    	maxSequencesCount:      u32,
    }

    GeometryAABBNV ¶

    GeometryAABBNV :: struct {
    	sType:    StructureType,
    	pNext:    rawptr,
    	aabbData: Buffer,
    	numAABBs: u32,
    	stride:   u32,
    	offset:   DeviceSize,
    }

    GeometryDataNV ¶

    GeometryDataNV :: struct {
    	triangles: GeometryTrianglesNV,
    	aabbs:     GeometryAABBNV,
    }

    GeometryFlagKHR ¶

    GeometryFlagKHR :: enum Flags {
    	OPAQUE                             = 0, 
    	NO_DUPLICATE_ANY_HIT_INVOCATION    = 1, 
    	OPAQUE_NV                          = 0, 
    	NO_DUPLICATE_ANY_HIT_INVOCATION_NV = 1, 
    }

    GeometryFlagsKHR ¶

    GeometryFlagsKHR :: distinct bit_set[GeometryFlagKHR; Flags]

    GeometryInstanceFlagKHR ¶

    GeometryInstanceFlagKHR :: enum Flags {
    	TRIANGLE_FACING_CULL_DISABLE       = 0, 
    	TRIANGLE_FLIP_FACING               = 1, 
    	FORCE_OPAQUE                       = 2, 
    	FORCE_NO_OPAQUE                    = 3, 
    	FORCE_OPACITY_MICROMAP_2_STATE_EXT = 4, 
    	DISABLE_OPACITY_MICROMAPS_EXT      = 5, 
    	TRIANGLE_FRONT_COUNTERCLOCKWISE    = 1, 
    	TRIANGLE_CULL_DISABLE_NV           = 0, 
    	TRIANGLE_FRONT_COUNTERCLOCKWISE_NV = 1, 
    	FORCE_OPAQUE_NV                    = 2, 
    	FORCE_NO_OPAQUE_NV                 = 3, 
    }

    GeometryInstanceFlagsKHR ¶

    GeometryInstanceFlagsKHR :: distinct bit_set[GeometryInstanceFlagKHR; Flags]

    GeometryNV ¶

    GeometryNV :: struct {
    	sType:        StructureType,
    	pNext:        rawptr,
    	geometryType: GeometryTypeKHR,
    	geometry:     GeometryDataNV,
    	flags:        GeometryFlagsKHR,
    }

    GeometryTrianglesNV ¶

    GeometryTrianglesNV :: struct {
    	sType:           StructureType,
    	pNext:           rawptr,
    	vertexData:      Buffer,
    	vertexOffset:    DeviceSize,
    	vertexCount:     u32,
    	vertexStride:    DeviceSize,
    	vertexFormat:    Format,
    	indexData:       Buffer,
    	indexOffset:     DeviceSize,
    	indexCount:      u32,
    	indexType:       IndexType,
    	transformData:   Buffer,
    	transformOffset: DeviceSize,
    }

    GeometryTypeKHR ¶

    GeometryTypeKHR :: enum i32 {
    	TRIANGLES    = 0, 
    	AABBS        = 1, 
    	INSTANCES    = 2, 
    	TRIANGLES_NV = 0, 
    	AABBS_NV     = 1, 
    }

    GraphicsPipelineCreateInfo ¶

    GraphicsPipelineCreateInfo :: struct {
    	sType:               StructureType,
    	pNext:               rawptr,
    	flags:               PipelineCreateFlags,
    	stageCount:          u32,
    	pStages:             [^]PipelineShaderStageCreateInfo,
    	pVertexInputState:   ^PipelineVertexInputStateCreateInfo,
    	pInputAssemblyState: ^PipelineInputAssemblyStateCreateInfo,
    	pTessellationState:  ^PipelineTessellationStateCreateInfo,
    	pViewportState:      ^PipelineViewportStateCreateInfo,
    	pRasterizationState: ^PipelineRasterizationStateCreateInfo,
    	pMultisampleState:   ^PipelineMultisampleStateCreateInfo,
    	pDepthStencilState:  ^PipelineDepthStencilStateCreateInfo,
    	pColorBlendState:    ^PipelineColorBlendStateCreateInfo,
    	pDynamicState:       ^PipelineDynamicStateCreateInfo,
    	layout:              PipelineLayout,
    	renderPass:          RenderPass,
    	subpass:             u32,
    	basePipelineHandle:  Pipeline,
    	basePipelineIndex:   i32,
    }

    GraphicsPipelineLibraryCreateInfoEXT ¶

    GraphicsPipelineLibraryCreateInfoEXT :: struct {
    	sType: StructureType,
    	pNext: rawptr,
    	flags: GraphicsPipelineLibraryFlagsEXT,
    }

    GraphicsPipelineLibraryFlagEXT ¶

    GraphicsPipelineLibraryFlagEXT :: enum Flags {
    	VERTEX_INPUT_INTERFACE    = 0, 
    	PRE_RASTERIZATION_SHADERS = 1, 
    	FRAGMENT_SHADER           = 2, 
    	FRAGMENT_OUTPUT_INTERFACE = 3, 
    }

    GraphicsPipelineLibraryFlagsEXT ¶

    GraphicsPipelineLibraryFlagsEXT :: distinct bit_set[GraphicsPipelineLibraryFlagEXT; Flags]

    GraphicsPipelineShaderGroupsCreateInfoNV ¶

    GraphicsPipelineShaderGroupsCreateInfoNV :: struct {
    	sType:         StructureType,
    	pNext:         rawptr,
    	groupCount:    u32,
    	pGroups:       [^]GraphicsShaderGroupCreateInfoNV,
    	pipelineCount: u32,
    	pPipelines:    [^]Pipeline,
    }

    GraphicsShaderGroupCreateInfoNV ¶

    GraphicsShaderGroupCreateInfoNV :: struct {
    	sType:              StructureType,
    	pNext:              rawptr,
    	stageCount:         u32,
    	pStages:            [^]PipelineShaderStageCreateInfo,
    	pVertexInputState:  ^PipelineVertexInputStateCreateInfo,
    	pTessellationState: ^PipelineTessellationStateCreateInfo,
    }

    HANDLE ¶

    HANDLE :: sys_windows.HANDLE

    HINSTANCE ¶

    HINSTANCE :: sys_windows.HANDLE

    HMONITOR ¶

    HMONITOR :: sys_windows.HMONITOR

    HWND ¶

    HWND :: sys_windows.HWND

    Handle ¶

    Handle :: distinct rawptr

    HdrMetadataEXT ¶

    HdrMetadataEXT :: struct {
    	sType:                     StructureType,
    	pNext:                     rawptr,
    	displayPrimaryRed:         XYColorEXT,
    	displayPrimaryGreen:       XYColorEXT,
    	displayPrimaryBlue:        XYColorEXT,
    	whitePoint:                XYColorEXT,
    	maxLuminance:              f32,
    	minLuminance:              f32,
    	maxContentLightLevel:      f32,
    	maxFrameAverageLightLevel: f32,
    }

    HeadlessSurfaceCreateFlagEXT ¶

    HeadlessSurfaceCreateFlagEXT :: enum u32 {
    }

    HeadlessSurfaceCreateFlagsEXT ¶

    HeadlessSurfaceCreateFlagsEXT :: distinct bit_set[HeadlessSurfaceCreateFlagEXT; Flags]

    HeadlessSurfaceCreateInfoEXT ¶

    HeadlessSurfaceCreateInfoEXT :: struct {
    	sType: StructureType,
    	pNext: rawptr,
    	flags: HeadlessSurfaceCreateFlagsEXT,
    }

    IOSSurfaceCreateFlagMVK ¶

    IOSSurfaceCreateFlagMVK :: enum u32 {
    }

    IOSSurfaceCreateFlagsMVK ¶

    IOSSurfaceCreateFlagsMVK :: distinct bit_set[IOSSurfaceCreateFlagMVK; Flags]

    IOSSurfaceCreateInfoMVK ¶

    IOSSurfaceCreateInfoMVK :: struct {
    	sType: StructureType,
    	pNext: rawptr,
    	flags: IOSSurfaceCreateFlagsMVK,
    	pView: rawptr,
    }

    IOSurfaceRef ¶

    IOSurfaceRef :: struct {}
     

    Opaque struct defined by Apple’s CoreGraphics framework

    Image ¶

    Image :: distinct u64

    ImageAspectFlag ¶

    ImageAspectFlag :: enum Flags {
    	COLOR              = 0, 
    	DEPTH              = 1, 
    	STENCIL            = 2, 
    	METADATA           = 3, 
    	PLANE_0            = 4, 
    	PLANE_1            = 5, 
    	PLANE_2            = 6, 
    	MEMORY_PLANE_0_EXT = 7, 
    	MEMORY_PLANE_1_EXT = 8, 
    	MEMORY_PLANE_2_EXT = 9, 
    	MEMORY_PLANE_3_EXT = 10, 
    	PLANE_0_KHR        = 4, 
    	PLANE_1_KHR        = 5, 
    	PLANE_2_KHR        = 6, 
    }

    ImageAspectFlags ¶

    ImageAspectFlags :: distinct bit_set[ImageAspectFlag; Flags]
    Related Constants

    ImageBlit ¶

    ImageBlit :: struct {
    	srcSubresource: ImageSubresourceLayers,
    	srcOffsets:     [2]Offset3D,
    	dstSubresource: ImageSubresourceLayers,
    	dstOffsets:     [2]Offset3D,
    }

    ImageBlit2 ¶

    ImageBlit2 :: struct {
    	sType:          StructureType,
    	pNext:          rawptr,
    	srcSubresource: ImageSubresourceLayers,
    	srcOffsets:     [2]Offset3D,
    	dstSubresource: ImageSubresourceLayers,
    	dstOffsets:     [2]Offset3D,
    }

    ImageCaptureDescriptorDataInfoEXT ¶

    ImageCaptureDescriptorDataInfoEXT :: struct {
    	sType: StructureType,
    	pNext: rawptr,
    	image: Image,
    }

    ImageCompressionControlEXT ¶

    ImageCompressionControlEXT :: struct {
    	sType:                        StructureType,
    	pNext:                        rawptr,
    	flags:                        ImageCompressionFlagsEXT,
    	compressionControlPlaneCount: u32,
    	pFixedRateFlags:              [^]ImageCompressionFixedRateFlagsEXT,
    }

    ImageCompressionFixedRateFlagEXT ¶

    ImageCompressionFixedRateFlagEXT :: enum Flags {
    	_1BPC  = 0, 
    	_2BPC  = 1, 
    	_3BPC  = 2, 
    	_4BPC  = 3, 
    	_5BPC  = 4, 
    	_6BPC  = 5, 
    	_7BPC  = 6, 
    	_8BPC  = 7, 
    	_9BPC  = 8, 
    	_10BPC = 9, 
    	_11BPC = 10, 
    	_12BPC = 11, 
    	_13BPC = 12, 
    	_14BPC = 13, 
    	_15BPC = 14, 
    	_16BPC = 15, 
    	_17BPC = 16, 
    	_18BPC = 17, 
    	_19BPC = 18, 
    	_20BPC = 19, 
    	_21BPC = 20, 
    	_22BPC = 21, 
    	_23BPC = 22, 
    	_24BPC = 23, 
    }

    ImageCompressionFixedRateFlagsEXT ¶

    ImageCompressionFixedRateFlagsEXT :: distinct bit_set[ImageCompressionFixedRateFlagEXT; Flags]
    Related Constants

    ImageCompressionFlagEXT ¶

    ImageCompressionFlagEXT :: enum Flags {
    	FIXED_RATE_DEFAULT  = 0, 
    	FIXED_RATE_EXPLICIT = 1, 
    	DISABLED            = 2, 
    }

    ImageCompressionFlagsEXT ¶

    ImageCompressionFlagsEXT :: distinct bit_set[ImageCompressionFlagEXT; Flags]
    Related Constants

    ImageCompressionPropertiesEXT ¶

    ImageCompressionPropertiesEXT :: struct {
    	sType:                          StructureType,
    	pNext:                          rawptr,
    	imageCompressionFlags:          ImageCompressionFlagsEXT,
    	imageCompressionFixedRateFlags: ImageCompressionFixedRateFlagsEXT,
    }

    ImageCopy ¶

    ImageCopy :: struct {
    	srcSubresource: ImageSubresourceLayers,
    	srcOffset:      Offset3D,
    	dstSubresource: ImageSubresourceLayers,
    	dstOffset:      Offset3D,
    	extent:         Extent3D,
    }

    ImageCopy2 ¶

    ImageCopy2 :: struct {
    	sType:          StructureType,
    	pNext:          rawptr,
    	srcSubresource: ImageSubresourceLayers,
    	srcOffset:      Offset3D,
    	dstSubresource: ImageSubresourceLayers,
    	dstOffset:      Offset3D,
    	extent:         Extent3D,
    }

    ImageCreateFlag ¶

    ImageCreateFlag :: enum Flags {
    	SPARSE_BINDING                            = 0, 
    	SPARSE_RESIDENCY                          = 1, 
    	SPARSE_ALIASED                            = 2, 
    	MUTABLE_FORMAT                            = 3, 
    	CUBE_COMPATIBLE                           = 4, 
    	ALIAS                                     = 10, 
    	SPLIT_INSTANCE_BIND_REGIONS               = 6, 
    	D2_ARRAY_COMPATIBLE                       = 5, 
    	BLOCK_TEXEL_VIEW_COMPATIBLE               = 7, 
    	EXTENDED_USAGE                            = 8, 
    	PROTECTED                                 = 11, 
    	DISJOINT                                  = 9, 
    	CORNER_SAMPLED_NV                         = 13, 
    	SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT     = 12, 
    	SUBSAMPLED_EXT                            = 14, 
    	DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT      = 16, 
    	MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_EXT = 18, 
    	D2_VIEW_COMPATIBLE_EXT                    = 17, 
    	FRAGMENT_DENSITY_MAP_OFFSET_QCOM          = 15, 
    	SPLIT_INSTANCE_BIND_REGIONS_KHR           = 6, 
    	D2_ARRAY_COMPATIBLE_KHR                   = 5, 
    	BLOCK_TEXEL_VIEW_COMPATIBLE_KHR           = 7, 
    	EXTENDED_USAGE_KHR                        = 8, 
    	DISJOINT_KHR                              = 9, 
    	ALIAS_KHR                                 = 10, 
    }

    ImageCreateFlags ¶

    ImageCreateFlags :: distinct bit_set[ImageCreateFlag; Flags]

    ImageCreateInfo ¶

    ImageCreateInfo :: struct {
    	sType:                 StructureType,
    	pNext:                 rawptr,
    	flags:                 ImageCreateFlags,
    	imageType:             ImageType,
    	format:                Format,
    	extent:                Extent3D,
    	mipLevels:             u32,
    	arrayLayers:           u32,
    	samples:               SampleCountFlags,
    	tiling:                ImageTiling,
    	usage:                 ImageUsageFlags,
    	sharingMode:           SharingMode,
    	queueFamilyIndexCount: u32,
    	pQueueFamilyIndices:   [^]u32,
    	initialLayout:         ImageLayout,
    }

    ImageDrmFormatModifierExplicitCreateInfoEXT ¶

    ImageDrmFormatModifierExplicitCreateInfoEXT :: struct {
    	sType:                       StructureType,
    	pNext:                       rawptr,
    	drmFormatModifier:           u64,
    	drmFormatModifierPlaneCount: u32,
    	pPlaneLayouts:               [^]SubresourceLayout,
    }

    ImageDrmFormatModifierListCreateInfoEXT ¶

    ImageDrmFormatModifierListCreateInfoEXT :: struct {
    	sType:                  StructureType,
    	pNext:                  rawptr,
    	drmFormatModifierCount: u32,
    	pDrmFormatModifiers:    [^]u64,
    }

    ImageDrmFormatModifierPropertiesEXT ¶

    ImageDrmFormatModifierPropertiesEXT :: struct {
    	sType:             StructureType,
    	pNext:             rawptr,
    	drmFormatModifier: u64,
    }

    ImageFormatListCreateInfo ¶

    ImageFormatListCreateInfo :: struct {
    	sType:           StructureType,
    	pNext:           rawptr,
    	viewFormatCount: u32,
    	pViewFormats:    [^]Format,
    }

    ImageFormatProperties ¶

    ImageFormatProperties :: struct {
    	maxExtent:       Extent3D,
    	maxMipLevels:    u32,
    	maxArrayLayers:  u32,
    	sampleCounts:    SampleCountFlags,
    	maxResourceSize: DeviceSize,
    }

    ImageFormatProperties2 ¶

    ImageFormatProperties2 :: struct {
    	sType:                 StructureType,
    	pNext:                 rawptr,
    	imageFormatProperties: ImageFormatProperties,
    }

    ImageLayout ¶

    ImageLayout :: enum i32 {
    	UNDEFINED                                      = 0, 
    	GENERAL                                        = 1, 
    	COLOR_ATTACHMENT_OPTIMAL                       = 2, 
    	DEPTH_STENCIL_ATTACHMENT_OPTIMAL               = 3, 
    	DEPTH_STENCIL_READ_ONLY_OPTIMAL                = 4, 
    	SHADER_READ_ONLY_OPTIMAL                       = 5, 
    	TRANSFER_SRC_OPTIMAL                           = 6, 
    	TRANSFER_DST_OPTIMAL                           = 7, 
    	PREINITIALIZED                                 = 8, 
    	DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL     = 1000117000, 
    	DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL     = 1000117001, 
    	DEPTH_ATTACHMENT_OPTIMAL                       = 1000241000, 
    	DEPTH_READ_ONLY_OPTIMAL                        = 1000241001, 
    	STENCIL_ATTACHMENT_OPTIMAL                     = 1000241002, 
    	STENCIL_READ_ONLY_OPTIMAL                      = 1000241003, 
    	READ_ONLY_OPTIMAL                              = 1000314000, 
    	ATTACHMENT_OPTIMAL                             = 1000314001, 
    	PRESENT_SRC_KHR                                = 1000001002, 
    	VIDEO_DECODE_DST_KHR                           = 1000024000, 
    	VIDEO_DECODE_SRC_KHR                           = 1000024001, 
    	VIDEO_DECODE_DPB_KHR                           = 1000024002, 
    	SHARED_PRESENT_KHR                             = 1000111000, 
    	FRAGMENT_DENSITY_MAP_OPTIMAL_EXT               = 1000218000, 
    	FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR   = 1000164003, 
    	VIDEO_ENCODE_DST_KHR                           = 1000299000, 
    	VIDEO_ENCODE_SRC_KHR                           = 1000299001, 
    	VIDEO_ENCODE_DPB_KHR                           = 1000299002, 
    	ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT           = 1000339000, 
    	DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR = 1000117000, 
    	DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR = 1000117001, 
    	SHADING_RATE_OPTIMAL_NV                        = 1000164003, 
    	DEPTH_ATTACHMENT_OPTIMAL_KHR                   = 1000241000, 
    	DEPTH_READ_ONLY_OPTIMAL_KHR                    = 1000241001, 
    	STENCIL_ATTACHMENT_OPTIMAL_KHR                 = 1000241002, 
    	STENCIL_READ_ONLY_OPTIMAL_KHR                  = 1000241003, 
    	READ_ONLY_OPTIMAL_KHR                          = 1000314000, 
    	ATTACHMENT_OPTIMAL_KHR                         = 1000314001, 
    }

    ImageMemoryBarrier ¶

    ImageMemoryBarrier :: struct {
    	sType:               StructureType,
    	pNext:               rawptr,
    	srcAccessMask:       AccessFlags,
    	dstAccessMask:       AccessFlags,
    	oldLayout:           ImageLayout,
    	newLayout:           ImageLayout,
    	srcQueueFamilyIndex: u32,
    	dstQueueFamilyIndex: u32,
    	image:               Image,
    	subresourceRange:    ImageSubresourceRange,
    }

    ImageMemoryBarrier2 ¶

    ImageMemoryBarrier2 :: struct {
    	sType:               StructureType,
    	pNext:               rawptr,
    	srcStageMask:        PipelineStageFlags2,
    	srcAccessMask:       AccessFlags2,
    	dstStageMask:        PipelineStageFlags2,
    	dstAccessMask:       AccessFlags2,
    	oldLayout:           ImageLayout,
    	newLayout:           ImageLayout,
    	srcQueueFamilyIndex: u32,
    	dstQueueFamilyIndex: u32,
    	image:               Image,
    	subresourceRange:    ImageSubresourceRange,
    }

    ImageMemoryRequirementsInfo2 ¶

    ImageMemoryRequirementsInfo2 :: struct {
    	sType: StructureType,
    	pNext: rawptr,
    	image: Image,
    }

    ImagePlaneMemoryRequirementsInfo ¶

    ImagePlaneMemoryRequirementsInfo :: struct {
    	sType:       StructureType,
    	pNext:       rawptr,
    	planeAspect: ImageAspectFlags,
    }

    ImageResolve ¶

    ImageResolve :: struct {
    	srcSubresource: ImageSubresourceLayers,
    	srcOffset:      Offset3D,
    	dstSubresource: ImageSubresourceLayers,
    	dstOffset:      Offset3D,
    	extent:         Extent3D,
    }

    ImageResolve2 ¶

    ImageResolve2 :: struct {
    	sType:          StructureType,
    	pNext:          rawptr,
    	srcSubresource: ImageSubresourceLayers,
    	srcOffset:      Offset3D,
    	dstSubresource: ImageSubresourceLayers,
    	dstOffset:      Offset3D,
    	extent:         Extent3D,
    }

    ImageSparseMemoryRequirementsInfo2 ¶

    ImageSparseMemoryRequirementsInfo2 :: struct {
    	sType: StructureType,
    	pNext: rawptr,
    	image: Image,
    }

    ImageStencilUsageCreateInfo ¶

    ImageStencilUsageCreateInfo :: struct {
    	sType:        StructureType,
    	pNext:        rawptr,
    	stencilUsage: ImageUsageFlags,
    }

    ImageSubresource ¶

    ImageSubresource :: struct {
    	aspectMask: ImageAspectFlags,
    	mipLevel:   u32,
    	arrayLayer: u32,
    }

    ImageSubresource2EXT ¶

    ImageSubresource2EXT :: struct {
    	sType:            StructureType,
    	pNext:            rawptr,
    	imageSubresource: ImageSubresource,
    }

    ImageSubresourceLayers ¶

    ImageSubresourceLayers :: struct {
    	aspectMask:     ImageAspectFlags,
    	mipLevel:       u32,
    	baseArrayLayer: u32,
    	layerCount:     u32,
    }

    ImageSubresourceRange ¶

    ImageSubresourceRange :: struct {
    	aspectMask:     ImageAspectFlags,
    	baseMipLevel:   u32,
    	levelCount:     u32,
    	baseArrayLayer: u32,
    	layerCount:     u32,
    }

    ImageSwapchainCreateInfoKHR ¶

    ImageSwapchainCreateInfoKHR :: struct {
    	sType:     StructureType,
    	pNext:     rawptr,
    	swapchain: SwapchainKHR,
    }

    ImageTiling ¶

    ImageTiling :: enum i32 {
    	OPTIMAL                 = 0, 
    	LINEAR                  = 1, 
    	DRM_FORMAT_MODIFIER_EXT = 1000158000, 
    }

    ImageType ¶

    ImageType :: enum i32 {
    	D1 = 0, 
    	D2 = 1, 
    	D3 = 2, 
    }

    ImageUsageFlag ¶

    ImageUsageFlag :: enum Flags {
    	TRANSFER_SRC                         = 0, 
    	TRANSFER_DST                         = 1, 
    	SAMPLED                              = 2, 
    	STORAGE                              = 3, 
    	COLOR_ATTACHMENT                     = 4, 
    	DEPTH_STENCIL_ATTACHMENT             = 5, 
    	TRANSIENT_ATTACHMENT                 = 6, 
    	INPUT_ATTACHMENT                     = 7, 
    	VIDEO_DECODE_DST_KHR                 = 10, 
    	VIDEO_DECODE_SRC_KHR                 = 11, 
    	VIDEO_DECODE_DPB_KHR                 = 12, 
    	FRAGMENT_DENSITY_MAP_EXT             = 9, 
    	FRAGMENT_SHADING_RATE_ATTACHMENT_KHR = 8, 
    	VIDEO_ENCODE_DST_KHR                 = 13, 
    	VIDEO_ENCODE_SRC_KHR                 = 14, 
    	VIDEO_ENCODE_DPB_KHR                 = 15, 
    	ATTACHMENT_FEEDBACK_LOOP_EXT         = 19, 
    	INVOCATION_MASK_HUAWEI               = 18, 
    	SAMPLE_WEIGHT_QCOM                   = 20, 
    	SAMPLE_BLOCK_MATCH_QCOM              = 21, 
    	SHADING_RATE_IMAGE_NV                = 8, 
    }

    ImageUsageFlags ¶

    ImageUsageFlags :: distinct bit_set[ImageUsageFlag; Flags]

    ImageView ¶

    ImageView :: distinct u64

    ImageViewASTCDecodeModeEXT ¶

    ImageViewASTCDecodeModeEXT :: struct {
    	sType:      StructureType,
    	pNext:      rawptr,
    	decodeMode: Format,
    }

    ImageViewAddressPropertiesNVX ¶

    ImageViewAddressPropertiesNVX :: struct {
    	sType:         StructureType,
    	pNext:         rawptr,
    	deviceAddress: DeviceAddress,
    	size:          DeviceSize,
    }

    ImageViewCaptureDescriptorDataInfoEXT ¶

    ImageViewCaptureDescriptorDataInfoEXT :: struct {
    	sType:     StructureType,
    	pNext:     rawptr,
    	imageView: ImageView,
    }

    ImageViewCreateFlag ¶

    ImageViewCreateFlag :: enum Flags {
    	FRAGMENT_DENSITY_MAP_DYNAMIC_EXT     = 0, 
    	DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT = 2, 
    	FRAGMENT_DENSITY_MAP_DEFERRED_EXT    = 1, 
    }

    ImageViewCreateFlags ¶

    ImageViewCreateFlags :: distinct bit_set[ImageViewCreateFlag; Flags]

    ImageViewCreateInfo ¶

    ImageViewCreateInfo :: struct {
    	sType:            StructureType,
    	pNext:            rawptr,
    	flags:            ImageViewCreateFlags,
    	image:            Image,
    	viewType:         ImageViewType,
    	format:           Format,
    	components:       ComponentMapping,
    	subresourceRange: ImageSubresourceRange,
    }

    ImageViewHandleInfoNVX ¶

    ImageViewHandleInfoNVX :: struct {
    	sType:          StructureType,
    	pNext:          rawptr,
    	imageView:      ImageView,
    	descriptorType: DescriptorType,
    	sampler:        Sampler,
    }

    ImageViewMinLodCreateInfoEXT ¶

    ImageViewMinLodCreateInfoEXT :: struct {
    	sType:  StructureType,
    	pNext:  rawptr,
    	minLod: f32,
    }

    ImageViewSampleWeightCreateInfoQCOM ¶

    ImageViewSampleWeightCreateInfoQCOM :: struct {
    	sType:        StructureType,
    	pNext:        rawptr,
    	filterCenter: Offset2D,
    	filterSize:   Extent2D,
    	numPhases:    u32,
    }

    ImageViewSlicedCreateInfoEXT ¶

    ImageViewSlicedCreateInfoEXT :: struct {
    	sType:       StructureType,
    	pNext:       rawptr,
    	sliceOffset: u32,
    	sliceCount:  u32,
    }

    ImageViewType ¶

    ImageViewType :: enum i32 {
    	D1         = 0, 
    	D2         = 1, 
    	D3         = 2, 
    	CUBE       = 3, 
    	D1_ARRAY   = 4, 
    	D2_ARRAY   = 5, 
    	CUBE_ARRAY = 6, 
    }

    ImageViewUsageCreateInfo ¶

    ImageViewUsageCreateInfo :: struct {
    	sType: StructureType,
    	pNext: rawptr,
    	usage: ImageUsageFlags,
    }

    ImportFenceFdInfoKHR ¶

    ImportFenceFdInfoKHR :: struct {
    	sType:      StructureType,
    	pNext:      rawptr,
    	fence:      Fence,
    	flags:      FenceImportFlags,
    	handleType: ExternalFenceHandleTypeFlags,
    	fd:         i32,
    }

    ImportFenceWin32HandleInfoKHR ¶

    ImportFenceWin32HandleInfoKHR :: struct {
    	sType:      StructureType,
    	pNext:      rawptr,
    	fence:      Fence,
    	flags:      FenceImportFlags,
    	handleType: ExternalFenceHandleTypeFlags,
    	handle:     sys_windows.HANDLE,
    	name:       [^]u16,
    }

    ImportMemoryFdInfoKHR ¶

    ImportMemoryFdInfoKHR :: struct {
    	sType:      StructureType,
    	pNext:      rawptr,
    	handleType: ExternalMemoryHandleTypeFlags,
    	fd:         i32,
    }

    ImportMemoryHostPointerInfoEXT ¶

    ImportMemoryHostPointerInfoEXT :: struct {
    	sType:        StructureType,
    	pNext:        rawptr,
    	handleType:   ExternalMemoryHandleTypeFlags,
    	pHostPointer: rawptr,
    }

    ImportMemoryWin32HandleInfoKHR ¶

    ImportMemoryWin32HandleInfoKHR :: struct {
    	sType:      StructureType,
    	pNext:      rawptr,
    	handleType: ExternalMemoryHandleTypeFlags,
    	handle:     sys_windows.HANDLE,
    	name:       [^]u16,
    }

    ImportMemoryWin32HandleInfoNV ¶

    ImportMemoryWin32HandleInfoNV :: struct {
    	sType:      StructureType,
    	pNext:      rawptr,
    	handleType: ExternalMemoryHandleTypeFlagsNV,
    	handle:     sys_windows.HANDLE,
    }

    ImportMetalBufferInfoEXT ¶

    ImportMetalBufferInfoEXT :: struct {
    	sType:     StructureType,
    	pNext:     rawptr,
    	mtlBuffer: rawptr,
    }

    ImportMetalIOSurfaceInfoEXT ¶

    ImportMetalIOSurfaceInfoEXT :: struct {
    	sType:     StructureType,
    	pNext:     rawptr,
    	ioSurface: IOSurfaceRef,
    }

    ImportMetalSharedEventInfoEXT ¶

    ImportMetalSharedEventInfoEXT :: struct {
    	sType:          StructureType,
    	pNext:          rawptr,
    	mtlSharedEvent: rawptr,
    }

    ImportMetalTextureInfoEXT ¶

    ImportMetalTextureInfoEXT :: struct {
    	sType:      StructureType,
    	pNext:      rawptr,
    	plane:      ImageAspectFlags,
    	mtlTexture: rawptr,
    }

    ImportSemaphoreFdInfoKHR ¶

    ImportSemaphoreFdInfoKHR :: struct {
    	sType:      StructureType,
    	pNext:      rawptr,
    	semaphore:  Semaphore,
    	flags:      SemaphoreImportFlags,
    	handleType: ExternalSemaphoreHandleTypeFlags,
    	fd:         i32,
    }

    ImportSemaphoreWin32HandleInfoKHR ¶

    ImportSemaphoreWin32HandleInfoKHR :: struct {
    	sType:      StructureType,
    	pNext:      rawptr,
    	semaphore:  Semaphore,
    	flags:      SemaphoreImportFlags,
    	handleType: ExternalSemaphoreHandleTypeFlags,
    	handle:     sys_windows.HANDLE,
    	name:       [^]u16,
    }

    IndexType ¶

    IndexType :: enum i32 {
    	UINT16    = 0, 
    	UINT32    = 1, 
    	NONE_KHR  = 1000165000, 
    	UINT8_EXT = 1000265000, 
    	NONE_NV   = 1000165000, 
    }

    IndirectCommandsLayoutCreateInfoNV ¶

    IndirectCommandsLayoutCreateInfoNV :: struct {
    	sType:             StructureType,
    	pNext:             rawptr,
    	flags:             IndirectCommandsLayoutUsageFlagsNV,
    	pipelineBindPoint: PipelineBindPoint,
    	tokenCount:        u32,
    	pTokens:           [^]IndirectCommandsLayoutTokenNV,
    	streamCount:       u32,
    	pStreamStrides:    [^]u32,
    }

    IndirectCommandsLayoutNV ¶

    IndirectCommandsLayoutNV :: distinct u64

    IndirectCommandsLayoutTokenNV ¶

    IndirectCommandsLayoutTokenNV :: struct {
    	sType:                        StructureType,
    	pNext:                        rawptr,
    	tokenType:                    IndirectCommandsTokenTypeNV,
    	stream:                       u32,
    	offset:                       u32,
    	vertexBindingUnit:            u32,
    	vertexDynamicStride:          b32,
    	pushconstantPipelineLayout:   PipelineLayout,
    	pushconstantShaderStageFlags: ShaderStageFlags,
    	pushconstantOffset:           u32,
    	pushconstantSize:             u32,
    	indirectStateFlags:           IndirectStateFlagsNV,
    	indexTypeCount:               u32,
    	pIndexTypes:                  [^]IndexType,
    	pIndexTypeValues:             [^]u32,
    }

    IndirectCommandsLayoutUsageFlagNV ¶

    IndirectCommandsLayoutUsageFlagNV :: enum Flags {
    	EXPLICIT_PREPROCESS = 0, 
    	INDEXED_SEQUENCES   = 1, 
    	UNORDERED_SEQUENCES = 2, 
    }

    IndirectCommandsLayoutUsageFlagsNV ¶

    IndirectCommandsLayoutUsageFlagsNV :: distinct bit_set[IndirectCommandsLayoutUsageFlagNV; Flags]

    IndirectCommandsStreamNV ¶

    IndirectCommandsStreamNV :: struct {
    	buffer: Buffer,
    	offset: DeviceSize,
    }

    IndirectCommandsTokenTypeNV ¶

    IndirectCommandsTokenTypeNV :: enum i32 {
    	SHADER_GROUP    = 0, 
    	STATE_FLAGS     = 1, 
    	INDEX_BUFFER    = 2, 
    	VERTEX_BUFFER   = 3, 
    	PUSH_CONSTANT   = 4, 
    	DRAW_INDEXED    = 5, 
    	DRAW            = 6, 
    	DRAW_TASKS      = 7, 
    	DRAW_MESH_TASKS = 1000328000, 
    }

    IndirectStateFlagNV ¶

    IndirectStateFlagNV :: enum Flags {
    	FLAG_FRONTFACE = 0, 
    }

    IndirectStateFlagsNV ¶

    IndirectStateFlagsNV :: distinct bit_set[IndirectStateFlagNV; Flags]

    InitializePerformanceApiInfoINTEL ¶

    InitializePerformanceApiInfoINTEL :: struct {
    	sType:     StructureType,
    	pNext:     rawptr,
    	pUserData: rawptr,
    }

    InputAttachmentAspectReference ¶

    InputAttachmentAspectReference :: struct {
    	subpass:              u32,
    	inputAttachmentIndex: u32,
    	aspectMask:           ImageAspectFlags,
    }

    Instance ¶

    Instance :: distinct rawptr
     

    Handles types

    Related Procedures With Parameters

    InstanceCreateFlag ¶

    InstanceCreateFlag :: enum Flags {
    	ENUMERATE_PORTABILITY_KHR = 0, 
    }

    InstanceCreateFlags ¶

    InstanceCreateFlags :: distinct bit_set[InstanceCreateFlag; Flags]

    InstanceCreateInfo ¶

    InstanceCreateInfo :: struct {
    	sType:                   StructureType,
    	pNext:                   rawptr,
    	flags:                   InstanceCreateFlags,
    	pApplicationInfo:        ^ApplicationInfo,
    	enabledLayerCount:       u32,
    	ppEnabledLayerNames:     [^]cstring,
    	enabledExtensionCount:   u32,
    	ppEnabledExtensionNames: [^]cstring,
    }

    InternalAllocationType ¶

    InternalAllocationType :: enum i32 {
    	EXECUTABLE = 0, 
    }

    LPCWSTR ¶

    LPCWSTR :: [^]u16

    LUID ¶

    LUID :: sys_windows.LUID

    LayerProperties ¶

    LayerProperties :: struct {
    	layerName:             [256]u8,
    	specVersion:           u32,
    	implementationVersion: u32,
    	description:           [256]u8,
    }

    LineRasterizationModeEXT ¶

    LineRasterizationModeEXT :: enum i32 {
    	DEFAULT            = 0, 
    	RECTANGULAR        = 1, 
    	BRESENHAM          = 2, 
    	RECTANGULAR_SMOOTH = 3, 
    }

    LogicOp ¶

    LogicOp :: enum i32 {
    	CLEAR         = 0, 
    	AND           = 1, 
    	AND_REVERSE   = 2, 
    	COPY          = 3, 
    	AND_INVERTED  = 4, 
    	NO_OP         = 5, 
    	XOR           = 6, 
    	OR            = 7, 
    	NOR           = 8, 
    	EQUIVALENT    = 9, 
    	INVERT        = 10, 
    	OR_REVERSE    = 11, 
    	COPY_INVERTED = 12, 
    	OR_INVERTED   = 13, 
    	NAND          = 14, 
    	SET           = 15, 
    }

    MTLBuffer_id ¶

    MTLBuffer_id :: rawptr

    MTLCommandQueue_id ¶

    MTLCommandQueue_id :: rawptr

    MTLDevice_id ¶

    MTLDevice_id :: rawptr

    MTLSharedEvent_id ¶

    MTLSharedEvent_id :: rawptr

    MTLTexture_id ¶

    MTLTexture_id :: rawptr

    MacOSSurfaceCreateFlagMVK ¶

    MacOSSurfaceCreateFlagMVK :: enum u32 {
    }

    MacOSSurfaceCreateFlagsMVK ¶

    MacOSSurfaceCreateFlagsMVK :: distinct bit_set[MacOSSurfaceCreateFlagMVK; Flags]

    MacOSSurfaceCreateInfoMVK ¶

    MacOSSurfaceCreateInfoMVK :: struct {
    	sType: StructureType,
    	pNext: rawptr,
    	flags: MacOSSurfaceCreateFlagsMVK,
    	pView: rawptr,
    }

    MappedMemoryRange ¶

    MappedMemoryRange :: struct {
    	sType:  StructureType,
    	pNext:  rawptr,
    	memory: DeviceMemory,
    	offset: DeviceSize,
    	size:   DeviceSize,
    }

    MemoryAllocateFlag ¶

    MemoryAllocateFlag :: enum Flags {
    	DEVICE_MASK                       = 0, 
    	DEVICE_ADDRESS                    = 1, 
    	DEVICE_ADDRESS_CAPTURE_REPLAY     = 2, 
    	DEVICE_MASK_KHR                   = 0, 
    	DEVICE_ADDRESS_KHR                = 1, 
    	DEVICE_ADDRESS_CAPTURE_REPLAY_KHR = 2, 
    }

    MemoryAllocateFlags ¶

    MemoryAllocateFlags :: distinct bit_set[MemoryAllocateFlag; Flags]

    MemoryAllocateFlagsInfo ¶

    MemoryAllocateFlagsInfo :: struct {
    	sType:      StructureType,
    	pNext:      rawptr,
    	flags:      MemoryAllocateFlags,
    	deviceMask: u32,
    }

    MemoryAllocateInfo ¶

    MemoryAllocateInfo :: struct {
    	sType:           StructureType,
    	pNext:           rawptr,
    	allocationSize:  DeviceSize,
    	memoryTypeIndex: u32,
    }

    MemoryBarrier ¶

    MemoryBarrier :: struct {
    	sType:         StructureType,
    	pNext:         rawptr,
    	srcAccessMask: AccessFlags,
    	dstAccessMask: AccessFlags,
    }

    MemoryBarrier2 ¶

    MemoryBarrier2 :: struct {
    	sType:         StructureType,
    	pNext:         rawptr,
    	srcStageMask:  PipelineStageFlags2,
    	srcAccessMask: AccessFlags2,
    	dstStageMask:  PipelineStageFlags2,
    	dstAccessMask: AccessFlags2,
    }

    MemoryDecompressionMethodFlagNV ¶

    MemoryDecompressionMethodFlagNV :: Flags64

    MemoryDecompressionMethodFlagsNV ¶

    MemoryDecompressionMethodFlagsNV :: Flags64

    MemoryDedicatedAllocateInfo ¶

    MemoryDedicatedAllocateInfo :: struct {
    	sType:  StructureType,
    	pNext:  rawptr,
    	image:  Image,
    	buffer: Buffer,
    }

    MemoryDedicatedRequirements ¶

    MemoryDedicatedRequirements :: struct {
    	sType:                       StructureType,
    	pNext:                       rawptr,
    	prefersDedicatedAllocation:  b32,
    	requiresDedicatedAllocation: b32,
    }

    MemoryFdPropertiesKHR ¶

    MemoryFdPropertiesKHR :: struct {
    	sType:          StructureType,
    	pNext:          rawptr,
    	memoryTypeBits: u32,
    }

    MemoryGetFdInfoKHR ¶

    MemoryGetFdInfoKHR :: struct {
    	sType:      StructureType,
    	pNext:      rawptr,
    	memory:     DeviceMemory,
    	handleType: ExternalMemoryHandleTypeFlags,
    }

    MemoryGetRemoteAddressInfoNV ¶

    MemoryGetRemoteAddressInfoNV :: struct {
    	sType:      StructureType,
    	pNext:      rawptr,
    	memory:     DeviceMemory,
    	handleType: ExternalMemoryHandleTypeFlags,
    }

    MemoryGetWin32HandleInfoKHR ¶

    MemoryGetWin32HandleInfoKHR :: struct {
    	sType:      StructureType,
    	pNext:      rawptr,
    	memory:     DeviceMemory,
    	handleType: ExternalMemoryHandleTypeFlags,
    }

    MemoryHeap ¶

    MemoryHeap :: struct {
    	size:  DeviceSize,
    	flags: MemoryHeapFlags,
    }

    MemoryHeapFlag ¶

    MemoryHeapFlag :: enum Flags {
    	DEVICE_LOCAL       = 0, 
    	MULTI_INSTANCE     = 1, 
    	MULTI_INSTANCE_KHR = 1, 
    }

    MemoryHeapFlags ¶

    MemoryHeapFlags :: distinct bit_set[MemoryHeapFlag; Flags]

    MemoryHostPointerPropertiesEXT ¶

    MemoryHostPointerPropertiesEXT :: struct {
    	sType:          StructureType,
    	pNext:          rawptr,
    	memoryTypeBits: u32,
    }

    MemoryMapFlag ¶

    MemoryMapFlag :: enum u32 {
    }

    MemoryMapFlags ¶

    MemoryMapFlags :: distinct bit_set[MemoryMapFlag; Flags]

    MemoryMapInfoKHR ¶

    MemoryMapInfoKHR :: struct {
    	sType:  StructureType,
    	pNext:  rawptr,
    	flags:  MemoryMapFlags,
    	memory: DeviceMemory,
    	offset: DeviceSize,
    	size:   DeviceSize,
    }

    MemoryOpaqueCaptureAddressAllocateInfo ¶

    MemoryOpaqueCaptureAddressAllocateInfo :: struct {
    	sType:                StructureType,
    	pNext:                rawptr,
    	opaqueCaptureAddress: u64,
    }

    MemoryOverallocationBehaviorAMD ¶

    MemoryOverallocationBehaviorAMD :: enum i32 {
    	DEFAULT    = 0, 
    	ALLOWED    = 1, 
    	DISALLOWED = 2, 
    }

    MemoryPriorityAllocateInfoEXT ¶

    MemoryPriorityAllocateInfoEXT :: struct {
    	sType:    StructureType,
    	pNext:    rawptr,
    	priority: f32,
    }

    MemoryPropertyFlag ¶

    MemoryPropertyFlag :: enum Flags {
    	DEVICE_LOCAL        = 0, 
    	HOST_VISIBLE        = 1, 
    	HOST_COHERENT       = 2, 
    	HOST_CACHED         = 3, 
    	LAZILY_ALLOCATED    = 4, 
    	PROTECTED           = 5, 
    	DEVICE_COHERENT_AMD = 6, 
    	DEVICE_UNCACHED_AMD = 7, 
    	RDMA_CAPABLE_NV     = 8, 
    }

    MemoryPropertyFlags ¶

    MemoryPropertyFlags :: distinct bit_set[MemoryPropertyFlag; Flags]

    MemoryRequirements ¶

    MemoryRequirements :: struct {
    	size:           DeviceSize,
    	alignment:      DeviceSize,
    	memoryTypeBits: u32,
    }

    MemoryRequirements2 ¶

    MemoryRequirements2 :: struct {
    	sType:              StructureType,
    	pNext:              rawptr,
    	memoryRequirements: MemoryRequirements,
    }

    MemoryType ¶

    MemoryType :: struct {
    	propertyFlags: MemoryPropertyFlags,
    	heapIndex:     u32,
    }

    MemoryUnmapFlagKHR ¶

    MemoryUnmapFlagKHR :: enum u32 {
    }

    MemoryUnmapFlagsKHR ¶

    MemoryUnmapFlagsKHR :: distinct bit_set[MemoryUnmapFlagKHR; Flags]

    MemoryUnmapInfoKHR ¶

    MemoryUnmapInfoKHR :: struct {
    	sType:  StructureType,
    	pNext:  rawptr,
    	flags:  MemoryUnmapFlagsKHR,
    	memory: DeviceMemory,
    }

    MemoryWin32HandlePropertiesKHR ¶

    MemoryWin32HandlePropertiesKHR :: struct {
    	sType:          StructureType,
    	pNext:          rawptr,
    	memoryTypeBits: u32,
    }

    MetalSurfaceCreateFlagEXT ¶

    MetalSurfaceCreateFlagEXT :: enum u32 {
    }

    MetalSurfaceCreateFlagsEXT ¶

    MetalSurfaceCreateFlagsEXT :: distinct bit_set[MetalSurfaceCreateFlagEXT; Flags]

    MetalSurfaceCreateInfoEXT ¶

    MetalSurfaceCreateInfoEXT :: struct {
    	sType:  StructureType,
    	pNext:  rawptr,
    	flags:  MetalSurfaceCreateFlagsEXT,
    	pLayer: ^CAMetalLayer,
    }

    MicromapBuildInfoEXT ¶

    MicromapBuildInfoEXT :: struct {
    	sType:               StructureType,
    	pNext:               rawptr,
    	type:                MicromapTypeEXT,
    	flags:               BuildMicromapFlagsEXT,
    	mode:                BuildMicromapModeEXT,
    	dstMicromap:         MicromapEXT,
    	usageCountsCount:    u32,
    	pUsageCounts:        [^]MicromapUsageEXT,
    	ppUsageCounts:       ^[^]MicromapUsageEXT,
    	data:                DeviceOrHostAddressConstKHR,
    	scratchData:         DeviceOrHostAddressKHR,
    	triangleArray:       DeviceOrHostAddressConstKHR,
    	triangleArrayStride: DeviceSize,
    }

    MicromapBuildSizesInfoEXT ¶

    MicromapBuildSizesInfoEXT :: struct {
    	sType:            StructureType,
    	pNext:            rawptr,
    	micromapSize:     DeviceSize,
    	buildScratchSize: DeviceSize,
    	discardable:      b32,
    }

    MicromapCreateFlagEXT ¶

    MicromapCreateFlagEXT :: enum Flags {
    	DEVICE_ADDRESS_CAPTURE_REPLAY = 0, 
    }

    MicromapCreateFlagsEXT ¶

    MicromapCreateFlagsEXT :: distinct bit_set[MicromapCreateFlagEXT; Flags]

    MicromapCreateInfoEXT ¶

    MicromapCreateInfoEXT :: struct {
    	sType:         StructureType,
    	pNext:         rawptr,
    	createFlags:   MicromapCreateFlagsEXT,
    	buffer:        Buffer,
    	offset:        DeviceSize,
    	size:          DeviceSize,
    	type:          MicromapTypeEXT,
    	deviceAddress: DeviceAddress,
    }

    MicromapEXT ¶

    MicromapEXT :: distinct u64

    MicromapTriangleEXT ¶

    MicromapTriangleEXT :: struct {
    	dataOffset:       u32,
    	subdivisionLevel: u16,
    	format:           u16,
    }

    MicromapTypeEXT ¶

    MicromapTypeEXT :: enum i32 {
    	OPACITY_MICROMAP         = 0, 
    	DISPLACEMENT_MICROMAP_NV = 1000397000, 
    }

    MicromapUsageEXT ¶

    MicromapUsageEXT :: struct {
    	count:            u32,
    	subdivisionLevel: u32,
    	format:           u32,
    }

    MicromapVersionInfoEXT ¶

    MicromapVersionInfoEXT :: struct {
    	sType:        StructureType,
    	pNext:        rawptr,
    	pVersionData: ^u8,
    }

    MultiDrawIndexedInfoEXT ¶

    MultiDrawIndexedInfoEXT :: struct {
    	firstIndex:   u32,
    	indexCount:   u32,
    	vertexOffset: i32,
    }

    MultiDrawInfoEXT ¶

    MultiDrawInfoEXT :: struct {
    	firstVertex: u32,
    	vertexCount: u32,
    }

    MultisamplePropertiesEXT ¶

    MultisamplePropertiesEXT :: struct {
    	sType:                     StructureType,
    	pNext:                     rawptr,
    	maxSampleLocationGridSize: Extent2D,
    }

    MultisampledRenderToSingleSampledInfoEXT ¶

    MultisampledRenderToSingleSampledInfoEXT :: struct {
    	sType:                                   StructureType,
    	pNext:                                   rawptr,
    	multisampledRenderToSingleSampledEnable: b32,
    	rasterizationSamples:                    SampleCountFlags,
    }

    MultiviewPerViewAttributesInfoNVX ¶

    MultiviewPerViewAttributesInfoNVX :: struct {
    	sType:                          StructureType,
    	pNext:                          rawptr,
    	perViewAttributes:              b32,
    	perViewAttributesPositionXOnly: b32,
    }

    MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM ¶

    MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM :: struct {
    	sType:                  StructureType,
    	pNext:                  rawptr,
    	perViewRenderAreaCount: u32,
    	pPerViewRenderAreas:    [^]Rect2D,
    }

    MutableDescriptorTypeCreateInfoEXT ¶

    MutableDescriptorTypeCreateInfoEXT :: struct {
    	sType:                          StructureType,
    	pNext:                          rawptr,
    	mutableDescriptorTypeListCount: u32,
    	pMutableDescriptorTypeLists:    [^]MutableDescriptorTypeListEXT,
    }

    MutableDescriptorTypeListEXT ¶

    MutableDescriptorTypeListEXT :: struct {
    	descriptorTypeCount: u32,
    	pDescriptorTypes:    [^]DescriptorType,
    }

    NonDispatchableHandle ¶

    NonDispatchableHandle :: distinct u64

    ObjectType ¶

    ObjectType :: enum i32 {
    	UNKNOWN                         = 0, 
    	INSTANCE                        = 1, 
    	PHYSICAL_DEVICE                 = 2, 
    	DEVICE                          = 3, 
    	QUEUE                           = 4, 
    	SEMAPHORE                       = 5, 
    	COMMAND_BUFFER                  = 6, 
    	FENCE                           = 7, 
    	DEVICE_MEMORY                   = 8, 
    	BUFFER                          = 9, 
    	IMAGE                           = 10, 
    	EVENT                           = 11, 
    	QUERY_POOL                      = 12, 
    	BUFFER_VIEW                     = 13, 
    	IMAGE_VIEW                      = 14, 
    	SHADER_MODULE                   = 15, 
    	PIPELINE_CACHE                  = 16, 
    	PIPELINE_LAYOUT                 = 17, 
    	RENDER_PASS                     = 18, 
    	PIPELINE                        = 19, 
    	DESCRIPTOR_SET_LAYOUT           = 20, 
    	SAMPLER                         = 21, 
    	DESCRIPTOR_POOL                 = 22, 
    	DESCRIPTOR_SET                  = 23, 
    	FRAMEBUFFER                     = 24, 
    	COMMAND_POOL                    = 25, 
    	SAMPLER_YCBCR_CONVERSION        = 1000156000, 
    	DESCRIPTOR_UPDATE_TEMPLATE      = 1000085000, 
    	PRIVATE_DATA_SLOT               = 1000295000, 
    	SURFACE_KHR                     = 1000000000, 
    	SWAPCHAIN_KHR                   = 1000001000, 
    	DISPLAY_KHR                     = 1000002000, 
    	DISPLAY_MODE_KHR                = 1000002001, 
    	DEBUG_REPORT_CALLBACK_EXT       = 1000011000, 
    	VIDEO_SESSION_KHR               = 1000023000, 
    	VIDEO_SESSION_PARAMETERS_KHR    = 1000023001, 
    	CU_MODULE_NVX                   = 1000029000, 
    	CU_FUNCTION_NVX                 = 1000029001, 
    	DEBUG_UTILS_MESSENGER_EXT       = 1000128000, 
    	ACCELERATION_STRUCTURE_KHR      = 1000150000, 
    	VALIDATION_CACHE_EXT            = 1000160000, 
    	ACCELERATION_STRUCTURE_NV       = 1000165000, 
    	PERFORMANCE_CONFIGURATION_INTEL = 1000210000, 
    	DEFERRED_OPERATION_KHR          = 1000268000, 
    	INDIRECT_COMMANDS_LAYOUT_NV     = 1000277000, 
    	BUFFER_COLLECTION_FUCHSIA       = 1000366000, 
    	MICROMAP_EXT                    = 1000396000, 
    	OPTICAL_FLOW_SESSION_NV         = 1000464000, 
    	SHADER_EXT                      = 1000482000, 
    	DESCRIPTOR_UPDATE_TEMPLATE_KHR  = 1000085000, 
    	SAMPLER_YCBCR_CONVERSION_KHR    = 1000156000, 
    	PRIVATE_DATA_SLOT_EXT           = 1000295000, 
    }

    Offset2D ¶

    Offset2D :: struct {
    	x: i32,
    	y: i32,
    }

    Offset3D ¶

    Offset3D :: struct {
    	x: i32,
    	y: i32,
    	z: i32,
    }

    OpacityMicromapFormatEXT ¶

    OpacityMicromapFormatEXT :: enum i32 {
    	_2_STATE = 1, 
    	_4_STATE = 2, 
    }

    OpacityMicromapSpecialIndexEXT ¶

    OpacityMicromapSpecialIndexEXT :: enum i32 {
    	FULLY_TRANSPARENT         = -1, 
    	FULLY_OPAQUE              = -2, 
    	FULLY_UNKNOWN_TRANSPARENT = -3, 
    	FULLY_UNKNOWN_OPAQUE      = -4, 
    }

    OpaqueCaptureDescriptorDataCreateInfoEXT ¶

    OpaqueCaptureDescriptorDataCreateInfoEXT :: struct {
    	sType:                       StructureType,
    	pNext:                       rawptr,
    	opaqueCaptureDescriptorData: rawptr,
    }

    OpticalFlowExecuteFlagNV ¶

    OpticalFlowExecuteFlagNV :: enum Flags {
    	DISABLE_TEMPORAL_HINTS = 0, 
    }

    OpticalFlowExecuteFlagsNV ¶

    OpticalFlowExecuteFlagsNV :: distinct bit_set[OpticalFlowExecuteFlagNV; Flags]

    OpticalFlowExecuteInfoNV ¶

    OpticalFlowExecuteInfoNV :: struct {
    	sType:       StructureType,
    	pNext:       rawptr,
    	flags:       OpticalFlowExecuteFlagsNV,
    	regionCount: u32,
    	pRegions:    [^]Rect2D,
    }

    OpticalFlowGridSizeFlagNV ¶

    OpticalFlowGridSizeFlagNV :: enum Flags {
    	_1X1 = 0, 
    	_2X2 = 1, 
    	_4X4 = 2, 
    	_8X8 = 3, 
    }

    OpticalFlowGridSizeFlagsNV ¶

    OpticalFlowGridSizeFlagsNV :: distinct bit_set[OpticalFlowGridSizeFlagNV; Flags]
    Related Constants

    OpticalFlowImageFormatInfoNV ¶

    OpticalFlowImageFormatInfoNV :: struct {
    	sType: StructureType,
    	pNext: rawptr,
    	usage: OpticalFlowUsageFlagsNV,
    }

    OpticalFlowImageFormatPropertiesNV ¶

    OpticalFlowImageFormatPropertiesNV :: struct {
    	sType:  StructureType,
    	pNext:  rawptr,
    	format: Format,
    }

    OpticalFlowPerformanceLevelNV ¶

    OpticalFlowPerformanceLevelNV :: enum i32 {
    	UNKNOWN = 0, 
    	SLOW    = 1, 
    	MEDIUM  = 2, 
    	FAST    = 3, 
    }

    OpticalFlowSessionBindingPointNV ¶

    OpticalFlowSessionBindingPointNV :: enum i32 {
    	UNKNOWN              = 0, 
    	INPUT                = 1, 
    	REFERENCE            = 2, 
    	HINT                 = 3, 
    	FLOW_VECTOR          = 4, 
    	BACKWARD_FLOW_VECTOR = 5, 
    	COST                 = 6, 
    	BACKWARD_COST        = 7, 
    	GLOBAL_FLOW          = 8, 
    }

    OpticalFlowSessionCreateFlagNV ¶

    OpticalFlowSessionCreateFlagNV :: enum Flags {
    	ENABLE_HINT        = 0, 
    	ENABLE_COST        = 1, 
    	ENABLE_GLOBAL_FLOW = 2, 
    	ALLOW_REGIONS      = 3, 
    	BOTH_DIRECTIONS    = 4, 
    }

    OpticalFlowSessionCreateFlagsNV ¶

    OpticalFlowSessionCreateFlagsNV :: distinct bit_set[OpticalFlowSessionCreateFlagNV; Flags]

    OpticalFlowSessionCreateInfoNV ¶

    OpticalFlowSessionCreateInfoNV :: struct {
    	sType:            StructureType,
    	pNext:            rawptr,
    	width:            u32,
    	height:           u32,
    	imageFormat:      Format,
    	flowVectorFormat: Format,
    	costFormat:       Format,
    	outputGridSize:   OpticalFlowGridSizeFlagsNV,
    	hintGridSize:     OpticalFlowGridSizeFlagsNV,
    	performanceLevel: OpticalFlowPerformanceLevelNV,
    	flags:            OpticalFlowSessionCreateFlagsNV,
    }

    OpticalFlowSessionCreatePrivateDataInfoNV ¶

    OpticalFlowSessionCreatePrivateDataInfoNV :: struct {
    	sType:        StructureType,
    	pNext:        rawptr,
    	id:           u32,
    	size:         u32,
    	pPrivateData: rawptr,
    }

    OpticalFlowSessionNV ¶

    OpticalFlowSessionNV :: distinct u64

    OpticalFlowUsageFlagNV ¶

    OpticalFlowUsageFlagNV :: enum Flags {
    	INPUT       = 0, 
    	OUTPUT      = 1, 
    	HINT        = 2, 
    	COST        = 3, 
    	GLOBAL_FLOW = 4, 
    }

    OpticalFlowUsageFlagsNV ¶

    OpticalFlowUsageFlagsNV :: distinct bit_set[OpticalFlowUsageFlagNV; Flags]
    Related Constants

    PastPresentationTimingGOOGLE ¶

    PastPresentationTimingGOOGLE :: struct {
    	presentID:           u32,
    	desiredPresentTime:  u64,
    	actualPresentTime:   u64,
    	earliestPresentTime: u64,
    	presentMargin:       u64,
    }

    PeerMemoryFeatureFlag ¶

    PeerMemoryFeatureFlag :: enum Flags {
    	COPY_SRC        = 0, 
    	COPY_DST        = 1, 
    	GENERIC_SRC     = 2, 
    	GENERIC_DST     = 3, 
    	COPY_SRC_KHR    = 0, 
    	COPY_DST_KHR    = 1, 
    	GENERIC_SRC_KHR = 2, 
    	GENERIC_DST_KHR = 3, 
    }

    PeerMemoryFeatureFlags ¶

    PeerMemoryFeatureFlags :: distinct bit_set[PeerMemoryFeatureFlag; Flags]

    PerformanceConfigurationAcquireInfoINTEL ¶

    PerformanceConfigurationAcquireInfoINTEL :: struct {
    	sType: StructureType,
    	pNext: rawptr,
    	type:  PerformanceConfigurationTypeINTEL,
    }

    PerformanceConfigurationINTEL ¶

    PerformanceConfigurationINTEL :: distinct u64

    PerformanceConfigurationTypeINTEL ¶

    PerformanceConfigurationTypeINTEL :: enum i32 {
    	PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL = 0, 
    }

    PerformanceCounterDescriptionFlagKHR ¶

    PerformanceCounterDescriptionFlagKHR :: enum Flags {
    	PERFORMANCE_IMPACTING = 0, 
    	CONCURRENTLY_IMPACTED = 1, 
    }

    PerformanceCounterDescriptionFlagsKHR ¶

    PerformanceCounterDescriptionFlagsKHR :: distinct bit_set[PerformanceCounterDescriptionFlagKHR; Flags]

    PerformanceCounterDescriptionKHR ¶

    PerformanceCounterDescriptionKHR :: struct {
    	sType:       StructureType,
    	pNext:       rawptr,
    	flags:       PerformanceCounterDescriptionFlagsKHR,
    	name:        [256]u8,
    	category:    [256]u8,
    	description: [256]u8,
    }

    PerformanceCounterKHR ¶

    PerformanceCounterKHR :: struct {
    	sType:   StructureType,
    	pNext:   rawptr,
    	unit:    PerformanceCounterUnitKHR,
    	scope:   PerformanceCounterScopeKHR,
    	storage: PerformanceCounterStorageKHR,
    	uuid:    [16]u8,
    }

    PerformanceCounterResultKHR ¶

    PerformanceCounterResultKHR :: struct #raw_union {
    	int32:   i32,
    	int64:   i64,
    	uint32:  u32,
    	uint64:  u64,
    	float32: f32,
    	float64: f64,
    }

    PerformanceCounterScopeKHR ¶

    PerformanceCounterScopeKHR :: enum i32 {
    	COMMAND_BUFFER             = 0, 
    	RENDER_PASS                = 1, 
    	COMMAND                    = 2, 
    	QUERY_SCOPE_COMMAND_BUFFER = 0, 
    	QUERY_SCOPE_RENDER_PASS    = 1, 
    	QUERY_SCOPE_COMMAND        = 2, 
    }

    PerformanceCounterStorageKHR ¶

    PerformanceCounterStorageKHR :: enum i32 {
    	INT32   = 0, 
    	INT64   = 1, 
    	UINT32  = 2, 
    	UINT64  = 3, 
    	FLOAT32 = 4, 
    	FLOAT64 = 5, 
    }