1use crate::core::BufferAttribute;
4
5use super::{Box3, Plane, Vector3, Vector4};
6
7#[derive(Clone, Copy, Debug, Default, PartialEq)]
10pub struct Triangle {
11 pub a: Vector3,
13 pub b: Vector3,
15 pub c: Vector3,
17}
18
19impl Triangle {
20 pub const fn new(a: Vector3, b: Vector3, c: Vector3) -> Self {
22 Self { a, b, c }
23 }
24
25 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 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 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 let mut target = Vector3::default();
79 target.set(1.0 - u - v, v, u);
80 Some(target)
81 }
82
83 pub fn static_contains_point(point: &Vector3, a: &Vector3, b: &Vector3, c: &Vector3) -> bool {
85 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 #[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 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 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 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 v0.cross(&v1).dot(direction) < 0.0
166 }
167
168 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 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 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 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 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 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 pub fn get_normal(&self) -> Vector3 {
235 Triangle::static_get_normal(&self.a, &self.b, &self.c)
236 }
237
238 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 pub fn get_barycoord(&self, point: &Vector3) -> Option<Vector3> {
247 Triangle::static_get_barycoord(point, &self.a, &self.b, &self.c)
248 }
249
250 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 pub fn contains_point(&self, point: &Vector3) -> bool {
263 Triangle::static_contains_point(point, &self.a, &self.b, &self.c)
264 }
265
266 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 pub fn intersects_box(&self, box3: &Box3) -> bool {
273 box3.intersects_triangle(self)
274 }
275
276 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 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 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 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 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 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 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 target.copy(&b).add_scaled_vector(&vbc, w); return target;
348 }
349
350 let denom = 1.0 / (va + vb + vc);
352 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 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}