Librairie de vecteurs et de matrices pour la 3D

Voila une petite librairie qui vous permettra de jongler avec les vecteurs et les matrices cyclops

Fichier "matrice.h"

Code:: ////////////////////////////////////////////////////////////////////////////////
//////++++++//////++//////++//////++++++//++//////++//++++++++//////////////////
//////++////++////++//////++////++////////++//////++//++////////////////////////
//////++//////++//++//////++//++//////////++++++++++//++++++////////////////////
//////++//////++//++//////++//++//////////++//////++//++////////////////////////
//////++////++////++//////++////++////////++//////++//++////////////////////////
//////++++++////////++++++////////++++++//++//////++//++++++++// Production ////
////////////////////////////////////////////////////////////////////////////////
// //
// Ecrit par Duche. //
// Contact: le_grand_duche@hotmail.com //
// //
// Date de dernière modification : 02/02/2006 //
// //
////////////////////////////////////////////////////////////////////////////////
// matrice.h /////////////////////////////////////////////////////////////////

#ifndef _MATRICE_H
#define _MATRICE_H

////////////////////////////////////////////////////////////////////////////////

#include <iostream>
using namespace std;

////////////////////////////////////////////////////////////////////////////////

#define pi 3.1415926536
#define EPSILON 1e-7
#define IDENTITE Matrice(1.0,0.0,0.0,0.0,1.0,0.0,0.0,0.0,1.0);

////////////////////////////////////////////////////////////////////////////////

class Vecteur;
class Matrice;

////////////////////////////////////////////////////////////////////////////////

class Vecteur
{
friend class Matrice;
public:
   Vecteur();
   Vecteur(const float&,const float&,const float&);
   float& operator[](int);
   const float& operator[](int) const;
   Vecteur operator+() const;
   Vecteur operator-() const; //Négation
   friend Vecteur operator+(const Vecteur&,const Vecteur&); //Somme
   friend Vecteur operator-(const Vecteur&,const Vecteur&); //Soustraction
   friend Vecteur operator*(const float&,const Vecteur&); //Multiplication scalaire
   friend Vecteur operator*(const Vecteur&,const float&); //Multiplication scalaire
   friend Vecteur operator/(const Vecteur&,const float&); //Division scalaire
   friend float operator*(const Vecteur&,const Vecteur&); //Produit scalaire
   friend Vecteur operator/(const Vecteur&,const Vecteur&); //Produit vectoriel
   friend Matrice operator%(const Vecteur&,const Vecteur&); //Produit tensoriel
   friend Vecteur operator*(const Matrice&,const Vecteur&); //Produit matriciel droit
   friend Vecteur operator*(const Vecteur&,const Matrice&); //Produit matriciel gauche
   void operator+=(const Vecteur&); //Somme
   void operator-=(const Vecteur&); //Soustraction
   void operator*=(const float&); //Multiplication scalaire
   void operator/=(const float&); //Division scalaire
   friend float norme(const Vecteur&); //Norme standart: V(x²+y²+z²)
   friend Vecteur orthogonal(const Vecteur&); /*Renvoie un vecteur orthogonal de même
   norme, dans le plan perpendiculaire à OXY et contenant le vecteur donné, et du même côté
   que l'axe OZ, le tout dans un système dextrogyre*/
   friend Vecteur orthogonal(const Vecteur&,const float&); /*Renvoie un vecteur orthogonal
   de même norme, faisant un angle donné avec l'angle décrit ci-dessus*/
   friend bool operator==(const Vecteur&,const Vecteur&); //Test d'égalité
   friend bool operator!=(const Vecteur&,const Vecteur&); //Test de différence
   friend ostream& operator<<(ostream&,const Vecteur&); //Ecriture
   friend istream& operator>>(istream&,Vecteur&); //Lecture
   /* fonctions propres à la class Matrice utilisant indirectement des vecteurs */
   friend Matrice operator*(const Matrice&,const Matrice&);
   friend float maxAbs(const Matrice&);
   friend Matrice transpose(const Matrice&);
   friend float det(const Matrice&);
   friend Matrice inverse(const Matrice&);
   friend Matrice inverse(const Matrice&,const float&);
   friend Matrice rotation(const Vecteur&,const float&);
private:
   float x,y,z;
};

