How to animate a solid sphere over a curve

Question

i am making a program in opengl to animate a solid-sphere over a curve
it goes like
//display function

void display()  
{  
    glClear(GL_DEPTH_BUFFER_BIT|GL_COLOR_BUFFER_BIT);  
    glLoadIdentity();  
    //set of condition   
    loop:j=1 to 5  
        loop:i=1 to 3  
            if(j==1)
            {  
                animate(x,y,z)  
                glutSwapBuffers();
            }
            elseif(j==5)
            {  
                animate(x,y,z)  
                glutSwapBuffers();
            }  
            else //for all value j between 1 and 5
            {  
                animate(x,y,z);  
                glutSwapBuffers();
            }  
}  

//animate function  
void animate(float x, float y, float z)  
{  
    glLoadIdentity();  
    glTranslatef(0,0,-20);  
    glPushMatrix();  
    glTranslatef (x, y, z);  
    glutSolidSphere (0.3, 10, 10);  

    int i, j;  

    for(i = 0; i < 10000; i++) //for introducing delay  
        for(j = 0; j < 5000; j++);


    glPopMatrix();  
    glutSwapBuffers();  
}  

Problem:the solid sphere is translating over the curve but for its each next position i am not able to remove its previous position...for instance if the sphere goes from sequence of position like P1,P2,P3,P4 AND THEN P5..after coming to position P5 its still visible at all others previous position(P1,P2,P3,P4) but i want it to display sphere only at current position while translation How can i do this?

Answer 1

You are not clearing the frame buffer, which means that you are drawing each frame on top of the previous frame. Try using glClearColor(0.0f, 0.0f, 0.0f, 1.0f ); with the color you desire.

Answer 2

OpenGL is not a scene graph. All it does is colouring pixels. After you sent some geometry to OpenGL and it processed it, its gone and forgotten and all whats left are its traces in the framebuffer. Note that the contents of a Vertex Buffer Objects are not geometry per se. Only the drawing calls (glDrawElements, glDrawArrays) turn values in a vertex buffer into geometry.

Also your program doesn't follow the typical animation loop. The way you're doing it right now does not allow user interaction, or any other kind of event processing during the animation. You should change your code into this:

static timeval delta_T = {0., 0.};

struct AnimationState {
    // ...
    float sphere_position[3];
};

AnimationState animation;

void display()  
{

    // Start time, frame rendering begins:
    timeval time_begin_frame;
    gettimeofday(&time_begin_frame, 0);

    animate(delta_T.tv_sec + delta_T.tv_usec * 1.e6);

    glClear(GL_DEPTH_BUFFER_BIT|GL_COLOR_BUFFER_BIT);  

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    set_projection();

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    apply_camera_transform();

    draw_sphere(animation.sphere_position[0], 
                animation.sphere_position[1], 
                animation.sphere_position[2])

    glutSwapBuffers();

    // frame render end time
    timeval time_end_frame;
    gettimeofday(&time_end_frame, 0);
    timersub(&time_end_frame, &time_begin_frame, &delta_time);

}  

void draw_sphere(float x, float y, float z)  
{  

    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();  
    glTranslatef (x, y, z);  
    glutSolidSphere (0.3, 10, 10);  

    glPopMatrix();

}  

void animate(float dT)
{
    // advance animation by timestep dT
}

void idle()
{
    glutPostRedisplay();
}

EDIT Full working code example

/* sinsphere.c */
#include <GL/glut.h>

#include <stdlib.h>

#include <sys/time.h>
#include <math.h>

#define M_PI    3.1415926535897932384626433832795029L
#define M_PI_2  1.5707963267948966192313216916397514L

# define timersub(a, b, result)                                               \
  do {                                                                        \
    (result)->tv_sec = (a)->tv_sec - (b)->tv_sec;                             \
    (result)->tv_usec = (a)->tv_usec - (b)->tv_usec;                          \
    if ((result)->tv_usec < 0) {                                              \
      --(result)->tv_sec;                                                     \
      (result)->tv_usec += 1000000;                                           \
    }                                                                         \
  } while (0)

void idle(void);
void animate(float dT);
void display(void);
void init_sphere(unsigned int rings, unsigned int sectors);
void draw_sphere(void);

