Clear Screen

I’m trying to make a C++ program with GLUT where a little spaceship is drawn and then moved around. My problem is that the program doesn’t seem to clear afterimages of the spaceship, and so the ship leaves a trail after it. Here is the code:

#ifdef __APPLE__
#include <GLUT/glut.h>
#else
#include <GL/glut.h>
#endif

#include <stdlib.h>
#include "drawEnt.h"

static int slices = 16;
static int stacks = 16;

bool success;

float xPlayer = 0; float yPlayer = 0;

/* GLUT callback Handlers */

static void resize(int width, int height)
{
    const float ar = (float) width / (float) height;
    glViewport(0, 0, width, height);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(width/-2, width/2, height/-2, height/2 ,0,1);

    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
}

static void display(void)
{
    const double t = glutGet(GLUT_ELAPSED_TIME) / 1000.0;
    const double a = t*90.0;

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glColor3d(0,1,0);

    //Set all point values
    pP1 [1] = xPlayer;              pP1 [2] = yPlayer+12;
    pP2 [1] = xPlayer + 11;         pP2 [2] = yPlayer-11;
    pP3 [1] = xPlayer - 11;         pP3 [2] = yPlayer-11;

    //Draw Player
    glBegin(GL_LINES);
        glVertex2f( pP1 [1], pP1 [2] );
        glVertex2f( pP2 [1], pP2 [2] );
    glEnd;

    glBegin(GL_LINES);
        glVertex2f( pP2 [1], pP2 [2] );
        glVertex2f( xPlayer, yPlayer );
    glEnd;

    glBegin(GL_LINES);
        glVertex2f( xPlayer, yPlayer );
        glVertex2f( pP3 [1], pP3 [2] );
    glEnd;

    glBegin(GL_LINES);
        glVertex2f( pP3 [1], pP3 [2] );
        glVertex2f( pP1 [1], pP1 [2] );
    glEnd;

    glutSwapBuffers();

}


static void key(unsigned char key, int x, int y)
{
    switch (key)
    {
        case 27 :
        case 'q':
            exit(0);
            break;

        case '+':
            slices++;
            stacks++;
            break;

        case '-':
            if (slices>3 && stacks>3)
            {
                slices--;
                stacks--;
            }
            break;

        case 'w':
            yPlayer = yPlayer + 5;
            break;
    }

    glutPostRedisplay();
}

static void idle(void)
{
    glutPostRedisplay();
}

const GLfloat light_ambient[]  = { 0.0f, 0.0f, 0.0f, 1.0f };
const GLfloat light_diffuse[]  = { 1.0f, 1.0f, 1.0f, 1.0f };
const GLfloat light_specular[] = { 1.0f, 1.0f, 1.0f, 1.0f };
const GLfloat light_position[] = { 2.0f, 5.0f, 5.0f, 0.0f };

const GLfloat mat_ambient[]    = { 0.7f, 0.7f, 0.7f, 1.0f };
const GLfloat mat_diffuse[]    = { 0.8f, 0.8f, 0.8f, 1.0f };
const GLfloat mat_specular[]   = { 1.0f, 1.0f, 1.0f, 1.0f };
const GLfloat high_shininess[] = { 100.0f };

/* Program entry point */

int main(int argc, char *argv[])
{
    glutInit(&argc, argv);
    glutInitWindowSize(640,480);
    glutInitWindowPosition(10,10);
    glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);

    glutCreateWindow("Vectrocity");

    glutReshapeFunc(resize);
    glutDisplayFunc(display);
    glutKeyboardFunc(key);
    glutIdleFunc(idle);

    glClearColor(0,0,0,1);
    glEnable(GL_CULL_FACE);
    glCullFace(GL_BACK);

    glEnable(GL_DEPTH_TEST);
    glDepthFunc(GL_LESS);

    glEnable(GL_LIGHT0);
    glEnable(GL_NORMALIZE);
    glEnable(GL_COLOR_MATERIAL);
    glEnable(GL_LIGHTING);

    glLightfv(GL_LIGHT0, GL_AMBIENT,  light_ambient);
    glLightfv(GL_LIGHT0, GL_DIFFUSE,  light_diffuse);
    glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
    glLightfv(GL_LIGHT0, GL_POSITION, light_position);

    glMaterialfv(GL_FRONT, GL_AMBIENT,   mat_ambient);
    glMaterialfv(GL_FRONT, GL_DIFFUSE,   mat_diffuse);
    glMaterialfv(GL_FRONT, GL_SPECULAR,  mat_specular);
    glMaterialfv(GL_FRONT, GL_SHININESS, high_shininess);

    glutMainLoop();

    return EXIT_SUCCESS;
}

Don’t modify the depth func to less. Keep the default. In other words, remove this line

 glDepthFunc(GL_LESS);

and see if it helps.

That didn’t seem to fix the problem, or do anything at all. Thanks for the reply, though.

Your code looks fine so there’s no problem there.
What’s your window initialisation code - specifically with regard to double buffering?

Incidentally, you have this line:

glEnable(GL_DEPTH_TEST);

You should actually disable depth testing since your are drawing in 2D via the glOrtho projection.

Yes, I actually did disable it at some point. I changed it to see if that fixed the problem and never changed it back.

Window initialization code. I’m afraid I gave you all the code I am aware of. Where would I find this?

Edit: You should probably know that it updates fine and gets rid of all the afterimages of the ship if I re size the window.

    glBegin(GL_LINES);
        glVertex2f( pP1 [1], pP1 [2] );
        glVertex2f( pP2 [1], pP2 [2] );
    glEnd;    // very bad   !!!!

    glEnd();  // correction !!!!

The problem is in your Display function. All of the glEnds have to have an open and close parens after them.

Wow, your right. I don’t know how I managed to make that mistake four times in a row, but either way, it fixed the problem! Thank you!

Of course the second time I run the program the computer blue screens… I’m calling that bad luck for now…

No problem. I’ve made that mistake myself a few times.
It’s nasty, because it compiles and runs, but the graphics is messed up.
So U don’t expect it to be a simple syntax problem.

A small suggestion -
glBegin(GL_LINES) tells OpenGL that every pair of vertices to follow is to be taken as a line segment.
Hence U don’t need all those glBegins and glEnds. U only need one of each.
Your code can be written very compactly as …

    glBegin(GL_LINES);
        glVertex2f ( pP1[1],  pP1[2]);  glVertex2f ( pP2[1],  pP2[2]);
        glVertex2f ( pP2[1],  pP2[2]);  glVertex2f (xPlayer, yPlayer);
        glVertex2f (xPlayer, yPlayer);  glVertex2f ( pP3[1],  pP3[2]);
        glVertex2f ( pP3[1],  pP3[2]);  glVertex2f ( pP1[1],  pP1[2]);
    glEnd();

Or, even better …

    glBegin(GL_LINE_LOOP);
        glVertex2f ( pP1[1],  pP1[2]);
	glVertex2f ( pP2[1],  pP2[2]);
	glVertex2f (xPlayer, yPlayer);
        glVertex2f ( pP3[1],  pP3[2]);
    glEnd();