////////////////////////////////////////////////////////////////////////////////

class Matrice
{
public:
   Matrice();
   Matrice(const float&,const float&,const float&,const float&,const float&,const float&,const float&,const float&,const float&);
   Matrice(const Vecteur&,const Vecteur&,const Vecteur&);
   Vecteur& operator[](int);
   const Vecteur& operator[](int) const;
   Matrice operator+() const;
   Matrice operator-() const; //Négation
   friend Matrice operator+(const Matrice&,const Matrice&); //Somme
   friend Matrice operator-(const Matrice&,const Matrice&); //Soustraction
   friend Matrice operator*(const float&,const Matrice&); //Produit scalaire
   friend Matrice operator*(const Matrice&,const float&); //Produit scalaire
   friend Matrice operator/(const Matrice&,const float&); //Division scalaire
   friend Vecteur operator*(const Matrice&,const Vecteur&); //Produit matriciel droit
   friend Vecteur operator*(const Vecteur&,const Matrice&); //Produit matriciel gauche
   friend Matrice operator*(const Matrice&,const Matrice&); //Produit matriciel
   void operator+=(const Matrice&); //Somme
   void operator-=(const Matrice&); //Soustraction
   void operator*=(const float&); //Multiplication scalaire
   void operator/=(const float&); //Division scalaire
   void operator*=(const Matrice&); //Produit matriciel
   friend float maxAbs(const Matrice&); //Max des valeurs absolues des éléments
   friend Matrice transpose(const Matrice&); //Renvoie la transposée de la matrice
   void transpose(); //Transpose la matrice
   friend float det(const Matrice&); //renvoie le déterminant
   friend Matrice inverse(const Matrice&); //Renvoie l'inverse de la matrice
   friend Matrice inverse(const Matrice&,const float&); //Idem mais on fournit le dét
   void inverse(); //Inverse la matrice
   void id(); //Met la matrice à l'identité
   friend Matrice rotation(const Vecteur&,const float&); //renvoie une matrice de rotation
   void rotation(const Vecteur&,const float&); //Matrice de rotation
   friend ostream& operator<<(ostream&,const Matrice&); //Ecriture
   friend istream& operator>>(istream&,Matrice&); //Lecture
private:
   Vecteur v0,v1,v2;
};

#endif

Fichier "matrice.cpp"

Code:: ////////////////////////////////////////////////////////////////////////////////
//////++++++//////++//////++//////++++++//++//////++//++++++++//////////////////
//////++////++////++//////++////++////////++//////++//++////////////////////////
//////++//////++//++//////++//++//////////++++++++++//++++++////////////////////
//////++//////++//++//////++//++//////////++//////++//++////////////////////////
//////++////++////++//////++////++////////++//////++//++////////////////////////
//////++++++////////++++++////////++++++//++//////++//++++++++// Production ////
////////////////////////////////////////////////////////////////////////////////
// //
// Ecrit par Duche. //
// Contact: le_grand_duche@hotmail.com //
// //
// Date de dernière modification : 02/02/2006 //
// //
////////////////////////////////////////////////////////////////////////////////
// matrice.cpp ///////////////////////////////////////////////////////////////

#include "matrice.h"
#include <iostream>
#include <math.h>
using namespace std;

////////////////////////////////////////////////////////////////////////////////
// VARIABLES GLOBALES ////////////////////////////////////////////////////////

float epsilon = EPSILON;

////////////////////////////////////////////////////////////////////////////////
// CLASSE VECTEUR ////////////////////////////////////////////////////////////