int main(int argc, char *argv[])
{    
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);
    glutCreateWindow("SinSphere");
    glutIdleFunc(idle);
    glutDisplayFunc(display);

    init_sphere(10, 30);

    glutMainLoop();

    return 0;
}

struct AnimationState
{
    float time;
        float sphere_speed;
    float sphere_path_radius;
    float sphere_path_bobbing;
    float sphere_position[3];
};

static struct AnimationState animation = {
    0.,
    0.1, 3., 1.,
    {1., 0., 0.}
};

void animate(float dT)
{
    animation.time += dT;

    animation.sphere_position[0] = animation.sphere_path_radius * cos(2*M_PI * animation.time * animation.sphere_speed);
    animation.sphere_position[1] = animation.sphere_path_bobbing * sin(2*M_PI * animation.time * 5 * animation.sphere_speed);
    animation.sphere_position[2] = animation.sphere_path_radius * sin(2*M_PI * animation.time * animation.sphere_speed);
}

GLfloat *sphere_vertices_normals;
unsigned int sphere_quads = 0;
GLushort *sphere_indices;

void init_sphere(unsigned int rings, unsigned int sectors)
{
    float const R = 1./(float)(rings-1);
    float const S = 1./(float)(sectors-1);
    int r, s;

    sphere_vertices_normals = malloc(sizeof(GLfloat)*3 * rings*sectors);

    GLfloat *v = sphere_vertices_normals;
    for(r = 0; r < rings; r++) for(s = 0; s < sectors; s++) {
        float const y = sin( -M_PI_2 + M_PI * r * R );

        float const x = cos(2*M_PI * s * S) * sin( M_PI * r * R );

        float const z = sin(2*M_PI * s * S) * sin( M_PI * r * R );

        v[0] = x;
        v[1] = y;
        v[2] = z;

        v+=3;
    }

    sphere_indices = malloc(sizeof(GLushort) *  rings * sectors * 4);
    GLushort *i = sphere_indices;
    for(r = 0; r < rings; r++) for(s = 0; s < sectors; s++) {
        *i++ = r * sectors + s;
        *i++ = r * sectors + (s+1);
        *i++ = (r+1) * sectors + (s+1);
        *i++ = (r+1) * sectors + s; 
        sphere_quads++;
    }
}

void draw_sphere()
{
    glTranslatef(animation.sphere_position[0], animation.sphere_position[1], animation.sphere_position[2]);

    glEnableClientState(GL_VERTEX_ARRAY);
    glEnableClientState(GL_NORMAL_ARRAY);

    glVertexPointer(3, GL_FLOAT, 0, sphere_vertices_normals);
    glNormalPointer(GL_FLOAT, 0, sphere_vertices_normals);
    glDrawElements(GL_QUADS, sphere_quads*4, GL_UNSIGNED_SHORT, sphere_indices);
}

void idle()
{
    glutPostRedisplay();
}

static GLfloat const light_pos[4] = {-1., 1., 1., 0.};
static GLfloat const light_color[4] = {1., 1., 1., 1.};

void display()
{
    static struct timeval delta_T = {0., 0.};
    struct timeval time_frame_begin, time_frame_end;

    int win_width, win_height;
    float win_aspect;

    gettimeofday(&time_frame_begin, 0);

    animate(delta_T.tv_sec + delta_T.tv_usec * 1.e-6);

    win_width = glutGet(GLUT_WINDOW_WIDTH);
    win_height = glutGet(GLUT_WINDOW_HEIGHT);
    win_aspect = (float)win_width/(float)win_height;

    glViewport(0, 0, win_width, win_height);
    glClearColor(0.6, 0.6, 1.0, 1.0);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glFrustum(-win_aspect, win_aspect, -1., 1., 1., 10.);

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glTranslatef(0,0,-5.5);

    glLightfv(GL_LIGHT0, GL_POSITION, light_pos);
    glLightfv(GL_LIGHT0, GL_DIFFUSE, light_color);

    glPushMatrix();

    glEnable(GL_DEPTH_TEST);

    glEnable(GL_LIGHTING);
    glEnable(GL_LIGHT0);
    draw_sphere();

    glPopMatrix();

    glutSwapBuffers();

    gettimeofday(&time_frame_end, 0);
    timersub(&time_frame_end, &time_frame_begin, &delta_T);

}