naga/compact/
types.rs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
use super::{HandleSet, ModuleMap};
use crate::Handle;

pub struct TypeTracer<'a> {
    pub overrides: &'a crate::Arena<crate::Override>,
    pub types_used: &'a mut HandleSet<crate::Type>,
    pub expressions_used: &'a mut HandleSet<crate::Expression>,
    pub overrides_used: &'a mut HandleSet<crate::Override>,
}

impl TypeTracer<'_> {
    pub fn trace_type(&mut self, ty: &crate::Type) {
        use crate::TypeInner as Ti;
        match ty.inner {
            // Types that do not contain handles.
            Ti::Scalar { .. }
            | Ti::Vector { .. }
            | Ti::Matrix { .. }
            | Ti::Atomic { .. }
            | Ti::ValuePointer { .. }
            | Ti::Image { .. }
            | Ti::Sampler { .. }
            | Ti::AccelerationStructure
            | Ti::RayQuery => {}

            // Types that do contain handles.
            Ti::Array {
                base,
                size,
                stride: _,
            }
            | Ti::BindingArray { base, size } => {
                self.types_used.insert(base);
                match size {
                    crate::ArraySize::Pending(pending) => match pending {
                        crate::PendingArraySize::Expression(expr) => {
                            self.expressions_used.insert(expr);
                        }
                        crate::PendingArraySize::Override(handle) => {
                            self.overrides_used.insert(handle);
                            let r#override = &self.overrides[handle];
                            self.types_used.insert(r#override.ty);
                            if let Some(expr) = r#override.init {
                                self.expressions_used.insert(expr);
                            }
                        }
                    },
                    crate::ArraySize::Constant(_) | crate::ArraySize::Dynamic => {}
                }
            }
            Ti::Pointer { base, space: _ } => {
                self.types_used.insert(base);
            }
            Ti::Struct {
                ref members,
                span: _,
            } => {
                self.types_used.insert_iter(members.iter().map(|m| m.ty));
            }
        }
    }
}

impl ModuleMap {
    pub fn adjust_type(&self, ty: &mut crate::Type) {
        let adjust = |ty: &mut Handle<crate::Type>| self.types.adjust(ty);

        use crate::TypeInner as Ti;
        match ty.inner {
            // Types that do not contain handles.
            Ti::Scalar(_)
            | Ti::Vector { .. }
            | Ti::Matrix { .. }
            | Ti::Atomic(_)
            | Ti::ValuePointer { .. }
            | Ti::Image { .. }
            | Ti::Sampler { .. }
            | Ti::AccelerationStructure
            | Ti::RayQuery => {}

            // Types that do contain handles.
            Ti::Pointer {
                ref mut base,
                space: _,
            } => adjust(base),
            Ti::Array {
                ref mut base,
                ref mut size,
                stride: _,
            }
            | Ti::BindingArray {
                ref mut base,
                ref mut size,
            } => {
                adjust(base);
                match *size {
                    crate::ArraySize::Pending(crate::PendingArraySize::Expression(
                        ref mut size_expr,
                    )) => {
                        self.global_expressions.adjust(size_expr);
                    }
                    crate::ArraySize::Pending(crate::PendingArraySize::Override(
                        ref mut r#override,
                    )) => {
                        self.overrides.adjust(r#override);
                    }
                    crate::ArraySize::Constant(_) | crate::ArraySize::Dynamic => {}
                }
            }
            Ti::Struct {
                ref mut members,
                span: _,
            } => {
                for member in members {
                    self.types.adjust(&mut member.ty);
                }
            }
        };
    }
}