Introduction to OpenGL Programming

1. Introduction to OpenGL Programming

2. What is OpenGL • OpenGL is a software API to graphics hardware. • designed as a streamlined, hardware-independent interface to be implemented on many different hardware platforms • Intuitive, procedural interface with c binding • No windowing commands ! • No high-level commands for describing models of three-dimensional objects • The OpenGL Utility Library (GLU) provides many of the modeling features, such as quadric surfaces and NURBS curves and surfaces

3. SGI and GL • Silicon Graphics (SGI) revolutionized the graphics workstation by implementing the pipeline in hardware (1982) • To access the system, application programmers used a library called GL • With GL, it was relatively simple to program three dimensional interactive applications

4. OpenGL The success of GL lead to OpenGL (1992), a platform-independent API that was • Easy to use • Close enough to the hardware to get excellent performance • Focus on rendering • Omitted windowing and input to avoid window system dependencies

5. OpenGL Evolution • Controlled by an Architectural Review Board (ARB) • Members include SGI, Microsoft, Nvidia, HP, 3DLabs, IBM,……. • Relatively stable (present version 2.0) • Evolution reflects new hardware capabilities • 3D texture mapping and texture objects • Vertex and fragment programs • Allows for platform specific features through extensions

6. OpenGL Libraries • OpenGL core library • OpenGL32 on Windows • GL on most unix/linux systems (libGL.a) • OpenGL Utility Library (GLU) • Provides functionality in OpenGL core but avoids having to rewrite code • Links with window system • GLX for X window systems, WGL for Windows • Cross-platform GUI libraries: GLUT, SDL, FLTK, QT, …

7. Windowing with OpenGL • OpenGL is independent of any specific window system • OpenGL can be used with different window systems • X windows (GLX) • MFC • … • GLUT provide a portable API for creating window and interacting with I/O devices

8. GLUT • OpenGL Utility Toolkit (GLUT) • Provides functionality common to all window systems • Open a window • Get input from mouse and keyboard • Menus • Event-driven • Code is portable but GLUT lacks the functionality of a good toolkit for a specific platform • No slide bars, buttons, …

9. Software Organization application program OpenGL Motif widget or similar GLUT GLX, AGLor WGL GLU OpenGL X, Win32, Mac O/S software and/or hardware

10. OpenGL Architecture geometry pipeline Immediate Mode Per Vertex Operations & Primitive Assembly Polynomial Evaluator DisplayList Per Fragment Operations Frame Buffer CPU Rasterization Texture Memory Pixel Operations

11. OpenGL as a state machine • GL State Variables- can be set and queried by OpenGL. Remains unchanged until the next change. • Projection and viewing matrix • Color and material properties • Lights and shading • Line and polygon drawing modes • … • OpenGL functions are of two types • Primitive generating • Can cause output if primitive is visible • How vertices are processed and appearance of primitive are controlled by the state • State changing • Transformation functions • Attribute functions

12. OpenGL Syntax • Functions have prefix gland initial capital letters for each word • glClearColor(), glEnable(), glPushMatrix() … • glu for GLU functions • gluLookAt(), gluPerspective() … • Constants begin with GL_, use all capital letters • GL_COLOR_BUFFER_BIT, GL_PROJECTION, GL_MODELVIEW … • Extra letters in some commands indicate the number and type of variables • glColor3f(), glVertex3f() … • OpenGL data types • GLfloat, GLdouble, GLint, GLenum, … • Underlying storage mode is the same • Easy to create overloaded functions in C++ but issue is efficiency

13. OpenGL function format function name dimensions glVertex3f(x,y,z) x,y,zare floats belongs to GL library glVertex3fv(p) pis a pointer to an array

14. OpenGL #defines • Most constants are defined in the include files gl.h, glu.h and glut.h • Note #include <GL/glut.h> should automatically include the others • Examples • glBegin(GL_POLYGON) • glClear(GL_COLOR_BUFFER_BIT) • include files also define OpenGL data types: GLfloat, GLdouble,….

