Techniques for drawing objects in OpenGL

Question

Techniques for drawing large numbers of objects in OpenGL

I am wondering what techniques or methods I could use to draw many objects on OpenGL.

For example, I may have a class which represents a brick, and maybe another which represents a tree, or something else random which I would like to draw like a lamppost. Then say, I have many bricks to draw, or lampposts or something like that... Calling a draw method for each one would lead to very long code.

At the moment I am using a glut callback function to draw the "stuff" in the world, like a brick or tree.

Using a globally accessible vector of base pointers

One idea I had was to have all the classes inherit from a base class, and put base pointers into a vector - then have the vector global. That way I could do something like:

for(int i = 0; i < vector_of_objects.size(); i ++)
    vector_of_objects[i]->draw();

Each object could have a draw function, which draws all the OpenGL primitives.

An example of such a class would be something like this. (This is what I have been experimenting with.)

class box {
    public:
        void draw() { // Do the drawing of a box }
    // Other members etc
}

Alternatives?

This doesn't seem like a good idea, since creating a new class for something like a house, would require the user to remember to add a draw function called 'draw'... Although this is a trivial point, not necessarily a big problem.

Are different techniques used in industry or games development? The advantage I see to this method is once the for loop is put in the draw function, you can forget about it - only having to worry about placing more items (or pointers) in the globally accessible vector.

Does anyone have any suggestions for a better alternative?

Answer 1

Create an interface for your Stuff and inherit classes from that. This way nobody will forget that a draw method needs to be implemented.

Answer 2

Create an abstract base class that contains a pure virtual function used for rendering the object. This forces the derived classes to implement the function in order for then to be instantiated.

class shape
{
public:
    virtual void draw( /* parameters */ ) = 0; // pure virtual

    // other member functions 
};

class box : public shape
{
public:
    virtual void draw( /* parameters same as in shape */ )
    {
        // rendering code goes here
    }
};

Now you can use it like so...

std::vector<shape*> vector_of_objects;

for(int i = 0; i < vector_of_objects.size(); i ++)
    vector_of_objects[i]->draw( /* arguments */ );

Answer 3

It it more complicated question :)

From opengl point of view object cube, box, tree... those are ony triangles pushed to the pipeline. Do you really need to have them separated? Probably you need but only for the logic of the game/app, not for the rendering.

So in general object in game can be declared like this:

class Object {
    Model3D m_mesh;
    PhysicsModel m_physicsModel;
    ...

    doStuff();
}

Model3D - mesh loaded from some file probably, contains triangles + materials + shaders + textures, etc. It is used to draw object.

PhysicsModel - physical representation of the object, used in physics engine.

From that you can derive your own objects. When you want to render the whole bunch of objects you push m_mesh-es to the rendering queue.

In general you have some entity + its various representations (rendering, physics).

RenderQueue collects meshes to render, can sort them by the material (shader, texture, etc) and do the efficient rendering. It can use instancing, culling techniques, etc, etc.

after objects are updated you will add them to rendering queue:

for(int i = 0; i < vector_of_objects.size(); i++)
    rendering_queue->add(object[i].m_mesh);

then in rendering code you will call:

rendering_queue->renderAll();

See nice presentation here about benefits of data driven engine