1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

// Take a look at the license at the top of the repository in the LICENSE file.

use crate::Point3D;
use crate::Sphere;
use crate::Vec3;
use glib::translate::*;

impl Sphere {
    /// Initializes the given [`Sphere`][crate::Sphere] using the given array
    /// of 3D coordinates so that the sphere includes them.
    ///
    /// The center of the sphere can either be specified, or will be center
    /// of the 3D volume that encompasses all `points`.
    /// ## `points`
    /// an array of [`Point3D`][crate::Point3D]
    /// ## `center`
    /// the center of the sphere
    ///
    /// # Returns
    ///
    /// the initialized [`Sphere`][crate::Sphere]
    #[doc(alias = "graphene_sphere_init_from_points")]
    pub fn init_from_points(&mut self, points: &[&Point3D], center: Option<&Point3D>) {
        let vec: Vec<_> = points
            .iter()
            .map(|e| unsafe { *e.to_glib_none().0 })
            .collect();
        let n = vec.len() as u32;

        unsafe {
            ffi::graphene_sphere_init_from_points(
                self.to_glib_none_mut().0,
                n,
                vec.as_ptr(),
                center.to_glib_none().0,
            );
        }
    }

    /// Initializes the given [`Sphere`][crate::Sphere] using the given array
    /// of 3D coordinates so that the sphere includes them.
    ///
    /// The center of the sphere can either be specified, or will be center
    /// of the 3D volume that encompasses all `vectors`.
    /// ## `vectors`
    /// an array of [`Vec3`][crate::Vec3]
    /// ## `center`
    /// the center of the sphere
    ///
    /// # Returns
    ///
    /// the initialized [`Sphere`][crate::Sphere]
    #[doc(alias = "graphene_sphere_init_from_vectors")]
    pub fn init_from_vectors(&mut self, vectors: &[&Vec3], center: Option<&Point3D>) {
        let vec: Vec<_> = vectors
            .iter()
            .map(|e| unsafe { *e.to_glib_none().0 })
            .collect();
        let n = vec.len() as u32;

        unsafe {
            ffi::graphene_sphere_init_from_vectors(
                self.to_glib_none_mut().0,
                n,
                vec.as_ptr(),
                center.to_glib_none().0,
            );
        }
    }

    #[doc(alias = "graphene_sphere_init")]
    pub fn new(center: Option<&Point3D>, radius: f32) -> Sphere {
        assert_initialized_main_thread!();
        unsafe {
            let alloc = ffi::graphene_sphere_alloc();
            ffi::graphene_sphere_init(alloc, center.to_glib_none().0, radius);
            from_glib_full(alloc)
        }
    }

    #[doc(alias = "graphene_sphere_init_from_points")]
    #[doc(alias = "new_from_points")]
    pub fn from_points(points: &[&Point3D], center: Option<&Point3D>) -> Sphere {
        assert_initialized_main_thread!();

        let vec: Vec<_> = points
            .iter()
            .map(|e| unsafe { *e.to_glib_none().0 })
            .collect();
        let n = vec.len() as u32;

        unsafe {
            let alloc = ffi::graphene_sphere_alloc();
            ffi::graphene_sphere_init_from_points(alloc, n, vec.as_ptr(), center.to_glib_none().0);
            from_glib_full(alloc)
        }
    }

    #[doc(alias = "graphene_sphere_init_from_vectors")]
    #[doc(alias = "new_from_vectors")]
    pub fn from_vectors(vectors: &[&Vec3], center: Option<&Point3D>) -> Sphere {
        assert_initialized_main_thread!();

        let vec: Vec<_> = vectors
            .iter()
            .map(|e| unsafe { *e.to_glib_none().0 })
            .collect();
        let n = vec.len() as u32;

        unsafe {
            let alloc = ffi::graphene_sphere_alloc();
            ffi::graphene_sphere_init_from_vectors(alloc, n, vec.as_ptr(), center.to_glib_none().0);
            from_glib_full(alloc)
        }
    }
}