rend3 0.3.0

Easy to use, customizable, efficient 3D renderer library built on wgpu.
Documentation 
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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

/// Determines if the renderer is using cpu-driven rendering, or faster gpu-driven
/// rendering.
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
pub enum RendererProfile {
    CpuDriven,
    GpuDriven,
}

impl RendererProfile {
    /// Turns a RendererMode into a [`ProfileData`] calling the appropriate
    /// initalization function.
    pub fn into_data<C, G>(self, cpu: impl FnOnce() -> C, gpu: impl FnOnce() -> G) -> ProfileData<C, G> {
        match self {
            Self::CpuDriven => ProfileData::Cpu(cpu()),
            Self::GpuDriven => ProfileData::Gpu(gpu()),
        }
    }
}

/// Stores two different types of data depending on the renderer mode.
#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum ProfileData<C, G> {
    Cpu(C),
    Gpu(G),
}
#[allow(dead_code)] // Even if these are unused, don't warn
impl<C, G> ProfileData<C, G> {
    pub fn profile(&self) -> RendererProfile {
        match self {
            Self::Cpu(_) => RendererProfile::CpuDriven,
            Self::Gpu(_) => RendererProfile::GpuDriven,
        }
    }

    pub fn into_cpu(self) -> C {
        match self {
            Self::Cpu(c) => c,
            Self::Gpu(_) => panic!("tried to extract cpu data in gpu mode"),
        }
    }

    pub fn as_cpu(&self) -> &C {
        match self {
            Self::Cpu(c) => c,
            Self::Gpu(_) => panic!("tried to extract cpu data in gpu mode"),
        }
    }

    pub fn as_cpu_mut(&mut self) -> &mut C {
        match self {
            Self::Cpu(c) => c,
            Self::Gpu(_) => panic!("tried to extract cpu data in gpu mode"),
        }
    }

    pub fn as_cpu_only_ref(&self) -> ProfileData<&C, ()> {
        match self {
            Self::Cpu(c) => ProfileData::Cpu(c),
            Self::Gpu(_) => ProfileData::Gpu(()),
        }
    }

    pub fn as_cpu_only_mut(&mut self) -> ProfileData<&mut C, ()> {
        match self {
            Self::Cpu(c) => ProfileData::Cpu(c),
            Self::Gpu(_) => ProfileData::Gpu(()),
        }
    }

    pub fn into_gpu(self) -> G {
        match self {
            Self::Gpu(g) => g,
            Self::Cpu(_) => panic!("tried to extract gpu data in cpu mode"),
        }
    }

    pub fn as_gpu(&self) -> &G {
        match self {
            Self::Gpu(g) => g,
            Self::Cpu(_) => panic!("tried to extract gpu data in cpu mode"),
        }
    }

    pub fn as_gpu_mut(&mut self) -> &mut G {
        match self {
            Self::Gpu(g) => g,
            Self::Cpu(_) => panic!("tried to extract gpu data in cpu mode"),
        }
    }

    pub fn as_gpu_only_ref(&self) -> ProfileData<(), &G> {
        match self {
            Self::Gpu(g) => ProfileData::Gpu(g),
            Self::Cpu(_) => ProfileData::Cpu(()),
        }
    }

    pub fn as_gpu_only_mut(&mut self) -> ProfileData<(), &mut G> {
        match self {
            Self::Gpu(g) => ProfileData::Gpu(g),
            Self::Cpu(_) => ProfileData::Cpu(()),
        }
    }

    pub fn as_ref(&self) -> ProfileData<&C, &G> {
        match self {
            Self::Cpu(c) => ProfileData::Cpu(c),
            Self::Gpu(c) => ProfileData::Gpu(c),
        }
    }

    pub fn as_ref_mut(&mut self) -> ProfileData<&mut C, &mut G> {
        match self {
            Self::Cpu(c) => ProfileData::Cpu(c),
            Self::Gpu(c) => ProfileData::Gpu(c),
        }
    }

    pub fn map_cpu<C2>(self, func: impl FnOnce(C) -> C2) -> ProfileData<C2, G> {
        match self {
            Self::Cpu(c) => ProfileData::Cpu(func(c)),
            Self::Gpu(g) => ProfileData::Gpu(g),
        }
    }

    pub fn map_gpu<G2>(self, func: impl FnOnce(G) -> G2) -> ProfileData<C, G2> {
        match self {
            Self::Cpu(c) => ProfileData::Cpu(c),
            Self::Gpu(g) => ProfileData::Gpu(func(g)),
        }
    }

    pub fn map<C2, G2>(self, cpu_func: impl FnOnce(C) -> C2, gpu_func: impl FnOnce(G) -> G2) -> ProfileData<C2, G2> {
        match self {
            Self::Cpu(c) => ProfileData::Cpu(cpu_func(c)),
            Self::Gpu(g) => ProfileData::Gpu(gpu_func(g)),
        }
    }
}

impl<T> ProfileData<T, T> {
    pub fn into_common(self) -> T {
        match self {
            Self::Cpu(c) => c,
            Self::Gpu(g) => g,
        }
    }
}