OpenGL help session

1. Introduction

• Why OpenGL?

  • Stanford-centric history:

    • Invented "Geometry Engine" in 1981 at Stanford in CSL
    • Stanford Professor Jim Clark started SGI with 7 Stanford colleagues (he also founded Netscape, Healtheon, myCFO, and others)
    • "Graphics Library" (IRIS GL) was created as a software interface to SGI hardware
    • OpenGL specification was written by Mark Segal and Kurt Akeley (Stanford student) in 1992, and it was inspired by IRIS GL
    • Today, OpenGL is governed by the OpenGL Architecture Review Board (ARB)

  • Relatively portable – runs on Macs, MS Windows, Unix, Linux, BeOS, OS/2, etc.

  • Industry standard (like Microsoft's DirectX)

  What does OpenGL do?

  • Draw stuff "onscreen", in 2D and 3D

• What doesn't it do?

  • Windows, menus, define what "onscreen" is, share the display, input devices

• GLUT as a windowing interface

  • Makes up for most of the important things in the "What doesn't it do" section

  • OpenGL + GLUT + {insert your windowing system here} make a pretty complete combination.

  • OpenGL/GLUT app should be portable across the various Unix platforms and Win32

• Overview of libraries

  

  (From diagram in OpenGL course notes from Siggraph 97)

2. GLUT overview

• Function names begin with "glut"

• Mostly used for one-time initialization

See sample code in /usr/class/cs248/assignments/assigment3/example/simple

Example:

  // GLUT Window Initialization:
  glutInit(&argc, argv);
  glutInitWindowSize(g_Width, g_Height);
  glutInitDisplayMode( GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
  glutCreateWindow("CS248 GLUT example");

• Callback model (like xsupport)

Example:

  // Register callbacks:
  glutDisplayFunc (display);
  glutXXXXXXXFunc(callbackName);
  ...
  glutMainLoop();

• More info:

GLUT documentation at http://www.opengl.org/developers/documentation/glut/index.html

3. OpenGL overview

• Function names prefixed with "gl"

• Function names may have suffixes indicating the data types

  • Number of Components	Data Type	Vector
    2 - (x, y)	b - byte	omit "v" for scalar form
    3 - (x, y, z)	ub - unsigned byte	(e.g. glVertex2f(x, y); )
    4 - (x, y, z, w)	s - unsigned short
    	us - unsigned short
    	i - int
    	ui - unsigned int
    	f - float
    	d - double

    (Table from Siggraph 97 OpenGL Course Notes.)

  • Example: glVertex3fv(vertices)

• glBegin, glEnd to specify polygons

• glColor* specifies the current color (used for subsequently defined vertices)

• glNormal* specifies the current normal

• glVertex* specifies vertices of polygons

• State management

  • many functions apply to current state, which is contained in a glXContext (or equivalent in Win32)

  • have lots of other functions to select/modify current state (e.g. glEnable, glDisable)

  • glGet{Boolean, Double, Float, Integer}v functions are used to get the state

  • glGetError

4. Rendering in OpenGL – basic 2D

   • How to get a basic 2D drawing onscreen

     Clearing screen – glClearColor, glClear

     Viewport – glViewport

     Orthographic projection – glOrtho

     Make polygons with glBegin/glEnd

     Specifying colors – glColor*

     Specify vertices – glVertex* in side a pair of glBegin/glEnd

     If double buffering, swap the front and back buffers – glSwapBuffers (or glutSwapBuffers)

     • To avoid seeing partially drawn image use two buffers: front and back.

   • front buffer is displayed

   • back buffer is written into

5. Rendering in OpenGL 3D

Overview of pipeline

Viewing

Transformation, 2 matrices
Backface culling - no need to draw hidden facets
Clipping - to viewing frustum
Depth test

Lighting

Diffuse, specular, ambient
Multiple lights
Depends on normal vectors -- glNormal

Shading

Based on light position, materials, normals
Calculated for each vertex, interpolated to fill polygon (Gouraud shading)

Transformation model

object (world) coordinates

=> modelview

viewing (positioning and aiming camera): gluLookAt

model: glRotate, glTranslate, glScale

=> eye (camera) coordinates

=> projection (fov, projection: glOrtho, gluPerspective, glFrustum)

=> clip coordinates

=> perspective division (by w)

=> normalized device coordinates

=> viewport transformation (size and position of image) 

=> screen coordinates.

glLoadIdentity - set current matrix to identity

(most commands: current matrix * specified matrix)

glMatrixMode - chooses between modelview and projection matrix stacks.

General transformations: glMultMatrix, glLoadMatrix

Note: matrix m[4][4] - C array.  Then m[i][j] - ith column and jth row of OGL transformation matrix.  C stores arrays in row-major order, while OpenGL expect column-major matrices.

glPushMatrix, glPopMatrix

Rendering primitives

Vertices, polygons, glBegin/glEnd as before

Z buffer (hidden surface removal)

glClear(GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);

clear depth buffer when clearing frame buffer

glEnable (GL_DEPTH_TEST), glDepthFunc

Lighting and Shading

Per vertex color calculation based on lighting conditions.

Uses shading normals - possibly different from geometric normals.

Shading model - GL_FLAT, GL_SMOOTH

Model - local lighting.

Light sources

To use:

Set up light sources - glLightfv - position diffuse

Set up materials - glMaterialfv - diffuse, specular, ambient, shininess

Specify geometry with normals - glNormal3f.

glShadeModel(GL_SMOOTH);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);

Texture mapping

Enabling texture modes

Enable texturing - glEnable (GL_TEXTURE_2D)

Bind texture to context, make it current (avoid downloading texture multiple times) - glBindTexture

Download texture - glTexImage2D

Alternatively, build mipmaps and load the texture - gluBuild2DMipmaps

Set filtering options - glTexParameteri

Specifying texture coordinates

By hand glTexCoord*

Automatically generate texture coordinates based on the position of each vertex- glTexGen

6. Performance considerations

Triangle strips - good

glBegin(GL_TRIANGLE_STRIP);

Vertex arrays - often good

store vertex related data (coordinates, colors, normals, etc.) into few arrays

use just few function calls - reduces overhead.

To use:

- enable arrays - glEnableClientState

- store data - glVertexPointer, glColorPointer, etc.

- draw geometry -

glArrayElement (all arrays) or glVertex*v, glColor*v, etc. - for individual arrays

glDrawElements, glDrawRangeElements


glBegin(GL_TRIANGLES);
glArrayElement(2);
glArrayElement(3);
glArrayElement(4);
glEnd();

Display lists - sometimes good

glNewList(1, GL_COMPILE);
/* Draw the model */
glEndList();

/* Later on... */
glCallList(1);

Immediate mode (default) - primitives are sent to display right away.

Retained mode - primitives are stored and can be redisplayed with different state.

Allows the OpenGL implementation to "precompile" the OpenGL calls and optimize.

Disadvantage - not editable.

Texture mapping

Mipmaps - power of 2 size is best.

Hardware vs. software

7. Gotchas

Lighting - have you enabled lighting and light sources?

Clipping esp. near/far planes - is your scene inside viewing frustum?

Are you looking in the right direction?

Avoid the dreaded black screen -

make small reversible changes to your code until you get a feel for what does what

OpenGL Web page

http://www.opengl.org/

Review session notes from 1999

http://graphics.stanford.edu/courses/cs248-99/OpenGLSession/248opengl.html