OpenGL far clipping when using frustum

Question

I'm using GLFW + OpenGL to try to make the "rotating cube". Although most of it is working, I have clipping in the far plane. I've tried changing values for frustum to very large numbers but it seems to have no effect.

int main(void) {
    if (!glfwInit()) exit(EXIT_FAILURE);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
    glfwWindowHint(GLFW_SAMPLES, 4); // 4x antialiasing
    GLFWwindow* window = glfwCreateWindow(640, 360, "3dTest", NULL, NULL);
    if (!window) {
        glfwTerminate();
        exit(EXIT_FAILURE);
    }
    glfwMakeContextCurrent(window);
    glfwSwapInterval(1);

    glClearColor(0.5f, 0.5f, 0.5f, 1.0f);   // Grey Background
    float rotqube = 0;
    while (!glfwWindowShouldClose(window)) {
        // clear color and depth buffer for new frame
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        // set up camera
        glViewport(0, 0, 640, 360);
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        glFrustum(-100.0, 100.0, -100.0, 100.0, 100.0, -100.0);

        // position camera
        glTranslatef(0.0f, 0.0f, -2.0f);    // Translate Into The Screen 2.0 Units
        glRotatef(rotqube, 0.0f, 1.0f, 0.0f);   // Rotate The cube around the Y axis
        glRotatef(rotqube, 1.0f, 1.0f, 1.0f);

        glBegin(GL_QUADS);      // Draw The Cube Using quads
        glColor3f(0.0f, 1.0f, 0.0f);    // Color Blue
        glVertex3f(1.0f, 1.0f, -1.0f);  // Top Right Of The Quad (Top)
        glVertex3f(-1.0f, 1.0f, -1.0f); // Top Left Of The Quad (Top)
        glVertex3f(-1.0f, 1.0f, 1.0f);  // Bottom Left Of The Quad (Top)
        glVertex3f(1.0f, 1.0f, 1.0f);   // Bottom Right Of The Quad (Top)
        ...
        glColor3f(1.0f, 0.0f, 1.0f);    // Color Violet
        glVertex3f(1.0f, 1.0f, -1.0f);  // Top Right Of The Quad (Right)
        glVertex3f(1.0f, 1.0f, 1.0f);   // Top Left Of The Quad (Right)
        glVertex3f(1.0f, -1.0f, 1.0f);  // Bottom Left Of The Quad (Right)
        glVertex3f(1.0f, -1.0f, -1.0f); // Bottom Right Of The Quad (Right)
        glEnd();            // End Drawing The Cube

        rotqube += 0.3f;

        //Swap buffer and check for events
        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    glfwDestroyWindow(window);
    glfwTerminate;
    exit(EXIT_SUCCESS);
    return 0;
}

This is what it looks like:

Answer 1

glFrustum(-100.0, 100.0, -100.0, 100.0, 100.0, -100.0);
                                               ^ wat

glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble nearVal, GLdouble farVal) :

Parameters:

• left , right :

  Specify the coordinates for the left and right vertical clipping planes.

• bottom , top :

  Specify the coordinates for the bottom and top horizontal clipping planes.

• nearVal , farVal :

  Specify the distances to the near and far depth clipping planes.
  Both distances must be positive.

Try something like 0.1 to 100.0 :

glFrustum(-100.0, 100.0, -100.0, 100.0, 0.1, 100.0);

Answer 2

You are not using a perspective projection at all. Your call

 glFrustum(-100.0, 100.0, -100.0, 100.0, 100.0, -100.0); 

has no effect whatsever , besides setting the GL_INVALID_VALUE error state.

As stated in the OpenGL 2.0 specification , section 2.11 "Coordinate Transformations":

For

 void Frustum( double l, double r, double b, double t, double n, double f ); 

the coordinates (l, b, −n)^T and (r, t, −n)^T specify the points on the near clipping plane that are mapped to the lower left and upper right corners of the window, respectively (assuming that the eye is located at (0, 0, 0)^T ). f gives the distance from the eye to the far clipping plane. If either n or f is less than or equal to zero , l is equal to r , b is equal to t , or n is equal to f , the error INVALID_VALUE results .

Trying to set a projection where one of the near or far planes lies behind the camera does not make the slightest sense, and would result in a lot of mathematical oddities during rendering (ie division by zero for vertices lying on the camera plane), hence it is not allowed.

Since this function fails with an error, you are using the identity matrix as the projection matrix, and do end up with a orthographic projection.

Now having written all that, I must make you aware that all of this is completely outdated. The fixed function pipeline and the GL matrix stack, including functions like glFrustum , glLoadIdendity , glRotate , and immediate mode rendering using glBegin / glEnd are deprecated and have been removed form core profiles of OpenGL almost a decade ago. It is a really bad idea to try to learn this stuff in 2018, and I strongly advice you to learn modern OpenGL instead.