Introduction to OpenGL and GLUT
GLUT
Outline
OpenGL & GLUT basics
Grpahics Pipeline
2-D drawing
User interaction
2
What is OpenGL?
An application programming interface (API)
A (low-level) Graphics rendering API
Generate high-quality color images composed
of geometric and image primitives
Maximal Portability
Display device independent
Window system independent
Operating system independent
Without a standard API (such as OpenGL) - impossible to port
(100, 50) Line(100,50,150,80) - device/lib 1
(150, 100) Moveto(100,50) - device/lib 2
Lineto(150,100)
OpenGL Basics
OpenGL’s primary function – Rendering
Rendering? – converting geometric/mathematical
object descriptions into frame buffer values
OpenGL can render:
Geometric primitives
Bitmaps and Images (Raster primitives)
Code Example
void Display()
{
glClear(GL_COLOR_BUFFER_BIT);
glColor4f(1,1,0,1);
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();
}
….
Graphics Pipeline
7
OpenGL – What is It?
GL (Graphics Library): Library of 2-D, 3-D
drawing primitives and operations
API for 3-D hardware acceleration
GLU (GL Utilities): Miscellaneous functions
dealing with camera set-up and higher-
level shape descriptions
GLUT (GL Utility Toolkit): Window-system
independent toolkit with numerous utility
functions, mostly dealing with user
interface
8
Event-driven GLUT program structure
1. Configure and open window
2. Initialize OpenGL state, program
variables
3. Register callback functions
• Display (where rendering occurs)
• Resize
• User input: keyboard, mouse clicks,
motion, etc.
4. Enter event processing loop
9
Call Back Function
A callback function is
a function passed into
another function as an argument, which
is then invoked inside the
outer function to complete some kind of
routine or action.
In C, a callback function is a function that
is called through a function pointer
10
Simple OpenGL program
#include <stdio.h>
#include <GL/glut.h>
void main(int argc, char** argv)
{
glutInit(&argc, argv); // configure and open window
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);
glutInitWindowSize(100, 100);
glutCreateWindow(“hello”);
init(); // set OpenGL states, variables
glutDisplayFunc(display); // register callback
routines
glutKeyboardFunc(keyboard);
glutMainLoop(); // enter event-driven loop
}
11
Configure and open window
• glutInit: Pass command-line flags on to
GLUT
• glutInitDisplayMode: OR together bit
masks to set modes on pixel type
• glutInitWindowSize, glutCreateWindow:
Set drawing window attributes, then make
it
12
Initialize OpenGL state
• init(): Set OpenGL state, program variables
– Use GL types/typedefs GLfloat, GLint, GL_TRUE,
GL_FALSE, etc. for
cross-platform compatibility
void init() {
glClearColor(0.0, 0.0, 0.0, 0.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0, right, 0, top);
}
sets “units” of subsequent draw commands
13
OpenGL screen coordinates
• Bottom left corner is origin
• gluOrtho2D() sets the units of the screen
coordinate system
•gluOrtho2D(0, w, 0, h) means the
coordinates are in units of pixels
•gluOrtho2D(0, 1, 0, 1) means the
coordinates are in units of “fractions of window
size” (regardless of actual window size)
glOrtho2D(L,R,B,T);
14
glutInitWindowSize sets the size of the
window.
Use glViewport to specify the window
region in window coordinates to be drawn
to.
gluOrtho2D specifies the coordinates to be
used with the viewport which defaults to
the window size.
15
So, if you want create a 400 x 400 window and
only want to draw to the rectangle(50, 50, 350,
350) within the window, then use
glViewport(50, 50, 350, 350). You would then
use gluOrtho2D to set your GL coordinates
wthin the viewport. So, if you used
gluOrtho2D(-1.0, 1.0, -1.0, 1.0) then visible GL
coordinates would range from -1.0 to 1.0 in the
x direction, from -1.0 to 1.0 in the y direction.
16
Example: Specifying the center of a
square
17
Example: Specifying the center of a
square
18
A complete OpenGL program
#include <stdio.h>
#include <GL/glut.h>
void main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (640, 480);
glutInitWindowPosition (100, 150);
glutCreateWindow ("my first attempt");
glutDisplayFunc(myDisplay);
myInit ();
glutMainLoop();
}
19
A complete OpenGL program
(cont.)
void myDisplay(void)
{
glClear (GL_COLOR_BUFFER_BIT);
glColor3f (0.0, 0.0, 0.0);
glPointSize(4.0);
glBegin(GL_POINTS);
glVertex2i(100, 50);
glVertex2i(100, 130);
glVertex2i(150, 130);
glEnd();
glFlush ();
}
20
A complete OpenGL program
(cont.)
void myInit (void)
{
glClearColor(1.0, 1.0, 1.0, 0.0);
glColor3f(0.0f, 0.0f, 0.0f);
glPointSize(4.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0, 640.0, 0.0, 480.0);
}
21
Rendering Steps
In function registered with glutDisplayFunc():
1. Clear window
• glClear(GL_COLOR_BUFFER_BIT);
2. Draw shapes
• Set colors, patterns, point/line sizes
• Specify type of geometric primitive(s) and list
vertices
3. Swap buffers if display mode is GLUT_DOUBLE
4. Force all operations to complete with glFlush()
22
Single- vs. double-buffering
• Single-buffering: Draw directly to screen
buffer
• Double-buffering: Draw to offscreen
buffer, then make that the screen
buffer when done
• For animation, double-buffering is
better because it eliminates flickering
23
OpenGL Geometric Primitives
24
Primitive Types
Sample Example
Void DrawQuad(GLfloat color[])
{
glColor3f(0,0,1);
glBegin(GL_QUADS);
glVertex2f(0,0);
glVertex2f(1.0, 0,0);
glVertex2f(1.0, 1.0);
glVertex2f(0.0, 1.0);
glEnd();
}
OpenGL Command Formats
glVertex2f(x, y)
Add ‘v’ for vector
form
number of B – byte
glVertex2fv(v)
Components/ ub – unsigned byte
Dimensions s – short
us – unsigned short
2 – (x,y) i – int
3 – (x,y,z) ui – unsigned int
4 – (x,y,z,w) or f – float
(r,g,b,a) d – double
Shape Example
Use GLUT (OpenGL Utility Toolkit)
For fast prototyping, we can use GLUT to interface
with different window systems
GLUT is a window independent API – programs
written using OpenGL and GLUT can be ported to X
windows, MS windows, and Macintosh with no effort
GLUT Basics GLUT
Program Structure
1. Configure and open window (GLUT)
2. Initialize OpenGL (Optional)
3. Register input callback functions (GLUT)
Render
Resize
Input: keyboard, mouse, etc
4. Enter event processing loop (GLUT)
Sample Program GLUT
#include <GL/glut.h>
#include <GL/gl.h>
Void main(int argc, char** argv)
{
int mode = GLUT_RGB|GLUT_SINGLE;
glutInitDisplayMode(mode);
glutInitWindowSize(500,500);
glutCreateWindow(argv[0]);
init();
glutDisplayFunc(display);
glutKeyboardFunc(key);
glutMainLoop();
}
Sample Program GLUT
#include <GL/glut.h>
#include <GL/gl.h>
Void main(int argc, char** argv)
{
int mode = GLUT_RGB|GLUT_SINGLE;
glutInitDisplayMode(mode); Specify the display
glutInitWindowSize(500,500); Mode – RGB or color
glutCreateWindow(“Simple”); Index, single or double
init(); Buffer
glutDisplayFunc(display);
glutKeyboardFunc(key);
glutMainLoop();
}
Sample Program GLUT
#include <GL/glut.h>
#include <GL/gl.h>
Void main(int argc, char** argv)
{
int mode = GLUT_RGB|GLUT_SINGLE;
glutInitDisplayMode(mode);
glutInitWindowSize(500,500); Create a window
glutCreateWindow(“Simple”); Named “simple”
init(); with resolution
500 x 500
glutDisplayFunc(display);
glutKeyboardFunc(key);
glutMainLoop();
}
Sample Program GLUT
#include <GL/glut.h>
#include <GL/gl.h>
Void main(int argc, char** argv)
{
int mode = GLUT_RGB|GLUT_SINGLE;
glutInitDisplayMode(mode);
glutInitWindowSize(500,500);
glutCreateWindow(“Simple”);
init(); Your OpenGL initialization
glutDisplayFunc(display); code (Optional)
glutKeyboardFunc(key);
glutMainLoop();
}
Sample Program GLUT
#include <GL/glut.h>
#include <GL/gl.h>
Void main(int argc, char** argv)
{
int mode = GLUT_RGB|GLUT_SINGLE;
glutInitDisplayMode(mode);
glutInitWindowSize(500,500);
glutCreateWindow(“Simple”);
init();
glutDisplayFunc(display); Register your call back
glutKeyboardFunc(key); functions
glutMainLoop();
}
Callback functions? GLUT
Most of window-based programs are
event-driven
– which means do nothing until an event
happens, and then execute some pre-defined
functions
Events – key press, mouse button press and
release, window resize, etc.
GLUT
glutDisplayFunc(void (*func)(void) )
Void main(int argc, char** argv)
{
…
glutDisplayFunc(display);
…
}
void display() – the function
you provide. It contains all
the OpenGL drawing function
calls and will be called
when pixels in the window
need to be refreshed.
Event Queue GLUT
Keyboard
Event queue ….
MainLoop() Mouse
Window
Mouse_callback() Keypress_callback() window_callback()
{ { {
…. …. ….
{ { {
And many more … GLUT
glutKeyboardFunc() – register the callback that
will be called when a key is pressed
glutMouseFunc() – register the callback that will
be called when a mouse button is pressed
glutMotionFunc() – register the callback that will
be called when the mouse is in motion while a buton
is pressed
glutIdleFunc() – register the callback that will be
called when nothing is going on (no event)
glutMainLoop() GLUT
#include <GL/glut.h>
#include <GL/gl.h>
Void main(int argc, char** argv)
{
int mode = GLUT_RGB|GLUT_SINGLE;
glutInitDisplayMode(mode);
glutInitWindowSize(500,500);
glutCreateWindow(“Simple”);
init();
glutDisplayFunc(display);
glutReshapeFunc(resize);
glutKeyboardFunc(key);
glutMainLoop(); The program goes into a infinite
} loop waiting for events
Windows Config: glut
Unzip glut-3.7.6-bin.zip and you will get
1. glut.h
2. glut32.dll
3. glut32.lib
41