Vecteur::Vecteur()
{
x = y = z = 0.0;
}

Vecteur::Vecteur(const float& _x,const float& _y,const float& _z)
{
x = _x;
y = _y;
z = _z;
}

float& Vecteur::operator[](int i)
{
if(i==0) return x;
if(i==1) return y;
if(i==2) return z;
}

const float& Vecteur::operator[](int i) const
{
if(i==0) return x;
if(i==1) return y;
if(i==2) return z;
}

Vecteur Vecteur::operator+() const
{
return *this;
}

Vecteur Vecteur::operator-() const
{
return Vecteur(-x,-y,-z);
}

Vecteur operator+(const Vecteur& u,const Vecteur& v)
{
return Vecteur(u.x+v.x,u.y+v.y,u.z+v.z);
}

Vecteur operator-(const Vecteur& u,const Vecteur& v)
{
return Vecteur(u.x-v.x,u.y-v.y,u.z-v.z);
}

Vecteur operator*(const float& r,const Vecteur& u)
{
return Vecteur(r*u.x,r*u.y,r*u.z);
}

Vecteur operator*(const Vecteur& u,const float& r)
{
return Vecteur(r*u.x,r*u.y,r*u.z);
}

Vecteur operator/(const Vecteur& u,const float& r)
{
return Vecteur(u.x/r,u.y/r,u.z/r);
}

float operator*(const Vecteur& u,const Vecteur& v)
{
return u.x*v.x+u.y*v.y+u.z*v.z;
}

Vecteur operator/(const Vecteur& u,const Vecteur& v)
{
return Vecteur(u.y*v.z-u.z*v.y,u.z*v.x-u.x*v.z,u.x*v.y-u.y*v.x);
}

Matrice operator%(const Vecteur& u,const Vecteur& v)
{
return Matrice(u.x*v,u.y*v,u.z*v);
}

void Vecteur::operator+=(const Vecteur& u)
{
x += u.x;
y += u.y;
z += u.z;
}

void Vecteur::operator-=(const Vecteur& u)
{
x -= u.x;
y -= u.y;
z -= u.z;
}

void Vecteur::operator*=(const float& r)
{
x *= r;
y *= r;
z *= r;
}

void Vecteur::operator/=(const float& r)
{
x /= r;
y /= r;
z /= r;
}

float norme(const Vecteur& u)
{
return sqrt(u.x*u.x+u.y*u.y+u.z*u.z);
}

Vecteur orthogonal(const Vecteur& u)
{
float r = sqrt(u.x*u.x+u.y*u.y);
return Vecteur(u.x*u.z/r,-u.y*u.z/r,r);
}

Vecteur orthogonal(const Vecteur& u,const float& alpha)
{
float r = sqrt(u.x*u.x+u.y*u.y);
Vecteur v(u.x*u.z/r,-u.y*u.z/r,r);
Matrice R = transpose(rotation(u,alpha));
v = R*v;
return v;
}

bool operator==(const Vecteur& u,const Vecteur& v)
{
return (fabs(u.x-v.x)<=epsilon)&&(fabs(u.y-v.y)<=epsilon)&&(fabs(u.z-v.z)<=epsilon);
}

bool operator!=(const Vecteur& u,const Vecteur& v)
{
return (fabs(u.x-v.x)>epsilon)||(fabs(u.y-v.y)>epsilon)||(fabs(u.z-v.z)>epsilon);
}

ostream& operator<<(ostream& out_stream,const Vecteur& u)
{
out_stream << "(" << u.x << "," << u.y << "," << u.z << ")";
return out_stream;
}

istream& operator>>(istream& in_stream,Vecteur& u)
{
char c;
in_stream >> c >> u.x >> c >> u.y >> c >> u.z >> c;
return in_stream;
}

////////////////////////////////////////////////////////////////////////////////
// CLASSE MATRICE ////////////////////////////////////////////////////////////

