OpenGL

OpenGL (Open Graphics Library) is a specification defining a cross-language cross-platform API for writing applications that produce 3D computer graphics (and 2D computer graphics as well). The interface consists of over 250 different function calls which can be used to draw complex three-dimensional scenes from simple primitives. It is very popular in the video games industry where it competes with Direct3D (on Microsoft Windows) (see Direct3D vs. OpenGL). OpenGL is widely used in CAD, virtual reality, scientific visualisation, information visualisation and video game development.

Specification

At its most basic level, OpenGL is a specification, meaning it is simply a document that describes a set of functions and the precise behaviours that they must perform. From this specification, hardware vendors create implementations — libraries of functions created to match the functions stated in the OpenGL specification. These implementations are designed to utilize the capabilities of their hardware where possible. When hardware acceleration is not available, the implementations need to emulate the functionality through software. Hardware vendors have to meet specific tests to be able to qualify their implementation as an OpenGL implementation. In this way, software developers just need to understand how to use the functions in the OpenGL specification, and can rely on hardware vendors to take care of making the interface from software to hardware very efficient.

Efficient implementations of OpenGL (leveraging graphics acceleration hardware to a greater or lesser extent) exist for Windows, many Unix platforms and Linux, Playstation 3, and Mac OS. These implementations are generally provided by display device manufacturers and rely heavily on the hardware provided by that manufacturer. The open source library Mesa is a fully software-based graphics API which is code-compatible with OpenGL. However, for licensing reasons it claims merely to be a "very similar" API.

The OpenGL specification is overseen by the OpenGL Architecture Review Board (ARB), which was formed in 1992. The ARB consists of a set of companies with a vested interest in creating a consistent and widely available API. According to the official OpenGL website, voting members of the ARB as of November 2004 include professional graphics hardware manufacturers SGI, 3Dlabs, Matrox and Evans & Sutherland (military applications), consumer graphics hardware manufacturers ATI Technologies and NVIDIA, processor specialist Intel, and computer manufacturers IBM, Apple Computer, Dell, Hewlett-Packard, and Sun Microsystems. Microsoft, one of the founding members, left in March 2003. Aside from these corporations, each year many other companies are invited to be part of the OpenGL ARB for one-year terms. With so many companies involved with such a diverse set of interests, OpenGL has become very much a general-purpose API with a wide range of capabilities.

Kurt Akeley and Mark Segal authored the original OpenGL specification. Chris Frazier edited version 1.1. Jon Leech edited versions 1.2 through the present version 2.0.

Extensions

The OpenGL standard allows individual vendors to provide additional functionality through extensions as new technology is created. An extension is then distributed in two parts: as a header file which contains the extension's function prototypes, and as the vendor's device driver. Each vendor has an alphabetic abbreviation that is used in naming their new functions and constants. For example, NVIDIA's abbreviation (NV) is used in defining their proprietary function glCombinerParameterfvNV() and their constant GL_NORMAL_MAP_NV. It may happen that more than one vendor agrees to implement the same extended functionality. In that case, the abbreviation EXT is used. It may further happen that the Architecture Review Board "blesses" the extension. It then becomes known as a standard extension, and the abbreviation ARB is used. The first ARB extension was GL_ARB_multitexture, introduced in version 1.2.1. Following the official extension promotion path, multitexturing is no longer an optionally implemented ARB extension, but has been a part of the OpenGL core API since version 1.3. Specifications for nearly all extensions can be found at the official extension registry [1].

Associated Utility Libraries

Several libraries are built on top of or beside OpenGL to provide features not available in OpenGL itself, libraries such as GLU can always be found with OpenGL implementations, others such as GLUT and SDL have grown over time and to provide rudimentary cross platform windowing and mouse functionality and if unavailable can easily be downloaded and added to a development environment. Simple graphical user interface functionality can be found in libraries like GLUI or FLTK. Still others libraries like AUX are deprecated libraries that have been superceded by functionality commonly available in more popular libraries, but code still exists out there particularly in simple tutorials. Other libraries have been created to provide OpenGL application developers a simple means of managing OpenGL extensions and versioning, examples of these libraries include GLEW "The OpenGL Extension Wrangler Library" and GLEE "The OpenGL Easy Extension library".

In addition to the aforementioned simple libraries other higher level object oriented scene graph retained mode libraries exist such as OpenSceneGraph and OpenGL Performer, these are available as cross platform Open Source or proprietary programming interfaces written on top of OpenGL and systems libraries to enable the creation of real-time visual simulation applications.

Bindings

