CPSC 424, Spring 2010
Information About the First Test

The first test will be given in class on Wednesday, March 3. The test will cover everything that we have done from the beginning of the term through class on Friday, February 26. This includes material from the notes up though Section 3.3, as well as Labs 1 through 5.

You can expect a variety of questions on the test. There will certainly be some definitions and essay-type questions. There might be some questions on Blender or Gimp in that category. You should expect some questions on computer graphics in general as well as on OpenGL and Jogl in particular. Some questions will ask you to write code segments or methods. Some will ask you to read code and determine what it does. Some might ask you to design classes or discuss how you would go about designing them. The idea of scene graphs and their implementation is probably more important than might be indicated by their brief appearance in the list of topics below.

I will not ask you to code using the Java Graphics2D graphics API, but you should be familiar with its features (so that you could, for example, compare it with OpenGL). There will not be any purely mathematical questions, such as computing dot and cross products or working with matrices and homogenous coordinates.

Here are some terms and ideas that you should be familiar with:

Computer graphics
Painting programs vs. Drawing programs
Raster graphics and Vector graphics

Basic elements of 3D Graphics:
   geometric modeling
   geometric transformations
   viewing and projection
Java 2D graphics:
   the Graphics2D class
   geometric transformations in 2D
   transformations can be used to transform objects or coordinates
   rotation, scaling, translation, shear
   shape classes such as Line2D
   Bezier curve segments; control points
   g2.fill(shape) and g2.draw(shape)

OpenGL as a standard graphics API
OpenGL and GPUs (graphics cards)
GLCanvas and GLPanel
the init(GLAutoDrawable) method
the display(GLAutoDrawable) method
the GL class
Getting a GL object:  GL gl = drawable.getGL()
OpenGL subroutine method names: what do the "3's" and "d's" mean?
vertices and the glVertex* methods, such as gl.glVertex2d, gl.glVertex3f
color and the glColor* methods, such as gl.glColor3f
rotation, scaling, and translation in 3D
glRotate*, glScale*, glTranslate*

gl.glPushMatrix(), gl.glPopMatrix()
hierarchical graphics
scene graphs
implementation of scene graphs with Java classes
transformations in scene graphs

coordinate systems
object coordinates
world coordinates
eye coordinates
normalized device coordinates
device coordinates
modeling transformation
viewing transformation
equivalence between modeling and viewing
the modelview transformation
the projection transformation; the view volume
the viewport and the viewport transformation
gl.glMatrixMode(GL.GL_MODELVIEW) vs. gl.GLMatrixMode(GL.GL_PROJECTION)
perspective projection vs orthographic projection
right-handed coordinate system
rotation in 3D; the rotation axis and the direction of rotation

enabling/disabling OpenGL features with gl.glEnable/gl.glDisable
essential features that need to be enabled for 3D
lighting; gl.glEnable(GL.GL_LIGHTING) and gl.glEnable(GL.GL_LIGHT0)
color vs. "material"; using gl.glEnable(GL.GL_COlOR_MATERIAL)
shade model; gl.glShadeModel(GL.GL_SMOOTH) vs. gl.glShadeModel(GL.GL_FLAT)
depth test; gl.glEnable(GL.GL_DEPTH_TEST)
the depth buffer; how it is used and why it needs to be cleared
the hidden surface problem and how the depth test solves it

display lists and why they might be used

vertex attributes
what is computed at a vertex, and what is interpolated to interior pixels
vectors; direction and length
normal vectors; glNormal3*
why normal vectors are essential in lighting computations
choosing a normal vector; faceted vs. smooth surfaces
how the cross product can be used to compute normal vectors
unit normal vectors; "normalizing" a vector
using gl.glEnable(GL.GL_NORMALIZE) to have OpenGL normalize vectors

front and back faces of polygons
counterclockwise ordering of vertices

2D image textures
texture coordinates; gl.glTexCoord2d(s,t)
mapping textures onto objects using texture coordinates

OpenGL primitive types
polygons in OpenGL must be planar and convex
polygon mode; drawing polygons as wireframe
polygon offset

polygonal meshes
indexed face set (IFS); vertex list and face list
polygon grids; drawing grids as triangle strips.
using a polygon grid to represent terrain

Some basic ideas from Gimp:
   color components and adjusting color levels
   paths and Bezier curves
   transparency and "partially selected" pixels
Some basic ides from Blender:
   lamps and spotlights
   the camera
   edit mode; modifying individual vertices in a mesh
   materials and textures
   procedural textures vs. image textures
   rendering an image