package vendor:vulkan

Source

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

AabbPositionsNV :: AabbPositionsKHR

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 :: struct {
	primitiveCount:  u32,
	primitiveOffset: u32,
	firstVertex:     u32,
	transformOffset: u32,
}

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

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

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

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

AccelerationStructureCreateFlagsKHR :: distinct bit_set[AccelerationStructureCreateFlagKHR; Flags]

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

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

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

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

AccelerationStructureGeometryDataKHR :: struct #raw_union {
	triangles: AccelerationStructureGeometryTrianglesDataKHR,
	aabbs:     AccelerationStructureGeometryAabbsDataKHR,
	instances: AccelerationStructureGeometryInstancesDataKHR,
}

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

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

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

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

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

AccelerationStructureInstanceKHR :: struct {
	transform:                      TransformMatrixKHR,
	accelerationStructureReference: u64,
}

AccelerationStructureInstanceNV :: AccelerationStructureInstanceKHR

AccelerationStructureKHR :: distinct u64

AccelerationStructureMatrixMotionInstanceNV :: struct {
	transformT0:                    TransformMatrixKHR,
	transformT1:                    TransformMatrixKHR,
	accelerationStructureReference: u64,
}

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

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

AccelerationStructureMotionInfoFlagNV :: enum u32 {
}

AccelerationStructureMotionInfoFlagsNV :: distinct bit_set[AccelerationStructureMotionInfoFlagNV; Flags]

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

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

AccelerationStructureMotionInstanceFlagNV :: enum u32 {
}

AccelerationStructureMotionInstanceFlagsNV :: distinct bit_set[AccelerationStructureMotionInstanceFlagNV; Flags]

AccelerationStructureMotionInstanceNV :: struct {
	type:  AccelerationStructureMotionInstanceTypeNV,
	flags: AccelerationStructureMotionInstanceFlagsNV,
	data:  AccelerationStructureMotionInstanceDataNV,
}

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

AccelerationStructureNV :: distinct u64

AccelerationStructureSRTMotionInstanceNV :: struct {
	transformT0:                    SRTDataNV,
	transformT1:                    SRTDataNV,
	accelerationStructureReference: u64,
}

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

AccelerationStructureTypeNV :: AccelerationStructureTypeKHR

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

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

AccessFlag2 :: Flags64

AccessFlag2KHR :: Flags64

AccessFlags :: distinct bit_set[AccessFlag; Flags]

AccessFlags2 :: Flags64

AccessFlags2KHR :: Flags64

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

AcquireProfilingLockFlagKHR :: enum Flags {
}

AcquireProfilingLockFlagsKHR :: distinct bit_set[AcquireProfilingLockFlagKHR; Flags]

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

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

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

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

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

AttachmentDescription2KHR :: AttachmentDescription2

AttachmentDescriptionFlag :: enum Flags {
	MAY_ALIAS = 0, 
}

AttachmentDescriptionFlags :: distinct bit_set[AttachmentDescriptionFlag; Flags]

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

AttachmentDescriptionStencilLayoutKHR :: AttachmentDescriptionStencilLayout

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

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

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

AttachmentReference2KHR :: AttachmentReference2

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

AttachmentReferenceStencilLayoutKHR :: AttachmentReferenceStencilLayout

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

AttachmentSampleCountInfoNV :: AttachmentSampleCountInfoAMD

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

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

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

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

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

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

BindBufferMemoryDeviceGroupInfoKHR :: BindBufferMemoryDeviceGroupInfo

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

BindBufferMemoryInfoKHR :: BindBufferMemoryInfo

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

BindImageMemoryDeviceGroupInfoKHR :: BindImageMemoryDeviceGroupInfo

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

BindImageMemoryInfoKHR :: BindImageMemoryInfo

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

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

BindImagePlaneMemoryInfoKHR :: BindImagePlaneMemoryInfo

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

BindShaderGroupIndirectCommandNV :: struct {
	groupIndex: u32,
}

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 :: struct {
	bufferAddress: DeviceAddress,
	size:          u32,
	stride:        u32,
}

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 :: 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 :: enum i32 {
	UNCORRELATED = 0, 
	DISJOINT     = 1, 
	CONJOINT     = 2, 
}

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

BlitImageInfo2KHR :: BlitImageInfo2

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 :: distinct u64

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

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

BufferCopy2KHR :: BufferCopy2

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 :: distinct bit_set[BufferCreateFlag; Flags]

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

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

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

BufferDeviceAddressInfoEXT :: BufferDeviceAddressInfo

BufferDeviceAddressInfoKHR :: BufferDeviceAddressInfo

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

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

BufferImageCopy2KHR :: BufferImageCopy2

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

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

BufferMemoryBarrier2KHR :: BufferMemoryBarrier2

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

BufferMemoryRequirementsInfo2KHR :: BufferMemoryRequirementsInfo2

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

BufferOpaqueCaptureAddressCreateInfoKHR :: BufferOpaqueCaptureAddressCreateInfo

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 :: distinct bit_set[BufferUsageFlag; Flags]

BufferView :: distinct u64

BufferViewCreateFlag :: enum u32 {
}

BufferViewCreateFlags :: distinct bit_set[BufferViewCreateFlag; Flags]

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

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

BuildAccelerationStructureFlagNV :: BuildAccelerationStructureFlagKHR

BuildAccelerationStructureFlagsKHR :: distinct bit_set[BuildAccelerationStructureFlagKHR; Flags]

BuildAccelerationStructureFlagsNV :: BuildAccelerationStructureFlagsKHR

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

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

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

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