glbinding

glbinding is a cross-platform C++ binding for the OpenGL API. Unlike traditional C bindings (like GLEW) that rely heavily on macros, glbinding leverages C++11 features such as enum classes, lambdas, and variadic templates.

Key features include:

• All OpenGL symbols are real functions and variables (no macros).
• Type-safe parameters.
• Per-feature API headers.
• Lazy function resolution.
• Multi-context and multi-thread support.
• Global and local function callbacks.
• Meta information about the generated binding and the OpenGL runtime.

It is designed to be highly compatible with existing OpenGL code. To migrate from a C binding, you can typically replace the includes, replace the initialization code, and use the appropriate API namespace (e.g., gl for full availability).

#include <glbinding/gl/gl.h>
using namespace gl;

// ...
auto shader = glCreateShader(GL_COMPUTE_SHADER);
// ...

Unlike the standard OpenGL API, glbinding uses strong typing for parameters such as booleans, bitfields, enums, and special values. This allows the compiler and IDE to detect invalid usage, such as passing a GLenum where a specific bitfield group is expected.

Note on Enums: While bitfields are strictly validated, some enums (named values) may still result in runtime errors if the wrong constant is used (e.g., passing GL_COLOR instead of GL_VERTEX_SHADER to glCreateShader), as the underlying groups for enums are not always fully maintained in the specification.

// Valid bitfield usage
glClear(GL_COLOR_BUFFER_BIT); 

// Compilation error: bitfield of group ClearBufferMask expected, got GLenum
glClear(GL_FRAMEBUFFER); 

// Valid bitfield combination
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 

// Compilation error: bitfields share no group
glClear(GL_COLOR_BUFFER_BIT | GL_MAP_READ_BIT); 

glbinding supports multiple contexts, which is essential for multi-threaded applications. However, you must explicitly manage context switching so glbinding can dispatch function pointers correctly.

1. Initialize per context: Call glbinding::initialize for each context. If using multiple contexts, provide a context identifier (e.g., 0, 1) as the first argument.
2. Switch contexts: Use glbinding::useCurrentContext() to use the context currently active in the thread, or glbinding::useContext(ContextHandle context) to switch to a specific context identified by a platform-specific handle.

Warning: While glbinding supports multiple threads, it does not provide locking for concurrent access to a single context. Each thread should ideally manage its own context.

// Context 1 initialization
glbinding::initialize(0, glfwGetProcAddress);

// Context 2 initialization
glbinding::initialize(1, glfwGetProcAddress);

// In the render loop:
// Switch to context 1
glbinding::useContext(0);
glClear(GL_COLOR_BUFFER_BIT);

// Switch to context 2
glbinding::useContext(1);
glClear(GL_COLOR_BUFFER_BIT);

To build glbinding from source, you need a C++11 compliant compiler (GCC 4.8+, Clang 3.3+, or MSVC 2013 Update 3 or newer). The current release defaults to C++17, but you can enable C++14 or C++11 compatibility using the CMake options OPTION_CXX_14_COMPATABILITY and OPTION_CXX_11_COMPATABILITY respectively.

Prerequisites

• Mandatory: CMake 3.15+, git, and an OpenGL driver library (dynamically linked).
• Optional: GLFW 3.2+ (examples/tools), GLEW 1.6+ (comparison example), cpplocate (examples), Qt5 5.0+ (Qt example), googletest (tests), Doxygen 1.8+ (documentation).

# Clone and checkout a specific version
git clone https://github.com/cginternals/glbinding.git
cd glbinding
git fetch --tags
git checkout v3.5.0

# Create build directory
mkdir build
cd build

# Configure (example for Visual Studio 2022 x64)
cmake .. -G "Visual Studio 17 2022" -A x64

# Build
cmake --build .

# Build specific configuration
cmake --build . --config Release
cmake --build . --config Debug