068-opengl.qxd 28.03.

2001 9:01 Uhr Seite 68

PROGRAMMING OPENGL

OpenGL Course, Part 1

HELLO 3D
WORLD THOMAS G E RUGE

Here we present the first in a series

covering an OpenGL programming
course. Using simple, easy-to-understand
examples, we will lead you into the
exciting and complex world of 3D
programming.

After a broad overview and a little bit of theory, the breathed life into Mesa, and the library has since
first part of the course shows how OpenGL been further developed by him and many other
programs are constructed, using Hello World as an developers all over the world.
example.
OpenGL was originally developed by SGI and in Principles
ages long past was called IrisGL. The primary aim of
developing IrisGL was to develop a programmable OpenGL is always in a defined state, which is set by
interface for the graphics workstations of SGI. This condition variables; this means that OpenGL is a
programmable interface was initially intended to be State Machine. An example of a condition variable
hardware-independent, future-proof and to meet is the current colour with which the individual
the special demands of 3D graphics programming. primitives are rendered (drawn). These are set using
It soon emerged that IrisGL is not only of the command glColor3f(red, green, blue) and this
interest for SGI workstations, but can also help then applies for all drawn objects until a second
other workstations to get up and running in terms glColor3f(..) command changes the colour.
of graphics. The OpenGL Architectural Review All objects under OpenGL must be composed
Board (ARB) was founded in 1992 by major from 10 different primitives. The instruction set in
manufacturers of graphics workstations such as SGI, the library comprises some 200 commands, all
Sun, Hewlett-Packard and others. The task of the starting with gl. OpenGL does in fact contain all the
ARB is to guide the further development of OpenGL simple operations for programming interactive 3D
and introduce new functionalities in later versions. graphics, but it cannot do real 3D bodies such as
OpenGL has now become the commonest cylinders and dice, only points, lines and polygons.
hardware-independent interface for 3D All complex bodies have to be constructed by
programming. the 3D developer out of simple primitives. To make
The latest version is OpenGL 1.2. There are the work a bit simpler for the applications
OpenGL implementations for Irix, Solaris, HP-UX, developer, hard-working 3D experts have developed
Linux, Windows and a few other operating systems. some programming libraries, a few of which we
In the Linux world the OpenGL clone Mesa is the shall be introducing in the course of this series of
most common one. The American Brian Paul articles. The two most important expansions are

68 LINUX MAGAZINE 8 · 2001

068-opengl.qxd 28.03.2001 9:01 Uhr Seite 69

OPENGL PROGRAMMING

3D transformations

The elementary transformations in 3D graphics Rotations about the three axes of the co-ordinate grid by
programming are translation, rotation and scaling of points the angle a:
in 3D space. So that these operations are shown in a
standard format and can be programmed easily,  cos α 0 − sin α 0
1 0 0 0 
transformations take the general form: b = M • a. So as to   0 1 0 0
0 cos α sin α 0 R( e y , α ) =  
display not only rotations or scalings, but also translations R( e x , α ) =    sin α 0 cos α 0
 0 − sin α cos α 0  
in this linear form, a homogenous co-ordinate xw is    0 0 0 1
0 0 0 1
inserted into the space of the transformations. In
mathematical jargon, we have embedded the affine space
 cos α sin α 0 0
R3 in the projective space P(R4) and can thereby display any 
− sin α cos α 0 0
affine figure (transformation) through a matrix R( e z , α ) =  
 0 0 1 0
multiplication.  
 0 0 0 1

 ax 
a 
a= y Rotations about any axis can be assembled from rotations
 az 
  about the co-ordinate axes:
 aw 

 bx 
b  R(p , α ) = R( e x , α ) ⋅ R( e y , α ) ⋅ R( e z , α )
b= y
 bz 
 
bw 
 t xx t xy t xz t xw 

t yx t yy t yz t yw 
M= 
 t zx t zy t zz t zw  Rotation about any point
 
 t wx t wy t wz t ww 
The rotation matrices described above define rotations
The three transformations referred to above then look like about the origin, but often an object needs to be rotated
this: about a different point u. To do this, we link together
translations and rotation in such a way that the point about
Translations which the rotation takes place serves as origin. This means
that we make a change to the co-ordinate system:
We can displace objects in space at will with translations

