J'ai un pote qui bosse sur un projet de jeu de billard. Il utilise les composantes de vitesse horizontale et verticale pour ses calculs de collisions. Est-ce qu'il existe un type "vecteur" en C/C++ (builder) pour lui permettre de résoudre ses problèmes? Et si oui, comment passer de ses composantes X, Y à ce type? Et du même coup, il se demande alors comment faire ses calculs de collisions/rebonds avec les vecteurs
 
Merci pour lui  

[edit]--Message édité par Elsener--[/edit]

Il y a une classe template vector en C++ (avec la STL) mais c'est un container et non un vecteur mathématique.
 
Mais il peut écrire sa propre classe de vecteur, avec les opérations matheuses qui vont bien. C'est un exercice classique pour débutant en C++.

Cadeau : c le fichier que j'utilise tout le temps.
 
class Vector3d
{
 public:
  float x,y,z;
  Vector3d(){}
  Vector3d(float vx, float vy=0, float vz=0)
    {
      x=vx;y=vy;z=vz;
    }
  float operator * (const Vector3d & v1) const
    {
      return (x*v1.x+y*v1.y+z*v1.z);
    }
  friend Vector3d operator * (const float scalaire, const Vector3d & v);
  friend Vector3d Modulate(const Vector3d & a, const Vector3d & b);
  Vector3d normalized() const;
   
  float xp () const {return x;}
  float yp () const {return y;}
  float zp () const {return z;}
 
  Vector3d & operator *= (const float scalaire)
  {
    x*=scalaire;
    y*=scalaire;
    z*=scalaire;
    return *this;
  }
  Vector3d & operator += (const Vector3d &v)
  {
    x+=v.x;
    y+=v.y;
    z+=v.z;
    return *this;  
  }
  Vector3d & mult(const float scalaire)
    {
      x*=scalaire;
      y*=scalaire;
      z*=scalaire;
    }
 
  Vector3d operator + (Vector3d v) const
    {
      return v+=(*this);
    }
  Vector3d operator ^ (const Vector3d &v) const
    {
      return  Vector3d(y*v.z-z*v.y, z*v.x-x*v.z, x*v.y-y*v.x);
    }
  bool operator == (const Vector3d & v) const
    {
      return (x==v.x)&&(y==v.y)&&(z==v.z);
    }
  Vector3d & operator -= (const Vector3d &v)
    {
      x-=v.x;
    y-=v.y;
    z-=v.z;
    return *this;
  }
  Vector3d operator - (const Vector3d &v) const
    {
      return Vector3d(x-v.x, y-v.y, z-v.z);
    }
  Vector3d & operator /= (float fact)
    {
      float oof=1.0/fact;
      return (*this)*=oof;
    }
  Vector3d operator / (float fact)
    {
      float oof=1.0/fact;
      return Vector3d(*this)*=oof;
    }
  float abs() const {return sqrtf(x*x+y*y+z*z);}
  float absq() const {return x*x+y*y+z*z;}
  /*C est pas joli comme nom, mais ça va plaire à certaines classes dérivées*/
  void Translate(const Vector3d &v){(*this)+=v;}
  Vector3d & Normalize()
    {
      return *this/=abs();
    }
  float MaxDist(const Vector3d & o) const
    {
      return max(max(fabsf(x-o.x), fabsf(y-o.y)),fabsf(z-o.z));
    }
  friend istream& operator >> (istream& in, Vector3d& v);
  friend ostream& operator << (ostream& out, const Vector3d& v);
};

Yeahhh!!!
Il jubile
 
Merci beaucoup! C'est vraiment excellent! Bon il travaille en 2D, mais la conversion de la classe prend 2 minutes Je crois que tu viens de lui sauver son projet, hehehe
 

En STL les valarray sont plus indiques pour des operations mathematiques...

Verdoux et BENB > Pourquoi est-ce que vous vous chicannez comme çà sur des points de détails ?

zop a écrit a écrit : Verdoux et BENB > Pourquoi est-ce que vous vous chicannez comme çà sur des points de détails ?

Loin de moi l'intention de "chicaner" Verdoux...
Apres y en a qui vont jaser
 
Je complete sa reponse, qui par ailleurs est plutot bien...
Quand on pose une question on attend souvent des reponses precises et riche. De la sorte j'enrichie la reponse de Verdoux pour le benefice de Elsener et de tous ceux qui lisent ce post
 
Pour info le valarray est un tableau de la STL optimise pour un usage mathematique plutot que stockage comme le vector...
 
Le mieux etant donc dans le cas present de reecrire la classe vector3D de tgrx en utilsant la STL pour n'importe quel taille de vecteur
(Non tapez pas sur la tete !)...

Eh mec, du calme.... c'est bon tu peux deja penser a tes superbes vacances de cet été!!!
en effet, les experts ne vont rien captés a ce que tu as fait.. alors peperre..
va plutot degraisser tu sais quoi, afin de mitrailler au milimetre!!!

BENB a écrit a écrit :   Le mieux etant donc dans le cas present de reecrire la classe vector3D de tgrx en utilsant la STL pour n'importe quel taille de vecteur (Non tapez pas sur la tete !)...

 
Bof... c'est vraiment compliquer le probleme pour pas grand chose. Parce qu'apres vaut templatiser tout ca, verifier quand on ajoute des vecteurs qu'ils ont la meme taille...
 
Surtout qu'au final c surtout en 3D que ca sert. NON au C++ theorique !

tgrx > Je sais je derive un peu, mais je fais tres peu (pas du tout en fait) de 3D, mais par contre je fais de la modelisation mathematique... d'ou mon interet pour des vecteurs de taille quelconques...

BENB> pas de pb, c'etait juste une remarque comme ca. Mais c'est vrai que moi aussi des fois je cede a la tentation et j'ecris des fonctions/classes hyper generales avec des templates a profusion, la STL a tout bout de champ... c sympa aussi