glam_det 2.0.0

// Copyright (C) 2020-2025 glam-det authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// Generated from quat.rs.tera template. Edit the template, not the generated file.

use crate::f32::simd_alias::{Mat4, UnitQuat, Vec4};
use crate::{
    euler::EulerRot::{self, *},
    neon, DQuat, Mat3, UnitVec2, UnitVec3, Vec3,
};

use crate::nums::*;

use core::arch::aarch64::*;

use auto_ops_det::{impl_op_ex, impl_op_ex_commutative};
#[cfg(not(target_arch = "spirv"))]
use core::fmt;
use core::iter::Sum;
use core::ops::{self, Deref, DerefMut, Neg};

union UnionCast {
    a: [f32; 4],
    v: Quat,
}

/// Creates a quaternion from `x`, `y`, `z` and `w` values.
#[inline]
pub const fn quat(x: f32, y: f32, z: f32, w: f32) -> Quat {
    Quat::from_xyzw(x, y, z, w)
}

/// A quaternion.
///
/// This type is 16 byte aligned.
#[derive(Clone, Copy)]
#[repr(transparent)]
pub struct Quat(pub(crate) float32x4_t);

impl Quat {
    /// All zeros.
    const ZERO: Self = Self::from_array([0.0_f32; 4]);

    /// The identity quaternion. Corresponds to no rotation.
    pub const IDENTITY: Self = Self::from_xyzw(0.0_f32, 0.0_f32, 0.0_f32, 1.0_f32);

    /// All NANs.
    pub const NAN: Self = Self::from_array([f32::NAN; 4]);

    /// Creates a new quaternion.
    #[inline]
    pub const fn from_xyzw(x: f32, y: f32, z: f32, w: f32) -> Self {
        unsafe { UnionCast { a: [x, y, z, w] }.v }
    }

    /// Creates a quaternion from an array.
    #[inline]
    pub const fn from_array(a: [f32; 4]) -> Self {
        Self::from_xyzw(a[0], a[1], a[2], a[3])
    }

    /// Creates a new quaternion from a 4D vector.
    #[inline]
    pub fn from_vec4(v: Vec4) -> Self {
        Self(v.0)
    }

    /// Creates a quaternion from a slice.
    ///
    /// # Panics
    ///
    /// Panics if `slice` length is less than 4.
    #[inline]
    pub fn from_slice(slice: &[f32]) -> Self {
        Self::from_xyzw(slice[0], slice[1], slice[2], slice[3])
    }

    /// Writes the quaternion to an unaligned slice.
    ///
    /// # Panics
    ///
    /// Panics if `slice` length is less than 4.
    #[inline]
    pub fn write_to_slice(self, slice: &mut [f32]) {
        slice[0] = self.x;
        slice[1] = self.y;
        slice[2] = self.z;
        slice[3] = self.w;
    }

    /// Create a quaternion for a unit-length `axis` and `angle` (in radians).
    #[inline]
    pub fn from_axis_angle(axis: UnitVec3, angle: f32) -> Self {
        glam_assert!(angle.is_finite(), "angle {:?} is not finite.", angle);
        let (s, c) = (angle * 0.5_f32).sin_cosf();
        let v = axis * s;
        Self::from_xyzw(v.x, v.y, v.z, c)
    }

    /// Create a quaternion that rotates `v.length()` radians around `v.normalize()`.
    ///
    /// `from_scaled_axis(Vec3::ZERO)` results in the identity quaternion.
    #[inline]
    pub fn from_scaled_axis(v: Vec3) -> Self {
        let length = v.length();
        if length == 0.0_f32 {
            Self::IDENTITY
        } else {
            Self::from_axis_angle((v / length).as_unit_vec3_unchecked(), length)
        }
    }

    /// Creates a quaternion from the `angle` (in radians) around the x axis.
    #[inline]
    pub fn from_rotation_x(angle: f32) -> Self {
        glam_assert!(angle.is_finite(), "angle {:?} is not finite.", angle);
        let (s, c) = (angle * 0.5_f32).sin_cosf();
        Self::from_xyzw(s, 0.0_f32, 0.0_f32, c)
    }

