c2a81ebed6550e541f6774a426360d0f7e516971
[blender-staging.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 Mat4MulVec(
406         float mat[][4],
407         int *vec
408 );
409         void 
410 VecMat4MulVecfl(
411         float *in, 
412         float mat[][4], 
413         float *vec
414 );
415         void 
416 Mat4MulMat43(
417         float (*m1)[4], 
418         float (*m3)[4], 
419         float (*m2)[3]
420 );
421
422         void 
423 Mat3IsMat3MulMat4(
424         float m1[][3], 
425         float m2[][3], 
426         float m3[][4]
427 );
428         void 
429 Mat4One(
430         float m[][4]
431 );
432         void 
433 Mat4Mul3Vecfl(
434         float mat[][4], 
435         float *vec
436 );
437         void 
438 Mat4MulVec4fl(
439         float mat[][4], 
440         float *vec
441 );
442         void 
443 Mat3MulVec(
444         float mat[][3],
445         int *vec
446 );
447         void 
448 Mat4MulVecfl(
449         float mat[][4], 
450         float *vec
451 );
452         void 
453 Mat4ToQuat(
454         float m[][4], 
455         float *q
456 );
457         void 
458 VecUpMat3old(
459         float *vec, 
460         float mat[][3], 
461         short axis
462 );
463         int 
464 FloatCompare(
465         float *v1, 
466         float *v2, 
467         float limit
468 );
469         float 
470 Normalise(
471         float *n
472 );
473         float 
474 CalcNormFloat(
475         float *v1,
476         float *v2,
477         float *v3,
478         float *n
479 );
480
481         float 
482 CalcNormFloat4(
483         float *v1,
484         float *v2,
485         float *v3,
486         float *v4,
487         float *n
488 );
489         float 
490 VecLenf(
491         float *v1, 
492         float *v2
493 );
494     float 
495 VecLength(
496         float *v
497 );
498         void 
499 VecMulf(
500         float *v1, 
501         float f
502 );
503         int
504 VecLenCompare(
505         float *v1,
506         float *v2,
507         float limit
508 );
509         int 
510 VecCompare(
511         float *v1, 
512         float *v2, 
513         float limit
514 );
515         int
516 VecEqual(
517         float *v1,
518         float *v2
519 );
520         float 
521 Sqrt3f(
522         float f
523 );
524         double 
525 Sqrt3d(
526         double d
527 );
528
529         void 
530 euler_rot(
531         float *beul, 
532         float ang, 
533         char axis
534 );
535         float 
536 saacos(
537         float fac
538 );
539         float 
540 sasqrt(
541         float fac
542 );
543         void
544 printvecf(
545         char *str,
546         float v[3]
547 );
548         void
549 printvec4f(
550         char *str,
551         float v[4]
552 );
553         float 
554 Inpf(
555         float *v1, 
556         float *v2
557 );
558         void 
559 VecSubf(
560         float *v, 
561         float *v1, 
562         float *v2
563 );
564         void 
565 VecAddf(
566         float *v, 
567         float *v1, 
568         float *v2
569 );
570         void
571 VecLerpf(
572         float *target, 
573         float *a, 
574         float *b,
575         float t
576 );
577         void 
578 VecUpMat3(
579         float *vec, 
580         float mat[][3], 
581         short axis
582 );
583         float 
584 DistVL2Dfl(
585         float *v1,
586         float *v2,
587         float *v3
588 );
589         float 
590 PdistVL2Dfl(
591         float *v1,
592         float *v2,
593         float *v3
594 );
595         float 
596 AreaF2Dfl(
597         float *v1, 
598         float *v2, 
599         float *v3
600 );
601         float 
602 AreaQ3Dfl(
603         float *v1, 
604         float *v2, 
605         float *v3, 
606         float *v4
607 );
608         float 
609 AreaT3Dfl(
610         float *v1, 
611         float *v2, 
612         float *v3
613 );
614         float 
615 AreaPoly3Dfl(
616         int nr, 
617         float *verts, 
618         float *normal
619 );
620         void 
621 VecRotToMat3(
622         float *vec, 
623         float phi, 
624         float mat[][3]
625 );
626
627 /* intersect Line-Line
628         return:
629         -1: colliniar
630          0: no intersection of segments
631          1: exact intersection of segments
632          2: cross-intersection of segments
633 */
634 extern short IsectLL2Df(float *v1, float *v2, float *v3, float *v4);
635 extern short IsectLL2Ds(short *v1, short *v2, short *v3, short *v4);
636
637 /* interpolation weights of point in a triangle or quad, v4 may be NULL */
638         void
639 InterpWeightsQ3Dfl(
640         float *v1, float *v2, float *v3, float *v4,
641         float *co,
642         float *w
643 );
644
645         float *
646 vectoquat(
647         float *vec, 
648         short axis, 
649         short upflag
650 );
651
652         float
653 VecAngle3(
654         float *v1, 
655         float *v2,
656         float *v3
657 );
658
659         float
660 VecAngle2(
661         float *v1, 
662         float *v2
663 );
664
665         void 
666 i_lookat(
667         float vx, float vy, 
668         float vz, float px, 
669         float py, float pz, 
670         float twist, float mat[][4]
671 );
672         void 
673 i_window(
674         float left, float right,
675         float bottom, float top,
676         float nearClip, float farClip,
677         float mat[][4]
678 );
679
680         void 
681 hsv_to_rgb(
682         float h, float s, 
683         float v, float *r, 
684         float *g, float *b
685 );
686
687         void 
688 hex_to_rgb(
689         char *hexcol, 
690         float *r, 
691         float *g, 
692         float *b
693 );
694
695         void 
696 rgb_to_yuv(
697         float r, float g, float b, 
698         float *ly, float *lu, float *lv
699 );
700
701         void 
702 yuv_to_rgb(
703         float y, float u, float v, 
704         float *lr, float *lg, float *lb
705 );
706
707         void 
708 ycc_to_rgb(
709         float y, float cb, float cr, 
710         float *lr, float *lg, float *lb
711 );
712
713         void 
714 rgb_to_ycc(
715         float r, float g, float b, 
716         float *ly, float *lcb, float *lcr
717 );
718         void 
719 rgb_to_hsv(
720         float r, float g, float b, 
721         float *lh, float *ls, float *lv
722 );
723         unsigned int 
724 hsv_to_cpack(
725         float h, float s, float v
726 );
727         unsigned int 
728 rgb_to_cpack(
729         float r, float g, float b
730 );
731         void 
732 cpack_to_rgb(
733         unsigned int col, 
734         float *r, float *g, float *b
735 );
736
737         void 
738 EulToQuat(
739         float *eul, 
740         float *quat
741 );
742
743         void 
744 Mat3MulVecfl(
745         float mat[][3], 
746         float *vec
747 );
748         void 
749 Mat3MulVecd(
750         float mat[][3], 
751         double *vec
752 );
753         void 
754 Mat3TransMulVecfl(
755         float mat[][3], 
756         float *vec
757 );
758         void 
759 VecStar(
760         float mat[][3],
761         float *vec
762 );
763         short 
764 EenheidsMat(
765         float mat[][3]
766 );
767         void 
768 printmatrix3(
769         char *str, float m[][3]
770 );
771         void 
772 QuatToMat3(
773         float *q, 
774         float m[][3]
775 );
776         void 
777 QuatToMat4(
778         float *q, 
779         float m[][4]
780 );
781         void 
782 Mat3ToQuat_is_ok(
783         float wmat[][3], 
784         float *q
785 );
786         void 
787 i_ortho(
788         float left, float right, 
789         float bottom, float top, 
790         float nearClip, float farClip, 
791         float matrix[][4]
792 );
793         void 
794 i_polarview(
795         float dist, float azimuth, float incidence, float twist, 
796         float Vm[][4]
797 );
798         void 
799 Mat3Ortho(
800         float mat[][3]
801 );
802         void 
803 Mat4Ortho(
804         float mat[][4]
805 );
806         void 
807 VecCopyf(
808         float *v1, 
809         float *v2
810 );
811         int 
812 VecLen(
813         int *v1, 
814         int *v2
815 );
816         void 
817 CalcNormShort(
818         short *v1, 
819         short *v2, 
820         short *v3, 
821         float *n
822 ) /* is ook uitprodukt */;
823
824         void 
825 CalcNormLong(
826         int* v1, 
827         int*v2, 
828         int*v3, 
829         float *n
830 );
831         void 
832 MinMax3(
833         float *min, 
834         float *max, 
835         float *vec
836 );
837
838         void 
839 SizeToMat3(
840         float *size, 
841         float mat[][3]
842 );
843         void 
844 printmatrix4(
845         char *str, 
846         float m[][4]
847 );
848 /* uit Sig.Proc.85 pag 253 */
849         void 
850 Mat3ToQuat(
851         float wmat[][3],
852         float *q
853 );
854         void 
855 i_translate(
856         float Tx, 
857         float Ty, 
858         float Tz, 
859         float mat[][4]
860 );
861         void 
862 i_multmatrix(
863         float icand[][4], 
864         float Vm[][4]
865 );
866         void 
867 i_rotate(
868         float angle, 
869         char axis, 
870         float mat[][4]
871 );
872         void 
873 VecMidf(
874         float *v, float *v1, float *v2
875 );
876         void 
877 Mat3ToSize(
878         float mat[][3], float *size
879 );
880         void 
881 Mat4ToSize(
882         float mat[][4], float *size
883 );
884         void 
885 triatoquat(
886         float *v1, 
887         float *v2, 
888         float *v3, float *quat
889 );
890         void 
891 MinMaxRGB(
892         short c[]
893 );
894         float
895 Vec2Lenf(
896         float *v1,
897         float *v2
898 );
899         void 
900 Vec2Mulf(
901         float *v1, 
902         float f
903 );
904         void 
905 Vec2Addf(
906         float *v,
907         float *v1, 
908         float *v2
909 );
910         void 
911 Vec2Subf(
912         float *v,
913         float *v1, 
914         float *v2
915 );
916         void
917 Vec2Copyf(
918         float *v1,
919         float *v2
920 );
921         float 
922 Inp2f(
923         float *v1, 
924         float *v2
925 );
926         float 
927 Normalise2(
928         float *n
929 );
930
931 void LocEulSizeToMat4(float mat[][4], float loc[3], float eul[3], float size[3]);
932
933 void tubemap(float x, float y, float z, float *u, float *v);
934 void spheremap(float x, float y, float z, float *u, float *v);
935                           
936 int LineIntersectsTriangle(float p1[3], float p2[3], float v0[3], float v1[3], float v2[3], float *lambda);
937 int point_in_tri_prism(float p[3], float v1[3], float v2[3], float v3[3]);
938                           
939 #ifdef __cplusplus
940 }
941 #endif
942         
943 #endif
944