In order to enforce its multi-language and multi-platform characteristics, various bindings and ports have been developed for OpenGL in many languages. Most notably, the Java 3D library can rely on OpenGL for its hardware acceleration. Direct bindings are also available like the Lightweight Java Game Library which has a direct binding of OpenGL for Java and other game related components. Very recently, Sun has released beta versions of the JOGL system, which provides direct bindings to C OpenGL commands, unlike Java 3D which does not provide such low level support. The OpenGL official page [2] lists various bindings for Java, Fortran 90, Perl, Pike, Python, Ada, and Visual Basic. Bindings are also available for C++ and C#, see [3].

Higher level functionality

OpenGL was designed to be output-only: it provides only rendering functions. The core API has no concept of windowing systems, audio, printing, keyboard/mouse, or other input devices. While this seems restrictive at first, it allows the code that does the rendering to be completely independent of the operating system it is running on, allowing cross-platform development. However some integration with the native windowing system is required to allow clean interaction with the host system. This is performed through the following add-on APIs:

• GLX - X11 (including network transparency)
• WGL - Microsoft Windows

Additionally the GLUT and SDL libraries provide functionality for basic windowing using OpenGL, in a portable manner. Mac OS X has three APIs to get OpenGL support: AGL for Carbon, NSOpenGL for Cocoa and CGL for lower-level access.

History

Today the digital generation of animated scenes in three dimensions is a regular fixture in everyday life. Scientists utilise computer graphics to analyse simulations of every possibility. Engineers and architects design virtual models using computer graphics. Movies employ computer graphics to create stunning special effects or entire animated films. And over the past few years, computer games have brought computer graphics technology to regular consumers, using graphics to bring their players into worlds that could never exist.

Bringing digital graphics technology to such widespread use was not without its challenges. Fifteen years ago, developing software that could function with a wide range of graphics hardware and all of their different interfaces was time consuming. Each team of programmers developed interfaces separately, and there was consequently much duplicated code. This was hindering the growing industry of computer graphics.

Silicon Graphics Incorporated specialises in the creation of specialised graphics hardware and software. Being the world leader in 3D graphics at the time, SGI naturally saw this hardware interface problem as a barrier to market growth. It therefore sought to standardise and abstract access to hardware.

The solution came in the form of a graphics API, known as OpenGL. OpenGL standardised access to hardware, and pushed the development responsibility of hardware interface programs, sometimes called device drivers, to hardware manufacturers. With so many different kinds of graphic hardware, getting them all to speak the same language in this way had a remarkable impact by giving software developers a higher level platform for 3D-software development.

In 1992, SGI led the creation of the OpenGL architectural review board (OpenGL ARB), the group of companies that would design the OpenGL specification for years to come. OpenGL evolved from (and is very similar in style to) SGI's earlier 3D interface, IRIS GL. One of the restrictions of IRIS GL was that it only provided access to features supported by the underlying hardware. If the graphics hardware did not support a feature, then the application could not use it. OpenGL overcame this problem by providing support in software for features unsupported by hardware, allowing applications to use advanced graphics on relatively low-powered systems.

When Direct3D was released in 1995, Microsoft, SGI, and Hewlett-Packard initiated the Fahrenheit project, which was a joint effort with the goal of unifying the OpenGL and Direct3D interfaces. It initially showed some promise of bringing order to the world of interactive 3D computer graphics APIs, but on account of financial constraints at SGI and general lack of industry support it was abandoned.

OpenGL 2.0

In comparison to DirectX, it has been said that one of the main problems with OpenGL is that its Architecture Review Board has such a large number of companies with such a diverse set of interests that deciding on each revision of the specification takes a lot of time. OpenGL 2.0 was conceived of by 3Dlabs to address concerns that OpenGL was stagnating and lacked a strong direction. 3Dlabs proposed a number of major additions to the standard, the most significant of which was GLSL (the OpenGL Shading Language). This would enable the programmer to replace the OpenGL fixed-function vertex and fragment pipelines with shaders written in a C-like language to create some of the most stunning effects such as bump mapping, heat haze and water waves and ripples. GLSL was notable for making relatively few concessions to the limitations of the hardware then available; this harked back to the earlier tradition of OpenGL setting ambitious, forward-looking targets for new 3D accelerators rather than merely tracking the state of currently available hardware. The final OpenGL 2.0 specification [4] included support for GLSL, but omitted many of the other features originally proposed - these were deferred to future versions of OpenGL, although some are now available as extensions.

Sample Renderings

The rasterization phase is the last step in the OpenGL rendering pipeline. It produces the final display product for the scene to be displayed.

