package vendor:vulkan

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 (1832)
Constants (768)
Variables (505)
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

AccelerationStructureCompatibilityKHR ¶

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

AccelerationStructureCreateFlagKHR ¶

AccelerationStructureCreateFlagKHR :: enum Flags {
	DEVICE_ADDRESS_CAPTURE_REPLAY = 0, 
	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,
	accelerationStructureReference: u64,
}

AccelerationStructureKHR ¶

AccelerationStructureKHR :: distinct u64

AccelerationStructureMatrixMotionInstanceNV ¶

AccelerationStructureMatrixMotionInstanceNV :: struct {
	transformT0:                    TransformMatrixKHR,
	transformT1:                    TransformMatrixKHR,
	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,
	accelerationStructureReference: u64,
}

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

AccessFlag2KHR ¶

AccessFlag2KHR :: Flags64

AccessFlags ¶

AccessFlags :: distinct bit_set[AccessFlag; Flags]

AccessFlags2KHR ¶

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

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

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

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, 
	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:        Flags64,
	srcAccessMask:       Flags64,
	dstStageMask:        Flags64,
	dstAccessMask:       Flags64,
	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, 
	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_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, 
}

CAMetalLayer ¶

CAMetalLayer :: struct($Key: typeid, $Value: typeid) where intrinsics.type_is_valid_map_key(Key) {}

CalibratedTimestampInfoEXT ¶

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

CheckpointData2NV ¶

CheckpointData2NV :: struct {
	sType:             StructureType,
	pNext:             rawptr,
	stage:             Flags64,
	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, 
}

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

CopyAccelerationStructureInfoKHR ¶

CopyAccelerationStructureInfoKHR :: struct {
	sType: StructureType,
	pNext: rawptr,
	src:   AccelerationStructureKHR,
	dst:   AccelerationStructureKHR,
	mode:  CopyAccelerationStructureModeKHR,
}

CopyAccelerationStructureModeKHR ¶

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

CopyAccelerationStructureToMemoryInfoKHR ¶

CopyAccelerationStructureToMemoryInfoKHR :: struct {
	sType: StructureType,
	pNext: rawptr,
	src:   AccelerationStructureKHR,
	dst:   DeviceOrHostAddressKHR,
	mode:  CopyAccelerationStructureModeKHR,
}

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

CopyMemoryToAccelerationStructureInfoKHR ¶

CopyMemoryToAccelerationStructureInfoKHR :: struct {
	sType: StructureType,
	pNext: rawptr,
	src:   DeviceOrHostAddressConstKHR,
	dst:   AccelerationStructureKHR,
	mode:  CopyAccelerationStructureModeKHR,
}

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]

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

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

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

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]

DescriptorBufferInfo ¶

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

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_VALVE       = 2, 
	UPDATE_AFTER_BIND_EXT = 1, 
}

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, 
	HOST_ONLY_POOL_VALVE       = 2, 
	UPDATE_AFTER_BIND_POOL_EXT = 1, 
}

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, 
	MUTABLE_VALVE              = 1000351000, 
	INLINE_UNIFORM_BLOCK_EXT   = 1000138000, 
}

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

DeviceAddress ¶

DeviceAddress :: distinct u64

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

DeviceDiagnosticsConfigFlagsNV ¶

DeviceDiagnosticsConfigFlagsNV :: distinct bit_set[DeviceDiagnosticsConfigFlagNV; Flags]

DeviceEventInfoEXT ¶

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

DeviceEventTypeEXT ¶

