Biiig commit! Thanks to 2-3 weeks of cvs freeze...
[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 #define MAT4_UNITY {{ 1.0, 0.0, 0.0, 0.0},\
48                                         { 0.0, 1.0, 0.0, 0.0},\
49                                         { 0.0, 0.0, 1.0, 0.0},\
50                                         { 0.0, 0.0, 0.0, 1.0}}
51
52 #define MAT3_UNITY {{ 1.0, 0.0, 0.0},\
53                                         { 0.0, 1.0, 0.0},\
54                                         { 0.0, 0.0, 1.0}}
55
56
57 /* matrix operations */
58 /* void Mat4MulMat4(float m1[][4], float m2[][4], float m3[][4]); */
59 /* void Mat3MulVecfl(float mat[][3], float *vec);  */
60 /* or **mat, but it's the same */
61 /*void Mat3MulVecd(float mat[][3], double *vec); */
62
63 /* void Mat4MulVecfl(float mat[][4], float *vec); */
64 /* void Mat4MulSerie(float answ[][4], float m1[][4], float m2[][4],  */
65 /*                   float m3[][4], float m4[][4], float m5[][4],  */
66 /*                   float m6[][4], float m7[][4], float m8[][4]); */
67 /* int Mat4Invert(float inverse[][4], float mat[][4]); */
68
69 /* m2 to m1 */
70 /*  void Mat3CpyMat4(float m1p[][3], float m2p[][4]); */
71 /* void Mat3CpyMat4(float *m1p, float *m2p); */
72
73 /* m1 to m2 */
74 /*  void Mat3CpyMat3(float m1p[][3], float m2p[][3]); */
75 /* void Mat3CpyMat3(float *m1p, float *m2p); */
76
77 /* m2 to m1 */
78 /* void Mat4CpyMat3(float m1p[][4], float m2p[][3]); */
79
80 /* M1 = M3*M2 */
81 /*  void Mat3MulMat3(float m1[][3], float m2[][3], float m3[][3]); */
82 /*void Mat3MulMat3(float *m1, float *m3, float *m2); */
83
84 /* m1 = m2 * m3, ignore the elements on the 4th row/column of m3 */
85 /*void Mat3IsMat3MulMat4(float m1[][3], float m2[][3], float m3[][4]); */
86
87 /* m1 to m2 */
88 /*  void Mat4CpyMat4(float m1[][4], float m2[][4]); */
89 /* void Mat4CpyMat4(float *m1, float *m2); */
90
91
92 /* void Mat4Ortho(float mat[][4]); */
93 /* void Mat4Mul3Vecfl(float mat[][4], float *vec); */
94 /* void Mat4MulVec4fl(float mat[][4], float *vec); */
95 /* void Mat4SwapMat4(float *m1, float *m2); */
96
97 /* void Mat3Inv(float m1[][3], float m2[][3]); */
98 /* void Mat4One(float m[][4]); */
99 /* void Mat3One(float m[][3]); */
100
101
102         void 
103 CalcCent3f(
104         float *cent,  float *v1, float *v2, float *v3
105 );
106
107         void 
108 CalcCent4f(
109         float *cent, float *v1, 
110         float *v2, float *v3,
111         float *v4
112 );
113
114         void 
115 Crossf(
116         float *c, float *a, float *b
117 );
118
119         void 
120 Projf(
121         float *c, float *v1, float *v2
122 );
123
124 /**
125  * Euler conversion routines
126  */
127
128         void 
129 EulToMat3(
130         float *eul, 
131         float mat[][3]
132 );
133         void 
134 EulToMat4(
135         float* eul, 
136         float mat[][4]
137 );
138
139         void 
140 Mat3ToEul(
141         float tmat[][3],
142         float *eul
143 );
144
145 /**
146  * @section Quaternion arithmetic routines
147  */
148
149         void 
150 QuatToEul(
151         float *quat, 
152         float *eul
153 );
154         void 
155 QuatOne(
156         float *
157 );
158         void 
159 QuatMul(
160         float *, 
161         float *, 
162         float *
163 );
164         void 
165 NormalQuat(
166         float *
167 );
168         void 
169 VecRotToQuat(
170         float *vec,
171         float phi,
172         float *quat
173 );
174         void 
175 QuatSub(
176         float *q, 
177         float *q1, 
178         float *q2
179 );
180
181
182 void QuatInterpol(float *result, float *quat1, float *quat2, float t);
183 void QuatAdd(float *result, float *quat1, float *quat2, float t);
184
185
186 /**
187  * @section matrix multiplication can copying routines
188  */
189
190         void 
191 Mat3MulFloat(
192         float *m, 
193         float f
194 );
195         void 
196 Mat4MulFloat(
197         float *m, 
198         float f
199 );
200         void 
201 Mat4MulFloat3(
202         float *m, 
203         float f
204 );
205         void 
206 Mat3Transp(
207         float mat[][3]
208 );
209         void 
210 Mat4Transp(
211         float mat[][4]
212 );
213         int 
214 Mat4Invert(
215         float inverse[][4], 
216         float mat[][4]
217 );
218         void 
219 Mat4InvertSimp(
220         float inverse[][4],
221         float mat[][4]
222 );
223         void 
224 Mat4Inv(
225         float *m1, 
226         float *m2
227 );
228         void 
229 Mat4InvGG(
230         float out[][4], 
231         float in[][4]
232 );
233         void 
234 Mat3CpyMat4(
235         float m1[][3],
236         float m2[][4]
237 );
238
239         void 
240 Mat3Inv(
241         float m1[][3], 
242         float m2[][3]
243 );
244
245         void 
246 Mat4CpyMat3(
247         float m1[][4], 
248         float m2[][3]
249 ); 
250
251         float 
252 Det2x2(
253         float a,float b,float c,float d
254 );
255
256         float 
257 Det3x3(
258         float a1, float a2, float a3,
259         float b1, float b2, float b3,
260         float c1, float c2, float c3 
261 );
262
263         float 
264 Det4x4(
265         float m[][4]
266 );
267
268         void 
269 Mat4Adj(
270         float out[][4], 
271         float in[][4]
272 );
273         void 
274 Mat3Adj(
275         float m1[][3], 
276         float m[][3]
277 );
278         void 
279 Mat4MulMat4(
280         float m1[][4], 
281         float m2[][4], 
282         float m3[][4]
283 );
284         void 
285 subMat4MulMat4(
286         float *m1, 
287         float *m2, 
288         float *m3
289 );
290 #ifndef TEST_ACTIVE
291         void 
292 Mat3MulMat3(
293         float m1[][3], 
294         float m3[][3], 
295         float m2[][3]
296 );
297 #else
298         void 
299 Mat3MulMat3(
300         float *m1, 
301         float *m3, 
302         float *m2
303 );
304 #endif
305         void 
306 Mat4MulMat34(
307         float (*m1)[4], 
308         float (*m3)[3], 
309         float (*m2)[4]
310 );
311         void 
312 Mat4CpyMat4(
313         float m1[][4], 
314         float m2[][4]
315 );
316         void 
317 Mat4SwapMat4(
318         float *m1, 
319         float *m2
320 );
321         void 
322 Mat3CpyMat3(
323         float m1[][3], 
324         float m2[][3]
325 );
326         void 
327 Mat3MulSerie(
328         float answ[][3],
329         float m1[][3], float m2[][3], float m3[][3],
330         float m4[][3], float m5[][3], float m6[][3],
331         float m7[][3], float m8[][3]
332 );
333         void 
334 Mat4MulSerie(
335         float answ[][4], 
336         float m1[][4],
337         float m2[][4], float m3[][4], float m4[][4],
338         float m5[][4], float m6[][4], float m7[][4],
339         float m8[][4]
340 );
341         void 
342 Mat4Clr(
343         float *m
344 );
345         void 
346 Mat3Clr(
347         float *m
348 );
349         void 
350 Mat3One(
351         float m[][3]
352 );
353         void 
354 Mat4MulVec(
355         float mat[][4],
356         int *vec
357 );
358         void 
359 VecMat4MulVecfl(
360         float *in, 
361         float mat[][4], 
362         float *vec
363 );
364         void 
365 Mat4MulMat43(
366         float (*m1)[4], 
367         float (*m3)[4], 
368         float (*m2)[3]
369 );
370
371         void 
372 Mat3IsMat3MulMat4(
373         float m1[][3], 
374         float m2[][3], 
375         float m3[][4]
376 );
377         void 
378 Mat4One(
379         float m[][4]
380 );
381         void 
382 Mat4Mul3Vecfl(
383         float mat[][4], 
384         float *vec
385 );
386         void 
387 Mat4MulVec4fl(
388         float mat[][4], 
389         float *vec
390 );
391         void 
392 Mat3MulVec(
393         float mat[][3],
394         int *vec
395 );
396         void 
397 Mat4MulVecfl(
398         float mat[][4], 
399         float *vec
400 );
401         void 
402 Mat4ToQuat(
403         float m[][4], 
404         float *q
405 );
406         void 
407 VecUpMat3old(
408         float *vec, 
409         float mat[][3], 
410         short axis
411 );
412         int 
413 FloatCompare(
414         float *v1, 
415         float *v2, 
416         float limit
417 );
418         float 
419 Normalise(
420         float *n
421 );
422         float 
423 CalcNormFloat(
424         float *v1,
425         float *v2,
426         float *v3,
427         float *n
428 );
429
430         float 
431 CalcNormFloat4(
432         float *v1,
433         float *v2,
434         float *v3,
435         float *v4,
436         float *n
437 );
438         float 
439 VecLenf(
440         float *v1, 
441         float *v2
442 );
443         void 
444 VecMulf(
445         float *v1, 
446         float f
447 );
448         int 
449 VecCompare(
450         float *v1, 
451         float *v2, 
452         float limit
453 );
454         float 
455 Sqrt3f(
456         float f
457 );
458         double 
459 Sqrt3d(
460         double d
461 );
462
463         void 
464 euler_rot(
465         float *beul, 
466         float ang, 
467         char axis
468 );
469         float 
470 saacos(
471         float fac
472 );
473         float 
474 sasqrt(
475         float fac
476 );
477         void
478 printvecf(
479         char *str,
480         float v[3]
481 );
482         float 
483 Inpf(
484         float *v1, 
485         float *v2
486 );
487         void 
488 VecSubf(
489         float *v, 
490         float *v1, 
491         float *v2
492 );
493         void 
494 VecAddf(
495         float *v, 
496         float *v1, 
497         float *v2
498 );
499         void 
500 VecUpMat3(
501         float *vec, 
502         float mat[][3], 
503         short axis
504 );
505         float 
506 DistVL2Dfl(
507         float *v1,
508         float *v2,
509         float *v3
510 );
511         float 
512 PdistVL2Dfl(
513         float *v1,
514         float *v2,
515         float *v3
516 );
517         float 
518 AreaF2Dfl(
519         float *v1, 
520         float *v2, 
521         float *v3
522 );
523         float 
524 AreaQ3Dfl(
525         float *v1, 
526         float *v2, 
527         float *v3, 
528         float *v4
529 );
530         float 
531 AreaT3Dfl(
532         float *v1, 
533         float *v2, 
534         float *v3
535 );
536         float 
537 AreaPoly3Dfl(
538         int nr, 
539         float *verts, 
540         float *normal
541 );
542         void 
543 VecRotToMat3(
544         float *vec, 
545         float phi, 
546         float mat[][3]
547 );
548
549 /* intersect Line-Line
550         return:
551         -1: colliniar
552          0: no intersection of segments
553          1: exact intersection of segments
554          2: cross-intersection of segments
555 */
556 extern short IsectLL2Df(float *v1, float *v2, float *v3, float *v4);
557 extern short IsectLL2Ds(short *v1, short *v2, short *v3, short *v4);
558
559
560         float *
561 vectoquat(
562         float *vec, 
563         short axis, 
564         short upflag
565 );
566
567         void 
568 i_lookat(
569         float vx, float vy, 
570         float vz, float px, 
571         float py, float pz, 
572         float twist, float mat[][4]
573 );
574         void 
575 i_window(
576         float left, float right,
577         float bottom, float top,
578         float nearClip, float farClip,
579         float mat[][4]
580 );
581
582         void 
583 hsv_to_rgb(
584         float h, float s, 
585         float v, float *r, 
586         float *g, float *b
587 );
588
589         void 
590 rgb_to_hsv(
591         float r, float g, float b, 
592         float *lh, float *ls, float *lv
593 );
594         unsigned int 
595 hsv_to_cpack(
596         float h, float s, float v
597 );
598         unsigned int 
599 rgb_to_cpack(
600         float r, float g, float b
601 );
602         void 
603 cpack_to_rgb(
604         unsigned int col, 
605         float *r, float *g, float *b
606 );
607
608         void 
609 EulToQuat(
610         float *eul, 
611         float *quat
612 );
613
614         void 
615 Mat3MulVecfl(
616         float mat[][3], 
617         float *vec
618 );
619         void 
620 Mat3MulVecd(
621         float mat[][3], 
622         double *vec
623 );
624         void 
625 Mat3TransMulVecfl(
626         float mat[][3], 
627         float *vec
628 );
629         void 
630 VecStar(
631         float mat[][3],
632         float *vec
633 );
634         short 
635 EenheidsMat(
636         float mat[][3]
637 );
638         void 
639 printmatrix3(
640         char *str, float m[][3]
641 );
642         void 
643 QuatToMat3(
644         float *q, 
645         float m[][3]
646 );
647         void 
648 QuatToMat4(
649         float *q, 
650         float m[][4]
651 );
652         void 
653 Mat3ToQuat_is_ok(
654         float wmat[][3], 
655         float *q
656 );
657         void 
658 i_ortho(
659         float left, float right, 
660         float bottom, float top, 
661         float nearClip, float farClip, 
662         float matrix[][4]
663 );
664         void 
665 i_polarview(
666         float dist, float azimuth, float incidence, float twist, 
667         float Vm[][4]
668 );
669         void 
670 Mat3Ortho(
671         float mat[][3]
672 );
673         void 
674 Mat4Ortho(
675         float mat[][4]
676 );
677         void 
678 VecCopyf(
679         float *v1, 
680         float *v2
681 );
682         int 
683 VecLen(
684         int *v1, 
685         int *v2
686 );
687         void 
688 CalcNormShort(
689         short *v1, 
690         short *v2, 
691         short *v3, 
692         float *n
693 ) /* is ook uitprodukt */;
694
695         void 
696 CalcNormLong(
697         int* v1, 
698         int*v2, 
699         int*v3, 
700         float *n
701 );
702         void 
703 MinMax3(
704         float *min, 
705         float *max, 
706         float *vec
707 );
708         void 
709 Mat3ToEuln(
710         float tmat[][3],
711         float *eul
712 );
713         void 
714 SizeToMat3(
715         float *size, 
716         float mat[][3]
717 );
718         void 
719 printmatrix4(
720         char *str, 
721         float m[][4]
722 );
723 /* uit Sig.Proc.85 pag 253 */
724         void 
725 Mat3ToQuat(
726         float wmat[][3],
727         float *q
728 );
729         void 
730 i_translate(
731         float Tx, 
732         float Ty, 
733         float Tz, 
734         float mat[][4]
735 );
736         void 
737 i_multmatrix(
738         float icand[][4], 
739         float Vm[][4]
740 );
741         void 
742 i_rotate(
743         float angle, 
744         char axis, 
745         float mat[][4]
746 );
747         void 
748 VecMidf(
749         float *v, float *v1, float *v2
750 );
751         void 
752 Mat3ToSize(
753         float mat[][3], float *size
754 );
755         void 
756 Mat4ToSize(
757         float mat[][4], float *size
758 );
759         void 
760 triatoquat(
761         float *v1, 
762         float *v2, 
763         float *v3, float *quat
764 );
765         void 
766 MinMaxRGB(
767         short c[]
768 );
769         float
770 Vec2Lenf(
771         float *v1,
772         float *v2
773 );
774         void 
775 Vec2Mulf(
776         float *v1, 
777         float f
778 );
779         void 
780 Vec2Addf(
781         float *v,
782         float *v1, 
783         float *v2
784 );
785
786 void tubemap(float x, float y, float z, float *u, float *v);
787 void spheremap(float x, float y, float z, float *u, float *v);
788                           
789                           
790 #ifdef __cplusplus
791 }
792 #endif
793         
794 #endif
795