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

use crate::renderer::*;

///
/// Three arrows indicating the three main axes; the x-axis (red), the y-axis (green) and the z-axis (blue).
/// Used for easily debugging where objects are placed in the 3D world.
///
pub struct Axes {
    model: std::cell::RefCell<Model<ColorMaterial>>,
    aabb_local: AxisAlignedBoundingBox,
    aabb: AxisAlignedBoundingBox,
    transformation: Mat4,
}

impl Axes {
    ///
    /// Creates a new axes object consisting of three arrows with the given radius and length.
    ///
    pub fn new(context: &Context, radius: f32, length: f32) -> ThreeDResult<Self> {
        let mut mesh = CpuMesh::arrow(0.9, 0.6, 16);
        mesh.transform(&Mat4::from_nonuniform_scale(length, radius, radius))?;
        let model = Model::new(context, &mesh)?;
        let mut aabb = model.aabb();
        let mut aabb2 = aabb.clone();
        aabb2.transform(&Mat4::from_angle_z(degrees(90.0)));
        aabb.expand_with_aabb(&aabb2);
        let mut aabb3 = aabb.clone();
        aabb3.transform(&Mat4::from_angle_y(degrees(-90.0)));
        aabb.expand_with_aabb(&aabb3);
        Ok(Self {
            model: std::cell::RefCell::new(model),
            aabb: aabb.clone(),
            aabb_local: aabb,
            transformation: Mat4::identity(),
        })
    }

    ///
    /// Returns the local to world transformation applied to the axes.
    ///
    pub fn transformation(&self) -> Mat4 {
        self.transformation
    }

    ///
    /// Set the local to world transformation applied to the axes.
    /// Can be used to visualize a local coordinate system.
    ///
    pub fn set_transformation(&mut self, transformation: Mat4) {
        self.transformation = transformation;
        let mut aabb = self.aabb_local.clone();
        aabb.transform(&self.transformation);
        self.aabb = aabb;
    }
}

impl Geometry for Axes {
    fn aabb(&self) -> AxisAlignedBoundingBox {
        self.aabb
    }

    fn render_with_material(
        &self,
        material: &dyn Material,
        camera: &Camera,
        lights: &[&dyn Light],
    ) -> ThreeDResult<()> {
        self.model
            .borrow_mut()
            .set_transformation(self.transformation);
        self.model
            .borrow()
            .render_with_material(&material, camera, lights)?;
        self.model
            .borrow_mut()
            .set_transformation(self.transformation * Mat4::from_angle_z(degrees(90.0)));
        self.model
            .borrow()
            .render_with_material(&material, camera, lights)?;
        self.model
            .borrow_mut()
            .set_transformation(self.transformation * Mat4::from_angle_y(degrees(-90.0)));
        self.model
            .borrow()
            .render_with_material(material, camera, lights)
    }
}

impl Object for Axes {
    fn render(&self, camera: &Camera, _lights: &[&dyn Light]) -> ThreeDResult<()> {
        self.model
            .borrow_mut()
            .set_transformation(self.transformation);
        self.model.borrow().render_with_material(
            &ColorMaterial {
                color: Color::RED,
                ..Default::default()
            },
            camera,
            &[],
        )?;
        self.model
            .borrow_mut()
            .set_transformation(self.transformation * Mat4::from_angle_z(degrees(90.0)));
        self.model.borrow().render_with_material(
            &ColorMaterial {
                color: Color::GREEN,
                ..Default::default()
            },
            camera,
            &[],
        )?;
        self.model
            .borrow_mut()
            .set_transformation(self.transformation * Mat4::from_angle_y(degrees(-90.0)));
        self.model.borrow().render_with_material(
            &ColorMaterial {
                color: Color::BLUE,
                ..Default::default()
            },
            camera,
            &[],
        )?;
        Ok(())
    }

    fn is_transparent(&self) -> bool {
        false
    }
}