1. The Human Visual System vs The Pinhole camera
Visible Spectrum
Human Visual System
Pinhole camera
Figures are extracted from Angel's book (ISBN x)

2. The Synthetic-camera Model
Figures are extracted from Angel's book (ISBN x)

3. Synthetic Camera y
(x,y,z) X Z d
Xp, Yp, -d

4. Synthetic Camera Projection Geometry
Projected Point
(x’,y’,z’) X
x,y,z d Z
COP
(0,0,0)
Projection Plane
x’ = x (d/z)
y’ = y(d/z)
z’ = d

5. Introduction to Graphics Programming

6. Graphics API

7. Computer Graphics Conceptual Model
API
Output
Devices
Application
Program
Application
Model
Graphics
System
Input
Devices
Function Calls
or Protocol
Data

8. Components of a Graphics API
Primitive functions
What to draw
Attribute functions
How to draw it
Viewing functions
(how to look at it)
Transformation functions
Rotate, scale, translate objects (where, how big?)
Input functions
Handle interactivity
Control functions
Communicate with window system
Initialization, error handling

9. API Design Considerations
Simple
Primitives
Complex
Primitives
Complex
State
Stateless
(Functional)

10. OpenGL and GLUT Overview

11. What Is OpenGL? Graphics rendering API
high-quality color images composed of geometric and image primitives
window system independent
operating system independent
developed by SGI
OpenGL is a library for doing computer graphics. By using it, you can create interactive applications which render high-quality color images composed of 3D geometric objects and images.
OpenGL is window and operating system independent. As such, the part of your application which does rendering is platform independent. However, in order for OpenGL to be able to render, it needs a window to draw into. Generally, this is controlled by the windowing system on whatever platform you’re working on.

12. Major decisions Simple primitive Retained State Approach
Not interactive with native windows

13. Major decisions Simple primitive Retained State Approach
Not interactive with native windows

14. Point and Line Segment Primitives
GL_POINTS
GL_LINES P0 P1 P2 P3 P4 P5 P6 P7 P0 P1 P2 P3 P4 P5 P6 P7
GL_LINE_STRIP
GL_LINE_LOOP P0 P1 P2 P3 P4 P5 P6 P7 P0 P1 P2 P3 P4 P5 P6 P7

15. Polygon Primitives GL_POINTS GL_POLYGON P0 P1 P2 P3 P4 P5 P6 P7 P2 P1
GL_TRIANGLES
GL_QUADS P0 P1 P2 P3 P4 P5 P6 P7 P0 P1 P2 P3 P4 P5 P6 P7

16. Polygons
OpenGL only supports rendering for simple, convex and flat polygon
1. Closed
2. Has an interior
Simple: Well defined interior
Complex:
Simple: No pair of edges of a polygon cross each other

17. Polygons: Convexity P1 P2 Definition extensible to 3D. Convex
Non-Convex P1 P2
Definition extensible to 3D.

18. OpenGL Primitive Syntax
glBegin ( type );
glVertex* ( ); .
glEnd ( );

19. Simple Example glBegin( GL_QUADS ); glColor3fv( color );
glVertex2f( 0.0, 0.0 );
glVertex2f( 1.0, 0.0 );
glVertex2f( 1.5, );
glVertex2f( 0.5, );
glEnd();
The drawRhombus() routine causes OpenGL to render a single quadrilateral in a single color. The rhombus is planar, since the z value is automatically set to 0.0 by glVertex2f().

20. OpenGL Command Formats
glVertex3fv( v )
Number of
components
Data Type
Vector
b - byte
ub - unsigned byte
s - short
us - unsigned short
i - int
ui - unsigned int
f - float
d - double
omit “v” for
scalar form
glVertex2f( x, y )
The OpenGL API calls are designed to accept almost any basic data type, which is reflected in the calls name. Knowing how the calls are structured makes it easy to determine which call should be used for a particular data format and size.
For instance, vertices from most commercial models are stored as three component floating point vectors. As such, the appropriate OpenGL command to use is glVertex3fv( coords ).
As mentioned before, OpenGL uses homogenous coordinates to specify vertices. For glVertex*() calls which don’t specify all the coordinates ( i.e. glVertex2f()), OpenGL will default z = 0.0, and w = 1.0 .
2 - (x,y)
3 - (x,y,z)
4 - (x,y,z,w)

21. Major decisions Simple primitive Retained State Approach
Not interactive with native windows

22. Setting Color Attribute in OpenGL RGB Mode
void glColor3{b s i d f ub ud ui}(TYPE r,
TYPE g, TYPE b);
glColor3f(0.0, 0.0, 0.0); /*black*/
glColor3f(1.0, 0.0, 0.0); /*red*/
glColor3f(0.0, 1.0, 0.0); /*green*/
glColor3f(0.0, 0.0, 1.0); /*blue*/
glColor3f(1.0, 1.0, 0.0); /*yellow*/
glColor3f(0.0, 1.0, 1.0); /*cyan*/
glColor3f(1.0, 0.0, 1.0); /*magenta*/
glColor3f(1.0, 1.0, 1.0); /*white*/