DeviceEventTypeEXT :: enum i32 {
	DISPLAY_HOTPLUG = 0, 
}

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,
	BuildAccelerationStructuresKHR:                  ProcBuildAccelerationStructuresKHR,
	CmdBeginConditionalRenderingEXT:                 ProcCmdBeginConditionalRenderingEXT,
	CmdBeginDebugUtilsLabelEXT:                      ProcCmdBeginDebugUtilsLabelEXT,
	CmdBeginQuery:                                   ProcCmdBeginQuery,
	CmdBeginQueryIndexedEXT:                         ProcCmdBeginQueryIndexedEXT,
	CmdBeginRenderPass:                              ProcCmdBeginRenderPass,
	CmdBeginRenderPass2:                             ProcCmdBeginRenderPass2,
	CmdBeginRenderPass2KHR:                          ProcCmdBeginRenderPass2KHR,
	CmdBeginRendering:                               ProcCmdBeginRendering,
	CmdBeginRenderingKHR:                            ProcCmdBeginRenderingKHR,
	CmdBeginTransformFeedbackEXT:                    ProcCmdBeginTransformFeedbackEXT,
	CmdBindDescriptorSets:                           ProcCmdBindDescriptorSets,
	CmdBindIndexBuffer:                              ProcCmdBindIndexBuffer,
	CmdBindInvocationMaskHUAWEI:                     ProcCmdBindInvocationMaskHUAWEI,
	CmdBindPipeline:                                 ProcCmdBindPipeline,
	CmdBindPipelineShaderGroupNV:                    ProcCmdBindPipelineShaderGroupNV,
	CmdBindShadingRateImageNV:                       ProcCmdBindShadingRateImageNV,
	CmdBindTransformFeedbackBuffersEXT:              ProcCmdBindTransformFeedbackBuffersEXT,
	CmdBindVertexBuffers:                            ProcCmdBindVertexBuffers,
	CmdBindVertexBuffers2:                           ProcCmdBindVertexBuffers2,
	CmdBindVertexBuffers2EXT:                        ProcCmdBindVertexBuffers2EXT,
	CmdBlitImage:                                    ProcCmdBlitImage,
	CmdBlitImage2:                                   ProcCmdBlitImage2,
	CmdBlitImage2KHR:                                ProcCmdBlitImage2KHR,
	CmdBuildAccelerationStructureNV:                 ProcCmdBuildAccelerationStructureNV,
	CmdBuildAccelerationStructuresIndirectKHR:       ProcCmdBuildAccelerationStructuresIndirectKHR,
	CmdBuildAccelerationStructuresKHR:               ProcCmdBuildAccelerationStructuresKHR,
	CmdClearAttachments:                             ProcCmdClearAttachments,
	CmdClearColorImage:                              ProcCmdClearColorImage,
	CmdClearDepthStencilImage:                       ProcCmdClearDepthStencilImage,
	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,
	CmdCopyMemoryToAccelerationStructureKHR:         ProcCmdCopyMemoryToAccelerationStructureKHR,
	CmdCopyQueryPoolResults:                         ProcCmdCopyQueryPoolResults,
	CmdCuLaunchKernelNVX:                            ProcCmdCuLaunchKernelNVX,
	CmdDebugMarkerBeginEXT:                          ProcCmdDebugMarkerBeginEXT,
	CmdDebugMarkerEndEXT:                            ProcCmdDebugMarkerEndEXT,
	CmdDebugMarkerInsertEXT:                         ProcCmdDebugMarkerInsertEXT,
	CmdDispatch:                                     ProcCmdDispatch,
	CmdDispatchBase:                                 ProcCmdDispatchBase,
	CmdDispatchBaseKHR:                              ProcCmdDispatchBaseKHR,
	CmdDispatchIndirect:                             ProcCmdDispatchIndirect,
	CmdDraw:                                         ProcCmdDraw,
	CmdDrawIndexed:                                  ProcCmdDrawIndexed,
	CmdDrawIndexedIndirect:                          ProcCmdDrawIndexedIndirect,
	CmdDrawIndexedIndirectCount:                     ProcCmdDrawIndexedIndirectCount,
	CmdDrawIndexedIndirectCountAMD:                  ProcCmdDrawIndexedIndirectCountAMD,
	CmdDrawIndexedIndirectCountKHR:                  ProcCmdDrawIndexedIndirectCountKHR,
	CmdDrawIndirect:                                 ProcCmdDrawIndirect,
	CmdDrawIndirectByteCountEXT:                     ProcCmdDrawIndirectByteCountEXT,
	CmdDrawIndirectCount:                            ProcCmdDrawIndirectCount,
	CmdDrawIndirectCountAMD:                         ProcCmdDrawIndirectCountAMD,
	CmdDrawIndirectCountKHR:                         ProcCmdDrawIndirectCountKHR,
	CmdDrawMeshTasksIndirectCountNV:                 ProcCmdDrawMeshTasksIndirectCountNV,
	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,
	CmdExecuteCommands:                              ProcCmdExecuteCommands,
	CmdExecuteGeneratedCommandsNV:                   ProcCmdExecuteGeneratedCommandsNV,
	CmdFillBuffer:                                   ProcCmdFillBuffer,
	CmdInsertDebugUtilsLabelEXT:                     ProcCmdInsertDebugUtilsLabelEXT,
	CmdNextSubpass:                                  ProcCmdNextSubpass,
	CmdNextSubpass2:                                 ProcCmdNextSubpass2,
	CmdNextSubpass2KHR:                              ProcCmdNextSubpass2KHR,
	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,
	CmdSetBlendConstants:                            ProcCmdSetBlendConstants,
	CmdSetCheckpointNV:                              ProcCmdSetCheckpointNV,
	CmdSetCoarseSampleOrderNV:                       ProcCmdSetCoarseSampleOrderNV,
	CmdSetCullMode:                                  ProcCmdSetCullMode,
	CmdSetCullModeEXT:                               ProcCmdSetCullModeEXT,
	CmdSetDepthBias:                                 ProcCmdSetDepthBias,
	CmdSetDepthBiasEnable:                           ProcCmdSetDepthBiasEnable,
	CmdSetDepthBiasEnableEXT:                        ProcCmdSetDepthBiasEnableEXT,
	CmdSetDepthBounds:                               ProcCmdSetDepthBounds,
	CmdSetDepthBoundsTestEnable:                     ProcCmdSetDepthBoundsTestEnable,
	CmdSetDepthBoundsTestEnableEXT:                  ProcCmdSetDepthBoundsTestEnableEXT,
	CmdSetDepthCompareOp:                            ProcCmdSetDepthCompareOp,
	CmdSetDepthCompareOpEXT:                         ProcCmdSetDepthCompareOpEXT,
	CmdSetDepthTestEnable:                           ProcCmdSetDepthTestEnable,
	CmdSetDepthTestEnableEXT:                        ProcCmdSetDepthTestEnableEXT,
	CmdSetDepthWriteEnable:                          ProcCmdSetDepthWriteEnable,
	CmdSetDepthWriteEnableEXT:                       ProcCmdSetDepthWriteEnableEXT,
	CmdSetDeviceMask:                                ProcCmdSetDeviceMask,
	CmdSetDeviceMaskKHR:                             ProcCmdSetDeviceMaskKHR,
	CmdSetDiscardRectangleEXT:                       ProcCmdSetDiscardRectangleEXT,
	CmdSetEvent:                                     ProcCmdSetEvent,
	CmdSetEvent2:                                    ProcCmdSetEvent2,
	CmdSetEvent2KHR:                                 ProcCmdSetEvent2KHR,
	CmdSetExclusiveScissorNV:                        ProcCmdSetExclusiveScissorNV,
	CmdSetFragmentShadingRateEnumNV:                 ProcCmdSetFragmentShadingRateEnumNV,
	CmdSetFragmentShadingRateKHR:                    ProcCmdSetFragmentShadingRateKHR,
	CmdSetFrontFace:                                 ProcCmdSetFrontFace,
	CmdSetFrontFaceEXT:                              ProcCmdSetFrontFaceEXT,
	CmdSetLineStippleEXT:                            ProcCmdSetLineStippleEXT,
	CmdSetLineWidth:                                 ProcCmdSetLineWidth,
	CmdSetLogicOpEXT:                                ProcCmdSetLogicOpEXT,
	CmdSetPatchControlPointsEXT:                     ProcCmdSetPatchControlPointsEXT,
	CmdSetPerformanceMarkerINTEL:                    ProcCmdSetPerformanceMarkerINTEL,
	CmdSetPerformanceOverrideINTEL:                  ProcCmdSetPerformanceOverrideINTEL,
	CmdSetPerformanceStreamMarkerINTEL:              ProcCmdSetPerformanceStreamMarkerINTEL,
	CmdSetPrimitiveRestartEnable:                    ProcCmdSetPrimitiveRestartEnable,
	CmdSetPrimitiveRestartEnableEXT:                 ProcCmdSetPrimitiveRestartEnableEXT,
	CmdSetPrimitiveTopology:                         ProcCmdSetPrimitiveTopology,
	CmdSetPrimitiveTopologyEXT:                      ProcCmdSetPrimitiveTopologyEXT,
	CmdSetRasterizerDiscardEnable:                   ProcCmdSetRasterizerDiscardEnable,
	CmdSetRasterizerDiscardEnableEXT:                ProcCmdSetRasterizerDiscardEnableEXT,
	CmdSetRayTracingPipelineStackSizeKHR:            ProcCmdSetRayTracingPipelineStackSizeKHR,
	CmdSetSampleLocationsEXT:                        ProcCmdSetSampleLocationsEXT,
	CmdSetScissor:                                   ProcCmdSetScissor,
	CmdSetScissorWithCount:                          ProcCmdSetScissorWithCount,
	CmdSetScissorWithCountEXT:                       ProcCmdSetScissorWithCountEXT,
	CmdSetStencilCompareMask:                        ProcCmdSetStencilCompareMask,
	CmdSetStencilOp:                                 ProcCmdSetStencilOp,
	CmdSetStencilOpEXT:                              ProcCmdSetStencilOpEXT,
	CmdSetStencilReference:                          ProcCmdSetStencilReference,
	CmdSetStencilTestEnable:                         ProcCmdSetStencilTestEnable,
	CmdSetStencilTestEnableEXT:                      ProcCmdSetStencilTestEnableEXT,
	CmdSetStencilWriteMask:                          ProcCmdSetStencilWriteMask,
	CmdSetVertexInputEXT:                            ProcCmdSetVertexInputEXT,
	CmdSetViewport:                                  ProcCmdSetViewport,
	CmdSetViewportShadingRatePaletteNV:              ProcCmdSetViewportShadingRatePaletteNV,
	CmdSetViewportWScalingNV:                        ProcCmdSetViewportWScalingNV,
	CmdSetViewportWithCount:                         ProcCmdSetViewportWithCount,
	CmdSetViewportWithCountEXT:                      ProcCmdSetViewportWithCountEXT,
	CmdSubpassShadingHUAWEI:                         ProcCmdSubpassShadingHUAWEI,
	CmdTraceRaysIndirectKHR:                         ProcCmdTraceRaysIndirectKHR,
	CmdTraceRaysKHR:                                 ProcCmdTraceRaysKHR,
	CmdTraceRaysNV:                                  ProcCmdTraceRaysNV,
	CmdUpdateBuffer:                                 ProcCmdUpdateBuffer,
	CmdWaitEvents:                                   ProcCmdWaitEvents,
	CmdWaitEvents2:                                  ProcCmdWaitEvents2,
	CmdWaitEvents2KHR:                               ProcCmdWaitEvents2KHR,
	CmdWriteAccelerationStructuresPropertiesKHR:     ProcCmdWriteAccelerationStructuresPropertiesKHR,
	CmdWriteAccelerationStructuresPropertiesNV:      ProcCmdWriteAccelerationStructuresPropertiesNV,
	CmdWriteBufferMarker2AMD:                        ProcCmdWriteBufferMarker2AMD,
	CmdWriteBufferMarkerAMD:                         ProcCmdWriteBufferMarkerAMD,
	CmdWriteTimestamp:                               ProcCmdWriteTimestamp,
	CmdWriteTimestamp2:                              ProcCmdWriteTimestamp2,
	CmdWriteTimestamp2KHR:                           ProcCmdWriteTimestamp2KHR,
	CompileDeferredNV:                               ProcCompileDeferredNV,
	CopyAccelerationStructureKHR:                    ProcCopyAccelerationStructureKHR,
	CopyAccelerationStructureToMemoryKHR:            ProcCopyAccelerationStructureToMemoryKHR,
	CopyMemoryToAccelerationStructureKHR:            ProcCopyMemoryToAccelerationStructureKHR,
	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,
	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,
	CreateSharedSwapchainsKHR:                       ProcCreateSharedSwapchainsKHR,
	CreateSwapchainKHR:                              ProcCreateSwapchainKHR,
	CreateValidationCacheEXT:                        ProcCreateValidationCacheEXT,
	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,
	DestroyPipeline:                                 ProcDestroyPipeline,
	DestroyPipelineCache:                            ProcDestroyPipelineCache,
	DestroyPipelineLayout:                           ProcDestroyPipelineLayout,
	DestroyPrivateDataSlot:                          ProcDestroyPrivateDataSlot,
	DestroyPrivateDataSlotEXT:                       ProcDestroyPrivateDataSlotEXT,
	DestroyQueryPool:                                ProcDestroyQueryPool,
	DestroyRenderPass:                               ProcDestroyRenderPass,
	DestroySampler:                                  ProcDestroySampler,
	DestroySamplerYcbcrConversion:                   ProcDestroySamplerYcbcrConversion,
	DestroySamplerYcbcrConversionKHR:                ProcDestroySamplerYcbcrConversionKHR,
	DestroySemaphore:                                ProcDestroySemaphore,
	DestroyShaderModule:                             ProcDestroyShaderModule,
	DestroySwapchainKHR:                             ProcDestroySwapchainKHR,
	DestroyValidationCacheEXT:                       ProcDestroyValidationCacheEXT,
	DeviceWaitIdle:                                  ProcDeviceWaitIdle,
	DisplayPowerControlEXT:                          ProcDisplayPowerControlEXT,
	EndCommandBuffer:                                ProcEndCommandBuffer,
	FlushMappedMemoryRanges:                         ProcFlushMappedMemoryRanges,
	FreeCommandBuffers:                              ProcFreeCommandBuffers,
	FreeDescriptorSets:                              ProcFreeDescriptorSets,
	FreeMemory:                                      ProcFreeMemory,
	GetAccelerationStructureBuildSizesKHR:           ProcGetAccelerationStructureBuildSizesKHR,
	GetAccelerationStructureDeviceAddressKHR:        ProcGetAccelerationStructureDeviceAddressKHR,
	GetAccelerationStructureHandleNV:                ProcGetAccelerationStructureHandleNV,
	GetAccelerationStructureMemoryRequirementsNV:    ProcGetAccelerationStructureMemoryRequirementsNV,
	GetBufferDeviceAddress:                          ProcGetBufferDeviceAddress,
	GetBufferDeviceAddressEXT:                       ProcGetBufferDeviceAddressEXT,
	GetBufferDeviceAddressKHR:                       ProcGetBufferDeviceAddressKHR,
	GetBufferMemoryRequirements:                     ProcGetBufferMemoryRequirements,
	GetBufferMemoryRequirements2:                    ProcGetBufferMemoryRequirements2,
	GetBufferMemoryRequirements2KHR:                 ProcGetBufferMemoryRequirements2KHR,
	GetBufferOpaqueCaptureAddress:                   ProcGetBufferOpaqueCaptureAddress,
	GetBufferOpaqueCaptureAddressKHR:                ProcGetBufferOpaqueCaptureAddressKHR,
	GetCalibratedTimestampsEXT:                      ProcGetCalibratedTimestampsEXT,
	GetDeferredOperationMaxConcurrencyKHR:           ProcGetDeferredOperationMaxConcurrencyKHR,
	GetDeferredOperationResultKHR:                   ProcGetDeferredOperationResultKHR,
	GetDescriptorSetHostMappingVALVE:                ProcGetDescriptorSetHostMappingVALVE,
	GetDescriptorSetLayoutHostMappingInfoVALVE:      ProcGetDescriptorSetLayoutHostMappingInfoVALVE,
	GetDescriptorSetLayoutSupport:                   ProcGetDescriptorSetLayoutSupport,
	GetDescriptorSetLayoutSupportKHR:                ProcGetDescriptorSetLayoutSupportKHR,
	GetDeviceAccelerationStructureCompatibilityKHR:  ProcGetDeviceAccelerationStructureCompatibilityKHR,
	GetDeviceBufferMemoryRequirements:               ProcGetDeviceBufferMemoryRequirements,
	GetDeviceBufferMemoryRequirementsKHR:            ProcGetDeviceBufferMemoryRequirementsKHR,
	GetDeviceGroupPeerMemoryFeatures:                ProcGetDeviceGroupPeerMemoryFeatures,
	GetDeviceGroupPeerMemoryFeaturesKHR:             ProcGetDeviceGroupPeerMemoryFeaturesKHR,
	GetDeviceGroupPresentCapabilitiesKHR:            ProcGetDeviceGroupPresentCapabilitiesKHR,
	GetDeviceGroupSurfacePresentModes2EXT:           ProcGetDeviceGroupSurfacePresentModes2EXT,
	GetDeviceGroupSurfacePresentModesKHR:            ProcGetDeviceGroupSurfacePresentModesKHR,
	GetDeviceImageMemoryRequirements:                ProcGetDeviceImageMemoryRequirements,
	GetDeviceImageMemoryRequirementsKHR:             ProcGetDeviceImageMemoryRequirementsKHR,
	GetDeviceImageSparseMemoryRequirements:          ProcGetDeviceImageSparseMemoryRequirements,
	GetDeviceImageSparseMemoryRequirementsKHR:       ProcGetDeviceImageSparseMemoryRequirementsKHR,
	GetDeviceMemoryCommitment:                       ProcGetDeviceMemoryCommitment,
	GetDeviceMemoryOpaqueCaptureAddress:             ProcGetDeviceMemoryOpaqueCaptureAddress,
	GetDeviceMemoryOpaqueCaptureAddressKHR:          ProcGetDeviceMemoryOpaqueCaptureAddressKHR,
	GetDeviceProcAddr:                               ProcGetDeviceProcAddr,
	GetDeviceQueue:                                  ProcGetDeviceQueue,
	GetDeviceQueue2:                                 ProcGetDeviceQueue2,
	GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI:   ProcGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI,
	GetEventStatus:                                  ProcGetEventStatus,
	GetFenceFdKHR:                                   ProcGetFenceFdKHR,
	GetFenceStatus:                                  ProcGetFenceStatus,
	GetFenceWin32HandleKHR:                          ProcGetFenceWin32HandleKHR,
	GetGeneratedCommandsMemoryRequirementsNV:        ProcGetGeneratedCommandsMemoryRequirementsNV,
	GetImageDrmFormatModifierPropertiesEXT:          ProcGetImageDrmFormatModifierPropertiesEXT,
	GetImageMemoryRequirements:                      ProcGetImageMemoryRequirements,
	GetImageMemoryRequirements2:                     ProcGetImageMemoryRequirements2,
	GetImageMemoryRequirements2KHR:                  ProcGetImageMemoryRequirements2KHR,
	GetImageSparseMemoryRequirements:                ProcGetImageSparseMemoryRequirements,
	GetImageSparseMemoryRequirements2:               ProcGetImageSparseMemoryRequirements2,
	GetImageSparseMemoryRequirements2KHR:            ProcGetImageSparseMemoryRequirements2KHR,
	GetImageSubresourceLayout:                       ProcGetImageSubresourceLayout,
	GetImageViewAddressNVX:                          ProcGetImageViewAddressNVX,
	GetImageViewHandleNVX:                           ProcGetImageViewHandleNVX,
	GetMemoryFdKHR:                                  ProcGetMemoryFdKHR,
	GetMemoryFdPropertiesKHR:                        ProcGetMemoryFdPropertiesKHR,
	GetMemoryHostPointerPropertiesEXT:               ProcGetMemoryHostPointerPropertiesEXT,
	GetMemoryRemoteAddressNV:                        ProcGetMemoryRemoteAddressNV,
	GetMemoryWin32HandleKHR:                         ProcGetMemoryWin32HandleKHR,
	GetMemoryWin32HandleNV:                          ProcGetMemoryWin32HandleNV,
	GetMemoryWin32HandlePropertiesKHR:               ProcGetMemoryWin32HandlePropertiesKHR,
	GetPastPresentationTimingGOOGLE:                 ProcGetPastPresentationTimingGOOGLE,
	GetPerformanceParameterINTEL:                    ProcGetPerformanceParameterINTEL,
	GetPipelineCacheData:                            ProcGetPipelineCacheData,
	GetPipelineExecutableInternalRepresentationsKHR: ProcGetPipelineExecutableInternalRepresentationsKHR,
	GetPipelineExecutablePropertiesKHR:              ProcGetPipelineExecutablePropertiesKHR,
	GetPipelineExecutableStatisticsKHR:              ProcGetPipelineExecutableStatisticsKHR,
	GetPrivateData:                                  ProcGetPrivateData,
	GetPrivateDataEXT:                               ProcGetPrivateDataEXT,
	GetQueryPoolResults:                             ProcGetQueryPoolResults,
	GetQueueCheckpointData2NV:                       ProcGetQueueCheckpointData2NV,
	GetQueueCheckpointDataNV:                        ProcGetQueueCheckpointDataNV,
	GetRayTracingCaptureReplayShaderGroupHandlesKHR: ProcGetRayTracingCaptureReplayShaderGroupHandlesKHR,
	GetRayTracingShaderGroupHandlesKHR:              ProcGetRayTracingShaderGroupHandlesKHR,
	GetRayTracingShaderGroupHandlesNV:               ProcGetRayTracingShaderGroupHandlesNV,
	GetRayTracingShaderGroupStackSizeKHR:            ProcGetRayTracingShaderGroupStackSizeKHR,
	GetRefreshCycleDurationGOOGLE:                   ProcGetRefreshCycleDurationGOOGLE,
	GetRenderAreaGranularity:                        ProcGetRenderAreaGranularity,
	GetSemaphoreCounterValue:                        ProcGetSemaphoreCounterValue,
	GetSemaphoreCounterValueKHR:                     ProcGetSemaphoreCounterValueKHR,
	GetSemaphoreFdKHR:                               ProcGetSemaphoreFdKHR,
	GetSemaphoreWin32HandleKHR:                      ProcGetSemaphoreWin32HandleKHR,
	GetShaderInfoAMD:                                ProcGetShaderInfoAMD,
	GetSwapchainCounterEXT:                          ProcGetSwapchainCounterEXT,
	GetSwapchainImagesKHR:                           ProcGetSwapchainImagesKHR,
	GetSwapchainStatusKHR:                           ProcGetSwapchainStatusKHR,
	GetValidationCacheDataEXT:                       ProcGetValidationCacheDataEXT,
	ImportFenceFdKHR:                                ProcImportFenceFdKHR,
	ImportFenceWin32HandleKHR:                       ProcImportFenceWin32HandleKHR,
	ImportSemaphoreFdKHR:                            ProcImportSemaphoreFdKHR,
	ImportSemaphoreWin32HandleKHR:                   ProcImportSemaphoreWin32HandleKHR,
	InitializePerformanceApiINTEL:                   ProcInitializePerformanceApiINTEL,
	InvalidateMappedMemoryRanges:                    ProcInvalidateMappedMemoryRanges,
	MapMemory:                                       ProcMapMemory,
	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,
	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,
	UpdateDescriptorSetWithTemplate:                 ProcUpdateDescriptorSetWithTemplate,
	UpdateDescriptorSetWithTemplateKHR:              ProcUpdateDescriptorSetWithTemplateKHR,
	UpdateDescriptorSets:                            ProcUpdateDescriptorSets,
	WaitForFences:                                   ProcWaitForFences,
	WaitForPresentKHR:                               ProcWaitForPresentKHR,
	WaitSemaphores:                                  ProcWaitSemaphores,
	WaitSemaphoresKHR:                               ProcWaitSemaphoresKHR,
	WriteAccelerationStructuresPropertiesKHR:        ProcWriteAccelerationStructuresPropertiesKHR,
}
 