1 0 0 tx   ax   ax + tx  b = T(u) ⋅ R(p ,α ) ⋅ T(u) −1 ⋅ a

  
0 1 0 ty   ay   ay + ty 
()
b = T t a =
0
⋅  =
0 1 tz   az   az + tz 
     
0 0 0 1  1   1 

Scalings
Scalings make objects bigger and smaller

s x 0 0 0  a x   s x ⋅ a x  Figuratively speaking, we have first displaced the point a by

  
0 sy 0 0  a y   s y ⋅ a y  the vector -u then rotated it by a and finally pushed the
b = Sa =   ⋅ =
0 0 sz 0  a z   s z ⋅ a z 
      point back again.
0 0 0 1  1   1 
In graphics programming the programmer needs such
assembled matrices over and over again, so that the 3D
objects appear where they belong. OpenGL relieves the
Rotations about the origin developer of a great deal of work in the creation and
Rotations change the orientation of objects. If we want to treatment of transformation matrices.
rotate the point a about an axis p by the angle a, the After all the transformations we finally want to work
associated transformation matrix R(p,a) in its commonest against with three-dimensional co-ordinates:
form looks like this: Where aw = 0, the point lies at infinity.

 rxx rxy rxz 0

  ax / aw 
r ryy ryz 0
R(p ,α) =  yx  
a3 =  a y / a w 
 rzx rzy rzz 0 
   a / a 
 0 0 0 1  z w

8 · 2001 LINUX MAGAZINE 69

068-opengl.qxd 28.03.2001 9:01 Uhr Seite 70

PROGRAMMING OPENGL

How the output of using, among others, Nurbs (Non-uniform-rational

the program HelloOpenGL
ought to look B-Splines). GLUT is an operating system-
independent tool for simpler handling of OpenGL
windows and provides the application developer
with routines to respond to user events from the
mouse or keyboard.
Anyone wanting to become a real 3D graphics
expert will have to overcome a few mathematical
obstacles. For a better understanding, some
knowledge of linear algebra is useful and terms such
as vectors or matrices should not be a complete and
utter mystery to the reader. The most important
terms that crop up time and time again in OpenGL
are set out in the 3D transformations boxout.
Anyone with a yen for higher mathematics can learn
more with the Open GL Programming Guide
Installing the OpenGL clone Mesa doesn’t take
GLU (OpenGL Utility Library) and GLUT (OpenGL much. In most distributions Mesa is also installed by
Utility Toolkit). default. Those users who have previously had no
GLU makes it easier to create projection OpenGL/Mesa environment on their computers, or
calculations and to construct complex surfaces, want to use the latest version of Mesa can find the
Listing 1: HelloOpenGL.c
#include /stdio.h>
#include /stdlib.h>

#include /GL/glut.h>

void DrawScene(void)
{
//set background colour (dark red)
glClearColor (0.5, 0.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT);

// Set colour of pentagon, (blue)

glColor3f(0.0, 0.1, 1.0);

//Polygon progression of the pentagon

glBegin(GL_POLYGON);
glVertex2f(-0.5, -0.5);
glVertex2f(-0.5, 0.5);
glVertex2f( 0.5, 0.5);
glVertex2f( 0.8, 0.0);
glVertex2f( 0.5, -0.5);
glEnd();

//draw previous GL commands

glFlush();
}

int main(int argc, char *argv[])

{
// initialises GLUT
glutInit(argc, argv);
// initialise output window (Single Buffer, RBG colour model)
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
// set window position and size
glutInitWindowPosition (100, 100);
glutInitWindowSize (500, 500);
// create window
glutCreateWindow (argv[0]);

// Set callback function to draw GL object

glutDisplayFunc(DrawScene);
// Main loop
glutMainLoop();

return EXIT_SUCCESS;
}

70 LINUX MAGAZINE 8 · 2001

068-opengl.qxd 28.03.2001 9:01 Uhr Seite 71

latest binary and source packets at the Mesa

homepage.

Hello OpenGL with the OpenGL