23. Other Simple OpenGL Attributes
glClearColor(1.0, 1.0, 1.0, 0.0);
Sets background color to white
Fourth argument is transparency; 0.0 is opaque
Sets a state variable
glPointSize(2.0);
Sets point size to be 2 pixels wide
Note that this is not a device-independent attribute
glLinewidth (2.0);

24. Immediate vs. Retained Mode Display Lists
Creating the Display List:
glNewList(Name, GL_COMPILE);
Attribute 1;
Primitive 1;
Primitive 2;
. . .
Primitive n;
glEndList;
Executing the list:
glCallList(Name);

25. Major decisions Simple primitive Retained State Approach
Not interact with native windows

26. OpenGL Library Functions
GL library contains all primitive and attribute functions
associated with OpenGL
GLU
GLU library builds on the GL library to include more
complex primitives (e.g. spheres) and convenience functions
GLUT (GL Utility Toolkit) includes functions to interface
with the native window system, including window creation,
management of input devices
GLUT

27. GL Library Organization Under Microsoft Windows
GLU GL
OpenGl
application
program
Frame
buffer
GLUT
Direct Draw

28. GL Library Organization (under X Windows)
GLU GL
OpenGL
application
program
Frame
buffer
GLUT
Xlib, Xtk
GLX

29. Geometry Pipeline

30. Vertices Vertices in world coordinates
void glVertex3f(GLfloat x, GLfloat y, GLfloat z)
Vertex (x, y, z) sent down the pipeline

31. Transformer Transformer in world coordinates Complex [Angel Ch. 4]
Must be set before object is drawn!
glRotatef(45.0, 0.0, 0.0, -1.0);
glVertex2f(1.0, 0.0);
Complex [Angel Ch. 4]

32. Transformation Matrices in OpenGL
Load Matrix
Matrix Mode 3D
Model
Vertices
Stack
Current
Stack
Current 2D 3D
Vertices
Modelview
Projection

33. Setting Viewing Matrix in GL: A Simple Case
glMatrixMode(GL_PROJECTION);
Sets the switch so that loaded matrix goes into the projection stack.
glLoadIdentity();
Pushes an identity matrix onto the stack;
gluOrtho2D(GLdouble left, Gldouble right,
Gldouble bottom, Gldouble top);
Sets the current view to an orthographic projection with view
volume bounded by x = left, x = right, y = bottom, y = top,
z = -1.0 and z = 1.0.

34. Clipper

35. Viewport Transformation
MyWindow w
Clipping
Window h x y
void glViewport(Glint x, GLint y, GLsizei w, Glsizei h);
Default viewport corresponds to entire window drawable area.

36. Projector

37. Orthographic Projection
x’ = x (d/z)
y’ = y(d/z)
z’ = d
If d = z - D and d w
x’ = x
y’ = y
z = d

38. Rasterizer

39. Simple GLUT Window Management Functions
glutInit(int *argc, char** argv);
Initializes a window session.
glutCreateWindow(char *name);
Creates a window with title *name.
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
Sets the display mode to single buffered and RGB color.
glutInitWindowSize (GLsizei h, GLsizei w);
Sets initial window size to h x w.
glutInitWindowPosition(x,y);
Sets initial window position to (x, y).

40. Form of Simplest glut/OpenGL program
#include <glut.h>
/* glut.h includes gl.h and glu.h */
void init (void) {
/* Usually contains setting of the viewing transformation*/ }
void display (void)
/*This function contains all of the draw/redraw commands

41. Form of Simplest glut/OpenGL program (slide 2)
void reshape (int w, int h) {
/* What to do whenever the window is resized. Usually includes resetting the viewport */ }
int main (int argc, char ** argv)
glutInit(int *argc, char** argv); /* init glut */
glutCreate Window(char *name); /* create window */
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
glutInitWindowSize (GLsizei h, GLsizei w);
glutInitWindowPosition(x,y);
init ();
glutDisplayFunc(display); /* register display */
glutReshapeFunc(reshape); /* register reshape */
glutMainLoop(); /* enter event loop */
return 0;

42. GLUT Callback Functions
Routine to call when something happens
window resize or redraw
user input
animation
“Register” callbacks with GLUT
glutDisplayFunc( display );
glutIdleFunc( idle );
glutKeyboardFunc( keyboard );

43. Rendering Callback Do all of your drawing here
glutDisplayFunc( display );
void display( void ) {
glClear( GL_COLOR_BUFFER_BIT );
glBegin( GL_QUADS );
glVertex3fv( v[0] );
glVertex3fv( v[1] );
glVertex3fv( v[2] );
glVertex3fv( v[3] );
glEnd();
glFlush (); }

44. Idle Callbacks Use for animation and continuous update
glutIdleFunc( idle );
void idle( void ) {
t += dt;
glutPostRedisplay(); }

45. Simple hello world