1 module erupted.types; 2 3 alias uint8_t = ubyte; 4 alias uint16_t = ushort; 5 alias uint32_t = uint; 6 alias uint64_t = ulong; 7 alias int8_t = byte; 8 alias int16_t = short; 9 alias int32_t = int; 10 alias int64_t = long; 11 12 @nogc nothrow: 13 pure { 14 uint VK_MAKE_VERSION( uint major, uint minor, uint patch ) { 15 return ( major << 22 ) | ( minor << 12 ) | ( patch ); 16 } 17 18 // Vulkan 1.0 version number 19 uint VK_API_VERSION_1_0() { return VK_MAKE_VERSION( 1, 0, 0 ); } 20 21 uint VK_VERSION_MAJOR( uint ver ) { return ver >> 22; } 22 uint VK_VERSION_MINOR( uint ver ) { return ( ver >> 12 ) & 0x3ff; } 23 uint VK_VERSION_PATCH( uint ver ) { return ver & 0xfff; } 24 } 25 26 // Linkage of debug and allocation callbacks 27 extern( System ): 28 29 // Version of corresponding c header file 30 enum VK_HEADER_VERSION = 32; 31 32 enum VK_NULL_HANDLE = null; 33 34 enum VK_DEFINE_HANDLE( string name ) = "struct "~name~"_handle; alias "~name~" = "~name~"_handle*;"; 35 36 version( X86_64 ) { 37 alias VK_DEFINE_NON_DISPATCHABLE_HANDLE( string name ) = VK_DEFINE_HANDLE!name; 38 enum VK_NULL_ND_HANDLE = null; 39 } else { 40 enum VK_DEFINE_NON_DISPATCHABLE_HANDLE( string name ) = "alias "~name~" = ulong;"; 41 enum VK_NULL_ND_HANDLE = 0uL; 42 } 43 44 // VK_VERSION_1_0 45 alias VkFlags = uint32_t; 46 alias VkBool32 = uint32_t; 47 alias VkDeviceSize = uint64_t; 48 alias VkSampleMask = uint32_t; 49 50 mixin( VK_DEFINE_HANDLE!q{VkInstance} ); 51 mixin( VK_DEFINE_HANDLE!q{VkPhysicalDevice} ); 52 mixin( VK_DEFINE_HANDLE!q{VkDevice} ); 53 mixin( VK_DEFINE_HANDLE!q{VkQueue} ); 54 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkSemaphore} ); 55 mixin( VK_DEFINE_HANDLE!q{VkCommandBuffer} ); 56 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkFence} ); 57 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkDeviceMemory} ); 58 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkBuffer} ); 59 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkImage} ); 60 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkEvent} ); 61 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkQueryPool} ); 62 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkBufferView} ); 63 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkImageView} ); 64 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkShaderModule} ); 65 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkPipelineCache} ); 66 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkPipelineLayout} ); 67 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkRenderPass} ); 68 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkPipeline} ); 69 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkDescriptorSetLayout} ); 70 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkSampler} ); 71 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkDescriptorPool} ); 72 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkDescriptorSet} ); 73 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkFramebuffer} ); 74 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkCommandPool} ); 75 76 enum VK_LOD_CLAMP_NONE = 1000.0f; 77 enum VK_REMAINING_MIP_LEVELS = (~0U); 78 enum VK_REMAINING_ARRAY_LAYERS = (~0U); 79 enum VK_WHOLE_SIZE = (~0UL); 80 enum VK_ATTACHMENT_UNUSED = (~0U); 81 enum VK_TRUE = 1; 82 enum VK_FALSE = 0; 83 enum VK_QUEUE_FAMILY_IGNORED = (~0U); 84 enum VK_SUBPASS_EXTERNAL = (~0U); 85 enum VK_MAX_PHYSICAL_DEVICE_NAME_SIZE = 256; 86 enum VK_UUID_SIZE = 16; 87 enum VK_MAX_MEMORY_TYPES = 32; 88 enum VK_MAX_MEMORY_HEAPS = 16; 89 enum VK_MAX_EXTENSION_NAME_SIZE = 256; 90 enum VK_MAX_DESCRIPTION_SIZE = 256; 91 92 93 enum VkPipelineCacheHeaderVersion { 94 VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1, 95 VK_PIPELINE_CACHE_HEADER_VERSION_BEGIN_RANGE = VK_PIPELINE_CACHE_HEADER_VERSION_ONE, 96 VK_PIPELINE_CACHE_HEADER_VERSION_END_RANGE = VK_PIPELINE_CACHE_HEADER_VERSION_ONE, 97 VK_PIPELINE_CACHE_HEADER_VERSION_RANGE_SIZE = ( VK_PIPELINE_CACHE_HEADER_VERSION_ONE - VK_PIPELINE_CACHE_HEADER_VERSION_ONE + 1 ), 98 VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF 99 } 100 101 // VkPipelineCacheHeaderVersion global enums 102 enum VK_PIPELINE_CACHE_HEADER_VERSION_ONE = VkPipelineCacheHeaderVersion.VK_PIPELINE_CACHE_HEADER_VERSION_ONE; 103 enum VK_PIPELINE_CACHE_HEADER_VERSION_BEGIN_RANGE = VkPipelineCacheHeaderVersion.VK_PIPELINE_CACHE_HEADER_VERSION_BEGIN_RANGE; 104 enum VK_PIPELINE_CACHE_HEADER_VERSION_END_RANGE = VkPipelineCacheHeaderVersion.VK_PIPELINE_CACHE_HEADER_VERSION_END_RANGE; 105 enum VK_PIPELINE_CACHE_HEADER_VERSION_RANGE_SIZE = VkPipelineCacheHeaderVersion.VK_PIPELINE_CACHE_HEADER_VERSION_RANGE_SIZE; 106 enum VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = VkPipelineCacheHeaderVersion.VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM; 107 108 enum VkResult { 109 VK_SUCCESS = 0, 110 VK_NOT_READY = 1, 111 VK_TIMEOUT = 2, 112 VK_EVENT_SET = 3, 113 VK_EVENT_RESET = 4, 114 VK_INCOMPLETE = 5, 115 VK_ERROR_OUT_OF_HOST_MEMORY = -1, 116 VK_ERROR_OUT_OF_DEVICE_MEMORY = -2, 117 VK_ERROR_INITIALIZATION_FAILED = -3, 118 VK_ERROR_DEVICE_LOST = -4, 119 VK_ERROR_MEMORY_MAP_FAILED = -5, 120 VK_ERROR_LAYER_NOT_PRESENT = -6, 121 VK_ERROR_EXTENSION_NOT_PRESENT = -7, 122 VK_ERROR_FEATURE_NOT_PRESENT = -8, 123 VK_ERROR_INCOMPATIBLE_DRIVER = -9, 124 VK_ERROR_TOO_MANY_OBJECTS = -10, 125 VK_ERROR_FORMAT_NOT_SUPPORTED = -11, 126 VK_ERROR_FRAGMENTED_POOL = -12, 127 VK_ERROR_SURFACE_LOST_KHR = -1000000000, 128 VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001, 129 VK_SUBOPTIMAL_KHR = 1000001003, 130 VK_ERROR_OUT_OF_DATE_KHR = -1000001004, 131 VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001, 132 VK_ERROR_VALIDATION_FAILED_EXT = -1000011001, 133 VK_ERROR_INVALID_SHADER_NV = -1000012000, 134 VK_NV_EXTENSION_1_ERROR = -1000013000, 135 VK_RESULT_BEGIN_RANGE = VK_ERROR_FRAGMENTED_POOL, 136 VK_RESULT_END_RANGE = VK_INCOMPLETE, 137 VK_RESULT_RANGE_SIZE = ( VK_INCOMPLETE - VK_ERROR_FRAGMENTED_POOL + 1 ), 138 VK_RESULT_MAX_ENUM = 0x7FFFFFFF 139 } 140 141 // VkResult global enums 142 enum VK_SUCCESS = VkResult.VK_SUCCESS; 143 enum VK_NOT_READY = VkResult.VK_NOT_READY; 144 enum VK_TIMEOUT = VkResult.VK_TIMEOUT; 145 enum VK_EVENT_SET = VkResult.VK_EVENT_SET; 146 enum VK_EVENT_RESET = VkResult.VK_EVENT_RESET; 147 enum VK_INCOMPLETE = VkResult.VK_INCOMPLETE; 148 enum VK_ERROR_OUT_OF_HOST_MEMORY = VkResult.VK_ERROR_OUT_OF_HOST_MEMORY; 149 enum VK_ERROR_OUT_OF_DEVICE_MEMORY = VkResult.VK_ERROR_OUT_OF_DEVICE_MEMORY; 150 enum VK_ERROR_INITIALIZATION_FAILED = VkResult.VK_ERROR_INITIALIZATION_FAILED; 151 enum VK_ERROR_DEVICE_LOST = VkResult.VK_ERROR_DEVICE_LOST; 152 enum VK_ERROR_MEMORY_MAP_FAILED = VkResult.VK_ERROR_MEMORY_MAP_FAILED; 153 enum VK_ERROR_LAYER_NOT_PRESENT = VkResult.VK_ERROR_LAYER_NOT_PRESENT; 154 enum VK_ERROR_EXTENSION_NOT_PRESENT = VkResult.VK_ERROR_EXTENSION_NOT_PRESENT; 155 enum VK_ERROR_FEATURE_NOT_PRESENT = VkResult.VK_ERROR_FEATURE_NOT_PRESENT; 156 enum VK_ERROR_INCOMPATIBLE_DRIVER = VkResult.VK_ERROR_INCOMPATIBLE_DRIVER; 157 enum VK_ERROR_TOO_MANY_OBJECTS = VkResult.VK_ERROR_TOO_MANY_OBJECTS; 158 enum VK_ERROR_FORMAT_NOT_SUPPORTED = VkResult.VK_ERROR_FORMAT_NOT_SUPPORTED; 159 enum VK_ERROR_FRAGMENTED_POOL = VkResult.VK_ERROR_FRAGMENTED_POOL; 160 enum VK_ERROR_SURFACE_LOST_KHR = VkResult.VK_ERROR_SURFACE_LOST_KHR; 161 enum VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = VkResult.VK_ERROR_NATIVE_WINDOW_IN_USE_KHR; 162 enum VK_SUBOPTIMAL_KHR = VkResult.VK_SUBOPTIMAL_KHR; 163 enum VK_ERROR_OUT_OF_DATE_KHR = VkResult.VK_ERROR_OUT_OF_DATE_KHR; 164 enum VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = VkResult.VK_ERROR_INCOMPATIBLE_DISPLAY_KHR; 165 enum VK_ERROR_VALIDATION_FAILED_EXT = VkResult.VK_ERROR_VALIDATION_FAILED_EXT; 166 enum VK_ERROR_INVALID_SHADER_NV = VkResult.VK_ERROR_INVALID_SHADER_NV; 167 enum VK_NV_EXTENSION_1_ERROR = VkResult.VK_NV_EXTENSION_1_ERROR; 168 enum VK_RESULT_BEGIN_RANGE = VkResult.VK_RESULT_BEGIN_RANGE; 169 enum VK_RESULT_END_RANGE = VkResult.VK_RESULT_END_RANGE; 170 enum VK_RESULT_RANGE_SIZE = VkResult.VK_RESULT_RANGE_SIZE; 171 enum VK_RESULT_MAX_ENUM = VkResult.VK_RESULT_MAX_ENUM; 172 173 enum VkStructureType { 174 VK_STRUCTURE_TYPE_APPLICATION_INFO = 0, 175 VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1, 176 VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2, 177 VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3, 178 VK_STRUCTURE_TYPE_SUBMIT_INFO = 4, 179 VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5, 180 VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6, 181 VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7, 182 VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8, 183 VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9, 184 VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10, 185 VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11, 186 VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12, 187 VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13, 188 VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14, 189 VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15, 190 VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16, 191 VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17, 192 VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18, 193 VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19, 194 VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20, 195 VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21, 196 VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22, 197 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23, 198 VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24, 199 VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25, 200 VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26, 201 VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27, 202 VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28, 203 VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29, 204 VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30, 205 VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31, 206 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32, 207 VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33, 208 VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34, 209 VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35, 210 VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36, 211 VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37, 212 VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38, 213 VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39, 214 VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40, 215 VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41, 216 VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42, 217 VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43, 218 VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44, 219 VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45, 220 VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46, 221 VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47, 222 VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48, 223 VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000, 224 VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001, 225 VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000, 226 VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001, 227 VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000, 228 VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000, 229 VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000, 230 VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000, 231 VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR = 1000007000, 232 VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000, 233 VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000, 234 VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = 1000011000, 235 VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = 1000018000, 236 VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = 1000022000, 237 VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = 1000022001, 238 VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = 1000022002, 239 VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000, 240 VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001, 241 VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002, 242 VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = 1000056000, 243 VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV = 1000056001, 244 VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057000, 245 VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057001, 246 VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV = 1000058000, 247 VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT = 1000061000, 248 VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO, 249 VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO, 250 VK_STRUCTURE_TYPE_RANGE_SIZE = ( VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1 ), 251 VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF 252 } 253 254 // VkStructureType global enums 255 enum VK_STRUCTURE_TYPE_APPLICATION_INFO = VkStructureType.VK_STRUCTURE_TYPE_APPLICATION_INFO; 256 enum VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; 257 enum VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO; 258 enum VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO; 259 enum VK_STRUCTURE_TYPE_SUBMIT_INFO = VkStructureType.VK_STRUCTURE_TYPE_SUBMIT_INFO; 260 enum VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; 261 enum VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = VkStructureType.VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE; 262 enum VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = VkStructureType.VK_STRUCTURE_TYPE_BIND_SPARSE_INFO; 263 enum VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_FENCE_CREATE_INFO; 264 enum VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO; 265 enum VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_EVENT_CREATE_INFO; 266 enum VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO; 267 enum VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO; 268 enum VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO; 269 enum VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; 270 enum VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO; 271 enum VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO; 272 enum VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO; 273 enum VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; 274 enum VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; 275 enum VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; 276 enum VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO; 277 enum VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; 278 enum VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; 279 enum VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; 280 enum VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; 281 enum VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; 282 enum VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; 283 enum VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; 284 enum VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO; 285 enum VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; 286 enum VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO; 287 enum VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; 288 enum VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO; 289 enum VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; 290 enum VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = VkStructureType.VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; 291 enum VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = VkStructureType.VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET; 292 enum VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO; 293 enum VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO; 294 enum VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO; 295 enum VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; 296 enum VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = VkStructureType.VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO; 297 enum VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = VkStructureType.VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; 298 enum VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = VkStructureType.VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO; 299 enum VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = VkStructureType.VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER; 300 enum VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = VkStructureType.VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; 301 enum VK_STRUCTURE_TYPE_MEMORY_BARRIER = VkStructureType.VK_STRUCTURE_TYPE_MEMORY_BARRIER; 302 enum VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO; 303 enum VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = VkStructureType.VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO; 304 enum VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = VkStructureType.VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR; 305 enum VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = VkStructureType.VK_STRUCTURE_TYPE_PRESENT_INFO_KHR; 306 enum VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = VkStructureType.VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR; 307 enum VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = VkStructureType.VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR; 308 enum VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = VkStructureType.VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR; 309 enum VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = VkStructureType.VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR; 310 enum VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = VkStructureType.VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR; 311 enum VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = VkStructureType.VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR; 312 enum VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR = VkStructureType.VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR; 313 enum VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = VkStructureType.VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR; 314 enum VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = VkStructureType.VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR; 315 enum VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = VkStructureType.VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT; 316 enum VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = VkStructureType.VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD; 317 enum VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = VkStructureType.VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT; 318 enum VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = VkStructureType.VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT; 319 enum VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = VkStructureType.VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT; 320 enum VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = VkStructureType.VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV; 321 enum VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = VkStructureType.VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV; 322 enum VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = VkStructureType.VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV; 323 enum VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = VkStructureType.VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV; 324 enum VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV = VkStructureType.VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV; 325 enum VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = VkStructureType.VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV; 326 enum VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV = VkStructureType.VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV; 327 enum VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV = VkStructureType.VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV; 328 enum VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT = VkStructureType.VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT; 329 enum VK_STRUCTURE_TYPE_BEGIN_RANGE = VkStructureType.VK_STRUCTURE_TYPE_BEGIN_RANGE; 330 enum VK_STRUCTURE_TYPE_END_RANGE = VkStructureType.VK_STRUCTURE_TYPE_END_RANGE; 331 enum VK_STRUCTURE_TYPE_RANGE_SIZE = VkStructureType.VK_STRUCTURE_TYPE_RANGE_SIZE; 332 enum VK_STRUCTURE_TYPE_MAX_ENUM = VkStructureType.VK_STRUCTURE_TYPE_MAX_ENUM; 333 334 enum VkSystemAllocationScope { 335 VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0, 336 VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1, 337 VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2, 338 VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3, 339 VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4, 340 VK_SYSTEM_ALLOCATION_SCOPE_BEGIN_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_COMMAND, 341 VK_SYSTEM_ALLOCATION_SCOPE_END_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE, 342 VK_SYSTEM_ALLOCATION_SCOPE_RANGE_SIZE = ( VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE - VK_SYSTEM_ALLOCATION_SCOPE_COMMAND + 1 ), 343 VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF 344 } 345 346 // VkSystemAllocationScope global enums 347 enum VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = VkSystemAllocationScope.VK_SYSTEM_ALLOCATION_SCOPE_COMMAND; 348 enum VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = VkSystemAllocationScope.VK_SYSTEM_ALLOCATION_SCOPE_OBJECT; 349 enum VK_SYSTEM_ALLOCATION_SCOPE_CACHE = VkSystemAllocationScope.VK_SYSTEM_ALLOCATION_SCOPE_CACHE; 350 enum VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = VkSystemAllocationScope.VK_SYSTEM_ALLOCATION_SCOPE_DEVICE; 351 enum VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = VkSystemAllocationScope.VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE; 352 enum VK_SYSTEM_ALLOCATION_SCOPE_BEGIN_RANGE = VkSystemAllocationScope.VK_SYSTEM_ALLOCATION_SCOPE_BEGIN_RANGE; 353 enum VK_SYSTEM_ALLOCATION_SCOPE_END_RANGE = VkSystemAllocationScope.VK_SYSTEM_ALLOCATION_SCOPE_END_RANGE; 354 enum VK_SYSTEM_ALLOCATION_SCOPE_RANGE_SIZE = VkSystemAllocationScope.VK_SYSTEM_ALLOCATION_SCOPE_RANGE_SIZE; 355 enum VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = VkSystemAllocationScope.VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM; 356 357 enum VkInternalAllocationType { 358 VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0, 359 VK_INTERNAL_ALLOCATION_TYPE_BEGIN_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE, 360 VK_INTERNAL_ALLOCATION_TYPE_END_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE, 361 VK_INTERNAL_ALLOCATION_TYPE_RANGE_SIZE = ( VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE - VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE + 1 ), 362 VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF 363 } 364 365 // VkInternalAllocationType global enums 366 enum VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = VkInternalAllocationType.VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE; 367 enum VK_INTERNAL_ALLOCATION_TYPE_BEGIN_RANGE = VkInternalAllocationType.VK_INTERNAL_ALLOCATION_TYPE_BEGIN_RANGE; 368 enum VK_INTERNAL_ALLOCATION_TYPE_END_RANGE = VkInternalAllocationType.VK_INTERNAL_ALLOCATION_TYPE_END_RANGE; 369 enum VK_INTERNAL_ALLOCATION_TYPE_RANGE_SIZE = VkInternalAllocationType.VK_INTERNAL_ALLOCATION_TYPE_RANGE_SIZE; 370 enum VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = VkInternalAllocationType.VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM; 371 372 enum VkFormat { 373 VK_FORMAT_UNDEFINED = 0, 374 VK_FORMAT_R4G4_UNORM_PACK8 = 1, 375 VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2, 376 VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3, 377 VK_FORMAT_R5G6B5_UNORM_PACK16 = 4, 378 VK_FORMAT_B5G6R5_UNORM_PACK16 = 5, 379 VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6, 380 VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7, 381 VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8, 382 VK_FORMAT_R8_UNORM = 9, 383 VK_FORMAT_R8_SNORM = 10, 384 VK_FORMAT_R8_USCALED = 11, 385 VK_FORMAT_R8_SSCALED = 12, 386 VK_FORMAT_R8_UINT = 13, 387 VK_FORMAT_R8_SINT = 14, 388 VK_FORMAT_R8_SRGB = 15, 389 VK_FORMAT_R8G8_UNORM = 16, 390 VK_FORMAT_R8G8_SNORM = 17, 391 VK_FORMAT_R8G8_USCALED = 18, 392 VK_FORMAT_R8G8_SSCALED = 19, 393 VK_FORMAT_R8G8_UINT = 20, 394 VK_FORMAT_R8G8_SINT = 21, 395 VK_FORMAT_R8G8_SRGB = 22, 396 VK_FORMAT_R8G8B8_UNORM = 23, 397 VK_FORMAT_R8G8B8_SNORM = 24, 398 VK_FORMAT_R8G8B8_USCALED = 25, 399 VK_FORMAT_R8G8B8_SSCALED = 26, 400 VK_FORMAT_R8G8B8_UINT = 27, 401 VK_FORMAT_R8G8B8_SINT = 28, 402 VK_FORMAT_R8G8B8_SRGB = 29, 403 VK_FORMAT_B8G8R8_UNORM = 30, 404 VK_FORMAT_B8G8R8_SNORM = 31, 405 VK_FORMAT_B8G8R8_USCALED = 32, 406 VK_FORMAT_B8G8R8_SSCALED = 33, 407 VK_FORMAT_B8G8R8_UINT = 34, 408 VK_FORMAT_B8G8R8_SINT = 35, 409 VK_FORMAT_B8G8R8_SRGB = 36, 410 VK_FORMAT_R8G8B8A8_UNORM = 37, 411 VK_FORMAT_R8G8B8A8_SNORM = 38, 412 VK_FORMAT_R8G8B8A8_USCALED = 39, 413 VK_FORMAT_R8G8B8A8_SSCALED = 40, 414 VK_FORMAT_R8G8B8A8_UINT = 41, 415 VK_FORMAT_R8G8B8A8_SINT = 42, 416 VK_FORMAT_R8G8B8A8_SRGB = 43, 417 VK_FORMAT_B8G8R8A8_UNORM = 44, 418 VK_FORMAT_B8G8R8A8_SNORM = 45, 419 VK_FORMAT_B8G8R8A8_USCALED = 46, 420 VK_FORMAT_B8G8R8A8_SSCALED = 47, 421 VK_FORMAT_B8G8R8A8_UINT = 48, 422 VK_FORMAT_B8G8R8A8_SINT = 49, 423 VK_FORMAT_B8G8R8A8_SRGB = 50, 424 VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51, 425 VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52, 426 VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53, 427 VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54, 428 VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55, 429 VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56, 430 VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57, 431 VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58, 432 VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59, 433 VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60, 434 VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61, 435 VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62, 436 VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63, 437 VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64, 438 VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65, 439 VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66, 440 VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67, 441 VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68, 442 VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69, 443 VK_FORMAT_R16_UNORM = 70, 444 VK_FORMAT_R16_SNORM = 71, 445 VK_FORMAT_R16_USCALED = 72, 446 VK_FORMAT_R16_SSCALED = 73, 447 VK_FORMAT_R16_UINT = 74, 448 VK_FORMAT_R16_SINT = 75, 449 VK_FORMAT_R16_SFLOAT = 76, 450 VK_FORMAT_R16G16_UNORM = 77, 451 VK_FORMAT_R16G16_SNORM = 78, 452 VK_FORMAT_R16G16_USCALED = 79, 453 VK_FORMAT_R16G16_SSCALED = 80, 454 VK_FORMAT_R16G16_UINT = 81, 455 VK_FORMAT_R16G16_SINT = 82, 456 VK_FORMAT_R16G16_SFLOAT = 83, 457 VK_FORMAT_R16G16B16_UNORM = 84, 458 VK_FORMAT_R16G16B16_SNORM = 85, 459 VK_FORMAT_R16G16B16_USCALED = 86, 460 VK_FORMAT_R16G16B16_SSCALED = 87, 461 VK_FORMAT_R16G16B16_UINT = 88, 462 VK_FORMAT_R16G16B16_SINT = 89, 463 VK_FORMAT_R16G16B16_SFLOAT = 90, 464 VK_FORMAT_R16G16B16A16_UNORM = 91, 465 VK_FORMAT_R16G16B16A16_SNORM = 92, 466 VK_FORMAT_R16G16B16A16_USCALED = 93, 467 VK_FORMAT_R16G16B16A16_SSCALED = 94, 468 VK_FORMAT_R16G16B16A16_UINT = 95, 469 VK_FORMAT_R16G16B16A16_SINT = 96, 470 VK_FORMAT_R16G16B16A16_SFLOAT = 97, 471 VK_FORMAT_R32_UINT = 98, 472 VK_FORMAT_R32_SINT = 99, 473 VK_FORMAT_R32_SFLOAT = 100, 474 VK_FORMAT_R32G32_UINT = 101, 475 VK_FORMAT_R32G32_SINT = 102, 476 VK_FORMAT_R32G32_SFLOAT = 103, 477 VK_FORMAT_R32G32B32_UINT = 104, 478 VK_FORMAT_R32G32B32_SINT = 105, 479 VK_FORMAT_R32G32B32_SFLOAT = 106, 480 VK_FORMAT_R32G32B32A32_UINT = 107, 481 VK_FORMAT_R32G32B32A32_SINT = 108, 482 VK_FORMAT_R32G32B32A32_SFLOAT = 109, 483 VK_FORMAT_R64_UINT = 110, 484 VK_FORMAT_R64_SINT = 111, 485 VK_FORMAT_R64_SFLOAT = 112, 486 VK_FORMAT_R64G64_UINT = 113, 487 VK_FORMAT_R64G64_SINT = 114, 488 VK_FORMAT_R64G64_SFLOAT = 115, 489 VK_FORMAT_R64G64B64_UINT = 116, 490 VK_FORMAT_R64G64B64_SINT = 117, 491 VK_FORMAT_R64G64B64_SFLOAT = 118, 492 VK_FORMAT_R64G64B64A64_UINT = 119, 493 VK_FORMAT_R64G64B64A64_SINT = 120, 494 VK_FORMAT_R64G64B64A64_SFLOAT = 121, 495 VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122, 496 VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123, 497 VK_FORMAT_D16_UNORM = 124, 498 VK_FORMAT_X8_D24_UNORM_PACK32 = 125, 499 VK_FORMAT_D32_SFLOAT = 126, 500 VK_FORMAT_S8_UINT = 127, 501 VK_FORMAT_D16_UNORM_S8_UINT = 128, 502 VK_FORMAT_D24_UNORM_S8_UINT = 129, 503 VK_FORMAT_D32_SFLOAT_S8_UINT = 130, 504 VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131, 505 VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132, 506 VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133, 507 VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134, 508 VK_FORMAT_BC2_UNORM_BLOCK = 135, 509 VK_FORMAT_BC2_SRGB_BLOCK = 136, 510 VK_FORMAT_BC3_UNORM_BLOCK = 137, 511 VK_FORMAT_BC3_SRGB_BLOCK = 138, 512 VK_FORMAT_BC4_UNORM_BLOCK = 139, 513 VK_FORMAT_BC4_SNORM_BLOCK = 140, 514 VK_FORMAT_BC5_UNORM_BLOCK = 141, 515 VK_FORMAT_BC5_SNORM_BLOCK = 142, 516 VK_FORMAT_BC6H_UFLOAT_BLOCK = 143, 517 VK_FORMAT_BC6H_SFLOAT_BLOCK = 144, 518 VK_FORMAT_BC7_UNORM_BLOCK = 145, 519 VK_FORMAT_BC7_SRGB_BLOCK = 146, 520 VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147, 521 VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148, 522 VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149, 523 VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150, 524 VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151, 525 VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152, 526 VK_FORMAT_EAC_R11_UNORM_BLOCK = 153, 527 VK_FORMAT_EAC_R11_SNORM_BLOCK = 154, 528 VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155, 529 VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156, 530 VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157, 531 VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158, 532 VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159, 533 VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160, 534 VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161, 535 VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162, 536 VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163, 537 VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164, 538 VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165, 539 VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166, 540 VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167, 541 VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168, 542 VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169, 543 VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170, 544 VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171, 545 VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172, 546 VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173, 547 VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174, 548 VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175, 549 VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176, 550 VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177, 551 VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178, 552 VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179, 553 VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180, 554 VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181, 555 VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182, 556 VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183, 557 VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184, 558 VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG = 1000054000, 559 VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG = 1000054001, 560 VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG = 1000054002, 561 VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG = 1000054003, 562 VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG = 1000054004, 563 VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005, 564 VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006, 565 VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007, 566 VK_FORMAT_BEGIN_RANGE = VK_FORMAT_UNDEFINED, 567 VK_FORMAT_END_RANGE = VK_FORMAT_ASTC_12x12_SRGB_BLOCK, 568 VK_FORMAT_RANGE_SIZE = ( VK_FORMAT_ASTC_12x12_SRGB_BLOCK - VK_FORMAT_UNDEFINED + 1 ), 569 VK_FORMAT_MAX_ENUM = 0x7FFFFFFF 570 } 571 572 // VkFormat global enums 573 enum VK_FORMAT_UNDEFINED = VkFormat.VK_FORMAT_UNDEFINED; 574 enum VK_FORMAT_R4G4_UNORM_PACK8 = VkFormat.VK_FORMAT_R4G4_UNORM_PACK8; 575 enum VK_FORMAT_R4G4B4A4_UNORM_PACK16 = VkFormat.VK_FORMAT_R4G4B4A4_UNORM_PACK16; 576 enum VK_FORMAT_B4G4R4A4_UNORM_PACK16 = VkFormat.VK_FORMAT_B4G4R4A4_UNORM_PACK16; 577 enum VK_FORMAT_R5G6B5_UNORM_PACK16 = VkFormat.VK_FORMAT_R5G6B5_UNORM_PACK16; 578 enum VK_FORMAT_B5G6R5_UNORM_PACK16 = VkFormat.VK_FORMAT_B5G6R5_UNORM_PACK16; 579 enum VK_FORMAT_R5G5B5A1_UNORM_PACK16 = VkFormat.VK_FORMAT_R5G5B5A1_UNORM_PACK16; 580 enum VK_FORMAT_B5G5R5A1_UNORM_PACK16 = VkFormat.VK_FORMAT_B5G5R5A1_UNORM_PACK16; 581 enum VK_FORMAT_A1R5G5B5_UNORM_PACK16 = VkFormat.VK_FORMAT_A1R5G5B5_UNORM_PACK16; 582 enum VK_FORMAT_R8_UNORM = VkFormat.VK_FORMAT_R8_UNORM; 583 enum VK_FORMAT_R8_SNORM = VkFormat.VK_FORMAT_R8_SNORM; 584 enum VK_FORMAT_R8_USCALED = VkFormat.VK_FORMAT_R8_USCALED; 585 enum VK_FORMAT_R8_SSCALED = VkFormat.VK_FORMAT_R8_SSCALED; 586 enum VK_FORMAT_R8_UINT = VkFormat.VK_FORMAT_R8_UINT; 587 enum VK_FORMAT_R8_SINT = VkFormat.VK_FORMAT_R8_SINT; 588 enum VK_FORMAT_R8_SRGB = VkFormat.VK_FORMAT_R8_SRGB; 589 enum VK_FORMAT_R8G8_UNORM = VkFormat.VK_FORMAT_R8G8_UNORM; 590 enum VK_FORMAT_R8G8_SNORM = VkFormat.VK_FORMAT_R8G8_SNORM; 591 enum VK_FORMAT_R8G8_USCALED = VkFormat.VK_FORMAT_R8G8_USCALED; 592 enum VK_FORMAT_R8G8_SSCALED = VkFormat.VK_FORMAT_R8G8_SSCALED; 593 enum VK_FORMAT_R8G8_UINT = VkFormat.VK_FORMAT_R8G8_UINT; 594 enum VK_FORMAT_R8G8_SINT = VkFormat.VK_FORMAT_R8G8_SINT; 595 enum VK_FORMAT_R8G8_SRGB = VkFormat.VK_FORMAT_R8G8_SRGB; 596 enum VK_FORMAT_R8G8B8_UNORM = VkFormat.VK_FORMAT_R8G8B8_UNORM; 597 enum VK_FORMAT_R8G8B8_SNORM = VkFormat.VK_FORMAT_R8G8B8_SNORM; 598 enum VK_FORMAT_R8G8B8_USCALED = VkFormat.VK_FORMAT_R8G8B8_USCALED; 599 enum VK_FORMAT_R8G8B8_SSCALED = VkFormat.VK_FORMAT_R8G8B8_SSCALED; 600 enum VK_FORMAT_R8G8B8_UINT = VkFormat.VK_FORMAT_R8G8B8_UINT; 601 enum VK_FORMAT_R8G8B8_SINT = VkFormat.VK_FORMAT_R8G8B8_SINT; 602 enum VK_FORMAT_R8G8B8_SRGB = VkFormat.VK_FORMAT_R8G8B8_SRGB; 603 enum VK_FORMAT_B8G8R8_UNORM = VkFormat.VK_FORMAT_B8G8R8_UNORM; 604 enum VK_FORMAT_B8G8R8_SNORM = VkFormat.VK_FORMAT_B8G8R8_SNORM; 605 enum VK_FORMAT_B8G8R8_USCALED = VkFormat.VK_FORMAT_B8G8R8_USCALED; 606 enum VK_FORMAT_B8G8R8_SSCALED = VkFormat.VK_FORMAT_B8G8R8_SSCALED; 607 enum VK_FORMAT_B8G8R8_UINT = VkFormat.VK_FORMAT_B8G8R8_UINT; 608 enum VK_FORMAT_B8G8R8_SINT = VkFormat.VK_FORMAT_B8G8R8_SINT; 609 enum VK_FORMAT_B8G8R8_SRGB = VkFormat.VK_FORMAT_B8G8R8_SRGB; 610 enum VK_FORMAT_R8G8B8A8_UNORM = VkFormat.VK_FORMAT_R8G8B8A8_UNORM; 611 enum VK_FORMAT_R8G8B8A8_SNORM = VkFormat.VK_FORMAT_R8G8B8A8_SNORM; 612 enum VK_FORMAT_R8G8B8A8_USCALED = VkFormat.VK_FORMAT_R8G8B8A8_USCALED; 613 enum VK_FORMAT_R8G8B8A8_SSCALED = VkFormat.VK_FORMAT_R8G8B8A8_SSCALED; 614 enum VK_FORMAT_R8G8B8A8_UINT = VkFormat.VK_FORMAT_R8G8B8A8_UINT; 615 enum VK_FORMAT_R8G8B8A8_SINT = VkFormat.VK_FORMAT_R8G8B8A8_SINT; 616 enum VK_FORMAT_R8G8B8A8_SRGB = VkFormat.VK_FORMAT_R8G8B8A8_SRGB; 617 enum VK_FORMAT_B8G8R8A8_UNORM = VkFormat.VK_FORMAT_B8G8R8A8_UNORM; 618 enum VK_FORMAT_B8G8R8A8_SNORM = VkFormat.VK_FORMAT_B8G8R8A8_SNORM; 619 enum VK_FORMAT_B8G8R8A8_USCALED = VkFormat.VK_FORMAT_B8G8R8A8_USCALED; 620 enum VK_FORMAT_B8G8R8A8_SSCALED = VkFormat.VK_FORMAT_B8G8R8A8_SSCALED; 621 enum VK_FORMAT_B8G8R8A8_UINT = VkFormat.VK_FORMAT_B8G8R8A8_UINT; 622 enum VK_FORMAT_B8G8R8A8_SINT = VkFormat.VK_FORMAT_B8G8R8A8_SINT; 623 enum VK_FORMAT_B8G8R8A8_SRGB = VkFormat.VK_FORMAT_B8G8R8A8_SRGB; 624 enum VK_FORMAT_A8B8G8R8_UNORM_PACK32 = VkFormat.VK_FORMAT_A8B8G8R8_UNORM_PACK32; 625 enum VK_FORMAT_A8B8G8R8_SNORM_PACK32 = VkFormat.VK_FORMAT_A8B8G8R8_SNORM_PACK32; 626 enum VK_FORMAT_A8B8G8R8_USCALED_PACK32 = VkFormat.VK_FORMAT_A8B8G8R8_USCALED_PACK32; 627 enum VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = VkFormat.VK_FORMAT_A8B8G8R8_SSCALED_PACK32; 628 enum VK_FORMAT_A8B8G8R8_UINT_PACK32 = VkFormat.VK_FORMAT_A8B8G8R8_UINT_PACK32; 629 enum VK_FORMAT_A8B8G8R8_SINT_PACK32 = VkFormat.VK_FORMAT_A8B8G8R8_SINT_PACK32; 630 enum VK_FORMAT_A8B8G8R8_SRGB_PACK32 = VkFormat.VK_FORMAT_A8B8G8R8_SRGB_PACK32; 631 enum VK_FORMAT_A2R10G10B10_UNORM_PACK32 = VkFormat.VK_FORMAT_A2R10G10B10_UNORM_PACK32; 632 enum VK_FORMAT_A2R10G10B10_SNORM_PACK32 = VkFormat.VK_FORMAT_A2R10G10B10_SNORM_PACK32; 633 enum VK_FORMAT_A2R10G10B10_USCALED_PACK32 = VkFormat.VK_FORMAT_A2R10G10B10_USCALED_PACK32; 634 enum VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = VkFormat.VK_FORMAT_A2R10G10B10_SSCALED_PACK32; 635 enum VK_FORMAT_A2R10G10B10_UINT_PACK32 = VkFormat.VK_FORMAT_A2R10G10B10_UINT_PACK32; 636 enum VK_FORMAT_A2R10G10B10_SINT_PACK32 = VkFormat.VK_FORMAT_A2R10G10B10_SINT_PACK32; 637 enum VK_FORMAT_A2B10G10R10_UNORM_PACK32 = VkFormat.VK_FORMAT_A2B10G10R10_UNORM_PACK32; 638 enum VK_FORMAT_A2B10G10R10_SNORM_PACK32 = VkFormat.VK_FORMAT_A2B10G10R10_SNORM_PACK32; 639 enum VK_FORMAT_A2B10G10R10_USCALED_PACK32 = VkFormat.VK_FORMAT_A2B10G10R10_USCALED_PACK32; 640 enum VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = VkFormat.VK_FORMAT_A2B10G10R10_SSCALED_PACK32; 641 enum VK_FORMAT_A2B10G10R10_UINT_PACK32 = VkFormat.VK_FORMAT_A2B10G10R10_UINT_PACK32; 642 enum VK_FORMAT_A2B10G10R10_SINT_PACK32 = VkFormat.VK_FORMAT_A2B10G10R10_SINT_PACK32; 643 enum VK_FORMAT_R16_UNORM = VkFormat.VK_FORMAT_R16_UNORM; 644 enum VK_FORMAT_R16_SNORM = VkFormat.VK_FORMAT_R16_SNORM; 645 enum VK_FORMAT_R16_USCALED = VkFormat.VK_FORMAT_R16_USCALED; 646 enum VK_FORMAT_R16_SSCALED = VkFormat.VK_FORMAT_R16_SSCALED; 647 enum VK_FORMAT_R16_UINT = VkFormat.VK_FORMAT_R16_UINT; 648 enum VK_FORMAT_R16_SINT = VkFormat.VK_FORMAT_R16_SINT; 649 enum VK_FORMAT_R16_SFLOAT = VkFormat.VK_FORMAT_R16_SFLOAT; 650 enum VK_FORMAT_R16G16_UNORM = VkFormat.VK_FORMAT_R16G16_UNORM; 651 enum VK_FORMAT_R16G16_SNORM = VkFormat.VK_FORMAT_R16G16_SNORM; 652 enum VK_FORMAT_R16G16_USCALED = VkFormat.VK_FORMAT_R16G16_USCALED; 653 enum VK_FORMAT_R16G16_SSCALED = VkFormat.VK_FORMAT_R16G16_SSCALED; 654 enum VK_FORMAT_R16G16_UINT = VkFormat.VK_FORMAT_R16G16_UINT; 655 enum VK_FORMAT_R16G16_SINT = VkFormat.VK_FORMAT_R16G16_SINT; 656 enum VK_FORMAT_R16G16_SFLOAT = VkFormat.VK_FORMAT_R16G16_SFLOAT; 657 enum VK_FORMAT_R16G16B16_UNORM = VkFormat.VK_FORMAT_R16G16B16_UNORM; 658 enum VK_FORMAT_R16G16B16_SNORM = VkFormat.VK_FORMAT_R16G16B16_SNORM; 659 enum VK_FORMAT_R16G16B16_USCALED = VkFormat.VK_FORMAT_R16G16B16_USCALED; 660 enum VK_FORMAT_R16G16B16_SSCALED = VkFormat.VK_FORMAT_R16G16B16_SSCALED; 661 enum VK_FORMAT_R16G16B16_UINT = VkFormat.VK_FORMAT_R16G16B16_UINT; 662 enum VK_FORMAT_R16G16B16_SINT = VkFormat.VK_FORMAT_R16G16B16_SINT; 663 enum VK_FORMAT_R16G16B16_SFLOAT = VkFormat.VK_FORMAT_R16G16B16_SFLOAT; 664 enum VK_FORMAT_R16G16B16A16_UNORM = VkFormat.VK_FORMAT_R16G16B16A16_UNORM; 665 enum VK_FORMAT_R16G16B16A16_SNORM = VkFormat.VK_FORMAT_R16G16B16A16_SNORM; 666 enum VK_FORMAT_R16G16B16A16_USCALED = VkFormat.VK_FORMAT_R16G16B16A16_USCALED; 667 enum VK_FORMAT_R16G16B16A16_SSCALED = VkFormat.VK_FORMAT_R16G16B16A16_SSCALED; 668 enum VK_FORMAT_R16G16B16A16_UINT = VkFormat.VK_FORMAT_R16G16B16A16_UINT; 669 enum VK_FORMAT_R16G16B16A16_SINT = VkFormat.VK_FORMAT_R16G16B16A16_SINT; 670 enum VK_FORMAT_R16G16B16A16_SFLOAT = VkFormat.VK_FORMAT_R16G16B16A16_SFLOAT; 671 enum VK_FORMAT_R32_UINT = VkFormat.VK_FORMAT_R32_UINT; 672 enum VK_FORMAT_R32_SINT = VkFormat.VK_FORMAT_R32_SINT; 673 enum VK_FORMAT_R32_SFLOAT = VkFormat.VK_FORMAT_R32_SFLOAT; 674 enum VK_FORMAT_R32G32_UINT = VkFormat.VK_FORMAT_R32G32_UINT; 675 enum VK_FORMAT_R32G32_SINT = VkFormat.VK_FORMAT_R32G32_SINT; 676 enum VK_FORMAT_R32G32_SFLOAT = VkFormat.VK_FORMAT_R32G32_SFLOAT; 677 enum VK_FORMAT_R32G32B32_UINT = VkFormat.VK_FORMAT_R32G32B32_UINT; 678 enum VK_FORMAT_R32G32B32_SINT = VkFormat.VK_FORMAT_R32G32B32_SINT; 679 enum VK_FORMAT_R32G32B32_SFLOAT = VkFormat.VK_FORMAT_R32G32B32_SFLOAT; 680 enum VK_FORMAT_R32G32B32A32_UINT = VkFormat.VK_FORMAT_R32G32B32A32_UINT; 681 enum VK_FORMAT_R32G32B32A32_SINT = VkFormat.VK_FORMAT_R32G32B32A32_SINT; 682 enum VK_FORMAT_R32G32B32A32_SFLOAT = VkFormat.VK_FORMAT_R32G32B32A32_SFLOAT; 683 enum VK_FORMAT_R64_UINT = VkFormat.VK_FORMAT_R64_UINT; 684 enum VK_FORMAT_R64_SINT = VkFormat.VK_FORMAT_R64_SINT; 685 enum VK_FORMAT_R64_SFLOAT = VkFormat.VK_FORMAT_R64_SFLOAT; 686 enum VK_FORMAT_R64G64_UINT = VkFormat.VK_FORMAT_R64G64_UINT; 687 enum VK_FORMAT_R64G64_SINT = VkFormat.VK_FORMAT_R64G64_SINT; 688 enum VK_FORMAT_R64G64_SFLOAT = VkFormat.VK_FORMAT_R64G64_SFLOAT; 689 enum VK_FORMAT_R64G64B64_UINT = VkFormat.VK_FORMAT_R64G64B64_UINT; 690 enum VK_FORMAT_R64G64B64_SINT = VkFormat.VK_FORMAT_R64G64B64_SINT; 691 enum VK_FORMAT_R64G64B64_SFLOAT = VkFormat.VK_FORMAT_R64G64B64_SFLOAT; 692 enum VK_FORMAT_R64G64B64A64_UINT = VkFormat.VK_FORMAT_R64G64B64A64_UINT; 693 enum VK_FORMAT_R64G64B64A64_SINT = VkFormat.VK_FORMAT_R64G64B64A64_SINT; 694 enum VK_FORMAT_R64G64B64A64_SFLOAT = VkFormat.VK_FORMAT_R64G64B64A64_SFLOAT; 695 enum VK_FORMAT_B10G11R11_UFLOAT_PACK32 = VkFormat.VK_FORMAT_B10G11R11_UFLOAT_PACK32; 696 enum VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = VkFormat.VK_FORMAT_E5B9G9R9_UFLOAT_PACK32; 697 enum VK_FORMAT_D16_UNORM = VkFormat.VK_FORMAT_D16_UNORM; 698 enum VK_FORMAT_X8_D24_UNORM_PACK32 = VkFormat.VK_FORMAT_X8_D24_UNORM_PACK32; 699 enum VK_FORMAT_D32_SFLOAT = VkFormat.VK_FORMAT_D32_SFLOAT; 700 enum VK_FORMAT_S8_UINT = VkFormat.VK_FORMAT_S8_UINT; 701 enum VK_FORMAT_D16_UNORM_S8_UINT = VkFormat.VK_FORMAT_D16_UNORM_S8_UINT; 702 enum VK_FORMAT_D24_UNORM_S8_UINT = VkFormat.VK_FORMAT_D24_UNORM_S8_UINT; 703 enum VK_FORMAT_D32_SFLOAT_S8_UINT = VkFormat.VK_FORMAT_D32_SFLOAT_S8_UINT; 704 enum VK_FORMAT_BC1_RGB_UNORM_BLOCK = VkFormat.VK_FORMAT_BC1_RGB_UNORM_BLOCK; 705 enum VK_FORMAT_BC1_RGB_SRGB_BLOCK = VkFormat.VK_FORMAT_BC1_RGB_SRGB_BLOCK; 706 enum VK_FORMAT_BC1_RGBA_UNORM_BLOCK = VkFormat.VK_FORMAT_BC1_RGBA_UNORM_BLOCK; 707 enum VK_FORMAT_BC1_RGBA_SRGB_BLOCK = VkFormat.VK_FORMAT_BC1_RGBA_SRGB_BLOCK; 708 enum VK_FORMAT_BC2_UNORM_BLOCK = VkFormat.VK_FORMAT_BC2_UNORM_BLOCK; 709 enum VK_FORMAT_BC2_SRGB_BLOCK = VkFormat.VK_FORMAT_BC2_SRGB_BLOCK; 710 enum VK_FORMAT_BC3_UNORM_BLOCK = VkFormat.VK_FORMAT_BC3_UNORM_BLOCK; 711 enum VK_FORMAT_BC3_SRGB_BLOCK = VkFormat.VK_FORMAT_BC3_SRGB_BLOCK; 712 enum VK_FORMAT_BC4_UNORM_BLOCK = VkFormat.VK_FORMAT_BC4_UNORM_BLOCK; 713 enum VK_FORMAT_BC4_SNORM_BLOCK = VkFormat.VK_FORMAT_BC4_SNORM_BLOCK; 714 enum VK_FORMAT_BC5_UNORM_BLOCK = VkFormat.VK_FORMAT_BC5_UNORM_BLOCK; 715 enum VK_FORMAT_BC5_SNORM_BLOCK = VkFormat.VK_FORMAT_BC5_SNORM_BLOCK; 716 enum VK_FORMAT_BC6H_UFLOAT_BLOCK = VkFormat.VK_FORMAT_BC6H_UFLOAT_BLOCK; 717 enum VK_FORMAT_BC6H_SFLOAT_BLOCK = VkFormat.VK_FORMAT_BC6H_SFLOAT_BLOCK; 718 enum VK_FORMAT_BC7_UNORM_BLOCK = VkFormat.VK_FORMAT_BC7_UNORM_BLOCK; 719 enum VK_FORMAT_BC7_SRGB_BLOCK = VkFormat.VK_FORMAT_BC7_SRGB_BLOCK; 720 enum VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = VkFormat.VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK; 721 enum VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = VkFormat.VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK; 722 enum VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = VkFormat.VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK; 723 enum VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = VkFormat.VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK; 724 enum VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = VkFormat.VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK; 725 enum VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = VkFormat.VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK; 726 enum VK_FORMAT_EAC_R11_UNORM_BLOCK = VkFormat.VK_FORMAT_EAC_R11_UNORM_BLOCK; 727 enum VK_FORMAT_EAC_R11_SNORM_BLOCK = VkFormat.VK_FORMAT_EAC_R11_SNORM_BLOCK; 728 enum VK_FORMAT_EAC_R11G11_UNORM_BLOCK = VkFormat.VK_FORMAT_EAC_R11G11_UNORM_BLOCK; 729 enum VK_FORMAT_EAC_R11G11_SNORM_BLOCK = VkFormat.VK_FORMAT_EAC_R11G11_SNORM_BLOCK; 730 enum VK_FORMAT_ASTC_4x4_UNORM_BLOCK = VkFormat.VK_FORMAT_ASTC_4x4_UNORM_BLOCK; 731 enum VK_FORMAT_ASTC_4x4_SRGB_BLOCK = VkFormat.VK_FORMAT_ASTC_4x4_SRGB_BLOCK; 732 enum VK_FORMAT_ASTC_5x4_UNORM_BLOCK = VkFormat.VK_FORMAT_ASTC_5x4_UNORM_BLOCK; 733 enum VK_FORMAT_ASTC_5x4_SRGB_BLOCK = VkFormat.VK_FORMAT_ASTC_5x4_SRGB_BLOCK; 734 enum VK_FORMAT_ASTC_5x5_UNORM_BLOCK = VkFormat.VK_FORMAT_ASTC_5x5_UNORM_BLOCK; 735 enum VK_FORMAT_ASTC_5x5_SRGB_BLOCK = VkFormat.VK_FORMAT_ASTC_5x5_SRGB_BLOCK; 736 enum VK_FORMAT_ASTC_6x5_UNORM_BLOCK = VkFormat.VK_FORMAT_ASTC_6x5_UNORM_BLOCK; 737 enum VK_FORMAT_ASTC_6x5_SRGB_BLOCK = VkFormat.VK_FORMAT_ASTC_6x5_SRGB_BLOCK; 738 enum VK_FORMAT_ASTC_6x6_UNORM_BLOCK = VkFormat.VK_FORMAT_ASTC_6x6_UNORM_BLOCK; 739 enum VK_FORMAT_ASTC_6x6_SRGB_BLOCK = VkFormat.VK_FORMAT_ASTC_6x6_SRGB_BLOCK; 740 enum VK_FORMAT_ASTC_8x5_UNORM_BLOCK = VkFormat.VK_FORMAT_ASTC_8x5_UNORM_BLOCK; 741 enum VK_FORMAT_ASTC_8x5_SRGB_BLOCK = VkFormat.VK_FORMAT_ASTC_8x5_SRGB_BLOCK; 742 enum VK_FORMAT_ASTC_8x6_UNORM_BLOCK = VkFormat.VK_FORMAT_ASTC_8x6_UNORM_BLOCK; 743 enum VK_FORMAT_ASTC_8x6_SRGB_BLOCK = VkFormat.VK_FORMAT_ASTC_8x6_SRGB_BLOCK; 744 enum VK_FORMAT_ASTC_8x8_UNORM_BLOCK = VkFormat.VK_FORMAT_ASTC_8x8_UNORM_BLOCK; 745 enum VK_FORMAT_ASTC_8x8_SRGB_BLOCK = VkFormat.VK_FORMAT_ASTC_8x8_SRGB_BLOCK; 746 enum VK_FORMAT_ASTC_10x5_UNORM_BLOCK = VkFormat.VK_FORMAT_ASTC_10x5_UNORM_BLOCK; 747 enum VK_FORMAT_ASTC_10x5_SRGB_BLOCK = VkFormat.VK_FORMAT_ASTC_10x5_SRGB_BLOCK; 748 enum VK_FORMAT_ASTC_10x6_UNORM_BLOCK = VkFormat.VK_FORMAT_ASTC_10x6_UNORM_BLOCK; 749 enum VK_FORMAT_ASTC_10x6_SRGB_BLOCK = VkFormat.VK_FORMAT_ASTC_10x6_SRGB_BLOCK; 750 enum VK_FORMAT_ASTC_10x8_UNORM_BLOCK = VkFormat.VK_FORMAT_ASTC_10x8_UNORM_BLOCK; 751 enum VK_FORMAT_ASTC_10x8_SRGB_BLOCK = VkFormat.VK_FORMAT_ASTC_10x8_SRGB_BLOCK; 752 enum VK_FORMAT_ASTC_10x10_UNORM_BLOCK = VkFormat.VK_FORMAT_ASTC_10x10_UNORM_BLOCK; 753 enum VK_FORMAT_ASTC_10x10_SRGB_BLOCK = VkFormat.VK_FORMAT_ASTC_10x10_SRGB_BLOCK; 754 enum VK_FORMAT_ASTC_12x10_UNORM_BLOCK = VkFormat.VK_FORMAT_ASTC_12x10_UNORM_BLOCK; 755 enum VK_FORMAT_ASTC_12x10_SRGB_BLOCK = VkFormat.VK_FORMAT_ASTC_12x10_SRGB_BLOCK; 756 enum VK_FORMAT_ASTC_12x12_UNORM_BLOCK = VkFormat.VK_FORMAT_ASTC_12x12_UNORM_BLOCK; 757 enum VK_FORMAT_ASTC_12x12_SRGB_BLOCK = VkFormat.VK_FORMAT_ASTC_12x12_SRGB_BLOCK; 758 enum VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG = VkFormat.VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG; 759 enum VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG = VkFormat.VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG; 760 enum VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG = VkFormat.VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG; 761 enum VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG = VkFormat.VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG; 762 enum VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG = VkFormat.VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG; 763 enum VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = VkFormat.VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG; 764 enum VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = VkFormat.VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG; 765 enum VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = VkFormat.VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG; 766 enum VK_FORMAT_BEGIN_RANGE = VkFormat.VK_FORMAT_BEGIN_RANGE; 767 enum VK_FORMAT_END_RANGE = VkFormat.VK_FORMAT_END_RANGE; 768 enum VK_FORMAT_RANGE_SIZE = VkFormat.VK_FORMAT_RANGE_SIZE; 769 enum VK_FORMAT_MAX_ENUM = VkFormat.VK_FORMAT_MAX_ENUM; 770 771 enum VkImageType { 772 VK_IMAGE_TYPE_1D = 0, 773 VK_IMAGE_TYPE_2D = 1, 774 VK_IMAGE_TYPE_3D = 2, 775 VK_IMAGE_TYPE_BEGIN_RANGE = VK_IMAGE_TYPE_1D, 776 VK_IMAGE_TYPE_END_RANGE = VK_IMAGE_TYPE_3D, 777 VK_IMAGE_TYPE_RANGE_SIZE = ( VK_IMAGE_TYPE_3D - VK_IMAGE_TYPE_1D + 1 ), 778 VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF 779 } 780 781 // VkImageType global enums 782 enum VK_IMAGE_TYPE_1D = VkImageType.VK_IMAGE_TYPE_1D; 783 enum VK_IMAGE_TYPE_2D = VkImageType.VK_IMAGE_TYPE_2D; 784 enum VK_IMAGE_TYPE_3D = VkImageType.VK_IMAGE_TYPE_3D; 785 enum VK_IMAGE_TYPE_BEGIN_RANGE = VkImageType.VK_IMAGE_TYPE_BEGIN_RANGE; 786 enum VK_IMAGE_TYPE_END_RANGE = VkImageType.VK_IMAGE_TYPE_END_RANGE; 787 enum VK_IMAGE_TYPE_RANGE_SIZE = VkImageType.VK_IMAGE_TYPE_RANGE_SIZE; 788 enum VK_IMAGE_TYPE_MAX_ENUM = VkImageType.VK_IMAGE_TYPE_MAX_ENUM; 789 790 enum VkImageTiling { 791 VK_IMAGE_TILING_OPTIMAL = 0, 792 VK_IMAGE_TILING_LINEAR = 1, 793 VK_IMAGE_TILING_BEGIN_RANGE = VK_IMAGE_TILING_OPTIMAL, 794 VK_IMAGE_TILING_END_RANGE = VK_IMAGE_TILING_LINEAR, 795 VK_IMAGE_TILING_RANGE_SIZE = ( VK_IMAGE_TILING_LINEAR - VK_IMAGE_TILING_OPTIMAL + 1 ), 796 VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF 797 } 798 799 // VkImageTiling global enums 800 enum VK_IMAGE_TILING_OPTIMAL = VkImageTiling.VK_IMAGE_TILING_OPTIMAL; 801 enum VK_IMAGE_TILING_LINEAR = VkImageTiling.VK_IMAGE_TILING_LINEAR; 802 enum VK_IMAGE_TILING_BEGIN_RANGE = VkImageTiling.VK_IMAGE_TILING_BEGIN_RANGE; 803 enum VK_IMAGE_TILING_END_RANGE = VkImageTiling.VK_IMAGE_TILING_END_RANGE; 804 enum VK_IMAGE_TILING_RANGE_SIZE = VkImageTiling.VK_IMAGE_TILING_RANGE_SIZE; 805 enum VK_IMAGE_TILING_MAX_ENUM = VkImageTiling.VK_IMAGE_TILING_MAX_ENUM; 806 807 enum VkPhysicalDeviceType { 808 VK_PHYSICAL_DEVICE_TYPE_OTHER = 0, 809 VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1, 810 VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2, 811 VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3, 812 VK_PHYSICAL_DEVICE_TYPE_CPU = 4, 813 VK_PHYSICAL_DEVICE_TYPE_BEGIN_RANGE = VK_PHYSICAL_DEVICE_TYPE_OTHER, 814 VK_PHYSICAL_DEVICE_TYPE_END_RANGE = VK_PHYSICAL_DEVICE_TYPE_CPU, 815 VK_PHYSICAL_DEVICE_TYPE_RANGE_SIZE = ( VK_PHYSICAL_DEVICE_TYPE_CPU - VK_PHYSICAL_DEVICE_TYPE_OTHER + 1 ), 816 VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF 817 } 818 819 // VkPhysicalDeviceType global enums 820 enum VK_PHYSICAL_DEVICE_TYPE_OTHER = VkPhysicalDeviceType.VK_PHYSICAL_DEVICE_TYPE_OTHER; 821 enum VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = VkPhysicalDeviceType.VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU; 822 enum VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = VkPhysicalDeviceType.VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU; 823 enum VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = VkPhysicalDeviceType.VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU; 824 enum VK_PHYSICAL_DEVICE_TYPE_CPU = VkPhysicalDeviceType.VK_PHYSICAL_DEVICE_TYPE_CPU; 825 enum VK_PHYSICAL_DEVICE_TYPE_BEGIN_RANGE = VkPhysicalDeviceType.VK_PHYSICAL_DEVICE_TYPE_BEGIN_RANGE; 826 enum VK_PHYSICAL_DEVICE_TYPE_END_RANGE = VkPhysicalDeviceType.VK_PHYSICAL_DEVICE_TYPE_END_RANGE; 827 enum VK_PHYSICAL_DEVICE_TYPE_RANGE_SIZE = VkPhysicalDeviceType.VK_PHYSICAL_DEVICE_TYPE_RANGE_SIZE; 828 enum VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = VkPhysicalDeviceType.VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM; 829 830 enum VkQueryType { 831 VK_QUERY_TYPE_OCCLUSION = 0, 832 VK_QUERY_TYPE_PIPELINE_STATISTICS = 1, 833 VK_QUERY_TYPE_TIMESTAMP = 2, 834 VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_TYPE_OCCLUSION, 835 VK_QUERY_TYPE_END_RANGE = VK_QUERY_TYPE_TIMESTAMP, 836 VK_QUERY_TYPE_RANGE_SIZE = ( VK_QUERY_TYPE_TIMESTAMP - VK_QUERY_TYPE_OCCLUSION + 1 ), 837 VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF 838 } 839 840 // VkQueryType global enums 841 enum VK_QUERY_TYPE_OCCLUSION = VkQueryType.VK_QUERY_TYPE_OCCLUSION; 842 enum VK_QUERY_TYPE_PIPELINE_STATISTICS = VkQueryType.VK_QUERY_TYPE_PIPELINE_STATISTICS; 843 enum VK_QUERY_TYPE_TIMESTAMP = VkQueryType.VK_QUERY_TYPE_TIMESTAMP; 844 enum VK_QUERY_TYPE_BEGIN_RANGE = VkQueryType.VK_QUERY_TYPE_BEGIN_RANGE; 845 enum VK_QUERY_TYPE_END_RANGE = VkQueryType.VK_QUERY_TYPE_END_RANGE; 846 enum VK_QUERY_TYPE_RANGE_SIZE = VkQueryType.VK_QUERY_TYPE_RANGE_SIZE; 847 enum VK_QUERY_TYPE_MAX_ENUM = VkQueryType.VK_QUERY_TYPE_MAX_ENUM; 848 849 enum VkSharingMode { 850 VK_SHARING_MODE_EXCLUSIVE = 0, 851 VK_SHARING_MODE_CONCURRENT = 1, 852 VK_SHARING_MODE_BEGIN_RANGE = VK_SHARING_MODE_EXCLUSIVE, 853 VK_SHARING_MODE_END_RANGE = VK_SHARING_MODE_CONCURRENT, 854 VK_SHARING_MODE_RANGE_SIZE = ( VK_SHARING_MODE_CONCURRENT - VK_SHARING_MODE_EXCLUSIVE + 1 ), 855 VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF 856 } 857 858 // VkSharingMode global enums 859 enum VK_SHARING_MODE_EXCLUSIVE = VkSharingMode.VK_SHARING_MODE_EXCLUSIVE; 860 enum VK_SHARING_MODE_CONCURRENT = VkSharingMode.VK_SHARING_MODE_CONCURRENT; 861 enum VK_SHARING_MODE_BEGIN_RANGE = VkSharingMode.VK_SHARING_MODE_BEGIN_RANGE; 862 enum VK_SHARING_MODE_END_RANGE = VkSharingMode.VK_SHARING_MODE_END_RANGE; 863 enum VK_SHARING_MODE_RANGE_SIZE = VkSharingMode.VK_SHARING_MODE_RANGE_SIZE; 864 enum VK_SHARING_MODE_MAX_ENUM = VkSharingMode.VK_SHARING_MODE_MAX_ENUM; 865 866 enum VkImageLayout { 867 VK_IMAGE_LAYOUT_UNDEFINED = 0, 868 VK_IMAGE_LAYOUT_GENERAL = 1, 869 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2, 870 VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3, 871 VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4, 872 VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5, 873 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6, 874 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7, 875 VK_IMAGE_LAYOUT_PREINITIALIZED = 8, 876 VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002, 877 VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED, 878 VK_IMAGE_LAYOUT_END_RANGE = VK_IMAGE_LAYOUT_PREINITIALIZED, 879 VK_IMAGE_LAYOUT_RANGE_SIZE = ( VK_IMAGE_LAYOUT_PREINITIALIZED - VK_IMAGE_LAYOUT_UNDEFINED + 1 ), 880 VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF 881 } 882 883 // VkImageLayout global enums 884 enum VK_IMAGE_LAYOUT_UNDEFINED = VkImageLayout.VK_IMAGE_LAYOUT_UNDEFINED; 885 enum VK_IMAGE_LAYOUT_GENERAL = VkImageLayout.VK_IMAGE_LAYOUT_GENERAL; 886 enum VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = VkImageLayout.VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; 887 enum VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = VkImageLayout.VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; 888 enum VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = VkImageLayout.VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL; 889 enum VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = VkImageLayout.VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL; 890 enum VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = VkImageLayout.VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL; 891 enum VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = VkImageLayout.VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; 892 enum VK_IMAGE_LAYOUT_PREINITIALIZED = VkImageLayout.VK_IMAGE_LAYOUT_PREINITIALIZED; 893 enum VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = VkImageLayout.VK_IMAGE_LAYOUT_PRESENT_SRC_KHR; 894 enum VK_IMAGE_LAYOUT_BEGIN_RANGE = VkImageLayout.VK_IMAGE_LAYOUT_BEGIN_RANGE; 895 enum VK_IMAGE_LAYOUT_END_RANGE = VkImageLayout.VK_IMAGE_LAYOUT_END_RANGE; 896 enum VK_IMAGE_LAYOUT_RANGE_SIZE = VkImageLayout.VK_IMAGE_LAYOUT_RANGE_SIZE; 897 enum VK_IMAGE_LAYOUT_MAX_ENUM = VkImageLayout.VK_IMAGE_LAYOUT_MAX_ENUM; 898 899 enum VkImageViewType { 900 VK_IMAGE_VIEW_TYPE_1D = 0, 901 VK_IMAGE_VIEW_TYPE_2D = 1, 902 VK_IMAGE_VIEW_TYPE_3D = 2, 903 VK_IMAGE_VIEW_TYPE_CUBE = 3, 904 VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4, 905 VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5, 906 VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6, 907 VK_IMAGE_VIEW_TYPE_BEGIN_RANGE = VK_IMAGE_VIEW_TYPE_1D, 908 VK_IMAGE_VIEW_TYPE_END_RANGE = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY, 909 VK_IMAGE_VIEW_TYPE_RANGE_SIZE = ( VK_IMAGE_VIEW_TYPE_CUBE_ARRAY - VK_IMAGE_VIEW_TYPE_1D + 1 ), 910 VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF 911 } 912 913 // VkImageViewType global enums 914 enum VK_IMAGE_VIEW_TYPE_1D = VkImageViewType.VK_IMAGE_VIEW_TYPE_1D; 915 enum VK_IMAGE_VIEW_TYPE_2D = VkImageViewType.VK_IMAGE_VIEW_TYPE_2D; 916 enum VK_IMAGE_VIEW_TYPE_3D = VkImageViewType.VK_IMAGE_VIEW_TYPE_3D; 917 enum VK_IMAGE_VIEW_TYPE_CUBE = VkImageViewType.VK_IMAGE_VIEW_TYPE_CUBE; 918 enum VK_IMAGE_VIEW_TYPE_1D_ARRAY = VkImageViewType.VK_IMAGE_VIEW_TYPE_1D_ARRAY; 919 enum VK_IMAGE_VIEW_TYPE_2D_ARRAY = VkImageViewType.VK_IMAGE_VIEW_TYPE_2D_ARRAY; 920 enum VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = VkImageViewType.VK_IMAGE_VIEW_TYPE_CUBE_ARRAY; 921 enum VK_IMAGE_VIEW_TYPE_BEGIN_RANGE = VkImageViewType.VK_IMAGE_VIEW_TYPE_BEGIN_RANGE; 922 enum VK_IMAGE_VIEW_TYPE_END_RANGE = VkImageViewType.VK_IMAGE_VIEW_TYPE_END_RANGE; 923 enum VK_IMAGE_VIEW_TYPE_RANGE_SIZE = VkImageViewType.VK_IMAGE_VIEW_TYPE_RANGE_SIZE; 924 enum VK_IMAGE_VIEW_TYPE_MAX_ENUM = VkImageViewType.VK_IMAGE_VIEW_TYPE_MAX_ENUM; 925 926 enum VkComponentSwizzle { 927 VK_COMPONENT_SWIZZLE_IDENTITY = 0, 928 VK_COMPONENT_SWIZZLE_ZERO = 1, 929 VK_COMPONENT_SWIZZLE_ONE = 2, 930 VK_COMPONENT_SWIZZLE_R = 3, 931 VK_COMPONENT_SWIZZLE_G = 4, 932 VK_COMPONENT_SWIZZLE_B = 5, 933 VK_COMPONENT_SWIZZLE_A = 6, 934 VK_COMPONENT_SWIZZLE_BEGIN_RANGE = VK_COMPONENT_SWIZZLE_IDENTITY, 935 VK_COMPONENT_SWIZZLE_END_RANGE = VK_COMPONENT_SWIZZLE_A, 936 VK_COMPONENT_SWIZZLE_RANGE_SIZE = ( VK_COMPONENT_SWIZZLE_A - VK_COMPONENT_SWIZZLE_IDENTITY + 1 ), 937 VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF 938 } 939 940 // VkComponentSwizzle global enums 941 enum VK_COMPONENT_SWIZZLE_IDENTITY = VkComponentSwizzle.VK_COMPONENT_SWIZZLE_IDENTITY; 942 enum VK_COMPONENT_SWIZZLE_ZERO = VkComponentSwizzle.VK_COMPONENT_SWIZZLE_ZERO; 943 enum VK_COMPONENT_SWIZZLE_ONE = VkComponentSwizzle.VK_COMPONENT_SWIZZLE_ONE; 944 enum VK_COMPONENT_SWIZZLE_R = VkComponentSwizzle.VK_COMPONENT_SWIZZLE_R; 945 enum VK_COMPONENT_SWIZZLE_G = VkComponentSwizzle.VK_COMPONENT_SWIZZLE_G; 946 enum VK_COMPONENT_SWIZZLE_B = VkComponentSwizzle.VK_COMPONENT_SWIZZLE_B; 947 enum VK_COMPONENT_SWIZZLE_A = VkComponentSwizzle.VK_COMPONENT_SWIZZLE_A; 948 enum VK_COMPONENT_SWIZZLE_BEGIN_RANGE = VkComponentSwizzle.VK_COMPONENT_SWIZZLE_BEGIN_RANGE; 949 enum VK_COMPONENT_SWIZZLE_END_RANGE = VkComponentSwizzle.VK_COMPONENT_SWIZZLE_END_RANGE; 950 enum VK_COMPONENT_SWIZZLE_RANGE_SIZE = VkComponentSwizzle.VK_COMPONENT_SWIZZLE_RANGE_SIZE; 951 enum VK_COMPONENT_SWIZZLE_MAX_ENUM = VkComponentSwizzle.VK_COMPONENT_SWIZZLE_MAX_ENUM; 952 953 enum VkVertexInputRate { 954 VK_VERTEX_INPUT_RATE_VERTEX = 0, 955 VK_VERTEX_INPUT_RATE_INSTANCE = 1, 956 VK_VERTEX_INPUT_RATE_BEGIN_RANGE = VK_VERTEX_INPUT_RATE_VERTEX, 957 VK_VERTEX_INPUT_RATE_END_RANGE = VK_VERTEX_INPUT_RATE_INSTANCE, 958 VK_VERTEX_INPUT_RATE_RANGE_SIZE = ( VK_VERTEX_INPUT_RATE_INSTANCE - VK_VERTEX_INPUT_RATE_VERTEX + 1 ), 959 VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF 960 } 961 962 // VkVertexInputRate global enums 963 enum VK_VERTEX_INPUT_RATE_VERTEX = VkVertexInputRate.VK_VERTEX_INPUT_RATE_VERTEX; 964 enum VK_VERTEX_INPUT_RATE_INSTANCE = VkVertexInputRate.VK_VERTEX_INPUT_RATE_INSTANCE; 965 enum VK_VERTEX_INPUT_RATE_BEGIN_RANGE = VkVertexInputRate.VK_VERTEX_INPUT_RATE_BEGIN_RANGE; 966 enum VK_VERTEX_INPUT_RATE_END_RANGE = VkVertexInputRate.VK_VERTEX_INPUT_RATE_END_RANGE; 967 enum VK_VERTEX_INPUT_RATE_RANGE_SIZE = VkVertexInputRate.VK_VERTEX_INPUT_RATE_RANGE_SIZE; 968 enum VK_VERTEX_INPUT_RATE_MAX_ENUM = VkVertexInputRate.VK_VERTEX_INPUT_RATE_MAX_ENUM; 969 970 enum VkPrimitiveTopology { 971 VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0, 972 VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1, 973 VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2, 974 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3, 975 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4, 976 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5, 977 VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6, 978 VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7, 979 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8, 980 VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9, 981 VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10, 982 VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE = VK_PRIMITIVE_TOPOLOGY_POINT_LIST, 983 VK_PRIMITIVE_TOPOLOGY_END_RANGE = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST, 984 VK_PRIMITIVE_TOPOLOGY_RANGE_SIZE = ( VK_PRIMITIVE_TOPOLOGY_PATCH_LIST - VK_PRIMITIVE_TOPOLOGY_POINT_LIST + 1 ), 985 VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF 986 } 987 988 // VkPrimitiveTopology global enums 989 enum VK_PRIMITIVE_TOPOLOGY_POINT_LIST = VkPrimitiveTopology.VK_PRIMITIVE_TOPOLOGY_POINT_LIST; 990 enum VK_PRIMITIVE_TOPOLOGY_LINE_LIST = VkPrimitiveTopology.VK_PRIMITIVE_TOPOLOGY_LINE_LIST; 991 enum VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = VkPrimitiveTopology.VK_PRIMITIVE_TOPOLOGY_LINE_STRIP; 992 enum VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = VkPrimitiveTopology.VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; 993 enum VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = VkPrimitiveTopology.VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP; 994 enum VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = VkPrimitiveTopology.VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN; 995 enum VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = VkPrimitiveTopology.VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY; 996 enum VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = VkPrimitiveTopology.VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY; 997 enum VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = VkPrimitiveTopology.VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY; 998 enum VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = VkPrimitiveTopology.VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY; 999 enum VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = VkPrimitiveTopology.VK_PRIMITIVE_TOPOLOGY_PATCH_LIST; 1000 enum VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE = VkPrimitiveTopology.VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE; 1001 enum VK_PRIMITIVE_TOPOLOGY_END_RANGE = VkPrimitiveTopology.VK_PRIMITIVE_TOPOLOGY_END_RANGE; 1002 enum VK_PRIMITIVE_TOPOLOGY_RANGE_SIZE = VkPrimitiveTopology.VK_PRIMITIVE_TOPOLOGY_RANGE_SIZE; 1003 enum VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = VkPrimitiveTopology.VK_PRIMITIVE_TOPOLOGY_MAX_ENUM; 1004 1005 enum VkPolygonMode { 1006 VK_POLYGON_MODE_FILL = 0, 1007 VK_POLYGON_MODE_LINE = 1, 1008 VK_POLYGON_MODE_POINT = 2, 1009 VK_POLYGON_MODE_BEGIN_RANGE = VK_POLYGON_MODE_FILL, 1010 VK_POLYGON_MODE_END_RANGE = VK_POLYGON_MODE_POINT, 1011 VK_POLYGON_MODE_RANGE_SIZE = ( VK_POLYGON_MODE_POINT - VK_POLYGON_MODE_FILL + 1 ), 1012 VK_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF 1013 } 1014 1015 // VkPolygonMode global enums 1016 enum VK_POLYGON_MODE_FILL = VkPolygonMode.VK_POLYGON_MODE_FILL; 1017 enum VK_POLYGON_MODE_LINE = VkPolygonMode.VK_POLYGON_MODE_LINE; 1018 enum VK_POLYGON_MODE_POINT = VkPolygonMode.VK_POLYGON_MODE_POINT; 1019 enum VK_POLYGON_MODE_BEGIN_RANGE = VkPolygonMode.VK_POLYGON_MODE_BEGIN_RANGE; 1020 enum VK_POLYGON_MODE_END_RANGE = VkPolygonMode.VK_POLYGON_MODE_END_RANGE; 1021 enum VK_POLYGON_MODE_RANGE_SIZE = VkPolygonMode.VK_POLYGON_MODE_RANGE_SIZE; 1022 enum VK_POLYGON_MODE_MAX_ENUM = VkPolygonMode.VK_POLYGON_MODE_MAX_ENUM; 1023 1024 enum VkFrontFace { 1025 VK_FRONT_FACE_COUNTER_CLOCKWISE = 0, 1026 VK_FRONT_FACE_CLOCKWISE = 1, 1027 VK_FRONT_FACE_BEGIN_RANGE = VK_FRONT_FACE_COUNTER_CLOCKWISE, 1028 VK_FRONT_FACE_END_RANGE = VK_FRONT_FACE_CLOCKWISE, 1029 VK_FRONT_FACE_RANGE_SIZE = ( VK_FRONT_FACE_CLOCKWISE - VK_FRONT_FACE_COUNTER_CLOCKWISE + 1 ), 1030 VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF 1031 } 1032 1033 // VkFrontFace global enums 1034 enum VK_FRONT_FACE_COUNTER_CLOCKWISE = VkFrontFace.VK_FRONT_FACE_COUNTER_CLOCKWISE; 1035 enum VK_FRONT_FACE_CLOCKWISE = VkFrontFace.VK_FRONT_FACE_CLOCKWISE; 1036 enum VK_FRONT_FACE_BEGIN_RANGE = VkFrontFace.VK_FRONT_FACE_BEGIN_RANGE; 1037 enum VK_FRONT_FACE_END_RANGE = VkFrontFace.VK_FRONT_FACE_END_RANGE; 1038 enum VK_FRONT_FACE_RANGE_SIZE = VkFrontFace.VK_FRONT_FACE_RANGE_SIZE; 1039 enum VK_FRONT_FACE_MAX_ENUM = VkFrontFace.VK_FRONT_FACE_MAX_ENUM; 1040 1041 enum VkCompareOp { 1042 VK_COMPARE_OP_NEVER = 0, 1043 VK_COMPARE_OP_LESS = 1, 1044 VK_COMPARE_OP_EQUAL = 2, 1045 VK_COMPARE_OP_LESS_OR_EQUAL = 3, 1046 VK_COMPARE_OP_GREATER = 4, 1047 VK_COMPARE_OP_NOT_EQUAL = 5, 1048 VK_COMPARE_OP_GREATER_OR_EQUAL = 6, 1049 VK_COMPARE_OP_ALWAYS = 7, 1050 VK_COMPARE_OP_BEGIN_RANGE = VK_COMPARE_OP_NEVER, 1051 VK_COMPARE_OP_END_RANGE = VK_COMPARE_OP_ALWAYS, 1052 VK_COMPARE_OP_RANGE_SIZE = ( VK_COMPARE_OP_ALWAYS - VK_COMPARE_OP_NEVER + 1 ), 1053 VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF 1054 } 1055 1056 // VkCompareOp global enums 1057 enum VK_COMPARE_OP_NEVER = VkCompareOp.VK_COMPARE_OP_NEVER; 1058 enum VK_COMPARE_OP_LESS = VkCompareOp.VK_COMPARE_OP_LESS; 1059 enum VK_COMPARE_OP_EQUAL = VkCompareOp.VK_COMPARE_OP_EQUAL; 1060 enum VK_COMPARE_OP_LESS_OR_EQUAL = VkCompareOp.VK_COMPARE_OP_LESS_OR_EQUAL; 1061 enum VK_COMPARE_OP_GREATER = VkCompareOp.VK_COMPARE_OP_GREATER; 1062 enum VK_COMPARE_OP_NOT_EQUAL = VkCompareOp.VK_COMPARE_OP_NOT_EQUAL; 1063 enum VK_COMPARE_OP_GREATER_OR_EQUAL = VkCompareOp.VK_COMPARE_OP_GREATER_OR_EQUAL; 1064 enum VK_COMPARE_OP_ALWAYS = VkCompareOp.VK_COMPARE_OP_ALWAYS; 1065 enum VK_COMPARE_OP_BEGIN_RANGE = VkCompareOp.VK_COMPARE_OP_BEGIN_RANGE; 1066 enum VK_COMPARE_OP_END_RANGE = VkCompareOp.VK_COMPARE_OP_END_RANGE; 1067 enum VK_COMPARE_OP_RANGE_SIZE = VkCompareOp.VK_COMPARE_OP_RANGE_SIZE; 1068 enum VK_COMPARE_OP_MAX_ENUM = VkCompareOp.VK_COMPARE_OP_MAX_ENUM; 1069 1070 enum VkStencilOp { 1071 VK_STENCIL_OP_KEEP = 0, 1072 VK_STENCIL_OP_ZERO = 1, 1073 VK_STENCIL_OP_REPLACE = 2, 1074 VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3, 1075 VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4, 1076 VK_STENCIL_OP_INVERT = 5, 1077 VK_STENCIL_OP_INCREMENT_AND_WRAP = 6, 1078 VK_STENCIL_OP_DECREMENT_AND_WRAP = 7, 1079 VK_STENCIL_OP_BEGIN_RANGE = VK_STENCIL_OP_KEEP, 1080 VK_STENCIL_OP_END_RANGE = VK_STENCIL_OP_DECREMENT_AND_WRAP, 1081 VK_STENCIL_OP_RANGE_SIZE = ( VK_STENCIL_OP_DECREMENT_AND_WRAP - VK_STENCIL_OP_KEEP + 1 ), 1082 VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF 1083 } 1084 1085 // VkStencilOp global enums 1086 enum VK_STENCIL_OP_KEEP = VkStencilOp.VK_STENCIL_OP_KEEP; 1087 enum VK_STENCIL_OP_ZERO = VkStencilOp.VK_STENCIL_OP_ZERO; 1088 enum VK_STENCIL_OP_REPLACE = VkStencilOp.VK_STENCIL_OP_REPLACE; 1089 enum VK_STENCIL_OP_INCREMENT_AND_CLAMP = VkStencilOp.VK_STENCIL_OP_INCREMENT_AND_CLAMP; 1090 enum VK_STENCIL_OP_DECREMENT_AND_CLAMP = VkStencilOp.VK_STENCIL_OP_DECREMENT_AND_CLAMP; 1091 enum VK_STENCIL_OP_INVERT = VkStencilOp.VK_STENCIL_OP_INVERT; 1092 enum VK_STENCIL_OP_INCREMENT_AND_WRAP = VkStencilOp.VK_STENCIL_OP_INCREMENT_AND_WRAP; 1093 enum VK_STENCIL_OP_DECREMENT_AND_WRAP = VkStencilOp.VK_STENCIL_OP_DECREMENT_AND_WRAP; 1094 enum VK_STENCIL_OP_BEGIN_RANGE = VkStencilOp.VK_STENCIL_OP_BEGIN_RANGE; 1095 enum VK_STENCIL_OP_END_RANGE = VkStencilOp.VK_STENCIL_OP_END_RANGE; 1096 enum VK_STENCIL_OP_RANGE_SIZE = VkStencilOp.VK_STENCIL_OP_RANGE_SIZE; 1097 enum VK_STENCIL_OP_MAX_ENUM = VkStencilOp.VK_STENCIL_OP_MAX_ENUM; 1098 1099 enum VkLogicOp { 1100 VK_LOGIC_OP_CLEAR = 0, 1101 VK_LOGIC_OP_AND = 1, 1102 VK_LOGIC_OP_AND_REVERSE = 2, 1103 VK_LOGIC_OP_COPY = 3, 1104 VK_LOGIC_OP_AND_INVERTED = 4, 1105 VK_LOGIC_OP_NO_OP = 5, 1106 VK_LOGIC_OP_XOR = 6, 1107 VK_LOGIC_OP_OR = 7, 1108 VK_LOGIC_OP_NOR = 8, 1109 VK_LOGIC_OP_EQUIVALENT = 9, 1110 VK_LOGIC_OP_INVERT = 10, 1111 VK_LOGIC_OP_OR_REVERSE = 11, 1112 VK_LOGIC_OP_COPY_INVERTED = 12, 1113 VK_LOGIC_OP_OR_INVERTED = 13, 1114 VK_LOGIC_OP_NAND = 14, 1115 VK_LOGIC_OP_SET = 15, 1116 VK_LOGIC_OP_BEGIN_RANGE = VK_LOGIC_OP_CLEAR, 1117 VK_LOGIC_OP_END_RANGE = VK_LOGIC_OP_SET, 1118 VK_LOGIC_OP_RANGE_SIZE = ( VK_LOGIC_OP_SET - VK_LOGIC_OP_CLEAR + 1 ), 1119 VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF 1120 } 1121 1122 // VkLogicOp global enums 1123 enum VK_LOGIC_OP_CLEAR = VkLogicOp.VK_LOGIC_OP_CLEAR; 1124 enum VK_LOGIC_OP_AND = VkLogicOp.VK_LOGIC_OP_AND; 1125 enum VK_LOGIC_OP_AND_REVERSE = VkLogicOp.VK_LOGIC_OP_AND_REVERSE; 1126 enum VK_LOGIC_OP_COPY = VkLogicOp.VK_LOGIC_OP_COPY; 1127 enum VK_LOGIC_OP_AND_INVERTED = VkLogicOp.VK_LOGIC_OP_AND_INVERTED; 1128 enum VK_LOGIC_OP_NO_OP = VkLogicOp.VK_LOGIC_OP_NO_OP; 1129 enum VK_LOGIC_OP_XOR = VkLogicOp.VK_LOGIC_OP_XOR; 1130 enum VK_LOGIC_OP_OR = VkLogicOp.VK_LOGIC_OP_OR; 1131 enum VK_LOGIC_OP_NOR = VkLogicOp.VK_LOGIC_OP_NOR; 1132 enum VK_LOGIC_OP_EQUIVALENT = VkLogicOp.VK_LOGIC_OP_EQUIVALENT; 1133 enum VK_LOGIC_OP_INVERT = VkLogicOp.VK_LOGIC_OP_INVERT; 1134 enum VK_LOGIC_OP_OR_REVERSE = VkLogicOp.VK_LOGIC_OP_OR_REVERSE; 1135 enum VK_LOGIC_OP_COPY_INVERTED = VkLogicOp.VK_LOGIC_OP_COPY_INVERTED; 1136 enum VK_LOGIC_OP_OR_INVERTED = VkLogicOp.VK_LOGIC_OP_OR_INVERTED; 1137 enum VK_LOGIC_OP_NAND = VkLogicOp.VK_LOGIC_OP_NAND; 1138 enum VK_LOGIC_OP_SET = VkLogicOp.VK_LOGIC_OP_SET; 1139 enum VK_LOGIC_OP_BEGIN_RANGE = VkLogicOp.VK_LOGIC_OP_BEGIN_RANGE; 1140 enum VK_LOGIC_OP_END_RANGE = VkLogicOp.VK_LOGIC_OP_END_RANGE; 1141 enum VK_LOGIC_OP_RANGE_SIZE = VkLogicOp.VK_LOGIC_OP_RANGE_SIZE; 1142 enum VK_LOGIC_OP_MAX_ENUM = VkLogicOp.VK_LOGIC_OP_MAX_ENUM; 1143 1144 enum VkBlendFactor { 1145 VK_BLEND_FACTOR_ZERO = 0, 1146 VK_BLEND_FACTOR_ONE = 1, 1147 VK_BLEND_FACTOR_SRC_COLOR = 2, 1148 VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3, 1149 VK_BLEND_FACTOR_DST_COLOR = 4, 1150 VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5, 1151 VK_BLEND_FACTOR_SRC_ALPHA = 6, 1152 VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7, 1153 VK_BLEND_FACTOR_DST_ALPHA = 8, 1154 VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9, 1155 VK_BLEND_FACTOR_CONSTANT_COLOR = 10, 1156 VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11, 1157 VK_BLEND_FACTOR_CONSTANT_ALPHA = 12, 1158 VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13, 1159 VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14, 1160 VK_BLEND_FACTOR_SRC1_COLOR = 15, 1161 VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16, 1162 VK_BLEND_FACTOR_SRC1_ALPHA = 17, 1163 VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18, 1164 VK_BLEND_FACTOR_BEGIN_RANGE = VK_BLEND_FACTOR_ZERO, 1165 VK_BLEND_FACTOR_END_RANGE = VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA, 1166 VK_BLEND_FACTOR_RANGE_SIZE = ( VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA - VK_BLEND_FACTOR_ZERO + 1 ), 1167 VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF 1168 } 1169 1170 // VkBlendFactor global enums 1171 enum VK_BLEND_FACTOR_ZERO = VkBlendFactor.VK_BLEND_FACTOR_ZERO; 1172 enum VK_BLEND_FACTOR_ONE = VkBlendFactor.VK_BLEND_FACTOR_ONE; 1173 enum VK_BLEND_FACTOR_SRC_COLOR = VkBlendFactor.VK_BLEND_FACTOR_SRC_COLOR; 1174 enum VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = VkBlendFactor.VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR; 1175 enum VK_BLEND_FACTOR_DST_COLOR = VkBlendFactor.VK_BLEND_FACTOR_DST_COLOR; 1176 enum VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = VkBlendFactor.VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR; 1177 enum VK_BLEND_FACTOR_SRC_ALPHA = VkBlendFactor.VK_BLEND_FACTOR_SRC_ALPHA; 1178 enum VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = VkBlendFactor.VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA; 1179 enum VK_BLEND_FACTOR_DST_ALPHA = VkBlendFactor.VK_BLEND_FACTOR_DST_ALPHA; 1180 enum VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = VkBlendFactor.VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA; 1181 enum VK_BLEND_FACTOR_CONSTANT_COLOR = VkBlendFactor.VK_BLEND_FACTOR_CONSTANT_COLOR; 1182 enum VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = VkBlendFactor.VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR; 1183 enum VK_BLEND_FACTOR_CONSTANT_ALPHA = VkBlendFactor.VK_BLEND_FACTOR_CONSTANT_ALPHA; 1184 enum VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = VkBlendFactor.VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA; 1185 enum VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = VkBlendFactor.VK_BLEND_FACTOR_SRC_ALPHA_SATURATE; 1186 enum VK_BLEND_FACTOR_SRC1_COLOR = VkBlendFactor.VK_BLEND_FACTOR_SRC1_COLOR; 1187 enum VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = VkBlendFactor.VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR; 1188 enum VK_BLEND_FACTOR_SRC1_ALPHA = VkBlendFactor.VK_BLEND_FACTOR_SRC1_ALPHA; 1189 enum VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = VkBlendFactor.VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA; 1190 enum VK_BLEND_FACTOR_BEGIN_RANGE = VkBlendFactor.VK_BLEND_FACTOR_BEGIN_RANGE; 1191 enum VK_BLEND_FACTOR_END_RANGE = VkBlendFactor.VK_BLEND_FACTOR_END_RANGE; 1192 enum VK_BLEND_FACTOR_RANGE_SIZE = VkBlendFactor.VK_BLEND_FACTOR_RANGE_SIZE; 1193 enum VK_BLEND_FACTOR_MAX_ENUM = VkBlendFactor.VK_BLEND_FACTOR_MAX_ENUM; 1194 1195 enum VkBlendOp { 1196 VK_BLEND_OP_ADD = 0, 1197 VK_BLEND_OP_SUBTRACT = 1, 1198 VK_BLEND_OP_REVERSE_SUBTRACT = 2, 1199 VK_BLEND_OP_MIN = 3, 1200 VK_BLEND_OP_MAX = 4, 1201 VK_BLEND_OP_BEGIN_RANGE = VK_BLEND_OP_ADD, 1202 VK_BLEND_OP_END_RANGE = VK_BLEND_OP_MAX, 1203 VK_BLEND_OP_RANGE_SIZE = ( VK_BLEND_OP_MAX - VK_BLEND_OP_ADD + 1 ), 1204 VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF 1205 } 1206 1207 // VkBlendOp global enums 1208 enum VK_BLEND_OP_ADD = VkBlendOp.VK_BLEND_OP_ADD; 1209 enum VK_BLEND_OP_SUBTRACT = VkBlendOp.VK_BLEND_OP_SUBTRACT; 1210 enum VK_BLEND_OP_REVERSE_SUBTRACT = VkBlendOp.VK_BLEND_OP_REVERSE_SUBTRACT; 1211 enum VK_BLEND_OP_MIN = VkBlendOp.VK_BLEND_OP_MIN; 1212 enum VK_BLEND_OP_MAX = VkBlendOp.VK_BLEND_OP_MAX; 1213 enum VK_BLEND_OP_BEGIN_RANGE = VkBlendOp.VK_BLEND_OP_BEGIN_RANGE; 1214 enum VK_BLEND_OP_END_RANGE = VkBlendOp.VK_BLEND_OP_END_RANGE; 1215 enum VK_BLEND_OP_RANGE_SIZE = VkBlendOp.VK_BLEND_OP_RANGE_SIZE; 1216 enum VK_BLEND_OP_MAX_ENUM = VkBlendOp.VK_BLEND_OP_MAX_ENUM; 1217 1218 enum VkDynamicState { 1219 VK_DYNAMIC_STATE_VIEWPORT = 0, 1220 VK_DYNAMIC_STATE_SCISSOR = 1, 1221 VK_DYNAMIC_STATE_LINE_WIDTH = 2, 1222 VK_DYNAMIC_STATE_DEPTH_BIAS = 3, 1223 VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4, 1224 VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5, 1225 VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6, 1226 VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7, 1227 VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8, 1228 VK_DYNAMIC_STATE_BEGIN_RANGE = VK_DYNAMIC_STATE_VIEWPORT, 1229 VK_DYNAMIC_STATE_END_RANGE = VK_DYNAMIC_STATE_STENCIL_REFERENCE, 1230 VK_DYNAMIC_STATE_RANGE_SIZE = ( VK_DYNAMIC_STATE_STENCIL_REFERENCE - VK_DYNAMIC_STATE_VIEWPORT + 1 ), 1231 VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF 1232 } 1233 1234 // VkDynamicState global enums 1235 enum VK_DYNAMIC_STATE_VIEWPORT = VkDynamicState.VK_DYNAMIC_STATE_VIEWPORT; 1236 enum VK_DYNAMIC_STATE_SCISSOR = VkDynamicState.VK_DYNAMIC_STATE_SCISSOR; 1237 enum VK_DYNAMIC_STATE_LINE_WIDTH = VkDynamicState.VK_DYNAMIC_STATE_LINE_WIDTH; 1238 enum VK_DYNAMIC_STATE_DEPTH_BIAS = VkDynamicState.VK_DYNAMIC_STATE_DEPTH_BIAS; 1239 enum VK_DYNAMIC_STATE_BLEND_CONSTANTS = VkDynamicState.VK_DYNAMIC_STATE_BLEND_CONSTANTS; 1240 enum VK_DYNAMIC_STATE_DEPTH_BOUNDS = VkDynamicState.VK_DYNAMIC_STATE_DEPTH_BOUNDS; 1241 enum VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = VkDynamicState.VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK; 1242 enum VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = VkDynamicState.VK_DYNAMIC_STATE_STENCIL_WRITE_MASK; 1243 enum VK_DYNAMIC_STATE_STENCIL_REFERENCE = VkDynamicState.VK_DYNAMIC_STATE_STENCIL_REFERENCE; 1244 enum VK_DYNAMIC_STATE_BEGIN_RANGE = VkDynamicState.VK_DYNAMIC_STATE_BEGIN_RANGE; 1245 enum VK_DYNAMIC_STATE_END_RANGE = VkDynamicState.VK_DYNAMIC_STATE_END_RANGE; 1246 enum VK_DYNAMIC_STATE_RANGE_SIZE = VkDynamicState.VK_DYNAMIC_STATE_RANGE_SIZE; 1247 enum VK_DYNAMIC_STATE_MAX_ENUM = VkDynamicState.VK_DYNAMIC_STATE_MAX_ENUM; 1248 1249 enum VkFilter { 1250 VK_FILTER_NEAREST = 0, 1251 VK_FILTER_LINEAR = 1, 1252 VK_FILTER_CUBIC_IMG = 1000015000, 1253 VK_FILTER_BEGIN_RANGE = VK_FILTER_NEAREST, 1254 VK_FILTER_END_RANGE = VK_FILTER_LINEAR, 1255 VK_FILTER_RANGE_SIZE = ( VK_FILTER_LINEAR - VK_FILTER_NEAREST + 1 ), 1256 VK_FILTER_MAX_ENUM = 0x7FFFFFFF 1257 } 1258 1259 // VkFilter global enums 1260 enum VK_FILTER_NEAREST = VkFilter.VK_FILTER_NEAREST; 1261 enum VK_FILTER_LINEAR = VkFilter.VK_FILTER_LINEAR; 1262 enum VK_FILTER_CUBIC_IMG = VkFilter.VK_FILTER_CUBIC_IMG; 1263 enum VK_FILTER_BEGIN_RANGE = VkFilter.VK_FILTER_BEGIN_RANGE; 1264 enum VK_FILTER_END_RANGE = VkFilter.VK_FILTER_END_RANGE; 1265 enum VK_FILTER_RANGE_SIZE = VkFilter.VK_FILTER_RANGE_SIZE; 1266 enum VK_FILTER_MAX_ENUM = VkFilter.VK_FILTER_MAX_ENUM; 1267 1268 enum VkSamplerMipmapMode { 1269 VK_SAMPLER_MIPMAP_MODE_NEAREST = 0, 1270 VK_SAMPLER_MIPMAP_MODE_LINEAR = 1, 1271 VK_SAMPLER_MIPMAP_MODE_BEGIN_RANGE = VK_SAMPLER_MIPMAP_MODE_NEAREST, 1272 VK_SAMPLER_MIPMAP_MODE_END_RANGE = VK_SAMPLER_MIPMAP_MODE_LINEAR, 1273 VK_SAMPLER_MIPMAP_MODE_RANGE_SIZE = ( VK_SAMPLER_MIPMAP_MODE_LINEAR - VK_SAMPLER_MIPMAP_MODE_NEAREST + 1 ), 1274 VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF 1275 } 1276 1277 // VkSamplerMipmapMode global enums 1278 enum VK_SAMPLER_MIPMAP_MODE_NEAREST = VkSamplerMipmapMode.VK_SAMPLER_MIPMAP_MODE_NEAREST; 1279 enum VK_SAMPLER_MIPMAP_MODE_LINEAR = VkSamplerMipmapMode.VK_SAMPLER_MIPMAP_MODE_LINEAR; 1280 enum VK_SAMPLER_MIPMAP_MODE_BEGIN_RANGE = VkSamplerMipmapMode.VK_SAMPLER_MIPMAP_MODE_BEGIN_RANGE; 1281 enum VK_SAMPLER_MIPMAP_MODE_END_RANGE = VkSamplerMipmapMode.VK_SAMPLER_MIPMAP_MODE_END_RANGE; 1282 enum VK_SAMPLER_MIPMAP_MODE_RANGE_SIZE = VkSamplerMipmapMode.VK_SAMPLER_MIPMAP_MODE_RANGE_SIZE; 1283 enum VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = VkSamplerMipmapMode.VK_SAMPLER_MIPMAP_MODE_MAX_ENUM; 1284 1285 enum VkSamplerAddressMode { 1286 VK_SAMPLER_ADDRESS_MODE_REPEAT = 0, 1287 VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1, 1288 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2, 1289 VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3, 1290 VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4, 1291 VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE = VK_SAMPLER_ADDRESS_MODE_REPEAT, 1292 VK_SAMPLER_ADDRESS_MODE_END_RANGE = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER, 1293 VK_SAMPLER_ADDRESS_MODE_RANGE_SIZE = ( VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER - VK_SAMPLER_ADDRESS_MODE_REPEAT + 1 ), 1294 VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF 1295 } 1296 1297 // VkSamplerAddressMode global enums 1298 enum VK_SAMPLER_ADDRESS_MODE_REPEAT = VkSamplerAddressMode.VK_SAMPLER_ADDRESS_MODE_REPEAT; 1299 enum VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = VkSamplerAddressMode.VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT; 1300 enum VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = VkSamplerAddressMode.VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE; 1301 enum VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = VkSamplerAddressMode.VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER; 1302 enum VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = VkSamplerAddressMode.VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE; 1303 enum VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE = VkSamplerAddressMode.VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE; 1304 enum VK_SAMPLER_ADDRESS_MODE_END_RANGE = VkSamplerAddressMode.VK_SAMPLER_ADDRESS_MODE_END_RANGE; 1305 enum VK_SAMPLER_ADDRESS_MODE_RANGE_SIZE = VkSamplerAddressMode.VK_SAMPLER_ADDRESS_MODE_RANGE_SIZE; 1306 enum VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = VkSamplerAddressMode.VK_SAMPLER_ADDRESS_MODE_MAX_ENUM; 1307 1308 enum VkBorderColor { 1309 VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0, 1310 VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1, 1311 VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2, 1312 VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3, 1313 VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4, 1314 VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5, 1315 VK_BORDER_COLOR_BEGIN_RANGE = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK, 1316 VK_BORDER_COLOR_END_RANGE = VK_BORDER_COLOR_INT_OPAQUE_WHITE, 1317 VK_BORDER_COLOR_RANGE_SIZE = ( VK_BORDER_COLOR_INT_OPAQUE_WHITE - VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK + 1 ), 1318 VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF 1319 } 1320 1321 // VkBorderColor global enums 1322 enum VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = VkBorderColor.VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK; 1323 enum VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = VkBorderColor.VK_BORDER_COLOR_INT_TRANSPARENT_BLACK; 1324 enum VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = VkBorderColor.VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK; 1325 enum VK_BORDER_COLOR_INT_OPAQUE_BLACK = VkBorderColor.VK_BORDER_COLOR_INT_OPAQUE_BLACK; 1326 enum VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = VkBorderColor.VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE; 1327 enum VK_BORDER_COLOR_INT_OPAQUE_WHITE = VkBorderColor.VK_BORDER_COLOR_INT_OPAQUE_WHITE; 1328 enum VK_BORDER_COLOR_BEGIN_RANGE = VkBorderColor.VK_BORDER_COLOR_BEGIN_RANGE; 1329 enum VK_BORDER_COLOR_END_RANGE = VkBorderColor.VK_BORDER_COLOR_END_RANGE; 1330 enum VK_BORDER_COLOR_RANGE_SIZE = VkBorderColor.VK_BORDER_COLOR_RANGE_SIZE; 1331 enum VK_BORDER_COLOR_MAX_ENUM = VkBorderColor.VK_BORDER_COLOR_MAX_ENUM; 1332 1333 enum VkDescriptorType { 1334 VK_DESCRIPTOR_TYPE_SAMPLER = 0, 1335 VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1, 1336 VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2, 1337 VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3, 1338 VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4, 1339 VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5, 1340 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6, 1341 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7, 1342 VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8, 1343 VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9, 1344 VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10, 1345 VK_DESCRIPTOR_TYPE_BEGIN_RANGE = VK_DESCRIPTOR_TYPE_SAMPLER, 1346 VK_DESCRIPTOR_TYPE_END_RANGE = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT, 1347 VK_DESCRIPTOR_TYPE_RANGE_SIZE = ( VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT - VK_DESCRIPTOR_TYPE_SAMPLER + 1 ), 1348 VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF 1349 } 1350 1351 // VkDescriptorType global enums 1352 enum VK_DESCRIPTOR_TYPE_SAMPLER = VkDescriptorType.VK_DESCRIPTOR_TYPE_SAMPLER; 1353 enum VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = VkDescriptorType.VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; 1354 enum VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = VkDescriptorType.VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE; 1355 enum VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = VkDescriptorType.VK_DESCRIPTOR_TYPE_STORAGE_IMAGE; 1356 enum VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = VkDescriptorType.VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER; 1357 enum VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = VkDescriptorType.VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER; 1358 enum VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = VkDescriptorType.VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; 1359 enum VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = VkDescriptorType.VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; 1360 enum VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = VkDescriptorType.VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC; 1361 enum VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = VkDescriptorType.VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC; 1362 enum VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = VkDescriptorType.VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT; 1363 enum VK_DESCRIPTOR_TYPE_BEGIN_RANGE = VkDescriptorType.VK_DESCRIPTOR_TYPE_BEGIN_RANGE; 1364 enum VK_DESCRIPTOR_TYPE_END_RANGE = VkDescriptorType.VK_DESCRIPTOR_TYPE_END_RANGE; 1365 enum VK_DESCRIPTOR_TYPE_RANGE_SIZE = VkDescriptorType.VK_DESCRIPTOR_TYPE_RANGE_SIZE; 1366 enum VK_DESCRIPTOR_TYPE_MAX_ENUM = VkDescriptorType.VK_DESCRIPTOR_TYPE_MAX_ENUM; 1367 1368 enum VkAttachmentLoadOp { 1369 VK_ATTACHMENT_LOAD_OP_LOAD = 0, 1370 VK_ATTACHMENT_LOAD_OP_CLEAR = 1, 1371 VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2, 1372 VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE = VK_ATTACHMENT_LOAD_OP_LOAD, 1373 VK_ATTACHMENT_LOAD_OP_END_RANGE = VK_ATTACHMENT_LOAD_OP_DONT_CARE, 1374 VK_ATTACHMENT_LOAD_OP_RANGE_SIZE = ( VK_ATTACHMENT_LOAD_OP_DONT_CARE - VK_ATTACHMENT_LOAD_OP_LOAD + 1 ), 1375 VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF 1376 } 1377 1378 // VkAttachmentLoadOp global enums 1379 enum VK_ATTACHMENT_LOAD_OP_LOAD = VkAttachmentLoadOp.VK_ATTACHMENT_LOAD_OP_LOAD; 1380 enum VK_ATTACHMENT_LOAD_OP_CLEAR = VkAttachmentLoadOp.VK_ATTACHMENT_LOAD_OP_CLEAR; 1381 enum VK_ATTACHMENT_LOAD_OP_DONT_CARE = VkAttachmentLoadOp.VK_ATTACHMENT_LOAD_OP_DONT_CARE; 1382 enum VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE = VkAttachmentLoadOp.VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE; 1383 enum VK_ATTACHMENT_LOAD_OP_END_RANGE = VkAttachmentLoadOp.VK_ATTACHMENT_LOAD_OP_END_RANGE; 1384 enum VK_ATTACHMENT_LOAD_OP_RANGE_SIZE = VkAttachmentLoadOp.VK_ATTACHMENT_LOAD_OP_RANGE_SIZE; 1385 enum VK_ATTACHMENT_LOAD_OP_MAX_ENUM = VkAttachmentLoadOp.VK_ATTACHMENT_LOAD_OP_MAX_ENUM; 1386 1387 enum VkAttachmentStoreOp { 1388 VK_ATTACHMENT_STORE_OP_STORE = 0, 1389 VK_ATTACHMENT_STORE_OP_DONT_CARE = 1, 1390 VK_ATTACHMENT_STORE_OP_BEGIN_RANGE = VK_ATTACHMENT_STORE_OP_STORE, 1391 VK_ATTACHMENT_STORE_OP_END_RANGE = VK_ATTACHMENT_STORE_OP_DONT_CARE, 1392 VK_ATTACHMENT_STORE_OP_RANGE_SIZE = ( VK_ATTACHMENT_STORE_OP_DONT_CARE - VK_ATTACHMENT_STORE_OP_STORE + 1 ), 1393 VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF 1394 } 1395 1396 // VkAttachmentStoreOp global enums 1397 enum VK_ATTACHMENT_STORE_OP_STORE = VkAttachmentStoreOp.VK_ATTACHMENT_STORE_OP_STORE; 1398 enum VK_ATTACHMENT_STORE_OP_DONT_CARE = VkAttachmentStoreOp.VK_ATTACHMENT_STORE_OP_DONT_CARE; 1399 enum VK_ATTACHMENT_STORE_OP_BEGIN_RANGE = VkAttachmentStoreOp.VK_ATTACHMENT_STORE_OP_BEGIN_RANGE; 1400 enum VK_ATTACHMENT_STORE_OP_END_RANGE = VkAttachmentStoreOp.VK_ATTACHMENT_STORE_OP_END_RANGE; 1401 enum VK_ATTACHMENT_STORE_OP_RANGE_SIZE = VkAttachmentStoreOp.VK_ATTACHMENT_STORE_OP_RANGE_SIZE; 1402 enum VK_ATTACHMENT_STORE_OP_MAX_ENUM = VkAttachmentStoreOp.VK_ATTACHMENT_STORE_OP_MAX_ENUM; 1403 1404 enum VkPipelineBindPoint { 1405 VK_PIPELINE_BIND_POINT_GRAPHICS = 0, 1406 VK_PIPELINE_BIND_POINT_COMPUTE = 1, 1407 VK_PIPELINE_BIND_POINT_BEGIN_RANGE = VK_PIPELINE_BIND_POINT_GRAPHICS, 1408 VK_PIPELINE_BIND_POINT_END_RANGE = VK_PIPELINE_BIND_POINT_COMPUTE, 1409 VK_PIPELINE_BIND_POINT_RANGE_SIZE = ( VK_PIPELINE_BIND_POINT_COMPUTE - VK_PIPELINE_BIND_POINT_GRAPHICS + 1 ), 1410 VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF 1411 } 1412 1413 // VkPipelineBindPoint global enums 1414 enum VK_PIPELINE_BIND_POINT_GRAPHICS = VkPipelineBindPoint.VK_PIPELINE_BIND_POINT_GRAPHICS; 1415 enum VK_PIPELINE_BIND_POINT_COMPUTE = VkPipelineBindPoint.VK_PIPELINE_BIND_POINT_COMPUTE; 1416 enum VK_PIPELINE_BIND_POINT_BEGIN_RANGE = VkPipelineBindPoint.VK_PIPELINE_BIND_POINT_BEGIN_RANGE; 1417 enum VK_PIPELINE_BIND_POINT_END_RANGE = VkPipelineBindPoint.VK_PIPELINE_BIND_POINT_END_RANGE; 1418 enum VK_PIPELINE_BIND_POINT_RANGE_SIZE = VkPipelineBindPoint.VK_PIPELINE_BIND_POINT_RANGE_SIZE; 1419 enum VK_PIPELINE_BIND_POINT_MAX_ENUM = VkPipelineBindPoint.VK_PIPELINE_BIND_POINT_MAX_ENUM; 1420 1421 enum VkCommandBufferLevel { 1422 VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0, 1423 VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1, 1424 VK_COMMAND_BUFFER_LEVEL_BEGIN_RANGE = VK_COMMAND_BUFFER_LEVEL_PRIMARY, 1425 VK_COMMAND_BUFFER_LEVEL_END_RANGE = VK_COMMAND_BUFFER_LEVEL_SECONDARY, 1426 VK_COMMAND_BUFFER_LEVEL_RANGE_SIZE = ( VK_COMMAND_BUFFER_LEVEL_SECONDARY - VK_COMMAND_BUFFER_LEVEL_PRIMARY + 1 ), 1427 VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF 1428 } 1429 1430 // VkCommandBufferLevel global enums 1431 enum VK_COMMAND_BUFFER_LEVEL_PRIMARY = VkCommandBufferLevel.VK_COMMAND_BUFFER_LEVEL_PRIMARY; 1432 enum VK_COMMAND_BUFFER_LEVEL_SECONDARY = VkCommandBufferLevel.VK_COMMAND_BUFFER_LEVEL_SECONDARY; 1433 enum VK_COMMAND_BUFFER_LEVEL_BEGIN_RANGE = VkCommandBufferLevel.VK_COMMAND_BUFFER_LEVEL_BEGIN_RANGE; 1434 enum VK_COMMAND_BUFFER_LEVEL_END_RANGE = VkCommandBufferLevel.VK_COMMAND_BUFFER_LEVEL_END_RANGE; 1435 enum VK_COMMAND_BUFFER_LEVEL_RANGE_SIZE = VkCommandBufferLevel.VK_COMMAND_BUFFER_LEVEL_RANGE_SIZE; 1436 enum VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = VkCommandBufferLevel.VK_COMMAND_BUFFER_LEVEL_MAX_ENUM; 1437 1438 enum VkIndexType { 1439 VK_INDEX_TYPE_UINT16 = 0, 1440 VK_INDEX_TYPE_UINT32 = 1, 1441 VK_INDEX_TYPE_BEGIN_RANGE = VK_INDEX_TYPE_UINT16, 1442 VK_INDEX_TYPE_END_RANGE = VK_INDEX_TYPE_UINT32, 1443 VK_INDEX_TYPE_RANGE_SIZE = ( VK_INDEX_TYPE_UINT32 - VK_INDEX_TYPE_UINT16 + 1 ), 1444 VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF 1445 } 1446 1447 // VkIndexType global enums 1448 enum VK_INDEX_TYPE_UINT16 = VkIndexType.VK_INDEX_TYPE_UINT16; 1449 enum VK_INDEX_TYPE_UINT32 = VkIndexType.VK_INDEX_TYPE_UINT32; 1450 enum VK_INDEX_TYPE_BEGIN_RANGE = VkIndexType.VK_INDEX_TYPE_BEGIN_RANGE; 1451 enum VK_INDEX_TYPE_END_RANGE = VkIndexType.VK_INDEX_TYPE_END_RANGE; 1452 enum VK_INDEX_TYPE_RANGE_SIZE = VkIndexType.VK_INDEX_TYPE_RANGE_SIZE; 1453 enum VK_INDEX_TYPE_MAX_ENUM = VkIndexType.VK_INDEX_TYPE_MAX_ENUM; 1454 1455 enum VkSubpassContents { 1456 VK_SUBPASS_CONTENTS_INLINE = 0, 1457 VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1, 1458 VK_SUBPASS_CONTENTS_BEGIN_RANGE = VK_SUBPASS_CONTENTS_INLINE, 1459 VK_SUBPASS_CONTENTS_END_RANGE = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS, 1460 VK_SUBPASS_CONTENTS_RANGE_SIZE = ( VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS - VK_SUBPASS_CONTENTS_INLINE + 1 ), 1461 VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF 1462 } 1463 1464 // VkSubpassContents global enums 1465 enum VK_SUBPASS_CONTENTS_INLINE = VkSubpassContents.VK_SUBPASS_CONTENTS_INLINE; 1466 enum VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = VkSubpassContents.VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS; 1467 enum VK_SUBPASS_CONTENTS_BEGIN_RANGE = VkSubpassContents.VK_SUBPASS_CONTENTS_BEGIN_RANGE; 1468 enum VK_SUBPASS_CONTENTS_END_RANGE = VkSubpassContents.VK_SUBPASS_CONTENTS_END_RANGE; 1469 enum VK_SUBPASS_CONTENTS_RANGE_SIZE = VkSubpassContents.VK_SUBPASS_CONTENTS_RANGE_SIZE; 1470 enum VK_SUBPASS_CONTENTS_MAX_ENUM = VkSubpassContents.VK_SUBPASS_CONTENTS_MAX_ENUM; 1471 1472 alias VkInstanceCreateFlags = VkFlags; 1473 1474 enum VkFormatFeatureFlagBits { 1475 VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001, 1476 VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002, 1477 VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004, 1478 VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008, 1479 VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010, 1480 VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020, 1481 VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040, 1482 VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080, 1483 VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100, 1484 VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200, 1485 VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0x00000400, 1486 VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800, 1487 VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000, 1488 VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = 0x00002000, 1489 VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1490 } 1491 1492 // VkFormatFeatureFlagBits global enums 1493 enum VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = VkFormatFeatureFlagBits.VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT; 1494 enum VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = VkFormatFeatureFlagBits.VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT; 1495 enum VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = VkFormatFeatureFlagBits.VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT; 1496 enum VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = VkFormatFeatureFlagBits.VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT; 1497 enum VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = VkFormatFeatureFlagBits.VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT; 1498 enum VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = VkFormatFeatureFlagBits.VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT; 1499 enum VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = VkFormatFeatureFlagBits.VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT; 1500 enum VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = VkFormatFeatureFlagBits.VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT; 1501 enum VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = VkFormatFeatureFlagBits.VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT; 1502 enum VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = VkFormatFeatureFlagBits.VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT; 1503 enum VK_FORMAT_FEATURE_BLIT_SRC_BIT = VkFormatFeatureFlagBits.VK_FORMAT_FEATURE_BLIT_SRC_BIT; 1504 enum VK_FORMAT_FEATURE_BLIT_DST_BIT = VkFormatFeatureFlagBits.VK_FORMAT_FEATURE_BLIT_DST_BIT; 1505 enum VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = VkFormatFeatureFlagBits.VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT; 1506 enum VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = VkFormatFeatureFlagBits.VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG; 1507 enum VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM = VkFormatFeatureFlagBits.VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM; 1508 alias VkFormatFeatureFlags = VkFlags; 1509 1510 enum VkImageUsageFlagBits { 1511 VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001, 1512 VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0x00000002, 1513 VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004, 1514 VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008, 1515 VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010, 1516 VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020, 1517 VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040, 1518 VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080, 1519 VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1520 } 1521 1522 // VkImageUsageFlagBits global enums 1523 enum VK_IMAGE_USAGE_TRANSFER_SRC_BIT = VkImageUsageFlagBits.VK_IMAGE_USAGE_TRANSFER_SRC_BIT; 1524 enum VK_IMAGE_USAGE_TRANSFER_DST_BIT = VkImageUsageFlagBits.VK_IMAGE_USAGE_TRANSFER_DST_BIT; 1525 enum VK_IMAGE_USAGE_SAMPLED_BIT = VkImageUsageFlagBits.VK_IMAGE_USAGE_SAMPLED_BIT; 1526 enum VK_IMAGE_USAGE_STORAGE_BIT = VkImageUsageFlagBits.VK_IMAGE_USAGE_STORAGE_BIT; 1527 enum VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = VkImageUsageFlagBits.VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; 1528 enum VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = VkImageUsageFlagBits.VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT; 1529 enum VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = VkImageUsageFlagBits.VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT; 1530 enum VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = VkImageUsageFlagBits.VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT; 1531 enum VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = VkImageUsageFlagBits.VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM; 1532 alias VkImageUsageFlags = VkFlags; 1533 1534 enum VkImageCreateFlagBits { 1535 VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0x00000001, 1536 VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, 1537 VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004, 1538 VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008, 1539 VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010, 1540 VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1541 } 1542 1543 // VkImageCreateFlagBits global enums 1544 enum VK_IMAGE_CREATE_SPARSE_BINDING_BIT = VkImageCreateFlagBits.VK_IMAGE_CREATE_SPARSE_BINDING_BIT; 1545 enum VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = VkImageCreateFlagBits.VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT; 1546 enum VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = VkImageCreateFlagBits.VK_IMAGE_CREATE_SPARSE_ALIASED_BIT; 1547 enum VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = VkImageCreateFlagBits.VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT; 1548 enum VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = VkImageCreateFlagBits.VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT; 1549 enum VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = VkImageCreateFlagBits.VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM; 1550 alias VkImageCreateFlags = VkFlags; 1551 1552 enum VkSampleCountFlagBits { 1553 VK_SAMPLE_COUNT_1_BIT = 0x00000001, 1554 VK_SAMPLE_COUNT_2_BIT = 0x00000002, 1555 VK_SAMPLE_COUNT_4_BIT = 0x00000004, 1556 VK_SAMPLE_COUNT_8_BIT = 0x00000008, 1557 VK_SAMPLE_COUNT_16_BIT = 0x00000010, 1558 VK_SAMPLE_COUNT_32_BIT = 0x00000020, 1559 VK_SAMPLE_COUNT_64_BIT = 0x00000040, 1560 VK_SAMPLE_COUNT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1561 } 1562 1563 // VkSampleCountFlagBits global enums 1564 enum VK_SAMPLE_COUNT_1_BIT = VkSampleCountFlagBits.VK_SAMPLE_COUNT_1_BIT; 1565 enum VK_SAMPLE_COUNT_2_BIT = VkSampleCountFlagBits.VK_SAMPLE_COUNT_2_BIT; 1566 enum VK_SAMPLE_COUNT_4_BIT = VkSampleCountFlagBits.VK_SAMPLE_COUNT_4_BIT; 1567 enum VK_SAMPLE_COUNT_8_BIT = VkSampleCountFlagBits.VK_SAMPLE_COUNT_8_BIT; 1568 enum VK_SAMPLE_COUNT_16_BIT = VkSampleCountFlagBits.VK_SAMPLE_COUNT_16_BIT; 1569 enum VK_SAMPLE_COUNT_32_BIT = VkSampleCountFlagBits.VK_SAMPLE_COUNT_32_BIT; 1570 enum VK_SAMPLE_COUNT_64_BIT = VkSampleCountFlagBits.VK_SAMPLE_COUNT_64_BIT; 1571 enum VK_SAMPLE_COUNT_FLAG_BITS_MAX_ENUM = VkSampleCountFlagBits.VK_SAMPLE_COUNT_FLAG_BITS_MAX_ENUM; 1572 alias VkSampleCountFlags = VkFlags; 1573 1574 enum VkQueueFlagBits { 1575 VK_QUEUE_GRAPHICS_BIT = 0x00000001, 1576 VK_QUEUE_COMPUTE_BIT = 0x00000002, 1577 VK_QUEUE_TRANSFER_BIT = 0x00000004, 1578 VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008, 1579 VK_QUEUE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1580 } 1581 1582 // VkQueueFlagBits global enums 1583 enum VK_QUEUE_GRAPHICS_BIT = VkQueueFlagBits.VK_QUEUE_GRAPHICS_BIT; 1584 enum VK_QUEUE_COMPUTE_BIT = VkQueueFlagBits.VK_QUEUE_COMPUTE_BIT; 1585 enum VK_QUEUE_TRANSFER_BIT = VkQueueFlagBits.VK_QUEUE_TRANSFER_BIT; 1586 enum VK_QUEUE_SPARSE_BINDING_BIT = VkQueueFlagBits.VK_QUEUE_SPARSE_BINDING_BIT; 1587 enum VK_QUEUE_FLAG_BITS_MAX_ENUM = VkQueueFlagBits.VK_QUEUE_FLAG_BITS_MAX_ENUM; 1588 alias VkQueueFlags = VkFlags; 1589 1590 enum VkMemoryPropertyFlagBits { 1591 VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0x00000001, 1592 VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000002, 1593 VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004, 1594 VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008, 1595 VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010, 1596 VK_MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1597 } 1598 1599 // VkMemoryPropertyFlagBits global enums 1600 enum VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = VkMemoryPropertyFlagBits.VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT; 1601 enum VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = VkMemoryPropertyFlagBits.VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT; 1602 enum VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = VkMemoryPropertyFlagBits.VK_MEMORY_PROPERTY_HOST_COHERENT_BIT; 1603 enum VK_MEMORY_PROPERTY_HOST_CACHED_BIT = VkMemoryPropertyFlagBits.VK_MEMORY_PROPERTY_HOST_CACHED_BIT; 1604 enum VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = VkMemoryPropertyFlagBits.VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT; 1605 enum VK_MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM = VkMemoryPropertyFlagBits.VK_MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM; 1606 alias VkMemoryPropertyFlags = VkFlags; 1607 1608 enum VkMemoryHeapFlagBits { 1609 VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001, 1610 VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1611 } 1612 1613 // VkMemoryHeapFlagBits global enums 1614 enum VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = VkMemoryHeapFlagBits.VK_MEMORY_HEAP_DEVICE_LOCAL_BIT; 1615 enum VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM = VkMemoryHeapFlagBits.VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM; 1616 alias VkMemoryHeapFlags = VkFlags; 1617 alias VkDeviceCreateFlags = VkFlags; 1618 alias VkDeviceQueueCreateFlags = VkFlags; 1619 1620 enum VkPipelineStageFlagBits { 1621 VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001, 1622 VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002, 1623 VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004, 1624 VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008, 1625 VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010, 1626 VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020, 1627 VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040, 1628 VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080, 1629 VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100, 1630 VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200, 1631 VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400, 1632 VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800, 1633 VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000, 1634 VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 0x00002000, 1635 VK_PIPELINE_STAGE_HOST_BIT = 0x00004000, 1636 VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000, 1637 VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000, 1638 VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1639 } 1640 1641 // VkPipelineStageFlagBits global enums 1642 enum VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT; 1643 enum VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT; 1644 enum VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_VERTEX_INPUT_BIT; 1645 enum VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_VERTEX_SHADER_BIT; 1646 enum VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT; 1647 enum VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT; 1648 enum VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT; 1649 enum VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT; 1650 enum VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT; 1651 enum VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT; 1652 enum VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; 1653 enum VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT; 1654 enum VK_PIPELINE_STAGE_TRANSFER_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_TRANSFER_BIT; 1655 enum VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT; 1656 enum VK_PIPELINE_STAGE_HOST_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_HOST_BIT; 1657 enum VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT; 1658 enum VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_ALL_COMMANDS_BIT; 1659 enum VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = VkPipelineStageFlagBits.VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM; 1660 alias VkPipelineStageFlags = VkFlags; 1661 alias VkMemoryMapFlags = VkFlags; 1662 1663 enum VkImageAspectFlagBits { 1664 VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001, 1665 VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002, 1666 VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004, 1667 VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008, 1668 VK_IMAGE_ASPECT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1669 } 1670 1671 // VkImageAspectFlagBits global enums 1672 enum VK_IMAGE_ASPECT_COLOR_BIT = VkImageAspectFlagBits.VK_IMAGE_ASPECT_COLOR_BIT; 1673 enum VK_IMAGE_ASPECT_DEPTH_BIT = VkImageAspectFlagBits.VK_IMAGE_ASPECT_DEPTH_BIT; 1674 enum VK_IMAGE_ASPECT_STENCIL_BIT = VkImageAspectFlagBits.VK_IMAGE_ASPECT_STENCIL_BIT; 1675 enum VK_IMAGE_ASPECT_METADATA_BIT = VkImageAspectFlagBits.VK_IMAGE_ASPECT_METADATA_BIT; 1676 enum VK_IMAGE_ASPECT_FLAG_BITS_MAX_ENUM = VkImageAspectFlagBits.VK_IMAGE_ASPECT_FLAG_BITS_MAX_ENUM; 1677 alias VkImageAspectFlags = VkFlags; 1678 1679 enum VkSparseImageFormatFlagBits { 1680 VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0x00000001, 1681 VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 0x00000002, 1682 VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0x00000004, 1683 VK_SPARSE_IMAGE_FORMAT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1684 } 1685 1686 // VkSparseImageFormatFlagBits global enums 1687 enum VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = VkSparseImageFormatFlagBits.VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT; 1688 enum VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = VkSparseImageFormatFlagBits.VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT; 1689 enum VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = VkSparseImageFormatFlagBits.VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT; 1690 enum VK_SPARSE_IMAGE_FORMAT_FLAG_BITS_MAX_ENUM = VkSparseImageFormatFlagBits.VK_SPARSE_IMAGE_FORMAT_FLAG_BITS_MAX_ENUM; 1691 alias VkSparseImageFormatFlags = VkFlags; 1692 1693 enum VkSparseMemoryBindFlagBits { 1694 VK_SPARSE_MEMORY_BIND_METADATA_BIT = 0x00000001, 1695 VK_SPARSE_MEMORY_BIND_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1696 } 1697 1698 // VkSparseMemoryBindFlagBits global enums 1699 enum VK_SPARSE_MEMORY_BIND_METADATA_BIT = VkSparseMemoryBindFlagBits.VK_SPARSE_MEMORY_BIND_METADATA_BIT; 1700 enum VK_SPARSE_MEMORY_BIND_FLAG_BITS_MAX_ENUM = VkSparseMemoryBindFlagBits.VK_SPARSE_MEMORY_BIND_FLAG_BITS_MAX_ENUM; 1701 alias VkSparseMemoryBindFlags = VkFlags; 1702 1703 enum VkFenceCreateFlagBits { 1704 VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001, 1705 VK_FENCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1706 } 1707 1708 // VkFenceCreateFlagBits global enums 1709 enum VK_FENCE_CREATE_SIGNALED_BIT = VkFenceCreateFlagBits.VK_FENCE_CREATE_SIGNALED_BIT; 1710 enum VK_FENCE_CREATE_FLAG_BITS_MAX_ENUM = VkFenceCreateFlagBits.VK_FENCE_CREATE_FLAG_BITS_MAX_ENUM; 1711 alias VkFenceCreateFlags = VkFlags; 1712 alias VkSemaphoreCreateFlags = VkFlags; 1713 alias VkEventCreateFlags = VkFlags; 1714 alias VkQueryPoolCreateFlags = VkFlags; 1715 1716 enum VkQueryPipelineStatisticFlagBits { 1717 VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001, 1718 VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0x00000002, 1719 VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0x00000004, 1720 VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 0x00000008, 1721 VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 0x00000010, 1722 VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 0x00000020, 1723 VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 0x00000040, 1724 VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 0x00000080, 1725 VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 0x00000100, 1726 VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 0x00000200, 1727 VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 0x00000400, 1728 VK_QUERY_PIPELINE_STATISTIC_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1729 } 1730 1731 // VkQueryPipelineStatisticFlagBits global enums 1732 enum VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = VkQueryPipelineStatisticFlagBits.VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT; 1733 enum VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = VkQueryPipelineStatisticFlagBits.VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT; 1734 enum VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = VkQueryPipelineStatisticFlagBits.VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT; 1735 enum VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = VkQueryPipelineStatisticFlagBits.VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT; 1736 enum VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = VkQueryPipelineStatisticFlagBits.VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT; 1737 enum VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = VkQueryPipelineStatisticFlagBits.VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT; 1738 enum VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = VkQueryPipelineStatisticFlagBits.VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT; 1739 enum VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = VkQueryPipelineStatisticFlagBits.VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT; 1740 enum VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = VkQueryPipelineStatisticFlagBits.VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT; 1741 enum VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = VkQueryPipelineStatisticFlagBits.VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT; 1742 enum VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = VkQueryPipelineStatisticFlagBits.VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT; 1743 enum VK_QUERY_PIPELINE_STATISTIC_FLAG_BITS_MAX_ENUM = VkQueryPipelineStatisticFlagBits.VK_QUERY_PIPELINE_STATISTIC_FLAG_BITS_MAX_ENUM; 1744 alias VkQueryPipelineStatisticFlags = VkFlags; 1745 1746 enum VkQueryResultFlagBits { 1747 VK_QUERY_RESULT_64_BIT = 0x00000001, 1748 VK_QUERY_RESULT_WAIT_BIT = 0x00000002, 1749 VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004, 1750 VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008, 1751 VK_QUERY_RESULT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1752 } 1753 1754 // VkQueryResultFlagBits global enums 1755 enum VK_QUERY_RESULT_64_BIT = VkQueryResultFlagBits.VK_QUERY_RESULT_64_BIT; 1756 enum VK_QUERY_RESULT_WAIT_BIT = VkQueryResultFlagBits.VK_QUERY_RESULT_WAIT_BIT; 1757 enum VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = VkQueryResultFlagBits.VK_QUERY_RESULT_WITH_AVAILABILITY_BIT; 1758 enum VK_QUERY_RESULT_PARTIAL_BIT = VkQueryResultFlagBits.VK_QUERY_RESULT_PARTIAL_BIT; 1759 enum VK_QUERY_RESULT_FLAG_BITS_MAX_ENUM = VkQueryResultFlagBits.VK_QUERY_RESULT_FLAG_BITS_MAX_ENUM; 1760 alias VkQueryResultFlags = VkFlags; 1761 1762 enum VkBufferCreateFlagBits { 1763 VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001, 1764 VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, 1765 VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004, 1766 VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1767 } 1768 1769 // VkBufferCreateFlagBits global enums 1770 enum VK_BUFFER_CREATE_SPARSE_BINDING_BIT = VkBufferCreateFlagBits.VK_BUFFER_CREATE_SPARSE_BINDING_BIT; 1771 enum VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = VkBufferCreateFlagBits.VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT; 1772 enum VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = VkBufferCreateFlagBits.VK_BUFFER_CREATE_SPARSE_ALIASED_BIT; 1773 enum VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = VkBufferCreateFlagBits.VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM; 1774 alias VkBufferCreateFlags = VkFlags; 1775 1776 enum VkBufferUsageFlagBits { 1777 VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001, 1778 VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002, 1779 VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004, 1780 VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008, 1781 VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010, 1782 VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020, 1783 VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040, 1784 VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080, 1785 VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100, 1786 VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1787 } 1788 1789 // VkBufferUsageFlagBits global enums 1790 enum VK_BUFFER_USAGE_TRANSFER_SRC_BIT = VkBufferUsageFlagBits.VK_BUFFER_USAGE_TRANSFER_SRC_BIT; 1791 enum VK_BUFFER_USAGE_TRANSFER_DST_BIT = VkBufferUsageFlagBits.VK_BUFFER_USAGE_TRANSFER_DST_BIT; 1792 enum VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = VkBufferUsageFlagBits.VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT; 1793 enum VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = VkBufferUsageFlagBits.VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT; 1794 enum VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = VkBufferUsageFlagBits.VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT; 1795 enum VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = VkBufferUsageFlagBits.VK_BUFFER_USAGE_STORAGE_BUFFER_BIT; 1796 enum VK_BUFFER_USAGE_INDEX_BUFFER_BIT = VkBufferUsageFlagBits.VK_BUFFER_USAGE_INDEX_BUFFER_BIT; 1797 enum VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = VkBufferUsageFlagBits.VK_BUFFER_USAGE_VERTEX_BUFFER_BIT; 1798 enum VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = VkBufferUsageFlagBits.VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT; 1799 enum VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = VkBufferUsageFlagBits.VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM; 1800 alias VkBufferUsageFlags = VkFlags; 1801 alias VkBufferViewCreateFlags = VkFlags; 1802 alias VkImageViewCreateFlags = VkFlags; 1803 alias VkShaderModuleCreateFlags = VkFlags; 1804 alias VkPipelineCacheCreateFlags = VkFlags; 1805 1806 enum VkPipelineCreateFlagBits { 1807 VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001, 1808 VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002, 1809 VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004, 1810 VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1811 } 1812 1813 // VkPipelineCreateFlagBits global enums 1814 enum VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = VkPipelineCreateFlagBits.VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT; 1815 enum VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = VkPipelineCreateFlagBits.VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT; 1816 enum VK_PIPELINE_CREATE_DERIVATIVE_BIT = VkPipelineCreateFlagBits.VK_PIPELINE_CREATE_DERIVATIVE_BIT; 1817 enum VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = VkPipelineCreateFlagBits.VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM; 1818 alias VkPipelineCreateFlags = VkFlags; 1819 alias VkPipelineShaderStageCreateFlags = VkFlags; 1820 1821 enum VkShaderStageFlagBits { 1822 VK_SHADER_STAGE_VERTEX_BIT = 0x00000001, 1823 VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002, 1824 VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004, 1825 VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008, 1826 VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010, 1827 VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020, 1828 VK_SHADER_STAGE_ALL_GRAPHICS = 0x0000001F, 1829 VK_SHADER_STAGE_ALL = 0x7FFFFFFF, 1830 VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1831 } 1832 1833 // VkShaderStageFlagBits global enums 1834 enum VK_SHADER_STAGE_VERTEX_BIT = VkShaderStageFlagBits.VK_SHADER_STAGE_VERTEX_BIT; 1835 enum VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = VkShaderStageFlagBits.VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT; 1836 enum VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = VkShaderStageFlagBits.VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT; 1837 enum VK_SHADER_STAGE_GEOMETRY_BIT = VkShaderStageFlagBits.VK_SHADER_STAGE_GEOMETRY_BIT; 1838 enum VK_SHADER_STAGE_FRAGMENT_BIT = VkShaderStageFlagBits.VK_SHADER_STAGE_FRAGMENT_BIT; 1839 enum VK_SHADER_STAGE_COMPUTE_BIT = VkShaderStageFlagBits.VK_SHADER_STAGE_COMPUTE_BIT; 1840 enum VK_SHADER_STAGE_ALL_GRAPHICS = VkShaderStageFlagBits.VK_SHADER_STAGE_ALL_GRAPHICS; 1841 enum VK_SHADER_STAGE_ALL = VkShaderStageFlagBits.VK_SHADER_STAGE_ALL; 1842 enum VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM = VkShaderStageFlagBits.VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM; 1843 alias VkPipelineVertexInputStateCreateFlags = VkFlags; 1844 alias VkPipelineInputAssemblyStateCreateFlags = VkFlags; 1845 alias VkPipelineTessellationStateCreateFlags = VkFlags; 1846 alias VkPipelineViewportStateCreateFlags = VkFlags; 1847 alias VkPipelineRasterizationStateCreateFlags = VkFlags; 1848 1849 enum VkCullModeFlagBits { 1850 VK_CULL_MODE_NONE = 0, 1851 VK_CULL_MODE_FRONT_BIT = 0x00000001, 1852 VK_CULL_MODE_BACK_BIT = 0x00000002, 1853 VK_CULL_MODE_FRONT_AND_BACK = 0x00000003, 1854 VK_CULL_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1855 } 1856 1857 // VkCullModeFlagBits global enums 1858 enum VK_CULL_MODE_NONE = VkCullModeFlagBits.VK_CULL_MODE_NONE; 1859 enum VK_CULL_MODE_FRONT_BIT = VkCullModeFlagBits.VK_CULL_MODE_FRONT_BIT; 1860 enum VK_CULL_MODE_BACK_BIT = VkCullModeFlagBits.VK_CULL_MODE_BACK_BIT; 1861 enum VK_CULL_MODE_FRONT_AND_BACK = VkCullModeFlagBits.VK_CULL_MODE_FRONT_AND_BACK; 1862 enum VK_CULL_MODE_FLAG_BITS_MAX_ENUM = VkCullModeFlagBits.VK_CULL_MODE_FLAG_BITS_MAX_ENUM; 1863 alias VkCullModeFlags = VkFlags; 1864 alias VkPipelineMultisampleStateCreateFlags = VkFlags; 1865 alias VkPipelineDepthStencilStateCreateFlags = VkFlags; 1866 alias VkPipelineColorBlendStateCreateFlags = VkFlags; 1867 1868 enum VkColorComponentFlagBits { 1869 VK_COLOR_COMPONENT_R_BIT = 0x00000001, 1870 VK_COLOR_COMPONENT_G_BIT = 0x00000002, 1871 VK_COLOR_COMPONENT_B_BIT = 0x00000004, 1872 VK_COLOR_COMPONENT_A_BIT = 0x00000008, 1873 VK_COLOR_COMPONENT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1874 } 1875 1876 // VkColorComponentFlagBits global enums 1877 enum VK_COLOR_COMPONENT_R_BIT = VkColorComponentFlagBits.VK_COLOR_COMPONENT_R_BIT; 1878 enum VK_COLOR_COMPONENT_G_BIT = VkColorComponentFlagBits.VK_COLOR_COMPONENT_G_BIT; 1879 enum VK_COLOR_COMPONENT_B_BIT = VkColorComponentFlagBits.VK_COLOR_COMPONENT_B_BIT; 1880 enum VK_COLOR_COMPONENT_A_BIT = VkColorComponentFlagBits.VK_COLOR_COMPONENT_A_BIT; 1881 enum VK_COLOR_COMPONENT_FLAG_BITS_MAX_ENUM = VkColorComponentFlagBits.VK_COLOR_COMPONENT_FLAG_BITS_MAX_ENUM; 1882 alias VkColorComponentFlags = VkFlags; 1883 alias VkPipelineDynamicStateCreateFlags = VkFlags; 1884 alias VkPipelineLayoutCreateFlags = VkFlags; 1885 alias VkShaderStageFlags = VkFlags; 1886 alias VkSamplerCreateFlags = VkFlags; 1887 alias VkDescriptorSetLayoutCreateFlags = VkFlags; 1888 1889 enum VkDescriptorPoolCreateFlagBits { 1890 VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001, 1891 VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1892 } 1893 1894 // VkDescriptorPoolCreateFlagBits global enums 1895 enum VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = VkDescriptorPoolCreateFlagBits.VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT; 1896 enum VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = VkDescriptorPoolCreateFlagBits.VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM; 1897 alias VkDescriptorPoolCreateFlags = VkFlags; 1898 alias VkDescriptorPoolResetFlags = VkFlags; 1899 alias VkFramebufferCreateFlags = VkFlags; 1900 alias VkRenderPassCreateFlags = VkFlags; 1901 1902 enum VkAttachmentDescriptionFlagBits { 1903 VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001, 1904 VK_ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1905 } 1906 1907 // VkAttachmentDescriptionFlagBits global enums 1908 enum VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = VkAttachmentDescriptionFlagBits.VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT; 1909 enum VK_ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM = VkAttachmentDescriptionFlagBits.VK_ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM; 1910 alias VkAttachmentDescriptionFlags = VkFlags; 1911 alias VkSubpassDescriptionFlags = VkFlags; 1912 1913 enum VkAccessFlagBits { 1914 VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0x00000001, 1915 VK_ACCESS_INDEX_READ_BIT = 0x00000002, 1916 VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004, 1917 VK_ACCESS_UNIFORM_READ_BIT = 0x00000008, 1918 VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 0x00000010, 1919 VK_ACCESS_SHADER_READ_BIT = 0x00000020, 1920 VK_ACCESS_SHADER_WRITE_BIT = 0x00000040, 1921 VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 0x00000080, 1922 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100, 1923 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200, 1924 VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400, 1925 VK_ACCESS_TRANSFER_READ_BIT = 0x00000800, 1926 VK_ACCESS_TRANSFER_WRITE_BIT = 0x00001000, 1927 VK_ACCESS_HOST_READ_BIT = 0x00002000, 1928 VK_ACCESS_HOST_WRITE_BIT = 0x00004000, 1929 VK_ACCESS_MEMORY_READ_BIT = 0x00008000, 1930 VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000, 1931 VK_ACCESS_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1932 } 1933 1934 // VkAccessFlagBits global enums 1935 enum VK_ACCESS_INDIRECT_COMMAND_READ_BIT = VkAccessFlagBits.VK_ACCESS_INDIRECT_COMMAND_READ_BIT; 1936 enum VK_ACCESS_INDEX_READ_BIT = VkAccessFlagBits.VK_ACCESS_INDEX_READ_BIT; 1937 enum VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = VkAccessFlagBits.VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT; 1938 enum VK_ACCESS_UNIFORM_READ_BIT = VkAccessFlagBits.VK_ACCESS_UNIFORM_READ_BIT; 1939 enum VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = VkAccessFlagBits.VK_ACCESS_INPUT_ATTACHMENT_READ_BIT; 1940 enum VK_ACCESS_SHADER_READ_BIT = VkAccessFlagBits.VK_ACCESS_SHADER_READ_BIT; 1941 enum VK_ACCESS_SHADER_WRITE_BIT = VkAccessFlagBits.VK_ACCESS_SHADER_WRITE_BIT; 1942 enum VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = VkAccessFlagBits.VK_ACCESS_COLOR_ATTACHMENT_READ_BIT; 1943 enum VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = VkAccessFlagBits.VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; 1944 enum VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = VkAccessFlagBits.VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT; 1945 enum VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = VkAccessFlagBits.VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT; 1946 enum VK_ACCESS_TRANSFER_READ_BIT = VkAccessFlagBits.VK_ACCESS_TRANSFER_READ_BIT; 1947 enum VK_ACCESS_TRANSFER_WRITE_BIT = VkAccessFlagBits.VK_ACCESS_TRANSFER_WRITE_BIT; 1948 enum VK_ACCESS_HOST_READ_BIT = VkAccessFlagBits.VK_ACCESS_HOST_READ_BIT; 1949 enum VK_ACCESS_HOST_WRITE_BIT = VkAccessFlagBits.VK_ACCESS_HOST_WRITE_BIT; 1950 enum VK_ACCESS_MEMORY_READ_BIT = VkAccessFlagBits.VK_ACCESS_MEMORY_READ_BIT; 1951 enum VK_ACCESS_MEMORY_WRITE_BIT = VkAccessFlagBits.VK_ACCESS_MEMORY_WRITE_BIT; 1952 enum VK_ACCESS_FLAG_BITS_MAX_ENUM = VkAccessFlagBits.VK_ACCESS_FLAG_BITS_MAX_ENUM; 1953 alias VkAccessFlags = VkFlags; 1954 1955 enum VkDependencyFlagBits { 1956 VK_DEPENDENCY_BY_REGION_BIT = 0x00000001, 1957 VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1958 } 1959 1960 // VkDependencyFlagBits global enums 1961 enum VK_DEPENDENCY_BY_REGION_BIT = VkDependencyFlagBits.VK_DEPENDENCY_BY_REGION_BIT; 1962 enum VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = VkDependencyFlagBits.VK_DEPENDENCY_FLAG_BITS_MAX_ENUM; 1963 alias VkDependencyFlags = VkFlags; 1964 1965 enum VkCommandPoolCreateFlagBits { 1966 VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001, 1967 VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002, 1968 VK_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1969 } 1970 1971 // VkCommandPoolCreateFlagBits global enums 1972 enum VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = VkCommandPoolCreateFlagBits.VK_COMMAND_POOL_CREATE_TRANSIENT_BIT; 1973 enum VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = VkCommandPoolCreateFlagBits.VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT; 1974 enum VK_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM = VkCommandPoolCreateFlagBits.VK_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM; 1975 alias VkCommandPoolCreateFlags = VkFlags; 1976 1977 enum VkCommandPoolResetFlagBits { 1978 VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001, 1979 VK_COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1980 } 1981 1982 // VkCommandPoolResetFlagBits global enums 1983 enum VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = VkCommandPoolResetFlagBits.VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT; 1984 enum VK_COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM = VkCommandPoolResetFlagBits.VK_COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM; 1985 alias VkCommandPoolResetFlags = VkFlags; 1986 1987 enum VkCommandBufferUsageFlagBits { 1988 VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001, 1989 VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002, 1990 VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004, 1991 VK_COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 1992 } 1993 1994 // VkCommandBufferUsageFlagBits global enums 1995 enum VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = VkCommandBufferUsageFlagBits.VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT; 1996 enum VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = VkCommandBufferUsageFlagBits.VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT; 1997 enum VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = VkCommandBufferUsageFlagBits.VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT; 1998 enum VK_COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = VkCommandBufferUsageFlagBits.VK_COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM; 1999 alias VkCommandBufferUsageFlags = VkFlags; 2000 2001 enum VkQueryControlFlagBits { 2002 VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001, 2003 VK_QUERY_CONTROL_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 2004 } 2005 2006 // VkQueryControlFlagBits global enums 2007 enum VK_QUERY_CONTROL_PRECISE_BIT = VkQueryControlFlagBits.VK_QUERY_CONTROL_PRECISE_BIT; 2008 enum VK_QUERY_CONTROL_FLAG_BITS_MAX_ENUM = VkQueryControlFlagBits.VK_QUERY_CONTROL_FLAG_BITS_MAX_ENUM; 2009 alias VkQueryControlFlags = VkFlags; 2010 2011 enum VkCommandBufferResetFlagBits { 2012 VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001, 2013 VK_COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 2014 } 2015 2016 // VkCommandBufferResetFlagBits global enums 2017 enum VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = VkCommandBufferResetFlagBits.VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT; 2018 enum VK_COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM = VkCommandBufferResetFlagBits.VK_COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM; 2019 alias VkCommandBufferResetFlags = VkFlags; 2020 2021 enum VkStencilFaceFlagBits { 2022 VK_STENCIL_FACE_FRONT_BIT = 0x00000001, 2023 VK_STENCIL_FACE_BACK_BIT = 0x00000002, 2024 VK_STENCIL_FRONT_AND_BACK = 0x00000003, 2025 VK_STENCIL_FACE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF 2026 } 2027 2028 // VkStencilFaceFlagBits global enums 2029 enum VK_STENCIL_FACE_FRONT_BIT = VkStencilFaceFlagBits.VK_STENCIL_FACE_FRONT_BIT; 2030 enum VK_STENCIL_FACE_BACK_BIT = VkStencilFaceFlagBits.VK_STENCIL_FACE_BACK_BIT; 2031 enum VK_STENCIL_FRONT_AND_BACK = VkStencilFaceFlagBits.VK_STENCIL_FRONT_AND_BACK; 2032 enum VK_STENCIL_FACE_FLAG_BITS_MAX_ENUM = VkStencilFaceFlagBits.VK_STENCIL_FACE_FLAG_BITS_MAX_ENUM; 2033 alias VkStencilFaceFlags = VkFlags; 2034 2035 alias PFN_vkAllocationFunction = void* function( void* pUserData, size_t size, size_t alignment, VkSystemAllocationScope allocationScope); 2036 alias PFN_vkReallocationFunction = void* function( void* pUserData, void* pOriginal, size_t size, size_t alignment, VkSystemAllocationScope allocationScope); 2037 alias PFN_vkFreeFunction = void function( void* pUserData, void* pMemory); 2038 alias PFN_vkInternalAllocationNotification = void function( void* pUserData, size_t size, VkInternalAllocationType allocationType, VkSystemAllocationScope allocationScope); 2039 alias PFN_vkInternalFreeNotification = void function( void* pUserData, size_t size, VkInternalAllocationType allocationType, VkSystemAllocationScope allocationScope); 2040 alias PFN_vkVoidFunction = void function( ); 2041 2042 struct VkApplicationInfo { 2043 VkStructureType sType = VK_STRUCTURE_TYPE_APPLICATION_INFO; 2044 const( void )* pNext; 2045 const( char )* pApplicationName; 2046 uint32_t applicationVersion; 2047 const( char )* pEngineName; 2048 uint32_t engineVersion; 2049 uint32_t apiVersion; 2050 } 2051 2052 struct VkInstanceCreateInfo { 2053 VkStructureType sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; 2054 const( void )* pNext; 2055 VkInstanceCreateFlags flags; 2056 const( VkApplicationInfo )* pApplicationInfo; 2057 uint32_t enabledLayerCount; 2058 const( char* )* ppEnabledLayerNames; 2059 uint32_t enabledExtensionCount; 2060 const( char* )* ppEnabledExtensionNames; 2061 } 2062 2063 struct VkAllocationCallbacks { 2064 void* pUserData; 2065 PFN_vkAllocationFunction pfnAllocation; 2066 PFN_vkReallocationFunction pfnReallocation; 2067 PFN_vkFreeFunction pfnFree; 2068 PFN_vkInternalAllocationNotification pfnInternalAllocation; 2069 PFN_vkInternalFreeNotification pfnInternalFree; 2070 } 2071 2072 struct VkPhysicalDeviceFeatures { 2073 VkBool32 robustBufferAccess; 2074 VkBool32 fullDrawIndexUint32; 2075 VkBool32 imageCubeArray; 2076 VkBool32 independentBlend; 2077 VkBool32 geometryShader; 2078 VkBool32 tessellationShader; 2079 VkBool32 sampleRateShading; 2080 VkBool32 dualSrcBlend; 2081 VkBool32 logicOp; 2082 VkBool32 multiDrawIndirect; 2083 VkBool32 drawIndirectFirstInstance; 2084 VkBool32 depthClamp; 2085 VkBool32 depthBiasClamp; 2086 VkBool32 fillModeNonSolid; 2087 VkBool32 depthBounds; 2088 VkBool32 wideLines; 2089 VkBool32 largePoints; 2090 VkBool32 alphaToOne; 2091 VkBool32 multiViewport; 2092 VkBool32 samplerAnisotropy; 2093 VkBool32 textureCompressionETC2; 2094 VkBool32 textureCompressionASTC_LDR; 2095 VkBool32 textureCompressionBC; 2096 VkBool32 occlusionQueryPrecise; 2097 VkBool32 pipelineStatisticsQuery; 2098 VkBool32 vertexPipelineStoresAndAtomics; 2099 VkBool32 fragmentStoresAndAtomics; 2100 VkBool32 shaderTessellationAndGeometryPointSize; 2101 VkBool32 shaderImageGatherExtended; 2102 VkBool32 shaderStorageImageExtendedFormats; 2103 VkBool32 shaderStorageImageMultisample; 2104 VkBool32 shaderStorageImageReadWithoutFormat; 2105 VkBool32 shaderStorageImageWriteWithoutFormat; 2106 VkBool32 shaderUniformBufferArrayDynamicIndexing; 2107 VkBool32 shaderSampledImageArrayDynamicIndexing; 2108 VkBool32 shaderStorageBufferArrayDynamicIndexing; 2109 VkBool32 shaderStorageImageArrayDynamicIndexing; 2110 VkBool32 shaderClipDistance; 2111 VkBool32 shaderCullDistance; 2112 VkBool32 shaderFloat64; 2113 VkBool32 shaderInt64; 2114 VkBool32 shaderInt16; 2115 VkBool32 shaderResourceResidency; 2116 VkBool32 shaderResourceMinLod; 2117 VkBool32 sparseBinding; 2118 VkBool32 sparseResidencyBuffer; 2119 VkBool32 sparseResidencyImage2D; 2120 VkBool32 sparseResidencyImage3D; 2121 VkBool32 sparseResidency2Samples; 2122 VkBool32 sparseResidency4Samples; 2123 VkBool32 sparseResidency8Samples; 2124 VkBool32 sparseResidency16Samples; 2125 VkBool32 sparseResidencyAliased; 2126 VkBool32 variableMultisampleRate; 2127 VkBool32 inheritedQueries; 2128 } 2129 2130 struct VkFormatProperties { 2131 VkFormatFeatureFlags linearTilingFeatures; 2132 VkFormatFeatureFlags optimalTilingFeatures; 2133 VkFormatFeatureFlags bufferFeatures; 2134 } 2135 2136 struct VkExtent3D { 2137 uint32_t width; 2138 uint32_t height; 2139 uint32_t depth; 2140 } 2141 2142 struct VkImageFormatProperties { 2143 VkExtent3D maxExtent; 2144 uint32_t maxMipLevels; 2145 uint32_t maxArrayLayers; 2146 VkSampleCountFlags sampleCounts; 2147 VkDeviceSize maxResourceSize; 2148 } 2149 2150 struct VkPhysicalDeviceLimits { 2151 uint32_t maxImageDimension1D; 2152 uint32_t maxImageDimension2D; 2153 uint32_t maxImageDimension3D; 2154 uint32_t maxImageDimensionCube; 2155 uint32_t maxImageArrayLayers; 2156 uint32_t maxTexelBufferElements; 2157 uint32_t maxUniformBufferRange; 2158 uint32_t maxStorageBufferRange; 2159 uint32_t maxPushConstantsSize; 2160 uint32_t maxMemoryAllocationCount; 2161 uint32_t maxSamplerAllocationCount; 2162 VkDeviceSize bufferImageGranularity; 2163 VkDeviceSize sparseAddressSpaceSize; 2164 uint32_t maxBoundDescriptorSets; 2165 uint32_t maxPerStageDescriptorSamplers; 2166 uint32_t maxPerStageDescriptorUniformBuffers; 2167 uint32_t maxPerStageDescriptorStorageBuffers; 2168 uint32_t maxPerStageDescriptorSampledImages; 2169 uint32_t maxPerStageDescriptorStorageImages; 2170 uint32_t maxPerStageDescriptorInputAttachments; 2171 uint32_t maxPerStageResources; 2172 uint32_t maxDescriptorSetSamplers; 2173 uint32_t maxDescriptorSetUniformBuffers; 2174 uint32_t maxDescriptorSetUniformBuffersDynamic; 2175 uint32_t maxDescriptorSetStorageBuffers; 2176 uint32_t maxDescriptorSetStorageBuffersDynamic; 2177 uint32_t maxDescriptorSetSampledImages; 2178 uint32_t maxDescriptorSetStorageImages; 2179 uint32_t maxDescriptorSetInputAttachments; 2180 uint32_t maxVertexInputAttributes; 2181 uint32_t maxVertexInputBindings; 2182 uint32_t maxVertexInputAttributeOffset; 2183 uint32_t maxVertexInputBindingStride; 2184 uint32_t maxVertexOutputComponents; 2185 uint32_t maxTessellationGenerationLevel; 2186 uint32_t maxTessellationPatchSize; 2187 uint32_t maxTessellationControlPerVertexInputComponents; 2188 uint32_t maxTessellationControlPerVertexOutputComponents; 2189 uint32_t maxTessellationControlPerPatchOutputComponents; 2190 uint32_t maxTessellationControlTotalOutputComponents; 2191 uint32_t maxTessellationEvaluationInputComponents; 2192 uint32_t maxTessellationEvaluationOutputComponents; 2193 uint32_t maxGeometryShaderInvocations; 2194 uint32_t maxGeometryInputComponents; 2195 uint32_t maxGeometryOutputComponents; 2196 uint32_t maxGeometryOutputVertices; 2197 uint32_t maxGeometryTotalOutputComponents; 2198 uint32_t maxFragmentInputComponents; 2199 uint32_t maxFragmentOutputAttachments; 2200 uint32_t maxFragmentDualSrcAttachments; 2201 uint32_t maxFragmentCombinedOutputResources; 2202 uint32_t maxComputeSharedMemorySize; 2203 uint32_t[3] maxComputeWorkGroupCount; 2204 uint32_t maxComputeWorkGroupInvocations; 2205 uint32_t[3] maxComputeWorkGroupSize; 2206 uint32_t subPixelPrecisionBits; 2207 uint32_t subTexelPrecisionBits; 2208 uint32_t mipmapPrecisionBits; 2209 uint32_t maxDrawIndexedIndexValue; 2210 uint32_t maxDrawIndirectCount; 2211 float maxSamplerLodBias; 2212 float maxSamplerAnisotropy; 2213 uint32_t maxViewports; 2214 uint32_t[2] maxViewportDimensions; 2215 float[2] viewportBoundsRange; 2216 uint32_t viewportSubPixelBits; 2217 size_t minMemoryMapAlignment; 2218 VkDeviceSize minTexelBufferOffsetAlignment; 2219 VkDeviceSize minUniformBufferOffsetAlignment; 2220 VkDeviceSize minStorageBufferOffsetAlignment; 2221 int32_t minTexelOffset; 2222 uint32_t maxTexelOffset; 2223 int32_t minTexelGatherOffset; 2224 uint32_t maxTexelGatherOffset; 2225 float minInterpolationOffset; 2226 float maxInterpolationOffset; 2227 uint32_t subPixelInterpolationOffsetBits; 2228 uint32_t maxFramebufferWidth; 2229 uint32_t maxFramebufferHeight; 2230 uint32_t maxFramebufferLayers; 2231 VkSampleCountFlags framebufferColorSampleCounts; 2232 VkSampleCountFlags framebufferDepthSampleCounts; 2233 VkSampleCountFlags framebufferStencilSampleCounts; 2234 VkSampleCountFlags framebufferNoAttachmentsSampleCounts; 2235 uint32_t maxColorAttachments; 2236 VkSampleCountFlags sampledImageColorSampleCounts; 2237 VkSampleCountFlags sampledImageIntegerSampleCounts; 2238 VkSampleCountFlags sampledImageDepthSampleCounts; 2239 VkSampleCountFlags sampledImageStencilSampleCounts; 2240 VkSampleCountFlags storageImageSampleCounts; 2241 uint32_t maxSampleMaskWords; 2242 VkBool32 timestampComputeAndGraphics; 2243 float timestampPeriod; 2244 uint32_t maxClipDistances; 2245 uint32_t maxCullDistances; 2246 uint32_t maxCombinedClipAndCullDistances; 2247 uint32_t discreteQueuePriorities; 2248 float[2] pointSizeRange; 2249 float[2] lineWidthRange; 2250 float pointSizeGranularity; 2251 float lineWidthGranularity; 2252 VkBool32 strictLines; 2253 VkBool32 standardSampleLocations; 2254 VkDeviceSize optimalBufferCopyOffsetAlignment; 2255 VkDeviceSize optimalBufferCopyRowPitchAlignment; 2256 VkDeviceSize nonCoherentAtomSize; 2257 } 2258 2259 struct VkPhysicalDeviceSparseProperties { 2260 VkBool32 residencyStandard2DBlockShape; 2261 VkBool32 residencyStandard2DMultisampleBlockShape; 2262 VkBool32 residencyStandard3DBlockShape; 2263 VkBool32 residencyAlignedMipSize; 2264 VkBool32 residencyNonResidentStrict; 2265 } 2266 2267 struct VkPhysicalDeviceProperties { 2268 uint32_t apiVersion; 2269 uint32_t driverVersion; 2270 uint32_t vendorID; 2271 uint32_t deviceID; 2272 VkPhysicalDeviceType deviceType; 2273 char[ VK_MAX_PHYSICAL_DEVICE_NAME_SIZE ] deviceName; 2274 uint8_t[ VK_UUID_SIZE ] pipelineCacheUUID; 2275 VkPhysicalDeviceLimits limits; 2276 VkPhysicalDeviceSparseProperties sparseProperties; 2277 } 2278 2279 struct VkQueueFamilyProperties { 2280 VkQueueFlags queueFlags; 2281 uint32_t queueCount; 2282 uint32_t timestampValidBits; 2283 VkExtent3D minImageTransferGranularity; 2284 } 2285 2286 struct VkMemoryType { 2287 VkMemoryPropertyFlags propertyFlags; 2288 uint32_t heapIndex; 2289 } 2290 2291 struct VkMemoryHeap { 2292 VkDeviceSize size; 2293 VkMemoryHeapFlags flags; 2294 } 2295 2296 struct VkPhysicalDeviceMemoryProperties { 2297 uint32_t memoryTypeCount; 2298 VkMemoryType[ VK_MAX_MEMORY_TYPES ] memoryTypes; 2299 uint32_t memoryHeapCount; 2300 VkMemoryHeap[ VK_MAX_MEMORY_HEAPS ] memoryHeaps; 2301 } 2302 2303 struct VkDeviceQueueCreateInfo { 2304 VkStructureType sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO; 2305 const( void )* pNext; 2306 VkDeviceQueueCreateFlags flags; 2307 uint32_t queueFamilyIndex; 2308 uint32_t queueCount; 2309 const( float )* pQueuePriorities; 2310 } 2311 2312 struct VkDeviceCreateInfo { 2313 VkStructureType sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO; 2314 const( void )* pNext; 2315 VkDeviceCreateFlags flags; 2316 uint32_t queueCreateInfoCount; 2317 const( VkDeviceQueueCreateInfo )* pQueueCreateInfos; 2318 uint32_t enabledLayerCount; 2319 const( char* )* ppEnabledLayerNames; 2320 uint32_t enabledExtensionCount; 2321 const( char* )* ppEnabledExtensionNames; 2322 const( VkPhysicalDeviceFeatures )* pEnabledFeatures; 2323 } 2324 2325 struct VkExtensionProperties { 2326 char[ VK_MAX_EXTENSION_NAME_SIZE ] extensionName; 2327 uint32_t specVersion; 2328 } 2329 2330 struct VkLayerProperties { 2331 char[ VK_MAX_EXTENSION_NAME_SIZE ] layerName; 2332 uint32_t specVersion; 2333 uint32_t implementationVersion; 2334 char[ VK_MAX_DESCRIPTION_SIZE ] description; 2335 } 2336 2337 struct VkSubmitInfo { 2338 VkStructureType sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; 2339 const( void )* pNext; 2340 uint32_t waitSemaphoreCount; 2341 const( VkSemaphore )* pWaitSemaphores; 2342 const( VkPipelineStageFlags )* pWaitDstStageMask; 2343 uint32_t commandBufferCount; 2344 const( VkCommandBuffer )* pCommandBuffers; 2345 uint32_t signalSemaphoreCount; 2346 const( VkSemaphore )* pSignalSemaphores; 2347 } 2348 2349 struct VkMemoryAllocateInfo { 2350 VkStructureType sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; 2351 const( void )* pNext; 2352 VkDeviceSize allocationSize; 2353 uint32_t memoryTypeIndex; 2354 } 2355 2356 struct VkMappedMemoryRange { 2357 VkStructureType sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE; 2358 const( void )* pNext; 2359 VkDeviceMemory memory; 2360 VkDeviceSize offset; 2361 VkDeviceSize size; 2362 } 2363 2364 struct VkMemoryRequirements { 2365 VkDeviceSize size; 2366 VkDeviceSize alignment; 2367 uint32_t memoryTypeBits; 2368 } 2369 2370 struct VkSparseImageFormatProperties { 2371 VkImageAspectFlags aspectMask; 2372 VkExtent3D imageGranularity; 2373 VkSparseImageFormatFlags flags; 2374 } 2375 2376 struct VkSparseImageMemoryRequirements { 2377 VkSparseImageFormatProperties formatProperties; 2378 uint32_t imageMipTailFirstLod; 2379 VkDeviceSize imageMipTailSize; 2380 VkDeviceSize imageMipTailOffset; 2381 VkDeviceSize imageMipTailStride; 2382 } 2383 2384 struct VkSparseMemoryBind { 2385 VkDeviceSize resourceOffset; 2386 VkDeviceSize size; 2387 VkDeviceMemory memory; 2388 VkDeviceSize memoryOffset; 2389 VkSparseMemoryBindFlags flags; 2390 } 2391 2392 struct VkSparseBufferMemoryBindInfo { 2393 VkBuffer buffer; 2394 uint32_t bindCount; 2395 const( VkSparseMemoryBind )* pBinds; 2396 } 2397 2398 struct VkSparseImageOpaqueMemoryBindInfo { 2399 VkImage image; 2400 uint32_t bindCount; 2401 const( VkSparseMemoryBind )* pBinds; 2402 } 2403 2404 struct VkImageSubresource { 2405 VkImageAspectFlags aspectMask; 2406 uint32_t mipLevel; 2407 uint32_t arrayLayer; 2408 } 2409 2410 struct VkOffset3D { 2411 int32_t x; 2412 int32_t y; 2413 int32_t z; 2414 } 2415 2416 struct VkSparseImageMemoryBind { 2417 VkImageSubresource subresource; 2418 VkOffset3D offset; 2419 VkExtent3D extent; 2420 VkDeviceMemory memory; 2421 VkDeviceSize memoryOffset; 2422 VkSparseMemoryBindFlags flags; 2423 } 2424 2425 struct VkSparseImageMemoryBindInfo { 2426 VkImage image; 2427 uint32_t bindCount; 2428 const( VkSparseImageMemoryBind )* pBinds; 2429 } 2430 2431 struct VkBindSparseInfo { 2432 VkStructureType sType = VK_STRUCTURE_TYPE_BIND_SPARSE_INFO; 2433 const( void )* pNext; 2434 uint32_t waitSemaphoreCount; 2435 const( VkSemaphore )* pWaitSemaphores; 2436 uint32_t bufferBindCount; 2437 const( VkSparseBufferMemoryBindInfo )* pBufferBinds; 2438 uint32_t imageOpaqueBindCount; 2439 const( VkSparseImageOpaqueMemoryBindInfo )* pImageOpaqueBinds; 2440 uint32_t imageBindCount; 2441 const( VkSparseImageMemoryBindInfo )* pImageBinds; 2442 uint32_t signalSemaphoreCount; 2443 const( VkSemaphore )* pSignalSemaphores; 2444 } 2445 2446 struct VkFenceCreateInfo { 2447 VkStructureType sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO; 2448 const( void )* pNext; 2449 VkFenceCreateFlags flags; 2450 } 2451 2452 struct VkSemaphoreCreateInfo { 2453 VkStructureType sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO; 2454 const( void )* pNext; 2455 VkSemaphoreCreateFlags flags; 2456 } 2457 2458 struct VkEventCreateInfo { 2459 VkStructureType sType = VK_STRUCTURE_TYPE_EVENT_CREATE_INFO; 2460 const( void )* pNext; 2461 VkEventCreateFlags flags; 2462 } 2463 2464 struct VkQueryPoolCreateInfo { 2465 VkStructureType sType = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO; 2466 const( void )* pNext; 2467 VkQueryPoolCreateFlags flags; 2468 VkQueryType queryType; 2469 uint32_t queryCount; 2470 VkQueryPipelineStatisticFlags pipelineStatistics; 2471 } 2472 2473 struct VkBufferCreateInfo { 2474 VkStructureType sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO; 2475 const( void )* pNext; 2476 VkBufferCreateFlags flags; 2477 VkDeviceSize size; 2478 VkBufferUsageFlags usage; 2479 VkSharingMode sharingMode; 2480 uint32_t queueFamilyIndexCount; 2481 const( uint32_t )* pQueueFamilyIndices; 2482 } 2483 2484 struct VkBufferViewCreateInfo { 2485 VkStructureType sType = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO; 2486 const( void )* pNext; 2487 VkBufferViewCreateFlags flags; 2488 VkBuffer buffer; 2489 VkFormat format; 2490 VkDeviceSize offset; 2491 VkDeviceSize range; 2492 } 2493 2494 struct VkImageCreateInfo { 2495 VkStructureType sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; 2496 const( void )* pNext; 2497 VkImageCreateFlags flags; 2498 VkImageType imageType; 2499 VkFormat format; 2500 VkExtent3D extent; 2501 uint32_t mipLevels; 2502 uint32_t arrayLayers; 2503 VkSampleCountFlagBits samples; 2504 VkImageTiling tiling; 2505 VkImageUsageFlags usage; 2506 VkSharingMode sharingMode; 2507 uint32_t queueFamilyIndexCount; 2508 const( uint32_t )* pQueueFamilyIndices; 2509 VkImageLayout initialLayout; 2510 } 2511 2512 struct VkSubresourceLayout { 2513 VkDeviceSize offset; 2514 VkDeviceSize size; 2515 VkDeviceSize rowPitch; 2516 VkDeviceSize arrayPitch; 2517 VkDeviceSize depthPitch; 2518 } 2519 2520 struct VkComponentMapping { 2521 VkComponentSwizzle r; 2522 VkComponentSwizzle g; 2523 VkComponentSwizzle b; 2524 VkComponentSwizzle a; 2525 } 2526 2527 struct VkImageSubresourceRange { 2528 VkImageAspectFlags aspectMask; 2529 uint32_t baseMipLevel; 2530 uint32_t levelCount; 2531 uint32_t baseArrayLayer; 2532 uint32_t layerCount; 2533 } 2534 2535 struct VkImageViewCreateInfo { 2536 VkStructureType sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO; 2537 const( void )* pNext; 2538 VkImageViewCreateFlags flags; 2539 VkImage image; 2540 VkImageViewType viewType; 2541 VkFormat format; 2542 VkComponentMapping components; 2543 VkImageSubresourceRange subresourceRange; 2544 } 2545 2546 struct VkShaderModuleCreateInfo { 2547 VkStructureType sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO; 2548 const( void )* pNext; 2549 VkShaderModuleCreateFlags flags; 2550 size_t codeSize; 2551 const( uint32_t )* pCode; 2552 } 2553 2554 struct VkPipelineCacheCreateInfo { 2555 VkStructureType sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO; 2556 const( void )* pNext; 2557 VkPipelineCacheCreateFlags flags; 2558 size_t initialDataSize; 2559 const( void )* pInitialData; 2560 } 2561 2562 struct VkSpecializationMapEntry { 2563 uint32_t constantID; 2564 uint32_t offset; 2565 size_t size; 2566 } 2567 2568 struct VkSpecializationInfo { 2569 uint32_t mapEntryCount; 2570 const( VkSpecializationMapEntry )* pMapEntries; 2571 size_t dataSize; 2572 const( void )* pData; 2573 } 2574 2575 struct VkPipelineShaderStageCreateInfo { 2576 VkStructureType sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; 2577 const( void )* pNext; 2578 VkPipelineShaderStageCreateFlags flags; 2579 VkShaderStageFlagBits stage; 2580 VkShaderModule _module; 2581 const( char )* pName; 2582 const( VkSpecializationInfo )* pSpecializationInfo; 2583 } 2584 2585 struct VkVertexInputBindingDescription { 2586 uint32_t binding; 2587 uint32_t stride; 2588 VkVertexInputRate inputRate; 2589 } 2590 2591 struct VkVertexInputAttributeDescription { 2592 uint32_t location; 2593 uint32_t binding; 2594 VkFormat format; 2595 uint32_t offset; 2596 } 2597 2598 struct VkPipelineVertexInputStateCreateInfo { 2599 VkStructureType sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; 2600 const( void )* pNext; 2601 VkPipelineVertexInputStateCreateFlags flags; 2602 uint32_t vertexBindingDescriptionCount; 2603 const( VkVertexInputBindingDescription )* pVertexBindingDescriptions; 2604 uint32_t vertexAttributeDescriptionCount; 2605 const( VkVertexInputAttributeDescription )* pVertexAttributeDescriptions; 2606 } 2607 2608 struct VkPipelineInputAssemblyStateCreateInfo { 2609 VkStructureType sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; 2610 const( void )* pNext; 2611 VkPipelineInputAssemblyStateCreateFlags flags; 2612 VkPrimitiveTopology topology; 2613 VkBool32 primitiveRestartEnable; 2614 } 2615 2616 struct VkPipelineTessellationStateCreateInfo { 2617 VkStructureType sType = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO; 2618 const( void )* pNext; 2619 VkPipelineTessellationStateCreateFlags flags; 2620 uint32_t patchControlPoints; 2621 } 2622 2623 struct VkViewport { 2624 float x; 2625 float y; 2626 float width; 2627 float height; 2628 float minDepth; 2629 float maxDepth; 2630 } 2631 2632 struct VkOffset2D { 2633 int32_t x; 2634 int32_t y; 2635 } 2636 2637 struct VkExtent2D { 2638 uint32_t width; 2639 uint32_t height; 2640 } 2641 2642 struct VkRect2D { 2643 VkOffset2D offset; 2644 VkExtent2D extent; 2645 } 2646 2647 struct VkPipelineViewportStateCreateInfo { 2648 VkStructureType sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; 2649 const( void )* pNext; 2650 VkPipelineViewportStateCreateFlags flags; 2651 uint32_t viewportCount; 2652 const( VkViewport )* pViewports; 2653 uint32_t scissorCount; 2654 const( VkRect2D )* pScissors; 2655 } 2656 2657 struct VkPipelineRasterizationStateCreateInfo { 2658 VkStructureType sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; 2659 const( void )* pNext; 2660 VkPipelineRasterizationStateCreateFlags flags; 2661 VkBool32 depthClampEnable; 2662 VkBool32 rasterizerDiscardEnable; 2663 VkPolygonMode polygonMode; 2664 VkCullModeFlags cullMode; 2665 VkFrontFace frontFace; 2666 VkBool32 depthBiasEnable; 2667 float depthBiasConstantFactor; 2668 float depthBiasClamp; 2669 float depthBiasSlopeFactor; 2670 float lineWidth; 2671 } 2672 2673 struct VkPipelineMultisampleStateCreateInfo { 2674 VkStructureType sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; 2675 const( void )* pNext; 2676 VkPipelineMultisampleStateCreateFlags flags; 2677 VkSampleCountFlagBits rasterizationSamples; 2678 VkBool32 sampleShadingEnable; 2679 float minSampleShading; 2680 const( VkSampleMask )* pSampleMask; 2681 VkBool32 alphaToCoverageEnable; 2682 VkBool32 alphaToOneEnable; 2683 } 2684 2685 struct VkStencilOpState { 2686 VkStencilOp failOp; 2687 VkStencilOp passOp; 2688 VkStencilOp depthFailOp; 2689 VkCompareOp compareOp; 2690 uint32_t compareMask; 2691 uint32_t writeMask; 2692 uint32_t reference; 2693 } 2694 2695 struct VkPipelineDepthStencilStateCreateInfo { 2696 VkStructureType sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; 2697 const( void )* pNext; 2698 VkPipelineDepthStencilStateCreateFlags flags; 2699 VkBool32 depthTestEnable; 2700 VkBool32 depthWriteEnable; 2701 VkCompareOp depthCompareOp; 2702 VkBool32 depthBoundsTestEnable; 2703 VkBool32 stencilTestEnable; 2704 VkStencilOpState front; 2705 VkStencilOpState back; 2706 float minDepthBounds; 2707 float maxDepthBounds; 2708 } 2709 2710 struct VkPipelineColorBlendAttachmentState { 2711 VkBool32 blendEnable; 2712 VkBlendFactor srcColorBlendFactor; 2713 VkBlendFactor dstColorBlendFactor; 2714 VkBlendOp colorBlendOp; 2715 VkBlendFactor srcAlphaBlendFactor; 2716 VkBlendFactor dstAlphaBlendFactor; 2717 VkBlendOp alphaBlendOp; 2718 VkColorComponentFlags colorWriteMask; 2719 } 2720 2721 struct VkPipelineColorBlendStateCreateInfo { 2722 VkStructureType sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; 2723 const( void )* pNext; 2724 VkPipelineColorBlendStateCreateFlags flags; 2725 VkBool32 logicOpEnable; 2726 VkLogicOp logicOp; 2727 uint32_t attachmentCount; 2728 const( VkPipelineColorBlendAttachmentState )* pAttachments; 2729 float[4] blendConstants; 2730 } 2731 2732 struct VkPipelineDynamicStateCreateInfo { 2733 VkStructureType sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; 2734 const( void )* pNext; 2735 VkPipelineDynamicStateCreateFlags flags; 2736 uint32_t dynamicStateCount; 2737 const( VkDynamicState )* pDynamicStates; 2738 } 2739 2740 struct VkGraphicsPipelineCreateInfo { 2741 VkStructureType sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; 2742 const( void )* pNext; 2743 VkPipelineCreateFlags flags; 2744 uint32_t stageCount; 2745 const( VkPipelineShaderStageCreateInfo )* pStages; 2746 const( VkPipelineVertexInputStateCreateInfo )* pVertexInputState; 2747 const( VkPipelineInputAssemblyStateCreateInfo )* pInputAssemblyState; 2748 const( VkPipelineTessellationStateCreateInfo )* pTessellationState; 2749 const( VkPipelineViewportStateCreateInfo )* pViewportState; 2750 const( VkPipelineRasterizationStateCreateInfo )* pRasterizationState; 2751 const( VkPipelineMultisampleStateCreateInfo )* pMultisampleState; 2752 const( VkPipelineDepthStencilStateCreateInfo )* pDepthStencilState; 2753 const( VkPipelineColorBlendStateCreateInfo )* pColorBlendState; 2754 const( VkPipelineDynamicStateCreateInfo )* pDynamicState; 2755 VkPipelineLayout layout; 2756 VkRenderPass renderPass; 2757 uint32_t subpass; 2758 VkPipeline basePipelineHandle; 2759 int32_t basePipelineIndex; 2760 } 2761 2762 struct VkComputePipelineCreateInfo { 2763 VkStructureType sType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO; 2764 const( void )* pNext; 2765 VkPipelineCreateFlags flags; 2766 VkPipelineShaderStageCreateInfo stage; 2767 VkPipelineLayout layout; 2768 VkPipeline basePipelineHandle; 2769 int32_t basePipelineIndex; 2770 } 2771 2772 struct VkPushConstantRange { 2773 VkShaderStageFlags stageFlags; 2774 uint32_t offset; 2775 uint32_t size; 2776 } 2777 2778 struct VkPipelineLayoutCreateInfo { 2779 VkStructureType sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; 2780 const( void )* pNext; 2781 VkPipelineLayoutCreateFlags flags; 2782 uint32_t setLayoutCount; 2783 const( VkDescriptorSetLayout )* pSetLayouts; 2784 uint32_t pushConstantRangeCount; 2785 const( VkPushConstantRange )* pPushConstantRanges; 2786 } 2787 2788 struct VkSamplerCreateInfo { 2789 VkStructureType sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO; 2790 const( void )* pNext; 2791 VkSamplerCreateFlags flags; 2792 VkFilter magFilter; 2793 VkFilter minFilter; 2794 VkSamplerMipmapMode mipmapMode; 2795 VkSamplerAddressMode addressModeU; 2796 VkSamplerAddressMode addressModeV; 2797 VkSamplerAddressMode addressModeW; 2798 float mipLodBias; 2799 VkBool32 anisotropyEnable; 2800 float maxAnisotropy; 2801 VkBool32 compareEnable; 2802 VkCompareOp compareOp; 2803 float minLod; 2804 float maxLod; 2805 VkBorderColor borderColor; 2806 VkBool32 unnormalizedCoordinates; 2807 } 2808 2809 struct VkDescriptorSetLayoutBinding { 2810 uint32_t binding; 2811 VkDescriptorType descriptorType; 2812 uint32_t descriptorCount; 2813 VkShaderStageFlags stageFlags; 2814 const( VkSampler )* pImmutableSamplers; 2815 } 2816 2817 struct VkDescriptorSetLayoutCreateInfo { 2818 VkStructureType sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; 2819 const( void )* pNext; 2820 VkDescriptorSetLayoutCreateFlags flags; 2821 uint32_t bindingCount; 2822 const( VkDescriptorSetLayoutBinding )* pBindings; 2823 } 2824 2825 struct VkDescriptorPoolSize { 2826 VkDescriptorType type; 2827 uint32_t descriptorCount; 2828 } 2829 2830 struct VkDescriptorPoolCreateInfo { 2831 VkStructureType sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO; 2832 const( void )* pNext; 2833 VkDescriptorPoolCreateFlags flags; 2834 uint32_t maxSets; 2835 uint32_t poolSizeCount; 2836 const( VkDescriptorPoolSize )* pPoolSizes; 2837 } 2838 2839 struct VkDescriptorSetAllocateInfo { 2840 VkStructureType sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; 2841 const( void )* pNext; 2842 VkDescriptorPool descriptorPool; 2843 uint32_t descriptorSetCount; 2844 const( VkDescriptorSetLayout )* pSetLayouts; 2845 } 2846 2847 struct VkDescriptorImageInfo { 2848 VkSampler sampler; 2849 VkImageView imageView; 2850 VkImageLayout imageLayout; 2851 } 2852 2853 struct VkDescriptorBufferInfo { 2854 VkBuffer buffer; 2855 VkDeviceSize offset; 2856 VkDeviceSize range; 2857 } 2858 2859 struct VkWriteDescriptorSet { 2860 VkStructureType sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; 2861 const( void )* pNext; 2862 VkDescriptorSet dstSet; 2863 uint32_t dstBinding; 2864 uint32_t dstArrayElement; 2865 uint32_t descriptorCount; 2866 VkDescriptorType descriptorType; 2867 const( VkDescriptorImageInfo )* pImageInfo; 2868 const( VkDescriptorBufferInfo )* pBufferInfo; 2869 const( VkBufferView )* pTexelBufferView; 2870 } 2871 2872 struct VkCopyDescriptorSet { 2873 VkStructureType sType = VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET; 2874 const( void )* pNext; 2875 VkDescriptorSet srcSet; 2876 uint32_t srcBinding; 2877 uint32_t srcArrayElement; 2878 VkDescriptorSet dstSet; 2879 uint32_t dstBinding; 2880 uint32_t dstArrayElement; 2881 uint32_t descriptorCount; 2882 } 2883 2884 struct VkFramebufferCreateInfo { 2885 VkStructureType sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO; 2886 const( void )* pNext; 2887 VkFramebufferCreateFlags flags; 2888 VkRenderPass renderPass; 2889 uint32_t attachmentCount; 2890 const( VkImageView )* pAttachments; 2891 uint32_t width; 2892 uint32_t height; 2893 uint32_t layers; 2894 } 2895 2896 struct VkAttachmentDescription { 2897 VkAttachmentDescriptionFlags flags; 2898 VkFormat format; 2899 VkSampleCountFlagBits samples; 2900 VkAttachmentLoadOp loadOp; 2901 VkAttachmentStoreOp storeOp; 2902 VkAttachmentLoadOp stencilLoadOp; 2903 VkAttachmentStoreOp stencilStoreOp; 2904 VkImageLayout initialLayout; 2905 VkImageLayout finalLayout; 2906 } 2907 2908 struct VkAttachmentReference { 2909 uint32_t attachment; 2910 VkImageLayout layout; 2911 } 2912 2913 struct VkSubpassDescription { 2914 VkSubpassDescriptionFlags flags; 2915 VkPipelineBindPoint pipelineBindPoint; 2916 uint32_t inputAttachmentCount; 2917 const( VkAttachmentReference )* pInputAttachments; 2918 uint32_t colorAttachmentCount; 2919 const( VkAttachmentReference )* pColorAttachments; 2920 const( VkAttachmentReference )* pResolveAttachments; 2921 const( VkAttachmentReference )* pDepthStencilAttachment; 2922 uint32_t preserveAttachmentCount; 2923 const( uint32_t )* pPreserveAttachments; 2924 } 2925 2926 struct VkSubpassDependency { 2927 uint32_t srcSubpass; 2928 uint32_t dstSubpass; 2929 VkPipelineStageFlags srcStageMask; 2930 VkPipelineStageFlags dstStageMask; 2931 VkAccessFlags srcAccessMask; 2932 VkAccessFlags dstAccessMask; 2933 VkDependencyFlags dependencyFlags; 2934 } 2935 2936 struct VkRenderPassCreateInfo { 2937 VkStructureType sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO; 2938 const( void )* pNext; 2939 VkRenderPassCreateFlags flags; 2940 uint32_t attachmentCount; 2941 const( VkAttachmentDescription )* pAttachments; 2942 uint32_t subpassCount; 2943 const( VkSubpassDescription )* pSubpasses; 2944 uint32_t dependencyCount; 2945 const( VkSubpassDependency )* pDependencies; 2946 } 2947 2948 struct VkCommandPoolCreateInfo { 2949 VkStructureType sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO; 2950 const( void )* pNext; 2951 VkCommandPoolCreateFlags flags; 2952 uint32_t queueFamilyIndex; 2953 } 2954 2955 struct VkCommandBufferAllocateInfo { 2956 VkStructureType sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; 2957 const( void )* pNext; 2958 VkCommandPool commandPool; 2959 VkCommandBufferLevel level; 2960 uint32_t commandBufferCount; 2961 } 2962 2963 struct VkCommandBufferInheritanceInfo { 2964 VkStructureType sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO; 2965 const( void )* pNext; 2966 VkRenderPass renderPass; 2967 uint32_t subpass; 2968 VkFramebuffer framebuffer; 2969 VkBool32 occlusionQueryEnable; 2970 VkQueryControlFlags queryFlags; 2971 VkQueryPipelineStatisticFlags pipelineStatistics; 2972 } 2973 2974 struct VkCommandBufferBeginInfo { 2975 VkStructureType sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; 2976 const( void )* pNext; 2977 VkCommandBufferUsageFlags flags; 2978 const( VkCommandBufferInheritanceInfo )* pInheritanceInfo; 2979 } 2980 2981 struct VkBufferCopy { 2982 VkDeviceSize srcOffset; 2983 VkDeviceSize dstOffset; 2984 VkDeviceSize size; 2985 } 2986 2987 struct VkImageSubresourceLayers { 2988 VkImageAspectFlags aspectMask; 2989 uint32_t mipLevel; 2990 uint32_t baseArrayLayer; 2991 uint32_t layerCount; 2992 } 2993 2994 struct VkImageCopy { 2995 VkImageSubresourceLayers srcSubresource; 2996 VkOffset3D srcOffset; 2997 VkImageSubresourceLayers dstSubresource; 2998 VkOffset3D dstOffset; 2999 VkExtent3D extent; 3000 } 3001 3002 struct VkImageBlit { 3003 VkImageSubresourceLayers srcSubresource; 3004 VkOffset3D[2] srcOffsets; 3005 VkImageSubresourceLayers dstSubresource; 3006 VkOffset3D[2] dstOffsets; 3007 } 3008 3009 struct VkBufferImageCopy { 3010 VkDeviceSize bufferOffset; 3011 uint32_t bufferRowLength; 3012 uint32_t bufferImageHeight; 3013 VkImageSubresourceLayers imageSubresource; 3014 VkOffset3D imageOffset; 3015 VkExtent3D imageExtent; 3016 } 3017 3018 union VkClearColorValue { 3019 float[4] float32; 3020 int32_t[4] int32; 3021 uint32_t[4] uint32; 3022 } 3023 3024 struct VkClearDepthStencilValue { 3025 float depth; 3026 uint32_t stencil; 3027 } 3028 3029 union VkClearValue { 3030 VkClearColorValue color; 3031 VkClearDepthStencilValue depthStencil; 3032 } 3033 3034 struct VkClearAttachment { 3035 VkImageAspectFlags aspectMask; 3036 uint32_t colorAttachment; 3037 VkClearValue clearValue; 3038 } 3039 3040 struct VkClearRect { 3041 VkRect2D rect; 3042 uint32_t baseArrayLayer; 3043 uint32_t layerCount; 3044 } 3045 3046 struct VkImageResolve { 3047 VkImageSubresourceLayers srcSubresource; 3048 VkOffset3D srcOffset; 3049 VkImageSubresourceLayers dstSubresource; 3050 VkOffset3D dstOffset; 3051 VkExtent3D extent; 3052 } 3053 3054 struct VkMemoryBarrier { 3055 VkStructureType sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER; 3056 const( void )* pNext; 3057 VkAccessFlags srcAccessMask; 3058 VkAccessFlags dstAccessMask; 3059 } 3060 3061 struct VkBufferMemoryBarrier { 3062 VkStructureType sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER; 3063 const( void )* pNext; 3064 VkAccessFlags srcAccessMask; 3065 VkAccessFlags dstAccessMask; 3066 uint32_t srcQueueFamilyIndex; 3067 uint32_t dstQueueFamilyIndex; 3068 VkBuffer buffer; 3069 VkDeviceSize offset; 3070 VkDeviceSize size; 3071 } 3072 3073 struct VkImageMemoryBarrier { 3074 VkStructureType sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; 3075 const( void )* pNext; 3076 VkAccessFlags srcAccessMask; 3077 VkAccessFlags dstAccessMask; 3078 VkImageLayout oldLayout; 3079 VkImageLayout newLayout; 3080 uint32_t srcQueueFamilyIndex; 3081 uint32_t dstQueueFamilyIndex; 3082 VkImage image; 3083 VkImageSubresourceRange subresourceRange; 3084 } 3085 3086 struct VkRenderPassBeginInfo { 3087 VkStructureType sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO; 3088 const( void )* pNext; 3089 VkRenderPass renderPass; 3090 VkFramebuffer framebuffer; 3091 VkRect2D renderArea; 3092 uint32_t clearValueCount; 3093 const( VkClearValue )* pClearValues; 3094 } 3095 3096 struct VkDispatchIndirectCommand { 3097 uint32_t x; 3098 uint32_t y; 3099 uint32_t z; 3100 } 3101 3102 struct VkDrawIndexedIndirectCommand { 3103 uint32_t indexCount; 3104 uint32_t instanceCount; 3105 uint32_t firstIndex; 3106 int32_t vertexOffset; 3107 uint32_t firstInstance; 3108 } 3109 3110 struct VkDrawIndirectCommand { 3111 uint32_t vertexCount; 3112 uint32_t instanceCount; 3113 uint32_t firstVertex; 3114 uint32_t firstInstance; 3115 } 3116 3117 // VK_KHR_surface 3118 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkSurfaceKHR} ); 3119 3120 enum VK_KHR_SURFACE_SPEC_VERSION = 25; 3121 enum VK_KHR_SURFACE_EXTENSION_NAME = "VK_KHR_surface"; 3122 enum VK_COLORSPACE_SRGB_NONLINEAR_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR; 3123 3124 3125 enum VkColorSpaceKHR { 3126 VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = 0, 3127 VK_COLOR_SPACE_BEGIN_RANGE_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, 3128 VK_COLOR_SPACE_END_RANGE_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, 3129 VK_COLOR_SPACE_RANGE_SIZE_KHR = ( VK_COLOR_SPACE_SRGB_NONLINEAR_KHR - VK_COLOR_SPACE_SRGB_NONLINEAR_KHR + 1 ), 3130 VK_COLOR_SPACE_MAX_ENUM_KHR = 0x7FFFFFFF 3131 } 3132 3133 // VkColorSpaceKHR global enums 3134 enum VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = VkColorSpaceKHR.VK_COLOR_SPACE_SRGB_NONLINEAR_KHR; 3135 enum VK_COLOR_SPACE_BEGIN_RANGE_KHR = VkColorSpaceKHR.VK_COLOR_SPACE_BEGIN_RANGE_KHR; 3136 enum VK_COLOR_SPACE_END_RANGE_KHR = VkColorSpaceKHR.VK_COLOR_SPACE_END_RANGE_KHR; 3137 enum VK_COLOR_SPACE_RANGE_SIZE_KHR = VkColorSpaceKHR.VK_COLOR_SPACE_RANGE_SIZE_KHR; 3138 enum VK_COLOR_SPACE_MAX_ENUM_KHR = VkColorSpaceKHR.VK_COLOR_SPACE_MAX_ENUM_KHR; 3139 3140 enum VkPresentModeKHR { 3141 VK_PRESENT_MODE_IMMEDIATE_KHR = 0, 3142 VK_PRESENT_MODE_MAILBOX_KHR = 1, 3143 VK_PRESENT_MODE_FIFO_KHR = 2, 3144 VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3, 3145 VK_PRESENT_MODE_BEGIN_RANGE_KHR = VK_PRESENT_MODE_IMMEDIATE_KHR, 3146 VK_PRESENT_MODE_END_RANGE_KHR = VK_PRESENT_MODE_FIFO_RELAXED_KHR, 3147 VK_PRESENT_MODE_RANGE_SIZE_KHR = ( VK_PRESENT_MODE_FIFO_RELAXED_KHR - VK_PRESENT_MODE_IMMEDIATE_KHR + 1 ), 3148 VK_PRESENT_MODE_MAX_ENUM_KHR = 0x7FFFFFFF 3149 } 3150 3151 // VkPresentModeKHR global enums 3152 enum VK_PRESENT_MODE_IMMEDIATE_KHR = VkPresentModeKHR.VK_PRESENT_MODE_IMMEDIATE_KHR; 3153 enum VK_PRESENT_MODE_MAILBOX_KHR = VkPresentModeKHR.VK_PRESENT_MODE_MAILBOX_KHR; 3154 enum VK_PRESENT_MODE_FIFO_KHR = VkPresentModeKHR.VK_PRESENT_MODE_FIFO_KHR; 3155 enum VK_PRESENT_MODE_FIFO_RELAXED_KHR = VkPresentModeKHR.VK_PRESENT_MODE_FIFO_RELAXED_KHR; 3156 enum VK_PRESENT_MODE_BEGIN_RANGE_KHR = VkPresentModeKHR.VK_PRESENT_MODE_BEGIN_RANGE_KHR; 3157 enum VK_PRESENT_MODE_END_RANGE_KHR = VkPresentModeKHR.VK_PRESENT_MODE_END_RANGE_KHR; 3158 enum VK_PRESENT_MODE_RANGE_SIZE_KHR = VkPresentModeKHR.VK_PRESENT_MODE_RANGE_SIZE_KHR; 3159 enum VK_PRESENT_MODE_MAX_ENUM_KHR = VkPresentModeKHR.VK_PRESENT_MODE_MAX_ENUM_KHR; 3160 3161 3162 enum VkSurfaceTransformFlagBitsKHR { 3163 VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 0x00000001, 3164 VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 0x00000002, 3165 VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 0x00000004, 3166 VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 0x00000008, 3167 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 0x00000010, 3168 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 0x00000020, 3169 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 0x00000040, 3170 VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 0x00000080, 3171 VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100, 3172 VK_SURFACE_TRANSFORM_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 3173 } 3174 3175 // VkSurfaceTransformFlagBitsKHR global enums 3176 enum VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = VkSurfaceTransformFlagBitsKHR.VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR; 3177 enum VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = VkSurfaceTransformFlagBitsKHR.VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR; 3178 enum VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = VkSurfaceTransformFlagBitsKHR.VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR; 3179 enum VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = VkSurfaceTransformFlagBitsKHR.VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR; 3180 enum VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = VkSurfaceTransformFlagBitsKHR.VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR; 3181 enum VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = VkSurfaceTransformFlagBitsKHR.VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR; 3182 enum VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = VkSurfaceTransformFlagBitsKHR.VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR; 3183 enum VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = VkSurfaceTransformFlagBitsKHR.VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR; 3184 enum VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = VkSurfaceTransformFlagBitsKHR.VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR; 3185 enum VK_SURFACE_TRANSFORM_FLAG_BITS_MAX_ENUM_KHR = VkSurfaceTransformFlagBitsKHR.VK_SURFACE_TRANSFORM_FLAG_BITS_MAX_ENUM_KHR; 3186 alias VkSurfaceTransformFlagsKHR = VkFlags; 3187 3188 enum VkCompositeAlphaFlagBitsKHR { 3189 VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0x00000001, 3190 VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0x00000002, 3191 VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 0x00000004, 3192 VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 0x00000008, 3193 VK_COMPOSITE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 3194 } 3195 3196 // VkCompositeAlphaFlagBitsKHR global enums 3197 enum VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = VkCompositeAlphaFlagBitsKHR.VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR; 3198 enum VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = VkCompositeAlphaFlagBitsKHR.VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR; 3199 enum VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = VkCompositeAlphaFlagBitsKHR.VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR; 3200 enum VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = VkCompositeAlphaFlagBitsKHR.VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR; 3201 enum VK_COMPOSITE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = VkCompositeAlphaFlagBitsKHR.VK_COMPOSITE_ALPHA_FLAG_BITS_MAX_ENUM_KHR; 3202 alias VkCompositeAlphaFlagsKHR = VkFlags; 3203 3204 struct VkSurfaceCapabilitiesKHR { 3205 uint32_t minImageCount; 3206 uint32_t maxImageCount; 3207 VkExtent2D currentExtent; 3208 VkExtent2D minImageExtent; 3209 VkExtent2D maxImageExtent; 3210 uint32_t maxImageArrayLayers; 3211 VkSurfaceTransformFlagsKHR supportedTransforms; 3212 VkSurfaceTransformFlagBitsKHR currentTransform; 3213 VkCompositeAlphaFlagsKHR supportedCompositeAlpha; 3214 VkImageUsageFlags supportedUsageFlags; 3215 } 3216 3217 struct VkSurfaceFormatKHR { 3218 VkFormat format; 3219 VkColorSpaceKHR colorSpace; 3220 } 3221 3222 // VK_KHR_swapchain 3223 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkSwapchainKHR} ); 3224 3225 enum VK_KHR_SWAPCHAIN_SPEC_VERSION = 68; 3226 enum VK_KHR_SWAPCHAIN_EXTENSION_NAME = "VK_KHR_swapchain"; 3227 3228 alias VkSwapchainCreateFlagsKHR = VkFlags; 3229 3230 struct VkSwapchainCreateInfoKHR { 3231 VkStructureType sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR; 3232 const( void )* pNext; 3233 VkSwapchainCreateFlagsKHR flags; 3234 VkSurfaceKHR surface; 3235 uint32_t minImageCount; 3236 VkFormat imageFormat; 3237 VkColorSpaceKHR imageColorSpace; 3238 VkExtent2D imageExtent; 3239 uint32_t imageArrayLayers; 3240 VkImageUsageFlags imageUsage; 3241 VkSharingMode imageSharingMode; 3242 uint32_t queueFamilyIndexCount; 3243 const( uint32_t )* pQueueFamilyIndices; 3244 VkSurfaceTransformFlagBitsKHR preTransform; 3245 VkCompositeAlphaFlagBitsKHR compositeAlpha; 3246 VkPresentModeKHR presentMode; 3247 VkBool32 clipped; 3248 VkSwapchainKHR oldSwapchain; 3249 } 3250 3251 struct VkPresentInfoKHR { 3252 VkStructureType sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR; 3253 const( void )* pNext; 3254 uint32_t waitSemaphoreCount; 3255 const( VkSemaphore )* pWaitSemaphores; 3256 uint32_t swapchainCount; 3257 const( VkSwapchainKHR )* pSwapchains; 3258 const( uint32_t )* pImageIndices; 3259 VkResult* pResults; 3260 } 3261 3262 // VK_KHR_display 3263 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkDisplayKHR} ); 3264 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkDisplayModeKHR} ); 3265 3266 enum VK_KHR_DISPLAY_SPEC_VERSION = 21; 3267 enum VK_KHR_DISPLAY_EXTENSION_NAME = "VK_KHR_display"; 3268 3269 3270 enum VkDisplayPlaneAlphaFlagBitsKHR { 3271 VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 0x00000001, 3272 VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000002, 3273 VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000004, 3274 VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000008, 3275 VK_DISPLAY_PLANE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF 3276 } 3277 3278 // VkDisplayPlaneAlphaFlagBitsKHR global enums 3279 enum VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = VkDisplayPlaneAlphaFlagBitsKHR.VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR; 3280 enum VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = VkDisplayPlaneAlphaFlagBitsKHR.VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR; 3281 enum VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = VkDisplayPlaneAlphaFlagBitsKHR.VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR; 3282 enum VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = VkDisplayPlaneAlphaFlagBitsKHR.VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR; 3283 enum VK_DISPLAY_PLANE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = VkDisplayPlaneAlphaFlagBitsKHR.VK_DISPLAY_PLANE_ALPHA_FLAG_BITS_MAX_ENUM_KHR; 3284 alias VkDisplayPlaneAlphaFlagsKHR = VkFlags; 3285 alias VkDisplayModeCreateFlagsKHR = VkFlags; 3286 alias VkDisplaySurfaceCreateFlagsKHR = VkFlags; 3287 3288 struct VkDisplayPropertiesKHR { 3289 VkDisplayKHR display; 3290 const( char )* displayName; 3291 VkExtent2D physicalDimensions; 3292 VkExtent2D physicalResolution; 3293 VkSurfaceTransformFlagsKHR supportedTransforms; 3294 VkBool32 planeReorderPossible; 3295 VkBool32 persistentContent; 3296 } 3297 3298 struct VkDisplayModeParametersKHR { 3299 VkExtent2D visibleRegion; 3300 uint32_t refreshRate; 3301 } 3302 3303 struct VkDisplayModePropertiesKHR { 3304 VkDisplayModeKHR displayMode; 3305 VkDisplayModeParametersKHR parameters; 3306 } 3307 3308 struct VkDisplayModeCreateInfoKHR { 3309 VkStructureType sType = VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR; 3310 const( void )* pNext; 3311 VkDisplayModeCreateFlagsKHR flags; 3312 VkDisplayModeParametersKHR parameters; 3313 } 3314 3315 struct VkDisplayPlaneCapabilitiesKHR { 3316 VkDisplayPlaneAlphaFlagsKHR supportedAlpha; 3317 VkOffset2D minSrcPosition; 3318 VkOffset2D maxSrcPosition; 3319 VkExtent2D minSrcExtent; 3320 VkExtent2D maxSrcExtent; 3321 VkOffset2D minDstPosition; 3322 VkOffset2D maxDstPosition; 3323 VkExtent2D minDstExtent; 3324 VkExtent2D maxDstExtent; 3325 } 3326 3327 struct VkDisplayPlanePropertiesKHR { 3328 VkDisplayKHR currentDisplay; 3329 uint32_t currentStackIndex; 3330 } 3331 3332 struct VkDisplaySurfaceCreateInfoKHR { 3333 VkStructureType sType = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR; 3334 const( void )* pNext; 3335 VkDisplaySurfaceCreateFlagsKHR flags; 3336 VkDisplayModeKHR displayMode; 3337 uint32_t planeIndex; 3338 uint32_t planeStackIndex; 3339 VkSurfaceTransformFlagBitsKHR transform; 3340 float globalAlpha; 3341 VkDisplayPlaneAlphaFlagBitsKHR alphaMode; 3342 VkExtent2D imageExtent; 3343 } 3344 3345 // VK_KHR_display_swapchain 3346 enum VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION = 9; 3347 enum VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME = "VK_KHR_display_swapchain"; 3348 3349 struct VkDisplayPresentInfoKHR { 3350 VkStructureType sType = VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR; 3351 const( void )* pNext; 3352 VkRect2D srcRect; 3353 VkRect2D dstRect; 3354 VkBool32 persistent; 3355 } 3356 3357 // VK_KHR_xlib_surface 3358 version( VK_USE_PLATFORM_XLIB_KHR ) { 3359 public import X11.Xlib; 3360 3361 enum VK_KHR_XLIB_SURFACE_SPEC_VERSION = 6; 3362 enum VK_KHR_XLIB_SURFACE_EXTENSION_NAME = "VK_KHR_xlib_surface"; 3363 3364 alias VkXlibSurfaceCreateFlagsKHR = VkFlags; 3365 3366 struct VkXlibSurfaceCreateInfoKHR { 3367 VkStructureType sType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR; 3368 const( void )* pNext; 3369 VkXlibSurfaceCreateFlagsKHR flags; 3370 Display* dpy; 3371 Window window; 3372 } 3373 } 3374 3375 // VK_KHR_xcb_surface 3376 version( VK_USE_PLATFORM_XCB_KHR ) { 3377 public import xcb.xcb; 3378 3379 enum VK_KHR_XCB_SURFACE_SPEC_VERSION = 6; 3380 enum VK_KHR_XCB_SURFACE_EXTENSION_NAME = "VK_KHR_xcb_surface"; 3381 3382 alias VkXcbSurfaceCreateFlagsKHR = VkFlags; 3383 3384 struct VkXcbSurfaceCreateInfoKHR { 3385 VkStructureType sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR; 3386 const( void )* pNext; 3387 VkXcbSurfaceCreateFlagsKHR flags; 3388 xcb_connection_t* connection; 3389 xcb_window_t window; 3390 } 3391 } 3392 3393 // VK_KHR_wayland_surface 3394 version( VK_USE_PLATFORM_WAYLAND_KHR ) { 3395 public import wayland.client; 3396 3397 enum VK_KHR_WAYLAND_SURFACE_SPEC_VERSION = 5; 3398 enum VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME = "VK_KHR_wayland_surface"; 3399 3400 alias VkWaylandSurfaceCreateFlagsKHR = VkFlags; 3401 struct wl_display; 3402 struct wl_surface; 3403 3404 3405 struct VkWaylandSurfaceCreateInfoKHR { 3406 VkStructureType sType = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR; 3407 const( void )* pNext; 3408 VkWaylandSurfaceCreateFlagsKHR flags; 3409 wl_display* display; 3410 wl_surface* surface; 3411 } 3412 } 3413 3414 // VK_KHR_mir_surface 3415 version( VK_USE_PLATFORM_MIR_KHR ) { 3416 public import mir_toolkit.client_types; 3417 3418 enum VK_KHR_MIR_SURFACE_SPEC_VERSION = 4; 3419 enum VK_KHR_MIR_SURFACE_EXTENSION_NAME = "VK_KHR_mir_surface"; 3420 3421 alias VkMirSurfaceCreateFlagsKHR = VkFlags; 3422 3423 struct VkMirSurfaceCreateInfoKHR { 3424 VkStructureType sType = VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR; 3425 const( void )* pNext; 3426 VkMirSurfaceCreateFlagsKHR flags; 3427 MirConnection* connection; 3428 MirSurface* mirSurface; 3429 } 3430 } 3431 3432 // VK_KHR_android_surface 3433 version( VK_USE_PLATFORM_ANDROID_KHR ) { 3434 public import android.native_window; 3435 3436 enum VK_KHR_ANDROID_SURFACE_SPEC_VERSION = 6; 3437 enum VK_KHR_ANDROID_SURFACE_EXTENSION_NAME = "VK_KHR_android_surface"; 3438 3439 alias VkAndroidSurfaceCreateFlagsKHR = VkFlags; 3440 3441 struct VkAndroidSurfaceCreateInfoKHR { 3442 VkStructureType sType = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR; 3443 const( void )* pNext; 3444 VkAndroidSurfaceCreateFlagsKHR flags; 3445 ANativeWindow* window; 3446 } 3447 } 3448 3449 // VK_KHR_win32_surface 3450 version( VK_USE_PLATFORM_WIN32_KHR ) { 3451 public import core.sys.windows.windows; 3452 3453 enum VK_KHR_WIN32_SURFACE_SPEC_VERSION = 5; 3454 enum VK_KHR_WIN32_SURFACE_EXTENSION_NAME = "VK_KHR_win32_surface"; 3455 3456 alias VkWin32SurfaceCreateFlagsKHR = VkFlags; 3457 3458 struct VkWin32SurfaceCreateInfoKHR { 3459 VkStructureType sType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR; 3460 const( void )* pNext; 3461 VkWin32SurfaceCreateFlagsKHR flags; 3462 HINSTANCE hinstance; 3463 HWND hwnd; 3464 } 3465 } 3466 3467 // VK_KHR_sampler_mirror_clamp_to_edge 3468 enum VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION = 1; 3469 enum VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME = "VK_KHR_sampler_mirror_clamp_to_edge"; 3470 3471 // VK_KHR_extension_60 3472 enum VK_KHR_EXTENSION_60_SPEC_VERSION = 0; 3473 enum VK_KHR_EXTENSION_60_EXTENSION_NAME = "VK_KHR_extension_60"; 3474 3475 // VK_KHR_extension_61 3476 enum VK_KHR_EXTENSION_61_SPEC_VERSION = 0; 3477 enum VK_KHR_EXTENSION_61_EXTENSION_NAME = "VK_KHR_extension_61"; 3478 3479 // VK_KHR_extension_64 3480 enum VK_KHR_EXTENSION_64_SPEC_VERSION = 0; 3481 enum VK_KHR_EXTENSION_64_EXTENSION_NAME = "VK_KHR_extension_64"; 3482 3483 // VK_KHR_extension_70 3484 enum VK_KHR_EXTENSION_70_SPEC_VERSION = 0; 3485 enum VK_KHR_EXTENSION_70_EXTENSION_NAME = "VK_KHR_extension_70"; 3486 3487 // VK_KHR_extension_71 3488 enum VK_KHR_EXTENSION_71_SPEC_VERSION = 0; 3489 enum VK_KHR_EXTENSION_71_EXTENSION_NAME = "VK_KHR_extension_71"; 3490 3491 // VK_KHR_extension_72 3492 enum VK_KHR_EXTENSION_72_SPEC_VERSION = 0; 3493 enum VK_KHR_EXTENSION_72_EXTENSION_NAME = "VK_KHR_extension_72"; 3494 3495 // VK_KHR_extension_73 3496 enum VK_KHR_EXTENSION_73_SPEC_VERSION = 0; 3497 enum VK_KHR_EXTENSION_73_EXTENSION_NAME = "VK_KHR_extension_73"; 3498 3499 // VK_KHR_extension_74 3500 enum VK_KHR_EXTENSION_74_SPEC_VERSION = 0; 3501 enum VK_KHR_EXTENSION_74_EXTENSION_NAME = "VK_KHR_extension_74"; 3502 3503 // VK_KHR_extension_75 3504 enum VK_KHR_EXTENSION_75_SPEC_VERSION = 0; 3505 enum VK_KHR_EXTENSION_75_EXTENSION_NAME = "VK_KHR_extension_75"; 3506 3507 // VK_KHR_extension_76 3508 enum VK_KHR_EXTENSION_76_SPEC_VERSION = 0; 3509 enum VK_KHR_EXTENSION_76_EXTENSION_NAME = "VK_KHR_extension_76"; 3510 3511 // VK_KHR_extension_77 3512 enum VK_KHR_EXTENSION_77_SPEC_VERSION = 0; 3513 enum VK_KHR_EXTENSION_77_EXTENSION_NAME = "VK_KHR_extension_77"; 3514 3515 // VK_KHR_extension_78 3516 enum VK_KHR_EXTENSION_78_SPEC_VERSION = 0; 3517 enum VK_KHR_EXTENSION_78_EXTENSION_NAME = "VK_KHR_extension_78"; 3518 3519 // VK_KHR_extension_79 3520 enum VK_KHR_EXTENSION_79_SPEC_VERSION = 0; 3521 enum VK_KHR_EXTENSION_79_EXTENSION_NAME = "VK_KHR_extension_79"; 3522 3523 // VK_KHR_extension_80 3524 enum VK_KHR_EXTENSION_80_SPEC_VERSION = 0; 3525 enum VK_KHR_EXTENSION_80_EXTENSION_NAME = "VK_KHR_extension_80"; 3526 3527 // VK_KHR_extension_81 3528 enum VK_KHR_EXTENSION_81_SPEC_VERSION = 0; 3529 enum VK_KHR_EXTENSION_81_EXTENSION_NAME = "VK_KHR_extension_81"; 3530 3531 // VK_KHR_extension_82 3532 enum VK_KHR_EXTENSION_82_SPEC_VERSION = 0; 3533 enum VK_KHR_EXTENSION_82_EXTENSION_NAME = "VK_KHR_extension_82"; 3534 3535 // VK_KHR_extension_83 3536 enum VK_KHR_EXTENSION_83_SPEC_VERSION = 0; 3537 enum VK_KHR_EXTENSION_83_EXTENSION_NAME = "VK_KHR_extension_83"; 3538 3539 // VK_KHR_extension_84 3540 enum VK_KHR_EXTENSION_84_SPEC_VERSION = 0; 3541 enum VK_KHR_EXTENSION_84_EXTENSION_NAME = "VK_KHR_extension_84"; 3542 3543 // VK_ANDROID_native_buffer 3544 enum VK_ANDROID_NATIVE_BUFFER_SPEC_VERSION = 4; 3545 enum VK_ANDROID_NATIVE_BUFFER_NUMBER = 11; 3546 enum VK_ANDROID_NATIVE_BUFFER_NAME = "VK_ANDROID_native_buffer"; 3547 3548 // VK_EXT_debug_report 3549 mixin( VK_DEFINE_NON_DISPATCHABLE_HANDLE!q{VkDebugReportCallbackEXT} ); 3550 3551 enum VK_EXT_DEBUG_REPORT_SPEC_VERSION = 3; 3552 enum VK_EXT_DEBUG_REPORT_EXTENSION_NAME = "VK_EXT_debug_report"; 3553 enum VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = VkStructureType.VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT; 3554 3555 3556 enum VkDebugReportObjectTypeEXT { 3557 VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0, 3558 VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = 1, 3559 VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = 2, 3560 VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = 3, 3561 VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = 4, 3562 VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = 5, 3563 VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = 6, 3564 VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = 7, 3565 VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = 8, 3566 VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = 9, 3567 VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = 10, 3568 VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = 11, 3569 VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = 12, 3570 VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = 13, 3571 VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = 14, 3572 VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = 15, 3573 VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = 16, 3574 VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = 17, 3575 VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = 18, 3576 VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = 19, 3577 VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = 20, 3578 VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = 21, 3579 VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = 22, 3580 VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = 23, 3581 VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = 24, 3582 VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = 25, 3583 VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26, 3584 VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27, 3585 VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT = 28, 3586 VK_DEBUG_REPORT_OBJECT_TYPE_BEGIN_RANGE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT, 3587 VK_DEBUG_REPORT_OBJECT_TYPE_END_RANGE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT, 3588 VK_DEBUG_REPORT_OBJECT_TYPE_RANGE_SIZE_EXT = ( VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT - VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT + 1 ), 3589 VK_DEBUG_REPORT_OBJECT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF 3590 } 3591 3592 // VkDebugReportObjectTypeEXT global enums 3593 enum VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT; 3594 enum VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT; 3595 enum VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT; 3596 enum VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT; 3597 enum VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT; 3598 enum VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT; 3599 enum VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT; 3600 enum VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT; 3601 enum VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT; 3602 enum VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT; 3603 enum VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT; 3604 enum VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT; 3605 enum VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT; 3606 enum VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT; 3607 enum VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT; 3608 enum VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT; 3609 enum VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT; 3610 enum VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT; 3611 enum VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT; 3612 enum VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT; 3613 enum VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT; 3614 enum VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT; 3615 enum VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT; 3616 enum VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT; 3617 enum VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT; 3618 enum VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT; 3619 enum VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT; 3620 enum VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT; 3621 enum VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT; 3622 enum VK_DEBUG_REPORT_OBJECT_TYPE_BEGIN_RANGE_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_BEGIN_RANGE_EXT; 3623 enum VK_DEBUG_REPORT_OBJECT_TYPE_END_RANGE_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_END_RANGE_EXT; 3624 enum VK_DEBUG_REPORT_OBJECT_TYPE_RANGE_SIZE_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_RANGE_SIZE_EXT; 3625 enum VK_DEBUG_REPORT_OBJECT_TYPE_MAX_ENUM_EXT = VkDebugReportObjectTypeEXT.VK_DEBUG_REPORT_OBJECT_TYPE_MAX_ENUM_EXT; 3626 3627 enum VkDebugReportErrorEXT { 3628 VK_DEBUG_REPORT_ERROR_NONE_EXT = 0, 3629 VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT = 1, 3630 VK_DEBUG_REPORT_ERROR_BEGIN_RANGE_EXT = VK_DEBUG_REPORT_ERROR_NONE_EXT, 3631 VK_DEBUG_REPORT_ERROR_END_RANGE_EXT = VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT, 3632 VK_DEBUG_REPORT_ERROR_RANGE_SIZE_EXT = ( VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT - VK_DEBUG_REPORT_ERROR_NONE_EXT + 1 ), 3633 VK_DEBUG_REPORT_ERROR_MAX_ENUM_EXT = 0x7FFFFFFF 3634 } 3635 3636 // VkDebugReportErrorEXT global enums 3637 enum VK_DEBUG_REPORT_ERROR_NONE_EXT = VkDebugReportErrorEXT.VK_DEBUG_REPORT_ERROR_NONE_EXT; 3638 enum VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT = VkDebugReportErrorEXT.VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT; 3639 enum VK_DEBUG_REPORT_ERROR_BEGIN_RANGE_EXT = VkDebugReportErrorEXT.VK_DEBUG_REPORT_ERROR_BEGIN_RANGE_EXT; 3640 enum VK_DEBUG_REPORT_ERROR_END_RANGE_EXT = VkDebugReportErrorEXT.VK_DEBUG_REPORT_ERROR_END_RANGE_EXT; 3641 enum VK_DEBUG_REPORT_ERROR_RANGE_SIZE_EXT = VkDebugReportErrorEXT.VK_DEBUG_REPORT_ERROR_RANGE_SIZE_EXT; 3642 enum VK_DEBUG_REPORT_ERROR_MAX_ENUM_EXT = VkDebugReportErrorEXT.VK_DEBUG_REPORT_ERROR_MAX_ENUM_EXT; 3643 3644 3645 enum VkDebugReportFlagBitsEXT { 3646 VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 0x00000001, 3647 VK_DEBUG_REPORT_WARNING_BIT_EXT = 0x00000002, 3648 VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = 0x00000004, 3649 VK_DEBUG_REPORT_ERROR_BIT_EXT = 0x00000008, 3650 VK_DEBUG_REPORT_DEBUG_BIT_EXT = 0x00000010, 3651 VK_DEBUG_REPORT_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF 3652 } 3653 3654 // VkDebugReportFlagBitsEXT global enums 3655 enum VK_DEBUG_REPORT_INFORMATION_BIT_EXT = VkDebugReportFlagBitsEXT.VK_DEBUG_REPORT_INFORMATION_BIT_EXT; 3656 enum VK_DEBUG_REPORT_WARNING_BIT_EXT = VkDebugReportFlagBitsEXT.VK_DEBUG_REPORT_WARNING_BIT_EXT; 3657 enum VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = VkDebugReportFlagBitsEXT.VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT; 3658 enum VK_DEBUG_REPORT_ERROR_BIT_EXT = VkDebugReportFlagBitsEXT.VK_DEBUG_REPORT_ERROR_BIT_EXT; 3659 enum VK_DEBUG_REPORT_DEBUG_BIT_EXT = VkDebugReportFlagBitsEXT.VK_DEBUG_REPORT_DEBUG_BIT_EXT; 3660 enum VK_DEBUG_REPORT_FLAG_BITS_MAX_ENUM_EXT = VkDebugReportFlagBitsEXT.VK_DEBUG_REPORT_FLAG_BITS_MAX_ENUM_EXT; 3661 alias VkDebugReportFlagsEXT = VkFlags; 3662 3663 alias PFN_vkDebugReportCallbackEXT = VkBool32 function( VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const( char )* pLayerPrefix, const( char )* pMessage, void* pUserData); 3664 3665 struct VkDebugReportCallbackCreateInfoEXT { 3666 VkStructureType sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT; 3667 const( void )* pNext; 3668 VkDebugReportFlagsEXT flags; 3669 PFN_vkDebugReportCallbackEXT pfnCallback; 3670 void* pUserData; 3671 } 3672 3673 // VK_NV_glsl_shader 3674 enum VK_NV_GLSL_SHADER_SPEC_VERSION = 1; 3675 enum VK_NV_GLSL_SHADER_EXTENSION_NAME = "VK_NV_glsl_shader"; 3676 3677 // VK_NV_extension_1 3678 enum VK_NV_EXTENSION_1_SPEC_VERSION = 0; 3679 enum VK_NV_EXTENSION_1_EXTENSION_NAME = "VK_NV_extension_1"; 3680 3681 // VK_IMG_filter_cubic 3682 enum VK_IMG_FILTER_CUBIC_SPEC_VERSION = 1; 3683 enum VK_IMG_FILTER_CUBIC_EXTENSION_NAME = "VK_IMG_filter_cubic"; 3684 3685 // VK_AMD_extension_17 3686 enum VK_AMD_EXTENSION_17_SPEC_VERSION = 0; 3687 enum VK_AMD_EXTENSION_17_EXTENSION_NAME = "VK_AMD_extension_17"; 3688 3689 // VK_AMD_extension_18 3690 enum VK_AMD_EXTENSION_18_SPEC_VERSION = 0; 3691 enum VK_AMD_EXTENSION_18_EXTENSION_NAME = "VK_AMD_extension_18"; 3692 3693 // VK_AMD_rasterization_order 3694 enum VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION = 1; 3695 enum VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME = "VK_AMD_rasterization_order"; 3696 3697 3698 enum VkRasterizationOrderAMD { 3699 VK_RASTERIZATION_ORDER_STRICT_AMD = 0, 3700 VK_RASTERIZATION_ORDER_RELAXED_AMD = 1, 3701 VK_RASTERIZATION_ORDER_BEGIN_RANGE_AMD = VK_RASTERIZATION_ORDER_STRICT_AMD, 3702 VK_RASTERIZATION_ORDER_END_RANGE_AMD = VK_RASTERIZATION_ORDER_RELAXED_AMD, 3703 VK_RASTERIZATION_ORDER_RANGE_SIZE_AMD = ( VK_RASTERIZATION_ORDER_RELAXED_AMD - VK_RASTERIZATION_ORDER_STRICT_AMD + 1 ), 3704 VK_RASTERIZATION_ORDER_MAX_ENUM_AMD = 0x7FFFFFFF 3705 } 3706 3707 // VkRasterizationOrderAMD global enums 3708 enum VK_RASTERIZATION_ORDER_STRICT_AMD = VkRasterizationOrderAMD.VK_RASTERIZATION_ORDER_STRICT_AMD; 3709 enum VK_RASTERIZATION_ORDER_RELAXED_AMD = VkRasterizationOrderAMD.VK_RASTERIZATION_ORDER_RELAXED_AMD; 3710 enum VK_RASTERIZATION_ORDER_BEGIN_RANGE_AMD = VkRasterizationOrderAMD.VK_RASTERIZATION_ORDER_BEGIN_RANGE_AMD; 3711 enum VK_RASTERIZATION_ORDER_END_RANGE_AMD = VkRasterizationOrderAMD.VK_RASTERIZATION_ORDER_END_RANGE_AMD; 3712 enum VK_RASTERIZATION_ORDER_RANGE_SIZE_AMD = VkRasterizationOrderAMD.VK_RASTERIZATION_ORDER_RANGE_SIZE_AMD; 3713 enum VK_RASTERIZATION_ORDER_MAX_ENUM_AMD = VkRasterizationOrderAMD.VK_RASTERIZATION_ORDER_MAX_ENUM_AMD; 3714 3715 struct VkPipelineRasterizationStateRasterizationOrderAMD { 3716 VkStructureType sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD; 3717 const( void )* pNext; 3718 VkRasterizationOrderAMD rasterizationOrder; 3719 } 3720 3721 // VK_AMD_extension_20 3722 enum VK_AMD_EXTENSION_20_SPEC_VERSION = 0; 3723 enum VK_AMD_EXTENSION_20_EXTENSION_NAME = "VK_AMD_extension_20"; 3724 3725 // VK_AMD_shader_trinary_minmax 3726 enum VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION = 1; 3727 enum VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME = "VK_AMD_shader_trinary_minmax"; 3728 3729 // VK_AMD_shader_explicit_vertex_parameter 3730 enum VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION = 1; 3731 enum VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME = "VK_AMD_shader_explicit_vertex_parameter"; 3732 3733 // VK_EXT_debug_marker 3734 enum VK_EXT_DEBUG_MARKER_SPEC_VERSION = 3; 3735 enum VK_EXT_DEBUG_MARKER_EXTENSION_NAME = "VK_EXT_debug_marker"; 3736 3737 struct VkDebugMarkerObjectNameInfoEXT { 3738 VkStructureType sType = VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT; 3739 const( void )* pNext; 3740 VkDebugReportObjectTypeEXT objectType; 3741 uint64_t object; 3742 const( char )* pObjectName; 3743 } 3744 3745 struct VkDebugMarkerObjectTagInfoEXT { 3746 VkStructureType sType = VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT; 3747 const( void )* pNext; 3748 VkDebugReportObjectTypeEXT objectType; 3749 uint64_t object; 3750 uint64_t tagName; 3751 size_t tagSize; 3752 const( void )* pTag; 3753 } 3754 3755 struct VkDebugMarkerMarkerInfoEXT { 3756 VkStructureType sType = VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT; 3757 const( void )* pNext; 3758 const( char )* pMarkerName; 3759 float[4] color; 3760 } 3761 3762 // VK_AMD_extension_24 3763 enum VK_AMD_EXTENSION_24_SPEC_VERSION = 0; 3764 enum VK_AMD_EXTENSION_24_EXTENSION_NAME = "VK_AMD_extension_24"; 3765 3766 // VK_AMD_extension_25 3767 enum VK_AMD_EXTENSION_25_SPEC_VERSION = 0; 3768 enum VK_AMD_EXTENSION_25_EXTENSION_NAME = "VK_AMD_extension_25"; 3769 3770 // VK_AMD_gcn_shader 3771 enum VK_AMD_GCN_SHADER_SPEC_VERSION = 1; 3772 enum VK_AMD_GCN_SHADER_EXTENSION_NAME = "VK_AMD_gcn_shader"; 3773 3774 // VK_NV_dedicated_allocation 3775 enum VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION = 1; 3776 enum VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME = "VK_NV_dedicated_allocation"; 3777 3778 struct VkDedicatedAllocationImageCreateInfoNV { 3779 VkStructureType sType = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV; 3780 const( void )* pNext; 3781 VkBool32 dedicatedAllocation; 3782 } 3783 3784 struct VkDedicatedAllocationBufferCreateInfoNV { 3785 VkStructureType sType = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV; 3786 const( void )* pNext; 3787 VkBool32 dedicatedAllocation; 3788 } 3789 3790 struct VkDedicatedAllocationMemoryAllocateInfoNV { 3791 VkStructureType sType = VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV; 3792 const( void )* pNext; 3793 VkImage image; 3794 VkBuffer buffer; 3795 } 3796 3797 // VK_EXT_extension_28 3798 enum VK_EXT_EXTENSION_28_SPEC_VERSION = 0; 3799 enum VK_EXT_EXTENSION_28_EXTENSION_NAME = "VK_NV_extension_28"; 3800 3801 // VK_NVX_extension_29 3802 enum VK_NVX_EXTENSION_29_SPEC_VERSION = 0; 3803 enum VK_NVX_EXTENSION_29_EXTENSION_NAME = "VK_NVX_extension_29"; 3804 3805 // VK_NVX_extension_30 3806 enum VK_NVX_EXTENSION_30_SPEC_VERSION = 0; 3807 enum VK_NVX_EXTENSION_30_EXTENSION_NAME = "VK_NVX_extension_30"; 3808 3809 // VK_NVX_extension_31 3810 enum VK_NVX_EXTENSION_31_SPEC_VERSION = 0; 3811 enum VK_NVX_EXTENSION_31_EXTENSION_NAME = "VK_NVX_extension_31"; 3812 3813 // VK_AMD_extension_32 3814 enum VK_AMD_EXTENSION_32_SPEC_VERSION = 0; 3815 enum VK_AMD_EXTENSION_32_EXTENSION_NAME = "VK_AMD_extension_32"; 3816 3817 // VK_AMD_extension_33 3818 enum VK_AMD_EXTENSION_33_SPEC_VERSION = 0; 3819 enum VK_AMD_EXTENSION_33_EXTENSION_NAME = "VK_AMD_extension_33"; 3820 3821 // VK_AMD_draw_indirect_count 3822 enum VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION = 1; 3823 enum VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME = "VK_AMD_draw_indirect_count"; 3824 3825 // VK_AMD_extension_35 3826 enum VK_AMD_EXTENSION_35_SPEC_VERSION = 0; 3827 enum VK_AMD_EXTENSION_35_EXTENSION_NAME = "VK_AMD_extension_35"; 3828 3829 // VK_AMD_negative_viewport_height 3830 enum VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION = 1; 3831 enum VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME = "VK_AMD_negative_viewport_height"; 3832 3833 // VK_AMD_gpu_shader_half_float 3834 enum VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION = 1; 3835 enum VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME = "VK_AMD_gpu_shader_half_float"; 3836 3837 // VK_AMD_shader_ballot 3838 enum VK_AMD_SHADER_BALLOT_SPEC_VERSION = 1; 3839 enum VK_AMD_SHADER_BALLOT_EXTENSION_NAME = "VK_AMD_shader_ballot"; 3840 3841 // VK_AMD_extension_39 3842 enum VK_AMD_EXTENSION_39_SPEC_VERSION = 0; 3843 enum VK_AMD_EXTENSION_39_EXTENSION_NAME = "VK_AMD_extension_39"; 3844 3845 // VK_AMD_extension_40 3846 enum VK_AMD_EXTENSION_40_SPEC_VERSION = 0; 3847 enum VK_AMD_EXTENSION_40_EXTENSION_NAME = "VK_AMD_extension_40"; 3848 3849 // VK_AMD_extension_41 3850 enum VK_AMD_EXTENSION_41_SPEC_VERSION = 0; 3851 enum VK_AMD_EXTENSION_41_EXTENSION_NAME = "VK_AMD_extension_41"; 3852 3853 // VK_AMD_extension_42 3854 enum VK_AMD_EXTENSION_42_SPEC_VERSION = 0; 3855 enum VK_AMD_EXTENSION_42_EXTENSION_NAME = "VK_AMD_extension_42"; 3856 3857 // VK_AMD_extension_43 3858 enum VK_AMD_EXTENSION_43_SPEC_VERSION = 0; 3859 enum VK_AMD_EXTENSION_43_EXTENSION_NAME = "VK_AMD_extension_43"; 3860 3861 // VK_AMD_extension_44 3862 enum VK_AMD_EXTENSION_44_SPEC_VERSION = 0; 3863 enum VK_AMD_EXTENSION_44_EXTENSION_NAME = "VK_AMD_extension_44"; 3864 3865 // VK_AMD_extension_45 3866 enum VK_AMD_EXTENSION_45_SPEC_VERSION = 0; 3867 enum VK_AMD_EXTENSION_45_EXTENSION_NAME = "VK_AMD_extension_45"; 3868 3869 // VK_AMD_extension_46 3870 enum VK_AMD_EXTENSION_46_SPEC_VERSION = 0; 3871 enum VK_AMD_EXTENSION_46_EXTENSION_NAME = "VK_AMD_extension_46"; 3872 3873 // VK_AMD_extension_47 3874 enum VK_AMD_EXTENSION_47_SPEC_VERSION = 0; 3875 enum VK_AMD_EXTENSION_47_EXTENSION_NAME = "VK_AMD_extension_47"; 3876 3877 // VK_NVX_extension_48 3878 enum VK_NVX_EXTENSION_48_SPEC_VERSION = 0; 3879 enum VK_NVX_EXTENSION_48_EXTENSION_NAME = "VK_NVX_extension_48"; 3880 3881 // VK_GOOGLE_extension_49 3882 enum VK_GOOGLE_EXTENSION_49_SPEC_VERSION = 0; 3883 enum VK_GOOGLE_EXTENSION_49_EXTENSION_NAME = "VK_GOOGLE_extension_49"; 3884 3885 // VK_GOOGLE_extension_50 3886 enum VK_GOOGLE_EXTENSION_50_SPEC_VERSION = 0; 3887 enum VK_GOOGLE_EXTENSION_50_EXTENSION_NAME = "VK_GOOGLE_extension_50"; 3888 3889 // VK_NVX_extension_51 3890 enum VK_NVX_EXTENSION_51_SPEC_VERSION = 0; 3891 enum VK_NVX_EXTENSION_51_EXTENSION_NAME = "VK_NVX_extension_51"; 3892 3893 // VK_NVX_extension_52 3894 enum VK_NVX_EXTENSION_52_SPEC_VERSION = 0; 3895 enum VK_NVX_EXTENSION_52_EXTENSION_NAME = "VK_NVX_extension_52"; 3896 3897 // VK_NV_extension_53 3898 enum VK_NV_EXTENSION_53_SPEC_VERSION = 0; 3899 enum VK_NV_EXTENSION_53_EXTENSION_NAME = "VK_NV_extension_53"; 3900 3901 // VK_NV_extension_54 3902 enum VK_NV_EXTENSION_54_SPEC_VERSION = 0; 3903 enum VK_NV_EXTENSION_54_EXTENSION_NAME = "VK_NV_extension_54"; 3904 3905 // VK_IMG_format_pvrtc 3906 enum VK_IMG_FORMAT_PVRTC_SPEC_VERSION = 1; 3907 enum VK_IMG_FORMAT_PVRTC_EXTENSION_NAME = "VK_IMG_format_pvrtc"; 3908 3909 // VK_NV_external_memory_capabilities 3910 enum VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION = 1; 3911 enum VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME = "VK_NV_external_memory_capabilities"; 3912 3913 3914 enum VkExternalMemoryHandleTypeFlagBitsNV { 3915 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV = 0x00000001, 3916 VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV = 0x00000002, 3917 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV = 0x00000004, 3918 VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV = 0x00000008, 3919 VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF 3920 } 3921 3922 // VkExternalMemoryHandleTypeFlagBitsNV global enums 3923 enum VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV = VkExternalMemoryHandleTypeFlagBitsNV.VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV; 3924 enum VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV = VkExternalMemoryHandleTypeFlagBitsNV.VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV; 3925 enum VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV = VkExternalMemoryHandleTypeFlagBitsNV.VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV; 3926 enum VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV = VkExternalMemoryHandleTypeFlagBitsNV.VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV; 3927 enum VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_NV = VkExternalMemoryHandleTypeFlagBitsNV.VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_NV; 3928 alias VkExternalMemoryHandleTypeFlagsNV = VkFlags; 3929 3930 enum VkExternalMemoryFeatureFlagBitsNV { 3931 VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV = 0x00000001, 3932 VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV = 0x00000002, 3933 VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV = 0x00000004, 3934 VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF 3935 } 3936 3937 // VkExternalMemoryFeatureFlagBitsNV global enums 3938 enum VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV = VkExternalMemoryFeatureFlagBitsNV.VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV; 3939 enum VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV = VkExternalMemoryFeatureFlagBitsNV.VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV; 3940 enum VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV = VkExternalMemoryFeatureFlagBitsNV.VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV; 3941 enum VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_NV = VkExternalMemoryFeatureFlagBitsNV.VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_NV; 3942 alias VkExternalMemoryFeatureFlagsNV = VkFlags; 3943 3944 struct VkExternalImageFormatPropertiesNV { 3945 VkImageFormatProperties imageFormatProperties; 3946 VkExternalMemoryFeatureFlagsNV externalMemoryFeatures; 3947 VkExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes; 3948 VkExternalMemoryHandleTypeFlagsNV compatibleHandleTypes; 3949 } 3950 3951 // VK_NV_external_memory 3952 enum VK_NV_EXTERNAL_MEMORY_SPEC_VERSION = 1; 3953 enum VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME = "VK_NV_external_memory"; 3954 3955 struct VkExternalMemoryImageCreateInfoNV { 3956 VkStructureType sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV; 3957 const( void )* pNext; 3958 VkExternalMemoryHandleTypeFlagsNV handleTypes; 3959 } 3960 3961 struct VkExportMemoryAllocateInfoNV { 3962 VkStructureType sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV; 3963 const( void )* pNext; 3964 VkExternalMemoryHandleTypeFlagsNV handleTypes; 3965 } 3966 3967 // VK_NV_external_memory_win32 3968 version( VK_USE_PLATFORM_WIN32_KHR ) { 3969 public import core.sys.windows.winnt; 3970 3971 enum VK_NV_EXTERNAL_MEMORY_WIN32_SPEC_VERSION = 1; 3972 enum VK_NV_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME = "VK_NV_external_memory_win32"; 3973 3974 struct VkImportMemoryWin32HandleInfoNV { 3975 VkStructureType sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV; 3976 const( void )* pNext; 3977 VkExternalMemoryHandleTypeFlagsNV handleType; 3978 HANDLE handle; 3979 } 3980 3981 struct VkExportMemoryWin32HandleInfoNV { 3982 VkStructureType sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV; 3983 const( void )* pNext; 3984 const( SECURITY_ATTRIBUTES )* pAttributes; 3985 DWORD dwAccess; 3986 } 3987 } 3988 3989 // VK_NV_win32_keyed_mutex 3990 version( VK_USE_PLATFORM_WIN32_KHR ) { 3991 3992 enum VK_NV_WIN32_KEYED_MUTEX_SPEC_VERSION = 1; 3993 enum VK_NV_WIN32_KEYED_MUTEX_EXTENSION_NAME = "VK_NV_win32_keyed_mutex"; 3994 3995 struct VkWin32KeyedMutexAcquireReleaseInfoNV { 3996 VkStructureType sType = VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV; 3997 const( void )* pNext; 3998 uint32_t acquireCount; 3999 const( VkDeviceMemory )* pAcquireSyncs; 4000 const( uint64_t )* pAcquireKeys; 4001 const( uint32_t )* pAcquireTimeoutMilliseconds; 4002 uint32_t releaseCount; 4003 const( VkDeviceMemory )* pReleaseSyncs; 4004 const( uint64_t )* pReleaseKeys; 4005 } 4006 } 4007 4008 // VK_EXT_validation_flags 4009 enum VK_EXT_VALIDATION_FLAGS_SPEC_VERSION = 1; 4010 enum VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME = "VK_EXT_validation_flags"; 4011 4012 4013 enum VkValidationCheckEXT { 4014 VK_VALIDATION_CHECK_ALL_EXT = 0, 4015 VK_VALIDATION_CHECK_BEGIN_RANGE_EXT = VK_VALIDATION_CHECK_ALL_EXT, 4016 VK_VALIDATION_CHECK_END_RANGE_EXT = VK_VALIDATION_CHECK_ALL_EXT, 4017 VK_VALIDATION_CHECK_RANGE_SIZE_EXT = ( VK_VALIDATION_CHECK_ALL_EXT - VK_VALIDATION_CHECK_ALL_EXT + 1 ), 4018 VK_VALIDATION_CHECK_MAX_ENUM_EXT = 0x7FFFFFFF 4019 } 4020 4021 // VkValidationCheckEXT global enums 4022 enum VK_VALIDATION_CHECK_ALL_EXT = VkValidationCheckEXT.VK_VALIDATION_CHECK_ALL_EXT; 4023 enum VK_VALIDATION_CHECK_BEGIN_RANGE_EXT = VkValidationCheckEXT.VK_VALIDATION_CHECK_BEGIN_RANGE_EXT; 4024 enum VK_VALIDATION_CHECK_END_RANGE_EXT = VkValidationCheckEXT.VK_VALIDATION_CHECK_END_RANGE_EXT; 4025 enum VK_VALIDATION_CHECK_RANGE_SIZE_EXT = VkValidationCheckEXT.VK_VALIDATION_CHECK_RANGE_SIZE_EXT; 4026 enum VK_VALIDATION_CHECK_MAX_ENUM_EXT = VkValidationCheckEXT.VK_VALIDATION_CHECK_MAX_ENUM_EXT; 4027 4028 struct VkValidationFlagsEXT { 4029 VkStructureType sType = VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT; 4030 const( void )* pNext; 4031 uint32_t disabledValidationCheckCount; 4032 VkValidationCheckEXT* pDisabledValidationChecks; 4033 } 4034 4035 // VK_NV_extension_63 4036 enum VK_NV_EXTENSION_63_SPEC_VERSION = 0; 4037 enum VK_NV_EXTENSION_63_EXTENSION_NAME = "VK_NV_extension_63"; 4038 4039 // VK_NV_extension_65 4040 enum VK_NV_EXTENSION_65_SPEC_VERSION = 0; 4041 enum VK_NV_EXTENSION_65_EXTENSION_NAME = "VK_NV_extension_65"; 4042 4043 // VK_NV_extension_66 4044 enum VK_NV_EXTENSION_66_SPEC_VERSION = 0; 4045 enum VK_NV_EXTENSION_66_EXTENSION_NAME = "VK_NV_extension_66"; 4046 4047 // VK_ARM_extension_01 4048 enum VK_ARM_EXTENSION_01_SPEC_VERSION = 0; 4049 enum VK_ARM_EXTENSION_01_EXTENSION_NAME = "VK_ARM_extension_01"; 4050 4051 // VK_ARM_extension_02 4052 enum VK_ARM_EXTENSION_02_SPEC_VERSION = 0; 4053 enum VK_ARM_EXTENSION_02_EXTENSION_NAME = "VK_ARM_extension_02"; 4054 4055 // VK_IMG_extension_69 4056 enum VK_IMG_EXTENSION_69_SPEC_VERSION = 0; 4057 enum VK_IMG_EXTENSION_69_EXTENSION_NAME = "VK_IMG_extension_69"; 4058