    /// Creates a quaternion from the `angle` (in radians) around the y axis.
    #[inline]
    pub fn from_rotation_y(angle: f32) -> Self {
        glam_assert!(angle.is_finite(), "angle {:?} is not finite.", angle);
        let (s, c) = (angle * 0.5_f32).sin_cosf();
        Self::from_xyzw(0.0_f32, s, 0.0_f32, c)
    }

    /// Creates a quaternion from the `angle` (in radians) around the z axis.
    #[inline]
    pub fn from_rotation_z(angle: f32) -> Self {
        glam_assert!(angle.is_finite(), "angle {:?} is not finite.", angle);
        let (s, c) = (angle * 0.5_f32).sin_cosf();
        Self::from_xyzw(0.0_f32, 0.0_f32, s, c)
    }

    #[inline]
    /// Creates a quaternion from the given Euler rotation sequence and the angles (in radians).
    pub fn from_euler(euler: EulerRot, a: f32, b: f32, c: f32) -> Self {
        let (sa, ca) = (a * 0.5_f32).sin_cosf();
        let (sb, cb) = (b * 0.5_f32).sin_cosf();
        let (sc, cc) = (c * 0.5_f32).sin_cosf();
        match euler {
            ZYX => Self::from_xyzw(
                ca * cb * sc - cc * sa * sb,
                ca * cc * sb + cb * sa * sc,
                cb * cc * sa - ca * sb * sc,
                ca * cb * cc + sa * sb * sc,
            ),
            ZXY => Self::from_xyzw(
                ca * cc * sb - cb * sa * sc,
                cc * sa * sb + ca * cb * sc,
                cb * cc * sa + ca * sb * sc,
                ca * cb * cc - sa * sb * sc,
            ),
            YXZ => Self::from_xyzw(
                ca * cc * sb + cb * sa * sc,
                cb * cc * sa - ca * sb * sc,
                ca * cb * sc - cc * sa * sb,
                ca * cb * cc + sa * sb * sc,
            ),
            YZX => Self::from_xyzw(
                cc * sa * sb + ca * cb * sc,
                cb * cc * sa + ca * sb * sc,
                ca * cc * sb - cb * sa * sc,
                ca * cb * cc - sa * sb * sc,
            ),
            XYZ => Self::from_xyzw(
                cb * cc * sa + ca * sb * sc,
                ca * cc * sb - cb * sa * sc,
                cc * sa * sb + ca * cb * sc,
                ca * cb * cc - sa * sb * sc,
            ),
            XZY => Self::from_xyzw(
                cb * cc * sa - ca * sb * sc,
                ca * cb * sc - cc * sa * sb,
                ca * cc * sb + cb * sa * sc,
                ca * cb * cc + sa * sb * sc,
            ),
            ZYZ => Self::from_xyzw(
                ca * sb * sc - cc * sa * sb,
                ca * cc * sb + sa * sb * sc,
                cb * cc * sa + ca * cb * sc,
                ca * cb * cc - cb * sa * sc,
            ),
            ZXZ => Self::from_xyzw(
                ca * cc * sb + sa * sb * sc,
                cc * sa * sb - ca * sb * sc,
                cb * cc * sa + ca * cb * sc,
                ca * cb * cc - cb * sa * sc,
            ),
            YXY => Self::from_xyzw(
                ca * cc * sb + sa * sb * sc,
                cb * cc * sa + ca * cb * sc,
                ca * sb * sc - cc * sa * sb,
                ca * cb * cc - cb * sa * sc,
            ),
            YZY => Self::from_xyzw(
                cc * sa * sb - ca * sb * sc,
                cb * cc * sa + ca * cb * sc,
                ca * cc * sb + sa * sb * sc,
                ca * cb * cc - cb * sa * sc,
            ),
            XYX => Self::from_xyzw(
                cb * cc * sa + ca * cb * sc,
                ca * cc * sb + sa * sb * sc,
                cc * sa * sb - ca * sb * sc,
                ca * cb * cc - cb * sa * sc,
            ),
            XZX => Self::from_xyzw(
                cb * cc * sa + ca * cb * sc,
                ca * sb * sc - cc * sa * sb,
                ca * cc * sb + sa * sb * sc,
                ca * cb * cc - cb * sa * sc,
            ),
        }
        .normalize()
    }

