0

For a simulation we've created a OpenGL1.1 view with a grid of 32 x 48 rectangles.

We're drawing this grid every time the CADisplayLink calls our draw function, and the vertex positions never change. The only thing that changes from frame to frame is the color of a vertex.

This is a simplified example of how we do it:

- (void)drawFrame {
    // draw grid
    for (int i = 0; i < numRectangles; i++) {
        // ... calculate CGPoint values for vertices ...

        GLshort vertices[ ] = {
            bottomLeft.x, bottomLeft.y,
            bottomRight.x, bottomRight.y,
            topLeft.x, topLeft.y,
            topRight.x, topRight.y
        };

        glVertexPointer(2, GL_SHORT, 0, vertices);           
        glColor4f(r, g, b, 1);

        glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
    }
}

The OpenGL instrument recommended using Vertex Buffer Objects (VBO) for better performance.

Is there an example of how to set up a very basic, simple usage of Vertex Buffer Objects in a case where the vertices don't change from frame to frame?

Apple is providing an example over here, under the section Use Vertex Buffer Objects to Manage Copying Vertex Data, but it's incomplete.

GLuint    vertexBuffer;
GLuint    indexBuffer;

void CreateVertexBuffers()
{

    glGenBuffers(1, &vertexBuffer);
    glBindBuffer(GL_ARRAY_BUFFER, vertexBuffer);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

    glGenBuffers(1, &indexBuffer);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);

}

It doesn't show how to really create the data. The previous listing (which is supposed to be a "bad example") contains these two lines:

const vertexStruct vertices[] = {...};
const GLubyte indices[] = {...};

So these two arrays or structs have to be passed into:

    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

and

    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);

?

Is this the "Interleaved (array of structs)" format preferred by iOS, according to Apple under the Use Interleaved Vertex Data section?

Improve this question

1 Answer 1

Reset to default
4

You're not supposed to draw single primitives using glDrawArrays, but large batches. So far you're using only regular vertex arrays, not vertex buffer objects.

The idea is, to put the geometry off all rectangles into one single VBO (a VBO is essentially a vertex array stored "in" OpenGL, rather your process). Changing single vertices is possible by using glBufferSubData.

Vertex color can be put into a vertex array, and hence into a VBO as well.

Update

Say you have some hexagon:

GLfloat vertices[2][] = {
    {0, 0},         // 0
    {1, 0},         // 1
    {0.5, 0.866},   // 2
    {-0.5, 0.866},  // 3
    {-1, 0},        // 4
    {0.5, -0.866},  // 5
    {-0.5, -0.866}, // 6
};

and you want to draw only part of the triangles, say the triangles consisting of vertices [0,1,2], [0,3,4] and [0,5,6], then you'd create the following index array

GLushort indices[] = {
    0, 1, 2,
    0, 3, 4,
    0, 5, 6
};

And use that as the indices for glDrawElements.

Update 2

One thing that many computer graphics and OpenGL newbies get wrong is, that a vertex is not merely a position, but a combination of vertex attributes. Which attributes make a vertex is a design choice made by the programmer. But the commonly used vertex attributes are

  • position
  • normal
  • texture coordinates
  • vertex color

Until OpenGL-3 core the position attribute was mandatory. Since OpenGL-3 core, which made shaders mandatory, vertex attributes are just arbitrary input data into shaders, and as long as a vertex shader manages to deliver the *gl_Position* output, OpenGL is happy.

The important thing is, that two vertices are identical only then, if all the attributes are the same. If they differ in just one attribute, they're not the same vertex. Now let's take our previous example of the hexagon. We're now making the triangles red, green and blue and were going to add two triangles, to extend the red and green ones into kind of diamond shapes:

// x, y, red, green, blue
GLfloat vertices[5][] = {
    // red
    {0, 0, 1, 0, 0},         // 0
    {1, 0, 1, 0, 0},         // 1
    {0.5, 0.866, 1, 0, 0},   // 2
    {1, 1, 1, 0, 0},         // 3

    // green
    {0, 0, 0, 1, 0},         // 4
    {-0.5, 0.866, 0, 1, 0},  // 5
    {-1, 0, 0, 1, 0},        // 6
    {-1, 1, 0, 1, 0},        // 7

    // blue
    {0, 0, 0, 0, 1},         // 8
    {0.5, -0.866, 0, 0, 1},  // 9
    {-0.5, -0.866, 0, 0, 1}, // 10
};

The triangles we now want to draw are

GLushort indices[] = {
    // the two red triangles
    0, 1, 2,
    3, 2, 1,

    // the two green triangles
    4, 5, 6,
    5, 7, 6,

    // the blue triangle
    8, 9, 10
};

Now we need to tell OpenGL about the structure of our vertex array. This is where the stride parameter of the gl…Pointer functions enters the picture. If nonzero, the stride tells OpenGL the distance (in bytes) between the start of each vertex in the array. By passing the data pointer with the right offset this makes OpenGL access the right things. In our case a vertex consists of

  • 2 position elements of GLfloat with offset 0
  • 3 color elements of GLfloat with offset 2*sizeof(GLfloat)

and each vertex is sizeof(GLfloat)*5 bytes apart.

We'll let the C compiler do the offset calculations for us, by simply dereferencing the right array elements and taking the address of it:

glVertexPointer(2, GL_FLOAT, sizeof(GLfloat)*5, &vertices[0][0]);
glColorPointer(3, GL_FLOAT, sizeof(GLfloat)*5, &vertices[0][2]);

The rest is just glDrawElements(GL_TRIANGLES, 5, GL_UNSIGNED_SHORT, indices).

Note that we're not using VBOs at this point, but client side vertex arrays only. VBOs build upon vertex arrays. So I strongly suggest you first get a strong grip of vertex arrays, before going to tackle VBOs. They quite easy to use actually, but there are a few conceptional pitfalls, like tricking the compiler to pass a number for a pointer parameter.

Improve this answer
Sign up to request clarification or add additional context in comments.

5 Comments

How would I create a VBO for those rectangles? And what are these "indicies" needed for? How would I change the color of a rectangle afterwards once it's in the VBO?
@dontWatchMyProfile: As I already wrote, you can partially update the contents of a VBO. Indices are used if you don't want to use the vertex array itself as a consecutive list of vertices to be drawn, but a array of vertices, which are drawn according to a index array.
Thanks datenwolf! So in my case where I simply want to draw a grid of 32 x 48 rectangles (that is, 32 cols and 48 rows), and then only change their color independently in subsequent run loop iterations, I'd need 32 VBOs (one for each column, so I can use GL_TRIANGLE_STRIP easily), without the need for indices, and could then somehow set the color for each vertex? Or will I need indices in this case?
You don't need 32 VBOs. You can just start from a nonzero offset using glDrawArrays. Colors would be an additional vertex attribute (look up glColorPointer). And don't use GL_TRIANGLE_STRIP if you want to draw a lot of disconnected quads, just use regular, tame GL_TRIANGLES. Triangle strips are meant for long strips of at least 100 vertices, to be efficient. Heck, in most cases simple indexed triangles easily outperform triangle strips.
GL_TRIANGLES is a great tip. Got already headaches about how I would colorize the quads independently when they're made by GL_TRIANGLE_STRIP. How would I create a simple grid of four rectangles, each with a different solid color, using GL_TRIANGLES? Maybe you could update your answer to reflect that, as it would make it more clear.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.