Discussion :

[ShevchenKik]

Bonjour,

j'implémente en ce moment les vertex Arrays pour accélérer un peu mon rendu.

J'ai pour l'instant deux versions:
A) une créant un array à afficher avec glDrawArrays: dans ce tableau, certains vertex sont répétés
B) une où j'utilise glDrawElements: dans ce cas, les vertex ne sont pas répétés dans le tableau, mais dans la liste d'indices qui lui est associée

Dans les deux cas, ca marche, tout s'affiche comme il faut.

En revanche, quand je quitte mon programme, ca plante au moment d'effacer ma liste d'indices (donc seulement dans le cas B), le A) n'ayant pas d'indices).

C'est bizarre, OpenGL garde-t-il un lien vers cette liste? Ca me surprendrait, d'autant plus que les tableaux de vertex, eux, s'effacent sans problème....

[smashy]

ne tenterais tu pas de detruire les listes apres destruction du context OpnGL ?

[ShevchenKik]

Je détruis tout ca dans mes destructeurs, donc à priori après la destruction du contexte OpenGL.

Dans tous les cas il s'agit d'un tableau de GLushort dans mon code c++, ca ne devrait donc rien avoir à faire avec OpenGL (ce n'est pas comme si j'effacais des display lists). Je viens d'essayer de supprimer le tableau avant la destruction du contexte OpenGL mais ca ne change rien.

Comme dit, ca marche sans problème pour le tableau de vertex donc je suis un peu perdu là....

[smashy]

je pensais que tu tentais de detruire une ressource OpenGL (un handle type GL(u)int sur un vertex buffer) apres destruction du context lui meme.

Si tu as un crash au moment du delete sur un buffer memoire CPU c'est autre chose ...


Dans ce cas, si tu as un bout de code minimaliste , ca nous aidera a t aider

[ShevchenKik]

Salut,

oui comme dit à priori c'est plus un probleme de c++ que d'opengl, mais vu que je suis quand même a peu près sûr de faire les choses correctement avec mon code c++ je ne sais plus trop....

Bref, un peu de code:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
class BGLVertexArray
{
private:
	.....
        .....
	// 1D sorted array parameters
	short		m_1DArray_Size;			// Size of the 1D sorted or indexed array 
	short		m_1DArray_nbIndices;	// Number of indices for the 1D indexed array
	short		m_1DArray_Type;			// Type (sorted or indexed) of the 1D array
	BGLVertex*	m_1DArray_Data;			// Sorted 1D Array 		
	GLushort*	m_1DArray_Indices;		// Indices of the indexed 1D array

Mon constructeur, qui ne fait rien à part initialiser les variables:

Code :

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

1
2
3
4
5
6
7
8
BGLVertexArray::BGLVertexArray()
{
	....
        ....
	m_1DArray_Data			= NULL;
	m_1DArray_Indices		= NULL;
        ....
}

La création des deux tableau se fait dans une autre méthode, extraits:

Code :

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

1
2
3
4
5
6
7
8
9
10
 
void BGLVertexArray::Create1DIndexedArray()
{
        ....
	m_1DArray_Indices	= new GLushort[m_1DArray_nbIndices];
	m_1DArray_Data		= new BGLVertex[m_1DArray_Size];
       .....
       //Remplissage des tableaux
       ....
}

Ensuite, avant de créer ma display list, j'appelle:

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
 
void BGLVertexArray::LoadArrays(BOOL useVertexAttribs, GLint attribLocation)
{
	glEnableClientState(GL_VERTEX_ARRAY);
	glVertexPointer(3, GL_DOUBLE, sizeof(BGLVertex), &m_1DArray_Data[0].Pos[0]);
 
	glEnableClientState(GL_NORMAL_ARRAY);	
	glNormalPointer(GL_DOUBLE, sizeof(BGLVertex), &m_1DArray_Data[0].Norm[0]);	
 
	glClientActiveTexture(GL_TEXTURE1); 
	glEnableClientState(GL_TEXTURE_COORD_ARRAY);
	glTexCoordPointer(2, GL_DOUBLE, sizeof(BGLVertex), &m_1DArray_Data[0].TexCoords[0]);	
 
	m_attribLoc = attribLocation;
	if(useVertexAttribs)
	{
		glEnableVertexAttribArray(m_attribLoc);
		glVertexAttribPointer(m_attribLoc, 3, GL_DOUBLE, false, sizeof(BGLVertex), &m_1DArray_Data[0].CNorm[0]);
	}
}

Et pour dessiner:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
void BGLVertexArray::Draw()
{
	switch(m_1DArray_Type)
	{
		case SORTED_ARRAY:
			glDrawArrays(GL_TRIANGLE_STRIP, 0, m_1DArray_Size);
			break;
 
		case INDEXED_ARRAY:
			glDrawElements(GL_TRIANGLE_STRIP, m_1DArray_nbIndices, GL_UNSIGNED_SHORT, m_1DArray_Indices);
			break;
	}
}

Dans le cas qui pose problème, j'utilise INDEXED_ARRAY

Jusque là tout va bien, dans les deux cas ca s'affiche correctement, donc les tableaux sont bien créés et leur contenu est valide

par contre quand le destructeur est appelé, ca plante à la destruction de la liste d'indices (mais, je le rappelle, pas de problème pour détruire la liste des vertex)

Destructeur:

Code :

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

1
2
3
4
5
BGLVertexArray::~BGLVertexArray()
{
	if(m_1DArray_Data)	  delete[] m_1DArray_Data;
        if(m_1DArray_Indices) delete[] m_1DArray_Indices; // Et là ca plante....
}

Voilà, ca fait pas mal de code d'un coup, désolé, mais ca ne devrait pas être trop compliqué à comprendre... Bref, si quelqu'un a une idée elle est plus que la bienvenue, merci d'avance!

[shenron666]

les raisons qui me viennent à l'esprit sont :
- tu libères un pointeur invalide
- tu libères un pointeur alors qu'une partie de ton code utilise les données qu'il stocke

assures toi qu'OpenGL n'est pas en train d'utiliser ton tableau au moment où tu le libères
il faut savoir qu'un appel à glDrawElements est asynchrone
tu balances le pointeur au driver qui te rend la main aussitot et les données pointées sont transférées en tache de fond, ce qui peux faire planter si tu libères le pointeur alors qu'il est en train de transférer