Device Procedure VTable

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

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

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

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_IMG = 1000015000, 
	CUBIC_EXT = 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, 
	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, 
	SAMPLED_IMAGE_FILTER_CUBIC_IMG                                              = 13, 
	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, 
	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, 
	SAMPLED_IMAGE_FILTER_CUBIC_EXT                                              = 13, 
}

FormatFeatureFlag2 ¶

FormatFeatureFlag2 :: Flags64

FormatFeatureFlag2KHR ¶

FormatFeatureFlag2KHR :: Flags64

FormatFeatureFlags ¶

FormatFeatureFlags :: distinct bit_set[FormatFeatureFlag; Flags]

FormatFeatureFlags2 ¶

FormatFeatureFlags2 :: Flags64

FormatFeatureFlags2KHR ¶

FormatFeatureFlags2KHR :: 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:  Flags64,
	optimalTilingFeatures: Flags64,
	bufferFeatures:        Flags64,
}

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

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]

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

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, 
	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, 
	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:        Flags64,
	srcAccessMask:       Flags64,
	dstStageMask:        Flags64,
	dstAccessMask:       Flags64,
	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,
}

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, 
	INVOCATION_MASK_HUAWEI               = 18, 
	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,
}

ImageViewCreateFlag ¶

ImageViewCreateFlag :: enum Flags {
	FRAGMENT_DENSITY_MAP_DYNAMIC_EXT  = 0, 
	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,
}

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

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

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

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

LONG ¶

LONG :: i32

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

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:  Flags64,
	srcAccessMask: Flags64,
	dstStageMask:  Flags64,
	dstAccessMask: 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]

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

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

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

MultiviewPerViewAttributesInfoNVX ¶

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

MutableDescriptorTypeCreateInfoVALVE ¶

MutableDescriptorTypeCreateInfoVALVE :: struct {
	sType:                          StructureType,
	pNext:                          rawptr,
	mutableDescriptorTypeListCount: u32,
	pMutableDescriptorTypeLists:    [^]MutableDescriptorTypeListVALVE,
}

MutableDescriptorTypeListVALVE ¶

MutableDescriptorTypeListVALVE :: 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, 
	DESCRIPTOR_UPDATE_TEMPLATE_KHR  = 1000085000, 
	SAMPLER_YCBCR_CONVERSION_KHR    = 1000156000, 
	PRIVATE_DATA_SLOT_EXT           = 1000295000, 
}

Offset2D ¶

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

Offset3D ¶

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

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

PerformanceCounterUnitKHR ¶

PerformanceCounterUnitKHR :: enum i32 {
	GENERIC          = 0, 
	PERCENTAGE       = 1, 
	NANOSECONDS      = 2, 
	BYTES            = 3, 
	BYTES_PER_SECOND = 4, 
	KELVIN           = 5, 
	WATTS            = 6, 
	VOLTS            = 7, 
	AMPS             = 8, 
	HERTZ            = 9, 
	CYCLES           = 10, 
}

PerformanceMarkerInfoINTEL ¶

PerformanceMarkerInfoINTEL :: struct {
	sType:  StructureType,
	pNext:  rawptr,
	marker: u64,
}

PerformanceOverrideInfoINTEL ¶

PerformanceOverrideInfoINTEL :: struct {
	sType:     StructureType,
	pNext:     rawptr,
	type:      PerformanceOverrideTypeINTEL,
	enable:    b32,
	parameter: u64,
}

PerformanceOverrideTypeINTEL ¶

PerformanceOverrideTypeINTEL :: enum i32 {
	PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL    = 0, 
	PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL = 1, 
}

PerformanceParameterTypeINTEL ¶

PerformanceParameterTypeINTEL :: enum i32 {
	PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL    = 0, 
	PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL = 1, 
}

PerformanceQuerySubmitInfoKHR ¶

PerformanceQuerySubmitInfoKHR :: struct {
	sType:            StructureType,
	pNext:            rawptr,
	counterPassIndex: u32,
}

PerformanceStreamMarkerInfoINTEL ¶

PerformanceStreamMarkerInfoINTEL :: struct {
	sType:  StructureType,
	pNext:  rawptr,
	marker: u32,
}

PerformanceValueDataINTEL ¶

PerformanceValueDataINTEL :: struct #raw_union {
	value32:     u32,
	value64:     u64,
	valueFloat:  f32,
	valueBool:   b32,
	valueString: cstring,
}

PerformanceValueINTEL ¶

PerformanceValueINTEL :: struct {
	type: PerformanceValueTypeINTEL,
	data: PerformanceValueDataINTEL,
}

PerformanceValueTypeINTEL ¶

PerformanceValueTypeINTEL :: enum i32 {
	PERFORMANCE_VALUE_TYPE_UINT32_INTEL = 0, 
	PERFORMANCE_VALUE_TYPE_UINT64_INTEL = 1, 
	PERFORMANCE_VALUE_TYPE_FLOAT_INTEL  = 2, 
	PERFORMANCE_VALUE_TYPE_BOOL_INTEL   = 3, 
	PERFORMANCE_VALUE_TYPE_STRING_INTEL = 4, 
}

PhysicalDevice ¶

PhysicalDevice :: distinct rawptr

PhysicalDevice16BitStorageFeatures ¶

PhysicalDevice16BitStorageFeatures :: struct {
	sType:                              StructureType,
	pNext:                              rawptr,
	storageBuffer16BitAccess:           b32,
	uniformAndStorageBuffer16BitAccess: b32,
	storagePushConstant16:              b32,
	storageInputOutput16:               b32,
}

PhysicalDevice4444FormatsFeaturesEXT ¶

PhysicalDevice4444FormatsFeaturesEXT :: struct {
	sType:          StructureType,
	pNext:          rawptr,
	formatA4R4G4B4: b32,
	formatA4B4G4R4: b32,
}

PhysicalDevice8BitStorageFeatures ¶

PhysicalDevice8BitStorageFeatures :: struct {
	sType:                             StructureType,
	pNext:                             rawptr,
	storageBuffer8BitAccess:           b32,
	uniformAndStorageBuffer8BitAccess: b32,
	storagePushConstant8:              b32,
}

PhysicalDeviceASTCDecodeFeaturesEXT ¶

PhysicalDeviceASTCDecodeFeaturesEXT :: struct {
	sType:                    StructureType,
	pNext:                    rawptr,
	decodeModeSharedExponent: b32,
}

PhysicalDeviceAccelerationStructureFeaturesKHR ¶

PhysicalDeviceAccelerationStructureFeaturesKHR :: struct {
	sType:                                                 StructureType,
	pNext:                                                 rawptr,
	accelerationStructure:                                 b32,
	accelerationStructureCaptureReplay:                    b32,
	accelerationStructureIndirectBuild:                    b32,
	accelerationStructureHostCommands:                     b32,
	descriptorBindingAccelerationStructureUpdateAfterBind: b32,
}

PhysicalDeviceAccelerationStructurePropertiesKHR ¶

PhysicalDeviceAccelerationStructurePropertiesKHR :: struct {
	sType:                                                      StructureType,
	pNext:                                                      rawptr,
	maxGeometryCount:                                           u64,
	maxInstanceCount:                                           u64,
	maxPrimitiveCount:                                          u64,
	maxPerStageDescriptorAccelerationStructures:                u32,
	maxPerStageDescriptorUpdateAfterBindAccelerationStructures: u32,
	maxDescriptorSetAccelerationStructures:                     u32,
	maxDescriptorSetUpdateAfterBindAccelerationStructures:      u32,
	minAccelerationStructureScratchOffsetAlignment:             u32,
}

PhysicalDeviceBlendOperationAdvancedFeaturesEXT ¶

PhysicalDeviceBlendOperationAdvancedFeaturesEXT :: struct {
	sType:                           StructureType,
	pNext:                           rawptr,
	advancedBlendCoherentOperations: b32,
}

PhysicalDeviceBlendOperationAdvancedPropertiesEXT ¶

PhysicalDeviceBlendOperationAdvancedPropertiesEXT :: struct {
	sType:                                 StructureType,
	pNext:                                 rawptr,
	advancedBlendMaxColorAttachments:      u32,
	advancedBlendIndependentBlend:         b32,
	advancedBlendNonPremultipliedSrcColor: b32,
	advancedBlendNonPremultipliedDstColor: b32,
	advancedBlendCorrelatedOverlap:        b32,
	advancedBlendAllOperations:            b32,
}

PhysicalDeviceBorderColorSwizzleFeaturesEXT ¶

PhysicalDeviceBorderColorSwizzleFeaturesEXT :: struct {
	sType:                       StructureType,
	pNext:                       rawptr,
	borderColorSwizzle:          b32,
	borderColorSwizzleFromImage: b32,
}

PhysicalDeviceBufferDeviceAddressFeatures ¶

PhysicalDeviceBufferDeviceAddressFeatures :: struct {
	sType:                            StructureType,
	pNext:                            rawptr,
	bufferDeviceAddress:              b32,
	bufferDeviceAddressCaptureReplay: b32,
	bufferDeviceAddressMultiDevice:   b32,
}

PhysicalDeviceBufferDeviceAddressFeaturesEXT ¶

PhysicalDeviceBufferDeviceAddressFeaturesEXT :: struct {
	sType:                            StructureType,
	pNext:                            rawptr,
	bufferDeviceAddress:              b32,
	bufferDeviceAddressCaptureReplay: b32,
	bufferDeviceAddressMultiDevice:   b32,
}

PhysicalDeviceCoherentMemoryFeaturesAMD ¶

PhysicalDeviceCoherentMemoryFeaturesAMD :: struct {
	sType:                StructureType,
	pNext:                rawptr,
	deviceCoherentMemory: b32,
}

