Skip to main content

goud_engine/ecs/components/global_transform2d/
impls.rs

1//! Trait implementations for [`GlobalTransform2D`]: Default, Debug, From, Mul, Component.
2
3use crate::ecs::components::transform2d::{Mat3x3, Transform2D};
4use crate::ecs::Component;
5use std::fmt;
6
7use super::types::GlobalTransform2D;
8
9impl Default for GlobalTransform2D {
10    #[inline]
11    fn default() -> Self {
12        Self::IDENTITY
13    }
14}
15
16impl fmt::Debug for GlobalTransform2D {
17    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
18        let (t, r, s) = self.decompose();
19        f.debug_struct("GlobalTransform2D")
20            .field("translation", &(t.x, t.y))
21            .field("rotation", &format!("{:.3} rad", r))
22            .field("scale", &(s.x, s.y))
23            .finish()
24    }
25}
26
27impl From<Transform2D> for GlobalTransform2D {
28    /// Converts a local Transform2D to a GlobalTransform2D.
29    ///
30    /// This is used for root entities where local == global.
31    #[inline]
32    fn from(transform: Transform2D) -> Self {
33        GlobalTransform2D {
34            matrix: transform.matrix(),
35        }
36    }
37}
38
39impl From<&Transform2D> for GlobalTransform2D {
40    #[inline]
41    fn from(transform: &Transform2D) -> Self {
42        GlobalTransform2D {
43            matrix: transform.matrix(),
44        }
45    }
46}
47
48impl From<Mat3x3> for GlobalTransform2D {
49    #[inline]
50    fn from(matrix: Mat3x3) -> Self {
51        GlobalTransform2D { matrix }
52    }
53}
54
55// Implement Component trait
56impl Component for GlobalTransform2D {}
57
58// Implement multiplication operators
59impl std::ops::Mul for GlobalTransform2D {
60    type Output = GlobalTransform2D;
61
62    #[inline]
63    fn mul(self, rhs: GlobalTransform2D) -> GlobalTransform2D {
64        self.mul_transform(&rhs)
65    }
66}
67
68impl std::ops::Mul<&GlobalTransform2D> for GlobalTransform2D {
69    type Output = GlobalTransform2D;
70
71    #[inline]
72    fn mul(self, rhs: &GlobalTransform2D) -> GlobalTransform2D {
73        self.mul_transform(rhs)
74    }
75}
76
77impl std::ops::Mul<Transform2D> for GlobalTransform2D {
78    type Output = GlobalTransform2D;
79
80    #[inline]
81    fn mul(self, rhs: Transform2D) -> GlobalTransform2D {
82        self.transform_by(&rhs)
83    }
84}
85
86impl std::ops::Mul<&Transform2D> for GlobalTransform2D {
87    type Output = GlobalTransform2D;
88
89    #[inline]
90    fn mul(self, rhs: &Transform2D) -> GlobalTransform2D {
91        self.transform_by(rhs)
92    }
93}