The OpenGL Extension Registry is maintained by SGI and contains the technical specifications of all known OpenGL extensions. The registry also contains guidelines for creating new extensions and has example C/C++ header files containing function entry points and token enums.

The extension registry can be intimidating with over 350 extensions plotting the development of the OpenGL API for more than a decade. However, most of the extensions have either been folded into the OpenGL core API or have been rendered obsolete by newer core functionality.

Extension Types

Some extensions start with GL_EXT, others with GL_NV, GL_ATI, GL_ARB, GL_MTX, GL_APPLE, GL_SGI. EXT means it is multi-vendor. It is developed by multiple vendors and other companies can include it in there drivers as well. Below follows a table with frequently found extension prefixes.

Regardless of the vendor prefix, vendor-specific OpenGL extensions may be implemented an/or licensed by multiple hardware vendors to ensure compatibility.

¹, Experimental extensions should not be used in a production environment as they are subject to removal from implementation.

ARB Approval

Proprietary extensions which prove their worth can become ARB approved (such as GL_ARB_multitexture) and shortly after become core. Most likely, an extension is already of type EXT, then becomes ARB, then core. In some cases, but not many, a proprietary extension becomes ARB, then core. Often, the original extension’s developer allows other companies to also code it into their drivers without royalty requirements.

When a proprietary extension becomes an ARB approved core extension, the vendor will rarely – if ever – remove it from their extension implementation. This is done to ensure backwards compatibility with software which implements older extensions.

In some rare occasions, there is a difference between extension and the core function, for example the case of GLSL in OpenGL 2.0 and the older extensions, and the case for environment textures. Many of the extensions in the OpenGL Extension Registry (OpenGL Extension Registry) are deprecated, make sure deprecated extensions are not used.

Extension Development

Anyone may develop extensions for the OpenGL® API; the community gives feedback. An example case would be the GL_GREMEDY_string_marker extension, which was initially a private extension, is now included in the OpenGL Extension Registry.

Specific Extension Usage

Vertex submission extensions

• GL_ARB_vertex_buffer_object Core in GL 1.5, also known as VBO
• GL_NV_vertex_array_range VBO replaced this
• GL_EXT_compiled_vertex_array VBO replaced this

Texturing related extensions

• GL_ARB_multitexture Core in GL 1.2.1
• GL_ARB_texture_env_combine Core in GL 1.3
• GL_ARB_texture_compression Core in GL 1.3
• Floating point and mipmapping and filtering Core in GL 3.0
• GL_EXT_texture_integer Core in GL 3.0

Programmability extensions

• GL_ARB_vertex_program
• GL_ARB_fragment_program

Framebuffer related extensions

• GL_ARB_draw_buffers Core in GL 2.0
• GL_EXT_framebuffer_object
• GL_EXT_framebuffer_object More about FBOs
• GL_EXT_framebuffer_multisample

External Links

• OpenGL Extension Registry

Extensions of Interest for the GL 2 Programmer

Extensions that you might need if you are targeting systems with GL 2.0 or GL 2.1
Perhaps you are new to GL programming and you find the large list at http://www.opengl.org/registry much too long to sift through.

GL_ARB_texture_rectangle
GL_ARB_color_buffer_float
GL_ARB_half_float_pixel
GL_ARB_texture_float
WGL_EXT_extensions_string (and the WGL extensions you can get with this extension)
GL_EXT_texture_filter_anisotropic
GL_NV_fence
GL_EXT_packed_depth_stencil
GL_NV_texture_compression_vtc
GL_EXT_texture_compression_s3tc
GL_NV_vertex_program (Many versions. GL_NV_vertex_program2, GL_NV_vertex_program3)
GL_NV_fragment_program (Many versions. GL_NV_fragment_program2, GL_NV_fragment_program3)
GL_GREMEDY_string_marker, GL_GREMEDY_frame_terminator (Special. Available in GLintercept which is a debugging tool)
GL_EXT_framebuffer_object
GL_EXT_framebuffer_blit
GL_EXT_framebuffer_multisample
GL_NV_framebuffer_multisample_coverage
GL_EXT_timer_query
GL_EXT_gpu_program_parameters
GL_NV_gpu_program4
GL_EXT_geometry_shader4
GL_EXT_gpu_shader4
GL_EXT_draw_instanced
GL_EXT_packed_float
GL_EXT_texture_array
GL_EXT_texture_buffer_object
GL_EXT_texture_compression_latc
GL_EXT_texture_compression_rgtc
GL_EXT_texture_shared_exponent
GL_NV_depth_buffer_float
GL_EXT_framebuffer_sRGB
WGL_EXT_framebuffer_sRGB
GL_NV_parameter_buffer_object
GL_EXT_draw_buffers2
GL_EXT_bindable_uniform
GL_EXT_texture_integer
GL_NV_conditional_render
GL_EXT_transform_feedback

