Discussion :

[PowerCitron]

Bonsoir,
Je me décide a poster ce message car il me reste plus beaucoup de cheveux sur la tête a cause d'un probleme simple je l'espere. Je suis novice dans l'utilisation d'opengl et j'ai tout d'abord pris le temps de lire les documentations sur le sujet. Pour optimiser mon application je choisis d'utiliser les VBO. J'ai créé des objets de base (cube, cylindre) et après quelque maux de tête j'ai finis par les faire fonctionner. Puis je suis passé a la sphere, et la sa se complique. J'arrive a faire ma sphere avec les vertex array, mais avec les vbo sa marche mal, tres mal.
Je m'explique sa marche en ce que je vais appeler "low detail" c'est a dire n=8 (nombre de vertex pour ma sphere est n*(n-1)+2 , le 2 correspond a mes "sommets") or des que je passe a n=10 j'ai une erreur memoire type
./opengl: malloc(): memory corruption: 0x0883bb28

Alors j'ai voulu tester si le même probleme se posait avec le cylindre. Et la petite larme est arrivée en montant le detail de mon cylindre, crash meme probleme. Pour mon cylindre qui est moins complexe que la sphere a n=100 il marche encore a 150 il ne marche plus.

Je sais vous aller me dire que sa sert a rien de faire un cylindre aussi detaillé mais pour la sphere n=10 c'est loin d être detaillé. Donc je pense que je dois mal initialiser mes VBO puisque qu avec les vertex array je n ai aucun probleme.
J'espere que quelqu un pourra m aider parce que sa fait un bon moment que je suis dessus et rien a faire.
Je vous presente mon code sur le cylindre car celui de la sphere c'est le carnage tellement j ai voulu trouver le probleme les VBO etant initialiser de la meme maniere de toute facon.

cylindre.cpp

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
 
void Cylindre::GenerateCylindre(const Vector& c, float r, float h, float proportion)
{
  float theta=0.0;
 
  int a=0, b=0, d=0, n=150;
	GLfloat VertexArray[12*n];
	GLuint Indice[6*n];
 
  for(int i=0;i<n;i++)
 
  {
 
     theta=proportion*i*M_PI/n;
 
     float x = cos(theta); 
 
     float z = sin(theta); 
		 VertexArray[a]= c[0] + x*r; //Vertex bas cylindre
		 VertexArray[a+1]= c[1];
		 VertexArray[a+2]= c[2] + z*r;
		 VertexArray[a+3]= x;				//Normal
		 VertexArray[a+4]= 0.0f;
		 VertexArray[a+5]= z;
		 VertexArray[a+6]= c[0] + x*r; //Vetex haut cylindre
		 VertexArray[a+7]= c[1] + h;
		 VertexArray[a+8]= c[2] + z*r;
		 VertexArray[a+9]= x;					//Normal
		 VertexArray[a+10]= 0.0f;
		 VertexArray[a+11]= z;
 
		 a=a+12;
 
    }
 
	for (int ii=0;ii<n-1;ii++)
	{
		Indice[b]=d;
		Indice[b+1]=d+2;
		Indice[b+2]=d+1;
		Indice[b+3]=d+1;
		Indice[b+4]=d+2;
		Indice[b+5]=d+3;
		b=b+6;
		d=d+2;
	}
	Indice[b]=d;
	Indice[b+1]=0;
	Indice[b+2]=d+1;
	Indice[b+3]=d+1;
	Indice[b+4]=0;
	Indice[b+5]=1;
 
	for (int j=0;j<12*n;j++)
	{
		CylindreArray[j]=VertexArray[j];
	}
	for (int jj=0;jj<6*n;jj++)
	{
		IndiceArray[jj]=Indice[jj];
	}
}
 
void Cylindre::InitVBO()
{
	// Génération des buffers
	glGenBuffers(2, CylindreBuffers);
 
	// Buffer d'informations de vertex                                                               
	glBindBuffer(GL_ARRAY_BUFFER, CylindreBuffers[0]);
	glBufferData(GL_ARRAY_BUFFER, sizeof(CylindreArray), CylindreArray, GL_STATIC_DRAW);  
 
	// Buffer d'indices
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, CylindreBuffers[1]);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(IndiceArray), IndiceArray, GL_STATIC_DRAW);
 
}
 
 
void Cylindre::Affiche()
{
	// Utilisation des données des buffers
	glBindBuffer(GL_ARRAY_BUFFER, CylindreBuffers[0]);
	glVertexPointer( 3, GL_FLOAT, 6 * sizeof(float), 0 );
	glNormalPointer( GL_FLOAT, 6 * sizeof(float), ((float*)NULL + (3)) );
 
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, CylindreBuffers[1]);
 
	// Activation d'utilisation des tableaux
	glEnableClientState( GL_VERTEX_ARRAY );
	glEnableClientState( GL_NORMAL_ARRAY );
 
	// Rendu de notre géométrie
	glDrawElements(GL_TRIANGLES, 6*N_VER_CY, GL_UNSIGNED_INT, 0);
 
	glDisableClientState( GL_NORMAL_ARRAY );
	glDisableClientState( GL_VERTEX_ARRAY );
}
 
 
Cylindre::Cylindre(const Vector& c, float r, float h, float proportion)
{ 
	GenerateCylindre(c,r,h,proportion);
	InitVBO();
}
 
