Pipeline graphique
 Tout Structures de données Espaces de nommage Fichiers Fonctions Variables Définitions de type Énumérations Valeurs énumérées Macros
libMath.h
Aller à la documentation de ce fichier.
1 #ifndef _DEF_MATH
2 #define _DEF_MATH
3 // basic math
4 // vector: vecteur3d, vecteur4d
5 // matrix: matrice22, matrice33, matrice44
6 // and associated functions/operators/methods
7 #include <math.h>
8 #include <memory.h>
9 #include <iostream>
10 #include <cstdio>
11 #include <cstdlib>
12 #include <utility>
13 
14 
15 
16 namespace Math {
17  // Pour résoudre les problèmes de dépendances cyclique
18  struct matrice44;
19 
21  struct coord2d {
22  int x, y;
23  inline coord2d() {x = 0; y = 0;}
24  inline coord2d(int x, int y) {this->x = x ; this->y = y;}
25  inline void set(int x,int y) {this->x = x; this->y = y;}
26  inline coord2d& operator-=(const coord2d &v) { x-=v.x; y-=v.y; return *this; }
27  inline void print(){std::cout << "x : " << x << " y : " << y << std::endl;}
28  };
29  inline coord2d operator-(const coord2d &v1, const coord2d &v2) { return coord2d(v1.x-v2.x,v1.y-v2.y); }
30  inline float dot3(coord2d v1, coord2d v2) { return v1.x*v2.x + v1.y*v2.y ; }
31  struct vecteur3d {
33  // @{
34  float x,y,z;
35  // @}
37  inline void set(float _x, float _y, float _z) { x=_x; y=_y; z=_z; }
39  inline void set(float v) { x=v; y=v; z=v; }
41  inline void vector(vecteur3d v1, vecteur3d v2) { x=v1.x-v2.x; y=v1.y-v2.y; z=v1.z-v2.z; }
43  inline vecteur3d() {}
45  inline vecteur3d(float _x, float _y, float _z) { set(_x,_y,_z); }
47  inline vecteur3d(float v) { set(v,v,v); }
49  inline void mul(float v) { x*=v; y*=v; z*=v; }
51  inline float norm2(void) { return x*x+y*y+z*z; }
53  inline float norm(void) { return sqrt(norm2()); }
55  inline bool normalize(const float nrm) { if (nrm == 0.f) return false; else mul(1.f/nrm); return true; }
57  inline bool normalize2(const float nrm2) { if (nrm2 == 0.f) return false; else { mul(1.f/sqrt(nrm2)); return true; } }
59  inline bool normalize(void) { float nrm2 = norm2(); return normalize2(nrm2); }
61  inline void cross(const vecteur3d &v1, const vecteur3d &v2) { x = v1.y*v2.z - v1.z*v2.y; y = v1.z*v2.x - v1.x*v2.z; z = v1.x*v2.y - v1.y*v2.x; }
63  inline vecteur3d& operator=(const vecteur3d &v) { x=v.x; y=v.y; z=v.z; return *this; }
65  inline vecteur3d& operator+=(const vecteur3d &v) { x+=v.x; y+=v.y; z+=v.z; return *this; }
67  inline vecteur3d& operator-=(const vecteur3d &v) { x-=v.x; y-=v.y; z-=v.z; return *this; }
69  inline vecteur3d& operator*=(const vecteur3d &v) { x*=v.x; y*=v.y; z*=v.z; return *this; }
71  inline vecteur3d& operator*=(const float v) { x*=v; y*=v; z*=v; return *this; }
73  inline void mul(matrice44 &M, vecteur3d &v); // déclaration plus loin
74  inline void print(){std::cout << "x : " << x << " y : " << y << " z : " << z << std::endl;}
75  };
77  inline vecteur3d operator+(const vecteur3d &v1, const vecteur3d &v2) { return vecteur3d(v1.x+v2.x,v1.y+v2.y,v1.z+v2.z); }
79  inline vecteur3d operator+(const vecteur3d &v, const float a) { return vecteur3d(v.x+a,v.y+a,v.z+a); }
81  inline vecteur3d operator+(const float a, const vecteur3d &v) { return vecteur3d(v.x+a,v.y+a,v.z+a); }
83  inline vecteur3d operator-(const vecteur3d &v1, const vecteur3d &v2) { return vecteur3d(v1.x-v2.x,v1.y-v2.y,v1.z-v2.z); }
84 
86  inline vecteur3d operator*(const vecteur3d &v1, const vecteur3d &v2) { return vecteur3d(v1.x*v2.x,v1.y*v2.y,v1.z*v2.z); }
88  inline vecteur3d operator*(const vecteur3d &v, const float a) { return vecteur3d(v.x*a,v.y*a,v.z*a); }
90  inline vecteur3d operator*(const float a, const vecteur3d &v) { return vecteur3d(v.x*a,v.y*a,v.z*a); }
92  inline float dot3(vecteur3d &v1, vecteur3d &v2) { return v1.x*v2.x + v1.y*v2.y + v1.z*v2.z; }
93 
95  struct vecteur4d {
97  float x,y,z,w;
99  inline void set(float _x, float _y, float _z, float _w) { x=_x; y=_y; z=_z; w=_w; }
101  inline void set(vecteur3d &_v, float _w) { x=_v.x; y=_v.y; z=_v.z; w=_w; }
103  inline vecteur4d() {}
105  inline vecteur4d(float _x, float _y, float _z, float _w) { set(_x,_y,_z,_w); }
107  inline vecteur4d(vecteur3d &_v, float _w) { set(_v,_w); }
108 
110  inline void mul(float v) { x*=v; y*=v; z*=v; w*=v; }
112  inline float norm2(void) { return x*x+y*y+z*z+w*w; }
114  inline float norm(void) { return sqrt(norm2()); }
116  inline bool normalize(const float nrm) { if (nrm == 0.f) return false; else mul(1.f/nrm); return true; }
118  inline bool normalize2(const float nrm2) { if (nrm2 == 0.f) return false; else { mul(1.f/sqrt(nrm2)); return true; } }
120  inline bool normalize(void) { float nrm2 = norm2(); return normalize2(nrm2); }
122  inline vecteur4d& operator=(const vecteur4d &v) { x=v.x; y=v.y; z=v.z; w=v.w; return *this; }
124  inline void mul(matrice44 &M, vecteur4d &v);
125 
126  inline void print(){std::cout << "x : " << x << " y : " << y << " z : " << z <<" w : " << w << std::endl;}
127  };
129  inline vecteur4d operator+(const vecteur4d &v1, const vecteur4d &v2) { return vecteur4d(v1.x+v2.x,v1.y+v2.y,v1.z+v2.z,v1.w+v2.w); }
131  inline vecteur4d operator+(const vecteur4d &v, const float a) { return vecteur4d(v.x+a,v.y+a,v.z+a,v.w+a); }
133  inline vecteur4d operator+(const float a, const vecteur4d &v) { return vecteur4d(v.x+a,v.y+a,v.z+a,v.w+a); }
135  inline vecteur4d operator-(const vecteur4d &v1, const vecteur4d &v2) { return vecteur4d(v1.x-v2.x,v1.y-v2.y,v1.z-v2.z,v1.w-v2.w); }
137  inline vecteur4d operator*(const vecteur4d &v1, const vecteur4d &v2) { return vecteur4d(v1.x*v2.x,v1.y*v2.y,v1.z*v2.z,v1.w*v2.w); }
139  inline vecteur4d operator*(const vecteur4d &v, const float a) { return vecteur4d(v.x*a,v.y*a,v.z*a,v.w*a); }
141  inline vecteur4d operator*(const float a, const vecteur4d &v) { return vecteur4d(v.x*a,v.y*a,v.z*a,v.w*a); }
142  inline vecteur3d operator-(const vecteur3d &v1, const vecteur4d &v2) { return vecteur3d(v1.x-v2.x,v1.y-v2.y,v1.z-v2.z); }
143  inline vecteur3d operator-(const vecteur4d &v1, const vecteur3d &v2) { return vecteur3d(v1.x-v2.x,v1.y-v2.y,v1.z-v2.z); }
145  inline float _det3(float *_v1, float *_v2, float *_v3) {
146  vecteur3d &v1 = *(vecteur3d*)_v1, &v2 = *(vecteur3d*)_v2, &v3 = *(vecteur3d*)_v3;
147  return v1.x*( v2.y*v3.z - v2.z*v3.y) - v1.y*( v2.x*v3.z - v2.z*v3.x) + v1.z*( v2.x*v3.y - v3.x*v2.y);
148  }
149 
151  struct matrice22 {
153  // @{
154  float m11, m12, m21, m22;
155  // @}
157  inline matrice22() {}
159  inline matrice22(float _m11, float _m12, float _m21, float _m22) {
160  m11 = _m11; m12 = _m12; m21 = _m21; m22 = _m22;
161  }
163  inline float det(void) {
164  return m11*m22 - m21*m12;
165  }
167  inline void inverse(matrice22 &M, float invdet) {
168  m11 = + M.m22 * invdet;
169  m12 = - M.m12 * invdet;
170  m21 = - M.m21 * invdet;
171  m22 = + M.m11 * invdet;
172  }
174  inline void mul(matrice22 &M1, matrice22 &M2) { // M1*M2
175  m11 = M1.m11 * M2.m11 + M1.m12 * M2.m21;
176  m12 = M1.m11 * M2.m12 + M1.m12 * M2.m22;
177  m21 = M1.m21 * M2.m11 + M1.m22 * M2.m21;
178  m22 = M1.m21 * M2.m12 + M1.m22 * M2.m22;
179  }
181  inline void imul(matrice22 &M1, matrice22 &M2) {
182  m11 = -( M1.m11 * M2.m11 + M1.m12 * M2.m21 );
183  m12 = -( M1.m11 * M2.m12 + M1.m12 * M2.m22 );
184  m21 = -( M1.m21 * M2.m11 + M1.m22 * M2.m21 );
185  m22 = -( M1.m21 * M2.m12 + M1.m22 * M2.m22 );
186  }
188  inline void diff(matrice22 &M1, matrice22 &M2) {
189  m11 = M1.m11 - M2.m11;
190  m12 = M1.m12 - M2.m12;
191  m21 = M1.m21 - M2.m21;
192  m22 = M1.m22 - M2.m22;
193  }
195  inline void add(matrice22 &M1, matrice22 &M2) {
196  m11 = M1.m11 + M2.m11;
197  m12 = M1.m12 + M2.m12;
198  m21 = M1.m21 + M2.m21;
199  m22 = M1.m22 + M2.m22;
200  }
202  inline void view(void) { printf("%f %f\n%f %f\n",m11, m12, m21, m22); }
203  };
204 
205 
206  #define MulLC(A,a,B,b) (A.m##a##1 * B.m1##b + A.m##a##2 * B.m2##b + A.m##a##3 * B.m3##b + A.m##a##4 * B.m4##b )
207 
209  struct matrice44 {
211  // @{
212  float m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44;
213  // @}
215  inline matrice44() {}
217  inline matrice44(float _m11, float _m12, float _m13, float _m14, float _m21, float _m22, float _m23, float _m24, float _m31, float _m32, float _m33, float _m34, float _m41, float _m42, float _m43, float _m44) {
218  set(_m11,_m12,_m13,_m14,_m21,_m22,_m23,_m24,_m31,_m32,_m33,_m34,_m41,_m42,_m43,_m44);
219  }
221  inline void set(float _m11, float _m12, float _m13, float _m14, float _m21, float _m22, float _m23, float _m24, float _m31, float _m32, float _m33, float _m34, float _m41, float _m42, float _m43, float _m44) {
222  m11=_m11; m12=_m12; m13=_m13; m14=_m14;
223  m21=_m21; m22=_m22; m23=_m23; m24=_m24;
224  m31=_m31; m32=_m32; m33=_m33; m34=_m34;
225  m41=_m41; m42=_m42; m43=_m43; m44=_m44;
226  }
228  inline void set(matrice44 &M) {
229  m11=M.m11; m12=M.m12; m13=M.m13; m14=M.m14;
230  m21=M.m21; m22=M.m22; m23=M.m23; m24=M.m24;
231  m31=M.m31; m32=M.m32; m33=M.m33; m34=M.m34;
232  m41=M.m41; m42=M.m42; m43=M.m43; m44=M.m44;
233  }
235  void mul(matrice44 &M1, matrice44 &M2) {
236  // if (((void*)&M1 == (void*)this) || ((void*)&M2 == (void*)this)) ERROR("invalid use","");
237  m11 = M1.m11 * M2.m11 + M1.m12 * M2.m21 + M1.m13 * M2.m31 + M1.m14 * M2.m41;
238  m12 = M1.m11 * M2.m12 + M1.m12 * M2.m22 + M1.m13 * M2.m32 + M1.m14 * M2.m42;
239  m13 = M1.m11 * M2.m13 + M1.m12 * M2.m23 + M1.m13 * M2.m33 + M1.m14 * M2.m43;
240  m14 = M1.m11 * M2.m14 + M1.m12 * M2.m24 + M1.m13 * M2.m34 + M1.m14 * M2.m44;
241 
242  m21 = M1.m21 * M2.m11 + M1.m22 * M2.m21 + M1.m23 * M2.m31 + M1.m24 * M2.m41;
243  m22 = M1.m21 * M2.m12 + M1.m22 * M2.m22 + M1.m23 * M2.m32 + M1.m24 * M2.m42;
244  m23 = M1.m21 * M2.m13 + M1.m22 * M2.m23 + M1.m23 * M2.m33 + M1.m24 * M2.m43;
245  m24 = M1.m21 * M2.m14 + M1.m22 * M2.m24 + M1.m23 * M2.m34 + M1.m24 * M2.m44;
246 
247  m31 = M1.m31 * M2.m11 + M1.m32 * M2.m21 + M1.m33 * M2.m31 + M1.m34 * M2.m41;
248  m32 = M1.m31 * M2.m12 + M1.m32 * M2.m22 + M1.m33 * M2.m32 + M1.m34 * M2.m42;
249  m33 = M1.m31 * M2.m13 + M1.m32 * M2.m23 + M1.m33 * M2.m33 + M1.m34 * M2.m43;
250  m34 = M1.m31 * M2.m14 + M1.m32 * M2.m24 + M1.m33 * M2.m34 + M1.m34 * M2.m44;
251 
252  m41 = M1.m41 * M2.m11 + M1.m42 * M2.m21 + M1.m43 * M2.m31 + M1.m44 * M2.m41;
253  m42 = M1.m41 * M2.m12 + M1.m42 * M2.m22 + M1.m43 * M2.m32 + M1.m44 * M2.m42;
254  m43 = M1.m41 * M2.m13 + M1.m42 * M2.m23 + M1.m43 * M2.m33 + M1.m44 * M2.m43;
255  m44 = M1.m41 * M2.m14 + M1.m42 * M2.m24 + M1.m43 * M2.m34 + M1.m44 * M2.m44;
256 
257  // m11 = MulLC(M1,1,M2,1); m12 = MulLC(M1,1,M2,2); m13 = MulLC(M1,1,M2,3); m14 = MulLC(M1,1,M2,4);
258  // m21 = MulLC(M1,2,M2,1); m22 = MulLC(M1,2,M2,2); m23 = MulLC(M1,2,M2,3); m24 = MulLC(M1,2,M2,4);
259  // m31 = MulLC(M1,3,M2,1); m32 = MulLC(M1,3,M2,2); m33 = MulLC(M1,3,M2,3); m34 = MulLC(M1,3,M2,4);
260  // m41 = MulLC(M1,4,M2,1); m42 = MulLC(M1,4,M2,2); m43 = MulLC(M1,4,M2,3); m44 = MulLC(M1,4,M2,4);
261  }
263  inline void zero() { memset(&m11,0,16*sizeof(float)); }
265  inline void view() { std::cout << m11 << " " << m12 << " " << m13 << " " << m14 << std::endl << m21 << " " << m22 << " " << m23 << " " << m24 << std::endl << m31 << " " << m32 << " " << m33 << " " << m34 << std::endl << m41 << " " << m42 << " " << m43 << " " << m44 << std::endl ; }
267  inline void scale(float a, float b, float c) { zero(); m11=a; m22=b; m33=c; m44=1.f; }
269  inline void identity() { scale(1.f,1.f,1.f); }
271  inline void translate(vecteur3d v) { scale(1.f,1.f,1.f); m14=v.x; m24=v.y; m34=v.z; }
273  inline void translate(float a, float b, float c) { scale(1.f,1.f,1.f); m14=a; m24=b; m34=c; }
275  inline void rotationX(float th) { scale(1.f,cos(th),cos(th)); m32=sin(th); m23=-sin(th); }
277  inline void rotationY(float th) { scale(cos(th),1.f,cos(th)); m31=sin(th); m13=-sin(th); }
279  inline void rotationZ(float th) { scale(cos(th),cos(th),1.f); m21=sin(th); m12=-sin(th); }
281  inline void transpose() {
282  #define SWAP(a,b) { float c=a; a=b; b=c; }
283  SWAP(m12,m21); SWAP(m13,m31); SWAP(m14,m41);
284  SWAP(m23,m32); SWAP(m24,m42);
285  SWAP(m34,m43);
286  #undef SWAP
287  }
289  inline float determinant(void) {
290  return
291  + m11 * _det3( &m22, &m32, &m42)
292  - m21 * _det3( &m12, &m32, &m42)
293  + m31 * _det3( &m12, &m22, &m42)
294  - m41 * _det3( &m12, &m22, &m32);
295  }
297  inline void ortho_inverse(matrice44 &M) {
298  m11 = M.m11; m12 = M.m21; m13 = M.m31; m14 = -(M.m11*M.m14 + M.m12*M.m24 + M.m13*M.m34);
299  m21 = M.m12; m22 = M.m22; m23 = M.m32; m24 = -(M.m21*M.m14 + M.m22*M.m24 + M.m23*M.m34);
300  m31 = M.m13; m32 = M.m23; m33 = M.m33; m34 = -(M.m31*M.m14 + M.m32*M.m24 + M.m33*M.m34);
301  // la dernière ligne de M devrait être cela
302  m41 = m42 = m43 = 0.f; m44 = 1.f;
303  }
305 
306  inline bool inverse(matrice44 &M) {
307  const float eps = 1e-6f;
308  matrice22
309  P(M.m11,M.m12,M.m21,M.m22), Q(M.m13,M.m14,M.m23,M.m24),
310  R(M.m31,M.m32,M.m41,M.m42), S(M.m33,M.m34,M.m43,M.m44);
311  float detP = P.det();
312  if (fabs(detP)<=eps) return false;
313  matrice22 iP, RiP, iPQ, RiPQ, SRiPQ;
314  iP.inverse(P,1.f/detP);
315  RiP.mul(R,iP);
316  iPQ.mul(iP,Q);
317  RiPQ.mul(R,iPQ);
318  SRiPQ.diff(S,RiPQ);
319  float detSRiPQ = SRiPQ.det();
320  if (fabs(detSRiPQ)<=eps) return false;
321  matrice22 Sb, Rb, Qb, Pb, iPQRb;
322  Sb.inverse(SRiPQ,1.f/detSRiPQ);
323  Rb.imul(Sb,RiP);
324  Qb.imul(iPQ,Sb);
325  iPQRb.mul(iPQ,Rb);
326  Pb.diff(iP,iPQRb);
327  set(Pb.m11,Pb.m12,Qb.m11,Qb.m12,
328  Pb.m21,Pb.m22,Qb.m21,Qb.m22,
329  Rb.m11,Rb.m12,Sb.m11,Sb.m12,
330  Rb.m21,Rb.m22,Sb.m21,Sb.m22);
331  return true;
332  };
333  };
334 
335  // méthodes avec dépendances cycliques
336  inline void vecteur3d::mul(matrice44 &M, vecteur3d &v) {
337  // hypothèse: Vin.w=1 et division par le w obtenu.
338  float wv = 1.f / ( M.m41*v.x + M.m42*v.y + M.m43*v.z + M.m44 );
339  x = (M.m11*v.x + M.m12*v.y + M.m13*v.z + M.m14)*wv;
340  y = (M.m21*v.x + M.m22*v.y + M.m23*v.z + M.m24)*wv;
341  z = (M.m31*v.x + M.m32*v.y + M.m33*v.z + M.m34)*wv;
342  }
343 
344  inline void vecteur4d::mul(matrice44 &M, vecteur4d &v) {
345  float x = M.m11*v.x + M.m12*v.y + M.m13*v.z + M.m14*v.w;
346  float y = M.m21*v.x + M.m22*v.y + M.m23*v.z + M.m24*v.w;
347  float z = M.m31*v.x + M.m32*v.y + M.m33*v.z + M.m34*v.w;
348  float w = M.m41*v.x + M.m42*v.y + M.m43*v.z + M.m44*v.w;
349  this->x = x;
350  this->y = y;
351  this->z = z;
352  this->w = w;
353  }
354 
355  // fonctions de base math
357  inline int sign(int x) { return (x>0 ? +1 : (x<0 ? -1 : 0 )); }
359  inline float clamp(float x) { return (x < 0.f ? 0.f : (x > 1.f ? 1.f : x)); }
360  const float pi = 3.14159265358979323846f;
361 
364  // @{
365  const vecteur3d
366  Black=vecteur3d(0.f,0.f,0.f), Cyan =vecteur3d(0.f,1.f,1.f),
367  Red =vecteur3d(1.f,0.f,0.f), Magenta=vecteur3d(1.f,0.f,1.f),
368  Green=vecteur3d(0.f,1.f,0.f), Yellow =vecteur3d(1.f,1.f,1.f),
369  Blue =vecteur3d(0.f,0.f,1.f), White =vecteur3d(1.f,1.f,1.f);
370  // @}
371 
372 }
373 
374 #endif
vecteur4d()
constructeur par défaut (non initialisé)
Definition: libMath.h:103
void mul(matrice44 &M1, matrice44 &M2)
M.mul(M1,M2) multiplication de 2 matrices 4x4.
Definition: libMath.h:235
vecteur3d(float _x, float _y, float _z)
constructeur U=(x,y,z)
Definition: libMath.h:45
vecteur3d operator*(const vecteur3d &v1, const vecteur3d &v2)
permet l'écriture U=V1*V2. Multiplication de vecteurs par composante.
Definition: libMath.h:86
vecteur4d(vecteur3d &_v, float _w)
constructeur U=(V,w)
Definition: libMath.h:107
void transpose()
M.transpose(), transposition (sur place) de la matrice M.
Definition: libMath.h:281
void inverse(matrice22 &M, float invdet)
calcul de l'inverse de la matrice : M.inverse(M1)
Definition: libMath.h:167
const vecteur3d Magenta
Definition: libMath.h:367
void print()
Definition: libMath.h:27
void rotationZ(float th)
M.rotationZ(th), construit la matrice de transformation 4x4 associé à une rotation d'axe Z et d'angle...
Definition: libMath.h:279
matrice44()
constructeur par défaut (sans initialisation)
Definition: libMath.h:215
void set(float _x, float _y, float _z, float _w)
U.set(x,y,z,w) fixe les composantes du vecteur à partir des coordonnées.
Definition: libMath.h:99
void rotationY(float th)
M.rotationY(th), construit la matrice de transformation 4x4 associé à une rotation d'axe Y et d'angle...
Definition: libMath.h:277
void vector(vecteur3d v1, vecteur3d v2)
construit U = V1 - V2
Definition: libMath.h:41
void rotationX(float th)
M.rotationX(th), construit la matrice de transformation 4x4 associé à une rotation d'axe X et d'angle...
Definition: libMath.h:275
void cross(const vecteur3d &v1, const vecteur3d &v2)
U.cross(V1,V2) place dans U le produit vectoriel de V1 et V2.
Definition: libMath.h:61
const vecteur3d Blue
Definition: libMath.h:369
void print()
Definition: libMath.h:126
float _det3(float *_v1, float *_v2, float *_v3)
calcul du déterminant 3x3 à partir de 3 vecteurs flottants (utilisé pour le calcul du déterminant 4x4...
Definition: libMath.h:145
vecteur4d & operator=(const vecteur4d &v)
permet l'écriture U = V. Egalité de vecteurs par composante.
Definition: libMath.h:122
void set(float _x, float _y, float _z)
U.set(x,y,z) fixe les composantes du vecteur.
Definition: libMath.h:37
bool normalize(void)
U.normalize() normalisation (sur place). Retourne faux si la norme est nulle.
Definition: libMath.h:120
const vecteur3d Green
Definition: libMath.h:368
void identity()
M.identity(), construit une matrice identité.
Definition: libMath.h:269
coord2d(int x, int y)
Definition: libMath.h:24
void add(matrice22 &M1, matrice22 &M2)
M = M1+M2, somme de 2 matrices 2x2 : M.add(M1,M2)
Definition: libMath.h:195
void view()
M.view(), affichage de la matrice.
Definition: libMath.h:265
void view(void)
affiche la matrice
Definition: libMath.h:202
void set(matrice44 &M)
setter par copie
Definition: libMath.h:228
structure pour les vecteurs 4D (de taille 4 = 3D + composante w).
Definition: libMath.h:95
float dot3(coord2d v1, coord2d v2)
Definition: libMath.h:30
void print()
Definition: libMath.h:74
float norm(void)
U.norm() renvoie la norme du vecteur U.
Definition: libMath.h:114
vecteur3d(float v)
constructeur U=(v,v,v)
Definition: libMath.h:47
vecteur3d()
constructeur par défaut (non initialisé)
Definition: libMath.h:43
structure pour les vecteurs 3D (de taille 3).
Definition: libMath.h:21
void ortho_inverse(matrice44 &M)
M.ortho_inverse(), calcul la matrice inverse associée à une transformation A.X+B où A est une matrice...
Definition: libMath.h:297
matrice22(float _m11, float _m12, float _m21, float _m22)
constructeur par valeur (en passant chaque valeur de la matrice)
Definition: libMath.h:159
matrice22()
constructeur par défaut (sans initialisation)
Definition: libMath.h:157
float norm2(void)
U.norm2() renvoie la norme du vecteur U au carré.
Definition: libMath.h:112
void set(int x, int y)
Definition: libMath.h:25
matrice44(float _m11, float _m12, float _m13, float _m14, float _m21, float _m22, float _m23, float _m24, float _m31, float _m32, float _m33, float _m34, float _m41, float _m42, float _m43, float _m44)
constructeur par valeur (en passant chaque valeur de la matrice)
Definition: libMath.h:217
vecteur3d & operator*=(const vecteur3d &v)
permet l'écriture U *= V. Multiplication de vecteurs par composante.
Definition: libMath.h:69
Definition: libMath.h:16
coord2d & operator-=(const coord2d &v)
Definition: libMath.h:26
bool normalize(void)
U.normalize() normalisation (sur place). Retourne faux si la norme est nulle.
Definition: libMath.h:59
const vecteur3d Red
Definition: libMath.h:367
vecteur3d & operator*=(const float v)
permet l'ecriture U *= v. Multiplication d'un vecteur par un scalaire.
Definition: libMath.h:71
coord2d operator-(const coord2d &v1, const coord2d &v2)
Definition: libMath.h:29
float determinant(void)
M.determinant(), retourne le déterminant de la matrice 4x4 M.
Definition: libMath.h:289
void mul(float v)
U.mul(v) multiplie (en place) U par le scalaire v.
Definition: libMath.h:49
#define SWAP(a, b)
bool normalize(const float nrm)
U.normalize(norm) normalisation (sur place) en passant la norme. Retourne faux si la norme est nulle...
Definition: libMath.h:116
vecteur3d & operator-=(const vecteur3d &v)
permet l'écriture U -= V. Addition de vecteurs par composante.
Definition: libMath.h:67
bool normalize(const float nrm)
U.normalize(norm) normalisation (sur place) en passant la norme. Retourne faux si la norme est nulle...
Definition: libMath.h:55
void diff(matrice22 &M1, matrice22 &M2)
M = M1-M2, difference de 2 matrices 2x2 : M.diff(M1,M2)
Definition: libMath.h:188
bool normalize2(const float nrm2)
U.normalize(norm2) normalisation (sur place) en passant la norme au carré. Retourne faux si la norme ...
Definition: libMath.h:118
bool inverse(matrice44 &M)
M.inverse(), inversion sur place de la matrice M. Renvoie true en cas de succès, false sinon...
Definition: libMath.h:306
float norm(void)
U.norm() renvoie la norme du vecteur U.
Definition: libMath.h:53
vecteur3d operator+(const vecteur3d &v1, const vecteur3d &v2)
permet l'écriture U=V1+V2. Addition de vecteurs par composante.
Definition: libMath.h:77
const vecteur3d Cyan
Definition: libMath.h:366
void set(float _m11, float _m12, float _m13, float _m14, float _m21, float _m22, float _m23, float _m24, float _m31, float _m32, float _m33, float _m34, float _m41, float _m42, float _m43, float _m44)
setter avec valeurs
Definition: libMath.h:221
const float pi
Definition: libMath.h:360
void set(float v)
U.set(v) equivalent de U.set(v,v,v)
Definition: libMath.h:39
const vecteur3d Yellow
Definition: libMath.h:368
void zero()
M.zero(), mise à zéro de la matrice.
Definition: libMath.h:263
void translate(float a, float b, float c)
M.translate(V), construit la matrice de transformation 4x4 associée à une translation de vecteur (a...
Definition: libMath.h:273
const vecteur3d White
Definition: libMath.h:369
void set(vecteur3d &_v, float _w)
U.set(V,w) fixe les composantes du vecteur à partir d'un vecteur 3D et d'une composante w...
Definition: libMath.h:101
float det(void)
calcul du déterminant: det = M.det()
Definition: libMath.h:163
void translate(vecteur3d v)
M.translate(V), construit la matrice de transformation 4x4 associée à une translation de vecteur V...
Definition: libMath.h:271
structure pour les matrices 4x4
Definition: libMath.h:209
vecteur3d & operator+=(const vecteur3d &v)
permet l'écriture U += V. Addition de vecteurs par composante.
Definition: libMath.h:65
void imul(matrice22 &M1, matrice22 &M2)
M = - M1*M2, opposé de la multiplication de 2 matrices 2x2 : M.imul(M1,M2)
Definition: libMath.h:181
int sign(int x)
renvoie le signe d'un entier (-1 si négatif, +1 si position, 0 si nul).
Definition: libMath.h:357
void mul(matrice22 &M1, matrice22 &M2)
M = M1*M2, multiplication de 2 matrices 2x2 : M.mul(M1,M2)
Definition: libMath.h:174
float clamp(float x)
seuillage: 0 si x<0, 1 si x>1, x sinon.
Definition: libMath.h:359
vecteur3d & operator=(const vecteur3d &v)
permet l'écriture U = V. Egalité de vecteurs par composante.
Definition: libMath.h:63
bool normalize2(const float nrm2)
U.normalize(norm2) normalisation (sur place) en passant la norme au carré. Retourne faux si la norme ...
Definition: libMath.h:57
void mul(float v)
U.mul(v) multiplie (en place) U par le scalaire v.
Definition: libMath.h:110
const vecteur3d Black
Definition: libMath.h:366
structure pour les matrices 2x2 : elles sont utilisées pour l'inversion par bloc de matrice 4x4...
Definition: libMath.h:151
float norm2(void)
U.norm2() renvoie la norme du vecteur U au carré.
Definition: libMath.h:51
vecteur4d(float _x, float _y, float _z, float _w)
constructeur U=(x,y,z,w)
Definition: libMath.h:105
void scale(float a, float b, float c)
M.scale(a,b,c), construit une matrice de mise à l'échelle de facteur (a,b,c) respectivement pour les ...
Definition: libMath.h:267