classe Vertex

Version imprimable

Voir 40 message(s) de cette discussion en une page

17/11/2004, 16h25
nicolas66

classe Vertex

Bonsoir tlm,

J'ai pour travail de réaliser des classes pour gérer les lumières, les couleurs et les vertex. Seulement j'ai crée une classe vertex avec en partie privé un pointeur de type float. Et qd je veux utiliser glVertex3f(...) avec un objet issu de ma classe vertex j'ai une erreur. Ya pas moyen de remédier à ca en faisant accepter mon pointeur en paramètre dans les fonctions OpenGL ? Sinon ca serait balo d'avoir fait tout ce travail pour rien ! Merci d'avance.

Nico.
17/11/2004, 16h37
Laurent Gomila

Salut

Est-ce que tu peux nous montrer le contenu de ta classe et l'utilisation que tu voudrais en faire exactement ?

Oui bien sûr, voilà déjà les fichiers pour la classe Vecteur :

Vecteur.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
#include <math.h>
#include <iostream.h>
 
class VecteurExceptions{};
 
class Vecteur
{
     private:
	float * adr;
 
     public:
	//---------      constructeurs     ---------
	Vecteur( const float &, const float &, const float & );
	Vecteur( const Vecteur & );
 
 
	//-------------- destructeur -------------
	~Vecteur();
 
 
	//--------- Méthodes principales ---------
	float norme() const;
	void normalize() const;
 
 
	//--------- surcharge d'opérateurs ---------
 
	// opérateur d'affectation entre deux vecteurs
	Vecteur & operator = ( const Vecteur & );
 
	// opérateur d'accès à un élément du vecteur
	float & operator [] ( const int & ) const;
 
	// opérateur unaire sur un vecteur
	Vecteur operator  - () const;
 
	// opérateurs binaires entre deux vecteurs
	Vecteur operator  + ( const Vecteur & ) const;
	Vecteur operator += ( const Vecteur & );
	Vecteur operator  - ( const Vecteur & ) const;
	Vecteur operator -= ( const Vecteur & );
	float   operator  * ( const Vecteur & ) const;
	Vecteur operator  ^ ( const Vecteur & ) const;
	Vecteur operator ^= ( const Vecteur & );
 
	// opérateurs binaires entre un vecteur et un float
	Vecteur operator  * ( const float & ) const;
	Vecteur operator *= ( const float & );
	Vecteur operator  / ( const float & ) const;
	Vecteur operator /= ( const float & );
 
	// opérateurs de comparaison entre vecteurs
	bool operator == ( const Vecteur & ) const;
	bool operator != ( const Vecteur & ) const;
	bool operator >= ( const Vecteur & ) const;
	bool operator <  ( const Vecteur & ) const;
	bool operator <= ( const Vecteur & ) const;
	bool operator >  ( const Vecteur & ) const;
};
 
ostream & operator << ( ostream &, const Vecteur & );

Vecteur.cc

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
 
#include "Vecteur.h"
 
 
//--------------------------------------------------------- Constructeurs --------------------------------------------------------------
 
Vecteur::Vecteur( const float & x=0.0, const float & y=0.0, const float & z=0.0 )
{
	this->adr = new float[3];
	this->adr[0] = x;
	this->adr[1] = y;
	this->adr[2] = z;
}
 
Vecteur::Vecteur( const Vecteur & v )
{
	this->adr = new float[3];
	for(int i=0;i<3;i++)
		this->adr[i] = v[i];
}
 
 
//---------------------------------------------------------- Destructeurs --------------------------------------------------------------
 
Vecteur::~Vecteur()
{
	delete [] this->adr;
}
 
 
//------------------------------------------------------ Méthode principales -----------------------------------------------------------
 
float Vecteur::norme() const
{
	return (float)sqrt( this->adr[0] * this->adr[0] + this->adr[1] * this->adr[1] + this->adr[2] * this->adr[2] );
}
 
