///////////////
// API version (major.minor.patch)
-define VERSION_MAJOR 0
-define VERSION_MINOR 221
+define VERSION_MAJOR 1
+define VERSION_MINOR 0
define VERSION_PATCH 0
// API limits
}
enum VkSamplerMipmapMode {
- VK_SAMPLER_MIPMAP_MODE_BASE = 0x00000000, /// Always choose base level
VK_SAMPLER_MIPMAP_MODE_NEAREST = 0x00000001, /// Choose nearest mip level
VK_SAMPLER_MIPMAP_MODE_LINEAR = 0x00000002, /// Linear filter between mip levels
}
VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38,
VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39,
VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40,
- VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 41,
- VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 42,
- VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 43,
- VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 44,
- VK_STRUCTURE_TYPE_MEMORY_BARRIER = 45,
- VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 46,
- VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 47,
+ VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_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,
+ VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46,
+ VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47,
+ VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48,
//@extension("VK_KHR_swapchain")
VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000,
}
class VkExtent2D {
- s32 width
- s32 height
+ u32 width
+ u32 height
}
class VkExtent3D {
- s32 width
- s32 height
- s32 depth
+ u32 width
+ u32 height
+ u32 depth
}
class VkViewport {
VkDeviceCreateFlags flags
u32 queueCreateInfoCount
const VkDeviceQueueCreateInfo* pQueueCreateInfos
- u32 enabledLayerNameCount
+ u32 enabledLayerCount
const char* const* ppEnabledLayerNames /// Ordered list of layer names to be enabled
- u32 enabledExtensionNameCount
+ u32 enabledExtensionCount
const char* const* ppEnabledExtensionNames
const VkPhysicalDeviceFeatures* pEnabledFeatures
}
const void* pNext /// Pointer to next structure
VkInstanceCreateFlags flags
const VkApplicationInfo* pApplicationInfo
- u32 enabledLayerNameCount
+ u32 enabledLayerCount
const char* const* ppEnabledLayerNames /// Ordered list of layer names to be enabled
- u32 enabledExtensionNameCount
+ u32 enabledExtensionCount
const char* const* ppEnabledExtensionNames /// Extension names to be enabled
}
class VkImageBlit {
VkImageSubresourceLayers srcSubresource
- VkOffset3D srcOffset /// Specified in pixels for both compressed and uncompressed images
- VkExtent3D srcExtent /// Specified in pixels for both compressed and uncompressed images
+ VkOffset3D[2] srcOffsets
VkImageSubresourceLayers dstSubresource
- VkOffset3D dstOffset /// Specified in pixels for both compressed and uncompressed images
- VkExtent3D dstExtent /// Specified in pixels for both compressed and uncompressed images
+ VkOffset3D[2] dstOffsets
}
class VkBufferImageCopy {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO
const void* pNext /// Pointer to next structure
VkPipelineLayoutCreateFlags flags
- u32 setLayoutCount /// Number of descriptor sets interfaced by the pipeline
+ u32 descriptorSetCount /// Number of descriptor sets interfaced by the pipeline
const VkDescriptorSetLayout* pSetLayouts /// Array of <setCount> number of descriptor set layout objects defining the layout of the
u32 pushConstantRangeCount /// Number of push-constant ranges used by the pipeline
const VkPushConstantRange* pPushConstantRanges /// Array of pushConstantRangeCount number of ranges used by various shader stages
const void* pNext /// Pointer to next structure
VkCommandPool commandPool
VkCommandBufferLevel level
- u32 bufferCount
+ u32 commandBufferCount
}
-class VkCommandBufferBeginInfo {
- VkStructureType sType /// Must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO
+class VkCommandBufferInheritanceInfo {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO
const void* pNext /// Pointer to next structure
- VkCommandBufferUsageFlags flags /// Command buffer usage flags
VkRenderPass renderPass /// Render pass for secondary command buffers
u32 subpass
VkFramebuffer framebuffer /// Framebuffer for secondary command buffers
VkQueryPipelineStatisticFlags pipelineStatistics
}
+class VkCommandBufferBeginInfo {
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO
+ const void* pNext /// Pointer to next structure
+ VkCommandBufferUsageFlags flags /// Command buffer usage flags
+ const VkCommandBufferInheritanceInfo* pInheritanceInfo
+}
+
class VkRenderPassBeginInfo {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO
const void* pNext /// Pointer to next structure
const VkAttachmentReference* pResolveAttachments
const VkAttachmentReference* pDepthStencilAttachment
u32 preserveAttachmentCount
- const VkAttachmentReference* pPreserveAttachments
+ const u32* pPreserveAttachments
}
class VkSubpassDependency {
const void* pNext /// Pointer to next structure
VkQueryPoolCreateFlags flags
VkQueryType queryType
- u32 entryCount
+ u32 queryCount
VkQueryPipelineStatisticFlags pipelineStatistics /// Optional
}
pInstance[0] = instance
State.Instances[instance] = new!InstanceObject()
- layers := pCreateInfo.ppEnabledLayerNames[0:pCreateInfo.enabledLayerNameCount]
- extensions := pCreateInfo.ppEnabledExtensionNames[0:pCreateInfo.enabledExtensionNameCount]
+ layers := pCreateInfo.ppEnabledLayerNames[0:pCreateInfo.enabledLayerCount]
+ extensions := pCreateInfo.ppEnabledExtensionNames[0:pCreateInfo.enabledExtensionCount]
return ?
}
VkCommandBuffer* pCommandBuffers) {
assert(pAllocateInfo[0].sType == VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO)
- count := pAllocateInfo[0].bufferCount
+ count := pAllocateInfo[0].commandBufferCount
commandBuffers := pCommandBuffers[0:count]
for i in (0 .. count) {
commandBuffer := ?
VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask,
u32 memoryBarrierCount,
- const void* const* ppMemoryBarriers) {
+ const VkMemoryBarrier* pMemoryBarriers,
+ u32 bufferMemoryBarrierCount,
+ const VkBufferMemoryBarrier* pBufferMemoryBarriers,
+ u32 imageMemoryBarrierCount,
+ const VkImageMemoryBarrier* pImageMemoryBarriers) {
commandBufferObject := GetCommandBuffer(commandBuffer)
events := pEvents[0:eventCount]
assert(commandBufferObject.device == eventObject.device)
}
- pMemoryBarriers := ppMemoryBarriers[0:memoryBarrierCount]
+ memoryBarriers := pMemoryBarriers[0:memoryBarrierCount]
for i in (0 .. memoryBarrierCount) {
- switch as!VkMemoryBarrier const*(pMemoryBarriers[i])[0].sType {
- case VK_STRUCTURE_TYPE_MEMORY_BARRIER: {
- memoryBarrier := as!VkMemoryBarrier const*(pMemoryBarriers[i])[0]
- }
- case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER: {
- imageMemoryBarrier := as!VkImageMemoryBarrier const*(pMemoryBarriers[i])[0]
- imageObject := GetImage(imageMemoryBarrier.image)
- assert(imageObject.device == commandBufferObject.device)
- }
- case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER: {
- bufferMemoryBarrier := as!VkBufferMemoryBarrier const*(pMemoryBarriers[i])[0]
- bufferObject := GetBuffer(bufferMemoryBarrier.buffer)
- assert(bufferObject.device == commandBufferObject.device)
- }
- }
+ memoryBarrier := memoryBarriers[i]
+ }
+ bufferMemoryBarriers := pBufferMemoryBarriers[0:bufferMemoryBarrierCount]
+ for i in (0 .. bufferMemoryBarrierCount) {
+ bufferMemoryBarrier := bufferMemoryBarriers[i]
+ bufferObject := GetBuffer(bufferMemoryBarrier.buffer)
+ assert(bufferObject.device == commandBufferObject.device)
+ }
+ imageMemoryBarriers := pImageMemoryBarriers[0:imageMemoryBarrierCount]
+ for i in (0 .. imageMemoryBarrierCount) {
+ imageMemoryBarrier := imageMemoryBarriers[i]
+ imageObject := GetImage(imageMemoryBarrier.image)
+ assert(imageObject.device == commandBufferObject.device)
}
}
VkPipelineStageFlags dstStageMask,
VkDependencyFlags dependencyFlags,
u32 memoryBarrierCount,
- const void* const* ppMemoryBarriers) {
+ const VkMemoryBarrier* pMemoryBarriers,
+ u32 bufferMemoryBarrierCount,
+ const VkBufferMemoryBarrier* pBufferMemoryBarriers,
+ u32 imageMemoryBarrierCount,
+ const VkImageMemoryBarrier* pImageMemoryBarriers) {
commandBufferObject := GetCommandBuffer(commandBuffer)
- pMemoryBarriers := ppMemoryBarriers[0:memoryBarrierCount]
+ memoryBarriers := pMemoryBarriers[0:memoryBarrierCount]
for i in (0 .. memoryBarrierCount) {
- switch as!VkMemoryBarrier const*(pMemoryBarriers[i])[0].sType {
- case VK_STRUCTURE_TYPE_MEMORY_BARRIER: {
- memoryBarrier := as!VkMemoryBarrier const*(pMemoryBarriers[i])[0]
- }
- case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER: {
- imageMemoryBarrier := as!VkImageMemoryBarrier const*(pMemoryBarriers[i])[0]
- imageObject := GetImage(imageMemoryBarrier.image)
- assert(imageObject.device == commandBufferObject.device)
- }
- case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER: {
- bufferMemoryBarrier := as!VkBufferMemoryBarrier const*(pMemoryBarriers[i])[0]
- bufferObject := GetBuffer(bufferMemoryBarrier.buffer)
- assert(bufferObject.device == commandBufferObject.device)
- }
- }
+ memoryBarrier := memoryBarriers[i]
+ }
+ bufferMemoryBarriers := pBufferMemoryBarriers[0:bufferMemoryBarrierCount]
+ for i in (0 .. bufferMemoryBarrierCount) {
+ bufferMemoryBarrier := bufferMemoryBarriers[i]
+ bufferObject := GetBuffer(bufferMemoryBarrier.buffer)
+ assert(bufferObject.device == commandBufferObject.device)
+ }
+ imageMemoryBarriers := pImageMemoryBarriers[0:imageMemoryBarrierCount]
+ for i in (0 .. imageMemoryBarrierCount) {
+ imageMemoryBarrier := imageMemoryBarriers[i]
+ imageObject := GetImage(imageMemoryBarrier.image)
+ assert(imageObject.device == commandBufferObject.device)
}
}
cmd void vkCmdBeginQuery(
VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
- u32 entry,
+ u32 query,
VkQueryControlFlags flags) {
commandBufferObject := GetCommandBuffer(commandBuffer)
queryPoolObject := GetQueryPool(queryPool)
cmd void vkCmdEndQuery(
VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
- u32 entry) {
+ u32 query) {
commandBufferObject := GetCommandBuffer(commandBuffer)
queryPoolObject := GetQueryPool(queryPool)
assert(commandBufferObject.device == queryPoolObject.device)
VkCommandBuffer commandBuffer,
VkPipelineStageFlagBits pipelineStage,
VkQueryPool queryPool,
- u32 entry) {
+ u32 query) {
commandBufferObject := GetCommandBuffer(commandBuffer)
queryPoolObject := GetQueryPool(queryPool)
assert(commandBufferObject.device == queryPoolObject.device)
cmd void vkCmdExecuteCommands(
VkCommandBuffer commandBuffer,
- u32 commandBuffersCount,
+ u32 commandBufferCount,
const VkCommandBuffer* pCommandBuffers) {
commandBufferObject := GetCommandBuffer(commandBuffer)
- commandBuffers := pCommandBuffers[0:commandBuffersCount]
- for i in (0 .. commandBuffersCount) {
+ commandBuffers := pCommandBuffers[0:commandBufferCount]
+ for i in (0 .. commandBufferCount) {
secondaryCommandBuffer := commandBuffers[i]
secondaryCommandBufferObject := GetCommandBuffer(secondaryCommandBuffer)
assert(commandBufferObject.device == secondaryCommandBufferObject.device)
@extension("VK_KHR_display")
cmd VkResult vkGetDisplayPlaneSupportedDisplaysKHR(
VkPhysicalDevice physicalDevice,
+ u32 planeIndex,
u32* pDisplayCount,
VkDisplayKHR* pDisplays) {
physicalDeviceObject := GetPhysicalDevice(physicalDevice)
((major << 22) | (minor << 12) | patch)
// Vulkan API version supported by this file
-#define VK_API_VERSION VK_MAKE_VERSION(0, 221, 0)
+#define VK_API_VERSION VK_MAKE_VERSION(1, 0, 0)
#define VK_NULL_HANDLE 0
VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38,
VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39,
VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40,
- VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 41,
- VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 42,
- VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 43,
- VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 44,
- VK_STRUCTURE_TYPE_MEMORY_BARRIER = 45,
- VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 46,
- VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 47,
+ VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_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,
+ VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46,
+ VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47,
+ VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48,
VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000,
VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001,
VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000,
} VkFilter;
typedef enum VkSamplerMipmapMode {
- VK_SAMPLER_MIPMAP_MODE_BASE = 0,
- VK_SAMPLER_MIPMAP_MODE_NEAREST = 1,
- VK_SAMPLER_MIPMAP_MODE_LINEAR = 2,
- VK_SAMPLER_MIPMAP_MODE_BEGIN_RANGE = VK_SAMPLER_MIPMAP_MODE_BASE,
+ VK_SAMPLER_MIPMAP_MODE_NEAREST = 0,
+ VK_SAMPLER_MIPMAP_MODE_LINEAR = 1,
+ VK_SAMPLER_MIPMAP_MODE_BEGIN_RANGE = VK_SAMPLER_MIPMAP_MODE_NEAREST,
VK_SAMPLER_MIPMAP_MODE_END_RANGE = VK_SAMPLER_MIPMAP_MODE_LINEAR,
- VK_SAMPLER_MIPMAP_MODE_RANGE_SIZE = (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_NEAREST + 1),
VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF
} VkSamplerMipmapMode;
} VkShaderStageFlagBits;
typedef VkFlags VkPipelineVertexInputStateCreateFlags;
typedef VkFlags VkPipelineInputAssemblyStateCreateFlags;
-typedef VkFlags VkPipelineTesselationStateCreateFlags;
+typedef VkFlags VkPipelineTessellationStateCreateFlags;
typedef VkFlags VkPipelineViewportStateCreateFlags;
typedef VkFlags VkPipelineRasterizationStateCreateFlags;
const void* pNext;
VkInstanceCreateFlags flags;
const VkApplicationInfo* pApplicationInfo;
- uint32_t enabledLayerNameCount;
+ uint32_t enabledLayerCount;
const char* const* ppEnabledLayerNames;
- uint32_t enabledExtensionNameCount;
+ uint32_t enabledExtensionCount;
const char* const* ppEnabledExtensionNames;
} VkInstanceCreateInfo;
} VkFormatProperties;
typedef struct VkExtent3D {
- int32_t width;
- int32_t height;
- int32_t depth;
+ uint32_t width;
+ uint32_t height;
+ uint32_t depth;
} VkExtent3D;
typedef struct VkImageFormatProperties {
VkDeviceCreateFlags flags;
uint32_t queueCreateInfoCount;
const VkDeviceQueueCreateInfo* pQueueCreateInfos;
- uint32_t enabledLayerNameCount;
+ uint32_t enabledLayerCount;
const char* const* ppEnabledLayerNames;
- uint32_t enabledExtensionNameCount;
+ uint32_t enabledExtensionCount;
const char* const* ppEnabledExtensionNames;
const VkPhysicalDeviceFeatures* pEnabledFeatures;
} VkDeviceCreateInfo;
const void* pNext;
VkQueryPoolCreateFlags flags;
VkQueryType queryType;
- uint32_t entryCount;
+ uint32_t queryCount;
VkQueryPipelineStatisticFlags pipelineStatistics;
} VkQueryPoolCreateInfo;
typedef struct VkPipelineTessellationStateCreateInfo {
VkStructureType sType;
const void* pNext;
- VkPipelineTesselationStateCreateFlags flags;
+ VkPipelineTessellationStateCreateFlags flags;
uint32_t patchControlPoints;
} VkPipelineTessellationStateCreateInfo;
} VkOffset2D;
typedef struct VkExtent2D {
- int32_t width;
- int32_t height;
+ uint32_t width;
+ uint32_t height;
} VkExtent2D;
typedef struct VkRect2D {
VkStructureType sType;
const void* pNext;
VkDescriptorPool descriptorPool;
- uint32_t setLayoutCount;
+ uint32_t descriptorSetCount;
const VkDescriptorSetLayout* pSetLayouts;
} VkDescriptorSetAllocateInfo;
const VkAttachmentReference* pResolveAttachments;
const VkAttachmentReference* pDepthStencilAttachment;
uint32_t preserveAttachmentCount;
- const VkAttachmentReference* pPreserveAttachments;
+ const uint32_t* pPreserveAttachments;
} VkSubpassDescription;
typedef struct VkSubpassDependency {
const void* pNext;
VkCommandPool commandPool;
VkCommandBufferLevel level;
- uint32_t bufferCount;
+ uint32_t commandBufferCount;
} VkCommandBufferAllocateInfo;
-typedef struct VkCommandBufferBeginInfo {
+typedef struct VkCommandBufferInheritanceInfo {
VkStructureType sType;
const void* pNext;
- VkCommandBufferUsageFlags flags;
VkRenderPass renderPass;
uint32_t subpass;
VkFramebuffer framebuffer;
VkBool32 occlusionQueryEnable;
VkQueryControlFlags queryFlags;
VkQueryPipelineStatisticFlags pipelineStatistics;
+} VkCommandBufferInheritanceInfo;
+
+typedef struct VkCommandBufferBeginInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkCommandBufferUsageFlags flags;
+ const VkCommandBufferInheritanceInfo* pInheritanceInfo;
} VkCommandBufferBeginInfo;
typedef struct VkBufferCopy {
typedef struct VkImageBlit {
VkImageSubresourceLayers srcSubresource;
- VkOffset3D srcOffset;
- VkExtent3D srcExtent;
+ VkOffset3D srcOffsets[2];
VkImageSubresourceLayers dstSubresource;
- VkOffset3D dstOffset;
- VkExtent3D dstExtent;
+ VkOffset3D dstOffsets[2];
} VkImageBlit;
typedef struct VkBufferImageCopy {
VkExtent3D extent;
} VkImageResolve;
-typedef struct VkRenderPassBeginInfo {
+typedef struct VkMemoryBarrier {
VkStructureType sType;
const void* pNext;
- VkRenderPass renderPass;
- VkFramebuffer framebuffer;
- VkRect2D renderArea;
- uint32_t clearValueCount;
- const VkClearValue* pClearValues;
-} VkRenderPassBeginInfo;
+ VkAccessFlags srcAccessMask;
+ VkAccessFlags dstAccessMask;
+} VkMemoryBarrier;
typedef struct VkBufferMemoryBarrier {
VkStructureType sType;
VkDeviceSize size;
} VkBufferMemoryBarrier;
+typedef struct VkImageMemoryBarrier {
+ VkStructureType sType;
+ const void* pNext;
+ VkAccessFlags srcAccessMask;
+ VkAccessFlags dstAccessMask;
+ VkImageLayout oldLayout;
+ VkImageLayout newLayout;
+ uint32_t srcQueueFamilyIndex;
+ uint32_t dstQueueFamilyIndex;
+ VkImage image;
+ VkImageSubresourceRange subresourceRange;
+} VkImageMemoryBarrier;
+
+typedef struct VkRenderPassBeginInfo {
+ VkStructureType sType;
+ const void* pNext;
+ VkRenderPass renderPass;
+ VkFramebuffer framebuffer;
+ VkRect2D renderArea;
+ uint32_t clearValueCount;
+ const VkClearValue* pClearValues;
+} VkRenderPassBeginInfo;
+
typedef struct VkDispatchIndirectCommand {
uint32_t x;
uint32_t y;
uint32_t firstInstance;
} VkDrawIndirectCommand;
-typedef struct VkImageMemoryBarrier {
- VkStructureType sType;
- const void* pNext;
- VkAccessFlags srcAccessMask;
- VkAccessFlags dstAccessMask;
- VkImageLayout oldLayout;
- VkImageLayout newLayout;
- uint32_t srcQueueFamilyIndex;
- uint32_t dstQueueFamilyIndex;
- VkImage image;
- VkImageSubresourceRange subresourceRange;
-} VkImageMemoryBarrier;
-
-typedef struct VkMemoryBarrier {
- VkStructureType sType;
- const void* pNext;
- VkAccessFlags srcAccessMask;
- VkAccessFlags dstAccessMask;
-} VkMemoryBarrier;
-
typedef VkResult (VKAPI_PTR *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance);
typedef void (VKAPI_PTR *PFN_vkDestroyInstance)(VkInstance instance, const VkAllocationCallbacks* pAllocator);
typedef void (VKAPI_PTR *PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions);
typedef void (VKAPI_PTR *PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
typedef void (VKAPI_PTR *PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
-typedef void (VKAPI_PTR *PFN_vkCmdWaitEvents)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const void* const* ppMemoryBarriers);
-typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier)(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const void* const* ppMemoryBarriers);
-typedef void (VKAPI_PTR *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t entry, VkQueryControlFlags flags);
-typedef void (VKAPI_PTR *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t entry);
+typedef void (VKAPI_PTR *PFN_vkCmdWaitEvents)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers);
+typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier)(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers);
+typedef void (VKAPI_PTR *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags);
+typedef void (VKAPI_PTR *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query);
typedef void (VKAPI_PTR *PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount);
-typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t entry);
+typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query);
typedef void (VKAPI_PTR *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags);
typedef void (VKAPI_PTR *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues);
typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents);
typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkSubpassContents contents);
typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer);
-typedef void (VKAPI_PTR *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBuffersCount, const VkCommandBuffer* pCommandBuffers);
+typedef void (VKAPI_PTR *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);
#ifdef VK_PROTOTYPES
VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(
VkPipelineStageFlags srcStageMask,
VkPipelineStageFlags dstStageMask,
uint32_t memoryBarrierCount,
- const void* const* ppMemoryBarriers);
+ const VkMemoryBarrier* pMemoryBarriers,
+ uint32_t bufferMemoryBarrierCount,
+ const VkBufferMemoryBarrier* pBufferMemoryBarriers,
+ uint32_t imageMemoryBarrierCount,
+ const VkImageMemoryBarrier* pImageMemoryBarriers);
VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier(
VkCommandBuffer commandBuffer,
VkPipelineStageFlags dstStageMask,
VkDependencyFlags dependencyFlags,
uint32_t memoryBarrierCount,
- const void* const* ppMemoryBarriers);
+ const VkMemoryBarrier* pMemoryBarriers,
+ uint32_t bufferMemoryBarrierCount,
+ const VkBufferMemoryBarrier* pBufferMemoryBarriers,
+ uint32_t imageMemoryBarrierCount,
+ const VkImageMemoryBarrier* pImageMemoryBarriers);
VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery(
VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
- uint32_t entry,
+ uint32_t query,
VkQueryControlFlags flags);
VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery(
VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
- uint32_t entry);
+ uint32_t query);
VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool(
VkCommandBuffer commandBuffer,
VkCommandBuffer commandBuffer,
VkPipelineStageFlagBits pipelineStage,
VkQueryPool queryPool,
- uint32_t entry);
+ uint32_t query);
VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults(
VkCommandBuffer commandBuffer,
VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands(
VkCommandBuffer commandBuffer,
- uint32_t commandBuffersCount,
+ uint32_t commandBufferCount,
const VkCommandBuffer* pCommandBuffers);
#endif
typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties);
typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties);
-typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays);
+typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays);
typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties);
typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR*pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode);
typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities);
VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneSupportedDisplaysKHR(
VkPhysicalDevice physicalDevice,
+ uint32_t planeIndex,
uint32_t* pDisplayCount,
VkDisplayKHR* pDisplays);
}
__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const void* const* ppMemoryBarriers) {
- GetDispatchTable(commandBuffer).CmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, ppMemoryBarriers);
+VKAPI_ATTR void vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) {
+ GetDispatchTable(commandBuffer).CmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
}
__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const void* const* ppMemoryBarriers) {
- GetDispatchTable(commandBuffer).CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, ppMemoryBarriers);
+VKAPI_ATTR void vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) {
+ GetDispatchTable(commandBuffer).CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
}
__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t entry, VkQueryControlFlags flags) {
- GetDispatchTable(commandBuffer).CmdBeginQuery(commandBuffer, queryPool, entry, flags);
+VKAPI_ATTR void vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags) {
+ GetDispatchTable(commandBuffer).CmdBeginQuery(commandBuffer, queryPool, query, flags);
}
__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t entry) {
- GetDispatchTable(commandBuffer).CmdEndQuery(commandBuffer, queryPool, entry);
+VKAPI_ATTR void vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) {
+ GetDispatchTable(commandBuffer).CmdEndQuery(commandBuffer, queryPool, query);
}
__attribute__((visibility("default")))
}
__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t entry) {
- GetDispatchTable(commandBuffer).CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, entry);
+VKAPI_ATTR void vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query) {
+ GetDispatchTable(commandBuffer).CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query);
}
__attribute__((visibility("default")))
}
__attribute__((visibility("default")))
-VKAPI_ATTR void vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBuffersCount, const VkCommandBuffer* pCommandBuffers) {
- GetDispatchTable(commandBuffer).CmdExecuteCommands(commandBuffer, commandBuffersCount, pCommandBuffers);
+VKAPI_ATTR void vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) {
+ GetDispatchTable(commandBuffer).CmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers);
}
__attribute__((visibility("default")))
}
}
// Load app layers
- for (uint32_t i = 0; i < create_info->enabledLayerNameCount; ++i) {
+ for (uint32_t i = 0; i < create_info->enabledLayerCount; ++i) {
if (!ActivateLayer(object, create_info->ppEnabledLayerNames[i])) {
ALOGE("requested %s layer '%s' not present",
create_info->sType == VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO
bool AddExtensionToCreateInfo(TCreateInfo& local_create_info,
const char* extension_name,
const VkAllocationCallbacks* alloc) {
- for (uint32_t i = 0; i < local_create_info.enabledExtensionNameCount; ++i) {
+ for (uint32_t i = 0; i < local_create_info.enabledExtensionCount; ++i) {
if (!strcmp(extension_name,
local_create_info.ppEnabledExtensionNames[i])) {
return false;
}
}
- uint32_t extension_count = local_create_info.enabledExtensionNameCount;
- local_create_info.enabledExtensionNameCount++;
+ uint32_t extension_count = local_create_info.enabledExtensionCount;
+ local_create_info.enabledExtensionCount++;
void* mem = alloc->pfnAllocation(
alloc->pUserData,
- local_create_info.enabledExtensionNameCount * sizeof(char*),
- alignof(char*), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
+ local_create_info.enabledExtensionCount * sizeof(char*), 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) {
} else {
ALOGW("%s extension cannot be enabled: memory allocation failed",
extension_name);
- local_create_info.enabledExtensionNameCount--;
+ local_create_info.enabledExtensionCount--;
return false;
}
return true;
table.AllocateCommandBuffers(vkdevice, alloc_info, cmdbufs);
if (result != VK_SUCCESS)
return result;
- for (uint32_t i = 0; i < alloc_info->bufferCount; i++) {
+ for (uint32_t i = 0; i < alloc_info->commandBufferCount; i++) {
hwvulkan_dispatch_t* cmdbuf_dispatch =
reinterpret_cast<hwvulkan_dispatch_t*>(cmdbufs[i]);
ALOGE_IF(cmdbuf_dispatch->magic != HWVULKAN_DISPATCH_MAGIC,
return VK_ERROR_INITIALIZATION_FAILED;
}
- capabilities->currentExtent = VkExtent2D{width, height};
+ capabilities->currentExtent =
+ VkExtent2D{static_cast<uint32_t>(width), static_cast<uint32_t>(height)};
// TODO(jessehall): Figure out what the min/max values should be.
capabilities->minImageCount = 2;
Surface& surface = *SurfaceFromHandle(create_info->surface);
const DriverDispatchTable& dispatch = GetDriverDispatch(device);
- err = native_window_set_buffers_dimensions(surface.window.get(),
- create_info->imageExtent.width,
- create_info->imageExtent.height);
+ err = native_window_set_buffers_dimensions(
+ surface.window.get(), static_cast<int>(create_info->imageExtent.width),
+ static_cast<int>(create_info->imageExtent.height));
if (err != 0) {
// TODO(jessehall): Improve error reporting. Can we enumerate possible
// errors and translate them to valid Vulkan result codes?
img.dequeued = true;
image_create.extent =
- VkExtent3D{img.buffer->width, img.buffer->height, 1};
+ VkExtent3D{static_cast<uint32_t>(img.buffer->width),
+ static_cast<uint32_t>(img.buffer->height),
+ 1};
image_native_buffer.handle = img.buffer->handle;
image_native_buffer.stride = img.buffer->stride;
image_native_buffer.format = img.buffer->format;
VkCommandBuffer* cmdbufs) {
VkResult result = VK_SUCCESS;
CommandPool& pool = *GetCommandPoolFromHandle(alloc_info->commandPool);
- std::fill(cmdbufs, cmdbufs + alloc_info->bufferCount, nullptr);
- for (uint32_t i = 0; i < alloc_info->bufferCount; i++) {
+ std::fill(cmdbufs, cmdbufs + alloc_info->commandBufferCount, nullptr);
+ for (uint32_t i = 0; i < alloc_info->commandBufferCount; i++) {
cmdbufs[i] =
static_cast<VkCommandBuffer_T*>(pool.allocator.pfnAllocation(
pool.allocator.pUserData, sizeof(VkCommandBuffer_T),
cmdbufs[i]->dispatch.magic = HWVULKAN_DISPATCH_MAGIC;
}
if (result != VK_SUCCESS) {
- for (uint32_t i = 0; i < alloc_info->bufferCount; i++) {
+ for (uint32_t i = 0; i < alloc_info->commandBufferCount; i++) {
if (!cmdbufs[i])
break;
pool.allocator.pfnFree(pool.allocator.pUserData, cmdbufs[i]);
VkResult AllocateDescriptorSets(VkDevice device,
const VkDescriptorSetAllocateInfo* alloc_info,
VkDescriptorSet* descriptor_sets) {
- for (uint32_t i = 0; i < alloc_info->setLayoutCount; i++)
+ for (uint32_t i = 0; i < alloc_info->descriptorSetCount; i++)
descriptor_sets[i] =
AllocHandle<VkDescriptorSet>(device, HandleType::kDescriptorSet);
return VK_SUCCESS;
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 CmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) {
}
-void CmdPipelineBarrier(VkCommandBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkDependencyFlags dependencyFlags, uint32_t memBarrierCount, const void* const* ppMemBarriers) {
+void CmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) {
}
void CmdBeginQuery(VkCommandBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags) {
VKAPI_ATTR void CmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions);
VKAPI_ATTR void CmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
VKAPI_ATTR void CmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
-VKAPI_ATTR void CmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const void* const* ppMemoryBarriers);
-VKAPI_ATTR void CmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const void* const* ppMemoryBarriers);
-VKAPI_ATTR void CmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t entry, VkQueryControlFlags flags);
-VKAPI_ATTR void CmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t entry);
+VKAPI_ATTR void CmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers);
+VKAPI_ATTR void CmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers);
+VKAPI_ATTR void CmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags);
+VKAPI_ATTR void CmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query);
VKAPI_ATTR void CmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount);
-VKAPI_ATTR void CmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t entry);
+VKAPI_ATTR void CmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query);
VKAPI_ATTR void CmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags);
VKAPI_ATTR void CmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues);
VKAPI_ATTR void CmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents);
VKAPI_ATTR void CmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents);
VKAPI_ATTR void CmdEndRenderPass(VkCommandBuffer commandBuffer);
-VKAPI_ATTR void CmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBuffersCount, const VkCommandBuffer* pCommandBuffers);
+VKAPI_ATTR void CmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);
VKAPI_ATTR VkResult GetSwapchainGrallocUsageANDROID(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, int* grallocUsage);
VKAPI_ATTR VkResult AcquireImageANDROID(VkDevice device, VkImage image, int nativeFenceFd, VkSemaphore semaphore, VkFence fence);
VKAPI_ATTR VkResult QueueSignalReleaseImageANDROID(VkQueue queue, VkImage image, int* pNativeFenceFd);