Classe de vecteurs en 2d / 3d portable, utilisation pour simulations physiques
Soyez le premier à donner votre avis sur cette source.
Vue 9 083 fois - Téléchargée 362 fois
Description
J'ai utilisé cette classe de vecteurs dans plusieurs simulations physiques (cinétiques surtout, physique classique de Newton et Co). L'aspect graphique était géré en OpenGL, mais la classe en elle-même est absolument indépendante de TOUT. Je n'ai rien utilisé de spécial: je n'ai utilisé que iostream pour la fonction de débuggage console, si on l'enlève on peut aussi enlever l'utilisation de la STD. Et puis j'ai aussi inclus math.h, en écrivant à côté les fonctions que j'ai utilisées, donc si vous ne voulez pas utiliser math.h, il vous suffit de réécrire ces fonctions, et tout marchera!
NOTE: le screenshot provient d'une simulation de collisions non-élastiques, les segments colorés sont les vecteurs vitesse des billes
ATTENTION GRANDE MISE A JOUR DU 5 MAI 2005:
--------------------------------------------------------------
je remplace le code (dégueulasse et informe) que j'avais posté ici (quelle daube :/) et je le remplace par deux nouvelles classes écrites récemment, et au passage, vous avez la version 2D et la version 3D. c'est doublement templaté, mais je vous suggères de garder les types proposés dans les 3 typedefs de bas de fichier: V3Di V3Df V3Dd et V2Di V2Df V2Dd. i = int, f = float, d = double.
pas mal de fonctions ont été ajoutées, et puis surtout c'est plus propre ^^
Edit du 30 septembre: correction d'un bug pour GetAngle et ajout des "const" pour les méthodes concernées
Si vous trouvez des erreurs / incohérences ... ou si vous avez des suggestions: postez joyeusement.
NOTE: le screenshot provient d'une simulation de collisions non-élastiques, les segments colorés sont les vecteurs vitesse des billes
ATTENTION GRANDE MISE A JOUR DU 5 MAI 2005:
--------------------------------------------------------------
je remplace le code (dégueulasse et informe) que j'avais posté ici (quelle daube :/) et je le remplace par deux nouvelles classes écrites récemment, et au passage, vous avez la version 2D et la version 3D. c'est doublement templaté, mais je vous suggères de garder les types proposés dans les 3 typedefs de bas de fichier: V3Di V3Df V3Dd et V2Di V2Df V2Dd. i = int, f = float, d = double.
pas mal de fonctions ont été ajoutées, et puis surtout c'est plus propre ^^
Edit du 30 septembre: correction d'un bug pour GetAngle et ajout des "const" pour les méthodes concernées
Source / Exemple :
//------------------------------------------------------------------------------
#ifndef CVECTEUR2D_H
#define CVECTEUR2D_H
//écrit par Kirua - nicolasboumal@hotmail.com
//------------------------------------------------------------------------------
#include <cmath> //pour la fonction hypot() (renvoie la racine carrée de la somme des carrés des 2 paramètres)
//------------------------------------------------------------------------------
//Explication: le premier paramètre (T) est le type des coordonnées. Pour un point de l'écran, on voudra
//des int, mais pour un point de l'espace, on préférera float ou même double. Le second paramètre (S)
//indique le type à utiliser pour effectuer les calculs intermédiaires. Il est recommandé d'utilisé un
//type plus précis (par défaut, double) afin d'éviter les pertes trop importantes liées aux arrondis.
template<typename T, typename S = double>
class CVecteur2D
{
public:
CVecteur2D() : x(0), y(0) {}
CVecteur2D(T _x, T _y) : x(_x), y(_y) {}
CVecteur2D(const CVecteur2D& V) { x = V.x; y = V.y; };
T x, y;
S GetModule() const {return S(hypot(y,x));}
void SetModule(S m) { S M = GetModule(); x = T(x*m/M); y = T(y*m/M); }
S GetAngle() const { return S(atan2(y, x)); }
CVecteur2D operator+ (const CVecteur2D& V) const {return CVecteur2D(x+V.x, y+V.y);}
CVecteur2D operator- (const CVecteur2D& V) const {return CVecteur2D(x-V.x, y-V.y);}
CVecteur2D operator* (const S R) const {return CVecteur2D(T(x*R), T(y*R));}
CVecteur2D operator/ (const S R) const {return CVecteur2D(T(x/R), T(y/R));}
S operator* (const CVecteur2D& V) const {return x*V.x + y*V.y;}
CVecteur2D& operator+=(const CVecteur2D& V) {x += V.x; y += V.y; return *this;}
CVecteur2D& operator-=(const CVecteur2D& V) {x -= V.x; y -= V.y; return *this;}
CVecteur2D& operator*=(const S R) {x = T(S(x) * R); y = T(S(y) * R); return *this;}
CVecteur2D& operator/=(const S R) {x = T(S(x) / R); y = T(S(y) / R); return *this;}
bool operator==(const CVecteur2D& V) const {return (x == V.x && y == V.y);}
bool operator!=(const CVecteur2D& V) const {return (x != V.x || y != V.y);}
};
//------------------------------------------------------------------------------
typedef CVecteur2D<int> V2Di;
typedef CVecteur2D<float> V2Df;
typedef CVecteur2D<double> V2Dd;
//------------------------------------------------------------------------------
#endif
//------------------------------------------------------------------------------
Et la classe 3D:
//------------------------------------------------------------------------------
#ifndef CVECTEUR3D_H
#define CVECTEUR3D_H
//écrit par Kirua - nicolasboumal@hotmail.com
//------------------------------------------------------------------------------
#include <cmath>
//------------------------------------------------------------------------------
template<typename T, typename S = double>
class CVecteur3D
{
public:
CVecteur3D() : x(0), y(0), z(0) {}
CVecteur3D(T _x, T _y, T _z) : x(_x), y(_y), z(_z) {}
CVecteur3D(const CVecteur3D& V) { x = V.x; y = V.y; z = V.z; }
T x, y, z;
S GetModule() const { return S(sqrt(x*x + y*y + z*z)); }
void SetModule(S m) { S M = GetModule(); x = T(x*m/M); y = T(y*m/M); z = T(z*m/M); }
CVecteur3D operator+ (const CVecteur3D& V) const {return CVecteur3D(x+V.x, y+V.y, z+V.z);}
CVecteur3D operator- (const CVecteur3D& V) const {return CVecteur3D(x-V.x, y-V.y, z-V.z);}
CVecteur3D operator* (const S R) const {return CVecteur3D(T(x*R), T(y*R), T(z*R));}
CVecteur3D operator/ (const S R) const {return CVecteur3D(T(x/R), T(y/R), T(z/R));}
S operator* (const CVecteur3D& V) const {return x*V.x + y*V.y + z*V.z;}
CVecteur3D& operator+=(const CVecteur3D& V) {x += V.x; y += V.y; z += V.z; return *this;}
CVecteur3D& operator-=(const CVecteur3D& V) {x -= V.x; y -= V.y; z -= V.z; return *this;}
CVecteur3D& operator*=(const S R) {x = T(S(x) * R); y = T(S(y) * R); z = T(S(z) * R); return *this;}
CVecteur3D& operator/=(const S R) {x = T(S(x) / R); y = T(S(y) / R); z = T(S(z) / R); return *this;}
bool operator==(const CVecteur3D& V) const {return (x == V.x && y == V.y && z == V.z);}
bool operator!=(const CVecteur3D& V) const {return (x != V.x || y != V.y || z != V.z);}
//produit croisé (cross product, produit vectoriel)
CVecteur3D operator^ (const CVecteur3D& V) const {return CVecteur3D(y*V.z - z*V.y, z*V.x - x*V.z, x*V.y - y*V.x);}
CVecteur3D& operator^= (const CVecteur3D& V) {x = y*V.z - z*V.y; y = z*V.x - x*V.z; z = x*V.y - y*V.x; return *this;}
};
//------------------------------------------------------------------------------
typedef CVecteur3D<int> V3Di;
typedef CVecteur3D<float> V3Df;
typedef CVecteur3D<double> V3Dd;
//------------------------------------------------------------------------------
#endif
//------------------------------------------------------------------------------
Conclusion :
Si vous trouvez des erreurs / incohérences ... ou si vous avez des suggestions: postez joyeusement.
Codes Sources
A voir également
- Simulation physique 3d
- Classe 2d - Meilleures réponses
- C / C++ / C++.NET : Animation 2d<->3d - Guide
- C / C++ / C++.NET : Moteur 2d/3d directx 9 - CodeS SourceS - Guide
- :: matrix, fausse 3d, profondeur. utilisation des object et des protos. - Codes sources - Flash (3D)
- Classe de vecteur - Codes sources - C / C++ / C++.NET (Maths & Algorithmes)
- Java : Classes ( matrice , vecteur et trigonométrie) avec ces opérations - CodeS Sou - Guide
Commentaires
template<typename S>
CVecteur2D operator* (const S factor) const
{
return CVecteur2D( T(factor)*x, T(factor)*y );
}
template<typename S>
CVecteur3D(const CVecteur3D<S>& V) { x (T)V.x; y (T)V.y; z = (T)V.z; }
et il y a une faute d'ortho trop bête dans le commentaire -_-
Vous n'êtes pas encore membre ?
inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.