// 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::Box;
use crate::Plane;
use crate::Point3D;
use crate::RayIntersectionKind;
use crate::Sphere;
use crate::Triangle;
use crate::Vec3;
use glib::translate::*;
use std::mem;

glib::wrapper! {
    /// A ray emitted from an origin in a given direction.
    ///
    /// The contents of the `graphene_ray_t` structure are private, and should not
    /// be modified directly.
    #[derive(Debug, PartialOrd, Ord, Hash)]
    pub struct Ray(Boxed<ffi::graphene_ray_t>);

    match fn {
        copy => |ptr| glib::gobject_ffi::g_boxed_copy(ffi::graphene_ray_get_type(), ptr as *mut _) as *mut ffi::graphene_ray_t,
        free => |ptr| glib::gobject_ffi::g_boxed_free(ffi::graphene_ray_get_type(), ptr as *mut _),
        init => |_ptr| (),
        clear => |_ptr| (),
        type_ => || ffi::graphene_ray_get_type(),
    }
}

impl Ray {
    /// Checks whether the two given [`Ray`][crate::Ray] are equal.
    /// ## `b`
    /// a [`Ray`][crate::Ray]
    ///
    /// # Returns
    ///
    /// `true` if the given rays are equal
    #[doc(alias = "graphene_ray_equal")]
    fn equal(&self, b: &Ray) -> bool {
        unsafe {
            from_glib(ffi::graphene_ray_equal(
                self.to_glib_none().0,
                b.to_glib_none().0,
            ))
        }
    }

    /// Computes the point on the given [`Ray`][crate::Ray] that is closest to the
    /// given point `p`.
    /// ## `p`
    /// a [`Point3D`][crate::Point3D]
    ///
    /// # Returns
    ///
    ///
    /// ## `res`
    /// return location for the closest point3d
    #[doc(alias = "graphene_ray_get_closest_point_to_point")]
    #[doc(alias = "get_closest_point_to_point")]
    pub fn closest_point_to_point(&self, p: &Point3D) -> Point3D {
        unsafe {
            let mut res = Point3D::uninitialized();
            ffi::graphene_ray_get_closest_point_to_point(
                self.to_glib_none().0,
                p.to_glib_none().0,
                res.to_glib_none_mut().0,
            );
            res
        }
    }

    /// Retrieves the direction of the given [`Ray`][crate::Ray].
    ///
    /// # Returns
    ///
    ///
    /// ## `direction`
    /// return location for the direction
    #[doc(alias = "graphene_ray_get_direction")]
    #[doc(alias = "get_direction")]
    pub fn direction(&self) -> Vec3 {
        unsafe {
            let mut direction = Vec3::uninitialized();
            ffi::graphene_ray_get_direction(self.to_glib_none().0, direction.to_glib_none_mut().0);
            direction
        }
    }

    /// Computes the distance of the origin of the given [`Ray`][crate::Ray] from the
    /// given plane.
    ///
    /// If the ray does not intersect the plane, this function returns `INFINITY`.
    /// ## `p`
    /// a [`Plane`][crate::Plane]
    ///
    /// # Returns
    ///
    /// the distance of the origin of the ray from the plane
    #[doc(alias = "graphene_ray_get_distance_to_plane")]
    #[doc(alias = "get_distance_to_plane")]
    pub fn distance_to_plane(&self, p: &Plane) -> f32 {
        unsafe {
            ffi::graphene_ray_get_distance_to_plane(self.to_glib_none().0, p.to_glib_none().0)
        }
    }

    /// Computes the distance of the closest approach between the
    /// given [`Ray`][crate::Ray] `self` and the point `p`.
    ///
    /// The closest approach to a ray from a point is the distance
    /// between the point and the projection of the point on the
    /// ray itself.
    /// ## `p`
    /// a [`Point3D`][crate::Point3D]
    ///
    /// # Returns
    ///
    /// the distance of the point
    #[doc(alias = "graphene_ray_get_distance_to_point")]
    #[doc(alias = "get_distance_to_point")]
    pub fn distance_to_point(&self, p: &Point3D) -> f32 {
        unsafe {
            ffi::graphene_ray_get_distance_to_point(self.to_glib_none().0, p.to_glib_none().0)
        }
    }

    /// Retrieves the origin of the given [`Ray`][crate::Ray].
    ///
    /// # Returns
    ///
    ///
    /// ## `origin`
    /// return location for the origin
    #[doc(alias = "graphene_ray_get_origin")]
    #[doc(alias = "get_origin")]
    pub fn origin(&self) -> Point3D {
        unsafe {
            let mut origin = Point3D::uninitialized();
            ffi::graphene_ray_get_origin(self.to_glib_none().0, origin.to_glib_none_mut().0);
            origin
        }
    }

    /// Retrieves the coordinates of a point at the distance `t` along the
    /// given [`Ray`][crate::Ray].
    /// ## `t`
    /// the distance along the ray
    ///
    /// # Returns
    ///
    ///
    /// ## `position`
    /// return location for the position
    #[doc(alias = "graphene_ray_get_position_at")]
    #[doc(alias = "get_position_at")]
    pub fn position_at(&self, t: f32) -> Point3D {
        unsafe {
            let mut position = Point3D::uninitialized();
            ffi::graphene_ray_get_position_at(
                self.to_glib_none().0,
                t,
                position.to_glib_none_mut().0,
            );
            position
        }
    }

    /// Initializes the given [`Ray`][crate::Ray] using the given `origin`
    /// and `direction` values.
    /// ## `origin`
    /// the origin of the ray
    /// ## `direction`
    /// the direction vector
    ///
    /// # Returns
    ///
    /// the initialized ray
    #[doc(alias = "graphene_ray_init")]
    pub fn init(&mut self, origin: Option<&Point3D>, direction: Option<&Vec3>) {
        unsafe {
            ffi::graphene_ray_init(
                self.to_glib_none_mut().0,
                origin.to_glib_none().0,
                direction.to_glib_none().0,
            );
        }
    }

    /// Initializes the given [`Ray`][crate::Ray] using the origin and direction
    /// values of another [`Ray`][crate::Ray].
    /// ## `src`
    /// a [`Ray`][crate::Ray]
    ///
    /// # Returns
    ///
    /// the initialized ray
    #[doc(alias = "graphene_ray_init_from_ray")]
    pub fn init_from_ray(&mut self, src: &Ray) {
        unsafe {
            ffi::graphene_ray_init_from_ray(self.to_glib_none_mut().0, src.to_glib_none().0);
        }
    }

    /// Initializes the given [`Ray`][crate::Ray] using the given vectors.
    /// ## `origin`
    /// a [`Vec3`][crate::Vec3]
    /// ## `direction`
    /// a [`Vec3`][crate::Vec3]
    ///
    /// # Returns
    ///
    /// the initialized ray
    #[doc(alias = "graphene_ray_init_from_vec3")]
    pub fn init_from_vec3(&mut self, origin: Option<&Vec3>, direction: Option<&Vec3>) {
        unsafe {
            ffi::graphene_ray_init_from_vec3(
                self.to_glib_none_mut().0,
                origin.to_glib_none().0,
                direction.to_glib_none().0,
            );
        }
    }

    /// Intersects the given [`Ray`][crate::Ray] `self` with the given
    /// [`Box`][crate::Box] `b`.
    /// ## `b`
    /// a [`Box`][crate::Box]
    ///
    /// # Returns
    ///
    /// the type of intersection
    ///
    /// ## `t_out`
    /// the distance of the point on the ray that intersects the box
    #[doc(alias = "graphene_ray_intersect_box")]
    pub fn intersect_box(&self, b: &Box) -> (RayIntersectionKind, f32) {
        unsafe {
            let mut t_out = mem::MaybeUninit::uninit();
            let ret = from_glib(ffi::graphene_ray_intersect_box(
                self.to_glib_none().0,
                b.to_glib_none().0,
                t_out.as_mut_ptr(),
            ));
            let t_out = t_out.assume_init();
            (ret, t_out)
        }
    }

