graphene/
quaternion.rs

1// Take a look at the license at the top of the repository in the LICENSE file.
2
3use std::{fmt, ops};
4
5use glib::translate::*;
6
7use crate::{ffi, Euler, Matrix, Quaternion, Vec3, Vec4};
8
9impl Quaternion {
10    #[doc(alias = "graphene_quaternion_init")]
11    pub fn new(x: f32, y: f32, z: f32, w: f32) -> Self {
12        assert_initialized_main_thread!();
13        unsafe {
14            let mut quat = Self::uninitialized();
15            ffi::graphene_quaternion_init(quat.to_glib_none_mut().0, x, y, z, w);
16            quat
17        }
18    }
19
20    #[doc(alias = "graphene_quaternion_init_from_angle_vec3")]
21    #[doc(alias = "init_from_angle_vec3")]
22    pub fn from_angle_vec3(angle: f32, axis: &Vec3) -> Self {
23        assert_initialized_main_thread!();
24        unsafe {
25            let mut quat = Self::uninitialized();
26            ffi::graphene_quaternion_init_from_angle_vec3(
27                quat.to_glib_none_mut().0,
28                angle,
29                axis.to_glib_none().0,
30            );
31            quat
32        }
33    }
34
35    #[doc(alias = "graphene_quaternion_init_from_angles")]
36    #[doc(alias = "init_from_angles")]
37    pub fn from_angles(deg_x: f32, deg_y: f32, deg_z: f32) -> Self {
38        assert_initialized_main_thread!();
39        unsafe {
40            let mut quat = Self::uninitialized();
41            ffi::graphene_quaternion_init_from_angles(
42                quat.to_glib_none_mut().0,
43                deg_x,
44                deg_y,
45                deg_z,
46            );
47            quat
48        }
49    }
50
51    #[doc(alias = "graphene_quaternion_init_from_euler")]
52    #[doc(alias = "init_from_euler")]
53    pub fn from_euler(e: &Euler) -> Self {
54        assert_initialized_main_thread!();
55        unsafe {
56            let mut quat = Self::uninitialized();
57            ffi::graphene_quaternion_init_from_euler(quat.to_glib_none_mut().0, e.to_glib_none().0);
58            quat
59        }
60    }
61
62    #[doc(alias = "graphene_quaternion_init_from_matrix")]
63    #[doc(alias = "init_from_matrix")]
64    pub fn from_matrix(m: &Matrix) -> Self {
65        assert_initialized_main_thread!();
66        unsafe {
67            let mut quat = Self::uninitialized();
68            ffi::graphene_quaternion_init_from_matrix(
69                quat.to_glib_none_mut().0,
70                m.to_glib_none().0,
71            );
72            quat
73        }
74    }
75
76    #[doc(alias = "graphene_quaternion_init_from_radians")]
77    #[doc(alias = "init_from_radians")]
78    pub fn from_radians(rad_x: f32, rad_y: f32, rad_z: f32) -> Self {
79        assert_initialized_main_thread!();
80        unsafe {
81            let mut quat = Self::uninitialized();
82            ffi::graphene_quaternion_init_from_radians(
83                quat.to_glib_none_mut().0,
84                rad_x,
85                rad_y,
86                rad_z,
87            );
88            quat
89        }
90    }
91
92    #[doc(alias = "graphene_quaternion_init_from_vec4")]
93    #[doc(alias = "init_from_vec4")]
94    pub fn from_vec4(src: &Vec4) -> Self {
95        assert_initialized_main_thread!();
96        unsafe {
97            let mut quat = Self::uninitialized();
98            ffi::graphene_quaternion_init_from_vec4(
99                quat.to_glib_none_mut().0,
100                src.to_glib_none().0,
101            );
102            quat
103        }
104    }
105
106    #[doc(alias = "graphene_quaternion_init_identity")]
107    #[doc(alias = "init_identity")]
108    pub fn new_identity() -> Self {
109        assert_initialized_main_thread!();
110        unsafe {
111            let mut quat = Self::uninitialized();
112            ffi::graphene_quaternion_init_identity(quat.to_glib_none_mut().0);
113            quat
114        }
115    }
116
117    #[inline]
118    pub fn x(&self) -> f32 {
119        self.inner.x
120    }
121
122    #[inline]
123    pub fn y(&self) -> f32 {
124        self.inner.y
125    }
126
127    #[inline]
128    pub fn z(&self) -> f32 {
129        self.inner.z
130    }
131
132    #[inline]
133    pub fn w(&self) -> f32 {
134        self.inner.w
135    }
136}
137
138impl fmt::Debug for Quaternion {
139    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
140        f.debug_struct("Quaternion")
141            .field("x", &self.x())
142            .field("y", &self.y())
143            .field("z", &self.z())
144            .field("w", &self.w())
145            .finish()
146    }
147}
148
149impl ops::Add<Quaternion> for Quaternion {
150    type Output = Quaternion;
151
152    fn add(self, rhs: Quaternion) -> Self::Output {
153        Quaternion::add(&self, &rhs)
154    }
155}
156
157impl ops::AddAssign<Quaternion> for Quaternion {
158    fn add_assign(&mut self, rhs: Quaternion) {
159        *self = *self + rhs;
160    }
161}
162
163impl ops::Mul<Quaternion> for Quaternion {
164    type Output = Quaternion;
165
166    fn mul(self, rhs: Quaternion) -> Self::Output {
167        Quaternion::multiply(&self, &rhs)
168    }
169}
170
171impl ops::MulAssign<Quaternion> for Quaternion {
172    fn mul_assign(&mut self, rhs: Quaternion) {
173        *self = *self * rhs;
174    }
175}
graphene/quaternion.rs

graphene/
quaternion.rs
