Introduction to C & C++
Lecture 12
–
OpenGL
JJCAO
OpenGL Applications
•
Modelling
& Creative Content Creation
–
Modelling
, Animation, Video & Creative Content Creation
applications that
use OpenGL
•
CAD
–
CAD/CAM
, Interior Design and Architectural applications that
use OpenGL
•
Developer
Toolkits & Libraries, Game Engines, High Level 3D
APIs
–
Tools
, Libraries, Game Engines and High Level 3D APIs for
developing OpenGL
applications and
games
•
Games
–
Freeware
and commercial games that use the OpenGL API
2
Windows OpenGL Applications
(
cont
)
•
Virtual
Reality Tools, Viewers & Internet 3D Streaming
–
VRML/Web3D
, Internet 3D Streaming & Virtual Reality
Tools
that use OpenGL
•
Utilities
: Screensavers, File Converters, Benchmarks
–
Screen

Savers
, Format Converters, Interface &
Performance Utilities
that use
OpenGL
•
Simulation
& Visualization
–
Simulation
and Visualization applications that use
OpenGL
•
Scientific
, Data Analysis & Geographic
Mapping
–
Scientific
and Data Analysis applications that use OpenGL
3
Modelling
& Creative
Content Creation
A list of
Modelling
, Animation, Video & Creative Content
Creation
applications
that use OpenGL can be found in
:
•
3ds
max
(Professional 3D
modelling
, animation and rendering
)
•
ImageModeler
(Automatic creation of 3D models
with
textures, from
still pictures)
•
Lightwave
3D (3D
modelling
, animation, rendering)
•
Cinema 4D (
Modelling
, ray tracing & animation)
•
Maya
(Character animation,
modelling
, F/X, rendering
)
•
Z

Brush
4
CAD
CAD/CAM
, Interior Design and Architectural
applications that
use OpenGL
•
AutoDest
•
Pro/E
•
CATIA
–
SolidWorks
,
Delmia
, ACIS
5
Developer Toolkits &
Libraries, Game
Engines
& 3D
APIs
Tools, Libraries, Game Engines and High Level 3D APIs
for developing
OpenGL applications and
games
•
Fly3D
(Game engine in C++ with lots of advanced features)
•
fltk
(Fast, Light GUI Toolkit for OpenGL
)
•
libQGLViewer
•
VTK
(open

source, freely available software system for 3D computer
graphics, image processing and visualization
)
6
CT scan from the visible woman dataset. An
isosurface
of the skin is clipped with a
sphere to reveal the underlying bone
structure.
Volume rendering and image display from
the visible woman dataset.
Fluid flow around the
space shuttle
Games
in OpenGL
A list of some famous games
include
•
Quake
(id's first true 3d FPS was Quake,
GLQuake
is the
3d
accelerated
version
)
•
Doom3
(Sequel to Doom
)
•
Half
Life
(FPS based on the
QuakeII
engine
)
•
Tribes
1 & 2 (FPS team online game )
7
Virtual Reality Tools, Viewers &
Internet 3D Streaming
VRML/Web3D, Internet 3D Streaming & Virtual Reality Tools
that use
OpenGL
•
OpenVRML
(VRML97 runtime library
)
•
Visualizador3D
(Virtual reality viewer for real
time walkthroughs
with textures
, collision and gravity
)
•
Cosmo
Player (VRML browser
)
•
OpenWorlds
(C++ toolkit for integrating VRML into any new or
existingapplications
)
•
Amaya
(Web Browser/Editor for HTML, XHTML, CSS,
MathML
,
SVG
and
XML)
8
Simulation & Visualization
Simulation and Visualization applications that use OpenGL
•
HyperPipe
(Professional Flight Simulation Software)
•
Capture
3.0 (A theatre/TV/event/architectural lighting
design
and visualization
software)
•
3DShadows
(Visualization of different real

time shadow

algorithms)
•
Di

Guy
(Virtual animated humans)
•
FreeVol3D
(A free 3D medical visualization software for
CT and
MR DICOM
volume data)
9
Scientific, Data Analysis &
Geographic Mapping
Scientific and Data Analysis applications that use
OpenGL
•
GraphingCalc
(Mathematical 2D/3D visualization program)
•
Graphis
(2D/3D Data visualization and analysis tool)
•
3DSurface
Viewer (Draw surfaces defined by mathematical
•
expressions)
•
OpenRT

