~mmach/netext73/mesa-haswell

#if defined(__LP64__) || defined(_WIN64) || (defined(__x86_64__) && !defined(__ILP32__) ) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)

#define VK_USE_64_BIT_PTR_DEFINES 1

#else

#define VK_USE_64_BIT_PTR_DEFINES 0

#endif

#ifndef VK_DEFINE_NON_DISPATCHABLE_HANDLE

#if (VK_USE_64_BIT_PTR_DEFINES==1)

#if (defined(__cplusplus) && (__cplusplus >= 201103L)) || (defined(_MSVC_LANG) && (_MSVC_LANG >= 201103L))

#define VK_NULL_HANDLE nullptr

#else

#define VK_NULL_HANDLE ((void*)0)

#endif

#else

#define VK_NULL_HANDLE 0ULL

#endif

#ifndef VK_NULL_HANDLE

#define VK_NULL_HANDLE 0

#endif

#ifndef VK_DEFINE_NON_DISPATCHABLE_HANDLE

#if (VK_USE_64_BIT_PTR_DEFINES==1)

#define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *object;

#else

#define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object;

#endif

// DEPRECATED: This define is deprecated. VK_MAKE_API_VERSION should be used instead.

#define VK_MAKE_VERSION(major, minor, patch) \

((((uint32_t)(major)) << 22) | (((uint32_t)(minor)) << 12) | ((uint32_t)(patch)))

// DEPRECATED: This define has been removed. Specific version defines (e.g. VK_API_VERSION_1_0), or the VK_MAKE_VERSION macro, should be used instead.

//#define VK_API_VERSION VK_MAKE_VERSION(1, 0, 0) // Patch version should always be set to 0

#define VK_MAKE_API_VERSION(variant, major, minor, patch) \

((((uint32_t)(variant)) << 29) | (((uint32_t)(major)) << 22) | (((uint32_t)(minor)) << 12) | ((uint32_t)(patch)))

// Vulkan 1.0 version number

#define VK_API_VERSION_1_0 VK_MAKE_API_VERSION(0, 1, 0, 0)// Patch version should always be set to 0

// Version of this file

#define VK_HEADER_VERSION 211

// Complete version of this file

#define VK_HEADER_VERSION_COMPLETE VK_MAKE_API_VERSION(0, 1, 3, VK_HEADER_VERSION)

// DEPRECATED: This define is deprecated. VK_API_VERSION_MAJOR should be used instead.

#define VK_VERSION_MAJOR(version) ((uint32_t)(version) >> 22)

// DEPRECATED: This define is deprecated. VK_API_VERSION_MINOR should be used instead.

#define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3FFU)

// DEPRECATED: This define is deprecated. VK_API_VERSION_PATCH should be used instead.

#define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xFFFU)

#define VK_API_VERSION_VARIANT(version) ((uint32_t)(version) >> 29)

#define VK_API_VERSION_MAJOR(version) (((uint32_t)(version) >> 22) & 0x7FU)

#define VK_API_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3FFU)

#define VK_API_VERSION_PATCH(version) ((uint32_t)(version) & 0xFFFU)

typedef uint32_t VkBool32;

typedef uint64_t VkDeviceAddress;

typedef uint64_t VkDeviceSize;

typedef uint32_t VkFlags;

typedef uint32_t VkSampleMask;

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBuffer)

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage)

100

VK_DEFINE_HANDLE(VkInstance)

101

VK_DEFINE_HANDLE(VkPhysicalDevice)

102

VK_DEFINE_HANDLE(VkDevice)

103

VK_DEFINE_HANDLE(VkQueue)

104

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSemaphore)

105

VK_DEFINE_HANDLE(VkCommandBuffer)

106

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence)

107

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory)

108

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent)

109

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkQueryPool)

110

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView)

111

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView)

112

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule)

113

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache)

114

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout)

115

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline)

116

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass)

117

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout)

118

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSampler)

119

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet)

120

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool)

121

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer)

122

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool)

123

#define VK_UUID_SIZE 16U

124

#define VK_ATTACHMENT_UNUSED (~0U)

125

#define VK_FALSE 0U

126

#define VK_LOD_CLAMP_NONE 1000.0F

127

#define VK_QUEUE_FAMILY_IGNORED (~0U)

128

#define VK_REMAINING_ARRAY_LAYERS (~0U)

129

#define VK_REMAINING_MIP_LEVELS (~0U)

130

#define VK_SUBPASS_EXTERNAL (~0U)

131

#define VK_TRUE 1U

132

#define VK_WHOLE_SIZE (~0ULL)

133

#define VK_MAX_MEMORY_TYPES 32U

134

#define VK_MAX_MEMORY_HEAPS 16U

135

#define VK_MAX_PHYSICAL_DEVICE_NAME_SIZE 256U

136

#define VK_MAX_EXTENSION_NAME_SIZE 256U

137

#define VK_MAX_DESCRIPTION_SIZE 256U

138

139

typedef enum VkResult {

140

VK_SUCCESS = 0,

141

VK_NOT_READY = 1,

142

VK_TIMEOUT = 2,

143

VK_EVENT_SET = 3,

144

VK_EVENT_RESET = 4,

145

VK_INCOMPLETE = 5,

146

VK_ERROR_OUT_OF_HOST_MEMORY = -1,

147

VK_ERROR_OUT_OF_DEVICE_MEMORY = -2,

148

VK_ERROR_INITIALIZATION_FAILED = -3,

149

VK_ERROR_DEVICE_LOST = -4,

150

VK_ERROR_MEMORY_MAP_FAILED = -5,

151

VK_ERROR_LAYER_NOT_PRESENT = -6,

152

VK_ERROR_EXTENSION_NOT_PRESENT = -7,

153

VK_ERROR_FEATURE_NOT_PRESENT = -8,

154

VK_ERROR_INCOMPATIBLE_DRIVER = -9,

155

VK_ERROR_TOO_MANY_OBJECTS = -10,

156

VK_ERROR_FORMAT_NOT_SUPPORTED = -11,

157

VK_ERROR_FRAGMENTED_POOL = -12,

158

VK_ERROR_UNKNOWN = -13,

159

VK_ERROR_OUT_OF_POOL_MEMORY = -1000069000,

160

VK_ERROR_INVALID_EXTERNAL_HANDLE = -1000072003,

161

VK_ERROR_FRAGMENTATION = -1000161000,

162

VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS = -1000257000,

163

VK_PIPELINE_COMPILE_REQUIRED = 1000297000,

164

VK_ERROR_SURFACE_LOST_KHR = -1000000000,

165

VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001,

166

VK_SUBOPTIMAL_KHR = 1000001003,

167

VK_ERROR_OUT_OF_DATE_KHR = -1000001004,

168

VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001,

169

VK_ERROR_VALIDATION_FAILED_EXT = -1000011001,

170

VK_ERROR_INVALID_SHADER_NV = -1000012000,

171

VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT = -1000158000,

172

VK_ERROR_NOT_PERMITTED_KHR = -1000174001,

173

VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT = -1000255000,

174

VK_THREAD_IDLE_KHR = 1000268000,

175

VK_THREAD_DONE_KHR = 1000268001,

176

VK_OPERATION_DEFERRED_KHR = 1000268002,

177

VK_OPERATION_NOT_DEFERRED_KHR = 1000268003,

178

VK_ERROR_OUT_OF_POOL_MEMORY_KHR = VK_ERROR_OUT_OF_POOL_MEMORY,

179

VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR = VK_ERROR_INVALID_EXTERNAL_HANDLE,

180

VK_ERROR_FRAGMENTATION_EXT = VK_ERROR_FRAGMENTATION,

181

VK_ERROR_NOT_PERMITTED_EXT = VK_ERROR_NOT_PERMITTED_KHR,

182

VK_ERROR_INVALID_DEVICE_ADDRESS_EXT = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS,

183

VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS,

184

VK_PIPELINE_COMPILE_REQUIRED_EXT = VK_PIPELINE_COMPILE_REQUIRED,

185

VK_ERROR_PIPELINE_COMPILE_REQUIRED_EXT = VK_PIPELINE_COMPILE_REQUIRED,

186

VK_RESULT_MAX_ENUM = 0x7FFFFFFF

187

} VkResult;

188

189

typedef enum VkStructureType {

190

VK_STRUCTURE_TYPE_APPLICATION_INFO = 0,

191

VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1,

192

VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2,

193

VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3,

194

VK_STRUCTURE_TYPE_SUBMIT_INFO = 4,

195

VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5,

196

VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6,

197

VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7,

198

VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8,

199

VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9,

200

VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10,

201

VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11,

202

VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12,

203

VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13,

204

VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14,

205

VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15,

206

VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16,

207

VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17,

208

VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18,

209

VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19,

210

VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20,

211

VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21,

212

VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22,

213

VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23,

214

VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24,

215

VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25,

216

VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26,

217

VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27,

218

VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28,

219

VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29,

220

VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30,

221

VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31,

222

VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32,

223

VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33,

224

VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34,

225

VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35,

226

VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36,

227

VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37,

228

VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38,

229

VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39,

230

VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40,

231

VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41,

232

VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42,

233

VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43,

234

VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44,

235

VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45,

236

VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46,

237

VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47,

238

VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48,

239

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES = 1000094000,

240

VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO = 1000157000,

241

VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO = 1000157001,

242

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES = 1000083000,

243

VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS = 1000127000,

244

VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO = 1000127001,

245

VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO = 1000060000,

246

VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO = 1000060003,

247

VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO = 1000060004,

248

VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO = 1000060005,

249

VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO = 1000060006,

250

VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO = 1000060013,

251

VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO = 1000060014,

252

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES = 1000070000,

253

VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO = 1000070001,

254

VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2 = 1000146000,

255

VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2 = 1000146001,

256

VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 = 1000146002,

257

VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2 = 1000146003,

258

VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 = 1000146004,

259

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 = 1000059000,

260

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 = 1000059001,

261

VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2 = 1000059002,

262

VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2 = 1000059003,

263

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 = 1000059004,

264

VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2 = 1000059005,

265

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 = 1000059006,

266

VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2 = 1000059007,

267

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 = 1000059008,

268

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES = 1000117000,

269

VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO = 1000117001,

270

VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO = 1000117002,

271

VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO = 1000117003,

272

VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO = 1000053000,

273

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES = 1000053001,

274

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES = 1000053002,

275

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES = 1000120000,

276

VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO = 1000145000,

277

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES = 1000145001,

278

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES = 1000145002,

279

VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2 = 1000145003,

280

VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO = 1000156000,

281

VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO = 1000156001,

282

VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO = 1000156002,

283

VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO = 1000156003,

284

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES = 1000156004,

285

VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES = 1000156005,

286

VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO = 1000085000,

287

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO = 1000071000,

288

VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES = 1000071001,

289

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO = 1000071002,

290

VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES = 1000071003,

291

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES = 1000071004,

292

VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO = 1000072000,

293

VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO = 1000072001,

294

VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO = 1000072002,

295

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO = 1000112000,

296

VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES = 1000112001,

297

VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO = 1000113000,

298

VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO = 1000077000,

299

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO = 1000076000,

300

VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES = 1000076001,

301

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES = 1000168000,

302

VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT = 1000168001,

303

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES = 1000063000,

304

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES = 49,

305

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES = 50,

306

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES = 51,

307

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES = 52,

308

VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO = 1000147000,

309

VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2 = 1000109000,

310

VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2 = 1000109001,

311

VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2 = 1000109002,

312

VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2 = 1000109003,

313

VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2 = 1000109004,

314

VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO = 1000109005,

315

VK_STRUCTURE_TYPE_SUBPASS_END_INFO = 1000109006,

316

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES = 1000177000,

317

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES = 1000196000,

318

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES = 1000180000,

319

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES = 1000082000,

320

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES = 1000197000,

321

VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO = 1000161000,

322

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES = 1000161001,

323

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES = 1000161002,

324

VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO = 1000161003,

325

VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT = 1000161004,

326

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES = 1000199000,

327

VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE = 1000199001,

328

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES = 1000221000,

329

VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO = 1000246000,

330

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES = 1000130000,

331

VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO = 1000130001,

332

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES = 1000211000,

333

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES = 1000108000,

334

VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO = 1000108001,

335

VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO = 1000108002,

336

VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO = 1000108003,

337

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES = 1000253000,

338

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES = 1000175000,

339

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES = 1000241000,

340

VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT = 1000241001,

341

VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT = 1000241002,

342

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES = 1000261000,

343

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES = 1000207000,

344

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES = 1000207001,

345

VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO = 1000207002,

346

VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO = 1000207003,

347

VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO = 1000207004,

348

VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO = 1000207005,

349

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES = 1000257000,

350

VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO = 1000244001,

351

VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO = 1000257002,

352

VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO = 1000257003,

353

VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO = 1000257004,

354

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES = 53,

355

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES = 54,

356

VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO = 1000192000,

357

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES = 1000215000,

358

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES = 1000245000,

359

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES = 1000276000,

360

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES = 1000295000,

361

VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO = 1000295001,

362

VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO = 1000295002,

363

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES = 1000297000,

364

VK_STRUCTURE_TYPE_MEMORY_BARRIER_2 = 1000314000,

365

VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2 = 1000314001,

366

VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2 = 1000314002,

367

VK_STRUCTURE_TYPE_DEPENDENCY_INFO = 1000314003,

368

VK_STRUCTURE_TYPE_SUBMIT_INFO_2 = 1000314004,

369

VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO = 1000314005,

370

VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO = 1000314006,

371

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES = 1000314007,

372

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES = 1000325000,

373

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES = 1000335000,

374

VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2 = 1000337000,

375

VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2 = 1000337001,

376

VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2 = 1000337002,

377

VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2 = 1000337003,

378

VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2 = 1000337004,

379

VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2 = 1000337005,

380

VK_STRUCTURE_TYPE_BUFFER_COPY_2 = 1000337006,

381

VK_STRUCTURE_TYPE_IMAGE_COPY_2 = 1000337007,

382

VK_STRUCTURE_TYPE_IMAGE_BLIT_2 = 1000337008,

383

VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2 = 1000337009,

384

VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2 = 1000337010,

385

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES = 1000225000,

386

VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO = 1000225001,

387

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES = 1000225002,

388

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES = 1000138000,

389

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES = 1000138001,

390

VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK = 1000138002,

391

VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO = 1000138003,

392

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES = 1000066000,

393

VK_STRUCTURE_TYPE_RENDERING_INFO = 1000044000,

394

VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO = 1000044001,

395

VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO = 1000044002,

396

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES = 1000044003,

397

VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO = 1000044004,

398

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES = 1000280000,

399

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES = 1000280001,

400

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES = 1000281001,

401

VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3 = 1000360000,

402

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES = 1000413000,

403

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES = 1000413001,

404

VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS = 1000413002,

405

VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS = 1000413003,

406

VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000,

407

VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001,

408

VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR = 1000060007,

409

VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR = 1000060008,

410

VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR = 1000060009,

411

VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR = 1000060010,

412

VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR = 1000060011,

413

VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR = 1000060012,

414

VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000,

415

VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001,

416

VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000,

417

VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000,

418

VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000,

419

VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000,

420

VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000,

421

VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000,

422

VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = 1000011000,

423

VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = 1000018000,

424

VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = 1000022000,

425

VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = 1000022001,

426

VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = 1000022002,

427

#ifdef VK_ENABLE_BETA_EXTENSIONS

428

VK_STRUCTURE_TYPE_VIDEO_PROFILE_KHR = 1000023000,

429

#endif

430

#ifdef VK_ENABLE_BETA_EXTENSIONS

431

VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR = 1000023001,

432

#endif

433

#ifdef VK_ENABLE_BETA_EXTENSIONS

434

VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_KHR = 1000023002,

435

#endif

436

#ifdef VK_ENABLE_BETA_EXTENSIONS

437

VK_STRUCTURE_TYPE_VIDEO_GET_MEMORY_PROPERTIES_KHR = 1000023003,

438

#endif

439

#ifdef VK_ENABLE_BETA_EXTENSIONS

440

VK_STRUCTURE_TYPE_VIDEO_BIND_MEMORY_KHR = 1000023004,

441

#endif

442

#ifdef VK_ENABLE_BETA_EXTENSIONS

443

VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR = 1000023005,

444

#endif

445

#ifdef VK_ENABLE_BETA_EXTENSIONS

446

VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000023006,

447

#endif

448

#ifdef VK_ENABLE_BETA_EXTENSIONS

449

VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR = 1000023007,

450

#endif

451

#ifdef VK_ENABLE_BETA_EXTENSIONS

452

VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR = 1000023008,

453

#endif

454

#ifdef VK_ENABLE_BETA_EXTENSIONS

455

VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR = 1000023009,

456

#endif

457

#ifdef VK_ENABLE_BETA_EXTENSIONS

458

VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR = 1000023010,

459

#endif

460

#ifdef VK_ENABLE_BETA_EXTENSIONS

461

VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_KHR = 1000023011,

462

#endif

463

#ifdef VK_ENABLE_BETA_EXTENSIONS

464

VK_STRUCTURE_TYPE_VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR = 1000023012,

465

#endif

466

#ifdef VK_ENABLE_BETA_EXTENSIONS

467

VK_STRUCTURE_TYPE_VIDEO_PROFILES_KHR = 1000023013,

468

#endif

469

#ifdef VK_ENABLE_BETA_EXTENSIONS

470

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR = 1000023014,

471

#endif

472

#ifdef VK_ENABLE_BETA_EXTENSIONS

473

VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR = 1000023015,

474

#endif

475

#ifdef VK_ENABLE_BETA_EXTENSIONS

476

VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_2_KHR = 1000023016,

477

#endif

478

#ifdef VK_ENABLE_BETA_EXTENSIONS

479

VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR = 1000024000,

480

#endif

481

#ifdef VK_ENABLE_BETA_EXTENSIONS

482

VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR = 1000024001,

483

#endif

484

VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000,

485

VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001,

486

VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002,

487

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT = 1000028000,

488

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT = 1000028001,

489

VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT = 1000028002,

490

VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX = 1000029000,

491

VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX = 1000029001,

492

VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX = 1000029002,

493

VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX = 1000030000,

494

VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX = 1000030001,

495

#ifdef VK_ENABLE_BETA_EXTENSIONS

496

VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT = 1000038000,

497

#endif

498

#ifdef VK_ENABLE_BETA_EXTENSIONS

499

VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT = 1000038001,

500

#endif

501

#ifdef VK_ENABLE_BETA_EXTENSIONS

502

VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT = 1000038002,

503

#endif

504

#ifdef VK_ENABLE_BETA_EXTENSIONS

505

VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT = 1000038003,

506

#endif

507

#ifdef VK_ENABLE_BETA_EXTENSIONS

508

VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT = 1000038004,

509

#endif

510

#ifdef VK_ENABLE_BETA_EXTENSIONS

511

VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_EXT = 1000038005,

512

#endif

513

#ifdef VK_ENABLE_BETA_EXTENSIONS

514

VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT = 1000038006,

515

#endif

516

#ifdef VK_ENABLE_BETA_EXTENSIONS

517

VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_EXT = 1000038007,

518

#endif

519

#ifdef VK_ENABLE_BETA_EXTENSIONS

520

VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT = 1000038008,

521

#endif

522

#ifdef VK_ENABLE_BETA_EXTENSIONS

523

VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT = 1000038009,

524

#endif

525

#ifdef VK_ENABLE_BETA_EXTENSIONS

526

VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_REFERENCE_LISTS_EXT = 1000038010,

527

#endif

528

#ifdef VK_ENABLE_BETA_EXTENSIONS

529

VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT = 1000039000,

530

#endif

531

#ifdef VK_ENABLE_BETA_EXTENSIONS

532

VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT = 1000039001,

533

#endif

534

#ifdef VK_ENABLE_BETA_EXTENSIONS

535

VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT = 1000039002,

536

#endif

537

#ifdef VK_ENABLE_BETA_EXTENSIONS

538

VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT = 1000039003,

539

#endif

540

#ifdef VK_ENABLE_BETA_EXTENSIONS

541

VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT = 1000039004,

542

#endif

543

#ifdef VK_ENABLE_BETA_EXTENSIONS

544

VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_EXT = 1000039005,

545

#endif

546

#ifdef VK_ENABLE_BETA_EXTENSIONS

547

VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT = 1000039006,

548

#endif

549

#ifdef VK_ENABLE_BETA_EXTENSIONS

550

VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_EXT = 1000039007,

551

#endif

552

#ifdef VK_ENABLE_BETA_EXTENSIONS

553

VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_REFERENCE_LISTS_EXT = 1000039008,

554

#endif

555

#ifdef VK_ENABLE_BETA_EXTENSIONS

556

VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT = 1000039009,

557

#endif

558

#ifdef VK_ENABLE_BETA_EXTENSIONS

559

VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT = 1000039010,

560

#endif

561

#ifdef VK_ENABLE_BETA_EXTENSIONS

562

VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT = 1000040000,

563

#endif

564

#ifdef VK_ENABLE_BETA_EXTENSIONS

565

VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT = 1000040001,

566

#endif

567

#ifdef VK_ENABLE_BETA_EXTENSIONS

568

VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_EXT = 1000040002,

569

#endif

570

#ifdef VK_ENABLE_BETA_EXTENSIONS

571

VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_EXT = 1000040003,

572

#endif

573

#ifdef VK_ENABLE_BETA_EXTENSIONS

574

VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT = 1000040004,

575

#endif

576

#ifdef VK_ENABLE_BETA_EXTENSIONS

577

VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT = 1000040005,

578

#endif

579

#ifdef VK_ENABLE_BETA_EXTENSIONS

580

VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT = 1000040006,

581

#endif

582

VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD = 1000041000,

583

VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR = 1000044006,

584

VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT = 1000044007,

585

VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD = 1000044008,

586

VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX = 1000044009,

587

VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP = 1000049000,

588

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV = 1000050000,

589

VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = 1000056000,

590

VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV = 1000056001,

591

VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057000,

592

VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057001,

593

VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV = 1000058000,

594

VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT = 1000061000,

595

VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN = 1000062000,

596

VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT = 1000067000,

597

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT = 1000067001,

598

VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073000,

599

VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073001,

600

VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR = 1000073002,

601

VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR = 1000073003,

602

VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR = 1000074000,

603

VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR = 1000074001,

604

VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR = 1000074002,

605

VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR = 1000075000,

606

VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078000,

607

VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078001,

608

VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR = 1000078002,

609

VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR = 1000078003,

610

VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR = 1000079000,

611

VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR = 1000079001,

612

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = 1000080000,

613

VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT = 1000081000,

614

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT = 1000081001,

615

VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT = 1000081002,

616

VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000,

617

VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV = 1000087000,

618

VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT = 1000090000,

619

VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT = 1000091000,

620

VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT = 1000091001,

621

VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT = 1000091002,

622

VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT = 1000091003,

623

VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE = 1000092000,

624

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX = 1000097000,

625

VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV = 1000098000,

626

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT = 1000099000,

627

VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT = 1000099001,

628

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT = 1000101000,

629

VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT = 1000101001,

630

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT = 1000102000,

631

VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT = 1000102001,

632

VK_STRUCTURE_TYPE_HDR_METADATA_EXT = 1000105000,

633

VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR = 1000111000,

634

VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114000,

635

VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114001,

636

VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR = 1000114002,

637

VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR = 1000115000,

638

VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR = 1000115001,

639

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR = 1000116000,

640

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR = 1000116001,

641

VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR = 1000116002,

642

VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR = 1000116003,

643

VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR = 1000116004,

644

VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR = 1000116005,

645

VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR = 1000116006,

646

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000,

647

VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR = 1000119001,

648

VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR = 1000119002,

649

VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR = 1000121000,

650

VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR = 1000121001,

651

VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR = 1000121002,

652

VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR = 1000121003,

653

VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR = 1000121004,

654

VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK = 1000122000,

655

VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK = 1000123000,

656

VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT = 1000128000,

657

VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT = 1000128001,

658

VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT = 1000128002,

659

VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT = 1000128003,

660

VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT = 1000128004,

661

VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID = 1000129000,

662

VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID = 1000129001,

663

VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID = 1000129002,

664

VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129003,

665

VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129004,

666

VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID = 1000129005,

667

VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID = 1000129006,

668

VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT = 1000143000,

669

VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT = 1000143001,

670

VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT = 1000143002,

671

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT = 1000143003,

672

VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT = 1000143004,

673

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT = 1000148000,

674

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT = 1000148001,

675

VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT = 1000148002,

676

VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV = 1000149000,

677

VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR = 1000150007,

678

VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR = 1000150000,

679

VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR = 1000150002,

680

VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR = 1000150003,

681

VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR = 1000150004,

682

VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR = 1000150005,

683

VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR = 1000150006,

684

VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR = 1000150009,

685

VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR = 1000150010,

686

VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR = 1000150011,

687

VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR = 1000150012,

688

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR = 1000150013,

689

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR = 1000150014,

690

VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR = 1000150017,

691

VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR = 1000150020,

692

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR = 1000347000,

693

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR = 1000347001,

694

VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR = 1000150015,

695

VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR = 1000150016,

696

VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR = 1000150018,

697

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR = 1000348013,

698

VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV = 1000152000,

699

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV = 1000154000,

700

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV = 1000154001,

701

VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT = 1000158000,

702

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT = 1000158002,

703

VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT = 1000158003,

704

VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT = 1000158004,

705

VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT = 1000158005,

706

VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT = 1000158006,

707

VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160000,

708

VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160001,

709

#ifdef VK_ENABLE_BETA_EXTENSIONS

710

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR = 1000163000,

711

#endif

712

#ifdef VK_ENABLE_BETA_EXTENSIONS

713

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR = 1000163001,

714

#endif

715

VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV = 1000164000,

716

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV = 1000164001,

717

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV = 1000164002,

718

VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV = 1000164005,

719

VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV = 1000165000,

720

VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV = 1000165001,

721

VK_STRUCTURE_TYPE_GEOMETRY_NV = 1000165003,

722

VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV = 1000165004,

723

VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV = 1000165005,

724

VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV = 1000165006,

725

VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV = 1000165007,

726

VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV = 1000165008,

727

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV = 1000165009,

728

VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV = 1000165011,

729

VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV = 1000165012,

730

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV = 1000166000,

731

VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV = 1000166001,

732

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT = 1000170000,

733

VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT = 1000170001,

734

VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT = 1000178000,

735

VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT = 1000178001,

736

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT = 1000178002,

737

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR = 1000181000,

738

VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD = 1000183000,

739

VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT = 1000184000,

740

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD = 1000185000,

741

#ifdef VK_ENABLE_BETA_EXTENSIONS

742

VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT = 1000187000,

743

#endif

744

#ifdef VK_ENABLE_BETA_EXTENSIONS

745

VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT = 1000187001,

746

#endif

747

#ifdef VK_ENABLE_BETA_EXTENSIONS

748

VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT = 1000187002,

749

#endif

750

#ifdef VK_ENABLE_BETA_EXTENSIONS

751

VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_EXT = 1000187003,

752

#endif

753

#ifdef VK_ENABLE_BETA_EXTENSIONS

754

VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT = 1000187004,

755

#endif

756

#ifdef VK_ENABLE_BETA_EXTENSIONS

757

VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT = 1000187005,

758

#endif

759

VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR = 1000174000,

760

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR = 1000388000,

761

VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR = 1000388001,

762

VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD = 1000189000,

763

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT = 1000190000,

764

VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT = 1000190001,

765

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT = 1000190002,

766

VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP = 1000191000,

767

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV = 1000201000,

768

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV = 1000202000,

769

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV = 1000202001,

770

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV = 1000203000,

771

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV = 1000204000,

772

VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV = 1000205000,

773

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV = 1000205002,

774

VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV = 1000206000,

775

VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV = 1000206001,

776

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL = 1000209000,

777

VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL = 1000210000,

778

VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL = 1000210001,

779

VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL = 1000210002,

780

VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL = 1000210003,

781

VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL = 1000210004,

782

VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL = 1000210005,

783

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT = 1000212000,

784

VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD = 1000213000,

785

VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD = 1000213001,

786

VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA = 1000214000,

787

VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT = 1000217000,

788

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT = 1000218000,

789

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT = 1000218001,

790

VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT = 1000218002,

791

VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR = 1000226000,

792

VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR = 1000226001,

793

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR = 1000226002,

794

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR = 1000226003,

795

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR = 1000226004,

796

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD = 1000227000,

797

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD = 1000229000,

798

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT = 1000234000,

799

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT = 1000237000,

800

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT = 1000238000,

801

VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT = 1000238001,

802

VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR = 1000239000,

803

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV = 1000240000,

804

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT = 1000244000,

805

VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT = 1000244002,

806

VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT = 1000247000,

807

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR = 1000248000,

808

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV = 1000249000,

809

VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV = 1000249001,

810

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV = 1000249002,

811

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV = 1000250000,

812

VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV = 1000250001,

813

VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV = 1000250002,

814

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT = 1000251000,

815

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT = 1000252000,

816

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT = 1000254000,

817

VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT = 1000254001,

818

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT = 1000254002,

819

VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT = 1000255000,

820

VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT = 1000255002,

821

VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT = 1000255001,

822

VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT = 1000256000,

823

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT = 1000259000,

824

VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT = 1000259001,

825

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT = 1000259002,

826

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT = 1000260000,

827

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT = 1000265000,

828

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT = 1000267000,

829

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR = 1000269000,

830

VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR = 1000269001,

831

VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR = 1000269002,

832

VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR = 1000269003,

833

VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR = 1000269004,

834

VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR = 1000269005,

835

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT = 1000273000,

836

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV = 1000277000,

837

VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV = 1000277001,

838

VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV = 1000277002,

839

VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV = 1000277003,

840

VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV = 1000277004,

841

VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV = 1000277005,

842

VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV = 1000277006,

843

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV = 1000277007,

844

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV = 1000278000,

845

VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV = 1000278001,

846

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT = 1000281000,

847

VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM = 1000282000,

848

VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM = 1000282001,

849

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT = 1000284000,

850

VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT = 1000284001,

851

VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT = 1000284002,

852

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT = 1000286000,

853

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT = 1000286001,

854

VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT = 1000287000,

855

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT = 1000287001,

856

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT = 1000287002,

857

VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR = 1000290000,

858

VK_STRUCTURE_TYPE_PRESENT_ID_KHR = 1000294000,

859

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR = 1000294001,

860

#ifdef VK_ENABLE_BETA_EXTENSIONS

861

VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR = 1000299000,

862

#endif

863

#ifdef VK_ENABLE_BETA_EXTENSIONS

864

VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR = 1000299001,

865

#endif

866

#ifdef VK_ENABLE_BETA_EXTENSIONS

867

VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR = 1000299002,

868

#endif

869

#ifdef VK_ENABLE_BETA_EXTENSIONS

870

VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR = 1000299003,

871

#endif

872

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV = 1000300000,

873

VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV = 1000300001,

874

VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV = 1000314008,

875

VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV = 1000314009,

876

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT = 1000320000,

877

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT = 1000320001,

878

VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT = 1000320002,

879

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR = 1000323000,

880

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV = 1000326000,

881

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV = 1000326001,

882

VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV = 1000326002,

883

VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV = 1000327000,

884

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV = 1000327001,

885

VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV = 1000327002,

886

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT = 1000330000,

887

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT = 1000332000,

888

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT = 1000332001,

889

VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM = 1000333000,

890

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR = 1000336000,

891

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT = 1000340000,

892

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_ARM = 1000342000,

893

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT = 1000344000,

894

VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT = 1000346000,

895

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE = 1000351000,

896

VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE = 1000351002,

897

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT = 1000352000,

898

VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT = 1000352001,

899

VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT = 1000352002,

900

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT = 1000353000,

901

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT = 1000355000,

902

VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT = 1000355001,

903

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT = 1000356000,

904

VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA = 1000364000,

905

VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA = 1000364001,

906

VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA = 1000364002,

907

VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA = 1000365000,

908

VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA = 1000365001,

909

VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA = 1000366000,

910

VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA = 1000366001,

911

VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA = 1000366002,

912

VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA = 1000366003,

913

VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA = 1000366004,

914

VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA = 1000366005,

915

VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA = 1000366006,

916

VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA = 1000366007,

917

VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA = 1000366008,

918

VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA = 1000366009,

919

VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI = 1000369000,

920

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI = 1000369001,

921

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI = 1000369002,

922

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI = 1000370000,

923

VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV = 1000371000,

924

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV = 1000371001,

925

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT = 1000377000,

926

VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX = 1000378000,

927

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT = 1000381000,

928

VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT = 1000381001,

929

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT = 1000382000,

930

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT = 1000391000,

931

VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT = 1000391001,

932

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT = 1000392000,

933

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT = 1000392001,

934

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT = 1000393000,

935

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT = 1000411000,

936

VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT = 1000411001,

937

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT = 1000412000,

938

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE = 1000420000,

939

VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE = 1000420001,

940

VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE = 1000420002,

941

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM = 1000425000,

942

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM = 1000425001,

943

VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM = 1000425002,

944

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV = 1000430000,

945

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,

946

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES,

947

VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT,

948

VK_STRUCTURE_TYPE_RENDERING_INFO_KHR = VK_STRUCTURE_TYPE_RENDERING_INFO,

949

VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO,

950

VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO,

951

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES,

952

VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO,

953

VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_NV = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD,

954

VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO,

955

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES,

956

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES,

957

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2,

958

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2,

959

VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2,

960

VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2,

961

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,

962

VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2,

963

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2,

964

VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2,

965

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2,

966

VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO,

967

VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO,

968

VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO,

969

VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO,

970

VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO,

971

VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO,

972

VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO,

973

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES,

974

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES,

975

VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO,

976

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO,

977

VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES,

978

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO,

979

VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES,

980

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES,

981

VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO,

982

VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO,

983

VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO,

984

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO,

985

VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES,

986

VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO,

987

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES,

988

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES,

989

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES,

990

VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO,

991

VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT,

992

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES,

993

VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO,

994

VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO,

995

VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO,

996

VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2,

997

VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2,

998

VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2,

999

VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2_KHR = VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2,

1000

VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2,

1001

VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO,

1002

VK_STRUCTURE_TYPE_SUBPASS_END_INFO_KHR = VK_STRUCTURE_TYPE_SUBPASS_END_INFO,

1003

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO,

1004

VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES,

1005

VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO,

1006

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES,

1007

VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO,

1008

VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO,

1009

VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO,

1010

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,

1011

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR,

1012

VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS,

1013

VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,

1014

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES,

1015

VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO,

1016

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES,

1017

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES,

1018

VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK,

1019

VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO,

1020

VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2,

1021

VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2,

1022

VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2,

1023

VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2,

1024

VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2,

1025

VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO,

1026

VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO,

1027

VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO,

1028

VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO,

1029

VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO,

1030

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES,

1031

VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES,

1032

VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO,

1033

VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO,

1034

VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO,

1035

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES,

1036

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES,

1037

VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO,

1038

VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT,

1039

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES,

1040

VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT,

1041

VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR,

1042

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES,

1043

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES,

1044

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES,

1045

VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO,

1046

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES,

1047

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES,

1048

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES,

1049

VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE,

1050

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES,

1051

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES,

1052

VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO,

1053

VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO,

1054

VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO_KHR = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO,

1055

VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO_KHR = VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO,

1056

VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL,

1057

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES,

1058

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES,

1059

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES,

1060

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES,

1061

VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO,

1062

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES,

1063

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES,

1064

VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT,

1065

VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT,

1066

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT,

1067

VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO,

1068

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES,

1069

VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO,

1070

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES,

1071

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES,

1072

VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO,

1073

VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO,

1074

VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO,

1075

VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO,

1076

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES,

1077

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES,

1078

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES,

1079

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES,

1080

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES,

1081

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES,

1082

VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO,

1083

VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO,

1084

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES,

1085

VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2,

1086

VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2_KHR = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2,

1087

VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2_KHR = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2,

1088

VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR = VK_STRUCTURE_TYPE_DEPENDENCY_INFO,

1089

VK_STRUCTURE_TYPE_SUBMIT_INFO_2_KHR = VK_STRUCTURE_TYPE_SUBMIT_INFO_2,

1090

VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO,

1091

VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO_KHR = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO,

1092

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES,

1093

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES,

1094

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES,

1095

VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR = VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2,

1096

VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR = VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2,

1097

VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR = VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2,

1098

VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2,

1099

VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR = VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2,

1100

VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR = VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2,

1101

VK_STRUCTURE_TYPE_BUFFER_COPY_2_KHR = VK_STRUCTURE_TYPE_BUFFER_COPY_2,

1102

VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR = VK_STRUCTURE_TYPE_IMAGE_COPY_2,

1103

VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR = VK_STRUCTURE_TYPE_IMAGE_BLIT_2,

1104

VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR = VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2,

1105

VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR = VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2,

1106

VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3,

1107

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR,

1108

VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR,

1109

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES,

1110

VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES,

1111

VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR = VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS,

1112

VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR = VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS,

1113

VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF

1114

} VkStructureType;

1115

1116

typedef enum VkImageLayout {

1117

VK_IMAGE_LAYOUT_UNDEFINED = 0,

1118

VK_IMAGE_LAYOUT_GENERAL = 1,

1119

VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2,

1120

VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3,

1121

VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4,

1122

VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5,

1123

VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6,

1124

VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7,

1125

VK_IMAGE_LAYOUT_PREINITIALIZED = 8,

1126

VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL = 1000117000,

1127

VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL = 1000117001,

1128

VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL = 1000241000,

1129

VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL = 1000241001,

1130

VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL = 1000241002,

1131

VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL = 1000241003,

1132

VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL = 1000314000,

1133

VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL = 1000314001,

1134

VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002,

1135

#ifdef VK_ENABLE_BETA_EXTENSIONS

1136

VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR = 1000024000,

1137

#endif

1138

#ifdef VK_ENABLE_BETA_EXTENSIONS

1139

VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR = 1000024001,

1140

#endif

1141

#ifdef VK_ENABLE_BETA_EXTENSIONS

1142

VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR = 1000024002,

1143

#endif

1144

VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR = 1000111000,

1145

VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT = 1000218000,

1146

VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR = 1000164003,

1147

#ifdef VK_ENABLE_BETA_EXTENSIONS

1148

VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR = 1000299000,

1149

#endif

1150

#ifdef VK_ENABLE_BETA_EXTENSIONS

1151

VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR = 1000299001,

1152

#endif

1153

#ifdef VK_ENABLE_BETA_EXTENSIONS

1154

VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR = 1000299002,

1155

#endif

1156

VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL,

1157

VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL,

1158

VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV = VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR,

1159

VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL,

1160

VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL,

1161

VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL,

1162

VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL,

1163

VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL,

1164

VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL,

1165

VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF

1166

} VkImageLayout;

1167

1168

typedef enum VkObjectType {

1169

VK_OBJECT_TYPE_UNKNOWN = 0,

1170

VK_OBJECT_TYPE_INSTANCE = 1,

1171

VK_OBJECT_TYPE_PHYSICAL_DEVICE = 2,

1172

VK_OBJECT_TYPE_DEVICE = 3,

1173

VK_OBJECT_TYPE_QUEUE = 4,

1174

VK_OBJECT_TYPE_SEMAPHORE = 5,

1175

VK_OBJECT_TYPE_COMMAND_BUFFER = 6,

1176

VK_OBJECT_TYPE_FENCE = 7,

1177

VK_OBJECT_TYPE_DEVICE_MEMORY = 8,

1178

VK_OBJECT_TYPE_BUFFER = 9,

1179

VK_OBJECT_TYPE_IMAGE = 10,

1180

VK_OBJECT_TYPE_EVENT = 11,

1181

VK_OBJECT_TYPE_QUERY_POOL = 12,

1182

VK_OBJECT_TYPE_BUFFER_VIEW = 13,

1183

VK_OBJECT_TYPE_IMAGE_VIEW = 14,

1184

VK_OBJECT_TYPE_SHADER_MODULE = 15,

1185

VK_OBJECT_TYPE_PIPELINE_CACHE = 16,

1186

VK_OBJECT_TYPE_PIPELINE_LAYOUT = 17,

1187

VK_OBJECT_TYPE_RENDER_PASS = 18,

1188

VK_OBJECT_TYPE_PIPELINE = 19,

1189

VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 20,

1190

VK_OBJECT_TYPE_SAMPLER = 21,

1191

VK_OBJECT_TYPE_DESCRIPTOR_POOL = 22,

1192

VK_OBJECT_TYPE_DESCRIPTOR_SET = 23,

1193

VK_OBJECT_TYPE_FRAMEBUFFER = 24,

1194

VK_OBJECT_TYPE_COMMAND_POOL = 25,

1195

VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION = 1000156000,

1196

VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE = 1000085000,

1197

VK_OBJECT_TYPE_PRIVATE_DATA_SLOT = 1000295000,

1198

VK_OBJECT_TYPE_SURFACE_KHR = 1000000000,

1199

VK_OBJECT_TYPE_SWAPCHAIN_KHR = 1000001000,

1200

VK_OBJECT_TYPE_DISPLAY_KHR = 1000002000,

1201

VK_OBJECT_TYPE_DISPLAY_MODE_KHR = 1000002001,

1202

VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT = 1000011000,

1203

#ifdef VK_ENABLE_BETA_EXTENSIONS

1204

VK_OBJECT_TYPE_VIDEO_SESSION_KHR = 1000023000,

1205

#endif

1206

#ifdef VK_ENABLE_BETA_EXTENSIONS

1207

VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR = 1000023001,

1208

#endif

1209

VK_OBJECT_TYPE_CU_MODULE_NVX = 1000029000,

1210

VK_OBJECT_TYPE_CU_FUNCTION_NVX = 1000029001,

1211

VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT = 1000128000,

1212

VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR = 1000150000,

1213

VK_OBJECT_TYPE_VALIDATION_CACHE_EXT = 1000160000,

1214

VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000,

1215

VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL = 1000210000,

1216

VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR = 1000268000,

1217

VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV = 1000277000,

1218

VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA = 1000366000,

1219

VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE,

1220

VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION,

1221

VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT = VK_OBJECT_TYPE_PRIVATE_DATA_SLOT,

1222

VK_OBJECT_TYPE_MAX_ENUM = 0x7FFFFFFF

1223

} VkObjectType;

1224

1225

typedef enum VkPipelineCacheHeaderVersion {

1226

VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1,

1227

VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF

1228

} VkPipelineCacheHeaderVersion;

1229

1230

typedef enum VkVendorId {

1231

VK_VENDOR_ID_VIV = 0x10001,

1232

VK_VENDOR_ID_VSI = 0x10002,

1233

VK_VENDOR_ID_KAZAN = 0x10003,

1234

VK_VENDOR_ID_CODEPLAY = 0x10004,

1235

VK_VENDOR_ID_MESA = 0x10005,

1236

VK_VENDOR_ID_POCL = 0x10006,

1237

VK_VENDOR_ID_MAX_ENUM = 0x7FFFFFFF

1238

} VkVendorId;

1239

1240

typedef enum VkSystemAllocationScope {

1241

VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0,

1242

VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1,

1243

VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2,

1244

VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3,

1245

VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4,

1246

VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF

1247

} VkSystemAllocationScope;

1248

1249

typedef enum VkInternalAllocationType {

1250

VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0,

1251

VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF

1252

} VkInternalAllocationType;

1253

1254

typedef enum VkFormat {

1255

VK_FORMAT_UNDEFINED = 0,

1256

VK_FORMAT_R4G4_UNORM_PACK8 = 1,

1257

VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2,

1258

VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3,

1259

VK_FORMAT_R5G6B5_UNORM_PACK16 = 4,

1260

VK_FORMAT_B5G6R5_UNORM_PACK16 = 5,

1261

VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6,

1262

VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7,

1263

VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8,

1264

VK_FORMAT_R8_UNORM = 9,

1265

VK_FORMAT_R8_SNORM = 10,

1266

VK_FORMAT_R8_USCALED = 11,

1267

VK_FORMAT_R8_SSCALED = 12,

1268

VK_FORMAT_R8_UINT = 13,

1269

VK_FORMAT_R8_SINT = 14,

1270

VK_FORMAT_R8_SRGB = 15,

1271

VK_FORMAT_R8G8_UNORM = 16,

1272

VK_FORMAT_R8G8_SNORM = 17,

1273

VK_FORMAT_R8G8_USCALED = 18,

1274

VK_FORMAT_R8G8_SSCALED = 19,

1275

VK_FORMAT_R8G8_UINT = 20,

1276

VK_FORMAT_R8G8_SINT = 21,

1277

VK_FORMAT_R8G8_SRGB = 22,

1278

VK_FORMAT_R8G8B8_UNORM = 23,

1279

VK_FORMAT_R8G8B8_SNORM = 24,

1280

VK_FORMAT_R8G8B8_USCALED = 25,

1281

VK_FORMAT_R8G8B8_SSCALED = 26,

1282

VK_FORMAT_R8G8B8_UINT = 27,

1283

VK_FORMAT_R8G8B8_SINT = 28,

1284

VK_FORMAT_R8G8B8_SRGB = 29,

1285

VK_FORMAT_B8G8R8_UNORM = 30,

1286

VK_FORMAT_B8G8R8_SNORM = 31,

1287

VK_FORMAT_B8G8R8_USCALED = 32,

1288

VK_FORMAT_B8G8R8_SSCALED = 33,

1289

VK_FORMAT_B8G8R8_UINT = 34,

1290

VK_FORMAT_B8G8R8_SINT = 35,

1291

VK_FORMAT_B8G8R8_SRGB = 36,

1292

VK_FORMAT_R8G8B8A8_UNORM = 37,

1293

VK_FORMAT_R8G8B8A8_SNORM = 38,

1294

VK_FORMAT_R8G8B8A8_USCALED = 39,

1295

VK_FORMAT_R8G8B8A8_SSCALED = 40,

1296

VK_FORMAT_R8G8B8A8_UINT = 41,

1297

VK_FORMAT_R8G8B8A8_SINT = 42,

1298

VK_FORMAT_R8G8B8A8_SRGB = 43,

1299

VK_FORMAT_B8G8R8A8_UNORM = 44,

1300

VK_FORMAT_B8G8R8A8_SNORM = 45,

1301

VK_FORMAT_B8G8R8A8_USCALED = 46,

1302

VK_FORMAT_B8G8R8A8_SSCALED = 47,

1303

VK_FORMAT_B8G8R8A8_UINT = 48,

1304

VK_FORMAT_B8G8R8A8_SINT = 49,

1305

VK_FORMAT_B8G8R8A8_SRGB = 50,

1306

VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51,

1307

VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52,

1308

VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53,

1309

VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54,

1310

VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55,

1311

VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56,

1312

VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57,

1313

VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58,

1314

VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59,

1315

VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60,

1316

VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61,

1317

VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62,

1318

VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63,

1319

VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64,

1320

VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65,

1321

VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66,

1322

VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67,

1323

VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68,

1324

VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69,

1325

VK_FORMAT_R16_UNORM = 70,

1326

VK_FORMAT_R16_SNORM = 71,

1327

VK_FORMAT_R16_USCALED = 72,

1328

VK_FORMAT_R16_SSCALED = 73,

1329

VK_FORMAT_R16_UINT = 74,

1330

VK_FORMAT_R16_SINT = 75,

1331

VK_FORMAT_R16_SFLOAT = 76,

1332

VK_FORMAT_R16G16_UNORM = 77,

1333

VK_FORMAT_R16G16_SNORM = 78,

1334

VK_FORMAT_R16G16_USCALED = 79,

1335

VK_FORMAT_R16G16_SSCALED = 80,

1336

VK_FORMAT_R16G16_UINT = 81,

1337

VK_FORMAT_R16G16_SINT = 82,

1338

VK_FORMAT_R16G16_SFLOAT = 83,

1339

VK_FORMAT_R16G16B16_UNORM = 84,

1340

VK_FORMAT_R16G16B16_SNORM = 85,

1341

VK_FORMAT_R16G16B16_USCALED = 86,

1342

VK_FORMAT_R16G16B16_SSCALED = 87,

1343

VK_FORMAT_R16G16B16_UINT = 88,

1344

VK_FORMAT_R16G16B16_SINT = 89,

1345

VK_FORMAT_R16G16B16_SFLOAT = 90,

1346

VK_FORMAT_R16G16B16A16_UNORM = 91,

1347

VK_FORMAT_R16G16B16A16_SNORM = 92,

1348

VK_FORMAT_R16G16B16A16_USCALED = 93,

1349

VK_FORMAT_R16G16B16A16_SSCALED = 94,

1350

VK_FORMAT_R16G16B16A16_UINT = 95,

1351

VK_FORMAT_R16G16B16A16_SINT = 96,

1352

VK_FORMAT_R16G16B16A16_SFLOAT = 97,

1353

VK_FORMAT_R32_UINT = 98,

1354

VK_FORMAT_R32_SINT = 99,

1355

VK_FORMAT_R32_SFLOAT = 100,

1356

VK_FORMAT_R32G32_UINT = 101,

1357

VK_FORMAT_R32G32_SINT = 102,

1358

VK_FORMAT_R32G32_SFLOAT = 103,

1359

VK_FORMAT_R32G32B32_UINT = 104,

1360

VK_FORMAT_R32G32B32_SINT = 105,

1361

VK_FORMAT_R32G32B32_SFLOAT = 106,

1362

VK_FORMAT_R32G32B32A32_UINT = 107,

1363

VK_FORMAT_R32G32B32A32_SINT = 108,

1364

VK_FORMAT_R32G32B32A32_SFLOAT = 109,

1365

VK_FORMAT_R64_UINT = 110,

1366

VK_FORMAT_R64_SINT = 111,

1367

VK_FORMAT_R64_SFLOAT = 112,

1368

VK_FORMAT_R64G64_UINT = 113,

1369

VK_FORMAT_R64G64_SINT = 114,

1370

VK_FORMAT_R64G64_SFLOAT = 115,

1371

VK_FORMAT_R64G64B64_UINT = 116,

1372

VK_FORMAT_R64G64B64_SINT = 117,

1373

VK_FORMAT_R64G64B64_SFLOAT = 118,

1374

VK_FORMAT_R64G64B64A64_UINT = 119,

1375

VK_FORMAT_R64G64B64A64_SINT = 120,

1376

VK_FORMAT_R64G64B64A64_SFLOAT = 121,

1377

VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122,

1378

VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123,

1379

VK_FORMAT_D16_UNORM = 124,

1380

VK_FORMAT_X8_D24_UNORM_PACK32 = 125,

1381

VK_FORMAT_D32_SFLOAT = 126,

1382

VK_FORMAT_S8_UINT = 127,

1383

VK_FORMAT_D16_UNORM_S8_UINT = 128,

1384

VK_FORMAT_D24_UNORM_S8_UINT = 129,

1385

VK_FORMAT_D32_SFLOAT_S8_UINT = 130,

1386

VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131,

1387

VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132,

1388

VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133,

1389

VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134,

1390

VK_FORMAT_BC2_UNORM_BLOCK = 135,

1391

VK_FORMAT_BC2_SRGB_BLOCK = 136,

1392

VK_FORMAT_BC3_UNORM_BLOCK = 137,

1393

VK_FORMAT_BC3_SRGB_BLOCK = 138,

1394

VK_FORMAT_BC4_UNORM_BLOCK = 139,

1395

VK_FORMAT_BC4_SNORM_BLOCK = 140,

1396

VK_FORMAT_BC5_UNORM_BLOCK = 141,

1397

VK_FORMAT_BC5_SNORM_BLOCK = 142,

1398

VK_FORMAT_BC6H_UFLOAT_BLOCK = 143,

1399

VK_FORMAT_BC6H_SFLOAT_BLOCK = 144,

1400

VK_FORMAT_BC7_UNORM_BLOCK = 145,

1401

VK_FORMAT_BC7_SRGB_BLOCK = 146,

1402

VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147,

1403

VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148,

1404

VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149,

1405

VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150,

1406

VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151,

1407

VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152,

1408

VK_FORMAT_EAC_R11_UNORM_BLOCK = 153,

1409

VK_FORMAT_EAC_R11_SNORM_BLOCK = 154,

1410

VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155,

1411

VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156,

1412

VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157,

1413

VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158,

1414

VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159,

1415

VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160,

1416

VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161,

1417

VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162,

1418

VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163,

1419

VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164,

1420

VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165,

1421

VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166,

1422

VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167,

1423

VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168,

1424

VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169,

1425

VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170,

1426

VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171,

1427

VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172,

1428

VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173,

1429

VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174,

1430

VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175,

1431

VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176,

1432

VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177,

1433

VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178,

1434

VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179,

1435

VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180,

1436

VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181,

1437

VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182,

1438

VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183,

1439

VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184,

1440

VK_FORMAT_G8B8G8R8_422_UNORM = 1000156000,

1441

VK_FORMAT_B8G8R8G8_422_UNORM = 1000156001,

1442

VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM = 1000156002,

1443

VK_FORMAT_G8_B8R8_2PLANE_420_UNORM = 1000156003,

1444

VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM = 1000156004,

1445

VK_FORMAT_G8_B8R8_2PLANE_422_UNORM = 1000156005,

1446

VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM = 1000156006,

1447

VK_FORMAT_R10X6_UNORM_PACK16 = 1000156007,

1448

VK_FORMAT_R10X6G10X6_UNORM_2PACK16 = 1000156008,

1449

VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 = 1000156009,

1450

VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 = 1000156010,

1451

VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 = 1000156011,

1452

VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 = 1000156012,

1453

VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 = 1000156013,

1454

VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 = 1000156014,

1455

VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 = 1000156015,

1456

VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 = 1000156016,

1457

VK_FORMAT_R12X4_UNORM_PACK16 = 1000156017,

1458

VK_FORMAT_R12X4G12X4_UNORM_2PACK16 = 1000156018,

1459

VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 = 1000156019,

1460

VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 = 1000156020,

1461

VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 = 1000156021,

1462

VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 = 1000156022,

1463

VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 = 1000156023,

1464

VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 = 1000156024,

1465

VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 = 1000156025,

1466

VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 = 1000156026,

1467

VK_FORMAT_G16B16G16R16_422_UNORM = 1000156027,

1468

VK_FORMAT_B16G16R16G16_422_UNORM = 1000156028,

1469

VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM = 1000156029,

1470

VK_FORMAT_G16_B16R16_2PLANE_420_UNORM = 1000156030,

1471

VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM = 1000156031,

1472

VK_FORMAT_G16_B16R16_2PLANE_422_UNORM = 1000156032,

1473

VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM = 1000156033,

1474

VK_FORMAT_G8_B8R8_2PLANE_444_UNORM = 1000330000,

1475

VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16 = 1000330001,

1476

VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16 = 1000330002,

1477

VK_FORMAT_G16_B16R16_2PLANE_444_UNORM = 1000330003,

1478

VK_FORMAT_A4R4G4B4_UNORM_PACK16 = 1000340000,

1479

VK_FORMAT_A4B4G4R4_UNORM_PACK16 = 1000340001,

1480

VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK = 1000066000,

1481

VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK = 1000066001,

1482

VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK = 1000066002,

1483

VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK = 1000066003,

1484

VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK = 1000066004,

1485

VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK = 1000066005,

1486

VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK = 1000066006,

1487

VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK = 1000066007,

1488

VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK = 1000066008,

1489

VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK = 1000066009,

1490

VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK = 1000066010,

1491

VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK = 1000066011,

1492

VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK = 1000066012,

1493

VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK = 1000066013,

1494

VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG = 1000054000,

1495

VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG = 1000054001,

1496

VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG = 1000054002,

1497

VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG = 1000054003,

1498

VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG = 1000054004,

1499

VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005,

1500

VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006,

1501

VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007,

1502

VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK,

1503

VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK,

1504

VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK,

1505

VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK,

1506

VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK,

1507

VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK,

1508

VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK,

1509

VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK,

1510

VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK,

1511

VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK,

1512

VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK,

1513

VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK,

1514

VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK,

1515

VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK,

1516

VK_FORMAT_G8B8G8R8_422_UNORM_KHR = VK_FORMAT_G8B8G8R8_422_UNORM,

1517

VK_FORMAT_B8G8R8G8_422_UNORM_KHR = VK_FORMAT_B8G8R8G8_422_UNORM,

1518

VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM,

1519

VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM,

1520

VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM,

1521

VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM,

1522

VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM,

1523

VK_FORMAT_R10X6_UNORM_PACK16_KHR = VK_FORMAT_R10X6_UNORM_PACK16,

1524

VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR = VK_FORMAT_R10X6G10X6_UNORM_2PACK16,

1525

VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR = VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16,

1526

VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR = VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16,

1527

VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16,

1528

VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16,

1529

VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16,

1530

VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16,

1531

VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16,

1532

VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16,

1533

VK_FORMAT_R12X4_UNORM_PACK16_KHR = VK_FORMAT_R12X4_UNORM_PACK16,

1534

VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR = VK_FORMAT_R12X4G12X4_UNORM_2PACK16,

1535

VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR = VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16,

1536

VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR = VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16,

1537

VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR = VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16,

1538

VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16,

1539

VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16,

1540

VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16,

1541

VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16,

1542

VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16,

1543

VK_FORMAT_G16B16G16R16_422_UNORM_KHR = VK_FORMAT_G16B16G16R16_422_UNORM,

1544

VK_FORMAT_B16G16R16G16_422_UNORM_KHR = VK_FORMAT_B16G16R16G16_422_UNORM,

1545

VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM,

1546

VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR = VK_FORMAT_G16_B16R16_2PLANE_420_UNORM,

1547

VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM,

1548

VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR = VK_FORMAT_G16_B16R16_2PLANE_422_UNORM,

1549

VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM,

1550

VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT = VK_FORMAT_G8_B8R8_2PLANE_444_UNORM,

1551

VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16,

1552

VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16,

1553

VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT = VK_FORMAT_G16_B16R16_2PLANE_444_UNORM,

1554

VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT = VK_FORMAT_A4R4G4B4_UNORM_PACK16,

1555

VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT = VK_FORMAT_A4B4G4R4_UNORM_PACK16,

1556

VK_FORMAT_MAX_ENUM = 0x7FFFFFFF

1557

} VkFormat;

1558

1559

typedef enum VkImageTiling {

1560

VK_IMAGE_TILING_OPTIMAL = 0,

1561

VK_IMAGE_TILING_LINEAR = 1,

1562

VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT = 1000158000,

1563

VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF

1564

} VkImageTiling;

1565

1566

typedef enum VkImageType {

1567

VK_IMAGE_TYPE_1D = 0,

1568

VK_IMAGE_TYPE_2D = 1,

1569

VK_IMAGE_TYPE_3D = 2,

1570

VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF

1571

} VkImageType;

1572

1573

typedef enum VkPhysicalDeviceType {

1574

VK_PHYSICAL_DEVICE_TYPE_OTHER = 0,

1575

VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1,

1576

VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2,

1577

VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3,

1578

VK_PHYSICAL_DEVICE_TYPE_CPU = 4,

1579

VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF

1580

} VkPhysicalDeviceType;

1581

1582

typedef enum VkQueryType {

1583

VK_QUERY_TYPE_OCCLUSION = 0,

1584

VK_QUERY_TYPE_PIPELINE_STATISTICS = 1,

1585

VK_QUERY_TYPE_TIMESTAMP = 2,

1586

#ifdef VK_ENABLE_BETA_EXTENSIONS

1587

VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR = 1000023000,

1588

#endif

1589

VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT = 1000028004,

1590

VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR = 1000116000,

1591

VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR = 1000150000,

1592

VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR = 1000150001,

1593

VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV = 1000165000,

1594

VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL = 1000210000,

1595

#ifdef VK_ENABLE_BETA_EXTENSIONS

1596

VK_QUERY_TYPE_VIDEO_ENCODE_BITSTREAM_BUFFER_RANGE_KHR = 1000299000,

1597

#endif

1598

VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT = 1000382000,

1599

VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF

1600

} VkQueryType;

1601

1602

typedef enum VkSharingMode {

1603

VK_SHARING_MODE_EXCLUSIVE = 0,

1604

VK_SHARING_MODE_CONCURRENT = 1,

1605

VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF

1606

} VkSharingMode;

1607

1608

typedef enum VkComponentSwizzle {

1609

VK_COMPONENT_SWIZZLE_IDENTITY = 0,

1610

VK_COMPONENT_SWIZZLE_ZERO = 1,

1611

VK_COMPONENT_SWIZZLE_ONE = 2,

1612

VK_COMPONENT_SWIZZLE_R = 3,

1613

VK_COMPONENT_SWIZZLE_G = 4,

1614

VK_COMPONENT_SWIZZLE_B = 5,

1615

VK_COMPONENT_SWIZZLE_A = 6,

1616

VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF

1617

} VkComponentSwizzle;

1618

1619

typedef enum VkImageViewType {

1620

VK_IMAGE_VIEW_TYPE_1D = 0,

1621

VK_IMAGE_VIEW_TYPE_2D = 1,

1622

VK_IMAGE_VIEW_TYPE_3D = 2,

1623

VK_IMAGE_VIEW_TYPE_CUBE = 3,

1624

VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4,

1625

VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5,

1626

VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6,

1627

VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF

1628

} VkImageViewType;

1629

1630

typedef enum VkBlendFactor {

1631

VK_BLEND_FACTOR_ZERO = 0,

1632

VK_BLEND_FACTOR_ONE = 1,

1633

VK_BLEND_FACTOR_SRC_COLOR = 2,

1634

VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3,

1635

VK_BLEND_FACTOR_DST_COLOR = 4,

1636

VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5,

1637

VK_BLEND_FACTOR_SRC_ALPHA = 6,

1638

VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7,

1639

VK_BLEND_FACTOR_DST_ALPHA = 8,

1640

VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9,

1641

VK_BLEND_FACTOR_CONSTANT_COLOR = 10,

1642

VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11,

1643

VK_BLEND_FACTOR_CONSTANT_ALPHA = 12,

1644

VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13,

1645

VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14,

1646

VK_BLEND_FACTOR_SRC1_COLOR = 15,

1647

VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16,

1648

VK_BLEND_FACTOR_SRC1_ALPHA = 17,

1649

VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18,

1650

VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF

1651

} VkBlendFactor;

1652

1653

typedef enum VkBlendOp {

1654

VK_BLEND_OP_ADD = 0,

1655

VK_BLEND_OP_SUBTRACT = 1,

1656

VK_BLEND_OP_REVERSE_SUBTRACT = 2,

1657

VK_BLEND_OP_MIN = 3,

1658

VK_BLEND_OP_MAX = 4,

1659

VK_BLEND_OP_ZERO_EXT = 1000148000,

1660

VK_BLEND_OP_SRC_EXT = 1000148001,

1661

VK_BLEND_OP_DST_EXT = 1000148002,

1662

VK_BLEND_OP_SRC_OVER_EXT = 1000148003,

1663

VK_BLEND_OP_DST_OVER_EXT = 1000148004,

1664

VK_BLEND_OP_SRC_IN_EXT = 1000148005,

1665

VK_BLEND_OP_DST_IN_EXT = 1000148006,

1666

VK_BLEND_OP_SRC_OUT_EXT = 1000148007,

1667

VK_BLEND_OP_DST_OUT_EXT = 1000148008,

1668

VK_BLEND_OP_SRC_ATOP_EXT = 1000148009,

1669

VK_BLEND_OP_DST_ATOP_EXT = 1000148010,

1670

VK_BLEND_OP_XOR_EXT = 1000148011,

1671

VK_BLEND_OP_MULTIPLY_EXT = 1000148012,

1672

VK_BLEND_OP_SCREEN_EXT = 1000148013,

1673

VK_BLEND_OP_OVERLAY_EXT = 1000148014,

1674

VK_BLEND_OP_DARKEN_EXT = 1000148015,

1675

VK_BLEND_OP_LIGHTEN_EXT = 1000148016,

1676

VK_BLEND_OP_COLORDODGE_EXT = 1000148017,

1677

VK_BLEND_OP_COLORBURN_EXT = 1000148018,

1678

VK_BLEND_OP_HARDLIGHT_EXT = 1000148019,

1679

VK_BLEND_OP_SOFTLIGHT_EXT = 1000148020,

1680

VK_BLEND_OP_DIFFERENCE_EXT = 1000148021,

1681

VK_BLEND_OP_EXCLUSION_EXT = 1000148022,

1682

VK_BLEND_OP_INVERT_EXT = 1000148023,

1683

VK_BLEND_OP_INVERT_RGB_EXT = 1000148024,

1684

VK_BLEND_OP_LINEARDODGE_EXT = 1000148025,

1685

VK_BLEND_OP_LINEARBURN_EXT = 1000148026,

1686

VK_BLEND_OP_VIVIDLIGHT_EXT = 1000148027,

1687

VK_BLEND_OP_LINEARLIGHT_EXT = 1000148028,

1688

VK_BLEND_OP_PINLIGHT_EXT = 1000148029,

1689

VK_BLEND_OP_HARDMIX_EXT = 1000148030,

1690

VK_BLEND_OP_HSL_HUE_EXT = 1000148031,

1691

VK_BLEND_OP_HSL_SATURATION_EXT = 1000148032,

1692

VK_BLEND_OP_HSL_COLOR_EXT = 1000148033,

1693

VK_BLEND_OP_HSL_LUMINOSITY_EXT = 1000148034,

1694

VK_BLEND_OP_PLUS_EXT = 1000148035,

1695

VK_BLEND_OP_PLUS_CLAMPED_EXT = 1000148036,

1696

VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT = 1000148037,

1697

VK_BLEND_OP_PLUS_DARKER_EXT = 1000148038,

1698

VK_BLEND_OP_MINUS_EXT = 1000148039,

1699

VK_BLEND_OP_MINUS_CLAMPED_EXT = 1000148040,

1700

VK_BLEND_OP_CONTRAST_EXT = 1000148041,

1701

VK_BLEND_OP_INVERT_OVG_EXT = 1000148042,

1702

VK_BLEND_OP_RED_EXT = 1000148043,

1703

VK_BLEND_OP_GREEN_EXT = 1000148044,

1704

VK_BLEND_OP_BLUE_EXT = 1000148045,

1705

VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF

1706

} VkBlendOp;

1707

1708

typedef enum VkCompareOp {

1709

VK_COMPARE_OP_NEVER = 0,

1710

VK_COMPARE_OP_LESS = 1,

1711

VK_COMPARE_OP_EQUAL = 2,

1712

VK_COMPARE_OP_LESS_OR_EQUAL = 3,

1713

VK_COMPARE_OP_GREATER = 4,

1714

VK_COMPARE_OP_NOT_EQUAL = 5,

1715

VK_COMPARE_OP_GREATER_OR_EQUAL = 6,

1716

VK_COMPARE_OP_ALWAYS = 7,

1717

VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF

1718

} VkCompareOp;

1719

1720

typedef enum VkDynamicState {

1721

VK_DYNAMIC_STATE_VIEWPORT = 0,

1722

VK_DYNAMIC_STATE_SCISSOR = 1,

1723

VK_DYNAMIC_STATE_LINE_WIDTH = 2,

1724

VK_DYNAMIC_STATE_DEPTH_BIAS = 3,

1725

VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4,

1726

VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5,

1727

VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6,

1728

VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7,

1729

VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8,

1730

VK_DYNAMIC_STATE_CULL_MODE = 1000267000,

1731

VK_DYNAMIC_STATE_FRONT_FACE = 1000267001,

1732

VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY = 1000267002,

1733

VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT = 1000267003,

1734

VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT = 1000267004,

1735

VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE = 1000267005,

1736

VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE = 1000267006,

1737

VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE = 1000267007,

1738

VK_DYNAMIC_STATE_DEPTH_COMPARE_OP = 1000267008,

1739

VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE = 1000267009,

1740

VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE = 1000267010,

1741

VK_DYNAMIC_STATE_STENCIL_OP = 1000267011,

1742

VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE = 1000377001,

1743

VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE = 1000377002,

1744

VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE = 1000377004,

1745

VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV = 1000087000,

1746

VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT = 1000099000,

1747

VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT = 1000143000,

1748

VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR = 1000347000,

1749

VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV = 1000164004,

1750

VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV = 1000164006,

1751

VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV = 1000205001,

1752

VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR = 1000226000,

1753

VK_DYNAMIC_STATE_LINE_STIPPLE_EXT = 1000259000,

1754

VK_DYNAMIC_STATE_VERTEX_INPUT_EXT = 1000352000,

1755

VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT = 1000377000,

1756

VK_DYNAMIC_STATE_LOGIC_OP_EXT = 1000377003,

1757

VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT = 1000381000,

1758

VK_DYNAMIC_STATE_CULL_MODE_EXT = VK_DYNAMIC_STATE_CULL_MODE,

1759

VK_DYNAMIC_STATE_FRONT_FACE_EXT = VK_DYNAMIC_STATE_FRONT_FACE,

1760

VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT = VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY,

1761

VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT = VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT,

1762

VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT = VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT,

1763

VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT = VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE,

1764

VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT = VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE,

1765

VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE_EXT = VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE,

1766

VK_DYNAMIC_STATE_DEPTH_COMPARE_OP_EXT = VK_DYNAMIC_STATE_DEPTH_COMPARE_OP,

1767

VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE_EXT = VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE,

1768

VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT = VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE,

1769

VK_DYNAMIC_STATE_STENCIL_OP_EXT = VK_DYNAMIC_STATE_STENCIL_OP,

1770

VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT = VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE,

1771

VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT = VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE,

1772

VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT = VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE,

1773

VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF

1774

} VkDynamicState;

1775

1776

typedef enum VkFrontFace {

1777

VK_FRONT_FACE_COUNTER_CLOCKWISE = 0,

1778

VK_FRONT_FACE_CLOCKWISE = 1,

1779

VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF

1780

} VkFrontFace;

1781

1782

typedef enum VkVertexInputRate {

1783

VK_VERTEX_INPUT_RATE_VERTEX = 0,

1784

VK_VERTEX_INPUT_RATE_INSTANCE = 1,

1785

VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF

1786

} VkVertexInputRate;

1787

1788

typedef enum VkPrimitiveTopology {

1789

VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0,

1790

VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1,

1791

VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2,

1792

VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3,

1793

VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4,

1794

VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5,

1795

VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6,

1796

VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7,

1797

VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8,

1798

VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9,

1799

VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10,

1800

VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF

1801

} VkPrimitiveTopology;

1802

1803

typedef enum VkPolygonMode {

1804

VK_POLYGON_MODE_FILL = 0,

1805

VK_POLYGON_MODE_LINE = 1,

1806

VK_POLYGON_MODE_POINT = 2,

1807

VK_POLYGON_MODE_FILL_RECTANGLE_NV = 1000153000,

1808

VK_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF

1809

} VkPolygonMode;

1810

1811

typedef enum VkStencilOp {

1812

VK_STENCIL_OP_KEEP = 0,

1813

VK_STENCIL_OP_ZERO = 1,

1814

VK_STENCIL_OP_REPLACE = 2,

1815

VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3,

1816

VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4,

1817

VK_STENCIL_OP_INVERT = 5,

1818

VK_STENCIL_OP_INCREMENT_AND_WRAP = 6,

1819

VK_STENCIL_OP_DECREMENT_AND_WRAP = 7,

1820

VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF

1821

} VkStencilOp;

1822

1823

typedef enum VkLogicOp {

1824

VK_LOGIC_OP_CLEAR = 0,

1825

VK_LOGIC_OP_AND = 1,

1826

VK_LOGIC_OP_AND_REVERSE = 2,

1827

VK_LOGIC_OP_COPY = 3,

1828

VK_LOGIC_OP_AND_INVERTED = 4,

1829

VK_LOGIC_OP_NO_OP = 5,

1830

VK_LOGIC_OP_XOR = 6,

1831

VK_LOGIC_OP_OR = 7,

1832

VK_LOGIC_OP_NOR = 8,

1833

VK_LOGIC_OP_EQUIVALENT = 9,

1834

VK_LOGIC_OP_INVERT = 10,

1835

VK_LOGIC_OP_OR_REVERSE = 11,

1836

VK_LOGIC_OP_COPY_INVERTED = 12,

1837

VK_LOGIC_OP_OR_INVERTED = 13,

1838

VK_LOGIC_OP_NAND = 14,

1839

VK_LOGIC_OP_SET = 15,

1840

VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF

1841

} VkLogicOp;

1842

1843

typedef enum VkBorderColor {

1844

VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0,

1845

VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1,

1846

VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2,

1847

VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3,

1848

VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4,

1849

VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5,

1850

VK_BORDER_COLOR_FLOAT_CUSTOM_EXT = 1000287003,

1851

VK_BORDER_COLOR_INT_CUSTOM_EXT = 1000287004,

1852

VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF

1853

} VkBorderColor;

1854

1855

typedef enum VkFilter {

1856

VK_FILTER_NEAREST = 0,

1857

VK_FILTER_LINEAR = 1,

1858

VK_FILTER_CUBIC_IMG = 1000015000,

1859

VK_FILTER_CUBIC_EXT = VK_FILTER_CUBIC_IMG,

1860

VK_FILTER_MAX_ENUM = 0x7FFFFFFF

1861

} VkFilter;

1862

1863

typedef enum VkSamplerAddressMode {

1864

VK_SAMPLER_ADDRESS_MODE_REPEAT = 0,

1865

VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1,

1866

VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2,

1867

VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3,

1868

VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4,

1869

VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE_KHR = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE,

1870

VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF

1871

} VkSamplerAddressMode;

1872

1873

typedef enum VkSamplerMipmapMode {

1874

VK_SAMPLER_MIPMAP_MODE_NEAREST = 0,

1875

VK_SAMPLER_MIPMAP_MODE_LINEAR = 1,

1876

VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF

1877

} VkSamplerMipmapMode;

1878

1879

typedef enum VkDescriptorType {

1880

VK_DESCRIPTOR_TYPE_SAMPLER = 0,

1881

VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1,

1882

VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2,

1883

VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3,

1884

VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4,

1885

VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5,

1886

VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6,

1887

VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7,

1888

VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8,

1889

VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9,

1890

VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10,

1891

VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK = 1000138000,

1892

VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR = 1000150000,

1893

VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000,

1894

VK_DESCRIPTOR_TYPE_MUTABLE_VALVE = 1000351000,

1895

VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT = VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK,

1896

VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF

1897

} VkDescriptorType;

1898

1899

typedef enum VkAttachmentLoadOp {

1900

VK_ATTACHMENT_LOAD_OP_LOAD = 0,

1901

VK_ATTACHMENT_LOAD_OP_CLEAR = 1,

1902

VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2,

1903

VK_ATTACHMENT_LOAD_OP_NONE_EXT = 1000400000,

1904

VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF

1905

} VkAttachmentLoadOp;

1906

1907

typedef enum VkAttachmentStoreOp {

1908

VK_ATTACHMENT_STORE_OP_STORE = 0,

1909

VK_ATTACHMENT_STORE_OP_DONT_CARE = 1,

1910

VK_ATTACHMENT_STORE_OP_NONE = 1000301000,

1911

VK_ATTACHMENT_STORE_OP_NONE_KHR = VK_ATTACHMENT_STORE_OP_NONE,

1912

VK_ATTACHMENT_STORE_OP_NONE_QCOM = VK_ATTACHMENT_STORE_OP_NONE,

1913

VK_ATTACHMENT_STORE_OP_NONE_EXT = VK_ATTACHMENT_STORE_OP_NONE,

1914

VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF

1915

} VkAttachmentStoreOp;

1916

1917

typedef enum VkPipelineBindPoint {

1918

VK_PIPELINE_BIND_POINT_GRAPHICS = 0,

1919

VK_PIPELINE_BIND_POINT_COMPUTE = 1,

1920

VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR = 1000165000,

1921

VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI = 1000369003,

1922

VK_PIPELINE_BIND_POINT_RAY_TRACING_NV = VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR,

1923

VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF

1924

} VkPipelineBindPoint;

1925

1926

typedef enum VkCommandBufferLevel {

1927

VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0,

1928

VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1,

1929

VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF

1930

} VkCommandBufferLevel;

1931

1932

typedef enum VkIndexType {

1933

VK_INDEX_TYPE_UINT16 = 0,

1934

VK_INDEX_TYPE_UINT32 = 1,

1935

VK_INDEX_TYPE_NONE_KHR = 1000165000,

1936

VK_INDEX_TYPE_UINT8_EXT = 1000265000,

1937

VK_INDEX_TYPE_NONE_NV = VK_INDEX_TYPE_NONE_KHR,

1938

VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF

1939

} VkIndexType;

1940

1941

typedef enum VkSubpassContents {

1942

VK_SUBPASS_CONTENTS_INLINE = 0,

1943

VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1,

1944

VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF

1945

} VkSubpassContents;

1946

1947

typedef enum VkAccessFlagBits {

1948

VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0x00000001,

1949

VK_ACCESS_INDEX_READ_BIT = 0x00000002,

1950

VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004,

1951

VK_ACCESS_UNIFORM_READ_BIT = 0x00000008,

1952

VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 0x00000010,

1953

VK_ACCESS_SHADER_READ_BIT = 0x00000020,

1954

VK_ACCESS_SHADER_WRITE_BIT = 0x00000040,

1955

VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 0x00000080,

1956

VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100,

1957

VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200,

1958

VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400,

1959

VK_ACCESS_TRANSFER_READ_BIT = 0x00000800,

1960

VK_ACCESS_TRANSFER_WRITE_BIT = 0x00001000,

1961

VK_ACCESS_HOST_READ_BIT = 0x00002000,

1962

VK_ACCESS_HOST_WRITE_BIT = 0x00004000,

1963

VK_ACCESS_MEMORY_READ_BIT = 0x00008000,

1964

VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000,

1965

VK_ACCESS_NONE = 0,

1966

VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT = 0x02000000,

1967

VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT = 0x04000000,

1968

VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT = 0x08000000,

1969

VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT = 0x00100000,

1970

VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000,

1971

VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR = 0x00200000,

1972

VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR = 0x00400000,

1973

VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT = 0x01000000,

1974

VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR = 0x00800000,

1975

VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV = 0x00020000,

1976

VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV = 0x00040000,

1977

VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV = VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR,

1978

VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV = VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR,

1979

VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV = VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR,

1980

VK_ACCESS_NONE_KHR = VK_ACCESS_NONE,

1981

VK_ACCESS_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

1982

} VkAccessFlagBits;

1983

typedef VkFlags VkAccessFlags;

1984

1985

typedef enum VkImageAspectFlagBits {

1986

VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001,

1987

VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002,

1988

VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004,

1989

VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008,

1990

VK_IMAGE_ASPECT_PLANE_0_BIT = 0x00000010,

1991

VK_IMAGE_ASPECT_PLANE_1_BIT = 0x00000020,

1992

VK_IMAGE_ASPECT_PLANE_2_BIT = 0x00000040,

1993

VK_IMAGE_ASPECT_NONE = 0,

1994

VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT = 0x00000080,

1995

VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT = 0x00000100,

1996

VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT = 0x00000200,

1997

VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT = 0x00000400,

1998

VK_IMAGE_ASPECT_PLANE_0_BIT_KHR = VK_IMAGE_ASPECT_PLANE_0_BIT,

1999

VK_IMAGE_ASPECT_PLANE_1_BIT_KHR = VK_IMAGE_ASPECT_PLANE_1_BIT,

2000

VK_IMAGE_ASPECT_PLANE_2_BIT_KHR = VK_IMAGE_ASPECT_PLANE_2_BIT,

2001

VK_IMAGE_ASPECT_NONE_KHR = VK_IMAGE_ASPECT_NONE,

2002

VK_IMAGE_ASPECT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

2003

} VkImageAspectFlagBits;

2004

typedef VkFlags VkImageAspectFlags;

2005

2006

typedef enum VkFormatFeatureFlagBits {

2007

VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001,

2008

VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002,

2009

VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004,

2010

VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008,

2011

VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010,

2012

VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020,

2013

VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040,

2014

VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080,

2015

VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100,

2016

VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200,

2017

VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0x00000400,

2018

VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800,

2019

VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000,

2020

VK_FORMAT_FEATURE_TRANSFER_SRC_BIT = 0x00004000,

2021

VK_FORMAT_FEATURE_TRANSFER_DST_BIT = 0x00008000,

2022

VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT = 0x00020000,

2023

VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT = 0x00040000,

2024

VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT = 0x00080000,

2025

VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT = 0x00100000,

2026

VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT = 0x00200000,

2027

VK_FORMAT_FEATURE_DISJOINT_BIT = 0x00400000,

2028

VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT = 0x00800000,

2029

VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT = 0x00010000,

2030

VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = 0x00002000,

2031

#ifdef VK_ENABLE_BETA_EXTENSIONS

2032

VK_FORMAT_FEATURE_VIDEO_DECODE_OUTPUT_BIT_KHR = 0x02000000,

2033

#endif

2034

#ifdef VK_ENABLE_BETA_EXTENSIONS

2035

VK_FORMAT_FEATURE_VIDEO_DECODE_DPB_BIT_KHR = 0x04000000,

2036

#endif

2037

VK_FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR = 0x20000000,

2038

VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x01000000,

2039

VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x40000000,

2040

#ifdef VK_ENABLE_BETA_EXTENSIONS

2041

VK_FORMAT_FEATURE_VIDEO_ENCODE_INPUT_BIT_KHR = 0x08000000,

2042

#endif

2043

#ifdef VK_ENABLE_BETA_EXTENSIONS

2044

VK_FORMAT_FEATURE_VIDEO_ENCODE_DPB_BIT_KHR = 0x10000000,

2045

#endif

2046

VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT,

2047

VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_DST_BIT,

2048

VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT,

2049

VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT,

2050

VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT,

2051

VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT,

2052

VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT,

2053

VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT,

2054

VK_FORMAT_FEATURE_DISJOINT_BIT_KHR = VK_FORMAT_FEATURE_DISJOINT_BIT,

2055

VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT,

2056

VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG,

2057

VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

2058

} VkFormatFeatureFlagBits;

2059

typedef VkFlags VkFormatFeatureFlags;

2060

2061

typedef enum VkImageCreateFlagBits {

2062

VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0x00000001,

2063

VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002,

2064

VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004,

2065

VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008,

2066

VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010,

2067

VK_IMAGE_CREATE_ALIAS_BIT = 0x00000400,

2068

VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT = 0x00000040,

2069

VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT = 0x00000020,

2070

VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT = 0x00000080,

2071

VK_IMAGE_CREATE_EXTENDED_USAGE_BIT = 0x00000100,

2072

VK_IMAGE_CREATE_PROTECTED_BIT = 0x00000800,

2073

VK_IMAGE_CREATE_DISJOINT_BIT = 0x00000200,

2074

VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV = 0x00002000,

2075

VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT = 0x00001000,

2076

VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT = 0x00004000,

2077

VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT = 0x00020000,

2078

VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM = 0x00008000,

2079

VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT,

2080

VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT,

2081

VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT,

2082

VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT,

2083

VK_IMAGE_CREATE_DISJOINT_BIT_KHR = VK_IMAGE_CREATE_DISJOINT_BIT,

2084

VK_IMAGE_CREATE_ALIAS_BIT_KHR = VK_IMAGE_CREATE_ALIAS_BIT,

2085

VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

2086

} VkImageCreateFlagBits;

2087

typedef VkFlags VkImageCreateFlags;

2088

2089

typedef enum VkSampleCountFlagBits {

2090

VK_SAMPLE_COUNT_1_BIT = 0x00000001,

2091

VK_SAMPLE_COUNT_2_BIT = 0x00000002,

2092

VK_SAMPLE_COUNT_4_BIT = 0x00000004,

2093

VK_SAMPLE_COUNT_8_BIT = 0x00000008,

2094

VK_SAMPLE_COUNT_16_BIT = 0x00000010,

2095

VK_SAMPLE_COUNT_32_BIT = 0x00000020,

2096

VK_SAMPLE_COUNT_64_BIT = 0x00000040,

2097

VK_SAMPLE_COUNT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

2098

} VkSampleCountFlagBits;

2099

typedef VkFlags VkSampleCountFlags;

2100

2101

typedef enum VkImageUsageFlagBits {

2102

VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001,

2103

VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0x00000002,

2104

VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004,

2105

VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008,

2106

VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010,

2107

VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020,

2108

VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040,

2109

VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080,

2110

#ifdef VK_ENABLE_BETA_EXTENSIONS

2111

VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR = 0x00000400,

2112

#endif

2113

#ifdef VK_ENABLE_BETA_EXTENSIONS

2114

VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR = 0x00000800,

2115

#endif

2116

#ifdef VK_ENABLE_BETA_EXTENSIONS

2117

VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR = 0x00001000,

2118

#endif

2119

VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x00000200,

2120

VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00000100,

2121

#ifdef VK_ENABLE_BETA_EXTENSIONS

2122

VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR = 0x00002000,

2123

#endif

2124

#ifdef VK_ENABLE_BETA_EXTENSIONS

2125

VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR = 0x00004000,

2126

#endif

2127

#ifdef VK_ENABLE_BETA_EXTENSIONS

2128

VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR = 0x00008000,

2129

#endif

2130

VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI = 0x00040000,

2131

VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV = VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR,

2132

VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

2133

} VkImageUsageFlagBits;

2134

typedef VkFlags VkImageUsageFlags;

2135

2136

typedef enum VkInstanceCreateFlagBits {

2137

VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR = 0x00000001,

2138

VK_INSTANCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

2139

} VkInstanceCreateFlagBits;

2140

typedef VkFlags VkInstanceCreateFlags;

2141

2142

typedef enum VkMemoryHeapFlagBits {

2143

VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001,

2144

VK_MEMORY_HEAP_MULTI_INSTANCE_BIT = 0x00000002,

2145

VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHR = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT,

2146

VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

2147

} VkMemoryHeapFlagBits;

2148

typedef VkFlags VkMemoryHeapFlags;

2149

2150

typedef enum VkMemoryPropertyFlagBits {

2151

VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0x00000001,

2152

VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000002,

2153

VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004,

2154

VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008,

2155

VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010,

2156

VK_MEMORY_PROPERTY_PROTECTED_BIT = 0x00000020,

2157

VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD = 0x00000040,

2158

VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD = 0x00000080,

2159

VK_MEMORY_PROPERTY_RDMA_CAPABLE_BIT_NV = 0x00000100,

2160

VK_MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

2161

} VkMemoryPropertyFlagBits;

2162

typedef VkFlags VkMemoryPropertyFlags;

2163

2164

typedef enum VkQueueFlagBits {

2165

VK_QUEUE_GRAPHICS_BIT = 0x00000001,

2166

VK_QUEUE_COMPUTE_BIT = 0x00000002,

2167

VK_QUEUE_TRANSFER_BIT = 0x00000004,

2168

VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008,

2169

VK_QUEUE_PROTECTED_BIT = 0x00000010,

2170

#ifdef VK_ENABLE_BETA_EXTENSIONS

2171

VK_QUEUE_VIDEO_DECODE_BIT_KHR = 0x00000020,

2172

#endif

2173

#ifdef VK_ENABLE_BETA_EXTENSIONS

2174

VK_QUEUE_VIDEO_ENCODE_BIT_KHR = 0x00000040,

2175

#endif

2176

VK_QUEUE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

2177

} VkQueueFlagBits;

2178

typedef VkFlags VkQueueFlags;

2179

typedef VkFlags VkDeviceCreateFlags;

2180

2181

typedef enum VkDeviceQueueCreateFlagBits {

2182

VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT = 0x00000001,

2183

VK_DEVICE_QUEUE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

2184

} VkDeviceQueueCreateFlagBits;

2185

typedef VkFlags VkDeviceQueueCreateFlags;

2186

2187

typedef enum VkPipelineStageFlagBits {

2188

VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001,

2189

VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002,

2190

VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004,

2191

VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008,

2192

VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010,

2193

VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020,

2194

VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040,

2195

VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080,

2196

VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100,

2197

VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200,

2198

VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400,

2199

VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800,

2200

VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000,

2201

VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 0x00002000,

2202

VK_PIPELINE_STAGE_HOST_BIT = 0x00004000,

2203

VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000,

2204

VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000,

2205

VK_PIPELINE_STAGE_NONE = 0,

2206

VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT = 0x01000000,

2207

VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00040000,

2208

VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR = 0x02000000,

2209

VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR = 0x00200000,

2210

VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV = 0x00080000,

2211

VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV = 0x00100000,

2212

VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT = 0x00800000,

2213

VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00400000,

2214

VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV = 0x00020000,

2215

VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV = VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR,

2216

VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV = VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR,

2217

VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV = VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR,

2218

VK_PIPELINE_STAGE_NONE_KHR = VK_PIPELINE_STAGE_NONE,

2219

VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

2220

} VkPipelineStageFlagBits;

2221

typedef VkFlags VkPipelineStageFlags;

2222

typedef VkFlags VkMemoryMapFlags;

2223

2224

typedef enum VkSparseMemoryBindFlagBits {

2225

VK_SPARSE_MEMORY_BIND_METADATA_BIT = 0x00000001,

2226

VK_SPARSE_MEMORY_BIND_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

2227

} VkSparseMemoryBindFlagBits;

2228

typedef VkFlags VkSparseMemoryBindFlags;

2229

2230

typedef enum VkSparseImageFormatFlagBits {

2231

VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0x00000001,

2232

VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 0x00000002,

2233

VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0x00000004,

2234

VK_SPARSE_IMAGE_FORMAT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

2235

} VkSparseImageFormatFlagBits;

2236

typedef VkFlags VkSparseImageFormatFlags;

2237

2238

typedef enum VkFenceCreateFlagBits {

2239

VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001,

2240

VK_FENCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

2241

} VkFenceCreateFlagBits;

2242

typedef VkFlags VkFenceCreateFlags;

2243

typedef VkFlags VkSemaphoreCreateFlags;

2244

2245

typedef enum VkEventCreateFlagBits {

2246

VK_EVENT_CREATE_DEVICE_ONLY_BIT = 0x00000001,

2247

VK_EVENT_CREATE_DEVICE_ONLY_BIT_KHR = VK_EVENT_CREATE_DEVICE_ONLY_BIT,

2248

VK_EVENT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

2249

} VkEventCreateFlagBits;

2250

typedef VkFlags VkEventCreateFlags;

2251

2252

typedef enum VkQueryPipelineStatisticFlagBits {

2253

VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001,

2254

VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0x00000002,

2255

VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0x00000004,

2256

VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 0x00000008,

2257

VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 0x00000010,

2258

VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 0x00000020,

2259

VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 0x00000040,

2260

VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 0x00000080,

2261

VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 0x00000100,

2262

VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 0x00000200,

2263

VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 0x00000400,

2264

VK_QUERY_PIPELINE_STATISTIC_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

2265

} VkQueryPipelineStatisticFlagBits;

2266

typedef VkFlags VkQueryPipelineStatisticFlags;

2267

typedef VkFlags VkQueryPoolCreateFlags;

2268

2269

typedef enum VkQueryResultFlagBits {

2270

VK_QUERY_RESULT_64_BIT = 0x00000001,

2271

VK_QUERY_RESULT_WAIT_BIT = 0x00000002,

2272

VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004,

2273

VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008,

2274

#ifdef VK_ENABLE_BETA_EXTENSIONS

2275

VK_QUERY_RESULT_WITH_STATUS_BIT_KHR = 0x00000010,

2276

#endif

2277

VK_QUERY_RESULT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

2278

} VkQueryResultFlagBits;

2279

typedef VkFlags VkQueryResultFlags;

2280

2281

typedef enum VkBufferCreateFlagBits {

2282

VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001,

2283

VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002,

2284

VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004,

2285

VK_BUFFER_CREATE_PROTECTED_BIT = 0x00000008,

2286

VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = 0x00000010,

2287

VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT,

2288

VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT,

2289

VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

2290

} VkBufferCreateFlagBits;

2291

typedef VkFlags VkBufferCreateFlags;

2292

2293

typedef enum VkBufferUsageFlagBits {

2294

VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001,

2295

VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002,

2296

VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004,

2297

VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008,

2298

VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010,

2299

VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020,

2300

VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040,

2301

VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080,

2302

VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100,

2303

VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT = 0x00020000,

2304

#ifdef VK_ENABLE_BETA_EXTENSIONS

2305

VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR = 0x00002000,

2306

#endif

2307

#ifdef VK_ENABLE_BETA_EXTENSIONS

2308

VK_BUFFER_USAGE_VIDEO_DECODE_DST_BIT_KHR = 0x00004000,

2309

#endif

2310

VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT = 0x00000800,

2311

VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT = 0x00001000,

2312

VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00000200,

2313

VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR = 0x00080000,

2314

VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR = 0x00100000,

2315

VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR = 0x00000400,

2316

#ifdef VK_ENABLE_BETA_EXTENSIONS

2317

VK_BUFFER_USAGE_VIDEO_ENCODE_DST_BIT_KHR = 0x00008000,

2318

#endif

2319

#ifdef VK_ENABLE_BETA_EXTENSIONS

2320

VK_BUFFER_USAGE_VIDEO_ENCODE_SRC_BIT_KHR = 0x00010000,

2321

#endif

2322

VK_BUFFER_USAGE_RAY_TRACING_BIT_NV = VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR,

2323

VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,

2324

VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT,

2325

VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

2326

} VkBufferUsageFlagBits;

2327

typedef VkFlags VkBufferUsageFlags;

2328

typedef VkFlags VkBufferViewCreateFlags;

2329

2330

typedef enum VkImageViewCreateFlagBits {

2331

VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT = 0x00000001,

2332

VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT = 0x00000002,

2333

VK_IMAGE_VIEW_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

2334

} VkImageViewCreateFlagBits;

2335

typedef VkFlags VkImageViewCreateFlags;

2336

typedef VkFlags VkShaderModuleCreateFlags;

2337

2338

typedef enum VkPipelineCacheCreateFlagBits {

2339

VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT = 0x00000001,

2340

VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT = VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT,

2341

VK_PIPELINE_CACHE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

2342

} VkPipelineCacheCreateFlagBits;

2343

typedef VkFlags VkPipelineCacheCreateFlags;

2344

2345

typedef enum VkColorComponentFlagBits {

2346

VK_COLOR_COMPONENT_R_BIT = 0x00000001,

2347

VK_COLOR_COMPONENT_G_BIT = 0x00000002,

2348

VK_COLOR_COMPONENT_B_BIT = 0x00000004,

2349

VK_COLOR_COMPONENT_A_BIT = 0x00000008,

2350

VK_COLOR_COMPONENT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

2351

} VkColorComponentFlagBits;

2352

typedef VkFlags VkColorComponentFlags;

2353

2354

typedef enum VkPipelineCreateFlagBits {

2355

VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001,

2356

VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002,

2357

VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004,

2358

VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 0x00000008,

2359

VK_PIPELINE_CREATE_DISPATCH_BASE_BIT = 0x00000010,

2360

VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT = 0x00000100,

2361

VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT = 0x00000200,

2362

VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00200000,

2363

VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = 0x00400000,

2364

VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR = 0x00004000,

2365

VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR = 0x00008000,

2366

VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR = 0x00010000,

2367

VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR = 0x00020000,

2368

VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR = 0x00001000,

2369

VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR = 0x00002000,

2370

VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR = 0x00080000,

2371

VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV = 0x00000020,

2372

VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR = 0x00000040,

2373

VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR = 0x00000080,

2374

VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV = 0x00040000,

2375

VK_PIPELINE_CREATE_LIBRARY_BIT_KHR = 0x00000800,

2376

VK_PIPELINE_CREATE_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT = 0x00800000,

2377

VK_PIPELINE_CREATE_LINK_TIME_OPTIMIZATION_BIT_EXT = 0x00000400,

2378

VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV = 0x00100000,

2379

VK_PIPELINE_CREATE_DISPATCH_BASE = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT,

2380

VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR,

2381

VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT,

2382

VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT,

2383

VK_PIPELINE_CREATE_DISPATCH_BASE_KHR = VK_PIPELINE_CREATE_DISPATCH_BASE,

2384

VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT = VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT,

2385

VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT_EXT = VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT,

2386

VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

2387

} VkPipelineCreateFlagBits;

2388

typedef VkFlags VkPipelineCreateFlags;

2389

2390

typedef enum VkPipelineShaderStageCreateFlagBits {

2391

VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT = 0x00000001,

2392

VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT = 0x00000002,

2393

VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT = VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT,

2394

VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT = VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT,

2395

VK_PIPELINE_SHADER_STAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

2396

} VkPipelineShaderStageCreateFlagBits;

2397

typedef VkFlags VkPipelineShaderStageCreateFlags;

2398

2399

typedef enum VkShaderStageFlagBits {

2400

VK_SHADER_STAGE_VERTEX_BIT = 0x00000001,

2401

VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002,

2402

VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004,

2403

VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008,

2404

VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010,

2405

VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020,

2406

VK_SHADER_STAGE_ALL_GRAPHICS = 0x0000001F,

2407

VK_SHADER_STAGE_ALL = 0x7FFFFFFF,

2408

VK_SHADER_STAGE_RAYGEN_BIT_KHR = 0x00000100,

2409

VK_SHADER_STAGE_ANY_HIT_BIT_KHR = 0x00000200,

2410

VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR = 0x00000400,

2411

VK_SHADER_STAGE_MISS_BIT_KHR = 0x00000800,

2412

VK_SHADER_STAGE_INTERSECTION_BIT_KHR = 0x00001000,

2413

VK_SHADER_STAGE_CALLABLE_BIT_KHR = 0x00002000,

2414

VK_SHADER_STAGE_TASK_BIT_NV = 0x00000040,

2415

VK_SHADER_STAGE_MESH_BIT_NV = 0x00000080,

2416

VK_SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI = 0x00004000,

2417

VK_SHADER_STAGE_RAYGEN_BIT_NV = VK_SHADER_STAGE_RAYGEN_BIT_KHR,

2418

VK_SHADER_STAGE_ANY_HIT_BIT_NV = VK_SHADER_STAGE_ANY_HIT_BIT_KHR,

2419

VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV = VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR,

2420

VK_SHADER_STAGE_MISS_BIT_NV = VK_SHADER_STAGE_MISS_BIT_KHR,

2421

VK_SHADER_STAGE_INTERSECTION_BIT_NV = VK_SHADER_STAGE_INTERSECTION_BIT_KHR,

2422

VK_SHADER_STAGE_CALLABLE_BIT_NV = VK_SHADER_STAGE_CALLABLE_BIT_KHR,

2423

VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

2424

} VkShaderStageFlagBits;

2425

2426

typedef enum VkCullModeFlagBits {

2427

VK_CULL_MODE_NONE = 0,

2428

VK_CULL_MODE_FRONT_BIT = 0x00000001,

2429

VK_CULL_MODE_BACK_BIT = 0x00000002,

2430

VK_CULL_MODE_FRONT_AND_BACK = 0x00000003,

2431

VK_CULL_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

2432

} VkCullModeFlagBits;

2433

typedef VkFlags VkCullModeFlags;

2434

typedef VkFlags VkPipelineVertexInputStateCreateFlags;

2435

typedef VkFlags VkPipelineInputAssemblyStateCreateFlags;

2436

typedef VkFlags VkPipelineTessellationStateCreateFlags;

2437

typedef VkFlags VkPipelineViewportStateCreateFlags;

2438

typedef VkFlags VkPipelineRasterizationStateCreateFlags;

2439

typedef VkFlags VkPipelineMultisampleStateCreateFlags;

2440

2441

typedef enum VkPipelineDepthStencilStateCreateFlagBits {

2442

VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM = 0x00000001,

2443

VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM = 0x00000002,

2444

VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

2445

} VkPipelineDepthStencilStateCreateFlagBits;

2446

typedef VkFlags VkPipelineDepthStencilStateCreateFlags;

2447

2448

typedef enum VkPipelineColorBlendStateCreateFlagBits {

2449

VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_ARM = 0x00000001,

2450

VK_PIPELINE_COLOR_BLEND_STATE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

2451

} VkPipelineColorBlendStateCreateFlagBits;

2452

typedef VkFlags VkPipelineColorBlendStateCreateFlags;

2453

typedef VkFlags VkPipelineDynamicStateCreateFlags;

2454

2455

typedef enum VkPipelineLayoutCreateFlagBits {

2456

VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT = 0x00000002,

2457

VK_PIPELINE_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

2458

} VkPipelineLayoutCreateFlagBits;

2459

typedef VkFlags VkPipelineLayoutCreateFlags;

2460

typedef VkFlags VkShaderStageFlags;

2461

2462

typedef enum VkSamplerCreateFlagBits {

2463

VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT = 0x00000001,

2464

VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT = 0x00000002,

2465

VK_SAMPLER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

2466

} VkSamplerCreateFlagBits;

2467

typedef VkFlags VkSamplerCreateFlags;

2468

2469

typedef enum VkDescriptorPoolCreateFlagBits {

2470

VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001,

2471

VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT = 0x00000002,

2472

VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE = 0x00000004,

2473

VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT,

2474

VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

2475

} VkDescriptorPoolCreateFlagBits;

2476

typedef VkFlags VkDescriptorPoolCreateFlags;

2477

typedef VkFlags VkDescriptorPoolResetFlags;

2478

2479

typedef enum VkDescriptorSetLayoutCreateFlagBits {

2480

VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT = 0x00000002,

2481

VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR = 0x00000001,

2482

VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE = 0x00000004,

2483

VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT,

2484

VK_DESCRIPTOR_SET_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

2485

} VkDescriptorSetLayoutCreateFlagBits;

2486

typedef VkFlags VkDescriptorSetLayoutCreateFlags;

2487

2488

typedef enum VkAttachmentDescriptionFlagBits {

2489

VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001,

2490

VK_ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

2491

} VkAttachmentDescriptionFlagBits;

2492

typedef VkFlags VkAttachmentDescriptionFlags;

2493

2494

typedef enum VkDependencyFlagBits {

2495

VK_DEPENDENCY_BY_REGION_BIT = 0x00000001,

2496

VK_DEPENDENCY_DEVICE_GROUP_BIT = 0x00000004,

2497

VK_DEPENDENCY_VIEW_LOCAL_BIT = 0x00000002,

2498

VK_DEPENDENCY_VIEW_LOCAL_BIT_KHR = VK_DEPENDENCY_VIEW_LOCAL_BIT,

2499

VK_DEPENDENCY_DEVICE_GROUP_BIT_KHR = VK_DEPENDENCY_DEVICE_GROUP_BIT,

2500

VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

2501

} VkDependencyFlagBits;

2502

typedef VkFlags VkDependencyFlags;

2503

2504

typedef enum VkFramebufferCreateFlagBits {

2505

VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT = 0x00000001,

2506

VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR = VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT,

2507

VK_FRAMEBUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

2508

} VkFramebufferCreateFlagBits;

2509

typedef VkFlags VkFramebufferCreateFlags;

2510

2511

typedef enum VkRenderPassCreateFlagBits {

2512

VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM = 0x00000002,

2513

VK_RENDER_PASS_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

2514

} VkRenderPassCreateFlagBits;

2515

typedef VkFlags VkRenderPassCreateFlags;

2516

2517

typedef enum VkSubpassDescriptionFlagBits {

2518

VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX = 0x00000001,

2519

VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX = 0x00000002,

2520

VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM = 0x00000004,

2521

VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM = 0x00000008,

2522

VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_ARM = 0x00000010,

2523

VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM = 0x00000020,

2524

VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM = 0x00000040,

2525

VK_SUBPASS_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

2526

} VkSubpassDescriptionFlagBits;

2527

typedef VkFlags VkSubpassDescriptionFlags;

2528

2529

typedef enum VkCommandPoolCreateFlagBits {

2530

VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001,

2531

VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002,

2532

VK_COMMAND_POOL_CREATE_PROTECTED_BIT = 0x00000004,

2533

VK_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

2534

} VkCommandPoolCreateFlagBits;

2535

typedef VkFlags VkCommandPoolCreateFlags;

2536

2537

typedef enum VkCommandPoolResetFlagBits {

2538

VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001,

2539

VK_COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

2540

} VkCommandPoolResetFlagBits;

2541

typedef VkFlags VkCommandPoolResetFlags;

2542

2543

typedef enum VkCommandBufferUsageFlagBits {

2544

VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001,

2545

VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002,

2546

VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004,

2547

VK_COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

2548

} VkCommandBufferUsageFlagBits;

2549

typedef VkFlags VkCommandBufferUsageFlags;

2550

2551

typedef enum VkQueryControlFlagBits {

2552

VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001,

2553

VK_QUERY_CONTROL_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

2554

} VkQueryControlFlagBits;

2555

typedef VkFlags VkQueryControlFlags;

2556

2557

typedef enum VkCommandBufferResetFlagBits {

2558

VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001,

2559

VK_COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

2560

} VkCommandBufferResetFlagBits;

2561

typedef VkFlags VkCommandBufferResetFlags;

2562

2563

typedef enum VkStencilFaceFlagBits {

2564

VK_STENCIL_FACE_FRONT_BIT = 0x00000001,

2565

VK_STENCIL_FACE_BACK_BIT = 0x00000002,

2566

VK_STENCIL_FACE_FRONT_AND_BACK = 0x00000003,

2567

VK_STENCIL_FRONT_AND_BACK = VK_STENCIL_FACE_FRONT_AND_BACK,

2568

VK_STENCIL_FACE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

2569

} VkStencilFaceFlagBits;

2570

typedef VkFlags VkStencilFaceFlags;

2571

typedef struct VkExtent2D {

2572

uint32_t width;

2573

uint32_t height;

2574

} VkExtent2D;

2575

2576

typedef struct VkExtent3D {

2577

uint32_t width;

2578

uint32_t height;

2579

uint32_t depth;

2580

} VkExtent3D;

2581

2582

typedef struct VkOffset2D {

2583

int32_t x;

2584

int32_t y;

2585

} VkOffset2D;

2586

2587

typedef struct VkOffset3D {

2588

int32_t x;

2589

int32_t y;

2590

int32_t z;

2591

} VkOffset3D;

2592

2593

typedef struct VkRect2D {

2594

VkOffset2D offset;

2595

VkExtent2D extent;

2596

} VkRect2D;

2597

2598

typedef struct VkBaseInStructure {

2599

VkStructureType sType;

2600

const struct VkBaseInStructure* pNext;

2601

} VkBaseInStructure;

2602

2603

typedef struct VkBaseOutStructure {

2604

VkStructureType sType;

2605

struct VkBaseOutStructure* pNext;

2606

} VkBaseOutStructure;

2607

2608

typedef struct VkBufferMemoryBarrier {

2609

VkStructureType sType;

2610

const void* pNext;

2611

VkAccessFlags srcAccessMask;

2612

VkAccessFlags dstAccessMask;

2613

uint32_t srcQueueFamilyIndex;

2614

uint32_t dstQueueFamilyIndex;

2615

VkBuffer buffer;

2616

VkDeviceSize offset;

2617

VkDeviceSize size;

2618

} VkBufferMemoryBarrier;

2619

2620

typedef struct VkDispatchIndirectCommand {

2621

uint32_t x;

2622

uint32_t y;

2623

uint32_t z;

2624

} VkDispatchIndirectCommand;

2625

2626

typedef struct VkDrawIndexedIndirectCommand {

2627

uint32_t indexCount;

2628

uint32_t instanceCount;

2629

uint32_t firstIndex;

2630

int32_t vertexOffset;

2631

uint32_t firstInstance;

2632

} VkDrawIndexedIndirectCommand;

2633

2634

typedef struct VkDrawIndirectCommand {

2635

uint32_t vertexCount;

2636

uint32_t instanceCount;

2637

uint32_t firstVertex;

2638

uint32_t firstInstance;

2639

} VkDrawIndirectCommand;

2640

2641

typedef struct VkImageSubresourceRange {

2642

VkImageAspectFlags aspectMask;

2643

uint32_t baseMipLevel;

2644

uint32_t levelCount;

2645

uint32_t baseArrayLayer;

2646

uint32_t layerCount;

2647

} VkImageSubresourceRange;

2648

2649

typedef struct VkImageMemoryBarrier {

2650

VkStructureType sType;

2651

const void* pNext;

2652

VkAccessFlags srcAccessMask;

2653

VkAccessFlags dstAccessMask;

2654

VkImageLayout oldLayout;

2655

VkImageLayout newLayout;

2656

uint32_t srcQueueFamilyIndex;

2657

uint32_t dstQueueFamilyIndex;

2658

VkImage image;

2659

VkImageSubresourceRange subresourceRange;

2660

} VkImageMemoryBarrier;

2661

2662

typedef struct VkMemoryBarrier {

2663

VkStructureType sType;

2664

const void* pNext;

2665

VkAccessFlags srcAccessMask;

2666

VkAccessFlags dstAccessMask;

2667

} VkMemoryBarrier;

2668

2669

typedef struct VkPipelineCacheHeaderVersionOne {

2670

uint32_t headerSize;

2671

VkPipelineCacheHeaderVersion headerVersion;

2672

uint32_t vendorID;

2673

uint32_t deviceID;

2674

uint8_t pipelineCacheUUID[VK_UUID_SIZE];

2675

} VkPipelineCacheHeaderVersionOne;

2676

2677

typedef void* (VKAPI_PTR *PFN_vkAllocationFunction)(

2678

void* pUserData,

2679

size_t size,

2680

size_t alignment,

2681

VkSystemAllocationScope allocationScope);

2682

2683

typedef void (VKAPI_PTR *PFN_vkFreeFunction)(

2684

void* pUserData,

2685

void* pMemory);

2686

2687

typedef void (VKAPI_PTR *PFN_vkInternalAllocationNotification)(

2688

void* pUserData,

2689

size_t size,

2690

VkInternalAllocationType allocationType,

2691

VkSystemAllocationScope allocationScope);

2692

2693

typedef void (VKAPI_PTR *PFN_vkInternalFreeNotification)(

2694

void* pUserData,

2695

size_t size,

2696

VkInternalAllocationType allocationType,

2697

VkSystemAllocationScope allocationScope);

2698

2699

typedef void* (VKAPI_PTR *PFN_vkReallocationFunction)(

2700

void* pUserData,

2701

void* pOriginal,

2702

size_t size,

2703

size_t alignment,

2704

VkSystemAllocationScope allocationScope);

2705

2706

typedef void (VKAPI_PTR *PFN_vkVoidFunction)(void);

2707

typedef struct VkAllocationCallbacks {

2708

void* pUserData;

2709

PFN_vkAllocationFunction pfnAllocation;

2710

PFN_vkReallocationFunction pfnReallocation;

2711

PFN_vkFreeFunction pfnFree;

2712

PFN_vkInternalAllocationNotification pfnInternalAllocation;

2713

PFN_vkInternalFreeNotification pfnInternalFree;

2714

} VkAllocationCallbacks;

2715

2716

typedef struct VkApplicationInfo {

2717

VkStructureType sType;

2718

const void* pNext;

2719

const char* pApplicationName;

2720

uint32_t applicationVersion;

2721

const char* pEngineName;

2722

uint32_t engineVersion;

2723

uint32_t apiVersion;

2724

} VkApplicationInfo;

2725

2726

typedef struct VkFormatProperties {

2727

VkFormatFeatureFlags linearTilingFeatures;

2728

VkFormatFeatureFlags optimalTilingFeatures;

2729

VkFormatFeatureFlags bufferFeatures;

2730

} VkFormatProperties;

2731

2732

typedef struct VkImageFormatProperties {

2733

VkExtent3D maxExtent;

2734

uint32_t maxMipLevels;

2735

uint32_t maxArrayLayers;

2736

VkSampleCountFlags sampleCounts;

2737

VkDeviceSize maxResourceSize;

2738

} VkImageFormatProperties;

2739

2740

typedef struct VkInstanceCreateInfo {

2741

VkStructureType sType;

2742

const void* pNext;

2743

VkInstanceCreateFlags flags;

2744

const VkApplicationInfo* pApplicationInfo;

2745

uint32_t enabledLayerCount;

2746

const char* const* ppEnabledLayerNames;

2747

uint32_t enabledExtensionCount;

2748

const char* const* ppEnabledExtensionNames;

2749

} VkInstanceCreateInfo;

2750

2751

typedef struct VkMemoryHeap {

2752

VkDeviceSize size;

2753

VkMemoryHeapFlags flags;

2754

} VkMemoryHeap;

2755

2756

typedef struct VkMemoryType {

2757

VkMemoryPropertyFlags propertyFlags;

2758

uint32_t heapIndex;

2759

} VkMemoryType;

2760

2761

typedef struct VkPhysicalDeviceFeatures {

2762

VkBool32 robustBufferAccess;

2763

VkBool32 fullDrawIndexUint32;

2764

VkBool32 imageCubeArray;

2765

VkBool32 independentBlend;

2766

VkBool32 geometryShader;

2767

VkBool32 tessellationShader;

2768

VkBool32 sampleRateShading;

2769

VkBool32 dualSrcBlend;

2770

VkBool32 logicOp;

2771

VkBool32 multiDrawIndirect;

2772

VkBool32 drawIndirectFirstInstance;

2773

VkBool32 depthClamp;

2774

VkBool32 depthBiasClamp;

2775

VkBool32 fillModeNonSolid;

2776

VkBool32 depthBounds;

2777

VkBool32 wideLines;

2778

VkBool32 largePoints;

2779

VkBool32 alphaToOne;

2780

VkBool32 multiViewport;

2781

VkBool32 samplerAnisotropy;

2782

VkBool32 textureCompressionETC2;

2783

VkBool32 textureCompressionASTC_LDR;

2784

VkBool32 textureCompressionBC;

2785

VkBool32 occlusionQueryPrecise;

2786

VkBool32 pipelineStatisticsQuery;

2787

VkBool32 vertexPipelineStoresAndAtomics;

2788

VkBool32 fragmentStoresAndAtomics;

2789

VkBool32 shaderTessellationAndGeometryPointSize;

2790

VkBool32 shaderImageGatherExtended;

2791

VkBool32 shaderStorageImageExtendedFormats;

2792

VkBool32 shaderStorageImageMultisample;

2793

VkBool32 shaderStorageImageReadWithoutFormat;

2794

VkBool32 shaderStorageImageWriteWithoutFormat;

2795

VkBool32 shaderUniformBufferArrayDynamicIndexing;

2796

VkBool32 shaderSampledImageArrayDynamicIndexing;

2797

VkBool32 shaderStorageBufferArrayDynamicIndexing;

2798

VkBool32 shaderStorageImageArrayDynamicIndexing;

2799

VkBool32 shaderClipDistance;

2800

VkBool32 shaderCullDistance;

2801

VkBool32 shaderFloat64;

2802

VkBool32 shaderInt64;

2803

VkBool32 shaderInt16;

2804

VkBool32 shaderResourceResidency;

2805

VkBool32 shaderResourceMinLod;

2806

VkBool32 sparseBinding;

2807

VkBool32 sparseResidencyBuffer;

2808

VkBool32 sparseResidencyImage2D;

2809

VkBool32 sparseResidencyImage3D;

2810

VkBool32 sparseResidency2Samples;

2811

VkBool32 sparseResidency4Samples;

2812

VkBool32 sparseResidency8Samples;

2813

VkBool32 sparseResidency16Samples;

2814

VkBool32 sparseResidencyAliased;

2815

VkBool32 variableMultisampleRate;

2816

VkBool32 inheritedQueries;

2817

} VkPhysicalDeviceFeatures;

2818

2819

typedef struct VkPhysicalDeviceLimits {

2820

uint32_t maxImageDimension1D;

2821

uint32_t maxImageDimension2D;

2822

uint32_t maxImageDimension3D;

2823

uint32_t maxImageDimensionCube;

2824

uint32_t maxImageArrayLayers;

2825

uint32_t maxTexelBufferElements;

2826

uint32_t maxUniformBufferRange;

2827

uint32_t maxStorageBufferRange;

2828

uint32_t maxPushConstantsSize;

2829

uint32_t maxMemoryAllocationCount;

2830

uint32_t maxSamplerAllocationCount;

2831

VkDeviceSize bufferImageGranularity;

2832

VkDeviceSize sparseAddressSpaceSize;

2833

uint32_t maxBoundDescriptorSets;

2834

uint32_t maxPerStageDescriptorSamplers;

2835

uint32_t maxPerStageDescriptorUniformBuffers;

2836

uint32_t maxPerStageDescriptorStorageBuffers;

2837

uint32_t maxPerStageDescriptorSampledImages;

2838

uint32_t maxPerStageDescriptorStorageImages;

2839

uint32_t maxPerStageDescriptorInputAttachments;

2840

uint32_t maxPerStageResources;

2841

uint32_t maxDescriptorSetSamplers;

2842

uint32_t maxDescriptorSetUniformBuffers;

2843

uint32_t maxDescriptorSetUniformBuffersDynamic;

2844

uint32_t maxDescriptorSetStorageBuffers;

2845

uint32_t maxDescriptorSetStorageBuffersDynamic;

2846

uint32_t maxDescriptorSetSampledImages;

2847

uint32_t maxDescriptorSetStorageImages;

2848

uint32_t maxDescriptorSetInputAttachments;

2849

uint32_t maxVertexInputAttributes;

2850

uint32_t maxVertexInputBindings;

2851

uint32_t maxVertexInputAttributeOffset;

2852

uint32_t maxVertexInputBindingStride;

2853

uint32_t maxVertexOutputComponents;

2854

uint32_t maxTessellationGenerationLevel;

2855

uint32_t maxTessellationPatchSize;

2856

uint32_t maxTessellationControlPerVertexInputComponents;

2857

uint32_t maxTessellationControlPerVertexOutputComponents;

2858

uint32_t maxTessellationControlPerPatchOutputComponents;

2859

uint32_t maxTessellationControlTotalOutputComponents;

2860

uint32_t maxTessellationEvaluationInputComponents;

2861

uint32_t maxTessellationEvaluationOutputComponents;

2862

uint32_t maxGeometryShaderInvocations;

2863

uint32_t maxGeometryInputComponents;

2864

uint32_t maxGeometryOutputComponents;

2865

uint32_t maxGeometryOutputVertices;

2866

uint32_t maxGeometryTotalOutputComponents;

2867

uint32_t maxFragmentInputComponents;

2868

uint32_t maxFragmentOutputAttachments;

2869

uint32_t maxFragmentDualSrcAttachments;

2870

uint32_t maxFragmentCombinedOutputResources;

2871

uint32_t maxComputeSharedMemorySize;

2872

uint32_t maxComputeWorkGroupCount[3];

2873

uint32_t maxComputeWorkGroupInvocations;

2874

uint32_t maxComputeWorkGroupSize[3];

2875

uint32_t subPixelPrecisionBits;

2876

uint32_t subTexelPrecisionBits;

2877

uint32_t mipmapPrecisionBits;

2878

uint32_t maxDrawIndexedIndexValue;

2879

uint32_t maxDrawIndirectCount;

2880

float maxSamplerLodBias;

2881

float maxSamplerAnisotropy;

2882

uint32_t maxViewports;

2883

uint32_t maxViewportDimensions[2];

2884

float viewportBoundsRange[2];

2885

uint32_t viewportSubPixelBits;

2886

size_t minMemoryMapAlignment;

2887

VkDeviceSize minTexelBufferOffsetAlignment;

2888

VkDeviceSize minUniformBufferOffsetAlignment;

2889

VkDeviceSize minStorageBufferOffsetAlignment;

2890

int32_t minTexelOffset;

2891

uint32_t maxTexelOffset;

2892

int32_t minTexelGatherOffset;

2893

uint32_t maxTexelGatherOffset;

2894

float minInterpolationOffset;

2895

float maxInterpolationOffset;

2896

uint32_t subPixelInterpolationOffsetBits;

2897

uint32_t maxFramebufferWidth;

2898

uint32_t maxFramebufferHeight;

2899

uint32_t maxFramebufferLayers;

2900

VkSampleCountFlags framebufferColorSampleCounts;

2901

VkSampleCountFlags framebufferDepthSampleCounts;

2902

VkSampleCountFlags framebufferStencilSampleCounts;

2903

VkSampleCountFlags framebufferNoAttachmentsSampleCounts;

2904

uint32_t maxColorAttachments;

2905

VkSampleCountFlags sampledImageColorSampleCounts;

2906

VkSampleCountFlags sampledImageIntegerSampleCounts;

2907

VkSampleCountFlags sampledImageDepthSampleCounts;

2908

VkSampleCountFlags sampledImageStencilSampleCounts;

2909

VkSampleCountFlags storageImageSampleCounts;

2910

uint32_t maxSampleMaskWords;

2911

VkBool32 timestampComputeAndGraphics;

2912

float timestampPeriod;

2913

uint32_t maxClipDistances;

2914

uint32_t maxCullDistances;

2915

uint32_t maxCombinedClipAndCullDistances;

2916

uint32_t discreteQueuePriorities;

2917

float pointSizeRange[2];

2918

float lineWidthRange[2];

2919

float pointSizeGranularity;

2920

float lineWidthGranularity;

2921

VkBool32 strictLines;

2922

VkBool32 standardSampleLocations;

2923

VkDeviceSize optimalBufferCopyOffsetAlignment;

2924

VkDeviceSize optimalBufferCopyRowPitchAlignment;

2925

VkDeviceSize nonCoherentAtomSize;

2926

} VkPhysicalDeviceLimits;

2927

2928

typedef struct VkPhysicalDeviceMemoryProperties {

2929

uint32_t memoryTypeCount;

2930

VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES];

2931

uint32_t memoryHeapCount;

2932

VkMemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS];

2933

} VkPhysicalDeviceMemoryProperties;

2934

2935

typedef struct VkPhysicalDeviceSparseProperties {

2936

VkBool32 residencyStandard2DBlockShape;

2937

VkBool32 residencyStandard2DMultisampleBlockShape;

2938

VkBool32 residencyStandard3DBlockShape;

2939

VkBool32 residencyAlignedMipSize;

2940

VkBool32 residencyNonResidentStrict;

2941

} VkPhysicalDeviceSparseProperties;

2942

2943

typedef struct VkPhysicalDeviceProperties {

2944

uint32_t apiVersion;

2945

uint32_t driverVersion;

2946

uint32_t vendorID;

2947

uint32_t deviceID;

2948

VkPhysicalDeviceType deviceType;

2949

char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];

2950

uint8_t pipelineCacheUUID[VK_UUID_SIZE];

2951

VkPhysicalDeviceLimits limits;

2952

VkPhysicalDeviceSparseProperties sparseProperties;

2953

} VkPhysicalDeviceProperties;

2954

2955

typedef struct VkQueueFamilyProperties {

2956

VkQueueFlags queueFlags;

2957

uint32_t queueCount;

2958

uint32_t timestampValidBits;

2959

VkExtent3D minImageTransferGranularity;

2960

} VkQueueFamilyProperties;

2961

2962

typedef struct VkDeviceQueueCreateInfo {

2963

VkStructureType sType;

2964

const void* pNext;

2965

VkDeviceQueueCreateFlags flags;

2966

uint32_t queueFamilyIndex;

2967

uint32_t queueCount;

2968

const float* pQueuePriorities;

2969

} VkDeviceQueueCreateInfo;

2970

2971

typedef struct VkDeviceCreateInfo {

2972

VkStructureType sType;

2973

const void* pNext;

2974

VkDeviceCreateFlags flags;

2975

uint32_t queueCreateInfoCount;

2976

const VkDeviceQueueCreateInfo* pQueueCreateInfos;

2977

uint32_t enabledLayerCount;

2978

const char* const* ppEnabledLayerNames;

2979

uint32_t enabledExtensionCount;

2980

const char* const* ppEnabledExtensionNames;

2981

const VkPhysicalDeviceFeatures* pEnabledFeatures;

2982

} VkDeviceCreateInfo;

2983

2984

typedef struct VkExtensionProperties {

2985

char extensionName[VK_MAX_EXTENSION_NAME_SIZE];

2986

uint32_t specVersion;

2987

} VkExtensionProperties;

2988

2989

typedef struct VkLayerProperties {

2990

char layerName[VK_MAX_EXTENSION_NAME_SIZE];

2991

uint32_t specVersion;

2992

uint32_t implementationVersion;

2993

char description[VK_MAX_DESCRIPTION_SIZE];

2994

} VkLayerProperties;

2995

2996

typedef struct VkSubmitInfo {

2997

VkStructureType sType;

2998

const void* pNext;

2999

uint32_t waitSemaphoreCount;

3000

const VkSemaphore* pWaitSemaphores;

3001

const VkPipelineStageFlags* pWaitDstStageMask;

3002

uint32_t commandBufferCount;

3003

const VkCommandBuffer* pCommandBuffers;

3004

uint32_t signalSemaphoreCount;

3005

const VkSemaphore* pSignalSemaphores;

3006

} VkSubmitInfo;

3007

3008

typedef struct VkMappedMemoryRange {

3009

VkStructureType sType;

3010

const void* pNext;

3011

VkDeviceMemory memory;

3012

VkDeviceSize offset;

3013

VkDeviceSize size;

3014

} VkMappedMemoryRange;

3015

3016

typedef struct VkMemoryAllocateInfo {

3017

VkStructureType sType;

3018

const void* pNext;

3019

VkDeviceSize allocationSize;

3020

uint32_t memoryTypeIndex;

3021

} VkMemoryAllocateInfo;

3022

3023

typedef struct VkMemoryRequirements {

3024

VkDeviceSize size;

3025

VkDeviceSize alignment;

3026

uint32_t memoryTypeBits;

3027

} VkMemoryRequirements;

3028

3029

typedef struct VkSparseMemoryBind {

3030

VkDeviceSize resourceOffset;

3031

VkDeviceSize size;

3032

VkDeviceMemory memory;

3033

VkDeviceSize memoryOffset;

3034

VkSparseMemoryBindFlags flags;

3035

} VkSparseMemoryBind;

3036

3037

typedef struct VkSparseBufferMemoryBindInfo {

3038

VkBuffer buffer;

3039

uint32_t bindCount;

3040

const VkSparseMemoryBind* pBinds;

3041

} VkSparseBufferMemoryBindInfo;

3042

3043

typedef struct VkSparseImageOpaqueMemoryBindInfo {

3044

VkImage image;

3045

uint32_t bindCount;

3046

const VkSparseMemoryBind* pBinds;

3047

} VkSparseImageOpaqueMemoryBindInfo;

3048

3049

typedef struct VkImageSubresource {

3050

VkImageAspectFlags aspectMask;

3051

uint32_t mipLevel;

3052

uint32_t arrayLayer;

3053

} VkImageSubresource;

3054

3055

typedef struct VkSparseImageMemoryBind {

3056

VkImageSubresource subresource;

3057

VkOffset3D offset;

3058

VkExtent3D extent;

3059

VkDeviceMemory memory;

3060

VkDeviceSize memoryOffset;

3061

VkSparseMemoryBindFlags flags;

3062

} VkSparseImageMemoryBind;

3063

3064

typedef struct VkSparseImageMemoryBindInfo {

3065

VkImage image;

3066

uint32_t bindCount;

3067

const VkSparseImageMemoryBind* pBinds;

3068

} VkSparseImageMemoryBindInfo;

3069

3070

typedef struct VkBindSparseInfo {

3071

VkStructureType sType;

3072

const void* pNext;

3073

uint32_t waitSemaphoreCount;

3074

const VkSemaphore* pWaitSemaphores;

3075

uint32_t bufferBindCount;

3076

const VkSparseBufferMemoryBindInfo* pBufferBinds;

3077

uint32_t imageOpaqueBindCount;

3078

const VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds;

3079

uint32_t imageBindCount;

3080

const VkSparseImageMemoryBindInfo* pImageBinds;

3081

uint32_t signalSemaphoreCount;

3082

const VkSemaphore* pSignalSemaphores;

3083

} VkBindSparseInfo;

3084

3085

typedef struct VkSparseImageFormatProperties {

3086

VkImageAspectFlags aspectMask;

3087

VkExtent3D imageGranularity;

3088

VkSparseImageFormatFlags flags;

3089

} VkSparseImageFormatProperties;

3090

3091

typedef struct VkSparseImageMemoryRequirements {

3092

VkSparseImageFormatProperties formatProperties;

3093

uint32_t imageMipTailFirstLod;

3094

VkDeviceSize imageMipTailSize;

3095

VkDeviceSize imageMipTailOffset;

3096

VkDeviceSize imageMipTailStride;

3097

} VkSparseImageMemoryRequirements;

3098

3099

typedef struct VkFenceCreateInfo {

3100

VkStructureType sType;

3101

const void* pNext;

3102

VkFenceCreateFlags flags;

3103

} VkFenceCreateInfo;

3104

3105

typedef struct VkSemaphoreCreateInfo {

3106

VkStructureType sType;

3107

const void* pNext;

3108

VkSemaphoreCreateFlags flags;

3109

} VkSemaphoreCreateInfo;

3110

3111

typedef struct VkEventCreateInfo {

3112

VkStructureType sType;

3113

const void* pNext;

3114

VkEventCreateFlags flags;

3115

} VkEventCreateInfo;

3116

3117

typedef struct VkQueryPoolCreateInfo {

3118

VkStructureType sType;

3119

const void* pNext;

3120

VkQueryPoolCreateFlags flags;

3121

VkQueryType queryType;

3122

uint32_t queryCount;

3123

VkQueryPipelineStatisticFlags pipelineStatistics;

3124

} VkQueryPoolCreateInfo;

3125

3126

typedef struct VkBufferCreateInfo {

3127

VkStructureType sType;

3128

const void* pNext;

3129

VkBufferCreateFlags flags;

3130

VkDeviceSize size;

3131

VkBufferUsageFlags usage;

3132

VkSharingMode sharingMode;

3133

uint32_t queueFamilyIndexCount;

3134

const uint32_t* pQueueFamilyIndices;

3135

} VkBufferCreateInfo;

3136

3137

typedef struct VkBufferViewCreateInfo {

3138

VkStructureType sType;

3139

const void* pNext;

3140

VkBufferViewCreateFlags flags;

3141

VkBuffer buffer;

3142

VkFormat format;

3143

VkDeviceSize offset;

3144

VkDeviceSize range;

3145

} VkBufferViewCreateInfo;

3146

3147

typedef struct VkImageCreateInfo {

3148

VkStructureType sType;

3149

const void* pNext;

3150

VkImageCreateFlags flags;

3151

VkImageType imageType;

3152

VkFormat format;

3153

VkExtent3D extent;

3154

uint32_t mipLevels;

3155

uint32_t arrayLayers;

3156

VkSampleCountFlagBits samples;

3157

VkImageTiling tiling;

3158

VkImageUsageFlags usage;

3159

VkSharingMode sharingMode;

3160

uint32_t queueFamilyIndexCount;

3161

const uint32_t* pQueueFamilyIndices;

3162

VkImageLayout initialLayout;

3163

} VkImageCreateInfo;

3164

3165

typedef struct VkSubresourceLayout {

3166

VkDeviceSize offset;

3167

VkDeviceSize size;

3168

VkDeviceSize rowPitch;

3169

VkDeviceSize arrayPitch;

3170

VkDeviceSize depthPitch;

3171

} VkSubresourceLayout;

3172

3173

typedef struct VkComponentMapping {

3174

VkComponentSwizzle r;

3175

VkComponentSwizzle g;

3176

VkComponentSwizzle b;

3177

VkComponentSwizzle a;

3178

} VkComponentMapping;

3179

3180

typedef struct VkImageViewCreateInfo {

3181

VkStructureType sType;

3182

const void* pNext;

3183

VkImageViewCreateFlags flags;

3184

VkImage image;

3185

VkImageViewType viewType;

3186

VkFormat format;

3187

VkComponentMapping components;

3188

VkImageSubresourceRange subresourceRange;

3189

} VkImageViewCreateInfo;

3190

3191

typedef struct VkShaderModuleCreateInfo {

3192

VkStructureType sType;

3193

const void* pNext;

3194

VkShaderModuleCreateFlags flags;

3195

size_t codeSize;

3196

const uint32_t* pCode;

3197

} VkShaderModuleCreateInfo;

3198

3199

typedef struct VkPipelineCacheCreateInfo {

3200

VkStructureType sType;

3201

const void* pNext;

3202

VkPipelineCacheCreateFlags flags;

3203

size_t initialDataSize;

3204

const void* pInitialData;

3205

} VkPipelineCacheCreateInfo;

3206

3207

typedef struct VkSpecializationMapEntry {

3208

uint32_t constantID;

3209

uint32_t offset;

3210

size_t size;

3211

} VkSpecializationMapEntry;

3212

3213

typedef struct VkSpecializationInfo {

3214

uint32_t mapEntryCount;

3215

const VkSpecializationMapEntry* pMapEntries;

3216

size_t dataSize;

3217

const void* pData;

3218

} VkSpecializationInfo;

3219

3220

typedef struct VkPipelineShaderStageCreateInfo {

3221

VkStructureType sType;

3222

const void* pNext;

3223

VkPipelineShaderStageCreateFlags flags;

3224

VkShaderStageFlagBits stage;

3225

VkShaderModule module;

3226

const char* pName;

3227

const VkSpecializationInfo* pSpecializationInfo;

3228

} VkPipelineShaderStageCreateInfo;

3229

3230

typedef struct VkComputePipelineCreateInfo {

3231

VkStructureType sType;

3232

const void* pNext;

3233

VkPipelineCreateFlags flags;

3234

VkPipelineShaderStageCreateInfo stage;

3235

VkPipelineLayout layout;

3236

VkPipeline basePipelineHandle;

3237

int32_t basePipelineIndex;

3238

} VkComputePipelineCreateInfo;

3239

3240

typedef struct VkVertexInputBindingDescription {

3241

uint32_t binding;

3242

uint32_t stride;

3243

VkVertexInputRate inputRate;

3244

} VkVertexInputBindingDescription;

3245

3246

typedef struct VkVertexInputAttributeDescription {

3247

uint32_t location;

3248

uint32_t binding;

3249

VkFormat format;

3250

uint32_t offset;

3251

} VkVertexInputAttributeDescription;

3252

3253

typedef struct VkPipelineVertexInputStateCreateInfo {

3254

VkStructureType sType;

3255

const void* pNext;

3256

VkPipelineVertexInputStateCreateFlags flags;

3257

uint32_t vertexBindingDescriptionCount;

3258

const VkVertexInputBindingDescription* pVertexBindingDescriptions;

3259

uint32_t vertexAttributeDescriptionCount;

3260

const VkVertexInputAttributeDescription* pVertexAttributeDescriptions;

3261

} VkPipelineVertexInputStateCreateInfo;

3262

3263

typedef struct VkPipelineInputAssemblyStateCreateInfo {

3264

VkStructureType sType;

3265

const void* pNext;

3266

VkPipelineInputAssemblyStateCreateFlags flags;

3267

VkPrimitiveTopology topology;

3268

VkBool32 primitiveRestartEnable;

3269

} VkPipelineInputAssemblyStateCreateInfo;

3270

3271

typedef struct VkPipelineTessellationStateCreateInfo {

3272

VkStructureType sType;

3273

const void* pNext;

3274

VkPipelineTessellationStateCreateFlags flags;

3275

uint32_t patchControlPoints;

3276

} VkPipelineTessellationStateCreateInfo;

3277

3278

typedef struct VkViewport {

3279

float x;

3280

float y;

3281

float width;

3282

float height;

3283

float minDepth;

3284

float maxDepth;

3285

} VkViewport;

3286

3287

typedef struct VkPipelineViewportStateCreateInfo {

3288

VkStructureType sType;

3289

const void* pNext;

3290

VkPipelineViewportStateCreateFlags flags;

3291

uint32_t viewportCount;

3292

const VkViewport* pViewports;

3293

uint32_t scissorCount;

3294

const VkRect2D* pScissors;

3295

} VkPipelineViewportStateCreateInfo;

3296

3297

typedef struct VkPipelineRasterizationStateCreateInfo {

3298

VkStructureType sType;

3299

const void* pNext;

3300

VkPipelineRasterizationStateCreateFlags flags;

3301

VkBool32 depthClampEnable;

3302

VkBool32 rasterizerDiscardEnable;

3303

VkPolygonMode polygonMode;

3304

VkCullModeFlags cullMode;

3305

VkFrontFace frontFace;

3306

VkBool32 depthBiasEnable;

3307

float depthBiasConstantFactor;

3308

float depthBiasClamp;

3309

float depthBiasSlopeFactor;

3310

float lineWidth;

3311

} VkPipelineRasterizationStateCreateInfo;

3312

3313

typedef struct VkPipelineMultisampleStateCreateInfo {

3314

VkStructureType sType;

3315

const void* pNext;

3316

VkPipelineMultisampleStateCreateFlags flags;

3317

VkSampleCountFlagBits rasterizationSamples;

3318

VkBool32 sampleShadingEnable;

3319

float minSampleShading;

3320

const VkSampleMask* pSampleMask;

3321

VkBool32 alphaToCoverageEnable;

3322

VkBool32 alphaToOneEnable;

3323

} VkPipelineMultisampleStateCreateInfo;

3324

3325

typedef struct VkStencilOpState {

3326

VkStencilOp failOp;

3327

VkStencilOp passOp;

3328

VkStencilOp depthFailOp;

3329

VkCompareOp compareOp;

3330

uint32_t compareMask;

3331

uint32_t writeMask;

3332

uint32_t reference;

3333

} VkStencilOpState;

3334

3335

typedef struct VkPipelineDepthStencilStateCreateInfo {

3336

VkStructureType sType;

3337

const void* pNext;

3338

VkPipelineDepthStencilStateCreateFlags flags;

3339

VkBool32 depthTestEnable;

3340

VkBool32 depthWriteEnable;

3341

VkCompareOp depthCompareOp;

3342

VkBool32 depthBoundsTestEnable;

3343

VkBool32 stencilTestEnable;

3344

VkStencilOpState front;

3345

VkStencilOpState back;

3346

float minDepthBounds;

3347

float maxDepthBounds;

3348

} VkPipelineDepthStencilStateCreateInfo;

3349

3350

typedef struct VkPipelineColorBlendAttachmentState {

3351

VkBool32 blendEnable;

3352

VkBlendFactor srcColorBlendFactor;

3353

VkBlendFactor dstColorBlendFactor;

3354

VkBlendOp colorBlendOp;

3355

VkBlendFactor srcAlphaBlendFactor;

3356

VkBlendFactor dstAlphaBlendFactor;

3357

VkBlendOp alphaBlendOp;

3358

VkColorComponentFlags colorWriteMask;

3359

} VkPipelineColorBlendAttachmentState;

3360

3361

typedef struct VkPipelineColorBlendStateCreateInfo {

3362

VkStructureType sType;

3363

const void* pNext;

3364

VkPipelineColorBlendStateCreateFlags flags;

3365

VkBool32 logicOpEnable;

3366

VkLogicOp logicOp;

3367

uint32_t attachmentCount;

3368

const VkPipelineColorBlendAttachmentState* pAttachments;

3369

float blendConstants[4];

3370

} VkPipelineColorBlendStateCreateInfo;

3371

3372

typedef struct VkPipelineDynamicStateCreateInfo {

3373

VkStructureType sType;

3374

const void* pNext;

3375

VkPipelineDynamicStateCreateFlags flags;

3376

uint32_t dynamicStateCount;

3377

const VkDynamicState* pDynamicStates;

3378

} VkPipelineDynamicStateCreateInfo;

3379

3380

typedef struct VkGraphicsPipelineCreateInfo {

3381

VkStructureType sType;

3382

const void* pNext;

3383

VkPipelineCreateFlags flags;

3384

uint32_t stageCount;

3385

const VkPipelineShaderStageCreateInfo* pStages;

3386

const VkPipelineVertexInputStateCreateInfo* pVertexInputState;

3387

const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState;

3388

const VkPipelineTessellationStateCreateInfo* pTessellationState;

3389

const VkPipelineViewportStateCreateInfo* pViewportState;

3390

const VkPipelineRasterizationStateCreateInfo* pRasterizationState;

3391

const VkPipelineMultisampleStateCreateInfo* pMultisampleState;

3392

const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState;

3393

const VkPipelineColorBlendStateCreateInfo* pColorBlendState;

3394

const VkPipelineDynamicStateCreateInfo* pDynamicState;

3395

VkPipelineLayout layout;

3396

VkRenderPass renderPass;

3397

uint32_t subpass;

3398

VkPipeline basePipelineHandle;

3399

int32_t basePipelineIndex;

3400

} VkGraphicsPipelineCreateInfo;

3401

3402

typedef struct VkPushConstantRange {

3403

VkShaderStageFlags stageFlags;

3404

uint32_t offset;

3405

uint32_t size;

3406

} VkPushConstantRange;

3407

3408

typedef struct VkPipelineLayoutCreateInfo {

3409

VkStructureType sType;

3410

const void* pNext;

3411

VkPipelineLayoutCreateFlags flags;

3412

uint32_t setLayoutCount;

3413

const VkDescriptorSetLayout* pSetLayouts;

3414

uint32_t pushConstantRangeCount;

3415

const VkPushConstantRange* pPushConstantRanges;

3416

} VkPipelineLayoutCreateInfo;

3417

3418

typedef struct VkSamplerCreateInfo {

3419

VkStructureType sType;

3420

const void* pNext;

3421

VkSamplerCreateFlags flags;

3422

VkFilter magFilter;

3423

VkFilter minFilter;

3424

VkSamplerMipmapMode mipmapMode;

3425

VkSamplerAddressMode addressModeU;

3426

VkSamplerAddressMode addressModeV;

3427

VkSamplerAddressMode addressModeW;

3428

float mipLodBias;

3429

VkBool32 anisotropyEnable;

3430

float maxAnisotropy;

3431

VkBool32 compareEnable;

3432

VkCompareOp compareOp;

3433

float minLod;

3434

float maxLod;

3435

VkBorderColor borderColor;

3436

VkBool32 unnormalizedCoordinates;

3437

} VkSamplerCreateInfo;

3438

3439

typedef struct VkCopyDescriptorSet {

3440

VkStructureType sType;

3441

const void* pNext;

3442

VkDescriptorSet srcSet;

3443

uint32_t srcBinding;

3444

uint32_t srcArrayElement;

3445

VkDescriptorSet dstSet;

3446

uint32_t dstBinding;

3447

uint32_t dstArrayElement;

3448

uint32_t descriptorCount;

3449

} VkCopyDescriptorSet;

3450

3451

typedef struct VkDescriptorBufferInfo {

3452

VkBuffer buffer;

3453

VkDeviceSize offset;

3454

VkDeviceSize range;

3455

} VkDescriptorBufferInfo;

3456

3457

typedef struct VkDescriptorImageInfo {

3458

VkSampler sampler;

3459

VkImageView imageView;

3460

VkImageLayout imageLayout;

3461

} VkDescriptorImageInfo;

3462

3463

typedef struct VkDescriptorPoolSize {

3464

VkDescriptorType type;

3465

uint32_t descriptorCount;

3466

} VkDescriptorPoolSize;

3467

3468

typedef struct VkDescriptorPoolCreateInfo {

3469

VkStructureType sType;

3470

const void* pNext;

3471

VkDescriptorPoolCreateFlags flags;

3472

uint32_t maxSets;

3473

uint32_t poolSizeCount;

3474

const VkDescriptorPoolSize* pPoolSizes;

3475

} VkDescriptorPoolCreateInfo;

3476

3477

typedef struct VkDescriptorSetAllocateInfo {

3478

VkStructureType sType;

3479

const void* pNext;

3480

VkDescriptorPool descriptorPool;

3481

uint32_t descriptorSetCount;

3482

const VkDescriptorSetLayout* pSetLayouts;

3483

} VkDescriptorSetAllocateInfo;

3484

3485

typedef struct VkDescriptorSetLayoutBinding {

3486

uint32_t binding;

3487

VkDescriptorType descriptorType;

3488

uint32_t descriptorCount;

3489

VkShaderStageFlags stageFlags;

3490

const VkSampler* pImmutableSamplers;

3491

} VkDescriptorSetLayoutBinding;

3492

3493

typedef struct VkDescriptorSetLayoutCreateInfo {

3494

VkStructureType sType;

3495

const void* pNext;

3496

VkDescriptorSetLayoutCreateFlags flags;

3497

uint32_t bindingCount;

3498

const VkDescriptorSetLayoutBinding* pBindings;

3499

} VkDescriptorSetLayoutCreateInfo;

3500

3501

typedef struct VkWriteDescriptorSet {

3502

VkStructureType sType;

3503

const void* pNext;

3504

VkDescriptorSet dstSet;

3505

uint32_t dstBinding;

3506

uint32_t dstArrayElement;

3507

uint32_t descriptorCount;

3508

VkDescriptorType descriptorType;

3509

const VkDescriptorImageInfo* pImageInfo;

3510

const VkDescriptorBufferInfo* pBufferInfo;

3511

const VkBufferView* pTexelBufferView;

3512

} VkWriteDescriptorSet;

3513

3514

typedef struct VkAttachmentDescription {

3515

VkAttachmentDescriptionFlags flags;

3516

VkFormat format;

3517

VkSampleCountFlagBits samples;

3518

VkAttachmentLoadOp loadOp;

3519

VkAttachmentStoreOp storeOp;

3520

VkAttachmentLoadOp stencilLoadOp;

3521

VkAttachmentStoreOp stencilStoreOp;

3522

VkImageLayout initialLayout;

3523

VkImageLayout finalLayout;

3524

} VkAttachmentDescription;

3525

3526

typedef struct VkAttachmentReference {

3527

uint32_t attachment;

3528

VkImageLayout layout;

3529

} VkAttachmentReference;

3530

3531

typedef struct VkFramebufferCreateInfo {

3532

VkStructureType sType;

3533

const void* pNext;

3534

VkFramebufferCreateFlags flags;

3535

VkRenderPass renderPass;

3536

uint32_t attachmentCount;

3537

const VkImageView* pAttachments;

3538

uint32_t width;

3539

uint32_t height;

3540

uint32_t layers;

3541

} VkFramebufferCreateInfo;

3542

3543

typedef struct VkSubpassDescription {

3544

VkSubpassDescriptionFlags flags;

3545

VkPipelineBindPoint pipelineBindPoint;

3546

uint32_t inputAttachmentCount;

3547

const VkAttachmentReference* pInputAttachments;

3548

uint32_t colorAttachmentCount;

3549

const VkAttachmentReference* pColorAttachments;

3550

const VkAttachmentReference* pResolveAttachments;

3551

const VkAttachmentReference* pDepthStencilAttachment;

3552

uint32_t preserveAttachmentCount;

3553

const uint32_t* pPreserveAttachments;

3554

} VkSubpassDescription;

3555

3556

typedef struct VkSubpassDependency {

3557

uint32_t srcSubpass;

3558

uint32_t dstSubpass;

3559

VkPipelineStageFlags srcStageMask;

3560

VkPipelineStageFlags dstStageMask;

3561

VkAccessFlags srcAccessMask;

3562

VkAccessFlags dstAccessMask;

3563

VkDependencyFlags dependencyFlags;

3564

} VkSubpassDependency;

3565

3566

typedef struct VkRenderPassCreateInfo {

3567

VkStructureType sType;

3568

const void* pNext;

3569

VkRenderPassCreateFlags flags;

3570

uint32_t attachmentCount;

3571

const VkAttachmentDescription* pAttachments;

3572

uint32_t subpassCount;

3573

const VkSubpassDescription* pSubpasses;

3574

uint32_t dependencyCount;

3575

const VkSubpassDependency* pDependencies;

3576

} VkRenderPassCreateInfo;

3577

3578

typedef struct VkCommandPoolCreateInfo {

3579

VkStructureType sType;

3580

const void* pNext;

3581

VkCommandPoolCreateFlags flags;

3582

uint32_t queueFamilyIndex;

3583

} VkCommandPoolCreateInfo;

3584

3585

typedef struct VkCommandBufferAllocateInfo {

3586

VkStructureType sType;

3587

const void* pNext;

3588

VkCommandPool commandPool;

3589

VkCommandBufferLevel level;

3590

uint32_t commandBufferCount;

3591

} VkCommandBufferAllocateInfo;

3592

3593

typedef struct VkCommandBufferInheritanceInfo {

3594

VkStructureType sType;

3595

const void* pNext;

3596

VkRenderPass renderPass;

3597

uint32_t subpass;

3598

VkFramebuffer framebuffer;

3599

VkBool32 occlusionQueryEnable;

3600

VkQueryControlFlags queryFlags;

3601

VkQueryPipelineStatisticFlags pipelineStatistics;

3602

} VkCommandBufferInheritanceInfo;

3603

3604

typedef struct VkCommandBufferBeginInfo {

3605

VkStructureType sType;

3606

const void* pNext;

3607

VkCommandBufferUsageFlags flags;

3608

const VkCommandBufferInheritanceInfo* pInheritanceInfo;

3609

} VkCommandBufferBeginInfo;

3610

3611

typedef struct VkBufferCopy {

3612

VkDeviceSize srcOffset;

3613

VkDeviceSize dstOffset;

3614

VkDeviceSize size;

3615

} VkBufferCopy;

3616

3617

typedef struct VkImageSubresourceLayers {

3618

VkImageAspectFlags aspectMask;

3619

uint32_t mipLevel;

3620

uint32_t baseArrayLayer;

3621

uint32_t layerCount;

3622

} VkImageSubresourceLayers;

3623

3624

typedef struct VkBufferImageCopy {

3625

VkDeviceSize bufferOffset;

3626

uint32_t bufferRowLength;

3627

uint32_t bufferImageHeight;

3628

VkImageSubresourceLayers imageSubresource;

3629

VkOffset3D imageOffset;

3630

VkExtent3D imageExtent;

3631

} VkBufferImageCopy;

3632

3633

typedef union VkClearColorValue {

3634

float float32[4];

3635

int32_t int32[4];

3636

uint32_t uint32[4];

3637

} VkClearColorValue;

3638

3639

typedef struct VkClearDepthStencilValue {

3640

float depth;

3641

uint32_t stencil;

3642

} VkClearDepthStencilValue;

3643

3644

typedef union VkClearValue {

3645

VkClearColorValue color;

3646

VkClearDepthStencilValue depthStencil;

3647

} VkClearValue;

3648

3649

typedef struct VkClearAttachment {

3650

VkImageAspectFlags aspectMask;

3651

uint32_t colorAttachment;

3652

VkClearValue clearValue;

3653

} VkClearAttachment;

3654

3655

typedef struct VkClearRect {

3656

VkRect2D rect;

3657

uint32_t baseArrayLayer;

3658

uint32_t layerCount;

3659

} VkClearRect;

3660

3661

typedef struct VkImageBlit {

3662

VkImageSubresourceLayers srcSubresource;

3663

VkOffset3D srcOffsets[2];

3664

VkImageSubresourceLayers dstSubresource;

3665

VkOffset3D dstOffsets[2];

3666

} VkImageBlit;

3667

3668

typedef struct VkImageCopy {

3669

VkImageSubresourceLayers srcSubresource;

3670

VkOffset3D srcOffset;

3671

VkImageSubresourceLayers dstSubresource;

3672

VkOffset3D dstOffset;

3673

VkExtent3D extent;

3674

} VkImageCopy;

3675

3676

typedef struct VkImageResolve {

3677

VkImageSubresourceLayers srcSubresource;

3678

VkOffset3D srcOffset;

3679

VkImageSubresourceLayers dstSubresource;

3680

VkOffset3D dstOffset;

3681

VkExtent3D extent;

3682

} VkImageResolve;

3683

3684

typedef struct VkRenderPassBeginInfo {

3685

VkStructureType sType;

3686

const void* pNext;

3687

VkRenderPass renderPass;

3688

VkFramebuffer framebuffer;

3689

VkRect2D renderArea;

3690

uint32_t clearValueCount;

3691

const VkClearValue* pClearValues;

3692

} VkRenderPassBeginInfo;

3693

3694

typedef VkResult (VKAPI_PTR *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance);

3695

typedef void (VKAPI_PTR *PFN_vkDestroyInstance)(VkInstance instance, const VkAllocationCallbacks* pAllocator);

3696

typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);

3697

typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);

3698

typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);

3699

typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties);

3700

typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);

3701

typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties);

3702

typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);

3703

typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName);

3704

typedef PFN_vkVoidFunction (VKAPI_PTR *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName);

3705

typedef VkResult (VKAPI_PTR *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice);

3706

typedef void (VKAPI_PTR *PFN_vkDestroyDevice)(VkDevice device, const VkAllocationCallbacks* pAllocator);

3707

typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);

3708

typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);

3709

typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pPropertyCount, VkLayerProperties* pProperties);

3710

typedef VkResult (VKAPI_PTR *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties);

3711

typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);

3712

typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence);

3713

typedef VkResult (VKAPI_PTR *PFN_vkQueueWaitIdle)(VkQueue queue);

3714

typedef VkResult (VKAPI_PTR *PFN_vkDeviceWaitIdle)(VkDevice device);

3715

typedef VkResult (VKAPI_PTR *PFN_vkAllocateMemory)(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory);

3716

typedef void (VKAPI_PTR *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator);

3717

typedef VkResult (VKAPI_PTR *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData);

3718

typedef void (VKAPI_PTR *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory memory);

3719

typedef VkResult (VKAPI_PTR *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);

3720

typedef VkResult (VKAPI_PTR *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);

3721

typedef void (VKAPI_PTR *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes);

3722

typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset);

3723

typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset);

3724

typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);

3725

typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);

3726

typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);

3727

typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties);

3728

typedef VkResult (VKAPI_PTR *PFN_vkQueueBindSparse)(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence);

3729

typedef VkResult (VKAPI_PTR *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);

3730

typedef void (VKAPI_PTR *PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator);

3731

typedef VkResult (VKAPI_PTR *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences);

3732

typedef VkResult (VKAPI_PTR *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence);

3733

typedef VkResult (VKAPI_PTR *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout);

3734

typedef VkResult (VKAPI_PTR *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore);

3735

typedef void (VKAPI_PTR *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator);

3736

typedef VkResult (VKAPI_PTR *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent);

3737

typedef void (VKAPI_PTR *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator);

3738

typedef VkResult (VKAPI_PTR *PFN_vkGetEventStatus)(VkDevice device, VkEvent event);

3739

typedef VkResult (VKAPI_PTR *PFN_vkSetEvent)(VkDevice device, VkEvent event);

3740

typedef VkResult (VKAPI_PTR *PFN_vkResetEvent)(VkDevice device, VkEvent event);

3741

typedef VkResult (VKAPI_PTR *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool);

3742

typedef void (VKAPI_PTR *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator);

3743

typedef VkResult (VKAPI_PTR *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags);

3744

typedef VkResult (VKAPI_PTR *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer);

3745

typedef void (VKAPI_PTR *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator);

3746

typedef VkResult (VKAPI_PTR *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView);

3747

typedef void (VKAPI_PTR *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator);

3748

typedef VkResult (VKAPI_PTR *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage);

3749

typedef void (VKAPI_PTR *PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator);

3750

typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);

3751

typedef VkResult (VKAPI_PTR *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView);

3752

typedef void (VKAPI_PTR *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator);

3753

typedef VkResult (VKAPI_PTR *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule);

3754

typedef void (VKAPI_PTR *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator);

3755

typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache);

3756

typedef void (VKAPI_PTR *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator);

3757

typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData);

3758

typedef VkResult (VKAPI_PTR *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);

3759

typedef VkResult (VKAPI_PTR *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);

3760

typedef VkResult (VKAPI_PTR *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);

3761

typedef void (VKAPI_PTR *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator);

3762

typedef VkResult (VKAPI_PTR *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout);

3763

typedef void (VKAPI_PTR *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator);

3764

typedef VkResult (VKAPI_PTR *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler);

3765

typedef void (VKAPI_PTR *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator);

3766

typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout);

3767

typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator);

3768

typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool);

3769

typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator);

3770

typedef VkResult (VKAPI_PTR *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags);

3771

typedef VkResult (VKAPI_PTR *PFN_vkAllocateDescriptorSets)(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets);

3772

typedef VkResult (VKAPI_PTR *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets);

3773

typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies);

3774

typedef VkResult (VKAPI_PTR *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer);

3775

typedef void (VKAPI_PTR *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator);

3776

typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass);

3777

typedef void (VKAPI_PTR *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator);

3778

typedef void (VKAPI_PTR *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);

3779

typedef VkResult (VKAPI_PTR *PFN_vkCreateCommandPool)(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool);

3780

typedef void (VKAPI_PTR *PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator);

3781

typedef VkResult (VKAPI_PTR *PFN_vkResetCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags);

3782

typedef VkResult (VKAPI_PTR *PFN_vkAllocateCommandBuffers)(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers);

3783

typedef void (VKAPI_PTR *PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);

3784

typedef VkResult (VKAPI_PTR *PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo);

3785

typedef VkResult (VKAPI_PTR *PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer);

3786

typedef VkResult (VKAPI_PTR *PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags);

3787

typedef void (VKAPI_PTR *PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);

3788

typedef void (VKAPI_PTR *PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports);

3789

typedef void (VKAPI_PTR *PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors);

3790

typedef void (VKAPI_PTR *PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, float lineWidth);

3791

typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor);

3792

typedef void (VKAPI_PTR *PFN_vkCmdSetBlendConstants)(VkCommandBuffer commandBuffer, const float blendConstants[4]);

3793

typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds);

3794

typedef void (VKAPI_PTR *PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask);

3795

typedef void (VKAPI_PTR *PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask);

3796

typedef void (VKAPI_PTR *PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference);

3797

typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorSets)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets);

3798

typedef void (VKAPI_PTR *PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);

3799

typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);

3800

typedef void (VKAPI_PTR *PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);

3801

typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);

3802

typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);

3803

typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);

3804

typedef void (VKAPI_PTR *PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);

3805

typedef void (VKAPI_PTR *PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset);

3806

typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions);

3807

typedef void (VKAPI_PTR *PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions);

3808

typedef void (VKAPI_PTR *PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter);

3809

typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions);

3810

typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions);

3811

typedef void (VKAPI_PTR *PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData);

3812

typedef void (VKAPI_PTR *PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data);

3813

typedef void (VKAPI_PTR *PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);

3814

typedef void (VKAPI_PTR *PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);

3815

typedef void (VKAPI_PTR *PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects);

3816

typedef void (VKAPI_PTR *PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions);

3817

typedef void (VKAPI_PTR *PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);

3818

typedef void (VKAPI_PTR *PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);

3819

typedef void (VKAPI_PTR *PFN_vkCmdWaitEvents)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers);

3820

typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier)(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers);

3821

typedef void (VKAPI_PTR *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags);

3822

typedef void (VKAPI_PTR *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query);

3823

typedef void (VKAPI_PTR *PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount);

3824

typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query);

3825

typedef void (VKAPI_PTR *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags);

3826

typedef void (VKAPI_PTR *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues);

3827

typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents);

3828

typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkSubpassContents contents);

3829

typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer);

3830

typedef void (VKAPI_PTR *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);

3831

3832

#ifndef VK_NO_PROTOTYPES

3833

VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(

3834

const VkInstanceCreateInfo* pCreateInfo,

3835

const VkAllocationCallbacks* pAllocator,

3836

VkInstance* pInstance);

3837

3838

VKAPI_ATTR void VKAPI_CALL vkDestroyInstance(

3839

VkInstance instance,

3840

const VkAllocationCallbacks* pAllocator);

3841

3842

VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices(

3843

VkInstance instance,

3844

uint32_t* pPhysicalDeviceCount,

3845

VkPhysicalDevice* pPhysicalDevices);

3846

3847

VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures(

3848

VkPhysicalDevice physicalDevice,

3849

VkPhysicalDeviceFeatures* pFeatures);

3850

3851

VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties(

3852

VkPhysicalDevice physicalDevice,

3853

VkFormat format,

3854

VkFormatProperties* pFormatProperties);

3855

3856

VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties(

3857

VkPhysicalDevice physicalDevice,

3858

VkFormat format,

3859

VkImageType type,

3860

VkImageTiling tiling,

3861

VkImageUsageFlags usage,

3862

VkImageCreateFlags flags,

3863

VkImageFormatProperties* pImageFormatProperties);

3864

3865

VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties(

3866

VkPhysicalDevice physicalDevice,

3867

VkPhysicalDeviceProperties* pProperties);

3868

3869

VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties(

3870

VkPhysicalDevice physicalDevice,

3871

uint32_t* pQueueFamilyPropertyCount,

3872

VkQueueFamilyProperties* pQueueFamilyProperties);

3873

3874

VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties(

3875

VkPhysicalDevice physicalDevice,

3876

VkPhysicalDeviceMemoryProperties* pMemoryProperties);

3877

3878

VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(

3879

VkInstance instance,

3880

const char* pName);

3881

3882

VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(

3883

VkDevice device,

3884

const char* pName);

3885

3886

VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(

3887

VkPhysicalDevice physicalDevice,

3888

const VkDeviceCreateInfo* pCreateInfo,

3889

const VkAllocationCallbacks* pAllocator,

3890

VkDevice* pDevice);

3891

3892

VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(

3893

VkDevice device,

3894

const VkAllocationCallbacks* pAllocator);

3895

3896

VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties(

3897

const char* pLayerName,

3898

uint32_t* pPropertyCount,

3899

VkExtensionProperties* pProperties);

3900

3901

VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(

3902

VkPhysicalDevice physicalDevice,

3903

const char* pLayerName,

3904

uint32_t* pPropertyCount,

3905

VkExtensionProperties* pProperties);

3906

3907

VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(

3908

uint32_t* pPropertyCount,

3909

VkLayerProperties* pProperties);

3910

3911

VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(

3912

VkPhysicalDevice physicalDevice,

3913

uint32_t* pPropertyCount,

3914

VkLayerProperties* pProperties);

3915

3916

VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue(

3917

VkDevice device,

3918

uint32_t queueFamilyIndex,

3919

uint32_t queueIndex,

3920

VkQueue* pQueue);

3921

3922

VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit(

3923

VkQueue queue,

3924

uint32_t submitCount,

3925

const VkSubmitInfo* pSubmits,

3926

VkFence fence);

3927

3928

VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle(

3929

VkQueue queue);

3930

3931

VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle(

3932

VkDevice device);

3933

3934

VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory(

3935

VkDevice device,

3936

const VkMemoryAllocateInfo* pAllocateInfo,

3937

const VkAllocationCallbacks* pAllocator,

3938

VkDeviceMemory* pMemory);

3939

3940

VKAPI_ATTR void VKAPI_CALL vkFreeMemory(

3941

VkDevice device,

3942

VkDeviceMemory memory,

3943

const VkAllocationCallbacks* pAllocator);

3944

3945

VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory(

3946

VkDevice device,

3947

VkDeviceMemory memory,

3948

VkDeviceSize offset,

3949

VkDeviceSize size,

3950

VkMemoryMapFlags flags,

3951

void** ppData);

3952

3953

VKAPI_ATTR void VKAPI_CALL vkUnmapMemory(

3954

VkDevice device,

3955

VkDeviceMemory memory);

3956

3957

VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges(

3958

VkDevice device,

3959

uint32_t memoryRangeCount,

3960

const VkMappedMemoryRange* pMemoryRanges);

3961

3962

VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges(

3963

VkDevice device,

3964

uint32_t memoryRangeCount,

3965

const VkMappedMemoryRange* pMemoryRanges);

3966

3967

VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment(

3968

VkDevice device,

3969

VkDeviceMemory memory,

3970

VkDeviceSize* pCommittedMemoryInBytes);

3971

3972

VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory(

3973

VkDevice device,

3974

VkBuffer buffer,

3975

VkDeviceMemory memory,

3976

VkDeviceSize memoryOffset);

3977

3978

VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory(

3979

VkDevice device,

3980

VkImage image,

3981

VkDeviceMemory memory,

3982

VkDeviceSize memoryOffset);

3983

3984

VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements(

3985

VkDevice device,

3986

VkBuffer buffer,

3987

VkMemoryRequirements* pMemoryRequirements);

3988

3989

VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements(

3990

VkDevice device,

3991

VkImage image,

3992

VkMemoryRequirements* pMemoryRequirements);

3993

3994

VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements(

3995

VkDevice device,

3996

VkImage image,

3997

uint32_t* pSparseMemoryRequirementCount,

3998

VkSparseImageMemoryRequirements* pSparseMemoryRequirements);

3999

4000

VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties(

4001

VkPhysicalDevice physicalDevice,

4002

VkFormat format,

4003

VkImageType type,

4004

VkSampleCountFlagBits samples,

4005

VkImageUsageFlags usage,

4006

VkImageTiling tiling,

4007

uint32_t* pPropertyCount,

4008

VkSparseImageFormatProperties* pProperties);

4009

4010

VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse(

4011

VkQueue queue,

4012

uint32_t bindInfoCount,

4013

const VkBindSparseInfo* pBindInfo,

4014

VkFence fence);

4015

4016

VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence(

4017

VkDevice device,

4018

const VkFenceCreateInfo* pCreateInfo,

4019

const VkAllocationCallbacks* pAllocator,

4020

VkFence* pFence);

4021

4022

VKAPI_ATTR void VKAPI_CALL vkDestroyFence(

4023

VkDevice device,

4024

VkFence fence,

4025

const VkAllocationCallbacks* pAllocator);

4026

4027

VKAPI_ATTR VkResult VKAPI_CALL vkResetFences(

4028

VkDevice device,

4029

uint32_t fenceCount,

4030

const VkFence* pFences);

4031

4032

VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus(

4033

VkDevice device,

4034

VkFence fence);

4035

4036

VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences(

4037

VkDevice device,

4038

uint32_t fenceCount,

4039

const VkFence* pFences,

4040

VkBool32 waitAll,

4041

uint64_t timeout);

4042

4043

VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore(

4044

VkDevice device,

4045

const VkSemaphoreCreateInfo* pCreateInfo,

4046

const VkAllocationCallbacks* pAllocator,

4047

VkSemaphore* pSemaphore);

4048

4049

VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore(

4050

VkDevice device,

4051

VkSemaphore semaphore,

4052

const VkAllocationCallbacks* pAllocator);

4053

4054

VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent(

4055

VkDevice device,

4056

const VkEventCreateInfo* pCreateInfo,

4057

const VkAllocationCallbacks* pAllocator,

4058

VkEvent* pEvent);

4059

4060

VKAPI_ATTR void VKAPI_CALL vkDestroyEvent(

4061

VkDevice device,

4062

VkEvent event,

4063

const VkAllocationCallbacks* pAllocator);

4064

4065

VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus(

4066

VkDevice device,

4067

VkEvent event);

4068

4069

VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent(

4070

VkDevice device,

4071

VkEvent event);

4072

4073

VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent(

4074

VkDevice device,

4075

VkEvent event);

4076

4077

VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool(

4078

VkDevice device,

4079

const VkQueryPoolCreateInfo* pCreateInfo,

4080

const VkAllocationCallbacks* pAllocator,

4081

VkQueryPool* pQueryPool);

4082

4083

VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool(

4084

VkDevice device,

4085

VkQueryPool queryPool,

4086

const VkAllocationCallbacks* pAllocator);

4087

4088

VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults(

4089

VkDevice device,

4090

VkQueryPool queryPool,

4091

uint32_t firstQuery,

4092

uint32_t queryCount,

4093

size_t dataSize,

4094

void* pData,

4095

VkDeviceSize stride,

4096

VkQueryResultFlags flags);

4097

4098

VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer(

4099

VkDevice device,

4100

const VkBufferCreateInfo* pCreateInfo,

4101

const VkAllocationCallbacks* pAllocator,

4102

VkBuffer* pBuffer);

4103

4104

VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer(

4105

VkDevice device,

4106

VkBuffer buffer,

4107

const VkAllocationCallbacks* pAllocator);

4108

4109

VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView(

4110

VkDevice device,

4111

const VkBufferViewCreateInfo* pCreateInfo,

4112

const VkAllocationCallbacks* pAllocator,

4113

VkBufferView* pView);

4114

4115

VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView(

4116

VkDevice device,

4117

VkBufferView bufferView,

4118

const VkAllocationCallbacks* pAllocator);

4119

4120

VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage(

4121

VkDevice device,

4122

const VkImageCreateInfo* pCreateInfo,

4123

const VkAllocationCallbacks* pAllocator,

4124

VkImage* pImage);

4125

4126

VKAPI_ATTR void VKAPI_CALL vkDestroyImage(

4127

VkDevice device,

4128

VkImage image,

4129

const VkAllocationCallbacks* pAllocator);

4130

4131

VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout(

4132

VkDevice device,

4133

VkImage image,

4134

const VkImageSubresource* pSubresource,

4135

VkSubresourceLayout* pLayout);

4136

4137

VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView(

4138

VkDevice device,

4139

const VkImageViewCreateInfo* pCreateInfo,

4140

const VkAllocationCallbacks* pAllocator,

4141

VkImageView* pView);

4142

4143

VKAPI_ATTR void VKAPI_CALL vkDestroyImageView(

4144

VkDevice device,

4145

VkImageView imageView,

4146

const VkAllocationCallbacks* pAllocator);

4147

4148

VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule(

4149

VkDevice device,

4150

const VkShaderModuleCreateInfo* pCreateInfo,

4151

const VkAllocationCallbacks* pAllocator,

4152

VkShaderModule* pShaderModule);

4153

4154

VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule(

4155

VkDevice device,

4156

VkShaderModule shaderModule,

4157

const VkAllocationCallbacks* pAllocator);

4158

4159

VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache(

4160

VkDevice device,

4161

const VkPipelineCacheCreateInfo* pCreateInfo,

4162

const VkAllocationCallbacks* pAllocator,

4163

VkPipelineCache* pPipelineCache);

4164

4165

VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache(

4166

VkDevice device,

4167

VkPipelineCache pipelineCache,

4168

const VkAllocationCallbacks* pAllocator);

4169

4170

VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData(

4171

VkDevice device,

4172

VkPipelineCache pipelineCache,

4173

size_t* pDataSize,

4174

void* pData);

4175

4176

VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches(

4177

VkDevice device,

4178

VkPipelineCache dstCache,

4179

uint32_t srcCacheCount,

4180

const VkPipelineCache* pSrcCaches);

4181

4182

VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines(

4183

VkDevice device,

4184

VkPipelineCache pipelineCache,

4185

uint32_t createInfoCount,

4186

const VkGraphicsPipelineCreateInfo* pCreateInfos,

4187

const VkAllocationCallbacks* pAllocator,

4188

VkPipeline* pPipelines);

4189

4190

VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines(

4191

VkDevice device,

4192

VkPipelineCache pipelineCache,

4193

uint32_t createInfoCount,

4194

const VkComputePipelineCreateInfo* pCreateInfos,

4195

const VkAllocationCallbacks* pAllocator,

4196

VkPipeline* pPipelines);

4197

4198

VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline(

4199

VkDevice device,

4200

VkPipeline pipeline,

4201

const VkAllocationCallbacks* pAllocator);

4202

4203

VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout(

4204

VkDevice device,

4205

const VkPipelineLayoutCreateInfo* pCreateInfo,

4206

const VkAllocationCallbacks* pAllocator,

4207

VkPipelineLayout* pPipelineLayout);

4208

4209

VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout(

4210

VkDevice device,

4211

VkPipelineLayout pipelineLayout,

4212

const VkAllocationCallbacks* pAllocator);

4213

4214

VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler(

4215

VkDevice device,

4216

const VkSamplerCreateInfo* pCreateInfo,

4217

const VkAllocationCallbacks* pAllocator,

4218

VkSampler* pSampler);

4219

4220

VKAPI_ATTR void VKAPI_CALL vkDestroySampler(

4221

VkDevice device,

4222

VkSampler sampler,

4223

const VkAllocationCallbacks* pAllocator);

4224

4225

VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout(

4226

VkDevice device,

4227

const VkDescriptorSetLayoutCreateInfo* pCreateInfo,

4228

const VkAllocationCallbacks* pAllocator,

4229

VkDescriptorSetLayout* pSetLayout);

4230

4231

VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout(

4232

VkDevice device,

4233

VkDescriptorSetLayout descriptorSetLayout,

4234

const VkAllocationCallbacks* pAllocator);

4235

4236

VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool(

4237

VkDevice device,

4238

const VkDescriptorPoolCreateInfo* pCreateInfo,

4239

const VkAllocationCallbacks* pAllocator,

4240

VkDescriptorPool* pDescriptorPool);

4241

4242

VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool(

4243

VkDevice device,

4244

VkDescriptorPool descriptorPool,

4245

const VkAllocationCallbacks* pAllocator);

4246

4247

VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool(

4248

VkDevice device,

4249

VkDescriptorPool descriptorPool,

4250

VkDescriptorPoolResetFlags flags);

4251

4252

VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets(

4253

VkDevice device,

4254

const VkDescriptorSetAllocateInfo* pAllocateInfo,

4255

VkDescriptorSet* pDescriptorSets);

4256

4257

VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets(

4258

VkDevice device,

4259

VkDescriptorPool descriptorPool,

4260

uint32_t descriptorSetCount,

4261

const VkDescriptorSet* pDescriptorSets);

4262

4263

VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets(

4264

VkDevice device,

4265

uint32_t descriptorWriteCount,

4266

const VkWriteDescriptorSet* pDescriptorWrites,

4267

uint32_t descriptorCopyCount,

4268

const VkCopyDescriptorSet* pDescriptorCopies);

4269

4270

VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer(

4271

VkDevice device,

4272

const VkFramebufferCreateInfo* pCreateInfo,

4273

const VkAllocationCallbacks* pAllocator,

4274

VkFramebuffer* pFramebuffer);

4275

4276

VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer(

4277

VkDevice device,

4278

VkFramebuffer framebuffer,

4279

const VkAllocationCallbacks* pAllocator);

4280

4281

VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass(

4282

VkDevice device,

4283

const VkRenderPassCreateInfo* pCreateInfo,

4284

const VkAllocationCallbacks* pAllocator,

4285

VkRenderPass* pRenderPass);

4286

4287

VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass(

4288

VkDevice device,

4289

VkRenderPass renderPass,

4290

const VkAllocationCallbacks* pAllocator);

4291

4292

VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity(

4293

VkDevice device,

4294

VkRenderPass renderPass,

4295

VkExtent2D* pGranularity);

4296

4297

VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool(

4298

VkDevice device,

4299

const VkCommandPoolCreateInfo* pCreateInfo,

4300

const VkAllocationCallbacks* pAllocator,

4301

VkCommandPool* pCommandPool);

4302

4303

VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool(

4304

VkDevice device,

4305

VkCommandPool commandPool,

4306

const VkAllocationCallbacks* pAllocator);

4307

4308

VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool(

4309

VkDevice device,

4310

VkCommandPool commandPool,

4311

VkCommandPoolResetFlags flags);

4312

4313

VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers(

4314

VkDevice device,

4315

const VkCommandBufferAllocateInfo* pAllocateInfo,

4316

VkCommandBuffer* pCommandBuffers);

4317

4318

VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers(

4319

VkDevice device,

4320

VkCommandPool commandPool,

4321

uint32_t commandBufferCount,

4322

const VkCommandBuffer* pCommandBuffers);

4323

4324

VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer(

4325

VkCommandBuffer commandBuffer,

4326

const VkCommandBufferBeginInfo* pBeginInfo);

4327

4328

VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer(

4329

VkCommandBuffer commandBuffer);

4330

4331

VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer(

4332

VkCommandBuffer commandBuffer,

4333

VkCommandBufferResetFlags flags);

4334

4335

VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline(

4336

VkCommandBuffer commandBuffer,

4337

VkPipelineBindPoint pipelineBindPoint,

4338

VkPipeline pipeline);

4339

4340

VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport(

4341

VkCommandBuffer commandBuffer,

4342

uint32_t firstViewport,

4343

uint32_t viewportCount,

4344

const VkViewport* pViewports);

4345

4346

VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor(

4347

VkCommandBuffer commandBuffer,

4348

uint32_t firstScissor,

4349

uint32_t scissorCount,

4350

const VkRect2D* pScissors);

4351

4352

VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth(

4353

VkCommandBuffer commandBuffer,

4354

float lineWidth);

4355

4356

VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias(

4357

VkCommandBuffer commandBuffer,

4358

float depthBiasConstantFactor,

4359

float depthBiasClamp,

4360

float depthBiasSlopeFactor);

4361

4362

VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants(

4363

VkCommandBuffer commandBuffer,

4364

const float blendConstants[4]);

4365

4366

VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds(

4367

VkCommandBuffer commandBuffer,

4368

float minDepthBounds,

4369

float maxDepthBounds);

4370

4371

VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask(

4372

VkCommandBuffer commandBuffer,

4373

VkStencilFaceFlags faceMask,

4374

uint32_t compareMask);

4375

4376

VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask(

4377

VkCommandBuffer commandBuffer,

4378

VkStencilFaceFlags faceMask,

4379

uint32_t writeMask);

4380

4381

VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference(

4382

VkCommandBuffer commandBuffer,

4383

VkStencilFaceFlags faceMask,

4384

uint32_t reference);

4385

4386

VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets(

4387

VkCommandBuffer commandBuffer,

4388

VkPipelineBindPoint pipelineBindPoint,

4389

VkPipelineLayout layout,

4390

uint32_t firstSet,

4391

uint32_t descriptorSetCount,

4392

const VkDescriptorSet* pDescriptorSets,

4393

uint32_t dynamicOffsetCount,

4394

const uint32_t* pDynamicOffsets);

4395

4396

VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer(

4397

VkCommandBuffer commandBuffer,

4398

VkBuffer buffer,

4399

VkDeviceSize offset,

4400

VkIndexType indexType);

4401

4402

VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers(

4403

VkCommandBuffer commandBuffer,

4404

uint32_t firstBinding,

4405

uint32_t bindingCount,

4406

const VkBuffer* pBuffers,

4407

const VkDeviceSize* pOffsets);

4408

4409

VKAPI_ATTR void VKAPI_CALL vkCmdDraw(

4410

VkCommandBuffer commandBuffer,

4411

uint32_t vertexCount,

4412

uint32_t instanceCount,

4413

uint32_t firstVertex,

4414

uint32_t firstInstance);

4415

4416

VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed(

4417

VkCommandBuffer commandBuffer,

4418

uint32_t indexCount,

4419

uint32_t instanceCount,

4420

uint32_t firstIndex,

4421

int32_t vertexOffset,

4422

uint32_t firstInstance);

4423

4424

VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect(

4425

VkCommandBuffer commandBuffer,

4426

VkBuffer buffer,

4427

VkDeviceSize offset,

4428

uint32_t drawCount,

4429

uint32_t stride);

4430

4431

VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect(

4432

VkCommandBuffer commandBuffer,

4433

VkBuffer buffer,

4434

VkDeviceSize offset,

4435

uint32_t drawCount,

4436

uint32_t stride);

4437

4438

VKAPI_ATTR void VKAPI_CALL vkCmdDispatch(

4439

VkCommandBuffer commandBuffer,

4440

uint32_t groupCountX,

4441

uint32_t groupCountY,

4442

uint32_t groupCountZ);

4443

4444

VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect(

4445

VkCommandBuffer commandBuffer,

4446

VkBuffer buffer,

4447

VkDeviceSize offset);

4448

4449

VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer(

4450

VkCommandBuffer commandBuffer,

4451

VkBuffer srcBuffer,

4452

VkBuffer dstBuffer,

4453

uint32_t regionCount,

4454

const VkBufferCopy* pRegions);

4455

4456

VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage(

4457

VkCommandBuffer commandBuffer,

4458

VkImage srcImage,

4459

VkImageLayout srcImageLayout,

4460

VkImage dstImage,

4461

VkImageLayout dstImageLayout,

4462

uint32_t regionCount,

4463

const VkImageCopy* pRegions);

4464

4465

VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage(

4466

VkCommandBuffer commandBuffer,

4467

VkImage srcImage,

4468

VkImageLayout srcImageLayout,

4469

VkImage dstImage,

4470

VkImageLayout dstImageLayout,

4471

uint32_t regionCount,

4472

const VkImageBlit* pRegions,

4473

VkFilter filter);

4474

4475

VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage(

4476

VkCommandBuffer commandBuffer,

4477

VkBuffer srcBuffer,

4478

VkImage dstImage,

4479

VkImageLayout dstImageLayout,

4480

uint32_t regionCount,

4481

const VkBufferImageCopy* pRegions);

4482

4483

VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer(

4484

VkCommandBuffer commandBuffer,

4485

VkImage srcImage,

4486

VkImageLayout srcImageLayout,

4487

VkBuffer dstBuffer,

4488

uint32_t regionCount,

4489

const VkBufferImageCopy* pRegions);

4490

4491

VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer(

4492

VkCommandBuffer commandBuffer,

4493

VkBuffer dstBuffer,

4494

VkDeviceSize dstOffset,

4495

VkDeviceSize dataSize,

4496

const void* pData);

4497

4498

VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer(

4499

VkCommandBuffer commandBuffer,

4500

VkBuffer dstBuffer,

4501

VkDeviceSize dstOffset,

4502

VkDeviceSize size,

4503

uint32_t data);

4504

4505

VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage(

4506

VkCommandBuffer commandBuffer,

4507

VkImage image,

4508

VkImageLayout imageLayout,

4509

const VkClearColorValue* pColor,

4510

uint32_t rangeCount,

4511

const VkImageSubresourceRange* pRanges);

4512

4513

VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage(

4514

VkCommandBuffer commandBuffer,

4515

VkImage image,

4516

VkImageLayout imageLayout,

4517

const VkClearDepthStencilValue* pDepthStencil,

4518

uint32_t rangeCount,

4519

const VkImageSubresourceRange* pRanges);

4520

4521

VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments(

4522

VkCommandBuffer commandBuffer,

4523

uint32_t attachmentCount,

4524

const VkClearAttachment* pAttachments,

4525

uint32_t rectCount,

4526

const VkClearRect* pRects);

4527

4528

VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage(

4529

VkCommandBuffer commandBuffer,

4530

VkImage srcImage,

4531

VkImageLayout srcImageLayout,

4532

VkImage dstImage,

4533

VkImageLayout dstImageLayout,

4534

uint32_t regionCount,

4535

const VkImageResolve* pRegions);

4536

4537

VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent(

4538

VkCommandBuffer commandBuffer,

4539

VkEvent event,

4540

VkPipelineStageFlags stageMask);

4541

4542

VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent(

4543

VkCommandBuffer commandBuffer,

4544

VkEvent event,

4545

VkPipelineStageFlags stageMask);

4546

4547

VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents(

4548

VkCommandBuffer commandBuffer,

4549

uint32_t eventCount,

4550

const VkEvent* pEvents,

4551

VkPipelineStageFlags srcStageMask,

4552

VkPipelineStageFlags dstStageMask,

4553

uint32_t memoryBarrierCount,

4554

const VkMemoryBarrier* pMemoryBarriers,

4555

uint32_t bufferMemoryBarrierCount,

4556

const VkBufferMemoryBarrier* pBufferMemoryBarriers,

4557

uint32_t imageMemoryBarrierCount,

4558

const VkImageMemoryBarrier* pImageMemoryBarriers);

4559

4560

VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier(

4561

VkCommandBuffer commandBuffer,

4562

VkPipelineStageFlags srcStageMask,

4563

VkPipelineStageFlags dstStageMask,

4564

VkDependencyFlags dependencyFlags,

4565

uint32_t memoryBarrierCount,

4566

const VkMemoryBarrier* pMemoryBarriers,

4567

uint32_t bufferMemoryBarrierCount,

4568

const VkBufferMemoryBarrier* pBufferMemoryBarriers,

4569

uint32_t imageMemoryBarrierCount,

4570

const VkImageMemoryBarrier* pImageMemoryBarriers);

4571

4572

VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery(

4573

VkCommandBuffer commandBuffer,

4574

VkQueryPool queryPool,

4575

uint32_t query,

4576

VkQueryControlFlags flags);

4577

4578

VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery(

4579

VkCommandBuffer commandBuffer,

4580

VkQueryPool queryPool,

4581

uint32_t query);

4582

4583

VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool(

4584

VkCommandBuffer commandBuffer,

4585

VkQueryPool queryPool,

4586

uint32_t firstQuery,

4587

uint32_t queryCount);

4588

4589

VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp(

4590

VkCommandBuffer commandBuffer,

4591

VkPipelineStageFlagBits pipelineStage,

4592

VkQueryPool queryPool,

4593

uint32_t query);

4594

4595

VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults(

4596

VkCommandBuffer commandBuffer,

4597

VkQueryPool queryPool,

4598

uint32_t firstQuery,

4599

uint32_t queryCount,

4600

VkBuffer dstBuffer,

4601

VkDeviceSize dstOffset,

4602

VkDeviceSize stride,

4603

VkQueryResultFlags flags);

4604

4605

VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants(

4606

VkCommandBuffer commandBuffer,

4607

VkPipelineLayout layout,

4608

VkShaderStageFlags stageFlags,

4609

uint32_t offset,

4610

uint32_t size,

4611

const void* pValues);

4612

4613

VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass(

4614

VkCommandBuffer commandBuffer,

4615

const VkRenderPassBeginInfo* pRenderPassBegin,

4616

VkSubpassContents contents);

4617

4618

VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass(

4619

VkCommandBuffer commandBuffer,

4620

VkSubpassContents contents);

4621

4622

VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass(

4623

VkCommandBuffer commandBuffer);

4624

4625

VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands(

4626

VkCommandBuffer commandBuffer,

4627

uint32_t commandBufferCount,

4628

const VkCommandBuffer* pCommandBuffers);

4629

#endif

4630

4631

4632

#define VK_VERSION_1_1 1

4633

// Vulkan 1.1 version number

4634

#define VK_API_VERSION_1_1 VK_MAKE_API_VERSION(0, 1, 1, 0)// Patch version should always be set to 0

4635

4636

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSamplerYcbcrConversion)

4637

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorUpdateTemplate)

4638

#define VK_MAX_DEVICE_GROUP_SIZE 32U

4639

#define VK_LUID_SIZE 8U

4640

#define VK_QUEUE_FAMILY_EXTERNAL (~1U)

4641

4642

typedef enum VkPointClippingBehavior {

4643

VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES = 0,

4644

VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY = 1,

4645

VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES,

4646

VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY,

4647

VK_POINT_CLIPPING_BEHAVIOR_MAX_ENUM = 0x7FFFFFFF

4648

} VkPointClippingBehavior;

4649

4650

typedef enum VkTessellationDomainOrigin {

4651

VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT = 0,

4652

VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT = 1,

4653

VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT,

4654

VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT,

4655

VK_TESSELLATION_DOMAIN_ORIGIN_MAX_ENUM = 0x7FFFFFFF

4656

} VkTessellationDomainOrigin;

4657

4658

typedef enum VkSamplerYcbcrModelConversion {

4659

VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY = 0,

4660

VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY = 1,

4661

VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709 = 2,

4662

VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601 = 3,

4663

VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 = 4,

4664

VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY,

4665

VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY,

4666

VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709,

4667

VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601,

4668

VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020,

4669

VK_SAMPLER_YCBCR_MODEL_CONVERSION_MAX_ENUM = 0x7FFFFFFF

4670

} VkSamplerYcbcrModelConversion;

4671

4672

typedef enum VkSamplerYcbcrRange {

4673

VK_SAMPLER_YCBCR_RANGE_ITU_FULL = 0,

4674

VK_SAMPLER_YCBCR_RANGE_ITU_NARROW = 1,

4675

VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR = VK_SAMPLER_YCBCR_RANGE_ITU_FULL,

4676

VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW,

4677

VK_SAMPLER_YCBCR_RANGE_MAX_ENUM = 0x7FFFFFFF

4678

} VkSamplerYcbcrRange;

4679

4680

typedef enum VkChromaLocation {

4681

VK_CHROMA_LOCATION_COSITED_EVEN = 0,

4682

VK_CHROMA_LOCATION_MIDPOINT = 1,

4683

VK_CHROMA_LOCATION_COSITED_EVEN_KHR = VK_CHROMA_LOCATION_COSITED_EVEN,

4684

VK_CHROMA_LOCATION_MIDPOINT_KHR = VK_CHROMA_LOCATION_MIDPOINT,

4685

VK_CHROMA_LOCATION_MAX_ENUM = 0x7FFFFFFF

4686

} VkChromaLocation;

4687

4688

typedef enum VkDescriptorUpdateTemplateType {

4689

VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET = 0,

4690

VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR = 1,

4691

VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET,

4692

VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_MAX_ENUM = 0x7FFFFFFF

4693

} VkDescriptorUpdateTemplateType;

4694

4695

typedef enum VkSubgroupFeatureFlagBits {

4696

VK_SUBGROUP_FEATURE_BASIC_BIT = 0x00000001,

4697

VK_SUBGROUP_FEATURE_VOTE_BIT = 0x00000002,

4698

VK_SUBGROUP_FEATURE_ARITHMETIC_BIT = 0x00000004,

4699

VK_SUBGROUP_FEATURE_BALLOT_BIT = 0x00000008,

4700

VK_SUBGROUP_FEATURE_SHUFFLE_BIT = 0x00000010,

4701

VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT = 0x00000020,

4702

VK_SUBGROUP_FEATURE_CLUSTERED_BIT = 0x00000040,

4703

VK_SUBGROUP_FEATURE_QUAD_BIT = 0x00000080,

4704

VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV = 0x00000100,

4705

VK_SUBGROUP_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

4706

} VkSubgroupFeatureFlagBits;

4707

typedef VkFlags VkSubgroupFeatureFlags;

4708

4709

typedef enum VkPeerMemoryFeatureFlagBits {

4710

VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT = 0x00000001,

4711

VK_PEER_MEMORY_FEATURE_COPY_DST_BIT = 0x00000002,

4712

VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT = 0x00000004,

4713

VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT = 0x00000008,

4714

VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHR = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT,

4715

VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHR = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT,

4716

VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHR = VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT,

4717

VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHR = VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT,

4718

VK_PEER_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

4719

} VkPeerMemoryFeatureFlagBits;

4720

typedef VkFlags VkPeerMemoryFeatureFlags;

4721

4722

typedef enum VkMemoryAllocateFlagBits {

4723

VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT = 0x00000001,

4724

VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT = 0x00000002,

4725

VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = 0x00000004,

4726

VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT,

4727

VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT,

4728

VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT,

4729

VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

4730

} VkMemoryAllocateFlagBits;

4731

typedef VkFlags VkMemoryAllocateFlags;

4732

typedef VkFlags VkCommandPoolTrimFlags;

4733

typedef VkFlags VkDescriptorUpdateTemplateCreateFlags;

4734

4735

typedef enum VkExternalMemoryHandleTypeFlagBits {

4736

VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001,

4737

VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002,

4738

VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004,

4739

VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT = 0x00000008,

4740

VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT = 0x00000010,

4741

VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT = 0x00000020,

4742

VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT = 0x00000040,

4743

VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT = 0x00000200,

4744

VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID = 0x00000400,

4745

VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT = 0x00000080,

4746

VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT = 0x00000100,

4747

VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA = 0x00000800,

4748

VK_EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV = 0x00001000,

4749

VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT,

4750

VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT,

4751

VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,

4752

VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT,

4753

VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT,

4754

VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT,

4755

VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT,

4756

VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

4757

} VkExternalMemoryHandleTypeFlagBits;

4758

typedef VkFlags VkExternalMemoryHandleTypeFlags;

4759

4760

typedef enum VkExternalMemoryFeatureFlagBits {

4761

VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT = 0x00000001,

4762

VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT = 0x00000002,

4763

VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT = 0x00000004,

4764

VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT,

4765

VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT,

4766

VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT,

4767

VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

4768

} VkExternalMemoryFeatureFlagBits;

4769

typedef VkFlags VkExternalMemoryFeatureFlags;

4770

4771

typedef enum VkExternalFenceHandleTypeFlagBits {

4772

VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001,

4773

VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002,

4774

VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004,

4775

VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT = 0x00000008,

4776

VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT,

4777

VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT,

4778

VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,

4779

VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT,

4780

VK_EXTERNAL_FENCE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

4781

} VkExternalFenceHandleTypeFlagBits;

4782

typedef VkFlags VkExternalFenceHandleTypeFlags;

4783

4784

typedef enum VkExternalFenceFeatureFlagBits {

4785

VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT = 0x00000001,

4786

VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT = 0x00000002,

4787

VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT,

4788

VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT,

4789

VK_EXTERNAL_FENCE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

4790

} VkExternalFenceFeatureFlagBits;

4791

typedef VkFlags VkExternalFenceFeatureFlags;

4792

4793

typedef enum VkFenceImportFlagBits {

4794

VK_FENCE_IMPORT_TEMPORARY_BIT = 0x00000001,

4795

VK_FENCE_IMPORT_TEMPORARY_BIT_KHR = VK_FENCE_IMPORT_TEMPORARY_BIT,

4796

VK_FENCE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

4797

} VkFenceImportFlagBits;

4798

typedef VkFlags VkFenceImportFlags;

4799

4800

typedef enum VkSemaphoreImportFlagBits {

4801

VK_SEMAPHORE_IMPORT_TEMPORARY_BIT = 0x00000001,

4802

VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT,

4803

VK_SEMAPHORE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

4804

} VkSemaphoreImportFlagBits;

4805

typedef VkFlags VkSemaphoreImportFlags;

4806

4807

typedef enum VkExternalSemaphoreHandleTypeFlagBits {

4808

VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001,

4809

VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002,

4810

VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004,

4811

VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT = 0x00000008,

4812

VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT = 0x00000010,

4813

VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA = 0x00000080,

4814

VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE_BIT = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT,

4815

VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT,

4816

VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT,

4817

VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,

4818

VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT,

4819

VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT,

4820

VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

4821

} VkExternalSemaphoreHandleTypeFlagBits;

4822

typedef VkFlags VkExternalSemaphoreHandleTypeFlags;

4823

4824

typedef enum VkExternalSemaphoreFeatureFlagBits {

4825

VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT = 0x00000001,

4826

VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT = 0x00000002,

4827

VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT,

4828

VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT,

4829

VK_EXTERNAL_SEMAPHORE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

4830

} VkExternalSemaphoreFeatureFlagBits;

4831

typedef VkFlags VkExternalSemaphoreFeatureFlags;

4832

typedef struct VkPhysicalDeviceSubgroupProperties {

4833

VkStructureType sType;

4834

void* pNext;

4835

uint32_t subgroupSize;

4836

VkShaderStageFlags supportedStages;

4837

VkSubgroupFeatureFlags supportedOperations;

4838

VkBool32 quadOperationsInAllStages;

4839

} VkPhysicalDeviceSubgroupProperties;

4840

4841

typedef struct VkBindBufferMemoryInfo {

4842

VkStructureType sType;

4843

const void* pNext;

4844

VkBuffer buffer;

4845

VkDeviceMemory memory;

4846

VkDeviceSize memoryOffset;

4847

} VkBindBufferMemoryInfo;

4848

4849

typedef struct VkBindImageMemoryInfo {

4850

VkStructureType sType;

4851

const void* pNext;

4852

VkImage image;

4853

VkDeviceMemory memory;

4854

VkDeviceSize memoryOffset;

4855

} VkBindImageMemoryInfo;

4856

4857

typedef struct VkPhysicalDevice16BitStorageFeatures {

4858

VkStructureType sType;

4859

void* pNext;

4860

VkBool32 storageBuffer16BitAccess;

4861

VkBool32 uniformAndStorageBuffer16BitAccess;

4862

VkBool32 storagePushConstant16;

4863

VkBool32 storageInputOutput16;

4864

} VkPhysicalDevice16BitStorageFeatures;

4865

4866

typedef struct VkMemoryDedicatedRequirements {

4867

VkStructureType sType;

4868

void* pNext;

4869

VkBool32 prefersDedicatedAllocation;

4870

VkBool32 requiresDedicatedAllocation;

4871

} VkMemoryDedicatedRequirements;

4872

4873

typedef struct VkMemoryDedicatedAllocateInfo {

4874

VkStructureType sType;

4875

const void* pNext;

4876

VkImage image;

4877

VkBuffer buffer;

4878

} VkMemoryDedicatedAllocateInfo;

4879

4880

typedef struct VkMemoryAllocateFlagsInfo {

4881

VkStructureType sType;

4882

const void* pNext;

4883

VkMemoryAllocateFlags flags;

4884

uint32_t deviceMask;

4885

} VkMemoryAllocateFlagsInfo;

4886

4887

typedef struct VkDeviceGroupRenderPassBeginInfo {

4888

VkStructureType sType;

4889

const void* pNext;

4890

uint32_t deviceMask;

4891

uint32_t deviceRenderAreaCount;

4892

const VkRect2D* pDeviceRenderAreas;

4893

} VkDeviceGroupRenderPassBeginInfo;

4894

4895

typedef struct VkDeviceGroupCommandBufferBeginInfo {

4896

VkStructureType sType;

4897

const void* pNext;

4898

uint32_t deviceMask;

4899

} VkDeviceGroupCommandBufferBeginInfo;

4900

4901

typedef struct VkDeviceGroupSubmitInfo {

4902

VkStructureType sType;

4903

const void* pNext;

4904

uint32_t waitSemaphoreCount;

4905

const uint32_t* pWaitSemaphoreDeviceIndices;

4906

uint32_t commandBufferCount;

4907

const uint32_t* pCommandBufferDeviceMasks;

4908

uint32_t signalSemaphoreCount;

4909

const uint32_t* pSignalSemaphoreDeviceIndices;

4910

} VkDeviceGroupSubmitInfo;

4911

4912

typedef struct VkDeviceGroupBindSparseInfo {

4913

VkStructureType sType;

4914

const void* pNext;

4915

uint32_t resourceDeviceIndex;

4916

uint32_t memoryDeviceIndex;

4917

} VkDeviceGroupBindSparseInfo;

4918

4919

typedef struct VkBindBufferMemoryDeviceGroupInfo {

4920

VkStructureType sType;

4921

const void* pNext;

4922

uint32_t deviceIndexCount;

4923

const uint32_t* pDeviceIndices;

4924

} VkBindBufferMemoryDeviceGroupInfo;

4925

4926

typedef struct VkBindImageMemoryDeviceGroupInfo {

4927

VkStructureType sType;

4928

const void* pNext;

4929

uint32_t deviceIndexCount;

4930

const uint32_t* pDeviceIndices;

4931

uint32_t splitInstanceBindRegionCount;

4932

const VkRect2D* pSplitInstanceBindRegions;

4933

} VkBindImageMemoryDeviceGroupInfo;

4934

4935

typedef struct VkPhysicalDeviceGroupProperties {

4936

VkStructureType sType;

4937

void* pNext;

4938

uint32_t physicalDeviceCount;

4939

VkPhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE];

4940

VkBool32 subsetAllocation;

4941

} VkPhysicalDeviceGroupProperties;

4942

4943

typedef struct VkDeviceGroupDeviceCreateInfo {

4944

VkStructureType sType;

4945

const void* pNext;

4946

uint32_t physicalDeviceCount;

4947

const VkPhysicalDevice* pPhysicalDevices;

4948

} VkDeviceGroupDeviceCreateInfo;

4949

4950

typedef struct VkBufferMemoryRequirementsInfo2 {

4951

VkStructureType sType;

4952

const void* pNext;

4953

VkBuffer buffer;

4954

} VkBufferMemoryRequirementsInfo2;

4955

4956

typedef struct VkImageMemoryRequirementsInfo2 {

4957

VkStructureType sType;

4958

const void* pNext;

4959

VkImage image;

4960

} VkImageMemoryRequirementsInfo2;

4961

4962

typedef struct VkImageSparseMemoryRequirementsInfo2 {

4963

VkStructureType sType;

4964

const void* pNext;

4965

VkImage image;

4966

} VkImageSparseMemoryRequirementsInfo2;

4967

4968

typedef struct VkMemoryRequirements2 {

4969

VkStructureType sType;

4970

void* pNext;

4971

VkMemoryRequirements memoryRequirements;

4972

} VkMemoryRequirements2;

4973

4974

typedef struct VkSparseImageMemoryRequirements2 {

4975

VkStructureType sType;

4976

void* pNext;

4977

VkSparseImageMemoryRequirements memoryRequirements;

4978

} VkSparseImageMemoryRequirements2;

4979

4980

typedef struct VkPhysicalDeviceFeatures2 {

4981

VkStructureType sType;

4982

void* pNext;

4983

VkPhysicalDeviceFeatures features;

4984

} VkPhysicalDeviceFeatures2;

4985

4986

typedef struct VkPhysicalDeviceProperties2 {

4987

VkStructureType sType;

4988

void* pNext;

4989

VkPhysicalDeviceProperties properties;

4990

} VkPhysicalDeviceProperties2;

4991

4992

typedef struct VkFormatProperties2 {

4993

VkStructureType sType;

4994

void* pNext;

4995

VkFormatProperties formatProperties;

4996

} VkFormatProperties2;

4997

4998

typedef struct VkImageFormatProperties2 {

4999

VkStructureType sType;

5000

void* pNext;

5001

VkImageFormatProperties imageFormatProperties;

5002

} VkImageFormatProperties2;

5003

5004

typedef struct VkPhysicalDeviceImageFormatInfo2 {

5005

VkStructureType sType;

5006

const void* pNext;

5007

VkFormat format;

5008

VkImageType type;

5009

VkImageTiling tiling;

5010

VkImageUsageFlags usage;

5011

VkImageCreateFlags flags;

5012

} VkPhysicalDeviceImageFormatInfo2;

5013

5014

typedef struct VkQueueFamilyProperties2 {

5015

VkStructureType sType;

5016

void* pNext;

5017

VkQueueFamilyProperties queueFamilyProperties;

5018

} VkQueueFamilyProperties2;

5019

5020

typedef struct VkPhysicalDeviceMemoryProperties2 {

5021

VkStructureType sType;

5022

void* pNext;

5023

VkPhysicalDeviceMemoryProperties memoryProperties;

5024

} VkPhysicalDeviceMemoryProperties2;

5025

5026

typedef struct VkSparseImageFormatProperties2 {

5027

VkStructureType sType;

5028

void* pNext;

5029

VkSparseImageFormatProperties properties;

5030

} VkSparseImageFormatProperties2;

5031

5032

typedef struct VkPhysicalDeviceSparseImageFormatInfo2 {

5033

VkStructureType sType;

5034

const void* pNext;

5035

VkFormat format;

5036

VkImageType type;

5037

VkSampleCountFlagBits samples;

5038

VkImageUsageFlags usage;

5039

VkImageTiling tiling;

5040

} VkPhysicalDeviceSparseImageFormatInfo2;

5041

5042

typedef struct VkPhysicalDevicePointClippingProperties {

5043

VkStructureType sType;

5044

void* pNext;

5045

VkPointClippingBehavior pointClippingBehavior;

5046

} VkPhysicalDevicePointClippingProperties;

5047

5048

typedef struct VkInputAttachmentAspectReference {

5049

uint32_t subpass;

5050

uint32_t inputAttachmentIndex;

5051

VkImageAspectFlags aspectMask;

5052

} VkInputAttachmentAspectReference;

5053

5054

typedef struct VkRenderPassInputAttachmentAspectCreateInfo {

5055

VkStructureType sType;

5056

const void* pNext;

5057

uint32_t aspectReferenceCount;

5058

const VkInputAttachmentAspectReference* pAspectReferences;

5059

} VkRenderPassInputAttachmentAspectCreateInfo;

5060

5061

typedef struct VkImageViewUsageCreateInfo {

5062

VkStructureType sType;

5063

const void* pNext;

5064

VkImageUsageFlags usage;

5065

} VkImageViewUsageCreateInfo;

5066

5067

typedef struct VkPipelineTessellationDomainOriginStateCreateInfo {

5068

VkStructureType sType;

5069

const void* pNext;

5070

VkTessellationDomainOrigin domainOrigin;

5071

} VkPipelineTessellationDomainOriginStateCreateInfo;

5072

5073

typedef struct VkRenderPassMultiviewCreateInfo {

5074

VkStructureType sType;

5075

const void* pNext;

5076

uint32_t subpassCount;

5077

const uint32_t* pViewMasks;

5078

uint32_t dependencyCount;

5079

const int32_t* pViewOffsets;

5080

uint32_t correlationMaskCount;

5081

const uint32_t* pCorrelationMasks;

5082

} VkRenderPassMultiviewCreateInfo;

5083

5084

typedef struct VkPhysicalDeviceMultiviewFeatures {

5085

VkStructureType sType;

5086

void* pNext;

5087

VkBool32 multiview;

5088

VkBool32 multiviewGeometryShader;

5089

VkBool32 multiviewTessellationShader;

5090

} VkPhysicalDeviceMultiviewFeatures;

5091

5092

typedef struct VkPhysicalDeviceMultiviewProperties {

5093

VkStructureType sType;

5094

void* pNext;

5095

uint32_t maxMultiviewViewCount;

5096

uint32_t maxMultiviewInstanceIndex;

5097

} VkPhysicalDeviceMultiviewProperties;

5098

5099

typedef struct VkPhysicalDeviceVariablePointersFeatures {

5100

VkStructureType sType;

5101

void* pNext;

5102

VkBool32 variablePointersStorageBuffer;

5103

VkBool32 variablePointers;

5104

} VkPhysicalDeviceVariablePointersFeatures;

5105

5106

typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointerFeatures;

5107

5108

typedef struct VkPhysicalDeviceProtectedMemoryFeatures {

5109

VkStructureType sType;

5110

void* pNext;

5111

VkBool32 protectedMemory;

5112

} VkPhysicalDeviceProtectedMemoryFeatures;

5113

5114

typedef struct VkPhysicalDeviceProtectedMemoryProperties {

5115

VkStructureType sType;

5116

void* pNext;

5117

VkBool32 protectedNoFault;

5118

} VkPhysicalDeviceProtectedMemoryProperties;

5119

5120

typedef struct VkDeviceQueueInfo2 {

5121

VkStructureType sType;

5122

const void* pNext;

5123

VkDeviceQueueCreateFlags flags;

5124

uint32_t queueFamilyIndex;

5125

uint32_t queueIndex;

5126

} VkDeviceQueueInfo2;

5127

5128

typedef struct VkProtectedSubmitInfo {

5129

VkStructureType sType;

5130

const void* pNext;

5131

VkBool32 protectedSubmit;

5132

} VkProtectedSubmitInfo;

5133

5134

typedef struct VkSamplerYcbcrConversionCreateInfo {

5135

VkStructureType sType;

5136

const void* pNext;

5137

VkFormat format;

5138

VkSamplerYcbcrModelConversion ycbcrModel;

5139

VkSamplerYcbcrRange ycbcrRange;

5140

VkComponentMapping components;

5141

VkChromaLocation xChromaOffset;

5142

VkChromaLocation yChromaOffset;

5143

VkFilter chromaFilter;

5144

VkBool32 forceExplicitReconstruction;

5145

} VkSamplerYcbcrConversionCreateInfo;

5146

5147

typedef struct VkSamplerYcbcrConversionInfo {

5148

VkStructureType sType;

5149

const void* pNext;

5150

VkSamplerYcbcrConversion conversion;

5151

} VkSamplerYcbcrConversionInfo;

5152

5153

typedef struct VkBindImagePlaneMemoryInfo {

5154

VkStructureType sType;

5155

const void* pNext;

5156

VkImageAspectFlagBits planeAspect;

5157

} VkBindImagePlaneMemoryInfo;

5158

5159

typedef struct VkImagePlaneMemoryRequirementsInfo {

5160

VkStructureType sType;

5161

const void* pNext;

5162

VkImageAspectFlagBits planeAspect;

5163

} VkImagePlaneMemoryRequirementsInfo;

5164

5165

typedef struct VkPhysicalDeviceSamplerYcbcrConversionFeatures {

5166

VkStructureType sType;

5167

void* pNext;

5168

VkBool32 samplerYcbcrConversion;

5169

} VkPhysicalDeviceSamplerYcbcrConversionFeatures;

5170

5171

typedef struct VkSamplerYcbcrConversionImageFormatProperties {

5172

VkStructureType sType;

5173

void* pNext;

5174

uint32_t combinedImageSamplerDescriptorCount;

5175

} VkSamplerYcbcrConversionImageFormatProperties;

5176

5177

typedef struct VkDescriptorUpdateTemplateEntry {

5178

uint32_t dstBinding;

5179

uint32_t dstArrayElement;

5180

uint32_t descriptorCount;

5181

VkDescriptorType descriptorType;

5182

size_t offset;

5183

size_t stride;

5184

} VkDescriptorUpdateTemplateEntry;

5185

5186

typedef struct VkDescriptorUpdateTemplateCreateInfo {

5187

VkStructureType sType;

5188

const void* pNext;

5189

VkDescriptorUpdateTemplateCreateFlags flags;

5190

uint32_t descriptorUpdateEntryCount;

5191

const VkDescriptorUpdateTemplateEntry* pDescriptorUpdateEntries;

5192

VkDescriptorUpdateTemplateType templateType;

5193

VkDescriptorSetLayout descriptorSetLayout;

5194

VkPipelineBindPoint pipelineBindPoint;

5195

VkPipelineLayout pipelineLayout;

5196

uint32_t set;

5197

} VkDescriptorUpdateTemplateCreateInfo;

5198

5199

typedef struct VkExternalMemoryProperties {

5200

VkExternalMemoryFeatureFlags externalMemoryFeatures;

5201

VkExternalMemoryHandleTypeFlags exportFromImportedHandleTypes;

5202

VkExternalMemoryHandleTypeFlags compatibleHandleTypes;

5203

} VkExternalMemoryProperties;

5204

5205

typedef struct VkPhysicalDeviceExternalImageFormatInfo {

5206

VkStructureType sType;

5207

const void* pNext;

5208

VkExternalMemoryHandleTypeFlagBits handleType;

5209

} VkPhysicalDeviceExternalImageFormatInfo;

5210

5211

typedef struct VkExternalImageFormatProperties {

5212

VkStructureType sType;

5213

void* pNext;

5214

VkExternalMemoryProperties externalMemoryProperties;

5215

} VkExternalImageFormatProperties;

5216

5217

typedef struct VkPhysicalDeviceExternalBufferInfo {

5218

VkStructureType sType;

5219

const void* pNext;

5220

VkBufferCreateFlags flags;

5221

VkBufferUsageFlags usage;

5222

VkExternalMemoryHandleTypeFlagBits handleType;

5223

} VkPhysicalDeviceExternalBufferInfo;

5224

5225

typedef struct VkExternalBufferProperties {

5226

VkStructureType sType;

5227

void* pNext;

5228

VkExternalMemoryProperties externalMemoryProperties;

5229

} VkExternalBufferProperties;

5230

5231

typedef struct VkPhysicalDeviceIDProperties {

5232

VkStructureType sType;

5233

void* pNext;

5234

uint8_t deviceUUID[VK_UUID_SIZE];

5235

uint8_t driverUUID[VK_UUID_SIZE];

5236

uint8_t deviceLUID[VK_LUID_SIZE];

5237

uint32_t deviceNodeMask;

5238

VkBool32 deviceLUIDValid;

5239

} VkPhysicalDeviceIDProperties;

5240

5241

typedef struct VkExternalMemoryImageCreateInfo {

5242

VkStructureType sType;

5243

const void* pNext;

5244

VkExternalMemoryHandleTypeFlags handleTypes;

5245

} VkExternalMemoryImageCreateInfo;

5246

5247

typedef struct VkExternalMemoryBufferCreateInfo {

5248

VkStructureType sType;

5249

const void* pNext;

5250

VkExternalMemoryHandleTypeFlags handleTypes;

5251

} VkExternalMemoryBufferCreateInfo;

5252

5253

typedef struct VkExportMemoryAllocateInfo {

5254

VkStructureType sType;

5255

const void* pNext;

5256

VkExternalMemoryHandleTypeFlags handleTypes;

5257

} VkExportMemoryAllocateInfo;

5258

5259

typedef struct VkPhysicalDeviceExternalFenceInfo {

5260

VkStructureType sType;

5261

const void* pNext;

5262

VkExternalFenceHandleTypeFlagBits handleType;

5263

} VkPhysicalDeviceExternalFenceInfo;

5264

5265

typedef struct VkExternalFenceProperties {

5266

VkStructureType sType;

5267

void* pNext;

5268

VkExternalFenceHandleTypeFlags exportFromImportedHandleTypes;

5269

VkExternalFenceHandleTypeFlags compatibleHandleTypes;

5270

VkExternalFenceFeatureFlags externalFenceFeatures;

5271

} VkExternalFenceProperties;

5272

5273

typedef struct VkExportFenceCreateInfo {

5274

VkStructureType sType;

5275

const void* pNext;

5276

VkExternalFenceHandleTypeFlags handleTypes;

5277

} VkExportFenceCreateInfo;

5278

5279

typedef struct VkExportSemaphoreCreateInfo {

5280

VkStructureType sType;

5281

const void* pNext;

5282

VkExternalSemaphoreHandleTypeFlags handleTypes;

5283

} VkExportSemaphoreCreateInfo;

5284

5285

typedef struct VkPhysicalDeviceExternalSemaphoreInfo {

5286

VkStructureType sType;

5287

const void* pNext;

5288

VkExternalSemaphoreHandleTypeFlagBits handleType;

5289

} VkPhysicalDeviceExternalSemaphoreInfo;

5290

5291

typedef struct VkExternalSemaphoreProperties {

5292

VkStructureType sType;

5293

void* pNext;

5294

VkExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes;

5295

VkExternalSemaphoreHandleTypeFlags compatibleHandleTypes;

5296

VkExternalSemaphoreFeatureFlags externalSemaphoreFeatures;

5297

} VkExternalSemaphoreProperties;

5298

5299

typedef struct VkPhysicalDeviceMaintenance3Properties {

5300

VkStructureType sType;

5301

void* pNext;

5302

uint32_t maxPerSetDescriptors;

5303

VkDeviceSize maxMemoryAllocationSize;

5304

} VkPhysicalDeviceMaintenance3Properties;

5305

5306

typedef struct VkDescriptorSetLayoutSupport {

5307

VkStructureType sType;

5308

void* pNext;

5309

VkBool32 supported;

5310

} VkDescriptorSetLayoutSupport;

5311

5312

typedef struct VkPhysicalDeviceShaderDrawParametersFeatures {

5313

VkStructureType sType;

5314

void* pNext;

5315

VkBool32 shaderDrawParameters;

5316

} VkPhysicalDeviceShaderDrawParametersFeatures;

5317

5318

typedef VkPhysicalDeviceShaderDrawParametersFeatures VkPhysicalDeviceShaderDrawParameterFeatures;

5319

5320

typedef VkResult (VKAPI_PTR *PFN_vkEnumerateInstanceVersion)(uint32_t* pApiVersion);

5321

typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos);

5322

typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos);

5323

typedef void (VKAPI_PTR *PFN_vkGetDeviceGroupPeerMemoryFeatures)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);

5324

typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMask)(VkCommandBuffer commandBuffer, uint32_t deviceMask);

5325

typedef void (VKAPI_PTR *PFN_vkCmdDispatchBase)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);

5326

typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceGroups)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties);

5327

typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2)(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements);

5328

typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2)(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements);

5329

typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements2)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);

5330

typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures);

5331

typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties);

5332

typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties2)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties);

5333

typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties);

5334

typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties2)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties);

5335

typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties);

5336

typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties);

5337

typedef void (VKAPI_PTR *PFN_vkTrimCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags);

5338

typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue2)(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue);

5339

typedef VkResult (VKAPI_PTR *PFN_vkCreateSamplerYcbcrConversion)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion);

5340

typedef void (VKAPI_PTR *PFN_vkDestroySamplerYcbcrConversion)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator);

5341

typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorUpdateTemplate)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);

5342

typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorUpdateTemplate)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator);

5343

typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplate)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData);

5344

typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties);

5345

typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalFenceProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties);

5346

typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphoreProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties);

5347

typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutSupport)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport);

5348

5349

#ifndef VK_NO_PROTOTYPES

5350

VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceVersion(

5351

uint32_t* pApiVersion);

5352

5353

VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2(

5354

VkDevice device,

5355

uint32_t bindInfoCount,

5356

const VkBindBufferMemoryInfo* pBindInfos);

5357

5358

VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2(

5359

VkDevice device,

5360

uint32_t bindInfoCount,

5361

const VkBindImageMemoryInfo* pBindInfos);

5362

5363

VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeatures(

5364

VkDevice device,

5365

uint32_t heapIndex,

5366

uint32_t localDeviceIndex,

5367

uint32_t remoteDeviceIndex,

5368

VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);

5369

5370

VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMask(

5371

VkCommandBuffer commandBuffer,

5372

uint32_t deviceMask);

5373

5374

VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBase(

5375

VkCommandBuffer commandBuffer,

5376

uint32_t baseGroupX,

5377

uint32_t baseGroupY,

5378

uint32_t baseGroupZ,

5379

uint32_t groupCountX,

5380

uint32_t groupCountY,

5381

uint32_t groupCountZ);

5382

5383

VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroups(

5384

VkInstance instance,

5385

uint32_t* pPhysicalDeviceGroupCount,

5386

VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties);

5387

5388

VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2(

5389

VkDevice device,

5390

const VkImageMemoryRequirementsInfo2* pInfo,

5391

VkMemoryRequirements2* pMemoryRequirements);

5392

5393

VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2(

5394

VkDevice device,

5395

const VkBufferMemoryRequirementsInfo2* pInfo,

5396

VkMemoryRequirements2* pMemoryRequirements);

5397

5398

VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2(

5399

VkDevice device,

5400

const VkImageSparseMemoryRequirementsInfo2* pInfo,

5401

uint32_t* pSparseMemoryRequirementCount,

5402

VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);

5403

5404

VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2(

5405

VkPhysicalDevice physicalDevice,

5406

VkPhysicalDeviceFeatures2* pFeatures);

5407

5408

VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2(

5409

VkPhysicalDevice physicalDevice,

5410

VkPhysicalDeviceProperties2* pProperties);

5411

5412

VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2(

5413

VkPhysicalDevice physicalDevice,

5414

VkFormat format,

5415

VkFormatProperties2* pFormatProperties);

5416

5417

VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2(

5418

VkPhysicalDevice physicalDevice,

5419

const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,

5420

VkImageFormatProperties2* pImageFormatProperties);

5421

5422

VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2(

5423

VkPhysicalDevice physicalDevice,

5424

uint32_t* pQueueFamilyPropertyCount,

5425

VkQueueFamilyProperties2* pQueueFamilyProperties);

5426

5427

VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2(

5428

VkPhysicalDevice physicalDevice,

5429

VkPhysicalDeviceMemoryProperties2* pMemoryProperties);

5430

5431

VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2(

5432

VkPhysicalDevice physicalDevice,

5433

const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,

5434

uint32_t* pPropertyCount,

5435

VkSparseImageFormatProperties2* pProperties);

5436

5437

VKAPI_ATTR void VKAPI_CALL vkTrimCommandPool(

5438

VkDevice device,

5439

VkCommandPool commandPool,

5440

VkCommandPoolTrimFlags flags);

5441

5442

VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue2(

5443

VkDevice device,

5444

const VkDeviceQueueInfo2* pQueueInfo,

5445

VkQueue* pQueue);

5446

5447

VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversion(

5448

VkDevice device,

5449

const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,

5450

const VkAllocationCallbacks* pAllocator,

5451

VkSamplerYcbcrConversion* pYcbcrConversion);

5452

5453

VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversion(

5454

VkDevice device,

5455

VkSamplerYcbcrConversion ycbcrConversion,

5456

const VkAllocationCallbacks* pAllocator);

5457

5458

VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplate(

5459

VkDevice device,

5460

const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,

5461

const VkAllocationCallbacks* pAllocator,

5462

VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);

5463

5464

VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplate(

5465

VkDevice device,

5466

VkDescriptorUpdateTemplate descriptorUpdateTemplate,

5467

const VkAllocationCallbacks* pAllocator);

5468

5469

VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplate(

5470

VkDevice device,

5471

VkDescriptorSet descriptorSet,

5472

VkDescriptorUpdateTemplate descriptorUpdateTemplate,

5473

const void* pData);

5474

5475

VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferProperties(

5476

VkPhysicalDevice physicalDevice,

5477

const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,

5478

VkExternalBufferProperties* pExternalBufferProperties);

5479

5480

VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFenceProperties(

5481

VkPhysicalDevice physicalDevice,

5482

const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,

5483

VkExternalFenceProperties* pExternalFenceProperties);

5484

5485

VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphoreProperties(

5486

VkPhysicalDevice physicalDevice,

5487

const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,

5488

VkExternalSemaphoreProperties* pExternalSemaphoreProperties);

5489

5490

VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupport(

5491

VkDevice device,

5492

const VkDescriptorSetLayoutCreateInfo* pCreateInfo,

5493

VkDescriptorSetLayoutSupport* pSupport);

5494

#endif

5495

5496

5497

#define VK_VERSION_1_2 1

5498

// Vulkan 1.2 version number

5499

#define VK_API_VERSION_1_2 VK_MAKE_API_VERSION(0, 1, 2, 0)// Patch version should always be set to 0

5500

5501

#define VK_MAX_DRIVER_NAME_SIZE 256U

5502

#define VK_MAX_DRIVER_INFO_SIZE 256U

5503

5504

typedef enum VkDriverId {

5505

VK_DRIVER_ID_AMD_PROPRIETARY = 1,

5506

VK_DRIVER_ID_AMD_OPEN_SOURCE = 2,

5507

VK_DRIVER_ID_MESA_RADV = 3,

5508

VK_DRIVER_ID_NVIDIA_PROPRIETARY = 4,

5509

VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS = 5,

5510

VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA = 6,

5511

VK_DRIVER_ID_IMAGINATION_PROPRIETARY = 7,

5512

VK_DRIVER_ID_QUALCOMM_PROPRIETARY = 8,

5513

VK_DRIVER_ID_ARM_PROPRIETARY = 9,

5514

VK_DRIVER_ID_GOOGLE_SWIFTSHADER = 10,

5515

VK_DRIVER_ID_GGP_PROPRIETARY = 11,

5516

VK_DRIVER_ID_BROADCOM_PROPRIETARY = 12,

5517

VK_DRIVER_ID_MESA_LLVMPIPE = 13,

5518

VK_DRIVER_ID_MOLTENVK = 14,

5519

VK_DRIVER_ID_COREAVI_PROPRIETARY = 15,

5520

VK_DRIVER_ID_JUICE_PROPRIETARY = 16,

5521

VK_DRIVER_ID_VERISILICON_PROPRIETARY = 17,

5522

VK_DRIVER_ID_MESA_TURNIP = 18,

5523

VK_DRIVER_ID_MESA_V3DV = 19,

5524

VK_DRIVER_ID_MESA_PANVK = 20,

5525

VK_DRIVER_ID_SAMSUNG_PROPRIETARY = 21,

5526

VK_DRIVER_ID_MESA_VENUS = 22,

5527

VK_DRIVER_ID_AMD_PROPRIETARY_KHR = VK_DRIVER_ID_AMD_PROPRIETARY,

5528

VK_DRIVER_ID_AMD_OPEN_SOURCE_KHR = VK_DRIVER_ID_AMD_OPEN_SOURCE,

5529

VK_DRIVER_ID_MESA_RADV_KHR = VK_DRIVER_ID_MESA_RADV,

5530

VK_DRIVER_ID_NVIDIA_PROPRIETARY_KHR = VK_DRIVER_ID_NVIDIA_PROPRIETARY,

5531

VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS_KHR = VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS,

5532

VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA_KHR = VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA,

5533

VK_DRIVER_ID_IMAGINATION_PROPRIETARY_KHR = VK_DRIVER_ID_IMAGINATION_PROPRIETARY,

5534

VK_DRIVER_ID_QUALCOMM_PROPRIETARY_KHR = VK_DRIVER_ID_QUALCOMM_PROPRIETARY,

5535

VK_DRIVER_ID_ARM_PROPRIETARY_KHR = VK_DRIVER_ID_ARM_PROPRIETARY,

5536

VK_DRIVER_ID_GOOGLE_SWIFTSHADER_KHR = VK_DRIVER_ID_GOOGLE_SWIFTSHADER,

5537

VK_DRIVER_ID_GGP_PROPRIETARY_KHR = VK_DRIVER_ID_GGP_PROPRIETARY,

5538

VK_DRIVER_ID_BROADCOM_PROPRIETARY_KHR = VK_DRIVER_ID_BROADCOM_PROPRIETARY,

5539

VK_DRIVER_ID_MAX_ENUM = 0x7FFFFFFF

5540

} VkDriverId;

5541

5542

typedef enum VkShaderFloatControlsIndependence {

5543

VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY = 0,

5544

VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL = 1,

5545

VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE = 2,

5546

VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY,

5547

VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL,

5548

VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE,

5549

VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_MAX_ENUM = 0x7FFFFFFF

5550

} VkShaderFloatControlsIndependence;

5551

5552

typedef enum VkSamplerReductionMode {

5553

VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE = 0,

5554

VK_SAMPLER_REDUCTION_MODE_MIN = 1,

5555

VK_SAMPLER_REDUCTION_MODE_MAX = 2,

5556

VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE,

5557

VK_SAMPLER_REDUCTION_MODE_MIN_EXT = VK_SAMPLER_REDUCTION_MODE_MIN,

5558

VK_SAMPLER_REDUCTION_MODE_MAX_EXT = VK_SAMPLER_REDUCTION_MODE_MAX,

5559

VK_SAMPLER_REDUCTION_MODE_MAX_ENUM = 0x7FFFFFFF

5560

} VkSamplerReductionMode;

5561

5562

typedef enum VkSemaphoreType {

5563

VK_SEMAPHORE_TYPE_BINARY = 0,

5564

VK_SEMAPHORE_TYPE_TIMELINE = 1,

5565

VK_SEMAPHORE_TYPE_BINARY_KHR = VK_SEMAPHORE_TYPE_BINARY,

5566

VK_SEMAPHORE_TYPE_TIMELINE_KHR = VK_SEMAPHORE_TYPE_TIMELINE,

5567

VK_SEMAPHORE_TYPE_MAX_ENUM = 0x7FFFFFFF

5568

} VkSemaphoreType;

5569

5570

typedef enum VkResolveModeFlagBits {

5571

VK_RESOLVE_MODE_NONE = 0,

5572

VK_RESOLVE_MODE_SAMPLE_ZERO_BIT = 0x00000001,

5573

VK_RESOLVE_MODE_AVERAGE_BIT = 0x00000002,

5574

VK_RESOLVE_MODE_MIN_BIT = 0x00000004,

5575

VK_RESOLVE_MODE_MAX_BIT = 0x00000008,

5576

VK_RESOLVE_MODE_NONE_KHR = VK_RESOLVE_MODE_NONE,

5577

VK_RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT,

5578

VK_RESOLVE_MODE_AVERAGE_BIT_KHR = VK_RESOLVE_MODE_AVERAGE_BIT,

5579

VK_RESOLVE_MODE_MIN_BIT_KHR = VK_RESOLVE_MODE_MIN_BIT,

5580

VK_RESOLVE_MODE_MAX_BIT_KHR = VK_RESOLVE_MODE_MAX_BIT,

5581

VK_RESOLVE_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

5582

} VkResolveModeFlagBits;

5583

typedef VkFlags VkResolveModeFlags;

5584

5585

typedef enum VkDescriptorBindingFlagBits {

5586

VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT = 0x00000001,

5587

VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT = 0x00000002,

5588

VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT = 0x00000004,

5589

VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT = 0x00000008,

5590

VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT = VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT,

5591

VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT = VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT,

5592

VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT = VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT,

5593

VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT = VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT,

5594

VK_DESCRIPTOR_BINDING_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

5595

} VkDescriptorBindingFlagBits;

5596

typedef VkFlags VkDescriptorBindingFlags;

5597

5598

typedef enum VkSemaphoreWaitFlagBits {

5599

VK_SEMAPHORE_WAIT_ANY_BIT = 0x00000001,

5600

VK_SEMAPHORE_WAIT_ANY_BIT_KHR = VK_SEMAPHORE_WAIT_ANY_BIT,

5601

VK_SEMAPHORE_WAIT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

5602

} VkSemaphoreWaitFlagBits;

5603

typedef VkFlags VkSemaphoreWaitFlags;

5604

typedef struct VkPhysicalDeviceVulkan11Features {

5605

VkStructureType sType;

5606

void* pNext;

5607

VkBool32 storageBuffer16BitAccess;

5608

VkBool32 uniformAndStorageBuffer16BitAccess;

5609

VkBool32 storagePushConstant16;

5610

VkBool32 storageInputOutput16;

5611

VkBool32 multiview;

5612

VkBool32 multiviewGeometryShader;

5613

VkBool32 multiviewTessellationShader;

5614

VkBool32 variablePointersStorageBuffer;

5615

VkBool32 variablePointers;

5616

VkBool32 protectedMemory;

5617

VkBool32 samplerYcbcrConversion;

5618

VkBool32 shaderDrawParameters;

5619

} VkPhysicalDeviceVulkan11Features;

5620

5621

typedef struct VkPhysicalDeviceVulkan11Properties {

5622

VkStructureType sType;

5623

void* pNext;

5624

uint8_t deviceUUID[VK_UUID_SIZE];

5625

uint8_t driverUUID[VK_UUID_SIZE];

5626

uint8_t deviceLUID[VK_LUID_SIZE];

5627

uint32_t deviceNodeMask;

5628

VkBool32 deviceLUIDValid;

5629

uint32_t subgroupSize;

5630

VkShaderStageFlags subgroupSupportedStages;

5631

VkSubgroupFeatureFlags subgroupSupportedOperations;

5632

VkBool32 subgroupQuadOperationsInAllStages;

5633

VkPointClippingBehavior pointClippingBehavior;

5634

uint32_t maxMultiviewViewCount;

5635

uint32_t maxMultiviewInstanceIndex;

5636

VkBool32 protectedNoFault;

5637

uint32_t maxPerSetDescriptors;

5638

VkDeviceSize maxMemoryAllocationSize;

5639

} VkPhysicalDeviceVulkan11Properties;

5640

5641

typedef struct VkPhysicalDeviceVulkan12Features {

5642

VkStructureType sType;

5643

void* pNext;

5644

VkBool32 samplerMirrorClampToEdge;

5645

VkBool32 drawIndirectCount;

5646

VkBool32 storageBuffer8BitAccess;

5647

VkBool32 uniformAndStorageBuffer8BitAccess;

5648

VkBool32 storagePushConstant8;

5649

VkBool32 shaderBufferInt64Atomics;

5650

VkBool32 shaderSharedInt64Atomics;

5651

VkBool32 shaderFloat16;

5652

VkBool32 shaderInt8;

5653

VkBool32 descriptorIndexing;

5654

VkBool32 shaderInputAttachmentArrayDynamicIndexing;

5655

VkBool32 shaderUniformTexelBufferArrayDynamicIndexing;

5656

VkBool32 shaderStorageTexelBufferArrayDynamicIndexing;

5657

VkBool32 shaderUniformBufferArrayNonUniformIndexing;

5658

VkBool32 shaderSampledImageArrayNonUniformIndexing;

5659

VkBool32 shaderStorageBufferArrayNonUniformIndexing;

5660

VkBool32 shaderStorageImageArrayNonUniformIndexing;

5661

VkBool32 shaderInputAttachmentArrayNonUniformIndexing;

5662

VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing;

5663

VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing;

5664

VkBool32 descriptorBindingUniformBufferUpdateAfterBind;

5665

VkBool32 descriptorBindingSampledImageUpdateAfterBind;

5666

VkBool32 descriptorBindingStorageImageUpdateAfterBind;

5667

VkBool32 descriptorBindingStorageBufferUpdateAfterBind;

5668

VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind;

5669

VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind;

5670

VkBool32 descriptorBindingUpdateUnusedWhilePending;

5671

VkBool32 descriptorBindingPartiallyBound;

5672

VkBool32 descriptorBindingVariableDescriptorCount;

5673

VkBool32 runtimeDescriptorArray;

5674

VkBool32 samplerFilterMinmax;

5675

VkBool32 scalarBlockLayout;

5676

VkBool32 imagelessFramebuffer;

5677

VkBool32 uniformBufferStandardLayout;

5678

VkBool32 shaderSubgroupExtendedTypes;

5679

VkBool32 separateDepthStencilLayouts;

5680

VkBool32 hostQueryReset;

5681

VkBool32 timelineSemaphore;

5682

VkBool32 bufferDeviceAddress;

5683

VkBool32 bufferDeviceAddressCaptureReplay;

5684

VkBool32 bufferDeviceAddressMultiDevice;

5685

VkBool32 vulkanMemoryModel;

5686

VkBool32 vulkanMemoryModelDeviceScope;

5687

VkBool32 vulkanMemoryModelAvailabilityVisibilityChains;

5688

VkBool32 shaderOutputViewportIndex;

5689

VkBool32 shaderOutputLayer;

5690

VkBool32 subgroupBroadcastDynamicId;

5691

} VkPhysicalDeviceVulkan12Features;

5692

5693

typedef struct VkConformanceVersion {

5694

uint8_t major;

5695

uint8_t minor;

5696

uint8_t subminor;

5697

uint8_t patch;

5698

} VkConformanceVersion;

5699

5700

typedef struct VkPhysicalDeviceVulkan12Properties {

5701

VkStructureType sType;

5702

void* pNext;

5703

VkDriverId driverID;

5704

char driverName[VK_MAX_DRIVER_NAME_SIZE];

5705

char driverInfo[VK_MAX_DRIVER_INFO_SIZE];

5706

VkConformanceVersion conformanceVersion;

5707

VkShaderFloatControlsIndependence denormBehaviorIndependence;

5708

VkShaderFloatControlsIndependence roundingModeIndependence;

5709

VkBool32 shaderSignedZeroInfNanPreserveFloat16;

5710

VkBool32 shaderSignedZeroInfNanPreserveFloat32;

5711

VkBool32 shaderSignedZeroInfNanPreserveFloat64;

5712

VkBool32 shaderDenormPreserveFloat16;

5713

VkBool32 shaderDenormPreserveFloat32;

5714

VkBool32 shaderDenormPreserveFloat64;

5715

VkBool32 shaderDenormFlushToZeroFloat16;

5716

VkBool32 shaderDenormFlushToZeroFloat32;

5717

VkBool32 shaderDenormFlushToZeroFloat64;

5718

VkBool32 shaderRoundingModeRTEFloat16;

5719

VkBool32 shaderRoundingModeRTEFloat32;

5720

VkBool32 shaderRoundingModeRTEFloat64;

5721

VkBool32 shaderRoundingModeRTZFloat16;

5722

VkBool32 shaderRoundingModeRTZFloat32;

5723

VkBool32 shaderRoundingModeRTZFloat64;

5724

uint32_t maxUpdateAfterBindDescriptorsInAllPools;

5725

VkBool32 shaderUniformBufferArrayNonUniformIndexingNative;

5726

VkBool32 shaderSampledImageArrayNonUniformIndexingNative;

5727

VkBool32 shaderStorageBufferArrayNonUniformIndexingNative;

5728

VkBool32 shaderStorageImageArrayNonUniformIndexingNative;

5729

VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative;

5730

VkBool32 robustBufferAccessUpdateAfterBind;

5731

VkBool32 quadDivergentImplicitLod;

5732

uint32_t maxPerStageDescriptorUpdateAfterBindSamplers;

5733

uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers;

5734

uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers;

5735

uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages;

5736

uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages;

5737

uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments;

5738

uint32_t maxPerStageUpdateAfterBindResources;

5739

uint32_t maxDescriptorSetUpdateAfterBindSamplers;

5740

uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers;

5741

uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;

5742

uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers;

5743

uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;

5744

uint32_t maxDescriptorSetUpdateAfterBindSampledImages;

5745

uint32_t maxDescriptorSetUpdateAfterBindStorageImages;

5746

uint32_t maxDescriptorSetUpdateAfterBindInputAttachments;

5747

VkResolveModeFlags supportedDepthResolveModes;

5748

VkResolveModeFlags supportedStencilResolveModes;

5749

VkBool32 independentResolveNone;

5750

VkBool32 independentResolve;

5751

VkBool32 filterMinmaxSingleComponentFormats;

5752

VkBool32 filterMinmaxImageComponentMapping;

5753

uint64_t maxTimelineSemaphoreValueDifference;

5754

VkSampleCountFlags framebufferIntegerColorSampleCounts;

5755

} VkPhysicalDeviceVulkan12Properties;

5756

5757

typedef struct VkImageFormatListCreateInfo {

5758

VkStructureType sType;

5759

const void* pNext;

5760

uint32_t viewFormatCount;

5761

const VkFormat* pViewFormats;

5762

} VkImageFormatListCreateInfo;

5763

5764

typedef struct VkAttachmentDescription2 {

5765

VkStructureType sType;

5766

const void* pNext;

5767

VkAttachmentDescriptionFlags flags;

5768

VkFormat format;

5769

VkSampleCountFlagBits samples;

5770

VkAttachmentLoadOp loadOp;

5771

VkAttachmentStoreOp storeOp;

5772

VkAttachmentLoadOp stencilLoadOp;

5773

VkAttachmentStoreOp stencilStoreOp;

5774

VkImageLayout initialLayout;

5775

VkImageLayout finalLayout;

5776

} VkAttachmentDescription2;

5777

5778

typedef struct VkAttachmentReference2 {

5779

VkStructureType sType;

5780

const void* pNext;

5781

uint32_t attachment;

5782

VkImageLayout layout;

5783

VkImageAspectFlags aspectMask;

5784

} VkAttachmentReference2;

5785

5786

typedef struct VkSubpassDescription2 {

5787

VkStructureType sType;

5788

const void* pNext;

5789

VkSubpassDescriptionFlags flags;

5790

VkPipelineBindPoint pipelineBindPoint;

5791

uint32_t viewMask;

5792

uint32_t inputAttachmentCount;

5793

const VkAttachmentReference2* pInputAttachments;

5794

uint32_t colorAttachmentCount;

5795

const VkAttachmentReference2* pColorAttachments;

5796

const VkAttachmentReference2* pResolveAttachments;

5797

const VkAttachmentReference2* pDepthStencilAttachment;

5798

uint32_t preserveAttachmentCount;

5799

const uint32_t* pPreserveAttachments;

5800

} VkSubpassDescription2;

5801

5802

typedef struct VkSubpassDependency2 {

5803

VkStructureType sType;

5804

const void* pNext;

5805

uint32_t srcSubpass;

5806

uint32_t dstSubpass;

5807

VkPipelineStageFlags srcStageMask;

5808

VkPipelineStageFlags dstStageMask;

5809

VkAccessFlags srcAccessMask;

5810

VkAccessFlags dstAccessMask;

5811

VkDependencyFlags dependencyFlags;

5812

int32_t viewOffset;

5813

} VkSubpassDependency2;

5814

5815

typedef struct VkRenderPassCreateInfo2 {

5816

VkStructureType sType;

5817

const void* pNext;

5818

VkRenderPassCreateFlags flags;

5819

uint32_t attachmentCount;

5820

const VkAttachmentDescription2* pAttachments;

5821

uint32_t subpassCount;

5822

const VkSubpassDescription2* pSubpasses;

5823

uint32_t dependencyCount;

5824

const VkSubpassDependency2* pDependencies;

5825

uint32_t correlatedViewMaskCount;

5826

const uint32_t* pCorrelatedViewMasks;

5827

} VkRenderPassCreateInfo2;

5828

5829

typedef struct VkSubpassBeginInfo {

5830

VkStructureType sType;

5831

const void* pNext;

5832

VkSubpassContents contents;

5833

} VkSubpassBeginInfo;

5834

5835

typedef struct VkSubpassEndInfo {

5836

VkStructureType sType;

5837

const void* pNext;

5838

} VkSubpassEndInfo;

5839

5840

typedef struct VkPhysicalDevice8BitStorageFeatures {

5841

VkStructureType sType;

5842

void* pNext;

5843

VkBool32 storageBuffer8BitAccess;

5844

VkBool32 uniformAndStorageBuffer8BitAccess;

5845

VkBool32 storagePushConstant8;

5846

} VkPhysicalDevice8BitStorageFeatures;

5847

5848

typedef struct VkPhysicalDeviceDriverProperties {

5849

VkStructureType sType;

5850

void* pNext;

5851

VkDriverId driverID;

5852

char driverName[VK_MAX_DRIVER_NAME_SIZE];

5853

char driverInfo[VK_MAX_DRIVER_INFO_SIZE];

5854

VkConformanceVersion conformanceVersion;

5855

} VkPhysicalDeviceDriverProperties;

5856

5857

typedef struct VkPhysicalDeviceShaderAtomicInt64Features {

5858

VkStructureType sType;

5859

void* pNext;

5860

VkBool32 shaderBufferInt64Atomics;

5861

VkBool32 shaderSharedInt64Atomics;

5862

} VkPhysicalDeviceShaderAtomicInt64Features;

5863

5864

typedef struct VkPhysicalDeviceShaderFloat16Int8Features {

5865

VkStructureType sType;

5866

void* pNext;

5867

VkBool32 shaderFloat16;

5868

VkBool32 shaderInt8;

5869

} VkPhysicalDeviceShaderFloat16Int8Features;

5870

5871

typedef struct VkPhysicalDeviceFloatControlsProperties {

5872

VkStructureType sType;

5873

void* pNext;

5874

VkShaderFloatControlsIndependence denormBehaviorIndependence;

5875

VkShaderFloatControlsIndependence roundingModeIndependence;

5876

VkBool32 shaderSignedZeroInfNanPreserveFloat16;

5877

VkBool32 shaderSignedZeroInfNanPreserveFloat32;

5878

VkBool32 shaderSignedZeroInfNanPreserveFloat64;

5879

VkBool32 shaderDenormPreserveFloat16;

5880

VkBool32 shaderDenormPreserveFloat32;

5881

VkBool32 shaderDenormPreserveFloat64;

5882

VkBool32 shaderDenormFlushToZeroFloat16;

5883

VkBool32 shaderDenormFlushToZeroFloat32;

5884

VkBool32 shaderDenormFlushToZeroFloat64;

5885

VkBool32 shaderRoundingModeRTEFloat16;

5886

VkBool32 shaderRoundingModeRTEFloat32;

5887

VkBool32 shaderRoundingModeRTEFloat64;

5888

VkBool32 shaderRoundingModeRTZFloat16;

5889

VkBool32 shaderRoundingModeRTZFloat32;

5890

VkBool32 shaderRoundingModeRTZFloat64;

5891

} VkPhysicalDeviceFloatControlsProperties;

5892

5893

typedef struct VkDescriptorSetLayoutBindingFlagsCreateInfo {

5894

VkStructureType sType;

5895

const void* pNext;

5896

uint32_t bindingCount;

5897

const VkDescriptorBindingFlags* pBindingFlags;

5898

} VkDescriptorSetLayoutBindingFlagsCreateInfo;

5899

5900

typedef struct VkPhysicalDeviceDescriptorIndexingFeatures {

5901

VkStructureType sType;

5902

void* pNext;

5903

VkBool32 shaderInputAttachmentArrayDynamicIndexing;

5904

VkBool32 shaderUniformTexelBufferArrayDynamicIndexing;

5905

VkBool32 shaderStorageTexelBufferArrayDynamicIndexing;

5906

VkBool32 shaderUniformBufferArrayNonUniformIndexing;

5907

VkBool32 shaderSampledImageArrayNonUniformIndexing;

5908

VkBool32 shaderStorageBufferArrayNonUniformIndexing;

5909

VkBool32 shaderStorageImageArrayNonUniformIndexing;

5910

VkBool32 shaderInputAttachmentArrayNonUniformIndexing;

5911

VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing;

5912

VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing;

5913

VkBool32 descriptorBindingUniformBufferUpdateAfterBind;

5914

VkBool32 descriptorBindingSampledImageUpdateAfterBind;

5915

VkBool32 descriptorBindingStorageImageUpdateAfterBind;

5916

VkBool32 descriptorBindingStorageBufferUpdateAfterBind;

5917

VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind;

5918

VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind;

5919

VkBool32 descriptorBindingUpdateUnusedWhilePending;

5920

VkBool32 descriptorBindingPartiallyBound;

5921

VkBool32 descriptorBindingVariableDescriptorCount;

5922

VkBool32 runtimeDescriptorArray;

5923

} VkPhysicalDeviceDescriptorIndexingFeatures;

5924

5925

typedef struct VkPhysicalDeviceDescriptorIndexingProperties {

5926

VkStructureType sType;

5927

void* pNext;

5928

uint32_t maxUpdateAfterBindDescriptorsInAllPools;

5929

VkBool32 shaderUniformBufferArrayNonUniformIndexingNative;

5930

VkBool32 shaderSampledImageArrayNonUniformIndexingNative;

5931

VkBool32 shaderStorageBufferArrayNonUniformIndexingNative;

5932

VkBool32 shaderStorageImageArrayNonUniformIndexingNative;

5933

VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative;

5934

VkBool32 robustBufferAccessUpdateAfterBind;

5935

VkBool32 quadDivergentImplicitLod;

5936

uint32_t maxPerStageDescriptorUpdateAfterBindSamplers;

5937

uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers;

5938

uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers;

5939

uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages;

5940

uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages;

5941

uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments;

5942

uint32_t maxPerStageUpdateAfterBindResources;

5943

uint32_t maxDescriptorSetUpdateAfterBindSamplers;

5944

uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers;

5945

uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;

5946

uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers;

5947

uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;

5948

uint32_t maxDescriptorSetUpdateAfterBindSampledImages;

5949

uint32_t maxDescriptorSetUpdateAfterBindStorageImages;

5950

uint32_t maxDescriptorSetUpdateAfterBindInputAttachments;

5951

} VkPhysicalDeviceDescriptorIndexingProperties;

5952

5953

typedef struct VkDescriptorSetVariableDescriptorCountAllocateInfo {

5954

VkStructureType sType;

5955

const void* pNext;

5956

uint32_t descriptorSetCount;

5957

const uint32_t* pDescriptorCounts;

5958

} VkDescriptorSetVariableDescriptorCountAllocateInfo;

5959

5960

typedef struct VkDescriptorSetVariableDescriptorCountLayoutSupport {

5961

VkStructureType sType;

5962

void* pNext;

5963

uint32_t maxVariableDescriptorCount;

5964

} VkDescriptorSetVariableDescriptorCountLayoutSupport;

5965

5966

typedef struct VkSubpassDescriptionDepthStencilResolve {

5967

VkStructureType sType;

5968

const void* pNext;

5969

VkResolveModeFlagBits depthResolveMode;

5970

VkResolveModeFlagBits stencilResolveMode;

5971

const VkAttachmentReference2* pDepthStencilResolveAttachment;

5972

} VkSubpassDescriptionDepthStencilResolve;

5973

5974

typedef struct VkPhysicalDeviceDepthStencilResolveProperties {

5975

VkStructureType sType;

5976

void* pNext;

5977

VkResolveModeFlags supportedDepthResolveModes;

5978

VkResolveModeFlags supportedStencilResolveModes;

5979

VkBool32 independentResolveNone;

5980

VkBool32 independentResolve;

5981

} VkPhysicalDeviceDepthStencilResolveProperties;

5982

5983

typedef struct VkPhysicalDeviceScalarBlockLayoutFeatures {

5984

VkStructureType sType;

5985

void* pNext;

5986

VkBool32 scalarBlockLayout;

5987

} VkPhysicalDeviceScalarBlockLayoutFeatures;

5988

5989

typedef struct VkImageStencilUsageCreateInfo {

5990

VkStructureType sType;

5991

const void* pNext;

5992

VkImageUsageFlags stencilUsage;

5993

} VkImageStencilUsageCreateInfo;

5994

5995

typedef struct VkSamplerReductionModeCreateInfo {

5996

VkStructureType sType;

5997

const void* pNext;

5998

VkSamplerReductionMode reductionMode;

5999

} VkSamplerReductionModeCreateInfo;

6000

6001

typedef struct VkPhysicalDeviceSamplerFilterMinmaxProperties {

6002

VkStructureType sType;

6003

void* pNext;

6004

VkBool32 filterMinmaxSingleComponentFormats;

6005

VkBool32 filterMinmaxImageComponentMapping;

6006

} VkPhysicalDeviceSamplerFilterMinmaxProperties;

6007

6008

typedef struct VkPhysicalDeviceVulkanMemoryModelFeatures {

6009

VkStructureType sType;

6010

void* pNext;

6011

VkBool32 vulkanMemoryModel;

6012

VkBool32 vulkanMemoryModelDeviceScope;

6013

VkBool32 vulkanMemoryModelAvailabilityVisibilityChains;

6014

} VkPhysicalDeviceVulkanMemoryModelFeatures;

6015

6016

typedef struct VkPhysicalDeviceImagelessFramebufferFeatures {

6017

VkStructureType sType;

6018

void* pNext;

6019

VkBool32 imagelessFramebuffer;

6020

} VkPhysicalDeviceImagelessFramebufferFeatures;

6021

6022

typedef struct VkFramebufferAttachmentImageInfo {

6023

VkStructureType sType;

6024

const void* pNext;

6025

VkImageCreateFlags flags;

6026

VkImageUsageFlags usage;

6027

uint32_t width;

6028

uint32_t height;

6029

uint32_t layerCount;

6030

uint32_t viewFormatCount;

6031

const VkFormat* pViewFormats;

6032

} VkFramebufferAttachmentImageInfo;

6033

6034

typedef struct VkFramebufferAttachmentsCreateInfo {

6035

VkStructureType sType;

6036

const void* pNext;

6037

uint32_t attachmentImageInfoCount;

6038

const VkFramebufferAttachmentImageInfo* pAttachmentImageInfos;

6039

} VkFramebufferAttachmentsCreateInfo;

6040

6041

typedef struct VkRenderPassAttachmentBeginInfo {

6042

VkStructureType sType;

6043

const void* pNext;

6044

uint32_t attachmentCount;

6045

const VkImageView* pAttachments;

6046

} VkRenderPassAttachmentBeginInfo;

6047

6048

typedef struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures {

6049

VkStructureType sType;

6050

void* pNext;

6051

VkBool32 uniformBufferStandardLayout;

6052

} VkPhysicalDeviceUniformBufferStandardLayoutFeatures;

6053

6054

typedef struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures {

6055

VkStructureType sType;

6056

void* pNext;

6057

VkBool32 shaderSubgroupExtendedTypes;

6058

} VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures;

6059

6060

typedef struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures {

6061

VkStructureType sType;

6062

void* pNext;

6063

VkBool32 separateDepthStencilLayouts;

6064

} VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures;

6065

6066

typedef struct VkAttachmentReferenceStencilLayout {

6067

VkStructureType sType;

6068

void* pNext;

6069

VkImageLayout stencilLayout;

6070

} VkAttachmentReferenceStencilLayout;

6071

6072

typedef struct VkAttachmentDescriptionStencilLayout {

6073

VkStructureType sType;

6074

void* pNext;

6075

VkImageLayout stencilInitialLayout;

6076

VkImageLayout stencilFinalLayout;

6077

} VkAttachmentDescriptionStencilLayout;

6078

6079

typedef struct VkPhysicalDeviceHostQueryResetFeatures {

6080

VkStructureType sType;

6081

void* pNext;

6082

VkBool32 hostQueryReset;

6083

} VkPhysicalDeviceHostQueryResetFeatures;

6084

6085

typedef struct VkPhysicalDeviceTimelineSemaphoreFeatures {

6086

VkStructureType sType;

6087

void* pNext;

6088

VkBool32 timelineSemaphore;

6089

} VkPhysicalDeviceTimelineSemaphoreFeatures;

6090

6091

typedef struct VkPhysicalDeviceTimelineSemaphoreProperties {

6092

VkStructureType sType;

6093

void* pNext;

6094

uint64_t maxTimelineSemaphoreValueDifference;

6095

} VkPhysicalDeviceTimelineSemaphoreProperties;

6096

6097

typedef struct VkSemaphoreTypeCreateInfo {

6098

VkStructureType sType;

6099

const void* pNext;

6100

VkSemaphoreType semaphoreType;

6101

uint64_t initialValue;

6102

} VkSemaphoreTypeCreateInfo;

6103

6104

typedef struct VkTimelineSemaphoreSubmitInfo {

6105

VkStructureType sType;

6106

const void* pNext;

6107

uint32_t waitSemaphoreValueCount;

6108

const uint64_t* pWaitSemaphoreValues;

6109

uint32_t signalSemaphoreValueCount;

6110

const uint64_t* pSignalSemaphoreValues;

6111

} VkTimelineSemaphoreSubmitInfo;

6112

6113

typedef struct VkSemaphoreWaitInfo {

6114

VkStructureType sType;

6115

const void* pNext;

6116

VkSemaphoreWaitFlags flags;

6117

uint32_t semaphoreCount;

6118

const VkSemaphore* pSemaphores;

6119

const uint64_t* pValues;

6120

} VkSemaphoreWaitInfo;

6121

6122

typedef struct VkSemaphoreSignalInfo {

6123

VkStructureType sType;

6124

const void* pNext;

6125

VkSemaphore semaphore;

6126

uint64_t value;

6127

} VkSemaphoreSignalInfo;

6128

6129

typedef struct VkPhysicalDeviceBufferDeviceAddressFeatures {

6130

VkStructureType sType;

6131

void* pNext;

6132

VkBool32 bufferDeviceAddress;

6133

VkBool32 bufferDeviceAddressCaptureReplay;

6134

VkBool32 bufferDeviceAddressMultiDevice;

6135

} VkPhysicalDeviceBufferDeviceAddressFeatures;

6136

6137

typedef struct VkBufferDeviceAddressInfo {

6138

VkStructureType sType;

6139

const void* pNext;

6140

VkBuffer buffer;

6141

} VkBufferDeviceAddressInfo;

6142

6143

typedef struct VkBufferOpaqueCaptureAddressCreateInfo {

6144

VkStructureType sType;

6145

const void* pNext;

6146

uint64_t opaqueCaptureAddress;

6147

} VkBufferOpaqueCaptureAddressCreateInfo;

6148

6149

typedef struct VkMemoryOpaqueCaptureAddressAllocateInfo {

6150

VkStructureType sType;

6151

const void* pNext;

6152

uint64_t opaqueCaptureAddress;

6153

} VkMemoryOpaqueCaptureAddressAllocateInfo;

6154

6155

typedef struct VkDeviceMemoryOpaqueCaptureAddressInfo {

6156

VkStructureType sType;

6157

const void* pNext;

6158

VkDeviceMemory memory;

6159

} VkDeviceMemoryOpaqueCaptureAddressInfo;

6160

6161

typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCount)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);

6162

typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCount)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);

6163

typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass2)(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass);

6164

typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass2)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo);

6165

typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass2)(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo);

6166

typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass2)(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo);

6167

typedef void (VKAPI_PTR *PFN_vkResetQueryPool)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount);

6168

typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreCounterValue)(VkDevice device, VkSemaphore semaphore, uint64_t* pValue);

6169

typedef VkResult (VKAPI_PTR *PFN_vkWaitSemaphores)(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout);

6170

typedef VkResult (VKAPI_PTR *PFN_vkSignalSemaphore)(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo);

6171

typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddress)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo);

6172

typedef uint64_t (VKAPI_PTR *PFN_vkGetBufferOpaqueCaptureAddress)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo);

6173

typedef uint64_t (VKAPI_PTR *PFN_vkGetDeviceMemoryOpaqueCaptureAddress)(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo);

6174

6175

#ifndef VK_NO_PROTOTYPES

6176

VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCount(

6177

VkCommandBuffer commandBuffer,

6178

VkBuffer buffer,

6179

VkDeviceSize offset,

6180

VkBuffer countBuffer,

6181

VkDeviceSize countBufferOffset,

6182

uint32_t maxDrawCount,

6183

uint32_t stride);

6184

6185

VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCount(

6186

VkCommandBuffer commandBuffer,

6187

VkBuffer buffer,

6188

VkDeviceSize offset,

6189

VkBuffer countBuffer,

6190

VkDeviceSize countBufferOffset,

6191

uint32_t maxDrawCount,

6192

uint32_t stride);

6193

6194

VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass2(

6195

VkDevice device,

6196

const VkRenderPassCreateInfo2* pCreateInfo,

6197

const VkAllocationCallbacks* pAllocator,

6198

VkRenderPass* pRenderPass);

6199

6200

VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass2(

6201

VkCommandBuffer commandBuffer,

6202

const VkRenderPassBeginInfo* pRenderPassBegin,

6203

const VkSubpassBeginInfo* pSubpassBeginInfo);

6204

6205

VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass2(

6206

VkCommandBuffer commandBuffer,

6207

const VkSubpassBeginInfo* pSubpassBeginInfo,

6208

const VkSubpassEndInfo* pSubpassEndInfo);

6209

6210

VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass2(

6211

VkCommandBuffer commandBuffer,

6212

const VkSubpassEndInfo* pSubpassEndInfo);

6213

6214

VKAPI_ATTR void VKAPI_CALL vkResetQueryPool(

6215

VkDevice device,

6216

VkQueryPool queryPool,

6217

uint32_t firstQuery,

6218

uint32_t queryCount);

6219

6220

VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreCounterValue(

6221

VkDevice device,

6222

VkSemaphore semaphore,

6223

uint64_t* pValue);

6224

6225

VKAPI_ATTR VkResult VKAPI_CALL vkWaitSemaphores(

6226

VkDevice device,

6227

const VkSemaphoreWaitInfo* pWaitInfo,

6228

uint64_t timeout);

6229

6230

VKAPI_ATTR VkResult VKAPI_CALL vkSignalSemaphore(

6231

VkDevice device,

6232

const VkSemaphoreSignalInfo* pSignalInfo);

6233

6234

VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddress(

6235

VkDevice device,

6236

const VkBufferDeviceAddressInfo* pInfo);

6237

6238

VKAPI_ATTR uint64_t VKAPI_CALL vkGetBufferOpaqueCaptureAddress(

6239

VkDevice device,

6240

const VkBufferDeviceAddressInfo* pInfo);

6241

6242

VKAPI_ATTR uint64_t VKAPI_CALL vkGetDeviceMemoryOpaqueCaptureAddress(

6243

VkDevice device,

6244

const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo);

6245

#endif

6246

6247

6248

#define VK_VERSION_1_3 1

6249

// Vulkan 1.3 version number

6250

#define VK_API_VERSION_1_3 VK_MAKE_API_VERSION(0, 1, 3, 0)// Patch version should always be set to 0

6251

6252

typedef uint64_t VkFlags64;

6253

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPrivateDataSlot)

6254

6255

typedef enum VkPipelineCreationFeedbackFlagBits {

6256

VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT = 0x00000001,

6257

VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT = 0x00000002,

6258

VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT = 0x00000004,

6259

VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT_EXT = VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT,

6260

VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT_EXT = VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT,

6261

VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT_EXT = VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT,

6262

VK_PIPELINE_CREATION_FEEDBACK_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

6263

} VkPipelineCreationFeedbackFlagBits;

6264

typedef VkFlags VkPipelineCreationFeedbackFlags;

6265

6266

typedef enum VkToolPurposeFlagBits {

6267

VK_TOOL_PURPOSE_VALIDATION_BIT = 0x00000001,

6268

VK_TOOL_PURPOSE_PROFILING_BIT = 0x00000002,

6269

VK_TOOL_PURPOSE_TRACING_BIT = 0x00000004,

6270

VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT = 0x00000008,

6271

VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT = 0x00000010,

6272

VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT = 0x00000020,

6273

VK_TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT = 0x00000040,

6274

VK_TOOL_PURPOSE_VALIDATION_BIT_EXT = VK_TOOL_PURPOSE_VALIDATION_BIT,

6275

VK_TOOL_PURPOSE_PROFILING_BIT_EXT = VK_TOOL_PURPOSE_PROFILING_BIT,

6276

VK_TOOL_PURPOSE_TRACING_BIT_EXT = VK_TOOL_PURPOSE_TRACING_BIT,

6277

VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT_EXT = VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT,

6278

VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT_EXT = VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT,

6279

VK_TOOL_PURPOSE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

6280

} VkToolPurposeFlagBits;

6281

typedef VkFlags VkToolPurposeFlags;

6282

typedef VkFlags VkPrivateDataSlotCreateFlags;

6283

typedef VkFlags64 VkPipelineStageFlags2;

6284

6285

// Flag bits for VkPipelineStageFlagBits2

6286

typedef VkFlags64 VkPipelineStageFlagBits2;

6287

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_NONE = 0ULL;

6288

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_NONE_KHR = 0ULL;

6289

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT = 0x00000001ULL;

6290

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR = 0x00000001ULL;

6291

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT = 0x00000002ULL;

6292

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR = 0x00000002ULL;

6293

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT = 0x00000004ULL;

6294

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR = 0x00000004ULL;

6295

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT = 0x00000008ULL;

6296

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT_KHR = 0x00000008ULL;

6297

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010ULL;

6298

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR = 0x00000010ULL;

6299

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020ULL;

6300

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR = 0x00000020ULL;

6301

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT = 0x00000040ULL;

6302

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR = 0x00000040ULL;

6303

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT = 0x00000080ULL;

6304

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR = 0x00000080ULL;

6305

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT = 0x00000100ULL;

6306

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR = 0x00000100ULL;

6307

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT = 0x00000200ULL;

6308

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR = 0x00000200ULL;

6309

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400ULL;

6310

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR = 0x00000400ULL;

6311

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT = 0x00000800ULL;

6312

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT_KHR = 0x00000800ULL;

6313

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT = 0x00001000ULL;

6314

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR = 0x00001000ULL;

6315

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TRANSFER_BIT = 0x00001000ULL;

6316

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR = 0x00001000ULL;

6317

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT = 0x00002000ULL;

6318

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT_KHR = 0x00002000ULL;

6319

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_HOST_BIT = 0x00004000ULL;

6320

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_HOST_BIT_KHR = 0x00004000ULL;

6321

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT = 0x00008000ULL;

6322

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR = 0x00008000ULL;

6323

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT = 0x00010000ULL;

6324

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR = 0x00010000ULL;

6325

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COPY_BIT = 0x100000000ULL;

6326

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COPY_BIT_KHR = 0x100000000ULL;

6327

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_RESOLVE_BIT = 0x200000000ULL;

6328

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR = 0x200000000ULL;

6329

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_BLIT_BIT = 0x400000000ULL;

6330

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_BLIT_BIT_KHR = 0x400000000ULL;

6331

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_CLEAR_BIT = 0x800000000ULL;

6332

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_CLEAR_BIT_KHR = 0x800000000ULL;

6333

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT = 0x1000000000ULL;

6334

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT_KHR = 0x1000000000ULL;

6335

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT = 0x2000000000ULL;

6336

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR = 0x2000000000ULL;

6337

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT = 0x4000000000ULL;

6338

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT_KHR = 0x4000000000ULL;

6339

#ifdef VK_ENABLE_BETA_EXTENSIONS

6340

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR = 0x04000000ULL;

6341

#endif

6342

#ifdef VK_ENABLE_BETA_EXTENSIONS

6343

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR = 0x08000000ULL;

6344

#endif

6345

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT = 0x01000000ULL;

6346

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT = 0x00040000ULL;

6347

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV = 0x00020000ULL;

6348

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00400000ULL;

6349

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV = 0x00400000ULL;

6350

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR = 0x02000000ULL;

6351

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR = 0x00200000ULL;

6352

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_NV = 0x00200000ULL;

6353

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_NV = 0x02000000ULL;

6354

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT = 0x00800000ULL;

6355

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV = 0x00080000ULL;

6356

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV = 0x00100000ULL;

6357

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI = 0x8000000000ULL;

6358

static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI = 0x10000000000ULL;

6359

6360

typedef VkFlags64 VkAccessFlags2;

6361

6362

// Flag bits for VkAccessFlagBits2

6363

typedef VkFlags64 VkAccessFlagBits2;

6364

static const VkAccessFlagBits2 VK_ACCESS_2_NONE = 0ULL;

6365

static const VkAccessFlagBits2 VK_ACCESS_2_NONE_KHR = 0ULL;

6366

static const VkAccessFlagBits2 VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT = 0x00000001ULL;

6367

static const VkAccessFlagBits2 VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR = 0x00000001ULL;

6368

static const VkAccessFlagBits2 VK_ACCESS_2_INDEX_READ_BIT = 0x00000002ULL;

6369

static const VkAccessFlagBits2 VK_ACCESS_2_INDEX_READ_BIT_KHR = 0x00000002ULL;

6370

static const VkAccessFlagBits2 VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004ULL;

6371

static const VkAccessFlagBits2 VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT_KHR = 0x00000004ULL;

6372

static const VkAccessFlagBits2 VK_ACCESS_2_UNIFORM_READ_BIT = 0x00000008ULL;

6373

static const VkAccessFlagBits2 VK_ACCESS_2_UNIFORM_READ_BIT_KHR = 0x00000008ULL;

6374

static const VkAccessFlagBits2 VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT = 0x00000010ULL;

6375

static const VkAccessFlagBits2 VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR = 0x00000010ULL;

6376

static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_READ_BIT = 0x00000020ULL;

6377

static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_READ_BIT_KHR = 0x00000020ULL;

6378

static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_WRITE_BIT = 0x00000040ULL;

6379

static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_WRITE_BIT_KHR = 0x00000040ULL;

6380

static const VkAccessFlagBits2 VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT = 0x00000080ULL;

6381

static const VkAccessFlagBits2 VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR = 0x00000080ULL;

6382

static const VkAccessFlagBits2 VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100ULL;

6383

static const VkAccessFlagBits2 VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR = 0x00000100ULL;

6384

static const VkAccessFlagBits2 VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200ULL;

6385

static const VkAccessFlagBits2 VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR = 0x00000200ULL;

6386

static const VkAccessFlagBits2 VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400ULL;

6387

static const VkAccessFlagBits2 VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR = 0x00000400ULL;

6388

static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFER_READ_BIT = 0x00000800ULL;

6389

static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFER_READ_BIT_KHR = 0x00000800ULL;

6390

static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFER_WRITE_BIT = 0x00001000ULL;

6391

static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR = 0x00001000ULL;

6392

static const VkAccessFlagBits2 VK_ACCESS_2_HOST_READ_BIT = 0x00002000ULL;

6393

static const VkAccessFlagBits2 VK_ACCESS_2_HOST_READ_BIT_KHR = 0x00002000ULL;

6394

static const VkAccessFlagBits2 VK_ACCESS_2_HOST_WRITE_BIT = 0x00004000ULL;

6395

static const VkAccessFlagBits2 VK_ACCESS_2_HOST_WRITE_BIT_KHR = 0x00004000ULL;

6396

static const VkAccessFlagBits2 VK_ACCESS_2_MEMORY_READ_BIT = 0x00008000ULL;

6397

static const VkAccessFlagBits2 VK_ACCESS_2_MEMORY_READ_BIT_KHR = 0x00008000ULL;

6398

static const VkAccessFlagBits2 VK_ACCESS_2_MEMORY_WRITE_BIT = 0x00010000ULL;

6399

static const VkAccessFlagBits2 VK_ACCESS_2_MEMORY_WRITE_BIT_KHR = 0x00010000ULL;

6400

static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_SAMPLED_READ_BIT = 0x100000000ULL;

6401

static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_SAMPLED_READ_BIT_KHR = 0x100000000ULL;

6402

static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_STORAGE_READ_BIT = 0x200000000ULL;

6403

static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR = 0x200000000ULL;

6404

static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT = 0x400000000ULL;

6405

static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR = 0x400000000ULL;

6406

#ifdef VK_ENABLE_BETA_EXTENSIONS

6407

static const VkAccessFlagBits2 VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR = 0x800000000ULL;

6408

#endif

6409

#ifdef VK_ENABLE_BETA_EXTENSIONS

6410

static const VkAccessFlagBits2 VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR = 0x1000000000ULL;

6411

#endif

6412

#ifdef VK_ENABLE_BETA_EXTENSIONS

6413

static const VkAccessFlagBits2 VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR = 0x2000000000ULL;

6414

#endif

6415

#ifdef VK_ENABLE_BETA_EXTENSIONS

6416

static const VkAccessFlagBits2 VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR = 0x4000000000ULL;

6417

#endif

6418

static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT = 0x02000000ULL;

6419

static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT = 0x04000000ULL;

6420

static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT = 0x08000000ULL;

6421

static const VkAccessFlagBits2 VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT = 0x00100000ULL;

6422

static const VkAccessFlagBits2 VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV = 0x00020000ULL;

6423

static const VkAccessFlagBits2 VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV = 0x00040000ULL;

6424

static const VkAccessFlagBits2 VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR = 0x00800000ULL;

6425

static const VkAccessFlagBits2 VK_ACCESS_2_SHADING_RATE_IMAGE_READ_BIT_NV = 0x00800000ULL;

6426

static const VkAccessFlagBits2 VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR = 0x00200000ULL;

6427

static const VkAccessFlagBits2 VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR = 0x00400000ULL;

6428

static const VkAccessFlagBits2 VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_NV = 0x00200000ULL;

6429

static const VkAccessFlagBits2 VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_NV = 0x00400000ULL;

6430

static const VkAccessFlagBits2 VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT = 0x01000000ULL;

6431

static const VkAccessFlagBits2 VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000ULL;

6432

static const VkAccessFlagBits2 VK_ACCESS_2_INVOCATION_MASK_READ_BIT_HUAWEI = 0x8000000000ULL;

6433

6434

6435

typedef enum VkSubmitFlagBits {

6436

VK_SUBMIT_PROTECTED_BIT = 0x00000001,

6437

VK_SUBMIT_PROTECTED_BIT_KHR = VK_SUBMIT_PROTECTED_BIT,

6438

VK_SUBMIT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

6439

} VkSubmitFlagBits;

6440

typedef VkFlags VkSubmitFlags;

6441

6442

typedef enum VkRenderingFlagBits {

6443

VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT = 0x00000001,

6444

VK_RENDERING_SUSPENDING_BIT = 0x00000002,

6445

VK_RENDERING_RESUMING_BIT = 0x00000004,

6446

VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR = VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT,

6447

VK_RENDERING_SUSPENDING_BIT_KHR = VK_RENDERING_SUSPENDING_BIT,

6448

VK_RENDERING_RESUMING_BIT_KHR = VK_RENDERING_RESUMING_BIT,

6449

VK_RENDERING_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF

6450

} VkRenderingFlagBits;

6451

typedef VkFlags VkRenderingFlags;

6452

typedef VkFlags64 VkFormatFeatureFlags2;

6453

6454

// Flag bits for VkFormatFeatureFlagBits2

6455

typedef VkFlags64 VkFormatFeatureFlagBits2;

6456

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT = 0x00000001ULL;

6457

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT_KHR = 0x00000001ULL;

6458

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT = 0x00000002ULL;

6459

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT_KHR = 0x00000002ULL;

6460

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004ULL;

6461

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT_KHR = 0x00000004ULL;

6462

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008ULL;

6463

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR = 0x00000008ULL;

6464

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT = 0x00000010ULL;

6465

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT_KHR = 0x00000010ULL;

6466

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020ULL;

6467

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT_KHR = 0x00000020ULL;

6468

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT = 0x00000040ULL;

6469

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT_KHR = 0x00000040ULL;

6470

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT = 0x00000080ULL;

6471

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT_KHR = 0x00000080ULL;

6472

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100ULL;

6473

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT_KHR = 0x00000100ULL;

6474

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200ULL;

6475

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT_KHR = 0x00000200ULL;

6476

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BLIT_SRC_BIT = 0x00000400ULL;

6477

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BLIT_SRC_BIT_KHR = 0x00000400ULL;

6478

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BLIT_DST_BIT = 0x00000800ULL;

6479

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BLIT_DST_BIT_KHR = 0x00000800ULL;

6480

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000ULL;

6481

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT_KHR = 0x00001000ULL;

6482

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT = 0x00002000ULL;

6483

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT = 0x00002000ULL;

6484

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT = 0x00004000ULL;

6485

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT_KHR = 0x00004000ULL;

6486

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT = 0x00008000ULL;

6487

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT_KHR = 0x00008000ULL;

6488

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT = 0x00010000ULL;

6489

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT_KHR = 0x00010000ULL;

6490

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT = 0x00020000ULL;

6491

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT_KHR = 0x00020000ULL;

6492

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT = 0x00040000ULL;

6493

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR = 0x00040000ULL;

6494

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT = 0x00080000ULL;

6495

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR = 0x00080000ULL;

6496

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT = 0x00100000ULL;

6497

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR = 0x00100000ULL;

6498

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT = 0x00200000ULL;

6499

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR = 0x00200000ULL;

6500

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DISJOINT_BIT = 0x00400000ULL;

6501

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DISJOINT_BIT_KHR = 0x00400000ULL;

6502

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT = 0x00800000ULL;

6503

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT_KHR = 0x00800000ULL;

6504

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT = 0x80000000ULL;

6505

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR = 0x80000000ULL;

6506

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT = 0x100000000ULL;

6507

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR = 0x100000000ULL;

6508

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT = 0x200000000ULL;

6509

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR = 0x200000000ULL;

6510

#ifdef VK_ENABLE_BETA_EXTENSIONS

6511

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_DECODE_OUTPUT_BIT_KHR = 0x02000000ULL;

6512

#endif

6513

#ifdef VK_ENABLE_BETA_EXTENSIONS

6514

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_DECODE_DPB_BIT_KHR = 0x04000000ULL;

6515

#endif

6516

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR = 0x20000000ULL;

6517

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x01000000ULL;

6518

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x40000000ULL;

6519

#ifdef VK_ENABLE_BETA_EXTENSIONS

6520

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR = 0x08000000ULL;

6521

#endif

6522

#ifdef VK_ENABLE_BETA_EXTENSIONS

6523

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR = 0x10000000ULL;

6524

#endif

6525

static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV = 0x4000000000ULL;

6526

6527

typedef struct VkPhysicalDeviceVulkan13Features {

6528

VkStructureType sType;

6529

void* pNext;

6530

VkBool32 robustImageAccess;

6531

VkBool32 inlineUniformBlock;

6532

VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind;

6533

VkBool32 pipelineCreationCacheControl;

6534

VkBool32 privateData;

6535

VkBool32 shaderDemoteToHelperInvocation;

6536

VkBool32 shaderTerminateInvocation;

6537

VkBool32 subgroupSizeControl;

6538

VkBool32 computeFullSubgroups;

6539

VkBool32 synchronization2;

6540

VkBool32 textureCompressionASTC_HDR;

6541

VkBool32 shaderZeroInitializeWorkgroupMemory;

6542

VkBool32 dynamicRendering;

6543

VkBool32 shaderIntegerDotProduct;

6544

VkBool32 maintenance4;

6545

} VkPhysicalDeviceVulkan13Features;

6546

6547

typedef struct VkPhysicalDeviceVulkan13Properties {

6548

VkStructureType sType;

6549

void* pNext;

6550

uint32_t minSubgroupSize;

6551

uint32_t maxSubgroupSize;

6552

uint32_t maxComputeWorkgroupSubgroups;

6553

VkShaderStageFlags requiredSubgroupSizeStages;

6554

uint32_t maxInlineUniformBlockSize;

6555

uint32_t maxPerStageDescriptorInlineUniformBlocks;

6556

uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;

6557

uint32_t maxDescriptorSetInlineUniformBlocks;

6558

uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks;

6559

uint32_t maxInlineUniformTotalSize;

6560

VkBool32 integerDotProduct8BitUnsignedAccelerated;

6561

VkBool32 integerDotProduct8BitSignedAccelerated;

6562

VkBool32 integerDotProduct8BitMixedSignednessAccelerated;

6563

VkBool32 integerDotProduct4x8BitPackedUnsignedAccelerated;

6564

VkBool32 integerDotProduct4x8BitPackedSignedAccelerated;

6565

VkBool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated;

6566

VkBool32 integerDotProduct16BitUnsignedAccelerated;

6567

VkBool32 integerDotProduct16BitSignedAccelerated;

6568

VkBool32 integerDotProduct16BitMixedSignednessAccelerated;

6569

VkBool32 integerDotProduct32BitUnsignedAccelerated;

6570

VkBool32 integerDotProduct32BitSignedAccelerated;

6571

VkBool32 integerDotProduct32BitMixedSignednessAccelerated;

6572

VkBool32 integerDotProduct64BitUnsignedAccelerated;

6573

VkBool32 integerDotProduct64BitSignedAccelerated;

6574

VkBool32 integerDotProduct64BitMixedSignednessAccelerated;

6575

VkBool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated;

6576

VkBool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated;

6577

VkBool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated;

6578

VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated;

6579

VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated;

6580

VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated;

6581

VkBool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated;

6582

VkBool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated;

6583

VkBool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated;

6584

VkBool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated;

6585

VkBool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated;

6586

VkBool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated;

6587

VkBool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated;

6588

VkBool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated;

6589

VkBool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated;

6590

VkDeviceSize storageTexelBufferOffsetAlignmentBytes;

6591

VkBool32 storageTexelBufferOffsetSingleTexelAlignment;

6592

VkDeviceSize uniformTexelBufferOffsetAlignmentBytes;

6593

VkBool32 uniformTexelBufferOffsetSingleTexelAlignment;

6594

VkDeviceSize maxBufferSize;

6595

} VkPhysicalDeviceVulkan13Properties;

6596

6597

typedef struct VkPipelineCreationFeedback {

6598

VkPipelineCreationFeedbackFlags flags;

6599

uint64_t duration;

6600

} VkPipelineCreationFeedback;

6601

6602

typedef struct VkPipelineCreationFeedbackCreateInfo {

6603

VkStructureType sType;

6604

const void* pNext;

6605

VkPipelineCreationFeedback* pPipelineCreationFeedback;

6606

uint32_t pipelineStageCreationFeedbackCount;

6607

VkPipelineCreationFeedback* pPipelineStageCreationFeedbacks;

6608

} VkPipelineCreationFeedbackCreateInfo;

6609

6610

typedef struct VkPhysicalDeviceShaderTerminateInvocationFeatures {

6611

VkStructureType sType;

6612

void* pNext;

6613

VkBool32 shaderTerminateInvocation;

6614

} VkPhysicalDeviceShaderTerminateInvocationFeatures;

6615

6616

typedef struct VkPhysicalDeviceToolProperties {

6617

VkStructureType sType;

6618

void* pNext;

6619

char name[VK_MAX_EXTENSION_NAME_SIZE];

6620

char version[VK_MAX_EXTENSION_NAME_SIZE];

6621

VkToolPurposeFlags purposes;

6622

char description[VK_MAX_DESCRIPTION_SIZE];

6623

char layer[VK_MAX_EXTENSION_NAME_SIZE];

6624

} VkPhysicalDeviceToolProperties;

6625

6626

typedef struct VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures {

6627

VkStructureType sType;

6628

void* pNext;

6629

VkBool32 shaderDemoteToHelperInvocation;

6630

} VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures;

6631

6632

typedef struct VkPhysicalDevicePrivateDataFeatures {

6633

VkStructureType sType;

6634

void* pNext;

6635

VkBool32 privateData;

6636

} VkPhysicalDevicePrivateDataFeatures;

6637

6638

typedef struct VkDevicePrivateDataCreateInfo {

6639

VkStructureType sType;

6640

const void* pNext;

6641

uint32_t privateDataSlotRequestCount;

6642

} VkDevicePrivateDataCreateInfo;

6643

6644

typedef struct VkPrivateDataSlotCreateInfo {

6645

VkStructureType sType;

6646

const void* pNext;

6647

VkPrivateDataSlotCreateFlags flags;

6648

} VkPrivateDataSlotCreateInfo;

6649

6650

typedef struct VkPhysicalDevicePipelineCreationCacheControlFeatures {

6651

VkStructureType sType;

6652

void* pNext;

6653

VkBool32 pipelineCreationCacheControl;

6654

} VkPhysicalDevicePipelineCreationCacheControlFeatures;

6655

6656

typedef struct VkMemoryBarrier2 {

6657

VkStructureType sType;

6658

const void* pNext;

6659

VkPipelineStageFlags2 srcStageMask;

6660

VkAccessFlags2 srcAccessMask;

6661

VkPipelineStageFlags2 dstStageMask;

6662

VkAccessFlags2 dstAccessMask;

6663

} VkMemoryBarrier2;

6664

6665

typedef struct VkBufferMemoryBarrier2 {

6666

VkStructureType sType;

6667

const void* pNext;

6668

VkPipelineStageFlags2 srcStageMask;

6669

VkAccessFlags2 srcAccessMask;

6670

VkPipelineStageFlags2 dstStageMask;

6671

VkAccessFlags2 dstAccessMask;

6672

uint32_t srcQueueFamilyIndex;

6673

uint32_t dstQueueFamilyIndex;

6674

VkBuffer buffer;

6675

VkDeviceSize offset;

6676

VkDeviceSize size;

6677

} VkBufferMemoryBarrier2;

6678

6679

typedef struct VkImageMemoryBarrier2 {

6680

VkStructureType sType;

6681

const void* pNext;

6682

VkPipelineStageFlags2 srcStageMask;

6683

VkAccessFlags2 srcAccessMask;

6684

VkPipelineStageFlags2 dstStageMask;

6685

VkAccessFlags2 dstAccessMask;

6686

VkImageLayout oldLayout;

6687

VkImageLayout newLayout;

6688

uint32_t srcQueueFamilyIndex;

6689

uint32_t dstQueueFamilyIndex;

6690

VkImage image;

6691

VkImageSubresourceRange subresourceRange;

6692

} VkImageMemoryBarrier2;

6693

6694

typedef struct VkDependencyInfo {

6695

VkStructureType sType;

6696

const void* pNext;

6697

VkDependencyFlags dependencyFlags;

6698

uint32_t memoryBarrierCount;

6699

const VkMemoryBarrier2* pMemoryBarriers;

6700

uint32_t bufferMemoryBarrierCount;

6701

const VkBufferMemoryBarrier2* pBufferMemoryBarriers;

6702

uint32_t imageMemoryBarrierCount;

6703

const VkImageMemoryBarrier2* pImageMemoryBarriers;

6704

} VkDependencyInfo;

6705

6706

typedef struct VkSemaphoreSubmitInfo {

6707

VkStructureType sType;

6708

const void* pNext;

6709

VkSemaphore semaphore;

6710

uint64_t value;

6711

VkPipelineStageFlags2 stageMask;

6712

uint32_t deviceIndex;

6713

} VkSemaphoreSubmitInfo;

6714

6715

typedef struct VkCommandBufferSubmitInfo {

6716

VkStructureType sType;

6717

const void* pNext;

6718

VkCommandBuffer commandBuffer;

6719

uint32_t deviceMask;

6720

} VkCommandBufferSubmitInfo;

6721

6722

typedef struct VkSubmitInfo2 {

6723

VkStructureType sType;

6724

const void* pNext;

6725

VkSubmitFlags flags;

6726

uint32_t waitSemaphoreInfoCount;

6727

const VkSemaphoreSubmitInfo* pWaitSemaphoreInfos;

6728

uint32_t commandBufferInfoCount;

6729

const VkCommandBufferSubmitInfo* pCommandBufferInfos;

6730

uint32_t signalSemaphoreInfoCount;

6731

const VkSemaphoreSubmitInfo* pSignalSemaphoreInfos;

6732

} VkSubmitInfo2;

6733

6734

typedef struct VkPhysicalDeviceSynchronization2Features {

6735

VkStructureType sType;

6736

void* pNext;

6737

VkBool32 synchronization2;

6738

} VkPhysicalDeviceSynchronization2Features;

6739

6740

typedef struct VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures {

6741

VkStructureType sType;

6742

void* pNext;

6743

VkBool32 shaderZeroInitializeWorkgroupMemory;

6744

} VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures;

6745

6746

typedef struct VkPhysicalDeviceImageRobustnessFeatures {

6747

VkStructureType sType;

6748

void* pNext;

6749

VkBool32 robustImageAccess;

6750

} VkPhysicalDeviceImageRobustnessFeatures;

6751

6752

typedef struct VkBufferCopy2 {

6753

VkStructureType sType;

6754

const void* pNext;

6755

VkDeviceSize srcOffset;

6756

VkDeviceSize dstOffset;

6757

VkDeviceSize size;

6758

} VkBufferCopy2;

6759

6760

typedef struct VkCopyBufferInfo2 {

6761

VkStructureType sType;

6762

const void* pNext;

6763

VkBuffer srcBuffer;

6764

VkBuffer dstBuffer;

6765

uint32_t regionCount;

6766

const VkBufferCopy2* pRegions;

6767

} VkCopyBufferInfo2;

6768

6769

typedef struct VkImageCopy2 {

6770

VkStructureType sType;

6771

const void* pNext;

6772

VkImageSubresourceLayers srcSubresource;

6773

VkOffset3D srcOffset;

6774

VkImageSubresourceLayers dstSubresource;

6775

VkOffset3D dstOffset;

6776

VkExtent3D extent;

6777

} VkImageCopy2;

6778

6779

typedef struct VkCopyImageInfo2 {

6780

VkStructureType sType;

6781

const void* pNext;

6782

VkImage srcImage;

6783

VkImageLayout srcImageLayout;

6784

VkImage dstImage;

6785

VkImageLayout dstImageLayout;

6786

uint32_t regionCount;

6787

const VkImageCopy2* pRegions;

6788

} VkCopyImageInfo2;

6789

6790

typedef struct VkBufferImageCopy2 {

6791

VkStructureType sType;

6792

const void* pNext;

6793

VkDeviceSize bufferOffset;

6794

uint32_t bufferRowLength;

6795

uint32_t bufferImageHeight;

6796

VkImageSubresourceLayers imageSubresource;

6797

VkOffset3D imageOffset;

6798

VkExtent3D imageExtent;

6799

} VkBufferImageCopy2;

6800

6801

typedef struct VkCopyBufferToImageInfo2 {

6802

VkStructureType sType;

6803

const void* pNext;

6804

VkBuffer srcBuffer;

6805

VkImage dstImage;

6806

VkImageLayout dstImageLayout;

6807

uint32_t regionCount;

6808

const VkBufferImageCopy2* pRegions;

6809

} VkCopyBufferToImageInfo2;

6810

6811

typedef struct VkCopyImageToBufferInfo2 {

6812

VkStructureType sType;

6813

const void* pNext;

6814

VkImage srcImage;

6815

VkImageLayout srcImageLayout;

6816

VkBuffer dstBuffer;

6817

uint32_t regionCount;

6818

const VkBufferImageCopy2* pRegions;

6819

} VkCopyImageToBufferInfo2;

6820

6821

typedef struct VkImageBlit2 {

6822

VkStructureType sType;

6823

const void* pNext;

6824

VkImageSubresourceLayers srcSubresource;

6825

VkOffset3D srcOffsets[2];

6826

VkImageSubresourceLayers dstSubresource;

6827

VkOffset3D dstOffsets[2];

6828

} VkImageBlit2;

6829

6830

typedef struct VkBlitImageInfo2 {

6831

VkStructureType sType;

6832

const void* pNext;

6833

VkImage srcImage;

6834

VkImageLayout srcImageLayout;

6835

VkImage dstImage;

6836

VkImageLayout dstImageLayout;

6837

uint32_t regionCount;

6838

const VkImageBlit2* pRegions;

6839

VkFilter filter;

6840

} VkBlitImageInfo2;

6841

6842

typedef struct VkImageResolve2 {

6843

VkStructureType sType;

6844

const void* pNext;

6845

VkImageSubresourceLayers srcSubresource;

6846

VkOffset3D srcOffset;

6847

VkImageSubresourceLayers dstSubresource;

6848

VkOffset3D dstOffset;

6849

VkExtent3D extent;

6850

} VkImageResolve2;

6851

6852

typedef struct VkResolveImageInfo2 {

6853

VkStructureType sType;

6854

const void* pNext;

6855

VkImage srcImage;

6856

VkImageLayout srcImageLayout;

6857

VkImage dstImage;

6858

VkImageLayout dstImageLayout;

6859

uint32_t regionCount;

6860

const VkImageResolve2* pRegions;

6861

} VkResolveImageInfo2;

6862

6863

typedef struct VkPhysicalDeviceSubgroupSizeControlFeatures {

6864

VkStructureType sType;

6865

void* pNext;

6866

VkBool32 subgroupSizeControl;

6867

VkBool32 computeFullSubgroups;

6868

} VkPhysicalDeviceSubgroupSizeControlFeatures;

6869

6870

typedef struct VkPhysicalDeviceSubgroupSizeControlProperties {

6871

VkStructureType sType;

6872

void* pNext;

6873

uint32_t minSubgroupSize;

6874

uint32_t maxSubgroupSize;

6875

uint32_t maxComputeWorkgroupSubgroups;

6876

VkShaderStageFlags requiredSubgroupSizeStages;

6877

} VkPhysicalDeviceSubgroupSizeControlProperties;

6878

6879

typedef struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfo {

6880

VkStructureType sType;

6881

void* pNext;

6882

uint32_t requiredSubgroupSize;

6883

} VkPipelineShaderStageRequiredSubgroupSizeCreateInfo;

6884

6885

typedef struct VkPhysicalDeviceInlineUniformBlockFeatures {

6886

VkStructureType sType;

6887

void* pNext;

6888

VkBool32 inlineUniformBlock;

6889

VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind;

6890

} VkPhysicalDeviceInlineUniformBlockFeatures;

6891

6892

typedef struct VkPhysicalDeviceInlineUniformBlockProperties {

6893

VkStructureType sType;

6894

void* pNext;

6895

uint32_t maxInlineUniformBlockSize;

6896

uint32_t maxPerStageDescriptorInlineUniformBlocks;

6897

uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;

6898

uint32_t maxDescriptorSetInlineUniformBlocks;

6899

uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks;

6900

} VkPhysicalDeviceInlineUniformBlockProperties;

6901

6902

typedef struct VkWriteDescriptorSetInlineUniformBlock {

6903

VkStructureType sType;

6904

const void* pNext;

6905

uint32_t dataSize;

6906

const void* pData;

6907

} VkWriteDescriptorSetInlineUniformBlock;

6908

6909

typedef struct VkDescriptorPoolInlineUniformBlockCreateInfo {

6910

VkStructureType sType;

6911

const void* pNext;

6912

uint32_t maxInlineUniformBlockBindings;

6913

} VkDescriptorPoolInlineUniformBlockCreateInfo;

6914

6915

typedef struct VkPhysicalDeviceTextureCompressionASTCHDRFeatures {

6916

VkStructureType sType;

6917

void* pNext;

6918

VkBool32 textureCompressionASTC_HDR;

6919

} VkPhysicalDeviceTextureCompressionASTCHDRFeatures;

6920

6921

typedef struct VkRenderingAttachmentInfo {

6922

VkStructureType sType;

6923

const void* pNext;

6924

VkImageView imageView;

6925

VkImageLayout imageLayout;

6926

VkResolveModeFlagBits resolveMode;

6927

VkImageView resolveImageView;

6928

VkImageLayout resolveImageLayout;

6929

VkAttachmentLoadOp loadOp;

6930

VkAttachmentStoreOp storeOp;

6931

VkClearValue clearValue;

6932

} VkRenderingAttachmentInfo;

6933

6934

typedef struct VkRenderingInfo {

6935

VkStructureType sType;

6936

const void* pNext;

6937

VkRenderingFlags flags;

6938

VkRect2D renderArea;

6939

uint32_t layerCount;

6940

uint32_t viewMask;

6941

uint32_t colorAttachmentCount;

6942

const VkRenderingAttachmentInfo* pColorAttachments;

6943

const VkRenderingAttachmentInfo* pDepthAttachment;

6944

const VkRenderingAttachmentInfo* pStencilAttachment;

6945

} VkRenderingInfo;

6946

6947

typedef struct VkPipelineRenderingCreateInfo {

6948

VkStructureType sType;

6949

const void* pNext;

6950

uint32_t viewMask;

6951

uint32_t colorAttachmentCount;

6952

const VkFormat* pColorAttachmentFormats;

6953

VkFormat depthAttachmentFormat;

6954

VkFormat stencilAttachmentFormat;

6955

} VkPipelineRenderingCreateInfo;

6956

6957

typedef struct VkPhysicalDeviceDynamicRenderingFeatures {

6958

VkStructureType sType;

6959

void* pNext;

6960

VkBool32 dynamicRendering;

6961

} VkPhysicalDeviceDynamicRenderingFeatures;

6962

6963

typedef struct VkCommandBufferInheritanceRenderingInfo {

6964

VkStructureType sType;

6965

const void* pNext;

6966

VkRenderingFlags flags;

6967

uint32_t viewMask;

6968

uint32_t colorAttachmentCount;

6969

const VkFormat* pColorAttachmentFormats;

6970

VkFormat depthAttachmentFormat;

6971

VkFormat stencilAttachmentFormat;

6972

VkSampleCountFlagBits rasterizationSamples;

6973

} VkCommandBufferInheritanceRenderingInfo;

6974

6975

typedef struct VkPhysicalDeviceShaderIntegerDotProductFeatures {

6976

VkStructureType sType;

6977

void* pNext;

6978

VkBool32 shaderIntegerDotProduct;

6979

} VkPhysicalDeviceShaderIntegerDotProductFeatures;

6980

6981

typedef struct VkPhysicalDeviceShaderIntegerDotProductProperties {

6982

VkStructureType sType;

6983

void* pNext;

6984

VkBool32 integerDotProduct8BitUnsignedAccelerated;

6985

VkBool32 integerDotProduct8BitSignedAccelerated;

6986

VkBool32 integerDotProduct8BitMixedSignednessAccelerated;

6987

VkBool32 integerDotProduct4x8BitPackedUnsignedAccelerated;

6988

VkBool32 integerDotProduct4x8BitPackedSignedAccelerated;

6989

VkBool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated;

6990

VkBool32 integerDotProduct16BitUnsignedAccelerated;

6991

VkBool32 integerDotProduct16BitSignedAccelerated;

6992

VkBool32 integerDotProduct16BitMixedSignednessAccelerated;

6993

VkBool32 integerDotProduct32BitUnsignedAccelerated;

6994

VkBool32 integerDotProduct32BitSignedAccelerated;

6995

VkBool32 integerDotProduct32BitMixedSignednessAccelerated;

6996

VkBool32 integerDotProduct64BitUnsignedAccelerated;

6997

VkBool32 integerDotProduct64BitSignedAccelerated;

6998

VkBool32 integerDotProduct64BitMixedSignednessAccelerated;

6999

VkBool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated;

7000

VkBool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated;

7001

VkBool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated;

7002

VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated;

7003

VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated;

7004

VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated;

7005

VkBool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated;

7006

VkBool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated;

7007

VkBool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated;

7008

VkBool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated;

7009

VkBool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated;

7010

VkBool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated;

7011

VkBool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated;

7012

VkBool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated;

7013

VkBool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated;

7014

} VkPhysicalDeviceShaderIntegerDotProductProperties;

7015

7016

typedef struct VkPhysicalDeviceTexelBufferAlignmentProperties {

7017

VkStructureType sType;

7018

void* pNext;

7019

VkDeviceSize storageTexelBufferOffsetAlignmentBytes;

7020

VkBool32 storageTexelBufferOffsetSingleTexelAlignment;

7021

VkDeviceSize uniformTexelBufferOffsetAlignmentBytes;

7022

VkBool32 uniformTexelBufferOffsetSingleTexelAlignment;

7023

} VkPhysicalDeviceTexelBufferAlignmentProperties;

7024

7025

typedef struct VkFormatProperties3 {

7026

VkStructureType sType;

7027

void* pNext;

7028

VkFormatFeatureFlags2 linearTilingFeatures;

7029

VkFormatFeatureFlags2 optimalTilingFeatures;

7030

VkFormatFeatureFlags2 bufferFeatures;

7031

} VkFormatProperties3;

7032

7033

typedef struct VkPhysicalDeviceMaintenance4Features {

7034

VkStructureType sType;

7035

void* pNext;

7036

VkBool32 maintenance4;

7037

} VkPhysicalDeviceMaintenance4Features;

7038

7039

typedef struct VkPhysicalDeviceMaintenance4Properties {

7040

VkStructureType sType;

7041

void* pNext;

7042

VkDeviceSize maxBufferSize;

7043

} VkPhysicalDeviceMaintenance4Properties;

7044

7045

typedef struct VkDeviceBufferMemoryRequirements {

7046

VkStructureType sType;

7047

const void* pNext;

7048

const VkBufferCreateInfo* pCreateInfo;

7049

} VkDeviceBufferMemoryRequirements;

7050

7051

typedef struct VkDeviceImageMemoryRequirements {

7052

VkStructureType sType;

7053

const void* pNext;

7054

const VkImageCreateInfo* pCreateInfo;

7055

VkImageAspectFlagBits planeAspect;

7056

} VkDeviceImageMemoryRequirements;

7057

7058

typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceToolProperties)(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties);

7059

typedef VkResult (VKAPI_PTR *PFN_vkCreatePrivateDataSlot)(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot);

7060

typedef void (VKAPI_PTR *PFN_vkDestroyPrivateDataSlot)(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator);

7061

typedef VkResult (VKAPI_PTR *PFN_vkSetPrivateData)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data);

7062

typedef void (VKAPI_PTR *PFN_vkGetPrivateData)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData);

7063

typedef void (VKAPI_PTR *PFN_vkCmdSetEvent2)(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo);

7064

typedef void (VKAPI_PTR *PFN_vkCmdResetEvent2)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask);

7065

typedef void (VKAPI_PTR *PFN_vkCmdWaitEvents2)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos);

7066

typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier2)(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo);

7067

typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp2)(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query);

7068

typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit2)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence);

7069

typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer2)(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo);

7070

typedef void (VKAPI_PTR *PFN_vkCmdCopyImage2)(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo);

7071

typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage2)(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo);

7072

typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer2)(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo);

7073

typedef void (VKAPI_PTR *PFN_vkCmdBlitImage2)(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo);

7074

typedef void (VKAPI_PTR *PFN_vkCmdResolveImage2)(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo);

7075

typedef void (VKAPI_PTR *PFN_vkCmdBeginRendering)(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo);

7076

typedef void (VKAPI_PTR *PFN_vkCmdEndRendering)(VkCommandBuffer commandBuffer);

7077

typedef void (VKAPI_PTR *PFN_vkCmdSetCullMode)(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode);

7078

typedef void (VKAPI_PTR *PFN_vkCmdSetFrontFace)(VkCommandBuffer commandBuffer, VkFrontFace frontFace);

7079

typedef void (VKAPI_PTR *PFN_vkCmdSetPrimitiveTopology)(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology);

7080

typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWithCount)(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports);

7081

typedef void (VKAPI_PTR *PFN_vkCmdSetScissorWithCount)(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors);

7082

typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers2)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides);

7083

typedef void (VKAPI_PTR *PFN_vkCmdSetDepthTestEnable)(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable);

7084

typedef void (VKAPI_PTR *PFN_vkCmdSetDepthWriteEnable)(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable);

7085

typedef void (VKAPI_PTR *PFN_vkCmdSetDepthCompareOp)(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp);

7086

typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBoundsTestEnable)(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable);

7087

typedef void (VKAPI_PTR *PFN_vkCmdSetStencilTestEnable)(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable);

7088

typedef void (VKAPI_PTR *PFN_vkCmdSetStencilOp)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp);

7089

typedef void (VKAPI_PTR *PFN_vkCmdSetRasterizerDiscardEnable)(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable);

7090

typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBiasEnable)(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable);

7091

typedef void (VKAPI_PTR *PFN_vkCmdSetPrimitiveRestartEnable)(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable);

7092

typedef void (VKAPI_PTR *PFN_vkGetDeviceBufferMemoryRequirements)(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements);

7093

typedef void (VKAPI_PTR *PFN_vkGetDeviceImageMemoryRequirements)(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements);

7094

typedef void (VKAPI_PTR *PFN_vkGetDeviceImageSparseMemoryRequirements)(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);

7095

7096

#ifndef VK_NO_PROTOTYPES

7097

VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceToolProperties(

7098

VkPhysicalDevice physicalDevice,

7099

uint32_t* pToolCount,

7100

VkPhysicalDeviceToolProperties* pToolProperties);

7101

7102

VKAPI_ATTR VkResult VKAPI_CALL vkCreatePrivateDataSlot(

7103

VkDevice device,

7104

const VkPrivateDataSlotCreateInfo* pCreateInfo,

7105

const VkAllocationCallbacks* pAllocator,

7106

VkPrivateDataSlot* pPrivateDataSlot);

7107

7108

VKAPI_ATTR void VKAPI_CALL vkDestroyPrivateDataSlot(

7109

VkDevice device,

7110

VkPrivateDataSlot privateDataSlot,

7111

const VkAllocationCallbacks* pAllocator);

7112

7113

VKAPI_ATTR VkResult VKAPI_CALL vkSetPrivateData(

7114

VkDevice device,

7115

VkObjectType objectType,

7116

uint64_t objectHandle,

7117

VkPrivateDataSlot privateDataSlot,

7118

uint64_t data);

7119

7120

VKAPI_ATTR void VKAPI_CALL vkGetPrivateData(

7121

VkDevice device,

7122

VkObjectType objectType,

7123

uint64_t objectHandle,

7124

VkPrivateDataSlot privateDataSlot,

7125

uint64_t* pData);

7126

7127

VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent2(

7128

VkCommandBuffer commandBuffer,

7129

VkEvent event,

7130

const VkDependencyInfo* pDependencyInfo);

7131

7132

VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent2(

7133

VkCommandBuffer commandBuffer,

7134

VkEvent event,

7135

VkPipelineStageFlags2 stageMask);

7136

7137

VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents2(

7138

VkCommandBuffer commandBuffer,

7139

uint32_t eventCount,

7140

const VkEvent* pEvents,

7141

const VkDependencyInfo* pDependencyInfos);

7142

7143

VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier2(

7144

VkCommandBuffer commandBuffer,

7145

const VkDependencyInfo* pDependencyInfo);

7146

7147

VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp2(

7148

VkCommandBuffer commandBuffer,

7149

VkPipelineStageFlags2 stage,

7150

VkQueryPool queryPool,

7151

uint32_t query);

7152

7153

VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit2(

7154

VkQueue queue,

7155

uint32_t submitCount,

7156

const VkSubmitInfo2* pSubmits,

7157

VkFence fence);

7158

7159

VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer2(

7160

VkCommandBuffer commandBuffer,

7161

const VkCopyBufferInfo2* pCopyBufferInfo);

7162

7163

VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage2(

7164

VkCommandBuffer commandBuffer,

7165

const VkCopyImageInfo2* pCopyImageInfo);

7166

7167

VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage2(

7168

VkCommandBuffer commandBuffer,

7169

const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo);

7170

7171

VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer2(

7172

VkCommandBuffer commandBuffer,

7173

const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo);

7174

7175

VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage2(

7176

VkCommandBuffer commandBuffer,

7177

const VkBlitImageInfo2* pBlitImageInfo);

7178

7179

VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage2(

7180

VkCommandBuffer commandBuffer,

7181

const VkResolveImageInfo2* pResolveImageInfo);

7182

7183

VKAPI_ATTR void VKAPI_CALL vkCmdBeginRendering(

7184

VkCommandBuffer commandBuffer,

7185

const VkRenderingInfo* pRenderingInfo);

7186

7187

VKAPI_ATTR void VKAPI_CALL vkCmdEndRendering(

7188

VkCommandBuffer commandBuffer);

7189

7190

VKAPI_ATTR void VKAPI_CALL vkCmdSetCullMode(

7191

VkCommandBuffer commandBuffer,

7192

VkCullModeFlags cullMode);

7193

7194

VKAPI_ATTR void VKAPI_CALL vkCmdSetFrontFace(

7195

VkCommandBuffer commandBuffer,

7196

VkFrontFace frontFace);

7197

7198

VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveTopology(

7199

VkCommandBuffer commandBuffer,

7200

VkPrimitiveTopology primitiveTopology);

7201

7202

VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWithCount(

7203

VkCommandBuffer commandBuffer,

7204

uint32_t viewportCount,

7205

const VkViewport* pViewports);

7206

7207

VKAPI_ATTR void VKAPI_CALL vkCmdSetScissorWithCount(

7208

VkCommandBuffer commandBuffer,

7209

uint32_t scissorCount,

7210

const VkRect2D* pScissors);

7211

7212

VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers2(

7213

VkCommandBuffer commandBuffer,

7214

uint32_t firstBinding,

7215

uint32_t bindingCount,

7216

const VkBuffer* pBuffers,

7217

const VkDeviceSize* pOffsets,

7218

const VkDeviceSize* pSizes,

7219

const VkDeviceSize* pStrides);

7220

7221

VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthTestEnable(

7222

VkCommandBuffer commandBuffer,

7223

VkBool32 depthTestEnable);

7224

7225

VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthWriteEnable(

7226

VkCommandBuffer commandBuffer,

7227

VkBool32 depthWriteEnable);

7228

7229

VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthCompareOp(

7230

VkCommandBuffer commandBuffer,

7231

VkCompareOp depthCompareOp);

7232

7233

VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBoundsTestEnable(

7234

VkCommandBuffer commandBuffer,

7235

VkBool32 depthBoundsTestEnable);

7236

7237

VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilTestEnable(

7238

VkCommandBuffer commandBuffer,

7239

VkBool32 stencilTestEnable);

7240

7241

VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilOp(

7242

VkCommandBuffer commandBuffer,

7243

VkStencilFaceFlags faceMask,

7244

VkStencilOp failOp,

7245

VkStencilOp passOp,

7246

VkStencilOp depthFailOp,

7247

VkCompareOp compareOp);

7248

7249

VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizerDiscardEnable(

7250

VkCommandBuffer commandBuffer,

7251

VkBool32 rasterizerDiscardEnable);

7252

7253

VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBiasEnable(

7254

VkCommandBuffer commandBuffer,

7255

VkBool32 depthBiasEnable);

7256

7257

VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveRestartEnable(

7258

VkCommandBuffer commandBuffer,

7259

VkBool32 primitiveRestartEnable);

7260

7261

VKAPI_ATTR void VKAPI_CALL vkGetDeviceBufferMemoryRequirements(

7262

VkDevice device,

7263

const VkDeviceBufferMemoryRequirements* pInfo,

7264

VkMemoryRequirements2* pMemoryRequirements);

7265

7266

VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageMemoryRequirements(

7267

VkDevice device,

7268

const VkDeviceImageMemoryRequirements* pInfo,

7269

VkMemoryRequirements2* pMemoryRequirements);

7270

7271

VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageSparseMemoryRequirements(

7272

VkDevice device,

7273

const VkDeviceImageMemoryRequirements* pInfo,

7274

uint32_t* pSparseMemoryRequirementCount,

7275

VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);

7276

#endif

7277

7278

7279

#define VK_KHR_surface 1

7280

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR)

7281

#define VK_KHR_SURFACE_SPEC_VERSION 25

7282

#define VK_KHR_SURFACE_EXTENSION_NAME "VK_KHR_surface"

7283

7284

typedef enum VkPresentModeKHR {

7285

VK_PRESENT_MODE_IMMEDIATE_KHR = 0,

7286

VK_PRESENT_MODE_MAILBOX_KHR = 1,

7287

VK_PRESENT_MODE_FIFO_KHR = 2,

7288

VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3,

7289

VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR = 1000111000,

7290

VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR = 1000111001,

7291

VK_PRESENT_MODE_MAX_ENUM_KHR = 0x7FFFFFFF

7292

} VkPresentModeKHR;

7293

7294

typedef enum VkColorSpaceKHR {

7295

VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = 0,

7296

VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT = 1000104001,

7297

VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT = 1000104002,

7298

VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT = 1000104003,

7299

VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT = 1000104004,

7300

VK_COLOR_SPACE_BT709_LINEAR_EXT = 1000104005,

7301

VK_COLOR_SPACE_BT709_NONLINEAR_EXT = 1000104006,

7302

VK_COLOR_SPACE_BT2020_LINEAR_EXT = 1000104007,

7303

VK_COLOR_SPACE_HDR10_ST2084_EXT = 1000104008,

7304

VK_COLOR_SPACE_DOLBYVISION_EXT = 1000104009,

7305

VK_COLOR_SPACE_HDR10_HLG_EXT = 1000104010,

7306

VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT = 1000104011,

7307

VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT = 1000104012,

7308

VK_COLOR_SPACE_PASS_THROUGH_EXT = 1000104013,

7309

VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT = 1000104014,

7310

VK_COLOR_SPACE_DISPLAY_NATIVE_AMD = 1000213000,

7311

VK_COLORSPACE_SRGB_NONLINEAR_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR,

7312

VK_COLOR_SPACE_DCI_P3_LINEAR_EXT = VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT,

7313

VK_COLOR_SPACE_MAX_ENUM_KHR = 0x7FFFFFFF

7314

} VkColorSpaceKHR;

7315

7316

typedef enum VkSurfaceTransformFlagBitsKHR {

7317

VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 0x00000001,

7318

VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 0x00000002,

7319

VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 0x00000004,

7320

VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 0x00000008,

7321

VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 0x00000010,

7322

VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 0x00000020,

7323

VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 0x00000040,

7324

VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 0x00000080,

7325

VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100,

7326

VK_SURFACE_TRANSFORM_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF

7327

} VkSurfaceTransformFlagBitsKHR;

7328

7329

typedef enum VkCompositeAlphaFlagBitsKHR {

7330

VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0x00000001,

7331

VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0x00000002,

7332

VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 0x00000004,

7333

VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 0x00000008,

7334

VK_COMPOSITE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF

7335

} VkCompositeAlphaFlagBitsKHR;

7336

typedef VkFlags VkCompositeAlphaFlagsKHR;

7337

typedef VkFlags VkSurfaceTransformFlagsKHR;

7338

typedef struct VkSurfaceCapabilitiesKHR {

7339

uint32_t minImageCount;

7340

uint32_t maxImageCount;

7341

VkExtent2D currentExtent;

7342

VkExtent2D minImageExtent;

7343

VkExtent2D maxImageExtent;

7344

uint32_t maxImageArrayLayers;

7345

VkSurfaceTransformFlagsKHR supportedTransforms;

7346

VkSurfaceTransformFlagBitsKHR currentTransform;

7347

VkCompositeAlphaFlagsKHR supportedCompositeAlpha;

7348

VkImageUsageFlags supportedUsageFlags;

7349

} VkSurfaceCapabilitiesKHR;

7350

7351

typedef struct VkSurfaceFormatKHR {

7352

VkFormat format;

7353

VkColorSpaceKHR colorSpace;

7354

} VkSurfaceFormatKHR;

7355

7356

typedef void (VKAPI_PTR *PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator);

7357

typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported);

7358

typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities);

7359

typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats);

7360

typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes);

7361

7362

#ifndef VK_NO_PROTOTYPES

7363

VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR(

7364

VkInstance instance,

7365

VkSurfaceKHR surface,

7366

const VkAllocationCallbacks* pAllocator);

7367

7368

VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR(

7369

VkPhysicalDevice physicalDevice,

7370

uint32_t queueFamilyIndex,

7371

VkSurfaceKHR surface,

7372

VkBool32* pSupported);

7373

7374

VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR(

7375

VkPhysicalDevice physicalDevice,

7376

VkSurfaceKHR surface,

7377

VkSurfaceCapabilitiesKHR* pSurfaceCapabilities);

7378

7379

VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR(

7380

VkPhysicalDevice physicalDevice,

7381

VkSurfaceKHR surface,

7382

uint32_t* pSurfaceFormatCount,

7383

VkSurfaceFormatKHR* pSurfaceFormats);

7384

7385

VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR(

7386

VkPhysicalDevice physicalDevice,

7387

VkSurfaceKHR surface,

7388

uint32_t* pPresentModeCount,

7389

VkPresentModeKHR* pPresentModes);

7390

#endif

7391

7392

7393

#define VK_KHR_swapchain 1

7394

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR)

7395

#define VK_KHR_SWAPCHAIN_SPEC_VERSION 70

7396

#define VK_KHR_SWAPCHAIN_EXTENSION_NAME "VK_KHR_swapchain"

7397

7398

typedef enum VkSwapchainCreateFlagBitsKHR {

7399

VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = 0x00000001,

7400

VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR = 0x00000002,

7401

VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR = 0x00000004,

7402

VK_SWAPCHAIN_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF

7403

} VkSwapchainCreateFlagBitsKHR;

7404

typedef VkFlags VkSwapchainCreateFlagsKHR;

7405

7406

typedef enum VkDeviceGroupPresentModeFlagBitsKHR {

7407

VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR = 0x00000001,

7408

VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR = 0x00000002,

7409

VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR = 0x00000004,

7410

VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR = 0x00000008,

7411

VK_DEVICE_GROUP_PRESENT_MODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF

7412

} VkDeviceGroupPresentModeFlagBitsKHR;

7413

typedef VkFlags VkDeviceGroupPresentModeFlagsKHR;

7414

typedef struct VkSwapchainCreateInfoKHR {

7415

VkStructureType sType;

7416

const void* pNext;

7417

VkSwapchainCreateFlagsKHR flags;

7418

VkSurfaceKHR surface;

7419

uint32_t minImageCount;

7420

VkFormat imageFormat;

7421

VkColorSpaceKHR imageColorSpace;

7422

VkExtent2D imageExtent;

7423

uint32_t imageArrayLayers;

7424

VkImageUsageFlags imageUsage;

7425

VkSharingMode imageSharingMode;

7426

uint32_t queueFamilyIndexCount;

7427

const uint32_t* pQueueFamilyIndices;

7428

VkSurfaceTransformFlagBitsKHR preTransform;

7429

VkCompositeAlphaFlagBitsKHR compositeAlpha;

7430

VkPresentModeKHR presentMode;

7431

VkBool32 clipped;

7432

VkSwapchainKHR oldSwapchain;

7433

} VkSwapchainCreateInfoKHR;

7434

7435

typedef struct VkPresentInfoKHR {

7436

VkStructureType sType;

7437

const void* pNext;

7438

uint32_t waitSemaphoreCount;

7439

const VkSemaphore* pWaitSemaphores;

7440

uint32_t swapchainCount;

7441

const VkSwapchainKHR* pSwapchains;

7442

const uint32_t* pImageIndices;

7443

VkResult* pResults;

7444

} VkPresentInfoKHR;

7445

7446

typedef struct VkImageSwapchainCreateInfoKHR {

7447

VkStructureType sType;

7448

const void* pNext;

7449

VkSwapchainKHR swapchain;

7450

} VkImageSwapchainCreateInfoKHR;

7451

7452

typedef struct VkBindImageMemorySwapchainInfoKHR {

7453

VkStructureType sType;

7454

const void* pNext;

7455

VkSwapchainKHR swapchain;

7456

uint32_t imageIndex;

7457

} VkBindImageMemorySwapchainInfoKHR;

7458

7459

typedef struct VkAcquireNextImageInfoKHR {

7460

VkStructureType sType;

7461

const void* pNext;

7462

VkSwapchainKHR swapchain;

7463

uint64_t timeout;

7464

VkSemaphore semaphore;

7465

VkFence fence;

7466

uint32_t deviceMask;

7467

} VkAcquireNextImageInfoKHR;

7468

7469

typedef struct VkDeviceGroupPresentCapabilitiesKHR {

7470

VkStructureType sType;

7471

void* pNext;

7472

uint32_t presentMask[VK_MAX_DEVICE_GROUP_SIZE];

7473

VkDeviceGroupPresentModeFlagsKHR modes;

7474

} VkDeviceGroupPresentCapabilitiesKHR;

7475

7476

typedef struct VkDeviceGroupPresentInfoKHR {

7477

VkStructureType sType;

7478

const void* pNext;

7479

uint32_t swapchainCount;

7480

const uint32_t* pDeviceMasks;

7481

VkDeviceGroupPresentModeFlagBitsKHR mode;

7482

} VkDeviceGroupPresentInfoKHR;

7483

7484

typedef struct VkDeviceGroupSwapchainCreateInfoKHR {

7485

VkStructureType sType;

7486

const void* pNext;

7487

VkDeviceGroupPresentModeFlagsKHR modes;

7488

} VkDeviceGroupSwapchainCreateInfoKHR;

7489

7490

typedef VkResult (VKAPI_PTR *PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain);

7491

typedef void (VKAPI_PTR *PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator);

7492

typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages);

7493

typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex);

7494

typedef VkResult (VKAPI_PTR *PFN_vkQueuePresentKHR)(VkQueue queue, const VkPresentInfoKHR* pPresentInfo);

7495

typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupPresentCapabilitiesKHR)(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities);

7496

typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceGroupSurfacePresentModesKHR)(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes);

7497

typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDevicePresentRectanglesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects);

7498

typedef VkResult (VKAPI_PTR *PFN_vkAcquireNextImage2KHR)(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex);

7499

7500

#ifndef VK_NO_PROTOTYPES

7501

VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR(

7502

VkDevice device,

7503

const VkSwapchainCreateInfoKHR* pCreateInfo,

7504

const VkAllocationCallbacks* pAllocator,

7505

VkSwapchainKHR* pSwapchain);

7506

7507

VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR(

7508

VkDevice device,

7509

VkSwapchainKHR swapchain,

7510

const VkAllocationCallbacks* pAllocator);

7511

7512

VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR(

7513

VkDevice device,

7514

VkSwapchainKHR swapchain,

7515

uint32_t* pSwapchainImageCount,

7516

VkImage* pSwapchainImages);

7517

7518

VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR(

7519

VkDevice device,

7520

VkSwapchainKHR swapchain,

7521

uint64_t timeout,

7522

VkSemaphore semaphore,

7523

VkFence fence,

7524

uint32_t* pImageIndex);

7525

7526

VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR(

7527

VkQueue queue,

7528

const VkPresentInfoKHR* pPresentInfo);

7529

7530

VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupPresentCapabilitiesKHR(

7531

VkDevice device,

7532

VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities);

7533

7534

VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModesKHR(

7535

VkDevice device,

7536

VkSurfaceKHR surface,

7537

VkDeviceGroupPresentModeFlagsKHR* pModes);

7538

7539

VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDevicePresentRectanglesKHR(

7540

VkPhysicalDevice physicalDevice,

7541

VkSurfaceKHR surface,

7542

uint32_t* pRectCount,

7543

VkRect2D* pRects);

7544

7545

VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImage2KHR(

7546

VkDevice device,

7547

const VkAcquireNextImageInfoKHR* pAcquireInfo,

7548

uint32_t* pImageIndex);

7549

#endif

7550

7551

7552

#define VK_KHR_display 1

7553

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR)

7554

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR)

7555

#define VK_KHR_DISPLAY_SPEC_VERSION 23

7556

#define VK_KHR_DISPLAY_EXTENSION_NAME "VK_KHR_display"

7557

typedef VkFlags VkDisplayModeCreateFlagsKHR;

7558

7559

typedef enum VkDisplayPlaneAlphaFlagBitsKHR {

7560

VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 0x00000001,

7561

VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000002,

7562

VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000004,

7563

VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000008,

7564

VK_DISPLAY_PLANE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF

7565

} VkDisplayPlaneAlphaFlagBitsKHR;

7566

typedef VkFlags VkDisplayPlaneAlphaFlagsKHR;

7567

typedef VkFlags VkDisplaySurfaceCreateFlagsKHR;

7568

typedef struct VkDisplayModeParametersKHR {

7569

VkExtent2D visibleRegion;

7570

uint32_t refreshRate;

7571

} VkDisplayModeParametersKHR;

7572

7573

typedef struct VkDisplayModeCreateInfoKHR {

7574

VkStructureType sType;

7575

const void* pNext;

7576

VkDisplayModeCreateFlagsKHR flags;

7577

VkDisplayModeParametersKHR parameters;

7578

} VkDisplayModeCreateInfoKHR;

7579

7580

typedef struct VkDisplayModePropertiesKHR {

7581

VkDisplayModeKHR displayMode;

7582

VkDisplayModeParametersKHR parameters;

7583

} VkDisplayModePropertiesKHR;

7584

7585

typedef struct VkDisplayPlaneCapabilitiesKHR {

7586

VkDisplayPlaneAlphaFlagsKHR supportedAlpha;

7587

VkOffset2D minSrcPosition;

7588

VkOffset2D maxSrcPosition;

7589

VkExtent2D minSrcExtent;

7590

VkExtent2D maxSrcExtent;

7591

VkOffset2D minDstPosition;

7592

VkOffset2D maxDstPosition;

7593

VkExtent2D minDstExtent;

7594

VkExtent2D maxDstExtent;

7595

} VkDisplayPlaneCapabilitiesKHR;

7596

7597

typedef struct VkDisplayPlanePropertiesKHR {

7598

VkDisplayKHR currentDisplay;

7599

uint32_t currentStackIndex;

7600

} VkDisplayPlanePropertiesKHR;

7601

7602

typedef struct VkDisplayPropertiesKHR {

7603

VkDisplayKHR display;

7604

const char* displayName;

7605

VkExtent2D physicalDimensions;

7606

VkExtent2D physicalResolution;

7607

VkSurfaceTransformFlagsKHR supportedTransforms;

7608

VkBool32 planeReorderPossible;

7609

VkBool32 persistentContent;

7610

} VkDisplayPropertiesKHR;

7611

7612

typedef struct VkDisplaySurfaceCreateInfoKHR {

7613

VkStructureType sType;

7614

const void* pNext;

7615

VkDisplaySurfaceCreateFlagsKHR flags;

7616

VkDisplayModeKHR displayMode;

7617

uint32_t planeIndex;

7618

uint32_t planeStackIndex;

7619

VkSurfaceTransformFlagBitsKHR transform;

7620

float globalAlpha;

7621

VkDisplayPlaneAlphaFlagBitsKHR alphaMode;

7622

VkExtent2D imageExtent;

7623

} VkDisplaySurfaceCreateInfoKHR;

7624

7625

typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties);

7626

typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties);

7627

typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays);

7628

typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties);

7629

typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode);

7630

typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities);

7631

typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);

7632

7633

#ifndef VK_NO_PROTOTYPES

7634

VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR(

7635

VkPhysicalDevice physicalDevice,

7636

uint32_t* pPropertyCount,

7637

VkDisplayPropertiesKHR* pProperties);

7638

7639

VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlanePropertiesKHR(

7640

VkPhysicalDevice physicalDevice,

7641

uint32_t* pPropertyCount,

7642

VkDisplayPlanePropertiesKHR* pProperties);

7643

7644

VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneSupportedDisplaysKHR(

7645

VkPhysicalDevice physicalDevice,

7646

uint32_t planeIndex,

7647

uint32_t* pDisplayCount,

7648

VkDisplayKHR* pDisplays);

7649

7650

VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR(

7651

VkPhysicalDevice physicalDevice,

7652

VkDisplayKHR display,

7653

uint32_t* pPropertyCount,

7654

VkDisplayModePropertiesKHR* pProperties);

7655

7656

VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR(

7657

VkPhysicalDevice physicalDevice,

7658

VkDisplayKHR display,

7659

const VkDisplayModeCreateInfoKHR* pCreateInfo,

7660

const VkAllocationCallbacks* pAllocator,

7661

VkDisplayModeKHR* pMode);

7662

7663

VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR(

7664

VkPhysicalDevice physicalDevice,

7665

VkDisplayModeKHR mode,

7666

uint32_t planeIndex,

7667

VkDisplayPlaneCapabilitiesKHR* pCapabilities);

7668

7669

VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR(

7670

VkInstance instance,

7671

const VkDisplaySurfaceCreateInfoKHR* pCreateInfo,

7672

const VkAllocationCallbacks* pAllocator,

7673

VkSurfaceKHR* pSurface);

7674

#endif

7675

7676

7677

#define VK_KHR_display_swapchain 1

7678

#define VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION 10

7679

#define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_KHR_display_swapchain"

7680

typedef struct VkDisplayPresentInfoKHR {

7681

VkStructureType sType;

7682

const void* pNext;

7683

VkRect2D srcRect;

7684

VkRect2D dstRect;

7685

VkBool32 persistent;

7686

} VkDisplayPresentInfoKHR;

7687

7688

typedef VkResult (VKAPI_PTR *PFN_vkCreateSharedSwapchainsKHR)(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains);

7689

7690

#ifndef VK_NO_PROTOTYPES

7691

VKAPI_ATTR VkResult VKAPI_CALL vkCreateSharedSwapchainsKHR(

7692

VkDevice device,

7693

uint32_t swapchainCount,

7694

const VkSwapchainCreateInfoKHR* pCreateInfos,

7695

const VkAllocationCallbacks* pAllocator,

7696

VkSwapchainKHR* pSwapchains);

7697

#endif

7698

7699

7700

#define VK_KHR_sampler_mirror_clamp_to_edge 1

7701

#define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION 3

7702

#define VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME "VK_KHR_sampler_mirror_clamp_to_edge"

7703

7704

7705

#define VK_KHR_dynamic_rendering 1

7706

#define VK_KHR_DYNAMIC_RENDERING_SPEC_VERSION 1

7707

#define VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME "VK_KHR_dynamic_rendering"

7708

typedef VkRenderingFlags VkRenderingFlagsKHR;

7709

7710

typedef VkRenderingFlagBits VkRenderingFlagBitsKHR;

7711

7712

typedef VkRenderingInfo VkRenderingInfoKHR;

7713

7714

typedef VkRenderingAttachmentInfo VkRenderingAttachmentInfoKHR;

7715

7716

typedef VkPipelineRenderingCreateInfo VkPipelineRenderingCreateInfoKHR;

7717

7718

typedef VkPhysicalDeviceDynamicRenderingFeatures VkPhysicalDeviceDynamicRenderingFeaturesKHR;

7719

7720

typedef VkCommandBufferInheritanceRenderingInfo VkCommandBufferInheritanceRenderingInfoKHR;

7721

7722

typedef struct VkRenderingFragmentShadingRateAttachmentInfoKHR {

7723

VkStructureType sType;

7724

const void* pNext;

7725

VkImageView imageView;

7726

VkImageLayout imageLayout;

7727

VkExtent2D shadingRateAttachmentTexelSize;

7728

} VkRenderingFragmentShadingRateAttachmentInfoKHR;

7729

7730

typedef struct VkRenderingFragmentDensityMapAttachmentInfoEXT {

7731

VkStructureType sType;

7732

const void* pNext;

7733

VkImageView imageView;

7734

VkImageLayout imageLayout;

7735

} VkRenderingFragmentDensityMapAttachmentInfoEXT;

7736

7737

typedef struct VkAttachmentSampleCountInfoAMD {

7738

VkStructureType sType;

7739

const void* pNext;

7740

uint32_t colorAttachmentCount;

7741

const VkSampleCountFlagBits* pColorAttachmentSamples;

7742

VkSampleCountFlagBits depthStencilAttachmentSamples;

7743

} VkAttachmentSampleCountInfoAMD;

7744

7745

typedef VkAttachmentSampleCountInfoAMD VkAttachmentSampleCountInfoNV;

7746

7747

typedef struct VkMultiviewPerViewAttributesInfoNVX {

7748

VkStructureType sType;

7749

const void* pNext;

7750

VkBool32 perViewAttributes;

7751

VkBool32 perViewAttributesPositionXOnly;

7752

} VkMultiviewPerViewAttributesInfoNVX;

7753

7754

typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderingKHR)(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo);

7755

typedef void (VKAPI_PTR *PFN_vkCmdEndRenderingKHR)(VkCommandBuffer commandBuffer);

7756

7757

#ifndef VK_NO_PROTOTYPES

7758

VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderingKHR(

7759

VkCommandBuffer commandBuffer,

7760

const VkRenderingInfo* pRenderingInfo);

7761

7762

VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderingKHR(

7763

VkCommandBuffer commandBuffer);

7764

#endif

7765

7766

7767

#define VK_KHR_multiview 1

7768

#define VK_KHR_MULTIVIEW_SPEC_VERSION 1

7769

#define VK_KHR_MULTIVIEW_EXTENSION_NAME "VK_KHR_multiview"

7770

typedef VkRenderPassMultiviewCreateInfo VkRenderPassMultiviewCreateInfoKHR;

7771

7772

typedef VkPhysicalDeviceMultiviewFeatures VkPhysicalDeviceMultiviewFeaturesKHR;

7773

7774

typedef VkPhysicalDeviceMultiviewProperties VkPhysicalDeviceMultiviewPropertiesKHR;

7775

7776

7777

7778

#define VK_KHR_get_physical_device_properties2 1

7779

#define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION 2

7780

#define VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_physical_device_properties2"

7781

typedef VkPhysicalDeviceFeatures2 VkPhysicalDeviceFeatures2KHR;

7782

7783

typedef VkPhysicalDeviceProperties2 VkPhysicalDeviceProperties2KHR;

7784

7785

typedef VkFormatProperties2 VkFormatProperties2KHR;

7786

7787

typedef VkImageFormatProperties2 VkImageFormatProperties2KHR;

7788

7789

typedef VkPhysicalDeviceImageFormatInfo2 VkPhysicalDeviceImageFormatInfo2KHR;

7790

7791

typedef VkQueueFamilyProperties2 VkQueueFamilyProperties2KHR;

7792

7793

typedef VkPhysicalDeviceMemoryProperties2 VkPhysicalDeviceMemoryProperties2KHR;

7794

7795

typedef VkSparseImageFormatProperties2 VkSparseImageFormatProperties2KHR;

7796

7797

typedef VkPhysicalDeviceSparseImageFormatInfo2 VkPhysicalDeviceSparseImageFormatInfo2KHR;

7798

7799

typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures);

7800

typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties);

7801

typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties2KHR)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties);

7802

typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties);

7803

typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties);

7804

typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties);

7805

typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties);

7806

7807

#ifndef VK_NO_PROTOTYPES

7808

VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2KHR(

7809

VkPhysicalDevice physicalDevice,

7810

VkPhysicalDeviceFeatures2* pFeatures);

7811

7812

VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2KHR(

7813

VkPhysicalDevice physicalDevice,

7814

VkPhysicalDeviceProperties2* pProperties);

7815

7816

VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2KHR(

7817

VkPhysicalDevice physicalDevice,

7818

VkFormat format,

7819

VkFormatProperties2* pFormatProperties);

7820

7821

VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2KHR(

7822

VkPhysicalDevice physicalDevice,

7823

const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo,

7824

VkImageFormatProperties2* pImageFormatProperties);

7825

7826

VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2KHR(

7827

VkPhysicalDevice physicalDevice,

7828

uint32_t* pQueueFamilyPropertyCount,

7829

VkQueueFamilyProperties2* pQueueFamilyProperties);

7830

7831

VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2KHR(

7832

VkPhysicalDevice physicalDevice,

7833

VkPhysicalDeviceMemoryProperties2* pMemoryProperties);

7834

7835

VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2KHR(

7836

VkPhysicalDevice physicalDevice,

7837

const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,

7838

uint32_t* pPropertyCount,

7839

VkSparseImageFormatProperties2* pProperties);

7840

#endif

7841

7842

7843

#define VK_KHR_device_group 1

7844

#define VK_KHR_DEVICE_GROUP_SPEC_VERSION 4

7845

#define VK_KHR_DEVICE_GROUP_EXTENSION_NAME "VK_KHR_device_group"

7846

typedef VkPeerMemoryFeatureFlags VkPeerMemoryFeatureFlagsKHR;

7847

7848

typedef VkPeerMemoryFeatureFlagBits VkPeerMemoryFeatureFlagBitsKHR;

7849

7850

typedef VkMemoryAllocateFlags VkMemoryAllocateFlagsKHR;

7851

7852

typedef VkMemoryAllocateFlagBits VkMemoryAllocateFlagBitsKHR;

7853

7854

typedef VkMemoryAllocateFlagsInfo VkMemoryAllocateFlagsInfoKHR;

7855

7856

typedef VkDeviceGroupRenderPassBeginInfo VkDeviceGroupRenderPassBeginInfoKHR;

7857

7858

typedef VkDeviceGroupCommandBufferBeginInfo VkDeviceGroupCommandBufferBeginInfoKHR;

7859

7860

typedef VkDeviceGroupSubmitInfo VkDeviceGroupSubmitInfoKHR;

7861

7862

typedef VkDeviceGroupBindSparseInfo VkDeviceGroupBindSparseInfoKHR;

7863

7864

typedef VkBindBufferMemoryDeviceGroupInfo VkBindBufferMemoryDeviceGroupInfoKHR;

7865

7866

typedef VkBindImageMemoryDeviceGroupInfo VkBindImageMemoryDeviceGroupInfoKHR;

7867

7868

typedef void (VKAPI_PTR *PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);

7869

typedef void (VKAPI_PTR *PFN_vkCmdSetDeviceMaskKHR)(VkCommandBuffer commandBuffer, uint32_t deviceMask);

7870

typedef void (VKAPI_PTR *PFN_vkCmdDispatchBaseKHR)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ);

7871

7872

#ifndef VK_NO_PROTOTYPES

7873

VKAPI_ATTR void VKAPI_CALL vkGetDeviceGroupPeerMemoryFeaturesKHR(

7874

VkDevice device,

7875

uint32_t heapIndex,

7876

uint32_t localDeviceIndex,

7877

uint32_t remoteDeviceIndex,

7878

VkPeerMemoryFeatureFlags* pPeerMemoryFeatures);

7879

7880

VKAPI_ATTR void VKAPI_CALL vkCmdSetDeviceMaskKHR(

7881

VkCommandBuffer commandBuffer,

7882

uint32_t deviceMask);

7883

7884

VKAPI_ATTR void VKAPI_CALL vkCmdDispatchBaseKHR(

7885

VkCommandBuffer commandBuffer,

7886

uint32_t baseGroupX,

7887

uint32_t baseGroupY,

7888

uint32_t baseGroupZ,

7889

uint32_t groupCountX,

7890

uint32_t groupCountY,

7891

uint32_t groupCountZ);

7892

#endif

7893

7894

7895

#define VK_KHR_shader_draw_parameters 1

7896

#define VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION 1

7897

#define VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME "VK_KHR_shader_draw_parameters"

7898

7899

7900

#define VK_KHR_maintenance1 1

7901

#define VK_KHR_MAINTENANCE_1_SPEC_VERSION 2

7902

#define VK_KHR_MAINTENANCE_1_EXTENSION_NAME "VK_KHR_maintenance1"

7903

#define VK_KHR_MAINTENANCE1_SPEC_VERSION VK_KHR_MAINTENANCE_1_SPEC_VERSION

7904

#define VK_KHR_MAINTENANCE1_EXTENSION_NAME VK_KHR_MAINTENANCE_1_EXTENSION_NAME

7905

typedef VkCommandPoolTrimFlags VkCommandPoolTrimFlagsKHR;

7906

7907

typedef void (VKAPI_PTR *PFN_vkTrimCommandPoolKHR)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags);

7908

7909

#ifndef VK_NO_PROTOTYPES

7910

VKAPI_ATTR void VKAPI_CALL vkTrimCommandPoolKHR(

7911

VkDevice device,

7912

VkCommandPool commandPool,

7913

VkCommandPoolTrimFlags flags);

7914

#endif

7915

7916

7917

#define VK_KHR_device_group_creation 1

7918

#define VK_KHR_DEVICE_GROUP_CREATION_SPEC_VERSION 1

7919

#define VK_KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME "VK_KHR_device_group_creation"

7920

#define VK_MAX_DEVICE_GROUP_SIZE_KHR VK_MAX_DEVICE_GROUP_SIZE

7921

typedef VkPhysicalDeviceGroupProperties VkPhysicalDeviceGroupPropertiesKHR;

7922

7923

typedef VkDeviceGroupDeviceCreateInfo VkDeviceGroupDeviceCreateInfoKHR;

7924

7925

typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceGroupsKHR)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties);

7926

7927

#ifndef VK_NO_PROTOTYPES

7928

VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceGroupsKHR(

7929

VkInstance instance,

7930

uint32_t* pPhysicalDeviceGroupCount,

7931

VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties);

7932

#endif

7933

7934

7935

#define VK_KHR_external_memory_capabilities 1

7936

#define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1

7937

#define VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_memory_capabilities"

7938

#define VK_LUID_SIZE_KHR VK_LUID_SIZE

7939

typedef VkExternalMemoryHandleTypeFlags VkExternalMemoryHandleTypeFlagsKHR;

7940

7941

typedef VkExternalMemoryHandleTypeFlagBits VkExternalMemoryHandleTypeFlagBitsKHR;

7942

7943

typedef VkExternalMemoryFeatureFlags VkExternalMemoryFeatureFlagsKHR;

7944

7945

typedef VkExternalMemoryFeatureFlagBits VkExternalMemoryFeatureFlagBitsKHR;

7946

7947

typedef VkExternalMemoryProperties VkExternalMemoryPropertiesKHR;

7948

7949

typedef VkPhysicalDeviceExternalImageFormatInfo VkPhysicalDeviceExternalImageFormatInfoKHR;

7950

7951

typedef VkExternalImageFormatProperties VkExternalImageFormatPropertiesKHR;

7952

7953

typedef VkPhysicalDeviceExternalBufferInfo VkPhysicalDeviceExternalBufferInfoKHR;

7954

7955

typedef VkExternalBufferProperties VkExternalBufferPropertiesKHR;

7956

7957

typedef VkPhysicalDeviceIDProperties VkPhysicalDeviceIDPropertiesKHR;

7958

7959

typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties);

7960

7961

#ifndef VK_NO_PROTOTYPES

7962

VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalBufferPropertiesKHR(

7963

VkPhysicalDevice physicalDevice,

7964

const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo,

7965

VkExternalBufferProperties* pExternalBufferProperties);

7966

#endif

7967

7968

7969

#define VK_KHR_external_memory 1

7970

#define VK_KHR_EXTERNAL_MEMORY_SPEC_VERSION 1

7971

#define VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME "VK_KHR_external_memory"

7972

#define VK_QUEUE_FAMILY_EXTERNAL_KHR VK_QUEUE_FAMILY_EXTERNAL

7973

typedef VkExternalMemoryImageCreateInfo VkExternalMemoryImageCreateInfoKHR;

7974

7975

typedef VkExternalMemoryBufferCreateInfo VkExternalMemoryBufferCreateInfoKHR;

7976

7977

typedef VkExportMemoryAllocateInfo VkExportMemoryAllocateInfoKHR;

7978

7979

7980

7981

#define VK_KHR_external_memory_fd 1

7982

#define VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION 1

7983

#define VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME "VK_KHR_external_memory_fd"

7984

typedef struct VkImportMemoryFdInfoKHR {

7985

VkStructureType sType;

7986

const void* pNext;

7987

VkExternalMemoryHandleTypeFlagBits handleType;

7988

int fd;

7989

} VkImportMemoryFdInfoKHR;

7990

7991

typedef struct VkMemoryFdPropertiesKHR {

7992

VkStructureType sType;

7993

void* pNext;

7994

uint32_t memoryTypeBits;

7995

} VkMemoryFdPropertiesKHR;

7996

7997

typedef struct VkMemoryGetFdInfoKHR {

7998

VkStructureType sType;

7999

const void* pNext;

8000

VkDeviceMemory memory;

8001

VkExternalMemoryHandleTypeFlagBits handleType;

8002

} VkMemoryGetFdInfoKHR;

8003

8004

typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdKHR)(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd);

8005

typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryFdPropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties);

8006

8007

#ifndef VK_NO_PROTOTYPES

8008

VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdKHR(

8009

VkDevice device,

8010

const VkMemoryGetFdInfoKHR* pGetFdInfo,

8011

int* pFd);

8012

8013

VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryFdPropertiesKHR(

8014

VkDevice device,

8015

VkExternalMemoryHandleTypeFlagBits handleType,

8016

int fd,

8017

VkMemoryFdPropertiesKHR* pMemoryFdProperties);

8018

#endif

8019

8020

8021

#define VK_KHR_external_semaphore_capabilities 1

8022

#define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION 1

8023

#define VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_semaphore_capabilities"

8024

typedef VkExternalSemaphoreHandleTypeFlags VkExternalSemaphoreHandleTypeFlagsKHR;

8025

8026

typedef VkExternalSemaphoreHandleTypeFlagBits VkExternalSemaphoreHandleTypeFlagBitsKHR;

8027

8028

typedef VkExternalSemaphoreFeatureFlags VkExternalSemaphoreFeatureFlagsKHR;

8029

8030

typedef VkExternalSemaphoreFeatureFlagBits VkExternalSemaphoreFeatureFlagBitsKHR;

8031

8032

typedef VkPhysicalDeviceExternalSemaphoreInfo VkPhysicalDeviceExternalSemaphoreInfoKHR;

8033

8034

typedef VkExternalSemaphoreProperties VkExternalSemaphorePropertiesKHR;

8035

8036

typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties);

8037

8038

#ifndef VK_NO_PROTOTYPES

8039

VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(

8040

VkPhysicalDevice physicalDevice,

8041

const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,

8042

VkExternalSemaphoreProperties* pExternalSemaphoreProperties);

8043

#endif

8044

8045

8046

#define VK_KHR_external_semaphore 1

8047

#define VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION 1

8048

#define VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME "VK_KHR_external_semaphore"

8049

typedef VkSemaphoreImportFlags VkSemaphoreImportFlagsKHR;

8050

8051

typedef VkSemaphoreImportFlagBits VkSemaphoreImportFlagBitsKHR;

8052

8053

typedef VkExportSemaphoreCreateInfo VkExportSemaphoreCreateInfoKHR;

8054

8055

8056

8057

#define VK_KHR_external_semaphore_fd 1

8058

#define VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION 1

8059

#define VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME "VK_KHR_external_semaphore_fd"

8060

typedef struct VkImportSemaphoreFdInfoKHR {

8061

VkStructureType sType;

8062

const void* pNext;

8063

VkSemaphore semaphore;

8064

VkSemaphoreImportFlags flags;

8065

VkExternalSemaphoreHandleTypeFlagBits handleType;

8066

int fd;

8067

} VkImportSemaphoreFdInfoKHR;

8068

8069

typedef struct VkSemaphoreGetFdInfoKHR {

8070

VkStructureType sType;

8071

const void* pNext;

8072

VkSemaphore semaphore;

8073

VkExternalSemaphoreHandleTypeFlagBits handleType;

8074

} VkSemaphoreGetFdInfoKHR;

8075

8076

typedef VkResult (VKAPI_PTR *PFN_vkImportSemaphoreFdKHR)(VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo);

8077

typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreFdKHR)(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd);

8078

8079

#ifndef VK_NO_PROTOTYPES

8080

VKAPI_ATTR VkResult VKAPI_CALL vkImportSemaphoreFdKHR(

8081

VkDevice device,

8082

const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo);

8083

8084

VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreFdKHR(

8085

VkDevice device,

8086

const VkSemaphoreGetFdInfoKHR* pGetFdInfo,

8087

int* pFd);

8088

#endif

8089

8090

8091

#define VK_KHR_push_descriptor 1

8092

#define VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION 2

8093

#define VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME "VK_KHR_push_descriptor"

8094

typedef struct VkPhysicalDevicePushDescriptorPropertiesKHR {

8095

VkStructureType sType;

8096

void* pNext;

8097

uint32_t maxPushDescriptors;

8098

} VkPhysicalDevicePushDescriptorPropertiesKHR;

8099

8100

typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetKHR)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites);

8101

typedef void (VKAPI_PTR *PFN_vkCmdPushDescriptorSetWithTemplateKHR)(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData);

8102

8103

#ifndef VK_NO_PROTOTYPES

8104

VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetKHR(

8105

VkCommandBuffer commandBuffer,

8106

VkPipelineBindPoint pipelineBindPoint,

8107

VkPipelineLayout layout,

8108

uint32_t set,

8109

uint32_t descriptorWriteCount,

8110

const VkWriteDescriptorSet* pDescriptorWrites);

8111

8112

VKAPI_ATTR void VKAPI_CALL vkCmdPushDescriptorSetWithTemplateKHR(

8113

VkCommandBuffer commandBuffer,

8114

VkDescriptorUpdateTemplate descriptorUpdateTemplate,

8115

VkPipelineLayout layout,

8116

uint32_t set,

8117

const void* pData);

8118

#endif

8119

8120

8121

#define VK_KHR_shader_float16_int8 1

8122

#define VK_KHR_SHADER_FLOAT16_INT8_SPEC_VERSION 1

8123

#define VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME "VK_KHR_shader_float16_int8"

8124

typedef VkPhysicalDeviceShaderFloat16Int8Features VkPhysicalDeviceShaderFloat16Int8FeaturesKHR;

8125

8126

typedef VkPhysicalDeviceShaderFloat16Int8Features VkPhysicalDeviceFloat16Int8FeaturesKHR;

8127

8128

8129

8130

#define VK_KHR_16bit_storage 1

8131

#define VK_KHR_16BIT_STORAGE_SPEC_VERSION 1

8132

#define VK_KHR_16BIT_STORAGE_EXTENSION_NAME "VK_KHR_16bit_storage"

8133

typedef VkPhysicalDevice16BitStorageFeatures VkPhysicalDevice16BitStorageFeaturesKHR;

8134

8135

8136

8137

#define VK_KHR_incremental_present 1

8138

#define VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION 2

8139

#define VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME "VK_KHR_incremental_present"

8140

typedef struct VkRectLayerKHR {

8141

VkOffset2D offset;

8142

VkExtent2D extent;

8143

uint32_t layer;

8144

} VkRectLayerKHR;

8145

8146

typedef struct VkPresentRegionKHR {

8147

uint32_t rectangleCount;

8148

const VkRectLayerKHR* pRectangles;

8149

} VkPresentRegionKHR;

8150

8151

typedef struct VkPresentRegionsKHR {

8152

VkStructureType sType;

8153

const void* pNext;

8154

uint32_t swapchainCount;

8155

const VkPresentRegionKHR* pRegions;

8156

} VkPresentRegionsKHR;

8157

8158

8159

8160

#define VK_KHR_descriptor_update_template 1

8161

typedef VkDescriptorUpdateTemplate VkDescriptorUpdateTemplateKHR;

8162

8163

#define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION 1

8164

#define VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME "VK_KHR_descriptor_update_template"

8165

typedef VkDescriptorUpdateTemplateType VkDescriptorUpdateTemplateTypeKHR;

8166

8167

typedef VkDescriptorUpdateTemplateCreateFlags VkDescriptorUpdateTemplateCreateFlagsKHR;

8168

8169

typedef VkDescriptorUpdateTemplateEntry VkDescriptorUpdateTemplateEntryKHR;

8170

8171

typedef VkDescriptorUpdateTemplateCreateInfo VkDescriptorUpdateTemplateCreateInfoKHR;

8172

8173

typedef VkResult (VKAPI_PTR *PFN_vkCreateDescriptorUpdateTemplateKHR)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);

8174

typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorUpdateTemplateKHR)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator);

8175

typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSetWithTemplateKHR)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData);

8176

8177

#ifndef VK_NO_PROTOTYPES

8178

VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorUpdateTemplateKHR(

8179

VkDevice device,

8180

const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,

8181

const VkAllocationCallbacks* pAllocator,

8182

VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate);

8183

8184

VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorUpdateTemplateKHR(

8185

VkDevice device,

8186

VkDescriptorUpdateTemplate descriptorUpdateTemplate,

8187

const VkAllocationCallbacks* pAllocator);

8188

8189

VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSetWithTemplateKHR(

8190

VkDevice device,

8191

VkDescriptorSet descriptorSet,

8192

VkDescriptorUpdateTemplate descriptorUpdateTemplate,

8193

const void* pData);

8194

#endif

8195

8196

8197

#define VK_KHR_imageless_framebuffer 1

8198

#define VK_KHR_IMAGELESS_FRAMEBUFFER_SPEC_VERSION 1

8199

#define VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME "VK_KHR_imageless_framebuffer"

8200

typedef VkPhysicalDeviceImagelessFramebufferFeatures VkPhysicalDeviceImagelessFramebufferFeaturesKHR;

8201

8202

typedef VkFramebufferAttachmentsCreateInfo VkFramebufferAttachmentsCreateInfoKHR;

8203

8204

typedef VkFramebufferAttachmentImageInfo VkFramebufferAttachmentImageInfoKHR;

8205

8206

typedef VkRenderPassAttachmentBeginInfo VkRenderPassAttachmentBeginInfoKHR;

8207

8208

8209

8210

#define VK_KHR_create_renderpass2 1

8211

#define VK_KHR_CREATE_RENDERPASS_2_SPEC_VERSION 1

8212

#define VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME "VK_KHR_create_renderpass2"

8213

typedef VkRenderPassCreateInfo2 VkRenderPassCreateInfo2KHR;

8214

8215

typedef VkAttachmentDescription2 VkAttachmentDescription2KHR;

8216

8217

typedef VkAttachmentReference2 VkAttachmentReference2KHR;

8218

8219

typedef VkSubpassDescription2 VkSubpassDescription2KHR;

8220

8221

typedef VkSubpassDependency2 VkSubpassDependency2KHR;

8222

8223

typedef VkSubpassBeginInfo VkSubpassBeginInfoKHR;

8224

8225

typedef VkSubpassEndInfo VkSubpassEndInfoKHR;

8226

8227

typedef VkResult (VKAPI_PTR *PFN_vkCreateRenderPass2KHR)(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass);

8228

typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass2KHR)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo);

8229

typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass2KHR)(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo);

8230

typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass2KHR)(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo);

8231

8232

#ifndef VK_NO_PROTOTYPES

8233

VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass2KHR(

8234

VkDevice device,

8235

const VkRenderPassCreateInfo2* pCreateInfo,

8236

const VkAllocationCallbacks* pAllocator,

8237

VkRenderPass* pRenderPass);

8238

8239

VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass2KHR(

8240

VkCommandBuffer commandBuffer,

8241

const VkRenderPassBeginInfo* pRenderPassBegin,

8242

const VkSubpassBeginInfo* pSubpassBeginInfo);

8243

8244

VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass2KHR(

8245

VkCommandBuffer commandBuffer,

8246

const VkSubpassBeginInfo* pSubpassBeginInfo,

8247

const VkSubpassEndInfo* pSubpassEndInfo);

8248

8249

VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass2KHR(

8250

VkCommandBuffer commandBuffer,

8251

const VkSubpassEndInfo* pSubpassEndInfo);

8252

#endif

8253

8254

8255

#define VK_KHR_shared_presentable_image 1

8256

#define VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION 1

8257

#define VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME "VK_KHR_shared_presentable_image"

8258

typedef struct VkSharedPresentSurfaceCapabilitiesKHR {

8259

VkStructureType sType;

8260

void* pNext;

8261

VkImageUsageFlags sharedPresentSupportedUsageFlags;

8262

} VkSharedPresentSurfaceCapabilitiesKHR;

8263

8264

typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainStatusKHR)(VkDevice device, VkSwapchainKHR swapchain);

8265

8266

#ifndef VK_NO_PROTOTYPES

8267

VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainStatusKHR(

8268

VkDevice device,

8269

VkSwapchainKHR swapchain);

8270

#endif

8271

8272

8273

#define VK_KHR_external_fence_capabilities 1

8274

#define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION 1

8275

#define VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME "VK_KHR_external_fence_capabilities"

8276

typedef VkExternalFenceHandleTypeFlags VkExternalFenceHandleTypeFlagsKHR;

8277

8278

typedef VkExternalFenceHandleTypeFlagBits VkExternalFenceHandleTypeFlagBitsKHR;

8279

8280

typedef VkExternalFenceFeatureFlags VkExternalFenceFeatureFlagsKHR;

8281

8282

typedef VkExternalFenceFeatureFlagBits VkExternalFenceFeatureFlagBitsKHR;

8283

8284

typedef VkPhysicalDeviceExternalFenceInfo VkPhysicalDeviceExternalFenceInfoKHR;

8285

8286

typedef VkExternalFenceProperties VkExternalFencePropertiesKHR;

8287

8288

typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties);

8289

8290

#ifndef VK_NO_PROTOTYPES

8291

VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceExternalFencePropertiesKHR(

8292

VkPhysicalDevice physicalDevice,

8293

const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo,

8294

VkExternalFenceProperties* pExternalFenceProperties);

8295

#endif

8296

8297

8298

#define VK_KHR_external_fence 1

8299

#define VK_KHR_EXTERNAL_FENCE_SPEC_VERSION 1

8300

#define VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME "VK_KHR_external_fence"

8301

typedef VkFenceImportFlags VkFenceImportFlagsKHR;

8302

8303

typedef VkFenceImportFlagBits VkFenceImportFlagBitsKHR;

8304

8305

typedef VkExportFenceCreateInfo VkExportFenceCreateInfoKHR;

8306

8307

8308

8309

#define VK_KHR_external_fence_fd 1

8310

#define VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION 1

8311

#define VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME "VK_KHR_external_fence_fd"

8312

typedef struct VkImportFenceFdInfoKHR {

8313

VkStructureType sType;

8314

const void* pNext;

8315

VkFence fence;

8316

VkFenceImportFlags flags;

8317

VkExternalFenceHandleTypeFlagBits handleType;

8318

int fd;

8319

} VkImportFenceFdInfoKHR;

8320

8321

typedef struct VkFenceGetFdInfoKHR {

8322

VkStructureType sType;

8323

const void* pNext;

8324

VkFence fence;

8325

VkExternalFenceHandleTypeFlagBits handleType;

8326

} VkFenceGetFdInfoKHR;

8327

8328

typedef VkResult (VKAPI_PTR *PFN_vkImportFenceFdKHR)(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo);

8329

typedef VkResult (VKAPI_PTR *PFN_vkGetFenceFdKHR)(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd);

8330

8331

#ifndef VK_NO_PROTOTYPES

8332

VKAPI_ATTR VkResult VKAPI_CALL vkImportFenceFdKHR(

8333

VkDevice device,

8334

const VkImportFenceFdInfoKHR* pImportFenceFdInfo);

8335

8336

VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceFdKHR(

8337

VkDevice device,

8338

const VkFenceGetFdInfoKHR* pGetFdInfo,

8339

int* pFd);

8340

#endif

8341

8342

8343

#define VK_KHR_performance_query 1

8344

#define VK_KHR_PERFORMANCE_QUERY_SPEC_VERSION 1

8345

#define VK_KHR_PERFORMANCE_QUERY_EXTENSION_NAME "VK_KHR_performance_query"

8346

8347

typedef enum VkPerformanceCounterUnitKHR {

8348

VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR = 0,

8349

VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR = 1,

8350

VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR = 2,

8351

VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR = 3,

8352

VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR = 4,

8353

VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR = 5,

8354

VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR = 6,

8355

VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR = 7,

8356

VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR = 8,

8357

VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR = 9,

8358

VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR = 10,

8359

VK_PERFORMANCE_COUNTER_UNIT_MAX_ENUM_KHR = 0x7FFFFFFF

8360

} VkPerformanceCounterUnitKHR;

8361

8362

typedef enum VkPerformanceCounterScopeKHR {

8363

VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR = 0,

8364

VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR = 1,

8365

VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR = 2,

8366

VK_QUERY_SCOPE_COMMAND_BUFFER_KHR = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR,

8367

VK_QUERY_SCOPE_RENDER_PASS_KHR = VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR,

8368

VK_QUERY_SCOPE_COMMAND_KHR = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR,

8369

VK_PERFORMANCE_COUNTER_SCOPE_MAX_ENUM_KHR = 0x7FFFFFFF

8370

} VkPerformanceCounterScopeKHR;

8371

8372

typedef enum VkPerformanceCounterStorageKHR {

8373

VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR = 0,

8374

VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR = 1,

8375

VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR = 2,

8376

VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR = 3,

8377

VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR = 4,

8378

VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR = 5,

8379

VK_PERFORMANCE_COUNTER_STORAGE_MAX_ENUM_KHR = 0x7FFFFFFF

8380

} VkPerformanceCounterStorageKHR;

8381

8382

typedef enum VkPerformanceCounterDescriptionFlagBitsKHR {

8383

VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR = 0x00000001,

8384

VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR = 0x00000002,

8385

VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR = VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR,

8386

VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR = VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR,

8387

VK_PERFORMANCE_COUNTER_DESCRIPTION_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF

8388

} VkPerformanceCounterDescriptionFlagBitsKHR;

8389

typedef VkFlags VkPerformanceCounterDescriptionFlagsKHR;

8390

8391

typedef enum VkAcquireProfilingLockFlagBitsKHR {

8392

VK_ACQUIRE_PROFILING_LOCK_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF

8393

} VkAcquireProfilingLockFlagBitsKHR;

8394

typedef VkFlags VkAcquireProfilingLockFlagsKHR;

8395

typedef struct VkPhysicalDevicePerformanceQueryFeaturesKHR {

8396

VkStructureType sType;

8397

void* pNext;

8398

VkBool32 performanceCounterQueryPools;

8399

VkBool32 performanceCounterMultipleQueryPools;

8400

} VkPhysicalDevicePerformanceQueryFeaturesKHR;

8401

8402

typedef struct VkPhysicalDevicePerformanceQueryPropertiesKHR {

8403

VkStructureType sType;

8404

void* pNext;

8405

VkBool32 allowCommandBufferQueryCopies;

8406

} VkPhysicalDevicePerformanceQueryPropertiesKHR;

8407

8408

typedef struct VkPerformanceCounterKHR {

8409

VkStructureType sType;

8410

void* pNext;

8411

VkPerformanceCounterUnitKHR unit;

8412

VkPerformanceCounterScopeKHR scope;

8413

VkPerformanceCounterStorageKHR storage;

8414

uint8_t uuid[VK_UUID_SIZE];

8415

} VkPerformanceCounterKHR;

8416

8417

typedef struct VkPerformanceCounterDescriptionKHR {

8418

VkStructureType sType;

8419

void* pNext;

8420

VkPerformanceCounterDescriptionFlagsKHR flags;

8421

char name[VK_MAX_DESCRIPTION_SIZE];

8422

char category[VK_MAX_DESCRIPTION_SIZE];

8423

char description[VK_MAX_DESCRIPTION_SIZE];

8424

} VkPerformanceCounterDescriptionKHR;

8425

8426

typedef struct VkQueryPoolPerformanceCreateInfoKHR {

8427

VkStructureType sType;

8428

const void* pNext;

8429

uint32_t queueFamilyIndex;

8430

uint32_t counterIndexCount;

8431

const uint32_t* pCounterIndices;

8432

} VkQueryPoolPerformanceCreateInfoKHR;

8433

8434

typedef union VkPerformanceCounterResultKHR {

8435

int32_t int32;

8436

int64_t int64;

8437

uint32_t uint32;

8438

uint64_t uint64;

8439

float float32;

8440

double float64;

8441

} VkPerformanceCounterResultKHR;

8442

8443

typedef struct VkAcquireProfilingLockInfoKHR {

8444

VkStructureType sType;

8445

const void* pNext;

8446

VkAcquireProfilingLockFlagsKHR flags;

8447

uint64_t timeout;

8448

} VkAcquireProfilingLockInfoKHR;

8449

8450

typedef struct VkPerformanceQuerySubmitInfoKHR {

8451

VkStructureType sType;

8452

const void* pNext;

8453

uint32_t counterPassIndex;

8454

} VkPerformanceQuerySubmitInfoKHR;

8455

8456

typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions);

8457

typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR)(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses);

8458

typedef VkResult (VKAPI_PTR *PFN_vkAcquireProfilingLockKHR)(VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo);

8459

typedef void (VKAPI_PTR *PFN_vkReleaseProfilingLockKHR)(VkDevice device);

8460

8461

#ifndef VK_NO_PROTOTYPES

8462

VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(

8463

VkPhysicalDevice physicalDevice,

8464

uint32_t queueFamilyIndex,

8465

uint32_t* pCounterCount,

8466

VkPerformanceCounterKHR* pCounters,

8467

VkPerformanceCounterDescriptionKHR* pCounterDescriptions);

8468

8469

VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(

8470

VkPhysicalDevice physicalDevice,

8471

const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo,

8472

uint32_t* pNumPasses);

8473

8474

VKAPI_ATTR VkResult VKAPI_CALL vkAcquireProfilingLockKHR(

8475

VkDevice device,

8476

const VkAcquireProfilingLockInfoKHR* pInfo);

8477

8478

VKAPI_ATTR void VKAPI_CALL vkReleaseProfilingLockKHR(

8479

VkDevice device);

8480

#endif

8481

8482

8483

#define VK_KHR_maintenance2 1

8484

#define VK_KHR_MAINTENANCE_2_SPEC_VERSION 1

8485

#define VK_KHR_MAINTENANCE_2_EXTENSION_NAME "VK_KHR_maintenance2"

8486

#define VK_KHR_MAINTENANCE2_SPEC_VERSION VK_KHR_MAINTENANCE_2_SPEC_VERSION

8487

#define VK_KHR_MAINTENANCE2_EXTENSION_NAME VK_KHR_MAINTENANCE_2_EXTENSION_NAME

8488

typedef VkPointClippingBehavior VkPointClippingBehaviorKHR;

8489

8490

typedef VkTessellationDomainOrigin VkTessellationDomainOriginKHR;

8491

8492

typedef VkPhysicalDevicePointClippingProperties VkPhysicalDevicePointClippingPropertiesKHR;

8493

8494

typedef VkRenderPassInputAttachmentAspectCreateInfo VkRenderPassInputAttachmentAspectCreateInfoKHR;

8495

8496

typedef VkInputAttachmentAspectReference VkInputAttachmentAspectReferenceKHR;

8497

8498

typedef VkImageViewUsageCreateInfo VkImageViewUsageCreateInfoKHR;

8499

8500

typedef VkPipelineTessellationDomainOriginStateCreateInfo VkPipelineTessellationDomainOriginStateCreateInfoKHR;

8501

8502

8503

8504

#define VK_KHR_get_surface_capabilities2 1

8505

#define VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION 1

8506

#define VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME "VK_KHR_get_surface_capabilities2"

8507

typedef struct VkPhysicalDeviceSurfaceInfo2KHR {

8508

VkStructureType sType;

8509

const void* pNext;

8510

VkSurfaceKHR surface;

8511

} VkPhysicalDeviceSurfaceInfo2KHR;

8512

8513

typedef struct VkSurfaceCapabilities2KHR {

8514

VkStructureType sType;

8515

void* pNext;

8516

VkSurfaceCapabilitiesKHR surfaceCapabilities;

8517

} VkSurfaceCapabilities2KHR;

8518

8519

typedef struct VkSurfaceFormat2KHR {

8520

VkStructureType sType;

8521

void* pNext;

8522

VkSurfaceFormatKHR surfaceFormat;

8523

} VkSurfaceFormat2KHR;

8524

8525

typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities);

8526

typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormats2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats);

8527

8528

#ifndef VK_NO_PROTOTYPES

8529

VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2KHR(

8530

VkPhysicalDevice physicalDevice,

8531

const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,

8532

VkSurfaceCapabilities2KHR* pSurfaceCapabilities);

8533

8534

VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormats2KHR(

8535

VkPhysicalDevice physicalDevice,

8536

const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo,

8537

uint32_t* pSurfaceFormatCount,

8538

VkSurfaceFormat2KHR* pSurfaceFormats);

8539

#endif

8540

8541

8542

#define VK_KHR_variable_pointers 1

8543

#define VK_KHR_VARIABLE_POINTERS_SPEC_VERSION 1

8544

#define VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME "VK_KHR_variable_pointers"

8545

typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointerFeaturesKHR;

8546

8547

typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointersFeaturesKHR;

8548

8549

8550

8551

#define VK_KHR_get_display_properties2 1

8552

#define VK_KHR_GET_DISPLAY_PROPERTIES_2_SPEC_VERSION 1

8553

#define VK_KHR_GET_DISPLAY_PROPERTIES_2_EXTENSION_NAME "VK_KHR_get_display_properties2"

8554

typedef struct VkDisplayProperties2KHR {

8555

VkStructureType sType;

8556

void* pNext;

8557

VkDisplayPropertiesKHR displayProperties;

8558

} VkDisplayProperties2KHR;

8559

8560

typedef struct VkDisplayPlaneProperties2KHR {

8561

VkStructureType sType;

8562

void* pNext;

8563

VkDisplayPlanePropertiesKHR displayPlaneProperties;

8564

} VkDisplayPlaneProperties2KHR;

8565

8566

typedef struct VkDisplayModeProperties2KHR {

8567

VkStructureType sType;

8568

void* pNext;

8569

VkDisplayModePropertiesKHR displayModeProperties;

8570

} VkDisplayModeProperties2KHR;

8571

8572

typedef struct VkDisplayPlaneInfo2KHR {

8573

VkStructureType sType;

8574

const void* pNext;

8575

VkDisplayModeKHR mode;

8576

uint32_t planeIndex;

8577

} VkDisplayPlaneInfo2KHR;

8578

8579

typedef struct VkDisplayPlaneCapabilities2KHR {

8580

VkStructureType sType;

8581

void* pNext;

8582

VkDisplayPlaneCapabilitiesKHR capabilities;

8583

} VkDisplayPlaneCapabilities2KHR;

8584

8585

typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties);

8586

typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties);

8587

typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModeProperties2KHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties);

8588

typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities);

8589

8590

#ifndef VK_NO_PROTOTYPES

8591

VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayProperties2KHR(

8592

VkPhysicalDevice physicalDevice,

8593

uint32_t* pPropertyCount,

8594

VkDisplayProperties2KHR* pProperties);

8595

8596

VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlaneProperties2KHR(

8597

VkPhysicalDevice physicalDevice,

8598

uint32_t* pPropertyCount,

8599

VkDisplayPlaneProperties2KHR* pProperties);

8600

8601

VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModeProperties2KHR(

8602

VkPhysicalDevice physicalDevice,

8603

VkDisplayKHR display,

8604

uint32_t* pPropertyCount,

8605

VkDisplayModeProperties2KHR* pProperties);

8606

8607

VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilities2KHR(

8608

VkPhysicalDevice physicalDevice,

8609

const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo,

8610

VkDisplayPlaneCapabilities2KHR* pCapabilities);

8611

#endif

8612

8613

8614

#define VK_KHR_dedicated_allocation 1

8615

#define VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION 3

8616

#define VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_KHR_dedicated_allocation"

8617

typedef VkMemoryDedicatedRequirements VkMemoryDedicatedRequirementsKHR;

8618

8619

typedef VkMemoryDedicatedAllocateInfo VkMemoryDedicatedAllocateInfoKHR;

8620

8621

8622

8623

#define VK_KHR_storage_buffer_storage_class 1

8624

#define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION 1

8625

#define VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME "VK_KHR_storage_buffer_storage_class"

8626

8627

8628

#define VK_KHR_relaxed_block_layout 1

8629

#define VK_KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION 1

8630

#define VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME "VK_KHR_relaxed_block_layout"

8631

8632

8633

#define VK_KHR_get_memory_requirements2 1

8634

#define VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION 1

8635

#define VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME "VK_KHR_get_memory_requirements2"

8636

typedef VkBufferMemoryRequirementsInfo2 VkBufferMemoryRequirementsInfo2KHR;

8637

8638

typedef VkImageMemoryRequirementsInfo2 VkImageMemoryRequirementsInfo2KHR;

8639

8640

typedef VkImageSparseMemoryRequirementsInfo2 VkImageSparseMemoryRequirementsInfo2KHR;

8641

8642

typedef VkMemoryRequirements2 VkMemoryRequirements2KHR;

8643

8644

typedef VkSparseImageMemoryRequirements2 VkSparseImageMemoryRequirements2KHR;

8645

8646

typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements2KHR)(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements);

8647

typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements2KHR)(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements);

8648

typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements2KHR)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);

8649

8650

#ifndef VK_NO_PROTOTYPES

8651

VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements2KHR(

8652

VkDevice device,

8653

const VkImageMemoryRequirementsInfo2* pInfo,

8654

VkMemoryRequirements2* pMemoryRequirements);

8655

8656

VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements2KHR(

8657

VkDevice device,

8658

const VkBufferMemoryRequirementsInfo2* pInfo,

8659

VkMemoryRequirements2* pMemoryRequirements);

8660

8661

VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements2KHR(

8662

VkDevice device,

8663

const VkImageSparseMemoryRequirementsInfo2* pInfo,

8664

uint32_t* pSparseMemoryRequirementCount,

8665

VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);

8666

#endif

8667

8668

8669

#define VK_KHR_image_format_list 1

8670

#define VK_KHR_IMAGE_FORMAT_LIST_SPEC_VERSION 1

8671

#define VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME "VK_KHR_image_format_list"

8672

typedef VkImageFormatListCreateInfo VkImageFormatListCreateInfoKHR;

8673

8674

8675

8676

#define VK_KHR_sampler_ycbcr_conversion 1

8677

typedef VkSamplerYcbcrConversion VkSamplerYcbcrConversionKHR;

8678

8679

#define VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION 14

8680

#define VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME "VK_KHR_sampler_ycbcr_conversion"

8681

typedef VkSamplerYcbcrModelConversion VkSamplerYcbcrModelConversionKHR;

8682

8683

typedef VkSamplerYcbcrRange VkSamplerYcbcrRangeKHR;

8684

8685

typedef VkChromaLocation VkChromaLocationKHR;

8686

8687

typedef VkSamplerYcbcrConversionCreateInfo VkSamplerYcbcrConversionCreateInfoKHR;

8688

8689

typedef VkSamplerYcbcrConversionInfo VkSamplerYcbcrConversionInfoKHR;

8690

8691

typedef VkBindImagePlaneMemoryInfo VkBindImagePlaneMemoryInfoKHR;

8692

8693

typedef VkImagePlaneMemoryRequirementsInfo VkImagePlaneMemoryRequirementsInfoKHR;

8694

8695

typedef VkPhysicalDeviceSamplerYcbcrConversionFeatures VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR;

8696

8697

typedef VkSamplerYcbcrConversionImageFormatProperties VkSamplerYcbcrConversionImageFormatPropertiesKHR;

8698

8699

typedef VkResult (VKAPI_PTR *PFN_vkCreateSamplerYcbcrConversionKHR)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion);

8700

typedef void (VKAPI_PTR *PFN_vkDestroySamplerYcbcrConversionKHR)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator);

8701

8702

#ifndef VK_NO_PROTOTYPES

8703

VKAPI_ATTR VkResult VKAPI_CALL vkCreateSamplerYcbcrConversionKHR(

8704

VkDevice device,

8705

const VkSamplerYcbcrConversionCreateInfo* pCreateInfo,

8706

const VkAllocationCallbacks* pAllocator,

8707

VkSamplerYcbcrConversion* pYcbcrConversion);

8708

8709

VKAPI_ATTR void VKAPI_CALL vkDestroySamplerYcbcrConversionKHR(

8710

VkDevice device,

8711

VkSamplerYcbcrConversion ycbcrConversion,

8712

const VkAllocationCallbacks* pAllocator);

8713

#endif

8714

8715

8716

#define VK_KHR_bind_memory2 1

8717

#define VK_KHR_BIND_MEMORY_2_SPEC_VERSION 1

8718

#define VK_KHR_BIND_MEMORY_2_EXTENSION_NAME "VK_KHR_bind_memory2"

8719

typedef VkBindBufferMemoryInfo VkBindBufferMemoryInfoKHR;

8720

8721

typedef VkBindImageMemoryInfo VkBindImageMemoryInfoKHR;

8722

8723

typedef VkResult (VKAPI_PTR *PFN_vkBindBufferMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos);

8724

typedef VkResult (VKAPI_PTR *PFN_vkBindImageMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos);

8725

8726

#ifndef VK_NO_PROTOTYPES

8727

VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory2KHR(

8728

VkDevice device,

8729

uint32_t bindInfoCount,

8730

const VkBindBufferMemoryInfo* pBindInfos);

8731

8732

VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory2KHR(

8733

VkDevice device,

8734

uint32_t bindInfoCount,

8735

const VkBindImageMemoryInfo* pBindInfos);

8736

#endif

8737

8738

8739

#define VK_KHR_maintenance3 1

8740

#define VK_KHR_MAINTENANCE_3_SPEC_VERSION 1

8741

#define VK_KHR_MAINTENANCE_3_EXTENSION_NAME "VK_KHR_maintenance3"

8742

#define VK_KHR_MAINTENANCE3_SPEC_VERSION VK_KHR_MAINTENANCE_3_SPEC_VERSION

8743

#define VK_KHR_MAINTENANCE3_EXTENSION_NAME VK_KHR_MAINTENANCE_3_EXTENSION_NAME

8744

typedef VkPhysicalDeviceMaintenance3Properties VkPhysicalDeviceMaintenance3PropertiesKHR;

8745

8746

typedef VkDescriptorSetLayoutSupport VkDescriptorSetLayoutSupportKHR;

8747

8748

typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutSupportKHR)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport);

8749

8750

#ifndef VK_NO_PROTOTYPES

8751

VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutSupportKHR(

8752

VkDevice device,

8753

const VkDescriptorSetLayoutCreateInfo* pCreateInfo,

8754

VkDescriptorSetLayoutSupport* pSupport);

8755

#endif

8756

8757

8758

#define VK_KHR_draw_indirect_count 1

8759

#define VK_KHR_DRAW_INDIRECT_COUNT_SPEC_VERSION 1

8760

#define VK_KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_KHR_draw_indirect_count"

8761

typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCountKHR)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);

8762

typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCountKHR)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);

8763

8764

#ifndef VK_NO_PROTOTYPES

8765

VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountKHR(

8766

VkCommandBuffer commandBuffer,

8767

VkBuffer buffer,

8768

VkDeviceSize offset,

8769

VkBuffer countBuffer,

8770

VkDeviceSize countBufferOffset,

8771

uint32_t maxDrawCount,

8772

uint32_t stride);

8773

8774

VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountKHR(

8775

VkCommandBuffer commandBuffer,

8776

VkBuffer buffer,

8777

VkDeviceSize offset,

8778

VkBuffer countBuffer,

8779

VkDeviceSize countBufferOffset,

8780

uint32_t maxDrawCount,

8781

uint32_t stride);

8782

#endif

8783

8784

8785

#define VK_KHR_shader_subgroup_extended_types 1

8786

#define VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_SPEC_VERSION 1

8787

#define VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_EXTENSION_NAME "VK_KHR_shader_subgroup_extended_types"

8788

typedef VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR;

8789

8790

8791

8792

#define VK_KHR_8bit_storage 1

8793

#define VK_KHR_8BIT_STORAGE_SPEC_VERSION 1

8794

#define VK_KHR_8BIT_STORAGE_EXTENSION_NAME "VK_KHR_8bit_storage"

8795

typedef VkPhysicalDevice8BitStorageFeatures VkPhysicalDevice8BitStorageFeaturesKHR;

8796

8797

8798

8799

#define VK_KHR_shader_atomic_int64 1

8800

#define VK_KHR_SHADER_ATOMIC_INT64_SPEC_VERSION 1

8801

#define VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME "VK_KHR_shader_atomic_int64"

8802

typedef VkPhysicalDeviceShaderAtomicInt64Features VkPhysicalDeviceShaderAtomicInt64FeaturesKHR;

8803

8804

8805

8806

#define VK_KHR_shader_clock 1

8807

#define VK_KHR_SHADER_CLOCK_SPEC_VERSION 1

8808

#define VK_KHR_SHADER_CLOCK_EXTENSION_NAME "VK_KHR_shader_clock"

8809

typedef struct VkPhysicalDeviceShaderClockFeaturesKHR {

8810

VkStructureType sType;

8811

void* pNext;

8812

VkBool32 shaderSubgroupClock;

8813

VkBool32 shaderDeviceClock;

8814

} VkPhysicalDeviceShaderClockFeaturesKHR;

8815

8816

8817

8818

#define VK_KHR_global_priority 1

8819

#define VK_MAX_GLOBAL_PRIORITY_SIZE_KHR 16U

8820

#define VK_KHR_GLOBAL_PRIORITY_SPEC_VERSION 1

8821

#define VK_KHR_GLOBAL_PRIORITY_EXTENSION_NAME "VK_KHR_global_priority"

8822

8823

typedef enum VkQueueGlobalPriorityKHR {

8824

VK_QUEUE_GLOBAL_PRIORITY_LOW_KHR = 128,

8825

VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_KHR = 256,

8826

VK_QUEUE_GLOBAL_PRIORITY_HIGH_KHR = 512,

8827

VK_QUEUE_GLOBAL_PRIORITY_REALTIME_KHR = 1024,

8828

VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT = VK_QUEUE_GLOBAL_PRIORITY_LOW_KHR,

8829

VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT = VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_KHR,

8830

VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT = VK_QUEUE_GLOBAL_PRIORITY_HIGH_KHR,

8831

VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT = VK_QUEUE_GLOBAL_PRIORITY_REALTIME_KHR,

8832

VK_QUEUE_GLOBAL_PRIORITY_MAX_ENUM_KHR = 0x7FFFFFFF

8833

} VkQueueGlobalPriorityKHR;

8834

typedef struct VkDeviceQueueGlobalPriorityCreateInfoKHR {

8835

VkStructureType sType;

8836

const void* pNext;

8837

VkQueueGlobalPriorityKHR globalPriority;

8838

} VkDeviceQueueGlobalPriorityCreateInfoKHR;

8839

8840

typedef struct VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR {

8841

VkStructureType sType;

8842

void* pNext;

8843

VkBool32 globalPriorityQuery;

8844

} VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR;

8845

8846

typedef struct VkQueueFamilyGlobalPriorityPropertiesKHR {

8847

VkStructureType sType;

8848

void* pNext;

8849

uint32_t priorityCount;

8850

VkQueueGlobalPriorityKHR priorities[VK_MAX_GLOBAL_PRIORITY_SIZE_KHR];

8851

} VkQueueFamilyGlobalPriorityPropertiesKHR;

8852

8853

8854

8855

#define VK_KHR_driver_properties 1

8856

#define VK_KHR_DRIVER_PROPERTIES_SPEC_VERSION 1

8857

#define VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME "VK_KHR_driver_properties"

8858

#define VK_MAX_DRIVER_NAME_SIZE_KHR VK_MAX_DRIVER_NAME_SIZE

8859

#define VK_MAX_DRIVER_INFO_SIZE_KHR VK_MAX_DRIVER_INFO_SIZE

8860

typedef VkDriverId VkDriverIdKHR;

8861

8862

typedef VkConformanceVersion VkConformanceVersionKHR;

8863

8864

typedef VkPhysicalDeviceDriverProperties VkPhysicalDeviceDriverPropertiesKHR;

8865

8866

8867

8868

#define VK_KHR_shader_float_controls 1

8869

#define VK_KHR_SHADER_FLOAT_CONTROLS_SPEC_VERSION 4

8870

#define VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME "VK_KHR_shader_float_controls"

8871

typedef VkShaderFloatControlsIndependence VkShaderFloatControlsIndependenceKHR;

8872

8873

typedef VkPhysicalDeviceFloatControlsProperties VkPhysicalDeviceFloatControlsPropertiesKHR;

8874

8875

8876

8877

#define VK_KHR_depth_stencil_resolve 1

8878

#define VK_KHR_DEPTH_STENCIL_RESOLVE_SPEC_VERSION 1

8879

#define VK_KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME "VK_KHR_depth_stencil_resolve"

8880

typedef VkResolveModeFlagBits VkResolveModeFlagBitsKHR;

8881

8882

typedef VkResolveModeFlags VkResolveModeFlagsKHR;

8883

8884

typedef VkSubpassDescriptionDepthStencilResolve VkSubpassDescriptionDepthStencilResolveKHR;

8885

8886

typedef VkPhysicalDeviceDepthStencilResolveProperties VkPhysicalDeviceDepthStencilResolvePropertiesKHR;

8887

8888

8889

8890

#define VK_KHR_swapchain_mutable_format 1

8891

#define VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_SPEC_VERSION 1

8892

#define VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME "VK_KHR_swapchain_mutable_format"

8893

8894

8895

#define VK_KHR_timeline_semaphore 1

8896

#define VK_KHR_TIMELINE_SEMAPHORE_SPEC_VERSION 2

8897

#define VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME "VK_KHR_timeline_semaphore"

8898

typedef VkSemaphoreType VkSemaphoreTypeKHR;

8899

8900

typedef VkSemaphoreWaitFlagBits VkSemaphoreWaitFlagBitsKHR;

8901

8902

typedef VkSemaphoreWaitFlags VkSemaphoreWaitFlagsKHR;

8903

8904

typedef VkPhysicalDeviceTimelineSemaphoreFeatures VkPhysicalDeviceTimelineSemaphoreFeaturesKHR;

8905

8906

typedef VkPhysicalDeviceTimelineSemaphoreProperties VkPhysicalDeviceTimelineSemaphorePropertiesKHR;

8907

8908

typedef VkSemaphoreTypeCreateInfo VkSemaphoreTypeCreateInfoKHR;

8909

8910

typedef VkTimelineSemaphoreSubmitInfo VkTimelineSemaphoreSubmitInfoKHR;

8911

8912

typedef VkSemaphoreWaitInfo VkSemaphoreWaitInfoKHR;

8913

8914

typedef VkSemaphoreSignalInfo VkSemaphoreSignalInfoKHR;

8915

8916

typedef VkResult (VKAPI_PTR *PFN_vkGetSemaphoreCounterValueKHR)(VkDevice device, VkSemaphore semaphore, uint64_t* pValue);

8917

typedef VkResult (VKAPI_PTR *PFN_vkWaitSemaphoresKHR)(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout);

8918

typedef VkResult (VKAPI_PTR *PFN_vkSignalSemaphoreKHR)(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo);

8919

8920

#ifndef VK_NO_PROTOTYPES

8921

VKAPI_ATTR VkResult VKAPI_CALL vkGetSemaphoreCounterValueKHR(

8922

VkDevice device,

8923

VkSemaphore semaphore,

8924

uint64_t* pValue);

8925

8926

VKAPI_ATTR VkResult VKAPI_CALL vkWaitSemaphoresKHR(

8927

VkDevice device,

8928

const VkSemaphoreWaitInfo* pWaitInfo,

8929

uint64_t timeout);

8930

8931

VKAPI_ATTR VkResult VKAPI_CALL vkSignalSemaphoreKHR(

8932

VkDevice device,

8933

const VkSemaphoreSignalInfo* pSignalInfo);

8934

#endif

8935

8936

8937

#define VK_KHR_vulkan_memory_model 1

8938

#define VK_KHR_VULKAN_MEMORY_MODEL_SPEC_VERSION 3

8939

#define VK_KHR_VULKAN_MEMORY_MODEL_EXTENSION_NAME "VK_KHR_vulkan_memory_model"

8940

typedef VkPhysicalDeviceVulkanMemoryModelFeatures VkPhysicalDeviceVulkanMemoryModelFeaturesKHR;

8941

8942

8943

8944

#define VK_KHR_shader_terminate_invocation 1

8945

#define VK_KHR_SHADER_TERMINATE_INVOCATION_SPEC_VERSION 1

8946

#define VK_KHR_SHADER_TERMINATE_INVOCATION_EXTENSION_NAME "VK_KHR_shader_terminate_invocation"

8947

typedef VkPhysicalDeviceShaderTerminateInvocationFeatures VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR;

8948

8949

8950

8951

#define VK_KHR_fragment_shading_rate 1

8952

#define VK_KHR_FRAGMENT_SHADING_RATE_SPEC_VERSION 2

8953

#define VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME "VK_KHR_fragment_shading_rate"

8954

8955

typedef enum VkFragmentShadingRateCombinerOpKHR {

8956

VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR = 0,

8957

VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR = 1,

8958

VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR = 2,

8959

VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR = 3,

8960

VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR = 4,

8961

VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_ENUM_KHR = 0x7FFFFFFF

8962

} VkFragmentShadingRateCombinerOpKHR;

8963

typedef struct VkFragmentShadingRateAttachmentInfoKHR {

8964

VkStructureType sType;

8965

const void* pNext;

8966

const VkAttachmentReference2* pFragmentShadingRateAttachment;

8967

VkExtent2D shadingRateAttachmentTexelSize;

8968

} VkFragmentShadingRateAttachmentInfoKHR;

8969

8970

typedef struct VkPipelineFragmentShadingRateStateCreateInfoKHR {

8971

VkStructureType sType;

8972

const void* pNext;

8973

VkExtent2D fragmentSize;

8974

VkFragmentShadingRateCombinerOpKHR combinerOps[2];

8975

} VkPipelineFragmentShadingRateStateCreateInfoKHR;

8976

8977

typedef struct VkPhysicalDeviceFragmentShadingRateFeaturesKHR {

8978

VkStructureType sType;

8979

void* pNext;

8980

VkBool32 pipelineFragmentShadingRate;

8981

VkBool32 primitiveFragmentShadingRate;

8982

VkBool32 attachmentFragmentShadingRate;

8983

} VkPhysicalDeviceFragmentShadingRateFeaturesKHR;

8984

8985

typedef struct VkPhysicalDeviceFragmentShadingRatePropertiesKHR {

8986

VkStructureType sType;

8987

void* pNext;

8988

VkExtent2D minFragmentShadingRateAttachmentTexelSize;

8989

VkExtent2D maxFragmentShadingRateAttachmentTexelSize;

8990

uint32_t maxFragmentShadingRateAttachmentTexelSizeAspectRatio;

8991

VkBool32 primitiveFragmentShadingRateWithMultipleViewports;

8992

VkBool32 layeredShadingRateAttachments;

8993

VkBool32 fragmentShadingRateNonTrivialCombinerOps;

8994

VkExtent2D maxFragmentSize;

8995

uint32_t maxFragmentSizeAspectRatio;

8996

uint32_t maxFragmentShadingRateCoverageSamples;

8997

VkSampleCountFlagBits maxFragmentShadingRateRasterizationSamples;

8998

VkBool32 fragmentShadingRateWithShaderDepthStencilWrites;

8999

VkBool32 fragmentShadingRateWithSampleMask;

9000

VkBool32 fragmentShadingRateWithShaderSampleMask;

9001

VkBool32 fragmentShadingRateWithConservativeRasterization;

9002

VkBool32 fragmentShadingRateWithFragmentShaderInterlock;

9003

VkBool32 fragmentShadingRateWithCustomSampleLocations;

9004

VkBool32 fragmentShadingRateStrictMultiplyCombiner;

9005

} VkPhysicalDeviceFragmentShadingRatePropertiesKHR;

9006

9007

typedef struct VkPhysicalDeviceFragmentShadingRateKHR {

9008

VkStructureType sType;

9009

void* pNext;

9010

VkSampleCountFlags sampleCounts;

9011

VkExtent2D fragmentSize;

9012

} VkPhysicalDeviceFragmentShadingRateKHR;

9013

9014

typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates);

9015

typedef void (VKAPI_PTR *PFN_vkCmdSetFragmentShadingRateKHR)(VkCommandBuffer commandBuffer, const VkExtent2D* pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]);

9016

9017

#ifndef VK_NO_PROTOTYPES

9018

VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceFragmentShadingRatesKHR(

9019

VkPhysicalDevice physicalDevice,

9020

uint32_t* pFragmentShadingRateCount,

9021

VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates);

9022

9023

VKAPI_ATTR void VKAPI_CALL vkCmdSetFragmentShadingRateKHR(

9024

VkCommandBuffer commandBuffer,

9025

const VkExtent2D* pFragmentSize,

9026

const VkFragmentShadingRateCombinerOpKHR combinerOps[2]);

9027

#endif

9028

9029

9030

#define VK_KHR_spirv_1_4 1

9031

#define VK_KHR_SPIRV_1_4_SPEC_VERSION 1

9032

#define VK_KHR_SPIRV_1_4_EXTENSION_NAME "VK_KHR_spirv_1_4"

9033

9034

9035

#define VK_KHR_surface_protected_capabilities 1

9036

#define VK_KHR_SURFACE_PROTECTED_CAPABILITIES_SPEC_VERSION 1

9037

#define VK_KHR_SURFACE_PROTECTED_CAPABILITIES_EXTENSION_NAME "VK_KHR_surface_protected_capabilities"

9038

typedef struct VkSurfaceProtectedCapabilitiesKHR {

9039

VkStructureType sType;

9040

const void* pNext;

9041

VkBool32 supportsProtected;

9042

} VkSurfaceProtectedCapabilitiesKHR;

9043

9044

9045

9046

#define VK_KHR_separate_depth_stencil_layouts 1

9047

#define VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_SPEC_VERSION 1

9048

#define VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_EXTENSION_NAME "VK_KHR_separate_depth_stencil_layouts"

9049

typedef VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR;

9050

9051

typedef VkAttachmentReferenceStencilLayout VkAttachmentReferenceStencilLayoutKHR;

9052

9053

typedef VkAttachmentDescriptionStencilLayout VkAttachmentDescriptionStencilLayoutKHR;

9054

9055

9056

9057

#define VK_KHR_present_wait 1

9058

#define VK_KHR_PRESENT_WAIT_SPEC_VERSION 1

9059

#define VK_KHR_PRESENT_WAIT_EXTENSION_NAME "VK_KHR_present_wait"

9060

typedef struct VkPhysicalDevicePresentWaitFeaturesKHR {

9061

VkStructureType sType;

9062

void* pNext;

9063

VkBool32 presentWait;

9064

} VkPhysicalDevicePresentWaitFeaturesKHR;

9065

9066

typedef VkResult (VKAPI_PTR *PFN_vkWaitForPresentKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout);

9067

9068

#ifndef VK_NO_PROTOTYPES

9069

VKAPI_ATTR VkResult VKAPI_CALL vkWaitForPresentKHR(

9070

VkDevice device,

9071

VkSwapchainKHR swapchain,

9072

uint64_t presentId,

9073

uint64_t timeout);

9074

#endif

9075

9076

9077

#define VK_KHR_uniform_buffer_standard_layout 1

9078

#define VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_SPEC_VERSION 1

9079

#define VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME "VK_KHR_uniform_buffer_standard_layout"

9080

typedef VkPhysicalDeviceUniformBufferStandardLayoutFeatures VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR;

9081

9082

9083

9084

#define VK_KHR_buffer_device_address 1

9085

#define VK_KHR_BUFFER_DEVICE_ADDRESS_SPEC_VERSION 1

9086

#define VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME "VK_KHR_buffer_device_address"

9087

typedef VkPhysicalDeviceBufferDeviceAddressFeatures VkPhysicalDeviceBufferDeviceAddressFeaturesKHR;

9088

9089

typedef VkBufferDeviceAddressInfo VkBufferDeviceAddressInfoKHR;

9090

9091

typedef VkBufferOpaqueCaptureAddressCreateInfo VkBufferOpaqueCaptureAddressCreateInfoKHR;

9092

9093

typedef VkMemoryOpaqueCaptureAddressAllocateInfo VkMemoryOpaqueCaptureAddressAllocateInfoKHR;

9094

9095

typedef VkDeviceMemoryOpaqueCaptureAddressInfo VkDeviceMemoryOpaqueCaptureAddressInfoKHR;

9096

9097

typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddressKHR)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo);

9098

typedef uint64_t (VKAPI_PTR *PFN_vkGetBufferOpaqueCaptureAddressKHR)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo);

9099

typedef uint64_t (VKAPI_PTR *PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR)(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo);

9100

9101

#ifndef VK_NO_PROTOTYPES

9102

VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddressKHR(

9103

VkDevice device,

9104

const VkBufferDeviceAddressInfo* pInfo);

9105

9106

VKAPI_ATTR uint64_t VKAPI_CALL vkGetBufferOpaqueCaptureAddressKHR(

9107

VkDevice device,

9108

const VkBufferDeviceAddressInfo* pInfo);

9109

9110

VKAPI_ATTR uint64_t VKAPI_CALL vkGetDeviceMemoryOpaqueCaptureAddressKHR(

9111

VkDevice device,

9112

const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo);

9113

#endif

9114

9115

9116

#define VK_KHR_deferred_host_operations 1

9117

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeferredOperationKHR)

9118

#define VK_KHR_DEFERRED_HOST_OPERATIONS_SPEC_VERSION 4

9119

#define VK_KHR_DEFERRED_HOST_OPERATIONS_EXTENSION_NAME "VK_KHR_deferred_host_operations"

9120

typedef VkResult (VKAPI_PTR *PFN_vkCreateDeferredOperationKHR)(VkDevice device, const VkAllocationCallbacks* pAllocator, VkDeferredOperationKHR* pDeferredOperation);

9121

typedef void (VKAPI_PTR *PFN_vkDestroyDeferredOperationKHR)(VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks* pAllocator);

9122

typedef uint32_t (VKAPI_PTR *PFN_vkGetDeferredOperationMaxConcurrencyKHR)(VkDevice device, VkDeferredOperationKHR operation);

9123

typedef VkResult (VKAPI_PTR *PFN_vkGetDeferredOperationResultKHR)(VkDevice device, VkDeferredOperationKHR operation);

9124

typedef VkResult (VKAPI_PTR *PFN_vkDeferredOperationJoinKHR)(VkDevice device, VkDeferredOperationKHR operation);

9125

9126

#ifndef VK_NO_PROTOTYPES

9127

VKAPI_ATTR VkResult VKAPI_CALL vkCreateDeferredOperationKHR(

9128

VkDevice device,

9129

const VkAllocationCallbacks* pAllocator,

9130

VkDeferredOperationKHR* pDeferredOperation);

9131

9132

VKAPI_ATTR void VKAPI_CALL vkDestroyDeferredOperationKHR(

9133

VkDevice device,

9134

VkDeferredOperationKHR operation,

9135

const VkAllocationCallbacks* pAllocator);

9136

9137

VKAPI_ATTR uint32_t VKAPI_CALL vkGetDeferredOperationMaxConcurrencyKHR(

9138

VkDevice device,

9139

VkDeferredOperationKHR operation);

9140

9141

VKAPI_ATTR VkResult VKAPI_CALL vkGetDeferredOperationResultKHR(

9142

VkDevice device,

9143

VkDeferredOperationKHR operation);

9144

9145

VKAPI_ATTR VkResult VKAPI_CALL vkDeferredOperationJoinKHR(

9146

VkDevice device,

9147

VkDeferredOperationKHR operation);

9148

#endif

9149

9150

9151

#define VK_KHR_pipeline_executable_properties 1

9152

#define VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION 1

9153

#define VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME "VK_KHR_pipeline_executable_properties"

9154

9155

typedef enum VkPipelineExecutableStatisticFormatKHR {

9156

VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR = 0,

9157

VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR = 1,

9158

VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR = 2,

9159

VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR = 3,

9160

VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_MAX_ENUM_KHR = 0x7FFFFFFF

9161

} VkPipelineExecutableStatisticFormatKHR;

9162

typedef struct VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR {

9163

VkStructureType sType;

9164

void* pNext;

9165

VkBool32 pipelineExecutableInfo;

9166

} VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR;

9167

9168

typedef struct VkPipelineInfoKHR {

9169

VkStructureType sType;

9170

const void* pNext;

9171

VkPipeline pipeline;

9172

} VkPipelineInfoKHR;

9173

9174

typedef struct VkPipelineExecutablePropertiesKHR {

9175

VkStructureType sType;

9176

void* pNext;

9177

VkShaderStageFlags stages;

9178

char name[VK_MAX_DESCRIPTION_SIZE];

9179

char description[VK_MAX_DESCRIPTION_SIZE];

9180

uint32_t subgroupSize;

9181

} VkPipelineExecutablePropertiesKHR;

9182

9183

typedef struct VkPipelineExecutableInfoKHR {

9184

VkStructureType sType;

9185

const void* pNext;

9186

VkPipeline pipeline;

9187

uint32_t executableIndex;

9188

} VkPipelineExecutableInfoKHR;

9189

9190

typedef union VkPipelineExecutableStatisticValueKHR {

9191

VkBool32 b32;

9192

int64_t i64;

9193

uint64_t u64;

9194

double f64;

9195

} VkPipelineExecutableStatisticValueKHR;

9196

9197

typedef struct VkPipelineExecutableStatisticKHR {

9198

VkStructureType sType;

9199

void* pNext;

9200

char name[VK_MAX_DESCRIPTION_SIZE];

9201

char description[VK_MAX_DESCRIPTION_SIZE];

9202

VkPipelineExecutableStatisticFormatKHR format;

9203

VkPipelineExecutableStatisticValueKHR value;

9204

} VkPipelineExecutableStatisticKHR;

9205

9206

typedef struct VkPipelineExecutableInternalRepresentationKHR {

9207

VkStructureType sType;

9208

void* pNext;

9209

char name[VK_MAX_DESCRIPTION_SIZE];

9210

char description[VK_MAX_DESCRIPTION_SIZE];

9211

VkBool32 isText;

9212

size_t dataSize;

9213

void* pData;

9214

} VkPipelineExecutableInternalRepresentationKHR;

9215

9216

typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutablePropertiesKHR)(VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties);

9217

typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutableStatisticsKHR)(VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics);

9218

typedef VkResult (VKAPI_PTR *PFN_vkGetPipelineExecutableInternalRepresentationsKHR)(VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations);

9219

9220

#ifndef VK_NO_PROTOTYPES

9221

VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutablePropertiesKHR(

9222

VkDevice device,

9223

const VkPipelineInfoKHR* pPipelineInfo,

9224

uint32_t* pExecutableCount,

9225

VkPipelineExecutablePropertiesKHR* pProperties);

9226

9227

VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutableStatisticsKHR(

9228

VkDevice device,

9229

const VkPipelineExecutableInfoKHR* pExecutableInfo,

9230

uint32_t* pStatisticCount,

9231

VkPipelineExecutableStatisticKHR* pStatistics);

9232

9233

VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineExecutableInternalRepresentationsKHR(

9234

VkDevice device,

9235

const VkPipelineExecutableInfoKHR* pExecutableInfo,

9236

uint32_t* pInternalRepresentationCount,

9237

VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations);

9238

#endif

9239

9240

9241

#define VK_KHR_shader_integer_dot_product 1

9242

#define VK_KHR_SHADER_INTEGER_DOT_PRODUCT_SPEC_VERSION 1

9243

#define VK_KHR_SHADER_INTEGER_DOT_PRODUCT_EXTENSION_NAME "VK_KHR_shader_integer_dot_product"

9244

typedef VkPhysicalDeviceShaderIntegerDotProductFeatures VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR;

9245

9246

typedef VkPhysicalDeviceShaderIntegerDotProductProperties VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR;

9247

9248

9249

9250

#define VK_KHR_pipeline_library 1

9251

#define VK_KHR_PIPELINE_LIBRARY_SPEC_VERSION 1

9252

#define VK_KHR_PIPELINE_LIBRARY_EXTENSION_NAME "VK_KHR_pipeline_library"

9253

typedef struct VkPipelineLibraryCreateInfoKHR {

9254

VkStructureType sType;

9255

const void* pNext;

9256

uint32_t libraryCount;

9257

const VkPipeline* pLibraries;

9258

} VkPipelineLibraryCreateInfoKHR;

9259

9260

9261

9262

#define VK_KHR_shader_non_semantic_info 1

9263

#define VK_KHR_SHADER_NON_SEMANTIC_INFO_SPEC_VERSION 1

9264

#define VK_KHR_SHADER_NON_SEMANTIC_INFO_EXTENSION_NAME "VK_KHR_shader_non_semantic_info"

9265

9266

9267

#define VK_KHR_present_id 1

9268

#define VK_KHR_PRESENT_ID_SPEC_VERSION 1

9269

#define VK_KHR_PRESENT_ID_EXTENSION_NAME "VK_KHR_present_id"

9270

typedef struct VkPresentIdKHR {

9271

VkStructureType sType;

9272

const void* pNext;

9273

uint32_t swapchainCount;

9274

const uint64_t* pPresentIds;

9275

} VkPresentIdKHR;

9276

9277

typedef struct VkPhysicalDevicePresentIdFeaturesKHR {

9278

VkStructureType sType;

9279

void* pNext;

9280

VkBool32 presentId;

9281

} VkPhysicalDevicePresentIdFeaturesKHR;

9282

9283

9284

9285

#define VK_KHR_synchronization2 1

9286

#define VK_KHR_SYNCHRONIZATION_2_SPEC_VERSION 1

9287

#define VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME "VK_KHR_synchronization2"

9288

typedef VkPipelineStageFlags2 VkPipelineStageFlags2KHR;

9289

9290

typedef VkPipelineStageFlagBits2 VkPipelineStageFlagBits2KHR;

9291

9292

typedef VkAccessFlags2 VkAccessFlags2KHR;

9293

9294

typedef VkAccessFlagBits2 VkAccessFlagBits2KHR;

9295

9296

typedef VkSubmitFlagBits VkSubmitFlagBitsKHR;

9297

9298

typedef VkSubmitFlags VkSubmitFlagsKHR;

9299

9300

typedef VkMemoryBarrier2 VkMemoryBarrier2KHR;

9301

9302

typedef VkBufferMemoryBarrier2 VkBufferMemoryBarrier2KHR;

9303

9304

typedef VkImageMemoryBarrier2 VkImageMemoryBarrier2KHR;

9305

9306

typedef VkDependencyInfo VkDependencyInfoKHR;

9307

9308

typedef VkSubmitInfo2 VkSubmitInfo2KHR;

9309

9310

typedef VkSemaphoreSubmitInfo VkSemaphoreSubmitInfoKHR;

9311

9312

typedef VkCommandBufferSubmitInfo VkCommandBufferSubmitInfoKHR;

9313

9314

typedef VkPhysicalDeviceSynchronization2Features VkPhysicalDeviceSynchronization2FeaturesKHR;

9315

9316

typedef struct VkQueueFamilyCheckpointProperties2NV {

9317

VkStructureType sType;

9318

void* pNext;

9319

VkPipelineStageFlags2 checkpointExecutionStageMask;

9320

} VkQueueFamilyCheckpointProperties2NV;

9321

9322

typedef struct VkCheckpointData2NV {

9323

VkStructureType sType;

9324

void* pNext;

9325

VkPipelineStageFlags2 stage;

9326

void* pCheckpointMarker;

9327

} VkCheckpointData2NV;

9328

9329

typedef void (VKAPI_PTR *PFN_vkCmdSetEvent2KHR)(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo);

9330

typedef void (VKAPI_PTR *PFN_vkCmdResetEvent2KHR)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask);

9331

typedef void (VKAPI_PTR *PFN_vkCmdWaitEvents2KHR)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos);

9332

typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier2KHR)(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo);

9333

typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp2KHR)(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query);

9334

typedef VkResult (VKAPI_PTR *PFN_vkQueueSubmit2KHR)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence);

9335

typedef void (VKAPI_PTR *PFN_vkCmdWriteBufferMarker2AMD)(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker);

9336

typedef void (VKAPI_PTR *PFN_vkGetQueueCheckpointData2NV)(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointData2NV* pCheckpointData);

9337

9338

#ifndef VK_NO_PROTOTYPES

9339

VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent2KHR(

9340

VkCommandBuffer commandBuffer,

9341

VkEvent event,

9342

const VkDependencyInfo* pDependencyInfo);

9343

9344

VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent2KHR(

9345

VkCommandBuffer commandBuffer,

9346

VkEvent event,

9347

VkPipelineStageFlags2 stageMask);

9348

9349

VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents2KHR(

9350

VkCommandBuffer commandBuffer,

9351

uint32_t eventCount,

9352

const VkEvent* pEvents,

9353

const VkDependencyInfo* pDependencyInfos);

9354

9355

VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier2KHR(

9356

VkCommandBuffer commandBuffer,

9357

const VkDependencyInfo* pDependencyInfo);

9358

9359

VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp2KHR(

9360

VkCommandBuffer commandBuffer,

9361

VkPipelineStageFlags2 stage,

9362

VkQueryPool queryPool,

9363

uint32_t query);

9364

9365

VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit2KHR(

9366

VkQueue queue,

9367

uint32_t submitCount,

9368

const VkSubmitInfo2* pSubmits,

9369

VkFence fence);

9370

9371

VKAPI_ATTR void VKAPI_CALL vkCmdWriteBufferMarker2AMD(

9372

VkCommandBuffer commandBuffer,

9373

VkPipelineStageFlags2 stage,

9374

VkBuffer dstBuffer,

9375

VkDeviceSize dstOffset,

9376

uint32_t marker);

9377

9378

VKAPI_ATTR void VKAPI_CALL vkGetQueueCheckpointData2NV(

9379

VkQueue queue,

9380

uint32_t* pCheckpointDataCount,

9381

VkCheckpointData2NV* pCheckpointData);

9382

#endif

9383

9384

9385

#define VK_KHR_shader_subgroup_uniform_control_flow 1

9386

#define VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_SPEC_VERSION 1

9387

#define VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_EXTENSION_NAME "VK_KHR_shader_subgroup_uniform_control_flow"

9388

typedef struct VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR {

9389

VkStructureType sType;

9390

void* pNext;

9391

VkBool32 shaderSubgroupUniformControlFlow;

9392

} VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR;

9393

9394

9395

9396

#define VK_KHR_zero_initialize_workgroup_memory 1

9397

#define VK_KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_SPEC_VERSION 1

9398

#define VK_KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_EXTENSION_NAME "VK_KHR_zero_initialize_workgroup_memory"

9399

typedef VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR;

9400

9401

9402

9403

#define VK_KHR_workgroup_memory_explicit_layout 1

9404

#define VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_SPEC_VERSION 1

9405

#define VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_EXTENSION_NAME "VK_KHR_workgroup_memory_explicit_layout"

9406

typedef struct VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {

9407

VkStructureType sType;

9408

void* pNext;

9409

VkBool32 workgroupMemoryExplicitLayout;

9410

VkBool32 workgroupMemoryExplicitLayoutScalarBlockLayout;

9411

VkBool32 workgroupMemoryExplicitLayout8BitAccess;

9412

VkBool32 workgroupMemoryExplicitLayout16BitAccess;

9413

} VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR;

9414

9415

9416

9417

#define VK_KHR_copy_commands2 1

9418

#define VK_KHR_COPY_COMMANDS_2_SPEC_VERSION 1

9419

#define VK_KHR_COPY_COMMANDS_2_EXTENSION_NAME "VK_KHR_copy_commands2"

9420

typedef VkCopyBufferInfo2 VkCopyBufferInfo2KHR;

9421

9422

typedef VkCopyImageInfo2 VkCopyImageInfo2KHR;

9423

9424

typedef VkCopyBufferToImageInfo2 VkCopyBufferToImageInfo2KHR;

9425

9426

typedef VkCopyImageToBufferInfo2 VkCopyImageToBufferInfo2KHR;

9427

9428

typedef VkBlitImageInfo2 VkBlitImageInfo2KHR;

9429

9430

typedef VkResolveImageInfo2 VkResolveImageInfo2KHR;

9431

9432

typedef VkBufferCopy2 VkBufferCopy2KHR;

9433

9434

typedef VkImageCopy2 VkImageCopy2KHR;

9435

9436

typedef VkImageBlit2 VkImageBlit2KHR;

9437

9438

typedef VkBufferImageCopy2 VkBufferImageCopy2KHR;

9439

9440

typedef VkImageResolve2 VkImageResolve2KHR;

9441

9442

typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer2KHR)(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo);

9443

typedef void (VKAPI_PTR *PFN_vkCmdCopyImage2KHR)(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo);

9444

typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage2KHR)(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo);

9445

typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer2KHR)(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo);

9446

typedef void (VKAPI_PTR *PFN_vkCmdBlitImage2KHR)(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo);

9447

typedef void (VKAPI_PTR *PFN_vkCmdResolveImage2KHR)(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo);

9448

9449

#ifndef VK_NO_PROTOTYPES

9450

VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer2KHR(

9451

VkCommandBuffer commandBuffer,

9452

const VkCopyBufferInfo2* pCopyBufferInfo);

9453

9454

VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage2KHR(

9455

VkCommandBuffer commandBuffer,

9456

const VkCopyImageInfo2* pCopyImageInfo);

9457

9458

VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage2KHR(

9459

VkCommandBuffer commandBuffer,

9460

const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo);

9461

9462

VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer2KHR(

9463

VkCommandBuffer commandBuffer,

9464

const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo);

9465

9466

VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage2KHR(

9467

VkCommandBuffer commandBuffer,

9468

const VkBlitImageInfo2* pBlitImageInfo);

9469

9470

VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage2KHR(

9471

VkCommandBuffer commandBuffer,

9472

const VkResolveImageInfo2* pResolveImageInfo);

9473

#endif

9474

9475

9476

#define VK_KHR_format_feature_flags2 1

9477

#define VK_KHR_FORMAT_FEATURE_FLAGS_2_SPEC_VERSION 1

9478

#define VK_KHR_FORMAT_FEATURE_FLAGS_2_EXTENSION_NAME "VK_KHR_format_feature_flags2"

9479

typedef VkFormatFeatureFlags2 VkFormatFeatureFlags2KHR;

9480

9481

typedef VkFormatFeatureFlagBits2 VkFormatFeatureFlagBits2KHR;

9482

9483

typedef VkFormatProperties3 VkFormatProperties3KHR;

9484

9485

9486

9487

#define VK_KHR_portability_enumeration 1

9488

#define VK_KHR_PORTABILITY_ENUMERATION_SPEC_VERSION 1

9489

#define VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME "VK_KHR_portability_enumeration"

9490

9491

9492

#define VK_KHR_maintenance4 1

9493

#define VK_KHR_MAINTENANCE_4_SPEC_VERSION 2

9494

#define VK_KHR_MAINTENANCE_4_EXTENSION_NAME "VK_KHR_maintenance4"

9495

typedef VkPhysicalDeviceMaintenance4Features VkPhysicalDeviceMaintenance4FeaturesKHR;

9496

9497

typedef VkPhysicalDeviceMaintenance4Properties VkPhysicalDeviceMaintenance4PropertiesKHR;

9498

9499

typedef VkDeviceBufferMemoryRequirements VkDeviceBufferMemoryRequirementsKHR;

9500

9501

typedef VkDeviceImageMemoryRequirements VkDeviceImageMemoryRequirementsKHR;

9502

9503

typedef void (VKAPI_PTR *PFN_vkGetDeviceBufferMemoryRequirementsKHR)(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements);

9504

typedef void (VKAPI_PTR *PFN_vkGetDeviceImageMemoryRequirementsKHR)(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements);

9505

typedef void (VKAPI_PTR *PFN_vkGetDeviceImageSparseMemoryRequirementsKHR)(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);

9506

9507

#ifndef VK_NO_PROTOTYPES

9508

VKAPI_ATTR void VKAPI_CALL vkGetDeviceBufferMemoryRequirementsKHR(

9509

VkDevice device,

9510

const VkDeviceBufferMemoryRequirements* pInfo,

9511

VkMemoryRequirements2* pMemoryRequirements);

9512

9513

VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageMemoryRequirementsKHR(

9514

VkDevice device,

9515

const VkDeviceImageMemoryRequirements* pInfo,

9516

VkMemoryRequirements2* pMemoryRequirements);

9517

9518

VKAPI_ATTR void VKAPI_CALL vkGetDeviceImageSparseMemoryRequirementsKHR(

9519

VkDevice device,

9520

const VkDeviceImageMemoryRequirements* pInfo,

9521

uint32_t* pSparseMemoryRequirementCount,

9522

VkSparseImageMemoryRequirements2* pSparseMemoryRequirements);

9523

#endif

9524

9525

9526

#define VK_EXT_debug_report 1

9527

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT)

9528

#define VK_EXT_DEBUG_REPORT_SPEC_VERSION 10

9529

#define VK_EXT_DEBUG_REPORT_EXTENSION_NAME "VK_EXT_debug_report"

9530

9531

typedef enum VkDebugReportObjectTypeEXT {

9532

VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0,

9533

VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = 1,

9534

VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = 2,

9535

VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = 3,

9536

VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = 4,

9537

VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = 5,

9538

VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = 6,

9539

VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = 7,

9540

VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = 8,

9541

VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = 9,

9542

VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = 10,

9543

VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = 11,

9544

VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = 12,

9545

VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = 13,

9546

VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = 14,

9547

VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = 15,

9548

VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = 16,

9549

VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = 17,

9550

VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = 18,

9551

VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = 19,

9552

VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = 20,

9553

VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = 21,

9554

VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = 22,

9555

VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = 23,

9556

VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = 24,

9557

VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = 25,

9558

VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26,

9559

VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27,

9560

VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT = 28,

9561

VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT = 29,

9562

VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT = 30,

9563

VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT = 33,

9564

VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT = 1000156000,

9565

VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT = 1000085000,

9566

VK_DEBUG_REPORT_OBJECT_TYPE_CU_MODULE_NVX_EXT = 1000029000,

9567

VK_DEBUG_REPORT_OBJECT_TYPE_CU_FUNCTION_NVX_EXT = 1000029001,

9568

VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR_EXT = 1000150000,

9569

VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT = 1000165000,

9570

VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA_EXT = 1000366000,

9571

VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT,

9572

VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT,

9573

VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT,

9574

VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT,

9575

VK_DEBUG_REPORT_OBJECT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF

9576

} VkDebugReportObjectTypeEXT;

9577

9578

typedef enum VkDebugReportFlagBitsEXT {

9579

VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 0x00000001,

9580

VK_DEBUG_REPORT_WARNING_BIT_EXT = 0x00000002,

9581

VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = 0x00000004,

9582

VK_DEBUG_REPORT_ERROR_BIT_EXT = 0x00000008,

9583

VK_DEBUG_REPORT_DEBUG_BIT_EXT = 0x00000010,

9584

VK_DEBUG_REPORT_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF

9585

} VkDebugReportFlagBitsEXT;

9586

typedef VkFlags VkDebugReportFlagsEXT;

9587

typedef VkBool32 (VKAPI_PTR *PFN_vkDebugReportCallbackEXT)(

9588

VkDebugReportFlagsEXT flags,

9589

VkDebugReportObjectTypeEXT objectType,

9590

uint64_t object,

9591

size_t location,

9592

int32_t messageCode,

9593

const char* pLayerPrefix,

9594

const char* pMessage,

9595

void* pUserData);

9596

9597

typedef struct VkDebugReportCallbackCreateInfoEXT {

9598

VkStructureType sType;

9599

const void* pNext;

9600

VkDebugReportFlagsEXT flags;

9601

PFN_vkDebugReportCallbackEXT pfnCallback;

9602

void* pUserData;

9603

} VkDebugReportCallbackCreateInfoEXT;

9604

9605

typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugReportCallbackEXT)(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback);

9606

typedef void (VKAPI_PTR *PFN_vkDestroyDebugReportCallbackEXT)(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator);

9607

typedef void (VKAPI_PTR *PFN_vkDebugReportMessageEXT)(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage);

9608

9609

#ifndef VK_NO_PROTOTYPES

9610

VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT(

9611

VkInstance instance,

9612

const VkDebugReportCallbackCreateInfoEXT* pCreateInfo,

9613

const VkAllocationCallbacks* pAllocator,

9614

VkDebugReportCallbackEXT* pCallback);

9615

9616

VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT(

9617

VkInstance instance,

9618

VkDebugReportCallbackEXT callback,

9619

const VkAllocationCallbacks* pAllocator);

9620

9621

VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT(

9622

VkInstance instance,

9623

VkDebugReportFlagsEXT flags,

9624

VkDebugReportObjectTypeEXT objectType,

9625

uint64_t object,

9626

size_t location,

9627

int32_t messageCode,

9628

const char* pLayerPrefix,

9629

const char* pMessage);

9630

#endif

9631

9632

9633

#define VK_NV_glsl_shader 1

9634

#define VK_NV_GLSL_SHADER_SPEC_VERSION 1

9635

#define VK_NV_GLSL_SHADER_EXTENSION_NAME "VK_NV_glsl_shader"

9636

9637

9638

#define VK_EXT_depth_range_unrestricted 1

9639

#define VK_EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION 1

9640

#define VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME "VK_EXT_depth_range_unrestricted"

9641

9642

9643

#define VK_IMG_filter_cubic 1

9644

#define VK_IMG_FILTER_CUBIC_SPEC_VERSION 1

9645

#define VK_IMG_FILTER_CUBIC_EXTENSION_NAME "VK_IMG_filter_cubic"

9646

9647

9648

#define VK_AMD_rasterization_order 1

9649

#define VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION 1

9650

#define VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME "VK_AMD_rasterization_order"

9651

9652

typedef enum VkRasterizationOrderAMD {

9653

VK_RASTERIZATION_ORDER_STRICT_AMD = 0,

9654

VK_RASTERIZATION_ORDER_RELAXED_AMD = 1,

9655

VK_RASTERIZATION_ORDER_MAX_ENUM_AMD = 0x7FFFFFFF

9656

} VkRasterizationOrderAMD;

9657

typedef struct VkPipelineRasterizationStateRasterizationOrderAMD {

9658

VkStructureType sType;

9659

const void* pNext;

9660

VkRasterizationOrderAMD rasterizationOrder;

9661

} VkPipelineRasterizationStateRasterizationOrderAMD;

9662

9663

9664

9665

#define VK_AMD_shader_trinary_minmax 1

9666

#define VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION 1

9667

#define VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME "VK_AMD_shader_trinary_minmax"

9668

9669

9670

#define VK_AMD_shader_explicit_vertex_parameter 1

9671

#define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION 1

9672

#define VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME "VK_AMD_shader_explicit_vertex_parameter"

9673

9674

9675

#define VK_EXT_debug_marker 1

9676

#define VK_EXT_DEBUG_MARKER_SPEC_VERSION 4

9677

#define VK_EXT_DEBUG_MARKER_EXTENSION_NAME "VK_EXT_debug_marker"

9678

typedef struct VkDebugMarkerObjectNameInfoEXT {

9679

VkStructureType sType;

9680

const void* pNext;

9681

VkDebugReportObjectTypeEXT objectType;

9682

uint64_t object;

9683

const char* pObjectName;

9684

} VkDebugMarkerObjectNameInfoEXT;

9685

9686

typedef struct VkDebugMarkerObjectTagInfoEXT {

9687

VkStructureType sType;

9688

const void* pNext;

9689

VkDebugReportObjectTypeEXT objectType;

9690

uint64_t object;

9691

uint64_t tagName;

9692

size_t tagSize;

9693

const void* pTag;

9694

} VkDebugMarkerObjectTagInfoEXT;

9695

9696

typedef struct VkDebugMarkerMarkerInfoEXT {

9697

VkStructureType sType;

9698

const void* pNext;

9699

const char* pMarkerName;

9700

float color[4];

9701

} VkDebugMarkerMarkerInfoEXT;

9702

9703

typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectTagEXT)(VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo);

9704

typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectNameEXT)(VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo);

9705

typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerBeginEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);

9706

typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerEndEXT)(VkCommandBuffer commandBuffer);

9707

typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerInsertEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);

9708

9709

#ifndef VK_NO_PROTOTYPES

9710

VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectTagEXT(

9711

VkDevice device,

9712

const VkDebugMarkerObjectTagInfoEXT* pTagInfo);

9713

9714

VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectNameEXT(

9715

VkDevice device,

9716

const VkDebugMarkerObjectNameInfoEXT* pNameInfo);

9717

9718

VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerBeginEXT(

9719

VkCommandBuffer commandBuffer,

9720

const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);

9721

9722

VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerEndEXT(

9723

VkCommandBuffer commandBuffer);

9724

9725

VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerInsertEXT(

9726

VkCommandBuffer commandBuffer,

9727

const VkDebugMarkerMarkerInfoEXT* pMarkerInfo);

9728

#endif

9729

9730

9731

#define VK_AMD_gcn_shader 1

9732

#define VK_AMD_GCN_SHADER_SPEC_VERSION 1

9733

#define VK_AMD_GCN_SHADER_EXTENSION_NAME "VK_AMD_gcn_shader"

9734

9735

9736

#define VK_NV_dedicated_allocation 1

9737

#define VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION 1

9738

#define VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME "VK_NV_dedicated_allocation"

9739

typedef struct VkDedicatedAllocationImageCreateInfoNV {

9740

VkStructureType sType;

9741

const void* pNext;

9742

VkBool32 dedicatedAllocation;

9743

} VkDedicatedAllocationImageCreateInfoNV;

9744

9745

typedef struct VkDedicatedAllocationBufferCreateInfoNV {

9746

VkStructureType sType;

9747

const void* pNext;

9748

VkBool32 dedicatedAllocation;

9749

} VkDedicatedAllocationBufferCreateInfoNV;

9750

9751

typedef struct VkDedicatedAllocationMemoryAllocateInfoNV {

9752

VkStructureType sType;

9753

const void* pNext;

9754

VkImage image;

9755

VkBuffer buffer;

9756

} VkDedicatedAllocationMemoryAllocateInfoNV;

9757

9758

9759

9760

#define VK_EXT_transform_feedback 1

9761

#define VK_EXT_TRANSFORM_FEEDBACK_SPEC_VERSION 1

9762

#define VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME "VK_EXT_transform_feedback"

9763

typedef VkFlags VkPipelineRasterizationStateStreamCreateFlagsEXT;

9764

typedef struct VkPhysicalDeviceTransformFeedbackFeaturesEXT {

9765

VkStructureType sType;

9766

void* pNext;

9767

VkBool32 transformFeedback;

9768

VkBool32 geometryStreams;

9769

} VkPhysicalDeviceTransformFeedbackFeaturesEXT;

9770

9771

typedef struct VkPhysicalDeviceTransformFeedbackPropertiesEXT {

9772

VkStructureType sType;

9773

void* pNext;

9774

uint32_t maxTransformFeedbackStreams;

9775

uint32_t maxTransformFeedbackBuffers;

9776

VkDeviceSize maxTransformFeedbackBufferSize;

9777

uint32_t maxTransformFeedbackStreamDataSize;

9778

uint32_t maxTransformFeedbackBufferDataSize;

9779

uint32_t maxTransformFeedbackBufferDataStride;

9780

VkBool32 transformFeedbackQueries;

9781

VkBool32 transformFeedbackStreamsLinesTriangles;

9782

VkBool32 transformFeedbackRasterizationStreamSelect;

9783

VkBool32 transformFeedbackDraw;

9784

} VkPhysicalDeviceTransformFeedbackPropertiesEXT;

9785

9786

typedef struct VkPipelineRasterizationStateStreamCreateInfoEXT {

9787

VkStructureType sType;

9788

const void* pNext;

9789

VkPipelineRasterizationStateStreamCreateFlagsEXT flags;

9790

uint32_t rasterizationStream;

9791

} VkPipelineRasterizationStateStreamCreateInfoEXT;

9792

9793

typedef void (VKAPI_PTR *PFN_vkCmdBindTransformFeedbackBuffersEXT)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes);

9794

typedef void (VKAPI_PTR *PFN_vkCmdBeginTransformFeedbackEXT)(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets);

9795

typedef void (VKAPI_PTR *PFN_vkCmdEndTransformFeedbackEXT)(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets);

9796

typedef void (VKAPI_PTR *PFN_vkCmdBeginQueryIndexedEXT)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index);

9797

typedef void (VKAPI_PTR *PFN_vkCmdEndQueryIndexedEXT)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index);

9798

typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectByteCountEXT)(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride);

9799

9800

#ifndef VK_NO_PROTOTYPES

9801

VKAPI_ATTR void VKAPI_CALL vkCmdBindTransformFeedbackBuffersEXT(

9802

VkCommandBuffer commandBuffer,

9803

uint32_t firstBinding,

9804

uint32_t bindingCount,

9805

const VkBuffer* pBuffers,

9806

const VkDeviceSize* pOffsets,

9807

const VkDeviceSize* pSizes);

9808

9809

VKAPI_ATTR void VKAPI_CALL vkCmdBeginTransformFeedbackEXT(

9810

VkCommandBuffer commandBuffer,

9811

uint32_t firstCounterBuffer,

9812

uint32_t counterBufferCount,

9813

const VkBuffer* pCounterBuffers,

9814

const VkDeviceSize* pCounterBufferOffsets);

9815

9816

VKAPI_ATTR void VKAPI_CALL vkCmdEndTransformFeedbackEXT(

9817

VkCommandBuffer commandBuffer,

9818

uint32_t firstCounterBuffer,

9819

uint32_t counterBufferCount,

9820

const VkBuffer* pCounterBuffers,

9821

const VkDeviceSize* pCounterBufferOffsets);

9822

9823

VKAPI_ATTR void VKAPI_CALL vkCmdBeginQueryIndexedEXT(

9824

VkCommandBuffer commandBuffer,

9825

VkQueryPool queryPool,

9826

uint32_t query,

9827

VkQueryControlFlags flags,

9828

uint32_t index);

9829

9830

VKAPI_ATTR void VKAPI_CALL vkCmdEndQueryIndexedEXT(

9831

VkCommandBuffer commandBuffer,

9832

VkQueryPool queryPool,

9833

uint32_t query,

9834

uint32_t index);

9835

9836

VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectByteCountEXT(

9837

VkCommandBuffer commandBuffer,

9838

uint32_t instanceCount,

9839

uint32_t firstInstance,

9840

VkBuffer counterBuffer,

9841

VkDeviceSize counterBufferOffset,

9842

uint32_t counterOffset,

9843

uint32_t vertexStride);

9844

#endif

9845

9846

9847

#define VK_NVX_binary_import 1

9848

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCuModuleNVX)

9849

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCuFunctionNVX)

9850

#define VK_NVX_BINARY_IMPORT_SPEC_VERSION 1

9851

#define VK_NVX_BINARY_IMPORT_EXTENSION_NAME "VK_NVX_binary_import"

9852

typedef struct VkCuModuleCreateInfoNVX {

9853

VkStructureType sType;

9854

const void* pNext;

9855

size_t dataSize;

9856

const void* pData;

9857

} VkCuModuleCreateInfoNVX;

9858

9859

typedef struct VkCuFunctionCreateInfoNVX {

9860

VkStructureType sType;

9861

const void* pNext;

9862

VkCuModuleNVX module;

9863

const char* pName;

9864

} VkCuFunctionCreateInfoNVX;

9865

9866

typedef struct VkCuLaunchInfoNVX {

9867

VkStructureType sType;

9868

const void* pNext;

9869

VkCuFunctionNVX function;

9870

uint32_t gridDimX;

9871

uint32_t gridDimY;

9872

uint32_t gridDimZ;

9873

uint32_t blockDimX;

9874

uint32_t blockDimY;

9875

uint32_t blockDimZ;

9876

uint32_t sharedMemBytes;

9877

size_t paramCount;

9878

const void* const * pParams;

9879

size_t extraCount;

9880

const void* const * pExtras;

9881

} VkCuLaunchInfoNVX;

9882

9883

typedef VkResult (VKAPI_PTR *PFN_vkCreateCuModuleNVX)(VkDevice device, const VkCuModuleCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuModuleNVX* pModule);

9884

typedef VkResult (VKAPI_PTR *PFN_vkCreateCuFunctionNVX)(VkDevice device, const VkCuFunctionCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuFunctionNVX* pFunction);

9885

typedef void (VKAPI_PTR *PFN_vkDestroyCuModuleNVX)(VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks* pAllocator);

9886

typedef void (VKAPI_PTR *PFN_vkDestroyCuFunctionNVX)(VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks* pAllocator);

9887

typedef void (VKAPI_PTR *PFN_vkCmdCuLaunchKernelNVX)(VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX* pLaunchInfo);

9888

9889

#ifndef VK_NO_PROTOTYPES

9890

VKAPI_ATTR VkResult VKAPI_CALL vkCreateCuModuleNVX(

9891

VkDevice device,

9892

const VkCuModuleCreateInfoNVX* pCreateInfo,

9893

const VkAllocationCallbacks* pAllocator,

9894

VkCuModuleNVX* pModule);

9895

9896

VKAPI_ATTR VkResult VKAPI_CALL vkCreateCuFunctionNVX(

9897

VkDevice device,

9898

const VkCuFunctionCreateInfoNVX* pCreateInfo,

9899

const VkAllocationCallbacks* pAllocator,

9900

VkCuFunctionNVX* pFunction);

9901

9902

VKAPI_ATTR void VKAPI_CALL vkDestroyCuModuleNVX(

9903

VkDevice device,

9904

VkCuModuleNVX module,

9905

const VkAllocationCallbacks* pAllocator);

9906

9907

VKAPI_ATTR void VKAPI_CALL vkDestroyCuFunctionNVX(

9908

VkDevice device,

9909

VkCuFunctionNVX function,

9910

const VkAllocationCallbacks* pAllocator);

9911

9912

VKAPI_ATTR void VKAPI_CALL vkCmdCuLaunchKernelNVX(

9913

VkCommandBuffer commandBuffer,

9914

const VkCuLaunchInfoNVX* pLaunchInfo);

9915

#endif

9916

9917

9918

#define VK_NVX_image_view_handle 1

9919

#define VK_NVX_IMAGE_VIEW_HANDLE_SPEC_VERSION 2

9920

#define VK_NVX_IMAGE_VIEW_HANDLE_EXTENSION_NAME "VK_NVX_image_view_handle"

9921

typedef struct VkImageViewHandleInfoNVX {

9922

VkStructureType sType;

9923

const void* pNext;

9924

VkImageView imageView;

9925

VkDescriptorType descriptorType;

9926

VkSampler sampler;

9927

} VkImageViewHandleInfoNVX;

9928

9929

typedef struct VkImageViewAddressPropertiesNVX {

9930

VkStructureType sType;

9931

void* pNext;

9932

VkDeviceAddress deviceAddress;

9933

VkDeviceSize size;

9934

} VkImageViewAddressPropertiesNVX;

9935

9936

typedef uint32_t (VKAPI_PTR *PFN_vkGetImageViewHandleNVX)(VkDevice device, const VkImageViewHandleInfoNVX* pInfo);

9937

typedef VkResult (VKAPI_PTR *PFN_vkGetImageViewAddressNVX)(VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX* pProperties);

9938

9939

#ifndef VK_NO_PROTOTYPES

9940

VKAPI_ATTR uint32_t VKAPI_CALL vkGetImageViewHandleNVX(

9941

VkDevice device,

9942

const VkImageViewHandleInfoNVX* pInfo);

9943

9944

VKAPI_ATTR VkResult VKAPI_CALL vkGetImageViewAddressNVX(

9945

VkDevice device,

9946

VkImageView imageView,

9947

VkImageViewAddressPropertiesNVX* pProperties);

9948

#endif

9949

9950

9951

#define VK_AMD_draw_indirect_count 1

9952

#define VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION 2

9953

#define VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME "VK_AMD_draw_indirect_count"

9954

typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);

9955

typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);

9956

9957

#ifndef VK_NO_PROTOTYPES

9958

VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountAMD(

9959

VkCommandBuffer commandBuffer,

9960

VkBuffer buffer,

9961

VkDeviceSize offset,

9962

VkBuffer countBuffer,

9963

VkDeviceSize countBufferOffset,

9964

uint32_t maxDrawCount,

9965

uint32_t stride);

9966

9967

VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountAMD(

9968

VkCommandBuffer commandBuffer,

9969

VkBuffer buffer,

9970

VkDeviceSize offset,

9971

VkBuffer countBuffer,

9972

VkDeviceSize countBufferOffset,

9973

uint32_t maxDrawCount,

9974

uint32_t stride);

9975

#endif

9976

9977

9978

#define VK_AMD_negative_viewport_height 1

9979

#define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION 1

9980

#define VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME "VK_AMD_negative_viewport_height"

9981

9982

9983

#define VK_AMD_gpu_shader_half_float 1

9984

#define VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION 2

9985

#define VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME "VK_AMD_gpu_shader_half_float"

9986

9987

9988

#define VK_AMD_shader_ballot 1

9989

#define VK_AMD_SHADER_BALLOT_SPEC_VERSION 1

9990

#define VK_AMD_SHADER_BALLOT_EXTENSION_NAME "VK_AMD_shader_ballot"

9991

9992

9993

#define VK_AMD_texture_gather_bias_lod 1

9994

#define VK_AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION 1

9995

#define VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME "VK_AMD_texture_gather_bias_lod"

9996

typedef struct VkTextureLODGatherFormatPropertiesAMD {

9997

VkStructureType sType;

9998

void* pNext;

9999

VkBool32 supportsTextureGatherLODBiasAMD;

10000

} VkTextureLODGatherFormatPropertiesAMD;

10001

10002

10003

10004

#define VK_AMD_shader_info 1

10005

#define VK_AMD_SHADER_INFO_SPEC_VERSION 1

10006

#define VK_AMD_SHADER_INFO_EXTENSION_NAME "VK_AMD_shader_info"

10007

10008

typedef enum VkShaderInfoTypeAMD {

10009

VK_SHADER_INFO_TYPE_STATISTICS_AMD = 0,

10010

VK_SHADER_INFO_TYPE_BINARY_AMD = 1,

10011

VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD = 2,

10012

VK_SHADER_INFO_TYPE_MAX_ENUM_AMD = 0x7FFFFFFF

10013

} VkShaderInfoTypeAMD;

10014

typedef struct VkShaderResourceUsageAMD {

10015

uint32_t numUsedVgprs;

10016

uint32_t numUsedSgprs;

10017

uint32_t ldsSizePerLocalWorkGroup;

10018

size_t ldsUsageSizeInBytes;

10019

size_t scratchMemUsageInBytes;

10020

} VkShaderResourceUsageAMD;

10021

10022

typedef struct VkShaderStatisticsInfoAMD {

10023

VkShaderStageFlags shaderStageMask;

10024

VkShaderResourceUsageAMD resourceUsage;

10025

uint32_t numPhysicalVgprs;

10026

uint32_t numPhysicalSgprs;

10027

uint32_t numAvailableVgprs;

10028

uint32_t numAvailableSgprs;

10029

uint32_t computeWorkGroupSize[3];

10030

} VkShaderStatisticsInfoAMD;

10031

10032

typedef VkResult (VKAPI_PTR *PFN_vkGetShaderInfoAMD)(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo);

10033

10034

#ifndef VK_NO_PROTOTYPES

10035

VKAPI_ATTR VkResult VKAPI_CALL vkGetShaderInfoAMD(

10036

VkDevice device,

10037

VkPipeline pipeline,

10038

VkShaderStageFlagBits shaderStage,

10039

VkShaderInfoTypeAMD infoType,

10040

size_t* pInfoSize,

10041

void* pInfo);

10042

#endif

10043

10044

10045

#define VK_AMD_shader_image_load_store_lod 1

10046

#define VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_SPEC_VERSION 1

10047

#define VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME "VK_AMD_shader_image_load_store_lod"

10048

10049

10050

#define VK_NV_corner_sampled_image 1

10051

#define VK_NV_CORNER_SAMPLED_IMAGE_SPEC_VERSION 2

10052

#define VK_NV_CORNER_SAMPLED_IMAGE_EXTENSION_NAME "VK_NV_corner_sampled_image"

10053

typedef struct VkPhysicalDeviceCornerSampledImageFeaturesNV {

10054

VkStructureType sType;

10055

void* pNext;

10056

VkBool32 cornerSampledImage;

10057

} VkPhysicalDeviceCornerSampledImageFeaturesNV;

10058

10059

10060

10061

#define VK_IMG_format_pvrtc 1

10062

#define VK_IMG_FORMAT_PVRTC_SPEC_VERSION 1

10063

#define VK_IMG_FORMAT_PVRTC_EXTENSION_NAME "VK_IMG_format_pvrtc"

10064

10065

10066

#define VK_NV_external_memory_capabilities 1

10067

#define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION 1

10068

#define VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME "VK_NV_external_memory_capabilities"

10069

10070

typedef enum VkExternalMemoryHandleTypeFlagBitsNV {

10071

VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV = 0x00000001,

10072

VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV = 0x00000002,

10073

VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV = 0x00000004,

10074

VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV = 0x00000008,

10075

VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF

10076

} VkExternalMemoryHandleTypeFlagBitsNV;

10077

typedef VkFlags VkExternalMemoryHandleTypeFlagsNV;

10078

10079

typedef enum VkExternalMemoryFeatureFlagBitsNV {

10080

VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV = 0x00000001,

10081

VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV = 0x00000002,

10082

VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV = 0x00000004,

10083

VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF

10084

} VkExternalMemoryFeatureFlagBitsNV;

10085

typedef VkFlags VkExternalMemoryFeatureFlagsNV;

10086

typedef struct VkExternalImageFormatPropertiesNV {

10087

VkImageFormatProperties imageFormatProperties;

10088

VkExternalMemoryFeatureFlagsNV externalMemoryFeatures;

10089

VkExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes;

10090

VkExternalMemoryHandleTypeFlagsNV compatibleHandleTypes;

10091

} VkExternalImageFormatPropertiesNV;

10092

10093

typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties);

10094

10095

#ifndef VK_NO_PROTOTYPES

10096

VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceExternalImageFormatPropertiesNV(

10097

VkPhysicalDevice physicalDevice,

10098

VkFormat format,

10099

VkImageType type,

10100

VkImageTiling tiling,

10101

VkImageUsageFlags usage,

10102

VkImageCreateFlags flags,

10103

VkExternalMemoryHandleTypeFlagsNV externalHandleType,

10104

VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties);

10105

#endif

10106

10107

10108

#define VK_NV_external_memory 1

10109

#define VK_NV_EXTERNAL_MEMORY_SPEC_VERSION 1

10110

#define VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME "VK_NV_external_memory"

10111

typedef struct VkExternalMemoryImageCreateInfoNV {

10112

VkStructureType sType;

10113

const void* pNext;

10114

VkExternalMemoryHandleTypeFlagsNV handleTypes;

10115

} VkExternalMemoryImageCreateInfoNV;

10116

10117

typedef struct VkExportMemoryAllocateInfoNV {

10118

VkStructureType sType;

10119

const void* pNext;

10120

VkExternalMemoryHandleTypeFlagsNV handleTypes;

10121

} VkExportMemoryAllocateInfoNV;

10122

10123

10124

10125

#define VK_EXT_validation_flags 1

10126

#define VK_EXT_VALIDATION_FLAGS_SPEC_VERSION 2

10127

#define VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME "VK_EXT_validation_flags"

10128

10129

typedef enum VkValidationCheckEXT {

10130

VK_VALIDATION_CHECK_ALL_EXT = 0,

10131

VK_VALIDATION_CHECK_SHADERS_EXT = 1,

10132

VK_VALIDATION_CHECK_MAX_ENUM_EXT = 0x7FFFFFFF

10133

} VkValidationCheckEXT;

10134

typedef struct VkValidationFlagsEXT {

10135

VkStructureType sType;

10136

const void* pNext;

10137

uint32_t disabledValidationCheckCount;

10138

const VkValidationCheckEXT* pDisabledValidationChecks;

10139

} VkValidationFlagsEXT;

10140

10141

10142

10143

#define VK_EXT_shader_subgroup_ballot 1

10144

#define VK_EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION 1

10145

#define VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME "VK_EXT_shader_subgroup_ballot"

10146

10147

10148

#define VK_EXT_shader_subgroup_vote 1

10149

#define VK_EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION 1

10150

#define VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME "VK_EXT_shader_subgroup_vote"

10151

10152

10153

#define VK_EXT_texture_compression_astc_hdr 1

10154

#define VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_SPEC_VERSION 1

10155

#define VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME "VK_EXT_texture_compression_astc_hdr"

10156

typedef VkPhysicalDeviceTextureCompressionASTCHDRFeatures VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT;

10157

10158

10159

10160

#define VK_EXT_astc_decode_mode 1

10161

#define VK_EXT_ASTC_DECODE_MODE_SPEC_VERSION 1

10162

#define VK_EXT_ASTC_DECODE_MODE_EXTENSION_NAME "VK_EXT_astc_decode_mode"

10163

typedef struct VkImageViewASTCDecodeModeEXT {

10164

VkStructureType sType;

10165

const void* pNext;

10166

VkFormat decodeMode;

10167

} VkImageViewASTCDecodeModeEXT;

10168

10169

typedef struct VkPhysicalDeviceASTCDecodeFeaturesEXT {

10170

VkStructureType sType;

10171

void* pNext;

10172

VkBool32 decodeModeSharedExponent;

10173

} VkPhysicalDeviceASTCDecodeFeaturesEXT;

10174

10175

10176

10177

#define VK_EXT_conditional_rendering 1

10178

#define VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION 2

10179

#define VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME "VK_EXT_conditional_rendering"

10180

10181

typedef enum VkConditionalRenderingFlagBitsEXT {

10182

VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT = 0x00000001,

10183

VK_CONDITIONAL_RENDERING_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF

10184

} VkConditionalRenderingFlagBitsEXT;

10185

typedef VkFlags VkConditionalRenderingFlagsEXT;

10186

typedef struct VkConditionalRenderingBeginInfoEXT {

10187

VkStructureType sType;

10188

const void* pNext;

10189

VkBuffer buffer;

10190

VkDeviceSize offset;

10191

VkConditionalRenderingFlagsEXT flags;

10192

} VkConditionalRenderingBeginInfoEXT;

10193

10194

typedef struct VkPhysicalDeviceConditionalRenderingFeaturesEXT {

10195

VkStructureType sType;

10196

void* pNext;

10197

VkBool32 conditionalRendering;

10198

VkBool32 inheritedConditionalRendering;

10199

} VkPhysicalDeviceConditionalRenderingFeaturesEXT;

10200

10201

typedef struct VkCommandBufferInheritanceConditionalRenderingInfoEXT {

10202

VkStructureType sType;

10203

const void* pNext;

10204

VkBool32 conditionalRenderingEnable;

10205

} VkCommandBufferInheritanceConditionalRenderingInfoEXT;

10206

10207

typedef void (VKAPI_PTR *PFN_vkCmdBeginConditionalRenderingEXT)(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin);

10208

typedef void (VKAPI_PTR *PFN_vkCmdEndConditionalRenderingEXT)(VkCommandBuffer commandBuffer);

10209

10210

#ifndef VK_NO_PROTOTYPES

10211

VKAPI_ATTR void VKAPI_CALL vkCmdBeginConditionalRenderingEXT(

10212

VkCommandBuffer commandBuffer,

10213

const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin);

10214

10215

VKAPI_ATTR void VKAPI_CALL vkCmdEndConditionalRenderingEXT(

10216

VkCommandBuffer commandBuffer);

10217

#endif

10218

10219

10220

#define VK_NV_clip_space_w_scaling 1

10221

#define VK_NV_CLIP_SPACE_W_SCALING_SPEC_VERSION 1

10222

#define VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME "VK_NV_clip_space_w_scaling"

10223

typedef struct VkViewportWScalingNV {

10224

float xcoeff;

10225

float ycoeff;

10226

} VkViewportWScalingNV;

10227

10228

typedef struct VkPipelineViewportWScalingStateCreateInfoNV {

10229

VkStructureType sType;

10230

const void* pNext;

10231

VkBool32 viewportWScalingEnable;

10232

uint32_t viewportCount;

10233

const VkViewportWScalingNV* pViewportWScalings;

10234

} VkPipelineViewportWScalingStateCreateInfoNV;

10235

10236

typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWScalingNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings);

10237

10238

#ifndef VK_NO_PROTOTYPES

10239

VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWScalingNV(

10240

VkCommandBuffer commandBuffer,

10241

uint32_t firstViewport,

10242

uint32_t viewportCount,

10243

const VkViewportWScalingNV* pViewportWScalings);

10244

#endif

10245

10246

10247

#define VK_EXT_direct_mode_display 1

10248

#define VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION 1

10249

#define VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME "VK_EXT_direct_mode_display"

10250

typedef VkResult (VKAPI_PTR *PFN_vkReleaseDisplayEXT)(VkPhysicalDevice physicalDevice, VkDisplayKHR display);

10251

10252

#ifndef VK_NO_PROTOTYPES

10253

VKAPI_ATTR VkResult VKAPI_CALL vkReleaseDisplayEXT(

10254

VkPhysicalDevice physicalDevice,

10255

VkDisplayKHR display);

10256

#endif

10257

10258

10259

#define VK_EXT_display_surface_counter 1

10260

#define VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION 1

10261

#define VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME "VK_EXT_display_surface_counter"

10262

10263

typedef enum VkSurfaceCounterFlagBitsEXT {

10264

VK_SURFACE_COUNTER_VBLANK_BIT_EXT = 0x00000001,

10265

VK_SURFACE_COUNTER_VBLANK_EXT = VK_SURFACE_COUNTER_VBLANK_BIT_EXT,

10266

VK_SURFACE_COUNTER_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF

10267

} VkSurfaceCounterFlagBitsEXT;

10268

typedef VkFlags VkSurfaceCounterFlagsEXT;

10269

typedef struct VkSurfaceCapabilities2EXT {

10270

VkStructureType sType;

10271

void* pNext;

10272

uint32_t minImageCount;

10273

uint32_t maxImageCount;

10274

VkExtent2D currentExtent;

10275

VkExtent2D minImageExtent;

10276

VkExtent2D maxImageExtent;

10277

uint32_t maxImageArrayLayers;

10278

VkSurfaceTransformFlagsKHR supportedTransforms;

10279

VkSurfaceTransformFlagBitsKHR currentTransform;

10280

VkCompositeAlphaFlagsKHR supportedCompositeAlpha;

10281

VkImageUsageFlags supportedUsageFlags;

10282

VkSurfaceCounterFlagsEXT supportedSurfaceCounters;

10283

} VkSurfaceCapabilities2EXT;

10284

10285

typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities);

10286

10287

#ifndef VK_NO_PROTOTYPES

10288

VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2EXT(

10289

VkPhysicalDevice physicalDevice,

10290

VkSurfaceKHR surface,

10291

VkSurfaceCapabilities2EXT* pSurfaceCapabilities);

10292

#endif

10293

10294

10295

#define VK_EXT_display_control 1

10296

#define VK_EXT_DISPLAY_CONTROL_SPEC_VERSION 1

10297

#define VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME "VK_EXT_display_control"

10298

10299

typedef enum VkDisplayPowerStateEXT {

10300

VK_DISPLAY_POWER_STATE_OFF_EXT = 0,

10301

VK_DISPLAY_POWER_STATE_SUSPEND_EXT = 1,

10302

VK_DISPLAY_POWER_STATE_ON_EXT = 2,

10303

VK_DISPLAY_POWER_STATE_MAX_ENUM_EXT = 0x7FFFFFFF

10304

} VkDisplayPowerStateEXT;

10305

10306

typedef enum VkDeviceEventTypeEXT {

10307

VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT = 0,

10308

VK_DEVICE_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF

10309

} VkDeviceEventTypeEXT;

10310

10311

typedef enum VkDisplayEventTypeEXT {

10312

VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT = 0,

10313

VK_DISPLAY_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF

10314

} VkDisplayEventTypeEXT;

10315

typedef struct VkDisplayPowerInfoEXT {

10316

VkStructureType sType;

10317

const void* pNext;

10318

VkDisplayPowerStateEXT powerState;

10319

} VkDisplayPowerInfoEXT;

10320

10321

typedef struct VkDeviceEventInfoEXT {

10322

VkStructureType sType;

10323

const void* pNext;

10324

VkDeviceEventTypeEXT deviceEvent;

10325

} VkDeviceEventInfoEXT;

10326

10327

typedef struct VkDisplayEventInfoEXT {

10328

VkStructureType sType;

10329

const void* pNext;

10330

VkDisplayEventTypeEXT displayEvent;

10331

} VkDisplayEventInfoEXT;

10332

10333

typedef struct VkSwapchainCounterCreateInfoEXT {

10334

VkStructureType sType;

10335

const void* pNext;

10336

VkSurfaceCounterFlagsEXT surfaceCounters;

10337

} VkSwapchainCounterCreateInfoEXT;

10338

10339

typedef VkResult (VKAPI_PTR *PFN_vkDisplayPowerControlEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo);

10340

typedef VkResult (VKAPI_PTR *PFN_vkRegisterDeviceEventEXT)(VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);

10341

typedef VkResult (VKAPI_PTR *PFN_vkRegisterDisplayEventEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);

10342

typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainCounterEXT)(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue);

10343

10344

#ifndef VK_NO_PROTOTYPES

10345

VKAPI_ATTR VkResult VKAPI_CALL vkDisplayPowerControlEXT(

10346

VkDevice device,

10347

VkDisplayKHR display,

10348

const VkDisplayPowerInfoEXT* pDisplayPowerInfo);

10349

10350

VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDeviceEventEXT(

10351

VkDevice device,

10352

const VkDeviceEventInfoEXT* pDeviceEventInfo,

10353

const VkAllocationCallbacks* pAllocator,

10354

VkFence* pFence);

10355

10356

VKAPI_ATTR VkResult VKAPI_CALL vkRegisterDisplayEventEXT(

10357

VkDevice device,

10358

VkDisplayKHR display,

10359

const VkDisplayEventInfoEXT* pDisplayEventInfo,

10360

const VkAllocationCallbacks* pAllocator,

10361

VkFence* pFence);

10362

10363

VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainCounterEXT(

10364

VkDevice device,

10365

VkSwapchainKHR swapchain,

10366

VkSurfaceCounterFlagBitsEXT counter,

10367

uint64_t* pCounterValue);

10368

#endif

10369

10370

10371

#define VK_GOOGLE_display_timing 1

10372

#define VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION 1

10373

#define VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME "VK_GOOGLE_display_timing"

10374

typedef struct VkRefreshCycleDurationGOOGLE {

10375

uint64_t refreshDuration;

10376

} VkRefreshCycleDurationGOOGLE;

10377

10378

typedef struct VkPastPresentationTimingGOOGLE {

10379

uint32_t presentID;

10380

uint64_t desiredPresentTime;

10381

uint64_t actualPresentTime;

10382

uint64_t earliestPresentTime;

10383

uint64_t presentMargin;

10384

} VkPastPresentationTimingGOOGLE;

10385

10386

typedef struct VkPresentTimeGOOGLE {

10387

uint32_t presentID;

10388

uint64_t desiredPresentTime;

10389

} VkPresentTimeGOOGLE;

10390

10391

typedef struct VkPresentTimesInfoGOOGLE {

10392

VkStructureType sType;

10393

const void* pNext;

10394

uint32_t swapchainCount;

10395

const VkPresentTimeGOOGLE* pTimes;

10396

} VkPresentTimesInfoGOOGLE;

10397

10398

typedef VkResult (VKAPI_PTR *PFN_vkGetRefreshCycleDurationGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties);

10399

typedef VkResult (VKAPI_PTR *PFN_vkGetPastPresentationTimingGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings);

10400

10401

#ifndef VK_NO_PROTOTYPES

10402

VKAPI_ATTR VkResult VKAPI_CALL vkGetRefreshCycleDurationGOOGLE(

10403

VkDevice device,

10404

VkSwapchainKHR swapchain,

10405

VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties);

10406

10407

VKAPI_ATTR VkResult VKAPI_CALL vkGetPastPresentationTimingGOOGLE(

10408

VkDevice device,

10409

VkSwapchainKHR swapchain,

10410

uint32_t* pPresentationTimingCount,

10411

VkPastPresentationTimingGOOGLE* pPresentationTimings);

10412

#endif

10413

10414

10415

#define VK_NV_sample_mask_override_coverage 1

10416

#define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION 1

10417

#define VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME "VK_NV_sample_mask_override_coverage"

10418

10419

10420

#define VK_NV_geometry_shader_passthrough 1

10421

#define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION 1

10422

#define VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME "VK_NV_geometry_shader_passthrough"

10423

10424

10425

#define VK_NV_viewport_array2 1

10426

#define VK_NV_VIEWPORT_ARRAY_2_SPEC_VERSION 1

10427

#define VK_NV_VIEWPORT_ARRAY_2_EXTENSION_NAME "VK_NV_viewport_array2"

10428

#define VK_NV_VIEWPORT_ARRAY2_SPEC_VERSION VK_NV_VIEWPORT_ARRAY_2_SPEC_VERSION

10429

#define VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME VK_NV_VIEWPORT_ARRAY_2_EXTENSION_NAME

10430

10431

10432

#define VK_NVX_multiview_per_view_attributes 1

10433

#define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION 1

10434

#define VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME "VK_NVX_multiview_per_view_attributes"

10435

typedef struct VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {

10436

VkStructureType sType;

10437

void* pNext;

10438

VkBool32 perViewPositionAllComponents;

10439

} VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX;

10440

10441

10442

10443

#define VK_NV_viewport_swizzle 1

10444

#define VK_NV_VIEWPORT_SWIZZLE_SPEC_VERSION 1

10445

#define VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME "VK_NV_viewport_swizzle"

10446

10447

typedef enum VkViewportCoordinateSwizzleNV {

10448

VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV = 0,

10449

VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV = 1,

10450

VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV = 2,

10451

VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV = 3,

10452

VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV = 4,

10453

VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV = 5,

10454

VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV = 6,

10455

VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV = 7,

10456

VK_VIEWPORT_COORDINATE_SWIZZLE_MAX_ENUM_NV = 0x7FFFFFFF

10457

} VkViewportCoordinateSwizzleNV;

10458

typedef VkFlags VkPipelineViewportSwizzleStateCreateFlagsNV;

10459

typedef struct VkViewportSwizzleNV {

10460

VkViewportCoordinateSwizzleNV x;

10461

VkViewportCoordinateSwizzleNV y;

10462

VkViewportCoordinateSwizzleNV z;

10463

VkViewportCoordinateSwizzleNV w;

10464

} VkViewportSwizzleNV;

10465

10466

typedef struct VkPipelineViewportSwizzleStateCreateInfoNV {

10467

VkStructureType sType;

10468

const void* pNext;

10469

VkPipelineViewportSwizzleStateCreateFlagsNV flags;

10470

uint32_t viewportCount;

10471

const VkViewportSwizzleNV* pViewportSwizzles;

10472

} VkPipelineViewportSwizzleStateCreateInfoNV;

10473

10474

10475

10476

#define VK_EXT_discard_rectangles 1

10477

#define VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION 1

10478

#define VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME "VK_EXT_discard_rectangles"

10479

10480

typedef enum VkDiscardRectangleModeEXT {

10481

VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT = 0,

10482

VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT = 1,

10483

VK_DISCARD_RECTANGLE_MODE_MAX_ENUM_EXT = 0x7FFFFFFF

10484

} VkDiscardRectangleModeEXT;

10485

typedef VkFlags VkPipelineDiscardRectangleStateCreateFlagsEXT;

10486

typedef struct VkPhysicalDeviceDiscardRectanglePropertiesEXT {

10487

VkStructureType sType;

10488

void* pNext;

10489

uint32_t maxDiscardRectangles;

10490

} VkPhysicalDeviceDiscardRectanglePropertiesEXT;

10491

10492

typedef struct VkPipelineDiscardRectangleStateCreateInfoEXT {

10493

VkStructureType sType;

10494

const void* pNext;

10495

VkPipelineDiscardRectangleStateCreateFlagsEXT flags;

10496

VkDiscardRectangleModeEXT discardRectangleMode;

10497

uint32_t discardRectangleCount;

10498

const VkRect2D* pDiscardRectangles;

10499

} VkPipelineDiscardRectangleStateCreateInfoEXT;

10500

10501

typedef void (VKAPI_PTR *PFN_vkCmdSetDiscardRectangleEXT)(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles);

10502

10503

#ifndef VK_NO_PROTOTYPES

10504

VKAPI_ATTR void VKAPI_CALL vkCmdSetDiscardRectangleEXT(

10505

VkCommandBuffer commandBuffer,

10506

uint32_t firstDiscardRectangle,

10507

uint32_t discardRectangleCount,

10508

const VkRect2D* pDiscardRectangles);

10509

#endif

10510

10511

10512

#define VK_EXT_conservative_rasterization 1

10513

#define VK_EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION 1

10514

#define VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME "VK_EXT_conservative_rasterization"

10515

10516

typedef enum VkConservativeRasterizationModeEXT {

10517

VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT = 0,

10518

VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT = 1,

10519

VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT = 2,

10520

VK_CONSERVATIVE_RASTERIZATION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF

10521

} VkConservativeRasterizationModeEXT;

10522

typedef VkFlags VkPipelineRasterizationConservativeStateCreateFlagsEXT;

10523

typedef struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT {

10524

VkStructureType sType;

10525

void* pNext;

10526

float primitiveOverestimationSize;

10527

float maxExtraPrimitiveOverestimationSize;

10528

float extraPrimitiveOverestimationSizeGranularity;

10529

VkBool32 primitiveUnderestimation;

10530

VkBool32 conservativePointAndLineRasterization;

10531

VkBool32 degenerateTrianglesRasterized;

10532

VkBool32 degenerateLinesRasterized;

10533

VkBool32 fullyCoveredFragmentShaderInputVariable;

10534

VkBool32 conservativeRasterizationPostDepthCoverage;

10535

} VkPhysicalDeviceConservativeRasterizationPropertiesEXT;

10536

10537

typedef struct VkPipelineRasterizationConservativeStateCreateInfoEXT {

10538

VkStructureType sType;

10539

const void* pNext;

10540

VkPipelineRasterizationConservativeStateCreateFlagsEXT flags;

10541

VkConservativeRasterizationModeEXT conservativeRasterizationMode;

10542

float extraPrimitiveOverestimationSize;

10543

} VkPipelineRasterizationConservativeStateCreateInfoEXT;

10544

10545

10546

10547

#define VK_EXT_depth_clip_enable 1

10548

#define VK_EXT_DEPTH_CLIP_ENABLE_SPEC_VERSION 1

10549

#define VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME "VK_EXT_depth_clip_enable"

10550

typedef VkFlags VkPipelineRasterizationDepthClipStateCreateFlagsEXT;

10551

typedef struct VkPhysicalDeviceDepthClipEnableFeaturesEXT {

10552

VkStructureType sType;

10553

void* pNext;

10554

VkBool32 depthClipEnable;

10555

} VkPhysicalDeviceDepthClipEnableFeaturesEXT;

10556

10557

typedef struct VkPipelineRasterizationDepthClipStateCreateInfoEXT {

10558

VkStructureType sType;

10559

const void* pNext;

10560

VkPipelineRasterizationDepthClipStateCreateFlagsEXT flags;

10561

VkBool32 depthClipEnable;

10562

} VkPipelineRasterizationDepthClipStateCreateInfoEXT;

10563

10564

10565

10566

#define VK_EXT_swapchain_colorspace 1

10567

#define VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION 4

10568

#define VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME "VK_EXT_swapchain_colorspace"

10569

10570

10571

#define VK_EXT_hdr_metadata 1

10572

#define VK_EXT_HDR_METADATA_SPEC_VERSION 2

10573

#define VK_EXT_HDR_METADATA_EXTENSION_NAME "VK_EXT_hdr_metadata"

10574

typedef struct VkXYColorEXT {

10575

float x;

10576

float y;

10577

} VkXYColorEXT;

10578

10579

typedef struct VkHdrMetadataEXT {

10580

VkStructureType sType;

10581

const void* pNext;

10582

VkXYColorEXT displayPrimaryRed;

10583

VkXYColorEXT displayPrimaryGreen;

10584

VkXYColorEXT displayPrimaryBlue;

10585

VkXYColorEXT whitePoint;

10586

float maxLuminance;

10587

float minLuminance;

10588

float maxContentLightLevel;

10589

float maxFrameAverageLightLevel;

10590

} VkHdrMetadataEXT;

10591

10592

typedef void (VKAPI_PTR *PFN_vkSetHdrMetadataEXT)(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata);

10593

10594

#ifndef VK_NO_PROTOTYPES

10595

VKAPI_ATTR void VKAPI_CALL vkSetHdrMetadataEXT(

10596

VkDevice device,

10597

uint32_t swapchainCount,

10598

const VkSwapchainKHR* pSwapchains,

10599

const VkHdrMetadataEXT* pMetadata);

10600

#endif

10601

10602

10603

#define VK_EXT_external_memory_dma_buf 1

10604

#define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION 1

10605

#define VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME "VK_EXT_external_memory_dma_buf"

10606

10607

10608

#define VK_EXT_queue_family_foreign 1

10609

#define VK_EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION 1

10610

#define VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME "VK_EXT_queue_family_foreign"

10611

#define VK_QUEUE_FAMILY_FOREIGN_EXT (~2U)

10612

10613

10614

#define VK_EXT_debug_utils 1

10615

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugUtilsMessengerEXT)

10616

#define VK_EXT_DEBUG_UTILS_SPEC_VERSION 2

10617

#define VK_EXT_DEBUG_UTILS_EXTENSION_NAME "VK_EXT_debug_utils"

10618

typedef VkFlags VkDebugUtilsMessengerCallbackDataFlagsEXT;

10619

10620

typedef enum VkDebugUtilsMessageSeverityFlagBitsEXT {

10621

VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT = 0x00000001,

10622

VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT = 0x00000010,

10623

VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT = 0x00000100,

10624

VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT = 0x00001000,

10625

VK_DEBUG_UTILS_MESSAGE_SEVERITY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF

10626

} VkDebugUtilsMessageSeverityFlagBitsEXT;

10627

10628

typedef enum VkDebugUtilsMessageTypeFlagBitsEXT {

10629

VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT = 0x00000001,

10630

VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT = 0x00000002,

10631

VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT = 0x00000004,

10632

VK_DEBUG_UTILS_MESSAGE_TYPE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF

10633

} VkDebugUtilsMessageTypeFlagBitsEXT;

10634

typedef VkFlags VkDebugUtilsMessageTypeFlagsEXT;

10635

typedef VkFlags VkDebugUtilsMessageSeverityFlagsEXT;

10636

typedef VkFlags VkDebugUtilsMessengerCreateFlagsEXT;

10637

typedef struct VkDebugUtilsLabelEXT {

10638

VkStructureType sType;

10639

const void* pNext;

10640

const char* pLabelName;

10641

float color[4];

10642

} VkDebugUtilsLabelEXT;

10643

10644

typedef struct VkDebugUtilsObjectNameInfoEXT {

10645

VkStructureType sType;

10646

const void* pNext;

10647

VkObjectType objectType;

10648

uint64_t objectHandle;

10649

const char* pObjectName;

10650

} VkDebugUtilsObjectNameInfoEXT;

10651

10652

typedef struct VkDebugUtilsMessengerCallbackDataEXT {

10653

VkStructureType sType;

10654

const void* pNext;

10655

VkDebugUtilsMessengerCallbackDataFlagsEXT flags;

10656

const char* pMessageIdName;

10657

int32_t messageIdNumber;

10658

const char* pMessage;

10659

uint32_t queueLabelCount;

10660

const VkDebugUtilsLabelEXT* pQueueLabels;

10661

uint32_t cmdBufLabelCount;

10662

const VkDebugUtilsLabelEXT* pCmdBufLabels;

10663

uint32_t objectCount;

10664

const VkDebugUtilsObjectNameInfoEXT* pObjects;

10665

} VkDebugUtilsMessengerCallbackDataEXT;

10666

10667

typedef VkBool32 (VKAPI_PTR *PFN_vkDebugUtilsMessengerCallbackEXT)(

10668

VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,

10669

VkDebugUtilsMessageTypeFlagsEXT messageTypes,

10670

const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData,

10671

void* pUserData);

10672

10673

typedef struct VkDebugUtilsMessengerCreateInfoEXT {

10674

VkStructureType sType;

10675

const void* pNext;

10676

VkDebugUtilsMessengerCreateFlagsEXT flags;

10677

VkDebugUtilsMessageSeverityFlagsEXT messageSeverity;

10678

VkDebugUtilsMessageTypeFlagsEXT messageType;

10679

PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback;

10680

void* pUserData;

10681

} VkDebugUtilsMessengerCreateInfoEXT;

10682

10683

typedef struct VkDebugUtilsObjectTagInfoEXT {

10684

VkStructureType sType;

10685

const void* pNext;

10686

VkObjectType objectType;

10687

uint64_t objectHandle;

10688

uint64_t tagName;

10689

size_t tagSize;

10690

const void* pTag;

10691

} VkDebugUtilsObjectTagInfoEXT;

10692

10693

typedef VkResult (VKAPI_PTR *PFN_vkSetDebugUtilsObjectNameEXT)(VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo);

10694

typedef VkResult (VKAPI_PTR *PFN_vkSetDebugUtilsObjectTagEXT)(VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo);

10695

typedef void (VKAPI_PTR *PFN_vkQueueBeginDebugUtilsLabelEXT)(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo);

10696

typedef void (VKAPI_PTR *PFN_vkQueueEndDebugUtilsLabelEXT)(VkQueue queue);

10697

typedef void (VKAPI_PTR *PFN_vkQueueInsertDebugUtilsLabelEXT)(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo);

10698

typedef void (VKAPI_PTR *PFN_vkCmdBeginDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo);

10699

typedef void (VKAPI_PTR *PFN_vkCmdEndDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer);

10700

typedef void (VKAPI_PTR *PFN_vkCmdInsertDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo);

10701

typedef VkResult (VKAPI_PTR *PFN_vkCreateDebugUtilsMessengerEXT)(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger);

10702

typedef void (VKAPI_PTR *PFN_vkDestroyDebugUtilsMessengerEXT)(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator);

10703

typedef void (VKAPI_PTR *PFN_vkSubmitDebugUtilsMessageEXT)(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData);

10704

10705

#ifndef VK_NO_PROTOTYPES

10706

VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectNameEXT(

10707

VkDevice device,

10708

const VkDebugUtilsObjectNameInfoEXT* pNameInfo);

10709

10710

VKAPI_ATTR VkResult VKAPI_CALL vkSetDebugUtilsObjectTagEXT(

10711

VkDevice device,

10712

const VkDebugUtilsObjectTagInfoEXT* pTagInfo);

10713

10714

VKAPI_ATTR void VKAPI_CALL vkQueueBeginDebugUtilsLabelEXT(

10715

VkQueue queue,

10716

const VkDebugUtilsLabelEXT* pLabelInfo);

10717

10718

VKAPI_ATTR void VKAPI_CALL vkQueueEndDebugUtilsLabelEXT(

10719

VkQueue queue);

10720

10721

VKAPI_ATTR void VKAPI_CALL vkQueueInsertDebugUtilsLabelEXT(

10722

VkQueue queue,

10723

const VkDebugUtilsLabelEXT* pLabelInfo);

10724

10725

VKAPI_ATTR void VKAPI_CALL vkCmdBeginDebugUtilsLabelEXT(

10726

VkCommandBuffer commandBuffer,

10727

const VkDebugUtilsLabelEXT* pLabelInfo);

10728

10729

VKAPI_ATTR void VKAPI_CALL vkCmdEndDebugUtilsLabelEXT(

10730

VkCommandBuffer commandBuffer);

10731

10732

VKAPI_ATTR void VKAPI_CALL vkCmdInsertDebugUtilsLabelEXT(

10733

VkCommandBuffer commandBuffer,

10734

const VkDebugUtilsLabelEXT* pLabelInfo);

10735

10736

VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugUtilsMessengerEXT(

10737

VkInstance instance,

10738

const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo,

10739

const VkAllocationCallbacks* pAllocator,

10740

VkDebugUtilsMessengerEXT* pMessenger);

10741

10742

VKAPI_ATTR void VKAPI_CALL vkDestroyDebugUtilsMessengerEXT(

10743

VkInstance instance,

10744

VkDebugUtilsMessengerEXT messenger,

10745

const VkAllocationCallbacks* pAllocator);

10746

10747

VKAPI_ATTR void VKAPI_CALL vkSubmitDebugUtilsMessageEXT(

10748

VkInstance instance,

10749

VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,

10750

VkDebugUtilsMessageTypeFlagsEXT messageTypes,

10751

const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData);

10752

#endif

10753

10754

10755

#define VK_EXT_sampler_filter_minmax 1

10756

#define VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION 2

10757

#define VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME "VK_EXT_sampler_filter_minmax"

10758

typedef VkSamplerReductionMode VkSamplerReductionModeEXT;

10759

10760

typedef VkSamplerReductionModeCreateInfo VkSamplerReductionModeCreateInfoEXT;

10761

10762

typedef VkPhysicalDeviceSamplerFilterMinmaxProperties VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT;

10763

10764

10765

10766

#define VK_AMD_gpu_shader_int16 1

10767

#define VK_AMD_GPU_SHADER_INT16_SPEC_VERSION 2

10768

#define VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME "VK_AMD_gpu_shader_int16"

10769

10770

10771

#define VK_AMD_mixed_attachment_samples 1

10772

#define VK_AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION 1

10773

#define VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME "VK_AMD_mixed_attachment_samples"

10774

10775

10776

#define VK_AMD_shader_fragment_mask 1

10777

#define VK_AMD_SHADER_FRAGMENT_MASK_SPEC_VERSION 1

10778

#define VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME "VK_AMD_shader_fragment_mask"

10779

10780

10781

#define VK_EXT_inline_uniform_block 1

10782

#define VK_EXT_INLINE_UNIFORM_BLOCK_SPEC_VERSION 1

10783

#define VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME "VK_EXT_inline_uniform_block"

10784

typedef VkPhysicalDeviceInlineUniformBlockFeatures VkPhysicalDeviceInlineUniformBlockFeaturesEXT;

10785

10786

typedef VkPhysicalDeviceInlineUniformBlockProperties VkPhysicalDeviceInlineUniformBlockPropertiesEXT;

10787

10788

typedef VkWriteDescriptorSetInlineUniformBlock VkWriteDescriptorSetInlineUniformBlockEXT;

10789

10790

typedef VkDescriptorPoolInlineUniformBlockCreateInfo VkDescriptorPoolInlineUniformBlockCreateInfoEXT;

10791

10792

10793

10794

#define VK_EXT_shader_stencil_export 1

10795

#define VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION 1

10796

#define VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME "VK_EXT_shader_stencil_export"

10797

10798

10799

#define VK_EXT_sample_locations 1

10800

#define VK_EXT_SAMPLE_LOCATIONS_SPEC_VERSION 1

10801

#define VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME "VK_EXT_sample_locations"

10802

typedef struct VkSampleLocationEXT {

10803

float x;

10804

float y;

10805

} VkSampleLocationEXT;

10806

10807

typedef struct VkSampleLocationsInfoEXT {

10808

VkStructureType sType;

10809

const void* pNext;

10810

VkSampleCountFlagBits sampleLocationsPerPixel;

10811

VkExtent2D sampleLocationGridSize;

10812

uint32_t sampleLocationsCount;

10813

const VkSampleLocationEXT* pSampleLocations;

10814

} VkSampleLocationsInfoEXT;

10815

10816

typedef struct VkAttachmentSampleLocationsEXT {

10817

uint32_t attachmentIndex;

10818

VkSampleLocationsInfoEXT sampleLocationsInfo;

10819

} VkAttachmentSampleLocationsEXT;

10820

10821

typedef struct VkSubpassSampleLocationsEXT {

10822

uint32_t subpassIndex;

10823

VkSampleLocationsInfoEXT sampleLocationsInfo;

10824

} VkSubpassSampleLocationsEXT;

10825

10826

typedef struct VkRenderPassSampleLocationsBeginInfoEXT {

10827

VkStructureType sType;

10828

const void* pNext;

10829

uint32_t attachmentInitialSampleLocationsCount;

10830

const VkAttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations;

10831

uint32_t postSubpassSampleLocationsCount;

10832

const VkSubpassSampleLocationsEXT* pPostSubpassSampleLocations;

10833

} VkRenderPassSampleLocationsBeginInfoEXT;

10834

10835

typedef struct VkPipelineSampleLocationsStateCreateInfoEXT {

10836

VkStructureType sType;

10837

const void* pNext;

10838

VkBool32 sampleLocationsEnable;

10839

VkSampleLocationsInfoEXT sampleLocationsInfo;

10840

} VkPipelineSampleLocationsStateCreateInfoEXT;

10841

10842

typedef struct VkPhysicalDeviceSampleLocationsPropertiesEXT {

10843

VkStructureType sType;

10844

void* pNext;

10845

VkSampleCountFlags sampleLocationSampleCounts;

10846

VkExtent2D maxSampleLocationGridSize;

10847

float sampleLocationCoordinateRange[2];

10848

uint32_t sampleLocationSubPixelBits;

10849

VkBool32 variableSampleLocations;

10850

} VkPhysicalDeviceSampleLocationsPropertiesEXT;

10851

10852

typedef struct VkMultisamplePropertiesEXT {

10853

VkStructureType sType;

10854

void* pNext;

10855

VkExtent2D maxSampleLocationGridSize;

10856

} VkMultisamplePropertiesEXT;

10857

10858

typedef void (VKAPI_PTR *PFN_vkCmdSetSampleLocationsEXT)(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo);

10859

typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT)(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties);

10860

10861

#ifndef VK_NO_PROTOTYPES

10862

VKAPI_ATTR void VKAPI_CALL vkCmdSetSampleLocationsEXT(

10863

VkCommandBuffer commandBuffer,

10864

const VkSampleLocationsInfoEXT* pSampleLocationsInfo);

10865

10866

VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMultisamplePropertiesEXT(

10867

VkPhysicalDevice physicalDevice,

10868

VkSampleCountFlagBits samples,

10869

VkMultisamplePropertiesEXT* pMultisampleProperties);

10870

#endif

10871

10872

10873

#define VK_EXT_blend_operation_advanced 1

10874

#define VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION 2

10875

#define VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME "VK_EXT_blend_operation_advanced"

10876

10877

typedef enum VkBlendOverlapEXT {

10878

VK_BLEND_OVERLAP_UNCORRELATED_EXT = 0,

10879

VK_BLEND_OVERLAP_DISJOINT_EXT = 1,

10880

VK_BLEND_OVERLAP_CONJOINT_EXT = 2,

10881

VK_BLEND_OVERLAP_MAX_ENUM_EXT = 0x7FFFFFFF

10882

} VkBlendOverlapEXT;

10883

typedef struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT {

10884

VkStructureType sType;

10885

void* pNext;

10886

VkBool32 advancedBlendCoherentOperations;

10887

} VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT;

10888

10889

typedef struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT {

10890

VkStructureType sType;

10891

void* pNext;

10892

uint32_t advancedBlendMaxColorAttachments;

10893

VkBool32 advancedBlendIndependentBlend;

10894

VkBool32 advancedBlendNonPremultipliedSrcColor;

10895

VkBool32 advancedBlendNonPremultipliedDstColor;

10896

VkBool32 advancedBlendCorrelatedOverlap;

10897

VkBool32 advancedBlendAllOperations;

10898

} VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT;

10899

10900

typedef struct VkPipelineColorBlendAdvancedStateCreateInfoEXT {

10901

VkStructureType sType;

10902

const void* pNext;

10903

VkBool32 srcPremultiplied;

10904

VkBool32 dstPremultiplied;

10905

VkBlendOverlapEXT blendOverlap;

10906

} VkPipelineColorBlendAdvancedStateCreateInfoEXT;

10907

10908

10909

10910

#define VK_NV_fragment_coverage_to_color 1

10911

#define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION 1

10912

#define VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME "VK_NV_fragment_coverage_to_color"

10913

typedef VkFlags VkPipelineCoverageToColorStateCreateFlagsNV;

10914

typedef struct VkPipelineCoverageToColorStateCreateInfoNV {

10915

VkStructureType sType;

10916

const void* pNext;

10917

VkPipelineCoverageToColorStateCreateFlagsNV flags;

10918

VkBool32 coverageToColorEnable;

10919

uint32_t coverageToColorLocation;

10920

} VkPipelineCoverageToColorStateCreateInfoNV;

10921

10922

10923

10924

#define VK_NV_framebuffer_mixed_samples 1

10925

#define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION 1

10926

#define VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME "VK_NV_framebuffer_mixed_samples"

10927

10928

typedef enum VkCoverageModulationModeNV {

10929

VK_COVERAGE_MODULATION_MODE_NONE_NV = 0,

10930

VK_COVERAGE_MODULATION_MODE_RGB_NV = 1,

10931

VK_COVERAGE_MODULATION_MODE_ALPHA_NV = 2,

10932

VK_COVERAGE_MODULATION_MODE_RGBA_NV = 3,

10933

VK_COVERAGE_MODULATION_MODE_MAX_ENUM_NV = 0x7FFFFFFF

10934

} VkCoverageModulationModeNV;

10935

typedef VkFlags VkPipelineCoverageModulationStateCreateFlagsNV;

10936

typedef struct VkPipelineCoverageModulationStateCreateInfoNV {

10937

VkStructureType sType;

10938

const void* pNext;

10939

VkPipelineCoverageModulationStateCreateFlagsNV flags;

10940

VkCoverageModulationModeNV coverageModulationMode;

10941

VkBool32 coverageModulationTableEnable;

10942

uint32_t coverageModulationTableCount;

10943

const float* pCoverageModulationTable;

10944

} VkPipelineCoverageModulationStateCreateInfoNV;

10945

10946

10947

10948

#define VK_NV_fill_rectangle 1

10949

#define VK_NV_FILL_RECTANGLE_SPEC_VERSION 1

10950

#define VK_NV_FILL_RECTANGLE_EXTENSION_NAME "VK_NV_fill_rectangle"

10951

10952

10953

#define VK_NV_shader_sm_builtins 1

10954

#define VK_NV_SHADER_SM_BUILTINS_SPEC_VERSION 1

10955

#define VK_NV_SHADER_SM_BUILTINS_EXTENSION_NAME "VK_NV_shader_sm_builtins"

10956

typedef struct VkPhysicalDeviceShaderSMBuiltinsPropertiesNV {

10957

VkStructureType sType;

10958

void* pNext;

10959

uint32_t shaderSMCount;

10960

uint32_t shaderWarpsPerSM;

10961

} VkPhysicalDeviceShaderSMBuiltinsPropertiesNV;

10962

10963

typedef struct VkPhysicalDeviceShaderSMBuiltinsFeaturesNV {

10964

VkStructureType sType;

10965

void* pNext;

10966

VkBool32 shaderSMBuiltins;

10967

} VkPhysicalDeviceShaderSMBuiltinsFeaturesNV;

10968

10969

10970

10971

#define VK_EXT_post_depth_coverage 1

10972

#define VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION 1

10973

#define VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME "VK_EXT_post_depth_coverage"

10974

10975

10976

#define VK_EXT_image_drm_format_modifier 1

10977

#define VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_SPEC_VERSION 2

10978

#define VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME "VK_EXT_image_drm_format_modifier"

10979

typedef struct VkDrmFormatModifierPropertiesEXT {

10980

uint64_t drmFormatModifier;

10981

uint32_t drmFormatModifierPlaneCount;

10982

VkFormatFeatureFlags drmFormatModifierTilingFeatures;

10983

} VkDrmFormatModifierPropertiesEXT;

10984

10985

typedef struct VkDrmFormatModifierPropertiesListEXT {

10986

VkStructureType sType;

10987

void* pNext;

10988

uint32_t drmFormatModifierCount;

10989

VkDrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties;

10990

} VkDrmFormatModifierPropertiesListEXT;

10991

10992

typedef struct VkPhysicalDeviceImageDrmFormatModifierInfoEXT {

10993

VkStructureType sType;

10994

const void* pNext;

10995

uint64_t drmFormatModifier;

10996

VkSharingMode sharingMode;

10997

uint32_t queueFamilyIndexCount;

10998

const uint32_t* pQueueFamilyIndices;

10999

} VkPhysicalDeviceImageDrmFormatModifierInfoEXT;

11000

11001

typedef struct VkImageDrmFormatModifierListCreateInfoEXT {

11002

VkStructureType sType;

11003

const void* pNext;

11004

uint32_t drmFormatModifierCount;

11005

const uint64_t* pDrmFormatModifiers;

11006

} VkImageDrmFormatModifierListCreateInfoEXT;

11007

11008

typedef struct VkImageDrmFormatModifierExplicitCreateInfoEXT {

11009

VkStructureType sType;

11010

const void* pNext;

11011

uint64_t drmFormatModifier;

11012

uint32_t drmFormatModifierPlaneCount;

11013

const VkSubresourceLayout* pPlaneLayouts;

11014

} VkImageDrmFormatModifierExplicitCreateInfoEXT;

11015

11016

typedef struct VkImageDrmFormatModifierPropertiesEXT {

11017

VkStructureType sType;

11018

void* pNext;

11019

uint64_t drmFormatModifier;

11020

} VkImageDrmFormatModifierPropertiesEXT;

11021

11022

typedef struct VkDrmFormatModifierProperties2EXT {

11023

uint64_t drmFormatModifier;

11024

uint32_t drmFormatModifierPlaneCount;

11025

VkFormatFeatureFlags2 drmFormatModifierTilingFeatures;

11026

} VkDrmFormatModifierProperties2EXT;

11027

11028

typedef struct VkDrmFormatModifierPropertiesList2EXT {

11029

VkStructureType sType;

11030

void* pNext;

11031

uint32_t drmFormatModifierCount;

11032

VkDrmFormatModifierProperties2EXT* pDrmFormatModifierProperties;

11033

} VkDrmFormatModifierPropertiesList2EXT;

11034

11035

typedef VkResult (VKAPI_PTR *PFN_vkGetImageDrmFormatModifierPropertiesEXT)(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties);

11036

11037

#ifndef VK_NO_PROTOTYPES

11038

VKAPI_ATTR VkResult VKAPI_CALL vkGetImageDrmFormatModifierPropertiesEXT(

11039

VkDevice device,

11040

VkImage image,

11041

VkImageDrmFormatModifierPropertiesEXT* pProperties);

11042

#endif

11043

11044

11045

#define VK_EXT_validation_cache 1

11046

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkValidationCacheEXT)

11047

#define VK_EXT_VALIDATION_CACHE_SPEC_VERSION 1

11048

#define VK_EXT_VALIDATION_CACHE_EXTENSION_NAME "VK_EXT_validation_cache"

11049

11050

typedef enum VkValidationCacheHeaderVersionEXT {

11051

VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT = 1,

11052

VK_VALIDATION_CACHE_HEADER_VERSION_MAX_ENUM_EXT = 0x7FFFFFFF

11053

} VkValidationCacheHeaderVersionEXT;

11054

typedef VkFlags VkValidationCacheCreateFlagsEXT;

11055

typedef struct VkValidationCacheCreateInfoEXT {

11056

VkStructureType sType;

11057

const void* pNext;

11058

VkValidationCacheCreateFlagsEXT flags;

11059

size_t initialDataSize;

11060

const void* pInitialData;

11061

} VkValidationCacheCreateInfoEXT;

11062

11063

typedef struct VkShaderModuleValidationCacheCreateInfoEXT {

11064

VkStructureType sType;

11065

const void* pNext;

11066

VkValidationCacheEXT validationCache;

11067

} VkShaderModuleValidationCacheCreateInfoEXT;

11068

11069

typedef VkResult (VKAPI_PTR *PFN_vkCreateValidationCacheEXT)(VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache);

11070

typedef void (VKAPI_PTR *PFN_vkDestroyValidationCacheEXT)(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator);

11071

typedef VkResult (VKAPI_PTR *PFN_vkMergeValidationCachesEXT)(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches);

11072

typedef VkResult (VKAPI_PTR *PFN_vkGetValidationCacheDataEXT)(VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData);

11073

11074

#ifndef VK_NO_PROTOTYPES

11075

VKAPI_ATTR VkResult VKAPI_CALL vkCreateValidationCacheEXT(

11076

VkDevice device,

11077

const VkValidationCacheCreateInfoEXT* pCreateInfo,

11078

const VkAllocationCallbacks* pAllocator,

11079

VkValidationCacheEXT* pValidationCache);

11080

11081

VKAPI_ATTR void VKAPI_CALL vkDestroyValidationCacheEXT(

11082

VkDevice device,

11083

VkValidationCacheEXT validationCache,

11084

const VkAllocationCallbacks* pAllocator);

11085

11086

VKAPI_ATTR VkResult VKAPI_CALL vkMergeValidationCachesEXT(

11087

VkDevice device,

11088

VkValidationCacheEXT dstCache,

11089

uint32_t srcCacheCount,

11090

const VkValidationCacheEXT* pSrcCaches);

11091

11092

VKAPI_ATTR VkResult VKAPI_CALL vkGetValidationCacheDataEXT(

11093

VkDevice device,

11094

VkValidationCacheEXT validationCache,

11095

size_t* pDataSize,

11096

void* pData);

11097

#endif

11098

11099

11100

#define VK_EXT_descriptor_indexing 1

11101

#define VK_EXT_DESCRIPTOR_INDEXING_SPEC_VERSION 2

11102

#define VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME "VK_EXT_descriptor_indexing"

11103

typedef VkDescriptorBindingFlagBits VkDescriptorBindingFlagBitsEXT;

11104

11105

typedef VkDescriptorBindingFlags VkDescriptorBindingFlagsEXT;

11106

11107

typedef VkDescriptorSetLayoutBindingFlagsCreateInfo VkDescriptorSetLayoutBindingFlagsCreateInfoEXT;

11108

11109

typedef VkPhysicalDeviceDescriptorIndexingFeatures VkPhysicalDeviceDescriptorIndexingFeaturesEXT;

11110

11111

typedef VkPhysicalDeviceDescriptorIndexingProperties VkPhysicalDeviceDescriptorIndexingPropertiesEXT;

11112

11113

typedef VkDescriptorSetVariableDescriptorCountAllocateInfo VkDescriptorSetVariableDescriptorCountAllocateInfoEXT;

11114

11115

typedef VkDescriptorSetVariableDescriptorCountLayoutSupport VkDescriptorSetVariableDescriptorCountLayoutSupportEXT;

11116

11117

11118

11119

#define VK_EXT_shader_viewport_index_layer 1

11120

#define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION 1

11121

#define VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME "VK_EXT_shader_viewport_index_layer"

11122

11123

11124

#define VK_NV_shading_rate_image 1

11125

#define VK_NV_SHADING_RATE_IMAGE_SPEC_VERSION 3

11126

#define VK_NV_SHADING_RATE_IMAGE_EXTENSION_NAME "VK_NV_shading_rate_image"

11127

11128

typedef enum VkShadingRatePaletteEntryNV {

11129

VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV = 0,

11130

VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV = 1,

11131

VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV = 2,

11132

VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV = 3,

11133

VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV = 4,

11134

VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV = 5,

11135

VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV = 6,

11136

VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV = 7,

11137

VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV = 8,

11138

VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV = 9,

11139

VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV = 10,

11140

VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV = 11,

11141

VK_SHADING_RATE_PALETTE_ENTRY_MAX_ENUM_NV = 0x7FFFFFFF

11142

} VkShadingRatePaletteEntryNV;

11143

11144

typedef enum VkCoarseSampleOrderTypeNV {

11145

VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV = 0,

11146

VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV = 1,

11147

VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV = 2,

11148

VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV = 3,

11149

VK_COARSE_SAMPLE_ORDER_TYPE_MAX_ENUM_NV = 0x7FFFFFFF

11150

} VkCoarseSampleOrderTypeNV;

11151

typedef struct VkShadingRatePaletteNV {

11152

uint32_t shadingRatePaletteEntryCount;

11153

const VkShadingRatePaletteEntryNV* pShadingRatePaletteEntries;

11154

} VkShadingRatePaletteNV;

11155

11156

typedef struct VkPipelineViewportShadingRateImageStateCreateInfoNV {

11157

VkStructureType sType;

11158

const void* pNext;

11159

VkBool32 shadingRateImageEnable;

11160

uint32_t viewportCount;

11161

const VkShadingRatePaletteNV* pShadingRatePalettes;

11162

} VkPipelineViewportShadingRateImageStateCreateInfoNV;

11163

11164

typedef struct VkPhysicalDeviceShadingRateImageFeaturesNV {

11165

VkStructureType sType;

11166

void* pNext;

11167

VkBool32 shadingRateImage;

11168

VkBool32 shadingRateCoarseSampleOrder;

11169

} VkPhysicalDeviceShadingRateImageFeaturesNV;

11170

11171

typedef struct VkPhysicalDeviceShadingRateImagePropertiesNV {

11172

VkStructureType sType;

11173

void* pNext;

11174

VkExtent2D shadingRateTexelSize;

11175

uint32_t shadingRatePaletteSize;

11176

uint32_t shadingRateMaxCoarseSamples;

11177

} VkPhysicalDeviceShadingRateImagePropertiesNV;

11178

11179

typedef struct VkCoarseSampleLocationNV {

11180

uint32_t pixelX;

11181

uint32_t pixelY;

11182

uint32_t sample;

11183

} VkCoarseSampleLocationNV;

11184

11185

typedef struct VkCoarseSampleOrderCustomNV {

11186

VkShadingRatePaletteEntryNV shadingRate;

11187

uint32_t sampleCount;

11188

uint32_t sampleLocationCount;

11189

const VkCoarseSampleLocationNV* pSampleLocations;

11190

} VkCoarseSampleOrderCustomNV;

11191

11192

typedef struct VkPipelineViewportCoarseSampleOrderStateCreateInfoNV {

11193

VkStructureType sType;

11194

const void* pNext;

11195

VkCoarseSampleOrderTypeNV sampleOrderType;

11196

uint32_t customSampleOrderCount;

11197

const VkCoarseSampleOrderCustomNV* pCustomSampleOrders;

11198

} VkPipelineViewportCoarseSampleOrderStateCreateInfoNV;

11199

11200

typedef void (VKAPI_PTR *PFN_vkCmdBindShadingRateImageNV)(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout);

11201

typedef void (VKAPI_PTR *PFN_vkCmdSetViewportShadingRatePaletteNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes);

11202

typedef void (VKAPI_PTR *PFN_vkCmdSetCoarseSampleOrderNV)(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders);

11203

11204

#ifndef VK_NO_PROTOTYPES

11205

VKAPI_ATTR void VKAPI_CALL vkCmdBindShadingRateImageNV(

11206

VkCommandBuffer commandBuffer,

11207

VkImageView imageView,

11208

VkImageLayout imageLayout);

11209

11210

VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportShadingRatePaletteNV(

11211

VkCommandBuffer commandBuffer,

11212

uint32_t firstViewport,

11213

uint32_t viewportCount,

11214

const VkShadingRatePaletteNV* pShadingRatePalettes);

11215

11216

VKAPI_ATTR void VKAPI_CALL vkCmdSetCoarseSampleOrderNV(

11217

VkCommandBuffer commandBuffer,

11218

VkCoarseSampleOrderTypeNV sampleOrderType,

11219

uint32_t customSampleOrderCount,

11220

const VkCoarseSampleOrderCustomNV* pCustomSampleOrders);

11221

#endif

11222

11223

11224

#define VK_NV_ray_tracing 1

11225

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkAccelerationStructureNV)

11226

#define VK_NV_RAY_TRACING_SPEC_VERSION 3

11227

#define VK_NV_RAY_TRACING_EXTENSION_NAME "VK_NV_ray_tracing"

11228

#define VK_SHADER_UNUSED_KHR (~0U)

11229

#define VK_SHADER_UNUSED_NV VK_SHADER_UNUSED_KHR

11230

11231

typedef enum VkRayTracingShaderGroupTypeKHR {

11232

VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR = 0,

11233

VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR = 1,

11234

VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR = 2,

11235

VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV = VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR,

11236

VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_NV = VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR,

11237

VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV = VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR,

11238

VK_RAY_TRACING_SHADER_GROUP_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF

11239

} VkRayTracingShaderGroupTypeKHR;

11240

typedef VkRayTracingShaderGroupTypeKHR VkRayTracingShaderGroupTypeNV;

11241

11242

11243

typedef enum VkGeometryTypeKHR {

11244

VK_GEOMETRY_TYPE_TRIANGLES_KHR = 0,

11245

VK_GEOMETRY_TYPE_AABBS_KHR = 1,

11246

VK_GEOMETRY_TYPE_INSTANCES_KHR = 2,

11247

VK_GEOMETRY_TYPE_TRIANGLES_NV = VK_GEOMETRY_TYPE_TRIANGLES_KHR,

11248

VK_GEOMETRY_TYPE_AABBS_NV = VK_GEOMETRY_TYPE_AABBS_KHR,

11249

VK_GEOMETRY_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF

11250

} VkGeometryTypeKHR;

11251

typedef VkGeometryTypeKHR VkGeometryTypeNV;

11252

11253

11254

typedef enum VkAccelerationStructureTypeKHR {

11255

VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR = 0,

11256

VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR = 1,

11257

VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR = 2,

11258

VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR,

11259

VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR,

11260

VK_ACCELERATION_STRUCTURE_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF

11261

} VkAccelerationStructureTypeKHR;

11262

typedef VkAccelerationStructureTypeKHR VkAccelerationStructureTypeNV;

11263

11264

11265

typedef enum VkCopyAccelerationStructureModeKHR {

11266

VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR = 0,

11267

VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR = 1,

11268

VK_COPY_ACCELERATION_STRUCTURE_MODE_SERIALIZE_KHR = 2,

11269

VK_COPY_ACCELERATION_STRUCTURE_MODE_DESERIALIZE_KHR = 3,

11270

VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV = VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR,

11271

VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV = VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR,

11272

VK_COPY_ACCELERATION_STRUCTURE_MODE_MAX_ENUM_KHR = 0x7FFFFFFF

11273

} VkCopyAccelerationStructureModeKHR;

11274

typedef VkCopyAccelerationStructureModeKHR VkCopyAccelerationStructureModeNV;

11275

11276

11277

typedef enum VkAccelerationStructureMemoryRequirementsTypeNV {

11278

VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV = 0,

11279

VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV = 1,

11280

VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV = 2,

11281

VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_MAX_ENUM_NV = 0x7FFFFFFF

11282

} VkAccelerationStructureMemoryRequirementsTypeNV;

11283

11284

typedef enum VkGeometryFlagBitsKHR {

11285

VK_GEOMETRY_OPAQUE_BIT_KHR = 0x00000001,

11286

VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR = 0x00000002,

11287

VK_GEOMETRY_OPAQUE_BIT_NV = VK_GEOMETRY_OPAQUE_BIT_KHR,

11288

VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_NV = VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR,

11289

VK_GEOMETRY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF

11290

} VkGeometryFlagBitsKHR;

11291

typedef VkFlags VkGeometryFlagsKHR;

11292

typedef VkGeometryFlagsKHR VkGeometryFlagsNV;

11293

11294

typedef VkGeometryFlagBitsKHR VkGeometryFlagBitsNV;

11295

11296

11297

typedef enum VkGeometryInstanceFlagBitsKHR {

11298

VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR = 0x00000001,

11299

VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR = 0x00000002,

11300

VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR = 0x00000004,

11301

VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR = 0x00000008,

11302

VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR = VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR,

11303

VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NV = VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR,

11304

VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_NV = VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR,

11305

VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_NV = VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR,

11306

VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NV = VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR,

11307

VK_GEOMETRY_INSTANCE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF

11308

} VkGeometryInstanceFlagBitsKHR;

11309

typedef VkFlags VkGeometryInstanceFlagsKHR;

11310

typedef VkGeometryInstanceFlagsKHR VkGeometryInstanceFlagsNV;

11311

11312

typedef VkGeometryInstanceFlagBitsKHR VkGeometryInstanceFlagBitsNV;

11313

11314

11315

typedef enum VkBuildAccelerationStructureFlagBitsKHR {

11316

VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR = 0x00000001,

11317

VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR = 0x00000002,

11318

VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR = 0x00000004,

11319

VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR = 0x00000008,

11320

VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR = 0x00000010,

11321

VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV = 0x00000020,

11322

VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR,

11323

VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR,

11324

VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR,

11325

VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR,

11326

VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR,

11327

VK_BUILD_ACCELERATION_STRUCTURE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF

11328

} VkBuildAccelerationStructureFlagBitsKHR;

11329

typedef VkFlags VkBuildAccelerationStructureFlagsKHR;

11330

typedef VkBuildAccelerationStructureFlagsKHR VkBuildAccelerationStructureFlagsNV;

11331

11332

typedef VkBuildAccelerationStructureFlagBitsKHR VkBuildAccelerationStructureFlagBitsNV;

11333

11334

typedef struct VkRayTracingShaderGroupCreateInfoNV {

11335

VkStructureType sType;

11336

const void* pNext;

11337

VkRayTracingShaderGroupTypeKHR type;

11338

uint32_t generalShader;

11339

uint32_t closestHitShader;

11340

uint32_t anyHitShader;

11341

uint32_t intersectionShader;

11342

} VkRayTracingShaderGroupCreateInfoNV;

11343

11344

typedef struct VkRayTracingPipelineCreateInfoNV {

11345

VkStructureType sType;

11346

const void* pNext;

11347

VkPipelineCreateFlags flags;

11348

uint32_t stageCount;

11349

const VkPipelineShaderStageCreateInfo* pStages;

11350

uint32_t groupCount;

11351

const VkRayTracingShaderGroupCreateInfoNV* pGroups;

11352

uint32_t maxRecursionDepth;

11353

VkPipelineLayout layout;

11354

VkPipeline basePipelineHandle;

11355

int32_t basePipelineIndex;

11356

} VkRayTracingPipelineCreateInfoNV;

11357

11358

typedef struct VkGeometryTrianglesNV {

11359

VkStructureType sType;

11360

const void* pNext;

11361

VkBuffer vertexData;

11362

VkDeviceSize vertexOffset;

11363

uint32_t vertexCount;

11364

VkDeviceSize vertexStride;

11365

VkFormat vertexFormat;

11366

VkBuffer indexData;

11367

VkDeviceSize indexOffset;

11368

uint32_t indexCount;

11369

VkIndexType indexType;

11370

VkBuffer transformData;

11371

VkDeviceSize transformOffset;

11372

} VkGeometryTrianglesNV;

11373

11374

typedef struct VkGeometryAABBNV {

11375

VkStructureType sType;

11376

const void* pNext;

11377

VkBuffer aabbData;

11378

uint32_t numAABBs;

11379

uint32_t stride;

11380

VkDeviceSize offset;

11381

} VkGeometryAABBNV;

11382

11383

typedef struct VkGeometryDataNV {

11384

VkGeometryTrianglesNV triangles;

11385

VkGeometryAABBNV aabbs;

11386

} VkGeometryDataNV;

11387

11388

typedef struct VkGeometryNV {

11389

VkStructureType sType;

11390

const void* pNext;

11391

VkGeometryTypeKHR geometryType;

11392

VkGeometryDataNV geometry;

11393

VkGeometryFlagsKHR flags;

11394

} VkGeometryNV;

11395

11396

typedef struct VkAccelerationStructureInfoNV {

11397

VkStructureType sType;

11398

const void* pNext;

11399

VkAccelerationStructureTypeNV type;

11400

VkBuildAccelerationStructureFlagsNV flags;

11401

uint32_t instanceCount;

11402

uint32_t geometryCount;

11403

const VkGeometryNV* pGeometries;

11404

} VkAccelerationStructureInfoNV;

11405

11406

typedef struct VkAccelerationStructureCreateInfoNV {

11407

VkStructureType sType;

11408

const void* pNext;

11409

VkDeviceSize compactedSize;

11410

VkAccelerationStructureInfoNV info;

11411

} VkAccelerationStructureCreateInfoNV;

11412

11413

typedef struct VkBindAccelerationStructureMemoryInfoNV {

11414

VkStructureType sType;

11415

const void* pNext;

11416

VkAccelerationStructureNV accelerationStructure;

11417

VkDeviceMemory memory;

11418

VkDeviceSize memoryOffset;

11419

uint32_t deviceIndexCount;

11420

const uint32_t* pDeviceIndices;

11421

} VkBindAccelerationStructureMemoryInfoNV;

11422

11423

typedef struct VkWriteDescriptorSetAccelerationStructureNV {

11424

VkStructureType sType;

11425

const void* pNext;

11426

uint32_t accelerationStructureCount;

11427

const VkAccelerationStructureNV* pAccelerationStructures;

11428

} VkWriteDescriptorSetAccelerationStructureNV;

11429

11430

typedef struct VkAccelerationStructureMemoryRequirementsInfoNV {

11431

VkStructureType sType;

11432

const void* pNext;

11433

VkAccelerationStructureMemoryRequirementsTypeNV type;

11434

VkAccelerationStructureNV accelerationStructure;

11435

} VkAccelerationStructureMemoryRequirementsInfoNV;

11436

11437

typedef struct VkPhysicalDeviceRayTracingPropertiesNV {

11438

VkStructureType sType;

11439

void* pNext;

11440

uint32_t shaderGroupHandleSize;

11441

uint32_t maxRecursionDepth;

11442

uint32_t maxShaderGroupStride;

11443

uint32_t shaderGroupBaseAlignment;

11444

uint64_t maxGeometryCount;

11445

uint64_t maxInstanceCount;

11446

uint64_t maxTriangleCount;

11447

uint32_t maxDescriptorSetAccelerationStructures;

11448

} VkPhysicalDeviceRayTracingPropertiesNV;

11449

11450

typedef struct VkTransformMatrixKHR {

11451

float matrix[3][4];

11452

} VkTransformMatrixKHR;

11453

11454

typedef VkTransformMatrixKHR VkTransformMatrixNV;

11455

11456

typedef struct VkAabbPositionsKHR {

11457

float minX;

11458

float minY;

11459

float minZ;

11460

float maxX;

11461

float maxY;

11462

float maxZ;

11463

} VkAabbPositionsKHR;

11464

11465

typedef VkAabbPositionsKHR VkAabbPositionsNV;

11466

11467

typedef struct VkAccelerationStructureInstanceKHR {

11468

VkTransformMatrixKHR transform;

11469

uint32_t instanceCustomIndex:24;

11470

uint32_t mask:8;

11471

uint32_t instanceShaderBindingTableRecordOffset:24;

11472

VkGeometryInstanceFlagsKHR flags:8;

11473

uint64_t accelerationStructureReference;

11474

} VkAccelerationStructureInstanceKHR;

11475

11476

typedef VkAccelerationStructureInstanceKHR VkAccelerationStructureInstanceNV;

11477

11478

typedef VkResult (VKAPI_PTR *PFN_vkCreateAccelerationStructureNV)(VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure);

11479

typedef void (VKAPI_PTR *PFN_vkDestroyAccelerationStructureNV)(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator);

11480

typedef void (VKAPI_PTR *PFN_vkGetAccelerationStructureMemoryRequirementsNV)(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements);

11481

typedef VkResult (VKAPI_PTR *PFN_vkBindAccelerationStructureMemoryNV)(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos);

11482

typedef void (VKAPI_PTR *PFN_vkCmdBuildAccelerationStructureNV)(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset);

11483

typedef void (VKAPI_PTR *PFN_vkCmdCopyAccelerationStructureNV)(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode);

11484

typedef void (VKAPI_PTR *PFN_vkCmdTraceRaysNV)(VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth);

11485

typedef VkResult (VKAPI_PTR *PFN_vkCreateRayTracingPipelinesNV)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);

11486

typedef VkResult (VKAPI_PTR *PFN_vkGetRayTracingShaderGroupHandlesKHR)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData);

11487

typedef VkResult (VKAPI_PTR *PFN_vkGetRayTracingShaderGroupHandlesNV)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData);

11488

typedef VkResult (VKAPI_PTR *PFN_vkGetAccelerationStructureHandleNV)(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData);

11489

typedef void (VKAPI_PTR *PFN_vkCmdWriteAccelerationStructuresPropertiesNV)(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery);

11490

typedef VkResult (VKAPI_PTR *PFN_vkCompileDeferredNV)(VkDevice device, VkPipeline pipeline, uint32_t shader);

11491

11492

#ifndef VK_NO_PROTOTYPES

11493

VKAPI_ATTR VkResult VKAPI_CALL vkCreateAccelerationStructureNV(

11494

VkDevice device,

11495

const VkAccelerationStructureCreateInfoNV* pCreateInfo,

11496

const VkAllocationCallbacks* pAllocator,

11497

VkAccelerationStructureNV* pAccelerationStructure);

11498

11499

VKAPI_ATTR void VKAPI_CALL vkDestroyAccelerationStructureNV(

11500

VkDevice device,

11501

VkAccelerationStructureNV accelerationStructure,

11502

const VkAllocationCallbacks* pAllocator);

11503

11504

VKAPI_ATTR void VKAPI_CALL vkGetAccelerationStructureMemoryRequirementsNV(

11505

VkDevice device,

11506

const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo,

11507

VkMemoryRequirements2KHR* pMemoryRequirements);

11508

11509

VKAPI_ATTR VkResult VKAPI_CALL vkBindAccelerationStructureMemoryNV(

11510

VkDevice device,

11511

uint32_t bindInfoCount,

11512

const VkBindAccelerationStructureMemoryInfoNV* pBindInfos);

11513

11514

VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructureNV(

11515

VkCommandBuffer commandBuffer,

11516

const VkAccelerationStructureInfoNV* pInfo,

11517

VkBuffer instanceData,

11518

VkDeviceSize instanceOffset,

11519

VkBool32 update,

11520

VkAccelerationStructureNV dst,

11521

VkAccelerationStructureNV src,

11522

VkBuffer scratch,

11523

VkDeviceSize scratchOffset);

11524

11525

VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureNV(

11526

VkCommandBuffer commandBuffer,

11527

VkAccelerationStructureNV dst,

11528

VkAccelerationStructureNV src,

11529

VkCopyAccelerationStructureModeKHR mode);

11530

11531

VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysNV(

11532

VkCommandBuffer commandBuffer,

11533

VkBuffer raygenShaderBindingTableBuffer,

11534

VkDeviceSize raygenShaderBindingOffset,

11535

VkBuffer missShaderBindingTableBuffer,

11536

VkDeviceSize missShaderBindingOffset,

11537

VkDeviceSize missShaderBindingStride,

11538

VkBuffer hitShaderBindingTableBuffer,

11539

VkDeviceSize hitShaderBindingOffset,

11540

VkDeviceSize hitShaderBindingStride,

11541

VkBuffer callableShaderBindingTableBuffer,

11542

VkDeviceSize callableShaderBindingOffset,

11543

VkDeviceSize callableShaderBindingStride,

11544

uint32_t width,

11545

uint32_t height,

11546

uint32_t depth);

11547

11548

VKAPI_ATTR VkResult VKAPI_CALL vkCreateRayTracingPipelinesNV(

11549

VkDevice device,

11550

VkPipelineCache pipelineCache,

11551

uint32_t createInfoCount,

11552

const VkRayTracingPipelineCreateInfoNV* pCreateInfos,

11553

const VkAllocationCallbacks* pAllocator,

11554

VkPipeline* pPipelines);

11555

11556

VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingShaderGroupHandlesKHR(

11557

VkDevice device,

11558

VkPipeline pipeline,

11559

uint32_t firstGroup,

11560

uint32_t groupCount,

11561

size_t dataSize,

11562

void* pData);

11563

11564

VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingShaderGroupHandlesNV(

11565

VkDevice device,

11566

VkPipeline pipeline,

11567

uint32_t firstGroup,

11568

uint32_t groupCount,

11569

size_t dataSize,

11570

void* pData);

11571

11572

VKAPI_ATTR VkResult VKAPI_CALL vkGetAccelerationStructureHandleNV(

11573

VkDevice device,

11574

VkAccelerationStructureNV accelerationStructure,

11575

size_t dataSize,

11576

void* pData);

11577

11578

VKAPI_ATTR void VKAPI_CALL vkCmdWriteAccelerationStructuresPropertiesNV(

11579

VkCommandBuffer commandBuffer,

11580

uint32_t accelerationStructureCount,

11581

const VkAccelerationStructureNV* pAccelerationStructures,

11582

VkQueryType queryType,

11583

VkQueryPool queryPool,

11584

uint32_t firstQuery);

11585

11586

VKAPI_ATTR VkResult VKAPI_CALL vkCompileDeferredNV(

11587

VkDevice device,

11588

VkPipeline pipeline,

11589

uint32_t shader);

11590

#endif

11591

11592

11593

#define VK_NV_representative_fragment_test 1

11594

#define VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION 2

11595

#define VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME "VK_NV_representative_fragment_test"

11596

typedef struct VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV {

11597

VkStructureType sType;

11598

void* pNext;

11599

VkBool32 representativeFragmentTest;

11600

} VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV;

11601

11602

typedef struct VkPipelineRepresentativeFragmentTestStateCreateInfoNV {

11603

VkStructureType sType;

11604

const void* pNext;

11605

VkBool32 representativeFragmentTestEnable;

11606

} VkPipelineRepresentativeFragmentTestStateCreateInfoNV;

11607

11608

11609

11610

#define VK_EXT_filter_cubic 1

11611

#define VK_EXT_FILTER_CUBIC_SPEC_VERSION 3

11612

#define VK_EXT_FILTER_CUBIC_EXTENSION_NAME "VK_EXT_filter_cubic"

11613

typedef struct VkPhysicalDeviceImageViewImageFormatInfoEXT {

11614

VkStructureType sType;

11615

void* pNext;

11616

VkImageViewType imageViewType;

11617

} VkPhysicalDeviceImageViewImageFormatInfoEXT;

11618

11619

typedef struct VkFilterCubicImageViewImageFormatPropertiesEXT {

11620

VkStructureType sType;

11621

void* pNext;

11622

VkBool32 filterCubic;

11623

VkBool32 filterCubicMinmax;

11624

} VkFilterCubicImageViewImageFormatPropertiesEXT;

11625

11626

11627

11628

#define VK_QCOM_render_pass_shader_resolve 1

11629

#define VK_QCOM_RENDER_PASS_SHADER_RESOLVE_SPEC_VERSION 4

11630

#define VK_QCOM_RENDER_PASS_SHADER_RESOLVE_EXTENSION_NAME "VK_QCOM_render_pass_shader_resolve"

11631

11632

11633

#define VK_EXT_global_priority 1

11634

#define VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION 2

11635

#define VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME "VK_EXT_global_priority"

11636

typedef VkQueueGlobalPriorityKHR VkQueueGlobalPriorityEXT;

11637

11638

typedef VkDeviceQueueGlobalPriorityCreateInfoKHR VkDeviceQueueGlobalPriorityCreateInfoEXT;

11639

11640

11641

11642

#define VK_EXT_external_memory_host 1

11643

#define VK_EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION 1

11644

#define VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME "VK_EXT_external_memory_host"

11645

typedef struct VkImportMemoryHostPointerInfoEXT {

11646

VkStructureType sType;

11647

const void* pNext;

11648

VkExternalMemoryHandleTypeFlagBits handleType;

11649

void* pHostPointer;

11650

} VkImportMemoryHostPointerInfoEXT;

11651

11652

typedef struct VkMemoryHostPointerPropertiesEXT {

11653

VkStructureType sType;

11654

void* pNext;

11655

uint32_t memoryTypeBits;

11656

} VkMemoryHostPointerPropertiesEXT;

11657

11658

typedef struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT {

11659

VkStructureType sType;

11660

void* pNext;

11661

VkDeviceSize minImportedHostPointerAlignment;

11662

} VkPhysicalDeviceExternalMemoryHostPropertiesEXT;

11663

11664

typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryHostPointerPropertiesEXT)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties);

11665

11666

#ifndef VK_NO_PROTOTYPES

11667

VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryHostPointerPropertiesEXT(

11668

VkDevice device,

11669

VkExternalMemoryHandleTypeFlagBits handleType,

11670

const void* pHostPointer,

11671

VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties);

11672

#endif

11673

11674

11675

#define VK_AMD_buffer_marker 1

11676

#define VK_AMD_BUFFER_MARKER_SPEC_VERSION 1

11677

#define VK_AMD_BUFFER_MARKER_EXTENSION_NAME "VK_AMD_buffer_marker"

11678

typedef void (VKAPI_PTR *PFN_vkCmdWriteBufferMarkerAMD)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker);

11679

11680

#ifndef VK_NO_PROTOTYPES

11681

VKAPI_ATTR void VKAPI_CALL vkCmdWriteBufferMarkerAMD(

11682

VkCommandBuffer commandBuffer,

11683

VkPipelineStageFlagBits pipelineStage,

11684

VkBuffer dstBuffer,

11685

VkDeviceSize dstOffset,

11686

uint32_t marker);

11687

#endif

11688

11689

11690

#define VK_AMD_pipeline_compiler_control 1

11691

#define VK_AMD_PIPELINE_COMPILER_CONTROL_SPEC_VERSION 1

11692

#define VK_AMD_PIPELINE_COMPILER_CONTROL_EXTENSION_NAME "VK_AMD_pipeline_compiler_control"

11693

11694

typedef enum VkPipelineCompilerControlFlagBitsAMD {

11695

VK_PIPELINE_COMPILER_CONTROL_FLAG_BITS_MAX_ENUM_AMD = 0x7FFFFFFF

11696

} VkPipelineCompilerControlFlagBitsAMD;

11697

typedef VkFlags VkPipelineCompilerControlFlagsAMD;

11698

typedef struct VkPipelineCompilerControlCreateInfoAMD {

11699

VkStructureType sType;

11700

const void* pNext;

11701

VkPipelineCompilerControlFlagsAMD compilerControlFlags;

11702

} VkPipelineCompilerControlCreateInfoAMD;

11703

11704

11705

11706

#define VK_EXT_calibrated_timestamps 1

11707

#define VK_EXT_CALIBRATED_TIMESTAMPS_SPEC_VERSION 2

11708

#define VK_EXT_CALIBRATED_TIMESTAMPS_EXTENSION_NAME "VK_EXT_calibrated_timestamps"

11709

11710

typedef enum VkTimeDomainEXT {

11711

VK_TIME_DOMAIN_DEVICE_EXT = 0,

11712

VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT = 1,

11713

VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT = 2,

11714

VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT = 3,

11715

VK_TIME_DOMAIN_MAX_ENUM_EXT = 0x7FFFFFFF

11716

} VkTimeDomainEXT;

11717

typedef struct VkCalibratedTimestampInfoEXT {

11718

VkStructureType sType;

11719

const void* pNext;

11720

VkTimeDomainEXT timeDomain;

11721

} VkCalibratedTimestampInfoEXT;

11722

11723

typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT)(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains);

11724

typedef VkResult (VKAPI_PTR *PFN_vkGetCalibratedTimestampsEXT)(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation);

11725

11726

#ifndef VK_NO_PROTOTYPES

11727

VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(

11728

VkPhysicalDevice physicalDevice,

11729

uint32_t* pTimeDomainCount,

11730

VkTimeDomainEXT* pTimeDomains);

11731

11732

VKAPI_ATTR VkResult VKAPI_CALL vkGetCalibratedTimestampsEXT(

11733

VkDevice device,

11734

uint32_t timestampCount,

11735

const VkCalibratedTimestampInfoEXT* pTimestampInfos,

11736

uint64_t* pTimestamps,

11737

uint64_t* pMaxDeviation);

11738

#endif

11739

11740

11741

#define VK_AMD_shader_core_properties 1

11742

#define VK_AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION 2

11743

#define VK_AMD_SHADER_CORE_PROPERTIES_EXTENSION_NAME "VK_AMD_shader_core_properties"

11744

typedef struct VkPhysicalDeviceShaderCorePropertiesAMD {

11745

VkStructureType sType;

11746

void* pNext;

11747

uint32_t shaderEngineCount;

11748

uint32_t shaderArraysPerEngineCount;

11749

uint32_t computeUnitsPerShaderArray;

11750

uint32_t simdPerComputeUnit;

11751

uint32_t wavefrontsPerSimd;

11752

uint32_t wavefrontSize;

11753

uint32_t sgprsPerSimd;

11754

uint32_t minSgprAllocation;

11755

uint32_t maxSgprAllocation;

11756

uint32_t sgprAllocationGranularity;

11757

uint32_t vgprsPerSimd;

11758

uint32_t minVgprAllocation;

11759

uint32_t maxVgprAllocation;

11760

uint32_t vgprAllocationGranularity;

11761

} VkPhysicalDeviceShaderCorePropertiesAMD;

11762

11763

11764

11765

#define VK_AMD_memory_overallocation_behavior 1

11766

#define VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_SPEC_VERSION 1

11767

#define VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_EXTENSION_NAME "VK_AMD_memory_overallocation_behavior"

11768

11769

typedef enum VkMemoryOverallocationBehaviorAMD {

11770

VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD = 0,

11771

VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD = 1,

11772

VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD = 2,

11773

VK_MEMORY_OVERALLOCATION_BEHAVIOR_MAX_ENUM_AMD = 0x7FFFFFFF

11774

} VkMemoryOverallocationBehaviorAMD;

11775

typedef struct VkDeviceMemoryOverallocationCreateInfoAMD {

11776

VkStructureType sType;

11777

const void* pNext;

11778

VkMemoryOverallocationBehaviorAMD overallocationBehavior;

11779

} VkDeviceMemoryOverallocationCreateInfoAMD;

11780

11781

11782

11783

#define VK_EXT_vertex_attribute_divisor 1

11784

#define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION 3

11785

#define VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME "VK_EXT_vertex_attribute_divisor"

11786

typedef struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT {

11787

VkStructureType sType;

11788

void* pNext;

11789

uint32_t maxVertexAttribDivisor;

11790

} VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT;

11791

11792

typedef struct VkVertexInputBindingDivisorDescriptionEXT {

11793

uint32_t binding;

11794

uint32_t divisor;

11795

} VkVertexInputBindingDivisorDescriptionEXT;

11796

11797

typedef struct VkPipelineVertexInputDivisorStateCreateInfoEXT {

11798

VkStructureType sType;

11799

const void* pNext;

11800

uint32_t vertexBindingDivisorCount;

11801

const VkVertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors;

11802

} VkPipelineVertexInputDivisorStateCreateInfoEXT;

11803

11804

typedef struct VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT {

11805

VkStructureType sType;

11806

void* pNext;

11807

VkBool32 vertexAttributeInstanceRateDivisor;

11808

VkBool32 vertexAttributeInstanceRateZeroDivisor;

11809

} VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT;

11810

11811

11812

11813

#define VK_EXT_pipeline_creation_feedback 1

11814

#define VK_EXT_PIPELINE_CREATION_FEEDBACK_SPEC_VERSION 1

11815

#define VK_EXT_PIPELINE_CREATION_FEEDBACK_EXTENSION_NAME "VK_EXT_pipeline_creation_feedback"

11816

typedef VkPipelineCreationFeedbackFlagBits VkPipelineCreationFeedbackFlagBitsEXT;

11817

11818

typedef VkPipelineCreationFeedbackFlags VkPipelineCreationFeedbackFlagsEXT;

11819

11820

typedef VkPipelineCreationFeedbackCreateInfo VkPipelineCreationFeedbackCreateInfoEXT;

11821

11822

typedef VkPipelineCreationFeedback VkPipelineCreationFeedbackEXT;

11823

11824

11825

11826

#define VK_NV_shader_subgroup_partitioned 1

11827

#define VK_NV_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION 1

11828

#define VK_NV_SHADER_SUBGROUP_PARTITIONED_EXTENSION_NAME "VK_NV_shader_subgroup_partitioned"

11829

11830

11831

#define VK_NV_compute_shader_derivatives 1

11832

#define VK_NV_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION 1

11833

#define VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME "VK_NV_compute_shader_derivatives"

11834

typedef struct VkPhysicalDeviceComputeShaderDerivativesFeaturesNV {

11835

VkStructureType sType;

11836

void* pNext;

11837

VkBool32 computeDerivativeGroupQuads;

11838

VkBool32 computeDerivativeGroupLinear;

11839

} VkPhysicalDeviceComputeShaderDerivativesFeaturesNV;

11840

11841

11842

11843

#define VK_NV_mesh_shader 1

11844

#define VK_NV_MESH_SHADER_SPEC_VERSION 1

11845

#define VK_NV_MESH_SHADER_EXTENSION_NAME "VK_NV_mesh_shader"

11846

typedef struct VkPhysicalDeviceMeshShaderFeaturesNV {

11847

VkStructureType sType;

11848

void* pNext;

11849

VkBool32 taskShader;

11850

VkBool32 meshShader;

11851

} VkPhysicalDeviceMeshShaderFeaturesNV;

11852

11853

typedef struct VkPhysicalDeviceMeshShaderPropertiesNV {

11854

VkStructureType sType;

11855

void* pNext;

11856

uint32_t maxDrawMeshTasksCount;

11857

uint32_t maxTaskWorkGroupInvocations;

11858

uint32_t maxTaskWorkGroupSize[3];

11859

uint32_t maxTaskTotalMemorySize;

11860

uint32_t maxTaskOutputCount;

11861

uint32_t maxMeshWorkGroupInvocations;

11862

uint32_t maxMeshWorkGroupSize[3];

11863

uint32_t maxMeshTotalMemorySize;

11864

uint32_t maxMeshOutputVertices;

11865

uint32_t maxMeshOutputPrimitives;

11866

uint32_t maxMeshMultiviewViewCount;

11867

uint32_t meshOutputPerVertexGranularity;

11868

uint32_t meshOutputPerPrimitiveGranularity;

11869

} VkPhysicalDeviceMeshShaderPropertiesNV;

11870

11871

typedef struct VkDrawMeshTasksIndirectCommandNV {

11872

uint32_t taskCount;

11873

uint32_t firstTask;

11874

} VkDrawMeshTasksIndirectCommandNV;

11875

11876

typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksNV)(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask);

11877

typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksIndirectNV)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);

11878

typedef void (VKAPI_PTR *PFN_vkCmdDrawMeshTasksIndirectCountNV)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride);

11879

11880

#ifndef VK_NO_PROTOTYPES

11881

VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksNV(

11882

VkCommandBuffer commandBuffer,

11883

uint32_t taskCount,

11884

uint32_t firstTask);

11885

11886

VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectNV(

11887

VkCommandBuffer commandBuffer,

11888

VkBuffer buffer,

11889

VkDeviceSize offset,

11890

uint32_t drawCount,

11891

uint32_t stride);

11892

11893

VKAPI_ATTR void VKAPI_CALL vkCmdDrawMeshTasksIndirectCountNV(

11894

VkCommandBuffer commandBuffer,

11895

VkBuffer buffer,

11896

VkDeviceSize offset,

11897

VkBuffer countBuffer,

11898

VkDeviceSize countBufferOffset,

11899

uint32_t maxDrawCount,

11900

uint32_t stride);

11901

#endif

11902

11903

11904

#define VK_NV_fragment_shader_barycentric 1

11905

#define VK_NV_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION 1

11906

#define VK_NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME "VK_NV_fragment_shader_barycentric"

11907

typedef struct VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV {

11908

VkStructureType sType;

11909

void* pNext;

11910

VkBool32 fragmentShaderBarycentric;

11911

} VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV;

11912

11913

11914

11915

#define VK_NV_shader_image_footprint 1

11916

#define VK_NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION 2

11917

#define VK_NV_SHADER_IMAGE_FOOTPRINT_EXTENSION_NAME "VK_NV_shader_image_footprint"

11918

typedef struct VkPhysicalDeviceShaderImageFootprintFeaturesNV {

11919

VkStructureType sType;

11920

void* pNext;

11921

VkBool32 imageFootprint;

11922

} VkPhysicalDeviceShaderImageFootprintFeaturesNV;

11923

11924

11925

11926

#define VK_NV_scissor_exclusive 1

11927

#define VK_NV_SCISSOR_EXCLUSIVE_SPEC_VERSION 1

11928

#define VK_NV_SCISSOR_EXCLUSIVE_EXTENSION_NAME "VK_NV_scissor_exclusive"

11929

typedef struct VkPipelineViewportExclusiveScissorStateCreateInfoNV {

11930

VkStructureType sType;

11931

const void* pNext;

11932

uint32_t exclusiveScissorCount;

11933

const VkRect2D* pExclusiveScissors;

11934

} VkPipelineViewportExclusiveScissorStateCreateInfoNV;

11935

11936

typedef struct VkPhysicalDeviceExclusiveScissorFeaturesNV {

11937

VkStructureType sType;

11938

void* pNext;

11939

VkBool32 exclusiveScissor;

11940

} VkPhysicalDeviceExclusiveScissorFeaturesNV;

11941

11942

typedef void (VKAPI_PTR *PFN_vkCmdSetExclusiveScissorNV)(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors);

11943

11944

#ifndef VK_NO_PROTOTYPES

11945

VKAPI_ATTR void VKAPI_CALL vkCmdSetExclusiveScissorNV(

11946

VkCommandBuffer commandBuffer,

11947

uint32_t firstExclusiveScissor,

11948

uint32_t exclusiveScissorCount,

11949

const VkRect2D* pExclusiveScissors);

11950

#endif

11951

11952

11953

#define VK_NV_device_diagnostic_checkpoints 1

11954

#define VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_SPEC_VERSION 2

11955

#define VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_EXTENSION_NAME "VK_NV_device_diagnostic_checkpoints"

11956

typedef struct VkQueueFamilyCheckpointPropertiesNV {

11957

VkStructureType sType;

11958

void* pNext;

11959

VkPipelineStageFlags checkpointExecutionStageMask;

11960

} VkQueueFamilyCheckpointPropertiesNV;

11961

11962

typedef struct VkCheckpointDataNV {

11963

VkStructureType sType;

11964

void* pNext;

11965

VkPipelineStageFlagBits stage;

11966

void* pCheckpointMarker;

11967

} VkCheckpointDataNV;

11968

11969

typedef void (VKAPI_PTR *PFN_vkCmdSetCheckpointNV)(VkCommandBuffer commandBuffer, const void* pCheckpointMarker);

11970

typedef void (VKAPI_PTR *PFN_vkGetQueueCheckpointDataNV)(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData);

11971

11972

#ifndef VK_NO_PROTOTYPES

11973

VKAPI_ATTR void VKAPI_CALL vkCmdSetCheckpointNV(

11974

VkCommandBuffer commandBuffer,

11975

const void* pCheckpointMarker);

11976

11977

VKAPI_ATTR void VKAPI_CALL vkGetQueueCheckpointDataNV(

11978

VkQueue queue,

11979

uint32_t* pCheckpointDataCount,

11980

VkCheckpointDataNV* pCheckpointData);

11981

#endif

11982

11983

11984

#define VK_INTEL_shader_integer_functions2 1

11985

#define VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_SPEC_VERSION 1

11986

#define VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_EXTENSION_NAME "VK_INTEL_shader_integer_functions2"

11987

typedef struct VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {

11988

VkStructureType sType;

11989

void* pNext;

11990

VkBool32 shaderIntegerFunctions2;

11991

} VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;

11992

11993

11994

11995

#define VK_INTEL_performance_query 1

11996

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPerformanceConfigurationINTEL)

11997

#define VK_INTEL_PERFORMANCE_QUERY_SPEC_VERSION 2

11998

#define VK_INTEL_PERFORMANCE_QUERY_EXTENSION_NAME "VK_INTEL_performance_query"

11999

12000

typedef enum VkPerformanceConfigurationTypeINTEL {

12001

VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL = 0,

12002

VK_PERFORMANCE_CONFIGURATION_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF

12003

} VkPerformanceConfigurationTypeINTEL;

12004

12005

typedef enum VkQueryPoolSamplingModeINTEL {

12006

VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL = 0,

12007

VK_QUERY_POOL_SAMPLING_MODE_MAX_ENUM_INTEL = 0x7FFFFFFF

12008

} VkQueryPoolSamplingModeINTEL;

12009

12010

typedef enum VkPerformanceOverrideTypeINTEL {

12011

VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL = 0,

12012

VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL = 1,

12013

VK_PERFORMANCE_OVERRIDE_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF

12014

} VkPerformanceOverrideTypeINTEL;

12015

12016

typedef enum VkPerformanceParameterTypeINTEL {

12017

VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL = 0,

12018

VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL = 1,

12019

VK_PERFORMANCE_PARAMETER_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF

12020

} VkPerformanceParameterTypeINTEL;

12021

12022

typedef enum VkPerformanceValueTypeINTEL {

12023

VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL = 0,

12024

VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL = 1,

12025

VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL = 2,

12026

VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL = 3,

12027

VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL = 4,

12028

VK_PERFORMANCE_VALUE_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF

12029

} VkPerformanceValueTypeINTEL;

12030

typedef union VkPerformanceValueDataINTEL {

12031

uint32_t value32;

12032

uint64_t value64;

12033

float valueFloat;

12034

VkBool32 valueBool;

12035

const char* valueString;

12036

} VkPerformanceValueDataINTEL;

12037

12038

typedef struct VkPerformanceValueINTEL {

12039

VkPerformanceValueTypeINTEL type;

12040

VkPerformanceValueDataINTEL data;

12041

} VkPerformanceValueINTEL;

12042

12043

typedef struct VkInitializePerformanceApiInfoINTEL {

12044

VkStructureType sType;

12045

const void* pNext;

12046

void* pUserData;

12047

} VkInitializePerformanceApiInfoINTEL;

12048

12049

typedef struct VkQueryPoolPerformanceQueryCreateInfoINTEL {

12050

VkStructureType sType;

12051

const void* pNext;

12052

VkQueryPoolSamplingModeINTEL performanceCountersSampling;

12053

} VkQueryPoolPerformanceQueryCreateInfoINTEL;

12054

12055

typedef VkQueryPoolPerformanceQueryCreateInfoINTEL VkQueryPoolCreateInfoINTEL;

12056

12057

typedef struct VkPerformanceMarkerInfoINTEL {

12058

VkStructureType sType;

12059

const void* pNext;

12060

uint64_t marker;

12061

} VkPerformanceMarkerInfoINTEL;

12062

12063

typedef struct VkPerformanceStreamMarkerInfoINTEL {

12064

VkStructureType sType;

12065

const void* pNext;

12066

uint32_t marker;

12067

} VkPerformanceStreamMarkerInfoINTEL;

12068

12069

typedef struct VkPerformanceOverrideInfoINTEL {

12070

VkStructureType sType;

12071

const void* pNext;

12072

VkPerformanceOverrideTypeINTEL type;

12073

VkBool32 enable;

12074

uint64_t parameter;

12075

} VkPerformanceOverrideInfoINTEL;

12076

12077

typedef struct VkPerformanceConfigurationAcquireInfoINTEL {

12078

VkStructureType sType;

12079

const void* pNext;

12080

VkPerformanceConfigurationTypeINTEL type;

12081

} VkPerformanceConfigurationAcquireInfoINTEL;

12082

12083

typedef VkResult (VKAPI_PTR *PFN_vkInitializePerformanceApiINTEL)(VkDevice device, const VkInitializePerformanceApiInfoINTEL* pInitializeInfo);

12084

typedef void (VKAPI_PTR *PFN_vkUninitializePerformanceApiINTEL)(VkDevice device);

12085

typedef VkResult (VKAPI_PTR *PFN_vkCmdSetPerformanceMarkerINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL* pMarkerInfo);

12086

typedef VkResult (VKAPI_PTR *PFN_vkCmdSetPerformanceStreamMarkerINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo);

12087

typedef VkResult (VKAPI_PTR *PFN_vkCmdSetPerformanceOverrideINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo);

12088

typedef VkResult (VKAPI_PTR *PFN_vkAcquirePerformanceConfigurationINTEL)(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, VkPerformanceConfigurationINTEL* pConfiguration);

12089

typedef VkResult (VKAPI_PTR *PFN_vkReleasePerformanceConfigurationINTEL)(VkDevice device, VkPerformanceConfigurationINTEL configuration);

12090

typedef VkResult (VKAPI_PTR *PFN_vkQueueSetPerformanceConfigurationINTEL)(VkQueue queue, VkPerformanceConfigurationINTEL configuration);

12091

typedef VkResult (VKAPI_PTR *PFN_vkGetPerformanceParameterINTEL)(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue);

12092

12093

#ifndef VK_NO_PROTOTYPES

12094

VKAPI_ATTR VkResult VKAPI_CALL vkInitializePerformanceApiINTEL(

12095

VkDevice device,

12096

const VkInitializePerformanceApiInfoINTEL* pInitializeInfo);

12097

12098

VKAPI_ATTR void VKAPI_CALL vkUninitializePerformanceApiINTEL(

12099

VkDevice device);

12100

12101

VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceMarkerINTEL(

12102

VkCommandBuffer commandBuffer,

12103

const VkPerformanceMarkerInfoINTEL* pMarkerInfo);

12104

12105

VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceStreamMarkerINTEL(

12106

VkCommandBuffer commandBuffer,

12107

const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo);

12108

12109

VKAPI_ATTR VkResult VKAPI_CALL vkCmdSetPerformanceOverrideINTEL(

12110

VkCommandBuffer commandBuffer,

12111

const VkPerformanceOverrideInfoINTEL* pOverrideInfo);

12112

12113

VKAPI_ATTR VkResult VKAPI_CALL vkAcquirePerformanceConfigurationINTEL(

12114

VkDevice device,

12115

const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo,

12116

VkPerformanceConfigurationINTEL* pConfiguration);

12117

12118

VKAPI_ATTR VkResult VKAPI_CALL vkReleasePerformanceConfigurationINTEL(

12119

VkDevice device,

12120

VkPerformanceConfigurationINTEL configuration);

12121

12122

VKAPI_ATTR VkResult VKAPI_CALL vkQueueSetPerformanceConfigurationINTEL(

12123

VkQueue queue,

12124

VkPerformanceConfigurationINTEL configuration);

12125

12126

VKAPI_ATTR VkResult VKAPI_CALL vkGetPerformanceParameterINTEL(

12127

VkDevice device,

12128

VkPerformanceParameterTypeINTEL parameter,

12129

VkPerformanceValueINTEL* pValue);

12130

#endif

12131

12132

12133

#define VK_EXT_pci_bus_info 1

12134

#define VK_EXT_PCI_BUS_INFO_SPEC_VERSION 2

12135

#define VK_EXT_PCI_BUS_INFO_EXTENSION_NAME "VK_EXT_pci_bus_info"

12136

typedef struct VkPhysicalDevicePCIBusInfoPropertiesEXT {

12137

VkStructureType sType;

12138

void* pNext;

12139

uint32_t pciDomain;

12140

uint32_t pciBus;

12141

uint32_t pciDevice;

12142

uint32_t pciFunction;

12143

} VkPhysicalDevicePCIBusInfoPropertiesEXT;

12144

12145

12146

12147

#define VK_AMD_display_native_hdr 1

12148

#define VK_AMD_DISPLAY_NATIVE_HDR_SPEC_VERSION 1

12149

#define VK_AMD_DISPLAY_NATIVE_HDR_EXTENSION_NAME "VK_AMD_display_native_hdr"

12150

typedef struct VkDisplayNativeHdrSurfaceCapabilitiesAMD {

12151

VkStructureType sType;

12152

void* pNext;

12153

VkBool32 localDimmingSupport;

12154

} VkDisplayNativeHdrSurfaceCapabilitiesAMD;

12155

12156

typedef struct VkSwapchainDisplayNativeHdrCreateInfoAMD {

12157

VkStructureType sType;

12158

const void* pNext;

12159

VkBool32 localDimmingEnable;

12160

} VkSwapchainDisplayNativeHdrCreateInfoAMD;

12161

12162

typedef void (VKAPI_PTR *PFN_vkSetLocalDimmingAMD)(VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable);

12163

12164

#ifndef VK_NO_PROTOTYPES

12165

VKAPI_ATTR void VKAPI_CALL vkSetLocalDimmingAMD(

12166

VkDevice device,

12167

VkSwapchainKHR swapChain,

12168

VkBool32 localDimmingEnable);

12169

#endif

12170

12171

12172

#define VK_EXT_fragment_density_map 1

12173

#define VK_EXT_FRAGMENT_DENSITY_MAP_SPEC_VERSION 2

12174

#define VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME "VK_EXT_fragment_density_map"

12175

typedef struct VkPhysicalDeviceFragmentDensityMapFeaturesEXT {

12176

VkStructureType sType;

12177

void* pNext;

12178

VkBool32 fragmentDensityMap;

12179

VkBool32 fragmentDensityMapDynamic;

12180

VkBool32 fragmentDensityMapNonSubsampledImages;

12181

} VkPhysicalDeviceFragmentDensityMapFeaturesEXT;

12182

12183

typedef struct VkPhysicalDeviceFragmentDensityMapPropertiesEXT {

12184

VkStructureType sType;

12185

void* pNext;

12186

VkExtent2D minFragmentDensityTexelSize;

12187

VkExtent2D maxFragmentDensityTexelSize;

12188

VkBool32 fragmentDensityInvocations;

12189

} VkPhysicalDeviceFragmentDensityMapPropertiesEXT;

12190

12191

typedef struct VkRenderPassFragmentDensityMapCreateInfoEXT {

12192

VkStructureType sType;

12193

const void* pNext;

12194

VkAttachmentReference fragmentDensityMapAttachment;

12195

} VkRenderPassFragmentDensityMapCreateInfoEXT;

12196

12197

12198

12199

#define VK_EXT_scalar_block_layout 1

12200

#define VK_EXT_SCALAR_BLOCK_LAYOUT_SPEC_VERSION 1

12201

#define VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME "VK_EXT_scalar_block_layout"

12202

typedef VkPhysicalDeviceScalarBlockLayoutFeatures VkPhysicalDeviceScalarBlockLayoutFeaturesEXT;

12203

12204

12205

12206

#define VK_GOOGLE_hlsl_functionality1 1

12207

#define VK_GOOGLE_HLSL_FUNCTIONALITY_1_SPEC_VERSION 1

12208

#define VK_GOOGLE_HLSL_FUNCTIONALITY_1_EXTENSION_NAME "VK_GOOGLE_hlsl_functionality1"

12209

#define VK_GOOGLE_HLSL_FUNCTIONALITY1_SPEC_VERSION VK_GOOGLE_HLSL_FUNCTIONALITY_1_SPEC_VERSION

12210

#define VK_GOOGLE_HLSL_FUNCTIONALITY1_EXTENSION_NAME VK_GOOGLE_HLSL_FUNCTIONALITY_1_EXTENSION_NAME

12211

12212

12213

#define VK_GOOGLE_decorate_string 1

12214

#define VK_GOOGLE_DECORATE_STRING_SPEC_VERSION 1

12215

#define VK_GOOGLE_DECORATE_STRING_EXTENSION_NAME "VK_GOOGLE_decorate_string"

12216

12217

12218

#define VK_EXT_subgroup_size_control 1

12219

#define VK_EXT_SUBGROUP_SIZE_CONTROL_SPEC_VERSION 2

12220

#define VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME "VK_EXT_subgroup_size_control"

12221

typedef VkPhysicalDeviceSubgroupSizeControlFeatures VkPhysicalDeviceSubgroupSizeControlFeaturesEXT;

12222

12223

typedef VkPhysicalDeviceSubgroupSizeControlProperties VkPhysicalDeviceSubgroupSizeControlPropertiesEXT;

12224

12225

typedef VkPipelineShaderStageRequiredSubgroupSizeCreateInfo VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT;

12226

12227

12228

12229

#define VK_AMD_shader_core_properties2 1

12230

#define VK_AMD_SHADER_CORE_PROPERTIES_2_SPEC_VERSION 1

12231

#define VK_AMD_SHADER_CORE_PROPERTIES_2_EXTENSION_NAME "VK_AMD_shader_core_properties2"

12232

12233

typedef enum VkShaderCorePropertiesFlagBitsAMD {

12234

VK_SHADER_CORE_PROPERTIES_FLAG_BITS_MAX_ENUM_AMD = 0x7FFFFFFF

12235

} VkShaderCorePropertiesFlagBitsAMD;

12236

typedef VkFlags VkShaderCorePropertiesFlagsAMD;

12237

typedef struct VkPhysicalDeviceShaderCoreProperties2AMD {

12238

VkStructureType sType;

12239

void* pNext;

12240

VkShaderCorePropertiesFlagsAMD shaderCoreFeatures;

12241

uint32_t activeComputeUnitCount;

12242

} VkPhysicalDeviceShaderCoreProperties2AMD;

12243

12244

12245

12246

#define VK_AMD_device_coherent_memory 1

12247

#define VK_AMD_DEVICE_COHERENT_MEMORY_SPEC_VERSION 1

12248

#define VK_AMD_DEVICE_COHERENT_MEMORY_EXTENSION_NAME "VK_AMD_device_coherent_memory"

12249

typedef struct VkPhysicalDeviceCoherentMemoryFeaturesAMD {

12250

VkStructureType sType;

12251

void* pNext;

12252

VkBool32 deviceCoherentMemory;

12253

} VkPhysicalDeviceCoherentMemoryFeaturesAMD;

12254

12255

12256

12257

#define VK_EXT_shader_image_atomic_int64 1

12258

#define VK_EXT_SHADER_IMAGE_ATOMIC_INT64_SPEC_VERSION 1

12259

#define VK_EXT_SHADER_IMAGE_ATOMIC_INT64_EXTENSION_NAME "VK_EXT_shader_image_atomic_int64"

12260

typedef struct VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT {

12261

VkStructureType sType;

12262

void* pNext;

12263

VkBool32 shaderImageInt64Atomics;

12264

VkBool32 sparseImageInt64Atomics;

12265

} VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT;

12266

12267

12268

12269

#define VK_EXT_memory_budget 1

12270

#define VK_EXT_MEMORY_BUDGET_SPEC_VERSION 1

12271

#define VK_EXT_MEMORY_BUDGET_EXTENSION_NAME "VK_EXT_memory_budget"

12272

typedef struct VkPhysicalDeviceMemoryBudgetPropertiesEXT {

12273

VkStructureType sType;

12274

void* pNext;

12275

VkDeviceSize heapBudget[VK_MAX_MEMORY_HEAPS];

12276

VkDeviceSize heapUsage[VK_MAX_MEMORY_HEAPS];

12277

} VkPhysicalDeviceMemoryBudgetPropertiesEXT;

12278

12279

12280

12281

#define VK_EXT_memory_priority 1

12282

#define VK_EXT_MEMORY_PRIORITY_SPEC_VERSION 1

12283

#define VK_EXT_MEMORY_PRIORITY_EXTENSION_NAME "VK_EXT_memory_priority"

12284

typedef struct VkPhysicalDeviceMemoryPriorityFeaturesEXT {

12285

VkStructureType sType;

12286

void* pNext;

12287

VkBool32 memoryPriority;

12288

} VkPhysicalDeviceMemoryPriorityFeaturesEXT;

12289

12290

typedef struct VkMemoryPriorityAllocateInfoEXT {

12291

VkStructureType sType;

12292

const void* pNext;

12293

float priority;

12294

} VkMemoryPriorityAllocateInfoEXT;

12295

12296

12297

12298

#define VK_NV_dedicated_allocation_image_aliasing 1

12299

#define VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_SPEC_VERSION 1

12300

#define VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_EXTENSION_NAME "VK_NV_dedicated_allocation_image_aliasing"

12301

typedef struct VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {

12302

VkStructureType sType;

12303

void* pNext;

12304

VkBool32 dedicatedAllocationImageAliasing;

12305

} VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;

12306

12307

12308

12309

#define VK_EXT_buffer_device_address 1

12310

#define VK_EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION 2

12311

#define VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME "VK_EXT_buffer_device_address"

12312

typedef struct VkPhysicalDeviceBufferDeviceAddressFeaturesEXT {

12313

VkStructureType sType;

12314

void* pNext;

12315

VkBool32 bufferDeviceAddress;

12316

VkBool32 bufferDeviceAddressCaptureReplay;

12317

VkBool32 bufferDeviceAddressMultiDevice;

12318

} VkPhysicalDeviceBufferDeviceAddressFeaturesEXT;

12319

12320

typedef VkPhysicalDeviceBufferDeviceAddressFeaturesEXT VkPhysicalDeviceBufferAddressFeaturesEXT;

12321

12322

typedef VkBufferDeviceAddressInfo VkBufferDeviceAddressInfoEXT;

12323

12324

typedef struct VkBufferDeviceAddressCreateInfoEXT {

12325

VkStructureType sType;

12326

const void* pNext;

12327

VkDeviceAddress deviceAddress;

12328

} VkBufferDeviceAddressCreateInfoEXT;

12329

12330

typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetBufferDeviceAddressEXT)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo);

12331

12332

#ifndef VK_NO_PROTOTYPES

12333

VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetBufferDeviceAddressEXT(

12334

VkDevice device,

12335

const VkBufferDeviceAddressInfo* pInfo);

12336

#endif

12337

12338

12339

#define VK_EXT_tooling_info 1

12340

#define VK_EXT_TOOLING_INFO_SPEC_VERSION 1

12341

#define VK_EXT_TOOLING_INFO_EXTENSION_NAME "VK_EXT_tooling_info"

12342

typedef VkToolPurposeFlagBits VkToolPurposeFlagBitsEXT;

12343

12344

typedef VkToolPurposeFlags VkToolPurposeFlagsEXT;

12345

12346

typedef VkPhysicalDeviceToolProperties VkPhysicalDeviceToolPropertiesEXT;

12347

12348

typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceToolPropertiesEXT)(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties);

12349

12350

#ifndef VK_NO_PROTOTYPES

12351

VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceToolPropertiesEXT(

12352

VkPhysicalDevice physicalDevice,

12353

uint32_t* pToolCount,

12354

VkPhysicalDeviceToolProperties* pToolProperties);

12355

#endif

12356

12357

12358

#define VK_EXT_separate_stencil_usage 1

12359

#define VK_EXT_SEPARATE_STENCIL_USAGE_SPEC_VERSION 1

12360

#define VK_EXT_SEPARATE_STENCIL_USAGE_EXTENSION_NAME "VK_EXT_separate_stencil_usage"

12361

typedef VkImageStencilUsageCreateInfo VkImageStencilUsageCreateInfoEXT;

12362

12363

12364

12365

#define VK_EXT_validation_features 1

12366

#define VK_EXT_VALIDATION_FEATURES_SPEC_VERSION 5

12367

#define VK_EXT_VALIDATION_FEATURES_EXTENSION_NAME "VK_EXT_validation_features"

12368

12369

typedef enum VkValidationFeatureEnableEXT {

12370

VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT = 0,

12371

VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT = 1,

12372

VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT = 2,

12373

VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT = 3,

12374

VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT = 4,

12375

VK_VALIDATION_FEATURE_ENABLE_MAX_ENUM_EXT = 0x7FFFFFFF

12376

} VkValidationFeatureEnableEXT;

12377

12378

typedef enum VkValidationFeatureDisableEXT {

12379

VK_VALIDATION_FEATURE_DISABLE_ALL_EXT = 0,

12380

VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT = 1,

12381

VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT = 2,

12382

VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT = 3,

12383

VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT = 4,

12384

VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT = 5,

12385

VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT = 6,

12386

VK_VALIDATION_FEATURE_DISABLE_SHADER_VALIDATION_CACHE_EXT = 7,

12387

VK_VALIDATION_FEATURE_DISABLE_MAX_ENUM_EXT = 0x7FFFFFFF

12388

} VkValidationFeatureDisableEXT;

12389

typedef struct VkValidationFeaturesEXT {

12390

VkStructureType sType;

12391

const void* pNext;

12392

uint32_t enabledValidationFeatureCount;

12393

const VkValidationFeatureEnableEXT* pEnabledValidationFeatures;

12394

uint32_t disabledValidationFeatureCount;

12395

const VkValidationFeatureDisableEXT* pDisabledValidationFeatures;

12396

} VkValidationFeaturesEXT;

12397

12398

12399

12400

#define VK_NV_cooperative_matrix 1

12401

#define VK_NV_COOPERATIVE_MATRIX_SPEC_VERSION 1

12402

#define VK_NV_COOPERATIVE_MATRIX_EXTENSION_NAME "VK_NV_cooperative_matrix"

12403

12404

typedef enum VkComponentTypeNV {

12405

VK_COMPONENT_TYPE_FLOAT16_NV = 0,

12406

VK_COMPONENT_TYPE_FLOAT32_NV = 1,

12407

VK_COMPONENT_TYPE_FLOAT64_NV = 2,

12408

VK_COMPONENT_TYPE_SINT8_NV = 3,

12409

VK_COMPONENT_TYPE_SINT16_NV = 4,

12410

VK_COMPONENT_TYPE_SINT32_NV = 5,

12411

VK_COMPONENT_TYPE_SINT64_NV = 6,

12412

VK_COMPONENT_TYPE_UINT8_NV = 7,

12413

VK_COMPONENT_TYPE_UINT16_NV = 8,

12414

VK_COMPONENT_TYPE_UINT32_NV = 9,

12415

VK_COMPONENT_TYPE_UINT64_NV = 10,

12416

VK_COMPONENT_TYPE_MAX_ENUM_NV = 0x7FFFFFFF

12417

} VkComponentTypeNV;

12418

12419

typedef enum VkScopeNV {

12420

VK_SCOPE_DEVICE_NV = 1,

12421

VK_SCOPE_WORKGROUP_NV = 2,

12422

VK_SCOPE_SUBGROUP_NV = 3,

12423

VK_SCOPE_QUEUE_FAMILY_NV = 5,

12424

VK_SCOPE_MAX_ENUM_NV = 0x7FFFFFFF

12425

} VkScopeNV;

12426

typedef struct VkCooperativeMatrixPropertiesNV {

12427

VkStructureType sType;

12428

void* pNext;

12429

uint32_t MSize;

12430

uint32_t NSize;

12431

uint32_t KSize;

12432

VkComponentTypeNV AType;

12433

VkComponentTypeNV BType;

12434

VkComponentTypeNV CType;

12435

VkComponentTypeNV DType;

12436

VkScopeNV scope;

12437

} VkCooperativeMatrixPropertiesNV;

12438

12439

typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesNV {

12440

VkStructureType sType;

12441

void* pNext;

12442

VkBool32 cooperativeMatrix;

12443

VkBool32 cooperativeMatrixRobustBufferAccess;

12444

} VkPhysicalDeviceCooperativeMatrixFeaturesNV;

12445

12446

typedef struct VkPhysicalDeviceCooperativeMatrixPropertiesNV {

12447

VkStructureType sType;

12448

void* pNext;

12449

VkShaderStageFlags cooperativeMatrixSupportedStages;

12450

} VkPhysicalDeviceCooperativeMatrixPropertiesNV;

12451

12452

typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties);

12453

12454

#ifndef VK_NO_PROTOTYPES

12455

VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(

12456

VkPhysicalDevice physicalDevice,

12457

uint32_t* pPropertyCount,

12458

VkCooperativeMatrixPropertiesNV* pProperties);

12459

#endif

12460

12461

12462

#define VK_NV_coverage_reduction_mode 1

12463

#define VK_NV_COVERAGE_REDUCTION_MODE_SPEC_VERSION 1

12464

#define VK_NV_COVERAGE_REDUCTION_MODE_EXTENSION_NAME "VK_NV_coverage_reduction_mode"

12465

12466

typedef enum VkCoverageReductionModeNV {

12467

VK_COVERAGE_REDUCTION_MODE_MERGE_NV = 0,

12468

VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV = 1,

12469

VK_COVERAGE_REDUCTION_MODE_MAX_ENUM_NV = 0x7FFFFFFF

12470

} VkCoverageReductionModeNV;

12471

typedef VkFlags VkPipelineCoverageReductionStateCreateFlagsNV;

12472

typedef struct VkPhysicalDeviceCoverageReductionModeFeaturesNV {

12473

VkStructureType sType;

12474

void* pNext;

12475

VkBool32 coverageReductionMode;

12476

} VkPhysicalDeviceCoverageReductionModeFeaturesNV;

12477

12478

typedef struct VkPipelineCoverageReductionStateCreateInfoNV {

12479

VkStructureType sType;

12480

const void* pNext;

12481

VkPipelineCoverageReductionStateCreateFlagsNV flags;

12482

VkCoverageReductionModeNV coverageReductionMode;

12483

} VkPipelineCoverageReductionStateCreateInfoNV;

12484

12485

typedef struct VkFramebufferMixedSamplesCombinationNV {

12486

VkStructureType sType;

12487

void* pNext;

12488

VkCoverageReductionModeNV coverageReductionMode;

12489

VkSampleCountFlagBits rasterizationSamples;

12490

VkSampleCountFlags depthStencilSamples;

12491

VkSampleCountFlags colorSamples;

12492

} VkFramebufferMixedSamplesCombinationNV;

12493

12494

typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV)(VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations);

12495

12496

#ifndef VK_NO_PROTOTYPES

12497

VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(

12498

VkPhysicalDevice physicalDevice,

12499

uint32_t* pCombinationCount,

12500

VkFramebufferMixedSamplesCombinationNV* pCombinations);

12501

#endif

12502

12503

12504

#define VK_EXT_fragment_shader_interlock 1

12505

#define VK_EXT_FRAGMENT_SHADER_INTERLOCK_SPEC_VERSION 1

12506

#define VK_EXT_FRAGMENT_SHADER_INTERLOCK_EXTENSION_NAME "VK_EXT_fragment_shader_interlock"

12507

typedef struct VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT {

12508

VkStructureType sType;

12509

void* pNext;

12510

VkBool32 fragmentShaderSampleInterlock;

12511

VkBool32 fragmentShaderPixelInterlock;

12512

VkBool32 fragmentShaderShadingRateInterlock;

12513

} VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT;

12514

12515

12516

12517

#define VK_EXT_ycbcr_image_arrays 1

12518

#define VK_EXT_YCBCR_IMAGE_ARRAYS_SPEC_VERSION 1

12519

#define VK_EXT_YCBCR_IMAGE_ARRAYS_EXTENSION_NAME "VK_EXT_ycbcr_image_arrays"

12520

typedef struct VkPhysicalDeviceYcbcrImageArraysFeaturesEXT {

12521

VkStructureType sType;

12522

void* pNext;

12523

VkBool32 ycbcrImageArrays;

12524

} VkPhysicalDeviceYcbcrImageArraysFeaturesEXT;

12525

12526

12527

12528

#define VK_EXT_provoking_vertex 1

12529

#define VK_EXT_PROVOKING_VERTEX_SPEC_VERSION 1

12530

#define VK_EXT_PROVOKING_VERTEX_EXTENSION_NAME "VK_EXT_provoking_vertex"

12531

12532

typedef enum VkProvokingVertexModeEXT {

12533

VK_PROVOKING_VERTEX_MODE_FIRST_VERTEX_EXT = 0,

12534

VK_PROVOKING_VERTEX_MODE_LAST_VERTEX_EXT = 1,

12535

VK_PROVOKING_VERTEX_MODE_MAX_ENUM_EXT = 0x7FFFFFFF

12536

} VkProvokingVertexModeEXT;

12537

typedef struct VkPhysicalDeviceProvokingVertexFeaturesEXT {

12538

VkStructureType sType;

12539

void* pNext;

12540

VkBool32 provokingVertexLast;

12541

VkBool32 transformFeedbackPreservesProvokingVertex;

12542

} VkPhysicalDeviceProvokingVertexFeaturesEXT;

12543

12544

typedef struct VkPhysicalDeviceProvokingVertexPropertiesEXT {

12545

VkStructureType sType;

12546

void* pNext;

12547

VkBool32 provokingVertexModePerPipeline;

12548

VkBool32 transformFeedbackPreservesTriangleFanProvokingVertex;

12549

} VkPhysicalDeviceProvokingVertexPropertiesEXT;

12550

12551

typedef struct VkPipelineRasterizationProvokingVertexStateCreateInfoEXT {

12552

VkStructureType sType;

12553

const void* pNext;

12554

VkProvokingVertexModeEXT provokingVertexMode;

12555

} VkPipelineRasterizationProvokingVertexStateCreateInfoEXT;

12556

12557

12558

12559

#define VK_EXT_headless_surface 1

12560

#define VK_EXT_HEADLESS_SURFACE_SPEC_VERSION 1

12561

#define VK_EXT_HEADLESS_SURFACE_EXTENSION_NAME "VK_EXT_headless_surface"

12562

typedef VkFlags VkHeadlessSurfaceCreateFlagsEXT;

12563

typedef struct VkHeadlessSurfaceCreateInfoEXT {

12564

VkStructureType sType;

12565

const void* pNext;

12566

VkHeadlessSurfaceCreateFlagsEXT flags;

12567

} VkHeadlessSurfaceCreateInfoEXT;

12568

12569

typedef VkResult (VKAPI_PTR *PFN_vkCreateHeadlessSurfaceEXT)(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);

12570

12571

#ifndef VK_NO_PROTOTYPES

12572

VKAPI_ATTR VkResult VKAPI_CALL vkCreateHeadlessSurfaceEXT(

12573

VkInstance instance,

12574

const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo,

12575

const VkAllocationCallbacks* pAllocator,

12576

VkSurfaceKHR* pSurface);

12577

#endif

12578

12579

12580

#define VK_EXT_line_rasterization 1

12581

#define VK_EXT_LINE_RASTERIZATION_SPEC_VERSION 1

12582

#define VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME "VK_EXT_line_rasterization"

12583

12584

typedef enum VkLineRasterizationModeEXT {

12585

VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT = 0,

12586

VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT = 1,

12587

VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT = 2,

12588

VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT = 3,

12589

VK_LINE_RASTERIZATION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF

12590

} VkLineRasterizationModeEXT;

12591

typedef struct VkPhysicalDeviceLineRasterizationFeaturesEXT {

12592

VkStructureType sType;

12593

void* pNext;

12594

VkBool32 rectangularLines;

12595

VkBool32 bresenhamLines;

12596

VkBool32 smoothLines;

12597

VkBool32 stippledRectangularLines;

12598

VkBool32 stippledBresenhamLines;

12599

VkBool32 stippledSmoothLines;

12600

} VkPhysicalDeviceLineRasterizationFeaturesEXT;

12601

12602

typedef struct VkPhysicalDeviceLineRasterizationPropertiesEXT {

12603

VkStructureType sType;

12604

void* pNext;

12605

uint32_t lineSubPixelPrecisionBits;

12606

} VkPhysicalDeviceLineRasterizationPropertiesEXT;

12607

12608

typedef struct VkPipelineRasterizationLineStateCreateInfoEXT {

12609

VkStructureType sType;

12610

const void* pNext;

12611

VkLineRasterizationModeEXT lineRasterizationMode;

12612

VkBool32 stippledLineEnable;

12613

uint32_t lineStippleFactor;

12614

uint16_t lineStipplePattern;

12615

} VkPipelineRasterizationLineStateCreateInfoEXT;

12616

12617

typedef void (VKAPI_PTR *PFN_vkCmdSetLineStippleEXT)(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern);

12618

12619

#ifndef VK_NO_PROTOTYPES

12620

VKAPI_ATTR void VKAPI_CALL vkCmdSetLineStippleEXT(

12621

VkCommandBuffer commandBuffer,

12622

uint32_t lineStippleFactor,

12623

uint16_t lineStipplePattern);

12624

#endif

12625

12626

12627

#define VK_EXT_shader_atomic_float 1

12628

#define VK_EXT_SHADER_ATOMIC_FLOAT_SPEC_VERSION 1

12629

#define VK_EXT_SHADER_ATOMIC_FLOAT_EXTENSION_NAME "VK_EXT_shader_atomic_float"

12630

typedef struct VkPhysicalDeviceShaderAtomicFloatFeaturesEXT {

12631

VkStructureType sType;

12632

void* pNext;

12633

VkBool32 shaderBufferFloat32Atomics;

12634

VkBool32 shaderBufferFloat32AtomicAdd;

12635

VkBool32 shaderBufferFloat64Atomics;

12636

VkBool32 shaderBufferFloat64AtomicAdd;

12637

VkBool32 shaderSharedFloat32Atomics;

12638

VkBool32 shaderSharedFloat32AtomicAdd;

12639

VkBool32 shaderSharedFloat64Atomics;

12640

VkBool32 shaderSharedFloat64AtomicAdd;

12641

VkBool32 shaderImageFloat32Atomics;

12642

VkBool32 shaderImageFloat32AtomicAdd;

12643

VkBool32 sparseImageFloat32Atomics;

12644

VkBool32 sparseImageFloat32AtomicAdd;

12645

} VkPhysicalDeviceShaderAtomicFloatFeaturesEXT;

12646

12647

12648

12649

#define VK_EXT_host_query_reset 1

12650

#define VK_EXT_HOST_QUERY_RESET_SPEC_VERSION 1

12651

#define VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME "VK_EXT_host_query_reset"

12652

typedef VkPhysicalDeviceHostQueryResetFeatures VkPhysicalDeviceHostQueryResetFeaturesEXT;

12653

12654

typedef void (VKAPI_PTR *PFN_vkResetQueryPoolEXT)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount);

12655

12656

#ifndef VK_NO_PROTOTYPES

12657

VKAPI_ATTR void VKAPI_CALL vkResetQueryPoolEXT(

12658

VkDevice device,

12659

VkQueryPool queryPool,

12660

uint32_t firstQuery,

12661

uint32_t queryCount);

12662

#endif

12663

12664

12665

#define VK_EXT_index_type_uint8 1

12666

#define VK_EXT_INDEX_TYPE_UINT8_SPEC_VERSION 1

12667

#define VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME "VK_EXT_index_type_uint8"

12668

typedef struct VkPhysicalDeviceIndexTypeUint8FeaturesEXT {

12669

VkStructureType sType;

12670

void* pNext;

12671

VkBool32 indexTypeUint8;

12672

} VkPhysicalDeviceIndexTypeUint8FeaturesEXT;

12673

12674

12675

12676

#define VK_EXT_extended_dynamic_state 1

12677

#define VK_EXT_EXTENDED_DYNAMIC_STATE_SPEC_VERSION 1

12678

#define VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME "VK_EXT_extended_dynamic_state"

12679

typedef struct VkPhysicalDeviceExtendedDynamicStateFeaturesEXT {

12680

VkStructureType sType;

12681

void* pNext;

12682

VkBool32 extendedDynamicState;

12683

} VkPhysicalDeviceExtendedDynamicStateFeaturesEXT;

12684

12685

typedef void (VKAPI_PTR *PFN_vkCmdSetCullModeEXT)(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode);

12686

typedef void (VKAPI_PTR *PFN_vkCmdSetFrontFaceEXT)(VkCommandBuffer commandBuffer, VkFrontFace frontFace);

12687

typedef void (VKAPI_PTR *PFN_vkCmdSetPrimitiveTopologyEXT)(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology);

12688

typedef void (VKAPI_PTR *PFN_vkCmdSetViewportWithCountEXT)(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports);

12689

typedef void (VKAPI_PTR *PFN_vkCmdSetScissorWithCountEXT)(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors);

12690

typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers2EXT)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides);

12691

typedef void (VKAPI_PTR *PFN_vkCmdSetDepthTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable);

12692

typedef void (VKAPI_PTR *PFN_vkCmdSetDepthWriteEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable);

12693

typedef void (VKAPI_PTR *PFN_vkCmdSetDepthCompareOpEXT)(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp);

12694

typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBoundsTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable);

12695

typedef void (VKAPI_PTR *PFN_vkCmdSetStencilTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable);

12696

typedef void (VKAPI_PTR *PFN_vkCmdSetStencilOpEXT)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp);

12697

12698

#ifndef VK_NO_PROTOTYPES

12699

VKAPI_ATTR void VKAPI_CALL vkCmdSetCullModeEXT(

12700

VkCommandBuffer commandBuffer,

12701

VkCullModeFlags cullMode);

12702

12703

VKAPI_ATTR void VKAPI_CALL vkCmdSetFrontFaceEXT(

12704

VkCommandBuffer commandBuffer,

12705

VkFrontFace frontFace);

12706

12707

VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveTopologyEXT(

12708

VkCommandBuffer commandBuffer,

12709

VkPrimitiveTopology primitiveTopology);

12710

12711

VKAPI_ATTR void VKAPI_CALL vkCmdSetViewportWithCountEXT(

12712

VkCommandBuffer commandBuffer,

12713

uint32_t viewportCount,

12714

const VkViewport* pViewports);

12715

12716

VKAPI_ATTR void VKAPI_CALL vkCmdSetScissorWithCountEXT(

12717

VkCommandBuffer commandBuffer,

12718

uint32_t scissorCount,

12719

const VkRect2D* pScissors);

12720

12721

VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers2EXT(

12722

VkCommandBuffer commandBuffer,

12723

uint32_t firstBinding,

12724

uint32_t bindingCount,

12725

const VkBuffer* pBuffers,

12726

const VkDeviceSize* pOffsets,

12727

const VkDeviceSize* pSizes,

12728

const VkDeviceSize* pStrides);

12729

12730

VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthTestEnableEXT(

12731

VkCommandBuffer commandBuffer,

12732

VkBool32 depthTestEnable);

12733

12734

VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthWriteEnableEXT(

12735

VkCommandBuffer commandBuffer,

12736

VkBool32 depthWriteEnable);

12737

12738

VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthCompareOpEXT(

12739

VkCommandBuffer commandBuffer,

12740

VkCompareOp depthCompareOp);

12741

12742

VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBoundsTestEnableEXT(

12743

VkCommandBuffer commandBuffer,

12744

VkBool32 depthBoundsTestEnable);

12745

12746

VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilTestEnableEXT(

12747

VkCommandBuffer commandBuffer,

12748

VkBool32 stencilTestEnable);

12749

12750

VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilOpEXT(

12751

VkCommandBuffer commandBuffer,

12752

VkStencilFaceFlags faceMask,

12753

VkStencilOp failOp,

12754

VkStencilOp passOp,

12755

VkStencilOp depthFailOp,

12756

VkCompareOp compareOp);

12757

#endif

12758

12759

12760

#define VK_EXT_shader_atomic_float2 1

12761

#define VK_EXT_SHADER_ATOMIC_FLOAT_2_SPEC_VERSION 1

12762

#define VK_EXT_SHADER_ATOMIC_FLOAT_2_EXTENSION_NAME "VK_EXT_shader_atomic_float2"

12763

typedef struct VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT {

12764

VkStructureType sType;

12765

void* pNext;

12766

VkBool32 shaderBufferFloat16Atomics;

12767

VkBool32 shaderBufferFloat16AtomicAdd;

12768

VkBool32 shaderBufferFloat16AtomicMinMax;

12769

VkBool32 shaderBufferFloat32AtomicMinMax;

12770

VkBool32 shaderBufferFloat64AtomicMinMax;

12771

VkBool32 shaderSharedFloat16Atomics;

12772

VkBool32 shaderSharedFloat16AtomicAdd;

12773

VkBool32 shaderSharedFloat16AtomicMinMax;

12774

VkBool32 shaderSharedFloat32AtomicMinMax;

12775

VkBool32 shaderSharedFloat64AtomicMinMax;

12776

VkBool32 shaderImageFloat32AtomicMinMax;

12777

VkBool32 sparseImageFloat32AtomicMinMax;

12778

} VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT;

12779

12780

12781

12782

#define VK_EXT_shader_demote_to_helper_invocation 1

12783

#define VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_SPEC_VERSION 1

12784

#define VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME "VK_EXT_shader_demote_to_helper_invocation"

12785

typedef VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT;

12786

12787

12788

12789

#define VK_NV_device_generated_commands 1

12790

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkIndirectCommandsLayoutNV)

12791

#define VK_NV_DEVICE_GENERATED_COMMANDS_SPEC_VERSION 3

12792

#define VK_NV_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME "VK_NV_device_generated_commands"

12793

12794

typedef enum VkIndirectCommandsTokenTypeNV {

12795

VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV = 0,

12796

VK_INDIRECT_COMMANDS_TOKEN_TYPE_STATE_FLAGS_NV = 1,

12797

VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NV = 2,

12798

VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NV = 3,

12799

VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV = 4,

12800

VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NV = 5,

12801

VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NV = 6,

12802

VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_TASKS_NV = 7,

12803

VK_INDIRECT_COMMANDS_TOKEN_TYPE_MAX_ENUM_NV = 0x7FFFFFFF

12804

} VkIndirectCommandsTokenTypeNV;

12805

12806

typedef enum VkIndirectStateFlagBitsNV {

12807

VK_INDIRECT_STATE_FLAG_FRONTFACE_BIT_NV = 0x00000001,

12808

VK_INDIRECT_STATE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF

12809

} VkIndirectStateFlagBitsNV;

12810

typedef VkFlags VkIndirectStateFlagsNV;

12811

12812

typedef enum VkIndirectCommandsLayoutUsageFlagBitsNV {

12813

VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_NV = 0x00000001,

12814

VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NV = 0x00000002,

12815

VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NV = 0x00000004,

12816

VK_INDIRECT_COMMANDS_LAYOUT_USAGE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF

12817

} VkIndirectCommandsLayoutUsageFlagBitsNV;

12818

typedef VkFlags VkIndirectCommandsLayoutUsageFlagsNV;

12819

typedef struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV {

12820

VkStructureType sType;

12821

void* pNext;

12822

uint32_t maxGraphicsShaderGroupCount;

12823

uint32_t maxIndirectSequenceCount;

12824

uint32_t maxIndirectCommandsTokenCount;

12825

uint32_t maxIndirectCommandsStreamCount;

12826

uint32_t maxIndirectCommandsTokenOffset;

12827

uint32_t maxIndirectCommandsStreamStride;

12828

uint32_t minSequencesCountBufferOffsetAlignment;

12829

uint32_t minSequencesIndexBufferOffsetAlignment;

12830

uint32_t minIndirectCommandsBufferOffsetAlignment;

12831

} VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV;

12832

12833

typedef struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV {

12834

VkStructureType sType;

12835

void* pNext;

12836

VkBool32 deviceGeneratedCommands;

12837

} VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV;

12838

12839

typedef struct VkGraphicsShaderGroupCreateInfoNV {

12840

VkStructureType sType;

12841

const void* pNext;

12842

uint32_t stageCount;

12843

const VkPipelineShaderStageCreateInfo* pStages;

12844

const VkPipelineVertexInputStateCreateInfo* pVertexInputState;

12845

const VkPipelineTessellationStateCreateInfo* pTessellationState;

12846

} VkGraphicsShaderGroupCreateInfoNV;

12847

12848

typedef struct VkGraphicsPipelineShaderGroupsCreateInfoNV {

12849

VkStructureType sType;

12850

const void* pNext;

12851

uint32_t groupCount;

12852

const VkGraphicsShaderGroupCreateInfoNV* pGroups;

12853

uint32_t pipelineCount;

12854

const VkPipeline* pPipelines;

12855

} VkGraphicsPipelineShaderGroupsCreateInfoNV;

12856

12857

typedef struct VkBindShaderGroupIndirectCommandNV {

12858

uint32_t groupIndex;

12859

} VkBindShaderGroupIndirectCommandNV;

12860

12861

typedef struct VkBindIndexBufferIndirectCommandNV {

12862

VkDeviceAddress bufferAddress;

12863

uint32_t size;

12864

VkIndexType indexType;

12865

} VkBindIndexBufferIndirectCommandNV;

12866

12867

typedef struct VkBindVertexBufferIndirectCommandNV {

12868

VkDeviceAddress bufferAddress;

12869

uint32_t size;

12870

uint32_t stride;

12871

} VkBindVertexBufferIndirectCommandNV;

12872

12873

typedef struct VkSetStateFlagsIndirectCommandNV {

12874

uint32_t data;

12875

} VkSetStateFlagsIndirectCommandNV;

12876

12877

typedef struct VkIndirectCommandsStreamNV {

12878

VkBuffer buffer;

12879

VkDeviceSize offset;

12880

} VkIndirectCommandsStreamNV;

12881

12882

typedef struct VkIndirectCommandsLayoutTokenNV {

12883

VkStructureType sType;

12884

const void* pNext;

12885

VkIndirectCommandsTokenTypeNV tokenType;

12886

uint32_t stream;

12887

uint32_t offset;

12888

uint32_t vertexBindingUnit;

12889

VkBool32 vertexDynamicStride;

12890

VkPipelineLayout pushconstantPipelineLayout;

12891

VkShaderStageFlags pushconstantShaderStageFlags;

12892

uint32_t pushconstantOffset;

12893

uint32_t pushconstantSize;

12894

VkIndirectStateFlagsNV indirectStateFlags;

12895

uint32_t indexTypeCount;

12896

const VkIndexType* pIndexTypes;

12897

const uint32_t* pIndexTypeValues;

12898

} VkIndirectCommandsLayoutTokenNV;

12899

12900

typedef struct VkIndirectCommandsLayoutCreateInfoNV {

12901

VkStructureType sType;

12902

const void* pNext;

12903

VkIndirectCommandsLayoutUsageFlagsNV flags;

12904

VkPipelineBindPoint pipelineBindPoint;

12905

uint32_t tokenCount;

12906

const VkIndirectCommandsLayoutTokenNV* pTokens;

12907

uint32_t streamCount;

12908

const uint32_t* pStreamStrides;

12909

} VkIndirectCommandsLayoutCreateInfoNV;

12910

12911

typedef struct VkGeneratedCommandsInfoNV {

12912

VkStructureType sType;

12913

const void* pNext;

12914

VkPipelineBindPoint pipelineBindPoint;

12915

VkPipeline pipeline;

12916

VkIndirectCommandsLayoutNV indirectCommandsLayout;

12917

uint32_t streamCount;

12918

const VkIndirectCommandsStreamNV* pStreams;

12919

uint32_t sequencesCount;

12920

VkBuffer preprocessBuffer;

12921

VkDeviceSize preprocessOffset;

12922

VkDeviceSize preprocessSize;

12923

VkBuffer sequencesCountBuffer;

12924

VkDeviceSize sequencesCountOffset;

12925

VkBuffer sequencesIndexBuffer;

12926

VkDeviceSize sequencesIndexOffset;

12927

} VkGeneratedCommandsInfoNV;

12928

12929

typedef struct VkGeneratedCommandsMemoryRequirementsInfoNV {

12930

VkStructureType sType;

12931

const void* pNext;

12932

VkPipelineBindPoint pipelineBindPoint;

12933

VkPipeline pipeline;

12934

VkIndirectCommandsLayoutNV indirectCommandsLayout;

12935

uint32_t maxSequencesCount;

12936

} VkGeneratedCommandsMemoryRequirementsInfoNV;

12937

12938

typedef void (VKAPI_PTR *PFN_vkGetGeneratedCommandsMemoryRequirementsNV)(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2* pMemoryRequirements);

12939

typedef void (VKAPI_PTR *PFN_vkCmdPreprocessGeneratedCommandsNV)(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo);

12940

typedef void (VKAPI_PTR *PFN_vkCmdExecuteGeneratedCommandsNV)(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo);

12941

typedef void (VKAPI_PTR *PFN_vkCmdBindPipelineShaderGroupNV)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex);

12942

typedef VkResult (VKAPI_PTR *PFN_vkCreateIndirectCommandsLayoutNV)(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNV* pIndirectCommandsLayout);

12943

typedef void (VKAPI_PTR *PFN_vkDestroyIndirectCommandsLayoutNV)(VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks* pAllocator);

12944

12945

#ifndef VK_NO_PROTOTYPES

12946

VKAPI_ATTR void VKAPI_CALL vkGetGeneratedCommandsMemoryRequirementsNV(

12947

VkDevice device,

12948

const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo,

12949

VkMemoryRequirements2* pMemoryRequirements);

12950

12951

VKAPI_ATTR void VKAPI_CALL vkCmdPreprocessGeneratedCommandsNV(

12952

VkCommandBuffer commandBuffer,

12953

const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo);

12954

12955

VKAPI_ATTR void VKAPI_CALL vkCmdExecuteGeneratedCommandsNV(

12956

VkCommandBuffer commandBuffer,

12957

VkBool32 isPreprocessed,

12958

const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo);

12959

12960

VKAPI_ATTR void VKAPI_CALL vkCmdBindPipelineShaderGroupNV(

12961

VkCommandBuffer commandBuffer,

12962

VkPipelineBindPoint pipelineBindPoint,

12963

VkPipeline pipeline,

12964

uint32_t groupIndex);

12965

12966

VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutNV(

12967

VkDevice device,

12968

const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo,

12969

const VkAllocationCallbacks* pAllocator,

12970

VkIndirectCommandsLayoutNV* pIndirectCommandsLayout);

12971

12972

VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectCommandsLayoutNV(

12973

VkDevice device,

12974

VkIndirectCommandsLayoutNV indirectCommandsLayout,

12975

const VkAllocationCallbacks* pAllocator);

12976

#endif

12977

12978

12979

#define VK_NV_inherited_viewport_scissor 1

12980

#define VK_NV_INHERITED_VIEWPORT_SCISSOR_SPEC_VERSION 1

12981

#define VK_NV_INHERITED_VIEWPORT_SCISSOR_EXTENSION_NAME "VK_NV_inherited_viewport_scissor"

12982

typedef struct VkPhysicalDeviceInheritedViewportScissorFeaturesNV {

12983

VkStructureType sType;

12984

void* pNext;

12985

VkBool32 inheritedViewportScissor2D;

12986

} VkPhysicalDeviceInheritedViewportScissorFeaturesNV;

12987

12988

typedef struct VkCommandBufferInheritanceViewportScissorInfoNV {

12989

VkStructureType sType;

12990

const void* pNext;

12991

VkBool32 viewportScissor2D;

12992

uint32_t viewportDepthCount;

12993

const VkViewport* pViewportDepths;

12994

} VkCommandBufferInheritanceViewportScissorInfoNV;

12995

12996

12997

12998

#define VK_EXT_texel_buffer_alignment 1

12999

#define VK_EXT_TEXEL_BUFFER_ALIGNMENT_SPEC_VERSION 1

13000

#define VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME "VK_EXT_texel_buffer_alignment"

13001

typedef struct VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT {

13002

VkStructureType sType;

13003

void* pNext;

13004

VkBool32 texelBufferAlignment;

13005

} VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT;

13006

13007

typedef VkPhysicalDeviceTexelBufferAlignmentProperties VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT;

13008

13009

13010

13011

#define VK_QCOM_render_pass_transform 1

13012

#define VK_QCOM_RENDER_PASS_TRANSFORM_SPEC_VERSION 2

13013

#define VK_QCOM_RENDER_PASS_TRANSFORM_EXTENSION_NAME "VK_QCOM_render_pass_transform"

13014

typedef struct VkRenderPassTransformBeginInfoQCOM {

13015

VkStructureType sType;

13016

void* pNext;

13017

VkSurfaceTransformFlagBitsKHR transform;

13018

} VkRenderPassTransformBeginInfoQCOM;

13019

13020

typedef struct VkCommandBufferInheritanceRenderPassTransformInfoQCOM {

13021

VkStructureType sType;

13022

void* pNext;

13023

VkSurfaceTransformFlagBitsKHR transform;

13024

VkRect2D renderArea;

13025

} VkCommandBufferInheritanceRenderPassTransformInfoQCOM;

13026

13027

13028

13029

#define VK_EXT_device_memory_report 1

13030

#define VK_EXT_DEVICE_MEMORY_REPORT_SPEC_VERSION 2

13031

#define VK_EXT_DEVICE_MEMORY_REPORT_EXTENSION_NAME "VK_EXT_device_memory_report"

13032

13033

typedef enum VkDeviceMemoryReportEventTypeEXT {

13034

VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT = 0,

13035

VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_FREE_EXT = 1,

13036

VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_IMPORT_EXT = 2,

13037

VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT = 3,

13038

VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATION_FAILED_EXT = 4,

13039

VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF

13040

} VkDeviceMemoryReportEventTypeEXT;

13041

typedef VkFlags VkDeviceMemoryReportFlagsEXT;

13042

typedef struct VkPhysicalDeviceDeviceMemoryReportFeaturesEXT {

13043

VkStructureType sType;

13044

void* pNext;

13045

VkBool32 deviceMemoryReport;

13046

} VkPhysicalDeviceDeviceMemoryReportFeaturesEXT;

13047

13048

typedef struct VkDeviceMemoryReportCallbackDataEXT {

13049

VkStructureType sType;

13050

void* pNext;

13051

VkDeviceMemoryReportFlagsEXT flags;

13052

VkDeviceMemoryReportEventTypeEXT type;

13053

uint64_t memoryObjectId;

13054

VkDeviceSize size;

13055

VkObjectType objectType;

13056

uint64_t objectHandle;

13057

uint32_t heapIndex;

13058

} VkDeviceMemoryReportCallbackDataEXT;

13059

13060

typedef void (VKAPI_PTR *PFN_vkDeviceMemoryReportCallbackEXT)(

13061

const VkDeviceMemoryReportCallbackDataEXT* pCallbackData,

13062

void* pUserData);

13063

13064

typedef struct VkDeviceDeviceMemoryReportCreateInfoEXT {

13065

VkStructureType sType;

13066

const void* pNext;

13067

VkDeviceMemoryReportFlagsEXT flags;

13068

PFN_vkDeviceMemoryReportCallbackEXT pfnUserCallback;

13069

void* pUserData;

13070

} VkDeviceDeviceMemoryReportCreateInfoEXT;

13071

13072

13073

13074

#define VK_EXT_acquire_drm_display 1

13075

#define VK_EXT_ACQUIRE_DRM_DISPLAY_SPEC_VERSION 1

13076

#define VK_EXT_ACQUIRE_DRM_DISPLAY_EXTENSION_NAME "VK_EXT_acquire_drm_display"

13077

typedef VkResult (VKAPI_PTR *PFN_vkAcquireDrmDisplayEXT)(VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display);

13078

typedef VkResult (VKAPI_PTR *PFN_vkGetDrmDisplayEXT)(VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR* display);

13079

13080

#ifndef VK_NO_PROTOTYPES

13081

VKAPI_ATTR VkResult VKAPI_CALL vkAcquireDrmDisplayEXT(

13082

VkPhysicalDevice physicalDevice,

13083

int32_t drmFd,

13084

VkDisplayKHR display);

13085

13086

VKAPI_ATTR VkResult VKAPI_CALL vkGetDrmDisplayEXT(

13087

VkPhysicalDevice physicalDevice,

13088

int32_t drmFd,

13089

uint32_t connectorId,

13090

VkDisplayKHR* display);

13091

#endif

13092

13093

13094

#define VK_EXT_robustness2 1

13095

#define VK_EXT_ROBUSTNESS_2_SPEC_VERSION 1

13096

#define VK_EXT_ROBUSTNESS_2_EXTENSION_NAME "VK_EXT_robustness2"

13097

typedef struct VkPhysicalDeviceRobustness2FeaturesEXT {

13098

VkStructureType sType;

13099

void* pNext;

13100

VkBool32 robustBufferAccess2;

13101

VkBool32 robustImageAccess2;

13102

VkBool32 nullDescriptor;

13103

} VkPhysicalDeviceRobustness2FeaturesEXT;

13104

13105

typedef struct VkPhysicalDeviceRobustness2PropertiesEXT {

13106

VkStructureType sType;

13107

void* pNext;

13108

VkDeviceSize robustStorageBufferAccessSizeAlignment;

13109

VkDeviceSize robustUniformBufferAccessSizeAlignment;

13110

} VkPhysicalDeviceRobustness2PropertiesEXT;

13111

13112

13113

13114

#define VK_EXT_custom_border_color 1

13115

#define VK_EXT_CUSTOM_BORDER_COLOR_SPEC_VERSION 12

13116

#define VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME "VK_EXT_custom_border_color"

13117

typedef struct VkSamplerCustomBorderColorCreateInfoEXT {

13118

VkStructureType sType;

13119

const void* pNext;

13120

VkClearColorValue customBorderColor;

13121

VkFormat format;

13122

} VkSamplerCustomBorderColorCreateInfoEXT;

13123

13124

typedef struct VkPhysicalDeviceCustomBorderColorPropertiesEXT {

13125

VkStructureType sType;

13126

void* pNext;

13127

uint32_t maxCustomBorderColorSamplers;

13128

} VkPhysicalDeviceCustomBorderColorPropertiesEXT;

13129

13130

typedef struct VkPhysicalDeviceCustomBorderColorFeaturesEXT {

13131

VkStructureType sType;

13132

void* pNext;

13133

VkBool32 customBorderColors;

13134

VkBool32 customBorderColorWithoutFormat;

13135

} VkPhysicalDeviceCustomBorderColorFeaturesEXT;

13136

13137

13138

13139

#define VK_GOOGLE_user_type 1

13140

#define VK_GOOGLE_USER_TYPE_SPEC_VERSION 1

13141

#define VK_GOOGLE_USER_TYPE_EXTENSION_NAME "VK_GOOGLE_user_type"

13142

13143

13144

#define VK_EXT_private_data 1

13145

typedef VkPrivateDataSlot VkPrivateDataSlotEXT;

13146

13147

#define VK_EXT_PRIVATE_DATA_SPEC_VERSION 1

13148

#define VK_EXT_PRIVATE_DATA_EXTENSION_NAME "VK_EXT_private_data"

13149

typedef VkPrivateDataSlotCreateFlags VkPrivateDataSlotCreateFlagsEXT;

13150

13151

typedef VkPhysicalDevicePrivateDataFeatures VkPhysicalDevicePrivateDataFeaturesEXT;

13152

13153

typedef VkDevicePrivateDataCreateInfo VkDevicePrivateDataCreateInfoEXT;

13154

13155

typedef VkPrivateDataSlotCreateInfo VkPrivateDataSlotCreateInfoEXT;

13156

13157

typedef VkResult (VKAPI_PTR *PFN_vkCreatePrivateDataSlotEXT)(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot);

13158

typedef void (VKAPI_PTR *PFN_vkDestroyPrivateDataSlotEXT)(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator);

13159

typedef VkResult (VKAPI_PTR *PFN_vkSetPrivateDataEXT)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data);

13160

typedef void (VKAPI_PTR *PFN_vkGetPrivateDataEXT)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData);

13161

13162

#ifndef VK_NO_PROTOTYPES

13163

VKAPI_ATTR VkResult VKAPI_CALL vkCreatePrivateDataSlotEXT(

13164

VkDevice device,

13165

const VkPrivateDataSlotCreateInfo* pCreateInfo,

13166

const VkAllocationCallbacks* pAllocator,

13167

VkPrivateDataSlot* pPrivateDataSlot);

13168

13169

VKAPI_ATTR void VKAPI_CALL vkDestroyPrivateDataSlotEXT(

13170

VkDevice device,

13171

VkPrivateDataSlot privateDataSlot,

13172

const VkAllocationCallbacks* pAllocator);

13173

13174

VKAPI_ATTR VkResult VKAPI_CALL vkSetPrivateDataEXT(

13175

VkDevice device,

13176

VkObjectType objectType,

13177

uint64_t objectHandle,

13178

VkPrivateDataSlot privateDataSlot,

13179

uint64_t data);

13180

13181

VKAPI_ATTR void VKAPI_CALL vkGetPrivateDataEXT(

13182

VkDevice device,

13183

VkObjectType objectType,

13184

uint64_t objectHandle,

13185

VkPrivateDataSlot privateDataSlot,

13186

uint64_t* pData);

13187

#endif

13188

13189

13190

#define VK_EXT_pipeline_creation_cache_control 1

13191

#define VK_EXT_PIPELINE_CREATION_CACHE_CONTROL_SPEC_VERSION 3

13192

#define VK_EXT_PIPELINE_CREATION_CACHE_CONTROL_EXTENSION_NAME "VK_EXT_pipeline_creation_cache_control"

13193

typedef VkPhysicalDevicePipelineCreationCacheControlFeatures VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT;

13194

13195

13196

13197

#define VK_NV_device_diagnostics_config 1

13198

#define VK_NV_DEVICE_DIAGNOSTICS_CONFIG_SPEC_VERSION 1

13199

#define VK_NV_DEVICE_DIAGNOSTICS_CONFIG_EXTENSION_NAME "VK_NV_device_diagnostics_config"

13200

13201

typedef enum VkDeviceDiagnosticsConfigFlagBitsNV {

13202

VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_DEBUG_INFO_BIT_NV = 0x00000001,

13203

VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_RESOURCE_TRACKING_BIT_NV = 0x00000002,

13204

VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_AUTOMATIC_CHECKPOINTS_BIT_NV = 0x00000004,

13205

VK_DEVICE_DIAGNOSTICS_CONFIG_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF

13206

} VkDeviceDiagnosticsConfigFlagBitsNV;

13207

typedef VkFlags VkDeviceDiagnosticsConfigFlagsNV;

13208

typedef struct VkPhysicalDeviceDiagnosticsConfigFeaturesNV {

13209

VkStructureType sType;

13210

void* pNext;

13211

VkBool32 diagnosticsConfig;

13212

} VkPhysicalDeviceDiagnosticsConfigFeaturesNV;

13213

13214

typedef struct VkDeviceDiagnosticsConfigCreateInfoNV {

13215

VkStructureType sType;

13216

const void* pNext;

13217

VkDeviceDiagnosticsConfigFlagsNV flags;

13218

} VkDeviceDiagnosticsConfigCreateInfoNV;

13219

13220

13221

13222

#define VK_QCOM_render_pass_store_ops 1

13223

#define VK_QCOM_RENDER_PASS_STORE_OPS_SPEC_VERSION 2

13224

#define VK_QCOM_RENDER_PASS_STORE_OPS_EXTENSION_NAME "VK_QCOM_render_pass_store_ops"

13225

13226

13227

#define VK_EXT_graphics_pipeline_library 1

13228

#define VK_EXT_GRAPHICS_PIPELINE_LIBRARY_SPEC_VERSION 1

13229

#define VK_EXT_GRAPHICS_PIPELINE_LIBRARY_EXTENSION_NAME "VK_EXT_graphics_pipeline_library"

13230

13231

typedef enum VkGraphicsPipelineLibraryFlagBitsEXT {

13232

VK_GRAPHICS_PIPELINE_LIBRARY_VERTEX_INPUT_INTERFACE_BIT_EXT = 0x00000001,

13233

VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT = 0x00000002,

13234

VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT = 0x00000004,

13235

VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT = 0x00000008,

13236

VK_GRAPHICS_PIPELINE_LIBRARY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF

13237

} VkGraphicsPipelineLibraryFlagBitsEXT;

13238

typedef VkFlags VkGraphicsPipelineLibraryFlagsEXT;

13239

typedef struct VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT {

13240

VkStructureType sType;

13241

void* pNext;

13242

VkBool32 graphicsPipelineLibrary;

13243

} VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT;

13244

13245

typedef struct VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT {

13246

VkStructureType sType;

13247

void* pNext;

13248

VkBool32 graphicsPipelineLibraryFastLinking;

13249

VkBool32 graphicsPipelineLibraryIndependentInterpolationDecoration;

13250

} VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT;

13251

13252

typedef struct VkGraphicsPipelineLibraryCreateInfoEXT {

13253

VkStructureType sType;

13254

void* pNext;

13255

VkGraphicsPipelineLibraryFlagsEXT flags;

13256

} VkGraphicsPipelineLibraryCreateInfoEXT;

13257

13258

13259

13260

#define VK_NV_fragment_shading_rate_enums 1

13261

#define VK_NV_FRAGMENT_SHADING_RATE_ENUMS_SPEC_VERSION 1

13262

#define VK_NV_FRAGMENT_SHADING_RATE_ENUMS_EXTENSION_NAME "VK_NV_fragment_shading_rate_enums"

13263

13264

typedef enum VkFragmentShadingRateTypeNV {

13265

VK_FRAGMENT_SHADING_RATE_TYPE_FRAGMENT_SIZE_NV = 0,

13266

VK_FRAGMENT_SHADING_RATE_TYPE_ENUMS_NV = 1,

13267

VK_FRAGMENT_SHADING_RATE_TYPE_MAX_ENUM_NV = 0x7FFFFFFF

13268

} VkFragmentShadingRateTypeNV;

13269

13270

typedef enum VkFragmentShadingRateNV {

13271

VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV = 0,

13272

VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_1X2_PIXELS_NV = 1,

13273

VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X1_PIXELS_NV = 4,

13274

VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X2_PIXELS_NV = 5,

13275

VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X4_PIXELS_NV = 6,

13276

VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X2_PIXELS_NV = 9,

13277

VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X4_PIXELS_NV = 10,

13278

VK_FRAGMENT_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV = 11,

13279

VK_FRAGMENT_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV = 12,

13280

VK_FRAGMENT_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV = 13,

13281

VK_FRAGMENT_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV = 14,

13282

VK_FRAGMENT_SHADING_RATE_NO_INVOCATIONS_NV = 15,

13283

VK_FRAGMENT_SHADING_RATE_MAX_ENUM_NV = 0x7FFFFFFF

13284

} VkFragmentShadingRateNV;

13285

typedef struct VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV {

13286

VkStructureType sType;

13287

void* pNext;

13288

VkBool32 fragmentShadingRateEnums;

13289

VkBool32 supersampleFragmentShadingRates;

13290

VkBool32 noInvocationFragmentShadingRates;

13291

} VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV;

13292

13293

typedef struct VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV {

13294

VkStructureType sType;

13295

void* pNext;

13296

VkSampleCountFlagBits maxFragmentShadingRateInvocationCount;

13297

} VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV;

13298

13299

typedef struct VkPipelineFragmentShadingRateEnumStateCreateInfoNV {

13300

VkStructureType sType;

13301

const void* pNext;

13302

VkFragmentShadingRateTypeNV shadingRateType;

13303

VkFragmentShadingRateNV shadingRate;

13304

VkFragmentShadingRateCombinerOpKHR combinerOps[2];

13305

} VkPipelineFragmentShadingRateEnumStateCreateInfoNV;

13306

13307

typedef void (VKAPI_PTR *PFN_vkCmdSetFragmentShadingRateEnumNV)(VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]);

13308

13309

#ifndef VK_NO_PROTOTYPES

13310

VKAPI_ATTR void VKAPI_CALL vkCmdSetFragmentShadingRateEnumNV(

13311

VkCommandBuffer commandBuffer,

13312

VkFragmentShadingRateNV shadingRate,

13313

const VkFragmentShadingRateCombinerOpKHR combinerOps[2]);

13314

#endif

13315

13316

13317

#define VK_NV_ray_tracing_motion_blur 1

13318

#define VK_NV_RAY_TRACING_MOTION_BLUR_SPEC_VERSION 1

13319

#define VK_NV_RAY_TRACING_MOTION_BLUR_EXTENSION_NAME "VK_NV_ray_tracing_motion_blur"

13320

13321

typedef enum VkAccelerationStructureMotionInstanceTypeNV {

13322

VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_STATIC_NV = 0,

13323

VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MATRIX_MOTION_NV = 1,

13324

VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_SRT_MOTION_NV = 2,

13325

VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MAX_ENUM_NV = 0x7FFFFFFF

13326

} VkAccelerationStructureMotionInstanceTypeNV;

13327

typedef VkFlags VkAccelerationStructureMotionInfoFlagsNV;

13328

typedef VkFlags VkAccelerationStructureMotionInstanceFlagsNV;

13329

typedef union VkDeviceOrHostAddressConstKHR {

13330

VkDeviceAddress deviceAddress;

13331

const void* hostAddress;

13332

} VkDeviceOrHostAddressConstKHR;

13333

13334

typedef struct VkAccelerationStructureGeometryMotionTrianglesDataNV {

13335

VkStructureType sType;

13336

const void* pNext;

13337

VkDeviceOrHostAddressConstKHR vertexData;

13338

} VkAccelerationStructureGeometryMotionTrianglesDataNV;

13339

13340

typedef struct VkAccelerationStructureMotionInfoNV {

13341

VkStructureType sType;

13342

const void* pNext;

13343

uint32_t maxInstances;

13344

VkAccelerationStructureMotionInfoFlagsNV flags;

13345

} VkAccelerationStructureMotionInfoNV;

13346

13347

typedef struct VkAccelerationStructureMatrixMotionInstanceNV {

13348

VkTransformMatrixKHR transformT0;

13349

VkTransformMatrixKHR transformT1;

13350

uint32_t instanceCustomIndex:24;

13351

uint32_t mask:8;

13352

uint32_t instanceShaderBindingTableRecordOffset:24;

13353

VkGeometryInstanceFlagsKHR flags:8;

13354

uint64_t accelerationStructureReference;

13355

} VkAccelerationStructureMatrixMotionInstanceNV;

13356

13357

typedef struct VkSRTDataNV {

13358

float sx;

13359

float a;

13360

float b;

13361

float pvx;

13362

float sy;

13363

float c;

13364

float pvy;

13365

float sz;

13366

float pvz;

13367

float qx;

13368

float qy;

13369

float qz;

13370

float qw;

13371

float tx;

13372

float ty;

13373

float tz;

13374

} VkSRTDataNV;

13375

13376

typedef struct VkAccelerationStructureSRTMotionInstanceNV {

13377

VkSRTDataNV transformT0;

13378

VkSRTDataNV transformT1;

13379

uint32_t instanceCustomIndex:24;

13380

uint32_t mask:8;

13381

uint32_t instanceShaderBindingTableRecordOffset:24;

13382

VkGeometryInstanceFlagsKHR flags:8;

13383

uint64_t accelerationStructureReference;

13384

} VkAccelerationStructureSRTMotionInstanceNV;

13385

13386

typedef union VkAccelerationStructureMotionInstanceDataNV {

13387

VkAccelerationStructureInstanceKHR staticInstance;

13388

VkAccelerationStructureMatrixMotionInstanceNV matrixMotionInstance;

13389

VkAccelerationStructureSRTMotionInstanceNV srtMotionInstance;

13390

} VkAccelerationStructureMotionInstanceDataNV;

13391

13392

typedef struct VkAccelerationStructureMotionInstanceNV {

13393

VkAccelerationStructureMotionInstanceTypeNV type;

13394

VkAccelerationStructureMotionInstanceFlagsNV flags;

13395

VkAccelerationStructureMotionInstanceDataNV data;

13396

} VkAccelerationStructureMotionInstanceNV;

13397

13398

typedef struct VkPhysicalDeviceRayTracingMotionBlurFeaturesNV {

13399

VkStructureType sType;

13400

void* pNext;

13401

VkBool32 rayTracingMotionBlur;

13402

VkBool32 rayTracingMotionBlurPipelineTraceRaysIndirect;

13403

} VkPhysicalDeviceRayTracingMotionBlurFeaturesNV;

13404

13405

13406

13407

#define VK_EXT_ycbcr_2plane_444_formats 1

13408

#define VK_EXT_YCBCR_2PLANE_444_FORMATS_SPEC_VERSION 1

13409

#define VK_EXT_YCBCR_2PLANE_444_FORMATS_EXTENSION_NAME "VK_EXT_ycbcr_2plane_444_formats"

13410

typedef struct VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {

13411

VkStructureType sType;

13412

void* pNext;

13413

VkBool32 ycbcr2plane444Formats;

13414

} VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT;

13415

13416

13417

13418

#define VK_EXT_fragment_density_map2 1

13419

#define VK_EXT_FRAGMENT_DENSITY_MAP_2_SPEC_VERSION 1

13420

#define VK_EXT_FRAGMENT_DENSITY_MAP_2_EXTENSION_NAME "VK_EXT_fragment_density_map2"

13421

typedef struct VkPhysicalDeviceFragmentDensityMap2FeaturesEXT {

13422

VkStructureType sType;

13423

void* pNext;

13424

VkBool32 fragmentDensityMapDeferred;

13425

} VkPhysicalDeviceFragmentDensityMap2FeaturesEXT;

13426

13427

typedef struct VkPhysicalDeviceFragmentDensityMap2PropertiesEXT {

13428

VkStructureType sType;

13429

void* pNext;

13430

VkBool32 subsampledLoads;

13431

VkBool32 subsampledCoarseReconstructionEarlyAccess;

13432

uint32_t maxSubsampledArrayLayers;

13433

uint32_t maxDescriptorSetSubsampledSamplers;

13434

} VkPhysicalDeviceFragmentDensityMap2PropertiesEXT;

13435

13436

13437

13438

#define VK_QCOM_rotated_copy_commands 1

13439

#define VK_QCOM_ROTATED_COPY_COMMANDS_SPEC_VERSION 1

13440

#define VK_QCOM_ROTATED_COPY_COMMANDS_EXTENSION_NAME "VK_QCOM_rotated_copy_commands"

13441

typedef struct VkCopyCommandTransformInfoQCOM {

13442

VkStructureType sType;

13443

const void* pNext;

13444

VkSurfaceTransformFlagBitsKHR transform;

13445

} VkCopyCommandTransformInfoQCOM;

13446

13447

13448

13449

#define VK_EXT_image_robustness 1

13450

#define VK_EXT_IMAGE_ROBUSTNESS_SPEC_VERSION 1

13451

#define VK_EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME "VK_EXT_image_robustness"

13452

typedef VkPhysicalDeviceImageRobustnessFeatures VkPhysicalDeviceImageRobustnessFeaturesEXT;

13453

13454

13455

13456

#define VK_EXT_4444_formats 1

13457

#define VK_EXT_4444_FORMATS_SPEC_VERSION 1

13458

#define VK_EXT_4444_FORMATS_EXTENSION_NAME "VK_EXT_4444_formats"

13459

typedef struct VkPhysicalDevice4444FormatsFeaturesEXT {

13460

VkStructureType sType;

13461

void* pNext;

13462

VkBool32 formatA4R4G4B4;

13463

VkBool32 formatA4B4G4R4;

13464

} VkPhysicalDevice4444FormatsFeaturesEXT;

13465

13466

13467

13468

#define VK_ARM_rasterization_order_attachment_access 1

13469

#define VK_ARM_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_SPEC_VERSION 1

13470

#define VK_ARM_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXTENSION_NAME "VK_ARM_rasterization_order_attachment_access"

13471

typedef struct VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM {

13472

VkStructureType sType;

13473

void* pNext;

13474

VkBool32 rasterizationOrderColorAttachmentAccess;

13475

VkBool32 rasterizationOrderDepthAttachmentAccess;

13476

VkBool32 rasterizationOrderStencilAttachmentAccess;

13477

} VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM;

13478

13479

13480

13481

#define VK_EXT_rgba10x6_formats 1

13482

#define VK_EXT_RGBA10X6_FORMATS_SPEC_VERSION 1

13483

#define VK_EXT_RGBA10X6_FORMATS_EXTENSION_NAME "VK_EXT_rgba10x6_formats"

13484

typedef struct VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT {

13485

VkStructureType sType;

13486

void* pNext;

13487

VkBool32 formatRgba10x6WithoutYCbCrSampler;

13488

} VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT;

13489

13490

13491

13492

#define VK_NV_acquire_winrt_display 1

13493

#define VK_NV_ACQUIRE_WINRT_DISPLAY_SPEC_VERSION 1

13494

#define VK_NV_ACQUIRE_WINRT_DISPLAY_EXTENSION_NAME "VK_NV_acquire_winrt_display"

13495

typedef VkResult (VKAPI_PTR *PFN_vkAcquireWinrtDisplayNV)(VkPhysicalDevice physicalDevice, VkDisplayKHR display);

13496

typedef VkResult (VKAPI_PTR *PFN_vkGetWinrtDisplayNV)(VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR* pDisplay);

13497

13498

#ifndef VK_NO_PROTOTYPES

13499

VKAPI_ATTR VkResult VKAPI_CALL vkAcquireWinrtDisplayNV(

13500

VkPhysicalDevice physicalDevice,

13501

VkDisplayKHR display);

13502

13503

VKAPI_ATTR VkResult VKAPI_CALL vkGetWinrtDisplayNV(

13504

VkPhysicalDevice physicalDevice,

13505

uint32_t deviceRelativeId,

13506

VkDisplayKHR* pDisplay);

13507

#endif

13508

13509

13510

#define VK_VALVE_mutable_descriptor_type 1

13511

#define VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION 1

13512

#define VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME "VK_VALVE_mutable_descriptor_type"

13513

typedef struct VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE {

13514

VkStructureType sType;

13515

void* pNext;

13516

VkBool32 mutableDescriptorType;

13517

} VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE;

13518

13519

typedef struct VkMutableDescriptorTypeListVALVE {

13520

uint32_t descriptorTypeCount;

13521

const VkDescriptorType* pDescriptorTypes;

13522

} VkMutableDescriptorTypeListVALVE;

13523

13524

typedef struct VkMutableDescriptorTypeCreateInfoVALVE {

13525

VkStructureType sType;

13526

const void* pNext;

13527

uint32_t mutableDescriptorTypeListCount;

13528

const VkMutableDescriptorTypeListVALVE* pMutableDescriptorTypeLists;

13529

} VkMutableDescriptorTypeCreateInfoVALVE;

13530

13531

13532

13533

#define VK_EXT_vertex_input_dynamic_state 1

13534

#define VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_SPEC_VERSION 2

13535

#define VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME "VK_EXT_vertex_input_dynamic_state"

13536

typedef struct VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT {

13537

VkStructureType sType;

13538

void* pNext;

13539

VkBool32 vertexInputDynamicState;

13540

} VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT;

13541

13542

typedef struct VkVertexInputBindingDescription2EXT {

13543

VkStructureType sType;

13544

void* pNext;

13545

uint32_t binding;

13546

uint32_t stride;

13547

VkVertexInputRate inputRate;

13548

uint32_t divisor;

13549

} VkVertexInputBindingDescription2EXT;

13550

13551

typedef struct VkVertexInputAttributeDescription2EXT {

13552

VkStructureType sType;

13553

void* pNext;

13554

uint32_t location;

13555

uint32_t binding;

13556

VkFormat format;

13557

uint32_t offset;

13558

} VkVertexInputAttributeDescription2EXT;

13559

13560

typedef void (VKAPI_PTR *PFN_vkCmdSetVertexInputEXT)(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions);

13561

13562

#ifndef VK_NO_PROTOTYPES

13563

VKAPI_ATTR void VKAPI_CALL vkCmdSetVertexInputEXT(

13564

VkCommandBuffer commandBuffer,

13565

uint32_t vertexBindingDescriptionCount,

13566

const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions,

13567

uint32_t vertexAttributeDescriptionCount,

13568

const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions);

13569

#endif

13570

13571

13572

#define VK_EXT_physical_device_drm 1

13573

#define VK_EXT_PHYSICAL_DEVICE_DRM_SPEC_VERSION 1

13574

#define VK_EXT_PHYSICAL_DEVICE_DRM_EXTENSION_NAME "VK_EXT_physical_device_drm"

13575

typedef struct VkPhysicalDeviceDrmPropertiesEXT {

13576

VkStructureType sType;

13577

void* pNext;

13578

VkBool32 hasPrimary;

13579

VkBool32 hasRender;

13580

int64_t primaryMajor;

13581

int64_t primaryMinor;

13582

int64_t renderMajor;

13583

int64_t renderMinor;

13584

} VkPhysicalDeviceDrmPropertiesEXT;

13585

13586

13587

13588

#define VK_EXT_depth_clip_control 1

13589

#define VK_EXT_DEPTH_CLIP_CONTROL_SPEC_VERSION 1

13590

#define VK_EXT_DEPTH_CLIP_CONTROL_EXTENSION_NAME "VK_EXT_depth_clip_control"

13591

typedef struct VkPhysicalDeviceDepthClipControlFeaturesEXT {

13592

VkStructureType sType;

13593

void* pNext;

13594

VkBool32 depthClipControl;

13595

} VkPhysicalDeviceDepthClipControlFeaturesEXT;

13596

13597

typedef struct VkPipelineViewportDepthClipControlCreateInfoEXT {

13598

VkStructureType sType;

13599

const void* pNext;

13600

VkBool32 negativeOneToOne;

13601

} VkPipelineViewportDepthClipControlCreateInfoEXT;

13602

13603

13604

13605

#define VK_EXT_primitive_topology_list_restart 1

13606

#define VK_EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_SPEC_VERSION 1

13607

#define VK_EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_EXTENSION_NAME "VK_EXT_primitive_topology_list_restart"

13608

typedef struct VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT {

13609

VkStructureType sType;

13610

void* pNext;

13611

VkBool32 primitiveTopologyListRestart;

13612

VkBool32 primitiveTopologyPatchListRestart;

13613

} VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT;

13614

13615

13616

13617

#define VK_HUAWEI_subpass_shading 1

13618

#define VK_HUAWEI_SUBPASS_SHADING_SPEC_VERSION 2

13619

#define VK_HUAWEI_SUBPASS_SHADING_EXTENSION_NAME "VK_HUAWEI_subpass_shading"

13620

typedef struct VkSubpassShadingPipelineCreateInfoHUAWEI {

13621

VkStructureType sType;

13622

void* pNext;

13623

VkRenderPass renderPass;

13624

uint32_t subpass;

13625

} VkSubpassShadingPipelineCreateInfoHUAWEI;

13626

13627

typedef struct VkPhysicalDeviceSubpassShadingFeaturesHUAWEI {

13628

VkStructureType sType;

13629

void* pNext;

13630

VkBool32 subpassShading;

13631

} VkPhysicalDeviceSubpassShadingFeaturesHUAWEI;

13632

13633

typedef struct VkPhysicalDeviceSubpassShadingPropertiesHUAWEI {

13634

VkStructureType sType;

13635

void* pNext;

13636

uint32_t maxSubpassShadingWorkgroupSizeAspectRatio;

13637

} VkPhysicalDeviceSubpassShadingPropertiesHUAWEI;

13638

13639

typedef VkResult (VKAPI_PTR *PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI)(VkDevice device, VkRenderPass renderpass, VkExtent2D* pMaxWorkgroupSize);

13640

typedef void (VKAPI_PTR *PFN_vkCmdSubpassShadingHUAWEI)(VkCommandBuffer commandBuffer);

13641

13642

#ifndef VK_NO_PROTOTYPES

13643

VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(

13644

VkDevice device,

13645

VkRenderPass renderpass,

13646

VkExtent2D* pMaxWorkgroupSize);

13647

13648

VKAPI_ATTR void VKAPI_CALL vkCmdSubpassShadingHUAWEI(

13649

VkCommandBuffer commandBuffer);

13650

#endif

13651

13652

13653

#define VK_HUAWEI_invocation_mask 1

13654

#define VK_HUAWEI_INVOCATION_MASK_SPEC_VERSION 1

13655

#define VK_HUAWEI_INVOCATION_MASK_EXTENSION_NAME "VK_HUAWEI_invocation_mask"

13656

typedef struct VkPhysicalDeviceInvocationMaskFeaturesHUAWEI {

13657

VkStructureType sType;

13658

void* pNext;

13659

VkBool32 invocationMask;

13660

} VkPhysicalDeviceInvocationMaskFeaturesHUAWEI;

13661

13662

typedef void (VKAPI_PTR *PFN_vkCmdBindInvocationMaskHUAWEI)(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout);

13663

13664

#ifndef VK_NO_PROTOTYPES

13665

VKAPI_ATTR void VKAPI_CALL vkCmdBindInvocationMaskHUAWEI(

13666

VkCommandBuffer commandBuffer,

13667

VkImageView imageView,

13668

VkImageLayout imageLayout);

13669

#endif

13670

13671

13672

#define VK_NV_external_memory_rdma 1

13673

typedef void* VkRemoteAddressNV;

13674

#define VK_NV_EXTERNAL_MEMORY_RDMA_SPEC_VERSION 1

13675

#define VK_NV_EXTERNAL_MEMORY_RDMA_EXTENSION_NAME "VK_NV_external_memory_rdma"

13676

typedef struct VkMemoryGetRemoteAddressInfoNV {

13677

VkStructureType sType;

13678

const void* pNext;

13679

VkDeviceMemory memory;

13680

VkExternalMemoryHandleTypeFlagBits handleType;

13681

} VkMemoryGetRemoteAddressInfoNV;

13682

13683

typedef struct VkPhysicalDeviceExternalMemoryRDMAFeaturesNV {

13684

VkStructureType sType;

13685

void* pNext;

13686

VkBool32 externalMemoryRDMA;

13687

} VkPhysicalDeviceExternalMemoryRDMAFeaturesNV;

13688

13689

typedef VkResult (VKAPI_PTR *PFN_vkGetMemoryRemoteAddressNV)(VkDevice device, const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, VkRemoteAddressNV* pAddress);

13690

13691

#ifndef VK_NO_PROTOTYPES

13692

VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryRemoteAddressNV(

13693

VkDevice device,

13694

const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo,

13695

VkRemoteAddressNV* pAddress);

13696

#endif

13697

13698

13699

#define VK_EXT_extended_dynamic_state2 1

13700

#define VK_EXT_EXTENDED_DYNAMIC_STATE_2_SPEC_VERSION 1

13701

#define VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME "VK_EXT_extended_dynamic_state2"

13702

typedef struct VkPhysicalDeviceExtendedDynamicState2FeaturesEXT {

13703

VkStructureType sType;

13704

void* pNext;

13705

VkBool32 extendedDynamicState2;

13706

VkBool32 extendedDynamicState2LogicOp;

13707

VkBool32 extendedDynamicState2PatchControlPoints;

13708

} VkPhysicalDeviceExtendedDynamicState2FeaturesEXT;

13709

13710

typedef void (VKAPI_PTR *PFN_vkCmdSetPatchControlPointsEXT)(VkCommandBuffer commandBuffer, uint32_t patchControlPoints);

13711

typedef void (VKAPI_PTR *PFN_vkCmdSetRasterizerDiscardEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable);

13712

typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBiasEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable);

13713

typedef void (VKAPI_PTR *PFN_vkCmdSetLogicOpEXT)(VkCommandBuffer commandBuffer, VkLogicOp logicOp);

13714

typedef void (VKAPI_PTR *PFN_vkCmdSetPrimitiveRestartEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable);

13715

13716

#ifndef VK_NO_PROTOTYPES

13717

VKAPI_ATTR void VKAPI_CALL vkCmdSetPatchControlPointsEXT(

13718

VkCommandBuffer commandBuffer,

13719

uint32_t patchControlPoints);

13720

13721

VKAPI_ATTR void VKAPI_CALL vkCmdSetRasterizerDiscardEnableEXT(

13722

VkCommandBuffer commandBuffer,

13723

VkBool32 rasterizerDiscardEnable);

13724

13725

VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBiasEnableEXT(

13726

VkCommandBuffer commandBuffer,

13727

VkBool32 depthBiasEnable);

13728

13729

VKAPI_ATTR void VKAPI_CALL vkCmdSetLogicOpEXT(

13730

VkCommandBuffer commandBuffer,

13731

VkLogicOp logicOp);

13732

13733

VKAPI_ATTR void VKAPI_CALL vkCmdSetPrimitiveRestartEnableEXT(

13734

VkCommandBuffer commandBuffer,

13735

VkBool32 primitiveRestartEnable);

13736

#endif

13737

13738

13739

#define VK_EXT_color_write_enable 1

13740

#define VK_EXT_COLOR_WRITE_ENABLE_SPEC_VERSION 1

13741

#define VK_EXT_COLOR_WRITE_ENABLE_EXTENSION_NAME "VK_EXT_color_write_enable"

13742

typedef struct VkPhysicalDeviceColorWriteEnableFeaturesEXT {

13743

VkStructureType sType;

13744

void* pNext;

13745

VkBool32 colorWriteEnable;

13746

} VkPhysicalDeviceColorWriteEnableFeaturesEXT;

13747

13748

typedef struct VkPipelineColorWriteCreateInfoEXT {

13749

VkStructureType sType;

13750

const void* pNext;

13751

uint32_t attachmentCount;

13752

const VkBool32* pColorWriteEnables;

13753

} VkPipelineColorWriteCreateInfoEXT;

13754

13755

typedef void (VKAPI_PTR *PFN_vkCmdSetColorWriteEnableEXT)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32* pColorWriteEnables);

13756

13757

#ifndef VK_NO_PROTOTYPES

13758

VKAPI_ATTR void VKAPI_CALL vkCmdSetColorWriteEnableEXT(

13759

VkCommandBuffer commandBuffer,

13760

uint32_t attachmentCount,

13761

const VkBool32* pColorWriteEnables);

13762

#endif

13763

13764

13765

#define VK_EXT_primitives_generated_query 1

13766

#define VK_EXT_PRIMITIVES_GENERATED_QUERY_SPEC_VERSION 1

13767

#define VK_EXT_PRIMITIVES_GENERATED_QUERY_EXTENSION_NAME "VK_EXT_primitives_generated_query"

13768

typedef struct VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT {

13769

VkStructureType sType;

13770

void* pNext;

13771

VkBool32 primitivesGeneratedQuery;

13772

VkBool32 primitivesGeneratedQueryWithRasterizerDiscard;

13773

VkBool32 primitivesGeneratedQueryWithNonZeroStreams;

13774

} VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT;

13775

13776

13777

13778

#define VK_EXT_global_priority_query 1

13779

#define VK_EXT_GLOBAL_PRIORITY_QUERY_SPEC_VERSION 1

13780

#define VK_EXT_GLOBAL_PRIORITY_QUERY_EXTENSION_NAME "VK_EXT_global_priority_query"

13781

#define VK_MAX_GLOBAL_PRIORITY_SIZE_EXT VK_MAX_GLOBAL_PRIORITY_SIZE_KHR

13782

typedef VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT;

13783

13784

typedef VkQueueFamilyGlobalPriorityPropertiesKHR VkQueueFamilyGlobalPriorityPropertiesEXT;

13785

13786

13787

13788

#define VK_EXT_image_view_min_lod 1

13789

#define VK_EXT_IMAGE_VIEW_MIN_LOD_SPEC_VERSION 1

13790

#define VK_EXT_IMAGE_VIEW_MIN_LOD_EXTENSION_NAME "VK_EXT_image_view_min_lod"

13791

typedef struct VkPhysicalDeviceImageViewMinLodFeaturesEXT {

13792

VkStructureType sType;

13793

void* pNext;

13794

VkBool32 minLod;

13795

} VkPhysicalDeviceImageViewMinLodFeaturesEXT;

13796

13797

typedef struct VkImageViewMinLodCreateInfoEXT {

13798

VkStructureType sType;

13799

const void* pNext;

13800

float minLod;

13801

} VkImageViewMinLodCreateInfoEXT;

13802

13803

13804

13805

#define VK_EXT_multi_draw 1

13806

#define VK_EXT_MULTI_DRAW_SPEC_VERSION 1

13807

#define VK_EXT_MULTI_DRAW_EXTENSION_NAME "VK_EXT_multi_draw"

13808

typedef struct VkPhysicalDeviceMultiDrawFeaturesEXT {

13809

VkStructureType sType;

13810

void* pNext;

13811

VkBool32 multiDraw;

13812

} VkPhysicalDeviceMultiDrawFeaturesEXT;

13813

13814

typedef struct VkPhysicalDeviceMultiDrawPropertiesEXT {

13815

VkStructureType sType;

13816

void* pNext;

13817

uint32_t maxMultiDrawCount;

13818

} VkPhysicalDeviceMultiDrawPropertiesEXT;

13819

13820

typedef struct VkMultiDrawInfoEXT {

13821

uint32_t firstVertex;

13822

uint32_t vertexCount;

13823

} VkMultiDrawInfoEXT;

13824

13825

typedef struct VkMultiDrawIndexedInfoEXT {

13826

uint32_t firstIndex;

13827

uint32_t indexCount;

13828

int32_t vertexOffset;

13829

} VkMultiDrawIndexedInfoEXT;

13830

13831

typedef void (VKAPI_PTR *PFN_vkCmdDrawMultiEXT)(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT* pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride);

13832

typedef void (VKAPI_PTR *PFN_vkCmdDrawMultiIndexedEXT)(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT* pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t* pVertexOffset);

13833

13834

#ifndef VK_NO_PROTOTYPES

13835

VKAPI_ATTR void VKAPI_CALL vkCmdDrawMultiEXT(

13836

VkCommandBuffer commandBuffer,

13837

uint32_t drawCount,

13838

const VkMultiDrawInfoEXT* pVertexInfo,

13839

uint32_t instanceCount,

13840

uint32_t firstInstance,

13841

uint32_t stride);

13842

13843

VKAPI_ATTR void VKAPI_CALL vkCmdDrawMultiIndexedEXT(

13844

VkCommandBuffer commandBuffer,

13845

uint32_t drawCount,

13846

const VkMultiDrawIndexedInfoEXT* pIndexInfo,

13847

uint32_t instanceCount,

13848

uint32_t firstInstance,

13849

uint32_t stride,

13850

const int32_t* pVertexOffset);

13851

#endif

13852

13853

13854

#define VK_EXT_image_2d_view_of_3d 1

13855

#define VK_EXT_IMAGE_2D_VIEW_OF_3D_SPEC_VERSION 1

13856

#define VK_EXT_IMAGE_2D_VIEW_OF_3D_EXTENSION_NAME "VK_EXT_image_2d_view_of_3d"

13857

typedef struct VkPhysicalDeviceImage2DViewOf3DFeaturesEXT {

13858

VkStructureType sType;

13859

void* pNext;

13860

VkBool32 image2DViewOf3D;

13861

VkBool32 sampler2DViewOf3D;

13862

} VkPhysicalDeviceImage2DViewOf3DFeaturesEXT;

13863

13864

13865

13866

#define VK_EXT_load_store_op_none 1

13867

#define VK_EXT_LOAD_STORE_OP_NONE_SPEC_VERSION 1

13868

#define VK_EXT_LOAD_STORE_OP_NONE_EXTENSION_NAME "VK_EXT_load_store_op_none"

13869

13870

13871

#define VK_EXT_border_color_swizzle 1

13872

#define VK_EXT_BORDER_COLOR_SWIZZLE_SPEC_VERSION 1

13873

#define VK_EXT_BORDER_COLOR_SWIZZLE_EXTENSION_NAME "VK_EXT_border_color_swizzle"

13874

typedef struct VkPhysicalDeviceBorderColorSwizzleFeaturesEXT {

13875

VkStructureType sType;

13876

void* pNext;

13877

VkBool32 borderColorSwizzle;

13878

VkBool32 borderColorSwizzleFromImage;

13879

} VkPhysicalDeviceBorderColorSwizzleFeaturesEXT;

13880

13881

typedef struct VkSamplerBorderColorComponentMappingCreateInfoEXT {

13882

VkStructureType sType;

13883

const void* pNext;

13884

VkComponentMapping components;

13885

VkBool32 srgb;

13886

} VkSamplerBorderColorComponentMappingCreateInfoEXT;

13887

13888

13889

13890

#define VK_EXT_pageable_device_local_memory 1

13891

#define VK_EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_SPEC_VERSION 1

13892

#define VK_EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_EXTENSION_NAME "VK_EXT_pageable_device_local_memory"

13893

typedef struct VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT {

13894

VkStructureType sType;

13895

void* pNext;

13896

VkBool32 pageableDeviceLocalMemory;

13897

} VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT;

13898

13899

typedef void (VKAPI_PTR *PFN_vkSetDeviceMemoryPriorityEXT)(VkDevice device, VkDeviceMemory memory, float priority);

13900

13901

#ifndef VK_NO_PROTOTYPES

13902

VKAPI_ATTR void VKAPI_CALL vkSetDeviceMemoryPriorityEXT(

13903

VkDevice device,

13904

VkDeviceMemory memory,

13905

float priority);

13906

#endif

13907

13908

13909

#define VK_VALVE_descriptor_set_host_mapping 1

13910

#define VK_VALVE_DESCRIPTOR_SET_HOST_MAPPING_SPEC_VERSION 1

13911

#define VK_VALVE_DESCRIPTOR_SET_HOST_MAPPING_EXTENSION_NAME "VK_VALVE_descriptor_set_host_mapping"

13912

typedef struct VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {

13913

VkStructureType sType;

13914

void* pNext;

13915

VkBool32 descriptorSetHostMapping;

13916

} VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE;

13917

13918

typedef struct VkDescriptorSetBindingReferenceVALVE {

13919

VkStructureType sType;

13920

const void* pNext;

13921

VkDescriptorSetLayout descriptorSetLayout;

13922

uint32_t binding;

13923

} VkDescriptorSetBindingReferenceVALVE;

13924

13925

typedef struct VkDescriptorSetLayoutHostMappingInfoVALVE {

13926

VkStructureType sType;

13927

void* pNext;

13928

size_t descriptorOffset;

13929

uint32_t descriptorSize;

13930

} VkDescriptorSetLayoutHostMappingInfoVALVE;

13931

13932

typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE)(VkDevice device, const VkDescriptorSetBindingReferenceVALVE* pBindingReference, VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping);

13933

typedef void (VKAPI_PTR *PFN_vkGetDescriptorSetHostMappingVALVE)(VkDevice device, VkDescriptorSet descriptorSet, void** ppData);

13934

13935

#ifndef VK_NO_PROTOTYPES

13936

VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetLayoutHostMappingInfoVALVE(

13937

VkDevice device,

13938

const VkDescriptorSetBindingReferenceVALVE* pBindingReference,

13939

VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping);

13940

13941

VKAPI_ATTR void VKAPI_CALL vkGetDescriptorSetHostMappingVALVE(

13942

VkDevice device,

13943

VkDescriptorSet descriptorSet,

13944

void** ppData);

13945

#endif

13946

13947

13948

#define VK_QCOM_fragment_density_map_offset 1

13949

#define VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION 1

13950

#define VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME "VK_QCOM_fragment_density_map_offset"

13951

typedef struct VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {

13952

VkStructureType sType;

13953

void* pNext;

13954

VkBool32 fragmentDensityMapOffset;

13955

} VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM;

13956

13957

typedef struct VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM {

13958

VkStructureType sType;

13959

void* pNext;

13960

VkExtent2D fragmentDensityOffsetGranularity;

13961

} VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM;

13962

13963

typedef struct VkSubpassFragmentDensityMapOffsetEndInfoQCOM {

13964

VkStructureType sType;

13965

const void* pNext;

13966

uint32_t fragmentDensityOffsetCount;

13967

const VkOffset2D* pFragmentDensityOffsets;

13968

} VkSubpassFragmentDensityMapOffsetEndInfoQCOM;

13969

13970

13971

13972

#define VK_NV_linear_color_attachment 1

13973

#define VK_NV_LINEAR_COLOR_ATTACHMENT_SPEC_VERSION 1

13974

#define VK_NV_LINEAR_COLOR_ATTACHMENT_EXTENSION_NAME "VK_NV_linear_color_attachment"

13975

typedef struct VkPhysicalDeviceLinearColorAttachmentFeaturesNV {

13976

VkStructureType sType;

13977

void* pNext;

13978

VkBool32 linearColorAttachment;

13979

} VkPhysicalDeviceLinearColorAttachmentFeaturesNV;

13980

13981

13982

13983

#define VK_GOOGLE_surfaceless_query 1

13984

#define VK_GOOGLE_SURFACELESS_QUERY_SPEC_VERSION 1

13985

#define VK_GOOGLE_SURFACELESS_QUERY_EXTENSION_NAME "VK_GOOGLE_surfaceless_query"

13986

13987

13988

#define VK_KHR_acceleration_structure 1

13989

VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkAccelerationStructureKHR)

13990

#define VK_KHR_ACCELERATION_STRUCTURE_SPEC_VERSION 13

13991

#define VK_KHR_ACCELERATION_STRUCTURE_EXTENSION_NAME "VK_KHR_acceleration_structure"

13992

13993

typedef enum VkBuildAccelerationStructureModeKHR {

13994

VK_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD_KHR = 0,

13995

VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR = 1,

13996

VK_BUILD_ACCELERATION_STRUCTURE_MODE_MAX_ENUM_KHR = 0x7FFFFFFF

13997

} VkBuildAccelerationStructureModeKHR;

13998

13999

typedef enum VkAccelerationStructureBuildTypeKHR {

14000

VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_KHR = 0,

14001

VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR = 1,

14002

VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_OR_DEVICE_KHR = 2,

14003

VK_ACCELERATION_STRUCTURE_BUILD_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF

14004

} VkAccelerationStructureBuildTypeKHR;

14005

14006

typedef enum VkAccelerationStructureCompatibilityKHR {

14007

VK_ACCELERATION_STRUCTURE_COMPATIBILITY_COMPATIBLE_KHR = 0,

14008

VK_ACCELERATION_STRUCTURE_COMPATIBILITY_INCOMPATIBLE_KHR = 1,

14009

VK_ACCELERATION_STRUCTURE_COMPATIBILITY_MAX_ENUM_KHR = 0x7FFFFFFF

14010

} VkAccelerationStructureCompatibilityKHR;

14011

14012

typedef enum VkAccelerationStructureCreateFlagBitsKHR {

14013

VK_ACCELERATION_STRUCTURE_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = 0x00000001,

14014

VK_ACCELERATION_STRUCTURE_CREATE_MOTION_BIT_NV = 0x00000004,

14015

VK_ACCELERATION_STRUCTURE_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF

14016

} VkAccelerationStructureCreateFlagBitsKHR;

14017

typedef VkFlags VkAccelerationStructureCreateFlagsKHR;

14018

typedef union VkDeviceOrHostAddressKHR {

14019

VkDeviceAddress deviceAddress;

14020

void* hostAddress;

14021

} VkDeviceOrHostAddressKHR;

14022

14023

typedef struct VkAccelerationStructureBuildRangeInfoKHR {

14024

uint32_t primitiveCount;

14025

uint32_t primitiveOffset;

14026

uint32_t firstVertex;

14027

uint32_t transformOffset;

14028

} VkAccelerationStructureBuildRangeInfoKHR;

14029

14030

typedef struct VkAccelerationStructureGeometryTrianglesDataKHR {

14031

VkStructureType sType;

14032

const void* pNext;

14033

VkFormat vertexFormat;

14034

VkDeviceOrHostAddressConstKHR vertexData;

14035

VkDeviceSize vertexStride;

14036

uint32_t maxVertex;

14037

VkIndexType indexType;

14038

VkDeviceOrHostAddressConstKHR indexData;

14039

VkDeviceOrHostAddressConstKHR transformData;

14040

} VkAccelerationStructureGeometryTrianglesDataKHR;

14041

14042

typedef struct VkAccelerationStructureGeometryAabbsDataKHR {

14043

VkStructureType sType;

14044

const void* pNext;

14045

VkDeviceOrHostAddressConstKHR data;

14046

VkDeviceSize stride;

14047

} VkAccelerationStructureGeometryAabbsDataKHR;

14048

14049

typedef struct VkAccelerationStructureGeometryInstancesDataKHR {

14050

VkStructureType sType;

14051

const void* pNext;

14052

VkBool32 arrayOfPointers;

14053

VkDeviceOrHostAddressConstKHR data;

14054

} VkAccelerationStructureGeometryInstancesDataKHR;

14055

14056

typedef union VkAccelerationStructureGeometryDataKHR {

14057

VkAccelerationStructureGeometryTrianglesDataKHR triangles;

14058

VkAccelerationStructureGeometryAabbsDataKHR aabbs;

14059

VkAccelerationStructureGeometryInstancesDataKHR instances;

14060

} VkAccelerationStructureGeometryDataKHR;

14061

14062

typedef struct VkAccelerationStructureGeometryKHR {

14063

VkStructureType sType;

14064

const void* pNext;

14065

VkGeometryTypeKHR geometryType;

14066

VkAccelerationStructureGeometryDataKHR geometry;

14067

VkGeometryFlagsKHR flags;

14068

} VkAccelerationStructureGeometryKHR;

14069

14070

typedef struct VkAccelerationStructureBuildGeometryInfoKHR {

14071

VkStructureType sType;

14072

const void* pNext;

14073

VkAccelerationStructureTypeKHR type;

14074

VkBuildAccelerationStructureFlagsKHR flags;

14075

VkBuildAccelerationStructureModeKHR mode;

14076

VkAccelerationStructureKHR srcAccelerationStructure;

14077

VkAccelerationStructureKHR dstAccelerationStructure;

14078

uint32_t geometryCount;

14079

const VkAccelerationStructureGeometryKHR* pGeometries;

14080

const VkAccelerationStructureGeometryKHR* const* ppGeometries;

14081

VkDeviceOrHostAddressKHR scratchData;

14082

} VkAccelerationStructureBuildGeometryInfoKHR;

14083

14084

typedef struct VkAccelerationStructureCreateInfoKHR {

14085

VkStructureType sType;

14086

const void* pNext;

14087

VkAccelerationStructureCreateFlagsKHR createFlags;

14088

VkBuffer buffer;

14089

VkDeviceSize offset;

14090

VkDeviceSize size;

14091

VkAccelerationStructureTypeKHR type;

14092

VkDeviceAddress deviceAddress;

14093

} VkAccelerationStructureCreateInfoKHR;

14094

14095

typedef struct VkWriteDescriptorSetAccelerationStructureKHR {

14096

VkStructureType sType;

14097

const void* pNext;

14098

uint32_t accelerationStructureCount;

14099

const VkAccelerationStructureKHR* pAccelerationStructures;

14100

} VkWriteDescriptorSetAccelerationStructureKHR;

14101

14102

typedef struct VkPhysicalDeviceAccelerationStructureFeaturesKHR {

14103

VkStructureType sType;

14104

void* pNext;

14105

VkBool32 accelerationStructure;

14106

VkBool32 accelerationStructureCaptureReplay;

14107

VkBool32 accelerationStructureIndirectBuild;

14108

VkBool32 accelerationStructureHostCommands;

14109

VkBool32 descriptorBindingAccelerationStructureUpdateAfterBind;

14110

} VkPhysicalDeviceAccelerationStructureFeaturesKHR;

14111

14112

typedef struct VkPhysicalDeviceAccelerationStructurePropertiesKHR {

14113

VkStructureType sType;

14114

void* pNext;

14115

uint64_t maxGeometryCount;

14116

uint64_t maxInstanceCount;

14117

uint64_t maxPrimitiveCount;

14118

uint32_t maxPerStageDescriptorAccelerationStructures;

14119

uint32_t maxPerStageDescriptorUpdateAfterBindAccelerationStructures;

14120

uint32_t maxDescriptorSetAccelerationStructures;

14121

uint32_t maxDescriptorSetUpdateAfterBindAccelerationStructures;

14122

uint32_t minAccelerationStructureScratchOffsetAlignment;

14123

} VkPhysicalDeviceAccelerationStructurePropertiesKHR;

14124

14125

typedef struct VkAccelerationStructureDeviceAddressInfoKHR {

14126

VkStructureType sType;

14127

const void* pNext;

14128

VkAccelerationStructureKHR accelerationStructure;

14129

} VkAccelerationStructureDeviceAddressInfoKHR;

14130

14131

typedef struct VkAccelerationStructureVersionInfoKHR {

14132

VkStructureType sType;

14133

const void* pNext;

14134

const uint8_t* pVersionData;

14135

} VkAccelerationStructureVersionInfoKHR;

14136

14137

typedef struct VkCopyAccelerationStructureToMemoryInfoKHR {

14138

VkStructureType sType;

14139

const void* pNext;

14140

VkAccelerationStructureKHR src;

14141

VkDeviceOrHostAddressKHR dst;

14142

VkCopyAccelerationStructureModeKHR mode;

14143

} VkCopyAccelerationStructureToMemoryInfoKHR;

14144

14145

typedef struct VkCopyMemoryToAccelerationStructureInfoKHR {

14146

VkStructureType sType;

14147

const void* pNext;

14148

VkDeviceOrHostAddressConstKHR src;

14149

VkAccelerationStructureKHR dst;

14150

VkCopyAccelerationStructureModeKHR mode;

14151

} VkCopyMemoryToAccelerationStructureInfoKHR;

14152

14153

typedef struct VkCopyAccelerationStructureInfoKHR {

14154

VkStructureType sType;

14155

const void* pNext;

14156

VkAccelerationStructureKHR src;

14157

VkAccelerationStructureKHR dst;

14158

VkCopyAccelerationStructureModeKHR mode;

14159

} VkCopyAccelerationStructureInfoKHR;

14160

14161

typedef struct VkAccelerationStructureBuildSizesInfoKHR {

14162

VkStructureType sType;

14163

const void* pNext;

14164

VkDeviceSize accelerationStructureSize;

14165

VkDeviceSize updateScratchSize;

14166

VkDeviceSize buildScratchSize;

14167

} VkAccelerationStructureBuildSizesInfoKHR;

14168

14169

typedef VkResult (VKAPI_PTR *PFN_vkCreateAccelerationStructureKHR)(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure);

14170

typedef void (VKAPI_PTR *PFN_vkDestroyAccelerationStructureKHR)(VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks* pAllocator);

14171

typedef void (VKAPI_PTR *PFN_vkCmdBuildAccelerationStructuresKHR)(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos);

14172

typedef void (VKAPI_PTR *PFN_vkCmdBuildAccelerationStructuresIndirectKHR)(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkDeviceAddress* pIndirectDeviceAddresses, const uint32_t* pIndirectStrides, const uint32_t* const* ppMaxPrimitiveCounts);

14173

typedef VkResult (VKAPI_PTR *PFN_vkBuildAccelerationStructuresKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos);

14174

typedef VkResult (VKAPI_PTR *PFN_vkCopyAccelerationStructureKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR* pInfo);

14175

typedef VkResult (VKAPI_PTR *PFN_vkCopyAccelerationStructureToMemoryKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo);

14176

typedef VkResult (VKAPI_PTR *PFN_vkCopyMemoryToAccelerationStructureKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo);

14177

typedef VkResult (VKAPI_PTR *PFN_vkWriteAccelerationStructuresPropertiesKHR)(VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, size_t dataSize, void* pData, size_t stride);

14178

typedef void (VKAPI_PTR *PFN_vkCmdCopyAccelerationStructureKHR)(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR* pInfo);

14179

typedef void (VKAPI_PTR *PFN_vkCmdCopyAccelerationStructureToMemoryKHR)(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo);

14180

typedef void (VKAPI_PTR *PFN_vkCmdCopyMemoryToAccelerationStructureKHR)(VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo);

14181

typedef VkDeviceAddress (VKAPI_PTR *PFN_vkGetAccelerationStructureDeviceAddressKHR)(VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR* pInfo);

14182

typedef void (VKAPI_PTR *PFN_vkCmdWriteAccelerationStructuresPropertiesKHR)(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery);

14183

typedef void (VKAPI_PTR *PFN_vkGetDeviceAccelerationStructureCompatibilityKHR)(VkDevice device, const VkAccelerationStructureVersionInfoKHR* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility);

14184

typedef void (VKAPI_PTR *PFN_vkGetAccelerationStructureBuildSizesKHR)(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, const uint32_t* pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo);

14185

14186

#ifndef VK_NO_PROTOTYPES

14187

VKAPI_ATTR VkResult VKAPI_CALL vkCreateAccelerationStructureKHR(

14188

VkDevice device,

14189

const VkAccelerationStructureCreateInfoKHR* pCreateInfo,

14190

const VkAllocationCallbacks* pAllocator,

14191

VkAccelerationStructureKHR* pAccelerationStructure);

14192

14193

VKAPI_ATTR void VKAPI_CALL vkDestroyAccelerationStructureKHR(

14194

VkDevice device,

14195

VkAccelerationStructureKHR accelerationStructure,

14196

const VkAllocationCallbacks* pAllocator);

14197

14198

VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructuresKHR(

14199

VkCommandBuffer commandBuffer,

14200

uint32_t infoCount,

14201

const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,

14202

const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos);

14203

14204

VKAPI_ATTR void VKAPI_CALL vkCmdBuildAccelerationStructuresIndirectKHR(

14205

VkCommandBuffer commandBuffer,

14206

uint32_t infoCount,

14207

const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,

14208

const VkDeviceAddress* pIndirectDeviceAddresses,

14209

const uint32_t* pIndirectStrides,

14210

const uint32_t* const* ppMaxPrimitiveCounts);

14211

14212

VKAPI_ATTR VkResult VKAPI_CALL vkBuildAccelerationStructuresKHR(

14213

VkDevice device,

14214

VkDeferredOperationKHR deferredOperation,

14215

uint32_t infoCount,

14216

const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,

14217

const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos);

14218

14219

VKAPI_ATTR VkResult VKAPI_CALL vkCopyAccelerationStructureKHR(

14220

VkDevice device,

14221

VkDeferredOperationKHR deferredOperation,

14222

const VkCopyAccelerationStructureInfoKHR* pInfo);

14223

14224

VKAPI_ATTR VkResult VKAPI_CALL vkCopyAccelerationStructureToMemoryKHR(

14225

VkDevice device,

14226

VkDeferredOperationKHR deferredOperation,

14227

const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo);

14228

14229

VKAPI_ATTR VkResult VKAPI_CALL vkCopyMemoryToAccelerationStructureKHR(

14230

VkDevice device,

14231

VkDeferredOperationKHR deferredOperation,

14232

const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo);

14233

14234

VKAPI_ATTR VkResult VKAPI_CALL vkWriteAccelerationStructuresPropertiesKHR(

14235

VkDevice device,

14236

uint32_t accelerationStructureCount,

14237

const VkAccelerationStructureKHR* pAccelerationStructures,

14238

VkQueryType queryType,

14239

size_t dataSize,

14240

void* pData,

14241

size_t stride);

14242

14243

VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureKHR(

14244

VkCommandBuffer commandBuffer,

14245

const VkCopyAccelerationStructureInfoKHR* pInfo);

14246

14247

VKAPI_ATTR void VKAPI_CALL vkCmdCopyAccelerationStructureToMemoryKHR(

14248

VkCommandBuffer commandBuffer,

14249

const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo);

14250

14251

VKAPI_ATTR void VKAPI_CALL vkCmdCopyMemoryToAccelerationStructureKHR(

14252

VkCommandBuffer commandBuffer,

14253

const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo);

14254

14255

VKAPI_ATTR VkDeviceAddress VKAPI_CALL vkGetAccelerationStructureDeviceAddressKHR(

14256

VkDevice device,

14257

const VkAccelerationStructureDeviceAddressInfoKHR* pInfo);

14258

14259

VKAPI_ATTR void VKAPI_CALL vkCmdWriteAccelerationStructuresPropertiesKHR(

14260

VkCommandBuffer commandBuffer,

14261

uint32_t accelerationStructureCount,

14262

const VkAccelerationStructureKHR* pAccelerationStructures,

14263

VkQueryType queryType,

14264

VkQueryPool queryPool,

14265

uint32_t firstQuery);

14266

14267

VKAPI_ATTR void VKAPI_CALL vkGetDeviceAccelerationStructureCompatibilityKHR(

14268

VkDevice device,

14269

const VkAccelerationStructureVersionInfoKHR* pVersionInfo,

14270

VkAccelerationStructureCompatibilityKHR* pCompatibility);

14271

14272

VKAPI_ATTR void VKAPI_CALL vkGetAccelerationStructureBuildSizesKHR(

14273

VkDevice device,

14274

VkAccelerationStructureBuildTypeKHR buildType,

14275

const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo,

14276

const uint32_t* pMaxPrimitiveCounts,

14277

VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo);

14278

#endif

14279

14280

14281

#define VK_KHR_ray_tracing_pipeline 1

14282

#define VK_KHR_RAY_TRACING_PIPELINE_SPEC_VERSION 1

14283

#define VK_KHR_RAY_TRACING_PIPELINE_EXTENSION_NAME "VK_KHR_ray_tracing_pipeline"

14284

14285

typedef enum VkShaderGroupShaderKHR {

14286

VK_SHADER_GROUP_SHADER_GENERAL_KHR = 0,

14287

VK_SHADER_GROUP_SHADER_CLOSEST_HIT_KHR = 1,

14288

VK_SHADER_GROUP_SHADER_ANY_HIT_KHR = 2,

14289

VK_SHADER_GROUP_SHADER_INTERSECTION_KHR = 3,

14290

VK_SHADER_GROUP_SHADER_MAX_ENUM_KHR = 0x7FFFFFFF

14291

} VkShaderGroupShaderKHR;

14292

typedef struct VkRayTracingShaderGroupCreateInfoKHR {

14293

VkStructureType sType;

14294

const void* pNext;

14295

VkRayTracingShaderGroupTypeKHR type;

14296

uint32_t generalShader;

14297

uint32_t closestHitShader;

14298

uint32_t anyHitShader;

14299

uint32_t intersectionShader;

14300

const void* pShaderGroupCaptureReplayHandle;

14301

} VkRayTracingShaderGroupCreateInfoKHR;

14302

14303

typedef struct VkRayTracingPipelineInterfaceCreateInfoKHR {

14304

VkStructureType sType;

14305

const void* pNext;

14306

uint32_t maxPipelineRayPayloadSize;

14307

uint32_t maxPipelineRayHitAttributeSize;

14308

} VkRayTracingPipelineInterfaceCreateInfoKHR;

14309

14310

typedef struct VkRayTracingPipelineCreateInfoKHR {

14311

VkStructureType sType;

14312

const void* pNext;

14313

VkPipelineCreateFlags flags;

14314

uint32_t stageCount;

14315

const VkPipelineShaderStageCreateInfo* pStages;

14316

uint32_t groupCount;

14317

const VkRayTracingShaderGroupCreateInfoKHR* pGroups;

14318

uint32_t maxPipelineRayRecursionDepth;

14319

const VkPipelineLibraryCreateInfoKHR* pLibraryInfo;

14320

const VkRayTracingPipelineInterfaceCreateInfoKHR* pLibraryInterface;

14321

const VkPipelineDynamicStateCreateInfo* pDynamicState;

14322

VkPipelineLayout layout;

14323

VkPipeline basePipelineHandle;

14324

int32_t basePipelineIndex;

14325

} VkRayTracingPipelineCreateInfoKHR;

14326

14327

typedef struct VkPhysicalDeviceRayTracingPipelineFeaturesKHR {

14328

VkStructureType sType;

14329

void* pNext;

14330

VkBool32 rayTracingPipeline;

14331

VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplay;

14332

VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplayMixed;

14333

VkBool32 rayTracingPipelineTraceRaysIndirect;

14334

VkBool32 rayTraversalPrimitiveCulling;

14335

} VkPhysicalDeviceRayTracingPipelineFeaturesKHR;

14336

14337

typedef struct VkPhysicalDeviceRayTracingPipelinePropertiesKHR {

14338

VkStructureType sType;

14339

void* pNext;

14340

uint32_t shaderGroupHandleSize;

14341

uint32_t maxRayRecursionDepth;

14342

uint32_t maxShaderGroupStride;

14343

uint32_t shaderGroupBaseAlignment;

14344

uint32_t shaderGroupHandleCaptureReplaySize;

14345

uint32_t maxRayDispatchInvocationCount;

14346

uint32_t shaderGroupHandleAlignment;

14347

uint32_t maxRayHitAttributeSize;

14348

} VkPhysicalDeviceRayTracingPipelinePropertiesKHR;

14349

14350

typedef struct VkStridedDeviceAddressRegionKHR {

14351

VkDeviceAddress deviceAddress;

14352

VkDeviceSize stride;

14353

VkDeviceSize size;

14354

} VkStridedDeviceAddressRegionKHR;

14355

14356

typedef struct VkTraceRaysIndirectCommandKHR {

14357

uint32_t width;

14358

uint32_t height;

14359

uint32_t depth;

14360

} VkTraceRaysIndirectCommandKHR;

14361

14362

typedef void (VKAPI_PTR *PFN_vkCmdTraceRaysKHR)(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth);

14363

typedef VkResult (VKAPI_PTR *PFN_vkCreateRayTracingPipelinesKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);

14364

typedef VkResult (VKAPI_PTR *PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData);

14365

typedef void (VKAPI_PTR *PFN_vkCmdTraceRaysIndirectKHR)(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress);

14366

typedef VkDeviceSize (VKAPI_PTR *PFN_vkGetRayTracingShaderGroupStackSizeKHR)(VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader);

14367

typedef void (VKAPI_PTR *PFN_vkCmdSetRayTracingPipelineStackSizeKHR)(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize);

14368

14369

#ifndef VK_NO_PROTOTYPES

14370

VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysKHR(

14371

VkCommandBuffer commandBuffer,

14372

const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable,

14373

const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable,

14374

const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable,

14375

const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable,

14376

uint32_t width,

14377

uint32_t height,

14378

uint32_t depth);

14379

14380

VKAPI_ATTR VkResult VKAPI_CALL vkCreateRayTracingPipelinesKHR(

14381

VkDevice device,

14382

VkDeferredOperationKHR deferredOperation,

14383

VkPipelineCache pipelineCache,

14384

uint32_t createInfoCount,

14385

const VkRayTracingPipelineCreateInfoKHR* pCreateInfos,

14386

const VkAllocationCallbacks* pAllocator,

14387

VkPipeline* pPipelines);

14388

14389

VKAPI_ATTR VkResult VKAPI_CALL vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(

14390

VkDevice device,

14391

VkPipeline pipeline,

14392

uint32_t firstGroup,

14393

uint32_t groupCount,

14394

size_t dataSize,

14395

void* pData);

14396

14397

VKAPI_ATTR void VKAPI_CALL vkCmdTraceRaysIndirectKHR(

14398

VkCommandBuffer commandBuffer,

14399

const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable,

14400

const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable,

14401

const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable,

14402

const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable,

14403

VkDeviceAddress indirectDeviceAddress);

14404

14405

VKAPI_ATTR VkDeviceSize VKAPI_CALL vkGetRayTracingShaderGroupStackSizeKHR(

14406

VkDevice device,

14407

VkPipeline pipeline,

14408

uint32_t group,

14409

VkShaderGroupShaderKHR groupShader);

14410

14411

VKAPI_ATTR void VKAPI_CALL vkCmdSetRayTracingPipelineStackSizeKHR(

14412

VkCommandBuffer commandBuffer,

14413

uint32_t pipelineStackSize);

14414

#endif

14415

14416

14417

#define VK_KHR_ray_query 1

14418

#define VK_KHR_RAY_QUERY_SPEC_VERSION 1

14419

#define VK_KHR_RAY_QUERY_EXTENSION_NAME "VK_KHR_ray_query"

14420

typedef struct VkPhysicalDeviceRayQueryFeaturesKHR {

14421

VkStructureType sType;

14422

void* pNext;

14423

VkBool32 rayQuery;

14424

} VkPhysicalDeviceRayQueryFeaturesKHR;

14425

14426

14427

#ifdef __cplusplus

14428

}

14429

#endif

14430

14431

#endif

Older »