1. Introduction to C & C++
Lecture 12 – OpenGL
JJCAO

2. OpenGL Applications Modelling & Creative Content Creation CAD
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

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

4. 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
Z-brush: do not know whether it is based on OpenGL

5. CAD
CAD/CAM, Interior Design and Architectural applications that use OpenGL
AutoDest
Pro/E
CATIA
SolidWorks, Delmia, ACIS
CAGD：我国几何设计与计算正是从飞机和造船起步，现在汽车和日常用品等得设计分析也是推动的源泉。
1974年, 达索公司面临的重大决策：齐头并进!!!
1975年买进CADAM及源码；
1977年启动开发CATIA，次年即推出，并建立数据库管理二者数据；
CATIA买断了CADAM，陆续购买了大量业界领先的公司，包括SolidWorks (实体造型)，Delmia (制造仿真)，ACIS (造型引擎) 等，现为CAD行业龙头！

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

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

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

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

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

11. What is OpenGL Low-level System-independent Client-Server abstraction
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

12. Characteristics of OpenGL
Function calls
No data structures
Abstract canvas
Window system independent
State machine
current color, current model transformation, …

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

14. OpenGL Rendering Pipeline
Defines objects mathematically.
Arranges objects in space relative to a viewpoint.
Calculates the color of the objects.
Rasterizes the objects.

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

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

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

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

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

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

21. OpenGL Geometric Drawing Primitives (cont)

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

23. 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); …

24. OpenGL Geometric Drawing Primitives (cont)
Nate_Robins_tutorials: Shapes

25. 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] ); }
glEnd();
曲面的内＆外；法向＆顶点顺序

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

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

28. 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()

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

30. Modeling Transformations (cont)
Nate_Robins_tutorials: Transformation

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

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

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

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

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

36. Projection & Viewpoint (cont)
Nate_Robins_tutorials: Projection

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

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

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

40. Nate_Robins_tutorials: lightmaterial

41. Light & Material (cont)

42. 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
Lines or filled polygon primitives can be drawn with flat shading (single color) or smooth shading (many different colours)

43. OpenGL Terrain Generator
An example of OpenGL terrain generator developed by António Ramires Fernandes can be found in:
Terrain generation from an image, computing normals and simulating both directional and positional lights

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

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

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

47. Reference Fotis Liarokapis Building Virtual Environments with OpenGL
[Nate Robins]
[Nehe]
[Red book]
OpenGL Programming Guide: The Official Guide to Learning OpenGL, Latest Version