How to prevent triangles in OpenGL from rendering on top of triangles in front of themselves

Question

I've been working with OpenGL using the OpenTK library for .NET, writing my own engine. I placed 3 different objects, one spinning cube and 2 adjacent cubes. Everything seemed to work fine until I changed the color of the quad on top of the objects.

I'm rendering cubes with a green top, on the left the block on the back is being rendered over the block in the front. I can't seem to find out where I'm going wrong with this, when the camera is set to look from the other side it renders correctly.

The following is the related code in classes with irrelevant or unrelated methods, properties and attributes omitted:

GameState.cs

class GameState : State
{
    // TEMP: Test Block
    SimpleBlock block;

    int i = 0;
    public override void Render()
    {
        base.Render();

        // Set OpenGL Settings
        GL.Viewport(0, 0, 1024, 768);
        GL.Enable(EnableCap.CullFace);

        // Reset the Matrices
        Matrices.ClearMatrices();

        // Set Camera Settings (Field of view in radians)
        Matrices.ProjectionMatrix = Matrix4.CreatePerspectiveFieldOfView((float)Math.PI / 2, (1024.0f / 768.0f), 1, 1000);

        // Create the Camera
        // this has to be in reverse
        Matrix4 viewMatrix = Matrix4.CreateRotationX((float)Math.PI/8);
        viewMatrix = viewMatrix.Translate(0, -2, -4);

        // Multiply it with the ModelView (Which at this point is set to a value that we can just use = and it has the same result)
        Matrices.ModelViewMatrix = viewMatrix;

        // Render the Block
        Matrices.Push();

        Matrices.ModelViewMatrix = Matrices.ModelViewMatrix.Translate(2, 0, 0);
        Matrices.ModelViewMatrix = Matrices.ModelViewMatrix.Translate(0.5f, 0, 0.5f);
        Matrices.ModelViewMatrix = Matrices.ModelViewMatrix.Rotate(0, i / 40.0f, 0);
        block.Render();

        Matrices.Pop();

        // Render the Block Again Twice
        Matrices.Push();

        Matrices.ModelViewMatrix = Matrices.ModelViewMatrix.Translate(-2, 0, 0);
        Matrices.ModelViewMatrix = Matrices.ModelViewMatrix.Translate(0.5f, 0, 0.5f);
        block.Render();

        Matrices.ModelViewMatrix = Matrices.ModelViewMatrix.Translate(0, 0, -1);
        block.Render();

        Matrices.Pop();

        // Increment Rotation Test Variable
        i++;
    }
}

SimpleBlock.cs

class SimpleBlock : IBlock
{
    public void Render()
    {
        // Send the Shader Parameters to the GPU
        Shader.Bind();
        Shader.SendMatrices();

        // Begin Rendering the Polys
        GL.Begin(BeginMode.Triangles);

        // Front Quad
        Shader.SetColor(Color4.SaddleBrown);
        GL.Normal3(0, 0, 1);
        GLUtils.QuadVertices(
            new Vector3(-0.5f, 1, 0.5f),
            new Vector3(-0.5f, 0, 0.5f),
            new Vector3( 0.5f, 1, 0.5f),
            new Vector3( 0.5f, 0, 0.5f));

        // Right Quad
        GL.Normal3(1, 0, 0);
        GLUtils.QuadVertices(
            new Vector3(0.5f, 1,  0.5f),
            new Vector3(0.5f, 0,  0.5f),
            new Vector3(0.5f, 1, -0.5f),
            new Vector3(0.5f, 0, -0.5f));

        // Back Quad
        GL.Normal3(0, 0, -1);
        GLUtils.QuadVertices(
            new Vector3( 0.5f, 1, -0.5f),
            new Vector3( 0.5f, 0, -0.5f),
            new Vector3(-0.5f, 1, -0.5f),
            new Vector3(-0.5f, 0, -0.5f));

        // Left Quad
        GL.Normal3(-1, 0, 0);
        GLUtils.QuadVertices(
            new Vector3(-0.5f, 1, -0.5f),
            new Vector3(-0.5f, 0, -0.5f),
            new Vector3(-0.5f, 1,  0.5f),
            new Vector3(-0.5f, 0,  0.5f));

        // Bottom Quad
        GL.Normal3(0, -1, 0);
        GLUtils.QuadVertices(
            new Vector3(-0.5f, 0,  0.5f),
            new Vector3(-0.5f, 0, -0.5f),
            new Vector3( 0.5f, 0,  0.5f),
            new Vector3( 0.5f, 0, -0.5f));

        // Top Quad
        Shader.SetColor(Color4.Green);
        GL.Normal3(0, 1, 0);
        GLUtils.QuadVertices(
            new Vector3(-0.5f, 1, -0.5f),
            new Vector3(-0.5f, 1, 0.5f),
            new Vector3(0.5f, 1, -0.5f),
            new Vector3(0.5f, 1, 0.5f));

        // Done!
        GL.End();
    }
}

BasicFragment.glfs

#version 130

// MultiColor Attribute
in vec4 multiColor;

// Output color
out vec4 gl_FragColor;

void main()
{
    // Set fragment
    gl_FragColor = multiColor;
}

BasicVertex.glvs

#version 130

// Transformation Matrices
uniform mat4 ProjectionMatrix;
uniform mat4 ModelViewMatrix;

// Vertex Position Attribute
in vec3 VertexPos;

// MultiColor Attributes
in vec4 MultiColor;
out vec4 multiColor;

void main()
{
    // Process Colors
    multiColor = MultiColor;

    // Process Vertex
    gl_Position = ProjectionMatrix * ModelViewMatrix * vec4(VertexPos.x, VertexPos.y, VertexPos.z, 1);
}

MainWindow.cs

// Extends OpenTK's GameWindow Class
class MainWindow : GameWindow
{
    public MainWindow()
        : base(1024, 768, new GraphicsMode(32, 0, 0, 4))
    {
        this.Title = "Trench Wars";
        this.WindowBorder = WindowBorder.Fixed;
        this.ClientSize = new Size(1024, 768);

        // Set VSync On
        this.VSync = VSyncMode.Adaptive;
    }

    protected override void OnRenderFrame(FrameEventArgs e)
    {
        base.OnRenderFrame(e);

        // Clear Screen
        GL.ClearColor(Color4.CornflowerBlue);
        GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);

        // Do State-Specific Rendering
        StateEngine.Render();

        // Pull a Wicked Bluffing move in Poker
        GL.Flush();

        // Swap Buffers
        this.SwapBuffers();
    }
}

Answer 1

It seems like you did forget to enable depth testing. glEnable(GL_DEPTH_TEST) before rendering the geometry is your friend (or given the language bindings you're using GL.Enable(EnableCap.DepthTest); ).