OpenGL - SegFault on glBufferData() while loading vertex data - c++

Question

Problem: Segmentation fault on glBufferData.
About libs & input data:
3ds file contains a few models.
GLEW - 1.11.0
GLFW - 3.0.4
GLM - 0.9.5.4
ASSIMP - 3.1.1
OS - Windows 7 x64 lastest PS
GPU: nvidia 770
Output:
Wersja OpenGL: 4.4.0
Kompilacja shadera...
Compiling shader : vert.vs
- Success
Compiling shader : frag.fs
- Success
Ustawianie Model - Widok - Projekcja...
Wczytywanie wczeťniej wygenerowanych obiektˇw...
Ladowanie Mesha nr.0...
Rozmiary - 2 | 108 | 108
a
b
c
Here is code:
Mesh_Loader.cpp
GLfloat **vertexData, **normalData, **colorsData_buffer;
GLushort** indexData;
/** Bufory */
GLuint* vertexBuffer, *colorBuffer, *indexBuffer;
int mesh_size = 0;
unsigned int* count_of_vertex; //Licznik ile vertex-ów na danym meshie jest
int* count_of_index; //Licznik indeksów
unsigned int suma_vertexow = 0; //Suma wszystkich vertexow... normalnie się powinno to inaczej obejść. Ale kij.
const struct aiFace* tmp_face;
int tmp_index = 0;
//[...]
bool mesh_load(const std::string& Filename)
{
Assimp::Importer Importer;
const aiScene* pScene = Importer.ReadFile(Filename.c_str(), aiProcess_Triangulate | aiProcess_GenSmoothNormals | aiProcess_FlipUVs);
/** Sprawdzenie czy wczytał scene */
if (pScene) {
init_from_scene(pScene);
return true;
}
else
{
std::cout << "Wystąpił błąd podczas wczytywania: " << Importer.GetErrorString() << std::endl;
return false;
}
}
void pre_reserve_memory(const aiMesh* paiMesh, int cur_poz)
{
count_of_index[cur_poz] = 0;
for (unsigned int i = 0; i < paiMesh->mNumFaces; i++) {
tmp_face = &paiMesh->mFaces[i];
count_of_index[cur_poz] += tmp_face->mNumIndices;
}
indexData[cur_poz] = new GLushort[count_of_index[cur_poz]];
}
void init_from_scene(const aiScene* pScene)
{
mesh_size = pScene->mNumMeshes;
//Pre Rezerwacja miejsca
vertexData = new GLfloat*[mesh_size];
colorsData_buffer = new GLfloat*[mesh_size];
normalData = new GLfloat*[mesh_size];
indexData = new GLushort*[mesh_size];
//Buffory
vertexBuffer = new GLuint[mesh_size];
colorBuffer = new GLuint[mesh_size];
indexBuffer = new GLuint[mesh_size];
count_of_vertex = new unsigned int[mesh_size];
count_of_index = new int[mesh_size];
for (unsigned int i = 0; i < pScene->mNumMeshes; i++)
{
pre_reserve_memory(pScene->mMeshes[i], i);
// [...]
przepare_mesh(pScene->mMeshes[i], vertexData[i], colorsData_buffer[i], normalData[i], indexData[i], &count_of_vertex[i]);
}
}
void przepare_mesh(const aiMesh* paiMesh, GLfloat* vertexData, GLfloat* colorsData_buffer, GLfloat* normalData, GLushort* indexData, unsigned int* count_of_vertex)
{
int counter;
vertexData = (GLfloat *)&paiMesh->mVertices;
colorsData_buffer = (GLfloat *)&paiMesh->mColors;
normalData = (GLfloat *)&paiMesh->mNormals;
*count_of_vertex = paiMesh->mNumVertices;
for (unsigned int i = 0; i < paiMesh->mNumFaces; i++) {
tmp_face = &paiMesh->mFaces[i];
for (unsigned int j = 0; j < tmp_face->mNumIndices; j++)
{
counter = i + j;
indexData[counter] = tmp_face->mIndices[j];
}
}
}
/** TODO: RE-LIGHTING, MOUSE */
void render_scene()
{
glLinkProgram(program); // jak skompilowalem kod to moge go polaczyc z bibliotekami - linkowanie
glUseProgram(program); // od tego momentu wszystko co zrobie bedzie uzywac tego programu (tej kombinacji shaderow)
glClearColor(0.0f, 0.0f, 0.4f, 0.0f); // ustala kolor wyczyszczonego okna
glEnable(GL_CULL_FACE); // wewnetrzne flagi opengl
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
/** Model - View - Projection */
glm::mat4 Model = glm::mat4(1.0f); // tworzenie macierzy obiektu
glm::mat4 View = glm::lookAt(glm::vec3(0.0f, 2.0f, -5.0f), glm::vec3(), glm::vec3(0.0f, 1.0f, 0.0f)); // widoku
glm::mat4 Projection = glm::perspective(60.0f, 16.0f / 9.0f, 0.1f, 1000.0f); // projekcji
glm::mat4 MVP; // zmienna na pozniej
GLuint MVPUniformLoc = glGetUniformLocation(program, "MVP"); // daje wskaznik gdzie MVP znajduje sie w pamieci
/** Addresy Pamięci */
GLuint positionAttribLoc = glGetAttribLocation(program, "position"); // wytlumaczenie cpu jak sie dostac do adresu pamieci gpu
GLuint colorAttribLoc = glGetAttribLocation(program, "color");
/** tworzenie tablicy przechowujacej vertexy */
GLuint vertexArrayObject;
glGenVertexArrays(1, &vertexArrayObject);
glBindVertexArray(vertexArrayObject);
for (int i = 0; i < mesh_size; i++)
{
suma_vertexow += count_of_vertex[i];
glGenBuffers(1, &vertexBuffer[i]);
glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer[i]);
glBufferData(GL_ARRAY_BUFFER, (sizeof(GLfloat)* count_of_vertex[i]), vertexData[i], GL_STATIC_DRAW); //Problem Area
if (colorsData_buffer[i] != NULL)
{
glGenBuffers(1, &colorBuffer[i]);
glBindBuffer(GL_ARRAY_BUFFER, colorBuffer[i]);
glBufferData(GL_ARRAY_BUFFER, (sizeof(GLfloat) * count_of_vertex[i]), colorsData_buffer[i], GL_DYNAMIC_DRAW);
}
glGenBuffers(1, &indexBuffer[i]);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer[i]);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, (sizeof(GLushort)* count_of_index[i]), indexData[i], GL_DYNAMIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, NULL);
glEnableVertexAttribArray(positionAttribLoc); // atrybuty wskazinikow (bufory)
glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer[i]);
glVertexAttribPointer(
positionAttribLoc, // attribute. No particular reason for 0, but must match the layout in the shader.
3, // size
GL_FLOAT, // type
NORMALIZED, // normalized?
0, // stride - wierzcholki oznaczajace pozycje sa w tym buforze jeden za drugim (odstep miedzy kolejnymi wierzcholkami)
(GLvoid*)0 // array buffer offset - w ktorym miejscu bufora zaczyna sie inf o wierzcholkach
);
glBindBuffer(GL_ARRAY_BUFFER, NULL);
if (colorsData_buffer[i] != NULL)
{
glEnableVertexAttribArray(colorAttribLoc);
glBindBuffer(GL_ARRAY_BUFFER, colorBuffer[i]);
glVertexAttribPointer(
colorAttribLoc, // attribute. No particular reason for 0, but must match the layout in the shader.
3, // size
GL_FLOAT, // type
NORMALIZED, // normalized?
0, // stride
(GLvoid*)0 // array buffer offset
);
}
glBindBuffer(GL_ARRAY_BUFFER, NULL);
}
//[...]
}
Mesh_Loader -> load via assimp.importer data from 3DS file
and extract data about index, Colors, Vertex, Normals for each mesh
function render -> load data about: data about index, Colors, Vertex, Normals
but It causes some problem when it loading data into buffer "glBufferData"
SegFault
Additioanl_func.cpp
Extra functions for load shader & mouse callback
Where is there problem?

Answer 1

I don't think this is an OpenGL problem. The code is simply using uninitialized pointers. This would likely cause a crash if they are used for anything. It just happens to be the case that they are passed to glBufferData().
Walking through the usage of vertexData, it's declared as a pointer to pointer to GLfloat:
GLfloat **vertexData;
Then it gets allocated:
vertexData = new GLfloat*[mesh_size];
vertexData now points to mesh_size pointers to GLfloat. Note that these pointers are uninitialized.
These pointers are then passed as arguments to a function:
przepare_mesh(..., vertexData[i], ...);
Inside the function, a value is then assigned to the function argument (I'm renaming the argument from the original code to avoid name confusion in my explanation):
void przepare_mesh(..., GLfloat* vertices, ...)
{
...
vertices = (GLfloat *)&paiMesh->mVertices;
Since the pointer was passed to the function by value, this assignment only changes the local value of the argument, and does not set a value for the pointer that was originally passed in. So vertexData[i] will still be uninitialized when this function returns.
Later, vertexData[i] is used as an argument for glBufferData(), and causes a crash because it's uninitialized.
The easiest way to fix this would be to change the declaration of the function argument to a reference:
void przepare_mesh(..., GLfloat*& vertices, ...)
Once the argument is a reference, assigning a value to it inside the function will change the value of the pointer passed in by the caller.
There are other cases of the same problem in the code, I just used the first one to illustrate the problem.