- OpenGL 4 Shading Language Cookbook(Second Edition)
- David Wolff
- 1252字
- 2021-07-21 17:50:56
Using a function loader to access the latest OpenGL functionality
The OpenGL ABI (application binary interface) is frozen to OpenGL version 1.1 on Windows. Unfortunately for Windows developers, that means that it is not possible to link directly to functions that are provided in newer versions of OpenGL. Instead, one must get access to these functions by acquiring a function pointer at runtime. Getting access to the function pointers is not difficult, but requires somewhat tedious work, and has a tendency to clutter your code. Additionally, Windows typically comes with a standard OpenGL gl.h
file that also conforms to OpenGL 1.1. The OpenGL wiki states that Microsoft has no plans to ever update the gl.h
and opengl32.lib
that come with their compilers. Thankfully, others have provided libraries that manage all of this for us by transparently providing the needed function pointers, while also exposing the needed functionality in header files. There are several libraries available that provide this kind of support. One of the oldest and most common is GLEW (OpenGL Extension Wrangler). However, there are a few serious issues with GLEW that might make it less desirable, and insufficient for my purposes when writing this book. First, at time of writing, it doesn't yet support core profiles properly, and for this book, I want to focus only on the latest non-deprecated functionality. Second, it provides one large header file that includes everything from all versions of OpenGL. It might be preferable to have a more streamlined header file that only includes functions that we might use. Finally, GLEW is distributed as a library that needs to be compiled separately and linked into our project. It is often preferable to have a loader that can be included into a project simply by adding the source files and compiling them directly into our executable, avoiding the need to support another link-time dependency.
In this recipe, we'll use the OpenGL Loader Generator (GLLoadGen
), available from https://bitbucket.org/alfonse/glloadgen/wiki/Home. This very flexible and efficient library solves all three of the issues described in the previous paragraph. It supports core profiles and it can generate a header that includes only the needed functionality, and also generates just a couple of files (a source file and a header) that we can add directly into our project.
Getting ready
To use GLLoadGen, you'll need Lua. Lua is a lightweight embeddable scripting language that is available for nearly all platforms. Binaries are available at http://luabinaries.sourceforge.net, and a fully packaged install for Windows (LuaForWindows) is available at:
https://code.google.com/p/luaforwindows
Download the GLLoadGen distribution from: https://bitbucket.org/alfonse/glloadgen/downloads. The distribution is compressed using 7zip, which is not widely installed, so you may need to install a 7zip utility, available at http://7-zip.org/. Extract the distribution to a convenient location on your hard drive. Since GLLoadGen is written in Lua, there's nothing to compile, once the distribution is uncompressed, you're ready to go.
How to do it...
The first step is to generate the header and source files for the OpenGL version and profile of choice. For this example, we'll generate files for an OpenGL 4.3 core profile. We can then copy the files into our project and compile them directly alongside our code:
- To generate the header and source files, navigate to the
GLLoadGen
distribution directory, and runGLLoadGen
with the following arguments:lua LoadGen.lua -style=pointer_c -spec=gl -version=4.3 \-profile=core core_4_3
- The previous step should generate two files:
gl_core_4_3.c
andgl_core_4_3.h
. Move these files into your project and includegl_core_4_3.c
in your build. Within your program code, you can include thegl_core_4_3.h
file whenever you need access to the OpenGL functions. However, in order to initialize the function pointers, you need to make sure to call a function to do so. The needed function is calledogl_LoadFunctions
. Somewhere just after the GL context is created (typically in an initialization function), and before any OpenGL functions are called, use the following code:int loaded = ogl_LoadFunctions(); if(loaded == ogl_LOAD_FAILED) { //Destroy the context and abort return; } int num_failed = loaded - ogl_LOAD_SUCCEEDED; printf("Number of functions that failed to load: %i.\n",num_failed);
That's all there is to it!
How it works...
The lua
command in step 1 generates a pair of files, that is; a header and a source file. The header provides prototypes for all of the selected OpenGL functions and redefines them as function pointers, and defines all of the OpenGL constants as well. The source file provides initialization code for the function pointers as well as some other utility functions. We can include the gl_core_4_3.h
header file wherever we need prototypes for OpenGL functions, so all function entry points are available at compile time. At run time, the ogl_LoadFunctions()
function will initialize all available function pointers. If some functions fail to load, the number of failures can be determined by the subtraction operation shown in step 2. If a function is not available in the selected OpenGL version, the code may not compile, because only function prototypes for the selected OpenGL version and profile are available in the header (depending on how it was generated).
The command line arguments available to GLLoadGen are fully documented here: https://bitbucket.org/alfonse/glloadgen/wiki/Command_Line_Options. The previous example shows the most commonly used setup, but there's a good amount of flexibility built into this tool.
Now that we have generated this source/header pair, we no longer have any dependency on GLLoadGen
and our program can be compiled without it. This is a significant advantage over tools such as GLEW.
There's more...
GLLoadGen
includes a few additional features that are quite useful. We can generate more C++ friendly code, manage extensions, and generate files that work without the need to call an initialization function.
GLLoadGen supports generation of C++ header/source files as well. This can be selected via the -style
parameter. For example, to generate C++ files, use -style=pointer_cpp
as in the following example:
lua LoadGen.lua -style=pointer_cpp -spec=gl -version=4.3 \-profile=core core_4_3
This will generate gl_core_4_3.cpp
and gl_core_4_3.hpp
. This places all OpenGL functions and constants within the gl::
namespace, and removes their gl
(or GL
) prefix. For example, to call the function glBufferData
, you might use the following syntax.
gl::BufferData(gl::ARRAY_BUFFER, size, data, gl::STATIC_DRAW);
Loading the function pointers is also slightly different. The return value is an object rather than just a simple integer and LoadFunctions
is in the gl::sys
namespace.
gl::exts::LoadTest didLoad = gl::sys::LoadFunctions(); if(!didLoad) { // Clean up (destroy the context) and abort. return; } printf("Number of functions that failed to load: %i.\n", didLoad.GetNumMissing());
GLLoadGen supports the automatic initialization of function pointers. This can be selected using the noload_c
or noload_cpp
options for the style
parameter. With these styles, there is no need to call the initialization function ogl_LoadFunctions
. The pointers are loaded automatically, the first time a function is called. This can be convenient, but there's very little overhead to loading them all at initialization.
GLLoadGen does not automatically support extensions. Instead, you need to ask for them with command line parameters. For example, to request ARB_texture_view
and ARB_vertex_attrib_binding
extensions, you might use the following command.
lua LoadGen.lua -style=pointer_c -spec=gl -version=3.3 \-profile=core core_3_3 \-exts ARB_texture_view ARB_vertex_attrib_binding
The -exts
parameter is a space-separated list of extensions. GLLoadGen also provides the ability to load a list of extensions from a file (via the -extfile
parameter) and provides some common extension files on the website.
You can also use GLLoadGen to check for the existence of an extension at run-time. For details, see the GLLoadGen wiki.
See also
- GLEW, an older, and more common loader and extension manager, available from glew.sourceforge.net.