3D
(Real time OpenGL 2D and 3D cognitive reaction
time experiments
)
•
WinTrak
Pro (Easy

to

use program for tracking satellites in
real

time
on PC
)
•
Equipotential
surfaces (3D Electromagnetism software for
visualization of
equipotential surfaces and field lines)
10
What is OpenGL
•
Low

level
–
A
software interface to graphics hardware that
consists of about 250 distinct functions
•
System

independent
–
Designed
as a streamlined, hardware

independent
interface to
be implemented
on many different
hardware
platforms
•
Client

Server
abstraction
–
Client
is the program which sends commands to the
server
–
Server
(graphics card) produces pixels on the
screen
Characteristics of OpenGL
•
Function calls
–
No
data
structures
•
Abstract
canvas
–
Window
system independent
•
State
machine
–
current color, current model
transformation,
…
12
OpenGL Command Syntax
•
Constants
begin with GL_ and are in capital letters
–
GL_LIGHTING,
–
GL_SMOOTH,
etc
•
Commands
have prefix
gl
and initial capital letters
for each word
–
glEnable
(),
–
glDisable
(),
etc
•
Some
commands
conatin
extra letters which
indicate the
number and
type of variables
–
glColor3b
(), glColor3i(), glColor3f(), etc
13
OpenGL
Rendering Pipeline
1.
Defines
objects mathematically.
2.
Arranges objects in space relative to a viewpoint.
3.
Calculates the
color
of the objects.
4.
Rasterizes the objects.
14
Key Stages in the OpenGL
Rendering Pipeline
•
Display
Lists
–
All
data, whether it describes geometry or pixels, can
be saved in
a display
list for current or later
use
•
Evaluators
–
All
geometric primitives are eventually described by
vertices
–
Evaluators
provide a method to derive the vertices
used to represent
the surface
from the control points
•
Per

Vertex
Operations
–
For
vertex data, next is the "
per

vertex
operations"
stage,
which converts
the vertices into primitives
15
Key Stages in the OpenGL
Rendering Pipeline (
cont
)
•
Primitive Assembly
–
The
results of this stage are complete geometric primitives,
which
are the
transformed and clipped vertices with related
color, depth,
and sometimes
texture

coordinate values and
guidelines for the
rasterization
step
•
Pixel
Operations
–
Pixels
from an array in system memory are first unpacked
from one of
a variety
of formats into the proper number of
components
–
Next
the data is scaled, biased, and processed by a pixel map
–
Results
are clamped and then either written into texture
memory or
sent to
the
rasterization
step
16
Key Stages in the OpenGL
Rendering Pipeline (
cont
)
•
Texture Assembly
–
An
OpenGL application may wish to apply texture images
onto
geometric
objects to make them look more realistic
•
Rasterization
–
Rasterization
is the conversion of both geometric and pixel
data
into fragments
–
Each
fragment square corresponds to a pixel in the
framebuffer
•
Fragment
Operations
–
Before
values are actually stored into the
framebuffer
, a
series
of operations
are performed that may alter or even
throw out fragments
–
All
these operations can be enabled or disabled
17
Brief History of OpenGL
It was promoted by SGI (& Microsoft, half

heartedly), is now
promoted/supported by NVIDIA, ATI, etc.
It doesn’t change every year (like DirectX, it’s main competitor
)
•
1983 IRIS GL ships with
SGI
IRIS 1000 terminal
•
1987 SGI and Pixar consider joint API development
•
1991 OpenGL ARB created
•
1992 OpenGL 1.0 completed (June 30)
•
1995 OpenGL 1.1 released (vertex array, texture objects, new
texenv
modes)
•
1997 Fahrenheit agreement between SGI and Microsoft
•
1998 OpenGL 1.2 released (3D textures, separate specular, imaging)
•
1999 OpenGL 1.2.1 released (multi

texture)
•
2001 OpenGL 1.3 released (compressed texture, cube maps,
multisample
, dot3)
•
2002 OpenGL 1.4 (
mip

map generation, shadows, point parameters)
•
2003 OpenGL 1.5 (vertex buffer objects, occlusion query) ARB extensions: OpenGL
Shading language,
ARB_vertex_program
,
ARB_fragment_program
•
2004 OpenGL 2.0
OpenGL Related Libraries
•
GLUT (GL Utility Toolkit)
–
A
simple windowing API for OpenGL
–
Callback
style
programming
•
GLU
(GL Utilities)
–
Several
routines that perform tasks like setting up
matrices for
viewing operations
and projections
and many
more
•
FSG
(Fahrenheit Scene Graph)
–
OO
toolkit that provides objects and methods for
creating interactive
3D graphics
animations
19
OpenGL Geometric
Drawing Primitives
•
OpenGL
geometric primitives can create a set of points, a line, or
a polygon
from
vertices
•
OpenGL
support
ten
primitives
•
A
drawing primitive must start with
glBegin
();
•
And
finish with
glEnd
();
•
Between
them the primitive
glBegin
(GL_POLYGON
);
glVertex2f
(

0.5,

0.5);
glVertex2f
(

0.5, 0.5);
glVertex2f
( 0.5, 0.5
);
glVertex2f
( 0.5,

0.5);
glEnd
();
OpenGL Geometric Drawing
Primitives (
cont
)
Front/Back Rendering
•
Each polygon has two sides,
front and back
•
OpenGL
can render the two differently
•
The
ordering of vertices
in the list
determines which
is the front side:
–
When
looking at the
front
side, the vertices
go
counterclockwise
–
This
is basically the right