Windows

If you are running Windows 98/Me/NT/2000/XP/2003/Vista, the OpenGL library has already been installed on your system.

Remember that GL is a system component on Windows. DO NOT modify or copy OpenGL32.dll from one OS to another. The filename is OpenGL32.dll and is either in WINDOWS\SYSTEM, WINNT\SYSTEM32 or WINDOWS\SYSTEM32. This also means that you do not have to ship a copy of the library with your application since it will already be available on the system.

The standard Windows OpenGL32.dll library alone will not provide you with hardware acceleration for OpenGL. In order to get hardware acceleration, you will need to install the latest drivers for your graphics card. The second reason to install new drivers is to have the latest version of GL on your system (the max version supported by your GPU):

• 3Dlabs
• ATI
• Intel
• NVidia

Some sites also distribute beta versions of graphics drivers, which may give you access to bug fixes or new functionality before an official driver release from the manufacturer:

• 3DChipset
• Guru3D

GLU is also included in the system folder as glu32.dll This is also a system component. Updated DLL should be placed in your program’s folder. You can get a GLU’s source code from MESA3D. You can get precompiled lib from vmelkon’s GLU; The current version is 1.3.

Other libraries like GLUT, freeGLUT, QT, etc are not part of the OS. These should be downloaded from the net. GLUT and OpenGL Utility Libraries

Windows 98, Me, 2000 support OpenGL version 1.1 as a software rasterizer implemented in OpenGL32.dll. There is no support for hardware acceleration therefore installing drivers is necessary. Windows XP supports OpenGL version 1.1 as a Direct3D wrapper in OpenGL32.dll. Since performance will be lousy, installing drivers is a good idea. On Windows 2003, you aren’t suppose to use it as a desktop machine, but it is similar to Win 2000/XP. Windows Vista supports OpenGL version 1.4 as a Direct3D wrapper. Always install drivers. Once again, by installing the latest version of the video driver, you can get hw acceleration, you avoid the Direct3D wrapper, you get the maximum version of GL supported by your GPU.

64 bits Windows versions

If you are running the 64 bit version of Windows Vista or perhaps you are running Windows XP x64, you might be wondering if there is a OpenGL64.dll file. The answer is no, there isn’t. On both of these Operating Systems, Windows\System32 contains all the 64 bit DLLs. It contains the OpenGL32.dll which is actually a 64 bit dll.

For 32 bit programs, Windows detects the exe as a 32 bit program and instead of using System32 files, it uses Windows\SysWOW64 which actually contains the 32 bit DLLs. WOW means Windows On Windows which is a backwards-compatibility layer.

To find your Windows’ System32 directory, go to: Start, Run… and type in %WINDIR%\System32. The system will redirect you to the default System32 directory automatically; this is also true for the 32 bits versions of Windows.

Linux

Graphics on Linux is almost exclusively implemented using the X windows system. Supporting OpenGL on Linux involves using GLX extensions to the X Server. There is a standard Application Binary Interface defined for OpenGL on Linux that gives application compatability for OpenGL for a range of drivers. In addition the Direct Rendering Infrastucture (DRI) is a driver framework that allows drivers to be written and interoperate within a standard framework to easily support hardware acceleration, the DRI is included in of XFree86 4.0 but may need a card specific driver to be configured after installation. These days, XFree86 has been rejected in favor of XOrg due to the change in the license of XFree86, so many developers left Xfree86 and joined the XOrg group. Popular Linux distros come with XOrg now. Developers