PhysicalDeviceColorWriteEnableFeaturesEXT ¶

PhysicalDeviceColorWriteEnableFeaturesEXT :: struct {
	sType:            StructureType,
	pNext:            rawptr,
	colorWriteEnable: b32,
}

PhysicalDeviceComputeShaderDerivativesFeaturesNV ¶

PhysicalDeviceComputeShaderDerivativesFeaturesNV :: struct {
	sType:                        StructureType,
	pNext:                        rawptr,
	computeDerivativeGroupQuads:  b32,
	computeDerivativeGroupLinear: b32,
}

PhysicalDeviceConditionalRenderingFeaturesEXT ¶

PhysicalDeviceConditionalRenderingFeaturesEXT :: struct {
	sType:                         StructureType,
	pNext:                         rawptr,
	conditionalRendering:          b32,
	inheritedConditionalRendering: b32,
}

PhysicalDeviceConservativeRasterizationPropertiesEXT ¶

PhysicalDeviceConservativeRasterizationPropertiesEXT :: struct {
	sType:                                       StructureType,
	pNext:                                       rawptr,
	primitiveOverestimationSize:                 f32,
	maxExtraPrimitiveOverestimationSize:         f32,
	extraPrimitiveOverestimationSizeGranularity: f32,
	primitiveUnderestimation:                    b32,
	conservativePointAndLineRasterization:       b32,
	degenerateTrianglesRasterized:               b32,
	degenerateLinesRasterized:                   b32,
	fullyCoveredFragmentShaderInputVariable:     b32,
	conservativeRasterizationPostDepthCoverage:  b32,
}

PhysicalDeviceCooperativeMatrixFeaturesNV ¶

PhysicalDeviceCooperativeMatrixFeaturesNV :: struct {
	sType:                               StructureType,
	pNext:                               rawptr,
	cooperativeMatrix:                   b32,
	cooperativeMatrixRobustBufferAccess: b32,
}

PhysicalDeviceCooperativeMatrixPropertiesNV ¶

PhysicalDeviceCooperativeMatrixPropertiesNV :: struct {
	sType:                            StructureType,
	pNext:                            rawptr,
	cooperativeMatrixSupportedStages: ShaderStageFlags,
}

PhysicalDeviceCornerSampledImageFeaturesNV ¶

PhysicalDeviceCornerSampledImageFeaturesNV :: struct {
	sType:              StructureType,
	pNext:              rawptr,
	cornerSampledImage: b32,
}

PhysicalDeviceCoverageReductionModeFeaturesNV ¶

PhysicalDeviceCoverageReductionModeFeaturesNV :: struct {
	sType:                 StructureType,
	pNext:                 rawptr,
	coverageReductionMode: b32,
}

PhysicalDeviceCustomBorderColorFeaturesEXT ¶

PhysicalDeviceCustomBorderColorFeaturesEXT :: struct {
	sType:                          StructureType,
	pNext:                          rawptr,
	customBorderColors:             b32,
	customBorderColorWithoutFormat: b32,
}

PhysicalDeviceCustomBorderColorPropertiesEXT ¶

PhysicalDeviceCustomBorderColorPropertiesEXT :: struct {
	sType:                        StructureType,
	pNext:                        rawptr,
	maxCustomBorderColorSamplers: u32,
}

PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV ¶

PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV :: struct {
	sType:                            StructureType,
	pNext:                            rawptr,
	dedicatedAllocationImageAliasing: b32,
}

PhysicalDeviceDepthClipControlFeaturesEXT ¶

PhysicalDeviceDepthClipControlFeaturesEXT :: struct {
	sType:            StructureType,
	pNext:            rawptr,
	depthClipControl: b32,
}

PhysicalDeviceDepthClipEnableFeaturesEXT ¶

PhysicalDeviceDepthClipEnableFeaturesEXT :: struct {
	sType:           StructureType,
	pNext:           rawptr,
	depthClipEnable: b32,
}

PhysicalDeviceDepthStencilResolveProperties ¶

PhysicalDeviceDepthStencilResolveProperties :: struct {
	sType:                        StructureType,
	pNext:                        rawptr,
	supportedDepthResolveModes:   ResolveModeFlags,
	supportedStencilResolveModes: ResolveModeFlags,
	independentResolveNone:       b32,
	independentResolve:           b32,
}

PhysicalDeviceDescriptorIndexingFeatures ¶

PhysicalDeviceDescriptorIndexingFeatures :: struct {
	sType:                                              StructureType,
	pNext:                                              rawptr,
	shaderInputAttachmentArrayDynamicIndexing:          b32,
	shaderUniformTexelBufferArrayDynamicIndexing:       b32,
	shaderStorageTexelBufferArrayDynamicIndexing:       b32,
	shaderUniformBufferArrayNonUniformIndexing:         b32,
	shaderSampledImageArrayNonUniformIndexing:          b32,
	shaderStorageBufferArrayNonUniformIndexing:         b32,
	shaderStorageImageArrayNonUniformIndexing:          b32,
	shaderInputAttachmentArrayNonUniformIndexing:       b32,
	shaderUniformTexelBufferArrayNonUniformIndexing:    b32,
	shaderStorageTexelBufferArrayNonUniformIndexing:    b32,
	descriptorBindingUniformBufferUpdateAfterBind:      b32,
	descriptorBindingSampledImageUpdateAfterBind:       b32,
	descriptorBindingStorageImageUpdateAfterBind:       b32,
	descriptorBindingStorageBufferUpdateAfterBind:      b32,
	descriptorBindingUniformTexelBufferUpdateAfterBind: b32,
	descriptorBindingStorageTexelBufferUpdateAfterBind: b32,
	descriptorBindingUpdateUnusedWhilePending:          b32,
	descriptorBindingPartiallyBound:                    b32,
	descriptorBindingVariableDescriptorCount:           b32,
	runtimeDescriptorArray:                             b32,
}

PhysicalDeviceDescriptorIndexingProperties ¶

PhysicalDeviceDescriptorIndexingProperties :: struct {
	sType:                                                StructureType,
	pNext:                                                rawptr,
	maxUpdateAfterBindDescriptorsInAllPools:              u32,
	shaderUniformBufferArrayNonUniformIndexingNative:     b32,
	shaderSampledImageArrayNonUniformIndexingNative:      b32,
	shaderStorageBufferArrayNonUniformIndexingNative:     b32,
	shaderStorageImageArrayNonUniformIndexingNative:      b32,
	shaderInputAttachmentArrayNonUniformIndexingNative:   b32,
	robustBufferAccessUpdateAfterBind:                    b32,
	quadDivergentImplicitLod:                             b32,
	maxPerStageDescriptorUpdateAfterBindSamplers:         u32,
	maxPerStageDescriptorUpdateAfterBindUniformBuffers:   u32,
	maxPerStageDescriptorUpdateAfterBindStorageBuffers:   u32,
	maxPerStageDescriptorUpdateAfterBindSampledImages:    u32,
	maxPerStageDescriptorUpdateAfterBindStorageImages:    u32,
	maxPerStageDescriptorUpdateAfterBindInputAttachments: u32,
	maxPerStageUpdateAfterBindResources:                  u32,
	maxDescriptorSetUpdateAfterBindSamplers:              u32,
	maxDescriptorSetUpdateAfterBindUniformBuffers:        u32,
	maxDescriptorSetUpdateAfterBindUniformBuffersDynamic: u32,
	maxDescriptorSetUpdateAfterBindStorageBuffers:        u32,
	maxDescriptorSetUpdateAfterBindStorageBuffersDynamic: u32,
	maxDescriptorSetUpdateAfterBindSampledImages:         u32,
	maxDescriptorSetUpdateAfterBindStorageImages:         u32,
	maxDescriptorSetUpdateAfterBindInputAttachments:      u32,
}

PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE ¶

PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE :: struct {
	sType:                    StructureType,
	pNext:                    rawptr,
	descriptorSetHostMapping: b32,
}

PhysicalDeviceDeviceGeneratedCommandsFeaturesNV ¶

PhysicalDeviceDeviceGeneratedCommandsFeaturesNV :: struct {
	sType:                   StructureType,
	pNext:                   rawptr,
	deviceGeneratedCommands: b32,
}

PhysicalDeviceDeviceGeneratedCommandsPropertiesNV ¶

PhysicalDeviceDeviceGeneratedCommandsPropertiesNV :: struct {
	sType:                                    StructureType,
	pNext:                                    rawptr,
	maxGraphicsShaderGroupCount:              u32,
	maxIndirectSequenceCount:                 u32,
	maxIndirectCommandsTokenCount:            u32,
	maxIndirectCommandsStreamCount:           u32,
	maxIndirectCommandsTokenOffset:           u32,
	maxIndirectCommandsStreamStride:          u32,
	minSequencesCountBufferOffsetAlignment:   u32,
	minSequencesIndexBufferOffsetAlignment:   u32,
	minIndirectCommandsBufferOffsetAlignment: u32,
}

PhysicalDeviceDeviceMemoryReportFeaturesEXT ¶

PhysicalDeviceDeviceMemoryReportFeaturesEXT :: struct {
	sType:              StructureType,
	pNext:              rawptr,
	deviceMemoryReport: b32,
}

PhysicalDeviceDiagnosticsConfigFeaturesNV ¶

PhysicalDeviceDiagnosticsConfigFeaturesNV :: struct {
	sType:             StructureType,
	pNext:             rawptr,
	diagnosticsConfig: b32,
}

PhysicalDeviceDiscardRectanglePropertiesEXT ¶

PhysicalDeviceDiscardRectanglePropertiesEXT :: struct {
	sType:                StructureType,
	pNext:                rawptr,
	maxDiscardRectangles: u32,
}

PhysicalDeviceDriverProperties ¶

PhysicalDeviceDriverProperties :: struct {
	sType:              StructureType,
	pNext:              rawptr,
	driverID:           DriverId,
	driverName:         [256]u8,
	driverInfo:         [256]u8,
	conformanceVersion: ConformanceVersion,
}

PhysicalDeviceDrmPropertiesEXT ¶

PhysicalDeviceDrmPropertiesEXT :: struct {
	sType:        StructureType,
	pNext:        rawptr,
	hasPrimary:   b32,
	hasRender:    b32,
	primaryMajor: i64,
	primaryMinor: i64,
	renderMajor:  i64,
	renderMinor:  i64,
}

PhysicalDeviceDynamicRenderingFeatures ¶

PhysicalDeviceDynamicRenderingFeatures :: struct {
	sType:            StructureType,
	pNext:            rawptr,
	dynamicRendering: b32,
}

PhysicalDeviceExclusiveScissorFeaturesNV ¶

PhysicalDeviceExclusiveScissorFeaturesNV :: struct {
	sType:            StructureType,
	pNext:            rawptr,
	exclusiveScissor: b32,
}

PhysicalDeviceExtendedDynamicState2FeaturesEXT ¶

PhysicalDeviceExtendedDynamicState2FeaturesEXT :: struct {
	sType:                                   StructureType,
	pNext:                                   rawptr,
	extendedDynamicState2:                   b32,
	extendedDynamicState2LogicOp:            b32,
	extendedDynamicState2PatchControlPoints: b32,
}

PhysicalDeviceExtendedDynamicStateFeaturesEXT ¶

PhysicalDeviceExtendedDynamicStateFeaturesEXT :: struct {
	sType:                StructureType,
	pNext:                rawptr,
	extendedDynamicState: b32,
}

PhysicalDeviceExternalBufferInfo ¶

PhysicalDeviceExternalBufferInfo :: struct {
	sType:      StructureType,
	pNext:      rawptr,
	flags:      BufferCreateFlags,
	usage:      BufferUsageFlags,
	handleType: ExternalMemoryHandleTypeFlags,
}

PhysicalDeviceExternalFenceInfo ¶

PhysicalDeviceExternalFenceInfo :: struct {
	sType:      StructureType,
	pNext:      rawptr,
	handleType: ExternalFenceHandleTypeFlags,
}

PhysicalDeviceExternalImageFormatInfo ¶

PhysicalDeviceExternalImageFormatInfo :: struct {
	sType:      StructureType,
	pNext:      rawptr,
	handleType: ExternalMemoryHandleTypeFlags,
}

PhysicalDeviceExternalMemoryHostPropertiesEXT ¶

PhysicalDeviceExternalMemoryHostPropertiesEXT :: struct {
	sType:                           StructureType,
	pNext:                           rawptr,
	minImportedHostPointerAlignment: DeviceSize,
}

