euclid/
homogen.rs

1// Copyright 2018 The Servo Project Developers. See the COPYRIGHT
2// file at the top-level directory of this distribution.
3//
4// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
5// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
6// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
7// option. This file may not be copied, modified, or distributed
8// except according to those terms.
9
10use crate::point::{Point2D, Point3D};
11use crate::vector::{Vector2D, Vector3D};
12
13use crate::num::{One, Zero};
14
15#[cfg(feature = "bytemuck")]
16use bytemuck::{Pod, Zeroable};
17use core::cmp::{Eq, PartialEq};
18use core::fmt;
19use core::hash::Hash;
20use core::marker::PhantomData;
21use core::ops::Div;
22#[cfg(feature = "malloc_size_of")]
23use malloc_size_of::{MallocSizeOf, MallocSizeOfOps};
24#[cfg(feature = "serde")]
25use serde;
26
27/// Homogeneous vector in 3D space.
28#[repr(C)]
29pub struct HomogeneousVector<T, U> {
30    pub x: T,
31    pub y: T,
32    pub z: T,
33    pub w: T,
34    #[doc(hidden)]
35    pub _unit: PhantomData<U>,
36}
37
38impl<T: Copy, U> Copy for HomogeneousVector<T, U> {}
39
40impl<T: Clone, U> Clone for HomogeneousVector<T, U> {
41    fn clone(&self) -> Self {
42        HomogeneousVector {
43            x: self.x.clone(),
44            y: self.y.clone(),
45            z: self.z.clone(),
46            w: self.w.clone(),
47            _unit: PhantomData,
48        }
49    }
50}
51
52#[cfg(feature = "serde")]
53impl<'de, T, U> serde::Deserialize<'de> for HomogeneousVector<T, U>
54where
55    T: serde::Deserialize<'de>,
56{
57    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
58    where
59        D: serde::Deserializer<'de>,
60    {
61        let (x, y, z, w) = serde::Deserialize::deserialize(deserializer)?;
62        Ok(HomogeneousVector {
63            x,
64            y,
65            z,
66            w,
67            _unit: PhantomData,
68        })
69    }
70}
71
72#[cfg(feature = "serde")]
73impl<T, U> serde::Serialize for HomogeneousVector<T, U>
74where
75    T: serde::Serialize,
76{
77    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
78    where
79        S: serde::Serializer,
80    {
81        (&self.x, &self.y, &self.z, &self.w).serialize(serializer)
82    }
83}
84
85#[cfg(feature = "arbitrary")]
86impl<'a, T, U> arbitrary::Arbitrary<'a> for HomogeneousVector<T, U>
87where
88    T: arbitrary::Arbitrary<'a>,
89{
90    fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> {
91        let (x, y, z, w) = arbitrary::Arbitrary::arbitrary(u)?;
92        Ok(HomogeneousVector {
93            x,
94            y,
95            z,
96            w,
97            _unit: PhantomData,
98        })
99    }
100}
101
102#[cfg(feature = "bytemuck")]
103unsafe impl<T: Zeroable, U> Zeroable for HomogeneousVector<T, U> {}
104
105#[cfg(feature = "bytemuck")]
106unsafe impl<T: Pod, U: 'static> Pod for HomogeneousVector<T, U> {}
107
108#[cfg(feature = "malloc_size_of")]
109impl<T: MallocSizeOf, U> MallocSizeOf for HomogeneousVector<T, U> {
110    fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize {
111        self.x.size_of(ops) + self.y.size_of(ops) + self.z.size_of(ops) + self.w.size_of(ops)
112    }
113}
114
115impl<T, U> Eq for HomogeneousVector<T, U> where T: Eq {}
116
117impl<T, U> PartialEq for HomogeneousVector<T, U>
118where
119    T: PartialEq,
120{
121    fn eq(&self, other: &Self) -> bool {
122        self.x == other.x && self.y == other.y && self.z == other.z && self.w == other.w
123    }
124}
125
126impl<T, U> Hash for HomogeneousVector<T, U>
127where
128    T: Hash,
129{
130    fn hash<H: core::hash::Hasher>(&self, h: &mut H) {
131        self.x.hash(h);
132        self.y.hash(h);
133        self.z.hash(h);
134        self.w.hash(h);
135    }
136}
137
138impl<T, U> HomogeneousVector<T, U> {
139    /// Constructor taking scalar values directly.
140    #[inline]
141    pub const fn new(x: T, y: T, z: T, w: T) -> Self {
142        HomogeneousVector {
143            x,
144            y,
145            z,
146            w,
147            _unit: PhantomData,
148        }
149    }
150}
151
152impl<T: Copy + Div<T, Output = T> + Zero + PartialOrd, U> HomogeneousVector<T, U> {
153    /// Convert into Cartesian 2D point.
154    ///
155    /// Returns `None` if the point is on or behind the W=0 hemisphere.
156    #[inline]
157    pub fn to_point2d(self) -> Option<Point2D<T, U>> {
158        if self.w > T::zero() {
159            Some(Point2D::new(self.x / self.w, self.y / self.w))
160        } else {
161            None
162        }
163    }
164
165    /// Convert into Cartesian 3D point.
166    ///
167    /// Returns `None` if the point is on or behind the W=0 hemisphere.
168    #[inline]
169    pub fn to_point3d(self) -> Option<Point3D<T, U>> {
170        if self.w > T::zero() {
171            Some(Point3D::new(
172                self.x / self.w,
173                self.y / self.w,
174                self.z / self.w,
175            ))
176        } else {
177            None
178        }
179    }
180}
181
182impl<T: Zero, U> From<Vector2D<T, U>> for HomogeneousVector<T, U> {
183    #[inline]
184    fn from(v: Vector2D<T, U>) -> Self {
185        HomogeneousVector::new(v.x, v.y, T::zero(), T::zero())
186    }
187}
188
189impl<T: Zero, U> From<Vector3D<T, U>> for HomogeneousVector<T, U> {
190    #[inline]
191    fn from(v: Vector3D<T, U>) -> Self {
192        HomogeneousVector::new(v.x, v.y, v.z, T::zero())
193    }
194}
195
196impl<T: Zero + One, U> From<Point2D<T, U>> for HomogeneousVector<T, U> {
197    #[inline]
198    fn from(p: Point2D<T, U>) -> Self {
199        HomogeneousVector::new(p.x, p.y, T::zero(), T::one())
200    }
201}
202
203impl<T: One, U> From<Point3D<T, U>> for HomogeneousVector<T, U> {
204    #[inline]
205    fn from(p: Point3D<T, U>) -> Self {
206        HomogeneousVector::new(p.x, p.y, p.z, T::one())
207    }
208}
209
210impl<T: fmt::Debug, U> fmt::Debug for HomogeneousVector<T, U> {
211    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
212        f.debug_tuple("")
213            .field(&self.x)
214            .field(&self.y)
215            .field(&self.z)
216            .field(&self.w)
217            .finish()
218    }
219}
220
221#[cfg(test)]
222mod homogeneous {
223    use super::HomogeneousVector;
224    use crate::default::{Point2D, Point3D};
225
226    #[test]
227    fn roundtrip() {
228        assert_eq!(
229            Some(Point2D::new(1.0, 2.0)),
230            HomogeneousVector::from(Point2D::new(1.0, 2.0)).to_point2d()
231        );
232        assert_eq!(
233            Some(Point3D::new(1.0, -2.0, 0.1)),
234            HomogeneousVector::from(Point3D::new(1.0, -2.0, 0.1)).to_point3d()
235        );
236    }
237
238    #[test]
239    fn negative() {
240        assert_eq!(
241            None,
242            HomogeneousVector::<f32, ()>::new(1.0, 2.0, 3.0, 0.0).to_point2d()
243        );
244        assert_eq!(
245            None,
246            HomogeneousVector::<f32, ()>::new(1.0, -2.0, -3.0, -2.0).to_point3d()
247        );
248    }
249}
euclid/homogen.rs

euclid/
homogen.rs