void Vecteur::normalize() const
{
	if( this->norme() != 0.0 )
	{
		this->adr[0] /= this->norme();
		this->adr[1] /= this->norme();
		this->adr[2] /= this->norme();
	}
}
 
//----------------------------------------------------- Surcharge d'opérateurs ---------------------------------------------------------
//---------------------------------------------------- Opérateur d'affectation ---------------------------------------------------------
 
Vecteur & Vecteur::operator = ( const Vecteur & v )
{
	if( this != &v )
	{
		delete [] this->adr;
		this->adr = new float[3];
		for(int i=0;i<3;i++)
			this->adr[i] = v.adr[i];
	}
	return (*this);
}
 
 
//------------------------------------------------- Opérateur d'accès aux éléments -----------------------------------------------------
 
float & Vecteur::operator [] ( const int & i ) const
{
	if( i < 0 || i >= 3 )
		throw VecteurExceptions();
	return this->adr[i];
}
 
 
//-------------------------------------------------------- Opérateur unaire ------------------------------------------------------------
 
Vecteur Vecteur::operator - () const
{
	return ((*this) * -1.0);
}
 
 
//----------------------------------------------- Opérateurs binaires entre vecteurs ---------------------------------------------------
 
Vecteur Vecteur::operator + ( const Vecteur & v ) const
{
	return Vecteur( this->adr[0] + v[0], this->adr[1] + v[1], this->adr[2] + v[2] );
}
 
Vecteur Vecteur::operator += ( const Vecteur & v )
{
	return ((*this) = (*this) + v);
}
 
Vecteur Vecteur::operator - ( const Vecteur & v ) const
{
	return (*this + (-v));
}
 
Vecteur Vecteur::operator -= ( const Vecteur & v )
{
	return ((*this) = (*this) - v);
}
 
float Vecteur::operator * ( const Vecteur & v ) const
{
	return ( this->adr[0]*v[0] + this->adr[1]*v[1] + this->adr[2]*v[2] );
}
 
Vecteur Vecteur::operator ^ ( const Vecteur & v ) const
{
	return Vecteur( this->adr[1]*v[2] - this->adr[2]*v[1], this->adr[2]*v[0] - this->adr[0]*v[2], this->adr[0]*v[1] - this->adr[1]*v[0] );
}
 
Vecteur Vecteur::operator ^= ( const Vecteur & v )
{
	return ((*this) = (*this) ^ v);
}
 
 
//-------------------------------------- Opérateurs binaires entre un vecteur et un flottant -------------------------------------------
 
Vecteur Vecteur::operator * ( const float & l ) const
{
	return Vecteur( this->adr[0] * l, this->adr[1] * l, this->adr[2] * l );
}
 
Vecteur Vecteur::operator *= ( const float & l )
{
	return ((*this) = (*this) * l);
}
 
Vecteur Vecteur::operator / ( const float & l ) const
{
	if( l == 0 )
		throw VecteurExceptions();
	return ((*this) * (1/l));
}
 
Vecteur Vecteur::operator /= ( const float & l )
{
	return ((*this) = (*this) / l);
}
 
 
//-------------------------------------------- Opérateur de comparaison entre vecteurs -------------------------------------------------
 
bool Vecteur::operator == ( const Vecteur & v ) const
{
	return (this->adr[0]==v[0] && this->adr[1]==v[1] && this->adr[2]==v[2] );
}
 
bool Vecteur::operator != ( const Vecteur & v ) const
{
	return !((*this) == v );
}
 
bool Vecteur::operator >= ( const Vecteur & v ) const
{
	return ( this->norme() >= v.norme() );
}
 
bool Vecteur::operator < ( const Vecteur & v ) const
{
	return !((*this) >= v );
}
 
bool Vecteur::operator <= ( const Vecteur & v ) const
{
	return ( this->norme() <= v.norme() );
}
 
