// API version (major.minor.patch)
define VERSION_MAJOR 0
-define VERSION_MINOR 197
+define VERSION_MINOR 198
define VERSION_PATCH 0
// API limits
-define VK_MAX_PHYSICAL_DEVICE_NAME 256
-define VK_UUID_LENGTH 16
-define VK_MAX_EXTENSION_NAME 256
-define VK_MAX_DESCRIPTION 256
-define VK_MAX_MEMORY_TYPES 32
-define VK_MAX_MEMORY_HEAPS 16 /// The maximum number of unique memory heaps, each of which supporting 1 or more memory types.
+define VK_MAX_PHYSICAL_DEVICE_NAME_SIZE 256
+define VK_UUID_SIZE 16
+define VK_MAX_EXTENSION_NAME_SIZE 256
+define VK_MAX_DESCRIPTION_SIZE 256
+define VK_MAX_MEMORY_TYPES 32
+define VK_MAX_MEMORY_HEAPS 16 /// The maximum number of unique memory heaps, each of which supporting 1 or more memory types.
// API keywords
define VK_TRUE 1
VK_COMMAND_BUFFER_LEVEL_SECONDARY = 0x00000001,
}
-enum VkChannelSwizzle {
- VK_CHANNEL_SWIZZLE_IDENTITY = 0x00000000,
- VK_CHANNEL_SWIZZLE_ZERO = 0x00000001,
- VK_CHANNEL_SWIZZLE_ONE = 0x00000002,
- VK_CHANNEL_SWIZZLE_R = 0x00000003,
- VK_CHANNEL_SWIZZLE_G = 0x00000004,
- VK_CHANNEL_SWIZZLE_B = 0x00000005,
- VK_CHANNEL_SWIZZLE_A = 0x00000006,
+enum VkComponentSwizzle {
+ VK_COMPONENT_SWIZZLE_IDENTITY = 0x00000000,
+ VK_COMPONENT_SWIZZLE_ZERO = 0x00000001,
+ VK_COMPONENT_SWIZZLE_ONE = 0x00000002,
+ VK_COMPONENT_SWIZZLE_R = 0x00000003,
+ VK_COMPONENT_SWIZZLE_G = 0x00000004,
+ VK_COMPONENT_SWIZZLE_B = 0x00000005,
+ VK_COMPONENT_SWIZZLE_A = 0x00000006,
}
enum VkDescriptorType {
VK_COMPARE_OP_ALWAYS = 0x00000007,
}
-enum VkFillMode {
- VK_FILL_MODE_SOLID = 0x00000000,
- VK_FILL_MODE_WIREFRAME = 0x00000001,
- VK_FILL_MODE_POINTS = 0x00000002,
+enum VkPolygonMode {
+ VK_POLYGON_MODE_FILL = 0x00000000,
+ VK_POLYGON_MODE_LINE = 0x00000001,
+ VK_POLYGON_MODE_POINT = 0x00000002,
}
enum VkFrontFace {
VK_FRONT_FACE_CLOCKWISE = 0x00000001,
}
-enum VkBlend {
- VK_BLEND_ZERO = 0x00000000,
- VK_BLEND_ONE = 0x00000001,
- VK_BLEND_SRC_COLOR = 0x00000002,
- VK_BLEND_ONE_MINUS_SRC_COLOR = 0x00000003,
- 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_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,
- VK_BLEND_ONE_MINUS_CONSTANT_ALPHA = 0x0000000d,
- VK_BLEND_SRC_ALPHA_SATURATE = 0x0000000e,
- VK_BLEND_SRC1_COLOR = 0x0000000f,
- VK_BLEND_ONE_MINUS_SRC1_COLOR = 0x00000010,
- VK_BLEND_SRC1_ALPHA = 0x00000011,
- VK_BLEND_ONE_MINUS_SRC1_ALPHA = 0x00000012,
+enum VkBlendFactor {
+ VK_BLEND_FACTOR_ZERO = 0x00000000,
+ VK_BLEND_FACTOR_ONE = 0x00000001,
+ VK_BLEND_FACTOR_SRC_COLOR = 0x00000002,
+ VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 0x00000003,
+ VK_BLEND_FACTOR_DST_COLOR = 0x00000004,
+ VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 0x00000005,
+ VK_BLEND_FACTOR_SRC_ALPHA = 0x00000006,
+ VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 0x00000007,
+ VK_BLEND_FACTOR_DST_ALPHA = 0x00000008,
+ VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 0x00000009,
+ VK_BLEND_FACTOR_CONSTANT_COLOR = 0x0000000a,
+ VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 0x0000000b,
+ VK_BLEND_FACTOR_CONSTANT_ALPHA = 0x0000000c,
+ VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 0x0000000d,
+ VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 0x0000000e,
+ VK_BLEND_FACTOR_SRC1_COLOR = 0x0000000f,
+ VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 0x00000010,
+ VK_BLEND_FACTOR_SRC1_ALPHA = 0x00000011,
+ VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 0x00000012,
}
enum VkBlendOp {
VK_PHYSICAL_DEVICE_TYPE_CPU = 0x00000004,
}
-enum VkVertexInputStepRate {
- VK_VERTEX_INPUT_STEP_RATE_VERTEX = 0x00000000,
- VK_VERTEX_INPUT_STEP_RATE_INSTANCE = 0x00000001,
+enum VkVertexInputRate {
+ VK_VERTEX_INPUT_RATE_VERTEX = 0x00000000,
+ VK_VERTEX_INPUT_RATE_INSTANCE = 0x00000001,
}
/// Vulkan format definitions
VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 21,
VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 22,
VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 23,
- VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO = 24,
+ VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 24,
VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 25,
VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 26,
VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 27,
VK_STRUCTURE_TYPE_DISPLAY_DISPLAY_PRESENT_INFO_KHR = 0xc0001001,
}
-enum VkRenderPassContents {
- VK_RENDER_PASS_CONTENTS_INLINE = 0x00000000,
- VK_RENDER_PASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 0x00000001,
+enum VkSubpassContents {
+ VK_SUBPASS_CONTENTS_INLINE = 0x00000000,
+ VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 0x00000001,
}
@lastUnused(-8)
bitfield VkQueueFlagBits {
VK_QUEUE_GRAPHICS_BIT = 0x00000001, /// Queue supports graphics operations
VK_QUEUE_COMPUTE_BIT = 0x00000002, /// Queue supports compute operations
- VK_QUEUE_DMA_BIT = 0x00000004, /// Queue supports DMA operations
+ VK_QUEUE_TRANSFER_BIT = 0x00000004, /// Queue supports transfer operations
VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008, /// Queue supports sparse resource memory management operations
}
VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004,
}
-/// Channel flags
-type VkFlags VkChannelFlags
-bitfield VkChannelFlagBits {
- VK_CHANNEL_R_BIT = 0x00000001,
- VK_CHANNEL_G_BIT = 0x00000002,
- VK_CHANNEL_B_BIT = 0x00000004,
- VK_CHANNEL_A_BIT = 0x00000008,
+/// Color component flags
+type VkFlags VkColorComponentFlags
+bitfield VkColorComponentFlagBits {
+ VK_COLOR_COMPONENT_R_BIT = 0x00000001,
+ VK_COLOR_COMPONENT_G_BIT = 0x00000002,
+ VK_COLOR_COMPONENT_B_BIT = 0x00000004,
+ VK_COLOR_COMPONENT_A_BIT = 0x00000008,
}
/// Fence creation flags
/// Query control flags
type VkFlags VkQueryControlFlags
bitfield VkQueryControlFlagBits {
- VK_QUERY_CONTROL_CONSERVATIVE_BIT = 0x00000001, /// Allow conservative results to be collected by the query
+ VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001,
}
/// Query result flags
}
class VkViewport {
- f32 originX
- f32 originY
+ f32 x
+ f32 y
f32 width
f32 height
f32 minDepth
u32 layerCount
}
-class VkChannelMapping {
- VkChannelSwizzle r
- VkChannelSwizzle g
- VkChannelSwizzle b
- VkChannelSwizzle a
+class VkComponentMapping {
+ VkComponentSwizzle r
+ VkComponentSwizzle g
+ VkComponentSwizzle b
+ VkComponentSwizzle a
}
class VkPhysicalDeviceProperties {
u32 apiVersion
u32 driverVersion
- u32 vendorId
- u32 deviceId
+ u32 vendorID
+ u32 deviceID
VkPhysicalDeviceType deviceType
- char[VK_MAX_PHYSICAL_DEVICE_NAME] deviceName
- u8[VK_UUID_LENGTH] pipelineCacheUUID
+ char[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE] deviceName
+ u8[VK_UUID_SIZE] pipelineCacheUUID
VkPhysicalDeviceLimits limits
VkPhysicalDeviceSparseProperties sparseProperties
}
class VkExtensionProperties {
- char[VK_MAX_EXTENSION_NAME] extensionName /// extension name
+ char[VK_MAX_EXTENSION_NAME_SIZE] extensionName /// extension name
u32 specVersion /// version of the extension specification implemented
}
class VkLayerProperties {
- char[VK_MAX_EXTENSION_NAME] layerName /// layer name
+ char[VK_MAX_EXTENSION_NAME_SIZE] 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
+ char[VK_MAX_DESCRIPTION_SIZE] description /// Free-form description of the layer
}
class VkSubmitInfo {
VkQueueFlags queueFlags /// Queue flags
u32 queueCount
u32 timestampValidBits
+ VkExtent3D minImageTransferGranularity
}
class VkPhysicalDeviceMemoryProperties {
class VkSparseImageMemoryRequirements {
VkSparseImageFormatProperties formatProperties
- u32 imageMipTailStartLOD
+ u32 imageMipTailStartLod
VkDeviceSize imageMipTailSize /// Specified in bytes, must be a multiple of image block size / alignment
VkDeviceSize imageMipTailOffset /// Specified in bytes, must be a multiple of image block size / alignment
VkDeviceSize imageMipTailStride /// Specified in bytes, must be a multiple of image block size / alignment
VkImage image
VkImageViewType viewType
VkFormat format
- VkChannelMapping channels
+ VkComponentMapping components
VkImageSubresourceRange subresourceRange
}
const VkSemaphore* pSignalSemaphores
}
-class VkImageSubresourceCopy {
- VkImageAspectFlags aspect
+class VkImageSubresourceLayers {
+ VkImageAspectFlags aspectMask
u32 mipLevel
u32 baseArrayLayer
u32 layerCount
}
class VkImageCopy {
- VkImageSubresourceCopy srcSubresource
+ VkImageSubresourceLayers srcSubresource
VkOffset3D srcOffset /// Specified in pixels for both compressed and uncompressed images
- VkImageSubresourceCopy dstSubresource
+ VkImageSubresourceLayers dstSubresource
VkOffset3D dstOffset /// Specified in pixels for both compressed and uncompressed images
VkExtent3D extent /// Specified in pixels for both compressed and uncompressed images
}
class VkImageBlit {
- VkImageSubresourceCopy srcSubresource
+ VkImageSubresourceLayers srcSubresource
VkOffset3D srcOffset /// Specified in pixels for both compressed and uncompressed images
VkExtent3D srcExtent /// Specified in pixels for both compressed and uncompressed images
- VkImageSubresourceCopy dstSubresource
+ VkImageSubresourceLayers dstSubresource
VkOffset3D dstOffset /// Specified in pixels for both compressed and uncompressed images
VkExtent3D dstExtent /// Specified in pixels for both compressed and uncompressed images
}
VkDeviceSize bufferOffset /// Specified in bytes
u32 bufferRowLength /// Specified in texels
u32 bufferImageHeight
- VkImageSubresourceCopy imageSubresource
+ VkImageSubresourceLayers imageSubresource
VkOffset3D imageOffset /// Specified in pixels for both compressed and uncompressed images
VkExtent3D imageExtent /// Specified in pixels for both compressed and uncompressed images
}
class VkImageResolve {
- VkImageSubresourceCopy srcSubresource
+ VkImageSubresourceLayers srcSubresource
VkOffset3D srcOffset
- VkImageSubresourceCopy dstSubresource
+ VkImageSubresourceLayers dstSubresource
VkOffset3D dstOffset
VkExtent3D extent
}
const VkDescriptorSetLayoutBinding* pBindings /// Array of descriptor set layout bindings
}
-class VkDescriptorTypeCount {
+class VkDescriptorPoolSize {
VkDescriptorType type
u32 descriptorCount
}
const void* pNext /// Pointer to next structure
VkDescriptorPoolCreateFlags flags
u32 maxSets
- u32 typeCount
- const VkDescriptorTypeCount* pTypeCounts
+ u32 poolSizeCount
+ const VkDescriptorPoolSize* pPoolSizes
}
class VkDescriptorSetAllocateInfo {
}
class VkSpecializationMapEntry {
- u32 constantId /// The SpecConstant ID specified in the BIL
+ u32 constantID /// The SpecConstant ID specified in the BIL
u32 offset /// Offset of the value in the data block
platform.size_t size /// Size in bytes of the SpecConstant
}
class VkVertexInputBindingDescription {
u32 binding /// Vertex buffer binding id
u32 stride /// Distance between vertices in bytes (0 = no advancement)
- VkVertexInputStepRate stepRate /// Rate at which binding is incremented
+ VkVertexInputRate inputRate /// Rate at which binding is incremented
}
class VkVertexInputAttributeDescription {
}
class VkPipelineRasterizationStateCreateInfo {
- VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO
+ VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO
const void* pNext /// Pointer to next structure
VkPipelineRasterizationStateCreateFlags flags
VkBool32 depthClampEnable
VkBool32 rasterizerDiscardEnable
- VkFillMode fillMode /// optional (GL45)
+ VkPolygonMode polygonMode /// optional (GL45)
VkCullModeFlags cullMode
VkFrontFace frontFace
VkBool32 depthBiasEnable
class VkPipelineColorBlendAttachmentState {
VkBool32 blendEnable
- VkBlend srcBlendColor
- VkBlend dstBlendColor
- VkBlendOp blendOpColor
- VkBlend srcBlendAlpha
- VkBlend dstBlendAlpha
- VkBlendOp blendOpAlpha
- VkChannelFlags channelWriteMask
+ VkBlendFactor srcColorBlendFactor
+ VkBlendFactor dstColorBlendFactor
+ VkBlendOp colorBlendOp
+ VkBlendFactor srcAlphaBlendFactor
+ VkBlendFactor dstAlphaBlendFactor
+ VkBlendOp alphaBlendOp
+ VkColorComponentFlags colorWriteMask
}
class VkPipelineColorBlendStateCreateInfo {
}
class VkStencilOpState {
- VkStencilOp stencilFailOp
- VkStencilOp stencilPassOp
- VkStencilOp stencilDepthFailOp
- VkCompareOp stencilCompareOp
- u32 stencilCompareMask
- u32 stencilWriteMask
- u32 stencilReference
+ VkStencilOp failOp
+ VkStencilOp passOp
+ VkStencilOp depthFailOp
+ VkCompareOp compareOp
+ u32 compareMask
+ u32 writeMask
+ u32 reference
}
class VkPipelineDepthStencilStateCreateInfo {
VkBool32 textureCompressionETC2 /// ETC texture compression formats
VkBool32 textureCompressionASTC_LDR /// ASTC LDR texture compression formats
VkBool32 textureCompressionBC /// BC1-7 texture compressed formats
- VkBool32 occlusionQueryNonConservative /// non-conservative (exact) occlusion queries
+ VkBool32 occlusionQueryPrecise
VkBool32 pipelineStatisticsQuery /// pipeline statistics query
VkBool32 vertexPipelineStoresAndAtomics
VkBool32 fragmentStoresAndAtomics
VkBool32 shaderInt64 /// 64-bit integers in shaders
VkBool32 shaderInt16 /// 16-bit integers in shaders
VkBool32 shaderResourceResidency /// shader can use texture operations that return resource residency information (requires sparseNonResident support)
- VkBool32 shaderResourceMinLOD /// shader can use texture operations that specify minimum resource LOD
+ VkBool32 shaderResourceMinLod /// shader can use texture operations that specify minimum resource LOD
VkBool32 sparseBinding /// Sparse resources support: Resource memory can be managed at opaque page level rather than object level
VkBool32 sparseResidencyBuffer /// Sparse resources support: GPU can access partially resident buffers
VkBool32 sparseResidencyImage2D /// Sparse resources support: GPU can access partially resident 2D (non-MSAA non-DepthStencil) images
f32 lineWidthGranularity /// granularity of supported line widths
VkBool32 strictLines
- VkDeviceSize recommendedBufferCopyOffsetAlignment
- VkDeviceSize recommendedBufferCopyRowPitchAlignment
+ VkDeviceSize optimalBufferCopyOffsetAlignment
+ VkDeviceSize optimalBufferCopyRowPitchAlignment
}
class VkPhysicalDeviceSparseProperties {
const void* pNext /// Pointer to next structure
VkQueryPoolCreateFlags flags
VkQueryType queryType
- u32 slots
+ u32 entryCount
VkQueryPipelineStatisticFlags pipelineStatistics /// Optional
}
cmd void vkCmdSetStencilCompareMask(
VkCommandBuffer commandBuffer,
VkStencilFaceFlags faceMask,
- u32 stencilCompareMask) {
+ u32 compareMask) {
commandBufferObject := GetCommandBuffer(commandBuffer)
commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}
cmd void vkCmdSetStencilWriteMask(
VkCommandBuffer commandBuffer,
VkStencilFaceFlags faceMask,
- u32 stencilWriteMask) {
+ u32 writeMask) {
commandBufferObject := GetCommandBuffer(commandBuffer)
commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}
cmd void vkCmdSetStencilReference(
VkCommandBuffer commandBuffer,
VkStencilFaceFlags faceMask,
- u32 stencilReference) {
+ u32 reference) {
commandBufferObject := GetCommandBuffer(commandBuffer)
commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_GRAPHICS_BIT)
}
bindCommandBuffer(commandBuffer, srcBuffer, srcBufferObject.memory)
bindCommandBuffer(commandBuffer, dstBuffer, dstBufferObject.memory)
- commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_DMA_BIT)
+ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_TRANSFER_BIT)
}
@threadSafety("app")
bindCommandBuffer(commandBuffer, srcImage, srcImageObject.memory)
bindCommandBuffer(commandBuffer, dstImage, dstImageObject.memory)
- commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_DMA_BIT)
+ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_TRANSFER_BIT)
}
@threadSafety("app")
bindCommandBuffer(commandBuffer, srcBuffer, srcBufferObject.memory)
bindCommandBuffer(commandBuffer, dstImage, dstImageObject.memory)
- commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_DMA_BIT)
+ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_TRANSFER_BIT)
}
@threadSafety("app")
bindCommandBuffer(commandBuffer, srcImage, srcImageObject.memory)
bindCommandBuffer(commandBuffer, dstBuffer, dstBufferObject.memory)
- commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_DMA_BIT)
+ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_TRANSFER_BIT)
}
@threadSafety("app")
bindCommandBuffer(commandBuffer, dstBuffer, dstBufferObject.memory)
- commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_DMA_BIT)
+ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_TRANSFER_BIT)
}
@threadSafety("app")
dstBufferObject := GetBuffer(dstBuffer)
assert(commandBufferObject.device == dstBufferObject.device)
- commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_DMA_BIT)
+ commandBufferObject.queueFlags = AddQueueFlag(commandBufferObject.queueFlags, VK_QUEUE_TRANSFER_BIT)
}
@threadSafety("app")
cmd void vkCmdBeginQuery(
VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
- u32 slot,
+ u32 entry,
VkQueryControlFlags flags) {
commandBufferObject := GetCommandBuffer(commandBuffer)
queryPoolObject := GetQueryPool(queryPool)
cmd void vkCmdEndQuery(
VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
- u32 slot) {
+ u32 entry) {
commandBufferObject := GetCommandBuffer(commandBuffer)
queryPoolObject := GetQueryPool(queryPool)
assert(commandBufferObject.device == queryPoolObject.device)
VkCommandBuffer commandBuffer,
VkPipelineStageFlagBits pipelineStage,
VkQueryPool queryPool,
- u32 slot) {
+ u32 entry) {
commandBufferObject := GetCommandBuffer(commandBuffer)
queryPoolObject := GetQueryPool(queryPool)
assert(commandBufferObject.device == queryPoolObject.device)
cmd void vkCmdBeginRenderPass(
VkCommandBuffer commandBuffer,
const VkRenderPassBeginInfo* pRenderPassBegin,
- VkRenderPassContents contents) {
+ VkSubpassContents contents) {
commandBufferObject := GetCommandBuffer(commandBuffer)
renderPassObject := GetRenderPass(pRenderPassBegin.renderPass)
framebufferObject := GetFramebuffer(pRenderPassBegin.framebuffer)
cmd void vkCmdNextSubpass(
VkCommandBuffer commandBuffer,
- VkRenderPassContents contents) {
+ VkSubpassContents contents) {
commandBufferObject := GetCommandBuffer(commandBuffer)
}
VkPhysicalDevice physicalDevice,
u32 queueFamilyIndex,
platform.Display* dpy,
- platform.VisualID visualId) {
+ platform.VisualID visualID) {
physicalDeviceObject := GetPhysicalDevice(physicalDevice)
return ?
}
#if defined(_WIN32)
// On Windows, VKAPI should equate to the __stdcall convention
#define VKAPI __stdcall
-#elif defined(__GNUC__)
- // On other platforms using GCC, VKAPI stays undefined
- #define VKAPI
#else
- // Unsupported Platform!
- #error "Unsupported OS Platform detected!"
+ // On other platforms, use the default calling convention
+ #define VKAPI
#endif
#include <stddef.h>
((major << 22) | (minor << 12) | patch)
// Vulkan API version supported by this file
-#define VK_API_VERSION VK_MAKE_VERSION(0, 197, 0)
+#define VK_API_VERSION VK_MAKE_VERSION(0, 198, 0)
#define VK_NULL_HANDLE 0
#define VK_FALSE 0
#define VK_QUEUE_FAMILY_IGNORED (~0U)
#define VK_SUBPASS_EXTERNAL (~0U)
-#define VK_MAX_PHYSICAL_DEVICE_NAME 256
-#define VK_UUID_LENGTH 16
+#define VK_MAX_PHYSICAL_DEVICE_NAME_SIZE 256
+#define VK_UUID_SIZE 16
#define VK_MAX_MEMORY_TYPES 32
#define VK_MAX_MEMORY_HEAPS 16
-#define VK_MAX_EXTENSION_NAME 256
-#define VK_MAX_DESCRIPTION 256
+#define VK_MAX_EXTENSION_NAME_SIZE 256
+#define VK_MAX_DESCRIPTION_SIZE 256
typedef enum {
VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 21,
VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 22,
VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 23,
- VK_STRUCTURE_TYPE_PIPELINE_RASTER_STATE_CREATE_INFO = 24,
+ VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 24,
VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 25,
VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 26,
VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 27,
} VkImageViewType;
typedef enum {
- VK_CHANNEL_SWIZZLE_IDENTITY = 0,
- VK_CHANNEL_SWIZZLE_ZERO = 1,
- VK_CHANNEL_SWIZZLE_ONE = 2,
- VK_CHANNEL_SWIZZLE_R = 3,
- VK_CHANNEL_SWIZZLE_G = 4,
- VK_CHANNEL_SWIZZLE_B = 5,
- 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_RANGE_SIZE = (VK_CHANNEL_SWIZZLE_A - VK_CHANNEL_SWIZZLE_IDENTITY + 1),
- VK_CHANNEL_SWIZZLE_MAX_ENUM = 0x7FFFFFFF
-} VkChannelSwizzle;
+ VK_COMPONENT_SWIZZLE_IDENTITY = 0,
+ VK_COMPONENT_SWIZZLE_ZERO = 1,
+ VK_COMPONENT_SWIZZLE_ONE = 2,
+ VK_COMPONENT_SWIZZLE_R = 3,
+ VK_COMPONENT_SWIZZLE_G = 4,
+ VK_COMPONENT_SWIZZLE_B = 5,
+ VK_COMPONENT_SWIZZLE_A = 6,
+ VK_COMPONENT_SWIZZLE_BEGIN_RANGE = VK_COMPONENT_SWIZZLE_IDENTITY,
+ VK_COMPONENT_SWIZZLE_END_RANGE = VK_COMPONENT_SWIZZLE_A,
+ VK_COMPONENT_SWIZZLE_RANGE_SIZE = (VK_COMPONENT_SWIZZLE_A - VK_COMPONENT_SWIZZLE_IDENTITY + 1),
+ VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF
+} VkComponentSwizzle;
typedef enum {
- VK_VERTEX_INPUT_STEP_RATE_VERTEX = 0,
- 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_RANGE_SIZE = (VK_VERTEX_INPUT_STEP_RATE_INSTANCE - VK_VERTEX_INPUT_STEP_RATE_VERTEX + 1),
- VK_VERTEX_INPUT_STEP_RATE_MAX_ENUM = 0x7FFFFFFF
-} VkVertexInputStepRate;
+ VK_VERTEX_INPUT_RATE_VERTEX = 0,
+ VK_VERTEX_INPUT_RATE_INSTANCE = 1,
+ VK_VERTEX_INPUT_RATE_BEGIN_RANGE = VK_VERTEX_INPUT_RATE_VERTEX,
+ VK_VERTEX_INPUT_RATE_END_RANGE = VK_VERTEX_INPUT_RATE_INSTANCE,
+ VK_VERTEX_INPUT_RATE_RANGE_SIZE = (VK_VERTEX_INPUT_RATE_INSTANCE - VK_VERTEX_INPUT_RATE_VERTEX + 1),
+ VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF
+} VkVertexInputRate;
typedef enum {
VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0,
} VkPrimitiveTopology;
typedef enum {
- VK_FILL_MODE_SOLID = 0,
- VK_FILL_MODE_WIREFRAME = 1,
- 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_RANGE_SIZE = (VK_FILL_MODE_POINTS - VK_FILL_MODE_SOLID + 1),
- VK_FILL_MODE_MAX_ENUM = 0x7FFFFFFF
-} VkFillMode;
+ VK_POLYGON_MODE_FILL = 0,
+ VK_POLYGON_MODE_LINE = 1,
+ VK_POLYGON_MODE_POINT = 2,
+ VK_POLYGON_MODE_BEGIN_RANGE = VK_POLYGON_MODE_FILL,
+ VK_POLYGON_MODE_END_RANGE = VK_POLYGON_MODE_POINT,
+ VK_POLYGON_MODE_RANGE_SIZE = (VK_POLYGON_MODE_POINT - VK_POLYGON_MODE_FILL + 1),
+ VK_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF
+} VkPolygonMode;
typedef enum {
VK_FRONT_FACE_COUNTER_CLOCKWISE = 0,
} VkLogicOp;
typedef enum {
- VK_BLEND_ZERO = 0,
- VK_BLEND_ONE = 1,
- VK_BLEND_SRC_COLOR = 2,
- VK_BLEND_ONE_MINUS_SRC_COLOR = 3,
- 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_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,
- VK_BLEND_ONE_MINUS_CONSTANT_ALPHA = 13,
- VK_BLEND_SRC_ALPHA_SATURATE = 14,
- VK_BLEND_SRC1_COLOR = 15,
- VK_BLEND_ONE_MINUS_SRC1_COLOR = 16,
- VK_BLEND_SRC1_ALPHA = 17,
- 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_RANGE_SIZE = (VK_BLEND_ONE_MINUS_SRC1_ALPHA - VK_BLEND_ZERO + 1),
- VK_BLEND_MAX_ENUM = 0x7FFFFFFF
-} VkBlend;
+ VK_BLEND_FACTOR_ZERO = 0,
+ VK_BLEND_FACTOR_ONE = 1,
+ VK_BLEND_FACTOR_SRC_COLOR = 2,
+ VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3,
+ VK_BLEND_FACTOR_DST_COLOR = 4,
+ VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5,
+ VK_BLEND_FACTOR_SRC_ALPHA = 6,
+ VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7,
+ VK_BLEND_FACTOR_DST_ALPHA = 8,
+ VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9,
+ VK_BLEND_FACTOR_CONSTANT_COLOR = 10,
+ VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11,
+ VK_BLEND_FACTOR_CONSTANT_ALPHA = 12,
+ VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13,
+ VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14,
+ VK_BLEND_FACTOR_SRC1_COLOR = 15,
+ VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16,
+ VK_BLEND_FACTOR_SRC1_ALPHA = 17,
+ VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18,
+ VK_BLEND_FACTOR_BEGIN_RANGE = VK_BLEND_FACTOR_ZERO,
+ VK_BLEND_FACTOR_END_RANGE = VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA,
+ VK_BLEND_FACTOR_RANGE_SIZE = (VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA - VK_BLEND_FACTOR_ZERO + 1),
+ VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF
+} VkBlendFactor;
typedef enum {
VK_BLEND_OP_ADD = 0,
} VkIndexType;
typedef enum {
- VK_RENDER_PASS_CONTENTS_INLINE = 0,
- 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_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;
+ VK_SUBPASS_CONTENTS_INLINE = 0,
+ VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1,
+ VK_SUBPASS_CONTENTS_BEGIN_RANGE = VK_SUBPASS_CONTENTS_INLINE,
+ VK_SUBPASS_CONTENTS_END_RANGE = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS,
+ VK_SUBPASS_CONTENTS_RANGE_SIZE = (VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS - VK_SUBPASS_CONTENTS_INLINE + 1),
+ VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF
+} VkSubpassContents;
typedef VkFlags VkInstanceCreateFlags;
typedef enum {
VK_QUEUE_GRAPHICS_BIT = 0x00000001,
VK_QUEUE_COMPUTE_BIT = 0x00000002,
- VK_QUEUE_DMA_BIT = 0x00000004,
+ VK_QUEUE_TRANSFER_BIT = 0x00000004,
VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008,
} VkQueueFlagBits;
typedef VkFlags VkQueueFlags;
typedef VkFlags VkPipelineColorBlendStateCreateFlags;
typedef enum {
- VK_CHANNEL_R_BIT = 0x00000001,
- VK_CHANNEL_G_BIT = 0x00000002,
- VK_CHANNEL_B_BIT = 0x00000004,
- VK_CHANNEL_A_BIT = 0x00000008,
-} VkChannelFlagBits;
-typedef VkFlags VkChannelFlags;
+ VK_COLOR_COMPONENT_R_BIT = 0x00000001,
+ VK_COLOR_COMPONENT_G_BIT = 0x00000002,
+ VK_COLOR_COMPONENT_B_BIT = 0x00000004,
+ VK_COLOR_COMPONENT_A_BIT = 0x00000008,
+} VkColorComponentFlagBits;
+typedef VkFlags VkColorComponentFlags;
typedef VkFlags VkPipelineDynamicStateCreateFlags;
typedef VkFlags VkPipelineLayoutCreateFlags;
typedef VkFlags VkShaderStageFlags;
typedef VkFlags VkStencilFaceFlags;
typedef enum {
- VK_QUERY_CONTROL_CONSERVATIVE_BIT = 0x00000001,
+ VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001,
} VkQueryControlFlagBits;
typedef VkFlags VkQueryControlFlags;
VkBool32 textureCompressionETC2;
VkBool32 textureCompressionASTC_LDR;
VkBool32 textureCompressionBC;
- VkBool32 occlusionQueryNonConservative;
+ VkBool32 occlusionQueryPrecise;
VkBool32 pipelineStatisticsQuery;
VkBool32 vertexPipelineStoresAndAtomics;
VkBool32 fragmentStoresAndAtomics;
VkBool32 shaderInt64;
VkBool32 shaderInt16;
VkBool32 shaderResourceResidency;
- VkBool32 shaderResourceMinLOD;
+ VkBool32 shaderResourceMinLod;
VkBool32 sparseBinding;
VkBool32 sparseResidencyBuffer;
VkBool32 sparseResidencyImage2D;
float pointSizeGranularity;
float lineWidthGranularity;
VkBool32 strictLines;
- VkDeviceSize recommendedBufferCopyOffsetAlignment;
- VkDeviceSize recommendedBufferCopyRowPitchAlignment;
+ VkDeviceSize optimalBufferCopyOffsetAlignment;
+ VkDeviceSize optimalBufferCopyRowPitchAlignment;
} VkPhysicalDeviceLimits;
typedef struct {
typedef struct {
uint32_t apiVersion;
uint32_t driverVersion;
- uint32_t vendorId;
- uint32_t deviceId;
+ uint32_t vendorID;
+ uint32_t deviceID;
VkPhysicalDeviceType deviceType;
- char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME];
- uint8_t pipelineCacheUUID[VK_UUID_LENGTH];
+ char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
+ uint8_t pipelineCacheUUID[VK_UUID_SIZE];
VkPhysicalDeviceLimits limits;
VkPhysicalDeviceSparseProperties sparseProperties;
} VkPhysicalDeviceProperties;
VkQueueFlags queueFlags;
uint32_t queueCount;
uint32_t timestampValidBits;
+ VkExtent3D minImageTransferGranularity;
} VkQueueFamilyProperties;
typedef struct {
} VkDeviceCreateInfo;
typedef struct {
- char extensionName[VK_MAX_EXTENSION_NAME];
+ char extensionName[VK_MAX_EXTENSION_NAME_SIZE];
uint32_t specVersion;
} VkExtensionProperties;
typedef struct {
- char layerName[VK_MAX_EXTENSION_NAME];
+ char layerName[VK_MAX_EXTENSION_NAME_SIZE];
uint32_t specVersion;
uint32_t implementationVersion;
- char description[VK_MAX_DESCRIPTION];
+ char description[VK_MAX_DESCRIPTION_SIZE];
} VkLayerProperties;
typedef struct {
typedef struct {
VkSparseImageFormatProperties formatProperties;
- uint32_t imageMipTailStartLOD;
+ uint32_t imageMipTailStartLod;
VkDeviceSize imageMipTailSize;
VkDeviceSize imageMipTailOffset;
VkDeviceSize imageMipTailStride;
const void* pNext;
VkQueryPoolCreateFlags flags;
VkQueryType queryType;
- uint32_t slots;
+ uint32_t entryCount;
VkQueryPipelineStatisticFlags pipelineStatistics;
} VkQueryPoolCreateInfo;
} VkSubresourceLayout;
typedef struct {
- VkChannelSwizzle r;
- VkChannelSwizzle g;
- VkChannelSwizzle b;
- VkChannelSwizzle a;
-} VkChannelMapping;
+ VkComponentSwizzle r;
+ VkComponentSwizzle g;
+ VkComponentSwizzle b;
+ VkComponentSwizzle a;
+} VkComponentMapping;
typedef struct {
VkImageAspectFlags aspectMask;
VkImage image;
VkImageViewType viewType;
VkFormat format;
- VkChannelMapping channels;
+ VkComponentMapping components;
VkImageSubresourceRange subresourceRange;
} VkImageViewCreateInfo;
} VkPipelineCacheCreateInfo;
typedef struct {
- uint32_t constantId;
+ uint32_t constantID;
uint32_t offset;
size_t size;
} VkSpecializationMapEntry;
typedef struct {
uint32_t binding;
uint32_t stride;
- VkVertexInputStepRate stepRate;
+ VkVertexInputRate inputRate;
} VkVertexInputBindingDescription;
typedef struct {
} VkPipelineTessellationStateCreateInfo;
typedef struct {
- float originX;
- float originY;
+ float x;
+ float y;
float width;
float height;
float minDepth;
VkPipelineRasterizationStateCreateFlags flags;
VkBool32 depthClampEnable;
VkBool32 rasterizerDiscardEnable;
- VkFillMode fillMode;
+ VkPolygonMode polygonMode;
VkCullModeFlags cullMode;
VkFrontFace frontFace;
VkBool32 depthBiasEnable;
} VkPipelineMultisampleStateCreateInfo;
typedef struct {
- VkStencilOp stencilFailOp;
- VkStencilOp stencilPassOp;
- VkStencilOp stencilDepthFailOp;
- VkCompareOp stencilCompareOp;
- uint32_t stencilCompareMask;
- uint32_t stencilWriteMask;
- uint32_t stencilReference;
+ VkStencilOp failOp;
+ VkStencilOp passOp;
+ VkStencilOp depthFailOp;
+ VkCompareOp compareOp;
+ uint32_t compareMask;
+ uint32_t writeMask;
+ uint32_t reference;
} VkStencilOpState;
typedef struct {
typedef struct {
VkBool32 blendEnable;
- VkBlend srcBlendColor;
- VkBlend dstBlendColor;
- VkBlendOp blendOpColor;
- VkBlend srcBlendAlpha;
- VkBlend dstBlendAlpha;
- VkBlendOp blendOpAlpha;
- VkChannelFlags channelWriteMask;
+ VkBlendFactor srcColorBlendFactor;
+ VkBlendFactor dstColorBlendFactor;
+ VkBlendOp colorBlendOp;
+ VkBlendFactor srcAlphaBlendFactor;
+ VkBlendFactor dstAlphaBlendFactor;
+ VkBlendOp alphaBlendOp;
+ VkColorComponentFlags colorWriteMask;
} VkPipelineColorBlendAttachmentState;
typedef struct {
typedef struct {
VkDescriptorType type;
uint32_t descriptorCount;
-} VkDescriptorTypeCount;
+} VkDescriptorPoolSize;
typedef struct {
VkStructureType sType;
const void* pNext;
VkDescriptorPoolCreateFlags flags;
uint32_t maxSets;
- uint32_t typeCount;
- const VkDescriptorTypeCount* pTypeCounts;
+ uint32_t poolSizeCount;
+ const VkDescriptorPoolSize* pPoolSizes;
} VkDescriptorPoolCreateInfo;
typedef struct {
} VkBufferCopy;
typedef struct {
- VkImageAspectFlags aspect;
+ VkImageAspectFlags aspectMask;
uint32_t mipLevel;
uint32_t baseArrayLayer;
uint32_t layerCount;
-} VkImageSubresourceCopy;
+} VkImageSubresourceLayers;
typedef struct {
- VkImageSubresourceCopy srcSubresource;
+ VkImageSubresourceLayers srcSubresource;
VkOffset3D srcOffset;
- VkImageSubresourceCopy dstSubresource;
+ VkImageSubresourceLayers dstSubresource;
VkOffset3D dstOffset;
VkExtent3D extent;
} VkImageCopy;
typedef struct {
- VkImageSubresourceCopy srcSubresource;
+ VkImageSubresourceLayers srcSubresource;
VkOffset3D srcOffset;
VkExtent3D srcExtent;
- VkImageSubresourceCopy dstSubresource;
+ VkImageSubresourceLayers dstSubresource;
VkOffset3D dstOffset;
VkExtent3D dstExtent;
} VkImageBlit;
VkDeviceSize bufferOffset;
uint32_t bufferRowLength;
uint32_t bufferImageHeight;
- VkImageSubresourceCopy imageSubresource;
+ VkImageSubresourceLayers imageSubresource;
VkOffset3D imageOffset;
VkExtent3D imageExtent;
} VkBufferImageCopy;
} VkClearRect;
typedef struct {
- VkImageSubresourceCopy srcSubresource;
+ VkImageSubresourceLayers srcSubresource;
VkOffset3D srcOffset;
- VkImageSubresourceCopy dstSubresource;
+ VkImageSubresourceLayers dstSubresource;
VkOffset3D dstOffset;
VkExtent3D extent;
} VkImageResolve;
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 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 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 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_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_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask);
+typedef void (VKAPI *PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask);
+typedef void (VKAPI *PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference);
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_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_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t entry, VkQueryControlFlags flags);
+typedef void (VKAPI *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t entry);
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_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t entry);
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_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents);
+typedef void (VKAPI *PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkSubpassContents contents);
typedef void (VKAPI *PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer);
typedef void (VKAPI *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBuffersCount, const VkCommandBuffer* pCommandBuffers);
void VKAPI vkDestroyCommandPool(
VkDevice device,
- VkCommandPool CommandPool,
+ VkCommandPool commandPool,
const VkAllocationCallbacks* pAllocator);
VkResult VKAPI vkResetCommandPool(
VkDevice device,
- VkCommandPool CommandPool,
+ VkCommandPool commandPool,
VkCommandPoolResetFlags flags);
VkResult VKAPI vkAllocateCommandBuffers(
void VKAPI vkFreeCommandBuffers(
VkDevice device,
- VkCommandPool CommandPool,
+ VkCommandPool commandPool,
uint32_t commandBufferCount,
const VkCommandBuffer* pCommandBuffers);
void VKAPI vkCmdSetStencilCompareMask(
VkCommandBuffer commandBuffer,
VkStencilFaceFlags faceMask,
- uint32_t stencilCompareMask);
+ uint32_t compareMask);
void VKAPI vkCmdSetStencilWriteMask(
VkCommandBuffer commandBuffer,
VkStencilFaceFlags faceMask,
- uint32_t stencilWriteMask);
+ uint32_t writeMask);
void VKAPI vkCmdSetStencilReference(
VkCommandBuffer commandBuffer,
VkStencilFaceFlags faceMask,
- uint32_t stencilReference);
+ uint32_t reference);
void VKAPI vkCmdBindDescriptorSets(
VkCommandBuffer commandBuffer,
void VKAPI vkCmdBeginQuery(
VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
- uint32_t slot,
+ uint32_t entry,
VkQueryControlFlags flags);
void VKAPI vkCmdEndQuery(
VkCommandBuffer commandBuffer,
VkQueryPool queryPool,
- uint32_t slot);
+ uint32_t entry);
void VKAPI vkCmdResetQueryPool(
VkCommandBuffer commandBuffer,
VkCommandBuffer commandBuffer,
VkPipelineStageFlagBits pipelineStage,
VkQueryPool queryPool,
- uint32_t slot);
+ uint32_t entry);
void VKAPI vkCmdCopyQueryPoolResults(
VkCommandBuffer commandBuffer,
void VKAPI vkCmdBeginRenderPass(
VkCommandBuffer commandBuffer,
const VkRenderPassBeginInfo* pRenderPassBegin,
- VkRenderPassContents contents);
+ VkSubpassContents contents);
void VKAPI vkCmdNextSubpass(
VkCommandBuffer commandBuffer,
- VkRenderPassContents contents);
+ VkSubpassContents contents);
void VKAPI vkCmdEndRenderPass(
VkCommandBuffer commandBuffer);
#define VK_EXT_KHR_XLIB_SURFACE_EXTENSION_NAME "vk_ext_khr_xlib_surface"
typedef VkResult (VKAPI *PFN_vkCreateXlibSurfaceKHR)(VkInstance instance, Display* dpy, Window window, VkSurfaceKHR* pSurface);
-typedef VkBool32 (VKAPI *PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualId);
+typedef VkBool32 (VKAPI *PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID);
#ifdef VK_PROTOTYPES
VkResult VKAPI vkCreateXlibSurfaceKHR(
VkPhysicalDevice physicalDevice,
uint32_t queueFamilyIndex,
Display* dpy,
- VisualID visualId);
+ VisualID visualID);
#endif
#endif /* VK_USE_PLATFORM_XLIB_KHR */
}
__attribute__((visibility("default")))
-void vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilCompareMask) {
- GetVtbl(commandBuffer).CmdSetStencilCompareMask(commandBuffer, faceMask, stencilCompareMask);
+void vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) {
+ GetVtbl(commandBuffer).CmdSetStencilCompareMask(commandBuffer, faceMask, compareMask);
}
__attribute__((visibility("default")))
-void vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilWriteMask) {
- GetVtbl(commandBuffer).CmdSetStencilWriteMask(commandBuffer, faceMask, stencilWriteMask);
+void vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) {
+ GetVtbl(commandBuffer).CmdSetStencilWriteMask(commandBuffer, faceMask, writeMask);
}
__attribute__((visibility("default")))
-void vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t stencilReference) {
- GetVtbl(commandBuffer).CmdSetStencilReference(commandBuffer, faceMask, stencilReference);
+void vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) {
+ GetVtbl(commandBuffer).CmdSetStencilReference(commandBuffer, faceMask, reference);
}
__attribute__((visibility("default")))
}
__attribute__((visibility("default")))
-void vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot, VkQueryControlFlags flags) {
- GetVtbl(commandBuffer).CmdBeginQuery(commandBuffer, queryPool, slot, flags);
+void vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t entry, VkQueryControlFlags flags) {
+ GetVtbl(commandBuffer).CmdBeginQuery(commandBuffer, queryPool, entry, flags);
}
__attribute__((visibility("default")))
-void vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot) {
- GetVtbl(commandBuffer).CmdEndQuery(commandBuffer, queryPool, slot);
+void vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t entry) {
+ GetVtbl(commandBuffer).CmdEndQuery(commandBuffer, queryPool, entry);
}
__attribute__((visibility("default")))
}
__attribute__((visibility("default")))
-void vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot) {
- GetVtbl(commandBuffer).CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, slot);
+void vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t entry) {
+ GetVtbl(commandBuffer).CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, entry);
}
__attribute__((visibility("default")))
}
__attribute__((visibility("default")))
-void vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents) {
+void vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) {
GetVtbl(commandBuffer).CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
}
__attribute__((visibility("default")))
-void vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkRenderPassContents contents) {
+void vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) {
GetVtbl(commandBuffer).CmdNextSubpass(commandBuffer, contents);
}
VkPhysicalDeviceProperties* properties) {
properties->apiVersion = VK_API_VERSION;
properties->driverVersion = VK_MAKE_VERSION(0, 0, 1);
- properties->vendorId = 0;
- properties->deviceId = 0;
+ properties->vendorID = 0;
+ properties->deviceID = 0;
properties->deviceType = VK_PHYSICAL_DEVICE_TYPE_OTHER;
strcpy(properties->deviceName, "Android Vulkan Null Driver");
memset(properties->pipelineCacheUUID, 0,
uint32_t* count,
VkQueueFamilyProperties* properties) {
if (properties) {
- properties->queueFlags =
- VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_DMA_BIT;
+ properties->queueFlags = VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT |
+ VK_QUEUE_TRANSFER_BIT;
properties->queueCount = 1;
properties->timestampValidBits = 64;
}
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 CmdBeginRenderPass(VkCommandBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) {
}
-void CmdNextSubpass(VkCommandBuffer cmdBuffer, VkRenderPassContents contents) {
+void CmdNextSubpass(VkCommandBuffer cmdBuffer, VkSubpassContents contents) {
}
void CmdEndRenderPass(VkCommandBuffer cmdBuffer) {
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 CmdBeginRenderPass(VkCommandBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents);
+void CmdNextSubpass(VkCommandBuffer cmdBuffer, VkSubpassContents contents);
void CmdEndRenderPass(VkCommandBuffer cmdBuffer);
void CmdExecuteCommands(VkCommandBuffer cmdBuffer, uint32_t cmdBuffersCount, const VkCommandBuffer* pCmdBuffers);
return "GRAPHICS";
case VK_QUEUE_COMPUTE_BIT:
return "COMPUTE";
- case VK_QUEUE_DMA_BIT:
- return "DMA";
+ case VK_QUEUE_TRANSFER_BIT:
+ return "TRANSFER";
case VK_QUEUE_SPARSE_BINDING_BIT:
return "SPARSE";
}
printf(" %u: \"%s\" (%s) %u.%u.%u/%#x [%04x:%04x]\n", idx,
props.deviceName, VkPhysicalDeviceTypeStr(props.deviceType),
(props.apiVersion >> 22) & 0x3FF, (props.apiVersion >> 12) & 0x3FF,
- (props.apiVersion >> 0) & 0xFFF, props.driverVersion, props.vendorId,
- props.deviceId);
+ (props.apiVersion >> 0) & 0xFFF, props.driverVersion, props.vendorID,
+ props.deviceID);
VkPhysicalDeviceMemoryProperties mem_props;
vkGetPhysicalDeviceMemoryProperties(pdev, &mem_props);
OSDN Git Service