Utility Toolkit
The first program has not much to do with 3D
as yet, as OpenGL can in fact also draw two-
dimensional objects – and that’s enough for a start.
To simplify window management we are making
use of the OpenGL expansion GLUT. OpenGL puts
together all 2D and 3D objects from primitives and
AD
in the first program example we are simply going to
draw an arrow in an OpenGL window.
The program (Listing: Hello-OpenGL.c) consists
of the functions DrawScene(..) and main(..).main (..)
contains only calls from GLUT and helps us to draw
the graphics, which are created in DrawScene(..), in DrawScene() specifies that the graphics buffer is
a window. cleared with a dark red.
The first command glutInit(argc, argv) initialises glClear(GL_COLOR_BUFFER_BIT) performs the
the GLUT library and takes over X-parameters such clearing of the graphics buffer. The next command
as -display or -iconic. With glColor3f(0.0, 0.1, 1.0) makes sure that henceforth
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB) we all subsequent objects are coloured blue. The
are agreeing that our OpenGL window uses only definition of the arrow starts with
one graphics buffer and uses RGB as the colour glBegin(GL_POLYGON). GL_POLYGON firstly
model. Buffer is that area of memory in which specifies that the following co-ordinates are to be
drawing takes place. GLUT_SINGLE tells the interpreted as a closed polygon progression.
function that we only want to use one buffer. The The following glVertex2f(x, y) commands define
memory that is visible on the monitor and the area the position of the corners of the polygon.
in which we are drawing are identical. This means glVertex2f defines the arrow in only two
that the onlooker sees how the individual OpenGL dimensions, and in order to describe the object with
objects are drawn. three-dimensional co-ordinates, glVertex2f(x, y)
glutInitWindowPosition(100,100) sets the would just have to be replaced by glVertex3f (x, y
OpenGL window to the position (x = 100, y = 100) ,z); glEnd() ends the definition of the arrow.
of the X-server. glutInitWindowSize(500,500) sets With glFlush we ensure that all previous
the size of the OpenGL window. The window is OpenGL commands are executed, in our example
created by the command the buffer is first coloured in red, then the arrow is
glutCreateWindow(argv[0]), but is not yet visible. As drawn. After the program stops, it is time for the
the result of the argument argv[0] the window compilation:
receives as name the program invocation.
gcc -I . -c HelloOpenGL.c
The instruction glutDisplayFunc (DrawScene)
ensures that every time the OpenGL window is to gcc -o HelloOpenGL HelloOpenGL.o \
be redrawn, the callback function DrawScene() is -lGL -lglut -lGLU
called up. Events which make such a redrawing
necessary are for example the displacement, When executing ./HelloOpenGL a window with
enlargement or reduction in size of the window and a blue arrow on a red background should be visible
the explicit call up of the function (see Figure).
glutPostRedisplay(). The first example is, nothing particularly
The main loop is invoked using glutMainLoop(). spectacular and nor is a 3D scene visible, but it
Within this loop the OpenGL program responds to already includes all the important components of an
all possible user events and intercepts mouse and OpenGL program. GLUT has firstly defined which
keyboard events. characteristics the OpenGL window possesses and
Thanks to the seven GLUT commands, we no how it responds to events. We have then defined
longer need to bother about making any changes the appearance of the scene within DrawScene().
whatsoever to our window or about actions by the
user. GLUT takes over these tasks. The programmer A full 3D pot
only has to write the callback functions, so that their
program responds as required to external events. We The sample program Teapot.c (Listing 2), with the
can thus now concentrate completely on the actual aid of the GLU library, paints a three-dimensional
OpenGL programming which occurs in DrawScene(). teapot and responds to events from mouse and
The command glClearColor(0.5, 0.0, 0.0, 0.0) in keyboard. The program consists, apart from the
068-opengl.qxd 28.03.2001 9:01 Uhr Seite 72

PROGRAMMING OPENGL