hand rule
–
Note
that this still holds after perspective
projection
22
OpenGL
Colouring
•
OpenGL maintains a
current
colour
(in RGBA mode) and a
current
colour
index (in color

index
mode).
Unless
you're using a more complicated
colouring
model such
as lighting
or texture mapping, each object is drawn
using the
current
colour
(or color index)
•
In
RGBA mode, use the
glColor
*()
–
The
glColor
*() command accept floating

point data types (
range between
0.0 and
1.0
)
•
In
color

index mode, use the
glIndex
*() command to select a
singlevalued
colour
index as the current
colour
index
–
void
glIndex
{
sifd
ub
}(TYPE c
);
glBegin
(GL_TRIANGLES);
glColor3F(1.0f,0.0f,0.0f);
glVertex3f( 0.0f, 1.0f, 0.0f);
glColor3F(0.0f,1.0f,0.0f); glVertex3f(

1.0f,

1.0f,
0.0f);
glColor3F(0.0f,0.0f,1.0f);
glVertex3f( 1.0f,

1.0f, 0.0f);
glEnd
();
glColor3F(0.5f,0.5f,1.0f);
glBegin
(GL_QUADS); // Draw A Quad
glVertex3f(

1.0f, 1.0f, 0.0f);
…
glEnd
();
OpenGL Geometric Drawing
Primitives (
cont
)
Draw a complicated 3D
Object
void
DrawMeshWire
(
CMesh
*m )
glBegin
( GL_LINES );
for (
int
i = 0; i < m

>
numFaces
* 3; i+=3 )
{
glVertex3f( m

>vertex[m

>faces[i]*3], m

>vertex[m

>faces[i]*3+1],
m

>vertex[m

>faces[i]*3+2] );
glVertex3f( m

>vertex[m

>faces[i+1]*3], m

>vertex[m

>faces[i+1]*3+1],
m

>vertex[m

>faces[i+1]*3+2] );
glVertex3f( m

>vertex[m

>faces[i+1]*3], m

>vertex[m

>faces[i+1]*3+1],
m

>vertex[m

>faces[i+1]*3+2] );
}
glEnd
();
Camera Analogy
•
OpenGL coordinate system has
different
origin
(lower

left corner) from the
window
system
(upper

left corner)
•
The
transformation process to produce
the
desired
scene for viewing is analogous
to
taking
a photograph with a
camera
•
The
steps with a camera (or a
computer)
might
be the following:
–
Set
up your tripod and pointing the
camera
at
the scene (viewing transformation).
–
Arrange
the scene to be photographed
into
the
desired composition (
modelling
transformation
)
–
Choose
a camera lens or adjust the
zoom
(projection
transformation)
–
Determine
how large you want the
final
photograph
to be (viewport transformation)
26
Stages of Vertex Transformation
•
To specify viewing,
modelling
, and projection
transformations, you
construct a 4x4 matrix M,
which is then multiplied by
the coordinates
of each
vertex v in the scene to accomplish
the
transformation
(v'=
Mv
)
27
Modeling
Transformations
•
The three OpenGL routines for modeling transformations
are:
–
glTranslate
*(),
–
glScale
*()
–
void
glRotate
{
fd
}(TYPE
angle
, TYPE
x
, TYPE
y
, TYPE
z
);
–
glRotatef
(
45.0
, 0.0, 0.0, 1.0
)
•
These
routines
transform an object (or coordinate system
,
if
you're thinking
of it that way) by moving, rotating,
stretching, shrinking,
or reflecting
it
•
All
three commands are
equivalent
to producing an
appropriate translation
, rotation, or scaling
matrix
, and then
calling
glMultMatrix
*() with that matrix as the
argument
•
OpenGL
automatically
computes the matrices for
you
•
Copy the current matrix and push it onto a stack:
–
glPushMatrix
()
•
Discard
the current matrix and replace it with whatever’s
on
top
of the stack:
–
glPopMatrix
()
28
Modeling Transformations (
cont
)
•
Each of these
postmultiplies
the
current matrix
–
E.g
., if current matrix is
C
, then
C=CS
•
The
current matrix is either the
modelview
matrix
or
the projection
matrix (also a texture matrix,
won’t discuss)
–
Set
these with
glMatrixMode
(), e.g.:
glMatrixMode
(GL_MODELVIEW);
glMatrixMode
(GL_PROJECTION
);
•
WARNING
: common mistake ahead!
–
Be
sure that you are in
GL_MODELVIEW
mode
before
making
modeling or viewing calls!
–
Ugly
mistake because it can appear to work, at least
for
a
while…
29
Modeling
Transformations (
cont
)
OpenGL
Viewing Transformation
•
Viewing
transformation is analogous to
positioning and aiming
a camera
•
A
viewing transformation changes the position and orientation of
the
Viewpoint
•
Before
the viewing transformation can be specified, the
current matrix
is set to the identity matrix by using
–
glLoadIdentity
();
•
You
can manufacture a viewing transformation in any of
several ways
–
Use
one or more modeling transformation commands (that
is,
glTranslate
*() and
glRotate
*())
–
Use
the Utility Library routine
gluLookAt
() to define a line of sight.
This routine
encapsulates a series of rotation and translation commands.
–
Create
your own utility routine that encapsulates rotations
and translations
31
OpenGL
Projection Transformation
•
Specifying the projection transformation is like choosing a
lens for
a
camera
•
The
purpose of the projection transformation is to define a
viewing
volume
, which is used in two ways.
–
The
viewing volume determines
how an object is projected
onto
the
screen
(that is, by using a perspective or an orthographic projection
), and
–
Defines
which objects or portions of objects are clipped out
of the
final image
•
Need
to establish the appropriate mode for constructing the
viewing
transformation
, or in other words select the projection mode
–
glMatrixMode
(GL_PROJECTION);
•
This
designates the projection matrix as the current matrix, which
is
originally
set to the identity matrix
32
Perspective Projection
•
The characteristic of perspective projection is that the farther an object
is
from
the camera, the smaller it appears in the final
image
•
This
occurs because the viewing volume for a perspective projection is
a
frustum
of a
pyramid
•
This
method of projection is commonly used for animation,
visual simulation
,
and any other applications that strive for some degree
of realism
because it's
similar to how our eye (or a camera)
works
•
The
command to define a frustum,
glFrustum
(), calculates a
perspective
projection
matrix and multiplies the current projection matrix (
typically the
identity matrix) by it
–
void
glFrustum
(
GLdouble
left,
GLdouble
right,
GLdouble
bottom,
Gldouble
top
,
GLdouble
near,
GLdouble
far);
33
Advanced Perspective Projection
•
glFrustum
() isn't intuitive to use so can use
gluPerspective
()
which creates
a
viewing volume of the same shape as
glFrustum
() does,
–
but
rather than specifying corners of the near clipping plane, you
specify the
angle of the
field of view in the y direction and the aspect ratio of
the width
to height (x/y).
•
These
two parameters are enough to determine an
untruncated
pyramid
along
the line of sight
–
You
also specify the distance between the viewpoint and the near and
far clipping
planes,
thereby truncating the pyramid
.
•
Note
that
gluPerspective
() is limited to creating frustums that
are symmetric
in both the x

