vulkan: Update from version 0.194.0 to 0.196.0
Change-Id: Ib62cc358b1f2575daeaa2a893eb4afca458ec5c3
(cherry picked from commit 48e9a8af39134fc2e995867668e113e56931167b)
diff --git a/vulkan/api/templates/vulkan_common.tmpl b/vulkan/api/templates/vulkan_common.tmpl
index 12d5788..ce37a13 100644
--- a/vulkan/api/templates/vulkan_common.tmpl
+++ b/vulkan/api/templates/vulkan_common.tmpl
@@ -211,7 +211,7 @@
{{define "Vtbl#VkPhysicalDevice"}}Instance{{end}}
{{define "Vtbl#VkDevice" }}Device{{end}}
{{define "Vtbl#VkQueue" }}Device{{end}}
-{{define "Vtbl#VkCmdBuffer" }}Device{{end}}
+{{define "Vtbl#VkCommandBuffer" }}Device{{end}}
{{define "Vtbl_Default" }}Global{{end}}
{{define "Vtbl"}}
{{AssertType $ "Function"}}
diff --git a/vulkan/api/vulkan.api b/vulkan/api/vulkan.api
index 418318a..7313904 100644
--- a/vulkan/api/vulkan.api
+++ b/vulkan/api/vulkan.api
@@ -27,7 +27,7 @@
// API version (major.minor.patch)
define VERSION_MAJOR 0
-define VERSION_MINOR 194
+define VERSION_MINOR 196
define VERSION_PATCH 0
// API limits
@@ -100,11 +100,11 @@
@dispatchHandle type u64 VkPhysicalDevice
@dispatchHandle type u64 VkDevice
@dispatchHandle type u64 VkQueue
-@dispatchHandle type u64 VkCmdBuffer
+@dispatchHandle type u64 VkCommandBuffer
/// Non dispatchable handle types.
@nonDispatchHandle type u64 VkDeviceMemory
-@nonDispatchHandle type u64 VkCmdPool
+@nonDispatchHandle type u64 VkCommandPool
@nonDispatchHandle type u64 VkBuffer
@nonDispatchHandle type u64 VkBufferView
@nonDispatchHandle type u64 VkImage
@@ -144,12 +144,12 @@
VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 0x00000003, /// Optimal layout when image is only used for depth/stencil attachment read/write
VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 0x00000004, /// Optimal layout when image is used for read only depth/stencil attachment and shader access
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 0x00000005, /// Optimal layout when image is used for read only shader access
- VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL = 0x00000006, /// Optimal layout when image is used only as source of transfer operations
- VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL = 0x00000007, /// Optimal layout when image is used only as destination of transfer operations
+ VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 0x00000006, /// Optimal layout when image is used only as source of transfer operations
+ VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 0x00000007, /// Optimal layout when image is used only as destination of transfer operations
VK_IMAGE_LAYOUT_PREINITIALIZED = 0x00000008, /// Initial layout used when the data is populated by the CPU
//@extension("VK_EXT_KHR_swapchain")
- VK_IMAGE_LAYOUT_PRESENT_SOURCE_KHR = 0xc0000802,
+ VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 0xc0000802,
}
enum VkAttachmentLoadOp {
@@ -184,9 +184,9 @@
VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 0x00000006,
}
-enum VkCmdBufferLevel {
- VK_CMD_BUFFER_LEVEL_PRIMARY = 0x00000000,
- VK_CMD_BUFFER_LEVEL_SECONDARY = 0x00000001,
+enum VkCommandBufferLevel {
+ VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0x00000000,
+ VK_COMMAND_BUFFER_LEVEL_SECONDARY = 0x00000001,
}
enum VkChannelSwizzle {
@@ -240,10 +240,10 @@
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 0x00000003,
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 0x00000004,
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 0x00000005,
- VK_PRIMITIVE_TOPOLOGY_LINE_LIST_ADJ = 0x00000006,
- VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_ADJ = 0x00000007,
- VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_ADJ = 0x00000008,
- VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_ADJ = 0x00000009,
+ VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 0x00000006,
+ VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 0x00000007,
+ VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 0x00000008,
+ VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 0x00000009,
VK_PRIMITIVE_TOPOLOGY_PATCH = 0x0000000a,
}
@@ -280,10 +280,10 @@
VK_COMPARE_OP_NEVER = 0x00000000,
VK_COMPARE_OP_LESS = 0x00000001,
VK_COMPARE_OP_EQUAL = 0x00000002,
- VK_COMPARE_OP_LESS_EQUAL = 0x00000003,
+ VK_COMPARE_OP_LESS_OR_EQUAL = 0x00000003,
VK_COMPARE_OP_GREATER = 0x00000004,
VK_COMPARE_OP_NOT_EQUAL = 0x00000005,
- VK_COMPARE_OP_GREATER_EQUAL = 0x00000006,
+ VK_COMPARE_OP_GREATER_OR_EQUAL = 0x00000006,
VK_COMPARE_OP_ALWAYS = 0x00000007,
}
@@ -294,8 +294,8 @@
}
enum VkFrontFace {
- VK_FRONT_FACE_CCW = 0x00000000,
- VK_FRONT_FACE_CW = 0x00000001,
+ VK_FRONT_FACE_COUNTER_CLOCKWISE = 0x00000000,
+ VK_FRONT_FACE_CLOCKWISE = 0x00000001,
}
enum VkBlend {
@@ -303,12 +303,12 @@
VK_BLEND_ONE = 0x00000001,
VK_BLEND_SRC_COLOR = 0x00000002,
VK_BLEND_ONE_MINUS_SRC_COLOR = 0x00000003,
- VK_BLEND_DEST_COLOR = 0x00000004,
- VK_BLEND_ONE_MINUS_DEST_COLOR = 0x00000005,
+ VK_BLEND_DST_COLOR = 0x00000004,
+ VK_BLEND_ONE_MINUS_DST_COLOR = 0x00000005,
VK_BLEND_SRC_ALPHA = 0x00000006,
VK_BLEND_ONE_MINUS_SRC_ALPHA = 0x00000007,
- VK_BLEND_DEST_ALPHA = 0x00000008,
- VK_BLEND_ONE_MINUS_DEST_ALPHA = 0x00000009,
+ VK_BLEND_DST_ALPHA = 0x00000008,
+ VK_BLEND_ONE_MINUS_DST_ALPHA = 0x00000009,
VK_BLEND_CONSTANT_COLOR = 0x0000000a,
VK_BLEND_ONE_MINUS_CONSTANT_COLOR = 0x0000000b,
VK_BLEND_CONSTANT_ALPHA = 0x0000000c,
@@ -332,11 +332,11 @@
VK_STENCIL_OP_KEEP = 0x00000000,
VK_STENCIL_OP_ZERO = 0x00000001,
VK_STENCIL_OP_REPLACE = 0x00000002,
- VK_STENCIL_OP_INC_CLAMP = 0x00000003,
- VK_STENCIL_OP_DEC_CLAMP = 0x00000004,
+ VK_STENCIL_OP_INCREMENT_AND_CLAMP = 0x00000003,
+ VK_STENCIL_OP_DECREMENT_AND_CLAMP = 0x00000004,
VK_STENCIL_OP_INVERT = 0x00000005,
- VK_STENCIL_OP_INC_WRAP = 0x00000006,
- VK_STENCIL_OP_DEC_WRAP = 0x00000007,
+ VK_STENCIL_OP_INCREMENT_AND_WRAP = 0x00000006,
+ VK_STENCIL_OP_DECREMENT_AND_WRAP = 0x00000007,
}
enum VkLogicOp {
@@ -345,11 +345,11 @@
VK_LOGIC_OP_AND_REVERSE = 0x00000002,
VK_LOGIC_OP_COPY = 0x00000003,
VK_LOGIC_OP_AND_INVERTED = 0x00000004,
- VK_LOGIC_OP_NOOP = 0x00000005,
+ VK_LOGIC_OP_NO_OP = 0x00000005,
VK_LOGIC_OP_XOR = 0x00000006,
VK_LOGIC_OP_OR = 0x00000007,
VK_LOGIC_OP_NOR = 0x00000008,
- VK_LOGIC_OP_EQUIV = 0x00000009,
+ VK_LOGIC_OP_EQUIVALENT = 0x00000009,
VK_LOGIC_OP_INVERT = 0x0000000a,
VK_LOGIC_OP_OR_REVERSE = 0x0000000b,
VK_LOGIC_OP_COPY_INVERTED = 0x0000000c,
@@ -358,16 +358,16 @@
VK_LOGIC_OP_SET = 0x0000000f,
}
-enum VkSystemAllocScope {
- VK_SYSTEM_ALLOC_SCOPE_FUNCTION = 0x00000000,
- VK_SYSTEM_ALLOC_SCOPE_OBJECT = 0x00000001,
- VK_SYSTEM_ALLOC_SCOPE_CACHE = 0x00000002,
- VK_SYSTEM_ALLOC_SCOPE_DEVICE = 0x00000003,
- VK_SYSTEM_ALLOC_SCOPE_INSTANCE = 0x00000004,
+enum VkSystemAllocationScope {
+ VK_SYSTEM_ALLOCATION_SCOPE_FUNCTION = 0x00000000,
+ VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 0x00000001,
+ VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 0x00000002,
+ VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 0x00000003,
+ VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 0x00000004,
}
-enum VkInternalAllocType {
- VK_INTERNAL_ALLOC_TYPE_EXECUTABLE = 0x00000000,
+enum VkInternalAllocationType {
+ VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0x00000000,
}
enum VkPhysicalDeviceType {
@@ -603,9 +603,9 @@
VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 37,
VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 38,
VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 39,
- VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO = 40,
- VK_STRUCTURE_TYPE_CMD_BUFFER_ALLOC_INFO = 41,
- VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO = 42,
+ VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 40,
+ VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOC_INFO = 41,
+ VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42,
VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43,
VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44,
VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45,
@@ -627,7 +627,7 @@
enum VkRenderPassContents {
VK_RENDER_PASS_CONTENTS_INLINE = 0x00000000,
- VK_RENDER_PASS_CONTENTS_SECONDARY_CMD_BUFFERS = 0x00000001,
+ VK_RENDER_PASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 0x00000001,
}
@lastUnused(-8)
@@ -765,8 +765,8 @@
/// Buffer usage flags
type VkFlags VkBufferUsageFlags
bitfield VkBufferUsageFlagBits {
- VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT = 0x00000001, /// Can be used as a source of transfer operations
- VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT = 0x00000002, /// Can be used as a destination of transfer operations
+ VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001, /// Can be used as a source of transfer operations
+ VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002, /// Can be used as a destination of transfer operations
VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004, /// Can be used as TBO
VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008, /// Can be used as IBO
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010, /// Can be used as UBO
@@ -812,8 +812,8 @@
/// Image usage flags
type VkFlags VkImageUsageFlags
bitfield VkImageUsageFlagBits {
- VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT = 0x00000001, /// Can be used as a source of transfer operations
- VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT = 0x00000002, /// Can be used as a destination of transfer operations
+ VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001, /// Can be used as a source of transfer operations
+ VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0x00000002, /// Can be used as a destination of transfer operations
VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004, /// Can be sampled from (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types)
VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008, /// Can be used as storage image (STORAGE_IMAGE descriptor type)
VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010, /// Can be used as framebuffer color attachment
@@ -878,8 +878,8 @@
VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080, /// Format can be used for color attachment images
VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100, /// Format supports blending in case it's used for color attachment images
VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200, /// Format can be used for depth/stencil attachment images
- VK_FORMAT_FEATURE_BLIT_SOURCE_BIT = 0x00000400, /// Format can be used as the source image of blits with vkCmdBlitImage
- VK_FORMAT_FEATURE_BLIT_DESTINATION_BIT = 0x00000800, /// Format can be used as the destination image of blits with vkCmdBlitImage
+ VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0x00000400, /// Format can be used as the source image of blits with vkCommandBlitImage
+ VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800, /// Format can be used as the destination image of blits with vkCommandBlitImage
}
/// Query control flags
@@ -914,11 +914,11 @@
//}
/// Command buffer usage flags
-type VkFlags VkCmdBufferUsageFlags
-bitfield VkCmdBufferUsageFlagBits {
- VK_CMD_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001,
- VK_CMD_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002,
- VK_CMD_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004,
+type VkFlags VkCommandBufferUsageFlags
+bitfield VkCommandBufferUsageFlagBits {
+ VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001,
+ VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002,
+ VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004,
}
/// Pipeline statistics flags
@@ -999,21 +999,21 @@
}
/// Command pool creation flags
-type VkFlags VkCmdPoolCreateFlags
-bitfield VkCmdPoolCreateFlagBits {
- VK_CMD_POOL_CREATE_TRANSIENT_BIT = 0x00000001, /// Command buffers have a short lifetime
- VK_CMD_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002, /// Command buffers may release their memory individually
+type VkFlags VkCommandPoolCreateFlags
+bitfield VkCommandPoolCreateFlagBits {
+ VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001, /// Command buffers have a short lifetime
+ VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002, /// Command buffers may release their memory individually
}
/// Command pool reset flags
-type VkFlags VkCmdPoolResetFlags
-bitfield VkCmdPoolResetFlagBits {
- VK_CMD_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001, /// Release resources owned by the pool
+type VkFlags VkCommandPoolResetFlags
+bitfield VkCommandPoolResetFlagBits {
+ VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001, /// Release resources owned by the pool
}
-type VkFlags VkCmdBufferResetFlags
-bitfield VkCmdBufferResetFlagBits {
- VK_CMD_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001, /// Release resources owned by the buffer
+type VkFlags VkCommandBufferResetFlags
+bitfield VkCommandBufferResetFlagBits {
+ VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001, /// Release resources owned by the buffer
}
type VkFlags VkSampleCountFlags
@@ -1095,9 +1095,9 @@
//bitfield VkPipelineViewportStateCreateFlagBits {
//}
-/// Raster state creation flags
-type VkFlags VkPipelineRasterStateCreateFlags
-//bitfield VkPipelineRasterStateCreateFlagBits {
+/// Rasterization state creation flags
+type VkFlags VkPipelineRasterizationStateCreateFlags
+//bitfield VkPipelineRasterizationStateCreateFlagBits {
//}
/// Multisample state creation flags
@@ -1233,7 +1233,7 @@
class VkClearRect {
VkRect2D rect
u32 baseArrayLayer
- u32 numLayers
+ u32 layerCount
}
class VkChannelMapping {
@@ -1256,15 +1256,15 @@
}
class VkExtensionProperties {
- char[VK_MAX_EXTENSION_NAME] extName /// extension name
+ char[VK_MAX_EXTENSION_NAME] extensionName /// extension name
u32 specVersion /// version of the extension specification implemented
}
class VkLayerProperties {
- char[VK_MAX_EXTENSION_NAME] layerName /// layer name
- u32 specVersion /// version of the layer specification implemented
- u32 implVersion /// build or release version of the layer's library
- char[VK_MAX_DESCRIPTION] description /// Free-form description of the layer
+ char[VK_MAX_EXTENSION_NAME] layerName /// layer name
+ u32 specVersion /// version of the layer specification implemented
+ u32 implementationVersion /// build or release version of the layer's library
+ char[VK_MAX_DESCRIPTION] description /// Free-form description of the layer
}
class VkSubmitInfo {
@@ -1273,7 +1273,7 @@
u32 waitSemaphoreCount
const VkSemaphore* pWaitSemaphores
u32 commandBufferCount
- const VkCmdBuffer* pCommandBuffers
+ const VkCommandBuffer* pCommandBuffers
u32 signalSemaphoreCount
const VkSemaphore* pSignalSemaphores
}
@@ -1281,19 +1281,19 @@
class VkApplicationInfo {
VkStructureType sType /// Type of structure. Should be VK_STRUCTURE_TYPE_APPLICATION_INFO
const void* pNext /// Next structure in chain
- const char* pAppName
- u32 appVersion
+ const char* pApplicationName
+ u32 applicationVersion
const char* pEngineName
u32 engineVersion
u32 apiVersion
}
-class VkAllocCallbacks {
+class VkAllocationCallbacks {
void* pUserData
- PFN_vkAllocFunction pfnAlloc
- PFN_vkReallocFunction pfnRealloc
+ PFN_vkAllocationFunction pfnAllocation
+ PFN_vkReallocationFunction pfnReallocation
PFN_vkFreeFunction pfnFree
- PFN_vkInternalAllocNotification pfnInternalAlloc
+ PFN_vkInternalAllocationNotification pfnInternalAllocation
PFN_vkInternalFreeNotification pfnInternalFree
}
@@ -1323,7 +1323,7 @@
VkStructureType sType /// Should be VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO
const void* pNext /// Pointer to next structure
VkInstanceCreateFlags flags
- const VkApplicationInfo* pAppInfo
+ const VkApplicationInfo* pApplicationInfo
u32 enabledLayerNameCount
const char* const* ppEnabledLayerNames /// Ordered list of layer names to be enabled
u32 enabledExtensionNameCount
@@ -1343,7 +1343,7 @@
VkMemoryHeap[VK_MAX_MEMORY_HEAPS] memoryHeaps
}
-class VkMemoryAllocInfo {
+class VkMemoryAllocateInfo {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO
const void* pNext /// Pointer to next structure
VkDeviceSize allocationSize /// Size of memory allocation
@@ -1383,7 +1383,7 @@
class VkMappedMemoryRange {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE
const void* pNext /// Pointer to next structure
- VkDeviceMemory mem /// Mapped memory object
+ VkDeviceMemory memory /// Mapped memory object
VkDeviceSize offset /// Offset within the mapped memory the range starts from
VkDeviceSize size /// Size of the range within the mapped memory
}
@@ -1417,9 +1417,9 @@
class VkWriteDescriptorSet {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET
const void* pNext /// Pointer to next structure
- VkDescriptorSet destSet /// Destination descriptor set
- u32 destBinding /// Binding within the destination descriptor set to write
- u32 destArrayElement /// Array element within the destination binding to write
+ VkDescriptorSet dstSet /// Destination descriptor set
+ u32 dstBinding /// Binding within the destination descriptor set to write
+ u32 dstArrayElement /// Array element within the destination binding to write
u32 descriptorCount /// Number of descriptors to write (determines the size of the array pointed by <pDescriptors>)
VkDescriptorType descriptorType /// Descriptor type to write (determines which fields of the array pointed by <pDescriptors> are going to be used)
const VkDescriptorImageInfo* pImageInfo
@@ -1433,9 +1433,9 @@
VkDescriptorSet srcSet /// Source descriptor set
u32 srcBinding /// Binding within the source descriptor set to copy from
u32 srcArrayElement /// Array element within the source binding to copy from
- VkDescriptorSet destSet /// Destination descriptor set
- u32 destBinding /// Binding within the destination descriptor set to copy to
- u32 destArrayElement /// Array element within the destination binding to copy to
+ VkDescriptorSet dstSet /// Destination descriptor set
+ u32 dstBinding /// Binding within the destination descriptor set to copy to
+ u32 dstArrayElement /// Array element within the destination binding to copy to
u32 descriptorCount /// Number of descriptors to copy
}
@@ -1469,9 +1469,9 @@
class VkImageSubresourceRange {
VkImageAspectFlags aspectMask
u32 baseMipLevel
- u32 numLevels
+ u32 levelCount
u32 baseArrayLayer
- u32 numLayers
+ u32 layerCount
}
class VkMemoryBarrier {
@@ -1487,7 +1487,7 @@
VkMemoryOutputFlags outputMask /// Outputs the barrier should sync
VkMemoryInputFlags inputMask /// Inputs the barrier should sync to
u32 srcQueueFamilyIndex /// Queue family to transition ownership from
- u32 destQueueFamilyIndex /// Queue family to transition ownership to
+ u32 dstQueueFamilyIndex /// Queue family to transition ownership to
VkBuffer buffer /// Buffer to sync
VkDeviceSize offset /// Offset within the buffer to sync
VkDeviceSize size /// Amount of bytes to sync
@@ -1501,7 +1501,7 @@
VkImageLayout oldLayout /// Current layout of the image
VkImageLayout newLayout /// New layout to transition the image to
u32 srcQueueFamilyIndex /// Queue family to transition ownership from
- u32 destQueueFamilyIndex /// Queue family to transition ownership to
+ u32 dstQueueFamilyIndex /// Queue family to transition ownership to
VkImage image /// Image to sync
VkImageSubresourceRange subresourceRange /// Subresource range to sync
}
@@ -1544,15 +1544,15 @@
class VkBufferCopy {
VkDeviceSize srcOffset /// Specified in bytes
- VkDeviceSize destOffset /// Specified in bytes
+ VkDeviceSize dstOffset /// Specified in bytes
VkDeviceSize size /// Specified in bytes
}
class VkSparseMemoryBind {
VkDeviceSize resourceOffset /// Specified in bytes
VkDeviceSize size /// Specified in bytes
- VkDeviceMemory mem
- VkDeviceSize memOffset /// Specified in bytes
+ VkDeviceMemory memory
+ VkDeviceSize memoryOffset /// Specified in bytes
VkSparseMemoryBindFlags flags
}
@@ -1560,8 +1560,8 @@
VkImageSubresource subresource
VkOffset3D offset
VkExtent3D extent
- VkDeviceMemory mem
- VkDeviceSize memOffset /// Specified in bytes
+ VkDeviceMemory memory
+ VkDeviceSize memoryOffset /// Specified in bytes
VkSparseMemoryBindFlags flags
}
@@ -1602,14 +1602,14 @@
VkImageAspectFlags aspect
u32 mipLevel
u32 baseArrayLayer
- u32 numLayers
+ u32 layerCount
}
class VkImageCopy {
VkImageSubresourceCopy srcSubresource
VkOffset3D srcOffset /// Specified in pixels for both compressed and uncompressed images
- VkImageSubresourceCopy destSubresource
- VkOffset3D destOffset /// Specified in pixels for both compressed and uncompressed images
+ VkImageSubresourceCopy dstSubresource
+ VkOffset3D dstOffset /// Specified in pixels for both compressed and uncompressed images
VkExtent3D extent /// Specified in pixels for both compressed and uncompressed images
}
@@ -1617,9 +1617,9 @@
VkImageSubresourceCopy srcSubresource
VkOffset3D srcOffset /// Specified in pixels for both compressed and uncompressed images
VkExtent3D srcExtent /// Specified in pixels for both compressed and uncompressed images
- VkImageSubresourceCopy destSubresource
- VkOffset3D destOffset /// Specified in pixels for both compressed and uncompressed images
- VkExtent3D destExtent /// Specified in pixels for both compressed and uncompressed images
+ VkImageSubresourceCopy dstSubresource
+ VkOffset3D dstOffset /// Specified in pixels for both compressed and uncompressed images
+ VkExtent3D dstExtent /// Specified in pixels for both compressed and uncompressed images
}
class VkBufferImageCopy {
@@ -1634,8 +1634,8 @@
class VkImageResolve {
VkImageSubresourceCopy srcSubresource
VkOffset3D srcOffset
- VkImageSubresourceCopy destSubresource
- VkOffset3D destOffset
+ VkImageSubresourceCopy dstSubresource
+ VkOffset3D dstOffset
VkExtent3D extent
}
@@ -1685,7 +1685,7 @@
const VkDescriptorTypeCount* pTypeCounts
}
-class VkDescriptorSetAllocInfo {
+class VkDescriptorSetAllocateInfo {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOC_INFO
const void* pNext /// Pointer to next structure
VkDescriptorPool descriptorPool
@@ -1772,10 +1772,10 @@
const VkRect2D* pScissors
}
-class VkPipelineRasterStateCreateInfo {
+class VkPipelineRasterizationStateCreateInfo {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO
const void* pNext /// Pointer to next structure
- VkPipelineRasterStateCreateFlags flags
+ VkPipelineRasterizationStateCreateFlags flags
VkBool32 depthClampEnable
VkBool32 rasterizerDiscardEnable
VkFillMode fillMode /// optional (GL45)
@@ -1792,7 +1792,7 @@
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO
const void* pNext /// Pointer to next structure
VkPipelineMultisampleStateCreateFlags flags
- u32 rasterSamples /// Number of samples used for rasterization
+ u32 rasterizationSamples /// Number of samples used for rasterization
VkBool32 sampleShadingEnable /// optional (GL45)
f32 minSampleShading /// optional (GL45)
const VkSampleMask* pSampleMask
@@ -1803,10 +1803,10 @@
class VkPipelineColorBlendAttachmentState {
VkBool32 blendEnable
VkBlend srcBlendColor
- VkBlend destBlendColor
+ VkBlend dstBlendColor
VkBlendOp blendOpColor
VkBlend srcBlendAlpha
- VkBlend destBlendAlpha
+ VkBlend dstBlendAlpha
VkBlendOp blendOpAlpha
VkChannelFlags channelWriteMask
}
@@ -1865,7 +1865,7 @@
const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState
const VkPipelineTessellationStateCreateInfo* pTessellationState
const VkPipelineViewportStateCreateInfo* pViewportState
- const VkPipelineRasterStateCreateInfo* pRasterState
+ const VkPipelineRasterizationStateCreateInfo* pRasterizationState
const VkPipelineMultisampleStateCreateInfo* pMultisampleState
const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState
const VkPipelineColorBlendStateCreateInfo* pColorBlendState
@@ -1883,7 +1883,6 @@
VkPipelineCacheCreateFlags flags
platform.size_t initialDataSize /// Size of initial data to populate cache, in bytes
const void* pInitialData /// Initial data to populate cache
- platform.size_t maxSize /// Maximum size cache can grow to, in bytes. If zero, then the cache may grow without bound.
}
class VkPushConstantRange {
@@ -1922,25 +1921,25 @@
VkBool32 unnormalizedCoordinates
}
-class VkCmdPoolCreateInfo {
- VkStructureType sType /// Must be VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO
+class VkCommandPoolCreateInfo {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO
const void* pNext /// Pointer to next structure
- VkCmdPoolCreateFlags flags /// Command pool creation flags
+ VkCommandPoolCreateFlags flags /// Command pool creation flags
u32 queueFamilyIndex
}
-class VkCmdBufferAllocInfo {
- VkStructureType sType /// Must be VK_STRUCTURE_TYPE_CMD_BUFFER_ALLOC_INFO
+class VkCommandBufferAllocateInfo {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOC_INFO
const void* pNext /// Pointer to next structure
- VkCmdPool cmdPool
- VkCmdBufferLevel level
+ VkCommandPool commandPool
+ VkCommandBufferLevel level
u32 bufferCount
}
-class VkCmdBufferBeginInfo {
- VkStructureType sType /// Must be VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO
+class VkCommandBufferBeginInfo {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO
const void* pNext /// Pointer to next structure
- VkCmdBufferUsageFlags flags /// Command buffer usage flags
+ VkCommandBufferUsageFlags flags /// Command buffer usage flags
VkRenderPass renderPass /// Render pass for secondary command buffers
u32 subpass
VkFramebuffer framebuffer /// Framebuffer for secondary command buffers
@@ -2014,9 +2013,9 @@
class VkSubpassDependency {
u32 srcSubpass
- u32 destSubpass
+ u32 dstSubpass
VkPipelineStageFlags srcStageMask
- VkPipelineStageFlags destStageMask
+ VkPipelineStageFlags dstStageMask
VkMemoryOutputFlags outputMask
VkMemoryInputFlags inputMask
VkDependencyFlags dependencyFlags
@@ -2054,7 +2053,7 @@
VkBool32 geometryShader /// geometry stage
VkBool32 tessellationShader /// tessellation control and evaluation stage
VkBool32 sampleRateShading /// per-sample shading and interpolation
- VkBool32 dualSourceBlend /// blend operations which take two sources
+ VkBool32 dualSrcBlend /// blend operations which take two sources
VkBool32 logicOp /// logic operations
VkBool32 multiDrawIndirect /// multi draw indirect
VkBool32 depthClamp /// depth clamping
@@ -2136,7 +2135,7 @@
u32 maxVertexInputBindingStride /// max vertex input binding stride
u32 maxVertexOutputComponents /// max num of output components written by vertex shader
/// tessellation control stage limits
- u32 maxTessellationGenLevel /// max level supported by tess primitive generator
+ u32 maxTessellationGenerationLevel /// max level supported by tess primitive generator
u32 maxTessellationPatchSize /// max patch size (vertices)
u32 maxTessellationControlPerVertexInputComponents /// max num of input components per-vertex in TCS
u32 maxTessellationControlPerVertexOutputComponents /// max num of output components per-vertex in TCS
@@ -2153,7 +2152,7 @@
/// fragment stage limits
u32 maxFragmentInputComponents /// max num of input compontents read in fragment stage
u32 maxFragmentOutputAttachments /// max num of output attachments written in fragment stage
- u32 maxFragmentDualSourceAttachments /// max num of output attachments written when using dual source blending
+ u32 maxFragmentDualSrcAttachments /// max num of output attachments written when using dual source blending
u32 maxFragmentCombinedOutputResources /// max total num of storage buffers, storage images and output buffers
/// compute stage limits
u32 maxComputeSharedMemorySize /// max total storage size of work group local storage (bytes)
@@ -2258,14 +2257,14 @@
u32 layers
}
-class VkDrawIndirectCmd {
+class VkDrawIndirectCommand {
u32 vertexCount
u32 instanceCount
u32 firstVertex
u32 firstInstance
}
-class VkDrawIndexedIndirectCmd {
+class VkDrawIndexedIndirectCommand {
u32 indexCount
u32 instanceCount
u32 firstIndex
@@ -2273,7 +2272,7 @@
u32 firstInstance
}
-class VkDispatchIndirectCmd {
+class VkDispatchIndirectCommand {
u32 x
u32 y
u32 z
@@ -2420,45 +2419,45 @@
@pfn cmd void vkVoidFunction() {
}
-@external type void* PFN_vkAllocFunction
-@pfn cmd void* vkAllocFunction(
+@external type void* PFN_vkAllocationFunction
+@pfn cmd void* vkAllocationFunction(
void* pUserData,
platform.size_t size,
platform.size_t alignment,
- VkSystemAllocScope allocScope) {
+ VkSystemAllocationScope allocationScope) {
return ?
}
-@external type void* PFN_vkReallocFunction
-@pfn cmd void* vkReallocFunction(
+@external type void* PFN_vkReallocationFunction
+@pfn cmd void* vkReallocationFunction(
void* pUserData,
void* pOriginal,
platform.size_t size,
platform.size_t alignment,
- VkSystemAllocScope allocScope) {
+ VkSystemAllocationScope allocationScope) {
return ?
}
@external type void* PFN_vkFreeFunction
@pfn cmd void vkFreeFunction(
void* pUserData,
- void* pMem) {
+ void* pMemory) {
}
-@external type void* PFN_vkInternalAllocNotification
-@pfn cmd void vkInternalAllocNotification(
+@external type void* PFN_vkInternalAllocationNotification
+@pfn cmd void vkInternalAllocationNotification(
void* pUserData,
platform.size_t size,
- VkInternalAllocType allocType,
- VkSystemAllocScope allocScope) {
+ VkInternalAllocationType allocationType,
+ VkSystemAllocationScope allocationScope) {
}
@external type void* PFN_vkInternalFreeNotification
@pfn cmd void vkInternalFreeNotification(
void* pUserData,
platform.size_t size,
- VkInternalAllocType allocType,
- VkSystemAllocScope allocScope) {
+ VkInternalAllocationType allocationType,
+ VkSystemAllocationScope allocationScope) {
}
// Global functions
@@ -2466,7 +2465,7 @@
@threadSafety("system")
cmd VkResult vkCreateInstance(
const VkInstanceCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkInstance* pInstance) {
assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO)
@@ -2483,7 +2482,7 @@
@threadSafety("system")
cmd void vkDestroyInstance(
VkInstance instance,
- const VkAllocCallbacks* pAllocator) {
+ const VkAllocationCallbacks* pAllocator) {
instanceObject := GetInstance(instance)
State.Instances[instance] = null
@@ -2610,7 +2609,7 @@
cmd VkResult vkCreateDevice(
VkPhysicalDevice physicalDevice,
const VkDeviceCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkDevice* pDevice) {
assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO)
physicalDeviceObject := GetPhysicalDevice(physicalDevice)
@@ -2625,7 +2624,7 @@
@threadSafety("system")
cmd void vkDestroyDevice(
VkDevice device,
- const VkAllocCallbacks* pAllocator) {
+ const VkAllocationCallbacks* pAllocator) {
deviceObject := GetDevice(device)
State.Devices[device] = null
@@ -2733,14 +2732,14 @@
assert(fenceObject.device == queueObject.device)
}
- // cmdBuffers := pCmdBuffers[0:cmdBufferCount]
- // for i in (0 .. cmdBufferCount) {
- // cmdBuffer := cmdBuffers[i]
- // cmdBufferObject := GetCmdBuffer(cmdBuffer)
- // assert(cmdBufferObject.device == queueObject.device)
+ // commandBuffers := pcommandBuffers[0:commandBufferCount]
+ // for i in (0 .. commandBufferCount) {
+ // commandBuffer := commandBuffers[i]
+ // commandBufferObject := GetCommandBuffer(commandBuffer)
+ // assert(commandBufferObject.device == queueObject.device)
//
- // validate("QueueCheck", cmdBufferObject.queueFlags in queueObject.flags,
- // "vkQueueSubmit: enqueued cmdBuffer requires missing queue capabilities.")
+ // validate("QueueCheck", commandBufferObject.queueFlags in queueObject.flags,
+ // "vkQueueSubmit: enqueued commandBuffer requires missing queue capabilities.")
// }
return ?
@@ -2766,19 +2765,19 @@
// Memory functions
@threadSafety("system")
-cmd VkResult vkAllocMemory(
+cmd VkResult vkAllocateMemory(
VkDevice device,
- const VkMemoryAllocInfo* pAllocInfo,
- const VkAllocCallbacks* pAllocator,
- VkDeviceMemory* pMem) {
- assert(pAllocInfo.sType == VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO)
+ const VkMemoryAllocateInfo* pAllocateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDeviceMemory* pMemory) {
+ assert(pAllocateInfo.sType == VK_STRUCTURE_TYPE_MEMORY_ALLOC_INFO)
deviceObject := GetDevice(device)
- mem := ?
- pMem[0] = mem
- State.DeviceMemories[mem] = new!DeviceMemoryObject(
+ memory := ?
+ pMemory[0] = memory
+ State.DeviceMemories[memory] = new!DeviceMemoryObject(
device: device,
- allocationSize: pAllocInfo[0].allocationSize)
+ allocationSize: pAllocateInfo[0].allocationSize)
return ?
}
@@ -2786,34 +2785,34 @@
@threadSafety("system")
cmd void vkFreeMemory(
VkDevice device,
- VkDeviceMemory mem,
- const VkAllocCallbacks* pAllocator) {
+ VkDeviceMemory memory,
+ const VkAllocationCallbacks* pAllocator) {
deviceObject := GetDevice(device)
- memObject := GetDeviceMemory(mem)
- assert(memObject.device == device)
+ memoryObject := GetDeviceMemory(memory)
+ assert(memoryObject.device == device)
// Check that no objects are still bound before freeing.
- validate("MemoryCheck", len(memObject.boundObjects) == 0,
+ validate("MemoryCheck", len(memoryObject.boundObjects) == 0,
"vkFreeMemory: objects still bound")
- validate("MemoryCheck", len(memObject.boundCommandBuffers) == 0,
- "vkFreeMemory: cmdBuffers still bound")
- State.DeviceMemories[mem] = null
+ validate("MemoryCheck", len(memoryObject.boundCommandBuffers) == 0,
+ "vkFreeMemory: commandBuffers still bound")
+ State.DeviceMemories[memory] = null
}
@threadSafety("app")
cmd VkResult vkMapMemory(
VkDevice device,
- VkDeviceMemory mem,
+ VkDeviceMemory memory,
VkDeviceSize offset,
VkDeviceSize size,
VkMemoryMapFlags flags,
void** ppData) {
deviceObject := GetDevice(device)
- memObject := GetDeviceMemory(mem)
- assert(memObject.device == device)
+ memoryObject := GetDeviceMemory(memory)
+ assert(memoryObject.device == device)
assert(flags == as!VkMemoryMapFlags(0))
- assert((offset + size) <= memObject.allocationSize)
+ assert((offset + size) <= memoryObject.allocationSize)
return ?
}
@@ -2821,24 +2820,24 @@
@threadSafety("app")
cmd void vkUnmapMemory(
VkDevice device,
- VkDeviceMemory mem) {
+ VkDeviceMemory memory) {
deviceObject := GetDevice(device)
- memObject := GetDeviceMemory(mem)
- assert(memObject.device == device)
+ memoryObject := GetDeviceMemory(memory)
+ assert(memoryObject.device == device)
}
cmd VkResult vkFlushMappedMemoryRanges(
VkDevice device,
- u32 memRangeCount
- const VkMappedMemoryRange* pMemRanges) {
+ u32 memoryRangeCount
+ const VkMappedMemoryRange* pMemoryRanges) {
deviceObject := GetDevice(device)
- memRanges := pMemRanges[0:memRangeCount]
- for i in (0 .. memRangeCount) {
- memRange := memRanges[i]
- memObject := GetDeviceMemory(memRange.mem)
- assert(memObject.device == device)
- assert((memRange.offset + memRange.size) <= memObject.allocationSize)
+ memoryRanges := pMemoryRanges[0:memoryRangeCount]
+ for i in (0 .. memoryRangeCount) {
+ memoryRange := memoryRanges[i]
+ memoryObject := GetDeviceMemory(memoryRange.memory)
+ assert(memoryObject.device == device)
+ assert((memoryRange.offset + memoryRange.size) <= memoryObject.allocationSize)
}
return ?
@@ -2846,16 +2845,16 @@
cmd VkResult vkInvalidateMappedMemoryRanges(
VkDevice device,
- u32 memRangeCount,
- const VkMappedMemoryRange* pMemRanges) {
+ u32 memoryRangeCount,
+ const VkMappedMemoryRange* pMemoryRanges) {
deviceObject := GetDevice(device)
- memRanges := pMemRanges[0:memRangeCount]
- for i in (0 .. memRangeCount) {
- memRange := memRanges[i]
- memObject := GetDeviceMemory(memRange.mem)
- assert(memObject.device == device)
- assert((memRange.offset + memRange.size) <= memObject.allocationSize)
+ memoryRanges := pMemoryRanges[0:memoryRangeCount]
+ for i in (0 .. memoryRangeCount) {
+ memoryRange := memoryRanges[i]
+ memoryObject := GetDeviceMemory(memoryRange.memory)
+ assert(memoryObject.device == device)
+ assert((memoryRange.offset + memoryRange.size) <= memoryObject.allocationSize)
}
return ?
@@ -2891,26 +2890,26 @@
cmd VkResult vkBindBufferMemory(
VkDevice device,
VkBuffer buffer,
- VkDeviceMemory mem,
- VkDeviceSize memOffset) {
+ VkDeviceMemory memory,
+ VkDeviceSize memoryOffset) {
deviceObject := GetDevice(device)
bufferObject := GetBuffer(buffer)
assert(bufferObject.device == device)
// Unbind buffer from previous memory object, if not VK_NULL_HANDLE.
- if bufferObject.mem != NULL_HANDLE {
- memObject := GetDeviceMemory(bufferObject.mem)
- memObject.boundObjects[as!u64(buffer)] = null
+ if bufferObject.memory != NULL_HANDLE {
+ memoryObject := GetDeviceMemory(bufferObject.memory)
+ memoryObject.boundObjects[as!u64(buffer)] = null
}
// Bind buffer to given memory object, if not VK_NULL_HANDLE.
- if mem != NULL_HANDLE {
- memObject := GetDeviceMemory(mem)
- assert(memObject.device == device)
- memObject.boundObjects[as!u64(buffer)] = memOffset
+ if memory != NULL_HANDLE {
+ memoryObject := GetDeviceMemory(memory)
+ assert(memoryObject.device == device)
+ memoryObject.boundObjects[as!u64(buffer)] = memoryOffset
}
- bufferObject.mem = mem
- bufferObject.memOffset = memOffset
+ bufferObject.memory = memory
+ bufferObject.memoryOffset = memoryOffset
return ?
}
@@ -2927,26 +2926,26 @@
cmd VkResult vkBindImageMemory(
VkDevice device,
VkImage image,
- VkDeviceMemory mem,
- VkDeviceSize memOffset) {
+ VkDeviceMemory memory,
+ VkDeviceSize memoryOffset) {
deviceObject := GetDevice(device)
imageObject := GetImage(image)
assert(imageObject.device == device)
// Unbind image from previous memory object, if not VK_NULL_HANDLE.
- if imageObject.mem != NULL_HANDLE {
- memObject := GetDeviceMemory(imageObject.mem)
- memObject.boundObjects[as!u64(image)] = null
+ if imageObject.memory != NULL_HANDLE {
+ memoryObject := GetDeviceMemory(imageObject.memory)
+ memoryObject.boundObjects[as!u64(image)] = null
}
// Bind image to given memory object, if not VK_NULL_HANDLE.
- if mem != NULL_HANDLE {
- memObject := GetDeviceMemory(mem)
- assert(memObject.device == device)
- memObject.boundObjects[as!u64(image)] = memOffset
+ if memory != NULL_HANDLE {
+ memoryObject := GetDeviceMemory(memory)
+ assert(memoryObject.device == device)
+ memoryObject.boundObjects[as!u64(image)] = memoryOffset
}
- imageObject.mem = mem
- imageObject.memOffset = memOffset
+ imageObject.memory = memory
+ imageObject.memoryOffset = memoryOffset
return ?
}
@@ -2990,7 +2989,7 @@
cmd VkResult vkCreateFence(
VkDevice device,
const VkFenceCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkFence* pFence) {
assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_FENCE_CREATE_INFO)
deviceObject := GetDevice(device)
@@ -3007,7 +3006,7 @@
cmd void vkDestroyFence(
VkDevice device,
VkFence fence,
- const VkAllocCallbacks* pAllocator) {
+ const VkAllocationCallbacks* pAllocator) {
deviceObject := GetDevice(device)
fenceObject := GetFence(fence)
assert(fenceObject.device == device)
@@ -3070,7 +3069,7 @@
cmd VkResult vkCreateSemaphore(
VkDevice device,
const VkSemaphoreCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkSemaphore* pSemaphore) {
assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO)
deviceObject := GetDevice(device)
@@ -3086,7 +3085,7 @@
cmd void vkDestroySemaphore(
VkDevice device,
VkSemaphore semaphore,
- const VkAllocCallbacks* pAllocator) {
+ const VkAllocationCallbacks* pAllocator) {
deviceObject := GetDevice(device)
semaphoreObject := GetSemaphore(semaphore)
assert(semaphoreObject.device == device)
@@ -3101,7 +3100,7 @@
cmd VkResult vkCreateEvent(
VkDevice device,
const VkEventCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkEvent* pEvent) {
assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_EVENT_CREATE_INFO)
deviceObject := GetDevice(device)
@@ -3117,7 +3116,7 @@
cmd void vkDestroyEvent(
VkDevice device,
VkEvent event,
- const VkAllocCallbacks* pAllocator) {
+ const VkAllocationCallbacks* pAllocator) {
deviceObject := GetDevice(device)
eventObject := GetEvent(event)
assert(eventObject.device == device)
@@ -3165,7 +3164,7 @@
cmd VkResult vkCreateQueryPool(
VkDevice device,
const VkQueryPoolCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkQueryPool* pQueryPool) {
assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO)
deviceObject := GetDevice(device)
@@ -3181,7 +3180,7 @@
cmd void vkDestroyQueryPool(
VkDevice device,
VkQueryPool queryPool,
- const VkAllocCallbacks* pAllocator) {
+ const VkAllocationCallbacks* pAllocator) {
deviceObject := GetDevice(device)
queryPoolObject := GetQueryPool(queryPool)
assert(queryPoolObject.device == device)
@@ -3214,7 +3213,7 @@
cmd VkResult vkCreateBuffer(
VkDevice device,
const VkBufferCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkBuffer* pBuffer) {
assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO)
deviceObject := GetDevice(device)
@@ -3230,12 +3229,12 @@
cmd void vkDestroyBuffer(
VkDevice device,
VkBuffer buffer,
- const VkAllocCallbacks* pAllocator) {
+ const VkAllocationCallbacks* pAllocator) {
deviceObject := GetDevice(device)
bufferObject := GetBuffer(buffer)
assert(bufferObject.device == device)
- assert(bufferObject.mem == 0)
+ assert(bufferObject.memory == 0)
State.Buffers[buffer] = null
}
@@ -3246,7 +3245,7 @@
cmd VkResult vkCreateBufferView(
VkDevice device,
const VkBufferViewCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkBufferView* pView) {
assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO)
deviceObject := GetDevice(device)
@@ -3265,7 +3264,7 @@
cmd void vkDestroyBufferView(
VkDevice device,
VkBufferView bufferView,
- const VkAllocCallbacks* pAllocator) {
+ const VkAllocationCallbacks* pAllocator) {
deviceObject := GetDevice(device)
bufferViewObject := GetBufferView(bufferView)
assert(bufferViewObject.device == device)
@@ -3280,7 +3279,7 @@
cmd VkResult vkCreateImage(
VkDevice device,
const VkImageCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkImage* pImage) {
assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO)
deviceObject := GetDevice(device)
@@ -3296,12 +3295,12 @@
cmd void vkDestroyImage(
VkDevice device,
VkImage image,
- const VkAllocCallbacks* pAllocator) {
+ const VkAllocationCallbacks* pAllocator) {
deviceObject := GetDevice(device)
imageObject := GetImage(image)
assert(imageObject.device == device)
- assert(imageObject.mem == 0)
+ assert(imageObject.memory == 0)
State.Images[image] = null
}
@@ -3322,7 +3321,7 @@
cmd VkResult vkCreateImageView(
VkDevice device,
const VkImageViewCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkImageView* pView) {
assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO)
deviceObject := GetDevice(device)
@@ -3341,7 +3340,7 @@
cmd void vkDestroyImageView(
VkDevice device,
VkImageView imageView,
- const VkAllocCallbacks* pAllocator) {
+ const VkAllocationCallbacks* pAllocator) {
deviceObject := GetDevice(device)
imageViewObject := GetImageView(imageView)
assert(imageViewObject.device == device)
@@ -3355,7 +3354,7 @@
cmd VkResult vkCreateShaderModule(
VkDevice device,
const VkShaderModuleCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkShaderModule* pShaderModule) {
assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO)
deviceObject := GetDevice(device)
@@ -3370,7 +3369,7 @@
cmd void vkDestroyShaderModule(
VkDevice device,
VkShaderModule shaderModule,
- const VkAllocCallbacks* pAllocator) {
+ const VkAllocationCallbacks* pAllocator) {
deviceObject := GetDevice(device)
shaderModuleObject := GetShaderModule(shaderModule)
assert(shaderModuleObject.device == device)
@@ -3382,7 +3381,7 @@
cmd VkResult vkCreateShader(
VkDevice device,
const VkShaderCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkShader* pShader) {
assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_SHADER_CREATE_INFO)
deviceObject := GetDevice(device)
@@ -3398,7 +3397,7 @@
cmd void vkDestroyShader(
VkDevice device,
VkShader shader,
- const VkAllocCallbacks* pAllocator) {
+ const VkAllocationCallbacks* pAllocator) {
deviceObject := GetDevice(device)
shaderObject := GetShader(shader)
assert(shaderObject.device == device)
@@ -3412,7 +3411,7 @@
cmd VkResult vkCreatePipelineCache(
VkDevice device,
const VkPipelineCacheCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkPipelineCache* pPipelineCache) {
assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO)
deviceObject := GetDevice(device)
@@ -3427,7 +3426,7 @@
cmd void vkDestroyPipelineCache(
VkDevice device,
VkPipelineCache pipelineCache,
- const VkAllocCallbacks* pAllocator) {
+ const VkAllocationCallbacks* pAllocator) {
deviceObject := GetDevice(device)
pipelineCacheObject := GetPipelineCache(pipelineCache)
assert(pipelineCacheObject.device == device)
@@ -3449,12 +3448,12 @@
cmd VkResult vkMergePipelineCaches(
VkDevice device,
- VkPipelineCache destCache,
+ VkPipelineCache dstCache,
u32 srcCacheCount,
const VkPipelineCache* pSrcCaches) {
deviceObject := GetDevice(device)
- destCacheObject := GetPipelineCache(destCache)
- assert(destCacheObject.device == device)
+ dstCacheObject := GetPipelineCache(dstCache)
+ assert(dstCacheObject.device == device)
srcCaches := pSrcCaches[0:srcCacheCount]
for i in (0 .. srcCacheCount) {
@@ -3471,7 +3470,7 @@
VkPipelineCache pipelineCache,
u32 createInfoCount,
const VkGraphicsPipelineCreateInfo* pCreateInfos,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkPipeline* pPipelines) {
deviceObject := GetDevice(device)
if pipelineCache != NULL_HANDLE {
@@ -3495,7 +3494,7 @@
VkPipelineCache pipelineCache,
u32 createInfoCount,
const VkComputePipelineCreateInfo* pCreateInfos,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkPipeline* pPipelines) {
deviceObject := GetDevice(device)
if pipelineCache != NULL_HANDLE {
@@ -3518,7 +3517,7 @@
cmd void vkDestroyPipeline(
VkDevice device,
VkPipeline pipeline,
- const VkAllocCallbacks* pAllocator) {
+ const VkAllocationCallbacks* pAllocator) {
deviceObject := GetDevice(device)
pipelineObjects := GetPipeline(pipeline)
assert(pipelineObjects.device == device)
@@ -3533,7 +3532,7 @@
cmd VkResult vkCreatePipelineLayout(
VkDevice device,
const VkPipelineLayoutCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkPipelineLayout* pPipelineLayout) {
assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO)
deviceObject := GetDevice(device)
@@ -3549,7 +3548,7 @@
cmd void vkDestroyPipelineLayout(
VkDevice device,
VkPipelineLayout pipelineLayout,
- const VkAllocCallbacks* pAllocator) {
+ const VkAllocationCallbacks* pAllocator) {
deviceObject := GetDevice(device)
pipelineLayoutObjects := GetPipelineLayout(pipelineLayout)
assert(pipelineLayoutObjects.device == device)
@@ -3564,7 +3563,7 @@
cmd VkResult vkCreateSampler(
VkDevice device,
const VkSamplerCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkSampler* pSampler) {
assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO)
deviceObject := GetDevice(device)
@@ -3580,7 +3579,7 @@
cmd void vkDestroySampler(
VkDevice device,
VkSampler sampler,
- const VkAllocCallbacks* pAllocator) {
+ const VkAllocationCallbacks* pAllocator) {
deviceObject := GetDevice(device)
samplerObject := GetSampler(sampler)
assert(samplerObject.device == device)
@@ -3595,7 +3594,7 @@
cmd VkResult vkCreateDescriptorSetLayout(
VkDevice device,
const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkDescriptorSetLayout* pSetLayout) {
assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO)
deviceObject := GetDevice(device)
@@ -3611,7 +3610,7 @@
cmd void vkDestroyDescriptorSetLayout(
VkDevice device,
VkDescriptorSetLayout descriptorSetLayout,
- const VkAllocCallbacks* pAllocator) {
+ const VkAllocationCallbacks* pAllocator) {
deviceObject := GetDevice(device)
descriptorSetLayoutObject := GetDescriptorSetLayout(descriptorSetLayout)
assert(descriptorSetLayoutObject.device == device)
@@ -3623,7 +3622,7 @@
cmd VkResult vkCreateDescriptorPool(
VkDevice device,
const VkDescriptorPoolCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkDescriptorPool* pDescriptorPool) {
assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO)
deviceObject := GetDevice(device)
@@ -3639,7 +3638,7 @@
cmd void vkDestroyDescriptorPool(
VkDevice device,
VkDescriptorPool descriptorPool,
- const VkAllocCallbacks* pAllocator) {
+ const VkAllocationCallbacks* pAllocator) {
deviceObject := GetDevice(device)
descriptorPoolObject := GetDescriptorPool(descriptorPool)
assert(descriptorPoolObject.device == device)
@@ -3660,12 +3659,12 @@
}
@threadSafety("app")
-cmd VkResult vkAllocDescriptorSets(
+cmd VkResult vkAllocateDescriptorSets(
VkDevice device,
- const VkDescriptorSetAllocInfo* pAllocInfo,
+ const VkDescriptorSetAllocateInfo* pAllocateInfo,
VkDescriptorSet* pDescriptorSets) {
deviceObject := GetDevice(device)
- allocInfo := pAllocInfo[0]
+ allocInfo := pAllocateInfo[0]
descriptorPoolObject := GetDescriptorPool(allocInfo.descriptorPool)
setLayouts := allocInfo.pSetLayouts[0:allocInfo.setCount]
@@ -3715,14 +3714,14 @@
descriptorWrites := pDescriptorWrites[0:descriptorWriteCount]
for i in (0 .. descriptorWriteCount) {
descriptorWrite := descriptorWrites[i]
- descriptorWriteObject := GetDescriptorSet(descriptorWrite.destSet)
+ descriptorWriteObject := GetDescriptorSet(descriptorWrite.dstSet)
assert(descriptorWriteObject.device == device)
}
descriptorCopies := pDescriptorCopies[0:descriptorCopyCount]
for i in (0 .. descriptorCopyCount) {
descriptorCopy := descriptorCopies[i]
- descriptorCopyObject := GetDescriptorSet(descriptorCopy.destSet)
+ descriptorCopyObject := GetDescriptorSet(descriptorCopy.dstSet)
assert(descriptorCopyObject.device == device)
}
}
@@ -3734,7 +3733,7 @@
cmd VkResult vkCreateFramebuffer(
VkDevice device,
const VkFramebufferCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkFramebuffer* pFramebuffer) {
assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO)
deviceObject := GetDevice(device)
@@ -3750,7 +3749,7 @@
cmd void vkDestroyFramebuffer(
VkDevice device,
VkFramebuffer framebuffer,
- const VkAllocCallbacks* pAllocator) {
+ const VkAllocationCallbacks* pAllocator) {
deviceObject := GetDevice(device)
framebufferObject := GetFramebuffer(framebuffer)
assert(framebufferObject.device == device)
@@ -3765,7 +3764,7 @@
cmd VkResult vkCreateRenderPass(
VkDevice device,
const VkRenderPassCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkRenderPass* pRenderPass) {
assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO)
deviceObject := GetDevice(device)
@@ -3781,7 +3780,7 @@
cmd void vkDestroyRenderPass(
VkDevice device,
VkRenderPass renderPass,
- const VkAllocCallbacks* pAllocator) {
+ const VkAllocationCallbacks* pAllocator) {
deviceObject := GetDevice(device)
renderPassObject := GetRenderPass(renderPass)
assert(renderPassObject.device == device)
@@ -3804,72 +3803,72 @@
cmd VkResult vkCreateCommandPool(
VkDevice device,
- const VkCmdPoolCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
- VkCmdPool* pCmdPool) {
- assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO)
+ const VkCommandPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkCommandPool* pCommandPool) {
+ assert(pCreateInfo.sType == VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO)
deviceObject := GetDevice(device)
- cmdPool := ?
- pCmdPool[0] = cmdPool
- State.CmdPools[cmdPool] = new!CmdPoolObject(device: device)
+ commandPool := ?
+ pCommandPool[0] = commandPool
+ State.CommandPools[commandPool] = new!CommandPoolObject(device: device)
return ?
}
cmd void vkDestroyCommandPool(
VkDevice device,
- VkCmdPool cmdPool,
- const VkAllocCallbacks* pAllocator) {
+ VkCommandPool commandPool,
+ const VkAllocationCallbacks* pAllocator) {
deviceObject := GetDevice(device)
- cmdPoolObject := GetCmdPool(cmdPool)
- assert(cmdPoolObject.device == device)
+ commandPoolObject := GetCommandPool(commandPool)
+ assert(commandPoolObject.device == device)
- State.CmdPools[cmdPool] = null
+ State.CommandPools[commandPool] = null
}
cmd VkResult vkResetCommandPool(
VkDevice device,
- VkCmdPool cmdPool,
- VkCmdPoolResetFlags flags) {
+ VkCommandPool commandPool,
+ VkCommandPoolResetFlags flags) {
deviceObject := GetDevice(device)
- cmdPoolObject := GetCmdPool(cmdPool)
- assert(cmdPoolObject.device == device)
+ commandPoolObject := GetCommandPool(commandPool)
+ assert(commandPoolObject.device == device)
return ?
}
// Command buffer functions
-macro void bindCmdBuffer(VkCmdBuffer cmdBuffer, any obj, VkDeviceMemory mem) {
- memoryObject := GetDeviceMemory(mem)
- memoryObject.boundCommandBuffers[cmdBuffer] = cmdBuffer
+macro void bindCommandBuffer(VkCommandBuffer commandBuffer, any obj, VkDeviceMemory memory) {
+ memoryObject := GetDeviceMemory(memory)
+ memoryObject.boundCommandBuffers[commandBuffer] = commandBuffer
- cmdBufferObject := GetCmdBuffer(cmdBuffer)
- cmdBufferObject.boundObjects[as!u64(obj)] = mem
+ commandBufferObject := GetCommandBuffer(commandBuffer)
+ commandBufferObject.boundObjects[as!u64(obj)] = memory
}
-macro void unbindCmdBuffer(VkCmdBuffer cmdBuffer, any obj, VkDeviceMemory mem) {
- memoryObject := GetDeviceMemory(mem)
- memoryObject.boundCommandBuffers[cmdBuffer] = null
+macro void unbindCommandBuffer(VkCommandBuffer commandBuffer, any obj, VkDeviceMemory memory) {
+ memoryObject := GetDeviceMemory(memory)
+ memoryObject.boundCommandBuffers[commandBuffer] = null
- cmdBufferObject := GetCmdBuffer(cmdBuffer)
- cmdBufferObject.boundObjects[as!u64(obj)] = null
+ commandBufferObject := GetCommandBuffer(commandBuffer)
+ commandBufferObject.boundObjects[as!u64(obj)] = null
}
@threadSafety("system")
-cmd VkResult vkAllocCommandBuffers(
+cmd VkResult vkAllocateCommandBuffers(
VkDevice device,
- const VkCmdBufferAllocInfo* pAllocInfo,
- VkCmdBuffer* pCmdBuffers) {
- assert(pAllocInfo[0].sType == VK_STRUCTURE_TYPE_CMD_BUFFER_ALLOC_INFO)
+ const VkCommandBufferAllocateInfo* pAllocateInfo,
+ VkCommandBuffer* pCommandBuffers) {
+ assert(pAllocateInfo[0].sType == VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOC_INFO)
- count := pAllocInfo[0].bufferCount
- cmdBuffers := pCmdBuffers[0:count]
+ count := pAllocateInfo[0].bufferCount
+ commandBuffers := pCommandBuffers[0:count]
for i in (0 .. count) {
- cmdBuffer := ?
- cmdBuffers[i] = cmdBuffer
- State.CmdBuffers[cmdBuffer] = new!CmdBufferObject(device: device)
+ commandBuffer := ?
+ commandBuffers[i] = commandBuffer
+ State.CommandBuffers[commandBuffer] = new!CommandBufferObject(device: device)
}
return ?
@@ -3878,26 +3877,26 @@
@threadSafety("system")
cmd void vkFreeCommandBuffers(
VkDevice device,
- VkCmdPool cmdPool,
+ VkCommandPool commandPool,
u32 commandBufferCount,
- const VkCmdBuffer* pCommandBuffers) {
+ const VkCommandBuffer* pCommandBuffers) {
deviceObject := GetDevice(device)
- cmdBuffers := pCommandBuffers[0:commandBufferCount]
+ commandBuffers := pCommandBuffers[0:commandBufferCount]
for i in (0 .. commandBufferCount) {
- cmdBufferObject := GetCmdBuffer(cmdBuffers[i])
- assert(cmdBufferObject.device == device)
+ commandBufferObject := GetCommandBuffer(commandBuffers[i])
+ assert(commandBufferObject.device == device)
// TODO: iterate over boundObjects and clear memory bindings
- State.CmdBuffers[cmdBuffers[i]] = null
+ State.CommandBuffers[commandBuffers[i]] = null
}
}
@threadSafety("app")
cmd VkResult vkBeginCommandBuffer(
- VkCmdBuffer cmdBuffer,
- const VkCmdBufferBeginInfo* pBeginInfo) {
- assert(pBeginInfo.sType == VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO)
- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+ VkCommandBuffer commandBuffer,
+ const VkCommandBufferBeginInfo* pBeginInfo) {
+ assert(pBeginInfo.sType == VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO)
+ commandBufferObject := GetCommandBuffer(commandBuffer)
// TODO: iterate over boundObjects and clear memory bindings
@@ -3906,17 +3905,17 @@
@threadSafety("app")
cmd VkResult vkEndCommandBuffer(
- VkCmdBuffer cmdBuffer) {
- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+ VkCommandBuffer commandBuffer) {
+ commandBufferObject := GetCommandBuffer(commandBuffer)
return ?
}
@threadSafety("app")
cmd VkResult vkResetCommandBuffer(
- VkCmdBuffer cmdBuffer,
- VkCmdBufferResetFlags flags) {
- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+ VkCommandBuffer commandBuffer,
+ VkCommandBufferResetFlags flags) {
+ commandBufferObject := GetCommandBuffer(commandBuffer)
// TODO: iterate over boundObjects and clear memory bindings
@@ -3928,106 +3927,106 @@
@threadSafety("app")
cmd void vkCmdBindPipeline(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkPipelineBindPoint pipelineBindPoint,
VkPipeline pipeline) {
- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+ commandBufferObject := GetCommandBuffer(commandBuffer)
pipelineObject := GetPipeline(pipeline)
- assert(cmdBufferObject.device == pipelineObject.device)
+ assert(commandBufferObject.device == pipelineObject.device)
queue := switch (pipelineBindPoint) {
case VK_PIPELINE_BIND_POINT_COMPUTE: VK_QUEUE_COMPUTE_BIT
case VK_PIPELINE_BIND_POINT_GRAPHICS: VK_QUEUE_GRAPHICS_BIT
}
- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, queue)
+ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, queue)
}
@threadSafety("app")
cmd void vkCmdSetViewport(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
u32 viewportCount,
const VkViewport* pViewports) {
- cmdBufferObject := GetCmdBuffer(cmdBuffer)
- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ commandBufferObject := GetCommandBuffer(commandBuffer)
+ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}
@threadSafety("app")
cmd void vkCmdSetScissor(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
u32 scissorCount,
const VkRect2D* pScissors) {
- cmdBufferObject := GetCmdBuffer(cmdBuffer)
- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ commandBufferObject := GetCommandBuffer(commandBuffer)
+ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}
@threadSafety("app")
cmd void vkCmdSetLineWidth(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
f32 lineWidth) {
- cmdBufferObject := GetCmdBuffer(cmdBuffer)
- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ commandBufferObject := GetCommandBuffer(commandBuffer)
+ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}
@threadSafety("app")
cmd void vkCmdSetDepthBias(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
f32 depthBiasConstantFactor,
f32 depthBiasClamp,
f32 depthBiasSlopeFactor) {
- cmdBufferObject := GetCmdBuffer(cmdBuffer)
- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ commandBufferObject := GetCommandBuffer(commandBuffer)
+ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}
@threadSafety("app")
cmd void vkCmdSetBlendConstants(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
// TODO(jessehall): apic only supports 'const' on pointer types. Using
// an annotation as a quick hack to pass this to the template without
// having to modify the AST and semantic model.
@readonly f32[4] blendConstants) {
- cmdBufferObject := GetCmdBuffer(cmdBuffer)
- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ commandBufferObject := GetCommandBuffer(commandBuffer)
+ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}
@threadSafety("app")
cmd void vkCmdSetDepthBounds(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
f32 minDepthBounds,
f32 maxDepthBounds) {
- cmdBufferObject := GetCmdBuffer(cmdBuffer)
- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ commandBufferObject := GetCommandBuffer(commandBuffer)
+ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}
@threadSafety("app")
cmd void vkCmdSetStencilCompareMask(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkStencilFaceFlags faceMask,
u32 stencilCompareMask) {
- cmdBufferObject := GetCmdBuffer(cmdBuffer)
- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ commandBufferObject := GetCommandBuffer(commandBuffer)
+ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}
@threadSafety("app")
cmd void vkCmdSetStencilWriteMask(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkStencilFaceFlags faceMask,
u32 stencilWriteMask) {
- cmdBufferObject := GetCmdBuffer(cmdBuffer)
- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ commandBufferObject := GetCommandBuffer(commandBuffer)
+ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}
@threadSafety("app")
cmd void vkCmdSetStencilReference(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkStencilFaceFlags faceMask,
u32 stencilReference) {
- cmdBufferObject := GetCmdBuffer(cmdBuffer)
- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ commandBufferObject := GetCommandBuffer(commandBuffer)
+ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}
@threadSafety("app")
cmd void vkCmdBindDescriptorSets(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkPipelineBindPoint pipelineBindPoint,
VkPipelineLayout layout,
u32 firstSet,
@@ -4035,13 +4034,13 @@
const VkDescriptorSet* pDescriptorSets,
u32 dynamicOffsetCount,
const u32* pDynamicOffsets) {
- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+ commandBufferObject := GetCommandBuffer(commandBuffer)
descriptorSets := pDescriptorSets[0:descriptorSetCount]
for i in (0 .. descriptorSetCount) {
descriptorSet := descriptorSets[i]
descriptorSetObject := GetDescriptorSet(descriptorSet)
- assert(cmdBufferObject.device == descriptorSetObject.device)
+ assert(commandBufferObject.device == descriptorSetObject.device)
}
dynamicOffsets := pDynamicOffsets[0:dynamicOffsetCount]
@@ -4053,32 +4052,32 @@
case VK_PIPELINE_BIND_POINT_COMPUTE: VK_QUEUE_COMPUTE_BIT
case VK_PIPELINE_BIND_POINT_GRAPHICS: VK_QUEUE_GRAPHICS_BIT
}
- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, queue)
+ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, queue)
}
@threadSafety("app")
cmd void vkCmdBindIndexBuffer(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
VkIndexType indexType) {
- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+ commandBufferObject := GetCommandBuffer(commandBuffer)
bufferObject := GetBuffer(buffer)
- assert(cmdBufferObject.device == bufferObject.device)
+ assert(commandBufferObject.device == bufferObject.device)
- bindCmdBuffer(cmdBuffer, buffer, bufferObject.mem)
+ bindCommandBuffer(commandBuffer, buffer, bufferObject.memory)
- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}
@threadSafety("app")
cmd void vkCmdBindVertexBuffers(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
u32 startBinding,
u32 bindingCount,
const VkBuffer* pBuffers,
const VkDeviceSize* pOffsets) {
- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+ commandBufferObject := GetCommandBuffer(commandBuffer)
// TODO: check if not [startBinding:startBinding+bindingCount]
buffers := pBuffers[0:bindingCount]
@@ -4087,395 +4086,395 @@
buffer := buffers[i]
offset := offsets[i]
bufferObject := GetBuffer(buffer)
- assert(cmdBufferObject.device == bufferObject.device)
+ assert(commandBufferObject.device == bufferObject.device)
- bindCmdBuffer(cmdBuffer, buffer, bufferObject.mem)
+ bindCommandBuffer(commandBuffer, buffer, bufferObject.memory)
}
- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}
@threadSafety("app")
cmd void vkCmdDraw(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
u32 vertexCount,
u32 instanceCount,
u32 firstVertex,
u32 firstInstance) {
- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+ commandBufferObject := GetCommandBuffer(commandBuffer)
- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}
@threadSafety("app")
cmd void vkCmdDrawIndexed(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
u32 indexCount,
u32 instanceCount,
u32 firstIndex,
s32 vertexOffset,
u32 firstInstance) {
- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+ commandBufferObject := GetCommandBuffer(commandBuffer)
- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}
@threadSafety("app")
cmd void vkCmdDrawIndirect(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
u32 drawCount,
u32 stride) {
- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+ commandBufferObject := GetCommandBuffer(commandBuffer)
bufferObject := GetBuffer(buffer)
- assert(cmdBufferObject.device == bufferObject.device)
+ assert(commandBufferObject.device == bufferObject.device)
- bindCmdBuffer(cmdBuffer, buffer, bufferObject.mem)
+ bindCommandBuffer(commandBuffer, buffer, bufferObject.memory)
- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}
@threadSafety("app")
cmd void vkCmdDrawIndexedIndirect(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
u32 drawCount,
u32 stride) {
- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+ commandBufferObject := GetCommandBuffer(commandBuffer)
bufferObject := GetBuffer(buffer)
- assert(cmdBufferObject.device == bufferObject.device)
+ assert(commandBufferObject.device == bufferObject.device)
- bindCmdBuffer(cmdBuffer, buffer, bufferObject.mem)
+ bindCommandBuffer(commandBuffer, buffer, bufferObject.memory)
- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}
@threadSafety("app")
cmd void vkCmdDispatch(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
u32 x,
u32 y,
u32 z) {
- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+ commandBufferObject := GetCommandBuffer(commandBuffer)
- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_COMPUTE_BIT)
+ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_COMPUTE_BIT)
}
@threadSafety("app")
cmd void vkCmdDispatchIndirect(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset) {
- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+ commandBufferObject := GetCommandBuffer(commandBuffer)
bufferObject := GetBuffer(buffer)
- assert(cmdBufferObject.device == bufferObject.device)
+ assert(commandBufferObject.device == bufferObject.device)
- bindCmdBuffer(cmdBuffer, buffer, bufferObject.mem)
+ bindCommandBuffer(commandBuffer, buffer, bufferObject.memory)
- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_COMPUTE_BIT)
+ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_COMPUTE_BIT)
}
@threadSafety("app")
cmd void vkCmdCopyBuffer(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkBuffer srcBuffer,
- VkBuffer destBuffer,
+ VkBuffer dstBuffer,
u32 regionCount,
const VkBufferCopy* pRegions) {
- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+ commandBufferObject := GetCommandBuffer(commandBuffer)
srcBufferObject := GetBuffer(srcBuffer)
- destBufferObject := GetBuffer(destBuffer)
- assert(cmdBufferObject.device == srcBufferObject.device)
- assert(cmdBufferObject.device == destBufferObject.device)
+ dstBufferObject := GetBuffer(dstBuffer)
+ assert(commandBufferObject.device == srcBufferObject.device)
+ assert(commandBufferObject.device == dstBufferObject.device)
regions := pRegions[0:regionCount]
for i in (0 .. regionCount) {
region := regions[i]
}
- bindCmdBuffer(cmdBuffer, srcBuffer, srcBufferObject.mem)
- bindCmdBuffer(cmdBuffer, destBuffer, destBufferObject.mem)
+ bindCommandBuffer(commandBuffer, srcBuffer, srcBufferObject.memory)
+ bindCommandBuffer(commandBuffer, dstBuffer, dstBufferObject.memory)
- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_DMA_BIT)
+ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_DMA_BIT)
}
@threadSafety("app")
cmd void vkCmdCopyImage(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
- VkImage destImage,
- VkImageLayout destImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
u32 regionCount,
const VkImageCopy* pRegions) {
- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+ commandBufferObject := GetCommandBuffer(commandBuffer)
srcImageObject := GetImage(srcImage)
- destImageObject := GetImage(destImage)
- assert(cmdBufferObject.device == srcImageObject.device)
- assert(cmdBufferObject.device == destImageObject.device)
+ dstImageObject := GetImage(dstImage)
+ assert(commandBufferObject.device == srcImageObject.device)
+ assert(commandBufferObject.device == dstImageObject.device)
regions := pRegions[0:regionCount]
for i in (0 .. regionCount) {
region := regions[i]
}
- bindCmdBuffer(cmdBuffer, srcImage, srcImageObject.mem)
- bindCmdBuffer(cmdBuffer, destImage, destImageObject.mem)
+ bindCommandBuffer(commandBuffer, srcImage, srcImageObject.memory)
+ bindCommandBuffer(commandBuffer, dstImage, dstImageObject.memory)
- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_DMA_BIT)
+ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_DMA_BIT)
}
@threadSafety("app")
cmd void vkCmdBlitImage(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
- VkImage destImage,
- VkImageLayout destImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
u32 regionCount,
const VkImageBlit* pRegions,
VkFilter filter) {
- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+ commandBufferObject := GetCommandBuffer(commandBuffer)
srcImageObject := GetImage(srcImage)
- destImageObject := GetImage(destImage)
- assert(cmdBufferObject.device == srcImageObject.device)
- assert(cmdBufferObject.device == destImageObject.device)
+ dstImageObject := GetImage(dstImage)
+ assert(commandBufferObject.device == srcImageObject.device)
+ assert(commandBufferObject.device == dstImageObject.device)
regions := pRegions[0:regionCount]
for i in (0 .. regionCount) {
region := regions[i]
}
- bindCmdBuffer(cmdBuffer, srcImage, srcImageObject.mem)
- bindCmdBuffer(cmdBuffer, destImage, destImageObject.mem)
+ bindCommandBuffer(commandBuffer, srcImage, srcImageObject.memory)
+ bindCommandBuffer(commandBuffer, dstImage, dstImageObject.memory)
- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}
@threadSafety("app")
cmd void vkCmdCopyBufferToImage(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkBuffer srcBuffer,
- VkImage destImage,
- VkImageLayout destImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
u32 regionCount,
const VkBufferImageCopy* pRegions) {
- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+ commandBufferObject := GetCommandBuffer(commandBuffer)
srcBufferObject := GetBuffer(srcBuffer)
- destImageObject := GetImage(destImage)
- assert(cmdBufferObject.device == srcBufferObject.device)
- assert(cmdBufferObject.device == destImageObject.device)
+ dstImageObject := GetImage(dstImage)
+ assert(commandBufferObject.device == srcBufferObject.device)
+ assert(commandBufferObject.device == dstImageObject.device)
regions := pRegions[0:regionCount]
for i in (0 .. regionCount) {
region := regions[i]
}
- bindCmdBuffer(cmdBuffer, srcBuffer, srcBufferObject.mem)
- bindCmdBuffer(cmdBuffer, destImage, destImageObject.mem)
+ bindCommandBuffer(commandBuffer, srcBuffer, srcBufferObject.memory)
+ bindCommandBuffer(commandBuffer, dstImage, dstImageObject.memory)
- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_DMA_BIT)
+ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_DMA_BIT)
}
@threadSafety("app")
cmd void vkCmdCopyImageToBuffer(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
- VkBuffer destBuffer,
+ VkBuffer dstBuffer,
u32 regionCount,
const VkBufferImageCopy* pRegions) {
- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+ commandBufferObject := GetCommandBuffer(commandBuffer)
srcImageObject := GetImage(srcImage)
- destBufferObject := GetBuffer(destBuffer)
- assert(cmdBufferObject.device == srcImageObject.device)
- assert(cmdBufferObject.device == destBufferObject.device)
+ dstBufferObject := GetBuffer(dstBuffer)
+ assert(commandBufferObject.device == srcImageObject.device)
+ assert(commandBufferObject.device == dstBufferObject.device)
regions := pRegions[0:regionCount]
for i in (0 .. regionCount) {
region := regions[i]
}
- bindCmdBuffer(cmdBuffer, srcImage, srcImageObject.mem)
- bindCmdBuffer(cmdBuffer, destBuffer, destBufferObject.mem)
+ bindCommandBuffer(commandBuffer, srcImage, srcImageObject.memory)
+ bindCommandBuffer(commandBuffer, dstBuffer, dstBufferObject.memory)
- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_DMA_BIT)
+ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_DMA_BIT)
}
@threadSafety("app")
cmd void vkCmdUpdateBuffer(
- VkCmdBuffer cmdBuffer,
- VkBuffer destBuffer,
- VkDeviceSize destOffset,
+ VkCommandBuffer commandBuffer,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
VkDeviceSize dataSize,
const u32* pData) {
- cmdBufferObject := GetCmdBuffer(cmdBuffer)
- destBufferObject := GetBuffer(destBuffer)
- assert(cmdBufferObject.device == destBufferObject.device)
+ commandBufferObject := GetCommandBuffer(commandBuffer)
+ dstBufferObject := GetBuffer(dstBuffer)
+ assert(commandBufferObject.device == dstBufferObject.device)
data := pData[0:dataSize]
- bindCmdBuffer(cmdBuffer, destBuffer, destBufferObject.mem)
+ bindCommandBuffer(commandBuffer, dstBuffer, dstBufferObject.memory)
- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_DMA_BIT)
+ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_DMA_BIT)
}
@threadSafety("app")
cmd void vkCmdFillBuffer(
- VkCmdBuffer cmdBuffer,
- VkBuffer destBuffer,
- VkDeviceSize destOffset,
+ VkCommandBuffer commandBuffer,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
VkDeviceSize size,
u32 data) {
- cmdBufferObject := GetCmdBuffer(cmdBuffer)
- destBufferObject := GetBuffer(destBuffer)
- assert(cmdBufferObject.device == destBufferObject.device)
+ commandBufferObject := GetCommandBuffer(commandBuffer)
+ dstBufferObject := GetBuffer(dstBuffer)
+ assert(commandBufferObject.device == dstBufferObject.device)
- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_DMA_BIT)
+ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_DMA_BIT)
}
@threadSafety("app")
cmd void vkCmdClearColorImage(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkImage image,
VkImageLayout imageLayout,
const VkClearColorValue* pColor,
u32 rangeCount,
const VkImageSubresourceRange* pRanges) {
- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+ commandBufferObject := GetCommandBuffer(commandBuffer)
imageObject := GetImage(image)
- assert(cmdBufferObject.device == imageObject.device)
+ assert(commandBufferObject.device == imageObject.device)
ranges := pRanges[0:rangeCount]
for i in (0 .. rangeCount) {
range := ranges[i]
}
- bindCmdBuffer(cmdBuffer, image, imageObject.mem)
+ bindCommandBuffer(commandBuffer, image, imageObject.memory)
- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}
@threadSafety("app")
cmd void vkCmdClearDepthStencilImage(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkImage image,
VkImageLayout imageLayout,
const VkClearDepthStencilValue* pDepthStencil,
u32 rangeCount,
const VkImageSubresourceRange* pRanges) {
- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+ commandBufferObject := GetCommandBuffer(commandBuffer)
imageObject := GetImage(image)
- assert(cmdBufferObject.device == imageObject.device)
+ assert(commandBufferObject.device == imageObject.device)
ranges := pRanges[0:rangeCount]
for i in (0 .. rangeCount) {
range := ranges[i]
}
- bindCmdBuffer(cmdBuffer, image, imageObject.mem)
+ bindCommandBuffer(commandBuffer, image, imageObject.memory)
- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}
@threadSafety("app")
cmd void vkCmdClearAttachments(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
u32 attachmentCount,
const VkClearAttachment* pAttachments,
u32 rectCount,
const VkClearRect* pRects) {
- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+ commandBufferObject := GetCommandBuffer(commandBuffer)
rects := pRects[0:rectCount]
for i in (0 .. rectCount) {
rect := rects[i]
}
- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}
@threadSafety("app")
cmd void vkCmdResolveImage(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
- VkImage destImage,
- VkImageLayout destImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
u32 regionCount,
const VkImageResolve* pRegions) {
- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+ commandBufferObject := GetCommandBuffer(commandBuffer)
srcImageObject := GetImage(srcImage)
- destImageObject := GetImage(destImage)
- assert(cmdBufferObject.device == srcImageObject.device)
- assert(cmdBufferObject.device == destImageObject.device)
+ dstImageObject := GetImage(dstImage)
+ assert(commandBufferObject.device == srcImageObject.device)
+ assert(commandBufferObject.device == dstImageObject.device)
regions := pRegions[0:regionCount]
for i in (0 .. regionCount) {
region := regions[i]
}
- bindCmdBuffer(cmdBuffer, srcImage, srcImageObject.mem)
- bindCmdBuffer(cmdBuffer, destImage, destImageObject.mem)
+ bindCommandBuffer(commandBuffer, srcImage, srcImageObject.memory)
+ bindCommandBuffer(commandBuffer, dstImage, dstImageObject.memory)
- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}
@threadSafety("app")
cmd void vkCmdSetEvent(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkEvent event,
VkPipelineStageFlags stageMask) {
- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+ commandBufferObject := GetCommandBuffer(commandBuffer)
eventObject := GetEvent(event)
- assert(cmdBufferObject.device == eventObject.device)
+ assert(commandBufferObject.device == eventObject.device)
}
@threadSafety("app")
cmd void vkCmdResetEvent(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkEvent event,
VkPipelineStageFlags stageMask) {
- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+ commandBufferObject := GetCommandBuffer(commandBuffer)
eventObject := GetEvent(event)
- assert(cmdBufferObject.device == eventObject.device)
+ assert(commandBufferObject.device == eventObject.device)
}
@threadSafety("app")
cmd void vkCmdWaitEvents(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
u32 eventCount,
const VkEvent* pEvents,
VkPipelineStageFlags srcStageMask,
- VkPipelineStageFlags destStageMask,
- u32 memBarrierCount,
- const void* const* ppMemBarriers) {
- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+ VkPipelineStageFlags dstStageMask,
+ u32 memoryBarrierCount,
+ const void* const* ppMemoryBarriers) {
+ commandBufferObject := GetCommandBuffer(commandBuffer)
events := pEvents[0:eventCount]
for i in (0 .. eventCount) {
event := events[i]
eventObject := GetEvent(event)
- assert(cmdBufferObject.device == eventObject.device)
+ assert(commandBufferObject.device == eventObject.device)
}
- pMemBarriers := ppMemBarriers[0:memBarrierCount]
- for i in (0 .. memBarrierCount) {
- switch as!VkMemoryBarrier const*(pMemBarriers[i])[0].sType {
+ pMemoryBarriers := ppMemoryBarriers[0:memoryBarrierCount]
+ for i in (0 .. memoryBarrierCount) {
+ switch as!VkMemoryBarrier const*(pMemoryBarriers[i])[0].sType {
case VK_STRUCTURE_TYPE_MEMORY_BARRIER: {
- memBarrier := as!VkMemoryBarrier const*(pMemBarriers[i])[0]
+ memoryBarrier := as!VkMemoryBarrier const*(pMemoryBarriers[i])[0]
}
case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER: {
- imageMemBarrier := as!VkImageMemoryBarrier const*(pMemBarriers[i])[0]
- imageObject := GetImage(imageMemBarrier.image)
- assert(imageObject.device == cmdBufferObject.device)
+ imageMemoryBarrier := as!VkImageMemoryBarrier const*(pMemoryBarriers[i])[0]
+ imageObject := GetImage(imageMemoryBarrier.image)
+ assert(imageObject.device == commandBufferObject.device)
}
case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER: {
- bufferMemBarrier := as!VkBufferMemoryBarrier const*(pMemBarriers[i])[0]
- bufferObject := GetBuffer(bufferMemBarrier.buffer)
- assert(bufferObject.device == cmdBufferObject.device)
+ bufferMemoryBarrier := as!VkBufferMemoryBarrier const*(pMemoryBarriers[i])[0]
+ bufferObject := GetBuffer(bufferMemoryBarrier.buffer)
+ assert(bufferObject.device == commandBufferObject.device)
}
}
}
@@ -4483,29 +4482,29 @@
@threadSafety("app")
cmd void vkCmdPipelineBarrier(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkPipelineStageFlags srcStageMask,
- VkPipelineStageFlags destStageMask,
+ VkPipelineStageFlags dstStageMask,
VkDependencyFlags dependencyFlags,
- u32 memBarrierCount,
- const void* const* ppMemBarriers) {
- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+ u32 memoryBarrierCount,
+ const void* const* ppMemoryBarriers) {
+ commandBufferObject := GetCommandBuffer(commandBuffer)
- pMemBarriers := ppMemBarriers[0:memBarrierCount]
- for i in (0 .. memBarrierCount) {
- switch as!VkMemoryBarrier const*(pMemBarriers[i])[0].sType {
+ pMemoryBarriers := ppMemoryBarriers[0:memoryBarrierCount]
+ for i in (0 .. memoryBarrierCount) {
+ switch as!VkMemoryBarrier const*(pMemoryBarriers[i])[0].sType {
case VK_STRUCTURE_TYPE_MEMORY_BARRIER: {
- memBarrier := as!VkMemoryBarrier const*(pMemBarriers[i])[0]
+ memoryBarrier := as!VkMemoryBarrier const*(pMemoryBarriers[i])[0]
}
case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER: {
- imageMemBarrier := as!VkImageMemoryBarrier const*(pMemBarriers[i])[0]
- imageObject := GetImage(imageMemBarrier.image)
- assert(imageObject.device == cmdBufferObject.device)
+ imageMemoryBarrier := as!VkImageMemoryBarrier const*(pMemoryBarriers[i])[0]
+ imageObject := GetImage(imageMemoryBarrier.image)
+ assert(imageObject.device == commandBufferObject.device)
}
case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER: {
- bufferMemBarrier := as!VkBufferMemoryBarrier const*(pMemBarriers[i])[0]
- bufferObject := GetBuffer(bufferMemBarrier.buffer)
- assert(bufferObject.device == cmdBufferObject.device)
+ bufferMemoryBarrier := as!VkBufferMemoryBarrier const*(pMemoryBarriers[i])[0]
+ bufferObject := GetBuffer(bufferMemoryBarrier.buffer)
+ assert(bufferObject.device == commandBufferObject.device)
}
}
}
@@ -4513,115 +4512,115 @@
@threadSafety("app")
cmd void vkCmdBeginQuery(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
u32 slot,
VkQueryControlFlags flags) {
- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+ commandBufferObject := GetCommandBuffer(commandBuffer)
queryPoolObject := GetQueryPool(queryPool)
- assert(cmdBufferObject.device == queryPoolObject.device)
+ assert(commandBufferObject.device == queryPoolObject.device)
}
@threadSafety("app")
cmd void vkCmdEndQuery(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
u32 slot) {
- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+ commandBufferObject := GetCommandBuffer(commandBuffer)
queryPoolObject := GetQueryPool(queryPool)
- assert(cmdBufferObject.device == queryPoolObject.device)
+ assert(commandBufferObject.device == queryPoolObject.device)
}
@threadSafety("app")
cmd void vkCmdResetQueryPool(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
u32 startQuery,
u32 queryCount) {
- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+ commandBufferObject := GetCommandBuffer(commandBuffer)
queryPoolObject := GetQueryPool(queryPool)
- assert(cmdBufferObject.device == queryPoolObject.device)
+ assert(commandBufferObject.device == queryPoolObject.device)
}
@threadSafety("app")
cmd void vkCmdWriteTimestamp(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkPipelineStageFlagBits pipelineStage,
VkQueryPool queryPool,
u32 slot) {
- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+ commandBufferObject := GetCommandBuffer(commandBuffer)
queryPoolObject := GetQueryPool(queryPool)
- assert(cmdBufferObject.device == queryPoolObject.device)
+ assert(commandBufferObject.device == queryPoolObject.device)
}
@threadSafety("app")
cmd void vkCmdCopyQueryPoolResults(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
u32 startQuery,
u32 queryCount,
- VkBuffer destBuffer,
- VkDeviceSize destOffset,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
VkDeviceSize stride,
VkQueryResultFlags flags) {
- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+ commandBufferObject := GetCommandBuffer(commandBuffer)
queryPoolObject := GetQueryPool(queryPool)
- destBufferObject := GetBuffer(destBuffer)
- assert(cmdBufferObject.device == queryPoolObject.device)
- assert(cmdBufferObject.device == destBufferObject.device)
+ dstBufferObject := GetBuffer(dstBuffer)
+ assert(commandBufferObject.device == queryPoolObject.device)
+ assert(commandBufferObject.device == dstBufferObject.device)
}
cmd void vkCmdPushConstants(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkPipelineLayout layout,
VkShaderStageFlags stageFlags,
u32 offset,
u32 size,
const void* values) {
- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+ commandBufferObject := GetCommandBuffer(commandBuffer)
layoutObject := GetPipelineLayout(layout)
- assert(cmdBufferObject.device == layoutObject.device)
+ assert(commandBufferObject.device == layoutObject.device)
}
@threadSafety("app")
cmd void vkCmdBeginRenderPass(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
const VkRenderPassBeginInfo* pRenderPassBegin,
VkRenderPassContents contents) {
- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+ commandBufferObject := GetCommandBuffer(commandBuffer)
renderPassObject := GetRenderPass(pRenderPassBegin.renderPass)
framebufferObject := GetFramebuffer(pRenderPassBegin.framebuffer)
- assert(cmdBufferObject.device == renderPassObject.device)
- assert(cmdBufferObject.device == framebufferObject.device)
+ assert(commandBufferObject.device == renderPassObject.device)
+ assert(commandBufferObject.device == framebufferObject.device)
- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}
cmd void vkCmdNextSubpass(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkRenderPassContents contents) {
- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+ commandBufferObject := GetCommandBuffer(commandBuffer)
}
@threadSafety("app")
cmd void vkCmdEndRenderPass(
- VkCmdBuffer cmdBuffer) {
- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+ VkCommandBuffer commandBuffer) {
+ commandBufferObject := GetCommandBuffer(commandBuffer)
- cmdBufferObject.queueFlags = AddQueueFlag(cmdBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
+ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}
cmd void vkCmdExecuteCommands(
- VkCmdBuffer cmdBuffer,
- u32 cmdBuffersCount,
- const VkCmdBuffer* pCmdBuffers) {
- cmdBufferObject := GetCmdBuffer(cmdBuffer)
+ VkCommandBuffer commandBuffer,
+ u32 commandBuffersCount,
+ const VkCommandBuffer* pCommandBuffers) {
+ commandBufferObject := GetCommandBuffer(commandBuffer)
- cmdBuffers := pCmdBuffers[0:cmdBuffersCount]
- for i in (0 .. cmdBuffersCount) {
- secondaryCmdBuffer := cmdBuffers[i]
- secondaryCmdBufferObject := GetCmdBuffer(secondaryCmdBuffer)
- assert(cmdBufferObject.device == secondaryCmdBufferObject.device)
+ commandBuffers := pCommandBuffers[0:commandBuffersCount]
+ for i in (0 .. commandBuffersCount) {
+ secondaryCommandBuffer := commandBuffers[i]
+ secondaryCommandBufferObject := GetCommandBuffer(secondaryCommandBuffer)
+ assert(commandBufferObject.device == secondaryCommandBufferObject.device)
}
}
@@ -4966,7 +4965,7 @@
map!(VkPhysicalDevice, ref!PhysicalDeviceObject) PhysicalDevices
map!(VkDevice, ref!DeviceObject) Devices
map!(VkQueue, ref!QueueObject) Queues
- map!(VkCmdBuffer, ref!CmdBufferObject) CmdBuffers
+ map!(VkCommandBuffer, ref!CommandBufferObject) CommandBuffers
// Non-dispatchable objects.
map!(VkDeviceMemory, ref!DeviceMemoryObject) DeviceMemories
@@ -4989,7 +4988,7 @@
map!(VkFramebuffer, ref!FramebufferObject) Framebuffers
map!(VkRenderPass, ref!RenderPassObject) RenderPasses
map!(VkPipelineCache, ref!PipelineCacheObject) PipelineCaches
- map!(VkCmdPool, ref!CmdPoolObject) CmdPools
+ map!(VkCommandPool, ref!CommandPoolObject) CommandPools
map!(VkSurfaceKHR, ref!SurfaceObject) Surfaces
map!(VkSwapchainKHR, ref!SwapchainObject) Swapchains
}
@@ -5010,23 +5009,23 @@
VkQueueFlags flags
}
-@internal class CmdBufferObject {
+@internal class CommandBufferObject {
VkDevice device
map!(u64, VkDeviceMemory) boundObjects
VkQueueFlags queueFlags
}
@internal class DeviceMemoryObject {
- VkDevice device
- VkDeviceSize allocationSize
- map!(u64, VkDeviceSize ) boundObjects
- map!(VkCmdBuffer, VkCmdBuffer) boundCommandBuffers
+ VkDevice device
+ VkDeviceSize allocationSize
+ map!(u64, VkDeviceSize) boundObjects
+ map!(VkCommandBuffer, VkCommandBuffer) boundCommandBuffers
}
@internal class BufferObject {
VkDevice device
- VkDeviceMemory mem
- VkDeviceSize memOffset
+ VkDeviceMemory memory
+ VkDeviceSize memoryOffset
}
@internal class BufferViewObject {
@@ -5036,8 +5035,8 @@
@internal class ImageObject {
VkDevice device
- VkDeviceMemory mem
- VkDeviceSize memOffset
+ VkDeviceMemory memory
+ VkDeviceSize memoryOffset
}
@internal class ImageViewObject {
@@ -5106,7 +5105,7 @@
VkDevice device
}
-@internal class CmdPoolObject {
+@internal class CommandPoolObject {
VkDevice device
}
@@ -5138,14 +5137,14 @@
return State.Queues[queue]
}
-macro ref!CmdBufferObject GetCmdBuffer(VkCmdBuffer cmdBuffer) {
- assert(cmdBuffer in State.CmdBuffers)
- return State.CmdBuffers[cmdBuffer]
+macro ref!CommandBufferObject GetCommandBuffer(VkCommandBuffer commandBuffer) {
+ assert(commandBuffer in State.CommandBuffers)
+ return State.CommandBuffers[commandBuffer]
}
-macro ref!DeviceMemoryObject GetDeviceMemory(VkDeviceMemory mem) {
- assert(mem in State.DeviceMemories)
- return State.DeviceMemories[mem]
+macro ref!DeviceMemoryObject GetDeviceMemory(VkDeviceMemory memory) {
+ assert(memory in State.DeviceMemories)
+ return State.DeviceMemories[memory]
}
macro ref!BufferObject GetBuffer(VkBuffer buffer) {
@@ -5243,9 +5242,9 @@
return State.PipelineCaches[pipelineCache]
}
-macro ref!CmdPoolObject GetCmdPool(VkCmdPool cmdPool) {
- assert(cmdPool in State.CmdPools)
- return State.CmdPools[cmdPool]
+macro ref!CommandPoolObject GetCommandPool(VkCommandPool commandPool) {
+ assert(commandPool in State.CommandPools)
+ return State.CommandPools[commandPool]
}
macro ref!SurfaceObject GetSurface(VkSurfaceKHR surface) {
diff --git a/vulkan/include/vulkan/vk_debug_report_lunarg.h b/vulkan/include/vulkan/vk_debug_report_lunarg.h
index 23bb63c..286c354 100644
--- a/vulkan/include/vulkan/vk_debug_report_lunarg.h
+++ b/vulkan/include/vulkan/vk_debug_report_lunarg.h
@@ -83,7 +83,7 @@
#define VK_DEBUG_REPORT_EXTENSION_NAME "DEBUG_REPORT"
-VK_DEFINE_NONDISP_HANDLE(VkDbgMsgCallback)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDbgMsgCallback)
// ------------------------------------------------------------------------------------------------
// Enumerations
diff --git a/vulkan/include/vulkan/vulkan.h b/vulkan/include/vulkan/vulkan.h
index af0ccdf..0130399 100644
--- a/vulkan/include/vulkan/vulkan.h
+++ b/vulkan/include/vulkan/vulkan.h
@@ -41,20 +41,20 @@
((major << 22) | (minor << 12) | patch)
// Vulkan API version supported by this file
-#define VK_API_VERSION VK_MAKE_VERSION(0, 194, 0)
+#define VK_API_VERSION VK_MAKE_VERSION(0, 196, 0)
#define VK_NULL_HANDLE 0
-#define VK_DEFINE_HANDLE(obj) typedef struct obj##_T* obj;
+#define VK_DEFINE_HANDLE(object) typedef struct object##_T* object;
#if defined(__LP64__) || defined(_WIN64) || defined(__x86_64__) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
- #define VK_DEFINE_NONDISP_HANDLE(obj) typedef struct obj##_T *obj;
+ #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *object;
#else
- #define VK_DEFINE_NONDISP_HANDLE(obj) typedef uint64_t obj;
+ #define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object;
#endif
@@ -68,28 +68,28 @@
VK_DEFINE_HANDLE(VkPhysicalDevice)
VK_DEFINE_HANDLE(VkDevice)
VK_DEFINE_HANDLE(VkQueue)
-VK_DEFINE_NONDISP_HANDLE(VkSemaphore)
-VK_DEFINE_HANDLE(VkCmdBuffer)
-VK_DEFINE_NONDISP_HANDLE(VkFence)
-VK_DEFINE_NONDISP_HANDLE(VkDeviceMemory)
-VK_DEFINE_NONDISP_HANDLE(VkBuffer)
-VK_DEFINE_NONDISP_HANDLE(VkImage)
-VK_DEFINE_NONDISP_HANDLE(VkEvent)
-VK_DEFINE_NONDISP_HANDLE(VkQueryPool)
-VK_DEFINE_NONDISP_HANDLE(VkBufferView)
-VK_DEFINE_NONDISP_HANDLE(VkImageView)
-VK_DEFINE_NONDISP_HANDLE(VkShaderModule)
-VK_DEFINE_NONDISP_HANDLE(VkShader)
-VK_DEFINE_NONDISP_HANDLE(VkPipelineCache)
-VK_DEFINE_NONDISP_HANDLE(VkPipelineLayout)
-VK_DEFINE_NONDISP_HANDLE(VkRenderPass)
-VK_DEFINE_NONDISP_HANDLE(VkPipeline)
-VK_DEFINE_NONDISP_HANDLE(VkDescriptorSetLayout)
-VK_DEFINE_NONDISP_HANDLE(VkSampler)
-VK_DEFINE_NONDISP_HANDLE(VkDescriptorPool)
-VK_DEFINE_NONDISP_HANDLE(VkDescriptorSet)
-VK_DEFINE_NONDISP_HANDLE(VkFramebuffer)
-VK_DEFINE_NONDISP_HANDLE(VkCmdPool)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSemaphore)
+VK_DEFINE_HANDLE(VkCommandBuffer)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBuffer)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkQueryPool)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShader)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSampler)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool)
#define VK_LOD_CLAMP_NONE 1000.0f
#define VK_REMAINING_MIP_LEVELS (~0U)
@@ -126,7 +126,7 @@
VK_ERROR_INCOMPATIBLE_DRIVER = -9,
VK_RESULT_BEGIN_RANGE = VK_ERROR_INCOMPATIBLE_DRIVER,
VK_RESULT_END_RANGE = VK_INCOMPLETE,
- VK_RESULT_NUM = (VK_INCOMPLETE - VK_ERROR_INCOMPATIBLE_DRIVER + 1),
+ VK_RESULT_RANGE_SIZE = (VK_INCOMPLETE - VK_ERROR_INCOMPATIBLE_DRIVER + 1),
VK_RESULT_MAX_ENUM = 0x7FFFFFFF
} VkResult;
@@ -171,9 +171,9 @@
VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 37,
VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 38,
VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 39,
- VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO = 40,
- VK_STRUCTURE_TYPE_CMD_BUFFER_ALLOC_INFO = 41,
- VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO = 42,
+ VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 40,
+ VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOC_INFO = 41,
+ VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42,
VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43,
VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44,
VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45,
@@ -182,29 +182,29 @@
VK_STRUCTURE_TYPE_LAYER_DEVICE_CREATE_INFO = 48,
VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO,
VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_LAYER_DEVICE_CREATE_INFO,
- VK_STRUCTURE_TYPE_NUM = (VK_STRUCTURE_TYPE_LAYER_DEVICE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1),
+ VK_STRUCTURE_TYPE_RANGE_SIZE = (VK_STRUCTURE_TYPE_LAYER_DEVICE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1),
VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF
} VkStructureType;
typedef enum {
- VK_SYSTEM_ALLOC_SCOPE_FUNCTION = 0,
- VK_SYSTEM_ALLOC_SCOPE_OBJECT = 1,
- VK_SYSTEM_ALLOC_SCOPE_CACHE = 2,
- VK_SYSTEM_ALLOC_SCOPE_DEVICE = 3,
- VK_SYSTEM_ALLOC_SCOPE_INSTANCE = 4,
- VK_SYSTEM_ALLOC_SCOPE_BEGIN_RANGE = VK_SYSTEM_ALLOC_SCOPE_FUNCTION,
- VK_SYSTEM_ALLOC_SCOPE_END_RANGE = VK_SYSTEM_ALLOC_SCOPE_INSTANCE,
- VK_SYSTEM_ALLOC_SCOPE_NUM = (VK_SYSTEM_ALLOC_SCOPE_INSTANCE - VK_SYSTEM_ALLOC_SCOPE_FUNCTION + 1),
- VK_SYSTEM_ALLOC_SCOPE_MAX_ENUM = 0x7FFFFFFF
-} VkSystemAllocScope;
+ VK_SYSTEM_ALLOCATION_SCOPE_FUNCTION = 0,
+ VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1,
+ VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2,
+ VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3,
+ VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4,
+ VK_SYSTEM_ALLOCATION_SCOPE_BEGIN_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_FUNCTION,
+ VK_SYSTEM_ALLOCATION_SCOPE_END_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE,
+ VK_SYSTEM_ALLOCATION_SCOPE_RANGE_SIZE = (VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE - VK_SYSTEM_ALLOCATION_SCOPE_FUNCTION + 1),
+ VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF
+} VkSystemAllocationScope;
typedef enum {
- VK_INTERNAL_ALLOC_TYPE_EXECUTABLE = 0,
- VK_INTERNAL_ALLOC_TYPE_BEGIN_RANGE = VK_INTERNAL_ALLOC_TYPE_EXECUTABLE,
- VK_INTERNAL_ALLOC_TYPE_END_RANGE = VK_INTERNAL_ALLOC_TYPE_EXECUTABLE,
- VK_INTERNAL_ALLOC_TYPE_NUM = (VK_INTERNAL_ALLOC_TYPE_EXECUTABLE - VK_INTERNAL_ALLOC_TYPE_EXECUTABLE + 1),
- VK_INTERNAL_ALLOC_TYPE_MAX_ENUM = 0x7FFFFFFF
-} VkInternalAllocType;
+ VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0,
+ VK_INTERNAL_ALLOCATION_TYPE_BEGIN_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE,
+ VK_INTERNAL_ALLOCATION_TYPE_END_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE,
+ VK_INTERNAL_ALLOCATION_TYPE_RANGE_SIZE = (VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE - VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE + 1),
+ VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF
+} VkInternalAllocationType;
typedef enum {
VK_FORMAT_UNDEFINED = 0,
@@ -383,7 +383,7 @@
VK_FORMAT_B10G10R10A2_SINT = 173,
VK_FORMAT_BEGIN_RANGE = VK_FORMAT_UNDEFINED,
VK_FORMAT_END_RANGE = VK_FORMAT_B10G10R10A2_SINT,
- VK_FORMAT_NUM = (VK_FORMAT_B10G10R10A2_SINT - VK_FORMAT_UNDEFINED + 1),
+ VK_FORMAT_RANGE_SIZE = (VK_FORMAT_B10G10R10A2_SINT - VK_FORMAT_UNDEFINED + 1),
VK_FORMAT_MAX_ENUM = 0x7FFFFFFF
} VkFormat;
@@ -393,7 +393,7 @@
VK_IMAGE_TYPE_3D = 2,
VK_IMAGE_TYPE_BEGIN_RANGE = VK_IMAGE_TYPE_1D,
VK_IMAGE_TYPE_END_RANGE = VK_IMAGE_TYPE_3D,
- VK_IMAGE_TYPE_NUM = (VK_IMAGE_TYPE_3D - VK_IMAGE_TYPE_1D + 1),
+ VK_IMAGE_TYPE_RANGE_SIZE = (VK_IMAGE_TYPE_3D - VK_IMAGE_TYPE_1D + 1),
VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF
} VkImageType;
@@ -402,7 +402,7 @@
VK_IMAGE_TILING_LINEAR = 1,
VK_IMAGE_TILING_BEGIN_RANGE = VK_IMAGE_TILING_OPTIMAL,
VK_IMAGE_TILING_END_RANGE = VK_IMAGE_TILING_LINEAR,
- VK_IMAGE_TILING_NUM = (VK_IMAGE_TILING_LINEAR - VK_IMAGE_TILING_OPTIMAL + 1),
+ VK_IMAGE_TILING_RANGE_SIZE = (VK_IMAGE_TILING_LINEAR - VK_IMAGE_TILING_OPTIMAL + 1),
VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF
} VkImageTiling;
@@ -414,7 +414,7 @@
VK_PHYSICAL_DEVICE_TYPE_CPU = 4,
VK_PHYSICAL_DEVICE_TYPE_BEGIN_RANGE = VK_PHYSICAL_DEVICE_TYPE_OTHER,
VK_PHYSICAL_DEVICE_TYPE_END_RANGE = VK_PHYSICAL_DEVICE_TYPE_CPU,
- VK_PHYSICAL_DEVICE_TYPE_NUM = (VK_PHYSICAL_DEVICE_TYPE_CPU - VK_PHYSICAL_DEVICE_TYPE_OTHER + 1),
+ VK_PHYSICAL_DEVICE_TYPE_RANGE_SIZE = (VK_PHYSICAL_DEVICE_TYPE_CPU - VK_PHYSICAL_DEVICE_TYPE_OTHER + 1),
VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF
} VkPhysicalDeviceType;
@@ -424,7 +424,7 @@
VK_QUERY_TYPE_TIMESTAMP = 2,
VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_TYPE_OCCLUSION,
VK_QUERY_TYPE_END_RANGE = VK_QUERY_TYPE_TIMESTAMP,
- VK_QUERY_TYPE_NUM = (VK_QUERY_TYPE_TIMESTAMP - VK_QUERY_TYPE_OCCLUSION + 1),
+ VK_QUERY_TYPE_RANGE_SIZE = (VK_QUERY_TYPE_TIMESTAMP - VK_QUERY_TYPE_OCCLUSION + 1),
VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF
} VkQueryType;
@@ -433,7 +433,7 @@
VK_SHARING_MODE_CONCURRENT = 1,
VK_SHARING_MODE_BEGIN_RANGE = VK_SHARING_MODE_EXCLUSIVE,
VK_SHARING_MODE_END_RANGE = VK_SHARING_MODE_CONCURRENT,
- VK_SHARING_MODE_NUM = (VK_SHARING_MODE_CONCURRENT - VK_SHARING_MODE_EXCLUSIVE + 1),
+ VK_SHARING_MODE_RANGE_SIZE = (VK_SHARING_MODE_CONCURRENT - VK_SHARING_MODE_EXCLUSIVE + 1),
VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF
} VkSharingMode;
@@ -444,12 +444,12 @@
VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3,
VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4,
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5,
- VK_IMAGE_LAYOUT_TRANSFER_SOURCE_OPTIMAL = 6,
- VK_IMAGE_LAYOUT_TRANSFER_DESTINATION_OPTIMAL = 7,
+ VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6,
+ VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7,
VK_IMAGE_LAYOUT_PREINITIALIZED = 8,
VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED,
VK_IMAGE_LAYOUT_END_RANGE = VK_IMAGE_LAYOUT_PREINITIALIZED,
- VK_IMAGE_LAYOUT_NUM = (VK_IMAGE_LAYOUT_PREINITIALIZED - VK_IMAGE_LAYOUT_UNDEFINED + 1),
+ VK_IMAGE_LAYOUT_RANGE_SIZE = (VK_IMAGE_LAYOUT_PREINITIALIZED - VK_IMAGE_LAYOUT_UNDEFINED + 1),
VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF
} VkImageLayout;
@@ -463,7 +463,7 @@
VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6,
VK_IMAGE_VIEW_TYPE_BEGIN_RANGE = VK_IMAGE_VIEW_TYPE_1D,
VK_IMAGE_VIEW_TYPE_END_RANGE = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY,
- VK_IMAGE_VIEW_TYPE_NUM = (VK_IMAGE_VIEW_TYPE_CUBE_ARRAY - VK_IMAGE_VIEW_TYPE_1D + 1),
+ VK_IMAGE_VIEW_TYPE_RANGE_SIZE = (VK_IMAGE_VIEW_TYPE_CUBE_ARRAY - VK_IMAGE_VIEW_TYPE_1D + 1),
VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF
} VkImageViewType;
@@ -477,7 +477,7 @@
VK_CHANNEL_SWIZZLE_A = 6,
VK_CHANNEL_SWIZZLE_BEGIN_RANGE = VK_CHANNEL_SWIZZLE_IDENTITY,
VK_CHANNEL_SWIZZLE_END_RANGE = VK_CHANNEL_SWIZZLE_A,
- VK_CHANNEL_SWIZZLE_NUM = (VK_CHANNEL_SWIZZLE_A - VK_CHANNEL_SWIZZLE_IDENTITY + 1),
+ VK_CHANNEL_SWIZZLE_RANGE_SIZE = (VK_CHANNEL_SWIZZLE_A - VK_CHANNEL_SWIZZLE_IDENTITY + 1),
VK_CHANNEL_SWIZZLE_MAX_ENUM = 0x7FFFFFFF
} VkChannelSwizzle;
@@ -486,7 +486,7 @@
VK_VERTEX_INPUT_STEP_RATE_INSTANCE = 1,
VK_VERTEX_INPUT_STEP_RATE_BEGIN_RANGE = VK_VERTEX_INPUT_STEP_RATE_VERTEX,
VK_VERTEX_INPUT_STEP_RATE_END_RANGE = VK_VERTEX_INPUT_STEP_RATE_INSTANCE,
- VK_VERTEX_INPUT_STEP_RATE_NUM = (VK_VERTEX_INPUT_STEP_RATE_INSTANCE - VK_VERTEX_INPUT_STEP_RATE_VERTEX + 1),
+ VK_VERTEX_INPUT_STEP_RATE_RANGE_SIZE = (VK_VERTEX_INPUT_STEP_RATE_INSTANCE - VK_VERTEX_INPUT_STEP_RATE_VERTEX + 1),
VK_VERTEX_INPUT_STEP_RATE_MAX_ENUM = 0x7FFFFFFF
} VkVertexInputStepRate;
@@ -497,14 +497,14 @@
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3,
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4,
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5,
- VK_PRIMITIVE_TOPOLOGY_LINE_LIST_ADJ = 6,
- VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_ADJ = 7,
- VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_ADJ = 8,
- VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_ADJ = 9,
+ VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6,
+ VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7,
+ VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8,
+ VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9,
VK_PRIMITIVE_TOPOLOGY_PATCH = 10,
VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE = VK_PRIMITIVE_TOPOLOGY_POINT_LIST,
VK_PRIMITIVE_TOPOLOGY_END_RANGE = VK_PRIMITIVE_TOPOLOGY_PATCH,
- VK_PRIMITIVE_TOPOLOGY_NUM = (VK_PRIMITIVE_TOPOLOGY_PATCH - VK_PRIMITIVE_TOPOLOGY_POINT_LIST + 1),
+ VK_PRIMITIVE_TOPOLOGY_RANGE_SIZE = (VK_PRIMITIVE_TOPOLOGY_PATCH - VK_PRIMITIVE_TOPOLOGY_POINT_LIST + 1),
VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF
} VkPrimitiveTopology;
@@ -514,16 +514,16 @@
VK_FILL_MODE_POINTS = 2,
VK_FILL_MODE_BEGIN_RANGE = VK_FILL_MODE_SOLID,
VK_FILL_MODE_END_RANGE = VK_FILL_MODE_POINTS,
- VK_FILL_MODE_NUM = (VK_FILL_MODE_POINTS - VK_FILL_MODE_SOLID + 1),
+ VK_FILL_MODE_RANGE_SIZE = (VK_FILL_MODE_POINTS - VK_FILL_MODE_SOLID + 1),
VK_FILL_MODE_MAX_ENUM = 0x7FFFFFFF
} VkFillMode;
typedef enum {
- VK_FRONT_FACE_CCW = 0,
- VK_FRONT_FACE_CW = 1,
- VK_FRONT_FACE_BEGIN_RANGE = VK_FRONT_FACE_CCW,
- VK_FRONT_FACE_END_RANGE = VK_FRONT_FACE_CW,
- VK_FRONT_FACE_NUM = (VK_FRONT_FACE_CW - VK_FRONT_FACE_CCW + 1),
+ VK_FRONT_FACE_COUNTER_CLOCKWISE = 0,
+ VK_FRONT_FACE_CLOCKWISE = 1,
+ VK_FRONT_FACE_BEGIN_RANGE = VK_FRONT_FACE_COUNTER_CLOCKWISE,
+ VK_FRONT_FACE_END_RANGE = VK_FRONT_FACE_CLOCKWISE,
+ VK_FRONT_FACE_RANGE_SIZE = (VK_FRONT_FACE_CLOCKWISE - VK_FRONT_FACE_COUNTER_CLOCKWISE + 1),
VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF
} VkFrontFace;
@@ -531,14 +531,14 @@
VK_COMPARE_OP_NEVER = 0,
VK_COMPARE_OP_LESS = 1,
VK_COMPARE_OP_EQUAL = 2,
- VK_COMPARE_OP_LESS_EQUAL = 3,
+ VK_COMPARE_OP_LESS_OR_EQUAL = 3,
VK_COMPARE_OP_GREATER = 4,
VK_COMPARE_OP_NOT_EQUAL = 5,
- VK_COMPARE_OP_GREATER_EQUAL = 6,
+ VK_COMPARE_OP_GREATER_OR_EQUAL = 6,
VK_COMPARE_OP_ALWAYS = 7,
VK_COMPARE_OP_BEGIN_RANGE = VK_COMPARE_OP_NEVER,
VK_COMPARE_OP_END_RANGE = VK_COMPARE_OP_ALWAYS,
- VK_COMPARE_OP_NUM = (VK_COMPARE_OP_ALWAYS - VK_COMPARE_OP_NEVER + 1),
+ VK_COMPARE_OP_RANGE_SIZE = (VK_COMPARE_OP_ALWAYS - VK_COMPARE_OP_NEVER + 1),
VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF
} VkCompareOp;
@@ -546,14 +546,14 @@
VK_STENCIL_OP_KEEP = 0,
VK_STENCIL_OP_ZERO = 1,
VK_STENCIL_OP_REPLACE = 2,
- VK_STENCIL_OP_INC_CLAMP = 3,
- VK_STENCIL_OP_DEC_CLAMP = 4,
+ VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3,
+ VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4,
VK_STENCIL_OP_INVERT = 5,
- VK_STENCIL_OP_INC_WRAP = 6,
- VK_STENCIL_OP_DEC_WRAP = 7,
+ VK_STENCIL_OP_INCREMENT_AND_WRAP = 6,
+ VK_STENCIL_OP_DECREMENT_AND_WRAP = 7,
VK_STENCIL_OP_BEGIN_RANGE = VK_STENCIL_OP_KEEP,
- VK_STENCIL_OP_END_RANGE = VK_STENCIL_OP_DEC_WRAP,
- VK_STENCIL_OP_NUM = (VK_STENCIL_OP_DEC_WRAP - VK_STENCIL_OP_KEEP + 1),
+ VK_STENCIL_OP_END_RANGE = VK_STENCIL_OP_DECREMENT_AND_WRAP,
+ VK_STENCIL_OP_RANGE_SIZE = (VK_STENCIL_OP_DECREMENT_AND_WRAP - VK_STENCIL_OP_KEEP + 1),
VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF
} VkStencilOp;
@@ -563,11 +563,11 @@
VK_LOGIC_OP_AND_REVERSE = 2,
VK_LOGIC_OP_COPY = 3,
VK_LOGIC_OP_AND_INVERTED = 4,
- VK_LOGIC_OP_NOOP = 5,
+ VK_LOGIC_OP_NO_OP = 5,
VK_LOGIC_OP_XOR = 6,
VK_LOGIC_OP_OR = 7,
VK_LOGIC_OP_NOR = 8,
- VK_LOGIC_OP_EQUIV = 9,
+ VK_LOGIC_OP_EQUIVALENT = 9,
VK_LOGIC_OP_INVERT = 10,
VK_LOGIC_OP_OR_REVERSE = 11,
VK_LOGIC_OP_COPY_INVERTED = 12,
@@ -576,7 +576,7 @@
VK_LOGIC_OP_SET = 15,
VK_LOGIC_OP_BEGIN_RANGE = VK_LOGIC_OP_CLEAR,
VK_LOGIC_OP_END_RANGE = VK_LOGIC_OP_SET,
- VK_LOGIC_OP_NUM = (VK_LOGIC_OP_SET - VK_LOGIC_OP_CLEAR + 1),
+ VK_LOGIC_OP_RANGE_SIZE = (VK_LOGIC_OP_SET - VK_LOGIC_OP_CLEAR + 1),
VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF
} VkLogicOp;
@@ -585,12 +585,12 @@
VK_BLEND_ONE = 1,
VK_BLEND_SRC_COLOR = 2,
VK_BLEND_ONE_MINUS_SRC_COLOR = 3,
- VK_BLEND_DEST_COLOR = 4,
- VK_BLEND_ONE_MINUS_DEST_COLOR = 5,
+ VK_BLEND_DST_COLOR = 4,
+ VK_BLEND_ONE_MINUS_DST_COLOR = 5,
VK_BLEND_SRC_ALPHA = 6,
VK_BLEND_ONE_MINUS_SRC_ALPHA = 7,
- VK_BLEND_DEST_ALPHA = 8,
- VK_BLEND_ONE_MINUS_DEST_ALPHA = 9,
+ VK_BLEND_DST_ALPHA = 8,
+ VK_BLEND_ONE_MINUS_DST_ALPHA = 9,
VK_BLEND_CONSTANT_COLOR = 10,
VK_BLEND_ONE_MINUS_CONSTANT_COLOR = 11,
VK_BLEND_CONSTANT_ALPHA = 12,
@@ -602,7 +602,7 @@
VK_BLEND_ONE_MINUS_SRC1_ALPHA = 18,
VK_BLEND_BEGIN_RANGE = VK_BLEND_ZERO,
VK_BLEND_END_RANGE = VK_BLEND_ONE_MINUS_SRC1_ALPHA,
- VK_BLEND_NUM = (VK_BLEND_ONE_MINUS_SRC1_ALPHA - VK_BLEND_ZERO + 1),
+ VK_BLEND_RANGE_SIZE = (VK_BLEND_ONE_MINUS_SRC1_ALPHA - VK_BLEND_ZERO + 1),
VK_BLEND_MAX_ENUM = 0x7FFFFFFF
} VkBlend;
@@ -614,7 +614,7 @@
VK_BLEND_OP_MAX = 4,
VK_BLEND_OP_BEGIN_RANGE = VK_BLEND_OP_ADD,
VK_BLEND_OP_END_RANGE = VK_BLEND_OP_MAX,
- VK_BLEND_OP_NUM = (VK_BLEND_OP_MAX - VK_BLEND_OP_ADD + 1),
+ VK_BLEND_OP_RANGE_SIZE = (VK_BLEND_OP_MAX - VK_BLEND_OP_ADD + 1),
VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF
} VkBlendOp;
@@ -630,7 +630,7 @@
VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8,
VK_DYNAMIC_STATE_BEGIN_RANGE = VK_DYNAMIC_STATE_VIEWPORT,
VK_DYNAMIC_STATE_END_RANGE = VK_DYNAMIC_STATE_STENCIL_REFERENCE,
- VK_DYNAMIC_STATE_NUM = (VK_DYNAMIC_STATE_STENCIL_REFERENCE - VK_DYNAMIC_STATE_VIEWPORT + 1),
+ VK_DYNAMIC_STATE_RANGE_SIZE = (VK_DYNAMIC_STATE_STENCIL_REFERENCE - VK_DYNAMIC_STATE_VIEWPORT + 1),
VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF
} VkDynamicState;
@@ -639,7 +639,7 @@
VK_FILTER_LINEAR = 1,
VK_FILTER_BEGIN_RANGE = VK_FILTER_NEAREST,
VK_FILTER_END_RANGE = VK_FILTER_LINEAR,
- VK_FILTER_NUM = (VK_FILTER_LINEAR - VK_FILTER_NEAREST + 1),
+ VK_FILTER_RANGE_SIZE = (VK_FILTER_LINEAR - VK_FILTER_NEAREST + 1),
VK_FILTER_MAX_ENUM = 0x7FFFFFFF
} VkFilter;
@@ -649,7 +649,7 @@
VK_SAMPLER_MIPMAP_MODE_LINEAR = 2,
VK_SAMPLER_MIPMAP_MODE_BEGIN_RANGE = VK_SAMPLER_MIPMAP_MODE_BASE,
VK_SAMPLER_MIPMAP_MODE_END_RANGE = VK_SAMPLER_MIPMAP_MODE_LINEAR,
- VK_SAMPLER_MIPMAP_MODE_NUM = (VK_SAMPLER_MIPMAP_MODE_LINEAR - VK_SAMPLER_MIPMAP_MODE_BASE + 1),
+ VK_SAMPLER_MIPMAP_MODE_RANGE_SIZE = (VK_SAMPLER_MIPMAP_MODE_LINEAR - VK_SAMPLER_MIPMAP_MODE_BASE + 1),
VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF
} VkSamplerMipmapMode;
@@ -661,7 +661,7 @@
VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4,
VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE = VK_SAMPLER_ADDRESS_MODE_REPEAT,
VK_SAMPLER_ADDRESS_MODE_END_RANGE = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE,
- VK_SAMPLER_ADDRESS_MODE_NUM = (VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE - VK_SAMPLER_ADDRESS_MODE_REPEAT + 1),
+ VK_SAMPLER_ADDRESS_MODE_RANGE_SIZE = (VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE - VK_SAMPLER_ADDRESS_MODE_REPEAT + 1),
VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF
} VkSamplerAddressMode;
@@ -674,7 +674,7 @@
VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5,
VK_BORDER_COLOR_BEGIN_RANGE = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,
VK_BORDER_COLOR_END_RANGE = VK_BORDER_COLOR_INT_OPAQUE_WHITE,
- VK_BORDER_COLOR_NUM = (VK_BORDER_COLOR_INT_OPAQUE_WHITE - VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK + 1),
+ VK_BORDER_COLOR_RANGE_SIZE = (VK_BORDER_COLOR_INT_OPAQUE_WHITE - VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK + 1),
VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF
} VkBorderColor;
@@ -692,7 +692,7 @@
VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10,
VK_DESCRIPTOR_TYPE_BEGIN_RANGE = VK_DESCRIPTOR_TYPE_SAMPLER,
VK_DESCRIPTOR_TYPE_END_RANGE = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
- VK_DESCRIPTOR_TYPE_NUM = (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT - VK_DESCRIPTOR_TYPE_SAMPLER + 1),
+ VK_DESCRIPTOR_TYPE_RANGE_SIZE = (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT - VK_DESCRIPTOR_TYPE_SAMPLER + 1),
VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF
} VkDescriptorType;
@@ -702,7 +702,7 @@
VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2,
VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE = VK_ATTACHMENT_LOAD_OP_LOAD,
VK_ATTACHMENT_LOAD_OP_END_RANGE = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
- VK_ATTACHMENT_LOAD_OP_NUM = (VK_ATTACHMENT_LOAD_OP_DONT_CARE - VK_ATTACHMENT_LOAD_OP_LOAD + 1),
+ VK_ATTACHMENT_LOAD_OP_RANGE_SIZE = (VK_ATTACHMENT_LOAD_OP_DONT_CARE - VK_ATTACHMENT_LOAD_OP_LOAD + 1),
VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF
} VkAttachmentLoadOp;
@@ -711,7 +711,7 @@
VK_ATTACHMENT_STORE_OP_DONT_CARE = 1,
VK_ATTACHMENT_STORE_OP_BEGIN_RANGE = VK_ATTACHMENT_STORE_OP_STORE,
VK_ATTACHMENT_STORE_OP_END_RANGE = VK_ATTACHMENT_STORE_OP_DONT_CARE,
- VK_ATTACHMENT_STORE_OP_NUM = (VK_ATTACHMENT_STORE_OP_DONT_CARE - VK_ATTACHMENT_STORE_OP_STORE + 1),
+ VK_ATTACHMENT_STORE_OP_RANGE_SIZE = (VK_ATTACHMENT_STORE_OP_DONT_CARE - VK_ATTACHMENT_STORE_OP_STORE + 1),
VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF
} VkAttachmentStoreOp;
@@ -720,34 +720,34 @@
VK_PIPELINE_BIND_POINT_COMPUTE = 1,
VK_PIPELINE_BIND_POINT_BEGIN_RANGE = VK_PIPELINE_BIND_POINT_GRAPHICS,
VK_PIPELINE_BIND_POINT_END_RANGE = VK_PIPELINE_BIND_POINT_COMPUTE,
- VK_PIPELINE_BIND_POINT_NUM = (VK_PIPELINE_BIND_POINT_COMPUTE - VK_PIPELINE_BIND_POINT_GRAPHICS + 1),
+ VK_PIPELINE_BIND_POINT_RANGE_SIZE = (VK_PIPELINE_BIND_POINT_COMPUTE - VK_PIPELINE_BIND_POINT_GRAPHICS + 1),
VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF
} VkPipelineBindPoint;
typedef enum {
- VK_CMD_BUFFER_LEVEL_PRIMARY = 0,
- VK_CMD_BUFFER_LEVEL_SECONDARY = 1,
- VK_CMD_BUFFER_LEVEL_BEGIN_RANGE = VK_CMD_BUFFER_LEVEL_PRIMARY,
- VK_CMD_BUFFER_LEVEL_END_RANGE = VK_CMD_BUFFER_LEVEL_SECONDARY,
- VK_CMD_BUFFER_LEVEL_NUM = (VK_CMD_BUFFER_LEVEL_SECONDARY - VK_CMD_BUFFER_LEVEL_PRIMARY + 1),
- VK_CMD_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF
-} VkCmdBufferLevel;
+ VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0,
+ VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1,
+ VK_COMMAND_BUFFER_LEVEL_BEGIN_RANGE = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
+ VK_COMMAND_BUFFER_LEVEL_END_RANGE = VK_COMMAND_BUFFER_LEVEL_SECONDARY,
+ VK_COMMAND_BUFFER_LEVEL_RANGE_SIZE = (VK_COMMAND_BUFFER_LEVEL_SECONDARY - VK_COMMAND_BUFFER_LEVEL_PRIMARY + 1),
+ VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF
+} VkCommandBufferLevel;
typedef enum {
VK_INDEX_TYPE_UINT16 = 0,
VK_INDEX_TYPE_UINT32 = 1,
VK_INDEX_TYPE_BEGIN_RANGE = VK_INDEX_TYPE_UINT16,
VK_INDEX_TYPE_END_RANGE = VK_INDEX_TYPE_UINT32,
- VK_INDEX_TYPE_NUM = (VK_INDEX_TYPE_UINT32 - VK_INDEX_TYPE_UINT16 + 1),
+ VK_INDEX_TYPE_RANGE_SIZE = (VK_INDEX_TYPE_UINT32 - VK_INDEX_TYPE_UINT16 + 1),
VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF
} VkIndexType;
typedef enum {
VK_RENDER_PASS_CONTENTS_INLINE = 0,
- VK_RENDER_PASS_CONTENTS_SECONDARY_CMD_BUFFERS = 1,
+ VK_RENDER_PASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1,
VK_RENDER_PASS_CONTENTS_BEGIN_RANGE = VK_RENDER_PASS_CONTENTS_INLINE,
- VK_RENDER_PASS_CONTENTS_END_RANGE = VK_RENDER_PASS_CONTENTS_SECONDARY_CMD_BUFFERS,
- VK_RENDER_PASS_CONTENTS_NUM = (VK_RENDER_PASS_CONTENTS_SECONDARY_CMD_BUFFERS - VK_RENDER_PASS_CONTENTS_INLINE + 1),
+ VK_RENDER_PASS_CONTENTS_END_RANGE = VK_RENDER_PASS_CONTENTS_SECONDARY_COMMAND_BUFFERS,
+ VK_RENDER_PASS_CONTENTS_RANGE_SIZE = (VK_RENDER_PASS_CONTENTS_SECONDARY_COMMAND_BUFFERS - VK_RENDER_PASS_CONTENTS_INLINE + 1),
VK_RENDER_PASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF
} VkRenderPassContents;
@@ -764,14 +764,14 @@
VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080,
VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100,
VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200,
- VK_FORMAT_FEATURE_BLIT_SOURCE_BIT = 0x00000400,
- VK_FORMAT_FEATURE_BLIT_DESTINATION_BIT = 0x00000800,
+ VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0x00000400,
+ VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800,
} VkFormatFeatureFlagBits;
typedef VkFlags VkFormatFeatureFlags;
typedef enum {
- VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT = 0x00000001,
- VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT = 0x00000002,
+ VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001,
+ VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0x00000002,
VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004,
VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008,
VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010,
@@ -885,8 +885,8 @@
typedef VkFlags VkBufferCreateFlags;
typedef enum {
- VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT = 0x00000001,
- VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT = 0x00000002,
+ VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001,
+ VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002,
VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004,
VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008,
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010,
@@ -925,7 +925,7 @@
typedef VkFlags VkPipelineInputAssemblyStateCreateFlags;
typedef VkFlags VkPipelineTesselationStateCreateFlags;
typedef VkFlags VkPipelineViewportStateCreateFlags;
-typedef VkFlags VkPipelineRasterStateCreateFlags;
+typedef VkFlags VkPipelineRasterizationStateCreateFlags;
typedef enum {
VK_CULL_MODE_NONE = 0,
@@ -1014,27 +1014,27 @@
typedef VkFlags VkDependencyFlags;
typedef enum {
- VK_CMD_POOL_CREATE_TRANSIENT_BIT = 0x00000001,
- VK_CMD_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002,
-} VkCmdPoolCreateFlagBits;
-typedef VkFlags VkCmdPoolCreateFlags;
+ VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001,
+ VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002,
+} VkCommandPoolCreateFlagBits;
+typedef VkFlags VkCommandPoolCreateFlags;
typedef enum {
- VK_CMD_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
-} VkCmdPoolResetFlagBits;
-typedef VkFlags VkCmdPoolResetFlags;
+ VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
+} VkCommandPoolResetFlagBits;
+typedef VkFlags VkCommandPoolResetFlags;
typedef enum {
- VK_CMD_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001,
- VK_CMD_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002,
- VK_CMD_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004,
-} VkCmdBufferUsageFlagBits;
-typedef VkFlags VkCmdBufferUsageFlags;
+ VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001,
+ VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002,
+ VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004,
+} VkCommandBufferUsageFlagBits;
+typedef VkFlags VkCommandBufferUsageFlags;
typedef enum {
- VK_CMD_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
-} VkCmdBufferResetFlagBits;
-typedef VkFlags VkCmdBufferResetFlags;
+ VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
+} VkCommandBufferResetFlagBits;
+typedef VkFlags VkCommandBufferResetFlags;
typedef enum {
VK_STENCIL_FACE_NONE = 0,
@@ -1049,42 +1049,42 @@
} VkQueryControlFlagBits;
typedef VkFlags VkQueryControlFlags;
-typedef void* (VKAPI *PFN_vkAllocFunction)(
+typedef void* (VKAPI *PFN_vkAllocationFunction)(
void* pUserData,
size_t size,
size_t alignment,
- VkSystemAllocScope allocScope);
+ VkSystemAllocationScope allocationScope);
-typedef void* (VKAPI *PFN_vkReallocFunction)(
+typedef void* (VKAPI *PFN_vkReallocationFunction)(
void* pUserData,
void* pOriginal,
size_t size,
size_t alignment,
- VkSystemAllocScope allocScope);
+ VkSystemAllocationScope allocationScope);
typedef void (VKAPI *PFN_vkFreeFunction)(
void* pUserData,
- void* pMem);
+ void* pMemory);
-typedef void (VKAPI *PFN_vkInternalAllocNotification)(
+typedef void (VKAPI *PFN_vkInternalAllocationNotification)(
void* pUserData,
size_t size,
- VkInternalAllocType allocType,
- VkSystemAllocScope allocScope);
+ VkInternalAllocationType allocationType,
+ VkSystemAllocationScope allocationScope);
typedef void (VKAPI *PFN_vkInternalFreeNotification)(
void* pUserData,
size_t size,
- VkInternalAllocType allocType,
- VkSystemAllocScope allocScope);
+ VkInternalAllocationType allocationType,
+ VkSystemAllocationScope allocationScope);
typedef void (VKAPI *PFN_vkVoidFunction)(void);
typedef struct {
VkStructureType sType;
const void* pNext;
- const char* pAppName;
- uint32_t appVersion;
+ const char* pApplicationName;
+ uint32_t applicationVersion;
const char* pEngineName;
uint32_t engineVersion;
uint32_t apiVersion;
@@ -1094,7 +1094,7 @@
VkStructureType sType;
const void* pNext;
VkInstanceCreateFlags flags;
- const VkApplicationInfo* pAppInfo;
+ const VkApplicationInfo* pApplicationInfo;
uint32_t enabledLayerNameCount;
const char*const* ppEnabledLayerNames;
uint32_t enabledExtensionNameCount;
@@ -1103,12 +1103,12 @@
typedef struct {
void* pUserData;
- PFN_vkAllocFunction pfnAlloc;
- PFN_vkReallocFunction pfnRealloc;
+ PFN_vkAllocationFunction pfnAllocation;
+ PFN_vkReallocationFunction pfnReallocation;
PFN_vkFreeFunction pfnFree;
- PFN_vkInternalAllocNotification pfnInternalAlloc;
+ PFN_vkInternalAllocationNotification pfnInternalAllocation;
PFN_vkInternalFreeNotification pfnInternalFree;
-} VkAllocCallbacks;
+} VkAllocationCallbacks;
typedef struct {
VkBool32 robustBufferAccess;
@@ -1118,7 +1118,7 @@
VkBool32 geometryShader;
VkBool32 tessellationShader;
VkBool32 sampleRateShading;
- VkBool32 dualSourceBlend;
+ VkBool32 dualSrcBlend;
VkBool32 logicOp;
VkBool32 multiDrawIndirect;
VkBool32 depthClamp;
@@ -1215,7 +1215,7 @@
uint32_t maxVertexInputAttributeOffset;
uint32_t maxVertexInputBindingStride;
uint32_t maxVertexOutputComponents;
- uint32_t maxTessellationGenLevel;
+ uint32_t maxTessellationGenerationLevel;
uint32_t maxTessellationPatchSize;
uint32_t maxTessellationControlPerVertexInputComponents;
uint32_t maxTessellationControlPerVertexOutputComponents;
@@ -1230,7 +1230,7 @@
uint32_t maxGeometryTotalOutputComponents;
uint32_t maxFragmentInputComponents;
uint32_t maxFragmentOutputAttachments;
- uint32_t maxFragmentDualSourceAttachments;
+ uint32_t maxFragmentDualSrcAttachments;
uint32_t maxFragmentCombinedOutputResources;
uint32_t maxComputeSharedMemorySize;
uint32_t maxComputeWorkGroupCount[3];
@@ -1352,14 +1352,14 @@
} VkDeviceCreateInfo;
typedef struct {
- char extName[VK_MAX_EXTENSION_NAME];
+ char extensionName[VK_MAX_EXTENSION_NAME];
uint32_t specVersion;
} VkExtensionProperties;
typedef struct {
char layerName[VK_MAX_EXTENSION_NAME];
uint32_t specVersion;
- uint32_t implVersion;
+ uint32_t implementationVersion;
char description[VK_MAX_DESCRIPTION];
} VkLayerProperties;
@@ -1369,7 +1369,7 @@
uint32_t waitSemaphoreCount;
const VkSemaphore* pWaitSemaphores;
uint32_t commandBufferCount;
- const VkCmdBuffer* pCommandBuffers;
+ const VkCommandBuffer* pCommandBuffers;
uint32_t signalSemaphoreCount;
const VkSemaphore* pSignalSemaphores;
} VkSubmitInfo;
@@ -1379,12 +1379,12 @@
const void* pNext;
VkDeviceSize allocationSize;
uint32_t memoryTypeIndex;
-} VkMemoryAllocInfo;
+} VkMemoryAllocateInfo;
typedef struct {
VkStructureType sType;
const void* pNext;
- VkDeviceMemory mem;
+ VkDeviceMemory memory;
VkDeviceSize offset;
VkDeviceSize size;
} VkMappedMemoryRange;
@@ -1412,8 +1412,8 @@
typedef struct {
VkDeviceSize resourceOffset;
VkDeviceSize size;
- VkDeviceMemory mem;
- VkDeviceSize memOffset;
+ VkDeviceMemory memory;
+ VkDeviceSize memoryOffset;
VkSparseMemoryBindFlags flags;
} VkSparseMemoryBind;
@@ -1445,8 +1445,8 @@
VkImageSubresource subresource;
VkOffset3D offset;
VkExtent3D extent;
- VkDeviceMemory mem;
- VkDeviceSize memOffset;
+ VkDeviceMemory memory;
+ VkDeviceSize memoryOffset;
VkSparseMemoryBindFlags flags;
} VkSparseImageMemoryBind;
@@ -1554,9 +1554,9 @@
typedef struct {
VkImageAspectFlags aspectMask;
uint32_t baseMipLevel;
- uint32_t numLevels;
+ uint32_t levelCount;
uint32_t baseArrayLayer;
- uint32_t numLayers;
+ uint32_t layerCount;
} VkImageSubresourceRange;
typedef struct {
@@ -1593,7 +1593,6 @@
VkPipelineCacheCreateFlags flags;
size_t initialDataSize;
const void* pInitialData;
- size_t maxSize;
} VkPipelineCacheCreateInfo;
typedef struct {
@@ -1692,7 +1691,7 @@
typedef struct {
VkStructureType sType;
const void* pNext;
- VkPipelineRasterStateCreateFlags flags;
+ VkPipelineRasterizationStateCreateFlags flags;
VkBool32 depthClampEnable;
VkBool32 rasterizerDiscardEnable;
VkFillMode fillMode;
@@ -1703,13 +1702,13 @@
float depthBiasClamp;
float depthBiasSlopeFactor;
float lineWidth;
-} VkPipelineRasterStateCreateInfo;
+} VkPipelineRasterizationStateCreateInfo;
typedef struct {
VkStructureType sType;
const void* pNext;
VkPipelineMultisampleStateCreateFlags flags;
- uint32_t rasterSamples;
+ uint32_t rasterizationSamples;
VkBool32 sampleShadingEnable;
float minSampleShading;
const VkSampleMask* pSampleMask;
@@ -1745,10 +1744,10 @@
typedef struct {
VkBool32 blendEnable;
VkBlend srcBlendColor;
- VkBlend destBlendColor;
+ VkBlend dstBlendColor;
VkBlendOp blendOpColor;
VkBlend srcBlendAlpha;
- VkBlend destBlendAlpha;
+ VkBlend dstBlendAlpha;
VkBlendOp blendOpAlpha;
VkChannelFlags channelWriteMask;
} VkPipelineColorBlendAttachmentState;
@@ -1782,7 +1781,7 @@
const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
const VkPipelineTessellationStateCreateInfo* pTessellationState;
const VkPipelineViewportStateCreateInfo* pViewportState;
- const VkPipelineRasterStateCreateInfo* pRasterState;
+ const VkPipelineRasterizationStateCreateInfo* pRasterizationState;
const VkPipelineMultisampleStateCreateInfo* pMultisampleState;
const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState;
const VkPipelineColorBlendStateCreateInfo* pColorBlendState;
@@ -1875,7 +1874,7 @@
VkDescriptorPool descriptorPool;
uint32_t setLayoutCount;
const VkDescriptorSetLayout* pSetLayouts;
-} VkDescriptorSetAllocInfo;
+} VkDescriptorSetAllocateInfo;
typedef struct {
VkSampler sampler;
@@ -1892,9 +1891,9 @@
typedef struct {
VkStructureType sType;
const void* pNext;
- VkDescriptorSet destSet;
- uint32_t destBinding;
- uint32_t destArrayElement;
+ VkDescriptorSet dstSet;
+ uint32_t dstBinding;
+ uint32_t dstArrayElement;
uint32_t descriptorCount;
VkDescriptorType descriptorType;
const VkDescriptorImageInfo* pImageInfo;
@@ -1908,9 +1907,9 @@
VkDescriptorSet srcSet;
uint32_t srcBinding;
uint32_t srcArrayElement;
- VkDescriptorSet destSet;
- uint32_t destBinding;
- uint32_t destArrayElement;
+ VkDescriptorSet dstSet;
+ uint32_t dstBinding;
+ uint32_t dstArrayElement;
uint32_t descriptorCount;
} VkCopyDescriptorSet;
@@ -1958,9 +1957,9 @@
typedef struct {
uint32_t srcSubpass;
- uint32_t destSubpass;
+ uint32_t dstSubpass;
VkPipelineStageFlags srcStageMask;
- VkPipelineStageFlags destStageMask;
+ VkPipelineStageFlags dstStageMask;
VkMemoryOutputFlags outputMask;
VkMemoryInputFlags inputMask;
VkDependencyFlags dependencyFlags;
@@ -1981,30 +1980,30 @@
typedef struct {
VkStructureType sType;
const void* pNext;
- VkCmdPoolCreateFlags flags;
+ VkCommandPoolCreateFlags flags;
uint32_t queueFamilyIndex;
-} VkCmdPoolCreateInfo;
+} VkCommandPoolCreateInfo;
typedef struct {
VkStructureType sType;
const void* pNext;
- VkCmdPool cmdPool;
- VkCmdBufferLevel level;
+ VkCommandPool commandPool;
+ VkCommandBufferLevel level;
uint32_t bufferCount;
-} VkCmdBufferAllocInfo;
+} VkCommandBufferAllocateInfo;
typedef struct {
VkStructureType sType;
const void* pNext;
- VkCmdBufferUsageFlags flags;
+ VkCommandBufferUsageFlags flags;
VkRenderPass renderPass;
uint32_t subpass;
VkFramebuffer framebuffer;
-} VkCmdBufferBeginInfo;
+} VkCommandBufferBeginInfo;
typedef struct {
VkDeviceSize srcOffset;
- VkDeviceSize destOffset;
+ VkDeviceSize dstOffset;
VkDeviceSize size;
} VkBufferCopy;
@@ -2012,14 +2011,14 @@
VkImageAspectFlags aspect;
uint32_t mipLevel;
uint32_t baseArrayLayer;
- uint32_t numLayers;
+ uint32_t layerCount;
} VkImageSubresourceCopy;
typedef struct {
VkImageSubresourceCopy srcSubresource;
VkOffset3D srcOffset;
- VkImageSubresourceCopy destSubresource;
- VkOffset3D destOffset;
+ VkImageSubresourceCopy dstSubresource;
+ VkOffset3D dstOffset;
VkExtent3D extent;
} VkImageCopy;
@@ -2027,9 +2026,9 @@
VkImageSubresourceCopy srcSubresource;
VkOffset3D srcOffset;
VkExtent3D srcExtent;
- VkImageSubresourceCopy destSubresource;
- VkOffset3D destOffset;
- VkExtent3D destExtent;
+ VkImageSubresourceCopy dstSubresource;
+ VkOffset3D dstOffset;
+ VkExtent3D dstExtent;
} VkImageBlit;
typedef struct {
@@ -2066,14 +2065,14 @@
typedef struct {
VkRect2D rect;
uint32_t baseArrayLayer;
- uint32_t numLayers;
+ uint32_t layerCount;
} VkClearRect;
typedef struct {
VkImageSubresourceCopy srcSubresource;
VkOffset3D srcOffset;
- VkImageSubresourceCopy destSubresource;
- VkOffset3D destOffset;
+ VkImageSubresourceCopy dstSubresource;
+ VkOffset3D dstOffset;
VkExtent3D extent;
} VkImageResolve;
@@ -2093,7 +2092,7 @@
VkMemoryOutputFlags outputMask;
VkMemoryInputFlags inputMask;
uint32_t srcQueueFamilyIndex;
- uint32_t destQueueFamilyIndex;
+ uint32_t dstQueueFamilyIndex;
VkBuffer buffer;
VkDeviceSize offset;
VkDeviceSize size;
@@ -2103,7 +2102,7 @@
uint32_t x;
uint32_t y;
uint32_t z;
-} VkDispatchIndirectCmd;
+} VkDispatchIndirectCommand;
typedef struct {
uint32_t indexCount;
@@ -2111,14 +2110,14 @@
uint32_t firstIndex;
int32_t vertexOffset;
uint32_t firstInstance;
-} VkDrawIndexedIndirectCmd;
+} VkDrawIndexedIndirectCommand;
typedef struct {
uint32_t vertexCount;
uint32_t instanceCount;
uint32_t firstVertex;
uint32_t firstInstance;
-} VkDrawIndirectCmd;
+} VkDrawIndirectCommand;
typedef struct {
VkStructureType sType;
@@ -2128,7 +2127,7 @@
VkImageLayout oldLayout;
VkImageLayout newLayout;
uint32_t srcQueueFamilyIndex;
- uint32_t destQueueFamilyIndex;
+ uint32_t dstQueueFamilyIndex;
VkImage image;
VkImageSubresourceRange subresourceRange;
} VkImageMemoryBarrier;
@@ -2141,8 +2140,8 @@
} VkMemoryBarrier;
-typedef VkResult (VKAPI *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkInstance* pInstance);
-typedef void (VKAPI *PFN_vkDestroyInstance)(VkInstance instance, const VkAllocCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance);
+typedef void (VKAPI *PFN_vkDestroyInstance)(VkInstance instance, const VkAllocationCallbacks* pAllocator);
typedef VkResult (VKAPI *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
typedef void (VKAPI *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
typedef void (VKAPI *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
@@ -2152,8 +2151,8 @@
typedef void (VKAPI *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName);
typedef PFN_vkVoidFunction (VKAPI *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName);
-typedef VkResult (VKAPI *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDevice* pDevice);
-typedef void (VKAPI *PFN_vkDestroyDevice)(VkDevice device, const VkAllocCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice);
+typedef void (VKAPI *PFN_vkDestroyDevice)(VkDevice device, const VkAllocationCallbacks* pAllocator);
typedef VkResult (VKAPI *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
typedef VkResult (VKAPI *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
typedef VkResult (VKAPI *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pPropertyCount, VkLayerProperties* pProperties);
@@ -2162,134 +2161,134 @@
typedef VkResult (VKAPI *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence);
typedef VkResult (VKAPI *PFN_vkQueueWaitIdle)(VkQueue queue);
typedef VkResult (VKAPI *PFN_vkDeviceWaitIdle)(VkDevice device);
-typedef VkResult (VKAPI *PFN_vkAllocMemory)(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, const VkAllocCallbacks* pAllocator, VkDeviceMemory* pMem);
-typedef void (VKAPI *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory mem, const VkAllocCallbacks* pAllocator);
-typedef VkResult (VKAPI *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData);
-typedef void (VKAPI *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory mem);
-typedef VkResult (VKAPI *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges);
-typedef VkResult (VKAPI *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges);
+typedef VkResult (VKAPI *PFN_vkAllocateMemory)(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory);
+typedef void (VKAPI *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData);
+typedef void (VKAPI *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory memory);
+typedef VkResult (VKAPI *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);
+typedef VkResult (VKAPI *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);
typedef void (VKAPI *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes);
-typedef VkResult (VKAPI *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memOffset);
-typedef VkResult (VKAPI *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memOffset);
+typedef VkResult (VKAPI *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset);
+typedef VkResult (VKAPI *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset);
typedef void (VKAPI *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
typedef void (VKAPI *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
typedef void (VKAPI *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
typedef void (VKAPI *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties);
typedef VkResult (VKAPI *PFN_vkQueueBindSparse)(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence);
-typedef VkResult (VKAPI *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkFence* pFence);
-typedef void (VKAPI *PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);
+typedef void (VKAPI *PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator);
typedef VkResult (VKAPI *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences);
typedef VkResult (VKAPI *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence);
typedef VkResult (VKAPI *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout);
-typedef VkResult (VKAPI *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkSemaphore* pSemaphore);
-typedef void (VKAPI *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocCallbacks* pAllocator);
-typedef VkResult (VKAPI *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkEvent* pEvent);
-typedef void (VKAPI *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore);
+typedef void (VKAPI *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent);
+typedef void (VKAPI *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator);
typedef VkResult (VKAPI *PFN_vkGetEventStatus)(VkDevice device, VkEvent event);
typedef VkResult (VKAPI *PFN_vkSetEvent)(VkDevice device, VkEvent event);
typedef VkResult (VKAPI *PFN_vkResetEvent)(VkDevice device, VkEvent event);
-typedef VkResult (VKAPI *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkQueryPool* pQueryPool);
-typedef void (VKAPI *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool);
+typedef void (VKAPI *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator);
typedef VkResult (VKAPI *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags);
-typedef VkResult (VKAPI *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkBuffer* pBuffer);
-typedef void (VKAPI *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocCallbacks* pAllocator);
-typedef VkResult (VKAPI *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkBufferView* pView);
-typedef void (VKAPI *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocCallbacks* pAllocator);
-typedef VkResult (VKAPI *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkImage* pImage);
-typedef void (VKAPI *PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer);
+typedef void (VKAPI *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView);
+typedef void (VKAPI *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage);
+typedef void (VKAPI *PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator);
typedef void (VKAPI *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
-typedef VkResult (VKAPI *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkImageView* pView);
-typedef void (VKAPI *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocCallbacks* pAllocator);
-typedef VkResult (VKAPI *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkShaderModule* pShaderModule);
-typedef void (VKAPI *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocCallbacks* pAllocator);
-typedef VkResult (VKAPI *PFN_vkCreateShader)(VkDevice device, const VkShaderCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkShader* pShader);
-typedef void (VKAPI *PFN_vkDestroyShader)(VkDevice device, VkShader shader, const VkAllocCallbacks* pAllocator);
-typedef VkResult (VKAPI *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkPipelineCache* pPipelineCache);
-typedef void (VKAPI *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView);
+typedef void (VKAPI *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule);
+typedef void (VKAPI *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateShader)(VkDevice device, const VkShaderCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShader* pShader);
+typedef void (VKAPI *PFN_vkDestroyShader)(VkDevice device, VkShader shader, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache);
+typedef void (VKAPI *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator);
typedef VkResult (VKAPI *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData);
-typedef VkResult (VKAPI *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache destCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);
-typedef VkResult (VKAPI *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocCallbacks* pAllocator, VkPipeline* pPipelines);
-typedef VkResult (VKAPI *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocCallbacks* pAllocator, VkPipeline* pPipelines);
-typedef void (VKAPI *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocCallbacks* pAllocator);
-typedef VkResult (VKAPI *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout);
-typedef void (VKAPI *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocCallbacks* pAllocator);
-typedef VkResult (VKAPI *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkSampler* pSampler);
-typedef void (VKAPI *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocCallbacks* pAllocator);
-typedef VkResult (VKAPI *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout);
-typedef void (VKAPI *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocCallbacks* pAllocator);
-typedef VkResult (VKAPI *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool);
-typedef void (VKAPI *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);
+typedef VkResult (VKAPI *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
+typedef VkResult (VKAPI *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
+typedef void (VKAPI *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout);
+typedef void (VKAPI *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler);
+typedef void (VKAPI *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout);
+typedef void (VKAPI *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool);
+typedef void (VKAPI *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator);
typedef VkResult (VKAPI *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags);
-typedef VkResult (VKAPI *PFN_vkAllocDescriptorSets)(VkDevice device, const VkDescriptorSetAllocInfo* pAllocInfo, VkDescriptorSet* pDescriptorSets);
+typedef VkResult (VKAPI *PFN_vkAllocateDescriptorSets)(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets);
typedef VkResult (VKAPI *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets);
typedef void (VKAPI *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies);
-typedef VkResult (VKAPI *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkFramebuffer* pFramebuffer);
-typedef void (VKAPI *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocCallbacks* pAllocator);
-typedef VkResult (VKAPI *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkRenderPass* pRenderPass);
-typedef void (VKAPI *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer);
+typedef void (VKAPI *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass);
+typedef void (VKAPI *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator);
typedef void (VKAPI *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
-typedef VkResult (VKAPI *PFN_vkCreateCommandPool)(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkCmdPool* pCmdPool);
-typedef void (VKAPI *PFN_vkDestroyCommandPool)(VkDevice device, VkCmdPool cmdPool, const VkAllocCallbacks* pAllocator);
-typedef VkResult (VKAPI *PFN_vkResetCommandPool)(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags);
-typedef VkResult (VKAPI *PFN_vkAllocCommandBuffers)(VkDevice device, const VkCmdBufferAllocInfo* pAllocInfo, VkCmdBuffer* pCmdBuffers);
-typedef void (VKAPI *PFN_vkFreeCommandBuffers)(VkDevice device, VkCmdPool cmdPool, uint32_t commandBufferCount, const VkCmdBuffer* pCommandBuffers);
-typedef VkResult (VKAPI *PFN_vkBeginCommandBuffer)(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo);
-typedef VkResult (VKAPI *PFN_vkEndCommandBuffer)(VkCmdBuffer cmdBuffer);
-typedef VkResult (VKAPI *PFN_vkResetCommandBuffer)(VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags);
-typedef void (VKAPI *PFN_vkCmdBindPipeline)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
-typedef void (VKAPI *PFN_vkCmdSetViewport)(VkCmdBuffer cmdBuffer, uint32_t viewportCount, const VkViewport* pViewports);
-typedef void (VKAPI *PFN_vkCmdSetScissor)(VkCmdBuffer cmdBuffer, uint32_t scissorCount, const VkRect2D* pScissors);
-typedef void (VKAPI *PFN_vkCmdSetLineWidth)(VkCmdBuffer cmdBuffer, float lineWidth);
-typedef void (VKAPI *PFN_vkCmdSetDepthBias)(VkCmdBuffer cmdBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor);
-typedef void (VKAPI *PFN_vkCmdSetBlendConstants)(VkCmdBuffer cmdBuffer, const float blendConstants[4]);
-typedef void (VKAPI *PFN_vkCmdSetDepthBounds)(VkCmdBuffer cmdBuffer, float minDepthBounds, float maxDepthBounds);
-typedef void (VKAPI *PFN_vkCmdSetStencilCompareMask)(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask);
-typedef void (VKAPI *PFN_vkCmdSetStencilWriteMask)(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask);
-typedef void (VKAPI *PFN_vkCmdSetStencilReference)(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference);
-typedef void (VKAPI *PFN_vkCmdBindDescriptorSets)(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets);
-typedef void (VKAPI *PFN_vkCmdBindIndexBuffer)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
-typedef void (VKAPI *PFN_vkCmdBindVertexBuffers)(VkCmdBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
-typedef void (VKAPI *PFN_vkCmdDraw)(VkCmdBuffer cmdBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);
-typedef void (VKAPI *PFN_vkCmdDrawIndexed)(VkCmdBuffer cmdBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);
-typedef void (VKAPI *PFN_vkCmdDrawIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
-typedef void (VKAPI *PFN_vkCmdDrawIndexedIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
-typedef void (VKAPI *PFN_vkCmdDispatch)(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z);
-typedef void (VKAPI *PFN_vkCmdDispatchIndirect)(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset);
-typedef void (VKAPI *PFN_vkCmdCopyBuffer)(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions);
-typedef void (VKAPI *PFN_vkCmdCopyImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions);
-typedef void (VKAPI *PFN_vkCmdBlitImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter);
-typedef void (VKAPI *PFN_vkCmdCopyBufferToImage)(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions);
-typedef void (VKAPI *PFN_vkCmdCopyImageToBuffer)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions);
-typedef void (VKAPI *PFN_vkCmdUpdateBuffer)(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData);
-typedef void (VKAPI *PFN_vkCmdFillBuffer)(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize size, uint32_t data);
-typedef void (VKAPI *PFN_vkCmdClearColorImage)(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
-typedef void (VKAPI *PFN_vkCmdClearDepthStencilImage)(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
-typedef void (VKAPI *PFN_vkCmdClearAttachments)(VkCmdBuffer cmdBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects);
-typedef void (VKAPI *PFN_vkCmdResolveImage)(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions);
-typedef void (VKAPI *PFN_vkCmdSetEvent)(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask);
-typedef void (VKAPI *PFN_vkCmdResetEvent)(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask);
-typedef void (VKAPI *PFN_vkCmdWaitEvents)(VkCmdBuffer cmdBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, uint32_t memBarrierCount, const void* const* ppMemBarriers);
-typedef void (VKAPI *PFN_vkCmdPipelineBarrier)(VkCmdBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkDependencyFlags dependencyFlags, uint32_t memBarrierCount, const void* const* ppMemBarriers);
-typedef void (VKAPI *PFN_vkCmdBeginQuery)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags);
-typedef void (VKAPI *PFN_vkCmdEndQuery)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot);
-typedef void (VKAPI *PFN_vkCmdResetQueryPool)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount);
-typedef void (VKAPI *PFN_vkCmdWriteTimestamp)(VkCmdBuffer cmdBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot);
-typedef void (VKAPI *PFN_vkCmdCopyQueryPoolResults)(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize stride, VkQueryResultFlags flags);
-typedef void (VKAPI *PFN_vkCmdPushConstants)(VkCmdBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* values);
-typedef void (VKAPI *PFN_vkCmdBeginRenderPass)(VkCmdBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents);
-typedef void (VKAPI *PFN_vkCmdNextSubpass)(VkCmdBuffer cmdBuffer, VkRenderPassContents contents);
-typedef void (VKAPI *PFN_vkCmdEndRenderPass)(VkCmdBuffer cmdBuffer);
-typedef void (VKAPI *PFN_vkCmdExecuteCommands)(VkCmdBuffer cmdBuffer, uint32_t cmdBuffersCount, const VkCmdBuffer* pCmdBuffers);
+typedef VkResult (VKAPI *PFN_vkCreateCommandPool)(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool);
+typedef void (VKAPI *PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPool CommandPool, const VkAllocationCallbacks* pAllocator);
+typedef VkResult (VKAPI *PFN_vkResetCommandPool)(VkDevice device, VkCommandPool CommandPool, VkCommandPoolResetFlags flags);
+typedef VkResult (VKAPI *PFN_vkAllocateCommandBuffers)(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers);
+typedef void (VKAPI *PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool CommandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);
+typedef VkResult (VKAPI *PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo);
+typedef VkResult (VKAPI *PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer);
+typedef VkResult (VKAPI *PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags);
+typedef void (VKAPI *PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
+typedef void (VKAPI *PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports);
+typedef void (VKAPI *PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors);
+typedef void (VKAPI *PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, float lineWidth);
+typedef void (VKAPI *PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor);
+typedef void (VKAPI *PFN_vkCmdSetBlendConstants)(VkCommandBuffer commandBuffer, const float blendConstants[4]);
+typedef void (VKAPI *PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds);
+typedef void (VKAPI *PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask);
+typedef void (VKAPI *PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask);
+typedef void (VKAPI *PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference);
+typedef void (VKAPI *PFN_vkCmdBindDescriptorSets)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets);
+typedef void (VKAPI *PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
+typedef void (VKAPI *PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
+typedef void (VKAPI *PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);
+typedef void (VKAPI *PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);
+typedef void (VKAPI *PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
+typedef void (VKAPI *PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
+typedef void (VKAPI *PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z);
+typedef void (VKAPI *PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset);
+typedef void (VKAPI *PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions);
+typedef void (VKAPI *PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions);
+typedef void (VKAPI *PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter);
+typedef void (VKAPI *PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions);
+typedef void (VKAPI *PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions);
+typedef void (VKAPI *PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const uint32_t* pData);
+typedef void (VKAPI *PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data);
+typedef void (VKAPI *PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
+typedef void (VKAPI *PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
+typedef void (VKAPI *PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects);
+typedef void (VKAPI *PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions);
+typedef void (VKAPI *PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
+typedef void (VKAPI *PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
+typedef void (VKAPI *PFN_vkCmdWaitEvents)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const void* const* ppMemoryBarriers);
+typedef void (VKAPI *PFN_vkCmdPipelineBarrier)(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const void* const* ppMemoryBarriers);
+typedef void (VKAPI *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags);
+typedef void (VKAPI *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot);
+typedef void (VKAPI *PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount);
+typedef void (VKAPI *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot);
+typedef void (VKAPI *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags);
+typedef void (VKAPI *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* values);
+typedef void (VKAPI *PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents);
+typedef void (VKAPI *PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkRenderPassContents contents);
+typedef void (VKAPI *PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer);
+typedef void (VKAPI *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBuffersCount, const VkCommandBuffer* pCommandBuffers);
#ifdef VK_PROTOTYPES
VkResult VKAPI vkCreateInstance(
const VkInstanceCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkInstance* pInstance);
void VKAPI vkDestroyInstance(
VkInstance instance,
- const VkAllocCallbacks* pAllocator);
+ const VkAllocationCallbacks* pAllocator);
VkResult VKAPI vkEnumeratePhysicalDevices(
VkInstance instance,
@@ -2338,12 +2337,12 @@
VkResult VKAPI vkCreateDevice(
VkPhysicalDevice physicalDevice,
const VkDeviceCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkDevice* pDevice);
void VKAPI vkDestroyDevice(
VkDevice device,
- const VkAllocCallbacks* pAllocator);
+ const VkAllocationCallbacks* pAllocator);
VkResult VKAPI vkEnumerateInstanceExtensionProperties(
const char* pLayerName,
@@ -2383,20 +2382,20 @@
VkResult VKAPI vkDeviceWaitIdle(
VkDevice device);
-VkResult VKAPI vkAllocMemory(
+VkResult VKAPI vkAllocateMemory(
VkDevice device,
- const VkMemoryAllocInfo* pAllocInfo,
- const VkAllocCallbacks* pAllocator,
- VkDeviceMemory* pMem);
+ const VkMemoryAllocateInfo* pAllocateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkDeviceMemory* pMemory);
void VKAPI vkFreeMemory(
VkDevice device,
- VkDeviceMemory mem,
- const VkAllocCallbacks* pAllocator);
+ VkDeviceMemory memory,
+ const VkAllocationCallbacks* pAllocator);
VkResult VKAPI vkMapMemory(
VkDevice device,
- VkDeviceMemory mem,
+ VkDeviceMemory memory,
VkDeviceSize offset,
VkDeviceSize size,
VkMemoryMapFlags flags,
@@ -2404,17 +2403,17 @@
void VKAPI vkUnmapMemory(
VkDevice device,
- VkDeviceMemory mem);
+ VkDeviceMemory memory);
VkResult VKAPI vkFlushMappedMemoryRanges(
VkDevice device,
- uint32_t memRangeCount,
- const VkMappedMemoryRange* pMemRanges);
+ uint32_t memoryRangeCount,
+ const VkMappedMemoryRange* pMemoryRanges);
VkResult VKAPI vkInvalidateMappedMemoryRanges(
VkDevice device,
- uint32_t memRangeCount,
- const VkMappedMemoryRange* pMemRanges);
+ uint32_t memoryRangeCount,
+ const VkMappedMemoryRange* pMemoryRanges);
void VKAPI vkGetDeviceMemoryCommitment(
VkDevice device,
@@ -2424,14 +2423,14 @@
VkResult VKAPI vkBindBufferMemory(
VkDevice device,
VkBuffer buffer,
- VkDeviceMemory mem,
- VkDeviceSize memOffset);
+ VkDeviceMemory memory,
+ VkDeviceSize memoryOffset);
VkResult VKAPI vkBindImageMemory(
VkDevice device,
VkImage image,
- VkDeviceMemory mem,
- VkDeviceSize memOffset);
+ VkDeviceMemory memory,
+ VkDeviceSize memoryOffset);
void VKAPI vkGetBufferMemoryRequirements(
VkDevice device,
@@ -2468,13 +2467,13 @@
VkResult VKAPI vkCreateFence(
VkDevice device,
const VkFenceCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkFence* pFence);
void VKAPI vkDestroyFence(
VkDevice device,
VkFence fence,
- const VkAllocCallbacks* pAllocator);
+ const VkAllocationCallbacks* pAllocator);
VkResult VKAPI vkResetFences(
VkDevice device,
@@ -2495,24 +2494,24 @@
VkResult VKAPI vkCreateSemaphore(
VkDevice device,
const VkSemaphoreCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkSemaphore* pSemaphore);
void VKAPI vkDestroySemaphore(
VkDevice device,
VkSemaphore semaphore,
- const VkAllocCallbacks* pAllocator);
+ const VkAllocationCallbacks* pAllocator);
VkResult VKAPI vkCreateEvent(
VkDevice device,
const VkEventCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkEvent* pEvent);
void VKAPI vkDestroyEvent(
VkDevice device,
VkEvent event,
- const VkAllocCallbacks* pAllocator);
+ const VkAllocationCallbacks* pAllocator);
VkResult VKAPI vkGetEventStatus(
VkDevice device,
@@ -2529,13 +2528,13 @@
VkResult VKAPI vkCreateQueryPool(
VkDevice device,
const VkQueryPoolCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkQueryPool* pQueryPool);
void VKAPI vkDestroyQueryPool(
VkDevice device,
VkQueryPool queryPool,
- const VkAllocCallbacks* pAllocator);
+ const VkAllocationCallbacks* pAllocator);
VkResult VKAPI vkGetQueryPoolResults(
VkDevice device,
@@ -2550,35 +2549,35 @@
VkResult VKAPI vkCreateBuffer(
VkDevice device,
const VkBufferCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkBuffer* pBuffer);
void VKAPI vkDestroyBuffer(
VkDevice device,
VkBuffer buffer,
- const VkAllocCallbacks* pAllocator);
+ const VkAllocationCallbacks* pAllocator);
VkResult VKAPI vkCreateBufferView(
VkDevice device,
const VkBufferViewCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkBufferView* pView);
void VKAPI vkDestroyBufferView(
VkDevice device,
VkBufferView bufferView,
- const VkAllocCallbacks* pAllocator);
+ const VkAllocationCallbacks* pAllocator);
VkResult VKAPI vkCreateImage(
VkDevice device,
const VkImageCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkImage* pImage);
void VKAPI vkDestroyImage(
VkDevice device,
VkImage image,
- const VkAllocCallbacks* pAllocator);
+ const VkAllocationCallbacks* pAllocator);
void VKAPI vkGetImageSubresourceLayout(
VkDevice device,
@@ -2589,46 +2588,46 @@
VkResult VKAPI vkCreateImageView(
VkDevice device,
const VkImageViewCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkImageView* pView);
void VKAPI vkDestroyImageView(
VkDevice device,
VkImageView imageView,
- const VkAllocCallbacks* pAllocator);
+ const VkAllocationCallbacks* pAllocator);
VkResult VKAPI vkCreateShaderModule(
VkDevice device,
const VkShaderModuleCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkShaderModule* pShaderModule);
void VKAPI vkDestroyShaderModule(
VkDevice device,
VkShaderModule shaderModule,
- const VkAllocCallbacks* pAllocator);
+ const VkAllocationCallbacks* pAllocator);
VkResult VKAPI vkCreateShader(
VkDevice device,
const VkShaderCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkShader* pShader);
void VKAPI vkDestroyShader(
VkDevice device,
VkShader shader,
- const VkAllocCallbacks* pAllocator);
+ const VkAllocationCallbacks* pAllocator);
VkResult VKAPI vkCreatePipelineCache(
VkDevice device,
const VkPipelineCacheCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkPipelineCache* pPipelineCache);
void VKAPI vkDestroyPipelineCache(
VkDevice device,
VkPipelineCache pipelineCache,
- const VkAllocCallbacks* pAllocator);
+ const VkAllocationCallbacks* pAllocator);
VkResult VKAPI vkGetPipelineCacheData(
VkDevice device,
@@ -2638,7 +2637,7 @@
VkResult VKAPI vkMergePipelineCaches(
VkDevice device,
- VkPipelineCache destCache,
+ VkPipelineCache dstCache,
uint32_t srcCacheCount,
const VkPipelineCache* pSrcCaches);
@@ -2647,7 +2646,7 @@
VkPipelineCache pipelineCache,
uint32_t createInfoCount,
const VkGraphicsPipelineCreateInfo* pCreateInfos,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkPipeline* pPipelines);
VkResult VKAPI vkCreateComputePipelines(
@@ -2655,66 +2654,66 @@
VkPipelineCache pipelineCache,
uint32_t createInfoCount,
const VkComputePipelineCreateInfo* pCreateInfos,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkPipeline* pPipelines);
void VKAPI vkDestroyPipeline(
VkDevice device,
VkPipeline pipeline,
- const VkAllocCallbacks* pAllocator);
+ const VkAllocationCallbacks* pAllocator);
VkResult VKAPI vkCreatePipelineLayout(
VkDevice device,
const VkPipelineLayoutCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkPipelineLayout* pPipelineLayout);
void VKAPI vkDestroyPipelineLayout(
VkDevice device,
VkPipelineLayout pipelineLayout,
- const VkAllocCallbacks* pAllocator);
+ const VkAllocationCallbacks* pAllocator);
VkResult VKAPI vkCreateSampler(
VkDevice device,
const VkSamplerCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkSampler* pSampler);
void VKAPI vkDestroySampler(
VkDevice device,
VkSampler sampler,
- const VkAllocCallbacks* pAllocator);
+ const VkAllocationCallbacks* pAllocator);
VkResult VKAPI vkCreateDescriptorSetLayout(
VkDevice device,
const VkDescriptorSetLayoutCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkDescriptorSetLayout* pSetLayout);
void VKAPI vkDestroyDescriptorSetLayout(
VkDevice device,
VkDescriptorSetLayout descriptorSetLayout,
- const VkAllocCallbacks* pAllocator);
+ const VkAllocationCallbacks* pAllocator);
VkResult VKAPI vkCreateDescriptorPool(
VkDevice device,
const VkDescriptorPoolCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkDescriptorPool* pDescriptorPool);
void VKAPI vkDestroyDescriptorPool(
VkDevice device,
VkDescriptorPool descriptorPool,
- const VkAllocCallbacks* pAllocator);
+ const VkAllocationCallbacks* pAllocator);
VkResult VKAPI vkResetDescriptorPool(
VkDevice device,
VkDescriptorPool descriptorPool,
VkDescriptorPoolResetFlags flags);
-VkResult VKAPI vkAllocDescriptorSets(
+VkResult VKAPI vkAllocateDescriptorSets(
VkDevice device,
- const VkDescriptorSetAllocInfo* pAllocInfo,
+ const VkDescriptorSetAllocateInfo* pAllocateInfo,
VkDescriptorSet* pDescriptorSets);
VkResult VKAPI vkFreeDescriptorSets(
@@ -2733,24 +2732,24 @@
VkResult VKAPI vkCreateFramebuffer(
VkDevice device,
const VkFramebufferCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkFramebuffer* pFramebuffer);
void VKAPI vkDestroyFramebuffer(
VkDevice device,
VkFramebuffer framebuffer,
- const VkAllocCallbacks* pAllocator);
+ const VkAllocationCallbacks* pAllocator);
VkResult VKAPI vkCreateRenderPass(
VkDevice device,
const VkRenderPassCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkRenderPass* pRenderPass);
void VKAPI vkDestroyRenderPass(
VkDevice device,
VkRenderPass renderPass,
- const VkAllocCallbacks* pAllocator);
+ const VkAllocationCallbacks* pAllocator);
void VKAPI vkGetRenderAreaGranularity(
VkDevice device,
@@ -2759,93 +2758,93 @@
VkResult VKAPI vkCreateCommandPool(
VkDevice device,
- const VkCmdPoolCreateInfo* pCreateInfo,
- const VkAllocCallbacks* pAllocator,
- VkCmdPool* pCmdPool);
+ const VkCommandPoolCreateInfo* pCreateInfo,
+ const VkAllocationCallbacks* pAllocator,
+ VkCommandPool* pCommandPool);
void VKAPI vkDestroyCommandPool(
VkDevice device,
- VkCmdPool cmdPool,
- const VkAllocCallbacks* pAllocator);
+ VkCommandPool CommandPool,
+ const VkAllocationCallbacks* pAllocator);
VkResult VKAPI vkResetCommandPool(
VkDevice device,
- VkCmdPool cmdPool,
- VkCmdPoolResetFlags flags);
+ VkCommandPool CommandPool,
+ VkCommandPoolResetFlags flags);
-VkResult VKAPI vkAllocCommandBuffers(
+VkResult VKAPI vkAllocateCommandBuffers(
VkDevice device,
- const VkCmdBufferAllocInfo* pAllocInfo,
- VkCmdBuffer* pCmdBuffers);
+ const VkCommandBufferAllocateInfo* pAllocateInfo,
+ VkCommandBuffer* pCommandBuffers);
void VKAPI vkFreeCommandBuffers(
VkDevice device,
- VkCmdPool cmdPool,
+ VkCommandPool CommandPool,
uint32_t commandBufferCount,
- const VkCmdBuffer* pCommandBuffers);
+ const VkCommandBuffer* pCommandBuffers);
VkResult VKAPI vkBeginCommandBuffer(
- VkCmdBuffer cmdBuffer,
- const VkCmdBufferBeginInfo* pBeginInfo);
+ VkCommandBuffer commandBuffer,
+ const VkCommandBufferBeginInfo* pBeginInfo);
VkResult VKAPI vkEndCommandBuffer(
- VkCmdBuffer cmdBuffer);
+ VkCommandBuffer commandBuffer);
VkResult VKAPI vkResetCommandBuffer(
- VkCmdBuffer cmdBuffer,
- VkCmdBufferResetFlags flags);
+ VkCommandBuffer commandBuffer,
+ VkCommandBufferResetFlags flags);
void VKAPI vkCmdBindPipeline(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkPipelineBindPoint pipelineBindPoint,
VkPipeline pipeline);
void VKAPI vkCmdSetViewport(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
uint32_t viewportCount,
const VkViewport* pViewports);
void VKAPI vkCmdSetScissor(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
uint32_t scissorCount,
const VkRect2D* pScissors);
void VKAPI vkCmdSetLineWidth(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
float lineWidth);
void VKAPI vkCmdSetDepthBias(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
float depthBiasConstantFactor,
float depthBiasClamp,
float depthBiasSlopeFactor);
void VKAPI vkCmdSetBlendConstants(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
const float blendConstants[4]);
void VKAPI vkCmdSetDepthBounds(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
float minDepthBounds,
float maxDepthBounds);
void VKAPI vkCmdSetStencilCompareMask(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkStencilFaceFlags faceMask,
uint32_t stencilCompareMask);
void VKAPI vkCmdSetStencilWriteMask(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkStencilFaceFlags faceMask,
uint32_t stencilWriteMask);
void VKAPI vkCmdSetStencilReference(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkStencilFaceFlags faceMask,
uint32_t stencilReference);
void VKAPI vkCmdBindDescriptorSets(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkPipelineBindPoint pipelineBindPoint,
VkPipelineLayout layout,
uint32_t firstSet,
@@ -2855,27 +2854,27 @@
const uint32_t* pDynamicOffsets);
void VKAPI vkCmdBindIndexBuffer(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
VkIndexType indexType);
void VKAPI vkCmdBindVertexBuffers(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
uint32_t startBinding,
uint32_t bindingCount,
const VkBuffer* pBuffers,
const VkDeviceSize* pOffsets);
void VKAPI vkCmdDraw(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
uint32_t vertexCount,
uint32_t instanceCount,
uint32_t firstVertex,
uint32_t firstInstance);
void VKAPI vkCmdDrawIndexed(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
uint32_t indexCount,
uint32_t instanceCount,
uint32_t firstIndex,
@@ -2883,88 +2882,88 @@
uint32_t firstInstance);
void VKAPI vkCmdDrawIndirect(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
uint32_t drawCount,
uint32_t stride);
void VKAPI vkCmdDrawIndexedIndirect(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset,
uint32_t drawCount,
uint32_t stride);
void VKAPI vkCmdDispatch(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
uint32_t x,
uint32_t y,
uint32_t z);
void VKAPI vkCmdDispatchIndirect(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkBuffer buffer,
VkDeviceSize offset);
void VKAPI vkCmdCopyBuffer(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkBuffer srcBuffer,
- VkBuffer destBuffer,
+ VkBuffer dstBuffer,
uint32_t regionCount,
const VkBufferCopy* pRegions);
void VKAPI vkCmdCopyImage(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
- VkImage destImage,
- VkImageLayout destImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
uint32_t regionCount,
const VkImageCopy* pRegions);
void VKAPI vkCmdBlitImage(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
- VkImage destImage,
- VkImageLayout destImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
uint32_t regionCount,
const VkImageBlit* pRegions,
VkFilter filter);
void VKAPI vkCmdCopyBufferToImage(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkBuffer srcBuffer,
- VkImage destImage,
- VkImageLayout destImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
uint32_t regionCount,
const VkBufferImageCopy* pRegions);
void VKAPI vkCmdCopyImageToBuffer(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
- VkBuffer destBuffer,
+ VkBuffer dstBuffer,
uint32_t regionCount,
const VkBufferImageCopy* pRegions);
void VKAPI vkCmdUpdateBuffer(
- VkCmdBuffer cmdBuffer,
- VkBuffer destBuffer,
- VkDeviceSize destOffset,
+ VkCommandBuffer commandBuffer,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
VkDeviceSize dataSize,
const uint32_t* pData);
void VKAPI vkCmdFillBuffer(
- VkCmdBuffer cmdBuffer,
- VkBuffer destBuffer,
- VkDeviceSize destOffset,
+ VkCommandBuffer commandBuffer,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
VkDeviceSize size,
uint32_t data);
void VKAPI vkCmdClearColorImage(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkImage image,
VkImageLayout imageLayout,
const VkClearColorValue* pColor,
@@ -2972,7 +2971,7 @@
const VkImageSubresourceRange* pRanges);
void VKAPI vkCmdClearDepthStencilImage(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkImage image,
VkImageLayout imageLayout,
const VkClearDepthStencilValue* pDepthStencil,
@@ -2980,83 +2979,83 @@
const VkImageSubresourceRange* pRanges);
void VKAPI vkCmdClearAttachments(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
uint32_t attachmentCount,
const VkClearAttachment* pAttachments,
uint32_t rectCount,
const VkClearRect* pRects);
void VKAPI vkCmdResolveImage(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkImage srcImage,
VkImageLayout srcImageLayout,
- VkImage destImage,
- VkImageLayout destImageLayout,
+ VkImage dstImage,
+ VkImageLayout dstImageLayout,
uint32_t regionCount,
const VkImageResolve* pRegions);
void VKAPI vkCmdSetEvent(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkEvent event,
VkPipelineStageFlags stageMask);
void VKAPI vkCmdResetEvent(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkEvent event,
VkPipelineStageFlags stageMask);
void VKAPI vkCmdWaitEvents(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
uint32_t eventCount,
const VkEvent* pEvents,
VkPipelineStageFlags srcStageMask,
- VkPipelineStageFlags destStageMask,
- uint32_t memBarrierCount,
- const void* const* ppMemBarriers);
+ VkPipelineStageFlags dstStageMask,
+ uint32_t memoryBarrierCount,
+ const void* const* ppMemoryBarriers);
void VKAPI vkCmdPipelineBarrier(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkPipelineStageFlags srcStageMask,
- VkPipelineStageFlags destStageMask,
+ VkPipelineStageFlags dstStageMask,
VkDependencyFlags dependencyFlags,
- uint32_t memBarrierCount,
- const void* const* ppMemBarriers);
+ uint32_t memoryBarrierCount,
+ const void* const* ppMemoryBarriers);
void VKAPI vkCmdBeginQuery(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
uint32_t slot,
VkQueryControlFlags flags);
void VKAPI vkCmdEndQuery(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
uint32_t slot);
void VKAPI vkCmdResetQueryPool(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
uint32_t startQuery,
uint32_t queryCount);
void VKAPI vkCmdWriteTimestamp(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkPipelineStageFlagBits pipelineStage,
VkQueryPool queryPool,
uint32_t slot);
void VKAPI vkCmdCopyQueryPoolResults(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
uint32_t startQuery,
uint32_t queryCount,
- VkBuffer destBuffer,
- VkDeviceSize destOffset,
+ VkBuffer dstBuffer,
+ VkDeviceSize dstOffset,
VkDeviceSize stride,
VkQueryResultFlags flags);
void VKAPI vkCmdPushConstants(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkPipelineLayout layout,
VkShaderStageFlags stageFlags,
uint32_t offset,
@@ -3064,25 +3063,25 @@
const void* values);
void VKAPI vkCmdBeginRenderPass(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
const VkRenderPassBeginInfo* pRenderPassBegin,
VkRenderPassContents contents);
void VKAPI vkCmdNextSubpass(
- VkCmdBuffer cmdBuffer,
+ VkCommandBuffer commandBuffer,
VkRenderPassContents contents);
void VKAPI vkCmdEndRenderPass(
- VkCmdBuffer cmdBuffer);
+ VkCommandBuffer commandBuffer);
void VKAPI vkCmdExecuteCommands(
- VkCmdBuffer cmdBuffer,
- uint32_t cmdBuffersCount,
- const VkCmdBuffer* pCmdBuffers);
+ VkCommandBuffer commandBuffer,
+ uint32_t commandBuffersCount,
+ const VkCommandBuffer* pCommandBuffers);
#endif
#define vk_ext_khr_surface 1
-VK_DEFINE_NONDISP_HANDLE(VkSurfaceKHR)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR)
#define VK_EXT_KHR_SURFACE_REVISION 20
#define VK_EXT_KHR_SURFACE_EXTENSION_NUMBER 1
@@ -3102,7 +3101,7 @@
VK_SURFACE_TRANSFORM_INHERIT_KHR = 8,
VK_SURFACE_TRANSFORM_BEGIN_RANGE = VK_SURFACE_TRANSFORM_NONE_KHR,
VK_SURFACE_TRANSFORM_END_RANGE = VK_SURFACE_TRANSFORM_INHERIT_KHR,
- VK_SURFACE_TRANSFORM_NUM = (VK_SURFACE_TRANSFORM_INHERIT_KHR - VK_SURFACE_TRANSFORM_NONE_KHR + 1),
+ VK_SURFACE_TRANSFORM_RANGE_SIZE = (VK_SURFACE_TRANSFORM_INHERIT_KHR - VK_SURFACE_TRANSFORM_NONE_KHR + 1),
VK_SURFACE_TRANSFORM_MAX_ENUM = 0x7FFFFFFF
} VkSurfaceTransformKHR;
@@ -3110,7 +3109,7 @@
VK_COLORSPACE_SRGB_NONLINEAR_KHR = 0,
VK_COLORSPACE_BEGIN_RANGE = VK_COLORSPACE_SRGB_NONLINEAR_KHR,
VK_COLORSPACE_END_RANGE = VK_COLORSPACE_SRGB_NONLINEAR_KHR,
- VK_COLORSPACE_NUM = (VK_COLORSPACE_SRGB_NONLINEAR_KHR - VK_COLORSPACE_SRGB_NONLINEAR_KHR + 1),
+ VK_COLORSPACE_RANGE_SIZE = (VK_COLORSPACE_SRGB_NONLINEAR_KHR - VK_COLORSPACE_SRGB_NONLINEAR_KHR + 1),
VK_COLORSPACE_MAX_ENUM = 0x7FFFFFFF
} VkColorSpaceKHR;
@@ -3121,7 +3120,7 @@
VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3,
VK_PRESENT_MODE_BEGIN_RANGE = VK_PRESENT_MODE_IMMEDIATE_KHR,
VK_PRESENT_MODE_END_RANGE = VK_PRESENT_MODE_FIFO_RELAXED_KHR,
- VK_PRESENT_MODE_NUM = (VK_PRESENT_MODE_FIFO_RELAXED_KHR - VK_PRESENT_MODE_IMMEDIATE_KHR + 1),
+ VK_PRESENT_MODE_RANGE_SIZE = (VK_PRESENT_MODE_FIFO_RELAXED_KHR - VK_PRESENT_MODE_IMMEDIATE_KHR + 1),
VK_PRESENT_MODE_MAX_ENUM = 0x7FFFFFFF
} VkPresentModeKHR;
@@ -3202,14 +3201,14 @@
#endif
#define vk_ext_khr_swapchain 1
-VK_DEFINE_NONDISP_HANDLE(VkSwapchainKHR)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR)
#define VK_EXT_KHR_SWAPCHAIN_REVISION 62
#define VK_EXT_KHR_SWAPCHAIN_EXTENSION_NUMBER 2
#define VK_EXT_KHR_SWAPCHAIN_EXTENSION_NAME "VK_EXT_KHR_swapchain"
#define VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR ((VkStructureType)(int)0xc0000800)
#define VK_STRUCTURE_TYPE_PRESENT_INFO_KHR ((VkStructureType)(int)0xc0000801)
-#define VK_IMAGE_LAYOUT_PRESENT_SOURCE_KHR ((VkImageLayout)(int)0xc0000802)
+#define VK_IMAGE_LAYOUT_PRESENT_SRC_KHR ((VkImageLayout)(int)0xc0000802)
#define VK_SUBOPTIMAL_KHR ((VkResult)(int)0x40000403)
#define VK_ERROR_OUT_OF_DATE_KHR ((VkResult)(int)0xc0000804)
@@ -3280,8 +3279,8 @@
#endif
#define vk_ext_khr_display 1
-VK_DEFINE_NONDISP_HANDLE(VkDisplayKHR)
-VK_DEFINE_NONDISP_HANDLE(VkDisplayModeKHR)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR)
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR)
#define VK_EXT_KHR_DISPLAY_REVISION 17
#define VK_EXT_KHR_DISPLAY_EXTENSION_NUMBER 3
diff --git a/vulkan/libvulkan/entry.cpp b/vulkan/libvulkan/entry.cpp
index 31f0231..a2b4c0f 100644
--- a/vulkan/libvulkan/entry.cpp
+++ b/vulkan/libvulkan/entry.cpp
@@ -36,18 +36,18 @@
inline const DeviceVtbl& GetVtbl(VkQueue queue) {
return **reinterpret_cast<DeviceVtbl**>(queue);
}
- inline const DeviceVtbl& GetVtbl(VkCmdBuffer cmdBuffer) {
- return **reinterpret_cast<DeviceVtbl**>(cmdBuffer);
+ inline const DeviceVtbl& GetVtbl(VkCommandBuffer commandBuffer) {
+ return **reinterpret_cast<DeviceVtbl**>(commandBuffer);
}
} // namespace
__attribute__((visibility("default")))
-VkResult vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkInstance* pInstance) {
+VkResult vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance) {
return vulkan::CreateInstance(pCreateInfo, pAllocator, pInstance);
}
__attribute__((visibility("default")))
-void vkDestroyInstance(VkInstance instance, const VkAllocCallbacks* pAllocator) {
+void vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator) {
GetVtbl(instance).DestroyInstance(instance, pAllocator);
}
@@ -97,12 +97,12 @@
}
__attribute__((visibility("default")))
-VkResult vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDevice* pDevice) {
+VkResult vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) {
return GetVtbl(physicalDevice).CreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice);
}
__attribute__((visibility("default")))
-void vkDestroyDevice(VkDevice device, const VkAllocCallbacks* pAllocator) {
+void vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) {
vulkan::DestroyDevice(device, pAllocator);
}
@@ -147,33 +147,33 @@
}
__attribute__((visibility("default")))
-VkResult vkAllocMemory(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, const VkAllocCallbacks* pAllocator, VkDeviceMemory* pMem) {
- return GetVtbl(device).AllocMemory(device, pAllocInfo, pAllocator, pMem);
+VkResult vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) {
+ return GetVtbl(device).AllocateMemory(device, pAllocateInfo, pAllocator, pMemory);
}
__attribute__((visibility("default")))
-void vkFreeMemory(VkDevice device, VkDeviceMemory mem, const VkAllocCallbacks* pAllocator) {
- GetVtbl(device).FreeMemory(device, mem, pAllocator);
+void vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) {
+ GetVtbl(device).FreeMemory(device, memory, pAllocator);
}
__attribute__((visibility("default")))
-VkResult vkMapMemory(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) {
- return GetVtbl(device).MapMemory(device, mem, offset, size, flags, ppData);
+VkResult vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) {
+ return GetVtbl(device).MapMemory(device, memory, offset, size, flags, ppData);
}
__attribute__((visibility("default")))
-void vkUnmapMemory(VkDevice device, VkDeviceMemory mem) {
- GetVtbl(device).UnmapMemory(device, mem);
+void vkUnmapMemory(VkDevice device, VkDeviceMemory memory) {
+ GetVtbl(device).UnmapMemory(device, memory);
}
__attribute__((visibility("default")))
-VkResult vkFlushMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges) {
- return GetVtbl(device).FlushMappedMemoryRanges(device, memRangeCount, pMemRanges);
+VkResult vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) {
+ return GetVtbl(device).FlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
}
__attribute__((visibility("default")))
-VkResult vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges) {
- return GetVtbl(device).InvalidateMappedMemoryRanges(device, memRangeCount, pMemRanges);
+VkResult vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) {
+ return GetVtbl(device).InvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
}
__attribute__((visibility("default")))
@@ -187,8 +187,8 @@
}
__attribute__((visibility("default")))
-VkResult vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize memOffset) {
- return GetVtbl(device).BindBufferMemory(device, buffer, mem, memOffset);
+VkResult vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) {
+ return GetVtbl(device).BindBufferMemory(device, buffer, memory, memoryOffset);
}
__attribute__((visibility("default")))
@@ -197,8 +197,8 @@
}
__attribute__((visibility("default")))
-VkResult vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize memOffset) {
- return GetVtbl(device).BindImageMemory(device, image, mem, memOffset);
+VkResult vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) {
+ return GetVtbl(device).BindImageMemory(device, image, memory, memoryOffset);
}
__attribute__((visibility("default")))
@@ -217,12 +217,12 @@
}
__attribute__((visibility("default")))
-VkResult vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkFence* pFence) {
+VkResult vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) {
return GetVtbl(device).CreateFence(device, pCreateInfo, pAllocator, pFence);
}
__attribute__((visibility("default")))
-void vkDestroyFence(VkDevice device, VkFence fence, const VkAllocCallbacks* pAllocator) {
+void vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) {
GetVtbl(device).DestroyFence(device, fence, pAllocator);
}
@@ -242,22 +242,22 @@
}
__attribute__((visibility("default")))
-VkResult vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkSemaphore* pSemaphore) {
+VkResult vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) {
return GetVtbl(device).CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
}
__attribute__((visibility("default")))
-void vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocCallbacks* pAllocator) {
+void vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) {
GetVtbl(device).DestroySemaphore(device, semaphore, pAllocator);
}
__attribute__((visibility("default")))
-VkResult vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkEvent* pEvent) {
+VkResult vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) {
return GetVtbl(device).CreateEvent(device, pCreateInfo, pAllocator, pEvent);
}
__attribute__((visibility("default")))
-void vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocCallbacks* pAllocator) {
+void vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) {
GetVtbl(device).DestroyEvent(device, event, pAllocator);
}
@@ -277,12 +277,12 @@
}
__attribute__((visibility("default")))
-VkResult vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkQueryPool* pQueryPool) {
+VkResult vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) {
return GetVtbl(device).CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
}
__attribute__((visibility("default")))
-void vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocCallbacks* pAllocator) {
+void vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) {
GetVtbl(device).DestroyQueryPool(device, queryPool, pAllocator);
}
@@ -292,32 +292,32 @@
}
__attribute__((visibility("default")))
-VkResult vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkBuffer* pBuffer) {
+VkResult vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) {
return GetVtbl(device).CreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
}
__attribute__((visibility("default")))
-void vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocCallbacks* pAllocator) {
+void vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) {
GetVtbl(device).DestroyBuffer(device, buffer, pAllocator);
}
__attribute__((visibility("default")))
-VkResult vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkBufferView* pView) {
+VkResult vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) {
return GetVtbl(device).CreateBufferView(device, pCreateInfo, pAllocator, pView);
}
__attribute__((visibility("default")))
-void vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocCallbacks* pAllocator) {
+void vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) {
GetVtbl(device).DestroyBufferView(device, bufferView, pAllocator);
}
__attribute__((visibility("default")))
-VkResult vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkImage* pImage) {
+VkResult vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) {
return GetVtbl(device).CreateImage(device, pCreateInfo, pAllocator, pImage);
}
__attribute__((visibility("default")))
-void vkDestroyImage(VkDevice device, VkImage image, const VkAllocCallbacks* pAllocator) {
+void vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) {
GetVtbl(device).DestroyImage(device, image, pAllocator);
}
@@ -327,42 +327,42 @@
}
__attribute__((visibility("default")))
-VkResult vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkImageView* pView) {
+VkResult vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) {
return GetVtbl(device).CreateImageView(device, pCreateInfo, pAllocator, pView);
}
__attribute__((visibility("default")))
-void vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocCallbacks* pAllocator) {
+void vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) {
GetVtbl(device).DestroyImageView(device, imageView, pAllocator);
}
__attribute__((visibility("default")))
-VkResult vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkShaderModule* pShaderModule) {
+VkResult vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule) {
return GetVtbl(device).CreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule);
}
__attribute__((visibility("default")))
-void vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocCallbacks* pAllocator) {
+void vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) {
GetVtbl(device).DestroyShaderModule(device, shaderModule, pAllocator);
}
__attribute__((visibility("default")))
-VkResult vkCreateShader(VkDevice device, const VkShaderCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkShader* pShader) {
+VkResult vkCreateShader(VkDevice device, const VkShaderCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShader* pShader) {
return GetVtbl(device).CreateShader(device, pCreateInfo, pAllocator, pShader);
}
__attribute__((visibility("default")))
-void vkDestroyShader(VkDevice device, VkShader shader, const VkAllocCallbacks* pAllocator) {
+void vkDestroyShader(VkDevice device, VkShader shader, const VkAllocationCallbacks* pAllocator) {
GetVtbl(device).DestroyShader(device, shader, pAllocator);
}
__attribute__((visibility("default")))
-VkResult vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkPipelineCache* pPipelineCache) {
+VkResult vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) {
return GetVtbl(device).CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
}
__attribute__((visibility("default")))
-void vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocCallbacks* pAllocator) {
+void vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) {
GetVtbl(device).DestroyPipelineCache(device, pipelineCache, pAllocator);
}
@@ -372,62 +372,62 @@
}
__attribute__((visibility("default")))
-VkResult vkMergePipelineCaches(VkDevice device, VkPipelineCache destCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) {
- return GetVtbl(device).MergePipelineCaches(device, destCache, srcCacheCount, pSrcCaches);
+VkResult vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) {
+ return GetVtbl(device).MergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches);
}
__attribute__((visibility("default")))
-VkResult vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocCallbacks* pAllocator, VkPipeline* pPipelines) {
+VkResult vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {
return GetVtbl(device).CreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
}
__attribute__((visibility("default")))
-VkResult vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocCallbacks* pAllocator, VkPipeline* pPipelines) {
+VkResult vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) {
return GetVtbl(device).CreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
}
__attribute__((visibility("default")))
-void vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocCallbacks* pAllocator) {
+void vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) {
GetVtbl(device).DestroyPipeline(device, pipeline, pAllocator);
}
__attribute__((visibility("default")))
-VkResult vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) {
+VkResult vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) {
return GetVtbl(device).CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
}
__attribute__((visibility("default")))
-void vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocCallbacks* pAllocator) {
+void vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) {
GetVtbl(device).DestroyPipelineLayout(device, pipelineLayout, pAllocator);
}
__attribute__((visibility("default")))
-VkResult vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkSampler* pSampler) {
+VkResult vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) {
return GetVtbl(device).CreateSampler(device, pCreateInfo, pAllocator, pSampler);
}
__attribute__((visibility("default")))
-void vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocCallbacks* pAllocator) {
+void vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) {
GetVtbl(device).DestroySampler(device, sampler, pAllocator);
}
__attribute__((visibility("default")))
-VkResult vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) {
+VkResult vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) {
return GetVtbl(device).CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
}
__attribute__((visibility("default")))
-void vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocCallbacks* pAllocator) {
+void vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) {
GetVtbl(device).DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
}
__attribute__((visibility("default")))
-VkResult vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) {
+VkResult vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) {
return GetVtbl(device).CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
}
__attribute__((visibility("default")))
-void vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocCallbacks* pAllocator) {
+void vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) {
GetVtbl(device).DestroyDescriptorPool(device, descriptorPool, pAllocator);
}
@@ -437,8 +437,8 @@
}
__attribute__((visibility("default")))
-VkResult vkAllocDescriptorSets(VkDevice device, const VkDescriptorSetAllocInfo* pAllocInfo, VkDescriptorSet* pDescriptorSets) {
- return GetVtbl(device).AllocDescriptorSets(device, pAllocInfo, pDescriptorSets);
+VkResult vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) {
+ return GetVtbl(device).AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
}
__attribute__((visibility("default")))
@@ -452,22 +452,22 @@
}
__attribute__((visibility("default")))
-VkResult vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkFramebuffer* pFramebuffer) {
+VkResult vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) {
return GetVtbl(device).CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
}
__attribute__((visibility("default")))
-void vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocCallbacks* pAllocator) {
+void vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) {
GetVtbl(device).DestroyFramebuffer(device, framebuffer, pAllocator);
}
__attribute__((visibility("default")))
-VkResult vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkRenderPass* pRenderPass) {
+VkResult vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) {
return GetVtbl(device).CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
}
__attribute__((visibility("default")))
-void vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocCallbacks* pAllocator) {
+void vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) {
GetVtbl(device).DestroyRenderPass(device, renderPass, pAllocator);
}
@@ -477,263 +477,263 @@
}
__attribute__((visibility("default")))
-VkResult vkCreateCommandPool(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* pAllocator, VkCmdPool* pCmdPool) {
- return GetVtbl(device).CreateCommandPool(device, pCreateInfo, pAllocator, pCmdPool);
+VkResult vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) {
+ return GetVtbl(device).CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
}
__attribute__((visibility("default")))
-void vkDestroyCommandPool(VkDevice device, VkCmdPool cmdPool, const VkAllocCallbacks* pAllocator) {
- GetVtbl(device).DestroyCommandPool(device, cmdPool, pAllocator);
+void vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) {
+ GetVtbl(device).DestroyCommandPool(device, commandPool, pAllocator);
}
__attribute__((visibility("default")))
-VkResult vkResetCommandPool(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags) {
- return GetVtbl(device).ResetCommandPool(device, cmdPool, flags);
+VkResult vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) {
+ return GetVtbl(device).ResetCommandPool(device, commandPool, flags);
}
__attribute__((visibility("default")))
-VkResult vkAllocCommandBuffers(VkDevice device, const VkCmdBufferAllocInfo* pAllocInfo, VkCmdBuffer* pCmdBuffers) {
- return GetVtbl(device).AllocCommandBuffers(device, pAllocInfo, pCmdBuffers);
+VkResult vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers) {
+ return GetVtbl(device).AllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers);
}
__attribute__((visibility("default")))
-void vkFreeCommandBuffers(VkDevice device, VkCmdPool cmdPool, uint32_t commandBufferCount, const VkCmdBuffer* pCommandBuffers) {
- GetVtbl(device).FreeCommandBuffers(device, cmdPool, commandBufferCount, pCommandBuffers);
+void vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) {
+ GetVtbl(device).FreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers);
}
__attribute__((visibility("default")))
-VkResult vkBeginCommandBuffer(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo) {
- return GetVtbl(cmdBuffer).BeginCommandBuffer(cmdBuffer, pBeginInfo);
+VkResult vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo) {
+ return GetVtbl(commandBuffer).BeginCommandBuffer(commandBuffer, pBeginInfo);
}
__attribute__((visibility("default")))
-VkResult vkEndCommandBuffer(VkCmdBuffer cmdBuffer) {
- return GetVtbl(cmdBuffer).EndCommandBuffer(cmdBuffer);
+VkResult vkEndCommandBuffer(VkCommandBuffer commandBuffer) {
+ return GetVtbl(commandBuffer).EndCommandBuffer(commandBuffer);
}
__attribute__((visibility("default")))
-VkResult vkResetCommandBuffer(VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags) {
- return GetVtbl(cmdBuffer).ResetCommandBuffer(cmdBuffer, flags);
+VkResult vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) {
+ return GetVtbl(commandBuffer).ResetCommandBuffer(commandBuffer, flags);
}
__attribute__((visibility("default")))
-void vkCmdBindPipeline(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {
- GetVtbl(cmdBuffer).CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline);
+void vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {
+ GetVtbl(commandBuffer).CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
}
__attribute__((visibility("default")))
-void vkCmdSetViewport(VkCmdBuffer cmdBuffer, uint32_t viewportCount, const VkViewport* pViewports) {
- GetVtbl(cmdBuffer).CmdSetViewport(cmdBuffer, viewportCount, pViewports);
+void vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) {
+ GetVtbl(commandBuffer).CmdSetViewport(commandBuffer, viewportCount, pViewports);
}
__attribute__((visibility("default")))
-void vkCmdSetScissor(VkCmdBuffer cmdBuffer, uint32_t scissorCount, const VkRect2D* pScissors) {
- GetVtbl(cmdBuffer).CmdSetScissor(cmdBuffer, scissorCount, pScissors);
+void vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors) {
+ GetVtbl(commandBuffer).CmdSetScissor(commandBuffer, scissorCount, pScissors);
}
__attribute__((visibility("default")))
-void vkCmdSetLineWidth(VkCmdBuffer cmdBuffer, float lineWidth) {
- GetVtbl(cmdBuffer).CmdSetLineWidth(cmdBuffer, lineWidth);
+void vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) {
+ GetVtbl(commandBuffer).CmdSetLineWidth(commandBuffer, lineWidth);
}
__attribute__((visibility("default")))
-void vkCmdSetDepthBias(VkCmdBuffer cmdBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) {
- GetVtbl(cmdBuffer).CmdSetDepthBias(cmdBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
+void vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) {
+ GetVtbl(commandBuffer).CmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
}
__attribute__((visibility("default")))
-void vkCmdSetBlendConstants(VkCmdBuffer cmdBuffer, const float blendConstants[4]) {
- GetVtbl(cmdBuffer).CmdSetBlendConstants(cmdBuffer, blendConstants);
+void vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) {
+ GetVtbl(commandBuffer).CmdSetBlendConstants(commandBuffer, blendConstants);
}
__attribute__((visibility("default")))
-void vkCmdSetDepthBounds(VkCmdBuffer cmdBuffer, float minDepthBounds, float maxDepthBounds) {
- GetVtbl(cmdBuffer).CmdSetDepthBounds(cmdBuffer, minDepthBounds, maxDepthBounds);
+void vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) {
+ GetVtbl(commandBuffer).CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
}
__attribute__((visibility("default")))
-void vkCmdSetStencilCompareMask(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask) {
- GetVtbl(cmdBuffer).CmdSetStencilCompareMask(cmdBuffer, faceMask, stencilCompareMask);
+void vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask) {
+ GetVtbl(commandBuffer).CmdSetStencilCompareMask(commandBuffer, faceMask, stencilCompareMask);
}
__attribute__((visibility("default")))
-void vkCmdSetStencilWriteMask(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask) {
- GetVtbl(cmdBuffer).CmdSetStencilWriteMask(cmdBuffer, faceMask, stencilWriteMask);
+void vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask) {
+ GetVtbl(commandBuffer).CmdSetStencilWriteMask(commandBuffer, faceMask, stencilWriteMask);
}
__attribute__((visibility("default")))
-void vkCmdSetStencilReference(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference) {
- GetVtbl(cmdBuffer).CmdSetStencilReference(cmdBuffer, faceMask, stencilReference);
+void vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference) {
+ GetVtbl(commandBuffer).CmdSetStencilReference(commandBuffer, faceMask, stencilReference);
}
__attribute__((visibility("default")))
-void vkCmdBindDescriptorSets(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) {
- GetVtbl(cmdBuffer).CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
+void vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) {
+ GetVtbl(commandBuffer).CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
}
__attribute__((visibility("default")))
-void vkCmdBindIndexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) {
- GetVtbl(cmdBuffer).CmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType);
+void vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) {
+ GetVtbl(commandBuffer).CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
}
__attribute__((visibility("default")))
-void vkCmdBindVertexBuffers(VkCmdBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) {
- GetVtbl(cmdBuffer).CmdBindVertexBuffers(cmdBuffer, startBinding, bindingCount, pBuffers, pOffsets);
+void vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) {
+ GetVtbl(commandBuffer).CmdBindVertexBuffers(commandBuffer, startBinding, bindingCount, pBuffers, pOffsets);
}
__attribute__((visibility("default")))
-void vkCmdDraw(VkCmdBuffer cmdBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) {
- GetVtbl(cmdBuffer).CmdDraw(cmdBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
+void vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) {
+ GetVtbl(commandBuffer).CmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
}
__attribute__((visibility("default")))
-void vkCmdDrawIndexed(VkCmdBuffer cmdBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) {
- GetVtbl(cmdBuffer).CmdDrawIndexed(cmdBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
+void vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) {
+ GetVtbl(commandBuffer).CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
}
__attribute__((visibility("default")))
-void vkCmdDrawIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
- GetVtbl(cmdBuffer).CmdDrawIndirect(cmdBuffer, buffer, offset, drawCount, stride);
+void vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
+ GetVtbl(commandBuffer).CmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride);
}
__attribute__((visibility("default")))
-void vkCmdDrawIndexedIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
- GetVtbl(cmdBuffer).CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, drawCount, stride);
+void vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
+ GetVtbl(commandBuffer).CmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride);
}
__attribute__((visibility("default")))
-void vkCmdDispatch(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z) {
- GetVtbl(cmdBuffer).CmdDispatch(cmdBuffer, x, y, z);
+void vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z) {
+ GetVtbl(commandBuffer).CmdDispatch(commandBuffer, x, y, z);
}
__attribute__((visibility("default")))
-void vkCmdDispatchIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset) {
- GetVtbl(cmdBuffer).CmdDispatchIndirect(cmdBuffer, buffer, offset);
+void vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) {
+ GetVtbl(commandBuffer).CmdDispatchIndirect(commandBuffer, buffer, offset);
}
__attribute__((visibility("default")))
-void vkCmdCopyBuffer(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) {
- GetVtbl(cmdBuffer).CmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions);
+void vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) {
+ GetVtbl(commandBuffer).CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
}
__attribute__((visibility("default")))
-void vkCmdCopyImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) {
- GetVtbl(cmdBuffer).CmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
+void vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) {
+ GetVtbl(commandBuffer).CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
}
__attribute__((visibility("default")))
-void vkCmdBlitImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) {
- GetVtbl(cmdBuffer).CmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions, filter);
+void vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) {
+ GetVtbl(commandBuffer).CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
}
__attribute__((visibility("default")))
-void vkCmdCopyBufferToImage(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
- GetVtbl(cmdBuffer).CmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions);
+void vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
+ GetVtbl(commandBuffer).CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
}
__attribute__((visibility("default")))
-void vkCmdCopyImageToBuffer(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
- GetVtbl(cmdBuffer).CmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions);
+void vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
+ GetVtbl(commandBuffer).CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
}
__attribute__((visibility("default")))
-void vkCmdUpdateBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData) {
- GetVtbl(cmdBuffer).CmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize, pData);
+void vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const uint32_t* pData) {
+ GetVtbl(commandBuffer).CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
}
__attribute__((visibility("default")))
-void vkCmdFillBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize size, uint32_t data) {
- GetVtbl(cmdBuffer).CmdFillBuffer(cmdBuffer, destBuffer, destOffset, size, data);
+void vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) {
+ GetVtbl(commandBuffer).CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
}
__attribute__((visibility("default")))
-void vkCmdClearColorImage(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
- GetVtbl(cmdBuffer).CmdClearColorImage(cmdBuffer, image, imageLayout, pColor, rangeCount, pRanges);
+void vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
+ GetVtbl(commandBuffer).CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
}
__attribute__((visibility("default")))
-void vkCmdClearDepthStencilImage(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
- GetVtbl(cmdBuffer).CmdClearDepthStencilImage(cmdBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
+void vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
+ GetVtbl(commandBuffer).CmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
}
__attribute__((visibility("default")))
-void vkCmdClearAttachments(VkCmdBuffer cmdBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) {
- GetVtbl(cmdBuffer).CmdClearAttachments(cmdBuffer, attachmentCount, pAttachments, rectCount, pRects);
+void vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) {
+ GetVtbl(commandBuffer).CmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
}
__attribute__((visibility("default")))
-void vkCmdResolveImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) {
- GetVtbl(cmdBuffer).CmdResolveImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
+void vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) {
+ GetVtbl(commandBuffer).CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
}
__attribute__((visibility("default")))
-void vkCmdSetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
- GetVtbl(cmdBuffer).CmdSetEvent(cmdBuffer, event, stageMask);
+void vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
+ GetVtbl(commandBuffer).CmdSetEvent(commandBuffer, event, stageMask);
}
__attribute__((visibility("default")))
-void vkCmdResetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
- GetVtbl(cmdBuffer).CmdResetEvent(cmdBuffer, event, stageMask);
+void vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
+ GetVtbl(commandBuffer).CmdResetEvent(commandBuffer, event, stageMask);
}
__attribute__((visibility("default")))
-void vkCmdWaitEvents(VkCmdBuffer cmdBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, uint32_t memBarrierCount, const void* const* ppMemBarriers) {
- GetVtbl(cmdBuffer).CmdWaitEvents(cmdBuffer, eventCount, pEvents, srcStageMask, destStageMask, memBarrierCount, ppMemBarriers);
+void vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const void* const* ppMemoryBarriers) {
+ GetVtbl(commandBuffer).CmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, ppMemoryBarriers);
}
__attribute__((visibility("default")))
-void vkCmdPipelineBarrier(VkCmdBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkDependencyFlags dependencyFlags, uint32_t memBarrierCount, const void* const* ppMemBarriers) {
- GetVtbl(cmdBuffer).CmdPipelineBarrier(cmdBuffer, srcStageMask, destStageMask, dependencyFlags, memBarrierCount, ppMemBarriers);
+void vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const void* const* ppMemoryBarriers) {
+ GetVtbl(commandBuffer).CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, ppMemoryBarriers);
}
__attribute__((visibility("default")))
-void vkCmdBeginQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags) {
- GetVtbl(cmdBuffer).CmdBeginQuery(cmdBuffer, queryPool, slot, flags);
+void vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags) {
+ GetVtbl(commandBuffer).CmdBeginQuery(commandBuffer, queryPool, slot, flags);
}
__attribute__((visibility("default")))
-void vkCmdEndQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot) {
- GetVtbl(cmdBuffer).CmdEndQuery(cmdBuffer, queryPool, slot);
+void vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot) {
+ GetVtbl(commandBuffer).CmdEndQuery(commandBuffer, queryPool, slot);
}
__attribute__((visibility("default")))
-void vkCmdResetQueryPool(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount) {
- GetVtbl(cmdBuffer).CmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount);
+void vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount) {
+ GetVtbl(commandBuffer).CmdResetQueryPool(commandBuffer, queryPool, startQuery, queryCount);
}
__attribute__((visibility("default")))
-void vkCmdWriteTimestamp(VkCmdBuffer cmdBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot) {
- GetVtbl(cmdBuffer).CmdWriteTimestamp(cmdBuffer, pipelineStage, queryPool, slot);
+void vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot) {
+ GetVtbl(commandBuffer).CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, slot);
}
__attribute__((visibility("default")))
-void vkCmdCopyQueryPoolResults(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize stride, VkQueryResultFlags flags) {
- GetVtbl(cmdBuffer).CmdCopyQueryPoolResults(cmdBuffer, queryPool, startQuery, queryCount, destBuffer, destOffset, stride, flags);
+void vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) {
+ GetVtbl(commandBuffer).CmdCopyQueryPoolResults(commandBuffer, queryPool, startQuery, queryCount, dstBuffer, dstOffset, stride, flags);
}
__attribute__((visibility("default")))
-void vkCmdPushConstants(VkCmdBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* values) {
- GetVtbl(cmdBuffer).CmdPushConstants(cmdBuffer, layout, stageFlags, offset, size, values);
+void vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* values) {
+ GetVtbl(commandBuffer).CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, values);
}
__attribute__((visibility("default")))
-void vkCmdBeginRenderPass(VkCmdBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents) {
- GetVtbl(cmdBuffer).CmdBeginRenderPass(cmdBuffer, pRenderPassBegin, contents);
+void vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents) {
+ GetVtbl(commandBuffer).CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
}
__attribute__((visibility("default")))
-void vkCmdNextSubpass(VkCmdBuffer cmdBuffer, VkRenderPassContents contents) {
- GetVtbl(cmdBuffer).CmdNextSubpass(cmdBuffer, contents);
+void vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkRenderPassContents contents) {
+ GetVtbl(commandBuffer).CmdNextSubpass(commandBuffer, contents);
}
__attribute__((visibility("default")))
-void vkCmdEndRenderPass(VkCmdBuffer cmdBuffer) {
- GetVtbl(cmdBuffer).CmdEndRenderPass(cmdBuffer);
+void vkCmdEndRenderPass(VkCommandBuffer commandBuffer) {
+ GetVtbl(commandBuffer).CmdEndRenderPass(commandBuffer);
}
__attribute__((visibility("default")))
-void vkCmdExecuteCommands(VkCmdBuffer cmdBuffer, uint32_t cmdBuffersCount, const VkCmdBuffer* pCmdBuffers) {
- GetVtbl(cmdBuffer).CmdExecuteCommands(cmdBuffer, cmdBuffersCount, pCmdBuffers);
+void vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBuffersCount, const VkCommandBuffer* pCommandBuffers) {
+ GetVtbl(commandBuffer).CmdExecuteCommands(commandBuffer, commandBuffersCount, pCommandBuffers);
}
__attribute__((visibility("default")))
diff --git a/vulkan/libvulkan/entry.cpp.tmpl b/vulkan/libvulkan/entry.cpp.tmpl
index d0e665f..5aed3df 100644
--- a/vulkan/libvulkan/entry.cpp.tmpl
+++ b/vulkan/libvulkan/entry.cpp.tmpl
@@ -63,8 +63,8 @@
inline const DeviceVtbl& GetVtbl(VkQueue queue) {
return **reinterpret_cast<DeviceVtbl**>(queue);
}
- inline const DeviceVtbl& GetVtbl(VkCmdBuffer cmdBuffer) {
- return **reinterpret_cast<DeviceVtbl**>(cmdBuffer);
+ inline const DeviceVtbl& GetVtbl(VkCommandBuffer commandBuffer) {
+ return **reinterpret_cast<DeviceVtbl**>(commandBuffer);
}
} // namespace
¶
@@ -159,7 +159,7 @@
{{define "Dispatch#VkPhysicalDevice"}}GetVtbl({{$.Node.Name}}).{{end}}
{{define "Dispatch#VkDevice" }}GetVtbl({{$.Node.Name}}).{{end}}
{{define "Dispatch#VkQueue" }}GetVtbl({{$.Node.Name}}).{{end}}
-{{define "Dispatch#VkCmdBuffer" }}GetVtbl({{$.Node.Name}}).{{end}}
+{{define "Dispatch#VkCommandBuffer" }}GetVtbl({{$.Node.Name}}).{{end}}
{{define "Dispatch_Default" }}vulkan::{{end}}
{{define "Dispatch"}}
{{AssertType $ "Function"}}
diff --git a/vulkan/libvulkan/get_proc_addr.cpp b/vulkan/libvulkan/get_proc_addr.cpp
index 4e08015..f6a6510 100644
--- a/vulkan/libvulkan/get_proc_addr.cpp
+++ b/vulkan/libvulkan/get_proc_addr.cpp
@@ -74,9 +74,9 @@
const NameProcEntry kDeviceProcTbl[] = {
// clang-format off
{"vkAcquireNextImageKHR", reinterpret_cast<PFN_vkVoidFunction>(vkAcquireNextImageKHR)},
- {"vkAllocCommandBuffers", reinterpret_cast<PFN_vkVoidFunction>(vkAllocCommandBuffers)},
- {"vkAllocDescriptorSets", reinterpret_cast<PFN_vkVoidFunction>(vkAllocDescriptorSets)},
- {"vkAllocMemory", reinterpret_cast<PFN_vkVoidFunction>(vkAllocMemory)},
+ {"vkAllocateCommandBuffers", reinterpret_cast<PFN_vkVoidFunction>(vkAllocateCommandBuffers)},
+ {"vkAllocateDescriptorSets", reinterpret_cast<PFN_vkVoidFunction>(vkAllocateDescriptorSets)},
+ {"vkAllocateMemory", reinterpret_cast<PFN_vkVoidFunction>(vkAllocateMemory)},
{"vkBeginCommandBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkBeginCommandBuffer)},
{"vkBindBufferMemory", reinterpret_cast<PFN_vkVoidFunction>(vkBindBufferMemory)},
{"vkBindImageMemory", reinterpret_cast<PFN_vkVoidFunction>(vkBindImageMemory)},
@@ -231,9 +231,9 @@
const NameOffsetEntry kDeviceOffsetTbl[] = {
// clang-format off
{"vkAcquireNextImageKHR", offsetof(DeviceVtbl, AcquireNextImageKHR)},
- {"vkAllocCommandBuffers", offsetof(DeviceVtbl, AllocCommandBuffers)},
- {"vkAllocDescriptorSets", offsetof(DeviceVtbl, AllocDescriptorSets)},
- {"vkAllocMemory", offsetof(DeviceVtbl, AllocMemory)},
+ {"vkAllocateCommandBuffers", offsetof(DeviceVtbl, AllocateCommandBuffers)},
+ {"vkAllocateDescriptorSets", offsetof(DeviceVtbl, AllocateDescriptorSets)},
+ {"vkAllocateMemory", offsetof(DeviceVtbl, AllocateMemory)},
{"vkBeginCommandBuffer", offsetof(DeviceVtbl, BeginCommandBuffer)},
{"vkBindBufferMemory", offsetof(DeviceVtbl, BindBufferMemory)},
{"vkBindImageMemory", offsetof(DeviceVtbl, BindImageMemory)},
@@ -530,9 +530,9 @@
ALOGE("missing device proc: %s", "vkDeviceWaitIdle");
success = false;
}
- vtbl.AllocMemory = reinterpret_cast<PFN_vkAllocMemory>(get_proc_addr(device, "vkAllocMemory"));
- if (UNLIKELY(!vtbl.AllocMemory)) {
- ALOGE("missing device proc: %s", "vkAllocMemory");
+ vtbl.AllocateMemory = reinterpret_cast<PFN_vkAllocateMemory>(get_proc_addr(device, "vkAllocateMemory"));
+ if (UNLIKELY(!vtbl.AllocateMemory)) {
+ ALOGE("missing device proc: %s", "vkAllocateMemory");
success = false;
}
vtbl.FreeMemory = reinterpret_cast<PFN_vkFreeMemory>(get_proc_addr(device, "vkFreeMemory"));
@@ -815,9 +815,9 @@
ALOGE("missing device proc: %s", "vkResetDescriptorPool");
success = false;
}
- vtbl.AllocDescriptorSets = reinterpret_cast<PFN_vkAllocDescriptorSets>(get_proc_addr(device, "vkAllocDescriptorSets"));
- if (UNLIKELY(!vtbl.AllocDescriptorSets)) {
- ALOGE("missing device proc: %s", "vkAllocDescriptorSets");
+ vtbl.AllocateDescriptorSets = reinterpret_cast<PFN_vkAllocateDescriptorSets>(get_proc_addr(device, "vkAllocateDescriptorSets"));
+ if (UNLIKELY(!vtbl.AllocateDescriptorSets)) {
+ ALOGE("missing device proc: %s", "vkAllocateDescriptorSets");
success = false;
}
vtbl.FreeDescriptorSets = reinterpret_cast<PFN_vkFreeDescriptorSets>(get_proc_addr(device, "vkFreeDescriptorSets"));
@@ -870,9 +870,9 @@
ALOGE("missing device proc: %s", "vkResetCommandPool");
success = false;
}
- vtbl.AllocCommandBuffers = reinterpret_cast<PFN_vkAllocCommandBuffers>(get_proc_addr(device, "vkAllocCommandBuffers"));
- if (UNLIKELY(!vtbl.AllocCommandBuffers)) {
- ALOGE("missing device proc: %s", "vkAllocCommandBuffers");
+ vtbl.AllocateCommandBuffers = reinterpret_cast<PFN_vkAllocateCommandBuffers>(get_proc_addr(device, "vkAllocateCommandBuffers"));
+ if (UNLIKELY(!vtbl.AllocateCommandBuffers)) {
+ ALOGE("missing device proc: %s", "vkAllocateCommandBuffers");
success = false;
}
vtbl.FreeCommandBuffers = reinterpret_cast<PFN_vkFreeCommandBuffers>(get_proc_addr(device, "vkFreeCommandBuffers"));
diff --git a/vulkan/libvulkan/loader.cpp b/vulkan/libvulkan/loader.cpp
index 03265ef..d1b369e 100644
--- a/vulkan/libvulkan/loader.cpp
+++ b/vulkan/libvulkan/loader.cpp
@@ -58,10 +58,10 @@
// Define Handle typedef to be void* as returned from dlopen.
typedef void* SharedLibraryHandle;
-// Standard-library allocator that delegates to VkAllocCallbacks.
+// Standard-library allocator that delegates to VkAllocationCallbacks.
//
// TODO(jessehall): This class currently always uses
-// VK_SYSTEM_ALLOC_SCOPE_INSTANCE. The scope to use could be a template
+// VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE. The scope to use could be a template
// parameter or a constructor parameter. The former would help catch bugs
// where we use the wrong scope, e.g. adding a command-scope string to an
// instance-scope vector. But that might also be pretty annoying to deal with.
@@ -70,7 +70,7 @@
public:
typedef T value_type;
- CallbackAllocator(const VkAllocCallbacks* alloc_input)
+ CallbackAllocator(const VkAllocationCallbacks* alloc_input)
: alloc(alloc_input) {}
template <class T2>
@@ -78,8 +78,9 @@
: alloc(other.alloc) {}
T* allocate(std::size_t n) {
- void* mem = alloc->pfnAlloc(alloc->pUserData, n * sizeof(T), alignof(T),
- VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
+ void* mem =
+ alloc->pfnAllocation(alloc->pUserData, n * sizeof(T), alignof(T),
+ VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
return static_cast<T*>(mem);
}
@@ -87,7 +88,7 @@
alloc->pfnFree(alloc->pUserData, array);
}
- const VkAllocCallbacks* alloc;
+ const VkAllocationCallbacks* alloc;
};
// These are needed in order to move Strings
template <class T>
@@ -136,7 +137,7 @@
} // namespace
struct VkInstance_T {
- VkInstance_T(const VkAllocCallbacks* alloc_callbacks)
+ VkInstance_T(const VkAllocationCallbacks* alloc_callbacks)
: vtbl(&vtbl_storage),
alloc(alloc_callbacks),
num_physical_devices(0),
@@ -155,7 +156,7 @@
InstanceVtbl* vtbl;
InstanceVtbl vtbl_storage;
- const VkAllocCallbacks* alloc;
+ const VkAllocationCallbacks* alloc;
uint32_t num_physical_devices;
VkPhysicalDevice physical_devices[kMaxPhysicalDevices];
@@ -214,7 +215,10 @@
return *reinterpret_cast<DeviceVtbl**>(queue);
}
-void* DefaultAlloc(void*, size_t size, size_t alignment, VkSystemAllocScope) {
+void* DefaultAllocate(void*,
+ size_t size,
+ size_t alignment,
+ VkSystemAllocationScope) {
void* ptr = nullptr;
// Vulkan requires 'alignment' to be a power of two, but posix_memalign
// additionally requires that it be at least sizeof(void*).
@@ -223,11 +227,11 @@
: nullptr;
}
-void* DefaultRealloc(void*,
- void* ptr,
- size_t size,
- size_t alignment,
- VkSystemAllocScope) {
+void* DefaultReallocate(void*,
+ void* ptr,
+ size_t size,
+ size_t alignment,
+ VkSystemAllocationScope) {
if (size == 0) {
free(ptr);
return nullptr;
@@ -257,10 +261,10 @@
free(pMem);
}
-const VkAllocCallbacks kDefaultAllocCallbacks = {
+const VkAllocationCallbacks kDefaultAllocCallbacks = {
.pUserData = nullptr,
- .pfnAlloc = DefaultAlloc,
- .pfnRealloc = DefaultRealloc,
+ .pfnAllocation = DefaultAllocate,
+ .pfnReallocation = DefaultReallocate,
.pfnFree = DefaultFree,
};
@@ -293,7 +297,7 @@
}
void DestroyDevice(Device* device) {
- const VkAllocCallbacks* alloc = device->instance->alloc;
+ const VkAllocationCallbacks* alloc = device->instance->alloc;
device->~Device();
alloc->pfnFree(alloc->pUserData, device);
}
@@ -480,7 +484,7 @@
template <class TCreateInfo>
bool AddExtensionToCreateInfo(TCreateInfo& local_create_info,
const char* extension_name,
- const VkAllocCallbacks* alloc) {
+ const VkAllocationCallbacks* alloc) {
for (uint32_t i = 0; i < local_create_info.enabledExtensionNameCount; ++i) {
if (!strcmp(extension_name,
local_create_info.ppEnabledExtensionNames[i])) {
@@ -489,10 +493,10 @@
}
uint32_t extension_count = local_create_info.enabledExtensionNameCount;
local_create_info.enabledExtensionNameCount++;
- void* mem = alloc->pfnAlloc(
+ void* mem = alloc->pfnAllocation(
alloc->pUserData,
local_create_info.enabledExtensionNameCount * sizeof(char*),
- alignof(char*), VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
+ alignof(char*), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
if (mem) {
const char** enabled_extensions = static_cast<const char**>(mem);
for (uint32_t i = 0; i < extension_count; ++i) {
@@ -512,7 +516,7 @@
template <class T>
void FreeAllocatedCreateInfo(T& local_create_info,
- const VkAllocCallbacks* alloc) {
+ const VkAllocationCallbacks* alloc) {
alloc->pfnFree(
alloc->pUserData,
const_cast<char**>(local_create_info.ppEnabledExtensionNames));
@@ -572,7 +576,7 @@
// chain.
void DestroyInstanceBottom(VkInstance instance,
- const VkAllocCallbacks* allocator) {
+ const VkAllocationCallbacks* allocator) {
// These checks allow us to call DestroyInstanceBottom from any error path
// in CreateInstanceBottom, before the driver instance is fully initialized.
if (instance->drv.vtbl.instance != VK_NULL_HANDLE &&
@@ -591,13 +595,13 @@
it != instance->active_layers.end(); ++it) {
DeactivateLayer(instance, it);
}
- const VkAllocCallbacks* alloc = instance->alloc;
+ const VkAllocationCallbacks* alloc = instance->alloc;
instance->~VkInstance_T();
alloc->pfnFree(alloc->pUserData, instance);
}
VkResult CreateInstanceBottom(const VkInstanceCreateInfo* create_info,
- const VkAllocCallbacks* allocator,
+ const VkAllocationCallbacks* allocator,
VkInstance* instance_ptr) {
Instance* instance = *instance_ptr;
VkResult result;
@@ -733,7 +737,7 @@
VkResult CreateDeviceBottom(VkPhysicalDevice pdev,
const VkDeviceCreateInfo* create_info,
- const VkAllocCallbacks* allocator,
+ const VkAllocationCallbacks* allocator,
VkDevice* out_device) {
Instance& instance = *static_cast<Instance*>(GetVtbl(pdev)->instance);
VkResult result;
@@ -745,9 +749,9 @@
allocator = &kDefaultAllocCallbacks;
}
- void* mem =
- allocator->pfnAlloc(allocator->pUserData, sizeof(Device),
- alignof(Device), VK_SYSTEM_ALLOC_SCOPE_DEVICE);
+ void* mem = allocator->pfnAllocation(allocator->pUserData, sizeof(Device),
+ alignof(Device),
+ VK_SYSTEM_ALLOCATION_SCOPE_DEVICE);
if (!mem)
return VK_ERROR_OUT_OF_HOST_MEMORY;
Device* device = new (mem) Device(&instance);
@@ -945,7 +949,7 @@
}
VkResult CreateInstance(const VkInstanceCreateInfo* create_info,
- const VkAllocCallbacks* allocator,
+ const VkAllocationCallbacks* allocator,
VkInstance* out_instance) {
VkResult result;
@@ -958,9 +962,9 @@
VkInstanceCreateInfo local_create_info = *create_info;
create_info = &local_create_info;
- void* instance_mem =
- allocator->pfnAlloc(allocator->pUserData, sizeof(Instance),
- alignof(Instance), VK_SYSTEM_ALLOC_SCOPE_INSTANCE);
+ void* instance_mem = allocator->pfnAllocation(
+ allocator->pUserData, sizeof(Instance), alignof(Instance),
+ VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
if (!instance_mem)
return VK_ERROR_OUT_OF_HOST_MEMORY;
Instance* instance = new (instance_mem) Instance(allocator);
@@ -1125,17 +1129,17 @@
}
VkResult AllocCommandBuffers(VkDevice device,
- const VkCmdBufferAllocInfo* alloc_info,
- VkCmdBuffer* cmdbuffers) {
+ const VkCommandBufferAllocateInfo* alloc_info,
+ VkCommandBuffer* cmdbufs) {
const DeviceVtbl* vtbl = GetVtbl(device);
- VkResult result = vtbl->AllocCommandBuffers(device, alloc_info, cmdbuffers);
+ VkResult result = vtbl->AllocateCommandBuffers(device, alloc_info, cmdbufs);
if (result != VK_SUCCESS)
return result;
for (uint32_t i = 0; i < alloc_info->bufferCount; i++) {
hwvulkan_dispatch_t* dispatch =
- reinterpret_cast<hwvulkan_dispatch_t*>(cmdbuffers[i]);
+ reinterpret_cast<hwvulkan_dispatch_t*>(cmdbufs[i]);
ALOGE_IF(dispatch->magic != HWVULKAN_DISPATCH_MAGIC,
- "invalid VkCmdBuffer dispatch magic: 0x%" PRIxPTR,
+ "invalid VkCommandBuffer dispatch magic: 0x%" PRIxPTR,
dispatch->magic);
dispatch->vtbl = vtbl;
}
@@ -1143,7 +1147,7 @@
}
VkResult DestroyDevice(VkDevice drv_device,
- const VkAllocCallbacks* /*allocator*/) {
+ const VkAllocationCallbacks* /*allocator*/) {
const DeviceVtbl* vtbl = GetVtbl(drv_device);
Device* device = static_cast<Device*>(vtbl->device);
for (auto it = device->active_layers.begin();
@@ -1158,27 +1162,27 @@
void* AllocMem(VkInstance instance,
size_t size,
size_t align,
- VkSystemAllocScope scope) {
- const VkAllocCallbacks* alloc_cb = instance->alloc;
- return alloc_cb->pfnAlloc(alloc_cb->pUserData, size, align, scope);
+ VkSystemAllocationScope scope) {
+ const VkAllocationCallbacks* alloc_cb = instance->alloc;
+ return alloc_cb->pfnAllocation(alloc_cb->pUserData, size, align, scope);
}
void FreeMem(VkInstance instance, void* ptr) {
- const VkAllocCallbacks* alloc_cb = instance->alloc;
+ const VkAllocationCallbacks* alloc_cb = instance->alloc;
alloc_cb->pfnFree(alloc_cb->pUserData, ptr);
}
void* AllocMem(VkDevice device,
size_t size,
size_t align,
- VkSystemAllocScope scope) {
- const VkAllocCallbacks* alloc_cb =
+ VkSystemAllocationScope scope) {
+ const VkAllocationCallbacks* alloc_cb =
static_cast<Device*>(GetVtbl(device)->device)->instance->alloc;
- return alloc_cb->pfnAlloc(alloc_cb->pUserData, size, align, scope);
+ return alloc_cb->pfnAllocation(alloc_cb->pUserData, size, align, scope);
}
void FreeMem(VkDevice device, void* ptr) {
- const VkAllocCallbacks* alloc_cb =
+ const VkAllocationCallbacks* alloc_cb =
static_cast<Device*>(GetVtbl(device)->device)->instance->alloc;
alloc_cb->pfnFree(alloc_cb->pUserData, ptr);
}
diff --git a/vulkan/libvulkan/loader.h b/vulkan/libvulkan/loader.h
index b6c8552..bf71c8f 100644
--- a/vulkan/libvulkan/loader.h
+++ b/vulkan/libvulkan/loader.h
@@ -67,7 +67,7 @@
PFN_vkDestroyDevice DestroyDevice;
PFN_vkGetDeviceQueue GetDeviceQueue;
PFN_vkDeviceWaitIdle DeviceWaitIdle;
- PFN_vkAllocMemory AllocMemory;
+ PFN_vkAllocateMemory AllocateMemory;
PFN_vkFreeMemory FreeMemory;
PFN_vkMapMemory MapMemory;
PFN_vkUnmapMemory UnmapMemory;
@@ -123,7 +123,7 @@
PFN_vkCreateDescriptorPool CreateDescriptorPool;
PFN_vkDestroyDescriptorPool DestroyDescriptorPool;
PFN_vkResetDescriptorPool ResetDescriptorPool;
- PFN_vkAllocDescriptorSets AllocDescriptorSets;
+ PFN_vkAllocateDescriptorSets AllocateDescriptorSets;
PFN_vkFreeDescriptorSets FreeDescriptorSets;
PFN_vkUpdateDescriptorSets UpdateDescriptorSets;
PFN_vkCreateFramebuffer CreateFramebuffer;
@@ -134,7 +134,7 @@
PFN_vkCreateCommandPool CreateCommandPool;
PFN_vkDestroyCommandPool DestroyCommandPool;
PFN_vkResetCommandPool ResetCommandPool;
- PFN_vkAllocCommandBuffers AllocCommandBuffers;
+ PFN_vkAllocateCommandBuffers AllocateCommandBuffers;
PFN_vkFreeCommandBuffers FreeCommandBuffers;
PFN_vkQueueSubmit QueueSubmit;
@@ -214,7 +214,7 @@
VkResult EnumerateInstanceLayerProperties(uint32_t* count,
VkLayerProperties* properties);
VkResult CreateInstance(const VkInstanceCreateInfo* create_info,
- const VkAllocCallbacks* pAllocator,
+ const VkAllocationCallbacks* pAllocator,
VkInstance* instance);
PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const char* name);
PFN_vkVoidFunction GetDeviceProcAddr(VkDevice drv_device, const char* name);
@@ -223,19 +223,20 @@
uint32_t index,
VkQueue* out_queue);
VkResult AllocCommandBuffers(VkDevice device,
- const VkCmdBufferAllocInfo* alloc_info,
- VkCmdBuffer* cmdbuffers);
-VkResult DestroyDevice(VkDevice drv_device, const VkAllocCallbacks* pAllocator);
+ const VkCommandBufferAllocateInfo* alloc_info,
+ VkCommandBuffer* cmdbufs);
+VkResult DestroyDevice(VkDevice drv_device,
+ const VkAllocationCallbacks* pAllocator);
void* AllocMem(VkInstance instance,
size_t size,
size_t align,
- VkSystemAllocScope scope);
+ VkSystemAllocationScope scope);
void FreeMem(VkInstance instance, void* ptr);
void* AllocMem(VkDevice device,
size_t size,
size_t align,
- VkSystemAllocScope scope);
+ VkSystemAllocationScope scope);
void FreeMem(VkDevice device, void* ptr);
const DeviceVtbl& GetDriverVtbl(VkDevice device);
const DeviceVtbl& GetDriverVtbl(VkQueue queue);
diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp
index f1fe236..5b35506 100644
--- a/vulkan/libvulkan/swapchain.cpp
+++ b/vulkan/libvulkan/swapchain.cpp
@@ -37,7 +37,8 @@
// ----------------------------------------------------------------------------
// These functions/classes form an adaptor that allows objects to be refcounted
// by both android::sp<> and std::shared_ptr<> simultaneously, and delegates
-// allocation of the shared_ptr<> control structure to VkAllocCallbacks. The
+// allocation of the shared_ptr<> control structure to VkAllocationCallbacks.
+// The
// platform holds a reference to the ANativeWindow using its embedded reference
// count, and the ANativeWindow implementation holds references to the
// ANativeWindowBuffers using their embedded reference counts, so the
@@ -54,12 +55,14 @@
template <>
struct AllocScope<VkInstance> {
- static const VkSystemAllocScope kScope = VK_SYSTEM_ALLOC_SCOPE_INSTANCE;
+ static const VkSystemAllocationScope kScope =
+ VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE;
};
template <>
struct AllocScope<VkDevice> {
- static const VkSystemAllocScope kScope = VK_SYSTEM_ALLOC_SCOPE_DEVICE;
+ static const VkSystemAllocationScope kScope =
+ VK_SYSTEM_ALLOCATION_SCOPE_DEVICE;
};
template <typename T, typename Host>
@@ -142,7 +145,7 @@
ANativeWindow* window,
VkSurfaceKHR* out_surface) {
void* mem = AllocMem(instance, sizeof(Surface), alignof(Surface),
- VK_SYSTEM_ALLOC_SCOPE_OBJECT);
+ VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (!mem)
return VK_ERROR_OUT_OF_HOST_MEMORY;
Surface* surface = new (mem) Surface;
@@ -231,9 +234,9 @@
// - VK_IMAGE_USAGE_DEPTH_STENCIL_BIT: definitely not
// - VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT: definitely not
capabilities->supportedUsageFlags =
- VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT |
- VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT | VK_IMAGE_USAGE_SAMPLED_BIT |
- VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
+ VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT |
+ VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_STORAGE_BIT |
+ VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT |
VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
return VK_SUCCESS;
@@ -378,7 +381,7 @@
// After this point, we must deallocate the swapchain on error.
void* mem = AllocMem(device, sizeof(Swapchain), alignof(Swapchain),
- VK_SYSTEM_ALLOC_SCOPE_OBJECT);
+ VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
if (!mem)
return VK_ERROR_OUT_OF_HOST_MEMORY;
Swapchain* swapchain = new (mem) Swapchain(surface, num_images);
diff --git a/vulkan/nulldrv/null_driver.cpp b/vulkan/nulldrv/null_driver.cpp
index 698dbd0..d134c0e 100644
--- a/vulkan/nulldrv/null_driver.cpp
+++ b/vulkan/nulldrv/null_driver.cpp
@@ -35,7 +35,7 @@
struct VkInstance_T {
hwvulkan_dispatch_t dispatch;
- VkAllocCallbacks allocator;
+ VkAllocationCallbacks allocator;
VkPhysicalDevice_T physical_device;
};
@@ -43,7 +43,7 @@
hwvulkan_dispatch_t dispatch;
};
-struct VkCmdBuffer_T {
+struct VkCommandBuffer_T {
hwvulkan_dispatch_t dispatch;
};
@@ -95,7 +95,7 @@
struct VkDevice_T {
hwvulkan_dispatch_t dispatch;
- VkAllocCallbacks allocator;
+ VkAllocationCallbacks allocator;
VkInstance_T* instance;
VkQueue_T queue;
std::array<uint64_t, HandleType::kNumTypes> next_handle;
@@ -131,16 +131,17 @@
namespace {
VkResult CreateInstance(const VkInstanceCreateInfo* /*create_info*/,
- const VkAllocCallbacks* allocator,
+ const VkAllocationCallbacks* allocator,
VkInstance* out_instance) {
// Assume the loader provided alloc callbacks even if the app didn't.
ALOG_ASSERT(
allocator,
"Missing alloc callbacks, loader or app should have provided them");
- VkInstance_T* instance = static_cast<VkInstance_T*>(allocator->pfnAlloc(
- allocator->pUserData, sizeof(VkInstance_T), alignof(VkInstance_T),
- VK_SYSTEM_ALLOC_SCOPE_INSTANCE));
+ VkInstance_T* instance =
+ static_cast<VkInstance_T*>(allocator->pfnAllocation(
+ allocator->pUserData, sizeof(VkInstance_T), alignof(VkInstance_T),
+ VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE));
if (!instance)
return VK_ERROR_OUT_OF_HOST_MEMORY;
@@ -245,7 +246,7 @@
// Instance
void DestroyInstance(VkInstance instance,
- const VkAllocCallbacks* /*allocator*/) {
+ const VkAllocationCallbacks* /*allocator*/) {
instance->allocator.pfnFree(instance->allocator.pUserData, instance);
}
@@ -303,14 +304,14 @@
VkResult CreateDevice(VkPhysicalDevice physical_device,
const VkDeviceCreateInfo*,
- const VkAllocCallbacks* allocator,
+ const VkAllocationCallbacks* allocator,
VkDevice* out_device) {
VkInstance_T* instance = GetInstanceFromPhysicalDevice(physical_device);
if (!allocator)
allocator = &instance->allocator;
- VkDevice_T* device = static_cast<VkDevice_T*>(
- allocator->pfnAlloc(allocator->pUserData, sizeof(VkDevice_T),
- alignof(VkDevice_T), VK_SYSTEM_ALLOC_SCOPE_DEVICE));
+ VkDevice_T* device = static_cast<VkDevice_T*>(allocator->pfnAllocation(
+ allocator->pUserData, sizeof(VkDevice_T), alignof(VkDevice_T),
+ VK_SYSTEM_ALLOCATION_SCOPE_DEVICE));
if (!device)
return VK_ERROR_OUT_OF_HOST_MEMORY;
@@ -325,7 +326,8 @@
return VK_SUCCESS;
}
-void DestroyDevice(VkDevice device, const VkAllocCallbacks* /*allocator*/) {
+void DestroyDevice(VkDevice device,
+ const VkAllocationCallbacks* /*allocator*/) {
if (!device)
return;
device->allocator.pfnFree(device->allocator.pUserData, device);
@@ -336,50 +338,51 @@
}
// -----------------------------------------------------------------------------
-// CmdPool
+// CommandPool
-struct CmdPool {
- typedef VkCmdPool HandleType;
- VkAllocCallbacks allocator;
+struct CommandPool {
+ typedef VkCommandPool HandleType;
+ VkAllocationCallbacks allocator;
};
-DEFINE_OBJECT_HANDLE_CONVERSION(CmdPool)
+DEFINE_OBJECT_HANDLE_CONVERSION(CommandPool)
VkResult CreateCommandPool(VkDevice device,
- const VkCmdPoolCreateInfo* /*create_info*/,
- const VkAllocCallbacks* allocator,
- VkCmdPool* cmd_pool) {
+ const VkCommandPoolCreateInfo* /*create_info*/,
+ const VkAllocationCallbacks* allocator,
+ VkCommandPool* cmd_pool) {
if (!allocator)
allocator = &device->allocator;
- CmdPool* pool = static_cast<CmdPool*>(
- allocator->pfnAlloc(allocator->pUserData, sizeof(CmdPool),
- alignof(CmdPool), VK_SYSTEM_ALLOC_SCOPE_OBJECT));
+ CommandPool* pool = static_cast<CommandPool*>(allocator->pfnAllocation(
+ allocator->pUserData, sizeof(CommandPool), alignof(CommandPool),
+ VK_SYSTEM_ALLOCATION_SCOPE_OBJECT));
if (!pool)
return VK_ERROR_OUT_OF_HOST_MEMORY;
pool->allocator = *allocator;
- *cmd_pool = GetHandleToCmdPool(pool);
+ *cmd_pool = GetHandleToCommandPool(pool);
return VK_SUCCESS;
}
void DestroyCommandPool(VkDevice /*device*/,
- VkCmdPool cmd_pool,
- const VkAllocCallbacks* /*allocator*/) {
- CmdPool* pool = GetCmdPoolFromHandle(cmd_pool);
+ VkCommandPool cmd_pool,
+ const VkAllocationCallbacks* /*allocator*/) {
+ CommandPool* pool = GetCommandPoolFromHandle(cmd_pool);
pool->allocator.pfnFree(pool->allocator.pUserData, pool);
}
// -----------------------------------------------------------------------------
// CmdBuffer
-VkResult AllocCommandBuffers(VkDevice /*device*/,
- const VkCmdBufferAllocInfo* alloc_info,
- VkCmdBuffer* cmdbufs) {
+VkResult AllocateCommandBuffers(VkDevice /*device*/,
+ const VkCommandBufferAllocateInfo* alloc_info,
+ VkCommandBuffer* cmdbufs) {
VkResult result = VK_SUCCESS;
- CmdPool& pool = *GetCmdPoolFromHandle(alloc_info->cmdPool);
+ CommandPool& pool = *GetCommandPoolFromHandle(alloc_info->commandPool);
std::fill(cmdbufs, cmdbufs + alloc_info->bufferCount, nullptr);
for (uint32_t i = 0; i < alloc_info->bufferCount; i++) {
- cmdbufs[i] = static_cast<VkCmdBuffer_T*>(pool.allocator.pfnAlloc(
- pool.allocator.pUserData, sizeof(VkCmdBuffer_T),
- alignof(VkCmdBuffer_T), VK_SYSTEM_ALLOC_SCOPE_OBJECT));
+ cmdbufs[i] =
+ static_cast<VkCommandBuffer_T*>(pool.allocator.pfnAllocation(
+ pool.allocator.pUserData, sizeof(VkCommandBuffer_T),
+ alignof(VkCommandBuffer_T), VK_SYSTEM_ALLOCATION_SCOPE_OBJECT));
if (!cmdbufs[i]) {
result = VK_ERROR_OUT_OF_HOST_MEMORY;
break;
@@ -397,10 +400,10 @@
}
void FreeCommandBuffers(VkDevice /*device*/,
- VkCmdPool cmd_pool,
+ VkCommandPool cmd_pool,
uint32_t count,
- const VkCmdBuffer* cmdbufs) {
- CmdPool& pool = *GetCmdPoolFromHandle(cmd_pool);
+ const VkCommandBuffer* cmdbufs) {
+ CommandPool& pool = *GetCommandPoolFromHandle(cmd_pool);
for (uint32_t i = 0; i < count; i++)
pool.allocator.pfnFree(pool.allocator.pUserData, cmdbufs[i]);
}
@@ -415,19 +418,19 @@
};
DEFINE_OBJECT_HANDLE_CONVERSION(DeviceMemory)
-VkResult AllocMemory(VkDevice device,
- const VkMemoryAllocInfo* alloc_info,
- const VkAllocCallbacks* allocator,
- VkDeviceMemory* mem_handle) {
+VkResult AllocateMemory(VkDevice device,
+ const VkMemoryAllocateInfo* alloc_info,
+ const VkAllocationCallbacks* allocator,
+ VkDeviceMemory* mem_handle) {
if (SIZE_MAX - sizeof(DeviceMemory) <= alloc_info->allocationSize)
return VK_ERROR_OUT_OF_HOST_MEMORY;
if (!allocator)
allocator = &device->allocator;
size_t size = sizeof(DeviceMemory) + size_t(alloc_info->allocationSize);
- DeviceMemory* mem = static_cast<DeviceMemory*>(
- allocator->pfnAlloc(allocator->pUserData, size, alignof(DeviceMemory),
- VK_SYSTEM_ALLOC_SCOPE_OBJECT));
+ DeviceMemory* mem = static_cast<DeviceMemory*>(allocator->pfnAllocation(
+ allocator->pUserData, size, alignof(DeviceMemory),
+ VK_SYSTEM_ALLOCATION_SCOPE_OBJECT));
if (!mem)
return VK_ERROR_OUT_OF_HOST_MEMORY;
mem->size = size;
@@ -437,7 +440,7 @@
void FreeMemory(VkDevice device,
VkDeviceMemory mem_handle,
- const VkAllocCallbacks* allocator) {
+ const VkAllocationCallbacks* allocator) {
if (!allocator)
allocator = &device->allocator;
DeviceMemory* mem = GetDeviceMemoryFromHandle(mem_handle);
@@ -466,7 +469,7 @@
VkResult CreateBuffer(VkDevice device,
const VkBufferCreateInfo* create_info,
- const VkAllocCallbacks* allocator,
+ const VkAllocationCallbacks* allocator,
VkBuffer* buffer_handle) {
ALOGW_IF(create_info->size > kMaxDeviceMemory,
"CreateBuffer: requested size 0x%" PRIx64
@@ -474,9 +477,9 @@
create_info->size, kMaxDeviceMemory);
if (!allocator)
allocator = &device->allocator;
- Buffer* buffer = static_cast<Buffer*>(
- allocator->pfnAlloc(allocator->pUserData, sizeof(Buffer),
- alignof(Buffer), VK_SYSTEM_ALLOC_SCOPE_OBJECT));
+ Buffer* buffer = static_cast<Buffer*>(allocator->pfnAllocation(
+ allocator->pUserData, sizeof(Buffer), alignof(Buffer),
+ VK_SYSTEM_ALLOCATION_SCOPE_OBJECT));
if (!buffer)
return VK_ERROR_OUT_OF_HOST_MEMORY;
buffer->size = create_info->size;
@@ -495,7 +498,7 @@
void DestroyBuffer(VkDevice device,
VkBuffer buffer_handle,
- const VkAllocCallbacks* allocator) {
+ const VkAllocationCallbacks* allocator) {
if (!allocator)
allocator = &device->allocator;
Buffer* buffer = GetBufferFromHandle(buffer_handle);
@@ -513,7 +516,7 @@
VkResult CreateImage(VkDevice device,
const VkImageCreateInfo* create_info,
- const VkAllocCallbacks* allocator,
+ const VkAllocationCallbacks* allocator,
VkImage* image_handle) {
if (create_info->imageType != VK_IMAGE_TYPE_2D ||
create_info->format != VK_FORMAT_R8G8B8A8_UNORM ||
@@ -534,9 +537,9 @@
if (!allocator)
allocator = &device->allocator;
- Image* image = static_cast<Image*>(
- allocator->pfnAlloc(allocator->pUserData, sizeof(Image), alignof(Image),
- VK_SYSTEM_ALLOC_SCOPE_OBJECT));
+ Image* image = static_cast<Image*>(allocator->pfnAllocation(
+ allocator->pUserData, sizeof(Image), alignof(Image),
+ VK_SYSTEM_ALLOCATION_SCOPE_OBJECT));
if (!image)
return VK_ERROR_OUT_OF_HOST_MEMORY;
image->size = size;
@@ -555,7 +558,7 @@
void DestroyImage(VkDevice device,
VkImage image_handle,
- const VkAllocCallbacks* allocator) {
+ const VkAllocationCallbacks* allocator) {
if (!allocator)
allocator = &device->allocator;
Image* image = GetImageFromHandle(image_handle);
@@ -567,7 +570,7 @@
VkResult CreateBufferView(VkDevice device,
const VkBufferViewCreateInfo*,
- const VkAllocCallbacks* /*allocator*/,
+ const VkAllocationCallbacks* /*allocator*/,
VkBufferView* view) {
*view = AllocHandle(device, HandleType::kBufferView);
return VK_SUCCESS;
@@ -575,15 +578,15 @@
VkResult CreateDescriptorPool(VkDevice device,
const VkDescriptorPoolCreateInfo*,
- const VkAllocCallbacks* /*allocator*/,
+ const VkAllocationCallbacks* /*allocator*/,
VkDescriptorPool* pool) {
*pool = AllocHandle(device, HandleType::kDescriptorPool);
return VK_SUCCESS;
}
-VkResult AllocDescriptorSets(VkDevice device,
- const VkDescriptorSetAllocInfo* alloc_info,
- VkDescriptorSet* descriptor_sets) {
+VkResult AllocateDescriptorSets(VkDevice device,
+ const VkDescriptorSetAllocateInfo* alloc_info,
+ VkDescriptorSet* descriptor_sets) {
for (uint32_t i = 0; i < alloc_info->setLayoutCount; i++)
descriptor_sets[i] = AllocHandle(device, HandleType::kDescriptorSet);
return VK_SUCCESS;
@@ -591,7 +594,7 @@
VkResult CreateDescriptorSetLayout(VkDevice device,
const VkDescriptorSetLayoutCreateInfo*,
- const VkAllocCallbacks* /*allocator*/,
+ const VkAllocationCallbacks* /*allocator*/,
VkDescriptorSetLayout* layout) {
*layout = AllocHandle(device, HandleType::kDescriptorSetLayout);
return VK_SUCCESS;
@@ -599,7 +602,7 @@
VkResult CreateEvent(VkDevice device,
const VkEventCreateInfo*,
- const VkAllocCallbacks* /*allocator*/,
+ const VkAllocationCallbacks* /*allocator*/,
VkEvent* event) {
*event = AllocHandle(device, HandleType::kEvent);
return VK_SUCCESS;
@@ -607,7 +610,7 @@
VkResult CreateFence(VkDevice device,
const VkFenceCreateInfo*,
- const VkAllocCallbacks* /*allocator*/,
+ const VkAllocationCallbacks* /*allocator*/,
VkFence* fence) {
*fence = AllocHandle(device, HandleType::kFence);
return VK_SUCCESS;
@@ -615,7 +618,7 @@
VkResult CreateFramebuffer(VkDevice device,
const VkFramebufferCreateInfo*,
- const VkAllocCallbacks* /*allocator*/,
+ const VkAllocationCallbacks* /*allocator*/,
VkFramebuffer* framebuffer) {
*framebuffer = AllocHandle(device, HandleType::kFramebuffer);
return VK_SUCCESS;
@@ -623,7 +626,7 @@
VkResult CreateImageView(VkDevice device,
const VkImageViewCreateInfo*,
- const VkAllocCallbacks* /*allocator*/,
+ const VkAllocationCallbacks* /*allocator*/,
VkImageView* view) {
*view = AllocHandle(device, HandleType::kImageView);
return VK_SUCCESS;
@@ -633,7 +636,7 @@
VkPipelineCache,
uint32_t count,
const VkGraphicsPipelineCreateInfo*,
- const VkAllocCallbacks* /*allocator*/,
+ const VkAllocationCallbacks* /*allocator*/,
VkPipeline* pipelines) {
for (uint32_t i = 0; i < count; i++)
pipelines[i] = AllocHandle(device, HandleType::kPipeline);
@@ -644,7 +647,7 @@
VkPipelineCache,
uint32_t count,
const VkComputePipelineCreateInfo*,
- const VkAllocCallbacks* /*allocator*/,
+ const VkAllocationCallbacks* /*allocator*/,
VkPipeline* pipelines) {
for (uint32_t i = 0; i < count; i++)
pipelines[i] = AllocHandle(device, HandleType::kPipeline);
@@ -653,7 +656,7 @@
VkResult CreatePipelineCache(VkDevice device,
const VkPipelineCacheCreateInfo*,
- const VkAllocCallbacks* /*allocator*/,
+ const VkAllocationCallbacks* /*allocator*/,
VkPipelineCache* cache) {
*cache = AllocHandle(device, HandleType::kPipelineCache);
return VK_SUCCESS;
@@ -661,7 +664,7 @@
VkResult CreatePipelineLayout(VkDevice device,
const VkPipelineLayoutCreateInfo*,
- const VkAllocCallbacks* /*allocator*/,
+ const VkAllocationCallbacks* /*allocator*/,
VkPipelineLayout* layout) {
*layout = AllocHandle(device, HandleType::kPipelineLayout);
return VK_SUCCESS;
@@ -669,7 +672,7 @@
VkResult CreateQueryPool(VkDevice device,
const VkQueryPoolCreateInfo*,
- const VkAllocCallbacks* /*allocator*/,
+ const VkAllocationCallbacks* /*allocator*/,
VkQueryPool* pool) {
*pool = AllocHandle(device, HandleType::kQueryPool);
return VK_SUCCESS;
@@ -677,7 +680,7 @@
VkResult CreateRenderPass(VkDevice device,
const VkRenderPassCreateInfo*,
- const VkAllocCallbacks* /*allocator*/,
+ const VkAllocationCallbacks* /*allocator*/,
VkRenderPass* renderpass) {
*renderpass = AllocHandle(device, HandleType::kRenderPass);
return VK_SUCCESS;
@@ -685,7 +688,7 @@
VkResult CreateSampler(VkDevice device,
const VkSamplerCreateInfo*,
- const VkAllocCallbacks* /*allocator*/,
+ const VkAllocationCallbacks* /*allocator*/,
VkSampler* sampler) {
*sampler = AllocHandle(device, HandleType::kSampler);
return VK_SUCCESS;
@@ -693,7 +696,7 @@
VkResult CreateSemaphore(VkDevice device,
const VkSemaphoreCreateInfo*,
- const VkAllocCallbacks* /*allocator*/,
+ const VkAllocationCallbacks* /*allocator*/,
VkSemaphore* semaphore) {
*semaphore = AllocHandle(device, HandleType::kSemaphore);
return VK_SUCCESS;
@@ -701,7 +704,7 @@
VkResult CreateShader(VkDevice device,
const VkShaderCreateInfo*,
- const VkAllocCallbacks* /*allocator*/,
+ const VkAllocationCallbacks* /*allocator*/,
VkShader* shader) {
*shader = AllocHandle(device, HandleType::kShader);
return VK_SUCCESS;
@@ -709,7 +712,7 @@
VkResult CreateShaderModule(VkDevice device,
const VkShaderModuleCreateInfo*,
- const VkAllocCallbacks* /*allocator*/,
+ const VkAllocationCallbacks* /*allocator*/,
VkShaderModule* module) {
*module = AllocHandle(device, HandleType::kShaderModule);
return VK_SUCCESS;
@@ -820,7 +823,7 @@
return VK_SUCCESS;
}
-void DestroyFence(VkDevice device, VkFence fence, const VkAllocCallbacks* allocator) {
+void DestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* allocator) {
}
VkResult ResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) {
@@ -836,10 +839,10 @@
return VK_SUCCESS;
}
-void DestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocCallbacks* allocator) {
+void DestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* allocator) {
}
-void DestroyEvent(VkDevice device, VkEvent event, const VkAllocCallbacks* allocator) {
+void DestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* allocator) {
}
VkResult GetEventStatus(VkDevice device, VkEvent event) {
@@ -857,7 +860,7 @@
return VK_SUCCESS;
}
-void DestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocCallbacks* allocator) {
+void DestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* allocator) {
}
VkResult GetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) {
@@ -865,23 +868,23 @@
return VK_SUCCESS;
}
-void DestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocCallbacks* allocator) {
+void DestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* allocator) {
}
void GetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) {
ALOGV("TODO: vk%s", __FUNCTION__);
}
-void DestroyImageView(VkDevice device, VkImageView imageView, const VkAllocCallbacks* allocator) {
+void DestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* allocator) {
}
-void DestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocCallbacks* allocator) {
+void DestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* allocator) {
}
-void DestroyShader(VkDevice device, VkShader shader, const VkAllocCallbacks* allocator) {
+void DestroyShader(VkDevice device, VkShader shader, const VkAllocationCallbacks* allocator) {
}
-void DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocCallbacks* allocator) {
+void DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* allocator) {
}
VkResult GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) {
@@ -894,19 +897,19 @@
return VK_SUCCESS;
}
-void DestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocCallbacks* allocator) {
+void DestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* allocator) {
}
-void DestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocCallbacks* allocator) {
+void DestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* allocator) {
}
-void DestroySampler(VkDevice device, VkSampler sampler, const VkAllocCallbacks* allocator) {
+void DestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* allocator) {
}
-void DestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocCallbacks* allocator) {
+void DestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* allocator) {
}
-void DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocCallbacks* allocator) {
+void DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* allocator) {
}
VkResult ResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) {
@@ -923,164 +926,164 @@
return VK_SUCCESS;
}
-void DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocCallbacks* allocator) {
+void DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* allocator) {
}
-void DestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocCallbacks* allocator) {
+void DestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* allocator) {
}
void GetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) {
ALOGV("TODO: vk%s", __FUNCTION__);
}
-VkResult ResetCommandPool(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags) {
+VkResult ResetCommandPool(VkDevice device, VkCommandPool cmdPool, VkCommandPoolResetFlags flags) {
ALOGV("TODO: vk%s", __FUNCTION__);
return VK_SUCCESS;
}
-VkResult BeginCommandBuffer(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo) {
+VkResult BeginCommandBuffer(VkCommandBuffer cmdBuffer, const VkCommandBufferBeginInfo* pBeginInfo) {
return VK_SUCCESS;
}
-VkResult EndCommandBuffer(VkCmdBuffer cmdBuffer) {
+VkResult EndCommandBuffer(VkCommandBuffer cmdBuffer) {
return VK_SUCCESS;
}
-VkResult ResetCommandBuffer(VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags) {
+VkResult ResetCommandBuffer(VkCommandBuffer cmdBuffer, VkCommandBufferResetFlags flags) {
ALOGV("TODO: vk%s", __FUNCTION__);
return VK_SUCCESS;
}
-void CmdBindPipeline(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {
+void CmdBindPipeline(VkCommandBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {
}
-void CmdSetViewport(VkCmdBuffer cmdBuffer, uint32_t viewportCount, const VkViewport* pViewports) {
+void CmdSetViewport(VkCommandBuffer cmdBuffer, uint32_t viewportCount, const VkViewport* pViewports) {
}
-void CmdSetScissor(VkCmdBuffer cmdBuffer, uint32_t scissorCount, const VkRect2D* pScissors) {
+void CmdSetScissor(VkCommandBuffer cmdBuffer, uint32_t scissorCount, const VkRect2D* pScissors) {
}
-void CmdSetLineWidth(VkCmdBuffer cmdBuffer, float lineWidth) {
+void CmdSetLineWidth(VkCommandBuffer cmdBuffer, float lineWidth) {
}
-void CmdSetDepthBias(VkCmdBuffer cmdBuffer, float depthBias, float depthBiasClamp, float slopeScaledDepthBias) {
+void CmdSetDepthBias(VkCommandBuffer cmdBuffer, float depthBias, float depthBiasClamp, float slopeScaledDepthBias) {
}
-void CmdSetBlendConstants(VkCmdBuffer cmdBuffer, const float blendConst[4]) {
+void CmdSetBlendConstants(VkCommandBuffer cmdBuffer, const float blendConst[4]) {
}
-void CmdSetDepthBounds(VkCmdBuffer cmdBuffer, float minDepthBounds, float maxDepthBounds) {
+void CmdSetDepthBounds(VkCommandBuffer cmdBuffer, float minDepthBounds, float maxDepthBounds) {
}
-void CmdSetStencilCompareMask(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask) {
+void CmdSetStencilCompareMask(VkCommandBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask) {
}
-void CmdSetStencilWriteMask(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask) {
+void CmdSetStencilWriteMask(VkCommandBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask) {
}
-void CmdSetStencilReference(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference) {
+void CmdSetStencilReference(VkCommandBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference) {
}
-void CmdBindDescriptorSets(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) {
+void CmdBindDescriptorSets(VkCommandBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) {
}
-void CmdBindIndexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) {
+void CmdBindIndexBuffer(VkCommandBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) {
}
-void CmdBindVertexBuffers(VkCmdBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) {
+void CmdBindVertexBuffers(VkCommandBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) {
}
-void CmdDraw(VkCmdBuffer cmdBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) {
+void CmdDraw(VkCommandBuffer cmdBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) {
}
-void CmdDrawIndexed(VkCmdBuffer cmdBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) {
+void CmdDrawIndexed(VkCommandBuffer cmdBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) {
}
-void CmdDrawIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride) {
+void CmdDrawIndirect(VkCommandBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride) {
}
-void CmdDrawIndexedIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride) {
+void CmdDrawIndexedIndirect(VkCommandBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride) {
}
-void CmdDispatch(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z) {
+void CmdDispatch(VkCommandBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z) {
}
-void CmdDispatchIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset) {
+void CmdDispatchIndirect(VkCommandBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset) {
}
-void CmdCopyBuffer(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) {
+void CmdCopyBuffer(VkCommandBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) {
}
-void CmdCopyImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) {
+void CmdCopyImage(VkCommandBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) {
}
-void CmdBlitImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) {
+void CmdBlitImage(VkCommandBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) {
}
-void CmdCopyBufferToImage(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
+void CmdCopyBufferToImage(VkCommandBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
}
-void CmdCopyImageToBuffer(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
+void CmdCopyImageToBuffer(VkCommandBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) {
}
-void CmdUpdateBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData) {
+void CmdUpdateBuffer(VkCommandBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData) {
}
-void CmdFillBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data) {
+void CmdFillBuffer(VkCommandBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data) {
}
-void CmdClearColorImage(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
+void CmdClearColorImage(VkCommandBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
}
-void CmdClearDepthStencilImage(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
+void CmdClearDepthStencilImage(VkCommandBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) {
}
-void CmdClearAttachments(VkCmdBuffer cmdBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) {
+void CmdClearAttachments(VkCommandBuffer cmdBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) {
}
-void CmdResolveImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) {
+void CmdResolveImage(VkCommandBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) {
}
-void CmdSetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
+void CmdSetEvent(VkCommandBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
}
-void CmdResetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
+void CmdResetEvent(VkCommandBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask) {
}
-void CmdWaitEvents(VkCmdBuffer cmdBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, uint32_t memBarrierCount, const void* const* ppMemBarriers) {
+void CmdWaitEvents(VkCommandBuffer cmdBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, uint32_t memBarrierCount, const void* const* ppMemBarriers) {
}
-void CmdPipelineBarrier(VkCmdBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkDependencyFlags dependencyFlags, uint32_t memBarrierCount, const void* const* ppMemBarriers) {
+void CmdPipelineBarrier(VkCommandBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkDependencyFlags dependencyFlags, uint32_t memBarrierCount, const void* const* ppMemBarriers) {
}
-void CmdBeginQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags) {
+void CmdBeginQuery(VkCommandBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags) {
}
-void CmdEndQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot) {
+void CmdEndQuery(VkCommandBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot) {
}
-void CmdResetQueryPool(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount) {
+void CmdResetQueryPool(VkCommandBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount) {
}
-void CmdWriteTimestamp(VkCmdBuffer cmdBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot) {
+void CmdWriteTimestamp(VkCommandBuffer cmdBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot) {
}
-void CmdCopyQueryPoolResults(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags) {
+void CmdCopyQueryPoolResults(VkCommandBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags) {
}
-void CmdPushConstants(VkCmdBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t start, uint32_t length, const void* values) {
+void CmdPushConstants(VkCommandBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t start, uint32_t length, const void* values) {
}
-void CmdBeginRenderPass(VkCmdBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents) {
+void CmdBeginRenderPass(VkCommandBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents) {
}
-void CmdNextSubpass(VkCmdBuffer cmdBuffer, VkRenderPassContents contents) {
+void CmdNextSubpass(VkCommandBuffer cmdBuffer, VkRenderPassContents contents) {
}
-void CmdEndRenderPass(VkCmdBuffer cmdBuffer) {
+void CmdEndRenderPass(VkCommandBuffer cmdBuffer) {
}
-void CmdExecuteCommands(VkCmdBuffer cmdBuffer, uint32_t cmdBuffersCount, const VkCmdBuffer* pCmdBuffers) {
+void CmdExecuteCommands(VkCommandBuffer cmdBuffer, uint32_t cmdBuffersCount, const VkCommandBuffer* pCmdBuffers) {
}
#pragma clang diagnostic pop
diff --git a/vulkan/nulldrv/null_driver.h b/vulkan/nulldrv/null_driver.h
index 5f3e53e..939a559 100644
--- a/vulkan/nulldrv/null_driver.h
+++ b/vulkan/nulldrv/null_driver.h
@@ -27,7 +27,7 @@
PFN_vkVoidFunction LookupDeviceProcAddr(const char* name);
// clang-format off
-void DestroyInstance(VkInstance instance, const VkAllocCallbacks* allocator);
+void DestroyInstance(VkInstance instance, const VkAllocationCallbacks* allocator);
VkResult EnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
void GetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
void GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
@@ -37,8 +37,8 @@
void GetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const char* pName);
PFN_vkVoidFunction GetDeviceProcAddr(VkDevice device, const char* pName);
-VkResult CreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkDevice* pDevice);
-void DestroyDevice(VkDevice device, const VkAllocCallbacks* allocator);
+VkResult CreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkDevice* pDevice);
+void DestroyDevice(VkDevice device, const VkAllocationCallbacks* allocator);
VkResult EnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties);
VkResult EnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pCount, VkExtensionProperties* pProperties);
VkResult EnumerateInstanceLayerProperties(uint32_t* pCount, VkLayerProperties* pProperties);
@@ -47,8 +47,8 @@
VkResult QueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmitInfo, VkFence fence);
VkResult QueueWaitIdle(VkQueue queue);
VkResult DeviceWaitIdle(VkDevice device);
-VkResult AllocMemory(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, const VkAllocCallbacks* allocator, VkDeviceMemory* pMem);
-void FreeMemory(VkDevice device, VkDeviceMemory mem, const VkAllocCallbacks* allocator);
+VkResult AllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocInfo, const VkAllocationCallbacks* allocator, VkDeviceMemory* pMem);
+void FreeMemory(VkDevice device, VkDeviceMemory mem, const VkAllocationCallbacks* allocator);
VkResult MapMemory(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData);
void UnmapMemory(VkDevice device, VkDeviceMemory mem);
VkResult FlushMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges);
@@ -61,110 +61,110 @@
void GetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
void GetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties);
VkResult QueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence);
-VkResult CreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkFence* pFence);
-void DestroyFence(VkDevice device, VkFence fence, const VkAllocCallbacks* allocator);
+VkResult CreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkFence* pFence);
+void DestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* allocator);
VkResult ResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences);
VkResult GetFenceStatus(VkDevice device, VkFence fence);
VkResult WaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout);
-VkResult CreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkSemaphore* pSemaphore);
-void DestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocCallbacks* allocator);
-VkResult CreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkEvent* pEvent);
-void DestroyEvent(VkDevice device, VkEvent event, const VkAllocCallbacks* allocator);
+VkResult CreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkSemaphore* pSemaphore);
+void DestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* allocator);
+VkResult CreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkEvent* pEvent);
+void DestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* allocator);
VkResult GetEventStatus(VkDevice device, VkEvent event);
VkResult SetEvent(VkDevice device, VkEvent event);
VkResult ResetEvent(VkDevice device, VkEvent event);
-VkResult CreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkQueryPool* pQueryPool);
-void DestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocCallbacks* allocator);
+VkResult CreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkQueryPool* pQueryPool);
+void DestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* allocator);
VkResult GetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags);
-VkResult CreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkBuffer* pBuffer);
-void DestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocCallbacks* allocator);
-VkResult CreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkBufferView* pView);
-void DestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocCallbacks* allocator);
-VkResult CreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkImage* pImage);
-void DestroyImage(VkDevice device, VkImage image, const VkAllocCallbacks* allocator);
+VkResult CreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkBuffer* pBuffer);
+void DestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* allocator);
+VkResult CreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkBufferView* pView);
+void DestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* allocator);
+VkResult CreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkImage* pImage);
+void DestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* allocator);
void GetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
-VkResult CreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkImageView* pView);
-void DestroyImageView(VkDevice device, VkImageView imageView, const VkAllocCallbacks* allocator);
-VkResult CreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkShaderModule* pShaderModule);
-void DestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocCallbacks* allocator);
-VkResult CreateShader(VkDevice device, const VkShaderCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkShader* pShader);
-void DestroyShader(VkDevice device, VkShader shader, const VkAllocCallbacks* allocator);
-VkResult CreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkPipelineCache* pPipelineCache);
-void DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocCallbacks* allocator);
+VkResult CreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkImageView* pView);
+void DestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* allocator);
+VkResult CreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkShaderModule* pShaderModule);
+void DestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* allocator);
+VkResult CreateShader(VkDevice device, const VkShaderCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkShader* pShader);
+void DestroyShader(VkDevice device, VkShader shader, const VkAllocationCallbacks* allocator);
+VkResult CreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkPipelineCache* pPipelineCache);
+void DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* allocator);
VkResult GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData);
VkResult MergePipelineCaches(VkDevice device, VkPipelineCache destCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);
-VkResult CreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocCallbacks* allocator, VkPipeline* pPipelines);
-VkResult CreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocCallbacks* allocator, VkPipeline* pPipelines);
-void DestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocCallbacks* allocator);
-VkResult CreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkPipelineLayout* pPipelineLayout);
-void DestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocCallbacks* allocator);
-VkResult CreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkSampler* pSampler);
-void DestroySampler(VkDevice device, VkSampler sampler, const VkAllocCallbacks* allocator);
-VkResult CreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkDescriptorSetLayout* pSetLayout);
-void DestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocCallbacks* allocator);
-VkResult CreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkDescriptorPool* pDescriptorPool);
-void DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocCallbacks* allocator);
+VkResult CreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* allocator, VkPipeline* pPipelines);
+VkResult CreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* allocator, VkPipeline* pPipelines);
+void DestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* allocator);
+VkResult CreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkPipelineLayout* pPipelineLayout);
+void DestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* allocator);
+VkResult CreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkSampler* pSampler);
+void DestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* allocator);
+VkResult CreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkDescriptorSetLayout* pSetLayout);
+void DestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* allocator);
+VkResult CreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkDescriptorPool* pDescriptorPool);
+void DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* allocator);
VkResult ResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags);
-VkResult AllocDescriptorSets(VkDevice device, const VkDescriptorSetAllocInfo* pAllocInfo, VkDescriptorSet* pDescriptorSets);
+VkResult AllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocInfo, VkDescriptorSet* pDescriptorSets);
VkResult FreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets);
void UpdateDescriptorSets(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies);
-VkResult CreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkFramebuffer* pFramebuffer);
-void DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocCallbacks* allocator);
-VkResult CreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkRenderPass* pRenderPass);
-void DestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocCallbacks* allocator);
+VkResult CreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkFramebuffer* pFramebuffer);
+void DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* allocator);
+VkResult CreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkRenderPass* pRenderPass);
+void DestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* allocator);
void GetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
-VkResult CreateCommandPool(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, const VkAllocCallbacks* allocator, VkCmdPool* pCmdPool);
-void DestroyCommandPool(VkDevice device, VkCmdPool cmdPool, const VkAllocCallbacks* allocator);
-VkResult ResetCommandPool(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags);
-VkResult AllocCommandBuffers(VkDevice device, const VkCmdBufferAllocInfo* pAllocInfo, VkCmdBuffer* pCmdBuffers);
-void FreeCommandBuffers(VkDevice device, VkCmdPool cmdPool, uint32_t count, const VkCmdBuffer* pCommandBuffers);
-VkResult BeginCommandBuffer(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo);
-VkResult EndCommandBuffer(VkCmdBuffer cmdBuffer);
-VkResult ResetCommandBuffer(VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags);
-void CmdBindPipeline(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
-void CmdSetViewport(VkCmdBuffer cmdBuffer, uint32_t viewportCount, const VkViewport* pViewports);
-void CmdSetScissor(VkCmdBuffer cmdBuffer, uint32_t scissorCount, const VkRect2D* pScissors);
-void CmdSetLineWidth(VkCmdBuffer cmdBuffer, float lineWidth);
-void CmdSetDepthBias(VkCmdBuffer cmdBuffer, float depthBias, float depthBiasClamp, float slopeScaledDepthBias);
-void CmdSetBlendConstants(VkCmdBuffer cmdBuffer, const float blendConst[4]);
-void CmdSetDepthBounds(VkCmdBuffer cmdBuffer, float minDepthBounds, float maxDepthBounds);
-void CmdSetStencilCompareMask(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask);
-void CmdSetStencilWriteMask(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask);
-void CmdSetStencilReference(VkCmdBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference);
-void CmdBindDescriptorSets(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets);
-void CmdBindIndexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
-void CmdBindVertexBuffers(VkCmdBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
-void CmdDraw(VkCmdBuffer cmdBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);
-void CmdDrawIndexed(VkCmdBuffer cmdBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);
-void CmdDrawIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride);
-void CmdDrawIndexedIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride);
-void CmdDispatch(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z);
-void CmdDispatchIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset);
-void CmdCopyBuffer(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions);
-void CmdCopyImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions);
-void CmdBlitImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter);
-void CmdCopyBufferToImage(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions);
-void CmdCopyImageToBuffer(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions);
-void CmdUpdateBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData);
-void CmdFillBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data);
-void CmdClearColorImage(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
-void CmdClearDepthStencilImage(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
-void CmdClearAttachments(VkCmdBuffer cmdBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects);
-void CmdResolveImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions);
-void CmdSetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask);
-void CmdResetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask);
-void CmdWaitEvents(VkCmdBuffer cmdBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, uint32_t memBarrierCount, const void* const* ppMemBarriers);
-void CmdPipelineBarrier(VkCmdBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkDependencyFlags dependencyFlags, uint32_t memBarrierCount, const void* const* ppMemBarriers);
-void CmdBeginQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags);
-void CmdEndQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot);
-void CmdResetQueryPool(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount);
-void CmdWriteTimestamp(VkCmdBuffer cmdBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot);
-void CmdCopyQueryPoolResults(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags);
-void CmdPushConstants(VkCmdBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t start, uint32_t length, const void* values);
-void CmdBeginRenderPass(VkCmdBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents);
-void CmdNextSubpass(VkCmdBuffer cmdBuffer, VkRenderPassContents contents);
-void CmdEndRenderPass(VkCmdBuffer cmdBuffer);
-void CmdExecuteCommands(VkCmdBuffer cmdBuffer, uint32_t cmdBuffersCount, const VkCmdBuffer* pCmdBuffers);
+VkResult CreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* allocator, VkCommandPool* pCmdPool);
+void DestroyCommandPool(VkDevice device, VkCommandPool cmdPool, const VkAllocationCallbacks* allocator);
+VkResult ResetCommandPool(VkDevice device, VkCommandPool cmdPool, VkCommandPoolResetFlags flags);
+VkResult AllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocInfo, VkCommandBuffer* pCmdBuffers);
+void FreeCommandBuffers(VkDevice device, VkCommandPool cmdPool, uint32_t count, const VkCommandBuffer* pCommandBuffers);
+VkResult BeginCommandBuffer(VkCommandBuffer cmdBuffer, const VkCommandBufferBeginInfo* pBeginInfo);
+VkResult EndCommandBuffer(VkCommandBuffer cmdBuffer);
+VkResult ResetCommandBuffer(VkCommandBuffer cmdBuffer, VkCommandBufferResetFlags flags);
+void CmdBindPipeline(VkCommandBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
+void CmdSetViewport(VkCommandBuffer cmdBuffer, uint32_t viewportCount, const VkViewport* pViewports);
+void CmdSetScissor(VkCommandBuffer cmdBuffer, uint32_t scissorCount, const VkRect2D* pScissors);
+void CmdSetLineWidth(VkCommandBuffer cmdBuffer, float lineWidth);
+void CmdSetDepthBias(VkCommandBuffer cmdBuffer, float depthBias, float depthBiasClamp, float slopeScaledDepthBias);
+void CmdSetBlendConstants(VkCommandBuffer cmdBuffer, const float blendConst[4]);
+void CmdSetDepthBounds(VkCommandBuffer cmdBuffer, float minDepthBounds, float maxDepthBounds);
+void CmdSetStencilCompareMask(VkCommandBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask);
+void CmdSetStencilWriteMask(VkCommandBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask);
+void CmdSetStencilReference(VkCommandBuffer cmdBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference);
+void CmdBindDescriptorSets(VkCommandBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets);
+void CmdBindIndexBuffer(VkCommandBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
+void CmdBindVertexBuffers(VkCommandBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
+void CmdDraw(VkCommandBuffer cmdBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);
+void CmdDrawIndexed(VkCommandBuffer cmdBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);
+void CmdDrawIndirect(VkCommandBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride);
+void CmdDrawIndexedIndirect(VkCommandBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride);
+void CmdDispatch(VkCommandBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z);
+void CmdDispatchIndirect(VkCommandBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset);
+void CmdCopyBuffer(VkCommandBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions);
+void CmdCopyImage(VkCommandBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions);
+void CmdBlitImage(VkCommandBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter);
+void CmdCopyBufferToImage(VkCommandBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions);
+void CmdCopyImageToBuffer(VkCommandBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions);
+void CmdUpdateBuffer(VkCommandBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData);
+void CmdFillBuffer(VkCommandBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data);
+void CmdClearColorImage(VkCommandBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
+void CmdClearDepthStencilImage(VkCommandBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
+void CmdClearAttachments(VkCommandBuffer cmdBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects);
+void CmdResolveImage(VkCommandBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions);
+void CmdSetEvent(VkCommandBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask);
+void CmdResetEvent(VkCommandBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask);
+void CmdWaitEvents(VkCommandBuffer cmdBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, uint32_t memBarrierCount, const void* const* ppMemBarriers);
+void CmdPipelineBarrier(VkCommandBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkDependencyFlags dependencyFlags, uint32_t memBarrierCount, const void* const* ppMemBarriers);
+void CmdBeginQuery(VkCommandBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags);
+void CmdEndQuery(VkCommandBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot);
+void CmdResetQueryPool(VkCommandBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount);
+void CmdWriteTimestamp(VkCommandBuffer cmdBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot);
+void CmdCopyQueryPoolResults(VkCommandBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkQueryResultFlags flags);
+void CmdPushConstants(VkCommandBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t start, uint32_t length, const void* values);
+void CmdBeginRenderPass(VkCommandBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents);
+void CmdNextSubpass(VkCommandBuffer cmdBuffer, VkRenderPassContents contents);
+void CmdEndRenderPass(VkCommandBuffer cmdBuffer);
+void CmdExecuteCommands(VkCommandBuffer cmdBuffer, uint32_t cmdBuffersCount, const VkCommandBuffer* pCmdBuffers);
VkResult GetSwapchainGrallocUsageANDROID(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, int* grallocUsage);
VkResult AcquireImageANDROID(VkDevice device, VkImage image, int nativeFenceFd, VkSemaphore semaphore);
diff --git a/vulkan/nulldrv/null_driver_gen.cpp b/vulkan/nulldrv/null_driver_gen.cpp
index f836a70..9b1b042 100644
--- a/vulkan/nulldrv/null_driver_gen.cpp
+++ b/vulkan/nulldrv/null_driver_gen.cpp
@@ -67,9 +67,9 @@
const NameProcEntry kDeviceProcTbl[] = {
// clang-format off
- {"vkAllocCommandBuffers", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkAllocCommandBuffers>(AllocCommandBuffers))},
- {"vkAllocDescriptorSets", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkAllocDescriptorSets>(AllocDescriptorSets))},
- {"vkAllocMemory", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkAllocMemory>(AllocMemory))},
+ {"vkAllocateCommandBuffers", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkAllocateCommandBuffers>(AllocateCommandBuffers))},
+ {"vkAllocateDescriptorSets", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkAllocateDescriptorSets>(AllocateDescriptorSets))},
+ {"vkAllocateMemory", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkAllocateMemory>(AllocateMemory))},
{"vkBeginCommandBuffer", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkBeginCommandBuffer>(BeginCommandBuffer))},
{"vkBindBufferMemory", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkBindBufferMemory>(BindBufferMemory))},
{"vkBindImageMemory", reinterpret_cast<PFN_vkVoidFunction>(static_cast<PFN_vkBindImageMemory>(BindImageMemory))},
diff --git a/vulkan/tools/vkinfo.cpp b/vulkan/tools/vkinfo.cpp
index eaec272..838d0e2 100644
--- a/vulkan/tools/vkinfo.cpp
+++ b/vulkan/tools/vkinfo.cpp
@@ -157,7 +157,7 @@
const VkInstanceCreateInfo create_info = {
.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO,
.pNext = nullptr,
- .pAppInfo = nullptr,
+ .pApplicationInfo = nullptr,
.enabledLayerNameCount = 0,
.ppEnabledLayerNames = nullptr,
.enabledExtensionNameCount = 0,