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