A simple helloworld question

I assume this would be a easy question but I just could not figure it out.

There is a hello.c in the red “programming guide” book. I’ve copied the code as below. My question is:

The program is not using gluLookAt(), therefore the camera should be at the default position, i.e. (0, 0, 0). But the rectangular is also at z=0 plane. How would this work? If the camera is placed right on the object plane, how could camera “see” the object? But I ran the program and it did show the rectangular. If I use prospective view, i.e. change
glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0);
glFrustum(0.0, 1.0, 0.0, 1.0, -1.0, 1.0);

It still shows the rectangular but the position and size is different.

I am kinda confused. Did I miss anything?


#include <GL/glut.h>

void display(void)
/* clear all pixels  */

/* draw white polygon (rectangle) with corners at
 * (0.25, 0.25, 0.0) and (0.75, 0.75, 0.0)  
   glColor3f (1.0, 1.0, 1.0);
      glVertex3f (0.25, 0.25, 0.0);
      glVertex3f (0.75, 0.25, 0.0);
      glVertex3f (0.75, 0.75, 0.0);
      glVertex3f (0.25, 0.75, 0.0);

/* don't wait!  
 * start processing buffered OpenGL routines 
   glFlush ();

void init (void) 
/* select clearing color 	*/
   glClearColor (0.0, 0.0, 0.0, 0.0);

/* initialize viewing values  */
   glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0);

 * Declare initial window size, position, and display mode
 * (single buffer and RGBA).  Open window with "hello"
 * in its title bar.  Call initialization routines.
 * Register callback function to display graphics.
 * Enter main loop and process events.
int main(int argc, char** argv)
   glutInit(&argc, argv);
   glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
   glutInitWindowSize (250, 250); 
   glutInitWindowPosition (100, 100);
   glutCreateWindow ("hello");
   init ();
   return 0;   /* ANSI C requires main to return int. */
You can't put -1.0 for the znear
Needs to be >0.0
and needs to be < zfar
glFrustum(0.0, 1.0, 0.0, 1.0, -1.0, 1.0);

With  glOrtho(0.0, 1.0, 0.0, 1.0, -1.0, 1.0);

the rectangle's z is transformed to 0.5
on the 0.0 to 1.0 scale.

Thanks for your reply.

I tried glFrustum(0.0, 1.0, 0.0, 1.0, 0, 1.0) and got same result as what glFrustum(0.0, 1.0, 0.0, 1.0, -1.0, 1.0) got. Maybe OpenGL set near to 0 when near < 0? Also, I think I still didn’t get why the camera can see the rectangular when the camera is on the plane of the rectangular.

For the glOrtho call, I don’t quite understand why the rectangular’s z was transformed to 0.5. Could you please explain more? How does this transform happen?


When using glOrtho, you get a parallel projection. The camera behaves as if it was infinitely far away. So you also see everything “behind” the camera, as long as it’s between near and far.

You set near to -1 and far to 1, so everything that is in this range is visible. The depth gets linearly interpolated between 0 and 1 in this range. So anything at -1 would get depth 0, z=1 would get depth 1. And in your case the rectangle at z=0 gets depth 0.5, because it’s exactly half way between near and far.

With glFrustum, near=0 is illegal, it produces a division by zero. near<0 is illegal too, but it does not produce a division by zero. I never tried it, but I expect it just produces a junk result. You’ll see the drawing, but it will be wrong.

Isn’t positive z-axis directed towards viewer (providing x directed right and y directed up)? If so, “near” value should be greater than “far”.

I’m quite confused with this matter. Can you clear this up, please?