dawn_rs/generated/
extensions.rs

1#![allow(dead_code, unused_imports)]
2use crate::ffi;
3use super::*;
4use std::any::Any;
5pub(crate) struct ChainedStructStorage {
6    entries: Vec<Box<ffi::WGPUChainedStruct>>,
7    buffers: Vec<Box<dyn Any>>,
8    nested: Vec<ChainedStructStorage>,
9}
10impl ChainedStructStorage {
11    pub(crate) fn new() -> Self {
12        Self {
13            entries: Vec::new(),
14            buffers: Vec::new(),
15            nested: Vec::new(),
16        }
17    }
18    pub(crate) fn push(
19        &mut self,
20        s_type: ffi::WGPUSType,
21        next: *mut ffi::WGPUChainedStruct,
22    ) -> *mut ffi::WGPUChainedStruct {
23        let mut node = Box::new(ffi::WGPUChainedStruct {
24            next,
25            sType: s_type,
26        });
27        let ptr = std::ptr::from_mut(node.as_mut());
28        self.entries.push(node);
29        ptr
30    }
31    pub(crate) fn push_value<T: 'static>(&mut self, value: T) -> *const T {
32        let boxed = Box::new(value);
33        let ptr = std::ptr::from_ref(boxed.as_ref());
34        self.buffers.push(boxed);
35        ptr
36    }
37    pub(crate) fn push_value_mut<T: 'static>(&mut self, value: T) -> *mut T {
38        let mut boxed = Box::new(value);
39        let ptr = std::ptr::from_mut(boxed.as_mut());
40        self.buffers.push(boxed);
41        ptr
42    }
43    pub(crate) fn push_vec<T: 'static>(&mut self, value: Vec<T>) -> *const T {
44        let ptr = value.as_ptr();
45        self.buffers.push(Box::new(value));
46        ptr
47    }
48    pub(crate) fn push_vec_mut<T: 'static>(&mut self, value: Vec<T>) -> *mut T {
49        let mut value = value;
50        let ptr = value.as_mut_ptr();
51        self.buffers.push(Box::new(value));
52        ptr
53    }
54    pub(crate) fn push_any<T: 'static>(&mut self, value: T) {
55        self.buffers.push(Box::new(value));
56    }
57    pub(crate) fn push_storage(&mut self, storage: ChainedStructStorage) {
58        self.nested.push(storage);
59    }
60}
61#[allow(dead_code)]
62pub enum AdapterInfoExtension {
63    AdapterPropertiesD3D(AdapterPropertiesD3D),
64    AdapterPropertiesWGPU(AdapterPropertiesWGPU),
65    AdapterPropertiesExplicitComputeSubgroupSizeConfigs(
66        AdapterPropertiesExplicitComputeSubgroupSizeConfigs,
67    ),
68    AdapterPropertiesMemoryHeaps(AdapterPropertiesMemoryHeaps),
69    AdapterPropertiesSubgroupMatrixConfigs(AdapterPropertiesSubgroupMatrixConfigs),
70    AdapterPropertiesVk(AdapterPropertiesVk),
71    DawnAdapterPropertiesPowerPreference(DawnAdapterPropertiesPowerPreference),
72}
73impl std::convert::From<AdapterPropertiesD3D> for AdapterInfoExtension {
74    fn from(ext: AdapterPropertiesD3D) -> Self {
75        AdapterInfoExtension::AdapterPropertiesD3D(ext)
76    }
77}
78impl std::convert::From<AdapterPropertiesWGPU> for AdapterInfoExtension {
79    fn from(ext: AdapterPropertiesWGPU) -> Self {
80        AdapterInfoExtension::AdapterPropertiesWGPU(ext)
81    }
82}
83impl std::convert::From<AdapterPropertiesExplicitComputeSubgroupSizeConfigs>
84for AdapterInfoExtension {
85    fn from(ext: AdapterPropertiesExplicitComputeSubgroupSizeConfigs) -> Self {
86        AdapterInfoExtension::AdapterPropertiesExplicitComputeSubgroupSizeConfigs(ext)
87    }
88}
89impl std::convert::From<AdapterPropertiesMemoryHeaps> for AdapterInfoExtension {
90    fn from(ext: AdapterPropertiesMemoryHeaps) -> Self {
91        AdapterInfoExtension::AdapterPropertiesMemoryHeaps(ext)
92    }
93}
94impl std::convert::From<AdapterPropertiesSubgroupMatrixConfigs>
95for AdapterInfoExtension {
96    fn from(ext: AdapterPropertiesSubgroupMatrixConfigs) -> Self {
97        AdapterInfoExtension::AdapterPropertiesSubgroupMatrixConfigs(ext)
98    }
99}
100impl std::convert::From<AdapterPropertiesVk> for AdapterInfoExtension {
101    fn from(ext: AdapterPropertiesVk) -> Self {
102        AdapterInfoExtension::AdapterPropertiesVk(ext)
103    }
104}
105impl std::convert::From<DawnAdapterPropertiesPowerPreference> for AdapterInfoExtension {
106    fn from(ext: DawnAdapterPropertiesPowerPreference) -> Self {
107        AdapterInfoExtension::DawnAdapterPropertiesPowerPreference(ext)
108    }
109}
110impl AdapterInfoExtension {
111    pub(crate) fn push_chain(
112        &self,
113        storage: &mut ChainedStructStorage,
114        next: *mut ffi::WGPUChainedStruct,
115    ) -> *mut ffi::WGPUChainedStruct {
116        match self {
117            AdapterInfoExtension::AdapterPropertiesD3D(value) => {
118                let (mut raw, storage_value) = value.to_ffi();
119                raw.chain.sType = SType::AdapterPropertiesD3D as ffi::WGPUSType;
120                raw.chain.next = next;
121                storage.push_storage(storage_value);
122                let raw_ptr = storage.push_value_mut(raw);
123                raw_ptr.cast::<ffi::WGPUChainedStruct>()
124            }
125            AdapterInfoExtension::AdapterPropertiesWGPU(value) => {
126                let (mut raw, storage_value) = value.to_ffi();
127                raw.chain.sType = SType::AdapterPropertiesWGPU as ffi::WGPUSType;
128                raw.chain.next = next;
129                storage.push_storage(storage_value);
130                let raw_ptr = storage.push_value_mut(raw);
131                raw_ptr.cast::<ffi::WGPUChainedStruct>()
132            }
133            AdapterInfoExtension::AdapterPropertiesExplicitComputeSubgroupSizeConfigs(
134                value,
135            ) => {
136                let (mut raw, storage_value) = value.to_ffi();
137                raw.chain.sType = SType::AdapterPropertiesExplicitComputeSubgroupSizeConfigs
138                    as ffi::WGPUSType;
139                raw.chain.next = next;
140                storage.push_storage(storage_value);
141                let raw_ptr = storage.push_value_mut(raw);
142                raw_ptr.cast::<ffi::WGPUChainedStruct>()
143            }
144            AdapterInfoExtension::AdapterPropertiesMemoryHeaps(value) => {
145                let (mut raw, storage_value) = value.to_ffi();
146                raw.chain.sType = SType::AdapterPropertiesMemoryHeaps as ffi::WGPUSType;
147                raw.chain.next = next;
148                storage.push_storage(storage_value);
149                let raw_ptr = storage.push_value_mut(raw);
150                raw_ptr.cast::<ffi::WGPUChainedStruct>()
151            }
152            AdapterInfoExtension::AdapterPropertiesSubgroupMatrixConfigs(value) => {
153                let (mut raw, storage_value) = value.to_ffi();
154                raw.chain.sType = SType::AdapterPropertiesSubgroupMatrixConfigs
155                    as ffi::WGPUSType;
156                raw.chain.next = next;
157                storage.push_storage(storage_value);
158                let raw_ptr = storage.push_value_mut(raw);
159                raw_ptr.cast::<ffi::WGPUChainedStruct>()
160            }
161            AdapterInfoExtension::AdapterPropertiesVk(value) => {
162                let (mut raw, storage_value) = value.to_ffi();
163                raw.chain.sType = SType::AdapterPropertiesVk as ffi::WGPUSType;
164                raw.chain.next = next;
165                storage.push_storage(storage_value);
166                let raw_ptr = storage.push_value_mut(raw);
167                raw_ptr.cast::<ffi::WGPUChainedStruct>()
168            }
169            AdapterInfoExtension::DawnAdapterPropertiesPowerPreference(value) => {
170                let (mut raw, storage_value) = value.to_ffi();
171                raw.chain.sType = SType::DawnAdapterPropertiesPowerPreference
172                    as ffi::WGPUSType;
173                raw.chain.next = next;
174                storage.push_storage(storage_value);
175                let raw_ptr = storage.push_value_mut(raw);
176                raw_ptr.cast::<ffi::WGPUChainedStruct>()
177            }
178        }
179    }
180}
181#[allow(dead_code)]
182pub enum BindGroupDescriptorExtension {}
183impl BindGroupDescriptorExtension {
184    pub(crate) fn push_chain(
185        &self,
186        storage: &mut ChainedStructStorage,
187        next: *mut ffi::WGPUChainedStruct,
188    ) -> *mut ffi::WGPUChainedStruct {
189        let _ = self;
190        let _ = storage;
191        next
192    }
193}
194#[allow(dead_code)]
195pub enum BindGroupEntryExtension {
196    ExternalTextureBindingEntry(ExternalTextureBindingEntry),
197    TexelBufferBindingEntry(TexelBufferBindingEntry),
198}
199impl std::convert::From<ExternalTextureBindingEntry> for BindGroupEntryExtension {
200    fn from(ext: ExternalTextureBindingEntry) -> Self {
201        BindGroupEntryExtension::ExternalTextureBindingEntry(ext)
202    }
203}
204impl std::convert::From<TexelBufferBindingEntry> for BindGroupEntryExtension {
205    fn from(ext: TexelBufferBindingEntry) -> Self {
206        BindGroupEntryExtension::TexelBufferBindingEntry(ext)
207    }
208}
209impl BindGroupEntryExtension {
210    pub(crate) fn push_chain(
211        &self,
212        storage: &mut ChainedStructStorage,
213        next: *mut ffi::WGPUChainedStruct,
214    ) -> *mut ffi::WGPUChainedStruct {
215        match self {
216            BindGroupEntryExtension::ExternalTextureBindingEntry(value) => {
217                let (mut raw, storage_value) = value.to_ffi();
218                raw.chain.sType = SType::ExternalTextureBindingEntry as ffi::WGPUSType;
219                raw.chain.next = next;
220                storage.push_storage(storage_value);
221                let raw_ptr = storage.push_value_mut(raw);
222                raw_ptr.cast::<ffi::WGPUChainedStruct>()
223            }
224            BindGroupEntryExtension::TexelBufferBindingEntry(value) => {
225                let (mut raw, storage_value) = value.to_ffi();
226                raw.chain.sType = SType::TexelBufferBindingEntry as ffi::WGPUSType;
227                raw.chain.next = next;
228                storage.push_storage(storage_value);
229                let raw_ptr = storage.push_value_mut(raw);
230                raw_ptr.cast::<ffi::WGPUChainedStruct>()
231            }
232        }
233    }
234}
235#[allow(dead_code)]
236pub enum BindGroupLayoutDescriptorExtension {}
237impl BindGroupLayoutDescriptorExtension {
238    pub(crate) fn push_chain(
239        &self,
240        storage: &mut ChainedStructStorage,
241        next: *mut ffi::WGPUChainedStruct,
242    ) -> *mut ffi::WGPUChainedStruct {
243        let _ = self;
244        let _ = storage;
245        next
246    }
247}
248#[allow(dead_code)]
249pub enum BindGroupLayoutEntryExtension {
250    ExternalTextureBindingLayout(ExternalTextureBindingLayout),
251    StaticSamplerBindingLayout(StaticSamplerBindingLayout),
252    TexelBufferBindingLayout(TexelBufferBindingLayout),
253}
254impl std::convert::From<ExternalTextureBindingLayout> for BindGroupLayoutEntryExtension {
255    fn from(ext: ExternalTextureBindingLayout) -> Self {
256        BindGroupLayoutEntryExtension::ExternalTextureBindingLayout(ext)
257    }
258}
259impl std::convert::From<StaticSamplerBindingLayout> for BindGroupLayoutEntryExtension {
260    fn from(ext: StaticSamplerBindingLayout) -> Self {
261        BindGroupLayoutEntryExtension::StaticSamplerBindingLayout(ext)
262    }
263}
264impl std::convert::From<TexelBufferBindingLayout> for BindGroupLayoutEntryExtension {
265    fn from(ext: TexelBufferBindingLayout) -> Self {
266        BindGroupLayoutEntryExtension::TexelBufferBindingLayout(ext)
267    }
268}
269impl BindGroupLayoutEntryExtension {
270    pub(crate) fn push_chain(
271        &self,
272        storage: &mut ChainedStructStorage,
273        next: *mut ffi::WGPUChainedStruct,
274    ) -> *mut ffi::WGPUChainedStruct {
275        match self {
276            BindGroupLayoutEntryExtension::ExternalTextureBindingLayout(value) => {
277                let (mut raw, storage_value) = value.to_ffi();
278                raw.chain.sType = SType::ExternalTextureBindingLayout as ffi::WGPUSType;
279                raw.chain.next = next;
280                storage.push_storage(storage_value);
281                let raw_ptr = storage.push_value_mut(raw);
282                raw_ptr.cast::<ffi::WGPUChainedStruct>()
283            }
284            BindGroupLayoutEntryExtension::StaticSamplerBindingLayout(value) => {
285                let (mut raw, storage_value) = value.to_ffi();
286                raw.chain.sType = SType::StaticSamplerBindingLayout as ffi::WGPUSType;
287                raw.chain.next = next;
288                storage.push_storage(storage_value);
289                let raw_ptr = storage.push_value_mut(raw);
290                raw_ptr.cast::<ffi::WGPUChainedStruct>()
291            }
292            BindGroupLayoutEntryExtension::TexelBufferBindingLayout(value) => {
293                let (mut raw, storage_value) = value.to_ffi();
294                raw.chain.sType = SType::TexelBufferBindingLayout as ffi::WGPUSType;
295                raw.chain.next = next;
296                storage.push_storage(storage_value);
297                let raw_ptr = storage.push_value_mut(raw);
298                raw_ptr.cast::<ffi::WGPUChainedStruct>()
299            }
300        }
301    }
302}
303#[allow(dead_code)]
304pub enum BindingResourceExtension {}
305impl BindingResourceExtension {
306    pub(crate) fn push_chain(
307        &self,
308        storage: &mut ChainedStructStorage,
309        next: *mut ffi::WGPUChainedStruct,
310    ) -> *mut ffi::WGPUChainedStruct {
311        let _ = self;
312        let _ = storage;
313        next
314    }
315}
316#[allow(dead_code)]
317pub enum BufferBindingLayoutExtension {}
318impl BufferBindingLayoutExtension {
319    pub(crate) fn push_chain(
320        &self,
321        storage: &mut ChainedStructStorage,
322        next: *mut ffi::WGPUChainedStruct,
323    ) -> *mut ffi::WGPUChainedStruct {
324        let _ = self;
325        let _ = storage;
326        next
327    }
328}
329#[allow(dead_code)]
330pub enum BufferDescriptorExtension {
331    BufferHostMappedPointer(BufferHostMappedPointer),
332    DawnBufferDescriptorErrorInfoFromWireClient(
333        DawnBufferDescriptorErrorInfoFromWireClient,
334    ),
335    DawnFakeBufferOOMForTesting(DawnFakeBufferOOMForTesting),
336}
337impl std::convert::From<BufferHostMappedPointer> for BufferDescriptorExtension {
338    fn from(ext: BufferHostMappedPointer) -> Self {
339        BufferDescriptorExtension::BufferHostMappedPointer(ext)
340    }
341}
342impl std::convert::From<DawnBufferDescriptorErrorInfoFromWireClient>
343for BufferDescriptorExtension {
344    fn from(ext: DawnBufferDescriptorErrorInfoFromWireClient) -> Self {
345        BufferDescriptorExtension::DawnBufferDescriptorErrorInfoFromWireClient(ext)
346    }
347}
348impl std::convert::From<DawnFakeBufferOOMForTesting> for BufferDescriptorExtension {
349    fn from(ext: DawnFakeBufferOOMForTesting) -> Self {
350        BufferDescriptorExtension::DawnFakeBufferOOMForTesting(ext)
351    }
352}
353impl BufferDescriptorExtension {
354    pub(crate) fn push_chain(
355        &self,
356        storage: &mut ChainedStructStorage,
357        next: *mut ffi::WGPUChainedStruct,
358    ) -> *mut ffi::WGPUChainedStruct {
359        match self {
360            BufferDescriptorExtension::BufferHostMappedPointer(value) => {
361                let (mut raw, storage_value) = value.to_ffi();
362                raw.chain.sType = SType::BufferHostMappedPointer as ffi::WGPUSType;
363                raw.chain.next = next;
364                storage.push_storage(storage_value);
365                let raw_ptr = storage.push_value_mut(raw);
366                raw_ptr.cast::<ffi::WGPUChainedStruct>()
367            }
368            BufferDescriptorExtension::DawnBufferDescriptorErrorInfoFromWireClient(
369                value,
370            ) => {
371                let (mut raw, storage_value) = value.to_ffi();
372                raw.chain.sType = SType::DawnBufferDescriptorErrorInfoFromWireClient
373                    as ffi::WGPUSType;
374                raw.chain.next = next;
375                storage.push_storage(storage_value);
376                let raw_ptr = storage.push_value_mut(raw);
377                raw_ptr.cast::<ffi::WGPUChainedStruct>()
378            }
379            BufferDescriptorExtension::DawnFakeBufferOOMForTesting(value) => {
380                let (mut raw, storage_value) = value.to_ffi();
381                raw.chain.sType = SType::DawnFakeBufferOOMForTesting as ffi::WGPUSType;
382                raw.chain.next = next;
383                storage.push_storage(storage_value);
384                let raw_ptr = storage.push_value_mut(raw);
385                raw_ptr.cast::<ffi::WGPUChainedStruct>()
386            }
387        }
388    }
389}
390#[allow(dead_code)]
391pub enum ColorTargetStateExtension {
392    ColorTargetStateExpandResolveTextureDawn(ColorTargetStateExpandResolveTextureDawn),
393}
394impl std::convert::From<ColorTargetStateExpandResolveTextureDawn>
395for ColorTargetStateExtension {
396    fn from(ext: ColorTargetStateExpandResolveTextureDawn) -> Self {
397        ColorTargetStateExtension::ColorTargetStateExpandResolveTextureDawn(ext)
398    }
399}
400impl ColorTargetStateExtension {
401    pub(crate) fn push_chain(
402        &self,
403        storage: &mut ChainedStructStorage,
404        next: *mut ffi::WGPUChainedStruct,
405    ) -> *mut ffi::WGPUChainedStruct {
406        match self {
407            ColorTargetStateExtension::ColorTargetStateExpandResolveTextureDawn(
408                value,
409            ) => {
410                let (mut raw, storage_value) = value.to_ffi();
411                raw.chain.sType = SType::ColorTargetStateExpandResolveTextureDawn
412                    as ffi::WGPUSType;
413                raw.chain.next = next;
414                storage.push_storage(storage_value);
415                let raw_ptr = storage.push_value_mut(raw);
416                raw_ptr.cast::<ffi::WGPUChainedStruct>()
417            }
418        }
419    }
420}
421#[allow(dead_code)]
422pub enum CommandBufferDescriptorExtension {}
423impl CommandBufferDescriptorExtension {
424    pub(crate) fn push_chain(
425        &self,
426        storage: &mut ChainedStructStorage,
427        next: *mut ffi::WGPUChainedStruct,
428    ) -> *mut ffi::WGPUChainedStruct {
429        let _ = self;
430        let _ = storage;
431        next
432    }
433}
434#[allow(dead_code)]
435pub enum CommandEncoderDescriptorExtension {
436    DawnEncoderInternalUsageDescriptor(DawnEncoderInternalUsageDescriptor),
437}
438impl std::convert::From<DawnEncoderInternalUsageDescriptor>
439for CommandEncoderDescriptorExtension {
440    fn from(ext: DawnEncoderInternalUsageDescriptor) -> Self {
441        CommandEncoderDescriptorExtension::DawnEncoderInternalUsageDescriptor(ext)
442    }
443}
444impl CommandEncoderDescriptorExtension {
445    pub(crate) fn push_chain(
446        &self,
447        storage: &mut ChainedStructStorage,
448        next: *mut ffi::WGPUChainedStruct,
449    ) -> *mut ffi::WGPUChainedStruct {
450        match self {
451            CommandEncoderDescriptorExtension::DawnEncoderInternalUsageDescriptor(
452                value,
453            ) => {
454                let (mut raw, storage_value) = value.to_ffi();
455                raw.chain.sType = SType::DawnEncoderInternalUsageDescriptor
456                    as ffi::WGPUSType;
457                raw.chain.next = next;
458                storage.push_storage(storage_value);
459                let raw_ptr = storage.push_value_mut(raw);
460                raw_ptr.cast::<ffi::WGPUChainedStruct>()
461            }
462        }
463    }
464}
465#[allow(dead_code)]
466pub enum CompilationInfoExtension {}
467impl CompilationInfoExtension {
468    pub(crate) fn push_chain(
469        &self,
470        storage: &mut ChainedStructStorage,
471        next: *mut ffi::WGPUChainedStruct,
472    ) -> *mut ffi::WGPUChainedStruct {
473        let _ = self;
474        let _ = storage;
475        next
476    }
477}
478#[allow(dead_code)]
479pub enum CompilationMessageExtension {
480    DawnCompilationMessageUtf16(DawnCompilationMessageUtf16),
481}
482impl std::convert::From<DawnCompilationMessageUtf16> for CompilationMessageExtension {
483    fn from(ext: DawnCompilationMessageUtf16) -> Self {
484        CompilationMessageExtension::DawnCompilationMessageUtf16(ext)
485    }
486}
487impl CompilationMessageExtension {
488    pub(crate) fn push_chain(
489        &self,
490        storage: &mut ChainedStructStorage,
491        next: *mut ffi::WGPUChainedStruct,
492    ) -> *mut ffi::WGPUChainedStruct {
493        match self {
494            CompilationMessageExtension::DawnCompilationMessageUtf16(value) => {
495                let (mut raw, storage_value) = value.to_ffi();
496                raw.chain.sType = SType::DawnCompilationMessageUtf16 as ffi::WGPUSType;
497                raw.chain.next = next;
498                storage.push_storage(storage_value);
499                let raw_ptr = storage.push_value_mut(raw);
500                raw_ptr.cast::<ffi::WGPUChainedStruct>()
501            }
502        }
503    }
504}
505#[allow(dead_code)]
506pub enum ComputePassDescriptorExtension {}
507impl ComputePassDescriptorExtension {
508    pub(crate) fn push_chain(
509        &self,
510        storage: &mut ChainedStructStorage,
511        next: *mut ffi::WGPUChainedStruct,
512    ) -> *mut ffi::WGPUChainedStruct {
513        let _ = self;
514        let _ = storage;
515        next
516    }
517}
518#[allow(dead_code)]
519pub enum ComputePipelineDescriptorExtension {}
520impl ComputePipelineDescriptorExtension {
521    pub(crate) fn push_chain(
522        &self,
523        storage: &mut ChainedStructStorage,
524        next: *mut ffi::WGPUChainedStruct,
525    ) -> *mut ffi::WGPUChainedStruct {
526        let _ = self;
527        let _ = storage;
528        next
529    }
530}
531#[allow(dead_code)]
532pub enum ComputeStateExtension {}
533impl ComputeStateExtension {
534    pub(crate) fn push_chain(
535        &self,
536        storage: &mut ChainedStructStorage,
537        next: *mut ffi::WGPUChainedStruct,
538    ) -> *mut ffi::WGPUChainedStruct {
539        let _ = self;
540        let _ = storage;
541        next
542    }
543}
544#[allow(dead_code)]
545pub enum ConstantEntryExtension {}
546impl ConstantEntryExtension {
547    pub(crate) fn push_chain(
548        &self,
549        storage: &mut ChainedStructStorage,
550        next: *mut ffi::WGPUChainedStruct,
551    ) -> *mut ffi::WGPUChainedStruct {
552        let _ = self;
553        let _ = storage;
554        next
555    }
556}
557#[allow(dead_code)]
558pub enum CopyTextureForBrowserOptionsExtension {}
559impl CopyTextureForBrowserOptionsExtension {
560    pub(crate) fn push_chain(
561        &self,
562        storage: &mut ChainedStructStorage,
563        next: *mut ffi::WGPUChainedStruct,
564    ) -> *mut ffi::WGPUChainedStruct {
565        let _ = self;
566        let _ = storage;
567        next
568    }
569}
570#[allow(dead_code)]
571pub enum DawnFormatCapabilitiesExtension {
572    DawnDrmFormatCapabilities(DawnDrmFormatCapabilities),
573}
574impl std::convert::From<DawnDrmFormatCapabilities> for DawnFormatCapabilitiesExtension {
575    fn from(ext: DawnDrmFormatCapabilities) -> Self {
576        DawnFormatCapabilitiesExtension::DawnDrmFormatCapabilities(ext)
577    }
578}
579impl DawnFormatCapabilitiesExtension {
580    pub(crate) fn push_chain(
581        &self,
582        storage: &mut ChainedStructStorage,
583        next: *mut ffi::WGPUChainedStruct,
584    ) -> *mut ffi::WGPUChainedStruct {
585        match self {
586            DawnFormatCapabilitiesExtension::DawnDrmFormatCapabilities(value) => {
587                let (mut raw, storage_value) = value.to_ffi();
588                raw.chain.sType = SType::DawnDrmFormatCapabilities as ffi::WGPUSType;
589                raw.chain.next = next;
590                storage.push_storage(storage_value);
591                let raw_ptr = storage.push_value_mut(raw);
592                raw_ptr.cast::<ffi::WGPUChainedStruct>()
593            }
594        }
595    }
596}
597#[allow(dead_code)]
598pub enum DepthStencilStateExtension {}
599impl DepthStencilStateExtension {
600    pub(crate) fn push_chain(
601        &self,
602        storage: &mut ChainedStructStorage,
603        next: *mut ffi::WGPUChainedStruct,
604    ) -> *mut ffi::WGPUChainedStruct {
605        let _ = self;
606        let _ = storage;
607        next
608    }
609}
610#[allow(dead_code)]
611pub enum DeviceDescriptorExtension {
612    DawnCacheDeviceDescriptor(DawnCacheDeviceDescriptor),
613    DawnConsumeAdapterDescriptor(DawnConsumeAdapterDescriptor),
614    DawnDeviceAllocatorControl(DawnDeviceAllocatorControl),
615    DawnFakeDeviceInitializeErrorForTesting(DawnFakeDeviceInitializeErrorForTesting),
616    DawnTogglesDescriptor(DawnTogglesDescriptor),
617}
618impl std::convert::From<DawnCacheDeviceDescriptor> for DeviceDescriptorExtension {
619    fn from(ext: DawnCacheDeviceDescriptor) -> Self {
620        DeviceDescriptorExtension::DawnCacheDeviceDescriptor(ext)
621    }
622}
623impl std::convert::From<DawnConsumeAdapterDescriptor> for DeviceDescriptorExtension {
624    fn from(ext: DawnConsumeAdapterDescriptor) -> Self {
625        DeviceDescriptorExtension::DawnConsumeAdapterDescriptor(ext)
626    }
627}
628impl std::convert::From<DawnDeviceAllocatorControl> for DeviceDescriptorExtension {
629    fn from(ext: DawnDeviceAllocatorControl) -> Self {
630        DeviceDescriptorExtension::DawnDeviceAllocatorControl(ext)
631    }
632}
633impl std::convert::From<DawnFakeDeviceInitializeErrorForTesting>
634for DeviceDescriptorExtension {
635    fn from(ext: DawnFakeDeviceInitializeErrorForTesting) -> Self {
636        DeviceDescriptorExtension::DawnFakeDeviceInitializeErrorForTesting(ext)
637    }
638}
639impl std::convert::From<DawnTogglesDescriptor> for DeviceDescriptorExtension {
640    fn from(ext: DawnTogglesDescriptor) -> Self {
641        DeviceDescriptorExtension::DawnTogglesDescriptor(ext)
642    }
643}
644impl DeviceDescriptorExtension {
645    pub(crate) fn push_chain(
646        &self,
647        storage: &mut ChainedStructStorage,
648        next: *mut ffi::WGPUChainedStruct,
649    ) -> *mut ffi::WGPUChainedStruct {
650        match self {
651            DeviceDescriptorExtension::DawnCacheDeviceDescriptor(value) => {
652                let (mut raw, storage_value) = value.to_ffi();
653                raw.chain.sType = SType::DawnCacheDeviceDescriptor as ffi::WGPUSType;
654                raw.chain.next = next;
655                storage.push_storage(storage_value);
656                let raw_ptr = storage.push_value_mut(raw);
657                raw_ptr.cast::<ffi::WGPUChainedStruct>()
658            }
659            DeviceDescriptorExtension::DawnConsumeAdapterDescriptor(value) => {
660                let (mut raw, storage_value) = value.to_ffi();
661                raw.chain.sType = SType::DawnConsumeAdapterDescriptor as ffi::WGPUSType;
662                raw.chain.next = next;
663                storage.push_storage(storage_value);
664                let raw_ptr = storage.push_value_mut(raw);
665                raw_ptr.cast::<ffi::WGPUChainedStruct>()
666            }
667            DeviceDescriptorExtension::DawnDeviceAllocatorControl(value) => {
668                let (mut raw, storage_value) = value.to_ffi();
669                raw.chain.sType = SType::DawnDeviceAllocatorControl as ffi::WGPUSType;
670                raw.chain.next = next;
671                storage.push_storage(storage_value);
672                let raw_ptr = storage.push_value_mut(raw);
673                raw_ptr.cast::<ffi::WGPUChainedStruct>()
674            }
675            DeviceDescriptorExtension::DawnFakeDeviceInitializeErrorForTesting(
676                value,
677            ) => {
678                let (mut raw, storage_value) = value.to_ffi();
679                raw.chain.sType = SType::DawnFakeDeviceInitializeErrorForTesting
680                    as ffi::WGPUSType;
681                raw.chain.next = next;
682                storage.push_storage(storage_value);
683                let raw_ptr = storage.push_value_mut(raw);
684                raw_ptr.cast::<ffi::WGPUChainedStruct>()
685            }
686            DeviceDescriptorExtension::DawnTogglesDescriptor(value) => {
687                let (mut raw, storage_value) = value.to_ffi();
688                raw.chain.sType = SType::DawnTogglesDescriptor as ffi::WGPUSType;
689                raw.chain.next = next;
690                storage.push_storage(storage_value);
691                let raw_ptr = storage.push_value_mut(raw);
692                raw_ptr.cast::<ffi::WGPUChainedStruct>()
693            }
694        }
695    }
696}
697#[allow(dead_code)]
698pub enum ExternalTextureDescriptorExtension {}
699impl ExternalTextureDescriptorExtension {
700    pub(crate) fn push_chain(
701        &self,
702        storage: &mut ChainedStructStorage,
703        next: *mut ffi::WGPUChainedStruct,
704    ) -> *mut ffi::WGPUChainedStruct {
705        let _ = self;
706        let _ = storage;
707        next
708    }
709}
710#[allow(dead_code)]
711pub enum FragmentStateExtension {}
712impl FragmentStateExtension {
713    pub(crate) fn push_chain(
714        &self,
715        storage: &mut ChainedStructStorage,
716        next: *mut ffi::WGPUChainedStruct,
717    ) -> *mut ffi::WGPUChainedStruct {
718        let _ = self;
719        let _ = storage;
720        next
721    }
722}
723#[allow(dead_code)]
724pub enum ImageCopyExternalTextureExtension {}
725impl ImageCopyExternalTextureExtension {
726    pub(crate) fn push_chain(
727        &self,
728        storage: &mut ChainedStructStorage,
729        next: *mut ffi::WGPUChainedStruct,
730    ) -> *mut ffi::WGPUChainedStruct {
731        let _ = self;
732        let _ = storage;
733        next
734    }
735}
736#[allow(dead_code)]
737pub enum InstanceDescriptorExtension {
738    DawnWGSLBlocklist(DawnWGSLBlocklist),
739    DawnTogglesDescriptor(DawnTogglesDescriptor),
740    DawnWireWGSLControl(DawnWireWGSLControl),
741}
742impl std::convert::From<DawnWGSLBlocklist> for InstanceDescriptorExtension {
743    fn from(ext: DawnWGSLBlocklist) -> Self {
744        InstanceDescriptorExtension::DawnWGSLBlocklist(ext)
745    }
746}
747impl std::convert::From<DawnTogglesDescriptor> for InstanceDescriptorExtension {
748    fn from(ext: DawnTogglesDescriptor) -> Self {
749        InstanceDescriptorExtension::DawnTogglesDescriptor(ext)
750    }
751}
752impl std::convert::From<DawnWireWGSLControl> for InstanceDescriptorExtension {
753    fn from(ext: DawnWireWGSLControl) -> Self {
754        InstanceDescriptorExtension::DawnWireWGSLControl(ext)
755    }
756}
757impl InstanceDescriptorExtension {
758    pub(crate) fn push_chain(
759        &self,
760        storage: &mut ChainedStructStorage,
761        next: *mut ffi::WGPUChainedStruct,
762    ) -> *mut ffi::WGPUChainedStruct {
763        match self {
764            InstanceDescriptorExtension::DawnWGSLBlocklist(value) => {
765                let (mut raw, storage_value) = value.to_ffi();
766                raw.chain.sType = SType::DawnWGSLBlocklist as ffi::WGPUSType;
767                raw.chain.next = next;
768                storage.push_storage(storage_value);
769                let raw_ptr = storage.push_value_mut(raw);
770                raw_ptr.cast::<ffi::WGPUChainedStruct>()
771            }
772            InstanceDescriptorExtension::DawnTogglesDescriptor(value) => {
773                let (mut raw, storage_value) = value.to_ffi();
774                raw.chain.sType = SType::DawnTogglesDescriptor as ffi::WGPUSType;
775                raw.chain.next = next;
776                storage.push_storage(storage_value);
777                let raw_ptr = storage.push_value_mut(raw);
778                raw_ptr.cast::<ffi::WGPUChainedStruct>()
779            }
780            InstanceDescriptorExtension::DawnWireWGSLControl(value) => {
781                let (mut raw, storage_value) = value.to_ffi();
782                raw.chain.sType = SType::DawnWireWGSLControl as ffi::WGPUSType;
783                raw.chain.next = next;
784                storage.push_storage(storage_value);
785                let raw_ptr = storage.push_value_mut(raw);
786                raw_ptr.cast::<ffi::WGPUChainedStruct>()
787            }
788        }
789    }
790}
791#[allow(dead_code)]
792pub enum InstanceLimitsExtension {}
793impl InstanceLimitsExtension {
794    pub(crate) fn push_chain(
795        &self,
796        storage: &mut ChainedStructStorage,
797        next: *mut ffi::WGPUChainedStruct,
798    ) -> *mut ffi::WGPUChainedStruct {
799        let _ = self;
800        let _ = storage;
801        next
802    }
803}
804#[allow(dead_code)]
805pub enum LimitsExtension {
806    CompatibilityModeLimits(CompatibilityModeLimits),
807    DawnHostMappedPointerLimits(DawnHostMappedPointerLimits),
808    DawnTexelCopyBufferRowAlignmentLimits(DawnTexelCopyBufferRowAlignmentLimits),
809    ResourceTableLimits(ResourceTableLimits),
810}
811impl std::convert::From<CompatibilityModeLimits> for LimitsExtension {
812    fn from(ext: CompatibilityModeLimits) -> Self {
813        LimitsExtension::CompatibilityModeLimits(ext)
814    }
815}
816impl std::convert::From<DawnHostMappedPointerLimits> for LimitsExtension {
817    fn from(ext: DawnHostMappedPointerLimits) -> Self {
818        LimitsExtension::DawnHostMappedPointerLimits(ext)
819    }
820}
821impl std::convert::From<DawnTexelCopyBufferRowAlignmentLimits> for LimitsExtension {
822    fn from(ext: DawnTexelCopyBufferRowAlignmentLimits) -> Self {
823        LimitsExtension::DawnTexelCopyBufferRowAlignmentLimits(ext)
824    }
825}
826impl std::convert::From<ResourceTableLimits> for LimitsExtension {
827    fn from(ext: ResourceTableLimits) -> Self {
828        LimitsExtension::ResourceTableLimits(ext)
829    }
830}
831impl LimitsExtension {
832    pub(crate) fn push_chain(
833        &self,
834        storage: &mut ChainedStructStorage,
835        next: *mut ffi::WGPUChainedStruct,
836    ) -> *mut ffi::WGPUChainedStruct {
837        match self {
838            LimitsExtension::CompatibilityModeLimits(value) => {
839                let (mut raw, storage_value) = value.to_ffi();
840                raw.chain.sType = SType::CompatibilityModeLimits as ffi::WGPUSType;
841                raw.chain.next = next;
842                storage.push_storage(storage_value);
843                let raw_ptr = storage.push_value_mut(raw);
844                raw_ptr.cast::<ffi::WGPUChainedStruct>()
845            }
846            LimitsExtension::DawnHostMappedPointerLimits(value) => {
847                let (mut raw, storage_value) = value.to_ffi();
848                raw.chain.sType = SType::DawnHostMappedPointerLimits as ffi::WGPUSType;
849                raw.chain.next = next;
850                storage.push_storage(storage_value);
851                let raw_ptr = storage.push_value_mut(raw);
852                raw_ptr.cast::<ffi::WGPUChainedStruct>()
853            }
854            LimitsExtension::DawnTexelCopyBufferRowAlignmentLimits(value) => {
855                let (mut raw, storage_value) = value.to_ffi();
856                raw.chain.sType = SType::DawnTexelCopyBufferRowAlignmentLimits
857                    as ffi::WGPUSType;
858                raw.chain.next = next;
859                storage.push_storage(storage_value);
860                let raw_ptr = storage.push_value_mut(raw);
861                raw_ptr.cast::<ffi::WGPUChainedStruct>()
862            }
863            LimitsExtension::ResourceTableLimits(value) => {
864                let (mut raw, storage_value) = value.to_ffi();
865                raw.chain.sType = SType::ResourceTableLimits as ffi::WGPUSType;
866                raw.chain.next = next;
867                storage.push_storage(storage_value);
868                let raw_ptr = storage.push_value_mut(raw);
869                raw_ptr.cast::<ffi::WGPUChainedStruct>()
870            }
871        }
872    }
873}
874#[allow(dead_code)]
875pub enum MultisampleStateExtension {}
876impl MultisampleStateExtension {
877    pub(crate) fn push_chain(
878        &self,
879        storage: &mut ChainedStructStorage,
880        next: *mut ffi::WGPUChainedStruct,
881    ) -> *mut ffi::WGPUChainedStruct {
882        let _ = self;
883        let _ = storage;
884        next
885    }
886}
887#[allow(dead_code)]
888pub enum PassTimestampWritesExtension {}
889impl PassTimestampWritesExtension {
890    pub(crate) fn push_chain(
891        &self,
892        storage: &mut ChainedStructStorage,
893        next: *mut ffi::WGPUChainedStruct,
894    ) -> *mut ffi::WGPUChainedStruct {
895        let _ = self;
896        let _ = storage;
897        next
898    }
899}
900#[allow(dead_code)]
901pub enum PipelineLayoutDescriptorExtension {
902    PipelineLayoutPixelLocalStorage(PipelineLayoutPixelLocalStorage),
903    PipelineLayoutResourceTable(PipelineLayoutResourceTable),
904}
905impl std::convert::From<PipelineLayoutPixelLocalStorage>
906for PipelineLayoutDescriptorExtension {
907    fn from(ext: PipelineLayoutPixelLocalStorage) -> Self {
908        PipelineLayoutDescriptorExtension::PipelineLayoutPixelLocalStorage(ext)
909    }
910}
911impl std::convert::From<PipelineLayoutResourceTable>
912for PipelineLayoutDescriptorExtension {
913    fn from(ext: PipelineLayoutResourceTable) -> Self {
914        PipelineLayoutDescriptorExtension::PipelineLayoutResourceTable(ext)
915    }
916}
917impl PipelineLayoutDescriptorExtension {
918    pub(crate) fn push_chain(
919        &self,
920        storage: &mut ChainedStructStorage,
921        next: *mut ffi::WGPUChainedStruct,
922    ) -> *mut ffi::WGPUChainedStruct {
923        match self {
924            PipelineLayoutDescriptorExtension::PipelineLayoutPixelLocalStorage(
925                value,
926            ) => {
927                let (mut raw, storage_value) = value.to_ffi();
928                raw.chain.sType = SType::PipelineLayoutPixelLocalStorage
929                    as ffi::WGPUSType;
930                raw.chain.next = next;
931                storage.push_storage(storage_value);
932                let raw_ptr = storage.push_value_mut(raw);
933                raw_ptr.cast::<ffi::WGPUChainedStruct>()
934            }
935            PipelineLayoutDescriptorExtension::PipelineLayoutResourceTable(value) => {
936                let (mut raw, storage_value) = value.to_ffi();
937                raw.chain.sType = SType::PipelineLayoutResourceTable as ffi::WGPUSType;
938                raw.chain.next = next;
939                storage.push_storage(storage_value);
940                let raw_ptr = storage.push_value_mut(raw);
941                raw_ptr.cast::<ffi::WGPUChainedStruct>()
942            }
943        }
944    }
945}
946#[allow(dead_code)]
947pub enum PipelineLayoutStorageAttachmentExtension {}
948impl PipelineLayoutStorageAttachmentExtension {
949    pub(crate) fn push_chain(
950        &self,
951        storage: &mut ChainedStructStorage,
952        next: *mut ffi::WGPUChainedStruct,
953    ) -> *mut ffi::WGPUChainedStruct {
954        let _ = self;
955        let _ = storage;
956        next
957    }
958}
959#[allow(dead_code)]
960pub enum PrimitiveStateExtension {}
961impl PrimitiveStateExtension {
962    pub(crate) fn push_chain(
963        &self,
964        storage: &mut ChainedStructStorage,
965        next: *mut ffi::WGPUChainedStruct,
966    ) -> *mut ffi::WGPUChainedStruct {
967        let _ = self;
968        let _ = storage;
969        next
970    }
971}
972#[allow(dead_code)]
973pub enum QuerySetDescriptorExtension {}
974impl QuerySetDescriptorExtension {
975    pub(crate) fn push_chain(
976        &self,
977        storage: &mut ChainedStructStorage,
978        next: *mut ffi::WGPUChainedStruct,
979    ) -> *mut ffi::WGPUChainedStruct {
980        let _ = self;
981        let _ = storage;
982        next
983    }
984}
985#[allow(dead_code)]
986pub enum QueueDescriptorExtension {}
987impl QueueDescriptorExtension {
988    pub(crate) fn push_chain(
989        &self,
990        storage: &mut ChainedStructStorage,
991        next: *mut ffi::WGPUChainedStruct,
992    ) -> *mut ffi::WGPUChainedStruct {
993        let _ = self;
994        let _ = storage;
995        next
996    }
997}
998#[allow(dead_code)]
999pub enum RenderBundleDescriptorExtension {}
1000impl RenderBundleDescriptorExtension {
1001    pub(crate) fn push_chain(
1002        &self,
1003        storage: &mut ChainedStructStorage,
1004        next: *mut ffi::WGPUChainedStruct,
1005    ) -> *mut ffi::WGPUChainedStruct {
1006        let _ = self;
1007        let _ = storage;
1008        next
1009    }
1010}
1011#[allow(dead_code)]
1012pub enum RenderBundleEncoderDescriptorExtension {}
1013impl RenderBundleEncoderDescriptorExtension {
1014    pub(crate) fn push_chain(
1015        &self,
1016        storage: &mut ChainedStructStorage,
1017        next: *mut ffi::WGPUChainedStruct,
1018    ) -> *mut ffi::WGPUChainedStruct {
1019        let _ = self;
1020        let _ = storage;
1021        next
1022    }
1023}
1024#[allow(dead_code)]
1025pub enum RenderPassColorAttachmentExtension {
1026    DawnRenderPassColorAttachmentRenderToSingleSampled(
1027        DawnRenderPassColorAttachmentRenderToSingleSampled,
1028    ),
1029}
1030impl std::convert::From<DawnRenderPassColorAttachmentRenderToSingleSampled>
1031for RenderPassColorAttachmentExtension {
1032    fn from(ext: DawnRenderPassColorAttachmentRenderToSingleSampled) -> Self {
1033        RenderPassColorAttachmentExtension::DawnRenderPassColorAttachmentRenderToSingleSampled(
1034            ext,
1035        )
1036    }
1037}
1038impl RenderPassColorAttachmentExtension {
1039    pub(crate) fn push_chain(
1040        &self,
1041        storage: &mut ChainedStructStorage,
1042        next: *mut ffi::WGPUChainedStruct,
1043    ) -> *mut ffi::WGPUChainedStruct {
1044        match self {
1045            RenderPassColorAttachmentExtension::DawnRenderPassColorAttachmentRenderToSingleSampled(
1046                value,
1047            ) => {
1048                let (mut raw, storage_value) = value.to_ffi();
1049                raw.chain.sType = SType::DawnRenderPassColorAttachmentRenderToSingleSampled
1050                    as ffi::WGPUSType;
1051                raw.chain.next = next;
1052                storage.push_storage(storage_value);
1053                let raw_ptr = storage.push_value_mut(raw);
1054                raw_ptr.cast::<ffi::WGPUChainedStruct>()
1055            }
1056        }
1057    }
1058}
1059#[allow(dead_code)]
1060pub enum RenderPassDepthStencilAttachmentExtension {}
1061impl RenderPassDepthStencilAttachmentExtension {
1062    pub(crate) fn push_chain(
1063        &self,
1064        storage: &mut ChainedStructStorage,
1065        next: *mut ffi::WGPUChainedStruct,
1066    ) -> *mut ffi::WGPUChainedStruct {
1067        let _ = self;
1068        let _ = storage;
1069        next
1070    }
1071}
1072#[allow(dead_code)]
1073pub enum RenderPassDescriptorExtension {
1074    DawnRenderPassSampleCount(DawnRenderPassSampleCount),
1075    RenderPassDescriptorExpandResolveRect(RenderPassDescriptorExpandResolveRect),
1076    RenderPassDescriptorResolveRect(RenderPassDescriptorResolveRect),
1077    RenderPassMaxDrawCount(RenderPassMaxDrawCount),
1078    RenderPassPixelLocalStorage(RenderPassPixelLocalStorage),
1079}
1080impl std::convert::From<DawnRenderPassSampleCount> for RenderPassDescriptorExtension {
1081    fn from(ext: DawnRenderPassSampleCount) -> Self {
1082        RenderPassDescriptorExtension::DawnRenderPassSampleCount(ext)
1083    }
1084}
1085impl std::convert::From<RenderPassDescriptorExpandResolveRect>
1086for RenderPassDescriptorExtension {
1087    fn from(ext: RenderPassDescriptorExpandResolveRect) -> Self {
1088        RenderPassDescriptorExtension::RenderPassDescriptorExpandResolveRect(ext)
1089    }
1090}
1091impl std::convert::From<RenderPassDescriptorResolveRect>
1092for RenderPassDescriptorExtension {
1093    fn from(ext: RenderPassDescriptorResolveRect) -> Self {
1094        RenderPassDescriptorExtension::RenderPassDescriptorResolveRect(ext)
1095    }
1096}
1097impl std::convert::From<RenderPassMaxDrawCount> for RenderPassDescriptorExtension {
1098    fn from(ext: RenderPassMaxDrawCount) -> Self {
1099        RenderPassDescriptorExtension::RenderPassMaxDrawCount(ext)
1100    }
1101}
1102impl std::convert::From<RenderPassPixelLocalStorage> for RenderPassDescriptorExtension {
1103    fn from(ext: RenderPassPixelLocalStorage) -> Self {
1104        RenderPassDescriptorExtension::RenderPassPixelLocalStorage(ext)
1105    }
1106}
1107impl RenderPassDescriptorExtension {
1108    pub(crate) fn push_chain(
1109        &self,
1110        storage: &mut ChainedStructStorage,
1111        next: *mut ffi::WGPUChainedStruct,
1112    ) -> *mut ffi::WGPUChainedStruct {
1113        match self {
1114            RenderPassDescriptorExtension::DawnRenderPassSampleCount(value) => {
1115                let (mut raw, storage_value) = value.to_ffi();
1116                raw.chain.sType = SType::DawnRenderPassSampleCount as ffi::WGPUSType;
1117                raw.chain.next = next;
1118                storage.push_storage(storage_value);
1119                let raw_ptr = storage.push_value_mut(raw);
1120                raw_ptr.cast::<ffi::WGPUChainedStruct>()
1121            }
1122            RenderPassDescriptorExtension::RenderPassDescriptorExpandResolveRect(
1123                value,
1124            ) => {
1125                let (mut raw, storage_value) = value.to_ffi();
1126                raw.chain.sType = SType::RenderPassDescriptorExpandResolveRect
1127                    as ffi::WGPUSType;
1128                raw.chain.next = next;
1129                storage.push_storage(storage_value);
1130                let raw_ptr = storage.push_value_mut(raw);
1131                raw_ptr.cast::<ffi::WGPUChainedStruct>()
1132            }
1133            RenderPassDescriptorExtension::RenderPassDescriptorResolveRect(value) => {
1134                let (mut raw, storage_value) = value.to_ffi();
1135                raw.chain.sType = SType::RenderPassDescriptorResolveRect
1136                    as ffi::WGPUSType;
1137                raw.chain.next = next;
1138                storage.push_storage(storage_value);
1139                let raw_ptr = storage.push_value_mut(raw);
1140                raw_ptr.cast::<ffi::WGPUChainedStruct>()
1141            }
1142            RenderPassDescriptorExtension::RenderPassMaxDrawCount(value) => {
1143                let (mut raw, storage_value) = value.to_ffi();
1144                raw.chain.sType = SType::RenderPassMaxDrawCount as ffi::WGPUSType;
1145                raw.chain.next = next;
1146                storage.push_storage(storage_value);
1147                let raw_ptr = storage.push_value_mut(raw);
1148                raw_ptr.cast::<ffi::WGPUChainedStruct>()
1149            }
1150            RenderPassDescriptorExtension::RenderPassPixelLocalStorage(value) => {
1151                let (mut raw, storage_value) = value.to_ffi();
1152                raw.chain.sType = SType::RenderPassPixelLocalStorage as ffi::WGPUSType;
1153                raw.chain.next = next;
1154                storage.push_storage(storage_value);
1155                let raw_ptr = storage.push_value_mut(raw);
1156                raw_ptr.cast::<ffi::WGPUChainedStruct>()
1157            }
1158        }
1159    }
1160}
1161#[allow(dead_code)]
1162pub enum RenderPassStorageAttachmentExtension {}
1163impl RenderPassStorageAttachmentExtension {
1164    pub(crate) fn push_chain(
1165        &self,
1166        storage: &mut ChainedStructStorage,
1167        next: *mut ffi::WGPUChainedStruct,
1168    ) -> *mut ffi::WGPUChainedStruct {
1169        let _ = self;
1170        let _ = storage;
1171        next
1172    }
1173}
1174#[allow(dead_code)]
1175pub enum RenderPipelineDescriptorExtension {}
1176impl RenderPipelineDescriptorExtension {
1177    pub(crate) fn push_chain(
1178        &self,
1179        storage: &mut ChainedStructStorage,
1180        next: *mut ffi::WGPUChainedStruct,
1181    ) -> *mut ffi::WGPUChainedStruct {
1182        let _ = self;
1183        let _ = storage;
1184        next
1185    }
1186}
1187#[allow(dead_code)]
1188pub enum RequestAdapterOptionsExtension {
1189    DawnTogglesDescriptor(DawnTogglesDescriptor),
1190    RequestAdapterWebGPUBackendOptions(RequestAdapterWebGPUBackendOptions),
1191    RequestAdapterWebXROptions(RequestAdapterWebXROptions),
1192}
1193impl std::convert::From<DawnTogglesDescriptor> for RequestAdapterOptionsExtension {
1194    fn from(ext: DawnTogglesDescriptor) -> Self {
1195        RequestAdapterOptionsExtension::DawnTogglesDescriptor(ext)
1196    }
1197}
1198impl std::convert::From<RequestAdapterWebGPUBackendOptions>
1199for RequestAdapterOptionsExtension {
1200    fn from(ext: RequestAdapterWebGPUBackendOptions) -> Self {
1201        RequestAdapterOptionsExtension::RequestAdapterWebGPUBackendOptions(ext)
1202    }
1203}
1204impl std::convert::From<RequestAdapterWebXROptions> for RequestAdapterOptionsExtension {
1205    fn from(ext: RequestAdapterWebXROptions) -> Self {
1206        RequestAdapterOptionsExtension::RequestAdapterWebXROptions(ext)
1207    }
1208}
1209impl RequestAdapterOptionsExtension {
1210    pub(crate) fn push_chain(
1211        &self,
1212        storage: &mut ChainedStructStorage,
1213        next: *mut ffi::WGPUChainedStruct,
1214    ) -> *mut ffi::WGPUChainedStruct {
1215        match self {
1216            RequestAdapterOptionsExtension::DawnTogglesDescriptor(value) => {
1217                let (mut raw, storage_value) = value.to_ffi();
1218                raw.chain.sType = SType::DawnTogglesDescriptor as ffi::WGPUSType;
1219                raw.chain.next = next;
1220                storage.push_storage(storage_value);
1221                let raw_ptr = storage.push_value_mut(raw);
1222                raw_ptr.cast::<ffi::WGPUChainedStruct>()
1223            }
1224            RequestAdapterOptionsExtension::RequestAdapterWebGPUBackendOptions(
1225                value,
1226            ) => {
1227                let (mut raw, storage_value) = value.to_ffi();
1228                raw.chain.sType = SType::RequestAdapterWebGPUBackendOptions
1229                    as ffi::WGPUSType;
1230                raw.chain.next = next;
1231                storage.push_storage(storage_value);
1232                let raw_ptr = storage.push_value_mut(raw);
1233                raw_ptr.cast::<ffi::WGPUChainedStruct>()
1234            }
1235            RequestAdapterOptionsExtension::RequestAdapterWebXROptions(value) => {
1236                let (mut raw, storage_value) = value.to_ffi();
1237                raw.chain.sType = SType::RequestAdapterWebXROptions as ffi::WGPUSType;
1238                raw.chain.next = next;
1239                storage.push_storage(storage_value);
1240                let raw_ptr = storage.push_value_mut(raw);
1241                raw_ptr.cast::<ffi::WGPUChainedStruct>()
1242            }
1243        }
1244    }
1245}
1246#[allow(dead_code)]
1247pub enum ResourceTableDescriptorExtension {}
1248impl ResourceTableDescriptorExtension {
1249    pub(crate) fn push_chain(
1250        &self,
1251        storage: &mut ChainedStructStorage,
1252        next: *mut ffi::WGPUChainedStruct,
1253    ) -> *mut ffi::WGPUChainedStruct {
1254        let _ = self;
1255        let _ = storage;
1256        next
1257    }
1258}
1259#[allow(dead_code)]
1260pub enum SamplerBindingLayoutExtension {}
1261impl SamplerBindingLayoutExtension {
1262    pub(crate) fn push_chain(
1263        &self,
1264        storage: &mut ChainedStructStorage,
1265        next: *mut ffi::WGPUChainedStruct,
1266    ) -> *mut ffi::WGPUChainedStruct {
1267        let _ = self;
1268        let _ = storage;
1269        next
1270    }
1271}
1272#[allow(dead_code)]
1273pub enum SamplerDescriptorExtension {
1274    YCbCrVkDescriptor(YCbCrVkDescriptor),
1275}
1276impl std::convert::From<YCbCrVkDescriptor> for SamplerDescriptorExtension {
1277    fn from(ext: YCbCrVkDescriptor) -> Self {
1278        SamplerDescriptorExtension::YCbCrVkDescriptor(ext)
1279    }
1280}
1281impl SamplerDescriptorExtension {
1282    pub(crate) fn push_chain(
1283        &self,
1284        storage: &mut ChainedStructStorage,
1285        next: *mut ffi::WGPUChainedStruct,
1286    ) -> *mut ffi::WGPUChainedStruct {
1287        match self {
1288            SamplerDescriptorExtension::YCbCrVkDescriptor(value) => {
1289                let (mut raw, storage_value) = value.to_ffi();
1290                raw.chain.sType = SType::YCbCrVkDescriptor as ffi::WGPUSType;
1291                raw.chain.next = next;
1292                storage.push_storage(storage_value);
1293                let raw_ptr = storage.push_value_mut(raw);
1294                raw_ptr.cast::<ffi::WGPUChainedStruct>()
1295            }
1296        }
1297    }
1298}
1299#[allow(dead_code)]
1300pub enum ShaderModuleDescriptorExtension {
1301    DawnShaderModuleSPIRVOptionsDescriptor(DawnShaderModuleSPIRVOptionsDescriptor),
1302    ShaderModuleCompilationOptions(ShaderModuleCompilationOptions),
1303    ShaderSourceSPIRV(ShaderSourceSPIRV),
1304    ShaderSourceWGSL(ShaderSourceWGSL),
1305}
1306impl std::convert::From<DawnShaderModuleSPIRVOptionsDescriptor>
1307for ShaderModuleDescriptorExtension {
1308    fn from(ext: DawnShaderModuleSPIRVOptionsDescriptor) -> Self {
1309        ShaderModuleDescriptorExtension::DawnShaderModuleSPIRVOptionsDescriptor(ext)
1310    }
1311}
1312impl std::convert::From<ShaderModuleCompilationOptions>
1313for ShaderModuleDescriptorExtension {
1314    fn from(ext: ShaderModuleCompilationOptions) -> Self {
1315        ShaderModuleDescriptorExtension::ShaderModuleCompilationOptions(ext)
1316    }
1317}
1318impl std::convert::From<ShaderSourceSPIRV> for ShaderModuleDescriptorExtension {
1319    fn from(ext: ShaderSourceSPIRV) -> Self {
1320        ShaderModuleDescriptorExtension::ShaderSourceSPIRV(ext)
1321    }
1322}
1323impl std::convert::From<ShaderSourceWGSL> for ShaderModuleDescriptorExtension {
1324    fn from(ext: ShaderSourceWGSL) -> Self {
1325        ShaderModuleDescriptorExtension::ShaderSourceWGSL(ext)
1326    }
1327}
1328impl ShaderModuleDescriptorExtension {
1329    pub(crate) fn push_chain(
1330        &self,
1331        storage: &mut ChainedStructStorage,
1332        next: *mut ffi::WGPUChainedStruct,
1333    ) -> *mut ffi::WGPUChainedStruct {
1334        match self {
1335            ShaderModuleDescriptorExtension::DawnShaderModuleSPIRVOptionsDescriptor(
1336                value,
1337            ) => {
1338                let (mut raw, storage_value) = value.to_ffi();
1339                raw.chain.sType = SType::DawnShaderModuleSPIRVOptionsDescriptor
1340                    as ffi::WGPUSType;
1341                raw.chain.next = next;
1342                storage.push_storage(storage_value);
1343                let raw_ptr = storage.push_value_mut(raw);
1344                raw_ptr.cast::<ffi::WGPUChainedStruct>()
1345            }
1346            ShaderModuleDescriptorExtension::ShaderModuleCompilationOptions(value) => {
1347                let (mut raw, storage_value) = value.to_ffi();
1348                raw.chain.sType = SType::ShaderModuleCompilationOptions
1349                    as ffi::WGPUSType;
1350                raw.chain.next = next;
1351                storage.push_storage(storage_value);
1352                let raw_ptr = storage.push_value_mut(raw);
1353                raw_ptr.cast::<ffi::WGPUChainedStruct>()
1354            }
1355            ShaderModuleDescriptorExtension::ShaderSourceSPIRV(value) => {
1356                let (mut raw, storage_value) = value.to_ffi();
1357                raw.chain.sType = SType::ShaderSourceSPIRV as ffi::WGPUSType;
1358                raw.chain.next = next;
1359                storage.push_storage(storage_value);
1360                let raw_ptr = storage.push_value_mut(raw);
1361                raw_ptr.cast::<ffi::WGPUChainedStruct>()
1362            }
1363            ShaderModuleDescriptorExtension::ShaderSourceWGSL(value) => {
1364                let (mut raw, storage_value) = value.to_ffi();
1365                raw.chain.sType = SType::ShaderSourceWGSL as ffi::WGPUSType;
1366                raw.chain.next = next;
1367                storage.push_storage(storage_value);
1368                let raw_ptr = storage.push_value_mut(raw);
1369                raw_ptr.cast::<ffi::WGPUChainedStruct>()
1370            }
1371        }
1372    }
1373}
1374#[allow(dead_code)]
1375pub enum SharedBufferMemoryBeginAccessDescriptorExtension {}
1376impl SharedBufferMemoryBeginAccessDescriptorExtension {
1377    pub(crate) fn push_chain(
1378        &self,
1379        storage: &mut ChainedStructStorage,
1380        next: *mut ffi::WGPUChainedStruct,
1381    ) -> *mut ffi::WGPUChainedStruct {
1382        let _ = self;
1383        let _ = storage;
1384        next
1385    }
1386}
1387#[allow(dead_code)]
1388pub enum SharedBufferMemoryDescriptorExtension {}
1389impl SharedBufferMemoryDescriptorExtension {
1390    pub(crate) fn push_chain(
1391        &self,
1392        storage: &mut ChainedStructStorage,
1393        next: *mut ffi::WGPUChainedStruct,
1394    ) -> *mut ffi::WGPUChainedStruct {
1395        let _ = self;
1396        let _ = storage;
1397        next
1398    }
1399}
1400#[allow(dead_code)]
1401pub enum SharedBufferMemoryEndAccessStateExtension {}
1402impl SharedBufferMemoryEndAccessStateExtension {
1403    pub(crate) fn push_chain(
1404        &self,
1405        storage: &mut ChainedStructStorage,
1406        next: *mut ffi::WGPUChainedStruct,
1407    ) -> *mut ffi::WGPUChainedStruct {
1408        let _ = self;
1409        let _ = storage;
1410        next
1411    }
1412}
1413#[allow(dead_code)]
1414pub enum SharedBufferMemoryPropertiesExtension {}
1415impl SharedBufferMemoryPropertiesExtension {
1416    pub(crate) fn push_chain(
1417        &self,
1418        storage: &mut ChainedStructStorage,
1419        next: *mut ffi::WGPUChainedStruct,
1420    ) -> *mut ffi::WGPUChainedStruct {
1421        let _ = self;
1422        let _ = storage;
1423        next
1424    }
1425}
1426#[allow(dead_code)]
1427pub enum SharedFenceDescriptorExtension {
1428    SharedFenceDXGISharedHandleDescriptor(SharedFenceDXGISharedHandleDescriptor),
1429    SharedFenceEGLSyncDescriptor(SharedFenceEGLSyncDescriptor),
1430    SharedFenceMTLSharedEventDescriptor(SharedFenceMTLSharedEventDescriptor),
1431    SharedFenceSyncFDDescriptor(SharedFenceSyncFDDescriptor),
1432    SharedFenceVkSemaphoreOpaqueFDDescriptor(SharedFenceVkSemaphoreOpaqueFDDescriptor),
1433    SharedFenceVkSemaphoreZirconHandleDescriptor(
1434        SharedFenceVkSemaphoreZirconHandleDescriptor,
1435    ),
1436}
1437impl std::convert::From<SharedFenceDXGISharedHandleDescriptor>
1438for SharedFenceDescriptorExtension {
1439    fn from(ext: SharedFenceDXGISharedHandleDescriptor) -> Self {
1440        SharedFenceDescriptorExtension::SharedFenceDXGISharedHandleDescriptor(ext)
1441    }
1442}
1443impl std::convert::From<SharedFenceEGLSyncDescriptor>
1444for SharedFenceDescriptorExtension {
1445    fn from(ext: SharedFenceEGLSyncDescriptor) -> Self {
1446        SharedFenceDescriptorExtension::SharedFenceEGLSyncDescriptor(ext)
1447    }
1448}
1449impl std::convert::From<SharedFenceMTLSharedEventDescriptor>
1450for SharedFenceDescriptorExtension {
1451    fn from(ext: SharedFenceMTLSharedEventDescriptor) -> Self {
1452        SharedFenceDescriptorExtension::SharedFenceMTLSharedEventDescriptor(ext)
1453    }
1454}
1455impl std::convert::From<SharedFenceSyncFDDescriptor> for SharedFenceDescriptorExtension {
1456    fn from(ext: SharedFenceSyncFDDescriptor) -> Self {
1457        SharedFenceDescriptorExtension::SharedFenceSyncFDDescriptor(ext)
1458    }
1459}
1460impl std::convert::From<SharedFenceVkSemaphoreOpaqueFDDescriptor>
1461for SharedFenceDescriptorExtension {
1462    fn from(ext: SharedFenceVkSemaphoreOpaqueFDDescriptor) -> Self {
1463        SharedFenceDescriptorExtension::SharedFenceVkSemaphoreOpaqueFDDescriptor(ext)
1464    }
1465}
1466impl std::convert::From<SharedFenceVkSemaphoreZirconHandleDescriptor>
1467for SharedFenceDescriptorExtension {
1468    fn from(ext: SharedFenceVkSemaphoreZirconHandleDescriptor) -> Self {
1469        SharedFenceDescriptorExtension::SharedFenceVkSemaphoreZirconHandleDescriptor(ext)
1470    }
1471}
1472impl SharedFenceDescriptorExtension {
1473    pub(crate) fn push_chain(
1474        &self,
1475        storage: &mut ChainedStructStorage,
1476        next: *mut ffi::WGPUChainedStruct,
1477    ) -> *mut ffi::WGPUChainedStruct {
1478        match self {
1479            SharedFenceDescriptorExtension::SharedFenceDXGISharedHandleDescriptor(
1480                value,
1481            ) => {
1482                let (mut raw, storage_value) = value.to_ffi();
1483                raw.chain.sType = SType::SharedFenceDXGISharedHandleDescriptor
1484                    as ffi::WGPUSType;
1485                raw.chain.next = next;
1486                storage.push_storage(storage_value);
1487                let raw_ptr = storage.push_value_mut(raw);
1488                raw_ptr.cast::<ffi::WGPUChainedStruct>()
1489            }
1490            SharedFenceDescriptorExtension::SharedFenceEGLSyncDescriptor(value) => {
1491                let (mut raw, storage_value) = value.to_ffi();
1492                raw.chain.sType = SType::SharedFenceEGLSyncDescriptor as ffi::WGPUSType;
1493                raw.chain.next = next;
1494                storage.push_storage(storage_value);
1495                let raw_ptr = storage.push_value_mut(raw);
1496                raw_ptr.cast::<ffi::WGPUChainedStruct>()
1497            }
1498            SharedFenceDescriptorExtension::SharedFenceMTLSharedEventDescriptor(
1499                value,
1500            ) => {
1501                let (mut raw, storage_value) = value.to_ffi();
1502                raw.chain.sType = SType::SharedFenceMTLSharedEventDescriptor
1503                    as ffi::WGPUSType;
1504                raw.chain.next = next;
1505                storage.push_storage(storage_value);
1506                let raw_ptr = storage.push_value_mut(raw);
1507                raw_ptr.cast::<ffi::WGPUChainedStruct>()
1508            }
1509            SharedFenceDescriptorExtension::SharedFenceSyncFDDescriptor(value) => {
1510                let (mut raw, storage_value) = value.to_ffi();
1511                raw.chain.sType = SType::SharedFenceSyncFDDescriptor as ffi::WGPUSType;
1512                raw.chain.next = next;
1513                storage.push_storage(storage_value);
1514                let raw_ptr = storage.push_value_mut(raw);
1515                raw_ptr.cast::<ffi::WGPUChainedStruct>()
1516            }
1517            SharedFenceDescriptorExtension::SharedFenceVkSemaphoreOpaqueFDDescriptor(
1518                value,
1519            ) => {
1520                let (mut raw, storage_value) = value.to_ffi();
1521                raw.chain.sType = SType::SharedFenceVkSemaphoreOpaqueFDDescriptor
1522                    as ffi::WGPUSType;
1523                raw.chain.next = next;
1524                storage.push_storage(storage_value);
1525                let raw_ptr = storage.push_value_mut(raw);
1526                raw_ptr.cast::<ffi::WGPUChainedStruct>()
1527            }
1528            SharedFenceDescriptorExtension::SharedFenceVkSemaphoreZirconHandleDescriptor(
1529                value,
1530            ) => {
1531                let (mut raw, storage_value) = value.to_ffi();
1532                raw.chain.sType = SType::SharedFenceVkSemaphoreZirconHandleDescriptor
1533                    as ffi::WGPUSType;
1534                raw.chain.next = next;
1535                storage.push_storage(storage_value);
1536                let raw_ptr = storage.push_value_mut(raw);
1537                raw_ptr.cast::<ffi::WGPUChainedStruct>()
1538            }
1539        }
1540    }
1541}
1542#[allow(dead_code)]
1543pub enum SharedFenceExportInfoExtension {
1544    SharedFenceDXGISharedHandleExportInfo(SharedFenceDXGISharedHandleExportInfo),
1545    SharedFenceEGLSyncExportInfo(SharedFenceEGLSyncExportInfo),
1546    SharedFenceMTLSharedEventExportInfo(SharedFenceMTLSharedEventExportInfo),
1547    SharedFenceSyncFDExportInfo(SharedFenceSyncFDExportInfo),
1548    SharedFenceVkSemaphoreOpaqueFDExportInfo(SharedFenceVkSemaphoreOpaqueFDExportInfo),
1549    SharedFenceVkSemaphoreZirconHandleExportInfo(
1550        SharedFenceVkSemaphoreZirconHandleExportInfo,
1551    ),
1552}
1553impl std::convert::From<SharedFenceDXGISharedHandleExportInfo>
1554for SharedFenceExportInfoExtension {
1555    fn from(ext: SharedFenceDXGISharedHandleExportInfo) -> Self {
1556        SharedFenceExportInfoExtension::SharedFenceDXGISharedHandleExportInfo(ext)
1557    }
1558}
1559impl std::convert::From<SharedFenceEGLSyncExportInfo>
1560for SharedFenceExportInfoExtension {
1561    fn from(ext: SharedFenceEGLSyncExportInfo) -> Self {
1562        SharedFenceExportInfoExtension::SharedFenceEGLSyncExportInfo(ext)
1563    }
1564}
1565impl std::convert::From<SharedFenceMTLSharedEventExportInfo>
1566for SharedFenceExportInfoExtension {
1567    fn from(ext: SharedFenceMTLSharedEventExportInfo) -> Self {
1568        SharedFenceExportInfoExtension::SharedFenceMTLSharedEventExportInfo(ext)
1569    }
1570}
1571impl std::convert::From<SharedFenceSyncFDExportInfo> for SharedFenceExportInfoExtension {
1572    fn from(ext: SharedFenceSyncFDExportInfo) -> Self {
1573        SharedFenceExportInfoExtension::SharedFenceSyncFDExportInfo(ext)
1574    }
1575}
1576impl std::convert::From<SharedFenceVkSemaphoreOpaqueFDExportInfo>
1577for SharedFenceExportInfoExtension {
1578    fn from(ext: SharedFenceVkSemaphoreOpaqueFDExportInfo) -> Self {
1579        SharedFenceExportInfoExtension::SharedFenceVkSemaphoreOpaqueFDExportInfo(ext)
1580    }
1581}
1582impl std::convert::From<SharedFenceVkSemaphoreZirconHandleExportInfo>
1583for SharedFenceExportInfoExtension {
1584    fn from(ext: SharedFenceVkSemaphoreZirconHandleExportInfo) -> Self {
1585        SharedFenceExportInfoExtension::SharedFenceVkSemaphoreZirconHandleExportInfo(ext)
1586    }
1587}
1588impl SharedFenceExportInfoExtension {
1589    pub(crate) fn push_chain(
1590        &self,
1591        storage: &mut ChainedStructStorage,
1592        next: *mut ffi::WGPUChainedStruct,
1593    ) -> *mut ffi::WGPUChainedStruct {
1594        match self {
1595            SharedFenceExportInfoExtension::SharedFenceDXGISharedHandleExportInfo(
1596                value,
1597            ) => {
1598                let (mut raw, storage_value) = value.to_ffi();
1599                raw.chain.sType = SType::SharedFenceDXGISharedHandleExportInfo
1600                    as ffi::WGPUSType;
1601                raw.chain.next = next;
1602                storage.push_storage(storage_value);
1603                let raw_ptr = storage.push_value_mut(raw);
1604                raw_ptr.cast::<ffi::WGPUChainedStruct>()
1605            }
1606            SharedFenceExportInfoExtension::SharedFenceEGLSyncExportInfo(value) => {
1607                let (mut raw, storage_value) = value.to_ffi();
1608                raw.chain.sType = SType::SharedFenceEGLSyncExportInfo as ffi::WGPUSType;
1609                raw.chain.next = next;
1610                storage.push_storage(storage_value);
1611                let raw_ptr = storage.push_value_mut(raw);
1612                raw_ptr.cast::<ffi::WGPUChainedStruct>()
1613            }
1614            SharedFenceExportInfoExtension::SharedFenceMTLSharedEventExportInfo(
1615                value,
1616            ) => {
1617                let (mut raw, storage_value) = value.to_ffi();
1618                raw.chain.sType = SType::SharedFenceMTLSharedEventExportInfo
1619                    as ffi::WGPUSType;
1620                raw.chain.next = next;
1621                storage.push_storage(storage_value);
1622                let raw_ptr = storage.push_value_mut(raw);
1623                raw_ptr.cast::<ffi::WGPUChainedStruct>()
1624            }
1625            SharedFenceExportInfoExtension::SharedFenceSyncFDExportInfo(value) => {
1626                let (mut raw, storage_value) = value.to_ffi();
1627                raw.chain.sType = SType::SharedFenceSyncFDExportInfo as ffi::WGPUSType;
1628                raw.chain.next = next;
1629                storage.push_storage(storage_value);
1630                let raw_ptr = storage.push_value_mut(raw);
1631                raw_ptr.cast::<ffi::WGPUChainedStruct>()
1632            }
1633            SharedFenceExportInfoExtension::SharedFenceVkSemaphoreOpaqueFDExportInfo(
1634                value,
1635            ) => {
1636                let (mut raw, storage_value) = value.to_ffi();
1637                raw.chain.sType = SType::SharedFenceVkSemaphoreOpaqueFDExportInfo
1638                    as ffi::WGPUSType;
1639                raw.chain.next = next;
1640                storage.push_storage(storage_value);
1641                let raw_ptr = storage.push_value_mut(raw);
1642                raw_ptr.cast::<ffi::WGPUChainedStruct>()
1643            }
1644            SharedFenceExportInfoExtension::SharedFenceVkSemaphoreZirconHandleExportInfo(
1645                value,
1646            ) => {
1647                let (mut raw, storage_value) = value.to_ffi();
1648                raw.chain.sType = SType::SharedFenceVkSemaphoreZirconHandleExportInfo
1649                    as ffi::WGPUSType;
1650                raw.chain.next = next;
1651                storage.push_storage(storage_value);
1652                let raw_ptr = storage.push_value_mut(raw);
1653                raw_ptr.cast::<ffi::WGPUChainedStruct>()
1654            }
1655        }
1656    }
1657}
1658#[allow(dead_code)]
1659pub enum SharedTextureMemoryBeginAccessDescriptorExtension {
1660    SharedTextureMemoryD3DSwapchainBeginState(SharedTextureMemoryD3DSwapchainBeginState),
1661    SharedTextureMemoryD3D11BeginState(SharedTextureMemoryD3D11BeginState),
1662    SharedTextureMemoryVkImageLayoutBeginState(
1663        SharedTextureMemoryVkImageLayoutBeginState,
1664    ),
1665}
1666impl std::convert::From<SharedTextureMemoryD3DSwapchainBeginState>
1667for SharedTextureMemoryBeginAccessDescriptorExtension {
1668    fn from(ext: SharedTextureMemoryD3DSwapchainBeginState) -> Self {
1669        SharedTextureMemoryBeginAccessDescriptorExtension::SharedTextureMemoryD3DSwapchainBeginState(
1670            ext,
1671        )
1672    }
1673}
1674impl std::convert::From<SharedTextureMemoryD3D11BeginState>
1675for SharedTextureMemoryBeginAccessDescriptorExtension {
1676    fn from(ext: SharedTextureMemoryD3D11BeginState) -> Self {
1677        SharedTextureMemoryBeginAccessDescriptorExtension::SharedTextureMemoryD3D11BeginState(
1678            ext,
1679        )
1680    }
1681}
1682impl std::convert::From<SharedTextureMemoryVkImageLayoutBeginState>
1683for SharedTextureMemoryBeginAccessDescriptorExtension {
1684    fn from(ext: SharedTextureMemoryVkImageLayoutBeginState) -> Self {
1685        SharedTextureMemoryBeginAccessDescriptorExtension::SharedTextureMemoryVkImageLayoutBeginState(
1686            ext,
1687        )
1688    }
1689}
1690impl SharedTextureMemoryBeginAccessDescriptorExtension {
1691    pub(crate) fn push_chain(
1692        &self,
1693        storage: &mut ChainedStructStorage,
1694        next: *mut ffi::WGPUChainedStruct,
1695    ) -> *mut ffi::WGPUChainedStruct {
1696        match self {
1697            SharedTextureMemoryBeginAccessDescriptorExtension::SharedTextureMemoryD3DSwapchainBeginState(
1698                value,
1699            ) => {
1700                let (mut raw, storage_value) = value.to_ffi();
1701                raw.chain.sType = SType::SharedTextureMemoryD3DSwapchainBeginState
1702                    as ffi::WGPUSType;
1703                raw.chain.next = next;
1704                storage.push_storage(storage_value);
1705                let raw_ptr = storage.push_value_mut(raw);
1706                raw_ptr.cast::<ffi::WGPUChainedStruct>()
1707            }
1708            SharedTextureMemoryBeginAccessDescriptorExtension::SharedTextureMemoryD3D11BeginState(
1709                value,
1710            ) => {
1711                let (mut raw, storage_value) = value.to_ffi();
1712                raw.chain.sType = SType::SharedTextureMemoryD3D11BeginState
1713                    as ffi::WGPUSType;
1714                raw.chain.next = next;
1715                storage.push_storage(storage_value);
1716                let raw_ptr = storage.push_value_mut(raw);
1717                raw_ptr.cast::<ffi::WGPUChainedStruct>()
1718            }
1719            SharedTextureMemoryBeginAccessDescriptorExtension::SharedTextureMemoryVkImageLayoutBeginState(
1720                value,
1721            ) => {
1722                let (mut raw, storage_value) = value.to_ffi();
1723                raw.chain.sType = SType::SharedTextureMemoryVkImageLayoutBeginState
1724                    as ffi::WGPUSType;
1725                raw.chain.next = next;
1726                storage.push_storage(storage_value);
1727                let raw_ptr = storage.push_value_mut(raw);
1728                raw_ptr.cast::<ffi::WGPUChainedStruct>()
1729            }
1730        }
1731    }
1732}
1733#[allow(dead_code)]
1734pub enum SharedTextureMemoryDescriptorExtension {
1735    SharedTextureMemoryDXGISharedHandleDescriptor(
1736        SharedTextureMemoryDXGISharedHandleDescriptor,
1737    ),
1738    SharedTextureMemoryEGLImageDescriptor(SharedTextureMemoryEGLImageDescriptor),
1739    SharedTextureMemoryIOSurfaceDescriptor(SharedTextureMemoryIOSurfaceDescriptor),
1740    SharedTextureMemoryAHardwareBufferDescriptor(
1741        SharedTextureMemoryAHardwareBufferDescriptor,
1742    ),
1743    SharedTextureMemoryDmaBufDescriptor(SharedTextureMemoryDmaBufDescriptor),
1744    SharedTextureMemoryOpaqueFDDescriptor(SharedTextureMemoryOpaqueFDDescriptor),
1745    SharedTextureMemoryVkDedicatedAllocationDescriptor(
1746        SharedTextureMemoryVkDedicatedAllocationDescriptor,
1747    ),
1748    SharedTextureMemoryZirconHandleDescriptor(SharedTextureMemoryZirconHandleDescriptor),
1749}
1750impl std::convert::From<SharedTextureMemoryDXGISharedHandleDescriptor>
1751for SharedTextureMemoryDescriptorExtension {
1752    fn from(ext: SharedTextureMemoryDXGISharedHandleDescriptor) -> Self {
1753        SharedTextureMemoryDescriptorExtension::SharedTextureMemoryDXGISharedHandleDescriptor(
1754            ext,
1755        )
1756    }
1757}
1758impl std::convert::From<SharedTextureMemoryEGLImageDescriptor>
1759for SharedTextureMemoryDescriptorExtension {
1760    fn from(ext: SharedTextureMemoryEGLImageDescriptor) -> Self {
1761        SharedTextureMemoryDescriptorExtension::SharedTextureMemoryEGLImageDescriptor(
1762            ext,
1763        )
1764    }
1765}
1766impl std::convert::From<SharedTextureMemoryIOSurfaceDescriptor>
1767for SharedTextureMemoryDescriptorExtension {
1768    fn from(ext: SharedTextureMemoryIOSurfaceDescriptor) -> Self {
1769        SharedTextureMemoryDescriptorExtension::SharedTextureMemoryIOSurfaceDescriptor(
1770            ext,
1771        )
1772    }
1773}
1774impl std::convert::From<SharedTextureMemoryAHardwareBufferDescriptor>
1775for SharedTextureMemoryDescriptorExtension {
1776    fn from(ext: SharedTextureMemoryAHardwareBufferDescriptor) -> Self {
1777        SharedTextureMemoryDescriptorExtension::SharedTextureMemoryAHardwareBufferDescriptor(
1778            ext,
1779        )
1780    }
1781}
1782impl std::convert::From<SharedTextureMemoryDmaBufDescriptor>
1783for SharedTextureMemoryDescriptorExtension {
1784    fn from(ext: SharedTextureMemoryDmaBufDescriptor) -> Self {
1785        SharedTextureMemoryDescriptorExtension::SharedTextureMemoryDmaBufDescriptor(ext)
1786    }
1787}
1788impl std::convert::From<SharedTextureMemoryOpaqueFDDescriptor>
1789for SharedTextureMemoryDescriptorExtension {
1790    fn from(ext: SharedTextureMemoryOpaqueFDDescriptor) -> Self {
1791        SharedTextureMemoryDescriptorExtension::SharedTextureMemoryOpaqueFDDescriptor(
1792            ext,
1793        )
1794    }
1795}
1796impl std::convert::From<SharedTextureMemoryVkDedicatedAllocationDescriptor>
1797for SharedTextureMemoryDescriptorExtension {
1798    fn from(ext: SharedTextureMemoryVkDedicatedAllocationDescriptor) -> Self {
1799        SharedTextureMemoryDescriptorExtension::SharedTextureMemoryVkDedicatedAllocationDescriptor(
1800            ext,
1801        )
1802    }
1803}
1804impl std::convert::From<SharedTextureMemoryZirconHandleDescriptor>
1805for SharedTextureMemoryDescriptorExtension {
1806    fn from(ext: SharedTextureMemoryZirconHandleDescriptor) -> Self {
1807        SharedTextureMemoryDescriptorExtension::SharedTextureMemoryZirconHandleDescriptor(
1808            ext,
1809        )
1810    }
1811}
1812impl SharedTextureMemoryDescriptorExtension {
1813    pub(crate) fn push_chain(
1814        &self,
1815        storage: &mut ChainedStructStorage,
1816        next: *mut ffi::WGPUChainedStruct,
1817    ) -> *mut ffi::WGPUChainedStruct {
1818        match self {
1819            SharedTextureMemoryDescriptorExtension::SharedTextureMemoryDXGISharedHandleDescriptor(
1820                value,
1821            ) => {
1822                let (mut raw, storage_value) = value.to_ffi();
1823                raw.chain.sType = SType::SharedTextureMemoryDXGISharedHandleDescriptor
1824                    as ffi::WGPUSType;
1825                raw.chain.next = next;
1826                storage.push_storage(storage_value);
1827                let raw_ptr = storage.push_value_mut(raw);
1828                raw_ptr.cast::<ffi::WGPUChainedStruct>()
1829            }
1830            SharedTextureMemoryDescriptorExtension::SharedTextureMemoryEGLImageDescriptor(
1831                value,
1832            ) => {
1833                let (mut raw, storage_value) = value.to_ffi();
1834                raw.chain.sType = SType::SharedTextureMemoryEGLImageDescriptor
1835                    as ffi::WGPUSType;
1836                raw.chain.next = next;
1837                storage.push_storage(storage_value);
1838                let raw_ptr = storage.push_value_mut(raw);
1839                raw_ptr.cast::<ffi::WGPUChainedStruct>()
1840            }
1841            SharedTextureMemoryDescriptorExtension::SharedTextureMemoryIOSurfaceDescriptor(
1842                value,
1843            ) => {
1844                let (mut raw, storage_value) = value.to_ffi();
1845                raw.chain.sType = SType::SharedTextureMemoryIOSurfaceDescriptor
1846                    as ffi::WGPUSType;
1847                raw.chain.next = next;
1848                storage.push_storage(storage_value);
1849                let raw_ptr = storage.push_value_mut(raw);
1850                raw_ptr.cast::<ffi::WGPUChainedStruct>()
1851            }
1852            SharedTextureMemoryDescriptorExtension::SharedTextureMemoryAHardwareBufferDescriptor(
1853                value,
1854            ) => {
1855                let (mut raw, storage_value) = value.to_ffi();
1856                raw.chain.sType = SType::SharedTextureMemoryAHardwareBufferDescriptor
1857                    as ffi::WGPUSType;
1858                raw.chain.next = next;
1859                storage.push_storage(storage_value);
1860                let raw_ptr = storage.push_value_mut(raw);
1861                raw_ptr.cast::<ffi::WGPUChainedStruct>()
1862            }
1863            SharedTextureMemoryDescriptorExtension::SharedTextureMemoryDmaBufDescriptor(
1864                value,
1865            ) => {
1866                let (mut raw, storage_value) = value.to_ffi();
1867                raw.chain.sType = SType::SharedTextureMemoryDmaBufDescriptor
1868                    as ffi::WGPUSType;
1869                raw.chain.next = next;
1870                storage.push_storage(storage_value);
1871                let raw_ptr = storage.push_value_mut(raw);
1872                raw_ptr.cast::<ffi::WGPUChainedStruct>()
1873            }
1874            SharedTextureMemoryDescriptorExtension::SharedTextureMemoryOpaqueFDDescriptor(
1875                value,
1876            ) => {
1877                let (mut raw, storage_value) = value.to_ffi();
1878                raw.chain.sType = SType::SharedTextureMemoryOpaqueFDDescriptor
1879                    as ffi::WGPUSType;
1880                raw.chain.next = next;
1881                storage.push_storage(storage_value);
1882                let raw_ptr = storage.push_value_mut(raw);
1883                raw_ptr.cast::<ffi::WGPUChainedStruct>()
1884            }
1885            SharedTextureMemoryDescriptorExtension::SharedTextureMemoryVkDedicatedAllocationDescriptor(
1886                value,
1887            ) => {
1888                let (mut raw, storage_value) = value.to_ffi();
1889                raw.chain.sType = SType::SharedTextureMemoryVkDedicatedAllocationDescriptor
1890                    as ffi::WGPUSType;
1891                raw.chain.next = next;
1892                storage.push_storage(storage_value);
1893                let raw_ptr = storage.push_value_mut(raw);
1894                raw_ptr.cast::<ffi::WGPUChainedStruct>()
1895            }
1896            SharedTextureMemoryDescriptorExtension::SharedTextureMemoryZirconHandleDescriptor(
1897                value,
1898            ) => {
1899                let (mut raw, storage_value) = value.to_ffi();
1900                raw.chain.sType = SType::SharedTextureMemoryZirconHandleDescriptor
1901                    as ffi::WGPUSType;
1902                raw.chain.next = next;
1903                storage.push_storage(storage_value);
1904                let raw_ptr = storage.push_value_mut(raw);
1905                raw_ptr.cast::<ffi::WGPUChainedStruct>()
1906            }
1907        }
1908    }
1909}
1910#[allow(dead_code)]
1911pub enum SharedTextureMemoryEndAccessStateExtension {
1912    SharedTextureMemoryMetalEndAccessState(SharedTextureMemoryMetalEndAccessState),
1913    SharedTextureMemoryVkImageLayoutEndState(SharedTextureMemoryVkImageLayoutEndState),
1914}
1915impl std::convert::From<SharedTextureMemoryMetalEndAccessState>
1916for SharedTextureMemoryEndAccessStateExtension {
1917    fn from(ext: SharedTextureMemoryMetalEndAccessState) -> Self {
1918        SharedTextureMemoryEndAccessStateExtension::SharedTextureMemoryMetalEndAccessState(
1919            ext,
1920        )
1921    }
1922}
1923impl std::convert::From<SharedTextureMemoryVkImageLayoutEndState>
1924for SharedTextureMemoryEndAccessStateExtension {
1925    fn from(ext: SharedTextureMemoryVkImageLayoutEndState) -> Self {
1926        SharedTextureMemoryEndAccessStateExtension::SharedTextureMemoryVkImageLayoutEndState(
1927            ext,
1928        )
1929    }
1930}
1931impl SharedTextureMemoryEndAccessStateExtension {
1932    pub(crate) fn push_chain(
1933        &self,
1934        storage: &mut ChainedStructStorage,
1935        next: *mut ffi::WGPUChainedStruct,
1936    ) -> *mut ffi::WGPUChainedStruct {
1937        match self {
1938            SharedTextureMemoryEndAccessStateExtension::SharedTextureMemoryMetalEndAccessState(
1939                value,
1940            ) => {
1941                let (mut raw, storage_value) = value.to_ffi();
1942                raw.chain.sType = SType::SharedTextureMemoryMetalEndAccessState
1943                    as ffi::WGPUSType;
1944                raw.chain.next = next;
1945                storage.push_storage(storage_value);
1946                let raw_ptr = storage.push_value_mut(raw);
1947                raw_ptr.cast::<ffi::WGPUChainedStruct>()
1948            }
1949            SharedTextureMemoryEndAccessStateExtension::SharedTextureMemoryVkImageLayoutEndState(
1950                value,
1951            ) => {
1952                let (mut raw, storage_value) = value.to_ffi();
1953                raw.chain.sType = SType::SharedTextureMemoryVkImageLayoutEndState
1954                    as ffi::WGPUSType;
1955                raw.chain.next = next;
1956                storage.push_storage(storage_value);
1957                let raw_ptr = storage.push_value_mut(raw);
1958                raw_ptr.cast::<ffi::WGPUChainedStruct>()
1959            }
1960        }
1961    }
1962}
1963#[allow(dead_code)]
1964pub enum SharedTextureMemoryPropertiesExtension {
1965    SharedTextureMemoryAHardwareBufferProperties(
1966        SharedTextureMemoryAHardwareBufferProperties,
1967    ),
1968}
1969impl std::convert::From<SharedTextureMemoryAHardwareBufferProperties>
1970for SharedTextureMemoryPropertiesExtension {
1971    fn from(ext: SharedTextureMemoryAHardwareBufferProperties) -> Self {
1972        SharedTextureMemoryPropertiesExtension::SharedTextureMemoryAHardwareBufferProperties(
1973            ext,
1974        )
1975    }
1976}
1977impl SharedTextureMemoryPropertiesExtension {
1978    pub(crate) fn push_chain(
1979        &self,
1980        storage: &mut ChainedStructStorage,
1981        next: *mut ffi::WGPUChainedStruct,
1982    ) -> *mut ffi::WGPUChainedStruct {
1983        match self {
1984            SharedTextureMemoryPropertiesExtension::SharedTextureMemoryAHardwareBufferProperties(
1985                value,
1986            ) => {
1987                let (mut raw, storage_value) = value.to_ffi();
1988                raw.chain.sType = SType::SharedTextureMemoryAHardwareBufferProperties
1989                    as ffi::WGPUSType;
1990                raw.chain.next = next;
1991                storage.push_storage(storage_value);
1992                let raw_ptr = storage.push_value_mut(raw);
1993                raw_ptr.cast::<ffi::WGPUChainedStruct>()
1994            }
1995        }
1996    }
1997}
1998#[allow(dead_code)]
1999pub enum StorageTextureBindingLayoutExtension {}
2000impl StorageTextureBindingLayoutExtension {
2001    pub(crate) fn push_chain(
2002        &self,
2003        storage: &mut ChainedStructStorage,
2004        next: *mut ffi::WGPUChainedStruct,
2005    ) -> *mut ffi::WGPUChainedStruct {
2006        let _ = self;
2007        let _ = storage;
2008        next
2009    }
2010}
2011#[allow(dead_code)]
2012pub enum SurfaceCapabilitiesExtension {}
2013impl SurfaceCapabilitiesExtension {
2014    pub(crate) fn push_chain(
2015        &self,
2016        storage: &mut ChainedStructStorage,
2017        next: *mut ffi::WGPUChainedStruct,
2018    ) -> *mut ffi::WGPUChainedStruct {
2019        let _ = self;
2020        let _ = storage;
2021        next
2022    }
2023}
2024#[allow(dead_code)]
2025pub enum SurfaceConfigurationExtension {}
2026impl SurfaceConfigurationExtension {
2027    pub(crate) fn push_chain(
2028        &self,
2029        storage: &mut ChainedStructStorage,
2030        next: *mut ffi::WGPUChainedStruct,
2031    ) -> *mut ffi::WGPUChainedStruct {
2032        let _ = self;
2033        let _ = storage;
2034        next
2035    }
2036}
2037#[allow(dead_code)]
2038pub enum SurfaceDescriptorExtension {
2039    EmscriptenSurfaceSourceCanvasHTMLSelector(EmscriptenSurfaceSourceCanvasHTMLSelector),
2040    SurfaceColorManagement(SurfaceColorManagement),
2041    SurfaceDescriptorFromWindowsUWPSwapChainPanel(
2042        SurfaceDescriptorFromWindowsUWPSwapChainPanel,
2043    ),
2044    SurfaceDescriptorFromWindowsWinUISwapChainPanel(
2045        SurfaceDescriptorFromWindowsWinUISwapChainPanel,
2046    ),
2047    SurfaceDescriptorFromWindowsCoreWindow(SurfaceDescriptorFromWindowsCoreWindow),
2048    SurfaceSourceXCBWindow(SurfaceSourceXCBWindow),
2049    SurfaceSourceAndroidNativeWindow(SurfaceSourceAndroidNativeWindow),
2050    SurfaceSourceMetalLayer(SurfaceSourceMetalLayer),
2051    SurfaceSourceWaylandSurface(SurfaceSourceWaylandSurface),
2052    SurfaceSourceWindowsHWND(SurfaceSourceWindowsHWND),
2053    SurfaceSourceXlibWindow(SurfaceSourceXlibWindow),
2054}
2055impl std::convert::From<EmscriptenSurfaceSourceCanvasHTMLSelector>
2056for SurfaceDescriptorExtension {
2057    fn from(ext: EmscriptenSurfaceSourceCanvasHTMLSelector) -> Self {
2058        SurfaceDescriptorExtension::EmscriptenSurfaceSourceCanvasHTMLSelector(ext)
2059    }
2060}
2061impl std::convert::From<SurfaceColorManagement> for SurfaceDescriptorExtension {
2062    fn from(ext: SurfaceColorManagement) -> Self {
2063        SurfaceDescriptorExtension::SurfaceColorManagement(ext)
2064    }
2065}
2066impl std::convert::From<SurfaceDescriptorFromWindowsUWPSwapChainPanel>
2067for SurfaceDescriptorExtension {
2068    fn from(ext: SurfaceDescriptorFromWindowsUWPSwapChainPanel) -> Self {
2069        SurfaceDescriptorExtension::SurfaceDescriptorFromWindowsUWPSwapChainPanel(ext)
2070    }
2071}
2072impl std::convert::From<SurfaceDescriptorFromWindowsWinUISwapChainPanel>
2073for SurfaceDescriptorExtension {
2074    fn from(ext: SurfaceDescriptorFromWindowsWinUISwapChainPanel) -> Self {
2075        SurfaceDescriptorExtension::SurfaceDescriptorFromWindowsWinUISwapChainPanel(ext)
2076    }
2077}
2078impl std::convert::From<SurfaceDescriptorFromWindowsCoreWindow>
2079for SurfaceDescriptorExtension {
2080    fn from(ext: SurfaceDescriptorFromWindowsCoreWindow) -> Self {
2081        SurfaceDescriptorExtension::SurfaceDescriptorFromWindowsCoreWindow(ext)
2082    }
2083}
2084impl std::convert::From<SurfaceSourceXCBWindow> for SurfaceDescriptorExtension {
2085    fn from(ext: SurfaceSourceXCBWindow) -> Self {
2086        SurfaceDescriptorExtension::SurfaceSourceXCBWindow(ext)
2087    }
2088}
2089impl std::convert::From<SurfaceSourceAndroidNativeWindow>
2090for SurfaceDescriptorExtension {
2091    fn from(ext: SurfaceSourceAndroidNativeWindow) -> Self {
2092        SurfaceDescriptorExtension::SurfaceSourceAndroidNativeWindow(ext)
2093    }
2094}
2095impl std::convert::From<SurfaceSourceMetalLayer> for SurfaceDescriptorExtension {
2096    fn from(ext: SurfaceSourceMetalLayer) -> Self {
2097        SurfaceDescriptorExtension::SurfaceSourceMetalLayer(ext)
2098    }
2099}
2100impl std::convert::From<SurfaceSourceWaylandSurface> for SurfaceDescriptorExtension {
2101    fn from(ext: SurfaceSourceWaylandSurface) -> Self {
2102        SurfaceDescriptorExtension::SurfaceSourceWaylandSurface(ext)
2103    }
2104}
2105impl std::convert::From<SurfaceSourceWindowsHWND> for SurfaceDescriptorExtension {
2106    fn from(ext: SurfaceSourceWindowsHWND) -> Self {
2107        SurfaceDescriptorExtension::SurfaceSourceWindowsHWND(ext)
2108    }
2109}
2110impl std::convert::From<SurfaceSourceXlibWindow> for SurfaceDescriptorExtension {
2111    fn from(ext: SurfaceSourceXlibWindow) -> Self {
2112        SurfaceDescriptorExtension::SurfaceSourceXlibWindow(ext)
2113    }
2114}
2115impl SurfaceDescriptorExtension {
2116    pub(crate) fn push_chain(
2117        &self,
2118        storage: &mut ChainedStructStorage,
2119        next: *mut ffi::WGPUChainedStruct,
2120    ) -> *mut ffi::WGPUChainedStruct {
2121        match self {
2122            SurfaceDescriptorExtension::EmscriptenSurfaceSourceCanvasHTMLSelector(
2123                value,
2124            ) => {
2125                let (mut raw, storage_value) = value.to_ffi();
2126                raw.chain.sType = SType::EmscriptenSurfaceSourceCanvasHTMLSelector
2127                    as ffi::WGPUSType;
2128                raw.chain.next = next;
2129                storage.push_storage(storage_value);
2130                let raw_ptr = storage.push_value_mut(raw);
2131                raw_ptr.cast::<ffi::WGPUChainedStruct>()
2132            }
2133            SurfaceDescriptorExtension::SurfaceColorManagement(value) => {
2134                let (mut raw, storage_value) = value.to_ffi();
2135                raw.chain.sType = SType::SurfaceColorManagement as ffi::WGPUSType;
2136                raw.chain.next = next;
2137                storage.push_storage(storage_value);
2138                let raw_ptr = storage.push_value_mut(raw);
2139                raw_ptr.cast::<ffi::WGPUChainedStruct>()
2140            }
2141            SurfaceDescriptorExtension::SurfaceDescriptorFromWindowsUWPSwapChainPanel(
2142                value,
2143            ) => {
2144                let (mut raw, storage_value) = value.to_ffi();
2145                raw.chain.sType = SType::SurfaceDescriptorFromWindowsUWPSwapChainPanel
2146                    as ffi::WGPUSType;
2147                raw.chain.next = next;
2148                storage.push_storage(storage_value);
2149                let raw_ptr = storage.push_value_mut(raw);
2150                raw_ptr.cast::<ffi::WGPUChainedStruct>()
2151            }
2152            SurfaceDescriptorExtension::SurfaceDescriptorFromWindowsWinUISwapChainPanel(
2153                value,
2154            ) => {
2155                let (mut raw, storage_value) = value.to_ffi();
2156                raw.chain.sType = SType::SurfaceDescriptorFromWindowsWinUISwapChainPanel
2157                    as ffi::WGPUSType;
2158                raw.chain.next = next;
2159                storage.push_storage(storage_value);
2160                let raw_ptr = storage.push_value_mut(raw);
2161                raw_ptr.cast::<ffi::WGPUChainedStruct>()
2162            }
2163            SurfaceDescriptorExtension::SurfaceDescriptorFromWindowsCoreWindow(
2164                value,
2165            ) => {
2166                let (mut raw, storage_value) = value.to_ffi();
2167                raw.chain.sType = SType::SurfaceDescriptorFromWindowsCoreWindow
2168                    as ffi::WGPUSType;
2169                raw.chain.next = next;
2170                storage.push_storage(storage_value);
2171                let raw_ptr = storage.push_value_mut(raw);
2172                raw_ptr.cast::<ffi::WGPUChainedStruct>()
2173            }
2174            SurfaceDescriptorExtension::SurfaceSourceXCBWindow(value) => {
2175                let (mut raw, storage_value) = value.to_ffi();
2176                raw.chain.sType = SType::SurfaceSourceXCBWindow as ffi::WGPUSType;
2177                raw.chain.next = next;
2178                storage.push_storage(storage_value);
2179                let raw_ptr = storage.push_value_mut(raw);
2180                raw_ptr.cast::<ffi::WGPUChainedStruct>()
2181            }
2182            SurfaceDescriptorExtension::SurfaceSourceAndroidNativeWindow(value) => {
2183                let (mut raw, storage_value) = value.to_ffi();
2184                raw.chain.sType = SType::SurfaceSourceAndroidNativeWindow
2185                    as ffi::WGPUSType;
2186                raw.chain.next = next;
2187                storage.push_storage(storage_value);
2188                let raw_ptr = storage.push_value_mut(raw);
2189                raw_ptr.cast::<ffi::WGPUChainedStruct>()
2190            }
2191            SurfaceDescriptorExtension::SurfaceSourceMetalLayer(value) => {
2192                let (mut raw, storage_value) = value.to_ffi();
2193                raw.chain.sType = SType::SurfaceSourceMetalLayer as ffi::WGPUSType;
2194                raw.chain.next = next;
2195                storage.push_storage(storage_value);
2196                let raw_ptr = storage.push_value_mut(raw);
2197                raw_ptr.cast::<ffi::WGPUChainedStruct>()
2198            }
2199            SurfaceDescriptorExtension::SurfaceSourceWaylandSurface(value) => {
2200                let (mut raw, storage_value) = value.to_ffi();
2201                raw.chain.sType = SType::SurfaceSourceWaylandSurface as ffi::WGPUSType;
2202                raw.chain.next = next;
2203                storage.push_storage(storage_value);
2204                let raw_ptr = storage.push_value_mut(raw);
2205                raw_ptr.cast::<ffi::WGPUChainedStruct>()
2206            }
2207            SurfaceDescriptorExtension::SurfaceSourceWindowsHWND(value) => {
2208                let (mut raw, storage_value) = value.to_ffi();
2209                raw.chain.sType = SType::SurfaceSourceWindowsHWND as ffi::WGPUSType;
2210                raw.chain.next = next;
2211                storage.push_storage(storage_value);
2212                let raw_ptr = storage.push_value_mut(raw);
2213                raw_ptr.cast::<ffi::WGPUChainedStruct>()
2214            }
2215            SurfaceDescriptorExtension::SurfaceSourceXlibWindow(value) => {
2216                let (mut raw, storage_value) = value.to_ffi();
2217                raw.chain.sType = SType::SurfaceSourceXlibWindow as ffi::WGPUSType;
2218                raw.chain.next = next;
2219                storage.push_storage(storage_value);
2220                let raw_ptr = storage.push_value_mut(raw);
2221                raw_ptr.cast::<ffi::WGPUChainedStruct>()
2222            }
2223        }
2224    }
2225}
2226#[allow(dead_code)]
2227pub enum SurfaceTextureExtension {}
2228impl SurfaceTextureExtension {
2229    pub(crate) fn push_chain(
2230        &self,
2231        storage: &mut ChainedStructStorage,
2232        next: *mut ffi::WGPUChainedStruct,
2233    ) -> *mut ffi::WGPUChainedStruct {
2234        let _ = self;
2235        let _ = storage;
2236        next
2237    }
2238}
2239#[allow(dead_code)]
2240pub enum TexelBufferViewDescriptorExtension {}
2241impl TexelBufferViewDescriptorExtension {
2242    pub(crate) fn push_chain(
2243        &self,
2244        storage: &mut ChainedStructStorage,
2245        next: *mut ffi::WGPUChainedStruct,
2246    ) -> *mut ffi::WGPUChainedStruct {
2247        let _ = self;
2248        let _ = storage;
2249        next
2250    }
2251}
2252#[allow(dead_code)]
2253pub enum TextureBindingLayoutExtension {}
2254impl TextureBindingLayoutExtension {
2255    pub(crate) fn push_chain(
2256        &self,
2257        storage: &mut ChainedStructStorage,
2258        next: *mut ffi::WGPUChainedStruct,
2259    ) -> *mut ffi::WGPUChainedStruct {
2260        let _ = self;
2261        let _ = storage;
2262        next
2263    }
2264}
2265#[allow(dead_code)]
2266pub enum TextureDescriptorExtension {
2267    DawnTextureInternalUsageDescriptor(DawnTextureInternalUsageDescriptor),
2268    TextureBindingViewDimensionDescriptor(TextureBindingViewDimensionDescriptor),
2269}
2270impl std::convert::From<DawnTextureInternalUsageDescriptor>
2271for TextureDescriptorExtension {
2272    fn from(ext: DawnTextureInternalUsageDescriptor) -> Self {
2273        TextureDescriptorExtension::DawnTextureInternalUsageDescriptor(ext)
2274    }
2275}
2276impl std::convert::From<TextureBindingViewDimensionDescriptor>
2277for TextureDescriptorExtension {
2278    fn from(ext: TextureBindingViewDimensionDescriptor) -> Self {
2279        TextureDescriptorExtension::TextureBindingViewDimensionDescriptor(ext)
2280    }
2281}
2282impl TextureDescriptorExtension {
2283    pub(crate) fn push_chain(
2284        &self,
2285        storage: &mut ChainedStructStorage,
2286        next: *mut ffi::WGPUChainedStruct,
2287    ) -> *mut ffi::WGPUChainedStruct {
2288        match self {
2289            TextureDescriptorExtension::DawnTextureInternalUsageDescriptor(value) => {
2290                let (mut raw, storage_value) = value.to_ffi();
2291                raw.chain.sType = SType::DawnTextureInternalUsageDescriptor
2292                    as ffi::WGPUSType;
2293                raw.chain.next = next;
2294                storage.push_storage(storage_value);
2295                let raw_ptr = storage.push_value_mut(raw);
2296                raw_ptr.cast::<ffi::WGPUChainedStruct>()
2297            }
2298            TextureDescriptorExtension::TextureBindingViewDimensionDescriptor(value) => {
2299                let (mut raw, storage_value) = value.to_ffi();
2300                raw.chain.sType = SType::TextureBindingViewDimensionDescriptor
2301                    as ffi::WGPUSType;
2302                raw.chain.next = next;
2303                storage.push_storage(storage_value);
2304                let raw_ptr = storage.push_value_mut(raw);
2305                raw_ptr.cast::<ffi::WGPUChainedStruct>()
2306            }
2307        }
2308    }
2309}
2310#[allow(dead_code)]
2311pub enum TextureViewDescriptorExtension {
2312    TextureComponentSwizzleDescriptor(TextureComponentSwizzleDescriptor),
2313    YCbCrVkDescriptor(YCbCrVkDescriptor),
2314}
2315impl std::convert::From<TextureComponentSwizzleDescriptor>
2316for TextureViewDescriptorExtension {
2317    fn from(ext: TextureComponentSwizzleDescriptor) -> Self {
2318        TextureViewDescriptorExtension::TextureComponentSwizzleDescriptor(ext)
2319    }
2320}
2321impl std::convert::From<YCbCrVkDescriptor> for TextureViewDescriptorExtension {
2322    fn from(ext: YCbCrVkDescriptor) -> Self {
2323        TextureViewDescriptorExtension::YCbCrVkDescriptor(ext)
2324    }
2325}
2326impl TextureViewDescriptorExtension {
2327    pub(crate) fn push_chain(
2328        &self,
2329        storage: &mut ChainedStructStorage,
2330        next: *mut ffi::WGPUChainedStruct,
2331    ) -> *mut ffi::WGPUChainedStruct {
2332        match self {
2333            TextureViewDescriptorExtension::TextureComponentSwizzleDescriptor(value) => {
2334                let (mut raw, storage_value) = value.to_ffi();
2335                raw.chain.sType = SType::TextureComponentSwizzleDescriptor
2336                    as ffi::WGPUSType;
2337                raw.chain.next = next;
2338                storage.push_storage(storage_value);
2339                let raw_ptr = storage.push_value_mut(raw);
2340                raw_ptr.cast::<ffi::WGPUChainedStruct>()
2341            }
2342            TextureViewDescriptorExtension::YCbCrVkDescriptor(value) => {
2343                let (mut raw, storage_value) = value.to_ffi();
2344                raw.chain.sType = SType::YCbCrVkDescriptor as ffi::WGPUSType;
2345                raw.chain.next = next;
2346                storage.push_storage(storage_value);
2347                let raw_ptr = storage.push_value_mut(raw);
2348                raw_ptr.cast::<ffi::WGPUChainedStruct>()
2349            }
2350        }
2351    }
2352}
2353#[allow(dead_code)]
2354pub enum VertexAttributeExtension {}
2355impl VertexAttributeExtension {
2356    pub(crate) fn push_chain(
2357        &self,
2358        storage: &mut ChainedStructStorage,
2359        next: *mut ffi::WGPUChainedStruct,
2360    ) -> *mut ffi::WGPUChainedStruct {
2361        let _ = self;
2362        let _ = storage;
2363        next
2364    }
2365}
2366#[allow(dead_code)]
2367pub enum VertexBufferLayoutExtension {}
2368impl VertexBufferLayoutExtension {
2369    pub(crate) fn push_chain(
2370        &self,
2371        storage: &mut ChainedStructStorage,
2372        next: *mut ffi::WGPUChainedStruct,
2373    ) -> *mut ffi::WGPUChainedStruct {
2374        let _ = self;
2375        let _ = storage;
2376        next
2377    }
2378}
2379#[allow(dead_code)]
2380pub enum VertexStateExtension {}
2381impl VertexStateExtension {
2382    pub(crate) fn push_chain(
2383        &self,
2384        storage: &mut ChainedStructStorage,
2385        next: *mut ffi::WGPUChainedStruct,
2386    ) -> *mut ffi::WGPUChainedStruct {
2387        let _ = self;
2388        let _ = storage;
2389        next
2390    }
2391}
dawn_rs/generated/extensions.rs

dawn_rs/generated/
extensions.rs
