CODEWITHSUNDEEP
opengl
Jonathan Simbahan
Jonathan Simbahan

Reputation: 31

OpenGL cube not rendering properly

I have a problem when rendering cubes in OpenGL.I am drawing two cubes, one is a wire cube and is centered around the origin, while the other is offset from the origin and is solid. I have mapped some keys to rotate the objects by some degrees wrt to the origin, so the whole scene can rotate around the origin.

The problem is, when I render the scene, when the wire cube is supposed to be infront of the other solid cube, it does not display itself correctly.

enter image description here

In the image above, the colored cube is supposed to be behind the wire cube. i.e. the green wire cube should be on top.

Also the cube is not behaving properly.

enter image description here

After I rotate it a little bit around the x axis (current horizontal line).

The cube has missing faces and is not rendering correctly. What am I doing wrong?

I have coded the following Note that rotateX,rotateY,rotateZ are mapped to keys, and are my global rotation variables.

//The Initialize function, called once:    
void Init(){
    glEnable(GL_TEXTURE_2D); 
    glShadeModel(GL_SMOOTH);                            // Enable Smooth Shading
    glClearColor(0.0f, 0.0f, 0.0f, 0.5f);               // Black Background
    glClearDepth(1.0f);                                 // Depth Buffer Setup
    glEnable(GL_DEPTH_TEST);                            // Depth Buffer Setup                       // Enables Depth Testing
    glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);  // Really Nice Perspective Calculations
    glEnable(GL_LIGHTING);
}

void draw(){
    //The main draw function
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity ();
    gluPerspective(45, 640/480.0, .5, 100);

    glMatrixMode(GL_MODELVIEW); //select the modelview matrix.
    glLoadIdentity ();
    gluLookAt(0,0,5,
              0,0,0,
              0,1,0);    

    glRotatef(rotateX,1,0,0);
    glRotatef(rotateY,0,1,0);
    glRotatef(rotateZ,0,0,1);
    drawScene();  // this just draws the main axis lines,

    glutWireCube(1);  

    glPopMatrix();
    glPushMatrix();
    glTranslatef(-2,1,0);
    drawNiceCube();
    glPopMatrix();

    glutSwapBuffers();
}

The code for the drawNiceCube() is just using GL_QUADS, while the drawWireCube is built in in GLUT.

EDIT: I have posted the full code at http://pastebin.com/p1kwPjEM, sorry if it is not well documented.

Upvotes: 3

Views: 5711

Answers (3)

Jonathan Simbahan
Jonathan Simbahan

Reputation: 31

datenwolf solved my problem. I quote him:

"@JonathanSimbahan: Parts of your code are redundant, but something is missing: You forgot to call Init(); after creating your GLUT window, hence depth testing and all the other state never get enabled. I for one suggest you don't use Init at all and move it's code into the drawing code, where it actually belongs."

Upvotes: 0

datenwolf
datenwolf

Reputation: 162164

Did you also request a window with a depth buffer?

glutInitDisplayMode( ... | GLUT_DEPTH | ...);

Update:

Did you somewhere enable face culling?

glEnable(GL_CULL_FACE);

Upvotes: 4

Yuriy Vikulov
Yuriy Vikulov

Reputation: 2499

This is may be cause of clockwise

10.090 How does face culling work? Why doesn't it use the surface normal?

OpenGL face culling calculates the signed area of the filled primitive in window coordinate space. The signed area is positive when the window coordinates are in a counter-clockwise order and negative when clockwise. An app can use glFrontFace() to specify the ordering, counter-clockwise or clockwise, to be interpreted as a front-facing or back-facing primitive. An application can specify culling either front or back faces by calling glCullFace(). Finally, face culling must be enabled with a call to glEnable(GL_CULL_FACE); .

OpenGL uses your primitive's window space projection to determine face culling for two reasons. To create interesting lighting effects, it's often desirable to specify normals that aren't orthogonal to the surface being approximated. If these normals were used for face culling, it might cause some primitives to be culled erroneously. Also, a dot-product culling scheme could require a matrix inversion, which isn't always possible (i.e., in the case where the matrix is singular), whereas the signed area in DC space is always defined.

However, some OpenGL implementations support the GL_EXT_ cull_vertex extension. If this extension is present, an application may specify a homogeneous eye position in object space. Vertices are flagged as culled, based on the dot product of the current normal with a vector from the vertex to the eye. If all vertices of a primitive are culled, the primitive isn't rendered. In many circumstances, using this extension

from here

Also you can read here

Upvotes: 1

Related Questions