PhysicalDeviceExternalMemoryRDMAFeaturesNV ¶

PhysicalDeviceExternalMemoryRDMAFeaturesNV :: struct {
	sType:              StructureType,
	pNext:              rawptr,
	externalMemoryRDMA: b32,
}

PhysicalDeviceExternalSemaphoreInfo ¶

PhysicalDeviceExternalSemaphoreInfo :: struct {
	sType:      StructureType,
	pNext:      rawptr,
	handleType: ExternalSemaphoreHandleTypeFlags,
}

PhysicalDeviceFeatures ¶

PhysicalDeviceFeatures :: struct {
	robustBufferAccess:                      b32,
	fullDrawIndexUint32:                     b32,
	imageCubeArray:                          b32,
	independentBlend:                        b32,
	geometryShader:                          b32,
	tessellationShader:                      b32,
	sampleRateShading:                       b32,
	dualSrcBlend:                            b32,
	logicOp:                                 b32,
	multiDrawIndirect:                       b32,
	drawIndirectFirstInstance:               b32,
	depthClamp:                              b32,
	depthBiasClamp:                          b32,
	fillModeNonSolid:                        b32,
	depthBounds:                             b32,
	wideLines:                               b32,
	largePoints:                             b32,
	alphaToOne:                              b32,
	multiViewport:                           b32,
	samplerAnisotropy:                       b32,
	textureCompressionETC2:                  b32,
	textureCompressionASTC_LDR:              b32,
	textureCompressionBC:                    b32,
	occlusionQueryPrecise:                   b32,
	pipelineStatisticsQuery:                 b32,
	vertexPipelineStoresAndAtomics:          b32,
	fragmentStoresAndAtomics:                b32,
	shaderTessellationAndGeometryPointSize:  b32,
	shaderImageGatherExtended:               b32,
	shaderStorageImageExtendedFormats:       b32,
	shaderStorageImageMultisample:           b32,
	shaderStorageImageReadWithoutFormat:     b32,
	shaderStorageImageWriteWithoutFormat:    b32,
	shaderUniformBufferArrayDynamicIndexing: b32,
	shaderSampledImageArrayDynamicIndexing:  b32,
	shaderStorageBufferArrayDynamicIndexing: b32,
	shaderStorageImageArrayDynamicIndexing:  b32,
	shaderClipDistance:                      b32,
	shaderCullDistance:                      b32,
	shaderFloat64:                           b32,
	shaderInt64:                             b32,
	shaderInt16:                             b32,
	shaderResourceResidency:                 b32,
	shaderResourceMinLod:                    b32,
	sparseBinding:                           b32,
	sparseResidencyBuffer:                   b32,
	sparseResidencyImage2D:                  b32,
	sparseResidencyImage3D:                  b32,
	sparseResidency2Samples:                 b32,
	sparseResidency4Samples:                 b32,
	sparseResidency8Samples:                 b32,
	sparseResidency16Samples:                b32,
	sparseResidencyAliased:                  b32,
	variableMultisampleRate:                 b32,
	inheritedQueries:                        b32,
}

PhysicalDeviceFeatures2 ¶

PhysicalDeviceFeatures2 :: struct {
	sType:    StructureType,
	pNext:    rawptr,
	features: PhysicalDeviceFeatures,
}

PhysicalDeviceFloatControlsProperties ¶

PhysicalDeviceFloatControlsProperties :: struct {
	sType:                                 StructureType,
	pNext:                                 rawptr,
	denormBehaviorIndependence:            ShaderFloatControlsIndependence,
	roundingModeIndependence:              ShaderFloatControlsIndependence,
	shaderSignedZeroInfNanPreserveFloat16: b32,
	shaderSignedZeroInfNanPreserveFloat32: b32,
	shaderSignedZeroInfNanPreserveFloat64: b32,
	shaderDenormPreserveFloat16:           b32,
	shaderDenormPreserveFloat32:           b32,
	shaderDenormPreserveFloat64:           b32,
	shaderDenormFlushToZeroFloat16:        b32,
	shaderDenormFlushToZeroFloat32:        b32,
	shaderDenormFlushToZeroFloat64:        b32,
	shaderRoundingModeRTEFloat16:          b32,
	shaderRoundingModeRTEFloat32:          b32,
	shaderRoundingModeRTEFloat64:          b32,
	shaderRoundingModeRTZFloat16:          b32,
	shaderRoundingModeRTZFloat32:          b32,
	shaderRoundingModeRTZFloat64:          b32,
}

PhysicalDeviceFragmentDensityMap2FeaturesEXT ¶

PhysicalDeviceFragmentDensityMap2FeaturesEXT :: struct {
	sType:                      StructureType,
	pNext:                      rawptr,
	fragmentDensityMapDeferred: b32,
}

PhysicalDeviceFragmentDensityMap2PropertiesEXT ¶

PhysicalDeviceFragmentDensityMap2PropertiesEXT :: struct {
	sType:                                     StructureType,
	pNext:                                     rawptr,
	subsampledLoads:                           b32,
	subsampledCoarseReconstructionEarlyAccess: b32,
	maxSubsampledArrayLayers:                  u32,
	maxDescriptorSetSubsampledSamplers:        u32,
}

PhysicalDeviceFragmentDensityMapFeaturesEXT ¶

PhysicalDeviceFragmentDensityMapFeaturesEXT :: struct {
	sType:                                 StructureType,
	pNext:                                 rawptr,
	fragmentDensityMap:                    b32,
	fragmentDensityMapDynamic:             b32,
	fragmentDensityMapNonSubsampledImages: b32,
}

PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM ¶

PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM :: struct {
	sType:                    StructureType,
	pNext:                    rawptr,
	fragmentDensityMapOffset: b32,
}

PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM ¶

PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM :: struct {
	sType:                            StructureType,
	pNext:                            rawptr,
	fragmentDensityOffsetGranularity: Extent2D,
}

PhysicalDeviceFragmentDensityMapPropertiesEXT ¶

PhysicalDeviceFragmentDensityMapPropertiesEXT :: struct {
	sType:                       StructureType,
	pNext:                       rawptr,
	minFragmentDensityTexelSize: Extent2D,
	maxFragmentDensityTexelSize: Extent2D,
	fragmentDensityInvocations:  b32,
}

PhysicalDeviceFragmentShaderBarycentricFeaturesNV ¶

PhysicalDeviceFragmentShaderBarycentricFeaturesNV :: struct {
	sType:                     StructureType,
	pNext:                     rawptr,
	fragmentShaderBarycentric: b32,
}

PhysicalDeviceFragmentShaderInterlockFeaturesEXT ¶

PhysicalDeviceFragmentShaderInterlockFeaturesEXT :: struct {
	sType:                              StructureType,
	pNext:                              rawptr,
	fragmentShaderSampleInterlock:      b32,
	fragmentShaderPixelInterlock:       b32,
	fragmentShaderShadingRateInterlock: b32,
}

PhysicalDeviceFragmentShadingRateEnumsFeaturesNV ¶

PhysicalDeviceFragmentShadingRateEnumsFeaturesNV :: struct {
	sType:                            StructureType,
	pNext:                            rawptr,
	fragmentShadingRateEnums:         b32,
	supersampleFragmentShadingRates:  b32,
	noInvocationFragmentShadingRates: b32,
}

PhysicalDeviceFragmentShadingRateEnumsPropertiesNV ¶

PhysicalDeviceFragmentShadingRateEnumsPropertiesNV :: struct {
	sType:                                 StructureType,
	pNext:                                 rawptr,
	maxFragmentShadingRateInvocationCount: SampleCountFlags,
}

PhysicalDeviceFragmentShadingRateFeaturesKHR ¶

PhysicalDeviceFragmentShadingRateFeaturesKHR :: struct {
	sType:                         StructureType,
	pNext:                         rawptr,
	pipelineFragmentShadingRate:   b32,
	primitiveFragmentShadingRate:  b32,
	attachmentFragmentShadingRate: b32,
}

PhysicalDeviceFragmentShadingRateKHR ¶

PhysicalDeviceFragmentShadingRateKHR :: struct {
	sType:        StructureType,
	pNext:        rawptr,
	sampleCounts: SampleCountFlags,
	fragmentSize: Extent2D,
}

PhysicalDeviceFragmentShadingRatePropertiesKHR ¶

PhysicalDeviceFragmentShadingRatePropertiesKHR :: struct {
	sType:                                                StructureType,
	pNext:                                                rawptr,
	minFragmentShadingRateAttachmentTexelSize:            Extent2D,
	maxFragmentShadingRateAttachmentTexelSize:            Extent2D,
	maxFragmentShadingRateAttachmentTexelSizeAspectRatio: u32,
	primitiveFragmentShadingRateWithMultipleViewports:    b32,
	layeredShadingRateAttachments:                        b32,
	fragmentShadingRateNonTrivialCombinerOps:             b32,
	maxFragmentSize:                                      Extent2D,
	maxFragmentSizeAspectRatio:                           u32,
	maxFragmentShadingRateCoverageSamples:                u32,
	maxFragmentShadingRateRasterizationSamples:           SampleCountFlags,
	fragmentShadingRateWithShaderDepthStencilWrites:      b32,
	fragmentShadingRateWithSampleMask:                    b32,
	fragmentShadingRateWithShaderSampleMask:              b32,
	fragmentShadingRateWithConservativeRasterization:     b32,
	fragmentShadingRateWithFragmentShaderInterlock:       b32,
	fragmentShadingRateWithCustomSampleLocations:         b32,
	fragmentShadingRateStrictMultiplyCombiner:            b32,
}

PhysicalDeviceGlobalPriorityQueryFeaturesKHR ¶

PhysicalDeviceGlobalPriorityQueryFeaturesKHR :: struct {
	sType:               StructureType,
	pNext:               rawptr,
	globalPriorityQuery: b32,
}

PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT ¶

PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT :: struct {
	sType:                   StructureType,
	pNext:                   rawptr,
	graphicsPipelineLibrary: b32,
}

PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT ¶

PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT :: struct {
	sType:                                                     StructureType,
	pNext:                                                     rawptr,
	graphicsPipelineLibraryFastLinking:                        b32,
	graphicsPipelineLibraryIndependentInterpolationDecoration: b32,
}

PhysicalDeviceGroupProperties ¶

PhysicalDeviceGroupProperties :: struct {
	sType:               StructureType,
	pNext:               rawptr,
	physicalDeviceCount: u32,
	physicalDevices:     [32]PhysicalDevice,
	subsetAllocation:    b32,
}

PhysicalDeviceHostQueryResetFeatures ¶

PhysicalDeviceHostQueryResetFeatures :: struct {
	sType:          StructureType,
	pNext:          rawptr,
	hostQueryReset: b32,
}

PhysicalDeviceIDProperties ¶

PhysicalDeviceIDProperties :: struct {
	sType:           StructureType,
	pNext:           rawptr,
	deviceUUID:      [16]u8,
	driverUUID:      [16]u8,
	deviceLUID:      [8]u8,
	deviceNodeMask:  u32,
	deviceLUIDValid: b32,
}

PhysicalDeviceImage2DViewOf3DFeaturesEXT ¶

PhysicalDeviceImage2DViewOf3DFeaturesEXT :: struct {
	sType:             StructureType,
	pNext:             rawptr,
	image2DViewOf3D:   b32,
	sampler2DViewOf3D: b32,
}

PhysicalDeviceImageDrmFormatModifierInfoEXT ¶

PhysicalDeviceImageDrmFormatModifierInfoEXT :: struct {
	sType:                 StructureType,
	pNext:                 rawptr,
	drmFormatModifier:     u64,
	sharingMode:           SharingMode,
	queueFamilyIndexCount: u32,
	pQueueFamilyIndices:   [^]u32,
}

PhysicalDeviceImageFormatInfo2 ¶

PhysicalDeviceImageFormatInfo2 :: struct {
	sType:  StructureType,
	pNext:  rawptr,
	format: Format,
	type:   ImageType,
	tiling: ImageTiling,
	usage:  ImageUsageFlags,
	flags:  ImageCreateFlags,
}

PhysicalDeviceImageRobustnessFeatures ¶

PhysicalDeviceImageRobustnessFeatures :: struct {
	sType:             StructureType,
	pNext:             rawptr,
	robustImageAccess: b32,
}

PhysicalDeviceImageViewImageFormatInfoEXT ¶

PhysicalDeviceImageViewImageFormatInfoEXT :: struct {
	sType:         StructureType,
	pNext:         rawptr,
	imageViewType: ImageViewType,
}