    #[inline]
    /// Creates a unit quaternion from the given the angles (in radians).
    /// Default euler rotation sequence is `Z -> Y -> X` as roll (z-axis) -> yaw (y-axis) -> pitch (x-axis).
    /// First apply the z-axis rotation.
    pub fn from_euler_default(a: f32, b: f32, c: f32) -> Self {
        Self::from_euler(EulerRot::default(), a, b, c)
    }

    /// From the columns of a 3x3 rotation matrix.
    #[inline]
    pub(crate) fn from_rotation_axes(x_axis: Vec3, y_axis: Vec3, z_axis: Vec3) -> Self {
        // Based on https://github.com/microsoft/DirectXMath `XM$quaternionRotationMatrix`
        let (m00, m01, m02) = x_axis.into();
        let (m10, m11, m12) = y_axis.into();
        let (m20, m21, m22) = z_axis.into();
        if m22 <= 0.0 {
            // x^2 + y^2 >= z^2 + w^2
            let dif10 = m11 - m00;
            let omm22 = 1.0 - m22;
            if dif10 <= 0.0 {
                // x^2 >= y^2
                let four_xsq = omm22 - dif10;
                let inv4x = 0.5 * four_xsq.sqrtf().recip();
                Self::from_xyzw(
                    four_xsq * inv4x,
                    (m01 + m10) * inv4x,
                    (m02 + m20) * inv4x,
                    (m12 - m21) * inv4x,
                )
            } else {
                // y^2 >= x^2
                let four_ysq = omm22 + dif10;
                let inv4y = 0.5 * four_ysq.sqrtf().recip();
                Self::from_xyzw(
                    (m01 + m10) * inv4y,
                    four_ysq * inv4y,
                    (m12 + m21) * inv4y,
                    (m20 - m02) * inv4y,
                )
            }
        } else {
            // z^2 + w^2 >= x^2 + y^2
            let sum10 = m11 + m00;
            let opm22 = 1.0 + m22;
            if sum10 <= 0.0 {
                // z^2 >= w^2
                let four_zsq = opm22 - sum10;
                let inv4z = 0.5 * four_zsq.sqrtf().recip();
                Self::from_xyzw(
                    (m02 + m20) * inv4z,
                    (m12 + m21) * inv4z,
                    four_zsq * inv4z,
                    (m01 - m10) * inv4z,
                )
            } else {
                // w^2 >= z^2
                let four_wsq = opm22 + sum10;
                let inv4w = 0.5 * four_wsq.sqrtf().recip();
                Self::from_xyzw(
                    (m12 - m21) * inv4w,
                    (m20 - m02) * inv4w,
                    (m01 - m10) * inv4w,
                    four_wsq * inv4w,
                )
            }
        }
    }

    /// Creates a quaternion from a 3x3 rotation matrix.
    #[inline]
    pub fn from_mat3(mat: &Mat3) -> Self {
        Self::from_rotation_axes(mat.x_axis, mat.y_axis, mat.z_axis)
    }

    /// Creates a quaternion from a 3x3 rotation matrix inside a homogeneous 4x4 matrix.
    #[inline]
    pub fn from_mat4(mat: &Mat4) -> Self {
        Self::from_rotation_axes(
            mat.x_axis.truncate(),
            mat.y_axis.truncate(),
            mat.z_axis.truncate(),
        )
    }

    /// Creates a quaternion from a 3x3 rotation matrix inside a 3D affine transform.
    #[inline]
    pub fn from_affine3(a: &crate::Affine3A) -> Self {
        #[allow(clippy::useless_conversion)]
        Self::from_rotation_axes(
            a.matrix3.x_axis.into(),
            a.matrix3.y_axis.into(),
            a.matrix3.z_axis.into(),
        )
    }

    /// Gets the minimal rotation for transforming `from` to `to`.  The rotation is in the
    /// plane spanned by the two vectors.  Will rotate at most 180 degrees.
    pub fn from_rotation_arc(from: UnitVec3, to: UnitVec3) -> Self {
        const ONE_MINUS_EPS: f32 = 1.0_f32 - 2.0_f32 * f32::EPSILON;
        let dot = from.dot(to);
        if dot > ONE_MINUS_EPS {
            // 0° singulary: from ≈ to
            Self::IDENTITY
        } else if dot < -ONE_MINUS_EPS {
            // 180° singulary: from ≈ -to
            use core::f32::consts::PI; // half a turn = 𝛕/2 = 180°
            Self::from_axis_angle(from.any_orthogonal_vector(), PI)
        } else {
            let c = from.cross(to);
            Quat::from_xyzw(c.x, c.y, c.z, 1.0 + dot).normalize()
        }
    }

    /// Gets the minimal rotation for transforming `from` to either `to` or `-to`.  This means
    /// that the resulting quaternion will rotate `from` so that it is colinear with `to`.
    ///
    /// The rotation is in the plane spanned by the two vectors.  Will rotate at most 90
    /// degrees.
    #[inline]
    pub fn from_rotation_arc_colinear(from: UnitVec3, to: UnitVec3) -> Self {
        if from.dot(to) < 0.0_f32 {
            Self::from_rotation_arc(from, -to)
        } else {
            Self::from_rotation_arc(from, to)
        }
    }

    /// Gets the minimal rotation for transforming `from` to `to`.  The resulting rotation is
    /// around the z axis. Will rotate at most 180 degrees.
    pub fn from_rotation_arc_2d(from: UnitVec2, to: UnitVec2) -> Self {
        const ONE_MINUS_EPSILON: f32 = 1.0 - 2.0 * f32::EPSILON;
        let dot = from.dot(to);
        if dot > ONE_MINUS_EPSILON {
            // 0° singulary: from ≈ to
            Self::IDENTITY
        } else if dot < -ONE_MINUS_EPSILON {
            // 180° singulary: from ≈ -to
            const COS_FRAC_PI_2: f32 = 0.0;
            const SIN_FRAC_PI_2: f32 = 1.0;
            // rotation around z by PI radians
            Self::from_xyzw(0.0, 0.0, SIN_FRAC_PI_2, COS_FRAC_PI_2)
        } else {
            // vector3 cross where z=0
            let z = from.x * to.y - to.x * from.y;
            let w = 1.0 + dot;
            // calculate length with x=0 and y=0 to normalize
            let len_rcp = 1.0 / (z * z + w * w).sqrtf();
            Self::from_xyzw(0.0, 0.0, z * len_rcp, w * len_rcp)
        }
    }

    /// `[x, y, z, w]`
    #[inline]
    pub fn to_array(&self) -> [f32; 4] {
        [self.x, self.y, self.z, self.w]
    }

    /// Returns the vector part of the quaternion.
    #[inline]
    pub fn xyz(self) -> Vec3 {
        Vec3::new(self.x, self.y, self.z)
    }

    /// Returns the quaternion conjugate of `self`. For a unit quaternion the
    /// conjugate is also the inverse.
    #[must_use]
    #[inline]
    pub fn conjugate(self) -> Self {
        const SIGN: float32x4_t = neon::float32x4_from_f32x4([-1.0, -1.0, -1.0, 1.0]);
        Self(unsafe { vmulq_f32(self.0, SIGN) })
    }

    /// Computes the dot product of `self` and `rhs`.
    #[inline]
    pub fn dot(self, rhs: Self) -> f32 {
        Vec4::from(self).dot(Vec4::from(rhs))
    }

    /// Computes the length of `self`.
    #[doc(alias = "magnitude")]
    #[inline]
    pub fn length(self) -> f32 {
        Vec4::from(self).length()
    }

    /// Computes the squared length of `self`.
    ///
    /// This is generally faster than `length()` as it avoids a square
    /// root operation.
    #[doc(alias = "magnitude2")]
    #[inline]
    pub fn length_squared(self) -> f32 {
        Vec4::from(self).length_squared()
    }