    /// Intersects the given [`Ray`][crate::Ray] `self` with the given
    /// [`Sphere`][crate::Sphere] `s`.
    /// ## `s`
    /// a [`Sphere`][crate::Sphere]
    ///
    /// # Returns
    ///
    /// the type of intersection
    ///
    /// ## `t_out`
    /// the distance of the point on the ray that intersects the sphere
    #[doc(alias = "graphene_ray_intersect_sphere")]
    pub fn intersect_sphere(&self, s: &Sphere) -> (RayIntersectionKind, f32) {
        unsafe {
            let mut t_out = mem::MaybeUninit::uninit();
            let ret = from_glib(ffi::graphene_ray_intersect_sphere(
                self.to_glib_none().0,
                s.to_glib_none().0,
                t_out.as_mut_ptr(),
            ));
            let t_out = t_out.assume_init();
            (ret, t_out)
        }
    }

    /// Intersects the given [`Ray`][crate::Ray] `self` with the given
    /// [`Triangle`][crate::Triangle] `t`.
    /// ## `t`
    /// a [`Triangle`][crate::Triangle]
    ///
    /// # Returns
    ///
    /// the type of intersection
    ///
    /// ## `t_out`
    /// the distance of the point on the ray that intersects the triangle
    #[doc(alias = "graphene_ray_intersect_triangle")]
    pub fn intersect_triangle(&self, t: &Triangle) -> (RayIntersectionKind, f32) {
        unsafe {
            let mut t_out = mem::MaybeUninit::uninit();
            let ret = from_glib(ffi::graphene_ray_intersect_triangle(
                self.to_glib_none().0,
                t.to_glib_none().0,
                t_out.as_mut_ptr(),
            ));
            let t_out = t_out.assume_init();
            (ret, t_out)
        }
    }

    /// Checks whether the given [`Ray`][crate::Ray] `self` intersects the
    /// given [`Box`][crate::Box] `b`.
    ///
    /// See also: [`intersect_box()`][Self::intersect_box()]
    /// ## `b`
    /// a [`Box`][crate::Box]
    ///
    /// # Returns
    ///
    /// `true` if the ray intersects the box
    #[doc(alias = "graphene_ray_intersects_box")]
    pub fn intersects_box(&self, b: &Box) -> bool {
        unsafe {
            from_glib(ffi::graphene_ray_intersects_box(
                self.to_glib_none().0,
                b.to_glib_none().0,
            ))
        }
    }

    /// Checks if the given [`Ray`][crate::Ray] `self` intersects the
    /// given [`Sphere`][crate::Sphere] `s`.
    ///
    /// See also: [`intersect_sphere()`][Self::intersect_sphere()]
    /// ## `s`
    /// a [`Sphere`][crate::Sphere]
    ///
    /// # Returns
    ///
    /// `true` if the ray intersects the sphere
    #[doc(alias = "graphene_ray_intersects_sphere")]
    pub fn intersects_sphere(&self, s: &Sphere) -> bool {
        unsafe {
            from_glib(ffi::graphene_ray_intersects_sphere(
                self.to_glib_none().0,
                s.to_glib_none().0,
            ))
        }
    }

    /// Checks whether the given [`Ray`][crate::Ray] `self` intersects the
    /// given [`Triangle`][crate::Triangle] `b`.
    ///
    /// See also: [`intersect_triangle()`][Self::intersect_triangle()]
    /// ## `t`
    /// a [`Triangle`][crate::Triangle]
    ///
    /// # Returns
    ///
    /// `true` if the ray intersects the triangle
    #[doc(alias = "graphene_ray_intersects_triangle")]
    pub fn intersects_triangle(&self, t: &Triangle) -> bool {
        unsafe {
            from_glib(ffi::graphene_ray_intersects_triangle(
                self.to_glib_none().0,
                t.to_glib_none().0,
            ))
        }
    }
}

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

impl Eq for Ray {}