main function main(..) and the initialisation function glutInitDisplayMode(GLUT_DOUBLE |

myinit(), of the callback functions mouse(..), GLUT_RGB | GLUT_DEPTH) initialises the OpenGL-
motion(..), keyb(..), recalcModelPos() and window with foreground and background buffer
DrawScene(). In comparison with the first sample and a depth buffer. The foreground buffer is shown
program main() uses three new callback functions in the OpenGL window. Drawing is done in the
and evaluates the depth information. invisible background buffer. When rendering is

Listing 2:Teapot.c
#include <stdio.h> {
#include <stdlib.h> glLoadIdentity();
glTranslatef(posx, posy, posz);
#include <GL/glut.h> glRotatef(xangle, 1.0, 0.0, 0.0);
glRotatef(yangle, 0.0, 1.0, 0.0);
// Condition variable }
// mouse movement
int mousemotion; void DrawScene(void)
int mousex, mousey; {
// Delete buffers
// Initialise model orientation glClearColor (0.5, 0.0, 0.0, 0.0);
GLfloat xangle = 4; /* for rotation */ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
GLfloat yangle = 120;
//Model position // Calculation of new model coordinates
GLfloat posx = 0, posy = 0, posz = 0; recalcModelPos();
// Teapot painting
//Callback Function: Reaction of mouse clicks glutSolidTeapot(0.6);
void mouse(int button, int state, int x, int y)
{ // Foreground and background buffer change
if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN) { glutSwapBuffers();
mousemotion = 1; }
mousex = x;
mousey = y; //Initialising function
} void myinit()
if (button == GLUT_LEFT_BUTTON && state == GLUT_UP) { {
mousemotion = 0; GLfloat light_position[] = {0.0, 0.0, -1.0, 1.0 };
}
} //First GL-Light fall

//Callback Function: Reaction of mouse movement glLightfv( GL_LIGHT0, GL_POSITION, light_position );

void motion(int x, int y)
{ glEnable(GL_LIGHT0);
if (mousemotion) {
xangle = xangle - (y - mousey); //Z-buffer activation
yangle = yangle - (x - mousex); glDepthFunc(GL_LEQUAL);
mousex = x; glEnable(GL_DEPTH_TEST);
mousey = y; }

// Draw a new display int main(int argc, char *argv[])

glutPostRedisplay(); {
} //GLUT initialisation window
} glutInit(&argc, argv);
glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
//Callback Function: Reaction of keypress glutInitWindowSize (500, 500);
void keyb( unsigned char keyPressed, int x, int y ) glutInitWindowPosition (100, 100);
{ glutCreateWindow (argv[0]);
switch( keyPressed ) {
// Initialisation
case ‘l’: myinit();
// Light activation
glEnable(GL_LIGHTING); //Callbacks set: Reaction of mouse clicks,
glutPostRedisplay(); movements and keyboard activity
break; glutMouseFunc(mouse);
case ‘o’: glutMotionFunc(motion);
// Light deactivation glutKeyboardFunc(keyb);
glDisable(GL_LIGHTING);
glutPostRedisplay(); //Callback for drawing the GL-Function
break; glutDisplayFunc(DrawScene);

} glutMainLoop();
}
//new Model position calculation return EXIT_SUCCESS;
void recalcModelPos(void) }

72 LINUX MAGAZINE 8 · 2001

068-opengl.qxd 28.03.2001 9:01 Uhr Seite 73

OPENGL PROGRAMMING

