Crash VBO en release

Bonjour,

Je poste ce message car je suis en train de m'arracher les cheveux sur un problème de VBO.
J'essaie de faire une sorte de mini moteur 3D en OpenGL.
Mon programme charge un modèle 3D et l'affiche en utilisant les VBO.
Le problème est que le programme fonctionne très bien en debug mais crash en release (si je le lance manuellement).
En commentant certaines parties du code je me suis rendu compte que le crash provient des appels au VBO.
J'utilise 2 classes l'une contient les indices(ogleIndexBuffer) de mon mesh et l'autre l'ensemble des vertices, normales et coordonnées de texture (ogleVNTBuffer).

Voici une partie du code de ogleVNTBuffer

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
 
class ogleOpenGLBufferParameter
{
protected:
	/// \protected int m_iOpenGLType
	/// \brief openGL type
	int								m_iOpenGLType;
 
	/// \protected  int m_offset
	/// \brief Data offset in buffer
	unsigned short					m_offset;
 
	/// \protected int m_stride
	/// \brief Specifies the byte offset between consecutive values
	unsigned short					m_stride;
 
	/// \protected GLuint m_attribIndex
	/// \brief place in shader
	GLuint							m_attribIndex;
 
	/// \protected GLenum   m_useType
	/// \brief the using type for OpenGL
	GLenum							m_useType;
 
	/// \protected ogleOpenGLBufferParameter*               m_sibling
	/// \brief next parameter
	/// \brief Not deleted it's use as link not a pointer
	ogleOpenGLBufferParameter*		m_sibling;
 
        ///
}

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
 
        /// \protected ogleBuffer<GLuint>               m_buffers
	/// \brief buffers id
	ogleBuffer<GLuint>		m_buffers;
 
	/// \protected ogleBuffer<GLuint>               m_Attributes
	/// \brief shader attributes
	ogleBuffer<GLuint>		m_Attributes;
 
	/// \protected ogleBuffer<int>          m_buffersOffsets
	/// \brief buffers offset
	ogleBuffer<int>			m_buffersOffsets;
 
	/// \protected ogleBuffer<int>          m_buffersSizes
	/// \brief buffers sizes
	ogleBuffer<int>			m_buffersSizes;
 
	/// \protected GLuint m_vertexArray
	/// \brief Vertex array object
	GLuint	m_vertexArray;	
 
    /// \protected float* m_TBuffer
	/// \brief data buffer
	float*				m_TBuffer;
 
	/// \protected unsigned int m_iSize
	/// \brief data buffer size
	unsigned int	m_iSize;

La fonction release libère la mémoire de m_TBuffer et met le pointeur à NULL, le paramètre true in dique que m_iSize n'est pas remis à zéro

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
 
bool ogleVNTBuffer::loadVertexToGraphical(ogleOpenGLBufferParameter *pParameters, const bool &bInVertexArray)
{
	bool bRet = false;
	m_Attributes[Enum_VBUFFER_INDEX] = pParameters->attributeIndex();
	if (bInVertexArray)
	{
		if (m_vertexArray != 0)
		{
			if (m_buffersSizes[Enum_VBUFFER_INDEX] != 0)
			{
				glEnableVertexAttribArray(m_Attributes[Enum_VBUFFER_INDEX]);
				glBindBuffer(GL_ARRAY_BUFFER, m_buffers[Enum_VBUFFER_INDEX]); // Bind our Vertex Buffer Object
				glBufferData(GL_ARRAY_BUFFER, m_buffersSizes[Enum_VBUFFER_INDEX] * sizeof(GLfloat), m_TBuffer, pParameters->useType());
				glVertexAttribPointer(m_Attributes[Enum_VBUFFER_INDEX], 3, GL_FLOAT, GL_FALSE, 0, 0); // Set up our vertex attributes pointer define order in shader
 
				glBindBuffer(GL_ARRAY_BUFFER, 0);
				glDisableVertexAttribArray(m_Attributes[Enum_VBUFFER_INDEX]);
 
				//ogleOpenGLMultiUseBuffer::releaseBuffer();
				bRet = true;
			}
			else
			{
				// can't add vertex buffer to graphical memory
				// release all
				releaseFromGraphical();
				glBindVertexArray(0);
			}
		}
	}
	else
	{
		// TODO
	}
 
	return bRet;
}
 
bool ogleVNTBuffer::loadNormalToGraphical(ogleOpenGLBufferParameter *pParameters, const bool &bInVertexArray)
{
	bool bRet = false;
	m_Attributes[Enum_NBUFFER_INDEX] = pParameters->attributeIndex();
 
	if (bInVertexArray)
	{
		if (m_buffersSizes[Enum_NBUFFER_INDEX] != 0)
		{
			glEnableVertexAttribArray(m_Attributes[Enum_NBUFFER_INDEX]);
			glBindBuffer(GL_ARRAY_BUFFER, m_buffers[Enum_NBUFFER_INDEX]); // Bind our Vertex Buffer Object
			glBufferData(GL_ARRAY_BUFFER, m_buffersSizes[Enum_NBUFFER_INDEX] * sizeof(GLfloat), m_TBuffer + m_buffersOffsets[Enum_NBUFFER_INDEX - 1], pParameters->useType());
			glVertexAttribPointer((GLuint)m_Attributes[Enum_NBUFFER_INDEX], 3, GL_FLOAT, GL_FALSE, 0, 0); // Set up our vertex attributes pointer
			glBindBuffer(GL_ARRAY_BUFFER, 0);
			glDisableVertexAttribArray(m_Attributes[Enum_NBUFFER_INDEX]);
			bRet = true;
		}
		else
		{
			// can't add vertex buffer to graphical memory
			// release all
			releaseFromGraphical();
		}
	}
	else
	{
		// TODO
	}
	return bRet;
}
 
bool ogleVNTBuffer::loadToGraphical(ogleOpenGLBufferParameter *pParameters)
{
	bool bRet = false;
	if (pParameters)
	{
		ogleOpenGLBufferParameter* pNormalParam = pParameters->next();
		if (pNormalParam)
		{
			ogleOpenGLBufferParameter* pTextCoordParam = pNormalParam->next();
			if (pTextCoordParam)
			{
				m_buffersOffsets[Enum_NBUFFER_INDEX - 1] = m_buffersSizes[Enum_VBUFFER_INDEX];
				m_buffersOffsets[Enum_TBUFFER_INDEX - 1] = m_buffersOffsets[Enum_NBUFFER_INDEX - 1] + m_buffersSizes[Enum_NBUFFER_INDEX];
				glGenBuffers(Enum_VNTBUFFER_COUNT, (GLuint*)m_buffers.get());
 
				glGenVertexArrays(1, &m_vertexArray); // Create our index Array Object
				glBindVertexArray(m_vertexArray); // Bind our Vertex Array Object so we can use it
 
				bRet = loadVertexToGraphical(pParameters, true);
				bRet &= loadNormalToGraphical(pNormalParam, true);
				bRet &= loadTextCoordToGraphical(pTextCoordParam, true);
 
				glBindVertexArray(0);
 
				if (bRet)
				{
					release(true);
				}
			}
		}
	}
	return bRet;
}
void ogleVNTBuffer::bindVertexArray()const
{
	glEnableVertexAttribArray(m_Attributes[Enum_VBUFFER_INDEX]);
	if (m_buffers[Enum_VBUFFER_INDEX] != 0)
	{
		glBindBuffer(GL_ARRAY_BUFFER, m_buffers[Enum_VBUFFER_INDEX]);
	}
	else
	{
		glVertexPointer(3, GL_FLOAT, 0, m_TBuffer);
		glVertexAttribPointer(m_Attributes[Enum_VBUFFER_INDEX], 3, GL_FLOAT, GL_FALSE, 0, m_TBuffer); // Set up our vertex attributes pointer define order in shader		
	}
}
 
void ogleVNTBuffer::bindNormalArray()const
{
	glEnableVertexAttribArray(m_Attributes[Enum_NBUFFER_INDEX]);
	if (m_buffers[Enum_NBUFFER_INDEX] != 0)
	{
		glBindBuffer(GL_ARRAY_BUFFER, m_buffers[Enum_NBUFFER_INDEX]);
	}
	else
	{
		glNormalPointer(GL_FLOAT, 0, m_TBuffer + m_buffersOffsets[Enum_NBUFFER_INDEX - 1]);
		glVertexAttribPointer(m_Attributes[Enum_NBUFFER_INDEX], 3, GL_FLOAT, GL_FALSE, 0, m_TBuffer + m_buffersOffsets[Enum_NBUFFER_INDEX - 1]); // Set up our vertex attributes pointer define order in shader
	}
}
 
void ogleVNTBuffer::bindTextCoorArray()const
{
	glEnableVertexAttribArray(m_Attributes[Enum_TBUFFER_INDEX]);
	if (m_buffers[Enum_TBUFFER_INDEX] != 0)
	{
		glBindBuffer(GL_ARRAY_BUFFER, m_buffers[Enum_TBUFFER_INDEX]);
	}
	else
	{
		glTexCoordPointer(2, GL_FLOAT, 0, m_TBuffer + m_buffersOffsets[Enum_TBUFFER_INDEX - 1]);
		glVertexAttribPointer(m_Attributes[Enum_TBUFFER_INDEX], 2, GL_FLOAT, GL_FALSE, 0, m_TBuffer + m_buffersOffsets[Enum_TBUFFER_INDEX - 1]); // Set up our vertex attributes pointer define order in shader
	}
}
void ogleVNTBuffer::bind()const
{
	if (m_vertexArray != 0)
	{
		glBindVertexArray(m_vertexArray);
		bindVertexArray();
		bindNormalArray();
	}
}

Le code des indices est similaire, ici m_TBuffer est un tableau de unsigned int.

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
 
bool ogleIndexBuffer::loadToGraphical(ogleOpenGLBufferParameter *pParameters)
{
	bool bRet = false;
	pParameters = pParameters->getFirst(Enum_OpenGL_iBuffer);
	if (pParameters)
	{
		glGenBuffers(1, &m_openglBuffer);
		if (m_openglBuffer != 0)
		{
			glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_openglBuffer); // Bind our Vertex Buffer Object
			glBufferData(GL_ELEMENT_ARRAY_BUFFER, size() * sizeof(unsigned int), m_TBuffer, pParameters->useType());
			glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
			release(true);
			bRet = true;
		}
		else
		{
			// can't add vertex buffer to graphical memory
			// release all
			releaseFromGraphical();
		}
	}
	return bRet;
}
 
void ogleIndexBuffer::bind()const
{
	if (m_openglBuffer != 0)
	{
		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_openglBuffer);
	}
}
 
void ogleIndexBuffer::draw()const
{
	if (m_openglBuffer != 0)
	{
		glDrawElements(GL_TRIANGLES, size(), GL_UNSIGNED_INT, (void*)NULL);
	}
	else
	{
		glDrawElements(GL_TRIANGLES, size(), GL_UNSIGNED_INT, m_TBuffer);
	}
}

J'espère avoir donner assez d'élément afin que vous puissiez m'aider.
Merci d'avance.
Pardon pour les fautes d'orthographe.