and y

axes along the line of sight
–
void
gluPerspective
(
GLdouble
fovy
,
GLdouble
aspect,
GLdouble
near,
GLdouble
far);
34
Orthographic Projection
•
With an orthographic projection, the viewing volume is a
rectangular
parallelepiped
–
Size
of the viewing volume doesn't change from one end to the other,
so
distance
from the camera doesn't affect how large an object
appears
•
Ortographic
projection is used for applications such as
creating
architectural
blueprints and computer

aided design, where it's crucial
to maintain
the actual sizes of objects and angles between them
–
void
gluOrtho2D
(
GLdouble
left,
GLdouble
right,
GLdouble
bottom,
GLdouble
top);
–
void
glOrtho
(
GLdouble
left,
GLdouble
right,
GLdouble
bottom,
Gldouble
top
,
GLdouble
near,
GLdouble
far);
35
Projection & Viewpoint (
cont
)
OpenGL Lighting
•
Provides a limited variety of light sources
•
We
can have
point sources, spotlights and ambient
sources
–
Each
source has separate diffuse, specular and ambient
RGB parameters
•
Materials
are
modeled
in a complementary manner
–
For
each surface separate
ambient, diffuse and specular
components
must
be used
•
Lighting
calculations must be enabled and each light source must
be
enabled
individually
–
glEnable
(GL_LIGHTING
);
–
glEnable
(LIGHT1);
•
Enabling
lighting makes OpenGL to do the shading
calculations
•
Once
lighting is enabled
,
colours
assigned by
glColor
() are
no longer
valid
37
Specifying a Light Source
•
Light sources have a number of properties, such as
colour
,
position, and
direction
•
The
OpenGL function to create a light source is
–
void
glLight
{if
}(
GLenum
light,
GLenum
param
, TYPE value);
•
The
directional light source allows to associate three
different
colour