15. GLUT • Developed by Mark Kilgard • Hides the complexities of differing window system APIs • Default user interface for class projects • Glut routines have prefix glut • glutCreateWindow() … • Has very limited GUI interface • Glui is the C++ extension of glut

16. Glut Routines • Initialization:glutInit() processes (and removes) command­line arguments that may be of interest to glut and the window system and does general initialization of Glut and OpenGL • Must be called before any other glut routines • Display Mode: The next procedure, glutInitDisplayMode(), performs initializations informing OpenGL how to set up the frame buffer. • Display Mode Meaning • GLUT_RGB Use RGB colors • GLUT_RGBA Use RGB plus alpha (for transparency) • GLUT_INDEX Use indexed colors (not recommended) • GLUT_DOUBLE Use double buffering (recommended) • GLUT_SINGLE Use single buffering (not recommended) • GLUT_DEPTH Use depth­buffer (for hidden surface removal.)

17. Glut Routines • Window Setup • glutInitWindowSize(int width, int height) • glutInitWindowPosition(int x, int y) • glutCreateWindow(char* title)

18. A Simple Program Generate a square on a solid background

19. simple.c #include <GL/glut.h> void mydisplay(){ glClear(GL_COLOR_BUFFER_BIT); glBegin(GL_POLYGON); glVertex2f(-0.5, -0.5); glVertex2f(-0.5, 0.5); glVertex2f(0.5, 0.5); glVertex2f(0.5, -0.5); glEnd(); glFlush(); } int main(int argc, char** argv){ glutInit(&argc, argv); glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB); glutInitWindowSize(500,500); glutInitWindowPosition(0,0); glutCreateWindow("simple"); glutDisplayFunc(mydisplay); init(); glutMainLoop(); }

20. Closer Look at the main() includesgl.h #include <GL/glut.h> int main(int argc, char** argv) { glutInit(&argc,argv); glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB); glutInitWindowSize(500,500); glutInitWindowPosition(0,0); glutCreateWindow("simple"); glutDisplayFunc(mydisplay); init(); glutMainLoop(); } define window properties display callback set OpenGL state enter event loop

21. init.c black clear color void init() { glClearColor (0.0, 0.0, 0.0, 1.0); glColor3f(1.0, 1.0, 1.0); glMatrixMode (GL_PROJECTION); glLoadIdentity (); glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0); } opaque window fill/draw with white viewing volume

22. Event Handling • Virtually all interactive graphics programs are even driven • GLUT uses callbacks to handle events • Windows system invokes a particular procedure when an event of particular type occurs. • MOST IMPORTANT: display event • Signaled when window first displays and whenever portions of the window reveals from blocking window • glutDisplayFunc(void (*func)(void)) registers the display callback function • Running the program: glutMainLoop() • Main event loop. Never exit()

23. More Callbacks • glutReshapeFunc(void (*func)(int w, int h)) indicates what action should be taken when the window is resized. • glutKeyboardFunc(void (*func)(unsigned char key, int x, int y)) and glutMouseFunc(void (*func)(int button, int state, int x, int y)) allow you to link a keyboard key or a mouse button with a routine that's invoked when the key or mouse button is pressed or released. • glutMotionFunc(void (*func)(int x, int y)) registers a routine to call back when the mouse is moved while a mouse button is also pressed. • glutIdleFunc(void (*func)(void)) registers a function that's to be executed if no other events are pending - for example, when the event loop would otherwise be idle

24. Compilation on Windows • See class web site on how to set up a project with OpenGL • Visual C++ • Get glut.h, glut32.lib and glut32.dll from web • Create a console application • Add opengl32.lib, glut32.lib, glut32.lib to project settings (under link tab)

25. Simple Animation • Animation • Redraw + swap buffers • What looks like if using single buffer • Example program • More on the glut documentation • Chapter 2 of textbook • OpenGL redbook • Links in the class resources page

