some tiny changes to the softbody system
[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 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         float 
516 Sqrt3f(
517         float f
518 );
519         double 
520 Sqrt3d(
521         double d
522 );
523
524         void 
525 euler_rot(
526         float *beul, 
527         float ang, 
528         char axis
529 );
530         float 
531 saacos(
532         float fac
533 );
534         float 
535 sasqrt(
536         float fac
537 );
538         void
539 printvecf(
540         char *str,
541         float v[3]
542 );
543         void
544 printvec4f(
545         char *str,
546         float v[4]
547 );
548         float 
549 Inpf(
550         float *v1, 
551         float *v2
552 );
553         void 
554 VecSubf(
555         float *v, 
556         float *v1, 
557         float *v2
558 );
559         void 
560 VecAddf(
561         float *v, 
562         float *v1, 
563         float *v2
564 );
565         void
566 VecLerpf(
567         float *target, 
568         float *a, 
569         float *b,
570         float t
571 );
572         void 
573 VecUpMat3(
574         float *vec, 
575         float mat[][3], 
576         short axis
577 );
578         float 
579 DistVL2Dfl(
580         float *v1,
581         float *v2,
582         float *v3
583 );
584         float 
585 PdistVL2Dfl(
586         float *v1,
587         float *v2,
588         float *v3
589 );
590         float 
591 AreaF2Dfl(
592         float *v1, 
593         float *v2, 
594         float *v3
595 );
596         float 
597 AreaQ3Dfl(
598         float *v1, 
599         float *v2, 
600         float *v3, 
601         float *v4
602 );
603         float 
604 AreaT3Dfl(
605         float *v1, 
606         float *v2, 
607         float *v3
608 );
609         float 
610 AreaPoly3Dfl(
611         int nr, 
612         float *verts, 
613         float *normal
614 );
615         void 
616 VecRotToMat3(
617         float *vec, 
618         float phi, 
619         float mat[][3]
620 );
621
622 /* intersect Line-Line
623         return:
624         -1: colliniar
625          0: no intersection of segments
626          1: exact intersection of segments
627          2: cross-intersection of segments
628 */
629 extern short IsectLL2Df(float *v1, float *v2, float *v3, float *v4);
630 extern short IsectLL2Ds(short *v1, short *v2, short *v3, short *v4);
631
632
633         float *
634 vectoquat(
635         float *vec, 
636         short axis, 
637         short upflag
638 );
639
640         float
641 VecAngle3(
642         float *v1, 
643         float *v2,
644         float *v3
645 );
646
647         float
648 VecAngle2(
649         float *v1, 
650         float *v2
651 );
652
653         void 
654 i_lookat(
655         float vx, float vy, 
656         float vz, float px, 
657         float py, float pz, 
658         float twist, float mat[][4]
659 );
660         void 
661 i_window(
662         float left, float right,
663         float bottom, float top,
664         float nearClip, float farClip,
665         float mat[][4]
666 );
667
668         void 
669 hsv_to_rgb(
670         float h, float s, 
671         float v, float *r, 
672         float *g, float *b
673 );
674
675 void hex_to_rgb(char *hexcol, float *r, float *g, float *b);
676
677         void 
678 rgb_to_hsv(
679         float r, float g, float b, 
680         float *lh, float *ls, float *lv
681 );
682         unsigned int 
683 hsv_to_cpack(
684         float h, float s, float v
685 );
686         unsigned int 
687 rgb_to_cpack(
688         float r, float g, float b
689 );
690         void 
691 cpack_to_rgb(
692         unsigned int col, 
693         float *r, float *g, float *b
694 );
695
696         void 
697 EulToQuat(
698         float *eul, 
699         float *quat
700 );
701
702         void 
703 Mat3MulVecfl(
704         float mat[][3], 
705         float *vec
706 );
707         void 
708 Mat3MulVecd(
709         float mat[][3], 
710         double *vec
711 );
712         void 
713 Mat3TransMulVecfl(
714         float mat[][3], 
715         float *vec
716 );
717         void 
718 VecStar(
719         float mat[][3],
720         float *vec
721 );
722         short 
723 EenheidsMat(
724         float mat[][3]
725 );
726         void 
727 printmatrix3(
728         char *str, float m[][3]
729 );
730         void 
731 QuatToMat3(
732         float *q, 
733         float m[][3]
734 );
735         void 
736 QuatToMat4(
737         float *q, 
738         float m[][4]
739 );
740         void 
741 Mat3ToQuat_is_ok(
742         float wmat[][3], 
743         float *q
744 );
745         void 
746 i_ortho(
747         float left, float right, 
748         float bottom, float top, 
749         float nearClip, float farClip, 
750         float matrix[][4]
751 );
752         void 
753 i_polarview(
754         float dist, float azimuth, float incidence, float twist, 
755         float Vm[][4]
756 );
757         void 
758 Mat3Ortho(
759         float mat[][3]
760 );
761         void 
762 Mat4Ortho(
763         float mat[][4]
764 );
765         void 
766 VecCopyf(
767         float *v1, 
768         float *v2
769 );
770         int 
771 VecLen(
772         int *v1, 
773         int *v2
774 );
775         void 
776 CalcNormShort(
777         short *v1, 
778         short *v2, 
779         short *v3, 
780         float *n
781 ) /* is ook uitprodukt */;
782
783         void 
784 CalcNormLong(
785         int* v1, 
786         int*v2, 
787         int*v3, 
788         float *n
789 );
790         void 
791 MinMax3(
792         float *min, 
793         float *max, 
794         float *vec
795 );
796
797         void 
798 SizeToMat3(
799         float *size, 
800         float mat[][3]
801 );
802         void 
803 printmatrix4(
804         char *str, 
805         float m[][4]
806 );
807 /* uit Sig.Proc.85 pag 253 */
808         void 
809 Mat3ToQuat(
810         float wmat[][3],
811         float *q
812 );
813         void 
814 i_translate(
815         float Tx, 
816         float Ty, 
817         float Tz, 
818         float mat[][4]
819 );
820         void 
821 i_multmatrix(
822         float icand[][4], 
823         float Vm[][4]
824 );
825         void 
826 i_rotate(
827         float angle, 
828         char axis, 
829         float mat[][4]
830 );
831         void 
832 VecMidf(
833         float *v, float *v1, float *v2
834 );
835         void 
836 Mat3ToSize(
837         float mat[][3], float *size
838 );
839         void 
840 Mat4ToSize(
841         float mat[][4], float *size
842 );
843         void 
844 triatoquat(
845         float *v1, 
846         float *v2, 
847         float *v3, float *quat
848 );
849         void 
850 MinMaxRGB(
851         short c[]
852 );
853         float
854 Vec2Lenf(
855         float *v1,
856         float *v2
857 );
858         void 
859 Vec2Mulf(
860         float *v1, 
861         float f
862 );
863         void 
864 Vec2Addf(
865         float *v,
866         float *v1, 
867         float *v2
868 );
869         void 
870 Vec2Subf(
871         float *v,
872         float *v1, 
873         float *v2
874 );
875         void
876 Vec2Copyf(
877         float *v1,
878         float *v2
879 );
880         float 
881 Inp2f(
882         float *v1, 
883         float *v2
884 );
885         float 
886 Normalise2(
887         float *n
888 );
889
890 void tubemap(float x, float y, float z, float *u, float *v);
891 void spheremap(float x, float y, float z, float *u, float *v);
892                           
893 int LineIntersectsTriangle(float p1[3], float p2[3], float v0[3], float v1[3], float v2[3], float *lambda);
894 int point_in_tri_prism(float p[3], float v1[3], float v2[3], float v3[3]);
895                           
896 #ifdef __cplusplus
897 }
898 #endif
899         
900 #endif
901