Programming with OpenGL and GLUT

1
Programmingwith OpenGL and GLUT

• Glenn G. ChappellCHAPPELLG_at_member.ams.org
• U. of Alaska Fairbanks
• CS 381 Lecture Notes
• Friday, September 12, 2003

2
ReviewThe Design of OpenGL

• Recall
• The overall API design.
• What ideas guided the design of the API?
• Naming conventions
• How are names of functions, constants, and types
  are put together?
• Types
• OpenGL defines its own simple types.
• Why?
• What type-related pitfalls should you watch out
  for?

3
ReviewThe Design of OpenGL

• Attributes Primitives
• OpenGL functions as a state machine.
• There are three kinds of functions
• Those that set state.
• Those that return state.
• Those that draw.
• Drawing is done via primitives.
• States are used to set attributes of those
  primitives.

4
ReviewOpenGL Primitives

• The ten glBegin-style OpenGL Primitives
• Points (1 primitive)
• GL_POINTS
• Polylines (3 primitives)
• GL_LINES
• GL_LINE_STRIP
• GL_LINE_LOOP
• Filled Polygons (6 primitives)
• Triangles
• GL_TRIANGLES
• GL_TRIANGLE_STRIP
• GL_TRIANGLE_FAN
• Quadrilaterals
• GL_QUADS
• GL_QUAD_STRIP
• General Polygons
• GL_POLYGON
• Know the ten primitives! Know the associated
  vertex orderings!

5
Introduction to GLUTWhat is GLUT?

• GLUT OpenGL Utility Toolkit
• Not part of OpenGL.
• By Mark J. Kilgard, formerly of SGI, currently at
  NVIDIA.
• GLUT is designed for constructing small to
  medium sized OpenGL programs.
• Features
• Simplifies some OpenGL operations.
• OS-independent interface for windows, pop-up
  menus, mouse, keyboard, text fonts.
• Optional flow-of-control handling for
  event-driven programming.
• Utility functions for drawing shapes sphere,
  cube, torus, etc.
• C/C Header ltGL/glut.hgt.
• This includes gl.h and glu.h for you, as well as
  windows.h if it is needed.
• Note The handling of windows.h is sometimes
  incorrect under Cygwin. You might need to
  include it yourself if you use Cygwin.

6
Introduction to GLUTThoughts on GLUT

• I do not consider GLUT to be suitable for
  developing professional-quality, production code.
• We use it because
• It allows for OS-independent GUI programming.
• It allows for short, easy-to-write programs that
  use graphics in interesting ways.
• It provides a relatively painless introduction to
  event-driven programming.
• So, as we cover event-driven programming
• Do not think, Future employers will be happy
  that I know GLUT.
• Instead, consider what general ideas about
  event-driven programming are illustrated by the
  specific commands and techniques we cover.

7
Introduction to GLUT Writing GLUT Programs

• Start with an already written program.
• Use the web or your own previous work.
• Give credit where credit is due!
• GLUT handles overall flow of control.
• You write functions to
• Initialize OpenGL states and your own variables.
• Draw things.
• Handle events (mouse clicks, window changes,
  keypresses, etc.).
• Do something when nothing else happens.
• These functions are called by GLUT, not you.

8
Introduction to GLUTAn Example GLUT Program

• We will now look at intro2d.cpp, a simple
  OpenGL/GLUT program.
• This program does 2-D graphics.
• 3-D CG is a bit trickier I suggest (but do not
  require) that you stick with 2-D for assignment
  2.
• Source code is on the web page.
• You can use it to base your own programs on, if
  proper credit is given.

9
intro2d.cppOverview

• 5 functions main, display, idle, keyboard, init
• Function main
• Does initialization window creation.
• Tells GLUT about display, idle, keyboard
  functions.
• Turns control over to GLUT.
• Function init
• Called by main to initialize GL states, print
  instructions.
• Function display
• Called by GLUT when something needs to be drawn.
• Updates the contents of the window.
• Function idle
• Called by GLUT when nothing else is happening.
• In this program, the idle function only does
  error checking.
• Function keyboard
• Called by GLUT when a key is pressed.
• Only handles ASCII keypresses. Use a GLUT
  special function for other keys.

10
intro2d.cppBeginning

• // intro2d.cpp
• // by Glenn G. Chappell
• // September 2003
• //
• // For CS 381
• // Introductory 2-D OpenGL/GLUT program
• Put comments like this on all programs for this
  class andevery other program you write for the
  rest of your life.
• include ltGL/glut.hgt // GLUT stuff,
• includes OpenGL headers as well
• Put this line at the beginning of all GLUT
  programs.
• Again, the OpenGL headers are included by glut.h.

11
intro2d.cppFunction main 1/4

• int main(int argc, char argv)
• // Initialize OpenGL/GLUT
• glutInit(argc, argv)
• Above is always the same (argc, argv come from
  Unix command-line).
• glutInitDisplayMode(GLUT_SINGLE GLUT_RGB)
• Main GLUT display configuration call
• One parameter multiple options bitwise-ored
  together.
• GLUT_SINGLE means 1 color buffer (stores the
  color of a pixel).
• GLUT_RGB means store actual color (no color
  look-up table LUT).
• OpenGL Buffers
• All looks like the viewport (portion of window
  where drawing occurs) in terms of size, but hold
  different kinds of data.
• Color buffers hold color. Essentially, color
  buffer frame buffer.
• Can allocate other buffers, e.g., GLUT_DEPTH for
  a depth buffer.

12
intro2d.cppFunction main 2/4

• // Make a window
• glutInitWindowSize(startwinsize,
  startwinsize)
