OpenGL key frame animation - the best approach

Answer 1

I'm assuming you're making a game, if you aren't ignore the bits about velocity and position, everything else applies.

You're going to have to calculate where to draw everything, there isn't really a shortcut around that.

However, as far as copying state goes, you need to approach the problem a little differently.

Each visible game object (Actor, Doodad, etc.) must maintain it's own state of where it is, where it is going, what frame of animation to show. The way I'm showing you here will also prevent temporal aliasing

As part of your game loop, you should first update each object by looping through them, passing them the delta time since the last update, and then each object should maintain a previous and current state. When asked to draw with a dt, that the time to do the linear interpolation between the two states, to create a drawable state.

When calculating the proper time, you should follow the guideline here. Yes, the article is about a integrating engine but the approach used will work with games without them, and will allow a game to downscale gracefully in environments where there isn't enough power to keep up as well as never to run too fast if the hardware changes under your feet.

Pseudo code:

Abstract Class GameObject {
     private State previous_state;
     private State current_state;
     private State draw_state;

     void Update(float dt) {
          previous_state = current_state.copy();
          current_state = current_state + dt;
     }
     void Draw(float dt) {
          draw_state = interpolate(previous_state, current_state, dt);
          //Do opengl commands to draw draw_state
     }
}

Then your game loop should look like:

void GameLoop() {
     while(1) {
          //Calculate dt here
          process_inputs();
          for {game_object in object_list} {
               game_object.Update(dt)
          }
          //...
          for {game_object in object_list} {
               game_object.Draw(dt)
          }
 }

Each State contains all the information needed to describe the object's position, velocity and animation frame. A simple State class might look like:

Class State {
     public float position_x;
     public float position_y;
     public float velocity_x;
     public float velocity_y;
     public int frame_number;
     public int max_frame;
     public float animation_duration;  //milliseconds
}

Subtracting two states should produce an intermediate state. Adding a time to a State should calculate the next position based on the velocity, as well as determine the next frame of animation.