Cylindre::~Cylindre()
{
	glDeleteBuffers(2, CylindreBuffers);
}

shape.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
 
#define N_VER_CY 150
 
class Cylindre
{
	protected :
 
		// Buffers VBO
		GLuint CylindreBuffers[2];		
		//Array
		GLfloat CylindreArray[12*N_VER_CY];
		GLuint IndiceArray[6*N_VER_CY];
 
		void GenerateCylindre(const Vector& c, float r, float h, float proportion);
		void InitVBO();
 
	public:
		void Affiche();
		Cylindre(const Vector& c, float r, float h, float proportion);
		~Cylindre();
};

et le main.cpp

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
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
 
// Angle de rotation des objects
float alpha=0.0f;
 
int Mousekey=0,Mousex,Mousey;
 
int light=1;
int myrotate=1;
float kavarr= 0.0f;
float kgaudroi=0.0f;
 
 
//Sphere * c=NULL;
Cylindre * a=NULL;
// Identifiant de fenetre
int window;
 
// Gestion du clavier.
void Keyboard(unsigned char key, int x, int y)
{
  // Si ESC
  if (key==27)
  {
    glutDestroyWindow(window); 
    exit(0);
  }
  // Gestion des lumieres
  if ((key=='l') || (key=='L'))
  {
    light = 1-light;
    if (!light) 
    {
      glDisable(GL_LIGHTING);
    } 
    else 
    {
      glEnable(GL_LIGHTING);
    }
  }
  if ((key=='r') || (key=='R'))
  {
    myrotate = 1-myrotate;
  }
  if ((key=='z') || (key=='Z'))
	{
		kavarr = kavarr + 1.0f;
	}
  if ((key=='s') || (key=='S'))
	{
		kavarr = kavarr - 1.0f;
	}
  if ((key=='q') || (key=='Q'))
	{
		kgaudroi = kgaudroi + 1.0f;
	}
  if ((key=='d') || (key=='D'))
	{
		kgaudroi = kgaudroi - 1.0f;
	}
  glutPostRedisplay();
}
 
void Resize(int width, int height)
{
  // Evite de divisser par 0 en cas de changement de taille
  if (height==0)				
  {
    height=1;
  }
  // Fenetrage
  glViewport (0, 0, width, height);
 
  // Definition de la matrice de vue
  glMatrixMode (GL_PROJECTION);
  glLoadIdentity ();  
 
 
  // Camera
 
  gluPerspective(45.0f,(GLfloat)width/(GLfloat)height,0.1f,100.0f);
 
 
  // Rebascule dans le repere du modele
  glMatrixMode(GL_MODELVIEW);
 
}
 
// Permet de definir une matiere a partir d'une couleur
void GlutShade(GLfloat r,GLfloat v,GLfloat b)
{
  // Couleur sans lumieres
  glColor3f(0.8,0.9,0.6);
 
  // Couleur avec lumieres
  GLfloat color[4];
 
  // La couleur diffuse sera egale a 25% de la couleur
  color[0]=0.75f*r;
  color[1]=0.75f*v;
  color[2]=0.75f*b;
  color[3]=1.0;
 
  glMaterialfv(GL_FRONT, GL_DIFFUSE, color);
 
  // La couleur ambiante sera egale a 25% de la couleur
  color[0]=0.25f*r;
  color[1]=0.25f*v;
  color[2]=0.25f*b;
  color[3]=1.0;
 
  glMaterialfv(GL_FRONT, GL_AMBIENT, color); // GL_AMBIENT_AND_DIFFUSE
 
  color[0]=1.0f;
  color[1]=0.0f;
  color[2]=0.0f;
  color[3]=1.0;
 
  glMaterialfv(GL_BACK, GL_AMBIENT_AND_DIFFUSE, color);
}
 
// Affichage
void GlutRendering()
{
  glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
  glMatrixMode (GL_MODELVIEW);
  glLoadIdentity ();
 
 
  //glTranslatef(0.0f,0.0f,kavarr);	
	glTranslatef(0.0f,0.0f,-20.0f);
 
  glRotatef(kgaudroi,0.0f,1.0f,0.0f);
	glRotatef(alpha,1.0f,1.0f,1.0f);
	//glRotatef(kavarr,1.0f,0.0f,0.0f);
 
	a->Affiche();
  //glCallList(a);
 
 
 
  glutSwapBuffers();
}
 
void MouseMove(int x, int y)
{
  Mousex = x;
  Mousey = y;
}
 
void MousePush(int button, int state, int x, int y)
{
}
 
// Rafraichissement
void GlutIdle(void)
{
  if (myrotate)
  {
    alpha+=0.005;
  }
  GlutRendering();
}
 
