Discussion :

[khayyam90]

Bien le bonjour,

Savez-vous s'il existe en standard ou dans boost une classe de vecteur 2D / 3D qui implémente toutes les méthodes qui vont bien ? genre +, -, *scalaire, produit vectoriel, produit scalaire, norme, <, ==, = ...

Avouez que ce serait dommage de réécrire la roue une énième fois.

Vous avez ça en stock ?

[_SamSoft_]

Justement, je suis en train de développer cela, une petite lib de maths mais ca c'est la base après je rajoute ma touche avec des fonctions pour calculer les aires, les périmètres...

Mais en toute honnêteté, je dirai que Vector2D/3D (pour les produits scalaires...) ca doit exister mais où ?

Pour ce n'est pas réinventer la roue car il y a des choses qui vont êtres dans ma lib qui n'existent pas vraiment (pê car c'est peu utilisé )

[Klaim]

Il me semble qu'il n'y a pas d'objet dans le genre dans boost, mais il me semble aussi qu'il y a une lib concernant la géometrie... ou seulement des calculs liés.

[khayyam90]

J'ai bien vu boost::numeric::ublas::vector<T>, mais ça manque de fonctionnalités

[HanLee]

Ben c'est surtout que c'est pas fait pour. C'est pour du calcul matriciel général, et pas pour des trucs spécifiques comme les jeux vidéos.

[khayyam90]

Ben c'est surtout que c'est pas fait pour. C'est pour du calcul matriciel général, et pas pour des trucs spécifiques comme les jeux vidéos.

J'entends bien. N'y a-t-il donc rien en standard qu'on doive réécrire/récupérer une classe externe ? Comme beaucoup de monde j'en ai une sous la main, mais j'aurais espéré pouvoir utiliser quelque chose d'un peu standard.

[Klaim]

Il me semble qu'il y en a une (bibliothèque) en particulier qui est pas mal utilisée dans les moteurs 2D/3D, quelque chose comme Math Magic ou quelque chose comme ça. Le problème c'est que je ne retrouve pas le nom exact.
Les classes 2D/3D/Quaternion de Ogre en sont largement inspirés (voir copiés à la base).

[HanLee]

Tu peux regarder du côté de CGAL sinon, c'est un biblio spécialisé pour les algorithmes géométriques.

[khayyam90]

On ne va pas aller jusque là. S'il n'y a rien en standard ou en boost, je vais me prendre une petite classe tierce.

[Kurisu]

Je suis en train d'en écrire une moi-même (cf. mes posts sur les templates), mais il existe GLM (glm.g-truc.net) qui me semble très correcte.
Sinon, DirectX/D3D possède des propres types pour l'algèbre linéaire.

[HanLee]

En même temps, c'est pas mal quand tu veux taper un peu du niveau supérieur en 3D, genre la décimation ou la subdivision de maillages, t'as des structures de données compliquées déjà implémentées.

[khayyam90]

oui, si on tape dans les biblios externes on trouve forcément

[nicroman]

En général ces classes sont si "classiques" à programmer, que tout le monde les a forcément déjà dans un coin... un petit coup de refactoring pour le mettre à la sauce du projet et basta.

Maintenant, chaque projet peut avoir ses spécificités...
Par exemple, un moteur de jeu préfèrera avoir des structures simples de float, des fonctions rapides dessus genre:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
template<type T,int size> T* vector_add(T* pdst, const T* psrc1, const T* psrc2);
template<type T,int size> T* vector_add_smult(T* pdst, const T* psrc1, const T* psrc2, T src2scalar);
template<type T,int size> T* vector_smult_add(T* pdst, const T* psrc1, T src1scalar, const T* psrc2);
template<type T,int size> T* vector_smult_add_smult(T* pdst, const T* psrc1, T src1scalar, const T* psrc2, T src2scalar);
template<type T,int size> T* vector_sub(T* pdst, const T* psrc1, const T* psrc2);
template<type T,int size> T* vector_sub_smult(T* pdst, const T* psrc1, const T* psrc2, T src2scalar);
template<type T,int size> T* vector_smult_sub(T* pdst, const T* psrc1, T src1scalar, const T* psrc2);
template<type T,int size> T* vector_smult_sub_smult(T* pdst, const T* psrc1, T src1scalar, const T* psrc2, T src2scalar);
template<type T, int size> T vector_sprod(const T* psrc1, const T* psrc2);
template<type T, int size> T* vector_vprod(T* pdst, const T* psrc1, const T* psrc2);
...

Et des classes qui wrappent tout ça pour la "beauté", la compréhension du code, et surtout éviter les bugs

Il y a beaucoup de fonctions "matricielles" en commun entre:
Vector3D, Point3D, Point3D_rhw, ou Quaternion....
Mais sémantiquement (au niveau classes C++ donc), ce sont des concepts bien différents et qui doivent être séparés. Et on peut faire dériver Quaternion d'une classe de OrthoNormalTransform sans sourcilier... Mais pas de Vector4D !

Prenons un autre exemple: il y a pour moi une différence entre "Tangeant3D" et "Normal3D"... Les deux héritent de Vector3D... et pourtant.... l'application d'une transformation 3D dans un cas sera directe, dans l'autre cas, c'est l'inverse de la transformation qui sera appliquée.