Opengl - rendering different vertex formats

Question

I am looking for a nice way to render mesh objects with different vertex layouts wihtout large effort (e.g. defining a renderer class for each vertex layout). You can see some examples of different vertex formats below.

enum EVertexFormat
{
    VERTEX_FORMAT_UNDEFINED = -1,
    VERTEX_FORMAT_P1 = 0,
    VERTEX_FORMAT_P1N1,
    VERTEX_FORMAT_P1N1UV,
    VERTEX_FORMAT_P1N1C1,
    VERTEX_FORMAT_P1N1UVC1,
};

// the simplest possible vertex -- position only 
struct SVertexP1
{
    math::Vector3D m_position;      // position of the vertex
};

struct SVertexP1N1
{
    math::Vector3D m_position;      // position of the vertex
    math::Vector3D m_normal;        // normal of the vertex
};

// a typical vertex format with position, vertex normal
// and one set of texture coordinates
struct SVertexP1N1UV
{
    math::Vector3D m_position;      // position of the vertex
    math::Vector3D m_normal;        // normal of the vertex
    math::Vector2D m_uv;            // (u,v) texture coordinate
};

struct SVertexP1N1C1
{
    math::Vector3D m_position;      // position of the vertex
    math::Vector3D m_normal;        // normal of the vertex
    uint32_t m_color_u32;           // color of the vertex
};

struct SVertexP1N1UVC1
{
    math::Vector3D m_position;      // position of the vertex
    math::Vector3D m_normal;        // normal of the vertex
    math::Vector2D m_uv;            // (u,v) texture coordinate
    uint32_t m_color_u32;           // color of the vertex
};

The background is, that I want to render different objects. Some of them are primitives (e.g. planes, spheres) which do not own texture coordinates or normals. On the other hand I want to render more complex objects which have normals, texture coordinates etc. Is there a smart way or design to avoid programming multiple renderer classes and instead using a single renderer class? I am aware, that this will also affect shaders.

Mange

Answer 1

What you can do is give each of your vertex structs a static method, maybe called EnableVertexAttribArray or something similar. In this static method you set up the vertex layout in the GL_ARRAY_BUFFER, assuming a correct array buffer has been bound.

struct SVertexP1N1
{
    math::Vector3D m_position;      // position of the vertex
    math::Vector3D m_normal;        // normal of the vertex
    static void EnableVertexAttribArray()
    {
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(SVertexP1N1), (const GLvoid*)offsetof(SVertexP1N1, m_position));
        glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(SVertexP1N1), (const GLvoid*)offsetof(SVertexP1N1, m_normal));
        glEnableVertexAttribArray(0);
        glEnableVertexAttribArray(1);
    }
};

Then you can make a template class of a vertex buffer, based on the vertex struct. For instance,

template <class VertexType> class vertex_buffer
{
public:
    typedef VertexType vertex_type;

    vertex_buffer()
    {
        glGenVertexArrays(1, &m_vao);
        glGenBuffers(1, &m_vbo);
        glGenBuffers(1, &m_ibo);
        glBindVertexArray(m_vao);
        glBindBuffer(GL_ARRAY_BUFFER, m_vbo);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ibo);
        vertex_type::EnableVertexAttribArray(); // <--------
        glBindBuffer(GL_ARRAY_BUFFER, 0);
        glBindVertexArray(0);
    }

    ~vertex_buffer()
    {
        glDeleteVertexArrays(1, &m_vao);
        glDeleteBuffers(1, &m_vbo);
        glDeleteBuffers(1, &m_ibo);
    }

    // ...

    void draw()
    {
        glBindVertexArray(m_vao);
        glBindBuffer(GL_ARRAY_BUFFER, m_vbo);
        glDrawElements(GL_TRIANGLES, m_indices.size(), GL_UNSIGNED_INT, NULL);
        glBindBuffer(GL_ARRAY_BUFFER, 0);
        glBindVertexArray(0);
    }

private:
    GLuint m_vao;
    GLuint m_vbo;
    GLuint m_ibo;
    std::vector<vertex_type> m_vertices;
    std::vector<GLuint> m_indices;
}

Bitternut