Question

I’m learning OpenGL with right now and I’d like to draw some sprites to the screen from a sprite sheet. I’m note sure if I’m doing this the right way though.

What I want to do is to build a world out of tiles à la Terraria. That means that all tiles that build my world are 1×1, but I might want things later like entities that are 2×1, 1×2, 2×2 etc.

What I do right now is that I have a class named “Tile” which contains the tile’s transform matrix and a pointer to its buffer. Very simple:

Tile::Tile(glm::vec2 position, GLuint* vbo)
{
    transformMatrix = glm::translate(transformMatrix, glm::vec3(position, 0.0f));
    buffer = vbo;
}

Then when I draw the tile I just bind the buffer and update the shader’s UV-coords and vertex position. After that I pass the tile’s transform matrix to the shader and draw it using glDrawElements:

glEnableVertexAttribArray(positionAttrib);
glEnableVertexAttribArray(textureAttrib);

for(int i = 0; i < 5; i++) 
{
    glBindBuffer(GL_ARRAY_BUFFER, *tiles[i].buffer);

    glVertexAttribPointer(positionAttrib, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(GLfloat), 0);
    glVertexAttribPointer(textureAttrib, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(GLfloat), (void*)(2 * sizeof(GLfloat)));

    glUniformMatrix4fv(transformMatrixLoc, 1, GL_FALSE, value_ptr(tiles[i].transformMatrix));
    glDrawElements(GL_TRIANGLE_STRIP, 4, GL_UNSIGNED_INT, 0);
}

glDisableVertexAttribArray(positionAttrib);
glDisableVertexAttribArray(textureAttrib);

Could I do this more efficiently? I was thinking that I could have one buffer for 1×1 tiles, one buffer for 2×1 tiles etc. etc. and then just have the Tile class contain UVpos and UVsize and then just send those to the shader, but I’m not sure how I’d do that.

I think what I described with one buffer for 1×1 and one for 2×1 sounds like it would be a lot faster.

Answer 1

Could I do this more efficiently?

I don’t think you could do it less efficiently. You are binding a whole buffer object for each quad. You are then uploading a matrix. For each quad.

The way tilemap drawing (and only the map, not the entities) normally works is that you build a buffer object that contains some portion of the visible screen’s tiles. Empty space is rendered as a transparent tile. You then render all of the tiles for that region of the screen, all in one drawing call. You provide one matrix for all of the tiles in that region.

Normally, you’ll have some number of such visible regions, to make it easy to update the tiles for that region when they change. Regions that go off-screen are re-used for regions that come on-screen, so you fill them with new tile data.