Vendors have different approaches to drivers on Linux, some support Open Source efforts using the DRI, and others support closed source frameworks but all methods support the standard ABI that will allow correctly written OpenGL applications to run on Linux.

• Nvidia
• Nvidia HOWTO (old)
• ATI

For more information on developing OpenGL applications on Linux, see Platform specifics: Linux

Linux comes with Mesa libraries, which implements the OpenGL API as a software rasterizer. Most Linux distros don’t come with hardware acceleration. Some Linux distributions may include support for hardware acceleration. Also, some GPUs have Open Source drivers developed by the community even though a close source driver may be available from the manufacturer.

Mac OS X

Every version of Mac OS X has shipped with OpenGL runtime libraries pre-installed. Users who want to run OpenGL applications do not need to install or configure anything.

Unlike other platforms, where the Operating System and OpenGL implementations are often updated separately, OpenGL updates are usually included as part of Mac OS X system updates. To obtain the latest OpenGL on Mac OS X, users should upgrade to the latest OS release, which can be found at Apple.com.

For developers, a default installation of Mac OS X does not include any OpenGL headers, nor does it include other necessary development tools. These are installed by a separate developer tools package called X Code. This installer includes the OpenGL headers, compilers (gcc), debuggers (gdb), Apple’s Xcode IDE, and a number of performance tools useful for OpenGL application development.

For more information on developing OpenGL applications on Mac OS X, see Platform specifics: Mac OS X.

OpenGL 2.0+ and extensions

If you will be programming for Windows, typically compilers comes with a standard OpenGL 1.1 .h and .lib.
For Linux and others, you might want to borrow the same idea (getting function pointers for the GL functions)
To access higher OpenGL functions, you would have to get the function pointers.
For example, in C or C++, this is what you would do
PS : The info here applies also to GL 3.0

Download glext.h and wglext.h from The Extensions Registry

Put it in your compiler’s GL folder.

include <GL/gl.h>
include <GL/glext.h>
include <GL/wglext.h>

extern PFNGLACTIVETEXTUREPROC glActiveTexture;  //Put this in a .h so that you can include the header in all your other .cpp
PFNGLACTIVETEXTUREPROC glActiveTexture;    //Declare your function pointer in a .cpp file

Once you create a GL context, you can use wglGetProcAddress to get a pointer to the function.

glActiveTexture = (PFNGLACTIVETEXTUREPROC) wglGetProcAddress("glActiveTexture");

This would be tedious if you had to do this for all the functions and it’s is even more work if you want to detect a certain OpenGL API version, then load all the core functions. Then, detect if a certain extension is present, then load all the functions.

There exists a few libraries out there that will get the function pointers for you. All you have to do is create an OpenGL rendering context and call the library’s init function. The recent version of GLee doesn’t require a call to its init function.

Examples are :

• GLEW – The GL Extension Wrangler Library
• GLEE – GL Easy Extension library

GLEW is used like this :
Step 1. Just before including gl.h, include glew.h
Step 2. Just after creating your GL context and making it current, call

 GLenum err=glewInit();
 if(err!=GLEW_OK)
 {
 //problem: glewInit failed, something is seriously wrong
 sprintf(ErrorMessage, "Error: %s\n", glewGetErrorString(err));
 return -1;
 }

OpenGL 3.0

Whenever a major version of GL comes out, for example when GL 2.0 was going to come out, there is a whole lot of discussion about old programs that will no longer run, that you would have to cancel your million dollar project and start using Direct3D.
So GL 3.0 adds a deprecation model and the specification hints at functions and tokens that you should no longer use for your newer projects.
This has been interpreted to mean that your program will no longer work by a few posters on the http://www.opengl.org forums.

All that GL 3.0 brings to the table is a new way to create a context. You can use it to make a GL 3.0 context.
Old programs that obviously create a standard context are not effected by this. They will continue to run.
GL 3.0 doesn’t mean that old programs won’t run anymore.

