Scanned with CamScanner

Scanned with CamScanner

Subject Name: Computer Graphics Class Name: SE (CSE)

OpenGL

Aim :- Case Study of OpenGL.

Theory :-

OpenGL (Open Graphics Library) is the computer industry's standard application

program interface (API) for defining 2-D and 3-D graphic images. Prior to OpenGL, any
company developing a graphical application typically had to rewrite the graphics part of it for
each operating system platform and had to be cognizant of the graphics hardware as well. With
OpenGL, an application can create the same effects in any operating system using any OpenGL-
adhering graphics adapter.

OpenGL specifies a set of "commands" or immediately executed functions. Each

command directs a drawing action or causes special effects. A list of these commands can be
created for repetitive effects. OpenGL is independent of the windowing characteristics of each
operating system, but provides special "glue" routines for each operating system that enable
OpenGL to work in that system's windowing environment. OpenGL comes with a large number
of built-in capabilities request able through the API. These include hidden surface removal,
alpha blending (transparency), antialiasing , texture mapping, pixel operations, viewing and
modeling transformations, and atmospheric effects (fog, smoke, and haze).

Silicon Graphics, makers of advanced graphics workstation s, initiated the development

of OpenGL. Other companies on the industry-wide Architecture Review Board include DEC,
Intel, IBM, Microsoft, and Sun Microsystems. There is no cost (other than learning) to
developing an application using the OpenGL API. Microsoft offers free download of the
OpenGL libraries for its Windows systems. Although OpenGL is not itself a development
"toolkit," such toolkits are available, including Silicon Graphics object-oriented
programming 3D graphics toolkit, Open Inventor.
Subject Name: Computer Graphics Class Name: SE (CSE)

Video games outsource real-time rendering calculations to the GPU over OpenGL. The
rendered results are not sent back to main memory, but to the frame buffer of video memory
instead. The display controller will then send this data to the display device.

Design
The OpenGL specification describes an abstract API for drawing 2D and 3D graphics.
Although it is possible for the API to be implemented entirely in software, it is designed to be
implemented mostly or entirely in hardware.

The API is defined as a set of functions which may be called by the client program,
alongside a set of named integer constants (for example, the constant GL_TEXTURE_2D,
which corresponds to the decimal number 3553). Although the function definitions are
superficially similar to those of the programming language C, they are language-independent.
As such, OpenGL has many language bindings, some of the most noteworthy being the Java
Subject Name: Computer Graphics Class Name: SE (CSE)

Script binding WebGL (API, based on OpenGL ES 2.0, for 3D rendering from within a web
browser); the C bindings WGL, GLX and CGL; the C binding provided by iOS; and
the Java and C bindings provided by Android.

In addition to being language-independent, OpenGL is also cross-platform. The

specification says nothing on the subject of obtaining, and managing an OpenGL context,
leaving this as a detail of the underlying windowing system. For the same reason, OpenGL is
purely concerned with rendering, providing no APIs related to input, audio, or windowing.

An illustration of the graphics pipeline process

Associated Libraries
The earliest versions of OpenGL were released with a companion library called
the OpenGL Utility Library (GLU). It provided simple, useful features which were unlikely to
be supported in contemporary hardware, such as tessellating, and
generating mipmaps and primitive shapes. The GLU specification was last updated in 1998 and
depends on OpenGL features which are now deprecated.

Context & Window Toolkits

Given that creating an OpenGL context is quite a complex process, and given that it
varies between operating systems, automatic OpenGL context creation has become a common
feature of several game-development and user-interface libraries,
including SDL, Allegro, SFML, FLTK, and Qt. A few libraries have been designed solely to
Subject Name: Computer Graphics Class Name: SE (CSE)

produce an OpenGL-capable window. The first such library was OpenGL Utility
Toolkit (GLUT), later superseded by freeglut. GLFW is a newer alternative.

 These toolkits are designed to create and manage OpenGL windows, and manage input,
but little beyond that.
 GLFW – A cross-platform windowing and keyboard-mouse-joystick handler; is more
game-oriented
 freeglut – A cross-platform windowing and keyboard-mouse handler; its API is a