//!Initialise OpenGL
void InitGlut(int width,int height)
{  
  glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_ALPHA | GLUT_DEPTH);
 
  // Fenetre initiale
  glutInitWindowSize(512, 512);  
  glutInitWindowPosition(0, 0);  
  window=glutCreateWindow("Real Time Rendering");
 
  glutDisplayFunc(GlutRendering);
  //glutFullScreen();
 
  // Rafraichissement
  glutIdleFunc(&GlutIdle);
 
  // Changement de taille
  glutReshapeFunc(Resize);
 
  // Clavier
  glutKeyboardFunc(Keyboard);
  //glutSpecialFunc(&SpecialKeyboard);
 
  // Souris
  glutMouseFunc(MousePush);
  glutMotionFunc(MouseMove);
 
  // Initialise les parametres de rendu
  glClearColor (0.3f, 0.4f, 0.6f, 1.0);
 
  glClearDepth(1.0);
  glDepthFunc(GL_LEQUAL);
  glEnable(GL_DEPTH_TEST);	
  glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
 
  glShadeModel(GL_SMOOTH);
 
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();				// Reset The Projection Matrix
 
  gluPerspective(45.0f,(GLfloat)width/(GLfloat)height,0.1f,100.0f);
 
  // Placement des lumieres dans l'espace du modele
  glMatrixMode(GL_MODELVIEW);
 
  GLfloat light_ambient[] = { 0.5f, 0.5f, 0.5f, 1.0f };
  GLfloat light_diffuse[] = { 1.0f, 1.0f, 1.0f, 1.0f };
  GLfloat light_position[] = { 0.0,0.0, 10.0,0.0 };
 
  glLightfv (GL_LIGHT1, GL_AMBIENT, light_ambient);
  glLightfv (GL_LIGHT1, GL_DIFFUSE, light_diffuse);
  glLightfv (GL_LIGHT1, GL_POSITION, light_position);
  glEnable(GL_LIGHT1); 
 
  glEnable(GL_LIGHTING);
 
	glewInit();
 
 
  // Elimination des facettes arriere
  //glCullFace(GL_BACK);
  //glEnable(GL_CULL_FACE);
}
 
 
int main(int argc,char **argv)
{
  glutInit(&argc, argv);
 
  InitGlut(512,512);
	//c=new Cube(Vector(-4.2,-0.5,-1.0),Vector(4.2,-3.0,2.0));
 
	a=new Cylindre(Vector(0.0,0.0,0.0),2.0,5.0,2.0);
  glutMainLoop();
 
	//delete c;
  return 0;
}

C'est la premiere fois que je post un message ici j'espere avoir suivis les regle et surtout
aider moi avant d avoir la boule a zero

[LittleWhite]

Bonjour,

Je ne sais pas si tu as saisi, mais ton problême est un problême de mémoire. Soit quand tu fais n = 100 , puis n = 150, il y a de forte chances pour que entre les deux valeurs de n , tu dépasse des limites de ton tableau.

Enfin, j'ai vu un truc très spécial:

Code :

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

1
2
 
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(IndiceArray), IndiceArray, GL_STATIC_DRAW);

là ou il y a le sizeof(IndicaArray) OpenGL attend la taille en byte du tableau.
Il y a de forte chance, que le sizeof(IndiceArray) renvoie la taille en byte mais que du pointeur et non du tableau ( mais je n'ai suis pas trop sur à cause de l'allocation statique des tableaux )
De plus, l'allocation statique des tableaux , me semble pas du tout aproprié ...

[PowerCitron]

Merci LittleWhite pour ta réponse. Je pense avoir trouvé le probleme mais il y a toujours quelques subtilités qui m'échappe. J ai supprimé tout *.o et recompilé et la magie sa marche avec un "n" grand. Ce qui est etrange est que si je grandis encore le "n" sans supprimer les *.o sa replante mais si je les supprime sa fonctionne nikel. J'aimerai bien connaitre la cause mais bon sa fonctionne c'est deja pas si mal.
Sinon pour le sizeof(IndiceArray) je suis d accord avec toi mais je me suis tellement acharné que j'ai tout essayé. Apparement sa fonctionne bien meme si sa reste etrange. Sinon le petit changement coute pas cher a faire et au moins je serai sur.
Je choisis des tableaux static car l'objectif de mon projet est la modelisation d'une ville sans voitures ou personnes animées par exemple donc il y aura tres peu de modifications a part le level detail des batiments si ils sont proche ou non.
Donc je vais mettre résolu mais j'espere que quelqu'un puisse m'éclairer sur cette histoire de *.o et de sizeof(IndiceArray).

[LittleWhite]

Pour la suppression des .o je sais pas. À part que cela oblige la recompilation de tout le projet par le compilateur, une fois que tu fais une modification et que tu lance la procédure de compilation. Mais de la façon dont tu le reconte, cela ne semble pas avoir d'importance.

L'histoire du sizeof, j'avais un doute hier, j'ai vérifé aujourd'hui dans un programme bidon, pour les tableaux statiques ( uniquement ) il renvoie bien la taille en byte du tableau. Donc c'est bon.