Merging r58196 through r58265 from trunk into soc-2013-depsgraph_mt
[blender.git] / source / blender / blenlib / intern / math_vector_inline.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
19  * All rights reserved.
20  *
21  * The Original Code is: some of this file.
22  *
23  * ***** END GPL LICENSE BLOCK *****
24  * */
25
26 /** \file blender/blenlib/intern/math_vector_inline.c
27  *  \ingroup bli
28  */
29
30 #ifndef __MATH_VECTOR_INLINE_C__
31 #define __MATH_VECTOR_INLINE_C__
32
33 #include "BLI_math.h"
34
35 /********************************** Init *************************************/
36
37 MINLINE void zero_v2(float r[2])
38 {
39         r[0] = 0.0f;
40         r[1] = 0.0f;
41 }
42
43 MINLINE void zero_v3(float r[3])
44 {
45         r[0] = 0.0f;
46         r[1] = 0.0f;
47         r[2] = 0.0f;
48 }
49
50 MINLINE void zero_v4(float r[4])
51 {
52         r[0] = 0.0f;
53         r[1] = 0.0f;
54         r[2] = 0.0f;
55         r[3] = 0.0f;
56 }
57
58 MINLINE void copy_v2_v2(float r[2], const float a[2])
59 {
60         r[0] = a[0];
61         r[1] = a[1];
62 }
63
64 MINLINE void copy_v3_v3(float r[3], const float a[3])
65 {
66         r[0] = a[0];
67         r[1] = a[1];
68         r[2] = a[2];
69 }
70
71 MINLINE void copy_v4_v4(float r[4], const float a[4])
72 {
73         r[0] = a[0];
74         r[1] = a[1];
75         r[2] = a[2];
76         r[3] = a[3];
77 }
78
79 MINLINE void copy_v2_fl(float r[2], float f)
80 {
81         r[0] = f;
82         r[1] = f;
83 }
84
85 MINLINE void copy_v3_fl(float r[3], float f)
86 {
87         r[0] = f;
88         r[1] = f;
89         r[2] = f;
90 }
91
92 MINLINE void copy_v4_fl(float r[4], float f)
93 {
94         r[0] = f;
95         r[1] = f;
96         r[2] = f;
97         r[3] = f;
98 }
99
100 /* short */
101 MINLINE void copy_v2_v2_char(char r[2], const char a[2])
102 {
103         r[0] = a[0];
104         r[1] = a[1];
105 }
106
107 MINLINE void copy_v3_v3_char(char r[3], const char a[3])
108 {
109         r[0] = a[0];
110         r[1] = a[1];
111         r[2] = a[2];
112 }
113
114 MINLINE void copy_v4_v4_char(char r[4], const char a[4])
115 {
116         r[0] = a[0];
117         r[1] = a[1];
118         r[2] = a[2];
119         r[3] = a[3];
120 }
121
122 /* short */
123 MINLINE void zero_v3_int(int r[3])
124 {
125         r[0] = 0;
126         r[1] = 0;
127         r[2] = 0;
128 }
129
130 MINLINE void copy_v2_v2_short(short r[2], const short a[2])
131 {
132         r[0] = a[0];
133         r[1] = a[1];
134 }
135
136 MINLINE void copy_v3_v3_short(short r[3], const short a[3])
137 {
138         r[0] = a[0];
139         r[1] = a[1];
140         r[2] = a[2];
141 }
142
143 MINLINE void copy_v4_v4_short(short r[4], const short a[4])
144 {
145         r[0] = a[0];
146         r[1] = a[1];
147         r[2] = a[2];
148         r[3] = a[3];
149 }
150
151 /* int */
152 MINLINE void copy_v2_v2_int(int r[2], const int a[2])
153 {
154         r[0] = a[0];
155         r[1] = a[1];
156 }
157
158 MINLINE void copy_v3_v3_int(int r[3], const int a[3])
159 {
160         r[0] = a[0];
161         r[1] = a[1];
162         r[2] = a[2];
163 }
164
165 MINLINE void copy_v4_v4_int(int r[4], const int a[4])
166 {
167         r[0] = a[0];
168         r[1] = a[1];
169         r[2] = a[2];
170         r[3] = a[3];
171 }
172
173 /* double -> float */
174 MINLINE void copy_v2fl_v2db(float r[2], const double a[2])
175 {
176         r[0] = (float)a[0];
177         r[1] = (float)a[1];
178 }
179
180 MINLINE void copy_v3fl_v3db(float r[3], const double a[3])
181 {
182         r[0] = (float)a[0];
183         r[1] = (float)a[1];
184         r[2] = (float)a[2];
185 }
186
187 MINLINE void copy_v4fl_v4db(float r[4], const double a[4])
188 {
189         r[0] = (float)a[0];
190         r[1] = (float)a[1];
191         r[2] = (float)a[2];
192         r[3] = (float)a[3];
193 }
194
195 /* float -> double */
196 MINLINE void copy_v2db_v2fl(double r[2], const float a[2])
197 {
198         r[0] = (double)a[0];
199         r[1] = (double)a[1];
200 }
201
202 MINLINE void copy_v3db_v3fl(double r[3], const float a[3])
203 {
204         r[0] = (double)a[0];
205         r[1] = (double)a[1];
206         r[2] = (double)a[2];
207 }
208
209 MINLINE void copy_v4db_v4fl(double r[4], const float a[4])
210 {
211         r[0] = (double)a[0];
212         r[1] = (double)a[1];
213         r[2] = (double)a[2];
214         r[3] = (double)a[3];
215 }
216
217 MINLINE void swap_v2_v2(float a[2], float b[2])
218 {
219         SWAP(float, a[0], b[0]);
220         SWAP(float, a[1], b[1]);
221 }
222
223 MINLINE void swap_v3_v3(float a[3], float b[3])
224 {
225         SWAP(float, a[0], b[0]);
226         SWAP(float, a[1], b[1]);
227         SWAP(float, a[2], b[2]);
228 }
229
230 MINLINE void swap_v4_v4(float a[4], float b[4])
231 {
232         SWAP(float, a[0], b[0]);
233         SWAP(float, a[1], b[1]);
234         SWAP(float, a[2], b[2]);
235         SWAP(float, a[3], b[3]);
236 }
237
238 /********************************* Arithmetic ********************************/
239
240 MINLINE void add_v2_fl(float r[2], float f)
241 {
242         r[0] += f;
243         r[1] += f;
244 }
245
246
247 MINLINE void add_v3_fl(float r[3], float f)
248 {
249         r[0] += f;
250         r[1] += f;
251         r[2] += f;
252 }
253
254 MINLINE void add_v4_fl(float r[4], float f)
255 {
256         r[0] += f;
257         r[1] += f;
258         r[2] += f;
259         r[3] += f;
260 }
261
262 MINLINE void add_v2_v2(float r[2], const float a[2])
263 {
264         r[0] += a[0];
265         r[1] += a[1];
266 }
267
268 MINLINE void add_v2_v2v2(float r[2], const float a[2], const float b[2])
269 {
270         r[0] = a[0] + b[0];
271         r[1] = a[1] + b[1];
272 }
273
274 MINLINE void add_v2_v2v2_int(int r[2], const int a[2], const int b[2])
275 {
276         r[0] = a[0] + b[0];
277         r[1] = a[1] + b[1];
278 }
279
280 MINLINE void add_v3_v3(float r[3], const float a[3])
281 {
282         r[0] += a[0];
283         r[1] += a[1];
284         r[2] += a[2];
285 }
286
287 MINLINE void add_v3_v3v3(float r[3], const float a[3], const float b[3])
288 {
289         r[0] = a[0] + b[0];
290         r[1] = a[1] + b[1];
291         r[2] = a[2] + b[2];
292 }
293
294 MINLINE void add_v4_v4(float r[4], const float a[4])
295 {
296         r[0] += a[0];
297         r[1] += a[1];
298         r[2] += a[2];
299         r[3] += a[3];
300 }
301
302 MINLINE void add_v4_v4v4(float r[4], const float a[4], const float b[4])
303 {
304         r[0] = a[0] + b[0];
305         r[1] = a[1] + b[1];
306         r[2] = a[2] + b[2];
307         r[3] = a[3] + b[3];
308 }
309
310 MINLINE void sub_v2_v2(float r[2], const float a[2])
311 {
312         r[0] -= a[0];
313         r[1] -= a[1];
314 }
315
316 MINLINE void sub_v2_v2v2(float r[2], const float a[2], const float b[2])
317 {
318         r[0] = a[0] - b[0];
319         r[1] = a[1] - b[1];
320 }
321
322 MINLINE void sub_v2_v2v2_int(int r[2], const int a[2], const int b[2])
323 {
324         r[0] = a[0] - b[0];
325         r[1] = a[1] - b[1];
326 }
327
328 MINLINE void sub_v3_v3(float r[3], const float a[3])
329 {
330         r[0] -= a[0];
331         r[1] -= a[1];
332         r[2] -= a[2];
333 }
334
335 MINLINE void sub_v3_v3v3(float r[3], const float a[3], const float b[3])
336 {
337         r[0] = a[0] - b[0];
338         r[1] = a[1] - b[1];
339         r[2] = a[2] - b[2];
340 }
341
342 MINLINE void sub_v4_v4(float r[4], const float a[4])
343 {
344         r[0] -= a[0];
345         r[1] -= a[1];
346         r[2] -= a[2];
347         r[3] -= a[3];
348 }
349
350 MINLINE void sub_v4_v4v4(float r[4], const float a[4], const float b[4])
351 {
352         r[0] = a[0] - b[0];
353         r[1] = a[1] - b[1];
354         r[2] = a[2] - b[2];
355         r[3] = a[3] - b[3];
356 }
357
358 MINLINE void mul_v2_fl(float r[2], float f)
359 {
360         r[0] *= f;
361         r[1] *= f;
362 }
363
364 MINLINE void mul_v2_v2fl(float r[2], const float a[2], float f)
365 {
366         r[0] = a[0] * f;
367         r[1] = a[1] * f;
368 }
369
370 MINLINE void mul_v3_fl(float r[3], float f)
371 {
372         r[0] *= f;
373         r[1] *= f;
374         r[2] *= f;
375 }
376
377 MINLINE void mul_v3_v3fl(float r[3], const float a[3], float f)
378 {
379         r[0] = a[0] * f;
380         r[1] = a[1] * f;
381         r[2] = a[2] * f;
382 }
383
384 MINLINE void mul_v2_v2(float r[2], const float a[2])
385 {
386         r[0] *= a[0];
387         r[1] *= a[1];
388 }
389
390 MINLINE void mul_v3_v3(float r[3], const float a[3])
391 {
392         r[0] *= a[0];
393         r[1] *= a[1];
394         r[2] *= a[2];
395 }
396
397 MINLINE void mul_v4_fl(float r[4], float f)
398 {
399         r[0] *= f;
400         r[1] *= f;
401         r[2] *= f;
402         r[3] *= f;
403 }
404
405 MINLINE void mul_v4_v4fl(float r[4], const float a[4], float f)
406 {
407         r[0] = a[0] * f;
408         r[1] = a[1] * f;
409         r[2] = a[2] * f;
410         r[3] = a[3] * f;
411 }
412
413 /* note: could add a matrix inline */
414 MINLINE float mul_project_m4_v3_zfac(float mat[4][4], const float co[3])
415 {
416         return (mat[0][3] * co[0]) +
417                (mat[1][3] * co[1]) +
418                (mat[2][3] * co[2]) + mat[3][3];
419 }
420
421
422 MINLINE void madd_v2_v2fl(float r[2], const float a[2], float f)
423 {
424         r[0] += a[0] * f;
425         r[1] += a[1] * f;
426 }
427
428 MINLINE void madd_v3_v3fl(float r[3], const float a[3], float f)
429 {
430         r[0] += a[0] * f;
431         r[1] += a[1] * f;
432         r[2] += a[2] * f;
433 }
434
435 MINLINE void madd_v3_v3v3(float r[3], const float a[3], const float b[3])
436 {
437         r[0] += a[0] * b[0];
438         r[1] += a[1] * b[1];
439         r[2] += a[2] * b[2];
440 }
441
442 MINLINE void madd_v2_v2v2fl(float r[2], const float a[2], const float b[2], float f)
443 {
444         r[0] = a[0] + b[0] * f;
445         r[1] = a[1] + b[1] * f;
446 }
447
448 MINLINE void madd_v3_v3v3fl(float r[3], const float a[3], const float b[3], float f)
449 {
450         r[0] = a[0] + b[0] * f;
451         r[1] = a[1] + b[1] * f;
452         r[2] = a[2] + b[2] * f;
453 }
454
455 MINLINE void madd_v3_v3v3v3(float r[3], const float a[3], const float b[3], const float c[3])
456 {
457         r[0] = a[0] + b[0] * c[0];
458         r[1] = a[1] + b[1] * c[1];
459         r[2] = a[2] + b[2] * c[2];
460 }
461
462 MINLINE void madd_v4_v4fl(float r[4], const float a[4], float f)
463 {
464         r[0] += a[0] * f;
465         r[1] += a[1] * f;
466         r[2] += a[2] * f;
467         r[3] += a[3] * f;
468 }
469
470 MINLINE void madd_v4_v4v4(float r[4], const float a[4], const float b[4])
471 {
472         r[0] += a[0] * b[0];
473         r[1] += a[1] * b[1];
474         r[2] += a[2] * b[2];
475         r[3] += a[3] * b[3];
476 }
477
478 MINLINE void mul_v3_v3v3(float r[3], const float v1[3], const float v2[3])
479 {
480         r[0] = v1[0] * v2[0];
481         r[1] = v1[1] * v2[1];
482         r[2] = v1[2] * v2[2];
483 }
484
485 MINLINE void negate_v2(float r[2])
486 {
487         r[0] = -r[0];
488         r[1] = -r[1];
489 }
490
491 MINLINE void negate_v2_v2(float r[2], const float a[2])
492 {
493         r[0] = -a[0];
494         r[1] = -a[1];
495 }
496
497 MINLINE void negate_v3(float r[3])
498 {
499         r[0] = -r[0];
500         r[1] = -r[1];
501         r[2] = -r[2];
502 }
503
504 MINLINE void negate_v3_v3(float r[3], const float a[3])
505 {
506         r[0] = -a[0];
507         r[1] = -a[1];
508         r[2] = -a[2];
509 }
510
511 MINLINE void negate_v4(float r[4])
512 {
513         r[0] = -r[0];
514         r[1] = -r[1];
515         r[2] = -r[2];
516         r[3] = -r[3];
517 }
518
519 MINLINE void negate_v4_v4(float r[4], const float a[4])
520 {
521         r[0] = -a[0];
522         r[1] = -a[1];
523         r[2] = -a[2];
524         r[3] = -a[3];
525 }
526
527 /* could add more... */
528 MINLINE void negate_v3_short(short r[3])
529 {
530         r[0] = -r[0];
531         r[1] = -r[1];
532         r[2] = -r[2];
533 }
534
535 MINLINE float dot_v2v2(const float a[2], const float b[2])
536 {
537         return a[0] * b[0] + a[1] * b[1];
538 }
539
540 MINLINE float dot_v3v3(const float a[3], const float b[3])
541 {
542         return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
543 }
544
545 MINLINE float cross_v2v2(const float a[2], const float b[2])
546 {
547         return a[0] * b[1] - a[1] * b[0];
548 }
549
550 MINLINE void cross_v3_v3v3(float r[3], const float a[3], const float b[3])
551 {
552         BLI_assert(r != a && r != b);
553         r[0] = a[1] * b[2] - a[2] * b[1];
554         r[1] = a[2] * b[0] - a[0] * b[2];
555         r[2] = a[0] * b[1] - a[1] * b[0];
556 }
557
558 /* Newell's Method */
559 /* excuse this fairly specific function,
560  * its used for polygon normals all over the place
561  * could use a better name */
562 MINLINE void add_newell_cross_v3_v3v3(float n[3], const float v_prev[3], const float v_curr[3])
563 {
564         n[0] += (v_prev[1] - v_curr[1]) * (v_prev[2] + v_curr[2]);
565         n[1] += (v_prev[2] - v_curr[2]) * (v_prev[0] + v_curr[0]);
566         n[2] += (v_prev[0] - v_curr[0]) * (v_prev[1] + v_curr[1]);
567 }
568
569 MINLINE void star_m3_v3(float rmat[3][3], float a[3])
570 {
571         rmat[0][0] = rmat[1][1] = rmat[2][2] = 0.0;
572         rmat[0][1] = -a[2];
573         rmat[0][2] = a[1];
574         rmat[1][0] = a[2];
575         rmat[1][2] = -a[0];
576         rmat[2][0] = -a[1];
577         rmat[2][1] = a[0];
578 }
579
580 /*********************************** Length **********************************/
581
582 MINLINE float len_squared_v2(const float v[2])
583 {
584         return v[0] * v[0] + v[1] * v[1];
585 }
586
587 MINLINE float len_squared_v3(const float v[3])
588 {
589         return v[0] * v[0] + v[1] * v[1] + v[2] * v[2];
590 }
591
592 MINLINE float len_manhattan_v2(const float v[2])
593 {
594         return fabsf(v[0]) + fabsf(v[1]);
595 }
596
597 MINLINE int len_manhattan_v2_int(const int v[2])
598 {
599         return ABS(v[0]) + ABS(v[1]);
600 }
601
602 MINLINE float len_manhattan_v3(const float v[3])
603 {
604         return fabsf(v[0]) + fabsf(v[1]) + fabsf(v[2]);
605 }
606
607 MINLINE float len_v2(const float v[2])
608 {
609         return sqrtf(v[0] * v[0] + v[1] * v[1]);
610 }
611
612 MINLINE float len_v2v2(const float v1[2], const float v2[2])
613 {
614         float x, y;
615
616         x = v1[0] - v2[0];
617         y = v1[1] - v2[1];
618         return sqrtf(x * x + y * y);
619 }
620
621 MINLINE float len_v3(const float a[3])
622 {
623         return sqrtf(dot_v3v3(a, a));
624 }
625
626 MINLINE float len_squared_v2v2(const float a[2], const float b[2])
627 {
628         float d[2];
629
630         sub_v2_v2v2(d, b, a);
631         return dot_v2v2(d, d);
632 }
633
634 MINLINE float len_squared_v3v3(const float a[3], const float b[3])
635 {
636         float d[3];
637
638         sub_v3_v3v3(d, b, a);
639         return dot_v3v3(d, d);
640 }
641
642 MINLINE float len_manhattan_v2v2(const float a[2], const float b[2])
643 {
644         float d[2];
645
646         sub_v2_v2v2(d, b, a);
647         return len_manhattan_v2(d);
648 }
649
650 MINLINE int len_manhattan_v2v2_int(const int a[2], const int b[2])
651 {
652         int d[2];
653
654         sub_v2_v2v2_int(d, b, a);
655         return len_manhattan_v2_int(d);
656 }
657
658 MINLINE float len_manhattan_v3v3(const float a[3], const float b[3])
659 {
660         float d[3];
661
662         sub_v3_v3v3(d, b, a);
663         return len_manhattan_v3(d);
664 }
665
666 MINLINE float len_v3v3(const float a[3], const float b[3])
667 {
668         float d[3];
669
670         sub_v3_v3v3(d, b, a);
671         return len_v3(d);
672 }
673
674 MINLINE float normalize_v2_v2(float r[2], const float a[2])
675 {
676         float d = dot_v2v2(a, a);
677
678         if (d > 1.0e-35f) {
679                 d = sqrtf(d);
680                 mul_v2_v2fl(r, a, 1.0f / d);
681         }
682         else {
683                 zero_v2(r);
684                 d = 0.0f;
685         }
686
687         return d;
688 }
689
690 MINLINE float normalize_v2(float n[2])
691 {
692         return normalize_v2_v2(n, n);
693 }
694
695 MINLINE float normalize_v3_v3(float r[3], const float a[3])
696 {
697         float d = dot_v3v3(a, a);
698
699         /* a larger value causes normalize errors in a
700          * scaled down models with camera extreme close */
701         if (d > 1.0e-35f) {
702                 d = sqrtf(d);
703                 mul_v3_v3fl(r, a, 1.0f / d);
704         }
705         else {
706                 zero_v3(r);
707                 d = 0.0f;
708         }
709
710         return d;
711 }
712
713 MINLINE double normalize_v3_d(double n[3])
714 {
715         double d = n[0] * n[0] + n[1] * n[1] + n[2] * n[2];
716
717         /* a larger value causes normalize errors in a
718          * scaled down models with camera extreme close */
719         if (d > 1.0e-35) {
720                 double mul;
721
722                 d = sqrt(d);
723                 mul = 1.0 / d;
724
725                 n[0] *= mul;
726                 n[1] *= mul;
727                 n[2] *= mul;
728         }
729         else {
730                 n[0] = n[1] = n[2] = 0;
731                 d = 0.0;
732         }
733
734         return d;
735 }
736
737 MINLINE float normalize_v3(float n[3])
738 {
739         return normalize_v3_v3(n, n);
740 }
741
742 MINLINE void normal_short_to_float_v3(float out[3], const short in[3])
743 {
744         out[0] = in[0] * (1.0f / 32767.0f);
745         out[1] = in[1] * (1.0f / 32767.0f);
746         out[2] = in[2] * (1.0f / 32767.0f);
747 }
748
749 MINLINE void normal_float_to_short_v3(short out[3], const float in[3])
750 {
751         out[0] = (short) (in[0] * 32767.0f);
752         out[1] = (short) (in[1] * 32767.0f);
753         out[2] = (short) (in[2] * 32767.0f);
754 }
755
756 /********************************* Comparison ********************************/
757
758
759 MINLINE int is_zero_v2(const float v[2])
760 {
761         return (v[0] == 0 && v[1] == 0);
762 }
763
764 MINLINE int is_zero_v3(const float v[3])
765 {
766         return (v[0] == 0 && v[1] == 0 && v[2] == 0);
767 }
768
769 MINLINE int is_zero_v4(const float v[4])
770 {
771         return (v[0] == 0 && v[1] == 0 && v[2] == 0 && v[3] == 0);
772 }
773
774 MINLINE int is_one_v3(const float v[3])
775 {
776         return (v[0] == 1 && v[1] == 1 && v[2] == 1);
777 }
778
779 MINLINE int equals_v2v2(const float v1[2], const float v2[2])
780 {
781         return ((v1[0] == v2[0]) && (v1[1] == v2[1]));
782 }
783
784 MINLINE int equals_v3v3(const float v1[3], const float v2[3])
785 {
786         return ((v1[0] == v2[0]) && (v1[1] == v2[1]) && (v1[2] == v2[2]));
787 }
788
789 MINLINE int equals_v4v4(const float v1[4], const float v2[4])
790 {
791         return ((v1[0] == v2[0]) && (v1[1] == v2[1]) && (v1[2] == v2[2]) && (v1[3] == v2[3]));
792 }
793
794 MINLINE int compare_v2v2(const float v1[2], const float v2[2], const float limit)
795 {
796         if (fabsf(v1[0] - v2[0]) < limit)
797                 if (fabsf(v1[1] - v2[1]) < limit)
798                         return 1;
799
800         return 0;
801 }
802
803 MINLINE int compare_v3v3(const float v1[3], const float v2[3], const float limit)
804 {
805         if (fabsf(v1[0] - v2[0]) < limit)
806                 if (fabsf(v1[1] - v2[1]) < limit)
807                         if (fabsf(v1[2] - v2[2]) < limit)
808                                 return 1;
809
810         return 0;
811 }
812
813 MINLINE int compare_len_v3v3(const float v1[3], const float v2[3], const float limit)
814 {
815         float x, y, z;
816
817         x = v1[0] - v2[0];
818         y = v1[1] - v2[1];
819         z = v1[2] - v2[2];
820
821         return ((x * x + y * y + z * z) < (limit * limit));
822 }
823
824 MINLINE int compare_v4v4(const float v1[4], const float v2[4], const float limit)
825 {
826         if (fabsf(v1[0] - v2[0]) < limit)
827                 if (fabsf(v1[1] - v2[1]) < limit)
828                         if (fabsf(v1[2] - v2[2]) < limit)
829                                 if (fabsf(v1[3] - v2[3]) < limit)
830                                         return 1;
831
832         return 0;
833 }
834
835 MINLINE float line_point_side_v2(const float l1[2], const float l2[2], const float pt[2])
836 {
837         return (((l1[0] - pt[0]) * (l2[1] - pt[1])) -
838                 ((l2[0] - pt[0]) * (l1[1] - pt[1])));
839 }
840
841 #endif /* __MATH_VECTOR_INLINE_C__ */