naga/compact/
types.rs

1use super::{HandleSet, ModuleMap};
2use crate::Handle;
3
4pub struct TypeTracer<'a> {
5    pub overrides: &'a crate::Arena<crate::Override>,
6    pub types_used: &'a mut HandleSet<crate::Type>,
7    pub expressions_used: &'a mut HandleSet<crate::Expression>,
8    pub overrides_used: &'a mut HandleSet<crate::Override>,
9}
10
11impl TypeTracer<'_> {
12    pub fn trace_type(&mut self, ty: &crate::Type) {
13        use crate::TypeInner as Ti;
14        match ty.inner {
15            // Types that do not contain handles.
16            Ti::Scalar { .. }
17            | Ti::Vector { .. }
18            | Ti::Matrix { .. }
19            | Ti::Atomic { .. }
20            | Ti::ValuePointer { .. }
21            | Ti::Image { .. }
22            | Ti::Sampler { .. }
23            | Ti::AccelerationStructure { .. }
24            | Ti::RayQuery { .. } => {}
25
26            // Types that do contain handles.
27            Ti::Array {
28                base,
29                size,
30                stride: _,
31            }
32            | Ti::BindingArray { base, size } => {
33                self.types_used.insert(base);
34                match size {
35                    crate::ArraySize::Pending(handle) => {
36                        self.overrides_used.insert(handle);
37                        let r#override = &self.overrides[handle];
38                        self.types_used.insert(r#override.ty);
39                        if let Some(expr) = r#override.init {
40                            self.expressions_used.insert(expr);
41                        }
42                    }
43                    crate::ArraySize::Constant(_) | crate::ArraySize::Dynamic => {}
44                }
45            }
46            Ti::Pointer { base, space: _ } => {
47                self.types_used.insert(base);
48            }
49            Ti::Struct {
50                ref members,
51                span: _,
52            } => {
53                self.types_used.insert_iter(members.iter().map(|m| m.ty));
54            }
55        }
56    }
57}
58
59impl ModuleMap {
60    pub fn adjust_type(&self, ty: &mut crate::Type) {
61        let adjust = |ty: &mut Handle<crate::Type>| self.types.adjust(ty);
62
63        use crate::TypeInner as Ti;
64        match ty.inner {
65            // Types that do not contain handles.
66            Ti::Scalar(_)
67            | Ti::Vector { .. }
68            | Ti::Matrix { .. }
69            | Ti::Atomic(_)
70            | Ti::ValuePointer { .. }
71            | Ti::Image { .. }
72            | Ti::Sampler { .. }
73            | Ti::AccelerationStructure { .. }
74            | Ti::RayQuery { .. } => {}
75
76            // Types that do contain handles.
77            Ti::Pointer {
78                ref mut base,
79                space: _,
80            } => adjust(base),
81            Ti::Array {
82                ref mut base,
83                ref mut size,
84                stride: _,
85            }
86            | Ti::BindingArray {
87                ref mut base,
88                ref mut size,
89            } => {
90                adjust(base);
91                match *size {
92                    crate::ArraySize::Pending(ref mut r#override) => {
93                        self.overrides.adjust(r#override);
94                    }
95                    crate::ArraySize::Constant(_) | crate::ArraySize::Dynamic => {}
96                }
97            }
98            Ti::Struct {
99                ref mut members,
100                span: _,
101            } => {
102                for member in members {
103                    self.types.adjust(&mut member.ty);
104                }
105            }
106        };
107    }
108}
naga/compact/types.rs

naga/compact/
types.rs