Matrice::Matrice()
{
v0 = Vecteur(0.0,0.0,0.0);
v1 = Vecteur(0.0,0.0,0.0);
v2 = Vecteur(0.0,0.0,0.0);
}

Matrice::Matrice(const float& _x00,const float& _x01,const float& _x02,const float& _x10,const float& _x11,const float& _x12,const float& _x20,const float& _x21,const float& _x22)
{
v0 = Vecteur(_x00,_x01,_x02);
v1 = Vecteur(_x10,_x11,_x12);
v2 = Vecteur(_x20,_x21,_x22);
}

Matrice::Matrice(const Vecteur& u0,const Vecteur& u1,const Vecteur& u2)
{
v0 = u0;
v1 = u1;
v2 = u2;
}

Vecteur& Matrice::operator[](int i)
{
if(i==0) return v0;
if(i==1) return v1;
if(i==2) return v2;
}

const Vecteur& Matrice::operator[](int i) const
{
if(i==0) return v0;
if(i==1) return v1;
if(i==2) return v2;
}

Matrice Matrice::operator+() const
{
return *this;
}

Matrice Matrice::operator-() const
{
return Matrice(-v0,-v1,-v2);
}

Matrice operator+(const Matrice& a,const Matrice& b)
{
return Matrice(a.v0+b.v0,a.v1+b.v1,a.v2+b.v2);
}

Matrice operator-(const Matrice& a,const Matrice& b)
{
return Matrice(a.v0-b.v0,a.v1-b.v1,a.v2-b.v2);
}

Matrice operator*(const float& r,const Matrice& a)
{
return Matrice(r*a.v0,r*a.v1,r*a.v2);
}

Matrice operator*(const Matrice& a,const float& r)
{
return Matrice(r*a.v0,r*a.v1,r*a.v2);
}

Matrice operator/(const Matrice& a,const float& r)
{
return Matrice(a.v0/r,a.v1/r,a.v2/r);
}

Vecteur operator*(const Matrice& a,const Vecteur& v)
{
return Vecteur(a.v0.x*v.x+a.v0.y*v.y+a.v0.z*v.z,a.v1.x*v.x+a.v1.y*v.y+a.v1.z*v.z,a.v2.x*v.x+a.v2.y*v.y+a.v2.z*v.z);
}

Vecteur operator*(const Vecteur& v,const Matrice& a)
{
return Vecteur(v.x*a.v0.x+v.y*a.v1.x+v.z*a.v2.x,v.x*a.v0.y+v.y*a.v1.y+v.z*a.v2.y,v.x*a.v0.z+v.y*a.v1.z+v.z*a.v2.z);
}

Matrice operator*(const Matrice& a,const Matrice& b)
{
return Matrice(a.v0.x*b.v0.x+a.v0.y*b.v1.x+a.v0.z*b.v2.x,a.v0.x*b.v0.y+a.v0.y*b.v1.y+a.v0.z*b.v2.y,a.v0.x*b.v0.z+a.v0.y*b.v1.z+a.v0.z*b.v2.z,          a.v1.x*b.v0.x+a.v1.y*b.v1.x+a.v1.z*b.v2.x,a.v1.x*b.v0.y+a.v1.y*b.v1.y+a.v1.z*b.v2.y,a.v1.x*b.v0.z+a.v1.y*b.v1.z+a.v1.z*b.v2.z,
                     a.v2.x*b.v0.x+a.v2.y*b.v1.x+a.v2.z*b.v2.x,a.v2.x*b.v0.y+a.v2.y*b.v1.y+a.v2.z*b.v2.y,a.v2.x*b.v0.z+a.v2.y*b.v1.z+a.v2.z*b.v2.z);
}

void Matrice::operator+=(const Matrice& a)
{
v0 += a.v0;
v1 += a.v1;
v2 += a.v2;
}

void Matrice::operator-=(const Matrice& a)
{
v0 -= a.v0;
v1 -= a.v1;
v2 -= a.v2;
}