related
parameters with any particular light
–
GL_AMBIENT
, GL_DIFFUSE, and GL_SPECULAR
•
The
positional light source need to define
–
the
location
(GL_LOCATION), and the
colour
(ambient, diffuse
and
specular
)
•
Also
can have a positional light source act as a spotlight
38
Specifying
Material Properties
•
Material
properties match the lighting properties
–
A
material has reflectivity properties for each type of
light
•
The
basic function for setting material properties is:
–
void
glMaterial
{if
}(
GLenum
face,
GLenum
name, TYPE value);
•
Diffuse
and
Ambient
Reflection
–
The
GL_DIFFUSE and GL_AMBIENT parameters set with
glMaterial
*()
affect
the
colour
of the diffuse and ambient light reflected by an object
•
Specular
Reflection
–
Specular
reflection from an object produces highlights.
–
OpenGL
allows you to set the effect that the material has on
reflected
light
(with GL_SPECULAR) and control the size and brightness of
the
highlight
(with GL_SHININESS
•
Emission
–
By
specifying an RGBA color for GL_EMISSION, you can make an
object
appear
to be giving off light of that color
39
Light & Material
Light & Material (
cont
)
41
OpenGL Shading
•
Lighting
calculations are made on a vertex

by

vertex
basis
•
OpenGL
computes vertex
colours
to create shading
effect.
–
flat shading (single color
):
glShadeModel
(GL_FLAT
);
With
flat shading the
color
of vertices is
duplicated
across all
the
primitive vertices
–
smooth shading (many different
colours
):
glShadeModel
(GL_SMOOTH
);
In
smooth shading the
colour
at each vertex is treated
individually
42
OpenGL Terrain Generator
•
An example of OpenGL terrain generator
developed by
António
Ramires
Fernandes
can be
found
in:
http
://www.lighthouse3d.com/opengl/appstools/tg
/
•
Terrain
generation from an image, computing
normals
and simulating
both directional and
positional lights
43
Laboratory Sessions
•
Assignment: Building the
solar system
•
You
will need to write from scratch a
complete OpenGL
programme
that
renders
a Sun with an orbiting planet and a moon
orbiting
the planet
44
Assignment Basic Implementation
The basic implementation includes the following:
•
Add
a sphere representing the sun planet
•
Make
the sun planet to rotate around itself
•
Add
another sphere representing the earth
•
Make
the earth planet to rotate around itself
•
Make
the earth planet to rotate around sun
•
Add
another sphere representing the moon
•
Make
the moon planet to rotate around itself
•
Make
the moon planet to rotate around the earth
•
Control
the camera position using the keyboard
•
Control
the camera position using widget menus
•
Add
a light source
•
Add
shading to the planets
•
Add
material properties to the planets (you have to check this
out
•
yourselves)
45
Assignment
Advanced Implementation
Recommended Implementation
•
Add
more planets, e.g. if you are quick enough you could create
the
complete
solar system
•
Add
more light sources (OpenGL supports up to 8 lights)
•
Have
planets counter rotating
•
Add
more moons to planets
•
Add
stars to the planetary system
•
Add
spaceships
46
Reference
47
Fotis
Liarokapis
Building
Virtual
Environments
with
OpenGL
[Nate
Robins]
http
:
//www
.
morrowland
.
com/apron/tut_gl
.
php
[Nehe]
http
:
//nehe
.
gamedev
.
net/
[Red
book]
OpenGL
Programming
Guide
:
The
Official
Guide
to
Learning
OpenGL,
Latest
Version
48
Comments 0
Log in to post a comment