superset of the GLUT API, and it is more stable and up to date than GLUT
 OpenGL Utility Toolkit (GLUT) – An old windowing handler, no longer maintained.

 Several "multimedia libraries" can create OpenGL windows, in addition to input, sound
and other tasks useful for game-like applications

 Allegro 5 – A cross-platform multimedia library with a C API focused on game

development
 Simple Direct Media Layer (SDL) – A cross-platform multimedia library with a C
API
 SFML – A cross-platform multimedia library with a C++ API and multiple other
bindings to languages such as C#, Java, Haskell, and Go
 Widget toolkits

 FLTK – A small cross-platform C++ widget library

 Qt – A cross-platform C++ widget toolkit. It provides many OpenGL helper objects,
which even abstract away the difference between desktop GL and OpenGL ES
 wxWidgets – A cross-platform C++ widget toolkit
9/18/22, 5:07 AM Overview of OpenGL

Last modified: 02/04/97

Acknowledgements
Much of the organization and content of this presentation came from the following sources:
Mark Segal and Kurt Akeley's white paper on OpenGL, David Quarrie's OpenGL overview, and
SGI's OpenGL data sheet.

Table of Contents
Introduction
OpenGL Pipeline
Vertices and Primitives
Clipping and Projection
Rasterization
Texturing and Fog
Framebuffer
Per-fragment Operations
Miscellaneous
Evaluators
Display Lists
Feedback and Selection
OpenGL State
Summary
References and Related Links

Introduction
OpenGL is a hardware-independent, operating system independent, vendor neutral graphics API
specification. Many vendors provide implementations of this specification for a variety of
hardware platforms. Bindings exist primarily for the C programming language, but bindings are
also available for Fortran and Ada.

OpenGL has been designed using a client/server paradigm, allowing the client application and
the graphics server controlling the display hardware to exist on the same or separate machines.
The network is transparent to the application.

OpenGL is window system independent, and therefore contains no windowing operations or

mechanisms for user input. Also, OpenGL does not provide direct support for complex
geometrical shapes, such as cubes or spheres. These must be built up from supported primitives.

Some features of OpenGL include the following:

Geometric and raster primitives

https://web.cs.wpi.edu/~matt/courses/cs563/talks/OpenGL_Presentation/OpenGL_Presentation.html#Per-fragment Operations 1/8
9/18/22, 5:07 AM Overview of OpenGL

RGBA or color index mode

Display list or immediate mode
Viewing and modeling transformations
Lighting and Shading
Hidden surface removal (Depth Buffer)
Alpha Blending (Translucency)
Anti-aliasing
Texture Mapping
Atmospheric Effects (Fog, Smoke, Haze)
Feedback and Selection
Stencil Planes
Accumulation Buffer
Depth Cueing
Wireframes
Motion blur

Also available with OpenGL are the following three libraries:

The OpenGL Utility Library (GLU), which contains several routines that use lower-level
OpenGL commands to perform such tasks as setting up matrices for specific viewing
orientations and projections, performing tessellation, and rendering surfaces.
The OpenGL Extension to the X Window System (GLX) provides a means of creating an
OpenGL context and associating it with an X Window System window.
The OpenGL Programming Guide Auxiliary Library provides routines for initializing and
opening windows, handling X events and dealing with common complex shapes, such as
cubes, spheres, and cylinders.

OpenGL is defined and released by the OpenGL Architecture Review Board (ARB). The ARB
consists of representatives from industry, including DEC, E&S, H-P, IBM, Intel, Intergraph,
Microsoft, SGI, and Sun. The ARB oversees the administration of the OpenGL Specification and
Conformance Test Suite.

OpenGL Pipeline
The OpenGL architecture is structured as a state-based pipeline. Below is a simplified diagram
of this pipeline. Commands enter the pipeline from the left.

https://web.cs.wpi.edu/~matt/courses/cs563/talks/OpenGL_Presentation/OpenGL_Presentation.html#Per-fragment Operations 2/8

9/18/22, 5:07 AM Overview of OpenGL

Commands may either be accumulated in display lists, or processed immediately through the
pipeline. Display lists allow for greater optimization and command reuse, but not all commands
can be put in display lists.