void Matrice::operator*=(const float& r)
{
v0 *= r;
v1 *= r;
v2 *= r;
}

void Matrice::operator/=(const float& r)
{
v0 /= r;
v1 /= r;
v2 /= r;
}

void Matrice::operator*=(const Matrice& a)
{
(*this) = (*this)*a;
}

float maxAbs(const Matrice& a)
{
return max(max(max(max(fabs(a.v0.x),fabs(a.v0.y)),max(fabs(a.v0.z),fabs(a.v1.x))),max(max(fabs(a.v1.y),fabs(a.v1.z)),max(fabs(a.v2.x),fabs(a.v2.y)))),fabs(a.v2.z));
}

Matrice transpose(const Matrice& a)
{
return Matrice(a.v0.x,a.v1.x,a.v2.x,a.v0.y,a.v1.y,a.v2.y,a.v0.z,a.v1.z,a.v2.z);
}

void Matrice::transpose()
{
swap(v0.y,v1.x);
swap(v0.z,v2.x);
swap(v1.z,v2.y);
}

float det(const Matrice& a)
{
return a.v0.x*a.v1.y*a.v2.z+a.v0.y*a.v1.z*a.v2.x+a.v0.z*a.v1.x*a.v2.y-a.v2.x*a.v1.y*a.v0.z-a.v2.y*a.v1.z*a.v0.x-a.v2.z*a.v1.x*a.v0.y;
}

Matrice inverse(const Matrice& a)
{
float r = det(a);
Matrice C(a.v1.y*a.v2.z-a.v2.y*a.v1.z,a.v0.y*a.v2.z-a.v2.y*a.v0.z,a.v0.y*a.v1.z-a.v1.y*a.v0.z,
   a.v1.x*a.v2.z-a.v2.x*a.v1.z,a.v0.x*a.v2.z-a.v2.x*a.v0.z,a.v0.x*a.v1.z-a.v1.x*a.v0.z,
   a.v1.x*a.v2.y-a.v2.x*a.v1.y,a.v0.x*a.v2.y-a.v2.x*a.v0.y,a.v0.x*a.v1.y-a.v1.x*a.v0.y);
C /= r;
return C;
}

Matrice inverse(const Matrice& a,const float& r)
{
Matrice C(a.v1.y*a.v2.z-a.v2.y*a.v1.z,a.v0.y*a.v2.z-a.v2.y*a.v0.z,a.v0.y*a.v1.z-a.v1.y*a.v0.z,
   a.v1.x*a.v2.z-a.v2.x*a.v1.z,a.v0.x*a.v2.z-a.v2.x*a.v0.z,a.v0.x*a.v1.z-a.v1.x*a.v0.z,
   a.v1.x*a.v2.y-a.v2.x*a.v1.y,a.v0.x*a.v2.y-a.v2.x*a.v0.y,a.v0.x*a.v1.y-a.v1.x*a.v0.y);
C /= r;
return C;
}

void Matrice::inverse()
{
Matrice a(*this);
(*this) = ::inverse(a);
}

void Matrice::id()
{
v0 = Vecteur(1.0,0.0,0.0);
v1 = Vecteur(0.0,1.0,0.0);
v2 = Vecteur(0.0,0.0,1.0);
}

