Search code examples
c++openglglutfreeglut

Glut Ortho2D Projection not showing

I have a problem where I am able to see the desired object in perspective projection while not being able to see the object in orthogonal projection even when the camera is located in the same coordinates and looking at the same coordinate.

I know that the object is rendered correctly since it displays correctly in the perspective view like so:

Perspective projection

The Plane is located at the origin with height of 10, width of 50, and no depth. It's positioned at (0, -10, 0)

I would like to be able to view this in orthographic projection. The way I set it up is like this in my CameraManager class:

void CameraManager::UpdateCamera() {

    // exit in erroneous situations
    if (m_screenWidth == 0 && m_screenHeight == 0)
        return;

    switch (m_projectionType)
    {
    case TWO_DIMENSIONAL:
        SetupOrthographicCamera();

        break;
    case THREE_DIMENSIONAL:
        SetupPerspectiveCamera();

        break;
    default:
        break;
    }

    SetupModelView();

}

Then in my SetupOrthographicCamera() I do this:

void CameraManager::SetupOrthographicCamera() {

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    //float aspectRatio = m_screenWidth / (float)m_screenHeight;
    gluOrtho2D(-50, 50, -100, 100);

    /*
    m_cameraPosition = btVector3(0, 0, -1);

    glMatrixMode(GL_MODELVIEW);
    gluLookAt(m_cameraPosition[0], m_cameraPosition[1], m_cameraPosition[2], m_cameraTarget[0], m_cameraTarget[1], m_cameraTarget[2], m_upVector.getX(), m_upVector.getY(), m_upVector.getZ());
    */
}

This is my Perspective camera:

void CameraManager::SetupPerspectiveCamera() {

    // select the projection matrix
    glMatrixMode(GL_PROJECTION);
    // set it to the matrix-equivalent of 1
    glLoadIdentity();
    // determine the aspect ratio of the screen
    float aspectRatio = m_screenWidth / (float)m_screenHeight;
    // create a viewing frustum based on the aspect ratio and the
    // boundaries of the camera
    glFrustum(-aspectRatio * m_nearPlane, aspectRatio * m_nearPlane, -m_nearPlane, m_nearPlane, m_nearPlane, m_farPlane);
    // the projection matrix is now set
}

And this is my SetupModelView():

void CameraManager::SetupModelView() {

    // select the view matrix
    glMatrixMode(GL_MODELVIEW);
    // set it to '1'
    glLoadIdentity();

    // our values represent the angles in degrees, but 3D 
    // math typically demands angular values are in radians.
    float pitch = m_cameraPitch * RADIANS_PER_DEGREE;
    float yaw = m_cameraYaw * RADIANS_PER_DEGREE;

    // create a quaternion defining the angular rotation 
    // around the up vector
    btQuaternion rotation(m_upVector, yaw);

    // set the camera's position to 0,0,0, then move the 'z' 
    // position to the current value of m_cameraDistance.
    btVector3 cameraPosition(0, 0, 0);
    cameraPosition[2] = -m_cameraDistance;

    // create a Bullet Vector3 to represent the camera 
    // position and scale it up if its value is too small.
    btVector3 forward(cameraPosition[0], cameraPosition[1], cameraPosition[2]);
    if (forward.length2() < SIMD_EPSILON) {
        forward.setValue(1.f, 0.f, 0.f);
    }

    // figure out the 'right' vector by using the cross 
    // product on the 'forward' and 'up' vectors
    btVector3 right = m_upVector.cross(forward);

    // create a quaternion that represents the camera's roll
    btQuaternion roll(right, -pitch);

    // turn the rotation (around the Y-axis) and roll (around 
    // the forward axis) into transformation matrices and 
    // apply them to the camera position. This gives us the 
    // final position
    cameraPosition = btMatrix3x3(rotation) * btMatrix3x3(roll) * cameraPosition;

    // save our new position in the member variable, and 
    // shift it relative to the target position (so that we 
    // orbit it)
    m_cameraPosition[0] = cameraPosition.getX();
    m_cameraPosition[1] = cameraPosition.getY();
    m_cameraPosition[2] = cameraPosition.getZ();
    m_cameraPosition += m_cameraTarget;

    // create a view matrix based on the camera's position and where it's
    // looking
    //printf("Camera Position = %f, %f, %f\n", cameraPosition[0], cameraPosition[1], cameraPosition[2]);
    // the view matrix is now set
    gluLookAt(m_cameraPosition[0], m_cameraPosition[1], m_cameraPosition[2], m_cameraTarget[0], m_cameraTarget[1], m_cameraTarget[2], m_upVector.getX(), m_upVector.getY(), m_upVector.getZ());

}

I'm not sure what I am missing.

Solution

  • If the object isn't rendered perpendicular in an ortho view, you may see nothing (as the camera is in a different z-axis plane). Also, are you looking at it from behind with backface culling on? Then you will never see it. I would try explicitly disabling this. I can think of more reasons...z-axis is inverted in OpenGL (negative is into the screen from the typical Euclidean perspective w/respect to other axes, you may be too close w/clipping ranges provided, etc. Sorry for vagueness, just some things you may have overlooked that may help you.)