Crash en glBufferData

Tengo errores aleatorios en glBufferData, y solo sucede en Windows. Mac OS y Linux no tienen problemas. Esa es mi función de carga que carga todo lo que guardé en la memoria a la GPU. vertex es una matriz de vectores flotantes que es:

 std::vector vertex[MAX_VBO]; 

y el código se bloquea aleatoriamente en la primera función glBufferData, lo llamo aleatorio porque a veces puede funcionar, pero cuando mis datos de vértice son enormes, es casi seguro que se bloquee.

 void VertexBuffer::upload() { glGenBuffers(5, vbo); printf("VBO %d - %d - %d\n", vertex[vboPosition].size(), vertex[vboNormal].size(), indices.size()); if (vertex[vboPosition].size() > 0) { glBindBuffer(GL_ARRAY_BUFFER, vbo[vboPosition]); glBufferData(GL_ARRAY_BUFFER, vertex[vboPosition].size() * sizeof(float)*4, &vertex[vboPosition][0], GL_STATIC_DRAW); } if (vertex[vboNormal].size() > 0) { glBindBuffer(GL_ARRAY_BUFFER, vbo[vboNormal]); glBufferData(GL_ARRAY_BUFFER, vertex[vboNormal].size() * sizeof(float)*3, &vertex[vboNormal][0], GL_STATIC_DRAW); } if (vertex[vboColor].size() > 0) { glBindBuffer(GL_ARRAY_BUFFER, vbo[vboColor]); glBufferData(GL_ARRAY_BUFFER, vertex[vboColor].size() * sizeof(float)*4, &vertex[vboColor][0], GL_STATIC_DRAW); } if (vertex[vboUV].size() > 0) { glBindBuffer(GL_ARRAY_BUFFER, vbo[vboUV]); glBufferData(GL_ARRAY_BUFFER, vertex[vboUV].size() * sizeof(float)*2, &vertex[vboUV][0], GL_STATIC_DRAW); } if (vertex[vboTangent].size() > 0) { glBindBuffer(GL_ARRAY_BUFFER, vbo[vboTangent]); glBufferData(GL_ARRAY_BUFFER, vertex[vboTangent].size() * sizeof(float)*3, &vertex[vboTangent][0], GL_STATIC_DRAW); } glBindBuffer(GL_ARRAY_BUFFER, 0); glGenBuffers(1, &vboind); if (indices.size() > 0) { glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vboind); glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(unsigned int), &indices[0], GL_STATIC_DRAW); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); } printf("Success \n"); } 

Más información: He intentado tanto el modo de liberación como el de depuración en el caso de que el comstackdor de microsoft coloque cosas raras entre vectores (no continuos, etc.) pero es lo mismo. También estoy usando el perfil básico de OpenGL 3.3.

Parece que el tamaño que está pasando a glBufferData() es mucho más grande que el tamaño real de los datos. Por ejemplo en este:

 std::vector vertex[MAX_VBO]; ... glBufferData(GL_ARRAY_BUFFER, vertex[vboPosition].size() * sizeof(float)*4, &vertex[vboPosition][0], GL_STATIC_DRAW); 

Dado que vertex[vboPosition] es un vector de flotadores, llamar a .size() en él devuelve el número de flotadores en el vector. Luego multiplica ese valor por sizeof(float) y por 4, que termina multiplicándolo por 16. Pero un float es solo de 4 bytes, por lo que es 4 veces más.

El segundo argumento es la cantidad de datos para cargar en bytes. Así que el cálculo correcto es:

  glBufferData(GL_ARRAY_BUFFER, vertex[vboPosition].size() * sizeof(float), &vertex[vboPosition][0], GL_STATIC_DRAW); 

Lo mismo se aplica a todas las demás llamadas a glBufferData() .