IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Développement 2D, 3D et Jeux Discussion :

Crash VBO en release


Sujet :

Développement 2D, 3D et Jeux

  1. #1
    Membre à l'essai
    Profil pro
    Inscrit en
    Novembre 2009
    Messages
    23
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Novembre 2009
    Messages : 23
    Points : 17
    Points
    17
    Par défaut 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 : 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
     
    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 : 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
     
            /// \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 : 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
     
    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 : 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
     
    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.

  2. #2
    Membre du Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Mars 2014
    Messages
    183
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 23
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Mars 2014
    Messages : 183
    Points : 60
    Points
    60
    Par défaut
    vérifie bien que toutes tes variables soient initialisées correctement. une variable non initialisé a la valeur 0 en debug et indéterminée en release

  3. #3
    Membre à l'essai
    Profil pro
    Inscrit en
    Novembre 2009
    Messages
    23
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Novembre 2009
    Messages : 23
    Points : 17
    Points
    17
    Par défaut
    Mes variables sont correctement initialisées.
    C'est l'appel à glDrawElements qui plante, le plus bizarre c'est que si je remplace
    glDrawElements(GL_TRIANGLES, size(), GL_UNSIGNED_INT, (void*)NULL);
    par
    glDrawElements(GL_TRIANGLES, size(), GL_INT, (void*)NULL);
    Je n'ai pas de crash mais je n'ai rien d'affiché.
    Si je lance l'exe en release via visual je n'ai pas de crash.
    J'ai voulu debugger avec gDebugger et là encore je n'ai pas de crash.

  4. #4
    Membre à l'essai
    Profil pro
    Inscrit en
    Novembre 2009
    Messages
    23
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Novembre 2009
    Messages : 23
    Points : 17
    Points
    17
    Par défaut
    J'ai trouvé la solution.
    Il y avait une variable de redéfinie et non initialisée (bizarre que je n'ai pas vu de warning)

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Réponses: 5
    Dernier message: 24/04/2015, 20h48
  2. Réponses: 6
    Dernier message: 25/11/2009, 16h18
  3. Deque front() crash release
    Par yamashi dans le forum C++
    Réponses: 7
    Dernier message: 25/08/2009, 22h41
  4. [VS2003] passage debug => release = crash
    Par Monstros Velu dans le forum Général Dotnet
    Réponses: 3
    Dernier message: 17/07/2009, 17h18
  5. Crash lors de l'utilisation des VBO
    Par Julien Bodin dans le forum OpenGL
    Réponses: 0
    Dernier message: 03/03/2009, 22h54

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo