Split VBO to smaller buffers?

Question

OpenGL newbie here. I am learning OpenGL and I'm trying to figure out workaround to VBO. Let me explain. If You load .obj file you have everything set up: vertex coordinates, normals, UV's and their indices. Why is this not enough to draw triangles on the screen? The reason why I am asking this is that VBO creation is the biggest bottleneck in the pipeline. For instance, I can create procedural sphere data with million vertices, its normals, UV's on CPU and split each of these in their own buffers/arrays. I can do this using multithreading and SIMD instructions. So basically now, when everything is setup I have to interleave this data for the GPU and this would take much more time than actually creating the organized data in the first place. I can't even use multithreading because the data in VBO is being repeated. For instance, cube with 8 vertex coords has 24 normals so I have to repeat each of these 8 vertices 3 times in the VBO. What is the exact reason why do we have to use VBO? Wouldn't splitting it in smaller buffers for coords, normals and uvs actually reduce memory usage and improve performance?

Answer 1

Currently you are interleaving vertex data in CPU but this is not a requirement. You can provide OpenGL with any data format you like have by using glVertexAttribPointer.

Example 1: using 3 VBOs

float positions[] = {...};
float normals[] = {...};
float texCoords[] = {...};
unsigned indices[] = {...};

GLuint vbo[3];
glGenBuffers(3, vbo);
// positions
glBindBuffer(GL_ARRAY_BUFFER, vbo[0])
glBufferData(GL_ARRAY_BUFFER, sizeof(positions), positions, GL_STREAM_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
// normals
glBindBuffer(GL_ARRAY_BUFFER, vbo[1])
glBufferData(GL_ARRAY_BUFFER, sizeof(normals), normals, GL_STREAM_DRAW);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, nullptr);
// tex coords
glBindBuffer(GL_ARRAY_BUFFER, vbo[2])
glBufferData(GL_ARRAY_BUFFER, sizeof(texCoords), texCoords, GL_STREAM_DRAW);
glEnableVertexAttribArray(2);
glVertexAttribPointer(3, 2, GL_FLOAT, GL_FALSE, 0, nullptr);
// indices
GLuint ebo;
glGenBuffers(1, &ebo);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STREAM_DRAW);

// draw
glDrawElements(GL_TRIANGLES, numInds, GL_UNSIGNED_BYTE, inds);

Example 2: using a single VBO

float positions[] = {...};
float normals[] = {...};
float texCoords[] = {...};
unsigned indices[] = {...};

GLuint vbo;
glGenBuffers(1, &vbo);
// positions
glBindBuffer(GL_ARRAY_BUFFER, vbo[0])
const int totalSize = sizeof(positions) + sizeof(normals) + sizeof(texCoords);
glBufferData(GL_ARRAY_BUFFER, totalSize, nullptr, GL_STREAM_DRAW); // notice we are not passing any data yet(nullptr). We are just allocating the space for now
int offset = 0;
// positions
glBufferSubData(GL_ARRAY_BUFFER, offset, sizeof(positions), positions); // here we upload the data
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (void*)offset);
offset += sizeof(positions);
// normals
glBufferSubData(GL_ARRAY_BUFFER, offset, sizeof(normals), normals);
glEnableVertexAttribArray(1);
glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, 0, (void*)offset);
offset += sizeof(normals);
// texCoords
glBufferSubData(GL_ARRAY_BUFFER, offset, sizeof(texCoords), texCoords);
glEnableVertexAttribArray(2);
glVertexAttribPointer(3, 2, GL_FLOAT, GL_FALSE, 0, (void*)offset);

// the code below didn't change
// indices
GLuint ebo;
glGenBuffers(1, &ebo);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STREAM_DRAW);

// draw
glDrawElements(GL_TRIANGLES, numInds, GL_UNSIGNED_BYTE, inds);

I haven't tested any of the code so there might be typos. Use VAOs if you can. Remember to free resources when you are done with them!

---

About repeating positions for the case of a cube:

In is true that if you want to draw a cube, you are going to repeat the positions 3 times (one for each adjacent face), because the normal needs to be different.

Fist of all, I have to make clear that, in many applications, having to repeat the position is not going to happen. That is because flat shading, is not desired.

Image from: http://www.faculty.jacobs-university.de/llinsen/teaching/320322_Fall2009/lecture13.pdf

Most commonly, we want stuff to look smooth. Simple geometric shapes as the cube are an exception so people don't bother to do anything complicated and just repeat position data (simple geometric shapes are usually cheap anyways).

Another way of thinking of it: VBO, as the name implies, is data that is assigned to a vertex. When you consider the case of a cube, the normal that you want to specify is for a face, not for a vertex. As far as I know, mesh data formats, such as .obj, don't allow per face data either.

With all that said, if you still consider that for you application saving those repeated data is worth the effort, there might a way to do it in OpenGL using geometry shaders. Geometry shaders will allow you to emit primitives as you want.

This is an example of a geometry shader. It doesn't take any normals, the normal is computed in the shader itself once per primitive.

#version 330 core

layout (triangles) in; // in glDrawElements we specify GL_TRIANGLES
layout (triangles, max_vertices = 3) out; // and we still want to output triangles

// these are the inputs we get from the vertex shader (only the texCoord, apart from the position)
in VS_OUT {
    //vec3 normal; // we don't have an input for the normal, we are going to compute it from the vertex positions
    vec2 texCoord;
} vs_out[];

// these outputs will be received in the fragment shader 
out GS_OUT {
    flat vec2 normal; // we use the flat modifier because we don't need interlotation :) https://www.khronos.org/opengl/wiki/Type_Qualifier_(GLSL)#Interpolation_qualifiers
    vec3 texCoord;
} gs_out;

void main()
{
    vec3 p0 = gl_in[0].gl_Position.xyz;
    vec3 p1 = gl_in[1].gl_Position.xyz;
    vec3 p2 = gl_in[2].gl_Position.xyz;
    // compute the normal with the cross product
    gs_out.normal = normalize(cross(p1-p0, p2-p0));

    gl_Position = gl_in[0].gl_Position; 
    gs_out.texCoord = vs_out[0].texCoord;
    EmitVertex();

    gl_Position = gl_in[1].gl_Position;
    gs_out.texCoord = vs_out[1].texCoord;
    EmitVertex();

    gl_Position = gl_in[2].gl_Position;
    gs_out.texCoord = vs_out[2].texCoord;
    EmitVertex();
    
    EndPrimitive();
}  

I think you could go even further and not compute the normal for each triangle, only for every quad. But that is tricky!