Skip to content

Instantly share code, notes, and snippets.

@eddyb

eddyb/ash-rewrite-cdecl-pseudo-rust-dump.rs Secret

Created January 28, 2024 00:56
Show Gist options
  • Save eddyb/5ae0247468892ea7dd2a136ed3afa869 to your computer and use it in GitHub Desktop.
Save eddyb/5ae0247468892ea7dd2a136ed3afa869 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
ash-rewrite-cdecl-pseudo-rust-dump.rs
type PFN_vkInternalAllocationNotification = unsafe extern fn(
pUserData: *mut void,
size: size_t,
allocationType: VkInternalAllocationType,
allocationScope: VkSystemAllocationScope,
);
type PFN_vkInternalFreeNotification = unsafe extern fn(
pUserData: *mut void,
size: size_t,
allocationType: VkInternalAllocationType,
allocationScope: VkSystemAllocationScope,
);
type PFN_vkReallocationFunction = unsafe extern fn(
pUserData: *mut void,
pOriginal: *mut void,
size: size_t,
alignment: size_t,
allocationScope: VkSystemAllocationScope,
) -> *mut void;
type PFN_vkAllocationFunction = unsafe extern fn(
pUserData: *mut void,
size: size_t,
alignment: size_t,
allocationScope: VkSystemAllocationScope,
) -> *mut void;
type PFN_vkFreeFunction = unsafe extern fn(
pUserData: *mut void,
pMemory: *mut void,
);
type PFN_vkVoidFunction = unsafe extern fn();
type PFN_vkDebugReportCallbackEXT = unsafe extern fn(
flags: VkDebugReportFlagsEXT,
objectType: VkDebugReportObjectTypeEXT,
object: uint64_t,
location: size_t,
messageCode: int32_t,
pLayerPrefix: *const char,
pMessage: *const char,
pUserData: *mut void,
) -> VkBool32;
type PFN_vkDebugUtilsMessengerCallbackEXT = unsafe extern fn(
messageSeverity: VkDebugUtilsMessageSeverityFlagBitsEXT,
messageTypes: VkDebugUtilsMessageTypeFlagsEXT,
pCallbackData: *const VkDebugUtilsMessengerCallbackDataEXT,
pUserData: *mut void,
) -> VkBool32;
type PFN_vkFaultCallbackFunction = unsafe extern fn(
unrecordedFaults: VkBool32,
faultCount: uint32_t,
pFaults: *const VkFaultData,
);
type PFN_vkDeviceMemoryReportCallbackEXT = unsafe extern fn(
pCallbackData: *const VkDeviceMemoryReportCallbackDataEXT,
pUserData: *mut void,
);
type PFN_vkGetInstanceProcAddrLUNARG = unsafe extern fn(
instance: VkInstance,
pName: *const char,
) -> PFN_vkVoidFunction;
struct VkBaseOutStructure {
sType: VkStructureType,
pNext: *mut /*struct*/VkBaseOutStructure,
}
struct VkBaseInStructure {
sType: VkStructureType,
pNext: *const /*struct*/VkBaseInStructure,
}
struct VkOffset2D {
x: int32_t,
y: int32_t,
}
struct VkOffset3D {
x: int32_t,
y: int32_t,
z: int32_t,
}
struct VkExtent2D {
width: uint32_t,
height: uint32_t,
}
struct VkExtent3D {
width: uint32_t,
height: uint32_t,
depth: uint32_t,
}
struct VkViewport {
x: float,
y: float,
width: float,
height: float,
minDepth: float,
maxDepth: float,
}
struct VkRect2D {
offset: VkOffset2D,
extent: VkExtent2D,
}
struct VkClearRect {
rect: VkRect2D,
baseArrayLayer: uint32_t,
layerCount: uint32_t,
}
struct VkComponentMapping {
r: VkComponentSwizzle,
g: VkComponentSwizzle,
b: VkComponentSwizzle,
a: VkComponentSwizzle,
}
struct VkPhysicalDeviceProperties {
apiVersion: uint32_t,
driverVersion: uint32_t,
vendorID: uint32_t,
deviceID: uint32_t,
deviceType: VkPhysicalDeviceType,
deviceName: [char; VK_MAX_PHYSICAL_DEVICE_NAME_SIZE],
pipelineCacheUUID: [uint8_t; VK_UUID_SIZE],
limits: VkPhysicalDeviceLimits,
sparseProperties: VkPhysicalDeviceSparseProperties,
}
struct VkExtensionProperties {
extensionName: [char; VK_MAX_EXTENSION_NAME_SIZE],
specVersion: uint32_t,
}
struct VkLayerProperties {
layerName: [char; VK_MAX_EXTENSION_NAME_SIZE],
specVersion: uint32_t,
implementationVersion: uint32_t,
description: [char; VK_MAX_DESCRIPTION_SIZE],
}
struct VkApplicationInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_APPLICATION_INFO,
pNext: *const void,
pApplicationName: *const [char; dyn null-terminated],
applicationVersion: uint32_t,
pEngineName: *const [char; dyn null-terminated],
engineVersion: uint32_t,
apiVersion: uint32_t,
}
struct VkAllocationCallbacks {
pUserData: *mut void,
pfnAllocation: PFN_vkAllocationFunction,
pfnReallocation: PFN_vkReallocationFunction,
pfnFree: PFN_vkFreeFunction,
pfnInternalAllocation: PFN_vkInternalAllocationNotification,
pfnInternalFree: PFN_vkInternalFreeNotification,
}
struct VkDeviceQueueCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
pNext: *const void,
flags: VkDeviceQueueCreateFlags,
queueFamilyIndex: uint32_t,
queueCount: uint32_t,
pQueuePriorities: *const [float; dyn queueCount],
}
struct VkDeviceCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
pNext: *const void,
flags: VkDeviceCreateFlags,
queueCreateInfoCount: uint32_t,
pQueueCreateInfos: *const [VkDeviceQueueCreateInfo; dyn queueCreateInfoCount],
enabledLayerCount: uint32_t,
ppEnabledLayerNames: *const [*const char; dyn enabledLayerCount,null-terminated],
enabledExtensionCount: uint32_t,
ppEnabledExtensionNames: *const [*const char; dyn enabledExtensionCount,null-terminated],
pEnabledFeatures: *const VkPhysicalDeviceFeatures,
}
struct VkInstanceCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
pNext: *const void,
flags: VkInstanceCreateFlags,
pApplicationInfo: *const VkApplicationInfo,
enabledLayerCount: uint32_t,
ppEnabledLayerNames: *const [*const char; dyn enabledLayerCount,null-terminated],
enabledExtensionCount: uint32_t,
ppEnabledExtensionNames: *const [*const char; dyn enabledExtensionCount,null-terminated],
}
struct VkQueueFamilyProperties {
queueFlags: VkQueueFlags,
queueCount: uint32_t,
timestampValidBits: uint32_t,
minImageTransferGranularity: VkExtent3D,
}
struct VkPhysicalDeviceMemoryProperties {
memoryTypeCount: uint32_t,
memoryTypes: [VkMemoryType; VK_MAX_MEMORY_TYPES],
memoryHeapCount: uint32_t,
memoryHeaps: [VkMemoryHeap; VK_MAX_MEMORY_HEAPS],
}
struct VkMemoryAllocateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
pNext: *const void,
allocationSize: VkDeviceSize,
memoryTypeIndex: uint32_t,
}
struct VkMemoryRequirements {
size: VkDeviceSize,
alignment: VkDeviceSize,
memoryTypeBits: uint32_t,
}
struct VkSparseImageFormatProperties {
aspectMask: VkImageAspectFlags,
imageGranularity: VkExtent3D,
flags: VkSparseImageFormatFlags,
}
struct VkSparseImageMemoryRequirements {
formatProperties: VkSparseImageFormatProperties,
imageMipTailFirstLod: uint32_t,
imageMipTailSize: VkDeviceSize,
imageMipTailOffset: VkDeviceSize,
imageMipTailStride: VkDeviceSize,
}
struct VkMemoryType {
propertyFlags: VkMemoryPropertyFlags,
heapIndex: uint32_t,
}
struct VkMemoryHeap {
size: VkDeviceSize,
flags: VkMemoryHeapFlags,
}
struct VkMappedMemoryRange {
sType: VkStructureType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,
pNext: *const void,
memory: VkDeviceMemory,
offset: VkDeviceSize,
size: VkDeviceSize,
}
struct VkFormatProperties {
linearTilingFeatures: VkFormatFeatureFlags,
optimalTilingFeatures: VkFormatFeatureFlags,
bufferFeatures: VkFormatFeatureFlags,
}
struct VkImageFormatProperties {
maxExtent: VkExtent3D,
maxMipLevels: uint32_t,
maxArrayLayers: uint32_t,
sampleCounts: VkSampleCountFlags,
maxResourceSize: VkDeviceSize,
}
struct VkDescriptorBufferInfo {
buffer: VkBuffer,
offset: VkDeviceSize,
range: VkDeviceSize,
}
struct VkDescriptorImageInfo {
sampler: VkSampler,
imageView: VkImageView,
imageLayout: VkImageLayout,
}
struct VkWriteDescriptorSet {
sType: VkStructureType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
pNext: *const void,
dstSet: VkDescriptorSet,
dstBinding: uint32_t,
dstArrayElement: uint32_t,
descriptorCount: uint32_t,
descriptorType: VkDescriptorType,
pImageInfo: *const [VkDescriptorImageInfo; dyn descriptorCount],
pBufferInfo: *const [VkDescriptorBufferInfo; dyn descriptorCount],
pTexelBufferView: *const [VkBufferView; dyn descriptorCount],
}
struct VkCopyDescriptorSet {
sType: VkStructureType = VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET,
pNext: *const void,
srcSet: VkDescriptorSet,
srcBinding: uint32_t,
srcArrayElement: uint32_t,
dstSet: VkDescriptorSet,
dstBinding: uint32_t,
dstArrayElement: uint32_t,
descriptorCount: uint32_t,
}
struct VkBufferUsageFlags2CreateInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR,
pNext: *const void,
usage: VkBufferUsageFlags2KHR,
}
struct VkBufferCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
pNext: *const void,
flags: VkBufferCreateFlags,
size: VkDeviceSize,
usage: VkBufferUsageFlags,
sharingMode: VkSharingMode,
queueFamilyIndexCount: uint32_t,
pQueueFamilyIndices: *const [uint32_t; dyn queueFamilyIndexCount],
}
struct VkBufferViewCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO,
pNext: *const void,
flags: VkBufferViewCreateFlags,
buffer: VkBuffer,
format: VkFormat,
offset: VkDeviceSize,
range: VkDeviceSize,
}
struct VkImageSubresource {
aspectMask: VkImageAspectFlags,
mipLevel: uint32_t,
arrayLayer: uint32_t,
}
struct VkImageSubresourceLayers {
aspectMask: VkImageAspectFlags,
mipLevel: uint32_t,
baseArrayLayer: uint32_t,
layerCount: uint32_t,
}
struct VkImageSubresourceRange {
aspectMask: VkImageAspectFlags,
baseMipLevel: uint32_t,
levelCount: uint32_t,
baseArrayLayer: uint32_t,
layerCount: uint32_t,
}
struct VkMemoryBarrier {
sType: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_BARRIER,
pNext: *const void,
srcAccessMask: VkAccessFlags,
dstAccessMask: VkAccessFlags,
}
struct VkBufferMemoryBarrier {
sType: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
pNext: *const void,
srcAccessMask: VkAccessFlags,
dstAccessMask: VkAccessFlags,
srcQueueFamilyIndex: uint32_t,
dstQueueFamilyIndex: uint32_t,
buffer: VkBuffer,
offset: VkDeviceSize,
size: VkDeviceSize,
}
struct VkImageMemoryBarrier {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
pNext: *const void,
srcAccessMask: VkAccessFlags,
dstAccessMask: VkAccessFlags,
oldLayout: VkImageLayout,
newLayout: VkImageLayout,
srcQueueFamilyIndex: uint32_t,
dstQueueFamilyIndex: uint32_t,
image: VkImage,
subresourceRange: VkImageSubresourceRange,
}
struct VkImageCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
pNext: *const void,
flags: VkImageCreateFlags,
imageType: VkImageType,
format: VkFormat,
extent: VkExtent3D,
mipLevels: uint32_t,
arrayLayers: uint32_t,
samples: VkSampleCountFlagBits,
tiling: VkImageTiling,
usage: VkImageUsageFlags,
sharingMode: VkSharingMode,
queueFamilyIndexCount: uint32_t,
pQueueFamilyIndices: *const [uint32_t; dyn queueFamilyIndexCount],
initialLayout: VkImageLayout,
}
struct VkSubresourceLayout {
offset: VkDeviceSize,
size: VkDeviceSize,
rowPitch: VkDeviceSize,
arrayPitch: VkDeviceSize,
depthPitch: VkDeviceSize,
}
struct VkImageViewCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
pNext: *const void,
flags: VkImageViewCreateFlags,
image: VkImage,
viewType: VkImageViewType,
format: VkFormat,
components: VkComponentMapping,
subresourceRange: VkImageSubresourceRange,
}
struct VkBufferCopy {
srcOffset: VkDeviceSize,
dstOffset: VkDeviceSize,
size: VkDeviceSize,
}
struct VkSparseMemoryBind {
resourceOffset: VkDeviceSize,
size: VkDeviceSize,
memory: VkDeviceMemory,
memoryOffset: VkDeviceSize,
flags: VkSparseMemoryBindFlags,
}
struct VkSparseImageMemoryBind {
subresource: VkImageSubresource,
offset: VkOffset3D,
extent: VkExtent3D,
memory: VkDeviceMemory,
memoryOffset: VkDeviceSize,
flags: VkSparseMemoryBindFlags,
}
struct VkSparseBufferMemoryBindInfo {
buffer: VkBuffer,
bindCount: uint32_t,
pBinds: *const [VkSparseMemoryBind; dyn bindCount],
}
struct VkSparseImageOpaqueMemoryBindInfo {
image: VkImage,
bindCount: uint32_t,
pBinds: *const [VkSparseMemoryBind; dyn bindCount],
}
struct VkSparseImageMemoryBindInfo {
image: VkImage,
bindCount: uint32_t,
pBinds: *const [VkSparseImageMemoryBind; dyn bindCount],
}
struct VkBindSparseInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_BIND_SPARSE_INFO,
pNext: *const void,
waitSemaphoreCount: uint32_t,
pWaitSemaphores: *const [VkSemaphore; dyn waitSemaphoreCount],
bufferBindCount: uint32_t,
pBufferBinds: *const [VkSparseBufferMemoryBindInfo; dyn bufferBindCount],
imageOpaqueBindCount: uint32_t,
pImageOpaqueBinds: *const [VkSparseImageOpaqueMemoryBindInfo; dyn imageOpaqueBindCount],
imageBindCount: uint32_t,
pImageBinds: *const [VkSparseImageMemoryBindInfo; dyn imageBindCount],
signalSemaphoreCount: uint32_t,
pSignalSemaphores: *const [VkSemaphore; dyn signalSemaphoreCount],
}
struct VkImageCopy {
srcSubresource: VkImageSubresourceLayers,
srcOffset: VkOffset3D,
dstSubresource: VkImageSubresourceLayers,
dstOffset: VkOffset3D,
extent: VkExtent3D,
}
struct VkImageBlit {
srcSubresource: VkImageSubresourceLayers,
srcOffsets: [VkOffset3D; 2],
dstSubresource: VkImageSubresourceLayers,
dstOffsets: [VkOffset3D; 2],
}
struct VkBufferImageCopy {
bufferOffset: VkDeviceSize,
bufferRowLength: uint32_t,
bufferImageHeight: uint32_t,
imageSubresource: VkImageSubresourceLayers,
imageOffset: VkOffset3D,
imageExtent: VkExtent3D,
}
struct VkCopyMemoryIndirectCommandNV {
srcAddress: VkDeviceAddress,
dstAddress: VkDeviceAddress,
size: VkDeviceSize,
}
struct VkCopyMemoryToImageIndirectCommandNV {
srcAddress: VkDeviceAddress,
bufferRowLength: uint32_t,
bufferImageHeight: uint32_t,
imageSubresource: VkImageSubresourceLayers,
imageOffset: VkOffset3D,
imageExtent: VkExtent3D,
}
struct VkImageResolve {
srcSubresource: VkImageSubresourceLayers,
srcOffset: VkOffset3D,
dstSubresource: VkImageSubresourceLayers,
dstOffset: VkOffset3D,
extent: VkExtent3D,
}
struct VkShaderModuleCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO,
pNext: *const void,
flags: VkShaderModuleCreateFlags,
codeSize: size_t,
pCode: *const [uint32_t; dyn codeSize / 4],
}
struct VkDescriptorSetLayoutBinding {
binding: uint32_t,
descriptorType: VkDescriptorType,
descriptorCount: uint32_t,
stageFlags: VkShaderStageFlags,
pImmutableSamplers: *const [VkSampler; dyn descriptorCount],
}
struct VkDescriptorSetLayoutCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
pNext: *const void,
flags: VkDescriptorSetLayoutCreateFlags,
bindingCount: uint32_t,
pBindings: *const [VkDescriptorSetLayoutBinding; dyn bindingCount],
}
struct VkDescriptorPoolSize {
type: VkDescriptorType,
descriptorCount: uint32_t,
}
struct VkDescriptorPoolCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
pNext: *const void,
flags: VkDescriptorPoolCreateFlags,
maxSets: uint32_t,
poolSizeCount: uint32_t,
pPoolSizes: *const [VkDescriptorPoolSize; dyn poolSizeCount],
}
struct VkDescriptorSetAllocateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
pNext: *const void,
descriptorPool: VkDescriptorPool,
descriptorSetCount: uint32_t,
pSetLayouts: *const [VkDescriptorSetLayout; dyn descriptorSetCount],
}
struct VkSpecializationMapEntry {
constantID: uint32_t,
offset: uint32_t,
size: size_t,
}
struct VkSpecializationInfo {
mapEntryCount: uint32_t,
pMapEntries: *const [VkSpecializationMapEntry; dyn mapEntryCount],
dataSize: size_t,
pData: *const [void; dyn dataSize],
}
struct VkPipelineShaderStageCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
pNext: *const void,
flags: VkPipelineShaderStageCreateFlags,
stage: VkShaderStageFlagBits,
module: VkShaderModule,
pName: *const [char; dyn null-terminated],
pSpecializationInfo: *const VkSpecializationInfo,
}
struct VkComputePipelineCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO,
pNext: *const void,
flags: VkPipelineCreateFlags,
stage: VkPipelineShaderStageCreateInfo,
layout: VkPipelineLayout,
basePipelineHandle: VkPipeline,
basePipelineIndex: int32_t,
}
struct VkComputePipelineIndirectBufferInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV,
pNext: *const void,
deviceAddress: VkDeviceAddress,
size: VkDeviceSize,
pipelineDeviceAddressCaptureReplay: VkDeviceAddress,
}
struct VkPipelineCreateFlags2CreateInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR,
pNext: *const void,
flags: VkPipelineCreateFlags2KHR,
}
struct VkVertexInputBindingDescription {
binding: uint32_t,
stride: uint32_t,
inputRate: VkVertexInputRate,
}
struct VkVertexInputAttributeDescription {
location: uint32_t,
binding: uint32_t,
format: VkFormat,
offset: uint32_t,
}
struct VkPipelineVertexInputStateCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
pNext: *const void,
flags: VkPipelineVertexInputStateCreateFlags,
vertexBindingDescriptionCount: uint32_t,
pVertexBindingDescriptions: *const [VkVertexInputBindingDescription; dyn vertexBindingDescriptionCount],
vertexAttributeDescriptionCount: uint32_t,
pVertexAttributeDescriptions: *const [VkVertexInputAttributeDescription; dyn vertexAttributeDescriptionCount],
}
struct VkPipelineInputAssemblyStateCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
pNext: *const void,
flags: VkPipelineInputAssemblyStateCreateFlags,
topology: VkPrimitiveTopology,
primitiveRestartEnable: VkBool32,
}
struct VkPipelineTessellationStateCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO,
pNext: *const void,
flags: VkPipelineTessellationStateCreateFlags,
patchControlPoints: uint32_t,
}
struct VkPipelineViewportStateCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,
pNext: *const void,
flags: VkPipelineViewportStateCreateFlags,
viewportCount: uint32_t,
pViewports: *const [VkViewport; dyn viewportCount],
scissorCount: uint32_t,
pScissors: *const [VkRect2D; dyn scissorCount],
}
struct VkPipelineRasterizationStateCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
pNext: *const void,
flags: VkPipelineRasterizationStateCreateFlags,
depthClampEnable: VkBool32,
rasterizerDiscardEnable: VkBool32,
polygonMode: VkPolygonMode,
cullMode: VkCullModeFlags,
frontFace: VkFrontFace,
depthBiasEnable: VkBool32,
depthBiasConstantFactor: float,
depthBiasClamp: float,
depthBiasSlopeFactor: float,
lineWidth: float,
}
struct VkPipelineMultisampleStateCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
pNext: *const void,
flags: VkPipelineMultisampleStateCreateFlags,
rasterizationSamples: VkSampleCountFlagBits,
sampleShadingEnable: VkBool32,
minSampleShading: float,
pSampleMask: *const [VkSampleMask; dyn (rasterizationSamples + 31) / 32],
alphaToCoverageEnable: VkBool32,
alphaToOneEnable: VkBool32,
}
struct VkPipelineColorBlendAttachmentState {
blendEnable: VkBool32,
srcColorBlendFactor: VkBlendFactor,
dstColorBlendFactor: VkBlendFactor,
colorBlendOp: VkBlendOp,
srcAlphaBlendFactor: VkBlendFactor,
dstAlphaBlendFactor: VkBlendFactor,
alphaBlendOp: VkBlendOp,
colorWriteMask: VkColorComponentFlags,
}
struct VkPipelineColorBlendStateCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,
pNext: *const void,
flags: VkPipelineColorBlendStateCreateFlags,
logicOpEnable: VkBool32,
logicOp: VkLogicOp,
attachmentCount: uint32_t,
pAttachments: *const [VkPipelineColorBlendAttachmentState; dyn attachmentCount],
blendConstants: [float; 4],
}
struct VkPipelineDynamicStateCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO,
pNext: *const void,
flags: VkPipelineDynamicStateCreateFlags,
dynamicStateCount: uint32_t,
pDynamicStates: *const [VkDynamicState; dyn dynamicStateCount],
}
struct VkStencilOpState {
failOp: VkStencilOp,
passOp: VkStencilOp,
depthFailOp: VkStencilOp,
compareOp: VkCompareOp,
compareMask: uint32_t,
writeMask: uint32_t,
reference: uint32_t,
}
struct VkPipelineDepthStencilStateCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,
pNext: *const void,
flags: VkPipelineDepthStencilStateCreateFlags,
depthTestEnable: VkBool32,
depthWriteEnable: VkBool32,
depthCompareOp: VkCompareOp,
depthBoundsTestEnable: VkBool32,
stencilTestEnable: VkBool32,
front: VkStencilOpState,
back: VkStencilOpState,
minDepthBounds: float,
maxDepthBounds: float,
}
struct VkGraphicsPipelineCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
pNext: *const void,
flags: VkPipelineCreateFlags,
stageCount: uint32_t,
pStages: *const [VkPipelineShaderStageCreateInfo; dyn stageCount],
pVertexInputState: *const VkPipelineVertexInputStateCreateInfo,
pInputAssemblyState: *const VkPipelineInputAssemblyStateCreateInfo,
pTessellationState: *const VkPipelineTessellationStateCreateInfo,
pViewportState: *const VkPipelineViewportStateCreateInfo,
pRasterizationState: *const VkPipelineRasterizationStateCreateInfo,
pMultisampleState: *const VkPipelineMultisampleStateCreateInfo,
pDepthStencilState: *const VkPipelineDepthStencilStateCreateInfo,
pColorBlendState: *const VkPipelineColorBlendStateCreateInfo,
pDynamicState: *const VkPipelineDynamicStateCreateInfo,
layout: VkPipelineLayout,
renderPass: VkRenderPass,
subpass: uint32_t,
basePipelineHandle: VkPipeline,
basePipelineIndex: int32_t,
}
struct VkPipelineCacheCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO,
pNext: *const void,
flags: VkPipelineCacheCreateFlags,
initialDataSize: size_t,
pInitialData: *const [void; dyn initialDataSize],
}
struct VkPipelineCacheHeaderVersionOne {
headerSize: uint32_t,
headerVersion: VkPipelineCacheHeaderVersion,
vendorID: uint32_t,
deviceID: uint32_t,
pipelineCacheUUID: [uint8_t; VK_UUID_SIZE],
}
struct VkPipelineCacheStageValidationIndexEntry {
codeSize: uint64_t,
codeOffset: uint64_t,
}
struct VkPipelineCacheSafetyCriticalIndexEntry {
pipelineIdentifier: [uint8_t; VK_UUID_SIZE],
pipelineMemorySize: uint64_t,
jsonSize: uint64_t,
jsonOffset: uint64_t,
stageIndexCount: uint32_t,
stageIndexStride: uint32_t,
stageIndexOffset: uint64_t,
}
struct VkPipelineCacheHeaderVersionSafetyCriticalOne {
headerVersionOne: VkPipelineCacheHeaderVersionOne,
validationVersion: VkPipelineCacheValidationVersion,
implementationData: uint32_t,
pipelineIndexCount: uint32_t,
pipelineIndexStride: uint32_t,
pipelineIndexOffset: uint64_t,
}
struct VkPushConstantRange {
stageFlags: VkShaderStageFlags,
offset: uint32_t,
size: uint32_t,
}
struct VkPipelineLayoutCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
pNext: *const void,
flags: VkPipelineLayoutCreateFlags,
setLayoutCount: uint32_t,
pSetLayouts: *const [VkDescriptorSetLayout; dyn setLayoutCount],
pushConstantRangeCount: uint32_t,
pPushConstantRanges: *const [VkPushConstantRange; dyn pushConstantRangeCount],
}
struct VkSamplerCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
pNext: *const void,
flags: VkSamplerCreateFlags,
magFilter: VkFilter,
minFilter: VkFilter,
mipmapMode: VkSamplerMipmapMode,
addressModeU: VkSamplerAddressMode,
addressModeV: VkSamplerAddressMode,
addressModeW: VkSamplerAddressMode,
mipLodBias: float,
anisotropyEnable: VkBool32,
maxAnisotropy: float,
compareEnable: VkBool32,
compareOp: VkCompareOp,
minLod: float,
maxLod: float,
borderColor: VkBorderColor,
unnormalizedCoordinates: VkBool32,
}
struct VkCommandPoolCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,
pNext: *const void,
flags: VkCommandPoolCreateFlags,
queueFamilyIndex: uint32_t,
}
struct VkCommandBufferAllocateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,
pNext: *const void,
commandPool: VkCommandPool,
level: VkCommandBufferLevel,
commandBufferCount: uint32_t,
}
struct VkCommandBufferInheritanceInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO,
pNext: *const void,
renderPass: VkRenderPass,
subpass: uint32_t,
framebuffer: VkFramebuffer,
occlusionQueryEnable: VkBool32,
queryFlags: VkQueryControlFlags,
pipelineStatistics: VkQueryPipelineStatisticFlags,
}
struct VkCommandBufferBeginInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
pNext: *const void,
flags: VkCommandBufferUsageFlags,
pInheritanceInfo: *const VkCommandBufferInheritanceInfo,
}
struct VkRenderPassBeginInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,
pNext: *const void,
renderPass: VkRenderPass,
framebuffer: VkFramebuffer,
renderArea: VkRect2D,
clearValueCount: uint32_t,
pClearValues: *const [VkClearValue; dyn clearValueCount],
}
struct VkClearDepthStencilValue {
depth: float,
stencil: uint32_t,
}
struct VkClearAttachment {
aspectMask: VkImageAspectFlags,
colorAttachment: uint32_t,
clearValue: VkClearValue,
}
struct VkAttachmentDescription {
flags: VkAttachmentDescriptionFlags,
format: VkFormat,
samples: VkSampleCountFlagBits,
loadOp: VkAttachmentLoadOp,
storeOp: VkAttachmentStoreOp,
stencilLoadOp: VkAttachmentLoadOp,
stencilStoreOp: VkAttachmentStoreOp,
initialLayout: VkImageLayout,
finalLayout: VkImageLayout,
}
struct VkAttachmentReference {
attachment: uint32_t,
layout: VkImageLayout,
}
struct VkSubpassDescription {
flags: VkSubpassDescriptionFlags,
pipelineBindPoint: VkPipelineBindPoint,
inputAttachmentCount: uint32_t,
pInputAttachments: *const [VkAttachmentReference; dyn inputAttachmentCount],
colorAttachmentCount: uint32_t,
pColorAttachments: *const [VkAttachmentReference; dyn colorAttachmentCount],
pResolveAttachments: *const [VkAttachmentReference; dyn colorAttachmentCount],
pDepthStencilAttachment: *const VkAttachmentReference,
preserveAttachmentCount: uint32_t,
pPreserveAttachments: *const [uint32_t; dyn preserveAttachmentCount],
}
struct VkSubpassDependency {
srcSubpass: uint32_t,
dstSubpass: uint32_t,
srcStageMask: VkPipelineStageFlags,
dstStageMask: VkPipelineStageFlags,
srcAccessMask: VkAccessFlags,
dstAccessMask: VkAccessFlags,
dependencyFlags: VkDependencyFlags,
}
struct VkRenderPassCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
pNext: *const void,
flags: VkRenderPassCreateFlags,
attachmentCount: uint32_t,
pAttachments: *const [VkAttachmentDescription; dyn attachmentCount],
subpassCount: uint32_t,
pSubpasses: *const [VkSubpassDescription; dyn subpassCount],
dependencyCount: uint32_t,
pDependencies: *const [VkSubpassDependency; dyn dependencyCount],
}
struct VkEventCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_EVENT_CREATE_INFO,
pNext: *const void,
flags: VkEventCreateFlags,
}
struct VkFenceCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,
pNext: *const void,
flags: VkFenceCreateFlags,
}
struct VkPhysicalDeviceFeatures {
robustBufferAccess: VkBool32,
fullDrawIndexUint32: VkBool32,
imageCubeArray: VkBool32,
independentBlend: VkBool32,
geometryShader: VkBool32,
tessellationShader: VkBool32,
sampleRateShading: VkBool32,
dualSrcBlend: VkBool32,
logicOp: VkBool32,
multiDrawIndirect: VkBool32,
drawIndirectFirstInstance: VkBool32,
depthClamp: VkBool32,
depthBiasClamp: VkBool32,
fillModeNonSolid: VkBool32,
depthBounds: VkBool32,
wideLines: VkBool32,
largePoints: VkBool32,
alphaToOne: VkBool32,
multiViewport: VkBool32,
samplerAnisotropy: VkBool32,
textureCompressionETC2: VkBool32,
textureCompressionASTC_LDR: VkBool32,
textureCompressionBC: VkBool32,
occlusionQueryPrecise: VkBool32,
pipelineStatisticsQuery: VkBool32,
vertexPipelineStoresAndAtomics: VkBool32,
fragmentStoresAndAtomics: VkBool32,
shaderTessellationAndGeometryPointSize: VkBool32,
shaderImageGatherExtended: VkBool32,
shaderStorageImageExtendedFormats: VkBool32,
shaderStorageImageMultisample: VkBool32,
shaderStorageImageReadWithoutFormat: VkBool32,
shaderStorageImageWriteWithoutFormat: VkBool32,
shaderUniformBufferArrayDynamicIndexing: VkBool32,
shaderSampledImageArrayDynamicIndexing: VkBool32,
shaderStorageBufferArrayDynamicIndexing: VkBool32,
shaderStorageImageArrayDynamicIndexing: VkBool32,
shaderClipDistance: VkBool32,
shaderCullDistance: VkBool32,
shaderFloat64: VkBool32,
shaderInt64: VkBool32,
shaderInt16: VkBool32,
shaderResourceResidency: VkBool32,
shaderResourceMinLod: VkBool32,
sparseBinding: VkBool32,
sparseResidencyBuffer: VkBool32,
sparseResidencyImage2D: VkBool32,
sparseResidencyImage3D: VkBool32,
sparseResidency2Samples: VkBool32,
sparseResidency4Samples: VkBool32,
sparseResidency8Samples: VkBool32,
sparseResidency16Samples: VkBool32,
sparseResidencyAliased: VkBool32,
variableMultisampleRate: VkBool32,
inheritedQueries: VkBool32,
}
struct VkPhysicalDeviceSparseProperties {
residencyStandard2DBlockShape: VkBool32,
residencyStandard2DMultisampleBlockShape: VkBool32,
residencyStandard3DBlockShape: VkBool32,
residencyAlignedMipSize: VkBool32,
residencyNonResidentStrict: VkBool32,
}
struct VkPhysicalDeviceLimits {
maxImageDimension1D: uint32_t,
maxImageDimension2D: uint32_t,
maxImageDimension3D: uint32_t,
maxImageDimensionCube: uint32_t,
maxImageArrayLayers: uint32_t,
maxTexelBufferElements: uint32_t,
maxUniformBufferRange: uint32_t,
maxStorageBufferRange: uint32_t,
maxPushConstantsSize: uint32_t,
maxMemoryAllocationCount: uint32_t,
maxSamplerAllocationCount: uint32_t,
bufferImageGranularity: VkDeviceSize,
sparseAddressSpaceSize: VkDeviceSize,
maxBoundDescriptorSets: uint32_t,
maxPerStageDescriptorSamplers: uint32_t,
maxPerStageDescriptorUniformBuffers: uint32_t,
maxPerStageDescriptorStorageBuffers: uint32_t,
maxPerStageDescriptorSampledImages: uint32_t,
maxPerStageDescriptorStorageImages: uint32_t,
maxPerStageDescriptorInputAttachments: uint32_t,
maxPerStageResources: uint32_t,
maxDescriptorSetSamplers: uint32_t,
maxDescriptorSetUniformBuffers: uint32_t,
maxDescriptorSetUniformBuffersDynamic: uint32_t,
maxDescriptorSetStorageBuffers: uint32_t,
maxDescriptorSetStorageBuffersDynamic: uint32_t,
maxDescriptorSetSampledImages: uint32_t,
maxDescriptorSetStorageImages: uint32_t,
maxDescriptorSetInputAttachments: uint32_t,
maxVertexInputAttributes: uint32_t,
maxVertexInputBindings: uint32_t,
maxVertexInputAttributeOffset: uint32_t,
maxVertexInputBindingStride: uint32_t,
maxVertexOutputComponents: uint32_t,
maxTessellationGenerationLevel: uint32_t,
maxTessellationPatchSize: uint32_t,
maxTessellationControlPerVertexInputComponents: uint32_t,
maxTessellationControlPerVertexOutputComponents: uint32_t,
maxTessellationControlPerPatchOutputComponents: uint32_t,
maxTessellationControlTotalOutputComponents: uint32_t,
maxTessellationEvaluationInputComponents: uint32_t,
maxTessellationEvaluationOutputComponents: uint32_t,
maxGeometryShaderInvocations: uint32_t,
maxGeometryInputComponents: uint32_t,
maxGeometryOutputComponents: uint32_t,
maxGeometryOutputVertices: uint32_t,
maxGeometryTotalOutputComponents: uint32_t,
maxFragmentInputComponents: uint32_t,
maxFragmentOutputAttachments: uint32_t,
maxFragmentDualSrcAttachments: uint32_t,
maxFragmentCombinedOutputResources: uint32_t,
maxComputeSharedMemorySize: uint32_t,
maxComputeWorkGroupCount: [uint32_t; 3],
maxComputeWorkGroupInvocations: uint32_t,
maxComputeWorkGroupSize: [uint32_t; 3],
subPixelPrecisionBits: uint32_t,
subTexelPrecisionBits: uint32_t,
mipmapPrecisionBits: uint32_t,
maxDrawIndexedIndexValue: uint32_t,
maxDrawIndirectCount: uint32_t,
maxSamplerLodBias: float,
maxSamplerAnisotropy: float,
maxViewports: uint32_t,
maxViewportDimensions: [uint32_t; 2],
viewportBoundsRange: [float; 2],
viewportSubPixelBits: uint32_t,
minMemoryMapAlignment: size_t,
minTexelBufferOffsetAlignment: VkDeviceSize,
minUniformBufferOffsetAlignment: VkDeviceSize,
minStorageBufferOffsetAlignment: VkDeviceSize,
minTexelOffset: int32_t,
maxTexelOffset: uint32_t,
minTexelGatherOffset: int32_t,
maxTexelGatherOffset: uint32_t,
minInterpolationOffset: float,
maxInterpolationOffset: float,
subPixelInterpolationOffsetBits: uint32_t,
maxFramebufferWidth: uint32_t,
maxFramebufferHeight: uint32_t,
maxFramebufferLayers: uint32_t,
framebufferColorSampleCounts: VkSampleCountFlags,
framebufferDepthSampleCounts: VkSampleCountFlags,
framebufferStencilSampleCounts: VkSampleCountFlags,
framebufferNoAttachmentsSampleCounts: VkSampleCountFlags,
maxColorAttachments: uint32_t,
sampledImageColorSampleCounts: VkSampleCountFlags,
sampledImageIntegerSampleCounts: VkSampleCountFlags,
sampledImageDepthSampleCounts: VkSampleCountFlags,
sampledImageStencilSampleCounts: VkSampleCountFlags,
storageImageSampleCounts: VkSampleCountFlags,
maxSampleMaskWords: uint32_t,
timestampComputeAndGraphics: VkBool32,
timestampPeriod: float,
maxClipDistances: uint32_t,
maxCullDistances: uint32_t,
maxCombinedClipAndCullDistances: uint32_t,
discreteQueuePriorities: uint32_t,
pointSizeRange: [float; 2],
lineWidthRange: [float; 2],
pointSizeGranularity: float,
lineWidthGranularity: float,
strictLines: VkBool32,
standardSampleLocations: VkBool32,
optimalBufferCopyOffsetAlignment: VkDeviceSize,
optimalBufferCopyRowPitchAlignment: VkDeviceSize,
nonCoherentAtomSize: VkDeviceSize,
}
struct VkSemaphoreCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
pNext: *const void,
flags: VkSemaphoreCreateFlags,
}
struct VkQueryPoolCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO,
pNext: *const void,
flags: VkQueryPoolCreateFlags,
queryType: VkQueryType,
queryCount: uint32_t,
pipelineStatistics: VkQueryPipelineStatisticFlags,
}
struct VkFramebufferCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
pNext: *const void,
flags: VkFramebufferCreateFlags,
renderPass: VkRenderPass,
attachmentCount: uint32_t,
pAttachments: *const [VkImageView; dyn attachmentCount],
width: uint32_t,
height: uint32_t,
layers: uint32_t,
}
struct VkDrawIndirectCommand {
vertexCount: uint32_t,
instanceCount: uint32_t,
firstVertex: uint32_t,
firstInstance: uint32_t,
}
struct VkDrawIndexedIndirectCommand {
indexCount: uint32_t,
instanceCount: uint32_t,
firstIndex: uint32_t,
vertexOffset: int32_t,
firstInstance: uint32_t,
}
struct VkDispatchIndirectCommand {
x: uint32_t,
y: uint32_t,
z: uint32_t,
}
struct VkMultiDrawInfoEXT {
firstVertex: uint32_t,
vertexCount: uint32_t,
}
struct VkMultiDrawIndexedInfoEXT {
firstIndex: uint32_t,
indexCount: uint32_t,
vertexOffset: int32_t,
}
struct VkSubmitInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_SUBMIT_INFO,
pNext: *const void,
waitSemaphoreCount: uint32_t,
pWaitSemaphores: *const [VkSemaphore; dyn waitSemaphoreCount],
pWaitDstStageMask: *const [VkPipelineStageFlags; dyn waitSemaphoreCount],
commandBufferCount: uint32_t,
pCommandBuffers: *const [VkCommandBuffer; dyn commandBufferCount],
signalSemaphoreCount: uint32_t,
pSignalSemaphores: *const [VkSemaphore; dyn signalSemaphoreCount],
}
struct VkDisplayPropertiesKHR {
display: VkDisplayKHR,
displayName: *const [char; dyn null-terminated],
physicalDimensions: VkExtent2D,
physicalResolution: VkExtent2D,
supportedTransforms: VkSurfaceTransformFlagsKHR,
planeReorderPossible: VkBool32,
persistentContent: VkBool32,
}
struct VkDisplayPlanePropertiesKHR {
currentDisplay: VkDisplayKHR,
currentStackIndex: uint32_t,
}
struct VkDisplayModeParametersKHR {
visibleRegion: VkExtent2D,
refreshRate: uint32_t,
}
struct VkDisplayModePropertiesKHR {
displayMode: VkDisplayModeKHR,
parameters: VkDisplayModeParametersKHR,
}
struct VkDisplayModeCreateInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR,
pNext: *const void,
flags: VkDisplayModeCreateFlagsKHR,
parameters: VkDisplayModeParametersKHR,
}
struct VkDisplayPlaneCapabilitiesKHR {
supportedAlpha: VkDisplayPlaneAlphaFlagsKHR,
minSrcPosition: VkOffset2D,
maxSrcPosition: VkOffset2D,
minSrcExtent: VkExtent2D,
maxSrcExtent: VkExtent2D,
minDstPosition: VkOffset2D,
maxDstPosition: VkOffset2D,
minDstExtent: VkExtent2D,
maxDstExtent: VkExtent2D,
}
struct VkDisplaySurfaceCreateInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR,
pNext: *const void,
flags: VkDisplaySurfaceCreateFlagsKHR,
displayMode: VkDisplayModeKHR,
planeIndex: uint32_t,
planeStackIndex: uint32_t,
transform: VkSurfaceTransformFlagBitsKHR,
globalAlpha: float,
alphaMode: VkDisplayPlaneAlphaFlagBitsKHR,
imageExtent: VkExtent2D,
}
struct VkDisplayPresentInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR,
pNext: *const void,
srcRect: VkRect2D,
dstRect: VkRect2D,
persistent: VkBool32,
}
struct VkSurfaceCapabilitiesKHR {
minImageCount: uint32_t,
maxImageCount: uint32_t,
currentExtent: VkExtent2D,
minImageExtent: VkExtent2D,
maxImageExtent: VkExtent2D,
maxImageArrayLayers: uint32_t,
supportedTransforms: VkSurfaceTransformFlagsKHR,
currentTransform: VkSurfaceTransformFlagBitsKHR,
supportedCompositeAlpha: VkCompositeAlphaFlagsKHR,
supportedUsageFlags: VkImageUsageFlags,
}
struct VkAndroidSurfaceCreateInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR,
pNext: *const void,
flags: VkAndroidSurfaceCreateFlagsKHR,
window: *mut /*struct*/ANativeWindow,
}
struct VkViSurfaceCreateInfoNN {
sType: VkStructureType = VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN,
pNext: *const void,
flags: VkViSurfaceCreateFlagsNN,
window: *mut void,
}
struct VkWaylandSurfaceCreateInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR,
pNext: *const void,
flags: VkWaylandSurfaceCreateFlagsKHR,
display: *mut /*struct*/wl_display,
surface: *mut /*struct*/wl_surface,
}
struct VkWin32SurfaceCreateInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR,
pNext: *const void,
flags: VkWin32SurfaceCreateFlagsKHR,
hinstance: HINSTANCE,
hwnd: HWND,
}
struct VkXlibSurfaceCreateInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR,
pNext: *const void,
flags: VkXlibSurfaceCreateFlagsKHR,
dpy: *mut Display,
window: Window,
}
struct VkXcbSurfaceCreateInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR,
pNext: *const void,
flags: VkXcbSurfaceCreateFlagsKHR,
connection: *mut xcb_connection_t,
window: xcb_window_t,
}
struct VkDirectFBSurfaceCreateInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT,
pNext: *const void,
flags: VkDirectFBSurfaceCreateFlagsEXT,
dfb: *mut IDirectFB,
surface: *mut IDirectFBSurface,
}
struct VkImagePipeSurfaceCreateInfoFUCHSIA {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA,
pNext: *const void,
flags: VkImagePipeSurfaceCreateFlagsFUCHSIA,
imagePipeHandle: zx_handle_t,
}
struct VkStreamDescriptorSurfaceCreateInfoGGP {
sType: VkStructureType = VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP,
pNext: *const void,
flags: VkStreamDescriptorSurfaceCreateFlagsGGP,
streamDescriptor: GgpStreamDescriptor,
}
struct VkScreenSurfaceCreateInfoQNX {
sType: VkStructureType = VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX,
pNext: *const void,
flags: VkScreenSurfaceCreateFlagsQNX,
context: *mut /*struct*/_screen_context,
window: *mut /*struct*/_screen_window,
}
struct VkSurfaceFormatKHR {
format: VkFormat,
colorSpace: VkColorSpaceKHR,
}
struct VkSwapchainCreateInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR,
pNext: *const void,
flags: VkSwapchainCreateFlagsKHR,
surface: VkSurfaceKHR,
minImageCount: uint32_t,
imageFormat: VkFormat,
imageColorSpace: VkColorSpaceKHR,
imageExtent: VkExtent2D,
imageArrayLayers: uint32_t,
imageUsage: VkImageUsageFlags,
imageSharingMode: VkSharingMode,
queueFamilyIndexCount: uint32_t,
pQueueFamilyIndices: *const [uint32_t; dyn queueFamilyIndexCount],
preTransform: VkSurfaceTransformFlagBitsKHR,
compositeAlpha: VkCompositeAlphaFlagBitsKHR,
presentMode: VkPresentModeKHR,
clipped: VkBool32,
oldSwapchain: VkSwapchainKHR,
}
struct VkPresentInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
pNext: *const void,
waitSemaphoreCount: uint32_t,
pWaitSemaphores: *const [VkSemaphore; dyn waitSemaphoreCount],
swapchainCount: uint32_t,
pSwapchains: *const [VkSwapchainKHR; dyn swapchainCount],
pImageIndices: *const [uint32_t; dyn swapchainCount],
pResults: *mut [VkResult; dyn swapchainCount],
}
struct VkDebugReportCallbackCreateInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT,
pNext: *const void,
flags: VkDebugReportFlagsEXT,
pfnCallback: PFN_vkDebugReportCallbackEXT,
pUserData: *mut void,
}
struct VkValidationFlagsEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT,
pNext: *const void,
disabledValidationCheckCount: uint32_t,
pDisabledValidationChecks: *const [VkValidationCheckEXT; dyn disabledValidationCheckCount],
}
struct VkValidationFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT,
pNext: *const void,
enabledValidationFeatureCount: uint32_t,
pEnabledValidationFeatures: *const [VkValidationFeatureEnableEXT; dyn enabledValidationFeatureCount],
disabledValidationFeatureCount: uint32_t,
pDisabledValidationFeatures: *const [VkValidationFeatureDisableEXT; dyn disabledValidationFeatureCount],
}
struct VkApplicationParametersEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_APPLICATION_PARAMETERS_EXT,
pNext: *const void,
vendorID: uint32_t,
deviceID: uint32_t,
key: uint32_t,
value: uint64_t,
}
struct VkPipelineRasterizationStateRasterizationOrderAMD {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD,
pNext: *const void,
rasterizationOrder: VkRasterizationOrderAMD,
}
struct VkDebugMarkerObjectNameInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT,
pNext: *const void,
objectType: VkDebugReportObjectTypeEXT,
object: uint64_t,
pObjectName: *const [char; dyn null-terminated],
}
struct VkDebugMarkerObjectTagInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT,
pNext: *const void,
objectType: VkDebugReportObjectTypeEXT,
object: uint64_t,
tagName: uint64_t,
tagSize: size_t,
pTag: *const [void; dyn tagSize],
}
struct VkDebugMarkerMarkerInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT,
pNext: *const void,
pMarkerName: *const [char; dyn null-terminated],
color: [float; 4],
}
struct VkDedicatedAllocationImageCreateInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV,
pNext: *const void,
dedicatedAllocation: VkBool32,
}
struct VkDedicatedAllocationBufferCreateInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV,
pNext: *const void,
dedicatedAllocation: VkBool32,
}
struct VkDedicatedAllocationMemoryAllocateInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV,
pNext: *const void,
image: VkImage,
buffer: VkBuffer,
}
struct VkExternalImageFormatPropertiesNV {
imageFormatProperties: VkImageFormatProperties,
externalMemoryFeatures: VkExternalMemoryFeatureFlagsNV,
exportFromImportedHandleTypes: VkExternalMemoryHandleTypeFlagsNV,
compatibleHandleTypes: VkExternalMemoryHandleTypeFlagsNV,
}
struct VkExternalMemoryImageCreateInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV,
pNext: *const void,
handleTypes: VkExternalMemoryHandleTypeFlagsNV,
}
struct VkExportMemoryAllocateInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV,
pNext: *const void,
handleTypes: VkExternalMemoryHandleTypeFlagsNV,
}
struct VkImportMemoryWin32HandleInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV,
pNext: *const void,
handleType: VkExternalMemoryHandleTypeFlagsNV,
handle: HANDLE,
}
struct VkExportMemoryWin32HandleInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV,
pNext: *const void,
pAttributes: *const SECURITY_ATTRIBUTES,
dwAccess: DWORD,
}
struct VkExportMemorySciBufInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_SCI_BUF_INFO_NV,
pNext: *const void,
pAttributes: NvSciBufAttrList,
}
struct VkImportMemorySciBufInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_SCI_BUF_INFO_NV,
pNext: *const void,
handleType: VkExternalMemoryHandleTypeFlagBits,
handle: NvSciBufObj,
}
struct VkMemoryGetSciBufInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_GET_SCI_BUF_INFO_NV,
pNext: *const void,
memory: VkDeviceMemory,
handleType: VkExternalMemoryHandleTypeFlagBits,
}
struct VkMemorySciBufPropertiesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_SCI_BUF_PROPERTIES_NV,
pNext: *const void,
memoryTypeBits: uint32_t,
}
struct VkPhysicalDeviceExternalMemorySciBufFeaturesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCI_BUF_FEATURES_NV,
pNext: *mut void,
sciBufImport: VkBool32,
sciBufExport: VkBool32,
}
struct VkWin32KeyedMutexAcquireReleaseInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV,
pNext: *const void,
acquireCount: uint32_t,
pAcquireSyncs: *const [VkDeviceMemory; dyn acquireCount],
pAcquireKeys: *const [uint64_t; dyn acquireCount],
pAcquireTimeoutMilliseconds: *const [uint32_t; dyn acquireCount],
releaseCount: uint32_t,
pReleaseSyncs: *const [VkDeviceMemory; dyn releaseCount],
pReleaseKeys: *const [uint64_t; dyn releaseCount],
}
struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV,
pNext: *mut void,
deviceGeneratedCommands: VkBool32,
}
struct VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV,
pNext: *mut void,
deviceGeneratedCompute: VkBool32,
deviceGeneratedComputePipelines: VkBool32,
deviceGeneratedComputeCaptureReplay: VkBool32,
}
struct VkDevicePrivateDataCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO,
pNext: *const void,
privateDataSlotRequestCount: uint32_t,
}
struct VkPrivateDataSlotCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO,
pNext: *const void,
flags: VkPrivateDataSlotCreateFlags,
}
struct VkPhysicalDevicePrivateDataFeatures {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES,
pNext: *mut void,
privateData: VkBool32,
}
struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV,
pNext: *mut void,
maxGraphicsShaderGroupCount: uint32_t,
maxIndirectSequenceCount: uint32_t,
maxIndirectCommandsTokenCount: uint32_t,
maxIndirectCommandsStreamCount: uint32_t,
maxIndirectCommandsTokenOffset: uint32_t,
maxIndirectCommandsStreamStride: uint32_t,
minSequencesCountBufferOffsetAlignment: uint32_t,
minSequencesIndexBufferOffsetAlignment: uint32_t,
minIndirectCommandsBufferOffsetAlignment: uint32_t,
}
struct VkPhysicalDeviceMultiDrawPropertiesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT,
pNext: *mut void,
maxMultiDrawCount: uint32_t,
}
struct VkGraphicsShaderGroupCreateInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV,
pNext: *const void,
stageCount: uint32_t,
pStages: *const [VkPipelineShaderStageCreateInfo; dyn stageCount],
pVertexInputState: *const VkPipelineVertexInputStateCreateInfo,
pTessellationState: *const VkPipelineTessellationStateCreateInfo,
}
struct VkGraphicsPipelineShaderGroupsCreateInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV,
pNext: *const void,
groupCount: uint32_t,
pGroups: *const [VkGraphicsShaderGroupCreateInfoNV; dyn groupCount],
pipelineCount: uint32_t,
pPipelines: *const [VkPipeline; dyn pipelineCount],
}
struct VkBindShaderGroupIndirectCommandNV {
groupIndex: uint32_t,
}
struct VkBindIndexBufferIndirectCommandNV {
bufferAddress: VkDeviceAddress,
size: uint32_t,
indexType: VkIndexType,
}
struct VkBindVertexBufferIndirectCommandNV {
bufferAddress: VkDeviceAddress,
size: uint32_t,
stride: uint32_t,
}
struct VkSetStateFlagsIndirectCommandNV {
data: uint32_t,
}
struct VkIndirectCommandsStreamNV {
buffer: VkBuffer,
offset: VkDeviceSize,
}
struct VkIndirectCommandsLayoutTokenNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV,
pNext: *const void,
tokenType: VkIndirectCommandsTokenTypeNV,
stream: uint32_t,
offset: uint32_t,
vertexBindingUnit: uint32_t,
vertexDynamicStride: VkBool32,
pushconstantPipelineLayout: VkPipelineLayout,
pushconstantShaderStageFlags: VkShaderStageFlags,
pushconstantOffset: uint32_t,
pushconstantSize: uint32_t,
indirectStateFlags: VkIndirectStateFlagsNV,
indexTypeCount: uint32_t,
pIndexTypes: *const [VkIndexType; dyn indexTypeCount],
pIndexTypeValues: *const [uint32_t; dyn indexTypeCount],
}
struct VkIndirectCommandsLayoutCreateInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV,
pNext: *const void,
flags: VkIndirectCommandsLayoutUsageFlagsNV,
pipelineBindPoint: VkPipelineBindPoint,
tokenCount: uint32_t,
pTokens: *const [VkIndirectCommandsLayoutTokenNV; dyn tokenCount],
streamCount: uint32_t,
pStreamStrides: *const [uint32_t; dyn streamCount],
}
struct VkGeneratedCommandsInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV,
pNext: *const void,
pipelineBindPoint: VkPipelineBindPoint,
pipeline: VkPipeline,
indirectCommandsLayout: VkIndirectCommandsLayoutNV,
streamCount: uint32_t,
pStreams: *const [VkIndirectCommandsStreamNV; dyn streamCount],
sequencesCount: uint32_t,
preprocessBuffer: VkBuffer,
preprocessOffset: VkDeviceSize,
preprocessSize: VkDeviceSize,
sequencesCountBuffer: VkBuffer,
sequencesCountOffset: VkDeviceSize,
sequencesIndexBuffer: VkBuffer,
sequencesIndexOffset: VkDeviceSize,
}
struct VkGeneratedCommandsMemoryRequirementsInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV,
pNext: *const void,
pipelineBindPoint: VkPipelineBindPoint,
pipeline: VkPipeline,
indirectCommandsLayout: VkIndirectCommandsLayoutNV,
maxSequencesCount: uint32_t,
}
struct VkPipelineIndirectDeviceAddressInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV,
pNext: *const void,
pipelineBindPoint: VkPipelineBindPoint,
pipeline: VkPipeline,
}
struct VkBindPipelineIndirectCommandNV {
pipelineAddress: VkDeviceAddress,
}
struct VkPhysicalDeviceFeatures2 {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2,
pNext: *mut void,
features: VkPhysicalDeviceFeatures,
}
struct VkPhysicalDeviceProperties2 {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2,
pNext: *mut void,
properties: VkPhysicalDeviceProperties,
}
struct VkFormatProperties2 {
sType: VkStructureType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2,
pNext: *mut void,
formatProperties: VkFormatProperties,
}
struct VkImageFormatProperties2 {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2,
pNext: *mut void,
imageFormatProperties: VkImageFormatProperties,
}
struct VkPhysicalDeviceImageFormatInfo2 {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
pNext: *const void,
format: VkFormat,
type: VkImageType,
tiling: VkImageTiling,
usage: VkImageUsageFlags,
flags: VkImageCreateFlags,
}
struct VkQueueFamilyProperties2 {
sType: VkStructureType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2,
pNext: *mut void,
queueFamilyProperties: VkQueueFamilyProperties,
}
struct VkPhysicalDeviceMemoryProperties2 {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2,
pNext: *mut void,
memoryProperties: VkPhysicalDeviceMemoryProperties,
}
struct VkSparseImageFormatProperties2 {
sType: VkStructureType = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2,
pNext: *mut void,
properties: VkSparseImageFormatProperties,
}
struct VkPhysicalDeviceSparseImageFormatInfo2 {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2,
pNext: *const void,
format: VkFormat,
type: VkImageType,
samples: VkSampleCountFlagBits,
usage: VkImageUsageFlags,
tiling: VkImageTiling,
}
struct VkPhysicalDevicePushDescriptorPropertiesKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR,
pNext: *mut void,
maxPushDescriptors: uint32_t,
}
struct VkConformanceVersion {
major: uint8_t,
minor: uint8_t,
subminor: uint8_t,
patch: uint8_t,
}
struct VkPhysicalDeviceDriverProperties {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES,
pNext: *mut void,
driverID: VkDriverId,
driverName: [char; VK_MAX_DRIVER_NAME_SIZE],
driverInfo: [char; VK_MAX_DRIVER_INFO_SIZE],
conformanceVersion: VkConformanceVersion,
}
struct VkPresentRegionsKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR,
pNext: *const void,
swapchainCount: uint32_t,
pRegions: *const [VkPresentRegionKHR; dyn swapchainCount],
}
struct VkPresentRegionKHR {
rectangleCount: uint32_t,
pRectangles: *const [VkRectLayerKHR; dyn rectangleCount],
}
struct VkRectLayerKHR {
offset: VkOffset2D,
extent: VkExtent2D,
layer: uint32_t,
}
struct VkPhysicalDeviceVariablePointersFeatures {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,
pNext: *mut void,
variablePointersStorageBuffer: VkBool32,
variablePointers: VkBool32,
}
struct VkExternalMemoryProperties {
externalMemoryFeatures: VkExternalMemoryFeatureFlags,
exportFromImportedHandleTypes: VkExternalMemoryHandleTypeFlags,
compatibleHandleTypes: VkExternalMemoryHandleTypeFlags,
}
struct VkPhysicalDeviceExternalImageFormatInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO,
pNext: *const void,
handleType: VkExternalMemoryHandleTypeFlagBits,
}
struct VkExternalImageFormatProperties {
sType: VkStructureType = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES,
pNext: *mut void,
externalMemoryProperties: VkExternalMemoryProperties,
}
struct VkPhysicalDeviceExternalBufferInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO,
pNext: *const void,
flags: VkBufferCreateFlags,
usage: VkBufferUsageFlags,
handleType: VkExternalMemoryHandleTypeFlagBits,
}
struct VkExternalBufferProperties {
sType: VkStructureType = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES,
pNext: *mut void,
externalMemoryProperties: VkExternalMemoryProperties,
}
struct VkPhysicalDeviceIDProperties {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES,
pNext: *mut void,
deviceUUID: [uint8_t; VK_UUID_SIZE],
driverUUID: [uint8_t; VK_UUID_SIZE],
deviceLUID: [uint8_t; VK_LUID_SIZE],
deviceNodeMask: uint32_t,
deviceLUIDValid: VkBool32,
}
struct VkExternalMemoryImageCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO,
pNext: *const void,
handleTypes: VkExternalMemoryHandleTypeFlags,
}
struct VkExternalMemoryBufferCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO,
pNext: *const void,
handleTypes: VkExternalMemoryHandleTypeFlags,
}
struct VkExportMemoryAllocateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO,
pNext: *const void,
handleTypes: VkExternalMemoryHandleTypeFlags,
}
struct VkImportMemoryWin32HandleInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR,
pNext: *const void,
handleType: VkExternalMemoryHandleTypeFlagBits,
handle: HANDLE,
name: LPCWSTR,
}
struct VkExportMemoryWin32HandleInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR,
pNext: *const void,
pAttributes: *const SECURITY_ATTRIBUTES,
dwAccess: DWORD,
name: LPCWSTR,
}
struct VkImportMemoryZirconHandleInfoFUCHSIA {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA,
pNext: *const void,
handleType: VkExternalMemoryHandleTypeFlagBits,
handle: zx_handle_t,
}
struct VkMemoryZirconHandlePropertiesFUCHSIA {
sType: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA,
pNext: *mut void,
memoryTypeBits: uint32_t,
}
struct VkMemoryGetZirconHandleInfoFUCHSIA {
sType: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA,
pNext: *const void,
memory: VkDeviceMemory,
handleType: VkExternalMemoryHandleTypeFlagBits,
}
struct VkMemoryWin32HandlePropertiesKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR,
pNext: *mut void,
memoryTypeBits: uint32_t,
}
struct VkMemoryGetWin32HandleInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR,
pNext: *const void,
memory: VkDeviceMemory,
handleType: VkExternalMemoryHandleTypeFlagBits,
}
struct VkImportMemoryFdInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR,
pNext: *const void,
handleType: VkExternalMemoryHandleTypeFlagBits,
fd: int,
}
struct VkMemoryFdPropertiesKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR,
pNext: *mut void,
memoryTypeBits: uint32_t,
}
struct VkMemoryGetFdInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR,
pNext: *const void,
memory: VkDeviceMemory,
handleType: VkExternalMemoryHandleTypeFlagBits,
}
struct VkWin32KeyedMutexAcquireReleaseInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR,
pNext: *const void,
acquireCount: uint32_t,
pAcquireSyncs: *const [VkDeviceMemory; dyn acquireCount],
pAcquireKeys: *const [uint64_t; dyn acquireCount],
pAcquireTimeouts: *const [uint32_t; dyn acquireCount],
releaseCount: uint32_t,
pReleaseSyncs: *const [VkDeviceMemory; dyn releaseCount],
pReleaseKeys: *const [uint64_t; dyn releaseCount],
}
struct VkPhysicalDeviceExternalSemaphoreInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO,
pNext: *const void,
handleType: VkExternalSemaphoreHandleTypeFlagBits,
}
struct VkExternalSemaphoreProperties {
sType: VkStructureType = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES,
pNext: *mut void,
exportFromImportedHandleTypes: VkExternalSemaphoreHandleTypeFlags,
compatibleHandleTypes: VkExternalSemaphoreHandleTypeFlags,
externalSemaphoreFeatures: VkExternalSemaphoreFeatureFlags,
}
struct VkExportSemaphoreCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO,
pNext: *const void,
handleTypes: VkExternalSemaphoreHandleTypeFlags,
}
struct VkImportSemaphoreWin32HandleInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR,
pNext: *const void,
semaphore: VkSemaphore,
flags: VkSemaphoreImportFlags,
handleType: VkExternalSemaphoreHandleTypeFlagBits,
handle: HANDLE,
name: LPCWSTR,
}
struct VkExportSemaphoreWin32HandleInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR,
pNext: *const void,
pAttributes: *const SECURITY_ATTRIBUTES,
dwAccess: DWORD,
name: LPCWSTR,
}
struct VkD3D12FenceSubmitInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR,
pNext: *const void,
waitSemaphoreValuesCount: uint32_t,
pWaitSemaphoreValues: *const [uint64_t; dyn waitSemaphoreValuesCount],
signalSemaphoreValuesCount: uint32_t,
pSignalSemaphoreValues: *const [uint64_t; dyn signalSemaphoreValuesCount],
}
struct VkSemaphoreGetWin32HandleInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR,
pNext: *const void,
semaphore: VkSemaphore,
handleType: VkExternalSemaphoreHandleTypeFlagBits,
}
struct VkImportSemaphoreFdInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR,
pNext: *const void,
semaphore: VkSemaphore,
flags: VkSemaphoreImportFlags,
handleType: VkExternalSemaphoreHandleTypeFlagBits,
fd: int,
}
struct VkSemaphoreGetFdInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR,
pNext: *const void,
semaphore: VkSemaphore,
handleType: VkExternalSemaphoreHandleTypeFlagBits,
}
struct VkImportSemaphoreZirconHandleInfoFUCHSIA {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA,
pNext: *const void,
semaphore: VkSemaphore,
flags: VkSemaphoreImportFlags,
handleType: VkExternalSemaphoreHandleTypeFlagBits,
zirconHandle: zx_handle_t,
}
struct VkSemaphoreGetZirconHandleInfoFUCHSIA {
sType: VkStructureType = VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA,
pNext: *const void,
semaphore: VkSemaphore,
handleType: VkExternalSemaphoreHandleTypeFlagBits,
}
struct VkPhysicalDeviceExternalFenceInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO,
pNext: *const void,
handleType: VkExternalFenceHandleTypeFlagBits,
}
struct VkExternalFenceProperties {
sType: VkStructureType = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES,
pNext: *mut void,
exportFromImportedHandleTypes: VkExternalFenceHandleTypeFlags,
compatibleHandleTypes: VkExternalFenceHandleTypeFlags,
externalFenceFeatures: VkExternalFenceFeatureFlags,
}
struct VkExportFenceCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO,
pNext: *const void,
handleTypes: VkExternalFenceHandleTypeFlags,
}
struct VkImportFenceWin32HandleInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR,
pNext: *const void,
fence: VkFence,
flags: VkFenceImportFlags,
handleType: VkExternalFenceHandleTypeFlagBits,
handle: HANDLE,
name: LPCWSTR,
}
struct VkExportFenceWin32HandleInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR,
pNext: *const void,
pAttributes: *const SECURITY_ATTRIBUTES,
dwAccess: DWORD,
name: LPCWSTR,
}
struct VkFenceGetWin32HandleInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR,
pNext: *const void,
fence: VkFence,
handleType: VkExternalFenceHandleTypeFlagBits,
}
struct VkImportFenceFdInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR,
pNext: *const void,
fence: VkFence,
flags: VkFenceImportFlags,
handleType: VkExternalFenceHandleTypeFlagBits,
fd: int,
}
struct VkFenceGetFdInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR,
pNext: *const void,
fence: VkFence,
handleType: VkExternalFenceHandleTypeFlagBits,
}
struct VkExportFenceSciSyncInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_EXPORT_FENCE_SCI_SYNC_INFO_NV,
pNext: *const void,
pAttributes: NvSciSyncAttrList,
}
struct VkImportFenceSciSyncInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMPORT_FENCE_SCI_SYNC_INFO_NV,
pNext: *const void,
fence: VkFence,
handleType: VkExternalFenceHandleTypeFlagBits,
handle: *mut void,
}
struct VkFenceGetSciSyncInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_FENCE_GET_SCI_SYNC_INFO_NV,
pNext: *const void,
fence: VkFence,
handleType: VkExternalFenceHandleTypeFlagBits,
}
struct VkExportSemaphoreSciSyncInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_SCI_SYNC_INFO_NV,
pNext: *const void,
pAttributes: NvSciSyncAttrList,
}
struct VkImportSemaphoreSciSyncInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_SCI_SYNC_INFO_NV,
pNext: *const void,
semaphore: VkSemaphore,
handleType: VkExternalSemaphoreHandleTypeFlagBits,
handle: *mut void,
}
struct VkSemaphoreGetSciSyncInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_SEMAPHORE_GET_SCI_SYNC_INFO_NV,
pNext: *const void,
semaphore: VkSemaphore,
handleType: VkExternalSemaphoreHandleTypeFlagBits,
}
struct VkSciSyncAttributesInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_SCI_SYNC_ATTRIBUTES_INFO_NV,
pNext: *const void,
clientType: VkSciSyncClientTypeNV,
primitiveType: VkSciSyncPrimitiveTypeNV,
}
struct VkPhysicalDeviceExternalSciSyncFeaturesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SCI_SYNC_FEATURES_NV,
pNext: *mut void,
sciSyncFence: VkBool32,
sciSyncSemaphore: VkBool32,
sciSyncImport: VkBool32,
sciSyncExport: VkBool32,
}
struct VkPhysicalDeviceExternalSciSync2FeaturesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SCI_SYNC_2_FEATURES_NV,
pNext: *mut void,
sciSyncFence: VkBool32,
sciSyncSemaphore2: VkBool32,
sciSyncImport: VkBool32,
sciSyncExport: VkBool32,
}
struct VkSemaphoreSciSyncPoolCreateInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_SEMAPHORE_SCI_SYNC_POOL_CREATE_INFO_NV,
pNext: *const void,
handle: NvSciSyncObj,
}
struct VkSemaphoreSciSyncCreateInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_SEMAPHORE_SCI_SYNC_CREATE_INFO_NV,
pNext: *const void,
semaphorePool: VkSemaphoreSciSyncPoolNV,
pFence: *const NvSciSyncFence,
}
struct VkDeviceSemaphoreSciSyncPoolReservationCreateInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_SEMAPHORE_SCI_SYNC_POOL_RESERVATION_CREATE_INFO_NV,
pNext: *const void,
semaphoreSciSyncPoolRequestCount: uint32_t,
}
struct VkPhysicalDeviceMultiviewFeatures {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES,
pNext: *mut void,
multiview: VkBool32,
multiviewGeometryShader: VkBool32,
multiviewTessellationShader: VkBool32,
}
struct VkPhysicalDeviceMultiviewProperties {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES,
pNext: *mut void,
maxMultiviewViewCount: uint32_t,
maxMultiviewInstanceIndex: uint32_t,
}
struct VkRenderPassMultiviewCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO,
pNext: *const void,
subpassCount: uint32_t,
pViewMasks: *const [uint32_t; dyn subpassCount],
dependencyCount: uint32_t,
pViewOffsets: *const [int32_t; dyn dependencyCount],
correlationMaskCount: uint32_t,
pCorrelationMasks: *const [uint32_t; dyn correlationMaskCount],
}
struct VkSurfaceCapabilities2EXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT,
pNext: *mut void,
minImageCount: uint32_t,
maxImageCount: uint32_t,
currentExtent: VkExtent2D,
minImageExtent: VkExtent2D,
maxImageExtent: VkExtent2D,
maxImageArrayLayers: uint32_t,
supportedTransforms: VkSurfaceTransformFlagsKHR,
currentTransform: VkSurfaceTransformFlagBitsKHR,
supportedCompositeAlpha: VkCompositeAlphaFlagsKHR,
supportedUsageFlags: VkImageUsageFlags,
supportedSurfaceCounters: VkSurfaceCounterFlagsEXT,
}
struct VkDisplayPowerInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT,
pNext: *const void,
powerState: VkDisplayPowerStateEXT,
}
struct VkDeviceEventInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT,
pNext: *const void,
deviceEvent: VkDeviceEventTypeEXT,
}
struct VkDisplayEventInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT,
pNext: *const void,
displayEvent: VkDisplayEventTypeEXT,
}
struct VkSwapchainCounterCreateInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT,
pNext: *const void,
surfaceCounters: VkSurfaceCounterFlagsEXT,
}
struct VkPhysicalDeviceGroupProperties {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES,
pNext: *mut void,
physicalDeviceCount: uint32_t,
physicalDevices: [VkPhysicalDevice; VK_MAX_DEVICE_GROUP_SIZE],
subsetAllocation: VkBool32,
}
struct VkMemoryAllocateFlagsInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO,
pNext: *const void,
flags: VkMemoryAllocateFlags,
deviceMask: uint32_t,
}
struct VkBindBufferMemoryInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO,
pNext: *const void,
buffer: VkBuffer,
memory: VkDeviceMemory,
memoryOffset: VkDeviceSize,
}
struct VkBindBufferMemoryDeviceGroupInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO,
pNext: *const void,
deviceIndexCount: uint32_t,
pDeviceIndices: *const [uint32_t; dyn deviceIndexCount],
}
struct VkBindImageMemoryInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO,
pNext: *const void,
image: VkImage,
memory: VkDeviceMemory,
memoryOffset: VkDeviceSize,
}
struct VkBindImageMemoryDeviceGroupInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO,
pNext: *const void,
deviceIndexCount: uint32_t,
pDeviceIndices: *const [uint32_t; dyn deviceIndexCount],
splitInstanceBindRegionCount: uint32_t,
pSplitInstanceBindRegions: *const [VkRect2D; dyn splitInstanceBindRegionCount],
}
struct VkDeviceGroupRenderPassBeginInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO,
pNext: *const void,
deviceMask: uint32_t,
deviceRenderAreaCount: uint32_t,
pDeviceRenderAreas: *const [VkRect2D; dyn deviceRenderAreaCount],
}
struct VkDeviceGroupCommandBufferBeginInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO,
pNext: *const void,
deviceMask: uint32_t,
}
struct VkDeviceGroupSubmitInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO,
pNext: *const void,
waitSemaphoreCount: uint32_t,
pWaitSemaphoreDeviceIndices: *const [uint32_t; dyn waitSemaphoreCount],
commandBufferCount: uint32_t,
pCommandBufferDeviceMasks: *const [uint32_t; dyn commandBufferCount],
signalSemaphoreCount: uint32_t,
pSignalSemaphoreDeviceIndices: *const [uint32_t; dyn signalSemaphoreCount],
}
struct VkDeviceGroupBindSparseInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO,
pNext: *const void,
resourceDeviceIndex: uint32_t,
memoryDeviceIndex: uint32_t,
}
struct VkDeviceGroupPresentCapabilitiesKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR,
pNext: *mut void,
presentMask: [uint32_t; VK_MAX_DEVICE_GROUP_SIZE],
modes: VkDeviceGroupPresentModeFlagsKHR,
}
struct VkImageSwapchainCreateInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR,
pNext: *const void,
swapchain: VkSwapchainKHR,
}
struct VkBindImageMemorySwapchainInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR,
pNext: *const void,
swapchain: VkSwapchainKHR,
imageIndex: uint32_t,
}
struct VkAcquireNextImageInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR,
pNext: *const void,
swapchain: VkSwapchainKHR,
timeout: uint64_t,
semaphore: VkSemaphore,
fence: VkFence,
deviceMask: uint32_t,
}
struct VkDeviceGroupPresentInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR,
pNext: *const void,
swapchainCount: uint32_t,
pDeviceMasks: *const [uint32_t; dyn swapchainCount],
mode: VkDeviceGroupPresentModeFlagBitsKHR,
}
struct VkDeviceGroupDeviceCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO,
pNext: *const void,
physicalDeviceCount: uint32_t,
pPhysicalDevices: *const [VkPhysicalDevice; dyn physicalDeviceCount],
}
struct VkDeviceGroupSwapchainCreateInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR,
pNext: *const void,
modes: VkDeviceGroupPresentModeFlagsKHR,
}
struct VkDescriptorUpdateTemplateEntry {
dstBinding: uint32_t,
dstArrayElement: uint32_t,
descriptorCount: uint32_t,
descriptorType: VkDescriptorType,
offset: size_t,
stride: size_t,
}
struct VkDescriptorUpdateTemplateCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO,
pNext: *const void,
flags: VkDescriptorUpdateTemplateCreateFlags,
descriptorUpdateEntryCount: uint32_t,
pDescriptorUpdateEntries: *const [VkDescriptorUpdateTemplateEntry; dyn descriptorUpdateEntryCount],
templateType: VkDescriptorUpdateTemplateType,
descriptorSetLayout: VkDescriptorSetLayout,
pipelineBindPoint: VkPipelineBindPoint,
pipelineLayout: VkPipelineLayout,
set: uint32_t,
}
struct VkXYColorEXT {
x: float,
y: float,
}
struct VkPhysicalDevicePresentIdFeaturesKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR,
pNext: *mut void,
presentId: VkBool32,
}
struct VkPresentIdKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_PRESENT_ID_KHR,
pNext: *const void,
swapchainCount: uint32_t,
pPresentIds: *const [uint64_t; dyn swapchainCount],
}
struct VkPhysicalDevicePresentWaitFeaturesKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR,
pNext: *mut void,
presentWait: VkBool32,
}
struct VkHdrMetadataEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_HDR_METADATA_EXT,
pNext: *const void,
displayPrimaryRed: VkXYColorEXT,
displayPrimaryGreen: VkXYColorEXT,
displayPrimaryBlue: VkXYColorEXT,
whitePoint: VkXYColorEXT,
maxLuminance: float,
minLuminance: float,
maxContentLightLevel: float,
maxFrameAverageLightLevel: float,
}
struct VkDisplayNativeHdrSurfaceCapabilitiesAMD {
sType: VkStructureType = VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD,
pNext: *mut void,
localDimmingSupport: VkBool32,
}
struct VkSwapchainDisplayNativeHdrCreateInfoAMD {
sType: VkStructureType = VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD,
pNext: *const void,
localDimmingEnable: VkBool32,
}
struct VkRefreshCycleDurationGOOGLE {
refreshDuration: uint64_t,
}
struct VkPastPresentationTimingGOOGLE {
presentID: uint32_t,
desiredPresentTime: uint64_t,
actualPresentTime: uint64_t,
earliestPresentTime: uint64_t,
presentMargin: uint64_t,
}
struct VkPresentTimesInfoGOOGLE {
sType: VkStructureType = VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE,
pNext: *const void,
swapchainCount: uint32_t,
pTimes: *const [VkPresentTimeGOOGLE; dyn swapchainCount],
}
struct VkPresentTimeGOOGLE {
presentID: uint32_t,
desiredPresentTime: uint64_t,
}
struct VkIOSSurfaceCreateInfoMVK {
sType: VkStructureType = VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK,
pNext: *const void,
flags: VkIOSSurfaceCreateFlagsMVK,
pView: *const void,
}
struct VkMacOSSurfaceCreateInfoMVK {
sType: VkStructureType = VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK,
pNext: *const void,
flags: VkMacOSSurfaceCreateFlagsMVK,
pView: *const void,
}
struct VkMetalSurfaceCreateInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT,
pNext: *const void,
flags: VkMetalSurfaceCreateFlagsEXT,
pLayer: *const CAMetalLayer,
}
struct VkViewportWScalingNV {
xcoeff: float,
ycoeff: float,
}
struct VkPipelineViewportWScalingStateCreateInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV,
pNext: *const void,
viewportWScalingEnable: VkBool32,
viewportCount: uint32_t,
pViewportWScalings: *const [VkViewportWScalingNV; dyn viewportCount],
}
struct VkViewportSwizzleNV {
x: VkViewportCoordinateSwizzleNV,
y: VkViewportCoordinateSwizzleNV,
z: VkViewportCoordinateSwizzleNV,
w: VkViewportCoordinateSwizzleNV,
}
struct VkPipelineViewportSwizzleStateCreateInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV,
pNext: *const void,
flags: VkPipelineViewportSwizzleStateCreateFlagsNV,
viewportCount: uint32_t,
pViewportSwizzles: *const [VkViewportSwizzleNV; dyn viewportCount],
}
struct VkPhysicalDeviceDiscardRectanglePropertiesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT,
pNext: *mut void,
maxDiscardRectangles: uint32_t,
}
struct VkPipelineDiscardRectangleStateCreateInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT,
pNext: *const void,
flags: VkPipelineDiscardRectangleStateCreateFlagsEXT,
discardRectangleMode: VkDiscardRectangleModeEXT,
discardRectangleCount: uint32_t,
pDiscardRectangles: *const [VkRect2D; dyn discardRectangleCount],
}
struct VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX,
pNext: *mut void,
perViewPositionAllComponents: VkBool32,
}
struct VkInputAttachmentAspectReference {
subpass: uint32_t,
inputAttachmentIndex: uint32_t,
aspectMask: VkImageAspectFlags,
}
struct VkRenderPassInputAttachmentAspectCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO,
pNext: *const void,
aspectReferenceCount: uint32_t,
pAspectReferences: *const [VkInputAttachmentAspectReference; dyn aspectReferenceCount],
}
struct VkPhysicalDeviceSurfaceInfo2KHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR,
pNext: *const void,
surface: VkSurfaceKHR,
}
struct VkSurfaceCapabilities2KHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR,
pNext: *mut void,
surfaceCapabilities: VkSurfaceCapabilitiesKHR,
}
struct VkSurfaceFormat2KHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR,
pNext: *mut void,
surfaceFormat: VkSurfaceFormatKHR,
}
struct VkDisplayProperties2KHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR,
pNext: *mut void,
displayProperties: VkDisplayPropertiesKHR,
}
struct VkDisplayPlaneProperties2KHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR,
pNext: *mut void,
displayPlaneProperties: VkDisplayPlanePropertiesKHR,
}
struct VkDisplayModeProperties2KHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR,
pNext: *mut void,
displayModeProperties: VkDisplayModePropertiesKHR,
}
struct VkDisplayPlaneInfo2KHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR,
pNext: *const void,
mode: VkDisplayModeKHR,
planeIndex: uint32_t,
}
struct VkDisplayPlaneCapabilities2KHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR,
pNext: *mut void,
capabilities: VkDisplayPlaneCapabilitiesKHR,
}
struct VkSharedPresentSurfaceCapabilitiesKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR,
pNext: *mut void,
sharedPresentSupportedUsageFlags: VkImageUsageFlags,
}
struct VkPhysicalDevice16BitStorageFeatures {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES,
pNext: *mut void,
storageBuffer16BitAccess: VkBool32,
uniformAndStorageBuffer16BitAccess: VkBool32,
storagePushConstant16: VkBool32,
storageInputOutput16: VkBool32,
}
struct VkPhysicalDeviceSubgroupProperties {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES,
pNext: *mut void,
subgroupSize: uint32_t,
supportedStages: VkShaderStageFlags,
supportedOperations: VkSubgroupFeatureFlags,
quadOperationsInAllStages: VkBool32,
}
struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES,
pNext: *mut void,
shaderSubgroupExtendedTypes: VkBool32,
}
struct VkBufferMemoryRequirementsInfo2 {
sType: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2,
pNext: *const void,
buffer: VkBuffer,
}
struct VkDeviceBufferMemoryRequirements {
sType: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS,
pNext: *const void,
pCreateInfo: *const VkBufferCreateInfo,
}
struct VkImageMemoryRequirementsInfo2 {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2,
pNext: *const void,
image: VkImage,
}
struct VkImageSparseMemoryRequirementsInfo2 {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2,
pNext: *const void,
image: VkImage,
}
struct VkDeviceImageMemoryRequirements {
sType: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS,
pNext: *const void,
pCreateInfo: *const VkImageCreateInfo,
planeAspect: VkImageAspectFlagBits,
}
struct VkMemoryRequirements2 {
sType: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2,
pNext: *mut void,
memoryRequirements: VkMemoryRequirements,
}
struct VkSparseImageMemoryRequirements2 {
sType: VkStructureType = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2,
pNext: *mut void,
memoryRequirements: VkSparseImageMemoryRequirements,
}
struct VkPhysicalDevicePointClippingProperties {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES,
pNext: *mut void,
pointClippingBehavior: VkPointClippingBehavior,
}
struct VkMemoryDedicatedRequirements {
sType: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS,
pNext: *mut void,
prefersDedicatedAllocation: VkBool32,
requiresDedicatedAllocation: VkBool32,
}
struct VkMemoryDedicatedAllocateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,
pNext: *const void,
image: VkImage,
buffer: VkBuffer,
}
struct VkImageViewUsageCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO,
pNext: *const void,
usage: VkImageUsageFlags,
}
struct VkImageViewSlicedCreateInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT,
pNext: *const void,
sliceOffset: uint32_t,
sliceCount: uint32_t,
}
struct VkPipelineTessellationDomainOriginStateCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO,
pNext: *const void,
domainOrigin: VkTessellationDomainOrigin,
}
struct VkSamplerYcbcrConversionInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO,
pNext: *const void,
conversion: VkSamplerYcbcrConversion,
}
struct VkSamplerYcbcrConversionCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO,
pNext: *const void,
format: VkFormat,
ycbcrModel: VkSamplerYcbcrModelConversion,
ycbcrRange: VkSamplerYcbcrRange,
components: VkComponentMapping,
xChromaOffset: VkChromaLocation,
yChromaOffset: VkChromaLocation,
chromaFilter: VkFilter,
forceExplicitReconstruction: VkBool32,
}
struct VkBindImagePlaneMemoryInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO,
pNext: *const void,
planeAspect: VkImageAspectFlagBits,
}
struct VkImagePlaneMemoryRequirementsInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO,
pNext: *const void,
planeAspect: VkImageAspectFlagBits,
}
struct VkPhysicalDeviceSamplerYcbcrConversionFeatures {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES,
pNext: *mut void,
samplerYcbcrConversion: VkBool32,
}
struct VkSamplerYcbcrConversionImageFormatProperties {
sType: VkStructureType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES,
pNext: *mut void,
combinedImageSamplerDescriptorCount: uint32_t,
}
struct VkTextureLODGatherFormatPropertiesAMD {
sType: VkStructureType = VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD,
pNext: *mut void,
supportsTextureGatherLODBiasAMD: VkBool32,
}
struct VkConditionalRenderingBeginInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT,
pNext: *const void,
buffer: VkBuffer,
offset: VkDeviceSize,
flags: VkConditionalRenderingFlagsEXT,
}
struct VkProtectedSubmitInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO,
pNext: *const void,
protectedSubmit: VkBool32,
}
struct VkPhysicalDeviceProtectedMemoryFeatures {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES,
pNext: *mut void,
protectedMemory: VkBool32,
}
struct VkPhysicalDeviceProtectedMemoryProperties {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES,
pNext: *mut void,
protectedNoFault: VkBool32,
}
struct VkDeviceQueueInfo2 {
sType: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2,
pNext: *const void,
flags: VkDeviceQueueCreateFlags,
queueFamilyIndex: uint32_t,
queueIndex: uint32_t,
}
struct VkPipelineCoverageToColorStateCreateInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV,
pNext: *const void,
flags: VkPipelineCoverageToColorStateCreateFlagsNV,
coverageToColorEnable: VkBool32,
coverageToColorLocation: uint32_t,
}
struct VkPhysicalDeviceSamplerFilterMinmaxProperties {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES,
pNext: *mut void,
filterMinmaxSingleComponentFormats: VkBool32,
filterMinmaxImageComponentMapping: VkBool32,
}
struct VkSampleLocationEXT {
x: float,
y: float,
}
struct VkSampleLocationsInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT,
pNext: *const void,
sampleLocationsPerPixel: VkSampleCountFlagBits,
sampleLocationGridSize: VkExtent2D,
sampleLocationsCount: uint32_t,
pSampleLocations: *const [VkSampleLocationEXT; dyn sampleLocationsCount],
}
struct VkAttachmentSampleLocationsEXT {
attachmentIndex: uint32_t,
sampleLocationsInfo: VkSampleLocationsInfoEXT,
}
struct VkSubpassSampleLocationsEXT {
subpassIndex: uint32_t,
sampleLocationsInfo: VkSampleLocationsInfoEXT,
}
struct VkRenderPassSampleLocationsBeginInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT,
pNext: *const void,
attachmentInitialSampleLocationsCount: uint32_t,
pAttachmentInitialSampleLocations: *const [VkAttachmentSampleLocationsEXT; dyn attachmentInitialSampleLocationsCount],
postSubpassSampleLocationsCount: uint32_t,
pPostSubpassSampleLocations: *const [VkSubpassSampleLocationsEXT; dyn postSubpassSampleLocationsCount],
}
struct VkPipelineSampleLocationsStateCreateInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT,
pNext: *const void,
sampleLocationsEnable: VkBool32,
sampleLocationsInfo: VkSampleLocationsInfoEXT,
}
struct VkPhysicalDeviceSampleLocationsPropertiesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT,
pNext: *mut void,
sampleLocationSampleCounts: VkSampleCountFlags,
maxSampleLocationGridSize: VkExtent2D,
sampleLocationCoordinateRange: [float; 2],
sampleLocationSubPixelBits: uint32_t,
variableSampleLocations: VkBool32,
}
struct VkMultisamplePropertiesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT,
pNext: *mut void,
maxSampleLocationGridSize: VkExtent2D,
}
struct VkSamplerReductionModeCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO,
pNext: *const void,
reductionMode: VkSamplerReductionMode,
}
struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT,
pNext: *mut void,
advancedBlendCoherentOperations: VkBool32,
}
struct VkPhysicalDeviceMultiDrawFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT,
pNext: *mut void,
multiDraw: VkBool32,
}
struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT,
pNext: *mut void,
advancedBlendMaxColorAttachments: uint32_t,
advancedBlendIndependentBlend: VkBool32,
advancedBlendNonPremultipliedSrcColor: VkBool32,
advancedBlendNonPremultipliedDstColor: VkBool32,
advancedBlendCorrelatedOverlap: VkBool32,
advancedBlendAllOperations: VkBool32,
}
struct VkPipelineColorBlendAdvancedStateCreateInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT,
pNext: *const void,
srcPremultiplied: VkBool32,
dstPremultiplied: VkBool32,
blendOverlap: VkBlendOverlapEXT,
}
struct VkPhysicalDeviceInlineUniformBlockFeatures {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES,
pNext: *mut void,
inlineUniformBlock: VkBool32,
descriptorBindingInlineUniformBlockUpdateAfterBind: VkBool32,
}
struct VkPhysicalDeviceInlineUniformBlockProperties {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES,
pNext: *mut void,
maxInlineUniformBlockSize: uint32_t,
maxPerStageDescriptorInlineUniformBlocks: uint32_t,
maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks: uint32_t,
maxDescriptorSetInlineUniformBlocks: uint32_t,
maxDescriptorSetUpdateAfterBindInlineUniformBlocks: uint32_t,
}
struct VkWriteDescriptorSetInlineUniformBlock {
sType: VkStructureType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK,
pNext: *const void,
dataSize: uint32_t,
pData: *const [void; dyn dataSize],
}
struct VkDescriptorPoolInlineUniformBlockCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO,
pNext: *const void,
maxInlineUniformBlockBindings: uint32_t,
}
struct VkPipelineCoverageModulationStateCreateInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV,
pNext: *const void,
flags: VkPipelineCoverageModulationStateCreateFlagsNV,
coverageModulationMode: VkCoverageModulationModeNV,
coverageModulationTableEnable: VkBool32,
coverageModulationTableCount: uint32_t,
pCoverageModulationTable: *const [float; dyn coverageModulationTableCount],
}
struct VkImageFormatListCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO,
pNext: *const void,
viewFormatCount: uint32_t,
pViewFormats: *const [VkFormat; dyn viewFormatCount],
}
struct VkValidationCacheCreateInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT,
pNext: *const void,
flags: VkValidationCacheCreateFlagsEXT,
initialDataSize: size_t,
pInitialData: *const [void; dyn initialDataSize],
}
struct VkShaderModuleValidationCacheCreateInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT,
pNext: *const void,
validationCache: VkValidationCacheEXT,
}
struct VkPhysicalDeviceMaintenance3Properties {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES,
pNext: *mut void,
maxPerSetDescriptors: uint32_t,
maxMemoryAllocationSize: VkDeviceSize,
}
struct VkPhysicalDeviceMaintenance4Features {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES,
pNext: *mut void,
maintenance4: VkBool32,
}
struct VkPhysicalDeviceMaintenance4Properties {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES,
pNext: *mut void,
maxBufferSize: VkDeviceSize,
}
struct VkPhysicalDeviceMaintenance5FeaturesKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR,
pNext: *mut void,
maintenance5: VkBool32,
}
struct VkPhysicalDeviceMaintenance5PropertiesKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR,
pNext: *mut void,
earlyFragmentMultisampleCoverageAfterSampleCounting: VkBool32,
earlyFragmentSampleMaskTestBeforeSampleCounting: VkBool32,
depthStencilSwizzleOneSupport: VkBool32,
polygonModePointSize: VkBool32,
nonStrictSinglePixelWideLinesUseParallelogram: VkBool32,
nonStrictWideLinesUseParallelogram: VkBool32,
}
struct VkRenderingAreaInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_RENDERING_AREA_INFO_KHR,
pNext: *const void,
viewMask: uint32_t,
colorAttachmentCount: uint32_t,
pColorAttachmentFormats: *const [VkFormat; dyn colorAttachmentCount],
depthAttachmentFormat: VkFormat,
stencilAttachmentFormat: VkFormat,
}
struct VkDescriptorSetLayoutSupport {
sType: VkStructureType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT,
pNext: *mut void,
supported: VkBool32,
}
struct VkPhysicalDeviceShaderDrawParametersFeatures {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES,
pNext: *mut void,
shaderDrawParameters: VkBool32,
}
struct VkPhysicalDeviceShaderFloat16Int8Features {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES,
pNext: *mut void,
shaderFloat16: VkBool32,
shaderInt8: VkBool32,
}
struct VkPhysicalDeviceFloatControlsProperties {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES,
pNext: *mut void,
denormBehaviorIndependence: VkShaderFloatControlsIndependence,
roundingModeIndependence: VkShaderFloatControlsIndependence,
shaderSignedZeroInfNanPreserveFloat16: VkBool32,
shaderSignedZeroInfNanPreserveFloat32: VkBool32,
shaderSignedZeroInfNanPreserveFloat64: VkBool32,
shaderDenormPreserveFloat16: VkBool32,
shaderDenormPreserveFloat32: VkBool32,
shaderDenormPreserveFloat64: VkBool32,
shaderDenormFlushToZeroFloat16: VkBool32,
shaderDenormFlushToZeroFloat32: VkBool32,
shaderDenormFlushToZeroFloat64: VkBool32,
shaderRoundingModeRTEFloat16: VkBool32,
shaderRoundingModeRTEFloat32: VkBool32,
shaderRoundingModeRTEFloat64: VkBool32,
shaderRoundingModeRTZFloat16: VkBool32,
shaderRoundingModeRTZFloat32: VkBool32,
shaderRoundingModeRTZFloat64: VkBool32,
}
struct VkPhysicalDeviceHostQueryResetFeatures {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES,
pNext: *mut void,
hostQueryReset: VkBool32,
}
struct VkNativeBufferUsage2ANDROID {
consumer: uint64_t,
producer: uint64_t,
}
struct VkNativeBufferANDROID {
sType: VkStructureType = VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID,
pNext: *const void,
handle: *const void,
stride: int,
format: int,
usage: int,
usage2: VkNativeBufferUsage2ANDROID,
}
struct VkSwapchainImageCreateInfoANDROID {
sType: VkStructureType = VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID,
pNext: *const void,
usage: VkSwapchainImageUsageFlagsANDROID,
}
struct VkPhysicalDevicePresentationPropertiesANDROID {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID,
pNext: *const void,
sharedImage: VkBool32,
}
struct VkShaderResourceUsageAMD {
numUsedVgprs: uint32_t,
numUsedSgprs: uint32_t,
ldsSizePerLocalWorkGroup: uint32_t,
ldsUsageSizeInBytes: size_t,
scratchMemUsageInBytes: size_t,
}
struct VkShaderStatisticsInfoAMD {
shaderStageMask: VkShaderStageFlags,
resourceUsage: VkShaderResourceUsageAMD,
numPhysicalVgprs: uint32_t,
numPhysicalSgprs: uint32_t,
numAvailableVgprs: uint32_t,
numAvailableSgprs: uint32_t,
computeWorkGroupSize: [uint32_t; 3],
}
struct VkDeviceQueueGlobalPriorityCreateInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR,
pNext: *const void,
globalPriority: VkQueueGlobalPriorityKHR,
}
struct VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR,
pNext: *mut void,
globalPriorityQuery: VkBool32,
}
struct VkQueueFamilyGlobalPriorityPropertiesKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR,
pNext: *mut void,
priorityCount: uint32_t,
priorities: [VkQueueGlobalPriorityKHR; VK_MAX_GLOBAL_PRIORITY_SIZE_KHR],
}
struct VkDebugUtilsObjectNameInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT,
pNext: *const void,
objectType: VkObjectType,
objectHandle: uint64_t,
pObjectName: *const [char; dyn null-terminated],
}
struct VkDebugUtilsObjectTagInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT,
pNext: *const void,
objectType: VkObjectType,
objectHandle: uint64_t,
tagName: uint64_t,
tagSize: size_t,
pTag: *const [void; dyn tagSize],
}
struct VkDebugUtilsLabelEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT,
pNext: *const void,
pLabelName: *const [char; dyn null-terminated],
color: [float; 4],
}
struct VkDebugUtilsMessengerCreateInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT,
pNext: *const void,
flags: VkDebugUtilsMessengerCreateFlagsEXT,
messageSeverity: VkDebugUtilsMessageSeverityFlagsEXT,
messageType: VkDebugUtilsMessageTypeFlagsEXT,
pfnUserCallback: PFN_vkDebugUtilsMessengerCallbackEXT,
pUserData: *mut void,
}
struct VkDebugUtilsMessengerCallbackDataEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT,
pNext: *const void,
flags: VkDebugUtilsMessengerCallbackDataFlagsEXT,
pMessageIdName: *const [char; dyn null-terminated],
messageIdNumber: int32_t,
pMessage: *const [char; dyn null-terminated],
queueLabelCount: uint32_t,
pQueueLabels: *const [VkDebugUtilsLabelEXT; dyn queueLabelCount],
cmdBufLabelCount: uint32_t,
pCmdBufLabels: *const [VkDebugUtilsLabelEXT; dyn cmdBufLabelCount],
objectCount: uint32_t,
pObjects: *const [VkDebugUtilsObjectNameInfoEXT; dyn objectCount],
}
struct VkPhysicalDeviceDeviceMemoryReportFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT,
pNext: *mut void,
deviceMemoryReport: VkBool32,
}
struct VkDeviceDeviceMemoryReportCreateInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT,
pNext: *const void,
flags: VkDeviceMemoryReportFlagsEXT,
pfnUserCallback: PFN_vkDeviceMemoryReportCallbackEXT,
pUserData: *mut void,
}
struct VkDeviceMemoryReportCallbackDataEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT,
pNext: *mut void,
flags: VkDeviceMemoryReportFlagsEXT,
type: VkDeviceMemoryReportEventTypeEXT,
memoryObjectId: uint64_t,
size: VkDeviceSize,
objectType: VkObjectType,
objectHandle: uint64_t,
heapIndex: uint32_t,
}
struct VkImportMemoryHostPointerInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT,
pNext: *const void,
handleType: VkExternalMemoryHandleTypeFlagBits,
pHostPointer: *mut void,
}
struct VkMemoryHostPointerPropertiesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT,
pNext: *mut void,
memoryTypeBits: uint32_t,
}
struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT,
pNext: *mut void,
minImportedHostPointerAlignment: VkDeviceSize,
}
struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT,
pNext: *mut void,
primitiveOverestimationSize: float,
maxExtraPrimitiveOverestimationSize: float,
extraPrimitiveOverestimationSizeGranularity: float,
primitiveUnderestimation: VkBool32,
conservativePointAndLineRasterization: VkBool32,
degenerateTrianglesRasterized: VkBool32,
degenerateLinesRasterized: VkBool32,
fullyCoveredFragmentShaderInputVariable: VkBool32,
conservativeRasterizationPostDepthCoverage: VkBool32,
}
struct VkCalibratedTimestampInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT,
pNext: *const void,
timeDomain: VkTimeDomainEXT,
}
struct VkPhysicalDeviceShaderCorePropertiesAMD {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD,
pNext: *mut void,
shaderEngineCount: uint32_t,
shaderArraysPerEngineCount: uint32_t,
computeUnitsPerShaderArray: uint32_t,
simdPerComputeUnit: uint32_t,
wavefrontsPerSimd: uint32_t,
wavefrontSize: uint32_t,
sgprsPerSimd: uint32_t,
minSgprAllocation: uint32_t,
maxSgprAllocation: uint32_t,
sgprAllocationGranularity: uint32_t,
vgprsPerSimd: uint32_t,
minVgprAllocation: uint32_t,
maxVgprAllocation: uint32_t,
vgprAllocationGranularity: uint32_t,
}
struct VkPhysicalDeviceShaderCoreProperties2AMD {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD,
pNext: *mut void,
shaderCoreFeatures: VkShaderCorePropertiesFlagsAMD,
activeComputeUnitCount: uint32_t,
}
struct VkPipelineRasterizationConservativeStateCreateInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT,
pNext: *const void,
flags: VkPipelineRasterizationConservativeStateCreateFlagsEXT,
conservativeRasterizationMode: VkConservativeRasterizationModeEXT,
extraPrimitiveOverestimationSize: float,
}
struct VkPhysicalDeviceDescriptorIndexingFeatures {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES,
pNext: *mut void,
shaderInputAttachmentArrayDynamicIndexing: VkBool32,
shaderUniformTexelBufferArrayDynamicIndexing: VkBool32,
shaderStorageTexelBufferArrayDynamicIndexing: VkBool32,
shaderUniformBufferArrayNonUniformIndexing: VkBool32,
shaderSampledImageArrayNonUniformIndexing: VkBool32,
shaderStorageBufferArrayNonUniformIndexing: VkBool32,
shaderStorageImageArrayNonUniformIndexing: VkBool32,
shaderInputAttachmentArrayNonUniformIndexing: VkBool32,
shaderUniformTexelBufferArrayNonUniformIndexing: VkBool32,
shaderStorageTexelBufferArrayNonUniformIndexing: VkBool32,
descriptorBindingUniformBufferUpdateAfterBind: VkBool32,
descriptorBindingSampledImageUpdateAfterBind: VkBool32,
descriptorBindingStorageImageUpdateAfterBind: VkBool32,
descriptorBindingStorageBufferUpdateAfterBind: VkBool32,
descriptorBindingUniformTexelBufferUpdateAfterBind: VkBool32,
descriptorBindingStorageTexelBufferUpdateAfterBind: VkBool32,
descriptorBindingUpdateUnusedWhilePending: VkBool32,
descriptorBindingPartiallyBound: VkBool32,
descriptorBindingVariableDescriptorCount: VkBool32,
runtimeDescriptorArray: VkBool32,
}
struct VkPhysicalDeviceDescriptorIndexingProperties {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES,
pNext: *mut void,
maxUpdateAfterBindDescriptorsInAllPools: uint32_t,
shaderUniformBufferArrayNonUniformIndexingNative: VkBool32,
shaderSampledImageArrayNonUniformIndexingNative: VkBool32,
shaderStorageBufferArrayNonUniformIndexingNative: VkBool32,
shaderStorageImageArrayNonUniformIndexingNative: VkBool32,
shaderInputAttachmentArrayNonUniformIndexingNative: VkBool32,
robustBufferAccessUpdateAfterBind: VkBool32,
quadDivergentImplicitLod: VkBool32,
maxPerStageDescriptorUpdateAfterBindSamplers: uint32_t,
maxPerStageDescriptorUpdateAfterBindUniformBuffers: uint32_t,
maxPerStageDescriptorUpdateAfterBindStorageBuffers: uint32_t,
maxPerStageDescriptorUpdateAfterBindSampledImages: uint32_t,
maxPerStageDescriptorUpdateAfterBindStorageImages: uint32_t,
maxPerStageDescriptorUpdateAfterBindInputAttachments: uint32_t,
maxPerStageUpdateAfterBindResources: uint32_t,
maxDescriptorSetUpdateAfterBindSamplers: uint32_t,
maxDescriptorSetUpdateAfterBindUniformBuffers: uint32_t,
maxDescriptorSetUpdateAfterBindUniformBuffersDynamic: uint32_t,
maxDescriptorSetUpdateAfterBindStorageBuffers: uint32_t,
maxDescriptorSetUpdateAfterBindStorageBuffersDynamic: uint32_t,
maxDescriptorSetUpdateAfterBindSampledImages: uint32_t,
maxDescriptorSetUpdateAfterBindStorageImages: uint32_t,
maxDescriptorSetUpdateAfterBindInputAttachments: uint32_t,
}
struct VkDescriptorSetLayoutBindingFlagsCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO,
pNext: *const void,
bindingCount: uint32_t,
pBindingFlags: *const [VkDescriptorBindingFlags; dyn bindingCount],
}
struct VkDescriptorSetVariableDescriptorCountAllocateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO,
pNext: *const void,
descriptorSetCount: uint32_t,
pDescriptorCounts: *const [uint32_t; dyn descriptorSetCount],
}
struct VkDescriptorSetVariableDescriptorCountLayoutSupport {
sType: VkStructureType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT,
pNext: *mut void,
maxVariableDescriptorCount: uint32_t,
}
struct VkAttachmentDescription2 {
sType: VkStructureType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2,
pNext: *const void,
flags: VkAttachmentDescriptionFlags,
format: VkFormat,
samples: VkSampleCountFlagBits,
loadOp: VkAttachmentLoadOp,
storeOp: VkAttachmentStoreOp,
stencilLoadOp: VkAttachmentLoadOp,
stencilStoreOp: VkAttachmentStoreOp,
initialLayout: VkImageLayout,
finalLayout: VkImageLayout,
}
struct VkAttachmentReference2 {
sType: VkStructureType = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2,
pNext: *const void,
attachment: uint32_t,
layout: VkImageLayout,
aspectMask: VkImageAspectFlags,
}
struct VkSubpassDescription2 {
sType: VkStructureType = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2,
pNext: *const void,
flags: VkSubpassDescriptionFlags,
pipelineBindPoint: VkPipelineBindPoint,
viewMask: uint32_t,
inputAttachmentCount: uint32_t,
pInputAttachments: *const [VkAttachmentReference2; dyn inputAttachmentCount],
colorAttachmentCount: uint32_t,
pColorAttachments: *const [VkAttachmentReference2; dyn colorAttachmentCount],
pResolveAttachments: *const [VkAttachmentReference2; dyn colorAttachmentCount],
pDepthStencilAttachment: *const VkAttachmentReference2,
preserveAttachmentCount: uint32_t,
pPreserveAttachments: *const [uint32_t; dyn preserveAttachmentCount],
}
struct VkSubpassDependency2 {
sType: VkStructureType = VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2,
pNext: *const void,
srcSubpass: uint32_t,
dstSubpass: uint32_t,
srcStageMask: VkPipelineStageFlags,
dstStageMask: VkPipelineStageFlags,
srcAccessMask: VkAccessFlags,
dstAccessMask: VkAccessFlags,
dependencyFlags: VkDependencyFlags,
viewOffset: int32_t,
}
struct VkRenderPassCreateInfo2 {
sType: VkStructureType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2,
pNext: *const void,
flags: VkRenderPassCreateFlags,
attachmentCount: uint32_t,
pAttachments: *const [VkAttachmentDescription2; dyn attachmentCount],
subpassCount: uint32_t,
pSubpasses: *const [VkSubpassDescription2; dyn subpassCount],
dependencyCount: uint32_t,
pDependencies: *const [VkSubpassDependency2; dyn dependencyCount],
correlatedViewMaskCount: uint32_t,
pCorrelatedViewMasks: *const [uint32_t; dyn correlatedViewMaskCount],
}
struct VkSubpassBeginInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO,
pNext: *const void,
contents: VkSubpassContents,
}
struct VkSubpassEndInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_SUBPASS_END_INFO,
pNext: *const void,
}
struct VkPhysicalDeviceTimelineSemaphoreFeatures {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES,
pNext: *mut void,
timelineSemaphore: VkBool32,
}
struct VkPhysicalDeviceTimelineSemaphoreProperties {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES,
pNext: *mut void,
maxTimelineSemaphoreValueDifference: uint64_t,
}
struct VkSemaphoreTypeCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO,
pNext: *const void,
semaphoreType: VkSemaphoreType,
initialValue: uint64_t,
}
struct VkTimelineSemaphoreSubmitInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO,
pNext: *const void,
waitSemaphoreValueCount: uint32_t,
pWaitSemaphoreValues: *const [uint64_t; dyn waitSemaphoreValueCount],
signalSemaphoreValueCount: uint32_t,
pSignalSemaphoreValues: *const [uint64_t; dyn signalSemaphoreValueCount],
}
struct VkSemaphoreWaitInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO,
pNext: *const void,
flags: VkSemaphoreWaitFlags,
semaphoreCount: uint32_t,
pSemaphores: *const [VkSemaphore; dyn semaphoreCount],
pValues: *const [uint64_t; dyn semaphoreCount],
}
struct VkSemaphoreSignalInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO,
pNext: *const void,
semaphore: VkSemaphore,
value: uint64_t,
}
struct VkVertexInputBindingDivisorDescriptionEXT {
binding: uint32_t,
divisor: uint32_t,
}
struct VkPipelineVertexInputDivisorStateCreateInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT,
pNext: *const void,
vertexBindingDivisorCount: uint32_t,
pVertexBindingDivisors: *const [VkVertexInputBindingDivisorDescriptionEXT; dyn vertexBindingDivisorCount],
}
struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT,
pNext: *mut void,
maxVertexAttribDivisor: uint32_t,
}
struct VkPhysicalDevicePCIBusInfoPropertiesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT,
pNext: *mut void,
pciDomain: uint32_t,
pciBus: uint32_t,
pciDevice: uint32_t,
pciFunction: uint32_t,
}
struct VkImportAndroidHardwareBufferInfoANDROID {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID,
pNext: *const void,
buffer: *mut /*struct*/AHardwareBuffer,
}
struct VkAndroidHardwareBufferUsageANDROID {
sType: VkStructureType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID,
pNext: *mut void,
androidHardwareBufferUsage: uint64_t,
}
struct VkAndroidHardwareBufferPropertiesANDROID {
sType: VkStructureType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID,
pNext: *mut void,
allocationSize: VkDeviceSize,
memoryTypeBits: uint32_t,
}
struct VkMemoryGetAndroidHardwareBufferInfoANDROID {
sType: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID,
pNext: *const void,
memory: VkDeviceMemory,
}
struct VkAndroidHardwareBufferFormatPropertiesANDROID {
sType: VkStructureType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID,
pNext: *mut void,
format: VkFormat,
externalFormat: uint64_t,
formatFeatures: VkFormatFeatureFlags,
samplerYcbcrConversionComponents: VkComponentMapping,
suggestedYcbcrModel: VkSamplerYcbcrModelConversion,
suggestedYcbcrRange: VkSamplerYcbcrRange,
suggestedXChromaOffset: VkChromaLocation,
suggestedYChromaOffset: VkChromaLocation,
}
struct VkCommandBufferInheritanceConditionalRenderingInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT,
pNext: *const void,
conditionalRenderingEnable: VkBool32,
}
struct VkExternalFormatANDROID {
sType: VkStructureType = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID,
pNext: *mut void,
externalFormat: uint64_t,
}
struct VkPhysicalDevice8BitStorageFeatures {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES,
pNext: *mut void,
storageBuffer8BitAccess: VkBool32,
uniformAndStorageBuffer8BitAccess: VkBool32,
storagePushConstant8: VkBool32,
}
struct VkPhysicalDeviceConditionalRenderingFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT,
pNext: *mut void,
conditionalRendering: VkBool32,
inheritedConditionalRendering: VkBool32,
}
struct VkPhysicalDeviceVulkanMemoryModelFeatures {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES,
pNext: *mut void,
vulkanMemoryModel: VkBool32,
vulkanMemoryModelDeviceScope: VkBool32,
vulkanMemoryModelAvailabilityVisibilityChains: VkBool32,
}
struct VkPhysicalDeviceShaderAtomicInt64Features {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES,
pNext: *mut void,
shaderBufferInt64Atomics: VkBool32,
shaderSharedInt64Atomics: VkBool32,
}
struct VkPhysicalDeviceShaderAtomicFloatFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT,
pNext: *mut void,
shaderBufferFloat32Atomics: VkBool32,
shaderBufferFloat32AtomicAdd: VkBool32,
shaderBufferFloat64Atomics: VkBool32,
shaderBufferFloat64AtomicAdd: VkBool32,
shaderSharedFloat32Atomics: VkBool32,
shaderSharedFloat32AtomicAdd: VkBool32,
shaderSharedFloat64Atomics: VkBool32,
shaderSharedFloat64AtomicAdd: VkBool32,
shaderImageFloat32Atomics: VkBool32,
shaderImageFloat32AtomicAdd: VkBool32,
sparseImageFloat32Atomics: VkBool32,
sparseImageFloat32AtomicAdd: VkBool32,
}
struct VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT,
pNext: *mut void,
shaderBufferFloat16Atomics: VkBool32,
shaderBufferFloat16AtomicAdd: VkBool32,
shaderBufferFloat16AtomicMinMax: VkBool32,
shaderBufferFloat32AtomicMinMax: VkBool32,
shaderBufferFloat64AtomicMinMax: VkBool32,
shaderSharedFloat16Atomics: VkBool32,
shaderSharedFloat16AtomicAdd: VkBool32,
shaderSharedFloat16AtomicMinMax: VkBool32,
shaderSharedFloat32AtomicMinMax: VkBool32,
shaderSharedFloat64AtomicMinMax: VkBool32,
shaderImageFloat32AtomicMinMax: VkBool32,
sparseImageFloat32AtomicMinMax: VkBool32,
}
struct VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT,
pNext: *mut void,
vertexAttributeInstanceRateDivisor: VkBool32,
vertexAttributeInstanceRateZeroDivisor: VkBool32,
}
struct VkQueueFamilyCheckpointPropertiesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV,
pNext: *mut void,
checkpointExecutionStageMask: VkPipelineStageFlags,
}
struct VkCheckpointDataNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV,
pNext: *mut void,
stage: VkPipelineStageFlagBits,
pCheckpointMarker: *mut void,
}
struct VkPhysicalDeviceDepthStencilResolveProperties {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES,
pNext: *mut void,
supportedDepthResolveModes: VkResolveModeFlags,
supportedStencilResolveModes: VkResolveModeFlags,
independentResolveNone: VkBool32,
independentResolve: VkBool32,
}
struct VkSubpassDescriptionDepthStencilResolve {
sType: VkStructureType = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE,
pNext: *const void,
depthResolveMode: VkResolveModeFlagBits,
stencilResolveMode: VkResolveModeFlagBits,
pDepthStencilResolveAttachment: *const VkAttachmentReference2,
}
struct VkImageViewASTCDecodeModeEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT,
pNext: *const void,
decodeMode: VkFormat,
}
struct VkPhysicalDeviceASTCDecodeFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT,
pNext: *mut void,
decodeModeSharedExponent: VkBool32,
}
struct VkPhysicalDeviceTransformFeedbackFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT,
pNext: *mut void,
transformFeedback: VkBool32,
geometryStreams: VkBool32,
}
struct VkPhysicalDeviceTransformFeedbackPropertiesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT,
pNext: *mut void,
maxTransformFeedbackStreams: uint32_t,
maxTransformFeedbackBuffers: uint32_t,
maxTransformFeedbackBufferSize: VkDeviceSize,
maxTransformFeedbackStreamDataSize: uint32_t,
maxTransformFeedbackBufferDataSize: uint32_t,
maxTransformFeedbackBufferDataStride: uint32_t,
transformFeedbackQueries: VkBool32,
transformFeedbackStreamsLinesTriangles: VkBool32,
transformFeedbackRasterizationStreamSelect: VkBool32,
transformFeedbackDraw: VkBool32,
}
struct VkPipelineRasterizationStateStreamCreateInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT,
pNext: *const void,
flags: VkPipelineRasterizationStateStreamCreateFlagsEXT,
rasterizationStream: uint32_t,
}
struct VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV,
pNext: *mut void,
representativeFragmentTest: VkBool32,
}
struct VkPipelineRepresentativeFragmentTestStateCreateInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV,
pNext: *const void,
representativeFragmentTestEnable: VkBool32,
}
struct VkPhysicalDeviceExclusiveScissorFeaturesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV,
pNext: *mut void,
exclusiveScissor: VkBool32,
}
struct VkPipelineViewportExclusiveScissorStateCreateInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV,
pNext: *const void,
exclusiveScissorCount: uint32_t,
pExclusiveScissors: *const [VkRect2D; dyn exclusiveScissorCount],
}
struct VkPhysicalDeviceCornerSampledImageFeaturesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV,
pNext: *mut void,
cornerSampledImage: VkBool32,
}
struct VkPhysicalDeviceComputeShaderDerivativesFeaturesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV,
pNext: *mut void,
computeDerivativeGroupQuads: VkBool32,
computeDerivativeGroupLinear: VkBool32,
}
struct VkPhysicalDeviceShaderImageFootprintFeaturesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV,
pNext: *mut void,
imageFootprint: VkBool32,
}
struct VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV,
pNext: *mut void,
dedicatedAllocationImageAliasing: VkBool32,
}
struct VkPhysicalDeviceCopyMemoryIndirectFeaturesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV,
pNext: *mut void,
indirectCopy: VkBool32,
}
struct VkPhysicalDeviceCopyMemoryIndirectPropertiesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV,
pNext: *mut void,
supportedQueues: VkQueueFlags,
}
struct VkPhysicalDeviceMemoryDecompressionFeaturesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV,
pNext: *mut void,
memoryDecompression: VkBool32,
}
struct VkPhysicalDeviceMemoryDecompressionPropertiesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV,
pNext: *mut void,
decompressionMethods: VkMemoryDecompressionMethodFlagsNV,
maxDecompressionIndirectCount: uint64_t,
}
struct VkShadingRatePaletteNV {
shadingRatePaletteEntryCount: uint32_t,
pShadingRatePaletteEntries: *const [VkShadingRatePaletteEntryNV; dyn shadingRatePaletteEntryCount],
}
struct VkPipelineViewportShadingRateImageStateCreateInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV,
pNext: *const void,
shadingRateImageEnable: VkBool32,
viewportCount: uint32_t,
pShadingRatePalettes: *const [VkShadingRatePaletteNV; dyn viewportCount],
}
struct VkPhysicalDeviceShadingRateImageFeaturesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV,
pNext: *mut void,
shadingRateImage: VkBool32,
shadingRateCoarseSampleOrder: VkBool32,
}
struct VkPhysicalDeviceShadingRateImagePropertiesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV,
pNext: *mut void,
shadingRateTexelSize: VkExtent2D,
shadingRatePaletteSize: uint32_t,
shadingRateMaxCoarseSamples: uint32_t,
}
struct VkPhysicalDeviceInvocationMaskFeaturesHUAWEI {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI,
pNext: *mut void,
invocationMask: VkBool32,
}
struct VkCoarseSampleLocationNV {
pixelX: uint32_t,
pixelY: uint32_t,
sample: uint32_t,
}
struct VkCoarseSampleOrderCustomNV {
shadingRate: VkShadingRatePaletteEntryNV,
sampleCount: uint32_t,
sampleLocationCount: uint32_t,
pSampleLocations: *const [VkCoarseSampleLocationNV; dyn sampleLocationCount],
}
struct VkPipelineViewportCoarseSampleOrderStateCreateInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV,
pNext: *const void,
sampleOrderType: VkCoarseSampleOrderTypeNV,
customSampleOrderCount: uint32_t,
pCustomSampleOrders: *const [VkCoarseSampleOrderCustomNV; dyn customSampleOrderCount],
}
struct VkPhysicalDeviceMeshShaderFeaturesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV,
pNext: *mut void,
taskShader: VkBool32,
meshShader: VkBool32,
}
struct VkPhysicalDeviceMeshShaderPropertiesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV,
pNext: *mut void,
maxDrawMeshTasksCount: uint32_t,
maxTaskWorkGroupInvocations: uint32_t,
maxTaskWorkGroupSize: [uint32_t; 3],
maxTaskTotalMemorySize: uint32_t,
maxTaskOutputCount: uint32_t,
maxMeshWorkGroupInvocations: uint32_t,
maxMeshWorkGroupSize: [uint32_t; 3],
maxMeshTotalMemorySize: uint32_t,
maxMeshOutputVertices: uint32_t,
maxMeshOutputPrimitives: uint32_t,
maxMeshMultiviewViewCount: uint32_t,
meshOutputPerVertexGranularity: uint32_t,
meshOutputPerPrimitiveGranularity: uint32_t,
}
struct VkDrawMeshTasksIndirectCommandNV {
taskCount: uint32_t,
firstTask: uint32_t,
}
struct VkPhysicalDeviceMeshShaderFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT,
pNext: *mut void,
taskShader: VkBool32,
meshShader: VkBool32,
multiviewMeshShader: VkBool32,
primitiveFragmentShadingRateMeshShader: VkBool32,
meshShaderQueries: VkBool32,
}
struct VkPhysicalDeviceMeshShaderPropertiesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT,
pNext: *mut void,
maxTaskWorkGroupTotalCount: uint32_t,
maxTaskWorkGroupCount: [uint32_t; 3],
maxTaskWorkGroupInvocations: uint32_t,
maxTaskWorkGroupSize: [uint32_t; 3],
maxTaskPayloadSize: uint32_t,
maxTaskSharedMemorySize: uint32_t,
maxTaskPayloadAndSharedMemorySize: uint32_t,
maxMeshWorkGroupTotalCount: uint32_t,
maxMeshWorkGroupCount: [uint32_t; 3],
maxMeshWorkGroupInvocations: uint32_t,
maxMeshWorkGroupSize: [uint32_t; 3],
maxMeshSharedMemorySize: uint32_t,
maxMeshPayloadAndSharedMemorySize: uint32_t,
maxMeshOutputMemorySize: uint32_t,
maxMeshPayloadAndOutputMemorySize: uint32_t,
maxMeshOutputComponents: uint32_t,
maxMeshOutputVertices: uint32_t,
maxMeshOutputPrimitives: uint32_t,
maxMeshOutputLayers: uint32_t,
maxMeshMultiviewViewCount: uint32_t,
meshOutputPerVertexGranularity: uint32_t,
meshOutputPerPrimitiveGranularity: uint32_t,
maxPreferredTaskWorkGroupInvocations: uint32_t,
maxPreferredMeshWorkGroupInvocations: uint32_t,
prefersLocalInvocationVertexOutput: VkBool32,
prefersLocalInvocationPrimitiveOutput: VkBool32,
prefersCompactVertexOutput: VkBool32,
prefersCompactPrimitiveOutput: VkBool32,
}
struct VkDrawMeshTasksIndirectCommandEXT {
groupCountX: uint32_t,
groupCountY: uint32_t,
groupCountZ: uint32_t,
}
struct VkRayTracingShaderGroupCreateInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV,
pNext: *const void,
type: VkRayTracingShaderGroupTypeKHR,
generalShader: uint32_t,
closestHitShader: uint32_t,
anyHitShader: uint32_t,
intersectionShader: uint32_t,
}
struct VkRayTracingShaderGroupCreateInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR,
pNext: *const void,
type: VkRayTracingShaderGroupTypeKHR,
generalShader: uint32_t,
closestHitShader: uint32_t,
anyHitShader: uint32_t,
intersectionShader: uint32_t,
pShaderGroupCaptureReplayHandle: *const void,
}
struct VkRayTracingPipelineCreateInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV,
pNext: *const void,
flags: VkPipelineCreateFlags,
stageCount: uint32_t,
pStages: *const [VkPipelineShaderStageCreateInfo; dyn stageCount],
groupCount: uint32_t,
pGroups: *const [VkRayTracingShaderGroupCreateInfoNV; dyn groupCount],
maxRecursionDepth: uint32_t,
layout: VkPipelineLayout,
basePipelineHandle: VkPipeline,
basePipelineIndex: int32_t,
}
struct VkRayTracingPipelineCreateInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR,
pNext: *const void,
flags: VkPipelineCreateFlags,
stageCount: uint32_t,
pStages: *const [VkPipelineShaderStageCreateInfo; dyn stageCount],
groupCount: uint32_t,
pGroups: *const [VkRayTracingShaderGroupCreateInfoKHR; dyn groupCount],
maxPipelineRayRecursionDepth: uint32_t,
pLibraryInfo: *const VkPipelineLibraryCreateInfoKHR,
pLibraryInterface: *const VkRayTracingPipelineInterfaceCreateInfoKHR,
pDynamicState: *const VkPipelineDynamicStateCreateInfo,
layout: VkPipelineLayout,
basePipelineHandle: VkPipeline,
basePipelineIndex: int32_t,
}
struct VkGeometryTrianglesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV,
pNext: *const void,
vertexData: VkBuffer,
vertexOffset: VkDeviceSize,
vertexCount: uint32_t,
vertexStride: VkDeviceSize,
vertexFormat: VkFormat,
indexData: VkBuffer,
indexOffset: VkDeviceSize,
indexCount: uint32_t,
indexType: VkIndexType,
transformData: VkBuffer,
transformOffset: VkDeviceSize,
}
struct VkGeometryAABBNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV,
pNext: *const void,
aabbData: VkBuffer,
numAABBs: uint32_t,
stride: uint32_t,
offset: VkDeviceSize,
}
struct VkGeometryDataNV {
triangles: VkGeometryTrianglesNV,
aabbs: VkGeometryAABBNV,
}
struct VkGeometryNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_GEOMETRY_NV,
pNext: *const void,
geometryType: VkGeometryTypeKHR,
geometry: VkGeometryDataNV,
flags: VkGeometryFlagsKHR,
}
struct VkAccelerationStructureInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV,
pNext: *const void,
type: VkAccelerationStructureTypeNV,
flags: VkBuildAccelerationStructureFlagsNV,
instanceCount: uint32_t,
geometryCount: uint32_t,
pGeometries: *const [VkGeometryNV; dyn geometryCount],
}
struct VkAccelerationStructureCreateInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV,
pNext: *const void,
compactedSize: VkDeviceSize,
info: VkAccelerationStructureInfoNV,
}
struct VkBindAccelerationStructureMemoryInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV,
pNext: *const void,
accelerationStructure: VkAccelerationStructureNV,
memory: VkDeviceMemory,
memoryOffset: VkDeviceSize,
deviceIndexCount: uint32_t,
pDeviceIndices: *const [uint32_t; dyn deviceIndexCount],
}
struct VkWriteDescriptorSetAccelerationStructureKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR,
pNext: *const void,
accelerationStructureCount: uint32_t,
pAccelerationStructures: *const [VkAccelerationStructureKHR; dyn accelerationStructureCount],
}
struct VkWriteDescriptorSetAccelerationStructureNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV,
pNext: *const void,
accelerationStructureCount: uint32_t,
pAccelerationStructures: *const [VkAccelerationStructureNV; dyn accelerationStructureCount],
}
struct VkAccelerationStructureMemoryRequirementsInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV,
pNext: *const void,
type: VkAccelerationStructureMemoryRequirementsTypeNV,
accelerationStructure: VkAccelerationStructureNV,
}
struct VkPhysicalDeviceAccelerationStructureFeaturesKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR,
pNext: *mut void,
accelerationStructure: VkBool32,
accelerationStructureCaptureReplay: VkBool32,
accelerationStructureIndirectBuild: VkBool32,
accelerationStructureHostCommands: VkBool32,
descriptorBindingAccelerationStructureUpdateAfterBind: VkBool32,
}
struct VkPhysicalDeviceRayTracingPipelineFeaturesKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR,
pNext: *mut void,
rayTracingPipeline: VkBool32,
rayTracingPipelineShaderGroupHandleCaptureReplay: VkBool32,
rayTracingPipelineShaderGroupHandleCaptureReplayMixed: VkBool32,
rayTracingPipelineTraceRaysIndirect: VkBool32,
rayTraversalPrimitiveCulling: VkBool32,
}
struct VkPhysicalDeviceRayQueryFeaturesKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR,
pNext: *mut void,
rayQuery: VkBool32,
}
struct VkPhysicalDeviceAccelerationStructurePropertiesKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR,
pNext: *mut void,
maxGeometryCount: uint64_t,
maxInstanceCount: uint64_t,
maxPrimitiveCount: uint64_t,
maxPerStageDescriptorAccelerationStructures: uint32_t,
maxPerStageDescriptorUpdateAfterBindAccelerationStructures: uint32_t,
maxDescriptorSetAccelerationStructures: uint32_t,
maxDescriptorSetUpdateAfterBindAccelerationStructures: uint32_t,
minAccelerationStructureScratchOffsetAlignment: uint32_t,
}
struct VkPhysicalDeviceRayTracingPipelinePropertiesKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR,
pNext: *mut void,
shaderGroupHandleSize: uint32_t,
maxRayRecursionDepth: uint32_t,
maxShaderGroupStride: uint32_t,
shaderGroupBaseAlignment: uint32_t,
shaderGroupHandleCaptureReplaySize: uint32_t,
maxRayDispatchInvocationCount: uint32_t,
shaderGroupHandleAlignment: uint32_t,
maxRayHitAttributeSize: uint32_t,
}
struct VkPhysicalDeviceRayTracingPropertiesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV,
pNext: *mut void,
shaderGroupHandleSize: uint32_t,
maxRecursionDepth: uint32_t,
maxShaderGroupStride: uint32_t,
shaderGroupBaseAlignment: uint32_t,
maxGeometryCount: uint64_t,
maxInstanceCount: uint64_t,
maxTriangleCount: uint64_t,
maxDescriptorSetAccelerationStructures: uint32_t,
}
struct VkStridedDeviceAddressRegionKHR {
deviceAddress: VkDeviceAddress,
stride: VkDeviceSize,
size: VkDeviceSize,
}
struct VkTraceRaysIndirectCommandKHR {
width: uint32_t,
height: uint32_t,
depth: uint32_t,
}
struct VkTraceRaysIndirectCommand2KHR {
raygenShaderRecordAddress: VkDeviceAddress,
raygenShaderRecordSize: VkDeviceSize,
missShaderBindingTableAddress: VkDeviceAddress,
missShaderBindingTableSize: VkDeviceSize,
missShaderBindingTableStride: VkDeviceSize,
hitShaderBindingTableAddress: VkDeviceAddress,
hitShaderBindingTableSize: VkDeviceSize,
hitShaderBindingTableStride: VkDeviceSize,
callableShaderBindingTableAddress: VkDeviceAddress,
callableShaderBindingTableSize: VkDeviceSize,
callableShaderBindingTableStride: VkDeviceSize,
width: uint32_t,
height: uint32_t,
depth: uint32_t,
}
struct VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR,
pNext: *mut void,
rayTracingMaintenance1: VkBool32,
rayTracingPipelineTraceRaysIndirect2: VkBool32,
}
struct VkDrmFormatModifierPropertiesListEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT,
pNext: *mut void,
drmFormatModifierCount: uint32_t,
pDrmFormatModifierProperties: *mut [VkDrmFormatModifierPropertiesEXT; dyn drmFormatModifierCount],
}
struct VkDrmFormatModifierPropertiesEXT {
drmFormatModifier: uint64_t,
drmFormatModifierPlaneCount: uint32_t,
drmFormatModifierTilingFeatures: VkFormatFeatureFlags,
}
struct VkPhysicalDeviceImageDrmFormatModifierInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT,
pNext: *const void,
drmFormatModifier: uint64_t,
sharingMode: VkSharingMode,
queueFamilyIndexCount: uint32_t,
pQueueFamilyIndices: *const [uint32_t; dyn queueFamilyIndexCount],
}
struct VkImageDrmFormatModifierListCreateInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT,
pNext: *const void,
drmFormatModifierCount: uint32_t,
pDrmFormatModifiers: *const [uint64_t; dyn drmFormatModifierCount],
}
struct VkImageDrmFormatModifierExplicitCreateInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT,
pNext: *const void,
drmFormatModifier: uint64_t,
drmFormatModifierPlaneCount: uint32_t,
pPlaneLayouts: *const [VkSubresourceLayout; dyn drmFormatModifierPlaneCount],
}
struct VkImageDrmFormatModifierPropertiesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT,
pNext: *mut void,
drmFormatModifier: uint64_t,
}
struct VkImageStencilUsageCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO,
pNext: *const void,
stencilUsage: VkImageUsageFlags,
}
struct VkDeviceMemoryOverallocationCreateInfoAMD {
sType: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD,
pNext: *const void,
overallocationBehavior: VkMemoryOverallocationBehaviorAMD,
}
struct VkPhysicalDeviceFragmentDensityMapFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT,
pNext: *mut void,
fragmentDensityMap: VkBool32,
fragmentDensityMapDynamic: VkBool32,
fragmentDensityMapNonSubsampledImages: VkBool32,
}
struct VkPhysicalDeviceFragmentDensityMap2FeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT,
pNext: *mut void,
fragmentDensityMapDeferred: VkBool32,
}
struct VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM,
pNext: *mut void,
fragmentDensityMapOffset: VkBool32,
}
struct VkPhysicalDeviceFragmentDensityMapPropertiesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT,
pNext: *mut void,
minFragmentDensityTexelSize: VkExtent2D,
maxFragmentDensityTexelSize: VkExtent2D,
fragmentDensityInvocations: VkBool32,
}
struct VkPhysicalDeviceFragmentDensityMap2PropertiesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT,
pNext: *mut void,
subsampledLoads: VkBool32,
subsampledCoarseReconstructionEarlyAccess: VkBool32,
maxSubsampledArrayLayers: uint32_t,
maxDescriptorSetSubsampledSamplers: uint32_t,
}
struct VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM,
pNext: *mut void,
fragmentDensityOffsetGranularity: VkExtent2D,
}
struct VkRenderPassFragmentDensityMapCreateInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT,
pNext: *const void,
fragmentDensityMapAttachment: VkAttachmentReference,
}
struct VkSubpassFragmentDensityMapOffsetEndInfoQCOM {
sType: VkStructureType = VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM,
pNext: *const void,
fragmentDensityOffsetCount: uint32_t,
pFragmentDensityOffsets: *const [VkOffset2D; dyn fragmentDensityOffsetCount],
}
struct VkPhysicalDeviceScalarBlockLayoutFeatures {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES,
pNext: *mut void,
scalarBlockLayout: VkBool32,
}
struct VkSurfaceProtectedCapabilitiesKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR,
pNext: *const void,
supportsProtected: VkBool32,
}
struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES,
pNext: *mut void,
uniformBufferStandardLayout: VkBool32,
}
struct VkPhysicalDeviceDepthClipEnableFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT,
pNext: *mut void,
depthClipEnable: VkBool32,
}
struct VkPipelineRasterizationDepthClipStateCreateInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT,
pNext: *const void,
flags: VkPipelineRasterizationDepthClipStateCreateFlagsEXT,
depthClipEnable: VkBool32,
}
struct VkPhysicalDeviceMemoryBudgetPropertiesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT,
pNext: *mut void,
heapBudget: [VkDeviceSize; VK_MAX_MEMORY_HEAPS],
heapUsage: [VkDeviceSize; VK_MAX_MEMORY_HEAPS],
}
struct VkPhysicalDeviceMemoryPriorityFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT,
pNext: *mut void,
memoryPriority: VkBool32,
}
struct VkMemoryPriorityAllocateInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT,
pNext: *const void,
priority: float,
}
struct VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT,
pNext: *mut void,
pageableDeviceLocalMemory: VkBool32,
}
struct VkPhysicalDeviceBufferDeviceAddressFeatures {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES,
pNext: *mut void,
bufferDeviceAddress: VkBool32,
bufferDeviceAddressCaptureReplay: VkBool32,
bufferDeviceAddressMultiDevice: VkBool32,
}
struct VkPhysicalDeviceBufferDeviceAddressFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT,
pNext: *mut void,
bufferDeviceAddress: VkBool32,
bufferDeviceAddressCaptureReplay: VkBool32,
bufferDeviceAddressMultiDevice: VkBool32,
}
struct VkBufferDeviceAddressInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO,
pNext: *const void,
buffer: VkBuffer,
}
struct VkBufferOpaqueCaptureAddressCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO,
pNext: *const void,
opaqueCaptureAddress: uint64_t,
}
struct VkBufferDeviceAddressCreateInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT,
pNext: *const void,
deviceAddress: VkDeviceAddress,
}
struct VkPhysicalDeviceImageViewImageFormatInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT,
pNext: *mut void,
imageViewType: VkImageViewType,
}
struct VkFilterCubicImageViewImageFormatPropertiesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT,
pNext: *mut void,
filterCubic: VkBool32,
filterCubicMinmax: VkBool32,
}
struct VkPhysicalDeviceImagelessFramebufferFeatures {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES,
pNext: *mut void,
imagelessFramebuffer: VkBool32,
}
struct VkFramebufferAttachmentsCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO,
pNext: *const void,
attachmentImageInfoCount: uint32_t,
pAttachmentImageInfos: *const [VkFramebufferAttachmentImageInfo; dyn attachmentImageInfoCount],
}
struct VkFramebufferAttachmentImageInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO,
pNext: *const void,
flags: VkImageCreateFlags,
usage: VkImageUsageFlags,
width: uint32_t,
height: uint32_t,
layerCount: uint32_t,
viewFormatCount: uint32_t,
pViewFormats: *const [VkFormat; dyn viewFormatCount],
}
struct VkRenderPassAttachmentBeginInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO,
pNext: *const void,
attachmentCount: uint32_t,
pAttachments: *const [VkImageView; dyn attachmentCount],
}
struct VkPhysicalDeviceTextureCompressionASTCHDRFeatures {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES,
pNext: *mut void,
textureCompressionASTC_HDR: VkBool32,
}
struct VkPhysicalDeviceCooperativeMatrixFeaturesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV,
pNext: *mut void,
cooperativeMatrix: VkBool32,
cooperativeMatrixRobustBufferAccess: VkBool32,
}
struct VkPhysicalDeviceCooperativeMatrixPropertiesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV,
pNext: *mut void,
cooperativeMatrixSupportedStages: VkShaderStageFlags,
}
struct VkCooperativeMatrixPropertiesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV,
pNext: *mut void,
MSize: uint32_t,
NSize: uint32_t,
KSize: uint32_t,
AType: VkComponentTypeNV,
BType: VkComponentTypeNV,
CType: VkComponentTypeNV,
DType: VkComponentTypeNV,
scope: VkScopeNV,
}
struct VkPhysicalDeviceYcbcrImageArraysFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT,
pNext: *mut void,
ycbcrImageArrays: VkBool32,
}
struct VkImageViewHandleInfoNVX {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX,
pNext: *const void,
imageView: VkImageView,
descriptorType: VkDescriptorType,
sampler: VkSampler,
}
struct VkImageViewAddressPropertiesNVX {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX,
pNext: *mut void,
deviceAddress: VkDeviceAddress,
size: VkDeviceSize,
}
struct VkPresentFrameTokenGGP {
sType: VkStructureType = VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP,
pNext: *const void,
frameToken: GgpFrameToken,
}
struct VkPipelineCreationFeedback {
flags: VkPipelineCreationFeedbackFlags,
duration: uint64_t,
}
struct VkPipelineCreationFeedbackCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO,
pNext: *const void,
pPipelineCreationFeedback: *mut VkPipelineCreationFeedback,
pipelineStageCreationFeedbackCount: uint32_t,
pPipelineStageCreationFeedbacks: *mut [VkPipelineCreationFeedback; dyn pipelineStageCreationFeedbackCount],
}
struct VkSurfaceFullScreenExclusiveInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT,
pNext: *mut void,
fullScreenExclusive: VkFullScreenExclusiveEXT,
}
struct VkSurfaceFullScreenExclusiveWin32InfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT,
pNext: *const void,
hmonitor: HMONITOR,
}
struct VkSurfaceCapabilitiesFullScreenExclusiveEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT,
pNext: *mut void,
fullScreenExclusiveSupported: VkBool32,
}
struct VkPhysicalDevicePresentBarrierFeaturesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV,
pNext: *mut void,
presentBarrier: VkBool32,
}
struct VkSurfaceCapabilitiesPresentBarrierNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV,
pNext: *mut void,
presentBarrierSupported: VkBool32,
}
struct VkSwapchainPresentBarrierCreateInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV,
pNext: *mut void,
presentBarrierEnable: VkBool32,
}
struct VkPhysicalDevicePerformanceQueryFeaturesKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR,
pNext: *mut void,
performanceCounterQueryPools: VkBool32,
performanceCounterMultipleQueryPools: VkBool32,
}
struct VkPhysicalDevicePerformanceQueryPropertiesKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR,
pNext: *mut void,
allowCommandBufferQueryCopies: VkBool32,
}
struct VkPerformanceCounterKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR,
pNext: *mut void,
unit: VkPerformanceCounterUnitKHR,
scope: VkPerformanceCounterScopeKHR,
storage: VkPerformanceCounterStorageKHR,
uuid: [uint8_t; VK_UUID_SIZE],
}
struct VkPerformanceCounterDescriptionKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR,
pNext: *mut void,
flags: VkPerformanceCounterDescriptionFlagsKHR,
name: [char; VK_MAX_DESCRIPTION_SIZE],
category: [char; VK_MAX_DESCRIPTION_SIZE],
description: [char; VK_MAX_DESCRIPTION_SIZE],
}
struct VkQueryPoolPerformanceCreateInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR,
pNext: *const void,
queueFamilyIndex: uint32_t,
counterIndexCount: uint32_t,
pCounterIndices: *const [uint32_t; dyn counterIndexCount],
}
struct VkAcquireProfilingLockInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR,
pNext: *const void,
flags: VkAcquireProfilingLockFlagsKHR,
timeout: uint64_t,
}
struct VkPerformanceQuerySubmitInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR,
pNext: *const void,
counterPassIndex: uint32_t,
}
struct VkPerformanceQueryReservationInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_RESERVATION_INFO_KHR,
pNext: *const void,
maxPerformanceQueriesPerPool: uint32_t,
}
struct VkHeadlessSurfaceCreateInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT,
pNext: *const void,
flags: VkHeadlessSurfaceCreateFlagsEXT,
}
struct VkPhysicalDeviceCoverageReductionModeFeaturesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV,
pNext: *mut void,
coverageReductionMode: VkBool32,
}
struct VkPipelineCoverageReductionStateCreateInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV,
pNext: *const void,
flags: VkPipelineCoverageReductionStateCreateFlagsNV,
coverageReductionMode: VkCoverageReductionModeNV,
}
struct VkFramebufferMixedSamplesCombinationNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV,
pNext: *mut void,
coverageReductionMode: VkCoverageReductionModeNV,
rasterizationSamples: VkSampleCountFlagBits,
depthStencilSamples: VkSampleCountFlags,
colorSamples: VkSampleCountFlags,
}
struct VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL,
pNext: *mut void,
shaderIntegerFunctions2: VkBool32,
}
struct VkPerformanceValueINTEL {
type: VkPerformanceValueTypeINTEL,
data: VkPerformanceValueDataINTEL,
}
struct VkInitializePerformanceApiInfoINTEL {
sType: VkStructureType = VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL,
pNext: *const void,
pUserData: *mut void,
}
struct VkQueryPoolPerformanceQueryCreateInfoINTEL {
sType: VkStructureType = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL,
pNext: *const void,
performanceCountersSampling: VkQueryPoolSamplingModeINTEL,
}
struct VkPerformanceMarkerInfoINTEL {
sType: VkStructureType = VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL,
pNext: *const void,
marker: uint64_t,
}
struct VkPerformanceStreamMarkerInfoINTEL {
sType: VkStructureType = VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL,
pNext: *const void,
marker: uint32_t,
}
struct VkPerformanceOverrideInfoINTEL {
sType: VkStructureType = VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL,
pNext: *const void,
type: VkPerformanceOverrideTypeINTEL,
enable: VkBool32,
parameter: uint64_t,
}
struct VkPerformanceConfigurationAcquireInfoINTEL {
sType: VkStructureType = VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL,
pNext: *const void,
type: VkPerformanceConfigurationTypeINTEL,
}
struct VkPhysicalDeviceShaderClockFeaturesKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR,
pNext: *mut void,
shaderSubgroupClock: VkBool32,
shaderDeviceClock: VkBool32,
}
struct VkPhysicalDeviceIndexTypeUint8FeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT,
pNext: *mut void,
indexTypeUint8: VkBool32,
}
struct VkPhysicalDeviceShaderSMBuiltinsPropertiesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV,
pNext: *mut void,
shaderSMCount: uint32_t,
shaderWarpsPerSM: uint32_t,
}
struct VkPhysicalDeviceShaderSMBuiltinsFeaturesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV,
pNext: *mut void,
shaderSMBuiltins: VkBool32,
}
struct VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT,
pNext: *mut void,
fragmentShaderSampleInterlock: VkBool32,
fragmentShaderPixelInterlock: VkBool32,
fragmentShaderShadingRateInterlock: VkBool32,
}
struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES,
pNext: *mut void,
separateDepthStencilLayouts: VkBool32,
}
struct VkAttachmentReferenceStencilLayout {
sType: VkStructureType = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT,
pNext: *mut void,
stencilLayout: VkImageLayout,
}
struct VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT,
pNext: *mut void,
primitiveTopologyListRestart: VkBool32,
primitiveTopologyPatchListRestart: VkBool32,
}
struct VkAttachmentDescriptionStencilLayout {
sType: VkStructureType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT,
pNext: *mut void,
stencilInitialLayout: VkImageLayout,
stencilFinalLayout: VkImageLayout,
}
struct VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR,
pNext: *mut void,
pipelineExecutableInfo: VkBool32,
}
struct VkPipelineInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR,
pNext: *const void,
pipeline: VkPipeline,
}
struct VkPipelineExecutablePropertiesKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR,
pNext: *mut void,
stages: VkShaderStageFlags,
name: [char; VK_MAX_DESCRIPTION_SIZE],
description: [char; VK_MAX_DESCRIPTION_SIZE],
subgroupSize: uint32_t,
}
struct VkPipelineExecutableInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR,
pNext: *const void,
pipeline: VkPipeline,
executableIndex: uint32_t,
}
struct VkPipelineExecutableStatisticKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR,
pNext: *mut void,
name: [char; VK_MAX_DESCRIPTION_SIZE],
description: [char; VK_MAX_DESCRIPTION_SIZE],
format: VkPipelineExecutableStatisticFormatKHR,
value: VkPipelineExecutableStatisticValueKHR,
}
struct VkPipelineExecutableInternalRepresentationKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR,
pNext: *mut void,
name: [char; VK_MAX_DESCRIPTION_SIZE],
description: [char; VK_MAX_DESCRIPTION_SIZE],
isText: VkBool32,
dataSize: size_t,
pData: *mut [void; dyn dataSize],
}
struct VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES,
pNext: *mut void,
shaderDemoteToHelperInvocation: VkBool32,
}
struct VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT,
pNext: *mut void,
texelBufferAlignment: VkBool32,
}
struct VkPhysicalDeviceTexelBufferAlignmentProperties {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES,
pNext: *mut void,
storageTexelBufferOffsetAlignmentBytes: VkDeviceSize,
storageTexelBufferOffsetSingleTexelAlignment: VkBool32,
uniformTexelBufferOffsetAlignmentBytes: VkDeviceSize,
uniformTexelBufferOffsetSingleTexelAlignment: VkBool32,
}
struct VkPhysicalDeviceSubgroupSizeControlFeatures {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES,
pNext: *mut void,
subgroupSizeControl: VkBool32,
computeFullSubgroups: VkBool32,
}
struct VkPhysicalDeviceSubgroupSizeControlProperties {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES,
pNext: *mut void,
minSubgroupSize: uint32_t,
maxSubgroupSize: uint32_t,
maxComputeWorkgroupSubgroups: uint32_t,
requiredSubgroupSizeStages: VkShaderStageFlags,
}
struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO,
pNext: *mut void,
requiredSubgroupSize: uint32_t,
}
struct VkSubpassShadingPipelineCreateInfoHUAWEI {
sType: VkStructureType = VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI,
pNext: *mut void,
renderPass: VkRenderPass,
subpass: uint32_t,
}
struct VkPhysicalDeviceSubpassShadingPropertiesHUAWEI {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI,
pNext: *mut void,
maxSubpassShadingWorkgroupSizeAspectRatio: uint32_t,
}
struct VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI,
pNext: *mut void,
maxWorkGroupCount: [uint32_t; 3],
maxWorkGroupSize: [uint32_t; 3],
maxOutputClusterCount: uint32_t,
indirectBufferOffsetAlignment: VkDeviceSize,
}
struct VkMemoryOpaqueCaptureAddressAllocateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO,
pNext: *const void,
opaqueCaptureAddress: uint64_t,
}
struct VkDeviceMemoryOpaqueCaptureAddressInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO,
pNext: *const void,
memory: VkDeviceMemory,
}
struct VkPhysicalDeviceLineRasterizationFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT,
pNext: *mut void,
rectangularLines: VkBool32,
bresenhamLines: VkBool32,
smoothLines: VkBool32,
stippledRectangularLines: VkBool32,
stippledBresenhamLines: VkBool32,
stippledSmoothLines: VkBool32,
}
struct VkPhysicalDeviceLineRasterizationPropertiesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT,
pNext: *mut void,
lineSubPixelPrecisionBits: uint32_t,
}
struct VkPipelineRasterizationLineStateCreateInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT,
pNext: *const void,
lineRasterizationMode: VkLineRasterizationModeEXT,
stippledLineEnable: VkBool32,
lineStippleFactor: uint32_t,
lineStipplePattern: uint16_t,
}
struct VkPhysicalDevicePipelineCreationCacheControlFeatures {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES,
pNext: *mut void,
pipelineCreationCacheControl: VkBool32,
}
struct VkPhysicalDeviceVulkan11Features {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES,
pNext: *mut void,
storageBuffer16BitAccess: VkBool32,
uniformAndStorageBuffer16BitAccess: VkBool32,
storagePushConstant16: VkBool32,
storageInputOutput16: VkBool32,
multiview: VkBool32,
multiviewGeometryShader: VkBool32,
multiviewTessellationShader: VkBool32,
variablePointersStorageBuffer: VkBool32,
variablePointers: VkBool32,
protectedMemory: VkBool32,
samplerYcbcrConversion: VkBool32,
shaderDrawParameters: VkBool32,
}
struct VkPhysicalDeviceVulkan11Properties {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES,
pNext: *mut void,
deviceUUID: [uint8_t; VK_UUID_SIZE],
driverUUID: [uint8_t; VK_UUID_SIZE],
deviceLUID: [uint8_t; VK_LUID_SIZE],
deviceNodeMask: uint32_t,
deviceLUIDValid: VkBool32,
subgroupSize: uint32_t,
subgroupSupportedStages: VkShaderStageFlags,
subgroupSupportedOperations: VkSubgroupFeatureFlags,
subgroupQuadOperationsInAllStages: VkBool32,
pointClippingBehavior: VkPointClippingBehavior,
maxMultiviewViewCount: uint32_t,
maxMultiviewInstanceIndex: uint32_t,
protectedNoFault: VkBool32,
maxPerSetDescriptors: uint32_t,
maxMemoryAllocationSize: VkDeviceSize,
}
struct VkPhysicalDeviceVulkan12Features {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES,
pNext: *mut void,
samplerMirrorClampToEdge: VkBool32,
drawIndirectCount: VkBool32,
storageBuffer8BitAccess: VkBool32,
uniformAndStorageBuffer8BitAccess: VkBool32,
storagePushConstant8: VkBool32,
shaderBufferInt64Atomics: VkBool32,
shaderSharedInt64Atomics: VkBool32,
shaderFloat16: VkBool32,
shaderInt8: VkBool32,
descriptorIndexing: VkBool32,
shaderInputAttachmentArrayDynamicIndexing: VkBool32,
shaderUniformTexelBufferArrayDynamicIndexing: VkBool32,
shaderStorageTexelBufferArrayDynamicIndexing: VkBool32,
shaderUniformBufferArrayNonUniformIndexing: VkBool32,
shaderSampledImageArrayNonUniformIndexing: VkBool32,
shaderStorageBufferArrayNonUniformIndexing: VkBool32,
shaderStorageImageArrayNonUniformIndexing: VkBool32,
shaderInputAttachmentArrayNonUniformIndexing: VkBool32,
shaderUniformTexelBufferArrayNonUniformIndexing: VkBool32,
shaderStorageTexelBufferArrayNonUniformIndexing: VkBool32,
descriptorBindingUniformBufferUpdateAfterBind: VkBool32,
descriptorBindingSampledImageUpdateAfterBind: VkBool32,
descriptorBindingStorageImageUpdateAfterBind: VkBool32,
descriptorBindingStorageBufferUpdateAfterBind: VkBool32,
descriptorBindingUniformTexelBufferUpdateAfterBind: VkBool32,
descriptorBindingStorageTexelBufferUpdateAfterBind: VkBool32,
descriptorBindingUpdateUnusedWhilePending: VkBool32,
descriptorBindingPartiallyBound: VkBool32,
descriptorBindingVariableDescriptorCount: VkBool32,
runtimeDescriptorArray: VkBool32,
samplerFilterMinmax: VkBool32,
scalarBlockLayout: VkBool32,
imagelessFramebuffer: VkBool32,
uniformBufferStandardLayout: VkBool32,
shaderSubgroupExtendedTypes: VkBool32,
separateDepthStencilLayouts: VkBool32,
hostQueryReset: VkBool32,
timelineSemaphore: VkBool32,
bufferDeviceAddress: VkBool32,
bufferDeviceAddressCaptureReplay: VkBool32,
bufferDeviceAddressMultiDevice: VkBool32,
vulkanMemoryModel: VkBool32,
vulkanMemoryModelDeviceScope: VkBool32,
vulkanMemoryModelAvailabilityVisibilityChains: VkBool32,
shaderOutputViewportIndex: VkBool32,
shaderOutputLayer: VkBool32,
subgroupBroadcastDynamicId: VkBool32,
}
struct VkPhysicalDeviceVulkan12Properties {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES,
pNext: *mut void,
driverID: VkDriverId,
driverName: [char; VK_MAX_DRIVER_NAME_SIZE],
driverInfo: [char; VK_MAX_DRIVER_INFO_SIZE],
conformanceVersion: VkConformanceVersion,
denormBehaviorIndependence: VkShaderFloatControlsIndependence,
roundingModeIndependence: VkShaderFloatControlsIndependence,
shaderSignedZeroInfNanPreserveFloat16: VkBool32,
shaderSignedZeroInfNanPreserveFloat32: VkBool32,
shaderSignedZeroInfNanPreserveFloat64: VkBool32,
shaderDenormPreserveFloat16: VkBool32,
shaderDenormPreserveFloat32: VkBool32,
shaderDenormPreserveFloat64: VkBool32,
shaderDenormFlushToZeroFloat16: VkBool32,
shaderDenormFlushToZeroFloat32: VkBool32,
shaderDenormFlushToZeroFloat64: VkBool32,
shaderRoundingModeRTEFloat16: VkBool32,
shaderRoundingModeRTEFloat32: VkBool32,
shaderRoundingModeRTEFloat64: VkBool32,
shaderRoundingModeRTZFloat16: VkBool32,
shaderRoundingModeRTZFloat32: VkBool32,
shaderRoundingModeRTZFloat64: VkBool32,
maxUpdateAfterBindDescriptorsInAllPools: uint32_t,
shaderUniformBufferArrayNonUniformIndexingNative: VkBool32,
shaderSampledImageArrayNonUniformIndexingNative: VkBool32,
shaderStorageBufferArrayNonUniformIndexingNative: VkBool32,
shaderStorageImageArrayNonUniformIndexingNative: VkBool32,
shaderInputAttachmentArrayNonUniformIndexingNative: VkBool32,
robustBufferAccessUpdateAfterBind: VkBool32,
quadDivergentImplicitLod: VkBool32,
maxPerStageDescriptorUpdateAfterBindSamplers: uint32_t,
maxPerStageDescriptorUpdateAfterBindUniformBuffers: uint32_t,
maxPerStageDescriptorUpdateAfterBindStorageBuffers: uint32_t,
maxPerStageDescriptorUpdateAfterBindSampledImages: uint32_t,
maxPerStageDescriptorUpdateAfterBindStorageImages: uint32_t,
maxPerStageDescriptorUpdateAfterBindInputAttachments: uint32_t,
maxPerStageUpdateAfterBindResources: uint32_t,
maxDescriptorSetUpdateAfterBindSamplers: uint32_t,
maxDescriptorSetUpdateAfterBindUniformBuffers: uint32_t,
maxDescriptorSetUpdateAfterBindUniformBuffersDynamic: uint32_t,
maxDescriptorSetUpdateAfterBindStorageBuffers: uint32_t,
maxDescriptorSetUpdateAfterBindStorageBuffersDynamic: uint32_t,
maxDescriptorSetUpdateAfterBindSampledImages: uint32_t,
maxDescriptorSetUpdateAfterBindStorageImages: uint32_t,
maxDescriptorSetUpdateAfterBindInputAttachments: uint32_t,
supportedDepthResolveModes: VkResolveModeFlags,
supportedStencilResolveModes: VkResolveModeFlags,
independentResolveNone: VkBool32,
independentResolve: VkBool32,
filterMinmaxSingleComponentFormats: VkBool32,
filterMinmaxImageComponentMapping: VkBool32,
maxTimelineSemaphoreValueDifference: uint64_t,
framebufferIntegerColorSampleCounts: VkSampleCountFlags,
}
struct VkPhysicalDeviceVulkan13Features {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES,
pNext: *mut void,
robustImageAccess: VkBool32,
inlineUniformBlock: VkBool32,
descriptorBindingInlineUniformBlockUpdateAfterBind: VkBool32,
pipelineCreationCacheControl: VkBool32,
privateData: VkBool32,
shaderDemoteToHelperInvocation: VkBool32,
shaderTerminateInvocation: VkBool32,
subgroupSizeControl: VkBool32,
computeFullSubgroups: VkBool32,
synchronization2: VkBool32,
textureCompressionASTC_HDR: VkBool32,
shaderZeroInitializeWorkgroupMemory: VkBool32,
dynamicRendering: VkBool32,
shaderIntegerDotProduct: VkBool32,
maintenance4: VkBool32,
}
struct VkPhysicalDeviceVulkan13Properties {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES,
pNext: *mut void,
minSubgroupSize: uint32_t,
maxSubgroupSize: uint32_t,
maxComputeWorkgroupSubgroups: uint32_t,
requiredSubgroupSizeStages: VkShaderStageFlags,
maxInlineUniformBlockSize: uint32_t,
maxPerStageDescriptorInlineUniformBlocks: uint32_t,
maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks: uint32_t,
maxDescriptorSetInlineUniformBlocks: uint32_t,
maxDescriptorSetUpdateAfterBindInlineUniformBlocks: uint32_t,
maxInlineUniformTotalSize: uint32_t,
integerDotProduct8BitUnsignedAccelerated: VkBool32,
integerDotProduct8BitSignedAccelerated: VkBool32,
integerDotProduct8BitMixedSignednessAccelerated: VkBool32,
integerDotProduct4x8BitPackedUnsignedAccelerated: VkBool32,
integerDotProduct4x8BitPackedSignedAccelerated: VkBool32,
integerDotProduct4x8BitPackedMixedSignednessAccelerated: VkBool32,
integerDotProduct16BitUnsignedAccelerated: VkBool32,
integerDotProduct16BitSignedAccelerated: VkBool32,
integerDotProduct16BitMixedSignednessAccelerated: VkBool32,
integerDotProduct32BitUnsignedAccelerated: VkBool32,
integerDotProduct32BitSignedAccelerated: VkBool32,
integerDotProduct32BitMixedSignednessAccelerated: VkBool32,
integerDotProduct64BitUnsignedAccelerated: VkBool32,
integerDotProduct64BitSignedAccelerated: VkBool32,
integerDotProduct64BitMixedSignednessAccelerated: VkBool32,
integerDotProductAccumulatingSaturating8BitUnsignedAccelerated: VkBool32,
integerDotProductAccumulatingSaturating8BitSignedAccelerated: VkBool32,
integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated: VkBool32,
integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated: VkBool32,
integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated: VkBool32,
integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated: VkBool32,
integerDotProductAccumulatingSaturating16BitUnsignedAccelerated: VkBool32,
integerDotProductAccumulatingSaturating16BitSignedAccelerated: VkBool32,
integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated: VkBool32,
integerDotProductAccumulatingSaturating32BitUnsignedAccelerated: VkBool32,
integerDotProductAccumulatingSaturating32BitSignedAccelerated: VkBool32,
integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated: VkBool32,
integerDotProductAccumulatingSaturating64BitUnsignedAccelerated: VkBool32,
integerDotProductAccumulatingSaturating64BitSignedAccelerated: VkBool32,
integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated: VkBool32,
storageTexelBufferOffsetAlignmentBytes: VkDeviceSize,
storageTexelBufferOffsetSingleTexelAlignment: VkBool32,
uniformTexelBufferOffsetAlignmentBytes: VkDeviceSize,
uniformTexelBufferOffsetSingleTexelAlignment: VkBool32,
maxBufferSize: VkDeviceSize,
}
struct VkPipelineCompilerControlCreateInfoAMD {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD,
pNext: *const void,
compilerControlFlags: VkPipelineCompilerControlFlagsAMD,
}
struct VkPhysicalDeviceCoherentMemoryFeaturesAMD {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD,
pNext: *mut void,
deviceCoherentMemory: VkBool32,
}
struct VkFaultData {
sType: VkStructureType = VK_STRUCTURE_TYPE_FAULT_DATA,
pNext: *mut void,
faultLevel: VkFaultLevel,
faultType: VkFaultType,
}
struct VkFaultCallbackInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_FAULT_CALLBACK_INFO,
pNext: *const void,
faultCount: uint32_t,
pFaults: *mut [VkFaultData; dyn faultCount],
pfnFaultCallback: PFN_vkFaultCallbackFunction,
}
struct VkPhysicalDeviceToolProperties {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES,
pNext: *mut void,
name: [char; VK_MAX_EXTENSION_NAME_SIZE],
version: [char; VK_MAX_EXTENSION_NAME_SIZE],
purposes: VkToolPurposeFlags,
description: [char; VK_MAX_DESCRIPTION_SIZE],
layer: [char; VK_MAX_EXTENSION_NAME_SIZE],
}
struct VkSamplerCustomBorderColorCreateInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT,
pNext: *const void,
customBorderColor: VkClearColorValue,
format: VkFormat,
}
struct VkPhysicalDeviceCustomBorderColorPropertiesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT,
pNext: *mut void,
maxCustomBorderColorSamplers: uint32_t,
}
struct VkPhysicalDeviceCustomBorderColorFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT,
pNext: *mut void,
customBorderColors: VkBool32,
customBorderColorWithoutFormat: VkBool32,
}
struct VkSamplerBorderColorComponentMappingCreateInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT,
pNext: *const void,
components: VkComponentMapping,
srgb: VkBool32,
}
struct VkPhysicalDeviceBorderColorSwizzleFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT,
pNext: *mut void,
borderColorSwizzle: VkBool32,
borderColorSwizzleFromImage: VkBool32,
}
struct VkAccelerationStructureGeometryTrianglesDataKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR,
pNext: *const void,
vertexFormat: VkFormat,
vertexData: VkDeviceOrHostAddressConstKHR,
vertexStride: VkDeviceSize,
maxVertex: uint32_t,
indexType: VkIndexType,
indexData: VkDeviceOrHostAddressConstKHR,
transformData: VkDeviceOrHostAddressConstKHR,
}
struct VkAccelerationStructureGeometryAabbsDataKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR,
pNext: *const void,
data: VkDeviceOrHostAddressConstKHR,
stride: VkDeviceSize,
}
struct VkAccelerationStructureGeometryInstancesDataKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR,
pNext: *const void,
arrayOfPointers: VkBool32,
data: VkDeviceOrHostAddressConstKHR,
}
struct VkAccelerationStructureGeometryKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR,
pNext: *const void,
geometryType: VkGeometryTypeKHR,
geometry: VkAccelerationStructureGeometryDataKHR,
flags: VkGeometryFlagsKHR,
}
struct VkAccelerationStructureBuildGeometryInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR,
pNext: *const void,
type: VkAccelerationStructureTypeKHR,
flags: VkBuildAccelerationStructureFlagsKHR,
mode: VkBuildAccelerationStructureModeKHR,
srcAccelerationStructure: VkAccelerationStructureKHR,
dstAccelerationStructure: VkAccelerationStructureKHR,
geometryCount: uint32_t,
pGeometries: *const [VkAccelerationStructureGeometryKHR; dyn geometryCount],
ppGeometries: *const [*const VkAccelerationStructureGeometryKHR; dyn geometryCount,1],
scratchData: VkDeviceOrHostAddressKHR,
}
struct VkAccelerationStructureBuildRangeInfoKHR {
primitiveCount: uint32_t,
primitiveOffset: uint32_t,
firstVertex: uint32_t,
transformOffset: uint32_t,
}
struct VkAccelerationStructureCreateInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR,
pNext: *const void,
createFlags: VkAccelerationStructureCreateFlagsKHR,
buffer: VkBuffer,
offset: VkDeviceSize,
size: VkDeviceSize,
type: VkAccelerationStructureTypeKHR,
deviceAddress: VkDeviceAddress,
}
struct VkAabbPositionsKHR {
minX: float,
minY: float,
minZ: float,
maxX: float,
maxY: float,
maxZ: float,
}
struct VkTransformMatrixKHR {
matrix: [[float; 4]; 3],
}
struct VkAccelerationStructureInstanceKHR {
transform: VkTransformMatrixKHR,
#[bitfield(24)] instanceCustomIndex: uint32_t,
#[bitfield(8)] mask: uint32_t,
#[bitfield(24)] instanceShaderBindingTableRecordOffset: uint32_t,
#[bitfield(8)] flags: VkGeometryInstanceFlagsKHR,
accelerationStructureReference: uint64_t,
}
struct VkAccelerationStructureDeviceAddressInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR,
pNext: *const void,
accelerationStructure: VkAccelerationStructureKHR,
}
struct VkAccelerationStructureVersionInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR,
pNext: *const void,
pVersionData: *const [uint8_t; dyn 2*VK_UUID_SIZE],
}
struct VkCopyAccelerationStructureInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR,
pNext: *const void,
src: VkAccelerationStructureKHR,
dst: VkAccelerationStructureKHR,
mode: VkCopyAccelerationStructureModeKHR,
}
struct VkCopyAccelerationStructureToMemoryInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR,
pNext: *const void,
src: VkAccelerationStructureKHR,
dst: VkDeviceOrHostAddressKHR,
mode: VkCopyAccelerationStructureModeKHR,
}
struct VkCopyMemoryToAccelerationStructureInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR,
pNext: *const void,
src: VkDeviceOrHostAddressConstKHR,
dst: VkAccelerationStructureKHR,
mode: VkCopyAccelerationStructureModeKHR,
}
struct VkRayTracingPipelineInterfaceCreateInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR,
pNext: *const void,
maxPipelineRayPayloadSize: uint32_t,
maxPipelineRayHitAttributeSize: uint32_t,
}
struct VkPipelineLibraryCreateInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR,
pNext: *const void,
libraryCount: uint32_t,
pLibraries: *const [VkPipeline; dyn libraryCount],
}
struct VkRefreshObjectKHR {
objectType: VkObjectType,
objectHandle: uint64_t,
flags: VkRefreshObjectFlagsKHR,
}
struct VkRefreshObjectListKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_REFRESH_OBJECT_LIST_KHR,
pNext: *const void,
objectCount: uint32_t,
pObjects: *const [VkRefreshObjectKHR; dyn objectCount],
}
struct VkPhysicalDeviceExtendedDynamicStateFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT,
pNext: *mut void,
extendedDynamicState: VkBool32,
}
struct VkPhysicalDeviceExtendedDynamicState2FeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT,
pNext: *mut void,
extendedDynamicState2: VkBool32,
extendedDynamicState2LogicOp: VkBool32,
extendedDynamicState2PatchControlPoints: VkBool32,
}
struct VkPhysicalDeviceExtendedDynamicState3FeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT,
pNext: *mut void,
extendedDynamicState3TessellationDomainOrigin: VkBool32,
extendedDynamicState3DepthClampEnable: VkBool32,
extendedDynamicState3PolygonMode: VkBool32,
extendedDynamicState3RasterizationSamples: VkBool32,
extendedDynamicState3SampleMask: VkBool32,
extendedDynamicState3AlphaToCoverageEnable: VkBool32,
extendedDynamicState3AlphaToOneEnable: VkBool32,
extendedDynamicState3LogicOpEnable: VkBool32,
extendedDynamicState3ColorBlendEnable: VkBool32,
extendedDynamicState3ColorBlendEquation: VkBool32,
extendedDynamicState3ColorWriteMask: VkBool32,
extendedDynamicState3RasterizationStream: VkBool32,
extendedDynamicState3ConservativeRasterizationMode: VkBool32,
extendedDynamicState3ExtraPrimitiveOverestimationSize: VkBool32,
extendedDynamicState3DepthClipEnable: VkBool32,
extendedDynamicState3SampleLocationsEnable: VkBool32,
extendedDynamicState3ColorBlendAdvanced: VkBool32,
extendedDynamicState3ProvokingVertexMode: VkBool32,
extendedDynamicState3LineRasterizationMode: VkBool32,
extendedDynamicState3LineStippleEnable: VkBool32,
extendedDynamicState3DepthClipNegativeOneToOne: VkBool32,
extendedDynamicState3ViewportWScalingEnable: VkBool32,
extendedDynamicState3ViewportSwizzle: VkBool32,
extendedDynamicState3CoverageToColorEnable: VkBool32,
extendedDynamicState3CoverageToColorLocation: VkBool32,
extendedDynamicState3CoverageModulationMode: VkBool32,
extendedDynamicState3CoverageModulationTableEnable: VkBool32,
extendedDynamicState3CoverageModulationTable: VkBool32,
extendedDynamicState3CoverageReductionMode: VkBool32,
extendedDynamicState3RepresentativeFragmentTestEnable: VkBool32,
extendedDynamicState3ShadingRateImageEnable: VkBool32,
}
struct VkPhysicalDeviceExtendedDynamicState3PropertiesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT,
pNext: *mut void,
dynamicPrimitiveTopologyUnrestricted: VkBool32,
}
struct VkColorBlendEquationEXT {
srcColorBlendFactor: VkBlendFactor,
dstColorBlendFactor: VkBlendFactor,
colorBlendOp: VkBlendOp,
srcAlphaBlendFactor: VkBlendFactor,
dstAlphaBlendFactor: VkBlendFactor,
alphaBlendOp: VkBlendOp,
}
struct VkColorBlendAdvancedEXT {
advancedBlendOp: VkBlendOp,
srcPremultiplied: VkBool32,
dstPremultiplied: VkBool32,
blendOverlap: VkBlendOverlapEXT,
clampResults: VkBool32,
}
struct VkRenderPassTransformBeginInfoQCOM {
sType: VkStructureType = VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM,
pNext: *mut void,
transform: VkSurfaceTransformFlagBitsKHR,
}
struct VkCopyCommandTransformInfoQCOM {
sType: VkStructureType = VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM,
pNext: *const void,
transform: VkSurfaceTransformFlagBitsKHR,
}
struct VkCommandBufferInheritanceRenderPassTransformInfoQCOM {
sType: VkStructureType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM,
pNext: *mut void,
transform: VkSurfaceTransformFlagBitsKHR,
renderArea: VkRect2D,
}
struct VkPhysicalDeviceDiagnosticsConfigFeaturesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV,
pNext: *mut void,
diagnosticsConfig: VkBool32,
}
struct VkDeviceDiagnosticsConfigCreateInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV,
pNext: *const void,
flags: VkDeviceDiagnosticsConfigFlagsNV,
}
struct VkPipelineOfflineCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_OFFLINE_CREATE_INFO,
pNext: *const void,
pipelineIdentifier: [uint8_t; VK_UUID_SIZE],
matchControl: VkPipelineMatchControl,
poolEntrySize: VkDeviceSize,
}
struct VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES,
pNext: *mut void,
shaderZeroInitializeWorkgroupMemory: VkBool32,
}
struct VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR,
pNext: *mut void,
shaderSubgroupUniformControlFlow: VkBool32,
}
struct VkPhysicalDeviceRobustness2FeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT,
pNext: *mut void,
robustBufferAccess2: VkBool32,
robustImageAccess2: VkBool32,
nullDescriptor: VkBool32,
}
struct VkPhysicalDeviceRobustness2PropertiesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT,
pNext: *mut void,
robustStorageBufferAccessSizeAlignment: VkDeviceSize,
robustUniformBufferAccessSizeAlignment: VkDeviceSize,
}
struct VkPhysicalDeviceImageRobustnessFeatures {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES,
pNext: *mut void,
robustImageAccess: VkBool32,
}
struct VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR,
pNext: *mut void,
workgroupMemoryExplicitLayout: VkBool32,
workgroupMemoryExplicitLayoutScalarBlockLayout: VkBool32,
workgroupMemoryExplicitLayout8BitAccess: VkBool32,
workgroupMemoryExplicitLayout16BitAccess: VkBool32,
}
struct VkPhysicalDevicePortabilitySubsetFeaturesKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR,
pNext: *mut void,
constantAlphaColorBlendFactors: VkBool32,
events: VkBool32,
imageViewFormatReinterpretation: VkBool32,
imageViewFormatSwizzle: VkBool32,
imageView2DOn3DImage: VkBool32,
multisampleArrayImage: VkBool32,
mutableComparisonSamplers: VkBool32,
pointPolygons: VkBool32,
samplerMipLodBias: VkBool32,
separateStencilMaskRef: VkBool32,
shaderSampleRateInterpolationFunctions: VkBool32,
tessellationIsolines: VkBool32,
tessellationPointMode: VkBool32,
triangleFans: VkBool32,
vertexAttributeAccessBeyondStride: VkBool32,
}
struct VkPhysicalDevicePortabilitySubsetPropertiesKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR,
pNext: *mut void,
minVertexInputBindingStrideAlignment: uint32_t,
}
struct VkPhysicalDevice4444FormatsFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT,
pNext: *mut void,
formatA4R4G4B4: VkBool32,
formatA4B4G4R4: VkBool32,
}
struct VkPhysicalDeviceSubpassShadingFeaturesHUAWEI {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI,
pNext: *mut void,
subpassShading: VkBool32,
}
struct VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI,
pNext: *mut void,
clustercullingShader: VkBool32,
multiviewClusterCullingShader: VkBool32,
}
struct VkBufferCopy2 {
sType: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_COPY_2,
pNext: *const void,
srcOffset: VkDeviceSize,
dstOffset: VkDeviceSize,
size: VkDeviceSize,
}
struct VkImageCopy2 {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_COPY_2,
pNext: *const void,
srcSubresource: VkImageSubresourceLayers,
srcOffset: VkOffset3D,
dstSubresource: VkImageSubresourceLayers,
dstOffset: VkOffset3D,
extent: VkExtent3D,
}
struct VkImageBlit2 {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_BLIT_2,
pNext: *const void,
srcSubresource: VkImageSubresourceLayers,
srcOffsets: [VkOffset3D; 2],
dstSubresource: VkImageSubresourceLayers,
dstOffsets: [VkOffset3D; 2],
}
struct VkBufferImageCopy2 {
sType: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2,
pNext: *const void,
bufferOffset: VkDeviceSize,
bufferRowLength: uint32_t,
bufferImageHeight: uint32_t,
imageSubresource: VkImageSubresourceLayers,
imageOffset: VkOffset3D,
imageExtent: VkExtent3D,
}
struct VkImageResolve2 {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2,
pNext: *const void,
srcSubresource: VkImageSubresourceLayers,
srcOffset: VkOffset3D,
dstSubresource: VkImageSubresourceLayers,
dstOffset: VkOffset3D,
extent: VkExtent3D,
}
struct VkCopyBufferInfo2 {
sType: VkStructureType = VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2,
pNext: *const void,
srcBuffer: VkBuffer,
dstBuffer: VkBuffer,
regionCount: uint32_t,
pRegions: *const [VkBufferCopy2; dyn regionCount],
}
struct VkCopyImageInfo2 {
sType: VkStructureType = VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2,
pNext: *const void,
srcImage: VkImage,
srcImageLayout: VkImageLayout,
dstImage: VkImage,
dstImageLayout: VkImageLayout,
regionCount: uint32_t,
pRegions: *const [VkImageCopy2; dyn regionCount],
}
struct VkBlitImageInfo2 {
sType: VkStructureType = VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2,
pNext: *const void,
srcImage: VkImage,
srcImageLayout: VkImageLayout,
dstImage: VkImage,
dstImageLayout: VkImageLayout,
regionCount: uint32_t,
pRegions: *const [VkImageBlit2; dyn regionCount],
filter: VkFilter,
}
struct VkCopyBufferToImageInfo2 {
sType: VkStructureType = VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2,
pNext: *const void,
srcBuffer: VkBuffer,
dstImage: VkImage,
dstImageLayout: VkImageLayout,
regionCount: uint32_t,
pRegions: *const [VkBufferImageCopy2; dyn regionCount],
}
struct VkCopyImageToBufferInfo2 {
sType: VkStructureType = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2,
pNext: *const void,
srcImage: VkImage,
srcImageLayout: VkImageLayout,
dstBuffer: VkBuffer,
regionCount: uint32_t,
pRegions: *const [VkBufferImageCopy2; dyn regionCount],
}
struct VkResolveImageInfo2 {
sType: VkStructureType = VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2,
pNext: *const void,
srcImage: VkImage,
srcImageLayout: VkImageLayout,
dstImage: VkImage,
dstImageLayout: VkImageLayout,
regionCount: uint32_t,
pRegions: *const [VkImageResolve2; dyn regionCount],
}
struct VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT,
pNext: *mut void,
shaderImageInt64Atomics: VkBool32,
sparseImageInt64Atomics: VkBool32,
}
struct VkFragmentShadingRateAttachmentInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR,
pNext: *const void,
pFragmentShadingRateAttachment: *const VkAttachmentReference2,
shadingRateAttachmentTexelSize: VkExtent2D,
}
struct VkPipelineFragmentShadingRateStateCreateInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR,
pNext: *const void,
fragmentSize: VkExtent2D,
combinerOps: [VkFragmentShadingRateCombinerOpKHR; 2],
}
struct VkPhysicalDeviceFragmentShadingRateFeaturesKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR,
pNext: *mut void,
pipelineFragmentShadingRate: VkBool32,
primitiveFragmentShadingRate: VkBool32,
attachmentFragmentShadingRate: VkBool32,
}
struct VkPhysicalDeviceFragmentShadingRatePropertiesKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR,
pNext: *mut void,
minFragmentShadingRateAttachmentTexelSize: VkExtent2D,
maxFragmentShadingRateAttachmentTexelSize: VkExtent2D,
maxFragmentShadingRateAttachmentTexelSizeAspectRatio: uint32_t,
primitiveFragmentShadingRateWithMultipleViewports: VkBool32,
layeredShadingRateAttachments: VkBool32,
fragmentShadingRateNonTrivialCombinerOps: VkBool32,
maxFragmentSize: VkExtent2D,
maxFragmentSizeAspectRatio: uint32_t,
maxFragmentShadingRateCoverageSamples: uint32_t,
maxFragmentShadingRateRasterizationSamples: VkSampleCountFlagBits,
fragmentShadingRateWithShaderDepthStencilWrites: VkBool32,
fragmentShadingRateWithSampleMask: VkBool32,
fragmentShadingRateWithShaderSampleMask: VkBool32,
fragmentShadingRateWithConservativeRasterization: VkBool32,
fragmentShadingRateWithFragmentShaderInterlock: VkBool32,
fragmentShadingRateWithCustomSampleLocations: VkBool32,
fragmentShadingRateStrictMultiplyCombiner: VkBool32,
}
struct VkPhysicalDeviceFragmentShadingRateKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR,
pNext: *mut void,
sampleCounts: VkSampleCountFlags,
fragmentSize: VkExtent2D,
}
struct VkPhysicalDeviceShaderTerminateInvocationFeatures {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES,
pNext: *mut void,
shaderTerminateInvocation: VkBool32,
}
struct VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV,
pNext: *mut void,
fragmentShadingRateEnums: VkBool32,
supersampleFragmentShadingRates: VkBool32,
noInvocationFragmentShadingRates: VkBool32,
}
struct VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV,
pNext: *mut void,
maxFragmentShadingRateInvocationCount: VkSampleCountFlagBits,
}
struct VkPipelineFragmentShadingRateEnumStateCreateInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV,
pNext: *const void,
shadingRateType: VkFragmentShadingRateTypeNV,
shadingRate: VkFragmentShadingRateNV,
combinerOps: [VkFragmentShadingRateCombinerOpKHR; 2],
}
struct VkAccelerationStructureBuildSizesInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR,
pNext: *const void,
accelerationStructureSize: VkDeviceSize,
updateScratchSize: VkDeviceSize,
buildScratchSize: VkDeviceSize,
}
struct VkPhysicalDeviceImage2DViewOf3DFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT,
pNext: *mut void,
image2DViewOf3D: VkBool32,
sampler2DViewOf3D: VkBool32,
}
struct VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT,
pNext: *mut void,
imageSlicedViewOf3D: VkBool32,
}
struct VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT,
pNext: *mut void,
attachmentFeedbackLoopDynamicState: VkBool32,
}
struct VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT,
pNext: *mut void,
mutableDescriptorType: VkBool32,
}
struct VkMutableDescriptorTypeListEXT {
descriptorTypeCount: uint32_t,
pDescriptorTypes: *const [VkDescriptorType; dyn descriptorTypeCount],
}
struct VkMutableDescriptorTypeCreateInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT,
pNext: *const void,
mutableDescriptorTypeListCount: uint32_t,
pMutableDescriptorTypeLists: *const [VkMutableDescriptorTypeListEXT; dyn mutableDescriptorTypeListCount],
}
struct VkPhysicalDeviceDepthClipControlFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT,
pNext: *mut void,
depthClipControl: VkBool32,
}
struct VkPipelineViewportDepthClipControlCreateInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT,
pNext: *const void,
negativeOneToOne: VkBool32,
}
struct VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT,
pNext: *mut void,
vertexInputDynamicState: VkBool32,
}
struct VkPhysicalDeviceExternalMemoryRDMAFeaturesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV,
pNext: *mut void,
externalMemoryRDMA: VkBool32,
}
struct VkVertexInputBindingDescription2EXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT,
pNext: *mut void,
binding: uint32_t,
stride: uint32_t,
inputRate: VkVertexInputRate,
divisor: uint32_t,
}
struct VkVertexInputAttributeDescription2EXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT,
pNext: *mut void,
location: uint32_t,
binding: uint32_t,
format: VkFormat,
offset: uint32_t,
}
struct VkPhysicalDeviceColorWriteEnableFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT,
pNext: *mut void,
colorWriteEnable: VkBool32,
}
struct VkPipelineColorWriteCreateInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT,
pNext: *const void,
attachmentCount: uint32_t,
pColorWriteEnables: *const [VkBool32; dyn attachmentCount],
}
struct VkMemoryBarrier2 {
sType: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2,
pNext: *const void,
srcStageMask: VkPipelineStageFlags2,
srcAccessMask: VkAccessFlags2,
dstStageMask: VkPipelineStageFlags2,
dstAccessMask: VkAccessFlags2,
}
struct VkImageMemoryBarrier2 {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,
pNext: *const void,
srcStageMask: VkPipelineStageFlags2,
srcAccessMask: VkAccessFlags2,
dstStageMask: VkPipelineStageFlags2,
dstAccessMask: VkAccessFlags2,
oldLayout: VkImageLayout,
newLayout: VkImageLayout,
srcQueueFamilyIndex: uint32_t,
dstQueueFamilyIndex: uint32_t,
image: VkImage,
subresourceRange: VkImageSubresourceRange,
}
struct VkBufferMemoryBarrier2 {
sType: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2,
pNext: *const void,
srcStageMask: VkPipelineStageFlags2,
srcAccessMask: VkAccessFlags2,
dstStageMask: VkPipelineStageFlags2,
dstAccessMask: VkAccessFlags2,
srcQueueFamilyIndex: uint32_t,
dstQueueFamilyIndex: uint32_t,
buffer: VkBuffer,
offset: VkDeviceSize,
size: VkDeviceSize,
}
struct VkDependencyInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,
pNext: *const void,
dependencyFlags: VkDependencyFlags,
memoryBarrierCount: uint32_t,
pMemoryBarriers: *const [VkMemoryBarrier2; dyn memoryBarrierCount],
bufferMemoryBarrierCount: uint32_t,
pBufferMemoryBarriers: *const [VkBufferMemoryBarrier2; dyn bufferMemoryBarrierCount],
imageMemoryBarrierCount: uint32_t,
pImageMemoryBarriers: *const [VkImageMemoryBarrier2; dyn imageMemoryBarrierCount],
}
struct VkSemaphoreSubmitInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,
pNext: *const void,
semaphore: VkSemaphore,
value: uint64_t,
stageMask: VkPipelineStageFlags2,
deviceIndex: uint32_t,
}
struct VkCommandBufferSubmitInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO,
pNext: *const void,
commandBuffer: VkCommandBuffer,
deviceMask: uint32_t,
}
struct VkSubmitInfo2 {
sType: VkStructureType = VK_STRUCTURE_TYPE_SUBMIT_INFO_2,
pNext: *const void,
flags: VkSubmitFlags,
waitSemaphoreInfoCount: uint32_t,
pWaitSemaphoreInfos: *const [VkSemaphoreSubmitInfo; dyn waitSemaphoreInfoCount],
commandBufferInfoCount: uint32_t,
pCommandBufferInfos: *const [VkCommandBufferSubmitInfo; dyn commandBufferInfoCount],
signalSemaphoreInfoCount: uint32_t,
pSignalSemaphoreInfos: *const [VkSemaphoreSubmitInfo; dyn signalSemaphoreInfoCount],
}
struct VkQueueFamilyCheckpointProperties2NV {
sType: VkStructureType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV,
pNext: *mut void,
checkpointExecutionStageMask: VkPipelineStageFlags2,
}
struct VkCheckpointData2NV {
sType: VkStructureType = VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV,
pNext: *mut void,
stage: VkPipelineStageFlags2,
pCheckpointMarker: *mut void,
}
struct VkPhysicalDeviceSynchronization2Features {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES,
pNext: *mut void,
synchronization2: VkBool32,
}
struct VkPhysicalDeviceHostImageCopyFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT,
pNext: *mut void,
hostImageCopy: VkBool32,
}
struct VkPhysicalDeviceHostImageCopyPropertiesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT,
pNext: *mut void,
copySrcLayoutCount: uint32_t,
pCopySrcLayouts: *mut [VkImageLayout; dyn copySrcLayoutCount],
copyDstLayoutCount: uint32_t,
pCopyDstLayouts: *mut [VkImageLayout; dyn copyDstLayoutCount],
optimalTilingLayoutUUID: [uint8_t; VK_UUID_SIZE],
identicalMemoryTypeRequirements: VkBool32,
}
struct VkMemoryToImageCopyEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY_EXT,
pNext: *const void,
pHostPointer: *const void,
memoryRowLength: uint32_t,
memoryImageHeight: uint32_t,
imageSubresource: VkImageSubresourceLayers,
imageOffset: VkOffset3D,
imageExtent: VkExtent3D,
}
struct VkImageToMemoryCopyEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY_EXT,
pNext: *const void,
pHostPointer: *mut void,
memoryRowLength: uint32_t,
memoryImageHeight: uint32_t,
imageSubresource: VkImageSubresourceLayers,
imageOffset: VkOffset3D,
imageExtent: VkExtent3D,
}
struct VkCopyMemoryToImageInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO_EXT,
pNext: *const void,
flags: VkHostImageCopyFlagsEXT,
dstImage: VkImage,
dstImageLayout: VkImageLayout,
regionCount: uint32_t,
pRegions: *const [VkMemoryToImageCopyEXT; dyn regionCount],
}
struct VkCopyImageToMemoryInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO_EXT,
pNext: *const void,
flags: VkHostImageCopyFlagsEXT,
srcImage: VkImage,
srcImageLayout: VkImageLayout,
regionCount: uint32_t,
pRegions: *const [VkImageToMemoryCopyEXT; dyn regionCount],
}
struct VkCopyImageToImageInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO_EXT,
pNext: *const void,
flags: VkHostImageCopyFlagsEXT,
srcImage: VkImage,
srcImageLayout: VkImageLayout,
dstImage: VkImage,
dstImageLayout: VkImageLayout,
regionCount: uint32_t,
pRegions: *const [VkImageCopy2; dyn regionCount],
}
struct VkHostImageLayoutTransitionInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO_EXT,
pNext: *const void,
image: VkImage,
oldLayout: VkImageLayout,
newLayout: VkImageLayout,
subresourceRange: VkImageSubresourceRange,
}
struct VkSubresourceHostMemcpySizeEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT,
pNext: *mut void,
size: VkDeviceSize,
}
struct VkHostImageCopyDevicePerformanceQueryEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT,
pNext: *mut void,
optimalDeviceAccess: VkBool32,
identicalMemoryLayout: VkBool32,
}
struct VkPhysicalDeviceVulkanSC10Properties {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_PROPERTIES,
pNext: *mut void,
deviceNoDynamicHostAllocations: VkBool32,
deviceDestroyFreesMemory: VkBool32,
commandPoolMultipleCommandBuffersRecording: VkBool32,
commandPoolResetCommandBuffer: VkBool32,
commandBufferSimultaneousUse: VkBool32,
secondaryCommandBufferNullOrImagelessFramebuffer: VkBool32,
recycleDescriptorSetMemory: VkBool32,
recyclePipelineMemory: VkBool32,
maxRenderPassSubpasses: uint32_t,
maxRenderPassDependencies: uint32_t,
maxSubpassInputAttachments: uint32_t,
maxSubpassPreserveAttachments: uint32_t,
maxFramebufferAttachments: uint32_t,
maxDescriptorSetLayoutBindings: uint32_t,
maxQueryFaultCount: uint32_t,
maxCallbackFaultCount: uint32_t,
maxCommandPoolCommandBuffers: uint32_t,
maxCommandBufferSize: VkDeviceSize,
}
struct VkPipelinePoolSize {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_POOL_SIZE,
pNext: *const void,
poolEntrySize: VkDeviceSize,
poolEntryCount: uint32_t,
}
struct VkDeviceObjectReservationCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_OBJECT_RESERVATION_CREATE_INFO,
pNext: *const void,
pipelineCacheCreateInfoCount: uint32_t,
pPipelineCacheCreateInfos: *const [VkPipelineCacheCreateInfo; dyn pipelineCacheCreateInfoCount],
pipelinePoolSizeCount: uint32_t,
pPipelinePoolSizes: *const [VkPipelinePoolSize; dyn pipelinePoolSizeCount],
semaphoreRequestCount: uint32_t,
commandBufferRequestCount: uint32_t,
fenceRequestCount: uint32_t,
deviceMemoryRequestCount: uint32_t,
bufferRequestCount: uint32_t,
imageRequestCount: uint32_t,
eventRequestCount: uint32_t,
queryPoolRequestCount: uint32_t,
bufferViewRequestCount: uint32_t,
imageViewRequestCount: uint32_t,
layeredImageViewRequestCount: uint32_t,
pipelineCacheRequestCount: uint32_t,
pipelineLayoutRequestCount: uint32_t,
renderPassRequestCount: uint32_t,
graphicsPipelineRequestCount: uint32_t,
computePipelineRequestCount: uint32_t,
descriptorSetLayoutRequestCount: uint32_t,
samplerRequestCount: uint32_t,
descriptorPoolRequestCount: uint32_t,
descriptorSetRequestCount: uint32_t,
framebufferRequestCount: uint32_t,
commandPoolRequestCount: uint32_t,
samplerYcbcrConversionRequestCount: uint32_t,
surfaceRequestCount: uint32_t,
swapchainRequestCount: uint32_t,
displayModeRequestCount: uint32_t,
subpassDescriptionRequestCount: uint32_t,
attachmentDescriptionRequestCount: uint32_t,
descriptorSetLayoutBindingRequestCount: uint32_t,
descriptorSetLayoutBindingLimit: uint32_t,
maxImageViewMipLevels: uint32_t,
maxImageViewArrayLayers: uint32_t,
maxLayeredImageViewMipLevels: uint32_t,
maxOcclusionQueriesPerPool: uint32_t,
maxPipelineStatisticsQueriesPerPool: uint32_t,
maxTimestampQueriesPerPool: uint32_t,
maxImmutableSamplersPerDescriptorSetLayout: uint32_t,
}
struct VkCommandPoolMemoryReservationCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_COMMAND_POOL_MEMORY_RESERVATION_CREATE_INFO,
pNext: *const void,
commandPoolReservedSize: VkDeviceSize,
commandPoolMaxCommandBuffers: uint32_t,
}
struct VkCommandPoolMemoryConsumption {
sType: VkStructureType = VK_STRUCTURE_TYPE_COMMAND_POOL_MEMORY_CONSUMPTION,
pNext: *mut void,
commandPoolAllocated: VkDeviceSize,
commandPoolReservedSize: VkDeviceSize,
commandBufferAllocated: VkDeviceSize,
}
struct VkPhysicalDeviceVulkanSC10Features {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_SC_1_0_FEATURES,
pNext: *mut void,
shaderAtomicInstructions: VkBool32,
}
struct VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT,
pNext: *mut void,
primitivesGeneratedQuery: VkBool32,
primitivesGeneratedQueryWithRasterizerDiscard: VkBool32,
primitivesGeneratedQueryWithNonZeroStreams: VkBool32,
}
struct VkPhysicalDeviceLegacyDitheringFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT,
pNext: *mut void,
legacyDithering: VkBool32,
}
struct VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT,
pNext: *mut void,
multisampledRenderToSingleSampled: VkBool32,
}
struct VkSubpassResolvePerformanceQueryEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT,
pNext: *mut void,
optimal: VkBool32,
}
struct VkMultisampledRenderToSingleSampledInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT,
pNext: *const void,
multisampledRenderToSingleSampledEnable: VkBool32,
rasterizationSamples: VkSampleCountFlagBits,
}
struct VkPhysicalDevicePipelineProtectedAccessFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT,
pNext: *mut void,
pipelineProtectedAccess: VkBool32,
}
struct VkQueueFamilyVideoPropertiesKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR,
pNext: *mut void,
videoCodecOperations: VkVideoCodecOperationFlagsKHR,
}
struct VkQueueFamilyQueryResultStatusPropertiesKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR,
pNext: *mut void,
queryResultStatusSupport: VkBool32,
}
struct VkVideoProfileListInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR,
pNext: *const void,
profileCount: uint32_t,
pProfiles: *const [VkVideoProfileInfoKHR; dyn profileCount],
}
struct VkPhysicalDeviceVideoFormatInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR,
pNext: *const void,
imageUsage: VkImageUsageFlags,
}
struct VkVideoFormatPropertiesKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR,
pNext: *mut void,
format: VkFormat,
componentMapping: VkComponentMapping,
imageCreateFlags: VkImageCreateFlags,
imageType: VkImageType,
imageTiling: VkImageTiling,
imageUsageFlags: VkImageUsageFlags,
}
struct VkVideoProfileInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR,
pNext: *const void,
videoCodecOperation: VkVideoCodecOperationFlagBitsKHR,
chromaSubsampling: VkVideoChromaSubsamplingFlagsKHR,
lumaBitDepth: VkVideoComponentBitDepthFlagsKHR,
chromaBitDepth: VkVideoComponentBitDepthFlagsKHR,
}
struct VkVideoCapabilitiesKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR,
pNext: *mut void,
flags: VkVideoCapabilityFlagsKHR,
minBitstreamBufferOffsetAlignment: VkDeviceSize,
minBitstreamBufferSizeAlignment: VkDeviceSize,
pictureAccessGranularity: VkExtent2D,
minCodedExtent: VkExtent2D,
maxCodedExtent: VkExtent2D,
maxDpbSlots: uint32_t,
maxActiveReferencePictures: uint32_t,
stdHeaderVersion: VkExtensionProperties,
}
struct VkVideoSessionMemoryRequirementsKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR,
pNext: *mut void,
memoryBindIndex: uint32_t,
memoryRequirements: VkMemoryRequirements,
}
struct VkBindVideoSessionMemoryInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR,
pNext: *const void,
memoryBindIndex: uint32_t,
memory: VkDeviceMemory,
memoryOffset: VkDeviceSize,
memorySize: VkDeviceSize,
}
struct VkVideoPictureResourceInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR,
pNext: *const void,
codedOffset: VkOffset2D,
codedExtent: VkExtent2D,
baseArrayLayer: uint32_t,
imageViewBinding: VkImageView,
}
struct VkVideoReferenceSlotInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR,
pNext: *const void,
slotIndex: int32_t,
pPictureResource: *const VkVideoPictureResourceInfoKHR,
}
struct VkVideoDecodeCapabilitiesKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR,
pNext: *mut void,
flags: VkVideoDecodeCapabilityFlagsKHR,
}
struct VkVideoDecodeUsageInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR,
pNext: *const void,
videoUsageHints: VkVideoDecodeUsageFlagsKHR,
}
struct VkVideoDecodeInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR,
pNext: *const void,
flags: VkVideoDecodeFlagsKHR,
srcBuffer: VkBuffer,
srcBufferOffset: VkDeviceSize,
srcBufferRange: VkDeviceSize,
dstPictureResource: VkVideoPictureResourceInfoKHR,
pSetupReferenceSlot: *const VkVideoReferenceSlotInfoKHR,
referenceSlotCount: uint32_t,
pReferenceSlots: *const [VkVideoReferenceSlotInfoKHR; dyn referenceSlotCount],
}
struct VkVideoDecodeH264ProfileInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR,
pNext: *const void,
stdProfileIdc: StdVideoH264ProfileIdc,
pictureLayout: VkVideoDecodeH264PictureLayoutFlagBitsKHR,
}
struct VkVideoDecodeH264CapabilitiesKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR,
pNext: *mut void,
maxLevelIdc: StdVideoH264LevelIdc,
fieldOffsetGranularity: VkOffset2D,
}
struct VkVideoDecodeH264SessionParametersAddInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR,
pNext: *const void,
stdSPSCount: uint32_t,
pStdSPSs: *const [StdVideoH264SequenceParameterSet; dyn stdSPSCount],
stdPPSCount: uint32_t,
pStdPPSs: *const [StdVideoH264PictureParameterSet; dyn stdPPSCount],
}
struct VkVideoDecodeH264SessionParametersCreateInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR,
pNext: *const void,
maxStdSPSCount: uint32_t,
maxStdPPSCount: uint32_t,
pParametersAddInfo: *const VkVideoDecodeH264SessionParametersAddInfoKHR,
}
struct VkVideoDecodeH264PictureInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR,
pNext: *const void,
pStdPictureInfo: *const StdVideoDecodeH264PictureInfo,
sliceCount: uint32_t,
pSliceOffsets: *const [uint32_t; dyn sliceCount],
}
struct VkVideoDecodeH264DpbSlotInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR,
pNext: *const void,
pStdReferenceInfo: *const StdVideoDecodeH264ReferenceInfo,
}
struct VkVideoDecodeH265ProfileInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR,
pNext: *const void,
stdProfileIdc: StdVideoH265ProfileIdc,
}
struct VkVideoDecodeH265CapabilitiesKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR,
pNext: *mut void,
maxLevelIdc: StdVideoH265LevelIdc,
}
struct VkVideoDecodeH265SessionParametersAddInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR,
pNext: *const void,
stdVPSCount: uint32_t,
pStdVPSs: *const [StdVideoH265VideoParameterSet; dyn stdVPSCount],
stdSPSCount: uint32_t,
pStdSPSs: *const [StdVideoH265SequenceParameterSet; dyn stdSPSCount],
stdPPSCount: uint32_t,
pStdPPSs: *const [StdVideoH265PictureParameterSet; dyn stdPPSCount],
}
struct VkVideoDecodeH265SessionParametersCreateInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR,
pNext: *const void,
maxStdVPSCount: uint32_t,
maxStdSPSCount: uint32_t,
maxStdPPSCount: uint32_t,
pParametersAddInfo: *const VkVideoDecodeH265SessionParametersAddInfoKHR,
}
struct VkVideoDecodeH265PictureInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR,
pNext: *const void,
pStdPictureInfo: *const StdVideoDecodeH265PictureInfo,
sliceSegmentCount: uint32_t,
pSliceSegmentOffsets: *const [uint32_t; dyn sliceSegmentCount],
}
struct VkVideoDecodeH265DpbSlotInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR,
pNext: *const void,
pStdReferenceInfo: *const StdVideoDecodeH265ReferenceInfo,
}
struct VkVideoSessionCreateInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR,
pNext: *const void,
queueFamilyIndex: uint32_t,
flags: VkVideoSessionCreateFlagsKHR,
pVideoProfile: *const VkVideoProfileInfoKHR,
pictureFormat: VkFormat,
maxCodedExtent: VkExtent2D,
referencePictureFormat: VkFormat,
maxDpbSlots: uint32_t,
maxActiveReferencePictures: uint32_t,
pStdHeaderVersion: *const VkExtensionProperties,
}
struct VkVideoSessionParametersCreateInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR,
pNext: *const void,
flags: VkVideoSessionParametersCreateFlagsKHR,
videoSessionParametersTemplate: VkVideoSessionParametersKHR,
videoSession: VkVideoSessionKHR,
}
struct VkVideoSessionParametersUpdateInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR,
pNext: *const void,
updateSequenceCount: uint32_t,
}
struct VkVideoEncodeSessionParametersGetInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR,
pNext: *const void,
videoSessionParameters: VkVideoSessionParametersKHR,
}
struct VkVideoEncodeSessionParametersFeedbackInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR,
pNext: *mut void,
hasOverrides: VkBool32,
}
struct VkVideoBeginCodingInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR,
pNext: *const void,
flags: VkVideoBeginCodingFlagsKHR,
videoSession: VkVideoSessionKHR,
videoSessionParameters: VkVideoSessionParametersKHR,
referenceSlotCount: uint32_t,
pReferenceSlots: *const [VkVideoReferenceSlotInfoKHR; dyn referenceSlotCount],
}
struct VkVideoEndCodingInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR,
pNext: *const void,
flags: VkVideoEndCodingFlagsKHR,
}
struct VkVideoCodingControlInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR,
pNext: *const void,
flags: VkVideoCodingControlFlagsKHR,
}
struct VkVideoEncodeUsageInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR,
pNext: *const void,
videoUsageHints: VkVideoEncodeUsageFlagsKHR,
videoContentHints: VkVideoEncodeContentFlagsKHR,
tuningMode: VkVideoEncodeTuningModeKHR,
}
struct VkVideoEncodeInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR,
pNext: *const void,
flags: VkVideoEncodeFlagsKHR,
dstBuffer: VkBuffer,
dstBufferOffset: VkDeviceSize,
dstBufferRange: VkDeviceSize,
srcPictureResource: VkVideoPictureResourceInfoKHR,
pSetupReferenceSlot: *const VkVideoReferenceSlotInfoKHR,
referenceSlotCount: uint32_t,
pReferenceSlots: *const [VkVideoReferenceSlotInfoKHR; dyn referenceSlotCount],
precedingExternallyEncodedBytes: uint32_t,
}
struct VkQueryPoolVideoEncodeFeedbackCreateInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR,
pNext: *const void,
encodeFeedbackFlags: VkVideoEncodeFeedbackFlagsKHR,
}
struct VkVideoEncodeQualityLevelInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR,
pNext: *const void,
qualityLevel: uint32_t,
}
struct VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR,
pNext: *const void,
pVideoProfile: *const VkVideoProfileInfoKHR,
qualityLevel: uint32_t,
}
struct VkVideoEncodeQualityLevelPropertiesKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR,
pNext: *mut void,
preferredRateControlMode: VkVideoEncodeRateControlModeFlagBitsKHR,
preferredRateControlLayerCount: uint32_t,
}
struct VkVideoEncodeRateControlInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR,
pNext: *const void,
flags: VkVideoEncodeRateControlFlagsKHR,
rateControlMode: VkVideoEncodeRateControlModeFlagBitsKHR,
layerCount: uint32_t,
pLayers: *const [VkVideoEncodeRateControlLayerInfoKHR; dyn layerCount],
virtualBufferSizeInMs: uint32_t,
initialVirtualBufferSizeInMs: uint32_t,
}
struct VkVideoEncodeRateControlLayerInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR,
pNext: *const void,
averageBitrate: uint64_t,
maxBitrate: uint64_t,
frameRateNumerator: uint32_t,
frameRateDenominator: uint32_t,
}
struct VkVideoEncodeCapabilitiesKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR,
pNext: *mut void,
flags: VkVideoEncodeCapabilityFlagsKHR,
rateControlModes: VkVideoEncodeRateControlModeFlagsKHR,
maxRateControlLayers: uint32_t,
maxBitrate: uint64_t,
maxQualityLevels: uint32_t,
encodeInputPictureGranularity: VkExtent2D,
supportedEncodeFeedbackFlags: VkVideoEncodeFeedbackFlagsKHR,
}
struct VkVideoEncodeH264CapabilitiesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT,
pNext: *mut void,
flags: VkVideoEncodeH264CapabilityFlagsEXT,
maxLevelIdc: StdVideoH264LevelIdc,
maxSliceCount: uint32_t,
maxPPictureL0ReferenceCount: uint32_t,
maxBPictureL0ReferenceCount: uint32_t,
maxL1ReferenceCount: uint32_t,
maxTemporalLayerCount: uint32_t,
expectDyadicTemporalLayerPattern: VkBool32,
minQp: int32_t,
maxQp: int32_t,
prefersGopRemainingFrames: VkBool32,
requiresGopRemainingFrames: VkBool32,
stdSyntaxFlags: VkVideoEncodeH264StdFlagsEXT,
}
struct VkVideoEncodeH264QualityLevelPropertiesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_EXT,
pNext: *mut void,
preferredRateControlFlags: VkVideoEncodeH264RateControlFlagsEXT,
preferredGopFrameCount: uint32_t,
preferredIdrPeriod: uint32_t,
preferredConsecutiveBFrameCount: uint32_t,
preferredTemporalLayerCount: uint32_t,
preferredConstantQp: VkVideoEncodeH264QpEXT,
preferredMaxL0ReferenceCount: uint32_t,
preferredMaxL1ReferenceCount: uint32_t,
preferredStdEntropyCodingModeFlag: VkBool32,
}
struct VkVideoEncodeH264SessionCreateInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_EXT,
pNext: *const void,
useMaxLevelIdc: VkBool32,
maxLevelIdc: StdVideoH264LevelIdc,
}
struct VkVideoEncodeH264SessionParametersAddInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT,
pNext: *const void,
stdSPSCount: uint32_t,
pStdSPSs: *const [StdVideoH264SequenceParameterSet; dyn stdSPSCount],
stdPPSCount: uint32_t,
pStdPPSs: *const [StdVideoH264PictureParameterSet; dyn stdPPSCount],
}
struct VkVideoEncodeH264SessionParametersCreateInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT,
pNext: *const void,
maxStdSPSCount: uint32_t,
maxStdPPSCount: uint32_t,
pParametersAddInfo: *const VkVideoEncodeH264SessionParametersAddInfoEXT,
}
struct VkVideoEncodeH264SessionParametersGetInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_EXT,
pNext: *const void,
writeStdSPS: VkBool32,
writeStdPPS: VkBool32,
stdSPSId: uint32_t,
stdPPSId: uint32_t,
}
struct VkVideoEncodeH264SessionParametersFeedbackInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_EXT,
pNext: *mut void,
hasStdSPSOverrides: VkBool32,
hasStdPPSOverrides: VkBool32,
}
struct VkVideoEncodeH264DpbSlotInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT,
pNext: *const void,
pStdReferenceInfo: *const StdVideoEncodeH264ReferenceInfo,
}
struct VkVideoEncodeH264PictureInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_EXT,
pNext: *const void,
naluSliceEntryCount: uint32_t,
pNaluSliceEntries: *const [VkVideoEncodeH264NaluSliceInfoEXT; dyn naluSliceEntryCount],
pStdPictureInfo: *const StdVideoEncodeH264PictureInfo,
generatePrefixNalu: VkBool32,
}
struct VkVideoEncodeH264ProfileInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_EXT,
pNext: *const void,
stdProfileIdc: StdVideoH264ProfileIdc,
}
struct VkVideoEncodeH264NaluSliceInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT,
pNext: *const void,
constantQp: int32_t,
pStdSliceHeader: *const StdVideoEncodeH264SliceHeader,
}
struct VkVideoEncodeH264RateControlInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT,
pNext: *const void,
flags: VkVideoEncodeH264RateControlFlagsEXT,
gopFrameCount: uint32_t,
idrPeriod: uint32_t,
consecutiveBFrameCount: uint32_t,
temporalLayerCount: uint32_t,
}
struct VkVideoEncodeH264QpEXT {
qpI: int32_t,
qpP: int32_t,
qpB: int32_t,
}
struct VkVideoEncodeH264FrameSizeEXT {
frameISize: uint32_t,
framePSize: uint32_t,
frameBSize: uint32_t,
}
struct VkVideoEncodeH264GopRemainingFrameInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_EXT,
pNext: *const void,
useGopRemainingFrames: VkBool32,
gopRemainingI: uint32_t,
gopRemainingP: uint32_t,
gopRemainingB: uint32_t,
}
struct VkVideoEncodeH264RateControlLayerInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT,
pNext: *const void,
useMinQp: VkBool32,
minQp: VkVideoEncodeH264QpEXT,
useMaxQp: VkBool32,
maxQp: VkVideoEncodeH264QpEXT,
useMaxFrameSize: VkBool32,
maxFrameSize: VkVideoEncodeH264FrameSizeEXT,
}
struct VkVideoEncodeH265CapabilitiesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT,
pNext: *mut void,
flags: VkVideoEncodeH265CapabilityFlagsEXT,
maxLevelIdc: StdVideoH265LevelIdc,
maxSliceSegmentCount: uint32_t,
maxTiles: VkExtent2D,
ctbSizes: VkVideoEncodeH265CtbSizeFlagsEXT,
transformBlockSizes: VkVideoEncodeH265TransformBlockSizeFlagsEXT,
maxPPictureL0ReferenceCount: uint32_t,
maxBPictureL0ReferenceCount: uint32_t,
maxL1ReferenceCount: uint32_t,
maxSubLayerCount: uint32_t,
expectDyadicTemporalSubLayerPattern: VkBool32,
minQp: int32_t,
maxQp: int32_t,
prefersGopRemainingFrames: VkBool32,
requiresGopRemainingFrames: VkBool32,
stdSyntaxFlags: VkVideoEncodeH265StdFlagsEXT,
}
struct VkVideoEncodeH265QualityLevelPropertiesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_EXT,
pNext: *mut void,
preferredRateControlFlags: VkVideoEncodeH265RateControlFlagsEXT,
preferredGopFrameCount: uint32_t,
preferredIdrPeriod: uint32_t,
preferredConsecutiveBFrameCount: uint32_t,
preferredSubLayerCount: uint32_t,
preferredConstantQp: VkVideoEncodeH265QpEXT,
preferredMaxL0ReferenceCount: uint32_t,
preferredMaxL1ReferenceCount: uint32_t,
}
struct VkVideoEncodeH265SessionCreateInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_EXT,
pNext: *const void,
useMaxLevelIdc: VkBool32,
maxLevelIdc: StdVideoH265LevelIdc,
}
struct VkVideoEncodeH265SessionParametersAddInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT,
pNext: *const void,
stdVPSCount: uint32_t,
pStdVPSs: *const [StdVideoH265VideoParameterSet; dyn stdVPSCount],
stdSPSCount: uint32_t,
pStdSPSs: *const [StdVideoH265SequenceParameterSet; dyn stdSPSCount],
stdPPSCount: uint32_t,
pStdPPSs: *const [StdVideoH265PictureParameterSet; dyn stdPPSCount],
}
struct VkVideoEncodeH265SessionParametersCreateInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT,
pNext: *const void,
maxStdVPSCount: uint32_t,
maxStdSPSCount: uint32_t,
maxStdPPSCount: uint32_t,
pParametersAddInfo: *const VkVideoEncodeH265SessionParametersAddInfoEXT,
}
struct VkVideoEncodeH265SessionParametersGetInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_EXT,
pNext: *const void,
writeStdVPS: VkBool32,
writeStdSPS: VkBool32,
writeStdPPS: VkBool32,
stdVPSId: uint32_t,
stdSPSId: uint32_t,
stdPPSId: uint32_t,
}
struct VkVideoEncodeH265SessionParametersFeedbackInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_EXT,
pNext: *mut void,
hasStdVPSOverrides: VkBool32,
hasStdSPSOverrides: VkBool32,
hasStdPPSOverrides: VkBool32,
}
struct VkVideoEncodeH265PictureInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_EXT,
pNext: *const void,
naluSliceSegmentEntryCount: uint32_t,
pNaluSliceSegmentEntries: *const [VkVideoEncodeH265NaluSliceSegmentInfoEXT; dyn naluSliceSegmentEntryCount],
pStdPictureInfo: *const StdVideoEncodeH265PictureInfo,
}
struct VkVideoEncodeH265NaluSliceSegmentInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT,
pNext: *const void,
constantQp: int32_t,
pStdSliceSegmentHeader: *const StdVideoEncodeH265SliceSegmentHeader,
}
struct VkVideoEncodeH265RateControlInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT,
pNext: *const void,
flags: VkVideoEncodeH265RateControlFlagsEXT,
gopFrameCount: uint32_t,
idrPeriod: uint32_t,
consecutiveBFrameCount: uint32_t,
subLayerCount: uint32_t,
}
struct VkVideoEncodeH265QpEXT {
qpI: int32_t,
qpP: int32_t,
qpB: int32_t,
}
struct VkVideoEncodeH265FrameSizeEXT {
frameISize: uint32_t,
framePSize: uint32_t,
frameBSize: uint32_t,
}
struct VkVideoEncodeH265GopRemainingFrameInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_EXT,
pNext: *const void,
useGopRemainingFrames: VkBool32,
gopRemainingI: uint32_t,
gopRemainingP: uint32_t,
gopRemainingB: uint32_t,
}
struct VkVideoEncodeH265RateControlLayerInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT,
pNext: *const void,
useMinQp: VkBool32,
minQp: VkVideoEncodeH265QpEXT,
useMaxQp: VkBool32,
maxQp: VkVideoEncodeH265QpEXT,
useMaxFrameSize: VkBool32,
maxFrameSize: VkVideoEncodeH265FrameSizeEXT,
}
struct VkVideoEncodeH265ProfileInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_EXT,
pNext: *const void,
stdProfileIdc: StdVideoH265ProfileIdc,
}
struct VkVideoEncodeH265DpbSlotInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT,
pNext: *const void,
pStdReferenceInfo: *const StdVideoEncodeH265ReferenceInfo,
}
struct VkPhysicalDeviceInheritedViewportScissorFeaturesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV,
pNext: *mut void,
inheritedViewportScissor2D: VkBool32,
}
struct VkCommandBufferInheritanceViewportScissorInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV,
pNext: *const void,
viewportScissor2D: VkBool32,
viewportDepthCount: uint32_t,
pViewportDepths: *const VkViewport,
}
struct VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT,
pNext: *mut void,
ycbcr2plane444Formats: VkBool32,
}
struct VkPhysicalDeviceProvokingVertexFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT,
pNext: *mut void,
provokingVertexLast: VkBool32,
transformFeedbackPreservesProvokingVertex: VkBool32,
}
struct VkPhysicalDeviceProvokingVertexPropertiesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT,
pNext: *mut void,
provokingVertexModePerPipeline: VkBool32,
transformFeedbackPreservesTriangleFanProvokingVertex: VkBool32,
}
struct VkPipelineRasterizationProvokingVertexStateCreateInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT,
pNext: *const void,
provokingVertexMode: VkProvokingVertexModeEXT,
}
struct VkCuModuleCreateInfoNVX {
sType: VkStructureType = VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX,
pNext: *const void,
dataSize: size_t,
pData: *const [void; dyn dataSize],
}
struct VkCuFunctionCreateInfoNVX {
sType: VkStructureType = VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX,
pNext: *const void,
module: VkCuModuleNVX,
pName: *const [char; dyn null-terminated],
}
struct VkCuLaunchInfoNVX {
sType: VkStructureType = VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX,
pNext: *const void,
function: VkCuFunctionNVX,
gridDimX: uint32_t,
gridDimY: uint32_t,
gridDimZ: uint32_t,
blockDimX: uint32_t,
blockDimY: uint32_t,
blockDimZ: uint32_t,
sharedMemBytes: uint32_t,
paramCount: size_t,
pParams: *const [*const void; dyn paramCount],
extraCount: size_t,
pExtras: *const [*const void; dyn extraCount],
}
struct VkPhysicalDeviceDescriptorBufferFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT,
pNext: *mut void,
descriptorBuffer: VkBool32,
descriptorBufferCaptureReplay: VkBool32,
descriptorBufferImageLayoutIgnored: VkBool32,
descriptorBufferPushDescriptors: VkBool32,
}
struct VkPhysicalDeviceDescriptorBufferPropertiesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT,
pNext: *mut void,
combinedImageSamplerDescriptorSingleArray: VkBool32,
bufferlessPushDescriptors: VkBool32,
allowSamplerImageViewPostSubmitCreation: VkBool32,
descriptorBufferOffsetAlignment: VkDeviceSize,
maxDescriptorBufferBindings: uint32_t,
maxResourceDescriptorBufferBindings: uint32_t,
maxSamplerDescriptorBufferBindings: uint32_t,
maxEmbeddedImmutableSamplerBindings: uint32_t,
maxEmbeddedImmutableSamplers: uint32_t,
bufferCaptureReplayDescriptorDataSize: size_t,
imageCaptureReplayDescriptorDataSize: size_t,
imageViewCaptureReplayDescriptorDataSize: size_t,
samplerCaptureReplayDescriptorDataSize: size_t,
accelerationStructureCaptureReplayDescriptorDataSize: size_t,
samplerDescriptorSize: size_t,
combinedImageSamplerDescriptorSize: size_t,
sampledImageDescriptorSize: size_t,
storageImageDescriptorSize: size_t,
uniformTexelBufferDescriptorSize: size_t,
robustUniformTexelBufferDescriptorSize: size_t,
storageTexelBufferDescriptorSize: size_t,
robustStorageTexelBufferDescriptorSize: size_t,
uniformBufferDescriptorSize: size_t,
robustUniformBufferDescriptorSize: size_t,
storageBufferDescriptorSize: size_t,
robustStorageBufferDescriptorSize: size_t,
inputAttachmentDescriptorSize: size_t,
accelerationStructureDescriptorSize: size_t,
maxSamplerDescriptorBufferRange: VkDeviceSize,
maxResourceDescriptorBufferRange: VkDeviceSize,
samplerDescriptorBufferAddressSpaceSize: VkDeviceSize,
resourceDescriptorBufferAddressSpaceSize: VkDeviceSize,
descriptorBufferAddressSpaceSize: VkDeviceSize,
}
struct VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT,
pNext: *mut void,
combinedImageSamplerDensityMapDescriptorSize: size_t,
}
struct VkDescriptorAddressInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT,
pNext: *mut void,
address: VkDeviceAddress,
range: VkDeviceSize,
format: VkFormat,
}
struct VkDescriptorBufferBindingInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT,
pNext: *mut void,
address: VkDeviceAddress,
usage: VkBufferUsageFlags,
}
struct VkDescriptorBufferBindingPushDescriptorBufferHandleEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT,
pNext: *mut void,
buffer: VkBuffer,
}
struct VkDescriptorGetInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT,
pNext: *const void,
type: VkDescriptorType,
data: VkDescriptorDataEXT,
}
struct VkBufferCaptureDescriptorDataInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT,
pNext: *const void,
buffer: VkBuffer,
}
struct VkImageCaptureDescriptorDataInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT,
pNext: *const void,
image: VkImage,
}
struct VkImageViewCaptureDescriptorDataInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT,
pNext: *const void,
imageView: VkImageView,
}
struct VkSamplerCaptureDescriptorDataInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT,
pNext: *const void,
sampler: VkSampler,
}
struct VkAccelerationStructureCaptureDescriptorDataInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT,
pNext: *const void,
accelerationStructure: VkAccelerationStructureKHR,
accelerationStructureNV: VkAccelerationStructureNV,
}
struct VkOpaqueCaptureDescriptorDataCreateInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT,
pNext: *const void,
opaqueCaptureDescriptorData: *const void,
}
struct VkPhysicalDeviceShaderIntegerDotProductFeatures {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES,
pNext: *mut void,
shaderIntegerDotProduct: VkBool32,
}
struct VkPhysicalDeviceShaderIntegerDotProductProperties {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES,
pNext: *mut void,
integerDotProduct8BitUnsignedAccelerated: VkBool32,
integerDotProduct8BitSignedAccelerated: VkBool32,
integerDotProduct8BitMixedSignednessAccelerated: VkBool32,
integerDotProduct4x8BitPackedUnsignedAccelerated: VkBool32,
integerDotProduct4x8BitPackedSignedAccelerated: VkBool32,
integerDotProduct4x8BitPackedMixedSignednessAccelerated: VkBool32,
integerDotProduct16BitUnsignedAccelerated: VkBool32,
integerDotProduct16BitSignedAccelerated: VkBool32,
integerDotProduct16BitMixedSignednessAccelerated: VkBool32,
integerDotProduct32BitUnsignedAccelerated: VkBool32,
integerDotProduct32BitSignedAccelerated: VkBool32,
integerDotProduct32BitMixedSignednessAccelerated: VkBool32,
integerDotProduct64BitUnsignedAccelerated: VkBool32,
integerDotProduct64BitSignedAccelerated: VkBool32,
integerDotProduct64BitMixedSignednessAccelerated: VkBool32,
integerDotProductAccumulatingSaturating8BitUnsignedAccelerated: VkBool32,
integerDotProductAccumulatingSaturating8BitSignedAccelerated: VkBool32,
integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated: VkBool32,
integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated: VkBool32,
integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated: VkBool32,
integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated: VkBool32,
integerDotProductAccumulatingSaturating16BitUnsignedAccelerated: VkBool32,
integerDotProductAccumulatingSaturating16BitSignedAccelerated: VkBool32,
integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated: VkBool32,
integerDotProductAccumulatingSaturating32BitUnsignedAccelerated: VkBool32,
integerDotProductAccumulatingSaturating32BitSignedAccelerated: VkBool32,
integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated: VkBool32,
integerDotProductAccumulatingSaturating64BitUnsignedAccelerated: VkBool32,
integerDotProductAccumulatingSaturating64BitSignedAccelerated: VkBool32,
integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated: VkBool32,
}
struct VkPhysicalDeviceDrmPropertiesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT,
pNext: *mut void,
hasPrimary: VkBool32,
hasRender: VkBool32,
primaryMajor: int64_t,
primaryMinor: int64_t,
renderMajor: int64_t,
renderMinor: int64_t,
}
struct VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR,
pNext: *mut void,
fragmentShaderBarycentric: VkBool32,
}
struct VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR,
pNext: *mut void,
triStripVertexOrderIndependentOfProvokingVertex: VkBool32,
}
struct VkPhysicalDeviceRayTracingMotionBlurFeaturesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV,
pNext: *mut void,
rayTracingMotionBlur: VkBool32,
rayTracingMotionBlurPipelineTraceRaysIndirect: VkBool32,
}
struct VkAccelerationStructureGeometryMotionTrianglesDataNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV,
pNext: *const void,
vertexData: VkDeviceOrHostAddressConstKHR,
}
struct VkAccelerationStructureMotionInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV,
pNext: *const void,
maxInstances: uint32_t,
flags: VkAccelerationStructureMotionInfoFlagsNV,
}
struct VkSRTDataNV {
sx: float,
a: float,
b: float,
pvx: float,
sy: float,
c: float,
pvy: float,
sz: float,
pvz: float,
qx: float,
qy: float,
qz: float,
qw: float,
tx: float,
ty: float,
tz: float,
}
struct VkAccelerationStructureSRTMotionInstanceNV {
transformT0: VkSRTDataNV,
transformT1: VkSRTDataNV,
#[bitfield(24)] instanceCustomIndex: uint32_t,
#[bitfield(8)] mask: uint32_t,
#[bitfield(24)] instanceShaderBindingTableRecordOffset: uint32_t,
#[bitfield(8)] flags: VkGeometryInstanceFlagsKHR,
accelerationStructureReference: uint64_t,
}
struct VkAccelerationStructureMatrixMotionInstanceNV {
transformT0: VkTransformMatrixKHR,
transformT1: VkTransformMatrixKHR,
#[bitfield(24)] instanceCustomIndex: uint32_t,
#[bitfield(8)] mask: uint32_t,
#[bitfield(24)] instanceShaderBindingTableRecordOffset: uint32_t,
#[bitfield(8)] flags: VkGeometryInstanceFlagsKHR,
accelerationStructureReference: uint64_t,
}
struct VkAccelerationStructureMotionInstanceNV {
type: VkAccelerationStructureMotionInstanceTypeNV,
flags: VkAccelerationStructureMotionInstanceFlagsNV,
data: VkAccelerationStructureMotionInstanceDataNV,
}
struct VkMemoryGetRemoteAddressInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV,
pNext: *const void,
memory: VkDeviceMemory,
handleType: VkExternalMemoryHandleTypeFlagBits,
}
struct VkImportMemoryBufferCollectionFUCHSIA {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA,
pNext: *const void,
collection: VkBufferCollectionFUCHSIA,
index: uint32_t,
}
struct VkBufferCollectionImageCreateInfoFUCHSIA {
sType: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA,
pNext: *const void,
collection: VkBufferCollectionFUCHSIA,
index: uint32_t,
}
struct VkBufferCollectionBufferCreateInfoFUCHSIA {
sType: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA,
pNext: *const void,
collection: VkBufferCollectionFUCHSIA,
index: uint32_t,
}
struct VkBufferCollectionCreateInfoFUCHSIA {
sType: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA,
pNext: *const void,
collectionToken: zx_handle_t,
}
struct VkBufferCollectionPropertiesFUCHSIA {
sType: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA,
pNext: *mut void,
memoryTypeBits: uint32_t,
bufferCount: uint32_t,
createInfoIndex: uint32_t,
sysmemPixelFormat: uint64_t,
formatFeatures: VkFormatFeatureFlags,
sysmemColorSpaceIndex: VkSysmemColorSpaceFUCHSIA,
samplerYcbcrConversionComponents: VkComponentMapping,
suggestedYcbcrModel: VkSamplerYcbcrModelConversion,
suggestedYcbcrRange: VkSamplerYcbcrRange,
suggestedXChromaOffset: VkChromaLocation,
suggestedYChromaOffset: VkChromaLocation,
}
struct VkBufferConstraintsInfoFUCHSIA {
sType: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA,
pNext: *const void,
createInfo: VkBufferCreateInfo,
requiredFormatFeatures: VkFormatFeatureFlags,
bufferCollectionConstraints: VkBufferCollectionConstraintsInfoFUCHSIA,
}
struct VkSysmemColorSpaceFUCHSIA {
sType: VkStructureType = VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA,
pNext: *const void,
colorSpace: uint32_t,
}
struct VkImageFormatConstraintsInfoFUCHSIA {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA,
pNext: *const void,
imageCreateInfo: VkImageCreateInfo,
requiredFormatFeatures: VkFormatFeatureFlags,
flags: VkImageFormatConstraintsFlagsFUCHSIA,
sysmemPixelFormat: uint64_t,
colorSpaceCount: uint32_t,
pColorSpaces: *const [VkSysmemColorSpaceFUCHSIA; dyn colorSpaceCount],
}
struct VkImageConstraintsInfoFUCHSIA {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA,
pNext: *const void,
formatConstraintsCount: uint32_t,
pFormatConstraints: *const [VkImageFormatConstraintsInfoFUCHSIA; dyn formatConstraintsCount],
bufferCollectionConstraints: VkBufferCollectionConstraintsInfoFUCHSIA,
flags: VkImageConstraintsInfoFlagsFUCHSIA,
}
struct VkBufferCollectionConstraintsInfoFUCHSIA {
sType: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA,
pNext: *const void,
minBufferCount: uint32_t,
maxBufferCount: uint32_t,
minBufferCountForCamping: uint32_t,
minBufferCountForDedicatedSlack: uint32_t,
minBufferCountForSharedSlack: uint32_t,
}
struct VkCudaModuleCreateInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV,
pNext: *const void,
dataSize: size_t,
pData: *const [void; dyn dataSize],
}
struct VkCudaFunctionCreateInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV,
pNext: *const void,
module: VkCudaModuleNV,
pName: *const [char; dyn null-terminated],
}
struct VkCudaLaunchInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV,
pNext: *const void,
function: VkCudaFunctionNV,
gridDimX: uint32_t,
gridDimY: uint32_t,
gridDimZ: uint32_t,
blockDimX: uint32_t,
blockDimY: uint32_t,
blockDimZ: uint32_t,
sharedMemBytes: uint32_t,
paramCount: size_t,
pParams: *const [*const void; dyn paramCount],
extraCount: size_t,
pExtras: *const [*const void; dyn extraCount],
}
struct VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT,
pNext: *mut void,
formatRgba10x6WithoutYCbCrSampler: VkBool32,
}
struct VkFormatProperties3 {
sType: VkStructureType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3,
pNext: *mut void,
linearTilingFeatures: VkFormatFeatureFlags2,
optimalTilingFeatures: VkFormatFeatureFlags2,
bufferFeatures: VkFormatFeatureFlags2,
}
struct VkDrmFormatModifierPropertiesList2EXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT,
pNext: *mut void,
drmFormatModifierCount: uint32_t,
pDrmFormatModifierProperties: *mut [VkDrmFormatModifierProperties2EXT; dyn drmFormatModifierCount],
}
struct VkDrmFormatModifierProperties2EXT {
drmFormatModifier: uint64_t,
drmFormatModifierPlaneCount: uint32_t,
drmFormatModifierTilingFeatures: VkFormatFeatureFlags2,
}
struct VkAndroidHardwareBufferFormatProperties2ANDROID {
sType: VkStructureType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID,
pNext: *mut void,
format: VkFormat,
externalFormat: uint64_t,
formatFeatures: VkFormatFeatureFlags2,
samplerYcbcrConversionComponents: VkComponentMapping,
suggestedYcbcrModel: VkSamplerYcbcrModelConversion,
suggestedYcbcrRange: VkSamplerYcbcrRange,
suggestedXChromaOffset: VkChromaLocation,
suggestedYChromaOffset: VkChromaLocation,
}
struct VkPipelineRenderingCreateInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO,
pNext: *const void,
viewMask: uint32_t,
colorAttachmentCount: uint32_t,
pColorAttachmentFormats: *const [VkFormat; dyn colorAttachmentCount],
depthAttachmentFormat: VkFormat,
stencilAttachmentFormat: VkFormat,
}
struct VkRenderingInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_RENDERING_INFO,
pNext: *const void,
flags: VkRenderingFlags,
renderArea: VkRect2D,
layerCount: uint32_t,
viewMask: uint32_t,
colorAttachmentCount: uint32_t,
pColorAttachments: *const [VkRenderingAttachmentInfo; dyn colorAttachmentCount],
pDepthAttachment: *const VkRenderingAttachmentInfo,
pStencilAttachment: *const VkRenderingAttachmentInfo,
}
struct VkRenderingAttachmentInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO,
pNext: *const void,
imageView: VkImageView,
imageLayout: VkImageLayout,
resolveMode: VkResolveModeFlagBits,
resolveImageView: VkImageView,
resolveImageLayout: VkImageLayout,
loadOp: VkAttachmentLoadOp,
storeOp: VkAttachmentStoreOp,
clearValue: VkClearValue,
}
struct VkRenderingFragmentShadingRateAttachmentInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR,
pNext: *const void,
imageView: VkImageView,
imageLayout: VkImageLayout,
shadingRateAttachmentTexelSize: VkExtent2D,
}
struct VkRenderingFragmentDensityMapAttachmentInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT,
pNext: *const void,
imageView: VkImageView,
imageLayout: VkImageLayout,
}
struct VkPhysicalDeviceDynamicRenderingFeatures {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES,
pNext: *mut void,
dynamicRendering: VkBool32,
}
struct VkCommandBufferInheritanceRenderingInfo {
sType: VkStructureType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO,
pNext: *const void,
flags: VkRenderingFlags,
viewMask: uint32_t,
colorAttachmentCount: uint32_t,
pColorAttachmentFormats: *const [VkFormat; dyn colorAttachmentCount],
depthAttachmentFormat: VkFormat,
stencilAttachmentFormat: VkFormat,
rasterizationSamples: VkSampleCountFlagBits,
}
struct VkAttachmentSampleCountInfoAMD {
sType: VkStructureType = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD,
pNext: *const void,
colorAttachmentCount: uint32_t,
pColorAttachmentSamples: *const [VkSampleCountFlagBits; dyn colorAttachmentCount],
depthStencilAttachmentSamples: VkSampleCountFlagBits,
}
struct VkMultiviewPerViewAttributesInfoNVX {
sType: VkStructureType = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX,
pNext: *const void,
perViewAttributes: VkBool32,
perViewAttributesPositionXOnly: VkBool32,
}
struct VkPhysicalDeviceImageViewMinLodFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT,
pNext: *mut void,
minLod: VkBool32,
}
struct VkImageViewMinLodCreateInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT,
pNext: *const void,
minLod: float,
}
struct VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT,
pNext: *mut void,
rasterizationOrderColorAttachmentAccess: VkBool32,
rasterizationOrderDepthAttachmentAccess: VkBool32,
rasterizationOrderStencilAttachmentAccess: VkBool32,
}
struct VkPhysicalDeviceLinearColorAttachmentFeaturesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV,
pNext: *mut void,
linearColorAttachment: VkBool32,
}
struct VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT,
pNext: *mut void,
graphicsPipelineLibrary: VkBool32,
}
struct VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT,
pNext: *mut void,
graphicsPipelineLibraryFastLinking: VkBool32,
graphicsPipelineLibraryIndependentInterpolationDecoration: VkBool32,
}
struct VkGraphicsPipelineLibraryCreateInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT,
pNext: *const void,
flags: VkGraphicsPipelineLibraryFlagsEXT,
}
struct VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE,
pNext: *mut void,
descriptorSetHostMapping: VkBool32,
}
struct VkDescriptorSetBindingReferenceVALVE {
sType: VkStructureType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE,
pNext: *const void,
descriptorSetLayout: VkDescriptorSetLayout,
binding: uint32_t,
}
struct VkDescriptorSetLayoutHostMappingInfoVALVE {
sType: VkStructureType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE,
pNext: *mut void,
descriptorOffset: size_t,
descriptorSize: uint32_t,
}
struct VkPhysicalDeviceNestedCommandBufferFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT,
pNext: *mut void,
nestedCommandBuffer: VkBool32,
nestedCommandBufferRendering: VkBool32,
nestedCommandBufferSimultaneousUse: VkBool32,
}
struct VkPhysicalDeviceNestedCommandBufferPropertiesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT,
pNext: *mut void,
maxCommandBufferNestingLevel: uint32_t,
}
struct VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT,
pNext: *mut void,
shaderModuleIdentifier: VkBool32,
}
struct VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT,
pNext: *mut void,
shaderModuleIdentifierAlgorithmUUID: [uint8_t; VK_UUID_SIZE],
}
struct VkPipelineShaderStageModuleIdentifierCreateInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT,
pNext: *const void,
identifierSize: uint32_t,
pIdentifier: *const [uint8_t; dyn identifierSize],
}
struct VkShaderModuleIdentifierEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT,
pNext: *mut void,
identifierSize: uint32_t,
identifier: [uint8_t; VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT],
}
struct VkImageCompressionControlEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT,
pNext: *const void,
flags: VkImageCompressionFlagsEXT,
compressionControlPlaneCount: uint32_t,
pFixedRateFlags: *mut [VkImageCompressionFixedRateFlagsEXT; dyn compressionControlPlaneCount],
}
struct VkPhysicalDeviceImageCompressionControlFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT,
pNext: *mut void,
imageCompressionControl: VkBool32,
}
struct VkImageCompressionPropertiesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT,
pNext: *mut void,
imageCompressionFlags: VkImageCompressionFlagsEXT,
imageCompressionFixedRateFlags: VkImageCompressionFixedRateFlagsEXT,
}
struct VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT,
pNext: *mut void,
imageCompressionControlSwapchain: VkBool32,
}
struct VkImageSubresource2KHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_KHR,
pNext: *mut void,
imageSubresource: VkImageSubresource,
}
struct VkSubresourceLayout2KHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR,
pNext: *mut void,
subresourceLayout: VkSubresourceLayout,
}
struct VkRenderPassCreationControlEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT,
pNext: *const void,
disallowMerging: VkBool32,
}
struct VkRenderPassCreationFeedbackInfoEXT {
postMergeSubpassCount: uint32_t,
}
struct VkRenderPassCreationFeedbackCreateInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT,
pNext: *const void,
pRenderPassFeedback: *mut VkRenderPassCreationFeedbackInfoEXT,
}
struct VkRenderPassSubpassFeedbackInfoEXT {
subpassMergeStatus: VkSubpassMergeStatusEXT,
description: [char; VK_MAX_DESCRIPTION_SIZE],
postMergeIndex: uint32_t,
}
struct VkRenderPassSubpassFeedbackCreateInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT,
pNext: *const void,
pSubpassFeedback: *mut VkRenderPassSubpassFeedbackInfoEXT,
}
struct VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT,
pNext: *mut void,
subpassMergeFeedback: VkBool32,
}
struct VkMicromapBuildInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT,
pNext: *const void,
type: VkMicromapTypeEXT,
flags: VkBuildMicromapFlagsEXT,
mode: VkBuildMicromapModeEXT,
dstMicromap: VkMicromapEXT,
usageCountsCount: uint32_t,
pUsageCounts: *const [VkMicromapUsageEXT; dyn usageCountsCount],
ppUsageCounts: *const [*const VkMicromapUsageEXT; dyn usageCountsCount,1],
data: VkDeviceOrHostAddressConstKHR,
scratchData: VkDeviceOrHostAddressKHR,
triangleArray: VkDeviceOrHostAddressConstKHR,
triangleArrayStride: VkDeviceSize,
}
struct VkMicromapCreateInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT,
pNext: *const void,
createFlags: VkMicromapCreateFlagsEXT,
buffer: VkBuffer,
offset: VkDeviceSize,
size: VkDeviceSize,
type: VkMicromapTypeEXT,
deviceAddress: VkDeviceAddress,
}
struct VkMicromapVersionInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT,
pNext: *const void,
pVersionData: *const [uint8_t; dyn 2*VK_UUID_SIZE],
}
struct VkCopyMicromapInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT,
pNext: *const void,
src: VkMicromapEXT,
dst: VkMicromapEXT,
mode: VkCopyMicromapModeEXT,
}
struct VkCopyMicromapToMemoryInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT,
pNext: *const void,
src: VkMicromapEXT,
dst: VkDeviceOrHostAddressKHR,
mode: VkCopyMicromapModeEXT,
}
struct VkCopyMemoryToMicromapInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT,
pNext: *const void,
src: VkDeviceOrHostAddressConstKHR,
dst: VkMicromapEXT,
mode: VkCopyMicromapModeEXT,
}
struct VkMicromapBuildSizesInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT,
pNext: *const void,
micromapSize: VkDeviceSize,
buildScratchSize: VkDeviceSize,
discardable: VkBool32,
}
struct VkMicromapUsageEXT {
count: uint32_t,
subdivisionLevel: uint32_t,
format: uint32_t,
}
struct VkMicromapTriangleEXT {
dataOffset: uint32_t,
subdivisionLevel: uint16_t,
format: uint16_t,
}
struct VkPhysicalDeviceOpacityMicromapFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT,
pNext: *mut void,
micromap: VkBool32,
micromapCaptureReplay: VkBool32,
micromapHostCommands: VkBool32,
}
struct VkPhysicalDeviceOpacityMicromapPropertiesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT,
pNext: *mut void,
maxOpacity2StateSubdivisionLevel: uint32_t,
maxOpacity4StateSubdivisionLevel: uint32_t,
}
struct VkAccelerationStructureTrianglesOpacityMicromapEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT,
pNext: *mut void,
indexType: VkIndexType,
indexBuffer: VkDeviceOrHostAddressConstKHR,
indexStride: VkDeviceSize,
baseTriangle: uint32_t,
usageCountsCount: uint32_t,
pUsageCounts: *const [VkMicromapUsageEXT; dyn usageCountsCount],
ppUsageCounts: *const [*const VkMicromapUsageEXT; dyn usageCountsCount,1],
micromap: VkMicromapEXT,
}
struct VkPhysicalDeviceDisplacementMicromapFeaturesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV,
pNext: *mut void,
displacementMicromap: VkBool32,
}
struct VkPhysicalDeviceDisplacementMicromapPropertiesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV,
pNext: *mut void,
maxDisplacementMicromapSubdivisionLevel: uint32_t,
}
struct VkAccelerationStructureTrianglesDisplacementMicromapNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV,
pNext: *mut void,
displacementBiasAndScaleFormat: VkFormat,
displacementVectorFormat: VkFormat,
displacementBiasAndScaleBuffer: VkDeviceOrHostAddressConstKHR,
displacementBiasAndScaleStride: VkDeviceSize,
displacementVectorBuffer: VkDeviceOrHostAddressConstKHR,
displacementVectorStride: VkDeviceSize,
displacedMicromapPrimitiveFlags: VkDeviceOrHostAddressConstKHR,
displacedMicromapPrimitiveFlagsStride: VkDeviceSize,
indexType: VkIndexType,
indexBuffer: VkDeviceOrHostAddressConstKHR,
indexStride: VkDeviceSize,
baseTriangle: uint32_t,
usageCountsCount: uint32_t,
pUsageCounts: *const [VkMicromapUsageEXT; dyn usageCountsCount],
ppUsageCounts: *const [*const VkMicromapUsageEXT; dyn usageCountsCount,1],
micromap: VkMicromapEXT,
}
struct VkPipelinePropertiesIdentifierEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT,
pNext: *mut void,
pipelineIdentifier: [uint8_t; VK_UUID_SIZE],
}
struct VkPhysicalDevicePipelinePropertiesFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT,
pNext: *mut void,
pipelinePropertiesIdentifier: VkBool32,
}
struct VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD,
pNext: *mut void,
shaderEarlyAndLateFragmentTests: VkBool32,
}
struct VkExternalMemoryAcquireUnmodifiedEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT,
pNext: *const void,
acquireUnmodifiedMemory: VkBool32,
}
struct VkExportMetalObjectCreateInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT,
pNext: *const void,
exportObjectType: VkExportMetalObjectTypeFlagBitsEXT,
}
struct VkExportMetalObjectsInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT,
pNext: *const void,
}
struct VkExportMetalDeviceInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT,
pNext: *const void,
mtlDevice: MTLDevice_id,
}
struct VkExportMetalCommandQueueInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT,
pNext: *const void,
queue: VkQueue,
mtlCommandQueue: MTLCommandQueue_id,
}
struct VkExportMetalBufferInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT,
pNext: *const void,
memory: VkDeviceMemory,
mtlBuffer: MTLBuffer_id,
}
struct VkImportMetalBufferInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT,
pNext: *const void,
mtlBuffer: MTLBuffer_id,
}
struct VkExportMetalTextureInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT,
pNext: *const void,
image: VkImage,
imageView: VkImageView,
bufferView: VkBufferView,
plane: VkImageAspectFlagBits,
mtlTexture: MTLTexture_id,
}
struct VkImportMetalTextureInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT,
pNext: *const void,
plane: VkImageAspectFlagBits,
mtlTexture: MTLTexture_id,
}
struct VkExportMetalIOSurfaceInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT,
pNext: *const void,
image: VkImage,
ioSurface: IOSurfaceRef,
}
struct VkImportMetalIOSurfaceInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT,
pNext: *const void,
ioSurface: IOSurfaceRef,
}
struct VkExportMetalSharedEventInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT,
pNext: *const void,
semaphore: VkSemaphore,
event: VkEvent,
mtlSharedEvent: MTLSharedEvent_id,
}
struct VkImportMetalSharedEventInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT,
pNext: *const void,
mtlSharedEvent: MTLSharedEvent_id,
}
struct VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT,
pNext: *mut void,
nonSeamlessCubeMap: VkBool32,
}
struct VkPhysicalDevicePipelineRobustnessFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT,
pNext: *mut void,
pipelineRobustness: VkBool32,
}
struct VkPipelineRobustnessCreateInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT,
pNext: *const void,
storageBuffers: VkPipelineRobustnessBufferBehaviorEXT,
uniformBuffers: VkPipelineRobustnessBufferBehaviorEXT,
vertexInputs: VkPipelineRobustnessBufferBehaviorEXT,
images: VkPipelineRobustnessImageBehaviorEXT,
}
struct VkPhysicalDevicePipelineRobustnessPropertiesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT,
pNext: *mut void,
defaultRobustnessStorageBuffers: VkPipelineRobustnessBufferBehaviorEXT,
defaultRobustnessUniformBuffers: VkPipelineRobustnessBufferBehaviorEXT,
defaultRobustnessVertexInputs: VkPipelineRobustnessBufferBehaviorEXT,
defaultRobustnessImages: VkPipelineRobustnessImageBehaviorEXT,
}
struct VkImageViewSampleWeightCreateInfoQCOM {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM,
pNext: *const void,
filterCenter: VkOffset2D,
filterSize: VkExtent2D,
numPhases: uint32_t,
}
struct VkPhysicalDeviceImageProcessingFeaturesQCOM {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM,
pNext: *mut void,
textureSampleWeighted: VkBool32,
textureBoxFilter: VkBool32,
textureBlockMatch: VkBool32,
}
struct VkPhysicalDeviceImageProcessingPropertiesQCOM {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM,
pNext: *mut void,
maxWeightFilterPhases: uint32_t,
maxWeightFilterDimension: VkExtent2D,
maxBlockMatchRegion: VkExtent2D,
maxBoxFilterBlockSize: VkExtent2D,
}
struct VkPhysicalDeviceTilePropertiesFeaturesQCOM {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM,
pNext: *mut void,
tileProperties: VkBool32,
}
struct VkTilePropertiesQCOM {
sType: VkStructureType = VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM,
pNext: *mut void,
tileSize: VkExtent3D,
apronSize: VkExtent2D,
origin: VkOffset2D,
}
struct VkPhysicalDeviceAmigoProfilingFeaturesSEC {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC,
pNext: *mut void,
amigoProfiling: VkBool32,
}
struct VkAmigoProfilingSubmitInfoSEC {
sType: VkStructureType = VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC,
pNext: *const void,
firstDrawTimestamp: uint64_t,
swapBufferTimestamp: uint64_t,
}
struct VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT,
pNext: *mut void,
attachmentFeedbackLoopLayout: VkBool32,
}
struct VkPhysicalDeviceDepthClampZeroOneFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT,
pNext: *mut void,
depthClampZeroOne: VkBool32,
}
struct VkPhysicalDeviceAddressBindingReportFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT,
pNext: *mut void,
reportAddressBinding: VkBool32,
}
struct VkDeviceAddressBindingCallbackDataEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT,
pNext: *mut void,
flags: VkDeviceAddressBindingFlagsEXT,
baseAddress: VkDeviceAddress,
size: VkDeviceSize,
bindingType: VkDeviceAddressBindingTypeEXT,
}
struct VkPhysicalDeviceOpticalFlowFeaturesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV,
pNext: *mut void,
opticalFlow: VkBool32,
}
struct VkPhysicalDeviceOpticalFlowPropertiesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV,
pNext: *mut void,
supportedOutputGridSizes: VkOpticalFlowGridSizeFlagsNV,
supportedHintGridSizes: VkOpticalFlowGridSizeFlagsNV,
hintSupported: VkBool32,
costSupported: VkBool32,
bidirectionalFlowSupported: VkBool32,
globalFlowSupported: VkBool32,
minWidth: uint32_t,
minHeight: uint32_t,
maxWidth: uint32_t,
maxHeight: uint32_t,
maxNumRegionsOfInterest: uint32_t,
}
struct VkOpticalFlowImageFormatInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV,
pNext: *const void,
usage: VkOpticalFlowUsageFlagsNV,
}
struct VkOpticalFlowImageFormatPropertiesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV,
pNext: *const void,
format: VkFormat,
}
struct VkOpticalFlowSessionCreateInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV,
pNext: *mut void,
width: uint32_t,
height: uint32_t,
imageFormat: VkFormat,
flowVectorFormat: VkFormat,
costFormat: VkFormat,
outputGridSize: VkOpticalFlowGridSizeFlagsNV,
hintGridSize: VkOpticalFlowGridSizeFlagsNV,
performanceLevel: VkOpticalFlowPerformanceLevelNV,
flags: VkOpticalFlowSessionCreateFlagsNV,
}
struct VkOpticalFlowSessionCreatePrivateDataInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV,
pNext: *mut void,
id: uint32_t,
size: uint32_t,
pPrivateData: *const void,
}
struct VkOpticalFlowExecuteInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV,
pNext: *mut void,
flags: VkOpticalFlowExecuteFlagsNV,
regionCount: uint32_t,
pRegions: *const [VkRect2D; dyn regionCount],
}
struct VkPhysicalDeviceFaultFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT,
pNext: *mut void,
deviceFault: VkBool32,
deviceFaultVendorBinary: VkBool32,
}
struct VkDeviceFaultAddressInfoEXT {
addressType: VkDeviceFaultAddressTypeEXT,
reportedAddress: VkDeviceAddress,
addressPrecision: VkDeviceSize,
}
struct VkDeviceFaultVendorInfoEXT {
description: [char; VK_MAX_DESCRIPTION_SIZE],
vendorFaultCode: uint64_t,
vendorFaultData: uint64_t,
}
struct VkDeviceFaultCountsEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT,
pNext: *mut void,
addressInfoCount: uint32_t,
vendorInfoCount: uint32_t,
vendorBinarySize: VkDeviceSize,
}
struct VkDeviceFaultInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT,
pNext: *mut void,
description: [char; VK_MAX_DESCRIPTION_SIZE],
pAddressInfos: *mut VkDeviceFaultAddressInfoEXT,
pVendorInfos: *mut VkDeviceFaultVendorInfoEXT,
pVendorBinaryData: *mut void,
}
struct VkDeviceFaultVendorBinaryHeaderVersionOneEXT {
headerSize: uint32_t,
headerVersion: VkDeviceFaultVendorBinaryHeaderVersionEXT,
vendorID: uint32_t,
deviceID: uint32_t,
driverVersion: uint32_t,
pipelineCacheUUID: [uint8_t; VK_UUID_SIZE],
applicationNameOffset: uint32_t,
applicationVersion: uint32_t,
engineNameOffset: uint32_t,
engineVersion: uint32_t,
apiVersion: uint32_t,
}
struct VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT,
pNext: *mut void,
pipelineLibraryGroupHandles: VkBool32,
}
struct VkDepthBiasInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_DEPTH_BIAS_INFO_EXT,
pNext: *const void,
depthBiasConstantFactor: float,
depthBiasClamp: float,
depthBiasSlopeFactor: float,
}
struct VkDepthBiasRepresentationInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT,
pNext: *const void,
depthBiasRepresentation: VkDepthBiasRepresentationEXT,
depthBiasExact: VkBool32,
}
struct VkDecompressMemoryRegionNV {
srcAddress: VkDeviceAddress,
dstAddress: VkDeviceAddress,
compressedSize: VkDeviceSize,
decompressedSize: VkDeviceSize,
decompressionMethod: VkMemoryDecompressionMethodFlagsNV,
}
struct VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM,
pNext: *mut void,
shaderCoreMask: uint64_t,
shaderCoreCount: uint32_t,
shaderWarpsPerCore: uint32_t,
}
struct VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM,
pNext: *mut void,
shaderCoreBuiltins: VkBool32,
}
struct VkFrameBoundaryEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT,
pNext: *const void,
flags: VkFrameBoundaryFlagsEXT,
frameID: uint64_t,
imageCount: uint32_t,
pImages: *const [VkImage; dyn imageCount],
bufferCount: uint32_t,
pBuffers: *const [VkBuffer; dyn bufferCount],
tagName: uint64_t,
tagSize: size_t,
pTag: *const [void; dyn tagSize],
}
struct VkPhysicalDeviceFrameBoundaryFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT,
pNext: *mut void,
frameBoundary: VkBool32,
}
struct VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT,
pNext: *mut void,
dynamicRenderingUnusedAttachments: VkBool32,
}
struct VkSurfacePresentModeEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT,
pNext: *mut void,
presentMode: VkPresentModeKHR,
}
struct VkSurfacePresentScalingCapabilitiesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT,
pNext: *mut void,
supportedPresentScaling: VkPresentScalingFlagsEXT,
supportedPresentGravityX: VkPresentGravityFlagsEXT,
supportedPresentGravityY: VkPresentGravityFlagsEXT,
minScaledImageExtent: VkExtent2D,
maxScaledImageExtent: VkExtent2D,
}
struct VkSurfacePresentModeCompatibilityEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT,
pNext: *mut void,
presentModeCount: uint32_t,
pPresentModes: *mut [VkPresentModeKHR; dyn presentModeCount],
}
struct VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT,
pNext: *mut void,
swapchainMaintenance1: VkBool32,
}
struct VkSwapchainPresentFenceInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT,
pNext: *const void,
swapchainCount: uint32_t,
pFences: *const [VkFence; dyn swapchainCount],
}
struct VkSwapchainPresentModesCreateInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT,
pNext: *const void,
presentModeCount: uint32_t,
pPresentModes: *const [VkPresentModeKHR; dyn presentModeCount],
}
struct VkSwapchainPresentModeInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT,
pNext: *const void,
swapchainCount: uint32_t,
pPresentModes: *const [VkPresentModeKHR; dyn swapchainCount],
}
struct VkSwapchainPresentScalingCreateInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT,
pNext: *const void,
scalingBehavior: VkPresentScalingFlagsEXT,
presentGravityX: VkPresentGravityFlagsEXT,
presentGravityY: VkPresentGravityFlagsEXT,
}
struct VkReleaseSwapchainImagesInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_EXT,
pNext: *const void,
swapchain: VkSwapchainKHR,
imageIndexCount: uint32_t,
pImageIndices: *const [uint32_t; dyn imageIndexCount],
}
struct VkPhysicalDeviceDepthBiasControlFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT,
pNext: *mut void,
depthBiasControl: VkBool32,
leastRepresentableValueForceUnormRepresentation: VkBool32,
floatRepresentation: VkBool32,
depthBiasExact: VkBool32,
}
struct VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV,
pNext: *mut void,
rayTracingInvocationReorder: VkBool32,
}
struct VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV,
pNext: *mut void,
rayTracingInvocationReorderReorderingHint: VkRayTracingInvocationReorderModeNV,
}
struct VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV,
pNext: *mut void,
extendedSparseAddressSpace: VkBool32,
}
struct VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV,
pNext: *mut void,
extendedSparseAddressSpaceSize: VkDeviceSize,
extendedSparseImageUsageFlags: VkImageUsageFlags,
extendedSparseBufferUsageFlags: VkBufferUsageFlags,
}
struct VkDirectDriverLoadingInfoLUNARG {
sType: VkStructureType = VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG,
pNext: *mut void,
flags: VkDirectDriverLoadingFlagsLUNARG,
pfnGetInstanceProcAddr: PFN_vkGetInstanceProcAddrLUNARG,
}
struct VkDirectDriverLoadingListLUNARG {
sType: VkStructureType = VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG,
pNext: *const void,
mode: VkDirectDriverLoadingModeLUNARG,
driverCount: uint32_t,
pDrivers: *const [VkDirectDriverLoadingInfoLUNARG; dyn driverCount],
}
struct VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM,
pNext: *mut void,
multiviewPerViewViewports: VkBool32,
}
struct VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR,
pNext: *mut void,
rayTracingPositionFetch: VkBool32,
}
struct VkDeviceImageSubresourceInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO_KHR,
pNext: *const void,
pCreateInfo: *const VkImageCreateInfo,
pSubresource: *const VkImageSubresource2KHR,
}
struct VkPhysicalDeviceShaderCorePropertiesARM {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM,
pNext: *mut void,
pixelRate: uint32_t,
texelRate: uint32_t,
fmaRate: uint32_t,
}
struct VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM,
pNext: *mut void,
multiviewPerViewRenderAreas: VkBool32,
}
struct VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM {
sType: VkStructureType = VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM,
pNext: *const void,
perViewRenderAreaCount: uint32_t,
pPerViewRenderAreas: *const [VkRect2D; dyn perViewRenderAreaCount],
}
struct VkQueryLowLatencySupportNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV,
pNext: *const void,
pQueriedLowLatencyData: *mut void,
}
struct VkMemoryMapInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_MAP_INFO_KHR,
pNext: *const void,
flags: VkMemoryMapFlags,
memory: VkDeviceMemory,
offset: VkDeviceSize,
size: VkDeviceSize,
}
struct VkMemoryUnmapInfoKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR,
pNext: *const void,
flags: VkMemoryUnmapFlagsKHR,
memory: VkDeviceMemory,
}
struct VkPhysicalDeviceShaderObjectFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT,
pNext: *mut void,
shaderObject: VkBool32,
}
struct VkPhysicalDeviceShaderObjectPropertiesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT,
pNext: *mut void,
shaderBinaryUUID: [uint8_t; VK_UUID_SIZE],
shaderBinaryVersion: uint32_t,
}
struct VkShaderCreateInfoEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT,
pNext: *const void,
flags: VkShaderCreateFlagsEXT,
stage: VkShaderStageFlagBits,
nextStage: VkShaderStageFlags,
codeType: VkShaderCodeTypeEXT,
codeSize: size_t,
pCode: *const [void; dyn codeSize],
pName: *const [char; dyn null-terminated],
setLayoutCount: uint32_t,
pSetLayouts: *const [VkDescriptorSetLayout; dyn setLayoutCount],
pushConstantRangeCount: uint32_t,
pPushConstantRanges: *const [VkPushConstantRange; dyn pushConstantRangeCount],
pSpecializationInfo: *const VkSpecializationInfo,
}
struct VkPhysicalDeviceShaderTileImageFeaturesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT,
pNext: *mut void,
shaderTileImageColorReadAccess: VkBool32,
shaderTileImageDepthReadAccess: VkBool32,
shaderTileImageStencilReadAccess: VkBool32,
}
struct VkPhysicalDeviceShaderTileImagePropertiesEXT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT,
pNext: *mut void,
shaderTileImageCoherentReadAccelerated: VkBool32,
shaderTileImageReadSampleFromPixelRateInvocation: VkBool32,
shaderTileImageReadFromHelperInvocation: VkBool32,
}
struct VkImportScreenBufferInfoQNX {
sType: VkStructureType = VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX,
pNext: *const void,
buffer: *mut /*struct*/_screen_buffer,
}
struct VkScreenBufferPropertiesQNX {
sType: VkStructureType = VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX,
pNext: *mut void,
allocationSize: VkDeviceSize,
memoryTypeBits: uint32_t,
}
struct VkScreenBufferFormatPropertiesQNX {
sType: VkStructureType = VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX,
pNext: *mut void,
format: VkFormat,
externalFormat: uint64_t,
screenUsage: uint64_t,
formatFeatures: VkFormatFeatureFlags,
samplerYcbcrConversionComponents: VkComponentMapping,
suggestedYcbcrModel: VkSamplerYcbcrModelConversion,
suggestedYcbcrRange: VkSamplerYcbcrRange,
suggestedXChromaOffset: VkChromaLocation,
suggestedYChromaOffset: VkChromaLocation,
}
struct VkExternalFormatQNX {
sType: VkStructureType = VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX,
pNext: *mut void,
externalFormat: uint64_t,
}
struct VkPhysicalDeviceExternalMemoryScreenBufferFeaturesQNX {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX,
pNext: *mut void,
screenBufferImport: VkBool32,
}
struct VkPhysicalDeviceCooperativeMatrixFeaturesKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR,
pNext: *mut void,
cooperativeMatrix: VkBool32,
cooperativeMatrixRobustBufferAccess: VkBool32,
}
struct VkCooperativeMatrixPropertiesKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR,
pNext: *mut void,
MSize: uint32_t,
NSize: uint32_t,
KSize: uint32_t,
AType: VkComponentTypeKHR,
BType: VkComponentTypeKHR,
CType: VkComponentTypeKHR,
ResultType: VkComponentTypeKHR,
saturatingAccumulation: VkBool32,
scope: VkScopeKHR,
}
struct VkPhysicalDeviceCooperativeMatrixPropertiesKHR {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR,
pNext: *mut void,
cooperativeMatrixSupportedStages: VkShaderStageFlags,
}
struct VkPhysicalDeviceShaderEnqueuePropertiesAMDX {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_PROPERTIES_AMDX,
pNext: *mut void,
maxExecutionGraphDepth: uint32_t,
maxExecutionGraphShaderOutputNodes: uint32_t,
maxExecutionGraphShaderPayloadSize: uint32_t,
maxExecutionGraphShaderPayloadCount: uint32_t,
executionGraphDispatchAddressAlignment: uint32_t,
}
struct VkPhysicalDeviceShaderEnqueueFeaturesAMDX {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ENQUEUE_FEATURES_AMDX,
pNext: *mut void,
shaderEnqueue: VkBool32,
}
struct VkExecutionGraphPipelineCreateInfoAMDX {
sType: VkStructureType = VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_CREATE_INFO_AMDX,
pNext: *const void,
flags: VkPipelineCreateFlags,
stageCount: uint32_t,
pStages: *const [VkPipelineShaderStageCreateInfo; dyn stageCount],
pLibraryInfo: *const VkPipelineLibraryCreateInfoKHR,
layout: VkPipelineLayout,
basePipelineHandle: VkPipeline,
basePipelineIndex: int32_t,
}
struct VkPipelineShaderStageNodeCreateInfoAMDX {
sType: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_NODE_CREATE_INFO_AMDX,
pNext: *const void,
pName: *const [char; dyn null-terminated],
index: uint32_t,
}
struct VkExecutionGraphPipelineScratchSizeAMDX {
sType: VkStructureType = VK_STRUCTURE_TYPE_EXECUTION_GRAPH_PIPELINE_SCRATCH_SIZE_AMDX,
pNext: *mut void,
size: VkDeviceSize,
}
struct VkDispatchGraphInfoAMDX {
nodeIndex: uint32_t,
payloadCount: uint32_t,
payloads: VkDeviceOrHostAddressConstAMDX,
payloadStride: uint64_t,
}
struct VkDispatchGraphCountInfoAMDX {
count: uint32_t,
infos: VkDeviceOrHostAddressConstAMDX,
stride: uint64_t,
}
struct VkPhysicalDeviceCubicClampFeaturesQCOM {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM,
pNext: *mut void,
cubicRangeClamp: VkBool32,
}
struct VkPhysicalDeviceYcbcrDegammaFeaturesQCOM {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM,
pNext: *mut void,
ycbcrDegamma: VkBool32,
}
struct VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM {
sType: VkStructureType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM,
pNext: *mut void,
enableYDegamma: VkBool32,
enableCbCrDegamma: VkBool32,
}
struct VkPhysicalDeviceCubicWeightsFeaturesQCOM {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM,
pNext: *mut void,
selectableCubicWeights: VkBool32,
}
struct VkSamplerCubicWeightsCreateInfoQCOM {
sType: VkStructureType = VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM,
pNext: *const void,
cubicWeights: VkCubicFilterWeightsQCOM,
}
struct VkBlitImageCubicWeightsInfoQCOM {
sType: VkStructureType = VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM,
pNext: *const void,
cubicWeights: VkCubicFilterWeightsQCOM,
}
struct VkPhysicalDeviceImageProcessing2FeaturesQCOM {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM,
pNext: *mut void,
textureBlockMatch2: VkBool32,
}
struct VkPhysicalDeviceImageProcessing2PropertiesQCOM {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM,
pNext: *mut void,
maxBlockMatchWindow: VkExtent2D,
}
struct VkSamplerBlockMatchWindowCreateInfoQCOM {
sType: VkStructureType = VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM,
pNext: *const void,
windowExtent: VkExtent2D,
windowCompareMode: VkBlockMatchWindowCompareModeQCOM,
}
struct VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV,
pNext: *mut void,
descriptorPoolOverallocation: VkBool32,
}
struct VkPhysicalDeviceLayeredDriverPropertiesMSFT {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT,
pNext: *mut void,
underlyingAPI: VkLayeredDriverUnderlyingApiMSFT,
}
struct VkPhysicalDeviceExternalFormatResolveFeaturesANDROID {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID,
pNext: *mut void,
externalFormatResolve: VkBool32,
}
struct VkPhysicalDeviceExternalFormatResolvePropertiesANDROID {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID,
pNext: *mut void,
nullColorAttachmentWithExternalFormatResolve: VkBool32,
externalFormatResolveChromaOffsetX: VkChromaLocation,
externalFormatResolveChromaOffsetY: VkChromaLocation,
}
struct VkAndroidHardwareBufferFormatResolvePropertiesANDROID {
sType: VkStructureType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID,
pNext: *mut void,
colorAttachmentFormat: VkFormat,
}
struct VkLatencySleepModeInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV,
pNext: *const void,
lowLatencyMode: VkBool32,
lowLatencyBoost: VkBool32,
minimumIntervalUs: uint32_t,
}
struct VkLatencySleepInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV,
pNext: *const void,
signalSemaphore: VkSemaphore,
value: uint64_t,
}
struct VkSetLatencyMarkerInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV,
pNext: *const void,
presentID: uint64_t,
marker: VkLatencyMarkerNV,
}
struct VkGetLatencyMarkerInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_GET_LATENCY_MARKER_INFO_NV,
pNext: *const void,
timingCount: uint32_t,
pTimings: *mut [VkLatencyTimingsFrameReportNV; dyn timingCount],
}
struct VkLatencyTimingsFrameReportNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_LATENCY_TIMINGS_FRAME_REPORT_NV,
pNext: *const void,
presentID: uint64_t,
inputSampleTimeUs: uint64_t,
simStartTimeUs: uint64_t,
simEndTimeUs: uint64_t,
renderSubmitStartTimeUs: uint64_t,
renderSubmitEndTimeUs: uint64_t,
presentStartTimeUs: uint64_t,
presentEndTimeUs: uint64_t,
driverStartTimeUs: uint64_t,
driverEndTimeUs: uint64_t,
osRenderQueueStartTimeUs: uint64_t,
osRenderQueueEndTimeUs: uint64_t,
gpuRenderStartTimeUs: uint64_t,
gpuRenderEndTimeUs: uint64_t,
}
struct VkOutOfBandQueueTypeInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_OUT_OF_BAND_QUEUE_TYPE_INFO_NV,
pNext: *const void,
queueType: VkOutOfBandQueueTypeNV,
}
struct VkLatencySubmissionPresentIdNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV,
pNext: *const void,
presentID: uint64_t,
}
struct VkSwapchainLatencyCreateInfoNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV,
pNext: *const void,
latencyModeEnable: VkBool32,
}
struct VkLatencySurfaceCapabilitiesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV,
pNext: *const void,
presentModeCount: uint32_t,
pPresentModes: *mut [VkPresentModeKHR; dyn presentModeCount],
}
struct VkPhysicalDeviceCudaKernelLaunchFeaturesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV,
pNext: *mut void,
cudaKernelLaunchFeatures: VkBool32,
}
struct VkPhysicalDeviceCudaKernelLaunchPropertiesNV {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV,
pNext: *mut void,
computeCapabilityMinor: uint32_t,
computeCapabilityMajor: uint32_t,
}
struct VkDeviceQueueShaderCoreControlCreateInfoARM {
sType: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM,
pNext: *mut void,
shaderCoreCount: uint32_t,
}
struct VkPhysicalDeviceSchedulingControlsFeaturesARM {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM,
pNext: *mut void,
schedulingControls: VkBool32,
}
struct VkPhysicalDeviceSchedulingControlsPropertiesARM {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM,
pNext: *mut void,
schedulingControlsFlags: VkPhysicalDeviceSchedulingControlsFlagsARM,
}
struct VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG {
sType: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG,
pNext: *mut void,
relaxedLineRasterization: VkBool32,
}
unsafe extern fn vkCreateInstance(
pCreateInfo: *const VkInstanceCreateInfo,
pAllocator: *const VkAllocationCallbacks,
pInstance: *mut VkInstance,
) -> VkResult;
unsafe extern fn vkDestroyInstance(
instance: VkInstance,
pAllocator: *const VkAllocationCallbacks,
);
unsafe extern fn vkEnumeratePhysicalDevices(
instance: VkInstance,
pPhysicalDeviceCount: *mut uint32_t,
pPhysicalDevices: *mut [VkPhysicalDevice; dyn pPhysicalDeviceCount],
) -> VkResult;
unsafe extern fn vkGetDeviceProcAddr(
device: VkDevice,
pName: *const [char; dyn null-terminated],
) -> PFN_vkVoidFunction;
unsafe extern fn vkGetInstanceProcAddr(
instance: VkInstance,
pName: *const [char; dyn null-terminated],
) -> PFN_vkVoidFunction;
unsafe extern fn vkGetPhysicalDeviceProperties(
physicalDevice: VkPhysicalDevice,
pProperties: *mut VkPhysicalDeviceProperties,
);
unsafe extern fn vkGetPhysicalDeviceQueueFamilyProperties(
physicalDevice: VkPhysicalDevice,
pQueueFamilyPropertyCount: *mut uint32_t,
pQueueFamilyProperties: *mut [VkQueueFamilyProperties; dyn pQueueFamilyPropertyCount],
);
unsafe extern fn vkGetPhysicalDeviceMemoryProperties(
physicalDevice: VkPhysicalDevice,
pMemoryProperties: *mut VkPhysicalDeviceMemoryProperties,
);
unsafe extern fn vkGetPhysicalDeviceFeatures(
physicalDevice: VkPhysicalDevice,
pFeatures: *mut VkPhysicalDeviceFeatures,
);
unsafe extern fn vkGetPhysicalDeviceFormatProperties(
physicalDevice: VkPhysicalDevice,
format: VkFormat,
pFormatProperties: *mut VkFormatProperties,
);
unsafe extern fn vkGetPhysicalDeviceImageFormatProperties(
physicalDevice: VkPhysicalDevice,
format: VkFormat,
type: VkImageType,
tiling: VkImageTiling,
usage: VkImageUsageFlags,
flags: VkImageCreateFlags,
pImageFormatProperties: *mut VkImageFormatProperties,
) -> VkResult;
unsafe extern fn vkCreateDevice(
physicalDevice: VkPhysicalDevice,
pCreateInfo: *const VkDeviceCreateInfo,
pAllocator: *const VkAllocationCallbacks,
pDevice: *mut VkDevice,
) -> VkResult;
unsafe extern fn vkDestroyDevice(
device: VkDevice,
pAllocator: *const VkAllocationCallbacks,
);
unsafe extern fn vkEnumerateInstanceVersion(
pApiVersion: *mut uint32_t,
) -> VkResult;
unsafe extern fn vkEnumerateInstanceLayerProperties(
pPropertyCount: *mut uint32_t,
pProperties: *mut [VkLayerProperties; dyn pPropertyCount],
) -> VkResult;
unsafe extern fn vkEnumerateInstanceExtensionProperties(
pLayerName: *const [char; dyn null-terminated],
pPropertyCount: *mut uint32_t,
pProperties: *mut [VkExtensionProperties; dyn pPropertyCount],
) -> VkResult;
unsafe extern fn vkEnumerateDeviceLayerProperties(
physicalDevice: VkPhysicalDevice,
pPropertyCount: *mut uint32_t,
pProperties: *mut [VkLayerProperties; dyn pPropertyCount],
) -> VkResult;
unsafe extern fn vkEnumerateDeviceExtensionProperties(
physicalDevice: VkPhysicalDevice,
pLayerName: *const [char; dyn null-terminated],
pPropertyCount: *mut uint32_t,
pProperties: *mut [VkExtensionProperties; dyn pPropertyCount],
) -> VkResult;
unsafe extern fn vkGetDeviceQueue(
device: VkDevice,
queueFamilyIndex: uint32_t,
queueIndex: uint32_t,
pQueue: *mut VkQueue,
);
unsafe extern fn vkQueueSubmit(
queue: VkQueue,
submitCount: uint32_t,
pSubmits: *const [VkSubmitInfo; dyn submitCount],
fence: VkFence,
) -> VkResult;
unsafe extern fn vkQueueWaitIdle(
queue: VkQueue,
) -> VkResult;
unsafe extern fn vkDeviceWaitIdle(
device: VkDevice,
) -> VkResult;
unsafe extern fn vkAllocateMemory(
device: VkDevice,
pAllocateInfo: *const VkMemoryAllocateInfo,
pAllocator: *const VkAllocationCallbacks,
pMemory: *mut VkDeviceMemory,
) -> VkResult;
unsafe extern fn vkFreeMemory(
device: VkDevice,
memory: VkDeviceMemory,
pAllocator: *const VkAllocationCallbacks,
);
unsafe extern fn vkMapMemory(
device: VkDevice,
memory: VkDeviceMemory,
offset: VkDeviceSize,
size: VkDeviceSize,
flags: VkMemoryMapFlags,
ppData: *mut *mut void,
) -> VkResult;
unsafe extern fn vkUnmapMemory(
device: VkDevice,
memory: VkDeviceMemory,
);
unsafe extern fn vkFlushMappedMemoryRanges(
device: VkDevice,
memoryRangeCount: uint32_t,
pMemoryRanges: *const [VkMappedMemoryRange; dyn memoryRangeCount],
) -> VkResult;
unsafe extern fn vkInvalidateMappedMemoryRanges(
device: VkDevice,
memoryRangeCount: uint32_t,
pMemoryRanges: *const [VkMappedMemoryRange; dyn memoryRangeCount],
) -> VkResult;
unsafe extern fn vkGetDeviceMemoryCommitment(
device: VkDevice,
memory: VkDeviceMemory,
pCommittedMemoryInBytes: *mut VkDeviceSize,
);
unsafe extern fn vkGetBufferMemoryRequirements(
device: VkDevice,
buffer: VkBuffer,
pMemoryRequirements: *mut VkMemoryRequirements,
);
unsafe extern fn vkBindBufferMemory(
device: VkDevice,
buffer: VkBuffer,
memory: VkDeviceMemory,
memoryOffset: VkDeviceSize,
) -> VkResult;
unsafe extern fn vkGetImageMemoryRequirements(
device: VkDevice,
image: VkImage,
pMemoryRequirements: *mut VkMemoryRequirements,
);
unsafe extern fn vkBindImageMemory(
device: VkDevice,
image: VkImage,
memory: VkDeviceMemory,
memoryOffset: VkDeviceSize,
) -> VkResult;
unsafe extern fn vkGetImageSparseMemoryRequirements(
device: VkDevice,
image: VkImage,
pSparseMemoryRequirementCount: *mut uint32_t,
pSparseMemoryRequirements: *mut [VkSparseImageMemoryRequirements; dyn pSparseMemoryRequirementCount],
);
unsafe extern fn vkGetPhysicalDeviceSparseImageFormatProperties(
physicalDevice: VkPhysicalDevice,
format: VkFormat,
type: VkImageType,
samples: VkSampleCountFlagBits,
usage: VkImageUsageFlags,
tiling: VkImageTiling,
pPropertyCount: *mut uint32_t,
pProperties: *mut [VkSparseImageFormatProperties; dyn pPropertyCount],
);
unsafe extern fn vkQueueBindSparse(
queue: VkQueue,
bindInfoCount: uint32_t,
pBindInfo: *const [VkBindSparseInfo; dyn bindInfoCount],
fence: VkFence,
) -> VkResult;
unsafe extern fn vkCreateFence(
device: VkDevice,
pCreateInfo: *const VkFenceCreateInfo,
pAllocator: *const VkAllocationCallbacks,
pFence: *mut VkFence,
) -> VkResult;
unsafe extern fn vkDestroyFence(
device: VkDevice,
fence: VkFence,
pAllocator: *const VkAllocationCallbacks,
);
unsafe extern fn vkResetFences(
device: VkDevice,
fenceCount: uint32_t,
pFences: *const [VkFence; dyn fenceCount],
) -> VkResult;
unsafe extern fn vkGetFenceStatus(
device: VkDevice,
fence: VkFence,
) -> VkResult;
unsafe extern fn vkWaitForFences(
device: VkDevice,
fenceCount: uint32_t,
pFences: *const [VkFence; dyn fenceCount],
waitAll: VkBool32,
timeout: uint64_t,
) -> VkResult;
unsafe extern fn vkCreateSemaphore(
device: VkDevice,
pCreateInfo: *const VkSemaphoreCreateInfo,
pAllocator: *const VkAllocationCallbacks,
pSemaphore: *mut VkSemaphore,
) -> VkResult;
unsafe extern fn vkDestroySemaphore(
device: VkDevice,
semaphore: VkSemaphore,
pAllocator: *const VkAllocationCallbacks,
);
unsafe extern fn vkCreateEvent(
device: VkDevice,
pCreateInfo: *const VkEventCreateInfo,
pAllocator: *const VkAllocationCallbacks,
pEvent: *mut VkEvent,
) -> VkResult;
unsafe extern fn vkDestroyEvent(
device: VkDevice,
event: VkEvent,
pAllocator: *const VkAllocationCallbacks,
);
unsafe extern fn vkGetEventStatus(
device: VkDevice,
event: VkEvent,
) -> VkResult;
unsafe extern fn vkSetEvent(
device: VkDevice,
event: VkEvent,
) -> VkResult;
unsafe extern fn vkResetEvent(
device: VkDevice,
event: VkEvent,
) -> VkResult;
unsafe extern fn vkCreateQueryPool(
device: VkDevice,
pCreateInfo: *const VkQueryPoolCreateInfo,
pAllocator: *const VkAllocationCallbacks,
pQueryPool: *mut VkQueryPool,
) -> VkResult;
unsafe extern fn vkDestroyQueryPool(
device: VkDevice,
queryPool: VkQueryPool,
pAllocator: *const VkAllocationCallbacks,
);
unsafe extern fn vkGetQueryPoolResults(
device: VkDevice,
queryPool: VkQueryPool,
firstQuery: uint32_t,
queryCount: uint32_t,
dataSize: size_t,
pData: *mut [void; dyn dataSize],
stride: VkDeviceSize,
flags: VkQueryResultFlags,
) -> VkResult;
unsafe extern fn vkResetQueryPool(
device: VkDevice,
queryPool: VkQueryPool,
firstQuery: uint32_t,
queryCount: uint32_t,
);
unsafe extern fn vkCreateBuffer(
device: VkDevice,
pCreateInfo: *const VkBufferCreateInfo,
pAllocator: *const VkAllocationCallbacks,
pBuffer: *mut VkBuffer,
) -> VkResult;
unsafe extern fn vkDestroyBuffer(
device: VkDevice,
buffer: VkBuffer,
pAllocator: *const VkAllocationCallbacks,
);
unsafe extern fn vkCreateBufferView(
device: VkDevice,
pCreateInfo: *const VkBufferViewCreateInfo,
pAllocator: *const VkAllocationCallbacks,
pView: *mut VkBufferView,
) -> VkResult;
unsafe extern fn vkDestroyBufferView(
device: VkDevice,
bufferView: VkBufferView,
pAllocator: *const VkAllocationCallbacks,
);
unsafe extern fn vkCreateImage(
device: VkDevice,
pCreateInfo: *const VkImageCreateInfo,
pAllocator: *const VkAllocationCallbacks,
pImage: *mut VkImage,
) -> VkResult;
unsafe extern fn vkDestroyImage(
device: VkDevice,
image: VkImage,
pAllocator: *const VkAllocationCallbacks,
);
unsafe extern fn vkGetImageSubresourceLayout(
device: VkDevice,
image: VkImage,
pSubresource: *const VkImageSubresource,
pLayout: *mut VkSubresourceLayout,
);
unsafe extern fn vkCreateImageView(
device: VkDevice,
pCreateInfo: *const VkImageViewCreateInfo,
pAllocator: *const VkAllocationCallbacks,
pView: *mut VkImageView,
) -> VkResult;
unsafe extern fn vkDestroyImageView(
device: VkDevice,
imageView: VkImageView,
pAllocator: *const VkAllocationCallbacks,
);
unsafe extern fn vkCreateShaderModule(
device: VkDevice,
pCreateInfo: *const VkShaderModuleCreateInfo,
pAllocator: *const VkAllocationCallbacks,
pShaderModule: *mut VkShaderModule,
) -> VkResult;
unsafe extern fn vkDestroyShaderModule(
device: VkDevice,
shaderModule: VkShaderModule,
pAllocator: *const VkAllocationCallbacks,
);
unsafe extern fn vkCreatePipelineCache(
device: VkDevice,
pCreateInfo: *const VkPipelineCacheCreateInfo,
pAllocator: *const VkAllocationCallbacks,
pPipelineCache: *mut VkPipelineCache,
) -> VkResult;
unsafe extern fn vkDestroyPipelineCache(
device: VkDevice,
pipelineCache: VkPipelineCache,
pAllocator: *const VkAllocationCallbacks,
);
unsafe extern fn vkGetPipelineCacheData(
device: VkDevice,
pipelineCache: VkPipelineCache,
pDataSize: *mut size_t,
pData: *mut [void; dyn pDataSize],
) -> VkResult;
unsafe extern fn vkMergePipelineCaches(
device: VkDevice,
dstCache: VkPipelineCache,
srcCacheCount: uint32_t,
pSrcCaches: *const [VkPipelineCache; dyn srcCacheCount],
) -> VkResult;
unsafe extern fn vkCreateGraphicsPipelines(
device: VkDevice,
pipelineCache: VkPipelineCache,
createInfoCount: uint32_t,
pCreateInfos: *const [VkGraphicsPipelineCreateInfo; dyn createInfoCount],
pAllocator: *const VkAllocationCallbacks,
pPipelines: *mut [VkPipeline; dyn createInfoCount],
) -> VkResult;
unsafe extern fn vkCreateComputePipelines(
device: VkDevice,
pipelineCache: VkPipelineCache,
createInfoCount: uint32_t,
pCreateInfos: *const [VkComputePipelineCreateInfo; dyn createInfoCount],
pAllocator: *const VkAllocationCallbacks,
pPipelines: *mut [VkPipeline; dyn createInfoCount],
) -> VkResult;
unsafe extern fn vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(
device: VkDevice,
renderpass: VkRenderPass,
pMaxWorkgroupSize: *mut VkExtent2D,
) -> VkResult;
unsafe extern fn vkDestroyPipeline(
device: VkDevice,
pipeline: VkPipeline,
pAllocator: *const VkAllocationCallbacks,
);
unsafe extern fn vkCreatePipelineLayout(
device: VkDevice,
pCreateInfo: *const VkPipelineLayoutCreateInfo,
pAllocator: *const VkAllocationCallbacks,
pPipelineLayout: *mut VkPipelineLayout,
) -> VkResult;
unsafe extern fn vkDestroyPipelineLayout(
device: VkDevice,
pipelineLayout: VkPipelineLayout,
pAllocator: *const VkAllocationCallbacks,
);
unsafe extern fn vkCreateSampler(
device: VkDevice,
pCreateInfo: *const VkSamplerCreateInfo,
pAllocator: *const VkAllocationCallbacks,
pSampler: *mut VkSampler,
) -> VkResult;
unsafe extern fn vkDestroySampler(
device: VkDevice,
sampler: VkSampler,
pAllocator: *const VkAllocationCallbacks,
);
unsafe extern fn vkCreateDescriptorSetLayout(
device: VkDevice,
pCreateInfo: *const VkDescriptorSetLayoutCreateInfo,
pAllocator: *const VkAllocationCallbacks,
pSetLayout: *mut VkDescriptorSetLayout,
) -> VkResult;
unsafe extern fn vkDestroyDescriptorSetLayout(
device: VkDevice,
descriptorSetLayout: VkDescriptorSetLayout,
pAllocator: *const VkAllocationCallbacks,
);
unsafe extern fn vkCreateDescriptorPool(
device: VkDevice,
pCreateInfo: *const VkDescriptorPoolCreateInfo,
pAllocator: *const VkAllocationCallbacks,
pDescriptorPool: *mut VkDescriptorPool,
) -> VkResult;
unsafe extern fn vkDestroyDescriptorPool(
device: VkDevice,
descriptorPool: VkDescriptorPool,
pAllocator: *const VkAllocationCallbacks,
);
unsafe extern fn vkResetDescriptorPool(
device: VkDevice,
descriptorPool: VkDescriptorPool,
flags: VkDescriptorPoolResetFlags,
) -> VkResult;
unsafe extern fn vkAllocateDescriptorSets(
device: VkDevice,
pAllocateInfo: *const VkDescriptorSetAllocateInfo,
pDescriptorSets: *mut [VkDescriptorSet; dyn pAllocateInfo->descriptorSetCount],
) -> VkResult;
unsafe extern fn vkFreeDescriptorSets(
device: VkDevice,
descriptorPool: VkDescriptorPool,
descriptorSetCount: uint32_t,
pDescriptorSets: *const [VkDescriptorSet; dyn descriptorSetCount],
) -> VkResult;
unsafe extern fn vkUpdateDescriptorSets(
device: VkDevice,
descriptorWriteCount: uint32_t,
pDescriptorWrites: *const [VkWriteDescriptorSet; dyn descriptorWriteCount],
descriptorCopyCount: uint32_t,
pDescriptorCopies: *const [VkCopyDescriptorSet; dyn descriptorCopyCount],
);
unsafe extern fn vkCreateFramebuffer(
device: VkDevice,
pCreateInfo: *const VkFramebufferCreateInfo,
pAllocator: *const VkAllocationCallbacks,
pFramebuffer: *mut VkFramebuffer,
) -> VkResult;
unsafe extern fn vkDestroyFramebuffer(
device: VkDevice,
framebuffer: VkFramebuffer,
pAllocator: *const VkAllocationCallbacks,
);
unsafe extern fn vkCreateRenderPass(
device: VkDevice,
pCreateInfo: *const VkRenderPassCreateInfo,
pAllocator: *const VkAllocationCallbacks,
pRenderPass: *mut VkRenderPass,
) -> VkResult;
unsafe extern fn vkDestroyRenderPass(
device: VkDevice,
renderPass: VkRenderPass,
pAllocator: *const VkAllocationCallbacks,
);
unsafe extern fn vkGetRenderAreaGranularity(
device: VkDevice,
renderPass: VkRenderPass,
pGranularity: *mut VkExtent2D,
);
unsafe extern fn vkGetRenderingAreaGranularityKHR(
device: VkDevice,
pRenderingAreaInfo: *const VkRenderingAreaInfoKHR,
pGranularity: *mut VkExtent2D,
);
unsafe extern fn vkCreateCommandPool(
device: VkDevice,
pCreateInfo: *const VkCommandPoolCreateInfo,
pAllocator: *const VkAllocationCallbacks,
pCommandPool: *mut VkCommandPool,
) -> VkResult;
unsafe extern fn vkDestroyCommandPool(
device: VkDevice,
commandPool: VkCommandPool,
pAllocator: *const VkAllocationCallbacks,
);
unsafe extern fn vkResetCommandPool(
device: VkDevice,
commandPool: VkCommandPool,
flags: VkCommandPoolResetFlags,
) -> VkResult;
unsafe extern fn vkAllocateCommandBuffers(
device: VkDevice,
pAllocateInfo: *const VkCommandBufferAllocateInfo,
pCommandBuffers: *mut [VkCommandBuffer; dyn pAllocateInfo->commandBufferCount],
) -> VkResult;
unsafe extern fn vkFreeCommandBuffers(
device: VkDevice,
commandPool: VkCommandPool,
commandBufferCount: uint32_t,
pCommandBuffers: *const [VkCommandBuffer; dyn commandBufferCount],
);
unsafe extern fn vkBeginCommandBuffer(
commandBuffer: VkCommandBuffer,
pBeginInfo: *const VkCommandBufferBeginInfo,
) -> VkResult;
unsafe extern fn vkEndCommandBuffer(
commandBuffer: VkCommandBuffer,
) -> VkResult;
unsafe extern fn vkResetCommandBuffer(
commandBuffer: VkCommandBuffer,
flags: VkCommandBufferResetFlags,
) -> VkResult;
unsafe extern fn vkCmdBindPipeline(
commandBuffer: VkCommandBuffer,
pipelineBindPoint: VkPipelineBindPoint,
pipeline: VkPipeline,
);
unsafe extern fn vkCmdSetAttachmentFeedbackLoopEnableEXT(
commandBuffer: VkCommandBuffer,
aspectMask: VkImageAspectFlags,
);
unsafe extern fn vkCmdSetViewport(
commandBuffer: VkCommandBuffer,
firstViewport: uint32_t,
viewportCount: uint32_t,
pViewports: *const [VkViewport; dyn viewportCount],
);
unsafe extern fn vkCmdSetScissor(
commandBuffer: VkCommandBuffer,
firstScissor: uint32_t,
scissorCount: uint32_t,
pScissors: *const [VkRect2D; dyn scissorCount],
);
unsafe extern fn vkCmdSetLineWidth(
commandBuffer: VkCommandBuffer,
lineWidth: float,
);
unsafe extern fn vkCmdSetDepthBias(
commandBuffer: VkCommandBuffer,
depthBiasConstantFactor: float,
depthBiasClamp: float,
depthBiasSlopeFactor: float,
);
unsafe extern fn vkCmdSetBlendConstants(
commandBuffer: VkCommandBuffer,
blendConstants: *const [float; 4],
);
unsafe extern fn vkCmdSetDepthBounds(
commandBuffer: VkCommandBuffer,
minDepthBounds: float,
maxDepthBounds: float,
);
unsafe extern fn vkCmdSetStencilCompareMask(
commandBuffer: VkCommandBuffer,
faceMask: VkStencilFaceFlags,
compareMask: uint32_t,
);
unsafe extern fn vkCmdSetStencilWriteMask(
commandBuffer: VkCommandBuffer,
faceMask: VkStencilFaceFlags,
writeMask: uint32_t,
);
unsafe extern fn vkCmdSetStencilReference(
commandBuffer: VkCommandBuffer,
faceMask: VkStencilFaceFlags,
reference: uint32_t,
);
unsafe extern fn vkCmdBindDescriptorSets(
commandBuffer: VkCommandBuffer,
pipelineBindPoint: VkPipelineBindPoint,
layout: VkPipelineLayout,
firstSet: uint32_t,
descriptorSetCount: uint32_t,
pDescriptorSets: *const [VkDescriptorSet; dyn descriptorSetCount],
dynamicOffsetCount: uint32_t,
pDynamicOffsets: *const [uint32_t; dyn dynamicOffsetCount],
);
unsafe extern fn vkCmdBindIndexBuffer(
commandBuffer: VkCommandBuffer,
buffer: VkBuffer,
offset: VkDeviceSize,
indexType: VkIndexType,
);
unsafe extern fn vkCmdBindVertexBuffers(
commandBuffer: VkCommandBuffer,
firstBinding: uint32_t,
bindingCount: uint32_t,
pBuffers: *const [VkBuffer; dyn bindingCount],
pOffsets: *const [VkDeviceSize; dyn bindingCount],
);
unsafe extern fn vkCmdDraw(
commandBuffer: VkCommandBuffer,
vertexCount: uint32_t,
instanceCount: uint32_t,
firstVertex: uint32_t,
firstInstance: uint32_t,
);
unsafe extern fn vkCmdDrawIndexed(
commandBuffer: VkCommandBuffer,
indexCount: uint32_t,
instanceCount: uint32_t,
firstIndex: uint32_t,
vertexOffset: int32_t,
firstInstance: uint32_t,
);
unsafe extern fn vkCmdDrawMultiEXT(
commandBuffer: VkCommandBuffer,
drawCount: uint32_t,
pVertexInfo: *const [VkMultiDrawInfoEXT; dyn drawCount],
instanceCount: uint32_t,
firstInstance: uint32_t,
stride: uint32_t,
);
unsafe extern fn vkCmdDrawMultiIndexedEXT(
commandBuffer: VkCommandBuffer,
drawCount: uint32_t,
pIndexInfo: *const [VkMultiDrawIndexedInfoEXT; dyn drawCount],
instanceCount: uint32_t,
firstInstance: uint32_t,
stride: uint32_t,
pVertexOffset: *const int32_t,
);
unsafe extern fn vkCmdDrawIndirect(
commandBuffer: VkCommandBuffer,
buffer: VkBuffer,
offset: VkDeviceSize,
drawCount: uint32_t,
stride: uint32_t,
);
unsafe extern fn vkCmdDrawIndexedIndirect(
commandBuffer: VkCommandBuffer,
buffer: VkBuffer,
offset: VkDeviceSize,
drawCount: uint32_t,
stride: uint32_t,
);
unsafe extern fn vkCmdDispatch(
commandBuffer: VkCommandBuffer,
groupCountX: uint32_t,
groupCountY: uint32_t,
groupCountZ: uint32_t,
);
unsafe extern fn vkCmdDispatchIndirect(
commandBuffer: VkCommandBuffer,
buffer: VkBuffer,
offset: VkDeviceSize,
);
unsafe extern fn vkCmdSubpassShadingHUAWEI(
commandBuffer: VkCommandBuffer,
);
unsafe extern fn vkCmdDrawClusterHUAWEI(
commandBuffer: VkCommandBuffer,
groupCountX: uint32_t,
groupCountY: uint32_t,
groupCountZ: uint32_t,
);
unsafe extern fn vkCmdDrawClusterIndirectHUAWEI(
commandBuffer: VkCommandBuffer,
buffer: VkBuffer,
offset: VkDeviceSize,
);
unsafe extern fn vkCmdUpdatePipelineIndirectBufferNV(
commandBuffer: VkCommandBuffer,
pipelineBindPoint: VkPipelineBindPoint,
pipeline: VkPipeline,
);
unsafe extern fn vkCmdCopyBuffer(
commandBuffer: VkCommandBuffer,
srcBuffer: VkBuffer,
dstBuffer: VkBuffer,
regionCount: uint32_t,
pRegions: *const [VkBufferCopy; dyn regionCount],
);
unsafe extern fn vkCmdCopyImage(
commandBuffer: VkCommandBuffer,
srcImage: VkImage,
srcImageLayout: VkImageLayout,
dstImage: VkImage,
dstImageLayout: VkImageLayout,
regionCount: uint32_t,
pRegions: *const [VkImageCopy; dyn regionCount],
);
unsafe extern fn vkCmdBlitImage(
commandBuffer: VkCommandBuffer,
srcImage: VkImage,
srcImageLayout: VkImageLayout,
dstImage: VkImage,
dstImageLayout: VkImageLayout,
regionCount: uint32_t,
pRegions: *const [VkImageBlit; dyn regionCount],
filter: VkFilter,
);
unsafe extern fn vkCmdCopyBufferToImage(
commandBuffer: VkCommandBuffer,
srcBuffer: VkBuffer,
dstImage: VkImage,
dstImageLayout: VkImageLayout,
regionCount: uint32_t,
pRegions: *const [VkBufferImageCopy; dyn regionCount],
);
unsafe extern fn vkCmdCopyImageToBuffer(
commandBuffer: VkCommandBuffer,
srcImage: VkImage,
srcImageLayout: VkImageLayout,
dstBuffer: VkBuffer,
regionCount: uint32_t,
pRegions: *const [VkBufferImageCopy; dyn regionCount],
);
unsafe extern fn vkCmdCopyMemoryIndirectNV(
commandBuffer: VkCommandBuffer,
copyBufferAddress: VkDeviceAddress,
copyCount: uint32_t,
stride: uint32_t,
);
unsafe extern fn vkCmdCopyMemoryToImageIndirectNV(
commandBuffer: VkCommandBuffer,
copyBufferAddress: VkDeviceAddress,
copyCount: uint32_t,
stride: uint32_t,
dstImage: VkImage,
dstImageLayout: VkImageLayout,
pImageSubresources: *const [VkImageSubresourceLayers; dyn copyCount],
);
unsafe extern fn vkCmdUpdateBuffer(
commandBuffer: VkCommandBuffer,
dstBuffer: VkBuffer,
dstOffset: VkDeviceSize,
dataSize: VkDeviceSize,
pData: *const [void; dyn dataSize],
);
unsafe extern fn vkCmdFillBuffer(
commandBuffer: VkCommandBuffer,
dstBuffer: VkBuffer,
dstOffset: VkDeviceSize,
size: VkDeviceSize,
data: uint32_t,
);
unsafe extern fn vkCmdClearColorImage(
commandBuffer: VkCommandBuffer,
image: VkImage,
imageLayout: VkImageLayout,
pColor: *const VkClearColorValue,
rangeCount: uint32_t,
pRanges: *const [VkImageSubresourceRange; dyn rangeCount],
);
unsafe extern fn vkCmdClearDepthStencilImage(
commandBuffer: VkCommandBuffer,
image: VkImage,
imageLayout: VkImageLayout,
pDepthStencil: *const VkClearDepthStencilValue,
rangeCount: uint32_t,
pRanges: *const [VkImageSubresourceRange; dyn rangeCount],
);
unsafe extern fn vkCmdClearAttachments(
commandBuffer: VkCommandBuffer,
attachmentCount: uint32_t,
pAttachments: *const [VkClearAttachment; dyn attachmentCount],
rectCount: uint32_t,
pRects: *const [VkClearRect; dyn rectCount],
);
unsafe extern fn vkCmdResolveImage(
commandBuffer: VkCommandBuffer,
srcImage: VkImage,
srcImageLayout: VkImageLayout,
dstImage: VkImage,
dstImageLayout: VkImageLayout,
regionCount: uint32_t,
pRegions: *const [VkImageResolve; dyn regionCount],
);
unsafe extern fn vkCmdSetEvent(
commandBuffer: VkCommandBuffer,
event: VkEvent,
stageMask: VkPipelineStageFlags,
);
unsafe extern fn vkCmdResetEvent(
commandBuffer: VkCommandBuffer,
event: VkEvent,
stageMask: VkPipelineStageFlags,
);
unsafe extern fn vkCmdWaitEvents(
commandBuffer: VkCommandBuffer,
eventCount: uint32_t,
pEvents: *const [VkEvent; dyn eventCount],
srcStageMask: VkPipelineStageFlags,
dstStageMask: VkPipelineStageFlags,
memoryBarrierCount: uint32_t,
pMemoryBarriers: *const [VkMemoryBarrier; dyn memoryBarrierCount],
bufferMemoryBarrierCount: uint32_t,
pBufferMemoryBarriers: *const [VkBufferMemoryBarrier; dyn bufferMemoryBarrierCount],
imageMemoryBarrierCount: uint32_t,
pImageMemoryBarriers: *const [VkImageMemoryBarrier; dyn imageMemoryBarrierCount],
);
unsafe extern fn vkCmdPipelineBarrier(
commandBuffer: VkCommandBuffer,
srcStageMask: VkPipelineStageFlags,
dstStageMask: VkPipelineStageFlags,
dependencyFlags: VkDependencyFlags,
memoryBarrierCount: uint32_t,
pMemoryBarriers: *const [VkMemoryBarrier; dyn memoryBarrierCount],
bufferMemoryBarrierCount: uint32_t,
pBufferMemoryBarriers: *const [VkBufferMemoryBarrier; dyn bufferMemoryBarrierCount],
imageMemoryBarrierCount: uint32_t,
pImageMemoryBarriers: *const [VkImageMemoryBarrier; dyn imageMemoryBarrierCount],
);
unsafe extern fn vkCmdBeginQuery(
commandBuffer: VkCommandBuffer,
queryPool: VkQueryPool,
query: uint32_t,
flags: VkQueryControlFlags,
);
unsafe extern fn vkCmdEndQuery(
commandBuffer: VkCommandBuffer,
queryPool: VkQueryPool,
query: uint32_t,
);
unsafe extern fn vkCmdBeginConditionalRenderingEXT(
commandBuffer: VkCommandBuffer,
pConditionalRenderingBegin: *const VkConditionalRenderingBeginInfoEXT,
);
unsafe extern fn vkCmdEndConditionalRenderingEXT(
commandBuffer: VkCommandBuffer,
);
unsafe extern fn vkCmdResetQueryPool(
commandBuffer: VkCommandBuffer,
queryPool: VkQueryPool,
firstQuery: uint32_t,
queryCount: uint32_t,
);
unsafe extern fn vkCmdWriteTimestamp(
commandBuffer: VkCommandBuffer,
pipelineStage: VkPipelineStageFlagBits,
queryPool: VkQueryPool,
query: uint32_t,
);
unsafe extern fn vkCmdCopyQueryPoolResults(
commandBuffer: VkCommandBuffer,
queryPool: VkQueryPool,
firstQuery: uint32_t,
queryCount: uint32_t,
dstBuffer: VkBuffer,
dstOffset: VkDeviceSize,
stride: VkDeviceSize,
flags: VkQueryResultFlags,
);
unsafe extern fn vkCmdPushConstants(
commandBuffer: VkCommandBuffer,
layout: VkPipelineLayout,
stageFlags: VkShaderStageFlags,
offset: uint32_t,
size: uint32_t,
pValues: *const [void; dyn size],
);
unsafe extern fn vkCmdBeginRenderPass(
commandBuffer: VkCommandBuffer,
pRenderPassBegin: *const VkRenderPassBeginInfo,
contents: VkSubpassContents,
);
unsafe extern fn vkCmdNextSubpass(
commandBuffer: VkCommandBuffer,
contents: VkSubpassContents,
);
unsafe extern fn vkCmdEndRenderPass(
commandBuffer: VkCommandBuffer,
);
unsafe extern fn vkCmdExecuteCommands(
commandBuffer: VkCommandBuffer,
commandBufferCount: uint32_t,
pCommandBuffers: *const [VkCommandBuffer; dyn commandBufferCount],
);
unsafe extern fn vkCreateAndroidSurfaceKHR(
instance: VkInstance,
pCreateInfo: *const VkAndroidSurfaceCreateInfoKHR,
pAllocator: *const VkAllocationCallbacks,
pSurface: *mut VkSurfaceKHR,
) -> VkResult;
unsafe extern fn vkGetPhysicalDeviceDisplayPropertiesKHR(
physicalDevice: VkPhysicalDevice,
pPropertyCount: *mut uint32_t,
pProperties: *mut [VkDisplayPropertiesKHR; dyn pPropertyCount],
) -> VkResult;
unsafe extern fn vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
physicalDevice: VkPhysicalDevice,
pPropertyCount: *mut uint32_t,
pProperties: *mut [VkDisplayPlanePropertiesKHR; dyn pPropertyCount],
) -> VkResult;
unsafe extern fn vkGetDisplayPlaneSupportedDisplaysKHR(
physicalDevice: VkPhysicalDevice,
planeIndex: uint32_t,
pDisplayCount: *mut uint32_t,
pDisplays: *mut [VkDisplayKHR; dyn pDisplayCount],
) -> VkResult;
unsafe extern fn vkGetDisplayModePropertiesKHR(
physicalDevice: VkPhysicalDevice,
display: VkDisplayKHR,
pPropertyCount: *mut uint32_t,
pProperties: *mut [VkDisplayModePropertiesKHR; dyn pPropertyCount],
) -> VkResult;
unsafe extern fn vkCreateDisplayModeKHR(
physicalDevice: VkPhysicalDevice,
display: VkDisplayKHR,
pCreateInfo: *const VkDisplayModeCreateInfoKHR,
pAllocator: *const VkAllocationCallbacks,
pMode: *mut VkDisplayModeKHR,
) -> VkResult;
unsafe extern fn vkGetDisplayPlaneCapabilitiesKHR(
physicalDevice: VkPhysicalDevice,
mode: VkDisplayModeKHR,
planeIndex: uint32_t,
pCapabilities: *mut VkDisplayPlaneCapabilitiesKHR,
) -> VkResult;
unsafe extern fn vkCreateDisplayPlaneSurfaceKHR(
instance: VkInstance,
pCreateInfo: *const VkDisplaySurfaceCreateInfoKHR,
pAllocator: *const VkAllocationCallbacks,
pSurface: *mut VkSurfaceKHR,
) -> VkResult;
unsafe extern fn vkCreateSharedSwapchainsKHR(
device: VkDevice,
swapchainCount: uint32_t,
pCreateInfos: *const [VkSwapchainCreateInfoKHR; dyn swapchainCount],
pAllocator: *const VkAllocationCallbacks,
pSwapchains: *mut [VkSwapchainKHR; dyn swapchainCount],
) -> VkResult;
unsafe extern fn vkDestroySurfaceKHR(
instance: VkInstance,
surface: VkSurfaceKHR,
pAllocator: *const VkAllocationCallbacks,
);
unsafe extern fn vkGetPhysicalDeviceSurfaceSupportKHR(
physicalDevice: VkPhysicalDevice,
queueFamilyIndex: uint32_t,
surface: VkSurfaceKHR,
pSupported: *mut VkBool32,
) -> VkResult;
unsafe extern fn vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
physicalDevice: VkPhysicalDevice,
surface: VkSurfaceKHR,
pSurfaceCapabilities: *mut VkSurfaceCapabilitiesKHR,
) -> VkResult;
unsafe extern fn vkGetPhysicalDeviceSurfaceFormatsKHR(
physicalDevice: VkPhysicalDevice,
surface: VkSurfaceKHR,
pSurfaceFormatCount: *mut uint32_t,
pSurfaceFormats: *mut [VkSurfaceFormatKHR; dyn pSurfaceFormatCount],
) -> VkResult;
unsafe extern fn vkGetPhysicalDeviceSurfacePresentModesKHR(
physicalDevice: VkPhysicalDevice,
surface: VkSurfaceKHR,
pPresentModeCount: *mut uint32_t,
pPresentModes: *mut [VkPresentModeKHR; dyn pPresentModeCount],
) -> VkResult;
unsafe extern fn vkCreateSwapchainKHR(
device: VkDevice,
pCreateInfo: *const VkSwapchainCreateInfoKHR,
pAllocator: *const VkAllocationCallbacks,
pSwapchain: *mut VkSwapchainKHR,
) -> VkResult;
unsafe extern fn vkDestroySwapchainKHR(
device: VkDevice,
swapchain: VkSwapchainKHR,
pAllocator: *const VkAllocationCallbacks,
);
unsafe extern fn vkGetSwapchainImagesKHR(
device: VkDevice,
swapchain: VkSwapchainKHR,
pSwapchainImageCount: *mut uint32_t,
pSwapchainImages: *mut [VkImage; dyn pSwapchainImageCount],
) -> VkResult;
unsafe extern fn vkAcquireNextImageKHR(
device: VkDevice,
swapchain: VkSwapchainKHR,
timeout: uint64_t,
semaphore: VkSemaphore,
fence: VkFence,
pImageIndex: *mut uint32_t,
) -> VkResult;
unsafe extern fn vkQueuePresentKHR(
queue: VkQueue,
pPresentInfo: *const VkPresentInfoKHR,
) -> VkResult;
unsafe extern fn vkCreateViSurfaceNN(
instance: VkInstance,
pCreateInfo: *const VkViSurfaceCreateInfoNN,
pAllocator: *const VkAllocationCallbacks,
pSurface: *mut VkSurfaceKHR,
) -> VkResult;
unsafe extern fn vkCreateWaylandSurfaceKHR(
instance: VkInstance,
pCreateInfo: *const VkWaylandSurfaceCreateInfoKHR,
pAllocator: *const VkAllocationCallbacks,
pSurface: *mut VkSurfaceKHR,
) -> VkResult;
unsafe extern fn vkGetPhysicalDeviceWaylandPresentationSupportKHR(
physicalDevice: VkPhysicalDevice,
queueFamilyIndex: uint32_t,
display: *mut /*struct*/wl_display,
) -> VkBool32;
unsafe extern fn vkCreateWin32SurfaceKHR(
instance: VkInstance,
pCreateInfo: *const VkWin32SurfaceCreateInfoKHR,
pAllocator: *const VkAllocationCallbacks,
pSurface: *mut VkSurfaceKHR,
) -> VkResult;
unsafe extern fn vkGetPhysicalDeviceWin32PresentationSupportKHR(
physicalDevice: VkPhysicalDevice,
queueFamilyIndex: uint32_t,
) -> VkBool32;
unsafe extern fn vkCreateXlibSurfaceKHR(
instance: VkInstance,
pCreateInfo: *const VkXlibSurfaceCreateInfoKHR,
pAllocator: *const VkAllocationCallbacks,
pSurface: *mut VkSurfaceKHR,
) -> VkResult;
unsafe extern fn vkGetPhysicalDeviceXlibPresentationSupportKHR(
physicalDevice: VkPhysicalDevice,
queueFamilyIndex: uint32_t,
dpy: *mut Display,
visualID: VisualID,
) -> VkBool32;
unsafe extern fn vkCreateXcbSurfaceKHR(
instance: VkInstance,
pCreateInfo: *const VkXcbSurfaceCreateInfoKHR,
pAllocator: *const VkAllocationCallbacks,
pSurface: *mut VkSurfaceKHR,
) -> VkResult;
unsafe extern fn vkGetPhysicalDeviceXcbPresentationSupportKHR(
physicalDevice: VkPhysicalDevice,
queueFamilyIndex: uint32_t,
connection: *mut xcb_connection_t,
visual_id: xcb_visualid_t,
) -> VkBool32;
unsafe extern fn vkCreateDirectFBSurfaceEXT(
instance: VkInstance,
pCreateInfo: *const VkDirectFBSurfaceCreateInfoEXT,
pAllocator: *const VkAllocationCallbacks,
pSurface: *mut VkSurfaceKHR,
) -> VkResult;
unsafe extern fn vkGetPhysicalDeviceDirectFBPresentationSupportEXT(
physicalDevice: VkPhysicalDevice,
queueFamilyIndex: uint32_t,
dfb: *mut IDirectFB,
) -> VkBool32;
unsafe extern fn vkCreateImagePipeSurfaceFUCHSIA(
instance: VkInstance,
pCreateInfo: *const VkImagePipeSurfaceCreateInfoFUCHSIA,
pAllocator: *const VkAllocationCallbacks,
pSurface: *mut VkSurfaceKHR,
) -> VkResult;
unsafe extern fn vkCreateStreamDescriptorSurfaceGGP(
instance: VkInstance,
pCreateInfo: *const VkStreamDescriptorSurfaceCreateInfoGGP,
pAllocator: *const VkAllocationCallbacks,
pSurface: *mut VkSurfaceKHR,
) -> VkResult;
unsafe extern fn vkCreateScreenSurfaceQNX(
instance: VkInstance,
pCreateInfo: *const VkScreenSurfaceCreateInfoQNX,
pAllocator: *const VkAllocationCallbacks,
pSurface: *mut VkSurfaceKHR,
) -> VkResult;
unsafe extern fn vkGetPhysicalDeviceScreenPresentationSupportQNX(
physicalDevice: VkPhysicalDevice,
queueFamilyIndex: uint32_t,
window: *mut /*struct*/_screen_window,
) -> VkBool32;
unsafe extern fn vkCreateDebugReportCallbackEXT(
instance: VkInstance,
pCreateInfo: *const VkDebugReportCallbackCreateInfoEXT,
pAllocator: *const VkAllocationCallbacks,
pCallback: *mut VkDebugReportCallbackEXT,
) -> VkResult;
unsafe extern fn vkDestroyDebugReportCallbackEXT(
instance: VkInstance,
callback: VkDebugReportCallbackEXT,
pAllocator: *const VkAllocationCallbacks,
);
unsafe extern fn vkDebugReportMessageEXT(
instance: VkInstance,
flags: VkDebugReportFlagsEXT,
objectType: VkDebugReportObjectTypeEXT,
object: uint64_t,
location: size_t,
messageCode: int32_t,
pLayerPrefix: *const [char; dyn null-terminated],
pMessage: *const [char; dyn null-terminated],
);
unsafe extern fn vkDebugMarkerSetObjectNameEXT(
device: VkDevice,
pNameInfo: *const VkDebugMarkerObjectNameInfoEXT,
) -> VkResult;
unsafe extern fn vkDebugMarkerSetObjectTagEXT(
device: VkDevice,
pTagInfo: *const VkDebugMarkerObjectTagInfoEXT,
) -> VkResult;
unsafe extern fn vkCmdDebugMarkerBeginEXT(
commandBuffer: VkCommandBuffer,
pMarkerInfo: *const VkDebugMarkerMarkerInfoEXT,
);
unsafe extern fn vkCmdDebugMarkerEndEXT(
commandBuffer: VkCommandBuffer,
);
unsafe extern fn vkCmdDebugMarkerInsertEXT(
commandBuffer: VkCommandBuffer,
pMarkerInfo: *const VkDebugMarkerMarkerInfoEXT,
);
unsafe extern fn vkGetPhysicalDeviceExternalImageFormatPropertiesNV(
physicalDevice: VkPhysicalDevice,
format: VkFormat,
type: VkImageType,
tiling: VkImageTiling,
usage: VkImageUsageFlags,
flags: VkImageCreateFlags,
externalHandleType: VkExternalMemoryHandleTypeFlagsNV,
pExternalImageFormatProperties: *mut VkExternalImageFormatPropertiesNV,
) -> VkResult;
unsafe extern fn vkGetMemoryWin32HandleNV(
device: VkDevice,
memory: VkDeviceMemory,
handleType: VkExternalMemoryHandleTypeFlagsNV,
pHandle: *mut HANDLE,
) -> VkResult;
unsafe extern fn vkCmdExecuteGeneratedCommandsNV(
commandBuffer: VkCommandBuffer,
isPreprocessed: VkBool32,
pGeneratedCommandsInfo: *const VkGeneratedCommandsInfoNV,
);
unsafe extern fn vkCmdPreprocessGeneratedCommandsNV(
commandBuffer: VkCommandBuffer,
pGeneratedCommandsInfo: *const VkGeneratedCommandsInfoNV,
);
unsafe extern fn vkCmdBindPipelineShaderGroupNV(
commandBuffer: VkCommandBuffer,
pipelineBindPoint: VkPipelineBindPoint,
pipeline: VkPipeline,
groupIndex: uint32_t,
);
unsafe extern fn vkGetGeneratedCommandsMemoryRequirementsNV(
device: VkDevice,
pInfo: *const VkGeneratedCommandsMemoryRequirementsInfoNV,
pMemoryRequirements: *mut VkMemoryRequirements2,
);
unsafe extern fn vkCreateIndirectCommandsLayoutNV(
device: VkDevice,
pCreateInfo: *const VkIndirectCommandsLayoutCreateInfoNV,
pAllocator: *const VkAllocationCallbacks,
pIndirectCommandsLayout: *mut VkIndirectCommandsLayoutNV,
) -> VkResult;
unsafe extern fn vkDestroyIndirectCommandsLayoutNV(
device: VkDevice,
indirectCommandsLayout: VkIndirectCommandsLayoutNV,
pAllocator: *const VkAllocationCallbacks,
);
unsafe extern fn vkGetPhysicalDeviceFeatures2(
physicalDevice: VkPhysicalDevice,
pFeatures: *mut VkPhysicalDeviceFeatures2,
);
unsafe extern fn vkGetPhysicalDeviceProperties2(
physicalDevice: VkPhysicalDevice,
pProperties: *mut VkPhysicalDeviceProperties2,
);
unsafe extern fn vkGetPhysicalDeviceFormatProperties2(
physicalDevice: VkPhysicalDevice,
format: VkFormat,
pFormatProperties: *mut VkFormatProperties2,
);
unsafe extern fn vkGetPhysicalDeviceImageFormatProperties2(
physicalDevice: VkPhysicalDevice,
pImageFormatInfo: *const VkPhysicalDeviceImageFormatInfo2,
pImageFormatProperties: *mut VkImageFormatProperties2,
) -> VkResult;
unsafe extern fn vkGetPhysicalDeviceQueueFamilyProperties2(
physicalDevice: VkPhysicalDevice,
pQueueFamilyPropertyCount: *mut uint32_t,
pQueueFamilyProperties: *mut [VkQueueFamilyProperties2; dyn pQueueFamilyPropertyCount],
);
unsafe extern fn vkGetPhysicalDeviceMemoryProperties2(
physicalDevice: VkPhysicalDevice,
pMemoryProperties: *mut VkPhysicalDeviceMemoryProperties2,
);
unsafe extern fn vkGetPhysicalDeviceSparseImageFormatProperties2(
physicalDevice: VkPhysicalDevice,
pFormatInfo: *const VkPhysicalDeviceSparseImageFormatInfo2,
pPropertyCount: *mut uint32_t,
pProperties: *mut [VkSparseImageFormatProperties2; dyn pPropertyCount],
);
unsafe extern fn vkCmdPushDescriptorSetKHR(
commandBuffer: VkCommandBuffer,
pipelineBindPoint: VkPipelineBindPoint,
layout: VkPipelineLayout,
set: uint32_t,
descriptorWriteCount: uint32_t,
pDescriptorWrites: *const [VkWriteDescriptorSet; dyn descriptorWriteCount],
);
unsafe extern fn vkTrimCommandPool(
device: VkDevice,
commandPool: VkCommandPool,
flags: VkCommandPoolTrimFlags,
);
unsafe extern fn vkGetPhysicalDeviceExternalBufferProperties(
physicalDevice: VkPhysicalDevice,
pExternalBufferInfo: *const VkPhysicalDeviceExternalBufferInfo,
pExternalBufferProperties: *mut VkExternalBufferProperties,
);
unsafe extern fn vkGetMemoryWin32HandleKHR(
device: VkDevice,
pGetWin32HandleInfo: *const VkMemoryGetWin32HandleInfoKHR,
pHandle: *mut HANDLE,
) -> VkResult;
unsafe extern fn vkGetMemoryWin32HandlePropertiesKHR(
device: VkDevice,
handleType: VkExternalMemoryHandleTypeFlagBits,
handle: HANDLE,
pMemoryWin32HandleProperties: *mut VkMemoryWin32HandlePropertiesKHR,
) -> VkResult;
unsafe extern fn vkGetMemoryFdKHR(
device: VkDevice,
pGetFdInfo: *const VkMemoryGetFdInfoKHR,
pFd: *mut int,
) -> VkResult;
unsafe extern fn vkGetMemoryFdPropertiesKHR(
device: VkDevice,
handleType: VkExternalMemoryHandleTypeFlagBits,
fd: int,
pMemoryFdProperties: *mut VkMemoryFdPropertiesKHR,
) -> VkResult;
unsafe extern fn vkGetMemoryZirconHandleFUCHSIA(
device: VkDevice,
pGetZirconHandleInfo: *const VkMemoryGetZirconHandleInfoFUCHSIA,
pZirconHandle: *mut zx_handle_t,
) -> VkResult;
unsafe extern fn vkGetMemoryZirconHandlePropertiesFUCHSIA(
device: VkDevice,
handleType: VkExternalMemoryHandleTypeFlagBits,
zirconHandle: zx_handle_t,
pMemoryZirconHandleProperties: *mut VkMemoryZirconHandlePropertiesFUCHSIA,
) -> VkResult;
unsafe extern fn vkGetMemoryRemoteAddressNV(
device: VkDevice,
pMemoryGetRemoteAddressInfo: *const VkMemoryGetRemoteAddressInfoNV,
pAddress: *mut VkRemoteAddressNV,
) -> VkResult;
unsafe extern fn vkGetMemorySciBufNV(
device: VkDevice,
pGetSciBufInfo: *const VkMemoryGetSciBufInfoNV,
pHandle: *mut NvSciBufObj,
) -> VkResult;
unsafe extern fn vkGetPhysicalDeviceExternalMemorySciBufPropertiesNV(
physicalDevice: VkPhysicalDevice,
handleType: VkExternalMemoryHandleTypeFlagBits,
handle: NvSciBufObj,
pMemorySciBufProperties: *mut VkMemorySciBufPropertiesNV,
) -> VkResult;
unsafe extern fn vkGetPhysicalDeviceSciBufAttributesNV(
physicalDevice: VkPhysicalDevice,
pAttributes: NvSciBufAttrList,
) -> VkResult;
unsafe extern fn vkGetPhysicalDeviceExternalSemaphoreProperties(
physicalDevice: VkPhysicalDevice,
pExternalSemaphoreInfo: *const VkPhysicalDeviceExternalSemaphoreInfo,
pExternalSemaphoreProperties: *mut VkExternalSemaphoreProperties,
);
unsafe extern fn vkGetSemaphoreWin32HandleKHR(
device: VkDevice,
pGetWin32HandleInfo: *const VkSemaphoreGetWin32HandleInfoKHR,
pHandle: *mut HANDLE,
) -> VkResult;
unsafe extern fn vkImportSemaphoreWin32HandleKHR(
device: VkDevice,
pImportSemaphoreWin32HandleInfo: *const VkImportSemaphoreWin32HandleInfoKHR,
) -> VkResult;
unsafe extern fn vkGetSemaphoreFdKHR(
device: VkDevice,
pGetFdInfo: *const VkSemaphoreGetFdInfoKHR,
pFd: *mut int,
) -> VkResult;
unsafe extern fn vkImportSemaphoreFdKHR(
device: VkDevice,
pImportSemaphoreFdInfo: *const VkImportSemaphoreFdInfoKHR,
) -> VkResult;
unsafe extern fn vkGetSemaphoreZirconHandleFUCHSIA(
device: VkDevice,
pGetZirconHandleInfo: *const VkSemaphoreGetZirconHandleInfoFUCHSIA,
pZirconHandle: *mut zx_handle_t,
) -> VkResult;
unsafe extern fn vkImportSemaphoreZirconHandleFUCHSIA(
device: VkDevice,
pImportSemaphoreZirconHandleInfo: *const VkImportSemaphoreZirconHandleInfoFUCHSIA,
) -> VkResult;
unsafe extern fn vkGetPhysicalDeviceExternalFenceProperties(
physicalDevice: VkPhysicalDevice,
pExternalFenceInfo: *const VkPhysicalDeviceExternalFenceInfo,
pExternalFenceProperties: *mut VkExternalFenceProperties,
);
unsafe extern fn vkGetFenceWin32HandleKHR(
device: VkDevice,
pGetWin32HandleInfo: *const VkFenceGetWin32HandleInfoKHR,
pHandle: *mut HANDLE,
) -> VkResult;
unsafe extern fn vkImportFenceWin32HandleKHR(
device: VkDevice,
pImportFenceWin32HandleInfo: *const VkImportFenceWin32HandleInfoKHR,
) -> VkResult;
unsafe extern fn vkGetFenceFdKHR(
device: VkDevice,
pGetFdInfo: *const VkFenceGetFdInfoKHR,
pFd: *mut int,
) -> VkResult;
unsafe extern fn vkImportFenceFdKHR(
device: VkDevice,
pImportFenceFdInfo: *const VkImportFenceFdInfoKHR,
) -> VkResult;
unsafe extern fn vkGetFenceSciSyncFenceNV(
device: VkDevice,
pGetSciSyncHandleInfo: *const VkFenceGetSciSyncInfoNV,
pHandle: *mut void,
) -> VkResult;
unsafe extern fn vkGetFenceSciSyncObjNV(
device: VkDevice,
pGetSciSyncHandleInfo: *const VkFenceGetSciSyncInfoNV,
pHandle: *mut void,
) -> VkResult;
unsafe extern fn vkImportFenceSciSyncFenceNV(
device: VkDevice,
pImportFenceSciSyncInfo: *const VkImportFenceSciSyncInfoNV,
) -> VkResult;
unsafe extern fn vkImportFenceSciSyncObjNV(
device: VkDevice,
pImportFenceSciSyncInfo: *const VkImportFenceSciSyncInfoNV,
) -> VkResult;
unsafe extern fn vkGetSemaphoreSciSyncObjNV(
device: VkDevice,
pGetSciSyncInfo: *const VkSemaphoreGetSciSyncInfoNV,
pHandle: *mut void,
) -> VkResult;
unsafe extern fn vkImportSemaphoreSciSyncObjNV(
device: VkDevice,
pImportSemaphoreSciSyncInfo: *const VkImportSemaphoreSciSyncInfoNV,
) -> VkResult;
unsafe extern fn vkGetPhysicalDeviceSciSyncAttributesNV(
physicalDevice: VkPhysicalDevice,
pSciSyncAttributesInfo: *const VkSciSyncAttributesInfoNV,
pAttributes: NvSciSyncAttrList,
) -> VkResult;
unsafe extern fn vkCreateSemaphoreSciSyncPoolNV(
device: VkDevice,
pCreateInfo: *const VkSemaphoreSciSyncPoolCreateInfoNV,
pAllocator: *const VkAllocationCallbacks,
pSemaphorePool: *mut VkSemaphoreSciSyncPoolNV,
) -> VkResult;
unsafe extern fn vkDestroySemaphoreSciSyncPoolNV(
device: VkDevice,
semaphorePool: VkSemaphoreSciSyncPoolNV,
pAllocator: *const VkAllocationCallbacks,
);
unsafe extern fn vkReleaseDisplayEXT(
physicalDevice: VkPhysicalDevice,
display: VkDisplayKHR,
) -> VkResult;
unsafe extern fn vkAcquireXlibDisplayEXT(
physicalDevice: VkPhysicalDevice,
dpy: *mut Display,
display: VkDisplayKHR,
) -> VkResult;
unsafe extern fn vkGetRandROutputDisplayEXT(
physicalDevice: VkPhysicalDevice,
dpy: *mut Display,
rrOutput: RROutput,
pDisplay: *mut VkDisplayKHR,
) -> VkResult;
unsafe extern fn vkAcquireWinrtDisplayNV(
physicalDevice: VkPhysicalDevice,
display: VkDisplayKHR,
) -> VkResult;
unsafe extern fn vkGetWinrtDisplayNV(
physicalDevice: VkPhysicalDevice,
deviceRelativeId: uint32_t,
pDisplay: *mut VkDisplayKHR,
) -> VkResult;
unsafe extern fn vkDisplayPowerControlEXT(
device: VkDevice,
display: VkDisplayKHR,
pDisplayPowerInfo: *const VkDisplayPowerInfoEXT,
) -> VkResult;
unsafe extern fn vkRegisterDeviceEventEXT(
device: VkDevice,
pDeviceEventInfo: *const VkDeviceEventInfoEXT,
pAllocator: *const VkAllocationCallbacks,
pFence: *mut VkFence,
) -> VkResult;
unsafe extern fn vkRegisterDisplayEventEXT(
device: VkDevice,
display: VkDisplayKHR,
pDisplayEventInfo: *const VkDisplayEventInfoEXT,
pAllocator: *const VkAllocationCallbacks,
pFence: *mut VkFence,
) -> VkResult;
unsafe extern fn vkGetSwapchainCounterEXT(
device: VkDevice,
swapchain: VkSwapchainKHR,
counter: VkSurfaceCounterFlagBitsEXT,
pCounterValue: *mut uint64_t,
) -> VkResult;
unsafe extern fn vkGetPhysicalDeviceSurfaceCapabilities2EXT(
physicalDevice: VkPhysicalDevice,
surface: VkSurfaceKHR,
pSurfaceCapabilities: *mut VkSurfaceCapabilities2EXT,
) -> VkResult;
unsafe extern fn vkEnumeratePhysicalDeviceGroups(
instance: VkInstance,
pPhysicalDeviceGroupCount: *mut uint32_t,
pPhysicalDeviceGroupProperties: *mut [VkPhysicalDeviceGroupProperties; dyn pPhysicalDeviceGroupCount],
) -> VkResult;
unsafe extern fn vkGetDeviceGroupPeerMemoryFeatures(
device: VkDevice,
heapIndex: uint32_t,
localDeviceIndex: uint32_t,
remoteDeviceIndex: uint32_t,
pPeerMemoryFeatures: *mut VkPeerMemoryFeatureFlags,
);
unsafe extern fn vkBindBufferMemory2(
device: VkDevice,
bindInfoCount: uint32_t,
pBindInfos: *const [VkBindBufferMemoryInfo; dyn bindInfoCount],
) -> VkResult;
unsafe extern fn vkBindImageMemory2(
device: VkDevice,
bindInfoCount: uint32_t,
pBindInfos: *const [VkBindImageMemoryInfo; dyn bindInfoCount],
) -> VkResult;
unsafe extern fn vkCmdSetDeviceMask(
commandBuffer: VkCommandBuffer,
deviceMask: uint32_t,
);
unsafe extern fn vkGetDeviceGroupPresentCapabilitiesKHR(
device: VkDevice,
pDeviceGroupPresentCapabilities: *mut VkDeviceGroupPresentCapabilitiesKHR,
) -> VkResult;
unsafe extern fn vkGetDeviceGroupSurfacePresentModesKHR(
device: VkDevice,
surface: VkSurfaceKHR,
pModes: *mut VkDeviceGroupPresentModeFlagsKHR,
) -> VkResult;
unsafe extern fn vkAcquireNextImage2KHR(
device: VkDevice,
pAcquireInfo: *const VkAcquireNextImageInfoKHR,
pImageIndex: *mut uint32_t,
) -> VkResult;
unsafe extern fn vkCmdDispatchBase(
commandBuffer: VkCommandBuffer,
baseGroupX: uint32_t,
baseGroupY: uint32_t,
baseGroupZ: uint32_t,
groupCountX: uint32_t,
groupCountY: uint32_t,
groupCountZ: uint32_t,
);
unsafe extern fn vkGetPhysicalDevicePresentRectanglesKHR(
physicalDevice: VkPhysicalDevice,
surface: VkSurfaceKHR,
pRectCount: *mut uint32_t,
pRects: *mut [VkRect2D; dyn pRectCount],
) -> VkResult;
unsafe extern fn vkCreateDescriptorUpdateTemplate(
device: VkDevice,
pCreateInfo: *const VkDescriptorUpdateTemplateCreateInfo,
pAllocator: *const VkAllocationCallbacks,
pDescriptorUpdateTemplate: *mut VkDescriptorUpdateTemplate,
) -> VkResult;
unsafe extern fn vkDestroyDescriptorUpdateTemplate(
device: VkDevice,
descriptorUpdateTemplate: VkDescriptorUpdateTemplate,
pAllocator: *const VkAllocationCallbacks,
);
unsafe extern fn vkUpdateDescriptorSetWithTemplate(
device: VkDevice,
descriptorSet: VkDescriptorSet,
descriptorUpdateTemplate: VkDescriptorUpdateTemplate,
pData: *const void,
);
unsafe extern fn vkCmdPushDescriptorSetWithTemplateKHR(
commandBuffer: VkCommandBuffer,
descriptorUpdateTemplate: VkDescriptorUpdateTemplate,
layout: VkPipelineLayout,
set: uint32_t,
pData: *const void,
);
unsafe extern fn vkSetHdrMetadataEXT(
device: VkDevice,
swapchainCount: uint32_t,
pSwapchains: *const [VkSwapchainKHR; dyn swapchainCount],
pMetadata: *const [VkHdrMetadataEXT; dyn swapchainCount],
);
unsafe extern fn vkGetSwapchainStatusKHR(
device: VkDevice,
swapchain: VkSwapchainKHR,
) -> VkResult;
unsafe extern fn vkGetRefreshCycleDurationGOOGLE(
device: VkDevice,
swapchain: VkSwapchainKHR,
pDisplayTimingProperties: *mut VkRefreshCycleDurationGOOGLE,
) -> VkResult;
unsafe extern fn vkGetPastPresentationTimingGOOGLE(
device: VkDevice,
swapchain: VkSwapchainKHR,
pPresentationTimingCount: *mut uint32_t,
pPresentationTimings: *mut [VkPastPresentationTimingGOOGLE; dyn pPresentationTimingCount],
) -> VkResult;
unsafe extern fn vkCreateIOSSurfaceMVK(
instance: VkInstance,
pCreateInfo: *const VkIOSSurfaceCreateInfoMVK,
pAllocator: *const VkAllocationCallbacks,
pSurface: *mut VkSurfaceKHR,
) -> VkResult;
unsafe extern fn vkCreateMacOSSurfaceMVK(
instance: VkInstance,
pCreateInfo: *const VkMacOSSurfaceCreateInfoMVK,
pAllocator: *const VkAllocationCallbacks,
pSurface: *mut VkSurfaceKHR,
) -> VkResult;
unsafe extern fn vkCreateMetalSurfaceEXT(
instance: VkInstance,
pCreateInfo: *const VkMetalSurfaceCreateInfoEXT,
pAllocator: *const VkAllocationCallbacks,
pSurface: *mut VkSurfaceKHR,
) -> VkResult;
unsafe extern fn vkCmdSetViewportWScalingNV(
commandBuffer: VkCommandBuffer,
firstViewport: uint32_t,
viewportCount: uint32_t,
pViewportWScalings: *const [VkViewportWScalingNV; dyn viewportCount],
);
unsafe extern fn vkCmdSetDiscardRectangleEXT(
commandBuffer: VkCommandBuffer,
firstDiscardRectangle: uint32_t,
discardRectangleCount: uint32_t,
pDiscardRectangles: *const [VkRect2D; dyn discardRectangleCount],
);
unsafe extern fn vkCmdSetDiscardRectangleEnableEXT(
commandBuffer: VkCommandBuffer,
discardRectangleEnable: VkBool32,
);
unsafe extern fn vkCmdSetDiscardRectangleModeEXT(
commandBuffer: VkCommandBuffer,
discardRectangleMode: VkDiscardRectangleModeEXT,
);
unsafe extern fn vkCmdSetSampleLocationsEXT(
commandBuffer: VkCommandBuffer,
pSampleLocationsInfo: *const VkSampleLocationsInfoEXT,
);
unsafe extern fn vkGetPhysicalDeviceMultisamplePropertiesEXT(
physicalDevice: VkPhysicalDevice,
samples: VkSampleCountFlagBits,
pMultisampleProperties: *mut VkMultisamplePropertiesEXT,
);
unsafe extern fn vkGetPhysicalDeviceSurfaceCapabilities2KHR(
physicalDevice: VkPhysicalDevice,
pSurfaceInfo: *const VkPhysicalDeviceSurfaceInfo2KHR,
pSurfaceCapabilities: *mut VkSurfaceCapabilities2KHR,
) -> VkResult;
unsafe extern fn vkGetPhysicalDeviceSurfaceFormats2KHR(
physicalDevice: VkPhysicalDevice,
pSurfaceInfo: *const VkPhysicalDeviceSurfaceInfo2KHR,
pSurfaceFormatCount: *mut uint32_t,
pSurfaceFormats: *mut [VkSurfaceFormat2KHR; dyn pSurfaceFormatCount],
) -> VkResult;
unsafe extern fn vkGetPhysicalDeviceDisplayProperties2KHR(
physicalDevice: VkPhysicalDevice,
pPropertyCount: *mut uint32_t,
pProperties: *mut [VkDisplayProperties2KHR; dyn pPropertyCount],
) -> VkResult;
unsafe extern fn vkGetPhysicalDeviceDisplayPlaneProperties2KHR(
physicalDevice: VkPhysicalDevice,
pPropertyCount: *mut uint32_t,
pProperties: *mut [VkDisplayPlaneProperties2KHR; dyn pPropertyCount],
) -> VkResult;
unsafe extern fn vkGetDisplayModeProperties2KHR(
physicalDevice: VkPhysicalDevice,
display: VkDisplayKHR,
pPropertyCount: *mut uint32_t,
pProperties: *mut [VkDisplayModeProperties2KHR; dyn pPropertyCount],
) -> VkResult;
unsafe extern fn vkGetDisplayPlaneCapabilities2KHR(
physicalDevice: VkPhysicalDevice,
pDisplayPlaneInfo: *const VkDisplayPlaneInfo2KHR,
pCapabilities: *mut VkDisplayPlaneCapabilities2KHR,
) -> VkResult;
unsafe extern fn vkGetBufferMemoryRequirements2(
device: VkDevice,
pInfo: *const VkBufferMemoryRequirementsInfo2,
pMemoryRequirements: *mut VkMemoryRequirements2,
);
unsafe extern fn vkGetImageMemoryRequirements2(
device: VkDevice,
pInfo: *const VkImageMemoryRequirementsInfo2,
pMemoryRequirements: *mut VkMemoryRequirements2,
);
unsafe extern fn vkGetImageSparseMemoryRequirements2(
device: VkDevice,
pInfo: *const VkImageSparseMemoryRequirementsInfo2,
pSparseMemoryRequirementCount: *mut uint32_t,
pSparseMemoryRequirements: *mut [VkSparseImageMemoryRequirements2; dyn pSparseMemoryRequirementCount],
);
unsafe extern fn vkGetDeviceBufferMemoryRequirements(
device: VkDevice,
pInfo: *const VkDeviceBufferMemoryRequirements,
pMemoryRequirements: *mut VkMemoryRequirements2,
);
unsafe extern fn vkGetDeviceImageMemoryRequirements(
device: VkDevice,
pInfo: *const VkDeviceImageMemoryRequirements,
pMemoryRequirements: *mut VkMemoryRequirements2,
);
unsafe extern fn vkGetDeviceImageSparseMemoryRequirements(
device: VkDevice,
pInfo: *const VkDeviceImageMemoryRequirements,
pSparseMemoryRequirementCount: *mut uint32_t,
pSparseMemoryRequirements: *mut [VkSparseImageMemoryRequirements2; dyn pSparseMemoryRequirementCount],
);
unsafe extern fn vkCreateSamplerYcbcrConversion(
device: VkDevice,
pCreateInfo: *const VkSamplerYcbcrConversionCreateInfo,
pAllocator: *const VkAllocationCallbacks,
pYcbcrConversion: *mut VkSamplerYcbcrConversion,
) -> VkResult;
unsafe extern fn vkDestroySamplerYcbcrConversion(
device: VkDevice,
ycbcrConversion: VkSamplerYcbcrConversion,
pAllocator: *const VkAllocationCallbacks,
);
unsafe extern fn vkGetDeviceQueue2(
device: VkDevice,
pQueueInfo: *const VkDeviceQueueInfo2,
pQueue: *mut VkQueue,
);
unsafe extern fn vkCreateValidationCacheEXT(
device: VkDevice,
pCreateInfo: *const VkValidationCacheCreateInfoEXT,
pAllocator: *const VkAllocationCallbacks,
pValidationCache: *mut VkValidationCacheEXT,
) -> VkResult;
unsafe extern fn vkDestroyValidationCacheEXT(
device: VkDevice,
validationCache: VkValidationCacheEXT,
pAllocator: *const VkAllocationCallbacks,
);
unsafe extern fn vkGetValidationCacheDataEXT(
device: VkDevice,
validationCache: VkValidationCacheEXT,
pDataSize: *mut size_t,
pData: *mut [void; dyn pDataSize],
) -> VkResult;
unsafe extern fn vkMergeValidationCachesEXT(
device: VkDevice,
dstCache: VkValidationCacheEXT,
srcCacheCount: uint32_t,
pSrcCaches: *const [VkValidationCacheEXT; dyn srcCacheCount],
) -> VkResult;
unsafe extern fn vkGetDescriptorSetLayoutSupport(
device: VkDevice,
pCreateInfo: *const VkDescriptorSetLayoutCreateInfo,
pSupport: *mut VkDescriptorSetLayoutSupport,
);
unsafe extern fn vkGetSwapchainGrallocUsageANDROID(
device: VkDevice,
format: VkFormat,
imageUsage: VkImageUsageFlags,
grallocUsage: *mut int,
) -> VkResult;
unsafe extern fn vkGetSwapchainGrallocUsage2ANDROID(
device: VkDevice,
format: VkFormat,
imageUsage: VkImageUsageFlags,
swapchainImageUsage: VkSwapchainImageUsageFlagsANDROID,
grallocConsumerUsage: *mut uint64_t,
grallocProducerUsage: *mut uint64_t,
) -> VkResult;
unsafe extern fn vkAcquireImageANDROID(
device: VkDevice,
image: VkImage,
nativeFenceFd: int,
semaphore: VkSemaphore,
fence: VkFence,
) -> VkResult;
unsafe extern fn vkQueueSignalReleaseImageANDROID(
queue: VkQueue,
waitSemaphoreCount: uint32_t,
pWaitSemaphores: *const [VkSemaphore; dyn waitSemaphoreCount],
image: VkImage,
pNativeFenceFd: *mut int,
) -> VkResult;
unsafe extern fn vkGetShaderInfoAMD(
device: VkDevice,
pipeline: VkPipeline,
shaderStage: VkShaderStageFlagBits,
infoType: VkShaderInfoTypeAMD,
pInfoSize: *mut size_t,
pInfo: *mut [void; dyn pInfoSize],
) -> VkResult;
unsafe extern fn vkSetLocalDimmingAMD(
device: VkDevice,
swapChain: VkSwapchainKHR,
localDimmingEnable: VkBool32,
);
unsafe extern fn vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(
physicalDevice: VkPhysicalDevice,
pTimeDomainCount: *mut uint32_t,
pTimeDomains: *mut [VkTimeDomainEXT; dyn pTimeDomainCount],
) -> VkResult;
unsafe extern fn vkGetCalibratedTimestampsEXT(
device: VkDevice,
timestampCount: uint32_t,
pTimestampInfos: *const [VkCalibratedTimestampInfoEXT; dyn timestampCount],
pTimestamps: *mut [uint64_t; dyn timestampCount],
pMaxDeviation: *mut uint64_t,
) -> VkResult;
unsafe extern fn vkSetDebugUtilsObjectNameEXT(
device: VkDevice,
pNameInfo: *const VkDebugUtilsObjectNameInfoEXT,
) -> VkResult;
unsafe extern fn vkSetDebugUtilsObjectTagEXT(
device: VkDevice,
pTagInfo: *const VkDebugUtilsObjectTagInfoEXT,
) -> VkResult;
unsafe extern fn vkQueueBeginDebugUtilsLabelEXT(
queue: VkQueue,
pLabelInfo: *const VkDebugUtilsLabelEXT,
);
unsafe extern fn vkQueueEndDebugUtilsLabelEXT(
queue: VkQueue,
);
unsafe extern fn vkQueueInsertDebugUtilsLabelEXT(
queue: VkQueue,
pLabelInfo: *const VkDebugUtilsLabelEXT,
);
unsafe extern fn vkCmdBeginDebugUtilsLabelEXT(
commandBuffer: VkCommandBuffer,
pLabelInfo: *const VkDebugUtilsLabelEXT,
);
unsafe extern fn vkCmdEndDebugUtilsLabelEXT(
commandBuffer: VkCommandBuffer,
);
unsafe extern fn vkCmdInsertDebugUtilsLabelEXT(
commandBuffer: VkCommandBuffer,
pLabelInfo: *const VkDebugUtilsLabelEXT,
);
unsafe extern fn vkCreateDebugUtilsMessengerEXT(
instance: VkInstance,
pCreateInfo: *const VkDebugUtilsMessengerCreateInfoEXT,
pAllocator: *const VkAllocationCallbacks,
pMessenger: *mut VkDebugUtilsMessengerEXT,
) -> VkResult;
unsafe extern fn vkDestroyDebugUtilsMessengerEXT(
instance: VkInstance,
messenger: VkDebugUtilsMessengerEXT,
pAllocator: *const VkAllocationCallbacks,
);
unsafe extern fn vkSubmitDebugUtilsMessageEXT(
instance: VkInstance,
messageSeverity: VkDebugUtilsMessageSeverityFlagBitsEXT,
messageTypes: VkDebugUtilsMessageTypeFlagsEXT,
pCallbackData: *const VkDebugUtilsMessengerCallbackDataEXT,
);
unsafe extern fn vkGetMemoryHostPointerPropertiesEXT(
device: VkDevice,
handleType: VkExternalMemoryHandleTypeFlagBits,
pHostPointer: *const void,
pMemoryHostPointerProperties: *mut VkMemoryHostPointerPropertiesEXT,
) -> VkResult;
unsafe extern fn vkCmdWriteBufferMarkerAMD(
commandBuffer: VkCommandBuffer,
pipelineStage: VkPipelineStageFlagBits,
dstBuffer: VkBuffer,
dstOffset: VkDeviceSize,
marker: uint32_t,
);
unsafe extern fn vkCreateRenderPass2(
device: VkDevice,
pCreateInfo: *const VkRenderPassCreateInfo2,
pAllocator: *const VkAllocationCallbacks,
pRenderPass: *mut VkRenderPass,
) -> VkResult;
unsafe extern fn vkCmdBeginRenderPass2(
commandBuffer: VkCommandBuffer,
pRenderPassBegin: *const VkRenderPassBeginInfo,
pSubpassBeginInfo: *const VkSubpassBeginInfo,
);
unsafe extern fn vkCmdNextSubpass2(
commandBuffer: VkCommandBuffer,
pSubpassBeginInfo: *const VkSubpassBeginInfo,
pSubpassEndInfo: *const VkSubpassEndInfo,
);
unsafe extern fn vkCmdEndRenderPass2(
commandBuffer: VkCommandBuffer,
pSubpassEndInfo: *const VkSubpassEndInfo,
);
unsafe extern fn vkGetSemaphoreCounterValue(
device: VkDevice,
semaphore: VkSemaphore,
pValue: *mut uint64_t,
) -> VkResult;
unsafe extern fn vkWaitSemaphores(
device: VkDevice,
pWaitInfo: *const VkSemaphoreWaitInfo,
timeout: uint64_t,
) -> VkResult;
unsafe extern fn vkSignalSemaphore(
device: VkDevice,
pSignalInfo: *const VkSemaphoreSignalInfo,
) -> VkResult;
unsafe extern fn vkGetAndroidHardwareBufferPropertiesANDROID(
device: VkDevice,
buffer: *const /*struct*/AHardwareBuffer,
pProperties: *mut VkAndroidHardwareBufferPropertiesANDROID,
) -> VkResult;
unsafe extern fn vkGetMemoryAndroidHardwareBufferANDROID(
device: VkDevice,
pInfo: *const VkMemoryGetAndroidHardwareBufferInfoANDROID,
pBuffer: *mut *mut /*struct*/AHardwareBuffer,
) -> VkResult;
unsafe extern fn vkCmdDrawIndirectCount(
commandBuffer: VkCommandBuffer,
buffer: VkBuffer,
offset: VkDeviceSize,
countBuffer: VkBuffer,
countBufferOffset: VkDeviceSize,
maxDrawCount: uint32_t,
stride: uint32_t,
);
unsafe extern fn vkCmdDrawIndexedIndirectCount(
commandBuffer: VkCommandBuffer,
buffer: VkBuffer,
offset: VkDeviceSize,
countBuffer: VkBuffer,
countBufferOffset: VkDeviceSize,
maxDrawCount: uint32_t,
stride: uint32_t,
);
unsafe extern fn vkCmdSetCheckpointNV(
commandBuffer: VkCommandBuffer,
pCheckpointMarker: *const void,
);
unsafe extern fn vkGetQueueCheckpointDataNV(
queue: VkQueue,
pCheckpointDataCount: *mut uint32_t,
pCheckpointData: *mut [VkCheckpointDataNV; dyn pCheckpointDataCount],
);
unsafe extern fn vkCmdBindTransformFeedbackBuffersEXT(
commandBuffer: VkCommandBuffer,
firstBinding: uint32_t,
bindingCount: uint32_t,
pBuffers: *const [VkBuffer; dyn bindingCount],
pOffsets: *const [VkDeviceSize; dyn bindingCount],
pSizes: *const [VkDeviceSize; dyn bindingCount],
);
unsafe extern fn vkCmdBeginTransformFeedbackEXT(
commandBuffer: VkCommandBuffer,
firstCounterBuffer: uint32_t,
counterBufferCount: uint32_t,
pCounterBuffers: *const [VkBuffer; dyn counterBufferCount],
pCounterBufferOffsets: *const [VkDeviceSize; dyn counterBufferCount],
);
unsafe extern fn vkCmdEndTransformFeedbackEXT(
commandBuffer: VkCommandBuffer,
firstCounterBuffer: uint32_t,
counterBufferCount: uint32_t,
pCounterBuffers: *const [VkBuffer; dyn counterBufferCount],
pCounterBufferOffsets: *const [VkDeviceSize; dyn counterBufferCount],
);
unsafe extern fn vkCmdBeginQueryIndexedEXT(
commandBuffer: VkCommandBuffer,
queryPool: VkQueryPool,
query: uint32_t,
flags: VkQueryControlFlags,
index: uint32_t,
);
unsafe extern fn vkCmdEndQueryIndexedEXT(
commandBuffer: VkCommandBuffer,
queryPool: VkQueryPool,
query: uint32_t,
index: uint32_t,
);
unsafe extern fn vkCmdDrawIndirectByteCountEXT(
commandBuffer: VkCommandBuffer,
instanceCount: uint32_t,
firstInstance: uint32_t,
counterBuffer: VkBuffer,
counterBufferOffset: VkDeviceSize,
counterOffset: uint32_t,
vertexStride: uint32_t,
);
unsafe extern fn vkCmdSetExclusiveScissorNV(
commandBuffer: VkCommandBuffer,
firstExclusiveScissor: uint32_t,
exclusiveScissorCount: uint32_t,
pExclusiveScissors: *const [VkRect2D; dyn exclusiveScissorCount],
);
unsafe extern fn vkCmdSetExclusiveScissorEnableNV(
commandBuffer: VkCommandBuffer,
firstExclusiveScissor: uint32_t,
exclusiveScissorCount: uint32_t,
pExclusiveScissorEnables: *const [VkBool32; dyn exclusiveScissorCount],
);
unsafe extern fn vkCmdBindShadingRateImageNV(
commandBuffer: VkCommandBuffer,
imageView: VkImageView,
imageLayout: VkImageLayout,
);
unsafe extern fn vkCmdSetViewportShadingRatePaletteNV(
commandBuffer: VkCommandBuffer,
firstViewport: uint32_t,
viewportCount: uint32_t,
pShadingRatePalettes: *const [VkShadingRatePaletteNV; dyn viewportCount],
);
unsafe extern fn vkCmdSetCoarseSampleOrderNV(
commandBuffer: VkCommandBuffer,
sampleOrderType: VkCoarseSampleOrderTypeNV,
customSampleOrderCount: uint32_t,
pCustomSampleOrders: *const [VkCoarseSampleOrderCustomNV; dyn customSampleOrderCount],
);
unsafe extern fn vkCmdDrawMeshTasksNV(
commandBuffer: VkCommandBuffer,
taskCount: uint32_t,
firstTask: uint32_t,
);
unsafe extern fn vkCmdDrawMeshTasksIndirectNV(
commandBuffer: VkCommandBuffer,
buffer: VkBuffer,
offset: VkDeviceSize,
drawCount: uint32_t,
stride: uint32_t,
);
unsafe extern fn vkCmdDrawMeshTasksIndirectCountNV(
commandBuffer: VkCommandBuffer,
buffer: VkBuffer,
offset: VkDeviceSize,
countBuffer: VkBuffer,
countBufferOffset: VkDeviceSize,
maxDrawCount: uint32_t,
stride: uint32_t,
);
unsafe extern fn vkCmdDrawMeshTasksEXT(
commandBuffer: VkCommandBuffer,
groupCountX: uint32_t,
groupCountY: uint32_t,
groupCountZ: uint32_t,
);
unsafe extern fn vkCmdDrawMeshTasksIndirectEXT(
commandBuffer: VkCommandBuffer,
buffer: VkBuffer,
offset: VkDeviceSize,
drawCount: uint32_t,
stride: uint32_t,
);
unsafe extern fn vkCmdDrawMeshTasksIndirectCountEXT(
commandBuffer: VkCommandBuffer,
buffer: VkBuffer,
offset: VkDeviceSize,
countBuffer: VkBuffer,
countBufferOffset: VkDeviceSize,
maxDrawCount: uint32_t,
stride: uint32_t,
);
unsafe extern fn vkCompileDeferredNV(
device: VkDevice,
pipeline: VkPipeline,
shader: uint32_t,
) -> VkResult;
unsafe extern fn vkCreateAccelerationStructureNV(
device: VkDevice,
pCreateInfo: *const VkAccelerationStructureCreateInfoNV,
pAllocator: *const VkAllocationCallbacks,
pAccelerationStructure: *mut VkAccelerationStructureNV,
) -> VkResult;
unsafe extern fn vkCmdBindInvocationMaskHUAWEI(
commandBuffer: VkCommandBuffer,
imageView: VkImageView,
imageLayout: VkImageLayout,
);
unsafe extern fn vkDestroyAccelerationStructureKHR(
device: VkDevice,
accelerationStructure: VkAccelerationStructureKHR,
pAllocator: *const VkAllocationCallbacks,
);
unsafe extern fn vkDestroyAccelerationStructureNV(
device: VkDevice,
accelerationStructure: VkAccelerationStructureNV,
pAllocator: *const VkAllocationCallbacks,
);
unsafe extern fn vkGetAccelerationStructureMemoryRequirementsNV(
device: VkDevice,
pInfo: *const VkAccelerationStructureMemoryRequirementsInfoNV,
pMemoryRequirements: *mut VkMemoryRequirements2KHR,
);
unsafe extern fn vkBindAccelerationStructureMemoryNV(
device: VkDevice,
bindInfoCount: uint32_t,
pBindInfos: *const [VkBindAccelerationStructureMemoryInfoNV; dyn bindInfoCount],
) -> VkResult;
unsafe extern fn vkCmdCopyAccelerationStructureNV(
commandBuffer: VkCommandBuffer,
dst: VkAccelerationStructureNV,
src: VkAccelerationStructureNV,
mode: VkCopyAccelerationStructureModeKHR,
);
unsafe extern fn vkCmdCopyAccelerationStructureKHR(
commandBuffer: VkCommandBuffer,
pInfo: *const VkCopyAccelerationStructureInfoKHR,
);
unsafe extern fn vkCopyAccelerationStructureKHR(
device: VkDevice,
deferredOperation: VkDeferredOperationKHR,
pInfo: *const VkCopyAccelerationStructureInfoKHR,
) -> VkResult;
unsafe extern fn vkCmdCopyAccelerationStructureToMemoryKHR(
commandBuffer: VkCommandBuffer,
pInfo: *const VkCopyAccelerationStructureToMemoryInfoKHR,
);
unsafe extern fn vkCopyAccelerationStructureToMemoryKHR(
device: VkDevice,
deferredOperation: VkDeferredOperationKHR,
pInfo: *const VkCopyAccelerationStructureToMemoryInfoKHR,
) -> VkResult;
unsafe extern fn vkCmdCopyMemoryToAccelerationStructureKHR(
commandBuffer: VkCommandBuffer,
pInfo: *const VkCopyMemoryToAccelerationStructureInfoKHR,
);
unsafe extern fn vkCopyMemoryToAccelerationStructureKHR(
device: VkDevice,
deferredOperation: VkDeferredOperationKHR,
pInfo: *const VkCopyMemoryToAccelerationStructureInfoKHR,
) -> VkResult;
unsafe extern fn vkCmdWriteAccelerationStructuresPropertiesKHR(
commandBuffer: VkCommandBuffer,
accelerationStructureCount: uint32_t,
pAccelerationStructures: *const [VkAccelerationStructureKHR; dyn accelerationStructureCount],
queryType: VkQueryType,
queryPool: VkQueryPool,
firstQuery: uint32_t,
);
unsafe extern fn vkCmdWriteAccelerationStructuresPropertiesNV(
commandBuffer: VkCommandBuffer,
accelerationStructureCount: uint32_t,
pAccelerationStructures: *const [VkAccelerationStructureNV; dyn accelerationStructureCount],
queryType: VkQueryType,
queryPool: VkQueryPool,
firstQuery: uint32_t,
);
unsafe extern fn vkCmdBuildAccelerationStructureNV(
commandBuffer: VkCommandBuffer,
pInfo: *const VkAccelerationStructureInfoNV,
instanceData: VkBuffer,
instanceOffset: VkDeviceSize,
update: VkBool32,
dst: VkAccelerationStructureNV,
src: VkAccelerationStructureNV,
scratch: VkBuffer,
scratchOffset: VkDeviceSize,
);
unsafe extern fn vkWriteAccelerationStructuresPropertiesKHR(
device: VkDevice,
accelerationStructureCount: uint32_t,
pAccelerationStructures: *const [VkAccelerationStructureKHR; dyn accelerationStructureCount],
queryType: VkQueryType,
dataSize: size_t,
pData: *mut [void; dyn dataSize],
stride: size_t,
) -> VkResult;
unsafe extern fn vkCmdTraceRaysKHR(
commandBuffer: VkCommandBuffer,
pRaygenShaderBindingTable: *const VkStridedDeviceAddressRegionKHR,
pMissShaderBindingTable: *const VkStridedDeviceAddressRegionKHR,
pHitShaderBindingTable: *const VkStridedDeviceAddressRegionKHR,
pCallableShaderBindingTable: *const VkStridedDeviceAddressRegionKHR,
width: uint32_t,
height: uint32_t,
depth: uint32_t,
);
unsafe extern fn vkCmdTraceRaysNV(
commandBuffer: VkCommandBuffer,
raygenShaderBindingTableBuffer: VkBuffer,
raygenShaderBindingOffset: VkDeviceSize,
missShaderBindingTableBuffer: VkBuffer,
missShaderBindingOffset: VkDeviceSize,
missShaderBindingStride: VkDeviceSize,
hitShaderBindingTableBuffer: VkBuffer,
hitShaderBindingOffset: VkDeviceSize,
hitShaderBindingStride: VkDeviceSize,
callableShaderBindingTableBuffer: VkBuffer,
callableShaderBindingOffset: VkDeviceSize,
callableShaderBindingStride: VkDeviceSize,
width: uint32_t,
height: uint32_t,
depth: uint32_t,
);
unsafe extern fn vkGetRayTracingShaderGroupHandlesKHR(
device: VkDevice,
pipeline: VkPipeline,
firstGroup: uint32_t,
groupCount: uint32_t,
dataSize: size_t,
pData: *mut [void; dyn dataSize],
) -> VkResult;
unsafe extern fn vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(
device: VkDevice,
pipeline: VkPipeline,
firstGroup: uint32_t,
groupCount: uint32_t,
dataSize: size_t,
pData: *mut [void; dyn dataSize],
) -> VkResult;
unsafe extern fn vkGetAccelerationStructureHandleNV(
device: VkDevice,
accelerationStructure: VkAccelerationStructureNV,
dataSize: size_t,
pData: *mut [void; dyn dataSize],
) -> VkResult;
unsafe extern fn vkCreateRayTracingPipelinesNV(
device: VkDevice,
pipelineCache: VkPipelineCache,
createInfoCount: uint32_t,
pCreateInfos: *const [VkRayTracingPipelineCreateInfoNV; dyn createInfoCount],
pAllocator: *const VkAllocationCallbacks,
pPipelines: *mut [VkPipeline; dyn createInfoCount],
) -> VkResult;
unsafe extern fn vkCreateRayTracingPipelinesKHR(
device: VkDevice,
deferredOperation: VkDeferredOperationKHR,
pipelineCache: VkPipelineCache,
createInfoCount: uint32_t,
pCreateInfos: *const [VkRayTracingPipelineCreateInfoKHR; dyn createInfoCount],
pAllocator: *const VkAllocationCallbacks,
pPipelines: *mut [VkPipeline; dyn createInfoCount],
) -> VkResult;
unsafe extern fn vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(
physicalDevice: VkPhysicalDevice,
pPropertyCount: *mut uint32_t,
pProperties: *mut [VkCooperativeMatrixPropertiesNV; dyn pPropertyCount],
) -> VkResult;
unsafe extern fn vkCmdTraceRaysIndirectKHR(
commandBuffer: VkCommandBuffer,
pRaygenShaderBindingTable: *const VkStridedDeviceAddressRegionKHR,
pMissShaderBindingTable: *const VkStridedDeviceAddressRegionKHR,
pHitShaderBindingTable: *const VkStridedDeviceAddressRegionKHR,
pCallableShaderBindingTable: *const VkStridedDeviceAddressRegionKHR,
indirectDeviceAddress: VkDeviceAddress,
);
unsafe extern fn vkCmdTraceRaysIndirect2KHR(
commandBuffer: VkCommandBuffer,
indirectDeviceAddress: VkDeviceAddress,
);
unsafe extern fn vkGetDeviceAccelerationStructureCompatibilityKHR(
device: VkDevice,
pVersionInfo: *const VkAccelerationStructureVersionInfoKHR,
pCompatibility: *mut VkAccelerationStructureCompatibilityKHR,
);
unsafe extern fn vkGetRayTracingShaderGroupStackSizeKHR(
device: VkDevice,
pipeline: VkPipeline,
group: uint32_t,
groupShader: VkShaderGroupShaderKHR,
) -> VkDeviceSize;
unsafe extern fn vkCmdSetRayTracingPipelineStackSizeKHR(
commandBuffer: VkCommandBuffer,
pipelineStackSize: uint32_t,
);
unsafe extern fn vkGetImageViewHandleNVX(
device: VkDevice,
pInfo: *const VkImageViewHandleInfoNVX,
) -> uint32_t;
unsafe extern fn vkGetImageViewAddressNVX(
device: VkDevice,
imageView: VkImageView,
pProperties: *mut VkImageViewAddressPropertiesNVX,
) -> VkResult;
unsafe extern fn vkGetPhysicalDeviceSurfacePresentModes2EXT(
physicalDevice: VkPhysicalDevice,
pSurfaceInfo: *const VkPhysicalDeviceSurfaceInfo2KHR,
pPresentModeCount: *mut uint32_t,
pPresentModes: *mut [VkPresentModeKHR; dyn pPresentModeCount],
) -> VkResult;
unsafe extern fn vkGetDeviceGroupSurfacePresentModes2EXT(
device: VkDevice,
pSurfaceInfo: *const VkPhysicalDeviceSurfaceInfo2KHR,
pModes: *mut VkDeviceGroupPresentModeFlagsKHR,
) -> VkResult;
unsafe extern fn vkAcquireFullScreenExclusiveModeEXT(
device: VkDevice,
swapchain: VkSwapchainKHR,
) -> VkResult;
unsafe extern fn vkReleaseFullScreenExclusiveModeEXT(
device: VkDevice,
swapchain: VkSwapchainKHR,
) -> VkResult;
unsafe extern fn vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
physicalDevice: VkPhysicalDevice,
queueFamilyIndex: uint32_t,
pCounterCount: *mut uint32_t,
pCounters: *mut [VkPerformanceCounterKHR; dyn pCounterCount],
pCounterDescriptions: *mut [VkPerformanceCounterDescriptionKHR; dyn pCounterCount],
) -> VkResult;
unsafe extern fn vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(
physicalDevice: VkPhysicalDevice,
pPerformanceQueryCreateInfo: *const VkQueryPoolPerformanceCreateInfoKHR,
pNumPasses: *mut uint32_t,
);
unsafe extern fn vkAcquireProfilingLockKHR(
device: VkDevice,
pInfo: *const VkAcquireProfilingLockInfoKHR,
) -> VkResult;
unsafe extern fn vkReleaseProfilingLockKHR(
device: VkDevice,
);
unsafe extern fn vkGetImageDrmFormatModifierPropertiesEXT(
device: VkDevice,
image: VkImage,
pProperties: *mut VkImageDrmFormatModifierPropertiesEXT,
) -> VkResult;
unsafe extern fn vkGetBufferOpaqueCaptureAddress(
device: VkDevice,
pInfo: *const VkBufferDeviceAddressInfo,
) -> uint64_t;
unsafe extern fn vkGetBufferDeviceAddress(
device: VkDevice,
pInfo: *const VkBufferDeviceAddressInfo,
) -> VkDeviceAddress;
unsafe extern fn vkCreateHeadlessSurfaceEXT(
instance: VkInstance,
pCreateInfo: *const VkHeadlessSurfaceCreateInfoEXT,
pAllocator: *const VkAllocationCallbacks,
pSurface: *mut VkSurfaceKHR,
) -> VkResult;
unsafe extern fn vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
physicalDevice: VkPhysicalDevice,
pCombinationCount: *mut uint32_t,
pCombinations: *mut [VkFramebufferMixedSamplesCombinationNV; dyn pCombinationCount],
) -> VkResult;
unsafe extern fn vkInitializePerformanceApiINTEL(
device: VkDevice,
pInitializeInfo: *const VkInitializePerformanceApiInfoINTEL,
) -> VkResult;
unsafe extern fn vkUninitializePerformanceApiINTEL(
device: VkDevice,
);
unsafe extern fn vkCmdSetPerformanceMarkerINTEL(
commandBuffer: VkCommandBuffer,
pMarkerInfo: *const VkPerformanceMarkerInfoINTEL,
) -> VkResult;
unsafe extern fn vkCmdSetPerformanceStreamMarkerINTEL(
commandBuffer: VkCommandBuffer,
pMarkerInfo: *const VkPerformanceStreamMarkerInfoINTEL,
) -> VkResult;
unsafe extern fn vkCmdSetPerformanceOverrideINTEL(
commandBuffer: VkCommandBuffer,
pOverrideInfo: *const VkPerformanceOverrideInfoINTEL,
) -> VkResult;
unsafe extern fn vkAcquirePerformanceConfigurationINTEL(
device: VkDevice,
pAcquireInfo: *const VkPerformanceConfigurationAcquireInfoINTEL,
pConfiguration: *mut VkPerformanceConfigurationINTEL,
) -> VkResult;
unsafe extern fn vkReleasePerformanceConfigurationINTEL(
device: VkDevice,
configuration: VkPerformanceConfigurationINTEL,
) -> VkResult;
unsafe extern fn vkQueueSetPerformanceConfigurationINTEL(
queue: VkQueue,
configuration: VkPerformanceConfigurationINTEL,
) -> VkResult;
unsafe extern fn vkGetPerformanceParameterINTEL(
device: VkDevice,
parameter: VkPerformanceParameterTypeINTEL,
pValue: *mut VkPerformanceValueINTEL,
) -> VkResult;
unsafe extern fn vkGetDeviceMemoryOpaqueCaptureAddress(
device: VkDevice,
pInfo: *const VkDeviceMemoryOpaqueCaptureAddressInfo,
) -> uint64_t;
unsafe extern fn vkGetPipelineExecutablePropertiesKHR(
device: VkDevice,
pPipelineInfo: *const VkPipelineInfoKHR,
pExecutableCount: *mut uint32_t,
pProperties: *mut [VkPipelineExecutablePropertiesKHR; dyn pExecutableCount],
) -> VkResult;
unsafe extern fn vkGetPipelineExecutableStatisticsKHR(
device: VkDevice,
pExecutableInfo: *const VkPipelineExecutableInfoKHR,
pStatisticCount: *mut uint32_t,
pStatistics: *mut [VkPipelineExecutableStatisticKHR; dyn pStatisticCount],
) -> VkResult;
unsafe extern fn vkGetPipelineExecutableInternalRepresentationsKHR(
device: VkDevice,
pExecutableInfo: *const VkPipelineExecutableInfoKHR,
pInternalRepresentationCount: *mut uint32_t,
pInternalRepresentations: *mut [VkPipelineExecutableInternalRepresentationKHR; dyn pInternalRepresentationCount],
) -> VkResult;
unsafe extern fn vkCmdSetLineStippleEXT(
commandBuffer: VkCommandBuffer,
lineStippleFactor: uint32_t,
lineStipplePattern: uint16_t,
);
unsafe extern fn vkGetFaultData(
device: VkDevice,
faultQueryBehavior: VkFaultQueryBehavior,
pUnrecordedFaults: *mut VkBool32,
pFaultCount: *mut uint32_t,
pFaults: *mut [VkFaultData; dyn pFaultCount],
) -> VkResult;
unsafe extern fn vkGetPhysicalDeviceToolProperties(
physicalDevice: VkPhysicalDevice,
pToolCount: *mut uint32_t,
pToolProperties: *mut [VkPhysicalDeviceToolProperties; dyn pToolCount],
) -> VkResult;
unsafe extern fn vkCreateAccelerationStructureKHR(
device: VkDevice,
pCreateInfo: *const VkAccelerationStructureCreateInfoKHR,
pAllocator: *const VkAllocationCallbacks,
pAccelerationStructure: *mut VkAccelerationStructureKHR,
) -> VkResult;
unsafe extern fn vkCmdBuildAccelerationStructuresKHR(
commandBuffer: VkCommandBuffer,
infoCount: uint32_t,
pInfos: *const [VkAccelerationStructureBuildGeometryInfoKHR; dyn infoCount],
ppBuildRangeInfos: *const [*const VkAccelerationStructureBuildRangeInfoKHR; dyn infoCount],
);
unsafe extern fn vkCmdBuildAccelerationStructuresIndirectKHR(
commandBuffer: VkCommandBuffer,
infoCount: uint32_t,
pInfos: *const [VkAccelerationStructureBuildGeometryInfoKHR; dyn infoCount],
pIndirectDeviceAddresses: *const [VkDeviceAddress; dyn infoCount],
pIndirectStrides: *const [uint32_t; dyn infoCount],
ppMaxPrimitiveCounts: *const [*const uint32_t; dyn infoCount],
);
unsafe extern fn vkBuildAccelerationStructuresKHR(
device: VkDevice,
deferredOperation: VkDeferredOperationKHR,
infoCount: uint32_t,
pInfos: *const [VkAccelerationStructureBuildGeometryInfoKHR; dyn infoCount],
ppBuildRangeInfos: *const [*const VkAccelerationStructureBuildRangeInfoKHR; dyn infoCount],
) -> VkResult;
unsafe extern fn vkGetAccelerationStructureDeviceAddressKHR(
device: VkDevice,
pInfo: *const VkAccelerationStructureDeviceAddressInfoKHR,
) -> VkDeviceAddress;
unsafe extern fn vkCreateDeferredOperationKHR(
device: VkDevice,
pAllocator: *const VkAllocationCallbacks,
pDeferredOperation: *mut VkDeferredOperationKHR,
) -> VkResult;
unsafe extern fn vkDestroyDeferredOperationKHR(
device: VkDevice,
operation: VkDeferredOperationKHR,
pAllocator: *const VkAllocationCallbacks,
);
unsafe extern fn vkGetDeferredOperationMaxConcurrencyKHR(
device: VkDevice,
operation: VkDeferredOperationKHR,
) -> uint32_t;
unsafe extern fn vkGetDeferredOperationResultKHR(
device: VkDevice,
operation: VkDeferredOperationKHR,
) -> VkResult;
unsafe extern fn vkDeferredOperationJoinKHR(
device: VkDevice,
operation: VkDeferredOperationKHR,
) -> VkResult;
unsafe extern fn vkGetPipelineIndirectMemoryRequirementsNV(
device: VkDevice,
pCreateInfo: *const VkComputePipelineCreateInfo,
pMemoryRequirements: *mut VkMemoryRequirements2,
);
unsafe extern fn vkGetPipelineIndirectDeviceAddressNV(
device: VkDevice,
pInfo: *const VkPipelineIndirectDeviceAddressInfoNV,
) -> VkDeviceAddress;
unsafe extern fn vkCmdSetCullMode(
commandBuffer: VkCommandBuffer,
cullMode: VkCullModeFlags,
);
unsafe extern fn vkCmdSetFrontFace(
commandBuffer: VkCommandBuffer,
frontFace: VkFrontFace,
);
unsafe extern fn vkCmdSetPrimitiveTopology(
commandBuffer: VkCommandBuffer,
primitiveTopology: VkPrimitiveTopology,
);
unsafe extern fn vkCmdSetViewportWithCount(
commandBuffer: VkCommandBuffer,
viewportCount: uint32_t,
pViewports: *const [VkViewport; dyn viewportCount],
);
unsafe extern fn vkCmdSetScissorWithCount(
commandBuffer: VkCommandBuffer,
scissorCount: uint32_t,
pScissors: *const [VkRect2D; dyn scissorCount],
);
unsafe extern fn vkCmdBindIndexBuffer2KHR(
commandBuffer: VkCommandBuffer,
buffer: VkBuffer,
offset: VkDeviceSize,
size: VkDeviceSize,
indexType: VkIndexType,
);
unsafe extern fn vkCmdBindVertexBuffers2(
commandBuffer: VkCommandBuffer,
firstBinding: uint32_t,
bindingCount: uint32_t,
pBuffers: *const [VkBuffer; dyn bindingCount],
pOffsets: *const [VkDeviceSize; dyn bindingCount],
pSizes: *const [VkDeviceSize; dyn bindingCount],
pStrides: *const [VkDeviceSize; dyn bindingCount],
);
unsafe extern fn vkCmdSetDepthTestEnable(
commandBuffer: VkCommandBuffer,
depthTestEnable: VkBool32,
);
unsafe extern fn vkCmdSetDepthWriteEnable(
commandBuffer: VkCommandBuffer,
depthWriteEnable: VkBool32,
);
unsafe extern fn vkCmdSetDepthCompareOp(
commandBuffer: VkCommandBuffer,
depthCompareOp: VkCompareOp,
);
unsafe extern fn vkCmdSetDepthBoundsTestEnable(
commandBuffer: VkCommandBuffer,
depthBoundsTestEnable: VkBool32,
);
unsafe extern fn vkCmdSetStencilTestEnable(
commandBuffer: VkCommandBuffer,
stencilTestEnable: VkBool32,
);
unsafe extern fn vkCmdSetStencilOp(
commandBuffer: VkCommandBuffer,
faceMask: VkStencilFaceFlags,
failOp: VkStencilOp,
passOp: VkStencilOp,
depthFailOp: VkStencilOp,
compareOp: VkCompareOp,
);
unsafe extern fn vkCmdSetPatchControlPointsEXT(
commandBuffer: VkCommandBuffer,
patchControlPoints: uint32_t,
);
unsafe extern fn vkCmdSetRasterizerDiscardEnable(
commandBuffer: VkCommandBuffer,
rasterizerDiscardEnable: VkBool32,
);
unsafe extern fn vkCmdSetDepthBiasEnable(
commandBuffer: VkCommandBuffer,
depthBiasEnable: VkBool32,
);
unsafe extern fn vkCmdSetLogicOpEXT(
commandBuffer: VkCommandBuffer,
logicOp: VkLogicOp,
);
unsafe extern fn vkCmdSetPrimitiveRestartEnable(
commandBuffer: VkCommandBuffer,
primitiveRestartEnable: VkBool32,
);
unsafe extern fn vkCmdSetTessellationDomainOriginEXT(
commandBuffer: VkCommandBuffer,
domainOrigin: VkTessellationDomainOrigin,
);
unsafe extern fn vkCmdSetDepthClampEnableEXT(
commandBuffer: VkCommandBuffer,
depthClampEnable: VkBool32,
);
unsafe extern fn vkCmdSetPolygonModeEXT(
commandBuffer: VkCommandBuffer,
polygonMode: VkPolygonMode,
);
unsafe extern fn vkCmdSetRasterizationSamplesEXT(
commandBuffer: VkCommandBuffer,
rasterizationSamples: VkSampleCountFlagBits,
);
unsafe extern fn vkCmdSetSampleMaskEXT(
commandBuffer: VkCommandBuffer,
samples: VkSampleCountFlagBits,
pSampleMask: *const [VkSampleMask; dyn (samples + 31) / 32],
);
unsafe extern fn vkCmdSetAlphaToCoverageEnableEXT(
commandBuffer: VkCommandBuffer,
alphaToCoverageEnable: VkBool32,
);
unsafe extern fn vkCmdSetAlphaToOneEnableEXT(
commandBuffer: VkCommandBuffer,
alphaToOneEnable: VkBool32,
);
unsafe extern fn vkCmdSetLogicOpEnableEXT(
commandBuffer: VkCommandBuffer,
logicOpEnable: VkBool32,
);
unsafe extern fn vkCmdSetColorBlendEnableEXT(
commandBuffer: VkCommandBuffer,
firstAttachment: uint32_t,
attachmentCount: uint32_t,
pColorBlendEnables: *const [VkBool32; dyn attachmentCount],
);
unsafe extern fn vkCmdSetColorBlendEquationEXT(
commandBuffer: VkCommandBuffer,
firstAttachment: uint32_t,
attachmentCount: uint32_t,
pColorBlendEquations: *const [VkColorBlendEquationEXT; dyn attachmentCount],
);
unsafe extern fn vkCmdSetColorWriteMaskEXT(
commandBuffer: VkCommandBuffer,
firstAttachment: uint32_t,
attachmentCount: uint32_t,
pColorWriteMasks: *const [VkColorComponentFlags; dyn attachmentCount],
);
unsafe extern fn vkCmdSetRasterizationStreamEXT(
commandBuffer: VkCommandBuffer,
rasterizationStream: uint32_t,
);
unsafe extern fn vkCmdSetConservativeRasterizationModeEXT(
commandBuffer: VkCommandBuffer,
conservativeRasterizationMode: VkConservativeRasterizationModeEXT,
);
unsafe extern fn vkCmdSetExtraPrimitiveOverestimationSizeEXT(
commandBuffer: VkCommandBuffer,
extraPrimitiveOverestimationSize: float,
);
unsafe extern fn vkCmdSetDepthClipEnableEXT(
commandBuffer: VkCommandBuffer,
depthClipEnable: VkBool32,
);
unsafe extern fn vkCmdSetSampleLocationsEnableEXT(
commandBuffer: VkCommandBuffer,
sampleLocationsEnable: VkBool32,
);
unsafe extern fn vkCmdSetColorBlendAdvancedEXT(
commandBuffer: VkCommandBuffer,
firstAttachment: uint32_t,
attachmentCount: uint32_t,
pColorBlendAdvanced: *const [VkColorBlendAdvancedEXT; dyn attachmentCount],
);
unsafe extern fn vkCmdSetProvokingVertexModeEXT(
commandBuffer: VkCommandBuffer,
provokingVertexMode: VkProvokingVertexModeEXT,
);
unsafe extern fn vkCmdSetLineRasterizationModeEXT(
commandBuffer: VkCommandBuffer,
lineRasterizationMode: VkLineRasterizationModeEXT,
);
unsafe extern fn vkCmdSetLineStippleEnableEXT(
commandBuffer: VkCommandBuffer,
stippledLineEnable: VkBool32,
);
unsafe extern fn vkCmdSetDepthClipNegativeOneToOneEXT(
commandBuffer: VkCommandBuffer,
negativeOneToOne: VkBool32,
);
unsafe extern fn vkCmdSetViewportWScalingEnableNV(
commandBuffer: VkCommandBuffer,
viewportWScalingEnable: VkBool32,
);
unsafe extern fn vkCmdSetViewportSwizzleNV(
commandBuffer: VkCommandBuffer,
firstViewport: uint32_t,
viewportCount: uint32_t,
pViewportSwizzles: *const [VkViewportSwizzleNV; dyn viewportCount],
);
unsafe extern fn vkCmdSetCoverageToColorEnableNV(
commandBuffer: VkCommandBuffer,
coverageToColorEnable: VkBool32,
);
unsafe extern fn vkCmdSetCoverageToColorLocationNV(
commandBuffer: VkCommandBuffer,
coverageToColorLocation: uint32_t,
);
unsafe extern fn vkCmdSetCoverageModulationModeNV(
commandBuffer: VkCommandBuffer,
coverageModulationMode: VkCoverageModulationModeNV,
);
unsafe extern fn vkCmdSetCoverageModulationTableEnableNV(
commandBuffer: VkCommandBuffer,
coverageModulationTableEnable: VkBool32,
);
unsafe extern fn vkCmdSetCoverageModulationTableNV(
commandBuffer: VkCommandBuffer,
coverageModulationTableCount: uint32_t,
pCoverageModulationTable: *const [float; dyn coverageModulationTableCount],
);
unsafe extern fn vkCmdSetShadingRateImageEnableNV(
commandBuffer: VkCommandBuffer,
shadingRateImageEnable: VkBool32,
);
unsafe extern fn vkCmdSetCoverageReductionModeNV(
commandBuffer: VkCommandBuffer,
coverageReductionMode: VkCoverageReductionModeNV,
);
unsafe extern fn vkCmdSetRepresentativeFragmentTestEnableNV(
commandBuffer: VkCommandBuffer,
representativeFragmentTestEnable: VkBool32,
);
unsafe extern fn vkCreatePrivateDataSlot(
device: VkDevice,
pCreateInfo: *const VkPrivateDataSlotCreateInfo,
pAllocator: *const VkAllocationCallbacks,
pPrivateDataSlot: *mut VkPrivateDataSlot,
) -> VkResult;
unsafe extern fn vkDestroyPrivateDataSlot(
device: VkDevice,
privateDataSlot: VkPrivateDataSlot,
pAllocator: *const VkAllocationCallbacks,
);
unsafe extern fn vkSetPrivateData(
device: VkDevice,
objectType: VkObjectType,
objectHandle: uint64_t,
privateDataSlot: VkPrivateDataSlot,
data: uint64_t,
) -> VkResult;
unsafe extern fn vkGetPrivateData(
device: VkDevice,
objectType: VkObjectType,
objectHandle: uint64_t,
privateDataSlot: VkPrivateDataSlot,
pData: *mut uint64_t,
);
unsafe extern fn vkCmdCopyBuffer2(
commandBuffer: VkCommandBuffer,
pCopyBufferInfo: *const VkCopyBufferInfo2,
);
unsafe extern fn vkCmdCopyImage2(
commandBuffer: VkCommandBuffer,
pCopyImageInfo: *const VkCopyImageInfo2,
);
unsafe extern fn vkCmdBlitImage2(
commandBuffer: VkCommandBuffer,
pBlitImageInfo: *const VkBlitImageInfo2,
);
unsafe extern fn vkCmdCopyBufferToImage2(
commandBuffer: VkCommandBuffer,
pCopyBufferToImageInfo: *const VkCopyBufferToImageInfo2,
);
unsafe extern fn vkCmdCopyImageToBuffer2(
commandBuffer: VkCommandBuffer,
pCopyImageToBufferInfo: *const VkCopyImageToBufferInfo2,
);
unsafe extern fn vkCmdResolveImage2(
commandBuffer: VkCommandBuffer,
pResolveImageInfo: *const VkResolveImageInfo2,
);
unsafe extern fn vkCmdRefreshObjectsKHR(
commandBuffer: VkCommandBuffer,
pRefreshObjects: *const VkRefreshObjectListKHR,
);
unsafe extern fn vkGetPhysicalDeviceRefreshableObjectTypesKHR(
physicalDevice: VkPhysicalDevice,
pRefreshableObjectTypeCount: *mut uint32_t,
pRefreshableObjectTypes: *mut [VkObjectType; dyn pRefreshableObjectTypeCount],
) -> VkResult;
unsafe extern fn vkCmdSetFragmentShadingRateKHR(
commandBuffer: VkCommandBuffer,
pFragmentSize: *const VkExtent2D,
combinerOps: *const [VkFragmentShadingRateCombinerOpKHR; 2],
);
unsafe extern fn vkGetPhysicalDeviceFragmentShadingRatesKHR(
physicalDevice: VkPhysicalDevice,
pFragmentShadingRateCount: *mut uint32_t,
pFragmentShadingRates: *mut [VkPhysicalDeviceFragmentShadingRateKHR; dyn pFragmentShadingRateCount],
) -> VkResult;
unsafe extern fn vkCmdSetFragmentShadingRateEnumNV(
commandBuffer: VkCommandBuffer,
shadingRate: VkFragmentShadingRateNV,
combinerOps: *const [VkFragmentShadingRateCombinerOpKHR; 2],
);
unsafe extern fn vkGetAccelerationStructureBuildSizesKHR(
device: VkDevice,
buildType: VkAccelerationStructureBuildTypeKHR,
pBuildInfo: *const VkAccelerationStructureBuildGeometryInfoKHR,
pMaxPrimitiveCounts: *const [uint32_t; dyn pBuildInfo->geometryCount],
pSizeInfo: *mut VkAccelerationStructureBuildSizesInfoKHR,
);
unsafe extern fn vkCmdSetVertexInputEXT(
commandBuffer: VkCommandBuffer,
vertexBindingDescriptionCount: uint32_t,
pVertexBindingDescriptions: *const [VkVertexInputBindingDescription2EXT; dyn vertexBindingDescriptionCount],
vertexAttributeDescriptionCount: uint32_t,
pVertexAttributeDescriptions: *const [VkVertexInputAttributeDescription2EXT; dyn vertexAttributeDescriptionCount],
);
unsafe extern fn vkCmdSetColorWriteEnableEXT(
commandBuffer: VkCommandBuffer,
attachmentCount: uint32_t,
pColorWriteEnables: *const [VkBool32; dyn attachmentCount],
);
unsafe extern fn vkCmdSetEvent2(
commandBuffer: VkCommandBuffer,
event: VkEvent,
pDependencyInfo: *const VkDependencyInfo,
);
unsafe extern fn vkCmdResetEvent2(
commandBuffer: VkCommandBuffer,
event: VkEvent,
stageMask: VkPipelineStageFlags2,
);
unsafe extern fn vkCmdWaitEvents2(
commandBuffer: VkCommandBuffer,
eventCount: uint32_t,
pEvents: *const [VkEvent; dyn eventCount],
pDependencyInfos: *const [VkDependencyInfo; dyn eventCount],
);
unsafe extern fn vkCmdPipelineBarrier2(
commandBuffer: VkCommandBuffer,
pDependencyInfo: *const VkDependencyInfo,
);
unsafe extern fn vkQueueSubmit2(
queue: VkQueue,
submitCount: uint32_t,
pSubmits: *const [VkSubmitInfo2; dyn submitCount],
fence: VkFence,
) -> VkResult;
unsafe extern fn vkCmdWriteTimestamp2(
commandBuffer: VkCommandBuffer,
stage: VkPipelineStageFlags2,
queryPool: VkQueryPool,
query: uint32_t,
);
unsafe extern fn vkCmdWriteBufferMarker2AMD(
commandBuffer: VkCommandBuffer,
stage: VkPipelineStageFlags2,
dstBuffer: VkBuffer,
dstOffset: VkDeviceSize,
marker: uint32_t,
);
unsafe extern fn vkGetQueueCheckpointData2NV(
queue: VkQueue,
pCheckpointDataCount: *mut uint32_t,
pCheckpointData: *mut [VkCheckpointData2NV; dyn pCheckpointDataCount],
);
unsafe extern fn vkCopyMemoryToImageEXT(
device: VkDevice,
pCopyMemoryToImageInfo: *const VkCopyMemoryToImageInfoEXT,
) -> VkResult;
unsafe extern fn vkCopyImageToMemoryEXT(
device: VkDevice,
pCopyImageToMemoryInfo: *const VkCopyImageToMemoryInfoEXT,
) -> VkResult;
unsafe extern fn vkCopyImageToImageEXT(
device: VkDevice,
pCopyImageToImageInfo: *const VkCopyImageToImageInfoEXT,
) -> VkResult;
unsafe extern fn vkTransitionImageLayoutEXT(
device: VkDevice,
transitionCount: uint32_t,
pTransitions: *const [VkHostImageLayoutTransitionInfoEXT; dyn transitionCount],
) -> VkResult;
unsafe extern fn vkGetCommandPoolMemoryConsumption(
device: VkDevice,
commandPool: VkCommandPool,
commandBuffer: VkCommandBuffer,
pConsumption: *mut VkCommandPoolMemoryConsumption,
);
unsafe extern fn vkGetPhysicalDeviceVideoCapabilitiesKHR(
physicalDevice: VkPhysicalDevice,
pVideoProfile: *const VkVideoProfileInfoKHR,
pCapabilities: *mut VkVideoCapabilitiesKHR,
) -> VkResult;
unsafe extern fn vkGetPhysicalDeviceVideoFormatPropertiesKHR(
physicalDevice: VkPhysicalDevice,
pVideoFormatInfo: *const VkPhysicalDeviceVideoFormatInfoKHR,
pVideoFormatPropertyCount: *mut uint32_t,
pVideoFormatProperties: *mut [VkVideoFormatPropertiesKHR; dyn pVideoFormatPropertyCount],
) -> VkResult;
unsafe extern fn vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(
physicalDevice: VkPhysicalDevice,
pQualityLevelInfo: *const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR,
pQualityLevelProperties: *mut VkVideoEncodeQualityLevelPropertiesKHR,
) -> VkResult;
unsafe extern fn vkCreateVideoSessionKHR(
device: VkDevice,
pCreateInfo: *const VkVideoSessionCreateInfoKHR,
pAllocator: *const VkAllocationCallbacks,
pVideoSession: *mut VkVideoSessionKHR,
) -> VkResult;
unsafe extern fn vkDestroyVideoSessionKHR(
device: VkDevice,
videoSession: VkVideoSessionKHR,
pAllocator: *const VkAllocationCallbacks,
);
unsafe extern fn vkCreateVideoSessionParametersKHR(
device: VkDevice,
pCreateInfo: *const VkVideoSessionParametersCreateInfoKHR,
pAllocator: *const VkAllocationCallbacks,
pVideoSessionParameters: *mut VkVideoSessionParametersKHR,
) -> VkResult;
unsafe extern fn vkUpdateVideoSessionParametersKHR(
device: VkDevice,
videoSessionParameters: VkVideoSessionParametersKHR,
pUpdateInfo: *const VkVideoSessionParametersUpdateInfoKHR,
) -> VkResult;
unsafe extern fn vkGetEncodedVideoSessionParametersKHR(
device: VkDevice,
pVideoSessionParametersInfo: *const VkVideoEncodeSessionParametersGetInfoKHR,
pFeedbackInfo: *mut VkVideoEncodeSessionParametersFeedbackInfoKHR,
pDataSize: *mut size_t,
pData: *mut [void; dyn pDataSize],
) -> VkResult;
unsafe extern fn vkDestroyVideoSessionParametersKHR(
device: VkDevice,
videoSessionParameters: VkVideoSessionParametersKHR,
pAllocator: *const VkAllocationCallbacks,
);
unsafe extern fn vkGetVideoSessionMemoryRequirementsKHR(
device: VkDevice,
videoSession: VkVideoSessionKHR,
pMemoryRequirementsCount: *mut uint32_t,
pMemoryRequirements: *mut [VkVideoSessionMemoryRequirementsKHR; dyn pMemoryRequirementsCount],
) -> VkResult;
unsafe extern fn vkBindVideoSessionMemoryKHR(
device: VkDevice,
videoSession: VkVideoSessionKHR,
bindSessionMemoryInfoCount: uint32_t,
pBindSessionMemoryInfos: *const [VkBindVideoSessionMemoryInfoKHR; dyn bindSessionMemoryInfoCount],
) -> VkResult;
unsafe extern fn vkCmdDecodeVideoKHR(
commandBuffer: VkCommandBuffer,
pDecodeInfo: *const VkVideoDecodeInfoKHR,
);
unsafe extern fn vkCmdBeginVideoCodingKHR(
commandBuffer: VkCommandBuffer,
pBeginInfo: *const VkVideoBeginCodingInfoKHR,
);
unsafe extern fn vkCmdControlVideoCodingKHR(
commandBuffer: VkCommandBuffer,
pCodingControlInfo: *const VkVideoCodingControlInfoKHR,
);
unsafe extern fn vkCmdEndVideoCodingKHR(
commandBuffer: VkCommandBuffer,
pEndCodingInfo: *const VkVideoEndCodingInfoKHR,
);
unsafe extern fn vkCmdEncodeVideoKHR(
commandBuffer: VkCommandBuffer,
pEncodeInfo: *const VkVideoEncodeInfoKHR,
);
unsafe extern fn vkCmdDecompressMemoryNV(
commandBuffer: VkCommandBuffer,
decompressRegionCount: uint32_t,
pDecompressMemoryRegions: *const [VkDecompressMemoryRegionNV; dyn decompressRegionCount],
);
unsafe extern fn vkCmdDecompressMemoryIndirectCountNV(
commandBuffer: VkCommandBuffer,
indirectCommandsAddress: VkDeviceAddress,
indirectCommandsCountAddress: VkDeviceAddress,
stride: uint32_t,
);
unsafe extern fn vkCreateCuModuleNVX(
device: VkDevice,
pCreateInfo: *const VkCuModuleCreateInfoNVX,
pAllocator: *const VkAllocationCallbacks,
pModule: *mut VkCuModuleNVX,
) -> VkResult;
unsafe extern fn vkCreateCuFunctionNVX(
device: VkDevice,
pCreateInfo: *const VkCuFunctionCreateInfoNVX,
pAllocator: *const VkAllocationCallbacks,
pFunction: *mut VkCuFunctionNVX,
) -> VkResult;
unsafe extern fn vkDestroyCuModuleNVX(
device: VkDevice,
module: VkCuModuleNVX,
pAllocator: *const VkAllocationCallbacks,
);
unsafe extern fn vkDestroyCuFunctionNVX(
device: VkDevice,
function: VkCuFunctionNVX,
pAllocator: *const VkAllocationCallbacks,
);
unsafe extern fn vkCmdCuLaunchKernelNVX(
commandBuffer: VkCommandBuffer,
pLaunchInfo: *const VkCuLaunchInfoNVX,
);
unsafe extern fn vkGetDescriptorSetLayoutSizeEXT(
device: VkDevice,
layout: VkDescriptorSetLayout,
pLayoutSizeInBytes: *mut VkDeviceSize,
);
unsafe extern fn vkGetDescriptorSetLayoutBindingOffsetEXT(
device: VkDevice,
layout: VkDescriptorSetLayout,
binding: uint32_t,
pOffset: *mut VkDeviceSize,
);
unsafe extern fn vkGetDescriptorEXT(
device: VkDevice,
pDescriptorInfo: *const VkDescriptorGetInfoEXT,
dataSize: size_t,
pDescriptor: *mut [void; dyn dataSize],
);
unsafe extern fn vkCmdBindDescriptorBuffersEXT(
commandBuffer: VkCommandBuffer,
bufferCount: uint32_t,
pBindingInfos: *const [VkDescriptorBufferBindingInfoEXT; dyn bufferCount],
);
unsafe extern fn vkCmdSetDescriptorBufferOffsetsEXT(
commandBuffer: VkCommandBuffer,
pipelineBindPoint: VkPipelineBindPoint,
layout: VkPipelineLayout,
firstSet: uint32_t,
setCount: uint32_t,
pBufferIndices: *const [uint32_t; dyn setCount],
pOffsets: *const [VkDeviceSize; dyn setCount],
);
unsafe extern fn vkCmdBindDescriptorBufferEmbeddedSamplersEXT(
commandBuffer: VkCommandBuffer,
pipelineBindPoint: VkPipelineBindPoint,
layout: VkPipelineLayout,
set: uint32_t,
);
unsafe extern fn vkGetBufferOpaqueCaptureDescriptorDataEXT(
device: VkDevice,
pInfo: *const VkBufferCaptureDescriptorDataInfoEXT,
pData: *mut void,
) -> VkResult;
unsafe extern fn vkGetImageOpaqueCaptureDescriptorDataEXT(
device: VkDevice,
pInfo: *const VkImageCaptureDescriptorDataInfoEXT,
pData: *mut void,
) -> VkResult;
unsafe extern fn vkGetImageViewOpaqueCaptureDescriptorDataEXT(
device: VkDevice,
pInfo: *const VkImageViewCaptureDescriptorDataInfoEXT,
pData: *mut void,
) -> VkResult;
unsafe extern fn vkGetSamplerOpaqueCaptureDescriptorDataEXT(
device: VkDevice,
pInfo: *const VkSamplerCaptureDescriptorDataInfoEXT,
pData: *mut void,
) -> VkResult;
unsafe extern fn vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(
device: VkDevice,
pInfo: *const VkAccelerationStructureCaptureDescriptorDataInfoEXT,
pData: *mut void,
) -> VkResult;
unsafe extern fn vkSetDeviceMemoryPriorityEXT(
device: VkDevice,
memory: VkDeviceMemory,
priority: float,
);
unsafe extern fn vkAcquireDrmDisplayEXT(
physicalDevice: VkPhysicalDevice,
drmFd: int32_t,
display: VkDisplayKHR,
) -> VkResult;
unsafe extern fn vkGetDrmDisplayEXT(
physicalDevice: VkPhysicalDevice,
drmFd: int32_t,
connectorId: uint32_t,
display: *mut VkDisplayKHR,
) -> VkResult;
unsafe extern fn vkWaitForPresentKHR(
device: VkDevice,
swapchain: VkSwapchainKHR,
presentId: uint64_t,
timeout: uint64_t,
) -> VkResult;
unsafe extern fn vkCreateBufferCollectionFUCHSIA(
device: VkDevice,
pCreateInfo: *const VkBufferCollectionCreateInfoFUCHSIA,
pAllocator: *const VkAllocationCallbacks,
pCollection: *mut VkBufferCollectionFUCHSIA,
) -> VkResult;
unsafe extern fn vkSetBufferCollectionBufferConstraintsFUCHSIA(
device: VkDevice,
collection: VkBufferCollectionFUCHSIA,
pBufferConstraintsInfo: *const VkBufferConstraintsInfoFUCHSIA,
) -> VkResult;
unsafe extern fn vkSetBufferCollectionImageConstraintsFUCHSIA(
device: VkDevice,
collection: VkBufferCollectionFUCHSIA,
pImageConstraintsInfo: *const VkImageConstraintsInfoFUCHSIA,
) -> VkResult;
unsafe extern fn vkDestroyBufferCollectionFUCHSIA(
device: VkDevice,
collection: VkBufferCollectionFUCHSIA,
pAllocator: *const VkAllocationCallbacks,
);
unsafe extern fn vkGetBufferCollectionPropertiesFUCHSIA(
device: VkDevice,
collection: VkBufferCollectionFUCHSIA,
pProperties: *mut VkBufferCollectionPropertiesFUCHSIA,
) -> VkResult;
unsafe extern fn vkCreateCudaModuleNV(
device: VkDevice,
pCreateInfo: *const VkCudaModuleCreateInfoNV,
pAllocator: *const VkAllocationCallbacks,
pModule: *mut VkCudaModuleNV,
) -> VkResult;
unsafe extern fn vkGetCudaModuleCacheNV(
device: VkDevice,
module: VkCudaModuleNV,
pCacheSize: *mut size_t,
pCacheData: *mut [void; dyn pCacheSize],
) -> VkResult;
unsafe extern fn vkCreateCudaFunctionNV(
device: VkDevice,
pCreateInfo: *const VkCudaFunctionCreateInfoNV,
pAllocator: *const VkAllocationCallbacks,
pFunction: *mut VkCudaFunctionNV,
) -> VkResult;
unsafe extern fn vkDestroyCudaModuleNV(
device: VkDevice,
module: VkCudaModuleNV,
pAllocator: *const VkAllocationCallbacks,
);
unsafe extern fn vkDestroyCudaFunctionNV(
device: VkDevice,
function: VkCudaFunctionNV,
pAllocator: *const VkAllocationCallbacks,
);
unsafe extern fn vkCmdCudaLaunchKernelNV(
commandBuffer: VkCommandBuffer,
pLaunchInfo: *const VkCudaLaunchInfoNV,
);
unsafe extern fn vkCmdBeginRendering(
commandBuffer: VkCommandBuffer,
pRenderingInfo: *const VkRenderingInfo,
);
unsafe extern fn vkCmdEndRendering(
commandBuffer: VkCommandBuffer,
);
unsafe extern fn vkGetDescriptorSetLayoutHostMappingInfoVALVE(
device: VkDevice,
pBindingReference: *const VkDescriptorSetBindingReferenceVALVE,
pHostMapping: *mut VkDescriptorSetLayoutHostMappingInfoVALVE,
);
unsafe extern fn vkGetDescriptorSetHostMappingVALVE(
device: VkDevice,
descriptorSet: VkDescriptorSet,
ppData: *mut *mut void,
);
unsafe extern fn vkCreateMicromapEXT(
device: VkDevice,
pCreateInfo: *const VkMicromapCreateInfoEXT,
pAllocator: *const VkAllocationCallbacks,
pMicromap: *mut VkMicromapEXT,
) -> VkResult;
unsafe extern fn vkCmdBuildMicromapsEXT(
commandBuffer: VkCommandBuffer,
infoCount: uint32_t,
pInfos: *const [VkMicromapBuildInfoEXT; dyn infoCount],
);
unsafe extern fn vkBuildMicromapsEXT(
device: VkDevice,
deferredOperation: VkDeferredOperationKHR,
infoCount: uint32_t,
pInfos: *const [VkMicromapBuildInfoEXT; dyn infoCount],
) -> VkResult;
unsafe extern fn vkDestroyMicromapEXT(
device: VkDevice,
micromap: VkMicromapEXT,
pAllocator: *const VkAllocationCallbacks,
);
unsafe extern fn vkCmdCopyMicromapEXT(
commandBuffer: VkCommandBuffer,
pInfo: *const VkCopyMicromapInfoEXT,
);
unsafe extern fn vkCopyMicromapEXT(
device: VkDevice,
deferredOperation: VkDeferredOperationKHR,
pInfo: *const VkCopyMicromapInfoEXT,
) -> VkResult;
unsafe extern fn vkCmdCopyMicromapToMemoryEXT(
commandBuffer: VkCommandBuffer,
pInfo: *const VkCopyMicromapToMemoryInfoEXT,
);
unsafe extern fn vkCopyMicromapToMemoryEXT(
device: VkDevice,
deferredOperation: VkDeferredOperationKHR,
pInfo: *const VkCopyMicromapToMemoryInfoEXT,
) -> VkResult;
unsafe extern fn vkCmdCopyMemoryToMicromapEXT(
commandBuffer: VkCommandBuffer,
pInfo: *const VkCopyMemoryToMicromapInfoEXT,
);
unsafe extern fn vkCopyMemoryToMicromapEXT(
device: VkDevice,
deferredOperation: VkDeferredOperationKHR,
pInfo: *const VkCopyMemoryToMicromapInfoEXT,
) -> VkResult;
unsafe extern fn vkCmdWriteMicromapsPropertiesEXT(
commandBuffer: VkCommandBuffer,
micromapCount: uint32_t,
pMicromaps: *const [VkMicromapEXT; dyn micromapCount],
queryType: VkQueryType,
queryPool: VkQueryPool,
firstQuery: uint32_t,
);
unsafe extern fn vkWriteMicromapsPropertiesEXT(
device: VkDevice,
micromapCount: uint32_t,
pMicromaps: *const [VkMicromapEXT; dyn micromapCount],
queryType: VkQueryType,
dataSize: size_t,
pData: *mut [void; dyn dataSize],
stride: size_t,
) -> VkResult;
unsafe extern fn vkGetDeviceMicromapCompatibilityEXT(
device: VkDevice,
pVersionInfo: *const VkMicromapVersionInfoEXT,
pCompatibility: *mut VkAccelerationStructureCompatibilityKHR,
);
unsafe extern fn vkGetMicromapBuildSizesEXT(
device: VkDevice,
buildType: VkAccelerationStructureBuildTypeKHR,
pBuildInfo: *const VkMicromapBuildInfoEXT,
pSizeInfo: *mut VkMicromapBuildSizesInfoEXT,
);
unsafe extern fn vkGetShaderModuleIdentifierEXT(
device: VkDevice,
shaderModule: VkShaderModule,
pIdentifier: *mut VkShaderModuleIdentifierEXT,
);
unsafe extern fn vkGetShaderModuleCreateInfoIdentifierEXT(
device: VkDevice,
pCreateInfo: *const VkShaderModuleCreateInfo,
pIdentifier: *mut VkShaderModuleIdentifierEXT,
);
unsafe extern fn vkGetImageSubresourceLayout2KHR(
device: VkDevice,
image: VkImage,
pSubresource: *const VkImageSubresource2KHR,
pLayout: *mut VkSubresourceLayout2KHR,
);
unsafe extern fn vkGetPipelinePropertiesEXT(
device: VkDevice,
pPipelineInfo: *const VkPipelineInfoEXT,
pPipelineProperties: *mut VkBaseOutStructure,
) -> VkResult;
unsafe extern fn vkExportMetalObjectsEXT(
device: VkDevice,
pMetalObjectsInfo: *mut VkExportMetalObjectsInfoEXT,
);
unsafe extern fn vkGetFramebufferTilePropertiesQCOM(
device: VkDevice,
framebuffer: VkFramebuffer,
pPropertiesCount: *mut uint32_t,
pProperties: *mut [VkTilePropertiesQCOM; dyn pPropertiesCount],
) -> VkResult;
unsafe extern fn vkGetDynamicRenderingTilePropertiesQCOM(
device: VkDevice,
pRenderingInfo: *const VkRenderingInfo,
pProperties: *mut VkTilePropertiesQCOM,
) -> VkResult;
unsafe extern fn vkGetPhysicalDeviceOpticalFlowImageFormatsNV(
physicalDevice: VkPhysicalDevice,
pOpticalFlowImageFormatInfo: *const VkOpticalFlowImageFormatInfoNV,
pFormatCount: *mut uint32_t,
pImageFormatProperties: *mut [VkOpticalFlowImageFormatPropertiesNV; dyn pFormatCount],
) -> VkResult;
unsafe extern fn vkCreateOpticalFlowSessionNV(
device: VkDevice,
pCreateInfo: *const VkOpticalFlowSessionCreateInfoNV,
pAllocator: *const VkAllocationCallbacks,
pSession: *mut VkOpticalFlowSessionNV,
) -> VkResult;
unsafe extern fn vkDestroyOpticalFlowSessionNV(
device: VkDevice,
session: VkOpticalFlowSessionNV,
pAllocator: *const VkAllocationCallbacks,
);
unsafe extern fn vkBindOpticalFlowSessionImageNV(
device: VkDevice,
session: VkOpticalFlowSessionNV,
bindingPoint: VkOpticalFlowSessionBindingPointNV,
view: VkImageView,
layout: VkImageLayout,
) -> VkResult;
unsafe extern fn vkCmdOpticalFlowExecuteNV(
commandBuffer: VkCommandBuffer,
session: VkOpticalFlowSessionNV,
pExecuteInfo: *const VkOpticalFlowExecuteInfoNV,
);
unsafe extern fn vkGetDeviceFaultInfoEXT(
device: VkDevice,
pFaultCounts: *mut VkDeviceFaultCountsEXT,
pFaultInfo: *mut VkDeviceFaultInfoEXT,
) -> VkResult;
unsafe extern fn vkCmdSetDepthBias2EXT(
commandBuffer: VkCommandBuffer,
pDepthBiasInfo: *const VkDepthBiasInfoEXT,
);
unsafe extern fn vkReleaseSwapchainImagesEXT(
device: VkDevice,
pReleaseInfo: *const VkReleaseSwapchainImagesInfoEXT,
) -> VkResult;
unsafe extern fn vkGetDeviceImageSubresourceLayoutKHR(
device: VkDevice,
pInfo: *const VkDeviceImageSubresourceInfoKHR,
pLayout: *mut VkSubresourceLayout2KHR,
);
unsafe extern fn vkMapMemory2KHR(
device: VkDevice,
pMemoryMapInfo: *const VkMemoryMapInfoKHR,
ppData: *mut *mut void,
) -> VkResult;
unsafe extern fn vkUnmapMemory2KHR(
device: VkDevice,
pMemoryUnmapInfo: *const VkMemoryUnmapInfoKHR,
) -> VkResult;
unsafe extern fn vkCreateShadersEXT(
device: VkDevice,
createInfoCount: uint32_t,
pCreateInfos: *const [VkShaderCreateInfoEXT; dyn createInfoCount],
pAllocator: *const VkAllocationCallbacks,
pShaders: *mut [VkShaderEXT; dyn createInfoCount],
) -> VkResult;
unsafe extern fn vkDestroyShaderEXT(
device: VkDevice,
shader: VkShaderEXT,
pAllocator: *const VkAllocationCallbacks,
);
unsafe extern fn vkGetShaderBinaryDataEXT(
device: VkDevice,
shader: VkShaderEXT,
pDataSize: *mut size_t,
pData: *mut [void; dyn pDataSize],
) -> VkResult;
unsafe extern fn vkCmdBindShadersEXT(
commandBuffer: VkCommandBuffer,
stageCount: uint32_t,
pStages: *const [VkShaderStageFlagBits; dyn stageCount],
pShaders: *const [VkShaderEXT; dyn stageCount],
);
unsafe extern fn vkGetScreenBufferPropertiesQNX(
device: VkDevice,
buffer: *const /*struct*/_screen_buffer,
pProperties: *mut VkScreenBufferPropertiesQNX,
) -> VkResult;
unsafe extern fn vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(
physicalDevice: VkPhysicalDevice,
pPropertyCount: *mut uint32_t,
pProperties: *mut [VkCooperativeMatrixPropertiesKHR; dyn pPropertyCount],
) -> VkResult;
unsafe extern fn vkGetExecutionGraphPipelineScratchSizeAMDX(
device: VkDevice,
executionGraph: VkPipeline,
pSizeInfo: *mut VkExecutionGraphPipelineScratchSizeAMDX,
) -> VkResult;
unsafe extern fn vkGetExecutionGraphPipelineNodeIndexAMDX(
device: VkDevice,
executionGraph: VkPipeline,
pNodeInfo: *const VkPipelineShaderStageNodeCreateInfoAMDX,
pNodeIndex: *mut uint32_t,
) -> VkResult;
unsafe extern fn vkCreateExecutionGraphPipelinesAMDX(
device: VkDevice,
pipelineCache: VkPipelineCache,
createInfoCount: uint32_t,
pCreateInfos: *const [VkExecutionGraphPipelineCreateInfoAMDX; dyn createInfoCount],
pAllocator: *const VkAllocationCallbacks,
pPipelines: *mut [VkPipeline; dyn createInfoCount],
) -> VkResult;
unsafe extern fn vkCmdInitializeGraphScratchMemoryAMDX(
commandBuffer: VkCommandBuffer,
scratch: VkDeviceAddress,
);
unsafe extern fn vkCmdDispatchGraphAMDX(
commandBuffer: VkCommandBuffer,
scratch: VkDeviceAddress,
pCountInfo: *const VkDispatchGraphCountInfoAMDX,
);
unsafe extern fn vkCmdDispatchGraphIndirectAMDX(
commandBuffer: VkCommandBuffer,
scratch: VkDeviceAddress,
pCountInfo: *const VkDispatchGraphCountInfoAMDX,
);
unsafe extern fn vkCmdDispatchGraphIndirectCountAMDX(
commandBuffer: VkCommandBuffer,
scratch: VkDeviceAddress,
countInfo: VkDeviceAddress,
);
unsafe extern fn vkSetLatencySleepModeNV(
device: VkDevice,
swapchain: VkSwapchainKHR,
pSleepModeInfo: *const VkLatencySleepModeInfoNV,
) -> VkResult;
unsafe extern fn vkLatencySleepNV(
device: VkDevice,
swapchain: VkSwapchainKHR,
pSleepInfo: *const VkLatencySleepInfoNV,
) -> VkResult;
unsafe extern fn vkSetLatencyMarkerNV(
device: VkDevice,
swapchain: VkSwapchainKHR,
pLatencyMarkerInfo: *const VkSetLatencyMarkerInfoNV,
);
unsafe extern fn vkGetLatencyTimingsNV(
device: VkDevice,
swapchain: VkSwapchainKHR,
pLatencyMarkerInfo: *mut VkGetLatencyMarkerInfoNV,
);
unsafe extern fn vkQueueNotifyOutOfBandNV(
queue: VkQueue,
pQueueTypeInfo: *const VkOutOfBandQueueTypeInfoNV,
);
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment