graphene/auto/

euler.rs

// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT

use crate::{EulerOrder, Matrix, Quaternion, Vec3, ffi};
use glib::translate::*;

glib::wrapper! {
    /// Describe a rotation using Euler angles.
    ///
    /// The contents of the [`Euler`][crate::Euler] structure are private
    /// and should never be accessed directly.
    pub struct Euler(BoxedInline<ffi::graphene_euler_t>);

    match fn {
        copy => |ptr| glib::gobject_ffi::g_boxed_copy(ffi::graphene_euler_get_type(), ptr as *mut _) as *mut ffi::graphene_euler_t,
        free => |ptr| glib::gobject_ffi::g_boxed_free(ffi::graphene_euler_get_type(), ptr as *mut _),
        type_ => || ffi::graphene_euler_get_type(),
    }
}

impl Euler {
    #[doc(alias = "graphene_euler_equal")]
    fn equal(&self, b: &Euler) -> bool {
        unsafe { ffi::graphene_euler_equal(self.to_glib_none().0, b.to_glib_none().0) }
    }

    /// Retrieves the first component of the Euler angle vector,
    /// depending on the order of rotation.
    ///
    /// See also: [`x()`][Self::x()]
    ///
    /// # Returns
    ///
    /// the first component of the Euler angle vector, in radians
    #[doc(alias = "graphene_euler_get_alpha")]
    #[doc(alias = "get_alpha")]
    pub fn alpha(&self) -> f32 {
        unsafe { ffi::graphene_euler_get_alpha(self.to_glib_none().0) }
    }

    /// Retrieves the second component of the Euler angle vector,
    /// depending on the order of rotation.
    ///
    /// See also: [`y()`][Self::y()]
    ///
    /// # Returns
    ///
    /// the second component of the Euler angle vector, in radians
    #[doc(alias = "graphene_euler_get_beta")]
    #[doc(alias = "get_beta")]
    pub fn beta(&self) -> f32 {
        unsafe { ffi::graphene_euler_get_beta(self.to_glib_none().0) }
    }

    /// Retrieves the third component of the Euler angle vector,
    /// depending on the order of rotation.
    ///
    /// See also: [`z()`][Self::z()]
    ///
    /// # Returns
    ///
    /// the third component of the Euler angle vector, in radians
    #[doc(alias = "graphene_euler_get_gamma")]
    #[doc(alias = "get_gamma")]
    pub fn gamma(&self) -> f32 {
        unsafe { ffi::graphene_euler_get_gamma(self.to_glib_none().0) }
    }

    /// Retrieves the order used to apply the rotations described in the
    /// [`Euler`][crate::Euler] structure, when converting to and from other
    /// structures, like [`Quaternion`][crate::Quaternion] and [`Matrix`][crate::Matrix].
    ///
    /// This function does not return the [`EulerOrder::Default`][crate::EulerOrder::Default]
    /// enumeration value; it will return the effective order of rotation
    /// instead.
    ///
    /// # Returns
    ///
    /// the order used to apply the rotations
    #[doc(alias = "graphene_euler_get_order")]
    #[doc(alias = "get_order")]
    pub fn order(&self) -> EulerOrder {
        unsafe { from_glib(ffi::graphene_euler_get_order(self.to_glib_none().0)) }
    }

    /// Retrieves the rotation angle on the X axis, in degrees.
    ///
    /// # Returns
    ///
    /// the rotation angle
    #[doc(alias = "graphene_euler_get_x")]
    #[doc(alias = "get_x")]
    pub fn x(&self) -> f32 {
        unsafe { ffi::graphene_euler_get_x(self.to_glib_none().0) }
    }

    /// Retrieves the rotation angle on the Y axis, in degrees.
    ///
    /// # Returns
    ///
    /// the rotation angle
    #[doc(alias = "graphene_euler_get_y")]
    #[doc(alias = "get_y")]
    pub fn y(&self) -> f32 {
        unsafe { ffi::graphene_euler_get_y(self.to_glib_none().0) }
    }

    /// Retrieves the rotation angle on the Z axis, in degrees.
    ///
    /// # Returns
    ///
    /// the rotation angle
    #[doc(alias = "graphene_euler_get_z")]
    #[doc(alias = "get_z")]
    pub fn z(&self) -> f32 {
        unsafe { ffi::graphene_euler_get_z(self.to_glib_none().0) }
    }

    /// Reorders a [`Euler`][crate::Euler] using `order`.
    ///
    /// This function is equivalent to creating a [`Quaternion`][crate::Quaternion] from the
    /// given [`Euler`][crate::Euler], and then converting the quaternion into another
    /// [`Euler`][crate::Euler].
    /// ## `order`
    /// the new order
    ///
    /// # Returns
    ///
    ///
    /// ## `res`
    /// return location for the reordered
    ///  [`Euler`][crate::Euler]
    #[doc(alias = "graphene_euler_reorder")]
    #[must_use]
    pub fn reorder(&self, order: EulerOrder) -> Euler {
        unsafe {
            let mut res = Euler::uninitialized();
            ffi::graphene_euler_reorder(
                self.to_glib_none().0,
                order.into_glib(),
                res.to_glib_none_mut().0,
            );
            res
        }
    }

    ///
    ///
    /// The rotation sign convention is right-handed, to preserve compatibility
    /// between Euler-based, quaternion-based, and angle-axis-based rotations.
    ///
    /// # Returns
    ///
    ///
    /// ## `res`
    /// return location for a [`Matrix`][crate::Matrix]
    #[doc(alias = "graphene_euler_to_matrix")]
    pub fn to_matrix(&self) -> Matrix {
        unsafe {
            let mut res = Matrix::uninitialized();
            ffi::graphene_euler_to_matrix(self.to_glib_none().0, res.to_glib_none_mut().0);
            res
        }
    }

    /// Converts a [`Euler`][crate::Euler] into a [`Quaternion`][crate::Quaternion].
    ///
    /// # Returns
    ///
    ///
    /// ## `res`
    /// return location for a [`Quaternion`][crate::Quaternion]
    #[doc(alias = "graphene_euler_to_quaternion")]
    pub fn to_quaternion(&self) -> Quaternion {
        unsafe {
            let mut res = Quaternion::uninitialized();
            ffi::graphene_euler_to_quaternion(self.to_glib_none().0, res.to_glib_none_mut().0);
            res
        }
    }

    /// Retrieves the angles of a [`Euler`][crate::Euler] and initializes a
    /// [`Vec3`][crate::Vec3] with them.
    ///
    /// # Returns
    ///
    ///
    /// ## `res`
    /// return location for a [`Vec3`][crate::Vec3]
    #[doc(alias = "graphene_euler_to_vec3")]
    pub fn to_vec3(&self) -> Vec3 {
        unsafe {
            let mut res = Vec3::uninitialized();
            ffi::graphene_euler_to_vec3(self.to_glib_none().0, res.to_glib_none_mut().0);
            res
        }
    }
}

impl PartialEq for Euler {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        self.equal(other)
    }
}

impl Eq for Euler {}