fa7c05cce7c965b3be475bb66c3378cfec4096c8
[blender.git] / source / blender / blenlib / BLI_arithb.h
1 #undef TEST_ACTIVE
2 //#define ACTIVE 1
3 /**
4  * blenlib/BLI_arithb.h    mar 2001 Nzc
5  *
6  * $Id$ 
7  *
8  * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
9  *
10  * This program is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU General Public License
12  * as published by the Free Software Foundation; either version 2
13  * of the License, or (at your option) any later version. The Blender
14  * Foundation also sells licenses for use in proprietary software under
15  * the Blender License.  See http://www.blender.org/BL/ for information
16  * about this.
17  *
18  * This program is distributed in the hope that it will be useful,
19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21  * GNU General Public License for more details.
22  *
23  * You should have received a copy of the GNU General Public License
24  * along with this program; if not, write to the Free Software Foundation,
25  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
26  *
27  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
28  * All rights reserved.
29  *
30  * The Original Code is: all of this file.
31  *
32  * Contributor(s): none yet.
33  *
34  * ***** END GPL/BL DUAL LICENSE BLOCK *****
35  *
36  * The old math stuff from Ton. These will slowly phase out in favour
37  * of MTC calls. (or even MoTO :) )
38  * */
39
40 #ifndef BLI_ARITHB_H
41 #define BLI_ARITHB_H
42
43 #ifdef __cplusplus
44 extern "C" {
45 #endif
46
47 #ifndef M_PI
48 #define M_PI            3.14159265358979323846
49 #endif
50 #ifndef M_PI_2
51 #define M_PI_2          1.57079632679489661923
52 #endif
53 #ifndef M_SQRT2
54 #define M_SQRT2         1.41421356237309504880
55 #endif
56 #ifndef M_SQRT1_2
57 #define M_SQRT1_2       0.70710678118654752440
58 #endif
59
60 #define MAT4_UNITY {{ 1.0, 0.0, 0.0, 0.0},\
61                                         { 0.0, 1.0, 0.0, 0.0},\
62                                         { 0.0, 0.0, 1.0, 0.0},\
63                                         { 0.0, 0.0, 0.0, 1.0}}
64
65 #define MAT3_UNITY {{ 1.0, 0.0, 0.0},\
66                                         { 0.0, 1.0, 0.0},\
67                                         { 0.0, 0.0, 1.0}}
68
69
70 /* matrix operations */
71 /* void Mat4MulMat4(float m1[][4], float m2[][4], float m3[][4]); */
72 /* void Mat3MulVecfl(float mat[][3], float *vec);  */
73 /* or **mat, but it's the same */
74 /*void Mat3MulVecd(float mat[][3], double *vec); */
75
76 /* void Mat4MulVecfl(float mat[][4], float *vec); */
77 /* void Mat4MulSerie(float answ[][4], float m1[][4], float m2[][4],  */
78 /*                   float m3[][4], float m4[][4], float m5[][4],  */
79 /*                   float m6[][4], float m7[][4], float m8[][4]); */
80 /* int Mat4Invert(float inverse[][4], float mat[][4]); */
81
82 /* m2 to m1 */
83 /*  void Mat3CpyMat4(float m1p[][3], float m2p[][4]); */
84 /* void Mat3CpyMat4(float *m1p, float *m2p); */
85
86 /* m1 to m2 */
87 /*  void Mat3CpyMat3(float m1p[][3], float m2p[][3]); */
88 /* void Mat3CpyMat3(float *m1p, float *m2p); */
89
90 /* m2 to m1 */
91 /* void Mat4CpyMat3(float m1p[][4], float m2p[][3]); */
92
93 /* M1 = M3*M2 */
94 /*  void Mat3MulMat3(float m1[][3], float m2[][3], float m3[][3]); */
95 /*void Mat3MulMat3(float *m1, float *m3, float *m2); */
96
97 /* m1 = m2 * m3, ignore the elements on the 4th row/column of m3 */
98 /*void Mat3IsMat3MulMat4(float m1[][3], float m2[][3], float m3[][4]); */
99
100 /* m1 to m2 */
101 /*  void Mat4CpyMat4(float m1[][4], float m2[][4]); */
102 /* void Mat4CpyMat4(float *m1, float *m2); */
103
104
105 /* void Mat4Ortho(float mat[][4]); */
106 /* void Mat4Mul3Vecfl(float mat[][4], float *vec); */
107 /* void Mat4MulVec4fl(float mat[][4], float *vec); */
108 /* void Mat4SwapMat4(float *m1, float *m2); */
109
110 /* void Mat3Inv(float m1[][3], float m2[][3]); */
111 /* void Mat4One(float m[][4]); */
112 /* void Mat3One(float m[][3]); */
113
114
115         void 
116 CalcCent3f(
117         float *cent,  float *v1, float *v2, float *v3
118 );
119
120         void 
121 CalcCent4f(
122         float *cent, float *v1, 
123         float *v2, float *v3,
124         float *v4
125 );
126
127         void 
128 Crossf(
129         float *c, float *a, float *b
130 );
131
132         void 
133 Projf(
134         float *c, float *v1, float *v2
135 );
136
137 /**
138  * Euler conversion routines
139  */
140
141         void 
142 EulToMat3(
143         float *eul, 
144         float mat[][3]
145 );
146         void 
147 EulToMat4(
148         float* eul, 
149         float mat[][4]
150 );
151
152         void 
153 Mat3ToEul(
154         float tmat[][3],
155         float *eul
156 );
157
158         void 
159 Mat4ToEul(
160         float tmat[][4],
161         float *eul
162 );
163
164 void compatible_eul(float *eul, float *oldrot);
165
166 void Mat3ToCompatibleEul(float mat[][3], float *eul, float *oldrot);
167
168 /**
169  * @section Quaternion arithmetic routines
170  */
171
172         void 
173 QuatToEul(
174         float *quat, 
175         float *eul
176 );
177         void 
178 QuatOne(
179         float *
180 );
181         void 
182 QuatMul(
183         float *, 
184         float *, 
185         float *
186 );
187         void 
188 QuatMulVecf(
189         float *q, 
190         float *v
191 );
192         void 
193 NormalQuat(
194         float *
195 );
196         void 
197 VecRotToQuat(
198         float *vec,
199         float phi,
200         float *quat
201 );
202         void 
203 QuatSub(
204         float *q, 
205         float *q1, 
206         float *q2
207 );
208         void 
209 QuatConj(
210         float *q 
211 );
212         void 
213 QuatInv(
214         float *q 
215 );
216         void 
217 QuatMulf(
218         float *q,
219         float f
220 );
221         float 
222 QuatDot(
223         float *q1, 
224         float *q2
225 );
226         void
227 printquat(
228         char *str,
229         float q[4]
230 );
231
232
233 void QuatInterpol(float *result, float *quat1, float *quat2, float t);
234 void QuatAdd(float *result, float *quat1, float *quat2, float t);
235
236
237 /**
238  * @section matrix multiplication can copying routines
239  */
240
241         void 
242 Mat3MulFloat(
243         float *m, 
244         float f
245 );
246         void 
247 Mat4MulFloat(
248         float *m, 
249         float f
250 );
251         void 
252 Mat4MulFloat3(
253         float *m, 
254         float f
255 );
256         void 
257 Mat3Transp(
258         float mat[][3]
259 );
260         void 
261 Mat4Transp(
262         float mat[][4]
263 );
264         int 
265 Mat4Invert(
266         float inverse[][4], 
267         float mat[][4]
268 );
269         void 
270 Mat4InvertSimp(
271         float inverse[][4],
272         float mat[][4]
273 );
274         void 
275 Mat4Inv(
276         float *m1, 
277         float *m2
278 );
279         void 
280 Mat4InvGG(
281         float out[][4], 
282         float in[][4]
283 );
284         void 
285 Mat3CpyMat4(
286         float m1[][3],
287         float m2[][4]
288 );
289
290         void 
291 Mat3Inv(
292         float m1[][3], 
293         float m2[][3]
294 );
295
296         void 
297 Mat4CpyMat3(
298         float m1[][4], 
299         float m2[][3]
300 ); 
301
302         float 
303 Det2x2(
304         float a,float b,float c,float d
305 );
306
307         float 
308 Det3x3(
309         float a1, float a2, float a3,
310         float b1, float b2, float b3,
311         float c1, float c2, float c3 
312 );
313
314         float 
315 Det4x4(
316         float m[][4]
317 );
318
319         void 
320 Mat4Adj(
321         float out[][4], 
322         float in[][4]
323 );
324         void 
325 Mat3Adj(
326         float m1[][3], 
327         float m[][3]
328 );
329         void 
330 Mat4MulMat4(
331         float m1[][4], 
332         float m2[][4], 
333         float m3[][4]
334 );
335         void 
336 subMat4MulMat4(
337         float *m1, 
338         float *m2, 
339         float *m3
340 );
341 #ifndef TEST_ACTIVE
342         void 
343 Mat3MulMat3(
344         float m1[][3], 
345         float m3[][3], 
346         float m2[][3]
347 );
348 #else
349         void 
350 Mat3MulMat3(
351         float *m1, 
352         float *m3, 
353         float *m2
354 );
355 #endif
356         void 
357 Mat4MulMat34(
358         float (*m1)[4], 
359         float (*m3)[3], 
360         float (*m2)[4]
361 );
362         void 
363 Mat4CpyMat4(
364         float m1[][4], 
365         float m2[][4]
366 );
367         void 
368 Mat4SwapMat4(
369         float *m1, 
370         float *m2
371 );
372         void 
373 Mat3CpyMat3(
374         float m1[][3], 
375         float m2[][3]
376 );
377         void 
378 Mat3MulSerie(
379         float answ[][3],
380         float m1[][3], float m2[][3], float m3[][3],
381         float m4[][3], float m5[][3], float m6[][3],
382         float m7[][3], float m8[][3]
383 );
384         void 
385 Mat4MulSerie(
386         float answ[][4], 
387         float m1[][4],
388         float m2[][4], float m3[][4], float m4[][4],
389         float m5[][4], float m6[][4], float m7[][4],
390         float m8[][4]
391 );
392         void 
393 Mat4Clr(
394         float *m
395 );
396         void 
397 Mat3Clr(
398         float *m
399 );
400         void 
401 Mat3One(
402         float m[][3]
403 );
404         void
405 Mat4MulVec3Project(
406         float mat[][4],
407         float *vec
408 );
409         void 
410 Mat4MulVec(
411         float mat[][4],
412         int *vec
413 );
414         void 
415 VecMat4MulVecfl(
416         float *in, 
417         float mat[][4], 
418         float *vec
419 );
420         void 
421 Mat4MulMat43(
422         float (*m1)[4], 
423         float (*m3)[4], 
424         float (*m2)[3]
425 );
426
427         void 
428 Mat3IsMat3MulMat4(
429         float m1[][3], 
430         float m2[][3], 
431         float m3[][4]
432 );
433         void 
434 Mat4One(
435         float m[][4]
436 );
437         void 
438 Mat4Mul3Vecfl(
439         float mat[][4], 
440         float *vec
441 );
442         void 
443 Mat4MulVec4fl(
444         float mat[][4], 
445         float *vec
446 );
447         void 
448 Mat3MulVec(
449         float mat[][3],
450         int *vec
451 );
452         void 
453 Mat4MulVecfl(
454         float mat[][4], 
455         float *vec
456 );
457         void 
458 Mat4ToQuat(
459         float m[][4], 
460         float *q
461 );
462         void 
463 VecUpMat3old(
464         float *vec, 
465         float mat[][3], 
466         short axis
467 );
468         int 
469 FloatCompare(
470         float *v1, 
471         float *v2, 
472         float limit
473 );
474         float 
475 Normalise(
476         float *n
477 );
478         float 
479 CalcNormFloat(
480         float *v1,
481         float *v2,
482         float *v3,
483         float *n
484 );
485
486         float 
487 CalcNormFloat4(
488         float *v1,
489         float *v2,
490         float *v3,
491         float *v4,
492         float *n
493 );
494         float 
495 VecLenf(
496         float *v1, 
497         float *v2
498 );
499     float 
500 VecLength(
501         float *v
502 );
503         void 
504 VecMulf(
505         float *v1, 
506         float f
507 );
508         int
509 VecLenCompare(
510         float *v1,
511         float *v2,
512         float limit
513 );
514         int 
515 VecCompare(
516         float *v1, 
517         float *v2, 
518         float limit
519 );
520         int
521 VecEqual(
522         float *v1,
523         float *v2
524 );
525         float 
526 Sqrt3f(
527         float f
528 );
529         double 
530 Sqrt3d(
531         double d
532 );
533
534         void 
535 euler_rot(
536         float *beul, 
537         float ang, 
538         char axis
539 );
540         float 
541 saacos(
542         float fac
543 );
544         float 
545 saasin(
546         float fac
547 );
548         float 
549 sasqrt(
550         float fac
551 );
552         void
553 printvecf(
554         char *str,
555         float v[3]
556 );
557         void
558 printvec4f(
559         char *str,
560         float v[4]
561 );
562         float 
563 Inpf(
564         float *v1, 
565         float *v2
566 );
567         void 
568 VecSubf(
569         float *v, 
570         float *v1, 
571         float *v2
572 );
573         void 
574 VecAddf(
575         float *v, 
576         float *v1, 
577         float *v2
578 );
579         void
580 VecLerpf(
581         float *target, 
582         float *a, 
583         float *b,
584         float t
585 );
586         void 
587 VecUpMat3(
588         float *vec, 
589         float mat[][3], 
590         short axis
591 );
592         float 
593 DistVL2Dfl(
594         float *v1,
595         float *v2,
596         float *v3
597 );
598         float 
599 PdistVL2Dfl(
600         float *v1,
601         float *v2,
602         float *v3
603 );
604         float 
605 AreaF2Dfl(
606         float *v1, 
607         float *v2, 
608         float *v3
609 );
610         float 
611 AreaQ3Dfl(
612         float *v1, 
613         float *v2, 
614         float *v3, 
615         float *v4
616 );
617         float 
618 AreaT3Dfl(
619         float *v1, 
620         float *v2, 
621         float *v3
622 );
623         float 
624 AreaPoly3Dfl(
625         int nr, 
626         float *verts, 
627         float *normal
628 );
629         void 
630 VecRotToMat3(
631         float *vec, 
632         float phi, 
633         float mat[][3]
634 );
635
636 /* intersect Line-Line
637         return:
638         -1: colliniar
639          0: no intersection of segments
640          1: exact intersection of segments
641          2: cross-intersection of segments
642 */
643 extern short IsectLL2Df(float *v1, float *v2, float *v3, float *v4);
644 extern short IsectLL2Ds(short *v1, short *v2, short *v3, short *v4);
645
646 /* interpolation weights of point in a triangle or quad, v4 may be NULL */
647         void
648 InterpWeightsQ3Dfl(
649         float *v1, float *v2, float *v3, float *v4,
650         float *co,
651         float *w
652 );
653
654         float *
655 vectoquat(
656         float *vec, 
657         short axis, 
658         short upflag
659 );
660
661         float
662 VecAngle3(
663         float *v1, 
664         float *v2,
665         float *v3
666 );
667
668         float
669 VecAngle2(
670         float *v1, 
671         float *v2
672 );
673         float
674 NormalizedVecAngle2(
675         float *v1,
676         float *v2
677 );
678
679         void 
680 i_lookat(
681         float vx, float vy, 
682         float vz, float px, 
683         float py, float pz, 
684         float twist, float mat[][4]
685 );
686         void 
687 i_window(
688         float left, float right,
689         float bottom, float top,
690         float nearClip, float farClip,
691         float mat[][4]
692 );
693
694         void 
695 hsv_to_rgb(
696         float h, float s, 
697         float v, float *r, 
698         float *g, float *b
699 );
700
701         void 
702 hex_to_rgb(
703         char *hexcol, 
704         float *r, 
705         float *g, 
706         float *b
707 );
708
709         void 
710 rgb_to_yuv(
711         float r, float g, float b, 
712         float *ly, float *lu, float *lv
713 );
714
715         void 
716 yuv_to_rgb(
717         float y, float u, float v, 
718         float *lr, float *lg, float *lb
719 );
720
721         void 
722 ycc_to_rgb(
723         float y, float cb, float cr, 
724         float *lr, float *lg, float *lb
725 );
726
727         void 
728 rgb_to_ycc(
729         float r, float g, float b, 
730         float *ly, float *lcb, float *lcr
731 );
732         void 
733 rgb_to_hsv(
734         float r, float g, float b, 
735         float *lh, float *ls, float *lv
736 );
737         unsigned int 
738 hsv_to_cpack(
739         float h, float s, float v
740 );
741         unsigned int 
742 rgb_to_cpack(
743         float r, float g, float b
744 );
745         void 
746 cpack_to_rgb(
747         unsigned int col, 
748         float *r, float *g, float *b
749 );
750
751         void 
752 EulToQuat(
753         float *eul, 
754         float *quat
755 );
756
757         void 
758 Mat3MulVecfl(
759         float mat[][3], 
760         float *vec
761 );
762         void 
763 Mat3MulVecd(
764         float mat[][3], 
765         double *vec
766 );
767         void 
768 Mat3TransMulVecfl(
769         float mat[][3], 
770         float *vec
771 );
772         void 
773 VecStar(
774         float mat[][3],
775         float *vec
776 );
777         short 
778 EenheidsMat(
779         float mat[][3]
780 );
781         void 
782 printmatrix3(
783         char *str, float m[][3]
784 );
785         void 
786 QuatToMat3(
787         float *q, 
788         float m[][3]
789 );
790         void 
791 QuatToMat4(
792         float *q, 
793         float m[][4]
794 );
795         void 
796 Mat3ToQuat_is_ok(
797         float wmat[][3], 
798         float *q
799 );
800         void 
801 i_ortho(
802         float left, float right, 
803         float bottom, float top, 
804         float nearClip, float farClip, 
805         float matrix[][4]
806 );
807         void 
808 i_polarview(
809         float dist, float azimuth, float incidence, float twist, 
810         float Vm[][4]
811 );
812         void 
813 Mat3Ortho(
814         float mat[][3]
815 );
816         void 
817 Mat4Ortho(
818         float mat[][4]
819 );
820         void 
821 VecCopyf(
822         float *v1, 
823         float *v2
824 );
825         int 
826 VecLen(
827         int *v1, 
828         int *v2
829 );
830         void 
831 CalcNormShort(
832         short *v1, 
833         short *v2, 
834         short *v3, 
835         float *n
836 ) /* is ook uitprodukt */;
837
838         void 
839 CalcNormLong(
840         int* v1, 
841         int*v2, 
842         int*v3, 
843         float *n
844 );
845         void 
846 MinMax3(
847         float *min, 
848         float *max, 
849         float *vec
850 );
851
852         void 
853 SizeToMat3(
854         float *size, 
855         float mat[][3]
856 );
857         void 
858 printmatrix4(
859         char *str, 
860         float m[][4]
861 );
862 /* uit Sig.Proc.85 pag 253 */
863         void 
864 Mat3ToQuat(
865         float wmat[][3],
866         float *q
867 );
868         void 
869 i_translate(
870         float Tx, 
871         float Ty, 
872         float Tz, 
873         float mat[][4]
874 );
875         void 
876 i_multmatrix(
877         float icand[][4], 
878         float Vm[][4]
879 );
880         void 
881 i_rotate(
882         float angle, 
883         char axis, 
884         float mat[][4]
885 );
886         void 
887 VecMidf(
888         float *v, float *v1, float *v2
889 );
890         void 
891 Mat3ToSize(
892         float mat[][3], float *size
893 );
894         void 
895 Mat4ToSize(
896         float mat[][4], float *size
897 );
898         void 
899 triatoquat(
900         float *v1, 
901         float *v2, 
902         float *v3, float *quat
903 );
904         void 
905 MinMaxRGB(
906         short c[]
907 );
908         float
909 Vec2Lenf(
910         float *v1,
911         float *v2
912 );
913         void 
914 Vec2Mulf(
915         float *v1, 
916         float f
917 );
918         void 
919 Vec2Addf(
920         float *v,
921         float *v1, 
922         float *v2
923 );
924         void 
925 Vec2Subf(
926         float *v,
927         float *v1, 
928         float *v2
929 );
930         void
931 Vec2Copyf(
932         float *v1,
933         float *v2
934 );
935         float 
936 Inp2f(
937         float *v1, 
938         float *v2
939 );
940         float 
941 Normalise2(
942         float *n
943 );
944
945 void LocEulSizeToMat4(float mat[][4], float loc[3], float eul[3], float size[3]);
946
947 void tubemap(float x, float y, float z, float *u, float *v);
948 void spheremap(float x, float y, float z, float *u, float *v);
949                           
950 int LineIntersectsTriangle(float p1[3], float p2[3], float v0[3], float v1[3], float v2[3], float *lambda);
951 int point_in_tri_prism(float p[3], float v1[3], float v2[3], float v3[3]);
952                           
953 #ifdef __cplusplus
954 }
955 #endif
956         
957 #endif
958