The first stage in the pipeline is the evaluator. This stage effectively takes any polynomial
evaluator commands and evaluates them into their corresponding vertex and attribute commands.

The second stage is the per-vertex operations, including transformations, lighting, primitive
assembly, clipping, projection, and viewport mapping.

The third stage is rasterization. This stage produces fragments, which are series of framebuffer
addresses and values, from the viewport-mapped primitives as well as bitmaps and pixel
rectangles.

The fourth stage is the per-fragment operations. Before fragments go to the framebuffer, they
may be subjected to a series of conditional tests and modifications, such as blending or z-
buffering.

Parts of the framebuffer may be fed back into the pipeline as pixel rectangles. Texture memory
may be used in the rasterization process when texture mapping is enabled.

Vertices and Primitives

Most objects (with the exception of pixel rectangles and bitmaps), use Begin/End primitives.
Each Begin/End primitive contains a series of vertex data, and may optionally contain normals,
texture coordinates, colors, edge flags, and material properties.

There are ten primitive types, as follows:

Points individual points

Lines pairs of vertices interpreted as individual line segments

https://web.cs.wpi.edu/~matt/courses/cs563/talks/OpenGL_Presentation/OpenGL_Presentation.html#Per-fragment Operations 3/8
9/18/22, 5:07 AM Overview of OpenGL

Polygon boundary of a simple, convex polygon

Triangles triples of vertices interpreted as triangles

Quads quadruples of vertices interpreted as four-sided polygons

Line Strip series of connected line segments

Line Loop same as above, with a segment added between last and first vertices

Triangle Strip linked strip of triangles

Triangle Fan linked fan of triangles

Quad Strip linked strip of quadrilaterals

Vertices may be specified in 2D, 3D, or 4D. 2D coordinates are promoted to 3D by assigning a Z
value of zero. 4D homogeneous coordinates are reduced to 3D by dividing x, y, and z by the w
coordinate (if non-zero).
https://web.cs.wpi.edu/~matt/courses/cs563/talks/OpenGL_Presentation/OpenGL_Presentation.html#Per-fragment Operations 4/8
9/18/22, 5:07 AM Overview of OpenGL

Optional vertex attributes are picked up from state if not specified per-vertex. The normal is a 3D
vector perpendicular to the surface being described, and is used during lighting calculations. The
color may be an RGBA value, or a Color Index, depending on the visual type of the window.
Texture coordinates determine the mapping of a texture onto the vertex, and may be specified
with 1, 2, 3, or 4 parameters. Edge flags are used to specify if the vertex is on a boundary of a
surface. Material properties specify such things as reflectance, ambience, etc, and are used for
lighting calculations.

These vertex and attribute commands, as well as many other OpenGL commands, accept
arguments either explicitely or through pointers. They also accept a variety of data types as
arguments, such as ints, floats, doubles, bytes, unsigned ints and bytes, etc.

Commands not associated with primitives are not allowed within Begin/End blocks. This allows
increased optimization of primitive processing.

The model-view matrix, texture matrix, and projection matrix each affect the vertex and its
attributes, and may be easily manipulated via transformations such as rotation, scaling, and
translation.

Lighting parameters, such as material properties, light source properties, and lighting model
parameters affect lighting on a per-vertex basis.

Clipping and Projection

Once a primitive has been assembled, it is subject to arbitrary clipping via user definable clip
planes. An OpenGL implementation must provide at least six, and they may be turned on and off
independently by the user.

Points are either clipped in our out, depending on whether they fall inside or outside the half-
space defined by the clip planes. Lines and polygons, however, may either be 100% clipped,
100% unclipped, or they may fall partially within the clip space. In this latter case, new vertices
are automatically place on the clip boundary between pre-existing vertices. Vertex attributes are
interpolated.

After clipping, vertices are transformed by the projection matrix (either perspective or
orthagonal), and then clipped to the frustum (view space), following the same process as above.
Finally, the vertices are mapped to the viewport (screen space).

