Lecture No.32 Introduction to OpenGL
As a software interface for graphics hardware, OpenGL renders multidimensional objects
into a frame buffer. OpenGL is industry-standard graphics software with which
programmers can create high-quality still and animated three-dimensional color images.
OpenGL is built for compatibility across hardware and operating systems. This
architecture makes it easy to port OpenGL programs from one system to another. While
each operating system has unique requirements, the OpenGL code in many programs can
be used as is.
Designed for use by C/C++ programmers
OpenGL can run on Linux and all versions of 32 bit Microsoft Windows.
Most Widely Adopted Graphics Standard
OpenGL is the premier environment for developing portable, interactive 2D and 3D
graphics applications. Since its introduction in 1992, OpenGL has become the industry's
most widely used and supported 2D and 3D graphics application programming interface
(API), bringing thousands of applications to a wide variety of computer platforms.
OpenGL fosters innovation and speeds application development by incorporating a broad
set of rendering, texture mapping, special effects, and other powerful visualization
functions. Developers can leverage the power of OpenGL across all popular desktop and
workstation platforms, ensuring wide application deployment.
High Visual Quality and Performance
Any visual computing application requiring maximum performance-from 3D animation
to CAD to visual simulation-can exploit high-quality, high-performance OpenGL
capabilities. These capabilities allow developers in diverse markets such as broadcasting,
CAD/CAM/CAE, entertainment, medical imaging, and virtual reality to produce and
display incredibly compelling 2D and 3D graphics.
An independent consortium, the OpenGL Architecture Review Board, guides the
OpenGL specification. With broad industry support, OpenGL is the only truly
open, vendor-neutral, multiplatform graphics standard.
OpenGL implementations have been available for more than seven years on a
wide variety of platforms. Additions to the specification are well controlled, and
proposed updates are announced in time for developers to adopt changes.
Backward compatibility requirements ensure that existing applications do not
xReliable and portable
All OpenGL applications produce consistent visual display results on any
OpenGL API-compliant hardware, regardless of operating system or windowing
Because of its thorough and forward-looking design, OpenGL allows new
hardware innovations to be accessible through the API via the OpenGL extension
mechanism. In this way, innovations appear in the API in a timely fashion, letting
application developers and hardware vendors incorporate new features into their
normal product release cycles.
OpenGL API-based applications can run on systems ranging from consumer
electronics to PCs, workstations, and supercomputers. As a result, applications can
scale to any class of machine that the developer chooses to target.
xEasy to use
OpenGL is well structured with an intuitive design and logical commands.
Efficient OpenGL routines typically result in applications with fewer lines of code
than those that make up programs generated using other graphics libraries or
packages. In addition, OpenGL drivers encapsulate information about the
underlying hardware, freeing the application developer from having to design for
specific hardware features.
Numerous books have been published about OpenGL, and a great deal of sample
code is readily available, making information about OpenGL inexpensive and
easy to obtain.
Simplifies Software Development, Speeds Time-to-Market
OpenGL routines simplify the development of graphics software—from rendering a
simple geometric point, line, or filled polygon to the creation of the most complex lighted
and texture-mapped NURBS curved surface. OpenGL gives software developers access
to geometric and image primitives, display lists, modeling transformations, lighting and
texturing, anti-aliasing, blending, and many other features.
Every conforming OpenGL implementation includes the full complement of OpenGL
functions. The well-specified OpenGL standard has language bindings for C, C++,
Fortran, Ada, and Java. All licensed OpenGL implementations come from a single
specification and language binding document and are required to pass a set of
conformance tests. Applications utilizing OpenGL functions are easily portable across a
wide array of platforms for maximized programmer productivity and shorter time-to-
All elements of the OpenGL state—even the contents of the texture memory and the
frame buffer—can be obtained by an OpenGL application. OpenGL also supports
visualization applications with 2D images treated as types of primitives that can be
manipulated just like 3D geometric objects. As shown in the OpenGL visualization
programming pipeline diagram above, images and vertices defining geometric primitives
are passed through the OpenGL pipeline to the frame buffer.
Supported on all UNIX® workstations, and shipped standard with every Windows
95/98/2000/NT and MacOS PC, no other graphics API operates on a wider range of
hardware platforms and software environments. OpenGL runs on every major operating
system including Mac OS, OS/2, UNIX, Windows 95/98, Windows 2000, Windows NT,
Linux, OPENStep, and BeOS; it also works with every major windowing system,
including Win32, MacOS, Presentation Manager, and X-Window System. OpenGL is
callable from Ada, C, C++, Fortran, Python, Perl and Java and offers complete
independence from network protocols and topologies.
Architected for Flexibility and Differentiation!
Although the OpenGL specification defines a particular graphics processing pipeline,
platform vendors have the freedom to tailor a particular OpenGL implementation to meet
unique system cost and performance objectives. Individual calls can be executed on
dedicated hardware, run as software routines on the standard system CPU, or
implemented as a combination of both dedicated hardware and software routines. This
implementation flexibility means that OpenGL hardware acceleration can range from
simple rendering to full geometry and is widely available on everything from low-cost
PCs to high-end workstations and supercomputers. Application developers are assured
consistent display results regardless of the platform implementation of the OpenGL
Using the OpenGL extension mechanism, hardware developers can differentiate their
products by developing extensions that allow software developers to access additional
performance and technological innovations.
Main purpose of OpenGL
As a software interface for graphics hardware, the main purpose of OpenGL is to render
two- and three-dimensional objects into a frame buffer. These objects are described as
sequences of vertices (that define geometric objects) or pixels (that define images).
OpenGL performs several processes on this data to convert it to pixels to form the final
desired image in the frame buffer.
The following topics present a global view of how OpenGL works:
Primitives and Commands discusses points, line segments, and polygons as the
basic units of drawing; and the processing of commands.
OpenGL Graphic Control describes which graphic operations OpenGL controls
and which it does not control.
Execution Model discusses the client/server model for interpreting OpenGL
Basic OpenGL Operation gives a high-level description of how OpenGL
processes data to produce a corresponding image in the frame buffer.
Primitives and Commands
OpenGL draws primitive points, line segments, or polygons subject to several selectable
modes. You can control modes independently of one another. That is, setting one mode
doesn't affect whether other modes are set (although many modes may interact to
determine what eventually ends up in the frame buffer). To specify primitives, set modes,
and perform other OpenGL operations, you issue commands in the form of function calls.
Primitives are defined by a group of one or more vertices. A vertex defines a point, an
endpoint of a line, or a corner of a polygon where two edges meet. Data (consisting of
vertex coordinates, colors, normals, texture coordinates, and edge flags) is associated with
a vertex, and each vertex and its associated data are processed independently, in order,
and in the same way. The only exceptions to this rule are cases in which the group of
vertices must be clipped so that a particular primitive fits within a specified region. In this
case, vertex data may be modified and new vertices created. The type of clipping depends
on which primitive the group of vertices represents.
Commands are always processed in the order in which they are received, although there
may be an indeterminate delay before a command takes effect. This means that each
primitive is drawn completely before any subsequent command takes effect. It also means
that state-querying commands return data that is consistent with complete execution of all
previously issued OpenGL commands.
OpenGL Graphic Control
OpenGL provides you with fairly direct control over the fundamental operations of two-
and three-dimensional graphics. This includes specification of such parameters as
transformation matrices, lighting equation coefficients, antialiasing methods, and pixel-
update operators. However, it doesn't provide you with a means for describing or
modeling complex geometric objects. Thus, the OpenGL commands you issue specify
how a certain result should be produced (what procedure should be followed) rather than
what exactly that result should look like. That is, OpenGL is fundamentally procedural
rather than descriptive. To fully understand how to use OpenGL, it helps to know the
order in which it carries out its operations.
The model for interpretation of OpenGL commands is client/server. Application code (the
client) issues commands, which are interpreted and processed by OpenGL (the server).
The server may or may not operate on the same computer as the client. In this sense,
OpenGL is network-transparent. A server can maintain several OpenGL contexts, each of
which is an encapsulated OpenGL state. A client can connect to any one of these
contexts. The required network protocol can be implemented by augmenting an already
existing protocol (such as that of the X Window System) or by using an independent
protocol. No OpenGL commands are provided for obtaining user input.
The window system that allocates frame buffer resources ultimately controls the effects of
OpenGL commands on the frame buffer. The window system: