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