OpenGL black screen(GL_PERSPECTIVE, GL_MODELVIEW problem)

Question

I'm trying to move the perspective view, so I can see that the sun, earth, and moon is moving around on a screen. I'm keep searching and trying to fix this but there's nothing on a screen. I really need help to fix this...

#include <gl/glew.h>
#include <gl/freeglut.h>
#include <GL/GL.h>
#include <GL/GLU.h>
#include <GL/glut.h>
#include <vector>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>

using namespace glm;

static int Day = 0, Time = 0;
int windowWidth, windowHeight;

vec3 eye(0, 2.0, 4.0);
vec3 at(0.2, 0, 0);
vec3 up(normalize(cross(vec3(1, 0, 0), at - eye)));


void InitLight() {
    // sun_light
    GLfloat sun_light_amb[] = { 0.5, 0, 0, 1.0 };
    GLfloat sun_light_diffuse[] = { 1, 0.5, 0.5, 1.0 };
    GLfloat sun_light_specular[] = { 1, 1, 1, 1.0 };
    // moon_light
    GLfloat moon_light_amb[] = { 0.5, 0.5, 0, 1.0 };
    GLfloat moon_light_diffuse[] = { 1, 1, 0.5, 1.0 };
    GLfloat moon_light_specular[] = { 1, 1, 1, 1.0 };

    glShadeModel(GL_SMOOTH);  // using GL_SMOOTH
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_LIGHTING);
    glEnable(GL_LIGHT0);
    glEnable(GL_LIGHT1);

    // sun - GL_LIGHT0
    glLightfv(GL_LIGHT0, GL_AMBIENT, sun_light_amb);
    glLightfv(GL_LIGHT0, GL_DIFFUSE, sun_light_diffuse);
    glLightfv(GL_LIGHT0, GL_SPECULAR, sun_light_specular);
    // moon - GL_LIGHT1
    glLightfv(GL_LIGHT1, GL_AMBIENT, moon_light_amb);
    glLightfv(GL_LIGHT1, GL_DIFFUSE, moon_light_diffuse);
    glLightfv(GL_LIGHT1, GL_SPECULAR, moon_light_specular);
}


void MyDisplay() {
    // material
    // sun
    GLfloat sun_mat_amb[] = { 0.2, 0 , 0, 1.0 };
    GLfloat sun_mat_diffuse[] = { 1, 0.5, 0.5, 1.0 };
    GLfloat sun_mat_specular[] = { 0, 0, 0, 1 };
    GLfloat sun_mat_emission[] = { 0.3, 0.1, 0.1, 0.0 };
    // sun
    GLfloat moon_mat_amb[] = { 0.1, 0.1, 0.1, 1.0 };
    GLfloat moon_mat_diff[] = { 0.5, 0.5, 0.1, 1.0 };
    GLfloat moon_mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
    GLfloat moon_shininess[] = { 100.0 };
    GLfloat moon_mat_emission[] = { 0.3, 0.3, 0.1, 0.0 };
    // earth
    GLfloat earth_mat_amb[] = { 0.1, 0.1, 0.1, 1.0 };
    GLfloat earth_mat_diff[] = { 0.1, 0.1, 0.8, 1.0 };
    GLfloat earth_mat_specular[] = { 0.5, 0.5, 1.0, 1.0 };
    GLfloat earth_shininess[] = { 80.0 };

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);


    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(20.f, (GLfloat)windowWidth / (GLfloat)windowHeight, 0.f, 20.f);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    gluLookAt(eye[0], eye[1], eye[2], at[0], at[1], at[2], up[0], up[1], up[2]);
    

    glEnable(GL_CULL_FACE);
    glFrontFace(GL_CW);
    glCullFace(GL_FRONT);

    glColor3f(1.0, 0.3, 0.3);   // sun
    glMaterialfv(GL_FRONT, GL_AMBIENT, sun_mat_amb);
    glMaterialfv(GL_FRONT, GL_DIFFUSE, sun_mat_diffuse);
    glMaterialfv(GL_FRONT, GL_SPECULAR, sun_mat_specular);
    glMaterialfv(GL_FRONT, GL_EMISSION, sun_mat_emission);
    glutSolidSphere(0.2, 20, 16);
    glEnable(GL_LIGHT0);    // sun - LIGHT0
    glPushMatrix();
        glRotatef((GLfloat)Day, 0.0, 1.0, 0.0);     // earth
        glTranslatef(0.7, 0.0, 0.0);
        glRotatef((GLfloat)Time, 0.0, 1.0, 0.0);
        glColor3f(0.5, 0.6, 0.7);
        glMaterialfv(GL_FRONT, GL_AMBIENT, earth_mat_amb);
        glMaterialfv(GL_FRONT, GL_DIFFUSE, earth_mat_diff);
        glMaterialfv(GL_FRONT, GL_SPECULAR, earth_mat_specular);
        glMaterialfv(GL_FRONT, GL_SHININESS, earth_shininess);
        glutSolidSphere(0.1, 10, 8);
        glPushMatrix();
            glRotatef((GLfloat)Time, 0.0, 1.0, 0.0);    // moon
            glTranslatef(0.2, 0.0, 0.0);
            glColor3f(0.9, 0.8, 0.2);
            glMaterialfv(GL_FRONT, GL_AMBIENT, moon_mat_amb);
            glMaterialfv(GL_FRONT, GL_DIFFUSE, moon_mat_diff);
            glMaterialfv(GL_FRONT, GL_SPECULAR, moon_mat_specular);
            glMaterialfv(GL_FRONT, GL_EMISSION, moon_mat_emission);
            glutSolidSphere(0.04, 10, 8);
            glEnable(GL_LIGHT1);    // moon - LIGHT1
            glPopMatrix();
        glPopMatrix();
    glutSwapBuffers();
}


void MyReshape(int w, int h) {
    windowWidth = w;
    windowHeight = h;

    glViewport(0, 0, (GLsizei)w, (GLsizei)h);
}

void MyTimer(int Value) {
    Day = (Day + 2) % 360;
    Time = (Time + 1) % 360;

    mat3 rot = rotate(mat4(1), radians(1.f), vec3(0, 0, 1)); // rotate 1 degree
    eye = rot * eye;
    up = rot * up;

    glutPostRedisplay();
    glutTimerFunc(40, MyTimer, 1);
}


int main(int argc, char** argv) {
    //Create window
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH);
    glutInitWindowSize(500, 500);
    glutInitWindowPosition(0, 0);
    glutCreateWindow("Test");

    //get window size
    windowWidth = glutGet(GLUT_WINDOW_WIDTH);
    windowHeight = glutGet(GLUT_WINDOW_HEIGHT);

    InitLight();
    glutDisplayFunc(MyDisplay);
    glutReshapeFunc(MyReshape);
    glutTimerFunc(40, MyTimer, 1);

    glutMainLoop();
    return 0;
}

• moving sun, earth, moon
• using GL_SMOOTH
• moving perspective when MyTimer callback (rotate eye and up => 1 degree)

Answer 1

The Perspective Projection matrix defines a Viewing Frustum. The near plane cannot be 0. The near plan must be grater than o and the far plan must be grater than the near plane.

0 < near < far

Change the near plane. e.g:

gluPerspective(20.f, (GLfloat)windowWidth / (GLfloat)windowHeight, 0.f, 20.f);

gluPerspective(20.f, (GLfloat)windowWidth / (GLfloat)windowHeight, 0.1f, 20.f);