Question

How to make a step by step display animation in openGL??

I’M doing a reprap printer project to read a GCode file and interpret it into graphic.
now i have difficulty make a step by step animation of drawing the whole object.
i need to draw many short lines to make up a whole object.
for example:

|-----|
|     |
|     |
|-----|

the square is made up of many short lines, and each line is generated by code like:

glPushMatrix();
.....
for(int i=0; i< instruction[i].size(),i++)
{  ....
   glBegin(GL_LINES);
     glVertex3f(oldx, oldy, oldz);
     glVertex3f(x, y, z);
   glEnd();
}
glPopMatrix();

now i want to make a step animation to display how this square is made. I tried to refresh the screen each time a new line is drawn, but it doesn’t work, the whole square just come out at once. anyone know how to make this?

Answer 1

Typical OpenGL implementations will queue up large number of calls to batch them together into bursts of activity to make optimal use of available communication bandwidth and GPU time resources.

What you want to do is basically the opposite of double buffered rendering, i.e. rendering where each drawing step is immediately visible. One way to do this is by rendering to a single buffered window and call glFinish() after each step. Major drawback: It’s likely to not work well on modern systems, which use compositing window managers and similar.

Another approach, which I recommend, is using a separate buffer for incremental drawing, and constantly refreshing the main framebuffer from this one. The key subjects are Frame Buffer Object and Render To Texture.

First you create a FBO (tons of tutorials out there and as answers on StackOverflow). A FBO is basically an abstraction to which you can connect target buffers, like textures or renderbuffers, and which can be bound as the destination of drawing calls.

So how to solve your problem with them? First you should not do the animation by delaying a drawing loop. This has several reasons, but the main issue is, that you loose program interactivity by this. Instead you maintain a (global) counter at which step in your animation you are. Let’s call it step:

int step = 0;

Then in your drawing function you have to phases: 1) Texture update 2) Screen refresh

Phase one consists of binding your framebuffer object as render target. For this to work the target texture must be unbound

glBindTexture(GL_TEXTURE_2D, 0);
glBindFramebuffer(GL_FRAMEBUFFER, animFBO);
glViewport(0, 0, fbo.width, fbo.height);
set_animFBO_projection();

the trick now is, that you clear the animFBO only once, namely after creation, and then never again. Now you draw your lines according to the animation step

draw_lines_for_step(step);

and increment the step counter (could do this as a compound statement, but this is more explicit)

step++;

After updating the animation FBO it’s time to update the screen. First unbind the animFBO

glBindFramebuffer(GL_FRAMEBUFFER, 0);

We’re now on the main, on-screen framebuffer

glViewport(0, 0, window.width, window.height);
set_window_projection(); //most likely a glMatrixMode(GL_PROJECTION); glOrtho(0, 1, 0, 1, -1, 1);

Now bind the FBO attached texture and draw it to a full viewport quad

glBindTexture(GL_TEXTURE_2D, animFBOTexture);
draw_full_viewport_textured_quad();

Finally do the buffer swap to show the animation step iteration

SwapBuffers();