Discussion :

[nicolas66]

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.

[Laurent Gomila]

Salut

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

[nicolas66]

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

Vecteur.h

Code :

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

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 :

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

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 :

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

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 :

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

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.

[sdenis]

Bonjour,

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

Code :

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

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 :

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

1
2
 
this->adr

pour faire appel à ton membre privé, et pas

Code :

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

1
2
 
adr;

tout simplement ?

[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.

[venomelektro]

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 :

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

1
2
 
glVertex3fv ((float*)&v);

Si tu veux pas caster en float* fait une union

Code :

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

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 :

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

1
2
3
 
Vector3 vec(1,0,1);
glVertex3f(vec.v);

[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.

[nicolas66]

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


Nico.

[Laurent Gomila]

Code :

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

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

[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.

[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.

[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.

[nicolas66]

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


Nico.

[Laurent Gomila]

Ligne de code incriminée ? Message d'erreur exact ?

[nicolas66]

Ya pas de message d'erreur justement c'est ca qui est bizarre ..

[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

[nicolas66]

J'essaye de tracer une ligne de couleur de l'origine au point M(1,0,0) en faisant ceci :

Code :

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

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) ..

[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 :

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

glVertex3fv(v);

Tout simplement.

[nicolas66]

C'est bon ca marche, je te remercie

[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