Try #68:

Author: bors[bot]

godot-core/src/builtin/mod.rs

@@ -42,6 +42,7 @@ mod math;
 mod node_path;
 mod others;
 mod packed_array;
+mod quaternion;
 mod string;
 mod string_name;
 mod variant;
@@ -63,6 +64,7 @@ pub use math::*;
 pub use node_path::*;
 pub use others::*;
 pub use packed_array::*;
+pub use quaternion::*;
 pub use string::*;
 pub use string_name::*;
 pub use variant::*;

godot-core/src/builtin/others.rs

@@ -16,7 +16,6 @@ use sys::{ffi_methods, GodotFfi};
 impl_builtin_stub!(Rect2, OpaqueRect2);
 impl_builtin_stub!(Rect2i, OpaqueRect2i);
 impl_builtin_stub!(Plane, OpaquePlane);
-impl_builtin_stub!(Quaternion, OpaqueQuaternion);
 impl_builtin_stub!(Aabb, OpaqueAabb);
 impl_builtin_stub!(Basis, OpaqueBasis);
 impl_builtin_stub!(Transform2D, OpaqueTransform2D);

godot-core/src/builtin/quaternion.rs

@@ -0,0 +1,288 @@
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+use std::ops::*;
+
+use godot_ffi as sys;
+use sys::{ffi_methods, GodotFfi};
+
+use crate::builtin::{math::*, vector3::*};
+
+#[derive(Default, Copy, Clone, Debug, PartialEq)]
+#[repr(C)]
+pub struct Quaternion {
+    x: f32,
+    y: f32,
+    z: f32,
+    w: f32,
+}
+
+impl Quaternion {
+    pub fn new(x: f32, y: f32, z: f32, w: f32) -> Self {
+        Self { x, y, z, w }
+    }
+
+    pub fn from_angle_axis(axis: Vector3, angle: f32) -> Self {
+        let d = axis.length();
+        if d == 0.0 {
+            Self::new(0.0, 0.0, 0.0, 0.0)
+        } else {
+            let sin_angle = (angle * 0.5).sin();
+            let cos_angle = (angle * 0.5).cos();
+            let s = sin_angle / d;
+            let x = axis.x * s;
+            let y = axis.y * s;
+            let z = axis.z * s;
+            let w = cos_angle;
+            Self::new(x, y, z, w)
+        }
+    }
+
+    pub fn angle_to(self, to: Self) -> f32 {
+        self.to_glam().angle_between(to.to_glam())
+    }
+
+    pub fn dot(self, with: Self) -> f32 {
+        self.to_glam().dot(with.to_glam())
+    }
+
+    pub fn to_exp(self) -> Self {
+        let mut v = Vector3::new(self.x, self.y, self.z);
+        let theta = v.length();
+        v = v.normalized();
+        if theta < CMP_EPSILON || !v.is_normalized() {
+            return Self::new(0.0, 0.0, 0.0, 1.0);
+        }
+        Self::from_angle_axis(v, theta)
+    }
+
+    pub fn from_euler(self, euler: Vector3) -> Self {
+        let half_a1 = euler.y * 0.5;
+        let half_a2 = euler.x * 0.5;
+        let half_a3 = euler.z * 0.5;
+        let cos_a1 = half_a1.cos();
+        let sin_a1 = half_a1.sin();
+        let cos_a2 = half_a2.cos();
+        let sin_a2 = half_a2.sin();
+        let cos_a3 = half_a3.cos();
+        let sin_a3 = half_a3.sin();
+        Self::new(
+            sin_a1 * cos_a2 * sin_a3 + cos_a1 * sin_a2 * cos_a3,
+            sin_a1 * cos_a2 * cos_a3 - cos_a1 * sin_a2 * sin_a3,
+            -sin_a1 * sin_a2 * cos_a3 + cos_a1 * cos_a2 * sin_a3,
+            sin_a1 * sin_a2 * sin_a3 + cos_a1 * cos_a2 * cos_a3,
+        )
+    }
+
+    pub fn get_angle(self) -> f32 {
+        2.0 * self.w.acos()
+    }
+
+    pub fn get_axis(self) -> Vector3 {
+        if self.w.abs() > 1.0 - CMP_EPSILON {
+            return Vector3::new(self.x, self.y, self.z);
+        }
+        let r = 1.0 / (1.0 - self.w * self.w).sqrt();
+        Vector3::new(self.x * r, self.y * r, self.z * r)
+    }
+
+    pub fn inverse(self) -> Self {
+        Quaternion::new(-self.x, -self.y, -self.z, self.w)
+    }
+
+    pub fn is_equal_approx(self, to: Self) -> bool {
+        is_equal_approx(self.x, to.x)
+            && is_equal_approx(self.y, to.y)
+            && is_equal_approx(self.z, to.z)
+            && is_equal_approx(self.w, to.w)
+    }
+
+    pub fn is_finite(self) -> bool {
+        self.x.is_finite() && self.y.is_finite() && self.z.is_finite() && self.w.is_finite()
+    }
+
+    pub fn is_normalized(self) -> bool {
+        is_equal_approx(self.length_squared(), 1.0) /*,UNIT_EPSILON)*/
+    }
+
+    pub fn length(self) -> f32 {
+        self.length_squared().sqrt()
+    }
+
+    pub fn length_squared(self) -> f32 {
+        self.dot(self)
+    }
+
+    pub fn log(self) -> Self {
+        let v = self.get_axis() * self.get_angle();
+        Self::new(v.x, v.y, v.z, 0.0)
+    }
+
+    pub fn normalized(self) -> Self {
+        self / self.length()
+    }
+
+    pub fn slerp(self, to: Self, weight: f32) -> Self {
+        let mut cosom = self.dot(to);
+        let to1: Self;
+        let omega: f32;
+        let sinom: f32;
+        let scale0: f32;
+        let scale1: f32;
+        if cosom < 0.0 {
+            cosom = -cosom;
+            to1 = -to;
+        } else {
+            to1 = to;
+        }
+
+        if 1.0 - cosom > CMP_EPSILON {
+            omega = cosom.acos();
+            sinom = omega.sin();
+            scale0 = ((1.0 - weight) * omega).sin() / sinom;
+            scale1 = (weight * omega).sin() / sinom;
+        } else {
+            scale0 = 1.0 - weight;
+            scale1 = weight;
+        }
+        Self::new(
+            scale0 * self.x + scale1 * to1.x,
+            scale0 * self.y + scale1 * to1.y,
+            scale0 * self.z + scale1 * to1.z,
+            scale0 * self.w + scale1 * to1.w,
+        )
+    }
+
+    pub fn slerpni(self, to: Self, weight: f32) -> Self {
+        let dot = self.dot(to);
+        if dot.abs() > 0.9999 {
+            return self;
+        }
+        let theta = dot.acos();
+        let sin_t = 1.0 / theta.sin();
+        let new_factor = (weight * theta).sin() * sin_t;
+        let inv_factor = ((1.0 - weight) * theta).sin() * sin_t;
+        Self::new(
+            inv_factor * self.x + new_factor * to.x,
+            inv_factor * self.y + new_factor * to.y,
+            inv_factor * self.z + new_factor * to.z,
+            inv_factor * self.w + new_factor * to.w,
+        )
+    }
+
+    pub fn from_glam(quat: glam::Quat) -> Self {
+        Self::new(quat.x, quat.y, quat.z, quat.w)
+    }
+
+    pub fn to_glam(self) -> glam::Quat {
+        glam::Quat::from_xyzw(self.x, self.y, self.z, self.w)
+    }
+}
+
+impl Add for Quaternion {
+    type Output = Self;
+
+    fn add(self, other: Self) -> Self {
+        Self::new(
+            self.x + other.x,
+            self.y + other.y,
+            self.z + other.z,
+            self.w + other.w,
+        )
+    }
+}
+
+impl AddAssign for Quaternion {
+    fn add_assign(&mut self, other: Self) {
+        *self = *self + other
+    }
+}
+
+impl Sub for Quaternion {
+    type Output = Self;
+
+    fn sub(self, other: Self) -> Self {
+        Self::new(
+            self.x - other.x,
+            self.y - other.y,
+            self.z - other.z,
+            self.w - other.w,
+        )
+    }
+}
+
+impl SubAssign for Quaternion {
+    fn sub_assign(&mut self, other: Self) {
+        *self = *self - other
+    }
+}
+
+impl Mul<Quaternion> for Quaternion {
+    type Output = Self;
+
+    fn mul(self, other: Quaternion) -> Self {
+        let x = self.w * other.x + self.x * other.w + self.y * other.z - self.z * other.y;
+        let y = self.w * other.y + self.y * other.w + self.z * other.x - self.x * other.z;
+        let z = self.w * other.z + self.z * other.w + self.x * other.y - self.y * other.x;
+        let w = self.w * other.w - self.x * other.x - self.y * other.y - self.z * other.z;
+        Self::new(x, y, z, w)
+    }
+}
+
+impl MulAssign<Quaternion> for Quaternion {
+    fn mul_assign(&mut self, other: Quaternion) {
+        *self = *self * other
+    }
+}
+
+impl Mul<f32> for Quaternion {
+    type Output = Self;
+
+    fn mul(self, other: f32) -> Self {
+        Quaternion::new(
+            self.x * other,
+            self.y * other,
+            self.z * other,
+            self.w * other,
+        )
+    }
+}
+
+impl MulAssign<f32> for Quaternion {
+    fn mul_assign(&mut self, other: f32) {
+        *self = *self * other
+    }
+}
+
+impl Div<f32> for Quaternion {
+    type Output = Self;
+
+    fn div(self, other: f32) -> Self {
+        Self::new(
+            self.x / other,
+            self.y / other,
+            self.z / other,
+            self.w / other,
+        )
+    }
+}
+
+impl DivAssign<f32> for Quaternion {
+    fn div_assign(&mut self, other: f32) {
+        *self = *self / other
+    }
+}
+
+impl Neg for Quaternion {
+    type Output = Self;
+
+    fn neg(self) -> Self {
+        Self::new(-self.x, -self.y, -self.z, -self.w)
+    }
+}
+
+impl GodotFfi for Quaternion {
+    ffi_methods! { type sys::GDExtensionTypePtr = *mut Self; .. }
+}