rafx-plugins 0.0.16

Rendering framework built on an extensible asset pipeline
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

use glam::f32::Vec3;
use glam::Quat;
use rafx::framework::visibility::VisibilityObjectArc;
use rafx::render_features::RenderObjectHandle;
use rafx::visibility::ViewFrustumArc;

#[derive(Clone)]
pub struct SpriteComponent {
    pub render_object_handle: RenderObjectHandle,
}

#[derive(Clone)]
pub struct MeshComponent {
    pub render_object_handle: RenderObjectHandle,
}

#[derive(Clone)]
pub struct VisibilityComponent {
    pub visibility_object_handle: VisibilityObjectArc,
}

#[derive(Clone, Copy)]
pub struct TransformComponent {
    pub translation: Vec3,
    pub rotation: Quat,
    pub scale: Vec3,
}

impl Default for TransformComponent {
    fn default() -> Self {
        Self {
            translation: Vec3::ZERO,
            rotation: Quat::IDENTITY,
            scale: Vec3::ONE,
        }
    }
}

impl TransformComponent {
    pub fn rotate(
        &mut self,
        rotation: Quat,
    ) {
        self.rotation *= rotation;
    }

    pub fn mul_transform(
        &self,
        transform: TransformComponent,
    ) -> Self {
        let translation = self.mul_vec3(transform.translation);
        let rotation = self.rotation * transform.rotation;
        let scale = self.scale * transform.scale;
        TransformComponent {
            translation,
            rotation,
            scale,
        }
    }

    pub fn mul_vec3(
        &self,
        mut value: Vec3,
    ) -> Vec3 {
        value = self.rotation * value;
        value = self.scale * value;
        value += self.translation;
        value
    }
}

const LIGHT_MIN_INTENSITY_TO_RENDER: f32 = 0.2;

#[derive(Clone)]
pub struct PointLightComponent {
    pub color: glam::Vec4,
    pub range: Option<f32>,
    pub intensity: f32,
    pub shadow_view_frustums: Option<[ViewFrustumArc; 6]>,
}

impl PointLightComponent {
    pub fn range_sq_from_intensity(intensity: f32) -> f32 {
        intensity / LIGHT_MIN_INTENSITY_TO_RENDER
    }

    pub fn range(&self) -> f32 {
        if let Some(range) = self.range {
            range
        } else {
            Self::range_sq_from_intensity(self.intensity).sqrt()
        }
    }

    pub fn range_sq(&self) -> f32 {
        if let Some(range) = self.range {
            range * range
        } else {
            Self::range_sq_from_intensity(self.intensity)
        }
    }
}

#[derive(Clone)]
pub struct DirectionalLightComponent {
    pub direction: glam::Vec3,
    pub color: glam::Vec4,
    pub intensity: f32,
    pub shadow_view_frustum: Option<ViewFrustumArc>,
}

#[derive(Clone)]
pub struct SpotLightComponent {
    pub direction: glam::Vec3,
    pub color: glam::Vec4,
    pub spotlight_half_angle: f32,
    pub range: Option<f32>,
    pub intensity: f32,
    pub shadow_view_frustum: Option<ViewFrustumArc>,
}

impl SpotLightComponent {
    pub fn range_sq_from_intensity(intensity: f32) -> f32 {
        intensity / LIGHT_MIN_INTENSITY_TO_RENDER
    }

    pub fn range(&self) -> f32 {
        if let Some(range) = self.range {
            range
        } else {
            Self::range_sq_from_intensity(self.intensity).sqrt()
        }
    }

    pub fn range_sq(&self) -> f32 {
        if let Some(range) = self.range {
            range * range
        } else {
            Self::range_sq_from_intensity(self.intensity)
        }
    }
}