1#![allow(
9 non_camel_case_types,
10 non_snake_case,
11 clippy::bad_bit_mask,
12 clippy::let_unit_value,
13 clippy::missing_safety_doc,
14 clippy::missing_transmute_annotations,
15 clippy::too_many_arguments,
16 clippy::type_complexity,
17 clippy::unnecessary_cast,
18 clippy::upper_case_acronyms,
19 clippy::useless_transmute
20)]
21
22use core::fmt;
23use core::hash::Hash;
24
25use crate::ObjectType;
26
27pub trait Handle: Copy + Clone + fmt::Debug + PartialEq + Eq + Hash + Default + Sized {
29 type Repr;
31
32 const TYPE: ObjectType;
34
35 fn null() -> Self;
37
38 fn from_raw(value: Self::Repr) -> Self;
40
41 fn as_raw(self) -> Self::Repr;
43
44 fn is_null(self) -> bool;
46}
47
48#[repr(transparent)]
50#[derive(Copy, Clone, PartialEq, Eq, Hash)]
51pub struct AccelerationStructureKHR(u64);
52
53impl Handle for AccelerationStructureKHR {
54 type Repr = u64;
55
56 const TYPE: ObjectType = ObjectType::ACCELERATION_STRUCTURE_KHR;
57
58 #[inline]
59 fn null() -> Self {
60 Self(0)
61 }
62
63 #[inline]
64 fn from_raw(value: Self::Repr) -> Self {
65 Self(value)
66 }
67
68 #[inline]
69 fn as_raw(self) -> Self::Repr {
70 self.0
71 }
72
73 #[inline]
74 fn is_null(self) -> bool {
75 self.0 == 0
76 }
77}
78
79impl Default for AccelerationStructureKHR {
80 #[inline]
81 fn default() -> Self {
82 Self::null()
83 }
84}
85
86impl fmt::Debug for AccelerationStructureKHR {
87 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
88 write!(f, "AccelerationStructureKHR({:p})", self.0 as *const u8)
89 }
90}
91
92#[repr(transparent)]
94#[derive(Copy, Clone, PartialEq, Eq, Hash)]
95pub struct AccelerationStructureNV(u64);
96
97impl Handle for AccelerationStructureNV {
98 type Repr = u64;
99
100 const TYPE: ObjectType = ObjectType::ACCELERATION_STRUCTURE_NV;
101
102 #[inline]
103 fn null() -> Self {
104 Self(0)
105 }
106
107 #[inline]
108 fn from_raw(value: Self::Repr) -> Self {
109 Self(value)
110 }
111
112 #[inline]
113 fn as_raw(self) -> Self::Repr {
114 self.0
115 }
116
117 #[inline]
118 fn is_null(self) -> bool {
119 self.0 == 0
120 }
121}
122
123impl Default for AccelerationStructureNV {
124 #[inline]
125 fn default() -> Self {
126 Self::null()
127 }
128}
129
130impl fmt::Debug for AccelerationStructureNV {
131 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
132 write!(f, "AccelerationStructureNV({:p})", self.0 as *const u8)
133 }
134}
135
136#[repr(transparent)]
138#[derive(Copy, Clone, PartialEq, Eq, Hash)]
139pub struct Buffer(u64);
140
141impl Handle for Buffer {
142 type Repr = u64;
143
144 const TYPE: ObjectType = ObjectType::BUFFER;
145
146 #[inline]
147 fn null() -> Self {
148 Self(0)
149 }
150
151 #[inline]
152 fn from_raw(value: Self::Repr) -> Self {
153 Self(value)
154 }
155
156 #[inline]
157 fn as_raw(self) -> Self::Repr {
158 self.0
159 }
160
161 #[inline]
162 fn is_null(self) -> bool {
163 self.0 == 0
164 }
165}
166
167impl Default for Buffer {
168 #[inline]
169 fn default() -> Self {
170 Self::null()
171 }
172}
173
174impl fmt::Debug for Buffer {
175 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
176 write!(f, "Buffer({:p})", self.0 as *const u8)
177 }
178}
179
180#[repr(transparent)]
182#[derive(Copy, Clone, PartialEq, Eq, Hash)]
183pub struct BufferCollectionFUCHSIA(u64);
184
185impl Handle for BufferCollectionFUCHSIA {
186 type Repr = u64;
187
188 const TYPE: ObjectType = ObjectType::BUFFER_COLLECTION_FUCHSIA;
189
190 #[inline]
191 fn null() -> Self {
192 Self(0)
193 }
194
195 #[inline]
196 fn from_raw(value: Self::Repr) -> Self {
197 Self(value)
198 }
199
200 #[inline]
201 fn as_raw(self) -> Self::Repr {
202 self.0
203 }
204
205 #[inline]
206 fn is_null(self) -> bool {
207 self.0 == 0
208 }
209}
210
211impl Default for BufferCollectionFUCHSIA {
212 #[inline]
213 fn default() -> Self {
214 Self::null()
215 }
216}
217
218impl fmt::Debug for BufferCollectionFUCHSIA {
219 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
220 write!(f, "BufferCollectionFUCHSIA({:p})", self.0 as *const u8)
221 }
222}
223
224#[repr(transparent)]
226#[derive(Copy, Clone, PartialEq, Eq, Hash)]
227pub struct BufferView(u64);
228
229impl Handle for BufferView {
230 type Repr = u64;
231
232 const TYPE: ObjectType = ObjectType::BUFFER_VIEW;
233
234 #[inline]
235 fn null() -> Self {
236 Self(0)
237 }
238
239 #[inline]
240 fn from_raw(value: Self::Repr) -> Self {
241 Self(value)
242 }
243
244 #[inline]
245 fn as_raw(self) -> Self::Repr {
246 self.0
247 }
248
249 #[inline]
250 fn is_null(self) -> bool {
251 self.0 == 0
252 }
253}
254
255impl Default for BufferView {
256 #[inline]
257 fn default() -> Self {
258 Self::null()
259 }
260}
261
262impl fmt::Debug for BufferView {
263 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
264 write!(f, "BufferView({:p})", self.0 as *const u8)
265 }
266}
267
268#[repr(transparent)]
270#[derive(Copy, Clone, PartialEq, Eq, Hash)]
271pub struct CommandBuffer(usize);
272
273impl Handle for CommandBuffer {
274 type Repr = usize;
275
276 const TYPE: ObjectType = ObjectType::COMMAND_BUFFER;
277
278 #[inline]
279 fn null() -> Self {
280 Self(0)
281 }
282
283 #[inline]
284 fn from_raw(value: Self::Repr) -> Self {
285 Self(value)
286 }
287
288 #[inline]
289 fn as_raw(self) -> Self::Repr {
290 self.0
291 }
292
293 #[inline]
294 fn is_null(self) -> bool {
295 self.0 == 0
296 }
297}
298
299impl Default for CommandBuffer {
300 #[inline]
301 fn default() -> Self {
302 Self::null()
303 }
304}
305
306impl fmt::Debug for CommandBuffer {
307 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
308 write!(f, "CommandBuffer({:p})", self.0 as *const u8)
309 }
310}
311
312#[repr(transparent)]
314#[derive(Copy, Clone, PartialEq, Eq, Hash)]
315pub struct CommandPool(u64);
316
317impl Handle for CommandPool {
318 type Repr = u64;
319
320 const TYPE: ObjectType = ObjectType::COMMAND_POOL;
321
322 #[inline]
323 fn null() -> Self {
324 Self(0)
325 }
326
327 #[inline]
328 fn from_raw(value: Self::Repr) -> Self {
329 Self(value)
330 }
331
332 #[inline]
333 fn as_raw(self) -> Self::Repr {
334 self.0
335 }
336
337 #[inline]
338 fn is_null(self) -> bool {
339 self.0 == 0
340 }
341}
342
343impl Default for CommandPool {
344 #[inline]
345 fn default() -> Self {
346 Self::null()
347 }
348}
349
350impl fmt::Debug for CommandPool {
351 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
352 write!(f, "CommandPool({:p})", self.0 as *const u8)
353 }
354}
355
356#[repr(transparent)]
358#[derive(Copy, Clone, PartialEq, Eq, Hash)]
359pub struct CuFunctionNVX(u64);
360
361impl Handle for CuFunctionNVX {
362 type Repr = u64;
363
364 const TYPE: ObjectType = ObjectType::CU_FUNCTION_NVX;
365
366 #[inline]
367 fn null() -> Self {
368 Self(0)
369 }
370
371 #[inline]
372 fn from_raw(value: Self::Repr) -> Self {
373 Self(value)
374 }
375
376 #[inline]
377 fn as_raw(self) -> Self::Repr {
378 self.0
379 }
380
381 #[inline]
382 fn is_null(self) -> bool {
383 self.0 == 0
384 }
385}
386
387impl Default for CuFunctionNVX {
388 #[inline]
389 fn default() -> Self {
390 Self::null()
391 }
392}
393
394impl fmt::Debug for CuFunctionNVX {
395 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
396 write!(f, "CuFunctionNVX({:p})", self.0 as *const u8)
397 }
398}
399
400#[repr(transparent)]
402#[derive(Copy, Clone, PartialEq, Eq, Hash)]
403pub struct CuModuleNVX(u64);
404
405impl Handle for CuModuleNVX {
406 type Repr = u64;
407
408 const TYPE: ObjectType = ObjectType::CU_MODULE_NVX;
409
410 #[inline]
411 fn null() -> Self {
412 Self(0)
413 }
414
415 #[inline]
416 fn from_raw(value: Self::Repr) -> Self {
417 Self(value)
418 }
419
420 #[inline]
421 fn as_raw(self) -> Self::Repr {
422 self.0
423 }
424
425 #[inline]
426 fn is_null(self) -> bool {
427 self.0 == 0
428 }
429}
430
431impl Default for CuModuleNVX {
432 #[inline]
433 fn default() -> Self {
434 Self::null()
435 }
436}
437
438impl fmt::Debug for CuModuleNVX {
439 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
440 write!(f, "CuModuleNVX({:p})", self.0 as *const u8)
441 }
442}
443
444#[repr(transparent)]
446#[derive(Copy, Clone, PartialEq, Eq, Hash)]
447pub struct CudaFunctionNV(u64);
448
449impl Handle for CudaFunctionNV {
450 type Repr = u64;
451
452 const TYPE: ObjectType = ObjectType::CUDA_FUNCTION_NV;
453
454 #[inline]
455 fn null() -> Self {
456 Self(0)
457 }
458
459 #[inline]
460 fn from_raw(value: Self::Repr) -> Self {
461 Self(value)
462 }
463
464 #[inline]
465 fn as_raw(self) -> Self::Repr {
466 self.0
467 }
468
469 #[inline]
470 fn is_null(self) -> bool {
471 self.0 == 0
472 }
473}
474
475impl Default for CudaFunctionNV {
476 #[inline]
477 fn default() -> Self {
478 Self::null()
479 }
480}
481
482impl fmt::Debug for CudaFunctionNV {
483 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
484 write!(f, "CudaFunctionNV({:p})", self.0 as *const u8)
485 }
486}
487
488#[repr(transparent)]
490#[derive(Copy, Clone, PartialEq, Eq, Hash)]
491pub struct CudaModuleNV(u64);
492
493impl Handle for CudaModuleNV {
494 type Repr = u64;
495
496 const TYPE: ObjectType = ObjectType::CUDA_MODULE_NV;
497
498 #[inline]
499 fn null() -> Self {
500 Self(0)
501 }
502
503 #[inline]
504 fn from_raw(value: Self::Repr) -> Self {
505 Self(value)
506 }
507
508 #[inline]
509 fn as_raw(self) -> Self::Repr {
510 self.0
511 }
512
513 #[inline]
514 fn is_null(self) -> bool {
515 self.0 == 0
516 }
517}
518
519impl Default for CudaModuleNV {
520 #[inline]
521 fn default() -> Self {
522 Self::null()
523 }
524}
525
526impl fmt::Debug for CudaModuleNV {
527 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
528 write!(f, "CudaModuleNV({:p})", self.0 as *const u8)
529 }
530}
531
532#[repr(transparent)]
534#[derive(Copy, Clone, PartialEq, Eq, Hash)]
535pub struct DataGraphPipelineSessionARM(u64);
536
537impl Handle for DataGraphPipelineSessionARM {
538 type Repr = u64;
539
540 const TYPE: ObjectType = ObjectType::DATA_GRAPH_PIPELINE_SESSION_ARM;
541
542 #[inline]
543 fn null() -> Self {
544 Self(0)
545 }
546
547 #[inline]
548 fn from_raw(value: Self::Repr) -> Self {
549 Self(value)
550 }
551
552 #[inline]
553 fn as_raw(self) -> Self::Repr {
554 self.0
555 }
556
557 #[inline]
558 fn is_null(self) -> bool {
559 self.0 == 0
560 }
561}
562
563impl Default for DataGraphPipelineSessionARM {
564 #[inline]
565 fn default() -> Self {
566 Self::null()
567 }
568}
569
570impl fmt::Debug for DataGraphPipelineSessionARM {
571 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
572 write!(f, "DataGraphPipelineSessionARM({:p})", self.0 as *const u8)
573 }
574}
575
576#[repr(transparent)]
578#[derive(Copy, Clone, PartialEq, Eq, Hash)]
579pub struct DebugReportCallbackEXT(u64);
580
581impl Handle for DebugReportCallbackEXT {
582 type Repr = u64;
583
584 const TYPE: ObjectType = ObjectType::DEBUG_REPORT_CALLBACK_EXT;
585
586 #[inline]
587 fn null() -> Self {
588 Self(0)
589 }
590
591 #[inline]
592 fn from_raw(value: Self::Repr) -> Self {
593 Self(value)
594 }
595
596 #[inline]
597 fn as_raw(self) -> Self::Repr {
598 self.0
599 }
600
601 #[inline]
602 fn is_null(self) -> bool {
603 self.0 == 0
604 }
605}
606
607impl Default for DebugReportCallbackEXT {
608 #[inline]
609 fn default() -> Self {
610 Self::null()
611 }
612}
613
614impl fmt::Debug for DebugReportCallbackEXT {
615 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
616 write!(f, "DebugReportCallbackEXT({:p})", self.0 as *const u8)
617 }
618}
619
620#[repr(transparent)]
622#[derive(Copy, Clone, PartialEq, Eq, Hash)]
623pub struct DebugUtilsMessengerEXT(u64);
624
625impl Handle for DebugUtilsMessengerEXT {
626 type Repr = u64;
627
628 const TYPE: ObjectType = ObjectType::DEBUG_UTILS_MESSENGER_EXT;
629
630 #[inline]
631 fn null() -> Self {
632 Self(0)
633 }
634
635 #[inline]
636 fn from_raw(value: Self::Repr) -> Self {
637 Self(value)
638 }
639
640 #[inline]
641 fn as_raw(self) -> Self::Repr {
642 self.0
643 }
644
645 #[inline]
646 fn is_null(self) -> bool {
647 self.0 == 0
648 }
649}
650
651impl Default for DebugUtilsMessengerEXT {
652 #[inline]
653 fn default() -> Self {
654 Self::null()
655 }
656}
657
658impl fmt::Debug for DebugUtilsMessengerEXT {
659 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
660 write!(f, "DebugUtilsMessengerEXT({:p})", self.0 as *const u8)
661 }
662}
663
664#[repr(transparent)]
666#[derive(Copy, Clone, PartialEq, Eq, Hash)]
667pub struct DeferredOperationKHR(u64);
668
669impl Handle for DeferredOperationKHR {
670 type Repr = u64;
671
672 const TYPE: ObjectType = ObjectType::DEFERRED_OPERATION_KHR;
673
674 #[inline]
675 fn null() -> Self {
676 Self(0)
677 }
678
679 #[inline]
680 fn from_raw(value: Self::Repr) -> Self {
681 Self(value)
682 }
683
684 #[inline]
685 fn as_raw(self) -> Self::Repr {
686 self.0
687 }
688
689 #[inline]
690 fn is_null(self) -> bool {
691 self.0 == 0
692 }
693}
694
695impl Default for DeferredOperationKHR {
696 #[inline]
697 fn default() -> Self {
698 Self::null()
699 }
700}
701
702impl fmt::Debug for DeferredOperationKHR {
703 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
704 write!(f, "DeferredOperationKHR({:p})", self.0 as *const u8)
705 }
706}
707
708#[repr(transparent)]
710#[derive(Copy, Clone, PartialEq, Eq, Hash)]
711pub struct DescriptorPool(u64);
712
713impl Handle for DescriptorPool {
714 type Repr = u64;
715
716 const TYPE: ObjectType = ObjectType::DESCRIPTOR_POOL;
717
718 #[inline]
719 fn null() -> Self {
720 Self(0)
721 }
722
723 #[inline]
724 fn from_raw(value: Self::Repr) -> Self {
725 Self(value)
726 }
727
728 #[inline]
729 fn as_raw(self) -> Self::Repr {
730 self.0
731 }
732
733 #[inline]
734 fn is_null(self) -> bool {
735 self.0 == 0
736 }
737}
738
739impl Default for DescriptorPool {
740 #[inline]
741 fn default() -> Self {
742 Self::null()
743 }
744}
745
746impl fmt::Debug for DescriptorPool {
747 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
748 write!(f, "DescriptorPool({:p})", self.0 as *const u8)
749 }
750}
751
752#[repr(transparent)]
754#[derive(Copy, Clone, PartialEq, Eq, Hash)]
755pub struct DescriptorSet(u64);
756
757impl Handle for DescriptorSet {
758 type Repr = u64;
759
760 const TYPE: ObjectType = ObjectType::DESCRIPTOR_SET;
761
762 #[inline]
763 fn null() -> Self {
764 Self(0)
765 }
766
767 #[inline]
768 fn from_raw(value: Self::Repr) -> Self {
769 Self(value)
770 }
771
772 #[inline]
773 fn as_raw(self) -> Self::Repr {
774 self.0
775 }
776
777 #[inline]
778 fn is_null(self) -> bool {
779 self.0 == 0
780 }
781}
782
783impl Default for DescriptorSet {
784 #[inline]
785 fn default() -> Self {
786 Self::null()
787 }
788}
789
790impl fmt::Debug for DescriptorSet {
791 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
792 write!(f, "DescriptorSet({:p})", self.0 as *const u8)
793 }
794}
795
796#[repr(transparent)]
798#[derive(Copy, Clone, PartialEq, Eq, Hash)]
799pub struct DescriptorSetLayout(u64);
800
801impl Handle for DescriptorSetLayout {
802 type Repr = u64;
803
804 const TYPE: ObjectType = ObjectType::DESCRIPTOR_SET_LAYOUT;
805
806 #[inline]
807 fn null() -> Self {
808 Self(0)
809 }
810
811 #[inline]
812 fn from_raw(value: Self::Repr) -> Self {
813 Self(value)
814 }
815
816 #[inline]
817 fn as_raw(self) -> Self::Repr {
818 self.0
819 }
820
821 #[inline]
822 fn is_null(self) -> bool {
823 self.0 == 0
824 }
825}
826
827impl Default for DescriptorSetLayout {
828 #[inline]
829 fn default() -> Self {
830 Self::null()
831 }
832}
833
834impl fmt::Debug for DescriptorSetLayout {
835 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
836 write!(f, "DescriptorSetLayout({:p})", self.0 as *const u8)
837 }
838}
839
840#[repr(transparent)]
842#[derive(Copy, Clone, PartialEq, Eq, Hash)]
843pub struct DescriptorUpdateTemplate(u64);
844
845impl Handle for DescriptorUpdateTemplate {
846 type Repr = u64;
847
848 const TYPE: ObjectType = ObjectType::DESCRIPTOR_UPDATE_TEMPLATE;
849
850 #[inline]
851 fn null() -> Self {
852 Self(0)
853 }
854
855 #[inline]
856 fn from_raw(value: Self::Repr) -> Self {
857 Self(value)
858 }
859
860 #[inline]
861 fn as_raw(self) -> Self::Repr {
862 self.0
863 }
864
865 #[inline]
866 fn is_null(self) -> bool {
867 self.0 == 0
868 }
869}
870
871impl Default for DescriptorUpdateTemplate {
872 #[inline]
873 fn default() -> Self {
874 Self::null()
875 }
876}
877
878impl fmt::Debug for DescriptorUpdateTemplate {
879 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
880 write!(f, "DescriptorUpdateTemplate({:p})", self.0 as *const u8)
881 }
882}
883
884#[repr(transparent)]
886#[derive(Copy, Clone, PartialEq, Eq, Hash)]
887pub struct Device(usize);
888
889impl Handle for Device {
890 type Repr = usize;
891
892 const TYPE: ObjectType = ObjectType::DEVICE;
893
894 #[inline]
895 fn null() -> Self {
896 Self(0)
897 }
898
899 #[inline]
900 fn from_raw(value: Self::Repr) -> Self {
901 Self(value)
902 }
903
904 #[inline]
905 fn as_raw(self) -> Self::Repr {
906 self.0
907 }
908
909 #[inline]
910 fn is_null(self) -> bool {
911 self.0 == 0
912 }
913}
914
915impl Default for Device {
916 #[inline]
917 fn default() -> Self {
918 Self::null()
919 }
920}
921
922impl fmt::Debug for Device {
923 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
924 write!(f, "Device({:p})", self.0 as *const u8)
925 }
926}
927
928#[repr(transparent)]
930#[derive(Copy, Clone, PartialEq, Eq, Hash)]
931pub struct DeviceMemory(u64);
932
933impl Handle for DeviceMemory {
934 type Repr = u64;
935
936 const TYPE: ObjectType = ObjectType::DEVICE_MEMORY;
937
938 #[inline]
939 fn null() -> Self {
940 Self(0)
941 }
942
943 #[inline]
944 fn from_raw(value: Self::Repr) -> Self {
945 Self(value)
946 }
947
948 #[inline]
949 fn as_raw(self) -> Self::Repr {
950 self.0
951 }
952
953 #[inline]
954 fn is_null(self) -> bool {
955 self.0 == 0
956 }
957}
958
959impl Default for DeviceMemory {
960 #[inline]
961 fn default() -> Self {
962 Self::null()
963 }
964}
965
966impl fmt::Debug for DeviceMemory {
967 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
968 write!(f, "DeviceMemory({:p})", self.0 as *const u8)
969 }
970}
971
972#[repr(transparent)]
974#[derive(Copy, Clone, PartialEq, Eq, Hash)]
975pub struct DisplayKHR(u64);
976
977impl Handle for DisplayKHR {
978 type Repr = u64;
979
980 const TYPE: ObjectType = ObjectType::DISPLAY_KHR;
981
982 #[inline]
983 fn null() -> Self {
984 Self(0)
985 }
986
987 #[inline]
988 fn from_raw(value: Self::Repr) -> Self {
989 Self(value)
990 }
991
992 #[inline]
993 fn as_raw(self) -> Self::Repr {
994 self.0
995 }
996
997 #[inline]
998 fn is_null(self) -> bool {
999 self.0 == 0
1000 }
1001}
1002
1003impl Default for DisplayKHR {
1004 #[inline]
1005 fn default() -> Self {
1006 Self::null()
1007 }
1008}
1009
1010impl fmt::Debug for DisplayKHR {
1011 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1012 write!(f, "DisplayKHR({:p})", self.0 as *const u8)
1013 }
1014}
1015
1016#[repr(transparent)]
1018#[derive(Copy, Clone, PartialEq, Eq, Hash)]
1019pub struct DisplayModeKHR(u64);
1020
1021impl Handle for DisplayModeKHR {
1022 type Repr = u64;
1023
1024 const TYPE: ObjectType = ObjectType::DISPLAY_MODE_KHR;
1025
1026 #[inline]
1027 fn null() -> Self {
1028 Self(0)
1029 }
1030
1031 #[inline]
1032 fn from_raw(value: Self::Repr) -> Self {
1033 Self(value)
1034 }
1035
1036 #[inline]
1037 fn as_raw(self) -> Self::Repr {
1038 self.0
1039 }
1040
1041 #[inline]
1042 fn is_null(self) -> bool {
1043 self.0 == 0
1044 }
1045}
1046
1047impl Default for DisplayModeKHR {
1048 #[inline]
1049 fn default() -> Self {
1050 Self::null()
1051 }
1052}
1053
1054impl fmt::Debug for DisplayModeKHR {
1055 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1056 write!(f, "DisplayModeKHR({:p})", self.0 as *const u8)
1057 }
1058}
1059
1060#[repr(transparent)]
1062#[derive(Copy, Clone, PartialEq, Eq, Hash)]
1063pub struct Event(u64);
1064
1065impl Handle for Event {
1066 type Repr = u64;
1067
1068 const TYPE: ObjectType = ObjectType::EVENT;
1069
1070 #[inline]
1071 fn null() -> Self {
1072 Self(0)
1073 }
1074
1075 #[inline]
1076 fn from_raw(value: Self::Repr) -> Self {
1077 Self(value)
1078 }
1079
1080 #[inline]
1081 fn as_raw(self) -> Self::Repr {
1082 self.0
1083 }
1084
1085 #[inline]
1086 fn is_null(self) -> bool {
1087 self.0 == 0
1088 }
1089}
1090
1091impl Default for Event {
1092 #[inline]
1093 fn default() -> Self {
1094 Self::null()
1095 }
1096}
1097
1098impl fmt::Debug for Event {
1099 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1100 write!(f, "Event({:p})", self.0 as *const u8)
1101 }
1102}
1103
1104#[repr(transparent)]
1106#[derive(Copy, Clone, PartialEq, Eq, Hash)]
1107pub struct ExternalComputeQueueNV(usize);
1108
1109impl Handle for ExternalComputeQueueNV {
1110 type Repr = usize;
1111
1112 const TYPE: ObjectType = ObjectType::EXTERNAL_COMPUTE_QUEUE_NV;
1113
1114 #[inline]
1115 fn null() -> Self {
1116 Self(0)
1117 }
1118
1119 #[inline]
1120 fn from_raw(value: Self::Repr) -> Self {
1121 Self(value)
1122 }
1123
1124 #[inline]
1125 fn as_raw(self) -> Self::Repr {
1126 self.0
1127 }
1128
1129 #[inline]
1130 fn is_null(self) -> bool {
1131 self.0 == 0
1132 }
1133}
1134
1135impl Default for ExternalComputeQueueNV {
1136 #[inline]
1137 fn default() -> Self {
1138 Self::null()
1139 }
1140}
1141
1142impl fmt::Debug for ExternalComputeQueueNV {
1143 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1144 write!(f, "ExternalComputeQueueNV({:p})", self.0 as *const u8)
1145 }
1146}
1147
1148#[repr(transparent)]
1150#[derive(Copy, Clone, PartialEq, Eq, Hash)]
1151pub struct Fence(u64);
1152
1153impl Handle for Fence {
1154 type Repr = u64;
1155
1156 const TYPE: ObjectType = ObjectType::FENCE;
1157
1158 #[inline]
1159 fn null() -> Self {
1160 Self(0)
1161 }
1162
1163 #[inline]
1164 fn from_raw(value: Self::Repr) -> Self {
1165 Self(value)
1166 }
1167
1168 #[inline]
1169 fn as_raw(self) -> Self::Repr {
1170 self.0
1171 }
1172
1173 #[inline]
1174 fn is_null(self) -> bool {
1175 self.0 == 0
1176 }
1177}
1178
1179impl Default for Fence {
1180 #[inline]
1181 fn default() -> Self {
1182 Self::null()
1183 }
1184}
1185
1186impl fmt::Debug for Fence {
1187 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1188 write!(f, "Fence({:p})", self.0 as *const u8)
1189 }
1190}
1191
1192#[repr(transparent)]
1194#[derive(Copy, Clone, PartialEq, Eq, Hash)]
1195pub struct Framebuffer(u64);
1196
1197impl Handle for Framebuffer {
1198 type Repr = u64;
1199
1200 const TYPE: ObjectType = ObjectType::FRAMEBUFFER;
1201
1202 #[inline]
1203 fn null() -> Self {
1204 Self(0)
1205 }
1206
1207 #[inline]
1208 fn from_raw(value: Self::Repr) -> Self {
1209 Self(value)
1210 }
1211
1212 #[inline]
1213 fn as_raw(self) -> Self::Repr {
1214 self.0
1215 }
1216
1217 #[inline]
1218 fn is_null(self) -> bool {
1219 self.0 == 0
1220 }
1221}
1222
1223impl Default for Framebuffer {
1224 #[inline]
1225 fn default() -> Self {
1226 Self::null()
1227 }
1228}
1229
1230impl fmt::Debug for Framebuffer {
1231 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1232 write!(f, "Framebuffer({:p})", self.0 as *const u8)
1233 }
1234}
1235
1236#[repr(transparent)]
1238#[derive(Copy, Clone, PartialEq, Eq, Hash)]
1239pub struct Image(u64);
1240
1241impl Handle for Image {
1242 type Repr = u64;
1243
1244 const TYPE: ObjectType = ObjectType::IMAGE;
1245
1246 #[inline]
1247 fn null() -> Self {
1248 Self(0)
1249 }
1250
1251 #[inline]
1252 fn from_raw(value: Self::Repr) -> Self {
1253 Self(value)
1254 }
1255
1256 #[inline]
1257 fn as_raw(self) -> Self::Repr {
1258 self.0
1259 }
1260
1261 #[inline]
1262 fn is_null(self) -> bool {
1263 self.0 == 0
1264 }
1265}
1266
1267impl Default for Image {
1268 #[inline]
1269 fn default() -> Self {
1270 Self::null()
1271 }
1272}
1273
1274impl fmt::Debug for Image {
1275 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1276 write!(f, "Image({:p})", self.0 as *const u8)
1277 }
1278}
1279
1280#[repr(transparent)]
1282#[derive(Copy, Clone, PartialEq, Eq, Hash)]
1283pub struct ImageView(u64);
1284
1285impl Handle for ImageView {
1286 type Repr = u64;
1287
1288 const TYPE: ObjectType = ObjectType::IMAGE_VIEW;
1289
1290 #[inline]
1291 fn null() -> Self {
1292 Self(0)
1293 }
1294
1295 #[inline]
1296 fn from_raw(value: Self::Repr) -> Self {
1297 Self(value)
1298 }
1299
1300 #[inline]
1301 fn as_raw(self) -> Self::Repr {
1302 self.0
1303 }
1304
1305 #[inline]
1306 fn is_null(self) -> bool {
1307 self.0 == 0
1308 }
1309}
1310
1311impl Default for ImageView {
1312 #[inline]
1313 fn default() -> Self {
1314 Self::null()
1315 }
1316}
1317
1318impl fmt::Debug for ImageView {
1319 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1320 write!(f, "ImageView({:p})", self.0 as *const u8)
1321 }
1322}
1323
1324#[repr(transparent)]
1326#[derive(Copy, Clone, PartialEq, Eq, Hash)]
1327pub struct IndirectCommandsLayoutEXT(u64);
1328
1329impl Handle for IndirectCommandsLayoutEXT {
1330 type Repr = u64;
1331
1332 const TYPE: ObjectType = ObjectType::INDIRECT_COMMANDS_LAYOUT_EXT;
1333
1334 #[inline]
1335 fn null() -> Self {
1336 Self(0)
1337 }
1338
1339 #[inline]
1340 fn from_raw(value: Self::Repr) -> Self {
1341 Self(value)
1342 }
1343
1344 #[inline]
1345 fn as_raw(self) -> Self::Repr {
1346 self.0
1347 }
1348
1349 #[inline]
1350 fn is_null(self) -> bool {
1351 self.0 == 0
1352 }
1353}
1354
1355impl Default for IndirectCommandsLayoutEXT {
1356 #[inline]
1357 fn default() -> Self {
1358 Self::null()
1359 }
1360}
1361
1362impl fmt::Debug for IndirectCommandsLayoutEXT {
1363 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1364 write!(f, "IndirectCommandsLayoutEXT({:p})", self.0 as *const u8)
1365 }
1366}
1367
1368#[repr(transparent)]
1370#[derive(Copy, Clone, PartialEq, Eq, Hash)]
1371pub struct IndirectCommandsLayoutNV(u64);
1372
1373impl Handle for IndirectCommandsLayoutNV {
1374 type Repr = u64;
1375
1376 const TYPE: ObjectType = ObjectType::INDIRECT_COMMANDS_LAYOUT_NV;
1377
1378 #[inline]
1379 fn null() -> Self {
1380 Self(0)
1381 }
1382
1383 #[inline]
1384 fn from_raw(value: Self::Repr) -> Self {
1385 Self(value)
1386 }
1387
1388 #[inline]
1389 fn as_raw(self) -> Self::Repr {
1390 self.0
1391 }
1392
1393 #[inline]
1394 fn is_null(self) -> bool {
1395 self.0 == 0
1396 }
1397}
1398
1399impl Default for IndirectCommandsLayoutNV {
1400 #[inline]
1401 fn default() -> Self {
1402 Self::null()
1403 }
1404}
1405
1406impl fmt::Debug for IndirectCommandsLayoutNV {
1407 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1408 write!(f, "IndirectCommandsLayoutNV({:p})", self.0 as *const u8)
1409 }
1410}
1411
1412#[repr(transparent)]
1414#[derive(Copy, Clone, PartialEq, Eq, Hash)]
1415pub struct IndirectExecutionSetEXT(u64);
1416
1417impl Handle for IndirectExecutionSetEXT {
1418 type Repr = u64;
1419
1420 const TYPE: ObjectType = ObjectType::INDIRECT_EXECUTION_SET_EXT;
1421
1422 #[inline]
1423 fn null() -> Self {
1424 Self(0)
1425 }
1426
1427 #[inline]
1428 fn from_raw(value: Self::Repr) -> Self {
1429 Self(value)
1430 }
1431
1432 #[inline]
1433 fn as_raw(self) -> Self::Repr {
1434 self.0
1435 }
1436
1437 #[inline]
1438 fn is_null(self) -> bool {
1439 self.0 == 0
1440 }
1441}
1442
1443impl Default for IndirectExecutionSetEXT {
1444 #[inline]
1445 fn default() -> Self {
1446 Self::null()
1447 }
1448}
1449
1450impl fmt::Debug for IndirectExecutionSetEXT {
1451 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1452 write!(f, "IndirectExecutionSetEXT({:p})", self.0 as *const u8)
1453 }
1454}
1455
1456#[repr(transparent)]
1458#[derive(Copy, Clone, PartialEq, Eq, Hash)]
1459pub struct Instance(usize);
1460
1461impl Handle for Instance {
1462 type Repr = usize;
1463
1464 const TYPE: ObjectType = ObjectType::INSTANCE;
1465
1466 #[inline]
1467 fn null() -> Self {
1468 Self(0)
1469 }
1470
1471 #[inline]
1472 fn from_raw(value: Self::Repr) -> Self {
1473 Self(value)
1474 }
1475
1476 #[inline]
1477 fn as_raw(self) -> Self::Repr {
1478 self.0
1479 }
1480
1481 #[inline]
1482 fn is_null(self) -> bool {
1483 self.0 == 0
1484 }
1485}
1486
1487impl Default for Instance {
1488 #[inline]
1489 fn default() -> Self {
1490 Self::null()
1491 }
1492}
1493
1494impl fmt::Debug for Instance {
1495 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1496 write!(f, "Instance({:p})", self.0 as *const u8)
1497 }
1498}
1499
1500#[repr(transparent)]
1502#[derive(Copy, Clone, PartialEq, Eq, Hash)]
1503pub struct MicromapEXT(u64);
1504
1505impl Handle for MicromapEXT {
1506 type Repr = u64;
1507
1508 const TYPE: ObjectType = ObjectType::MICROMAP_EXT;
1509
1510 #[inline]
1511 fn null() -> Self {
1512 Self(0)
1513 }
1514
1515 #[inline]
1516 fn from_raw(value: Self::Repr) -> Self {
1517 Self(value)
1518 }
1519
1520 #[inline]
1521 fn as_raw(self) -> Self::Repr {
1522 self.0
1523 }
1524
1525 #[inline]
1526 fn is_null(self) -> bool {
1527 self.0 == 0
1528 }
1529}
1530
1531impl Default for MicromapEXT {
1532 #[inline]
1533 fn default() -> Self {
1534 Self::null()
1535 }
1536}
1537
1538impl fmt::Debug for MicromapEXT {
1539 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1540 write!(f, "MicromapEXT({:p})", self.0 as *const u8)
1541 }
1542}
1543
1544#[repr(transparent)]
1546#[derive(Copy, Clone, PartialEq, Eq, Hash)]
1547pub struct OpticalFlowSessionNV(u64);
1548
1549impl Handle for OpticalFlowSessionNV {
1550 type Repr = u64;
1551
1552 const TYPE: ObjectType = ObjectType::OPTICAL_FLOW_SESSION_NV;
1553
1554 #[inline]
1555 fn null() -> Self {
1556 Self(0)
1557 }
1558
1559 #[inline]
1560 fn from_raw(value: Self::Repr) -> Self {
1561 Self(value)
1562 }
1563
1564 #[inline]
1565 fn as_raw(self) -> Self::Repr {
1566 self.0
1567 }
1568
1569 #[inline]
1570 fn is_null(self) -> bool {
1571 self.0 == 0
1572 }
1573}
1574
1575impl Default for OpticalFlowSessionNV {
1576 #[inline]
1577 fn default() -> Self {
1578 Self::null()
1579 }
1580}
1581
1582impl fmt::Debug for OpticalFlowSessionNV {
1583 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1584 write!(f, "OpticalFlowSessionNV({:p})", self.0 as *const u8)
1585 }
1586}
1587
1588#[repr(transparent)]
1590#[derive(Copy, Clone, PartialEq, Eq, Hash)]
1591pub struct PerformanceConfigurationINTEL(u64);
1592
1593impl Handle for PerformanceConfigurationINTEL {
1594 type Repr = u64;
1595
1596 const TYPE: ObjectType = ObjectType::PERFORMANCE_CONFIGURATION_INTEL;
1597
1598 #[inline]
1599 fn null() -> Self {
1600 Self(0)
1601 }
1602
1603 #[inline]
1604 fn from_raw(value: Self::Repr) -> Self {
1605 Self(value)
1606 }
1607
1608 #[inline]
1609 fn as_raw(self) -> Self::Repr {
1610 self.0
1611 }
1612
1613 #[inline]
1614 fn is_null(self) -> bool {
1615 self.0 == 0
1616 }
1617}
1618
1619impl Default for PerformanceConfigurationINTEL {
1620 #[inline]
1621 fn default() -> Self {
1622 Self::null()
1623 }
1624}
1625
1626impl fmt::Debug for PerformanceConfigurationINTEL {
1627 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1628 write!(
1629 f,
1630 "PerformanceConfigurationINTEL({:p})",
1631 self.0 as *const u8
1632 )
1633 }
1634}
1635
1636#[repr(transparent)]
1638#[derive(Copy, Clone, PartialEq, Eq, Hash)]
1639pub struct PhysicalDevice(usize);
1640
1641impl Handle for PhysicalDevice {
1642 type Repr = usize;
1643
1644 const TYPE: ObjectType = ObjectType::PHYSICAL_DEVICE;
1645
1646 #[inline]
1647 fn null() -> Self {
1648 Self(0)
1649 }
1650
1651 #[inline]
1652 fn from_raw(value: Self::Repr) -> Self {
1653 Self(value)
1654 }
1655
1656 #[inline]
1657 fn as_raw(self) -> Self::Repr {
1658 self.0
1659 }
1660
1661 #[inline]
1662 fn is_null(self) -> bool {
1663 self.0 == 0
1664 }
1665}
1666
1667impl Default for PhysicalDevice {
1668 #[inline]
1669 fn default() -> Self {
1670 Self::null()
1671 }
1672}
1673
1674impl fmt::Debug for PhysicalDevice {
1675 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1676 write!(f, "PhysicalDevice({:p})", self.0 as *const u8)
1677 }
1678}
1679
1680#[repr(transparent)]
1682#[derive(Copy, Clone, PartialEq, Eq, Hash)]
1683pub struct Pipeline(u64);
1684
1685impl Handle for Pipeline {
1686 type Repr = u64;
1687
1688 const TYPE: ObjectType = ObjectType::PIPELINE;
1689
1690 #[inline]
1691 fn null() -> Self {
1692 Self(0)
1693 }
1694
1695 #[inline]
1696 fn from_raw(value: Self::Repr) -> Self {
1697 Self(value)
1698 }
1699
1700 #[inline]
1701 fn as_raw(self) -> Self::Repr {
1702 self.0
1703 }
1704
1705 #[inline]
1706 fn is_null(self) -> bool {
1707 self.0 == 0
1708 }
1709}
1710
1711impl Default for Pipeline {
1712 #[inline]
1713 fn default() -> Self {
1714 Self::null()
1715 }
1716}
1717
1718impl fmt::Debug for Pipeline {
1719 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1720 write!(f, "Pipeline({:p})", self.0 as *const u8)
1721 }
1722}
1723
1724#[repr(transparent)]
1726#[derive(Copy, Clone, PartialEq, Eq, Hash)]
1727pub struct PipelineBinaryKHR(u64);
1728
1729impl Handle for PipelineBinaryKHR {
1730 type Repr = u64;
1731
1732 const TYPE: ObjectType = ObjectType::PIPELINE_BINARY_KHR;
1733
1734 #[inline]
1735 fn null() -> Self {
1736 Self(0)
1737 }
1738
1739 #[inline]
1740 fn from_raw(value: Self::Repr) -> Self {
1741 Self(value)
1742 }
1743
1744 #[inline]
1745 fn as_raw(self) -> Self::Repr {
1746 self.0
1747 }
1748
1749 #[inline]
1750 fn is_null(self) -> bool {
1751 self.0 == 0
1752 }
1753}
1754
1755impl Default for PipelineBinaryKHR {
1756 #[inline]
1757 fn default() -> Self {
1758 Self::null()
1759 }
1760}
1761
1762impl fmt::Debug for PipelineBinaryKHR {
1763 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1764 write!(f, "PipelineBinaryKHR({:p})", self.0 as *const u8)
1765 }
1766}
1767
1768#[repr(transparent)]
1770#[derive(Copy, Clone, PartialEq, Eq, Hash)]
1771pub struct PipelineCache(u64);
1772
1773impl Handle for PipelineCache {
1774 type Repr = u64;
1775
1776 const TYPE: ObjectType = ObjectType::PIPELINE_CACHE;
1777
1778 #[inline]
1779 fn null() -> Self {
1780 Self(0)
1781 }
1782
1783 #[inline]
1784 fn from_raw(value: Self::Repr) -> Self {
1785 Self(value)
1786 }
1787
1788 #[inline]
1789 fn as_raw(self) -> Self::Repr {
1790 self.0
1791 }
1792
1793 #[inline]
1794 fn is_null(self) -> bool {
1795 self.0 == 0
1796 }
1797}
1798
1799impl Default for PipelineCache {
1800 #[inline]
1801 fn default() -> Self {
1802 Self::null()
1803 }
1804}
1805
1806impl fmt::Debug for PipelineCache {
1807 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1808 write!(f, "PipelineCache({:p})", self.0 as *const u8)
1809 }
1810}
1811
1812#[repr(transparent)]
1814#[derive(Copy, Clone, PartialEq, Eq, Hash)]
1815pub struct PipelineLayout(u64);
1816
1817impl Handle for PipelineLayout {
1818 type Repr = u64;
1819
1820 const TYPE: ObjectType = ObjectType::PIPELINE_LAYOUT;
1821
1822 #[inline]
1823 fn null() -> Self {
1824 Self(0)
1825 }
1826
1827 #[inline]
1828 fn from_raw(value: Self::Repr) -> Self {
1829 Self(value)
1830 }
1831
1832 #[inline]
1833 fn as_raw(self) -> Self::Repr {
1834 self.0
1835 }
1836
1837 #[inline]
1838 fn is_null(self) -> bool {
1839 self.0 == 0
1840 }
1841}
1842
1843impl Default for PipelineLayout {
1844 #[inline]
1845 fn default() -> Self {
1846 Self::null()
1847 }
1848}
1849
1850impl fmt::Debug for PipelineLayout {
1851 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1852 write!(f, "PipelineLayout({:p})", self.0 as *const u8)
1853 }
1854}
1855
1856#[repr(transparent)]
1858#[derive(Copy, Clone, PartialEq, Eq, Hash)]
1859pub struct PrivateDataSlot(u64);
1860
1861impl Handle for PrivateDataSlot {
1862 type Repr = u64;
1863
1864 const TYPE: ObjectType = ObjectType::PRIVATE_DATA_SLOT;
1865
1866 #[inline]
1867 fn null() -> Self {
1868 Self(0)
1869 }
1870
1871 #[inline]
1872 fn from_raw(value: Self::Repr) -> Self {
1873 Self(value)
1874 }
1875
1876 #[inline]
1877 fn as_raw(self) -> Self::Repr {
1878 self.0
1879 }
1880
1881 #[inline]
1882 fn is_null(self) -> bool {
1883 self.0 == 0
1884 }
1885}
1886
1887impl Default for PrivateDataSlot {
1888 #[inline]
1889 fn default() -> Self {
1890 Self::null()
1891 }
1892}
1893
1894impl fmt::Debug for PrivateDataSlot {
1895 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1896 write!(f, "PrivateDataSlot({:p})", self.0 as *const u8)
1897 }
1898}
1899
1900#[repr(transparent)]
1902#[derive(Copy, Clone, PartialEq, Eq, Hash)]
1903pub struct QueryPool(u64);
1904
1905impl Handle for QueryPool {
1906 type Repr = u64;
1907
1908 const TYPE: ObjectType = ObjectType::QUERY_POOL;
1909
1910 #[inline]
1911 fn null() -> Self {
1912 Self(0)
1913 }
1914
1915 #[inline]
1916 fn from_raw(value: Self::Repr) -> Self {
1917 Self(value)
1918 }
1919
1920 #[inline]
1921 fn as_raw(self) -> Self::Repr {
1922 self.0
1923 }
1924
1925 #[inline]
1926 fn is_null(self) -> bool {
1927 self.0 == 0
1928 }
1929}
1930
1931impl Default for QueryPool {
1932 #[inline]
1933 fn default() -> Self {
1934 Self::null()
1935 }
1936}
1937
1938impl fmt::Debug for QueryPool {
1939 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1940 write!(f, "QueryPool({:p})", self.0 as *const u8)
1941 }
1942}
1943
1944#[repr(transparent)]
1946#[derive(Copy, Clone, PartialEq, Eq, Hash)]
1947pub struct Queue(usize);
1948
1949impl Handle for Queue {
1950 type Repr = usize;
1951
1952 const TYPE: ObjectType = ObjectType::QUEUE;
1953
1954 #[inline]
1955 fn null() -> Self {
1956 Self(0)
1957 }
1958
1959 #[inline]
1960 fn from_raw(value: Self::Repr) -> Self {
1961 Self(value)
1962 }
1963
1964 #[inline]
1965 fn as_raw(self) -> Self::Repr {
1966 self.0
1967 }
1968
1969 #[inline]
1970 fn is_null(self) -> bool {
1971 self.0 == 0
1972 }
1973}
1974
1975impl Default for Queue {
1976 #[inline]
1977 fn default() -> Self {
1978 Self::null()
1979 }
1980}
1981
1982impl fmt::Debug for Queue {
1983 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
1984 write!(f, "Queue({:p})", self.0 as *const u8)
1985 }
1986}
1987
1988#[repr(transparent)]
1990#[derive(Copy, Clone, PartialEq, Eq, Hash)]
1991pub struct RenderPass(u64);
1992
1993impl Handle for RenderPass {
1994 type Repr = u64;
1995
1996 const TYPE: ObjectType = ObjectType::RENDER_PASS;
1997
1998 #[inline]
1999 fn null() -> Self {
2000 Self(0)
2001 }
2002
2003 #[inline]
2004 fn from_raw(value: Self::Repr) -> Self {
2005 Self(value)
2006 }
2007
2008 #[inline]
2009 fn as_raw(self) -> Self::Repr {
2010 self.0
2011 }
2012
2013 #[inline]
2014 fn is_null(self) -> bool {
2015 self.0 == 0
2016 }
2017}
2018
2019impl Default for RenderPass {
2020 #[inline]
2021 fn default() -> Self {
2022 Self::null()
2023 }
2024}
2025
2026impl fmt::Debug for RenderPass {
2027 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2028 write!(f, "RenderPass({:p})", self.0 as *const u8)
2029 }
2030}
2031
2032#[repr(transparent)]
2034#[derive(Copy, Clone, PartialEq, Eq, Hash)]
2035pub struct Sampler(u64);
2036
2037impl Handle for Sampler {
2038 type Repr = u64;
2039
2040 const TYPE: ObjectType = ObjectType::SAMPLER;
2041
2042 #[inline]
2043 fn null() -> Self {
2044 Self(0)
2045 }
2046
2047 #[inline]
2048 fn from_raw(value: Self::Repr) -> Self {
2049 Self(value)
2050 }
2051
2052 #[inline]
2053 fn as_raw(self) -> Self::Repr {
2054 self.0
2055 }
2056
2057 #[inline]
2058 fn is_null(self) -> bool {
2059 self.0 == 0
2060 }
2061}
2062
2063impl Default for Sampler {
2064 #[inline]
2065 fn default() -> Self {
2066 Self::null()
2067 }
2068}
2069
2070impl fmt::Debug for Sampler {
2071 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2072 write!(f, "Sampler({:p})", self.0 as *const u8)
2073 }
2074}
2075
2076#[repr(transparent)]
2078#[derive(Copy, Clone, PartialEq, Eq, Hash)]
2079pub struct SamplerYcbcrConversion(u64);
2080
2081impl Handle for SamplerYcbcrConversion {
2082 type Repr = u64;
2083
2084 const TYPE: ObjectType = ObjectType::SAMPLER_YCBCR_CONVERSION;
2085
2086 #[inline]
2087 fn null() -> Self {
2088 Self(0)
2089 }
2090
2091 #[inline]
2092 fn from_raw(value: Self::Repr) -> Self {
2093 Self(value)
2094 }
2095
2096 #[inline]
2097 fn as_raw(self) -> Self::Repr {
2098 self.0
2099 }
2100
2101 #[inline]
2102 fn is_null(self) -> bool {
2103 self.0 == 0
2104 }
2105}
2106
2107impl Default for SamplerYcbcrConversion {
2108 #[inline]
2109 fn default() -> Self {
2110 Self::null()
2111 }
2112}
2113
2114impl fmt::Debug for SamplerYcbcrConversion {
2115 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2116 write!(f, "SamplerYcbcrConversion({:p})", self.0 as *const u8)
2117 }
2118}
2119
2120#[repr(transparent)]
2122#[derive(Copy, Clone, PartialEq, Eq, Hash)]
2123pub struct Semaphore(u64);
2124
2125impl Handle for Semaphore {
2126 type Repr = u64;
2127
2128 const TYPE: ObjectType = ObjectType::SEMAPHORE;
2129
2130 #[inline]
2131 fn null() -> Self {
2132 Self(0)
2133 }
2134
2135 #[inline]
2136 fn from_raw(value: Self::Repr) -> Self {
2137 Self(value)
2138 }
2139
2140 #[inline]
2141 fn as_raw(self) -> Self::Repr {
2142 self.0
2143 }
2144
2145 #[inline]
2146 fn is_null(self) -> bool {
2147 self.0 == 0
2148 }
2149}
2150
2151impl Default for Semaphore {
2152 #[inline]
2153 fn default() -> Self {
2154 Self::null()
2155 }
2156}
2157
2158impl fmt::Debug for Semaphore {
2159 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2160 write!(f, "Semaphore({:p})", self.0 as *const u8)
2161 }
2162}
2163
2164#[repr(transparent)]
2166#[derive(Copy, Clone, PartialEq, Eq, Hash)]
2167pub struct SemaphoreSciSyncPoolNV(u64);
2168
2169impl Handle for SemaphoreSciSyncPoolNV {
2170 type Repr = u64;
2171
2172 const TYPE: ObjectType = ObjectType::SEMAPHORE_SCI_SYNC_POOL_NV;
2173
2174 #[inline]
2175 fn null() -> Self {
2176 Self(0)
2177 }
2178
2179 #[inline]
2180 fn from_raw(value: Self::Repr) -> Self {
2181 Self(value)
2182 }
2183
2184 #[inline]
2185 fn as_raw(self) -> Self::Repr {
2186 self.0
2187 }
2188
2189 #[inline]
2190 fn is_null(self) -> bool {
2191 self.0 == 0
2192 }
2193}
2194
2195impl Default for SemaphoreSciSyncPoolNV {
2196 #[inline]
2197 fn default() -> Self {
2198 Self::null()
2199 }
2200}
2201
2202impl fmt::Debug for SemaphoreSciSyncPoolNV {
2203 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2204 write!(f, "SemaphoreSciSyncPoolNV({:p})", self.0 as *const u8)
2205 }
2206}
2207
2208#[repr(transparent)]
2210#[derive(Copy, Clone, PartialEq, Eq, Hash)]
2211pub struct ShaderEXT(u64);
2212
2213impl Handle for ShaderEXT {
2214 type Repr = u64;
2215
2216 const TYPE: ObjectType = ObjectType::SHADER_EXT;
2217
2218 #[inline]
2219 fn null() -> Self {
2220 Self(0)
2221 }
2222
2223 #[inline]
2224 fn from_raw(value: Self::Repr) -> Self {
2225 Self(value)
2226 }
2227
2228 #[inline]
2229 fn as_raw(self) -> Self::Repr {
2230 self.0
2231 }
2232
2233 #[inline]
2234 fn is_null(self) -> bool {
2235 self.0 == 0
2236 }
2237}
2238
2239impl Default for ShaderEXT {
2240 #[inline]
2241 fn default() -> Self {
2242 Self::null()
2243 }
2244}
2245
2246impl fmt::Debug for ShaderEXT {
2247 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2248 write!(f, "ShaderEXT({:p})", self.0 as *const u8)
2249 }
2250}
2251
2252#[repr(transparent)]
2254#[derive(Copy, Clone, PartialEq, Eq, Hash)]
2255pub struct ShaderModule(u64);
2256
2257impl Handle for ShaderModule {
2258 type Repr = u64;
2259
2260 const TYPE: ObjectType = ObjectType::SHADER_MODULE;
2261
2262 #[inline]
2263 fn null() -> Self {
2264 Self(0)
2265 }
2266
2267 #[inline]
2268 fn from_raw(value: Self::Repr) -> Self {
2269 Self(value)
2270 }
2271
2272 #[inline]
2273 fn as_raw(self) -> Self::Repr {
2274 self.0
2275 }
2276
2277 #[inline]
2278 fn is_null(self) -> bool {
2279 self.0 == 0
2280 }
2281}
2282
2283impl Default for ShaderModule {
2284 #[inline]
2285 fn default() -> Self {
2286 Self::null()
2287 }
2288}
2289
2290impl fmt::Debug for ShaderModule {
2291 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2292 write!(f, "ShaderModule({:p})", self.0 as *const u8)
2293 }
2294}
2295
2296#[repr(transparent)]
2298#[derive(Copy, Clone, PartialEq, Eq, Hash)]
2299pub struct SurfaceKHR(u64);
2300
2301impl Handle for SurfaceKHR {
2302 type Repr = u64;
2303
2304 const TYPE: ObjectType = ObjectType::SURFACE_KHR;
2305
2306 #[inline]
2307 fn null() -> Self {
2308 Self(0)
2309 }
2310
2311 #[inline]
2312 fn from_raw(value: Self::Repr) -> Self {
2313 Self(value)
2314 }
2315
2316 #[inline]
2317 fn as_raw(self) -> Self::Repr {
2318 self.0
2319 }
2320
2321 #[inline]
2322 fn is_null(self) -> bool {
2323 self.0 == 0
2324 }
2325}
2326
2327impl Default for SurfaceKHR {
2328 #[inline]
2329 fn default() -> Self {
2330 Self::null()
2331 }
2332}
2333
2334impl fmt::Debug for SurfaceKHR {
2335 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2336 write!(f, "SurfaceKHR({:p})", self.0 as *const u8)
2337 }
2338}
2339
2340#[repr(transparent)]
2342#[derive(Copy, Clone, PartialEq, Eq, Hash)]
2343pub struct SwapchainKHR(u64);
2344
2345impl Handle for SwapchainKHR {
2346 type Repr = u64;
2347
2348 const TYPE: ObjectType = ObjectType::SWAPCHAIN_KHR;
2349
2350 #[inline]
2351 fn null() -> Self {
2352 Self(0)
2353 }
2354
2355 #[inline]
2356 fn from_raw(value: Self::Repr) -> Self {
2357 Self(value)
2358 }
2359
2360 #[inline]
2361 fn as_raw(self) -> Self::Repr {
2362 self.0
2363 }
2364
2365 #[inline]
2366 fn is_null(self) -> bool {
2367 self.0 == 0
2368 }
2369}
2370
2371impl Default for SwapchainKHR {
2372 #[inline]
2373 fn default() -> Self {
2374 Self::null()
2375 }
2376}
2377
2378impl fmt::Debug for SwapchainKHR {
2379 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2380 write!(f, "SwapchainKHR({:p})", self.0 as *const u8)
2381 }
2382}
2383
2384#[repr(transparent)]
2386#[derive(Copy, Clone, PartialEq, Eq, Hash)]
2387pub struct TensorARM(u64);
2388
2389impl Handle for TensorARM {
2390 type Repr = u64;
2391
2392 const TYPE: ObjectType = ObjectType::TENSOR_ARM;
2393
2394 #[inline]
2395 fn null() -> Self {
2396 Self(0)
2397 }
2398
2399 #[inline]
2400 fn from_raw(value: Self::Repr) -> Self {
2401 Self(value)
2402 }
2403
2404 #[inline]
2405 fn as_raw(self) -> Self::Repr {
2406 self.0
2407 }
2408
2409 #[inline]
2410 fn is_null(self) -> bool {
2411 self.0 == 0
2412 }
2413}
2414
2415impl Default for TensorARM {
2416 #[inline]
2417 fn default() -> Self {
2418 Self::null()
2419 }
2420}
2421
2422impl fmt::Debug for TensorARM {
2423 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2424 write!(f, "TensorARM({:p})", self.0 as *const u8)
2425 }
2426}
2427
2428#[repr(transparent)]
2430#[derive(Copy, Clone, PartialEq, Eq, Hash)]
2431pub struct TensorViewARM(u64);
2432
2433impl Handle for TensorViewARM {
2434 type Repr = u64;
2435
2436 const TYPE: ObjectType = ObjectType::TENSOR_VIEW_ARM;
2437
2438 #[inline]
2439 fn null() -> Self {
2440 Self(0)
2441 }
2442
2443 #[inline]
2444 fn from_raw(value: Self::Repr) -> Self {
2445 Self(value)
2446 }
2447
2448 #[inline]
2449 fn as_raw(self) -> Self::Repr {
2450 self.0
2451 }
2452
2453 #[inline]
2454 fn is_null(self) -> bool {
2455 self.0 == 0
2456 }
2457}
2458
2459impl Default for TensorViewARM {
2460 #[inline]
2461 fn default() -> Self {
2462 Self::null()
2463 }
2464}
2465
2466impl fmt::Debug for TensorViewARM {
2467 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2468 write!(f, "TensorViewARM({:p})", self.0 as *const u8)
2469 }
2470}
2471
2472#[repr(transparent)]
2474#[derive(Copy, Clone, PartialEq, Eq, Hash)]
2475pub struct ValidationCacheEXT(u64);
2476
2477impl Handle for ValidationCacheEXT {
2478 type Repr = u64;
2479
2480 const TYPE: ObjectType = ObjectType::VALIDATION_CACHE_EXT;
2481
2482 #[inline]
2483 fn null() -> Self {
2484 Self(0)
2485 }
2486
2487 #[inline]
2488 fn from_raw(value: Self::Repr) -> Self {
2489 Self(value)
2490 }
2491
2492 #[inline]
2493 fn as_raw(self) -> Self::Repr {
2494 self.0
2495 }
2496
2497 #[inline]
2498 fn is_null(self) -> bool {
2499 self.0 == 0
2500 }
2501}
2502
2503impl Default for ValidationCacheEXT {
2504 #[inline]
2505 fn default() -> Self {
2506 Self::null()
2507 }
2508}
2509
2510impl fmt::Debug for ValidationCacheEXT {
2511 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2512 write!(f, "ValidationCacheEXT({:p})", self.0 as *const u8)
2513 }
2514}
2515
2516#[repr(transparent)]
2518#[derive(Copy, Clone, PartialEq, Eq, Hash)]
2519pub struct VideoSessionKHR(u64);
2520
2521impl Handle for VideoSessionKHR {
2522 type Repr = u64;
2523
2524 const TYPE: ObjectType = ObjectType::VIDEO_SESSION_KHR;
2525
2526 #[inline]
2527 fn null() -> Self {
2528 Self(0)
2529 }
2530
2531 #[inline]
2532 fn from_raw(value: Self::Repr) -> Self {
2533 Self(value)
2534 }
2535
2536 #[inline]
2537 fn as_raw(self) -> Self::Repr {
2538 self.0
2539 }
2540
2541 #[inline]
2542 fn is_null(self) -> bool {
2543 self.0 == 0
2544 }
2545}
2546
2547impl Default for VideoSessionKHR {
2548 #[inline]
2549 fn default() -> Self {
2550 Self::null()
2551 }
2552}
2553
2554impl fmt::Debug for VideoSessionKHR {
2555 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2556 write!(f, "VideoSessionKHR({:p})", self.0 as *const u8)
2557 }
2558}
2559
2560#[repr(transparent)]
2562#[derive(Copy, Clone, PartialEq, Eq, Hash)]
2563pub struct VideoSessionParametersKHR(u64);
2564
2565impl Handle for VideoSessionParametersKHR {
2566 type Repr = u64;
2567
2568 const TYPE: ObjectType = ObjectType::VIDEO_SESSION_PARAMETERS_KHR;
2569
2570 #[inline]
2571 fn null() -> Self {
2572 Self(0)
2573 }
2574
2575 #[inline]
2576 fn from_raw(value: Self::Repr) -> Self {
2577 Self(value)
2578 }
2579
2580 #[inline]
2581 fn as_raw(self) -> Self::Repr {
2582 self.0
2583 }
2584
2585 #[inline]
2586 fn is_null(self) -> bool {
2587 self.0 == 0
2588 }
2589}
2590
2591impl Default for VideoSessionParametersKHR {
2592 #[inline]
2593 fn default() -> Self {
2594 Self::null()
2595 }
2596}
2597
2598impl fmt::Debug for VideoSessionParametersKHR {
2599 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
2600 write!(f, "VideoSessionParametersKHR({:p})", self.0 as *const u8)
2601 }
2602}
2603
2604pub type DescriptorUpdateTemplateKHR = DescriptorUpdateTemplate;
2606pub type PrivateDataSlotEXT = PrivateDataSlot;
2608pub type SamplerYcbcrConversionKHR = SamplerYcbcrConversion;