Matrice rotation(const Vecteur& w,const float& alpha)
{
float Min = min(fabs(w.x),min(fabs(w.y),fabs(w.z)));
Matrice B;
B.v0.z = w.x;
B.v1.z = w.y;
B.v2.z = w.z;
if(fabs(w.x) == Min)
{
   float lambda = 1.0/sqrt(1.0-w.x*w.x);
   B.v0.x = lambda*(1.0-w.x*w.x);
   B.v0.y = 0.0;
   B.v1.x = -lambda*w.x*w.y;
   B.v1.y = lambda*w.z;
   B.v2.x = -lambda*w.x*w.z;
   B.v2.y = -lambda*w.y;
}
else if(fabs(w.y) == Min)
{
   float lambda = 1.0/sqrt(1-w.y*w.y);
   B.v0.x = -lambda*w.x*w.y;
   B.v0.y = -lambda*w.z;
   B.v1.x = lambda*(1.0-w.y*w.y);
   B.v1.y = 0.0;
   B.v2.x = -lambda*w.y*w.z;
   B.v2.y = lambda*w.x;
}
else if(fabs(w.z) == Min)
{
   float lambda = 1.0/sqrt(1-w.z*w.z);
   B.v0.x = -lambda*w.x*w.z;
   B.v0.y = lambda*w.y;
   B.v1.x = -lambda*w.y*w.z;
   B.v1.y = -lambda*w.x;
   B.v2.x = lambda*(1.0-w.z*w.z);
   B.v2.y = 0.0;
}
Matrice Bt = transpose(B);
float c = cos(alpha);
float s = sin(alpha);
Matrice R(c,-s,0.0,s,c,0.0,0.0,0.0,1.0);
Matrice K = B*R*Bt;
return K;
}

void Matrice::rotation(const Vecteur& w,const float& alpha)
{
Matrice R;
R = ::rotation(w,alpha);
(*this) = R;
}

ostream& operator<<(ostream& out_stream,const Matrice& a)
{
out_stream << "(" << a.v0 << "," << a.v1 << "," << a.v2 << ")";
return out_stream;
}

istream& operator>>(istream& in_stream,Matrice& a)
{
char c;
in_stream >> c >> a.v0 >> c >> a.v1 >> c >> a.v2 >> c;
return in_stream;
}

Fichier de commentaires:

Code:: ////////////////////////////////////////////////////////////////////////////////
//////++++++//////++//////++//////++++++//++//////++//++++++++//////////////////
//////++////++////++//////++////++////////++//////++//++////////////////////////
//////++//////++//++//////++//++//////////++++++++++//++++++////////////////////
//////++//////++//++//////++//++//////////++//////++//++////////////////////////
//////++////++////++//////++////++////////++//////++//++////////////////////////
//////++++++////////++++++////////++++++//++//////++//++++++++// Production ////
////////////////////////////////////////////////////////////////////////////////
// //
// Ecrit par Duche. //
// Contact: le_grand_duche@hotmail.com //
// //
// Date de dernière modification : 02/02/2006 //
// //
////////////////////////////////////////////////////////////////////////////////
// matrice.math //////////////////////////////////////////////////////////////
/*

********************************************************************************
*** Précisions Mathématiques pour la fonction *********************************
*** Matrice rotation(const Vecteur&,const float&); ****************************
********************************************************************************

On a un vecteur w = (w.x,w.y,w.z) supposé de norme égale à 1.
Il s'agit de trouver une matrice de changement de base B telle que
(1x,1y,1z)(B00,B01,B02) = (1x',1y',1z')
(B10,B11,B12)
(B20,B21,B22)
où 1x,1y,1z sont les vecteurs de la base orthonormale dextrogyre utilisée
usuellement et ou 1x',1y',1z' sont les vecteurs d'une base orthonormale
dextrogyre telle que 1z' = w.

On alors 1x' = (B00,B10,B20)
1y' = (B01,B11,B21)
1z' = (B02,B12,B22)
Forcément on a B20 = x.x, B21 = w.y, B22 = w.z

Il faut maintenant définir intelligement des vecteurs 1x' et 1y'
Pour ce faire, il suffit de choisir arbitrairement un vecteur 1y'
perpendiculaire à w = 1z' et puis de calculer 1x' = 1y'×1z' = 1y'×w
(où a×b est le produit vectoriel)
Il se trouve que le vecteur w×a est perpendiculaire à w quelque soit a
(pour autant que a ne soit pas "trop près" de w, pour éviter d'avoir un
vecteur nul...) Il existe donc un facteur µ>0 tel que µ(w×a) soit de norme 1
On choisit a = |(1,0,0) si w.x = min(w.x,w.y,w.z)
|(0,1,0) si w.y = min(w.x,w.y,w.z)
|(0,0,1) si w.z = min(w.x,w.y,w.z)
Ainsi a est forcément "loin" de w (sauf si w = 0, mais on avait posé que la
norme de w devait etre 1, donc w ne peut être nul...)
Les deux vecteurs a et w étant norme 1, ce µ vaut en fait 1/abs(sin(g))
   où g est l'angle séparant a et w. On calcul ce sinus par la règle suivante:
   sin²(g)+cos²(g)=1 => sin(g)=sqrt(1-cos²(g))
   Et on calcule cos(g) en sachant que a et w sont de norme 1, donc leur
   produit scalaire a.x*w.x+a.y*w.y+a.z*w.z vaut par définition 1*1*cos(g)

   On trouve ainsi
   1y' = µ(w×a) = µ(w.y*a.z-w.z*a.y,w.z*a.x-w.x*a.z,w.x*a.y-w.y*a.x)
   1x' = µ((w×a)×w) = µ((w*w)a-(a*w)w) (cfr formule d'expultion)
      = µ(a-cos(g)w) = µ(a.x-cos(g)*w.x,a.y-cos(g)*w.y,a.z-cos(g)*w.z)
   Notre matrice B est donc
   ( µ(a.x-cos(g)*w.x) µ(w.y*a.z-w.z*a.y) w.x )
   ( µ(a.y-cos(g)*w.y) µ(w.z*a.x-w.x*a.z) w.y )
   ( µ(a.z-cos(g)*w.z) µ(w.x*a.y-w.y*a.x) w.z )

   Une fois que l'on est dans cette base, on peut appliquer une rotation d'un
   angle alpha autour de l'axe 1z'
   Cela s'exprime par la matrice R =
   ( cos(alpha) -sin(alpha) 0 )
   ( sin(alpha) cos(alpha) 0 )
   ( 0 0 1 )

   Cette matrice de rotation R est alors exprimée dans la base initiale
   1x,1y,1z par la matrice BRB' (où B' est la transposée de B)
   La matrice que renvoie la fonction est cette matrice BRB'

*///////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

