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