Mercurial > games > semicongine

comparison fuhtark_test/Vulkan-Headers-1.4.334/include/vulkan/vulkan_shared.hpp @ 1501:f40d9d814c08 default tip main

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
did: correct vulkan-api generator
author sam <sam@basx.dev>
date Wed, 26 Nov 2025 23:34:29 +0700
parents
children
comparison
equal deleted inserted replaced
1500:91c8c3b7cbf0 1501:f40d9d814c08
1 // Copyright 2015-2025 The Khronos Group Inc.
2 //
3 // SPDX-License-Identifier: Apache-2.0 OR MIT
4 //
5
6 // This header is generated from the Khronos Vulkan XML API Registry.
7
8 #ifndef VULKAN_SHARED_HPP
9 #define VULKAN_SHARED_HPP
10
11 #include <vulkan/vulkan.hpp>
12
13 #if !defined( VULKAN_HPP_CXX_MODULE )
14 # include <atomic> // std::atomic_size_t
15 #endif
16
17 namespace VULKAN_HPP_NAMESPACE
18 {
19 #if !defined( VULKAN_HPP_NO_SMART_HANDLE )
20 template <typename HandleType>
21 class SharedHandleTraits;
22
23 class NoDestructor
24 {
25 };
26
27 template <typename HandleType, typename = void>
28 struct HasDestructorType : std::false_type
29 {
30 };
31
32 template <typename HandleType>
33 struct HasDestructorType<HandleType, decltype( (void)typename SharedHandleTraits<HandleType>::DestructorType() )> : std::true_type
34 {
35 };
36
37 template <typename HandleType, typename Enable = void>
38 struct GetDestructorType
39 {
40 using type = NoDestructor;
41 };
42
43 template <typename HandleType>
44 struct GetDestructorType<HandleType, typename std::enable_if<HasDestructorType<HandleType>::value>::type>
45 {
46 using type = typename SharedHandleTraits<HandleType>::DestructorType;
47 };
48
49 template <class HandleType>
50 using DestructorTypeOf = typename GetDestructorType<HandleType>::type;
51
52 template <class HandleType>
53 struct HasDestructor : std::integral_constant<bool, !std::is_same<DestructorTypeOf<HandleType>, NoDestructor>::value>
54 {
55 };
56
57 template <typename HandleType, typename = void>
58 struct HasPoolType : std::false_type
59 {
60 };
61
62 template <typename HandleType>
63 struct HasPoolType<HandleType, decltype( (void)typename SharedHandleTraits<HandleType>::deleter::PoolTypeExport() )> : std::true_type
64 {
65 };
66
67 template <typename HandleType, typename Enable = void>
68 struct GetPoolType
69 {
70 using type = NoDestructor;
71 };
72
73 template <typename HandleType>
74 struct GetPoolType<HandleType, typename std::enable_if<HasPoolType<HandleType>::value>::type>
75 {
76 using type = typename SharedHandleTraits<HandleType>::deleter::PoolTypeExport;
77 };
78
79 //=====================================================================================================================
80
81 template <typename HandleType>
82 class SharedHandle;
83
84 template <typename DestructorType, typename Deleter>
85 struct SharedHeader
86 {
87 SharedHeader( SharedHandle<DestructorType> parent, Deleter deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( Deleter() ) ) VULKAN_HPP_NOEXCEPT
88 : parent( std::move( parent ) )
89 , deleter( std::move( deleter ) )
90 {
91 }
92
93 SharedHandle<DestructorType> parent;
94 Deleter deleter;
95 };
96
97 template <typename Deleter>
98 struct SharedHeader<NoDestructor, Deleter>
99 {
100 SharedHeader( Deleter deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( Deleter() ) ) VULKAN_HPP_NOEXCEPT : deleter( std::move( deleter ) ) {}
101
102 Deleter deleter;
103 };
104
105 //=====================================================================================================================
106
107 template <typename HeaderType>
108 class ReferenceCounter
109 {
110 public:
111 template <typename... Args>
112 ReferenceCounter( Args &&... control_args ) : m_header( std::forward<Args>( control_args )... )
113 {
114 }
115
116 ReferenceCounter( const ReferenceCounter & ) = delete;
117 ReferenceCounter & operator=( const ReferenceCounter & ) = delete;
118
119 public:
120 size_t addRef() VULKAN_HPP_NOEXCEPT
121 {
122 // Relaxed memory order is sufficient since this does not impose any ordering on other operations
123 return m_ref_cnt.fetch_add( 1, std::memory_order_relaxed );
124 }
125
126 size_t release() VULKAN_HPP_NOEXCEPT
127 {
128 // A release memory order to ensure that all releases are ordered
129 return m_ref_cnt.fetch_sub( 1, std::memory_order_release );
130 }
131
132 public:
133 std::atomic_size_t m_ref_cnt{ 1 };
134 HeaderType m_header;
135 };
136
137 //=====================================================================================================================
138
139 template <typename HandleType, typename HeaderType, typename ForwardType = SharedHandle<HandleType>>
140 class SharedHandleBase
141 {
142 public:
143 SharedHandleBase() = default;
144
145 template <typename... Args>
146 SharedHandleBase( HandleType handle, Args &&... control_args )
147 : m_control( new ReferenceCounter<HeaderType>( std::forward<Args>( control_args )... ) ), m_handle( handle )
148 {
149 }
150
151 SharedHandleBase( const SharedHandleBase & o ) VULKAN_HPP_NOEXCEPT
152 {
153 o.addRef();
154 m_handle = o.m_handle;
155 m_control = o.m_control;
156 }
157
158 SharedHandleBase( SharedHandleBase && o ) VULKAN_HPP_NOEXCEPT
159 : m_control( o.m_control )
160 , m_handle( o.m_handle )
161 {
162 o.m_handle = nullptr;
163 o.m_control = nullptr;
164 }
165
166 SharedHandleBase & operator=( const SharedHandleBase & o ) VULKAN_HPP_NOEXCEPT
167 {
168 SharedHandleBase( o ).swap( *this );
169 return *this;
170 }
171
172 SharedHandleBase & operator=( SharedHandleBase && o ) VULKAN_HPP_NOEXCEPT
173 {
174 SharedHandleBase( std::move( o ) ).swap( *this );
175 return *this;
176 }
177
178 ~SharedHandleBase()
179 {
180 // only this function owns the last reference to the control block
181 // the same principle is used in the default deleter of std::shared_ptr
182 if ( m_control && ( m_control->release() == 1 ) )
183 {
184 // noop in x86, but does thread synchronization in ARM
185 // it is required to ensure that last thread is getting to destroy the control block
186 // by ordering all atomic operations before this fence
187 std::atomic_thread_fence( std::memory_order_acquire );
188 ForwardType::internalDestroy( getHeader(), m_handle );
189 delete m_control;
190 }
191 }
192
193 public:
194 HandleType get() const VULKAN_HPP_NOEXCEPT
195 {
196 return m_handle;
197 }
198
199 HandleType operator*() const VULKAN_HPP_NOEXCEPT
200 {
201 return m_handle;
202 }
203
204 explicit operator bool() const VULKAN_HPP_NOEXCEPT
205 {
206 return bool( m_handle );
207 }
208
209 # if defined( VULKAN_HPP_SMART_HANDLE_IMPLICIT_CAST )
210 operator HandleType() const VULKAN_HPP_NOEXCEPT
211 {
212 return m_handle;
213 }
214 # endif
215
216 const HandleType * operator->() const VULKAN_HPP_NOEXCEPT
217 {
218 return &m_handle;
219 }
220
221 HandleType * operator->() VULKAN_HPP_NOEXCEPT
222 {
223 return &m_handle;
224 }
225
226 void reset() VULKAN_HPP_NOEXCEPT
227 {
228 SharedHandleBase().swap( *this );
229 }
230
231 void swap( SharedHandleBase & o ) VULKAN_HPP_NOEXCEPT
232 {
233 std::swap( m_handle, o.m_handle );
234 std::swap( m_control, o.m_control );
235 }
236
237 template <typename T = HandleType>
238 typename std::enable_if<HasDestructor<T>::value, const SharedHandle<DestructorTypeOf<HandleType>> &>::type getDestructorType() const VULKAN_HPP_NOEXCEPT
239 {
240 return getHeader().parent;
241 }
242
243 protected:
244 template <typename T = HandleType>
245 static typename std::enable_if<!HasDestructor<T>::value, void>::type internalDestroy( const HeaderType & control, HandleType handle ) VULKAN_HPP_NOEXCEPT
246 {
247 control.deleter.destroy( handle );
248 }
249
250 template <typename T = HandleType>
251 static typename std::enable_if<HasDestructor<T>::value, void>::type internalDestroy( const HeaderType & control, HandleType handle ) VULKAN_HPP_NOEXCEPT
252 {
253 control.deleter.destroy( control.parent.get(), handle );
254 }
255
256 const HeaderType & getHeader() const VULKAN_HPP_NOEXCEPT
257 {
258 return m_control->m_header;
259 }
260
261 private:
262 void addRef() const VULKAN_HPP_NOEXCEPT
263 {
264 if ( m_control )
265 m_control->addRef();
266 }
267
268 protected:
269 ReferenceCounter<HeaderType> * m_control = nullptr;
270 HandleType m_handle{};
271 };
272
273 template <typename HandleType>
274 class SharedHandle : public SharedHandleBase<HandleType, SharedHeader<DestructorTypeOf<HandleType>, typename SharedHandleTraits<HandleType>::deleter>>
275 {
276 private:
277 using BaseType = SharedHandleBase<HandleType, SharedHeader<DestructorTypeOf<HandleType>, typename SharedHandleTraits<HandleType>::deleter>>;
278 using DeleterType = typename SharedHandleTraits<HandleType>::deleter;
279 friend BaseType;
280
281 public:
282 SharedHandle() = default;
283
284 template <typename T = HandleType, typename = typename std::enable_if<HasDestructor<T>::value && !HasPoolType<T>::value>::type>
285 explicit SharedHandle( HandleType handle,
286 SharedHandle<DestructorTypeOf<HandleType>> parent,
287 DeleterType deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( DeleterType() ) ) VULKAN_HPP_NOEXCEPT
288 : BaseType( handle, std::move( parent ), std::move( deleter ) )
289 {
290 }
291
292 template <typename Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE,
293 typename T = HandleType,
294 typename = typename std::enable_if<HasDestructor<T>::value && HasPoolType<T>::value>::type>
295 explicit SharedHandle( HandleType handle,
296 SharedHandle<DestructorTypeOf<HandleType>> parent,
297 SharedHandle<typename GetPoolType<HandleType>::type> pool,
298 const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT ) VULKAN_HPP_NOEXCEPT
299 : BaseType( handle, std::move( parent ), DeleterType{ std::move( pool ), dispatch } )
300 {
301 }
302
303 template <typename T = HandleType, typename = typename std::enable_if<!HasDestructor<T>::value>::type>
304 explicit SharedHandle( HandleType handle, DeleterType deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( DeleterType() ) ) VULKAN_HPP_NOEXCEPT
305 : BaseType( handle, std::move( deleter ) )
306 {
307 }
308
309 protected:
310 using BaseType::internalDestroy;
311 };
312
313 namespace detail
314 {
315 // Silence the function cast warnings.
316 # if defined( __GNUC__ ) && !defined( __clang__ ) && !defined( __INTEL_COMPILER )
317 # pragma GCC diagnostic push
318 # pragma GCC diagnostic ignored "-Wcast-function-type"
319 # elif defined( __clang__ ) && ( __clang_major__ >= 13 ) && !defined( __INTEL_COMPILER )
320 # pragma clang diagnostic push
321 # pragma clang diagnostic ignored "-Wcast-function-type"
322 # endif
323
324 template <typename HandleType, typename Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
325 class ObjectDestroyShared
326 {
327 public:
328 using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;
329
330 using DestroyFunctionPointerType =
331 typename std::conditional<HasDestructor<HandleType>::value,
332 void ( DestructorType::* )( HandleType, const AllocationCallbacks *, const Dispatcher & ) const,
333 void ( HandleType::* )( const AllocationCallbacks *, const Dispatcher & ) const>::type;
334
335 using SelectorType = typename std::conditional<HasDestructor<HandleType>::value, DestructorType, HandleType>::type;
336
337 ObjectDestroyShared( Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
338 const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
339 : m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType>( &SelectorType::destroy ) ) )
340 , m_dispatch( &dispatch )
341 , m_allocationCallbacks( allocationCallbacks )
342 {
343 }
344
345 public:
346 template <typename T = HandleType>
347 typename std::enable_if<HasDestructor<T>::value, void>::type destroy( DestructorType parent, HandleType handle ) const VULKAN_HPP_NOEXCEPT
348 {
349 VULKAN_HPP_ASSERT( m_destroy && m_dispatch );
350 ( parent.*m_destroy )( handle, m_allocationCallbacks, *m_dispatch );
351 }
352
353 template <typename T = HandleType>
354 typename std::enable_if<!HasDestructor<T>::value, void>::type destroy( HandleType handle ) const VULKAN_HPP_NOEXCEPT
355 {
356 VULKAN_HPP_ASSERT( m_destroy && m_dispatch );
357 ( handle.*m_destroy )( m_allocationCallbacks, *m_dispatch );
358 }
359
360 private:
361 DestroyFunctionPointerType m_destroy = nullptr;
362 const Dispatcher * m_dispatch = nullptr;
363 Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
364 };
365
366 template <typename HandleType, typename Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
367 class ObjectFreeShared
368 {
369 public:
370 using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;
371
372 using DestroyFunctionPointerType = void ( DestructorType::* )( HandleType, const AllocationCallbacks *, const Dispatcher & ) const;
373
374 ObjectFreeShared( Optional<const AllocationCallbacks> allocationCallbacks VULKAN_HPP_DEFAULT_ASSIGNMENT( nullptr ),
375 const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
376 : m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType>( &DestructorType::free ) ) )
377 , m_dispatch( &dispatch )
378 , m_allocationCallbacks( allocationCallbacks )
379 {
380 }
381
382 public:
383 void destroy( DestructorType parent, HandleType handle ) const VULKAN_HPP_NOEXCEPT
384 {
385 VULKAN_HPP_ASSERT( m_destroy && m_dispatch );
386 ( parent.*m_destroy )( handle, m_allocationCallbacks, *m_dispatch );
387 }
388
389 private:
390 DestroyFunctionPointerType m_destroy = nullptr;
391 const Dispatcher * m_dispatch = nullptr;
392 Optional<const AllocationCallbacks> m_allocationCallbacks = nullptr;
393 };
394
395 template <typename HandleType, typename Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
396 class ObjectReleaseShared
397 {
398 public:
399 using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;
400
401 using DestroyFunctionPointerType = void ( DestructorType::* )( HandleType, const Dispatcher & ) const;
402
403 ObjectReleaseShared( const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
404 : m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType>( &DestructorType::release ) ) ), m_dispatch( &dispatch )
405 {
406 }
407
408 public:
409 void destroy( DestructorType parent, HandleType handle ) const VULKAN_HPP_NOEXCEPT
410 {
411 VULKAN_HPP_ASSERT( m_destroy && m_dispatch );
412 ( parent.*m_destroy )( handle, *m_dispatch );
413 }
414
415 private:
416 DestroyFunctionPointerType m_destroy = nullptr;
417 const Dispatcher * m_dispatch = nullptr;
418 };
419
420 template <typename HandleType, typename PoolType, typename Dispatcher = VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>
421 class PoolFreeShared
422 {
423 public:
424 using DestructorType = typename SharedHandleTraits<HandleType>::DestructorType;
425
426 using PoolTypeExport = PoolType;
427
428 using ReturnType = decltype( std::declval<DestructorType>().free( PoolType(), 0u, nullptr, Dispatcher() ) );
429
430 using DestroyFunctionPointerType = ReturnType ( DestructorType::* )( PoolType, uint32_t, const HandleType *, const Dispatcher & ) const;
431
432 PoolFreeShared() = default;
433
434 PoolFreeShared( SharedHandle<PoolType> pool, const Dispatcher & dispatch VULKAN_HPP_DEFAULT_DISPATCHER_ASSIGNMENT )
435 : m_destroy( reinterpret_cast<decltype( m_destroy )>( static_cast<DestroyFunctionPointerType>( &DestructorType::free ) ) )
436 , m_dispatch( &dispatch )
437 , m_pool( std::move( pool ) )
438 {
439 }
440
441 public:
442 void destroy( DestructorType parent, HandleType handle ) const VULKAN_HPP_NOEXCEPT
443 {
444 VULKAN_HPP_ASSERT( m_destroy && m_dispatch && m_pool );
445 ( parent.*m_destroy )( m_pool.get(), 1u, &handle, *m_dispatch );
446 }
447
448 private:
449 DestroyFunctionPointerType m_destroy = nullptr;
450 const Dispatcher * m_dispatch = nullptr;
451 SharedHandle<PoolType> m_pool{};
452 };
453
454 # if defined( __GNUC__ ) && !defined( __clang__ ) && !defined( __INTEL_COMPILER )
455 # pragma GCC diagnostic pop
456 # elif defined( __clang__ ) && ( __clang_major__ >= 13 ) && !defined( __INTEL_COMPILER )
457 # pragma clang diagnostic pop
458 # endif
459 } // namespace detail
460
461 //======================
462 //=== SHARED HANDLEs ===
463 //======================
464
465 //=== VK_VERSION_1_0 ===
466 template <>
467 class SharedHandleTraits<Instance>
468 {
469 public:
470 using DestructorType = NoDestructor;
471 using deleter = detail::ObjectDestroyShared<Instance>;
472 };
473
474 using SharedInstance = SharedHandle<Instance>;
475
476 template <>
477 class SharedHandleTraits<Device>
478 {
479 public:
480 using DestructorType = NoDestructor;
481 using deleter = detail::ObjectDestroyShared<Device>;
482 };
483
484 using SharedDevice = SharedHandle<Device>;
485
486 template <>
487 class SharedHandleTraits<DeviceMemory>
488 {
489 public:
490 using DestructorType = Device;
491 using deleter = detail::ObjectFreeShared<DeviceMemory>;
492 };
493
494 using SharedDeviceMemory = SharedHandle<DeviceMemory>;
495
496 template <>
497 class SharedHandleTraits<Fence>
498 {
499 public:
500 using DestructorType = Device;
501 using deleter = detail::ObjectDestroyShared<Fence>;
502 };
503
504 using SharedFence = SharedHandle<Fence>;
505
506 template <>
507 class SharedHandleTraits<Semaphore>
508 {
509 public:
510 using DestructorType = Device;
511 using deleter = detail::ObjectDestroyShared<Semaphore>;
512 };
513
514 using SharedSemaphore = SharedHandle<Semaphore>;
515
516 template <>
517 class SharedHandleTraits<QueryPool>
518 {
519 public:
520 using DestructorType = Device;
521 using deleter = detail::ObjectDestroyShared<QueryPool>;
522 };
523
524 using SharedQueryPool = SharedHandle<QueryPool>;
525
526 template <>
527 class SharedHandleTraits<Buffer>
528 {
529 public:
530 using DestructorType = Device;
531 using deleter = detail::ObjectDestroyShared<Buffer>;
532 };
533
534 using SharedBuffer = SharedHandle<Buffer>;
535
536 template <>
537 class SharedHandleTraits<Image>
538 {
539 public:
540 using DestructorType = Device;
541 using deleter = detail::ObjectDestroyShared<Image>;
542 };
543
544 using SharedImage = SharedHandle<Image>;
545
546 template <>
547 class SharedHandleTraits<ImageView>
548 {
549 public:
550 using DestructorType = Device;
551 using deleter = detail::ObjectDestroyShared<ImageView>;
552 };
553
554 using SharedImageView = SharedHandle<ImageView>;
555
556 template <>
557 class SharedHandleTraits<CommandPool>
558 {
559 public:
560 using DestructorType = Device;
561 using deleter = detail::ObjectDestroyShared<CommandPool>;
562 };
563
564 using SharedCommandPool = SharedHandle<CommandPool>;
565
566 template <>
567 class SharedHandleTraits<CommandBuffer>
568 {
569 public:
570 using DestructorType = Device;
571 using deleter = detail::PoolFreeShared<CommandBuffer, CommandPool>;
572 };
573
574 using SharedCommandBuffer = SharedHandle<CommandBuffer>;
575
576 template <>
577 class SharedHandleTraits<Event>
578 {
579 public:
580 using DestructorType = Device;
581 using deleter = detail::ObjectDestroyShared<Event>;
582 };
583
584 using SharedEvent = SharedHandle<Event>;
585
586 template <>
587 class SharedHandleTraits<BufferView>
588 {
589 public:
590 using DestructorType = Device;
591 using deleter = detail::ObjectDestroyShared<BufferView>;
592 };
593
594 using SharedBufferView = SharedHandle<BufferView>;
595
596 template <>
597 class SharedHandleTraits<ShaderModule>
598 {
599 public:
600 using DestructorType = Device;
601 using deleter = detail::ObjectDestroyShared<ShaderModule>;
602 };
603
604 using SharedShaderModule = SharedHandle<ShaderModule>;
605
606 template <>
607 class SharedHandleTraits<PipelineCache>
608 {
609 public:
610 using DestructorType = Device;
611 using deleter = detail::ObjectDestroyShared<PipelineCache>;
612 };
613
614 using SharedPipelineCache = SharedHandle<PipelineCache>;
615
616 template <>
617 class SharedHandleTraits<Pipeline>
618 {
619 public:
620 using DestructorType = Device;
621 using deleter = detail::ObjectDestroyShared<Pipeline>;
622 };
623
624 using SharedPipeline = SharedHandle<Pipeline>;
625
626 template <>
627 class SharedHandleTraits<PipelineLayout>
628 {
629 public:
630 using DestructorType = Device;
631 using deleter = detail::ObjectDestroyShared<PipelineLayout>;
632 };
633
634 using SharedPipelineLayout = SharedHandle<PipelineLayout>;
635
636 template <>
637 class SharedHandleTraits<Sampler>
638 {
639 public:
640 using DestructorType = Device;
641 using deleter = detail::ObjectDestroyShared<Sampler>;
642 };
643
644 using SharedSampler = SharedHandle<Sampler>;
645
646 template <>
647 class SharedHandleTraits<DescriptorPool>
648 {
649 public:
650 using DestructorType = Device;
651 using deleter = detail::ObjectDestroyShared<DescriptorPool>;
652 };
653
654 using SharedDescriptorPool = SharedHandle<DescriptorPool>;
655
656 template <>
657 class SharedHandleTraits<DescriptorSet>
658 {
659 public:
660 using DestructorType = Device;
661 using deleter = detail::PoolFreeShared<DescriptorSet, DescriptorPool>;
662 };
663
664 using SharedDescriptorSet = SharedHandle<DescriptorSet>;
665
666 template <>
667 class SharedHandleTraits<DescriptorSetLayout>
668 {
669 public:
670 using DestructorType = Device;
671 using deleter = detail::ObjectDestroyShared<DescriptorSetLayout>;
672 };
673
674 using SharedDescriptorSetLayout = SharedHandle<DescriptorSetLayout>;
675
676 template <>
677 class SharedHandleTraits<Framebuffer>
678 {
679 public:
680 using DestructorType = Device;
681 using deleter = detail::ObjectDestroyShared<Framebuffer>;
682 };
683
684 using SharedFramebuffer = SharedHandle<Framebuffer>;
685
686 template <>
687 class SharedHandleTraits<RenderPass>
688 {
689 public:
690 using DestructorType = Device;
691 using deleter = detail::ObjectDestroyShared<RenderPass>;
692 };
693
694 using SharedRenderPass = SharedHandle<RenderPass>;
695
696 //=== VK_VERSION_1_1 ===
697 template <>
698 class SharedHandleTraits<DescriptorUpdateTemplate>
699 {
700 public:
701 using DestructorType = Device;
702 using deleter = detail::ObjectDestroyShared<DescriptorUpdateTemplate>;
703 };
704
705 using SharedDescriptorUpdateTemplate = SharedHandle<DescriptorUpdateTemplate>;
706 using SharedDescriptorUpdateTemplateKHR = SharedHandle<DescriptorUpdateTemplate>;
707
708 template <>
709 class SharedHandleTraits<SamplerYcbcrConversion>
710 {
711 public:
712 using DestructorType = Device;
713 using deleter = detail::ObjectDestroyShared<SamplerYcbcrConversion>;
714 };
715
716 using SharedSamplerYcbcrConversion = SharedHandle<SamplerYcbcrConversion>;
717 using SharedSamplerYcbcrConversionKHR = SharedHandle<SamplerYcbcrConversion>;
718
719 //=== VK_VERSION_1_3 ===
720 template <>
721 class SharedHandleTraits<PrivateDataSlot>
722 {
723 public:
724 using DestructorType = Device;
725 using deleter = detail::ObjectDestroyShared<PrivateDataSlot>;
726 };
727
728 using SharedPrivateDataSlot = SharedHandle<PrivateDataSlot>;
729 using SharedPrivateDataSlotEXT = SharedHandle<PrivateDataSlot>;
730
731 //=== VK_KHR_surface ===
732 template <>
733 class SharedHandleTraits<SurfaceKHR>
734 {
735 public:
736 using DestructorType = Instance;
737 using deleter = detail::ObjectDestroyShared<SurfaceKHR>;
738 };
739
740 using SharedSurfaceKHR = SharedHandle<SurfaceKHR>;
741
742 //=== VK_KHR_swapchain ===
743 template <>
744 class SharedHandleTraits<SwapchainKHR>
745 {
746 public:
747 using DestructorType = Device;
748 using deleter = detail::ObjectDestroyShared<SwapchainKHR>;
749 };
750
751 using SharedSwapchainKHR = SharedHandle<SwapchainKHR>;
752
753 //=== VK_KHR_display ===
754 template <>
755 class SharedHandleTraits<DisplayKHR>
756 {
757 public:
758 using DestructorType = PhysicalDevice;
759 using deleter = detail::ObjectDestroyShared<DisplayKHR>;
760 };
761
762 using SharedDisplayKHR = SharedHandle<DisplayKHR>;
763
764 //=== VK_EXT_debug_report ===
765 template <>
766 class SharedHandleTraits<DebugReportCallbackEXT>
767 {
768 public:
769 using DestructorType = Instance;
770 using deleter = detail::ObjectDestroyShared<DebugReportCallbackEXT>;
771 };
772
773 using SharedDebugReportCallbackEXT = SharedHandle<DebugReportCallbackEXT>;
774
775 //=== VK_KHR_video_queue ===
776 template <>
777 class SharedHandleTraits<VideoSessionKHR>
778 {
779 public:
780 using DestructorType = Device;
781 using deleter = detail::ObjectDestroyShared<VideoSessionKHR>;
782 };
783
784 using SharedVideoSessionKHR = SharedHandle<VideoSessionKHR>;
785
786 template <>
787 class SharedHandleTraits<VideoSessionParametersKHR>
788 {
789 public:
790 using DestructorType = Device;
791 using deleter = detail::ObjectDestroyShared<VideoSessionParametersKHR>;
792 };
793
794 using SharedVideoSessionParametersKHR = SharedHandle<VideoSessionParametersKHR>;
795
796 //=== VK_NVX_binary_import ===
797 template <>
798 class SharedHandleTraits<CuModuleNVX>
799 {
800 public:
801 using DestructorType = Device;
802 using deleter = detail::ObjectDestroyShared<CuModuleNVX>;
803 };
804
805 using SharedCuModuleNVX = SharedHandle<CuModuleNVX>;
806
807 template <>
808 class SharedHandleTraits<CuFunctionNVX>
809 {
810 public:
811 using DestructorType = Device;
812 using deleter = detail::ObjectDestroyShared<CuFunctionNVX>;
813 };
814
815 using SharedCuFunctionNVX = SharedHandle<CuFunctionNVX>;
816
817 //=== VK_EXT_debug_utils ===
818 template <>
819 class SharedHandleTraits<DebugUtilsMessengerEXT>
820 {
821 public:
822 using DestructorType = Instance;
823 using deleter = detail::ObjectDestroyShared<DebugUtilsMessengerEXT>;
824 };
825
826 using SharedDebugUtilsMessengerEXT = SharedHandle<DebugUtilsMessengerEXT>;
827
828 //=== VK_KHR_acceleration_structure ===
829 template <>
830 class SharedHandleTraits<AccelerationStructureKHR>
831 {
832 public:
833 using DestructorType = Device;
834 using deleter = detail::ObjectDestroyShared<AccelerationStructureKHR>;
835 };
836
837 using SharedAccelerationStructureKHR = SharedHandle<AccelerationStructureKHR>;
838
839 //=== VK_EXT_validation_cache ===
840 template <>
841 class SharedHandleTraits<ValidationCacheEXT>
842 {
843 public:
844 using DestructorType = Device;
845 using deleter = detail::ObjectDestroyShared<ValidationCacheEXT>;
846 };
847
848 using SharedValidationCacheEXT = SharedHandle<ValidationCacheEXT>;
849
850 //=== VK_NV_ray_tracing ===
851 template <>
852 class SharedHandleTraits<AccelerationStructureNV>
853 {
854 public:
855 using DestructorType = Device;
856 using deleter = detail::ObjectDestroyShared<AccelerationStructureNV>;
857 };
858
859 using SharedAccelerationStructureNV = SharedHandle<AccelerationStructureNV>;
860
861 //=== VK_INTEL_performance_query ===
862 template <>
863 class SharedHandleTraits<PerformanceConfigurationINTEL>
864 {
865 public:
866 using DestructorType = Device;
867 using deleter = detail::ObjectDestroyShared<PerformanceConfigurationINTEL>;
868 };
869
870 using SharedPerformanceConfigurationINTEL = SharedHandle<PerformanceConfigurationINTEL>;
871
872 //=== VK_KHR_deferred_host_operations ===
873 template <>
874 class SharedHandleTraits<DeferredOperationKHR>
875 {
876 public:
877 using DestructorType = Device;
878 using deleter = detail::ObjectDestroyShared<DeferredOperationKHR>;
879 };
880
881 using SharedDeferredOperationKHR = SharedHandle<DeferredOperationKHR>;
882
883 //=== VK_NV_device_generated_commands ===
884 template <>
885 class SharedHandleTraits<IndirectCommandsLayoutNV>
886 {
887 public:
888 using DestructorType = Device;
889 using deleter = detail::ObjectDestroyShared<IndirectCommandsLayoutNV>;
890 };
891
892 using SharedIndirectCommandsLayoutNV = SharedHandle<IndirectCommandsLayoutNV>;
893
894 # if defined( VK_ENABLE_BETA_EXTENSIONS )
895 //=== VK_NV_cuda_kernel_launch ===
896 template <>
897 class SharedHandleTraits<CudaModuleNV>
898 {
899 public:
900 using DestructorType = Device;
901 using deleter = detail::ObjectDestroyShared<CudaModuleNV>;
902 };
903
904 using SharedCudaModuleNV = SharedHandle<CudaModuleNV>;
905
906 template <>
907 class SharedHandleTraits<CudaFunctionNV>
908 {
909 public:
910 using DestructorType = Device;
911 using deleter = detail::ObjectDestroyShared<CudaFunctionNV>;
912 };
913
914 using SharedCudaFunctionNV = SharedHandle<CudaFunctionNV>;
915 # endif /*VK_ENABLE_BETA_EXTENSIONS*/
916
917 # if defined( VK_USE_PLATFORM_FUCHSIA )
918 //=== VK_FUCHSIA_buffer_collection ===
919 template <>
920 class SharedHandleTraits<BufferCollectionFUCHSIA>
921 {
922 public:
923 using DestructorType = Device;
924 using deleter = detail::ObjectDestroyShared<BufferCollectionFUCHSIA>;
925 };
926
927 using SharedBufferCollectionFUCHSIA = SharedHandle<BufferCollectionFUCHSIA>;
928 # endif /*VK_USE_PLATFORM_FUCHSIA*/
929
930 //=== VK_EXT_opacity_micromap ===
931 template <>
932 class SharedHandleTraits<MicromapEXT>
933 {
934 public:
935 using DestructorType = Device;
936 using deleter = detail::ObjectDestroyShared<MicromapEXT>;
937 };
938
939 using SharedMicromapEXT = SharedHandle<MicromapEXT>;
940
941 //=== VK_ARM_tensors ===
942 template <>
943 class SharedHandleTraits<TensorARM>
944 {
945 public:
946 using DestructorType = Device;
947 using deleter = detail::ObjectDestroyShared<TensorARM>;
948 };
949
950 using SharedTensorARM = SharedHandle<TensorARM>;
951
952 template <>
953 class SharedHandleTraits<TensorViewARM>
954 {
955 public:
956 using DestructorType = Device;
957 using deleter = detail::ObjectDestroyShared<TensorViewARM>;
958 };
959
960 using SharedTensorViewARM = SharedHandle<TensorViewARM>;
961
962 //=== VK_NV_optical_flow ===
963 template <>
964 class SharedHandleTraits<OpticalFlowSessionNV>
965 {
966 public:
967 using DestructorType = Device;
968 using deleter = detail::ObjectDestroyShared<OpticalFlowSessionNV>;
969 };
970
971 using SharedOpticalFlowSessionNV = SharedHandle<OpticalFlowSessionNV>;
972
973 //=== VK_EXT_shader_object ===
974 template <>
975 class SharedHandleTraits<ShaderEXT>
976 {
977 public:
978 using DestructorType = Device;
979 using deleter = detail::ObjectDestroyShared<ShaderEXT>;
980 };
981
982 using SharedShaderEXT = SharedHandle<ShaderEXT>;
983
984 //=== VK_KHR_pipeline_binary ===
985 template <>
986 class SharedHandleTraits<PipelineBinaryKHR>
987 {
988 public:
989 using DestructorType = Device;
990 using deleter = detail::ObjectDestroyShared<PipelineBinaryKHR>;
991 };
992
993 using SharedPipelineBinaryKHR = SharedHandle<PipelineBinaryKHR>;
994
995 //=== VK_ARM_data_graph ===
996 template <>
997 class SharedHandleTraits<DataGraphPipelineSessionARM>
998 {
999 public:
1000 using DestructorType = Device;
1001 using deleter = detail::ObjectDestroyShared<DataGraphPipelineSessionARM>;
1002 };
1003
1004 using SharedDataGraphPipelineSessionARM = SharedHandle<DataGraphPipelineSessionARM>;
1005
1006 //=== VK_NV_external_compute_queue ===
1007 template <>
1008 class SharedHandleTraits<ExternalComputeQueueNV>
1009 {
1010 public:
1011 using DestructorType = Device;
1012 using deleter = detail::ObjectDestroyShared<ExternalComputeQueueNV>;
1013 };
1014
1015 using SharedExternalComputeQueueNV = SharedHandle<ExternalComputeQueueNV>;
1016
1017 //=== VK_EXT_device_generated_commands ===
1018 template <>
1019 class SharedHandleTraits<IndirectCommandsLayoutEXT>
1020 {
1021 public:
1022 using DestructorType = Device;
1023 using deleter = detail::ObjectDestroyShared<IndirectCommandsLayoutEXT>;
1024 };
1025
1026 using SharedIndirectCommandsLayoutEXT = SharedHandle<IndirectCommandsLayoutEXT>;
1027
1028 template <>
1029 class SharedHandleTraits<IndirectExecutionSetEXT>
1030 {
1031 public:
1032 using DestructorType = Device;
1033 using deleter = detail::ObjectDestroyShared<IndirectExecutionSetEXT>;
1034 };
1035
1036 using SharedIndirectExecutionSetEXT = SharedHandle<IndirectExecutionSetEXT>;
1037
1038 // a number of SharedHandle specializations
1039 enum class SwapchainOwns
1040 {
1041 no,
1042 yes,
1043 };
1044
1045 struct ImageHeader : SharedHeader<DestructorTypeOf<Image>, typename SharedHandleTraits<Image>::deleter>
1046 {
1047 ImageHeader( SharedHandle<DestructorTypeOf<Image>> parent,
1048 typename SharedHandleTraits<Image>::deleter deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( typename SharedHandleTraits<Image>::deleter() ),
1049 SwapchainOwns swapchainOwned = SwapchainOwns::no ) VULKAN_HPP_NOEXCEPT
1050 : SharedHeader<DestructorTypeOf<Image>, typename SharedHandleTraits<Image>::deleter>( std::move( parent ), std::move( deleter ) )
1051 , swapchainOwned( swapchainOwned )
1052 {
1053 }
1054
1055 SwapchainOwns swapchainOwned = SwapchainOwns::no;
1056 };
1057
1058 template <>
1059 class SharedHandle<Image> : public SharedHandleBase<Image, ImageHeader>
1060 {
1061 using BaseType = SharedHandleBase<Image, ImageHeader>;
1062 using DeleterType = typename SharedHandleTraits<Image>::deleter;
1063 friend BaseType;
1064
1065 public:
1066 SharedHandle() = default;
1067
1068 explicit SharedHandle( Image handle,
1069 SharedHandle<DestructorTypeOf<Image>> parent,
1070 SwapchainOwns swapchain_owned VULKAN_HPP_DEFAULT_ASSIGNMENT( SwapchainOwns::no ),
1071 DeleterType deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( DeleterType() ) ) VULKAN_HPP_NOEXCEPT
1072 : BaseType( handle, std::move( parent ), std::move( deleter ), swapchain_owned )
1073 {
1074 }
1075
1076 protected:
1077 static void internalDestroy( const ImageHeader & control, Image handle ) VULKAN_HPP_NOEXCEPT
1078 {
1079 if ( control.swapchainOwned == SwapchainOwns::no )
1080 {
1081 control.deleter.destroy( control.parent.get(), handle );
1082 }
1083 }
1084 };
1085
1086 struct SwapchainHeader
1087 {
1088 SwapchainHeader( SharedHandle<SurfaceKHR> surface,
1089 SharedHandle<DestructorTypeOf<SwapchainKHR>> parent,
1090 typename SharedHandleTraits<SwapchainKHR>::deleter deleter
1091 VULKAN_HPP_DEFAULT_ASSIGNMENT( typename SharedHandleTraits<SwapchainKHR>::deleter() ) ) VULKAN_HPP_NOEXCEPT
1092 : surface( std::move( surface ) )
1093 , parent( std::move( parent ) )
1094 , deleter( std::move( deleter ) )
1095 {
1096 }
1097
1098 SharedHandle<SurfaceKHR> surface;
1099 SharedHandle<DestructorTypeOf<SwapchainKHR>> parent;
1100 typename SharedHandleTraits<SwapchainKHR>::deleter deleter;
1101 };
1102
1103 template <>
1104 class SharedHandle<SwapchainKHR> : public SharedHandleBase<SwapchainKHR, SwapchainHeader>
1105 {
1106 using BaseType = SharedHandleBase<SwapchainKHR, SwapchainHeader>;
1107 using DeleterType = typename SharedHandleTraits<SwapchainKHR>::deleter;
1108 friend BaseType;
1109
1110 public:
1111 SharedHandle() = default;
1112
1113 explicit SharedHandle( SwapchainKHR handle,
1114 SharedHandle<DestructorTypeOf<SwapchainKHR>> parent,
1115 SharedHandle<SurfaceKHR> surface,
1116 DeleterType deleter VULKAN_HPP_DEFAULT_ASSIGNMENT( DeleterType() ) ) VULKAN_HPP_NOEXCEPT
1117 : BaseType( handle, std::move( surface ), std::move( parent ), std::move( deleter ) )
1118 {
1119 }
1120
1121 public:
1122 const SharedHandle<SurfaceKHR> & getSurface() const VULKAN_HPP_NOEXCEPT
1123 {
1124 return getHeader().surface;
1125 }
1126
1127 protected:
1128 using BaseType::internalDestroy;
1129 };
1130
1131 template <typename HandleType, typename DestructorType>
1132 class SharedHandleBaseNoDestroy : public SharedHandleBase<HandleType, DestructorType>
1133 {
1134 public:
1135 using SharedHandleBase<HandleType, DestructorType>::SharedHandleBase;
1136
1137 const DestructorType & getDestructorType() const VULKAN_HPP_NOEXCEPT
1138 {
1139 return SharedHandleBase<HandleType, DestructorType>::getHeader();
1140 }
1141
1142 protected:
1143 static void internalDestroy( const DestructorType &, HandleType ) VULKAN_HPP_NOEXCEPT {}
1144 };
1145
1146 //=== VK_VERSION_1_0 ===
1147
1148 template <>
1149 class SharedHandle<PhysicalDevice> : public SharedHandleBaseNoDestroy<PhysicalDevice, SharedInstance>
1150 {
1151 friend SharedHandleBase<PhysicalDevice, SharedInstance>;
1152
1153 public:
1154 SharedHandle() = default;
1155
1156 explicit SharedHandle( PhysicalDevice handle, SharedInstance parent ) noexcept
1157 : SharedHandleBaseNoDestroy<PhysicalDevice, SharedInstance>( handle, std::move( parent ) )
1158 {
1159 }
1160 };
1161
1162 using SharedPhysicalDevice = SharedHandle<PhysicalDevice>;
1163
1164 template <>
1165 class SharedHandle<Queue> : public SharedHandleBaseNoDestroy<Queue, SharedDevice>
1166 {
1167 friend SharedHandleBase<Queue, SharedDevice>;
1168
1169 public:
1170 SharedHandle() = default;
1171
1172 explicit SharedHandle( Queue handle, SharedDevice parent ) noexcept : SharedHandleBaseNoDestroy<Queue, SharedDevice>( handle, std::move( parent ) ) {}
1173 };
1174
1175 using SharedQueue = SharedHandle<Queue>;
1176
1177 //=== VK_KHR_display ===
1178
1179 template <>
1180 class SharedHandle<DisplayModeKHR> : public SharedHandleBaseNoDestroy<DisplayModeKHR, SharedDisplayKHR>
1181 {
1182 friend SharedHandleBase<DisplayModeKHR, SharedDisplayKHR>;
1183
1184 public:
1185 SharedHandle() = default;
1186
1187 explicit SharedHandle( DisplayModeKHR handle, SharedDisplayKHR parent ) noexcept
1188 : SharedHandleBaseNoDestroy<DisplayModeKHR, SharedDisplayKHR>( handle, std::move( parent ) )
1189 {
1190 }
1191 };
1192
1193 using SharedDisplayModeKHR = SharedHandle<DisplayModeKHR>;
1194 #endif // !VULKAN_HPP_NO_SMART_HANDLE
1195 } // namespace VULKAN_HPP_NAMESPACE
1196 #endif // VULKAN_SHARED_HPP