Classe de vecteurs en 2d / 3d portable, utilisation pour simulations physiques

Télécharger le projet
Commenter

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

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.
Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

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.

Du même auteur (cs_Kirua)