graphene/auto/
quaternion.rs1use crate::{ffi, Matrix, Vec3, Vec4};
6use glib::translate::*;
7
8glib::wrapper! {
9 pub struct Quaternion(BoxedInline<ffi::graphene_quaternion_t>);
10
11 match fn {
12 copy => |ptr| glib::gobject_ffi::g_boxed_copy(ffi::graphene_quaternion_get_type(), ptr as *mut _) as *mut ffi::graphene_quaternion_t,
13 free => |ptr| glib::gobject_ffi::g_boxed_free(ffi::graphene_quaternion_get_type(), ptr as *mut _),
14 type_ => || ffi::graphene_quaternion_get_type(),
15 }
16}
17
18impl Quaternion {
19 #[doc(alias = "graphene_quaternion_add")]
20 #[must_use]
21 pub fn add(&self, b: &Quaternion) -> Quaternion {
22 unsafe {
23 let mut res = Quaternion::uninitialized();
24 ffi::graphene_quaternion_add(
25 self.to_glib_none().0,
26 b.to_glib_none().0,
27 res.to_glib_none_mut().0,
28 );
29 res
30 }
31 }
32
33 #[doc(alias = "graphene_quaternion_dot")]
34 pub fn dot(&self, b: &Quaternion) -> f32 {
35 unsafe { ffi::graphene_quaternion_dot(self.to_glib_none().0, b.to_glib_none().0) }
36 }
37
38 #[doc(alias = "graphene_quaternion_equal")]
39 fn equal(&self, b: &Quaternion) -> bool {
40 unsafe { ffi::graphene_quaternion_equal(self.to_glib_none().0, b.to_glib_none().0) }
41 }
42
43 #[doc(alias = "graphene_quaternion_invert")]
44 #[must_use]
45 pub fn invert(&self) -> Quaternion {
46 unsafe {
47 let mut res = Quaternion::uninitialized();
48 ffi::graphene_quaternion_invert(self.to_glib_none().0, res.to_glib_none_mut().0);
49 res
50 }
51 }
52
53 #[doc(alias = "graphene_quaternion_multiply")]
54 #[must_use]
55 pub fn multiply(&self, b: &Quaternion) -> Quaternion {
56 unsafe {
57 let mut res = Quaternion::uninitialized();
58 ffi::graphene_quaternion_multiply(
59 self.to_glib_none().0,
60 b.to_glib_none().0,
61 res.to_glib_none_mut().0,
62 );
63 res
64 }
65 }
66
67 #[doc(alias = "graphene_quaternion_normalize")]
68 #[must_use]
69 pub fn normalize(&self) -> Quaternion {
70 unsafe {
71 let mut res = Quaternion::uninitialized();
72 ffi::graphene_quaternion_normalize(self.to_glib_none().0, res.to_glib_none_mut().0);
73 res
74 }
75 }
76
77 #[doc(alias = "graphene_quaternion_scale")]
78 #[must_use]
79 pub fn scale(&self, factor: f32) -> Quaternion {
80 unsafe {
81 let mut res = Quaternion::uninitialized();
82 ffi::graphene_quaternion_scale(self.to_glib_none().0, factor, res.to_glib_none_mut().0);
83 res
84 }
85 }
86
87 #[doc(alias = "graphene_quaternion_slerp")]
88 #[must_use]
89 pub fn slerp(&self, b: &Quaternion, factor: f32) -> Quaternion {
90 unsafe {
91 let mut res = Quaternion::uninitialized();
92 ffi::graphene_quaternion_slerp(
93 self.to_glib_none().0,
94 b.to_glib_none().0,
95 factor,
96 res.to_glib_none_mut().0,
97 );
98 res
99 }
100 }
101
102 #[doc(alias = "graphene_quaternion_to_angle_vec3")]
103 pub fn to_angle_vec3(&self) -> (f32, Vec3) {
104 unsafe {
105 let mut angle = std::mem::MaybeUninit::uninit();
106 let mut axis = Vec3::uninitialized();
107 ffi::graphene_quaternion_to_angle_vec3(
108 self.to_glib_none().0,
109 angle.as_mut_ptr(),
110 axis.to_glib_none_mut().0,
111 );
112 (angle.assume_init(), axis)
113 }
114 }
115
116 #[doc(alias = "graphene_quaternion_to_angles")]
117 pub fn to_angles(&self) -> (f32, f32, f32) {
118 unsafe {
119 let mut deg_x = std::mem::MaybeUninit::uninit();
120 let mut deg_y = std::mem::MaybeUninit::uninit();
121 let mut deg_z = std::mem::MaybeUninit::uninit();
122 ffi::graphene_quaternion_to_angles(
123 self.to_glib_none().0,
124 deg_x.as_mut_ptr(),
125 deg_y.as_mut_ptr(),
126 deg_z.as_mut_ptr(),
127 );
128 (
129 deg_x.assume_init(),
130 deg_y.assume_init(),
131 deg_z.assume_init(),
132 )
133 }
134 }
135
136 #[doc(alias = "graphene_quaternion_to_matrix")]
137 pub fn to_matrix(&self) -> Matrix {
138 unsafe {
139 let mut m = Matrix::uninitialized();
140 ffi::graphene_quaternion_to_matrix(self.to_glib_none().0, m.to_glib_none_mut().0);
141 m
142 }
143 }
144
145 #[doc(alias = "graphene_quaternion_to_radians")]
146 pub fn to_radians(&self) -> (f32, f32, f32) {
147 unsafe {
148 let mut rad_x = std::mem::MaybeUninit::uninit();
149 let mut rad_y = std::mem::MaybeUninit::uninit();
150 let mut rad_z = std::mem::MaybeUninit::uninit();
151 ffi::graphene_quaternion_to_radians(
152 self.to_glib_none().0,
153 rad_x.as_mut_ptr(),
154 rad_y.as_mut_ptr(),
155 rad_z.as_mut_ptr(),
156 );
157 (
158 rad_x.assume_init(),
159 rad_y.assume_init(),
160 rad_z.assume_init(),
161 )
162 }
163 }
164
165 #[doc(alias = "graphene_quaternion_to_vec4")]
166 pub fn to_vec4(&self) -> Vec4 {
167 unsafe {
168 let mut res = Vec4::uninitialized();
169 ffi::graphene_quaternion_to_vec4(self.to_glib_none().0, res.to_glib_none_mut().0);
170 res
171 }
172 }
173}
174
175impl PartialEq for Quaternion {
176 #[inline]
177 fn eq(&self, other: &Self) -> bool {
178 self.equal(other)
179 }
180}
181
182impl Eq for Quaternion {}