26. OpenGL Drawing • We have learned how to create a window • Steps in the display function • Clear the window • Set drawing attributes • Send drawing commands • Swap the buffers • OpenGL coordinate system has different origin from the window system • Uses lower left corner instead of upper left corner as origin

27. Clear the Window • glClear(GL_COLOR_BUFFER_BIT) • clears the frame buffer by overwriting it with the background color. • Background color is a state set by glClearColor(GLfloat r, GLfloat g, GLfloat b, GLfloat a) in the init().

28. Drawing Attributes: Color • glColor3f(GLfloat r, GLfloat g, GLfloat b) sets the drawing color • glColor3d(), glColor3ui() can also be used • Remember OpenGL is a state machine • Once set, the attribute applies to all subsequent defined objects until it is set to some other value • glColor3fv() takes a flat array as input • There are more drawing attributes than color • Point size: glPointSize() • Line width: glLinewidth() • Dash or dotted line: glLineStipple() • Polygon pattern: glPolygonStipple() • …

29. Drawing Commands • Simple Objects glRectf() • Complex Objects • Use construct glBegin(mode) and glEnd() and a list of vertices in between • glBegin(mode) glVertex(v0); glVertex(v1); ... glEnd(); • Some other commands can also be used between glBegin() and glEnd(), e.g. glColor3f(). • Example

30. Projection and Viewport

31. z=0 Orthographic projection • Orthographic View • glOrtho(left, right, bottom, top, front, back) • Specifies the coordinates of 3D region to be projected into the image space. • Any drawing outside the region will be automatically clipped away.

32. Viewports • Do not have use the entire window for the image: glViewport(x,y,w,h) • Values in pixels (screen coordinates)

33. Window to Viewport mapping Aspect Ratio: Height/Width If the aspect ratio of the window Is different from that of the viewport, the picture will be distorted.

34. Sierpinski Gasket (2D) • Start with a triangle • Connect bisectors of sides and remove central triangle • Repeat

35. Example • Five subdivisions

36. Gasket Program #include <GL/glut.h> /* initial triangle */ GLfloat v[3][2]={{-1.0, -0.58}, {1.0, -0.58}, {0.0, 1.15}}; int n; /* number of recursive steps */ void triangle( GLfloat *a, GLfloat *b, GLfloat *c) /* display one triangle */ { glVertex2fv(a); glVertex2fv(b); glVertex2fv(c); }

37. Triangle Subdivision void divide_triangle(GLfloat *a, GLfloat *b, GLfloat *c, int m) { /* triangle subdivision using vertex numbers */ point2 v0, v1, v2; int j; if(m>0) { for(j=0; j<2; j++) v0[j]=(a[j]+b[j])/2; for(j=0; j<2; j++) v1[j]=(a[j]+c[j])/2; for(j=0; j<2; j++) v2[j]=(b[j]+c[j])/2; divide_triangle(a, v0, v1, m-1); divide_triangle(c, v1, v2, m-1); divide_triangle(b, v2, v0, m-1); } else(triangle(a,b,c)); /* draw triangle at end of recursion */ }

38. Gasket Display Functions void display() { glClear(GL_COLOR_BUFFER_BIT); glBegin(GL_TRIANGLES); divide_triangle(v[0], v[1], v[2], n); glEnd(); glFlush(); } • By having the glBegin and glEnd in the display callback rather than in the function triangle and using GL_TRIANGLES rather than GL_POLYGON in glBegin, we call glBegin and glEnd only once for the entire gasket rather than once for each triangle

39. Example: 3D Gasket after 5 iterations

40. Tetrahedron Code void tetrahedron( int m) { glColor3f(1.0,0.0,0.0); divide_triangle(v[0], v[1], v[2], m); glColor3f(0.0,1.0,0.0); divide_triangle(v[3], v[2], v[1], m); glColor3f(0.0,0.0,1.0); divide_triangle(v[0], v[3], v[1], m); glColor3f(0.0,0.0,0.0); divide_triangle(v[0], v[2], v[3], m); }