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