OpenHarmony/third_party_mesa3d
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

vk/vulkan.h: Reformat a bunch of enums to match revision 130

Browse Source 
In theory, no functional change.
This commit is contained in:
Jason Ekstrand
2015-07-06 17:06:02 -07:00
parent 8c5e48f307
commit c7cef662d0
1 changed files with 124 additions and 154 deletions
Download Patch File Download Diff File Expand all files Collapse all files

278
include/vulkan/vulkan.h
View File

@@ -234,7 +234,6 @@ typedef enum {
VK_SYSTEM_ALLOC_TYPE_MAX_ENUM = 0x7FFFFFFF VK_SYSTEM_ALLOC_TYPE_MAX_ENUM = 0x7FFFFFFF
} VkSystemAllocType; } VkSystemAllocType;
// Vulkan format definitions
typedef enum { typedef enum {
VK_FORMAT_UNDEFINED = 0, VK_FORMAT_UNDEFINED = 0,
VK_FORMAT_R4G4_UNORM = 1, VK_FORMAT_R4G4_UNORM = 1,
@@ -881,222 +880,193 @@ typedef enum {
VK_TIMESTAMP_TYPE_MAX_ENUM = 0x7FFFFFFF VK_TIMESTAMP_TYPE_MAX_ENUM = 0x7FFFFFFF
} VkTimestampType; } VkTimestampType;
// Format capability flags
typedef VkFlags VkFormatFeatureFlags;
typedef enum { typedef enum {
VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = VK_BIT(0), // Format can be used for sampled images (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types) VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001,
VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = VK_BIT(1), // Format can be used for storage images (STORAGE_IMAGE descriptor type) VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002,
VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = VK_BIT(2), // Format supports atomic operations in case it's used for storage images VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004,
VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = VK_BIT(3), // Format can be used for uniform texel buffers (TBOs) VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008,
VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = VK_BIT(4), // Format can be used for storage texel buffers (IBOs) VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010,
VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = VK_BIT(5), // Format supports atomic operations in case it's used for storage texel buffers VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020,
VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = VK_BIT(6), // Format can be used for vertex buffers (VBOs) VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040,
VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = VK_BIT(7), // Format can be used for color attachment images VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080,
VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = VK_BIT(8), // Format supports blending in case it's used for color attachment images VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100,
VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = VK_BIT(9), // Format can be used for depth/stencil attachment images VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200,
VK_FORMAT_FEATURE_CONVERSION_BIT = VK_BIT(10), // Format can be used as the source or destination of format converting blits VK_FORMAT_FEATURE_CONVERSION_BIT = 0x00000400,
} VkFormatFeatureFlagBits; } VkFormatFeatureFlagBits;
typedef VkFlags VkFormatFeatureFlags;
// Queue capabilities
typedef VkFlags VkQueueFlags;
typedef enum { typedef enum {
VK_QUEUE_GRAPHICS_BIT = VK_BIT(0), // Queue supports graphics operations VK_QUEUE_GRAPHICS_BIT = 0x00000001,
VK_QUEUE_COMPUTE_BIT = VK_BIT(1), // Queue supports compute operations VK_QUEUE_COMPUTE_BIT = 0x00000002,
VK_QUEUE_DMA_BIT = VK_BIT(2), // Queue supports DMA operations VK_QUEUE_DMA_BIT = 0x00000004,
VK_QUEUE_MEMMGR_BIT = VK_BIT(3), // Queue supports memory management operations VK_QUEUE_SPARSE_MEMMGR_BIT = 0x00000008,
VK_QUEUE_EXTENDED_BIT = VK_BIT(30), // Extended queue VK_QUEUE_EXTENDED_BIT = 0x40000000,
} VkQueueFlagBits; } VkQueueFlagBits;
typedef VkFlags VkQueueFlags;
// Memory properties passed into vkAllocMemory().
typedef VkFlags VkMemoryPropertyFlags;
typedef enum { typedef enum {
VK_MEMORY_PROPERTY_DEVICE_ONLY = 0, // If otherwise stated, then allocate memory on device VK_MEMORY_PROPERTY_DEVICE_ONLY = 0,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = VK_BIT(0), // Memory should be mappable by host VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000001,
VK_MEMORY_PROPERTY_HOST_DEVICE_COHERENT_BIT = VK_BIT(1), // Memory should be coherent between host and device accesses VK_MEMORY_PROPERTY_HOST_DEVICE_COHERENT_BIT = 0x00000002,
VK_MEMORY_PROPERTY_HOST_UNCACHED_BIT = VK_BIT(2), // Memory should not be cached by the host VK_MEMORY_PROPERTY_HOST_UNCACHED_BIT = 0x00000004,
VK_MEMORY_PROPERTY_HOST_WRITE_COMBINED_BIT = VK_BIT(3), // Memory should support host write combining VK_MEMORY_PROPERTY_HOST_WRITE_COMBINED_BIT = 0x00000008,
VK_MEMORY_PROPERTY_PREFER_HOST_LOCAL = VK_BIT(4), // If set, prefer host access VK_MEMORY_PROPERTY_PREFER_HOST_LOCAL = 0x00000010,
VK_MEMORY_PROPERTY_SHAREABLE_BIT = VK_BIT(5), VK_MEMORY_PROPERTY_SHAREABLE_BIT = 0x00000011,
} VkMemoryPropertyFlagBits; } VkMemoryPropertyFlagBits;
typedef VkFlags VkMemoryPropertyFlags;
// Device creation flags
typedef VkFlags VkDeviceCreateFlags;
typedef enum { typedef enum {
VK_DEVICE_CREATE_VALIDATION_BIT = VK_BIT(0), VK_DEVICE_CREATE_VALIDATION_BIT = 0x00000001,
VK_DEVICE_CREATE_MULTI_DEVICE_IQ_MATCH_BIT = VK_BIT(1), VK_DEVICE_CREATE_MULTI_DEVICE_IQ_MATCH_BIT = 0x00000002,
} VkDeviceCreateFlagBits; } VkDeviceCreateFlagBits;
typedef VkFlags VkDeviceCreateFlags;
// Memory mapping flags
typedef VkFlags VkMemoryMapFlags; typedef VkFlags VkMemoryMapFlags;
// Fence creation flags
typedef VkFlags VkFenceCreateFlags;
typedef enum { typedef enum {
VK_FENCE_CREATE_SIGNALED_BIT = VK_BIT(0), VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001,
} VkFenceCreateFlagBits; } VkFenceCreateFlagBits;
typedef VkFlags VkFenceCreateFlags;
// Semaphore creation flags
typedef VkFlags VkSemaphoreCreateFlags;
typedef enum { typedef enum {
VK_SEMAPHORE_CREATE_SHAREABLE_BIT = VK_BIT(0), VK_SEMAPHORE_CREATE_SHAREABLE_BIT = 0x00000001,
} VkSemaphoreCreateFlagBits; } VkSemaphoreCreateFlagBits;
typedef VkFlags VkSemaphoreCreateFlags;
// Event creation flags
typedef VkFlags VkEventCreateFlags; typedef VkFlags VkEventCreateFlags;
// Pipeline statistics flags
typedef VkFlags VkQueryPipelineStatisticFlags;
typedef enum VkQueryPipelineStatisticFlagBits_ { typedef enum VkQueryPipelineStatisticFlagBits_ {
VK_QUERY_PIPELINE_STATISTIC_IA_VERTICES_BIT = VK_BIT(0), // Optional VK_QUERY_PIPELINE_STATISTIC_IA_VERTICES_BIT = 0x00000001,
VK_QUERY_PIPELINE_STATISTIC_IA_PRIMITIVES_BIT = VK_BIT(1), // Optional VK_QUERY_PIPELINE_STATISTIC_IA_PRIMITIVES_BIT = 0x00000002,
VK_QUERY_PIPELINE_STATISTIC_VS_INVOCATIONS_BIT = VK_BIT(2), // Optional VK_QUERY_PIPELINE_STATISTIC_VS_INVOCATIONS_BIT = 0x00000004,
VK_QUERY_PIPELINE_STATISTIC_GS_INVOCATIONS_BIT = VK_BIT(3), // Optional VK_QUERY_PIPELINE_STATISTIC_GS_INVOCATIONS_BIT = 0x00000008,
VK_QUERY_PIPELINE_STATISTIC_GS_PRIMITIVES_BIT = VK_BIT(4), // Optional VK_QUERY_PIPELINE_STATISTIC_GS_PRIMITIVES_BIT = 0x00000010,
VK_QUERY_PIPELINE_STATISTIC_C_INVOCATIONS_BIT = VK_BIT(5), // Optional VK_QUERY_PIPELINE_STATISTIC_C_INVOCATIONS_BIT = 0x00000020,
VK_QUERY_PIPELINE_STATISTIC_C_PRIMITIVES_BIT = VK_BIT(6), // Optional VK_QUERY_PIPELINE_STATISTIC_C_PRIMITIVES_BIT = 0x00000040,
VK_QUERY_PIPELINE_STATISTIC_FS_INVOCATIONS_BIT = VK_BIT(7), // Optional VK_QUERY_PIPELINE_STATISTIC_FS_INVOCATIONS_BIT = 0x00000080,
VK_QUERY_PIPELINE_STATISTIC_TCS_PATCHES_BIT = VK_BIT(8), // Optional VK_QUERY_PIPELINE_STATISTIC_TCS_PATCHES_BIT = 0x00000100,
VK_QUERY_PIPELINE_STATISTIC_TES_INVOCATIONS_BIT = VK_BIT(9), // Optional VK_QUERY_PIPELINE_STATISTIC_TES_INVOCATIONS_BIT = 0x00000200,
VK_QUERY_PIPELINE_STATISTIC_CS_INVOCATIONS_BIT = VK_BIT(10), // Optional VK_QUERY_PIPELINE_STATISTIC_CS_INVOCATIONS_BIT = 0x00000400,
} VkQueryPipelineStatisticFlagBits; } VkQueryPipelineStatisticFlagBits;
typedef VkFlags VkQueryPipelineStatisticFlags;
// Query result flags
typedef VkFlags VkQueryResultFlags;
typedef enum { typedef enum {
VK_QUERY_RESULT_32_BIT = 0, // Results of the queries are written to the destination buffer as 32-bit values VK_QUERY_RESULT_32_BIT = 0,
VK_QUERY_RESULT_64_BIT = VK_BIT(0), // Results of the queries are written to the destination buffer as 64-bit values VK_QUERY_RESULT_64_BIT = 0x00000001,
VK_QUERY_RESULT_NO_WAIT_BIT = 0, // Results of the queries aren't waited on before proceeding with the result copy VK_QUERY_RESULT_NO_WAIT_BIT = 0,
VK_QUERY_RESULT_WAIT_BIT = VK_BIT(1), // Results of the queries are waited on before proceeding with the result copy VK_QUERY_RESULT_WAIT_BIT = 0x00000002,
VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = VK_BIT(2), // Besides the results of the query, the availability of the results is also written VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004,
VK_QUERY_RESULT_PARTIAL_BIT = VK_BIT(3), // Copy the partial results of the query even if the final results aren't available VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008,
} VkQueryResultFlagBits; } VkQueryResultFlagBits;
typedef VkFlags VkQueryResultFlags;
// Buffer usage flags
typedef VkFlags VkBufferUsageFlags;
typedef enum { typedef enum {
VK_BUFFER_USAGE_GENERAL = 0, // No special usage VK_BUFFER_USAGE_GENERAL = 0,
VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT = VK_BIT(0), // Can be used as a source of transfer operations VK_BUFFER_USAGE_TRANSFER_SOURCE_BIT = 0x00000001,
VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT = VK_BIT(1), // Can be used as a destination of transfer operations VK_BUFFER_USAGE_TRANSFER_DESTINATION_BIT = 0x00000002,
VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = VK_BIT(2), // Can be used as TBO VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004,
VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = VK_BIT(3), // Can be used as IBO VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008,
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = VK_BIT(4), // Can be used as UBO VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010,
VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = VK_BIT(5), // Can be used as SSBO VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020,
VK_BUFFER_USAGE_INDEX_BUFFER_BIT = VK_BIT(6), // Can be used as source of fixed function index fetch (index buffer) VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040,
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = VK_BIT(7), // Can be used as source of fixed function vertex fetch (VBO) VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080,
VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = VK_BIT(8), // Can be the source of indirect parameters (e.g. indirect buffer, parameter buffer) VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100,
} VkBufferUsageFlagBits; } VkBufferUsageFlagBits;
typedef VkFlags VkBufferUsageFlags;
// Buffer creation flags
typedef VkFlags VkBufferCreateFlags;
typedef enum { typedef enum {
VK_BUFFER_CREATE_SHAREABLE_BIT = VK_BIT(0), // Buffer should be shareable VK_BUFFER_CREATE_SHAREABLE_BIT = 0x00000001,
VK_BUFFER_CREATE_SPARSE_BIT = VK_BIT(1), // Buffer should support sparse backing VK_BUFFER_CREATE_SPARSE_BIT = 0x00000002,
} VkBufferCreateFlagBits; } VkBufferCreateFlagBits;
typedef VkFlags VkBufferCreateFlags;
// Image usage flags
typedef VkFlags VkImageUsageFlags;
typedef enum { typedef enum {
VK_IMAGE_USAGE_GENERAL = 0, // No special usage VK_IMAGE_USAGE_GENERAL = 0,
VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT = VK_BIT(0), // Can be used as a source of transfer operations VK_IMAGE_USAGE_TRANSFER_SOURCE_BIT = 0x00000001,
VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT = VK_BIT(1), // Can be used as a destination of transfer operations VK_IMAGE_USAGE_TRANSFER_DESTINATION_BIT = 0x00000002,
VK_IMAGE_USAGE_SAMPLED_BIT = VK_BIT(2), // Can be sampled from (SAMPLED_IMAGE and COMBINED_IMAGE_SAMPLER descriptor types) VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004,
VK_IMAGE_USAGE_STORAGE_BIT = VK_BIT(3), // Can be used as storage image (STORAGE_IMAGE descriptor type) VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008,
VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = VK_BIT(4), // Can be used as framebuffer color attachment VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010,
VK_IMAGE_USAGE_DEPTH_STENCIL_BIT = VK_BIT(5), // Can be used as framebuffer depth/stencil attachment VK_IMAGE_USAGE_DEPTH_STENCIL_BIT = 0x00000020,
VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = VK_BIT(6), // Image data not needed outside of rendering VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040,
} VkImageUsageFlagBits; } VkImageUsageFlagBits;
typedef VkFlags VkImageUsageFlags;
// Image creation flags
typedef VkFlags VkImageCreateFlags;
typedef enum { typedef enum {
VK_IMAGE_CREATE_INVARIANT_DATA_BIT = VK_BIT(0), VK_IMAGE_CREATE_INVARIANT_DATA_BIT = 0x00000001,
VK_IMAGE_CREATE_CLONEABLE_BIT = VK_BIT(1), VK_IMAGE_CREATE_CLONEABLE_BIT = 0x00000002,
VK_IMAGE_CREATE_SHAREABLE_BIT = VK_BIT(2), // Image should be shareable VK_IMAGE_CREATE_SHAREABLE_BIT = 0x00000004,
VK_IMAGE_CREATE_SPARSE_BIT = VK_BIT(3), // Image should support sparse backing VK_IMAGE_CREATE_SPARSE_BIT = 0x00000008,
VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = VK_BIT(4), // Allows image views to have different format than the base image VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000010,
VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = VK_BIT(5), // Allows creating image views with cube type from the created image VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000020,
} VkImageCreateFlagBits; } VkImageCreateFlagBits;
typedef VkFlags VkImageCreateFlags;
// Depth-stencil view creation flags
typedef VkFlags VkDepthStencilViewCreateFlags;
typedef enum { typedef enum {
VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT = VK_BIT(0), VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_DEPTH_BIT = 0x00000001,
VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT = VK_BIT(1), VK_DEPTH_STENCIL_VIEW_CREATE_READ_ONLY_STENCIL_BIT = 0x00000002,
} VkDepthStencilViewCreateFlagBits; } VkDepthStencilViewCreateFlagBits;
typedef VkFlags VkDepthStencilViewCreateFlags;
// Shader creation flags
typedef VkFlags VkShaderCreateFlags; typedef VkFlags VkShaderCreateFlags;
// Channel flags
typedef VkFlags VkChannelFlags;
typedef enum { typedef enum {
VK_CHANNEL_R_BIT = VK_BIT(0), VK_CHANNEL_R_BIT = 0x00000001,
VK_CHANNEL_G_BIT = VK_BIT(1), VK_CHANNEL_G_BIT = 0x00000002,
VK_CHANNEL_B_BIT = VK_BIT(2), VK_CHANNEL_B_BIT = 0x00000004,
VK_CHANNEL_A_BIT = VK_BIT(3), VK_CHANNEL_A_BIT = 0x00000008,
} VkChannelFlagBits; } VkChannelFlagBits;
typedef VkFlags VkChannelFlags;
// Pipeline creation flags
typedef VkFlags VkPipelineCreateFlags;
typedef enum { typedef enum {
VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = VK_BIT(0), VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001,
VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = VK_BIT(1), VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002,
} VkPipelineCreateFlagBits; } VkPipelineCreateFlagBits;
typedef VkFlags VkPipelineCreateFlags;
// Shader stage flags
typedef VkFlags VkShaderStageFlags;
typedef enum { typedef enum {
VK_SHADER_STAGE_VERTEX_BIT = VK_BIT(0), VK_SHADER_STAGE_VERTEX_BIT = 0x00000001,
VK_SHADER_STAGE_TESS_CONTROL_BIT = VK_BIT(1), VK_SHADER_STAGE_TESS_CONTROL_BIT = 0x00000002,
VK_SHADER_STAGE_TESS_EVALUATION_BIT = VK_BIT(2), VK_SHADER_STAGE_TESS_EVALUATION_BIT = 0x00000004,
VK_SHADER_STAGE_GEOMETRY_BIT = VK_BIT(3), VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008,
VK_SHADER_STAGE_FRAGMENT_BIT = VK_BIT(4), VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010,
VK_SHADER_STAGE_COMPUTE_BIT = VK_BIT(5), VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020,
VK_SHADER_STAGE_ALL = 0x7FFFFFFF,
VK_SHADER_STAGE_ALL = 0x7FFFFFFF,
} VkShaderStageFlagBits; } VkShaderStageFlagBits;
typedef VkFlags VkShaderStageFlags;
// Command buffer creation flags
typedef VkFlags VkCmdBufferCreateFlags; typedef VkFlags VkCmdBufferCreateFlags;
// Command buffer optimization flags
typedef VkFlags VkCmdBufferOptimizeFlags;
typedef enum { typedef enum {
VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT = VK_BIT(0), VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT = 0x00000001,
VK_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT = VK_BIT(1), VK_CMD_BUFFER_OPTIMIZE_PIPELINE_SWITCH_BIT = 0x00000002,
VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT = VK_BIT(2), VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT = 0x00000004,
VK_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT = VK_BIT(3), VK_CMD_BUFFER_OPTIMIZE_DESCRIPTOR_SET_SWITCH_BIT = 0x00000008,
} VkCmdBufferOptimizeFlagBits; } VkCmdBufferOptimizeFlagBits;
typedef VkFlags VkCmdBufferOptimizeFlags;
// Query control flags
typedef VkFlags VkQueryControlFlags;
typedef enum { typedef enum {
VK_QUERY_CONTROL_CONSERVATIVE_BIT = VK_BIT(0), // Allow conservative results to be collected by the query VK_QUERY_CONTROL_CONSERVATIVE_BIT = 0x00000001,
} VkQueryControlFlagBits; } VkQueryControlFlagBits;
typedef VkFlags VkQueryControlFlags;
// Memory output flags passed to resource transition commands
typedef VkFlags VkMemoryOutputFlags;
typedef enum { typedef enum {
VK_MEMORY_OUTPUT_CPU_WRITE_BIT = VK_BIT(0), // Controls output coherency of CPU writes VK_MEMORY_OUTPUT_CPU_WRITE_BIT = 0x00000001,
VK_MEMORY_OUTPUT_SHADER_WRITE_BIT = VK_BIT(1), // Controls output coherency of generic shader writes VK_MEMORY_OUTPUT_SHADER_WRITE_BIT = 0x00000002,
VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT = VK_BIT(2), // Controls output coherency of color attachment writes VK_MEMORY_OUTPUT_COLOR_ATTACHMENT_BIT = 0x00000004,
VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT = VK_BIT(3), // Controls output coherency of depth/stencil attachment writes VK_MEMORY_OUTPUT_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000008,
VK_MEMORY_OUTPUT_TRANSFER_BIT = VK_BIT(4), // Controls output coherency of transfer operations VK_MEMORY_OUTPUT_TRANSFER_BIT = 0x00000010,
} VkMemoryOutputFlagBits; } VkMemoryOutputFlagBits;
typedef VkFlags VkMemoryOutputFlags;
// Memory input flags passed to resource transition commands
typedef VkFlags VkMemoryInputFlags;
typedef enum { typedef enum {
VK_MEMORY_INPUT_CPU_READ_BIT = VK_BIT(0), // Controls input coherency of CPU reads VK_MEMORY_INPUT_CPU_READ_BIT = 0x00000001,
VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT = VK_BIT(1), // Controls input coherency of indirect command reads VK_MEMORY_INPUT_INDIRECT_COMMAND_BIT = 0x00000002,
VK_MEMORY_INPUT_INDEX_FETCH_BIT = VK_BIT(2), // Controls input coherency of index fetches VK_MEMORY_INPUT_INDEX_FETCH_BIT = 0x00000004,
VK_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT = VK_BIT(3), // Controls input coherency of vertex attribute fetches VK_MEMORY_INPUT_VERTEX_ATTRIBUTE_FETCH_BIT = 0x00000008,
VK_MEMORY_INPUT_UNIFORM_READ_BIT = VK_BIT(4), // Controls input coherency of uniform buffer reads VK_MEMORY_INPUT_UNIFORM_READ_BIT = 0x00000010,
VK_MEMORY_INPUT_SHADER_READ_BIT = VK_BIT(5), // Controls input coherency of generic shader reads VK_MEMORY_INPUT_SHADER_READ_BIT = 0x00000020,
VK_MEMORY_INPUT_COLOR_ATTACHMENT_BIT = VK_BIT(6), // Controls input coherency of color attachment reads VK_MEMORY_INPUT_COLOR_ATTACHMENT_BIT = 0x00000040,
VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT = VK_BIT(7), // Controls input coherency of depth/stencil attachment reads VK_MEMORY_INPUT_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000080,
VK_MEMORY_INPUT_TRANSFER_BIT = VK_BIT(8), // Controls input coherency of transfer operations VK_MEMORY_INPUT_TRANSFER_BIT = 0x00000100,
} VkMemoryInputFlagBits; } VkMemoryInputFlagBits;
typedef VkFlags VkMemoryInputFlags;
typedef enum { typedef enum {
VK_PROVOKING_VERTEX_FIRST = 0x00000000, VK_PROVOKING_VERTEX_FIRST = 0x00000000,