How to make your first OpenGL Program

The first thing to do is chose a programming language. It could be C++, C++ Managed, Visual Basic, Visual Basic .NET, Pascal, Perl, Java, Ada, x86 assembly, etc.

The second thing is to chose a compiler. It could be MS Visual C++, DevC++, Delphi, Masm, etc. Remember that OpenGL is an API, so as long as you have the language bindings for your compiler, you can do OpenGL programming.

Typically, a compiler comes with the binding files. For example, if you have a C++ compiler, it will come with gl.h and opengl32.lib. It may even come with glu.h and glu32.lib, glut.h and glut32.lib.

If you don’t have your binding files, you will need to figure out where to download them from. Microsoft releases their Windows Platform SDK which contains these files and most likely you don’t need it because your compiler came with the files.

You might want to use SDL, GLUT, freeGLUT, or some other wrapper that takes care of creating a GL window for you and destroying for you. It makes it easier for someone who just wants to learn the OpenGL API syntax.

Assuming you know how to program in your language of choice, now all you need is to learn OpenGL. There are many online tutorials. Just search for opengl+tutorial in your favorite search engine.

OpenGL Viewers

These are programs that you install and run, and they give you information specific to the OpenGL API your system implements, like the version offered by your system, the vendor, the renderer, the extension list, supported viewport size, line size, point size, plus many other details. Some might include a benchmark. Some are standalone benchmarks.

• GLInfo2 (Windows)
• GPU Caps Viewer (Windows XP, Vista 32)
• OpenGL Extension Viewer (Windows, Windows x64 and MacOS X)
• OpenGL ES benchmark tool (Linux, Symbian, Windows Mobile)
• Fur rendering benchmark (Windows)
• Futuremark’s GL ES benchmark

External Links

• Tutorials
  • NeHe, OpenGL Tutorials
  • GLUT, Tutorials
  • Delphi3D.net, Delphi programming and OpenGL
  • lighthouse3d.com, GL 2.0, GLSL, tutorials
• Implementations
  • The Mesa 3D Graphics Library, a software renderer based on the OpenGL API.
• Engines
  • Ogre 3D engine
  • 3DS loader, keyframes
• Demos
  • Delphi OpenGL Demos
  • Humus.name many demos, advanced
  • Flipcode many demos
  • Paul Bourke many demos and explanations, advanced
• Theory and General Graphics Programming
  • Magic Software algorithms, intersection test
  • Light Exposure Theory
  • Scriptionary.com Graphics Programming related both OpenGL and Direct3D
• Image Loader
  • http://openil.sourceforge.net, DevIL, formally called OpenIL, Image Library, supports many many formats
  • http://gpwiki.org/index.php/SDL:Tutorials:Using_SDL_with_OpenGL SDL and GL
  • http://lonesock.net/soil.html SOIL, Simple OpenGL Image Library
  • GLaux, do not use GLaux. It is 15 years old and considered deprecated
• Sound Loader
  • http://connect.creativelabs.com/openal/default.aspx, OpenAL, Audio Library, sort of like OpenGL, but for audio
  • http://un4seen.com BASS audio library
  • http://www.fmod.org FMOD audio librray
• Language Bindings
  • POGL Perl
• Other
  • 3D models
  • http://www.opengl.org/sdk/docs/tutorials/TyphoonLabs/
  • http://www.opengl.org/sdk/tools/ShaderDesigner/
  • http://lumina.sourceforge.net/Tutorials/Armature.html
  • http://www.opencsg.org, Constructive Solid Geometry, boolean operations with geometry
  • http://www.gamedev.net/community/forums/showfaq.asp?forum_id=25#q11a, The Gamedev FAQ
  • http://gpwiki.org Another Wiki about Game Programming, also has GL code snippets and other APIs

Documentation

• The GL spec page
• The GLSL spec page
• The extension registry
• OpenGL Quick Reference
• XML Toolchain and Man Pages
• Viewing XHTML and MathML

SDK

• OpenGL SDK projects and OpenGL man pages
• nVidia’s SDK, examples and many pdf
• AMD/ATI’s examples and many pdf