PhysicalDeviceImageViewMinLodFeaturesEXT ¶

PhysicalDeviceImageViewMinLodFeaturesEXT :: struct {
	sType:  StructureType,
	pNext:  rawptr,
	minLod: b32,
}

PhysicalDeviceImagelessFramebufferFeatures ¶

PhysicalDeviceImagelessFramebufferFeatures :: struct {
	sType:                StructureType,
	pNext:                rawptr,
	imagelessFramebuffer: b32,
}

PhysicalDeviceIndexTypeUint8FeaturesEXT ¶

PhysicalDeviceIndexTypeUint8FeaturesEXT :: struct {
	sType:          StructureType,
	pNext:          rawptr,
	indexTypeUint8: b32,
}

PhysicalDeviceInheritedViewportScissorFeaturesNV ¶

PhysicalDeviceInheritedViewportScissorFeaturesNV :: struct {
	sType:                      StructureType,
	pNext:                      rawptr,
	inheritedViewportScissor2D: b32,
}

PhysicalDeviceInlineUniformBlockFeatures ¶

PhysicalDeviceInlineUniformBlockFeatures :: struct {
	sType:                                              StructureType,
	pNext:                                              rawptr,
	inlineUniformBlock:                                 b32,
	descriptorBindingInlineUniformBlockUpdateAfterBind: b32,
}

PhysicalDeviceInlineUniformBlockProperties ¶

PhysicalDeviceInlineUniformBlockProperties :: struct {
	sType:                                                   StructureType,
	pNext:                                                   rawptr,
	maxInlineUniformBlockSize:                               u32,
	maxPerStageDescriptorInlineUniformBlocks:                u32,
	maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks: u32,
	maxDescriptorSetInlineUniformBlocks:                     u32,
	maxDescriptorSetUpdateAfterBindInlineUniformBlocks:      u32,
}

PhysicalDeviceInvocationMaskFeaturesHUAWEI ¶

PhysicalDeviceInvocationMaskFeaturesHUAWEI :: struct {
	sType:          StructureType,
	pNext:          rawptr,
	invocationMask: b32,
}

PhysicalDeviceLimits ¶

PhysicalDeviceLimits :: struct {
	maxImageDimension1D:                             u32,
	maxImageDimension2D:                             u32,
	maxImageDimension3D:                             u32,
	maxImageDimensionCube:                           u32,
	maxImageArrayLayers:                             u32,
	maxTexelBufferElements:                          u32,
	maxUniformBufferRange:                           u32,
	maxStorageBufferRange:                           u32,
	maxPushConstantsSize:                            u32,
	maxMemoryAllocationCount:                        u32,
	maxSamplerAllocationCount:                       u32,
	bufferImageGranularity:                          DeviceSize,
	sparseAddressSpaceSize:                          DeviceSize,
	maxBoundDescriptorSets:                          u32,
	maxPerStageDescriptorSamplers:                   u32,
	maxPerStageDescriptorUniformBuffers:             u32,
	maxPerStageDescriptorStorageBuffers:             u32,
	maxPerStageDescriptorSampledImages:              u32,
	maxPerStageDescriptorStorageImages:              u32,
	maxPerStageDescriptorInputAttachments:           u32,
	maxPerStageResources:                            u32,
	maxDescriptorSetSamplers:                        u32,
	maxDescriptorSetUniformBuffers:                  u32,
	maxDescriptorSetUniformBuffersDynamic:           u32,
	maxDescriptorSetStorageBuffers:                  u32,
	maxDescriptorSetStorageBuffersDynamic:           u32,
	maxDescriptorSetSampledImages:                   u32,
	maxDescriptorSetStorageImages:                   u32,
	maxDescriptorSetInputAttachments:                u32,
	maxVertexInputAttributes:                        u32,
	maxVertexInputBindings:                          u32,
	maxVertexInputAttributeOffset:                   u32,
	maxVertexInputBindingStride:                     u32,
	maxVertexOutputComponents:                       u32,
	maxTessellationGenerationLevel:                  u32,
	maxTessellationPatchSize:                        u32,
	maxTessellationControlPerVertexInputComponents:  u32,
	maxTessellationControlPerVertexOutputComponents: u32,
	maxTessellationControlPerPatchOutputComponents:  u32,
	maxTessellationControlTotalOutputComponents:     u32,
	maxTessellationEvaluationInputComponents:        u32,
	maxTessellationEvaluationOutputComponents:       u32,
	maxGeometryShaderInvocations:                    u32,
	maxGeometryInputComponents:                      u32,
	maxGeometryOutputComponents:                     u32,
	maxGeometryOutputVertices:                       u32,
	maxGeometryTotalOutputComponents:                u32,
	maxFragmentInputComponents:                      u32,
	maxFragmentOutputAttachments:                    u32,
	maxFragmentDualSrcAttachments:                   u32,
	maxFragmentCombinedOutputResources:              u32,
	maxComputeSharedMemorySize:                      u32,
	maxComputeWorkGroupCount:                        [3]u32,
	maxComputeWorkGroupInvocations:                  u32,
	maxComputeWorkGroupSize:                         [3]u32,
	subPixelPrecisionBits:                           u32,
	subTexelPrecisionBits:                           u32,
	mipmapPrecisionBits:                             u32,
	maxDrawIndexedIndexValue:                        u32,
	maxDrawIndirectCount:                            u32,
	maxSamplerLodBias:                               f32,
	maxSamplerAnisotropy:                            f32,
	maxViewports:                                    u32,
	maxViewportDimensions:                           [2]u32,
	viewportBoundsRange:                             [2]f32,
	viewportSubPixelBits:                            u32,
	minMemoryMapAlignment:                           int,
	minTexelBufferOffsetAlignment:                   DeviceSize,
	minUniformBufferOffsetAlignment:                 DeviceSize,
	minStorageBufferOffsetAlignment:                 DeviceSize,
	minTexelOffset:                                  i32,
	maxTexelOffset:                                  u32,
	minTexelGatherOffset:                            i32,
	maxTexelGatherOffset:                            u32,
	minInterpolationOffset:                          f32,
	maxInterpolationOffset:                          f32,
	subPixelInterpolationOffsetBits:                 u32,
	maxFramebufferWidth:                             u32,
	maxFramebufferHeight:                            u32,
	maxFramebufferLayers:                            u32,
	framebufferColorSampleCounts:                    SampleCountFlags,
	framebufferDepthSampleCounts:                    SampleCountFlags,
	framebufferStencilSampleCounts:                  SampleCountFlags,
	framebufferNoAttachmentsSampleCounts:            SampleCountFlags,
	maxColorAttachments:                             u32,
	sampledImageColorSampleCounts:                   SampleCountFlags,
	sampledImageIntegerSampleCounts:                 SampleCountFlags,
	sampledImageDepthSampleCounts:                   SampleCountFlags,
	sampledImageStencilSampleCounts:                 SampleCountFlags,
	storageImageSampleCounts:                        SampleCountFlags,
	maxSampleMaskWords:                              u32,
	timestampComputeAndGraphics:                     b32,
	timestampPeriod:                                 f32,
	maxClipDistances:                                u32,
	maxCullDistances:                                u32,
	maxCombinedClipAndCullDistances:                 u32,
	discreteQueuePriorities:                         u32,
	pointSizeRange:                                  [2]f32,
	lineWidthRange:                                  [2]f32,
	pointSizeGranularity:                            f32,
	lineWidthGranularity:                            f32,
	strictLines:                                     b32,
	standardSampleLocations:                         b32,
	optimalBufferCopyOffsetAlignment:                DeviceSize,
	optimalBufferCopyRowPitchAlignment:              DeviceSize,
	nonCoherentAtomSize:                             DeviceSize,
}

PhysicalDeviceLineRasterizationFeaturesEXT ¶

PhysicalDeviceLineRasterizationFeaturesEXT :: struct {
	sType:                    StructureType,
	pNext:                    rawptr,
	rectangularLines:         b32,
	bresenhamLines:           b32,
	smoothLines:              b32,
	stippledRectangularLines: b32,
	stippledBresenhamLines:   b32,
	stippledSmoothLines:      b32,
}

PhysicalDeviceLineRasterizationPropertiesEXT ¶

PhysicalDeviceLineRasterizationPropertiesEXT :: struct {
	sType:                     StructureType,
	pNext:                     rawptr,
	lineSubPixelPrecisionBits: u32,
}

PhysicalDeviceLinearColorAttachmentFeaturesNV ¶

PhysicalDeviceLinearColorAttachmentFeaturesNV :: struct {
	sType:                 StructureType,
	pNext:                 rawptr,
	linearColorAttachment: b32,
}

PhysicalDeviceMaintenance3Properties ¶

PhysicalDeviceMaintenance3Properties :: struct {
	sType:                   StructureType,
	pNext:                   rawptr,
	maxPerSetDescriptors:    u32,
	maxMemoryAllocationSize: DeviceSize,
}

PhysicalDeviceMaintenance4Features ¶

PhysicalDeviceMaintenance4Features :: struct {
	sType:        StructureType,
	pNext:        rawptr,
	maintenance4: b32,
}

PhysicalDeviceMaintenance4Properties ¶

PhysicalDeviceMaintenance4Properties :: struct {
	sType:         StructureType,
	pNext:         rawptr,
	maxBufferSize: DeviceSize,
}

PhysicalDeviceMemoryBudgetPropertiesEXT ¶

PhysicalDeviceMemoryBudgetPropertiesEXT :: struct {
	sType:      StructureType,
	pNext:      rawptr,
	heapBudget: [16]DeviceSize,
	heapUsage:  [16]DeviceSize,
}

PhysicalDeviceMemoryPriorityFeaturesEXT ¶

PhysicalDeviceMemoryPriorityFeaturesEXT :: struct {
	sType:          StructureType,
	pNext:          rawptr,
	memoryPriority: b32,
}

PhysicalDeviceMemoryProperties ¶

PhysicalDeviceMemoryProperties :: struct {
	memoryTypeCount: u32,
	memoryTypes:     [32]MemoryType,
	memoryHeapCount: u32,
	memoryHeaps:     [16]MemoryHeap,
}

PhysicalDeviceMemoryProperties2 ¶

PhysicalDeviceMemoryProperties2 :: struct {
	sType:            StructureType,
	pNext:            rawptr,
	memoryProperties: PhysicalDeviceMemoryProperties,
}

PhysicalDeviceMeshShaderFeaturesNV ¶

PhysicalDeviceMeshShaderFeaturesNV :: struct {
	sType:      StructureType,
	pNext:      rawptr,
	taskShader: b32,
	meshShader: b32,
}

PhysicalDeviceMeshShaderPropertiesNV ¶

PhysicalDeviceMeshShaderPropertiesNV :: struct {
	sType:                             StructureType,
	pNext:                             rawptr,
	maxDrawMeshTasksCount:             u32,
	maxTaskWorkGroupInvocations:       u32,
	maxTaskWorkGroupSize:              [3]u32,
	maxTaskTotalMemorySize:            u32,
	maxTaskOutputCount:                u32,
	maxMeshWorkGroupInvocations:       u32,
	maxMeshWorkGroupSize:              [3]u32,
	maxMeshTotalMemorySize:            u32,
	maxMeshOutputVertices:             u32,
	maxMeshOutputPrimitives:           u32,
	maxMeshMultiviewViewCount:         u32,
	meshOutputPerVertexGranularity:    u32,
	meshOutputPerPrimitiveGranularity: u32,
}

PhysicalDeviceMultiDrawFeaturesEXT ¶

PhysicalDeviceMultiDrawFeaturesEXT :: struct {
	sType:     StructureType,
	pNext:     rawptr,
	multiDraw: b32,
}

PhysicalDeviceMultiDrawPropertiesEXT ¶

PhysicalDeviceMultiDrawPropertiesEXT :: struct {
	sType:             StructureType,
	pNext:             rawptr,
	maxMultiDrawCount: u32,
}

PhysicalDeviceMultiviewFeatures ¶

PhysicalDeviceMultiviewFeatures :: struct {
	sType:                       StructureType,
	pNext:                       rawptr,
	multiview:                   b32,
	multiviewGeometryShader:     b32,
	multiviewTessellationShader: b32,
}

PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX ¶

PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX :: struct {
	sType:                        StructureType,
	pNext:                        rawptr,
	perViewPositionAllComponents: b32,
}

PhysicalDeviceMultiviewProperties ¶

PhysicalDeviceMultiviewProperties :: struct {
	sType:                     StructureType,
	pNext:                     rawptr,
	maxMultiviewViewCount:     u32,
	maxMultiviewInstanceIndex: u32,
}

