Question

I’m new to OpenGL and graphics programming in general, though I’ve always been interested in the topic so have a grounding in the theory.

What I’d like to do is create a scene in which a set of objects move about. Specifically, they’re robotic soccer players on a field. The objects are:

• The lighting, field and goals, which don’t change
• The ball, which is a single mesh which will undergo translation and rotation but not scaling
• The players, which are each composed of body parts, each of which are translated and rotated to give the illusion of a connected body

So to my GL novice mind, I’d like to load these objects into the scene and then just move them about. No properties of the vertices will change, either their positioning nor texture/normals/etc. Just the transformation of their ‘parent’ object as a whole.

Furthermore, the players all have identical bodies. Can I optimise somehow by loading the model into memory once, then painting it multiple times with a different transformation matrix each time?

I’m currently playing with OpenTK which is a lightweight wrapper on top of OpenGL libraries.

So a helpful answer to this question would either be:

• What parts of OpenGL give me what I need? Do I have to redraw all the faces every frame? Just those that move? Can I just update some transformation matrices? How simple can I make this using OpenTK? What would psuedocode look like? Or,
• Is there a better framework that’s free (ideally open source) and provides this level of abstraction?

Note that I require any solution to run in .NET across multiple platforms.

Answer 1

Using so called vertex arrays is probably the surest way to optimize such a scene. Here’s a good tutorial:

http://www.songho.ca/opengl/gl_vertexarray.html

A vertex array or more generally, a gl data array holds data like vertex positions, normals, colors. You can also have an array that hold indexes to these buffers to indicate in which order to draw them.
Then you have a few closely related functions which manage these arrays, allocate them, set data to them and paint them. You can perform a rendering of a complex mesh with just a single OpenGL command like glDrawElements()

These arrays generally reside on the host memory, A further optimization is to use vertex buffer objects which are the same concept as regular arrays but reside on the GPU memory and can be somewhat faster. Here’s abit about that:

http://www.songho.ca/opengl/gl_vbo.html

Working with buffers as opposed to good old glBegin() .. glEnd() has the advantage of being compatible with OpenGL ES. in OpenGL ES, arrays and buffers are the only way to draw stuff.

— EDIT

Moving things, rotating them and transforming them in the scene is done using the Model View matrix and does not require any changes to the mesh data. To illustrate:

you have your initialization:

void initGL() {
  // create set of arrays to draw a player
  // set data in them
  // create set of arrays for ball
  // set data in them
}

void drawScene {
  glMatrixMode(GL_MODEL_VIEW);
  glLoadIdentity();
  // set up view transformation
  gluLookAt(...);
  drawPlayingField();

  glPushMatrix();
  glTranslate( player 1 position );
  drawPlayer();
  glPopMatrix();

  glPushMatrix();
  glTranslate( player 2 position );
  drawPlayer();
  glPopMatrix();

  glPushMatix();
  glTranslate( ball position );
  glRotate( ball rotation );
  drawBall();
  glPopMatrix();
}