The Human Visual System vs The Pinhole camera Visible Spectrum Human Visual System Pinhole camera Figures are extracted from Angel's book (ISBN 0-201-38597-x)

The Synthetic-camera Model Figures are extracted from Angel's book (ISBN 0-201-38597-x)

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

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

Introduction to Graphics Programming

Graphics API

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

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

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

OpenGL and GLUT Overview

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.

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

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

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

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

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

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

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

Simple Example glBegin( GL_QUADS ); glColor3fv( color ); glVertex2f( 0.0, 0.0 ); glVertex2f( 1.0, 0.0 ); glVertex2f( 1.5, 1.118 ); glVertex2f( 0.5, 1.118 ); 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().

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)

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

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*/

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);

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);

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

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

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

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

Geometry Pipeline

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

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]

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

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.

Clipper

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.

Projector

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

Rasterizer

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).

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

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;

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 );

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 (); }

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

Simple hello world