1#![allow(missing_docs)]
16#![allow(unused_unsafe)]
18use ash::vk;
19use smallvec::smallvec;
20use std::{
21 borrow::Borrow,
22 collections::HashSet,
23 ffi::{c_char, c_int, c_void, CStr},
24 ptr::NonNull,
25 sync::Arc,
26};
27
28use super::{
29 bool_iterator_from_raw_parts, get_device_proc_addr_loader, get_instance_proc_addr_loader,
30 maybe_slice_from_raw_parts, maybe_uninit_slice_from_raw_parts_mut,
31 uninit_slice_from_raw_parts_mut, ApiVersion, Feature, TryFromExtensionError, VulkanCommand,
32};
33use crate::{
34 fill_vk_out_array,
35 vk_utils::{ptr_as_uninit_mut, slice_from_raw_parts},
36 DeviceHooks, DeviceInfo, Global, InstanceHooks, InstanceInfo, Layer, LayerResult,
37 LayerVulkanCommand,
38};
39
40#[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Debug)]
41pub enum Extension {
42 KHRSurface,
43 KHRSwapchain,
44 KHRDisplay,
45 KHRDisplaySwapchain,
46 KHRXlibSurface,
47 KHRXcbSurface,
48 KHRWaylandSurface,
49 KHRAndroidSurface,
50 KHRWin32Surface,
51 KHRSamplerMirrorClampToEdge,
52 KHRVideoQueue,
53 KHRVideoDecodeQueue,
54 KHRVideoDecodeH264,
55 KHRDynamicRendering,
56 KHRMultiview,
57 KHRGetPhysicalDeviceProperties2,
58 KHRDeviceGroup,
59 KHRShaderDrawParameters,
60 KHRMaintenance1,
61 KHRDeviceGroupCreation,
62 KHRExternalMemoryCapabilities,
63 KHRExternalMemory,
64 KHRExternalMemoryWin32,
65 KHRExternalMemoryFd,
66 KHRWin32KeyedMutex,
67 KHRExternalSemaphoreCapabilities,
68 KHRExternalSemaphore,
69 KHRExternalSemaphoreWin32,
70 KHRExternalSemaphoreFd,
71 KHRPushDescriptor,
72 KHRShaderFloat16Int8,
73 KHR16bitStorage,
74 KHRIncrementalPresent,
75 KHRDescriptorUpdateTemplate,
76 KHRImagelessFramebuffer,
77 KHRCreateRenderpass2,
78 KHRSharedPresentableImage,
79 KHRExternalFenceCapabilities,
80 KHRExternalFence,
81 KHRExternalFenceWin32,
82 KHRExternalFenceFd,
83 KHRPerformanceQuery,
84 KHRMaintenance2,
85 KHRGetSurfaceCapabilities2,
86 KHRVariablePointers,
87 KHRGetDisplayProperties2,
88 KHRDedicatedAllocation,
89 KHRStorageBufferStorageClass,
90 KHRRelaxedBlockLayout,
91 KHRGetMemoryRequirements2,
92 KHRImageFormatList,
93 KHRSamplerYcbcrConversion,
94 KHRBindMemory2,
95 KHRPortabilitySubset,
96 KHRMaintenance3,
97 KHRDrawIndirectCount,
98 KHRShaderSubgroupExtendedTypes,
99 KHR8bitStorage,
100 KHRShaderAtomicInt64,
101 KHRShaderClock,
102 KHRVideoDecodeH265,
103 KHRGlobalPriority,
104 KHRDriverProperties,
105 KHRShaderFloatControls,
106 KHRDepthStencilResolve,
107 KHRSwapchainMutableFormat,
108 KHRTimelineSemaphore,
109 KHRVulkanMemoryModel,
110 KHRShaderTerminateInvocation,
111 KHRFragmentShadingRate,
112 KHRSpirv14,
113 KHRSurfaceProtectedCapabilities,
114 KHRSeparateDepthStencilLayouts,
115 KHRPresentWait,
116 KHRUniformBufferStandardLayout,
117 KHRBufferDeviceAddress,
118 KHRDeferredHostOperations,
119 KHRPipelineExecutableProperties,
120 KHRMapMemory2,
121 KHRShaderIntegerDotProduct,
122 KHRPipelineLibrary,
123 KHRShaderNonSemanticInfo,
124 KHRPresentId,
125 KHRVideoEncodeQueue,
126 KHRSynchronization2,
127 KHRFragmentShaderBarycentric,
128 KHRShaderSubgroupUniformControlFlow,
129 KHRZeroInitializeWorkgroupMemory,
130 KHRWorkgroupMemoryExplicitLayout,
131 KHRCopyCommands2,
132 KHRFormatFeatureFlags2,
133 KHRRayTracingMaintenance1,
134 KHRPortabilityEnumeration,
135 KHRMaintenance4,
136 KHRRayTracingPositionFetch,
137 ANDROIDNativeBuffer,
138 EXTDebugReport,
139 NVGlslShader,
140 EXTDepthRangeUnrestricted,
141 IMGFilterCubic,
142 AMDRasterizationOrder,
143 AMDShaderTrinaryMinmax,
144 AMDShaderExplicitVertexParameter,
145 EXTDebugMarker,
146 AMDGcnShader,
147 NVDedicatedAllocation,
148 EXTTransformFeedback,
149 NVXBinaryImport,
150 NVXImageViewHandle,
151 AMDDrawIndirectCount,
152 AMDNegativeViewportHeight,
153 AMDGpuShaderHalfFloat,
154 AMDShaderBallot,
155 EXTVideoEncodeH264,
156 EXTVideoEncodeH265,
157 AMDTextureGatherBiasLod,
158 AMDShaderInfo,
159 AMDShaderImageLoadStoreLod,
160 GGPStreamDescriptorSurface,
161 NVCornerSampledImage,
162 IMGFormatPvrtc,
163 NVExternalMemoryCapabilities,
164 NVExternalMemory,
165 NVExternalMemoryWin32,
166 NVWin32KeyedMutex,
167 EXTValidationFlags,
168 NNViSurface,
169 EXTShaderSubgroupBallot,
170 EXTShaderSubgroupVote,
171 EXTTextureCompressionAstcHdr,
172 EXTAstcDecodeMode,
173 EXTPipelineRobustness,
174 EXTConditionalRendering,
175 NVClipSpaceWScaling,
176 EXTDirectModeDisplay,
177 EXTAcquireXlibDisplay,
178 EXTDisplaySurfaceCounter,
179 EXTDisplayControl,
180 GOOGLEDisplayTiming,
181 NVSampleMaskOverrideCoverage,
182 NVGeometryShaderPassthrough,
183 NVViewportArray2,
184 NVXMultiviewPerViewAttributes,
185 NVViewportSwizzle,
186 EXTDiscardRectangles,
187 EXTConservativeRasterization,
188 EXTDepthClipEnable,
189 EXTSwapchainColorspace,
190 EXTHdrMetadata,
191 MVKIosSurface,
192 MVKMacosSurface,
193 EXTExternalMemoryDmaBuf,
194 EXTQueueFamilyForeign,
195 EXTDebugUtils,
196 ANDROIDExternalMemoryAndroidHardwareBuffer,
197 EXTSamplerFilterMinmax,
198 AMDGpuShaderInt16,
199 AMDMixedAttachmentSamples,
200 AMDShaderFragmentMask,
201 EXTInlineUniformBlock,
202 EXTShaderStencilExport,
203 EXTSampleLocations,
204 EXTBlendOperationAdvanced,
205 NVFragmentCoverageToColor,
206 NVFramebufferMixedSamples,
207 NVFillRectangle,
208 NVShaderSmBuiltins,
209 EXTPostDepthCoverage,
210 EXTImageDrmFormatModifier,
211 EXTValidationCache,
212 EXTDescriptorIndexing,
213 EXTShaderViewportIndexLayer,
214 NVShadingRateImage,
215 NVRayTracing,
216 NVRepresentativeFragmentTest,
217 EXTFilterCubic,
218 QCOMRenderPassShaderResolve,
219 EXTGlobalPriority,
220 EXTExternalMemoryHost,
221 AMDBufferMarker,
222 AMDPipelineCompilerControl,
223 EXTCalibratedTimestamps,
224 AMDShaderCoreProperties,
225 AMDMemoryOverallocationBehavior,
226 EXTVertexAttributeDivisor,
227 GGPFrameToken,
228 EXTPipelineCreationFeedback,
229 NVShaderSubgroupPartitioned,
230 NVComputeShaderDerivatives,
231 NVMeshShader,
232 NVFragmentShaderBarycentric,
233 NVShaderImageFootprint,
234 NVScissorExclusive,
235 NVDeviceDiagnosticCheckpoints,
236 INTELShaderIntegerFunctions2,
237 INTELPerformanceQuery,
238 EXTPciBusInfo,
239 AMDDisplayNativeHdr,
240 FUCHSIAImagepipeSurface,
241 EXTMetalSurface,
242 EXTFragmentDensityMap,
243 EXTScalarBlockLayout,
244 GOOGLEHlslFunctionality1,
245 GOOGLEDecorateString,
246 EXTSubgroupSizeControl,
247 AMDShaderCoreProperties2,
248 AMDDeviceCoherentMemory,
249 EXTShaderImageAtomicInt64,
250 EXTMemoryBudget,
251 EXTMemoryPriority,
252 NVDedicatedAllocationImageAliasing,
253 EXTBufferDeviceAddress,
254 EXTToolingInfo,
255 EXTSeparateStencilUsage,
256 EXTValidationFeatures,
257 NVCooperativeMatrix,
258 NVCoverageReductionMode,
259 EXTFragmentShaderInterlock,
260 EXTYcbcrImageArrays,
261 EXTProvokingVertex,
262 EXTFullScreenExclusive,
263 EXTHeadlessSurface,
264 EXTLineRasterization,
265 EXTShaderAtomicFloat,
266 EXTHostQueryReset,
267 EXTIndexTypeUint8,
268 EXTExtendedDynamicState,
269 EXTShaderAtomicFloat2,
270 EXTSurfaceMaintenance1,
271 EXTSwapchainMaintenance1,
272 EXTShaderDemoteToHelperInvocation,
273 NVDeviceGeneratedCommands,
274 NVInheritedViewportScissor,
275 EXTTexelBufferAlignment,
276 QCOMRenderPassTransform,
277 EXTDeviceMemoryReport,
278 EXTAcquireDrmDisplay,
279 EXTRobustness2,
280 EXTCustomBorderColor,
281 GOOGLEUserType,
282 NVPresentBarrier,
283 EXTPrivateData,
284 EXTPipelineCreationCacheControl,
285 NVDeviceDiagnosticsConfig,
286 QCOMRenderPassStoreOps,
287 NVLowLatency,
288 EXTMetalObjects,
289 EXTDescriptorBuffer,
290 EXTGraphicsPipelineLibrary,
291 AMDShaderEarlyAndLateFragmentTests,
292 NVFragmentShadingRateEnums,
293 NVRayTracingMotionBlur,
294 EXTYcbcr2plane444Formats,
295 EXTFragmentDensityMap2,
296 QCOMRotatedCopyCommands,
297 EXTImageRobustness,
298 EXTImageCompressionControl,
299 EXTAttachmentFeedbackLoopLayout,
300 EXT4444Formats,
301 EXTDeviceFault,
302 ARMRasterizationOrderAttachmentAccess,
303 EXTRgba10x6Formats,
304 NVAcquireWinrtDisplay,
305 EXTDirectfbSurface,
306 VALVEMutableDescriptorType,
307 EXTVertexInputDynamicState,
308 EXTPhysicalDeviceDrm,
309 EXTDeviceAddressBindingReport,
310 EXTDepthClipControl,
311 EXTPrimitiveTopologyListRestart,
312 FUCHSIAExternalMemory,
313 FUCHSIAExternalSemaphore,
314 FUCHSIABufferCollection,
315 HUAWEISubpassShading,
316 HUAWEIInvocationMask,
317 NVExternalMemoryRdma,
318 EXTPipelineProperties,
319 EXTMultisampledRenderToSingleSampled,
320 EXTExtendedDynamicState2,
321 QNXScreenSurface,
322 EXTColorWriteEnable,
323 EXTPrimitivesGeneratedQuery,
324 EXTGlobalPriorityQuery,
325 EXTImageViewMinLod,
326 EXTMultiDraw,
327 EXTImage2dViewOf3d,
328 EXTShaderTileImage,
329 EXTOpacityMicromap,
330 NVDisplacementMicromap,
331 EXTLoadStoreOpNone,
332 HUAWEIClusterCullingShader,
333 EXTBorderColorSwizzle,
334 EXTPageableDeviceLocalMemory,
335 ARMShaderCoreProperties,
336 EXTImageSlicedViewOf3d,
337 VALVEDescriptorSetHostMapping,
338 EXTDepthClampZeroOne,
339 EXTNonSeamlessCubeMap,
340 QCOMFragmentDensityMapOffset,
341 NVCopyMemoryIndirect,
342 NVMemoryDecompression,
343 NVLinearColorAttachment,
344 GOOGLESurfacelessQuery,
345 EXTImageCompressionControlSwapchain,
346 QCOMImageProcessing,
347 EXTExtendedDynamicState3,
348 EXTSubpassMergeFeedback,
349 LUNARGDirectDriverLoading,
350 EXTShaderModuleIdentifier,
351 EXTRasterizationOrderAttachmentAccess,
352 NVOpticalFlow,
353 EXTLegacyDithering,
354 EXTPipelineProtectedAccess,
355 EXTShaderObject,
356 QCOMTileProperties,
357 SECAmigoProfiling,
358 QCOMMultiviewPerViewViewports,
359 NVRayTracingInvocationReorder,
360 EXTMutableDescriptorType,
361 ARMShaderCoreBuiltins,
362 EXTPipelineLibraryGroupHandles,
363 EXTDynamicRenderingUnusedAttachments,
364 QCOMMultiviewPerViewRenderAreas,
365 EXTAttachmentFeedbackLoopDynamicState,
366 KHRAccelerationStructure,
367 KHRRayTracingPipeline,
368 KHRRayQuery,
369 EXTMeshShader,
370}
371
372impl TryFrom<&str> for Extension {
373 type Error = TryFromExtensionError;
374
375 fn try_from(value: &str) -> Result<Self, Self::Error> {
376 match value {
377 "VK_KHR_surface" => Ok(Extension::KHRSurface),
378 "VK_KHR_swapchain" => Ok(Extension::KHRSwapchain),
379 "VK_KHR_display" => Ok(Extension::KHRDisplay),
380 "VK_KHR_display_swapchain" => Ok(Extension::KHRDisplaySwapchain),
381 "VK_KHR_xlib_surface" => Ok(Extension::KHRXlibSurface),
382 "VK_KHR_xcb_surface" => Ok(Extension::KHRXcbSurface),
383 "VK_KHR_wayland_surface" => Ok(Extension::KHRWaylandSurface),
384 "VK_KHR_android_surface" => Ok(Extension::KHRAndroidSurface),
385 "VK_KHR_win32_surface" => Ok(Extension::KHRWin32Surface),
386 "VK_KHR_sampler_mirror_clamp_to_edge" => Ok(Extension::KHRSamplerMirrorClampToEdge),
387 "VK_KHR_video_queue" => Ok(Extension::KHRVideoQueue),
388 "VK_KHR_video_decode_queue" => Ok(Extension::KHRVideoDecodeQueue),
389 "VK_KHR_video_decode_h264" => Ok(Extension::KHRVideoDecodeH264),
390 "VK_KHR_dynamic_rendering" => Ok(Extension::KHRDynamicRendering),
391 "VK_KHR_multiview" => Ok(Extension::KHRMultiview),
392 "VK_KHR_get_physical_device_properties2" => {
393 Ok(Extension::KHRGetPhysicalDeviceProperties2)
394 }
395 "VK_KHR_device_group" => Ok(Extension::KHRDeviceGroup),
396 "VK_KHR_shader_draw_parameters" => Ok(Extension::KHRShaderDrawParameters),
397 "VK_KHR_maintenance1" => Ok(Extension::KHRMaintenance1),
398 "VK_KHR_device_group_creation" => Ok(Extension::KHRDeviceGroupCreation),
399 "VK_KHR_external_memory_capabilities" => Ok(Extension::KHRExternalMemoryCapabilities),
400 "VK_KHR_external_memory" => Ok(Extension::KHRExternalMemory),
401 "VK_KHR_external_memory_win32" => Ok(Extension::KHRExternalMemoryWin32),
402 "VK_KHR_external_memory_fd" => Ok(Extension::KHRExternalMemoryFd),
403 "VK_KHR_win32_keyed_mutex" => Ok(Extension::KHRWin32KeyedMutex),
404 "VK_KHR_external_semaphore_capabilities" => {
405 Ok(Extension::KHRExternalSemaphoreCapabilities)
406 }
407 "VK_KHR_external_semaphore" => Ok(Extension::KHRExternalSemaphore),
408 "VK_KHR_external_semaphore_win32" => Ok(Extension::KHRExternalSemaphoreWin32),
409 "VK_KHR_external_semaphore_fd" => Ok(Extension::KHRExternalSemaphoreFd),
410 "VK_KHR_push_descriptor" => Ok(Extension::KHRPushDescriptor),
411 "VK_KHR_shader_float16_int8" => Ok(Extension::KHRShaderFloat16Int8),
412 "VK_KHR_16bit_storage" => Ok(Extension::KHR16bitStorage),
413 "VK_KHR_incremental_present" => Ok(Extension::KHRIncrementalPresent),
414 "VK_KHR_descriptor_update_template" => Ok(Extension::KHRDescriptorUpdateTemplate),
415 "VK_KHR_imageless_framebuffer" => Ok(Extension::KHRImagelessFramebuffer),
416 "VK_KHR_create_renderpass2" => Ok(Extension::KHRCreateRenderpass2),
417 "VK_KHR_shared_presentable_image" => Ok(Extension::KHRSharedPresentableImage),
418 "VK_KHR_external_fence_capabilities" => Ok(Extension::KHRExternalFenceCapabilities),
419 "VK_KHR_external_fence" => Ok(Extension::KHRExternalFence),
420 "VK_KHR_external_fence_win32" => Ok(Extension::KHRExternalFenceWin32),
421 "VK_KHR_external_fence_fd" => Ok(Extension::KHRExternalFenceFd),
422 "VK_KHR_performance_query" => Ok(Extension::KHRPerformanceQuery),
423 "VK_KHR_maintenance2" => Ok(Extension::KHRMaintenance2),
424 "VK_KHR_get_surface_capabilities2" => Ok(Extension::KHRGetSurfaceCapabilities2),
425 "VK_KHR_variable_pointers" => Ok(Extension::KHRVariablePointers),
426 "VK_KHR_get_display_properties2" => Ok(Extension::KHRGetDisplayProperties2),
427 "VK_KHR_dedicated_allocation" => Ok(Extension::KHRDedicatedAllocation),
428 "VK_KHR_storage_buffer_storage_class" => Ok(Extension::KHRStorageBufferStorageClass),
429 "VK_KHR_relaxed_block_layout" => Ok(Extension::KHRRelaxedBlockLayout),
430 "VK_KHR_get_memory_requirements2" => Ok(Extension::KHRGetMemoryRequirements2),
431 "VK_KHR_image_format_list" => Ok(Extension::KHRImageFormatList),
432 "VK_KHR_sampler_ycbcr_conversion" => Ok(Extension::KHRSamplerYcbcrConversion),
433 "VK_KHR_bind_memory2" => Ok(Extension::KHRBindMemory2),
434 "VK_KHR_portability_subset" => Ok(Extension::KHRPortabilitySubset),
435 "VK_KHR_maintenance3" => Ok(Extension::KHRMaintenance3),
436 "VK_KHR_draw_indirect_count" => Ok(Extension::KHRDrawIndirectCount),
437 "VK_KHR_shader_subgroup_extended_types" => {
438 Ok(Extension::KHRShaderSubgroupExtendedTypes)
439 }
440 "VK_KHR_8bit_storage" => Ok(Extension::KHR8bitStorage),
441 "VK_KHR_shader_atomic_int64" => Ok(Extension::KHRShaderAtomicInt64),
442 "VK_KHR_shader_clock" => Ok(Extension::KHRShaderClock),
443 "VK_KHR_video_decode_h265" => Ok(Extension::KHRVideoDecodeH265),
444 "VK_KHR_global_priority" => Ok(Extension::KHRGlobalPriority),
445 "VK_KHR_driver_properties" => Ok(Extension::KHRDriverProperties),
446 "VK_KHR_shader_float_controls" => Ok(Extension::KHRShaderFloatControls),
447 "VK_KHR_depth_stencil_resolve" => Ok(Extension::KHRDepthStencilResolve),
448 "VK_KHR_swapchain_mutable_format" => Ok(Extension::KHRSwapchainMutableFormat),
449 "VK_KHR_timeline_semaphore" => Ok(Extension::KHRTimelineSemaphore),
450 "VK_KHR_vulkan_memory_model" => Ok(Extension::KHRVulkanMemoryModel),
451 "VK_KHR_shader_terminate_invocation" => Ok(Extension::KHRShaderTerminateInvocation),
452 "VK_KHR_fragment_shading_rate" => Ok(Extension::KHRFragmentShadingRate),
453 "VK_KHR_spirv_1_4" => Ok(Extension::KHRSpirv14),
454 "VK_KHR_surface_protected_capabilities" => {
455 Ok(Extension::KHRSurfaceProtectedCapabilities)
456 }
457 "VK_KHR_separate_depth_stencil_layouts" => {
458 Ok(Extension::KHRSeparateDepthStencilLayouts)
459 }
460 "VK_KHR_present_wait" => Ok(Extension::KHRPresentWait),
461 "VK_KHR_uniform_buffer_standard_layout" => {
462 Ok(Extension::KHRUniformBufferStandardLayout)
463 }
464 "VK_KHR_buffer_device_address" => Ok(Extension::KHRBufferDeviceAddress),
465 "VK_KHR_deferred_host_operations" => Ok(Extension::KHRDeferredHostOperations),
466 "VK_KHR_pipeline_executable_properties" => {
467 Ok(Extension::KHRPipelineExecutableProperties)
468 }
469 "VK_KHR_map_memory2" => Ok(Extension::KHRMapMemory2),
470 "VK_KHR_shader_integer_dot_product" => Ok(Extension::KHRShaderIntegerDotProduct),
471 "VK_KHR_pipeline_library" => Ok(Extension::KHRPipelineLibrary),
472 "VK_KHR_shader_non_semantic_info" => Ok(Extension::KHRShaderNonSemanticInfo),
473 "VK_KHR_present_id" => Ok(Extension::KHRPresentId),
474 "VK_KHR_video_encode_queue" => Ok(Extension::KHRVideoEncodeQueue),
475 "VK_KHR_synchronization2" => Ok(Extension::KHRSynchronization2),
476 "VK_KHR_fragment_shader_barycentric" => Ok(Extension::KHRFragmentShaderBarycentric),
477 "VK_KHR_shader_subgroup_uniform_control_flow" => {
478 Ok(Extension::KHRShaderSubgroupUniformControlFlow)
479 }
480 "VK_KHR_zero_initialize_workgroup_memory" => {
481 Ok(Extension::KHRZeroInitializeWorkgroupMemory)
482 }
483 "VK_KHR_workgroup_memory_explicit_layout" => {
484 Ok(Extension::KHRWorkgroupMemoryExplicitLayout)
485 }
486 "VK_KHR_copy_commands2" => Ok(Extension::KHRCopyCommands2),
487 "VK_KHR_format_feature_flags2" => Ok(Extension::KHRFormatFeatureFlags2),
488 "VK_KHR_ray_tracing_maintenance1" => Ok(Extension::KHRRayTracingMaintenance1),
489 "VK_KHR_portability_enumeration" => Ok(Extension::KHRPortabilityEnumeration),
490 "VK_KHR_maintenance4" => Ok(Extension::KHRMaintenance4),
491 "VK_KHR_ray_tracing_position_fetch" => Ok(Extension::KHRRayTracingPositionFetch),
492 "VK_ANDROID_native_buffer" => Ok(Extension::ANDROIDNativeBuffer),
493 "VK_EXT_debug_report" => Ok(Extension::EXTDebugReport),
494 "VK_NV_glsl_shader" => Ok(Extension::NVGlslShader),
495 "VK_EXT_depth_range_unrestricted" => Ok(Extension::EXTDepthRangeUnrestricted),
496 "VK_IMG_filter_cubic" => Ok(Extension::IMGFilterCubic),
497 "VK_AMD_rasterization_order" => Ok(Extension::AMDRasterizationOrder),
498 "VK_AMD_shader_trinary_minmax" => Ok(Extension::AMDShaderTrinaryMinmax),
499 "VK_AMD_shader_explicit_vertex_parameter" => {
500 Ok(Extension::AMDShaderExplicitVertexParameter)
501 }
502 "VK_EXT_debug_marker" => Ok(Extension::EXTDebugMarker),
503 "VK_AMD_gcn_shader" => Ok(Extension::AMDGcnShader),
504 "VK_NV_dedicated_allocation" => Ok(Extension::NVDedicatedAllocation),
505 "VK_EXT_transform_feedback" => Ok(Extension::EXTTransformFeedback),
506 "VK_NVX_binary_import" => Ok(Extension::NVXBinaryImport),
507 "VK_NVX_image_view_handle" => Ok(Extension::NVXImageViewHandle),
508 "VK_AMD_draw_indirect_count" => Ok(Extension::AMDDrawIndirectCount),
509 "VK_AMD_negative_viewport_height" => Ok(Extension::AMDNegativeViewportHeight),
510 "VK_AMD_gpu_shader_half_float" => Ok(Extension::AMDGpuShaderHalfFloat),
511 "VK_AMD_shader_ballot" => Ok(Extension::AMDShaderBallot),
512 "VK_EXT_video_encode_h264" => Ok(Extension::EXTVideoEncodeH264),
513 "VK_EXT_video_encode_h265" => Ok(Extension::EXTVideoEncodeH265),
514 "VK_AMD_texture_gather_bias_lod" => Ok(Extension::AMDTextureGatherBiasLod),
515 "VK_AMD_shader_info" => Ok(Extension::AMDShaderInfo),
516 "VK_AMD_shader_image_load_store_lod" => Ok(Extension::AMDShaderImageLoadStoreLod),
517 "VK_GGP_stream_descriptor_surface" => Ok(Extension::GGPStreamDescriptorSurface),
518 "VK_NV_corner_sampled_image" => Ok(Extension::NVCornerSampledImage),
519 "VK_IMG_format_pvrtc" => Ok(Extension::IMGFormatPvrtc),
520 "VK_NV_external_memory_capabilities" => Ok(Extension::NVExternalMemoryCapabilities),
521 "VK_NV_external_memory" => Ok(Extension::NVExternalMemory),
522 "VK_NV_external_memory_win32" => Ok(Extension::NVExternalMemoryWin32),
523 "VK_NV_win32_keyed_mutex" => Ok(Extension::NVWin32KeyedMutex),
524 "VK_EXT_validation_flags" => Ok(Extension::EXTValidationFlags),
525 "VK_NN_vi_surface" => Ok(Extension::NNViSurface),
526 "VK_EXT_shader_subgroup_ballot" => Ok(Extension::EXTShaderSubgroupBallot),
527 "VK_EXT_shader_subgroup_vote" => Ok(Extension::EXTShaderSubgroupVote),
528 "VK_EXT_texture_compression_astc_hdr" => Ok(Extension::EXTTextureCompressionAstcHdr),
529 "VK_EXT_astc_decode_mode" => Ok(Extension::EXTAstcDecodeMode),
530 "VK_EXT_pipeline_robustness" => Ok(Extension::EXTPipelineRobustness),
531 "VK_EXT_conditional_rendering" => Ok(Extension::EXTConditionalRendering),
532 "VK_NV_clip_space_w_scaling" => Ok(Extension::NVClipSpaceWScaling),
533 "VK_EXT_direct_mode_display" => Ok(Extension::EXTDirectModeDisplay),
534 "VK_EXT_acquire_xlib_display" => Ok(Extension::EXTAcquireXlibDisplay),
535 "VK_EXT_display_surface_counter" => Ok(Extension::EXTDisplaySurfaceCounter),
536 "VK_EXT_display_control" => Ok(Extension::EXTDisplayControl),
537 "VK_GOOGLE_display_timing" => Ok(Extension::GOOGLEDisplayTiming),
538 "VK_NV_sample_mask_override_coverage" => Ok(Extension::NVSampleMaskOverrideCoverage),
539 "VK_NV_geometry_shader_passthrough" => Ok(Extension::NVGeometryShaderPassthrough),
540 "VK_NV_viewport_array2" => Ok(Extension::NVViewportArray2),
541 "VK_NVX_multiview_per_view_attributes" => Ok(Extension::NVXMultiviewPerViewAttributes),
542 "VK_NV_viewport_swizzle" => Ok(Extension::NVViewportSwizzle),
543 "VK_EXT_discard_rectangles" => Ok(Extension::EXTDiscardRectangles),
544 "VK_EXT_conservative_rasterization" => Ok(Extension::EXTConservativeRasterization),
545 "VK_EXT_depth_clip_enable" => Ok(Extension::EXTDepthClipEnable),
546 "VK_EXT_swapchain_colorspace" => Ok(Extension::EXTSwapchainColorspace),
547 "VK_EXT_hdr_metadata" => Ok(Extension::EXTHdrMetadata),
548 "VK_MVK_ios_surface" => Ok(Extension::MVKIosSurface),
549 "VK_MVK_macos_surface" => Ok(Extension::MVKMacosSurface),
550 "VK_EXT_external_memory_dma_buf" => Ok(Extension::EXTExternalMemoryDmaBuf),
551 "VK_EXT_queue_family_foreign" => Ok(Extension::EXTQueueFamilyForeign),
552 "VK_EXT_debug_utils" => Ok(Extension::EXTDebugUtils),
553 "VK_ANDROID_external_memory_android_hardware_buffer" => {
554 Ok(Extension::ANDROIDExternalMemoryAndroidHardwareBuffer)
555 }
556 "VK_EXT_sampler_filter_minmax" => Ok(Extension::EXTSamplerFilterMinmax),
557 "VK_AMD_gpu_shader_int16" => Ok(Extension::AMDGpuShaderInt16),
558 "VK_AMD_mixed_attachment_samples" => Ok(Extension::AMDMixedAttachmentSamples),
559 "VK_AMD_shader_fragment_mask" => Ok(Extension::AMDShaderFragmentMask),
560 "VK_EXT_inline_uniform_block" => Ok(Extension::EXTInlineUniformBlock),
561 "VK_EXT_shader_stencil_export" => Ok(Extension::EXTShaderStencilExport),
562 "VK_EXT_sample_locations" => Ok(Extension::EXTSampleLocations),
563 "VK_EXT_blend_operation_advanced" => Ok(Extension::EXTBlendOperationAdvanced),
564 "VK_NV_fragment_coverage_to_color" => Ok(Extension::NVFragmentCoverageToColor),
565 "VK_NV_framebuffer_mixed_samples" => Ok(Extension::NVFramebufferMixedSamples),
566 "VK_NV_fill_rectangle" => Ok(Extension::NVFillRectangle),
567 "VK_NV_shader_sm_builtins" => Ok(Extension::NVShaderSmBuiltins),
568 "VK_EXT_post_depth_coverage" => Ok(Extension::EXTPostDepthCoverage),
569 "VK_EXT_image_drm_format_modifier" => Ok(Extension::EXTImageDrmFormatModifier),
570 "VK_EXT_validation_cache" => Ok(Extension::EXTValidationCache),
571 "VK_EXT_descriptor_indexing" => Ok(Extension::EXTDescriptorIndexing),
572 "VK_EXT_shader_viewport_index_layer" => Ok(Extension::EXTShaderViewportIndexLayer),
573 "VK_NV_shading_rate_image" => Ok(Extension::NVShadingRateImage),
574 "VK_NV_ray_tracing" => Ok(Extension::NVRayTracing),
575 "VK_NV_representative_fragment_test" => Ok(Extension::NVRepresentativeFragmentTest),
576 "VK_EXT_filter_cubic" => Ok(Extension::EXTFilterCubic),
577 "VK_QCOM_render_pass_shader_resolve" => Ok(Extension::QCOMRenderPassShaderResolve),
578 "VK_EXT_global_priority" => Ok(Extension::EXTGlobalPriority),
579 "VK_EXT_external_memory_host" => Ok(Extension::EXTExternalMemoryHost),
580 "VK_AMD_buffer_marker" => Ok(Extension::AMDBufferMarker),
581 "VK_AMD_pipeline_compiler_control" => Ok(Extension::AMDPipelineCompilerControl),
582 "VK_EXT_calibrated_timestamps" => Ok(Extension::EXTCalibratedTimestamps),
583 "VK_AMD_shader_core_properties" => Ok(Extension::AMDShaderCoreProperties),
584 "VK_AMD_memory_overallocation_behavior" => {
585 Ok(Extension::AMDMemoryOverallocationBehavior)
586 }
587 "VK_EXT_vertex_attribute_divisor" => Ok(Extension::EXTVertexAttributeDivisor),
588 "VK_GGP_frame_token" => Ok(Extension::GGPFrameToken),
589 "VK_EXT_pipeline_creation_feedback" => Ok(Extension::EXTPipelineCreationFeedback),
590 "VK_NV_shader_subgroup_partitioned" => Ok(Extension::NVShaderSubgroupPartitioned),
591 "VK_NV_compute_shader_derivatives" => Ok(Extension::NVComputeShaderDerivatives),
592 "VK_NV_mesh_shader" => Ok(Extension::NVMeshShader),
593 "VK_NV_fragment_shader_barycentric" => Ok(Extension::NVFragmentShaderBarycentric),
594 "VK_NV_shader_image_footprint" => Ok(Extension::NVShaderImageFootprint),
595 "VK_NV_scissor_exclusive" => Ok(Extension::NVScissorExclusive),
596 "VK_NV_device_diagnostic_checkpoints" => Ok(Extension::NVDeviceDiagnosticCheckpoints),
597 "VK_INTEL_shader_integer_functions2" => Ok(Extension::INTELShaderIntegerFunctions2),
598 "VK_INTEL_performance_query" => Ok(Extension::INTELPerformanceQuery),
599 "VK_EXT_pci_bus_info" => Ok(Extension::EXTPciBusInfo),
600 "VK_AMD_display_native_hdr" => Ok(Extension::AMDDisplayNativeHdr),
601 "VK_FUCHSIA_imagepipe_surface" => Ok(Extension::FUCHSIAImagepipeSurface),
602 "VK_EXT_metal_surface" => Ok(Extension::EXTMetalSurface),
603 "VK_EXT_fragment_density_map" => Ok(Extension::EXTFragmentDensityMap),
604 "VK_EXT_scalar_block_layout" => Ok(Extension::EXTScalarBlockLayout),
605 "VK_GOOGLE_hlsl_functionality1" => Ok(Extension::GOOGLEHlslFunctionality1),
606 "VK_GOOGLE_decorate_string" => Ok(Extension::GOOGLEDecorateString),
607 "VK_EXT_subgroup_size_control" => Ok(Extension::EXTSubgroupSizeControl),
608 "VK_AMD_shader_core_properties2" => Ok(Extension::AMDShaderCoreProperties2),
609 "VK_AMD_device_coherent_memory" => Ok(Extension::AMDDeviceCoherentMemory),
610 "VK_EXT_shader_image_atomic_int64" => Ok(Extension::EXTShaderImageAtomicInt64),
611 "VK_EXT_memory_budget" => Ok(Extension::EXTMemoryBudget),
612 "VK_EXT_memory_priority" => Ok(Extension::EXTMemoryPriority),
613 "VK_NV_dedicated_allocation_image_aliasing" => {
614 Ok(Extension::NVDedicatedAllocationImageAliasing)
615 }
616 "VK_EXT_buffer_device_address" => Ok(Extension::EXTBufferDeviceAddress),
617 "VK_EXT_tooling_info" => Ok(Extension::EXTToolingInfo),
618 "VK_EXT_separate_stencil_usage" => Ok(Extension::EXTSeparateStencilUsage),
619 "VK_EXT_validation_features" => Ok(Extension::EXTValidationFeatures),
620 "VK_NV_cooperative_matrix" => Ok(Extension::NVCooperativeMatrix),
621 "VK_NV_coverage_reduction_mode" => Ok(Extension::NVCoverageReductionMode),
622 "VK_EXT_fragment_shader_interlock" => Ok(Extension::EXTFragmentShaderInterlock),
623 "VK_EXT_ycbcr_image_arrays" => Ok(Extension::EXTYcbcrImageArrays),
624 "VK_EXT_provoking_vertex" => Ok(Extension::EXTProvokingVertex),
625 "VK_EXT_full_screen_exclusive" => Ok(Extension::EXTFullScreenExclusive),
626 "VK_EXT_headless_surface" => Ok(Extension::EXTHeadlessSurface),
627 "VK_EXT_line_rasterization" => Ok(Extension::EXTLineRasterization),
628 "VK_EXT_shader_atomic_float" => Ok(Extension::EXTShaderAtomicFloat),
629 "VK_EXT_host_query_reset" => Ok(Extension::EXTHostQueryReset),
630 "VK_EXT_index_type_uint8" => Ok(Extension::EXTIndexTypeUint8),
631 "VK_EXT_extended_dynamic_state" => Ok(Extension::EXTExtendedDynamicState),
632 "VK_EXT_shader_atomic_float2" => Ok(Extension::EXTShaderAtomicFloat2),
633 "VK_EXT_surface_maintenance1" => Ok(Extension::EXTSurfaceMaintenance1),
634 "VK_EXT_swapchain_maintenance1" => Ok(Extension::EXTSwapchainMaintenance1),
635 "VK_EXT_shader_demote_to_helper_invocation" => {
636 Ok(Extension::EXTShaderDemoteToHelperInvocation)
637 }
638 "VK_NV_device_generated_commands" => Ok(Extension::NVDeviceGeneratedCommands),
639 "VK_NV_inherited_viewport_scissor" => Ok(Extension::NVInheritedViewportScissor),
640 "VK_EXT_texel_buffer_alignment" => Ok(Extension::EXTTexelBufferAlignment),
641 "VK_QCOM_render_pass_transform" => Ok(Extension::QCOMRenderPassTransform),
642 "VK_EXT_device_memory_report" => Ok(Extension::EXTDeviceMemoryReport),
643 "VK_EXT_acquire_drm_display" => Ok(Extension::EXTAcquireDrmDisplay),
644 "VK_EXT_robustness2" => Ok(Extension::EXTRobustness2),
645 "VK_EXT_custom_border_color" => Ok(Extension::EXTCustomBorderColor),
646 "VK_GOOGLE_user_type" => Ok(Extension::GOOGLEUserType),
647 "VK_NV_present_barrier" => Ok(Extension::NVPresentBarrier),
648 "VK_EXT_private_data" => Ok(Extension::EXTPrivateData),
649 "VK_EXT_pipeline_creation_cache_control" => {
650 Ok(Extension::EXTPipelineCreationCacheControl)
651 }
652 "VK_NV_device_diagnostics_config" => Ok(Extension::NVDeviceDiagnosticsConfig),
653 "VK_QCOM_render_pass_store_ops" => Ok(Extension::QCOMRenderPassStoreOps),
654 "VK_NV_low_latency" => Ok(Extension::NVLowLatency),
655 "VK_EXT_metal_objects" => Ok(Extension::EXTMetalObjects),
656 "VK_EXT_descriptor_buffer" => Ok(Extension::EXTDescriptorBuffer),
657 "VK_EXT_graphics_pipeline_library" => Ok(Extension::EXTGraphicsPipelineLibrary),
658 "VK_AMD_shader_early_and_late_fragment_tests" => {
659 Ok(Extension::AMDShaderEarlyAndLateFragmentTests)
660 }
661 "VK_NV_fragment_shading_rate_enums" => Ok(Extension::NVFragmentShadingRateEnums),
662 "VK_NV_ray_tracing_motion_blur" => Ok(Extension::NVRayTracingMotionBlur),
663 "VK_EXT_ycbcr_2plane_444_formats" => Ok(Extension::EXTYcbcr2plane444Formats),
664 "VK_EXT_fragment_density_map2" => Ok(Extension::EXTFragmentDensityMap2),
665 "VK_QCOM_rotated_copy_commands" => Ok(Extension::QCOMRotatedCopyCommands),
666 "VK_EXT_image_robustness" => Ok(Extension::EXTImageRobustness),
667 "VK_EXT_image_compression_control" => Ok(Extension::EXTImageCompressionControl),
668 "VK_EXT_attachment_feedback_loop_layout" => {
669 Ok(Extension::EXTAttachmentFeedbackLoopLayout)
670 }
671 "VK_EXT_4444_formats" => Ok(Extension::EXT4444Formats),
672 "VK_EXT_device_fault" => Ok(Extension::EXTDeviceFault),
673 "VK_ARM_rasterization_order_attachment_access" => {
674 Ok(Extension::ARMRasterizationOrderAttachmentAccess)
675 }
676 "VK_EXT_rgba10x6_formats" => Ok(Extension::EXTRgba10x6Formats),
677 "VK_NV_acquire_winrt_display" => Ok(Extension::NVAcquireWinrtDisplay),
678 "VK_EXT_directfb_surface" => Ok(Extension::EXTDirectfbSurface),
679 "VK_VALVE_mutable_descriptor_type" => Ok(Extension::VALVEMutableDescriptorType),
680 "VK_EXT_vertex_input_dynamic_state" => Ok(Extension::EXTVertexInputDynamicState),
681 "VK_EXT_physical_device_drm" => Ok(Extension::EXTPhysicalDeviceDrm),
682 "VK_EXT_device_address_binding_report" => Ok(Extension::EXTDeviceAddressBindingReport),
683 "VK_EXT_depth_clip_control" => Ok(Extension::EXTDepthClipControl),
684 "VK_EXT_primitive_topology_list_restart" => {
685 Ok(Extension::EXTPrimitiveTopologyListRestart)
686 }
687 "VK_FUCHSIA_external_memory" => Ok(Extension::FUCHSIAExternalMemory),
688 "VK_FUCHSIA_external_semaphore" => Ok(Extension::FUCHSIAExternalSemaphore),
689 "VK_FUCHSIA_buffer_collection" => Ok(Extension::FUCHSIABufferCollection),
690 "VK_HUAWEI_subpass_shading" => Ok(Extension::HUAWEISubpassShading),
691 "VK_HUAWEI_invocation_mask" => Ok(Extension::HUAWEIInvocationMask),
692 "VK_NV_external_memory_rdma" => Ok(Extension::NVExternalMemoryRdma),
693 "VK_EXT_pipeline_properties" => Ok(Extension::EXTPipelineProperties),
694 "VK_EXT_multisampled_render_to_single_sampled" => {
695 Ok(Extension::EXTMultisampledRenderToSingleSampled)
696 }
697 "VK_EXT_extended_dynamic_state2" => Ok(Extension::EXTExtendedDynamicState2),
698 "VK_QNX_screen_surface" => Ok(Extension::QNXScreenSurface),
699 "VK_EXT_color_write_enable" => Ok(Extension::EXTColorWriteEnable),
700 "VK_EXT_primitives_generated_query" => Ok(Extension::EXTPrimitivesGeneratedQuery),
701 "VK_EXT_global_priority_query" => Ok(Extension::EXTGlobalPriorityQuery),
702 "VK_EXT_image_view_min_lod" => Ok(Extension::EXTImageViewMinLod),
703 "VK_EXT_multi_draw" => Ok(Extension::EXTMultiDraw),
704 "VK_EXT_image_2d_view_of_3d" => Ok(Extension::EXTImage2dViewOf3d),
705 "VK_EXT_shader_tile_image" => Ok(Extension::EXTShaderTileImage),
706 "VK_EXT_opacity_micromap" => Ok(Extension::EXTOpacityMicromap),
707 "VK_NV_displacement_micromap" => Ok(Extension::NVDisplacementMicromap),
708 "VK_EXT_load_store_op_none" => Ok(Extension::EXTLoadStoreOpNone),
709 "VK_HUAWEI_cluster_culling_shader" => Ok(Extension::HUAWEIClusterCullingShader),
710 "VK_EXT_border_color_swizzle" => Ok(Extension::EXTBorderColorSwizzle),
711 "VK_EXT_pageable_device_local_memory" => Ok(Extension::EXTPageableDeviceLocalMemory),
712 "VK_ARM_shader_core_properties" => Ok(Extension::ARMShaderCoreProperties),
713 "VK_EXT_image_sliced_view_of_3d" => Ok(Extension::EXTImageSlicedViewOf3d),
714 "VK_VALVE_descriptor_set_host_mapping" => Ok(Extension::VALVEDescriptorSetHostMapping),
715 "VK_EXT_depth_clamp_zero_one" => Ok(Extension::EXTDepthClampZeroOne),
716 "VK_EXT_non_seamless_cube_map" => Ok(Extension::EXTNonSeamlessCubeMap),
717 "VK_QCOM_fragment_density_map_offset" => Ok(Extension::QCOMFragmentDensityMapOffset),
718 "VK_NV_copy_memory_indirect" => Ok(Extension::NVCopyMemoryIndirect),
719 "VK_NV_memory_decompression" => Ok(Extension::NVMemoryDecompression),
720 "VK_NV_linear_color_attachment" => Ok(Extension::NVLinearColorAttachment),
721 "VK_GOOGLE_surfaceless_query" => Ok(Extension::GOOGLESurfacelessQuery),
722 "VK_EXT_image_compression_control_swapchain" => {
723 Ok(Extension::EXTImageCompressionControlSwapchain)
724 }
725 "VK_QCOM_image_processing" => Ok(Extension::QCOMImageProcessing),
726 "VK_EXT_extended_dynamic_state3" => Ok(Extension::EXTExtendedDynamicState3),
727 "VK_EXT_subpass_merge_feedback" => Ok(Extension::EXTSubpassMergeFeedback),
728 "VK_LUNARG_direct_driver_loading" => Ok(Extension::LUNARGDirectDriverLoading),
729 "VK_EXT_shader_module_identifier" => Ok(Extension::EXTShaderModuleIdentifier),
730 "VK_EXT_rasterization_order_attachment_access" => {
731 Ok(Extension::EXTRasterizationOrderAttachmentAccess)
732 }
733 "VK_NV_optical_flow" => Ok(Extension::NVOpticalFlow),
734 "VK_EXT_legacy_dithering" => Ok(Extension::EXTLegacyDithering),
735 "VK_EXT_pipeline_protected_access" => Ok(Extension::EXTPipelineProtectedAccess),
736 "VK_EXT_shader_object" => Ok(Extension::EXTShaderObject),
737 "VK_QCOM_tile_properties" => Ok(Extension::QCOMTileProperties),
738 "VK_SEC_amigo_profiling" => Ok(Extension::SECAmigoProfiling),
739 "VK_QCOM_multiview_per_view_viewports" => Ok(Extension::QCOMMultiviewPerViewViewports),
740 "VK_NV_ray_tracing_invocation_reorder" => Ok(Extension::NVRayTracingInvocationReorder),
741 "VK_EXT_mutable_descriptor_type" => Ok(Extension::EXTMutableDescriptorType),
742 "VK_ARM_shader_core_builtins" => Ok(Extension::ARMShaderCoreBuiltins),
743 "VK_EXT_pipeline_library_group_handles" => {
744 Ok(Extension::EXTPipelineLibraryGroupHandles)
745 }
746 "VK_EXT_dynamic_rendering_unused_attachments" => {
747 Ok(Extension::EXTDynamicRenderingUnusedAttachments)
748 }
749 "VK_QCOM_multiview_per_view_render_areas" => {
750 Ok(Extension::QCOMMultiviewPerViewRenderAreas)
751 }
752 "VK_EXT_attachment_feedback_loop_dynamic_state" => {
753 Ok(Extension::EXTAttachmentFeedbackLoopDynamicState)
754 }
755 "VK_KHR_acceleration_structure" => Ok(Extension::KHRAccelerationStructure),
756 "VK_KHR_ray_tracing_pipeline" => Ok(Extension::KHRRayTracingPipeline),
757 "VK_KHR_ray_query" => Ok(Extension::KHRRayQuery),
758 "VK_EXT_mesh_shader" => Ok(Extension::EXTMeshShader),
759 _ => Err(TryFromExtensionError::UnknownExtension(value.to_owned())),
760 }
761 }
762}
763
764impl From<Extension> for &'static str {
765 fn from(value: Extension) -> &'static str {
766 match value {
767 Extension::KHRSurface => "VK_KHR_surface",
768 Extension::KHRSwapchain => "VK_KHR_swapchain",
769 Extension::KHRDisplay => "VK_KHR_display",
770 Extension::KHRDisplaySwapchain => "VK_KHR_display_swapchain",
771 Extension::KHRXlibSurface => "VK_KHR_xlib_surface",
772 Extension::KHRXcbSurface => "VK_KHR_xcb_surface",
773 Extension::KHRWaylandSurface => "VK_KHR_wayland_surface",
774 Extension::KHRAndroidSurface => "VK_KHR_android_surface",
775 Extension::KHRWin32Surface => "VK_KHR_win32_surface",
776 Extension::KHRSamplerMirrorClampToEdge => "VK_KHR_sampler_mirror_clamp_to_edge",
777 Extension::KHRVideoQueue => "VK_KHR_video_queue",
778 Extension::KHRVideoDecodeQueue => "VK_KHR_video_decode_queue",
779 Extension::KHRVideoDecodeH264 => "VK_KHR_video_decode_h264",
780 Extension::KHRDynamicRendering => "VK_KHR_dynamic_rendering",
781 Extension::KHRMultiview => "VK_KHR_multiview",
782 Extension::KHRGetPhysicalDeviceProperties2 => "VK_KHR_get_physical_device_properties2",
783 Extension::KHRDeviceGroup => "VK_KHR_device_group",
784 Extension::KHRShaderDrawParameters => "VK_KHR_shader_draw_parameters",
785 Extension::KHRMaintenance1 => "VK_KHR_maintenance1",
786 Extension::KHRDeviceGroupCreation => "VK_KHR_device_group_creation",
787 Extension::KHRExternalMemoryCapabilities => "VK_KHR_external_memory_capabilities",
788 Extension::KHRExternalMemory => "VK_KHR_external_memory",
789 Extension::KHRExternalMemoryWin32 => "VK_KHR_external_memory_win32",
790 Extension::KHRExternalMemoryFd => "VK_KHR_external_memory_fd",
791 Extension::KHRWin32KeyedMutex => "VK_KHR_win32_keyed_mutex",
792 Extension::KHRExternalSemaphoreCapabilities => "VK_KHR_external_semaphore_capabilities",
793 Extension::KHRExternalSemaphore => "VK_KHR_external_semaphore",
794 Extension::KHRExternalSemaphoreWin32 => "VK_KHR_external_semaphore_win32",
795 Extension::KHRExternalSemaphoreFd => "VK_KHR_external_semaphore_fd",
796 Extension::KHRPushDescriptor => "VK_KHR_push_descriptor",
797 Extension::KHRShaderFloat16Int8 => "VK_KHR_shader_float16_int8",
798 Extension::KHR16bitStorage => "VK_KHR_16bit_storage",
799 Extension::KHRIncrementalPresent => "VK_KHR_incremental_present",
800 Extension::KHRDescriptorUpdateTemplate => "VK_KHR_descriptor_update_template",
801 Extension::KHRImagelessFramebuffer => "VK_KHR_imageless_framebuffer",
802 Extension::KHRCreateRenderpass2 => "VK_KHR_create_renderpass2",
803 Extension::KHRSharedPresentableImage => "VK_KHR_shared_presentable_image",
804 Extension::KHRExternalFenceCapabilities => "VK_KHR_external_fence_capabilities",
805 Extension::KHRExternalFence => "VK_KHR_external_fence",
806 Extension::KHRExternalFenceWin32 => "VK_KHR_external_fence_win32",
807 Extension::KHRExternalFenceFd => "VK_KHR_external_fence_fd",
808 Extension::KHRPerformanceQuery => "VK_KHR_performance_query",
809 Extension::KHRMaintenance2 => "VK_KHR_maintenance2",
810 Extension::KHRGetSurfaceCapabilities2 => "VK_KHR_get_surface_capabilities2",
811 Extension::KHRVariablePointers => "VK_KHR_variable_pointers",
812 Extension::KHRGetDisplayProperties2 => "VK_KHR_get_display_properties2",
813 Extension::KHRDedicatedAllocation => "VK_KHR_dedicated_allocation",
814 Extension::KHRStorageBufferStorageClass => "VK_KHR_storage_buffer_storage_class",
815 Extension::KHRRelaxedBlockLayout => "VK_KHR_relaxed_block_layout",
816 Extension::KHRGetMemoryRequirements2 => "VK_KHR_get_memory_requirements2",
817 Extension::KHRImageFormatList => "VK_KHR_image_format_list",
818 Extension::KHRSamplerYcbcrConversion => "VK_KHR_sampler_ycbcr_conversion",
819 Extension::KHRBindMemory2 => "VK_KHR_bind_memory2",
820 Extension::KHRPortabilitySubset => "VK_KHR_portability_subset",
821 Extension::KHRMaintenance3 => "VK_KHR_maintenance3",
822 Extension::KHRDrawIndirectCount => "VK_KHR_draw_indirect_count",
823 Extension::KHRShaderSubgroupExtendedTypes => "VK_KHR_shader_subgroup_extended_types",
824 Extension::KHR8bitStorage => "VK_KHR_8bit_storage",
825 Extension::KHRShaderAtomicInt64 => "VK_KHR_shader_atomic_int64",
826 Extension::KHRShaderClock => "VK_KHR_shader_clock",
827 Extension::KHRVideoDecodeH265 => "VK_KHR_video_decode_h265",
828 Extension::KHRGlobalPriority => "VK_KHR_global_priority",
829 Extension::KHRDriverProperties => "VK_KHR_driver_properties",
830 Extension::KHRShaderFloatControls => "VK_KHR_shader_float_controls",
831 Extension::KHRDepthStencilResolve => "VK_KHR_depth_stencil_resolve",
832 Extension::KHRSwapchainMutableFormat => "VK_KHR_swapchain_mutable_format",
833 Extension::KHRTimelineSemaphore => "VK_KHR_timeline_semaphore",
834 Extension::KHRVulkanMemoryModel => "VK_KHR_vulkan_memory_model",
835 Extension::KHRShaderTerminateInvocation => "VK_KHR_shader_terminate_invocation",
836 Extension::KHRFragmentShadingRate => "VK_KHR_fragment_shading_rate",
837 Extension::KHRSpirv14 => "VK_KHR_spirv_1_4",
838 Extension::KHRSurfaceProtectedCapabilities => "VK_KHR_surface_protected_capabilities",
839 Extension::KHRSeparateDepthStencilLayouts => "VK_KHR_separate_depth_stencil_layouts",
840 Extension::KHRPresentWait => "VK_KHR_present_wait",
841 Extension::KHRUniformBufferStandardLayout => "VK_KHR_uniform_buffer_standard_layout",
842 Extension::KHRBufferDeviceAddress => "VK_KHR_buffer_device_address",
843 Extension::KHRDeferredHostOperations => "VK_KHR_deferred_host_operations",
844 Extension::KHRPipelineExecutableProperties => "VK_KHR_pipeline_executable_properties",
845 Extension::KHRMapMemory2 => "VK_KHR_map_memory2",
846 Extension::KHRShaderIntegerDotProduct => "VK_KHR_shader_integer_dot_product",
847 Extension::KHRPipelineLibrary => "VK_KHR_pipeline_library",
848 Extension::KHRShaderNonSemanticInfo => "VK_KHR_shader_non_semantic_info",
849 Extension::KHRPresentId => "VK_KHR_present_id",
850 Extension::KHRVideoEncodeQueue => "VK_KHR_video_encode_queue",
851 Extension::KHRSynchronization2 => "VK_KHR_synchronization2",
852 Extension::KHRFragmentShaderBarycentric => "VK_KHR_fragment_shader_barycentric",
853 Extension::KHRShaderSubgroupUniformControlFlow => {
854 "VK_KHR_shader_subgroup_uniform_control_flow"
855 }
856 Extension::KHRZeroInitializeWorkgroupMemory => {
857 "VK_KHR_zero_initialize_workgroup_memory"
858 }
859 Extension::KHRWorkgroupMemoryExplicitLayout => {
860 "VK_KHR_workgroup_memory_explicit_layout"
861 }
862 Extension::KHRCopyCommands2 => "VK_KHR_copy_commands2",
863 Extension::KHRFormatFeatureFlags2 => "VK_KHR_format_feature_flags2",
864 Extension::KHRRayTracingMaintenance1 => "VK_KHR_ray_tracing_maintenance1",
865 Extension::KHRPortabilityEnumeration => "VK_KHR_portability_enumeration",
866 Extension::KHRMaintenance4 => "VK_KHR_maintenance4",
867 Extension::KHRRayTracingPositionFetch => "VK_KHR_ray_tracing_position_fetch",
868 Extension::ANDROIDNativeBuffer => "VK_ANDROID_native_buffer",
869 Extension::EXTDebugReport => "VK_EXT_debug_report",
870 Extension::NVGlslShader => "VK_NV_glsl_shader",
871 Extension::EXTDepthRangeUnrestricted => "VK_EXT_depth_range_unrestricted",
872 Extension::IMGFilterCubic => "VK_IMG_filter_cubic",
873 Extension::AMDRasterizationOrder => "VK_AMD_rasterization_order",
874 Extension::AMDShaderTrinaryMinmax => "VK_AMD_shader_trinary_minmax",
875 Extension::AMDShaderExplicitVertexParameter => {
876 "VK_AMD_shader_explicit_vertex_parameter"
877 }
878 Extension::EXTDebugMarker => "VK_EXT_debug_marker",
879 Extension::AMDGcnShader => "VK_AMD_gcn_shader",
880 Extension::NVDedicatedAllocation => "VK_NV_dedicated_allocation",
881 Extension::EXTTransformFeedback => "VK_EXT_transform_feedback",
882 Extension::NVXBinaryImport => "VK_NVX_binary_import",
883 Extension::NVXImageViewHandle => "VK_NVX_image_view_handle",
884 Extension::AMDDrawIndirectCount => "VK_AMD_draw_indirect_count",
885 Extension::AMDNegativeViewportHeight => "VK_AMD_negative_viewport_height",
886 Extension::AMDGpuShaderHalfFloat => "VK_AMD_gpu_shader_half_float",
887 Extension::AMDShaderBallot => "VK_AMD_shader_ballot",
888 Extension::EXTVideoEncodeH264 => "VK_EXT_video_encode_h264",
889 Extension::EXTVideoEncodeH265 => "VK_EXT_video_encode_h265",
890 Extension::AMDTextureGatherBiasLod => "VK_AMD_texture_gather_bias_lod",
891 Extension::AMDShaderInfo => "VK_AMD_shader_info",
892 Extension::AMDShaderImageLoadStoreLod => "VK_AMD_shader_image_load_store_lod",
893 Extension::GGPStreamDescriptorSurface => "VK_GGP_stream_descriptor_surface",
894 Extension::NVCornerSampledImage => "VK_NV_corner_sampled_image",
895 Extension::IMGFormatPvrtc => "VK_IMG_format_pvrtc",
896 Extension::NVExternalMemoryCapabilities => "VK_NV_external_memory_capabilities",
897 Extension::NVExternalMemory => "VK_NV_external_memory",
898 Extension::NVExternalMemoryWin32 => "VK_NV_external_memory_win32",
899 Extension::NVWin32KeyedMutex => "VK_NV_win32_keyed_mutex",
900 Extension::EXTValidationFlags => "VK_EXT_validation_flags",
901 Extension::NNViSurface => "VK_NN_vi_surface",
902 Extension::EXTShaderSubgroupBallot => "VK_EXT_shader_subgroup_ballot",
903 Extension::EXTShaderSubgroupVote => "VK_EXT_shader_subgroup_vote",
904 Extension::EXTTextureCompressionAstcHdr => "VK_EXT_texture_compression_astc_hdr",
905 Extension::EXTAstcDecodeMode => "VK_EXT_astc_decode_mode",
906 Extension::EXTPipelineRobustness => "VK_EXT_pipeline_robustness",
907 Extension::EXTConditionalRendering => "VK_EXT_conditional_rendering",
908 Extension::NVClipSpaceWScaling => "VK_NV_clip_space_w_scaling",
909 Extension::EXTDirectModeDisplay => "VK_EXT_direct_mode_display",
910 Extension::EXTAcquireXlibDisplay => "VK_EXT_acquire_xlib_display",
911 Extension::EXTDisplaySurfaceCounter => "VK_EXT_display_surface_counter",
912 Extension::EXTDisplayControl => "VK_EXT_display_control",
913 Extension::GOOGLEDisplayTiming => "VK_GOOGLE_display_timing",
914 Extension::NVSampleMaskOverrideCoverage => "VK_NV_sample_mask_override_coverage",
915 Extension::NVGeometryShaderPassthrough => "VK_NV_geometry_shader_passthrough",
916 Extension::NVViewportArray2 => "VK_NV_viewport_array2",
917 Extension::NVXMultiviewPerViewAttributes => "VK_NVX_multiview_per_view_attributes",
918 Extension::NVViewportSwizzle => "VK_NV_viewport_swizzle",
919 Extension::EXTDiscardRectangles => "VK_EXT_discard_rectangles",
920 Extension::EXTConservativeRasterization => "VK_EXT_conservative_rasterization",
921 Extension::EXTDepthClipEnable => "VK_EXT_depth_clip_enable",
922 Extension::EXTSwapchainColorspace => "VK_EXT_swapchain_colorspace",
923 Extension::EXTHdrMetadata => "VK_EXT_hdr_metadata",
924 Extension::MVKIosSurface => "VK_MVK_ios_surface",
925 Extension::MVKMacosSurface => "VK_MVK_macos_surface",
926 Extension::EXTExternalMemoryDmaBuf => "VK_EXT_external_memory_dma_buf",
927 Extension::EXTQueueFamilyForeign => "VK_EXT_queue_family_foreign",
928 Extension::EXTDebugUtils => "VK_EXT_debug_utils",
929 Extension::ANDROIDExternalMemoryAndroidHardwareBuffer => {
930 "VK_ANDROID_external_memory_android_hardware_buffer"
931 }
932 Extension::EXTSamplerFilterMinmax => "VK_EXT_sampler_filter_minmax",
933 Extension::AMDGpuShaderInt16 => "VK_AMD_gpu_shader_int16",
934 Extension::AMDMixedAttachmentSamples => "VK_AMD_mixed_attachment_samples",
935 Extension::AMDShaderFragmentMask => "VK_AMD_shader_fragment_mask",
936 Extension::EXTInlineUniformBlock => "VK_EXT_inline_uniform_block",
937 Extension::EXTShaderStencilExport => "VK_EXT_shader_stencil_export",
938 Extension::EXTSampleLocations => "VK_EXT_sample_locations",
939 Extension::EXTBlendOperationAdvanced => "VK_EXT_blend_operation_advanced",
940 Extension::NVFragmentCoverageToColor => "VK_NV_fragment_coverage_to_color",
941 Extension::NVFramebufferMixedSamples => "VK_NV_framebuffer_mixed_samples",
942 Extension::NVFillRectangle => "VK_NV_fill_rectangle",
943 Extension::NVShaderSmBuiltins => "VK_NV_shader_sm_builtins",
944 Extension::EXTPostDepthCoverage => "VK_EXT_post_depth_coverage",
945 Extension::EXTImageDrmFormatModifier => "VK_EXT_image_drm_format_modifier",
946 Extension::EXTValidationCache => "VK_EXT_validation_cache",
947 Extension::EXTDescriptorIndexing => "VK_EXT_descriptor_indexing",
948 Extension::EXTShaderViewportIndexLayer => "VK_EXT_shader_viewport_index_layer",
949 Extension::NVShadingRateImage => "VK_NV_shading_rate_image",
950 Extension::NVRayTracing => "VK_NV_ray_tracing",
951 Extension::NVRepresentativeFragmentTest => "VK_NV_representative_fragment_test",
952 Extension::EXTFilterCubic => "VK_EXT_filter_cubic",
953 Extension::QCOMRenderPassShaderResolve => "VK_QCOM_render_pass_shader_resolve",
954 Extension::EXTGlobalPriority => "VK_EXT_global_priority",
955 Extension::EXTExternalMemoryHost => "VK_EXT_external_memory_host",
956 Extension::AMDBufferMarker => "VK_AMD_buffer_marker",
957 Extension::AMDPipelineCompilerControl => "VK_AMD_pipeline_compiler_control",
958 Extension::EXTCalibratedTimestamps => "VK_EXT_calibrated_timestamps",
959 Extension::AMDShaderCoreProperties => "VK_AMD_shader_core_properties",
960 Extension::AMDMemoryOverallocationBehavior => "VK_AMD_memory_overallocation_behavior",
961 Extension::EXTVertexAttributeDivisor => "VK_EXT_vertex_attribute_divisor",
962 Extension::GGPFrameToken => "VK_GGP_frame_token",
963 Extension::EXTPipelineCreationFeedback => "VK_EXT_pipeline_creation_feedback",
964 Extension::NVShaderSubgroupPartitioned => "VK_NV_shader_subgroup_partitioned",
965 Extension::NVComputeShaderDerivatives => "VK_NV_compute_shader_derivatives",
966 Extension::NVMeshShader => "VK_NV_mesh_shader",
967 Extension::NVFragmentShaderBarycentric => "VK_NV_fragment_shader_barycentric",
968 Extension::NVShaderImageFootprint => "VK_NV_shader_image_footprint",
969 Extension::NVScissorExclusive => "VK_NV_scissor_exclusive",
970 Extension::NVDeviceDiagnosticCheckpoints => "VK_NV_device_diagnostic_checkpoints",
971 Extension::INTELShaderIntegerFunctions2 => "VK_INTEL_shader_integer_functions2",
972 Extension::INTELPerformanceQuery => "VK_INTEL_performance_query",
973 Extension::EXTPciBusInfo => "VK_EXT_pci_bus_info",
974 Extension::AMDDisplayNativeHdr => "VK_AMD_display_native_hdr",
975 Extension::FUCHSIAImagepipeSurface => "VK_FUCHSIA_imagepipe_surface",
976 Extension::EXTMetalSurface => "VK_EXT_metal_surface",
977 Extension::EXTFragmentDensityMap => "VK_EXT_fragment_density_map",
978 Extension::EXTScalarBlockLayout => "VK_EXT_scalar_block_layout",
979 Extension::GOOGLEHlslFunctionality1 => "VK_GOOGLE_hlsl_functionality1",
980 Extension::GOOGLEDecorateString => "VK_GOOGLE_decorate_string",
981 Extension::EXTSubgroupSizeControl => "VK_EXT_subgroup_size_control",
982 Extension::AMDShaderCoreProperties2 => "VK_AMD_shader_core_properties2",
983 Extension::AMDDeviceCoherentMemory => "VK_AMD_device_coherent_memory",
984 Extension::EXTShaderImageAtomicInt64 => "VK_EXT_shader_image_atomic_int64",
985 Extension::EXTMemoryBudget => "VK_EXT_memory_budget",
986 Extension::EXTMemoryPriority => "VK_EXT_memory_priority",
987 Extension::NVDedicatedAllocationImageAliasing => {
988 "VK_NV_dedicated_allocation_image_aliasing"
989 }
990 Extension::EXTBufferDeviceAddress => "VK_EXT_buffer_device_address",
991 Extension::EXTToolingInfo => "VK_EXT_tooling_info",
992 Extension::EXTSeparateStencilUsage => "VK_EXT_separate_stencil_usage",
993 Extension::EXTValidationFeatures => "VK_EXT_validation_features",
994 Extension::NVCooperativeMatrix => "VK_NV_cooperative_matrix",
995 Extension::NVCoverageReductionMode => "VK_NV_coverage_reduction_mode",
996 Extension::EXTFragmentShaderInterlock => "VK_EXT_fragment_shader_interlock",
997 Extension::EXTYcbcrImageArrays => "VK_EXT_ycbcr_image_arrays",
998 Extension::EXTProvokingVertex => "VK_EXT_provoking_vertex",
999 Extension::EXTFullScreenExclusive => "VK_EXT_full_screen_exclusive",
1000 Extension::EXTHeadlessSurface => "VK_EXT_headless_surface",
1001 Extension::EXTLineRasterization => "VK_EXT_line_rasterization",
1002 Extension::EXTShaderAtomicFloat => "VK_EXT_shader_atomic_float",
1003 Extension::EXTHostQueryReset => "VK_EXT_host_query_reset",
1004 Extension::EXTIndexTypeUint8 => "VK_EXT_index_type_uint8",
1005 Extension::EXTExtendedDynamicState => "VK_EXT_extended_dynamic_state",
1006 Extension::EXTShaderAtomicFloat2 => "VK_EXT_shader_atomic_float2",
1007 Extension::EXTSurfaceMaintenance1 => "VK_EXT_surface_maintenance1",
1008 Extension::EXTSwapchainMaintenance1 => "VK_EXT_swapchain_maintenance1",
1009 Extension::EXTShaderDemoteToHelperInvocation => {
1010 "VK_EXT_shader_demote_to_helper_invocation"
1011 }
1012 Extension::NVDeviceGeneratedCommands => "VK_NV_device_generated_commands",
1013 Extension::NVInheritedViewportScissor => "VK_NV_inherited_viewport_scissor",
1014 Extension::EXTTexelBufferAlignment => "VK_EXT_texel_buffer_alignment",
1015 Extension::QCOMRenderPassTransform => "VK_QCOM_render_pass_transform",
1016 Extension::EXTDeviceMemoryReport => "VK_EXT_device_memory_report",
1017 Extension::EXTAcquireDrmDisplay => "VK_EXT_acquire_drm_display",
1018 Extension::EXTRobustness2 => "VK_EXT_robustness2",
1019 Extension::EXTCustomBorderColor => "VK_EXT_custom_border_color",
1020 Extension::GOOGLEUserType => "VK_GOOGLE_user_type",
1021 Extension::NVPresentBarrier => "VK_NV_present_barrier",
1022 Extension::EXTPrivateData => "VK_EXT_private_data",
1023 Extension::EXTPipelineCreationCacheControl => "VK_EXT_pipeline_creation_cache_control",
1024 Extension::NVDeviceDiagnosticsConfig => "VK_NV_device_diagnostics_config",
1025 Extension::QCOMRenderPassStoreOps => "VK_QCOM_render_pass_store_ops",
1026 Extension::NVLowLatency => "VK_NV_low_latency",
1027 Extension::EXTMetalObjects => "VK_EXT_metal_objects",
1028 Extension::EXTDescriptorBuffer => "VK_EXT_descriptor_buffer",
1029 Extension::EXTGraphicsPipelineLibrary => "VK_EXT_graphics_pipeline_library",
1030 Extension::AMDShaderEarlyAndLateFragmentTests => {
1031 "VK_AMD_shader_early_and_late_fragment_tests"
1032 }
1033 Extension::NVFragmentShadingRateEnums => "VK_NV_fragment_shading_rate_enums",
1034 Extension::NVRayTracingMotionBlur => "VK_NV_ray_tracing_motion_blur",
1035 Extension::EXTYcbcr2plane444Formats => "VK_EXT_ycbcr_2plane_444_formats",
1036 Extension::EXTFragmentDensityMap2 => "VK_EXT_fragment_density_map2",
1037 Extension::QCOMRotatedCopyCommands => "VK_QCOM_rotated_copy_commands",
1038 Extension::EXTImageRobustness => "VK_EXT_image_robustness",
1039 Extension::EXTImageCompressionControl => "VK_EXT_image_compression_control",
1040 Extension::EXTAttachmentFeedbackLoopLayout => "VK_EXT_attachment_feedback_loop_layout",
1041 Extension::EXT4444Formats => "VK_EXT_4444_formats",
1042 Extension::EXTDeviceFault => "VK_EXT_device_fault",
1043 Extension::ARMRasterizationOrderAttachmentAccess => {
1044 "VK_ARM_rasterization_order_attachment_access"
1045 }
1046 Extension::EXTRgba10x6Formats => "VK_EXT_rgba10x6_formats",
1047 Extension::NVAcquireWinrtDisplay => "VK_NV_acquire_winrt_display",
1048 Extension::EXTDirectfbSurface => "VK_EXT_directfb_surface",
1049 Extension::VALVEMutableDescriptorType => "VK_VALVE_mutable_descriptor_type",
1050 Extension::EXTVertexInputDynamicState => "VK_EXT_vertex_input_dynamic_state",
1051 Extension::EXTPhysicalDeviceDrm => "VK_EXT_physical_device_drm",
1052 Extension::EXTDeviceAddressBindingReport => "VK_EXT_device_address_binding_report",
1053 Extension::EXTDepthClipControl => "VK_EXT_depth_clip_control",
1054 Extension::EXTPrimitiveTopologyListRestart => "VK_EXT_primitive_topology_list_restart",
1055 Extension::FUCHSIAExternalMemory => "VK_FUCHSIA_external_memory",
1056 Extension::FUCHSIAExternalSemaphore => "VK_FUCHSIA_external_semaphore",
1057 Extension::FUCHSIABufferCollection => "VK_FUCHSIA_buffer_collection",
1058 Extension::HUAWEISubpassShading => "VK_HUAWEI_subpass_shading",
1059 Extension::HUAWEIInvocationMask => "VK_HUAWEI_invocation_mask",
1060 Extension::NVExternalMemoryRdma => "VK_NV_external_memory_rdma",
1061 Extension::EXTPipelineProperties => "VK_EXT_pipeline_properties",
1062 Extension::EXTMultisampledRenderToSingleSampled => {
1063 "VK_EXT_multisampled_render_to_single_sampled"
1064 }
1065 Extension::EXTExtendedDynamicState2 => "VK_EXT_extended_dynamic_state2",
1066 Extension::QNXScreenSurface => "VK_QNX_screen_surface",
1067 Extension::EXTColorWriteEnable => "VK_EXT_color_write_enable",
1068 Extension::EXTPrimitivesGeneratedQuery => "VK_EXT_primitives_generated_query",
1069 Extension::EXTGlobalPriorityQuery => "VK_EXT_global_priority_query",
1070 Extension::EXTImageViewMinLod => "VK_EXT_image_view_min_lod",
1071 Extension::EXTMultiDraw => "VK_EXT_multi_draw",
1072 Extension::EXTImage2dViewOf3d => "VK_EXT_image_2d_view_of_3d",
1073 Extension::EXTShaderTileImage => "VK_EXT_shader_tile_image",
1074 Extension::EXTOpacityMicromap => "VK_EXT_opacity_micromap",
1075 Extension::NVDisplacementMicromap => "VK_NV_displacement_micromap",
1076 Extension::EXTLoadStoreOpNone => "VK_EXT_load_store_op_none",
1077 Extension::HUAWEIClusterCullingShader => "VK_HUAWEI_cluster_culling_shader",
1078 Extension::EXTBorderColorSwizzle => "VK_EXT_border_color_swizzle",
1079 Extension::EXTPageableDeviceLocalMemory => "VK_EXT_pageable_device_local_memory",
1080 Extension::ARMShaderCoreProperties => "VK_ARM_shader_core_properties",
1081 Extension::EXTImageSlicedViewOf3d => "VK_EXT_image_sliced_view_of_3d",
1082 Extension::VALVEDescriptorSetHostMapping => "VK_VALVE_descriptor_set_host_mapping",
1083 Extension::EXTDepthClampZeroOne => "VK_EXT_depth_clamp_zero_one",
1084 Extension::EXTNonSeamlessCubeMap => "VK_EXT_non_seamless_cube_map",
1085 Extension::QCOMFragmentDensityMapOffset => "VK_QCOM_fragment_density_map_offset",
1086 Extension::NVCopyMemoryIndirect => "VK_NV_copy_memory_indirect",
1087 Extension::NVMemoryDecompression => "VK_NV_memory_decompression",
1088 Extension::NVLinearColorAttachment => "VK_NV_linear_color_attachment",
1089 Extension::GOOGLESurfacelessQuery => "VK_GOOGLE_surfaceless_query",
1090 Extension::EXTImageCompressionControlSwapchain => {
1091 "VK_EXT_image_compression_control_swapchain"
1092 }
1093 Extension::QCOMImageProcessing => "VK_QCOM_image_processing",
1094 Extension::EXTExtendedDynamicState3 => "VK_EXT_extended_dynamic_state3",
1095 Extension::EXTSubpassMergeFeedback => "VK_EXT_subpass_merge_feedback",
1096 Extension::LUNARGDirectDriverLoading => "VK_LUNARG_direct_driver_loading",
1097 Extension::EXTShaderModuleIdentifier => "VK_EXT_shader_module_identifier",
1098 Extension::EXTRasterizationOrderAttachmentAccess => {
1099 "VK_EXT_rasterization_order_attachment_access"
1100 }
1101 Extension::NVOpticalFlow => "VK_NV_optical_flow",
1102 Extension::EXTLegacyDithering => "VK_EXT_legacy_dithering",
1103 Extension::EXTPipelineProtectedAccess => "VK_EXT_pipeline_protected_access",
1104 Extension::EXTShaderObject => "VK_EXT_shader_object",
1105 Extension::QCOMTileProperties => "VK_QCOM_tile_properties",
1106 Extension::SECAmigoProfiling => "VK_SEC_amigo_profiling",
1107 Extension::QCOMMultiviewPerViewViewports => "VK_QCOM_multiview_per_view_viewports",
1108 Extension::NVRayTracingInvocationReorder => "VK_NV_ray_tracing_invocation_reorder",
1109 Extension::EXTMutableDescriptorType => "VK_EXT_mutable_descriptor_type",
1110 Extension::ARMShaderCoreBuiltins => "VK_ARM_shader_core_builtins",
1111 Extension::EXTPipelineLibraryGroupHandles => "VK_EXT_pipeline_library_group_handles",
1112 Extension::EXTDynamicRenderingUnusedAttachments => {
1113 "VK_EXT_dynamic_rendering_unused_attachments"
1114 }
1115 Extension::QCOMMultiviewPerViewRenderAreas => "VK_QCOM_multiview_per_view_render_areas",
1116 Extension::EXTAttachmentFeedbackLoopDynamicState => {
1117 "VK_EXT_attachment_feedback_loop_dynamic_state"
1118 }
1119 Extension::KHRAccelerationStructure => "VK_KHR_acceleration_structure",
1120 Extension::KHRRayTracingPipeline => "VK_KHR_ray_tracing_pipeline",
1121 Extension::KHRRayQuery => "VK_KHR_ray_query",
1122 Extension::EXTMeshShader => "VK_EXT_mesh_shader",
1123 }
1124 }
1125}
1126
1127pub(crate) struct DeviceDispatchTable {
1128 pub core: Arc<ash::Device>,
1129 khr_swapchain: Arc<ash::vk::KhrSwapchainFn>,
1130 khr_video_queue: Arc<ash::vk::KhrVideoQueueFn>,
1131 khr_performance_query: Arc<ash::vk::KhrPerformanceQueryFn>,
1132 khr_fragment_shading_rate: Arc<ash::vk::KhrFragmentShadingRateFn>,
1133 ext_debug_utils: Arc<ash::vk::ExtDebugUtilsFn>,
1134 ext_sample_locations: Arc<ash::vk::ExtSampleLocationsFn>,
1135 ext_calibrated_timestamps: Arc<ash::vk::ExtCalibratedTimestampsFn>,
1136 ext_full_screen_exclusive: Arc<ash::vk::ExtFullScreenExclusiveFn>,
1137 nv_optical_flow: Arc<ash::vk::NvOpticalFlowFn>,
1138 khr_display_swapchain: Arc<ash::vk::KhrDisplaySwapchainFn>,
1139 khr_video_decode_queue: Arc<ash::vk::KhrVideoDecodeQueueFn>,
1140 khr_external_memory_win32: Arc<ash::vk::KhrExternalMemoryWin32Fn>,
1141 khr_external_memory_fd: Arc<ash::vk::KhrExternalMemoryFdFn>,
1142 khr_external_semaphore_win32: Arc<ash::vk::KhrExternalSemaphoreWin32Fn>,
1143 khr_external_semaphore_fd: Arc<ash::vk::KhrExternalSemaphoreFdFn>,
1144 khr_push_descriptor: Arc<ash::vk::KhrPushDescriptorFn>,
1145 khr_shared_presentable_image: Arc<ash::vk::KhrSharedPresentableImageFn>,
1146 khr_external_fence_win32: Arc<ash::vk::KhrExternalFenceWin32Fn>,
1147 khr_external_fence_fd: Arc<ash::vk::KhrExternalFenceFdFn>,
1148 khr_present_wait: Arc<ash::vk::KhrPresentWaitFn>,
1149 khr_deferred_host_operations: Arc<ash::vk::KhrDeferredHostOperationsFn>,
1150 khr_pipeline_executable_properties: Arc<ash::vk::KhrPipelineExecutablePropertiesFn>,
1151 khr_video_encode_queue: Arc<ash::vk::KhrVideoEncodeQueueFn>,
1152 khr_synchronization2: Arc<ash::vk::KhrSynchronization2Fn>,
1153 khr_ray_tracing_maintenance1: Arc<ash::vk::KhrRayTracingMaintenance1Fn>,
1154 android_native_buffer: Arc<ash::vk::AndroidNativeBufferFn>,
1155 ext_debug_marker: Arc<ash::vk::ExtDebugMarkerFn>,
1156 ext_transform_feedback: Arc<ash::vk::ExtTransformFeedbackFn>,
1157 nvx_binary_import: Arc<ash::vk::NvxBinaryImportFn>,
1158 nvx_image_view_handle: Arc<ash::vk::NvxImageViewHandleFn>,
1159 amd_shader_info: Arc<ash::vk::AmdShaderInfoFn>,
1160 nv_external_memory_win32: Arc<ash::vk::NvExternalMemoryWin32Fn>,
1161 ext_conditional_rendering: Arc<ash::vk::ExtConditionalRenderingFn>,
1162 nv_clip_space_w_scaling: Arc<ash::vk::NvClipSpaceWScalingFn>,
1163 ext_display_control: Arc<ash::vk::ExtDisplayControlFn>,
1164 google_display_timing: Arc<ash::vk::GoogleDisplayTimingFn>,
1165 ext_discard_rectangles: Arc<ash::vk::ExtDiscardRectanglesFn>,
1166 ext_hdr_metadata: Arc<ash::vk::ExtHdrMetadataFn>,
1167 android_external_memory_android_hardware_buffer:
1168 Arc<ash::vk::AndroidExternalMemoryAndroidHardwareBufferFn>,
1169 ext_image_drm_format_modifier: Arc<ash::vk::ExtImageDrmFormatModifierFn>,
1170 ext_validation_cache: Arc<ash::vk::ExtValidationCacheFn>,
1171 nv_shading_rate_image: Arc<ash::vk::NvShadingRateImageFn>,
1172 nv_ray_tracing: Arc<ash::vk::NvRayTracingFn>,
1173 khr_ray_tracing_pipeline: Arc<ash::vk::KhrRayTracingPipelineFn>,
1174 ext_external_memory_host: Arc<ash::vk::ExtExternalMemoryHostFn>,
1175 amd_buffer_marker: Arc<ash::vk::AmdBufferMarkerFn>,
1176 nv_mesh_shader: Arc<ash::vk::NvMeshShaderFn>,
1177 nv_scissor_exclusive: Arc<ash::vk::NvScissorExclusiveFn>,
1178 nv_device_diagnostic_checkpoints: Arc<ash::vk::NvDeviceDiagnosticCheckpointsFn>,
1179 intel_performance_query: Arc<ash::vk::IntelPerformanceQueryFn>,
1180 amd_display_native_hdr: Arc<ash::vk::AmdDisplayNativeHdrFn>,
1181 ext_line_rasterization: Arc<ash::vk::ExtLineRasterizationFn>,
1182 ext_swapchain_maintenance1: Arc<ash::vk::ExtSwapchainMaintenance1Fn>,
1183 nv_device_generated_commands: Arc<ash::vk::NvDeviceGeneratedCommandsFn>,
1184 ext_metal_objects: Arc<ash::vk::ExtMetalObjectsFn>,
1185 ext_descriptor_buffer: Arc<ash::vk::ExtDescriptorBufferFn>,
1186 nv_fragment_shading_rate_enums: Arc<ash::vk::NvFragmentShadingRateEnumsFn>,
1187 ext_image_compression_control: Arc<ash::vk::ExtImageCompressionControlFn>,
1188 ext_vertex_input_dynamic_state: Arc<ash::vk::ExtVertexInputDynamicStateFn>,
1189 fuchsia_external_memory: Arc<ash::vk::FuchsiaExternalMemoryFn>,
1190 fuchsia_external_semaphore: Arc<ash::vk::FuchsiaExternalSemaphoreFn>,
1191 fuchsia_buffer_collection: Arc<ash::vk::FuchsiaBufferCollectionFn>,
1192 huawei_subpass_shading: Arc<ash::vk::HuaweiSubpassShadingFn>,
1193 huawei_invocation_mask: Arc<ash::vk::HuaweiInvocationMaskFn>,
1194 nv_external_memory_rdma: Arc<ash::vk::NvExternalMemoryRdmaFn>,
1195 ext_pipeline_properties: Arc<ash::vk::ExtPipelinePropertiesFn>,
1196 ext_extended_dynamic_state2: Arc<ash::vk::ExtExtendedDynamicState2Fn>,
1197 ext_color_write_enable: Arc<ash::vk::ExtColorWriteEnableFn>,
1198 ext_multi_draw: Arc<ash::vk::ExtMultiDrawFn>,
1199 ext_opacity_micromap: Arc<ash::vk::ExtOpacityMicromapFn>,
1200 ext_pageable_device_local_memory: Arc<ash::vk::ExtPageableDeviceLocalMemoryFn>,
1201 valve_descriptor_set_host_mapping: Arc<ash::vk::ValveDescriptorSetHostMappingFn>,
1202 nv_copy_memory_indirect: Arc<ash::vk::NvCopyMemoryIndirectFn>,
1203 nv_memory_decompression: Arc<ash::vk::NvMemoryDecompressionFn>,
1204 ext_extended_dynamic_state3: Arc<ash::vk::ExtExtendedDynamicState3Fn>,
1205 ext_shader_module_identifier: Arc<ash::vk::ExtShaderModuleIdentifierFn>,
1206 qcom_tile_properties: Arc<ash::vk::QcomTilePropertiesFn>,
1207 khr_acceleration_structure: Arc<ash::vk::KhrAccelerationStructureFn>,
1208 ext_mesh_shader: Arc<ash::vk::ExtMeshShaderFn>,
1209}
1210impl DeviceDispatchTable {
1211 pub(crate) fn load(
1212 get_device_proc_addr: vk::PFN_vkGetDeviceProcAddr,
1213 device: Arc<ash::Device>,
1214 ) -> Self {
1215 let proc_addr_loader = get_device_proc_addr_loader(get_device_proc_addr, &device);
1216 Self {
1217 core: Arc::clone(&device),
1218 khr_swapchain: Arc::new(ash::vk::KhrSwapchainFn::load(&proc_addr_loader)),
1219 khr_video_queue: Arc::new(ash::vk::KhrVideoQueueFn::load(&proc_addr_loader)),
1220 khr_performance_query: Arc::new(ash::vk::KhrPerformanceQueryFn::load(
1221 &proc_addr_loader,
1222 )),
1223 khr_fragment_shading_rate: Arc::new(ash::vk::KhrFragmentShadingRateFn::load(
1224 &proc_addr_loader,
1225 )),
1226 ext_debug_utils: Arc::new(ash::vk::ExtDebugUtilsFn::load(&proc_addr_loader)),
1227 ext_sample_locations: Arc::new(ash::vk::ExtSampleLocationsFn::load(&proc_addr_loader)),
1228 ext_calibrated_timestamps: Arc::new(ash::vk::ExtCalibratedTimestampsFn::load(
1229 &proc_addr_loader,
1230 )),
1231 ext_full_screen_exclusive: Arc::new(ash::vk::ExtFullScreenExclusiveFn::load(
1232 &proc_addr_loader,
1233 )),
1234 nv_optical_flow: Arc::new(ash::vk::NvOpticalFlowFn::load(&proc_addr_loader)),
1235 khr_display_swapchain: Arc::new(ash::vk::KhrDisplaySwapchainFn::load(
1236 &proc_addr_loader,
1237 )),
1238 khr_video_decode_queue: Arc::new(ash::vk::KhrVideoDecodeQueueFn::load(
1239 &proc_addr_loader,
1240 )),
1241 khr_external_memory_win32: Arc::new(ash::vk::KhrExternalMemoryWin32Fn::load(
1242 &proc_addr_loader,
1243 )),
1244 khr_external_memory_fd: Arc::new(ash::vk::KhrExternalMemoryFdFn::load(
1245 &proc_addr_loader,
1246 )),
1247 khr_external_semaphore_win32: Arc::new(ash::vk::KhrExternalSemaphoreWin32Fn::load(
1248 &proc_addr_loader,
1249 )),
1250 khr_external_semaphore_fd: Arc::new(ash::vk::KhrExternalSemaphoreFdFn::load(
1251 &proc_addr_loader,
1252 )),
1253 khr_push_descriptor: Arc::new(ash::vk::KhrPushDescriptorFn::load(&proc_addr_loader)),
1254 khr_shared_presentable_image: Arc::new(ash::vk::KhrSharedPresentableImageFn::load(
1255 &proc_addr_loader,
1256 )),
1257 khr_external_fence_win32: Arc::new(ash::vk::KhrExternalFenceWin32Fn::load(
1258 &proc_addr_loader,
1259 )),
1260 khr_external_fence_fd: Arc::new(ash::vk::KhrExternalFenceFdFn::load(&proc_addr_loader)),
1261 khr_present_wait: Arc::new(ash::vk::KhrPresentWaitFn::load(&proc_addr_loader)),
1262 khr_deferred_host_operations: Arc::new(ash::vk::KhrDeferredHostOperationsFn::load(
1263 &proc_addr_loader,
1264 )),
1265 khr_pipeline_executable_properties: Arc::new(
1266 ash::vk::KhrPipelineExecutablePropertiesFn::load(&proc_addr_loader),
1267 ),
1268 khr_video_encode_queue: Arc::new(ash::vk::KhrVideoEncodeQueueFn::load(
1269 &proc_addr_loader,
1270 )),
1271 khr_synchronization2: Arc::new(ash::vk::KhrSynchronization2Fn::load(&proc_addr_loader)),
1272 khr_ray_tracing_maintenance1: Arc::new(ash::vk::KhrRayTracingMaintenance1Fn::load(
1273 &proc_addr_loader,
1274 )),
1275 android_native_buffer: Arc::new(ash::vk::AndroidNativeBufferFn::load(
1276 &proc_addr_loader,
1277 )),
1278 ext_debug_marker: Arc::new(ash::vk::ExtDebugMarkerFn::load(&proc_addr_loader)),
1279 ext_transform_feedback: Arc::new(ash::vk::ExtTransformFeedbackFn::load(
1280 &proc_addr_loader,
1281 )),
1282 nvx_binary_import: Arc::new(ash::vk::NvxBinaryImportFn::load(&proc_addr_loader)),
1283 nvx_image_view_handle: Arc::new(ash::vk::NvxImageViewHandleFn::load(&proc_addr_loader)),
1284 amd_shader_info: Arc::new(ash::vk::AmdShaderInfoFn::load(&proc_addr_loader)),
1285 nv_external_memory_win32: Arc::new(ash::vk::NvExternalMemoryWin32Fn::load(
1286 &proc_addr_loader,
1287 )),
1288 ext_conditional_rendering: Arc::new(ash::vk::ExtConditionalRenderingFn::load(
1289 &proc_addr_loader,
1290 )),
1291 nv_clip_space_w_scaling: Arc::new(ash::vk::NvClipSpaceWScalingFn::load(
1292 &proc_addr_loader,
1293 )),
1294 ext_display_control: Arc::new(ash::vk::ExtDisplayControlFn::load(&proc_addr_loader)),
1295 google_display_timing: Arc::new(ash::vk::GoogleDisplayTimingFn::load(
1296 &proc_addr_loader,
1297 )),
1298 ext_discard_rectangles: Arc::new(ash::vk::ExtDiscardRectanglesFn::load(
1299 &proc_addr_loader,
1300 )),
1301 ext_hdr_metadata: Arc::new(ash::vk::ExtHdrMetadataFn::load(&proc_addr_loader)),
1302 android_external_memory_android_hardware_buffer: Arc::new(
1303 ash::vk::AndroidExternalMemoryAndroidHardwareBufferFn::load(&proc_addr_loader),
1304 ),
1305 ext_image_drm_format_modifier: Arc::new(ash::vk::ExtImageDrmFormatModifierFn::load(
1306 &proc_addr_loader,
1307 )),
1308 ext_validation_cache: Arc::new(ash::vk::ExtValidationCacheFn::load(&proc_addr_loader)),
1309 nv_shading_rate_image: Arc::new(ash::vk::NvShadingRateImageFn::load(&proc_addr_loader)),
1310 nv_ray_tracing: Arc::new(ash::vk::NvRayTracingFn::load(&proc_addr_loader)),
1311 khr_ray_tracing_pipeline: Arc::new(ash::vk::KhrRayTracingPipelineFn::load(
1312 &proc_addr_loader,
1313 )),
1314 ext_external_memory_host: Arc::new(ash::vk::ExtExternalMemoryHostFn::load(
1315 &proc_addr_loader,
1316 )),
1317 amd_buffer_marker: Arc::new(ash::vk::AmdBufferMarkerFn::load(&proc_addr_loader)),
1318 nv_mesh_shader: Arc::new(ash::vk::NvMeshShaderFn::load(&proc_addr_loader)),
1319 nv_scissor_exclusive: Arc::new(ash::vk::NvScissorExclusiveFn::load(&proc_addr_loader)),
1320 nv_device_diagnostic_checkpoints: Arc::new(
1321 ash::vk::NvDeviceDiagnosticCheckpointsFn::load(&proc_addr_loader),
1322 ),
1323 intel_performance_query: Arc::new(ash::vk::IntelPerformanceQueryFn::load(
1324 &proc_addr_loader,
1325 )),
1326 amd_display_native_hdr: Arc::new(ash::vk::AmdDisplayNativeHdrFn::load(
1327 &proc_addr_loader,
1328 )),
1329 ext_line_rasterization: Arc::new(ash::vk::ExtLineRasterizationFn::load(
1330 &proc_addr_loader,
1331 )),
1332 ext_swapchain_maintenance1: Arc::new(ash::vk::ExtSwapchainMaintenance1Fn::load(
1333 &proc_addr_loader,
1334 )),
1335 nv_device_generated_commands: Arc::new(ash::vk::NvDeviceGeneratedCommandsFn::load(
1336 &proc_addr_loader,
1337 )),
1338 ext_metal_objects: Arc::new(ash::vk::ExtMetalObjectsFn::load(&proc_addr_loader)),
1339 ext_descriptor_buffer: Arc::new(ash::vk::ExtDescriptorBufferFn::load(
1340 &proc_addr_loader,
1341 )),
1342 nv_fragment_shading_rate_enums: Arc::new(ash::vk::NvFragmentShadingRateEnumsFn::load(
1343 &proc_addr_loader,
1344 )),
1345 ext_image_compression_control: Arc::new(ash::vk::ExtImageCompressionControlFn::load(
1346 &proc_addr_loader,
1347 )),
1348 ext_vertex_input_dynamic_state: Arc::new(ash::vk::ExtVertexInputDynamicStateFn::load(
1349 &proc_addr_loader,
1350 )),
1351 fuchsia_external_memory: Arc::new(ash::vk::FuchsiaExternalMemoryFn::load(
1352 &proc_addr_loader,
1353 )),
1354 fuchsia_external_semaphore: Arc::new(ash::vk::FuchsiaExternalSemaphoreFn::load(
1355 &proc_addr_loader,
1356 )),
1357 fuchsia_buffer_collection: Arc::new(ash::vk::FuchsiaBufferCollectionFn::load(
1358 &proc_addr_loader,
1359 )),
1360 huawei_subpass_shading: Arc::new(ash::vk::HuaweiSubpassShadingFn::load(
1361 &proc_addr_loader,
1362 )),
1363 huawei_invocation_mask: Arc::new(ash::vk::HuaweiInvocationMaskFn::load(
1364 &proc_addr_loader,
1365 )),
1366 nv_external_memory_rdma: Arc::new(ash::vk::NvExternalMemoryRdmaFn::load(
1367 &proc_addr_loader,
1368 )),
1369 ext_pipeline_properties: Arc::new(ash::vk::ExtPipelinePropertiesFn::load(
1370 &proc_addr_loader,
1371 )),
1372 ext_extended_dynamic_state2: Arc::new(ash::vk::ExtExtendedDynamicState2Fn::load(
1373 &proc_addr_loader,
1374 )),
1375 ext_color_write_enable: Arc::new(ash::vk::ExtColorWriteEnableFn::load(
1376 &proc_addr_loader,
1377 )),
1378 ext_multi_draw: Arc::new(ash::vk::ExtMultiDrawFn::load(&proc_addr_loader)),
1379 ext_opacity_micromap: Arc::new(ash::vk::ExtOpacityMicromapFn::load(&proc_addr_loader)),
1380 ext_pageable_device_local_memory: Arc::new(
1381 ash::vk::ExtPageableDeviceLocalMemoryFn::load(&proc_addr_loader),
1382 ),
1383 valve_descriptor_set_host_mapping: Arc::new(
1384 ash::vk::ValveDescriptorSetHostMappingFn::load(&proc_addr_loader),
1385 ),
1386 nv_copy_memory_indirect: Arc::new(ash::vk::NvCopyMemoryIndirectFn::load(
1387 &proc_addr_loader,
1388 )),
1389 nv_memory_decompression: Arc::new(ash::vk::NvMemoryDecompressionFn::load(
1390 &proc_addr_loader,
1391 )),
1392 ext_extended_dynamic_state3: Arc::new(ash::vk::ExtExtendedDynamicState3Fn::load(
1393 &proc_addr_loader,
1394 )),
1395 ext_shader_module_identifier: Arc::new(ash::vk::ExtShaderModuleIdentifierFn::load(
1396 &proc_addr_loader,
1397 )),
1398 qcom_tile_properties: Arc::new(ash::vk::QcomTilePropertiesFn::load(&proc_addr_loader)),
1399 khr_acceleration_structure: Arc::new(ash::vk::KhrAccelerationStructureFn::load(
1400 &proc_addr_loader,
1401 )),
1402 ext_mesh_shader: Arc::new(ash::vk::ExtMeshShaderFn::load(&proc_addr_loader)),
1403 }
1404 }
1405}
1406pub(crate) struct InstanceDispatchTable {
1407 pub core: Arc<ash::Instance>,
1408 khr_surface: Arc<ash::vk::KhrSurfaceFn>,
1409 khr_swapchain: Arc<ash::vk::KhrSwapchainFn>,
1410 khr_display: Arc<ash::vk::KhrDisplayFn>,
1411 khr_xlib_surface: Arc<ash::vk::KhrXlibSurfaceFn>,
1412 khr_xcb_surface: Arc<ash::vk::KhrXcbSurfaceFn>,
1413 khr_wayland_surface: Arc<ash::vk::KhrWaylandSurfaceFn>,
1414 khr_android_surface: Arc<ash::vk::KhrAndroidSurfaceFn>,
1415 khr_win32_surface: Arc<ash::vk::KhrWin32SurfaceFn>,
1416 khr_video_queue: Arc<ash::vk::KhrVideoQueueFn>,
1417 khr_performance_query: Arc<ash::vk::KhrPerformanceQueryFn>,
1418 khr_get_surface_capabilities2: Arc<ash::vk::KhrGetSurfaceCapabilities2Fn>,
1419 khr_get_display_properties2: Arc<ash::vk::KhrGetDisplayProperties2Fn>,
1420 khr_fragment_shading_rate: Arc<ash::vk::KhrFragmentShadingRateFn>,
1421 #[allow(deprecated)]
1422 ext_debug_report: Arc<ash::vk::ExtDebugReportFn>,
1423 ggp_stream_descriptor_surface: Arc<ash::vk::GgpStreamDescriptorSurfaceFn>,
1424 nv_external_memory_capabilities: Arc<ash::vk::NvExternalMemoryCapabilitiesFn>,
1425 nn_vi_surface: Arc<ash::vk::NnViSurfaceFn>,
1426 ext_direct_mode_display: Arc<ash::vk::ExtDirectModeDisplayFn>,
1427 ext_acquire_xlib_display: Arc<ash::vk::ExtAcquireXlibDisplayFn>,
1428 ext_display_surface_counter: Arc<ash::vk::ExtDisplaySurfaceCounterFn>,
1429 mvk_ios_surface: Arc<ash::vk::MvkIosSurfaceFn>,
1430 mvk_macos_surface: Arc<ash::vk::MvkMacosSurfaceFn>,
1431 ext_debug_utils: Arc<ash::vk::ExtDebugUtilsFn>,
1432 ext_sample_locations: Arc<ash::vk::ExtSampleLocationsFn>,
1433 ext_calibrated_timestamps: Arc<ash::vk::ExtCalibratedTimestampsFn>,
1434 fuchsia_imagepipe_surface: Arc<ash::vk::FuchsiaImagepipeSurfaceFn>,
1435 ext_metal_surface: Arc<ash::vk::ExtMetalSurfaceFn>,
1436 nv_cooperative_matrix: Arc<ash::vk::NvCooperativeMatrixFn>,
1437 nv_coverage_reduction_mode: Arc<ash::vk::NvCoverageReductionModeFn>,
1438 ext_full_screen_exclusive: Arc<ash::vk::ExtFullScreenExclusiveFn>,
1439 ext_headless_surface: Arc<ash::vk::ExtHeadlessSurfaceFn>,
1440 ext_acquire_drm_display: Arc<ash::vk::ExtAcquireDrmDisplayFn>,
1441 nv_acquire_winrt_display: Arc<ash::vk::NvAcquireWinrtDisplayFn>,
1442 ext_directfb_surface: Arc<ash::vk::ExtDirectfbSurfaceFn>,
1443 qnx_screen_surface: Arc<ash::vk::QnxScreenSurfaceFn>,
1444 nv_optical_flow: Arc<ash::vk::NvOpticalFlowFn>,
1445}
1446impl InstanceDispatchTable {
1447 pub(crate) fn load(
1448 get_instance_proc_addr: vk::PFN_vkGetInstanceProcAddr,
1449 instance: Arc<ash::Instance>,
1450 ) -> Self {
1451 let proc_addr_loader = get_instance_proc_addr_loader(get_instance_proc_addr, &instance);
1452 Self {
1453 core: Arc::clone(&instance),
1454 khr_surface: Arc::new(ash::vk::KhrSurfaceFn::load(&proc_addr_loader)),
1455 khr_swapchain: Arc::new(ash::vk::KhrSwapchainFn::load(&proc_addr_loader)),
1456 khr_display: Arc::new(ash::vk::KhrDisplayFn::load(&proc_addr_loader)),
1457 khr_xlib_surface: Arc::new(ash::vk::KhrXlibSurfaceFn::load(&proc_addr_loader)),
1458 khr_xcb_surface: Arc::new(ash::vk::KhrXcbSurfaceFn::load(&proc_addr_loader)),
1459 khr_wayland_surface: Arc::new(ash::vk::KhrWaylandSurfaceFn::load(&proc_addr_loader)),
1460 khr_android_surface: Arc::new(ash::vk::KhrAndroidSurfaceFn::load(&proc_addr_loader)),
1461 khr_win32_surface: Arc::new(ash::vk::KhrWin32SurfaceFn::load(&proc_addr_loader)),
1462 khr_video_queue: Arc::new(ash::vk::KhrVideoQueueFn::load(&proc_addr_loader)),
1463 khr_performance_query: Arc::new(ash::vk::KhrPerformanceQueryFn::load(
1464 &proc_addr_loader,
1465 )),
1466 khr_get_surface_capabilities2: Arc::new(ash::vk::KhrGetSurfaceCapabilities2Fn::load(
1467 &proc_addr_loader,
1468 )),
1469 khr_get_display_properties2: Arc::new(ash::vk::KhrGetDisplayProperties2Fn::load(
1470 &proc_addr_loader,
1471 )),
1472 khr_fragment_shading_rate: Arc::new(ash::vk::KhrFragmentShadingRateFn::load(
1473 &proc_addr_loader,
1474 )),
1475 ext_debug_report: Arc::new(ash::vk::ExtDebugReportFn::load(&proc_addr_loader)),
1476 ggp_stream_descriptor_surface: Arc::new(ash::vk::GgpStreamDescriptorSurfaceFn::load(
1477 &proc_addr_loader,
1478 )),
1479 nv_external_memory_capabilities: Arc::new(
1480 ash::vk::NvExternalMemoryCapabilitiesFn::load(&proc_addr_loader),
1481 ),
1482 nn_vi_surface: Arc::new(ash::vk::NnViSurfaceFn::load(&proc_addr_loader)),
1483 ext_direct_mode_display: Arc::new(ash::vk::ExtDirectModeDisplayFn::load(
1484 &proc_addr_loader,
1485 )),
1486 ext_acquire_xlib_display: Arc::new(ash::vk::ExtAcquireXlibDisplayFn::load(
1487 &proc_addr_loader,
1488 )),
1489 ext_display_surface_counter: Arc::new(ash::vk::ExtDisplaySurfaceCounterFn::load(
1490 &proc_addr_loader,
1491 )),
1492 mvk_ios_surface: Arc::new(ash::vk::MvkIosSurfaceFn::load(&proc_addr_loader)),
1493 mvk_macos_surface: Arc::new(ash::vk::MvkMacosSurfaceFn::load(&proc_addr_loader)),
1494 ext_debug_utils: Arc::new(ash::vk::ExtDebugUtilsFn::load(&proc_addr_loader)),
1495 ext_sample_locations: Arc::new(ash::vk::ExtSampleLocationsFn::load(&proc_addr_loader)),
1496 ext_calibrated_timestamps: Arc::new(ash::vk::ExtCalibratedTimestampsFn::load(
1497 &proc_addr_loader,
1498 )),
1499 fuchsia_imagepipe_surface: Arc::new(ash::vk::FuchsiaImagepipeSurfaceFn::load(
1500 &proc_addr_loader,
1501 )),
1502 ext_metal_surface: Arc::new(ash::vk::ExtMetalSurfaceFn::load(&proc_addr_loader)),
1503 nv_cooperative_matrix: Arc::new(ash::vk::NvCooperativeMatrixFn::load(
1504 &proc_addr_loader,
1505 )),
1506 nv_coverage_reduction_mode: Arc::new(ash::vk::NvCoverageReductionModeFn::load(
1507 &proc_addr_loader,
1508 )),
1509 ext_full_screen_exclusive: Arc::new(ash::vk::ExtFullScreenExclusiveFn::load(
1510 &proc_addr_loader,
1511 )),
1512 ext_headless_surface: Arc::new(ash::vk::ExtHeadlessSurfaceFn::load(&proc_addr_loader)),
1513 ext_acquire_drm_display: Arc::new(ash::vk::ExtAcquireDrmDisplayFn::load(
1514 &proc_addr_loader,
1515 )),
1516 nv_acquire_winrt_display: Arc::new(ash::vk::NvAcquireWinrtDisplayFn::load(
1517 &proc_addr_loader,
1518 )),
1519 ext_directfb_surface: Arc::new(ash::vk::ExtDirectfbSurfaceFn::load(&proc_addr_loader)),
1520 qnx_screen_surface: Arc::new(ash::vk::QnxScreenSurfaceFn::load(&proc_addr_loader)),
1521 nv_optical_flow: Arc::new(ash::vk::NvOpticalFlowFn::load(&proc_addr_loader)),
1522 }
1523 }
1524}
1525
1526impl<T: Layer> Global<T> {
1548 pub(crate) fn create_device_commands(
1549 &self,
1550 instance_info: &T::InstanceInfo,
1551 device_info: Option<&T::DeviceInfo>,
1552 ) -> Box<[VulkanCommand]> {
1553 let hooked_commands = self
1554 .layer_info
1555 .hooked_device_commands(instance_info, device_info)
1556 .collect::<HashSet<_>>();
1557 Box::new([
1558 VulkanCommand {
1559 name: "vkAcquireFullScreenExclusiveModeEXT",
1560 features: smallvec![Feature::Extension(Extension::EXTFullScreenExclusive)],
1561 hooked: hooked_commands
1562 .contains(&LayerVulkanCommand::AcquireFullScreenExclusiveModeExt),
1563 proc: unsafe {
1564 std::mem::transmute::<
1565 vk::PFN_vkAcquireFullScreenExclusiveModeEXT,
1566 vk::PFN_vkVoidFunction,
1567 >(Self::acquire_full_screen_exclusive_mode_ext)
1568 },
1569 },
1570 VulkanCommand {
1571 name: "vkAcquireImageANDROID",
1572 features: smallvec![Feature::Extension(Extension::ANDROIDNativeBuffer)],
1573 hooked: hooked_commands.contains(&LayerVulkanCommand::AcquireImageAndroid),
1574 proc: unsafe {
1575 std::mem::transmute::<vk::PFN_vkAcquireImageANDROID, vk::PFN_vkVoidFunction>(
1576 Self::acquire_image_android,
1577 )
1578 },
1579 },
1580 VulkanCommand {
1581 name: "vkAcquireNextImage2KHR",
1582 features: smallvec![
1583 Feature::Extension(Extension::KHRSwapchain),
1584 Feature::Extension(Extension::KHRDeviceGroup)
1585 ],
1586 hooked: hooked_commands.contains(&LayerVulkanCommand::AcquireNextImage2Khr),
1587 proc: unsafe {
1588 std::mem::transmute::<vk::PFN_vkAcquireNextImage2KHR, vk::PFN_vkVoidFunction>(
1589 Self::acquire_next_image2_khr,
1590 )
1591 },
1592 },
1593 VulkanCommand {
1594 name: "vkAcquireNextImageKHR",
1595 features: smallvec![Feature::Extension(Extension::KHRSwapchain)],
1596 hooked: hooked_commands.contains(&LayerVulkanCommand::AcquireNextImageKhr),
1597 proc: unsafe {
1598 std::mem::transmute::<vk::PFN_vkAcquireNextImageKHR, vk::PFN_vkVoidFunction>(
1599 Self::acquire_next_image_khr,
1600 )
1601 },
1602 },
1603 VulkanCommand {
1604 name: "vkAcquirePerformanceConfigurationINTEL",
1605 features: smallvec![Feature::Extension(Extension::INTELPerformanceQuery)],
1606 hooked: hooked_commands
1607 .contains(&LayerVulkanCommand::AcquirePerformanceConfigurationIntel),
1608 proc: unsafe {
1609 std::mem::transmute::<
1610 vk::PFN_vkAcquirePerformanceConfigurationINTEL,
1611 vk::PFN_vkVoidFunction,
1612 >(Self::acquire_performance_configuration_intel)
1613 },
1614 },
1615 VulkanCommand {
1616 name: "vkAcquireProfilingLockKHR",
1617 features: smallvec![Feature::Extension(Extension::KHRPerformanceQuery)],
1618 hooked: hooked_commands.contains(&LayerVulkanCommand::AcquireProfilingLockKhr),
1619 proc: unsafe {
1620 std::mem::transmute::<vk::PFN_vkAcquireProfilingLockKHR, vk::PFN_vkVoidFunction>(
1621 Self::acquire_profiling_lock_khr,
1622 )
1623 },
1624 },
1625 VulkanCommand {
1626 name: "vkAllocateCommandBuffers",
1627 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
1628 hooked: hooked_commands.contains(&LayerVulkanCommand::AllocateCommandBuffers),
1629 proc: unsafe {
1630 std::mem::transmute::<vk::PFN_vkAllocateCommandBuffers, vk::PFN_vkVoidFunction>(
1631 Self::allocate_command_buffers,
1632 )
1633 },
1634 },
1635 VulkanCommand {
1636 name: "vkAllocateDescriptorSets",
1637 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
1638 hooked: hooked_commands.contains(&LayerVulkanCommand::AllocateDescriptorSets),
1639 proc: unsafe {
1640 std::mem::transmute::<vk::PFN_vkAllocateDescriptorSets, vk::PFN_vkVoidFunction>(
1641 Self::allocate_descriptor_sets,
1642 )
1643 },
1644 },
1645 VulkanCommand {
1646 name: "vkAllocateMemory",
1647 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
1648 hooked: hooked_commands.contains(&LayerVulkanCommand::AllocateMemory),
1649 proc: unsafe {
1650 std::mem::transmute::<vk::PFN_vkAllocateMemory, vk::PFN_vkVoidFunction>(
1651 Self::allocate_memory,
1652 )
1653 },
1654 },
1655 VulkanCommand {
1656 name: "vkBeginCommandBuffer",
1657 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
1658 hooked: hooked_commands.contains(&LayerVulkanCommand::BeginCommandBuffer),
1659 proc: unsafe {
1660 std::mem::transmute::<vk::PFN_vkBeginCommandBuffer, vk::PFN_vkVoidFunction>(
1661 Self::begin_command_buffer,
1662 )
1663 },
1664 },
1665 VulkanCommand {
1666 name: "vkBindAccelerationStructureMemoryNV",
1667 features: smallvec![Feature::Extension(Extension::NVRayTracing)],
1668 hooked: hooked_commands
1669 .contains(&LayerVulkanCommand::BindAccelerationStructureMemoryNv),
1670 proc: unsafe {
1671 std::mem::transmute::<
1672 vk::PFN_vkBindAccelerationStructureMemoryNV,
1673 vk::PFN_vkVoidFunction,
1674 >(Self::bind_acceleration_structure_memory_nv)
1675 },
1676 },
1677 VulkanCommand {
1678 name: "vkBindBufferMemory",
1679 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
1680 hooked: hooked_commands.contains(&LayerVulkanCommand::BindBufferMemory),
1681 proc: unsafe {
1682 std::mem::transmute::<vk::PFN_vkBindBufferMemory, vk::PFN_vkVoidFunction>(
1683 Self::bind_buffer_memory,
1684 )
1685 },
1686 },
1687 VulkanCommand {
1688 name: "vkBindBufferMemory2",
1689 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 1 })],
1690 hooked: hooked_commands.contains(&LayerVulkanCommand::BindBufferMemory2),
1691 proc: unsafe {
1692 std::mem::transmute::<vk::PFN_vkBindBufferMemory2, vk::PFN_vkVoidFunction>(
1693 Self::bind_buffer_memory2,
1694 )
1695 },
1696 },
1697 VulkanCommand {
1698 name: "vkBindBufferMemory2KHR",
1699 features: smallvec![Feature::Extension(Extension::KHRBindMemory2)],
1700 hooked: hooked_commands.contains(&LayerVulkanCommand::BindBufferMemory2),
1701 proc: unsafe {
1702 std::mem::transmute::<vk::PFN_vkBindBufferMemory2, vk::PFN_vkVoidFunction>(
1703 Self::bind_buffer_memory2,
1704 )
1705 },
1706 },
1707 VulkanCommand {
1708 name: "vkBindImageMemory",
1709 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
1710 hooked: hooked_commands.contains(&LayerVulkanCommand::BindImageMemory),
1711 proc: unsafe {
1712 std::mem::transmute::<vk::PFN_vkBindImageMemory, vk::PFN_vkVoidFunction>(
1713 Self::bind_image_memory,
1714 )
1715 },
1716 },
1717 VulkanCommand {
1718 name: "vkBindImageMemory2",
1719 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 1 })],
1720 hooked: hooked_commands.contains(&LayerVulkanCommand::BindImageMemory2),
1721 proc: unsafe {
1722 std::mem::transmute::<vk::PFN_vkBindImageMemory2, vk::PFN_vkVoidFunction>(
1723 Self::bind_image_memory2,
1724 )
1725 },
1726 },
1727 VulkanCommand {
1728 name: "vkBindImageMemory2KHR",
1729 features: smallvec![Feature::Extension(Extension::KHRBindMemory2)],
1730 hooked: hooked_commands.contains(&LayerVulkanCommand::BindImageMemory2),
1731 proc: unsafe {
1732 std::mem::transmute::<vk::PFN_vkBindImageMemory2, vk::PFN_vkVoidFunction>(
1733 Self::bind_image_memory2,
1734 )
1735 },
1736 },
1737 VulkanCommand {
1738 name: "vkBindOpticalFlowSessionImageNV",
1739 features: smallvec![Feature::Extension(Extension::NVOpticalFlow)],
1740 hooked: hooked_commands
1741 .contains(&LayerVulkanCommand::BindOpticalFlowSessionImageNv),
1742 proc: unsafe {
1743 std::mem::transmute::<
1744 vk::PFN_vkBindOpticalFlowSessionImageNV,
1745 vk::PFN_vkVoidFunction,
1746 >(Self::bind_optical_flow_session_image_nv)
1747 },
1748 },
1749 VulkanCommand {
1750 name: "vkBindVideoSessionMemoryKHR",
1751 features: smallvec![Feature::Extension(Extension::KHRVideoQueue)],
1752 hooked: hooked_commands.contains(&LayerVulkanCommand::BindVideoSessionMemoryKhr),
1753 proc: unsafe {
1754 std::mem::transmute::<vk::PFN_vkBindVideoSessionMemoryKHR, vk::PFN_vkVoidFunction>(
1755 Self::bind_video_session_memory_khr,
1756 )
1757 },
1758 },
1759 VulkanCommand {
1760 name: "vkBuildMicromapsEXT",
1761 features: smallvec![Feature::Extension(Extension::EXTOpacityMicromap)],
1762 hooked: hooked_commands.contains(&LayerVulkanCommand::BuildMicromapsExt),
1763 proc: unsafe {
1764 std::mem::transmute::<vk::PFN_vkBuildMicromapsEXT, vk::PFN_vkVoidFunction>(
1765 Self::build_micromaps_ext,
1766 )
1767 },
1768 },
1769 VulkanCommand {
1770 name: "vkCmdBeginConditionalRenderingEXT",
1771 features: smallvec![Feature::Extension(Extension::EXTConditionalRendering)],
1772 hooked: hooked_commands
1773 .contains(&LayerVulkanCommand::CmdBeginConditionalRenderingExt),
1774 proc: unsafe {
1775 std::mem::transmute::<
1776 vk::PFN_vkCmdBeginConditionalRenderingEXT,
1777 vk::PFN_vkVoidFunction,
1778 >(Self::cmd_begin_conditional_rendering_ext)
1779 },
1780 },
1781 VulkanCommand {
1782 name: "vkCmdBeginDebugUtilsLabelEXT",
1783 features: smallvec![Feature::Extension(Extension::EXTDebugUtils)],
1784 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdBeginDebugUtilsLabelExt),
1785 proc: unsafe {
1786 std::mem::transmute::<
1787 vk::PFN_vkCmdBeginDebugUtilsLabelEXT,
1788 vk::PFN_vkVoidFunction,
1789 >(Self::cmd_begin_debug_utils_label_ext)
1790 },
1791 },
1792 VulkanCommand {
1793 name: "vkCmdBeginQuery",
1794 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
1795 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdBeginQuery),
1796 proc: unsafe {
1797 std::mem::transmute::<vk::PFN_vkCmdBeginQuery, vk::PFN_vkVoidFunction>(
1798 Self::cmd_begin_query,
1799 )
1800 },
1801 },
1802 VulkanCommand {
1803 name: "vkCmdBeginQueryIndexedEXT",
1804 features: smallvec![Feature::Extension(Extension::EXTTransformFeedback)],
1805 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdBeginQueryIndexedExt),
1806 proc: unsafe {
1807 std::mem::transmute::<vk::PFN_vkCmdBeginQueryIndexedEXT, vk::PFN_vkVoidFunction>(
1808 Self::cmd_begin_query_indexed_ext,
1809 )
1810 },
1811 },
1812 VulkanCommand {
1813 name: "vkCmdBeginRenderPass",
1814 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
1815 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdBeginRenderPass),
1816 proc: unsafe {
1817 std::mem::transmute::<vk::PFN_vkCmdBeginRenderPass, vk::PFN_vkVoidFunction>(
1818 Self::cmd_begin_render_pass,
1819 )
1820 },
1821 },
1822 VulkanCommand {
1823 name: "vkCmdBeginRenderPass2",
1824 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 2 })],
1825 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdBeginRenderPass2),
1826 proc: unsafe {
1827 std::mem::transmute::<vk::PFN_vkCmdBeginRenderPass2, vk::PFN_vkVoidFunction>(
1828 Self::cmd_begin_render_pass2,
1829 )
1830 },
1831 },
1832 VulkanCommand {
1833 name: "vkCmdBeginRenderPass2KHR",
1834 features: smallvec![Feature::Extension(Extension::KHRCreateRenderpass2)],
1835 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdBeginRenderPass2),
1836 proc: unsafe {
1837 std::mem::transmute::<vk::PFN_vkCmdBeginRenderPass2, vk::PFN_vkVoidFunction>(
1838 Self::cmd_begin_render_pass2,
1839 )
1840 },
1841 },
1842 VulkanCommand {
1843 name: "vkCmdBeginRendering",
1844 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 3 })],
1845 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdBeginRendering),
1846 proc: unsafe {
1847 std::mem::transmute::<vk::PFN_vkCmdBeginRendering, vk::PFN_vkVoidFunction>(
1848 Self::cmd_begin_rendering,
1849 )
1850 },
1851 },
1852 VulkanCommand {
1853 name: "vkCmdBeginRenderingKHR",
1854 features: smallvec![Feature::Extension(Extension::KHRDynamicRendering)],
1855 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdBeginRendering),
1856 proc: unsafe {
1857 std::mem::transmute::<vk::PFN_vkCmdBeginRendering, vk::PFN_vkVoidFunction>(
1858 Self::cmd_begin_rendering,
1859 )
1860 },
1861 },
1862 VulkanCommand {
1863 name: "vkCmdBeginTransformFeedbackEXT",
1864 features: smallvec![Feature::Extension(Extension::EXTTransformFeedback)],
1865 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdBeginTransformFeedbackExt),
1866 proc: unsafe {
1867 std::mem::transmute::<
1868 vk::PFN_vkCmdBeginTransformFeedbackEXT,
1869 vk::PFN_vkVoidFunction,
1870 >(Self::cmd_begin_transform_feedback_ext)
1871 },
1872 },
1873 VulkanCommand {
1874 name: "vkCmdBeginVideoCodingKHR",
1875 features: smallvec![Feature::Extension(Extension::KHRVideoQueue)],
1876 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdBeginVideoCodingKhr),
1877 proc: unsafe {
1878 std::mem::transmute::<vk::PFN_vkCmdBeginVideoCodingKHR, vk::PFN_vkVoidFunction>(
1879 Self::cmd_begin_video_coding_khr,
1880 )
1881 },
1882 },
1883 VulkanCommand {
1884 name: "vkCmdBindDescriptorBufferEmbeddedSamplersEXT",
1885 features: smallvec![Feature::Extension(Extension::EXTDescriptorBuffer)],
1886 hooked: hooked_commands
1887 .contains(&LayerVulkanCommand::CmdBindDescriptorBufferEmbeddedSamplersExt),
1888 proc: unsafe {
1889 std::mem::transmute::<
1890 vk::PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT,
1891 vk::PFN_vkVoidFunction,
1892 >(Self::cmd_bind_descriptor_buffer_embedded_samplers_ext)
1893 },
1894 },
1895 VulkanCommand {
1896 name: "vkCmdBindDescriptorBuffersEXT",
1897 features: smallvec![Feature::Extension(Extension::EXTDescriptorBuffer)],
1898 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdBindDescriptorBuffersExt),
1899 proc: unsafe {
1900 std::mem::transmute::<
1901 vk::PFN_vkCmdBindDescriptorBuffersEXT,
1902 vk::PFN_vkVoidFunction,
1903 >(Self::cmd_bind_descriptor_buffers_ext)
1904 },
1905 },
1906 VulkanCommand {
1907 name: "vkCmdBindDescriptorSets",
1908 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
1909 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdBindDescriptorSets),
1910 proc: unsafe {
1911 std::mem::transmute::<vk::PFN_vkCmdBindDescriptorSets, vk::PFN_vkVoidFunction>(
1912 Self::cmd_bind_descriptor_sets,
1913 )
1914 },
1915 },
1916 VulkanCommand {
1917 name: "vkCmdBindIndexBuffer",
1918 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
1919 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdBindIndexBuffer),
1920 proc: unsafe {
1921 std::mem::transmute::<vk::PFN_vkCmdBindIndexBuffer, vk::PFN_vkVoidFunction>(
1922 Self::cmd_bind_index_buffer,
1923 )
1924 },
1925 },
1926 VulkanCommand {
1927 name: "vkCmdBindInvocationMaskHUAWEI",
1928 features: smallvec![Feature::Extension(Extension::HUAWEIInvocationMask)],
1929 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdBindInvocationMaskHuawei),
1930 proc: unsafe {
1931 std::mem::transmute::<
1932 vk::PFN_vkCmdBindInvocationMaskHUAWEI,
1933 vk::PFN_vkVoidFunction,
1934 >(Self::cmd_bind_invocation_mask_huawei)
1935 },
1936 },
1937 VulkanCommand {
1938 name: "vkCmdBindPipeline",
1939 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
1940 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdBindPipeline),
1941 proc: unsafe {
1942 std::mem::transmute::<vk::PFN_vkCmdBindPipeline, vk::PFN_vkVoidFunction>(
1943 Self::cmd_bind_pipeline,
1944 )
1945 },
1946 },
1947 VulkanCommand {
1948 name: "vkCmdBindPipelineShaderGroupNV",
1949 features: smallvec![Feature::Extension(Extension::NVDeviceGeneratedCommands)],
1950 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdBindPipelineShaderGroupNv),
1951 proc: unsafe {
1952 std::mem::transmute::<
1953 vk::PFN_vkCmdBindPipelineShaderGroupNV,
1954 vk::PFN_vkVoidFunction,
1955 >(Self::cmd_bind_pipeline_shader_group_nv)
1956 },
1957 },
1958 VulkanCommand {
1959 name: "vkCmdBindShadingRateImageNV",
1960 features: smallvec![Feature::Extension(Extension::NVShadingRateImage)],
1961 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdBindShadingRateImageNv),
1962 proc: unsafe {
1963 std::mem::transmute::<vk::PFN_vkCmdBindShadingRateImageNV, vk::PFN_vkVoidFunction>(
1964 Self::cmd_bind_shading_rate_image_nv,
1965 )
1966 },
1967 },
1968 VulkanCommand {
1969 name: "vkCmdBindTransformFeedbackBuffersEXT",
1970 features: smallvec![Feature::Extension(Extension::EXTTransformFeedback)],
1971 hooked: hooked_commands
1972 .contains(&LayerVulkanCommand::CmdBindTransformFeedbackBuffersExt),
1973 proc: unsafe {
1974 std::mem::transmute::<
1975 vk::PFN_vkCmdBindTransformFeedbackBuffersEXT,
1976 vk::PFN_vkVoidFunction,
1977 >(Self::cmd_bind_transform_feedback_buffers_ext)
1978 },
1979 },
1980 VulkanCommand {
1981 name: "vkCmdBindVertexBuffers",
1982 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
1983 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdBindVertexBuffers),
1984 proc: unsafe {
1985 std::mem::transmute::<vk::PFN_vkCmdBindVertexBuffers, vk::PFN_vkVoidFunction>(
1986 Self::cmd_bind_vertex_buffers,
1987 )
1988 },
1989 },
1990 VulkanCommand {
1991 name: "vkCmdBindVertexBuffers2",
1992 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 3 })],
1993 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdBindVertexBuffers2),
1994 proc: unsafe {
1995 std::mem::transmute::<vk::PFN_vkCmdBindVertexBuffers2, vk::PFN_vkVoidFunction>(
1996 Self::cmd_bind_vertex_buffers2,
1997 )
1998 },
1999 },
2000 VulkanCommand {
2001 name: "vkCmdBindVertexBuffers2EXT",
2002 features: smallvec![
2003 Feature::Extension(Extension::EXTExtendedDynamicState),
2004 Feature::Extension(Extension::EXTShaderObject)
2005 ],
2006 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdBindVertexBuffers2),
2007 proc: unsafe {
2008 std::mem::transmute::<vk::PFN_vkCmdBindVertexBuffers2, vk::PFN_vkVoidFunction>(
2009 Self::cmd_bind_vertex_buffers2,
2010 )
2011 },
2012 },
2013 VulkanCommand {
2014 name: "vkCmdBlitImage",
2015 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
2016 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdBlitImage),
2017 proc: unsafe {
2018 std::mem::transmute::<vk::PFN_vkCmdBlitImage, vk::PFN_vkVoidFunction>(
2019 Self::cmd_blit_image,
2020 )
2021 },
2022 },
2023 VulkanCommand {
2024 name: "vkCmdBlitImage2",
2025 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 3 })],
2026 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdBlitImage2),
2027 proc: unsafe {
2028 std::mem::transmute::<vk::PFN_vkCmdBlitImage2, vk::PFN_vkVoidFunction>(
2029 Self::cmd_blit_image2,
2030 )
2031 },
2032 },
2033 VulkanCommand {
2034 name: "vkCmdBlitImage2KHR",
2035 features: smallvec![Feature::Extension(Extension::KHRCopyCommands2)],
2036 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdBlitImage2),
2037 proc: unsafe {
2038 std::mem::transmute::<vk::PFN_vkCmdBlitImage2, vk::PFN_vkVoidFunction>(
2039 Self::cmd_blit_image2,
2040 )
2041 },
2042 },
2043 VulkanCommand {
2044 name: "vkCmdBuildAccelerationStructureNV",
2045 features: smallvec![Feature::Extension(Extension::NVRayTracing)],
2046 hooked: hooked_commands
2047 .contains(&LayerVulkanCommand::CmdBuildAccelerationStructureNv),
2048 proc: unsafe {
2049 std::mem::transmute::<
2050 vk::PFN_vkCmdBuildAccelerationStructureNV,
2051 vk::PFN_vkVoidFunction,
2052 >(Self::cmd_build_acceleration_structure_nv)
2053 },
2054 },
2055 VulkanCommand {
2056 name: "vkCmdBuildMicromapsEXT",
2057 features: smallvec![Feature::Extension(Extension::EXTOpacityMicromap)],
2058 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdBuildMicromapsExt),
2059 proc: unsafe {
2060 std::mem::transmute::<vk::PFN_vkCmdBuildMicromapsEXT, vk::PFN_vkVoidFunction>(
2061 Self::cmd_build_micromaps_ext,
2062 )
2063 },
2064 },
2065 VulkanCommand {
2066 name: "vkCmdClearAttachments",
2067 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
2068 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdClearAttachments),
2069 proc: unsafe {
2070 std::mem::transmute::<vk::PFN_vkCmdClearAttachments, vk::PFN_vkVoidFunction>(
2071 Self::cmd_clear_attachments,
2072 )
2073 },
2074 },
2075 VulkanCommand {
2076 name: "vkCmdClearColorImage",
2077 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
2078 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdClearColorImage),
2079 proc: unsafe {
2080 std::mem::transmute::<vk::PFN_vkCmdClearColorImage, vk::PFN_vkVoidFunction>(
2081 Self::cmd_clear_color_image,
2082 )
2083 },
2084 },
2085 VulkanCommand {
2086 name: "vkCmdClearDepthStencilImage",
2087 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
2088 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdClearDepthStencilImage),
2089 proc: unsafe {
2090 std::mem::transmute::<vk::PFN_vkCmdClearDepthStencilImage, vk::PFN_vkVoidFunction>(
2091 Self::cmd_clear_depth_stencil_image,
2092 )
2093 },
2094 },
2095 VulkanCommand {
2096 name: "vkCmdControlVideoCodingKHR",
2097 features: smallvec![Feature::Extension(Extension::KHRVideoQueue)],
2098 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdControlVideoCodingKhr),
2099 proc: unsafe {
2100 std::mem::transmute::<vk::PFN_vkCmdControlVideoCodingKHR, vk::PFN_vkVoidFunction>(
2101 Self::cmd_control_video_coding_khr,
2102 )
2103 },
2104 },
2105 VulkanCommand {
2106 name: "vkCmdCopyAccelerationStructureKHR",
2107 features: smallvec![Feature::Extension(Extension::KHRAccelerationStructure)],
2108 hooked: hooked_commands
2109 .contains(&LayerVulkanCommand::CmdCopyAccelerationStructureKhr),
2110 proc: unsafe {
2111 std::mem::transmute::<
2112 vk::PFN_vkCmdCopyAccelerationStructureKHR,
2113 vk::PFN_vkVoidFunction,
2114 >(Self::cmd_copy_acceleration_structure_khr)
2115 },
2116 },
2117 VulkanCommand {
2118 name: "vkCmdCopyAccelerationStructureNV",
2119 features: smallvec![Feature::Extension(Extension::NVRayTracing)],
2120 hooked: hooked_commands
2121 .contains(&LayerVulkanCommand::CmdCopyAccelerationStructureNv),
2122 proc: unsafe {
2123 std::mem::transmute::<
2124 vk::PFN_vkCmdCopyAccelerationStructureNV,
2125 vk::PFN_vkVoidFunction,
2126 >(Self::cmd_copy_acceleration_structure_nv)
2127 },
2128 },
2129 VulkanCommand {
2130 name: "vkCmdCopyAccelerationStructureToMemoryKHR",
2131 features: smallvec![Feature::Extension(Extension::KHRAccelerationStructure)],
2132 hooked: hooked_commands
2133 .contains(&LayerVulkanCommand::CmdCopyAccelerationStructureToMemoryKhr),
2134 proc: unsafe {
2135 std::mem::transmute::<
2136 vk::PFN_vkCmdCopyAccelerationStructureToMemoryKHR,
2137 vk::PFN_vkVoidFunction,
2138 >(Self::cmd_copy_acceleration_structure_to_memory_khr)
2139 },
2140 },
2141 VulkanCommand {
2142 name: "vkCmdCopyBuffer",
2143 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
2144 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdCopyBuffer),
2145 proc: unsafe {
2146 std::mem::transmute::<vk::PFN_vkCmdCopyBuffer, vk::PFN_vkVoidFunction>(
2147 Self::cmd_copy_buffer,
2148 )
2149 },
2150 },
2151 VulkanCommand {
2152 name: "vkCmdCopyBuffer2",
2153 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 3 })],
2154 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdCopyBuffer2),
2155 proc: unsafe {
2156 std::mem::transmute::<vk::PFN_vkCmdCopyBuffer2, vk::PFN_vkVoidFunction>(
2157 Self::cmd_copy_buffer2,
2158 )
2159 },
2160 },
2161 VulkanCommand {
2162 name: "vkCmdCopyBuffer2KHR",
2163 features: smallvec![Feature::Extension(Extension::KHRCopyCommands2)],
2164 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdCopyBuffer2),
2165 proc: unsafe {
2166 std::mem::transmute::<vk::PFN_vkCmdCopyBuffer2, vk::PFN_vkVoidFunction>(
2167 Self::cmd_copy_buffer2,
2168 )
2169 },
2170 },
2171 VulkanCommand {
2172 name: "vkCmdCopyBufferToImage",
2173 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
2174 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdCopyBufferToImage),
2175 proc: unsafe {
2176 std::mem::transmute::<vk::PFN_vkCmdCopyBufferToImage, vk::PFN_vkVoidFunction>(
2177 Self::cmd_copy_buffer_to_image,
2178 )
2179 },
2180 },
2181 VulkanCommand {
2182 name: "vkCmdCopyBufferToImage2",
2183 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 3 })],
2184 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdCopyBufferToImage2),
2185 proc: unsafe {
2186 std::mem::transmute::<vk::PFN_vkCmdCopyBufferToImage2, vk::PFN_vkVoidFunction>(
2187 Self::cmd_copy_buffer_to_image2,
2188 )
2189 },
2190 },
2191 VulkanCommand {
2192 name: "vkCmdCopyBufferToImage2KHR",
2193 features: smallvec![Feature::Extension(Extension::KHRCopyCommands2)],
2194 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdCopyBufferToImage2),
2195 proc: unsafe {
2196 std::mem::transmute::<vk::PFN_vkCmdCopyBufferToImage2, vk::PFN_vkVoidFunction>(
2197 Self::cmd_copy_buffer_to_image2,
2198 )
2199 },
2200 },
2201 VulkanCommand {
2202 name: "vkCmdCopyImage",
2203 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
2204 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdCopyImage),
2205 proc: unsafe {
2206 std::mem::transmute::<vk::PFN_vkCmdCopyImage, vk::PFN_vkVoidFunction>(
2207 Self::cmd_copy_image,
2208 )
2209 },
2210 },
2211 VulkanCommand {
2212 name: "vkCmdCopyImage2",
2213 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 3 })],
2214 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdCopyImage2),
2215 proc: unsafe {
2216 std::mem::transmute::<vk::PFN_vkCmdCopyImage2, vk::PFN_vkVoidFunction>(
2217 Self::cmd_copy_image2,
2218 )
2219 },
2220 },
2221 VulkanCommand {
2222 name: "vkCmdCopyImage2KHR",
2223 features: smallvec![Feature::Extension(Extension::KHRCopyCommands2)],
2224 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdCopyImage2),
2225 proc: unsafe {
2226 std::mem::transmute::<vk::PFN_vkCmdCopyImage2, vk::PFN_vkVoidFunction>(
2227 Self::cmd_copy_image2,
2228 )
2229 },
2230 },
2231 VulkanCommand {
2232 name: "vkCmdCopyImageToBuffer",
2233 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
2234 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdCopyImageToBuffer),
2235 proc: unsafe {
2236 std::mem::transmute::<vk::PFN_vkCmdCopyImageToBuffer, vk::PFN_vkVoidFunction>(
2237 Self::cmd_copy_image_to_buffer,
2238 )
2239 },
2240 },
2241 VulkanCommand {
2242 name: "vkCmdCopyImageToBuffer2",
2243 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 3 })],
2244 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdCopyImageToBuffer2),
2245 proc: unsafe {
2246 std::mem::transmute::<vk::PFN_vkCmdCopyImageToBuffer2, vk::PFN_vkVoidFunction>(
2247 Self::cmd_copy_image_to_buffer2,
2248 )
2249 },
2250 },
2251 VulkanCommand {
2252 name: "vkCmdCopyImageToBuffer2KHR",
2253 features: smallvec![Feature::Extension(Extension::KHRCopyCommands2)],
2254 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdCopyImageToBuffer2),
2255 proc: unsafe {
2256 std::mem::transmute::<vk::PFN_vkCmdCopyImageToBuffer2, vk::PFN_vkVoidFunction>(
2257 Self::cmd_copy_image_to_buffer2,
2258 )
2259 },
2260 },
2261 VulkanCommand {
2262 name: "vkCmdCopyMemoryIndirectNV",
2263 features: smallvec![Feature::Extension(Extension::NVCopyMemoryIndirect)],
2264 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdCopyMemoryIndirectNv),
2265 proc: unsafe {
2266 std::mem::transmute::<vk::PFN_vkCmdCopyMemoryIndirectNV, vk::PFN_vkVoidFunction>(
2267 Self::cmd_copy_memory_indirect_nv,
2268 )
2269 },
2270 },
2271 VulkanCommand {
2272 name: "vkCmdCopyMemoryToAccelerationStructureKHR",
2273 features: smallvec![Feature::Extension(Extension::KHRAccelerationStructure)],
2274 hooked: hooked_commands
2275 .contains(&LayerVulkanCommand::CmdCopyMemoryToAccelerationStructureKhr),
2276 proc: unsafe {
2277 std::mem::transmute::<
2278 vk::PFN_vkCmdCopyMemoryToAccelerationStructureKHR,
2279 vk::PFN_vkVoidFunction,
2280 >(Self::cmd_copy_memory_to_acceleration_structure_khr)
2281 },
2282 },
2283 VulkanCommand {
2284 name: "vkCmdCopyMemoryToImageIndirectNV",
2285 features: smallvec![Feature::Extension(Extension::NVCopyMemoryIndirect)],
2286 hooked: hooked_commands
2287 .contains(&LayerVulkanCommand::CmdCopyMemoryToImageIndirectNv),
2288 proc: unsafe {
2289 std::mem::transmute::<
2290 vk::PFN_vkCmdCopyMemoryToImageIndirectNV,
2291 vk::PFN_vkVoidFunction,
2292 >(Self::cmd_copy_memory_to_image_indirect_nv)
2293 },
2294 },
2295 VulkanCommand {
2296 name: "vkCmdCopyMemoryToMicromapEXT",
2297 features: smallvec![Feature::Extension(Extension::EXTOpacityMicromap)],
2298 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdCopyMemoryToMicromapExt),
2299 proc: unsafe {
2300 std::mem::transmute::<
2301 vk::PFN_vkCmdCopyMemoryToMicromapEXT,
2302 vk::PFN_vkVoidFunction,
2303 >(Self::cmd_copy_memory_to_micromap_ext)
2304 },
2305 },
2306 VulkanCommand {
2307 name: "vkCmdCopyMicromapEXT",
2308 features: smallvec![Feature::Extension(Extension::EXTOpacityMicromap)],
2309 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdCopyMicromapExt),
2310 proc: unsafe {
2311 std::mem::transmute::<vk::PFN_vkCmdCopyMicromapEXT, vk::PFN_vkVoidFunction>(
2312 Self::cmd_copy_micromap_ext,
2313 )
2314 },
2315 },
2316 VulkanCommand {
2317 name: "vkCmdCopyMicromapToMemoryEXT",
2318 features: smallvec![Feature::Extension(Extension::EXTOpacityMicromap)],
2319 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdCopyMicromapToMemoryExt),
2320 proc: unsafe {
2321 std::mem::transmute::<
2322 vk::PFN_vkCmdCopyMicromapToMemoryEXT,
2323 vk::PFN_vkVoidFunction,
2324 >(Self::cmd_copy_micromap_to_memory_ext)
2325 },
2326 },
2327 VulkanCommand {
2328 name: "vkCmdCopyQueryPoolResults",
2329 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
2330 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdCopyQueryPoolResults),
2331 proc: unsafe {
2332 std::mem::transmute::<vk::PFN_vkCmdCopyQueryPoolResults, vk::PFN_vkVoidFunction>(
2333 Self::cmd_copy_query_pool_results,
2334 )
2335 },
2336 },
2337 VulkanCommand {
2338 name: "vkCmdCuLaunchKernelNVX",
2339 features: smallvec![Feature::Extension(Extension::NVXBinaryImport)],
2340 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdCuLaunchKernelNvx),
2341 proc: unsafe {
2342 std::mem::transmute::<vk::PFN_vkCmdCuLaunchKernelNVX, vk::PFN_vkVoidFunction>(
2343 Self::cmd_cu_launch_kernel_nvx,
2344 )
2345 },
2346 },
2347 VulkanCommand {
2348 name: "vkCmdDebugMarkerBeginEXT",
2349 features: smallvec![Feature::Extension(Extension::EXTDebugMarker)],
2350 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdDebugMarkerBeginExt),
2351 proc: unsafe {
2352 std::mem::transmute::<vk::PFN_vkCmdDebugMarkerBeginEXT, vk::PFN_vkVoidFunction>(
2353 Self::cmd_debug_marker_begin_ext,
2354 )
2355 },
2356 },
2357 VulkanCommand {
2358 name: "vkCmdDebugMarkerEndEXT",
2359 features: smallvec![Feature::Extension(Extension::EXTDebugMarker)],
2360 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdDebugMarkerEndExt),
2361 proc: unsafe {
2362 std::mem::transmute::<vk::PFN_vkCmdDebugMarkerEndEXT, vk::PFN_vkVoidFunction>(
2363 Self::cmd_debug_marker_end_ext,
2364 )
2365 },
2366 },
2367 VulkanCommand {
2368 name: "vkCmdDebugMarkerInsertEXT",
2369 features: smallvec![Feature::Extension(Extension::EXTDebugMarker)],
2370 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdDebugMarkerInsertExt),
2371 proc: unsafe {
2372 std::mem::transmute::<vk::PFN_vkCmdDebugMarkerInsertEXT, vk::PFN_vkVoidFunction>(
2373 Self::cmd_debug_marker_insert_ext,
2374 )
2375 },
2376 },
2377 VulkanCommand {
2378 name: "vkCmdDecodeVideoKHR",
2379 features: smallvec![Feature::Extension(Extension::KHRVideoDecodeQueue)],
2380 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdDecodeVideoKhr),
2381 proc: unsafe {
2382 std::mem::transmute::<vk::PFN_vkCmdDecodeVideoKHR, vk::PFN_vkVoidFunction>(
2383 Self::cmd_decode_video_khr,
2384 )
2385 },
2386 },
2387 VulkanCommand {
2388 name: "vkCmdDecompressMemoryIndirectCountNV",
2389 features: smallvec![Feature::Extension(Extension::NVMemoryDecompression)],
2390 hooked: hooked_commands
2391 .contains(&LayerVulkanCommand::CmdDecompressMemoryIndirectCountNv),
2392 proc: unsafe {
2393 std::mem::transmute::<
2394 vk::PFN_vkCmdDecompressMemoryIndirectCountNV,
2395 vk::PFN_vkVoidFunction,
2396 >(Self::cmd_decompress_memory_indirect_count_nv)
2397 },
2398 },
2399 VulkanCommand {
2400 name: "vkCmdDecompressMemoryNV",
2401 features: smallvec![Feature::Extension(Extension::NVMemoryDecompression)],
2402 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdDecompressMemoryNv),
2403 proc: unsafe {
2404 std::mem::transmute::<vk::PFN_vkCmdDecompressMemoryNV, vk::PFN_vkVoidFunction>(
2405 Self::cmd_decompress_memory_nv,
2406 )
2407 },
2408 },
2409 VulkanCommand {
2410 name: "vkCmdDispatch",
2411 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
2412 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdDispatch),
2413 proc: unsafe {
2414 std::mem::transmute::<vk::PFN_vkCmdDispatch, vk::PFN_vkVoidFunction>(
2415 Self::cmd_dispatch,
2416 )
2417 },
2418 },
2419 VulkanCommand {
2420 name: "vkCmdDispatchBase",
2421 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 1 })],
2422 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdDispatchBase),
2423 proc: unsafe {
2424 std::mem::transmute::<vk::PFN_vkCmdDispatchBase, vk::PFN_vkVoidFunction>(
2425 Self::cmd_dispatch_base,
2426 )
2427 },
2428 },
2429 VulkanCommand {
2430 name: "vkCmdDispatchBaseKHR",
2431 features: smallvec![Feature::Extension(Extension::KHRDeviceGroup)],
2432 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdDispatchBase),
2433 proc: unsafe {
2434 std::mem::transmute::<vk::PFN_vkCmdDispatchBase, vk::PFN_vkVoidFunction>(
2435 Self::cmd_dispatch_base,
2436 )
2437 },
2438 },
2439 VulkanCommand {
2440 name: "vkCmdDispatchIndirect",
2441 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
2442 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdDispatchIndirect),
2443 proc: unsafe {
2444 std::mem::transmute::<vk::PFN_vkCmdDispatchIndirect, vk::PFN_vkVoidFunction>(
2445 Self::cmd_dispatch_indirect,
2446 )
2447 },
2448 },
2449 VulkanCommand {
2450 name: "vkCmdDraw",
2451 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
2452 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdDraw),
2453 proc: unsafe {
2454 std::mem::transmute::<vk::PFN_vkCmdDraw, vk::PFN_vkVoidFunction>(Self::cmd_draw)
2455 },
2456 },
2457 VulkanCommand {
2458 name: "vkCmdDrawIndexed",
2459 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
2460 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdDrawIndexed),
2461 proc: unsafe {
2462 std::mem::transmute::<vk::PFN_vkCmdDrawIndexed, vk::PFN_vkVoidFunction>(
2463 Self::cmd_draw_indexed,
2464 )
2465 },
2466 },
2467 VulkanCommand {
2468 name: "vkCmdDrawIndexedIndirect",
2469 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
2470 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdDrawIndexedIndirect),
2471 proc: unsafe {
2472 std::mem::transmute::<vk::PFN_vkCmdDrawIndexedIndirect, vk::PFN_vkVoidFunction>(
2473 Self::cmd_draw_indexed_indirect,
2474 )
2475 },
2476 },
2477 VulkanCommand {
2478 name: "vkCmdDrawIndexedIndirectCount",
2479 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 2 })],
2480 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdDrawIndexedIndirectCount),
2481 proc: unsafe {
2482 std::mem::transmute::<
2483 vk::PFN_vkCmdDrawIndexedIndirectCount,
2484 vk::PFN_vkVoidFunction,
2485 >(Self::cmd_draw_indexed_indirect_count)
2486 },
2487 },
2488 VulkanCommand {
2489 name: "vkCmdDrawIndexedIndirectCountAMD",
2490 features: smallvec![Feature::Extension(Extension::AMDDrawIndirectCount)],
2491 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdDrawIndexedIndirectCount),
2492 proc: unsafe {
2493 std::mem::transmute::<
2494 vk::PFN_vkCmdDrawIndexedIndirectCount,
2495 vk::PFN_vkVoidFunction,
2496 >(Self::cmd_draw_indexed_indirect_count)
2497 },
2498 },
2499 VulkanCommand {
2500 name: "vkCmdDrawIndexedIndirectCountKHR",
2501 features: smallvec![Feature::Extension(Extension::KHRDrawIndirectCount)],
2502 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdDrawIndexedIndirectCount),
2503 proc: unsafe {
2504 std::mem::transmute::<
2505 vk::PFN_vkCmdDrawIndexedIndirectCount,
2506 vk::PFN_vkVoidFunction,
2507 >(Self::cmd_draw_indexed_indirect_count)
2508 },
2509 },
2510 VulkanCommand {
2511 name: "vkCmdDrawIndirect",
2512 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
2513 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdDrawIndirect),
2514 proc: unsafe {
2515 std::mem::transmute::<vk::PFN_vkCmdDrawIndirect, vk::PFN_vkVoidFunction>(
2516 Self::cmd_draw_indirect,
2517 )
2518 },
2519 },
2520 VulkanCommand {
2521 name: "vkCmdDrawIndirectByteCountEXT",
2522 features: smallvec![Feature::Extension(Extension::EXTTransformFeedback)],
2523 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdDrawIndirectByteCountExt),
2524 proc: unsafe {
2525 std::mem::transmute::<
2526 vk::PFN_vkCmdDrawIndirectByteCountEXT,
2527 vk::PFN_vkVoidFunction,
2528 >(Self::cmd_draw_indirect_byte_count_ext)
2529 },
2530 },
2531 VulkanCommand {
2532 name: "vkCmdDrawIndirectCount",
2533 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 2 })],
2534 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdDrawIndirectCount),
2535 proc: unsafe {
2536 std::mem::transmute::<vk::PFN_vkCmdDrawIndirectCount, vk::PFN_vkVoidFunction>(
2537 Self::cmd_draw_indirect_count,
2538 )
2539 },
2540 },
2541 VulkanCommand {
2542 name: "vkCmdDrawIndirectCountAMD",
2543 features: smallvec![Feature::Extension(Extension::AMDDrawIndirectCount)],
2544 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdDrawIndirectCount),
2545 proc: unsafe {
2546 std::mem::transmute::<vk::PFN_vkCmdDrawIndirectCount, vk::PFN_vkVoidFunction>(
2547 Self::cmd_draw_indirect_count,
2548 )
2549 },
2550 },
2551 VulkanCommand {
2552 name: "vkCmdDrawIndirectCountKHR",
2553 features: smallvec![Feature::Extension(Extension::KHRDrawIndirectCount)],
2554 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdDrawIndirectCount),
2555 proc: unsafe {
2556 std::mem::transmute::<vk::PFN_vkCmdDrawIndirectCount, vk::PFN_vkVoidFunction>(
2557 Self::cmd_draw_indirect_count,
2558 )
2559 },
2560 },
2561 VulkanCommand {
2562 name: "vkCmdDrawMeshTasksEXT",
2563 features: smallvec![Feature::Extension(Extension::EXTMeshShader)],
2564 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdDrawMeshTasksExt),
2565 proc: unsafe {
2566 std::mem::transmute::<vk::PFN_vkCmdDrawMeshTasksEXT, vk::PFN_vkVoidFunction>(
2567 Self::cmd_draw_mesh_tasks_ext,
2568 )
2569 },
2570 },
2571 VulkanCommand {
2572 name: "vkCmdDrawMeshTasksIndirectCountEXT",
2573 features: smallvec![Feature::Extension(Extension::EXTMeshShader)],
2574 hooked: hooked_commands
2575 .contains(&LayerVulkanCommand::CmdDrawMeshTasksIndirectCountExt),
2576 proc: unsafe {
2577 std::mem::transmute::<
2578 vk::PFN_vkCmdDrawMeshTasksIndirectCountEXT,
2579 vk::PFN_vkVoidFunction,
2580 >(Self::cmd_draw_mesh_tasks_indirect_count_ext)
2581 },
2582 },
2583 VulkanCommand {
2584 name: "vkCmdDrawMeshTasksIndirectCountNV",
2585 features: smallvec![Feature::Extension(Extension::NVMeshShader)],
2586 hooked: hooked_commands
2587 .contains(&LayerVulkanCommand::CmdDrawMeshTasksIndirectCountNv),
2588 proc: unsafe {
2589 std::mem::transmute::<
2590 vk::PFN_vkCmdDrawMeshTasksIndirectCountNV,
2591 vk::PFN_vkVoidFunction,
2592 >(Self::cmd_draw_mesh_tasks_indirect_count_nv)
2593 },
2594 },
2595 VulkanCommand {
2596 name: "vkCmdDrawMeshTasksIndirectEXT",
2597 features: smallvec![Feature::Extension(Extension::EXTMeshShader)],
2598 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdDrawMeshTasksIndirectExt),
2599 proc: unsafe {
2600 std::mem::transmute::<
2601 vk::PFN_vkCmdDrawMeshTasksIndirectEXT,
2602 vk::PFN_vkVoidFunction,
2603 >(Self::cmd_draw_mesh_tasks_indirect_ext)
2604 },
2605 },
2606 VulkanCommand {
2607 name: "vkCmdDrawMeshTasksIndirectNV",
2608 features: smallvec![Feature::Extension(Extension::NVMeshShader)],
2609 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdDrawMeshTasksIndirectNv),
2610 proc: unsafe {
2611 std::mem::transmute::<
2612 vk::PFN_vkCmdDrawMeshTasksIndirectNV,
2613 vk::PFN_vkVoidFunction,
2614 >(Self::cmd_draw_mesh_tasks_indirect_nv)
2615 },
2616 },
2617 VulkanCommand {
2618 name: "vkCmdDrawMeshTasksNV",
2619 features: smallvec![Feature::Extension(Extension::NVMeshShader)],
2620 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdDrawMeshTasksNv),
2621 proc: unsafe {
2622 std::mem::transmute::<vk::PFN_vkCmdDrawMeshTasksNV, vk::PFN_vkVoidFunction>(
2623 Self::cmd_draw_mesh_tasks_nv,
2624 )
2625 },
2626 },
2627 VulkanCommand {
2628 name: "vkCmdDrawMultiEXT",
2629 features: smallvec![Feature::Extension(Extension::EXTMultiDraw)],
2630 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdDrawMultiExt),
2631 proc: unsafe {
2632 std::mem::transmute::<vk::PFN_vkCmdDrawMultiEXT, vk::PFN_vkVoidFunction>(
2633 Self::cmd_draw_multi_ext,
2634 )
2635 },
2636 },
2637 VulkanCommand {
2638 name: "vkCmdDrawMultiIndexedEXT",
2639 features: smallvec![Feature::Extension(Extension::EXTMultiDraw)],
2640 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdDrawMultiIndexedExt),
2641 proc: unsafe {
2642 std::mem::transmute::<vk::PFN_vkCmdDrawMultiIndexedEXT, vk::PFN_vkVoidFunction>(
2643 Self::cmd_draw_multi_indexed_ext,
2644 )
2645 },
2646 },
2647 VulkanCommand {
2648 name: "vkCmdEncodeVideoKHR",
2649 features: smallvec![Feature::Extension(Extension::KHRVideoEncodeQueue)],
2650 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdEncodeVideoKhr),
2651 proc: unsafe {
2652 std::mem::transmute::<vk::PFN_vkCmdEncodeVideoKHR, vk::PFN_vkVoidFunction>(
2653 Self::cmd_encode_video_khr,
2654 )
2655 },
2656 },
2657 VulkanCommand {
2658 name: "vkCmdEndConditionalRenderingEXT",
2659 features: smallvec![Feature::Extension(Extension::EXTConditionalRendering)],
2660 hooked: hooked_commands
2661 .contains(&LayerVulkanCommand::CmdEndConditionalRenderingExt),
2662 proc: unsafe {
2663 std::mem::transmute::<
2664 vk::PFN_vkCmdEndConditionalRenderingEXT,
2665 vk::PFN_vkVoidFunction,
2666 >(Self::cmd_end_conditional_rendering_ext)
2667 },
2668 },
2669 VulkanCommand {
2670 name: "vkCmdEndDebugUtilsLabelEXT",
2671 features: smallvec![Feature::Extension(Extension::EXTDebugUtils)],
2672 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdEndDebugUtilsLabelExt),
2673 proc: unsafe {
2674 std::mem::transmute::<vk::PFN_vkCmdEndDebugUtilsLabelEXT, vk::PFN_vkVoidFunction>(
2675 Self::cmd_end_debug_utils_label_ext,
2676 )
2677 },
2678 },
2679 VulkanCommand {
2680 name: "vkCmdEndQuery",
2681 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
2682 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdEndQuery),
2683 proc: unsafe {
2684 std::mem::transmute::<vk::PFN_vkCmdEndQuery, vk::PFN_vkVoidFunction>(
2685 Self::cmd_end_query,
2686 )
2687 },
2688 },
2689 VulkanCommand {
2690 name: "vkCmdEndQueryIndexedEXT",
2691 features: smallvec![Feature::Extension(Extension::EXTTransformFeedback)],
2692 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdEndQueryIndexedExt),
2693 proc: unsafe {
2694 std::mem::transmute::<vk::PFN_vkCmdEndQueryIndexedEXT, vk::PFN_vkVoidFunction>(
2695 Self::cmd_end_query_indexed_ext,
2696 )
2697 },
2698 },
2699 VulkanCommand {
2700 name: "vkCmdEndRenderPass",
2701 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
2702 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdEndRenderPass),
2703 proc: unsafe {
2704 std::mem::transmute::<vk::PFN_vkCmdEndRenderPass, vk::PFN_vkVoidFunction>(
2705 Self::cmd_end_render_pass,
2706 )
2707 },
2708 },
2709 VulkanCommand {
2710 name: "vkCmdEndRenderPass2",
2711 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 2 })],
2712 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdEndRenderPass2),
2713 proc: unsafe {
2714 std::mem::transmute::<vk::PFN_vkCmdEndRenderPass2, vk::PFN_vkVoidFunction>(
2715 Self::cmd_end_render_pass2,
2716 )
2717 },
2718 },
2719 VulkanCommand {
2720 name: "vkCmdEndRenderPass2KHR",
2721 features: smallvec![Feature::Extension(Extension::KHRCreateRenderpass2)],
2722 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdEndRenderPass2),
2723 proc: unsafe {
2724 std::mem::transmute::<vk::PFN_vkCmdEndRenderPass2, vk::PFN_vkVoidFunction>(
2725 Self::cmd_end_render_pass2,
2726 )
2727 },
2728 },
2729 VulkanCommand {
2730 name: "vkCmdEndRendering",
2731 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 3 })],
2732 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdEndRendering),
2733 proc: unsafe {
2734 std::mem::transmute::<vk::PFN_vkCmdEndRendering, vk::PFN_vkVoidFunction>(
2735 Self::cmd_end_rendering,
2736 )
2737 },
2738 },
2739 VulkanCommand {
2740 name: "vkCmdEndRenderingKHR",
2741 features: smallvec![Feature::Extension(Extension::KHRDynamicRendering)],
2742 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdEndRendering),
2743 proc: unsafe {
2744 std::mem::transmute::<vk::PFN_vkCmdEndRendering, vk::PFN_vkVoidFunction>(
2745 Self::cmd_end_rendering,
2746 )
2747 },
2748 },
2749 VulkanCommand {
2750 name: "vkCmdEndTransformFeedbackEXT",
2751 features: smallvec![Feature::Extension(Extension::EXTTransformFeedback)],
2752 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdEndTransformFeedbackExt),
2753 proc: unsafe {
2754 std::mem::transmute::<
2755 vk::PFN_vkCmdEndTransformFeedbackEXT,
2756 vk::PFN_vkVoidFunction,
2757 >(Self::cmd_end_transform_feedback_ext)
2758 },
2759 },
2760 VulkanCommand {
2761 name: "vkCmdEndVideoCodingKHR",
2762 features: smallvec![Feature::Extension(Extension::KHRVideoQueue)],
2763 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdEndVideoCodingKhr),
2764 proc: unsafe {
2765 std::mem::transmute::<vk::PFN_vkCmdEndVideoCodingKHR, vk::PFN_vkVoidFunction>(
2766 Self::cmd_end_video_coding_khr,
2767 )
2768 },
2769 },
2770 VulkanCommand {
2771 name: "vkCmdExecuteCommands",
2772 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
2773 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdExecuteCommands),
2774 proc: unsafe {
2775 std::mem::transmute::<vk::PFN_vkCmdExecuteCommands, vk::PFN_vkVoidFunction>(
2776 Self::cmd_execute_commands,
2777 )
2778 },
2779 },
2780 VulkanCommand {
2781 name: "vkCmdExecuteGeneratedCommandsNV",
2782 features: smallvec![Feature::Extension(Extension::NVDeviceGeneratedCommands)],
2783 hooked: hooked_commands
2784 .contains(&LayerVulkanCommand::CmdExecuteGeneratedCommandsNv),
2785 proc: unsafe {
2786 std::mem::transmute::<
2787 vk::PFN_vkCmdExecuteGeneratedCommandsNV,
2788 vk::PFN_vkVoidFunction,
2789 >(Self::cmd_execute_generated_commands_nv)
2790 },
2791 },
2792 VulkanCommand {
2793 name: "vkCmdFillBuffer",
2794 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
2795 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdFillBuffer),
2796 proc: unsafe {
2797 std::mem::transmute::<vk::PFN_vkCmdFillBuffer, vk::PFN_vkVoidFunction>(
2798 Self::cmd_fill_buffer,
2799 )
2800 },
2801 },
2802 VulkanCommand {
2803 name: "vkCmdInsertDebugUtilsLabelEXT",
2804 features: smallvec![Feature::Extension(Extension::EXTDebugUtils)],
2805 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdInsertDebugUtilsLabelExt),
2806 proc: unsafe {
2807 std::mem::transmute::<
2808 vk::PFN_vkCmdInsertDebugUtilsLabelEXT,
2809 vk::PFN_vkVoidFunction,
2810 >(Self::cmd_insert_debug_utils_label_ext)
2811 },
2812 },
2813 VulkanCommand {
2814 name: "vkCmdNextSubpass",
2815 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
2816 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdNextSubpass),
2817 proc: unsafe {
2818 std::mem::transmute::<vk::PFN_vkCmdNextSubpass, vk::PFN_vkVoidFunction>(
2819 Self::cmd_next_subpass,
2820 )
2821 },
2822 },
2823 VulkanCommand {
2824 name: "vkCmdNextSubpass2",
2825 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 2 })],
2826 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdNextSubpass2),
2827 proc: unsafe {
2828 std::mem::transmute::<vk::PFN_vkCmdNextSubpass2, vk::PFN_vkVoidFunction>(
2829 Self::cmd_next_subpass2,
2830 )
2831 },
2832 },
2833 VulkanCommand {
2834 name: "vkCmdNextSubpass2KHR",
2835 features: smallvec![Feature::Extension(Extension::KHRCreateRenderpass2)],
2836 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdNextSubpass2),
2837 proc: unsafe {
2838 std::mem::transmute::<vk::PFN_vkCmdNextSubpass2, vk::PFN_vkVoidFunction>(
2839 Self::cmd_next_subpass2,
2840 )
2841 },
2842 },
2843 VulkanCommand {
2844 name: "vkCmdOpticalFlowExecuteNV",
2845 features: smallvec![Feature::Extension(Extension::NVOpticalFlow)],
2846 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdOpticalFlowExecuteNv),
2847 proc: unsafe {
2848 std::mem::transmute::<vk::PFN_vkCmdOpticalFlowExecuteNV, vk::PFN_vkVoidFunction>(
2849 Self::cmd_optical_flow_execute_nv,
2850 )
2851 },
2852 },
2853 VulkanCommand {
2854 name: "vkCmdPipelineBarrier",
2855 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
2856 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdPipelineBarrier),
2857 proc: unsafe {
2858 std::mem::transmute::<vk::PFN_vkCmdPipelineBarrier, vk::PFN_vkVoidFunction>(
2859 Self::cmd_pipeline_barrier,
2860 )
2861 },
2862 },
2863 VulkanCommand {
2864 name: "vkCmdPipelineBarrier2",
2865 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 3 })],
2866 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdPipelineBarrier2),
2867 proc: unsafe {
2868 std::mem::transmute::<vk::PFN_vkCmdPipelineBarrier2, vk::PFN_vkVoidFunction>(
2869 Self::cmd_pipeline_barrier2,
2870 )
2871 },
2872 },
2873 VulkanCommand {
2874 name: "vkCmdPipelineBarrier2KHR",
2875 features: smallvec![Feature::Extension(Extension::KHRSynchronization2)],
2876 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdPipelineBarrier2),
2877 proc: unsafe {
2878 std::mem::transmute::<vk::PFN_vkCmdPipelineBarrier2, vk::PFN_vkVoidFunction>(
2879 Self::cmd_pipeline_barrier2,
2880 )
2881 },
2882 },
2883 VulkanCommand {
2884 name: "vkCmdPreprocessGeneratedCommandsNV",
2885 features: smallvec![Feature::Extension(Extension::NVDeviceGeneratedCommands)],
2886 hooked: hooked_commands
2887 .contains(&LayerVulkanCommand::CmdPreprocessGeneratedCommandsNv),
2888 proc: unsafe {
2889 std::mem::transmute::<
2890 vk::PFN_vkCmdPreprocessGeneratedCommandsNV,
2891 vk::PFN_vkVoidFunction,
2892 >(Self::cmd_preprocess_generated_commands_nv)
2893 },
2894 },
2895 VulkanCommand {
2896 name: "vkCmdPushConstants",
2897 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
2898 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdPushConstants),
2899 proc: unsafe {
2900 std::mem::transmute::<vk::PFN_vkCmdPushConstants, vk::PFN_vkVoidFunction>(
2901 Self::cmd_push_constants,
2902 )
2903 },
2904 },
2905 VulkanCommand {
2906 name: "vkCmdPushDescriptorSetKHR",
2907 features: smallvec![Feature::Extension(Extension::KHRPushDescriptor)],
2908 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdPushDescriptorSetKhr),
2909 proc: unsafe {
2910 std::mem::transmute::<vk::PFN_vkCmdPushDescriptorSetKHR, vk::PFN_vkVoidFunction>(
2911 Self::cmd_push_descriptor_set_khr,
2912 )
2913 },
2914 },
2915 VulkanCommand {
2916 name: "vkCmdPushDescriptorSetWithTemplateKHR",
2917 features: smallvec![
2918 Feature::Extension(Extension::KHRPushDescriptor),
2919 Feature::Extension(Extension::KHRDescriptorUpdateTemplate)
2920 ],
2921 hooked: hooked_commands
2922 .contains(&LayerVulkanCommand::CmdPushDescriptorSetWithTemplateKhr),
2923 proc: unsafe {
2924 std::mem::transmute::<
2925 vk::PFN_vkCmdPushDescriptorSetWithTemplateKHR,
2926 vk::PFN_vkVoidFunction,
2927 >(Self::cmd_push_descriptor_set_with_template_khr)
2928 },
2929 },
2930 VulkanCommand {
2931 name: "vkCmdResetEvent",
2932 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
2933 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdResetEvent),
2934 proc: unsafe {
2935 std::mem::transmute::<vk::PFN_vkCmdResetEvent, vk::PFN_vkVoidFunction>(
2936 Self::cmd_reset_event,
2937 )
2938 },
2939 },
2940 VulkanCommand {
2941 name: "vkCmdResetEvent2",
2942 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 3 })],
2943 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdResetEvent2),
2944 proc: unsafe {
2945 std::mem::transmute::<vk::PFN_vkCmdResetEvent2, vk::PFN_vkVoidFunction>(
2946 Self::cmd_reset_event2,
2947 )
2948 },
2949 },
2950 VulkanCommand {
2951 name: "vkCmdResetEvent2KHR",
2952 features: smallvec![Feature::Extension(Extension::KHRSynchronization2)],
2953 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdResetEvent2),
2954 proc: unsafe {
2955 std::mem::transmute::<vk::PFN_vkCmdResetEvent2, vk::PFN_vkVoidFunction>(
2956 Self::cmd_reset_event2,
2957 )
2958 },
2959 },
2960 VulkanCommand {
2961 name: "vkCmdResetQueryPool",
2962 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
2963 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdResetQueryPool),
2964 proc: unsafe {
2965 std::mem::transmute::<vk::PFN_vkCmdResetQueryPool, vk::PFN_vkVoidFunction>(
2966 Self::cmd_reset_query_pool,
2967 )
2968 },
2969 },
2970 VulkanCommand {
2971 name: "vkCmdResolveImage",
2972 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
2973 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdResolveImage),
2974 proc: unsafe {
2975 std::mem::transmute::<vk::PFN_vkCmdResolveImage, vk::PFN_vkVoidFunction>(
2976 Self::cmd_resolve_image,
2977 )
2978 },
2979 },
2980 VulkanCommand {
2981 name: "vkCmdResolveImage2",
2982 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 3 })],
2983 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdResolveImage2),
2984 proc: unsafe {
2985 std::mem::transmute::<vk::PFN_vkCmdResolveImage2, vk::PFN_vkVoidFunction>(
2986 Self::cmd_resolve_image2,
2987 )
2988 },
2989 },
2990 VulkanCommand {
2991 name: "vkCmdResolveImage2KHR",
2992 features: smallvec![Feature::Extension(Extension::KHRCopyCommands2)],
2993 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdResolveImage2),
2994 proc: unsafe {
2995 std::mem::transmute::<vk::PFN_vkCmdResolveImage2, vk::PFN_vkVoidFunction>(
2996 Self::cmd_resolve_image2,
2997 )
2998 },
2999 },
3000 VulkanCommand {
3001 name: "vkCmdSetAlphaToCoverageEnableEXT",
3002 features: smallvec![
3003 Feature::Extension(Extension::EXTExtendedDynamicState3),
3004 Feature::Extension(Extension::EXTShaderObject)
3005 ],
3006 hooked: hooked_commands
3007 .contains(&LayerVulkanCommand::CmdSetAlphaToCoverageEnableExt),
3008 proc: unsafe {
3009 std::mem::transmute::<
3010 vk::PFN_vkCmdSetAlphaToCoverageEnableEXT,
3011 vk::PFN_vkVoidFunction,
3012 >(Self::cmd_set_alpha_to_coverage_enable_ext)
3013 },
3014 },
3015 VulkanCommand {
3016 name: "vkCmdSetAlphaToOneEnableEXT",
3017 features: smallvec![
3018 Feature::Extension(Extension::EXTExtendedDynamicState3),
3019 Feature::Extension(Extension::EXTShaderObject)
3020 ],
3021 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetAlphaToOneEnableExt),
3022 proc: unsafe {
3023 std::mem::transmute::<vk::PFN_vkCmdSetAlphaToOneEnableEXT, vk::PFN_vkVoidFunction>(
3024 Self::cmd_set_alpha_to_one_enable_ext,
3025 )
3026 },
3027 },
3028 VulkanCommand {
3029 name: "vkCmdSetBlendConstants",
3030 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
3031 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetBlendConstants),
3032 proc: unsafe {
3033 std::mem::transmute::<vk::PFN_vkCmdSetBlendConstants, vk::PFN_vkVoidFunction>(
3034 Self::cmd_set_blend_constants,
3035 )
3036 },
3037 },
3038 VulkanCommand {
3039 name: "vkCmdSetCheckpointNV",
3040 features: smallvec![Feature::Extension(Extension::NVDeviceDiagnosticCheckpoints)],
3041 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetCheckpointNv),
3042 proc: unsafe {
3043 std::mem::transmute::<vk::PFN_vkCmdSetCheckpointNV, vk::PFN_vkVoidFunction>(
3044 Self::cmd_set_checkpoint_nv,
3045 )
3046 },
3047 },
3048 VulkanCommand {
3049 name: "vkCmdSetCoarseSampleOrderNV",
3050 features: smallvec![Feature::Extension(Extension::NVShadingRateImage)],
3051 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetCoarseSampleOrderNv),
3052 proc: unsafe {
3053 std::mem::transmute::<vk::PFN_vkCmdSetCoarseSampleOrderNV, vk::PFN_vkVoidFunction>(
3054 Self::cmd_set_coarse_sample_order_nv,
3055 )
3056 },
3057 },
3058 VulkanCommand {
3059 name: "vkCmdSetColorBlendAdvancedEXT",
3060 features: smallvec![
3061 Feature::Extension(Extension::EXTExtendedDynamicState3),
3062 Feature::Extension(Extension::EXTShaderObject)
3063 ],
3064 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetColorBlendAdvancedExt),
3065 proc: unsafe {
3066 std::mem::transmute::<
3067 vk::PFN_vkCmdSetColorBlendAdvancedEXT,
3068 vk::PFN_vkVoidFunction,
3069 >(Self::cmd_set_color_blend_advanced_ext)
3070 },
3071 },
3072 VulkanCommand {
3073 name: "vkCmdSetColorBlendEnableEXT",
3074 features: smallvec![
3075 Feature::Extension(Extension::EXTExtendedDynamicState3),
3076 Feature::Extension(Extension::EXTShaderObject)
3077 ],
3078 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetColorBlendEnableExt),
3079 proc: unsafe {
3080 std::mem::transmute::<vk::PFN_vkCmdSetColorBlendEnableEXT, vk::PFN_vkVoidFunction>(
3081 Self::cmd_set_color_blend_enable_ext,
3082 )
3083 },
3084 },
3085 VulkanCommand {
3086 name: "vkCmdSetColorBlendEquationEXT",
3087 features: smallvec![
3088 Feature::Extension(Extension::EXTExtendedDynamicState3),
3089 Feature::Extension(Extension::EXTShaderObject)
3090 ],
3091 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetColorBlendEquationExt),
3092 proc: unsafe {
3093 std::mem::transmute::<
3094 vk::PFN_vkCmdSetColorBlendEquationEXT,
3095 vk::PFN_vkVoidFunction,
3096 >(Self::cmd_set_color_blend_equation_ext)
3097 },
3098 },
3099 VulkanCommand {
3100 name: "vkCmdSetColorWriteEnableEXT",
3101 features: smallvec![Feature::Extension(Extension::EXTColorWriteEnable)],
3102 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetColorWriteEnableExt),
3103 proc: unsafe {
3104 std::mem::transmute::<vk::PFN_vkCmdSetColorWriteEnableEXT, vk::PFN_vkVoidFunction>(
3105 Self::cmd_set_color_write_enable_ext,
3106 )
3107 },
3108 },
3109 VulkanCommand {
3110 name: "vkCmdSetColorWriteMaskEXT",
3111 features: smallvec![
3112 Feature::Extension(Extension::EXTExtendedDynamicState3),
3113 Feature::Extension(Extension::EXTShaderObject)
3114 ],
3115 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetColorWriteMaskExt),
3116 proc: unsafe {
3117 std::mem::transmute::<vk::PFN_vkCmdSetColorWriteMaskEXT, vk::PFN_vkVoidFunction>(
3118 Self::cmd_set_color_write_mask_ext,
3119 )
3120 },
3121 },
3122 VulkanCommand {
3123 name: "vkCmdSetConservativeRasterizationModeEXT",
3124 features: smallvec![
3125 Feature::Extension(Extension::EXTExtendedDynamicState3),
3126 Feature::Extension(Extension::EXTShaderObject)
3127 ],
3128 hooked: hooked_commands
3129 .contains(&LayerVulkanCommand::CmdSetConservativeRasterizationModeExt),
3130 proc: unsafe {
3131 std::mem::transmute::<
3132 vk::PFN_vkCmdSetConservativeRasterizationModeEXT,
3133 vk::PFN_vkVoidFunction,
3134 >(Self::cmd_set_conservative_rasterization_mode_ext)
3135 },
3136 },
3137 VulkanCommand {
3138 name: "vkCmdSetCoverageModulationModeNV",
3139 features: smallvec![
3140 Feature::Extension(Extension::EXTExtendedDynamicState3),
3141 Feature::Extension(Extension::EXTShaderObject)
3142 ],
3143 hooked: hooked_commands
3144 .contains(&LayerVulkanCommand::CmdSetCoverageModulationModeNv),
3145 proc: unsafe {
3146 std::mem::transmute::<
3147 vk::PFN_vkCmdSetCoverageModulationModeNV,
3148 vk::PFN_vkVoidFunction,
3149 >(Self::cmd_set_coverage_modulation_mode_nv)
3150 },
3151 },
3152 VulkanCommand {
3153 name: "vkCmdSetCoverageModulationTableEnableNV",
3154 features: smallvec![
3155 Feature::Extension(Extension::EXTExtendedDynamicState3),
3156 Feature::Extension(Extension::EXTShaderObject)
3157 ],
3158 hooked: hooked_commands
3159 .contains(&LayerVulkanCommand::CmdSetCoverageModulationTableEnableNv),
3160 proc: unsafe {
3161 std::mem::transmute::<
3162 vk::PFN_vkCmdSetCoverageModulationTableEnableNV,
3163 vk::PFN_vkVoidFunction,
3164 >(Self::cmd_set_coverage_modulation_table_enable_nv)
3165 },
3166 },
3167 VulkanCommand {
3168 name: "vkCmdSetCoverageModulationTableNV",
3169 features: smallvec![
3170 Feature::Extension(Extension::EXTExtendedDynamicState3),
3171 Feature::Extension(Extension::EXTShaderObject)
3172 ],
3173 hooked: hooked_commands
3174 .contains(&LayerVulkanCommand::CmdSetCoverageModulationTableNv),
3175 proc: unsafe {
3176 std::mem::transmute::<
3177 vk::PFN_vkCmdSetCoverageModulationTableNV,
3178 vk::PFN_vkVoidFunction,
3179 >(Self::cmd_set_coverage_modulation_table_nv)
3180 },
3181 },
3182 VulkanCommand {
3183 name: "vkCmdSetCoverageReductionModeNV",
3184 features: smallvec![
3185 Feature::Extension(Extension::EXTExtendedDynamicState3),
3186 Feature::Extension(Extension::EXTShaderObject)
3187 ],
3188 hooked: hooked_commands
3189 .contains(&LayerVulkanCommand::CmdSetCoverageReductionModeNv),
3190 proc: unsafe {
3191 std::mem::transmute::<
3192 vk::PFN_vkCmdSetCoverageReductionModeNV,
3193 vk::PFN_vkVoidFunction,
3194 >(Self::cmd_set_coverage_reduction_mode_nv)
3195 },
3196 },
3197 VulkanCommand {
3198 name: "vkCmdSetCoverageToColorEnableNV",
3199 features: smallvec![
3200 Feature::Extension(Extension::EXTExtendedDynamicState3),
3201 Feature::Extension(Extension::EXTShaderObject)
3202 ],
3203 hooked: hooked_commands
3204 .contains(&LayerVulkanCommand::CmdSetCoverageToColorEnableNv),
3205 proc: unsafe {
3206 std::mem::transmute::<
3207 vk::PFN_vkCmdSetCoverageToColorEnableNV,
3208 vk::PFN_vkVoidFunction,
3209 >(Self::cmd_set_coverage_to_color_enable_nv)
3210 },
3211 },
3212 VulkanCommand {
3213 name: "vkCmdSetCoverageToColorLocationNV",
3214 features: smallvec![
3215 Feature::Extension(Extension::EXTExtendedDynamicState3),
3216 Feature::Extension(Extension::EXTShaderObject)
3217 ],
3218 hooked: hooked_commands
3219 .contains(&LayerVulkanCommand::CmdSetCoverageToColorLocationNv),
3220 proc: unsafe {
3221 std::mem::transmute::<
3222 vk::PFN_vkCmdSetCoverageToColorLocationNV,
3223 vk::PFN_vkVoidFunction,
3224 >(Self::cmd_set_coverage_to_color_location_nv)
3225 },
3226 },
3227 VulkanCommand {
3228 name: "vkCmdSetCullMode",
3229 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 3 })],
3230 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetCullMode),
3231 proc: unsafe {
3232 std::mem::transmute::<vk::PFN_vkCmdSetCullMode, vk::PFN_vkVoidFunction>(
3233 Self::cmd_set_cull_mode,
3234 )
3235 },
3236 },
3237 VulkanCommand {
3238 name: "vkCmdSetCullModeEXT",
3239 features: smallvec![
3240 Feature::Extension(Extension::EXTExtendedDynamicState),
3241 Feature::Extension(Extension::EXTShaderObject)
3242 ],
3243 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetCullMode),
3244 proc: unsafe {
3245 std::mem::transmute::<vk::PFN_vkCmdSetCullMode, vk::PFN_vkVoidFunction>(
3246 Self::cmd_set_cull_mode,
3247 )
3248 },
3249 },
3250 VulkanCommand {
3251 name: "vkCmdSetDepthBias",
3252 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
3253 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetDepthBias),
3254 proc: unsafe {
3255 std::mem::transmute::<vk::PFN_vkCmdSetDepthBias, vk::PFN_vkVoidFunction>(
3256 Self::cmd_set_depth_bias,
3257 )
3258 },
3259 },
3260 VulkanCommand {
3261 name: "vkCmdSetDepthBiasEnable",
3262 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 3 })],
3263 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetDepthBiasEnable),
3264 proc: unsafe {
3265 std::mem::transmute::<vk::PFN_vkCmdSetDepthBiasEnable, vk::PFN_vkVoidFunction>(
3266 Self::cmd_set_depth_bias_enable,
3267 )
3268 },
3269 },
3270 VulkanCommand {
3271 name: "vkCmdSetDepthBiasEnableEXT",
3272 features: smallvec![
3273 Feature::Extension(Extension::EXTExtendedDynamicState2),
3274 Feature::Extension(Extension::EXTShaderObject)
3275 ],
3276 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetDepthBiasEnable),
3277 proc: unsafe {
3278 std::mem::transmute::<vk::PFN_vkCmdSetDepthBiasEnable, vk::PFN_vkVoidFunction>(
3279 Self::cmd_set_depth_bias_enable,
3280 )
3281 },
3282 },
3283 VulkanCommand {
3284 name: "vkCmdSetDepthBounds",
3285 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
3286 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetDepthBounds),
3287 proc: unsafe {
3288 std::mem::transmute::<vk::PFN_vkCmdSetDepthBounds, vk::PFN_vkVoidFunction>(
3289 Self::cmd_set_depth_bounds,
3290 )
3291 },
3292 },
3293 VulkanCommand {
3294 name: "vkCmdSetDepthBoundsTestEnable",
3295 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 3 })],
3296 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetDepthBoundsTestEnable),
3297 proc: unsafe {
3298 std::mem::transmute::<
3299 vk::PFN_vkCmdSetDepthBoundsTestEnable,
3300 vk::PFN_vkVoidFunction,
3301 >(Self::cmd_set_depth_bounds_test_enable)
3302 },
3303 },
3304 VulkanCommand {
3305 name: "vkCmdSetDepthBoundsTestEnableEXT",
3306 features: smallvec![
3307 Feature::Extension(Extension::EXTExtendedDynamicState),
3308 Feature::Extension(Extension::EXTShaderObject)
3309 ],
3310 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetDepthBoundsTestEnable),
3311 proc: unsafe {
3312 std::mem::transmute::<
3313 vk::PFN_vkCmdSetDepthBoundsTestEnable,
3314 vk::PFN_vkVoidFunction,
3315 >(Self::cmd_set_depth_bounds_test_enable)
3316 },
3317 },
3318 VulkanCommand {
3319 name: "vkCmdSetDepthClampEnableEXT",
3320 features: smallvec![
3321 Feature::Extension(Extension::EXTExtendedDynamicState3),
3322 Feature::Extension(Extension::EXTShaderObject)
3323 ],
3324 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetDepthClampEnableExt),
3325 proc: unsafe {
3326 std::mem::transmute::<vk::PFN_vkCmdSetDepthClampEnableEXT, vk::PFN_vkVoidFunction>(
3327 Self::cmd_set_depth_clamp_enable_ext,
3328 )
3329 },
3330 },
3331 VulkanCommand {
3332 name: "vkCmdSetDepthClipEnableEXT",
3333 features: smallvec![
3334 Feature::Extension(Extension::EXTExtendedDynamicState3),
3335 Feature::Extension(Extension::EXTShaderObject)
3336 ],
3337 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetDepthClipEnableExt),
3338 proc: unsafe {
3339 std::mem::transmute::<vk::PFN_vkCmdSetDepthClipEnableEXT, vk::PFN_vkVoidFunction>(
3340 Self::cmd_set_depth_clip_enable_ext,
3341 )
3342 },
3343 },
3344 VulkanCommand {
3345 name: "vkCmdSetDepthClipNegativeOneToOneEXT",
3346 features: smallvec![
3347 Feature::Extension(Extension::EXTExtendedDynamicState3),
3348 Feature::Extension(Extension::EXTShaderObject)
3349 ],
3350 hooked: hooked_commands
3351 .contains(&LayerVulkanCommand::CmdSetDepthClipNegativeOneToOneExt),
3352 proc: unsafe {
3353 std::mem::transmute::<
3354 vk::PFN_vkCmdSetDepthClipNegativeOneToOneEXT,
3355 vk::PFN_vkVoidFunction,
3356 >(Self::cmd_set_depth_clip_negative_one_to_one_ext)
3357 },
3358 },
3359 VulkanCommand {
3360 name: "vkCmdSetDepthCompareOp",
3361 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 3 })],
3362 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetDepthCompareOp),
3363 proc: unsafe {
3364 std::mem::transmute::<vk::PFN_vkCmdSetDepthCompareOp, vk::PFN_vkVoidFunction>(
3365 Self::cmd_set_depth_compare_op,
3366 )
3367 },
3368 },
3369 VulkanCommand {
3370 name: "vkCmdSetDepthCompareOpEXT",
3371 features: smallvec![
3372 Feature::Extension(Extension::EXTExtendedDynamicState),
3373 Feature::Extension(Extension::EXTShaderObject)
3374 ],
3375 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetDepthCompareOp),
3376 proc: unsafe {
3377 std::mem::transmute::<vk::PFN_vkCmdSetDepthCompareOp, vk::PFN_vkVoidFunction>(
3378 Self::cmd_set_depth_compare_op,
3379 )
3380 },
3381 },
3382 VulkanCommand {
3383 name: "vkCmdSetDepthTestEnable",
3384 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 3 })],
3385 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetDepthTestEnable),
3386 proc: unsafe {
3387 std::mem::transmute::<vk::PFN_vkCmdSetDepthTestEnable, vk::PFN_vkVoidFunction>(
3388 Self::cmd_set_depth_test_enable,
3389 )
3390 },
3391 },
3392 VulkanCommand {
3393 name: "vkCmdSetDepthTestEnableEXT",
3394 features: smallvec![
3395 Feature::Extension(Extension::EXTExtendedDynamicState),
3396 Feature::Extension(Extension::EXTShaderObject)
3397 ],
3398 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetDepthTestEnable),
3399 proc: unsafe {
3400 std::mem::transmute::<vk::PFN_vkCmdSetDepthTestEnable, vk::PFN_vkVoidFunction>(
3401 Self::cmd_set_depth_test_enable,
3402 )
3403 },
3404 },
3405 VulkanCommand {
3406 name: "vkCmdSetDepthWriteEnable",
3407 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 3 })],
3408 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetDepthWriteEnable),
3409 proc: unsafe {
3410 std::mem::transmute::<vk::PFN_vkCmdSetDepthWriteEnable, vk::PFN_vkVoidFunction>(
3411 Self::cmd_set_depth_write_enable,
3412 )
3413 },
3414 },
3415 VulkanCommand {
3416 name: "vkCmdSetDepthWriteEnableEXT",
3417 features: smallvec![
3418 Feature::Extension(Extension::EXTExtendedDynamicState),
3419 Feature::Extension(Extension::EXTShaderObject)
3420 ],
3421 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetDepthWriteEnable),
3422 proc: unsafe {
3423 std::mem::transmute::<vk::PFN_vkCmdSetDepthWriteEnable, vk::PFN_vkVoidFunction>(
3424 Self::cmd_set_depth_write_enable,
3425 )
3426 },
3427 },
3428 VulkanCommand {
3429 name: "vkCmdSetDescriptorBufferOffsetsEXT",
3430 features: smallvec![Feature::Extension(Extension::EXTDescriptorBuffer)],
3431 hooked: hooked_commands
3432 .contains(&LayerVulkanCommand::CmdSetDescriptorBufferOffsetsExt),
3433 proc: unsafe {
3434 std::mem::transmute::<
3435 vk::PFN_vkCmdSetDescriptorBufferOffsetsEXT,
3436 vk::PFN_vkVoidFunction,
3437 >(Self::cmd_set_descriptor_buffer_offsets_ext)
3438 },
3439 },
3440 VulkanCommand {
3441 name: "vkCmdSetDeviceMask",
3442 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 1 })],
3443 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetDeviceMask),
3444 proc: unsafe {
3445 std::mem::transmute::<vk::PFN_vkCmdSetDeviceMask, vk::PFN_vkVoidFunction>(
3446 Self::cmd_set_device_mask,
3447 )
3448 },
3449 },
3450 VulkanCommand {
3451 name: "vkCmdSetDeviceMaskKHR",
3452 features: smallvec![Feature::Extension(Extension::KHRDeviceGroup)],
3453 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetDeviceMask),
3454 proc: unsafe {
3455 std::mem::transmute::<vk::PFN_vkCmdSetDeviceMask, vk::PFN_vkVoidFunction>(
3456 Self::cmd_set_device_mask,
3457 )
3458 },
3459 },
3460 VulkanCommand {
3461 name: "vkCmdSetDiscardRectangleEXT",
3462 features: smallvec![Feature::Extension(Extension::EXTDiscardRectangles)],
3463 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetDiscardRectangleExt),
3464 proc: unsafe {
3465 std::mem::transmute::<vk::PFN_vkCmdSetDiscardRectangleEXT, vk::PFN_vkVoidFunction>(
3466 Self::cmd_set_discard_rectangle_ext,
3467 )
3468 },
3469 },
3470 VulkanCommand {
3471 name: "vkCmdSetEvent",
3472 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
3473 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetEvent),
3474 proc: unsafe {
3475 std::mem::transmute::<vk::PFN_vkCmdSetEvent, vk::PFN_vkVoidFunction>(
3476 Self::cmd_set_event,
3477 )
3478 },
3479 },
3480 VulkanCommand {
3481 name: "vkCmdSetEvent2",
3482 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 3 })],
3483 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetEvent2),
3484 proc: unsafe {
3485 std::mem::transmute::<vk::PFN_vkCmdSetEvent2, vk::PFN_vkVoidFunction>(
3486 Self::cmd_set_event2,
3487 )
3488 },
3489 },
3490 VulkanCommand {
3491 name: "vkCmdSetEvent2KHR",
3492 features: smallvec![Feature::Extension(Extension::KHRSynchronization2)],
3493 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetEvent2),
3494 proc: unsafe {
3495 std::mem::transmute::<vk::PFN_vkCmdSetEvent2, vk::PFN_vkVoidFunction>(
3496 Self::cmd_set_event2,
3497 )
3498 },
3499 },
3500 VulkanCommand {
3501 name: "vkCmdSetExclusiveScissorNV",
3502 features: smallvec![Feature::Extension(Extension::NVScissorExclusive)],
3503 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetExclusiveScissorNv),
3504 proc: unsafe {
3505 std::mem::transmute::<vk::PFN_vkCmdSetExclusiveScissorNV, vk::PFN_vkVoidFunction>(
3506 Self::cmd_set_exclusive_scissor_nv,
3507 )
3508 },
3509 },
3510 VulkanCommand {
3511 name: "vkCmdSetExtraPrimitiveOverestimationSizeEXT",
3512 features: smallvec![
3513 Feature::Extension(Extension::EXTExtendedDynamicState3),
3514 Feature::Extension(Extension::EXTShaderObject)
3515 ],
3516 hooked: hooked_commands
3517 .contains(&LayerVulkanCommand::CmdSetExtraPrimitiveOverestimationSizeExt),
3518 proc: unsafe {
3519 std::mem::transmute::<
3520 vk::PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT,
3521 vk::PFN_vkVoidFunction,
3522 >(Self::cmd_set_extra_primitive_overestimation_size_ext)
3523 },
3524 },
3525 VulkanCommand {
3526 name: "vkCmdSetFragmentShadingRateEnumNV",
3527 features: smallvec![Feature::Extension(Extension::NVFragmentShadingRateEnums)],
3528 hooked: hooked_commands
3529 .contains(&LayerVulkanCommand::CmdSetFragmentShadingRateEnumNv),
3530 proc: unsafe {
3531 std::mem::transmute::<
3532 vk::PFN_vkCmdSetFragmentShadingRateEnumNV,
3533 vk::PFN_vkVoidFunction,
3534 >(Self::cmd_set_fragment_shading_rate_enum_nv)
3535 },
3536 },
3537 VulkanCommand {
3538 name: "vkCmdSetFragmentShadingRateKHR",
3539 features: smallvec![Feature::Extension(Extension::KHRFragmentShadingRate)],
3540 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetFragmentShadingRateKhr),
3541 proc: unsafe {
3542 std::mem::transmute::<
3543 vk::PFN_vkCmdSetFragmentShadingRateKHR,
3544 vk::PFN_vkVoidFunction,
3545 >(Self::cmd_set_fragment_shading_rate_khr)
3546 },
3547 },
3548 VulkanCommand {
3549 name: "vkCmdSetFrontFace",
3550 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 3 })],
3551 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetFrontFace),
3552 proc: unsafe {
3553 std::mem::transmute::<vk::PFN_vkCmdSetFrontFace, vk::PFN_vkVoidFunction>(
3554 Self::cmd_set_front_face,
3555 )
3556 },
3557 },
3558 VulkanCommand {
3559 name: "vkCmdSetFrontFaceEXT",
3560 features: smallvec![
3561 Feature::Extension(Extension::EXTExtendedDynamicState),
3562 Feature::Extension(Extension::EXTShaderObject)
3563 ],
3564 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetFrontFace),
3565 proc: unsafe {
3566 std::mem::transmute::<vk::PFN_vkCmdSetFrontFace, vk::PFN_vkVoidFunction>(
3567 Self::cmd_set_front_face,
3568 )
3569 },
3570 },
3571 VulkanCommand {
3572 name: "vkCmdSetLineRasterizationModeEXT",
3573 features: smallvec![
3574 Feature::Extension(Extension::EXTExtendedDynamicState3),
3575 Feature::Extension(Extension::EXTShaderObject)
3576 ],
3577 hooked: hooked_commands
3578 .contains(&LayerVulkanCommand::CmdSetLineRasterizationModeExt),
3579 proc: unsafe {
3580 std::mem::transmute::<
3581 vk::PFN_vkCmdSetLineRasterizationModeEXT,
3582 vk::PFN_vkVoidFunction,
3583 >(Self::cmd_set_line_rasterization_mode_ext)
3584 },
3585 },
3586 VulkanCommand {
3587 name: "vkCmdSetLineStippleEXT",
3588 features: smallvec![Feature::Extension(Extension::EXTLineRasterization)],
3589 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetLineStippleExt),
3590 proc: unsafe {
3591 std::mem::transmute::<vk::PFN_vkCmdSetLineStippleEXT, vk::PFN_vkVoidFunction>(
3592 Self::cmd_set_line_stipple_ext,
3593 )
3594 },
3595 },
3596 VulkanCommand {
3597 name: "vkCmdSetLineStippleEnableEXT",
3598 features: smallvec![
3599 Feature::Extension(Extension::EXTExtendedDynamicState3),
3600 Feature::Extension(Extension::EXTShaderObject)
3601 ],
3602 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetLineStippleEnableExt),
3603 proc: unsafe {
3604 std::mem::transmute::<
3605 vk::PFN_vkCmdSetLineStippleEnableEXT,
3606 vk::PFN_vkVoidFunction,
3607 >(Self::cmd_set_line_stipple_enable_ext)
3608 },
3609 },
3610 VulkanCommand {
3611 name: "vkCmdSetLineWidth",
3612 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
3613 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetLineWidth),
3614 proc: unsafe {
3615 std::mem::transmute::<vk::PFN_vkCmdSetLineWidth, vk::PFN_vkVoidFunction>(
3616 Self::cmd_set_line_width,
3617 )
3618 },
3619 },
3620 VulkanCommand {
3621 name: "vkCmdSetLogicOpEXT",
3622 features: smallvec![
3623 Feature::Extension(Extension::EXTExtendedDynamicState2),
3624 Feature::Extension(Extension::EXTShaderObject)
3625 ],
3626 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetLogicOpExt),
3627 proc: unsafe {
3628 std::mem::transmute::<vk::PFN_vkCmdSetLogicOpEXT, vk::PFN_vkVoidFunction>(
3629 Self::cmd_set_logic_op_ext,
3630 )
3631 },
3632 },
3633 VulkanCommand {
3634 name: "vkCmdSetLogicOpEnableEXT",
3635 features: smallvec![
3636 Feature::Extension(Extension::EXTExtendedDynamicState3),
3637 Feature::Extension(Extension::EXTShaderObject)
3638 ],
3639 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetLogicOpEnableExt),
3640 proc: unsafe {
3641 std::mem::transmute::<vk::PFN_vkCmdSetLogicOpEnableEXT, vk::PFN_vkVoidFunction>(
3642 Self::cmd_set_logic_op_enable_ext,
3643 )
3644 },
3645 },
3646 VulkanCommand {
3647 name: "vkCmdSetPatchControlPointsEXT",
3648 features: smallvec![
3649 Feature::Extension(Extension::EXTExtendedDynamicState2),
3650 Feature::Extension(Extension::EXTShaderObject)
3651 ],
3652 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetPatchControlPointsExt),
3653 proc: unsafe {
3654 std::mem::transmute::<
3655 vk::PFN_vkCmdSetPatchControlPointsEXT,
3656 vk::PFN_vkVoidFunction,
3657 >(Self::cmd_set_patch_control_points_ext)
3658 },
3659 },
3660 VulkanCommand {
3661 name: "vkCmdSetPerformanceMarkerINTEL",
3662 features: smallvec![Feature::Extension(Extension::INTELPerformanceQuery)],
3663 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetPerformanceMarkerIntel),
3664 proc: unsafe {
3665 std::mem::transmute::<
3666 vk::PFN_vkCmdSetPerformanceMarkerINTEL,
3667 vk::PFN_vkVoidFunction,
3668 >(Self::cmd_set_performance_marker_intel)
3669 },
3670 },
3671 VulkanCommand {
3672 name: "vkCmdSetPerformanceOverrideINTEL",
3673 features: smallvec![Feature::Extension(Extension::INTELPerformanceQuery)],
3674 hooked: hooked_commands
3675 .contains(&LayerVulkanCommand::CmdSetPerformanceOverrideIntel),
3676 proc: unsafe {
3677 std::mem::transmute::<
3678 vk::PFN_vkCmdSetPerformanceOverrideINTEL,
3679 vk::PFN_vkVoidFunction,
3680 >(Self::cmd_set_performance_override_intel)
3681 },
3682 },
3683 VulkanCommand {
3684 name: "vkCmdSetPerformanceStreamMarkerINTEL",
3685 features: smallvec![Feature::Extension(Extension::INTELPerformanceQuery)],
3686 hooked: hooked_commands
3687 .contains(&LayerVulkanCommand::CmdSetPerformanceStreamMarkerIntel),
3688 proc: unsafe {
3689 std::mem::transmute::<
3690 vk::PFN_vkCmdSetPerformanceStreamMarkerINTEL,
3691 vk::PFN_vkVoidFunction,
3692 >(Self::cmd_set_performance_stream_marker_intel)
3693 },
3694 },
3695 VulkanCommand {
3696 name: "vkCmdSetPolygonModeEXT",
3697 features: smallvec![
3698 Feature::Extension(Extension::EXTExtendedDynamicState3),
3699 Feature::Extension(Extension::EXTShaderObject)
3700 ],
3701 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetPolygonModeExt),
3702 proc: unsafe {
3703 std::mem::transmute::<vk::PFN_vkCmdSetPolygonModeEXT, vk::PFN_vkVoidFunction>(
3704 Self::cmd_set_polygon_mode_ext,
3705 )
3706 },
3707 },
3708 VulkanCommand {
3709 name: "vkCmdSetPrimitiveRestartEnable",
3710 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 3 })],
3711 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetPrimitiveRestartEnable),
3712 proc: unsafe {
3713 std::mem::transmute::<
3714 vk::PFN_vkCmdSetPrimitiveRestartEnable,
3715 vk::PFN_vkVoidFunction,
3716 >(Self::cmd_set_primitive_restart_enable)
3717 },
3718 },
3719 VulkanCommand {
3720 name: "vkCmdSetPrimitiveRestartEnableEXT",
3721 features: smallvec![
3722 Feature::Extension(Extension::EXTExtendedDynamicState2),
3723 Feature::Extension(Extension::EXTShaderObject)
3724 ],
3725 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetPrimitiveRestartEnable),
3726 proc: unsafe {
3727 std::mem::transmute::<
3728 vk::PFN_vkCmdSetPrimitiveRestartEnable,
3729 vk::PFN_vkVoidFunction,
3730 >(Self::cmd_set_primitive_restart_enable)
3731 },
3732 },
3733 VulkanCommand {
3734 name: "vkCmdSetPrimitiveTopology",
3735 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 3 })],
3736 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetPrimitiveTopology),
3737 proc: unsafe {
3738 std::mem::transmute::<vk::PFN_vkCmdSetPrimitiveTopology, vk::PFN_vkVoidFunction>(
3739 Self::cmd_set_primitive_topology,
3740 )
3741 },
3742 },
3743 VulkanCommand {
3744 name: "vkCmdSetPrimitiveTopologyEXT",
3745 features: smallvec![
3746 Feature::Extension(Extension::EXTExtendedDynamicState),
3747 Feature::Extension(Extension::EXTShaderObject)
3748 ],
3749 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetPrimitiveTopology),
3750 proc: unsafe {
3751 std::mem::transmute::<vk::PFN_vkCmdSetPrimitiveTopology, vk::PFN_vkVoidFunction>(
3752 Self::cmd_set_primitive_topology,
3753 )
3754 },
3755 },
3756 VulkanCommand {
3757 name: "vkCmdSetProvokingVertexModeEXT",
3758 features: smallvec![
3759 Feature::Extension(Extension::EXTExtendedDynamicState3),
3760 Feature::Extension(Extension::EXTShaderObject)
3761 ],
3762 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetProvokingVertexModeExt),
3763 proc: unsafe {
3764 std::mem::transmute::<
3765 vk::PFN_vkCmdSetProvokingVertexModeEXT,
3766 vk::PFN_vkVoidFunction,
3767 >(Self::cmd_set_provoking_vertex_mode_ext)
3768 },
3769 },
3770 VulkanCommand {
3771 name: "vkCmdSetRasterizationSamplesEXT",
3772 features: smallvec![
3773 Feature::Extension(Extension::EXTExtendedDynamicState3),
3774 Feature::Extension(Extension::EXTShaderObject)
3775 ],
3776 hooked: hooked_commands
3777 .contains(&LayerVulkanCommand::CmdSetRasterizationSamplesExt),
3778 proc: unsafe {
3779 std::mem::transmute::<
3780 vk::PFN_vkCmdSetRasterizationSamplesEXT,
3781 vk::PFN_vkVoidFunction,
3782 >(Self::cmd_set_rasterization_samples_ext)
3783 },
3784 },
3785 VulkanCommand {
3786 name: "vkCmdSetRasterizationStreamEXT",
3787 features: smallvec![
3788 Feature::Extension(Extension::EXTExtendedDynamicState3),
3789 Feature::Extension(Extension::EXTShaderObject)
3790 ],
3791 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetRasterizationStreamExt),
3792 proc: unsafe {
3793 std::mem::transmute::<
3794 vk::PFN_vkCmdSetRasterizationStreamEXT,
3795 vk::PFN_vkVoidFunction,
3796 >(Self::cmd_set_rasterization_stream_ext)
3797 },
3798 },
3799 VulkanCommand {
3800 name: "vkCmdSetRasterizerDiscardEnable",
3801 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 3 })],
3802 hooked: hooked_commands
3803 .contains(&LayerVulkanCommand::CmdSetRasterizerDiscardEnable),
3804 proc: unsafe {
3805 std::mem::transmute::<
3806 vk::PFN_vkCmdSetRasterizerDiscardEnable,
3807 vk::PFN_vkVoidFunction,
3808 >(Self::cmd_set_rasterizer_discard_enable)
3809 },
3810 },
3811 VulkanCommand {
3812 name: "vkCmdSetRasterizerDiscardEnableEXT",
3813 features: smallvec![
3814 Feature::Extension(Extension::EXTExtendedDynamicState2),
3815 Feature::Extension(Extension::EXTShaderObject)
3816 ],
3817 hooked: hooked_commands
3818 .contains(&LayerVulkanCommand::CmdSetRasterizerDiscardEnable),
3819 proc: unsafe {
3820 std::mem::transmute::<
3821 vk::PFN_vkCmdSetRasterizerDiscardEnable,
3822 vk::PFN_vkVoidFunction,
3823 >(Self::cmd_set_rasterizer_discard_enable)
3824 },
3825 },
3826 VulkanCommand {
3827 name: "vkCmdSetRayTracingPipelineStackSizeKHR",
3828 features: smallvec![Feature::Extension(Extension::KHRRayTracingPipeline)],
3829 hooked: hooked_commands
3830 .contains(&LayerVulkanCommand::CmdSetRayTracingPipelineStackSizeKhr),
3831 proc: unsafe {
3832 std::mem::transmute::<
3833 vk::PFN_vkCmdSetRayTracingPipelineStackSizeKHR,
3834 vk::PFN_vkVoidFunction,
3835 >(Self::cmd_set_ray_tracing_pipeline_stack_size_khr)
3836 },
3837 },
3838 VulkanCommand {
3839 name: "vkCmdSetRepresentativeFragmentTestEnableNV",
3840 features: smallvec![
3841 Feature::Extension(Extension::EXTExtendedDynamicState3),
3842 Feature::Extension(Extension::EXTShaderObject)
3843 ],
3844 hooked: hooked_commands
3845 .contains(&LayerVulkanCommand::CmdSetRepresentativeFragmentTestEnableNv),
3846 proc: unsafe {
3847 std::mem::transmute::<
3848 vk::PFN_vkCmdSetRepresentativeFragmentTestEnableNV,
3849 vk::PFN_vkVoidFunction,
3850 >(Self::cmd_set_representative_fragment_test_enable_nv)
3851 },
3852 },
3853 VulkanCommand {
3854 name: "vkCmdSetSampleLocationsEXT",
3855 features: smallvec![Feature::Extension(Extension::EXTSampleLocations)],
3856 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetSampleLocationsExt),
3857 proc: unsafe {
3858 std::mem::transmute::<vk::PFN_vkCmdSetSampleLocationsEXT, vk::PFN_vkVoidFunction>(
3859 Self::cmd_set_sample_locations_ext,
3860 )
3861 },
3862 },
3863 VulkanCommand {
3864 name: "vkCmdSetSampleLocationsEnableEXT",
3865 features: smallvec![
3866 Feature::Extension(Extension::EXTExtendedDynamicState3),
3867 Feature::Extension(Extension::EXTShaderObject)
3868 ],
3869 hooked: hooked_commands
3870 .contains(&LayerVulkanCommand::CmdSetSampleLocationsEnableExt),
3871 proc: unsafe {
3872 std::mem::transmute::<
3873 vk::PFN_vkCmdSetSampleLocationsEnableEXT,
3874 vk::PFN_vkVoidFunction,
3875 >(Self::cmd_set_sample_locations_enable_ext)
3876 },
3877 },
3878 VulkanCommand {
3879 name: "vkCmdSetSampleMaskEXT",
3880 features: smallvec![
3881 Feature::Extension(Extension::EXTExtendedDynamicState3),
3882 Feature::Extension(Extension::EXTShaderObject)
3883 ],
3884 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetSampleMaskExt),
3885 proc: unsafe {
3886 std::mem::transmute::<vk::PFN_vkCmdSetSampleMaskEXT, vk::PFN_vkVoidFunction>(
3887 Self::cmd_set_sample_mask_ext,
3888 )
3889 },
3890 },
3891 VulkanCommand {
3892 name: "vkCmdSetScissor",
3893 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
3894 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetScissor),
3895 proc: unsafe {
3896 std::mem::transmute::<vk::PFN_vkCmdSetScissor, vk::PFN_vkVoidFunction>(
3897 Self::cmd_set_scissor,
3898 )
3899 },
3900 },
3901 VulkanCommand {
3902 name: "vkCmdSetScissorWithCount",
3903 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 3 })],
3904 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetScissorWithCount),
3905 proc: unsafe {
3906 std::mem::transmute::<vk::PFN_vkCmdSetScissorWithCount, vk::PFN_vkVoidFunction>(
3907 Self::cmd_set_scissor_with_count,
3908 )
3909 },
3910 },
3911 VulkanCommand {
3912 name: "vkCmdSetScissorWithCountEXT",
3913 features: smallvec![
3914 Feature::Extension(Extension::EXTExtendedDynamicState),
3915 Feature::Extension(Extension::EXTShaderObject)
3916 ],
3917 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetScissorWithCount),
3918 proc: unsafe {
3919 std::mem::transmute::<vk::PFN_vkCmdSetScissorWithCount, vk::PFN_vkVoidFunction>(
3920 Self::cmd_set_scissor_with_count,
3921 )
3922 },
3923 },
3924 VulkanCommand {
3925 name: "vkCmdSetShadingRateImageEnableNV",
3926 features: smallvec![
3927 Feature::Extension(Extension::EXTExtendedDynamicState3),
3928 Feature::Extension(Extension::EXTShaderObject)
3929 ],
3930 hooked: hooked_commands
3931 .contains(&LayerVulkanCommand::CmdSetShadingRateImageEnableNv),
3932 proc: unsafe {
3933 std::mem::transmute::<
3934 vk::PFN_vkCmdSetShadingRateImageEnableNV,
3935 vk::PFN_vkVoidFunction,
3936 >(Self::cmd_set_shading_rate_image_enable_nv)
3937 },
3938 },
3939 VulkanCommand {
3940 name: "vkCmdSetStencilCompareMask",
3941 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
3942 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetStencilCompareMask),
3943 proc: unsafe {
3944 std::mem::transmute::<vk::PFN_vkCmdSetStencilCompareMask, vk::PFN_vkVoidFunction>(
3945 Self::cmd_set_stencil_compare_mask,
3946 )
3947 },
3948 },
3949 VulkanCommand {
3950 name: "vkCmdSetStencilOp",
3951 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 3 })],
3952 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetStencilOp),
3953 proc: unsafe {
3954 std::mem::transmute::<vk::PFN_vkCmdSetStencilOp, vk::PFN_vkVoidFunction>(
3955 Self::cmd_set_stencil_op,
3956 )
3957 },
3958 },
3959 VulkanCommand {
3960 name: "vkCmdSetStencilOpEXT",
3961 features: smallvec![
3962 Feature::Extension(Extension::EXTExtendedDynamicState),
3963 Feature::Extension(Extension::EXTShaderObject)
3964 ],
3965 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetStencilOp),
3966 proc: unsafe {
3967 std::mem::transmute::<vk::PFN_vkCmdSetStencilOp, vk::PFN_vkVoidFunction>(
3968 Self::cmd_set_stencil_op,
3969 )
3970 },
3971 },
3972 VulkanCommand {
3973 name: "vkCmdSetStencilReference",
3974 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
3975 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetStencilReference),
3976 proc: unsafe {
3977 std::mem::transmute::<vk::PFN_vkCmdSetStencilReference, vk::PFN_vkVoidFunction>(
3978 Self::cmd_set_stencil_reference,
3979 )
3980 },
3981 },
3982 VulkanCommand {
3983 name: "vkCmdSetStencilTestEnable",
3984 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 3 })],
3985 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetStencilTestEnable),
3986 proc: unsafe {
3987 std::mem::transmute::<vk::PFN_vkCmdSetStencilTestEnable, vk::PFN_vkVoidFunction>(
3988 Self::cmd_set_stencil_test_enable,
3989 )
3990 },
3991 },
3992 VulkanCommand {
3993 name: "vkCmdSetStencilTestEnableEXT",
3994 features: smallvec![
3995 Feature::Extension(Extension::EXTExtendedDynamicState),
3996 Feature::Extension(Extension::EXTShaderObject)
3997 ],
3998 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetStencilTestEnable),
3999 proc: unsafe {
4000 std::mem::transmute::<vk::PFN_vkCmdSetStencilTestEnable, vk::PFN_vkVoidFunction>(
4001 Self::cmd_set_stencil_test_enable,
4002 )
4003 },
4004 },
4005 VulkanCommand {
4006 name: "vkCmdSetStencilWriteMask",
4007 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
4008 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetStencilWriteMask),
4009 proc: unsafe {
4010 std::mem::transmute::<vk::PFN_vkCmdSetStencilWriteMask, vk::PFN_vkVoidFunction>(
4011 Self::cmd_set_stencil_write_mask,
4012 )
4013 },
4014 },
4015 VulkanCommand {
4016 name: "vkCmdSetTessellationDomainOriginEXT",
4017 features: smallvec![
4018 Feature::Extension(Extension::EXTExtendedDynamicState3),
4019 Feature::Extension(Extension::EXTShaderObject)
4020 ],
4021 hooked: hooked_commands
4022 .contains(&LayerVulkanCommand::CmdSetTessellationDomainOriginExt),
4023 proc: unsafe {
4024 std::mem::transmute::<
4025 vk::PFN_vkCmdSetTessellationDomainOriginEXT,
4026 vk::PFN_vkVoidFunction,
4027 >(Self::cmd_set_tessellation_domain_origin_ext)
4028 },
4029 },
4030 VulkanCommand {
4031 name: "vkCmdSetVertexInputEXT",
4032 features: smallvec![
4033 Feature::Extension(Extension::EXTVertexInputDynamicState),
4034 Feature::Extension(Extension::EXTShaderObject)
4035 ],
4036 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetVertexInputExt),
4037 proc: unsafe {
4038 std::mem::transmute::<vk::PFN_vkCmdSetVertexInputEXT, vk::PFN_vkVoidFunction>(
4039 Self::cmd_set_vertex_input_ext,
4040 )
4041 },
4042 },
4043 VulkanCommand {
4044 name: "vkCmdSetViewport",
4045 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
4046 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetViewport),
4047 proc: unsafe {
4048 std::mem::transmute::<vk::PFN_vkCmdSetViewport, vk::PFN_vkVoidFunction>(
4049 Self::cmd_set_viewport,
4050 )
4051 },
4052 },
4053 VulkanCommand {
4054 name: "vkCmdSetViewportShadingRatePaletteNV",
4055 features: smallvec![Feature::Extension(Extension::NVShadingRateImage)],
4056 hooked: hooked_commands
4057 .contains(&LayerVulkanCommand::CmdSetViewportShadingRatePaletteNv),
4058 proc: unsafe {
4059 std::mem::transmute::<
4060 vk::PFN_vkCmdSetViewportShadingRatePaletteNV,
4061 vk::PFN_vkVoidFunction,
4062 >(Self::cmd_set_viewport_shading_rate_palette_nv)
4063 },
4064 },
4065 VulkanCommand {
4066 name: "vkCmdSetViewportSwizzleNV",
4067 features: smallvec![
4068 Feature::Extension(Extension::EXTExtendedDynamicState3),
4069 Feature::Extension(Extension::EXTShaderObject)
4070 ],
4071 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetViewportSwizzleNv),
4072 proc: unsafe {
4073 std::mem::transmute::<vk::PFN_vkCmdSetViewportSwizzleNV, vk::PFN_vkVoidFunction>(
4074 Self::cmd_set_viewport_swizzle_nv,
4075 )
4076 },
4077 },
4078 VulkanCommand {
4079 name: "vkCmdSetViewportWScalingEnableNV",
4080 features: smallvec![
4081 Feature::Extension(Extension::EXTExtendedDynamicState3),
4082 Feature::Extension(Extension::EXTShaderObject)
4083 ],
4084 hooked: hooked_commands
4085 .contains(&LayerVulkanCommand::CmdSetViewportWScalingEnableNv),
4086 proc: unsafe {
4087 std::mem::transmute::<
4088 vk::PFN_vkCmdSetViewportWScalingEnableNV,
4089 vk::PFN_vkVoidFunction,
4090 >(Self::cmd_set_viewport_w_scaling_enable_nv)
4091 },
4092 },
4093 VulkanCommand {
4094 name: "vkCmdSetViewportWScalingNV",
4095 features: smallvec![Feature::Extension(Extension::NVClipSpaceWScaling)],
4096 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetViewportWScalingNv),
4097 proc: unsafe {
4098 std::mem::transmute::<vk::PFN_vkCmdSetViewportWScalingNV, vk::PFN_vkVoidFunction>(
4099 Self::cmd_set_viewport_w_scaling_nv,
4100 )
4101 },
4102 },
4103 VulkanCommand {
4104 name: "vkCmdSetViewportWithCount",
4105 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 3 })],
4106 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetViewportWithCount),
4107 proc: unsafe {
4108 std::mem::transmute::<vk::PFN_vkCmdSetViewportWithCount, vk::PFN_vkVoidFunction>(
4109 Self::cmd_set_viewport_with_count,
4110 )
4111 },
4112 },
4113 VulkanCommand {
4114 name: "vkCmdSetViewportWithCountEXT",
4115 features: smallvec![
4116 Feature::Extension(Extension::EXTExtendedDynamicState),
4117 Feature::Extension(Extension::EXTShaderObject)
4118 ],
4119 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSetViewportWithCount),
4120 proc: unsafe {
4121 std::mem::transmute::<vk::PFN_vkCmdSetViewportWithCount, vk::PFN_vkVoidFunction>(
4122 Self::cmd_set_viewport_with_count,
4123 )
4124 },
4125 },
4126 VulkanCommand {
4127 name: "vkCmdSubpassShadingHUAWEI",
4128 features: smallvec![Feature::Extension(Extension::HUAWEISubpassShading)],
4129 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdSubpassShadingHuawei),
4130 proc: unsafe {
4131 std::mem::transmute::<vk::PFN_vkCmdSubpassShadingHUAWEI, vk::PFN_vkVoidFunction>(
4132 Self::cmd_subpass_shading_huawei,
4133 )
4134 },
4135 },
4136 VulkanCommand {
4137 name: "vkCmdTraceRaysIndirect2KHR",
4138 features: smallvec![Feature::Extension(Extension::KHRRayTracingMaintenance1)],
4139 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdTraceRaysIndirect2Khr),
4140 proc: unsafe {
4141 std::mem::transmute::<vk::PFN_vkCmdTraceRaysIndirect2KHR, vk::PFN_vkVoidFunction>(
4142 Self::cmd_trace_rays_indirect2_khr,
4143 )
4144 },
4145 },
4146 VulkanCommand {
4147 name: "vkCmdTraceRaysIndirectKHR",
4148 features: smallvec![Feature::Extension(Extension::KHRRayTracingPipeline)],
4149 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdTraceRaysIndirectKhr),
4150 proc: unsafe {
4151 std::mem::transmute::<vk::PFN_vkCmdTraceRaysIndirectKHR, vk::PFN_vkVoidFunction>(
4152 Self::cmd_trace_rays_indirect_khr,
4153 )
4154 },
4155 },
4156 VulkanCommand {
4157 name: "vkCmdTraceRaysKHR",
4158 features: smallvec![Feature::Extension(Extension::KHRRayTracingPipeline)],
4159 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdTraceRaysKhr),
4160 proc: unsafe {
4161 std::mem::transmute::<vk::PFN_vkCmdTraceRaysKHR, vk::PFN_vkVoidFunction>(
4162 Self::cmd_trace_rays_khr,
4163 )
4164 },
4165 },
4166 VulkanCommand {
4167 name: "vkCmdTraceRaysNV",
4168 features: smallvec![Feature::Extension(Extension::NVRayTracing)],
4169 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdTraceRaysNv),
4170 proc: unsafe {
4171 std::mem::transmute::<vk::PFN_vkCmdTraceRaysNV, vk::PFN_vkVoidFunction>(
4172 Self::cmd_trace_rays_nv,
4173 )
4174 },
4175 },
4176 VulkanCommand {
4177 name: "vkCmdUpdateBuffer",
4178 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
4179 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdUpdateBuffer),
4180 proc: unsafe {
4181 std::mem::transmute::<vk::PFN_vkCmdUpdateBuffer, vk::PFN_vkVoidFunction>(
4182 Self::cmd_update_buffer,
4183 )
4184 },
4185 },
4186 VulkanCommand {
4187 name: "vkCmdWaitEvents",
4188 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
4189 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdWaitEvents),
4190 proc: unsafe {
4191 std::mem::transmute::<vk::PFN_vkCmdWaitEvents, vk::PFN_vkVoidFunction>(
4192 Self::cmd_wait_events,
4193 )
4194 },
4195 },
4196 VulkanCommand {
4197 name: "vkCmdWaitEvents2",
4198 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 3 })],
4199 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdWaitEvents2),
4200 proc: unsafe {
4201 std::mem::transmute::<vk::PFN_vkCmdWaitEvents2, vk::PFN_vkVoidFunction>(
4202 Self::cmd_wait_events2,
4203 )
4204 },
4205 },
4206 VulkanCommand {
4207 name: "vkCmdWaitEvents2KHR",
4208 features: smallvec![Feature::Extension(Extension::KHRSynchronization2)],
4209 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdWaitEvents2),
4210 proc: unsafe {
4211 std::mem::transmute::<vk::PFN_vkCmdWaitEvents2, vk::PFN_vkVoidFunction>(
4212 Self::cmd_wait_events2,
4213 )
4214 },
4215 },
4216 VulkanCommand {
4217 name: "vkCmdWriteAccelerationStructuresPropertiesKHR",
4218 features: smallvec![Feature::Extension(Extension::KHRAccelerationStructure)],
4219 hooked: hooked_commands
4220 .contains(&LayerVulkanCommand::CmdWriteAccelerationStructuresPropertiesKhr),
4221 proc: unsafe {
4222 std::mem::transmute::<
4223 vk::PFN_vkCmdWriteAccelerationStructuresPropertiesKHR,
4224 vk::PFN_vkVoidFunction,
4225 >(Self::cmd_write_acceleration_structures_properties_khr)
4226 },
4227 },
4228 VulkanCommand {
4229 name: "vkCmdWriteAccelerationStructuresPropertiesNV",
4230 features: smallvec![Feature::Extension(Extension::NVRayTracing)],
4231 hooked: hooked_commands
4232 .contains(&LayerVulkanCommand::CmdWriteAccelerationStructuresPropertiesNv),
4233 proc: unsafe {
4234 std::mem::transmute::<
4235 vk::PFN_vkCmdWriteAccelerationStructuresPropertiesNV,
4236 vk::PFN_vkVoidFunction,
4237 >(Self::cmd_write_acceleration_structures_properties_nv)
4238 },
4239 },
4240 VulkanCommand {
4241 name: "vkCmdWriteBufferMarker2AMD",
4242 features: smallvec![Feature::Extension(Extension::KHRSynchronization2)],
4243 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdWriteBufferMarker2Amd),
4244 proc: unsafe {
4245 std::mem::transmute::<vk::PFN_vkCmdWriteBufferMarker2AMD, vk::PFN_vkVoidFunction>(
4246 Self::cmd_write_buffer_marker2_amd,
4247 )
4248 },
4249 },
4250 VulkanCommand {
4251 name: "vkCmdWriteBufferMarkerAMD",
4252 features: smallvec![Feature::Extension(Extension::AMDBufferMarker)],
4253 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdWriteBufferMarkerAmd),
4254 proc: unsafe {
4255 std::mem::transmute::<vk::PFN_vkCmdWriteBufferMarkerAMD, vk::PFN_vkVoidFunction>(
4256 Self::cmd_write_buffer_marker_amd,
4257 )
4258 },
4259 },
4260 VulkanCommand {
4261 name: "vkCmdWriteMicromapsPropertiesEXT",
4262 features: smallvec![Feature::Extension(Extension::EXTOpacityMicromap)],
4263 hooked: hooked_commands
4264 .contains(&LayerVulkanCommand::CmdWriteMicromapsPropertiesExt),
4265 proc: unsafe {
4266 std::mem::transmute::<
4267 vk::PFN_vkCmdWriteMicromapsPropertiesEXT,
4268 vk::PFN_vkVoidFunction,
4269 >(Self::cmd_write_micromaps_properties_ext)
4270 },
4271 },
4272 VulkanCommand {
4273 name: "vkCmdWriteTimestamp",
4274 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
4275 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdWriteTimestamp),
4276 proc: unsafe {
4277 std::mem::transmute::<vk::PFN_vkCmdWriteTimestamp, vk::PFN_vkVoidFunction>(
4278 Self::cmd_write_timestamp,
4279 )
4280 },
4281 },
4282 VulkanCommand {
4283 name: "vkCmdWriteTimestamp2",
4284 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 3 })],
4285 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdWriteTimestamp2),
4286 proc: unsafe {
4287 std::mem::transmute::<vk::PFN_vkCmdWriteTimestamp2, vk::PFN_vkVoidFunction>(
4288 Self::cmd_write_timestamp2,
4289 )
4290 },
4291 },
4292 VulkanCommand {
4293 name: "vkCmdWriteTimestamp2KHR",
4294 features: smallvec![Feature::Extension(Extension::KHRSynchronization2)],
4295 hooked: hooked_commands.contains(&LayerVulkanCommand::CmdWriteTimestamp2),
4296 proc: unsafe {
4297 std::mem::transmute::<vk::PFN_vkCmdWriteTimestamp2, vk::PFN_vkVoidFunction>(
4298 Self::cmd_write_timestamp2,
4299 )
4300 },
4301 },
4302 VulkanCommand {
4303 name: "vkCompileDeferredNV",
4304 features: smallvec![Feature::Extension(Extension::NVRayTracing)],
4305 hooked: hooked_commands.contains(&LayerVulkanCommand::CompileDeferredNv),
4306 proc: unsafe {
4307 std::mem::transmute::<vk::PFN_vkCompileDeferredNV, vk::PFN_vkVoidFunction>(
4308 Self::compile_deferred_nv,
4309 )
4310 },
4311 },
4312 VulkanCommand {
4313 name: "vkCopyAccelerationStructureKHR",
4314 features: smallvec![Feature::Extension(Extension::KHRAccelerationStructure)],
4315 hooked: hooked_commands.contains(&LayerVulkanCommand::CopyAccelerationStructureKhr),
4316 proc: unsafe {
4317 std::mem::transmute::<
4318 vk::PFN_vkCopyAccelerationStructureKHR,
4319 vk::PFN_vkVoidFunction,
4320 >(Self::copy_acceleration_structure_khr)
4321 },
4322 },
4323 VulkanCommand {
4324 name: "vkCopyAccelerationStructureToMemoryKHR",
4325 features: smallvec![Feature::Extension(Extension::KHRAccelerationStructure)],
4326 hooked: hooked_commands
4327 .contains(&LayerVulkanCommand::CopyAccelerationStructureToMemoryKhr),
4328 proc: unsafe {
4329 std::mem::transmute::<
4330 vk::PFN_vkCopyAccelerationStructureToMemoryKHR,
4331 vk::PFN_vkVoidFunction,
4332 >(Self::copy_acceleration_structure_to_memory_khr)
4333 },
4334 },
4335 VulkanCommand {
4336 name: "vkCopyMemoryToAccelerationStructureKHR",
4337 features: smallvec![Feature::Extension(Extension::KHRAccelerationStructure)],
4338 hooked: hooked_commands
4339 .contains(&LayerVulkanCommand::CopyMemoryToAccelerationStructureKhr),
4340 proc: unsafe {
4341 std::mem::transmute::<
4342 vk::PFN_vkCopyMemoryToAccelerationStructureKHR,
4343 vk::PFN_vkVoidFunction,
4344 >(Self::copy_memory_to_acceleration_structure_khr)
4345 },
4346 },
4347 VulkanCommand {
4348 name: "vkCopyMemoryToMicromapEXT",
4349 features: smallvec![Feature::Extension(Extension::EXTOpacityMicromap)],
4350 hooked: hooked_commands.contains(&LayerVulkanCommand::CopyMemoryToMicromapExt),
4351 proc: unsafe {
4352 std::mem::transmute::<vk::PFN_vkCopyMemoryToMicromapEXT, vk::PFN_vkVoidFunction>(
4353 Self::copy_memory_to_micromap_ext,
4354 )
4355 },
4356 },
4357 VulkanCommand {
4358 name: "vkCopyMicromapEXT",
4359 features: smallvec![Feature::Extension(Extension::EXTOpacityMicromap)],
4360 hooked: hooked_commands.contains(&LayerVulkanCommand::CopyMicromapExt),
4361 proc: unsafe {
4362 std::mem::transmute::<vk::PFN_vkCopyMicromapEXT, vk::PFN_vkVoidFunction>(
4363 Self::copy_micromap_ext,
4364 )
4365 },
4366 },
4367 VulkanCommand {
4368 name: "vkCopyMicromapToMemoryEXT",
4369 features: smallvec![Feature::Extension(Extension::EXTOpacityMicromap)],
4370 hooked: hooked_commands.contains(&LayerVulkanCommand::CopyMicromapToMemoryExt),
4371 proc: unsafe {
4372 std::mem::transmute::<vk::PFN_vkCopyMicromapToMemoryEXT, vk::PFN_vkVoidFunction>(
4373 Self::copy_micromap_to_memory_ext,
4374 )
4375 },
4376 },
4377 VulkanCommand {
4378 name: "vkCreateAccelerationStructureKHR",
4379 features: smallvec![Feature::Extension(Extension::KHRAccelerationStructure)],
4380 hooked: hooked_commands
4381 .contains(&LayerVulkanCommand::CreateAccelerationStructureKhr),
4382 proc: unsafe {
4383 std::mem::transmute::<
4384 vk::PFN_vkCreateAccelerationStructureKHR,
4385 vk::PFN_vkVoidFunction,
4386 >(Self::create_acceleration_structure_khr)
4387 },
4388 },
4389 VulkanCommand {
4390 name: "vkCreateAccelerationStructureNV",
4391 features: smallvec![Feature::Extension(Extension::NVRayTracing)],
4392 hooked: hooked_commands
4393 .contains(&LayerVulkanCommand::CreateAccelerationStructureNv),
4394 proc: unsafe {
4395 std::mem::transmute::<
4396 vk::PFN_vkCreateAccelerationStructureNV,
4397 vk::PFN_vkVoidFunction,
4398 >(Self::create_acceleration_structure_nv)
4399 },
4400 },
4401 VulkanCommand {
4402 name: "vkCreateBuffer",
4403 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
4404 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateBuffer),
4405 proc: unsafe {
4406 std::mem::transmute::<vk::PFN_vkCreateBuffer, vk::PFN_vkVoidFunction>(
4407 Self::create_buffer,
4408 )
4409 },
4410 },
4411 VulkanCommand {
4412 name: "vkCreateBufferCollectionFUCHSIA",
4413 features: smallvec![Feature::Extension(Extension::FUCHSIABufferCollection)],
4414 hooked: hooked_commands
4415 .contains(&LayerVulkanCommand::CreateBufferCollectionFuchsia),
4416 proc: unsafe {
4417 std::mem::transmute::<
4418 vk::PFN_vkCreateBufferCollectionFUCHSIA,
4419 vk::PFN_vkVoidFunction,
4420 >(Self::create_buffer_collection_fuchsia)
4421 },
4422 },
4423 VulkanCommand {
4424 name: "vkCreateBufferView",
4425 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
4426 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateBufferView),
4427 proc: unsafe {
4428 std::mem::transmute::<vk::PFN_vkCreateBufferView, vk::PFN_vkVoidFunction>(
4429 Self::create_buffer_view,
4430 )
4431 },
4432 },
4433 VulkanCommand {
4434 name: "vkCreateCommandPool",
4435 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
4436 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateCommandPool),
4437 proc: unsafe {
4438 std::mem::transmute::<vk::PFN_vkCreateCommandPool, vk::PFN_vkVoidFunction>(
4439 Self::create_command_pool,
4440 )
4441 },
4442 },
4443 VulkanCommand {
4444 name: "vkCreateComputePipelines",
4445 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
4446 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateComputePipelines),
4447 proc: unsafe {
4448 std::mem::transmute::<vk::PFN_vkCreateComputePipelines, vk::PFN_vkVoidFunction>(
4449 Self::create_compute_pipelines,
4450 )
4451 },
4452 },
4453 VulkanCommand {
4454 name: "vkCreateCuFunctionNVX",
4455 features: smallvec![Feature::Extension(Extension::NVXBinaryImport)],
4456 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateCuFunctionNvx),
4457 proc: unsafe {
4458 std::mem::transmute::<vk::PFN_vkCreateCuFunctionNVX, vk::PFN_vkVoidFunction>(
4459 Self::create_cu_function_nvx,
4460 )
4461 },
4462 },
4463 VulkanCommand {
4464 name: "vkCreateCuModuleNVX",
4465 features: smallvec![Feature::Extension(Extension::NVXBinaryImport)],
4466 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateCuModuleNvx),
4467 proc: unsafe {
4468 std::mem::transmute::<vk::PFN_vkCreateCuModuleNVX, vk::PFN_vkVoidFunction>(
4469 Self::create_cu_module_nvx,
4470 )
4471 },
4472 },
4473 VulkanCommand {
4474 name: "vkCreateDeferredOperationKHR",
4475 features: smallvec![Feature::Extension(Extension::KHRDeferredHostOperations)],
4476 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateDeferredOperationKhr),
4477 proc: unsafe {
4478 std::mem::transmute::<
4479 vk::PFN_vkCreateDeferredOperationKHR,
4480 vk::PFN_vkVoidFunction,
4481 >(Self::create_deferred_operation_khr)
4482 },
4483 },
4484 VulkanCommand {
4485 name: "vkCreateDescriptorPool",
4486 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
4487 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateDescriptorPool),
4488 proc: unsafe {
4489 std::mem::transmute::<vk::PFN_vkCreateDescriptorPool, vk::PFN_vkVoidFunction>(
4490 Self::create_descriptor_pool,
4491 )
4492 },
4493 },
4494 VulkanCommand {
4495 name: "vkCreateDescriptorSetLayout",
4496 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
4497 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateDescriptorSetLayout),
4498 proc: unsafe {
4499 std::mem::transmute::<vk::PFN_vkCreateDescriptorSetLayout, vk::PFN_vkVoidFunction>(
4500 Self::create_descriptor_set_layout,
4501 )
4502 },
4503 },
4504 VulkanCommand {
4505 name: "vkCreateDescriptorUpdateTemplate",
4506 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 1 })],
4507 hooked: hooked_commands
4508 .contains(&LayerVulkanCommand::CreateDescriptorUpdateTemplate),
4509 proc: unsafe {
4510 std::mem::transmute::<
4511 vk::PFN_vkCreateDescriptorUpdateTemplate,
4512 vk::PFN_vkVoidFunction,
4513 >(Self::create_descriptor_update_template)
4514 },
4515 },
4516 VulkanCommand {
4517 name: "vkCreateDescriptorUpdateTemplateKHR",
4518 features: smallvec![Feature::Extension(Extension::KHRDescriptorUpdateTemplate)],
4519 hooked: hooked_commands
4520 .contains(&LayerVulkanCommand::CreateDescriptorUpdateTemplate),
4521 proc: unsafe {
4522 std::mem::transmute::<
4523 vk::PFN_vkCreateDescriptorUpdateTemplate,
4524 vk::PFN_vkVoidFunction,
4525 >(Self::create_descriptor_update_template)
4526 },
4527 },
4528 VulkanCommand {
4529 name: "vkCreateEvent",
4530 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
4531 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateEvent),
4532 proc: unsafe {
4533 std::mem::transmute::<vk::PFN_vkCreateEvent, vk::PFN_vkVoidFunction>(
4534 Self::create_event,
4535 )
4536 },
4537 },
4538 VulkanCommand {
4539 name: "vkCreateFence",
4540 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
4541 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateFence),
4542 proc: unsafe {
4543 std::mem::transmute::<vk::PFN_vkCreateFence, vk::PFN_vkVoidFunction>(
4544 Self::create_fence,
4545 )
4546 },
4547 },
4548 VulkanCommand {
4549 name: "vkCreateFramebuffer",
4550 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
4551 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateFramebuffer),
4552 proc: unsafe {
4553 std::mem::transmute::<vk::PFN_vkCreateFramebuffer, vk::PFN_vkVoidFunction>(
4554 Self::create_framebuffer,
4555 )
4556 },
4557 },
4558 VulkanCommand {
4559 name: "vkCreateGraphicsPipelines",
4560 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
4561 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateGraphicsPipelines),
4562 proc: unsafe {
4563 std::mem::transmute::<vk::PFN_vkCreateGraphicsPipelines, vk::PFN_vkVoidFunction>(
4564 Self::create_graphics_pipelines,
4565 )
4566 },
4567 },
4568 VulkanCommand {
4569 name: "vkCreateImage",
4570 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
4571 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateImage),
4572 proc: unsafe {
4573 std::mem::transmute::<vk::PFN_vkCreateImage, vk::PFN_vkVoidFunction>(
4574 Self::create_image,
4575 )
4576 },
4577 },
4578 VulkanCommand {
4579 name: "vkCreateImageView",
4580 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
4581 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateImageView),
4582 proc: unsafe {
4583 std::mem::transmute::<vk::PFN_vkCreateImageView, vk::PFN_vkVoidFunction>(
4584 Self::create_image_view,
4585 )
4586 },
4587 },
4588 VulkanCommand {
4589 name: "vkCreateIndirectCommandsLayoutNV",
4590 features: smallvec![Feature::Extension(Extension::NVDeviceGeneratedCommands)],
4591 hooked: hooked_commands
4592 .contains(&LayerVulkanCommand::CreateIndirectCommandsLayoutNv),
4593 proc: unsafe {
4594 std::mem::transmute::<
4595 vk::PFN_vkCreateIndirectCommandsLayoutNV,
4596 vk::PFN_vkVoidFunction,
4597 >(Self::create_indirect_commands_layout_nv)
4598 },
4599 },
4600 VulkanCommand {
4601 name: "vkCreateMicromapEXT",
4602 features: smallvec![Feature::Extension(Extension::EXTOpacityMicromap)],
4603 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateMicromapExt),
4604 proc: unsafe {
4605 std::mem::transmute::<vk::PFN_vkCreateMicromapEXT, vk::PFN_vkVoidFunction>(
4606 Self::create_micromap_ext,
4607 )
4608 },
4609 },
4610 VulkanCommand {
4611 name: "vkCreateOpticalFlowSessionNV",
4612 features: smallvec![Feature::Extension(Extension::NVOpticalFlow)],
4613 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateOpticalFlowSessionNv),
4614 proc: unsafe {
4615 std::mem::transmute::<
4616 vk::PFN_vkCreateOpticalFlowSessionNV,
4617 vk::PFN_vkVoidFunction,
4618 >(Self::create_optical_flow_session_nv)
4619 },
4620 },
4621 VulkanCommand {
4622 name: "vkCreatePipelineCache",
4623 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
4624 hooked: hooked_commands.contains(&LayerVulkanCommand::CreatePipelineCache),
4625 proc: unsafe {
4626 std::mem::transmute::<vk::PFN_vkCreatePipelineCache, vk::PFN_vkVoidFunction>(
4627 Self::create_pipeline_cache,
4628 )
4629 },
4630 },
4631 VulkanCommand {
4632 name: "vkCreatePipelineLayout",
4633 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
4634 hooked: hooked_commands.contains(&LayerVulkanCommand::CreatePipelineLayout),
4635 proc: unsafe {
4636 std::mem::transmute::<vk::PFN_vkCreatePipelineLayout, vk::PFN_vkVoidFunction>(
4637 Self::create_pipeline_layout,
4638 )
4639 },
4640 },
4641 VulkanCommand {
4642 name: "vkCreatePrivateDataSlot",
4643 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 3 })],
4644 hooked: hooked_commands.contains(&LayerVulkanCommand::CreatePrivateDataSlot),
4645 proc: unsafe {
4646 std::mem::transmute::<vk::PFN_vkCreatePrivateDataSlot, vk::PFN_vkVoidFunction>(
4647 Self::create_private_data_slot,
4648 )
4649 },
4650 },
4651 VulkanCommand {
4652 name: "vkCreatePrivateDataSlotEXT",
4653 features: smallvec![Feature::Extension(Extension::EXTPrivateData)],
4654 hooked: hooked_commands.contains(&LayerVulkanCommand::CreatePrivateDataSlot),
4655 proc: unsafe {
4656 std::mem::transmute::<vk::PFN_vkCreatePrivateDataSlot, vk::PFN_vkVoidFunction>(
4657 Self::create_private_data_slot,
4658 )
4659 },
4660 },
4661 VulkanCommand {
4662 name: "vkCreateQueryPool",
4663 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
4664 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateQueryPool),
4665 proc: unsafe {
4666 std::mem::transmute::<vk::PFN_vkCreateQueryPool, vk::PFN_vkVoidFunction>(
4667 Self::create_query_pool,
4668 )
4669 },
4670 },
4671 VulkanCommand {
4672 name: "vkCreateRayTracingPipelinesKHR",
4673 features: smallvec![Feature::Extension(Extension::KHRRayTracingPipeline)],
4674 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateRayTracingPipelinesKhr),
4675 proc: unsafe {
4676 std::mem::transmute::<
4677 vk::PFN_vkCreateRayTracingPipelinesKHR,
4678 vk::PFN_vkVoidFunction,
4679 >(Self::create_ray_tracing_pipelines_khr)
4680 },
4681 },
4682 VulkanCommand {
4683 name: "vkCreateRayTracingPipelinesNV",
4684 features: smallvec![Feature::Extension(Extension::NVRayTracing)],
4685 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateRayTracingPipelinesNv),
4686 proc: unsafe {
4687 std::mem::transmute::<
4688 vk::PFN_vkCreateRayTracingPipelinesNV,
4689 vk::PFN_vkVoidFunction,
4690 >(Self::create_ray_tracing_pipelines_nv)
4691 },
4692 },
4693 VulkanCommand {
4694 name: "vkCreateRenderPass",
4695 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
4696 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateRenderPass),
4697 proc: unsafe {
4698 std::mem::transmute::<vk::PFN_vkCreateRenderPass, vk::PFN_vkVoidFunction>(
4699 Self::create_render_pass,
4700 )
4701 },
4702 },
4703 VulkanCommand {
4704 name: "vkCreateRenderPass2",
4705 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 2 })],
4706 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateRenderPass2),
4707 proc: unsafe {
4708 std::mem::transmute::<vk::PFN_vkCreateRenderPass2, vk::PFN_vkVoidFunction>(
4709 Self::create_render_pass2,
4710 )
4711 },
4712 },
4713 VulkanCommand {
4714 name: "vkCreateRenderPass2KHR",
4715 features: smallvec![Feature::Extension(Extension::KHRCreateRenderpass2)],
4716 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateRenderPass2),
4717 proc: unsafe {
4718 std::mem::transmute::<vk::PFN_vkCreateRenderPass2, vk::PFN_vkVoidFunction>(
4719 Self::create_render_pass2,
4720 )
4721 },
4722 },
4723 VulkanCommand {
4724 name: "vkCreateSampler",
4725 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
4726 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateSampler),
4727 proc: unsafe {
4728 std::mem::transmute::<vk::PFN_vkCreateSampler, vk::PFN_vkVoidFunction>(
4729 Self::create_sampler,
4730 )
4731 },
4732 },
4733 VulkanCommand {
4734 name: "vkCreateSamplerYcbcrConversion",
4735 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 1 })],
4736 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateSamplerYcbcrConversion),
4737 proc: unsafe {
4738 std::mem::transmute::<
4739 vk::PFN_vkCreateSamplerYcbcrConversion,
4740 vk::PFN_vkVoidFunction,
4741 >(Self::create_sampler_ycbcr_conversion)
4742 },
4743 },
4744 VulkanCommand {
4745 name: "vkCreateSamplerYcbcrConversionKHR",
4746 features: smallvec![Feature::Extension(Extension::KHRSamplerYcbcrConversion)],
4747 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateSamplerYcbcrConversion),
4748 proc: unsafe {
4749 std::mem::transmute::<
4750 vk::PFN_vkCreateSamplerYcbcrConversion,
4751 vk::PFN_vkVoidFunction,
4752 >(Self::create_sampler_ycbcr_conversion)
4753 },
4754 },
4755 VulkanCommand {
4756 name: "vkCreateSemaphore",
4757 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
4758 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateSemaphore),
4759 proc: unsafe {
4760 std::mem::transmute::<vk::PFN_vkCreateSemaphore, vk::PFN_vkVoidFunction>(
4761 Self::create_semaphore,
4762 )
4763 },
4764 },
4765 VulkanCommand {
4766 name: "vkCreateShaderModule",
4767 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
4768 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateShaderModule),
4769 proc: unsafe {
4770 std::mem::transmute::<vk::PFN_vkCreateShaderModule, vk::PFN_vkVoidFunction>(
4771 Self::create_shader_module,
4772 )
4773 },
4774 },
4775 VulkanCommand {
4776 name: "vkCreateSharedSwapchainsKHR",
4777 features: smallvec![Feature::Extension(Extension::KHRDisplaySwapchain)],
4778 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateSharedSwapchainsKhr),
4779 proc: unsafe {
4780 std::mem::transmute::<vk::PFN_vkCreateSharedSwapchainsKHR, vk::PFN_vkVoidFunction>(
4781 Self::create_shared_swapchains_khr,
4782 )
4783 },
4784 },
4785 VulkanCommand {
4786 name: "vkCreateSwapchainKHR",
4787 features: smallvec![Feature::Extension(Extension::KHRSwapchain)],
4788 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateSwapchainKhr),
4789 proc: unsafe {
4790 std::mem::transmute::<vk::PFN_vkCreateSwapchainKHR, vk::PFN_vkVoidFunction>(
4791 Self::create_swapchain_khr,
4792 )
4793 },
4794 },
4795 VulkanCommand {
4796 name: "vkCreateValidationCacheEXT",
4797 features: smallvec![Feature::Extension(Extension::EXTValidationCache)],
4798 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateValidationCacheExt),
4799 proc: unsafe {
4800 std::mem::transmute::<vk::PFN_vkCreateValidationCacheEXT, vk::PFN_vkVoidFunction>(
4801 Self::create_validation_cache_ext,
4802 )
4803 },
4804 },
4805 VulkanCommand {
4806 name: "vkCreateVideoSessionKHR",
4807 features: smallvec![Feature::Extension(Extension::KHRVideoQueue)],
4808 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateVideoSessionKhr),
4809 proc: unsafe {
4810 std::mem::transmute::<vk::PFN_vkCreateVideoSessionKHR, vk::PFN_vkVoidFunction>(
4811 Self::create_video_session_khr,
4812 )
4813 },
4814 },
4815 VulkanCommand {
4816 name: "vkCreateVideoSessionParametersKHR",
4817 features: smallvec![Feature::Extension(Extension::KHRVideoQueue)],
4818 hooked: hooked_commands
4819 .contains(&LayerVulkanCommand::CreateVideoSessionParametersKhr),
4820 proc: unsafe {
4821 std::mem::transmute::<
4822 vk::PFN_vkCreateVideoSessionParametersKHR,
4823 vk::PFN_vkVoidFunction,
4824 >(Self::create_video_session_parameters_khr)
4825 },
4826 },
4827 VulkanCommand {
4828 name: "vkDebugMarkerSetObjectNameEXT",
4829 features: smallvec![Feature::Extension(Extension::EXTDebugMarker)],
4830 hooked: hooked_commands.contains(&LayerVulkanCommand::DebugMarkerSetObjectNameExt),
4831 proc: unsafe {
4832 std::mem::transmute::<
4833 vk::PFN_vkDebugMarkerSetObjectNameEXT,
4834 vk::PFN_vkVoidFunction,
4835 >(Self::debug_marker_set_object_name_ext)
4836 },
4837 },
4838 VulkanCommand {
4839 name: "vkDebugMarkerSetObjectTagEXT",
4840 features: smallvec![Feature::Extension(Extension::EXTDebugMarker)],
4841 hooked: hooked_commands.contains(&LayerVulkanCommand::DebugMarkerSetObjectTagExt),
4842 proc: unsafe {
4843 std::mem::transmute::<
4844 vk::PFN_vkDebugMarkerSetObjectTagEXT,
4845 vk::PFN_vkVoidFunction,
4846 >(Self::debug_marker_set_object_tag_ext)
4847 },
4848 },
4849 VulkanCommand {
4850 name: "vkDeferredOperationJoinKHR",
4851 features: smallvec![Feature::Extension(Extension::KHRDeferredHostOperations)],
4852 hooked: hooked_commands.contains(&LayerVulkanCommand::DeferredOperationJoinKhr),
4853 proc: unsafe {
4854 std::mem::transmute::<vk::PFN_vkDeferredOperationJoinKHR, vk::PFN_vkVoidFunction>(
4855 Self::deferred_operation_join_khr,
4856 )
4857 },
4858 },
4859 VulkanCommand {
4860 name: "vkDestroyAccelerationStructureKHR",
4861 features: smallvec![Feature::Extension(Extension::KHRAccelerationStructure)],
4862 hooked: hooked_commands
4863 .contains(&LayerVulkanCommand::DestroyAccelerationStructureKhr),
4864 proc: unsafe {
4865 std::mem::transmute::<
4866 vk::PFN_vkDestroyAccelerationStructureKHR,
4867 vk::PFN_vkVoidFunction,
4868 >(Self::destroy_acceleration_structure_khr)
4869 },
4870 },
4871 VulkanCommand {
4872 name: "vkDestroyAccelerationStructureNV",
4873 features: smallvec![Feature::Extension(Extension::NVRayTracing)],
4874 hooked: hooked_commands
4875 .contains(&LayerVulkanCommand::DestroyAccelerationStructureNv),
4876 proc: unsafe {
4877 std::mem::transmute::<
4878 vk::PFN_vkDestroyAccelerationStructureNV,
4879 vk::PFN_vkVoidFunction,
4880 >(Self::destroy_acceleration_structure_nv)
4881 },
4882 },
4883 VulkanCommand {
4884 name: "vkDestroyBuffer",
4885 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
4886 hooked: hooked_commands.contains(&LayerVulkanCommand::DestroyBuffer),
4887 proc: unsafe {
4888 std::mem::transmute::<vk::PFN_vkDestroyBuffer, vk::PFN_vkVoidFunction>(
4889 Self::destroy_buffer,
4890 )
4891 },
4892 },
4893 VulkanCommand {
4894 name: "vkDestroyBufferCollectionFUCHSIA",
4895 features: smallvec![Feature::Extension(Extension::FUCHSIABufferCollection)],
4896 hooked: hooked_commands
4897 .contains(&LayerVulkanCommand::DestroyBufferCollectionFuchsia),
4898 proc: unsafe {
4899 std::mem::transmute::<
4900 vk::PFN_vkDestroyBufferCollectionFUCHSIA,
4901 vk::PFN_vkVoidFunction,
4902 >(Self::destroy_buffer_collection_fuchsia)
4903 },
4904 },
4905 VulkanCommand {
4906 name: "vkDestroyBufferView",
4907 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
4908 hooked: hooked_commands.contains(&LayerVulkanCommand::DestroyBufferView),
4909 proc: unsafe {
4910 std::mem::transmute::<vk::PFN_vkDestroyBufferView, vk::PFN_vkVoidFunction>(
4911 Self::destroy_buffer_view,
4912 )
4913 },
4914 },
4915 VulkanCommand {
4916 name: "vkDestroyCommandPool",
4917 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
4918 hooked: hooked_commands.contains(&LayerVulkanCommand::DestroyCommandPool),
4919 proc: unsafe {
4920 std::mem::transmute::<vk::PFN_vkDestroyCommandPool, vk::PFN_vkVoidFunction>(
4921 Self::destroy_command_pool,
4922 )
4923 },
4924 },
4925 VulkanCommand {
4926 name: "vkDestroyCuFunctionNVX",
4927 features: smallvec![Feature::Extension(Extension::NVXBinaryImport)],
4928 hooked: hooked_commands.contains(&LayerVulkanCommand::DestroyCuFunctionNvx),
4929 proc: unsafe {
4930 std::mem::transmute::<vk::PFN_vkDestroyCuFunctionNVX, vk::PFN_vkVoidFunction>(
4931 Self::destroy_cu_function_nvx,
4932 )
4933 },
4934 },
4935 VulkanCommand {
4936 name: "vkDestroyCuModuleNVX",
4937 features: smallvec![Feature::Extension(Extension::NVXBinaryImport)],
4938 hooked: hooked_commands.contains(&LayerVulkanCommand::DestroyCuModuleNvx),
4939 proc: unsafe {
4940 std::mem::transmute::<vk::PFN_vkDestroyCuModuleNVX, vk::PFN_vkVoidFunction>(
4941 Self::destroy_cu_module_nvx,
4942 )
4943 },
4944 },
4945 VulkanCommand {
4946 name: "vkDestroyDeferredOperationKHR",
4947 features: smallvec![Feature::Extension(Extension::KHRDeferredHostOperations)],
4948 hooked: hooked_commands.contains(&LayerVulkanCommand::DestroyDeferredOperationKhr),
4949 proc: unsafe {
4950 std::mem::transmute::<
4951 vk::PFN_vkDestroyDeferredOperationKHR,
4952 vk::PFN_vkVoidFunction,
4953 >(Self::destroy_deferred_operation_khr)
4954 },
4955 },
4956 VulkanCommand {
4957 name: "vkDestroyDescriptorPool",
4958 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
4959 hooked: hooked_commands.contains(&LayerVulkanCommand::DestroyDescriptorPool),
4960 proc: unsafe {
4961 std::mem::transmute::<vk::PFN_vkDestroyDescriptorPool, vk::PFN_vkVoidFunction>(
4962 Self::destroy_descriptor_pool,
4963 )
4964 },
4965 },
4966 VulkanCommand {
4967 name: "vkDestroyDescriptorSetLayout",
4968 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
4969 hooked: hooked_commands.contains(&LayerVulkanCommand::DestroyDescriptorSetLayout),
4970 proc: unsafe {
4971 std::mem::transmute::<
4972 vk::PFN_vkDestroyDescriptorSetLayout,
4973 vk::PFN_vkVoidFunction,
4974 >(Self::destroy_descriptor_set_layout)
4975 },
4976 },
4977 VulkanCommand {
4978 name: "vkDestroyDescriptorUpdateTemplate",
4979 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 1 })],
4980 hooked: hooked_commands
4981 .contains(&LayerVulkanCommand::DestroyDescriptorUpdateTemplate),
4982 proc: unsafe {
4983 std::mem::transmute::<
4984 vk::PFN_vkDestroyDescriptorUpdateTemplate,
4985 vk::PFN_vkVoidFunction,
4986 >(Self::destroy_descriptor_update_template)
4987 },
4988 },
4989 VulkanCommand {
4990 name: "vkDestroyDescriptorUpdateTemplateKHR",
4991 features: smallvec![Feature::Extension(Extension::KHRDescriptorUpdateTemplate)],
4992 hooked: hooked_commands
4993 .contains(&LayerVulkanCommand::DestroyDescriptorUpdateTemplate),
4994 proc: unsafe {
4995 std::mem::transmute::<
4996 vk::PFN_vkDestroyDescriptorUpdateTemplate,
4997 vk::PFN_vkVoidFunction,
4998 >(Self::destroy_descriptor_update_template)
4999 },
5000 },
5001 VulkanCommand {
5002 name: "vkDestroyDevice",
5003 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
5004 hooked: true,
5005 proc: unsafe {
5006 std::mem::transmute::<vk::PFN_vkDestroyDevice, vk::PFN_vkVoidFunction>(
5007 Self::destroy_device,
5008 )
5009 },
5010 },
5011 VulkanCommand {
5012 name: "vkDestroyEvent",
5013 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
5014 hooked: hooked_commands.contains(&LayerVulkanCommand::DestroyEvent),
5015 proc: unsafe {
5016 std::mem::transmute::<vk::PFN_vkDestroyEvent, vk::PFN_vkVoidFunction>(
5017 Self::destroy_event,
5018 )
5019 },
5020 },
5021 VulkanCommand {
5022 name: "vkDestroyFence",
5023 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
5024 hooked: hooked_commands.contains(&LayerVulkanCommand::DestroyFence),
5025 proc: unsafe {
5026 std::mem::transmute::<vk::PFN_vkDestroyFence, vk::PFN_vkVoidFunction>(
5027 Self::destroy_fence,
5028 )
5029 },
5030 },
5031 VulkanCommand {
5032 name: "vkDestroyFramebuffer",
5033 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
5034 hooked: hooked_commands.contains(&LayerVulkanCommand::DestroyFramebuffer),
5035 proc: unsafe {
5036 std::mem::transmute::<vk::PFN_vkDestroyFramebuffer, vk::PFN_vkVoidFunction>(
5037 Self::destroy_framebuffer,
5038 )
5039 },
5040 },
5041 VulkanCommand {
5042 name: "vkDestroyImage",
5043 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
5044 hooked: hooked_commands.contains(&LayerVulkanCommand::DestroyImage),
5045 proc: unsafe {
5046 std::mem::transmute::<vk::PFN_vkDestroyImage, vk::PFN_vkVoidFunction>(
5047 Self::destroy_image,
5048 )
5049 },
5050 },
5051 VulkanCommand {
5052 name: "vkDestroyImageView",
5053 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
5054 hooked: hooked_commands.contains(&LayerVulkanCommand::DestroyImageView),
5055 proc: unsafe {
5056 std::mem::transmute::<vk::PFN_vkDestroyImageView, vk::PFN_vkVoidFunction>(
5057 Self::destroy_image_view,
5058 )
5059 },
5060 },
5061 VulkanCommand {
5062 name: "vkDestroyIndirectCommandsLayoutNV",
5063 features: smallvec![Feature::Extension(Extension::NVDeviceGeneratedCommands)],
5064 hooked: hooked_commands
5065 .contains(&LayerVulkanCommand::DestroyIndirectCommandsLayoutNv),
5066 proc: unsafe {
5067 std::mem::transmute::<
5068 vk::PFN_vkDestroyIndirectCommandsLayoutNV,
5069 vk::PFN_vkVoidFunction,
5070 >(Self::destroy_indirect_commands_layout_nv)
5071 },
5072 },
5073 VulkanCommand {
5074 name: "vkDestroyMicromapEXT",
5075 features: smallvec![Feature::Extension(Extension::EXTOpacityMicromap)],
5076 hooked: hooked_commands.contains(&LayerVulkanCommand::DestroyMicromapExt),
5077 proc: unsafe {
5078 std::mem::transmute::<vk::PFN_vkDestroyMicromapEXT, vk::PFN_vkVoidFunction>(
5079 Self::destroy_micromap_ext,
5080 )
5081 },
5082 },
5083 VulkanCommand {
5084 name: "vkDestroyOpticalFlowSessionNV",
5085 features: smallvec![Feature::Extension(Extension::NVOpticalFlow)],
5086 hooked: hooked_commands.contains(&LayerVulkanCommand::DestroyOpticalFlowSessionNv),
5087 proc: unsafe {
5088 std::mem::transmute::<
5089 vk::PFN_vkDestroyOpticalFlowSessionNV,
5090 vk::PFN_vkVoidFunction,
5091 >(Self::destroy_optical_flow_session_nv)
5092 },
5093 },
5094 VulkanCommand {
5095 name: "vkDestroyPipeline",
5096 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
5097 hooked: hooked_commands.contains(&LayerVulkanCommand::DestroyPipeline),
5098 proc: unsafe {
5099 std::mem::transmute::<vk::PFN_vkDestroyPipeline, vk::PFN_vkVoidFunction>(
5100 Self::destroy_pipeline,
5101 )
5102 },
5103 },
5104 VulkanCommand {
5105 name: "vkDestroyPipelineCache",
5106 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
5107 hooked: hooked_commands.contains(&LayerVulkanCommand::DestroyPipelineCache),
5108 proc: unsafe {
5109 std::mem::transmute::<vk::PFN_vkDestroyPipelineCache, vk::PFN_vkVoidFunction>(
5110 Self::destroy_pipeline_cache,
5111 )
5112 },
5113 },
5114 VulkanCommand {
5115 name: "vkDestroyPipelineLayout",
5116 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
5117 hooked: hooked_commands.contains(&LayerVulkanCommand::DestroyPipelineLayout),
5118 proc: unsafe {
5119 std::mem::transmute::<vk::PFN_vkDestroyPipelineLayout, vk::PFN_vkVoidFunction>(
5120 Self::destroy_pipeline_layout,
5121 )
5122 },
5123 },
5124 VulkanCommand {
5125 name: "vkDestroyPrivateDataSlot",
5126 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 3 })],
5127 hooked: hooked_commands.contains(&LayerVulkanCommand::DestroyPrivateDataSlot),
5128 proc: unsafe {
5129 std::mem::transmute::<vk::PFN_vkDestroyPrivateDataSlot, vk::PFN_vkVoidFunction>(
5130 Self::destroy_private_data_slot,
5131 )
5132 },
5133 },
5134 VulkanCommand {
5135 name: "vkDestroyPrivateDataSlotEXT",
5136 features: smallvec![Feature::Extension(Extension::EXTPrivateData)],
5137 hooked: hooked_commands.contains(&LayerVulkanCommand::DestroyPrivateDataSlot),
5138 proc: unsafe {
5139 std::mem::transmute::<vk::PFN_vkDestroyPrivateDataSlot, vk::PFN_vkVoidFunction>(
5140 Self::destroy_private_data_slot,
5141 )
5142 },
5143 },
5144 VulkanCommand {
5145 name: "vkDestroyQueryPool",
5146 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
5147 hooked: hooked_commands.contains(&LayerVulkanCommand::DestroyQueryPool),
5148 proc: unsafe {
5149 std::mem::transmute::<vk::PFN_vkDestroyQueryPool, vk::PFN_vkVoidFunction>(
5150 Self::destroy_query_pool,
5151 )
5152 },
5153 },
5154 VulkanCommand {
5155 name: "vkDestroyRenderPass",
5156 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
5157 hooked: hooked_commands.contains(&LayerVulkanCommand::DestroyRenderPass),
5158 proc: unsafe {
5159 std::mem::transmute::<vk::PFN_vkDestroyRenderPass, vk::PFN_vkVoidFunction>(
5160 Self::destroy_render_pass,
5161 )
5162 },
5163 },
5164 VulkanCommand {
5165 name: "vkDestroySampler",
5166 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
5167 hooked: hooked_commands.contains(&LayerVulkanCommand::DestroySampler),
5168 proc: unsafe {
5169 std::mem::transmute::<vk::PFN_vkDestroySampler, vk::PFN_vkVoidFunction>(
5170 Self::destroy_sampler,
5171 )
5172 },
5173 },
5174 VulkanCommand {
5175 name: "vkDestroySamplerYcbcrConversion",
5176 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 1 })],
5177 hooked: hooked_commands
5178 .contains(&LayerVulkanCommand::DestroySamplerYcbcrConversion),
5179 proc: unsafe {
5180 std::mem::transmute::<
5181 vk::PFN_vkDestroySamplerYcbcrConversion,
5182 vk::PFN_vkVoidFunction,
5183 >(Self::destroy_sampler_ycbcr_conversion)
5184 },
5185 },
5186 VulkanCommand {
5187 name: "vkDestroySamplerYcbcrConversionKHR",
5188 features: smallvec![Feature::Extension(Extension::KHRSamplerYcbcrConversion)],
5189 hooked: hooked_commands
5190 .contains(&LayerVulkanCommand::DestroySamplerYcbcrConversion),
5191 proc: unsafe {
5192 std::mem::transmute::<
5193 vk::PFN_vkDestroySamplerYcbcrConversion,
5194 vk::PFN_vkVoidFunction,
5195 >(Self::destroy_sampler_ycbcr_conversion)
5196 },
5197 },
5198 VulkanCommand {
5199 name: "vkDestroySemaphore",
5200 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
5201 hooked: hooked_commands.contains(&LayerVulkanCommand::DestroySemaphore),
5202 proc: unsafe {
5203 std::mem::transmute::<vk::PFN_vkDestroySemaphore, vk::PFN_vkVoidFunction>(
5204 Self::destroy_semaphore,
5205 )
5206 },
5207 },
5208 VulkanCommand {
5209 name: "vkDestroyShaderModule",
5210 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
5211 hooked: hooked_commands.contains(&LayerVulkanCommand::DestroyShaderModule),
5212 proc: unsafe {
5213 std::mem::transmute::<vk::PFN_vkDestroyShaderModule, vk::PFN_vkVoidFunction>(
5214 Self::destroy_shader_module,
5215 )
5216 },
5217 },
5218 VulkanCommand {
5219 name: "vkDestroySwapchainKHR",
5220 features: smallvec![Feature::Extension(Extension::KHRSwapchain)],
5221 hooked: hooked_commands.contains(&LayerVulkanCommand::DestroySwapchainKhr),
5222 proc: unsafe {
5223 std::mem::transmute::<vk::PFN_vkDestroySwapchainKHR, vk::PFN_vkVoidFunction>(
5224 Self::destroy_swapchain_khr,
5225 )
5226 },
5227 },
5228 VulkanCommand {
5229 name: "vkDestroyValidationCacheEXT",
5230 features: smallvec![Feature::Extension(Extension::EXTValidationCache)],
5231 hooked: hooked_commands.contains(&LayerVulkanCommand::DestroyValidationCacheExt),
5232 proc: unsafe {
5233 std::mem::transmute::<vk::PFN_vkDestroyValidationCacheEXT, vk::PFN_vkVoidFunction>(
5234 Self::destroy_validation_cache_ext,
5235 )
5236 },
5237 },
5238 VulkanCommand {
5239 name: "vkDestroyVideoSessionKHR",
5240 features: smallvec![Feature::Extension(Extension::KHRVideoQueue)],
5241 hooked: hooked_commands.contains(&LayerVulkanCommand::DestroyVideoSessionKhr),
5242 proc: unsafe {
5243 std::mem::transmute::<vk::PFN_vkDestroyVideoSessionKHR, vk::PFN_vkVoidFunction>(
5244 Self::destroy_video_session_khr,
5245 )
5246 },
5247 },
5248 VulkanCommand {
5249 name: "vkDestroyVideoSessionParametersKHR",
5250 features: smallvec![Feature::Extension(Extension::KHRVideoQueue)],
5251 hooked: hooked_commands
5252 .contains(&LayerVulkanCommand::DestroyVideoSessionParametersKhr),
5253 proc: unsafe {
5254 std::mem::transmute::<
5255 vk::PFN_vkDestroyVideoSessionParametersKHR,
5256 vk::PFN_vkVoidFunction,
5257 >(Self::destroy_video_session_parameters_khr)
5258 },
5259 },
5260 VulkanCommand {
5261 name: "vkDeviceWaitIdle",
5262 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
5263 hooked: hooked_commands.contains(&LayerVulkanCommand::DeviceWaitIdle),
5264 proc: unsafe {
5265 std::mem::transmute::<vk::PFN_vkDeviceWaitIdle, vk::PFN_vkVoidFunction>(
5266 Self::device_wait_idle,
5267 )
5268 },
5269 },
5270 VulkanCommand {
5271 name: "vkDisplayPowerControlEXT",
5272 features: smallvec![Feature::Extension(Extension::EXTDisplayControl)],
5273 hooked: hooked_commands.contains(&LayerVulkanCommand::DisplayPowerControlExt),
5274 proc: unsafe {
5275 std::mem::transmute::<vk::PFN_vkDisplayPowerControlEXT, vk::PFN_vkVoidFunction>(
5276 Self::display_power_control_ext,
5277 )
5278 },
5279 },
5280 VulkanCommand {
5281 name: "vkEndCommandBuffer",
5282 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
5283 hooked: hooked_commands.contains(&LayerVulkanCommand::EndCommandBuffer),
5284 proc: unsafe {
5285 std::mem::transmute::<vk::PFN_vkEndCommandBuffer, vk::PFN_vkVoidFunction>(
5286 Self::end_command_buffer,
5287 )
5288 },
5289 },
5290 VulkanCommand {
5291 name: "vkExportMetalObjectsEXT",
5292 features: smallvec![Feature::Extension(Extension::EXTMetalObjects)],
5293 hooked: hooked_commands.contains(&LayerVulkanCommand::ExportMetalObjectsExt),
5294 proc: unsafe {
5295 std::mem::transmute::<vk::PFN_vkExportMetalObjectsEXT, vk::PFN_vkVoidFunction>(
5296 Self::export_metal_objects_ext,
5297 )
5298 },
5299 },
5300 VulkanCommand {
5301 name: "vkFlushMappedMemoryRanges",
5302 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
5303 hooked: hooked_commands.contains(&LayerVulkanCommand::FlushMappedMemoryRanges),
5304 proc: unsafe {
5305 std::mem::transmute::<vk::PFN_vkFlushMappedMemoryRanges, vk::PFN_vkVoidFunction>(
5306 Self::flush_mapped_memory_ranges,
5307 )
5308 },
5309 },
5310 VulkanCommand {
5311 name: "vkFreeCommandBuffers",
5312 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
5313 hooked: hooked_commands.contains(&LayerVulkanCommand::FreeCommandBuffers),
5314 proc: unsafe {
5315 std::mem::transmute::<vk::PFN_vkFreeCommandBuffers, vk::PFN_vkVoidFunction>(
5316 Self::free_command_buffers,
5317 )
5318 },
5319 },
5320 VulkanCommand {
5321 name: "vkFreeDescriptorSets",
5322 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
5323 hooked: hooked_commands.contains(&LayerVulkanCommand::FreeDescriptorSets),
5324 proc: unsafe {
5325 std::mem::transmute::<vk::PFN_vkFreeDescriptorSets, vk::PFN_vkVoidFunction>(
5326 Self::free_descriptor_sets,
5327 )
5328 },
5329 },
5330 VulkanCommand {
5331 name: "vkFreeMemory",
5332 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
5333 hooked: hooked_commands.contains(&LayerVulkanCommand::FreeMemory),
5334 proc: unsafe {
5335 std::mem::transmute::<vk::PFN_vkFreeMemory, vk::PFN_vkVoidFunction>(
5336 Self::free_memory,
5337 )
5338 },
5339 },
5340 VulkanCommand {
5341 name: "vkGetAccelerationStructureBuildSizesKHR",
5342 features: smallvec![Feature::Extension(Extension::KHRAccelerationStructure)],
5343 hooked: hooked_commands
5344 .contains(&LayerVulkanCommand::GetAccelerationStructureBuildSizesKhr),
5345 proc: unsafe {
5346 std::mem::transmute::<
5347 vk::PFN_vkGetAccelerationStructureBuildSizesKHR,
5348 vk::PFN_vkVoidFunction,
5349 >(Self::get_acceleration_structure_build_sizes_khr)
5350 },
5351 },
5352 VulkanCommand {
5353 name: "vkGetAccelerationStructureDeviceAddressKHR",
5354 features: smallvec![Feature::Extension(Extension::KHRAccelerationStructure)],
5355 hooked: hooked_commands
5356 .contains(&LayerVulkanCommand::GetAccelerationStructureDeviceAddressKhr),
5357 proc: unsafe {
5358 std::mem::transmute::<
5359 vk::PFN_vkGetAccelerationStructureDeviceAddressKHR,
5360 vk::PFN_vkVoidFunction,
5361 >(Self::get_acceleration_structure_device_address_khr)
5362 },
5363 },
5364 VulkanCommand {
5365 name: "vkGetAccelerationStructureHandleNV",
5366 features: smallvec![Feature::Extension(Extension::NVRayTracing)],
5367 hooked: hooked_commands
5368 .contains(&LayerVulkanCommand::GetAccelerationStructureHandleNv),
5369 proc: unsafe {
5370 std::mem::transmute::<
5371 vk::PFN_vkGetAccelerationStructureHandleNV,
5372 vk::PFN_vkVoidFunction,
5373 >(Self::get_acceleration_structure_handle_nv)
5374 },
5375 },
5376 VulkanCommand {
5377 name: "vkGetAccelerationStructureMemoryRequirementsNV",
5378 features: smallvec![Feature::Extension(Extension::NVRayTracing)],
5379 hooked: hooked_commands
5380 .contains(&LayerVulkanCommand::GetAccelerationStructureMemoryRequirementsNv),
5381 proc: unsafe {
5382 std::mem::transmute::<
5383 vk::PFN_vkGetAccelerationStructureMemoryRequirementsNV,
5384 vk::PFN_vkVoidFunction,
5385 >(Self::get_acceleration_structure_memory_requirements_nv)
5386 },
5387 },
5388 VulkanCommand {
5389 name: "vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT",
5390 features: smallvec![Feature::Extension(Extension::EXTDescriptorBuffer)],
5391 hooked: hooked_commands.contains(
5392 &LayerVulkanCommand::GetAccelerationStructureOpaqueCaptureDescriptorDataExt,
5393 ),
5394 proc: unsafe {
5395 std::mem::transmute::<
5396 vk::PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT,
5397 vk::PFN_vkVoidFunction,
5398 >(
5399 Self::get_acceleration_structure_opaque_capture_descriptor_data_ext
5400 )
5401 },
5402 },
5403 VulkanCommand {
5404 name: "vkGetAndroidHardwareBufferPropertiesANDROID",
5405 features: smallvec![Feature::Extension(
5406 Extension::ANDROIDExternalMemoryAndroidHardwareBuffer
5407 )],
5408 hooked: hooked_commands
5409 .contains(&LayerVulkanCommand::GetAndroidHardwareBufferPropertiesAndroid),
5410 proc: unsafe {
5411 std::mem::transmute::<
5412 vk::PFN_vkGetAndroidHardwareBufferPropertiesANDROID,
5413 vk::PFN_vkVoidFunction,
5414 >(Self::get_android_hardware_buffer_properties_android)
5415 },
5416 },
5417 VulkanCommand {
5418 name: "vkGetBufferCollectionPropertiesFUCHSIA",
5419 features: smallvec![Feature::Extension(Extension::FUCHSIABufferCollection)],
5420 hooked: hooked_commands
5421 .contains(&LayerVulkanCommand::GetBufferCollectionPropertiesFuchsia),
5422 proc: unsafe {
5423 std::mem::transmute::<
5424 vk::PFN_vkGetBufferCollectionPropertiesFUCHSIA,
5425 vk::PFN_vkVoidFunction,
5426 >(Self::get_buffer_collection_properties_fuchsia)
5427 },
5428 },
5429 VulkanCommand {
5430 name: "vkGetBufferDeviceAddress",
5431 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 2 })],
5432 hooked: hooked_commands.contains(&LayerVulkanCommand::GetBufferDeviceAddress),
5433 proc: unsafe {
5434 std::mem::transmute::<vk::PFN_vkGetBufferDeviceAddress, vk::PFN_vkVoidFunction>(
5435 Self::get_buffer_device_address,
5436 )
5437 },
5438 },
5439 VulkanCommand {
5440 name: "vkGetBufferDeviceAddressEXT",
5441 features: smallvec![Feature::Extension(Extension::EXTBufferDeviceAddress)],
5442 hooked: hooked_commands.contains(&LayerVulkanCommand::GetBufferDeviceAddress),
5443 proc: unsafe {
5444 std::mem::transmute::<vk::PFN_vkGetBufferDeviceAddress, vk::PFN_vkVoidFunction>(
5445 Self::get_buffer_device_address,
5446 )
5447 },
5448 },
5449 VulkanCommand {
5450 name: "vkGetBufferDeviceAddressKHR",
5451 features: smallvec![Feature::Extension(Extension::KHRBufferDeviceAddress)],
5452 hooked: hooked_commands.contains(&LayerVulkanCommand::GetBufferDeviceAddress),
5453 proc: unsafe {
5454 std::mem::transmute::<vk::PFN_vkGetBufferDeviceAddress, vk::PFN_vkVoidFunction>(
5455 Self::get_buffer_device_address,
5456 )
5457 },
5458 },
5459 VulkanCommand {
5460 name: "vkGetBufferMemoryRequirements",
5461 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
5462 hooked: hooked_commands.contains(&LayerVulkanCommand::GetBufferMemoryRequirements),
5463 proc: unsafe {
5464 std::mem::transmute::<
5465 vk::PFN_vkGetBufferMemoryRequirements,
5466 vk::PFN_vkVoidFunction,
5467 >(Self::get_buffer_memory_requirements)
5468 },
5469 },
5470 VulkanCommand {
5471 name: "vkGetBufferMemoryRequirements2",
5472 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 1 })],
5473 hooked: hooked_commands.contains(&LayerVulkanCommand::GetBufferMemoryRequirements2),
5474 proc: unsafe {
5475 std::mem::transmute::<
5476 vk::PFN_vkGetBufferMemoryRequirements2,
5477 vk::PFN_vkVoidFunction,
5478 >(Self::get_buffer_memory_requirements2)
5479 },
5480 },
5481 VulkanCommand {
5482 name: "vkGetBufferMemoryRequirements2KHR",
5483 features: smallvec![Feature::Extension(Extension::KHRGetMemoryRequirements2)],
5484 hooked: hooked_commands.contains(&LayerVulkanCommand::GetBufferMemoryRequirements2),
5485 proc: unsafe {
5486 std::mem::transmute::<
5487 vk::PFN_vkGetBufferMemoryRequirements2,
5488 vk::PFN_vkVoidFunction,
5489 >(Self::get_buffer_memory_requirements2)
5490 },
5491 },
5492 VulkanCommand {
5493 name: "vkGetBufferOpaqueCaptureAddress",
5494 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 2 })],
5495 hooked: hooked_commands
5496 .contains(&LayerVulkanCommand::GetBufferOpaqueCaptureAddress),
5497 proc: unsafe {
5498 std::mem::transmute::<
5499 vk::PFN_vkGetBufferOpaqueCaptureAddress,
5500 vk::PFN_vkVoidFunction,
5501 >(Self::get_buffer_opaque_capture_address)
5502 },
5503 },
5504 VulkanCommand {
5505 name: "vkGetBufferOpaqueCaptureAddressKHR",
5506 features: smallvec![Feature::Extension(Extension::KHRBufferDeviceAddress)],
5507 hooked: hooked_commands
5508 .contains(&LayerVulkanCommand::GetBufferOpaqueCaptureAddress),
5509 proc: unsafe {
5510 std::mem::transmute::<
5511 vk::PFN_vkGetBufferOpaqueCaptureAddress,
5512 vk::PFN_vkVoidFunction,
5513 >(Self::get_buffer_opaque_capture_address)
5514 },
5515 },
5516 VulkanCommand {
5517 name: "vkGetBufferOpaqueCaptureDescriptorDataEXT",
5518 features: smallvec![Feature::Extension(Extension::EXTDescriptorBuffer)],
5519 hooked: hooked_commands
5520 .contains(&LayerVulkanCommand::GetBufferOpaqueCaptureDescriptorDataExt),
5521 proc: unsafe {
5522 std::mem::transmute::<
5523 vk::PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT,
5524 vk::PFN_vkVoidFunction,
5525 >(Self::get_buffer_opaque_capture_descriptor_data_ext)
5526 },
5527 },
5528 VulkanCommand {
5529 name: "vkGetCalibratedTimestampsEXT",
5530 features: smallvec![Feature::Extension(Extension::EXTCalibratedTimestamps)],
5531 hooked: hooked_commands.contains(&LayerVulkanCommand::GetCalibratedTimestampsExt),
5532 proc: unsafe {
5533 std::mem::transmute::<
5534 vk::PFN_vkGetCalibratedTimestampsEXT,
5535 vk::PFN_vkVoidFunction,
5536 >(Self::get_calibrated_timestamps_ext)
5537 },
5538 },
5539 VulkanCommand {
5540 name: "vkGetDeferredOperationMaxConcurrencyKHR",
5541 features: smallvec![Feature::Extension(Extension::KHRDeferredHostOperations)],
5542 hooked: hooked_commands
5543 .contains(&LayerVulkanCommand::GetDeferredOperationMaxConcurrencyKhr),
5544 proc: unsafe {
5545 std::mem::transmute::<
5546 vk::PFN_vkGetDeferredOperationMaxConcurrencyKHR,
5547 vk::PFN_vkVoidFunction,
5548 >(Self::get_deferred_operation_max_concurrency_khr)
5549 },
5550 },
5551 VulkanCommand {
5552 name: "vkGetDeferredOperationResultKHR",
5553 features: smallvec![Feature::Extension(Extension::KHRDeferredHostOperations)],
5554 hooked: hooked_commands
5555 .contains(&LayerVulkanCommand::GetDeferredOperationResultKhr),
5556 proc: unsafe {
5557 std::mem::transmute::<
5558 vk::PFN_vkGetDeferredOperationResultKHR,
5559 vk::PFN_vkVoidFunction,
5560 >(Self::get_deferred_operation_result_khr)
5561 },
5562 },
5563 VulkanCommand {
5564 name: "vkGetDescriptorEXT",
5565 features: smallvec![Feature::Extension(Extension::EXTDescriptorBuffer)],
5566 hooked: hooked_commands.contains(&LayerVulkanCommand::GetDescriptorExt),
5567 proc: unsafe {
5568 std::mem::transmute::<vk::PFN_vkGetDescriptorEXT, vk::PFN_vkVoidFunction>(
5569 Self::get_descriptor_ext,
5570 )
5571 },
5572 },
5573 VulkanCommand {
5574 name: "vkGetDescriptorSetHostMappingVALVE",
5575 features: smallvec![Feature::Extension(Extension::VALVEDescriptorSetHostMapping)],
5576 hooked: hooked_commands
5577 .contains(&LayerVulkanCommand::GetDescriptorSetHostMappingValve),
5578 proc: unsafe {
5579 std::mem::transmute::<
5580 vk::PFN_vkGetDescriptorSetHostMappingVALVE,
5581 vk::PFN_vkVoidFunction,
5582 >(Self::get_descriptor_set_host_mapping_valve)
5583 },
5584 },
5585 VulkanCommand {
5586 name: "vkGetDescriptorSetLayoutBindingOffsetEXT",
5587 features: smallvec![Feature::Extension(Extension::EXTDescriptorBuffer)],
5588 hooked: hooked_commands
5589 .contains(&LayerVulkanCommand::GetDescriptorSetLayoutBindingOffsetExt),
5590 proc: unsafe {
5591 std::mem::transmute::<
5592 vk::PFN_vkGetDescriptorSetLayoutBindingOffsetEXT,
5593 vk::PFN_vkVoidFunction,
5594 >(Self::get_descriptor_set_layout_binding_offset_ext)
5595 },
5596 },
5597 VulkanCommand {
5598 name: "vkGetDescriptorSetLayoutHostMappingInfoVALVE",
5599 features: smallvec![Feature::Extension(Extension::VALVEDescriptorSetHostMapping)],
5600 hooked: hooked_commands
5601 .contains(&LayerVulkanCommand::GetDescriptorSetLayoutHostMappingInfoValve),
5602 proc: unsafe {
5603 std::mem::transmute::<
5604 vk::PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE,
5605 vk::PFN_vkVoidFunction,
5606 >(Self::get_descriptor_set_layout_host_mapping_info_valve)
5607 },
5608 },
5609 VulkanCommand {
5610 name: "vkGetDescriptorSetLayoutSizeEXT",
5611 features: smallvec![Feature::Extension(Extension::EXTDescriptorBuffer)],
5612 hooked: hooked_commands
5613 .contains(&LayerVulkanCommand::GetDescriptorSetLayoutSizeExt),
5614 proc: unsafe {
5615 std::mem::transmute::<
5616 vk::PFN_vkGetDescriptorSetLayoutSizeEXT,
5617 vk::PFN_vkVoidFunction,
5618 >(Self::get_descriptor_set_layout_size_ext)
5619 },
5620 },
5621 VulkanCommand {
5622 name: "vkGetDescriptorSetLayoutSupport",
5623 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 1 })],
5624 hooked: hooked_commands
5625 .contains(&LayerVulkanCommand::GetDescriptorSetLayoutSupport),
5626 proc: unsafe {
5627 std::mem::transmute::<
5628 vk::PFN_vkGetDescriptorSetLayoutSupport,
5629 vk::PFN_vkVoidFunction,
5630 >(Self::get_descriptor_set_layout_support)
5631 },
5632 },
5633 VulkanCommand {
5634 name: "vkGetDescriptorSetLayoutSupportKHR",
5635 features: smallvec![Feature::Extension(Extension::KHRMaintenance3)],
5636 hooked: hooked_commands
5637 .contains(&LayerVulkanCommand::GetDescriptorSetLayoutSupport),
5638 proc: unsafe {
5639 std::mem::transmute::<
5640 vk::PFN_vkGetDescriptorSetLayoutSupport,
5641 vk::PFN_vkVoidFunction,
5642 >(Self::get_descriptor_set_layout_support)
5643 },
5644 },
5645 VulkanCommand {
5646 name: "vkGetDeviceAccelerationStructureCompatibilityKHR",
5647 features: smallvec![Feature::Extension(Extension::KHRAccelerationStructure)],
5648 hooked: hooked_commands
5649 .contains(&LayerVulkanCommand::GetDeviceAccelerationStructureCompatibilityKhr),
5650 proc: unsafe {
5651 std::mem::transmute::<
5652 vk::PFN_vkGetDeviceAccelerationStructureCompatibilityKHR,
5653 vk::PFN_vkVoidFunction,
5654 >(Self::get_device_acceleration_structure_compatibility_khr)
5655 },
5656 },
5657 VulkanCommand {
5658 name: "vkGetDeviceBufferMemoryRequirements",
5659 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 3 })],
5660 hooked: hooked_commands
5661 .contains(&LayerVulkanCommand::GetDeviceBufferMemoryRequirements),
5662 proc: unsafe {
5663 std::mem::transmute::<
5664 vk::PFN_vkGetDeviceBufferMemoryRequirements,
5665 vk::PFN_vkVoidFunction,
5666 >(Self::get_device_buffer_memory_requirements)
5667 },
5668 },
5669 VulkanCommand {
5670 name: "vkGetDeviceBufferMemoryRequirementsKHR",
5671 features: smallvec![Feature::Extension(Extension::KHRMaintenance4)],
5672 hooked: hooked_commands
5673 .contains(&LayerVulkanCommand::GetDeviceBufferMemoryRequirements),
5674 proc: unsafe {
5675 std::mem::transmute::<
5676 vk::PFN_vkGetDeviceBufferMemoryRequirements,
5677 vk::PFN_vkVoidFunction,
5678 >(Self::get_device_buffer_memory_requirements)
5679 },
5680 },
5681 VulkanCommand {
5682 name: "vkGetDeviceGroupPeerMemoryFeatures",
5683 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 1 })],
5684 hooked: hooked_commands
5685 .contains(&LayerVulkanCommand::GetDeviceGroupPeerMemoryFeatures),
5686 proc: unsafe {
5687 std::mem::transmute::<
5688 vk::PFN_vkGetDeviceGroupPeerMemoryFeatures,
5689 vk::PFN_vkVoidFunction,
5690 >(Self::get_device_group_peer_memory_features)
5691 },
5692 },
5693 VulkanCommand {
5694 name: "vkGetDeviceGroupPeerMemoryFeaturesKHR",
5695 features: smallvec![Feature::Extension(Extension::KHRDeviceGroup)],
5696 hooked: hooked_commands
5697 .contains(&LayerVulkanCommand::GetDeviceGroupPeerMemoryFeatures),
5698 proc: unsafe {
5699 std::mem::transmute::<
5700 vk::PFN_vkGetDeviceGroupPeerMemoryFeatures,
5701 vk::PFN_vkVoidFunction,
5702 >(Self::get_device_group_peer_memory_features)
5703 },
5704 },
5705 VulkanCommand {
5706 name: "vkGetDeviceGroupPresentCapabilitiesKHR",
5707 features: smallvec![
5708 Feature::Extension(Extension::KHRSwapchain),
5709 Feature::Extension(Extension::KHRDeviceGroup)
5710 ],
5711 hooked: hooked_commands
5712 .contains(&LayerVulkanCommand::GetDeviceGroupPresentCapabilitiesKhr),
5713 proc: unsafe {
5714 std::mem::transmute::<
5715 vk::PFN_vkGetDeviceGroupPresentCapabilitiesKHR,
5716 vk::PFN_vkVoidFunction,
5717 >(Self::get_device_group_present_capabilities_khr)
5718 },
5719 },
5720 VulkanCommand {
5721 name: "vkGetDeviceGroupSurfacePresentModes2EXT",
5722 features: smallvec![Feature::Extension(Extension::EXTFullScreenExclusive)],
5723 hooked: hooked_commands
5724 .contains(&LayerVulkanCommand::GetDeviceGroupSurfacePresentModes2Ext),
5725 proc: unsafe {
5726 std::mem::transmute::<
5727 vk::PFN_vkGetDeviceGroupSurfacePresentModes2EXT,
5728 vk::PFN_vkVoidFunction,
5729 >(Self::get_device_group_surface_present_modes2_ext)
5730 },
5731 },
5732 VulkanCommand {
5733 name: "vkGetDeviceGroupSurfacePresentModesKHR",
5734 features: smallvec![
5735 Feature::Extension(Extension::KHRSwapchain),
5736 Feature::Extension(Extension::KHRDeviceGroup)
5737 ],
5738 hooked: hooked_commands
5739 .contains(&LayerVulkanCommand::GetDeviceGroupSurfacePresentModesKhr),
5740 proc: unsafe {
5741 std::mem::transmute::<
5742 vk::PFN_vkGetDeviceGroupSurfacePresentModesKHR,
5743 vk::PFN_vkVoidFunction,
5744 >(Self::get_device_group_surface_present_modes_khr)
5745 },
5746 },
5747 VulkanCommand {
5748 name: "vkGetDeviceImageMemoryRequirements",
5749 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 3 })],
5750 hooked: hooked_commands
5751 .contains(&LayerVulkanCommand::GetDeviceImageMemoryRequirements),
5752 proc: unsafe {
5753 std::mem::transmute::<
5754 vk::PFN_vkGetDeviceImageMemoryRequirements,
5755 vk::PFN_vkVoidFunction,
5756 >(Self::get_device_image_memory_requirements)
5757 },
5758 },
5759 VulkanCommand {
5760 name: "vkGetDeviceImageMemoryRequirementsKHR",
5761 features: smallvec![Feature::Extension(Extension::KHRMaintenance4)],
5762 hooked: hooked_commands
5763 .contains(&LayerVulkanCommand::GetDeviceImageMemoryRequirements),
5764 proc: unsafe {
5765 std::mem::transmute::<
5766 vk::PFN_vkGetDeviceImageMemoryRequirements,
5767 vk::PFN_vkVoidFunction,
5768 >(Self::get_device_image_memory_requirements)
5769 },
5770 },
5771 VulkanCommand {
5772 name: "vkGetDeviceImageSparseMemoryRequirements",
5773 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 3 })],
5774 hooked: hooked_commands
5775 .contains(&LayerVulkanCommand::GetDeviceImageSparseMemoryRequirements),
5776 proc: unsafe {
5777 std::mem::transmute::<
5778 vk::PFN_vkGetDeviceImageSparseMemoryRequirements,
5779 vk::PFN_vkVoidFunction,
5780 >(Self::get_device_image_sparse_memory_requirements)
5781 },
5782 },
5783 VulkanCommand {
5784 name: "vkGetDeviceImageSparseMemoryRequirementsKHR",
5785 features: smallvec![Feature::Extension(Extension::KHRMaintenance4)],
5786 hooked: hooked_commands
5787 .contains(&LayerVulkanCommand::GetDeviceImageSparseMemoryRequirements),
5788 proc: unsafe {
5789 std::mem::transmute::<
5790 vk::PFN_vkGetDeviceImageSparseMemoryRequirements,
5791 vk::PFN_vkVoidFunction,
5792 >(Self::get_device_image_sparse_memory_requirements)
5793 },
5794 },
5795 VulkanCommand {
5796 name: "vkGetDeviceMemoryCommitment",
5797 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
5798 hooked: hooked_commands.contains(&LayerVulkanCommand::GetDeviceMemoryCommitment),
5799 proc: unsafe {
5800 std::mem::transmute::<vk::PFN_vkGetDeviceMemoryCommitment, vk::PFN_vkVoidFunction>(
5801 Self::get_device_memory_commitment,
5802 )
5803 },
5804 },
5805 VulkanCommand {
5806 name: "vkGetDeviceMemoryOpaqueCaptureAddress",
5807 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 2 })],
5808 hooked: hooked_commands
5809 .contains(&LayerVulkanCommand::GetDeviceMemoryOpaqueCaptureAddress),
5810 proc: unsafe {
5811 std::mem::transmute::<
5812 vk::PFN_vkGetDeviceMemoryOpaqueCaptureAddress,
5813 vk::PFN_vkVoidFunction,
5814 >(Self::get_device_memory_opaque_capture_address)
5815 },
5816 },
5817 VulkanCommand {
5818 name: "vkGetDeviceMemoryOpaqueCaptureAddressKHR",
5819 features: smallvec![Feature::Extension(Extension::KHRBufferDeviceAddress)],
5820 hooked: hooked_commands
5821 .contains(&LayerVulkanCommand::GetDeviceMemoryOpaqueCaptureAddress),
5822 proc: unsafe {
5823 std::mem::transmute::<
5824 vk::PFN_vkGetDeviceMemoryOpaqueCaptureAddress,
5825 vk::PFN_vkVoidFunction,
5826 >(Self::get_device_memory_opaque_capture_address)
5827 },
5828 },
5829 VulkanCommand {
5830 name: "vkGetDeviceMicromapCompatibilityEXT",
5831 features: smallvec![Feature::Extension(Extension::EXTOpacityMicromap)],
5832 hooked: hooked_commands
5833 .contains(&LayerVulkanCommand::GetDeviceMicromapCompatibilityExt),
5834 proc: unsafe {
5835 std::mem::transmute::<
5836 vk::PFN_vkGetDeviceMicromapCompatibilityEXT,
5837 vk::PFN_vkVoidFunction,
5838 >(Self::get_device_micromap_compatibility_ext)
5839 },
5840 },
5841 VulkanCommand {
5842 name: "vkGetDeviceProcAddr",
5843 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
5844 hooked: true,
5845 proc: unsafe {
5846 std::mem::transmute::<vk::PFN_vkGetDeviceProcAddr, vk::PFN_vkVoidFunction>(
5847 Self::get_device_proc_addr,
5848 )
5849 },
5850 },
5851 VulkanCommand {
5852 name: "vkGetDeviceQueue",
5853 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
5854 hooked: hooked_commands.contains(&LayerVulkanCommand::GetDeviceQueue),
5855 proc: unsafe {
5856 std::mem::transmute::<vk::PFN_vkGetDeviceQueue, vk::PFN_vkVoidFunction>(
5857 Self::get_device_queue,
5858 )
5859 },
5860 },
5861 VulkanCommand {
5862 name: "vkGetDeviceQueue2",
5863 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 1 })],
5864 hooked: hooked_commands.contains(&LayerVulkanCommand::GetDeviceQueue2),
5865 proc: unsafe {
5866 std::mem::transmute::<vk::PFN_vkGetDeviceQueue2, vk::PFN_vkVoidFunction>(
5867 Self::get_device_queue2,
5868 )
5869 },
5870 },
5871 VulkanCommand {
5872 name: "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI",
5873 features: smallvec![Feature::Extension(Extension::HUAWEISubpassShading)],
5874 hooked: hooked_commands
5875 .contains(&LayerVulkanCommand::GetDeviceSubpassShadingMaxWorkgroupSizeHuawei),
5876 proc: unsafe {
5877 std::mem::transmute::<
5878 vk::PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI,
5879 vk::PFN_vkVoidFunction,
5880 >(Self::get_device_subpass_shading_max_workgroup_size_huawei)
5881 },
5882 },
5883 VulkanCommand {
5884 name: "vkGetDynamicRenderingTilePropertiesQCOM",
5885 features: smallvec![Feature::Extension(Extension::QCOMTileProperties)],
5886 hooked: hooked_commands
5887 .contains(&LayerVulkanCommand::GetDynamicRenderingTilePropertiesQcom),
5888 proc: unsafe {
5889 std::mem::transmute::<
5890 vk::PFN_vkGetDynamicRenderingTilePropertiesQCOM,
5891 vk::PFN_vkVoidFunction,
5892 >(Self::get_dynamic_rendering_tile_properties_qcom)
5893 },
5894 },
5895 VulkanCommand {
5896 name: "vkGetEventStatus",
5897 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
5898 hooked: hooked_commands.contains(&LayerVulkanCommand::GetEventStatus),
5899 proc: unsafe {
5900 std::mem::transmute::<vk::PFN_vkGetEventStatus, vk::PFN_vkVoidFunction>(
5901 Self::get_event_status,
5902 )
5903 },
5904 },
5905 VulkanCommand {
5906 name: "vkGetFenceFdKHR",
5907 features: smallvec![Feature::Extension(Extension::KHRExternalFenceFd)],
5908 hooked: hooked_commands.contains(&LayerVulkanCommand::GetFenceFdKhr),
5909 proc: unsafe {
5910 std::mem::transmute::<vk::PFN_vkGetFenceFdKHR, vk::PFN_vkVoidFunction>(
5911 Self::get_fence_fd_khr,
5912 )
5913 },
5914 },
5915 VulkanCommand {
5916 name: "vkGetFenceStatus",
5917 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
5918 hooked: hooked_commands.contains(&LayerVulkanCommand::GetFenceStatus),
5919 proc: unsafe {
5920 std::mem::transmute::<vk::PFN_vkGetFenceStatus, vk::PFN_vkVoidFunction>(
5921 Self::get_fence_status,
5922 )
5923 },
5924 },
5925 VulkanCommand {
5926 name: "vkGetFenceWin32HandleKHR",
5927 features: smallvec![Feature::Extension(Extension::KHRExternalFenceWin32)],
5928 hooked: hooked_commands.contains(&LayerVulkanCommand::GetFenceWin32HandleKhr),
5929 proc: unsafe {
5930 std::mem::transmute::<vk::PFN_vkGetFenceWin32HandleKHR, vk::PFN_vkVoidFunction>(
5931 Self::get_fence_win32_handle_khr,
5932 )
5933 },
5934 },
5935 VulkanCommand {
5936 name: "vkGetFramebufferTilePropertiesQCOM",
5937 features: smallvec![Feature::Extension(Extension::QCOMTileProperties)],
5938 hooked: hooked_commands
5939 .contains(&LayerVulkanCommand::GetFramebufferTilePropertiesQcom),
5940 proc: unsafe {
5941 std::mem::transmute::<
5942 vk::PFN_vkGetFramebufferTilePropertiesQCOM,
5943 vk::PFN_vkVoidFunction,
5944 >(Self::get_framebuffer_tile_properties_qcom)
5945 },
5946 },
5947 VulkanCommand {
5948 name: "vkGetGeneratedCommandsMemoryRequirementsNV",
5949 features: smallvec![Feature::Extension(Extension::NVDeviceGeneratedCommands)],
5950 hooked: hooked_commands
5951 .contains(&LayerVulkanCommand::GetGeneratedCommandsMemoryRequirementsNv),
5952 proc: unsafe {
5953 std::mem::transmute::<
5954 vk::PFN_vkGetGeneratedCommandsMemoryRequirementsNV,
5955 vk::PFN_vkVoidFunction,
5956 >(Self::get_generated_commands_memory_requirements_nv)
5957 },
5958 },
5959 VulkanCommand {
5960 name: "vkGetImageDrmFormatModifierPropertiesEXT",
5961 features: smallvec![Feature::Extension(Extension::EXTImageDrmFormatModifier)],
5962 hooked: hooked_commands
5963 .contains(&LayerVulkanCommand::GetImageDrmFormatModifierPropertiesExt),
5964 proc: unsafe {
5965 std::mem::transmute::<
5966 vk::PFN_vkGetImageDrmFormatModifierPropertiesEXT,
5967 vk::PFN_vkVoidFunction,
5968 >(Self::get_image_drm_format_modifier_properties_ext)
5969 },
5970 },
5971 VulkanCommand {
5972 name: "vkGetImageMemoryRequirements",
5973 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
5974 hooked: hooked_commands.contains(&LayerVulkanCommand::GetImageMemoryRequirements),
5975 proc: unsafe {
5976 std::mem::transmute::<
5977 vk::PFN_vkGetImageMemoryRequirements,
5978 vk::PFN_vkVoidFunction,
5979 >(Self::get_image_memory_requirements)
5980 },
5981 },
5982 VulkanCommand {
5983 name: "vkGetImageMemoryRequirements2",
5984 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 1 })],
5985 hooked: hooked_commands.contains(&LayerVulkanCommand::GetImageMemoryRequirements2),
5986 proc: unsafe {
5987 std::mem::transmute::<
5988 vk::PFN_vkGetImageMemoryRequirements2,
5989 vk::PFN_vkVoidFunction,
5990 >(Self::get_image_memory_requirements2)
5991 },
5992 },
5993 VulkanCommand {
5994 name: "vkGetImageMemoryRequirements2KHR",
5995 features: smallvec![Feature::Extension(Extension::KHRGetMemoryRequirements2)],
5996 hooked: hooked_commands.contains(&LayerVulkanCommand::GetImageMemoryRequirements2),
5997 proc: unsafe {
5998 std::mem::transmute::<
5999 vk::PFN_vkGetImageMemoryRequirements2,
6000 vk::PFN_vkVoidFunction,
6001 >(Self::get_image_memory_requirements2)
6002 },
6003 },
6004 VulkanCommand {
6005 name: "vkGetImageOpaqueCaptureDescriptorDataEXT",
6006 features: smallvec![Feature::Extension(Extension::EXTDescriptorBuffer)],
6007 hooked: hooked_commands
6008 .contains(&LayerVulkanCommand::GetImageOpaqueCaptureDescriptorDataExt),
6009 proc: unsafe {
6010 std::mem::transmute::<
6011 vk::PFN_vkGetImageOpaqueCaptureDescriptorDataEXT,
6012 vk::PFN_vkVoidFunction,
6013 >(Self::get_image_opaque_capture_descriptor_data_ext)
6014 },
6015 },
6016 VulkanCommand {
6017 name: "vkGetImageSparseMemoryRequirements",
6018 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
6019 hooked: hooked_commands
6020 .contains(&LayerVulkanCommand::GetImageSparseMemoryRequirements),
6021 proc: unsafe {
6022 std::mem::transmute::<
6023 vk::PFN_vkGetImageSparseMemoryRequirements,
6024 vk::PFN_vkVoidFunction,
6025 >(Self::get_image_sparse_memory_requirements)
6026 },
6027 },
6028 VulkanCommand {
6029 name: "vkGetImageSparseMemoryRequirements2",
6030 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 1 })],
6031 hooked: hooked_commands
6032 .contains(&LayerVulkanCommand::GetImageSparseMemoryRequirements2),
6033 proc: unsafe {
6034 std::mem::transmute::<
6035 vk::PFN_vkGetImageSparseMemoryRequirements2,
6036 vk::PFN_vkVoidFunction,
6037 >(Self::get_image_sparse_memory_requirements2)
6038 },
6039 },
6040 VulkanCommand {
6041 name: "vkGetImageSparseMemoryRequirements2KHR",
6042 features: smallvec![Feature::Extension(Extension::KHRGetMemoryRequirements2)],
6043 hooked: hooked_commands
6044 .contains(&LayerVulkanCommand::GetImageSparseMemoryRequirements2),
6045 proc: unsafe {
6046 std::mem::transmute::<
6047 vk::PFN_vkGetImageSparseMemoryRequirements2,
6048 vk::PFN_vkVoidFunction,
6049 >(Self::get_image_sparse_memory_requirements2)
6050 },
6051 },
6052 VulkanCommand {
6053 name: "vkGetImageSubresourceLayout",
6054 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
6055 hooked: hooked_commands.contains(&LayerVulkanCommand::GetImageSubresourceLayout),
6056 proc: unsafe {
6057 std::mem::transmute::<vk::PFN_vkGetImageSubresourceLayout, vk::PFN_vkVoidFunction>(
6058 Self::get_image_subresource_layout,
6059 )
6060 },
6061 },
6062 VulkanCommand {
6063 name: "vkGetImageSubresourceLayout2EXT",
6064 features: smallvec![Feature::Extension(Extension::EXTImageCompressionControl)],
6065 hooked: hooked_commands
6066 .contains(&LayerVulkanCommand::GetImageSubresourceLayout2Ext),
6067 proc: unsafe {
6068 std::mem::transmute::<
6069 vk::PFN_vkGetImageSubresourceLayout2EXT,
6070 vk::PFN_vkVoidFunction,
6071 >(Self::get_image_subresource_layout2_ext)
6072 },
6073 },
6074 VulkanCommand {
6075 name: "vkGetImageViewAddressNVX",
6076 features: smallvec![Feature::Extension(Extension::NVXImageViewHandle)],
6077 hooked: hooked_commands.contains(&LayerVulkanCommand::GetImageViewAddressNvx),
6078 proc: unsafe {
6079 std::mem::transmute::<vk::PFN_vkGetImageViewAddressNVX, vk::PFN_vkVoidFunction>(
6080 Self::get_image_view_address_nvx,
6081 )
6082 },
6083 },
6084 VulkanCommand {
6085 name: "vkGetImageViewHandleNVX",
6086 features: smallvec![Feature::Extension(Extension::NVXImageViewHandle)],
6087 hooked: hooked_commands.contains(&LayerVulkanCommand::GetImageViewHandleNvx),
6088 proc: unsafe {
6089 std::mem::transmute::<vk::PFN_vkGetImageViewHandleNVX, vk::PFN_vkVoidFunction>(
6090 Self::get_image_view_handle_nvx,
6091 )
6092 },
6093 },
6094 VulkanCommand {
6095 name: "vkGetImageViewOpaqueCaptureDescriptorDataEXT",
6096 features: smallvec![Feature::Extension(Extension::EXTDescriptorBuffer)],
6097 hooked: hooked_commands
6098 .contains(&LayerVulkanCommand::GetImageViewOpaqueCaptureDescriptorDataExt),
6099 proc: unsafe {
6100 std::mem::transmute::<
6101 vk::PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT,
6102 vk::PFN_vkVoidFunction,
6103 >(Self::get_image_view_opaque_capture_descriptor_data_ext)
6104 },
6105 },
6106 VulkanCommand {
6107 name: "vkGetMemoryAndroidHardwareBufferANDROID",
6108 features: smallvec![Feature::Extension(
6109 Extension::ANDROIDExternalMemoryAndroidHardwareBuffer
6110 )],
6111 hooked: hooked_commands
6112 .contains(&LayerVulkanCommand::GetMemoryAndroidHardwareBufferAndroid),
6113 proc: unsafe {
6114 std::mem::transmute::<
6115 vk::PFN_vkGetMemoryAndroidHardwareBufferANDROID,
6116 vk::PFN_vkVoidFunction,
6117 >(Self::get_memory_android_hardware_buffer_android)
6118 },
6119 },
6120 VulkanCommand {
6121 name: "vkGetMemoryFdKHR",
6122 features: smallvec![Feature::Extension(Extension::KHRExternalMemoryFd)],
6123 hooked: hooked_commands.contains(&LayerVulkanCommand::GetMemoryFdKhr),
6124 proc: unsafe {
6125 std::mem::transmute::<vk::PFN_vkGetMemoryFdKHR, vk::PFN_vkVoidFunction>(
6126 Self::get_memory_fd_khr,
6127 )
6128 },
6129 },
6130 VulkanCommand {
6131 name: "vkGetMemoryFdPropertiesKHR",
6132 features: smallvec![Feature::Extension(Extension::KHRExternalMemoryFd)],
6133 hooked: hooked_commands.contains(&LayerVulkanCommand::GetMemoryFdPropertiesKhr),
6134 proc: unsafe {
6135 std::mem::transmute::<vk::PFN_vkGetMemoryFdPropertiesKHR, vk::PFN_vkVoidFunction>(
6136 Self::get_memory_fd_properties_khr,
6137 )
6138 },
6139 },
6140 VulkanCommand {
6141 name: "vkGetMemoryHostPointerPropertiesEXT",
6142 features: smallvec![Feature::Extension(Extension::EXTExternalMemoryHost)],
6143 hooked: hooked_commands
6144 .contains(&LayerVulkanCommand::GetMemoryHostPointerPropertiesExt),
6145 proc: unsafe {
6146 std::mem::transmute::<
6147 vk::PFN_vkGetMemoryHostPointerPropertiesEXT,
6148 vk::PFN_vkVoidFunction,
6149 >(Self::get_memory_host_pointer_properties_ext)
6150 },
6151 },
6152 VulkanCommand {
6153 name: "vkGetMemoryRemoteAddressNV",
6154 features: smallvec![Feature::Extension(Extension::NVExternalMemoryRdma)],
6155 hooked: hooked_commands.contains(&LayerVulkanCommand::GetMemoryRemoteAddressNv),
6156 proc: unsafe {
6157 std::mem::transmute::<vk::PFN_vkGetMemoryRemoteAddressNV, vk::PFN_vkVoidFunction>(
6158 Self::get_memory_remote_address_nv,
6159 )
6160 },
6161 },
6162 VulkanCommand {
6163 name: "vkGetMemoryWin32HandleKHR",
6164 features: smallvec![Feature::Extension(Extension::KHRExternalMemoryWin32)],
6165 hooked: hooked_commands.contains(&LayerVulkanCommand::GetMemoryWin32HandleKhr),
6166 proc: unsafe {
6167 std::mem::transmute::<vk::PFN_vkGetMemoryWin32HandleKHR, vk::PFN_vkVoidFunction>(
6168 Self::get_memory_win32_handle_khr,
6169 )
6170 },
6171 },
6172 VulkanCommand {
6173 name: "vkGetMemoryWin32HandleNV",
6174 features: smallvec![Feature::Extension(Extension::NVExternalMemoryWin32)],
6175 hooked: hooked_commands.contains(&LayerVulkanCommand::GetMemoryWin32HandleNv),
6176 proc: unsafe {
6177 std::mem::transmute::<vk::PFN_vkGetMemoryWin32HandleNV, vk::PFN_vkVoidFunction>(
6178 Self::get_memory_win32_handle_nv,
6179 )
6180 },
6181 },
6182 VulkanCommand {
6183 name: "vkGetMemoryWin32HandlePropertiesKHR",
6184 features: smallvec![Feature::Extension(Extension::KHRExternalMemoryWin32)],
6185 hooked: hooked_commands
6186 .contains(&LayerVulkanCommand::GetMemoryWin32HandlePropertiesKhr),
6187 proc: unsafe {
6188 std::mem::transmute::<
6189 vk::PFN_vkGetMemoryWin32HandlePropertiesKHR,
6190 vk::PFN_vkVoidFunction,
6191 >(Self::get_memory_win32_handle_properties_khr)
6192 },
6193 },
6194 VulkanCommand {
6195 name: "vkGetMemoryZirconHandleFUCHSIA",
6196 features: smallvec![Feature::Extension(Extension::FUCHSIAExternalMemory)],
6197 hooked: hooked_commands.contains(&LayerVulkanCommand::GetMemoryZirconHandleFuchsia),
6198 proc: unsafe {
6199 std::mem::transmute::<
6200 vk::PFN_vkGetMemoryZirconHandleFUCHSIA,
6201 vk::PFN_vkVoidFunction,
6202 >(Self::get_memory_zircon_handle_fuchsia)
6203 },
6204 },
6205 VulkanCommand {
6206 name: "vkGetMemoryZirconHandlePropertiesFUCHSIA",
6207 features: smallvec![Feature::Extension(Extension::FUCHSIAExternalMemory)],
6208 hooked: hooked_commands
6209 .contains(&LayerVulkanCommand::GetMemoryZirconHandlePropertiesFuchsia),
6210 proc: unsafe {
6211 std::mem::transmute::<
6212 vk::PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA,
6213 vk::PFN_vkVoidFunction,
6214 >(Self::get_memory_zircon_handle_properties_fuchsia)
6215 },
6216 },
6217 VulkanCommand {
6218 name: "vkGetMicromapBuildSizesEXT",
6219 features: smallvec![Feature::Extension(Extension::EXTOpacityMicromap)],
6220 hooked: hooked_commands.contains(&LayerVulkanCommand::GetMicromapBuildSizesExt),
6221 proc: unsafe {
6222 std::mem::transmute::<vk::PFN_vkGetMicromapBuildSizesEXT, vk::PFN_vkVoidFunction>(
6223 Self::get_micromap_build_sizes_ext,
6224 )
6225 },
6226 },
6227 VulkanCommand {
6228 name: "vkGetPastPresentationTimingGOOGLE",
6229 features: smallvec![Feature::Extension(Extension::GOOGLEDisplayTiming)],
6230 hooked: hooked_commands
6231 .contains(&LayerVulkanCommand::GetPastPresentationTimingGoogle),
6232 proc: unsafe {
6233 std::mem::transmute::<
6234 vk::PFN_vkGetPastPresentationTimingGOOGLE,
6235 vk::PFN_vkVoidFunction,
6236 >(Self::get_past_presentation_timing_google)
6237 },
6238 },
6239 VulkanCommand {
6240 name: "vkGetPerformanceParameterINTEL",
6241 features: smallvec![Feature::Extension(Extension::INTELPerformanceQuery)],
6242 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPerformanceParameterIntel),
6243 proc: unsafe {
6244 std::mem::transmute::<
6245 vk::PFN_vkGetPerformanceParameterINTEL,
6246 vk::PFN_vkVoidFunction,
6247 >(Self::get_performance_parameter_intel)
6248 },
6249 },
6250 VulkanCommand {
6251 name: "vkGetPipelineCacheData",
6252 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
6253 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPipelineCacheData),
6254 proc: unsafe {
6255 std::mem::transmute::<vk::PFN_vkGetPipelineCacheData, vk::PFN_vkVoidFunction>(
6256 Self::get_pipeline_cache_data,
6257 )
6258 },
6259 },
6260 VulkanCommand {
6261 name: "vkGetPipelineExecutableInternalRepresentationsKHR",
6262 features: smallvec![Feature::Extension(
6263 Extension::KHRPipelineExecutableProperties
6264 )],
6265 hooked: hooked_commands
6266 .contains(&LayerVulkanCommand::GetPipelineExecutableInternalRepresentationsKhr),
6267 proc: unsafe {
6268 std::mem::transmute::<
6269 vk::PFN_vkGetPipelineExecutableInternalRepresentationsKHR,
6270 vk::PFN_vkVoidFunction,
6271 >(Self::get_pipeline_executable_internal_representations_khr)
6272 },
6273 },
6274 VulkanCommand {
6275 name: "vkGetPipelineExecutablePropertiesKHR",
6276 features: smallvec![Feature::Extension(
6277 Extension::KHRPipelineExecutableProperties
6278 )],
6279 hooked: hooked_commands
6280 .contains(&LayerVulkanCommand::GetPipelineExecutablePropertiesKhr),
6281 proc: unsafe {
6282 std::mem::transmute::<
6283 vk::PFN_vkGetPipelineExecutablePropertiesKHR,
6284 vk::PFN_vkVoidFunction,
6285 >(Self::get_pipeline_executable_properties_khr)
6286 },
6287 },
6288 VulkanCommand {
6289 name: "vkGetPipelineExecutableStatisticsKHR",
6290 features: smallvec![Feature::Extension(
6291 Extension::KHRPipelineExecutableProperties
6292 )],
6293 hooked: hooked_commands
6294 .contains(&LayerVulkanCommand::GetPipelineExecutableStatisticsKhr),
6295 proc: unsafe {
6296 std::mem::transmute::<
6297 vk::PFN_vkGetPipelineExecutableStatisticsKHR,
6298 vk::PFN_vkVoidFunction,
6299 >(Self::get_pipeline_executable_statistics_khr)
6300 },
6301 },
6302 VulkanCommand {
6303 name: "vkGetPipelinePropertiesEXT",
6304 features: smallvec![Feature::Extension(Extension::EXTPipelineProperties)],
6305 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPipelinePropertiesExt),
6306 proc: unsafe {
6307 std::mem::transmute::<vk::PFN_vkGetPipelinePropertiesEXT, vk::PFN_vkVoidFunction>(
6308 Self::get_pipeline_properties_ext,
6309 )
6310 },
6311 },
6312 VulkanCommand {
6313 name: "vkGetPrivateData",
6314 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 3 })],
6315 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPrivateData),
6316 proc: unsafe {
6317 std::mem::transmute::<vk::PFN_vkGetPrivateData, vk::PFN_vkVoidFunction>(
6318 Self::get_private_data,
6319 )
6320 },
6321 },
6322 VulkanCommand {
6323 name: "vkGetPrivateDataEXT",
6324 features: smallvec![Feature::Extension(Extension::EXTPrivateData)],
6325 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPrivateData),
6326 proc: unsafe {
6327 std::mem::transmute::<vk::PFN_vkGetPrivateData, vk::PFN_vkVoidFunction>(
6328 Self::get_private_data,
6329 )
6330 },
6331 },
6332 VulkanCommand {
6333 name: "vkGetQueryPoolResults",
6334 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
6335 hooked: hooked_commands.contains(&LayerVulkanCommand::GetQueryPoolResults),
6336 proc: unsafe {
6337 std::mem::transmute::<vk::PFN_vkGetQueryPoolResults, vk::PFN_vkVoidFunction>(
6338 Self::get_query_pool_results,
6339 )
6340 },
6341 },
6342 VulkanCommand {
6343 name: "vkGetQueueCheckpointData2NV",
6344 features: smallvec![Feature::Extension(Extension::KHRSynchronization2)],
6345 hooked: hooked_commands.contains(&LayerVulkanCommand::GetQueueCheckpointData2Nv),
6346 proc: unsafe {
6347 std::mem::transmute::<vk::PFN_vkGetQueueCheckpointData2NV, vk::PFN_vkVoidFunction>(
6348 Self::get_queue_checkpoint_data2_nv,
6349 )
6350 },
6351 },
6352 VulkanCommand {
6353 name: "vkGetQueueCheckpointDataNV",
6354 features: smallvec![Feature::Extension(Extension::NVDeviceDiagnosticCheckpoints)],
6355 hooked: hooked_commands.contains(&LayerVulkanCommand::GetQueueCheckpointDataNv),
6356 proc: unsafe {
6357 std::mem::transmute::<vk::PFN_vkGetQueueCheckpointDataNV, vk::PFN_vkVoidFunction>(
6358 Self::get_queue_checkpoint_data_nv,
6359 )
6360 },
6361 },
6362 VulkanCommand {
6363 name: "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR",
6364 features: smallvec![Feature::Extension(Extension::KHRRayTracingPipeline)],
6365 hooked: hooked_commands
6366 .contains(&LayerVulkanCommand::GetRayTracingCaptureReplayShaderGroupHandlesKhr),
6367 proc: unsafe {
6368 std::mem::transmute::<
6369 vk::PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR,
6370 vk::PFN_vkVoidFunction,
6371 >(
6372 Self::get_ray_tracing_capture_replay_shader_group_handles_khr
6373 )
6374 },
6375 },
6376 VulkanCommand {
6377 name: "vkGetRayTracingShaderGroupHandlesKHR",
6378 features: smallvec![Feature::Extension(Extension::KHRRayTracingPipeline)],
6379 hooked: hooked_commands
6380 .contains(&LayerVulkanCommand::GetRayTracingShaderGroupHandlesKhr),
6381 proc: unsafe {
6382 std::mem::transmute::<
6383 vk::PFN_vkGetRayTracingShaderGroupHandlesKHR,
6384 vk::PFN_vkVoidFunction,
6385 >(Self::get_ray_tracing_shader_group_handles_khr)
6386 },
6387 },
6388 VulkanCommand {
6389 name: "vkGetRayTracingShaderGroupHandlesNV",
6390 features: smallvec![Feature::Extension(Extension::NVRayTracing)],
6391 hooked: hooked_commands
6392 .contains(&LayerVulkanCommand::GetRayTracingShaderGroupHandlesKhr),
6393 proc: unsafe {
6394 std::mem::transmute::<
6395 vk::PFN_vkGetRayTracingShaderGroupHandlesKHR,
6396 vk::PFN_vkVoidFunction,
6397 >(Self::get_ray_tracing_shader_group_handles_khr)
6398 },
6399 },
6400 VulkanCommand {
6401 name: "vkGetRayTracingShaderGroupStackSizeKHR",
6402 features: smallvec![Feature::Extension(Extension::KHRRayTracingPipeline)],
6403 hooked: hooked_commands
6404 .contains(&LayerVulkanCommand::GetRayTracingShaderGroupStackSizeKhr),
6405 proc: unsafe {
6406 std::mem::transmute::<
6407 vk::PFN_vkGetRayTracingShaderGroupStackSizeKHR,
6408 vk::PFN_vkVoidFunction,
6409 >(Self::get_ray_tracing_shader_group_stack_size_khr)
6410 },
6411 },
6412 VulkanCommand {
6413 name: "vkGetRefreshCycleDurationGOOGLE",
6414 features: smallvec![Feature::Extension(Extension::GOOGLEDisplayTiming)],
6415 hooked: hooked_commands
6416 .contains(&LayerVulkanCommand::GetRefreshCycleDurationGoogle),
6417 proc: unsafe {
6418 std::mem::transmute::<
6419 vk::PFN_vkGetRefreshCycleDurationGOOGLE,
6420 vk::PFN_vkVoidFunction,
6421 >(Self::get_refresh_cycle_duration_google)
6422 },
6423 },
6424 VulkanCommand {
6425 name: "vkGetRenderAreaGranularity",
6426 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
6427 hooked: hooked_commands.contains(&LayerVulkanCommand::GetRenderAreaGranularity),
6428 proc: unsafe {
6429 std::mem::transmute::<vk::PFN_vkGetRenderAreaGranularity, vk::PFN_vkVoidFunction>(
6430 Self::get_render_area_granularity,
6431 )
6432 },
6433 },
6434 VulkanCommand {
6435 name: "vkGetSamplerOpaqueCaptureDescriptorDataEXT",
6436 features: smallvec![Feature::Extension(Extension::EXTDescriptorBuffer)],
6437 hooked: hooked_commands
6438 .contains(&LayerVulkanCommand::GetSamplerOpaqueCaptureDescriptorDataExt),
6439 proc: unsafe {
6440 std::mem::transmute::<
6441 vk::PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT,
6442 vk::PFN_vkVoidFunction,
6443 >(Self::get_sampler_opaque_capture_descriptor_data_ext)
6444 },
6445 },
6446 VulkanCommand {
6447 name: "vkGetSemaphoreCounterValue",
6448 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 2 })],
6449 hooked: hooked_commands.contains(&LayerVulkanCommand::GetSemaphoreCounterValue),
6450 proc: unsafe {
6451 std::mem::transmute::<vk::PFN_vkGetSemaphoreCounterValue, vk::PFN_vkVoidFunction>(
6452 Self::get_semaphore_counter_value,
6453 )
6454 },
6455 },
6456 VulkanCommand {
6457 name: "vkGetSemaphoreCounterValueKHR",
6458 features: smallvec![Feature::Extension(Extension::KHRTimelineSemaphore)],
6459 hooked: hooked_commands.contains(&LayerVulkanCommand::GetSemaphoreCounterValue),
6460 proc: unsafe {
6461 std::mem::transmute::<vk::PFN_vkGetSemaphoreCounterValue, vk::PFN_vkVoidFunction>(
6462 Self::get_semaphore_counter_value,
6463 )
6464 },
6465 },
6466 VulkanCommand {
6467 name: "vkGetSemaphoreFdKHR",
6468 features: smallvec![Feature::Extension(Extension::KHRExternalSemaphoreFd)],
6469 hooked: hooked_commands.contains(&LayerVulkanCommand::GetSemaphoreFdKhr),
6470 proc: unsafe {
6471 std::mem::transmute::<vk::PFN_vkGetSemaphoreFdKHR, vk::PFN_vkVoidFunction>(
6472 Self::get_semaphore_fd_khr,
6473 )
6474 },
6475 },
6476 VulkanCommand {
6477 name: "vkGetSemaphoreWin32HandleKHR",
6478 features: smallvec![Feature::Extension(Extension::KHRExternalSemaphoreWin32)],
6479 hooked: hooked_commands.contains(&LayerVulkanCommand::GetSemaphoreWin32HandleKhr),
6480 proc: unsafe {
6481 std::mem::transmute::<
6482 vk::PFN_vkGetSemaphoreWin32HandleKHR,
6483 vk::PFN_vkVoidFunction,
6484 >(Self::get_semaphore_win32_handle_khr)
6485 },
6486 },
6487 VulkanCommand {
6488 name: "vkGetSemaphoreZirconHandleFUCHSIA",
6489 features: smallvec![Feature::Extension(Extension::FUCHSIAExternalSemaphore)],
6490 hooked: hooked_commands
6491 .contains(&LayerVulkanCommand::GetSemaphoreZirconHandleFuchsia),
6492 proc: unsafe {
6493 std::mem::transmute::<
6494 vk::PFN_vkGetSemaphoreZirconHandleFUCHSIA,
6495 vk::PFN_vkVoidFunction,
6496 >(Self::get_semaphore_zircon_handle_fuchsia)
6497 },
6498 },
6499 VulkanCommand {
6500 name: "vkGetShaderInfoAMD",
6501 features: smallvec![Feature::Extension(Extension::AMDShaderInfo)],
6502 hooked: hooked_commands.contains(&LayerVulkanCommand::GetShaderInfoAmd),
6503 proc: unsafe {
6504 std::mem::transmute::<vk::PFN_vkGetShaderInfoAMD, vk::PFN_vkVoidFunction>(
6505 Self::get_shader_info_amd,
6506 )
6507 },
6508 },
6509 VulkanCommand {
6510 name: "vkGetShaderModuleCreateInfoIdentifierEXT",
6511 features: smallvec![Feature::Extension(Extension::EXTShaderModuleIdentifier)],
6512 hooked: hooked_commands
6513 .contains(&LayerVulkanCommand::GetShaderModuleCreateInfoIdentifierExt),
6514 proc: unsafe {
6515 std::mem::transmute::<
6516 vk::PFN_vkGetShaderModuleCreateInfoIdentifierEXT,
6517 vk::PFN_vkVoidFunction,
6518 >(Self::get_shader_module_create_info_identifier_ext)
6519 },
6520 },
6521 VulkanCommand {
6522 name: "vkGetShaderModuleIdentifierEXT",
6523 features: smallvec![Feature::Extension(Extension::EXTShaderModuleIdentifier)],
6524 hooked: hooked_commands.contains(&LayerVulkanCommand::GetShaderModuleIdentifierExt),
6525 proc: unsafe {
6526 std::mem::transmute::<
6527 vk::PFN_vkGetShaderModuleIdentifierEXT,
6528 vk::PFN_vkVoidFunction,
6529 >(Self::get_shader_module_identifier_ext)
6530 },
6531 },
6532 VulkanCommand {
6533 name: "vkGetSwapchainCounterEXT",
6534 features: smallvec![Feature::Extension(Extension::EXTDisplayControl)],
6535 hooked: hooked_commands.contains(&LayerVulkanCommand::GetSwapchainCounterExt),
6536 proc: unsafe {
6537 std::mem::transmute::<vk::PFN_vkGetSwapchainCounterEXT, vk::PFN_vkVoidFunction>(
6538 Self::get_swapchain_counter_ext,
6539 )
6540 },
6541 },
6542 VulkanCommand {
6543 name: "vkGetSwapchainGrallocUsage2ANDROID",
6544 features: smallvec![Feature::Extension(Extension::ANDROIDNativeBuffer)],
6545 hooked: hooked_commands
6546 .contains(&LayerVulkanCommand::GetSwapchainGrallocUsage2Android),
6547 proc: unsafe {
6548 std::mem::transmute::<
6549 vk::PFN_vkGetSwapchainGrallocUsage2ANDROID,
6550 vk::PFN_vkVoidFunction,
6551 >(Self::get_swapchain_gralloc_usage2_android)
6552 },
6553 },
6554 VulkanCommand {
6555 name: "vkGetSwapchainGrallocUsageANDROID",
6556 features: smallvec![Feature::Extension(Extension::ANDROIDNativeBuffer)],
6557 hooked: hooked_commands
6558 .contains(&LayerVulkanCommand::GetSwapchainGrallocUsageAndroid),
6559 proc: unsafe {
6560 std::mem::transmute::<
6561 vk::PFN_vkGetSwapchainGrallocUsageANDROID,
6562 vk::PFN_vkVoidFunction,
6563 >(Self::get_swapchain_gralloc_usage_android)
6564 },
6565 },
6566 VulkanCommand {
6567 name: "vkGetSwapchainImagesKHR",
6568 features: smallvec![Feature::Extension(Extension::KHRSwapchain)],
6569 hooked: hooked_commands.contains(&LayerVulkanCommand::GetSwapchainImagesKhr),
6570 proc: unsafe {
6571 std::mem::transmute::<vk::PFN_vkGetSwapchainImagesKHR, vk::PFN_vkVoidFunction>(
6572 Self::get_swapchain_images_khr,
6573 )
6574 },
6575 },
6576 VulkanCommand {
6577 name: "vkGetSwapchainStatusKHR",
6578 features: smallvec![Feature::Extension(Extension::KHRSharedPresentableImage)],
6579 hooked: hooked_commands.contains(&LayerVulkanCommand::GetSwapchainStatusKhr),
6580 proc: unsafe {
6581 std::mem::transmute::<vk::PFN_vkGetSwapchainStatusKHR, vk::PFN_vkVoidFunction>(
6582 Self::get_swapchain_status_khr,
6583 )
6584 },
6585 },
6586 VulkanCommand {
6587 name: "vkGetValidationCacheDataEXT",
6588 features: smallvec![Feature::Extension(Extension::EXTValidationCache)],
6589 hooked: hooked_commands.contains(&LayerVulkanCommand::GetValidationCacheDataExt),
6590 proc: unsafe {
6591 std::mem::transmute::<vk::PFN_vkGetValidationCacheDataEXT, vk::PFN_vkVoidFunction>(
6592 Self::get_validation_cache_data_ext,
6593 )
6594 },
6595 },
6596 VulkanCommand {
6597 name: "vkGetVideoSessionMemoryRequirementsKHR",
6598 features: smallvec![Feature::Extension(Extension::KHRVideoQueue)],
6599 hooked: hooked_commands
6600 .contains(&LayerVulkanCommand::GetVideoSessionMemoryRequirementsKhr),
6601 proc: unsafe {
6602 std::mem::transmute::<
6603 vk::PFN_vkGetVideoSessionMemoryRequirementsKHR,
6604 vk::PFN_vkVoidFunction,
6605 >(Self::get_video_session_memory_requirements_khr)
6606 },
6607 },
6608 VulkanCommand {
6609 name: "vkImportFenceFdKHR",
6610 features: smallvec![Feature::Extension(Extension::KHRExternalFenceFd)],
6611 hooked: hooked_commands.contains(&LayerVulkanCommand::ImportFenceFdKhr),
6612 proc: unsafe {
6613 std::mem::transmute::<vk::PFN_vkImportFenceFdKHR, vk::PFN_vkVoidFunction>(
6614 Self::import_fence_fd_khr,
6615 )
6616 },
6617 },
6618 VulkanCommand {
6619 name: "vkImportFenceWin32HandleKHR",
6620 features: smallvec![Feature::Extension(Extension::KHRExternalFenceWin32)],
6621 hooked: hooked_commands.contains(&LayerVulkanCommand::ImportFenceWin32HandleKhr),
6622 proc: unsafe {
6623 std::mem::transmute::<vk::PFN_vkImportFenceWin32HandleKHR, vk::PFN_vkVoidFunction>(
6624 Self::import_fence_win32_handle_khr,
6625 )
6626 },
6627 },
6628 VulkanCommand {
6629 name: "vkImportSemaphoreFdKHR",
6630 features: smallvec![Feature::Extension(Extension::KHRExternalSemaphoreFd)],
6631 hooked: hooked_commands.contains(&LayerVulkanCommand::ImportSemaphoreFdKhr),
6632 proc: unsafe {
6633 std::mem::transmute::<vk::PFN_vkImportSemaphoreFdKHR, vk::PFN_vkVoidFunction>(
6634 Self::import_semaphore_fd_khr,
6635 )
6636 },
6637 },
6638 VulkanCommand {
6639 name: "vkImportSemaphoreWin32HandleKHR",
6640 features: smallvec![Feature::Extension(Extension::KHRExternalSemaphoreWin32)],
6641 hooked: hooked_commands
6642 .contains(&LayerVulkanCommand::ImportSemaphoreWin32HandleKhr),
6643 proc: unsafe {
6644 std::mem::transmute::<
6645 vk::PFN_vkImportSemaphoreWin32HandleKHR,
6646 vk::PFN_vkVoidFunction,
6647 >(Self::import_semaphore_win32_handle_khr)
6648 },
6649 },
6650 VulkanCommand {
6651 name: "vkImportSemaphoreZirconHandleFUCHSIA",
6652 features: smallvec![Feature::Extension(Extension::FUCHSIAExternalSemaphore)],
6653 hooked: hooked_commands
6654 .contains(&LayerVulkanCommand::ImportSemaphoreZirconHandleFuchsia),
6655 proc: unsafe {
6656 std::mem::transmute::<
6657 vk::PFN_vkImportSemaphoreZirconHandleFUCHSIA,
6658 vk::PFN_vkVoidFunction,
6659 >(Self::import_semaphore_zircon_handle_fuchsia)
6660 },
6661 },
6662 VulkanCommand {
6663 name: "vkInitializePerformanceApiINTEL",
6664 features: smallvec![Feature::Extension(Extension::INTELPerformanceQuery)],
6665 hooked: hooked_commands
6666 .contains(&LayerVulkanCommand::InitializePerformanceApiIntel),
6667 proc: unsafe {
6668 std::mem::transmute::<
6669 vk::PFN_vkInitializePerformanceApiINTEL,
6670 vk::PFN_vkVoidFunction,
6671 >(Self::initialize_performance_api_intel)
6672 },
6673 },
6674 VulkanCommand {
6675 name: "vkInvalidateMappedMemoryRanges",
6676 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
6677 hooked: hooked_commands.contains(&LayerVulkanCommand::InvalidateMappedMemoryRanges),
6678 proc: unsafe {
6679 std::mem::transmute::<
6680 vk::PFN_vkInvalidateMappedMemoryRanges,
6681 vk::PFN_vkVoidFunction,
6682 >(Self::invalidate_mapped_memory_ranges)
6683 },
6684 },
6685 VulkanCommand {
6686 name: "vkMapMemory",
6687 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
6688 hooked: hooked_commands.contains(&LayerVulkanCommand::MapMemory),
6689 proc: unsafe {
6690 std::mem::transmute::<vk::PFN_vkMapMemory, vk::PFN_vkVoidFunction>(
6691 Self::map_memory,
6692 )
6693 },
6694 },
6695 VulkanCommand {
6696 name: "vkMergePipelineCaches",
6697 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
6698 hooked: hooked_commands.contains(&LayerVulkanCommand::MergePipelineCaches),
6699 proc: unsafe {
6700 std::mem::transmute::<vk::PFN_vkMergePipelineCaches, vk::PFN_vkVoidFunction>(
6701 Self::merge_pipeline_caches,
6702 )
6703 },
6704 },
6705 VulkanCommand {
6706 name: "vkMergeValidationCachesEXT",
6707 features: smallvec![Feature::Extension(Extension::EXTValidationCache)],
6708 hooked: hooked_commands.contains(&LayerVulkanCommand::MergeValidationCachesExt),
6709 proc: unsafe {
6710 std::mem::transmute::<vk::PFN_vkMergeValidationCachesEXT, vk::PFN_vkVoidFunction>(
6711 Self::merge_validation_caches_ext,
6712 )
6713 },
6714 },
6715 VulkanCommand {
6716 name: "vkQueueBeginDebugUtilsLabelEXT",
6717 features: smallvec![Feature::Extension(Extension::EXTDebugUtils)],
6718 hooked: hooked_commands.contains(&LayerVulkanCommand::QueueBeginDebugUtilsLabelExt),
6719 proc: unsafe {
6720 std::mem::transmute::<
6721 vk::PFN_vkQueueBeginDebugUtilsLabelEXT,
6722 vk::PFN_vkVoidFunction,
6723 >(Self::queue_begin_debug_utils_label_ext)
6724 },
6725 },
6726 VulkanCommand {
6727 name: "vkQueueBindSparse",
6728 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
6729 hooked: hooked_commands.contains(&LayerVulkanCommand::QueueBindSparse),
6730 proc: unsafe {
6731 std::mem::transmute::<vk::PFN_vkQueueBindSparse, vk::PFN_vkVoidFunction>(
6732 Self::queue_bind_sparse,
6733 )
6734 },
6735 },
6736 VulkanCommand {
6737 name: "vkQueueEndDebugUtilsLabelEXT",
6738 features: smallvec![Feature::Extension(Extension::EXTDebugUtils)],
6739 hooked: hooked_commands.contains(&LayerVulkanCommand::QueueEndDebugUtilsLabelExt),
6740 proc: unsafe {
6741 std::mem::transmute::<
6742 vk::PFN_vkQueueEndDebugUtilsLabelEXT,
6743 vk::PFN_vkVoidFunction,
6744 >(Self::queue_end_debug_utils_label_ext)
6745 },
6746 },
6747 VulkanCommand {
6748 name: "vkQueueInsertDebugUtilsLabelEXT",
6749 features: smallvec![Feature::Extension(Extension::EXTDebugUtils)],
6750 hooked: hooked_commands
6751 .contains(&LayerVulkanCommand::QueueInsertDebugUtilsLabelExt),
6752 proc: unsafe {
6753 std::mem::transmute::<
6754 vk::PFN_vkQueueInsertDebugUtilsLabelEXT,
6755 vk::PFN_vkVoidFunction,
6756 >(Self::queue_insert_debug_utils_label_ext)
6757 },
6758 },
6759 VulkanCommand {
6760 name: "vkQueuePresentKHR",
6761 features: smallvec![Feature::Extension(Extension::KHRSwapchain)],
6762 hooked: hooked_commands.contains(&LayerVulkanCommand::QueuePresentKhr),
6763 proc: unsafe {
6764 std::mem::transmute::<vk::PFN_vkQueuePresentKHR, vk::PFN_vkVoidFunction>(
6765 Self::queue_present_khr,
6766 )
6767 },
6768 },
6769 VulkanCommand {
6770 name: "vkQueueSetPerformanceConfigurationINTEL",
6771 features: smallvec![Feature::Extension(Extension::INTELPerformanceQuery)],
6772 hooked: hooked_commands
6773 .contains(&LayerVulkanCommand::QueueSetPerformanceConfigurationIntel),
6774 proc: unsafe {
6775 std::mem::transmute::<
6776 vk::PFN_vkQueueSetPerformanceConfigurationINTEL,
6777 vk::PFN_vkVoidFunction,
6778 >(Self::queue_set_performance_configuration_intel)
6779 },
6780 },
6781 VulkanCommand {
6782 name: "vkQueueSignalReleaseImageANDROID",
6783 features: smallvec![Feature::Extension(Extension::ANDROIDNativeBuffer)],
6784 hooked: hooked_commands
6785 .contains(&LayerVulkanCommand::QueueSignalReleaseImageAndroid),
6786 proc: unsafe {
6787 std::mem::transmute::<
6788 vk::PFN_vkQueueSignalReleaseImageANDROID,
6789 vk::PFN_vkVoidFunction,
6790 >(Self::queue_signal_release_image_android)
6791 },
6792 },
6793 VulkanCommand {
6794 name: "vkQueueSubmit",
6795 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
6796 hooked: hooked_commands.contains(&LayerVulkanCommand::QueueSubmit),
6797 proc: unsafe {
6798 std::mem::transmute::<vk::PFN_vkQueueSubmit, vk::PFN_vkVoidFunction>(
6799 Self::queue_submit,
6800 )
6801 },
6802 },
6803 VulkanCommand {
6804 name: "vkQueueSubmit2",
6805 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 3 })],
6806 hooked: hooked_commands.contains(&LayerVulkanCommand::QueueSubmit2),
6807 proc: unsafe {
6808 std::mem::transmute::<vk::PFN_vkQueueSubmit2, vk::PFN_vkVoidFunction>(
6809 Self::queue_submit2,
6810 )
6811 },
6812 },
6813 VulkanCommand {
6814 name: "vkQueueSubmit2KHR",
6815 features: smallvec![Feature::Extension(Extension::KHRSynchronization2)],
6816 hooked: hooked_commands.contains(&LayerVulkanCommand::QueueSubmit2),
6817 proc: unsafe {
6818 std::mem::transmute::<vk::PFN_vkQueueSubmit2, vk::PFN_vkVoidFunction>(
6819 Self::queue_submit2,
6820 )
6821 },
6822 },
6823 VulkanCommand {
6824 name: "vkQueueWaitIdle",
6825 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
6826 hooked: hooked_commands.contains(&LayerVulkanCommand::QueueWaitIdle),
6827 proc: unsafe {
6828 std::mem::transmute::<vk::PFN_vkQueueWaitIdle, vk::PFN_vkVoidFunction>(
6829 Self::queue_wait_idle,
6830 )
6831 },
6832 },
6833 VulkanCommand {
6834 name: "vkRegisterDeviceEventEXT",
6835 features: smallvec![Feature::Extension(Extension::EXTDisplayControl)],
6836 hooked: hooked_commands.contains(&LayerVulkanCommand::RegisterDeviceEventExt),
6837 proc: unsafe {
6838 std::mem::transmute::<vk::PFN_vkRegisterDeviceEventEXT, vk::PFN_vkVoidFunction>(
6839 Self::register_device_event_ext,
6840 )
6841 },
6842 },
6843 VulkanCommand {
6844 name: "vkRegisterDisplayEventEXT",
6845 features: smallvec![Feature::Extension(Extension::EXTDisplayControl)],
6846 hooked: hooked_commands.contains(&LayerVulkanCommand::RegisterDisplayEventExt),
6847 proc: unsafe {
6848 std::mem::transmute::<vk::PFN_vkRegisterDisplayEventEXT, vk::PFN_vkVoidFunction>(
6849 Self::register_display_event_ext,
6850 )
6851 },
6852 },
6853 VulkanCommand {
6854 name: "vkReleaseFullScreenExclusiveModeEXT",
6855 features: smallvec![Feature::Extension(Extension::EXTFullScreenExclusive)],
6856 hooked: hooked_commands
6857 .contains(&LayerVulkanCommand::ReleaseFullScreenExclusiveModeExt),
6858 proc: unsafe {
6859 std::mem::transmute::<
6860 vk::PFN_vkReleaseFullScreenExclusiveModeEXT,
6861 vk::PFN_vkVoidFunction,
6862 >(Self::release_full_screen_exclusive_mode_ext)
6863 },
6864 },
6865 VulkanCommand {
6866 name: "vkReleasePerformanceConfigurationINTEL",
6867 features: smallvec![Feature::Extension(Extension::INTELPerformanceQuery)],
6868 hooked: hooked_commands
6869 .contains(&LayerVulkanCommand::ReleasePerformanceConfigurationIntel),
6870 proc: unsafe {
6871 std::mem::transmute::<
6872 vk::PFN_vkReleasePerformanceConfigurationINTEL,
6873 vk::PFN_vkVoidFunction,
6874 >(Self::release_performance_configuration_intel)
6875 },
6876 },
6877 VulkanCommand {
6878 name: "vkReleaseProfilingLockKHR",
6879 features: smallvec![Feature::Extension(Extension::KHRPerformanceQuery)],
6880 hooked: hooked_commands.contains(&LayerVulkanCommand::ReleaseProfilingLockKhr),
6881 proc: unsafe {
6882 std::mem::transmute::<vk::PFN_vkReleaseProfilingLockKHR, vk::PFN_vkVoidFunction>(
6883 Self::release_profiling_lock_khr,
6884 )
6885 },
6886 },
6887 VulkanCommand {
6888 name: "vkReleaseSwapchainImagesEXT",
6889 features: smallvec![Feature::Extension(Extension::EXTSwapchainMaintenance1)],
6890 hooked: hooked_commands.contains(&LayerVulkanCommand::ReleaseSwapchainImagesExt),
6891 proc: unsafe {
6892 std::mem::transmute::<vk::PFN_vkReleaseSwapchainImagesEXT, vk::PFN_vkVoidFunction>(
6893 Self::release_swapchain_images_ext,
6894 )
6895 },
6896 },
6897 VulkanCommand {
6898 name: "vkResetCommandBuffer",
6899 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
6900 hooked: hooked_commands.contains(&LayerVulkanCommand::ResetCommandBuffer),
6901 proc: unsafe {
6902 std::mem::transmute::<vk::PFN_vkResetCommandBuffer, vk::PFN_vkVoidFunction>(
6903 Self::reset_command_buffer,
6904 )
6905 },
6906 },
6907 VulkanCommand {
6908 name: "vkResetCommandPool",
6909 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
6910 hooked: hooked_commands.contains(&LayerVulkanCommand::ResetCommandPool),
6911 proc: unsafe {
6912 std::mem::transmute::<vk::PFN_vkResetCommandPool, vk::PFN_vkVoidFunction>(
6913 Self::reset_command_pool,
6914 )
6915 },
6916 },
6917 VulkanCommand {
6918 name: "vkResetDescriptorPool",
6919 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
6920 hooked: hooked_commands.contains(&LayerVulkanCommand::ResetDescriptorPool),
6921 proc: unsafe {
6922 std::mem::transmute::<vk::PFN_vkResetDescriptorPool, vk::PFN_vkVoidFunction>(
6923 Self::reset_descriptor_pool,
6924 )
6925 },
6926 },
6927 VulkanCommand {
6928 name: "vkResetEvent",
6929 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
6930 hooked: hooked_commands.contains(&LayerVulkanCommand::ResetEvent),
6931 proc: unsafe {
6932 std::mem::transmute::<vk::PFN_vkResetEvent, vk::PFN_vkVoidFunction>(
6933 Self::reset_event,
6934 )
6935 },
6936 },
6937 VulkanCommand {
6938 name: "vkResetFences",
6939 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
6940 hooked: hooked_commands.contains(&LayerVulkanCommand::ResetFences),
6941 proc: unsafe {
6942 std::mem::transmute::<vk::PFN_vkResetFences, vk::PFN_vkVoidFunction>(
6943 Self::reset_fences,
6944 )
6945 },
6946 },
6947 VulkanCommand {
6948 name: "vkResetQueryPool",
6949 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 2 })],
6950 hooked: hooked_commands.contains(&LayerVulkanCommand::ResetQueryPool),
6951 proc: unsafe {
6952 std::mem::transmute::<vk::PFN_vkResetQueryPool, vk::PFN_vkVoidFunction>(
6953 Self::reset_query_pool,
6954 )
6955 },
6956 },
6957 VulkanCommand {
6958 name: "vkResetQueryPoolEXT",
6959 features: smallvec![Feature::Extension(Extension::EXTHostQueryReset)],
6960 hooked: hooked_commands.contains(&LayerVulkanCommand::ResetQueryPool),
6961 proc: unsafe {
6962 std::mem::transmute::<vk::PFN_vkResetQueryPool, vk::PFN_vkVoidFunction>(
6963 Self::reset_query_pool,
6964 )
6965 },
6966 },
6967 VulkanCommand {
6968 name: "vkSetBufferCollectionBufferConstraintsFUCHSIA",
6969 features: smallvec![Feature::Extension(Extension::FUCHSIABufferCollection)],
6970 hooked: hooked_commands
6971 .contains(&LayerVulkanCommand::SetBufferCollectionBufferConstraintsFuchsia),
6972 proc: unsafe {
6973 std::mem::transmute::<
6974 vk::PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA,
6975 vk::PFN_vkVoidFunction,
6976 >(Self::set_buffer_collection_buffer_constraints_fuchsia)
6977 },
6978 },
6979 VulkanCommand {
6980 name: "vkSetBufferCollectionImageConstraintsFUCHSIA",
6981 features: smallvec![Feature::Extension(Extension::FUCHSIABufferCollection)],
6982 hooked: hooked_commands
6983 .contains(&LayerVulkanCommand::SetBufferCollectionImageConstraintsFuchsia),
6984 proc: unsafe {
6985 std::mem::transmute::<
6986 vk::PFN_vkSetBufferCollectionImageConstraintsFUCHSIA,
6987 vk::PFN_vkVoidFunction,
6988 >(Self::set_buffer_collection_image_constraints_fuchsia)
6989 },
6990 },
6991 VulkanCommand {
6992 name: "vkSetDebugUtilsObjectNameEXT",
6993 features: smallvec![Feature::Extension(Extension::EXTDebugUtils)],
6994 hooked: hooked_commands.contains(&LayerVulkanCommand::SetDebugUtilsObjectNameExt),
6995 proc: unsafe {
6996 std::mem::transmute::<
6997 vk::PFN_vkSetDebugUtilsObjectNameEXT,
6998 vk::PFN_vkVoidFunction,
6999 >(Self::set_debug_utils_object_name_ext)
7000 },
7001 },
7002 VulkanCommand {
7003 name: "vkSetDebugUtilsObjectTagEXT",
7004 features: smallvec![Feature::Extension(Extension::EXTDebugUtils)],
7005 hooked: hooked_commands.contains(&LayerVulkanCommand::SetDebugUtilsObjectTagExt),
7006 proc: unsafe {
7007 std::mem::transmute::<vk::PFN_vkSetDebugUtilsObjectTagEXT, vk::PFN_vkVoidFunction>(
7008 Self::set_debug_utils_object_tag_ext,
7009 )
7010 },
7011 },
7012 VulkanCommand {
7013 name: "vkSetDeviceMemoryPriorityEXT",
7014 features: smallvec![Feature::Extension(Extension::EXTPageableDeviceLocalMemory)],
7015 hooked: hooked_commands.contains(&LayerVulkanCommand::SetDeviceMemoryPriorityExt),
7016 proc: unsafe {
7017 std::mem::transmute::<
7018 vk::PFN_vkSetDeviceMemoryPriorityEXT,
7019 vk::PFN_vkVoidFunction,
7020 >(Self::set_device_memory_priority_ext)
7021 },
7022 },
7023 VulkanCommand {
7024 name: "vkSetEvent",
7025 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
7026 hooked: hooked_commands.contains(&LayerVulkanCommand::SetEvent),
7027 proc: unsafe {
7028 std::mem::transmute::<vk::PFN_vkSetEvent, vk::PFN_vkVoidFunction>(
7029 Self::set_event,
7030 )
7031 },
7032 },
7033 VulkanCommand {
7034 name: "vkSetHdrMetadataEXT",
7035 features: smallvec![Feature::Extension(Extension::EXTHdrMetadata)],
7036 hooked: hooked_commands.contains(&LayerVulkanCommand::SetHdrMetadataExt),
7037 proc: unsafe {
7038 std::mem::transmute::<vk::PFN_vkSetHdrMetadataEXT, vk::PFN_vkVoidFunction>(
7039 Self::set_hdr_metadata_ext,
7040 )
7041 },
7042 },
7043 VulkanCommand {
7044 name: "vkSetLocalDimmingAMD",
7045 features: smallvec![Feature::Extension(Extension::AMDDisplayNativeHdr)],
7046 hooked: hooked_commands.contains(&LayerVulkanCommand::SetLocalDimmingAmd),
7047 proc: unsafe {
7048 std::mem::transmute::<vk::PFN_vkSetLocalDimmingAMD, vk::PFN_vkVoidFunction>(
7049 Self::set_local_dimming_amd,
7050 )
7051 },
7052 },
7053 VulkanCommand {
7054 name: "vkSetPrivateData",
7055 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 3 })],
7056 hooked: hooked_commands.contains(&LayerVulkanCommand::SetPrivateData),
7057 proc: unsafe {
7058 std::mem::transmute::<vk::PFN_vkSetPrivateData, vk::PFN_vkVoidFunction>(
7059 Self::set_private_data,
7060 )
7061 },
7062 },
7063 VulkanCommand {
7064 name: "vkSetPrivateDataEXT",
7065 features: smallvec![Feature::Extension(Extension::EXTPrivateData)],
7066 hooked: hooked_commands.contains(&LayerVulkanCommand::SetPrivateData),
7067 proc: unsafe {
7068 std::mem::transmute::<vk::PFN_vkSetPrivateData, vk::PFN_vkVoidFunction>(
7069 Self::set_private_data,
7070 )
7071 },
7072 },
7073 VulkanCommand {
7074 name: "vkSignalSemaphore",
7075 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 2 })],
7076 hooked: hooked_commands.contains(&LayerVulkanCommand::SignalSemaphore),
7077 proc: unsafe {
7078 std::mem::transmute::<vk::PFN_vkSignalSemaphore, vk::PFN_vkVoidFunction>(
7079 Self::signal_semaphore,
7080 )
7081 },
7082 },
7083 VulkanCommand {
7084 name: "vkSignalSemaphoreKHR",
7085 features: smallvec![Feature::Extension(Extension::KHRTimelineSemaphore)],
7086 hooked: hooked_commands.contains(&LayerVulkanCommand::SignalSemaphore),
7087 proc: unsafe {
7088 std::mem::transmute::<vk::PFN_vkSignalSemaphore, vk::PFN_vkVoidFunction>(
7089 Self::signal_semaphore,
7090 )
7091 },
7092 },
7093 VulkanCommand {
7094 name: "vkTrimCommandPool",
7095 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 1 })],
7096 hooked: hooked_commands.contains(&LayerVulkanCommand::TrimCommandPool),
7097 proc: unsafe {
7098 std::mem::transmute::<vk::PFN_vkTrimCommandPool, vk::PFN_vkVoidFunction>(
7099 Self::trim_command_pool,
7100 )
7101 },
7102 },
7103 VulkanCommand {
7104 name: "vkTrimCommandPoolKHR",
7105 features: smallvec![Feature::Extension(Extension::KHRMaintenance1)],
7106 hooked: hooked_commands.contains(&LayerVulkanCommand::TrimCommandPool),
7107 proc: unsafe {
7108 std::mem::transmute::<vk::PFN_vkTrimCommandPool, vk::PFN_vkVoidFunction>(
7109 Self::trim_command_pool,
7110 )
7111 },
7112 },
7113 VulkanCommand {
7114 name: "vkUninitializePerformanceApiINTEL",
7115 features: smallvec![Feature::Extension(Extension::INTELPerformanceQuery)],
7116 hooked: hooked_commands
7117 .contains(&LayerVulkanCommand::UninitializePerformanceApiIntel),
7118 proc: unsafe {
7119 std::mem::transmute::<
7120 vk::PFN_vkUninitializePerformanceApiINTEL,
7121 vk::PFN_vkVoidFunction,
7122 >(Self::uninitialize_performance_api_intel)
7123 },
7124 },
7125 VulkanCommand {
7126 name: "vkUnmapMemory",
7127 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
7128 hooked: hooked_commands.contains(&LayerVulkanCommand::UnmapMemory),
7129 proc: unsafe {
7130 std::mem::transmute::<vk::PFN_vkUnmapMemory, vk::PFN_vkVoidFunction>(
7131 Self::unmap_memory,
7132 )
7133 },
7134 },
7135 VulkanCommand {
7136 name: "vkUpdateDescriptorSetWithTemplate",
7137 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 1 })],
7138 hooked: hooked_commands
7139 .contains(&LayerVulkanCommand::UpdateDescriptorSetWithTemplate),
7140 proc: unsafe {
7141 std::mem::transmute::<
7142 vk::PFN_vkUpdateDescriptorSetWithTemplate,
7143 vk::PFN_vkVoidFunction,
7144 >(Self::update_descriptor_set_with_template)
7145 },
7146 },
7147 VulkanCommand {
7148 name: "vkUpdateDescriptorSetWithTemplateKHR",
7149 features: smallvec![Feature::Extension(Extension::KHRDescriptorUpdateTemplate)],
7150 hooked: hooked_commands
7151 .contains(&LayerVulkanCommand::UpdateDescriptorSetWithTemplate),
7152 proc: unsafe {
7153 std::mem::transmute::<
7154 vk::PFN_vkUpdateDescriptorSetWithTemplate,
7155 vk::PFN_vkVoidFunction,
7156 >(Self::update_descriptor_set_with_template)
7157 },
7158 },
7159 VulkanCommand {
7160 name: "vkUpdateDescriptorSets",
7161 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
7162 hooked: hooked_commands.contains(&LayerVulkanCommand::UpdateDescriptorSets),
7163 proc: unsafe {
7164 std::mem::transmute::<vk::PFN_vkUpdateDescriptorSets, vk::PFN_vkVoidFunction>(
7165 Self::update_descriptor_sets,
7166 )
7167 },
7168 },
7169 VulkanCommand {
7170 name: "vkUpdateVideoSessionParametersKHR",
7171 features: smallvec![Feature::Extension(Extension::KHRVideoQueue)],
7172 hooked: hooked_commands
7173 .contains(&LayerVulkanCommand::UpdateVideoSessionParametersKhr),
7174 proc: unsafe {
7175 std::mem::transmute::<
7176 vk::PFN_vkUpdateVideoSessionParametersKHR,
7177 vk::PFN_vkVoidFunction,
7178 >(Self::update_video_session_parameters_khr)
7179 },
7180 },
7181 VulkanCommand {
7182 name: "vkWaitForFences",
7183 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0 })],
7184 hooked: hooked_commands.contains(&LayerVulkanCommand::WaitForFences),
7185 proc: unsafe {
7186 std::mem::transmute::<vk::PFN_vkWaitForFences, vk::PFN_vkVoidFunction>(
7187 Self::wait_for_fences,
7188 )
7189 },
7190 },
7191 VulkanCommand {
7192 name: "vkWaitForPresentKHR",
7193 features: smallvec![Feature::Extension(Extension::KHRPresentWait)],
7194 hooked: hooked_commands.contains(&LayerVulkanCommand::WaitForPresentKhr),
7195 proc: unsafe {
7196 std::mem::transmute::<vk::PFN_vkWaitForPresentKHR, vk::PFN_vkVoidFunction>(
7197 Self::wait_for_present_khr,
7198 )
7199 },
7200 },
7201 VulkanCommand {
7202 name: "vkWaitSemaphores",
7203 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 2 })],
7204 hooked: hooked_commands.contains(&LayerVulkanCommand::WaitSemaphores),
7205 proc: unsafe {
7206 std::mem::transmute::<vk::PFN_vkWaitSemaphores, vk::PFN_vkVoidFunction>(
7207 Self::wait_semaphores,
7208 )
7209 },
7210 },
7211 VulkanCommand {
7212 name: "vkWaitSemaphoresKHR",
7213 features: smallvec![Feature::Extension(Extension::KHRTimelineSemaphore)],
7214 hooked: hooked_commands.contains(&LayerVulkanCommand::WaitSemaphores),
7215 proc: unsafe {
7216 std::mem::transmute::<vk::PFN_vkWaitSemaphores, vk::PFN_vkVoidFunction>(
7217 Self::wait_semaphores,
7218 )
7219 },
7220 },
7221 VulkanCommand {
7222 name: "vkWriteAccelerationStructuresPropertiesKHR",
7223 features: smallvec![Feature::Extension(Extension::KHRAccelerationStructure)],
7224 hooked: hooked_commands
7225 .contains(&LayerVulkanCommand::WriteAccelerationStructuresPropertiesKhr),
7226 proc: unsafe {
7227 std::mem::transmute::<
7228 vk::PFN_vkWriteAccelerationStructuresPropertiesKHR,
7229 vk::PFN_vkVoidFunction,
7230 >(Self::write_acceleration_structures_properties_khr)
7231 },
7232 },
7233 VulkanCommand {
7234 name: "vkWriteMicromapsPropertiesEXT",
7235 features: smallvec![Feature::Extension(Extension::EXTOpacityMicromap)],
7236 hooked: hooked_commands.contains(&LayerVulkanCommand::WriteMicromapsPropertiesExt),
7237 proc: unsafe {
7238 std::mem::transmute::<
7239 vk::PFN_vkWriteMicromapsPropertiesEXT,
7240 vk::PFN_vkVoidFunction,
7241 >(Self::write_micromaps_properties_ext)
7242 },
7243 },
7244 ])
7245 }
7246 pub(crate) fn create_instance_commands(
7247 &self,
7248 instance_info: &T::InstanceInfo,
7249 ) -> Box<[VulkanCommand]> {
7250 let hooked_commands = self
7251 .layer_info
7252 .hooked_instance_commands(instance_info)
7253 .collect::<HashSet<_>>();
7254 Box::new([
7255 VulkanCommand {
7256 name: "vkAcquireDrmDisplayEXT",
7257 features: smallvec![Feature::Extension(Extension::EXTAcquireDrmDisplay)],
7258 hooked: hooked_commands.contains(&LayerVulkanCommand::AcquireDrmDisplayExt),
7259 proc: unsafe { std::mem::transmute::<vk::PFN_vkAcquireDrmDisplayEXT, vk::PFN_vkVoidFunction>(Self::acquire_drm_display_ext)},
7260 },
7261 VulkanCommand {
7262 name: "vkAcquireWinrtDisplayNV",
7263 features: smallvec![Feature::Extension(Extension::NVAcquireWinrtDisplay)],
7264 hooked: hooked_commands.contains(&LayerVulkanCommand::AcquireWinrtDisplayNv),
7265 proc: unsafe { std::mem::transmute::<vk::PFN_vkAcquireWinrtDisplayNV, vk::PFN_vkVoidFunction>(Self::acquire_winrt_display_nv)},
7266 },
7267 VulkanCommand {
7268 name: "vkAcquireXlibDisplayEXT",
7269 features: smallvec![Feature::Extension(Extension::EXTAcquireXlibDisplay)],
7270 hooked: hooked_commands.contains(&LayerVulkanCommand::AcquireXlibDisplayExt),
7271 proc: unsafe { std::mem::transmute::<vk::PFN_vkAcquireXlibDisplayEXT, vk::PFN_vkVoidFunction>(Self::acquire_xlib_display_ext)},
7272 },
7273 VulkanCommand {
7274 name: "vkCreateAndroidSurfaceKHR",
7275 features: smallvec![Feature::Extension(Extension::KHRAndroidSurface)],
7276 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateAndroidSurfaceKhr),
7277 proc: unsafe { std::mem::transmute::<vk::PFN_vkCreateAndroidSurfaceKHR, vk::PFN_vkVoidFunction>(Self::create_android_surface_khr)},
7278 },
7279 VulkanCommand {
7280 name: "vkCreateDebugReportCallbackEXT",
7281 features: smallvec![Feature::Extension(Extension::EXTDebugReport)],
7282 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateDebugReportCallbackExt),
7283 proc: unsafe { std::mem::transmute::<vk::PFN_vkCreateDebugReportCallbackEXT, vk::PFN_vkVoidFunction>(Self::create_debug_report_callback_ext)},
7284 },
7285 VulkanCommand {
7286 name: "vkCreateDebugUtilsMessengerEXT",
7287 features: smallvec![Feature::Extension(Extension::EXTDebugUtils)],
7288 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateDebugUtilsMessengerExt),
7289 proc: unsafe { std::mem::transmute::<vk::PFN_vkCreateDebugUtilsMessengerEXT, vk::PFN_vkVoidFunction>(Self::create_debug_utils_messenger_ext)},
7290 },
7291 VulkanCommand {
7292 name: "vkCreateDevice",
7293 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0})],
7294 hooked: true,
7295 proc: unsafe { std::mem::transmute::<vk::PFN_vkCreateDevice, vk::PFN_vkVoidFunction>(Self::create_device)},
7296 },
7297 VulkanCommand {
7298 name: "vkCreateDirectFBSurfaceEXT",
7299 features: smallvec![Feature::Extension(Extension::EXTDirectfbSurface)],
7300 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateDirectFbSurfaceExt),
7301 proc: unsafe { std::mem::transmute::<vk::PFN_vkCreateDirectFBSurfaceEXT, vk::PFN_vkVoidFunction>(Self::create_direct_fb_surface_ext)},
7302 },
7303 VulkanCommand {
7304 name: "vkCreateDisplayModeKHR",
7305 features: smallvec![Feature::Extension(Extension::KHRDisplay)],
7306 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateDisplayModeKhr),
7307 proc: unsafe { std::mem::transmute::<vk::PFN_vkCreateDisplayModeKHR, vk::PFN_vkVoidFunction>(Self::create_display_mode_khr)},
7308 },
7309 VulkanCommand {
7310 name: "vkCreateDisplayPlaneSurfaceKHR",
7311 features: smallvec![Feature::Extension(Extension::KHRDisplay)],
7312 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateDisplayPlaneSurfaceKhr),
7313 proc: unsafe { std::mem::transmute::<vk::PFN_vkCreateDisplayPlaneSurfaceKHR, vk::PFN_vkVoidFunction>(Self::create_display_plane_surface_khr)},
7314 },
7315 VulkanCommand {
7316 name: "vkCreateHeadlessSurfaceEXT",
7317 features: smallvec![Feature::Extension(Extension::EXTHeadlessSurface)],
7318 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateHeadlessSurfaceExt),
7319 proc: unsafe { std::mem::transmute::<vk::PFN_vkCreateHeadlessSurfaceEXT, vk::PFN_vkVoidFunction>(Self::create_headless_surface_ext)},
7320 },
7321 VulkanCommand {
7322 name: "vkCreateIOSSurfaceMVK",
7323 features: smallvec![Feature::Extension(Extension::MVKIosSurface)],
7324 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateIosSurfaceMvk),
7325 proc: unsafe { std::mem::transmute::<vk::PFN_vkCreateIOSSurfaceMVK, vk::PFN_vkVoidFunction>(Self::create_ios_surface_mvk)},
7326 },
7327 VulkanCommand {
7328 name: "vkCreateImagePipeSurfaceFUCHSIA",
7329 features: smallvec![Feature::Extension(Extension::FUCHSIAImagepipeSurface)],
7330 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateImagePipeSurfaceFuchsia),
7331 proc: unsafe { std::mem::transmute::<vk::PFN_vkCreateImagePipeSurfaceFUCHSIA, vk::PFN_vkVoidFunction>(Self::create_image_pipe_surface_fuchsia)},
7332 },
7333 VulkanCommand {
7334 name: "vkCreateMacOSSurfaceMVK",
7335 features: smallvec![Feature::Extension(Extension::MVKMacosSurface)],
7336 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateMacOsSurfaceMvk),
7337 proc: unsafe { std::mem::transmute::<vk::PFN_vkCreateMacOSSurfaceMVK, vk::PFN_vkVoidFunction>(Self::create_mac_os_surface_mvk)},
7338 },
7339 VulkanCommand {
7340 name: "vkCreateMetalSurfaceEXT",
7341 features: smallvec![Feature::Extension(Extension::EXTMetalSurface)],
7342 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateMetalSurfaceExt),
7343 proc: unsafe { std::mem::transmute::<vk::PFN_vkCreateMetalSurfaceEXT, vk::PFN_vkVoidFunction>(Self::create_metal_surface_ext)},
7344 },
7345 VulkanCommand {
7346 name: "vkCreateScreenSurfaceQNX",
7347 features: smallvec![Feature::Extension(Extension::QNXScreenSurface)],
7348 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateScreenSurfaceQnx),
7349 proc: unsafe { std::mem::transmute::<vk::PFN_vkCreateScreenSurfaceQNX, vk::PFN_vkVoidFunction>(Self::create_screen_surface_qnx)},
7350 },
7351 VulkanCommand {
7352 name: "vkCreateStreamDescriptorSurfaceGGP",
7353 features: smallvec![Feature::Extension(Extension::GGPStreamDescriptorSurface)],
7354 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateStreamDescriptorSurfaceGgp),
7355 proc: unsafe { std::mem::transmute::<vk::PFN_vkCreateStreamDescriptorSurfaceGGP, vk::PFN_vkVoidFunction>(Self::create_stream_descriptor_surface_ggp)},
7356 },
7357 VulkanCommand {
7358 name: "vkCreateViSurfaceNN",
7359 features: smallvec![Feature::Extension(Extension::NNViSurface)],
7360 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateViSurfaceNn),
7361 proc: unsafe { std::mem::transmute::<vk::PFN_vkCreateViSurfaceNN, vk::PFN_vkVoidFunction>(Self::create_vi_surface_nn)},
7362 },
7363 VulkanCommand {
7364 name: "vkCreateWaylandSurfaceKHR",
7365 features: smallvec![Feature::Extension(Extension::KHRWaylandSurface)],
7366 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateWaylandSurfaceKhr),
7367 proc: unsafe { std::mem::transmute::<vk::PFN_vkCreateWaylandSurfaceKHR, vk::PFN_vkVoidFunction>(Self::create_wayland_surface_khr)},
7368 },
7369 VulkanCommand {
7370 name: "vkCreateWin32SurfaceKHR",
7371 features: smallvec![Feature::Extension(Extension::KHRWin32Surface)],
7372 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateWin32SurfaceKhr),
7373 proc: unsafe { std::mem::transmute::<vk::PFN_vkCreateWin32SurfaceKHR, vk::PFN_vkVoidFunction>(Self::create_win32_surface_khr)},
7374 },
7375 VulkanCommand {
7376 name: "vkCreateXcbSurfaceKHR",
7377 features: smallvec![Feature::Extension(Extension::KHRXcbSurface)],
7378 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateXcbSurfaceKhr),
7379 proc: unsafe { std::mem::transmute::<vk::PFN_vkCreateXcbSurfaceKHR, vk::PFN_vkVoidFunction>(Self::create_xcb_surface_khr)},
7380 },
7381 VulkanCommand {
7382 name: "vkCreateXlibSurfaceKHR",
7383 features: smallvec![Feature::Extension(Extension::KHRXlibSurface)],
7384 hooked: hooked_commands.contains(&LayerVulkanCommand::CreateXlibSurfaceKhr),
7385 proc: unsafe { std::mem::transmute::<vk::PFN_vkCreateXlibSurfaceKHR, vk::PFN_vkVoidFunction>(Self::create_xlib_surface_khr)},
7386 },
7387 VulkanCommand {
7388 name: "vkDebugReportMessageEXT",
7389 features: smallvec![Feature::Extension(Extension::EXTDebugReport)],
7390 hooked: hooked_commands.contains(&LayerVulkanCommand::DebugReportMessageExt),
7391 proc: unsafe { std::mem::transmute::<vk::PFN_vkDebugReportMessageEXT, vk::PFN_vkVoidFunction>(Self::debug_report_message_ext)},
7392 },
7393 VulkanCommand {
7394 name: "vkDestroyDebugReportCallbackEXT",
7395 features: smallvec![Feature::Extension(Extension::EXTDebugReport)],
7396 hooked: hooked_commands.contains(&LayerVulkanCommand::DestroyDebugReportCallbackExt),
7397 proc: unsafe { std::mem::transmute::<vk::PFN_vkDestroyDebugReportCallbackEXT, vk::PFN_vkVoidFunction>(Self::destroy_debug_report_callback_ext)},
7398 },
7399 VulkanCommand {
7400 name: "vkDestroyDebugUtilsMessengerEXT",
7401 features: smallvec![Feature::Extension(Extension::EXTDebugUtils)],
7402 hooked: hooked_commands.contains(&LayerVulkanCommand::DestroyDebugUtilsMessengerExt),
7403 proc: unsafe { std::mem::transmute::<vk::PFN_vkDestroyDebugUtilsMessengerEXT, vk::PFN_vkVoidFunction>(Self::destroy_debug_utils_messenger_ext)},
7404 },
7405 VulkanCommand {
7406 name: "vkDestroyInstance",
7407 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0})],
7408 hooked: true,
7409 proc: unsafe { std::mem::transmute::<vk::PFN_vkDestroyInstance, vk::PFN_vkVoidFunction>(Self::destroy_instance)},
7410 },
7411 VulkanCommand {
7412 name: "vkDestroySurfaceKHR",
7413 features: smallvec![Feature::Extension(Extension::KHRSurface)],
7414 hooked: hooked_commands.contains(&LayerVulkanCommand::DestroySurfaceKhr),
7415 proc: unsafe { std::mem::transmute::<vk::PFN_vkDestroySurfaceKHR, vk::PFN_vkVoidFunction>(Self::destroy_surface_khr)},
7416 },
7417 VulkanCommand {
7418 name: "vkEnumerateDeviceExtensionProperties",
7419 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0})],
7420 hooked: true,
7421 proc: unsafe { std::mem::transmute::<vk::PFN_vkEnumerateDeviceExtensionProperties, vk::PFN_vkVoidFunction>(Self::enumerate_device_extension_properties)},
7422 },
7423 VulkanCommand {
7424 name: "vkEnumerateDeviceLayerProperties",
7425 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0})],
7426 hooked: true,
7427 proc: unsafe { std::mem::transmute::<vk::PFN_vkEnumerateDeviceLayerProperties, vk::PFN_vkVoidFunction>(Self::enumerate_device_layer_properties)},
7428 },
7429 VulkanCommand {
7430 name: "vkEnumeratePhysicalDeviceGroups",
7431 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 1})],
7432 hooked: true,
7433 proc: unsafe { std::mem::transmute::<vk::PFN_vkEnumeratePhysicalDeviceGroups, vk::PFN_vkVoidFunction>(Self::enumerate_physical_device_groups)},
7434 },
7435 VulkanCommand {
7436 name: "vkEnumeratePhysicalDeviceGroupsKHR",
7437 features: smallvec![Feature::Extension(Extension::KHRDeviceGroupCreation)],
7438 hooked: true,
7439 proc: unsafe { std::mem::transmute::<vk::PFN_vkEnumeratePhysicalDeviceGroups, vk::PFN_vkVoidFunction>(Self::enumerate_physical_device_groups)},
7440 },
7441 VulkanCommand {
7442 name: "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR",
7443 features: smallvec![Feature::Extension(Extension::KHRPerformanceQuery)],
7444 hooked: hooked_commands.contains(&LayerVulkanCommand::EnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKhr),
7445 proc: unsafe { std::mem::transmute::<vk::PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR, vk::PFN_vkVoidFunction>(Self::enumerate_physical_device_queue_family_performance_query_counters_khr)},
7446 },
7447 VulkanCommand {
7448 name: "vkEnumeratePhysicalDevices",
7449 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0})],
7450 hooked: true,
7451 proc: unsafe { std::mem::transmute::<vk::PFN_vkEnumeratePhysicalDevices, vk::PFN_vkVoidFunction>(Self::enumerate_physical_devices)},
7452 },
7453 VulkanCommand {
7454 name: "vkGetDisplayModeProperties2KHR",
7455 features: smallvec![Feature::Extension(Extension::KHRGetDisplayProperties2)],
7456 hooked: hooked_commands.contains(&LayerVulkanCommand::GetDisplayModeProperties2Khr),
7457 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetDisplayModeProperties2KHR, vk::PFN_vkVoidFunction>(Self::get_display_mode_properties2_khr)},
7458 },
7459 VulkanCommand {
7460 name: "vkGetDisplayModePropertiesKHR",
7461 features: smallvec![Feature::Extension(Extension::KHRDisplay)],
7462 hooked: hooked_commands.contains(&LayerVulkanCommand::GetDisplayModePropertiesKhr),
7463 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetDisplayModePropertiesKHR, vk::PFN_vkVoidFunction>(Self::get_display_mode_properties_khr)},
7464 },
7465 VulkanCommand {
7466 name: "vkGetDisplayPlaneCapabilities2KHR",
7467 features: smallvec![Feature::Extension(Extension::KHRGetDisplayProperties2)],
7468 hooked: hooked_commands.contains(&LayerVulkanCommand::GetDisplayPlaneCapabilities2Khr),
7469 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetDisplayPlaneCapabilities2KHR, vk::PFN_vkVoidFunction>(Self::get_display_plane_capabilities2_khr)},
7470 },
7471 VulkanCommand {
7472 name: "vkGetDisplayPlaneCapabilitiesKHR",
7473 features: smallvec![Feature::Extension(Extension::KHRDisplay)],
7474 hooked: hooked_commands.contains(&LayerVulkanCommand::GetDisplayPlaneCapabilitiesKhr),
7475 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetDisplayPlaneCapabilitiesKHR, vk::PFN_vkVoidFunction>(Self::get_display_plane_capabilities_khr)},
7476 },
7477 VulkanCommand {
7478 name: "vkGetDisplayPlaneSupportedDisplaysKHR",
7479 features: smallvec![Feature::Extension(Extension::KHRDisplay)],
7480 hooked: hooked_commands.contains(&LayerVulkanCommand::GetDisplayPlaneSupportedDisplaysKhr),
7481 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetDisplayPlaneSupportedDisplaysKHR, vk::PFN_vkVoidFunction>(Self::get_display_plane_supported_displays_khr)},
7482 },
7483 VulkanCommand {
7484 name: "vkGetDrmDisplayEXT",
7485 features: smallvec![Feature::Extension(Extension::EXTAcquireDrmDisplay)],
7486 hooked: hooked_commands.contains(&LayerVulkanCommand::GetDrmDisplayExt),
7487 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetDrmDisplayEXT, vk::PFN_vkVoidFunction>(Self::get_drm_display_ext)},
7488 },
7489 VulkanCommand {
7490 name: "vkGetInstanceProcAddr",
7491 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0})],
7492 hooked: true,
7493 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetInstanceProcAddr, vk::PFN_vkVoidFunction>(Self::get_instance_proc_addr)},
7494 },
7495 VulkanCommand {
7496 name: "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT",
7497 features: smallvec![Feature::Extension(Extension::EXTCalibratedTimestamps)],
7498 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceCalibrateableTimeDomainsExt),
7499 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT, vk::PFN_vkVoidFunction>(Self::get_physical_device_calibrateable_time_domains_ext)},
7500 },
7501 VulkanCommand {
7502 name: "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV",
7503 features: smallvec![Feature::Extension(Extension::NVCooperativeMatrix)],
7504 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceCooperativeMatrixPropertiesNv),
7505 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV, vk::PFN_vkVoidFunction>(Self::get_physical_device_cooperative_matrix_properties_nv)},
7506 },
7507 VulkanCommand {
7508 name: "vkGetPhysicalDeviceDirectFBPresentationSupportEXT",
7509 features: smallvec![Feature::Extension(Extension::EXTDirectfbSurface)],
7510 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceDirectFbPresentationSupportExt),
7511 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT, vk::PFN_vkVoidFunction>(Self::get_physical_device_direct_fb_presentation_support_ext)},
7512 },
7513 VulkanCommand {
7514 name: "vkGetPhysicalDeviceDisplayPlaneProperties2KHR",
7515 features: smallvec![Feature::Extension(Extension::KHRGetDisplayProperties2)],
7516 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceDisplayPlaneProperties2Khr),
7517 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR, vk::PFN_vkVoidFunction>(Self::get_physical_device_display_plane_properties2_khr)},
7518 },
7519 VulkanCommand {
7520 name: "vkGetPhysicalDeviceDisplayPlanePropertiesKHR",
7521 features: smallvec![Feature::Extension(Extension::KHRDisplay)],
7522 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceDisplayPlanePropertiesKhr),
7523 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR, vk::PFN_vkVoidFunction>(Self::get_physical_device_display_plane_properties_khr)},
7524 },
7525 VulkanCommand {
7526 name: "vkGetPhysicalDeviceDisplayProperties2KHR",
7527 features: smallvec![Feature::Extension(Extension::KHRGetDisplayProperties2)],
7528 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceDisplayProperties2Khr),
7529 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceDisplayProperties2KHR, vk::PFN_vkVoidFunction>(Self::get_physical_device_display_properties2_khr)},
7530 },
7531 VulkanCommand {
7532 name: "vkGetPhysicalDeviceDisplayPropertiesKHR",
7533 features: smallvec![Feature::Extension(Extension::KHRDisplay)],
7534 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceDisplayPropertiesKhr),
7535 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceDisplayPropertiesKHR, vk::PFN_vkVoidFunction>(Self::get_physical_device_display_properties_khr)},
7536 },
7537 VulkanCommand {
7538 name: "vkGetPhysicalDeviceExternalBufferProperties",
7539 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 1})],
7540 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceExternalBufferProperties),
7541 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceExternalBufferProperties, vk::PFN_vkVoidFunction>(Self::get_physical_device_external_buffer_properties)},
7542 },
7543 VulkanCommand {
7544 name: "vkGetPhysicalDeviceExternalBufferPropertiesKHR",
7545 features: smallvec![Feature::Extension(Extension::KHRExternalMemoryCapabilities)],
7546 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceExternalBufferProperties),
7547 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceExternalBufferProperties, vk::PFN_vkVoidFunction>(Self::get_physical_device_external_buffer_properties)},
7548 },
7549 VulkanCommand {
7550 name: "vkGetPhysicalDeviceExternalFenceProperties",
7551 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 1})],
7552 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceExternalFenceProperties),
7553 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceExternalFenceProperties, vk::PFN_vkVoidFunction>(Self::get_physical_device_external_fence_properties)},
7554 },
7555 VulkanCommand {
7556 name: "vkGetPhysicalDeviceExternalFencePropertiesKHR",
7557 features: smallvec![Feature::Extension(Extension::KHRExternalFenceCapabilities)],
7558 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceExternalFenceProperties),
7559 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceExternalFenceProperties, vk::PFN_vkVoidFunction>(Self::get_physical_device_external_fence_properties)},
7560 },
7561 VulkanCommand {
7562 name: "vkGetPhysicalDeviceExternalImageFormatPropertiesNV",
7563 features: smallvec![Feature::Extension(Extension::NVExternalMemoryCapabilities)],
7564 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceExternalImageFormatPropertiesNv),
7565 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV, vk::PFN_vkVoidFunction>(Self::get_physical_device_external_image_format_properties_nv)},
7566 },
7567 VulkanCommand {
7568 name: "vkGetPhysicalDeviceExternalSemaphoreProperties",
7569 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 1})],
7570 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceExternalSemaphoreProperties),
7571 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceExternalSemaphoreProperties, vk::PFN_vkVoidFunction>(Self::get_physical_device_external_semaphore_properties)},
7572 },
7573 VulkanCommand {
7574 name: "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR",
7575 features: smallvec![Feature::Extension(Extension::KHRExternalSemaphoreCapabilities)],
7576 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceExternalSemaphoreProperties),
7577 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceExternalSemaphoreProperties, vk::PFN_vkVoidFunction>(Self::get_physical_device_external_semaphore_properties)},
7578 },
7579 VulkanCommand {
7580 name: "vkGetPhysicalDeviceFeatures",
7581 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0})],
7582 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceFeatures),
7583 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceFeatures, vk::PFN_vkVoidFunction>(Self::get_physical_device_features)},
7584 },
7585 VulkanCommand {
7586 name: "vkGetPhysicalDeviceFeatures2",
7587 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 1})],
7588 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceFeatures2),
7589 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceFeatures2, vk::PFN_vkVoidFunction>(Self::get_physical_device_features2)},
7590 },
7591 VulkanCommand {
7592 name: "vkGetPhysicalDeviceFeatures2KHR",
7593 features: smallvec![Feature::Extension(Extension::KHRGetPhysicalDeviceProperties2)],
7594 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceFeatures2),
7595 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceFeatures2, vk::PFN_vkVoidFunction>(Self::get_physical_device_features2)},
7596 },
7597 VulkanCommand {
7598 name: "vkGetPhysicalDeviceFormatProperties",
7599 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0})],
7600 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceFormatProperties),
7601 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceFormatProperties, vk::PFN_vkVoidFunction>(Self::get_physical_device_format_properties)},
7602 },
7603 VulkanCommand {
7604 name: "vkGetPhysicalDeviceFormatProperties2",
7605 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 1})],
7606 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceFormatProperties2),
7607 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceFormatProperties2, vk::PFN_vkVoidFunction>(Self::get_physical_device_format_properties2)},
7608 },
7609 VulkanCommand {
7610 name: "vkGetPhysicalDeviceFormatProperties2KHR",
7611 features: smallvec![Feature::Extension(Extension::KHRGetPhysicalDeviceProperties2)],
7612 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceFormatProperties2),
7613 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceFormatProperties2, vk::PFN_vkVoidFunction>(Self::get_physical_device_format_properties2)},
7614 },
7615 VulkanCommand {
7616 name: "vkGetPhysicalDeviceFragmentShadingRatesKHR",
7617 features: smallvec![Feature::Extension(Extension::KHRFragmentShadingRate)],
7618 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceFragmentShadingRatesKhr),
7619 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR, vk::PFN_vkVoidFunction>(Self::get_physical_device_fragment_shading_rates_khr)},
7620 },
7621 VulkanCommand {
7622 name: "vkGetPhysicalDeviceImageFormatProperties",
7623 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0})],
7624 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceImageFormatProperties),
7625 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceImageFormatProperties, vk::PFN_vkVoidFunction>(Self::get_physical_device_image_format_properties)},
7626 },
7627 VulkanCommand {
7628 name: "vkGetPhysicalDeviceImageFormatProperties2",
7629 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 1})],
7630 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceImageFormatProperties2),
7631 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceImageFormatProperties2, vk::PFN_vkVoidFunction>(Self::get_physical_device_image_format_properties2)},
7632 },
7633 VulkanCommand {
7634 name: "vkGetPhysicalDeviceImageFormatProperties2KHR",
7635 features: smallvec![Feature::Extension(Extension::KHRGetPhysicalDeviceProperties2)],
7636 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceImageFormatProperties2),
7637 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceImageFormatProperties2, vk::PFN_vkVoidFunction>(Self::get_physical_device_image_format_properties2)},
7638 },
7639 VulkanCommand {
7640 name: "vkGetPhysicalDeviceMemoryProperties",
7641 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0})],
7642 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceMemoryProperties),
7643 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceMemoryProperties, vk::PFN_vkVoidFunction>(Self::get_physical_device_memory_properties)},
7644 },
7645 VulkanCommand {
7646 name: "vkGetPhysicalDeviceMemoryProperties2",
7647 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 1})],
7648 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceMemoryProperties2),
7649 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceMemoryProperties2, vk::PFN_vkVoidFunction>(Self::get_physical_device_memory_properties2)},
7650 },
7651 VulkanCommand {
7652 name: "vkGetPhysicalDeviceMemoryProperties2KHR",
7653 features: smallvec![Feature::Extension(Extension::KHRGetPhysicalDeviceProperties2)],
7654 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceMemoryProperties2),
7655 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceMemoryProperties2, vk::PFN_vkVoidFunction>(Self::get_physical_device_memory_properties2)},
7656 },
7657 VulkanCommand {
7658 name: "vkGetPhysicalDeviceMultisamplePropertiesEXT",
7659 features: smallvec![Feature::Extension(Extension::EXTSampleLocations)],
7660 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceMultisamplePropertiesExt),
7661 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT, vk::PFN_vkVoidFunction>(Self::get_physical_device_multisample_properties_ext)},
7662 },
7663 VulkanCommand {
7664 name: "vkGetPhysicalDeviceOpticalFlowImageFormatsNV",
7665 features: smallvec![Feature::Extension(Extension::NVOpticalFlow)],
7666 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceOpticalFlowImageFormatsNv),
7667 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV, vk::PFN_vkVoidFunction>(Self::get_physical_device_optical_flow_image_formats_nv)},
7668 },
7669 VulkanCommand {
7670 name: "vkGetPhysicalDevicePresentRectanglesKHR",
7671 features: smallvec![Feature::Extension(Extension::KHRSwapchain), Feature::Extension(Extension::KHRDeviceGroup)],
7672 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDevicePresentRectanglesKhr),
7673 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDevicePresentRectanglesKHR, vk::PFN_vkVoidFunction>(Self::get_physical_device_present_rectangles_khr)},
7674 },
7675 VulkanCommand {
7676 name: "vkGetPhysicalDeviceProperties",
7677 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0})],
7678 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceProperties),
7679 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceProperties, vk::PFN_vkVoidFunction>(Self::get_physical_device_properties)},
7680 },
7681 VulkanCommand {
7682 name: "vkGetPhysicalDeviceProperties2",
7683 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 1})],
7684 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceProperties2),
7685 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceProperties2, vk::PFN_vkVoidFunction>(Self::get_physical_device_properties2)},
7686 },
7687 VulkanCommand {
7688 name: "vkGetPhysicalDeviceProperties2KHR",
7689 features: smallvec![Feature::Extension(Extension::KHRGetPhysicalDeviceProperties2)],
7690 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceProperties2),
7691 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceProperties2, vk::PFN_vkVoidFunction>(Self::get_physical_device_properties2)},
7692 },
7693 VulkanCommand {
7694 name: "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR",
7695 features: smallvec![Feature::Extension(Extension::KHRPerformanceQuery)],
7696 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceQueueFamilyPerformanceQueryPassesKhr),
7697 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR, vk::PFN_vkVoidFunction>(Self::get_physical_device_queue_family_performance_query_passes_khr)},
7698 },
7699 VulkanCommand {
7700 name: "vkGetPhysicalDeviceQueueFamilyProperties",
7701 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0})],
7702 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceQueueFamilyProperties),
7703 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceQueueFamilyProperties, vk::PFN_vkVoidFunction>(Self::get_physical_device_queue_family_properties)},
7704 },
7705 VulkanCommand {
7706 name: "vkGetPhysicalDeviceQueueFamilyProperties2",
7707 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 1})],
7708 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceQueueFamilyProperties2),
7709 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceQueueFamilyProperties2, vk::PFN_vkVoidFunction>(Self::get_physical_device_queue_family_properties2)},
7710 },
7711 VulkanCommand {
7712 name: "vkGetPhysicalDeviceQueueFamilyProperties2KHR",
7713 features: smallvec![Feature::Extension(Extension::KHRGetPhysicalDeviceProperties2)],
7714 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceQueueFamilyProperties2),
7715 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceQueueFamilyProperties2, vk::PFN_vkVoidFunction>(Self::get_physical_device_queue_family_properties2)},
7716 },
7717 VulkanCommand {
7718 name: "vkGetPhysicalDeviceScreenPresentationSupportQNX",
7719 features: smallvec![Feature::Extension(Extension::QNXScreenSurface)],
7720 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceScreenPresentationSupportQnx),
7721 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX, vk::PFN_vkVoidFunction>(Self::get_physical_device_screen_presentation_support_qnx)},
7722 },
7723 VulkanCommand {
7724 name: "vkGetPhysicalDeviceSparseImageFormatProperties",
7725 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 0})],
7726 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceSparseImageFormatProperties),
7727 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceSparseImageFormatProperties, vk::PFN_vkVoidFunction>(Self::get_physical_device_sparse_image_format_properties)},
7728 },
7729 VulkanCommand {
7730 name: "vkGetPhysicalDeviceSparseImageFormatProperties2",
7731 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 1})],
7732 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceSparseImageFormatProperties2),
7733 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceSparseImageFormatProperties2, vk::PFN_vkVoidFunction>(Self::get_physical_device_sparse_image_format_properties2)},
7734 },
7735 VulkanCommand {
7736 name: "vkGetPhysicalDeviceSparseImageFormatProperties2KHR",
7737 features: smallvec![Feature::Extension(Extension::KHRGetPhysicalDeviceProperties2)],
7738 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceSparseImageFormatProperties2),
7739 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceSparseImageFormatProperties2, vk::PFN_vkVoidFunction>(Self::get_physical_device_sparse_image_format_properties2)},
7740 },
7741 VulkanCommand {
7742 name: "vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV",
7743 features: smallvec![Feature::Extension(Extension::NVCoverageReductionMode)],
7744 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNv),
7745 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV, vk::PFN_vkVoidFunction>(Self::get_physical_device_supported_framebuffer_mixed_samples_combinations_nv)},
7746 },
7747 VulkanCommand {
7748 name: "vkGetPhysicalDeviceSurfaceCapabilities2EXT",
7749 features: smallvec![Feature::Extension(Extension::EXTDisplaySurfaceCounter)],
7750 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceSurfaceCapabilities2Ext),
7751 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT, vk::PFN_vkVoidFunction>(Self::get_physical_device_surface_capabilities2_ext)},
7752 },
7753 VulkanCommand {
7754 name: "vkGetPhysicalDeviceSurfaceCapabilities2KHR",
7755 features: smallvec![Feature::Extension(Extension::KHRGetSurfaceCapabilities2)],
7756 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceSurfaceCapabilities2Khr),
7757 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR, vk::PFN_vkVoidFunction>(Self::get_physical_device_surface_capabilities2_khr)},
7758 },
7759 VulkanCommand {
7760 name: "vkGetPhysicalDeviceSurfaceCapabilitiesKHR",
7761 features: smallvec![Feature::Extension(Extension::KHRSurface)],
7762 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceSurfaceCapabilitiesKhr),
7763 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR, vk::PFN_vkVoidFunction>(Self::get_physical_device_surface_capabilities_khr)},
7764 },
7765 VulkanCommand {
7766 name: "vkGetPhysicalDeviceSurfaceFormats2KHR",
7767 features: smallvec![Feature::Extension(Extension::KHRGetSurfaceCapabilities2)],
7768 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceSurfaceFormats2Khr),
7769 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceSurfaceFormats2KHR, vk::PFN_vkVoidFunction>(Self::get_physical_device_surface_formats2_khr)},
7770 },
7771 VulkanCommand {
7772 name: "vkGetPhysicalDeviceSurfaceFormatsKHR",
7773 features: smallvec![Feature::Extension(Extension::KHRSurface)],
7774 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceSurfaceFormatsKhr),
7775 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceSurfaceFormatsKHR, vk::PFN_vkVoidFunction>(Self::get_physical_device_surface_formats_khr)},
7776 },
7777 VulkanCommand {
7778 name: "vkGetPhysicalDeviceSurfacePresentModes2EXT",
7779 features: smallvec![Feature::Extension(Extension::EXTFullScreenExclusive)],
7780 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceSurfacePresentModes2Ext),
7781 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT, vk::PFN_vkVoidFunction>(Self::get_physical_device_surface_present_modes2_ext)},
7782 },
7783 VulkanCommand {
7784 name: "vkGetPhysicalDeviceSurfacePresentModesKHR",
7785 features: smallvec![Feature::Extension(Extension::KHRSurface)],
7786 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceSurfacePresentModesKhr),
7787 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceSurfacePresentModesKHR, vk::PFN_vkVoidFunction>(Self::get_physical_device_surface_present_modes_khr)},
7788 },
7789 VulkanCommand {
7790 name: "vkGetPhysicalDeviceSurfaceSupportKHR",
7791 features: smallvec![Feature::Extension(Extension::KHRSurface)],
7792 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceSurfaceSupportKhr),
7793 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceSurfaceSupportKHR, vk::PFN_vkVoidFunction>(Self::get_physical_device_surface_support_khr)},
7794 },
7795 VulkanCommand {
7796 name: "vkGetPhysicalDeviceToolProperties",
7797 features: smallvec![Feature::Core(ApiVersion { major: 1, minor: 3})],
7798 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceToolProperties),
7799 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceToolProperties, vk::PFN_vkVoidFunction>(Self::get_physical_device_tool_properties)},
7800 },
7801 VulkanCommand {
7802 name: "vkGetPhysicalDeviceToolPropertiesEXT",
7803 features: smallvec![Feature::Extension(Extension::EXTToolingInfo)],
7804 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceToolProperties),
7805 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceToolProperties, vk::PFN_vkVoidFunction>(Self::get_physical_device_tool_properties)},
7806 },
7807 VulkanCommand {
7808 name: "vkGetPhysicalDeviceVideoCapabilitiesKHR",
7809 features: smallvec![Feature::Extension(Extension::KHRVideoQueue)],
7810 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceVideoCapabilitiesKhr),
7811 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR, vk::PFN_vkVoidFunction>(Self::get_physical_device_video_capabilities_khr)},
7812 },
7813 VulkanCommand {
7814 name: "vkGetPhysicalDeviceVideoFormatPropertiesKHR",
7815 features: smallvec![Feature::Extension(Extension::KHRVideoQueue)],
7816 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceVideoFormatPropertiesKhr),
7817 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR, vk::PFN_vkVoidFunction>(Self::get_physical_device_video_format_properties_khr)},
7818 },
7819 VulkanCommand {
7820 name: "vkGetPhysicalDeviceWaylandPresentationSupportKHR",
7821 features: smallvec![Feature::Extension(Extension::KHRWaylandSurface)],
7822 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceWaylandPresentationSupportKhr),
7823 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR, vk::PFN_vkVoidFunction>(Self::get_physical_device_wayland_presentation_support_khr)},
7824 },
7825 VulkanCommand {
7826 name: "vkGetPhysicalDeviceWin32PresentationSupportKHR",
7827 features: smallvec![Feature::Extension(Extension::KHRWin32Surface)],
7828 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceWin32PresentationSupportKhr),
7829 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR, vk::PFN_vkVoidFunction>(Self::get_physical_device_win32_presentation_support_khr)},
7830 },
7831 VulkanCommand {
7832 name: "vkGetPhysicalDeviceXcbPresentationSupportKHR",
7833 features: smallvec![Feature::Extension(Extension::KHRXcbSurface)],
7834 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceXcbPresentationSupportKhr),
7835 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR, vk::PFN_vkVoidFunction>(Self::get_physical_device_xcb_presentation_support_khr)},
7836 },
7837 VulkanCommand {
7838 name: "vkGetPhysicalDeviceXlibPresentationSupportKHR",
7839 features: smallvec![Feature::Extension(Extension::KHRXlibSurface)],
7840 hooked: hooked_commands.contains(&LayerVulkanCommand::GetPhysicalDeviceXlibPresentationSupportKhr),
7841 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR, vk::PFN_vkVoidFunction>(Self::get_physical_device_xlib_presentation_support_khr)},
7842 },
7843 VulkanCommand {
7844 name: "vkGetRandROutputDisplayEXT",
7845 features: smallvec![Feature::Extension(Extension::EXTAcquireXlibDisplay)],
7846 hooked: hooked_commands.contains(&LayerVulkanCommand::GetRandROutputDisplayExt),
7847 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetRandROutputDisplayEXT, vk::PFN_vkVoidFunction>(Self::get_rand_r_output_display_ext)},
7848 },
7849 VulkanCommand {
7850 name: "vkGetWinrtDisplayNV",
7851 features: smallvec![Feature::Extension(Extension::NVAcquireWinrtDisplay)],
7852 hooked: hooked_commands.contains(&LayerVulkanCommand::GetWinrtDisplayNv),
7853 proc: unsafe { std::mem::transmute::<vk::PFN_vkGetWinrtDisplayNV, vk::PFN_vkVoidFunction>(Self::get_winrt_display_nv)},
7854 },
7855 VulkanCommand {
7856 name: "vkReleaseDisplayEXT",
7857 features: smallvec![Feature::Extension(Extension::EXTDirectModeDisplay)],
7858 hooked: hooked_commands.contains(&LayerVulkanCommand::ReleaseDisplayExt),
7859 proc: unsafe { std::mem::transmute::<vk::PFN_vkReleaseDisplayEXT, vk::PFN_vkVoidFunction>(Self::release_display_ext)},
7860 },
7861 VulkanCommand {
7862 name: "vkSubmitDebugUtilsMessageEXT",
7863 features: smallvec![Feature::Extension(Extension::EXTDebugUtils)],
7864 hooked: hooked_commands.contains(&LayerVulkanCommand::SubmitDebugUtilsMessageExt),
7865 proc: unsafe { std::mem::transmute::<vk::PFN_vkSubmitDebugUtilsMessageEXT, vk::PFN_vkVoidFunction>(Self::submit_debug_utils_message_ext)},
7866 },
7867 ])
7868 }
7869 extern "system" fn get_physical_device_features(
7870 physical_device: vk::PhysicalDevice,
7871 p_features: *mut vk::PhysicalDeviceFeatures,
7872 ) {
7873 let global = Self::instance();
7874 let instance_info = global.get_instance_info(physical_device).unwrap();
7876 let dispatch_table = &instance_info.dispatch_table.core.fp_v1_0();
7877 let layer_result = instance_info
7878 .customized_info
7879 .borrow()
7880 .hooks()
7881 .get_physical_device_features(
7882 physical_device,
7883 unsafe { ptr_as_uninit_mut(p_features) }.unwrap(),
7884 );
7885 match layer_result {
7886 LayerResult::Handled(res) => res,
7887 LayerResult::Unhandled => unsafe {
7888 (dispatch_table.get_physical_device_features)(physical_device, p_features)
7889 },
7890 }
7891 }
7892 extern "system" fn get_physical_device_format_properties(
7893 physical_device: vk::PhysicalDevice,
7894 format: vk::Format,
7895 p_format_properties: *mut vk::FormatProperties,
7896 ) {
7897 let global = Self::instance();
7898 let instance_info = global.get_instance_info(physical_device).unwrap();
7900 let dispatch_table = &instance_info.dispatch_table.core.fp_v1_0();
7901 let layer_result = instance_info
7902 .customized_info
7903 .borrow()
7904 .hooks()
7905 .get_physical_device_format_properties(
7906 physical_device,
7907 format,
7908 unsafe { ptr_as_uninit_mut(p_format_properties) }.unwrap(),
7909 );
7910 match layer_result {
7911 LayerResult::Handled(res) => res,
7912 LayerResult::Unhandled => unsafe {
7913 (dispatch_table.get_physical_device_format_properties)(
7914 physical_device,
7915 format,
7916 p_format_properties,
7917 )
7918 },
7919 }
7920 }
7921 extern "system" fn get_physical_device_image_format_properties(
7922 physical_device: vk::PhysicalDevice,
7923 format: vk::Format,
7924 _type: vk::ImageType,
7925 tiling: vk::ImageTiling,
7926 usage: vk::ImageUsageFlags,
7927 flags: vk::ImageCreateFlags,
7928 p_image_format_properties: *mut vk::ImageFormatProperties,
7929 ) -> vk::Result {
7930 let global = Self::instance();
7931 let instance_info = global.get_instance_info(physical_device).unwrap();
7933 let dispatch_table = &instance_info.dispatch_table.core.fp_v1_0();
7934 let layer_result = instance_info
7935 .customized_info
7936 .borrow()
7937 .hooks()
7938 .get_physical_device_image_format_properties(
7939 physical_device,
7940 format,
7941 _type,
7942 tiling,
7943 usage,
7944 flags,
7945 unsafe { ptr_as_uninit_mut(p_image_format_properties) }.unwrap(),
7946 );
7947 match layer_result {
7948 LayerResult::Handled(res) => match res {
7949 Ok(()) => vk::Result::SUCCESS,
7950 Err(e) => e,
7951 },
7952 LayerResult::Unhandled => unsafe {
7953 (dispatch_table.get_physical_device_image_format_properties)(
7954 physical_device,
7955 format,
7956 _type,
7957 tiling,
7958 usage,
7959 flags,
7960 p_image_format_properties,
7961 )
7962 },
7963 }
7964 }
7965 extern "system" fn get_physical_device_properties(
7966 physical_device: vk::PhysicalDevice,
7967 p_properties: *mut vk::PhysicalDeviceProperties,
7968 ) {
7969 let global = Self::instance();
7970 let instance_info = global.get_instance_info(physical_device).unwrap();
7972 let dispatch_table = &instance_info.dispatch_table.core.fp_v1_0();
7973 let layer_result = instance_info
7974 .customized_info
7975 .borrow()
7976 .hooks()
7977 .get_physical_device_properties(
7978 physical_device,
7979 unsafe { ptr_as_uninit_mut(p_properties) }.unwrap(),
7980 );
7981 match layer_result {
7982 LayerResult::Handled(res) => res,
7983 LayerResult::Unhandled => unsafe {
7984 (dispatch_table.get_physical_device_properties)(physical_device, p_properties)
7985 },
7986 }
7987 }
7988 extern "system" fn get_physical_device_queue_family_properties(
7989 physical_device: vk::PhysicalDevice,
7990 p_queue_family_property_count: *mut u32,
7991 p_queue_family_properties: *mut vk::QueueFamilyProperties,
7992 ) {
7993 let global = Self::instance();
7994 let instance_info = global.get_instance_info(physical_device).unwrap();
7996 let dispatch_table = &instance_info.dispatch_table.core.fp_v1_0();
7997 let layer_result = instance_info
7998 .customized_info
7999 .borrow()
8000 .hooks()
8001 .get_physical_device_queue_family_properties(
8002 physical_device,
8003 unsafe { ptr_as_uninit_mut(p_queue_family_property_count) }.unwrap(),
8004 unsafe {
8005 maybe_uninit_slice_from_raw_parts_mut(
8006 p_queue_family_properties,
8007 p_queue_family_property_count,
8008 )
8009 },
8010 );
8011 match layer_result {
8012 LayerResult::Handled(res) => res,
8013 LayerResult::Unhandled => unsafe {
8014 (dispatch_table.get_physical_device_queue_family_properties)(
8015 physical_device,
8016 p_queue_family_property_count,
8017 p_queue_family_properties,
8018 )
8019 },
8020 }
8021 }
8022 extern "system" fn get_physical_device_memory_properties(
8023 physical_device: vk::PhysicalDevice,
8024 p_memory_properties: *mut vk::PhysicalDeviceMemoryProperties,
8025 ) {
8026 let global = Self::instance();
8027 let instance_info = global.get_instance_info(physical_device).unwrap();
8029 let dispatch_table = &instance_info.dispatch_table.core.fp_v1_0();
8030 let layer_result = instance_info
8031 .customized_info
8032 .borrow()
8033 .hooks()
8034 .get_physical_device_memory_properties(
8035 physical_device,
8036 unsafe { ptr_as_uninit_mut(p_memory_properties) }.unwrap(),
8037 );
8038 match layer_result {
8039 LayerResult::Handled(res) => res,
8040 LayerResult::Unhandled => unsafe {
8041 (dispatch_table.get_physical_device_memory_properties)(
8042 physical_device,
8043 p_memory_properties,
8044 )
8045 },
8046 }
8047 }
8048 extern "system" fn get_physical_device_sparse_image_format_properties(
8049 physical_device: vk::PhysicalDevice,
8050 format: vk::Format,
8051 _type: vk::ImageType,
8052 samples: vk::SampleCountFlags,
8053 usage: vk::ImageUsageFlags,
8054 tiling: vk::ImageTiling,
8055 p_property_count: *mut u32,
8056 p_properties: *mut vk::SparseImageFormatProperties,
8057 ) {
8058 let global = Self::instance();
8059 let instance_info = global.get_instance_info(physical_device).unwrap();
8061 let dispatch_table = &instance_info.dispatch_table.core.fp_v1_0();
8062 let layer_result = instance_info
8063 .customized_info
8064 .borrow()
8065 .hooks()
8066 .get_physical_device_sparse_image_format_properties(
8067 physical_device,
8068 format,
8069 _type,
8070 samples,
8071 usage,
8072 tiling,
8073 unsafe { ptr_as_uninit_mut(p_property_count) }.unwrap(),
8074 unsafe { maybe_uninit_slice_from_raw_parts_mut(p_properties, p_property_count) },
8075 );
8076 match layer_result {
8077 LayerResult::Handled(res) => res,
8078 LayerResult::Unhandled => unsafe {
8079 (dispatch_table.get_physical_device_sparse_image_format_properties)(
8080 physical_device,
8081 format,
8082 _type,
8083 samples,
8084 usage,
8085 tiling,
8086 p_property_count,
8087 p_properties,
8088 )
8089 },
8090 }
8091 }
8092 extern "system" fn get_physical_device_features2(
8093 physical_device: vk::PhysicalDevice,
8094 p_features: *mut vk::PhysicalDeviceFeatures2,
8095 ) {
8096 let global = Self::instance();
8097 let instance_info = global.get_instance_info(physical_device).unwrap();
8099 let dispatch_table = &instance_info.dispatch_table.core.fp_v1_1();
8100 let layer_result = instance_info
8101 .customized_info
8102 .borrow()
8103 .hooks()
8104 .get_physical_device_features2(
8105 physical_device,
8106 unsafe { ptr_as_uninit_mut(p_features) }.unwrap(),
8107 );
8108 match layer_result {
8109 LayerResult::Handled(res) => res,
8110 LayerResult::Unhandled => unsafe {
8111 (dispatch_table.get_physical_device_features2)(physical_device, p_features)
8112 },
8113 }
8114 }
8115 extern "system" fn get_physical_device_properties2(
8116 physical_device: vk::PhysicalDevice,
8117 p_properties: *mut vk::PhysicalDeviceProperties2,
8118 ) {
8119 let global = Self::instance();
8120 let instance_info = global.get_instance_info(physical_device).unwrap();
8122 let dispatch_table = &instance_info.dispatch_table.core.fp_v1_1();
8123 let layer_result = instance_info
8124 .customized_info
8125 .borrow()
8126 .hooks()
8127 .get_physical_device_properties2(
8128 physical_device,
8129 unsafe { ptr_as_uninit_mut(p_properties) }.unwrap(),
8130 );
8131 match layer_result {
8132 LayerResult::Handled(res) => res,
8133 LayerResult::Unhandled => unsafe {
8134 (dispatch_table.get_physical_device_properties2)(physical_device, p_properties)
8135 },
8136 }
8137 }
8138 extern "system" fn get_physical_device_format_properties2(
8139 physical_device: vk::PhysicalDevice,
8140 format: vk::Format,
8141 p_format_properties: *mut vk::FormatProperties2,
8142 ) {
8143 let global = Self::instance();
8144 let instance_info = global.get_instance_info(physical_device).unwrap();
8146 let dispatch_table = &instance_info.dispatch_table.core.fp_v1_1();
8147 let layer_result = instance_info
8148 .customized_info
8149 .borrow()
8150 .hooks()
8151 .get_physical_device_format_properties2(
8152 physical_device,
8153 format,
8154 unsafe { ptr_as_uninit_mut(p_format_properties) }.unwrap(),
8155 );
8156 match layer_result {
8157 LayerResult::Handled(res) => res,
8158 LayerResult::Unhandled => unsafe {
8159 (dispatch_table.get_physical_device_format_properties2)(
8160 physical_device,
8161 format,
8162 p_format_properties,
8163 )
8164 },
8165 }
8166 }
8167 extern "system" fn get_physical_device_image_format_properties2(
8168 physical_device: vk::PhysicalDevice,
8169 p_image_format_info: *const vk::PhysicalDeviceImageFormatInfo2,
8170 p_image_format_properties: *mut vk::ImageFormatProperties2,
8171 ) -> vk::Result {
8172 let global = Self::instance();
8173 let instance_info = global.get_instance_info(physical_device).unwrap();
8175 let dispatch_table = &instance_info.dispatch_table.core.fp_v1_1();
8176 let layer_result = instance_info
8177 .customized_info
8178 .borrow()
8179 .hooks()
8180 .get_physical_device_image_format_properties2(
8181 physical_device,
8182 unsafe { p_image_format_info.as_ref() }.unwrap(),
8183 unsafe { ptr_as_uninit_mut(p_image_format_properties) }.unwrap(),
8184 );
8185 match layer_result {
8186 LayerResult::Handled(res) => match res {
8187 Ok(()) => vk::Result::SUCCESS,
8188 Err(e) => e,
8189 },
8190 LayerResult::Unhandled => unsafe {
8191 (dispatch_table.get_physical_device_image_format_properties2)(
8192 physical_device,
8193 p_image_format_info,
8194 p_image_format_properties,
8195 )
8196 },
8197 }
8198 }
8199 extern "system" fn get_physical_device_queue_family_properties2(
8200 physical_device: vk::PhysicalDevice,
8201 p_queue_family_property_count: *mut u32,
8202 p_queue_family_properties: *mut vk::QueueFamilyProperties2,
8203 ) {
8204 let global = Self::instance();
8205 let instance_info = global.get_instance_info(physical_device).unwrap();
8207 let dispatch_table = &instance_info.dispatch_table.core.fp_v1_1();
8208 let layer_result = instance_info
8209 .customized_info
8210 .borrow()
8211 .hooks()
8212 .get_physical_device_queue_family_properties2(
8213 physical_device,
8214 unsafe { ptr_as_uninit_mut(p_queue_family_property_count) }.unwrap(),
8215 unsafe {
8216 maybe_uninit_slice_from_raw_parts_mut(
8217 p_queue_family_properties,
8218 p_queue_family_property_count,
8219 )
8220 },
8221 );
8222 match layer_result {
8223 LayerResult::Handled(res) => res,
8224 LayerResult::Unhandled => unsafe {
8225 (dispatch_table.get_physical_device_queue_family_properties2)(
8226 physical_device,
8227 p_queue_family_property_count,
8228 p_queue_family_properties,
8229 )
8230 },
8231 }
8232 }
8233 extern "system" fn get_physical_device_memory_properties2(
8234 physical_device: vk::PhysicalDevice,
8235 p_memory_properties: *mut vk::PhysicalDeviceMemoryProperties2,
8236 ) {
8237 let global = Self::instance();
8238 let instance_info = global.get_instance_info(physical_device).unwrap();
8240 let dispatch_table = &instance_info.dispatch_table.core.fp_v1_1();
8241 let layer_result = instance_info
8242 .customized_info
8243 .borrow()
8244 .hooks()
8245 .get_physical_device_memory_properties2(
8246 physical_device,
8247 unsafe { ptr_as_uninit_mut(p_memory_properties) }.unwrap(),
8248 );
8249 match layer_result {
8250 LayerResult::Handled(res) => res,
8251 LayerResult::Unhandled => unsafe {
8252 (dispatch_table.get_physical_device_memory_properties2)(
8253 physical_device,
8254 p_memory_properties,
8255 )
8256 },
8257 }
8258 }
8259 extern "system" fn get_physical_device_sparse_image_format_properties2(
8260 physical_device: vk::PhysicalDevice,
8261 p_format_info: *const vk::PhysicalDeviceSparseImageFormatInfo2,
8262 p_property_count: *mut u32,
8263 p_properties: *mut vk::SparseImageFormatProperties2,
8264 ) {
8265 let global = Self::instance();
8266 let instance_info = global.get_instance_info(physical_device).unwrap();
8268 let dispatch_table = &instance_info.dispatch_table.core.fp_v1_1();
8269 let layer_result = instance_info
8270 .customized_info
8271 .borrow()
8272 .hooks()
8273 .get_physical_device_sparse_image_format_properties2(
8274 physical_device,
8275 unsafe { p_format_info.as_ref() }.unwrap(),
8276 unsafe { ptr_as_uninit_mut(p_property_count) }.unwrap(),
8277 unsafe { maybe_uninit_slice_from_raw_parts_mut(p_properties, p_property_count) },
8278 );
8279 match layer_result {
8280 LayerResult::Handled(res) => res,
8281 LayerResult::Unhandled => unsafe {
8282 (dispatch_table.get_physical_device_sparse_image_format_properties2)(
8283 physical_device,
8284 p_format_info,
8285 p_property_count,
8286 p_properties,
8287 )
8288 },
8289 }
8290 }
8291 extern "system" fn get_physical_device_external_buffer_properties(
8292 physical_device: vk::PhysicalDevice,
8293 p_external_buffer_info: *const vk::PhysicalDeviceExternalBufferInfo,
8294 p_external_buffer_properties: *mut vk::ExternalBufferProperties,
8295 ) {
8296 let global = Self::instance();
8297 let instance_info = global.get_instance_info(physical_device).unwrap();
8299 let dispatch_table = &instance_info.dispatch_table.core.fp_v1_1();
8300 let layer_result = instance_info
8301 .customized_info
8302 .borrow()
8303 .hooks()
8304 .get_physical_device_external_buffer_properties(
8305 physical_device,
8306 unsafe { p_external_buffer_info.as_ref() }.unwrap(),
8307 unsafe { ptr_as_uninit_mut(p_external_buffer_properties) }.unwrap(),
8308 );
8309 match layer_result {
8310 LayerResult::Handled(res) => res,
8311 LayerResult::Unhandled => unsafe {
8312 (dispatch_table.get_physical_device_external_buffer_properties)(
8313 physical_device,
8314 p_external_buffer_info,
8315 p_external_buffer_properties,
8316 )
8317 },
8318 }
8319 }
8320 extern "system" fn get_physical_device_external_fence_properties(
8321 physical_device: vk::PhysicalDevice,
8322 p_external_fence_info: *const vk::PhysicalDeviceExternalFenceInfo,
8323 p_external_fence_properties: *mut vk::ExternalFenceProperties,
8324 ) {
8325 let global = Self::instance();
8326 let instance_info = global.get_instance_info(physical_device).unwrap();
8328 let dispatch_table = &instance_info.dispatch_table.core.fp_v1_1();
8329 let layer_result = instance_info
8330 .customized_info
8331 .borrow()
8332 .hooks()
8333 .get_physical_device_external_fence_properties(
8334 physical_device,
8335 unsafe { p_external_fence_info.as_ref() }.unwrap(),
8336 unsafe { ptr_as_uninit_mut(p_external_fence_properties) }.unwrap(),
8337 );
8338 match layer_result {
8339 LayerResult::Handled(res) => res,
8340 LayerResult::Unhandled => unsafe {
8341 (dispatch_table.get_physical_device_external_fence_properties)(
8342 physical_device,
8343 p_external_fence_info,
8344 p_external_fence_properties,
8345 )
8346 },
8347 }
8348 }
8349 extern "system" fn get_physical_device_external_semaphore_properties(
8350 physical_device: vk::PhysicalDevice,
8351 p_external_semaphore_info: *const vk::PhysicalDeviceExternalSemaphoreInfo,
8352 p_external_semaphore_properties: *mut vk::ExternalSemaphoreProperties,
8353 ) {
8354 let global = Self::instance();
8355 let instance_info = global.get_instance_info(physical_device).unwrap();
8357 let dispatch_table = &instance_info.dispatch_table.core.fp_v1_1();
8358 let layer_result = instance_info
8359 .customized_info
8360 .borrow()
8361 .hooks()
8362 .get_physical_device_external_semaphore_properties(
8363 physical_device,
8364 unsafe { p_external_semaphore_info.as_ref() }.unwrap(),
8365 unsafe { ptr_as_uninit_mut(p_external_semaphore_properties) }.unwrap(),
8366 );
8367 match layer_result {
8368 LayerResult::Handled(res) => res,
8369 LayerResult::Unhandled => unsafe {
8370 (dispatch_table.get_physical_device_external_semaphore_properties)(
8371 physical_device,
8372 p_external_semaphore_info,
8373 p_external_semaphore_properties,
8374 )
8375 },
8376 }
8377 }
8378 extern "system" fn get_physical_device_tool_properties(
8379 physical_device: vk::PhysicalDevice,
8380 p_tool_count: *mut u32,
8381 p_tool_properties: *mut vk::PhysicalDeviceToolProperties,
8382 ) -> vk::Result {
8383 let global = Self::instance();
8384 let instance_info = global.get_instance_info(physical_device).unwrap();
8386 let dispatch_table = &instance_info.dispatch_table.core.fp_v1_3();
8387 let layer_result = instance_info
8388 .customized_info
8389 .borrow()
8390 .hooks()
8391 .get_physical_device_tool_properties(
8392 physical_device,
8393 unsafe { ptr_as_uninit_mut(p_tool_count) }.unwrap(),
8394 unsafe { maybe_uninit_slice_from_raw_parts_mut(p_tool_properties, p_tool_count) },
8395 );
8396 match layer_result {
8397 LayerResult::Handled(res) => match res {
8398 Ok(()) => vk::Result::SUCCESS,
8399 Err(e) => e,
8400 },
8401 LayerResult::Unhandled => unsafe {
8402 (dispatch_table.get_physical_device_tool_properties)(
8403 physical_device,
8404 p_tool_count,
8405 p_tool_properties,
8406 )
8407 },
8408 }
8409 }
8410 extern "system" fn destroy_surface_khr(
8411 instance: vk::Instance,
8412 surface: vk::SurfaceKHR,
8413 p_allocator: *const vk::AllocationCallbacks,
8414 ) {
8415 let global = Self::instance();
8416 let instance_info = global.get_instance_info(instance).unwrap();
8418 let dispatch_table = &instance_info.dispatch_table.khr_surface;
8419 let layer_result = instance_info
8420 .customized_info
8421 .borrow()
8422 .hooks()
8423 .destroy_surface_khr(surface, unsafe { p_allocator.as_ref() });
8424 match layer_result {
8425 LayerResult::Handled(res) => res,
8426 LayerResult::Unhandled => unsafe {
8427 (dispatch_table.destroy_surface_khr)(instance, surface, p_allocator)
8428 },
8429 }
8430 }
8431 extern "system" fn get_physical_device_surface_support_khr(
8432 physical_device: vk::PhysicalDevice,
8433 queue_family_index: u32,
8434 surface: vk::SurfaceKHR,
8435 p_supported: *mut vk::Bool32,
8436 ) -> vk::Result {
8437 let global = Self::instance();
8438 let instance_info = global.get_instance_info(physical_device).unwrap();
8440 let dispatch_table = &instance_info.dispatch_table.khr_surface;
8441 let layer_result = instance_info
8442 .customized_info
8443 .borrow()
8444 .hooks()
8445 .get_physical_device_surface_support_khr(physical_device, queue_family_index, surface);
8446 match layer_result {
8447 LayerResult::Handled(res) => match res {
8448 Ok(res) => {
8449 *unsafe { p_supported.as_mut() }.unwrap() =
8450 if res { vk::TRUE } else { vk::FALSE };
8451 vk::Result::SUCCESS
8452 }
8453 Err(e) => e,
8454 },
8455 LayerResult::Unhandled => unsafe {
8456 (dispatch_table.get_physical_device_surface_support_khr)(
8457 physical_device,
8458 queue_family_index,
8459 surface,
8460 p_supported,
8461 )
8462 },
8463 }
8464 }
8465 extern "system" fn get_physical_device_surface_capabilities_khr(
8466 physical_device: vk::PhysicalDevice,
8467 surface: vk::SurfaceKHR,
8468 p_surface_capabilities: *mut vk::SurfaceCapabilitiesKHR,
8469 ) -> vk::Result {
8470 let global = Self::instance();
8471 let instance_info = global.get_instance_info(physical_device).unwrap();
8473 let dispatch_table = &instance_info.dispatch_table.khr_surface;
8474 let layer_result = instance_info
8475 .customized_info
8476 .borrow()
8477 .hooks()
8478 .get_physical_device_surface_capabilities_khr(
8479 physical_device,
8480 surface,
8481 unsafe { ptr_as_uninit_mut(p_surface_capabilities) }.unwrap(),
8482 );
8483 match layer_result {
8484 LayerResult::Handled(res) => match res {
8485 Ok(()) => vk::Result::SUCCESS,
8486 Err(e) => e,
8487 },
8488 LayerResult::Unhandled => unsafe {
8489 (dispatch_table.get_physical_device_surface_capabilities_khr)(
8490 physical_device,
8491 surface,
8492 p_surface_capabilities,
8493 )
8494 },
8495 }
8496 }
8497 extern "system" fn get_physical_device_surface_formats_khr(
8498 physical_device: vk::PhysicalDevice,
8499 surface: vk::SurfaceKHR,
8500 p_surface_format_count: *mut u32,
8501 p_surface_formats: *mut vk::SurfaceFormatKHR,
8502 ) -> vk::Result {
8503 let global = Self::instance();
8504 let instance_info = global.get_instance_info(physical_device).unwrap();
8506 let dispatch_table = &instance_info.dispatch_table.khr_surface;
8507 let layer_result = instance_info
8508 .customized_info
8509 .borrow()
8510 .hooks()
8511 .get_physical_device_surface_formats_khr(
8512 physical_device,
8513 surface,
8514 unsafe { ptr_as_uninit_mut(p_surface_format_count) }.unwrap(),
8515 unsafe {
8516 maybe_uninit_slice_from_raw_parts_mut(p_surface_formats, p_surface_format_count)
8517 },
8518 );
8519 match layer_result {
8520 LayerResult::Handled(res) => match res {
8521 Ok(()) => vk::Result::SUCCESS,
8522 Err(e) => e,
8523 },
8524 LayerResult::Unhandled => unsafe {
8525 (dispatch_table.get_physical_device_surface_formats_khr)(
8526 physical_device,
8527 surface,
8528 p_surface_format_count,
8529 p_surface_formats,
8530 )
8531 },
8532 }
8533 }
8534 extern "system" fn get_physical_device_surface_present_modes_khr(
8535 physical_device: vk::PhysicalDevice,
8536 surface: vk::SurfaceKHR,
8537 p_present_mode_count: *mut u32,
8538 p_present_modes: *mut vk::PresentModeKHR,
8539 ) -> vk::Result {
8540 let global = Self::instance();
8541 let instance_info = global.get_instance_info(physical_device).unwrap();
8543 let dispatch_table = &instance_info.dispatch_table.khr_surface;
8544 let layer_result = instance_info
8545 .customized_info
8546 .borrow()
8547 .hooks()
8548 .get_physical_device_surface_present_modes_khr(physical_device, surface);
8549 match layer_result {
8550 LayerResult::Handled(res) => match res {
8551 Ok(res) => unsafe {
8552 fill_vk_out_array(
8553 &res,
8554 NonNull::new(p_present_mode_count).unwrap(),
8555 p_present_modes,
8556 )
8557 },
8558 Err(e) => e,
8559 },
8560 LayerResult::Unhandled => unsafe {
8561 (dispatch_table.get_physical_device_surface_present_modes_khr)(
8562 physical_device,
8563 surface,
8564 p_present_mode_count,
8565 p_present_modes,
8566 )
8567 },
8568 }
8569 }
8570 extern "system" fn get_physical_device_present_rectangles_khr(
8571 physical_device: vk::PhysicalDevice,
8572 surface: vk::SurfaceKHR,
8573 p_rect_count: *mut u32,
8574 p_rects: *mut vk::Rect2D,
8575 ) -> vk::Result {
8576 let global = Self::instance();
8577 let instance_info = global.get_instance_info(physical_device).unwrap();
8579 let dispatch_table = &instance_info.dispatch_table.khr_swapchain;
8580 let layer_result = instance_info
8581 .customized_info
8582 .borrow()
8583 .hooks()
8584 .get_physical_device_present_rectangles_khr(
8585 physical_device,
8586 surface,
8587 unsafe { ptr_as_uninit_mut(p_rect_count) }.unwrap(),
8588 unsafe { maybe_uninit_slice_from_raw_parts_mut(p_rects, p_rect_count) },
8589 );
8590 match layer_result {
8591 LayerResult::Handled(res) => match res {
8592 Ok(()) => vk::Result::SUCCESS,
8593 Err(e) => e,
8594 },
8595 LayerResult::Unhandled => unsafe {
8596 (dispatch_table.get_physical_device_present_rectangles_khr)(
8597 physical_device,
8598 surface,
8599 p_rect_count,
8600 p_rects,
8601 )
8602 },
8603 }
8604 }
8605 extern "system" fn get_physical_device_display_properties_khr(
8606 physical_device: vk::PhysicalDevice,
8607 p_property_count: *mut u32,
8608 p_properties: *mut vk::DisplayPropertiesKHR,
8609 ) -> vk::Result {
8610 let global = Self::instance();
8611 let instance_info = global.get_instance_info(physical_device).unwrap();
8613 let dispatch_table = &instance_info.dispatch_table.khr_display;
8614 let layer_result = instance_info
8615 .customized_info
8616 .borrow()
8617 .hooks()
8618 .get_physical_device_display_properties_khr(
8619 physical_device,
8620 unsafe { ptr_as_uninit_mut(p_property_count) }.unwrap(),
8621 unsafe { maybe_uninit_slice_from_raw_parts_mut(p_properties, p_property_count) },
8622 );
8623 match layer_result {
8624 LayerResult::Handled(res) => match res {
8625 Ok(()) => vk::Result::SUCCESS,
8626 Err(e) => e,
8627 },
8628 LayerResult::Unhandled => unsafe {
8629 (dispatch_table.get_physical_device_display_properties_khr)(
8630 physical_device,
8631 p_property_count,
8632 p_properties,
8633 )
8634 },
8635 }
8636 }
8637 extern "system" fn get_physical_device_display_plane_properties_khr(
8638 physical_device: vk::PhysicalDevice,
8639 p_property_count: *mut u32,
8640 p_properties: *mut vk::DisplayPlanePropertiesKHR,
8641 ) -> vk::Result {
8642 let global = Self::instance();
8643 let instance_info = global.get_instance_info(physical_device).unwrap();
8645 let dispatch_table = &instance_info.dispatch_table.khr_display;
8646 let layer_result = instance_info
8647 .customized_info
8648 .borrow()
8649 .hooks()
8650 .get_physical_device_display_plane_properties_khr(
8651 physical_device,
8652 unsafe { ptr_as_uninit_mut(p_property_count) }.unwrap(),
8653 unsafe { maybe_uninit_slice_from_raw_parts_mut(p_properties, p_property_count) },
8654 );
8655 match layer_result {
8656 LayerResult::Handled(res) => match res {
8657 Ok(()) => vk::Result::SUCCESS,
8658 Err(e) => e,
8659 },
8660 LayerResult::Unhandled => unsafe {
8661 (dispatch_table.get_physical_device_display_plane_properties_khr)(
8662 physical_device,
8663 p_property_count,
8664 p_properties,
8665 )
8666 },
8667 }
8668 }
8669 extern "system" fn get_display_plane_supported_displays_khr(
8670 physical_device: vk::PhysicalDevice,
8671 plane_index: u32,
8672 p_display_count: *mut u32,
8673 p_displays: *mut vk::DisplayKHR,
8674 ) -> vk::Result {
8675 let global = Self::instance();
8676 let instance_info = global.get_instance_info(physical_device).unwrap();
8678 let dispatch_table = &instance_info.dispatch_table.khr_display;
8679 let layer_result = instance_info
8680 .customized_info
8681 .borrow()
8682 .hooks()
8683 .get_display_plane_supported_displays_khr(physical_device, plane_index);
8684 match layer_result {
8685 LayerResult::Handled(res) => match res {
8686 Ok(res) => unsafe {
8687 fill_vk_out_array(&res, NonNull::new(p_display_count).unwrap(), p_displays)
8688 },
8689 Err(e) => e,
8690 },
8691 LayerResult::Unhandled => unsafe {
8692 (dispatch_table.get_display_plane_supported_displays_khr)(
8693 physical_device,
8694 plane_index,
8695 p_display_count,
8696 p_displays,
8697 )
8698 },
8699 }
8700 }
8701 extern "system" fn get_display_mode_properties_khr(
8702 physical_device: vk::PhysicalDevice,
8703 display: vk::DisplayKHR,
8704 p_property_count: *mut u32,
8705 p_properties: *mut vk::DisplayModePropertiesKHR,
8706 ) -> vk::Result {
8707 let global = Self::instance();
8708 let instance_info = global.get_instance_info(physical_device).unwrap();
8710 let dispatch_table = &instance_info.dispatch_table.khr_display;
8711 let layer_result = instance_info
8712 .customized_info
8713 .borrow()
8714 .hooks()
8715 .get_display_mode_properties_khr(
8716 physical_device,
8717 display,
8718 unsafe { ptr_as_uninit_mut(p_property_count) }.unwrap(),
8719 unsafe { maybe_uninit_slice_from_raw_parts_mut(p_properties, p_property_count) },
8720 );
8721 match layer_result {
8722 LayerResult::Handled(res) => match res {
8723 Ok(()) => vk::Result::SUCCESS,
8724 Err(e) => e,
8725 },
8726 LayerResult::Unhandled => unsafe {
8727 (dispatch_table.get_display_mode_properties_khr)(
8728 physical_device,
8729 display,
8730 p_property_count,
8731 p_properties,
8732 )
8733 },
8734 }
8735 }
8736 extern "system" fn create_display_mode_khr(
8737 physical_device: vk::PhysicalDevice,
8738 display: vk::DisplayKHR,
8739 p_create_info: *const vk::DisplayModeCreateInfoKHR,
8740 p_allocator: *const vk::AllocationCallbacks,
8741 p_mode: *mut vk::DisplayModeKHR,
8742 ) -> vk::Result {
8743 let global = Self::instance();
8744 let instance_info = global.get_instance_info(physical_device).unwrap();
8746 let dispatch_table = &instance_info.dispatch_table.khr_display;
8747 let layer_result = instance_info
8748 .customized_info
8749 .borrow()
8750 .hooks()
8751 .create_display_mode_khr(
8752 physical_device,
8753 display,
8754 unsafe { p_create_info.as_ref() }.unwrap(),
8755 unsafe { p_allocator.as_ref() },
8756 );
8757 match layer_result {
8758 LayerResult::Handled(res) => match res {
8759 Ok(res) => {
8760 *unsafe { p_mode.as_mut() }.unwrap() = res;
8761 vk::Result::SUCCESS
8762 }
8763 Err(e) => e,
8764 },
8765 LayerResult::Unhandled => unsafe {
8766 (dispatch_table.create_display_mode_khr)(
8767 physical_device,
8768 display,
8769 p_create_info,
8770 p_allocator,
8771 p_mode,
8772 )
8773 },
8774 }
8775 }
8776 extern "system" fn get_display_plane_capabilities_khr(
8777 physical_device: vk::PhysicalDevice,
8778 mode: vk::DisplayModeKHR,
8779 plane_index: u32,
8780 p_capabilities: *mut vk::DisplayPlaneCapabilitiesKHR,
8781 ) -> vk::Result {
8782 let global = Self::instance();
8783 let instance_info = global.get_instance_info(physical_device).unwrap();
8785 let dispatch_table = &instance_info.dispatch_table.khr_display;
8786 let layer_result = instance_info
8787 .customized_info
8788 .borrow()
8789 .hooks()
8790 .get_display_plane_capabilities_khr(
8791 physical_device,
8792 mode,
8793 plane_index,
8794 unsafe { ptr_as_uninit_mut(p_capabilities) }.unwrap(),
8795 );
8796 match layer_result {
8797 LayerResult::Handled(res) => match res {
8798 Ok(()) => vk::Result::SUCCESS,
8799 Err(e) => e,
8800 },
8801 LayerResult::Unhandled => unsafe {
8802 (dispatch_table.get_display_plane_capabilities_khr)(
8803 physical_device,
8804 mode,
8805 plane_index,
8806 p_capabilities,
8807 )
8808 },
8809 }
8810 }
8811 extern "system" fn create_display_plane_surface_khr(
8812 instance: vk::Instance,
8813 p_create_info: *const vk::DisplaySurfaceCreateInfoKHR,
8814 p_allocator: *const vk::AllocationCallbacks,
8815 p_surface: *mut vk::SurfaceKHR,
8816 ) -> vk::Result {
8817 let global = Self::instance();
8818 let instance_info = global.get_instance_info(instance).unwrap();
8820 let dispatch_table = &instance_info.dispatch_table.khr_display;
8821 let layer_result = instance_info
8822 .customized_info
8823 .borrow()
8824 .hooks()
8825 .create_display_plane_surface_khr(unsafe { p_create_info.as_ref() }.unwrap(), unsafe {
8826 p_allocator.as_ref()
8827 });
8828 match layer_result {
8829 LayerResult::Handled(res) => match res {
8830 Ok(res) => {
8831 *unsafe { p_surface.as_mut() }.unwrap() = res;
8832 vk::Result::SUCCESS
8833 }
8834 Err(e) => e,
8835 },
8836 LayerResult::Unhandled => unsafe {
8837 (dispatch_table.create_display_plane_surface_khr)(
8838 instance,
8839 p_create_info,
8840 p_allocator,
8841 p_surface,
8842 )
8843 },
8844 }
8845 }
8846 extern "system" fn create_xlib_surface_khr(
8847 instance: vk::Instance,
8848 p_create_info: *const vk::XlibSurfaceCreateInfoKHR,
8849 p_allocator: *const vk::AllocationCallbacks,
8850 p_surface: *mut vk::SurfaceKHR,
8851 ) -> vk::Result {
8852 let global = Self::instance();
8853 let instance_info = global.get_instance_info(instance).unwrap();
8855 let dispatch_table = &instance_info.dispatch_table.khr_xlib_surface;
8856 let layer_result = instance_info
8857 .customized_info
8858 .borrow()
8859 .hooks()
8860 .create_xlib_surface_khr(unsafe { p_create_info.as_ref() }.unwrap(), unsafe {
8861 p_allocator.as_ref()
8862 });
8863 match layer_result {
8864 LayerResult::Handled(res) => match res {
8865 Ok(res) => {
8866 *unsafe { p_surface.as_mut() }.unwrap() = res;
8867 vk::Result::SUCCESS
8868 }
8869 Err(e) => e,
8870 },
8871 LayerResult::Unhandled => unsafe {
8872 (dispatch_table.create_xlib_surface_khr)(
8873 instance,
8874 p_create_info,
8875 p_allocator,
8876 p_surface,
8877 )
8878 },
8879 }
8880 }
8881 extern "system" fn get_physical_device_xlib_presentation_support_khr(
8882 physical_device: vk::PhysicalDevice,
8883 queue_family_index: u32,
8884 dpy: *mut vk::Display,
8885 visual_id: vk::VisualID,
8886 ) -> vk::Bool32 {
8887 let global = Self::instance();
8888 let instance_info = global.get_instance_info(physical_device).unwrap();
8890 let dispatch_table = &instance_info.dispatch_table.khr_xlib_surface;
8891 let layer_result = instance_info
8892 .customized_info
8893 .borrow()
8894 .hooks()
8895 .get_physical_device_xlib_presentation_support_khr(
8896 physical_device,
8897 queue_family_index,
8898 unsafe { ptr_as_uninit_mut(dpy) }.unwrap(),
8899 visual_id,
8900 );
8901 match layer_result {
8902 LayerResult::Handled(res) => {
8903 if res {
8904 vk::TRUE
8905 } else {
8906 vk::FALSE
8907 }
8908 }
8909 LayerResult::Unhandled => unsafe {
8910 (dispatch_table.get_physical_device_xlib_presentation_support_khr)(
8911 physical_device,
8912 queue_family_index,
8913 dpy,
8914 visual_id,
8915 )
8916 },
8917 }
8918 }
8919 extern "system" fn create_xcb_surface_khr(
8920 instance: vk::Instance,
8921 p_create_info: *const vk::XcbSurfaceCreateInfoKHR,
8922 p_allocator: *const vk::AllocationCallbacks,
8923 p_surface: *mut vk::SurfaceKHR,
8924 ) -> vk::Result {
8925 let global = Self::instance();
8926 let instance_info = global.get_instance_info(instance).unwrap();
8928 let dispatch_table = &instance_info.dispatch_table.khr_xcb_surface;
8929 let layer_result = instance_info
8930 .customized_info
8931 .borrow()
8932 .hooks()
8933 .create_xcb_surface_khr(unsafe { p_create_info.as_ref() }.unwrap(), unsafe {
8934 p_allocator.as_ref()
8935 });
8936 match layer_result {
8937 LayerResult::Handled(res) => match res {
8938 Ok(res) => {
8939 *unsafe { p_surface.as_mut() }.unwrap() = res;
8940 vk::Result::SUCCESS
8941 }
8942 Err(e) => e,
8943 },
8944 LayerResult::Unhandled => unsafe {
8945 (dispatch_table.create_xcb_surface_khr)(
8946 instance,
8947 p_create_info,
8948 p_allocator,
8949 p_surface,
8950 )
8951 },
8952 }
8953 }
8954 extern "system" fn get_physical_device_xcb_presentation_support_khr(
8955 physical_device: vk::PhysicalDevice,
8956 queue_family_index: u32,
8957 connection: *mut vk::xcb_connection_t,
8958 visual_id: vk::xcb_visualid_t,
8959 ) -> vk::Bool32 {
8960 let global = Self::instance();
8961 let instance_info = global.get_instance_info(physical_device).unwrap();
8963 let dispatch_table = &instance_info.dispatch_table.khr_xcb_surface;
8964 let layer_result = instance_info
8965 .customized_info
8966 .borrow()
8967 .hooks()
8968 .get_physical_device_xcb_presentation_support_khr(
8969 physical_device,
8970 queue_family_index,
8971 connection,
8972 visual_id,
8973 );
8974 match layer_result {
8975 LayerResult::Handled(res) => {
8976 if res {
8977 vk::TRUE
8978 } else {
8979 vk::FALSE
8980 }
8981 }
8982 LayerResult::Unhandled => unsafe {
8983 (dispatch_table.get_physical_device_xcb_presentation_support_khr)(
8984 physical_device,
8985 queue_family_index,
8986 connection,
8987 visual_id,
8988 )
8989 },
8990 }
8991 }
8992 extern "system" fn create_wayland_surface_khr(
8993 instance: vk::Instance,
8994 p_create_info: *const vk::WaylandSurfaceCreateInfoKHR,
8995 p_allocator: *const vk::AllocationCallbacks,
8996 p_surface: *mut vk::SurfaceKHR,
8997 ) -> vk::Result {
8998 let global = Self::instance();
8999 let instance_info = global.get_instance_info(instance).unwrap();
9001 let dispatch_table = &instance_info.dispatch_table.khr_wayland_surface;
9002 let layer_result = instance_info
9003 .customized_info
9004 .borrow()
9005 .hooks()
9006 .create_wayland_surface_khr(unsafe { p_create_info.as_ref() }.unwrap(), unsafe {
9007 p_allocator.as_ref()
9008 });
9009 match layer_result {
9010 LayerResult::Handled(res) => match res {
9011 Ok(res) => {
9012 *unsafe { p_surface.as_mut() }.unwrap() = res;
9013 vk::Result::SUCCESS
9014 }
9015 Err(e) => e,
9016 },
9017 LayerResult::Unhandled => unsafe {
9018 (dispatch_table.create_wayland_surface_khr)(
9019 instance,
9020 p_create_info,
9021 p_allocator,
9022 p_surface,
9023 )
9024 },
9025 }
9026 }
9027 extern "system" fn get_physical_device_wayland_presentation_support_khr(
9028 physical_device: vk::PhysicalDevice,
9029 queue_family_index: u32,
9030 display: *mut vk::wl_display,
9031 ) -> vk::Bool32 {
9032 let global = Self::instance();
9033 let instance_info = global.get_instance_info(physical_device).unwrap();
9035 let dispatch_table = &instance_info.dispatch_table.khr_wayland_surface;
9036 let layer_result = instance_info
9037 .customized_info
9038 .borrow()
9039 .hooks()
9040 .get_physical_device_wayland_presentation_support_khr(
9041 physical_device,
9042 queue_family_index,
9043 display,
9044 );
9045 match layer_result {
9046 LayerResult::Handled(res) => {
9047 if res {
9048 vk::TRUE
9049 } else {
9050 vk::FALSE
9051 }
9052 }
9053 LayerResult::Unhandled => unsafe {
9054 (dispatch_table.get_physical_device_wayland_presentation_support_khr)(
9055 physical_device,
9056 queue_family_index,
9057 display,
9058 )
9059 },
9060 }
9061 }
9062 extern "system" fn create_android_surface_khr(
9063 instance: vk::Instance,
9064 p_create_info: *const vk::AndroidSurfaceCreateInfoKHR,
9065 p_allocator: *const vk::AllocationCallbacks,
9066 p_surface: *mut vk::SurfaceKHR,
9067 ) -> vk::Result {
9068 let global = Self::instance();
9069 let instance_info = global.get_instance_info(instance).unwrap();
9071 let dispatch_table = &instance_info.dispatch_table.khr_android_surface;
9072 let layer_result = instance_info
9073 .customized_info
9074 .borrow()
9075 .hooks()
9076 .create_android_surface_khr(unsafe { p_create_info.as_ref() }.unwrap(), unsafe {
9077 p_allocator.as_ref()
9078 });
9079 match layer_result {
9080 LayerResult::Handled(res) => match res {
9081 Ok(res) => {
9082 *unsafe { p_surface.as_mut() }.unwrap() = res;
9083 vk::Result::SUCCESS
9084 }
9085 Err(e) => e,
9086 },
9087 LayerResult::Unhandled => unsafe {
9088 (dispatch_table.create_android_surface_khr)(
9089 instance,
9090 p_create_info,
9091 p_allocator,
9092 p_surface,
9093 )
9094 },
9095 }
9096 }
9097 extern "system" fn create_win32_surface_khr(
9098 instance: vk::Instance,
9099 p_create_info: *const vk::Win32SurfaceCreateInfoKHR,
9100 p_allocator: *const vk::AllocationCallbacks,
9101 p_surface: *mut vk::SurfaceKHR,
9102 ) -> vk::Result {
9103 let global = Self::instance();
9104 let instance_info = global.get_instance_info(instance).unwrap();
9106 let dispatch_table = &instance_info.dispatch_table.khr_win32_surface;
9107 let layer_result = instance_info
9108 .customized_info
9109 .borrow()
9110 .hooks()
9111 .create_win32_surface_khr(unsafe { p_create_info.as_ref() }.unwrap(), unsafe {
9112 p_allocator.as_ref()
9113 });
9114 match layer_result {
9115 LayerResult::Handled(res) => match res {
9116 Ok(res) => {
9117 *unsafe { p_surface.as_mut() }.unwrap() = res;
9118 vk::Result::SUCCESS
9119 }
9120 Err(e) => e,
9121 },
9122 LayerResult::Unhandled => unsafe {
9123 (dispatch_table.create_win32_surface_khr)(
9124 instance,
9125 p_create_info,
9126 p_allocator,
9127 p_surface,
9128 )
9129 },
9130 }
9131 }
9132 extern "system" fn get_physical_device_win32_presentation_support_khr(
9133 physical_device: vk::PhysicalDevice,
9134 queue_family_index: u32,
9135 ) -> vk::Bool32 {
9136 let global = Self::instance();
9137 let instance_info = global.get_instance_info(physical_device).unwrap();
9139 let dispatch_table = &instance_info.dispatch_table.khr_win32_surface;
9140 let layer_result = instance_info
9141 .customized_info
9142 .borrow()
9143 .hooks()
9144 .get_physical_device_win32_presentation_support_khr(
9145 physical_device,
9146 queue_family_index,
9147 );
9148 match layer_result {
9149 LayerResult::Handled(res) => {
9150 if res {
9151 vk::TRUE
9152 } else {
9153 vk::FALSE
9154 }
9155 }
9156 LayerResult::Unhandled => unsafe {
9157 (dispatch_table.get_physical_device_win32_presentation_support_khr)(
9158 physical_device,
9159 queue_family_index,
9160 )
9161 },
9162 }
9163 }
9164 extern "system" fn get_physical_device_video_capabilities_khr(
9165 physical_device: vk::PhysicalDevice,
9166 p_video_profile: *const vk::VideoProfileInfoKHR,
9167 p_capabilities: *mut vk::VideoCapabilitiesKHR,
9168 ) -> vk::Result {
9169 let global = Self::instance();
9170 let instance_info = global.get_instance_info(physical_device).unwrap();
9172 let dispatch_table = &instance_info.dispatch_table.khr_video_queue;
9173 let layer_result = instance_info
9174 .customized_info
9175 .borrow()
9176 .hooks()
9177 .get_physical_device_video_capabilities_khr(
9178 physical_device,
9179 unsafe { p_video_profile.as_ref() }.unwrap(),
9180 unsafe { ptr_as_uninit_mut(p_capabilities) }.unwrap(),
9181 );
9182 match layer_result {
9183 LayerResult::Handled(res) => match res {
9184 Ok(()) => vk::Result::SUCCESS,
9185 Err(e) => e,
9186 },
9187 LayerResult::Unhandled => unsafe {
9188 (dispatch_table.get_physical_device_video_capabilities_khr)(
9189 physical_device,
9190 p_video_profile,
9191 p_capabilities,
9192 )
9193 },
9194 }
9195 }
9196 extern "system" fn get_physical_device_video_format_properties_khr(
9197 physical_device: vk::PhysicalDevice,
9198 p_video_format_info: *const vk::PhysicalDeviceVideoFormatInfoKHR,
9199 p_video_format_property_count: *mut u32,
9200 p_video_format_properties: *mut vk::VideoFormatPropertiesKHR,
9201 ) -> vk::Result {
9202 let global = Self::instance();
9203 let instance_info = global.get_instance_info(physical_device).unwrap();
9205 let dispatch_table = &instance_info.dispatch_table.khr_video_queue;
9206 let layer_result = instance_info
9207 .customized_info
9208 .borrow()
9209 .hooks()
9210 .get_physical_device_video_format_properties_khr(
9211 physical_device,
9212 unsafe { p_video_format_info.as_ref() }.unwrap(),
9213 unsafe { ptr_as_uninit_mut(p_video_format_property_count) }.unwrap(),
9214 unsafe {
9215 maybe_uninit_slice_from_raw_parts_mut(
9216 p_video_format_properties,
9217 p_video_format_property_count,
9218 )
9219 },
9220 );
9221 match layer_result {
9222 LayerResult::Handled(res) => match res {
9223 Ok(()) => vk::Result::SUCCESS,
9224 Err(e) => e,
9225 },
9226 LayerResult::Unhandled => unsafe {
9227 (dispatch_table.get_physical_device_video_format_properties_khr)(
9228 physical_device,
9229 p_video_format_info,
9230 p_video_format_property_count,
9231 p_video_format_properties,
9232 )
9233 },
9234 }
9235 }
9236 extern "system" fn enumerate_physical_device_queue_family_performance_query_counters_khr(
9237 physical_device: vk::PhysicalDevice,
9238 queue_family_index: u32,
9239 p_counter_count: *mut u32,
9240 p_counters: *mut vk::PerformanceCounterKHR,
9241 p_counter_descriptions: *mut vk::PerformanceCounterDescriptionKHR,
9242 ) -> vk::Result {
9243 let global = Self::instance();
9244 let instance_info = global.get_instance_info(physical_device).unwrap();
9246 let dispatch_table = &instance_info.dispatch_table.khr_performance_query;
9247 let layer_result = instance_info
9248 .customized_info
9249 .borrow()
9250 .hooks()
9251 .enumerate_physical_device_queue_family_performance_query_counters_khr(
9252 physical_device,
9253 queue_family_index,
9254 unsafe { ptr_as_uninit_mut(p_counter_count) }.unwrap(),
9255 unsafe { maybe_uninit_slice_from_raw_parts_mut(p_counters, p_counter_count) },
9256 unsafe {
9257 maybe_uninit_slice_from_raw_parts_mut(p_counter_descriptions, p_counter_count)
9258 },
9259 );
9260 match layer_result {
9261 LayerResult::Handled(res) => match res {
9262 Ok(()) => vk::Result::SUCCESS,
9263 Err(e) => e,
9264 },
9265 LayerResult::Unhandled => unsafe {
9266 (dispatch_table
9267 .enumerate_physical_device_queue_family_performance_query_counters_khr)(
9268 physical_device,
9269 queue_family_index,
9270 p_counter_count,
9271 p_counters,
9272 p_counter_descriptions,
9273 )
9274 },
9275 }
9276 }
9277 extern "system" fn get_physical_device_queue_family_performance_query_passes_khr(
9278 physical_device: vk::PhysicalDevice,
9279 p_performance_query_create_info: *const vk::QueryPoolPerformanceCreateInfoKHR,
9280 p_num_passes: *mut u32,
9281 ) {
9282 let global = Self::instance();
9283 let instance_info = global.get_instance_info(physical_device).unwrap();
9285 let dispatch_table = &instance_info.dispatch_table.khr_performance_query;
9286 let layer_result = instance_info
9287 .customized_info
9288 .borrow()
9289 .hooks()
9290 .get_physical_device_queue_family_performance_query_passes_khr(
9291 physical_device,
9292 unsafe { p_performance_query_create_info.as_ref() }.unwrap(),
9293 );
9294 match layer_result {
9295 LayerResult::Handled(res) => {
9296 *unsafe { p_num_passes.as_mut() }.unwrap() = res;
9297 }
9298 LayerResult::Unhandled => unsafe {
9299 (dispatch_table.get_physical_device_queue_family_performance_query_passes_khr)(
9300 physical_device,
9301 p_performance_query_create_info,
9302 p_num_passes,
9303 )
9304 },
9305 }
9306 }
9307 extern "system" fn get_physical_device_surface_capabilities2_khr(
9308 physical_device: vk::PhysicalDevice,
9309 p_surface_info: *const vk::PhysicalDeviceSurfaceInfo2KHR,
9310 p_surface_capabilities: *mut vk::SurfaceCapabilities2KHR,
9311 ) -> vk::Result {
9312 let global = Self::instance();
9313 let instance_info = global.get_instance_info(physical_device).unwrap();
9315 let dispatch_table = &instance_info.dispatch_table.khr_get_surface_capabilities2;
9316 let layer_result = instance_info
9317 .customized_info
9318 .borrow()
9319 .hooks()
9320 .get_physical_device_surface_capabilities2_khr(
9321 physical_device,
9322 unsafe { p_surface_info.as_ref() }.unwrap(),
9323 unsafe { ptr_as_uninit_mut(p_surface_capabilities) }.unwrap(),
9324 );
9325 match layer_result {
9326 LayerResult::Handled(res) => match res {
9327 Ok(()) => vk::Result::SUCCESS,
9328 Err(e) => e,
9329 },
9330 LayerResult::Unhandled => unsafe {
9331 (dispatch_table.get_physical_device_surface_capabilities2_khr)(
9332 physical_device,
9333 p_surface_info,
9334 p_surface_capabilities,
9335 )
9336 },
9337 }
9338 }
9339 extern "system" fn get_physical_device_surface_formats2_khr(
9340 physical_device: vk::PhysicalDevice,
9341 p_surface_info: *const vk::PhysicalDeviceSurfaceInfo2KHR,
9342 p_surface_format_count: *mut u32,
9343 p_surface_formats: *mut vk::SurfaceFormat2KHR,
9344 ) -> vk::Result {
9345 let global = Self::instance();
9346 let instance_info = global.get_instance_info(physical_device).unwrap();
9348 let dispatch_table = &instance_info.dispatch_table.khr_get_surface_capabilities2;
9349 let layer_result = instance_info
9350 .customized_info
9351 .borrow()
9352 .hooks()
9353 .get_physical_device_surface_formats2_khr(
9354 physical_device,
9355 unsafe { p_surface_info.as_ref() }.unwrap(),
9356 unsafe { ptr_as_uninit_mut(p_surface_format_count) }.unwrap(),
9357 unsafe {
9358 maybe_uninit_slice_from_raw_parts_mut(p_surface_formats, p_surface_format_count)
9359 },
9360 );
9361 match layer_result {
9362 LayerResult::Handled(res) => match res {
9363 Ok(()) => vk::Result::SUCCESS,
9364 Err(e) => e,
9365 },
9366 LayerResult::Unhandled => unsafe {
9367 (dispatch_table.get_physical_device_surface_formats2_khr)(
9368 physical_device,
9369 p_surface_info,
9370 p_surface_format_count,
9371 p_surface_formats,
9372 )
9373 },
9374 }
9375 }
9376 extern "system" fn get_physical_device_display_properties2_khr(
9377 physical_device: vk::PhysicalDevice,
9378 p_property_count: *mut u32,
9379 p_properties: *mut vk::DisplayProperties2KHR,
9380 ) -> vk::Result {
9381 let global = Self::instance();
9382 let instance_info = global.get_instance_info(physical_device).unwrap();
9384 let dispatch_table = &instance_info.dispatch_table.khr_get_display_properties2;
9385 let layer_result = instance_info
9386 .customized_info
9387 .borrow()
9388 .hooks()
9389 .get_physical_device_display_properties2_khr(
9390 physical_device,
9391 unsafe { ptr_as_uninit_mut(p_property_count) }.unwrap(),
9392 unsafe { maybe_uninit_slice_from_raw_parts_mut(p_properties, p_property_count) },
9393 );
9394 match layer_result {
9395 LayerResult::Handled(res) => match res {
9396 Ok(()) => vk::Result::SUCCESS,
9397 Err(e) => e,
9398 },
9399 LayerResult::Unhandled => unsafe {
9400 (dispatch_table.get_physical_device_display_properties2_khr)(
9401 physical_device,
9402 p_property_count,
9403 p_properties,
9404 )
9405 },
9406 }
9407 }
9408 extern "system" fn get_physical_device_display_plane_properties2_khr(
9409 physical_device: vk::PhysicalDevice,
9410 p_property_count: *mut u32,
9411 p_properties: *mut vk::DisplayPlaneProperties2KHR,
9412 ) -> vk::Result {
9413 let global = Self::instance();
9414 let instance_info = global.get_instance_info(physical_device).unwrap();
9416 let dispatch_table = &instance_info.dispatch_table.khr_get_display_properties2;
9417 let layer_result = instance_info
9418 .customized_info
9419 .borrow()
9420 .hooks()
9421 .get_physical_device_display_plane_properties2_khr(
9422 physical_device,
9423 unsafe { ptr_as_uninit_mut(p_property_count) }.unwrap(),
9424 unsafe { maybe_uninit_slice_from_raw_parts_mut(p_properties, p_property_count) },
9425 );
9426 match layer_result {
9427 LayerResult::Handled(res) => match res {
9428 Ok(()) => vk::Result::SUCCESS,
9429 Err(e) => e,
9430 },
9431 LayerResult::Unhandled => unsafe {
9432 (dispatch_table.get_physical_device_display_plane_properties2_khr)(
9433 physical_device,
9434 p_property_count,
9435 p_properties,
9436 )
9437 },
9438 }
9439 }
9440 extern "system" fn get_display_mode_properties2_khr(
9441 physical_device: vk::PhysicalDevice,
9442 display: vk::DisplayKHR,
9443 p_property_count: *mut u32,
9444 p_properties: *mut vk::DisplayModeProperties2KHR,
9445 ) -> vk::Result {
9446 let global = Self::instance();
9447 let instance_info = global.get_instance_info(physical_device).unwrap();
9449 let dispatch_table = &instance_info.dispatch_table.khr_get_display_properties2;
9450 let layer_result = instance_info
9451 .customized_info
9452 .borrow()
9453 .hooks()
9454 .get_display_mode_properties2_khr(
9455 physical_device,
9456 display,
9457 unsafe { ptr_as_uninit_mut(p_property_count) }.unwrap(),
9458 unsafe { maybe_uninit_slice_from_raw_parts_mut(p_properties, p_property_count) },
9459 );
9460 match layer_result {
9461 LayerResult::Handled(res) => match res {
9462 Ok(()) => vk::Result::SUCCESS,
9463 Err(e) => e,
9464 },
9465 LayerResult::Unhandled => unsafe {
9466 (dispatch_table.get_display_mode_properties2_khr)(
9467 physical_device,
9468 display,
9469 p_property_count,
9470 p_properties,
9471 )
9472 },
9473 }
9474 }
9475 extern "system" fn get_display_plane_capabilities2_khr(
9476 physical_device: vk::PhysicalDevice,
9477 p_display_plane_info: *const vk::DisplayPlaneInfo2KHR,
9478 p_capabilities: *mut vk::DisplayPlaneCapabilities2KHR,
9479 ) -> vk::Result {
9480 let global = Self::instance();
9481 let instance_info = global.get_instance_info(physical_device).unwrap();
9483 let dispatch_table = &instance_info.dispatch_table.khr_get_display_properties2;
9484 let layer_result = instance_info
9485 .customized_info
9486 .borrow()
9487 .hooks()
9488 .get_display_plane_capabilities2_khr(
9489 physical_device,
9490 unsafe { p_display_plane_info.as_ref() }.unwrap(),
9491 unsafe { ptr_as_uninit_mut(p_capabilities) }.unwrap(),
9492 );
9493 match layer_result {
9494 LayerResult::Handled(res) => match res {
9495 Ok(()) => vk::Result::SUCCESS,
9496 Err(e) => e,
9497 },
9498 LayerResult::Unhandled => unsafe {
9499 (dispatch_table.get_display_plane_capabilities2_khr)(
9500 physical_device,
9501 p_display_plane_info,
9502 p_capabilities,
9503 )
9504 },
9505 }
9506 }
9507 extern "system" fn get_physical_device_fragment_shading_rates_khr(
9508 physical_device: vk::PhysicalDevice,
9509 p_fragment_shading_rate_count: *mut u32,
9510 p_fragment_shading_rates: *mut vk::PhysicalDeviceFragmentShadingRateKHR,
9511 ) -> vk::Result {
9512 let global = Self::instance();
9513 let instance_info = global.get_instance_info(physical_device).unwrap();
9515 let dispatch_table = &instance_info.dispatch_table.khr_fragment_shading_rate;
9516 let layer_result = instance_info
9517 .customized_info
9518 .borrow()
9519 .hooks()
9520 .get_physical_device_fragment_shading_rates_khr(
9521 physical_device,
9522 unsafe { ptr_as_uninit_mut(p_fragment_shading_rate_count) }.unwrap(),
9523 unsafe {
9524 maybe_uninit_slice_from_raw_parts_mut(
9525 p_fragment_shading_rates,
9526 p_fragment_shading_rate_count,
9527 )
9528 },
9529 );
9530 match layer_result {
9531 LayerResult::Handled(res) => match res {
9532 Ok(()) => vk::Result::SUCCESS,
9533 Err(e) => e,
9534 },
9535 LayerResult::Unhandled => unsafe {
9536 (dispatch_table.get_physical_device_fragment_shading_rates_khr)(
9537 physical_device,
9538 p_fragment_shading_rate_count,
9539 p_fragment_shading_rates,
9540 )
9541 },
9542 }
9543 }
9544 extern "system" fn create_debug_report_callback_ext(
9545 instance: vk::Instance,
9546 p_create_info: *const vk::DebugReportCallbackCreateInfoEXT,
9547 p_allocator: *const vk::AllocationCallbacks,
9548 p_callback: *mut vk::DebugReportCallbackEXT,
9549 ) -> vk::Result {
9550 let global = Self::instance();
9551 let instance_info = global.get_instance_info(instance).unwrap();
9553 let dispatch_table = &instance_info.dispatch_table.ext_debug_report;
9554 let layer_result = instance_info
9555 .customized_info
9556 .borrow()
9557 .hooks()
9558 .create_debug_report_callback_ext(unsafe { p_create_info.as_ref() }.unwrap(), unsafe {
9559 p_allocator.as_ref()
9560 });
9561 match layer_result {
9562 LayerResult::Handled(res) => match res {
9563 Ok(res) => {
9564 *unsafe { p_callback.as_mut() }.unwrap() = res;
9565 vk::Result::SUCCESS
9566 }
9567 Err(e) => e,
9568 },
9569 LayerResult::Unhandled => unsafe {
9570 (dispatch_table.create_debug_report_callback_ext)(
9571 instance,
9572 p_create_info,
9573 p_allocator,
9574 p_callback,
9575 )
9576 },
9577 }
9578 }
9579 extern "system" fn destroy_debug_report_callback_ext(
9580 instance: vk::Instance,
9581 callback: vk::DebugReportCallbackEXT,
9582 p_allocator: *const vk::AllocationCallbacks,
9583 ) {
9584 let global = Self::instance();
9585 let instance_info = global.get_instance_info(instance).unwrap();
9587 let dispatch_table = &instance_info.dispatch_table.ext_debug_report;
9588 let layer_result = instance_info
9589 .customized_info
9590 .borrow()
9591 .hooks()
9592 .destroy_debug_report_callback_ext(callback, unsafe { p_allocator.as_ref() });
9593 match layer_result {
9594 LayerResult::Handled(res) => res,
9595 LayerResult::Unhandled => unsafe {
9596 (dispatch_table.destroy_debug_report_callback_ext)(instance, callback, p_allocator)
9597 },
9598 }
9599 }
9600 extern "system" fn debug_report_message_ext(
9601 instance: vk::Instance,
9602 flags: vk::DebugReportFlagsEXT,
9603 object_type: vk::DebugReportObjectTypeEXT,
9604 object: u64,
9605 location: usize,
9606 message_code: i32,
9607 p_layer_prefix: *const c_char,
9608 p_message: *const c_char,
9609 ) {
9610 let global = Self::instance();
9611 let instance_info = global.get_instance_info(instance).unwrap();
9613 let dispatch_table = &instance_info.dispatch_table.ext_debug_report;
9614 let layer_result = instance_info
9615 .customized_info
9616 .borrow()
9617 .hooks()
9618 .debug_report_message_ext(
9619 flags,
9620 object_type,
9621 object,
9622 location,
9623 message_code,
9624 unsafe { CStr::from_ptr(p_layer_prefix) }.to_str().unwrap(),
9625 unsafe { CStr::from_ptr(p_message) }.to_str().unwrap(),
9626 );
9627 match layer_result {
9628 LayerResult::Handled(res) => res,
9629 LayerResult::Unhandled => unsafe {
9630 (dispatch_table.debug_report_message_ext)(
9631 instance,
9632 flags,
9633 object_type,
9634 object,
9635 location,
9636 message_code,
9637 p_layer_prefix,
9638 p_message,
9639 )
9640 },
9641 }
9642 }
9643 extern "system" fn create_stream_descriptor_surface_ggp(
9644 instance: vk::Instance,
9645 p_create_info: *const vk::StreamDescriptorSurfaceCreateInfoGGP,
9646 p_allocator: *const vk::AllocationCallbacks,
9647 p_surface: *mut vk::SurfaceKHR,
9648 ) -> vk::Result {
9649 let global = Self::instance();
9650 let instance_info = global.get_instance_info(instance).unwrap();
9652 let dispatch_table = &instance_info.dispatch_table.ggp_stream_descriptor_surface;
9653 let layer_result = instance_info
9654 .customized_info
9655 .borrow()
9656 .hooks()
9657 .create_stream_descriptor_surface_ggp(
9658 unsafe { p_create_info.as_ref() }.unwrap(),
9659 unsafe { p_allocator.as_ref() },
9660 );
9661 match layer_result {
9662 LayerResult::Handled(res) => match res {
9663 Ok(res) => {
9664 *unsafe { p_surface.as_mut() }.unwrap() = res;
9665 vk::Result::SUCCESS
9666 }
9667 Err(e) => e,
9668 },
9669 LayerResult::Unhandled => unsafe {
9670 (dispatch_table.create_stream_descriptor_surface_ggp)(
9671 instance,
9672 p_create_info,
9673 p_allocator,
9674 p_surface,
9675 )
9676 },
9677 }
9678 }
9679 extern "system" fn get_physical_device_external_image_format_properties_nv(
9680 physical_device: vk::PhysicalDevice,
9681 format: vk::Format,
9682 _type: vk::ImageType,
9683 tiling: vk::ImageTiling,
9684 usage: vk::ImageUsageFlags,
9685 flags: vk::ImageCreateFlags,
9686 external_handle_type: vk::ExternalMemoryHandleTypeFlagsNV,
9687 p_external_image_format_properties: *mut vk::ExternalImageFormatPropertiesNV,
9688 ) -> vk::Result {
9689 let global = Self::instance();
9690 let instance_info = global.get_instance_info(physical_device).unwrap();
9692 let dispatch_table = &instance_info.dispatch_table.nv_external_memory_capabilities;
9693 let layer_result = instance_info
9694 .customized_info
9695 .borrow()
9696 .hooks()
9697 .get_physical_device_external_image_format_properties_nv(
9698 physical_device,
9699 format,
9700 _type,
9701 tiling,
9702 usage,
9703 flags,
9704 external_handle_type,
9705 unsafe { ptr_as_uninit_mut(p_external_image_format_properties) }.unwrap(),
9706 );
9707 match layer_result {
9708 LayerResult::Handled(res) => match res {
9709 Ok(()) => vk::Result::SUCCESS,
9710 Err(e) => e,
9711 },
9712 LayerResult::Unhandled => unsafe {
9713 (dispatch_table.get_physical_device_external_image_format_properties_nv)(
9714 physical_device,
9715 format,
9716 _type,
9717 tiling,
9718 usage,
9719 flags,
9720 external_handle_type,
9721 p_external_image_format_properties,
9722 )
9723 },
9724 }
9725 }
9726 extern "system" fn create_vi_surface_nn(
9727 instance: vk::Instance,
9728 p_create_info: *const vk::ViSurfaceCreateInfoNN,
9729 p_allocator: *const vk::AllocationCallbacks,
9730 p_surface: *mut vk::SurfaceKHR,
9731 ) -> vk::Result {
9732 let global = Self::instance();
9733 let instance_info = global.get_instance_info(instance).unwrap();
9735 let dispatch_table = &instance_info.dispatch_table.nn_vi_surface;
9736 let layer_result = instance_info
9737 .customized_info
9738 .borrow()
9739 .hooks()
9740 .create_vi_surface_nn(unsafe { p_create_info.as_ref() }.unwrap(), unsafe {
9741 p_allocator.as_ref()
9742 });
9743 match layer_result {
9744 LayerResult::Handled(res) => match res {
9745 Ok(res) => {
9746 *unsafe { p_surface.as_mut() }.unwrap() = res;
9747 vk::Result::SUCCESS
9748 }
9749 Err(e) => e,
9750 },
9751 LayerResult::Unhandled => unsafe {
9752 (dispatch_table.create_vi_surface_nn)(
9753 instance,
9754 p_create_info,
9755 p_allocator,
9756 p_surface,
9757 )
9758 },
9759 }
9760 }
9761 extern "system" fn release_display_ext(
9762 physical_device: vk::PhysicalDevice,
9763 display: vk::DisplayKHR,
9764 ) -> vk::Result {
9765 let global = Self::instance();
9766 let instance_info = global.get_instance_info(physical_device).unwrap();
9768 let dispatch_table = &instance_info.dispatch_table.ext_direct_mode_display;
9769 let layer_result = instance_info
9770 .customized_info
9771 .borrow()
9772 .hooks()
9773 .release_display_ext(physical_device, display);
9774 match layer_result {
9775 LayerResult::Handled(res) => match res {
9776 Ok(()) => vk::Result::SUCCESS,
9777 Err(e) => e,
9778 },
9779 LayerResult::Unhandled => unsafe {
9780 (dispatch_table.release_display_ext)(physical_device, display)
9781 },
9782 }
9783 }
9784 extern "system" fn acquire_xlib_display_ext(
9785 physical_device: vk::PhysicalDevice,
9786 dpy: *mut vk::Display,
9787 display: vk::DisplayKHR,
9788 ) -> vk::Result {
9789 let global = Self::instance();
9790 let instance_info = global.get_instance_info(physical_device).unwrap();
9792 let dispatch_table = &instance_info.dispatch_table.ext_acquire_xlib_display;
9793 let layer_result = instance_info
9794 .customized_info
9795 .borrow()
9796 .hooks()
9797 .acquire_xlib_display_ext(
9798 physical_device,
9799 unsafe { ptr_as_uninit_mut(dpy) }.unwrap(),
9800 display,
9801 );
9802 match layer_result {
9803 LayerResult::Handled(res) => match res {
9804 Ok(()) => vk::Result::SUCCESS,
9805 Err(e) => e,
9806 },
9807 LayerResult::Unhandled => unsafe {
9808 (dispatch_table.acquire_xlib_display_ext)(physical_device, dpy, display)
9809 },
9810 }
9811 }
9812 extern "system" fn get_rand_r_output_display_ext(
9813 physical_device: vk::PhysicalDevice,
9814 dpy: *mut vk::Display,
9815 rr_output: vk::RROutput,
9816 p_display: *mut vk::DisplayKHR,
9817 ) -> vk::Result {
9818 let global = Self::instance();
9819 let instance_info = global.get_instance_info(physical_device).unwrap();
9821 let dispatch_table = &instance_info.dispatch_table.ext_acquire_xlib_display;
9822 let layer_result = instance_info
9823 .customized_info
9824 .borrow()
9825 .hooks()
9826 .get_rand_r_output_display_ext(
9827 physical_device,
9828 unsafe { ptr_as_uninit_mut(dpy) }.unwrap(),
9829 rr_output,
9830 );
9831 match layer_result {
9832 LayerResult::Handled(res) => match res {
9833 Ok(res) => {
9834 *unsafe { p_display.as_mut() }.unwrap() = res;
9835 vk::Result::SUCCESS
9836 }
9837 Err(e) => e,
9838 },
9839 LayerResult::Unhandled => unsafe {
9840 (dispatch_table.get_rand_r_output_display_ext)(
9841 physical_device,
9842 dpy,
9843 rr_output,
9844 p_display,
9845 )
9846 },
9847 }
9848 }
9849 extern "system" fn get_physical_device_surface_capabilities2_ext(
9850 physical_device: vk::PhysicalDevice,
9851 surface: vk::SurfaceKHR,
9852 p_surface_capabilities: *mut vk::SurfaceCapabilities2EXT,
9853 ) -> vk::Result {
9854 let global = Self::instance();
9855 let instance_info = global.get_instance_info(physical_device).unwrap();
9857 let dispatch_table = &instance_info.dispatch_table.ext_display_surface_counter;
9858 let layer_result = instance_info
9859 .customized_info
9860 .borrow()
9861 .hooks()
9862 .get_physical_device_surface_capabilities2_ext(
9863 physical_device,
9864 surface,
9865 unsafe { ptr_as_uninit_mut(p_surface_capabilities) }.unwrap(),
9866 );
9867 match layer_result {
9868 LayerResult::Handled(res) => match res {
9869 Ok(()) => vk::Result::SUCCESS,
9870 Err(e) => e,
9871 },
9872 LayerResult::Unhandled => unsafe {
9873 (dispatch_table.get_physical_device_surface_capabilities2_ext)(
9874 physical_device,
9875 surface,
9876 p_surface_capabilities,
9877 )
9878 },
9879 }
9880 }
9881 extern "system" fn create_ios_surface_mvk(
9882 instance: vk::Instance,
9883 p_create_info: *const vk::IOSSurfaceCreateInfoMVK,
9884 p_allocator: *const vk::AllocationCallbacks,
9885 p_surface: *mut vk::SurfaceKHR,
9886 ) -> vk::Result {
9887 let global = Self::instance();
9888 let instance_info = global.get_instance_info(instance).unwrap();
9890 let dispatch_table = &instance_info.dispatch_table.mvk_ios_surface;
9891 let layer_result = instance_info
9892 .customized_info
9893 .borrow()
9894 .hooks()
9895 .create_ios_surface_mvk(unsafe { p_create_info.as_ref() }.unwrap(), unsafe {
9896 p_allocator.as_ref()
9897 });
9898 match layer_result {
9899 LayerResult::Handled(res) => match res {
9900 Ok(res) => {
9901 *unsafe { p_surface.as_mut() }.unwrap() = res;
9902 vk::Result::SUCCESS
9903 }
9904 Err(e) => e,
9905 },
9906 LayerResult::Unhandled => unsafe {
9907 (dispatch_table.create_ios_surface_mvk)(
9908 instance,
9909 p_create_info,
9910 p_allocator,
9911 p_surface,
9912 )
9913 },
9914 }
9915 }
9916 extern "system" fn create_mac_os_surface_mvk(
9917 instance: vk::Instance,
9918 p_create_info: *const vk::MacOSSurfaceCreateInfoMVK,
9919 p_allocator: *const vk::AllocationCallbacks,
9920 p_surface: *mut vk::SurfaceKHR,
9921 ) -> vk::Result {
9922 let global = Self::instance();
9923 let instance_info = global.get_instance_info(instance).unwrap();
9925 let dispatch_table = &instance_info.dispatch_table.mvk_macos_surface;
9926 let layer_result = instance_info
9927 .customized_info
9928 .borrow()
9929 .hooks()
9930 .create_mac_os_surface_mvk(unsafe { p_create_info.as_ref() }.unwrap(), unsafe {
9931 p_allocator.as_ref()
9932 });
9933 match layer_result {
9934 LayerResult::Handled(res) => match res {
9935 Ok(res) => {
9936 *unsafe { p_surface.as_mut() }.unwrap() = res;
9937 vk::Result::SUCCESS
9938 }
9939 Err(e) => e,
9940 },
9941 LayerResult::Unhandled => unsafe {
9942 (dispatch_table.create_mac_os_surface_mvk)(
9943 instance,
9944 p_create_info,
9945 p_allocator,
9946 p_surface,
9947 )
9948 },
9949 }
9950 }
9951 extern "system" fn create_debug_utils_messenger_ext(
9952 instance: vk::Instance,
9953 p_create_info: *const vk::DebugUtilsMessengerCreateInfoEXT,
9954 p_allocator: *const vk::AllocationCallbacks,
9955 p_messenger: *mut vk::DebugUtilsMessengerEXT,
9956 ) -> vk::Result {
9957 let global = Self::instance();
9958 let instance_info = global.get_instance_info(instance).unwrap();
9960 let dispatch_table = &instance_info.dispatch_table.ext_debug_utils;
9961 let layer_result = instance_info
9962 .customized_info
9963 .borrow()
9964 .hooks()
9965 .create_debug_utils_messenger_ext(unsafe { p_create_info.as_ref() }.unwrap(), unsafe {
9966 p_allocator.as_ref()
9967 });
9968 match layer_result {
9969 LayerResult::Handled(res) => match res {
9970 Ok(res) => {
9971 *unsafe { p_messenger.as_mut() }.unwrap() = res;
9972 vk::Result::SUCCESS
9973 }
9974 Err(e) => e,
9975 },
9976 LayerResult::Unhandled => unsafe {
9977 (dispatch_table.create_debug_utils_messenger_ext)(
9978 instance,
9979 p_create_info,
9980 p_allocator,
9981 p_messenger,
9982 )
9983 },
9984 }
9985 }
9986 extern "system" fn destroy_debug_utils_messenger_ext(
9987 instance: vk::Instance,
9988 messenger: vk::DebugUtilsMessengerEXT,
9989 p_allocator: *const vk::AllocationCallbacks,
9990 ) {
9991 let global = Self::instance();
9992 let instance_info = global.get_instance_info(instance).unwrap();
9994 let dispatch_table = &instance_info.dispatch_table.ext_debug_utils;
9995 let layer_result = instance_info
9996 .customized_info
9997 .borrow()
9998 .hooks()
9999 .destroy_debug_utils_messenger_ext(messenger, unsafe { p_allocator.as_ref() });
10000 match layer_result {
10001 LayerResult::Handled(res) => res,
10002 LayerResult::Unhandled => unsafe {
10003 (dispatch_table.destroy_debug_utils_messenger_ext)(instance, messenger, p_allocator)
10004 },
10005 }
10006 }
10007 extern "system" fn submit_debug_utils_message_ext(
10008 instance: vk::Instance,
10009 message_severity: vk::DebugUtilsMessageSeverityFlagsEXT,
10010 message_types: vk::DebugUtilsMessageTypeFlagsEXT,
10011 p_callback_data: *const vk::DebugUtilsMessengerCallbackDataEXT,
10012 ) {
10013 let global = Self::instance();
10014 let instance_info = global.get_instance_info(instance).unwrap();
10016 let dispatch_table = &instance_info.dispatch_table.ext_debug_utils;
10017 let layer_result = instance_info
10018 .customized_info
10019 .borrow()
10020 .hooks()
10021 .submit_debug_utils_message_ext(
10022 message_severity,
10023 message_types,
10024 unsafe { p_callback_data.as_ref() }.unwrap(),
10025 );
10026 match layer_result {
10027 LayerResult::Handled(res) => res,
10028 LayerResult::Unhandled => unsafe {
10029 (dispatch_table.submit_debug_utils_message_ext)(
10030 instance,
10031 message_severity,
10032 message_types,
10033 p_callback_data,
10034 )
10035 },
10036 }
10037 }
10038 extern "system" fn get_physical_device_multisample_properties_ext(
10039 physical_device: vk::PhysicalDevice,
10040 samples: vk::SampleCountFlags,
10041 p_multisample_properties: *mut vk::MultisamplePropertiesEXT,
10042 ) {
10043 let global = Self::instance();
10044 let instance_info = global.get_instance_info(physical_device).unwrap();
10046 let dispatch_table = &instance_info.dispatch_table.ext_sample_locations;
10047 let layer_result = instance_info
10048 .customized_info
10049 .borrow()
10050 .hooks()
10051 .get_physical_device_multisample_properties_ext(
10052 physical_device,
10053 samples,
10054 unsafe { ptr_as_uninit_mut(p_multisample_properties) }.unwrap(),
10055 );
10056 match layer_result {
10057 LayerResult::Handled(res) => res,
10058 LayerResult::Unhandled => unsafe {
10059 (dispatch_table.get_physical_device_multisample_properties_ext)(
10060 physical_device,
10061 samples,
10062 p_multisample_properties,
10063 )
10064 },
10065 }
10066 }
10067 extern "system" fn get_physical_device_calibrateable_time_domains_ext(
10068 physical_device: vk::PhysicalDevice,
10069 p_time_domain_count: *mut u32,
10070 p_time_domains: *mut vk::TimeDomainEXT,
10071 ) -> vk::Result {
10072 let global = Self::instance();
10073 let instance_info = global.get_instance_info(physical_device).unwrap();
10075 let dispatch_table = &instance_info.dispatch_table.ext_calibrated_timestamps;
10076 let layer_result = instance_info
10077 .customized_info
10078 .borrow()
10079 .hooks()
10080 .get_physical_device_calibrateable_time_domains_ext(physical_device);
10081 match layer_result {
10082 LayerResult::Handled(res) => match res {
10083 Ok(res) => unsafe {
10084 fill_vk_out_array(
10085 &res,
10086 NonNull::new(p_time_domain_count).unwrap(),
10087 p_time_domains,
10088 )
10089 },
10090 Err(e) => e,
10091 },
10092 LayerResult::Unhandled => unsafe {
10093 (dispatch_table.get_physical_device_calibrateable_time_domains_ext)(
10094 physical_device,
10095 p_time_domain_count,
10096 p_time_domains,
10097 )
10098 },
10099 }
10100 }
10101 extern "system" fn create_image_pipe_surface_fuchsia(
10102 instance: vk::Instance,
10103 p_create_info: *const vk::ImagePipeSurfaceCreateInfoFUCHSIA,
10104 p_allocator: *const vk::AllocationCallbacks,
10105 p_surface: *mut vk::SurfaceKHR,
10106 ) -> vk::Result {
10107 let global = Self::instance();
10108 let instance_info = global.get_instance_info(instance).unwrap();
10110 let dispatch_table = &instance_info.dispatch_table.fuchsia_imagepipe_surface;
10111 let layer_result = instance_info
10112 .customized_info
10113 .borrow()
10114 .hooks()
10115 .create_image_pipe_surface_fuchsia(
10116 unsafe { p_create_info.as_ref() }.unwrap(),
10117 unsafe { p_allocator.as_ref() },
10118 );
10119 match layer_result {
10120 LayerResult::Handled(res) => match res {
10121 Ok(res) => {
10122 *unsafe { p_surface.as_mut() }.unwrap() = res;
10123 vk::Result::SUCCESS
10124 }
10125 Err(e) => e,
10126 },
10127 LayerResult::Unhandled => unsafe {
10128 (dispatch_table.create_image_pipe_surface_fuchsia)(
10129 instance,
10130 p_create_info,
10131 p_allocator,
10132 p_surface,
10133 )
10134 },
10135 }
10136 }
10137 extern "system" fn create_metal_surface_ext(
10138 instance: vk::Instance,
10139 p_create_info: *const vk::MetalSurfaceCreateInfoEXT,
10140 p_allocator: *const vk::AllocationCallbacks,
10141 p_surface: *mut vk::SurfaceKHR,
10142 ) -> vk::Result {
10143 let global = Self::instance();
10144 let instance_info = global.get_instance_info(instance).unwrap();
10146 let dispatch_table = &instance_info.dispatch_table.ext_metal_surface;
10147 let layer_result = instance_info
10148 .customized_info
10149 .borrow()
10150 .hooks()
10151 .create_metal_surface_ext(unsafe { p_create_info.as_ref() }.unwrap(), unsafe {
10152 p_allocator.as_ref()
10153 });
10154 match layer_result {
10155 LayerResult::Handled(res) => match res {
10156 Ok(res) => {
10157 *unsafe { p_surface.as_mut() }.unwrap() = res;
10158 vk::Result::SUCCESS
10159 }
10160 Err(e) => e,
10161 },
10162 LayerResult::Unhandled => unsafe {
10163 (dispatch_table.create_metal_surface_ext)(
10164 instance,
10165 p_create_info,
10166 p_allocator,
10167 p_surface,
10168 )
10169 },
10170 }
10171 }
10172 extern "system" fn get_physical_device_cooperative_matrix_properties_nv(
10173 physical_device: vk::PhysicalDevice,
10174 p_property_count: *mut u32,
10175 p_properties: *mut vk::CooperativeMatrixPropertiesNV,
10176 ) -> vk::Result {
10177 let global = Self::instance();
10178 let instance_info = global.get_instance_info(physical_device).unwrap();
10180 let dispatch_table = &instance_info.dispatch_table.nv_cooperative_matrix;
10181 let layer_result = instance_info
10182 .customized_info
10183 .borrow()
10184 .hooks()
10185 .get_physical_device_cooperative_matrix_properties_nv(
10186 physical_device,
10187 unsafe { ptr_as_uninit_mut(p_property_count) }.unwrap(),
10188 unsafe { maybe_uninit_slice_from_raw_parts_mut(p_properties, p_property_count) },
10189 );
10190 match layer_result {
10191 LayerResult::Handled(res) => match res {
10192 Ok(()) => vk::Result::SUCCESS,
10193 Err(e) => e,
10194 },
10195 LayerResult::Unhandled => unsafe {
10196 (dispatch_table.get_physical_device_cooperative_matrix_properties_nv)(
10197 physical_device,
10198 p_property_count,
10199 p_properties,
10200 )
10201 },
10202 }
10203 }
10204 extern "system" fn get_physical_device_supported_framebuffer_mixed_samples_combinations_nv(
10205 physical_device: vk::PhysicalDevice,
10206 p_combination_count: *mut u32,
10207 p_combinations: *mut vk::FramebufferMixedSamplesCombinationNV,
10208 ) -> vk::Result {
10209 let global = Self::instance();
10210 let instance_info = global.get_instance_info(physical_device).unwrap();
10212 let dispatch_table = &instance_info.dispatch_table.nv_coverage_reduction_mode;
10213 let layer_result = instance_info
10214 .customized_info
10215 .borrow()
10216 .hooks()
10217 .get_physical_device_supported_framebuffer_mixed_samples_combinations_nv(
10218 physical_device,
10219 unsafe { ptr_as_uninit_mut(p_combination_count) }.unwrap(),
10220 unsafe {
10221 maybe_uninit_slice_from_raw_parts_mut(p_combinations, p_combination_count)
10222 },
10223 );
10224 match layer_result {
10225 LayerResult::Handled(res) => match res {
10226 Ok(()) => vk::Result::SUCCESS,
10227 Err(e) => e,
10228 },
10229 LayerResult::Unhandled => unsafe {
10230 (dispatch_table
10231 .get_physical_device_supported_framebuffer_mixed_samples_combinations_nv)(
10232 physical_device,
10233 p_combination_count,
10234 p_combinations,
10235 )
10236 },
10237 }
10238 }
10239 extern "system" fn get_physical_device_surface_present_modes2_ext(
10240 physical_device: vk::PhysicalDevice,
10241 p_surface_info: *const vk::PhysicalDeviceSurfaceInfo2KHR,
10242 p_present_mode_count: *mut u32,
10243 p_present_modes: *mut vk::PresentModeKHR,
10244 ) -> vk::Result {
10245 let global = Self::instance();
10246 let instance_info = global.get_instance_info(physical_device).unwrap();
10248 let dispatch_table = &instance_info.dispatch_table.ext_full_screen_exclusive;
10249 let layer_result = instance_info
10250 .customized_info
10251 .borrow()
10252 .hooks()
10253 .get_physical_device_surface_present_modes2_ext(
10254 physical_device,
10255 unsafe { p_surface_info.as_ref() }.unwrap(),
10256 );
10257 match layer_result {
10258 LayerResult::Handled(res) => match res {
10259 Ok(res) => unsafe {
10260 fill_vk_out_array(
10261 &res,
10262 NonNull::new(p_present_mode_count).unwrap(),
10263 p_present_modes,
10264 )
10265 },
10266 Err(e) => e,
10267 },
10268 LayerResult::Unhandled => unsafe {
10269 (dispatch_table.get_physical_device_surface_present_modes2_ext)(
10270 physical_device,
10271 p_surface_info,
10272 p_present_mode_count,
10273 p_present_modes,
10274 )
10275 },
10276 }
10277 }
10278 extern "system" fn create_headless_surface_ext(
10279 instance: vk::Instance,
10280 p_create_info: *const vk::HeadlessSurfaceCreateInfoEXT,
10281 p_allocator: *const vk::AllocationCallbacks,
10282 p_surface: *mut vk::SurfaceKHR,
10283 ) -> vk::Result {
10284 let global = Self::instance();
10285 let instance_info = global.get_instance_info(instance).unwrap();
10287 let dispatch_table = &instance_info.dispatch_table.ext_headless_surface;
10288 let layer_result = instance_info
10289 .customized_info
10290 .borrow()
10291 .hooks()
10292 .create_headless_surface_ext(unsafe { p_create_info.as_ref() }.unwrap(), unsafe {
10293 p_allocator.as_ref()
10294 });
10295 match layer_result {
10296 LayerResult::Handled(res) => match res {
10297 Ok(res) => {
10298 *unsafe { p_surface.as_mut() }.unwrap() = res;
10299 vk::Result::SUCCESS
10300 }
10301 Err(e) => e,
10302 },
10303 LayerResult::Unhandled => unsafe {
10304 (dispatch_table.create_headless_surface_ext)(
10305 instance,
10306 p_create_info,
10307 p_allocator,
10308 p_surface,
10309 )
10310 },
10311 }
10312 }
10313 extern "system" fn acquire_drm_display_ext(
10314 physical_device: vk::PhysicalDevice,
10315 drm_fd: i32,
10316 display: vk::DisplayKHR,
10317 ) -> vk::Result {
10318 let global = Self::instance();
10319 let instance_info = global.get_instance_info(physical_device).unwrap();
10321 let dispatch_table = &instance_info.dispatch_table.ext_acquire_drm_display;
10322 let layer_result = instance_info
10323 .customized_info
10324 .borrow()
10325 .hooks()
10326 .acquire_drm_display_ext(physical_device, drm_fd, display);
10327 match layer_result {
10328 LayerResult::Handled(res) => match res {
10329 Ok(()) => vk::Result::SUCCESS,
10330 Err(e) => e,
10331 },
10332 LayerResult::Unhandled => unsafe {
10333 (dispatch_table.acquire_drm_display_ext)(physical_device, drm_fd, display)
10334 },
10335 }
10336 }
10337 extern "system" fn get_drm_display_ext(
10338 physical_device: vk::PhysicalDevice,
10339 drm_fd: i32,
10340 connector_id: u32,
10341 display: *mut vk::DisplayKHR,
10342 ) -> vk::Result {
10343 let global = Self::instance();
10344 let instance_info = global.get_instance_info(physical_device).unwrap();
10346 let dispatch_table = &instance_info.dispatch_table.ext_acquire_drm_display;
10347 let layer_result = instance_info
10348 .customized_info
10349 .borrow()
10350 .hooks()
10351 .get_drm_display_ext(physical_device, drm_fd, connector_id);
10352 match layer_result {
10353 LayerResult::Handled(res) => match res {
10354 Ok(res) => {
10355 *unsafe { display.as_mut() }.unwrap() = res;
10356 vk::Result::SUCCESS
10357 }
10358 Err(e) => e,
10359 },
10360 LayerResult::Unhandled => unsafe {
10361 (dispatch_table.get_drm_display_ext)(physical_device, drm_fd, connector_id, display)
10362 },
10363 }
10364 }
10365 extern "system" fn acquire_winrt_display_nv(
10366 physical_device: vk::PhysicalDevice,
10367 display: vk::DisplayKHR,
10368 ) -> vk::Result {
10369 let global = Self::instance();
10370 let instance_info = global.get_instance_info(physical_device).unwrap();
10372 let dispatch_table = &instance_info.dispatch_table.nv_acquire_winrt_display;
10373 let layer_result = instance_info
10374 .customized_info
10375 .borrow()
10376 .hooks()
10377 .acquire_winrt_display_nv(physical_device, display);
10378 match layer_result {
10379 LayerResult::Handled(res) => match res {
10380 Ok(()) => vk::Result::SUCCESS,
10381 Err(e) => e,
10382 },
10383 LayerResult::Unhandled => unsafe {
10384 (dispatch_table.acquire_winrt_display_nv)(physical_device, display)
10385 },
10386 }
10387 }
10388 extern "system" fn get_winrt_display_nv(
10389 physical_device: vk::PhysicalDevice,
10390 device_relative_id: u32,
10391 p_display: *mut vk::DisplayKHR,
10392 ) -> vk::Result {
10393 let global = Self::instance();
10394 let instance_info = global.get_instance_info(physical_device).unwrap();
10396 let dispatch_table = &instance_info.dispatch_table.nv_acquire_winrt_display;
10397 let layer_result = instance_info
10398 .customized_info
10399 .borrow()
10400 .hooks()
10401 .get_winrt_display_nv(physical_device, device_relative_id);
10402 match layer_result {
10403 LayerResult::Handled(res) => match res {
10404 Ok(res) => {
10405 *unsafe { p_display.as_mut() }.unwrap() = res;
10406 vk::Result::SUCCESS
10407 }
10408 Err(e) => e,
10409 },
10410 LayerResult::Unhandled => unsafe {
10411 (dispatch_table.get_winrt_display_nv)(
10412 physical_device,
10413 device_relative_id,
10414 p_display,
10415 )
10416 },
10417 }
10418 }
10419 extern "system" fn create_direct_fb_surface_ext(
10420 instance: vk::Instance,
10421 p_create_info: *const vk::DirectFBSurfaceCreateInfoEXT,
10422 p_allocator: *const vk::AllocationCallbacks,
10423 p_surface: *mut vk::SurfaceKHR,
10424 ) -> vk::Result {
10425 let global = Self::instance();
10426 let instance_info = global.get_instance_info(instance).unwrap();
10428 let dispatch_table = &instance_info.dispatch_table.ext_directfb_surface;
10429 let layer_result = instance_info
10430 .customized_info
10431 .borrow()
10432 .hooks()
10433 .create_direct_fb_surface_ext(unsafe { p_create_info.as_ref() }.unwrap(), unsafe {
10434 p_allocator.as_ref()
10435 });
10436 match layer_result {
10437 LayerResult::Handled(res) => match res {
10438 Ok(res) => {
10439 *unsafe { p_surface.as_mut() }.unwrap() = res;
10440 vk::Result::SUCCESS
10441 }
10442 Err(e) => e,
10443 },
10444 LayerResult::Unhandled => unsafe {
10445 (dispatch_table.create_direct_fb_surface_ext)(
10446 instance,
10447 p_create_info,
10448 p_allocator,
10449 p_surface,
10450 )
10451 },
10452 }
10453 }
10454 extern "system" fn get_physical_device_direct_fb_presentation_support_ext(
10455 physical_device: vk::PhysicalDevice,
10456 queue_family_index: u32,
10457 dfb: *mut vk::IDirectFB,
10458 ) -> vk::Bool32 {
10459 let global = Self::instance();
10460 let instance_info = global.get_instance_info(physical_device).unwrap();
10462 let dispatch_table = &instance_info.dispatch_table.ext_directfb_surface;
10463 let layer_result = instance_info
10464 .customized_info
10465 .borrow()
10466 .hooks()
10467 .get_physical_device_direct_fb_presentation_support_ext(
10468 physical_device,
10469 queue_family_index,
10470 unsafe { ptr_as_uninit_mut(dfb) }.unwrap(),
10471 );
10472 match layer_result {
10473 LayerResult::Handled(res) => {
10474 if res {
10475 vk::TRUE
10476 } else {
10477 vk::FALSE
10478 }
10479 }
10480 LayerResult::Unhandled => unsafe {
10481 (dispatch_table.get_physical_device_direct_fb_presentation_support_ext)(
10482 physical_device,
10483 queue_family_index,
10484 dfb,
10485 )
10486 },
10487 }
10488 }
10489 extern "system" fn create_screen_surface_qnx(
10490 instance: vk::Instance,
10491 p_create_info: *const vk::ScreenSurfaceCreateInfoQNX,
10492 p_allocator: *const vk::AllocationCallbacks,
10493 p_surface: *mut vk::SurfaceKHR,
10494 ) -> vk::Result {
10495 let global = Self::instance();
10496 let instance_info = global.get_instance_info(instance).unwrap();
10498 let dispatch_table = &instance_info.dispatch_table.qnx_screen_surface;
10499 let layer_result = instance_info
10500 .customized_info
10501 .borrow()
10502 .hooks()
10503 .create_screen_surface_qnx(unsafe { p_create_info.as_ref() }.unwrap(), unsafe {
10504 p_allocator.as_ref()
10505 });
10506 match layer_result {
10507 LayerResult::Handled(res) => match res {
10508 Ok(res) => {
10509 *unsafe { p_surface.as_mut() }.unwrap() = res;
10510 vk::Result::SUCCESS
10511 }
10512 Err(e) => e,
10513 },
10514 LayerResult::Unhandled => unsafe {
10515 (dispatch_table.create_screen_surface_qnx)(
10516 instance,
10517 p_create_info,
10518 p_allocator,
10519 p_surface,
10520 )
10521 },
10522 }
10523 }
10524 extern "system" fn get_physical_device_screen_presentation_support_qnx(
10525 physical_device: vk::PhysicalDevice,
10526 queue_family_index: u32,
10527 window: *mut vk::_screen_window,
10528 ) -> vk::Bool32 {
10529 let global = Self::instance();
10530 let instance_info = global.get_instance_info(physical_device).unwrap();
10532 let dispatch_table = &instance_info.dispatch_table.qnx_screen_surface;
10533 let layer_result = instance_info
10534 .customized_info
10535 .borrow()
10536 .hooks()
10537 .get_physical_device_screen_presentation_support_qnx(
10538 physical_device,
10539 queue_family_index,
10540 window,
10541 );
10542 match layer_result {
10543 LayerResult::Handled(res) => {
10544 if res {
10545 vk::TRUE
10546 } else {
10547 vk::FALSE
10548 }
10549 }
10550 LayerResult::Unhandled => unsafe {
10551 (dispatch_table.get_physical_device_screen_presentation_support_qnx)(
10552 physical_device,
10553 queue_family_index,
10554 window,
10555 )
10556 },
10557 }
10558 }
10559 extern "system" fn get_physical_device_optical_flow_image_formats_nv(
10560 physical_device: vk::PhysicalDevice,
10561 p_optical_flow_image_format_info: *const vk::OpticalFlowImageFormatInfoNV,
10562 p_format_count: *mut u32,
10563 p_image_format_properties: *mut vk::OpticalFlowImageFormatPropertiesNV,
10564 ) -> vk::Result {
10565 let global = Self::instance();
10566 let instance_info = global.get_instance_info(physical_device).unwrap();
10568 let dispatch_table = &instance_info.dispatch_table.nv_optical_flow;
10569 let layer_result = instance_info
10570 .customized_info
10571 .borrow()
10572 .hooks()
10573 .get_physical_device_optical_flow_image_formats_nv(
10574 physical_device,
10575 unsafe { p_optical_flow_image_format_info.as_ref() }.unwrap(),
10576 unsafe { ptr_as_uninit_mut(p_format_count) }.unwrap(),
10577 unsafe {
10578 maybe_uninit_slice_from_raw_parts_mut(p_image_format_properties, p_format_count)
10579 },
10580 );
10581 match layer_result {
10582 LayerResult::Handled(res) => match res {
10583 Ok(()) => vk::Result::SUCCESS,
10584 Err(e) => e,
10585 },
10586 LayerResult::Unhandled => unsafe {
10587 (dispatch_table.get_physical_device_optical_flow_image_formats_nv)(
10588 physical_device,
10589 p_optical_flow_image_format_info,
10590 p_format_count,
10591 p_image_format_properties,
10592 )
10593 },
10594 }
10595 }
10596 extern "system" fn get_device_queue(
10597 device: vk::Device,
10598 queue_family_index: u32,
10599 queue_index: u32,
10600 p_queue: *mut vk::Queue,
10601 ) {
10602 let global = Self::instance();
10603 let device_info = global.get_device_info(device).unwrap();
10605 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
10606 let layer_result = device_info
10607 .customized_info
10608 .borrow()
10609 .hooks()
10610 .get_device_queue(queue_family_index, queue_index);
10611 match layer_result {
10612 LayerResult::Handled(res) => {
10613 *unsafe { p_queue.as_mut() }.unwrap() = res;
10614 }
10615 LayerResult::Unhandled => unsafe {
10616 (dispatch_table.get_device_queue)(device, queue_family_index, queue_index, p_queue)
10617 },
10618 }
10619 }
10620 extern "system" fn queue_submit(
10621 queue: vk::Queue,
10622 submit_count: u32,
10623 p_submits: *const vk::SubmitInfo,
10624 fence: vk::Fence,
10625 ) -> vk::Result {
10626 let global = Self::instance();
10627 let device_info = global.get_device_info(queue).unwrap();
10629 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
10630 let layer_result = device_info.customized_info.borrow().hooks().queue_submit(
10631 queue,
10632 unsafe { slice_from_raw_parts(p_submits, submit_count) },
10633 fence,
10634 );
10635 match layer_result {
10636 LayerResult::Handled(res) => match res {
10637 Ok(()) => vk::Result::SUCCESS,
10638 Err(e) => e,
10639 },
10640 LayerResult::Unhandled => unsafe {
10641 (dispatch_table.queue_submit)(queue, submit_count, p_submits, fence)
10642 },
10643 }
10644 }
10645 extern "system" fn queue_wait_idle(queue: vk::Queue) -> vk::Result {
10646 let global = Self::instance();
10647 let device_info = global.get_device_info(queue).unwrap();
10649 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
10650 let layer_result = device_info
10651 .customized_info
10652 .borrow()
10653 .hooks()
10654 .queue_wait_idle(queue);
10655 match layer_result {
10656 LayerResult::Handled(res) => match res {
10657 Ok(()) => vk::Result::SUCCESS,
10658 Err(e) => e,
10659 },
10660 LayerResult::Unhandled => unsafe { (dispatch_table.queue_wait_idle)(queue) },
10661 }
10662 }
10663 extern "system" fn device_wait_idle(device: vk::Device) -> vk::Result {
10664 let global = Self::instance();
10665 let device_info = global.get_device_info(device).unwrap();
10667 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
10668 let layer_result = device_info
10669 .customized_info
10670 .borrow()
10671 .hooks()
10672 .device_wait_idle();
10673 match layer_result {
10674 LayerResult::Handled(res) => match res {
10675 Ok(()) => vk::Result::SUCCESS,
10676 Err(e) => e,
10677 },
10678 LayerResult::Unhandled => unsafe { (dispatch_table.device_wait_idle)(device) },
10679 }
10680 }
10681 extern "system" fn allocate_memory(
10682 device: vk::Device,
10683 p_allocate_info: *const vk::MemoryAllocateInfo,
10684 p_allocator: *const vk::AllocationCallbacks,
10685 p_memory: *mut vk::DeviceMemory,
10686 ) -> vk::Result {
10687 let global = Self::instance();
10688 let device_info = global.get_device_info(device).unwrap();
10690 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
10691 let layer_result = device_info
10692 .customized_info
10693 .borrow()
10694 .hooks()
10695 .allocate_memory(unsafe { p_allocate_info.as_ref() }.unwrap(), unsafe {
10696 p_allocator.as_ref()
10697 });
10698 match layer_result {
10699 LayerResult::Handled(res) => match res {
10700 Ok(res) => {
10701 *unsafe { p_memory.as_mut() }.unwrap() = res;
10702 vk::Result::SUCCESS
10703 }
10704 Err(e) => e,
10705 },
10706 LayerResult::Unhandled => unsafe {
10707 (dispatch_table.allocate_memory)(device, p_allocate_info, p_allocator, p_memory)
10708 },
10709 }
10710 }
10711 extern "system" fn free_memory(
10712 device: vk::Device,
10713 memory: vk::DeviceMemory,
10714 p_allocator: *const vk::AllocationCallbacks,
10715 ) {
10716 let global = Self::instance();
10717 let device_info = global.get_device_info(device).unwrap();
10719 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
10720 let layer_result = device_info
10721 .customized_info
10722 .borrow()
10723 .hooks()
10724 .free_memory(memory, unsafe { p_allocator.as_ref() });
10725 match layer_result {
10726 LayerResult::Handled(res) => res,
10727 LayerResult::Unhandled => unsafe {
10728 (dispatch_table.free_memory)(device, memory, p_allocator)
10729 },
10730 }
10731 }
10732 extern "system" fn map_memory(
10733 device: vk::Device,
10734 memory: vk::DeviceMemory,
10735 offset: vk::DeviceSize,
10736 size: vk::DeviceSize,
10737 flags: vk::MemoryMapFlags,
10738 pp_data: *mut *mut c_void,
10739 ) -> vk::Result {
10740 let global = Self::instance();
10741 let device_info = global.get_device_info(device).unwrap();
10743 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
10744 let layer_result = device_info
10745 .customized_info
10746 .borrow()
10747 .hooks()
10748 .map_memory(memory, offset, size, flags);
10749 match layer_result {
10750 LayerResult::Handled(res) => match res {
10751 Ok(res) => {
10752 *unsafe { pp_data.as_mut() }.unwrap() = res.unwrap_or(std::ptr::null_mut());
10753 vk::Result::SUCCESS
10754 }
10755 Err(e) => e,
10756 },
10757 LayerResult::Unhandled => unsafe {
10758 (dispatch_table.map_memory)(device, memory, offset, size, flags, pp_data)
10759 },
10760 }
10761 }
10762 extern "system" fn unmap_memory(device: vk::Device, memory: vk::DeviceMemory) {
10763 let global = Self::instance();
10764 let device_info = global.get_device_info(device).unwrap();
10766 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
10767 let layer_result = device_info
10768 .customized_info
10769 .borrow()
10770 .hooks()
10771 .unmap_memory(memory);
10772 match layer_result {
10773 LayerResult::Handled(res) => res,
10774 LayerResult::Unhandled => unsafe { (dispatch_table.unmap_memory)(device, memory) },
10775 }
10776 }
10777 extern "system" fn flush_mapped_memory_ranges(
10778 device: vk::Device,
10779 memory_range_count: u32,
10780 p_memory_ranges: *const vk::MappedMemoryRange,
10781 ) -> vk::Result {
10782 let global = Self::instance();
10783 let device_info = global.get_device_info(device).unwrap();
10785 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
10786 let layer_result = device_info
10787 .customized_info
10788 .borrow()
10789 .hooks()
10790 .flush_mapped_memory_ranges(unsafe {
10791 slice_from_raw_parts(p_memory_ranges, memory_range_count)
10792 });
10793 match layer_result {
10794 LayerResult::Handled(res) => match res {
10795 Ok(()) => vk::Result::SUCCESS,
10796 Err(e) => e,
10797 },
10798 LayerResult::Unhandled => unsafe {
10799 (dispatch_table.flush_mapped_memory_ranges)(
10800 device,
10801 memory_range_count,
10802 p_memory_ranges,
10803 )
10804 },
10805 }
10806 }
10807 extern "system" fn invalidate_mapped_memory_ranges(
10808 device: vk::Device,
10809 memory_range_count: u32,
10810 p_memory_ranges: *const vk::MappedMemoryRange,
10811 ) -> vk::Result {
10812 let global = Self::instance();
10813 let device_info = global.get_device_info(device).unwrap();
10815 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
10816 let layer_result = device_info
10817 .customized_info
10818 .borrow()
10819 .hooks()
10820 .invalidate_mapped_memory_ranges(unsafe {
10821 slice_from_raw_parts(p_memory_ranges, memory_range_count)
10822 });
10823 match layer_result {
10824 LayerResult::Handled(res) => match res {
10825 Ok(()) => vk::Result::SUCCESS,
10826 Err(e) => e,
10827 },
10828 LayerResult::Unhandled => unsafe {
10829 (dispatch_table.invalidate_mapped_memory_ranges)(
10830 device,
10831 memory_range_count,
10832 p_memory_ranges,
10833 )
10834 },
10835 }
10836 }
10837 extern "system" fn get_device_memory_commitment(
10838 device: vk::Device,
10839 memory: vk::DeviceMemory,
10840 p_committed_memory_in_bytes: *mut vk::DeviceSize,
10841 ) {
10842 let global = Self::instance();
10843 let device_info = global.get_device_info(device).unwrap();
10845 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
10846 let layer_result = device_info
10847 .customized_info
10848 .borrow()
10849 .hooks()
10850 .get_device_memory_commitment(memory);
10851 match layer_result {
10852 LayerResult::Handled(res) => {
10853 *unsafe { p_committed_memory_in_bytes.as_mut() }.unwrap() = res;
10854 }
10855 LayerResult::Unhandled => unsafe {
10856 (dispatch_table.get_device_memory_commitment)(
10857 device,
10858 memory,
10859 p_committed_memory_in_bytes,
10860 )
10861 },
10862 }
10863 }
10864 extern "system" fn bind_buffer_memory(
10865 device: vk::Device,
10866 buffer: vk::Buffer,
10867 memory: vk::DeviceMemory,
10868 memory_offset: vk::DeviceSize,
10869 ) -> vk::Result {
10870 let global = Self::instance();
10871 let device_info = global.get_device_info(device).unwrap();
10873 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
10874 let layer_result = device_info
10875 .customized_info
10876 .borrow()
10877 .hooks()
10878 .bind_buffer_memory(buffer, memory, memory_offset);
10879 match layer_result {
10880 LayerResult::Handled(res) => match res {
10881 Ok(()) => vk::Result::SUCCESS,
10882 Err(e) => e,
10883 },
10884 LayerResult::Unhandled => unsafe {
10885 (dispatch_table.bind_buffer_memory)(device, buffer, memory, memory_offset)
10886 },
10887 }
10888 }
10889 extern "system" fn bind_image_memory(
10890 device: vk::Device,
10891 image: vk::Image,
10892 memory: vk::DeviceMemory,
10893 memory_offset: vk::DeviceSize,
10894 ) -> vk::Result {
10895 let global = Self::instance();
10896 let device_info = global.get_device_info(device).unwrap();
10898 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
10899 let layer_result = device_info
10900 .customized_info
10901 .borrow()
10902 .hooks()
10903 .bind_image_memory(image, memory, memory_offset);
10904 match layer_result {
10905 LayerResult::Handled(res) => match res {
10906 Ok(()) => vk::Result::SUCCESS,
10907 Err(e) => e,
10908 },
10909 LayerResult::Unhandled => unsafe {
10910 (dispatch_table.bind_image_memory)(device, image, memory, memory_offset)
10911 },
10912 }
10913 }
10914 extern "system" fn get_buffer_memory_requirements(
10915 device: vk::Device,
10916 buffer: vk::Buffer,
10917 p_memory_requirements: *mut vk::MemoryRequirements,
10918 ) {
10919 let global = Self::instance();
10920 let device_info = global.get_device_info(device).unwrap();
10922 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
10923 let layer_result = device_info
10924 .customized_info
10925 .borrow()
10926 .hooks()
10927 .get_buffer_memory_requirements(
10928 buffer,
10929 unsafe { ptr_as_uninit_mut(p_memory_requirements) }.unwrap(),
10930 );
10931 match layer_result {
10932 LayerResult::Handled(res) => res,
10933 LayerResult::Unhandled => unsafe {
10934 (dispatch_table.get_buffer_memory_requirements)(
10935 device,
10936 buffer,
10937 p_memory_requirements,
10938 )
10939 },
10940 }
10941 }
10942 extern "system" fn get_image_memory_requirements(
10943 device: vk::Device,
10944 image: vk::Image,
10945 p_memory_requirements: *mut vk::MemoryRequirements,
10946 ) {
10947 let global = Self::instance();
10948 let device_info = global.get_device_info(device).unwrap();
10950 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
10951 let layer_result = device_info
10952 .customized_info
10953 .borrow()
10954 .hooks()
10955 .get_image_memory_requirements(
10956 image,
10957 unsafe { ptr_as_uninit_mut(p_memory_requirements) }.unwrap(),
10958 );
10959 match layer_result {
10960 LayerResult::Handled(res) => res,
10961 LayerResult::Unhandled => unsafe {
10962 (dispatch_table.get_image_memory_requirements)(device, image, p_memory_requirements)
10963 },
10964 }
10965 }
10966 extern "system" fn get_image_sparse_memory_requirements(
10967 device: vk::Device,
10968 image: vk::Image,
10969 p_sparse_memory_requirement_count: *mut u32,
10970 p_sparse_memory_requirements: *mut vk::SparseImageMemoryRequirements,
10971 ) {
10972 let global = Self::instance();
10973 let device_info = global.get_device_info(device).unwrap();
10975 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
10976 let layer_result = device_info
10977 .customized_info
10978 .borrow()
10979 .hooks()
10980 .get_image_sparse_memory_requirements(
10981 image,
10982 unsafe { ptr_as_uninit_mut(p_sparse_memory_requirement_count) }.unwrap(),
10983 unsafe {
10984 maybe_uninit_slice_from_raw_parts_mut(
10985 p_sparse_memory_requirements,
10986 p_sparse_memory_requirement_count,
10987 )
10988 },
10989 );
10990 match layer_result {
10991 LayerResult::Handled(res) => res,
10992 LayerResult::Unhandled => unsafe {
10993 (dispatch_table.get_image_sparse_memory_requirements)(
10994 device,
10995 image,
10996 p_sparse_memory_requirement_count,
10997 p_sparse_memory_requirements,
10998 )
10999 },
11000 }
11001 }
11002 extern "system" fn queue_bind_sparse(
11003 queue: vk::Queue,
11004 bind_info_count: u32,
11005 p_bind_info: *const vk::BindSparseInfo,
11006 fence: vk::Fence,
11007 ) -> vk::Result {
11008 let global = Self::instance();
11009 let device_info = global.get_device_info(queue).unwrap();
11011 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
11012 let layer_result = device_info
11013 .customized_info
11014 .borrow()
11015 .hooks()
11016 .queue_bind_sparse(
11017 queue,
11018 unsafe { slice_from_raw_parts(p_bind_info, bind_info_count) },
11019 fence,
11020 );
11021 match layer_result {
11022 LayerResult::Handled(res) => match res {
11023 Ok(()) => vk::Result::SUCCESS,
11024 Err(e) => e,
11025 },
11026 LayerResult::Unhandled => unsafe {
11027 (dispatch_table.queue_bind_sparse)(queue, bind_info_count, p_bind_info, fence)
11028 },
11029 }
11030 }
11031 extern "system" fn create_fence(
11032 device: vk::Device,
11033 p_create_info: *const vk::FenceCreateInfo,
11034 p_allocator: *const vk::AllocationCallbacks,
11035 p_fence: *mut vk::Fence,
11036 ) -> vk::Result {
11037 let global = Self::instance();
11038 let device_info = global.get_device_info(device).unwrap();
11040 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
11041 let layer_result = device_info
11042 .customized_info
11043 .borrow()
11044 .hooks()
11045 .create_fence(unsafe { p_create_info.as_ref() }.unwrap(), unsafe {
11046 p_allocator.as_ref()
11047 });
11048 match layer_result {
11049 LayerResult::Handled(res) => match res {
11050 Ok(res) => {
11051 *unsafe { p_fence.as_mut() }.unwrap() = res;
11052 vk::Result::SUCCESS
11053 }
11054 Err(e) => e,
11055 },
11056 LayerResult::Unhandled => unsafe {
11057 (dispatch_table.create_fence)(device, p_create_info, p_allocator, p_fence)
11058 },
11059 }
11060 }
11061 extern "system" fn destroy_fence(
11062 device: vk::Device,
11063 fence: vk::Fence,
11064 p_allocator: *const vk::AllocationCallbacks,
11065 ) {
11066 let global = Self::instance();
11067 let device_info = global.get_device_info(device).unwrap();
11069 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
11070 let layer_result = device_info
11071 .customized_info
11072 .borrow()
11073 .hooks()
11074 .destroy_fence(fence, unsafe { p_allocator.as_ref() });
11075 match layer_result {
11076 LayerResult::Handled(res) => res,
11077 LayerResult::Unhandled => unsafe {
11078 (dispatch_table.destroy_fence)(device, fence, p_allocator)
11079 },
11080 }
11081 }
11082 extern "system" fn reset_fences(
11083 device: vk::Device,
11084 fence_count: u32,
11085 p_fences: *const vk::Fence,
11086 ) -> vk::Result {
11087 let global = Self::instance();
11088 let device_info = global.get_device_info(device).unwrap();
11090 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
11091 let layer_result = device_info
11092 .customized_info
11093 .borrow()
11094 .hooks()
11095 .reset_fences(unsafe { slice_from_raw_parts(p_fences, fence_count) });
11096 match layer_result {
11097 LayerResult::Handled(res) => match res {
11098 Ok(()) => vk::Result::SUCCESS,
11099 Err(e) => e,
11100 },
11101 LayerResult::Unhandled => unsafe {
11102 (dispatch_table.reset_fences)(device, fence_count, p_fences)
11103 },
11104 }
11105 }
11106 extern "system" fn get_fence_status(device: vk::Device, fence: vk::Fence) -> vk::Result {
11107 let global = Self::instance();
11108 let device_info = global.get_device_info(device).unwrap();
11110 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
11111 let layer_result = device_info
11112 .customized_info
11113 .borrow()
11114 .hooks()
11115 .get_fence_status(fence);
11116 match layer_result {
11117 LayerResult::Handled(res) => match res {
11118 Ok(()) => vk::Result::SUCCESS,
11119 Err(e) => e,
11120 },
11121 LayerResult::Unhandled => unsafe { (dispatch_table.get_fence_status)(device, fence) },
11122 }
11123 }
11124 extern "system" fn wait_for_fences(
11125 device: vk::Device,
11126 fence_count: u32,
11127 p_fences: *const vk::Fence,
11128 wait_all: vk::Bool32,
11129 timeout: u64,
11130 ) -> vk::Result {
11131 let global = Self::instance();
11132 let device_info = global.get_device_info(device).unwrap();
11134 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
11135 let layer_result = device_info
11136 .customized_info
11137 .borrow()
11138 .hooks()
11139 .wait_for_fences(
11140 unsafe { slice_from_raw_parts(p_fences, fence_count) },
11141 wait_all == vk::TRUE,
11142 timeout,
11143 );
11144 match layer_result {
11145 LayerResult::Handled(res) => match res {
11146 Ok(()) => vk::Result::SUCCESS,
11147 Err(e) => e,
11148 },
11149 LayerResult::Unhandled => unsafe {
11150 (dispatch_table.wait_for_fences)(device, fence_count, p_fences, wait_all, timeout)
11151 },
11152 }
11153 }
11154 extern "system" fn create_semaphore(
11155 device: vk::Device,
11156 p_create_info: *const vk::SemaphoreCreateInfo,
11157 p_allocator: *const vk::AllocationCallbacks,
11158 p_semaphore: *mut vk::Semaphore,
11159 ) -> vk::Result {
11160 let global = Self::instance();
11161 let device_info = global.get_device_info(device).unwrap();
11163 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
11164 let layer_result = device_info
11165 .customized_info
11166 .borrow()
11167 .hooks()
11168 .create_semaphore(unsafe { p_create_info.as_ref() }.unwrap(), unsafe {
11169 p_allocator.as_ref()
11170 });
11171 match layer_result {
11172 LayerResult::Handled(res) => match res {
11173 Ok(res) => {
11174 *unsafe { p_semaphore.as_mut() }.unwrap() = res;
11175 vk::Result::SUCCESS
11176 }
11177 Err(e) => e,
11178 },
11179 LayerResult::Unhandled => unsafe {
11180 (dispatch_table.create_semaphore)(device, p_create_info, p_allocator, p_semaphore)
11181 },
11182 }
11183 }
11184 extern "system" fn destroy_semaphore(
11185 device: vk::Device,
11186 semaphore: vk::Semaphore,
11187 p_allocator: *const vk::AllocationCallbacks,
11188 ) {
11189 let global = Self::instance();
11190 let device_info = global.get_device_info(device).unwrap();
11192 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
11193 let layer_result = device_info
11194 .customized_info
11195 .borrow()
11196 .hooks()
11197 .destroy_semaphore(semaphore, unsafe { p_allocator.as_ref() });
11198 match layer_result {
11199 LayerResult::Handled(res) => res,
11200 LayerResult::Unhandled => unsafe {
11201 (dispatch_table.destroy_semaphore)(device, semaphore, p_allocator)
11202 },
11203 }
11204 }
11205 extern "system" fn create_event(
11206 device: vk::Device,
11207 p_create_info: *const vk::EventCreateInfo,
11208 p_allocator: *const vk::AllocationCallbacks,
11209 p_event: *mut vk::Event,
11210 ) -> vk::Result {
11211 let global = Self::instance();
11212 let device_info = global.get_device_info(device).unwrap();
11214 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
11215 let layer_result = device_info
11216 .customized_info
11217 .borrow()
11218 .hooks()
11219 .create_event(unsafe { p_create_info.as_ref() }.unwrap(), unsafe {
11220 p_allocator.as_ref()
11221 });
11222 match layer_result {
11223 LayerResult::Handled(res) => match res {
11224 Ok(res) => {
11225 *unsafe { p_event.as_mut() }.unwrap() = res;
11226 vk::Result::SUCCESS
11227 }
11228 Err(e) => e,
11229 },
11230 LayerResult::Unhandled => unsafe {
11231 (dispatch_table.create_event)(device, p_create_info, p_allocator, p_event)
11232 },
11233 }
11234 }
11235 extern "system" fn destroy_event(
11236 device: vk::Device,
11237 event: vk::Event,
11238 p_allocator: *const vk::AllocationCallbacks,
11239 ) {
11240 let global = Self::instance();
11241 let device_info = global.get_device_info(device).unwrap();
11243 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
11244 let layer_result = device_info
11245 .customized_info
11246 .borrow()
11247 .hooks()
11248 .destroy_event(event, unsafe { p_allocator.as_ref() });
11249 match layer_result {
11250 LayerResult::Handled(res) => res,
11251 LayerResult::Unhandled => unsafe {
11252 (dispatch_table.destroy_event)(device, event, p_allocator)
11253 },
11254 }
11255 }
11256 extern "system" fn get_event_status(device: vk::Device, event: vk::Event) -> vk::Result {
11257 let global = Self::instance();
11258 let device_info = global.get_device_info(device).unwrap();
11260 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
11261 let layer_result = device_info
11262 .customized_info
11263 .borrow()
11264 .hooks()
11265 .get_event_status(event);
11266 match layer_result {
11267 LayerResult::Handled(res) => match res {
11268 Ok(()) => vk::Result::SUCCESS,
11269 Err(e) => e,
11270 },
11271 LayerResult::Unhandled => unsafe { (dispatch_table.get_event_status)(device, event) },
11272 }
11273 }
11274 extern "system" fn set_event(device: vk::Device, event: vk::Event) -> vk::Result {
11275 let global = Self::instance();
11276 let device_info = global.get_device_info(device).unwrap();
11278 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
11279 let layer_result = device_info
11280 .customized_info
11281 .borrow()
11282 .hooks()
11283 .set_event(event);
11284 match layer_result {
11285 LayerResult::Handled(res) => match res {
11286 Ok(()) => vk::Result::SUCCESS,
11287 Err(e) => e,
11288 },
11289 LayerResult::Unhandled => unsafe { (dispatch_table.set_event)(device, event) },
11290 }
11291 }
11292 extern "system" fn reset_event(device: vk::Device, event: vk::Event) -> vk::Result {
11293 let global = Self::instance();
11294 let device_info = global.get_device_info(device).unwrap();
11296 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
11297 let layer_result = device_info
11298 .customized_info
11299 .borrow()
11300 .hooks()
11301 .reset_event(event);
11302 match layer_result {
11303 LayerResult::Handled(res) => match res {
11304 Ok(()) => vk::Result::SUCCESS,
11305 Err(e) => e,
11306 },
11307 LayerResult::Unhandled => unsafe { (dispatch_table.reset_event)(device, event) },
11308 }
11309 }
11310 extern "system" fn create_query_pool(
11311 device: vk::Device,
11312 p_create_info: *const vk::QueryPoolCreateInfo,
11313 p_allocator: *const vk::AllocationCallbacks,
11314 p_query_pool: *mut vk::QueryPool,
11315 ) -> vk::Result {
11316 let global = Self::instance();
11317 let device_info = global.get_device_info(device).unwrap();
11319 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
11320 let layer_result = device_info
11321 .customized_info
11322 .borrow()
11323 .hooks()
11324 .create_query_pool(unsafe { p_create_info.as_ref() }.unwrap(), unsafe {
11325 p_allocator.as_ref()
11326 });
11327 match layer_result {
11328 LayerResult::Handled(res) => match res {
11329 Ok(res) => {
11330 *unsafe { p_query_pool.as_mut() }.unwrap() = res;
11331 vk::Result::SUCCESS
11332 }
11333 Err(e) => e,
11334 },
11335 LayerResult::Unhandled => unsafe {
11336 (dispatch_table.create_query_pool)(device, p_create_info, p_allocator, p_query_pool)
11337 },
11338 }
11339 }
11340 extern "system" fn destroy_query_pool(
11341 device: vk::Device,
11342 query_pool: vk::QueryPool,
11343 p_allocator: *const vk::AllocationCallbacks,
11344 ) {
11345 let global = Self::instance();
11346 let device_info = global.get_device_info(device).unwrap();
11348 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
11349 let layer_result = device_info
11350 .customized_info
11351 .borrow()
11352 .hooks()
11353 .destroy_query_pool(query_pool, unsafe { p_allocator.as_ref() });
11354 match layer_result {
11355 LayerResult::Handled(res) => res,
11356 LayerResult::Unhandled => unsafe {
11357 (dispatch_table.destroy_query_pool)(device, query_pool, p_allocator)
11358 },
11359 }
11360 }
11361 extern "system" fn get_query_pool_results(
11362 device: vk::Device,
11363 query_pool: vk::QueryPool,
11364 first_query: u32,
11365 query_count: u32,
11366 data_size: usize,
11367 p_data: *mut c_void,
11368 stride: vk::DeviceSize,
11369 flags: vk::QueryResultFlags,
11370 ) -> vk::Result {
11371 let global = Self::instance();
11372 let device_info = global.get_device_info(device).unwrap();
11374 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
11375 let layer_result = device_info
11376 .customized_info
11377 .borrow()
11378 .hooks()
11379 .get_query_pool_results(
11380 query_pool,
11381 first_query,
11382 query_count,
11383 unsafe { uninit_slice_from_raw_parts_mut(p_data as *mut u8, data_size) },
11384 stride,
11385 flags,
11386 );
11387 match layer_result {
11388 LayerResult::Handled(res) => match res {
11389 Ok(()) => vk::Result::SUCCESS,
11390 Err(e) => e,
11391 },
11392 LayerResult::Unhandled => unsafe {
11393 (dispatch_table.get_query_pool_results)(
11394 device,
11395 query_pool,
11396 first_query,
11397 query_count,
11398 data_size,
11399 p_data,
11400 stride,
11401 flags,
11402 )
11403 },
11404 }
11405 }
11406 extern "system" fn create_buffer(
11407 device: vk::Device,
11408 p_create_info: *const vk::BufferCreateInfo,
11409 p_allocator: *const vk::AllocationCallbacks,
11410 p_buffer: *mut vk::Buffer,
11411 ) -> vk::Result {
11412 let global = Self::instance();
11413 let device_info = global.get_device_info(device).unwrap();
11415 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
11416 let layer_result = device_info
11417 .customized_info
11418 .borrow()
11419 .hooks()
11420 .create_buffer(unsafe { p_create_info.as_ref() }.unwrap(), unsafe {
11421 p_allocator.as_ref()
11422 });
11423 match layer_result {
11424 LayerResult::Handled(res) => match res {
11425 Ok(res) => {
11426 *unsafe { p_buffer.as_mut() }.unwrap() = res;
11427 vk::Result::SUCCESS
11428 }
11429 Err(e) => e,
11430 },
11431 LayerResult::Unhandled => unsafe {
11432 (dispatch_table.create_buffer)(device, p_create_info, p_allocator, p_buffer)
11433 },
11434 }
11435 }
11436 extern "system" fn destroy_buffer(
11437 device: vk::Device,
11438 buffer: vk::Buffer,
11439 p_allocator: *const vk::AllocationCallbacks,
11440 ) {
11441 let global = Self::instance();
11442 let device_info = global.get_device_info(device).unwrap();
11444 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
11445 let layer_result = device_info
11446 .customized_info
11447 .borrow()
11448 .hooks()
11449 .destroy_buffer(buffer, unsafe { p_allocator.as_ref() });
11450 match layer_result {
11451 LayerResult::Handled(res) => res,
11452 LayerResult::Unhandled => unsafe {
11453 (dispatch_table.destroy_buffer)(device, buffer, p_allocator)
11454 },
11455 }
11456 }
11457 extern "system" fn create_buffer_view(
11458 device: vk::Device,
11459 p_create_info: *const vk::BufferViewCreateInfo,
11460 p_allocator: *const vk::AllocationCallbacks,
11461 p_view: *mut vk::BufferView,
11462 ) -> vk::Result {
11463 let global = Self::instance();
11464 let device_info = global.get_device_info(device).unwrap();
11466 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
11467 let layer_result = device_info
11468 .customized_info
11469 .borrow()
11470 .hooks()
11471 .create_buffer_view(unsafe { p_create_info.as_ref() }.unwrap(), unsafe {
11472 p_allocator.as_ref()
11473 });
11474 match layer_result {
11475 LayerResult::Handled(res) => match res {
11476 Ok(res) => {
11477 *unsafe { p_view.as_mut() }.unwrap() = res;
11478 vk::Result::SUCCESS
11479 }
11480 Err(e) => e,
11481 },
11482 LayerResult::Unhandled => unsafe {
11483 (dispatch_table.create_buffer_view)(device, p_create_info, p_allocator, p_view)
11484 },
11485 }
11486 }
11487 extern "system" fn destroy_buffer_view(
11488 device: vk::Device,
11489 buffer_view: vk::BufferView,
11490 p_allocator: *const vk::AllocationCallbacks,
11491 ) {
11492 let global = Self::instance();
11493 let device_info = global.get_device_info(device).unwrap();
11495 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
11496 let layer_result = device_info
11497 .customized_info
11498 .borrow()
11499 .hooks()
11500 .destroy_buffer_view(buffer_view, unsafe { p_allocator.as_ref() });
11501 match layer_result {
11502 LayerResult::Handled(res) => res,
11503 LayerResult::Unhandled => unsafe {
11504 (dispatch_table.destroy_buffer_view)(device, buffer_view, p_allocator)
11505 },
11506 }
11507 }
11508 extern "system" fn create_image(
11509 device: vk::Device,
11510 p_create_info: *const vk::ImageCreateInfo,
11511 p_allocator: *const vk::AllocationCallbacks,
11512 p_image: *mut vk::Image,
11513 ) -> vk::Result {
11514 let global = Self::instance();
11515 let device_info = global.get_device_info(device).unwrap();
11517 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
11518 let layer_result = device_info
11519 .customized_info
11520 .borrow()
11521 .hooks()
11522 .create_image(unsafe { p_create_info.as_ref() }.unwrap(), unsafe {
11523 p_allocator.as_ref()
11524 });
11525 match layer_result {
11526 LayerResult::Handled(res) => match res {
11527 Ok(res) => {
11528 *unsafe { p_image.as_mut() }.unwrap() = res;
11529 vk::Result::SUCCESS
11530 }
11531 Err(e) => e,
11532 },
11533 LayerResult::Unhandled => unsafe {
11534 (dispatch_table.create_image)(device, p_create_info, p_allocator, p_image)
11535 },
11536 }
11537 }
11538 extern "system" fn destroy_image(
11539 device: vk::Device,
11540 image: vk::Image,
11541 p_allocator: *const vk::AllocationCallbacks,
11542 ) {
11543 let global = Self::instance();
11544 let device_info = global.get_device_info(device).unwrap();
11546 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
11547 let layer_result = device_info
11548 .customized_info
11549 .borrow()
11550 .hooks()
11551 .destroy_image(image, unsafe { p_allocator.as_ref() });
11552 match layer_result {
11553 LayerResult::Handled(res) => res,
11554 LayerResult::Unhandled => unsafe {
11555 (dispatch_table.destroy_image)(device, image, p_allocator)
11556 },
11557 }
11558 }
11559 extern "system" fn get_image_subresource_layout(
11560 device: vk::Device,
11561 image: vk::Image,
11562 p_subresource: *const vk::ImageSubresource,
11563 p_layout: *mut vk::SubresourceLayout,
11564 ) {
11565 let global = Self::instance();
11566 let device_info = global.get_device_info(device).unwrap();
11568 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
11569 let layer_result = device_info
11570 .customized_info
11571 .borrow()
11572 .hooks()
11573 .get_image_subresource_layout(
11574 image,
11575 unsafe { p_subresource.as_ref() }.unwrap(),
11576 unsafe { ptr_as_uninit_mut(p_layout) }.unwrap(),
11577 );
11578 match layer_result {
11579 LayerResult::Handled(res) => res,
11580 LayerResult::Unhandled => unsafe {
11581 (dispatch_table.get_image_subresource_layout)(
11582 device,
11583 image,
11584 p_subresource,
11585 p_layout,
11586 )
11587 },
11588 }
11589 }
11590 extern "system" fn create_image_view(
11591 device: vk::Device,
11592 p_create_info: *const vk::ImageViewCreateInfo,
11593 p_allocator: *const vk::AllocationCallbacks,
11594 p_view: *mut vk::ImageView,
11595 ) -> vk::Result {
11596 let global = Self::instance();
11597 let device_info = global.get_device_info(device).unwrap();
11599 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
11600 let layer_result = device_info
11601 .customized_info
11602 .borrow()
11603 .hooks()
11604 .create_image_view(unsafe { p_create_info.as_ref() }.unwrap(), unsafe {
11605 p_allocator.as_ref()
11606 });
11607 match layer_result {
11608 LayerResult::Handled(res) => match res {
11609 Ok(res) => {
11610 *unsafe { p_view.as_mut() }.unwrap() = res;
11611 vk::Result::SUCCESS
11612 }
11613 Err(e) => e,
11614 },
11615 LayerResult::Unhandled => unsafe {
11616 (dispatch_table.create_image_view)(device, p_create_info, p_allocator, p_view)
11617 },
11618 }
11619 }
11620 extern "system" fn destroy_image_view(
11621 device: vk::Device,
11622 image_view: vk::ImageView,
11623 p_allocator: *const vk::AllocationCallbacks,
11624 ) {
11625 let global = Self::instance();
11626 let device_info = global.get_device_info(device).unwrap();
11628 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
11629 let layer_result = device_info
11630 .customized_info
11631 .borrow()
11632 .hooks()
11633 .destroy_image_view(image_view, unsafe { p_allocator.as_ref() });
11634 match layer_result {
11635 LayerResult::Handled(res) => res,
11636 LayerResult::Unhandled => unsafe {
11637 (dispatch_table.destroy_image_view)(device, image_view, p_allocator)
11638 },
11639 }
11640 }
11641 extern "system" fn create_shader_module(
11642 device: vk::Device,
11643 p_create_info: *const vk::ShaderModuleCreateInfo,
11644 p_allocator: *const vk::AllocationCallbacks,
11645 p_shader_module: *mut vk::ShaderModule,
11646 ) -> vk::Result {
11647 let global = Self::instance();
11648 let device_info = global.get_device_info(device).unwrap();
11650 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
11651 let layer_result = device_info
11652 .customized_info
11653 .borrow()
11654 .hooks()
11655 .create_shader_module(unsafe { p_create_info.as_ref() }.unwrap(), unsafe {
11656 p_allocator.as_ref()
11657 });
11658 match layer_result {
11659 LayerResult::Handled(res) => match res {
11660 Ok(res) => {
11661 *unsafe { p_shader_module.as_mut() }.unwrap() = res;
11662 vk::Result::SUCCESS
11663 }
11664 Err(e) => e,
11665 },
11666 LayerResult::Unhandled => unsafe {
11667 (dispatch_table.create_shader_module)(
11668 device,
11669 p_create_info,
11670 p_allocator,
11671 p_shader_module,
11672 )
11673 },
11674 }
11675 }
11676 extern "system" fn destroy_shader_module(
11677 device: vk::Device,
11678 shader_module: vk::ShaderModule,
11679 p_allocator: *const vk::AllocationCallbacks,
11680 ) {
11681 let global = Self::instance();
11682 let device_info = global.get_device_info(device).unwrap();
11684 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
11685 let layer_result = device_info
11686 .customized_info
11687 .borrow()
11688 .hooks()
11689 .destroy_shader_module(shader_module, unsafe { p_allocator.as_ref() });
11690 match layer_result {
11691 LayerResult::Handled(res) => res,
11692 LayerResult::Unhandled => unsafe {
11693 (dispatch_table.destroy_shader_module)(device, shader_module, p_allocator)
11694 },
11695 }
11696 }
11697 extern "system" fn create_pipeline_cache(
11698 device: vk::Device,
11699 p_create_info: *const vk::PipelineCacheCreateInfo,
11700 p_allocator: *const vk::AllocationCallbacks,
11701 p_pipeline_cache: *mut vk::PipelineCache,
11702 ) -> vk::Result {
11703 let global = Self::instance();
11704 let device_info = global.get_device_info(device).unwrap();
11706 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
11707 let layer_result = device_info
11708 .customized_info
11709 .borrow()
11710 .hooks()
11711 .create_pipeline_cache(unsafe { p_create_info.as_ref() }.unwrap(), unsafe {
11712 p_allocator.as_ref()
11713 });
11714 match layer_result {
11715 LayerResult::Handled(res) => match res {
11716 Ok(res) => {
11717 *unsafe { p_pipeline_cache.as_mut() }.unwrap() = res;
11718 vk::Result::SUCCESS
11719 }
11720 Err(e) => e,
11721 },
11722 LayerResult::Unhandled => unsafe {
11723 (dispatch_table.create_pipeline_cache)(
11724 device,
11725 p_create_info,
11726 p_allocator,
11727 p_pipeline_cache,
11728 )
11729 },
11730 }
11731 }
11732 extern "system" fn destroy_pipeline_cache(
11733 device: vk::Device,
11734 pipeline_cache: vk::PipelineCache,
11735 p_allocator: *const vk::AllocationCallbacks,
11736 ) {
11737 let global = Self::instance();
11738 let device_info = global.get_device_info(device).unwrap();
11740 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
11741 let layer_result = device_info
11742 .customized_info
11743 .borrow()
11744 .hooks()
11745 .destroy_pipeline_cache(pipeline_cache, unsafe { p_allocator.as_ref() });
11746 match layer_result {
11747 LayerResult::Handled(res) => res,
11748 LayerResult::Unhandled => unsafe {
11749 (dispatch_table.destroy_pipeline_cache)(device, pipeline_cache, p_allocator)
11750 },
11751 }
11752 }
11753 extern "system" fn get_pipeline_cache_data(
11754 device: vk::Device,
11755 pipeline_cache: vk::PipelineCache,
11756 p_data_size: *mut usize,
11757 p_data: *mut c_void,
11758 ) -> vk::Result {
11759 let global = Self::instance();
11760 let device_info = global.get_device_info(device).unwrap();
11762 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
11763 let layer_result = device_info
11764 .customized_info
11765 .borrow()
11766 .hooks()
11767 .get_pipeline_cache_data(
11768 pipeline_cache,
11769 unsafe { ptr_as_uninit_mut(p_data_size) }.unwrap(),
11770 unsafe { maybe_uninit_slice_from_raw_parts_mut(p_data as *mut u8, p_data_size) },
11771 );
11772 match layer_result {
11773 LayerResult::Handled(res) => match res {
11774 Ok(()) => vk::Result::SUCCESS,
11775 Err(e) => e,
11776 },
11777 LayerResult::Unhandled => unsafe {
11778 (dispatch_table.get_pipeline_cache_data)(
11779 device,
11780 pipeline_cache,
11781 p_data_size,
11782 p_data,
11783 )
11784 },
11785 }
11786 }
11787 extern "system" fn merge_pipeline_caches(
11788 device: vk::Device,
11789 dst_cache: vk::PipelineCache,
11790 src_cache_count: u32,
11791 p_src_caches: *const vk::PipelineCache,
11792 ) -> vk::Result {
11793 let global = Self::instance();
11794 let device_info = global.get_device_info(device).unwrap();
11796 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
11797 let layer_result = device_info
11798 .customized_info
11799 .borrow()
11800 .hooks()
11801 .merge_pipeline_caches(dst_cache, unsafe {
11802 slice_from_raw_parts(p_src_caches, src_cache_count)
11803 });
11804 match layer_result {
11805 LayerResult::Handled(res) => match res {
11806 Ok(()) => vk::Result::SUCCESS,
11807 Err(e) => e,
11808 },
11809 LayerResult::Unhandled => unsafe {
11810 (dispatch_table.merge_pipeline_caches)(
11811 device,
11812 dst_cache,
11813 src_cache_count,
11814 p_src_caches,
11815 )
11816 },
11817 }
11818 }
11819 extern "system" fn create_graphics_pipelines(
11820 device: vk::Device,
11821 pipeline_cache: vk::PipelineCache,
11822 create_info_count: u32,
11823 p_create_infos: *const vk::GraphicsPipelineCreateInfo,
11824 p_allocator: *const vk::AllocationCallbacks,
11825 p_pipelines: *mut vk::Pipeline,
11826 ) -> vk::Result {
11827 let global = Self::instance();
11828 let device_info = global.get_device_info(device).unwrap();
11830 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
11831 let layer_result = device_info
11832 .customized_info
11833 .borrow()
11834 .hooks()
11835 .create_graphics_pipelines(
11836 pipeline_cache,
11837 unsafe { slice_from_raw_parts(p_create_infos, create_info_count) },
11838 unsafe { p_allocator.as_ref() },
11839 );
11840 match layer_result {
11841 LayerResult::Handled(res) => match res {
11842 Ok(res) => {
11843 unsafe {
11844 std::slice::from_raw_parts_mut(
11845 p_pipelines,
11846 create_info_count.try_into().unwrap(),
11847 )
11848 }
11849 .copy_from_slice(&res);
11850 vk::Result::SUCCESS
11851 }
11852 Err(e) => e,
11853 },
11854 LayerResult::Unhandled => unsafe {
11855 (dispatch_table.create_graphics_pipelines)(
11856 device,
11857 pipeline_cache,
11858 create_info_count,
11859 p_create_infos,
11860 p_allocator,
11861 p_pipelines,
11862 )
11863 },
11864 }
11865 }
11866 extern "system" fn create_compute_pipelines(
11867 device: vk::Device,
11868 pipeline_cache: vk::PipelineCache,
11869 create_info_count: u32,
11870 p_create_infos: *const vk::ComputePipelineCreateInfo,
11871 p_allocator: *const vk::AllocationCallbacks,
11872 p_pipelines: *mut vk::Pipeline,
11873 ) -> vk::Result {
11874 let global = Self::instance();
11875 let device_info = global.get_device_info(device).unwrap();
11877 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
11878 let layer_result = device_info
11879 .customized_info
11880 .borrow()
11881 .hooks()
11882 .create_compute_pipelines(
11883 pipeline_cache,
11884 unsafe { slice_from_raw_parts(p_create_infos, create_info_count) },
11885 unsafe { p_allocator.as_ref() },
11886 );
11887 match layer_result {
11888 LayerResult::Handled(res) => match res {
11889 Ok(res) => {
11890 unsafe {
11891 std::slice::from_raw_parts_mut(
11892 p_pipelines,
11893 create_info_count.try_into().unwrap(),
11894 )
11895 }
11896 .copy_from_slice(&res);
11897 vk::Result::SUCCESS
11898 }
11899 Err(e) => e,
11900 },
11901 LayerResult::Unhandled => unsafe {
11902 (dispatch_table.create_compute_pipelines)(
11903 device,
11904 pipeline_cache,
11905 create_info_count,
11906 p_create_infos,
11907 p_allocator,
11908 p_pipelines,
11909 )
11910 },
11911 }
11912 }
11913 extern "system" fn destroy_pipeline(
11914 device: vk::Device,
11915 pipeline: vk::Pipeline,
11916 p_allocator: *const vk::AllocationCallbacks,
11917 ) {
11918 let global = Self::instance();
11919 let device_info = global.get_device_info(device).unwrap();
11921 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
11922 let layer_result = device_info
11923 .customized_info
11924 .borrow()
11925 .hooks()
11926 .destroy_pipeline(pipeline, unsafe { p_allocator.as_ref() });
11927 match layer_result {
11928 LayerResult::Handled(res) => res,
11929 LayerResult::Unhandled => unsafe {
11930 (dispatch_table.destroy_pipeline)(device, pipeline, p_allocator)
11931 },
11932 }
11933 }
11934 extern "system" fn create_pipeline_layout(
11935 device: vk::Device,
11936 p_create_info: *const vk::PipelineLayoutCreateInfo,
11937 p_allocator: *const vk::AllocationCallbacks,
11938 p_pipeline_layout: *mut vk::PipelineLayout,
11939 ) -> vk::Result {
11940 let global = Self::instance();
11941 let device_info = global.get_device_info(device).unwrap();
11943 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
11944 let layer_result = device_info
11945 .customized_info
11946 .borrow()
11947 .hooks()
11948 .create_pipeline_layout(unsafe { p_create_info.as_ref() }.unwrap(), unsafe {
11949 p_allocator.as_ref()
11950 });
11951 match layer_result {
11952 LayerResult::Handled(res) => match res {
11953 Ok(res) => {
11954 *unsafe { p_pipeline_layout.as_mut() }.unwrap() = res;
11955 vk::Result::SUCCESS
11956 }
11957 Err(e) => e,
11958 },
11959 LayerResult::Unhandled => unsafe {
11960 (dispatch_table.create_pipeline_layout)(
11961 device,
11962 p_create_info,
11963 p_allocator,
11964 p_pipeline_layout,
11965 )
11966 },
11967 }
11968 }
11969 extern "system" fn destroy_pipeline_layout(
11970 device: vk::Device,
11971 pipeline_layout: vk::PipelineLayout,
11972 p_allocator: *const vk::AllocationCallbacks,
11973 ) {
11974 let global = Self::instance();
11975 let device_info = global.get_device_info(device).unwrap();
11977 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
11978 let layer_result = device_info
11979 .customized_info
11980 .borrow()
11981 .hooks()
11982 .destroy_pipeline_layout(pipeline_layout, unsafe { p_allocator.as_ref() });
11983 match layer_result {
11984 LayerResult::Handled(res) => res,
11985 LayerResult::Unhandled => unsafe {
11986 (dispatch_table.destroy_pipeline_layout)(device, pipeline_layout, p_allocator)
11987 },
11988 }
11989 }
11990 extern "system" fn create_sampler(
11991 device: vk::Device,
11992 p_create_info: *const vk::SamplerCreateInfo,
11993 p_allocator: *const vk::AllocationCallbacks,
11994 p_sampler: *mut vk::Sampler,
11995 ) -> vk::Result {
11996 let global = Self::instance();
11997 let device_info = global.get_device_info(device).unwrap();
11999 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
12000 let layer_result = device_info
12001 .customized_info
12002 .borrow()
12003 .hooks()
12004 .create_sampler(unsafe { p_create_info.as_ref() }.unwrap(), unsafe {
12005 p_allocator.as_ref()
12006 });
12007 match layer_result {
12008 LayerResult::Handled(res) => match res {
12009 Ok(res) => {
12010 *unsafe { p_sampler.as_mut() }.unwrap() = res;
12011 vk::Result::SUCCESS
12012 }
12013 Err(e) => e,
12014 },
12015 LayerResult::Unhandled => unsafe {
12016 (dispatch_table.create_sampler)(device, p_create_info, p_allocator, p_sampler)
12017 },
12018 }
12019 }
12020 extern "system" fn destroy_sampler(
12021 device: vk::Device,
12022 sampler: vk::Sampler,
12023 p_allocator: *const vk::AllocationCallbacks,
12024 ) {
12025 let global = Self::instance();
12026 let device_info = global.get_device_info(device).unwrap();
12028 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
12029 let layer_result = device_info
12030 .customized_info
12031 .borrow()
12032 .hooks()
12033 .destroy_sampler(sampler, unsafe { p_allocator.as_ref() });
12034 match layer_result {
12035 LayerResult::Handled(res) => res,
12036 LayerResult::Unhandled => unsafe {
12037 (dispatch_table.destroy_sampler)(device, sampler, p_allocator)
12038 },
12039 }
12040 }
12041 extern "system" fn create_descriptor_set_layout(
12042 device: vk::Device,
12043 p_create_info: *const vk::DescriptorSetLayoutCreateInfo,
12044 p_allocator: *const vk::AllocationCallbacks,
12045 p_set_layout: *mut vk::DescriptorSetLayout,
12046 ) -> vk::Result {
12047 let global = Self::instance();
12048 let device_info = global.get_device_info(device).unwrap();
12050 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
12051 let layer_result = device_info
12052 .customized_info
12053 .borrow()
12054 .hooks()
12055 .create_descriptor_set_layout(unsafe { p_create_info.as_ref() }.unwrap(), unsafe {
12056 p_allocator.as_ref()
12057 });
12058 match layer_result {
12059 LayerResult::Handled(res) => match res {
12060 Ok(res) => {
12061 *unsafe { p_set_layout.as_mut() }.unwrap() = res;
12062 vk::Result::SUCCESS
12063 }
12064 Err(e) => e,
12065 },
12066 LayerResult::Unhandled => unsafe {
12067 (dispatch_table.create_descriptor_set_layout)(
12068 device,
12069 p_create_info,
12070 p_allocator,
12071 p_set_layout,
12072 )
12073 },
12074 }
12075 }
12076 extern "system" fn destroy_descriptor_set_layout(
12077 device: vk::Device,
12078 descriptor_set_layout: vk::DescriptorSetLayout,
12079 p_allocator: *const vk::AllocationCallbacks,
12080 ) {
12081 let global = Self::instance();
12082 let device_info = global.get_device_info(device).unwrap();
12084 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
12085 let layer_result = device_info
12086 .customized_info
12087 .borrow()
12088 .hooks()
12089 .destroy_descriptor_set_layout(descriptor_set_layout, unsafe { p_allocator.as_ref() });
12090 match layer_result {
12091 LayerResult::Handled(res) => res,
12092 LayerResult::Unhandled => unsafe {
12093 (dispatch_table.destroy_descriptor_set_layout)(
12094 device,
12095 descriptor_set_layout,
12096 p_allocator,
12097 )
12098 },
12099 }
12100 }
12101 extern "system" fn create_descriptor_pool(
12102 device: vk::Device,
12103 p_create_info: *const vk::DescriptorPoolCreateInfo,
12104 p_allocator: *const vk::AllocationCallbacks,
12105 p_descriptor_pool: *mut vk::DescriptorPool,
12106 ) -> vk::Result {
12107 let global = Self::instance();
12108 let device_info = global.get_device_info(device).unwrap();
12110 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
12111 let layer_result = device_info
12112 .customized_info
12113 .borrow()
12114 .hooks()
12115 .create_descriptor_pool(unsafe { p_create_info.as_ref() }.unwrap(), unsafe {
12116 p_allocator.as_ref()
12117 });
12118 match layer_result {
12119 LayerResult::Handled(res) => match res {
12120 Ok(res) => {
12121 *unsafe { p_descriptor_pool.as_mut() }.unwrap() = res;
12122 vk::Result::SUCCESS
12123 }
12124 Err(e) => e,
12125 },
12126 LayerResult::Unhandled => unsafe {
12127 (dispatch_table.create_descriptor_pool)(
12128 device,
12129 p_create_info,
12130 p_allocator,
12131 p_descriptor_pool,
12132 )
12133 },
12134 }
12135 }
12136 extern "system" fn destroy_descriptor_pool(
12137 device: vk::Device,
12138 descriptor_pool: vk::DescriptorPool,
12139 p_allocator: *const vk::AllocationCallbacks,
12140 ) {
12141 let global = Self::instance();
12142 let device_info = global.get_device_info(device).unwrap();
12144 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
12145 let layer_result = device_info
12146 .customized_info
12147 .borrow()
12148 .hooks()
12149 .destroy_descriptor_pool(descriptor_pool, unsafe { p_allocator.as_ref() });
12150 match layer_result {
12151 LayerResult::Handled(res) => res,
12152 LayerResult::Unhandled => unsafe {
12153 (dispatch_table.destroy_descriptor_pool)(device, descriptor_pool, p_allocator)
12154 },
12155 }
12156 }
12157 extern "system" fn reset_descriptor_pool(
12158 device: vk::Device,
12159 descriptor_pool: vk::DescriptorPool,
12160 flags: vk::DescriptorPoolResetFlags,
12161 ) -> vk::Result {
12162 let global = Self::instance();
12163 let device_info = global.get_device_info(device).unwrap();
12165 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
12166 let layer_result = device_info
12167 .customized_info
12168 .borrow()
12169 .hooks()
12170 .reset_descriptor_pool(descriptor_pool, flags);
12171 match layer_result {
12172 LayerResult::Handled(res) => match res {
12173 Ok(()) => vk::Result::SUCCESS,
12174 Err(e) => e,
12175 },
12176 LayerResult::Unhandled => unsafe {
12177 (dispatch_table.reset_descriptor_pool)(device, descriptor_pool, flags)
12178 },
12179 }
12180 }
12181 extern "system" fn allocate_descriptor_sets(
12182 device: vk::Device,
12183 p_allocate_info: *const vk::DescriptorSetAllocateInfo,
12184 p_descriptor_sets: *mut vk::DescriptorSet,
12185 ) -> vk::Result {
12186 let global = Self::instance();
12187 let device_info = global.get_device_info(device).unwrap();
12189 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
12190 let layer_result = device_info
12191 .customized_info
12192 .borrow()
12193 .hooks()
12194 .allocate_descriptor_sets(unsafe { p_allocate_info.as_ref() }.unwrap());
12195 match layer_result {
12196 LayerResult::Handled(res) => match res {
12197 Ok(res) => {
12198 unsafe {
12199 std::slice::from_raw_parts_mut(
12200 p_descriptor_sets,
12201 unsafe { p_allocate_info.as_ref().unwrap() }
12202 .descriptor_set_count
12203 .try_into()
12204 .unwrap(),
12205 )
12206 }
12207 .copy_from_slice(&res);
12208 vk::Result::SUCCESS
12209 }
12210 Err(e) => e,
12211 },
12212 LayerResult::Unhandled => unsafe {
12213 (dispatch_table.allocate_descriptor_sets)(
12214 device,
12215 p_allocate_info,
12216 p_descriptor_sets,
12217 )
12218 },
12219 }
12220 }
12221 extern "system" fn free_descriptor_sets(
12222 device: vk::Device,
12223 descriptor_pool: vk::DescriptorPool,
12224 descriptor_set_count: u32,
12225 p_descriptor_sets: *const vk::DescriptorSet,
12226 ) -> vk::Result {
12227 let global = Self::instance();
12228 let device_info = global.get_device_info(device).unwrap();
12230 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
12231 let layer_result = device_info
12232 .customized_info
12233 .borrow()
12234 .hooks()
12235 .free_descriptor_sets(descriptor_pool, unsafe {
12236 slice_from_raw_parts(p_descriptor_sets, descriptor_set_count)
12237 });
12238 match layer_result {
12239 LayerResult::Handled(res) => match res {
12240 Ok(()) => vk::Result::SUCCESS,
12241 Err(e) => e,
12242 },
12243 LayerResult::Unhandled => unsafe {
12244 (dispatch_table.free_descriptor_sets)(
12245 device,
12246 descriptor_pool,
12247 descriptor_set_count,
12248 p_descriptor_sets,
12249 )
12250 },
12251 }
12252 }
12253 extern "system" fn update_descriptor_sets(
12254 device: vk::Device,
12255 descriptor_write_count: u32,
12256 p_descriptor_writes: *const vk::WriteDescriptorSet,
12257 descriptor_copy_count: u32,
12258 p_descriptor_copies: *const vk::CopyDescriptorSet,
12259 ) {
12260 let global = Self::instance();
12261 let device_info = global.get_device_info(device).unwrap();
12263 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
12264 let layer_result = device_info
12265 .customized_info
12266 .borrow()
12267 .hooks()
12268 .update_descriptor_sets(
12269 unsafe { slice_from_raw_parts(p_descriptor_writes, descriptor_write_count) },
12270 unsafe { slice_from_raw_parts(p_descriptor_copies, descriptor_copy_count) },
12271 );
12272 match layer_result {
12273 LayerResult::Handled(res) => res,
12274 LayerResult::Unhandled => unsafe {
12275 (dispatch_table.update_descriptor_sets)(
12276 device,
12277 descriptor_write_count,
12278 p_descriptor_writes,
12279 descriptor_copy_count,
12280 p_descriptor_copies,
12281 )
12282 },
12283 }
12284 }
12285 extern "system" fn create_framebuffer(
12286 device: vk::Device,
12287 p_create_info: *const vk::FramebufferCreateInfo,
12288 p_allocator: *const vk::AllocationCallbacks,
12289 p_framebuffer: *mut vk::Framebuffer,
12290 ) -> vk::Result {
12291 let global = Self::instance();
12292 let device_info = global.get_device_info(device).unwrap();
12294 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
12295 let layer_result = device_info
12296 .customized_info
12297 .borrow()
12298 .hooks()
12299 .create_framebuffer(unsafe { p_create_info.as_ref() }.unwrap(), unsafe {
12300 p_allocator.as_ref()
12301 });
12302 match layer_result {
12303 LayerResult::Handled(res) => match res {
12304 Ok(res) => {
12305 *unsafe { p_framebuffer.as_mut() }.unwrap() = res;
12306 vk::Result::SUCCESS
12307 }
12308 Err(e) => e,
12309 },
12310 LayerResult::Unhandled => unsafe {
12311 (dispatch_table.create_framebuffer)(
12312 device,
12313 p_create_info,
12314 p_allocator,
12315 p_framebuffer,
12316 )
12317 },
12318 }
12319 }
12320 extern "system" fn destroy_framebuffer(
12321 device: vk::Device,
12322 framebuffer: vk::Framebuffer,
12323 p_allocator: *const vk::AllocationCallbacks,
12324 ) {
12325 let global = Self::instance();
12326 let device_info = global.get_device_info(device).unwrap();
12328 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
12329 let layer_result = device_info
12330 .customized_info
12331 .borrow()
12332 .hooks()
12333 .destroy_framebuffer(framebuffer, unsafe { p_allocator.as_ref() });
12334 match layer_result {
12335 LayerResult::Handled(res) => res,
12336 LayerResult::Unhandled => unsafe {
12337 (dispatch_table.destroy_framebuffer)(device, framebuffer, p_allocator)
12338 },
12339 }
12340 }
12341 extern "system" fn create_render_pass(
12342 device: vk::Device,
12343 p_create_info: *const vk::RenderPassCreateInfo,
12344 p_allocator: *const vk::AllocationCallbacks,
12345 p_render_pass: *mut vk::RenderPass,
12346 ) -> vk::Result {
12347 let global = Self::instance();
12348 let device_info = global.get_device_info(device).unwrap();
12350 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
12351 let layer_result = device_info
12352 .customized_info
12353 .borrow()
12354 .hooks()
12355 .create_render_pass(unsafe { p_create_info.as_ref() }.unwrap(), unsafe {
12356 p_allocator.as_ref()
12357 });
12358 match layer_result {
12359 LayerResult::Handled(res) => match res {
12360 Ok(res) => {
12361 *unsafe { p_render_pass.as_mut() }.unwrap() = res;
12362 vk::Result::SUCCESS
12363 }
12364 Err(e) => e,
12365 },
12366 LayerResult::Unhandled => unsafe {
12367 (dispatch_table.create_render_pass)(
12368 device,
12369 p_create_info,
12370 p_allocator,
12371 p_render_pass,
12372 )
12373 },
12374 }
12375 }
12376 extern "system" fn destroy_render_pass(
12377 device: vk::Device,
12378 render_pass: vk::RenderPass,
12379 p_allocator: *const vk::AllocationCallbacks,
12380 ) {
12381 let global = Self::instance();
12382 let device_info = global.get_device_info(device).unwrap();
12384 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
12385 let layer_result = device_info
12386 .customized_info
12387 .borrow()
12388 .hooks()
12389 .destroy_render_pass(render_pass, unsafe { p_allocator.as_ref() });
12390 match layer_result {
12391 LayerResult::Handled(res) => res,
12392 LayerResult::Unhandled => unsafe {
12393 (dispatch_table.destroy_render_pass)(device, render_pass, p_allocator)
12394 },
12395 }
12396 }
12397 extern "system" fn get_render_area_granularity(
12398 device: vk::Device,
12399 render_pass: vk::RenderPass,
12400 p_granularity: *mut vk::Extent2D,
12401 ) {
12402 let global = Self::instance();
12403 let device_info = global.get_device_info(device).unwrap();
12405 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
12406 let layer_result = device_info
12407 .customized_info
12408 .borrow()
12409 .hooks()
12410 .get_render_area_granularity(
12411 render_pass,
12412 unsafe { ptr_as_uninit_mut(p_granularity) }.unwrap(),
12413 );
12414 match layer_result {
12415 LayerResult::Handled(res) => res,
12416 LayerResult::Unhandled => unsafe {
12417 (dispatch_table.get_render_area_granularity)(device, render_pass, p_granularity)
12418 },
12419 }
12420 }
12421 extern "system" fn create_command_pool(
12422 device: vk::Device,
12423 p_create_info: *const vk::CommandPoolCreateInfo,
12424 p_allocator: *const vk::AllocationCallbacks,
12425 p_command_pool: *mut vk::CommandPool,
12426 ) -> vk::Result {
12427 let global = Self::instance();
12428 let device_info = global.get_device_info(device).unwrap();
12430 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
12431 let layer_result = device_info
12432 .customized_info
12433 .borrow()
12434 .hooks()
12435 .create_command_pool(unsafe { p_create_info.as_ref() }.unwrap(), unsafe {
12436 p_allocator.as_ref()
12437 });
12438 match layer_result {
12439 LayerResult::Handled(res) => match res {
12440 Ok(res) => {
12441 *unsafe { p_command_pool.as_mut() }.unwrap() = res;
12442 vk::Result::SUCCESS
12443 }
12444 Err(e) => e,
12445 },
12446 LayerResult::Unhandled => unsafe {
12447 (dispatch_table.create_command_pool)(
12448 device,
12449 p_create_info,
12450 p_allocator,
12451 p_command_pool,
12452 )
12453 },
12454 }
12455 }
12456 extern "system" fn destroy_command_pool(
12457 device: vk::Device,
12458 command_pool: vk::CommandPool,
12459 p_allocator: *const vk::AllocationCallbacks,
12460 ) {
12461 let global = Self::instance();
12462 let device_info = global.get_device_info(device).unwrap();
12464 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
12465 let layer_result = device_info
12466 .customized_info
12467 .borrow()
12468 .hooks()
12469 .destroy_command_pool(command_pool, unsafe { p_allocator.as_ref() });
12470 match layer_result {
12471 LayerResult::Handled(res) => res,
12472 LayerResult::Unhandled => unsafe {
12473 (dispatch_table.destroy_command_pool)(device, command_pool, p_allocator)
12474 },
12475 }
12476 }
12477 extern "system" fn reset_command_pool(
12478 device: vk::Device,
12479 command_pool: vk::CommandPool,
12480 flags: vk::CommandPoolResetFlags,
12481 ) -> vk::Result {
12482 let global = Self::instance();
12483 let device_info = global.get_device_info(device).unwrap();
12485 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
12486 let layer_result = device_info
12487 .customized_info
12488 .borrow()
12489 .hooks()
12490 .reset_command_pool(command_pool, flags);
12491 match layer_result {
12492 LayerResult::Handled(res) => match res {
12493 Ok(()) => vk::Result::SUCCESS,
12494 Err(e) => e,
12495 },
12496 LayerResult::Unhandled => unsafe {
12497 (dispatch_table.reset_command_pool)(device, command_pool, flags)
12498 },
12499 }
12500 }
12501 extern "system" fn allocate_command_buffers(
12502 device: vk::Device,
12503 p_allocate_info: *const vk::CommandBufferAllocateInfo,
12504 p_command_buffers: *mut vk::CommandBuffer,
12505 ) -> vk::Result {
12506 let global = Self::instance();
12507 let device_info = global.get_device_info(device).unwrap();
12509 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
12510 let layer_result = device_info
12511 .customized_info
12512 .borrow()
12513 .hooks()
12514 .allocate_command_buffers(unsafe { p_allocate_info.as_ref() }.unwrap());
12515 match layer_result {
12516 LayerResult::Handled(res) => match res {
12517 Ok(res) => {
12518 unsafe {
12519 std::slice::from_raw_parts_mut(
12520 p_command_buffers,
12521 unsafe { p_allocate_info.as_ref().unwrap() }
12522 .command_buffer_count
12523 .try_into()
12524 .unwrap(),
12525 )
12526 }
12527 .copy_from_slice(&res);
12528 vk::Result::SUCCESS
12529 }
12530 Err(e) => e,
12531 },
12532 LayerResult::Unhandled => unsafe {
12533 (dispatch_table.allocate_command_buffers)(
12534 device,
12535 p_allocate_info,
12536 p_command_buffers,
12537 )
12538 },
12539 }
12540 }
12541 extern "system" fn free_command_buffers(
12542 device: vk::Device,
12543 command_pool: vk::CommandPool,
12544 command_buffer_count: u32,
12545 p_command_buffers: *const vk::CommandBuffer,
12546 ) {
12547 let global = Self::instance();
12548 let device_info = global.get_device_info(device).unwrap();
12550 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
12551 let layer_result = device_info
12552 .customized_info
12553 .borrow()
12554 .hooks()
12555 .free_command_buffers(command_pool, unsafe {
12556 slice_from_raw_parts(p_command_buffers, command_buffer_count)
12557 });
12558 match layer_result {
12559 LayerResult::Handled(res) => res,
12560 LayerResult::Unhandled => unsafe {
12561 (dispatch_table.free_command_buffers)(
12562 device,
12563 command_pool,
12564 command_buffer_count,
12565 p_command_buffers,
12566 )
12567 },
12568 }
12569 }
12570 extern "system" fn begin_command_buffer(
12571 command_buffer: vk::CommandBuffer,
12572 p_begin_info: *const vk::CommandBufferBeginInfo,
12573 ) -> vk::Result {
12574 let global = Self::instance();
12575 let device_info = global.get_device_info(command_buffer).unwrap();
12577 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
12578 let layer_result = device_info
12579 .customized_info
12580 .borrow()
12581 .hooks()
12582 .begin_command_buffer(command_buffer, unsafe { p_begin_info.as_ref() }.unwrap());
12583 match layer_result {
12584 LayerResult::Handled(res) => match res {
12585 Ok(()) => vk::Result::SUCCESS,
12586 Err(e) => e,
12587 },
12588 LayerResult::Unhandled => unsafe {
12589 (dispatch_table.begin_command_buffer)(command_buffer, p_begin_info)
12590 },
12591 }
12592 }
12593 extern "system" fn end_command_buffer(command_buffer: vk::CommandBuffer) -> vk::Result {
12594 let global = Self::instance();
12595 let device_info = global.get_device_info(command_buffer).unwrap();
12597 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
12598 let layer_result = device_info
12599 .customized_info
12600 .borrow()
12601 .hooks()
12602 .end_command_buffer(command_buffer);
12603 match layer_result {
12604 LayerResult::Handled(res) => match res {
12605 Ok(()) => vk::Result::SUCCESS,
12606 Err(e) => e,
12607 },
12608 LayerResult::Unhandled => unsafe {
12609 (dispatch_table.end_command_buffer)(command_buffer)
12610 },
12611 }
12612 }
12613 extern "system" fn reset_command_buffer(
12614 command_buffer: vk::CommandBuffer,
12615 flags: vk::CommandBufferResetFlags,
12616 ) -> vk::Result {
12617 let global = Self::instance();
12618 let device_info = global.get_device_info(command_buffer).unwrap();
12620 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
12621 let layer_result = device_info
12622 .customized_info
12623 .borrow()
12624 .hooks()
12625 .reset_command_buffer(command_buffer, flags);
12626 match layer_result {
12627 LayerResult::Handled(res) => match res {
12628 Ok(()) => vk::Result::SUCCESS,
12629 Err(e) => e,
12630 },
12631 LayerResult::Unhandled => unsafe {
12632 (dispatch_table.reset_command_buffer)(command_buffer, flags)
12633 },
12634 }
12635 }
12636 extern "system" fn cmd_bind_pipeline(
12637 command_buffer: vk::CommandBuffer,
12638 pipeline_bind_point: vk::PipelineBindPoint,
12639 pipeline: vk::Pipeline,
12640 ) {
12641 let global = Self::instance();
12642 let device_info = global.get_device_info(command_buffer).unwrap();
12644 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
12645 let layer_result = device_info
12646 .customized_info
12647 .borrow()
12648 .hooks()
12649 .cmd_bind_pipeline(command_buffer, pipeline_bind_point, pipeline);
12650 match layer_result {
12651 LayerResult::Handled(res) => res,
12652 LayerResult::Unhandled => unsafe {
12653 (dispatch_table.cmd_bind_pipeline)(command_buffer, pipeline_bind_point, pipeline)
12654 },
12655 }
12656 }
12657 extern "system" fn cmd_set_viewport(
12658 command_buffer: vk::CommandBuffer,
12659 first_viewport: u32,
12660 viewport_count: u32,
12661 p_viewports: *const vk::Viewport,
12662 ) {
12663 let global = Self::instance();
12664 let device_info = global.get_device_info(command_buffer).unwrap();
12666 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
12667 let layer_result = device_info
12668 .customized_info
12669 .borrow()
12670 .hooks()
12671 .cmd_set_viewport(command_buffer, first_viewport, unsafe {
12672 slice_from_raw_parts(p_viewports, viewport_count)
12673 });
12674 match layer_result {
12675 LayerResult::Handled(res) => res,
12676 LayerResult::Unhandled => unsafe {
12677 (dispatch_table.cmd_set_viewport)(
12678 command_buffer,
12679 first_viewport,
12680 viewport_count,
12681 p_viewports,
12682 )
12683 },
12684 }
12685 }
12686 extern "system" fn cmd_set_scissor(
12687 command_buffer: vk::CommandBuffer,
12688 first_scissor: u32,
12689 scissor_count: u32,
12690 p_scissors: *const vk::Rect2D,
12691 ) {
12692 let global = Self::instance();
12693 let device_info = global.get_device_info(command_buffer).unwrap();
12695 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
12696 let layer_result = device_info
12697 .customized_info
12698 .borrow()
12699 .hooks()
12700 .cmd_set_scissor(command_buffer, first_scissor, unsafe {
12701 slice_from_raw_parts(p_scissors, scissor_count)
12702 });
12703 match layer_result {
12704 LayerResult::Handled(res) => res,
12705 LayerResult::Unhandled => unsafe {
12706 (dispatch_table.cmd_set_scissor)(
12707 command_buffer,
12708 first_scissor,
12709 scissor_count,
12710 p_scissors,
12711 )
12712 },
12713 }
12714 }
12715 extern "system" fn cmd_set_line_width(command_buffer: vk::CommandBuffer, line_width: f32) {
12716 let global = Self::instance();
12717 let device_info = global.get_device_info(command_buffer).unwrap();
12719 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
12720 let layer_result = device_info
12721 .customized_info
12722 .borrow()
12723 .hooks()
12724 .cmd_set_line_width(command_buffer, line_width);
12725 match layer_result {
12726 LayerResult::Handled(res) => res,
12727 LayerResult::Unhandled => unsafe {
12728 (dispatch_table.cmd_set_line_width)(command_buffer, line_width)
12729 },
12730 }
12731 }
12732 extern "system" fn cmd_set_depth_bias(
12733 command_buffer: vk::CommandBuffer,
12734 depth_bias_constant_factor: f32,
12735 depth_bias_clamp: f32,
12736 depth_bias_slope_factor: f32,
12737 ) {
12738 let global = Self::instance();
12739 let device_info = global.get_device_info(command_buffer).unwrap();
12741 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
12742 let layer_result = device_info
12743 .customized_info
12744 .borrow()
12745 .hooks()
12746 .cmd_set_depth_bias(
12747 command_buffer,
12748 depth_bias_constant_factor,
12749 depth_bias_clamp,
12750 depth_bias_slope_factor,
12751 );
12752 match layer_result {
12753 LayerResult::Handled(res) => res,
12754 LayerResult::Unhandled => unsafe {
12755 (dispatch_table.cmd_set_depth_bias)(
12756 command_buffer,
12757 depth_bias_constant_factor,
12758 depth_bias_clamp,
12759 depth_bias_slope_factor,
12760 )
12761 },
12762 }
12763 }
12764 extern "system" fn cmd_set_blend_constants(
12765 command_buffer: vk::CommandBuffer,
12766 blend_constants: *const [f32; 4],
12767 ) {
12768 let global = Self::instance();
12769 let device_info = global.get_device_info(command_buffer).unwrap();
12771 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
12772 let layer_result = device_info
12773 .customized_info
12774 .borrow()
12775 .hooks()
12776 .cmd_set_blend_constants(command_buffer, unsafe { blend_constants.as_ref() }.unwrap());
12777 match layer_result {
12778 LayerResult::Handled(res) => res,
12779 LayerResult::Unhandled => unsafe {
12780 (dispatch_table.cmd_set_blend_constants)(command_buffer, blend_constants)
12781 },
12782 }
12783 }
12784 extern "system" fn cmd_set_depth_bounds(
12785 command_buffer: vk::CommandBuffer,
12786 min_depth_bounds: f32,
12787 max_depth_bounds: f32,
12788 ) {
12789 let global = Self::instance();
12790 let device_info = global.get_device_info(command_buffer).unwrap();
12792 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
12793 let layer_result = device_info
12794 .customized_info
12795 .borrow()
12796 .hooks()
12797 .cmd_set_depth_bounds(command_buffer, min_depth_bounds, max_depth_bounds);
12798 match layer_result {
12799 LayerResult::Handled(res) => res,
12800 LayerResult::Unhandled => unsafe {
12801 (dispatch_table.cmd_set_depth_bounds)(
12802 command_buffer,
12803 min_depth_bounds,
12804 max_depth_bounds,
12805 )
12806 },
12807 }
12808 }
12809 extern "system" fn cmd_set_stencil_compare_mask(
12810 command_buffer: vk::CommandBuffer,
12811 face_mask: vk::StencilFaceFlags,
12812 compare_mask: u32,
12813 ) {
12814 let global = Self::instance();
12815 let device_info = global.get_device_info(command_buffer).unwrap();
12817 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
12818 let layer_result = device_info
12819 .customized_info
12820 .borrow()
12821 .hooks()
12822 .cmd_set_stencil_compare_mask(command_buffer, face_mask, compare_mask);
12823 match layer_result {
12824 LayerResult::Handled(res) => res,
12825 LayerResult::Unhandled => unsafe {
12826 (dispatch_table.cmd_set_stencil_compare_mask)(
12827 command_buffer,
12828 face_mask,
12829 compare_mask,
12830 )
12831 },
12832 }
12833 }
12834 extern "system" fn cmd_set_stencil_write_mask(
12835 command_buffer: vk::CommandBuffer,
12836 face_mask: vk::StencilFaceFlags,
12837 write_mask: u32,
12838 ) {
12839 let global = Self::instance();
12840 let device_info = global.get_device_info(command_buffer).unwrap();
12842 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
12843 let layer_result = device_info
12844 .customized_info
12845 .borrow()
12846 .hooks()
12847 .cmd_set_stencil_write_mask(command_buffer, face_mask, write_mask);
12848 match layer_result {
12849 LayerResult::Handled(res) => res,
12850 LayerResult::Unhandled => unsafe {
12851 (dispatch_table.cmd_set_stencil_write_mask)(command_buffer, face_mask, write_mask)
12852 },
12853 }
12854 }
12855 extern "system" fn cmd_set_stencil_reference(
12856 command_buffer: vk::CommandBuffer,
12857 face_mask: vk::StencilFaceFlags,
12858 reference: u32,
12859 ) {
12860 let global = Self::instance();
12861 let device_info = global.get_device_info(command_buffer).unwrap();
12863 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
12864 let layer_result = device_info
12865 .customized_info
12866 .borrow()
12867 .hooks()
12868 .cmd_set_stencil_reference(command_buffer, face_mask, reference);
12869 match layer_result {
12870 LayerResult::Handled(res) => res,
12871 LayerResult::Unhandled => unsafe {
12872 (dispatch_table.cmd_set_stencil_reference)(command_buffer, face_mask, reference)
12873 },
12874 }
12875 }
12876 extern "system" fn cmd_bind_descriptor_sets(
12877 command_buffer: vk::CommandBuffer,
12878 pipeline_bind_point: vk::PipelineBindPoint,
12879 layout: vk::PipelineLayout,
12880 first_set: u32,
12881 descriptor_set_count: u32,
12882 p_descriptor_sets: *const vk::DescriptorSet,
12883 dynamic_offset_count: u32,
12884 p_dynamic_offsets: *const u32,
12885 ) {
12886 let global = Self::instance();
12887 let device_info = global.get_device_info(command_buffer).unwrap();
12889 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
12890 let layer_result = device_info
12891 .customized_info
12892 .borrow()
12893 .hooks()
12894 .cmd_bind_descriptor_sets(
12895 command_buffer,
12896 pipeline_bind_point,
12897 layout,
12898 first_set,
12899 unsafe { slice_from_raw_parts(p_descriptor_sets, descriptor_set_count) },
12900 unsafe { slice_from_raw_parts(p_dynamic_offsets, dynamic_offset_count) },
12901 );
12902 match layer_result {
12903 LayerResult::Handled(res) => res,
12904 LayerResult::Unhandled => unsafe {
12905 (dispatch_table.cmd_bind_descriptor_sets)(
12906 command_buffer,
12907 pipeline_bind_point,
12908 layout,
12909 first_set,
12910 descriptor_set_count,
12911 p_descriptor_sets,
12912 dynamic_offset_count,
12913 p_dynamic_offsets,
12914 )
12915 },
12916 }
12917 }
12918 extern "system" fn cmd_bind_index_buffer(
12919 command_buffer: vk::CommandBuffer,
12920 buffer: vk::Buffer,
12921 offset: vk::DeviceSize,
12922 index_type: vk::IndexType,
12923 ) {
12924 let global = Self::instance();
12925 let device_info = global.get_device_info(command_buffer).unwrap();
12927 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
12928 let layer_result = device_info
12929 .customized_info
12930 .borrow()
12931 .hooks()
12932 .cmd_bind_index_buffer(command_buffer, buffer, offset, index_type);
12933 match layer_result {
12934 LayerResult::Handled(res) => res,
12935 LayerResult::Unhandled => unsafe {
12936 (dispatch_table.cmd_bind_index_buffer)(command_buffer, buffer, offset, index_type)
12937 },
12938 }
12939 }
12940 extern "system" fn cmd_bind_vertex_buffers(
12941 command_buffer: vk::CommandBuffer,
12942 first_binding: u32,
12943 binding_count: u32,
12944 p_buffers: *const vk::Buffer,
12945 p_offsets: *const vk::DeviceSize,
12946 ) {
12947 let global = Self::instance();
12948 let device_info = global.get_device_info(command_buffer).unwrap();
12950 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
12951 let layer_result = device_info
12952 .customized_info
12953 .borrow()
12954 .hooks()
12955 .cmd_bind_vertex_buffers(
12956 command_buffer,
12957 first_binding,
12958 unsafe { slice_from_raw_parts(p_buffers, binding_count) },
12959 unsafe { slice_from_raw_parts(p_offsets, binding_count) },
12960 );
12961 match layer_result {
12962 LayerResult::Handled(res) => res,
12963 LayerResult::Unhandled => unsafe {
12964 (dispatch_table.cmd_bind_vertex_buffers)(
12965 command_buffer,
12966 first_binding,
12967 binding_count,
12968 p_buffers,
12969 p_offsets,
12970 )
12971 },
12972 }
12973 }
12974 extern "system" fn cmd_draw(
12975 command_buffer: vk::CommandBuffer,
12976 vertex_count: u32,
12977 instance_count: u32,
12978 first_vertex: u32,
12979 first_instance: u32,
12980 ) {
12981 let global = Self::instance();
12982 let device_info = global.get_device_info(command_buffer).unwrap();
12984 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
12985 let layer_result = device_info.customized_info.borrow().hooks().cmd_draw(
12986 command_buffer,
12987 vertex_count,
12988 instance_count,
12989 first_vertex,
12990 first_instance,
12991 );
12992 match layer_result {
12993 LayerResult::Handled(res) => res,
12994 LayerResult::Unhandled => unsafe {
12995 (dispatch_table.cmd_draw)(
12996 command_buffer,
12997 vertex_count,
12998 instance_count,
12999 first_vertex,
13000 first_instance,
13001 )
13002 },
13003 }
13004 }
13005 extern "system" fn cmd_draw_indexed(
13006 command_buffer: vk::CommandBuffer,
13007 index_count: u32,
13008 instance_count: u32,
13009 first_index: u32,
13010 vertex_offset: i32,
13011 first_instance: u32,
13012 ) {
13013 let global = Self::instance();
13014 let device_info = global.get_device_info(command_buffer).unwrap();
13016 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
13017 let layer_result = device_info
13018 .customized_info
13019 .borrow()
13020 .hooks()
13021 .cmd_draw_indexed(
13022 command_buffer,
13023 index_count,
13024 instance_count,
13025 first_index,
13026 vertex_offset,
13027 first_instance,
13028 );
13029 match layer_result {
13030 LayerResult::Handled(res) => res,
13031 LayerResult::Unhandled => unsafe {
13032 (dispatch_table.cmd_draw_indexed)(
13033 command_buffer,
13034 index_count,
13035 instance_count,
13036 first_index,
13037 vertex_offset,
13038 first_instance,
13039 )
13040 },
13041 }
13042 }
13043 extern "system" fn cmd_draw_indirect(
13044 command_buffer: vk::CommandBuffer,
13045 buffer: vk::Buffer,
13046 offset: vk::DeviceSize,
13047 draw_count: u32,
13048 stride: u32,
13049 ) {
13050 let global = Self::instance();
13051 let device_info = global.get_device_info(command_buffer).unwrap();
13053 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
13054 let layer_result = device_info
13055 .customized_info
13056 .borrow()
13057 .hooks()
13058 .cmd_draw_indirect(command_buffer, buffer, offset, draw_count, stride);
13059 match layer_result {
13060 LayerResult::Handled(res) => res,
13061 LayerResult::Unhandled => unsafe {
13062 (dispatch_table.cmd_draw_indirect)(
13063 command_buffer,
13064 buffer,
13065 offset,
13066 draw_count,
13067 stride,
13068 )
13069 },
13070 }
13071 }
13072 extern "system" fn cmd_draw_indexed_indirect(
13073 command_buffer: vk::CommandBuffer,
13074 buffer: vk::Buffer,
13075 offset: vk::DeviceSize,
13076 draw_count: u32,
13077 stride: u32,
13078 ) {
13079 let global = Self::instance();
13080 let device_info = global.get_device_info(command_buffer).unwrap();
13082 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
13083 let layer_result = device_info
13084 .customized_info
13085 .borrow()
13086 .hooks()
13087 .cmd_draw_indexed_indirect(command_buffer, buffer, offset, draw_count, stride);
13088 match layer_result {
13089 LayerResult::Handled(res) => res,
13090 LayerResult::Unhandled => unsafe {
13091 (dispatch_table.cmd_draw_indexed_indirect)(
13092 command_buffer,
13093 buffer,
13094 offset,
13095 draw_count,
13096 stride,
13097 )
13098 },
13099 }
13100 }
13101 extern "system" fn cmd_dispatch(
13102 command_buffer: vk::CommandBuffer,
13103 group_countx: u32,
13104 group_county: u32,
13105 group_countz: u32,
13106 ) {
13107 let global = Self::instance();
13108 let device_info = global.get_device_info(command_buffer).unwrap();
13110 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
13111 let layer_result = device_info.customized_info.borrow().hooks().cmd_dispatch(
13112 command_buffer,
13113 group_countx,
13114 group_county,
13115 group_countz,
13116 );
13117 match layer_result {
13118 LayerResult::Handled(res) => res,
13119 LayerResult::Unhandled => unsafe {
13120 (dispatch_table.cmd_dispatch)(
13121 command_buffer,
13122 group_countx,
13123 group_county,
13124 group_countz,
13125 )
13126 },
13127 }
13128 }
13129 extern "system" fn cmd_dispatch_indirect(
13130 command_buffer: vk::CommandBuffer,
13131 buffer: vk::Buffer,
13132 offset: vk::DeviceSize,
13133 ) {
13134 let global = Self::instance();
13135 let device_info = global.get_device_info(command_buffer).unwrap();
13137 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
13138 let layer_result = device_info
13139 .customized_info
13140 .borrow()
13141 .hooks()
13142 .cmd_dispatch_indirect(command_buffer, buffer, offset);
13143 match layer_result {
13144 LayerResult::Handled(res) => res,
13145 LayerResult::Unhandled => unsafe {
13146 (dispatch_table.cmd_dispatch_indirect)(command_buffer, buffer, offset)
13147 },
13148 }
13149 }
13150 extern "system" fn cmd_copy_buffer(
13151 command_buffer: vk::CommandBuffer,
13152 src_buffer: vk::Buffer,
13153 dst_buffer: vk::Buffer,
13154 region_count: u32,
13155 p_regions: *const vk::BufferCopy,
13156 ) {
13157 let global = Self::instance();
13158 let device_info = global.get_device_info(command_buffer).unwrap();
13160 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
13161 let layer_result = device_info
13162 .customized_info
13163 .borrow()
13164 .hooks()
13165 .cmd_copy_buffer(command_buffer, src_buffer, dst_buffer, unsafe {
13166 slice_from_raw_parts(p_regions, region_count)
13167 });
13168 match layer_result {
13169 LayerResult::Handled(res) => res,
13170 LayerResult::Unhandled => unsafe {
13171 (dispatch_table.cmd_copy_buffer)(
13172 command_buffer,
13173 src_buffer,
13174 dst_buffer,
13175 region_count,
13176 p_regions,
13177 )
13178 },
13179 }
13180 }
13181 extern "system" fn cmd_copy_image(
13182 command_buffer: vk::CommandBuffer,
13183 src_image: vk::Image,
13184 src_image_layout: vk::ImageLayout,
13185 dst_image: vk::Image,
13186 dst_image_layout: vk::ImageLayout,
13187 region_count: u32,
13188 p_regions: *const vk::ImageCopy,
13189 ) {
13190 let global = Self::instance();
13191 let device_info = global.get_device_info(command_buffer).unwrap();
13193 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
13194 let layer_result = device_info.customized_info.borrow().hooks().cmd_copy_image(
13195 command_buffer,
13196 src_image,
13197 src_image_layout,
13198 dst_image,
13199 dst_image_layout,
13200 unsafe { slice_from_raw_parts(p_regions, region_count) },
13201 );
13202 match layer_result {
13203 LayerResult::Handled(res) => res,
13204 LayerResult::Unhandled => unsafe {
13205 (dispatch_table.cmd_copy_image)(
13206 command_buffer,
13207 src_image,
13208 src_image_layout,
13209 dst_image,
13210 dst_image_layout,
13211 region_count,
13212 p_regions,
13213 )
13214 },
13215 }
13216 }
13217 extern "system" fn cmd_blit_image(
13218 command_buffer: vk::CommandBuffer,
13219 src_image: vk::Image,
13220 src_image_layout: vk::ImageLayout,
13221 dst_image: vk::Image,
13222 dst_image_layout: vk::ImageLayout,
13223 region_count: u32,
13224 p_regions: *const vk::ImageBlit,
13225 filter: vk::Filter,
13226 ) {
13227 let global = Self::instance();
13228 let device_info = global.get_device_info(command_buffer).unwrap();
13230 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
13231 let layer_result = device_info.customized_info.borrow().hooks().cmd_blit_image(
13232 command_buffer,
13233 src_image,
13234 src_image_layout,
13235 dst_image,
13236 dst_image_layout,
13237 unsafe { slice_from_raw_parts(p_regions, region_count) },
13238 filter,
13239 );
13240 match layer_result {
13241 LayerResult::Handled(res) => res,
13242 LayerResult::Unhandled => unsafe {
13243 (dispatch_table.cmd_blit_image)(
13244 command_buffer,
13245 src_image,
13246 src_image_layout,
13247 dst_image,
13248 dst_image_layout,
13249 region_count,
13250 p_regions,
13251 filter,
13252 )
13253 },
13254 }
13255 }
13256 extern "system" fn cmd_copy_buffer_to_image(
13257 command_buffer: vk::CommandBuffer,
13258 src_buffer: vk::Buffer,
13259 dst_image: vk::Image,
13260 dst_image_layout: vk::ImageLayout,
13261 region_count: u32,
13262 p_regions: *const vk::BufferImageCopy,
13263 ) {
13264 let global = Self::instance();
13265 let device_info = global.get_device_info(command_buffer).unwrap();
13267 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
13268 let layer_result = device_info
13269 .customized_info
13270 .borrow()
13271 .hooks()
13272 .cmd_copy_buffer_to_image(
13273 command_buffer,
13274 src_buffer,
13275 dst_image,
13276 dst_image_layout,
13277 unsafe { slice_from_raw_parts(p_regions, region_count) },
13278 );
13279 match layer_result {
13280 LayerResult::Handled(res) => res,
13281 LayerResult::Unhandled => unsafe {
13282 (dispatch_table.cmd_copy_buffer_to_image)(
13283 command_buffer,
13284 src_buffer,
13285 dst_image,
13286 dst_image_layout,
13287 region_count,
13288 p_regions,
13289 )
13290 },
13291 }
13292 }
13293 extern "system" fn cmd_copy_image_to_buffer(
13294 command_buffer: vk::CommandBuffer,
13295 src_image: vk::Image,
13296 src_image_layout: vk::ImageLayout,
13297 dst_buffer: vk::Buffer,
13298 region_count: u32,
13299 p_regions: *const vk::BufferImageCopy,
13300 ) {
13301 let global = Self::instance();
13302 let device_info = global.get_device_info(command_buffer).unwrap();
13304 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
13305 let layer_result = device_info
13306 .customized_info
13307 .borrow()
13308 .hooks()
13309 .cmd_copy_image_to_buffer(
13310 command_buffer,
13311 src_image,
13312 src_image_layout,
13313 dst_buffer,
13314 unsafe { slice_from_raw_parts(p_regions, region_count) },
13315 );
13316 match layer_result {
13317 LayerResult::Handled(res) => res,
13318 LayerResult::Unhandled => unsafe {
13319 (dispatch_table.cmd_copy_image_to_buffer)(
13320 command_buffer,
13321 src_image,
13322 src_image_layout,
13323 dst_buffer,
13324 region_count,
13325 p_regions,
13326 )
13327 },
13328 }
13329 }
13330 extern "system" fn cmd_update_buffer(
13331 command_buffer: vk::CommandBuffer,
13332 dst_buffer: vk::Buffer,
13333 dst_offset: vk::DeviceSize,
13334 data_size: vk::DeviceSize,
13335 p_data: *const c_void,
13336 ) {
13337 let global = Self::instance();
13338 let device_info = global.get_device_info(command_buffer).unwrap();
13340 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
13341 let layer_result = device_info
13342 .customized_info
13343 .borrow()
13344 .hooks()
13345 .cmd_update_buffer(command_buffer, dst_buffer, dst_offset, unsafe {
13346 slice_from_raw_parts(p_data as *const u8, data_size)
13347 });
13348 match layer_result {
13349 LayerResult::Handled(res) => res,
13350 LayerResult::Unhandled => unsafe {
13351 (dispatch_table.cmd_update_buffer)(
13352 command_buffer,
13353 dst_buffer,
13354 dst_offset,
13355 data_size,
13356 p_data,
13357 )
13358 },
13359 }
13360 }
13361 extern "system" fn cmd_fill_buffer(
13362 command_buffer: vk::CommandBuffer,
13363 dst_buffer: vk::Buffer,
13364 dst_offset: vk::DeviceSize,
13365 size: vk::DeviceSize,
13366 data: u32,
13367 ) {
13368 let global = Self::instance();
13369 let device_info = global.get_device_info(command_buffer).unwrap();
13371 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
13372 let layer_result = device_info
13373 .customized_info
13374 .borrow()
13375 .hooks()
13376 .cmd_fill_buffer(command_buffer, dst_buffer, dst_offset, size, data);
13377 match layer_result {
13378 LayerResult::Handled(res) => res,
13379 LayerResult::Unhandled => unsafe {
13380 (dispatch_table.cmd_fill_buffer)(command_buffer, dst_buffer, dst_offset, size, data)
13381 },
13382 }
13383 }
13384 extern "system" fn cmd_clear_color_image(
13385 command_buffer: vk::CommandBuffer,
13386 image: vk::Image,
13387 image_layout: vk::ImageLayout,
13388 p_color: *const vk::ClearColorValue,
13389 range_count: u32,
13390 p_ranges: *const vk::ImageSubresourceRange,
13391 ) {
13392 let global = Self::instance();
13393 let device_info = global.get_device_info(command_buffer).unwrap();
13395 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
13396 let layer_result = device_info
13397 .customized_info
13398 .borrow()
13399 .hooks()
13400 .cmd_clear_color_image(
13401 command_buffer,
13402 image,
13403 image_layout,
13404 unsafe { p_color.as_ref() }.unwrap(),
13405 unsafe { slice_from_raw_parts(p_ranges, range_count) },
13406 );
13407 match layer_result {
13408 LayerResult::Handled(res) => res,
13409 LayerResult::Unhandled => unsafe {
13410 (dispatch_table.cmd_clear_color_image)(
13411 command_buffer,
13412 image,
13413 image_layout,
13414 p_color,
13415 range_count,
13416 p_ranges,
13417 )
13418 },
13419 }
13420 }
13421 extern "system" fn cmd_clear_depth_stencil_image(
13422 command_buffer: vk::CommandBuffer,
13423 image: vk::Image,
13424 image_layout: vk::ImageLayout,
13425 p_depth_stencil: *const vk::ClearDepthStencilValue,
13426 range_count: u32,
13427 p_ranges: *const vk::ImageSubresourceRange,
13428 ) {
13429 let global = Self::instance();
13430 let device_info = global.get_device_info(command_buffer).unwrap();
13432 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
13433 let layer_result = device_info
13434 .customized_info
13435 .borrow()
13436 .hooks()
13437 .cmd_clear_depth_stencil_image(
13438 command_buffer,
13439 image,
13440 image_layout,
13441 unsafe { p_depth_stencil.as_ref() }.unwrap(),
13442 unsafe { slice_from_raw_parts(p_ranges, range_count) },
13443 );
13444 match layer_result {
13445 LayerResult::Handled(res) => res,
13446 LayerResult::Unhandled => unsafe {
13447 (dispatch_table.cmd_clear_depth_stencil_image)(
13448 command_buffer,
13449 image,
13450 image_layout,
13451 p_depth_stencil,
13452 range_count,
13453 p_ranges,
13454 )
13455 },
13456 }
13457 }
13458 extern "system" fn cmd_clear_attachments(
13459 command_buffer: vk::CommandBuffer,
13460 attachment_count: u32,
13461 p_attachments: *const vk::ClearAttachment,
13462 rect_count: u32,
13463 p_rects: *const vk::ClearRect,
13464 ) {
13465 let global = Self::instance();
13466 let device_info = global.get_device_info(command_buffer).unwrap();
13468 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
13469 let layer_result = device_info
13470 .customized_info
13471 .borrow()
13472 .hooks()
13473 .cmd_clear_attachments(
13474 command_buffer,
13475 unsafe { slice_from_raw_parts(p_attachments, attachment_count) },
13476 unsafe { slice_from_raw_parts(p_rects, rect_count) },
13477 );
13478 match layer_result {
13479 LayerResult::Handled(res) => res,
13480 LayerResult::Unhandled => unsafe {
13481 (dispatch_table.cmd_clear_attachments)(
13482 command_buffer,
13483 attachment_count,
13484 p_attachments,
13485 rect_count,
13486 p_rects,
13487 )
13488 },
13489 }
13490 }
13491 extern "system" fn cmd_resolve_image(
13492 command_buffer: vk::CommandBuffer,
13493 src_image: vk::Image,
13494 src_image_layout: vk::ImageLayout,
13495 dst_image: vk::Image,
13496 dst_image_layout: vk::ImageLayout,
13497 region_count: u32,
13498 p_regions: *const vk::ImageResolve,
13499 ) {
13500 let global = Self::instance();
13501 let device_info = global.get_device_info(command_buffer).unwrap();
13503 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
13504 let layer_result = device_info
13505 .customized_info
13506 .borrow()
13507 .hooks()
13508 .cmd_resolve_image(
13509 command_buffer,
13510 src_image,
13511 src_image_layout,
13512 dst_image,
13513 dst_image_layout,
13514 unsafe { slice_from_raw_parts(p_regions, region_count) },
13515 );
13516 match layer_result {
13517 LayerResult::Handled(res) => res,
13518 LayerResult::Unhandled => unsafe {
13519 (dispatch_table.cmd_resolve_image)(
13520 command_buffer,
13521 src_image,
13522 src_image_layout,
13523 dst_image,
13524 dst_image_layout,
13525 region_count,
13526 p_regions,
13527 )
13528 },
13529 }
13530 }
13531 extern "system" fn cmd_set_event(
13532 command_buffer: vk::CommandBuffer,
13533 event: vk::Event,
13534 stage_mask: vk::PipelineStageFlags,
13535 ) {
13536 let global = Self::instance();
13537 let device_info = global.get_device_info(command_buffer).unwrap();
13539 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
13540 let layer_result = device_info.customized_info.borrow().hooks().cmd_set_event(
13541 command_buffer,
13542 event,
13543 stage_mask,
13544 );
13545 match layer_result {
13546 LayerResult::Handled(res) => res,
13547 LayerResult::Unhandled => unsafe {
13548 (dispatch_table.cmd_set_event)(command_buffer, event, stage_mask)
13549 },
13550 }
13551 }
13552 extern "system" fn cmd_reset_event(
13553 command_buffer: vk::CommandBuffer,
13554 event: vk::Event,
13555 stage_mask: vk::PipelineStageFlags,
13556 ) {
13557 let global = Self::instance();
13558 let device_info = global.get_device_info(command_buffer).unwrap();
13560 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
13561 let layer_result = device_info
13562 .customized_info
13563 .borrow()
13564 .hooks()
13565 .cmd_reset_event(command_buffer, event, stage_mask);
13566 match layer_result {
13567 LayerResult::Handled(res) => res,
13568 LayerResult::Unhandled => unsafe {
13569 (dispatch_table.cmd_reset_event)(command_buffer, event, stage_mask)
13570 },
13571 }
13572 }
13573 extern "system" fn cmd_wait_events(
13574 command_buffer: vk::CommandBuffer,
13575 event_count: u32,
13576 p_events: *const vk::Event,
13577 src_stage_mask: vk::PipelineStageFlags,
13578 dst_stage_mask: vk::PipelineStageFlags,
13579 memory_barrier_count: u32,
13580 p_memory_barriers: *const vk::MemoryBarrier,
13581 buffer_memory_barrier_count: u32,
13582 p_buffer_memory_barriers: *const vk::BufferMemoryBarrier,
13583 image_memory_barrier_count: u32,
13584 p_image_memory_barriers: *const vk::ImageMemoryBarrier,
13585 ) {
13586 let global = Self::instance();
13587 let device_info = global.get_device_info(command_buffer).unwrap();
13589 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
13590 let layer_result = device_info
13591 .customized_info
13592 .borrow()
13593 .hooks()
13594 .cmd_wait_events(
13595 command_buffer,
13596 unsafe { slice_from_raw_parts(p_events, event_count) },
13597 src_stage_mask,
13598 dst_stage_mask,
13599 unsafe { slice_from_raw_parts(p_memory_barriers, memory_barrier_count) },
13600 unsafe {
13601 slice_from_raw_parts(p_buffer_memory_barriers, buffer_memory_barrier_count)
13602 },
13603 unsafe {
13604 slice_from_raw_parts(p_image_memory_barriers, image_memory_barrier_count)
13605 },
13606 );
13607 match layer_result {
13608 LayerResult::Handled(res) => res,
13609 LayerResult::Unhandled => unsafe {
13610 (dispatch_table.cmd_wait_events)(
13611 command_buffer,
13612 event_count,
13613 p_events,
13614 src_stage_mask,
13615 dst_stage_mask,
13616 memory_barrier_count,
13617 p_memory_barriers,
13618 buffer_memory_barrier_count,
13619 p_buffer_memory_barriers,
13620 image_memory_barrier_count,
13621 p_image_memory_barriers,
13622 )
13623 },
13624 }
13625 }
13626 extern "system" fn cmd_pipeline_barrier(
13627 command_buffer: vk::CommandBuffer,
13628 src_stage_mask: vk::PipelineStageFlags,
13629 dst_stage_mask: vk::PipelineStageFlags,
13630 dependency_flags: vk::DependencyFlags,
13631 memory_barrier_count: u32,
13632 p_memory_barriers: *const vk::MemoryBarrier,
13633 buffer_memory_barrier_count: u32,
13634 p_buffer_memory_barriers: *const vk::BufferMemoryBarrier,
13635 image_memory_barrier_count: u32,
13636 p_image_memory_barriers: *const vk::ImageMemoryBarrier,
13637 ) {
13638 let global = Self::instance();
13639 let device_info = global.get_device_info(command_buffer).unwrap();
13641 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
13642 let layer_result = device_info
13643 .customized_info
13644 .borrow()
13645 .hooks()
13646 .cmd_pipeline_barrier(
13647 command_buffer,
13648 src_stage_mask,
13649 dst_stage_mask,
13650 dependency_flags,
13651 unsafe { slice_from_raw_parts(p_memory_barriers, memory_barrier_count) },
13652 unsafe {
13653 slice_from_raw_parts(p_buffer_memory_barriers, buffer_memory_barrier_count)
13654 },
13655 unsafe {
13656 slice_from_raw_parts(p_image_memory_barriers, image_memory_barrier_count)
13657 },
13658 );
13659 match layer_result {
13660 LayerResult::Handled(res) => res,
13661 LayerResult::Unhandled => unsafe {
13662 (dispatch_table.cmd_pipeline_barrier)(
13663 command_buffer,
13664 src_stage_mask,
13665 dst_stage_mask,
13666 dependency_flags,
13667 memory_barrier_count,
13668 p_memory_barriers,
13669 buffer_memory_barrier_count,
13670 p_buffer_memory_barriers,
13671 image_memory_barrier_count,
13672 p_image_memory_barriers,
13673 )
13674 },
13675 }
13676 }
13677 extern "system" fn cmd_begin_query(
13678 command_buffer: vk::CommandBuffer,
13679 query_pool: vk::QueryPool,
13680 query: u32,
13681 flags: vk::QueryControlFlags,
13682 ) {
13683 let global = Self::instance();
13684 let device_info = global.get_device_info(command_buffer).unwrap();
13686 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
13687 let layer_result = device_info
13688 .customized_info
13689 .borrow()
13690 .hooks()
13691 .cmd_begin_query(command_buffer, query_pool, query, flags);
13692 match layer_result {
13693 LayerResult::Handled(res) => res,
13694 LayerResult::Unhandled => unsafe {
13695 (dispatch_table.cmd_begin_query)(command_buffer, query_pool, query, flags)
13696 },
13697 }
13698 }
13699 extern "system" fn cmd_end_query(
13700 command_buffer: vk::CommandBuffer,
13701 query_pool: vk::QueryPool,
13702 query: u32,
13703 ) {
13704 let global = Self::instance();
13705 let device_info = global.get_device_info(command_buffer).unwrap();
13707 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
13708 let layer_result = device_info.customized_info.borrow().hooks().cmd_end_query(
13709 command_buffer,
13710 query_pool,
13711 query,
13712 );
13713 match layer_result {
13714 LayerResult::Handled(res) => res,
13715 LayerResult::Unhandled => unsafe {
13716 (dispatch_table.cmd_end_query)(command_buffer, query_pool, query)
13717 },
13718 }
13719 }
13720 extern "system" fn cmd_reset_query_pool(
13721 command_buffer: vk::CommandBuffer,
13722 query_pool: vk::QueryPool,
13723 first_query: u32,
13724 query_count: u32,
13725 ) {
13726 let global = Self::instance();
13727 let device_info = global.get_device_info(command_buffer).unwrap();
13729 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
13730 let layer_result = device_info
13731 .customized_info
13732 .borrow()
13733 .hooks()
13734 .cmd_reset_query_pool(command_buffer, query_pool, first_query, query_count);
13735 match layer_result {
13736 LayerResult::Handled(res) => res,
13737 LayerResult::Unhandled => unsafe {
13738 (dispatch_table.cmd_reset_query_pool)(
13739 command_buffer,
13740 query_pool,
13741 first_query,
13742 query_count,
13743 )
13744 },
13745 }
13746 }
13747 extern "system" fn cmd_write_timestamp(
13748 command_buffer: vk::CommandBuffer,
13749 pipeline_stage: vk::PipelineStageFlags,
13750 query_pool: vk::QueryPool,
13751 query: u32,
13752 ) {
13753 let global = Self::instance();
13754 let device_info = global.get_device_info(command_buffer).unwrap();
13756 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
13757 let layer_result = device_info
13758 .customized_info
13759 .borrow()
13760 .hooks()
13761 .cmd_write_timestamp(command_buffer, pipeline_stage, query_pool, query);
13762 match layer_result {
13763 LayerResult::Handled(res) => res,
13764 LayerResult::Unhandled => unsafe {
13765 (dispatch_table.cmd_write_timestamp)(
13766 command_buffer,
13767 pipeline_stage,
13768 query_pool,
13769 query,
13770 )
13771 },
13772 }
13773 }
13774 extern "system" fn cmd_copy_query_pool_results(
13775 command_buffer: vk::CommandBuffer,
13776 query_pool: vk::QueryPool,
13777 first_query: u32,
13778 query_count: u32,
13779 dst_buffer: vk::Buffer,
13780 dst_offset: vk::DeviceSize,
13781 stride: vk::DeviceSize,
13782 flags: vk::QueryResultFlags,
13783 ) {
13784 let global = Self::instance();
13785 let device_info = global.get_device_info(command_buffer).unwrap();
13787 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
13788 let layer_result = device_info
13789 .customized_info
13790 .borrow()
13791 .hooks()
13792 .cmd_copy_query_pool_results(
13793 command_buffer,
13794 query_pool,
13795 first_query,
13796 query_count,
13797 dst_buffer,
13798 dst_offset,
13799 stride,
13800 flags,
13801 );
13802 match layer_result {
13803 LayerResult::Handled(res) => res,
13804 LayerResult::Unhandled => unsafe {
13805 (dispatch_table.cmd_copy_query_pool_results)(
13806 command_buffer,
13807 query_pool,
13808 first_query,
13809 query_count,
13810 dst_buffer,
13811 dst_offset,
13812 stride,
13813 flags,
13814 )
13815 },
13816 }
13817 }
13818 extern "system" fn cmd_push_constants(
13819 command_buffer: vk::CommandBuffer,
13820 layout: vk::PipelineLayout,
13821 stage_flags: vk::ShaderStageFlags,
13822 offset: u32,
13823 size: u32,
13824 p_values: *const c_void,
13825 ) {
13826 let global = Self::instance();
13827 let device_info = global.get_device_info(command_buffer).unwrap();
13829 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
13830 let layer_result = device_info
13831 .customized_info
13832 .borrow()
13833 .hooks()
13834 .cmd_push_constants(command_buffer, layout, stage_flags, offset, unsafe {
13835 slice_from_raw_parts(p_values as *const u8, size)
13836 });
13837 match layer_result {
13838 LayerResult::Handled(res) => res,
13839 LayerResult::Unhandled => unsafe {
13840 (dispatch_table.cmd_push_constants)(
13841 command_buffer,
13842 layout,
13843 stage_flags,
13844 offset,
13845 size,
13846 p_values,
13847 )
13848 },
13849 }
13850 }
13851 extern "system" fn cmd_begin_render_pass(
13852 command_buffer: vk::CommandBuffer,
13853 p_render_pass_begin: *const vk::RenderPassBeginInfo,
13854 contents: vk::SubpassContents,
13855 ) {
13856 let global = Self::instance();
13857 let device_info = global.get_device_info(command_buffer).unwrap();
13859 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
13860 let layer_result = device_info
13861 .customized_info
13862 .borrow()
13863 .hooks()
13864 .cmd_begin_render_pass(
13865 command_buffer,
13866 unsafe { p_render_pass_begin.as_ref() }.unwrap(),
13867 contents,
13868 );
13869 match layer_result {
13870 LayerResult::Handled(res) => res,
13871 LayerResult::Unhandled => unsafe {
13872 (dispatch_table.cmd_begin_render_pass)(
13873 command_buffer,
13874 p_render_pass_begin,
13875 contents,
13876 )
13877 },
13878 }
13879 }
13880 extern "system" fn cmd_next_subpass(
13881 command_buffer: vk::CommandBuffer,
13882 contents: vk::SubpassContents,
13883 ) {
13884 let global = Self::instance();
13885 let device_info = global.get_device_info(command_buffer).unwrap();
13887 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
13888 let layer_result = device_info
13889 .customized_info
13890 .borrow()
13891 .hooks()
13892 .cmd_next_subpass(command_buffer, contents);
13893 match layer_result {
13894 LayerResult::Handled(res) => res,
13895 LayerResult::Unhandled => unsafe {
13896 (dispatch_table.cmd_next_subpass)(command_buffer, contents)
13897 },
13898 }
13899 }
13900 extern "system" fn cmd_end_render_pass(command_buffer: vk::CommandBuffer) {
13901 let global = Self::instance();
13902 let device_info = global.get_device_info(command_buffer).unwrap();
13904 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
13905 let layer_result = device_info
13906 .customized_info
13907 .borrow()
13908 .hooks()
13909 .cmd_end_render_pass(command_buffer);
13910 match layer_result {
13911 LayerResult::Handled(res) => res,
13912 LayerResult::Unhandled => unsafe {
13913 (dispatch_table.cmd_end_render_pass)(command_buffer)
13914 },
13915 }
13916 }
13917 extern "system" fn cmd_execute_commands(
13918 command_buffer: vk::CommandBuffer,
13919 command_buffer_count: u32,
13920 p_command_buffers: *const vk::CommandBuffer,
13921 ) {
13922 let global = Self::instance();
13923 let device_info = global.get_device_info(command_buffer).unwrap();
13925 let dispatch_table = &device_info.dispatch_table.core.fp_v1_0();
13926 let layer_result = device_info
13927 .customized_info
13928 .borrow()
13929 .hooks()
13930 .cmd_execute_commands(command_buffer, unsafe {
13931 slice_from_raw_parts(p_command_buffers, command_buffer_count)
13932 });
13933 match layer_result {
13934 LayerResult::Handled(res) => res,
13935 LayerResult::Unhandled => unsafe {
13936 (dispatch_table.cmd_execute_commands)(
13937 command_buffer,
13938 command_buffer_count,
13939 p_command_buffers,
13940 )
13941 },
13942 }
13943 }
13944 extern "system" fn bind_buffer_memory2(
13945 device: vk::Device,
13946 bind_info_count: u32,
13947 p_bind_infos: *const vk::BindBufferMemoryInfo,
13948 ) -> vk::Result {
13949 let global = Self::instance();
13950 let device_info = global.get_device_info(device).unwrap();
13952 let dispatch_table = &device_info.dispatch_table.core.fp_v1_1();
13953 let layer_result = device_info
13954 .customized_info
13955 .borrow()
13956 .hooks()
13957 .bind_buffer_memory2(unsafe { slice_from_raw_parts(p_bind_infos, bind_info_count) });
13958 match layer_result {
13959 LayerResult::Handled(res) => match res {
13960 Ok(()) => vk::Result::SUCCESS,
13961 Err(e) => e,
13962 },
13963 LayerResult::Unhandled => unsafe {
13964 (dispatch_table.bind_buffer_memory2)(device, bind_info_count, p_bind_infos)
13965 },
13966 }
13967 }
13968 extern "system" fn bind_image_memory2(
13969 device: vk::Device,
13970 bind_info_count: u32,
13971 p_bind_infos: *const vk::BindImageMemoryInfo,
13972 ) -> vk::Result {
13973 let global = Self::instance();
13974 let device_info = global.get_device_info(device).unwrap();
13976 let dispatch_table = &device_info.dispatch_table.core.fp_v1_1();
13977 let layer_result = device_info
13978 .customized_info
13979 .borrow()
13980 .hooks()
13981 .bind_image_memory2(unsafe { slice_from_raw_parts(p_bind_infos, bind_info_count) });
13982 match layer_result {
13983 LayerResult::Handled(res) => match res {
13984 Ok(()) => vk::Result::SUCCESS,
13985 Err(e) => e,
13986 },
13987 LayerResult::Unhandled => unsafe {
13988 (dispatch_table.bind_image_memory2)(device, bind_info_count, p_bind_infos)
13989 },
13990 }
13991 }
13992 extern "system" fn get_device_group_peer_memory_features(
13993 device: vk::Device,
13994 heap_index: u32,
13995 local_device_index: u32,
13996 remote_device_index: u32,
13997 p_peer_memory_features: *mut vk::PeerMemoryFeatureFlags,
13998 ) {
13999 let global = Self::instance();
14000 let device_info = global.get_device_info(device).unwrap();
14002 let dispatch_table = &device_info.dispatch_table.core.fp_v1_1();
14003 let layer_result = device_info
14004 .customized_info
14005 .borrow()
14006 .hooks()
14007 .get_device_group_peer_memory_features(
14008 heap_index,
14009 local_device_index,
14010 remote_device_index,
14011 );
14012 match layer_result {
14013 LayerResult::Handled(res) => {
14014 *unsafe { p_peer_memory_features.as_mut() }.unwrap() = res;
14015 }
14016 LayerResult::Unhandled => unsafe {
14017 (dispatch_table.get_device_group_peer_memory_features)(
14018 device,
14019 heap_index,
14020 local_device_index,
14021 remote_device_index,
14022 p_peer_memory_features,
14023 )
14024 },
14025 }
14026 }
14027 extern "system" fn cmd_set_device_mask(command_buffer: vk::CommandBuffer, device_mask: u32) {
14028 let global = Self::instance();
14029 let device_info = global.get_device_info(command_buffer).unwrap();
14031 let dispatch_table = &device_info.dispatch_table.core.fp_v1_1();
14032 let layer_result = device_info
14033 .customized_info
14034 .borrow()
14035 .hooks()
14036 .cmd_set_device_mask(command_buffer, device_mask);
14037 match layer_result {
14038 LayerResult::Handled(res) => res,
14039 LayerResult::Unhandled => unsafe {
14040 (dispatch_table.cmd_set_device_mask)(command_buffer, device_mask)
14041 },
14042 }
14043 }
14044 extern "system" fn cmd_dispatch_base(
14045 command_buffer: vk::CommandBuffer,
14046 base_groupx: u32,
14047 base_groupy: u32,
14048 base_groupz: u32,
14049 group_countx: u32,
14050 group_county: u32,
14051 group_countz: u32,
14052 ) {
14053 let global = Self::instance();
14054 let device_info = global.get_device_info(command_buffer).unwrap();
14056 let dispatch_table = &device_info.dispatch_table.core.fp_v1_1();
14057 let layer_result = device_info
14058 .customized_info
14059 .borrow()
14060 .hooks()
14061 .cmd_dispatch_base(
14062 command_buffer,
14063 base_groupx,
14064 base_groupy,
14065 base_groupz,
14066 group_countx,
14067 group_county,
14068 group_countz,
14069 );
14070 match layer_result {
14071 LayerResult::Handled(res) => res,
14072 LayerResult::Unhandled => unsafe {
14073 (dispatch_table.cmd_dispatch_base)(
14074 command_buffer,
14075 base_groupx,
14076 base_groupy,
14077 base_groupz,
14078 group_countx,
14079 group_county,
14080 group_countz,
14081 )
14082 },
14083 }
14084 }
14085 extern "system" fn get_image_memory_requirements2(
14086 device: vk::Device,
14087 p_info: *const vk::ImageMemoryRequirementsInfo2,
14088 p_memory_requirements: *mut vk::MemoryRequirements2,
14089 ) {
14090 let global = Self::instance();
14091 let device_info = global.get_device_info(device).unwrap();
14093 let dispatch_table = &device_info.dispatch_table.core.fp_v1_1();
14094 let layer_result = device_info
14095 .customized_info
14096 .borrow()
14097 .hooks()
14098 .get_image_memory_requirements2(
14099 unsafe { p_info.as_ref() }.unwrap(),
14100 unsafe { ptr_as_uninit_mut(p_memory_requirements) }.unwrap(),
14101 );
14102 match layer_result {
14103 LayerResult::Handled(res) => res,
14104 LayerResult::Unhandled => unsafe {
14105 (dispatch_table.get_image_memory_requirements2)(
14106 device,
14107 p_info,
14108 p_memory_requirements,
14109 )
14110 },
14111 }
14112 }
14113 extern "system" fn get_buffer_memory_requirements2(
14114 device: vk::Device,
14115 p_info: *const vk::BufferMemoryRequirementsInfo2,
14116 p_memory_requirements: *mut vk::MemoryRequirements2,
14117 ) {
14118 let global = Self::instance();
14119 let device_info = global.get_device_info(device).unwrap();
14121 let dispatch_table = &device_info.dispatch_table.core.fp_v1_1();
14122 let layer_result = device_info
14123 .customized_info
14124 .borrow()
14125 .hooks()
14126 .get_buffer_memory_requirements2(
14127 unsafe { p_info.as_ref() }.unwrap(),
14128 unsafe { ptr_as_uninit_mut(p_memory_requirements) }.unwrap(),
14129 );
14130 match layer_result {
14131 LayerResult::Handled(res) => res,
14132 LayerResult::Unhandled => unsafe {
14133 (dispatch_table.get_buffer_memory_requirements2)(
14134 device,
14135 p_info,
14136 p_memory_requirements,
14137 )
14138 },
14139 }
14140 }
14141 extern "system" fn get_image_sparse_memory_requirements2(
14142 device: vk::Device,
14143 p_info: *const vk::ImageSparseMemoryRequirementsInfo2,
14144 p_sparse_memory_requirement_count: *mut u32,
14145 p_sparse_memory_requirements: *mut vk::SparseImageMemoryRequirements2,
14146 ) {
14147 let global = Self::instance();
14148 let device_info = global.get_device_info(device).unwrap();
14150 let dispatch_table = &device_info.dispatch_table.core.fp_v1_1();
14151 let layer_result = device_info
14152 .customized_info
14153 .borrow()
14154 .hooks()
14155 .get_image_sparse_memory_requirements2(
14156 unsafe { p_info.as_ref() }.unwrap(),
14157 unsafe { ptr_as_uninit_mut(p_sparse_memory_requirement_count) }.unwrap(),
14158 unsafe {
14159 maybe_uninit_slice_from_raw_parts_mut(
14160 p_sparse_memory_requirements,
14161 p_sparse_memory_requirement_count,
14162 )
14163 },
14164 );
14165 match layer_result {
14166 LayerResult::Handled(res) => res,
14167 LayerResult::Unhandled => unsafe {
14168 (dispatch_table.get_image_sparse_memory_requirements2)(
14169 device,
14170 p_info,
14171 p_sparse_memory_requirement_count,
14172 p_sparse_memory_requirements,
14173 )
14174 },
14175 }
14176 }
14177 extern "system" fn trim_command_pool(
14178 device: vk::Device,
14179 command_pool: vk::CommandPool,
14180 flags: vk::CommandPoolTrimFlags,
14181 ) {
14182 let global = Self::instance();
14183 let device_info = global.get_device_info(device).unwrap();
14185 let dispatch_table = &device_info.dispatch_table.core.fp_v1_1();
14186 let layer_result = device_info
14187 .customized_info
14188 .borrow()
14189 .hooks()
14190 .trim_command_pool(command_pool, flags);
14191 match layer_result {
14192 LayerResult::Handled(res) => res,
14193 LayerResult::Unhandled => unsafe {
14194 (dispatch_table.trim_command_pool)(device, command_pool, flags)
14195 },
14196 }
14197 }
14198 extern "system" fn get_device_queue2(
14199 device: vk::Device,
14200 p_queue_info: *const vk::DeviceQueueInfo2,
14201 p_queue: *mut vk::Queue,
14202 ) {
14203 let global = Self::instance();
14204 let device_info = global.get_device_info(device).unwrap();
14206 let dispatch_table = &device_info.dispatch_table.core.fp_v1_1();
14207 let layer_result = device_info
14208 .customized_info
14209 .borrow()
14210 .hooks()
14211 .get_device_queue2(unsafe { p_queue_info.as_ref() }.unwrap());
14212 match layer_result {
14213 LayerResult::Handled(res) => {
14214 *unsafe { p_queue.as_mut() }.unwrap() = res;
14215 }
14216 LayerResult::Unhandled => unsafe {
14217 (dispatch_table.get_device_queue2)(device, p_queue_info, p_queue)
14218 },
14219 }
14220 }
14221 extern "system" fn create_sampler_ycbcr_conversion(
14222 device: vk::Device,
14223 p_create_info: *const vk::SamplerYcbcrConversionCreateInfo,
14224 p_allocator: *const vk::AllocationCallbacks,
14225 p_ycbcr_conversion: *mut vk::SamplerYcbcrConversion,
14226 ) -> vk::Result {
14227 let global = Self::instance();
14228 let device_info = global.get_device_info(device).unwrap();
14230 let dispatch_table = &device_info.dispatch_table.core.fp_v1_1();
14231 let layer_result = device_info
14232 .customized_info
14233 .borrow()
14234 .hooks()
14235 .create_sampler_ycbcr_conversion(unsafe { p_create_info.as_ref() }.unwrap(), unsafe {
14236 p_allocator.as_ref()
14237 });
14238 match layer_result {
14239 LayerResult::Handled(res) => match res {
14240 Ok(res) => {
14241 *unsafe { p_ycbcr_conversion.as_mut() }.unwrap() = res;
14242 vk::Result::SUCCESS
14243 }
14244 Err(e) => e,
14245 },
14246 LayerResult::Unhandled => unsafe {
14247 (dispatch_table.create_sampler_ycbcr_conversion)(
14248 device,
14249 p_create_info,
14250 p_allocator,
14251 p_ycbcr_conversion,
14252 )
14253 },
14254 }
14255 }
14256 extern "system" fn destroy_sampler_ycbcr_conversion(
14257 device: vk::Device,
14258 ycbcr_conversion: vk::SamplerYcbcrConversion,
14259 p_allocator: *const vk::AllocationCallbacks,
14260 ) {
14261 let global = Self::instance();
14262 let device_info = global.get_device_info(device).unwrap();
14264 let dispatch_table = &device_info.dispatch_table.core.fp_v1_1();
14265 let layer_result = device_info
14266 .customized_info
14267 .borrow()
14268 .hooks()
14269 .destroy_sampler_ycbcr_conversion(ycbcr_conversion, unsafe { p_allocator.as_ref() });
14270 match layer_result {
14271 LayerResult::Handled(res) => res,
14272 LayerResult::Unhandled => unsafe {
14273 (dispatch_table.destroy_sampler_ycbcr_conversion)(
14274 device,
14275 ycbcr_conversion,
14276 p_allocator,
14277 )
14278 },
14279 }
14280 }
14281 extern "system" fn create_descriptor_update_template(
14282 device: vk::Device,
14283 p_create_info: *const vk::DescriptorUpdateTemplateCreateInfo,
14284 p_allocator: *const vk::AllocationCallbacks,
14285 p_descriptor_update_template: *mut vk::DescriptorUpdateTemplate,
14286 ) -> vk::Result {
14287 let global = Self::instance();
14288 let device_info = global.get_device_info(device).unwrap();
14290 let dispatch_table = &device_info.dispatch_table.core.fp_v1_1();
14291 let layer_result = device_info
14292 .customized_info
14293 .borrow()
14294 .hooks()
14295 .create_descriptor_update_template(
14296 unsafe { p_create_info.as_ref() }.unwrap(),
14297 unsafe { p_allocator.as_ref() },
14298 );
14299 match layer_result {
14300 LayerResult::Handled(res) => match res {
14301 Ok(res) => {
14302 *unsafe { p_descriptor_update_template.as_mut() }.unwrap() = res;
14303 vk::Result::SUCCESS
14304 }
14305 Err(e) => e,
14306 },
14307 LayerResult::Unhandled => unsafe {
14308 (dispatch_table.create_descriptor_update_template)(
14309 device,
14310 p_create_info,
14311 p_allocator,
14312 p_descriptor_update_template,
14313 )
14314 },
14315 }
14316 }
14317 extern "system" fn destroy_descriptor_update_template(
14318 device: vk::Device,
14319 descriptor_update_template: vk::DescriptorUpdateTemplate,
14320 p_allocator: *const vk::AllocationCallbacks,
14321 ) {
14322 let global = Self::instance();
14323 let device_info = global.get_device_info(device).unwrap();
14325 let dispatch_table = &device_info.dispatch_table.core.fp_v1_1();
14326 let layer_result = device_info
14327 .customized_info
14328 .borrow()
14329 .hooks()
14330 .destroy_descriptor_update_template(descriptor_update_template, unsafe {
14331 p_allocator.as_ref()
14332 });
14333 match layer_result {
14334 LayerResult::Handled(res) => res,
14335 LayerResult::Unhandled => unsafe {
14336 (dispatch_table.destroy_descriptor_update_template)(
14337 device,
14338 descriptor_update_template,
14339 p_allocator,
14340 )
14341 },
14342 }
14343 }
14344 extern "system" fn update_descriptor_set_with_template(
14345 device: vk::Device,
14346 descriptor_set: vk::DescriptorSet,
14347 descriptor_update_template: vk::DescriptorUpdateTemplate,
14348 p_data: *const c_void,
14349 ) {
14350 let global = Self::instance();
14351 let device_info = global.get_device_info(device).unwrap();
14353 let dispatch_table = &device_info.dispatch_table.core.fp_v1_1();
14354 let layer_result = device_info
14355 .customized_info
14356 .borrow()
14357 .hooks()
14358 .update_descriptor_set_with_template(
14359 descriptor_set,
14360 descriptor_update_template,
14361 p_data,
14362 );
14363 match layer_result {
14364 LayerResult::Handled(res) => res,
14365 LayerResult::Unhandled => unsafe {
14366 (dispatch_table.update_descriptor_set_with_template)(
14367 device,
14368 descriptor_set,
14369 descriptor_update_template,
14370 p_data,
14371 )
14372 },
14373 }
14374 }
14375 extern "system" fn get_descriptor_set_layout_support(
14376 device: vk::Device,
14377 p_create_info: *const vk::DescriptorSetLayoutCreateInfo,
14378 p_support: *mut vk::DescriptorSetLayoutSupport,
14379 ) {
14380 let global = Self::instance();
14381 let device_info = global.get_device_info(device).unwrap();
14383 let dispatch_table = &device_info.dispatch_table.core.fp_v1_1();
14384 let layer_result = device_info
14385 .customized_info
14386 .borrow()
14387 .hooks()
14388 .get_descriptor_set_layout_support(
14389 unsafe { p_create_info.as_ref() }.unwrap(),
14390 unsafe { ptr_as_uninit_mut(p_support) }.unwrap(),
14391 );
14392 match layer_result {
14393 LayerResult::Handled(res) => res,
14394 LayerResult::Unhandled => unsafe {
14395 (dispatch_table.get_descriptor_set_layout_support)(device, p_create_info, p_support)
14396 },
14397 }
14398 }
14399 extern "system" fn cmd_draw_indirect_count(
14400 command_buffer: vk::CommandBuffer,
14401 buffer: vk::Buffer,
14402 offset: vk::DeviceSize,
14403 count_buffer: vk::Buffer,
14404 count_buffer_offset: vk::DeviceSize,
14405 max_draw_count: u32,
14406 stride: u32,
14407 ) {
14408 let global = Self::instance();
14409 let device_info = global.get_device_info(command_buffer).unwrap();
14411 let dispatch_table = &device_info.dispatch_table.core.fp_v1_2();
14412 let layer_result = device_info
14413 .customized_info
14414 .borrow()
14415 .hooks()
14416 .cmd_draw_indirect_count(
14417 command_buffer,
14418 buffer,
14419 offset,
14420 count_buffer,
14421 count_buffer_offset,
14422 max_draw_count,
14423 stride,
14424 );
14425 match layer_result {
14426 LayerResult::Handled(res) => res,
14427 LayerResult::Unhandled => unsafe {
14428 (dispatch_table.cmd_draw_indirect_count)(
14429 command_buffer,
14430 buffer,
14431 offset,
14432 count_buffer,
14433 count_buffer_offset,
14434 max_draw_count,
14435 stride,
14436 )
14437 },
14438 }
14439 }
14440 extern "system" fn cmd_draw_indexed_indirect_count(
14441 command_buffer: vk::CommandBuffer,
14442 buffer: vk::Buffer,
14443 offset: vk::DeviceSize,
14444 count_buffer: vk::Buffer,
14445 count_buffer_offset: vk::DeviceSize,
14446 max_draw_count: u32,
14447 stride: u32,
14448 ) {
14449 let global = Self::instance();
14450 let device_info = global.get_device_info(command_buffer).unwrap();
14452 let dispatch_table = &device_info.dispatch_table.core.fp_v1_2();
14453 let layer_result = device_info
14454 .customized_info
14455 .borrow()
14456 .hooks()
14457 .cmd_draw_indexed_indirect_count(
14458 command_buffer,
14459 buffer,
14460 offset,
14461 count_buffer,
14462 count_buffer_offset,
14463 max_draw_count,
14464 stride,
14465 );
14466 match layer_result {
14467 LayerResult::Handled(res) => res,
14468 LayerResult::Unhandled => unsafe {
14469 (dispatch_table.cmd_draw_indexed_indirect_count)(
14470 command_buffer,
14471 buffer,
14472 offset,
14473 count_buffer,
14474 count_buffer_offset,
14475 max_draw_count,
14476 stride,
14477 )
14478 },
14479 }
14480 }
14481 extern "system" fn create_render_pass2(
14482 device: vk::Device,
14483 p_create_info: *const vk::RenderPassCreateInfo2,
14484 p_allocator: *const vk::AllocationCallbacks,
14485 p_render_pass: *mut vk::RenderPass,
14486 ) -> vk::Result {
14487 let global = Self::instance();
14488 let device_info = global.get_device_info(device).unwrap();
14490 let dispatch_table = &device_info.dispatch_table.core.fp_v1_2();
14491 let layer_result = device_info
14492 .customized_info
14493 .borrow()
14494 .hooks()
14495 .create_render_pass2(unsafe { p_create_info.as_ref() }.unwrap(), unsafe {
14496 p_allocator.as_ref()
14497 });
14498 match layer_result {
14499 LayerResult::Handled(res) => match res {
14500 Ok(res) => {
14501 *unsafe { p_render_pass.as_mut() }.unwrap() = res;
14502 vk::Result::SUCCESS
14503 }
14504 Err(e) => e,
14505 },
14506 LayerResult::Unhandled => unsafe {
14507 (dispatch_table.create_render_pass2)(
14508 device,
14509 p_create_info,
14510 p_allocator,
14511 p_render_pass,
14512 )
14513 },
14514 }
14515 }
14516 extern "system" fn cmd_begin_render_pass2(
14517 command_buffer: vk::CommandBuffer,
14518 p_render_pass_begin: *const vk::RenderPassBeginInfo,
14519 p_subpass_begin_info: *const vk::SubpassBeginInfo,
14520 ) {
14521 let global = Self::instance();
14522 let device_info = global.get_device_info(command_buffer).unwrap();
14524 let dispatch_table = &device_info.dispatch_table.core.fp_v1_2();
14525 let layer_result = device_info
14526 .customized_info
14527 .borrow()
14528 .hooks()
14529 .cmd_begin_render_pass2(
14530 command_buffer,
14531 unsafe { p_render_pass_begin.as_ref() }.unwrap(),
14532 unsafe { p_subpass_begin_info.as_ref() }.unwrap(),
14533 );
14534 match layer_result {
14535 LayerResult::Handled(res) => res,
14536 LayerResult::Unhandled => unsafe {
14537 (dispatch_table.cmd_begin_render_pass2)(
14538 command_buffer,
14539 p_render_pass_begin,
14540 p_subpass_begin_info,
14541 )
14542 },
14543 }
14544 }
14545 extern "system" fn cmd_next_subpass2(
14546 command_buffer: vk::CommandBuffer,
14547 p_subpass_begin_info: *const vk::SubpassBeginInfo,
14548 p_subpass_end_info: *const vk::SubpassEndInfo,
14549 ) {
14550 let global = Self::instance();
14551 let device_info = global.get_device_info(command_buffer).unwrap();
14553 let dispatch_table = &device_info.dispatch_table.core.fp_v1_2();
14554 let layer_result = device_info
14555 .customized_info
14556 .borrow()
14557 .hooks()
14558 .cmd_next_subpass2(
14559 command_buffer,
14560 unsafe { p_subpass_begin_info.as_ref() }.unwrap(),
14561 unsafe { p_subpass_end_info.as_ref() }.unwrap(),
14562 );
14563 match layer_result {
14564 LayerResult::Handled(res) => res,
14565 LayerResult::Unhandled => unsafe {
14566 (dispatch_table.cmd_next_subpass2)(
14567 command_buffer,
14568 p_subpass_begin_info,
14569 p_subpass_end_info,
14570 )
14571 },
14572 }
14573 }
14574 extern "system" fn cmd_end_render_pass2(
14575 command_buffer: vk::CommandBuffer,
14576 p_subpass_end_info: *const vk::SubpassEndInfo,
14577 ) {
14578 let global = Self::instance();
14579 let device_info = global.get_device_info(command_buffer).unwrap();
14581 let dispatch_table = &device_info.dispatch_table.core.fp_v1_2();
14582 let layer_result = device_info
14583 .customized_info
14584 .borrow()
14585 .hooks()
14586 .cmd_end_render_pass2(
14587 command_buffer,
14588 unsafe { p_subpass_end_info.as_ref() }.unwrap(),
14589 );
14590 match layer_result {
14591 LayerResult::Handled(res) => res,
14592 LayerResult::Unhandled => unsafe {
14593 (dispatch_table.cmd_end_render_pass2)(command_buffer, p_subpass_end_info)
14594 },
14595 }
14596 }
14597 extern "system" fn reset_query_pool(
14598 device: vk::Device,
14599 query_pool: vk::QueryPool,
14600 first_query: u32,
14601 query_count: u32,
14602 ) {
14603 let global = Self::instance();
14604 let device_info = global.get_device_info(device).unwrap();
14606 let dispatch_table = &device_info.dispatch_table.core.fp_v1_2();
14607 let layer_result = device_info
14608 .customized_info
14609 .borrow()
14610 .hooks()
14611 .reset_query_pool(query_pool, first_query, query_count);
14612 match layer_result {
14613 LayerResult::Handled(res) => res,
14614 LayerResult::Unhandled => unsafe {
14615 (dispatch_table.reset_query_pool)(device, query_pool, first_query, query_count)
14616 },
14617 }
14618 }
14619 extern "system" fn get_semaphore_counter_value(
14620 device: vk::Device,
14621 semaphore: vk::Semaphore,
14622 p_value: *mut u64,
14623 ) -> vk::Result {
14624 let global = Self::instance();
14625 let device_info = global.get_device_info(device).unwrap();
14627 let dispatch_table = &device_info.dispatch_table.core.fp_v1_2();
14628 let layer_result = device_info
14629 .customized_info
14630 .borrow()
14631 .hooks()
14632 .get_semaphore_counter_value(semaphore);
14633 match layer_result {
14634 LayerResult::Handled(res) => match res {
14635 Ok(res) => {
14636 *unsafe { p_value.as_mut() }.unwrap() = res;
14637 vk::Result::SUCCESS
14638 }
14639 Err(e) => e,
14640 },
14641 LayerResult::Unhandled => unsafe {
14642 (dispatch_table.get_semaphore_counter_value)(device, semaphore, p_value)
14643 },
14644 }
14645 }
14646 extern "system" fn wait_semaphores(
14647 device: vk::Device,
14648 p_wait_info: *const vk::SemaphoreWaitInfo,
14649 timeout: u64,
14650 ) -> vk::Result {
14651 let global = Self::instance();
14652 let device_info = global.get_device_info(device).unwrap();
14654 let dispatch_table = &device_info.dispatch_table.core.fp_v1_2();
14655 let layer_result = device_info
14656 .customized_info
14657 .borrow()
14658 .hooks()
14659 .wait_semaphores(unsafe { p_wait_info.as_ref() }.unwrap(), timeout);
14660 match layer_result {
14661 LayerResult::Handled(res) => match res {
14662 Ok(()) => vk::Result::SUCCESS,
14663 Err(e) => e,
14664 },
14665 LayerResult::Unhandled => unsafe {
14666 (dispatch_table.wait_semaphores)(device, p_wait_info, timeout)
14667 },
14668 }
14669 }
14670 extern "system" fn signal_semaphore(
14671 device: vk::Device,
14672 p_signal_info: *const vk::SemaphoreSignalInfo,
14673 ) -> vk::Result {
14674 let global = Self::instance();
14675 let device_info = global.get_device_info(device).unwrap();
14677 let dispatch_table = &device_info.dispatch_table.core.fp_v1_2();
14678 let layer_result = device_info
14679 .customized_info
14680 .borrow()
14681 .hooks()
14682 .signal_semaphore(unsafe { p_signal_info.as_ref() }.unwrap());
14683 match layer_result {
14684 LayerResult::Handled(res) => match res {
14685 Ok(()) => vk::Result::SUCCESS,
14686 Err(e) => e,
14687 },
14688 LayerResult::Unhandled => unsafe {
14689 (dispatch_table.signal_semaphore)(device, p_signal_info)
14690 },
14691 }
14692 }
14693 extern "system" fn get_buffer_device_address(
14694 device: vk::Device,
14695 p_info: *const vk::BufferDeviceAddressInfo,
14696 ) -> vk::DeviceAddress {
14697 let global = Self::instance();
14698 let device_info = global.get_device_info(device).unwrap();
14700 let dispatch_table = &device_info.dispatch_table.core.fp_v1_2();
14701 let layer_result = device_info
14702 .customized_info
14703 .borrow()
14704 .hooks()
14705 .get_buffer_device_address(unsafe { p_info.as_ref() }.unwrap());
14706 match layer_result {
14707 LayerResult::Handled(res) => res,
14708 LayerResult::Unhandled => unsafe {
14709 (dispatch_table.get_buffer_device_address)(device, p_info)
14710 },
14711 }
14712 }
14713 extern "system" fn get_buffer_opaque_capture_address(
14714 device: vk::Device,
14715 p_info: *const vk::BufferDeviceAddressInfo,
14716 ) -> u64 {
14717 let global = Self::instance();
14718 let device_info = global.get_device_info(device).unwrap();
14720 let dispatch_table = &device_info.dispatch_table.core.fp_v1_2();
14721 let layer_result = device_info
14722 .customized_info
14723 .borrow()
14724 .hooks()
14725 .get_buffer_opaque_capture_address(unsafe { p_info.as_ref() }.unwrap());
14726 match layer_result {
14727 LayerResult::Handled(res) => res,
14728 LayerResult::Unhandled => unsafe {
14729 (dispatch_table.get_buffer_opaque_capture_address)(device, p_info)
14730 },
14731 }
14732 }
14733 extern "system" fn get_device_memory_opaque_capture_address(
14734 device: vk::Device,
14735 p_info: *const vk::DeviceMemoryOpaqueCaptureAddressInfo,
14736 ) -> u64 {
14737 let global = Self::instance();
14738 let device_info = global.get_device_info(device).unwrap();
14740 let dispatch_table = &device_info.dispatch_table.core.fp_v1_2();
14741 let layer_result = device_info
14742 .customized_info
14743 .borrow()
14744 .hooks()
14745 .get_device_memory_opaque_capture_address(unsafe { p_info.as_ref() }.unwrap());
14746 match layer_result {
14747 LayerResult::Handled(res) => res,
14748 LayerResult::Unhandled => unsafe {
14749 (dispatch_table.get_device_memory_opaque_capture_address)(device, p_info)
14750 },
14751 }
14752 }
14753 extern "system" fn create_private_data_slot(
14754 device: vk::Device,
14755 p_create_info: *const vk::PrivateDataSlotCreateInfo,
14756 p_allocator: *const vk::AllocationCallbacks,
14757 p_private_data_slot: *mut vk::PrivateDataSlot,
14758 ) -> vk::Result {
14759 let global = Self::instance();
14760 let device_info = global.get_device_info(device).unwrap();
14762 let dispatch_table = &device_info.dispatch_table.core.fp_v1_3();
14763 let layer_result = device_info
14764 .customized_info
14765 .borrow()
14766 .hooks()
14767 .create_private_data_slot(unsafe { p_create_info.as_ref() }.unwrap(), unsafe {
14768 p_allocator.as_ref()
14769 });
14770 match layer_result {
14771 LayerResult::Handled(res) => match res {
14772 Ok(res) => {
14773 *unsafe { p_private_data_slot.as_mut() }.unwrap() = res;
14774 vk::Result::SUCCESS
14775 }
14776 Err(e) => e,
14777 },
14778 LayerResult::Unhandled => unsafe {
14779 (dispatch_table.create_private_data_slot)(
14780 device,
14781 p_create_info,
14782 p_allocator,
14783 p_private_data_slot,
14784 )
14785 },
14786 }
14787 }
14788 extern "system" fn destroy_private_data_slot(
14789 device: vk::Device,
14790 private_data_slot: vk::PrivateDataSlot,
14791 p_allocator: *const vk::AllocationCallbacks,
14792 ) {
14793 let global = Self::instance();
14794 let device_info = global.get_device_info(device).unwrap();
14796 let dispatch_table = &device_info.dispatch_table.core.fp_v1_3();
14797 let layer_result = device_info
14798 .customized_info
14799 .borrow()
14800 .hooks()
14801 .destroy_private_data_slot(private_data_slot, unsafe { p_allocator.as_ref() });
14802 match layer_result {
14803 LayerResult::Handled(res) => res,
14804 LayerResult::Unhandled => unsafe {
14805 (dispatch_table.destroy_private_data_slot)(device, private_data_slot, p_allocator)
14806 },
14807 }
14808 }
14809 extern "system" fn set_private_data(
14810 device: vk::Device,
14811 object_type: vk::ObjectType,
14812 object_handle: u64,
14813 private_data_slot: vk::PrivateDataSlot,
14814 data: u64,
14815 ) -> vk::Result {
14816 let global = Self::instance();
14817 let device_info = global.get_device_info(device).unwrap();
14819 let dispatch_table = &device_info.dispatch_table.core.fp_v1_3();
14820 let layer_result = device_info
14821 .customized_info
14822 .borrow()
14823 .hooks()
14824 .set_private_data(object_type, object_handle, private_data_slot, data);
14825 match layer_result {
14826 LayerResult::Handled(res) => match res {
14827 Ok(()) => vk::Result::SUCCESS,
14828 Err(e) => e,
14829 },
14830 LayerResult::Unhandled => unsafe {
14831 (dispatch_table.set_private_data)(
14832 device,
14833 object_type,
14834 object_handle,
14835 private_data_slot,
14836 data,
14837 )
14838 },
14839 }
14840 }
14841 extern "system" fn get_private_data(
14842 device: vk::Device,
14843 object_type: vk::ObjectType,
14844 object_handle: u64,
14845 private_data_slot: vk::PrivateDataSlot,
14846 p_data: *mut u64,
14847 ) {
14848 let global = Self::instance();
14849 let device_info = global.get_device_info(device).unwrap();
14851 let dispatch_table = &device_info.dispatch_table.core.fp_v1_3();
14852 let layer_result = device_info
14853 .customized_info
14854 .borrow()
14855 .hooks()
14856 .get_private_data(object_type, object_handle, private_data_slot);
14857 match layer_result {
14858 LayerResult::Handled(res) => {
14859 *unsafe { p_data.as_mut() }.unwrap() = res;
14860 }
14861 LayerResult::Unhandled => unsafe {
14862 (dispatch_table.get_private_data)(
14863 device,
14864 object_type,
14865 object_handle,
14866 private_data_slot,
14867 p_data,
14868 )
14869 },
14870 }
14871 }
14872 extern "system" fn cmd_set_event2(
14873 command_buffer: vk::CommandBuffer,
14874 event: vk::Event,
14875 p_dependency_info: *const vk::DependencyInfo,
14876 ) {
14877 let global = Self::instance();
14878 let device_info = global.get_device_info(command_buffer).unwrap();
14880 let dispatch_table = &device_info.dispatch_table.core.fp_v1_3();
14881 let layer_result = device_info.customized_info.borrow().hooks().cmd_set_event2(
14882 command_buffer,
14883 event,
14884 unsafe { p_dependency_info.as_ref() }.unwrap(),
14885 );
14886 match layer_result {
14887 LayerResult::Handled(res) => res,
14888 LayerResult::Unhandled => unsafe {
14889 (dispatch_table.cmd_set_event2)(command_buffer, event, p_dependency_info)
14890 },
14891 }
14892 }
14893 extern "system" fn cmd_reset_event2(
14894 command_buffer: vk::CommandBuffer,
14895 event: vk::Event,
14896 stage_mask: vk::PipelineStageFlags2,
14897 ) {
14898 let global = Self::instance();
14899 let device_info = global.get_device_info(command_buffer).unwrap();
14901 let dispatch_table = &device_info.dispatch_table.core.fp_v1_3();
14902 let layer_result = device_info
14903 .customized_info
14904 .borrow()
14905 .hooks()
14906 .cmd_reset_event2(command_buffer, event, stage_mask);
14907 match layer_result {
14908 LayerResult::Handled(res) => res,
14909 LayerResult::Unhandled => unsafe {
14910 (dispatch_table.cmd_reset_event2)(command_buffer, event, stage_mask)
14911 },
14912 }
14913 }
14914 extern "system" fn cmd_wait_events2(
14915 command_buffer: vk::CommandBuffer,
14916 event_count: u32,
14917 p_events: *const vk::Event,
14918 p_dependency_infos: *const vk::DependencyInfo,
14919 ) {
14920 let global = Self::instance();
14921 let device_info = global.get_device_info(command_buffer).unwrap();
14923 let dispatch_table = &device_info.dispatch_table.core.fp_v1_3();
14924 let layer_result = device_info
14925 .customized_info
14926 .borrow()
14927 .hooks()
14928 .cmd_wait_events2(
14929 command_buffer,
14930 unsafe { slice_from_raw_parts(p_events, event_count) },
14931 unsafe { slice_from_raw_parts(p_dependency_infos, event_count) },
14932 );
14933 match layer_result {
14934 LayerResult::Handled(res) => res,
14935 LayerResult::Unhandled => unsafe {
14936 (dispatch_table.cmd_wait_events2)(
14937 command_buffer,
14938 event_count,
14939 p_events,
14940 p_dependency_infos,
14941 )
14942 },
14943 }
14944 }
14945 extern "system" fn cmd_pipeline_barrier2(
14946 command_buffer: vk::CommandBuffer,
14947 p_dependency_info: *const vk::DependencyInfo,
14948 ) {
14949 let global = Self::instance();
14950 let device_info = global.get_device_info(command_buffer).unwrap();
14952 let dispatch_table = &device_info.dispatch_table.core.fp_v1_3();
14953 let layer_result = device_info
14954 .customized_info
14955 .borrow()
14956 .hooks()
14957 .cmd_pipeline_barrier2(
14958 command_buffer,
14959 unsafe { p_dependency_info.as_ref() }.unwrap(),
14960 );
14961 match layer_result {
14962 LayerResult::Handled(res) => res,
14963 LayerResult::Unhandled => unsafe {
14964 (dispatch_table.cmd_pipeline_barrier2)(command_buffer, p_dependency_info)
14965 },
14966 }
14967 }
14968 extern "system" fn cmd_write_timestamp2(
14969 command_buffer: vk::CommandBuffer,
14970 stage: vk::PipelineStageFlags2,
14971 query_pool: vk::QueryPool,
14972 query: u32,
14973 ) {
14974 let global = Self::instance();
14975 let device_info = global.get_device_info(command_buffer).unwrap();
14977 let dispatch_table = &device_info.dispatch_table.core.fp_v1_3();
14978 let layer_result = device_info
14979 .customized_info
14980 .borrow()
14981 .hooks()
14982 .cmd_write_timestamp2(command_buffer, stage, query_pool, query);
14983 match layer_result {
14984 LayerResult::Handled(res) => res,
14985 LayerResult::Unhandled => unsafe {
14986 (dispatch_table.cmd_write_timestamp2)(command_buffer, stage, query_pool, query)
14987 },
14988 }
14989 }
14990 extern "system" fn queue_submit2(
14991 queue: vk::Queue,
14992 submit_count: u32,
14993 p_submits: *const vk::SubmitInfo2,
14994 fence: vk::Fence,
14995 ) -> vk::Result {
14996 let global = Self::instance();
14997 let device_info = global.get_device_info(queue).unwrap();
14999 let dispatch_table = &device_info.dispatch_table.core.fp_v1_3();
15000 let layer_result = device_info.customized_info.borrow().hooks().queue_submit2(
15001 queue,
15002 unsafe { slice_from_raw_parts(p_submits, submit_count) },
15003 fence,
15004 );
15005 match layer_result {
15006 LayerResult::Handled(res) => match res {
15007 Ok(()) => vk::Result::SUCCESS,
15008 Err(e) => e,
15009 },
15010 LayerResult::Unhandled => unsafe {
15011 (dispatch_table.queue_submit2)(queue, submit_count, p_submits, fence)
15012 },
15013 }
15014 }
15015 extern "system" fn cmd_copy_buffer2(
15016 command_buffer: vk::CommandBuffer,
15017 p_copy_buffer_info: *const vk::CopyBufferInfo2,
15018 ) {
15019 let global = Self::instance();
15020 let device_info = global.get_device_info(command_buffer).unwrap();
15022 let dispatch_table = &device_info.dispatch_table.core.fp_v1_3();
15023 let layer_result = device_info
15024 .customized_info
15025 .borrow()
15026 .hooks()
15027 .cmd_copy_buffer2(
15028 command_buffer,
15029 unsafe { p_copy_buffer_info.as_ref() }.unwrap(),
15030 );
15031 match layer_result {
15032 LayerResult::Handled(res) => res,
15033 LayerResult::Unhandled => unsafe {
15034 (dispatch_table.cmd_copy_buffer2)(command_buffer, p_copy_buffer_info)
15035 },
15036 }
15037 }
15038 extern "system" fn cmd_copy_image2(
15039 command_buffer: vk::CommandBuffer,
15040 p_copy_image_info: *const vk::CopyImageInfo2,
15041 ) {
15042 let global = Self::instance();
15043 let device_info = global.get_device_info(command_buffer).unwrap();
15045 let dispatch_table = &device_info.dispatch_table.core.fp_v1_3();
15046 let layer_result = device_info
15047 .customized_info
15048 .borrow()
15049 .hooks()
15050 .cmd_copy_image2(
15051 command_buffer,
15052 unsafe { p_copy_image_info.as_ref() }.unwrap(),
15053 );
15054 match layer_result {
15055 LayerResult::Handled(res) => res,
15056 LayerResult::Unhandled => unsafe {
15057 (dispatch_table.cmd_copy_image2)(command_buffer, p_copy_image_info)
15058 },
15059 }
15060 }
15061 extern "system" fn cmd_copy_buffer_to_image2(
15062 command_buffer: vk::CommandBuffer,
15063 p_copy_buffer_to_image_info: *const vk::CopyBufferToImageInfo2,
15064 ) {
15065 let global = Self::instance();
15066 let device_info = global.get_device_info(command_buffer).unwrap();
15068 let dispatch_table = &device_info.dispatch_table.core.fp_v1_3();
15069 let layer_result = device_info
15070 .customized_info
15071 .borrow()
15072 .hooks()
15073 .cmd_copy_buffer_to_image2(
15074 command_buffer,
15075 unsafe { p_copy_buffer_to_image_info.as_ref() }.unwrap(),
15076 );
15077 match layer_result {
15078 LayerResult::Handled(res) => res,
15079 LayerResult::Unhandled => unsafe {
15080 (dispatch_table.cmd_copy_buffer_to_image2)(
15081 command_buffer,
15082 p_copy_buffer_to_image_info,
15083 )
15084 },
15085 }
15086 }
15087 extern "system" fn cmd_copy_image_to_buffer2(
15088 command_buffer: vk::CommandBuffer,
15089 p_copy_image_to_buffer_info: *const vk::CopyImageToBufferInfo2,
15090 ) {
15091 let global = Self::instance();
15092 let device_info = global.get_device_info(command_buffer).unwrap();
15094 let dispatch_table = &device_info.dispatch_table.core.fp_v1_3();
15095 let layer_result = device_info
15096 .customized_info
15097 .borrow()
15098 .hooks()
15099 .cmd_copy_image_to_buffer2(
15100 command_buffer,
15101 unsafe { p_copy_image_to_buffer_info.as_ref() }.unwrap(),
15102 );
15103 match layer_result {
15104 LayerResult::Handled(res) => res,
15105 LayerResult::Unhandled => unsafe {
15106 (dispatch_table.cmd_copy_image_to_buffer2)(
15107 command_buffer,
15108 p_copy_image_to_buffer_info,
15109 )
15110 },
15111 }
15112 }
15113 extern "system" fn cmd_blit_image2(
15114 command_buffer: vk::CommandBuffer,
15115 p_blit_image_info: *const vk::BlitImageInfo2,
15116 ) {
15117 let global = Self::instance();
15118 let device_info = global.get_device_info(command_buffer).unwrap();
15120 let dispatch_table = &device_info.dispatch_table.core.fp_v1_3();
15121 let layer_result = device_info
15122 .customized_info
15123 .borrow()
15124 .hooks()
15125 .cmd_blit_image2(
15126 command_buffer,
15127 unsafe { p_blit_image_info.as_ref() }.unwrap(),
15128 );
15129 match layer_result {
15130 LayerResult::Handled(res) => res,
15131 LayerResult::Unhandled => unsafe {
15132 (dispatch_table.cmd_blit_image2)(command_buffer, p_blit_image_info)
15133 },
15134 }
15135 }
15136 extern "system" fn cmd_resolve_image2(
15137 command_buffer: vk::CommandBuffer,
15138 p_resolve_image_info: *const vk::ResolveImageInfo2,
15139 ) {
15140 let global = Self::instance();
15141 let device_info = global.get_device_info(command_buffer).unwrap();
15143 let dispatch_table = &device_info.dispatch_table.core.fp_v1_3();
15144 let layer_result = device_info
15145 .customized_info
15146 .borrow()
15147 .hooks()
15148 .cmd_resolve_image2(
15149 command_buffer,
15150 unsafe { p_resolve_image_info.as_ref() }.unwrap(),
15151 );
15152 match layer_result {
15153 LayerResult::Handled(res) => res,
15154 LayerResult::Unhandled => unsafe {
15155 (dispatch_table.cmd_resolve_image2)(command_buffer, p_resolve_image_info)
15156 },
15157 }
15158 }
15159 extern "system" fn cmd_begin_rendering(
15160 command_buffer: vk::CommandBuffer,
15161 p_rendering_info: *const vk::RenderingInfo,
15162 ) {
15163 let global = Self::instance();
15164 let device_info = global.get_device_info(command_buffer).unwrap();
15166 let dispatch_table = &device_info.dispatch_table.core.fp_v1_3();
15167 let layer_result = device_info
15168 .customized_info
15169 .borrow()
15170 .hooks()
15171 .cmd_begin_rendering(
15172 command_buffer,
15173 unsafe { p_rendering_info.as_ref() }.unwrap(),
15174 );
15175 match layer_result {
15176 LayerResult::Handled(res) => res,
15177 LayerResult::Unhandled => unsafe {
15178 (dispatch_table.cmd_begin_rendering)(command_buffer, p_rendering_info)
15179 },
15180 }
15181 }
15182 extern "system" fn cmd_end_rendering(command_buffer: vk::CommandBuffer) {
15183 let global = Self::instance();
15184 let device_info = global.get_device_info(command_buffer).unwrap();
15186 let dispatch_table = &device_info.dispatch_table.core.fp_v1_3();
15187 let layer_result = device_info
15188 .customized_info
15189 .borrow()
15190 .hooks()
15191 .cmd_end_rendering(command_buffer);
15192 match layer_result {
15193 LayerResult::Handled(res) => res,
15194 LayerResult::Unhandled => unsafe { (dispatch_table.cmd_end_rendering)(command_buffer) },
15195 }
15196 }
15197 extern "system" fn cmd_set_cull_mode(
15198 command_buffer: vk::CommandBuffer,
15199 cull_mode: vk::CullModeFlags,
15200 ) {
15201 let global = Self::instance();
15202 let device_info = global.get_device_info(command_buffer).unwrap();
15204 let dispatch_table = &device_info.dispatch_table.core.fp_v1_3();
15205 let layer_result = device_info
15206 .customized_info
15207 .borrow()
15208 .hooks()
15209 .cmd_set_cull_mode(command_buffer, cull_mode);
15210 match layer_result {
15211 LayerResult::Handled(res) => res,
15212 LayerResult::Unhandled => unsafe {
15213 (dispatch_table.cmd_set_cull_mode)(command_buffer, cull_mode)
15214 },
15215 }
15216 }
15217 extern "system" fn cmd_set_front_face(
15218 command_buffer: vk::CommandBuffer,
15219 front_face: vk::FrontFace,
15220 ) {
15221 let global = Self::instance();
15222 let device_info = global.get_device_info(command_buffer).unwrap();
15224 let dispatch_table = &device_info.dispatch_table.core.fp_v1_3();
15225 let layer_result = device_info
15226 .customized_info
15227 .borrow()
15228 .hooks()
15229 .cmd_set_front_face(command_buffer, front_face);
15230 match layer_result {
15231 LayerResult::Handled(res) => res,
15232 LayerResult::Unhandled => unsafe {
15233 (dispatch_table.cmd_set_front_face)(command_buffer, front_face)
15234 },
15235 }
15236 }
15237 extern "system" fn cmd_set_primitive_topology(
15238 command_buffer: vk::CommandBuffer,
15239 primitive_topology: vk::PrimitiveTopology,
15240 ) {
15241 let global = Self::instance();
15242 let device_info = global.get_device_info(command_buffer).unwrap();
15244 let dispatch_table = &device_info.dispatch_table.core.fp_v1_3();
15245 let layer_result = device_info
15246 .customized_info
15247 .borrow()
15248 .hooks()
15249 .cmd_set_primitive_topology(command_buffer, primitive_topology);
15250 match layer_result {
15251 LayerResult::Handled(res) => res,
15252 LayerResult::Unhandled => unsafe {
15253 (dispatch_table.cmd_set_primitive_topology)(command_buffer, primitive_topology)
15254 },
15255 }
15256 }
15257 extern "system" fn cmd_set_viewport_with_count(
15258 command_buffer: vk::CommandBuffer,
15259 viewport_count: u32,
15260 p_viewports: *const vk::Viewport,
15261 ) {
15262 let global = Self::instance();
15263 let device_info = global.get_device_info(command_buffer).unwrap();
15265 let dispatch_table = &device_info.dispatch_table.core.fp_v1_3();
15266 let layer_result = device_info
15267 .customized_info
15268 .borrow()
15269 .hooks()
15270 .cmd_set_viewport_with_count(command_buffer, unsafe {
15271 slice_from_raw_parts(p_viewports, viewport_count)
15272 });
15273 match layer_result {
15274 LayerResult::Handled(res) => res,
15275 LayerResult::Unhandled => unsafe {
15276 (dispatch_table.cmd_set_viewport_with_count)(
15277 command_buffer,
15278 viewport_count,
15279 p_viewports,
15280 )
15281 },
15282 }
15283 }
15284 extern "system" fn cmd_set_scissor_with_count(
15285 command_buffer: vk::CommandBuffer,
15286 scissor_count: u32,
15287 p_scissors: *const vk::Rect2D,
15288 ) {
15289 let global = Self::instance();
15290 let device_info = global.get_device_info(command_buffer).unwrap();
15292 let dispatch_table = &device_info.dispatch_table.core.fp_v1_3();
15293 let layer_result = device_info
15294 .customized_info
15295 .borrow()
15296 .hooks()
15297 .cmd_set_scissor_with_count(command_buffer, unsafe {
15298 slice_from_raw_parts(p_scissors, scissor_count)
15299 });
15300 match layer_result {
15301 LayerResult::Handled(res) => res,
15302 LayerResult::Unhandled => unsafe {
15303 (dispatch_table.cmd_set_scissor_with_count)(
15304 command_buffer,
15305 scissor_count,
15306 p_scissors,
15307 )
15308 },
15309 }
15310 }
15311 extern "system" fn cmd_bind_vertex_buffers2(
15312 command_buffer: vk::CommandBuffer,
15313 first_binding: u32,
15314 binding_count: u32,
15315 p_buffers: *const vk::Buffer,
15316 p_offsets: *const vk::DeviceSize,
15317 p_sizes: *const vk::DeviceSize,
15318 p_strides: *const vk::DeviceSize,
15319 ) {
15320 let global = Self::instance();
15321 let device_info = global.get_device_info(command_buffer).unwrap();
15323 let dispatch_table = &device_info.dispatch_table.core.fp_v1_3();
15324 let layer_result = device_info
15325 .customized_info
15326 .borrow()
15327 .hooks()
15328 .cmd_bind_vertex_buffers2(
15329 command_buffer,
15330 first_binding,
15331 unsafe { slice_from_raw_parts(p_buffers, binding_count) },
15332 unsafe { slice_from_raw_parts(p_offsets, binding_count) },
15333 unsafe { maybe_slice_from_raw_parts(p_sizes, binding_count) },
15334 unsafe { maybe_slice_from_raw_parts(p_strides, binding_count) },
15335 );
15336 match layer_result {
15337 LayerResult::Handled(res) => res,
15338 LayerResult::Unhandled => unsafe {
15339 (dispatch_table.cmd_bind_vertex_buffers2)(
15340 command_buffer,
15341 first_binding,
15342 binding_count,
15343 p_buffers,
15344 p_offsets,
15345 p_sizes,
15346 p_strides,
15347 )
15348 },
15349 }
15350 }
15351 extern "system" fn cmd_set_depth_test_enable(
15352 command_buffer: vk::CommandBuffer,
15353 depth_test_enable: vk::Bool32,
15354 ) {
15355 let global = Self::instance();
15356 let device_info = global.get_device_info(command_buffer).unwrap();
15358 let dispatch_table = &device_info.dispatch_table.core.fp_v1_3();
15359 let layer_result = device_info
15360 .customized_info
15361 .borrow()
15362 .hooks()
15363 .cmd_set_depth_test_enable(command_buffer, depth_test_enable == vk::TRUE);
15364 match layer_result {
15365 LayerResult::Handled(res) => res,
15366 LayerResult::Unhandled => unsafe {
15367 (dispatch_table.cmd_set_depth_test_enable)(command_buffer, depth_test_enable)
15368 },
15369 }
15370 }
15371 extern "system" fn cmd_set_depth_write_enable(
15372 command_buffer: vk::CommandBuffer,
15373 depth_write_enable: vk::Bool32,
15374 ) {
15375 let global = Self::instance();
15376 let device_info = global.get_device_info(command_buffer).unwrap();
15378 let dispatch_table = &device_info.dispatch_table.core.fp_v1_3();
15379 let layer_result = device_info
15380 .customized_info
15381 .borrow()
15382 .hooks()
15383 .cmd_set_depth_write_enable(command_buffer, depth_write_enable == vk::TRUE);
15384 match layer_result {
15385 LayerResult::Handled(res) => res,
15386 LayerResult::Unhandled => unsafe {
15387 (dispatch_table.cmd_set_depth_write_enable)(command_buffer, depth_write_enable)
15388 },
15389 }
15390 }
15391 extern "system" fn cmd_set_depth_compare_op(
15392 command_buffer: vk::CommandBuffer,
15393 depth_compare_op: vk::CompareOp,
15394 ) {
15395 let global = Self::instance();
15396 let device_info = global.get_device_info(command_buffer).unwrap();
15398 let dispatch_table = &device_info.dispatch_table.core.fp_v1_3();
15399 let layer_result = device_info
15400 .customized_info
15401 .borrow()
15402 .hooks()
15403 .cmd_set_depth_compare_op(command_buffer, depth_compare_op);
15404 match layer_result {
15405 LayerResult::Handled(res) => res,
15406 LayerResult::Unhandled => unsafe {
15407 (dispatch_table.cmd_set_depth_compare_op)(command_buffer, depth_compare_op)
15408 },
15409 }
15410 }
15411 extern "system" fn cmd_set_depth_bounds_test_enable(
15412 command_buffer: vk::CommandBuffer,
15413 depth_bounds_test_enable: vk::Bool32,
15414 ) {
15415 let global = Self::instance();
15416 let device_info = global.get_device_info(command_buffer).unwrap();
15418 let dispatch_table = &device_info.dispatch_table.core.fp_v1_3();
15419 let layer_result = device_info
15420 .customized_info
15421 .borrow()
15422 .hooks()
15423 .cmd_set_depth_bounds_test_enable(command_buffer, depth_bounds_test_enable == vk::TRUE);
15424 match layer_result {
15425 LayerResult::Handled(res) => res,
15426 LayerResult::Unhandled => unsafe {
15427 (dispatch_table.cmd_set_depth_bounds_test_enable)(
15428 command_buffer,
15429 depth_bounds_test_enable,
15430 )
15431 },
15432 }
15433 }
15434 extern "system" fn cmd_set_stencil_test_enable(
15435 command_buffer: vk::CommandBuffer,
15436 stencil_test_enable: vk::Bool32,
15437 ) {
15438 let global = Self::instance();
15439 let device_info = global.get_device_info(command_buffer).unwrap();
15441 let dispatch_table = &device_info.dispatch_table.core.fp_v1_3();
15442 let layer_result = device_info
15443 .customized_info
15444 .borrow()
15445 .hooks()
15446 .cmd_set_stencil_test_enable(command_buffer, stencil_test_enable == vk::TRUE);
15447 match layer_result {
15448 LayerResult::Handled(res) => res,
15449 LayerResult::Unhandled => unsafe {
15450 (dispatch_table.cmd_set_stencil_test_enable)(command_buffer, stencil_test_enable)
15451 },
15452 }
15453 }
15454 extern "system" fn cmd_set_stencil_op(
15455 command_buffer: vk::CommandBuffer,
15456 face_mask: vk::StencilFaceFlags,
15457 fail_op: vk::StencilOp,
15458 pass_op: vk::StencilOp,
15459 depth_fail_op: vk::StencilOp,
15460 compare_op: vk::CompareOp,
15461 ) {
15462 let global = Self::instance();
15463 let device_info = global.get_device_info(command_buffer).unwrap();
15465 let dispatch_table = &device_info.dispatch_table.core.fp_v1_3();
15466 let layer_result = device_info
15467 .customized_info
15468 .borrow()
15469 .hooks()
15470 .cmd_set_stencil_op(
15471 command_buffer,
15472 face_mask,
15473 fail_op,
15474 pass_op,
15475 depth_fail_op,
15476 compare_op,
15477 );
15478 match layer_result {
15479 LayerResult::Handled(res) => res,
15480 LayerResult::Unhandled => unsafe {
15481 (dispatch_table.cmd_set_stencil_op)(
15482 command_buffer,
15483 face_mask,
15484 fail_op,
15485 pass_op,
15486 depth_fail_op,
15487 compare_op,
15488 )
15489 },
15490 }
15491 }
15492 extern "system" fn cmd_set_rasterizer_discard_enable(
15493 command_buffer: vk::CommandBuffer,
15494 rasterizer_discard_enable: vk::Bool32,
15495 ) {
15496 let global = Self::instance();
15497 let device_info = global.get_device_info(command_buffer).unwrap();
15499 let dispatch_table = &device_info.dispatch_table.core.fp_v1_3();
15500 let layer_result = device_info
15501 .customized_info
15502 .borrow()
15503 .hooks()
15504 .cmd_set_rasterizer_discard_enable(
15505 command_buffer,
15506 rasterizer_discard_enable == vk::TRUE,
15507 );
15508 match layer_result {
15509 LayerResult::Handled(res) => res,
15510 LayerResult::Unhandled => unsafe {
15511 (dispatch_table.cmd_set_rasterizer_discard_enable)(
15512 command_buffer,
15513 rasterizer_discard_enable,
15514 )
15515 },
15516 }
15517 }
15518 extern "system" fn cmd_set_depth_bias_enable(
15519 command_buffer: vk::CommandBuffer,
15520 depth_bias_enable: vk::Bool32,
15521 ) {
15522 let global = Self::instance();
15523 let device_info = global.get_device_info(command_buffer).unwrap();
15525 let dispatch_table = &device_info.dispatch_table.core.fp_v1_3();
15526 let layer_result = device_info
15527 .customized_info
15528 .borrow()
15529 .hooks()
15530 .cmd_set_depth_bias_enable(command_buffer, depth_bias_enable == vk::TRUE);
15531 match layer_result {
15532 LayerResult::Handled(res) => res,
15533 LayerResult::Unhandled => unsafe {
15534 (dispatch_table.cmd_set_depth_bias_enable)(command_buffer, depth_bias_enable)
15535 },
15536 }
15537 }
15538 extern "system" fn cmd_set_primitive_restart_enable(
15539 command_buffer: vk::CommandBuffer,
15540 primitive_restart_enable: vk::Bool32,
15541 ) {
15542 let global = Self::instance();
15543 let device_info = global.get_device_info(command_buffer).unwrap();
15545 let dispatch_table = &device_info.dispatch_table.core.fp_v1_3();
15546 let layer_result = device_info
15547 .customized_info
15548 .borrow()
15549 .hooks()
15550 .cmd_set_primitive_restart_enable(command_buffer, primitive_restart_enable == vk::TRUE);
15551 match layer_result {
15552 LayerResult::Handled(res) => res,
15553 LayerResult::Unhandled => unsafe {
15554 (dispatch_table.cmd_set_primitive_restart_enable)(
15555 command_buffer,
15556 primitive_restart_enable,
15557 )
15558 },
15559 }
15560 }
15561 extern "system" fn get_device_buffer_memory_requirements(
15562 device: vk::Device,
15563 p_info: *const vk::DeviceBufferMemoryRequirements,
15564 p_memory_requirements: *mut vk::MemoryRequirements2,
15565 ) {
15566 let global = Self::instance();
15567 let device_info = global.get_device_info(device).unwrap();
15569 let dispatch_table = &device_info.dispatch_table.core.fp_v1_3();
15570 let layer_result = device_info
15571 .customized_info
15572 .borrow()
15573 .hooks()
15574 .get_device_buffer_memory_requirements(
15575 unsafe { p_info.as_ref() }.unwrap(),
15576 unsafe { ptr_as_uninit_mut(p_memory_requirements) }.unwrap(),
15577 );
15578 match layer_result {
15579 LayerResult::Handled(res) => res,
15580 LayerResult::Unhandled => unsafe {
15581 (dispatch_table.get_device_buffer_memory_requirements)(
15582 device,
15583 p_info,
15584 p_memory_requirements,
15585 )
15586 },
15587 }
15588 }
15589 extern "system" fn get_device_image_memory_requirements(
15590 device: vk::Device,
15591 p_info: *const vk::DeviceImageMemoryRequirements,
15592 p_memory_requirements: *mut vk::MemoryRequirements2,
15593 ) {
15594 let global = Self::instance();
15595 let device_info = global.get_device_info(device).unwrap();
15597 let dispatch_table = &device_info.dispatch_table.core.fp_v1_3();
15598 let layer_result = device_info
15599 .customized_info
15600 .borrow()
15601 .hooks()
15602 .get_device_image_memory_requirements(
15603 unsafe { p_info.as_ref() }.unwrap(),
15604 unsafe { ptr_as_uninit_mut(p_memory_requirements) }.unwrap(),
15605 );
15606 match layer_result {
15607 LayerResult::Handled(res) => res,
15608 LayerResult::Unhandled => unsafe {
15609 (dispatch_table.get_device_image_memory_requirements)(
15610 device,
15611 p_info,
15612 p_memory_requirements,
15613 )
15614 },
15615 }
15616 }
15617 extern "system" fn get_device_image_sparse_memory_requirements(
15618 device: vk::Device,
15619 p_info: *const vk::DeviceImageMemoryRequirements,
15620 p_sparse_memory_requirement_count: *mut u32,
15621 p_sparse_memory_requirements: *mut vk::SparseImageMemoryRequirements2,
15622 ) {
15623 let global = Self::instance();
15624 let device_info = global.get_device_info(device).unwrap();
15626 let dispatch_table = &device_info.dispatch_table.core.fp_v1_3();
15627 let layer_result = device_info
15628 .customized_info
15629 .borrow()
15630 .hooks()
15631 .get_device_image_sparse_memory_requirements(
15632 unsafe { p_info.as_ref() }.unwrap(),
15633 unsafe { ptr_as_uninit_mut(p_sparse_memory_requirement_count) }.unwrap(),
15634 unsafe {
15635 maybe_uninit_slice_from_raw_parts_mut(
15636 p_sparse_memory_requirements,
15637 p_sparse_memory_requirement_count,
15638 )
15639 },
15640 );
15641 match layer_result {
15642 LayerResult::Handled(res) => res,
15643 LayerResult::Unhandled => unsafe {
15644 (dispatch_table.get_device_image_sparse_memory_requirements)(
15645 device,
15646 p_info,
15647 p_sparse_memory_requirement_count,
15648 p_sparse_memory_requirements,
15649 )
15650 },
15651 }
15652 }
15653 extern "system" fn create_swapchain_khr(
15654 device: vk::Device,
15655 p_create_info: *const vk::SwapchainCreateInfoKHR,
15656 p_allocator: *const vk::AllocationCallbacks,
15657 p_swapchain: *mut vk::SwapchainKHR,
15658 ) -> vk::Result {
15659 let global = Self::instance();
15660 let device_info = global.get_device_info(device).unwrap();
15662 let dispatch_table = &device_info.dispatch_table.khr_swapchain;
15663 let layer_result = device_info
15664 .customized_info
15665 .borrow()
15666 .hooks()
15667 .create_swapchain_khr(unsafe { p_create_info.as_ref() }.unwrap(), unsafe {
15668 p_allocator.as_ref()
15669 });
15670 match layer_result {
15671 LayerResult::Handled(res) => match res {
15672 Ok(res) => {
15673 *unsafe { p_swapchain.as_mut() }.unwrap() = res;
15674 vk::Result::SUCCESS
15675 }
15676 Err(e) => e,
15677 },
15678 LayerResult::Unhandled => unsafe {
15679 (dispatch_table.create_swapchain_khr)(
15680 device,
15681 p_create_info,
15682 p_allocator,
15683 p_swapchain,
15684 )
15685 },
15686 }
15687 }
15688 extern "system" fn destroy_swapchain_khr(
15689 device: vk::Device,
15690 swapchain: vk::SwapchainKHR,
15691 p_allocator: *const vk::AllocationCallbacks,
15692 ) {
15693 let global = Self::instance();
15694 let device_info = global.get_device_info(device).unwrap();
15696 let dispatch_table = &device_info.dispatch_table.khr_swapchain;
15697 let layer_result = device_info
15698 .customized_info
15699 .borrow()
15700 .hooks()
15701 .destroy_swapchain_khr(swapchain, unsafe { p_allocator.as_ref() });
15702 match layer_result {
15703 LayerResult::Handled(res) => res,
15704 LayerResult::Unhandled => unsafe {
15705 (dispatch_table.destroy_swapchain_khr)(device, swapchain, p_allocator)
15706 },
15707 }
15708 }
15709 extern "system" fn get_swapchain_images_khr(
15710 device: vk::Device,
15711 swapchain: vk::SwapchainKHR,
15712 p_swapchain_image_count: *mut u32,
15713 p_swapchain_images: *mut vk::Image,
15714 ) -> vk::Result {
15715 let global = Self::instance();
15716 let device_info = global.get_device_info(device).unwrap();
15718 let dispatch_table = &device_info.dispatch_table.khr_swapchain;
15719 let layer_result = device_info
15720 .customized_info
15721 .borrow()
15722 .hooks()
15723 .get_swapchain_images_khr(swapchain);
15724 match layer_result {
15725 LayerResult::Handled(res) => match res {
15726 Ok(res) => unsafe {
15727 fill_vk_out_array(
15728 &res,
15729 NonNull::new(p_swapchain_image_count).unwrap(),
15730 p_swapchain_images,
15731 )
15732 },
15733 Err(e) => e,
15734 },
15735 LayerResult::Unhandled => unsafe {
15736 (dispatch_table.get_swapchain_images_khr)(
15737 device,
15738 swapchain,
15739 p_swapchain_image_count,
15740 p_swapchain_images,
15741 )
15742 },
15743 }
15744 }
15745 extern "system" fn acquire_next_image_khr(
15746 device: vk::Device,
15747 swapchain: vk::SwapchainKHR,
15748 timeout: u64,
15749 semaphore: vk::Semaphore,
15750 fence: vk::Fence,
15751 p_image_index: *mut u32,
15752 ) -> vk::Result {
15753 let global = Self::instance();
15754 let device_info = global.get_device_info(device).unwrap();
15756 let dispatch_table = &device_info.dispatch_table.khr_swapchain;
15757 let layer_result = device_info
15758 .customized_info
15759 .borrow()
15760 .hooks()
15761 .acquire_next_image_khr(swapchain, timeout, semaphore, fence);
15762 match layer_result {
15763 LayerResult::Handled(res) => match res {
15764 Ok(res) => {
15765 *unsafe { p_image_index.as_mut() }.unwrap() = res;
15766 vk::Result::SUCCESS
15767 }
15768 Err(e) => e,
15769 },
15770 LayerResult::Unhandled => unsafe {
15771 (dispatch_table.acquire_next_image_khr)(
15772 device,
15773 swapchain,
15774 timeout,
15775 semaphore,
15776 fence,
15777 p_image_index,
15778 )
15779 },
15780 }
15781 }
15782 extern "system" fn queue_present_khr(
15783 queue: vk::Queue,
15784 p_present_info: *const vk::PresentInfoKHR,
15785 ) -> vk::Result {
15786 let global = Self::instance();
15787 let device_info = global.get_device_info(queue).unwrap();
15789 let dispatch_table = &device_info.dispatch_table.khr_swapchain;
15790 let layer_result = device_info
15791 .customized_info
15792 .borrow()
15793 .hooks()
15794 .queue_present_khr(queue, unsafe { p_present_info.as_ref() }.unwrap());
15795 match layer_result {
15796 LayerResult::Handled(res) => match res {
15797 Ok(()) => vk::Result::SUCCESS,
15798 Err(e) => e,
15799 },
15800 LayerResult::Unhandled => unsafe {
15801 (dispatch_table.queue_present_khr)(queue, p_present_info)
15802 },
15803 }
15804 }
15805 extern "system" fn get_device_group_present_capabilities_khr(
15806 device: vk::Device,
15807 p_device_group_present_capabilities: *mut vk::DeviceGroupPresentCapabilitiesKHR,
15808 ) -> vk::Result {
15809 let global = Self::instance();
15810 let device_info = global.get_device_info(device).unwrap();
15812 let dispatch_table = &device_info.dispatch_table.khr_swapchain;
15813 let layer_result = device_info
15814 .customized_info
15815 .borrow()
15816 .hooks()
15817 .get_device_group_present_capabilities_khr(
15818 unsafe { ptr_as_uninit_mut(p_device_group_present_capabilities) }.unwrap(),
15819 );
15820 match layer_result {
15821 LayerResult::Handled(res) => match res {
15822 Ok(()) => vk::Result::SUCCESS,
15823 Err(e) => e,
15824 },
15825 LayerResult::Unhandled => unsafe {
15826 (dispatch_table.get_device_group_present_capabilities_khr)(
15827 device,
15828 p_device_group_present_capabilities,
15829 )
15830 },
15831 }
15832 }
15833 extern "system" fn get_device_group_surface_present_modes_khr(
15834 device: vk::Device,
15835 surface: vk::SurfaceKHR,
15836 p_modes: *mut vk::DeviceGroupPresentModeFlagsKHR,
15837 ) -> vk::Result {
15838 let global = Self::instance();
15839 let device_info = global.get_device_info(device).unwrap();
15841 let dispatch_table = &device_info.dispatch_table.khr_swapchain;
15842 let layer_result = device_info
15843 .customized_info
15844 .borrow()
15845 .hooks()
15846 .get_device_group_surface_present_modes_khr(surface);
15847 match layer_result {
15848 LayerResult::Handled(res) => match res {
15849 Ok(res) => {
15850 *unsafe { p_modes.as_mut() }.unwrap() = res;
15851 vk::Result::SUCCESS
15852 }
15853 Err(e) => e,
15854 },
15855 LayerResult::Unhandled => unsafe {
15856 (dispatch_table.get_device_group_surface_present_modes_khr)(
15857 device, surface, p_modes,
15858 )
15859 },
15860 }
15861 }
15862 extern "system" fn acquire_next_image2_khr(
15863 device: vk::Device,
15864 p_acquire_info: *const vk::AcquireNextImageInfoKHR,
15865 p_image_index: *mut u32,
15866 ) -> vk::Result {
15867 let global = Self::instance();
15868 let device_info = global.get_device_info(device).unwrap();
15870 let dispatch_table = &device_info.dispatch_table.khr_swapchain;
15871 let layer_result = device_info
15872 .customized_info
15873 .borrow()
15874 .hooks()
15875 .acquire_next_image2_khr(unsafe { p_acquire_info.as_ref() }.unwrap());
15876 match layer_result {
15877 LayerResult::Handled(res) => match res {
15878 Ok(res) => {
15879 *unsafe { p_image_index.as_mut() }.unwrap() = res;
15880 vk::Result::SUCCESS
15881 }
15882 Err(e) => e,
15883 },
15884 LayerResult::Unhandled => unsafe {
15885 (dispatch_table.acquire_next_image2_khr)(device, p_acquire_info, p_image_index)
15886 },
15887 }
15888 }
15889 extern "system" fn create_shared_swapchains_khr(
15890 device: vk::Device,
15891 swapchain_count: u32,
15892 p_create_infos: *const vk::SwapchainCreateInfoKHR,
15893 p_allocator: *const vk::AllocationCallbacks,
15894 p_swapchains: *mut vk::SwapchainKHR,
15895 ) -> vk::Result {
15896 let global = Self::instance();
15897 let device_info = global.get_device_info(device).unwrap();
15899 let dispatch_table = &device_info.dispatch_table.khr_display_swapchain;
15900 let layer_result = device_info
15901 .customized_info
15902 .borrow()
15903 .hooks()
15904 .create_shared_swapchains_khr(
15905 unsafe { slice_from_raw_parts(p_create_infos, swapchain_count) },
15906 unsafe { p_allocator.as_ref() },
15907 );
15908 match layer_result {
15909 LayerResult::Handled(res) => match res {
15910 Ok(res) => {
15911 unsafe {
15912 std::slice::from_raw_parts_mut(
15913 p_swapchains,
15914 swapchain_count.try_into().unwrap(),
15915 )
15916 }
15917 .copy_from_slice(&res);
15918 vk::Result::SUCCESS
15919 }
15920 Err(e) => e,
15921 },
15922 LayerResult::Unhandled => unsafe {
15923 (dispatch_table.create_shared_swapchains_khr)(
15924 device,
15925 swapchain_count,
15926 p_create_infos,
15927 p_allocator,
15928 p_swapchains,
15929 )
15930 },
15931 }
15932 }
15933 extern "system" fn create_video_session_khr(
15934 device: vk::Device,
15935 p_create_info: *const vk::VideoSessionCreateInfoKHR,
15936 p_allocator: *const vk::AllocationCallbacks,
15937 p_video_session: *mut vk::VideoSessionKHR,
15938 ) -> vk::Result {
15939 let global = Self::instance();
15940 let device_info = global.get_device_info(device).unwrap();
15942 let dispatch_table = &device_info.dispatch_table.khr_video_queue;
15943 let layer_result = device_info
15944 .customized_info
15945 .borrow()
15946 .hooks()
15947 .create_video_session_khr(unsafe { p_create_info.as_ref() }.unwrap(), unsafe {
15948 p_allocator.as_ref()
15949 });
15950 match layer_result {
15951 LayerResult::Handled(res) => match res {
15952 Ok(res) => {
15953 *unsafe { p_video_session.as_mut() }.unwrap() = res;
15954 vk::Result::SUCCESS
15955 }
15956 Err(e) => e,
15957 },
15958 LayerResult::Unhandled => unsafe {
15959 (dispatch_table.create_video_session_khr)(
15960 device,
15961 p_create_info,
15962 p_allocator,
15963 p_video_session,
15964 )
15965 },
15966 }
15967 }
15968 extern "system" fn destroy_video_session_khr(
15969 device: vk::Device,
15970 video_session: vk::VideoSessionKHR,
15971 p_allocator: *const vk::AllocationCallbacks,
15972 ) {
15973 let global = Self::instance();
15974 let device_info = global.get_device_info(device).unwrap();
15976 let dispatch_table = &device_info.dispatch_table.khr_video_queue;
15977 let layer_result = device_info
15978 .customized_info
15979 .borrow()
15980 .hooks()
15981 .destroy_video_session_khr(video_session, unsafe { p_allocator.as_ref() });
15982 match layer_result {
15983 LayerResult::Handled(res) => res,
15984 LayerResult::Unhandled => unsafe {
15985 (dispatch_table.destroy_video_session_khr)(device, video_session, p_allocator)
15986 },
15987 }
15988 }
15989 extern "system" fn get_video_session_memory_requirements_khr(
15990 device: vk::Device,
15991 video_session: vk::VideoSessionKHR,
15992 p_memory_requirements_count: *mut u32,
15993 p_memory_requirements: *mut vk::VideoSessionMemoryRequirementsKHR,
15994 ) -> vk::Result {
15995 let global = Self::instance();
15996 let device_info = global.get_device_info(device).unwrap();
15998 let dispatch_table = &device_info.dispatch_table.khr_video_queue;
15999 let layer_result = device_info
16000 .customized_info
16001 .borrow()
16002 .hooks()
16003 .get_video_session_memory_requirements_khr(
16004 video_session,
16005 unsafe { ptr_as_uninit_mut(p_memory_requirements_count) }.unwrap(),
16006 unsafe {
16007 maybe_uninit_slice_from_raw_parts_mut(
16008 p_memory_requirements,
16009 p_memory_requirements_count,
16010 )
16011 },
16012 );
16013 match layer_result {
16014 LayerResult::Handled(res) => match res {
16015 Ok(()) => vk::Result::SUCCESS,
16016 Err(e) => e,
16017 },
16018 LayerResult::Unhandled => unsafe {
16019 (dispatch_table.get_video_session_memory_requirements_khr)(
16020 device,
16021 video_session,
16022 p_memory_requirements_count,
16023 p_memory_requirements,
16024 )
16025 },
16026 }
16027 }
16028 extern "system" fn bind_video_session_memory_khr(
16029 device: vk::Device,
16030 video_session: vk::VideoSessionKHR,
16031 bind_session_memory_info_count: u32,
16032 p_bind_session_memory_infos: *const vk::BindVideoSessionMemoryInfoKHR,
16033 ) -> vk::Result {
16034 let global = Self::instance();
16035 let device_info = global.get_device_info(device).unwrap();
16037 let dispatch_table = &device_info.dispatch_table.khr_video_queue;
16038 let layer_result = device_info
16039 .customized_info
16040 .borrow()
16041 .hooks()
16042 .bind_video_session_memory_khr(video_session, unsafe {
16043 slice_from_raw_parts(p_bind_session_memory_infos, bind_session_memory_info_count)
16044 });
16045 match layer_result {
16046 LayerResult::Handled(res) => match res {
16047 Ok(()) => vk::Result::SUCCESS,
16048 Err(e) => e,
16049 },
16050 LayerResult::Unhandled => unsafe {
16051 (dispatch_table.bind_video_session_memory_khr)(
16052 device,
16053 video_session,
16054 bind_session_memory_info_count,
16055 p_bind_session_memory_infos,
16056 )
16057 },
16058 }
16059 }
16060 extern "system" fn create_video_session_parameters_khr(
16061 device: vk::Device,
16062 p_create_info: *const vk::VideoSessionParametersCreateInfoKHR,
16063 p_allocator: *const vk::AllocationCallbacks,
16064 p_video_session_parameters: *mut vk::VideoSessionParametersKHR,
16065 ) -> vk::Result {
16066 let global = Self::instance();
16067 let device_info = global.get_device_info(device).unwrap();
16069 let dispatch_table = &device_info.dispatch_table.khr_video_queue;
16070 let layer_result = device_info
16071 .customized_info
16072 .borrow()
16073 .hooks()
16074 .create_video_session_parameters_khr(
16075 unsafe { p_create_info.as_ref() }.unwrap(),
16076 unsafe { p_allocator.as_ref() },
16077 );
16078 match layer_result {
16079 LayerResult::Handled(res) => match res {
16080 Ok(res) => {
16081 *unsafe { p_video_session_parameters.as_mut() }.unwrap() = res;
16082 vk::Result::SUCCESS
16083 }
16084 Err(e) => e,
16085 },
16086 LayerResult::Unhandled => unsafe {
16087 (dispatch_table.create_video_session_parameters_khr)(
16088 device,
16089 p_create_info,
16090 p_allocator,
16091 p_video_session_parameters,
16092 )
16093 },
16094 }
16095 }
16096 extern "system" fn update_video_session_parameters_khr(
16097 device: vk::Device,
16098 video_session_parameters: vk::VideoSessionParametersKHR,
16099 p_update_info: *const vk::VideoSessionParametersUpdateInfoKHR,
16100 ) -> vk::Result {
16101 let global = Self::instance();
16102 let device_info = global.get_device_info(device).unwrap();
16104 let dispatch_table = &device_info.dispatch_table.khr_video_queue;
16105 let layer_result = device_info
16106 .customized_info
16107 .borrow()
16108 .hooks()
16109 .update_video_session_parameters_khr(
16110 video_session_parameters,
16111 unsafe { p_update_info.as_ref() }.unwrap(),
16112 );
16113 match layer_result {
16114 LayerResult::Handled(res) => match res {
16115 Ok(()) => vk::Result::SUCCESS,
16116 Err(e) => e,
16117 },
16118 LayerResult::Unhandled => unsafe {
16119 (dispatch_table.update_video_session_parameters_khr)(
16120 device,
16121 video_session_parameters,
16122 p_update_info,
16123 )
16124 },
16125 }
16126 }
16127 extern "system" fn destroy_video_session_parameters_khr(
16128 device: vk::Device,
16129 video_session_parameters: vk::VideoSessionParametersKHR,
16130 p_allocator: *const vk::AllocationCallbacks,
16131 ) {
16132 let global = Self::instance();
16133 let device_info = global.get_device_info(device).unwrap();
16135 let dispatch_table = &device_info.dispatch_table.khr_video_queue;
16136 let layer_result = device_info
16137 .customized_info
16138 .borrow()
16139 .hooks()
16140 .destroy_video_session_parameters_khr(video_session_parameters, unsafe {
16141 p_allocator.as_ref()
16142 });
16143 match layer_result {
16144 LayerResult::Handled(res) => res,
16145 LayerResult::Unhandled => unsafe {
16146 (dispatch_table.destroy_video_session_parameters_khr)(
16147 device,
16148 video_session_parameters,
16149 p_allocator,
16150 )
16151 },
16152 }
16153 }
16154 extern "system" fn cmd_begin_video_coding_khr(
16155 command_buffer: vk::CommandBuffer,
16156 p_begin_info: *const vk::VideoBeginCodingInfoKHR,
16157 ) {
16158 let global = Self::instance();
16159 let device_info = global.get_device_info(command_buffer).unwrap();
16161 let dispatch_table = &device_info.dispatch_table.khr_video_queue;
16162 let layer_result = device_info
16163 .customized_info
16164 .borrow()
16165 .hooks()
16166 .cmd_begin_video_coding_khr(command_buffer, unsafe { p_begin_info.as_ref() }.unwrap());
16167 match layer_result {
16168 LayerResult::Handled(res) => res,
16169 LayerResult::Unhandled => unsafe {
16170 (dispatch_table.cmd_begin_video_coding_khr)(command_buffer, p_begin_info)
16171 },
16172 }
16173 }
16174 extern "system" fn cmd_end_video_coding_khr(
16175 command_buffer: vk::CommandBuffer,
16176 p_end_coding_info: *const vk::VideoEndCodingInfoKHR,
16177 ) {
16178 let global = Self::instance();
16179 let device_info = global.get_device_info(command_buffer).unwrap();
16181 let dispatch_table = &device_info.dispatch_table.khr_video_queue;
16182 let layer_result = device_info
16183 .customized_info
16184 .borrow()
16185 .hooks()
16186 .cmd_end_video_coding_khr(
16187 command_buffer,
16188 unsafe { p_end_coding_info.as_ref() }.unwrap(),
16189 );
16190 match layer_result {
16191 LayerResult::Handled(res) => res,
16192 LayerResult::Unhandled => unsafe {
16193 (dispatch_table.cmd_end_video_coding_khr)(command_buffer, p_end_coding_info)
16194 },
16195 }
16196 }
16197 extern "system" fn cmd_control_video_coding_khr(
16198 command_buffer: vk::CommandBuffer,
16199 p_coding_control_info: *const vk::VideoCodingControlInfoKHR,
16200 ) {
16201 let global = Self::instance();
16202 let device_info = global.get_device_info(command_buffer).unwrap();
16204 let dispatch_table = &device_info.dispatch_table.khr_video_queue;
16205 let layer_result = device_info
16206 .customized_info
16207 .borrow()
16208 .hooks()
16209 .cmd_control_video_coding_khr(
16210 command_buffer,
16211 unsafe { p_coding_control_info.as_ref() }.unwrap(),
16212 );
16213 match layer_result {
16214 LayerResult::Handled(res) => res,
16215 LayerResult::Unhandled => unsafe {
16216 (dispatch_table.cmd_control_video_coding_khr)(command_buffer, p_coding_control_info)
16217 },
16218 }
16219 }
16220 extern "system" fn cmd_decode_video_khr(
16221 command_buffer: vk::CommandBuffer,
16222 p_decode_info: *const vk::VideoDecodeInfoKHR,
16223 ) {
16224 let global = Self::instance();
16225 let device_info = global.get_device_info(command_buffer).unwrap();
16227 let dispatch_table = &device_info.dispatch_table.khr_video_decode_queue;
16228 let layer_result = device_info
16229 .customized_info
16230 .borrow()
16231 .hooks()
16232 .cmd_decode_video_khr(command_buffer, unsafe { p_decode_info.as_ref() }.unwrap());
16233 match layer_result {
16234 LayerResult::Handled(res) => res,
16235 LayerResult::Unhandled => unsafe {
16236 (dispatch_table.cmd_decode_video_khr)(command_buffer, p_decode_info)
16237 },
16238 }
16239 }
16240 extern "system" fn get_memory_win32_handle_khr(
16241 device: vk::Device,
16242 p_get_win32_handle_info: *const vk::MemoryGetWin32HandleInfoKHR,
16243 p_handle: *mut vk::HANDLE,
16244 ) -> vk::Result {
16245 let global = Self::instance();
16246 let device_info = global.get_device_info(device).unwrap();
16248 let dispatch_table = &device_info.dispatch_table.khr_external_memory_win32;
16249 let layer_result = device_info
16250 .customized_info
16251 .borrow()
16252 .hooks()
16253 .get_memory_win32_handle_khr(unsafe { p_get_win32_handle_info.as_ref() }.unwrap());
16254 match layer_result {
16255 LayerResult::Handled(res) => match res {
16256 Ok(res) => {
16257 *unsafe { p_handle.as_mut() }.unwrap() = res;
16258 vk::Result::SUCCESS
16259 }
16260 Err(e) => e,
16261 },
16262 LayerResult::Unhandled => unsafe {
16263 (dispatch_table.get_memory_win32_handle_khr)(
16264 device,
16265 p_get_win32_handle_info,
16266 p_handle,
16267 )
16268 },
16269 }
16270 }
16271 extern "system" fn get_memory_win32_handle_properties_khr(
16272 device: vk::Device,
16273 handle_type: vk::ExternalMemoryHandleTypeFlags,
16274 handle: vk::HANDLE,
16275 p_memory_win32_handle_properties: *mut vk::MemoryWin32HandlePropertiesKHR,
16276 ) -> vk::Result {
16277 let global = Self::instance();
16278 let device_info = global.get_device_info(device).unwrap();
16280 let dispatch_table = &device_info.dispatch_table.khr_external_memory_win32;
16281 let layer_result = device_info
16282 .customized_info
16283 .borrow()
16284 .hooks()
16285 .get_memory_win32_handle_properties_khr(
16286 handle_type,
16287 handle,
16288 unsafe { ptr_as_uninit_mut(p_memory_win32_handle_properties) }.unwrap(),
16289 );
16290 match layer_result {
16291 LayerResult::Handled(res) => match res {
16292 Ok(()) => vk::Result::SUCCESS,
16293 Err(e) => e,
16294 },
16295 LayerResult::Unhandled => unsafe {
16296 (dispatch_table.get_memory_win32_handle_properties_khr)(
16297 device,
16298 handle_type,
16299 handle,
16300 p_memory_win32_handle_properties,
16301 )
16302 },
16303 }
16304 }
16305 extern "system" fn get_memory_fd_khr(
16306 device: vk::Device,
16307 p_get_fd_info: *const vk::MemoryGetFdInfoKHR,
16308 p_fd: *mut c_int,
16309 ) -> vk::Result {
16310 let global = Self::instance();
16311 let device_info = global.get_device_info(device).unwrap();
16313 let dispatch_table = &device_info.dispatch_table.khr_external_memory_fd;
16314 let layer_result = device_info
16315 .customized_info
16316 .borrow()
16317 .hooks()
16318 .get_memory_fd_khr(unsafe { p_get_fd_info.as_ref() }.unwrap());
16319 match layer_result {
16320 LayerResult::Handled(res) => match res {
16321 Ok(res) => {
16322 *unsafe { p_fd.as_mut() }.unwrap() = res;
16323 vk::Result::SUCCESS
16324 }
16325 Err(e) => e,
16326 },
16327 LayerResult::Unhandled => unsafe {
16328 (dispatch_table.get_memory_fd_khr)(device, p_get_fd_info, p_fd)
16329 },
16330 }
16331 }
16332 extern "system" fn get_memory_fd_properties_khr(
16333 device: vk::Device,
16334 handle_type: vk::ExternalMemoryHandleTypeFlags,
16335 fd: c_int,
16336 p_memory_fd_properties: *mut vk::MemoryFdPropertiesKHR,
16337 ) -> vk::Result {
16338 let global = Self::instance();
16339 let device_info = global.get_device_info(device).unwrap();
16341 let dispatch_table = &device_info.dispatch_table.khr_external_memory_fd;
16342 let layer_result = device_info
16343 .customized_info
16344 .borrow()
16345 .hooks()
16346 .get_memory_fd_properties_khr(
16347 handle_type,
16348 fd,
16349 unsafe { ptr_as_uninit_mut(p_memory_fd_properties) }.unwrap(),
16350 );
16351 match layer_result {
16352 LayerResult::Handled(res) => match res {
16353 Ok(()) => vk::Result::SUCCESS,
16354 Err(e) => e,
16355 },
16356 LayerResult::Unhandled => unsafe {
16357 (dispatch_table.get_memory_fd_properties_khr)(
16358 device,
16359 handle_type,
16360 fd,
16361 p_memory_fd_properties,
16362 )
16363 },
16364 }
16365 }
16366 extern "system" fn import_semaphore_win32_handle_khr(
16367 device: vk::Device,
16368 p_import_semaphore_win32_handle_info: *const vk::ImportSemaphoreWin32HandleInfoKHR,
16369 ) -> vk::Result {
16370 let global = Self::instance();
16371 let device_info = global.get_device_info(device).unwrap();
16373 let dispatch_table = &device_info.dispatch_table.khr_external_semaphore_win32;
16374 let layer_result = device_info
16375 .customized_info
16376 .borrow()
16377 .hooks()
16378 .import_semaphore_win32_handle_khr(
16379 unsafe { p_import_semaphore_win32_handle_info.as_ref() }.unwrap(),
16380 );
16381 match layer_result {
16382 LayerResult::Handled(res) => match res {
16383 Ok(()) => vk::Result::SUCCESS,
16384 Err(e) => e,
16385 },
16386 LayerResult::Unhandled => unsafe {
16387 (dispatch_table.import_semaphore_win32_handle_khr)(
16388 device,
16389 p_import_semaphore_win32_handle_info,
16390 )
16391 },
16392 }
16393 }
16394 extern "system" fn get_semaphore_win32_handle_khr(
16395 device: vk::Device,
16396 p_get_win32_handle_info: *const vk::SemaphoreGetWin32HandleInfoKHR,
16397 p_handle: *mut vk::HANDLE,
16398 ) -> vk::Result {
16399 let global = Self::instance();
16400 let device_info = global.get_device_info(device).unwrap();
16402 let dispatch_table = &device_info.dispatch_table.khr_external_semaphore_win32;
16403 let layer_result = device_info
16404 .customized_info
16405 .borrow()
16406 .hooks()
16407 .get_semaphore_win32_handle_khr(unsafe { p_get_win32_handle_info.as_ref() }.unwrap());
16408 match layer_result {
16409 LayerResult::Handled(res) => match res {
16410 Ok(res) => {
16411 *unsafe { p_handle.as_mut() }.unwrap() = res;
16412 vk::Result::SUCCESS
16413 }
16414 Err(e) => e,
16415 },
16416 LayerResult::Unhandled => unsafe {
16417 (dispatch_table.get_semaphore_win32_handle_khr)(
16418 device,
16419 p_get_win32_handle_info,
16420 p_handle,
16421 )
16422 },
16423 }
16424 }
16425 extern "system" fn import_semaphore_fd_khr(
16426 device: vk::Device,
16427 p_import_semaphore_fd_info: *const vk::ImportSemaphoreFdInfoKHR,
16428 ) -> vk::Result {
16429 let global = Self::instance();
16430 let device_info = global.get_device_info(device).unwrap();
16432 let dispatch_table = &device_info.dispatch_table.khr_external_semaphore_fd;
16433 let layer_result = device_info
16434 .customized_info
16435 .borrow()
16436 .hooks()
16437 .import_semaphore_fd_khr(unsafe { p_import_semaphore_fd_info.as_ref() }.unwrap());
16438 match layer_result {
16439 LayerResult::Handled(res) => match res {
16440 Ok(()) => vk::Result::SUCCESS,
16441 Err(e) => e,
16442 },
16443 LayerResult::Unhandled => unsafe {
16444 (dispatch_table.import_semaphore_fd_khr)(device, p_import_semaphore_fd_info)
16445 },
16446 }
16447 }
16448 extern "system" fn get_semaphore_fd_khr(
16449 device: vk::Device,
16450 p_get_fd_info: *const vk::SemaphoreGetFdInfoKHR,
16451 p_fd: *mut c_int,
16452 ) -> vk::Result {
16453 let global = Self::instance();
16454 let device_info = global.get_device_info(device).unwrap();
16456 let dispatch_table = &device_info.dispatch_table.khr_external_semaphore_fd;
16457 let layer_result = device_info
16458 .customized_info
16459 .borrow()
16460 .hooks()
16461 .get_semaphore_fd_khr(unsafe { p_get_fd_info.as_ref() }.unwrap());
16462 match layer_result {
16463 LayerResult::Handled(res) => match res {
16464 Ok(res) => {
16465 *unsafe { p_fd.as_mut() }.unwrap() = res;
16466 vk::Result::SUCCESS
16467 }
16468 Err(e) => e,
16469 },
16470 LayerResult::Unhandled => unsafe {
16471 (dispatch_table.get_semaphore_fd_khr)(device, p_get_fd_info, p_fd)
16472 },
16473 }
16474 }
16475 extern "system" fn cmd_push_descriptor_set_khr(
16476 command_buffer: vk::CommandBuffer,
16477 pipeline_bind_point: vk::PipelineBindPoint,
16478 layout: vk::PipelineLayout,
16479 set: u32,
16480 descriptor_write_count: u32,
16481 p_descriptor_writes: *const vk::WriteDescriptorSet,
16482 ) {
16483 let global = Self::instance();
16484 let device_info = global.get_device_info(command_buffer).unwrap();
16486 let dispatch_table = &device_info.dispatch_table.khr_push_descriptor;
16487 let layer_result = device_info
16488 .customized_info
16489 .borrow()
16490 .hooks()
16491 .cmd_push_descriptor_set_khr(
16492 command_buffer,
16493 pipeline_bind_point,
16494 layout,
16495 set,
16496 unsafe { slice_from_raw_parts(p_descriptor_writes, descriptor_write_count) },
16497 );
16498 match layer_result {
16499 LayerResult::Handled(res) => res,
16500 LayerResult::Unhandled => unsafe {
16501 (dispatch_table.cmd_push_descriptor_set_khr)(
16502 command_buffer,
16503 pipeline_bind_point,
16504 layout,
16505 set,
16506 descriptor_write_count,
16507 p_descriptor_writes,
16508 )
16509 },
16510 }
16511 }
16512 extern "system" fn cmd_push_descriptor_set_with_template_khr(
16513 command_buffer: vk::CommandBuffer,
16514 descriptor_update_template: vk::DescriptorUpdateTemplate,
16515 layout: vk::PipelineLayout,
16516 set: u32,
16517 p_data: *const c_void,
16518 ) {
16519 let global = Self::instance();
16520 let device_info = global.get_device_info(command_buffer).unwrap();
16522 let dispatch_table = &device_info.dispatch_table.khr_push_descriptor;
16523 let layer_result = device_info
16524 .customized_info
16525 .borrow()
16526 .hooks()
16527 .cmd_push_descriptor_set_with_template_khr(
16528 command_buffer,
16529 descriptor_update_template,
16530 layout,
16531 set,
16532 p_data,
16533 );
16534 match layer_result {
16535 LayerResult::Handled(res) => res,
16536 LayerResult::Unhandled => unsafe {
16537 (dispatch_table.cmd_push_descriptor_set_with_template_khr)(
16538 command_buffer,
16539 descriptor_update_template,
16540 layout,
16541 set,
16542 p_data,
16543 )
16544 },
16545 }
16546 }
16547 extern "system" fn get_swapchain_status_khr(
16548 device: vk::Device,
16549 swapchain: vk::SwapchainKHR,
16550 ) -> vk::Result {
16551 let global = Self::instance();
16552 let device_info = global.get_device_info(device).unwrap();
16554 let dispatch_table = &device_info.dispatch_table.khr_shared_presentable_image;
16555 let layer_result = device_info
16556 .customized_info
16557 .borrow()
16558 .hooks()
16559 .get_swapchain_status_khr(swapchain);
16560 match layer_result {
16561 LayerResult::Handled(res) => match res {
16562 Ok(()) => vk::Result::SUCCESS,
16563 Err(e) => e,
16564 },
16565 LayerResult::Unhandled => unsafe {
16566 (dispatch_table.get_swapchain_status_khr)(device, swapchain)
16567 },
16568 }
16569 }
16570 extern "system" fn import_fence_win32_handle_khr(
16571 device: vk::Device,
16572 p_import_fence_win32_handle_info: *const vk::ImportFenceWin32HandleInfoKHR,
16573 ) -> vk::Result {
16574 let global = Self::instance();
16575 let device_info = global.get_device_info(device).unwrap();
16577 let dispatch_table = &device_info.dispatch_table.khr_external_fence_win32;
16578 let layer_result = device_info
16579 .customized_info
16580 .borrow()
16581 .hooks()
16582 .import_fence_win32_handle_khr(
16583 unsafe { p_import_fence_win32_handle_info.as_ref() }.unwrap(),
16584 );
16585 match layer_result {
16586 LayerResult::Handled(res) => match res {
16587 Ok(()) => vk::Result::SUCCESS,
16588 Err(e) => e,
16589 },
16590 LayerResult::Unhandled => unsafe {
16591 (dispatch_table.import_fence_win32_handle_khr)(
16592 device,
16593 p_import_fence_win32_handle_info,
16594 )
16595 },
16596 }
16597 }
16598 extern "system" fn get_fence_win32_handle_khr(
16599 device: vk::Device,
16600 p_get_win32_handle_info: *const vk::FenceGetWin32HandleInfoKHR,
16601 p_handle: *mut vk::HANDLE,
16602 ) -> vk::Result {
16603 let global = Self::instance();
16604 let device_info = global.get_device_info(device).unwrap();
16606 let dispatch_table = &device_info.dispatch_table.khr_external_fence_win32;
16607 let layer_result = device_info
16608 .customized_info
16609 .borrow()
16610 .hooks()
16611 .get_fence_win32_handle_khr(unsafe { p_get_win32_handle_info.as_ref() }.unwrap());
16612 match layer_result {
16613 LayerResult::Handled(res) => match res {
16614 Ok(res) => {
16615 *unsafe { p_handle.as_mut() }.unwrap() = res;
16616 vk::Result::SUCCESS
16617 }
16618 Err(e) => e,
16619 },
16620 LayerResult::Unhandled => unsafe {
16621 (dispatch_table.get_fence_win32_handle_khr)(
16622 device,
16623 p_get_win32_handle_info,
16624 p_handle,
16625 )
16626 },
16627 }
16628 }
16629 extern "system" fn import_fence_fd_khr(
16630 device: vk::Device,
16631 p_import_fence_fd_info: *const vk::ImportFenceFdInfoKHR,
16632 ) -> vk::Result {
16633 let global = Self::instance();
16634 let device_info = global.get_device_info(device).unwrap();
16636 let dispatch_table = &device_info.dispatch_table.khr_external_fence_fd;
16637 let layer_result = device_info
16638 .customized_info
16639 .borrow()
16640 .hooks()
16641 .import_fence_fd_khr(unsafe { p_import_fence_fd_info.as_ref() }.unwrap());
16642 match layer_result {
16643 LayerResult::Handled(res) => match res {
16644 Ok(()) => vk::Result::SUCCESS,
16645 Err(e) => e,
16646 },
16647 LayerResult::Unhandled => unsafe {
16648 (dispatch_table.import_fence_fd_khr)(device, p_import_fence_fd_info)
16649 },
16650 }
16651 }
16652 extern "system" fn get_fence_fd_khr(
16653 device: vk::Device,
16654 p_get_fd_info: *const vk::FenceGetFdInfoKHR,
16655 p_fd: *mut c_int,
16656 ) -> vk::Result {
16657 let global = Self::instance();
16658 let device_info = global.get_device_info(device).unwrap();
16660 let dispatch_table = &device_info.dispatch_table.khr_external_fence_fd;
16661 let layer_result = device_info
16662 .customized_info
16663 .borrow()
16664 .hooks()
16665 .get_fence_fd_khr(unsafe { p_get_fd_info.as_ref() }.unwrap());
16666 match layer_result {
16667 LayerResult::Handled(res) => match res {
16668 Ok(res) => {
16669 *unsafe { p_fd.as_mut() }.unwrap() = res;
16670 vk::Result::SUCCESS
16671 }
16672 Err(e) => e,
16673 },
16674 LayerResult::Unhandled => unsafe {
16675 (dispatch_table.get_fence_fd_khr)(device, p_get_fd_info, p_fd)
16676 },
16677 }
16678 }
16679 extern "system" fn acquire_profiling_lock_khr(
16680 device: vk::Device,
16681 p_info: *const vk::AcquireProfilingLockInfoKHR,
16682 ) -> vk::Result {
16683 let global = Self::instance();
16684 let device_info = global.get_device_info(device).unwrap();
16686 let dispatch_table = &device_info.dispatch_table.khr_performance_query;
16687 let layer_result = device_info
16688 .customized_info
16689 .borrow()
16690 .hooks()
16691 .acquire_profiling_lock_khr(unsafe { p_info.as_ref() }.unwrap());
16692 match layer_result {
16693 LayerResult::Handled(res) => match res {
16694 Ok(()) => vk::Result::SUCCESS,
16695 Err(e) => e,
16696 },
16697 LayerResult::Unhandled => unsafe {
16698 (dispatch_table.acquire_profiling_lock_khr)(device, p_info)
16699 },
16700 }
16701 }
16702 extern "system" fn release_profiling_lock_khr(device: vk::Device) {
16703 let global = Self::instance();
16704 let device_info = global.get_device_info(device).unwrap();
16706 let dispatch_table = &device_info.dispatch_table.khr_performance_query;
16707 let layer_result = device_info
16708 .customized_info
16709 .borrow()
16710 .hooks()
16711 .release_profiling_lock_khr();
16712 match layer_result {
16713 LayerResult::Handled(res) => res,
16714 LayerResult::Unhandled => unsafe {
16715 (dispatch_table.release_profiling_lock_khr)(device)
16716 },
16717 }
16718 }
16719 extern "system" fn cmd_set_fragment_shading_rate_khr(
16720 command_buffer: vk::CommandBuffer,
16721 p_fragment_size: *const vk::Extent2D,
16722 combiner_ops: *const [vk::FragmentShadingRateCombinerOpKHR; 2],
16723 ) {
16724 let global = Self::instance();
16725 let device_info = global.get_device_info(command_buffer).unwrap();
16727 let dispatch_table = &device_info.dispatch_table.khr_fragment_shading_rate;
16728 let layer_result = device_info
16729 .customized_info
16730 .borrow()
16731 .hooks()
16732 .cmd_set_fragment_shading_rate_khr(
16733 command_buffer,
16734 unsafe { p_fragment_size.as_ref() }.unwrap(),
16735 unsafe { combiner_ops.as_ref() }.unwrap(),
16736 );
16737 match layer_result {
16738 LayerResult::Handled(res) => res,
16739 LayerResult::Unhandled => unsafe {
16740 (dispatch_table.cmd_set_fragment_shading_rate_khr)(
16741 command_buffer,
16742 p_fragment_size,
16743 combiner_ops,
16744 )
16745 },
16746 }
16747 }
16748 extern "system" fn wait_for_present_khr(
16749 device: vk::Device,
16750 swapchain: vk::SwapchainKHR,
16751 present_id: u64,
16752 timeout: u64,
16753 ) -> vk::Result {
16754 let global = Self::instance();
16755 let device_info = global.get_device_info(device).unwrap();
16757 let dispatch_table = &device_info.dispatch_table.khr_present_wait;
16758 let layer_result = device_info
16759 .customized_info
16760 .borrow()
16761 .hooks()
16762 .wait_for_present_khr(swapchain, present_id, timeout);
16763 match layer_result {
16764 LayerResult::Handled(res) => match res {
16765 Ok(()) => vk::Result::SUCCESS,
16766 Err(e) => e,
16767 },
16768 LayerResult::Unhandled => unsafe {
16769 (dispatch_table.wait_for_present_khr)(device, swapchain, present_id, timeout)
16770 },
16771 }
16772 }
16773 extern "system" fn create_deferred_operation_khr(
16774 device: vk::Device,
16775 p_allocator: *const vk::AllocationCallbacks,
16776 p_deferred_operation: *mut vk::DeferredOperationKHR,
16777 ) -> vk::Result {
16778 let global = Self::instance();
16779 let device_info = global.get_device_info(device).unwrap();
16781 let dispatch_table = &device_info.dispatch_table.khr_deferred_host_operations;
16782 let layer_result = device_info
16783 .customized_info
16784 .borrow()
16785 .hooks()
16786 .create_deferred_operation_khr(unsafe { p_allocator.as_ref() });
16787 match layer_result {
16788 LayerResult::Handled(res) => match res {
16789 Ok(res) => {
16790 *unsafe { p_deferred_operation.as_mut() }.unwrap() = res;
16791 vk::Result::SUCCESS
16792 }
16793 Err(e) => e,
16794 },
16795 LayerResult::Unhandled => unsafe {
16796 (dispatch_table.create_deferred_operation_khr)(
16797 device,
16798 p_allocator,
16799 p_deferred_operation,
16800 )
16801 },
16802 }
16803 }
16804 extern "system" fn destroy_deferred_operation_khr(
16805 device: vk::Device,
16806 operation: vk::DeferredOperationKHR,
16807 p_allocator: *const vk::AllocationCallbacks,
16808 ) {
16809 let global = Self::instance();
16810 let device_info = global.get_device_info(device).unwrap();
16812 let dispatch_table = &device_info.dispatch_table.khr_deferred_host_operations;
16813 let layer_result = device_info
16814 .customized_info
16815 .borrow()
16816 .hooks()
16817 .destroy_deferred_operation_khr(operation, unsafe { p_allocator.as_ref() });
16818 match layer_result {
16819 LayerResult::Handled(res) => res,
16820 LayerResult::Unhandled => unsafe {
16821 (dispatch_table.destroy_deferred_operation_khr)(device, operation, p_allocator)
16822 },
16823 }
16824 }
16825 extern "system" fn get_deferred_operation_max_concurrency_khr(
16826 device: vk::Device,
16827 operation: vk::DeferredOperationKHR,
16828 ) -> u32 {
16829 let global = Self::instance();
16830 let device_info = global.get_device_info(device).unwrap();
16832 let dispatch_table = &device_info.dispatch_table.khr_deferred_host_operations;
16833 let layer_result = device_info
16834 .customized_info
16835 .borrow()
16836 .hooks()
16837 .get_deferred_operation_max_concurrency_khr(operation);
16838 match layer_result {
16839 LayerResult::Handled(res) => res,
16840 LayerResult::Unhandled => unsafe {
16841 (dispatch_table.get_deferred_operation_max_concurrency_khr)(device, operation)
16842 },
16843 }
16844 }
16845 extern "system" fn get_deferred_operation_result_khr(
16846 device: vk::Device,
16847 operation: vk::DeferredOperationKHR,
16848 ) -> vk::Result {
16849 let global = Self::instance();
16850 let device_info = global.get_device_info(device).unwrap();
16852 let dispatch_table = &device_info.dispatch_table.khr_deferred_host_operations;
16853 let layer_result = device_info
16854 .customized_info
16855 .borrow()
16856 .hooks()
16857 .get_deferred_operation_result_khr(operation);
16858 match layer_result {
16859 LayerResult::Handled(res) => match res {
16860 Ok(()) => vk::Result::SUCCESS,
16861 Err(e) => e,
16862 },
16863 LayerResult::Unhandled => unsafe {
16864 (dispatch_table.get_deferred_operation_result_khr)(device, operation)
16865 },
16866 }
16867 }
16868 extern "system" fn deferred_operation_join_khr(
16869 device: vk::Device,
16870 operation: vk::DeferredOperationKHR,
16871 ) -> vk::Result {
16872 let global = Self::instance();
16873 let device_info = global.get_device_info(device).unwrap();
16875 let dispatch_table = &device_info.dispatch_table.khr_deferred_host_operations;
16876 let layer_result = device_info
16877 .customized_info
16878 .borrow()
16879 .hooks()
16880 .deferred_operation_join_khr(operation);
16881 match layer_result {
16882 LayerResult::Handled(res) => match res {
16883 Ok(()) => vk::Result::SUCCESS,
16884 Err(e) => e,
16885 },
16886 LayerResult::Unhandled => unsafe {
16887 (dispatch_table.deferred_operation_join_khr)(device, operation)
16888 },
16889 }
16890 }
16891 extern "system" fn get_pipeline_executable_properties_khr(
16892 device: vk::Device,
16893 p_pipeline_info: *const vk::PipelineInfoKHR,
16894 p_executable_count: *mut u32,
16895 p_properties: *mut vk::PipelineExecutablePropertiesKHR,
16896 ) -> vk::Result {
16897 let global = Self::instance();
16898 let device_info = global.get_device_info(device).unwrap();
16900 let dispatch_table = &device_info
16901 .dispatch_table
16902 .khr_pipeline_executable_properties;
16903 let layer_result = device_info
16904 .customized_info
16905 .borrow()
16906 .hooks()
16907 .get_pipeline_executable_properties_khr(
16908 unsafe { p_pipeline_info.as_ref() }.unwrap(),
16909 unsafe { ptr_as_uninit_mut(p_executable_count) }.unwrap(),
16910 unsafe { maybe_uninit_slice_from_raw_parts_mut(p_properties, p_executable_count) },
16911 );
16912 match layer_result {
16913 LayerResult::Handled(res) => match res {
16914 Ok(()) => vk::Result::SUCCESS,
16915 Err(e) => e,
16916 },
16917 LayerResult::Unhandled => unsafe {
16918 (dispatch_table.get_pipeline_executable_properties_khr)(
16919 device,
16920 p_pipeline_info,
16921 p_executable_count,
16922 p_properties,
16923 )
16924 },
16925 }
16926 }
16927 extern "system" fn get_pipeline_executable_statistics_khr(
16928 device: vk::Device,
16929 p_executable_info: *const vk::PipelineExecutableInfoKHR,
16930 p_statistic_count: *mut u32,
16931 p_statistics: *mut vk::PipelineExecutableStatisticKHR,
16932 ) -> vk::Result {
16933 let global = Self::instance();
16934 let device_info = global.get_device_info(device).unwrap();
16936 let dispatch_table = &device_info
16937 .dispatch_table
16938 .khr_pipeline_executable_properties;
16939 let layer_result = device_info
16940 .customized_info
16941 .borrow()
16942 .hooks()
16943 .get_pipeline_executable_statistics_khr(
16944 unsafe { p_executable_info.as_ref() }.unwrap(),
16945 unsafe { ptr_as_uninit_mut(p_statistic_count) }.unwrap(),
16946 unsafe { maybe_uninit_slice_from_raw_parts_mut(p_statistics, p_statistic_count) },
16947 );
16948 match layer_result {
16949 LayerResult::Handled(res) => match res {
16950 Ok(()) => vk::Result::SUCCESS,
16951 Err(e) => e,
16952 },
16953 LayerResult::Unhandled => unsafe {
16954 (dispatch_table.get_pipeline_executable_statistics_khr)(
16955 device,
16956 p_executable_info,
16957 p_statistic_count,
16958 p_statistics,
16959 )
16960 },
16961 }
16962 }
16963 extern "system" fn get_pipeline_executable_internal_representations_khr(
16964 device: vk::Device,
16965 p_executable_info: *const vk::PipelineExecutableInfoKHR,
16966 p_internal_representation_count: *mut u32,
16967 p_internal_representations: *mut vk::PipelineExecutableInternalRepresentationKHR,
16968 ) -> vk::Result {
16969 let global = Self::instance();
16970 let device_info = global.get_device_info(device).unwrap();
16972 let dispatch_table = &device_info
16973 .dispatch_table
16974 .khr_pipeline_executable_properties;
16975 let layer_result = device_info
16976 .customized_info
16977 .borrow()
16978 .hooks()
16979 .get_pipeline_executable_internal_representations_khr(
16980 unsafe { p_executable_info.as_ref() }.unwrap(),
16981 unsafe { ptr_as_uninit_mut(p_internal_representation_count) }.unwrap(),
16982 unsafe {
16983 maybe_uninit_slice_from_raw_parts_mut(
16984 p_internal_representations,
16985 p_internal_representation_count,
16986 )
16987 },
16988 );
16989 match layer_result {
16990 LayerResult::Handled(res) => match res {
16991 Ok(()) => vk::Result::SUCCESS,
16992 Err(e) => e,
16993 },
16994 LayerResult::Unhandled => unsafe {
16995 (dispatch_table.get_pipeline_executable_internal_representations_khr)(
16996 device,
16997 p_executable_info,
16998 p_internal_representation_count,
16999 p_internal_representations,
17000 )
17001 },
17002 }
17003 }
17004 extern "system" fn cmd_encode_video_khr(
17005 command_buffer: vk::CommandBuffer,
17006 p_encode_info: *const vk::VideoEncodeInfoKHR,
17007 ) {
17008 let global = Self::instance();
17009 let device_info = global.get_device_info(command_buffer).unwrap();
17011 let dispatch_table = &device_info.dispatch_table.khr_video_encode_queue;
17012 let layer_result = device_info
17013 .customized_info
17014 .borrow()
17015 .hooks()
17016 .cmd_encode_video_khr(command_buffer, unsafe { p_encode_info.as_ref() }.unwrap());
17017 match layer_result {
17018 LayerResult::Handled(res) => res,
17019 LayerResult::Unhandled => unsafe {
17020 (dispatch_table.cmd_encode_video_khr)(command_buffer, p_encode_info)
17021 },
17022 }
17023 }
17024 extern "system" fn cmd_write_buffer_marker2_amd(
17025 command_buffer: vk::CommandBuffer,
17026 stage: vk::PipelineStageFlags2,
17027 dst_buffer: vk::Buffer,
17028 dst_offset: vk::DeviceSize,
17029 marker: u32,
17030 ) {
17031 let global = Self::instance();
17032 let device_info = global.get_device_info(command_buffer).unwrap();
17034 let dispatch_table = &device_info.dispatch_table.khr_synchronization2;
17035 let layer_result = device_info
17036 .customized_info
17037 .borrow()
17038 .hooks()
17039 .cmd_write_buffer_marker2_amd(command_buffer, stage, dst_buffer, dst_offset, marker);
17040 match layer_result {
17041 LayerResult::Handled(res) => res,
17042 LayerResult::Unhandled => unsafe {
17043 (dispatch_table.cmd_write_buffer_marker2_amd)(
17044 command_buffer,
17045 stage,
17046 dst_buffer,
17047 dst_offset,
17048 marker,
17049 )
17050 },
17051 }
17052 }
17053 extern "system" fn get_queue_checkpoint_data2_nv(
17054 queue: vk::Queue,
17055 p_checkpoint_data_count: *mut u32,
17056 p_checkpoint_data: *mut vk::CheckpointData2NV,
17057 ) {
17058 let global = Self::instance();
17059 let device_info = global.get_device_info(queue).unwrap();
17061 let dispatch_table = &device_info.dispatch_table.khr_synchronization2;
17062 let layer_result = device_info
17063 .customized_info
17064 .borrow()
17065 .hooks()
17066 .get_queue_checkpoint_data2_nv(
17067 queue,
17068 unsafe { ptr_as_uninit_mut(p_checkpoint_data_count) }.unwrap(),
17069 unsafe {
17070 maybe_uninit_slice_from_raw_parts_mut(
17071 p_checkpoint_data,
17072 p_checkpoint_data_count,
17073 )
17074 },
17075 );
17076 match layer_result {
17077 LayerResult::Handled(res) => res,
17078 LayerResult::Unhandled => unsafe {
17079 (dispatch_table.get_queue_checkpoint_data2_nv)(
17080 queue,
17081 p_checkpoint_data_count,
17082 p_checkpoint_data,
17083 )
17084 },
17085 }
17086 }
17087 extern "system" fn cmd_trace_rays_indirect2_khr(
17088 command_buffer: vk::CommandBuffer,
17089 indirect_device_address: vk::DeviceAddress,
17090 ) {
17091 let global = Self::instance();
17092 let device_info = global.get_device_info(command_buffer).unwrap();
17094 let dispatch_table = &device_info.dispatch_table.khr_ray_tracing_maintenance1;
17095 let layer_result = device_info
17096 .customized_info
17097 .borrow()
17098 .hooks()
17099 .cmd_trace_rays_indirect2_khr(command_buffer, indirect_device_address);
17100 match layer_result {
17101 LayerResult::Handled(res) => res,
17102 LayerResult::Unhandled => unsafe {
17103 (dispatch_table.cmd_trace_rays_indirect2_khr)(
17104 command_buffer,
17105 indirect_device_address,
17106 )
17107 },
17108 }
17109 }
17110 extern "system" fn get_swapchain_gralloc_usage_android(
17111 device: vk::Device,
17112 format: vk::Format,
17113 image_usage: vk::ImageUsageFlags,
17114 gralloc_usage: *mut c_int,
17115 ) -> vk::Result {
17116 let global = Self::instance();
17117 let device_info = global.get_device_info(device).unwrap();
17119 let dispatch_table = &device_info.dispatch_table.android_native_buffer;
17120 let layer_result = device_info
17121 .customized_info
17122 .borrow()
17123 .hooks()
17124 .get_swapchain_gralloc_usage_android(format, image_usage);
17125 match layer_result {
17126 LayerResult::Handled(res) => match res {
17127 Ok(res) => {
17128 *unsafe { gralloc_usage.as_mut() }.unwrap() = res;
17129 vk::Result::SUCCESS
17130 }
17131 Err(e) => e,
17132 },
17133 LayerResult::Unhandled => unsafe {
17134 (dispatch_table.get_swapchain_gralloc_usage_android)(
17135 device,
17136 format,
17137 image_usage,
17138 gralloc_usage,
17139 )
17140 },
17141 }
17142 }
17143 extern "system" fn acquire_image_android(
17144 device: vk::Device,
17145 image: vk::Image,
17146 native_fence_fd: c_int,
17147 semaphore: vk::Semaphore,
17148 fence: vk::Fence,
17149 ) -> vk::Result {
17150 let global = Self::instance();
17151 let device_info = global.get_device_info(device).unwrap();
17153 let dispatch_table = &device_info.dispatch_table.android_native_buffer;
17154 let layer_result = device_info
17155 .customized_info
17156 .borrow()
17157 .hooks()
17158 .acquire_image_android(image, native_fence_fd, semaphore, fence);
17159 match layer_result {
17160 LayerResult::Handled(res) => match res {
17161 Ok(()) => vk::Result::SUCCESS,
17162 Err(e) => e,
17163 },
17164 LayerResult::Unhandled => unsafe {
17165 (dispatch_table.acquire_image_android)(
17166 device,
17167 image,
17168 native_fence_fd,
17169 semaphore,
17170 fence,
17171 )
17172 },
17173 }
17174 }
17175 extern "system" fn queue_signal_release_image_android(
17176 queue: vk::Queue,
17177 wait_semaphore_count: u32,
17178 p_wait_semaphores: *const vk::Semaphore,
17179 image: vk::Image,
17180 p_native_fence_fd: *mut c_int,
17181 ) -> vk::Result {
17182 let global = Self::instance();
17183 let device_info = global.get_device_info(queue).unwrap();
17185 let dispatch_table = &device_info.dispatch_table.android_native_buffer;
17186 let layer_result = device_info
17187 .customized_info
17188 .borrow()
17189 .hooks()
17190 .queue_signal_release_image_android(
17191 queue,
17192 unsafe { slice_from_raw_parts(p_wait_semaphores, wait_semaphore_count) },
17193 image,
17194 );
17195 match layer_result {
17196 LayerResult::Handled(res) => match res {
17197 Ok(res) => {
17198 *unsafe { p_native_fence_fd.as_mut() }.unwrap() = res;
17199 vk::Result::SUCCESS
17200 }
17201 Err(e) => e,
17202 },
17203 LayerResult::Unhandled => unsafe {
17204 (dispatch_table.queue_signal_release_image_android)(
17205 queue,
17206 wait_semaphore_count,
17207 p_wait_semaphores,
17208 image,
17209 p_native_fence_fd,
17210 )
17211 },
17212 }
17213 }
17214 extern "system" fn get_swapchain_gralloc_usage2_android(
17215 device: vk::Device,
17216 format: vk::Format,
17217 image_usage: vk::ImageUsageFlags,
17218 swapchain_image_usage: vk::SwapchainImageUsageFlagsANDROID,
17219 gralloc_consumer_usage: *mut u64,
17220 gralloc_producer_usage: *mut u64,
17221 ) -> vk::Result {
17222 let global = Self::instance();
17223 let device_info = global.get_device_info(device).unwrap();
17225 let dispatch_table = &device_info.dispatch_table.android_native_buffer;
17226 let layer_result = device_info
17227 .customized_info
17228 .borrow()
17229 .hooks()
17230 .get_swapchain_gralloc_usage2_android(
17231 format,
17232 image_usage,
17233 swapchain_image_usage,
17234 unsafe { ptr_as_uninit_mut(gralloc_consumer_usage) }.unwrap(),
17235 );
17236 match layer_result {
17237 LayerResult::Handled(res) => match res {
17238 Ok(res) => {
17239 *unsafe { gralloc_producer_usage.as_mut() }.unwrap() = res;
17240 vk::Result::SUCCESS
17241 }
17242 Err(e) => e,
17243 },
17244 LayerResult::Unhandled => unsafe {
17245 (dispatch_table.get_swapchain_gralloc_usage2_android)(
17246 device,
17247 format,
17248 image_usage,
17249 swapchain_image_usage,
17250 gralloc_consumer_usage,
17251 gralloc_producer_usage,
17252 )
17253 },
17254 }
17255 }
17256 extern "system" fn debug_marker_set_object_tag_ext(
17257 device: vk::Device,
17258 p_tag_info: *const vk::DebugMarkerObjectTagInfoEXT,
17259 ) -> vk::Result {
17260 let global = Self::instance();
17261 let device_info = global.get_device_info(device).unwrap();
17263 let dispatch_table = &device_info.dispatch_table.ext_debug_marker;
17264 let layer_result = device_info
17265 .customized_info
17266 .borrow()
17267 .hooks()
17268 .debug_marker_set_object_tag_ext(unsafe { p_tag_info.as_ref() }.unwrap());
17269 match layer_result {
17270 LayerResult::Handled(res) => match res {
17271 Ok(()) => vk::Result::SUCCESS,
17272 Err(e) => e,
17273 },
17274 LayerResult::Unhandled => unsafe {
17275 (dispatch_table.debug_marker_set_object_tag_ext)(device, p_tag_info)
17276 },
17277 }
17278 }
17279 extern "system" fn debug_marker_set_object_name_ext(
17280 device: vk::Device,
17281 p_name_info: *const vk::DebugMarkerObjectNameInfoEXT,
17282 ) -> vk::Result {
17283 let global = Self::instance();
17284 let device_info = global.get_device_info(device).unwrap();
17286 let dispatch_table = &device_info.dispatch_table.ext_debug_marker;
17287 let layer_result = device_info
17288 .customized_info
17289 .borrow()
17290 .hooks()
17291 .debug_marker_set_object_name_ext(unsafe { p_name_info.as_ref() }.unwrap());
17292 match layer_result {
17293 LayerResult::Handled(res) => match res {
17294 Ok(()) => vk::Result::SUCCESS,
17295 Err(e) => e,
17296 },
17297 LayerResult::Unhandled => unsafe {
17298 (dispatch_table.debug_marker_set_object_name_ext)(device, p_name_info)
17299 },
17300 }
17301 }
17302 extern "system" fn cmd_debug_marker_begin_ext(
17303 command_buffer: vk::CommandBuffer,
17304 p_marker_info: *const vk::DebugMarkerMarkerInfoEXT,
17305 ) {
17306 let global = Self::instance();
17307 let device_info = global.get_device_info(command_buffer).unwrap();
17309 let dispatch_table = &device_info.dispatch_table.ext_debug_marker;
17310 let layer_result = device_info
17311 .customized_info
17312 .borrow()
17313 .hooks()
17314 .cmd_debug_marker_begin_ext(command_buffer, unsafe { p_marker_info.as_ref() }.unwrap());
17315 match layer_result {
17316 LayerResult::Handled(res) => res,
17317 LayerResult::Unhandled => unsafe {
17318 (dispatch_table.cmd_debug_marker_begin_ext)(command_buffer, p_marker_info)
17319 },
17320 }
17321 }
17322 extern "system" fn cmd_debug_marker_end_ext(command_buffer: vk::CommandBuffer) {
17323 let global = Self::instance();
17324 let device_info = global.get_device_info(command_buffer).unwrap();
17326 let dispatch_table = &device_info.dispatch_table.ext_debug_marker;
17327 let layer_result = device_info
17328 .customized_info
17329 .borrow()
17330 .hooks()
17331 .cmd_debug_marker_end_ext(command_buffer);
17332 match layer_result {
17333 LayerResult::Handled(res) => res,
17334 LayerResult::Unhandled => unsafe {
17335 (dispatch_table.cmd_debug_marker_end_ext)(command_buffer)
17336 },
17337 }
17338 }
17339 extern "system" fn cmd_debug_marker_insert_ext(
17340 command_buffer: vk::CommandBuffer,
17341 p_marker_info: *const vk::DebugMarkerMarkerInfoEXT,
17342 ) {
17343 let global = Self::instance();
17344 let device_info = global.get_device_info(command_buffer).unwrap();
17346 let dispatch_table = &device_info.dispatch_table.ext_debug_marker;
17347 let layer_result = device_info
17348 .customized_info
17349 .borrow()
17350 .hooks()
17351 .cmd_debug_marker_insert_ext(
17352 command_buffer,
17353 unsafe { p_marker_info.as_ref() }.unwrap(),
17354 );
17355 match layer_result {
17356 LayerResult::Handled(res) => res,
17357 LayerResult::Unhandled => unsafe {
17358 (dispatch_table.cmd_debug_marker_insert_ext)(command_buffer, p_marker_info)
17359 },
17360 }
17361 }
17362 extern "system" fn cmd_bind_transform_feedback_buffers_ext(
17363 command_buffer: vk::CommandBuffer,
17364 first_binding: u32,
17365 binding_count: u32,
17366 p_buffers: *const vk::Buffer,
17367 p_offsets: *const vk::DeviceSize,
17368 p_sizes: *const vk::DeviceSize,
17369 ) {
17370 let global = Self::instance();
17371 let device_info = global.get_device_info(command_buffer).unwrap();
17373 let dispatch_table = &device_info.dispatch_table.ext_transform_feedback;
17374 let layer_result = device_info
17375 .customized_info
17376 .borrow()
17377 .hooks()
17378 .cmd_bind_transform_feedback_buffers_ext(
17379 command_buffer,
17380 first_binding,
17381 unsafe { slice_from_raw_parts(p_buffers, binding_count) },
17382 unsafe { slice_from_raw_parts(p_offsets, binding_count) },
17383 unsafe { maybe_slice_from_raw_parts(p_sizes, binding_count) },
17384 );
17385 match layer_result {
17386 LayerResult::Handled(res) => res,
17387 LayerResult::Unhandled => unsafe {
17388 (dispatch_table.cmd_bind_transform_feedback_buffers_ext)(
17389 command_buffer,
17390 first_binding,
17391 binding_count,
17392 p_buffers,
17393 p_offsets,
17394 p_sizes,
17395 )
17396 },
17397 }
17398 }
17399 extern "system" fn cmd_begin_transform_feedback_ext(
17400 command_buffer: vk::CommandBuffer,
17401 first_counter_buffer: u32,
17402 counter_buffer_count: u32,
17403 p_counter_buffers: *const vk::Buffer,
17404 p_counter_buffer_offsets: *const vk::DeviceSize,
17405 ) {
17406 let global = Self::instance();
17407 let device_info = global.get_device_info(command_buffer).unwrap();
17409 let dispatch_table = &device_info.dispatch_table.ext_transform_feedback;
17410 let layer_result = device_info
17411 .customized_info
17412 .borrow()
17413 .hooks()
17414 .cmd_begin_transform_feedback_ext(
17415 command_buffer,
17416 first_counter_buffer,
17417 unsafe { slice_from_raw_parts(p_counter_buffers, counter_buffer_count) },
17418 unsafe {
17419 maybe_slice_from_raw_parts(p_counter_buffer_offsets, counter_buffer_count)
17420 },
17421 );
17422 match layer_result {
17423 LayerResult::Handled(res) => res,
17424 LayerResult::Unhandled => unsafe {
17425 (dispatch_table.cmd_begin_transform_feedback_ext)(
17426 command_buffer,
17427 first_counter_buffer,
17428 counter_buffer_count,
17429 p_counter_buffers,
17430 p_counter_buffer_offsets,
17431 )
17432 },
17433 }
17434 }
17435 extern "system" fn cmd_end_transform_feedback_ext(
17436 command_buffer: vk::CommandBuffer,
17437 first_counter_buffer: u32,
17438 counter_buffer_count: u32,
17439 p_counter_buffers: *const vk::Buffer,
17440 p_counter_buffer_offsets: *const vk::DeviceSize,
17441 ) {
17442 let global = Self::instance();
17443 let device_info = global.get_device_info(command_buffer).unwrap();
17445 let dispatch_table = &device_info.dispatch_table.ext_transform_feedback;
17446 let layer_result = device_info
17447 .customized_info
17448 .borrow()
17449 .hooks()
17450 .cmd_end_transform_feedback_ext(
17451 command_buffer,
17452 first_counter_buffer,
17453 unsafe { slice_from_raw_parts(p_counter_buffers, counter_buffer_count) },
17454 unsafe {
17455 maybe_slice_from_raw_parts(p_counter_buffer_offsets, counter_buffer_count)
17456 },
17457 );
17458 match layer_result {
17459 LayerResult::Handled(res) => res,
17460 LayerResult::Unhandled => unsafe {
17461 (dispatch_table.cmd_end_transform_feedback_ext)(
17462 command_buffer,
17463 first_counter_buffer,
17464 counter_buffer_count,
17465 p_counter_buffers,
17466 p_counter_buffer_offsets,
17467 )
17468 },
17469 }
17470 }
17471 extern "system" fn cmd_begin_query_indexed_ext(
17472 command_buffer: vk::CommandBuffer,
17473 query_pool: vk::QueryPool,
17474 query: u32,
17475 flags: vk::QueryControlFlags,
17476 index: u32,
17477 ) {
17478 let global = Self::instance();
17479 let device_info = global.get_device_info(command_buffer).unwrap();
17481 let dispatch_table = &device_info.dispatch_table.ext_transform_feedback;
17482 let layer_result = device_info
17483 .customized_info
17484 .borrow()
17485 .hooks()
17486 .cmd_begin_query_indexed_ext(command_buffer, query_pool, query, flags, index);
17487 match layer_result {
17488 LayerResult::Handled(res) => res,
17489 LayerResult::Unhandled => unsafe {
17490 (dispatch_table.cmd_begin_query_indexed_ext)(
17491 command_buffer,
17492 query_pool,
17493 query,
17494 flags,
17495 index,
17496 )
17497 },
17498 }
17499 }
17500 extern "system" fn cmd_end_query_indexed_ext(
17501 command_buffer: vk::CommandBuffer,
17502 query_pool: vk::QueryPool,
17503 query: u32,
17504 index: u32,
17505 ) {
17506 let global = Self::instance();
17507 let device_info = global.get_device_info(command_buffer).unwrap();
17509 let dispatch_table = &device_info.dispatch_table.ext_transform_feedback;
17510 let layer_result = device_info
17511 .customized_info
17512 .borrow()
17513 .hooks()
17514 .cmd_end_query_indexed_ext(command_buffer, query_pool, query, index);
17515 match layer_result {
17516 LayerResult::Handled(res) => res,
17517 LayerResult::Unhandled => unsafe {
17518 (dispatch_table.cmd_end_query_indexed_ext)(command_buffer, query_pool, query, index)
17519 },
17520 }
17521 }
17522 extern "system" fn cmd_draw_indirect_byte_count_ext(
17523 command_buffer: vk::CommandBuffer,
17524 instance_count: u32,
17525 first_instance: u32,
17526 counter_buffer: vk::Buffer,
17527 counter_buffer_offset: vk::DeviceSize,
17528 counter_offset: u32,
17529 vertex_stride: u32,
17530 ) {
17531 let global = Self::instance();
17532 let device_info = global.get_device_info(command_buffer).unwrap();
17534 let dispatch_table = &device_info.dispatch_table.ext_transform_feedback;
17535 let layer_result = device_info
17536 .customized_info
17537 .borrow()
17538 .hooks()
17539 .cmd_draw_indirect_byte_count_ext(
17540 command_buffer,
17541 instance_count,
17542 first_instance,
17543 counter_buffer,
17544 counter_buffer_offset,
17545 counter_offset,
17546 vertex_stride,
17547 );
17548 match layer_result {
17549 LayerResult::Handled(res) => res,
17550 LayerResult::Unhandled => unsafe {
17551 (dispatch_table.cmd_draw_indirect_byte_count_ext)(
17552 command_buffer,
17553 instance_count,
17554 first_instance,
17555 counter_buffer,
17556 counter_buffer_offset,
17557 counter_offset,
17558 vertex_stride,
17559 )
17560 },
17561 }
17562 }
17563 extern "system" fn create_cu_module_nvx(
17564 device: vk::Device,
17565 p_create_info: *const vk::CuModuleCreateInfoNVX,
17566 p_allocator: *const vk::AllocationCallbacks,
17567 p_module: *mut vk::CuModuleNVX,
17568 ) -> vk::Result {
17569 let global = Self::instance();
17570 let device_info = global.get_device_info(device).unwrap();
17572 let dispatch_table = &device_info.dispatch_table.nvx_binary_import;
17573 let layer_result = device_info
17574 .customized_info
17575 .borrow()
17576 .hooks()
17577 .create_cu_module_nvx(unsafe { p_create_info.as_ref() }.unwrap(), unsafe {
17578 p_allocator.as_ref()
17579 });
17580 match layer_result {
17581 LayerResult::Handled(res) => match res {
17582 Ok(res) => {
17583 *unsafe { p_module.as_mut() }.unwrap() = res;
17584 vk::Result::SUCCESS
17585 }
17586 Err(e) => e,
17587 },
17588 LayerResult::Unhandled => unsafe {
17589 (dispatch_table.create_cu_module_nvx)(device, p_create_info, p_allocator, p_module)
17590 },
17591 }
17592 }
17593 extern "system" fn create_cu_function_nvx(
17594 device: vk::Device,
17595 p_create_info: *const vk::CuFunctionCreateInfoNVX,
17596 p_allocator: *const vk::AllocationCallbacks,
17597 p_function: *mut vk::CuFunctionNVX,
17598 ) -> vk::Result {
17599 let global = Self::instance();
17600 let device_info = global.get_device_info(device).unwrap();
17602 let dispatch_table = &device_info.dispatch_table.nvx_binary_import;
17603 let layer_result = device_info
17604 .customized_info
17605 .borrow()
17606 .hooks()
17607 .create_cu_function_nvx(unsafe { p_create_info.as_ref() }.unwrap(), unsafe {
17608 p_allocator.as_ref()
17609 });
17610 match layer_result {
17611 LayerResult::Handled(res) => match res {
17612 Ok(res) => {
17613 *unsafe { p_function.as_mut() }.unwrap() = res;
17614 vk::Result::SUCCESS
17615 }
17616 Err(e) => e,
17617 },
17618 LayerResult::Unhandled => unsafe {
17619 (dispatch_table.create_cu_function_nvx)(
17620 device,
17621 p_create_info,
17622 p_allocator,
17623 p_function,
17624 )
17625 },
17626 }
17627 }
17628 extern "system" fn destroy_cu_module_nvx(
17629 device: vk::Device,
17630 module: vk::CuModuleNVX,
17631 p_allocator: *const vk::AllocationCallbacks,
17632 ) {
17633 let global = Self::instance();
17634 let device_info = global.get_device_info(device).unwrap();
17636 let dispatch_table = &device_info.dispatch_table.nvx_binary_import;
17637 let layer_result = device_info
17638 .customized_info
17639 .borrow()
17640 .hooks()
17641 .destroy_cu_module_nvx(module, unsafe { p_allocator.as_ref() });
17642 match layer_result {
17643 LayerResult::Handled(res) => res,
17644 LayerResult::Unhandled => unsafe {
17645 (dispatch_table.destroy_cu_module_nvx)(device, module, p_allocator)
17646 },
17647 }
17648 }
17649 extern "system" fn destroy_cu_function_nvx(
17650 device: vk::Device,
17651 function: vk::CuFunctionNVX,
17652 p_allocator: *const vk::AllocationCallbacks,
17653 ) {
17654 let global = Self::instance();
17655 let device_info = global.get_device_info(device).unwrap();
17657 let dispatch_table = &device_info.dispatch_table.nvx_binary_import;
17658 let layer_result = device_info
17659 .customized_info
17660 .borrow()
17661 .hooks()
17662 .destroy_cu_function_nvx(function, unsafe { p_allocator.as_ref() });
17663 match layer_result {
17664 LayerResult::Handled(res) => res,
17665 LayerResult::Unhandled => unsafe {
17666 (dispatch_table.destroy_cu_function_nvx)(device, function, p_allocator)
17667 },
17668 }
17669 }
17670 extern "system" fn cmd_cu_launch_kernel_nvx(
17671 command_buffer: vk::CommandBuffer,
17672 p_launch_info: *const vk::CuLaunchInfoNVX,
17673 ) {
17674 let global = Self::instance();
17675 let device_info = global.get_device_info(command_buffer).unwrap();
17677 let dispatch_table = &device_info.dispatch_table.nvx_binary_import;
17678 let layer_result = device_info
17679 .customized_info
17680 .borrow()
17681 .hooks()
17682 .cmd_cu_launch_kernel_nvx(command_buffer, unsafe { p_launch_info.as_ref() }.unwrap());
17683 match layer_result {
17684 LayerResult::Handled(res) => res,
17685 LayerResult::Unhandled => unsafe {
17686 (dispatch_table.cmd_cu_launch_kernel_nvx)(command_buffer, p_launch_info)
17687 },
17688 }
17689 }
17690 extern "system" fn get_image_view_handle_nvx(
17691 device: vk::Device,
17692 p_info: *const vk::ImageViewHandleInfoNVX,
17693 ) -> u32 {
17694 let global = Self::instance();
17695 let device_info = global.get_device_info(device).unwrap();
17697 let dispatch_table = &device_info.dispatch_table.nvx_image_view_handle;
17698 let layer_result = device_info
17699 .customized_info
17700 .borrow()
17701 .hooks()
17702 .get_image_view_handle_nvx(unsafe { p_info.as_ref() }.unwrap());
17703 match layer_result {
17704 LayerResult::Handled(res) => res,
17705 LayerResult::Unhandled => unsafe {
17706 (dispatch_table.get_image_view_handle_nvx)(device, p_info)
17707 },
17708 }
17709 }
17710 extern "system" fn get_image_view_address_nvx(
17711 device: vk::Device,
17712 image_view: vk::ImageView,
17713 p_properties: *mut vk::ImageViewAddressPropertiesNVX,
17714 ) -> vk::Result {
17715 let global = Self::instance();
17716 let device_info = global.get_device_info(device).unwrap();
17718 let dispatch_table = &device_info.dispatch_table.nvx_image_view_handle;
17719 let layer_result = device_info
17720 .customized_info
17721 .borrow()
17722 .hooks()
17723 .get_image_view_address_nvx(
17724 image_view,
17725 unsafe { ptr_as_uninit_mut(p_properties) }.unwrap(),
17726 );
17727 match layer_result {
17728 LayerResult::Handled(res) => match res {
17729 Ok(()) => vk::Result::SUCCESS,
17730 Err(e) => e,
17731 },
17732 LayerResult::Unhandled => unsafe {
17733 (dispatch_table.get_image_view_address_nvx)(device, image_view, p_properties)
17734 },
17735 }
17736 }
17737 extern "system" fn get_shader_info_amd(
17738 device: vk::Device,
17739 pipeline: vk::Pipeline,
17740 shader_stage: vk::ShaderStageFlags,
17741 info_type: vk::ShaderInfoTypeAMD,
17742 p_info_size: *mut usize,
17743 p_info: *mut c_void,
17744 ) -> vk::Result {
17745 let global = Self::instance();
17746 let device_info = global.get_device_info(device).unwrap();
17748 let dispatch_table = &device_info.dispatch_table.amd_shader_info;
17749 let layer_result = device_info
17750 .customized_info
17751 .borrow()
17752 .hooks()
17753 .get_shader_info_amd(
17754 pipeline,
17755 shader_stage,
17756 info_type,
17757 unsafe { ptr_as_uninit_mut(p_info_size) }.unwrap(),
17758 unsafe { maybe_uninit_slice_from_raw_parts_mut(p_info as *mut u8, p_info_size) },
17759 );
17760 match layer_result {
17761 LayerResult::Handled(res) => match res {
17762 Ok(()) => vk::Result::SUCCESS,
17763 Err(e) => e,
17764 },
17765 LayerResult::Unhandled => unsafe {
17766 (dispatch_table.get_shader_info_amd)(
17767 device,
17768 pipeline,
17769 shader_stage,
17770 info_type,
17771 p_info_size,
17772 p_info,
17773 )
17774 },
17775 }
17776 }
17777 extern "system" fn get_memory_win32_handle_nv(
17778 device: vk::Device,
17779 memory: vk::DeviceMemory,
17780 handle_type: vk::ExternalMemoryHandleTypeFlagsNV,
17781 p_handle: *mut vk::HANDLE,
17782 ) -> vk::Result {
17783 let global = Self::instance();
17784 let device_info = global.get_device_info(device).unwrap();
17786 let dispatch_table = &device_info.dispatch_table.nv_external_memory_win32;
17787 let layer_result = device_info
17788 .customized_info
17789 .borrow()
17790 .hooks()
17791 .get_memory_win32_handle_nv(memory, handle_type);
17792 match layer_result {
17793 LayerResult::Handled(res) => match res {
17794 Ok(res) => {
17795 *unsafe { p_handle.as_mut() }.unwrap() = res;
17796 vk::Result::SUCCESS
17797 }
17798 Err(e) => e,
17799 },
17800 LayerResult::Unhandled => unsafe {
17801 (dispatch_table.get_memory_win32_handle_nv)(device, memory, handle_type, p_handle)
17802 },
17803 }
17804 }
17805 extern "system" fn cmd_begin_conditional_rendering_ext(
17806 command_buffer: vk::CommandBuffer,
17807 p_conditional_rendering_begin: *const vk::ConditionalRenderingBeginInfoEXT,
17808 ) {
17809 let global = Self::instance();
17810 let device_info = global.get_device_info(command_buffer).unwrap();
17812 let dispatch_table = &device_info.dispatch_table.ext_conditional_rendering;
17813 let layer_result = device_info
17814 .customized_info
17815 .borrow()
17816 .hooks()
17817 .cmd_begin_conditional_rendering_ext(
17818 command_buffer,
17819 unsafe { p_conditional_rendering_begin.as_ref() }.unwrap(),
17820 );
17821 match layer_result {
17822 LayerResult::Handled(res) => res,
17823 LayerResult::Unhandled => unsafe {
17824 (dispatch_table.cmd_begin_conditional_rendering_ext)(
17825 command_buffer,
17826 p_conditional_rendering_begin,
17827 )
17828 },
17829 }
17830 }
17831 extern "system" fn cmd_end_conditional_rendering_ext(command_buffer: vk::CommandBuffer) {
17832 let global = Self::instance();
17833 let device_info = global.get_device_info(command_buffer).unwrap();
17835 let dispatch_table = &device_info.dispatch_table.ext_conditional_rendering;
17836 let layer_result = device_info
17837 .customized_info
17838 .borrow()
17839 .hooks()
17840 .cmd_end_conditional_rendering_ext(command_buffer);
17841 match layer_result {
17842 LayerResult::Handled(res) => res,
17843 LayerResult::Unhandled => unsafe {
17844 (dispatch_table.cmd_end_conditional_rendering_ext)(command_buffer)
17845 },
17846 }
17847 }
17848 extern "system" fn cmd_set_viewport_w_scaling_nv(
17849 command_buffer: vk::CommandBuffer,
17850 first_viewport: u32,
17851 viewport_count: u32,
17852 p_viewport_w_scalings: *const vk::ViewportWScalingNV,
17853 ) {
17854 let global = Self::instance();
17855 let device_info = global.get_device_info(command_buffer).unwrap();
17857 let dispatch_table = &device_info.dispatch_table.nv_clip_space_w_scaling;
17858 let layer_result = device_info
17859 .customized_info
17860 .borrow()
17861 .hooks()
17862 .cmd_set_viewport_w_scaling_nv(command_buffer, first_viewport, unsafe {
17863 slice_from_raw_parts(p_viewport_w_scalings, viewport_count)
17864 });
17865 match layer_result {
17866 LayerResult::Handled(res) => res,
17867 LayerResult::Unhandled => unsafe {
17868 (dispatch_table.cmd_set_viewport_w_scaling_nv)(
17869 command_buffer,
17870 first_viewport,
17871 viewport_count,
17872 p_viewport_w_scalings,
17873 )
17874 },
17875 }
17876 }
17877 extern "system" fn display_power_control_ext(
17878 device: vk::Device,
17879 display: vk::DisplayKHR,
17880 p_display_power_info: *const vk::DisplayPowerInfoEXT,
17881 ) -> vk::Result {
17882 let global = Self::instance();
17883 let device_info = global.get_device_info(device).unwrap();
17885 let dispatch_table = &device_info.dispatch_table.ext_display_control;
17886 let layer_result = device_info
17887 .customized_info
17888 .borrow()
17889 .hooks()
17890 .display_power_control_ext(display, unsafe { p_display_power_info.as_ref() }.unwrap());
17891 match layer_result {
17892 LayerResult::Handled(res) => match res {
17893 Ok(()) => vk::Result::SUCCESS,
17894 Err(e) => e,
17895 },
17896 LayerResult::Unhandled => unsafe {
17897 (dispatch_table.display_power_control_ext)(device, display, p_display_power_info)
17898 },
17899 }
17900 }
17901 extern "system" fn register_device_event_ext(
17902 device: vk::Device,
17903 p_device_event_info: *const vk::DeviceEventInfoEXT,
17904 p_allocator: *const vk::AllocationCallbacks,
17905 p_fence: *mut vk::Fence,
17906 ) -> vk::Result {
17907 let global = Self::instance();
17908 let device_info = global.get_device_info(device).unwrap();
17910 let dispatch_table = &device_info.dispatch_table.ext_display_control;
17911 let layer_result = device_info
17912 .customized_info
17913 .borrow()
17914 .hooks()
17915 .register_device_event_ext(unsafe { p_device_event_info.as_ref() }.unwrap(), unsafe {
17916 p_allocator.as_ref()
17917 });
17918 match layer_result {
17919 LayerResult::Handled(res) => match res {
17920 Ok(res) => {
17921 *unsafe { p_fence.as_mut() }.unwrap() = res;
17922 vk::Result::SUCCESS
17923 }
17924 Err(e) => e,
17925 },
17926 LayerResult::Unhandled => unsafe {
17927 (dispatch_table.register_device_event_ext)(
17928 device,
17929 p_device_event_info,
17930 p_allocator,
17931 p_fence,
17932 )
17933 },
17934 }
17935 }
17936 extern "system" fn register_display_event_ext(
17937 device: vk::Device,
17938 display: vk::DisplayKHR,
17939 p_display_event_info: *const vk::DisplayEventInfoEXT,
17940 p_allocator: *const vk::AllocationCallbacks,
17941 p_fence: *mut vk::Fence,
17942 ) -> vk::Result {
17943 let global = Self::instance();
17944 let device_info = global.get_device_info(device).unwrap();
17946 let dispatch_table = &device_info.dispatch_table.ext_display_control;
17947 let layer_result = device_info
17948 .customized_info
17949 .borrow()
17950 .hooks()
17951 .register_display_event_ext(
17952 display,
17953 unsafe { p_display_event_info.as_ref() }.unwrap(),
17954 unsafe { p_allocator.as_ref() },
17955 );
17956 match layer_result {
17957 LayerResult::Handled(res) => match res {
17958 Ok(res) => {
17959 *unsafe { p_fence.as_mut() }.unwrap() = res;
17960 vk::Result::SUCCESS
17961 }
17962 Err(e) => e,
17963 },
17964 LayerResult::Unhandled => unsafe {
17965 (dispatch_table.register_display_event_ext)(
17966 device,
17967 display,
17968 p_display_event_info,
17969 p_allocator,
17970 p_fence,
17971 )
17972 },
17973 }
17974 }
17975 extern "system" fn get_swapchain_counter_ext(
17976 device: vk::Device,
17977 swapchain: vk::SwapchainKHR,
17978 counter: vk::SurfaceCounterFlagsEXT,
17979 p_counter_value: *mut u64,
17980 ) -> vk::Result {
17981 let global = Self::instance();
17982 let device_info = global.get_device_info(device).unwrap();
17984 let dispatch_table = &device_info.dispatch_table.ext_display_control;
17985 let layer_result = device_info
17986 .customized_info
17987 .borrow()
17988 .hooks()
17989 .get_swapchain_counter_ext(swapchain, counter);
17990 match layer_result {
17991 LayerResult::Handled(res) => match res {
17992 Ok(res) => {
17993 *unsafe { p_counter_value.as_mut() }.unwrap() = res;
17994 vk::Result::SUCCESS
17995 }
17996 Err(e) => e,
17997 },
17998 LayerResult::Unhandled => unsafe {
17999 (dispatch_table.get_swapchain_counter_ext)(
18000 device,
18001 swapchain,
18002 counter,
18003 p_counter_value,
18004 )
18005 },
18006 }
18007 }
18008 extern "system" fn get_refresh_cycle_duration_google(
18009 device: vk::Device,
18010 swapchain: vk::SwapchainKHR,
18011 p_display_timing_properties: *mut vk::RefreshCycleDurationGOOGLE,
18012 ) -> vk::Result {
18013 let global = Self::instance();
18014 let device_info = global.get_device_info(device).unwrap();
18016 let dispatch_table = &device_info.dispatch_table.google_display_timing;
18017 let layer_result = device_info
18018 .customized_info
18019 .borrow()
18020 .hooks()
18021 .get_refresh_cycle_duration_google(
18022 swapchain,
18023 unsafe { ptr_as_uninit_mut(p_display_timing_properties) }.unwrap(),
18024 );
18025 match layer_result {
18026 LayerResult::Handled(res) => match res {
18027 Ok(()) => vk::Result::SUCCESS,
18028 Err(e) => e,
18029 },
18030 LayerResult::Unhandled => unsafe {
18031 (dispatch_table.get_refresh_cycle_duration_google)(
18032 device,
18033 swapchain,
18034 p_display_timing_properties,
18035 )
18036 },
18037 }
18038 }
18039 extern "system" fn get_past_presentation_timing_google(
18040 device: vk::Device,
18041 swapchain: vk::SwapchainKHR,
18042 p_presentation_timing_count: *mut u32,
18043 p_presentation_timings: *mut vk::PastPresentationTimingGOOGLE,
18044 ) -> vk::Result {
18045 let global = Self::instance();
18046 let device_info = global.get_device_info(device).unwrap();
18048 let dispatch_table = &device_info.dispatch_table.google_display_timing;
18049 let layer_result = device_info
18050 .customized_info
18051 .borrow()
18052 .hooks()
18053 .get_past_presentation_timing_google(
18054 swapchain,
18055 unsafe { ptr_as_uninit_mut(p_presentation_timing_count) }.unwrap(),
18056 unsafe {
18057 maybe_uninit_slice_from_raw_parts_mut(
18058 p_presentation_timings,
18059 p_presentation_timing_count,
18060 )
18061 },
18062 );
18063 match layer_result {
18064 LayerResult::Handled(res) => match res {
18065 Ok(()) => vk::Result::SUCCESS,
18066 Err(e) => e,
18067 },
18068 LayerResult::Unhandled => unsafe {
18069 (dispatch_table.get_past_presentation_timing_google)(
18070 device,
18071 swapchain,
18072 p_presentation_timing_count,
18073 p_presentation_timings,
18074 )
18075 },
18076 }
18077 }
18078 extern "system" fn cmd_set_discard_rectangle_ext(
18079 command_buffer: vk::CommandBuffer,
18080 first_discard_rectangle: u32,
18081 discard_rectangle_count: u32,
18082 p_discard_rectangles: *const vk::Rect2D,
18083 ) {
18084 let global = Self::instance();
18085 let device_info = global.get_device_info(command_buffer).unwrap();
18087 let dispatch_table = &device_info.dispatch_table.ext_discard_rectangles;
18088 let layer_result = device_info
18089 .customized_info
18090 .borrow()
18091 .hooks()
18092 .cmd_set_discard_rectangle_ext(command_buffer, first_discard_rectangle, unsafe {
18093 slice_from_raw_parts(p_discard_rectangles, discard_rectangle_count)
18094 });
18095 match layer_result {
18096 LayerResult::Handled(res) => res,
18097 LayerResult::Unhandled => unsafe {
18098 (dispatch_table.cmd_set_discard_rectangle_ext)(
18099 command_buffer,
18100 first_discard_rectangle,
18101 discard_rectangle_count,
18102 p_discard_rectangles,
18103 )
18104 },
18105 }
18106 }
18107 extern "system" fn set_hdr_metadata_ext(
18108 device: vk::Device,
18109 swapchain_count: u32,
18110 p_swapchains: *const vk::SwapchainKHR,
18111 p_metadata: *const vk::HdrMetadataEXT,
18112 ) {
18113 let global = Self::instance();
18114 let device_info = global.get_device_info(device).unwrap();
18116 let dispatch_table = &device_info.dispatch_table.ext_hdr_metadata;
18117 let layer_result = device_info
18118 .customized_info
18119 .borrow()
18120 .hooks()
18121 .set_hdr_metadata_ext(
18122 unsafe { slice_from_raw_parts(p_swapchains, swapchain_count) },
18123 unsafe { slice_from_raw_parts(p_metadata, swapchain_count) },
18124 );
18125 match layer_result {
18126 LayerResult::Handled(res) => res,
18127 LayerResult::Unhandled => unsafe {
18128 (dispatch_table.set_hdr_metadata_ext)(
18129 device,
18130 swapchain_count,
18131 p_swapchains,
18132 p_metadata,
18133 )
18134 },
18135 }
18136 }
18137 extern "system" fn set_debug_utils_object_name_ext(
18138 device: vk::Device,
18139 p_name_info: *const vk::DebugUtilsObjectNameInfoEXT,
18140 ) -> vk::Result {
18141 let global = Self::instance();
18142 let device_info = global.get_device_info(device).unwrap();
18144 let dispatch_table = &device_info.dispatch_table.ext_debug_utils;
18145 let layer_result = device_info
18146 .customized_info
18147 .borrow()
18148 .hooks()
18149 .set_debug_utils_object_name_ext(unsafe { p_name_info.as_ref() }.unwrap());
18150 match layer_result {
18151 LayerResult::Handled(res) => match res {
18152 Ok(()) => vk::Result::SUCCESS,
18153 Err(e) => e,
18154 },
18155 LayerResult::Unhandled => unsafe {
18156 (dispatch_table.set_debug_utils_object_name_ext)(device, p_name_info)
18157 },
18158 }
18159 }
18160 extern "system" fn set_debug_utils_object_tag_ext(
18161 device: vk::Device,
18162 p_tag_info: *const vk::DebugUtilsObjectTagInfoEXT,
18163 ) -> vk::Result {
18164 let global = Self::instance();
18165 let device_info = global.get_device_info(device).unwrap();
18167 let dispatch_table = &device_info.dispatch_table.ext_debug_utils;
18168 let layer_result = device_info
18169 .customized_info
18170 .borrow()
18171 .hooks()
18172 .set_debug_utils_object_tag_ext(unsafe { p_tag_info.as_ref() }.unwrap());
18173 match layer_result {
18174 LayerResult::Handled(res) => match res {
18175 Ok(()) => vk::Result::SUCCESS,
18176 Err(e) => e,
18177 },
18178 LayerResult::Unhandled => unsafe {
18179 (dispatch_table.set_debug_utils_object_tag_ext)(device, p_tag_info)
18180 },
18181 }
18182 }
18183 extern "system" fn queue_begin_debug_utils_label_ext(
18184 queue: vk::Queue,
18185 p_label_info: *const vk::DebugUtilsLabelEXT,
18186 ) {
18187 let global = Self::instance();
18188 let device_info = global.get_device_info(queue).unwrap();
18190 let dispatch_table = &device_info.dispatch_table.ext_debug_utils;
18191 let layer_result = device_info
18192 .customized_info
18193 .borrow()
18194 .hooks()
18195 .queue_begin_debug_utils_label_ext(queue, unsafe { p_label_info.as_ref() }.unwrap());
18196 match layer_result {
18197 LayerResult::Handled(res) => res,
18198 LayerResult::Unhandled => unsafe {
18199 (dispatch_table.queue_begin_debug_utils_label_ext)(queue, p_label_info)
18200 },
18201 }
18202 }
18203 extern "system" fn queue_end_debug_utils_label_ext(queue: vk::Queue) {
18204 let global = Self::instance();
18205 let device_info = global.get_device_info(queue).unwrap();
18207 let dispatch_table = &device_info.dispatch_table.ext_debug_utils;
18208 let layer_result = device_info
18209 .customized_info
18210 .borrow()
18211 .hooks()
18212 .queue_end_debug_utils_label_ext(queue);
18213 match layer_result {
18214 LayerResult::Handled(res) => res,
18215 LayerResult::Unhandled => unsafe {
18216 (dispatch_table.queue_end_debug_utils_label_ext)(queue)
18217 },
18218 }
18219 }
18220 extern "system" fn queue_insert_debug_utils_label_ext(
18221 queue: vk::Queue,
18222 p_label_info: *const vk::DebugUtilsLabelEXT,
18223 ) {
18224 let global = Self::instance();
18225 let device_info = global.get_device_info(queue).unwrap();
18227 let dispatch_table = &device_info.dispatch_table.ext_debug_utils;
18228 let layer_result = device_info
18229 .customized_info
18230 .borrow()
18231 .hooks()
18232 .queue_insert_debug_utils_label_ext(queue, unsafe { p_label_info.as_ref() }.unwrap());
18233 match layer_result {
18234 LayerResult::Handled(res) => res,
18235 LayerResult::Unhandled => unsafe {
18236 (dispatch_table.queue_insert_debug_utils_label_ext)(queue, p_label_info)
18237 },
18238 }
18239 }
18240 extern "system" fn cmd_begin_debug_utils_label_ext(
18241 command_buffer: vk::CommandBuffer,
18242 p_label_info: *const vk::DebugUtilsLabelEXT,
18243 ) {
18244 let global = Self::instance();
18245 let device_info = global.get_device_info(command_buffer).unwrap();
18247 let dispatch_table = &device_info.dispatch_table.ext_debug_utils;
18248 let layer_result = device_info
18249 .customized_info
18250 .borrow()
18251 .hooks()
18252 .cmd_begin_debug_utils_label_ext(
18253 command_buffer,
18254 unsafe { p_label_info.as_ref() }.unwrap(),
18255 );
18256 match layer_result {
18257 LayerResult::Handled(res) => res,
18258 LayerResult::Unhandled => unsafe {
18259 (dispatch_table.cmd_begin_debug_utils_label_ext)(command_buffer, p_label_info)
18260 },
18261 }
18262 }
18263 extern "system" fn cmd_end_debug_utils_label_ext(command_buffer: vk::CommandBuffer) {
18264 let global = Self::instance();
18265 let device_info = global.get_device_info(command_buffer).unwrap();
18267 let dispatch_table = &device_info.dispatch_table.ext_debug_utils;
18268 let layer_result = device_info
18269 .customized_info
18270 .borrow()
18271 .hooks()
18272 .cmd_end_debug_utils_label_ext(command_buffer);
18273 match layer_result {
18274 LayerResult::Handled(res) => res,
18275 LayerResult::Unhandled => unsafe {
18276 (dispatch_table.cmd_end_debug_utils_label_ext)(command_buffer)
18277 },
18278 }
18279 }
18280 extern "system" fn cmd_insert_debug_utils_label_ext(
18281 command_buffer: vk::CommandBuffer,
18282 p_label_info: *const vk::DebugUtilsLabelEXT,
18283 ) {
18284 let global = Self::instance();
18285 let device_info = global.get_device_info(command_buffer).unwrap();
18287 let dispatch_table = &device_info.dispatch_table.ext_debug_utils;
18288 let layer_result = device_info
18289 .customized_info
18290 .borrow()
18291 .hooks()
18292 .cmd_insert_debug_utils_label_ext(
18293 command_buffer,
18294 unsafe { p_label_info.as_ref() }.unwrap(),
18295 );
18296 match layer_result {
18297 LayerResult::Handled(res) => res,
18298 LayerResult::Unhandled => unsafe {
18299 (dispatch_table.cmd_insert_debug_utils_label_ext)(command_buffer, p_label_info)
18300 },
18301 }
18302 }
18303 extern "system" fn get_android_hardware_buffer_properties_android(
18304 device: vk::Device,
18305 buffer: *const vk::AHardwareBuffer,
18306 p_properties: *mut vk::AndroidHardwareBufferPropertiesANDROID,
18307 ) -> vk::Result {
18308 let global = Self::instance();
18309 let device_info = global.get_device_info(device).unwrap();
18311 let dispatch_table = &device_info
18312 .dispatch_table
18313 .android_external_memory_android_hardware_buffer;
18314 let layer_result = device_info
18315 .customized_info
18316 .borrow()
18317 .hooks()
18318 .get_android_hardware_buffer_properties_android(
18319 buffer,
18320 unsafe { ptr_as_uninit_mut(p_properties) }.unwrap(),
18321 );
18322 match layer_result {
18323 LayerResult::Handled(res) => match res {
18324 Ok(()) => vk::Result::SUCCESS,
18325 Err(e) => e,
18326 },
18327 LayerResult::Unhandled => unsafe {
18328 (dispatch_table.get_android_hardware_buffer_properties_android)(
18329 device,
18330 buffer,
18331 p_properties,
18332 )
18333 },
18334 }
18335 }
18336 extern "system" fn get_memory_android_hardware_buffer_android(
18337 device: vk::Device,
18338 p_info: *const vk::MemoryGetAndroidHardwareBufferInfoANDROID,
18339 p_buffer: *mut *mut vk::AHardwareBuffer,
18340 ) -> vk::Result {
18341 let global = Self::instance();
18342 let device_info = global.get_device_info(device).unwrap();
18344 let dispatch_table = &device_info
18345 .dispatch_table
18346 .android_external_memory_android_hardware_buffer;
18347 let layer_result = device_info
18348 .customized_info
18349 .borrow()
18350 .hooks()
18351 .get_memory_android_hardware_buffer_android(unsafe { p_info.as_ref() }.unwrap());
18352 match layer_result {
18353 LayerResult::Handled(res) => match res {
18354 Ok(res) => {
18355 *unsafe { p_buffer.as_mut() }.unwrap() = res;
18356 vk::Result::SUCCESS
18357 }
18358 Err(e) => e,
18359 },
18360 LayerResult::Unhandled => unsafe {
18361 (dispatch_table.get_memory_android_hardware_buffer_android)(
18362 device, p_info, p_buffer,
18363 )
18364 },
18365 }
18366 }
18367 extern "system" fn cmd_set_sample_locations_ext(
18368 command_buffer: vk::CommandBuffer,
18369 p_sample_locations_info: *const vk::SampleLocationsInfoEXT,
18370 ) {
18371 let global = Self::instance();
18372 let device_info = global.get_device_info(command_buffer).unwrap();
18374 let dispatch_table = &device_info.dispatch_table.ext_sample_locations;
18375 let layer_result = device_info
18376 .customized_info
18377 .borrow()
18378 .hooks()
18379 .cmd_set_sample_locations_ext(
18380 command_buffer,
18381 unsafe { p_sample_locations_info.as_ref() }.unwrap(),
18382 );
18383 match layer_result {
18384 LayerResult::Handled(res) => res,
18385 LayerResult::Unhandled => unsafe {
18386 (dispatch_table.cmd_set_sample_locations_ext)(
18387 command_buffer,
18388 p_sample_locations_info,
18389 )
18390 },
18391 }
18392 }
18393 extern "system" fn get_image_drm_format_modifier_properties_ext(
18394 device: vk::Device,
18395 image: vk::Image,
18396 p_properties: *mut vk::ImageDrmFormatModifierPropertiesEXT,
18397 ) -> vk::Result {
18398 let global = Self::instance();
18399 let device_info = global.get_device_info(device).unwrap();
18401 let dispatch_table = &device_info.dispatch_table.ext_image_drm_format_modifier;
18402 let layer_result = device_info
18403 .customized_info
18404 .borrow()
18405 .hooks()
18406 .get_image_drm_format_modifier_properties_ext(
18407 image,
18408 unsafe { ptr_as_uninit_mut(p_properties) }.unwrap(),
18409 );
18410 match layer_result {
18411 LayerResult::Handled(res) => match res {
18412 Ok(()) => vk::Result::SUCCESS,
18413 Err(e) => e,
18414 },
18415 LayerResult::Unhandled => unsafe {
18416 (dispatch_table.get_image_drm_format_modifier_properties_ext)(
18417 device,
18418 image,
18419 p_properties,
18420 )
18421 },
18422 }
18423 }
18424 extern "system" fn create_validation_cache_ext(
18425 device: vk::Device,
18426 p_create_info: *const vk::ValidationCacheCreateInfoEXT,
18427 p_allocator: *const vk::AllocationCallbacks,
18428 p_validation_cache: *mut vk::ValidationCacheEXT,
18429 ) -> vk::Result {
18430 let global = Self::instance();
18431 let device_info = global.get_device_info(device).unwrap();
18433 let dispatch_table = &device_info.dispatch_table.ext_validation_cache;
18434 let layer_result = device_info
18435 .customized_info
18436 .borrow()
18437 .hooks()
18438 .create_validation_cache_ext(unsafe { p_create_info.as_ref() }.unwrap(), unsafe {
18439 p_allocator.as_ref()
18440 });
18441 match layer_result {
18442 LayerResult::Handled(res) => match res {
18443 Ok(res) => {
18444 *unsafe { p_validation_cache.as_mut() }.unwrap() = res;
18445 vk::Result::SUCCESS
18446 }
18447 Err(e) => e,
18448 },
18449 LayerResult::Unhandled => unsafe {
18450 (dispatch_table.create_validation_cache_ext)(
18451 device,
18452 p_create_info,
18453 p_allocator,
18454 p_validation_cache,
18455 )
18456 },
18457 }
18458 }
18459 extern "system" fn destroy_validation_cache_ext(
18460 device: vk::Device,
18461 validation_cache: vk::ValidationCacheEXT,
18462 p_allocator: *const vk::AllocationCallbacks,
18463 ) {
18464 let global = Self::instance();
18465 let device_info = global.get_device_info(device).unwrap();
18467 let dispatch_table = &device_info.dispatch_table.ext_validation_cache;
18468 let layer_result = device_info
18469 .customized_info
18470 .borrow()
18471 .hooks()
18472 .destroy_validation_cache_ext(validation_cache, unsafe { p_allocator.as_ref() });
18473 match layer_result {
18474 LayerResult::Handled(res) => res,
18475 LayerResult::Unhandled => unsafe {
18476 (dispatch_table.destroy_validation_cache_ext)(device, validation_cache, p_allocator)
18477 },
18478 }
18479 }
18480 extern "system" fn merge_validation_caches_ext(
18481 device: vk::Device,
18482 dst_cache: vk::ValidationCacheEXT,
18483 src_cache_count: u32,
18484 p_src_caches: *const vk::ValidationCacheEXT,
18485 ) -> vk::Result {
18486 let global = Self::instance();
18487 let device_info = global.get_device_info(device).unwrap();
18489 let dispatch_table = &device_info.dispatch_table.ext_validation_cache;
18490 let layer_result = device_info
18491 .customized_info
18492 .borrow()
18493 .hooks()
18494 .merge_validation_caches_ext(dst_cache, unsafe {
18495 slice_from_raw_parts(p_src_caches, src_cache_count)
18496 });
18497 match layer_result {
18498 LayerResult::Handled(res) => match res {
18499 Ok(()) => vk::Result::SUCCESS,
18500 Err(e) => e,
18501 },
18502 LayerResult::Unhandled => unsafe {
18503 (dispatch_table.merge_validation_caches_ext)(
18504 device,
18505 dst_cache,
18506 src_cache_count,
18507 p_src_caches,
18508 )
18509 },
18510 }
18511 }
18512 extern "system" fn get_validation_cache_data_ext(
18513 device: vk::Device,
18514 validation_cache: vk::ValidationCacheEXT,
18515 p_data_size: *mut usize,
18516 p_data: *mut c_void,
18517 ) -> vk::Result {
18518 let global = Self::instance();
18519 let device_info = global.get_device_info(device).unwrap();
18521 let dispatch_table = &device_info.dispatch_table.ext_validation_cache;
18522 let layer_result = device_info
18523 .customized_info
18524 .borrow()
18525 .hooks()
18526 .get_validation_cache_data_ext(
18527 validation_cache,
18528 unsafe { ptr_as_uninit_mut(p_data_size) }.unwrap(),
18529 unsafe { maybe_uninit_slice_from_raw_parts_mut(p_data as *mut u8, p_data_size) },
18530 );
18531 match layer_result {
18532 LayerResult::Handled(res) => match res {
18533 Ok(()) => vk::Result::SUCCESS,
18534 Err(e) => e,
18535 },
18536 LayerResult::Unhandled => unsafe {
18537 (dispatch_table.get_validation_cache_data_ext)(
18538 device,
18539 validation_cache,
18540 p_data_size,
18541 p_data,
18542 )
18543 },
18544 }
18545 }
18546 extern "system" fn cmd_bind_shading_rate_image_nv(
18547 command_buffer: vk::CommandBuffer,
18548 image_view: vk::ImageView,
18549 image_layout: vk::ImageLayout,
18550 ) {
18551 let global = Self::instance();
18552 let device_info = global.get_device_info(command_buffer).unwrap();
18554 let dispatch_table = &device_info.dispatch_table.nv_shading_rate_image;
18555 let layer_result = device_info
18556 .customized_info
18557 .borrow()
18558 .hooks()
18559 .cmd_bind_shading_rate_image_nv(command_buffer, image_view, image_layout);
18560 match layer_result {
18561 LayerResult::Handled(res) => res,
18562 LayerResult::Unhandled => unsafe {
18563 (dispatch_table.cmd_bind_shading_rate_image_nv)(
18564 command_buffer,
18565 image_view,
18566 image_layout,
18567 )
18568 },
18569 }
18570 }
18571 extern "system" fn cmd_set_viewport_shading_rate_palette_nv(
18572 command_buffer: vk::CommandBuffer,
18573 first_viewport: u32,
18574 viewport_count: u32,
18575 p_shading_rate_palettes: *const vk::ShadingRatePaletteNV,
18576 ) {
18577 let global = Self::instance();
18578 let device_info = global.get_device_info(command_buffer).unwrap();
18580 let dispatch_table = &device_info.dispatch_table.nv_shading_rate_image;
18581 let layer_result = device_info
18582 .customized_info
18583 .borrow()
18584 .hooks()
18585 .cmd_set_viewport_shading_rate_palette_nv(command_buffer, first_viewport, unsafe {
18586 slice_from_raw_parts(p_shading_rate_palettes, viewport_count)
18587 });
18588 match layer_result {
18589 LayerResult::Handled(res) => res,
18590 LayerResult::Unhandled => unsafe {
18591 (dispatch_table.cmd_set_viewport_shading_rate_palette_nv)(
18592 command_buffer,
18593 first_viewport,
18594 viewport_count,
18595 p_shading_rate_palettes,
18596 )
18597 },
18598 }
18599 }
18600 extern "system" fn cmd_set_coarse_sample_order_nv(
18601 command_buffer: vk::CommandBuffer,
18602 sample_order_type: vk::CoarseSampleOrderTypeNV,
18603 custom_sample_order_count: u32,
18604 p_custom_sample_orders: *const vk::CoarseSampleOrderCustomNV,
18605 ) {
18606 let global = Self::instance();
18607 let device_info = global.get_device_info(command_buffer).unwrap();
18609 let dispatch_table = &device_info.dispatch_table.nv_shading_rate_image;
18610 let layer_result = device_info
18611 .customized_info
18612 .borrow()
18613 .hooks()
18614 .cmd_set_coarse_sample_order_nv(command_buffer, sample_order_type, unsafe {
18615 slice_from_raw_parts(p_custom_sample_orders, custom_sample_order_count)
18616 });
18617 match layer_result {
18618 LayerResult::Handled(res) => res,
18619 LayerResult::Unhandled => unsafe {
18620 (dispatch_table.cmd_set_coarse_sample_order_nv)(
18621 command_buffer,
18622 sample_order_type,
18623 custom_sample_order_count,
18624 p_custom_sample_orders,
18625 )
18626 },
18627 }
18628 }
18629 extern "system" fn create_acceleration_structure_nv(
18630 device: vk::Device,
18631 p_create_info: *const vk::AccelerationStructureCreateInfoNV,
18632 p_allocator: *const vk::AllocationCallbacks,
18633 p_acceleration_structure: *mut vk::AccelerationStructureNV,
18634 ) -> vk::Result {
18635 let global = Self::instance();
18636 let device_info = global.get_device_info(device).unwrap();
18638 let dispatch_table = &device_info.dispatch_table.nv_ray_tracing;
18639 let layer_result = device_info
18640 .customized_info
18641 .borrow()
18642 .hooks()
18643 .create_acceleration_structure_nv(unsafe { p_create_info.as_ref() }.unwrap(), unsafe {
18644 p_allocator.as_ref()
18645 });
18646 match layer_result {
18647 LayerResult::Handled(res) => match res {
18648 Ok(res) => {
18649 *unsafe { p_acceleration_structure.as_mut() }.unwrap() = res;
18650 vk::Result::SUCCESS
18651 }
18652 Err(e) => e,
18653 },
18654 LayerResult::Unhandled => unsafe {
18655 (dispatch_table.create_acceleration_structure_nv)(
18656 device,
18657 p_create_info,
18658 p_allocator,
18659 p_acceleration_structure,
18660 )
18661 },
18662 }
18663 }
18664 extern "system" fn destroy_acceleration_structure_nv(
18665 device: vk::Device,
18666 acceleration_structure: vk::AccelerationStructureNV,
18667 p_allocator: *const vk::AllocationCallbacks,
18668 ) {
18669 let global = Self::instance();
18670 let device_info = global.get_device_info(device).unwrap();
18672 let dispatch_table = &device_info.dispatch_table.nv_ray_tracing;
18673 let layer_result = device_info
18674 .customized_info
18675 .borrow()
18676 .hooks()
18677 .destroy_acceleration_structure_nv(acceleration_structure, unsafe {
18678 p_allocator.as_ref()
18679 });
18680 match layer_result {
18681 LayerResult::Handled(res) => res,
18682 LayerResult::Unhandled => unsafe {
18683 (dispatch_table.destroy_acceleration_structure_nv)(
18684 device,
18685 acceleration_structure,
18686 p_allocator,
18687 )
18688 },
18689 }
18690 }
18691 extern "system" fn get_acceleration_structure_memory_requirements_nv(
18692 device: vk::Device,
18693 p_info: *const vk::AccelerationStructureMemoryRequirementsInfoNV,
18694 p_memory_requirements: *mut vk::MemoryRequirements2KHR,
18695 ) {
18696 let global = Self::instance();
18697 let device_info = global.get_device_info(device).unwrap();
18699 let dispatch_table = &device_info.dispatch_table.nv_ray_tracing;
18700 let layer_result = device_info
18701 .customized_info
18702 .borrow()
18703 .hooks()
18704 .get_acceleration_structure_memory_requirements_nv(
18705 unsafe { p_info.as_ref() }.unwrap(),
18706 unsafe { ptr_as_uninit_mut(p_memory_requirements) }.unwrap(),
18707 );
18708 match layer_result {
18709 LayerResult::Handled(res) => res,
18710 LayerResult::Unhandled => unsafe {
18711 (dispatch_table.get_acceleration_structure_memory_requirements_nv)(
18712 device,
18713 p_info,
18714 p_memory_requirements,
18715 )
18716 },
18717 }
18718 }
18719 extern "system" fn bind_acceleration_structure_memory_nv(
18720 device: vk::Device,
18721 bind_info_count: u32,
18722 p_bind_infos: *const vk::BindAccelerationStructureMemoryInfoNV,
18723 ) -> vk::Result {
18724 let global = Self::instance();
18725 let device_info = global.get_device_info(device).unwrap();
18727 let dispatch_table = &device_info.dispatch_table.nv_ray_tracing;
18728 let layer_result = device_info
18729 .customized_info
18730 .borrow()
18731 .hooks()
18732 .bind_acceleration_structure_memory_nv(unsafe {
18733 slice_from_raw_parts(p_bind_infos, bind_info_count)
18734 });
18735 match layer_result {
18736 LayerResult::Handled(res) => match res {
18737 Ok(()) => vk::Result::SUCCESS,
18738 Err(e) => e,
18739 },
18740 LayerResult::Unhandled => unsafe {
18741 (dispatch_table.bind_acceleration_structure_memory_nv)(
18742 device,
18743 bind_info_count,
18744 p_bind_infos,
18745 )
18746 },
18747 }
18748 }
18749 extern "system" fn cmd_build_acceleration_structure_nv(
18750 command_buffer: vk::CommandBuffer,
18751 p_info: *const vk::AccelerationStructureInfoNV,
18752 instance_data: vk::Buffer,
18753 instance_offset: vk::DeviceSize,
18754 update: vk::Bool32,
18755 dst: vk::AccelerationStructureNV,
18756 src: vk::AccelerationStructureNV,
18757 scratch: vk::Buffer,
18758 scratch_offset: vk::DeviceSize,
18759 ) {
18760 let global = Self::instance();
18761 let device_info = global.get_device_info(command_buffer).unwrap();
18763 let dispatch_table = &device_info.dispatch_table.nv_ray_tracing;
18764 let layer_result = device_info
18765 .customized_info
18766 .borrow()
18767 .hooks()
18768 .cmd_build_acceleration_structure_nv(
18769 command_buffer,
18770 unsafe { p_info.as_ref() }.unwrap(),
18771 instance_data,
18772 instance_offset,
18773 update == vk::TRUE,
18774 dst,
18775 src,
18776 scratch,
18777 scratch_offset,
18778 );
18779 match layer_result {
18780 LayerResult::Handled(res) => res,
18781 LayerResult::Unhandled => unsafe {
18782 (dispatch_table.cmd_build_acceleration_structure_nv)(
18783 command_buffer,
18784 p_info,
18785 instance_data,
18786 instance_offset,
18787 update,
18788 dst,
18789 src,
18790 scratch,
18791 scratch_offset,
18792 )
18793 },
18794 }
18795 }
18796 extern "system" fn cmd_copy_acceleration_structure_nv(
18797 command_buffer: vk::CommandBuffer,
18798 dst: vk::AccelerationStructureNV,
18799 src: vk::AccelerationStructureNV,
18800 mode: vk::CopyAccelerationStructureModeKHR,
18801 ) {
18802 let global = Self::instance();
18803 let device_info = global.get_device_info(command_buffer).unwrap();
18805 let dispatch_table = &device_info.dispatch_table.nv_ray_tracing;
18806 let layer_result = device_info
18807 .customized_info
18808 .borrow()
18809 .hooks()
18810 .cmd_copy_acceleration_structure_nv(command_buffer, dst, src, mode);
18811 match layer_result {
18812 LayerResult::Handled(res) => res,
18813 LayerResult::Unhandled => unsafe {
18814 (dispatch_table.cmd_copy_acceleration_structure_nv)(command_buffer, dst, src, mode)
18815 },
18816 }
18817 }
18818 extern "system" fn cmd_trace_rays_nv(
18819 command_buffer: vk::CommandBuffer,
18820 raygen_shader_binding_table_buffer: vk::Buffer,
18821 raygen_shader_binding_offset: vk::DeviceSize,
18822 miss_shader_binding_table_buffer: vk::Buffer,
18823 miss_shader_binding_offset: vk::DeviceSize,
18824 miss_shader_binding_stride: vk::DeviceSize,
18825 hit_shader_binding_table_buffer: vk::Buffer,
18826 hit_shader_binding_offset: vk::DeviceSize,
18827 hit_shader_binding_stride: vk::DeviceSize,
18828 callable_shader_binding_table_buffer: vk::Buffer,
18829 callable_shader_binding_offset: vk::DeviceSize,
18830 callable_shader_binding_stride: vk::DeviceSize,
18831 width: u32,
18832 height: u32,
18833 depth: u32,
18834 ) {
18835 let global = Self::instance();
18836 let device_info = global.get_device_info(command_buffer).unwrap();
18838 let dispatch_table = &device_info.dispatch_table.nv_ray_tracing;
18839 let layer_result = device_info
18840 .customized_info
18841 .borrow()
18842 .hooks()
18843 .cmd_trace_rays_nv(
18844 command_buffer,
18845 raygen_shader_binding_table_buffer,
18846 raygen_shader_binding_offset,
18847 miss_shader_binding_table_buffer,
18848 miss_shader_binding_offset,
18849 miss_shader_binding_stride,
18850 hit_shader_binding_table_buffer,
18851 hit_shader_binding_offset,
18852 hit_shader_binding_stride,
18853 callable_shader_binding_table_buffer,
18854 callable_shader_binding_offset,
18855 callable_shader_binding_stride,
18856 width,
18857 height,
18858 depth,
18859 );
18860 match layer_result {
18861 LayerResult::Handled(res) => res,
18862 LayerResult::Unhandled => unsafe {
18863 (dispatch_table.cmd_trace_rays_nv)(
18864 command_buffer,
18865 raygen_shader_binding_table_buffer,
18866 raygen_shader_binding_offset,
18867 miss_shader_binding_table_buffer,
18868 miss_shader_binding_offset,
18869 miss_shader_binding_stride,
18870 hit_shader_binding_table_buffer,
18871 hit_shader_binding_offset,
18872 hit_shader_binding_stride,
18873 callable_shader_binding_table_buffer,
18874 callable_shader_binding_offset,
18875 callable_shader_binding_stride,
18876 width,
18877 height,
18878 depth,
18879 )
18880 },
18881 }
18882 }
18883 extern "system" fn create_ray_tracing_pipelines_nv(
18884 device: vk::Device,
18885 pipeline_cache: vk::PipelineCache,
18886 create_info_count: u32,
18887 p_create_infos: *const vk::RayTracingPipelineCreateInfoNV,
18888 p_allocator: *const vk::AllocationCallbacks,
18889 p_pipelines: *mut vk::Pipeline,
18890 ) -> vk::Result {
18891 let global = Self::instance();
18892 let device_info = global.get_device_info(device).unwrap();
18894 let dispatch_table = &device_info.dispatch_table.nv_ray_tracing;
18895 let layer_result = device_info
18896 .customized_info
18897 .borrow()
18898 .hooks()
18899 .create_ray_tracing_pipelines_nv(
18900 pipeline_cache,
18901 unsafe { slice_from_raw_parts(p_create_infos, create_info_count) },
18902 unsafe { p_allocator.as_ref() },
18903 );
18904 match layer_result {
18905 LayerResult::Handled(res) => match res {
18906 Ok(res) => {
18907 unsafe {
18908 std::slice::from_raw_parts_mut(
18909 p_pipelines,
18910 create_info_count.try_into().unwrap(),
18911 )
18912 }
18913 .copy_from_slice(&res);
18914 vk::Result::SUCCESS
18915 }
18916 Err(e) => e,
18917 },
18918 LayerResult::Unhandled => unsafe {
18919 (dispatch_table.create_ray_tracing_pipelines_nv)(
18920 device,
18921 pipeline_cache,
18922 create_info_count,
18923 p_create_infos,
18924 p_allocator,
18925 p_pipelines,
18926 )
18927 },
18928 }
18929 }
18930 extern "system" fn get_ray_tracing_shader_group_handles_khr(
18931 device: vk::Device,
18932 pipeline: vk::Pipeline,
18933 first_group: u32,
18934 group_count: u32,
18935 data_size: usize,
18936 p_data: *mut c_void,
18937 ) -> vk::Result {
18938 let global = Self::instance();
18939 let device_info = global.get_device_info(device).unwrap();
18941 let dispatch_table = &device_info.dispatch_table.khr_ray_tracing_pipeline;
18942 let layer_result = device_info
18943 .customized_info
18944 .borrow()
18945 .hooks()
18946 .get_ray_tracing_shader_group_handles_khr(pipeline, first_group, group_count, unsafe {
18947 uninit_slice_from_raw_parts_mut(p_data as *mut u8, data_size)
18948 });
18949 match layer_result {
18950 LayerResult::Handled(res) => match res {
18951 Ok(()) => vk::Result::SUCCESS,
18952 Err(e) => e,
18953 },
18954 LayerResult::Unhandled => unsafe {
18955 (dispatch_table.get_ray_tracing_shader_group_handles_khr)(
18956 device,
18957 pipeline,
18958 first_group,
18959 group_count,
18960 data_size,
18961 p_data,
18962 )
18963 },
18964 }
18965 }
18966 extern "system" fn get_acceleration_structure_handle_nv(
18967 device: vk::Device,
18968 acceleration_structure: vk::AccelerationStructureNV,
18969 data_size: usize,
18970 p_data: *mut c_void,
18971 ) -> vk::Result {
18972 let global = Self::instance();
18973 let device_info = global.get_device_info(device).unwrap();
18975 let dispatch_table = &device_info.dispatch_table.nv_ray_tracing;
18976 let layer_result = device_info
18977 .customized_info
18978 .borrow()
18979 .hooks()
18980 .get_acceleration_structure_handle_nv(acceleration_structure, unsafe {
18981 uninit_slice_from_raw_parts_mut(p_data as *mut u8, data_size)
18982 });
18983 match layer_result {
18984 LayerResult::Handled(res) => match res {
18985 Ok(()) => vk::Result::SUCCESS,
18986 Err(e) => e,
18987 },
18988 LayerResult::Unhandled => unsafe {
18989 (dispatch_table.get_acceleration_structure_handle_nv)(
18990 device,
18991 acceleration_structure,
18992 data_size,
18993 p_data,
18994 )
18995 },
18996 }
18997 }
18998 extern "system" fn cmd_write_acceleration_structures_properties_nv(
18999 command_buffer: vk::CommandBuffer,
19000 acceleration_structure_count: u32,
19001 p_acceleration_structures: *const vk::AccelerationStructureNV,
19002 query_type: vk::QueryType,
19003 query_pool: vk::QueryPool,
19004 first_query: u32,
19005 ) {
19006 let global = Self::instance();
19007 let device_info = global.get_device_info(command_buffer).unwrap();
19009 let dispatch_table = &device_info.dispatch_table.nv_ray_tracing;
19010 let layer_result = device_info
19011 .customized_info
19012 .borrow()
19013 .hooks()
19014 .cmd_write_acceleration_structures_properties_nv(
19015 command_buffer,
19016 unsafe {
19017 slice_from_raw_parts(p_acceleration_structures, acceleration_structure_count)
19018 },
19019 query_type,
19020 query_pool,
19021 first_query,
19022 );
19023 match layer_result {
19024 LayerResult::Handled(res) => res,
19025 LayerResult::Unhandled => unsafe {
19026 (dispatch_table.cmd_write_acceleration_structures_properties_nv)(
19027 command_buffer,
19028 acceleration_structure_count,
19029 p_acceleration_structures,
19030 query_type,
19031 query_pool,
19032 first_query,
19033 )
19034 },
19035 }
19036 }
19037 extern "system" fn compile_deferred_nv(
19038 device: vk::Device,
19039 pipeline: vk::Pipeline,
19040 shader: u32,
19041 ) -> vk::Result {
19042 let global = Self::instance();
19043 let device_info = global.get_device_info(device).unwrap();
19045 let dispatch_table = &device_info.dispatch_table.nv_ray_tracing;
19046 let layer_result = device_info
19047 .customized_info
19048 .borrow()
19049 .hooks()
19050 .compile_deferred_nv(pipeline, shader);
19051 match layer_result {
19052 LayerResult::Handled(res) => match res {
19053 Ok(()) => vk::Result::SUCCESS,
19054 Err(e) => e,
19055 },
19056 LayerResult::Unhandled => unsafe {
19057 (dispatch_table.compile_deferred_nv)(device, pipeline, shader)
19058 },
19059 }
19060 }
19061 extern "system" fn get_memory_host_pointer_properties_ext(
19062 device: vk::Device,
19063 handle_type: vk::ExternalMemoryHandleTypeFlags,
19064 p_host_pointer: *const c_void,
19065 p_memory_host_pointer_properties: *mut vk::MemoryHostPointerPropertiesEXT,
19066 ) -> vk::Result {
19067 let global = Self::instance();
19068 let device_info = global.get_device_info(device).unwrap();
19070 let dispatch_table = &device_info.dispatch_table.ext_external_memory_host;
19071 let layer_result = device_info
19072 .customized_info
19073 .borrow()
19074 .hooks()
19075 .get_memory_host_pointer_properties_ext(
19076 handle_type,
19077 p_host_pointer,
19078 unsafe { ptr_as_uninit_mut(p_memory_host_pointer_properties) }.unwrap(),
19079 );
19080 match layer_result {
19081 LayerResult::Handled(res) => match res {
19082 Ok(()) => vk::Result::SUCCESS,
19083 Err(e) => e,
19084 },
19085 LayerResult::Unhandled => unsafe {
19086 (dispatch_table.get_memory_host_pointer_properties_ext)(
19087 device,
19088 handle_type,
19089 p_host_pointer,
19090 p_memory_host_pointer_properties,
19091 )
19092 },
19093 }
19094 }
19095 extern "system" fn cmd_write_buffer_marker_amd(
19096 command_buffer: vk::CommandBuffer,
19097 pipeline_stage: vk::PipelineStageFlags,
19098 dst_buffer: vk::Buffer,
19099 dst_offset: vk::DeviceSize,
19100 marker: u32,
19101 ) {
19102 let global = Self::instance();
19103 let device_info = global.get_device_info(command_buffer).unwrap();
19105 let dispatch_table = &device_info.dispatch_table.amd_buffer_marker;
19106 let layer_result = device_info
19107 .customized_info
19108 .borrow()
19109 .hooks()
19110 .cmd_write_buffer_marker_amd(
19111 command_buffer,
19112 pipeline_stage,
19113 dst_buffer,
19114 dst_offset,
19115 marker,
19116 );
19117 match layer_result {
19118 LayerResult::Handled(res) => res,
19119 LayerResult::Unhandled => unsafe {
19120 (dispatch_table.cmd_write_buffer_marker_amd)(
19121 command_buffer,
19122 pipeline_stage,
19123 dst_buffer,
19124 dst_offset,
19125 marker,
19126 )
19127 },
19128 }
19129 }
19130 extern "system" fn get_calibrated_timestamps_ext(
19131 device: vk::Device,
19132 timestamp_count: u32,
19133 p_timestamp_infos: *const vk::CalibratedTimestampInfoEXT,
19134 p_timestamps: *mut u64,
19135 p_max_deviation: *mut u64,
19136 ) -> vk::Result {
19137 let global = Self::instance();
19138 let device_info = global.get_device_info(device).unwrap();
19140 let dispatch_table = &device_info.dispatch_table.ext_calibrated_timestamps;
19141 let layer_result = device_info
19142 .customized_info
19143 .borrow()
19144 .hooks()
19145 .get_calibrated_timestamps_ext(
19146 unsafe { slice_from_raw_parts(p_timestamp_infos, timestamp_count) },
19147 unsafe { uninit_slice_from_raw_parts_mut(p_timestamps, timestamp_count) },
19148 );
19149 match layer_result {
19150 LayerResult::Handled(res) => match res {
19151 Ok(res) => {
19152 *unsafe { p_max_deviation.as_mut() }.unwrap() = res;
19153 vk::Result::SUCCESS
19154 }
19155 Err(e) => e,
19156 },
19157 LayerResult::Unhandled => unsafe {
19158 (dispatch_table.get_calibrated_timestamps_ext)(
19159 device,
19160 timestamp_count,
19161 p_timestamp_infos,
19162 p_timestamps,
19163 p_max_deviation,
19164 )
19165 },
19166 }
19167 }
19168 extern "system" fn cmd_draw_mesh_tasks_nv(
19169 command_buffer: vk::CommandBuffer,
19170 task_count: u32,
19171 first_task: u32,
19172 ) {
19173 let global = Self::instance();
19174 let device_info = global.get_device_info(command_buffer).unwrap();
19176 let dispatch_table = &device_info.dispatch_table.nv_mesh_shader;
19177 let layer_result = device_info
19178 .customized_info
19179 .borrow()
19180 .hooks()
19181 .cmd_draw_mesh_tasks_nv(command_buffer, task_count, first_task);
19182 match layer_result {
19183 LayerResult::Handled(res) => res,
19184 LayerResult::Unhandled => unsafe {
19185 (dispatch_table.cmd_draw_mesh_tasks_nv)(command_buffer, task_count, first_task)
19186 },
19187 }
19188 }
19189 extern "system" fn cmd_draw_mesh_tasks_indirect_nv(
19190 command_buffer: vk::CommandBuffer,
19191 buffer: vk::Buffer,
19192 offset: vk::DeviceSize,
19193 draw_count: u32,
19194 stride: u32,
19195 ) {
19196 let global = Self::instance();
19197 let device_info = global.get_device_info(command_buffer).unwrap();
19199 let dispatch_table = &device_info.dispatch_table.nv_mesh_shader;
19200 let layer_result = device_info
19201 .customized_info
19202 .borrow()
19203 .hooks()
19204 .cmd_draw_mesh_tasks_indirect_nv(command_buffer, buffer, offset, draw_count, stride);
19205 match layer_result {
19206 LayerResult::Handled(res) => res,
19207 LayerResult::Unhandled => unsafe {
19208 (dispatch_table.cmd_draw_mesh_tasks_indirect_nv)(
19209 command_buffer,
19210 buffer,
19211 offset,
19212 draw_count,
19213 stride,
19214 )
19215 },
19216 }
19217 }
19218 extern "system" fn cmd_draw_mesh_tasks_indirect_count_nv(
19219 command_buffer: vk::CommandBuffer,
19220 buffer: vk::Buffer,
19221 offset: vk::DeviceSize,
19222 count_buffer: vk::Buffer,
19223 count_buffer_offset: vk::DeviceSize,
19224 max_draw_count: u32,
19225 stride: u32,
19226 ) {
19227 let global = Self::instance();
19228 let device_info = global.get_device_info(command_buffer).unwrap();
19230 let dispatch_table = &device_info.dispatch_table.nv_mesh_shader;
19231 let layer_result = device_info
19232 .customized_info
19233 .borrow()
19234 .hooks()
19235 .cmd_draw_mesh_tasks_indirect_count_nv(
19236 command_buffer,
19237 buffer,
19238 offset,
19239 count_buffer,
19240 count_buffer_offset,
19241 max_draw_count,
19242 stride,
19243 );
19244 match layer_result {
19245 LayerResult::Handled(res) => res,
19246 LayerResult::Unhandled => unsafe {
19247 (dispatch_table.cmd_draw_mesh_tasks_indirect_count_nv)(
19248 command_buffer,
19249 buffer,
19250 offset,
19251 count_buffer,
19252 count_buffer_offset,
19253 max_draw_count,
19254 stride,
19255 )
19256 },
19257 }
19258 }
19259 extern "system" fn cmd_set_exclusive_scissor_nv(
19260 command_buffer: vk::CommandBuffer,
19261 first_exclusive_scissor: u32,
19262 exclusive_scissor_count: u32,
19263 p_exclusive_scissors: *const vk::Rect2D,
19264 ) {
19265 let global = Self::instance();
19266 let device_info = global.get_device_info(command_buffer).unwrap();
19268 let dispatch_table = &device_info.dispatch_table.nv_scissor_exclusive;
19269 let layer_result = device_info
19270 .customized_info
19271 .borrow()
19272 .hooks()
19273 .cmd_set_exclusive_scissor_nv(command_buffer, first_exclusive_scissor, unsafe {
19274 slice_from_raw_parts(p_exclusive_scissors, exclusive_scissor_count)
19275 });
19276 match layer_result {
19277 LayerResult::Handled(res) => res,
19278 LayerResult::Unhandled => unsafe {
19279 (dispatch_table.cmd_set_exclusive_scissor_nv)(
19280 command_buffer,
19281 first_exclusive_scissor,
19282 exclusive_scissor_count,
19283 p_exclusive_scissors,
19284 )
19285 },
19286 }
19287 }
19288 extern "system" fn cmd_set_checkpoint_nv(
19289 command_buffer: vk::CommandBuffer,
19290 p_checkpoint_marker: *const c_void,
19291 ) {
19292 let global = Self::instance();
19293 let device_info = global.get_device_info(command_buffer).unwrap();
19295 let dispatch_table = &device_info.dispatch_table.nv_device_diagnostic_checkpoints;
19296 let layer_result = device_info
19297 .customized_info
19298 .borrow()
19299 .hooks()
19300 .cmd_set_checkpoint_nv(command_buffer, p_checkpoint_marker);
19301 match layer_result {
19302 LayerResult::Handled(res) => res,
19303 LayerResult::Unhandled => unsafe {
19304 (dispatch_table.cmd_set_checkpoint_nv)(command_buffer, p_checkpoint_marker)
19305 },
19306 }
19307 }
19308 extern "system" fn get_queue_checkpoint_data_nv(
19309 queue: vk::Queue,
19310 p_checkpoint_data_count: *mut u32,
19311 p_checkpoint_data: *mut vk::CheckpointDataNV,
19312 ) {
19313 let global = Self::instance();
19314 let device_info = global.get_device_info(queue).unwrap();
19316 let dispatch_table = &device_info.dispatch_table.nv_device_diagnostic_checkpoints;
19317 let layer_result = device_info
19318 .customized_info
19319 .borrow()
19320 .hooks()
19321 .get_queue_checkpoint_data_nv(
19322 queue,
19323 unsafe { ptr_as_uninit_mut(p_checkpoint_data_count) }.unwrap(),
19324 unsafe {
19325 maybe_uninit_slice_from_raw_parts_mut(
19326 p_checkpoint_data,
19327 p_checkpoint_data_count,
19328 )
19329 },
19330 );
19331 match layer_result {
19332 LayerResult::Handled(res) => res,
19333 LayerResult::Unhandled => unsafe {
19334 (dispatch_table.get_queue_checkpoint_data_nv)(
19335 queue,
19336 p_checkpoint_data_count,
19337 p_checkpoint_data,
19338 )
19339 },
19340 }
19341 }
19342 extern "system" fn initialize_performance_api_intel(
19343 device: vk::Device,
19344 p_initialize_info: *const vk::InitializePerformanceApiInfoINTEL,
19345 ) -> vk::Result {
19346 let global = Self::instance();
19347 let device_info = global.get_device_info(device).unwrap();
19349 let dispatch_table = &device_info.dispatch_table.intel_performance_query;
19350 let layer_result = device_info
19351 .customized_info
19352 .borrow()
19353 .hooks()
19354 .initialize_performance_api_intel(unsafe { p_initialize_info.as_ref() }.unwrap());
19355 match layer_result {
19356 LayerResult::Handled(res) => match res {
19357 Ok(()) => vk::Result::SUCCESS,
19358 Err(e) => e,
19359 },
19360 LayerResult::Unhandled => unsafe {
19361 (dispatch_table.initialize_performance_api_intel)(device, p_initialize_info)
19362 },
19363 }
19364 }
19365 extern "system" fn uninitialize_performance_api_intel(device: vk::Device) {
19366 let global = Self::instance();
19367 let device_info = global.get_device_info(device).unwrap();
19369 let dispatch_table = &device_info.dispatch_table.intel_performance_query;
19370 let layer_result = device_info
19371 .customized_info
19372 .borrow()
19373 .hooks()
19374 .uninitialize_performance_api_intel();
19375 match layer_result {
19376 LayerResult::Handled(res) => res,
19377 LayerResult::Unhandled => unsafe {
19378 (dispatch_table.uninitialize_performance_api_intel)(device)
19379 },
19380 }
19381 }
19382 extern "system" fn cmd_set_performance_marker_intel(
19383 command_buffer: vk::CommandBuffer,
19384 p_marker_info: *const vk::PerformanceMarkerInfoINTEL,
19385 ) -> vk::Result {
19386 let global = Self::instance();
19387 let device_info = global.get_device_info(command_buffer).unwrap();
19389 let dispatch_table = &device_info.dispatch_table.intel_performance_query;
19390 let layer_result = device_info
19391 .customized_info
19392 .borrow()
19393 .hooks()
19394 .cmd_set_performance_marker_intel(
19395 command_buffer,
19396 unsafe { p_marker_info.as_ref() }.unwrap(),
19397 );
19398 match layer_result {
19399 LayerResult::Handled(res) => match res {
19400 Ok(()) => vk::Result::SUCCESS,
19401 Err(e) => e,
19402 },
19403 LayerResult::Unhandled => unsafe {
19404 (dispatch_table.cmd_set_performance_marker_intel)(command_buffer, p_marker_info)
19405 },
19406 }
19407 }
19408 extern "system" fn cmd_set_performance_stream_marker_intel(
19409 command_buffer: vk::CommandBuffer,
19410 p_marker_info: *const vk::PerformanceStreamMarkerInfoINTEL,
19411 ) -> vk::Result {
19412 let global = Self::instance();
19413 let device_info = global.get_device_info(command_buffer).unwrap();
19415 let dispatch_table = &device_info.dispatch_table.intel_performance_query;
19416 let layer_result = device_info
19417 .customized_info
19418 .borrow()
19419 .hooks()
19420 .cmd_set_performance_stream_marker_intel(
19421 command_buffer,
19422 unsafe { p_marker_info.as_ref() }.unwrap(),
19423 );
19424 match layer_result {
19425 LayerResult::Handled(res) => match res {
19426 Ok(()) => vk::Result::SUCCESS,
19427 Err(e) => e,
19428 },
19429 LayerResult::Unhandled => unsafe {
19430 (dispatch_table.cmd_set_performance_stream_marker_intel)(
19431 command_buffer,
19432 p_marker_info,
19433 )
19434 },
19435 }
19436 }
19437 extern "system" fn cmd_set_performance_override_intel(
19438 command_buffer: vk::CommandBuffer,
19439 p_override_info: *const vk::PerformanceOverrideInfoINTEL,
19440 ) -> vk::Result {
19441 let global = Self::instance();
19442 let device_info = global.get_device_info(command_buffer).unwrap();
19444 let dispatch_table = &device_info.dispatch_table.intel_performance_query;
19445 let layer_result = device_info
19446 .customized_info
19447 .borrow()
19448 .hooks()
19449 .cmd_set_performance_override_intel(
19450 command_buffer,
19451 unsafe { p_override_info.as_ref() }.unwrap(),
19452 );
19453 match layer_result {
19454 LayerResult::Handled(res) => match res {
19455 Ok(()) => vk::Result::SUCCESS,
19456 Err(e) => e,
19457 },
19458 LayerResult::Unhandled => unsafe {
19459 (dispatch_table.cmd_set_performance_override_intel)(command_buffer, p_override_info)
19460 },
19461 }
19462 }
19463 extern "system" fn acquire_performance_configuration_intel(
19464 device: vk::Device,
19465 p_acquire_info: *const vk::PerformanceConfigurationAcquireInfoINTEL,
19466 p_configuration: *mut vk::PerformanceConfigurationINTEL,
19467 ) -> vk::Result {
19468 let global = Self::instance();
19469 let device_info = global.get_device_info(device).unwrap();
19471 let dispatch_table = &device_info.dispatch_table.intel_performance_query;
19472 let layer_result = device_info
19473 .customized_info
19474 .borrow()
19475 .hooks()
19476 .acquire_performance_configuration_intel(unsafe { p_acquire_info.as_ref() }.unwrap());
19477 match layer_result {
19478 LayerResult::Handled(res) => match res {
19479 Ok(res) => {
19480 *unsafe { p_configuration.as_mut() }.unwrap() = res;
19481 vk::Result::SUCCESS
19482 }
19483 Err(e) => e,
19484 },
19485 LayerResult::Unhandled => unsafe {
19486 (dispatch_table.acquire_performance_configuration_intel)(
19487 device,
19488 p_acquire_info,
19489 p_configuration,
19490 )
19491 },
19492 }
19493 }
19494 extern "system" fn release_performance_configuration_intel(
19495 device: vk::Device,
19496 configuration: vk::PerformanceConfigurationINTEL,
19497 ) -> vk::Result {
19498 let global = Self::instance();
19499 let device_info = global.get_device_info(device).unwrap();
19501 let dispatch_table = &device_info.dispatch_table.intel_performance_query;
19502 let layer_result = device_info
19503 .customized_info
19504 .borrow()
19505 .hooks()
19506 .release_performance_configuration_intel(configuration);
19507 match layer_result {
19508 LayerResult::Handled(res) => match res {
19509 Ok(()) => vk::Result::SUCCESS,
19510 Err(e) => e,
19511 },
19512 LayerResult::Unhandled => unsafe {
19513 (dispatch_table.release_performance_configuration_intel)(device, configuration)
19514 },
19515 }
19516 }
19517 extern "system" fn queue_set_performance_configuration_intel(
19518 queue: vk::Queue,
19519 configuration: vk::PerformanceConfigurationINTEL,
19520 ) -> vk::Result {
19521 let global = Self::instance();
19522 let device_info = global.get_device_info(queue).unwrap();
19524 let dispatch_table = &device_info.dispatch_table.intel_performance_query;
19525 let layer_result = device_info
19526 .customized_info
19527 .borrow()
19528 .hooks()
19529 .queue_set_performance_configuration_intel(queue, configuration);
19530 match layer_result {
19531 LayerResult::Handled(res) => match res {
19532 Ok(()) => vk::Result::SUCCESS,
19533 Err(e) => e,
19534 },
19535 LayerResult::Unhandled => unsafe {
19536 (dispatch_table.queue_set_performance_configuration_intel)(queue, configuration)
19537 },
19538 }
19539 }
19540 extern "system" fn get_performance_parameter_intel(
19541 device: vk::Device,
19542 parameter: vk::PerformanceParameterTypeINTEL,
19543 p_value: *mut vk::PerformanceValueINTEL,
19544 ) -> vk::Result {
19545 let global = Self::instance();
19546 let device_info = global.get_device_info(device).unwrap();
19548 let dispatch_table = &device_info.dispatch_table.intel_performance_query;
19549 let layer_result = device_info
19550 .customized_info
19551 .borrow()
19552 .hooks()
19553 .get_performance_parameter_intel(
19554 parameter,
19555 unsafe { ptr_as_uninit_mut(p_value) }.unwrap(),
19556 );
19557 match layer_result {
19558 LayerResult::Handled(res) => match res {
19559 Ok(()) => vk::Result::SUCCESS,
19560 Err(e) => e,
19561 },
19562 LayerResult::Unhandled => unsafe {
19563 (dispatch_table.get_performance_parameter_intel)(device, parameter, p_value)
19564 },
19565 }
19566 }
19567 extern "system" fn set_local_dimming_amd(
19568 device: vk::Device,
19569 swap_chain: vk::SwapchainKHR,
19570 local_dimming_enable: vk::Bool32,
19571 ) {
19572 let global = Self::instance();
19573 let device_info = global.get_device_info(device).unwrap();
19575 let dispatch_table = &device_info.dispatch_table.amd_display_native_hdr;
19576 let layer_result = device_info
19577 .customized_info
19578 .borrow()
19579 .hooks()
19580 .set_local_dimming_amd(swap_chain, local_dimming_enable == vk::TRUE);
19581 match layer_result {
19582 LayerResult::Handled(res) => res,
19583 LayerResult::Unhandled => unsafe {
19584 (dispatch_table.set_local_dimming_amd)(device, swap_chain, local_dimming_enable)
19585 },
19586 }
19587 }
19588 extern "system" fn acquire_full_screen_exclusive_mode_ext(
19589 device: vk::Device,
19590 swapchain: vk::SwapchainKHR,
19591 ) -> vk::Result {
19592 let global = Self::instance();
19593 let device_info = global.get_device_info(device).unwrap();
19595 let dispatch_table = &device_info.dispatch_table.ext_full_screen_exclusive;
19596 let layer_result = device_info
19597 .customized_info
19598 .borrow()
19599 .hooks()
19600 .acquire_full_screen_exclusive_mode_ext(swapchain);
19601 match layer_result {
19602 LayerResult::Handled(res) => match res {
19603 Ok(()) => vk::Result::SUCCESS,
19604 Err(e) => e,
19605 },
19606 LayerResult::Unhandled => unsafe {
19607 (dispatch_table.acquire_full_screen_exclusive_mode_ext)(device, swapchain)
19608 },
19609 }
19610 }
19611 extern "system" fn release_full_screen_exclusive_mode_ext(
19612 device: vk::Device,
19613 swapchain: vk::SwapchainKHR,
19614 ) -> vk::Result {
19615 let global = Self::instance();
19616 let device_info = global.get_device_info(device).unwrap();
19618 let dispatch_table = &device_info.dispatch_table.ext_full_screen_exclusive;
19619 let layer_result = device_info
19620 .customized_info
19621 .borrow()
19622 .hooks()
19623 .release_full_screen_exclusive_mode_ext(swapchain);
19624 match layer_result {
19625 LayerResult::Handled(res) => match res {
19626 Ok(()) => vk::Result::SUCCESS,
19627 Err(e) => e,
19628 },
19629 LayerResult::Unhandled => unsafe {
19630 (dispatch_table.release_full_screen_exclusive_mode_ext)(device, swapchain)
19631 },
19632 }
19633 }
19634 extern "system" fn get_device_group_surface_present_modes2_ext(
19635 device: vk::Device,
19636 p_surface_info: *const vk::PhysicalDeviceSurfaceInfo2KHR,
19637 p_modes: *mut vk::DeviceGroupPresentModeFlagsKHR,
19638 ) -> vk::Result {
19639 let global = Self::instance();
19640 let device_info = global.get_device_info(device).unwrap();
19642 let dispatch_table = &device_info.dispatch_table.ext_full_screen_exclusive;
19643 let layer_result = device_info
19644 .customized_info
19645 .borrow()
19646 .hooks()
19647 .get_device_group_surface_present_modes2_ext(
19648 unsafe { p_surface_info.as_ref() }.unwrap(),
19649 );
19650 match layer_result {
19651 LayerResult::Handled(res) => match res {
19652 Ok(res) => {
19653 *unsafe { p_modes.as_mut() }.unwrap() = res;
19654 vk::Result::SUCCESS
19655 }
19656 Err(e) => e,
19657 },
19658 LayerResult::Unhandled => unsafe {
19659 (dispatch_table.get_device_group_surface_present_modes2_ext)(
19660 device,
19661 p_surface_info,
19662 p_modes,
19663 )
19664 },
19665 }
19666 }
19667 extern "system" fn cmd_set_line_stipple_ext(
19668 command_buffer: vk::CommandBuffer,
19669 line_stipple_factor: u32,
19670 line_stipple_pattern: u16,
19671 ) {
19672 let global = Self::instance();
19673 let device_info = global.get_device_info(command_buffer).unwrap();
19675 let dispatch_table = &device_info.dispatch_table.ext_line_rasterization;
19676 let layer_result = device_info
19677 .customized_info
19678 .borrow()
19679 .hooks()
19680 .cmd_set_line_stipple_ext(command_buffer, line_stipple_factor, line_stipple_pattern);
19681 match layer_result {
19682 LayerResult::Handled(res) => res,
19683 LayerResult::Unhandled => unsafe {
19684 (dispatch_table.cmd_set_line_stipple_ext)(
19685 command_buffer,
19686 line_stipple_factor,
19687 line_stipple_pattern,
19688 )
19689 },
19690 }
19691 }
19692 extern "system" fn release_swapchain_images_ext(
19693 device: vk::Device,
19694 p_release_info: *const vk::ReleaseSwapchainImagesInfoEXT,
19695 ) -> vk::Result {
19696 let global = Self::instance();
19697 let device_info = global.get_device_info(device).unwrap();
19699 let dispatch_table = &device_info.dispatch_table.ext_swapchain_maintenance1;
19700 let layer_result = device_info
19701 .customized_info
19702 .borrow()
19703 .hooks()
19704 .release_swapchain_images_ext(unsafe { p_release_info.as_ref() }.unwrap());
19705 match layer_result {
19706 LayerResult::Handled(res) => match res {
19707 Ok(()) => vk::Result::SUCCESS,
19708 Err(e) => e,
19709 },
19710 LayerResult::Unhandled => unsafe {
19711 (dispatch_table.release_swapchain_images_ext)(device, p_release_info)
19712 },
19713 }
19714 }
19715 extern "system" fn get_generated_commands_memory_requirements_nv(
19716 device: vk::Device,
19717 p_info: *const vk::GeneratedCommandsMemoryRequirementsInfoNV,
19718 p_memory_requirements: *mut vk::MemoryRequirements2,
19719 ) {
19720 let global = Self::instance();
19721 let device_info = global.get_device_info(device).unwrap();
19723 let dispatch_table = &device_info.dispatch_table.nv_device_generated_commands;
19724 let layer_result = device_info
19725 .customized_info
19726 .borrow()
19727 .hooks()
19728 .get_generated_commands_memory_requirements_nv(
19729 unsafe { p_info.as_ref() }.unwrap(),
19730 unsafe { ptr_as_uninit_mut(p_memory_requirements) }.unwrap(),
19731 );
19732 match layer_result {
19733 LayerResult::Handled(res) => res,
19734 LayerResult::Unhandled => unsafe {
19735 (dispatch_table.get_generated_commands_memory_requirements_nv)(
19736 device,
19737 p_info,
19738 p_memory_requirements,
19739 )
19740 },
19741 }
19742 }
19743 extern "system" fn cmd_preprocess_generated_commands_nv(
19744 command_buffer: vk::CommandBuffer,
19745 p_generated_commands_info: *const vk::GeneratedCommandsInfoNV,
19746 ) {
19747 let global = Self::instance();
19748 let device_info = global.get_device_info(command_buffer).unwrap();
19750 let dispatch_table = &device_info.dispatch_table.nv_device_generated_commands;
19751 let layer_result = device_info
19752 .customized_info
19753 .borrow()
19754 .hooks()
19755 .cmd_preprocess_generated_commands_nv(
19756 command_buffer,
19757 unsafe { p_generated_commands_info.as_ref() }.unwrap(),
19758 );
19759 match layer_result {
19760 LayerResult::Handled(res) => res,
19761 LayerResult::Unhandled => unsafe {
19762 (dispatch_table.cmd_preprocess_generated_commands_nv)(
19763 command_buffer,
19764 p_generated_commands_info,
19765 )
19766 },
19767 }
19768 }
19769 extern "system" fn cmd_execute_generated_commands_nv(
19770 command_buffer: vk::CommandBuffer,
19771 is_preprocessed: vk::Bool32,
19772 p_generated_commands_info: *const vk::GeneratedCommandsInfoNV,
19773 ) {
19774 let global = Self::instance();
19775 let device_info = global.get_device_info(command_buffer).unwrap();
19777 let dispatch_table = &device_info.dispatch_table.nv_device_generated_commands;
19778 let layer_result = device_info
19779 .customized_info
19780 .borrow()
19781 .hooks()
19782 .cmd_execute_generated_commands_nv(
19783 command_buffer,
19784 is_preprocessed == vk::TRUE,
19785 unsafe { p_generated_commands_info.as_ref() }.unwrap(),
19786 );
19787 match layer_result {
19788 LayerResult::Handled(res) => res,
19789 LayerResult::Unhandled => unsafe {
19790 (dispatch_table.cmd_execute_generated_commands_nv)(
19791 command_buffer,
19792 is_preprocessed,
19793 p_generated_commands_info,
19794 )
19795 },
19796 }
19797 }
19798 extern "system" fn cmd_bind_pipeline_shader_group_nv(
19799 command_buffer: vk::CommandBuffer,
19800 pipeline_bind_point: vk::PipelineBindPoint,
19801 pipeline: vk::Pipeline,
19802 group_index: u32,
19803 ) {
19804 let global = Self::instance();
19805 let device_info = global.get_device_info(command_buffer).unwrap();
19807 let dispatch_table = &device_info.dispatch_table.nv_device_generated_commands;
19808 let layer_result = device_info
19809 .customized_info
19810 .borrow()
19811 .hooks()
19812 .cmd_bind_pipeline_shader_group_nv(
19813 command_buffer,
19814 pipeline_bind_point,
19815 pipeline,
19816 group_index,
19817 );
19818 match layer_result {
19819 LayerResult::Handled(res) => res,
19820 LayerResult::Unhandled => unsafe {
19821 (dispatch_table.cmd_bind_pipeline_shader_group_nv)(
19822 command_buffer,
19823 pipeline_bind_point,
19824 pipeline,
19825 group_index,
19826 )
19827 },
19828 }
19829 }
19830 extern "system" fn create_indirect_commands_layout_nv(
19831 device: vk::Device,
19832 p_create_info: *const vk::IndirectCommandsLayoutCreateInfoNV,
19833 p_allocator: *const vk::AllocationCallbacks,
19834 p_indirect_commands_layout: *mut vk::IndirectCommandsLayoutNV,
19835 ) -> vk::Result {
19836 let global = Self::instance();
19837 let device_info = global.get_device_info(device).unwrap();
19839 let dispatch_table = &device_info.dispatch_table.nv_device_generated_commands;
19840 let layer_result = device_info
19841 .customized_info
19842 .borrow()
19843 .hooks()
19844 .create_indirect_commands_layout_nv(
19845 unsafe { p_create_info.as_ref() }.unwrap(),
19846 unsafe { p_allocator.as_ref() },
19847 );
19848 match layer_result {
19849 LayerResult::Handled(res) => match res {
19850 Ok(res) => {
19851 *unsafe { p_indirect_commands_layout.as_mut() }.unwrap() = res;
19852 vk::Result::SUCCESS
19853 }
19854 Err(e) => e,
19855 },
19856 LayerResult::Unhandled => unsafe {
19857 (dispatch_table.create_indirect_commands_layout_nv)(
19858 device,
19859 p_create_info,
19860 p_allocator,
19861 p_indirect_commands_layout,
19862 )
19863 },
19864 }
19865 }
19866 extern "system" fn destroy_indirect_commands_layout_nv(
19867 device: vk::Device,
19868 indirect_commands_layout: vk::IndirectCommandsLayoutNV,
19869 p_allocator: *const vk::AllocationCallbacks,
19870 ) {
19871 let global = Self::instance();
19872 let device_info = global.get_device_info(device).unwrap();
19874 let dispatch_table = &device_info.dispatch_table.nv_device_generated_commands;
19875 let layer_result = device_info
19876 .customized_info
19877 .borrow()
19878 .hooks()
19879 .destroy_indirect_commands_layout_nv(indirect_commands_layout, unsafe {
19880 p_allocator.as_ref()
19881 });
19882 match layer_result {
19883 LayerResult::Handled(res) => res,
19884 LayerResult::Unhandled => unsafe {
19885 (dispatch_table.destroy_indirect_commands_layout_nv)(
19886 device,
19887 indirect_commands_layout,
19888 p_allocator,
19889 )
19890 },
19891 }
19892 }
19893 extern "system" fn export_metal_objects_ext(
19894 device: vk::Device,
19895 p_metal_objects_info: *mut vk::ExportMetalObjectsInfoEXT,
19896 ) {
19897 let global = Self::instance();
19898 let device_info = global.get_device_info(device).unwrap();
19900 let dispatch_table = &device_info.dispatch_table.ext_metal_objects;
19901 let layer_result = device_info
19902 .customized_info
19903 .borrow()
19904 .hooks()
19905 .export_metal_objects_ext(unsafe { ptr_as_uninit_mut(p_metal_objects_info) }.unwrap());
19906 match layer_result {
19907 LayerResult::Handled(res) => res,
19908 LayerResult::Unhandled => unsafe {
19909 (dispatch_table.export_metal_objects_ext)(device, p_metal_objects_info)
19910 },
19911 }
19912 }
19913 extern "system" fn get_descriptor_set_layout_size_ext(
19914 device: vk::Device,
19915 layout: vk::DescriptorSetLayout,
19916 p_layout_size_in_bytes: *mut vk::DeviceSize,
19917 ) {
19918 let global = Self::instance();
19919 let device_info = global.get_device_info(device).unwrap();
19921 let dispatch_table = &device_info.dispatch_table.ext_descriptor_buffer;
19922 let layer_result = device_info
19923 .customized_info
19924 .borrow()
19925 .hooks()
19926 .get_descriptor_set_layout_size_ext(layout);
19927 match layer_result {
19928 LayerResult::Handled(res) => {
19929 *unsafe { p_layout_size_in_bytes.as_mut() }.unwrap() = res;
19930 }
19931 LayerResult::Unhandled => unsafe {
19932 (dispatch_table.get_descriptor_set_layout_size_ext)(
19933 device,
19934 layout,
19935 p_layout_size_in_bytes,
19936 )
19937 },
19938 }
19939 }
19940 extern "system" fn get_descriptor_set_layout_binding_offset_ext(
19941 device: vk::Device,
19942 layout: vk::DescriptorSetLayout,
19943 binding: u32,
19944 p_offset: *mut vk::DeviceSize,
19945 ) {
19946 let global = Self::instance();
19947 let device_info = global.get_device_info(device).unwrap();
19949 let dispatch_table = &device_info.dispatch_table.ext_descriptor_buffer;
19950 let layer_result = device_info
19951 .customized_info
19952 .borrow()
19953 .hooks()
19954 .get_descriptor_set_layout_binding_offset_ext(layout, binding);
19955 match layer_result {
19956 LayerResult::Handled(res) => {
19957 *unsafe { p_offset.as_mut() }.unwrap() = res;
19958 }
19959 LayerResult::Unhandled => unsafe {
19960 (dispatch_table.get_descriptor_set_layout_binding_offset_ext)(
19961 device, layout, binding, p_offset,
19962 )
19963 },
19964 }
19965 }
19966 extern "system" fn get_descriptor_ext(
19967 device: vk::Device,
19968 p_descriptor_info: *const vk::DescriptorGetInfoEXT,
19969 data_size: usize,
19970 p_descriptor: *mut c_void,
19971 ) {
19972 let global = Self::instance();
19973 let device_info = global.get_device_info(device).unwrap();
19975 let dispatch_table = &device_info.dispatch_table.ext_descriptor_buffer;
19976 let layer_result = device_info
19977 .customized_info
19978 .borrow()
19979 .hooks()
19980 .get_descriptor_ext(unsafe { p_descriptor_info.as_ref() }.unwrap(), unsafe {
19981 uninit_slice_from_raw_parts_mut(p_descriptor as *mut u8, data_size)
19982 });
19983 match layer_result {
19984 LayerResult::Handled(res) => res,
19985 LayerResult::Unhandled => unsafe {
19986 (dispatch_table.get_descriptor_ext)(
19987 device,
19988 p_descriptor_info,
19989 data_size,
19990 p_descriptor,
19991 )
19992 },
19993 }
19994 }
19995 extern "system" fn cmd_bind_descriptor_buffers_ext(
19996 command_buffer: vk::CommandBuffer,
19997 buffer_count: u32,
19998 p_binding_infos: *const vk::DescriptorBufferBindingInfoEXT,
19999 ) {
20000 let global = Self::instance();
20001 let device_info = global.get_device_info(command_buffer).unwrap();
20003 let dispatch_table = &device_info.dispatch_table.ext_descriptor_buffer;
20004 let layer_result = device_info
20005 .customized_info
20006 .borrow()
20007 .hooks()
20008 .cmd_bind_descriptor_buffers_ext(command_buffer, unsafe {
20009 slice_from_raw_parts(p_binding_infos, buffer_count)
20010 });
20011 match layer_result {
20012 LayerResult::Handled(res) => res,
20013 LayerResult::Unhandled => unsafe {
20014 (dispatch_table.cmd_bind_descriptor_buffers_ext)(
20015 command_buffer,
20016 buffer_count,
20017 p_binding_infos,
20018 )
20019 },
20020 }
20021 }
20022 extern "system" fn cmd_set_descriptor_buffer_offsets_ext(
20023 command_buffer: vk::CommandBuffer,
20024 pipeline_bind_point: vk::PipelineBindPoint,
20025 layout: vk::PipelineLayout,
20026 first_set: u32,
20027 set_count: u32,
20028 p_buffer_indices: *const u32,
20029 p_offsets: *const vk::DeviceSize,
20030 ) {
20031 let global = Self::instance();
20032 let device_info = global.get_device_info(command_buffer).unwrap();
20034 let dispatch_table = &device_info.dispatch_table.ext_descriptor_buffer;
20035 let layer_result = device_info
20036 .customized_info
20037 .borrow()
20038 .hooks()
20039 .cmd_set_descriptor_buffer_offsets_ext(
20040 command_buffer,
20041 pipeline_bind_point,
20042 layout,
20043 first_set,
20044 unsafe { slice_from_raw_parts(p_buffer_indices, set_count) },
20045 unsafe { slice_from_raw_parts(p_offsets, set_count) },
20046 );
20047 match layer_result {
20048 LayerResult::Handled(res) => res,
20049 LayerResult::Unhandled => unsafe {
20050 (dispatch_table.cmd_set_descriptor_buffer_offsets_ext)(
20051 command_buffer,
20052 pipeline_bind_point,
20053 layout,
20054 first_set,
20055 set_count,
20056 p_buffer_indices,
20057 p_offsets,
20058 )
20059 },
20060 }
20061 }
20062 extern "system" fn cmd_bind_descriptor_buffer_embedded_samplers_ext(
20063 command_buffer: vk::CommandBuffer,
20064 pipeline_bind_point: vk::PipelineBindPoint,
20065 layout: vk::PipelineLayout,
20066 set: u32,
20067 ) {
20068 let global = Self::instance();
20069 let device_info = global.get_device_info(command_buffer).unwrap();
20071 let dispatch_table = &device_info.dispatch_table.ext_descriptor_buffer;
20072 let layer_result = device_info
20073 .customized_info
20074 .borrow()
20075 .hooks()
20076 .cmd_bind_descriptor_buffer_embedded_samplers_ext(
20077 command_buffer,
20078 pipeline_bind_point,
20079 layout,
20080 set,
20081 );
20082 match layer_result {
20083 LayerResult::Handled(res) => res,
20084 LayerResult::Unhandled => unsafe {
20085 (dispatch_table.cmd_bind_descriptor_buffer_embedded_samplers_ext)(
20086 command_buffer,
20087 pipeline_bind_point,
20088 layout,
20089 set,
20090 )
20091 },
20092 }
20093 }
20094 extern "system" fn get_buffer_opaque_capture_descriptor_data_ext(
20095 device: vk::Device,
20096 p_info: *const vk::BufferCaptureDescriptorDataInfoEXT,
20097 p_data: *mut c_void,
20098 ) -> vk::Result {
20099 let global = Self::instance();
20100 let device_info = global.get_device_info(device).unwrap();
20102 let dispatch_table = &device_info.dispatch_table.ext_descriptor_buffer;
20103 let layer_result = device_info
20104 .customized_info
20105 .borrow()
20106 .hooks()
20107 .get_buffer_opaque_capture_descriptor_data_ext(
20108 unsafe { p_info.as_ref() }.unwrap(),
20109 p_data,
20110 );
20111 match layer_result {
20112 LayerResult::Handled(res) => match res {
20113 Ok(()) => vk::Result::SUCCESS,
20114 Err(e) => e,
20115 },
20116 LayerResult::Unhandled => unsafe {
20117 (dispatch_table.get_buffer_opaque_capture_descriptor_data_ext)(
20118 device, p_info, p_data,
20119 )
20120 },
20121 }
20122 }
20123 extern "system" fn get_image_opaque_capture_descriptor_data_ext(
20124 device: vk::Device,
20125 p_info: *const vk::ImageCaptureDescriptorDataInfoEXT,
20126 p_data: *mut c_void,
20127 ) -> vk::Result {
20128 let global = Self::instance();
20129 let device_info = global.get_device_info(device).unwrap();
20131 let dispatch_table = &device_info.dispatch_table.ext_descriptor_buffer;
20132 let layer_result = device_info
20133 .customized_info
20134 .borrow()
20135 .hooks()
20136 .get_image_opaque_capture_descriptor_data_ext(
20137 unsafe { p_info.as_ref() }.unwrap(),
20138 p_data,
20139 );
20140 match layer_result {
20141 LayerResult::Handled(res) => match res {
20142 Ok(()) => vk::Result::SUCCESS,
20143 Err(e) => e,
20144 },
20145 LayerResult::Unhandled => unsafe {
20146 (dispatch_table.get_image_opaque_capture_descriptor_data_ext)(
20147 device, p_info, p_data,
20148 )
20149 },
20150 }
20151 }
20152 extern "system" fn get_image_view_opaque_capture_descriptor_data_ext(
20153 device: vk::Device,
20154 p_info: *const vk::ImageViewCaptureDescriptorDataInfoEXT,
20155 p_data: *mut c_void,
20156 ) -> vk::Result {
20157 let global = Self::instance();
20158 let device_info = global.get_device_info(device).unwrap();
20160 let dispatch_table = &device_info.dispatch_table.ext_descriptor_buffer;
20161 let layer_result = device_info
20162 .customized_info
20163 .borrow()
20164 .hooks()
20165 .get_image_view_opaque_capture_descriptor_data_ext(
20166 unsafe { p_info.as_ref() }.unwrap(),
20167 p_data,
20168 );
20169 match layer_result {
20170 LayerResult::Handled(res) => match res {
20171 Ok(()) => vk::Result::SUCCESS,
20172 Err(e) => e,
20173 },
20174 LayerResult::Unhandled => unsafe {
20175 (dispatch_table.get_image_view_opaque_capture_descriptor_data_ext)(
20176 device, p_info, p_data,
20177 )
20178 },
20179 }
20180 }
20181 extern "system" fn get_sampler_opaque_capture_descriptor_data_ext(
20182 device: vk::Device,
20183 p_info: *const vk::SamplerCaptureDescriptorDataInfoEXT,
20184 p_data: *mut c_void,
20185 ) -> vk::Result {
20186 let global = Self::instance();
20187 let device_info = global.get_device_info(device).unwrap();
20189 let dispatch_table = &device_info.dispatch_table.ext_descriptor_buffer;
20190 let layer_result = device_info
20191 .customized_info
20192 .borrow()
20193 .hooks()
20194 .get_sampler_opaque_capture_descriptor_data_ext(
20195 unsafe { p_info.as_ref() }.unwrap(),
20196 p_data,
20197 );
20198 match layer_result {
20199 LayerResult::Handled(res) => match res {
20200 Ok(()) => vk::Result::SUCCESS,
20201 Err(e) => e,
20202 },
20203 LayerResult::Unhandled => unsafe {
20204 (dispatch_table.get_sampler_opaque_capture_descriptor_data_ext)(
20205 device, p_info, p_data,
20206 )
20207 },
20208 }
20209 }
20210 extern "system" fn get_acceleration_structure_opaque_capture_descriptor_data_ext(
20211 device: vk::Device,
20212 p_info: *const vk::AccelerationStructureCaptureDescriptorDataInfoEXT,
20213 p_data: *mut c_void,
20214 ) -> vk::Result {
20215 let global = Self::instance();
20216 let device_info = global.get_device_info(device).unwrap();
20218 let dispatch_table = &device_info.dispatch_table.ext_descriptor_buffer;
20219 let layer_result = device_info
20220 .customized_info
20221 .borrow()
20222 .hooks()
20223 .get_acceleration_structure_opaque_capture_descriptor_data_ext(
20224 unsafe { p_info.as_ref() }.unwrap(),
20225 p_data,
20226 );
20227 match layer_result {
20228 LayerResult::Handled(res) => match res {
20229 Ok(()) => vk::Result::SUCCESS,
20230 Err(e) => e,
20231 },
20232 LayerResult::Unhandled => unsafe {
20233 (dispatch_table.get_acceleration_structure_opaque_capture_descriptor_data_ext)(
20234 device, p_info, p_data,
20235 )
20236 },
20237 }
20238 }
20239 extern "system" fn cmd_set_fragment_shading_rate_enum_nv(
20240 command_buffer: vk::CommandBuffer,
20241 shading_rate: vk::FragmentShadingRateNV,
20242 combiner_ops: *const [vk::FragmentShadingRateCombinerOpKHR; 2],
20243 ) {
20244 let global = Self::instance();
20245 let device_info = global.get_device_info(command_buffer).unwrap();
20247 let dispatch_table = &device_info.dispatch_table.nv_fragment_shading_rate_enums;
20248 let layer_result = device_info
20249 .customized_info
20250 .borrow()
20251 .hooks()
20252 .cmd_set_fragment_shading_rate_enum_nv(
20253 command_buffer,
20254 shading_rate,
20255 unsafe { combiner_ops.as_ref() }.unwrap(),
20256 );
20257 match layer_result {
20258 LayerResult::Handled(res) => res,
20259 LayerResult::Unhandled => unsafe {
20260 (dispatch_table.cmd_set_fragment_shading_rate_enum_nv)(
20261 command_buffer,
20262 shading_rate,
20263 combiner_ops,
20264 )
20265 },
20266 }
20267 }
20268 extern "system" fn get_image_subresource_layout2_ext(
20269 device: vk::Device,
20270 image: vk::Image,
20271 p_subresource: *const vk::ImageSubresource2EXT,
20272 p_layout: *mut vk::SubresourceLayout2EXT,
20273 ) {
20274 let global = Self::instance();
20275 let device_info = global.get_device_info(device).unwrap();
20277 let dispatch_table = &device_info.dispatch_table.ext_image_compression_control;
20278 let layer_result = device_info
20279 .customized_info
20280 .borrow()
20281 .hooks()
20282 .get_image_subresource_layout2_ext(
20283 image,
20284 unsafe { p_subresource.as_ref() }.unwrap(),
20285 unsafe { ptr_as_uninit_mut(p_layout) }.unwrap(),
20286 );
20287 match layer_result {
20288 LayerResult::Handled(res) => res,
20289 LayerResult::Unhandled => unsafe {
20290 (dispatch_table.get_image_subresource_layout2_ext)(
20291 device,
20292 image,
20293 p_subresource,
20294 p_layout,
20295 )
20296 },
20297 }
20298 }
20299 extern "system" fn cmd_set_vertex_input_ext(
20300 command_buffer: vk::CommandBuffer,
20301 vertex_binding_description_count: u32,
20302 p_vertex_binding_descriptions: *const vk::VertexInputBindingDescription2EXT,
20303 vertex_attribute_description_count: u32,
20304 p_vertex_attribute_descriptions: *const vk::VertexInputAttributeDescription2EXT,
20305 ) {
20306 let global = Self::instance();
20307 let device_info = global.get_device_info(command_buffer).unwrap();
20309 let dispatch_table = &device_info.dispatch_table.ext_vertex_input_dynamic_state;
20310 let layer_result = device_info
20311 .customized_info
20312 .borrow()
20313 .hooks()
20314 .cmd_set_vertex_input_ext(
20315 command_buffer,
20316 unsafe {
20317 slice_from_raw_parts(
20318 p_vertex_binding_descriptions,
20319 vertex_binding_description_count,
20320 )
20321 },
20322 unsafe {
20323 slice_from_raw_parts(
20324 p_vertex_attribute_descriptions,
20325 vertex_attribute_description_count,
20326 )
20327 },
20328 );
20329 match layer_result {
20330 LayerResult::Handled(res) => res,
20331 LayerResult::Unhandled => unsafe {
20332 (dispatch_table.cmd_set_vertex_input_ext)(
20333 command_buffer,
20334 vertex_binding_description_count,
20335 p_vertex_binding_descriptions,
20336 vertex_attribute_description_count,
20337 p_vertex_attribute_descriptions,
20338 )
20339 },
20340 }
20341 }
20342 extern "system" fn get_memory_zircon_handle_fuchsia(
20343 device: vk::Device,
20344 p_get_zircon_handle_info: *const vk::MemoryGetZirconHandleInfoFUCHSIA,
20345 p_zircon_handle: *mut vk::zx_handle_t,
20346 ) -> vk::Result {
20347 let global = Self::instance();
20348 let device_info = global.get_device_info(device).unwrap();
20350 let dispatch_table = &device_info.dispatch_table.fuchsia_external_memory;
20351 let layer_result = device_info
20352 .customized_info
20353 .borrow()
20354 .hooks()
20355 .get_memory_zircon_handle_fuchsia(
20356 unsafe { p_get_zircon_handle_info.as_ref() }.unwrap(),
20357 );
20358 match layer_result {
20359 LayerResult::Handled(res) => match res {
20360 Ok(res) => {
20361 *unsafe { p_zircon_handle.as_mut() }.unwrap() = res;
20362 vk::Result::SUCCESS
20363 }
20364 Err(e) => e,
20365 },
20366 LayerResult::Unhandled => unsafe {
20367 (dispatch_table.get_memory_zircon_handle_fuchsia)(
20368 device,
20369 p_get_zircon_handle_info,
20370 p_zircon_handle,
20371 )
20372 },
20373 }
20374 }
20375 extern "system" fn get_memory_zircon_handle_properties_fuchsia(
20376 device: vk::Device,
20377 handle_type: vk::ExternalMemoryHandleTypeFlags,
20378 zircon_handle: vk::zx_handle_t,
20379 p_memory_zircon_handle_properties: *mut vk::MemoryZirconHandlePropertiesFUCHSIA,
20380 ) -> vk::Result {
20381 let global = Self::instance();
20382 let device_info = global.get_device_info(device).unwrap();
20384 let dispatch_table = &device_info.dispatch_table.fuchsia_external_memory;
20385 let layer_result = device_info
20386 .customized_info
20387 .borrow()
20388 .hooks()
20389 .get_memory_zircon_handle_properties_fuchsia(
20390 handle_type,
20391 zircon_handle,
20392 unsafe { ptr_as_uninit_mut(p_memory_zircon_handle_properties) }.unwrap(),
20393 );
20394 match layer_result {
20395 LayerResult::Handled(res) => match res {
20396 Ok(()) => vk::Result::SUCCESS,
20397 Err(e) => e,
20398 },
20399 LayerResult::Unhandled => unsafe {
20400 (dispatch_table.get_memory_zircon_handle_properties_fuchsia)(
20401 device,
20402 handle_type,
20403 zircon_handle,
20404 p_memory_zircon_handle_properties,
20405 )
20406 },
20407 }
20408 }
20409 extern "system" fn import_semaphore_zircon_handle_fuchsia(
20410 device: vk::Device,
20411 p_import_semaphore_zircon_handle_info: *const vk::ImportSemaphoreZirconHandleInfoFUCHSIA,
20412 ) -> vk::Result {
20413 let global = Self::instance();
20414 let device_info = global.get_device_info(device).unwrap();
20416 let dispatch_table = &device_info.dispatch_table.fuchsia_external_semaphore;
20417 let layer_result = device_info
20418 .customized_info
20419 .borrow()
20420 .hooks()
20421 .import_semaphore_zircon_handle_fuchsia(
20422 unsafe { p_import_semaphore_zircon_handle_info.as_ref() }.unwrap(),
20423 );
20424 match layer_result {
20425 LayerResult::Handled(res) => match res {
20426 Ok(()) => vk::Result::SUCCESS,
20427 Err(e) => e,
20428 },
20429 LayerResult::Unhandled => unsafe {
20430 (dispatch_table.import_semaphore_zircon_handle_fuchsia)(
20431 device,
20432 p_import_semaphore_zircon_handle_info,
20433 )
20434 },
20435 }
20436 }
20437 extern "system" fn get_semaphore_zircon_handle_fuchsia(
20438 device: vk::Device,
20439 p_get_zircon_handle_info: *const vk::SemaphoreGetZirconHandleInfoFUCHSIA,
20440 p_zircon_handle: *mut vk::zx_handle_t,
20441 ) -> vk::Result {
20442 let global = Self::instance();
20443 let device_info = global.get_device_info(device).unwrap();
20445 let dispatch_table = &device_info.dispatch_table.fuchsia_external_semaphore;
20446 let layer_result = device_info
20447 .customized_info
20448 .borrow()
20449 .hooks()
20450 .get_semaphore_zircon_handle_fuchsia(
20451 unsafe { p_get_zircon_handle_info.as_ref() }.unwrap(),
20452 );
20453 match layer_result {
20454 LayerResult::Handled(res) => match res {
20455 Ok(res) => {
20456 *unsafe { p_zircon_handle.as_mut() }.unwrap() = res;
20457 vk::Result::SUCCESS
20458 }
20459 Err(e) => e,
20460 },
20461 LayerResult::Unhandled => unsafe {
20462 (dispatch_table.get_semaphore_zircon_handle_fuchsia)(
20463 device,
20464 p_get_zircon_handle_info,
20465 p_zircon_handle,
20466 )
20467 },
20468 }
20469 }
20470 extern "system" fn create_buffer_collection_fuchsia(
20471 device: vk::Device,
20472 p_create_info: *const vk::BufferCollectionCreateInfoFUCHSIA,
20473 p_allocator: *const vk::AllocationCallbacks,
20474 p_collection: *mut vk::BufferCollectionFUCHSIA,
20475 ) -> vk::Result {
20476 let global = Self::instance();
20477 let device_info = global.get_device_info(device).unwrap();
20479 let dispatch_table = &device_info.dispatch_table.fuchsia_buffer_collection;
20480 let layer_result = device_info
20481 .customized_info
20482 .borrow()
20483 .hooks()
20484 .create_buffer_collection_fuchsia(unsafe { p_create_info.as_ref() }.unwrap(), unsafe {
20485 p_allocator.as_ref()
20486 });
20487 match layer_result {
20488 LayerResult::Handled(res) => match res {
20489 Ok(res) => {
20490 *unsafe { p_collection.as_mut() }.unwrap() = res;
20491 vk::Result::SUCCESS
20492 }
20493 Err(e) => e,
20494 },
20495 LayerResult::Unhandled => unsafe {
20496 (dispatch_table.create_buffer_collection_fuchsia)(
20497 device,
20498 p_create_info,
20499 p_allocator,
20500 p_collection,
20501 )
20502 },
20503 }
20504 }
20505 extern "system" fn set_buffer_collection_image_constraints_fuchsia(
20506 device: vk::Device,
20507 collection: vk::BufferCollectionFUCHSIA,
20508 p_image_constraints_info: *const vk::ImageConstraintsInfoFUCHSIA,
20509 ) -> vk::Result {
20510 let global = Self::instance();
20511 let device_info = global.get_device_info(device).unwrap();
20513 let dispatch_table = &device_info.dispatch_table.fuchsia_buffer_collection;
20514 let layer_result = device_info
20515 .customized_info
20516 .borrow()
20517 .hooks()
20518 .set_buffer_collection_image_constraints_fuchsia(
20519 collection,
20520 unsafe { p_image_constraints_info.as_ref() }.unwrap(),
20521 );
20522 match layer_result {
20523 LayerResult::Handled(res) => match res {
20524 Ok(()) => vk::Result::SUCCESS,
20525 Err(e) => e,
20526 },
20527 LayerResult::Unhandled => unsafe {
20528 (dispatch_table.set_buffer_collection_image_constraints_fuchsia)(
20529 device,
20530 collection,
20531 p_image_constraints_info,
20532 )
20533 },
20534 }
20535 }
20536 extern "system" fn set_buffer_collection_buffer_constraints_fuchsia(
20537 device: vk::Device,
20538 collection: vk::BufferCollectionFUCHSIA,
20539 p_buffer_constraints_info: *const vk::BufferConstraintsInfoFUCHSIA,
20540 ) -> vk::Result {
20541 let global = Self::instance();
20542 let device_info = global.get_device_info(device).unwrap();
20544 let dispatch_table = &device_info.dispatch_table.fuchsia_buffer_collection;
20545 let layer_result = device_info
20546 .customized_info
20547 .borrow()
20548 .hooks()
20549 .set_buffer_collection_buffer_constraints_fuchsia(
20550 collection,
20551 unsafe { p_buffer_constraints_info.as_ref() }.unwrap(),
20552 );
20553 match layer_result {
20554 LayerResult::Handled(res) => match res {
20555 Ok(()) => vk::Result::SUCCESS,
20556 Err(e) => e,
20557 },
20558 LayerResult::Unhandled => unsafe {
20559 (dispatch_table.set_buffer_collection_buffer_constraints_fuchsia)(
20560 device,
20561 collection,
20562 p_buffer_constraints_info,
20563 )
20564 },
20565 }
20566 }
20567 extern "system" fn destroy_buffer_collection_fuchsia(
20568 device: vk::Device,
20569 collection: vk::BufferCollectionFUCHSIA,
20570 p_allocator: *const vk::AllocationCallbacks,
20571 ) {
20572 let global = Self::instance();
20573 let device_info = global.get_device_info(device).unwrap();
20575 let dispatch_table = &device_info.dispatch_table.fuchsia_buffer_collection;
20576 let layer_result = device_info
20577 .customized_info
20578 .borrow()
20579 .hooks()
20580 .destroy_buffer_collection_fuchsia(collection, unsafe { p_allocator.as_ref() });
20581 match layer_result {
20582 LayerResult::Handled(res) => res,
20583 LayerResult::Unhandled => unsafe {
20584 (dispatch_table.destroy_buffer_collection_fuchsia)(device, collection, p_allocator)
20585 },
20586 }
20587 }
20588 extern "system" fn get_buffer_collection_properties_fuchsia(
20589 device: vk::Device,
20590 collection: vk::BufferCollectionFUCHSIA,
20591 p_properties: *mut vk::BufferCollectionPropertiesFUCHSIA,
20592 ) -> vk::Result {
20593 let global = Self::instance();
20594 let device_info = global.get_device_info(device).unwrap();
20596 let dispatch_table = &device_info.dispatch_table.fuchsia_buffer_collection;
20597 let layer_result = device_info
20598 .customized_info
20599 .borrow()
20600 .hooks()
20601 .get_buffer_collection_properties_fuchsia(
20602 collection,
20603 unsafe { ptr_as_uninit_mut(p_properties) }.unwrap(),
20604 );
20605 match layer_result {
20606 LayerResult::Handled(res) => match res {
20607 Ok(()) => vk::Result::SUCCESS,
20608 Err(e) => e,
20609 },
20610 LayerResult::Unhandled => unsafe {
20611 (dispatch_table.get_buffer_collection_properties_fuchsia)(
20612 device,
20613 collection,
20614 p_properties,
20615 )
20616 },
20617 }
20618 }
20619 extern "system" fn get_device_subpass_shading_max_workgroup_size_huawei(
20620 device: vk::Device,
20621 renderpass: vk::RenderPass,
20622 p_max_workgroup_size: *mut vk::Extent2D,
20623 ) -> vk::Result {
20624 let global = Self::instance();
20625 let device_info = global.get_device_info(device).unwrap();
20627 let dispatch_table = &device_info.dispatch_table.huawei_subpass_shading;
20628 let layer_result = device_info
20629 .customized_info
20630 .borrow()
20631 .hooks()
20632 .get_device_subpass_shading_max_workgroup_size_huawei(
20633 renderpass,
20634 unsafe { ptr_as_uninit_mut(p_max_workgroup_size) }.unwrap(),
20635 );
20636 match layer_result {
20637 LayerResult::Handled(res) => match res {
20638 Ok(()) => vk::Result::SUCCESS,
20639 Err(e) => e,
20640 },
20641 LayerResult::Unhandled => unsafe {
20642 (dispatch_table.get_device_subpass_shading_max_workgroup_size_huawei)(
20643 device,
20644 renderpass,
20645 p_max_workgroup_size,
20646 )
20647 },
20648 }
20649 }
20650 extern "system" fn cmd_subpass_shading_huawei(command_buffer: vk::CommandBuffer) {
20651 let global = Self::instance();
20652 let device_info = global.get_device_info(command_buffer).unwrap();
20654 let dispatch_table = &device_info.dispatch_table.huawei_subpass_shading;
20655 let layer_result = device_info
20656 .customized_info
20657 .borrow()
20658 .hooks()
20659 .cmd_subpass_shading_huawei(command_buffer);
20660 match layer_result {
20661 LayerResult::Handled(res) => res,
20662 LayerResult::Unhandled => unsafe {
20663 (dispatch_table.cmd_subpass_shading_huawei)(command_buffer)
20664 },
20665 }
20666 }
20667 extern "system" fn cmd_bind_invocation_mask_huawei(
20668 command_buffer: vk::CommandBuffer,
20669 image_view: vk::ImageView,
20670 image_layout: vk::ImageLayout,
20671 ) {
20672 let global = Self::instance();
20673 let device_info = global.get_device_info(command_buffer).unwrap();
20675 let dispatch_table = &device_info.dispatch_table.huawei_invocation_mask;
20676 let layer_result = device_info
20677 .customized_info
20678 .borrow()
20679 .hooks()
20680 .cmd_bind_invocation_mask_huawei(command_buffer, image_view, image_layout);
20681 match layer_result {
20682 LayerResult::Handled(res) => res,
20683 LayerResult::Unhandled => unsafe {
20684 (dispatch_table.cmd_bind_invocation_mask_huawei)(
20685 command_buffer,
20686 image_view,
20687 image_layout,
20688 )
20689 },
20690 }
20691 }
20692 extern "system" fn get_memory_remote_address_nv(
20693 device: vk::Device,
20694 p_memory_get_remote_address_info: *const vk::MemoryGetRemoteAddressInfoNV,
20695 p_address: *mut vk::RemoteAddressNV,
20696 ) -> vk::Result {
20697 let global = Self::instance();
20698 let device_info = global.get_device_info(device).unwrap();
20700 let dispatch_table = &device_info.dispatch_table.nv_external_memory_rdma;
20701 let layer_result = device_info
20702 .customized_info
20703 .borrow()
20704 .hooks()
20705 .get_memory_remote_address_nv(
20706 unsafe { p_memory_get_remote_address_info.as_ref() }.unwrap(),
20707 );
20708 match layer_result {
20709 LayerResult::Handled(res) => match res {
20710 Ok(res) => {
20711 *unsafe { p_address.as_mut() }.unwrap() = res;
20712 vk::Result::SUCCESS
20713 }
20714 Err(e) => e,
20715 },
20716 LayerResult::Unhandled => unsafe {
20717 (dispatch_table.get_memory_remote_address_nv)(
20718 device,
20719 p_memory_get_remote_address_info,
20720 p_address,
20721 )
20722 },
20723 }
20724 }
20725 extern "system" fn get_pipeline_properties_ext(
20726 device: vk::Device,
20727 p_pipeline_info: *const vk::PipelineInfoEXT,
20728 p_pipeline_properties: *mut vk::BaseOutStructure,
20729 ) -> vk::Result {
20730 let global = Self::instance();
20731 let device_info = global.get_device_info(device).unwrap();
20733 let dispatch_table = &device_info.dispatch_table.ext_pipeline_properties;
20734 let layer_result = device_info
20735 .customized_info
20736 .borrow()
20737 .hooks()
20738 .get_pipeline_properties_ext(
20739 unsafe { p_pipeline_info.as_ref() }.unwrap(),
20740 unsafe { ptr_as_uninit_mut(p_pipeline_properties) }.unwrap(),
20741 );
20742 match layer_result {
20743 LayerResult::Handled(res) => match res {
20744 Ok(()) => vk::Result::SUCCESS,
20745 Err(e) => e,
20746 },
20747 LayerResult::Unhandled => unsafe {
20748 (dispatch_table.get_pipeline_properties_ext)(
20749 device,
20750 p_pipeline_info,
20751 p_pipeline_properties,
20752 )
20753 },
20754 }
20755 }
20756 extern "system" fn cmd_set_patch_control_points_ext(
20757 command_buffer: vk::CommandBuffer,
20758 patch_control_points: u32,
20759 ) {
20760 let global = Self::instance();
20761 let device_info = global.get_device_info(command_buffer).unwrap();
20763 let dispatch_table = &device_info.dispatch_table.ext_extended_dynamic_state2;
20764 let layer_result = device_info
20765 .customized_info
20766 .borrow()
20767 .hooks()
20768 .cmd_set_patch_control_points_ext(command_buffer, patch_control_points);
20769 match layer_result {
20770 LayerResult::Handled(res) => res,
20771 LayerResult::Unhandled => unsafe {
20772 (dispatch_table.cmd_set_patch_control_points_ext)(
20773 command_buffer,
20774 patch_control_points,
20775 )
20776 },
20777 }
20778 }
20779 extern "system" fn cmd_set_logic_op_ext(
20780 command_buffer: vk::CommandBuffer,
20781 logic_op: vk::LogicOp,
20782 ) {
20783 let global = Self::instance();
20784 let device_info = global.get_device_info(command_buffer).unwrap();
20786 let dispatch_table = &device_info.dispatch_table.ext_extended_dynamic_state2;
20787 let layer_result = device_info
20788 .customized_info
20789 .borrow()
20790 .hooks()
20791 .cmd_set_logic_op_ext(command_buffer, logic_op);
20792 match layer_result {
20793 LayerResult::Handled(res) => res,
20794 LayerResult::Unhandled => unsafe {
20795 (dispatch_table.cmd_set_logic_op_ext)(command_buffer, logic_op)
20796 },
20797 }
20798 }
20799 extern "system" fn cmd_set_color_write_enable_ext(
20800 command_buffer: vk::CommandBuffer,
20801 attachment_count: u32,
20802 p_color_write_enables: *const vk::Bool32,
20803 ) {
20804 let global = Self::instance();
20805 let device_info = global.get_device_info(command_buffer).unwrap();
20807 let dispatch_table = &device_info.dispatch_table.ext_color_write_enable;
20808 let layer_result = device_info
20809 .customized_info
20810 .borrow()
20811 .hooks()
20812 .cmd_set_color_write_enable_ext(command_buffer, unsafe {
20813 bool_iterator_from_raw_parts(p_color_write_enables, attachment_count)
20814 });
20815 match layer_result {
20816 LayerResult::Handled(res) => res,
20817 LayerResult::Unhandled => unsafe {
20818 (dispatch_table.cmd_set_color_write_enable_ext)(
20819 command_buffer,
20820 attachment_count,
20821 p_color_write_enables,
20822 )
20823 },
20824 }
20825 }
20826 extern "system" fn cmd_draw_multi_ext(
20827 command_buffer: vk::CommandBuffer,
20828 draw_count: u32,
20829 p_vertex_info: *const vk::MultiDrawInfoEXT,
20830 instance_count: u32,
20831 first_instance: u32,
20832 stride: u32,
20833 ) {
20834 let global = Self::instance();
20835 let device_info = global.get_device_info(command_buffer).unwrap();
20837 let dispatch_table = &device_info.dispatch_table.ext_multi_draw;
20838 let layer_result = device_info
20839 .customized_info
20840 .borrow()
20841 .hooks()
20842 .cmd_draw_multi_ext(
20843 command_buffer,
20844 unsafe { slice_from_raw_parts(p_vertex_info, draw_count) },
20845 instance_count,
20846 first_instance,
20847 stride,
20848 );
20849 match layer_result {
20850 LayerResult::Handled(res) => res,
20851 LayerResult::Unhandled => unsafe {
20852 (dispatch_table.cmd_draw_multi_ext)(
20853 command_buffer,
20854 draw_count,
20855 p_vertex_info,
20856 instance_count,
20857 first_instance,
20858 stride,
20859 )
20860 },
20861 }
20862 }
20863 extern "system" fn cmd_draw_multi_indexed_ext(
20864 command_buffer: vk::CommandBuffer,
20865 draw_count: u32,
20866 p_index_info: *const vk::MultiDrawIndexedInfoEXT,
20867 instance_count: u32,
20868 first_instance: u32,
20869 stride: u32,
20870 p_vertex_offset: *const i32,
20871 ) {
20872 let global = Self::instance();
20873 let device_info = global.get_device_info(command_buffer).unwrap();
20875 let dispatch_table = &device_info.dispatch_table.ext_multi_draw;
20876 let layer_result = device_info
20877 .customized_info
20878 .borrow()
20879 .hooks()
20880 .cmd_draw_multi_indexed_ext(
20881 command_buffer,
20882 unsafe { slice_from_raw_parts(p_index_info, draw_count) },
20883 instance_count,
20884 first_instance,
20885 stride,
20886 unsafe { p_vertex_offset.as_ref() },
20887 );
20888 match layer_result {
20889 LayerResult::Handled(res) => res,
20890 LayerResult::Unhandled => unsafe {
20891 (dispatch_table.cmd_draw_multi_indexed_ext)(
20892 command_buffer,
20893 draw_count,
20894 p_index_info,
20895 instance_count,
20896 first_instance,
20897 stride,
20898 p_vertex_offset,
20899 )
20900 },
20901 }
20902 }
20903 extern "system" fn create_micromap_ext(
20904 device: vk::Device,
20905 p_create_info: *const vk::MicromapCreateInfoEXT,
20906 p_allocator: *const vk::AllocationCallbacks,
20907 p_micromap: *mut vk::MicromapEXT,
20908 ) -> vk::Result {
20909 let global = Self::instance();
20910 let device_info = global.get_device_info(device).unwrap();
20912 let dispatch_table = &device_info.dispatch_table.ext_opacity_micromap;
20913 let layer_result = device_info
20914 .customized_info
20915 .borrow()
20916 .hooks()
20917 .create_micromap_ext(unsafe { p_create_info.as_ref() }.unwrap(), unsafe {
20918 p_allocator.as_ref()
20919 });
20920 match layer_result {
20921 LayerResult::Handled(res) => match res {
20922 Ok(res) => {
20923 *unsafe { p_micromap.as_mut() }.unwrap() = res;
20924 vk::Result::SUCCESS
20925 }
20926 Err(e) => e,
20927 },
20928 LayerResult::Unhandled => unsafe {
20929 (dispatch_table.create_micromap_ext)(device, p_create_info, p_allocator, p_micromap)
20930 },
20931 }
20932 }
20933 extern "system" fn destroy_micromap_ext(
20934 device: vk::Device,
20935 micromap: vk::MicromapEXT,
20936 p_allocator: *const vk::AllocationCallbacks,
20937 ) {
20938 let global = Self::instance();
20939 let device_info = global.get_device_info(device).unwrap();
20941 let dispatch_table = &device_info.dispatch_table.ext_opacity_micromap;
20942 let layer_result = device_info
20943 .customized_info
20944 .borrow()
20945 .hooks()
20946 .destroy_micromap_ext(micromap, unsafe { p_allocator.as_ref() });
20947 match layer_result {
20948 LayerResult::Handled(res) => res,
20949 LayerResult::Unhandled => unsafe {
20950 (dispatch_table.destroy_micromap_ext)(device, micromap, p_allocator)
20951 },
20952 }
20953 }
20954 extern "system" fn cmd_build_micromaps_ext(
20955 command_buffer: vk::CommandBuffer,
20956 info_count: u32,
20957 p_infos: *const vk::MicromapBuildInfoEXT,
20958 ) {
20959 let global = Self::instance();
20960 let device_info = global.get_device_info(command_buffer).unwrap();
20962 let dispatch_table = &device_info.dispatch_table.ext_opacity_micromap;
20963 let layer_result = device_info
20964 .customized_info
20965 .borrow()
20966 .hooks()
20967 .cmd_build_micromaps_ext(command_buffer, unsafe {
20968 slice_from_raw_parts(p_infos, info_count)
20969 });
20970 match layer_result {
20971 LayerResult::Handled(res) => res,
20972 LayerResult::Unhandled => unsafe {
20973 (dispatch_table.cmd_build_micromaps_ext)(command_buffer, info_count, p_infos)
20974 },
20975 }
20976 }
20977 extern "system" fn build_micromaps_ext(
20978 device: vk::Device,
20979 deferred_operation: vk::DeferredOperationKHR,
20980 info_count: u32,
20981 p_infos: *const vk::MicromapBuildInfoEXT,
20982 ) -> vk::Result {
20983 let global = Self::instance();
20984 let device_info = global.get_device_info(device).unwrap();
20986 let dispatch_table = &device_info.dispatch_table.ext_opacity_micromap;
20987 let layer_result = device_info
20988 .customized_info
20989 .borrow()
20990 .hooks()
20991 .build_micromaps_ext(deferred_operation, unsafe {
20992 slice_from_raw_parts(p_infos, info_count)
20993 });
20994 match layer_result {
20995 LayerResult::Handled(res) => match res {
20996 Ok(()) => vk::Result::SUCCESS,
20997 Err(e) => e,
20998 },
20999 LayerResult::Unhandled => unsafe {
21000 (dispatch_table.build_micromaps_ext)(
21001 device,
21002 deferred_operation,
21003 info_count,
21004 p_infos,
21005 )
21006 },
21007 }
21008 }
21009 extern "system" fn copy_micromap_ext(
21010 device: vk::Device,
21011 deferred_operation: vk::DeferredOperationKHR,
21012 p_info: *const vk::CopyMicromapInfoEXT,
21013 ) -> vk::Result {
21014 let global = Self::instance();
21015 let device_info = global.get_device_info(device).unwrap();
21017 let dispatch_table = &device_info.dispatch_table.ext_opacity_micromap;
21018 let layer_result = device_info
21019 .customized_info
21020 .borrow()
21021 .hooks()
21022 .copy_micromap_ext(deferred_operation, unsafe { p_info.as_ref() }.unwrap());
21023 match layer_result {
21024 LayerResult::Handled(res) => match res {
21025 Ok(()) => vk::Result::SUCCESS,
21026 Err(e) => e,
21027 },
21028 LayerResult::Unhandled => unsafe {
21029 (dispatch_table.copy_micromap_ext)(device, deferred_operation, p_info)
21030 },
21031 }
21032 }
21033 extern "system" fn copy_micromap_to_memory_ext(
21034 device: vk::Device,
21035 deferred_operation: vk::DeferredOperationKHR,
21036 p_info: *const vk::CopyMicromapToMemoryInfoEXT,
21037 ) -> vk::Result {
21038 let global = Self::instance();
21039 let device_info = global.get_device_info(device).unwrap();
21041 let dispatch_table = &device_info.dispatch_table.ext_opacity_micromap;
21042 let layer_result = device_info
21043 .customized_info
21044 .borrow()
21045 .hooks()
21046 .copy_micromap_to_memory_ext(deferred_operation, unsafe { p_info.as_ref() }.unwrap());
21047 match layer_result {
21048 LayerResult::Handled(res) => match res {
21049 Ok(()) => vk::Result::SUCCESS,
21050 Err(e) => e,
21051 },
21052 LayerResult::Unhandled => unsafe {
21053 (dispatch_table.copy_micromap_to_memory_ext)(device, deferred_operation, p_info)
21054 },
21055 }
21056 }
21057 extern "system" fn copy_memory_to_micromap_ext(
21058 device: vk::Device,
21059 deferred_operation: vk::DeferredOperationKHR,
21060 p_info: *const vk::CopyMemoryToMicromapInfoEXT,
21061 ) -> vk::Result {
21062 let global = Self::instance();
21063 let device_info = global.get_device_info(device).unwrap();
21065 let dispatch_table = &device_info.dispatch_table.ext_opacity_micromap;
21066 let layer_result = device_info
21067 .customized_info
21068 .borrow()
21069 .hooks()
21070 .copy_memory_to_micromap_ext(deferred_operation, unsafe { p_info.as_ref() }.unwrap());
21071 match layer_result {
21072 LayerResult::Handled(res) => match res {
21073 Ok(()) => vk::Result::SUCCESS,
21074 Err(e) => e,
21075 },
21076 LayerResult::Unhandled => unsafe {
21077 (dispatch_table.copy_memory_to_micromap_ext)(device, deferred_operation, p_info)
21078 },
21079 }
21080 }
21081 extern "system" fn write_micromaps_properties_ext(
21082 device: vk::Device,
21083 micromap_count: u32,
21084 p_micromaps: *const vk::MicromapEXT,
21085 query_type: vk::QueryType,
21086 data_size: usize,
21087 p_data: *mut c_void,
21088 stride: usize,
21089 ) -> vk::Result {
21090 let global = Self::instance();
21091 let device_info = global.get_device_info(device).unwrap();
21093 let dispatch_table = &device_info.dispatch_table.ext_opacity_micromap;
21094 let layer_result = device_info
21095 .customized_info
21096 .borrow()
21097 .hooks()
21098 .write_micromaps_properties_ext(
21099 unsafe { slice_from_raw_parts(p_micromaps, micromap_count) },
21100 query_type,
21101 unsafe { uninit_slice_from_raw_parts_mut(p_data as *mut u8, data_size) },
21102 stride,
21103 );
21104 match layer_result {
21105 LayerResult::Handled(res) => match res {
21106 Ok(()) => vk::Result::SUCCESS,
21107 Err(e) => e,
21108 },
21109 LayerResult::Unhandled => unsafe {
21110 (dispatch_table.write_micromaps_properties_ext)(
21111 device,
21112 micromap_count,
21113 p_micromaps,
21114 query_type,
21115 data_size,
21116 p_data,
21117 stride,
21118 )
21119 },
21120 }
21121 }
21122 extern "system" fn cmd_copy_micromap_ext(
21123 command_buffer: vk::CommandBuffer,
21124 p_info: *const vk::CopyMicromapInfoEXT,
21125 ) {
21126 let global = Self::instance();
21127 let device_info = global.get_device_info(command_buffer).unwrap();
21129 let dispatch_table = &device_info.dispatch_table.ext_opacity_micromap;
21130 let layer_result = device_info
21131 .customized_info
21132 .borrow()
21133 .hooks()
21134 .cmd_copy_micromap_ext(command_buffer, unsafe { p_info.as_ref() }.unwrap());
21135 match layer_result {
21136 LayerResult::Handled(res) => res,
21137 LayerResult::Unhandled => unsafe {
21138 (dispatch_table.cmd_copy_micromap_ext)(command_buffer, p_info)
21139 },
21140 }
21141 }
21142 extern "system" fn cmd_copy_micromap_to_memory_ext(
21143 command_buffer: vk::CommandBuffer,
21144 p_info: *const vk::CopyMicromapToMemoryInfoEXT,
21145 ) {
21146 let global = Self::instance();
21147 let device_info = global.get_device_info(command_buffer).unwrap();
21149 let dispatch_table = &device_info.dispatch_table.ext_opacity_micromap;
21150 let layer_result = device_info
21151 .customized_info
21152 .borrow()
21153 .hooks()
21154 .cmd_copy_micromap_to_memory_ext(command_buffer, unsafe { p_info.as_ref() }.unwrap());
21155 match layer_result {
21156 LayerResult::Handled(res) => res,
21157 LayerResult::Unhandled => unsafe {
21158 (dispatch_table.cmd_copy_micromap_to_memory_ext)(command_buffer, p_info)
21159 },
21160 }
21161 }
21162 extern "system" fn cmd_copy_memory_to_micromap_ext(
21163 command_buffer: vk::CommandBuffer,
21164 p_info: *const vk::CopyMemoryToMicromapInfoEXT,
21165 ) {
21166 let global = Self::instance();
21167 let device_info = global.get_device_info(command_buffer).unwrap();
21169 let dispatch_table = &device_info.dispatch_table.ext_opacity_micromap;
21170 let layer_result = device_info
21171 .customized_info
21172 .borrow()
21173 .hooks()
21174 .cmd_copy_memory_to_micromap_ext(command_buffer, unsafe { p_info.as_ref() }.unwrap());
21175 match layer_result {
21176 LayerResult::Handled(res) => res,
21177 LayerResult::Unhandled => unsafe {
21178 (dispatch_table.cmd_copy_memory_to_micromap_ext)(command_buffer, p_info)
21179 },
21180 }
21181 }
21182 extern "system" fn cmd_write_micromaps_properties_ext(
21183 command_buffer: vk::CommandBuffer,
21184 micromap_count: u32,
21185 p_micromaps: *const vk::MicromapEXT,
21186 query_type: vk::QueryType,
21187 query_pool: vk::QueryPool,
21188 first_query: u32,
21189 ) {
21190 let global = Self::instance();
21191 let device_info = global.get_device_info(command_buffer).unwrap();
21193 let dispatch_table = &device_info.dispatch_table.ext_opacity_micromap;
21194 let layer_result = device_info
21195 .customized_info
21196 .borrow()
21197 .hooks()
21198 .cmd_write_micromaps_properties_ext(
21199 command_buffer,
21200 unsafe { slice_from_raw_parts(p_micromaps, micromap_count) },
21201 query_type,
21202 query_pool,
21203 first_query,
21204 );
21205 match layer_result {
21206 LayerResult::Handled(res) => res,
21207 LayerResult::Unhandled => unsafe {
21208 (dispatch_table.cmd_write_micromaps_properties_ext)(
21209 command_buffer,
21210 micromap_count,
21211 p_micromaps,
21212 query_type,
21213 query_pool,
21214 first_query,
21215 )
21216 },
21217 }
21218 }
21219 extern "system" fn get_device_micromap_compatibility_ext(
21220 device: vk::Device,
21221 p_version_info: *const vk::MicromapVersionInfoEXT,
21222 p_compatibility: *mut vk::AccelerationStructureCompatibilityKHR,
21223 ) {
21224 let global = Self::instance();
21225 let device_info = global.get_device_info(device).unwrap();
21227 let dispatch_table = &device_info.dispatch_table.ext_opacity_micromap;
21228 let layer_result = device_info
21229 .customized_info
21230 .borrow()
21231 .hooks()
21232 .get_device_micromap_compatibility_ext(unsafe { p_version_info.as_ref() }.unwrap());
21233 match layer_result {
21234 LayerResult::Handled(res) => {
21235 *unsafe { p_compatibility.as_mut() }.unwrap() = res;
21236 }
21237 LayerResult::Unhandled => unsafe {
21238 (dispatch_table.get_device_micromap_compatibility_ext)(
21239 device,
21240 p_version_info,
21241 p_compatibility,
21242 )
21243 },
21244 }
21245 }
21246 extern "system" fn get_micromap_build_sizes_ext(
21247 device: vk::Device,
21248 build_type: vk::AccelerationStructureBuildTypeKHR,
21249 p_build_info: *const vk::MicromapBuildInfoEXT,
21250 p_size_info: *mut vk::MicromapBuildSizesInfoEXT,
21251 ) {
21252 let global = Self::instance();
21253 let device_info = global.get_device_info(device).unwrap();
21255 let dispatch_table = &device_info.dispatch_table.ext_opacity_micromap;
21256 let layer_result = device_info
21257 .customized_info
21258 .borrow()
21259 .hooks()
21260 .get_micromap_build_sizes_ext(
21261 build_type,
21262 unsafe { p_build_info.as_ref() }.unwrap(),
21263 unsafe { ptr_as_uninit_mut(p_size_info) }.unwrap(),
21264 );
21265 match layer_result {
21266 LayerResult::Handled(res) => res,
21267 LayerResult::Unhandled => unsafe {
21268 (dispatch_table.get_micromap_build_sizes_ext)(
21269 device,
21270 build_type,
21271 p_build_info,
21272 p_size_info,
21273 )
21274 },
21275 }
21276 }
21277 extern "system" fn set_device_memory_priority_ext(
21278 device: vk::Device,
21279 memory: vk::DeviceMemory,
21280 priority: f32,
21281 ) {
21282 let global = Self::instance();
21283 let device_info = global.get_device_info(device).unwrap();
21285 let dispatch_table = &device_info.dispatch_table.ext_pageable_device_local_memory;
21286 let layer_result = device_info
21287 .customized_info
21288 .borrow()
21289 .hooks()
21290 .set_device_memory_priority_ext(memory, priority);
21291 match layer_result {
21292 LayerResult::Handled(res) => res,
21293 LayerResult::Unhandled => unsafe {
21294 (dispatch_table.set_device_memory_priority_ext)(device, memory, priority)
21295 },
21296 }
21297 }
21298 extern "system" fn get_descriptor_set_layout_host_mapping_info_valve(
21299 device: vk::Device,
21300 p_binding_reference: *const vk::DescriptorSetBindingReferenceVALVE,
21301 p_host_mapping: *mut vk::DescriptorSetLayoutHostMappingInfoVALVE,
21302 ) {
21303 let global = Self::instance();
21304 let device_info = global.get_device_info(device).unwrap();
21306 let dispatch_table = &device_info.dispatch_table.valve_descriptor_set_host_mapping;
21307 let layer_result = device_info
21308 .customized_info
21309 .borrow()
21310 .hooks()
21311 .get_descriptor_set_layout_host_mapping_info_valve(
21312 unsafe { p_binding_reference.as_ref() }.unwrap(),
21313 unsafe { ptr_as_uninit_mut(p_host_mapping) }.unwrap(),
21314 );
21315 match layer_result {
21316 LayerResult::Handled(res) => res,
21317 LayerResult::Unhandled => unsafe {
21318 (dispatch_table.get_descriptor_set_layout_host_mapping_info_valve)(
21319 device,
21320 p_binding_reference,
21321 p_host_mapping,
21322 )
21323 },
21324 }
21325 }
21326 extern "system" fn get_descriptor_set_host_mapping_valve(
21327 device: vk::Device,
21328 descriptor_set: vk::DescriptorSet,
21329 pp_data: *mut *mut c_void,
21330 ) {
21331 let global = Self::instance();
21332 let device_info = global.get_device_info(device).unwrap();
21334 let dispatch_table = &device_info.dispatch_table.valve_descriptor_set_host_mapping;
21335 let layer_result = device_info
21336 .customized_info
21337 .borrow()
21338 .hooks()
21339 .get_descriptor_set_host_mapping_valve(descriptor_set);
21340 match layer_result {
21341 LayerResult::Handled(res) => {
21342 *unsafe { pp_data.as_mut() }.unwrap() = res;
21343 }
21344 LayerResult::Unhandled => unsafe {
21345 (dispatch_table.get_descriptor_set_host_mapping_valve)(
21346 device,
21347 descriptor_set,
21348 pp_data,
21349 )
21350 },
21351 }
21352 }
21353 extern "system" fn cmd_copy_memory_indirect_nv(
21354 command_buffer: vk::CommandBuffer,
21355 copy_buffer_address: vk::DeviceAddress,
21356 copy_count: u32,
21357 stride: u32,
21358 ) {
21359 let global = Self::instance();
21360 let device_info = global.get_device_info(command_buffer).unwrap();
21362 let dispatch_table = &device_info.dispatch_table.nv_copy_memory_indirect;
21363 let layer_result = device_info
21364 .customized_info
21365 .borrow()
21366 .hooks()
21367 .cmd_copy_memory_indirect_nv(command_buffer, copy_buffer_address, copy_count, stride);
21368 match layer_result {
21369 LayerResult::Handled(res) => res,
21370 LayerResult::Unhandled => unsafe {
21371 (dispatch_table.cmd_copy_memory_indirect_nv)(
21372 command_buffer,
21373 copy_buffer_address,
21374 copy_count,
21375 stride,
21376 )
21377 },
21378 }
21379 }
21380 extern "system" fn cmd_copy_memory_to_image_indirect_nv(
21381 command_buffer: vk::CommandBuffer,
21382 copy_buffer_address: vk::DeviceAddress,
21383 copy_count: u32,
21384 stride: u32,
21385 dst_image: vk::Image,
21386 dst_image_layout: vk::ImageLayout,
21387 p_image_subresources: *const vk::ImageSubresourceLayers,
21388 ) {
21389 let global = Self::instance();
21390 let device_info = global.get_device_info(command_buffer).unwrap();
21392 let dispatch_table = &device_info.dispatch_table.nv_copy_memory_indirect;
21393 let layer_result = device_info
21394 .customized_info
21395 .borrow()
21396 .hooks()
21397 .cmd_copy_memory_to_image_indirect_nv(
21398 command_buffer,
21399 copy_buffer_address,
21400 stride,
21401 dst_image,
21402 dst_image_layout,
21403 unsafe { slice_from_raw_parts(p_image_subresources, copy_count) },
21404 );
21405 match layer_result {
21406 LayerResult::Handled(res) => res,
21407 LayerResult::Unhandled => unsafe {
21408 (dispatch_table.cmd_copy_memory_to_image_indirect_nv)(
21409 command_buffer,
21410 copy_buffer_address,
21411 copy_count,
21412 stride,
21413 dst_image,
21414 dst_image_layout,
21415 p_image_subresources,
21416 )
21417 },
21418 }
21419 }
21420 extern "system" fn cmd_decompress_memory_nv(
21421 command_buffer: vk::CommandBuffer,
21422 decompress_region_count: u32,
21423 p_decompress_memory_regions: *const vk::DecompressMemoryRegionNV,
21424 ) {
21425 let global = Self::instance();
21426 let device_info = global.get_device_info(command_buffer).unwrap();
21428 let dispatch_table = &device_info.dispatch_table.nv_memory_decompression;
21429 let layer_result = device_info
21430 .customized_info
21431 .borrow()
21432 .hooks()
21433 .cmd_decompress_memory_nv(command_buffer, unsafe {
21434 slice_from_raw_parts(p_decompress_memory_regions, decompress_region_count)
21435 });
21436 match layer_result {
21437 LayerResult::Handled(res) => res,
21438 LayerResult::Unhandled => unsafe {
21439 (dispatch_table.cmd_decompress_memory_nv)(
21440 command_buffer,
21441 decompress_region_count,
21442 p_decompress_memory_regions,
21443 )
21444 },
21445 }
21446 }
21447 extern "system" fn cmd_decompress_memory_indirect_count_nv(
21448 command_buffer: vk::CommandBuffer,
21449 indirect_commands_address: vk::DeviceAddress,
21450 indirect_commands_count_address: vk::DeviceAddress,
21451 stride: u32,
21452 ) {
21453 let global = Self::instance();
21454 let device_info = global.get_device_info(command_buffer).unwrap();
21456 let dispatch_table = &device_info.dispatch_table.nv_memory_decompression;
21457 let layer_result = device_info
21458 .customized_info
21459 .borrow()
21460 .hooks()
21461 .cmd_decompress_memory_indirect_count_nv(
21462 command_buffer,
21463 indirect_commands_address,
21464 indirect_commands_count_address,
21465 stride,
21466 );
21467 match layer_result {
21468 LayerResult::Handled(res) => res,
21469 LayerResult::Unhandled => unsafe {
21470 (dispatch_table.cmd_decompress_memory_indirect_count_nv)(
21471 command_buffer,
21472 indirect_commands_address,
21473 indirect_commands_count_address,
21474 stride,
21475 )
21476 },
21477 }
21478 }
21479 extern "system" fn cmd_set_tessellation_domain_origin_ext(
21480 command_buffer: vk::CommandBuffer,
21481 domain_origin: vk::TessellationDomainOrigin,
21482 ) {
21483 let global = Self::instance();
21484 let device_info = global.get_device_info(command_buffer).unwrap();
21486 let dispatch_table = &device_info.dispatch_table.ext_extended_dynamic_state3;
21487 let layer_result = device_info
21488 .customized_info
21489 .borrow()
21490 .hooks()
21491 .cmd_set_tessellation_domain_origin_ext(command_buffer, domain_origin);
21492 match layer_result {
21493 LayerResult::Handled(res) => res,
21494 LayerResult::Unhandled => unsafe {
21495 (dispatch_table.cmd_set_tessellation_domain_origin_ext)(
21496 command_buffer,
21497 domain_origin,
21498 )
21499 },
21500 }
21501 }
21502 extern "system" fn cmd_set_depth_clamp_enable_ext(
21503 command_buffer: vk::CommandBuffer,
21504 depth_clamp_enable: vk::Bool32,
21505 ) {
21506 let global = Self::instance();
21507 let device_info = global.get_device_info(command_buffer).unwrap();
21509 let dispatch_table = &device_info.dispatch_table.ext_extended_dynamic_state3;
21510 let layer_result = device_info
21511 .customized_info
21512 .borrow()
21513 .hooks()
21514 .cmd_set_depth_clamp_enable_ext(command_buffer, depth_clamp_enable == vk::TRUE);
21515 match layer_result {
21516 LayerResult::Handled(res) => res,
21517 LayerResult::Unhandled => unsafe {
21518 (dispatch_table.cmd_set_depth_clamp_enable_ext)(command_buffer, depth_clamp_enable)
21519 },
21520 }
21521 }
21522 extern "system" fn cmd_set_polygon_mode_ext(
21523 command_buffer: vk::CommandBuffer,
21524 polygon_mode: vk::PolygonMode,
21525 ) {
21526 let global = Self::instance();
21527 let device_info = global.get_device_info(command_buffer).unwrap();
21529 let dispatch_table = &device_info.dispatch_table.ext_extended_dynamic_state3;
21530 let layer_result = device_info
21531 .customized_info
21532 .borrow()
21533 .hooks()
21534 .cmd_set_polygon_mode_ext(command_buffer, polygon_mode);
21535 match layer_result {
21536 LayerResult::Handled(res) => res,
21537 LayerResult::Unhandled => unsafe {
21538 (dispatch_table.cmd_set_polygon_mode_ext)(command_buffer, polygon_mode)
21539 },
21540 }
21541 }
21542 extern "system" fn cmd_set_rasterization_samples_ext(
21543 command_buffer: vk::CommandBuffer,
21544 rasterization_samples: vk::SampleCountFlags,
21545 ) {
21546 let global = Self::instance();
21547 let device_info = global.get_device_info(command_buffer).unwrap();
21549 let dispatch_table = &device_info.dispatch_table.ext_extended_dynamic_state3;
21550 let layer_result = device_info
21551 .customized_info
21552 .borrow()
21553 .hooks()
21554 .cmd_set_rasterization_samples_ext(command_buffer, rasterization_samples);
21555 match layer_result {
21556 LayerResult::Handled(res) => res,
21557 LayerResult::Unhandled => unsafe {
21558 (dispatch_table.cmd_set_rasterization_samples_ext)(
21559 command_buffer,
21560 rasterization_samples,
21561 )
21562 },
21563 }
21564 }
21565 extern "system" fn cmd_set_sample_mask_ext(
21566 command_buffer: vk::CommandBuffer,
21567 samples: vk::SampleCountFlags,
21568 p_sample_mask: *const vk::SampleMask,
21569 ) {
21570 let global = Self::instance();
21571 let device_info = global.get_device_info(command_buffer).unwrap();
21573 let dispatch_table = &device_info.dispatch_table.ext_extended_dynamic_state3;
21574 let layer_result = device_info
21575 .customized_info
21576 .borrow()
21577 .hooks()
21578 .cmd_set_sample_mask_ext(command_buffer, samples, unsafe {
21579 slice_from_raw_parts(p_sample_mask, samples.as_raw().div_ceil(32))
21580 });
21581 match layer_result {
21582 LayerResult::Handled(res) => res,
21583 LayerResult::Unhandled => unsafe {
21584 (dispatch_table.cmd_set_sample_mask_ext)(command_buffer, samples, p_sample_mask)
21585 },
21586 }
21587 }
21588 extern "system" fn cmd_set_alpha_to_coverage_enable_ext(
21589 command_buffer: vk::CommandBuffer,
21590 alpha_to_coverage_enable: vk::Bool32,
21591 ) {
21592 let global = Self::instance();
21593 let device_info = global.get_device_info(command_buffer).unwrap();
21595 let dispatch_table = &device_info.dispatch_table.ext_extended_dynamic_state3;
21596 let layer_result = device_info
21597 .customized_info
21598 .borrow()
21599 .hooks()
21600 .cmd_set_alpha_to_coverage_enable_ext(
21601 command_buffer,
21602 alpha_to_coverage_enable == vk::TRUE,
21603 );
21604 match layer_result {
21605 LayerResult::Handled(res) => res,
21606 LayerResult::Unhandled => unsafe {
21607 (dispatch_table.cmd_set_alpha_to_coverage_enable_ext)(
21608 command_buffer,
21609 alpha_to_coverage_enable,
21610 )
21611 },
21612 }
21613 }
21614 extern "system" fn cmd_set_alpha_to_one_enable_ext(
21615 command_buffer: vk::CommandBuffer,
21616 alpha_to_one_enable: vk::Bool32,
21617 ) {
21618 let global = Self::instance();
21619 let device_info = global.get_device_info(command_buffer).unwrap();
21621 let dispatch_table = &device_info.dispatch_table.ext_extended_dynamic_state3;
21622 let layer_result = device_info
21623 .customized_info
21624 .borrow()
21625 .hooks()
21626 .cmd_set_alpha_to_one_enable_ext(command_buffer, alpha_to_one_enable == vk::TRUE);
21627 match layer_result {
21628 LayerResult::Handled(res) => res,
21629 LayerResult::Unhandled => unsafe {
21630 (dispatch_table.cmd_set_alpha_to_one_enable_ext)(
21631 command_buffer,
21632 alpha_to_one_enable,
21633 )
21634 },
21635 }
21636 }
21637 extern "system" fn cmd_set_logic_op_enable_ext(
21638 command_buffer: vk::CommandBuffer,
21639 logic_op_enable: vk::Bool32,
21640 ) {
21641 let global = Self::instance();
21642 let device_info = global.get_device_info(command_buffer).unwrap();
21644 let dispatch_table = &device_info.dispatch_table.ext_extended_dynamic_state3;
21645 let layer_result = device_info
21646 .customized_info
21647 .borrow()
21648 .hooks()
21649 .cmd_set_logic_op_enable_ext(command_buffer, logic_op_enable == vk::TRUE);
21650 match layer_result {
21651 LayerResult::Handled(res) => res,
21652 LayerResult::Unhandled => unsafe {
21653 (dispatch_table.cmd_set_logic_op_enable_ext)(command_buffer, logic_op_enable)
21654 },
21655 }
21656 }
21657 extern "system" fn cmd_set_color_blend_enable_ext(
21658 command_buffer: vk::CommandBuffer,
21659 first_attachment: u32,
21660 attachment_count: u32,
21661 p_color_blend_enables: *const vk::Bool32,
21662 ) {
21663 let global = Self::instance();
21664 let device_info = global.get_device_info(command_buffer).unwrap();
21666 let dispatch_table = &device_info.dispatch_table.ext_extended_dynamic_state3;
21667 let layer_result = device_info
21668 .customized_info
21669 .borrow()
21670 .hooks()
21671 .cmd_set_color_blend_enable_ext(command_buffer, first_attachment, unsafe {
21672 bool_iterator_from_raw_parts(p_color_blend_enables, attachment_count)
21673 });
21674 match layer_result {
21675 LayerResult::Handled(res) => res,
21676 LayerResult::Unhandled => unsafe {
21677 (dispatch_table.cmd_set_color_blend_enable_ext)(
21678 command_buffer,
21679 first_attachment,
21680 attachment_count,
21681 p_color_blend_enables,
21682 )
21683 },
21684 }
21685 }
21686 extern "system" fn cmd_set_color_blend_equation_ext(
21687 command_buffer: vk::CommandBuffer,
21688 first_attachment: u32,
21689 attachment_count: u32,
21690 p_color_blend_equations: *const vk::ColorBlendEquationEXT,
21691 ) {
21692 let global = Self::instance();
21693 let device_info = global.get_device_info(command_buffer).unwrap();
21695 let dispatch_table = &device_info.dispatch_table.ext_extended_dynamic_state3;
21696 let layer_result = device_info
21697 .customized_info
21698 .borrow()
21699 .hooks()
21700 .cmd_set_color_blend_equation_ext(command_buffer, first_attachment, unsafe {
21701 slice_from_raw_parts(p_color_blend_equations, attachment_count)
21702 });
21703 match layer_result {
21704 LayerResult::Handled(res) => res,
21705 LayerResult::Unhandled => unsafe {
21706 (dispatch_table.cmd_set_color_blend_equation_ext)(
21707 command_buffer,
21708 first_attachment,
21709 attachment_count,
21710 p_color_blend_equations,
21711 )
21712 },
21713 }
21714 }
21715 extern "system" fn cmd_set_color_write_mask_ext(
21716 command_buffer: vk::CommandBuffer,
21717 first_attachment: u32,
21718 attachment_count: u32,
21719 p_color_write_masks: *const vk::ColorComponentFlags,
21720 ) {
21721 let global = Self::instance();
21722 let device_info = global.get_device_info(command_buffer).unwrap();
21724 let dispatch_table = &device_info.dispatch_table.ext_extended_dynamic_state3;
21725 let layer_result = device_info
21726 .customized_info
21727 .borrow()
21728 .hooks()
21729 .cmd_set_color_write_mask_ext(command_buffer, first_attachment, unsafe {
21730 slice_from_raw_parts(p_color_write_masks, attachment_count)
21731 });
21732 match layer_result {
21733 LayerResult::Handled(res) => res,
21734 LayerResult::Unhandled => unsafe {
21735 (dispatch_table.cmd_set_color_write_mask_ext)(
21736 command_buffer,
21737 first_attachment,
21738 attachment_count,
21739 p_color_write_masks,
21740 )
21741 },
21742 }
21743 }
21744 extern "system" fn cmd_set_rasterization_stream_ext(
21745 command_buffer: vk::CommandBuffer,
21746 rasterization_stream: u32,
21747 ) {
21748 let global = Self::instance();
21749 let device_info = global.get_device_info(command_buffer).unwrap();
21751 let dispatch_table = &device_info.dispatch_table.ext_extended_dynamic_state3;
21752 let layer_result = device_info
21753 .customized_info
21754 .borrow()
21755 .hooks()
21756 .cmd_set_rasterization_stream_ext(command_buffer, rasterization_stream);
21757 match layer_result {
21758 LayerResult::Handled(res) => res,
21759 LayerResult::Unhandled => unsafe {
21760 (dispatch_table.cmd_set_rasterization_stream_ext)(
21761 command_buffer,
21762 rasterization_stream,
21763 )
21764 },
21765 }
21766 }
21767 extern "system" fn cmd_set_conservative_rasterization_mode_ext(
21768 command_buffer: vk::CommandBuffer,
21769 conservative_rasterization_mode: vk::ConservativeRasterizationModeEXT,
21770 ) {
21771 let global = Self::instance();
21772 let device_info = global.get_device_info(command_buffer).unwrap();
21774 let dispatch_table = &device_info.dispatch_table.ext_extended_dynamic_state3;
21775 let layer_result = device_info
21776 .customized_info
21777 .borrow()
21778 .hooks()
21779 .cmd_set_conservative_rasterization_mode_ext(
21780 command_buffer,
21781 conservative_rasterization_mode,
21782 );
21783 match layer_result {
21784 LayerResult::Handled(res) => res,
21785 LayerResult::Unhandled => unsafe {
21786 (dispatch_table.cmd_set_conservative_rasterization_mode_ext)(
21787 command_buffer,
21788 conservative_rasterization_mode,
21789 )
21790 },
21791 }
21792 }
21793 extern "system" fn cmd_set_extra_primitive_overestimation_size_ext(
21794 command_buffer: vk::CommandBuffer,
21795 extra_primitive_overestimation_size: f32,
21796 ) {
21797 let global = Self::instance();
21798 let device_info = global.get_device_info(command_buffer).unwrap();
21800 let dispatch_table = &device_info.dispatch_table.ext_extended_dynamic_state3;
21801 let layer_result = device_info
21802 .customized_info
21803 .borrow()
21804 .hooks()
21805 .cmd_set_extra_primitive_overestimation_size_ext(
21806 command_buffer,
21807 extra_primitive_overestimation_size,
21808 );
21809 match layer_result {
21810 LayerResult::Handled(res) => res,
21811 LayerResult::Unhandled => unsafe {
21812 (dispatch_table.cmd_set_extra_primitive_overestimation_size_ext)(
21813 command_buffer,
21814 extra_primitive_overestimation_size,
21815 )
21816 },
21817 }
21818 }
21819 extern "system" fn cmd_set_depth_clip_enable_ext(
21820 command_buffer: vk::CommandBuffer,
21821 depth_clip_enable: vk::Bool32,
21822 ) {
21823 let global = Self::instance();
21824 let device_info = global.get_device_info(command_buffer).unwrap();
21826 let dispatch_table = &device_info.dispatch_table.ext_extended_dynamic_state3;
21827 let layer_result = device_info
21828 .customized_info
21829 .borrow()
21830 .hooks()
21831 .cmd_set_depth_clip_enable_ext(command_buffer, depth_clip_enable == vk::TRUE);
21832 match layer_result {
21833 LayerResult::Handled(res) => res,
21834 LayerResult::Unhandled => unsafe {
21835 (dispatch_table.cmd_set_depth_clip_enable_ext)(command_buffer, depth_clip_enable)
21836 },
21837 }
21838 }
21839 extern "system" fn cmd_set_sample_locations_enable_ext(
21840 command_buffer: vk::CommandBuffer,
21841 sample_locations_enable: vk::Bool32,
21842 ) {
21843 let global = Self::instance();
21844 let device_info = global.get_device_info(command_buffer).unwrap();
21846 let dispatch_table = &device_info.dispatch_table.ext_extended_dynamic_state3;
21847 let layer_result = device_info
21848 .customized_info
21849 .borrow()
21850 .hooks()
21851 .cmd_set_sample_locations_enable_ext(
21852 command_buffer,
21853 sample_locations_enable == vk::TRUE,
21854 );
21855 match layer_result {
21856 LayerResult::Handled(res) => res,
21857 LayerResult::Unhandled => unsafe {
21858 (dispatch_table.cmd_set_sample_locations_enable_ext)(
21859 command_buffer,
21860 sample_locations_enable,
21861 )
21862 },
21863 }
21864 }
21865 extern "system" fn cmd_set_color_blend_advanced_ext(
21866 command_buffer: vk::CommandBuffer,
21867 first_attachment: u32,
21868 attachment_count: u32,
21869 p_color_blend_advanced: *const vk::ColorBlendAdvancedEXT,
21870 ) {
21871 let global = Self::instance();
21872 let device_info = global.get_device_info(command_buffer).unwrap();
21874 let dispatch_table = &device_info.dispatch_table.ext_extended_dynamic_state3;
21875 let layer_result = device_info
21876 .customized_info
21877 .borrow()
21878 .hooks()
21879 .cmd_set_color_blend_advanced_ext(command_buffer, first_attachment, unsafe {
21880 slice_from_raw_parts(p_color_blend_advanced, attachment_count)
21881 });
21882 match layer_result {
21883 LayerResult::Handled(res) => res,
21884 LayerResult::Unhandled => unsafe {
21885 (dispatch_table.cmd_set_color_blend_advanced_ext)(
21886 command_buffer,
21887 first_attachment,
21888 attachment_count,
21889 p_color_blend_advanced,
21890 )
21891 },
21892 }
21893 }
21894 extern "system" fn cmd_set_provoking_vertex_mode_ext(
21895 command_buffer: vk::CommandBuffer,
21896 provoking_vertex_mode: vk::ProvokingVertexModeEXT,
21897 ) {
21898 let global = Self::instance();
21899 let device_info = global.get_device_info(command_buffer).unwrap();
21901 let dispatch_table = &device_info.dispatch_table.ext_extended_dynamic_state3;
21902 let layer_result = device_info
21903 .customized_info
21904 .borrow()
21905 .hooks()
21906 .cmd_set_provoking_vertex_mode_ext(command_buffer, provoking_vertex_mode);
21907 match layer_result {
21908 LayerResult::Handled(res) => res,
21909 LayerResult::Unhandled => unsafe {
21910 (dispatch_table.cmd_set_provoking_vertex_mode_ext)(
21911 command_buffer,
21912 provoking_vertex_mode,
21913 )
21914 },
21915 }
21916 }
21917 extern "system" fn cmd_set_line_rasterization_mode_ext(
21918 command_buffer: vk::CommandBuffer,
21919 line_rasterization_mode: vk::LineRasterizationModeEXT,
21920 ) {
21921 let global = Self::instance();
21922 let device_info = global.get_device_info(command_buffer).unwrap();
21924 let dispatch_table = &device_info.dispatch_table.ext_extended_dynamic_state3;
21925 let layer_result = device_info
21926 .customized_info
21927 .borrow()
21928 .hooks()
21929 .cmd_set_line_rasterization_mode_ext(command_buffer, line_rasterization_mode);
21930 match layer_result {
21931 LayerResult::Handled(res) => res,
21932 LayerResult::Unhandled => unsafe {
21933 (dispatch_table.cmd_set_line_rasterization_mode_ext)(
21934 command_buffer,
21935 line_rasterization_mode,
21936 )
21937 },
21938 }
21939 }
21940 extern "system" fn cmd_set_line_stipple_enable_ext(
21941 command_buffer: vk::CommandBuffer,
21942 stippled_line_enable: vk::Bool32,
21943 ) {
21944 let global = Self::instance();
21945 let device_info = global.get_device_info(command_buffer).unwrap();
21947 let dispatch_table = &device_info.dispatch_table.ext_extended_dynamic_state3;
21948 let layer_result = device_info
21949 .customized_info
21950 .borrow()
21951 .hooks()
21952 .cmd_set_line_stipple_enable_ext(command_buffer, stippled_line_enable == vk::TRUE);
21953 match layer_result {
21954 LayerResult::Handled(res) => res,
21955 LayerResult::Unhandled => unsafe {
21956 (dispatch_table.cmd_set_line_stipple_enable_ext)(
21957 command_buffer,
21958 stippled_line_enable,
21959 )
21960 },
21961 }
21962 }
21963 extern "system" fn cmd_set_depth_clip_negative_one_to_one_ext(
21964 command_buffer: vk::CommandBuffer,
21965 negative_one_to_one: vk::Bool32,
21966 ) {
21967 let global = Self::instance();
21968 let device_info = global.get_device_info(command_buffer).unwrap();
21970 let dispatch_table = &device_info.dispatch_table.ext_extended_dynamic_state3;
21971 let layer_result = device_info
21972 .customized_info
21973 .borrow()
21974 .hooks()
21975 .cmd_set_depth_clip_negative_one_to_one_ext(
21976 command_buffer,
21977 negative_one_to_one == vk::TRUE,
21978 );
21979 match layer_result {
21980 LayerResult::Handled(res) => res,
21981 LayerResult::Unhandled => unsafe {
21982 (dispatch_table.cmd_set_depth_clip_negative_one_to_one_ext)(
21983 command_buffer,
21984 negative_one_to_one,
21985 )
21986 },
21987 }
21988 }
21989 extern "system" fn cmd_set_viewport_w_scaling_enable_nv(
21990 command_buffer: vk::CommandBuffer,
21991 viewport_w_scaling_enable: vk::Bool32,
21992 ) {
21993 let global = Self::instance();
21994 let device_info = global.get_device_info(command_buffer).unwrap();
21996 let dispatch_table = &device_info.dispatch_table.ext_extended_dynamic_state3;
21997 let layer_result = device_info
21998 .customized_info
21999 .borrow()
22000 .hooks()
22001 .cmd_set_viewport_w_scaling_enable_nv(
22002 command_buffer,
22003 viewport_w_scaling_enable == vk::TRUE,
22004 );
22005 match layer_result {
22006 LayerResult::Handled(res) => res,
22007 LayerResult::Unhandled => unsafe {
22008 (dispatch_table.cmd_set_viewport_w_scaling_enable_nv)(
22009 command_buffer,
22010 viewport_w_scaling_enable,
22011 )
22012 },
22013 }
22014 }
22015 extern "system" fn cmd_set_viewport_swizzle_nv(
22016 command_buffer: vk::CommandBuffer,
22017 first_viewport: u32,
22018 viewport_count: u32,
22019 p_viewport_swizzles: *const vk::ViewportSwizzleNV,
22020 ) {
22021 let global = Self::instance();
22022 let device_info = global.get_device_info(command_buffer).unwrap();
22024 let dispatch_table = &device_info.dispatch_table.ext_extended_dynamic_state3;
22025 let layer_result = device_info
22026 .customized_info
22027 .borrow()
22028 .hooks()
22029 .cmd_set_viewport_swizzle_nv(command_buffer, first_viewport, unsafe {
22030 slice_from_raw_parts(p_viewport_swizzles, viewport_count)
22031 });
22032 match layer_result {
22033 LayerResult::Handled(res) => res,
22034 LayerResult::Unhandled => unsafe {
22035 (dispatch_table.cmd_set_viewport_swizzle_nv)(
22036 command_buffer,
22037 first_viewport,
22038 viewport_count,
22039 p_viewport_swizzles,
22040 )
22041 },
22042 }
22043 }
22044 extern "system" fn cmd_set_coverage_to_color_enable_nv(
22045 command_buffer: vk::CommandBuffer,
22046 coverage_to_color_enable: vk::Bool32,
22047 ) {
22048 let global = Self::instance();
22049 let device_info = global.get_device_info(command_buffer).unwrap();
22051 let dispatch_table = &device_info.dispatch_table.ext_extended_dynamic_state3;
22052 let layer_result = device_info
22053 .customized_info
22054 .borrow()
22055 .hooks()
22056 .cmd_set_coverage_to_color_enable_nv(
22057 command_buffer,
22058 coverage_to_color_enable == vk::TRUE,
22059 );
22060 match layer_result {
22061 LayerResult::Handled(res) => res,
22062 LayerResult::Unhandled => unsafe {
22063 (dispatch_table.cmd_set_coverage_to_color_enable_nv)(
22064 command_buffer,
22065 coverage_to_color_enable,
22066 )
22067 },
22068 }
22069 }
22070 extern "system" fn cmd_set_coverage_to_color_location_nv(
22071 command_buffer: vk::CommandBuffer,
22072 coverage_to_color_location: u32,
22073 ) {
22074 let global = Self::instance();
22075 let device_info = global.get_device_info(command_buffer).unwrap();
22077 let dispatch_table = &device_info.dispatch_table.ext_extended_dynamic_state3;
22078 let layer_result = device_info
22079 .customized_info
22080 .borrow()
22081 .hooks()
22082 .cmd_set_coverage_to_color_location_nv(command_buffer, coverage_to_color_location);
22083 match layer_result {
22084 LayerResult::Handled(res) => res,
22085 LayerResult::Unhandled => unsafe {
22086 (dispatch_table.cmd_set_coverage_to_color_location_nv)(
22087 command_buffer,
22088 coverage_to_color_location,
22089 )
22090 },
22091 }
22092 }
22093 extern "system" fn cmd_set_coverage_modulation_mode_nv(
22094 command_buffer: vk::CommandBuffer,
22095 coverage_modulation_mode: vk::CoverageModulationModeNV,
22096 ) {
22097 let global = Self::instance();
22098 let device_info = global.get_device_info(command_buffer).unwrap();
22100 let dispatch_table = &device_info.dispatch_table.ext_extended_dynamic_state3;
22101 let layer_result = device_info
22102 .customized_info
22103 .borrow()
22104 .hooks()
22105 .cmd_set_coverage_modulation_mode_nv(command_buffer, coverage_modulation_mode);
22106 match layer_result {
22107 LayerResult::Handled(res) => res,
22108 LayerResult::Unhandled => unsafe {
22109 (dispatch_table.cmd_set_coverage_modulation_mode_nv)(
22110 command_buffer,
22111 coverage_modulation_mode,
22112 )
22113 },
22114 }
22115 }
22116 extern "system" fn cmd_set_coverage_modulation_table_enable_nv(
22117 command_buffer: vk::CommandBuffer,
22118 coverage_modulation_table_enable: vk::Bool32,
22119 ) {
22120 let global = Self::instance();
22121 let device_info = global.get_device_info(command_buffer).unwrap();
22123 let dispatch_table = &device_info.dispatch_table.ext_extended_dynamic_state3;
22124 let layer_result = device_info
22125 .customized_info
22126 .borrow()
22127 .hooks()
22128 .cmd_set_coverage_modulation_table_enable_nv(
22129 command_buffer,
22130 coverage_modulation_table_enable == vk::TRUE,
22131 );
22132 match layer_result {
22133 LayerResult::Handled(res) => res,
22134 LayerResult::Unhandled => unsafe {
22135 (dispatch_table.cmd_set_coverage_modulation_table_enable_nv)(
22136 command_buffer,
22137 coverage_modulation_table_enable,
22138 )
22139 },
22140 }
22141 }
22142 extern "system" fn cmd_set_coverage_modulation_table_nv(
22143 command_buffer: vk::CommandBuffer,
22144 coverage_modulation_table_count: u32,
22145 p_coverage_modulation_table: *const f32,
22146 ) {
22147 let global = Self::instance();
22148 let device_info = global.get_device_info(command_buffer).unwrap();
22150 let dispatch_table = &device_info.dispatch_table.ext_extended_dynamic_state3;
22151 let layer_result = device_info
22152 .customized_info
22153 .borrow()
22154 .hooks()
22155 .cmd_set_coverage_modulation_table_nv(command_buffer, unsafe {
22156 slice_from_raw_parts(p_coverage_modulation_table, coverage_modulation_table_count)
22157 });
22158 match layer_result {
22159 LayerResult::Handled(res) => res,
22160 LayerResult::Unhandled => unsafe {
22161 (dispatch_table.cmd_set_coverage_modulation_table_nv)(
22162 command_buffer,
22163 coverage_modulation_table_count,
22164 p_coverage_modulation_table,
22165 )
22166 },
22167 }
22168 }
22169 extern "system" fn cmd_set_shading_rate_image_enable_nv(
22170 command_buffer: vk::CommandBuffer,
22171 shading_rate_image_enable: vk::Bool32,
22172 ) {
22173 let global = Self::instance();
22174 let device_info = global.get_device_info(command_buffer).unwrap();
22176 let dispatch_table = &device_info.dispatch_table.ext_extended_dynamic_state3;
22177 let layer_result = device_info
22178 .customized_info
22179 .borrow()
22180 .hooks()
22181 .cmd_set_shading_rate_image_enable_nv(
22182 command_buffer,
22183 shading_rate_image_enable == vk::TRUE,
22184 );
22185 match layer_result {
22186 LayerResult::Handled(res) => res,
22187 LayerResult::Unhandled => unsafe {
22188 (dispatch_table.cmd_set_shading_rate_image_enable_nv)(
22189 command_buffer,
22190 shading_rate_image_enable,
22191 )
22192 },
22193 }
22194 }
22195 extern "system" fn cmd_set_representative_fragment_test_enable_nv(
22196 command_buffer: vk::CommandBuffer,
22197 representative_fragment_test_enable: vk::Bool32,
22198 ) {
22199 let global = Self::instance();
22200 let device_info = global.get_device_info(command_buffer).unwrap();
22202 let dispatch_table = &device_info.dispatch_table.ext_extended_dynamic_state3;
22203 let layer_result = device_info
22204 .customized_info
22205 .borrow()
22206 .hooks()
22207 .cmd_set_representative_fragment_test_enable_nv(
22208 command_buffer,
22209 representative_fragment_test_enable == vk::TRUE,
22210 );
22211 match layer_result {
22212 LayerResult::Handled(res) => res,
22213 LayerResult::Unhandled => unsafe {
22214 (dispatch_table.cmd_set_representative_fragment_test_enable_nv)(
22215 command_buffer,
22216 representative_fragment_test_enable,
22217 )
22218 },
22219 }
22220 }
22221 extern "system" fn cmd_set_coverage_reduction_mode_nv(
22222 command_buffer: vk::CommandBuffer,
22223 coverage_reduction_mode: vk::CoverageReductionModeNV,
22224 ) {
22225 let global = Self::instance();
22226 let device_info = global.get_device_info(command_buffer).unwrap();
22228 let dispatch_table = &device_info.dispatch_table.ext_extended_dynamic_state3;
22229 let layer_result = device_info
22230 .customized_info
22231 .borrow()
22232 .hooks()
22233 .cmd_set_coverage_reduction_mode_nv(command_buffer, coverage_reduction_mode);
22234 match layer_result {
22235 LayerResult::Handled(res) => res,
22236 LayerResult::Unhandled => unsafe {
22237 (dispatch_table.cmd_set_coverage_reduction_mode_nv)(
22238 command_buffer,
22239 coverage_reduction_mode,
22240 )
22241 },
22242 }
22243 }
22244 extern "system" fn get_shader_module_identifier_ext(
22245 device: vk::Device,
22246 shader_module: vk::ShaderModule,
22247 p_identifier: *mut vk::ShaderModuleIdentifierEXT,
22248 ) {
22249 let global = Self::instance();
22250 let device_info = global.get_device_info(device).unwrap();
22252 let dispatch_table = &device_info.dispatch_table.ext_shader_module_identifier;
22253 let layer_result = device_info
22254 .customized_info
22255 .borrow()
22256 .hooks()
22257 .get_shader_module_identifier_ext(
22258 shader_module,
22259 unsafe { ptr_as_uninit_mut(p_identifier) }.unwrap(),
22260 );
22261 match layer_result {
22262 LayerResult::Handled(res) => res,
22263 LayerResult::Unhandled => unsafe {
22264 (dispatch_table.get_shader_module_identifier_ext)(
22265 device,
22266 shader_module,
22267 p_identifier,
22268 )
22269 },
22270 }
22271 }
22272 extern "system" fn get_shader_module_create_info_identifier_ext(
22273 device: vk::Device,
22274 p_create_info: *const vk::ShaderModuleCreateInfo,
22275 p_identifier: *mut vk::ShaderModuleIdentifierEXT,
22276 ) {
22277 let global = Self::instance();
22278 let device_info = global.get_device_info(device).unwrap();
22280 let dispatch_table = &device_info.dispatch_table.ext_shader_module_identifier;
22281 let layer_result = device_info
22282 .customized_info
22283 .borrow()
22284 .hooks()
22285 .get_shader_module_create_info_identifier_ext(
22286 unsafe { p_create_info.as_ref() }.unwrap(),
22287 unsafe { ptr_as_uninit_mut(p_identifier) }.unwrap(),
22288 );
22289 match layer_result {
22290 LayerResult::Handled(res) => res,
22291 LayerResult::Unhandled => unsafe {
22292 (dispatch_table.get_shader_module_create_info_identifier_ext)(
22293 device,
22294 p_create_info,
22295 p_identifier,
22296 )
22297 },
22298 }
22299 }
22300 extern "system" fn create_optical_flow_session_nv(
22301 device: vk::Device,
22302 p_create_info: *const vk::OpticalFlowSessionCreateInfoNV,
22303 p_allocator: *const vk::AllocationCallbacks,
22304 p_session: *mut vk::OpticalFlowSessionNV,
22305 ) -> vk::Result {
22306 let global = Self::instance();
22307 let device_info = global.get_device_info(device).unwrap();
22309 let dispatch_table = &device_info.dispatch_table.nv_optical_flow;
22310 let layer_result = device_info
22311 .customized_info
22312 .borrow()
22313 .hooks()
22314 .create_optical_flow_session_nv(unsafe { p_create_info.as_ref() }.unwrap(), unsafe {
22315 p_allocator.as_ref()
22316 });
22317 match layer_result {
22318 LayerResult::Handled(res) => match res {
22319 Ok(res) => {
22320 *unsafe { p_session.as_mut() }.unwrap() = res;
22321 vk::Result::SUCCESS
22322 }
22323 Err(e) => e,
22324 },
22325 LayerResult::Unhandled => unsafe {
22326 (dispatch_table.create_optical_flow_session_nv)(
22327 device,
22328 p_create_info,
22329 p_allocator,
22330 p_session,
22331 )
22332 },
22333 }
22334 }
22335 extern "system" fn destroy_optical_flow_session_nv(
22336 device: vk::Device,
22337 session: vk::OpticalFlowSessionNV,
22338 p_allocator: *const vk::AllocationCallbacks,
22339 ) {
22340 let global = Self::instance();
22341 let device_info = global.get_device_info(device).unwrap();
22343 let dispatch_table = &device_info.dispatch_table.nv_optical_flow;
22344 let layer_result = device_info
22345 .customized_info
22346 .borrow()
22347 .hooks()
22348 .destroy_optical_flow_session_nv(session, unsafe { p_allocator.as_ref() });
22349 match layer_result {
22350 LayerResult::Handled(res) => res,
22351 LayerResult::Unhandled => unsafe {
22352 (dispatch_table.destroy_optical_flow_session_nv)(device, session, p_allocator)
22353 },
22354 }
22355 }
22356 extern "system" fn bind_optical_flow_session_image_nv(
22357 device: vk::Device,
22358 session: vk::OpticalFlowSessionNV,
22359 binding_point: vk::OpticalFlowSessionBindingPointNV,
22360 view: vk::ImageView,
22361 layout: vk::ImageLayout,
22362 ) -> vk::Result {
22363 let global = Self::instance();
22364 let device_info = global.get_device_info(device).unwrap();
22366 let dispatch_table = &device_info.dispatch_table.nv_optical_flow;
22367 let layer_result = device_info
22368 .customized_info
22369 .borrow()
22370 .hooks()
22371 .bind_optical_flow_session_image_nv(session, binding_point, view, layout);
22372 match layer_result {
22373 LayerResult::Handled(res) => match res {
22374 Ok(()) => vk::Result::SUCCESS,
22375 Err(e) => e,
22376 },
22377 LayerResult::Unhandled => unsafe {
22378 (dispatch_table.bind_optical_flow_session_image_nv)(
22379 device,
22380 session,
22381 binding_point,
22382 view,
22383 layout,
22384 )
22385 },
22386 }
22387 }
22388 extern "system" fn cmd_optical_flow_execute_nv(
22389 command_buffer: vk::CommandBuffer,
22390 session: vk::OpticalFlowSessionNV,
22391 p_execute_info: *const vk::OpticalFlowExecuteInfoNV,
22392 ) {
22393 let global = Self::instance();
22394 let device_info = global.get_device_info(command_buffer).unwrap();
22396 let dispatch_table = &device_info.dispatch_table.nv_optical_flow;
22397 let layer_result = device_info
22398 .customized_info
22399 .borrow()
22400 .hooks()
22401 .cmd_optical_flow_execute_nv(
22402 command_buffer,
22403 session,
22404 unsafe { p_execute_info.as_ref() }.unwrap(),
22405 );
22406 match layer_result {
22407 LayerResult::Handled(res) => res,
22408 LayerResult::Unhandled => unsafe {
22409 (dispatch_table.cmd_optical_flow_execute_nv)(
22410 command_buffer,
22411 session,
22412 p_execute_info,
22413 )
22414 },
22415 }
22416 }
22417 extern "system" fn get_framebuffer_tile_properties_qcom(
22418 device: vk::Device,
22419 framebuffer: vk::Framebuffer,
22420 p_properties_count: *mut u32,
22421 p_properties: *mut vk::TilePropertiesQCOM,
22422 ) -> vk::Result {
22423 let global = Self::instance();
22424 let device_info = global.get_device_info(device).unwrap();
22426 let dispatch_table = &device_info.dispatch_table.qcom_tile_properties;
22427 let layer_result = device_info
22428 .customized_info
22429 .borrow()
22430 .hooks()
22431 .get_framebuffer_tile_properties_qcom(
22432 framebuffer,
22433 unsafe { ptr_as_uninit_mut(p_properties_count) }.unwrap(),
22434 unsafe { maybe_uninit_slice_from_raw_parts_mut(p_properties, p_properties_count) },
22435 );
22436 match layer_result {
22437 LayerResult::Handled(res) => match res {
22438 Ok(()) => vk::Result::SUCCESS,
22439 Err(e) => e,
22440 },
22441 LayerResult::Unhandled => unsafe {
22442 (dispatch_table.get_framebuffer_tile_properties_qcom)(
22443 device,
22444 framebuffer,
22445 p_properties_count,
22446 p_properties,
22447 )
22448 },
22449 }
22450 }
22451 extern "system" fn get_dynamic_rendering_tile_properties_qcom(
22452 device: vk::Device,
22453 p_rendering_info: *const vk::RenderingInfo,
22454 p_properties: *mut vk::TilePropertiesQCOM,
22455 ) -> vk::Result {
22456 let global = Self::instance();
22457 let device_info = global.get_device_info(device).unwrap();
22459 let dispatch_table = &device_info.dispatch_table.qcom_tile_properties;
22460 let layer_result = device_info
22461 .customized_info
22462 .borrow()
22463 .hooks()
22464 .get_dynamic_rendering_tile_properties_qcom(
22465 unsafe { p_rendering_info.as_ref() }.unwrap(),
22466 unsafe { ptr_as_uninit_mut(p_properties) }.unwrap(),
22467 );
22468 match layer_result {
22469 LayerResult::Handled(res) => match res {
22470 Ok(()) => vk::Result::SUCCESS,
22471 Err(e) => e,
22472 },
22473 LayerResult::Unhandled => unsafe {
22474 (dispatch_table.get_dynamic_rendering_tile_properties_qcom)(
22475 device,
22476 p_rendering_info,
22477 p_properties,
22478 )
22479 },
22480 }
22481 }
22482 extern "system" fn create_acceleration_structure_khr(
22483 device: vk::Device,
22484 p_create_info: *const vk::AccelerationStructureCreateInfoKHR,
22485 p_allocator: *const vk::AllocationCallbacks,
22486 p_acceleration_structure: *mut vk::AccelerationStructureKHR,
22487 ) -> vk::Result {
22488 let global = Self::instance();
22489 let device_info = global.get_device_info(device).unwrap();
22491 let dispatch_table = &device_info.dispatch_table.khr_acceleration_structure;
22492 let layer_result = device_info
22493 .customized_info
22494 .borrow()
22495 .hooks()
22496 .create_acceleration_structure_khr(
22497 unsafe { p_create_info.as_ref() }.unwrap(),
22498 unsafe { p_allocator.as_ref() },
22499 );
22500 match layer_result {
22501 LayerResult::Handled(res) => match res {
22502 Ok(res) => {
22503 *unsafe { p_acceleration_structure.as_mut() }.unwrap() = res;
22504 vk::Result::SUCCESS
22505 }
22506 Err(e) => e,
22507 },
22508 LayerResult::Unhandled => unsafe {
22509 (dispatch_table.create_acceleration_structure_khr)(
22510 device,
22511 p_create_info,
22512 p_allocator,
22513 p_acceleration_structure,
22514 )
22515 },
22516 }
22517 }
22518 extern "system" fn destroy_acceleration_structure_khr(
22519 device: vk::Device,
22520 acceleration_structure: vk::AccelerationStructureKHR,
22521 p_allocator: *const vk::AllocationCallbacks,
22522 ) {
22523 let global = Self::instance();
22524 let device_info = global.get_device_info(device).unwrap();
22526 let dispatch_table = &device_info.dispatch_table.khr_acceleration_structure;
22527 let layer_result = device_info
22528 .customized_info
22529 .borrow()
22530 .hooks()
22531 .destroy_acceleration_structure_khr(acceleration_structure, unsafe {
22532 p_allocator.as_ref()
22533 });
22534 match layer_result {
22535 LayerResult::Handled(res) => res,
22536 LayerResult::Unhandled => unsafe {
22537 (dispatch_table.destroy_acceleration_structure_khr)(
22538 device,
22539 acceleration_structure,
22540 p_allocator,
22541 )
22542 },
22543 }
22544 }
22545 extern "system" fn copy_acceleration_structure_khr(
22546 device: vk::Device,
22547 deferred_operation: vk::DeferredOperationKHR,
22548 p_info: *const vk::CopyAccelerationStructureInfoKHR,
22549 ) -> vk::Result {
22550 let global = Self::instance();
22551 let device_info = global.get_device_info(device).unwrap();
22553 let dispatch_table = &device_info.dispatch_table.khr_acceleration_structure;
22554 let layer_result = device_info
22555 .customized_info
22556 .borrow()
22557 .hooks()
22558 .copy_acceleration_structure_khr(
22559 deferred_operation,
22560 unsafe { p_info.as_ref() }.unwrap(),
22561 );
22562 match layer_result {
22563 LayerResult::Handled(res) => match res {
22564 Ok(()) => vk::Result::SUCCESS,
22565 Err(e) => e,
22566 },
22567 LayerResult::Unhandled => unsafe {
22568 (dispatch_table.copy_acceleration_structure_khr)(device, deferred_operation, p_info)
22569 },
22570 }
22571 }
22572 extern "system" fn copy_acceleration_structure_to_memory_khr(
22573 device: vk::Device,
22574 deferred_operation: vk::DeferredOperationKHR,
22575 p_info: *const vk::CopyAccelerationStructureToMemoryInfoKHR,
22576 ) -> vk::Result {
22577 let global = Self::instance();
22578 let device_info = global.get_device_info(device).unwrap();
22580 let dispatch_table = &device_info.dispatch_table.khr_acceleration_structure;
22581 let layer_result = device_info
22582 .customized_info
22583 .borrow()
22584 .hooks()
22585 .copy_acceleration_structure_to_memory_khr(
22586 deferred_operation,
22587 unsafe { p_info.as_ref() }.unwrap(),
22588 );
22589 match layer_result {
22590 LayerResult::Handled(res) => match res {
22591 Ok(()) => vk::Result::SUCCESS,
22592 Err(e) => e,
22593 },
22594 LayerResult::Unhandled => unsafe {
22595 (dispatch_table.copy_acceleration_structure_to_memory_khr)(
22596 device,
22597 deferred_operation,
22598 p_info,
22599 )
22600 },
22601 }
22602 }
22603 extern "system" fn copy_memory_to_acceleration_structure_khr(
22604 device: vk::Device,
22605 deferred_operation: vk::DeferredOperationKHR,
22606 p_info: *const vk::CopyMemoryToAccelerationStructureInfoKHR,
22607 ) -> vk::Result {
22608 let global = Self::instance();
22609 let device_info = global.get_device_info(device).unwrap();
22611 let dispatch_table = &device_info.dispatch_table.khr_acceleration_structure;
22612 let layer_result = device_info
22613 .customized_info
22614 .borrow()
22615 .hooks()
22616 .copy_memory_to_acceleration_structure_khr(
22617 deferred_operation,
22618 unsafe { p_info.as_ref() }.unwrap(),
22619 );
22620 match layer_result {
22621 LayerResult::Handled(res) => match res {
22622 Ok(()) => vk::Result::SUCCESS,
22623 Err(e) => e,
22624 },
22625 LayerResult::Unhandled => unsafe {
22626 (dispatch_table.copy_memory_to_acceleration_structure_khr)(
22627 device,
22628 deferred_operation,
22629 p_info,
22630 )
22631 },
22632 }
22633 }
22634 extern "system" fn write_acceleration_structures_properties_khr(
22635 device: vk::Device,
22636 acceleration_structure_count: u32,
22637 p_acceleration_structures: *const vk::AccelerationStructureKHR,
22638 query_type: vk::QueryType,
22639 data_size: usize,
22640 p_data: *mut c_void,
22641 stride: usize,
22642 ) -> vk::Result {
22643 let global = Self::instance();
22644 let device_info = global.get_device_info(device).unwrap();
22646 let dispatch_table = &device_info.dispatch_table.khr_acceleration_structure;
22647 let layer_result = device_info
22648 .customized_info
22649 .borrow()
22650 .hooks()
22651 .write_acceleration_structures_properties_khr(
22652 unsafe {
22653 slice_from_raw_parts(p_acceleration_structures, acceleration_structure_count)
22654 },
22655 query_type,
22656 unsafe { uninit_slice_from_raw_parts_mut(p_data as *mut u8, data_size) },
22657 stride,
22658 );
22659 match layer_result {
22660 LayerResult::Handled(res) => match res {
22661 Ok(()) => vk::Result::SUCCESS,
22662 Err(e) => e,
22663 },
22664 LayerResult::Unhandled => unsafe {
22665 (dispatch_table.write_acceleration_structures_properties_khr)(
22666 device,
22667 acceleration_structure_count,
22668 p_acceleration_structures,
22669 query_type,
22670 data_size,
22671 p_data,
22672 stride,
22673 )
22674 },
22675 }
22676 }
22677 extern "system" fn cmd_copy_acceleration_structure_khr(
22678 command_buffer: vk::CommandBuffer,
22679 p_info: *const vk::CopyAccelerationStructureInfoKHR,
22680 ) {
22681 let global = Self::instance();
22682 let device_info = global.get_device_info(command_buffer).unwrap();
22684 let dispatch_table = &device_info.dispatch_table.khr_acceleration_structure;
22685 let layer_result = device_info
22686 .customized_info
22687 .borrow()
22688 .hooks()
22689 .cmd_copy_acceleration_structure_khr(
22690 command_buffer,
22691 unsafe { p_info.as_ref() }.unwrap(),
22692 );
22693 match layer_result {
22694 LayerResult::Handled(res) => res,
22695 LayerResult::Unhandled => unsafe {
22696 (dispatch_table.cmd_copy_acceleration_structure_khr)(command_buffer, p_info)
22697 },
22698 }
22699 }
22700 extern "system" fn cmd_copy_acceleration_structure_to_memory_khr(
22701 command_buffer: vk::CommandBuffer,
22702 p_info: *const vk::CopyAccelerationStructureToMemoryInfoKHR,
22703 ) {
22704 let global = Self::instance();
22705 let device_info = global.get_device_info(command_buffer).unwrap();
22707 let dispatch_table = &device_info.dispatch_table.khr_acceleration_structure;
22708 let layer_result = device_info
22709 .customized_info
22710 .borrow()
22711 .hooks()
22712 .cmd_copy_acceleration_structure_to_memory_khr(
22713 command_buffer,
22714 unsafe { p_info.as_ref() }.unwrap(),
22715 );
22716 match layer_result {
22717 LayerResult::Handled(res) => res,
22718 LayerResult::Unhandled => unsafe {
22719 (dispatch_table.cmd_copy_acceleration_structure_to_memory_khr)(
22720 command_buffer,
22721 p_info,
22722 )
22723 },
22724 }
22725 }
22726 extern "system" fn cmd_copy_memory_to_acceleration_structure_khr(
22727 command_buffer: vk::CommandBuffer,
22728 p_info: *const vk::CopyMemoryToAccelerationStructureInfoKHR,
22729 ) {
22730 let global = Self::instance();
22731 let device_info = global.get_device_info(command_buffer).unwrap();
22733 let dispatch_table = &device_info.dispatch_table.khr_acceleration_structure;
22734 let layer_result = device_info
22735 .customized_info
22736 .borrow()
22737 .hooks()
22738 .cmd_copy_memory_to_acceleration_structure_khr(
22739 command_buffer,
22740 unsafe { p_info.as_ref() }.unwrap(),
22741 );
22742 match layer_result {
22743 LayerResult::Handled(res) => res,
22744 LayerResult::Unhandled => unsafe {
22745 (dispatch_table.cmd_copy_memory_to_acceleration_structure_khr)(
22746 command_buffer,
22747 p_info,
22748 )
22749 },
22750 }
22751 }
22752 extern "system" fn get_acceleration_structure_device_address_khr(
22753 device: vk::Device,
22754 p_info: *const vk::AccelerationStructureDeviceAddressInfoKHR,
22755 ) -> vk::DeviceAddress {
22756 let global = Self::instance();
22757 let device_info = global.get_device_info(device).unwrap();
22759 let dispatch_table = &device_info.dispatch_table.khr_acceleration_structure;
22760 let layer_result = device_info
22761 .customized_info
22762 .borrow()
22763 .hooks()
22764 .get_acceleration_structure_device_address_khr(unsafe { p_info.as_ref() }.unwrap());
22765 match layer_result {
22766 LayerResult::Handled(res) => res,
22767 LayerResult::Unhandled => unsafe {
22768 (dispatch_table.get_acceleration_structure_device_address_khr)(device, p_info)
22769 },
22770 }
22771 }
22772 extern "system" fn cmd_write_acceleration_structures_properties_khr(
22773 command_buffer: vk::CommandBuffer,
22774 acceleration_structure_count: u32,
22775 p_acceleration_structures: *const vk::AccelerationStructureKHR,
22776 query_type: vk::QueryType,
22777 query_pool: vk::QueryPool,
22778 first_query: u32,
22779 ) {
22780 let global = Self::instance();
22781 let device_info = global.get_device_info(command_buffer).unwrap();
22783 let dispatch_table = &device_info.dispatch_table.khr_acceleration_structure;
22784 let layer_result = device_info
22785 .customized_info
22786 .borrow()
22787 .hooks()
22788 .cmd_write_acceleration_structures_properties_khr(
22789 command_buffer,
22790 unsafe {
22791 slice_from_raw_parts(p_acceleration_structures, acceleration_structure_count)
22792 },
22793 query_type,
22794 query_pool,
22795 first_query,
22796 );
22797 match layer_result {
22798 LayerResult::Handled(res) => res,
22799 LayerResult::Unhandled => unsafe {
22800 (dispatch_table.cmd_write_acceleration_structures_properties_khr)(
22801 command_buffer,
22802 acceleration_structure_count,
22803 p_acceleration_structures,
22804 query_type,
22805 query_pool,
22806 first_query,
22807 )
22808 },
22809 }
22810 }
22811 extern "system" fn get_device_acceleration_structure_compatibility_khr(
22812 device: vk::Device,
22813 p_version_info: *const vk::AccelerationStructureVersionInfoKHR,
22814 p_compatibility: *mut vk::AccelerationStructureCompatibilityKHR,
22815 ) {
22816 let global = Self::instance();
22817 let device_info = global.get_device_info(device).unwrap();
22819 let dispatch_table = &device_info.dispatch_table.khr_acceleration_structure;
22820 let layer_result = device_info
22821 .customized_info
22822 .borrow()
22823 .hooks()
22824 .get_device_acceleration_structure_compatibility_khr(
22825 unsafe { p_version_info.as_ref() }.unwrap(),
22826 );
22827 match layer_result {
22828 LayerResult::Handled(res) => {
22829 *unsafe { p_compatibility.as_mut() }.unwrap() = res;
22830 }
22831 LayerResult::Unhandled => unsafe {
22832 (dispatch_table.get_device_acceleration_structure_compatibility_khr)(
22833 device,
22834 p_version_info,
22835 p_compatibility,
22836 )
22837 },
22838 }
22839 }
22840 extern "system" fn get_acceleration_structure_build_sizes_khr(
22841 device: vk::Device,
22842 build_type: vk::AccelerationStructureBuildTypeKHR,
22843 p_build_info: *const vk::AccelerationStructureBuildGeometryInfoKHR,
22844 p_max_primitive_counts: *const u32,
22845 p_size_info: *mut vk::AccelerationStructureBuildSizesInfoKHR,
22846 ) {
22847 let global = Self::instance();
22848 let device_info = global.get_device_info(device).unwrap();
22850 let dispatch_table = &device_info.dispatch_table.khr_acceleration_structure;
22851 let layer_result = device_info
22852 .customized_info
22853 .borrow()
22854 .hooks()
22855 .get_acceleration_structure_build_sizes_khr(
22856 build_type,
22857 unsafe { p_build_info.as_ref() }.unwrap(),
22858 unsafe {
22859 maybe_slice_from_raw_parts(
22860 p_max_primitive_counts,
22861 unsafe { p_build_info.as_ref() }.unwrap().geometry_count,
22862 )
22863 },
22864 unsafe { ptr_as_uninit_mut(p_size_info) }.unwrap(),
22865 );
22866 match layer_result {
22867 LayerResult::Handled(res) => res,
22868 LayerResult::Unhandled => unsafe {
22869 (dispatch_table.get_acceleration_structure_build_sizes_khr)(
22870 device,
22871 build_type,
22872 p_build_info,
22873 p_max_primitive_counts,
22874 p_size_info,
22875 )
22876 },
22877 }
22878 }
22879 extern "system" fn cmd_trace_rays_khr(
22880 command_buffer: vk::CommandBuffer,
22881 p_raygen_shader_binding_table: *const vk::StridedDeviceAddressRegionKHR,
22882 p_miss_shader_binding_table: *const vk::StridedDeviceAddressRegionKHR,
22883 p_hit_shader_binding_table: *const vk::StridedDeviceAddressRegionKHR,
22884 p_callable_shader_binding_table: *const vk::StridedDeviceAddressRegionKHR,
22885 width: u32,
22886 height: u32,
22887 depth: u32,
22888 ) {
22889 let global = Self::instance();
22890 let device_info = global.get_device_info(command_buffer).unwrap();
22892 let dispatch_table = &device_info.dispatch_table.khr_ray_tracing_pipeline;
22893 let layer_result = device_info
22894 .customized_info
22895 .borrow()
22896 .hooks()
22897 .cmd_trace_rays_khr(
22898 command_buffer,
22899 unsafe { p_raygen_shader_binding_table.as_ref() }.unwrap(),
22900 unsafe { p_miss_shader_binding_table.as_ref() }.unwrap(),
22901 unsafe { p_hit_shader_binding_table.as_ref() }.unwrap(),
22902 unsafe { p_callable_shader_binding_table.as_ref() }.unwrap(),
22903 width,
22904 height,
22905 depth,
22906 );
22907 match layer_result {
22908 LayerResult::Handled(res) => res,
22909 LayerResult::Unhandled => unsafe {
22910 (dispatch_table.cmd_trace_rays_khr)(
22911 command_buffer,
22912 p_raygen_shader_binding_table,
22913 p_miss_shader_binding_table,
22914 p_hit_shader_binding_table,
22915 p_callable_shader_binding_table,
22916 width,
22917 height,
22918 depth,
22919 )
22920 },
22921 }
22922 }
22923 extern "system" fn create_ray_tracing_pipelines_khr(
22924 device: vk::Device,
22925 deferred_operation: vk::DeferredOperationKHR,
22926 pipeline_cache: vk::PipelineCache,
22927 create_info_count: u32,
22928 p_create_infos: *const vk::RayTracingPipelineCreateInfoKHR,
22929 p_allocator: *const vk::AllocationCallbacks,
22930 p_pipelines: *mut vk::Pipeline,
22931 ) -> vk::Result {
22932 let global = Self::instance();
22933 let device_info = global.get_device_info(device).unwrap();
22935 let dispatch_table = &device_info.dispatch_table.khr_ray_tracing_pipeline;
22936 let layer_result = device_info
22937 .customized_info
22938 .borrow()
22939 .hooks()
22940 .create_ray_tracing_pipelines_khr(
22941 deferred_operation,
22942 pipeline_cache,
22943 unsafe { slice_from_raw_parts(p_create_infos, create_info_count) },
22944 unsafe { p_allocator.as_ref() },
22945 );
22946 match layer_result {
22947 LayerResult::Handled(res) => match res {
22948 Ok(res) => {
22949 unsafe {
22950 std::slice::from_raw_parts_mut(
22951 p_pipelines,
22952 create_info_count.try_into().unwrap(),
22953 )
22954 }
22955 .copy_from_slice(&res);
22956 vk::Result::SUCCESS
22957 }
22958 Err(e) => e,
22959 },
22960 LayerResult::Unhandled => unsafe {
22961 (dispatch_table.create_ray_tracing_pipelines_khr)(
22962 device,
22963 deferred_operation,
22964 pipeline_cache,
22965 create_info_count,
22966 p_create_infos,
22967 p_allocator,
22968 p_pipelines,
22969 )
22970 },
22971 }
22972 }
22973 extern "system" fn get_ray_tracing_capture_replay_shader_group_handles_khr(
22974 device: vk::Device,
22975 pipeline: vk::Pipeline,
22976 first_group: u32,
22977 group_count: u32,
22978 data_size: usize,
22979 p_data: *mut c_void,
22980 ) -> vk::Result {
22981 let global = Self::instance();
22982 let device_info = global.get_device_info(device).unwrap();
22984 let dispatch_table = &device_info.dispatch_table.khr_ray_tracing_pipeline;
22985 let layer_result = device_info
22986 .customized_info
22987 .borrow()
22988 .hooks()
22989 .get_ray_tracing_capture_replay_shader_group_handles_khr(
22990 pipeline,
22991 first_group,
22992 group_count,
22993 unsafe { uninit_slice_from_raw_parts_mut(p_data as *mut u8, data_size) },
22994 );
22995 match layer_result {
22996 LayerResult::Handled(res) => match res {
22997 Ok(()) => vk::Result::SUCCESS,
22998 Err(e) => e,
22999 },
23000 LayerResult::Unhandled => unsafe {
23001 (dispatch_table.get_ray_tracing_capture_replay_shader_group_handles_khr)(
23002 device,
23003 pipeline,
23004 first_group,
23005 group_count,
23006 data_size,
23007 p_data,
23008 )
23009 },
23010 }
23011 }
23012 extern "system" fn cmd_trace_rays_indirect_khr(
23013 command_buffer: vk::CommandBuffer,
23014 p_raygen_shader_binding_table: *const vk::StridedDeviceAddressRegionKHR,
23015 p_miss_shader_binding_table: *const vk::StridedDeviceAddressRegionKHR,
23016 p_hit_shader_binding_table: *const vk::StridedDeviceAddressRegionKHR,
23017 p_callable_shader_binding_table: *const vk::StridedDeviceAddressRegionKHR,
23018 indirect_device_address: vk::DeviceAddress,
23019 ) {
23020 let global = Self::instance();
23021 let device_info = global.get_device_info(command_buffer).unwrap();
23023 let dispatch_table = &device_info.dispatch_table.khr_ray_tracing_pipeline;
23024 let layer_result = device_info
23025 .customized_info
23026 .borrow()
23027 .hooks()
23028 .cmd_trace_rays_indirect_khr(
23029 command_buffer,
23030 unsafe { p_raygen_shader_binding_table.as_ref() }.unwrap(),
23031 unsafe { p_miss_shader_binding_table.as_ref() }.unwrap(),
23032 unsafe { p_hit_shader_binding_table.as_ref() }.unwrap(),
23033 unsafe { p_callable_shader_binding_table.as_ref() }.unwrap(),
23034 indirect_device_address,
23035 );
23036 match layer_result {
23037 LayerResult::Handled(res) => res,
23038 LayerResult::Unhandled => unsafe {
23039 (dispatch_table.cmd_trace_rays_indirect_khr)(
23040 command_buffer,
23041 p_raygen_shader_binding_table,
23042 p_miss_shader_binding_table,
23043 p_hit_shader_binding_table,
23044 p_callable_shader_binding_table,
23045 indirect_device_address,
23046 )
23047 },
23048 }
23049 }
23050 extern "system" fn get_ray_tracing_shader_group_stack_size_khr(
23051 device: vk::Device,
23052 pipeline: vk::Pipeline,
23053 group: u32,
23054 group_shader: vk::ShaderGroupShaderKHR,
23055 ) -> vk::DeviceSize {
23056 let global = Self::instance();
23057 let device_info = global.get_device_info(device).unwrap();
23059 let dispatch_table = &device_info.dispatch_table.khr_ray_tracing_pipeline;
23060 let layer_result = device_info
23061 .customized_info
23062 .borrow()
23063 .hooks()
23064 .get_ray_tracing_shader_group_stack_size_khr(pipeline, group, group_shader);
23065 match layer_result {
23066 LayerResult::Handled(res) => res,
23067 LayerResult::Unhandled => unsafe {
23068 (dispatch_table.get_ray_tracing_shader_group_stack_size_khr)(
23069 device,
23070 pipeline,
23071 group,
23072 group_shader,
23073 )
23074 },
23075 }
23076 }
23077 extern "system" fn cmd_set_ray_tracing_pipeline_stack_size_khr(
23078 command_buffer: vk::CommandBuffer,
23079 pipeline_stack_size: u32,
23080 ) {
23081 let global = Self::instance();
23082 let device_info = global.get_device_info(command_buffer).unwrap();
23084 let dispatch_table = &device_info.dispatch_table.khr_ray_tracing_pipeline;
23085 let layer_result = device_info
23086 .customized_info
23087 .borrow()
23088 .hooks()
23089 .cmd_set_ray_tracing_pipeline_stack_size_khr(command_buffer, pipeline_stack_size);
23090 match layer_result {
23091 LayerResult::Handled(res) => res,
23092 LayerResult::Unhandled => unsafe {
23093 (dispatch_table.cmd_set_ray_tracing_pipeline_stack_size_khr)(
23094 command_buffer,
23095 pipeline_stack_size,
23096 )
23097 },
23098 }
23099 }
23100 extern "system" fn cmd_draw_mesh_tasks_ext(
23101 command_buffer: vk::CommandBuffer,
23102 group_countx: u32,
23103 group_county: u32,
23104 group_countz: u32,
23105 ) {
23106 let global = Self::instance();
23107 let device_info = global.get_device_info(command_buffer).unwrap();
23109 let dispatch_table = &device_info.dispatch_table.ext_mesh_shader;
23110 let layer_result = device_info
23111 .customized_info
23112 .borrow()
23113 .hooks()
23114 .cmd_draw_mesh_tasks_ext(command_buffer, group_countx, group_county, group_countz);
23115 match layer_result {
23116 LayerResult::Handled(res) => res,
23117 LayerResult::Unhandled => unsafe {
23118 (dispatch_table.cmd_draw_mesh_tasks_ext)(
23119 command_buffer,
23120 group_countx,
23121 group_county,
23122 group_countz,
23123 )
23124 },
23125 }
23126 }
23127 extern "system" fn cmd_draw_mesh_tasks_indirect_ext(
23128 command_buffer: vk::CommandBuffer,
23129 buffer: vk::Buffer,
23130 offset: vk::DeviceSize,
23131 draw_count: u32,
23132 stride: u32,
23133 ) {
23134 let global = Self::instance();
23135 let device_info = global.get_device_info(command_buffer).unwrap();
23137 let dispatch_table = &device_info.dispatch_table.ext_mesh_shader;
23138 let layer_result = device_info
23139 .customized_info
23140 .borrow()
23141 .hooks()
23142 .cmd_draw_mesh_tasks_indirect_ext(command_buffer, buffer, offset, draw_count, stride);
23143 match layer_result {
23144 LayerResult::Handled(res) => res,
23145 LayerResult::Unhandled => unsafe {
23146 (dispatch_table.cmd_draw_mesh_tasks_indirect_ext)(
23147 command_buffer,
23148 buffer,
23149 offset,
23150 draw_count,
23151 stride,
23152 )
23153 },
23154 }
23155 }
23156 extern "system" fn cmd_draw_mesh_tasks_indirect_count_ext(
23157 command_buffer: vk::CommandBuffer,
23158 buffer: vk::Buffer,
23159 offset: vk::DeviceSize,
23160 count_buffer: vk::Buffer,
23161 count_buffer_offset: vk::DeviceSize,
23162 max_draw_count: u32,
23163 stride: u32,
23164 ) {
23165 let global = Self::instance();
23166 let device_info = global.get_device_info(command_buffer).unwrap();
23168 let dispatch_table = &device_info.dispatch_table.ext_mesh_shader;
23169 let layer_result = device_info
23170 .customized_info
23171 .borrow()
23172 .hooks()
23173 .cmd_draw_mesh_tasks_indirect_count_ext(
23174 command_buffer,
23175 buffer,
23176 offset,
23177 count_buffer,
23178 count_buffer_offset,
23179 max_draw_count,
23180 stride,
23181 );
23182 match layer_result {
23183 LayerResult::Handled(res) => res,
23184 LayerResult::Unhandled => unsafe {
23185 (dispatch_table.cmd_draw_mesh_tasks_indirect_count_ext)(
23186 command_buffer,
23187 buffer,
23188 offset,
23189 count_buffer,
23190 count_buffer_offset,
23191 max_draw_count,
23192 stride,
23193 )
23194 },
23195 }
23196 }
23197}