Rasterization
Rasterization converts the above viewport-mapped primitives into fragments. Fragments consist
of pixel location in framebuffer, color, texture coordinates, and depth (z buffer). Depending on
the shading mode, vertex attributes are either interpolated across the primitive to all fragments
(smooth shading), or all fragments are assigned the same values based on one vertex's attributes
(flat shading).

Rasterization is affected by the point and line widths, the line stipple sequence, and the polygon
stipple pattern. Antialiasing may be enabled or disabled for each primitive type. If enabled, the

https://web.cs.wpi.edu/~matt/courses/cs563/talks/OpenGL_Presentation/OpenGL_Presentation.html#Per-fragment Operations 5/8

9/18/22, 5:07 AM Overview of OpenGL

alpha color value (if in RGBA mode) or color index (if in CI mode) are modified to reflect sub-
pixel coverage.

Pixel rectangles and bitmaps are also rasterized, but they bypass the lighting and geometrical
transformations. They are groups of values heading for the framebuffer. They can be scaled,
offset, and mapped via lookup tables. The rasterization process produces a rectangle of
fragments at a location controlled by the current raster position state variable. The size may be
affected by the pixel zoom setting.

Bitmaps are similar to pixel rectangles, but the data is binary, only producing fragments when
on. This is useful for drawing text in 3D space as part of a scene.

Texturing and Fog

When enabled, a fragment's texture coordinates index a texture image, generating a texel. The
texel may represent just intensity, transparancy, or full RGBA color. The texel modifies the
fragment's color based on the current texture environment, which can either be decal, blend, or
modulate mode.

The texture being mapped may be filtered by a variety of texture filters, each a trade-off of
quality versus computational cost. Mipmaps may be specified, allowing smaller representations
of the texture to be used when the projected size of the primitive is small.

After texturing, a fog function may be applied to the fragments. This is a blend of the fragment's
color with a constant, user-specifiable fog color. The blend is based on the distance of the viewer
from the fragment, and may either be linear (depth curing) or exponential (atmospheric affects).

Framebuffer
Fragments produced by rasterization go to the framebuffer where they may be displayed. The
framebuffer is a rectangular array of n bitplanes. The bitplanes are organized into several logical
buffers -- Color, Depth, Stencil, and Accumulation.

The color buffer contains the fragment's color info.

The depth buffer contains the fragment's depth info, typically used for z-buffering hidden surface
removal.

The stencil buffer can be associated with fragments that pass the conditional tests described
below and make it into the framebuffer. It can be useful for multiple-pass algorithms.

The accumulation buffer is also used for multiple-pass algorithms. It can average the values
stored in the color buffer. Full-screen antialiasing can be achieved by jittering the viewpoint.
Depth of Field can be achieved by jittering the view angle. Motion blur can be achieved by
stepping the scene in time.

Stereo and double-buffering may be supported under OpenGL, depending on the

implementation. These would further divide the framebuffer into up to 4 sections -- front and
back buffer, left and right. Other auxiliary buffers may be available on some implementations.
Any buffers may be individually enabled or disabled for writing. The depths and availabilities of
https://web.cs.wpi.edu/~matt/courses/cs563/talks/OpenGL_Presentation/OpenGL_Presentation.html#Per-fragment Operations 6/8
9/18/22, 5:07 AM Overview of OpenGL

buffers may vary, but must meet the minimum requirement of OpenGL. Each buffer may be
individually cleared to a specified value.

Per-fragment Operations
Before being placed into the framebuffer, each fragment may be subjected to a series of tests and
modifications, each of which may be individually enabled, disabled, and controlled. These
include stencil test, depth test, and blending.

The stencil test compares the value in the stencil buffer associated with the fragment with a
reference value. If successful, the stencil value may be updated and the fragment proceeds to the
next test. If it fails, the fragment is discarded, and the stencil value may be updated with another
value.

The depth test is similar. It compares the fragment's depth with that currently in the depth buffer.
If successful, the depth buffer is updated and the fragment proceeds to the next test. Otherwise,
the fragment is discarded and the depth buffer is unchanged.

Blending mixes the fragment's color with the color already in the color buffer based on some
blend function. This is used for antialiasing and transparency.