    /// Computes `1.0 / length()`.
    ///
    /// For valid results, `self` must _not_ be of length zero.
    #[inline]
    pub fn length_recip(self) -> f32 {
        Vec4::from(self).length_recip()
    }

    /// Returns `self` normalized to length 1.0.
    ///
    /// For valid results, `self` must _not_ be of length zero or infinite.
    ///
    /// Panics
    ///
    /// Will panic if `self` is zero or infinite length when `glam_assert` is enabled.
    #[must_use]
    #[inline]
    pub fn normalize(self) -> Self {
        Self::from_vec4(Vec4::from(self).normalize())
    }

    /// Returns `self` normalized to a unit quaternion.
    ///
    /// For valid results, `self` must _not_ be of length zero or infinite.
    ///
    /// Panics
    ///
    /// Will panic if `self` is zero or infinite length when `glam_assert` is enabled.
    #[must_use]
    #[inline]
    pub fn normalize_to_unit(self) -> UnitQuat {
        self.normalize().as_unit_quat_unchecked()
    }

    /// Returns `true` if, and only if, all elements are finite.
    /// If any element is either `NaN`, positive or negative infinity, this will return `false`.
    #[inline]
    pub fn is_finite(self) -> bool {
        Vec4::from(self).is_finite()
    }

    #[inline]
    pub fn is_nan(self) -> bool {
        Vec4::from(self).is_nan()
    }

    /// Returns whether `self` of length `1.0` or not.
    ///
    /// Uses a precision threshold of `1e-6`.
    #[inline]
    pub fn is_normalized(self) -> bool {
        Vec4::from(self).is_normalized()
    }

    /// Returns true if the absolute difference of all elements between `self` and `rhs`
    /// is less than or equal to `max_abs_diff`.
    ///
    /// This can be used to compare if two quaternions contain similar elements. It works
    /// best when comparing with a known value. The `max_abs_diff` that should be used used
    /// depends on the values being compared against.
    ///
    /// For more see
    /// [comparing floating point numbers](https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/).
    #[inline]
    pub fn abs_diff_eq(self, rhs: Self, max_abs_diff: f32) -> bool {
        Vec4::from(self).abs_diff_eq(Vec4::from(rhs), max_abs_diff)
    }

    /// Multiplies two quaternions. If they each represent a rotation, the result will
    /// represent the combined rotation.
    ///
    /// Note that due to floating point rounding the result may not be perfectly normalized.
    #[inline]
    pub fn mul_quat(self, rhs: Self) -> Self {
        unsafe {
            const CONTROL_WZYX: float32x4_t = neon::float32x4_from_f32x4([1., -1., 1., -1.]);
            const CONTROL_ZWXY: float32x4_t = neon::float32x4_from_f32x4([1., 1., -1., -1.]);
            const CONTROL_YXWZ: float32x4_t = neon::float32x4_from_f32x4([-1., 1., 1., -1.]);

            let q1 = rhs.0;
            let q2 = self.0;

            let q2l = vget_low_f32(q2);
            let q2h = vget_high_f32(q2);

            let q2x = vdupq_lane_f32(q2l, 0);
            let q2y = vdupq_lane_f32(q2l, 1);
            let q2z = vdupq_lane_f32(q2h, 0);
            let v_result = vmulq_lane_f32(q1, q2h, 1);

            // Mul by Q1WZYX
            let v_temp_0 = vrev64q_f32(q1);
            let v_temp_1 = vcombine_f32(vget_high_f32(v_temp_0), vget_low_f32(v_temp_0));
            let q2x = vmulq_f32(q2x, v_temp_1);
            let v_result = vmlaq_f32(v_result, q2x, CONTROL_WZYX);

            // Mul by Q1ZWXY
            let v_temp_2 = vrev64q_f32(v_temp_1);
            let q2y = vmulq_f32(q2y, v_temp_2);
            let v_result = vmlaq_f32(v_result, q2y, CONTROL_ZWXY);

            // Mul by Q1YXWZ
            let q2z = vmulq_f32(q2z, v_temp_0);
            Self(vmlaq_f32(v_result, q2z, CONTROL_YXWZ))
        }
    }

