graphene/
box_.rs

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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
// Take a look at the license at the top of the repository in the LICENSE file.

use std::fmt;

use glib::translate::*;

use crate::{ffi, Box, Point3D, Vec3};

impl Box {
    /// Computes the vertices of the given [`Box`][crate::Box].
    ///
    /// # Returns
    ///
    ///
    /// ## `vertices`
    /// return location for an array
    ///  of 8 [`Vec3`][crate::Vec3]
    #[doc(alias = "graphene_box_get_vertices")]
    #[doc(alias = "get_vertices")]
    pub fn vertices(&self) -> &[Vec3; 8] {
        unsafe {
            let mut out: [ffi::graphene_vec3_t; 8] = std::mem::zeroed();
            ffi::graphene_box_get_vertices(self.to_glib_none().0, &mut out as *mut _);
            &*(&out as *const [ffi::graphene_vec3_t; 8] as *const [Vec3; 8])
        }
    }

    /// Initializes the given [`Box`][crate::Box] with two vertices.
    /// ## `min`
    /// the coordinates of the minimum vertex
    /// ## `max`
    /// the coordinates of the maximum vertex
    ///
    /// # Returns
    ///
    /// the initialized [`Box`][crate::Box]
    #[doc(alias = "graphene_box_init")]
    pub fn new(min: Option<&Point3D>, max: Option<&Point3D>) -> Self {
        assert_initialized_main_thread!();
        unsafe {
            let mut b = Self::uninitialized();
            ffi::graphene_box_init(
                b.to_glib_none_mut().0,
                min.to_glib_none().0,
                max.to_glib_none().0,
            );
            b
        }
    }

    /// Initializes the given [`Box`][crate::Box] with the given array
    /// of vertices.
    ///
    /// If `n_points` is 0, the returned box is initialized with
    /// [`empty()`][Self::empty()].
    /// ## `points`
    /// an array of [`Point3D`][crate::Point3D]
    ///
    /// # Returns
    ///
    /// the initialized [`Box`][crate::Box]
    #[doc(alias = "graphene_box_init_from_points")]
    #[doc(alias = "init_from_points")]
    pub fn from_points(points: &[Point3D]) -> Self {
        assert_initialized_main_thread!();

        let n = points.len() as u32;

        unsafe {
            let mut b = Self::uninitialized();
            ffi::graphene_box_init_from_points(b.to_glib_none_mut().0, n, points.to_glib_none().0);
            b
        }
    }

    /// Initializes the given [`Box`][crate::Box] with two vertices
    /// stored inside [`Vec3`][crate::Vec3].
    /// ## `min`
    /// the coordinates of the minimum vertex
    /// ## `max`
    /// the coordinates of the maximum vertex
    ///
    /// # Returns
    ///
    /// the initialized [`Box`][crate::Box]
    #[doc(alias = "graphene_box_init_from_vec3")]
    #[doc(alias = "init_from_vec3")]
    pub fn from_vec3(min: Option<&Vec3>, max: Option<&Vec3>) -> Self {
        assert_initialized_main_thread!();
        unsafe {
            let mut b = Self::uninitialized();
            ffi::graphene_box_init_from_vec3(
                b.to_glib_none_mut().0,
                min.to_glib_none().0,
                max.to_glib_none().0,
            );
            b
        }
    }

    /// Initializes the given [`Box`][crate::Box] with the given array
    /// of vertices.
    ///
    /// If `n_vectors` is 0, the returned box is initialized with
    /// [`empty()`][Self::empty()].
    /// ## `vectors`
    /// an array of [`Vec3`][crate::Vec3]
    ///
    /// # Returns
    ///
    /// the initialized [`Box`][crate::Box]
    #[doc(alias = "graphene_box_init_from_vectors")]
    #[doc(alias = "init_from_vectors")]
    pub fn from_vectors(vectors: &[Vec3]) -> Self {
        assert_initialized_main_thread!();

        let n = vectors.len() as u32;

        unsafe {
            let mut b = Self::uninitialized();
            ffi::graphene_box_init_from_vectors(
                b.to_glib_none_mut().0,
                n,
                vectors.to_glib_none().0,
            );
            b
        }
    }
}

impl Default for Box {
    fn default() -> Self {
        Self::zero()
    }
}

impl fmt::Debug for Box {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("Box")
            .field("min", &self.min())
            .field("max", &self.max())
            .finish()
    }
}