Miscellaneous
Evaluators
Evaluators allow the specification of polynomial functions of 1 or 2 variables which may be used
to determine a primitive's vertex coordinates, normal coordinates, texture coordinates, and/or
color. A polynomial map based on a Bezier basis may be specified for any of these attributes
individually.

Evaluators may either be used within primitives (generating individual vertices) or outside of
primitives (generating entire primitives).

Display Lists
Display lists encapsulate a group of commands so that they may be later issued as many times as
desired simply by calling the list by name. This allows increased optimization, server-side
command caching, and simplified user programming. Display lists may be redefined, but may
not be edited. They can be nested, however.

Feedback and Selection

So far we have discussed OpenGL's render mode, by which primitives are rendered to the
framebuffer. There are two other modes -- feedback and selection.

In feedback mode, primitives are intercepted after processing but before rasterization. It returns
info about the primitives, such as vertex coordinates, texture coordinates, and color. This is
useful for rendering to vector devices, such as pen plotters.

https://web.cs.wpi.edu/~matt/courses/cs563/talks/OpenGL_Presentation/OpenGL_Presentation.html#Per-fragment Operations 7/8

9/18/22, 5:07 AM Overview of OpenGL

In selection mode, OpenGL returns a "hit" whenever a clipped primitive lies within the view
frustum. This can be useful for picking primitives via the cursor.

OpenGL State
Nearly all of OpenGL state may be queried. Most attributes may be pushed and popped from
stacks to quickly go back and forth between state configurations.

Summary
OpenGL is a fully functional primitive-level API that allows the programmer to efficiently
address and take advantage of graphics hardware. Many high-level libraries and applications
make use of OpenGL due to its performance, ease of programming, extensibility, and widespread
support.

References and Related Links

Books
Neider, Jackie, Tom Davis, and Mason Woo, OpenGL Programming Guide: The
Official Guide to Learning OpenGL, Release 1, Addison-Wesley, Reading,
Massachusetts, 1993 (ISBN 0-201-63274-8).
OpenGL Architecture Review Board, OpenGL Reference Manual: The Official
Reference Document for OpenGL, Release 1, Addison-Wesley, Reading,
Massachusetts, 1992 (ISBN 0-201-63276-4).
WWW
The OpenGL Graphics Interface
OpenGL Overview
OpenGL Data Sheet
OpenGL WWW Center
OpenGL Specification and Man Pages
The OpenGL Performance Characterization Project
Gateway to OpenGL Info
Usenet
comp.graphics.api.opengl
comp.graphics.api.misc

Copyright © 1997 by Benj Lipchak.

All rights reserved.

OpenGL® is a registered trademark of Silicon Graphics, Inc.

https://web.cs.wpi.edu/~matt/courses/cs563/talks/OpenGL_Presentation/OpenGL_Presentation.html#Per-fragment Operations 8/8

 CS 432/680
INTERACTIVE COMPUTER GRAPHICS

Introduction to OpenGL
Week 1

David Breen
Department of Computer Science
Drexel University

Based on material from Ed Angel, University of New Mexico

 Objectives
• Learn the basic design of a graphics
system
• Introduce graphics pipeline architecture
• Describe software components of an
interactive graphics system

2
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 Image Formation
Revisited
• Can we mimic the synthetic camera model to
design graphics hardware and software?
• Application Programmer Interface (API)
– Need only specify
• Objects
• Materials
• Viewer
• Lights
• But how is the API implemented?

3
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 Physical Approaches
• Ray tracing: follow rays of light from center
of projection until they either are absorbed by
objects or go off to infinity
– Can handle global effects
• Multiple reflections
• Translucent objects
– Slow
– Need whole data base
• Radiosity: Energy based
approach
– Very slow 4
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 Practical Approach
• Process objects one at a time in the order
they are generated by the application
– Can consider only local lighting
• Pipeline architecture

application display
program
• All steps can be implemented in hardware on
the graphics card
5
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 The Programmer’s
Interface

• Programmer sees the graphics system

through an interface: the Application
Programmer Interface (API)

