// API version (major.minor.patch)
define VERSION_MAJOR 0
-define VERSION_MINOR 180
+define VERSION_MINOR 181
define VERSION_PATCH 0
// API limits
VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 0x00000006,
}
-enum VkImageAspect {
- VK_IMAGE_ASPECT_COLOR = 0x00000000,
- VK_IMAGE_ASPECT_DEPTH = 0x00000001,
- VK_IMAGE_ASPECT_STENCIL = 0x00000002,
- VK_IMAGE_ASPECT_METADATA = 0x00000003,
-}
-
enum VkCmdBufferLevel {
VK_CMD_BUFFER_LEVEL_PRIMARY = 0x00000000,
VK_CMD_BUFFER_LEVEL_SECONDARY = 0x00000001,
VK_FORMAT_B10G10R10A2_SINT = 0x000000AD,
}
-/// Shader stage enumerant
-enum VkShaderStage {
- VK_SHADER_STAGE_VERTEX = 0x00000000,
- VK_SHADER_STAGE_TESSELLATION_CONTROL = 0x00000001,
- VK_SHADER_STAGE_TESSELLATION_EVALUATION = 0x00000002,
- VK_SHADER_STAGE_GEOMETRY = 0x00000003,
- VK_SHADER_STAGE_FRAGMENT = 0x00000004,
- VK_SHADER_STAGE_COMPUTE = 0x00000005,
-}
-
/// Structure type enumerant
enum VkStructureType {
VK_STRUCTURE_TYPE_APPLICATION_INFO = 0,
enum VkResult {
// Return codes for successful operation execution (positive values)
VK_SUCCESS = 0x00000000,
- VK_UNSUPPORTED = 0x00000001,
- VK_NOT_READY = 0x00000002,
- VK_TIMEOUT = 0x00000003,
- VK_EVENT_SET = 0x00000004,
- VK_EVENT_RESET = 0x00000005,
- VK_INCOMPLETE = 0x00000006,
+ VK_NOT_READY = 0x00000001,
+ VK_TIMEOUT = 0x00000002,
+ VK_EVENT_SET = 0x00000003,
+ VK_EVENT_RESET = 0x00000004,
+ VK_INCOMPLETE = 0x00000005,
// Error codes (negative values)
VK_ERROR_OUT_OF_HOST_MEMORY = 0xFFFFFFFF,
bitfield VkCmdBufferCreateFlags {
}
-/// Command buffer optimization flags
-bitfield VkCmdBufferOptimizeFlags {
- VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT = 0x00000001,
- VK_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT = 0x00000002,
- VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT = 0x00000004,
- VK_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT = 0x00000008,
- VK_CMD_BUFFER_OPTIMIZE_NO_SIMULTANEOUS_USE_BIT = 0x00000010, /// Only one call to the secondary command buffer will exist at any given time
+/// Command buffer usage flags
+bitfield VkCmdBufferUsageFlags {
+ 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,
}
/// Pipeline statistics flags
VkExtent2D extent
}
-class VkRect3D {
- VkOffset3D offset
- VkExtent3D extent
+class VkClearRect {
+ VkRect2D rect
+ u32 baseArrayLayer
+ u32 numLayers
}
class VkChannelMapping {
}
class VkSparseImageFormatProperties {
- VkImageAspect aspect
+ VkImageAspectFlags aspect
VkExtent3D imageGranularity
VkSparseImageFormatFlags flags
}
class VkImageFormatProperties {
VkExtent3D maxExtent /// max image dimensions for this resource type
u32 maxMipLevels /// max number of mipmap levels for this resource type
- u32 maxArraySize /// max array size for this resource type
+ u32 maxArrayLayers /// max array layers for this resource type
VkSampleCountFlags sampleCounts /// supported sample counts for this resource type
VkDeviceSize maxResourceSize /// max size (in bytes) of this resource type
}
+class VkDescriptorImageInfo {
+ VkSampler sampler
+ VkImageView imageView
+ VkImageLayout imageLayout
+}
+
class VkDescriptorBufferInfo {
VkBuffer buffer /// Buffer used for this descriptor when the descriptor is UNIFORM_BUFFER[_DYNAMIC]
VkDeviceSize offset /// Base offset from buffer start in bytes to update in the descriptor set.
VkDeviceSize range /// Size in bytes of the buffer resource for this descriptor update.
}
+@union
class VkDescriptorInfo {
- VkBufferView bufferView /// Buffer view to write to the descriptor (in case it's a buffer descriptor, otherwise should be VK_NULL_HANDLE)
- VkSampler sampler /// Sampler to write to the descriptor (in case it's a SAMPLER or COMBINED_IMAGE_SAMPLER descriptor, otherwise should be VK_NULL_HANDLE)
- VkImageView imageView /// Image view to write to the descriptor (in case it's a SAMPLED_IMAGE, STORAGE_IMAGE, COMBINED_IMAGE_SAMPLER, or INPUT_ATTACHMENT descriptor, otherwise should be VK_NULL_HANDLE)
- VkImageLayout imageLayout /// Layout the image is expected to be in when accessed using this descriptor (only used if imageView is not VK_NULL_HANDLE)
+ VkDescriptorImageInfo imageInfo
VkDescriptorBufferInfo bufferInfo /// Raw buffer, size and offset for UNIFORM_BUFFER[_DYNAMIC] or STORAGE_BUFFER[_DYNAMIC] descriptor types. Ignored otherwise.
+ VkBufferView texelBufferView
}
class VkWriteDescriptorSet {
}
class VkImageSubresource {
- VkImageAspect aspect
+ VkImageAspectFlags aspect
u32 mipLevel
u32 arrayLayer
}
class VkImageSubresourceRange {
VkImageAspectFlags aspectMask
u32 baseMipLevel
- u32 mipLevels
+ u32 numLevels
u32 baseArrayLayer
- u32 arraySize
+ u32 numLayers
}
class VkMemoryBarrier {
VkFormat format
VkExtent3D extent
u32 mipLevels
- u32 arraySize
+ u32 arrayLayers
u32 samples
VkImageTiling tiling
VkImageUsageFlags usage /// Image usage flags
}
class VkImageSubresourceCopy {
- VkImageAspect aspect
+ VkImageAspectFlags aspect
u32 mipLevel
- u32 arrayLayer
- u32 arraySize
+ u32 baseArrayLayer
+ u32 numLayers
}
class VkImageCopy {
VkShaderModule module /// Module containing entry point
const char* pName /// Null-terminated entry point name
VkShaderCreateFlags flags /// Reserved
- VkShaderStage stage
+ VkShaderStageFlags stage
}
class VkDescriptorSetLayoutBinding {
class VkPipelineShaderStageCreateInfo {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO
const void* pNext /// Pointer to next structure
- VkShaderStage stage
+ VkShaderStageFlags stage
VkShader shader
const VkSpecializationInfo* pSpecializationInfo
}
class VkCmdBufferBeginInfo {
VkStructureType sType /// Must be VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO
const void* pNext /// Pointer to next structure
- VkCmdBufferOptimizeFlags flags /// Command buffer optimization flags
+ VkCmdBufferUsageFlags flags /// Command buffer usage flags
VkRenderPass renderPass /// Render pass for secondary command buffers
u32 subpass
VkFramebuffer framebuffer /// Framebuffer for secondary command buffers
u32 attachmentCount,
const VkClearAttachment* pAttachments,
u32 rectCount,
- const VkRect3D* pRects) {
+ const VkClearRect* pRects) {
cmdBufferObject := GetCmdBuffer(cmdBuffer)
rects := pRects[0:rectCount]
((major << 22) | (minor << 12) | patch)
// Vulkan API version supported by this file
-#define VK_API_VERSION VK_MAKE_VERSION(0, 180, 0)
+#define VK_API_VERSION VK_MAKE_VERSION(0, 181, 0)
#if defined(__cplusplus) && ((defined(_MSC_VER) && _MSC_VER >= 1800) || __cplusplus >= 201103L)
typedef enum {
VK_SUCCESS = 0,
- VK_UNSUPPORTED = 1,
- VK_NOT_READY = 2,
- VK_TIMEOUT = 3,
- VK_EVENT_SET = 4,
- VK_EVENT_RESET = 5,
- VK_INCOMPLETE = 6,
+ VK_NOT_READY = 1,
+ VK_TIMEOUT = 2,
+ VK_EVENT_SET = 3,
+ VK_EVENT_RESET = 4,
+ VK_INCOMPLETE = 5,
VK_ERROR_OUT_OF_HOST_MEMORY = -1,
VK_ERROR_OUT_OF_DEVICE_MEMORY = -2,
VK_ERROR_INITIALIZATION_FAILED = -3,
} VkPhysicalDeviceType;
typedef enum {
- VK_IMAGE_ASPECT_COLOR = 0,
- VK_IMAGE_ASPECT_DEPTH = 1,
- VK_IMAGE_ASPECT_STENCIL = 2,
- VK_IMAGE_ASPECT_METADATA = 3,
- VK_IMAGE_ASPECT_BEGIN_RANGE = VK_IMAGE_ASPECT_COLOR,
- VK_IMAGE_ASPECT_END_RANGE = VK_IMAGE_ASPECT_METADATA,
- VK_IMAGE_ASPECT_NUM = (VK_IMAGE_ASPECT_METADATA - VK_IMAGE_ASPECT_COLOR + 1),
- VK_IMAGE_ASPECT_MAX_ENUM = 0x7FFFFFFF
-} VkImageAspect;
-
-typedef enum {
VK_QUERY_TYPE_OCCLUSION = 0,
VK_QUERY_TYPE_PIPELINE_STATISTICS = 1,
VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_TYPE_OCCLUSION,
} VkChannelSwizzle;
typedef enum {
- VK_SHADER_STAGE_VERTEX = 0,
- VK_SHADER_STAGE_TESSELLATION_CONTROL = 1,
- VK_SHADER_STAGE_TESSELLATION_EVALUATION = 2,
- VK_SHADER_STAGE_GEOMETRY = 3,
- VK_SHADER_STAGE_FRAGMENT = 4,
- VK_SHADER_STAGE_COMPUTE = 5,
- VK_SHADER_STAGE_BEGIN_RANGE = VK_SHADER_STAGE_VERTEX,
- VK_SHADER_STAGE_END_RANGE = VK_SHADER_STAGE_COMPUTE,
- VK_SHADER_STAGE_NUM = (VK_SHADER_STAGE_COMPUTE - VK_SHADER_STAGE_VERTEX + 1),
- VK_SHADER_STAGE_MAX_ENUM = 0x7FFFFFFF
-} VkShaderStage;
-
-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,
typedef VkFlags VkMemoryMapFlags;
typedef enum {
+ VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001,
+ VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002,
+ VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004,
+ VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008,
+} VkImageAspectFlagBits;
+
+typedef enum {
VK_SPARSE_IMAGE_FMT_SINGLE_MIPTAIL_BIT = 0x00000001,
VK_SPARSE_IMAGE_FMT_ALIGNED_MIP_SIZE_BIT = 0x00000002,
VK_SPARSE_IMAGE_FMT_NONSTD_BLOCK_SIZE_BIT = 0x00000004,
VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004,
} VkBufferCreateFlagBits;
typedef VkFlags VkBufferCreateFlags;
-
-typedef enum {
- VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001,
- VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002,
- VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004,
- VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008,
-} VkImageAspectFlagBits;
typedef VkFlags VkImageAspectFlags;
typedef enum {
typedef VkFlags VkShaderCreateFlags;
typedef enum {
+ VK_SHADER_STAGE_VERTEX_BIT = 0x00000001,
+ VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002,
+ VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004,
+ VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008,
+ VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010,
+ VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020,
+ VK_SHADER_STAGE_ALL = 0x7FFFFFFF,
+} VkShaderStageFlagBits;
+
+typedef enum {
VK_CHANNEL_R_BIT = 0x00000001,
VK_CHANNEL_G_BIT = 0x00000002,
VK_CHANNEL_B_BIT = 0x00000004,
VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004,
} VkPipelineCreateFlagBits;
typedef VkFlags VkPipelineCreateFlags;
-
-typedef enum {
- VK_SHADER_STAGE_VERTEX_BIT = 0x00000001,
- VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002,
- VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004,
- VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008,
- VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010,
- VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020,
- VK_SHADER_STAGE_ALL = 0x7FFFFFFF,
-} VkShaderStageFlagBits;
typedef VkFlags VkShaderStageFlags;
typedef enum {
typedef VkFlags VkCmdBufferCreateFlags;
typedef enum {
- VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT = 0x00000001,
- VK_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT = 0x00000002,
- VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT = 0x00000004,
- VK_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT = 0x00000008,
- VK_CMD_BUFFER_OPTIMIZE_NO_SIMULTANEOUS_USE_BIT = 0x00000010,
-} VkCmdBufferOptimizeFlagBits;
-typedef VkFlags VkCmdBufferOptimizeFlags;
+ 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;
typedef enum {
VK_CMD_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
typedef struct {
VkExtent3D maxExtent;
uint32_t maxMipLevels;
- uint32_t maxArraySize;
+ uint32_t maxArrayLayers;
VkSampleCountFlags sampleCounts;
VkDeviceSize maxResourceSize;
} VkImageFormatProperties;
} VkMemoryRequirements;
typedef struct {
- VkImageAspect aspect;
+ VkImageAspectFlagBits aspect;
VkExtent3D imageGranularity;
VkSparseImageFormatFlags flags;
} VkSparseImageFormatProperties;
} VkSparseMemoryBindInfo;
typedef struct {
- VkImageAspect aspect;
+ VkImageAspectFlagBits aspect;
uint32_t mipLevel;
uint32_t arrayLayer;
} VkImageSubresource;
VkFormat format;
VkExtent3D extent;
uint32_t mipLevels;
- uint32_t arraySize;
+ uint32_t arrayLayers;
uint32_t samples;
VkImageTiling tiling;
VkImageUsageFlags usage;
typedef struct {
VkImageAspectFlags aspectMask;
uint32_t baseMipLevel;
- uint32_t mipLevels;
+ uint32_t numLevels;
uint32_t baseArrayLayer;
- uint32_t arraySize;
+ uint32_t numLayers;
} VkImageSubresourceRange;
typedef struct {
VkShaderModule module;
const char* pName;
VkShaderCreateFlags flags;
- VkShaderStage stage;
+ VkShaderStageFlagBits stage;
} VkShaderCreateInfo;
typedef struct {
typedef struct {
VkStructureType sType;
const void* pNext;
- VkShaderStage stage;
+ VkShaderStageFlagBits stage;
VkShader shader;
const VkSpecializationInfo* pSpecializationInfo;
} VkPipelineShaderStageCreateInfo;
} VkDescriptorPoolCreateInfo;
typedef struct {
+ VkSampler sampler;
+ VkImageView imageView;
+ VkImageLayout imageLayout;
+} VkDescriptorImageInfo;
+
+typedef struct {
VkBuffer buffer;
VkDeviceSize offset;
VkDeviceSize range;
} VkDescriptorBufferInfo;
-typedef struct {
- VkBufferView bufferView;
- VkSampler sampler;
- VkImageView imageView;
- VkImageLayout imageLayout;
+typedef union {
+ VkDescriptorImageInfo imageInfo;
VkDescriptorBufferInfo bufferInfo;
+ VkBufferView texelBufferView;
} VkDescriptorInfo;
typedef struct {
typedef struct {
VkStructureType sType;
const void* pNext;
- VkCmdBufferOptimizeFlags flags;
+ VkCmdBufferUsageFlags flags;
VkRenderPass renderPass;
uint32_t subpass;
VkFramebuffer framebuffer;
} VkBufferCopy;
typedef struct {
- VkImageAspect aspect;
+ VkImageAspectFlags aspect;
uint32_t mipLevel;
- uint32_t arrayLayer;
- uint32_t arraySize;
+ uint32_t baseArrayLayer;
+ uint32_t numLayers;
} VkImageSubresourceCopy;
typedef struct {
} VkClearAttachment;
typedef struct {
- VkOffset3D offset;
- VkExtent3D extent;
-} VkRect3D;
+ VkRect2D rect;
+ uint32_t baseArrayLayer;
+ uint32_t numLayers;
+} VkClearRect;
typedef struct {
VkImageSubresourceCopy srcSubresource;
typedef void (VKAPI *PFN_vkCmdFillBuffer)(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, 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 VkRect3D* pRects);
+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);
uint32_t attachmentCount,
const VkClearAttachment* pAttachments,
uint32_t rectCount,
- const VkRect3D* pRects);
+ const VkClearRect* pRects);
void VKAPI vkCmdResolveImage(
VkCmdBuffer cmdBuffer,
}
__attribute__((visibility("default")))
-void vkCmdClearAttachments(VkCmdBuffer cmdBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkRect3D* pRects) {
+void vkCmdClearAttachments(VkCmdBuffer cmdBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) {
GetVtbl(cmdBuffer).CmdClearAttachments(cmdBuffer, attachmentCount, pAttachments, rectCount, pRects);
}
.format = VK_FORMAT_R8G8B8A8_UNORM, // TODO(jessehall)
.extent = {0, 0, 1},
.mipLevels = 1,
- .arraySize = 1,
+ .arrayLayers = 1,
.samples = 1,
.tiling = VK_IMAGE_TILING_OPTIMAL,
.usage = create_info->imageUsageFlags,
ALOGE("CreateImage: not yet implemented: type=%d format=%d mips=%u",
create_info->imageType, create_info->format,
create_info->mipLevels);
- return VK_UNSUPPORTED;
+ return VK_ERROR_OUT_OF_HOST_MEMORY;
}
VkDeviceSize size =
VkDeviceSize(create_info->extent.width * create_info->extent.height) *
- create_info->arraySize * create_info->samples * 4u;
+ create_info->arrayLayers * create_info->samples * 4u;
ALOGW_IF(size > kMaxDeviceMemory,
"CreateImage: image size 0x%" PRIx64
" exceeds max device memory size 0x%" PRIx64,
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 VkRect3D* pRects) {
+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 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 VkRect3D* pRects);
+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);
switch (result) {
// clang-format off
case VK_SUCCESS: result_str = "VK_SUCCESS"; break;
- case VK_UNSUPPORTED: result_str = "VK_UNSUPPORTED"; break;
case VK_NOT_READY: result_str = "VK_NOT_READY"; break;
case VK_TIMEOUT: result_str = "VK_TIMEOUT"; break;
case VK_EVENT_SET: result_str = "VK_EVENT_SET"; break;
OSDN Git Service
