Rotation constraint update.
[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 compatible_eul(float *eul, float *oldrot);
159
160 /**
161  * @section Quaternion arithmetic routines
162  */
163
164         void 
165 QuatToEul(
166         float *quat, 
167         float *eul
168 );
169         void 
170 QuatOne(
171         float *
172 );
173         void 
174 QuatMul(
175         float *, 
176         float *, 
177         float *
178 );
179         void 
180 QuatMulVecf(
181         float *q, 
182         float *v
183 );
184         void 
185 NormalQuat(
186         float *
187 );
188         void 
189 VecRotToQuat(
190         float *vec,
191         float phi,
192         float *quat
193 );
194         void 
195 QuatSub(
196         float *q, 
197         float *q1, 
198         float *q2
199 );
200         void 
201 QuatConj(
202         float *q 
203 );
204         void 
205 QuatInv(
206         float *q 
207 );
208         void 
209 QuatMulf(
210         float *q,
211         float f
212 );
213         float 
214 QuatDot(
215         float *q1, 
216         float *q2
217 );
218         void
219 printquat(
220         char *str,
221         float q[4]
222 );
223
224
225 void QuatInterpol(float *result, float *quat1, float *quat2, float t);
226 void QuatAdd(float *result, float *quat1, float *quat2, float t);
227
228
229 /**
230  * @section matrix multiplication can copying routines
231  */
232
233         void 
234 Mat3MulFloat(
235         float *m, 
236         float f
237 );
238         void 
239 Mat4MulFloat(
240         float *m, 
241         float f
242 );
243         void 
244 Mat4MulFloat3(
245         float *m, 
246         float f
247 );
248         void 
249 Mat3Transp(
250         float mat[][3]
251 );
252         void 
253 Mat4Transp(
254         float mat[][4]
255 );
256         int 
257 Mat4Invert(
258         float inverse[][4], 
259         float mat[][4]
260 );
261         void 
262 Mat4InvertSimp(
263         float inverse[][4],
264         float mat[][4]
265 );
266         void 
267 Mat4Inv(
268         float *m1, 
269         float *m2
270 );
271         void 
272 Mat4InvGG(
273         float out[][4], 
274         float in[][4]
275 );
276         void 
277 Mat3CpyMat4(
278         float m1[][3],
279         float m2[][4]
280 );
281
282         void 
283 Mat3Inv(
284         float m1[][3], 
285         float m2[][3]
286 );
287
288         void 
289 Mat4CpyMat3(
290         float m1[][4], 
291         float m2[][3]
292 ); 
293
294         float 
295 Det2x2(
296         float a,float b,float c,float d
297 );
298
299         float 
300 Det3x3(
301         float a1, float a2, float a3,
302         float b1, float b2, float b3,
303         float c1, float c2, float c3 
304 );
305
306         float 
307 Det4x4(
308         float m[][4]
309 );
310
311         void 
312 Mat4Adj(
313         float out[][4], 
314         float in[][4]
315 );
316         void 
317 Mat3Adj(
318         float m1[][3], 
319         float m[][3]
320 );
321         void 
322 Mat4MulMat4(
323         float m1[][4], 
324         float m2[][4], 
325         float m3[][4]
326 );
327         void 
328 subMat4MulMat4(
329         float *m1, 
330         float *m2, 
331         float *m3
332 );
333 #ifndef TEST_ACTIVE
334         void 
335 Mat3MulMat3(
336         float m1[][3], 
337         float m3[][3], 
338         float m2[][3]
339 );
340 #else
341         void 
342 Mat3MulMat3(
343         float *m1, 
344         float *m3, 
345         float *m2
346 );
347 #endif
348         void 
349 Mat4MulMat34(
350         float (*m1)[4], 
351         float (*m3)[3], 
352         float (*m2)[4]
353 );
354         void 
355 Mat4CpyMat4(
356         float m1[][4], 
357         float m2[][4]
358 );
359         void 
360 Mat4SwapMat4(
361         float *m1, 
362         float *m2
363 );
364         void 
365 Mat3CpyMat3(
366         float m1[][3], 
367         float m2[][3]
368 );
369         void 
370 Mat3MulSerie(
371         float answ[][3],
372         float m1[][3], float m2[][3], float m3[][3],
373         float m4[][3], float m5[][3], float m6[][3],
374         float m7[][3], float m8[][3]
375 );
376         void 
377 Mat4MulSerie(
378         float answ[][4], 
379         float m1[][4],
380         float m2[][4], float m3[][4], float m4[][4],
381         float m5[][4], float m6[][4], float m7[][4],
382         float m8[][4]
383 );
384         void 
385 Mat4Clr(
386         float *m
387 );
388         void 
389 Mat3Clr(
390         float *m
391 );
392         void 
393 Mat3One(
394         float m[][3]
395 );
396         void 
397 Mat4MulVec(
398         float mat[][4],
399         int *vec
400 );
401         void 
402 VecMat4MulVecfl(
403         float *in, 
404         float mat[][4], 
405         float *vec
406 );
407         void 
408 Mat4MulMat43(
409         float (*m1)[4], 
410         float (*m3)[4], 
411         float (*m2)[3]
412 );
413
414         void 
415 Mat3IsMat3MulMat4(
416         float m1[][3], 
417         float m2[][3], 
418         float m3[][4]
419 );
420         void 
421 Mat4One(
422         float m[][4]
423 );
424         void 
425 Mat4Mul3Vecfl(
426         float mat[][4], 
427         float *vec
428 );
429         void 
430 Mat4MulVec4fl(
431         float mat[][4], 
432         float *vec
433 );
434         void 
435 Mat3MulVec(
436         float mat[][3],
437         int *vec
438 );
439         void 
440 Mat4MulVecfl(
441         float mat[][4], 
442         float *vec
443 );
444         void 
445 Mat4ToQuat(
446         float m[][4], 
447         float *q
448 );
449         void 
450 VecUpMat3old(
451         float *vec, 
452         float mat[][3], 
453         short axis
454 );
455         int 
456 FloatCompare(
457         float *v1, 
458         float *v2, 
459         float limit
460 );
461         float 
462 Normalise(
463         float *n
464 );
465         float 
466 CalcNormFloat(
467         float *v1,
468         float *v2,
469         float *v3,
470         float *n
471 );
472
473         float 
474 CalcNormFloat4(
475         float *v1,
476         float *v2,
477         float *v3,
478         float *v4,
479         float *n
480 );
481         float 
482 VecLenf(
483         float *v1, 
484         float *v2
485 );
486     float 
487 VecLength(
488         float *v
489 );
490         void 
491 VecMulf(
492         float *v1, 
493         float f
494 );
495         int
496 VecLenCompare(
497         float *v1,
498         float *v2,
499         float limit
500 );
501         int 
502 VecCompare(
503         float *v1, 
504         float *v2, 
505         float limit
506 );
507         float 
508 Sqrt3f(
509         float f
510 );
511         double 
512 Sqrt3d(
513         double d
514 );
515
516         void 
517 euler_rot(
518         float *beul, 
519         float ang, 
520         char axis
521 );
522         float 
523 saacos(
524         float fac
525 );
526         float 
527 sasqrt(
528         float fac
529 );
530         void
531 printvecf(
532         char *str,
533         float v[3]
534 );
535         void
536 printvec4f(
537         char *str,
538         float v[4]
539 );
540         float 
541 Inpf(
542         float *v1, 
543         float *v2
544 );
545         void 
546 VecSubf(
547         float *v, 
548         float *v1, 
549         float *v2
550 );
551         void 
552 VecAddf(
553         float *v, 
554         float *v1, 
555         float *v2
556 );
557         void
558 VecLerpf(
559         float *target, 
560         float *a, 
561         float *b,
562         float t
563 );
564         void 
565 VecUpMat3(
566         float *vec, 
567         float mat[][3], 
568         short axis
569 );
570         float 
571 DistVL2Dfl(
572         float *v1,
573         float *v2,
574         float *v3
575 );
576         float 
577 PdistVL2Dfl(
578         float *v1,
579         float *v2,
580         float *v3
581 );
582         float 
583 AreaF2Dfl(
584         float *v1, 
585         float *v2, 
586         float *v3
587 );
588         float 
589 AreaQ3Dfl(
590         float *v1, 
591         float *v2, 
592         float *v3, 
593         float *v4
594 );
595         float 
596 AreaT3Dfl(
597         float *v1, 
598         float *v2, 
599         float *v3
600 );
601         float 
602 AreaPoly3Dfl(
603         int nr, 
604         float *verts, 
605         float *normal
606 );
607         void 
608 VecRotToMat3(
609         float *vec, 
610         float phi, 
611         float mat[][3]
612 );
613
614 /* intersect Line-Line
615         return:
616         -1: colliniar
617          0: no intersection of segments
618          1: exact intersection of segments
619          2: cross-intersection of segments
620 */
621 extern short IsectLL2Df(float *v1, float *v2, float *v3, float *v4);
622 extern short IsectLL2Ds(short *v1, short *v2, short *v3, short *v4);
623
624
625         float *
626 vectoquat(
627         float *vec, 
628         short axis, 
629         short upflag
630 );
631
632         float
633 VecAngle3(
634         float *v1, 
635         float *v2,
636         float *v3
637 );
638
639         float
640 VecAngle2(
641         float *v1, 
642         float *v2
643 );
644
645         void 
646 i_lookat(
647         float vx, float vy, 
648         float vz, float px, 
649         float py, float pz, 
650         float twist, float mat[][4]
651 );
652         void 
653 i_window(
654         float left, float right,
655         float bottom, float top,
656         float nearClip, float farClip,
657         float mat[][4]
658 );
659
660         void 
661 hsv_to_rgb(
662         float h, float s, 
663         float v, float *r, 
664         float *g, float *b
665 );
666
667 void hex_to_rgb(char *hexcol, float *r, float *g, float *b);
668
669         void 
670 rgb_to_hsv(
671         float r, float g, float b, 
672         float *lh, float *ls, float *lv
673 );
674         unsigned int 
675 hsv_to_cpack(
676         float h, float s, float v
677 );
678         unsigned int 
679 rgb_to_cpack(
680         float r, float g, float b
681 );
682         void 
683 cpack_to_rgb(
684         unsigned int col, 
685         float *r, float *g, float *b
686 );
687
688         void 
689 EulToQuat(
690         float *eul, 
691         float *quat
692 );
693
694         void 
695 Mat3MulVecfl(
696         float mat[][3], 
697         float *vec
698 );
699         void 
700 Mat3MulVecd(
701         float mat[][3], 
702         double *vec
703 );
704         void 
705 Mat3TransMulVecfl(
706         float mat[][3], 
707         float *vec
708 );
709         void 
710 VecStar(
711         float mat[][3],
712         float *vec
713 );
714         short 
715 EenheidsMat(
716         float mat[][3]
717 );
718         void 
719 printmatrix3(
720         char *str, float m[][3]
721 );
722         void 
723 QuatToMat3(
724         float *q, 
725         float m[][3]
726 );
727         void 
728 QuatToMat4(
729         float *q, 
730         float m[][4]
731 );
732         void 
733 Mat3ToQuat_is_ok(
734         float wmat[][3], 
735         float *q
736 );
737         void 
738 i_ortho(
739         float left, float right, 
740         float bottom, float top, 
741         float nearClip, float farClip, 
742         float matrix[][4]
743 );
744         void 
745 i_polarview(
746         float dist, float azimuth, float incidence, float twist, 
747         float Vm[][4]
748 );
749         void 
750 Mat3Ortho(
751         float mat[][3]
752 );
753         void 
754 Mat4Ortho(
755         float mat[][4]
756 );
757         void 
758 VecCopyf(
759         float *v1, 
760         float *v2
761 );
762         int 
763 VecLen(
764         int *v1, 
765         int *v2
766 );
767         void 
768 CalcNormShort(
769         short *v1, 
770         short *v2, 
771         short *v3, 
772         float *n
773 ) /* is ook uitprodukt */;
774
775         void 
776 CalcNormLong(
777         int* v1, 
778         int*v2, 
779         int*v3, 
780         float *n
781 );
782         void 
783 MinMax3(
784         float *min, 
785         float *max, 
786         float *vec
787 );
788         void 
789 Mat3ToEuln(
790         float tmat[][3],
791         float *eul
792 );
793         void 
794 SizeToMat3(
795         float *size, 
796         float mat[][3]
797 );
798         void 
799 printmatrix4(
800         char *str, 
801         float m[][4]
802 );
803 /* uit Sig.Proc.85 pag 253 */
804         void 
805 Mat3ToQuat(
806         float wmat[][3],
807         float *q
808 );
809         void 
810 i_translate(
811         float Tx, 
812         float Ty, 
813         float Tz, 
814         float mat[][4]
815 );
816         void 
817 i_multmatrix(
818         float icand[][4], 
819         float Vm[][4]
820 );
821         void 
822 i_rotate(
823         float angle, 
824         char axis, 
825         float mat[][4]
826 );
827         void 
828 VecMidf(
829         float *v, float *v1, float *v2
830 );
831         void 
832 Mat3ToSize(
833         float mat[][3], float *size
834 );
835         void 
836 Mat4ToSize(
837         float mat[][4], float *size
838 );
839         void 
840 triatoquat(
841         float *v1, 
842         float *v2, 
843         float *v3, float *quat
844 );
845         void 
846 MinMaxRGB(
847         short c[]
848 );
849         float
850 Vec2Lenf(
851         float *v1,
852         float *v2
853 );
854         void 
855 Vec2Mulf(
856         float *v1, 
857         float f
858 );
859         void 
860 Vec2Addf(
861         float *v,
862         float *v1, 
863         float *v2
864 );
865         void 
866 Vec2Subf(
867         float *v,
868         float *v1, 
869         float *v2
870 );
871         void
872 Vec2Copyf(
873         float *v1,
874         float *v2
875 );
876         float 
877 Inp2f(
878         float *v1, 
879         float *v2
880 );
881         float 
882 Normalise2(
883         float *n
884 );
885
886 void tubemap(float x, float y, float z, float *u, float *v);
887 void spheremap(float x, float y, float z, float *u, float *v);
888                           
889 int LineIntersectsTriangle(float p1[3], float p2[3], float v0[3], float v1[3], float v2[3], float *lambda);
890                           
891 #ifdef __cplusplus
892 }
893 #endif
894         
895 #endif
896