complete, we swap foreground and background could also be omitted. These displacements will also
buffers, so the image just drawn can be seen. be discussed later on in this series of articles.
The depth or z-buffer ensures that areas With glRotatef(xangle, 1.0, 0.0, 0.0) and
covered by other areas cannot be seen. In the z- glRotatef(yangle, 0.0, 1.0, 0.0) we multiply the
buffer each pixel in the OpenGL window is assigned matrix again with rotations about the x and the y-
a z-value. If a new pixel is to be set during axis. This matrix is then used later in DrawScene(). In
rendering, a check is made as to whether its z-value this function, the buffer must first be cleared, as
is greater than that of a pixel that has already been well as the z-buffer, so as not to receive any
set. If so, the new pixel comes before the old one incorrect depth information. Next, with
and can be drawn, otherwise not. recalcModelPos() the matrix is calculated with the
If all parameters have been set and if the new model co-ordinates. This matrix is then to be
OpenGL window has been created, an initialisation multiplied by all points of the teapot.
function myinit() is called up. This function was The teapot is created, as the result of the
introduced for better legibility of the program. instruction glutSolidTeapot(0.6), with a size 0.6.
The next step is to set the diverse callback There is nothing behind this command but the
functions. So glutMouseFunc(mouse) sets the placing of polygons, similar to the way we called up The author
function to be called up when pressing or releasing the arrow in the first program with glVertex2f. Thomas G E Ruge has been a
a mouse button. glutMotionFunc(motion) sets the GLUT has more fixed, pre-defined objects. If you’d converted Linux fan since
callback function for mouse movements. So that like to experiment with other objects, try out Kernel 0.98 and is interested in
the program also responds to keyboard events, we glutWireTorus(..) or glutSolidDodecahedron(..). everything to do with 3D or
also call up glutKeyboardFunc(keyb). The rest of The teapot was drawn in the invisible virtual reality. He has been
main() is equivalent to HelloOpenGL. background buffer and appears with the command driving forward the technical
glutSwapBuffers() in the foreground. In the construction of the Virtual
Callback functions in detail initialisation function myinit() we create, using Reality Laboratory in the
glLightfv(GL_ LIGHT0, GL_POSITION, research department of
In void mouse(int button, int state, int x, int y) the light_position), a light at the position (0, 0, -1) and Siemens AG for nearly six years
position of the mouse in the OpenGL window is switch it on using glEnable(GL_ LIGHT0). and is involved in the
queried, buffered in x and y and registers whether the The last two commands set the z-buffer mode. possibilities of high-end VR
left mouse button was pressed. The function makes a glDepthFunc(GL_LEQUAL) draws only pixels whose with Linux clusters.
note with mousemotion of the condition of the left z-value is less than that of the pixel already drawn.
mouse button and takes it into account later in the glEnable(GL_DEPTH_TEST) activates the z-buffer
function motion(int x, int y). The function motion(..) calculation. Finally, the compilation:
calculates, from the current mouse position (x,y) and
gcc -I . -c Teapot.c
the mouse position at the time when the left mouse
gcc -o Teapot Teapot.o -lGL \
button has been pressed (mousex, mousey), the angle -lGL -lglut -lGLU
about which the object should be rotated (xangle,
yangle). The call up of glutPostRedisplay() ensures that If everything fits, when you call up teapot, as in
the scene is actually redrawn and by calling up the picture, a white teapot should appear, which
DrawScene() the new position of the teapot is responds to the input of the letters l and o and to
calculated in recalcModelPos(). mouse actions.
The callback function keyb(unsigned char
keyPressed, int x, int y) responds to the two letters l What’s next?
and o. When the user enters l the light calculation is
activated with glEnable(GL_LIGHTING), o That’s the end of our journey into the realms of
deactivates the light again with the aid of OpenGL and GLUT. We have looked at the options
glDisable(GL_LIGHTING). These three callback for responses to the various inputs by the user and
functions cover all events that the program has to conjuring and moving polygons on the screen. The
process. next installment will be about the primitives of
The next function recalcModelPos() is called up OpenGL, how the world can become a bit more
by DrawScene() to calculate the new position of the colourful and how edges can be smoothed with the
teapot. Generally every transformation (rotation, aid of normal vectors. ■
displacement, scaling) can be described using four-
dimensional matrix-vector multiplications. This is Info
explained in more detail in the 3D transformations
boxout. OpenGL uses the matrix stack for such Woo, Neider, Davis, Shreiner: Open GL Programming Guide 3rd ed., Verlag
multiplications. Addison Wesley Longman Inc.,1999
In recalcModelPos() with glLoadIdentity() the J. Encarnacao : Graphische DV 1, Oldenbourg Verlag GmbH
identity matrix is loaded onto the stack. glTranslatef OpenGL homepage: http://www.opengl.org
(posx, posy, posz) multiplies this matrix by a matrix Mesa homepage: http://www.mesa3d.org
which displaces an object by the co-ordinates posx,
posy, posz. But since they all contain 0 this step ■

8 · 2001 LINUX MAGAZINE 73