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