Si vous avez des questions sur ce sujet, n'hésitez pas à me le demander...
Si ca manque de commentaires, dites-le moi j'en ajouterai dès que possible.
Bonne Prog à tous ![/code]

Admin Nombre de messages : 78 Date d'inscription : 11/11/2005

Sympathique comme tout ! cheers

merci a toi Very Happy

J'ai pas testé les fonctions "faciles" (j'ai juste testé la rotation...) il se peut donc qu'il y ait des bug, mais ce seront juste des fautes de frappe...

Nombre de messages : 57 Date d'inscription : 10/02/2006

j'ai une petite question, en c++ comment declare ton une matrice ?

j'ai essaié un truc du genre :

Code:: Mx = MatriceX[0][0] = 1,
MatriceX[0][1] = 0,
MatriceX[0][2] = 0,
MatriceX[0][3] = 0,
MatriceX[1][0] = 0,
MatriceX[0][1] = cos(angle),
MatriceX[0][2] = -sin(angle),
MatriceX[0][3] = 0,
MatriceX[2][0] = 0,
MatriceX[0][1] = sin(angle),
MatriceX[0][2] = cos(angle),
MatriceX[0][3] = 0,
MatriceX[3][0] = 0,
MatriceX[0][1] = 0,
MatriceX[0][2] = 0,
MatriceX[0][3] = 1;

mais c'est pas ça :/

Admin Nombre de messages : 78 Date d'inscription : 11/11/2005

met des ; déja Smile

ensuite, intialise ainsi :

double MatriceX[4][4];

Nombre de messages : 57 Date d'inscription : 10/02/2006

mais normalement la matrice devrait retourner une valeur non ?