Skip to main content

three_rs/math/
triangle.rs

1//! Port of `three.js/src/math/Triangle.js`.
2
3use crate::core::BufferAttribute;
4
5use super::{Box3, Plane, Vector3, Vector4};
6
7/// Port of `three.js/src/math/Triangle.js`'s `Triangle` class: a geometric
8/// triangle defined by three corner vectors.
9#[derive(Clone, Copy, Debug, Default, PartialEq)]
10pub struct Triangle {
11    /// The first corner of the triangle.
12    pub a: Vector3,
13    /// The second corner of the triangle.
14    pub b: Vector3,
15    /// The third corner of the triangle.
16    pub c: Vector3,
17}
18
19impl Triangle {
20    /// `new Triangle()`.
21    pub const fn new(a: Vector3, b: Vector3, c: Vector3) -> Self {
22        Self { a, b, c }
23    }
24
25    /// `Triangle.getNormal()` (static).
26    pub fn static_get_normal(a: &Vector3, b: &Vector3, c: &Vector3) -> Vector3 {
27        let mut target = Vector3::default();
28        let mut v0 = Vector3::default();
29
30        target.sub_vectors(c, b);
31        v0.sub_vectors(a, b);
32        target.cross(&v0);
33
34        let target_length_sq = target.length_sq();
35        if target_length_sq > 0.0 {
36            target.multiply_scalar(1.0 / target_length_sq.sqrt());
37            return target;
38        }
39
40        target.set(0.0, 0.0, 0.0);
41        target
42    }
43
44    /// `Triangle.getBarycoord()` (static). `None` where three.js returns `null`
45    /// (collinear or singular triangle).
46    pub fn static_get_barycoord(
47        point: &Vector3,
48        a: &Vector3,
49        b: &Vector3,
50        c: &Vector3,
51    ) -> Option<Vector3> {
52        let mut v0 = Vector3::default();
53        let mut v1 = Vector3::default();
54        let mut v2 = Vector3::default();
55
56        v0.sub_vectors(c, a);
57        v1.sub_vectors(b, a);
58        v2.sub_vectors(point, a);
59
60        let dot00 = v0.dot(&v0);
61        let dot01 = v0.dot(&v1);
62        let dot02 = v0.dot(&v2);
63        let dot11 = v1.dot(&v1);
64        let dot12 = v1.dot(&v2);
65
66        let denom = dot00 * dot11 - dot01 * dot01;
67
68        // collinear or singular triangle
69        if denom == 0.0 {
70            return None;
71        }
72
73        let inv_denom = 1.0 / denom;
74        let u = (dot11 * dot02 - dot01 * dot12) * inv_denom;
75        let v = (dot00 * dot12 - dot01 * dot02) * inv_denom;
76
77        // barycentric coordinates must always sum to 1
78        let mut target = Vector3::default();
79        target.set(1.0 - u - v, v, u);
80        Some(target)
81    }
82
83    /// `Triangle.containsPoint()` (static).
84    pub fn static_contains_point(point: &Vector3, a: &Vector3, b: &Vector3, c: &Vector3) -> bool {
85        // if the triangle is degenerate then we can't contain a point
86        let Some(v3) = Self::static_get_barycoord(point, a, b, c) else {
87            return false;
88        };
89
90        (v3.x >= 0.0) && (v3.y >= 0.0) && ((v3.x + v3.y) <= 1.0)
91    }
92
93    /// `Triangle.getInterpolation()` (static). `None` where three.js returns
94    /// `null` (degenerate triangle).
95    #[allow(clippy::too_many_arguments)]
96    pub fn static_get_interpolation(
97        point: &Vector3,
98        p1: &Vector3,
99        p2: &Vector3,
100        p3: &Vector3,
101        v1: &Vector3,
102        v2: &Vector3,
103        v3: &Vector3,
104    ) -> Option<Vector3> {
105        let bary = Self::static_get_barycoord(point, p1, p2, p3)?;
106
107        let mut target = Vector3::default();
108        target.set_scalar(0.0);
109        target.add_scaled_vector(v1, bary.x);
110        target.add_scaled_vector(v2, bary.y);
111        target.add_scaled_vector(v3, bary.z);
112
113        Some(target)
114    }
115
116    /// `Triangle.getInterpolatedAttribute()` (static): the attribute's values
117    /// at vertices `i1`, `i2`, `i3`, weighted by `barycoord`.
118    ///
119    /// three.js takes a `Vector2`/`Vector3`/`Vector4` target and reads as many
120    /// components as the target has; the port returns a [`Vector4`] holding the
121    /// first `min( itemSize, 4 )` components, the rest 0, and the caller takes
122    /// the swizzle it wants (`Mesh` takes `xy` for `uv` and `xyz` for
123    /// `normal`, which is what its `new Vector2()` / `new Vector3()` targets
124    /// read).
125    pub fn static_get_interpolated_attribute(
126        attr: &BufferAttribute,
127        i1: usize,
128        i2: usize,
129        i3: usize,
130        barycoord: &Vector3,
131    ) -> Vector4 {
132        let item_size = attr.item_size.min(4);
133        // `Vector4.fromBufferAttribute()`: `getX..getW`, so a typed or
134        // normalized attribute reads as three's does.
135        let read = |index: usize| {
136            let mut v = Vector4::new(0.0, 0.0, 0.0, 0.0);
137            for component in 0..item_size {
138                v.set_component(component, attr.get_component(index, component));
139            }
140            v
141        };
142        let (v40, v41, v42) = (read(i1), read(i2), read(i3));
143
144        let mut target = Vector4::new(0.0, 0.0, 0.0, 0.0);
145        target.add_scaled_vector(&v40, barycoord.x);
146        target.add_scaled_vector(&v41, barycoord.y);
147        target.add_scaled_vector(&v42, barycoord.z);
148        target
149    }
150
151    /// `Triangle.isFrontFacing()` (static).
152    pub fn static_is_front_facing(
153        a: &Vector3,
154        b: &Vector3,
155        c: &Vector3,
156        direction: &Vector3,
157    ) -> bool {
158        let mut v0 = Vector3::default();
159        let mut v1 = Vector3::default();
160
161        v0.sub_vectors(c, b);
162        v1.sub_vectors(a, b);
163
164        // strictly front facing
165        v0.cross(&v1).dot(direction) < 0.0
166    }
167
168    /// `Triangle.set()`.
169    pub fn set(&mut self, a: &Vector3, b: &Vector3, c: &Vector3) -> &mut Self {
170        self.a.copy(a);
171        self.b.copy(b);
172        self.c.copy(c);
173        self
174    }
175
176    /// `Triangle.setFromPointsAndIndices()`.
177    pub fn set_from_points_and_indices(
178        &mut self,
179        points: &[Vector3],
180        i0: usize,
181        i1: usize,
182        i2: usize,
183    ) -> &mut Self {
184        self.a.copy(&points[i0]);
185        self.b.copy(&points[i1]);
186        self.c.copy(&points[i2]);
187        self
188    }
189
190    /// `Triangle.setFromAttributeAndIndices()`.
191    pub fn set_from_attribute_and_indices(
192        &mut self,
193        attribute: &BufferAttribute,
194        i0: usize,
195        i1: usize,
196        i2: usize,
197    ) -> &mut Self {
198        self.a = attribute.get_vector3(i0);
199        self.b = attribute.get_vector3(i1);
200        self.c = attribute.get_vector3(i2);
201        self
202    }
203
204    /// `Triangle.copy()`.
205    pub fn copy(&mut self, triangle: &Self) -> &mut Self {
206        self.a.copy(&triangle.a);
207        self.b.copy(&triangle.b);
208        self.c.copy(&triangle.c);
209        self
210    }
211
212    /// `Triangle.getArea()`.
213    pub fn get_area(&self) -> f64 {
214        let mut v0 = Vector3::default();
215        let mut v1 = Vector3::default();
216
217        v0.sub_vectors(&self.c, &self.b);
218        v1.sub_vectors(&self.a, &self.b);
219
220        v0.cross(&v1).length() * 0.5
221    }
222
223    /// `Triangle.getMidpoint()`.
224    pub fn get_midpoint(&self) -> Vector3 {
225        let mut target = Vector3::default();
226        target
227            .add_vectors(&self.a, &self.b)
228            .add(&self.c)
229            .multiply_scalar(1.0 / 3.0);
230        target
231    }
232
233    /// `Triangle.getNormal()`.
234    pub fn get_normal(&self) -> Vector3 {
235        Triangle::static_get_normal(&self.a, &self.b, &self.c)
236    }
237
238    /// `Triangle.getPlane()`.
239    pub fn get_plane(&self) -> Plane {
240        let mut target = Plane::default();
241        target.set_from_coplanar_points(&self.a, &self.b, &self.c);
242        target
243    }
244
245    /// `Triangle.getBarycoord()`.
246    pub fn get_barycoord(&self, point: &Vector3) -> Option<Vector3> {
247        Triangle::static_get_barycoord(point, &self.a, &self.b, &self.c)
248    }
249
250    /// `Triangle.getInterpolation()`.
251    pub fn get_interpolation(
252        &self,
253        point: &Vector3,
254        v1: &Vector3,
255        v2: &Vector3,
256        v3: &Vector3,
257    ) -> Option<Vector3> {
258        Triangle::static_get_interpolation(point, &self.a, &self.b, &self.c, v1, v2, v3)
259    }
260
261    /// `Triangle.containsPoint()`.
262    pub fn contains_point(&self, point: &Vector3) -> bool {
263        Triangle::static_contains_point(point, &self.a, &self.b, &self.c)
264    }
265
266    /// `Triangle.isFrontFacing()`.
267    pub fn is_front_facing(&self, direction: &Vector3) -> bool {
268        Triangle::static_is_front_facing(&self.a, &self.b, &self.c, direction)
269    }
270
271    /// `Triangle.intersectsBox()`.
272    pub fn intersects_box(&self, box3: &Box3) -> bool {
273        box3.intersects_triangle(self)
274    }
275
276    /// `Triangle.closestPointToPoint()`.
277    pub fn closest_point_to_point(&self, p: &Vector3) -> Vector3 {
278        let a = self.a;
279        let b = self.b;
280        let c = self.c;
281        let mut target = Vector3::default();
282
283        let mut vab = Vector3::default();
284        let mut vac = Vector3::default();
285        let mut vbc = Vector3::default();
286        let mut vap = Vector3::default();
287        let mut vbp = Vector3::default();
288        let mut vcp = Vector3::default();
289
290        // algorithm thanks to Real-Time Collision Detection by Christer Ericson,
291        // published by Morgan Kaufmann Publishers, (c) 2005 Elsevier Inc.,
292        // under the accompanying license; see chapter 5.1.5 for detailed explanation.
293        // basically, we're distinguishing which of the voronoi regions of the triangle
294        // the point lies in with the minimum amount of redundant computation.
295
296        vab.sub_vectors(&b, &a);
297        vac.sub_vectors(&c, &a);
298        vap.sub_vectors(p, &a);
299        let d1 = vab.dot(&vap);
300        let d2 = vac.dot(&vap);
301        if d1 <= 0.0 && d2 <= 0.0 {
302            // vertex region of A; barycentric coords (1, 0, 0)
303            target.copy(&a);
304            return target;
305        }
306
307        vbp.sub_vectors(p, &b);
308        let d3 = vab.dot(&vbp);
309        let d4 = vac.dot(&vbp);
310        if d3 >= 0.0 && d4 <= d3 {
311            // vertex region of B; barycentric coords (0, 1, 0)
312            target.copy(&b);
313            return target;
314        }
315
316        let vc = d1 * d4 - d3 * d2;
317        if vc <= 0.0 && d1 >= 0.0 && d3 <= 0.0 {
318            let v = d1 / (d1 - d3);
319            // edge region of AB; barycentric coords (1-v, v, 0)
320            target.copy(&a).add_scaled_vector(&vab, v);
321            return target;
322        }
323
324        vcp.sub_vectors(p, &c);
325        let d5 = vab.dot(&vcp);
326        let d6 = vac.dot(&vcp);
327        if d6 >= 0.0 && d5 <= d6 {
328            // vertex region of C; barycentric coords (0, 0, 1)
329            target.copy(&c);
330            return target;
331        }
332
333        let vb = d5 * d2 - d1 * d6;
334        if vb <= 0.0 && d2 >= 0.0 && d6 <= 0.0 {
335            let w = d2 / (d2 - d6);
336            // edge region of AC; barycentric coords (1-w, 0, w)
337            target.copy(&a).add_scaled_vector(&vac, w);
338            return target;
339        }
340
341        let va = d3 * d6 - d5 * d4;
342        if va <= 0.0 && (d4 - d3) >= 0.0 && (d5 - d6) >= 0.0 {
343            vbc.sub_vectors(&c, &b);
344            let w = (d4 - d3) / ((d4 - d3) + (d5 - d6));
345            // edge region of BC; barycentric coords (0, 1-w, w)
346            target.copy(&b).add_scaled_vector(&vbc, w); // edge region of BC
347            return target;
348        }
349
350        // face region
351        let denom = 1.0 / (va + vb + vc);
352        // u = va * denom
353        let v = vb * denom;
354        let w = vc * denom;
355
356        target
357            .copy(&a)
358            .add_scaled_vector(&vab, v)
359            .add_scaled_vector(&vac, w);
360        target
361    }
362
363    /// `Triangle.equals()`.
364    pub fn equals(&self, triangle: &Self) -> bool {
365        triangle.a.equals(&self.a) && triangle.b.equals(&self.b) && triangle.c.equals(&self.c)
366    }
367}