Blank Screen in OpenGL and Glut

Question

When attempting to draw a cube, I get, instead, a blank screen. It is a screen with the background of my glClearColor.

My code is in so many files that I can't really post it all here, so I've placed it on Github. You'll want to look at it. It's a visual studio 2012 file but all the source is there for any IDE. Though very incomplete, here are some snippets:

EDIT: I am now able to see my shapes, but they are completely lightless. Even when I use the already made normals in glutSolidTeapot, it looks flat. Also, even though I specify far cutting plane to be 1000, my shapes disappear far before that. I've updated my code to be more recent.

CodeIndigo.cpp

// Entry point!
// Code indigo is a 3d mystery game. Readme for more information.

#include "CodeIndigo.h"
#include <iostream>


void box_update (const int& frame, const Object& self)
{
    return;
}

void update (int frame)
{
    if (Indigo::keys ['w'])
    {
        Indigo::Current_World.camera.Move (0.05);
    }
    if (Indigo::keys ['s'])
    {
        Indigo::Current_World.camera.Move (-0.05);
    }
    if (Indigo::keys ['a'])
    {
        Indigo::Current_World.camera.Move (0.0, -0.05);
    }
    if (Indigo::keys ['d'])
    {
        Indigo::Current_World.camera.Move (0.0, 0.05);
    }
    if (GL_NO_ERROR != glGetError ())
    {
        std::cout << "Error: " << glGetError () << std::endl;
    }
    if (Indigo::keys ['3'])
    {
        Camera camera = Indigo::Current_World.camera;
        std::cout << camera.X << ", " << camera.Y << ", " << camera.Z << " looking at "
            << camera.eye.Get_X () << ", " << camera.eye.Get_Y () << ", " << camera.eye.Get_Z () << std::endl;
    }
}

void mouse_moved (int x, int y)
{
    static const float sensitivity = 0.5;
    Indigo::Current_World.camera.eye.Add_Direction (0.0, x * sensitivity,
        y * -1 * sensitivity);
    std::cout << x << ", " << y << std::endl;
}

int main(int argc, char ** argv)
{
    Indigo::Initialize (argc, argv, " ~ Code Indigo",
        800, 600, true, 60, Indigo::Sky_Color, 60);
    Mesh box = Mesh::Sphere (0.5);
    Object add = Object(0.0, 0.0, -1.0, box, Indigo::White_Color, 40.0f, box_update);
    int object = Indigo::Current_World.Add_Object (add);
    Indigo::Update_Function = update;
    Indigo::Relative_Mouse_Moved_Function = mouse_moved;
    Indigo::Current_World.lighting.Add_Light (0.0, 2.0, 0.0);
    Indigo::Current_World.camera.Place (0.0, 0.0, 0.0);
    Indigo::Current_World.camera.eye.Set_Direction (1.0, 90.0, -2.8);
    Indigo::Run ();
    return (0);
}

Indigo::Initialize

// Initializes window and rendering matrices.
void Initialize (int argc, char ** argv, const char * window_name,
    const int& window_width, const int& window_height, const bool& fullscreen,
    int field_of_view, float * background, int max_framerate)
{
    glutInit (&argc, argv);
    glutInitDisplayMode (GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);
    glutInitWindowSize (window_width, window_height);
    glutCreateWindow (window_name);
    if (fullscreen)
    {
        glutFullScreen ();
    }
    if (background)
    {
        glClearColor (background [0], background [1], background [2], 1.0);
    }
    else
    {
        glClearColor (Sky_Color [0], Sky_Color [1], Sky_Color [2], 1.0);
    }
    Frame_Length_Minimum = 1000 / max_framerate;
    glutSetKeyRepeat (GLUT_KEY_REPEAT_OFF);
    glutDisplayFunc (Render);
    glutTimerFunc (10, Update, 0);
    glutReshapeFunc (Reshape);
    glutPassiveMotionFunc (Mouse_Moved);
    glutMouseFunc (Mouse_Button);
    glutKeyboardFunc (Key_Pressed);
    glutKeyboardUpFunc (Key_Released);
    glMatrixMode (GL_PROJECTION);
    Reshape ();
    glMatrixMode (GL_MODELVIEW);
    glLoadIdentity ();
    glShadeModel (GL_SMOOTH);
    glEnable (GL_DEPTH_TEST);
    return;
}

Indigo::Reshape

// Acts for when the window reshapes
void Reshape (int width, int height)
{
    bool viewport = true;
    if (0 == width)
    {
        width = glutGet (GLUT_WINDOW_WIDTH);
        viewport = false;
    }
    if (0 == height)
    {
        height = glutGet (GLUT_WINDOW_HEIGHT);
        viewport = false;
    }
    if (viewport)
    {
        glViewport (0, 0, width, height);
    }
    glLoadIdentity ();
    gluPerspective (Field_Of_View,
        (float) width / (float) height,
        0.5, 1000.0);
}

World::Render

void World::Render (void) const
{
    // Renders every object in the world
    glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glMatrixMode (GL_PROJECTION);
    Indigo::Reshape ();
    glMatrixMode (GL_MODELVIEW);
    camera.Look ();
    lighting.Position_Lights ();
    // <DELETE>
    float full_array [] = {1.0, 1.0, 1.0, 1.0};
    glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, full_array);
    glMaterialfv (GL_FRONT_AND_BACK, GL_SPECULAR, full_array);
    glMaterialf (GL_FRONT_AND_BACK, GL_SHININESS, 60.0);
    glutSolidTeapot (0.3);
    // </DELETE>
    for (int Object_ID=0; Object_ID<objects.size (); ++Object_ID)
    {
        const_cast <Object&> (objects [Object_ID]).Render ();
    }
    glutSwapBuffers ();
    return;
}

Object::Render

// Renders the object
void Object::Render (void) const
{
    float full_array [] = {1.0, 1.0, 1.0, 1.0};
    glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, object_color ? object_color : full_array);
    glMaterialfv (GL_FRONT_AND_BACK, GL_SPECULAR, full_array);
    glMaterialf (GL_FRONT_AND_BACK, GL_SHININESS, object_shine);
    glPushMatrix ();
    glTranslatef (X, Y, Z);
    std::vector <Vertex> points = Data.Get_Vertices ();
    glBegin (Render_Types [Data.Group_Size]);
    for (int Point=0; Point<points.size (); Point++)
    {
        // When each polygon is finished, calculate a light normal
        if ((Point + 1) % (Data.Group_Size == 0 ? 3 : Data.Group_Size) == 0)
        {
            Vertex two = points [Point - 1] - points [Point - 2];
            Vertex three = points [Point] - points [Point - 2];
            glNormal3f (two.Z * three.Y - two.Y * three.Z,
                two.X * three.Z - two.Z * three.X,
                two.Y * three.X - two.X * three.Y);
        }
        Vertex Cursor = points [Point];
        glVertex3f (Cursor.X, Cursor.Y, Cursor.Z);
    }
    glEnd ();
    glPopMatrix ();
    return;
}

Sorry for too much code!

The difficulty is that I don't know whether the problem lies in my:

• Setting up of the projection matrix with gluPerspective
• Some Glut thing I don't know about
• Drawing the shape
• Anything else

Answer 1

I agree with pwny. too much of untested code. Usual causes:

1. bad camera/object position
2. wrong frustrum/perspective (bad znear or zfar)
3. enabled textures without using them
4. improper lighting/material parameters
5. forgotten to set glColor

to check for what is wrong

1. disable GL_CULL_FACE,GL_DEPTH_TEST,GL_TEXTURE_1D,2D,...lighting,material,blend

2. set projection (GL_PROJECTION), camera and model (GL_MODELVIEW) to defined state (unit matrix for example)

3. try to render GL_QUAD without GL_CULL_FACE at the right position and size to be visible

4. after success set projection matrix to perspective

   tweak znear,zfar and quad position to match your scene

5. replace quad with your cube

6. after success re-enable all what you need incrementally

PS. also good idea is to check for glerrors (may be wrong something entirely else)

Answer 2

The main problem was that I hadn't enabled GL_LIGHTING correctly.