Blender V5.3
math_vector.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2001-2002 NaN Holding BV. All rights reserved.
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include <algorithm>
10
11#include "BLI_math_base_c.hh"
12#include "BLI_math_vector_c.hh"
13
14#include "BLI_math_base_safe.hh"
15#include "BLI_math_geom_c.hh"
17
18#include "BLI_strict_flags.hh" /* IWYU pragma: keep. Keep last. */
19
20namespace blender {
21
22/* -------------------------------------------------------------------- */
25
26void interp_v2_v2v2(float r[2], const float a[2], const float b[2], const float t)
27{
28 const float s = 1.0f - t;
29
30 r[0] = s * a[0] + t * b[0];
31 r[1] = s * a[1] + t * b[1];
32}
33
35 float r[2], const float a[2], const float b[2], const float c[2], const float t[3])
36{
37 r[0] = a[0] * t[0] + b[0] * t[1] + c[0] * t[2];
38 r[1] = a[1] * t[0] + b[1] * t[1] + c[1] * t[2];
39}
40
41void interp_v3_v3v3(float r[3], const float a[3], const float b[3], const float t)
42{
43 const float s = 1.0f - t;
44
45 r[0] = s * a[0] + t * b[0];
46 r[1] = s * a[1] + t * b[1];
47 r[2] = s * a[2] + t * b[2];
48}
49
50void interp_v4_v4v4(float r[4], const float a[4], const float b[4], const float t)
51{
52 const float s = 1.0f - t;
53
54 r[0] = s * a[0] + t * b[0];
55 r[1] = s * a[1] + t * b[1];
56 r[2] = s * a[2] + t * b[2];
57 r[3] = s * a[3] + t * b[3];
58}
59
60bool interp_v3_v3v3_slerp(float target[3], const float a[3], const float b[3], const float t)
61{
62 float cosom, w[2];
63
66
67 cosom = dot_v3v3(a, b);
68
69 /* direct opposites */
70 if (cosom < (-1.0f + FLT_EPSILON)) [[unlikely]] {
71 return false;
72 }
73
74 interp_dot_slerp(t, cosom, w);
75
76 target[0] = w[0] * a[0] + w[1] * b[0];
77 target[1] = w[0] * a[1] + w[1] * b[1];
78 target[2] = w[0] * a[2] + w[1] * b[2];
79
80 return true;
81}
82
83void interp_v3_v3v3_slerp_safe(float target[3], const float a[3], const float b[3], const float t)
84{
85 if (!interp_v3_v3v3_slerp(target, a, b, t)) [[unlikely]] {
86 /* Axis are aligned so any orthogonal vector is acceptable. */
87 float ab_ortho[3];
88 ortho_v3_v3(ab_ortho, a);
89 normalize_v3(ab_ortho);
90 if (t < 0.5f) {
91 if (!interp_v3_v3v3_slerp(target, a, ab_ortho, t * 2.0f)) [[unlikely]] {
92 BLI_assert(0);
93 copy_v3_v3(target, a);
94 }
95 }
96 else {
97 if (!interp_v3_v3v3_slerp(target, ab_ortho, b, (t - 0.5f) * 2.0f)) [[unlikely]] {
98 BLI_assert(0);
99 copy_v3_v3(target, b);
100 }
101 }
102 }
103}
104
106 const float v1[2],
107 const float v2[2],
108 const float v3[2],
109 const float v4[2],
110 const float u)
111{
112 float q0[2], q1[2], q2[2], r0[2], r1[2];
113
114 interp_v2_v2v2(q0, v1, v2, u);
115 interp_v2_v2v2(q1, v2, v3, u);
116 interp_v2_v2v2(q2, v3, v4, u);
117
118 interp_v2_v2v2(r0, q0, q1, u);
119 interp_v2_v2v2(r1, q1, q2, u);
120
121 interp_v2_v2v2(p, r0, r1, u);
122}
123
125 float p[3], const float v1[3], const float v2[3], const float v3[3], const float w[3])
126{
127 p[0] = v1[0] * w[0] + v2[0] * w[1] + v3[0] * w[2];
128 p[1] = v1[1] * w[0] + v2[1] * w[1] + v3[1] * w[2];
129 p[2] = v1[2] * w[0] + v2[2] * w[1] + v3[2] * w[2];
130}
131
132void interp_v3_v3v3v3v3(float p[3],
133 const float v1[3],
134 const float v2[3],
135 const float v3[3],
136 const float v4[3],
137 const float w[4])
138{
139 p[0] = v1[0] * w[0] + v2[0] * w[1] + v3[0] * w[2] + v4[0] * w[3];
140 p[1] = v1[1] * w[0] + v2[1] * w[1] + v3[1] * w[2] + v4[1] * w[3];
141 p[2] = v1[2] * w[0] + v2[2] * w[1] + v3[2] * w[2] + v4[2] * w[3];
142}
143
145 float p[4], const float v1[4], const float v2[4], const float v3[4], const float w[3])
146{
147 p[0] = v1[0] * w[0] + v2[0] * w[1] + v3[0] * w[2];
148 p[1] = v1[1] * w[0] + v2[1] * w[1] + v3[1] * w[2];
149 p[2] = v1[2] * w[0] + v2[2] * w[1] + v3[2] * w[2];
150 p[3] = v1[3] * w[0] + v2[3] * w[1] + v3[3] * w[2];
151}
152
153void interp_v4_v4v4v4v4(float p[4],
154 const float v1[4],
155 const float v2[4],
156 const float v3[4],
157 const float v4[4],
158 const float w[4])
159{
160 p[0] = v1[0] * w[0] + v2[0] * w[1] + v3[0] * w[2] + v4[0] * w[3];
161 p[1] = v1[1] * w[0] + v2[1] * w[1] + v3[1] * w[2] + v4[1] * w[3];
162 p[2] = v1[2] * w[0] + v2[2] * w[1] + v3[2] * w[2] + v4[2] * w[3];
163 p[3] = v1[3] * w[0] + v2[3] * w[1] + v3[3] * w[2] + v4[3] * w[3];
164}
165
167 float p[3], const float v1[3], const float v2[3], const float v3[3], const float uv[2])
168{
169 p[0] = v1[0] + ((v2[0] - v1[0]) * uv[0]) + ((v3[0] - v1[0]) * uv[1]);
170 p[1] = v1[1] + ((v2[1] - v1[1]) * uv[0]) + ((v3[1] - v1[1]) * uv[1]);
171 p[2] = v1[2] + ((v2[2] - v1[2]) * uv[0]) + ((v3[2] - v1[2]) * uv[1]);
172}
173
174void interp_v3_v3v3_uchar(uchar target[3], const uchar a[3], const uchar b[3], const float t)
175{
176 const float s = 1.0f - t;
177
178 target[0] = char(floorf(s * a[0] + t * b[0]));
179 target[1] = char(floorf(s * a[1] + t * b[1]));
180 target[2] = char(floorf(s * a[2] + t * b[2]));
181}
182
183void mid_v3_v3v3(float r[3], const float a[3], const float b[3])
184{
185 r[0] = 0.5f * (a[0] + b[0]);
186 r[1] = 0.5f * (a[1] + b[1]);
187 r[2] = 0.5f * (a[2] + b[2]);
188}
189
190void mid_v2_v2v2(float r[2], const float a[2], const float b[2])
191{
192 r[0] = 0.5f * (a[0] + b[0]);
193 r[1] = 0.5f * (a[1] + b[1]);
194}
195
196void mid_v2_v2v2v2(float v[2], const float v1[2], const float v2[2], const float v3[2])
197{
198 v[0] = (v1[0] + v2[0] + v3[0]) / 3.0f;
199 v[1] = (v1[1] + v2[1] + v3[1]) / 3.0f;
200}
201
202void mid_v3_v3v3v3(float v[3], const float v1[3], const float v2[3], const float v3[3])
203{
204 v[0] = (v1[0] + v2[0] + v3[0]) / 3.0f;
205 v[1] = (v1[1] + v2[1] + v3[1]) / 3.0f;
206 v[2] = (v1[2] + v2[2] + v3[2]) / 3.0f;
207}
208
210 float v[3], const float v1[3], const float v2[3], const float v3[3], const float v4[3])
211{
212 v[0] = (v1[0] + v2[0] + v3[0] + v4[0]) / 4.0f;
213 v[1] = (v1[1] + v2[1] + v3[1] + v4[1]) / 4.0f;
214 v[2] = (v1[2] + v2[2] + v3[2] + v4[2]) / 4.0f;
215}
216
217void mid_v3_v3_array(float r[3], const float (*vec_arr)[3], const uint vec_arr_num)
218{
219 const float factor = 1.0f / float(vec_arr_num);
220 zero_v3(r);
221
222 for (uint i = 0; i < vec_arr_num; i++) {
223 madd_v3_v3fl(r, vec_arr[i], factor);
224 }
225}
226
227void mid_v3_v3v3_angle_weighted(float r[3], const float a[3], const float b[3])
228{
229 /* trick, we want the middle of 2 normals as well as the angle between them
230 * avoid multiple calculations by */
231 float angle;
232
233 /* double check they are normalized */
236
237 add_v3_v3v3(r, a, b);
238 angle = (float(M_2_PI) *
239 /* normally we would only multiply by 2,
240 * but instead of an angle make this 0-1 factor */
241 2.0f) *
242 acosf(normalize_v3(r) / 2.0f);
243 mul_v3_fl(r, angle);
244}
245
247
248/* -------------------------------------------------------------------- */
251
252float angle_v3v3v3(const float a[3], const float b[3], const float c[3])
253{
254 float vec1[3], vec2[3];
255
256 sub_v3_v3v3(vec1, b, a);
257 sub_v3_v3v3(vec2, b, c);
258 normalize_v3(vec1);
259 normalize_v3(vec2);
260
261 return angle_normalized_v3v3(vec1, vec2);
262}
263
264float cos_v3v3v3(const float p1[3], const float p2[3], const float p3[3])
265{
266 float vec1[3], vec2[3];
267
268 sub_v3_v3v3(vec1, p2, p1);
269 sub_v3_v3v3(vec2, p2, p3);
270 normalize_v3(vec1);
271 normalize_v3(vec2);
272
273 return dot_v3v3(vec1, vec2);
274}
275
276float angle_v3v3(const float a[3], const float b[3])
277{
278 float vec1[3], vec2[3];
279
280 normalize_v3_v3(vec1, a);
281 normalize_v3_v3(vec2, b);
282
283 return angle_normalized_v3v3(vec1, vec2);
284}
285
286float angle_v2v2v2(const float a[2], const float b[2], const float c[2])
287{
288 float vec1[2], vec2[2];
289
290 vec1[0] = b[0] - a[0];
291 vec1[1] = b[1] - a[1];
292
293 vec2[0] = b[0] - c[0];
294 vec2[1] = b[1] - c[1];
295
296 normalize_v2(vec1);
297 normalize_v2(vec2);
298
299 return angle_normalized_v2v2(vec1, vec2);
300}
301
302float cos_v2v2v2(const float p1[2], const float p2[2], const float p3[2])
303{
304 float vec1[2], vec2[2];
305
306 sub_v2_v2v2(vec1, p2, p1);
307 sub_v2_v2v2(vec2, p2, p3);
308 normalize_v2(vec1);
309 normalize_v2(vec2);
310
311 return dot_v2v2(vec1, vec2);
312}
313
314float angle_v2v2(const float a[2], const float b[2])
315{
316 float vec1[2], vec2[2];
317
318 vec1[0] = a[0];
319 vec1[1] = a[1];
320
321 vec2[0] = b[0];
322 vec2[1] = b[1];
323
324 normalize_v2(vec1);
325 normalize_v2(vec2);
326
327 return angle_normalized_v2v2(vec1, vec2);
328}
329
330float angle_signed_v2v2(const float v1[2], const float v2[2])
331{
332 const float perp_dot = (v1[1] * v2[0]) - (v1[0] * v2[1]);
333 return atan2f(perp_dot, dot_v2v2(v1, v2));
334}
335
336float angle_normalized_v3v3(const float v1[3], const float v2[3])
337{
338 /* double check they are normalized */
341
342 /* this is the same as acos(dot_v3v3(v1, v2)), but more accurate */
343 if (dot_v3v3(v1, v2) >= 0.0f) {
344 return 2.0f * safe_asinf(len_v3v3(v1, v2) / 2.0f);
345 }
346
347 float v2_n[3];
348 negate_v3_v3(v2_n, v2);
349 return float(M_PI) - 2.0f * safe_asinf(len_v3v3(v1, v2_n) / 2.0f);
350}
351
352float angle_normalized_v2v2(const float a[2], const float b[2])
353{
354 /* double check they are normalized */
357
358 /* this is the same as acos(dot_v3v3(v1, v2)), but more accurate */
359 if (dot_v2v2(a, b) >= 0.0f) {
360 return 2.0f * safe_asinf(len_v2v2(a, b) / 2.0f);
361 }
362
363 float v2_n[2];
364 negate_v2_v2(v2_n, b);
365 return float(M_PI) - 2.0f * safe_asinf(len_v2v2(a, v2_n) / 2.0f);
366}
367
368float angle_on_axis_v3v3_v3(const float v1[3], const float v2[3], const float axis[3])
369{
370 float v1_proj[3], v2_proj[3];
371
372 /* project the vectors onto the axis */
373 project_plane_normalized_v3_v3v3(v1_proj, v1, axis);
374 project_plane_normalized_v3_v3v3(v2_proj, v2, axis);
375
376 return angle_v3v3(v1_proj, v2_proj);
377}
378
379float angle_signed_on_axis_v3v3_v3(const float v1[3], const float v2[3], const float axis[3])
380{
381 float v1_proj[3], v2_proj[3], tproj[3];
382 float angle;
383
384 /* project the vectors onto the axis */
385 project_plane_normalized_v3_v3v3(v1_proj, v1, axis);
386 project_plane_normalized_v3_v3v3(v2_proj, v2, axis);
387
388 angle = angle_v3v3(v1_proj, v2_proj);
389
390 /* calculate the sign (reuse 'tproj') */
391 cross_v3_v3v3(tproj, v2_proj, v1_proj);
392 if (dot_v3v3(tproj, axis) < 0.0f) {
393 angle = float(M_PI * 2.0) - angle;
394 }
395
396 return angle;
397}
398
399float angle_on_axis_v3v3v3_v3(const float v1[3],
400 const float v2[3],
401 const float v3[3],
402 const float axis[3])
403{
404 float vec1[3], vec2[3];
405
406 sub_v3_v3v3(vec1, v1, v2);
407 sub_v3_v3v3(vec2, v3, v2);
408
409 return angle_on_axis_v3v3_v3(vec1, vec2, axis);
410}
411
412float angle_signed_on_axis_v3v3v3_v3(const float v1[3],
413 const float v2[3],
414 const float v3[3],
415 const float axis[3])
416{
417 float vec1[3], vec2[3];
418
419 sub_v3_v3v3(vec1, v1, v2);
420 sub_v3_v3v3(vec2, v3, v2);
421
422 return angle_signed_on_axis_v3v3_v3(vec1, vec2, axis);
423}
424
425void angle_tri_v3(float angles[3], const float v1[3], const float v2[3], const float v3[3])
426{
427 float ed1[3], ed2[3], ed3[3];
428
429 sub_v3_v3v3(ed1, v3, v1);
430 sub_v3_v3v3(ed2, v1, v2);
431 sub_v3_v3v3(ed3, v2, v3);
432
433 normalize_v3(ed1);
434 normalize_v3(ed2);
435 normalize_v3(ed3);
436
437 angles[0] = float(M_PI) - angle_normalized_v3v3(ed1, ed2);
438 angles[1] = float(M_PI) - angle_normalized_v3v3(ed2, ed3);
439 // face_angles[2] = M_PI - angle_normalized_v3v3(ed3, ed1);
440 angles[2] = float(M_PI) - (angles[0] + angles[1]);
441}
442
444 float angles[4], const float v1[3], const float v2[3], const float v3[3], const float v4[3])
445{
446 float ed1[3], ed2[3], ed3[3], ed4[3];
447
448 sub_v3_v3v3(ed1, v4, v1);
449 sub_v3_v3v3(ed2, v1, v2);
450 sub_v3_v3v3(ed3, v2, v3);
451 sub_v3_v3v3(ed4, v3, v4);
452
453 normalize_v3(ed1);
454 normalize_v3(ed2);
455 normalize_v3(ed3);
456 normalize_v3(ed4);
457
458 angles[0] = float(M_PI) - angle_normalized_v3v3(ed1, ed2);
459 angles[1] = float(M_PI) - angle_normalized_v3v3(ed2, ed3);
460 angles[2] = float(M_PI) - angle_normalized_v3v3(ed3, ed4);
461 angles[3] = float(M_PI) - angle_normalized_v3v3(ed4, ed1);
462}
463
464void angle_poly_v3(float *angles, const float *verts[3], int len)
465{
466 int i;
467 float vec[3][3];
468
469 sub_v3_v3v3(vec[2], verts[len - 1], verts[0]);
470 normalize_v3(vec[2]);
471 for (i = 0; i < len; i++) {
472 sub_v3_v3v3(vec[i % 3], verts[i % len], verts[(i + 1) % len]);
473 normalize_v3(vec[i % 3]);
474 angles[i] = float(M_PI) - angle_normalized_v3v3(vec[(i + 2) % 3], vec[i % 3]);
475 }
476}
477
479
480/* -------------------------------------------------------------------- */
483
484void project_v2_v2v2(float out[2], const float p[2], const float v_proj[2])
485{
486 if (is_zero_v2(v_proj)) [[unlikely]] {
487 zero_v2(out);
488 return;
489 }
490
491 const float mul = dot_v2v2(p, v_proj) / dot_v2v2(v_proj, v_proj);
492 mul_v2_v2fl(out, v_proj, mul);
493}
494
495void project_v3_v3v3(float out[3], const float p[3], const float v_proj[3])
496{
497 if (is_zero_v3(v_proj)) [[unlikely]] {
498 zero_v3(out);
499 return;
500 }
501
502 const float mul = dot_v3v3(p, v_proj) / dot_v3v3(v_proj, v_proj);
503 mul_v3_v3fl(out, v_proj, mul);
504}
505
506void project_v2_v2v2_normalized(float out[2], const float p[2], const float v_proj[2])
507{
508 BLI_ASSERT_UNIT_V2(v_proj);
509
510 const float mul = dot_v2v2(p, v_proj);
511 mul_v2_v2fl(out, v_proj, mul);
512}
513
514void project_v3_v3v3_normalized(float out[3], const float p[3], const float v_proj[3])
515{
516 BLI_ASSERT_UNIT_V3(v_proj);
517
518 const float mul = dot_v3v3(p, v_proj);
519 mul_v3_v3fl(out, v_proj, mul);
520}
521
522void project_plane_v3_v3v3(float out[3], const float p[3], const float v_plane[3])
523{
524 const float mul = dot_v3v3(p, v_plane) / dot_v3v3(v_plane, v_plane);
525 /* out[x] = p[x] - (mul * v_plane[x]) */
526 madd_v3_v3v3fl(out, p, v_plane, -mul);
527}
528
529void project_plane_normalized_v3_v3v3(float out[3], const float p[3], const float v_plane[3])
530{
531 BLI_ASSERT_UNIT_V3(v_plane);
532 const float mul = dot_v3v3(p, v_plane);
533 /* out[x] = p[x] - (mul * v_plane[x]) */
534 madd_v3_v3v3fl(out, p, v_plane, -mul);
535}
536
537void project_v3_plane(float out[3], const float plane_no[3], const float plane_co[3])
538{
539 float vector[3];
540 float mul;
541
542 sub_v3_v3v3(vector, out, plane_co);
543 mul = dot_v3v3(vector, plane_no) / len_squared_v3(plane_no);
544
545 /* out[x] = out[x] - (mul * plane_no[x]) */
546 madd_v3_v3fl(out, plane_no, -mul);
547}
548
549void bisect_v3_v3v3v3(float r[3], const float a[3], const float b[3], const float c[3])
550{
551 float d_12[3], d_23[3];
552 sub_v3_v3v3(d_12, b, a);
553 sub_v3_v3v3(d_23, c, b);
554 normalize_v3(d_12);
555 normalize_v3(d_23);
556 add_v3_v3v3(r, d_12, d_23);
557 normalize_v3(r);
558}
559
560void reflect_v3_v3v3(float out[3], const float v[3], const float normal[3])
561{
562 BLI_ASSERT_UNIT_V3(normal);
563 const float dot2 = 2.0f * dot_v3v3(v, normal);
564 /* out[x] = v[x] - (dot2 * normal[x]) */
565 madd_v3_v3v3fl(out, v, normal, -dot2);
566}
567
568void ortho_basis_v3v3_v3(float r_n1[3], float r_n2[3], const float n[3])
569{
570 const float eps = FLT_EPSILON;
571 const float f = len_squared_v2(n);
572
573 if (f > eps) {
574 const float d = 1.0f / sqrtf(f);
575
576 BLI_assert(isfinite(d));
577
578 r_n1[0] = n[1] * d;
579 r_n1[1] = -n[0] * d;
580 r_n1[2] = 0.0f;
581 r_n2[0] = -n[2] * r_n1[1];
582 r_n2[1] = n[2] * r_n1[0];
583 r_n2[2] = n[0] * r_n1[1] - n[1] * r_n1[0];
584 }
585 else {
586 /* degenerate case */
587 r_n1[0] = (n[2] < 0.0f) ? -1.0f : 1.0f;
588 r_n1[1] = r_n1[2] = r_n2[0] = r_n2[2] = 0.0f;
589 r_n2[1] = 1.0f;
590 }
591}
592
593void ortho_v3_v3(float out[3], const float v[3])
594{
595 const int axis = axis_dominant_v3_single(v);
596
597 BLI_assert(out != v);
598
599 switch (axis) {
600 case 0:
601 out[0] = -v[1] - v[2];
602 out[1] = v[0];
603 out[2] = v[0];
604 break;
605 case 1:
606 out[0] = v[1];
607 out[1] = -v[0] - v[2];
608 out[2] = v[1];
609 break;
610 case 2:
611 out[0] = v[2];
612 out[1] = v[2];
613 out[2] = -v[0] - v[1];
614 break;
615 }
616}
617
618void ortho_v2_v2(float out[2], const float v[2])
619{
620 BLI_assert(out != v);
621
622 out[0] = -v[1];
623 out[1] = v[0];
624}
625
626void rotate_v2_v2fl(float r[2], const float p[2], const float angle)
627{
628 const float co = cosf(angle);
629 const float si = sinf(angle);
630
631 BLI_assert(r != p);
632
633 r[0] = co * p[0] - si * p[1];
634 r[1] = si * p[0] + co * p[1];
635}
636
638 const float p[3],
639 const float axis[3],
640 const float angle)
641{
642 const float costheta = cosf(angle);
643 const float sintheta = sinf(angle);
644
645 /* double check they are normalized */
646 BLI_ASSERT_UNIT_V3(axis);
647
648 out[0] = ((costheta + (1 - costheta) * axis[0] * axis[0]) * p[0]) +
649 (((1 - costheta) * axis[0] * axis[1] - axis[2] * sintheta) * p[1]) +
650 (((1 - costheta) * axis[0] * axis[2] + axis[1] * sintheta) * p[2]);
651
652 out[1] = (((1 - costheta) * axis[0] * axis[1] + axis[2] * sintheta) * p[0]) +
653 ((costheta + (1 - costheta) * axis[1] * axis[1]) * p[1]) +
654 (((1 - costheta) * axis[1] * axis[2] - axis[0] * sintheta) * p[2]);
655
656 out[2] = (((1 - costheta) * axis[0] * axis[2] - axis[1] * sintheta) * p[0]) +
657 (((1 - costheta) * axis[1] * axis[2] + axis[0] * sintheta) * p[1]) +
658 ((costheta + (1 - costheta) * axis[2] * axis[2]) * p[2]);
659}
660
661void rotate_v3_v3v3fl(float r[3], const float p[3], const float axis[3], const float angle)
662{
663 BLI_assert(r != p);
664
665 float axis_n[3];
666
667 normalize_v3_v3(axis_n, axis);
668
669 rotate_normalized_v3_v3v3fl(r, p, axis_n, angle);
670}
671
673
674/* -------------------------------------------------------------------- */
677
678void print_v2(const char *str, const float v[2])
679{
680 printf("%s: %.8f %.8f\n", str, v[0], v[1]);
681}
682
683void print_v3(const char *str, const float v[3])
684{
685 printf("%s: %.8f %.8f %.8f\n", str, v[0], v[1], v[2]);
686}
687
688void print_v4(const char *str, const float v[4])
689{
690 printf("%s: %.8f %.8f %.8f %.8f\n", str, v[0], v[1], v[2], v[3]);
691}
692
693void print_vn(const char *str, const float v[], const int n)
694{
695 int i = 0;
696 printf("%s[%d]:", str, n);
697 while (i < n) {
698 printf(" %.8f", v[i++]);
699 }
700 printf("\n");
701}
702
703void minmax_v4v4_v4(float min[4], float max[4], const float vec[4])
704{
705 min[0] = std::min(min[0], vec[0]);
706 min[1] = std::min(min[1], vec[1]);
707 min[2] = std::min(min[2], vec[2]);
708 min[3] = std::min(min[3], vec[3]);
709
710 max[0] = std::max(max[0], vec[0]);
711 max[1] = std::max(max[1], vec[1]);
712 max[2] = std::max(max[2], vec[2]);
713 max[3] = std::max(max[3], vec[3]);
714}
715
716void minmax_v3v3_v3(float min[3], float max[3], const float vec[3])
717{
718 min[0] = std::min(min[0], vec[0]);
719 min[1] = std::min(min[1], vec[1]);
720 min[2] = std::min(min[2], vec[2]);
721
722 max[0] = std::max(max[0], vec[0]);
723 max[1] = std::max(max[1], vec[1]);
724 max[2] = std::max(max[2], vec[2]);
725}
726
727void minmax_v2v2_v2(float min[2], float max[2], const float vec[2])
728{
729 min[0] = std::min(min[0], vec[0]);
730 min[1] = std::min(min[1], vec[1]);
731
732 max[0] = std::max(max[0], vec[0]);
733 max[1] = std::max(max[1], vec[1]);
734}
735
736void dist_ensure_v3_v3fl(float v1[3], const float v2[3], const float dist)
737{
738 if (!equals_v3v3(v2, v1)) {
739 float nor[3];
740
741 sub_v3_v3v3(nor, v1, v2);
742 normalize_v3(nor);
743 madd_v3_v3v3fl(v1, v2, nor, dist);
744 }
745}
746
747void dist_ensure_v2_v2fl(float v1[2], const float v2[2], const float dist)
748{
749 if (!equals_v2v2(v2, v1)) {
750 float nor[2];
751
752 sub_v2_v2v2(nor, v1, v2);
753 normalize_v2(nor);
754 madd_v2_v2v2fl(v1, v2, nor, dist);
755 }
756}
757
758void axis_sort_v3(const float axis_values[3], int r_axis_order[3])
759{
760 float v[3];
761 copy_v3_v3(v, axis_values);
762
763#define SWAP_AXIS(a, b) \
764 { \
765 SWAP(float, v[a], v[b]); \
766 SWAP(int, r_axis_order[a], r_axis_order[b]); \
767 } \
768 (void)0
769
770 if (v[0] < v[1]) {
771 if (v[2] < v[0]) {
772 SWAP_AXIS(0, 2);
773 }
774 }
775 else {
776 if (v[1] < v[2]) {
777 SWAP_AXIS(0, 1);
778 }
779 else {
780 SWAP_AXIS(0, 2);
781 }
782 }
783 if (v[2] < v[1]) {
784 SWAP_AXIS(1, 2);
785 }
786
787#undef SWAP_AXIS
788}
789
791
792/* -------------------------------------------------------------------- */
795
796MINLINE double sqr_db(double f)
797{
798 return f * f;
799}
800
801double dot_vn_vn(const float *array_src_a, const float *array_src_b, const int size)
802{
803 double d = 0.0f;
804 const float *array_pt_a = array_src_a + (size - 1);
805 const float *array_pt_b = array_src_b + (size - 1);
806 int i = size;
807 while (i--) {
808 d += double(*(array_pt_a--) * *(array_pt_b--));
809 }
810 return d;
811}
812
813double len_squared_vn(const float *array, const int size)
814{
815 double d = 0.0f;
816 const float *array_pt = array + (size - 1);
817 int i = size;
818 while (i--) {
819 d += sqr_db(double(*(array_pt)--));
820 }
821 return d;
822}
823
824float normalize_vn_vn(float *array_tar, const float *array_src, const int size)
825{
826 const double d = len_squared_vn(array_src, size);
827 float d_sqrt;
828 if (d > 1.0e-35) {
829 d_sqrt = float(sqrt(d));
830 mul_vn_vn_fl(array_tar, array_src, size, 1.0f / d_sqrt);
831 }
832 else {
833 std::fill_n(array_tar, size, 0.0f);
834 d_sqrt = 0.0f;
835 }
836 return d_sqrt;
837}
838
839float normalize_vn(float *array_tar, const int size)
840{
841 return normalize_vn_vn(array_tar, array_tar, size);
842}
843
844void range_vn_fl(float *array_tar, const int size, const float start, const float step)
845{
846 float *array_pt = array_tar + (size - 1);
847 int i = size;
848 while (i--) {
849 *(array_pt--) = start + step * float(i);
850 }
851}
852
853void negate_vn(float *array_tar, const int size)
854{
855 float *array_pt = array_tar + (size - 1);
856 int i = size;
857 while (i--) {
858 *(array_pt--) *= -1.0f;
859 }
860}
861
862void negate_vn_vn(float *array_tar, const float *array_src, const int size)
863{
864 float *tar = array_tar + (size - 1);
865 const float *src = array_src + (size - 1);
866 int i = size;
867 while (i--) {
868 *(tar--) = -*(src--);
869 }
870}
871
872void mul_vn_vn(float *array_tar, const float *array_src, const int size)
873{
874 float *tar = array_tar + (size - 1);
875 const float *src = array_src + (size - 1);
876 int i = size;
877 while (i--) {
878 *(tar--) *= *(src--);
879 }
880}
881
882void mul_vn_vnvn(float *array_tar,
883 const float *array_src_a,
884 const float *array_src_b,
885 const int size)
886{
887 float *tar = array_tar + (size - 1);
888 const float *src_a = array_src_a + (size - 1);
889 const float *src_b = array_src_b + (size - 1);
890 int i = size;
891 while (i--) {
892 *(tar--) = *(src_a--) * *(src_b--);
893 }
894}
895
896void mul_vn_fl(float *array_tar, const int size, const float f)
897{
898 float *array_pt = array_tar + (size - 1);
899 int i = size;
900 while (i--) {
901 *(array_pt--) *= f;
902 }
903}
904
905void mul_vn_vn_fl(float *array_tar, const float *array_src, const int size, const float f)
906{
907 float *tar = array_tar + (size - 1);
908 const float *src = array_src + (size - 1);
909 int i = size;
910 while (i--) {
911 *(tar--) = *(src--) * f;
912 }
913}
914
915void add_vn_vn(float *array_tar, const float *array_src, const int size)
916{
917 float *tar = array_tar + (size - 1);
918 const float *src = array_src + (size - 1);
919 int i = size;
920 while (i--) {
921 *(tar--) += *(src--);
922 }
923}
924
925void add_vn_vnvn(float *array_tar,
926 const float *array_src_a,
927 const float *array_src_b,
928 const int size)
929{
930 float *tar = array_tar + (size - 1);
931 const float *src_a = array_src_a + (size - 1);
932 const float *src_b = array_src_b + (size - 1);
933 int i = size;
934 while (i--) {
935 *(tar--) = *(src_a--) + *(src_b--);
936 }
937}
938
939void sub_vn_vn(float *array_tar, const float *array_src, const int size)
940{
941 float *tar = array_tar + (size - 1);
942 const float *src = array_src + (size - 1);
943 int i = size;
944 while (i--) {
945 *(tar--) -= *(src--);
946 }
947}
948
949void sub_vn_vnvn(float *array_tar,
950 const float *array_src_a,
951 const float *array_src_b,
952 const int size)
953{
954 float *tar = array_tar + (size - 1);
955 const float *src_a = array_src_a + (size - 1);
956 const float *src_b = array_src_b + (size - 1);
957 int i = size;
958 while (i--) {
959 *(tar--) = *(src_a--) - *(src_b--);
960 }
961}
962
963void interp_vn_vn(float *array_tar, const float *array_src, const float t, const int size)
964{
965 const float s = 1.0f - t;
966 float *tar = array_tar + (size - 1);
967 const float *src = array_src + (size - 1);
968 int i = size;
969 while (i--) {
970 *(tar) = (s * *(tar)) + (t * *(src));
971 tar--;
972 src--;
973 }
974}
975
977
978/* -------------------------------------------------------------------- */
981
982void add_vn_vn_d(double *array_tar, const double *array_src, const int size)
983{
984 double *tar = array_tar + (size - 1);
985 const double *src = array_src + (size - 1);
986 int i = size;
987 while (i--) {
988 *(tar--) += *(src--);
989 }
990}
991
992void add_vn_vnvn_d(double *array_tar,
993 const double *array_src_a,
994 const double *array_src_b,
995 const int size)
996{
997 double *tar = array_tar + (size - 1);
998 const double *src_a = array_src_a + (size - 1);
999 const double *src_b = array_src_b + (size - 1);
1000 int i = size;
1001 while (i--) {
1002 *(tar--) = *(src_a--) + *(src_b--);
1003 }
1004}
1005
1006void mul_vn_db(double *array_tar, const int size, const double f)
1007{
1008 double *array_pt = array_tar + (size - 1);
1009 int i = size;
1010 while (i--) {
1011 *(array_pt--) *= f;
1012 }
1013}
1014
1015void interp_v3_v3v3_db(double target[3], const double a[3], const double b[3], const double t)
1016{
1017 const double s = 1.0f - t;
1018
1019 target[0] = s * a[0] + t * b[0];
1020 target[1] = s * a[1] + t * b[1];
1021 target[2] = s * a[2] + t * b[2];
1022}
1023
1024void interp_v2_v2v2_db(double target[2], const double a[2], const double b[2], const double t)
1025{
1026 const double s = 1.0f - t;
1027
1028 target[0] = s * a[0] + t * b[0];
1029 target[1] = s * a[1] + t * b[1];
1030}
1031
1033
1034} // namespace blender
#define BLI_ASSERT_UNIT_V2(v)
#define BLI_ASSERT_UNIT_V3(v)
#define M_PI
#define MINLINE
btScalar max
SIMD_FORCE_INLINE const btScalar & w() const
Return the w value.
Definition btQuadWord.h:119
SIMD_FORCE_INLINE btScalar angle(const btVector3 &v) const
Return the angle between this and another vector.
Definition btVector3.h:356
#define acosf(x)
#define str(s)
#define FLT_EPSILON
VecBase< float, D > step(VecOp< float, D >, VecOp< float, D >) RET
ccl_device_inline dual1 len(const ccl_private dual< T > &a)
Definition math_dual.h:263
#define SWAP_AXIS(a, b)
BMesh Iterators.
MINLINE void madd_v3_v3v3fl(float r[3], const float a[3], const float b[3], float f)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
void mul_vn_fl(float *array_tar, int size, float f)
MINLINE void negate_v3_v3(float r[3], const float a[3])
void mid_v3_v3v3_angle_weighted(float r[3], const float a[3], const float b[3])
float angle_normalized_v3v3(const float v1[3], const float v2[3]) ATTR_WARN_UNUSED_RESULT
float normalize_vn_vn(float *array_tar, const float *array_src, int size)
void mid_v2_v2v2v2(float v[2], const float v1[2], const float v2[2], const float v3[2])
void angle_quad_v3(float angles[4], const float v1[3], const float v2[3], const float v3[3], const float v4[3])
MINLINE bool is_zero_v2(const float v[2]) ATTR_WARN_UNUSED_RESULT
bool interp_v3_v3v3_slerp(float target[3], const float a[3], const float b[3], float t) ATTR_WARN_UNUSED_RESULT
MINLINE float safe_asinf(float a)
void rotate_normalized_v3_v3v3fl(float out[3], const float p[3], const float axis[3], float angle)
void interp_v4_v4v4v4(float p[4], const float v1[4], const float v2[4], const float v3[4], const float w[3])
void mid_v3_v3v3v3v3(float v[3], const float v1[3], const float v2[3], const float v3[3], const float v4[3])
MINLINE void copy_v3_v3(float r[3], const float a[3])
unsigned int uint
Definition BKE_text.h:55
void sub_vn_vnvn(float *array_tar, const float *array_src_a, const float *array_src_b, int size)
float angle_v2v2v2(const float a[2], const float b[2], const float c[2]) ATTR_WARN_UNUSED_RESULT
void minmax_v3v3_v3(float min[3], float max[3], const float vec[3])
void add_vn_vn(float *array_tar, const float *array_src, int size)
MINLINE void add_v3_v3v3(float r[3], const float a[3], const float b[3])
float normalize_vn(float *array_tar, int size)
void mid_v3_v3v3v3(float v[3], const float v1[3], const float v2[3], const float v3[3])
void mul_vn_vn_fl(float *array_tar, const float *array_src, int size, float f)
MINLINE double sqr_db(double f)
void interp_v2_v2v2v2(float r[2], const float a[2], const float b[2], const float c[2], const float t[3])
void interp_v4_v4v4(float r[4], const float a[4], const float b[4], float t)
MINLINE void negate_v2_v2(float r[2], const float a[2])
void project_v3_v3v3_normalized(float out[3], const float p[3], const float v_proj[3])
void mul_vn_db(double *array_tar, int size, double f)
float angle_v3v3v3(const float a[3], const float b[3], const float c[3]) ATTR_WARN_UNUSED_RESULT
void print_vn(const char *str, const float v[], int n)
void project_v2_v2v2_normalized(float out[2], const float p[2], const float v_proj[2])
void project_v3_plane(float out[3], const float plane_no[3], const float plane_co[3])
float angle_v3v3(const float a[3], const float b[3]) ATTR_WARN_UNUSED_RESULT
void angle_tri_v3(float angles[3], const float v1[3], const float v2[3], const float v3[3])
void ortho_v2_v2(float out[2], const float v[2])
float angle_signed_v2v2(const float v1[2], const float v2[2]) ATTR_WARN_UNUSED_RESULT
MINLINE void sub_v2_v2v2(float r[2], const float a[2], const float b[2])
void interp_v2_v2v2_db(double target[2], const double a[2], const double b[2], double t)
void interp_vn_vn(float *array_tar, const float *array_src, float t, int size)
MINLINE float normalize_v2(float n[2])
void interp_dot_slerp(float t, float cosom, float r_w[2])
void project_plane_normalized_v3_v3v3(float out[3], const float p[3], const float v_plane[3])
ATTR_WARN_UNUSED_RESULT const BMVert * v
void add_vn_vn_d(double *array_tar, const double *array_src, int size)
void print_v3(const char *str, const float v[3])
void range_vn_fl(float *array_tar, int size, float start, float step)
float angle_signed_on_axis_v3v3_v3(const float v1[3], const float v2[3], const float axis[3]) ATTR_WARN_UNUSED_RESULT
MINLINE void mul_v3_fl(float r[3], float f)
void project_v3_v3v3(float out[3], const float p[3], const float v_proj[3])
float angle_on_axis_v3v3v3_v3(const float v1[3], const float v2[3], const float v3[3], const float axis[3]) ATTR_WARN_UNUSED_RESULT
MINLINE void madd_v3_v3fl(float r[3], const float a[3], float f)
MINLINE bool equals_v3v3(const float v1[3], const float v2[3]) ATTR_WARN_UNUSED_RESULT
float angle_normalized_v2v2(const float a[2], const float b[2]) ATTR_WARN_UNUSED_RESULT
void interp_v3_v3v3v3_uv(float p[3], const float v1[3], const float v2[3], const float v3[3], const float uv[2])
unsigned char uchar
Definition BKE_text.h:58
double dot_vn_vn(const float *array_src_a, const float *array_src_b, int size) ATTR_WARN_UNUSED_RESULT
void dist_ensure_v3_v3fl(float v1[3], const float v2[3], float dist)
float angle_signed_on_axis_v3v3v3_v3(const float v1[3], const float v2[3], const float v3[3], const float axis[3]) ATTR_WARN_UNUSED_RESULT
MINLINE void cross_v3_v3v3(float r[3], const float a[3], const float b[3])
void rotate_v2_v2fl(float r[2], const float p[2], float angle)
void minmax_v2v2_v2(float min[2], float max[2], const float vec[2])
MINLINE int axis_dominant_v3_single(const float vec[3])
void interp_v3_v3v3v3v3(float p[3], const float v1[3], const float v2[3], const float v3[3], const float v4[3], const float w[4])
double len_squared_vn(const float *array, int size) ATTR_WARN_UNUSED_RESULT
void project_v2_v2v2(float out[2], const float p[2], const float v_proj[2])
sqrt(x)+1/max(0
void mul_vn_vn(float *array_tar, const float *array_src, int size)
void interp_v3_v3v3(float r[3], const float a[3], const float b[3], float t)
float cos_v2v2v2(const float p1[2], const float p2[2], const float p3[2]) ATTR_WARN_UNUSED_RESULT
void minmax_v4v4_v4(float min[4], float max[4], const float vec[4])
void print_v4(const char *str, const float v[4])
MINLINE void mul_v2_v2fl(float r[2], const float a[2], float f)
MINLINE void zero_v3(float r[3])
void dist_ensure_v2_v2fl(float v1[2], const float v2[2], float dist)
MINLINE float dot_v2v2(const float a[2], const float b[2]) ATTR_WARN_UNUSED_RESULT
void reflect_v3_v3v3(float out[3], const float v[3], const float normal[3])
void add_vn_vnvn(float *array_tar, const float *array_src_a, const float *array_src_b, int size)
MINLINE bool equals_v2v2(const float v1[2], const float v2[2]) ATTR_WARN_UNUSED_RESULT
void print_v2(const char *str, const float v[2])
void ortho_v3_v3(float out[3], const float v[3])
void project_plane_v3_v3v3(float out[3], const float p[3], const float v_plane[3])
MINLINE float normalize_v3_v3(float r[3], const float a[3])
void interp_v3_v3v3_slerp_safe(float target[3], const float a[3], const float b[3], float t)
MINLINE void mul_v3_v3fl(float r[3], const float a[3], float f)
MINLINE float normalize_v3(float n[3])
MINLINE float len_squared_v2(const float v[2]) ATTR_WARN_UNUSED_RESULT
void interp_v3_v3v3_db(double target[3], const double a[3], const double b[3], double t)
MINLINE void sub_v3_v3v3(float r[3], const float a[3], const float b[3])
void mid_v3_v3v3(float r[3], const float a[3], const float b[3])
void sub_vn_vn(float *array_tar, const float *array_src, int size)
ATTR_WARN_UNUSED_RESULT const BMVert * v2
float angle_on_axis_v3v3_v3(const float v1[3], const float v2[3], const float axis[3]) ATTR_WARN_UNUSED_RESULT
void interp_v2_v2v2(float r[2], const float a[2], const float b[2], float t)
void interp_v3_v3v3_uchar(unsigned char target[3], const unsigned char a[3], const unsigned char b[3], float t)
MINLINE float len_v2v2(const float v1[2], const float v2[2]) ATTR_WARN_UNUSED_RESULT
void bisect_v3_v3v3v3(float r[3], const float a[3], const float b[3], const float c[3])
void mid_v2_v2v2(float r[2], const float a[2], const float b[2])
void negate_vn(float *array_tar, int size)
void axis_sort_v3(const float axis_values[3], int r_axis_order[3])
MINLINE float len_squared_v3(const float v[3]) ATTR_WARN_UNUSED_RESULT
void interp_v2_v2v2v2v2_cubic(float p[2], const float v1[2], const float v2[2], const float v3[2], const float v4[2], float u)
void negate_vn_vn(float *array_tar, const float *array_src, int size)
float angle_v2v2(const float a[2], const float b[2]) ATTR_WARN_UNUSED_RESULT
void mul_vn_vnvn(float *array_tar, const float *array_src_a, const float *array_src_b, int size)
void interp_v3_v3v3v3(float p[3], const float v1[3], const float v2[3], const float v3[3], const float w[3])
void ortho_basis_v3v3_v3(float r_n1[3], float r_n2[3], const float n[3])
MINLINE float len_v3v3(const float a[3], const float b[3]) ATTR_WARN_UNUSED_RESULT
void interp_v4_v4v4v4v4(float p[4], const float v1[4], const float v2[4], const float v3[4], const float v4[4], const float w[4])
MINLINE float dot_v3v3(const float a[3], const float b[3]) ATTR_WARN_UNUSED_RESULT
float cos_v3v3v3(const float p1[3], const float p2[3], const float p3[3]) ATTR_WARN_UNUSED_RESULT
MINLINE void zero_v2(float r[2])
MINLINE bool is_zero_v3(const float v[3]) ATTR_WARN_UNUSED_RESULT
void mid_v3_v3_array(float r[3], const float(*vec_arr)[3], unsigned int vec_arr_num)
void rotate_v3_v3v3fl(float r[3], const float p[3], const float axis[3], float angle)
MINLINE void madd_v2_v2v2fl(float r[2], const float a[2], const float b[2], float f)
void angle_poly_v3(float *angles, const float *verts[3], int len)
void add_vn_vnvn_d(double *array_tar, const double *array_src_a, const double *array_src_b, int size)
const btScalar eps
Definition poly34.cpp:11
#define floorf
#define sqrtf
#define sinf
#define cosf
#define atan2f
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
#define min(a, b)
Definition sort.cc:38