Introduction to Graphics Programming

1. Introduction to Graphics Programming

2. Graphics API

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

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

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

6. OpenGL and GLUT Overview

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

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

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

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

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

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

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

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

15. 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();

16. OpenGL Command Formats glVertex3fv( v ) Data Type Vector Number of components 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 ) 2 - (x,y) 3 - (x,y,z) 4 - (x,y,z,w)

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

18. Setting Color Attribute in OpenGLRGB 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*/

19. 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 • Sets a state variable • glLinewidth (2.0);

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

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

22. GLU GL GLUT OpenGL Library Functions GL library contains all primitive and attribute functions associated with OpenGL 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

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

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

25. Geometry Pipeline

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

27. Transformer • Transformer in world coordinates • 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]

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

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

30. Clipper

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

32. Projector

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

34. Rasterizer

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

36. Form of Simplestglut/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 }

37. Form of Simplestglut/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; • }

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

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

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

41. Simple hello world

42. Simple hello world Include Files: #include <windows.h> #include <glut.h>

43. Simple hello world void init (void) { /* select clearing color */ glClearColor (0.0, 0.0, 0.0, 0.0); /* initialize viewing values */ glMatrixMode(GL_PROJECTION); glLoadIdentity(); glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0); }

44. Simple hello world void display(void) { /* clear all pixels */ glClear (GL_COLOR_BUFFER_BIT); /* draw colored polygon (rectangle) with corners at * (0.25, 0.25, 0.0) and (0.75, 0.75, 0.0) …. */ glColor3f (1.0, 0.0, 0.0); //red glBegin(GL_QUADS); glVertex3f (0.25, 0.25, 0.0); glVertex3f (0.75, 0.25, 0.0); glColor3f (0.0, 0.0, 1.0); //blue glVertex3f (0.75, 0.75, 0.0); glVertex3f (0.25, 0.75, 0.0); glEnd(); glutSolidSphere(0.15,12,2); //draw a sphere glFlush (); }

45. Simple hello world int main(int argc, char** argv) { glutInit(&argc, argv); glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB); glutInitWindowSize (250, 250); glutInitWindowPosition (100, 100); glutCreateWindow ("hello"); init (); glutDisplayFunc(display); glutMainLoop(); return 0; /* ANSI C requires main to return int. */ }