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