PhysicalDeviceMutableDescriptorTypeFeaturesVALVE ¶

PhysicalDeviceMutableDescriptorTypeFeaturesVALVE :: struct {
	sType:                 StructureType,
	pNext:                 rawptr,
	mutableDescriptorType: b32,
}

PhysicalDevicePCIBusInfoPropertiesEXT ¶

PhysicalDevicePCIBusInfoPropertiesEXT :: struct {
	sType:       StructureType,
	pNext:       rawptr,
	pciDomain:   u32,
	pciBus:      u32,
	pciDevice:   u32,
	pciFunction: u32,
}

PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT ¶

PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT :: struct {
	sType:                     StructureType,
	pNext:                     rawptr,
	pageableDeviceLocalMemory: b32,
}

PhysicalDevicePerformanceQueryFeaturesKHR ¶

PhysicalDevicePerformanceQueryFeaturesKHR :: struct {
	sType:                                StructureType,
	pNext:                                rawptr,
	performanceCounterQueryPools:         b32,
	performanceCounterMultipleQueryPools: b32,
}

PhysicalDevicePerformanceQueryPropertiesKHR ¶

PhysicalDevicePerformanceQueryPropertiesKHR :: struct {
	sType:                         StructureType,
	pNext:                         rawptr,
	allowCommandBufferQueryCopies: b32,
}

PhysicalDevicePipelineCreationCacheControlFeatures ¶

PhysicalDevicePipelineCreationCacheControlFeatures :: struct {
	sType:                        StructureType,
	pNext:                        rawptr,
	pipelineCreationCacheControl: b32,
}

PhysicalDevicePipelineExecutablePropertiesFeaturesKHR ¶

PhysicalDevicePipelineExecutablePropertiesFeaturesKHR :: struct {
	sType:                  StructureType,
	pNext:                  rawptr,
	pipelineExecutableInfo: b32,
}

PhysicalDevicePointClippingProperties ¶

PhysicalDevicePointClippingProperties :: struct {
	sType:                 StructureType,
	pNext:                 rawptr,
	pointClippingBehavior: PointClippingBehavior,
}

PhysicalDevicePresentIdFeaturesKHR ¶

PhysicalDevicePresentIdFeaturesKHR :: struct {
	sType:     StructureType,
	pNext:     rawptr,
	presentId: b32,
}

PhysicalDevicePresentWaitFeaturesKHR ¶

PhysicalDevicePresentWaitFeaturesKHR :: struct {
	sType:       StructureType,
	pNext:       rawptr,
	presentWait: b32,
}

PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT ¶

PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT :: struct {
	sType:                             StructureType,
	pNext:                             rawptr,
	primitiveTopologyListRestart:      b32,
	primitiveTopologyPatchListRestart: b32,
}

PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT ¶

PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT :: struct {
	sType:                                         StructureType,
	pNext:                                         rawptr,
	primitivesGeneratedQuery:                      b32,
	primitivesGeneratedQueryWithRasterizerDiscard: b32,
	primitivesGeneratedQueryWithNonZeroStreams:    b32,
}

PhysicalDevicePrivateDataFeatures ¶

PhysicalDevicePrivateDataFeatures :: struct {
	sType:       StructureType,
	pNext:       rawptr,
	privateData: b32,
}

PhysicalDeviceProperties ¶

PhysicalDeviceProperties :: struct {
	apiVersion:        u32,
	driverVersion:     u32,
	vendorID:          u32,
	deviceID:          u32,
	deviceType:        PhysicalDeviceType,
	deviceName:        [256]u8,
	pipelineCacheUUID: [16]u8,
	limits:            PhysicalDeviceLimits,
	sparseProperties:  PhysicalDeviceSparseProperties,
}

PhysicalDeviceProperties2 ¶

PhysicalDeviceProperties2 :: struct {
	sType:      StructureType,
	pNext:      rawptr,
	properties: PhysicalDeviceProperties,
}

PhysicalDeviceProtectedMemoryFeatures ¶

PhysicalDeviceProtectedMemoryFeatures :: struct {
	sType:           StructureType,
	pNext:           rawptr,
	protectedMemory: b32,
}

PhysicalDeviceProtectedMemoryProperties ¶

PhysicalDeviceProtectedMemoryProperties :: struct {
	sType:            StructureType,
	pNext:            rawptr,
	protectedNoFault: b32,
}

PhysicalDeviceProvokingVertexFeaturesEXT ¶

PhysicalDeviceProvokingVertexFeaturesEXT :: struct {
	sType:                                     StructureType,
	pNext:                                     rawptr,
	provokingVertexLast:                       b32,
	transformFeedbackPreservesProvokingVertex: b32,
}

PhysicalDeviceProvokingVertexPropertiesEXT ¶

PhysicalDeviceProvokingVertexPropertiesEXT :: struct {
	sType:                                                StructureType,
	pNext:                                                rawptr,
	provokingVertexModePerPipeline:                       b32,
	transformFeedbackPreservesTriangleFanProvokingVertex: b32,
}

PhysicalDevicePushDescriptorPropertiesKHR ¶

PhysicalDevicePushDescriptorPropertiesKHR :: struct {
	sType:              StructureType,
	pNext:              rawptr,
	maxPushDescriptors: u32,
}

PhysicalDeviceRGBA10X6FormatsFeaturesEXT ¶

PhysicalDeviceRGBA10X6FormatsFeaturesEXT :: struct {
	sType:                             StructureType,
	pNext:                             rawptr,
	formatRgba10x6WithoutYCbCrSampler: b32,
}

PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM ¶

PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM :: struct {
	sType:                                     StructureType,
	pNext:                                     rawptr,
	rasterizationOrderColorAttachmentAccess:   b32,
	rasterizationOrderDepthAttachmentAccess:   b32,
	rasterizationOrderStencilAttachmentAccess: b32,
}

PhysicalDeviceRayQueryFeaturesKHR ¶

PhysicalDeviceRayQueryFeaturesKHR :: struct {
	sType:    StructureType,
	pNext:    rawptr,
	rayQuery: b32,
}

PhysicalDeviceRayTracingMotionBlurFeaturesNV ¶

PhysicalDeviceRayTracingMotionBlurFeaturesNV :: struct {
	sType:                                         StructureType,
	pNext:                                         rawptr,
	rayTracingMotionBlur:                          b32,
	rayTracingMotionBlurPipelineTraceRaysIndirect: b32,
}

PhysicalDeviceRayTracingPipelineFeaturesKHR ¶

PhysicalDeviceRayTracingPipelineFeaturesKHR :: struct {
	sType:                                                 StructureType,
	pNext:                                                 rawptr,
	rayTracingPipeline:                                    b32,
	rayTracingPipelineShaderGroupHandleCaptureReplay:      b32,
	rayTracingPipelineShaderGroupHandleCaptureReplayMixed: b32,
	rayTracingPipelineTraceRaysIndirect:                   b32,
	rayTraversalPrimitiveCulling:                          b32,
}

PhysicalDeviceRayTracingPipelinePropertiesKHR ¶

PhysicalDeviceRayTracingPipelinePropertiesKHR :: struct {
	sType:                              StructureType,
	pNext:                              rawptr,
	shaderGroupHandleSize:              u32,
	maxRayRecursionDepth:               u32,
	maxShaderGroupStride:               u32,
	shaderGroupBaseAlignment:           u32,
	shaderGroupHandleCaptureReplaySize: u32,
	maxRayDispatchInvocationCount:      u32,
	shaderGroupHandleAlignment:         u32,
	maxRayHitAttributeSize:             u32,
}

PhysicalDeviceRayTracingPropertiesNV ¶

PhysicalDeviceRayTracingPropertiesNV :: struct {
	sType:                                  StructureType,
	pNext:                                  rawptr,
	shaderGroupHandleSize:                  u32,
	maxRecursionDepth:                      u32,
	maxShaderGroupStride:                   u32,
	shaderGroupBaseAlignment:               u32,
	maxGeometryCount:                       u64,
	maxInstanceCount:                       u64,
	maxTriangleCount:                       u64,
	maxDescriptorSetAccelerationStructures: u32,
}

PhysicalDeviceRepresentativeFragmentTestFeaturesNV ¶

PhysicalDeviceRepresentativeFragmentTestFeaturesNV :: struct {
	sType:                      StructureType,
	pNext:                      rawptr,
	representativeFragmentTest: b32,
}

PhysicalDeviceRobustness2FeaturesEXT ¶

PhysicalDeviceRobustness2FeaturesEXT :: struct {
	sType:               StructureType,
	pNext:               rawptr,
	robustBufferAccess2: b32,
	robustImageAccess2:  b32,
	nullDescriptor:      b32,
}

PhysicalDeviceRobustness2PropertiesEXT ¶

PhysicalDeviceRobustness2PropertiesEXT :: struct {
	sType:                                  StructureType,
	pNext:                                  rawptr,
	robustStorageBufferAccessSizeAlignment: DeviceSize,
	robustUniformBufferAccessSizeAlignment: DeviceSize,
}

PhysicalDeviceSampleLocationsPropertiesEXT ¶

PhysicalDeviceSampleLocationsPropertiesEXT :: struct {
	sType:                         StructureType,
	pNext:                         rawptr,
	sampleLocationSampleCounts:    SampleCountFlags,
	maxSampleLocationGridSize:     Extent2D,
	sampleLocationCoordinateRange: [2]f32,
	sampleLocationSubPixelBits:    u32,
	variableSampleLocations:       b32,
}

PhysicalDeviceSamplerFilterMinmaxProperties ¶

PhysicalDeviceSamplerFilterMinmaxProperties :: struct {
	sType:                              StructureType,
	pNext:                              rawptr,
	filterMinmaxSingleComponentFormats: b32,
	filterMinmaxImageComponentMapping:  b32,
}

PhysicalDeviceSamplerYcbcrConversionFeatures ¶

PhysicalDeviceSamplerYcbcrConversionFeatures :: struct {
	sType:                  StructureType,
	pNext:                  rawptr,
	samplerYcbcrConversion: b32,
}

PhysicalDeviceScalarBlockLayoutFeatures ¶

PhysicalDeviceScalarBlockLayoutFeatures :: struct {
	sType:             StructureType,
	pNext:             rawptr,
	scalarBlockLayout: b32,
}

PhysicalDeviceSeparateDepthStencilLayoutsFeatures ¶

PhysicalDeviceSeparateDepthStencilLayoutsFeatures :: struct {
	sType:                       StructureType,
	pNext:                       rawptr,
	separateDepthStencilLayouts: b32,
}

PhysicalDeviceShaderAtomicFloat2FeaturesEXT ¶

PhysicalDeviceShaderAtomicFloat2FeaturesEXT :: struct {
	sType:                           StructureType,
	pNext:                           rawptr,
	shaderBufferFloat16Atomics:      b32,
	shaderBufferFloat16AtomicAdd:    b32,
	shaderBufferFloat16AtomicMinMax: b32,
	shaderBufferFloat32AtomicMinMax: b32,
	shaderBufferFloat64AtomicMinMax: b32,
	shaderSharedFloat16Atomics:      b32,
	shaderSharedFloat16AtomicAdd:    b32,
	shaderSharedFloat16AtomicMinMax: b32,
	shaderSharedFloat32AtomicMinMax: b32,
	shaderSharedFloat64AtomicMinMax: b32,
	shaderImageFloat32AtomicMinMax:  b32,
	sparseImageFloat32AtomicMinMax:  b32,
}

PhysicalDeviceShaderAtomicFloatFeaturesEXT ¶

PhysicalDeviceShaderAtomicFloatFeaturesEXT :: struct {
	sType:                        StructureType,
	pNext:                        rawptr,
	shaderBufferFloat32Atomics:   b32,
	shaderBufferFloat32AtomicAdd: b32,
	shaderBufferFloat64Atomics:   b32,
	shaderBufferFloat64AtomicAdd: b32,
	shaderSharedFloat32Atomics:   b32,
	shaderSharedFloat32AtomicAdd: b32,
	shaderSharedFloat64Atomics:   b32,
	shaderSharedFloat64AtomicAdd: b32,
	shaderImageFloat32Atomics:    b32,
	shaderImageFloat32AtomicAdd:  b32,
	sparseImageFloat32Atomics:    b32,
	sparseImageFloat32AtomicAdd:  b32,
}

PhysicalDeviceShaderAtomicInt64Features ¶