• glutInitWindowPosition(50, 50)
• glutCreateWindow("CS 381 - Introductory 2-D
  Program")
• Specify window size (x,y), position (x,y), and
  title.
• OS may ignore these and put window wherever it
  feels like.
• Function glutCreateWindow also creates an OpenGL
  context.
• An OpenGL context is a copy of all the OpenGL
  states related to a particular output channel
  (generally a window).
• So, dont set any OpenGL states until after doing
  glutCreateWindow.
• You can have multiple contexts. Changing a state
  (e.g., drawing color) in one context does not
  affect the others.

13
intro2d.cppFunction main 3/4

• // Initialize GL states register callbacks
• init()
• glutDisplayFunc(display)
• glutIdleFunc(idle)
• glutKeyboardFunc(keyboard)
• Tell GLUT what function to call to draw window
  contents (display), what to call when nothing is
  happening (idle), and what to call when an ASCII
  keypress happens (keyboard).
• display, idle, keyboard are callbacks need to be
  registered with GLUT.
• Other callbacks can be registered using functions
  like
• glutMouseFunc (for mouse events)
• glutReshapeFunc (for when the user resizes the
  window)
• and others
• These functions only register the callbacks they
  do not call them.

14
intro2d.cppFunction main 4/4

• // Do something
• glutMainLoop()
• return 0
• Very little has actually happened so far we have
  merely done initialization.
• But now we turn control over to GLUT, callbacks
  get called, and the program really starts
  running.
• GLUT handles high-level flow of control from now
  on when something needs to be done, GLUT calls
  the appropriate callback.
• return 0 is just to keep the compiler happy.
  Since glutMainLoop never returns, this line is
  never executed.

15
intro2d.cppFunction init 1/2

• void init()
• glClearColor(1.0, 1.0, 1.0, 0.0)
• Here we set various GL states.
• The first state to set is the clear color.
• This is the color to set all pixels to when the
  viewport is cleared. Think of it as the
  background color.
• Set to white 100 red, 100 green, 100 blue.
• 4th parameter is alpha.
• Alpha is used for many things most common use is
  transparency.
• Alpha not used in this program, but it is a
  required parameter.

16
intro2d.cppFunction init 2/2

• glMatrixMode(GL_PROJECTION)
• glLoadIdentity()
• gluOrtho2D(0.0, 1.0, 0.0, 1.0)
• glMatrixMode(GL_MODELVIEW) // Always go back
  to
• model/view
  mode
• In OpenGL, drawing data is sent through a
  pipeline, in which transformations are applied to
  vertex coordinates. These transformations are
  stored as 44 matrices.
• Here, we set up the matrix to do the projection
  onto the screen.
• What is important to know now is that the 4
  parameters of gluOrtho2D set up a coordinate
  system for the window
• x-coordinate of left side
• x-coordinate of right side
• y-coordinate of bottom
• y-coordinate of top

17
intro2d.cppFunction display 1/5

• void display()
• glClear(GL_COLOR_BUFFER_BIT)
• The first thing to do when displaying is to clear
  the buffer.
• glClear sets every pixel in the color buffer to
  the color specified with glClearColor.
• Can clear other buffers (if they were allocated
  by the glutInitDisplayMode call).

18
intro2d.cppFunction display 2/5

• glColor3d(0.9, 0.1, 0.1)
• Sets the drawing color.
• This is the color of upcoming vertices.
• Drawing color is another GL state.
• glColor can take several forms with different
  types of parameters.
• What does 3d mean?

19
intro2d.cppFunction display 3/5

• glBegin(GL_QUADS)
• glVertex2d(0.1, 0.1)
• glVertex2d(0.9, 0.1)
• glVertex2d(0.9, 0.9)
• glVertex2d(0.1, 0.9)
• glEnd()
• Specifying the coordinates of actual things to
  draw is done between glBegin and glEnd.
• glVertex call gives coordinates GL_QUADS tells
  how to use them.
• Coordinate system was specified by the glOrtho2D
  call.
• Recall GL_QUADS is a GL primitive it means draw
  a series of quadrilaterals.
• Indentation between glBegin and glEnd is helpful.
• It is not required, of course.
• Only a very limited set of GL commands are
  allowed between glBegin and glEnd.

20
intro2d.cppFunction display 4/5

• glFlush()
• glFlush says start drawing now.
• Another possibility is glFinish start and wait
  until done.
• In this class, always flush at the end your
  display function. Use glFlush, glFinish, or
  glutSwapBuffers (to be discussed later).

21
intro2d.cppTHE RULES

• Rules for callbacks (display in particular)
• You never call your callback functions. Only GLUT
  does that.
• The display function only does drawing (which may
  include GL state changes).
• No drawing is done outside the display function
  (but state changes may be done).
• These rules are for this class.
• Later in life, you may want to break them.
• But think hard first theyre good rules.

22
STOPPED

• We stopped here on Friday, September 12.
• We will continue with the following slides on
  Monday.

23
intro2d.cppFunction keyboard

• void keyboard(unsigned char key, int x, int y)
• switch (key)
• case ESCKEY // ESC Quit
• exit(0)
• break
• GLUT calls the keyboard function whenever an
  ASCII keypress happens.
• Use the GLUT special function for non-ASCII
  (like arrow keys).
• The ASCII value of the keypress is in key. Mouse
  position is in x, y.
• Your keyboard (or special) function will usually
  be one big switch.
• Why did I put in the (unnecessary) break?

24
intro2d.cppFunction idle

• // Print OpenGL errors, if there are any
• (for debugging)
• if (GLenum err glGetError())
• cerr ltlt "OpenGL ERROR " ltlt
  gluErrorString(err)
• ltlt endl
• GLUT calls the idle function whenever nothing
  else needs doing.
• It is useful for making time-dependent changes to
  the scene.
• Here, we check for OpenGL errors, and print a
  message if there is an error.
• This is a rather atypical use of the idle
  function.