    #[inline]
    pub fn as_f64(self) -> DQuat {
        DQuat::from_xyzw(self.x as f64, self.y as f64, self.z as f64, self.w as f64)
    }
}

#[cfg(not(target_arch = "spirv"))]
impl fmt::Debug for Quat {
    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt.debug_tuple(stringify!(Quat))
            .field(&self.x)
            .field(&self.y)
            .field(&self.z)
            .field(&self.w)
            .finish()
    }
}

#[cfg(not(target_arch = "spirv"))]
impl fmt::Display for Quat {
    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(fmt, "[{}, {}, {}, {}]", self.x, self.y, self.z, self.w)
    }
}

impl_op_ex!(+ |a: &Quat, b: &Quat| -> Quat{
    Quat::from_vec4(Vec4::from(a) + Vec4::from(b))
});

impl_op_ex!(-|a: &Quat, b: &Quat| -> Quat { Quat::from_vec4(Vec4::from(a) - Vec4::from(b)) });

impl_op_ex!(+= |a: &mut Quat, b: &Quat| { *a = *a + b });
impl_op_ex!(-= |a: &mut Quat, b: &Quat| { *a = *a - b });

impl_op_ex_commutative!(*|a: &Quat, b: &f32| -> Quat { Quat::from_vec4(Vec4::from(a) * b) });

impl_op_ex!(/ |a: &Quat, b: &f32| -> Quat{
    Quat::from_vec4(Vec4::from(a) / b)
});

impl_op_ex!(*|a: &Quat, b: &Quat| -> Quat { a.mul_quat(*b) });

impl_op_ex!(*= |a: &mut Quat, b: &Quat| {
    *a = a.mul_quat(*b)
});

impl Neg for Quat {
    type Output = Self;
    #[inline]
    fn neg(self) -> Self {
        self * -1.0_f32
    }
}

impl Default for Quat {
    #[inline]
    fn default() -> Self {
        Self::IDENTITY
    }
}

impl PartialEq for Quat {
    #[inline]
    fn eq(&self, rhs: &Self) -> bool {
        Vec4::from(*self).eq(&Vec4::from(*rhs))
    }
}

#[cfg(not(target_arch = "spirv"))]
impl AsRef<[f32; 4]> for Quat {
    #[inline]
    fn as_ref(&self) -> &[f32; 4] {
        unsafe { &*(self as *const Self as *const [f32; 4]) }
    }
}

impl<'a> Sum<&'a Self> for Quat {
    fn sum<I>(iter: I) -> Self
    where
        I: Iterator<Item = &'a Self>,
    {
        iter.fold(Self::ZERO, |a, &b| a + b)
    }
}

impl From<Quat> for Vec4 {
    #[inline]
    fn from(q: Quat) -> Self {
        Self(q.0)
    }
}

impl From<Quat> for (f32, f32, f32, f32) {
    #[inline]
    fn from(q: Quat) -> Self {
        Vec4::from(q).into()
    }
}

impl From<Quat> for [f32; 4] {
    #[inline]
    fn from(q: Quat) -> Self {
        Vec4::from(q).into()
    }
}

impl From<&Quat> for Vec4 {
    #[inline]
    fn from(q: &Quat) -> Self {
        Self(q.0)
    }
}

impl From<&Quat> for (f32, f32, f32, f32) {
    #[inline]
    fn from(q: &Quat) -> Self {
        Vec4::from(q).into()
    }
}

impl From<&Quat> for [f32; 4] {
    #[inline]
    fn from(q: &Quat) -> Self {
        Vec4::from(q).into()
    }
}

impl From<Quat> for float32x4_t {
    #[inline]
    fn from(q: Quat) -> Self {
        q.0
    }
}

impl Deref for Quat {
    type Target = crate::deref::Vec4<f32>;
    #[inline]
    fn deref(&self) -> &Self::Target {
        unsafe { &*(self as *const Self).cast() }
    }
}

impl DerefMut for Quat {
    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        unsafe { &mut *(self as *mut Self).cast() }
    }
}