Scene-1 rendered using OpenGL

Scene-2 rendered using OpenGL

Future in Microsoft Windows

On August 6, 2005, Microsoft's intentions for OpenGL support in Windows Vista were revealed on in an Opengl.org news announcement:

Microsoft's current plan for OpenGL on Windows Vista is to layer OpenGL over Direct3D in order to use OpenGL with a composited desktop to obtain the Aeroglass experience. If an OpenGL ICD is run - the desktop compositor will switch off - significantly degrading the user experience.

In practice this means for OpenGL under Aeroglass:

OpenGL performance will be significantly reduced - perhaps as much as 50%

OpenGL on Windows will be fixed at a vanilla version of OpenGL 1.4

No extensions will be possible to expose future hardware innovations

It would be technically straightforward to provide an OpenGL ICD within the full Aeroglass experience without compromising the stability or the security of the operating system. Layering OpenGL over Direct3D is a policy more than a technical decision.

As a result, the future of Microsoft Windows support of OpenGL as a mainstream library for computer and video games looks precarious. Microsoft has taken the decision not to release the information necessary to allow third parties (such as those at NVIDIA, ATI or the other large graphics card manufacturers) to develop replacement drivers, leaving no way to avoid the 50% speed drop. A 3Dlabs employee states in the same Opengl.org thread:

This information came from the OpenGL BOF held at Siggraph 2005 in LA this last Wednesday evening. This was confirmed at the BOF by NVIDIA, ATI and us (3Dlabs).

As soon as an [installable client driver] is loaded the composited desktop is turned off on Windows Vista. If you want the composited desktop Aeroglass experience, you will need to make your application go through Microsoft's OpenGL implementation, which is layered on top of DirectX. As pointed out earlier, this layering can have performance implications. Their implementation supports OpenGL version 1.4 only, without extension support.

We believe it possible to provide an ICD with full composited desktop support while adhering to the stability and security requirements in Windows Vista. But we need Microsoft's help in doing so.

Therefore, as mentioned before, please let your contact in the ISV or IHV or OEM community know how you feel about this and spread the word.

For some more information, you can browse these Microsoft WinHEC slides:

"Windows Graphics Overview [WinHEC 2005; 171 KB]" http://download.microsoft.com/download/9/8/f/98f3fe47-dfc3-4e74-92a3-088782200fe7/TWPR05007_WinHEC05.ppt

"Advances in Display and Composition Architecture for Windows [WinHEC 2005; 422 KB]" http://download.microsoft.com/download/9/8/f/98f3fe47-dfc3-4e74-92a3-088782200fe7/TWPR05005_WinHEC05.ppt

Regards, Barthold 3Dlabs

An installable client driver is the glue provided by a card manufacturer to connect your operating system with your graphics card.

See also

• OpenGL ES
• LWJGL
• JOGL
• Graphics pipeline

Further reading

• Fosner, Ron: OpenGL Programming for Windows 95 and Windows NT, Addison Wesley, ISBN 0-201-40709-4
• Kilgard, Mark: OpenGL for the X Window System, Addison-Wesley, ISBN 0-201-48359-9
• OpenGL Architecture Review Board, et al: OpenGL Reference Manual: The Official Reference Document to OpenGL, Version 1.4, Addison-Wesley, ISBN 0-321-17383-X
• Rost, Randi J.: OpenGL Shading Language, Addison-Wesley, ISBN 0-321-19789-5
• OpenGL Architecture Review Board, et al: OpenGL Programming Guide: The Official Guide to Learning OpenGL, Version 2, Fifth Edition, Addison-Wesley, ISBN 0-321-33573-2

External links

• Official website
• Online copy of an early edition of The OpenGL Programming Guide
• 2D to 3D surface conversion and texture manipulation routines

Programmer resources

• Neon Helium - Learning material on OpenGL. Critizised for only teaching to copy and paste.
• CodeSampler.com - Code samples and tutorials for OpenGL game programming.
• OpenGL Directory - Compilation of resources and links for anything OpenGL.
• OpenGL Lighting Model
• Basic OpenGL Lighting - an explanation of the standard OpenGL lighting by Steve Baker
• LablGL - OpenGL bindings for the Objective Caml language.
• Simple LablGL examples - starting with a minimal 7-line program.
• HOpenGL - OpenGL bindings for the language Haskell.
• OpenGL screensaver basecode - for Windows and Linux, GPL license
• JOGL OpenGL binding for the Java language.
• Blender - Open Source modelling software using OpenGL.
• LWJGL OpenGL binding for the Java language and other game related components