6
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 API Contents
• Functions that specify what we need to
form an image
– Objects
– Viewer
– Light Source(s)
– Materials
• Other information
– Input from devices such as mouse and
keyboard
– Capabilities of system
7
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 Object Specification
• Most APIs support a limited set of primitives
including
– Points (1D object)
– Line segments (2D objects)
– Polygons (3D objects)
– Some curves and surfaces
• Quadrics
• Parametric polynomial
• All are defined through locations in space or
vertices
8
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 Example
type of object
location of vertex
glBegin(GL_POLYGON)
glVertex3f(0.0, 0.0, 0.0);
glVertex3f(0.0, 1.0, 0.0);
glVertex3f(0.0, 0.0, 1.0);
glEnd( );

end of object definition

9
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 Camera Specification
• Six degrees of freedom
– Position of center of lens
– Orientation
• Lens
• Film size
• Orientation of film plane

10
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 Lights and Materials
• Types of lights
– Point sources vs distributed sources
– Spot lights
– Near and far sources
– Color properties
• Material properties
– Absorption: color properties
– Scattering
• Diffuse
• Specular
11
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 Following the Pipeline:
Transformations
• Much of the work in the pipeline is in
converting object representations from
one coordinate system to another
– World coordinates
– Camera coordinates
– Screen coordinates
• Every change of coordinates is
equivalent to a matrix transformation

12
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 Clipping
• Just as a real camera cannot “see” the
whole world, the virtual camera can only
see part of the world space
– Objects that are not within this volume are
said to be clipped out of the scene

13
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 Projection
• Must carry out the process that
combines the 3D viewer with the 3D
objects to produce the 2D image
– Perspective projections: all projectors meet
at the center of projection
– Parallel projection: projectors are parallel,
center of projection is replaced by a
direction of projection

14
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 Rasterization
• If an object is visible in the image, the
appropriate pixels in the frame buffer must be
assigned colors
– Vertices assembled into objects
– Effects of lights and materials must be determined
– Polygons filled with interior colors/shades
– Must have also determine which objects are in
front (hidden surface removal)

15
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
Programming with OpenGL
Part 1: Background

David Breen
Department of Computer Science
Drexel University
 Objectives
• Development of the OpenGL API
• OpenGL Architecture
– OpenGL as a state machine
• Functions
– Types
– Formats
• Simple program
17
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 Early History of APIs
• IFIPS (1973) formed two committees to come
up with a standard graphics API
– Graphical Kernel System (GKS)
• 2D but contained good workstation model
– Core
• Both 2D and 3D
– GKS adopted as IS0 and later ANSI standard
(1980s)
• GKS not easily extended to 3D (GKS-3D)
• Far behind hardware development
18
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 PHIGS and X
• Programmers Hierarchical Graphics System
(PHIGS)
– Arose from CAD community
– Database model with retained graphics
(structures)
• X Window System
– DEC/MIT effort
– Client-server architecture with graphics
• PEX combined the two
– Not easy to use (all the defects of each)
19
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 SGI and GL
• Silicon Graphics (SGI) revolutionized the
graphics workstation by implementing the
pipeline in hardware (1982)
• To use the system, application programmers
used a library called GL
• With GL, it was relatively simple to program
three dimensional interactive applications

20
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 OpenGL
• GL’s success 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
21
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 OpenGL Evolution
• Controlled by an Architectural Review Board
(ARB)
– Members include SGI, Microsoft, Nvidia, HP,
3DLabs, IBM, ATI, Apple, Intel, …….
– Relatively stable (present version 2.1)
• Evolution reflects new hardware capabilities
– 3D texture mapping and texture objects
– Vertex programs
– Programmable shaders
– Allows for platform specific features through
extensions

22
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 OpenGL Libraries
• OpenGL core library
– OpenGL32 on Windows
– GL on most unix/linux systems
• 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
– AGL for Macintosh
23
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 GLUT
• OpenGL Utility Library (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
• Slide bars

24
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 Software Organization
application program

OpenGL Motif
widget or similar GLUT
GLX, AGL
or WGL GLU

X, Win32, Mac O/S GL

software and/or hardware

25
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 OpenGL Architecture
Immediate Mode Geometric
pipeline
Per Vertex
Polynomial Operations &
Evaluator Primitive
Assembly

Display Per Fragment Frame

CPU List
Rasterization
Operations Buffer

Texture
Memory
Pixel
Operations
26
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 OpenGL Functions
• Primitives
– Points
– Line Segments
– Polygons
• Attributes
• Transformations
– Viewing
– Modeling
• Control
• Input (GLUT)
27
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 OpenGL State
• OpenGL is a state machine
• 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

28
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 Lack of Object
Orientation
• OpenGL is not object oriented so that
there are multiple functions for a given
logical function, e.g. glVertex3f,
glVertex2i, glVertex3dv,…..
• Underlying storage mode is the same
• Easy to create overloaded functions in
C++ but issue is efficiency

29
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 OpenGL function format
function name

glVertex3f(x,y,z)

x,y,z are floats

belongs to GL library

glVertex3fv(p)

p is a pointer to an array
30
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 OpenGL #defines
• Most constants are defined in the include files
gl.h, glu.h and glut.h
– Note #include <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,….
31
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 A Simple Program
Generate a square on a solid background

32
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 simple.c
#include <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){
glutCreateWindow("simple");
glutDisplayFunc(mydisplay);
glutMainLoop();
} 33
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 Event Loop
• Note that the program defines a display
callback function named mydisplay
– Every glut program must have a display callback
– The display callback is executed whenever
OpenGL decides the display must be refreshed,
for example when the window is opened
– The main function ends with the program entering
an event loop

34
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 Defaults
• simple.c is too simple
• Makes heavy use of state variable
default values for
– Viewing
– Colors
– Window parameters
• Next version will make the defaults
more explicit
35
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 Notes on compilation
• Unix/linux
– Include files usually in …/include/GL
– Compile with –lglut –lglu –lgl loader flags
– May have to add –L flag for X libraries
– Mesa implementation included with most
linux distributions

36
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 Notes on compilation
• On tux

– #include <GL/glut.h>
– g++ *.cpp -L/usr/X11R6/lib -lGL -lglut -lGLU

37
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 Compilation on Windows

• 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)
• Borland C similar
• Cygwin (linux under Windows)
– Can use gcc and similar makefile to linux
– Use –lopengl32 –lglu32 –lglut32 flags

38
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
Programming with OpenGL
Part 2: Complete Programs

David Breen
Department of Computer Science
Drexel University
 Objectives
• Refine the first program
– Alter the default values
– Introduce a standard program structure
• Simple viewing
– Two-dimensional viewing as a special
case of three-dimensional viewing
• Fundamental OpenGL primitives
• Attributes
40
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 Program Structure
• Most OpenGL programs have a similar structure that
consists of the following functions
– main():
• defines the callback functions
• opens one or more windows with the required properties
• enters event loop (last executable statement)
– init(): sets the state variables
• viewing
• Attributes
– callbacks
• Display function
• Input and window functions

41
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 Simple.c revisited
• In this version, we will see the same
output but have defined all the relevant
state values through function calls with
the default values
• In particular, we set
– Colors
– Viewing conditions
– Window properties

42
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 main.c
#include <GL/glut.h> includes gl.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); define window properties
init(); display callback
glutMainLoop(); set OpenGL state
}

enter event loop

43
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 GLUT functions
• glutInit allows application to get command line
arguments and initializes system
• gluInitDisplayMode requests properties of the window
(the rendering context)
– RGB color
– Single buffering
– Properties logically ORed together
• glutWindowSize in pixels
• glutWindowPosition from top-left corner of display
• glutCreateWindow create window with title “simple”
• glutDisplayFunc display callback
• glutMainLoop enter infinite event loop

44
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 init.c

black clear color

void init() opaque window
{
glClearColor (0.0, 0.0, 0.0, 1.0);

glColor3f(1.0, 1.0, 1.0);

fill with white
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0);
}
viewing volume
45
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 Coordinate Systems
• The units used in glVertex are
determined by the application and are
called world or problem coordinates
• The viewing specifications are also in
world coordinates and it is the size of the
viewing volume that determines what will
appear in the image
• Internally, OpenGL will convert to camera
coordinates and later to screen
coordinates
46
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 OpenGL Camera
• OpenGL places a camera at the origin
pointing in the negative z direction
• The default viewing volume
is a box centered at the
origin with sides of
length 2