bool Vecteur::operator > ( const Vecteur & v ) const
{
	return !((*this) <= v );
}
 
 
//------------------------------------------------- Opérateur sur sortie standard ------------------------------------------------------
 
ostream & operator << ( ostream & sortie, const Vecteur & v )
{
	for(int i=0;i<3;i++)
		(i!=2) ? sortie << v[i] << endl : sortie << v[i];
	return sortie;
}

Tout ca pour dire que lors d'un appel à glVertex3f, j'aimerai pouvoir lui passer en paramètre mon objet Vecteur. Genre :

Code:

1
2
3
4
5
 
Vecteur v(0,0,0);
glBegin(GL_POINTS);
glVertex3f(v);
glEnd();

Bon sinon si je peux pas, j'aimerai pouvoir arriver à lui passer chacune de mes coordonnées peut-être comme ca :

Code:

1
2
3
4
5
6
7
8
 
Vecteur v(0,0,0);
glVertex3f(v.getX(),v.getY(),v.getZ());
 
OU
 
Vecteur v(0,0,0);
glVertex3f(v[0],v[1],v[2]);

Dites-moi ce que vous en pensez et ce qu'il serait le plus pratique et judicieux selon vous sachant que j'aimerai en fait étendre cette classe pour gérer les coords de textures et de normales. Est-ce que ces classes sont vraiment utiles pour après ? Merci bien !

Nico.

17/11/2004, 20h24
sdenis
Bonjour,

La fonction glVertex3f accepte comme argument 3 flottants, donc tu est obligé d'utiliser
Code:

1 2 3 4 glVertex3f(vertex.getX(),vertex.getY(),vertex.getZ()); // ou mieux glVertex3f(vertex[0],vertex[1],vertex[2]);
Ta classe a quand même une utilité car elle représente l'objet, et tu pourras faire des opérations (comparaison, norme, ...) plus facilement.

Une p'tite question en passant, pourquoi utliliser la notation
Code:

1 2 this->adr
pour faire appel à ton membre privé, et pas
Code:

1 2 adr;
tout simplement ?
17/11/2004, 20h42
nicolas66

Ah merci bien pour toutes ces précisions. Je sais coder mais je me pose souvent pas mal de questions (c'est bien sans l'être ..). En fait je m'en suis aperçu toute à l'heure pour le paramètre de 'glVertex3f' et je vais faire le nécessaire pour modifier ma classe.

En ce qui concerne 'this->adr', je préfère le mettre car je repère mieux quelle sont les variables privées attachées à la classe. En revanche, ca alourdi un peu le code, je l'accorde ..

Bref, je débute en OpenGL cette année et j'ai un projet à rendre. Je commance donc par créer ce que j'appelle des classes de bas niveau (lumières, vertex, couleurs, etc.) pour monter d'autres classes qui s'appuieront sur ce que j'ai fais avant. Enfin voilà, on s'en fou lol. Merci encore pour tes conseils et bonne fin de soirée à toi !

Nico.
18/11/2004, 10h59
venomelektro
Citation:

Tout ca pour dire que lors d'un appel à glVertex3f, j'aimerai pouvoir lui passer en paramètre mon objet Vecteur. Genre :

Code:

Vecteur v(0,0,0);
glBegin(GL_POINTS);
glVertex3f(v);
glEnd();

utilise

glVertex3fv() et passe en arg l adresse de ton vecteur

genre
Code:

1 2 glVertex3fv ((float*)&v);
Si tu veux pas caster en float* fait une union
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 class Vector3 { public: union { struct { float x; float y; float z; }; float v[3]; };
du coup
Code:

1 2 3 Vector3 vec(1,0,1); glVertex3f(vec.v);
18/11/2004, 14h40
Laurent Gomila

Autre solution, à la manière de D3DMATRIX : tu définis pour ta classe un opérateur de cast automatique en float*, ainsi tu passes directement ton objet à ta fonction.
18/11/2004, 18h59
nicolas66

Comment fais-tu pour l'opérateur de cast automatique ? J'ai jamais fait ce genre de truc .. Merci.

Nico.

Code:

1
2
3
4
5
6
7
8
9
struct vertex
{
   float v[3];
 
   operator float*()
   {
      return v;
   }
};

18/11/2004, 20h19
nicolas66

Merci pour l'info. J'ai une dernière petite question : comme je vais faire une petite pièce texturée en 3d, il me faut 6 "cubes" formant les 4 murs, le sol et le plafond. Habituellement en OpenGL, est-ce que :

* Pour chacun de ces "cubes" on trace des cubes par l'intermédiaire de la fonction 'glutSolidCube(...)' et puis on met une texture.

OU

* On fait plein de tableaux entrelacés (coords espace + coords texture) pour tracer chaque cube.

Nico.
18/11/2004, 20h38
Laurent Gomila

Je pense que la première solution sera très inefficace, donc à éviter. Personnellement je suis passé à OpenGL après avoir appris DirectX, donc j'ai tendance à n'utiliser que des VBO pour stocker ma géometrie. Le principe c'est de stocker toute ta géometrie (enfin... le maximum) dans un gros buffer, ainsi tu économise les changements de buffers et tu peux batcher tes polygones pour améliorer le rendu.
18/11/2004, 21h04
nicolas66

En gros, ca veut qu'il faut mettre les coords de l'espace + les coords de texture dans un même tableau ou un même fichier ?

Nico.
19/11/2004, 10h24
nicolas66

J'ai testé la méthode avec glVertexfv(...) et ca ne marche pas avec la méthode de cast :(.

Nico.
19/11/2004, 10h48
Laurent Gomila

:arrow: Ligne de code incriminée ? Message d'erreur exact ?
19/11/2004, 13h01
nicolas66

Ya pas de message d'erreur justement c'est ca qui est bizarre ..
19/11/2004, 14h10
Laurent Gomila

Ben essaie d'être plus précis quand même... "Ca marche pas mais y a pas d'erreur" ça va pas beaucoup nous aider :wink:
19/11/2004, 17h45
nicolas66
J'essaye de tracer une ligne de couleur de l'origine au point M(1,0,0) en faisant ceci :
Code:

1 2 3 4 5 6 7 Vecteur<float> v(1,0,0); glBegin(GL_LINES); glColor3f(0.0,1.0,0.0); glVertex3f(0,0,0); glVertex3fv( (float *)&v ); glEnd();
Tout passe parfaitement à la compilation. Seulement la ligne n'est pas du tout tracée sur l'écran (Ma classe est la même que précédemment) ..
19/11/2004, 21h42
Laurent Gomila

Tu t'y prends mal. Le but d'un operateur de cast automatique est justement de ne pas avoir à caster explicitement, et d'autre part c'est ton objet qui va être casté en float*, pas son adresse.

Code:

glVertex3fv(v);

Tout simplement.
19/11/2004, 21h50
nicolas66

C'est bon ca marche, je te remercie :)
26/11/2004, 02h20
ReD-@

pkoi 6 cubes pr ta piece ??? tu croi pa ke 2 cubes suffisent ?
un cube ki se voit de l interienr et un autre ki le contient
sauf si tu sera toujour a l interieur d ta piece ou ke les mur auront le mem texture (symetriq) des 2 cotés ds ces 2 cas tu peu utiliser k un seul cube
et la si tu fé une seule piece peut importe l ordre

ah wi sinon pr ta kestion tu peut faire une struct vertexcomplet (vertex+couleur+autre chose si t en a besoin) composée de ta class vertex + d une autre pr les couleur
ensuite tu fé un tablo de vertexcomplet
mé en general peut importe si tu fé un tablo ou 2 c selon commen tu veu voir le chose coté performances ca change rien

Voir 40 message(s) de cette discussion en une page