PhysicalDeviceShaderAtomicInt64Features :: struct {
	sType:                    StructureType,
	pNext:                    rawptr,
	shaderBufferInt64Atomics: b32,
	shaderSharedInt64Atomics: b32,
}

PhysicalDeviceShaderClockFeaturesKHR ¶

PhysicalDeviceShaderClockFeaturesKHR :: struct {
	sType:               StructureType,
	pNext:               rawptr,
	shaderSubgroupClock: b32,
	shaderDeviceClock:   b32,
}

PhysicalDeviceShaderCoreProperties2AMD ¶

PhysicalDeviceShaderCoreProperties2AMD :: struct {
	sType:                  StructureType,
	pNext:                  rawptr,
	shaderCoreFeatures:     ShaderCorePropertiesFlagsAMD,
	activeComputeUnitCount: u32,
}

PhysicalDeviceShaderCorePropertiesAMD ¶

PhysicalDeviceShaderCorePropertiesAMD :: struct {
	sType:                      StructureType,
	pNext:                      rawptr,
	shaderEngineCount:          u32,
	shaderArraysPerEngineCount: u32,
	computeUnitsPerShaderArray: u32,
	simdPerComputeUnit:         u32,
	wavefrontsPerSimd:          u32,
	wavefrontSize:              u32,
	sgprsPerSimd:               u32,
	minSgprAllocation:          u32,
	maxSgprAllocation:          u32,
	sgprAllocationGranularity:  u32,
	vgprsPerSimd:               u32,
	minVgprAllocation:          u32,
	maxVgprAllocation:          u32,
	vgprAllocationGranularity:  u32,
}

PhysicalDeviceShaderDemoteToHelperInvocationFeatures ¶

PhysicalDeviceShaderDemoteToHelperInvocationFeatures :: struct {
	sType:                          StructureType,
	pNext:                          rawptr,
	shaderDemoteToHelperInvocation: b32,
}

PhysicalDeviceShaderDrawParametersFeatures ¶

PhysicalDeviceShaderDrawParametersFeatures :: struct {
	sType:                StructureType,
	pNext:                rawptr,
	shaderDrawParameters: b32,
}

PhysicalDeviceShaderFloat16Int8Features ¶

PhysicalDeviceShaderFloat16Int8Features :: struct {
	sType:         StructureType,
	pNext:         rawptr,
	shaderFloat16: b32,
	shaderInt8:    b32,
}

PhysicalDeviceShaderImageAtomicInt64FeaturesEXT ¶

PhysicalDeviceShaderImageAtomicInt64FeaturesEXT :: struct {
	sType:                   StructureType,
	pNext:                   rawptr,
	shaderImageInt64Atomics: b32,
	sparseImageInt64Atomics: b32,
}

PhysicalDeviceShaderImageFootprintFeaturesNV ¶

PhysicalDeviceShaderImageFootprintFeaturesNV :: struct {
	sType:          StructureType,
	pNext:          rawptr,
	imageFootprint: b32,
}

PhysicalDeviceShaderIntegerDotProductFeatures ¶

PhysicalDeviceShaderIntegerDotProductFeatures :: struct {
	sType:                   StructureType,
	pNext:                   rawptr,
	shaderIntegerDotProduct: b32,
}

PhysicalDeviceShaderIntegerDotProductProperties ¶

PhysicalDeviceShaderIntegerDotProductProperties :: struct {
	sType:                                                                         StructureType,
	pNext:                                                                         rawptr,
	integerDotProduct8BitUnsignedAccelerated:                                      b32,
	integerDotProduct8BitSignedAccelerated:                                        b32,
	integerDotProduct8BitMixedSignednessAccelerated:                               b32,
	integerDotProduct4x8BitPackedUnsignedAccelerated:                              b32,
	integerDotProduct4x8BitPackedSignedAccelerated:                                b32,
	integerDotProduct4x8BitPackedMixedSignednessAccelerated:                       b32,
	integerDotProduct16BitUnsignedAccelerated:                                     b32,
	integerDotProduct16BitSignedAccelerated:                                       b32,
	integerDotProduct16BitMixedSignednessAccelerated:                              b32,
	integerDotProduct32BitUnsignedAccelerated:                                     b32,
	integerDotProduct32BitSignedAccelerated:                                       b32,
	integerDotProduct32BitMixedSignednessAccelerated:                              b32,
	integerDotProduct64BitUnsignedAccelerated:                                     b32,
	integerDotProduct64BitSignedAccelerated:                                       b32,
	integerDotProduct64BitMixedSignednessAccelerated:                              b32,
	integerDotProductAccumulatingSaturating8BitUnsignedAccelerated:                b32,
	integerDotProductAccumulatingSaturating8BitSignedAccelerated:                  b32,
	integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated:         b32,
	integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated:        b32,
	integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated:          b32,
	integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated: b32,
	integerDotProductAccumulatingSaturating16BitUnsignedAccelerated:               b32,
	integerDotProductAccumulatingSaturating16BitSignedAccelerated:                 b32,
	integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated:        b32,
	integerDotProductAccumulatingSaturating32BitUnsignedAccelerated:               b32,
	integerDotProductAccumulatingSaturating32BitSignedAccelerated:                 b32,
	integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated:        b32,
	integerDotProductAccumulatingSaturating64BitUnsignedAccelerated:               b32,
	integerDotProductAccumulatingSaturating64BitSignedAccelerated:                 b32,
	integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated:        b32,
}

PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL ¶

PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL :: struct {
	sType:                   StructureType,
	pNext:                   rawptr,
	shaderIntegerFunctions2: b32,
}

PhysicalDeviceShaderSMBuiltinsFeaturesNV ¶

PhysicalDeviceShaderSMBuiltinsFeaturesNV :: struct {
	sType:            StructureType,
	pNext:            rawptr,
	shaderSMBuiltins: b32,
}

PhysicalDeviceShaderSMBuiltinsPropertiesNV ¶

PhysicalDeviceShaderSMBuiltinsPropertiesNV :: struct {
	sType:            StructureType,
	pNext:            rawptr,
	shaderSMCount:    u32,
	shaderWarpsPerSM: u32,
}

PhysicalDeviceShaderSubgroupExtendedTypesFeatures ¶

PhysicalDeviceShaderSubgroupExtendedTypesFeatures :: struct {
	sType:                       StructureType,
	pNext:                       rawptr,
	shaderSubgroupExtendedTypes: b32,
}

PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR ¶

PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR :: struct {
	sType:                            StructureType,
	pNext:                            rawptr,
	shaderSubgroupUniformControlFlow: b32,
}

PhysicalDeviceShaderTerminateInvocationFeatures ¶

PhysicalDeviceShaderTerminateInvocationFeatures :: struct {
	sType:                     StructureType,
	pNext:                     rawptr,
	shaderTerminateInvocation: b32,
}

PhysicalDeviceShadingRateImageFeaturesNV ¶

PhysicalDeviceShadingRateImageFeaturesNV :: struct {
	sType:                        StructureType,
	pNext:                        rawptr,
	shadingRateImage:             b32,
	shadingRateCoarseSampleOrder: b32,
}

PhysicalDeviceShadingRateImagePropertiesNV ¶

PhysicalDeviceShadingRateImagePropertiesNV :: struct {
	sType:                       StructureType,
	pNext:                       rawptr,
	shadingRateTexelSize:        Extent2D,
	shadingRatePaletteSize:      u32,
	shadingRateMaxCoarseSamples: u32,
}

PhysicalDeviceSparseImageFormatInfo2 ¶

PhysicalDeviceSparseImageFormatInfo2 :: struct {
	sType:   StructureType,
	pNext:   rawptr,
	format:  Format,
	type:    ImageType,
	samples: SampleCountFlags,
	usage:   ImageUsageFlags,
	tiling:  ImageTiling,
}

PhysicalDeviceSparseProperties ¶

PhysicalDeviceSparseProperties :: struct {
	residencyStandard2DBlockShape:            b32,
	residencyStandard2DMultisampleBlockShape: b32,
	residencyStandard3DBlockShape:            b32,
	residencyAlignedMipSize:                  b32,
	residencyNonResidentStrict:               b32,
}

PhysicalDeviceSubgroupProperties ¶

PhysicalDeviceSubgroupProperties :: struct {
	sType:                     StructureType,
	pNext:                     rawptr,
	subgroupSize:              u32,
	supportedStages:           ShaderStageFlags,
	supportedOperations:       SubgroupFeatureFlags,
	quadOperationsInAllStages: b32,
}

PhysicalDeviceSubgroupSizeControlFeatures ¶

PhysicalDeviceSubgroupSizeControlFeatures :: struct {
	sType:                StructureType,
	pNext:                rawptr,
	subgroupSizeControl:  b32,
	computeFullSubgroups: b32,
}

PhysicalDeviceSubgroupSizeControlProperties ¶

PhysicalDeviceSubgroupSizeControlProperties :: struct {
	sType:                        StructureType,
	pNext:                        rawptr,
	minSubgroupSize:              u32,
	maxSubgroupSize:              u32,
	maxComputeWorkgroupSubgroups: u32,
	requiredSubgroupSizeStages:   ShaderStageFlags,
}

PhysicalDeviceSubpassShadingFeaturesHUAWEI ¶

PhysicalDeviceSubpassShadingFeaturesHUAWEI :: struct {
	sType:          StructureType,
	pNext:          rawptr,
	subpassShading: b32,
}

PhysicalDeviceSubpassShadingPropertiesHUAWEI ¶

PhysicalDeviceSubpassShadingPropertiesHUAWEI :: struct {
	sType:                                     StructureType,
	pNext:                                     rawptr,
	maxSubpassShadingWorkgroupSizeAspectRatio: u32,
}

PhysicalDeviceSurfaceInfo2KHR ¶

PhysicalDeviceSurfaceInfo2KHR :: struct {
	sType:   StructureType,
	pNext:   rawptr,
	surface: SurfaceKHR,
}

PhysicalDeviceSynchronization2Features ¶

PhysicalDeviceSynchronization2Features :: struct {
	sType:            StructureType,
	pNext:            rawptr,
	synchronization2: b32,
}

PhysicalDeviceTexelBufferAlignmentFeaturesEXT ¶

PhysicalDeviceTexelBufferAlignmentFeaturesEXT :: struct {
	sType:                StructureType,
	pNext:                rawptr,
	texelBufferAlignment: b32,
}

PhysicalDeviceTexelBufferAlignmentProperties ¶

PhysicalDeviceTexelBufferAlignmentProperties :: struct {
	sType:                                        StructureType,
	pNext:                                        rawptr,
	storageTexelBufferOffsetAlignmentBytes:       DeviceSize,
	storageTexelBufferOffsetSingleTexelAlignment: b32,
	uniformTexelBufferOffsetAlignmentBytes:       DeviceSize,
	uniformTexelBufferOffsetSingleTexelAlignment: b32,
}

PhysicalDeviceTextureCompressionASTCHDRFeatures ¶

PhysicalDeviceTextureCompressionASTCHDRFeatures :: struct {
	sType:                      StructureType,
	pNext:                      rawptr,
	textureCompressionASTC_HDR: b32,
}

PhysicalDeviceTimelineSemaphoreFeatures ¶

PhysicalDeviceTimelineSemaphoreFeatures :: struct {
	sType:             StructureType,
	pNext:             rawptr,
	timelineSemaphore: b32,
}

PhysicalDeviceTimelineSemaphoreProperties ¶

PhysicalDeviceTimelineSemaphoreProperties :: struct {
	sType:                               StructureType,
	pNext:                               rawptr,
	maxTimelineSemaphoreValueDifference: u64,
}

PhysicalDeviceToolProperties ¶

PhysicalDeviceToolProperties :: struct {
	sType:       StructureType,
	pNext:       rawptr,
	name:        [256]u8,
	version:     [256]u8,
	purposes:    ToolPurposeFlags,
	description: [256]u8,
	layer:       [256]u8,
}

PhysicalDeviceTransformFeedbackFeaturesEXT ¶

PhysicalDeviceTransformFeedbackFeaturesEXT :: struct {
	sType:             StructureType,
	pNext:             rawptr,
	transformFeedback: b32,
	geometryStreams:   b32,
}

PhysicalDeviceTransformFeedbackPropertiesEXT ¶

PhysicalDeviceTransformFeedbackPropertiesEXT :: struct {
	sType:                                      StructureType,
	pNext:                                      rawptr,
	maxTransformFeedbackStreams:                u32,
	maxTransformFeedbackBuffers:                u32,
	maxTransformFeedbackBufferSize:             DeviceSize,
	maxTransfor