47
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 Orthographic Viewing
In the default orthographic view, points are
projected along the z axis onto the plane z=0

z=0

z=0

48
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 Transformations and
Viewing
• In OpenGL, the projection is carried out by a
projection matrix (transformation)
• There is only one set of transformation functions so
we must set the matrix mode first
glMatrixMode (GL_PROJECTION)
• Transformation functions are incremental so we start
with an identity matrix and alter it with a projection
matrix that gives the view volume
glLoadIdentity ();
glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0);

49
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 Two- and three-dimensional
viewing
• In glOrtho(left, right, bottom, top,
near, far) the near and far distances are
measured from the camera
• Two-dimensional vertex commands place all
vertices in the plane z=0
• If the application is in two dimensions, we can use
the function
gluOrtho2D(left, right,bottom,top)
• In two dimensions, the view or clipping volume
becomes a clipping window
50
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 mydisplay.c

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();
}
51
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 OpenGL Primitives

GL_POINTS GL_POLYGON
GL_LINES GL_LINE_STRIP

GL_LINE_LOOP

GL_TRIANGLES
GL_QUAD_STRIP

GL_TRIANGLE_STRIP GL_TRIANGLE_FAN

52
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 Polygon Issues
• OpenGL will only display polygons correctly that
are
– Simple: edges cannot cross
– Convex: All points on line segment between
two points in a polygon are also in the polygon
– Flat: all vertices are in the same plane
• User program must check if above true
• Triangles satisfy all conditions

nonsimple polygon nonconvex polygon

53
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 Text
• Not an OpenGL primitive
• Fonts provides by windowing system are
not portable
• GLUT has some bitmap and stroke fonts

– glutBitmapCharacter(void *font, int char)

– glutBitmapCharacter(void *font, int char)

54
 GLUT Bitmap Text
• glutBitmapCharacter(void *font, int char)
– Displays char at current raster position
• glRasterPos[23][sifd](TYPE x, TYPE y,
TYPE z)
– Sets raster position by transforming world
coordinate point into screen coordinates
• Current raster position is automatically
incremented after char is displayed
• Example (10 pt times roman)
– glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_10,
‘a’)
55
 GLUT Stroke Text
• glutStrokeCharacter(void *font, int char)
– Displays char at current world location
mapped to screen
• Stroke text is geometry that is modified by
modeling transformations
• Each character is approximately 100 x 100
in world coordinates
• Example (roman)
– glutStrokeCharacter(GLUT_STROKE_ROMAN, ‘a’)

56
 Attributes
• Attributes are part of the OpenGL state
and determine the appearance of objects
– Color (points, lines, polygons)
– Size and width (points, lines)
– Stipple pattern (lines, polygons)
– Polygon mode
• Display as filled: solid color or stipple pattern
• Display edges
58
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 RGB color
• Each color component stored separately in
the frame buffer
• Usually 8 bits per component in buffer
• Note in glColor3f the color values range
from 0.0 (none) to 1.0 (all), while in
glColor3ub the values range from 0 to 255

59
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 Indexed Color
• Colors are indices into tables of RGB
values
• Requires less memory
– indices usually 8 bits
– not as important now
• Memory inexpensive
• Need more colors for shading

60
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 Color and State
• The color as set by glColor becomes part of the state
and will be used until changed
– Colors and other attributes are not part of the object
but are assigned when the object is rendered
• We can create conceptual vertex colors by code such
as
glColor
glVertex
glColor
glVertex

61
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 Smooth Color
• Default is smooth shading
– OpenGL interpolates vertex colors across visible
polygons
• Alternative is flat shading
– Color of first vertex
determines fill color
• glShadeModel
(GL_SMOOTH)
or GL_FLAT

62
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002
 Viewports
• Do not have to use the entire window
for the image: glViewport(x,y,w,h)
• Values in pixels (screen coordinates)

63
Angel: Interactive Computer Graphics 3E © Addison-Wesley 2002