A C++ binding for the OpenGL API, generated using the gl.xml specification.

Overview


glbinding is a cross-platform C++ binding for the OpenGL API.

GitHub release Travis Appveyor Tokei

Documentation Examples Tools

glbinding leverages C++11 features like enum classes, lambdas, and variadic templates, instead of relying on macros; all OpenGL symbols are real functions and variables. It provides 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 OpenGL binding and the OpenGL runtime, as well as tools and examples for quick-starting your projects. Based on the OpenGL API specification (gl.xml) glbinding is generated using python scripts and templates that can be easily adapted to fit custom needs.

what-is-glbinding

Code that is written using a typical C binding for OpenGL, e.g., GLEW, is fully compatible for the use with glbinding and causes no significant impact on runtime performance (see compare example): just replace all includes to the former binding, replace the initialization code and use the appropriate API namespace, e.g., gl for full availability of the OpenGL API.

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

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

Resources

Installation and Development

Feature Documentation and Code Snippets

Install Instructions

glbinding is available for different platforms using different distribution channels. You can either download the source and manually compile it or use one of the pre-compiled releases of this repository. For systems providing package managers, we generally strive for packages in these package managers.

Windows

The various glbinding packages can be installed either by downloading an installer, e.g., the x64 installer for glbinding v3.1.0 for Microsoft Visual Studio 2015, or downloading and extracting one of the precompiled archives, e.g. runtime, examples, dev, and tools. Since lately, glbinding is also available on vcpkg with more recent releases:

> vcpkg install glbinding

Alternatively, download the source code and commence building from source.

Ubuntu

glbinding is provided on Ubuntu using PPAs and in Ubuntu universe since Artful Aardvark. We maintain our own PPA for most recent releases. For Ubuntu 16.04 (xenial), 17.10 (artful), and 18.04 (bionic) use the standard PPA, for Ubuntu 14.04 (trusty) use the backports PPA. Using the current PPA as example, the following lines install glbinding including the GLFW examples:

> sudo apt-add-repository ppa:cginternals/ppa
> sudo apt-get update
> sudo apt-get install libglbinding-examples-glfw
> # start example
> /usr/share/glbinding/cubescape

To use glbinding as dependency, install the development package:

> sudo apt-get install libglbinding-dev libglbinding-dbg

Alternatively, download the source code and commence building from source.

Arch Linux

On Arch, glbinding is provided by the glbinding package in the community repository. To install glbinding execute the following line:

> sudo pacman -S glbinding

Alternatively, download the source code and commence building from source.

macOS

The package manager on macOS we depend on is homebrew. The package there is called glbinding. To install glbinding using homebrew, execute the following line:

> brew install glbinding

Alternatively, download the source code and commence building from source.

Debian-based Systems

glbinding is available for Debian 9 (Stretch), 10 (Buster) and Sid. Install it using apt-get install glbinding. For advanced use, download the source code and commence building from source.

Cross-Platform Package Managers

As one of the cross-platform package managers, conan provides glbinding in its center index. You can use the folling line to install glbinding using conan:

> conan install glbinding/[email protected]

Build Instructions

Prerequisites and Dependencies

The only mandatory run-time dependencies of glbinding are the STL of the used compiler and an OpenGL driver library, dynamically linked with your application. Building glbinding from source has several mandatory and optional dependencies:

  • CMake 3.0 or higher for building glbinding from source (mandatory for any build from source)
  • git for version control and script supporting tasks
  • GLFW 3.2 or higher for examples and tools
  • GLEW 1.6 or higher for the comparison example (optional)
  • cpplocate for the examples (optional)
  • Qt5 5.0 or higher for the qt-based example (optional)
  • Doxygen 1.8 or higher for generating the documentation on your system
    • graphviz for generating diagrams (optional)

Compile Instructions

For compilation, a C++11 compliant compiler, e.g., GCC 4.8, Clang 3.3, MSVC 2013 Update 3, is required. First, download the source code as archive or via git:

> git clone https://github.com/cginternals/glbinding.git
> cd glbinding

Then, depending on the version of glbinding you want to build, choose the appropriate tag or branch, e.g., for the 2.1.4 release:

> git fetch --tags
> git checkout v2.1.4

The actual compilation can be done using CMake and your favorite compiler and IDE.

For building glbinding CMake via command line can be used (should work on all systems):

First, create a build directory (we do not recommend in-source builds):

> mkdir build
> cd build

Configure glbinding with your preferred or default generator, e.g., for Visual Studio 2015 in x64 use (note: some IDEs have integrated support for CMake projects, e.g., Qt Creator, and allow you to skip the manual project configuration):

> cmake .. -G "Visual Studio 14 2015 Win64"

In order to compile the project, either use you favorite Editor/IDE with the created project or use CMake as follows:

> cmake --build .

For multi-configuration projects specific configuration (e.g., on Windows using MSVC) can be built using:

> cmake --build . --config Release
> cmake --build . --config Debug

Update Generated Source Code

The generation scripts for glbinding are maintained within the khrbinding-generator project. Assuming a directory structure with both projects such as <projects>/glbinding and <projects>/khrbinding-generator, updating the source code is started as follows:

> python3 update.py -p "profiles/gl.json"
> python3 generate.py -p "profiles/gl.json" -d "../glbinding/source"

Tips for Linking

We suggest using the build system CMake for a smooth integration. For it, glbinding provides a configuration script that should be installed into your system or at least accessible by CMake. In your projects' CMakeLists.txt, add one of the following lines:

find_package(glbinding QUIET) # if you want to check for existence
find_package(glbinding REQUIRED) # if it is really required in your project

Finally, just link glbinding to your own library or executable:

target_link_libraries(${target} ... PUBLIC
    glbinding::glbinding
    glbinding::glbinding-aux # for additional, auxiliary features as logging, meta information, or debugging functionality
)

Dependency on KHR Headers

As of mid 2019, the OpenGL API depends on the platform headers from the Khronos group, even on desktop systems. This introduced a direct dependency of glbinding to the KHR/khrplatform.h header file. For most Linux systems, these headers are easily available (e.g., by installing libegl1-mesa-dev on Ubuntu), whereas on other systems, pre-existing packages are scarce. Even in the case of Ubuntu, one can argue that installing the EGL dependency is strange, as glbinding does not depend on EGL in any way.

For those cases, glbinding comes with a copy of the headers for internal use.

This solution has one significant downside: As those headers are used by the types of the OpenGL API and the types are used within the public interface of glbinding, the khrplatform.h headers needs to be present when building downstream projects, i.e., they need to be installed along glbinding. In order to not conflict with packages providing the official headers, this internal header has to be installed on a separate location. This complicates the project setup and results in the following usage scenarios for you to choose from:

KHR/khrplatform.h Usage

For this usage scenario, glbinding needs to get built with the CMake option OPTION_BUILD_OWN_KHR_HEADERS set to Off and system-wide availability of the KHR/khrplatform.h headers, e.g., by having libegl1-mesa-dev installed. If either the option is On or the system-wide headers are not found, the internally provided headers are used instead.

This decision is stored as property of the glbinding CMake target and will be used for downstream projects as well. The use and propagation of this decision is transparent to the user as well, i.e., the user should not need to handle this downstream. The only thing to consider is to have the system-wide KHR/khrplatform.h headers available when building the downstream project.

glbinding-internal khrplatform.h Usage

For this usage scenario, glbinding should get built with the CMake option OPTION_BUILD_OWN_KHR_HEADERS set to On. Alternatively, this scenario is the fallback if the official KHR/khrplatform.h headers are not found.

This decision is stored as property of the glbinding CMake target and will be used for downstream projects as well. The use and propagation of this decision is transparent to the user as well, i.e., the user should not need to handle this downstream.

Basic Example

The following examples are tailored for use with glbinding 3.0 and above.

glbinding has to be initialized once on the active OpenGL context you want to use glbinding with. For initialization, a callback for function pointer resolution must be passed, which your context creation API should provide. In the most basic case, you call glbinding::initialize once:

#include <glbinding/gl/gl.h>
#include <glbinding/glbinding.h>

using namespace gl;

int main()
{
  // create context, e.g. using GLFW, Qt, SDL, GLUT, ...

  // Assume context creation using GLFW
  glbinding::initialize(glfwGetProcAddress);

  glBegin(GL_TRIANGLES);
  // ...
  glEnd();
}

Features

The following examples are tailored for use with glbinding 3.0 and above.

Type-Safe Parameters

The original OpenGL API provides several concepts in their interface, namely functions, booleans, bitfields, enums, as well as special values and basic types but mostly does not differentiate between these types. Hence, actual knowledge about each function and its parameters is required; there is no way for a basic code assistance. As glbinding differentiates between all these types, IDEs and compilers can detect wrong usages of the OpenGL API.

One example is the passing of a named constant in places where a bit combination is expected:

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

In the case of bitfields, the OpenGL API offers groups and each parameter states the group valid values must come from. glbinding uses this information to prevent invalid bit combinations:

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // valid
glClear(GL_COLOR_BUFFER_BIT | GL_MAP_READ_BIT);     // compile error: both bitfields share no group

glClear(GL_STENCIL_BUFFER_BIT | GL_LIGHTING_BIT);   // compile error: bitwise or operation is valid,
                                                    // the shared group is AttribMask, but the
                                                    // resulting group does not match the expected.

Unfortunately, such groups are incomplete and unmaintained for enums (named values). Thus, glbinding could not provide any assistance for cases such as:

GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER); // All good
GLuint colorShader = glCreateShader(GL_COLOR);          // No compilation error but a runtime error!

Compilation-Centered Header Design

C++ strictly separates interface from implementation. For improving the compilation time of a program or system written in C++ forward declarations of types are commonly used and includes of unnecessary symbols are omitted.

For an interface of a library, class, or module providing OpenGL related functionality, it is likely that only the type information of OpenGL is needed, not actual functions or constants usually required for implementation. In addition to the customary all-in-one header gl.h glbinding also provides specialized headers:

#include <glbinding/gl/gl.h>        // all of the headers below, meaning the complete OpenGL API

#include <glbinding/gl/bitfield.h>  // bitfield constants (e.g., GL_COLOR_BUFFER_BIT)
#include <glbinding/gl/boolean.h>   // boolean constants (GL_TRUE and GL_FALSE)
#include <glbinding/gl/enum.h>      // symbol constants (e.g., GL_VERTEX_SHADER)
#include <glbinding/gl/functions.h> // functions
#include <glbinding/gl/types.h>     // type declarations of the OpenGL API (including bitfields, boolean, enum, and extensions)
#include <glbinding/gl/values.h>    // special values (e.g., GL_INVALID_INDEX)

There is one additional header that provides all extensions and provide them as an enumeration in terms of C++ enums.

#include <glbinding/gl/extension.h>

Feature-Centered Header Design

The OpenGL API is iteratively developed and released in versions, internally (for the API specification) named features. The latest feature/version of OpenGL is 4.6. The previous version are 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 2.0, 2.1, 3.0, 3.1, 3.2, 3.3, 4.0, 4.1, 4.2, 4.3, 4.4., and 4.5. OpenGL uses a deprecation model for removing outdated parts of its API which results in compatibility (with deprecated API) and core (without deprecated API) usage that is manifested in the targeted OpenGL context. On top of that, new API concepts are suggested as extensions (often vendor specific) that might be integrated into future versions. All this results in many possible specific manifestations of the OpenGL API you can use in your program.

One tough task is to adhere to one agreed set of functions in your own OpenGL program (e.g., OpenGL 3.2 Core if you want to develop for every Windows, macOS, and Linux released in the last 4 years). glbinding facilitates this by providing per-feature headers by means of well-defined/generated subsets of the OpenGL API.

All-Features OpenGL Headers

If you do not use per-feature headers the OpenGL program can look like this:

#include <glbinding/gl/gl.h>

// draw code
gl::glClear(gl::GL_COLOR_BUFFER_BIT | gl::GL_DEPTH_BUFFER_BIT);
gl::glUniform1i(u_numcubes, m_numcubes);
gl::glDrawElementsInstanced(gl::GL_TRIANGLES, 18, gl::GL_UNSIGNED_BYTE, 0, m_numcubes * m_numcubes);

Single-Feature OpenGL Headers

When developing your code on Windows with latest drivers installed, the code above is likely to compile and run. But if you want to port it to systems with less mature driver support (e.g., macOS or Linux using open source drivers), you may wonder if glDrawElementsInstanced is available. In this case, just switch to per-feature headers of glbinding and choose the OpenGL 3.2 Core headers (as you know that at least this version is available on all target platforms):

#include <glbinding/gl32core/gl.h>

// draw code
gl32core::glClear(gl32core::GL_COLOR_BUFFER_BIT | gl32core::GL_DEPTH_BUFFER_BIT);
gl32core::glUniform1i(u_numcubes, m_numcubes);
gl32core::glDrawElementsInstanced(gl32core::GL_TRIANGLES, 18, gl32core::GL_UNSIGNED_BYTE, 0, m_numcubes * m_numcubes);

If the code compiles you can be sure it is OpenGL 3.2 Core compliant. Using functions that are not yet available or relying on deprecated functionality is prevented.

Lazy Function Pointer Resolution

By default, glbinding tries to resolve all OpenGL function pointers during initialization, which can consume some time:

// Assume context creation using GLFW
glbinding::initialize(glfwGetProcAddress); // immediate function pointer resolution

Alternatively, the user can decide that functions pointers are resolved only when used for the first time. This is achieved by:

// Assume context creation using GLFW
glbinding::initialize(glfwGetProcAddress, false); // lazy function pointer resolution

Multi-Context Support

glbinding has built-in support for multiple contexts. The only requirement is, that the currently active context has to be specified. This feature mixes well with multi-threaded applications, but keep in mind that concurrent use of one context often results in non-meaningful communication with the OpenGL driver.

In order to use multiple contexts, use your favorite context creation library (e.g., glut, SDL, egl, glfw, Qt) to request the required contexts. The functions to make a context current should be provided by these libraries and is not part of glbinding (except that you can get the current context handle). When using multiple contexts, glbinding has to be initialized for each context (when current).

Since each context can correspond to a different feature set of OpenGL and the drivers are free to assign their function pointers, glbinding cannot assume any equalities of requested function pointers. Thus, contexts switches have to be communicated to glbinding explicitly in order to have correctly dispatched function pointers:

// use the current active context
glbinding::useCurrentContext();

// use another context, identified by platform-specific handle
glbinding::useContext(ContextHandle context);

Multi-Threading Support

Concurrent use of glbinding is mainly intended for usage over multiple contexts in different threads (multiple threads operating on a single OpenGL context requires locking, which glbinding will not provide). For it, glbinding supports multiple active contexts, one per thread. This necessitates that glbinding gets informed in each thread which context is currently active (see multi-context example).

Note: multi-threaded communication with OpenGL will most likely result in a meaningless sequence of OpenGL calls. To avoid this, semantic groups of OpenGL calls should be treated as critical sections.

Example for usage of multiple contexts:

// Context 1 creation
// GLFWwindow * window1 = glfwCreateWindow(640, 480, "", nullptr, nullptr);
// glfwMakeContextCurrent(window1);
glbinding::initialize(0, glbinding::getProcAddress); // 0 here is the context identifier
// Context 1 initialization
glClearColor(1.0f, 0.0f, 0.0f, 0.0f);

// Context 2 creation
// GLFWwindow * window2 = glfwCreateWindow(640, 480, "", nullptr, nullptr);
// glfwMakeContextCurrent(window2);
glbinding::initialize(1, glbinding::getProcAddress); // 1 here is the context identifier
// Context 1 initialization
glClearColor(0.0f, 1.0f, 0.0f, 0.0f);

// Rendering
while (doNotClose()) {
  // Make context 1 active
  // glfwMakeContextCurrent(window1);
  glbinding::useContext(0);

  // Context 1 rendering
  glViewport(0, 0, width, height);
  glClear(GL_COLOR_BUFFER_BIT);

  // Swap buffer for context 1
  // glfwSwapBuffers(window1);

  // Make context 2 active
  // glfwMakeContextCurrent(window2);
  glbinding::useContext(1);

  // Context 2 rendering
  glViewport(0, 0, width, height);
  glClear(GL_COLOR_BUFFER_BIT);

  // Swap buffer for context 2
  // glfwSwapBuffers(window2);
}

Multiple OpenGL Contexts in Multiple Threads

The combination of multiple OpenGL contexts and multiple threads for OpenGL usage is supported by glbinding in general. You must tell glbinding which OpenGL context is used in which thread by calling the initialize method once the context is used first (glbinding::initialize) and if you want to switch the current context for one thread, you have to update the current context, too (glbinding::useContext). However, we discourage the use of one context in multiple threads.

Function Callbacks

To support orthogonal features of the OpenGL API, glbinding allows attaching a number of callbacks to several concepts of the OpenGL API (e.g. a function). Such orthogonal features include runtime error checking (i.e., glGetError after each function call), logging, and caching of driver information.

glbinding supports different types of callbacks that can be registered. The main types are

  • global and local (per-function) before callbacks, that are called before the OpenGL function call,
  • global and local (per-function) after callbacks, that are called after the OpenGL function call,
  • unresolved callbacks, that are called each time an unresolved OpenGL function should be called (instead of a segmentation fault),
  • context switch callbacks, that are called if the internal current OpenGL context of glbinding is changed.

The before callbacks are useful , e.g., for tracing or application-specific parameter checking. The available information in this callback is the wrapped OpenGL function (including its name and bound function address) and all parameters. The after callbacks are useful, e.g., for tracing, logging, or the obligatory error check (glGetError). Available information is extended by the return value. The unresolved callback provides information about the (unresolved) wrapped OpenGL function object.

Example for error checking:

setCallbackMaskExcept(CallbackMask::After, { "glGetError" });
setAfterCallback([](const FunctionCall &)
{
  const auto error = glGetError();
  if (error != GL_NO_ERROR)
    std::cout << "error: " << std::hex << error << std::endl;
});

// OpenGL Code ...

As a shortcut, glbinding 3.0 introduced a debugging interface for error-checking after callbacks within the glbinding-aux library:

#include <glbinding-aux/debug.h>

glbinding::aux::enableGetErrorCallback();

// OpenGL Code ...

Example for logging:

setCallbackMask(CallbackMask::After | CallbackMask::ParametersAndReturnValue);
setAfterCallback([](const FunctionCall & call)
{
  std::cout << call.function->name() << "(";
  for (unsigned i = 0; i < call.parameters.size(); ++i)
  {
    std::cout << call.parameters[i].get();
    if (i < call.parameters.size() - 1)
      std::cout << ", ";
  }
  std::cout << ")";

  if (call.returnValue)
    std::cout << " -> " << call.returnValue.get();

  std::cout << std::endl;
});

// OpenGL Code ...

Alternative Signatures

The OpenGL API is designed without function overloading using only simple parameter types. This results in explicit parameter encoding in function names for conceptually overloaded functions (e.g., glTexParameteri and glTexParameterf). Another design decision for the OpenGL API is the high similarity of the integer, boolean, enum, and bitfield data types. This means, that for overloaded functions, there is no separate function for GLboolean, GLenum, and GLbitfield types. Using type-save functions of glbinding, some typically compiling code constructs are now deliberately broken. For most of those cases, we provide alternative overloaded function signatures. Additionally, we also fix signatures that are semantically broken in the OpenGL API specification, i.e., when base types (C types) are similar such as in the case of enums and integers.

Alternative function signatures are enabled by default, so the following example works out-of-the-box:

#include <glbinding/gl/gl.h>

using namespace gl;

// ...
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_R8, 64, 64, 0, GL_RED, GL_UNSIGNED_BYTE, terrain.data());

Meta Information

Besides an actual OpenGL binding, glbinding also supports queries for both compile time and runtime information about the gl.xml and your OpenGL driver within the glbinding-aux library. This library comes with own includes and needs to be linked seperately. Typical use cases are querying the available OpenGL extensions or the associated extensions to an OpenGL feature and their functions and enums.

The following example prints out a list of all available OpenGL versions/features:

#include <iostream>

#include <glbinding/Version.h>

#include <glbinding-aux/Meta.h>
#include <glbinding-aux/types_to_string.h>

// ...
using glbinding::Meta;

for (const Version & v : Meta::versions())
  std::cout << v << std::endl;
Issues
  • CMake 3.2 Requirement Workaround

    CMake 3.2 Requirement Workaround

    A lot of linux distributions do not support 3.2 in their package managers. Upcoming distributions like Ubuntu 16.04 are shipping with 3.3.2, but existing distributions such as Debian 8.2 (ships with 3.0.2), CentOS 7 etc still lag behind with older versions.

    From what I have noticed, WRITE_COMPILER_DETECTION_HEADER is the only function that requires > 3.1.3. I think everything else is satisfied by 3.0.

    Is there any chance that a workaround for this function can be provided?

    I tried manually including the WriteCompilerDetectionHeader in the cmake directory and include it from there. But unfortunately, it looks like the get_property for CMAKE_${_lang}_KNOWN_FEATURES is unsupported in 3.0.2. So the cxx_thread_local feature fails. So this is not an avenue that can be taken.

    opened by shehzan10 15
  • Make the testsuite a standalone CMake project

    Make the testsuite a standalone CMake project

    More of a wishlist item than an issue actually. It would be nice to make the tests in source/tests a standlone CMake project, so that they can be run against the built target as it is now, but also against an already installed one (for instance coming from a package or an embedded version).

    This would be significantly ease the Debian CI process, since all this would require is installing the libglbinding-dev package, copy the source/tests directory to the testbed and run a standard CMake configuration, build and run.

    I am able to achieve this at the moment, but the following must be prepended to source/tests/CMakeLists.txt:

    cmake_minimum_required(VERSION 3.0)
    project(glbinding-tests)
    
    if (POLICY CMP0063)
      cmake_policy(SET CMP0063 NEW)
    endif ()
    
    find_package(glbinding REQUIRED)
    set(META_PROJECT_NAME "glbinding")
    
    list(APPEND CMAKE_MODULE_PATH "\${CMAKE_CURRENT_SOURCE_DIR}/cmake")
    include(CompileOptions)
    
    set(OPTION_BUILD_TESTS ON)
    set(OPTION_BUILD_GPU_TESTS OFF)
    

    FYI, Debian is not the only distribution with CI in place, so addressing this should benefit a larger crowd.

    Cheers,

    Deployment 
    opened by ghisvail 14
  • undefined reference to `operator<<(std::ostream&, gl::GLenum const&)'

    undefined reference to `operator<<(std::ostream&, gl::GLenum const&)'

    I'm getting these two linker errors under Ubuntu 16.04 64-bit:

    • undefined reference to `operator<<(std::ostream&, gl::GLenum const&)'
    • undefined reference to `operator+(gl::GLenum const&, unsigned int)'

    Previously, under Ubuntu 15.10 64-bit I didn't get none of these linker error messages and I was using glbinding for my projects. In Ubuntu 15.10 I compiled glbinding myself using cmake. Now, for Ubuntu 16.04 I've used the supplied PPA and installed glbinding that way.

    What's going on. How do I resolve these two linker errors? Is there anything I can do to help resolve them if it's a problem on your side?

    Regards,

    opened by damien-lloyd 13
  • PPA libglbinding-dev conflicts with libegl1-mesa-dev

    PPA libglbinding-dev conflicts with libegl1-mesa-dev

    Hi and thanks for your hard work!

    We use glbinding in decaf emulator. It seems libglbinding 3.1 of cginternals add /usr/include/KHR/khrplatform.h which conflict with libegl1-mesa-dev` ownership.

    Making our Travis builds failing:

    Unpacking libglbinding-dev (3.1.0+571~ubuntu16.04.1) ...
    dpkg: error processing archive /var/cache/apt/archives/libglbinding-dev_3.1.0+571~ubuntu16.04.1_amd64.deb (--unpack):
     trying to overwrite '/usr/include/KHR/khrplatform.h', which is also in package libegl1-mesa-dev:amd64 18.0.5-0ubuntu0~16.04.1
    

    I'm not a package experts, but because of this libglbinding 3.1 is conflicting with libegl1-mesa-dev on Xenial.

    I suspect you don't want to create a dependency to libegl1-mesa-dev because of one single file. Maybe having it in its own dedicated files could be a solution:

    /usr/include/glbinding/glbinding_khrplatform.h
    

    What do you suggest?

    Decaf PR for more information here.

    Have a nice day.

    opened by Narann 12
  • GL_BY_STRINGS + Release Mode Hangs When Building

    GL_BY_STRINGS + Release Mode Hangs When Building

    I'm trying to use glbinding::Meta::getEnum(...), and I'm under the impression that this feature isn't available unless I compile with GL_BY_STRINGS enabled. I downloaded v1.1 of the source and ran cmake with the following options: cmake -DOPTION_GL_BY_STRINGS=1 -DCMAKE_BUILD_TYPE=RELEASE ..

    When I then run make, it hangs at 59% every time. I've let it go for 20 minutes or so to no effect except heating up my laptop. [ 59%] Building CXX object source/glbinding/CMakeFiles/glbinding.dir/source/Meta_ExtensionsByFunctionString.cpp.o

    If I disable OPTION_GL_BY_STRINGS, or switch CMAKE_BUILD_TYPE to DEBUG, it builds everything fairly quickly without any issues. I'm new to cmake--am I doing something wrong here? Let me know if you need any more info from me.

    opened by MasonRemaley 12
  • Build error with GCC after version 1.0.4

    Build error with GCC after version 1.0.4

    I'm compiling glbinding with TDM GCC 4.9.2 64 bit in Windows 7.

    With glbinding 1.0.4 I never had problems, while with 1.0.5 the compiler gives me "unrecognized command line options" error.

    Removing this instruction @ line 137 in "source/glbinding/CMakeLists.txt" from glbinding 1.0.5 sources:

    target_compile_options(${target} PRIVATE ${DEFAULT_COMPILE_FLAGS})

    resolved the problem. This line was not present in glbinding 1.0.4.

    Thank you for your attention and best regards

    opened by wizofoz 11
  • logging.cpp doesn't compile.

    logging.cpp doesn't compile.

    When compiling logging.cpp for Win32 I get this error:

    c:\program files (x86)\microsoft visual studio 12.0\vc\include\concrt.h(4774): error C3861: '__uncaught_exception': identifier not found

    To fix this I added

    #include <eh.h>

    to the top. I am not sure why it occurred yet but there is a build configuration that for some reason causes __uncaught_exception not to be defined.

    bug 
    opened by Cthutu 10
  • Getting rid of dll-interface warnings when compiling on Windows

    Getting rid of dll-interface warnings when compiling on Windows

    Sorry, this is possibly a dumb thing (I hope so) -- I've not developed much on Windows in recent years, but am now porting an OS X OpenGL application to Windows 10 (using Visual Studio 2015). I’m using the downloaded (pre-built) Windows version of glbinding (from here). What do I need to change (a define or a project compilation setting?) to get rid of the huge number of warnings that appear that look something like this:

    ...\glbinding\include\glbinding\binding.h(47): warning C4251: ‘glbinding::Binding::Accum’: class ‘glbinding::Function<void,gl::GLenum,gl::GLfloat>’ needs to have dll-interface to be used by clients of class ‘glbinding::Binding’
    

    These warnings occur when compiling the .cpp file that includes glbinding/Binding.h. Do I need to recompile glbinding as a static library? (I'd prefer to use the pre-built version if at all possible, which seems to be a dynamic-linking version.)

    By the way, these are warnings, not errors. The project otherwise compiles, links and seems to run correctly. But there are a huge number of them (hundreds or thousands), and they'll make it harder to spot real warnings. I can just disable the warning, but it seems this may not be the best solution...?

    I've seen some threads discussing this warning (e.g. here or here). But I'm not sure what's the best thing to do in my case, as I'm not the one creating a DLL, just using the existing glbinding library in an executable.

    Thanks for any help you can offer, Glen.

    opened by totalgee 9
  • libglbinding.so.3 => not found by libglbinding-aux.so (bad runpath?)

    libglbinding.so.3 => not found by libglbinding-aux.so (bad runpath?)

    I have built glbinding from source:

    mkdir build && cd build && cmake -G "Ninja" ../ -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX="../install"
    

    I cd into the install directory cd ../install and run:

    ldd libglbinding-aux.so
    

    output:

    [...]
    libglbinding.so.3 => not found
    [...]
    

    This is because the runpath is set to $ORIGIN/lib, where $ORIGIN for libglbinding-aux.so is it's absolute path (in my case ~/glbinding/install/lib/) and hence $ORIGIN/lib is ~/glbinding/install/lib/lib. No wonder libglbinding-aux.so can't find libglbinding.so.3, since there is no ~/glbinding/install/lib/lib/libglbinding.so.3 (note the lib/lib!)

    I'd expect

    ldd libglbinding-aux.so
    

    to report libglbinding.so.3 as found in ~/glbinding/install/lib/libglbinding.so.3


    Question(s):

    1. Why is runpath for all glbinding libraries set to $ORIGIN/lib as opposed to just $ORIGIN? If runpath of glbinding-aux.so.3 was just $ORIGIN, then ldd libglbinding-aux.so would've found libglbinding.so.3.
    2. Is there some intended way on how to solve my problem described above, or is this a bug in glbinding?

    Background: I use CMake to build an executable that depends on glbinding. I install the executable and all of it's runtime dependencies like so:

    install(
      RUNTIME_DEPENDENCY_SET MyExecutableTarget
      DESTINATION bin
      RUNTIME_DEPENDENCY_SET MyExecutableTargetRuntimeDependencySet)
    install(
      TARGETS MyExecutableTarget
      DESTINATION bin
      RUNTIME_DEPENDENCY_SET MyExecutableTargetRuntimeDependencySet)
    

    but this step fails since libglbinding-aux.so can't resolve it's dependency on libglbinding.so.3 since no such file exists in RUNPATH. I can workaround this with patchelf --set-rpath "\$ORIGIN" libglbinding-aux.so.3, but I'd rather not do this since it's brittle and requires developer-machines to install patchelf.

    opened by Kuxe 8
  • Conan packaging

    Conan packaging

    I've just updated a Conan package to the latest release here, based on someone else's previous work. Now builds on both Travis/Appveyor and publishes to Bintray on push.

    Any interest in getting this in here, or maybe to https://github.com/conan-io/conan-center-index ?

    opened by kaidokert 8
  • glbinding-aux does not link on msvc 2019

    glbinding-aux does not link on msvc 2019

    waited several hours, did not crash nor finish ... msvc2019 is officially released and not in any beta/alpha state so i assume we should strive for support/fix as soon as possible.

    bug 
    opened by cgcostume 8
  • Missing -lpthread

    Missing -lpthread

    On FreeBSD 13 version 3.1.0 breaks:

    [ 16% 5/6] : && /usr/bin/c++ -O2 -pipe -fno-omit-frame-pointer -fstack-protector-strong -fno-strict-aliasing -fno-omit-frame-pointer -O2 -pipe -fno-omit-frame-pointer -fstack-protector-strong -fno-strict-aliasing -fno-omit-frame-pointer -fstack-protector-strong source/tools/glmeta/CMakeFiles/glmeta.dir/main.cpp.o -o glmeta  -Wl,-rpath,/disk-samsung/freebsd-ports/graphics/glbinding/work/.build:  libglbinding-aux.so.3.1.0  libglbinding.so.3.1.0 && :
    FAILED: glmeta 
    : && /usr/bin/c++ -O2 -pipe -fno-omit-frame-pointer -fstack-protector-strong -fno-strict-aliasing -fno-omit-frame-pointer -O2 -pipe -fno-omit-frame-pointer -fstack-protector-strong -fno-strict-aliasing -fno-omit-frame-pointer -fstack-protector-strong source/tools/glmeta/CMakeFiles/glmeta.dir/main.cpp.o -o glmeta  -Wl,-rpath,/disk-samsung/freebsd-ports/graphics/glbinding/work/.build:  libglbinding-aux.so.3.1.0  libglbinding.so.3.1.0 && :
    ld: error: libglbinding-aux.so.3.1.0: undefined reference to pthread_create [--no-allow-shlib-undefined]
    c++: error: linker command failed with exit code 1 (use -v to see invocation)
    
    opened by yurivict 2
  • Per-feature headers and gl namespace

    Per-feature headers and gl namespace

    I liked the idea of per-feature headers very much. However I was hoping for a stricter implementation. Even though I include only the gl45core, deprecated functions are accessible through the gl namespace. Below is a test project

    image

    Currently line 6 gives an error but line 5 does not. Is there a way to use glbinding where both lines give an error, i.e. defined gl functions are the only ones from the included feature header?

    opened by bekorn 1
  • What's the status of noexcept?

    What's the status of noexcept?

    Hi there, thanks for the awesome library! Are there any plans to support noexcept for the public bindings provided by the library? I found that #115 mentions this but that was 4.5 years ago.

    Personally I find this the only downside of the library over old C-bindings, as IIRC C-headers are treated as noexcept by default, whereas here at least my Visual Studio 2019 warns about incorrect noexcept usage inside noexcept functions when Core Guideline Checks are enabled.

    I understand that this might be challenging due to the existence of setAfterCallback, but I figured I'd at least ask.

    opened by Tyyppi77 1
  • Problem with glBufferData under MinGW GCC 9.2

    Problem with glBufferData under MinGW GCC 9.2

    ( using CMake 3.16.4, MinGW Makefiles, MinGW 64 GCC 9.2, Windows 10 )

    Compiling cubescape example I'm getting this link error:

    glbinding/source/examples/cubescape/CubeScape.cpp:172: undefined reference to `gl::glBufferData(gl::GLenum, unsigned long long, void const*, gl::GLenum)'

    Curiously it works if I change glBufferData by glBufferDataARB

    It seems that both methods are in libglbinding.dll.a:

    objconv -dH libglbinding.dll.a | grep -i glbufferdata
    ZN2gl15glBufferDataARBENS_6GLenumExPKvS0
    _imp__ZN2gl15glBufferDataARBENS_6GLenumExPKvS0
    ZN2gl12glBufferDataENS_6GLenumExPKvS0
    _imp__ZN2gl12glBufferDataENS_6GLenumExPKvS0

    Looking at the code, both methods are quite similar to me.

    I'm puzzled. Some clues about what is going on?

    opened by Darky-Lucera 2
  • Static linking does not work

    Static linking does not work

    I compiled a static version of glbinding using cmake (libglbinding.a), but when i try to link this into my project I just get many errors like: undefined reference to '__imp__ZN2gl8glEnableENS_6GLenumE'

    I'm using CLion and the latest version of CMake. Here is my CMakeLists.txt:

    cmake_minimum_required(VERSION 3.15)
    project(blobs)
    
    include_directories(include)
    
    set(CMAKE_CXX_STANDARD 17)
    set(CMAKE_FIND_LIBRARY_SUFFIXES, ".a")
    set(CMAKE_EXE_LINKER_FLAGS "-static-libgcc -static-libstdc++ -static")
    
    find_package(glfw3 REQUIRED)
    #find_package(glbinding REQUIRED)
    find_package(glm REQUIRED)
    
    add_executable(blobs src/main.cpp src/shader.cpp)
    target_link_libraries(blobs glfw3 D:/msys64/mingw64/lib/libglbinding.a glm)
    

    The reason I want to statically link is so that I can create a standalone executable for my project. If instead I use the dynamic linking (glbinding::glbinding), when I run the executable it says it can't find the dll file. To note, the program does run fine if it isn't statically linked when run in CLion (but cannot be run as a standalone executable). This is my first time using CMake and CLion so I apologise for not really knowing what to do. Please say if you need any more information. :)

    bug Setup 
    opened by chez4 1
Releases(v3.1.0)
  • v3.1.0(Apr 26, 2019)

    glbinding, version 3.1.0, created by CG Internals and the Computer Graphics Systems Group at the Hasso Plattner Institute, University of Potsdam, Germany.

    Contact: Daniel Limberger, Willy Scheibel ([email protected])

    CHANGES

    • Improve documentation
    • Improvements on project setup (cmake-init update, cmake policies update)
    • Update to current gl.xml
    • Improve error propagation in examples and tools
    • Add KHR platform headers as gl.xml now relies on their availability
    • Convert all dependencies to being optional
    • Add fallback implementation for native function resolution lookup if no external can be provided

    FIXES

    • Fix compilation with MSVC 2019

    KNOWN ISSUES

    • Linking with MSVC 2019 takes super long time

    DISCLAIMER OF WARRANTIES AND LIMITATION OF LIABILITY The software is supplied “as is” and all use is at your own risk. CG Internals, Hasso Plattner Institute, and the University of Potsdam disclaim all warranties of any kind, either express or implied, as to the software, including, but not limited to, implied warranties of fitness for a particular purpose, merchantability or non‐infringement of proprietary rights. Neither this agreement nor any documentation furnished under it is intended to express or imply any warranty that the operation of the software will be uninterrupted, timely, or error‐free. Under no circumstances shall CG Internals, Hasso Plattner Institute, or University of Potsdam be liable to any user for direct, indirect, incidental, consequential, special, or exemplary damages, arising from or relating to this agreement, the software, or userʹs use or misuse of the software or any other services provided by CG Internals, Hasso Plattner Institute and University of Potsdam. Such limitation of liability shall apply whether the damages arise from the use or misuse of the software or any other services supplied by CG Internals, Hasso Plattner Institute, or University of Potsdam (including such damages incurred by third parties), or errors of the software.

    Source code(tar.gz)
    Source code(zip)
    glbinding-3.1.0-msvc2017-x64-dev.zip(1.51 MB)
    glbinding-3.1.0-msvc2017-x64-examples.zip(9.28 MB)
    glbinding-3.1.0-msvc2017-x64-installer.exe(21.56 MB)
    glbinding-3.1.0-msvc2017-x64-runtime.zip(1.39 MB)
    glbinding-3.1.0-msvc2017-x64-tools.zip(1.45 MB)
  • v3.0.2(Jul 11, 2018)

    glbinding, version 3.0.2, created by CG Internals and the Computer Graphics Systems Group at the Hasso Plattner Institute, University of Potsdam, Germany.

    Contact: Daniel Limberger, Willy Scheibel ([email protected])

    BREAKING CHANGES

    • provide get proc address function pointer resolver
    • move logging, print-to-stream and meta functionality to new glbinding-aux module
    • move parser and code generator to external project cginternal/khrbinding-generator

    CHANGES

    • introduce glbinding-aux module for desired OpenGL API functionality besides a plain binding
    • update OpenGL API (gl.xml)
    • add glGetProgramResourceiv overload for GLenum
    • add glinfo and glisdeprecated tools
    • add global glbinding API (no need to access global Binding class for most use cases anymore)
    • assert a valid function pointer instead of silent failure #262
    • provide glGetError after callback default implementation in glbinding-aux module

    FIXES

    • unspecialized class template error #254
    • remove use of result_type #250
    • fix sign of GLsizeiptr #226

    DISCLAIMER OF WARRANTIES AND LIMITATION OF LIABILITY The software is supplied “as is” and all use is at your own risk. CG Internals GmbH, Hasso Plattner Institute, and the University of Potsdam disclaim all warranties of any kind, either express or implied, as to the software, including, but not limited to, implied warranties of fitness for a particular purpose, merchantability or non‐infringement of proprietary rights. Neither this agreement nor any documentation furnished under it is intended to express or imply any warranty that the operation of the software will be uninterrupted, timely, or error‐free. Under no circumstances shall CG Internals GmbH, Hasso Plattner Institute, or University of Potsdam be liable to any user for direct, indirect, incidental, consequential, special, or exemplary damages, arising from or relating to this agreement, the software, or userʹs use or misuse of the software or any other services provided by CG Internals GmbH, Hasso Plattner Institute and University of Potsdam. Such limitation of liability shall apply whether the damages arise from the use or misuse of the software or any other services supplied by CG Internals, Hasso Plattner Institute, or University of Potsdam (including such damages incurred by third parties), or errors of the software.

    Source code(tar.gz)
    Source code(zip)
  • v2.1.4(Feb 22, 2018)

    glbinding, version 2.1.4, created by CG Internals and the Computer Graphics Systems Group at the Hasso Plattner Institute, University of Potsdam, Germany.

    FIXES

    • Fix compilation error for MSVC (fixes #234)

    CHANGES

    • Add support for OpenGL 4.6
    • Add OPTION_BUILD_WITH_BOOST_THREAD CMake option

    BREAKING CHANGES

    • Increase minimum required GLFW version to 3.2
    Source code(tar.gz)
    Source code(zip)
  • v2.1.3(May 5, 2017)

    glbinding, version 2.1.3, created by CG Internals and the Computer Graphics Systems Group at the Hasso Plattner Institute, University of Potsdam, Germany.

    CHANGES

    • Fix version for packaging
    • Update gl.xml
    • Update cmake-init template
    Source code(tar.gz)
    Source code(zip)
  • v2.1.2(Apr 24, 2017)

    glbinding, version 2.1.2, created by CG Internals and the Computer Graphics Systems Group at the Hasso Plattner Institute, University of Potsdam, Germany.

    FIXES (BREAKING CHANGES)

    • Fix parameter type of glClampColor to glBoolean (closes #230)

    FIXES

    • Test for nullptr before constructing invalid std::strings

    CHANGES

    • Use stdlib lock_guards
    • Add decimal representations to GLenum constants fur quick reference
    • Introduce constexpr and inline semantics where applicable
    Source code(tar.gz)
    Source code(zip)
  • v2.1.1(Jun 27, 2016)

    glbinding, version 2.1.1, created by CG Internals and the Computer Graphics Systems Group at the Hasso Plattner Institute, University of Potsdam, Germany.

    Contact: Daniel Limberger, Willy Scheibel ([email protected])

    CHANGES

    • update OpenGL API (gl.xml) to revision 32957
    • provide actual overloaded functions for function-patches (e.g., glTexParameteri), former e and b post-fixed will be removed in next major version
    • update and refine OS X deployment
    • enable type-safe GLboolean to behave like bool
    • rename hpp to more common inl and remove header back-includes
    • extend version, meta, and context info features
      • add various ContextInfo::supported queries
      • rename Meta::getRequiredExtensions() to Meta::extensions()
      • rename Meta::getRequiringVersion() to Meta::version()
      • add preceeding and succeeding functions to Version
      • update glfunctions tool (list missing extensions and functions in summary)

    FIXES

    • fix GLFW find script
    • fix race on AbstractFunction state vector

    DISCLAIMER OF WARRANTIES AND LIMITATION OF LIABILITY The software is supplied “as is” and all use is at your own risk. CG Internals GmbH, Hasso Plattner Institute, and the University of Potsdam disclaim all warranties of any kind, either express or implied, as to the software, including, but not limited to, implied warranties of fitness for a particular purpose, merchantability or non‐infringement of proprietary rights. Neither this agreement nor any documentation furnished under it is intended to express or imply any warranty that the operation of the software will be uninterrupted, timely, or error‐free. Under no circumstances shall CG Internals GmbH, Hasso Plattner Institute, or University of Potsdam be liable to any user for direct, indirect, incidental, consequential, special, or exemplary damages, arising from or relating to this agreement, the software, or userʹs use or misuse of the software or any other services provided by CG Internals GmbH, Hasso Plattner Institute and University of Potsdam. Such limitation of liability shall apply whether the damages arise from the use or misuse of the software or any other services supplied by CG Internals, Hasso Plattner Institute, or University of Potsdam (including such damages incurred by third parties), or errors of the software.

    Source code(tar.gz)
    Source code(zip)
    glbinding-2.1.1-msvc2015-x64-dev.zip(1.28 MB)
    glbinding-2.1.1-msvc2015-x64-examples.zip(8.41 MB)
    glbinding-2.1.1-msvc2015-x64-installer.exe(20.87 MB)
    glbinding-2.1.1-msvc2015-x64-runtime.zip(1.20 MB)
    glbinding-2.1.1-msvc2015-x64-tools.zip(1.30 MB)
  • v2.0.0(Mar 24, 2016)

    glbinding, version 2.0.0, created by CG Internals and the Computer Graphics Systems Group at the Hasso Plattner Institute, University of Potsdam, Germany.

    Contact: Daniel Limberger, Willy Scheibel ([email protected])

    BREAKING CHANGES

    • CMake find script doesn't define GLBINDING_LIBRARIES and GLBINDING_INCLUDES anymore. Use the new target_link_libraries(${target} PRIVATE glbinding::glbinding) syntax to link against glbinding

    CHANGES

    • updated OpenGL API (gl.xml) to revision 32363
    • introduced per-feature header directories (e.g., gl32core/gl.h)
    • add support for NMake and CYGWIN
    • decreased compilation time and compilation resource on most platforms
    • added context creation cheat sheet for gathering intel on context creation on various system configurations
    • added operation assign operators for bit fields
    • package provisioning using Ubuntu PPAs, Homebrew recipe and AUR source package.
    • refined cmake setup (minimum required version is now 3.0)
    • updated Wiki and Readme
    • revised meta run-time generation (always included)
    • differentiate between examples and tools (tools enabled by default, examples enabled by cmake option OPTION_BUILD_EXAMPLES=On)
    • added google-mock directly into the code base
    • added continuous integration and status display in readme for
      • MSVC 2013 Update 5 and 2015 Update 1 (Windows 10, x64)
      • GCC 4.8, 4.9, and 5.3 (Ubuntu 14.04)
      • Clang 3.5 (Ubuntu 14.04)
      • Travis CI: GCC 4.8 and Clang 3.5 (Ubuntu 14.04)
      • Coverity
    • refined glfw and glew find scripts
    • doxygen documentation hosted on gh-pages
    • Use moustache as template engine for the code generation

    FIXES (excerpt)

    • use cmath instead of complex to define std::abs
    • added support for GL_NV_conservative_raster_dilate
    • disabled warning 4127 in cubescape-qt due to qt issues in msvc2015
    • updated logo
    • reviewed and fixed bitfield group handling in meta
    • fixed type conversion warning/error
    • fixed gl.xml updating process
    • fixed global and local callback handling
    • disabled RTCc
    • renamed tools to avoid name clashes with system installs
    • add deployment for documentation
    • ...

    DISCLAIMER OF WARRANTIES AND LIMITATION OF LIABILITY The software is supplied “as is” and all use is at your own risk. CG Internals GmbH, Hasso Plattner Institute, and the University of Potsdam disclaim all warranties of any kind, either express or implied, as to the software, including, but not limited to, implied warranties of fitness for a particular purpose, merchantability or non‐infringement of proprietary rights. Neither this agreement nor any documentation furnished under it is intended to express or imply any warranty that the operation of the software will be uninterrupted, timely, or error‐free. Under no circumstances shall CG Internals GmbH, Hasso Plattner Institute, or University of Potsdam be liable to any user for direct, indirect, incidental, consequential, special, or exemplary damages, arising from or relating to this agreement, the software, or userʹs use or misuse of the software or any other services provided by CG Internals GmbH, Hasso Plattner Institute and University of Potsdam. Such limitation of liability shall apply whether the damages arise from the use or misuse of the software or any other services supplied by CG Internals, Hasso Plattner Institute, or University of Potsdam (including such damages incurred by third parties), or errors of the software.

    Source code(tar.gz)
    Source code(zip)
    glbinding-2.0.0-msvc2015-x64-dev.zip(1.27 MB)
    glbinding-2.0.0-msvc2015-x64-examples.zip(19.23 MB)
    glbinding-2.0.0-msvc2015-x64-installer.exe(27.72 MB)
    glbinding-2.0.0-msvc2015-x64-runtime.zip(1.31 MB)
    glbinding-2.0.0-msvc2015-x64-tools.zip(1.34 MB)
  • v1.1.0(Apr 8, 2015)

    glbinding, version 1.1.0, created by the Computer Graphics System Group at the Hasso Plattner Institute, University of Potsdam, Germany.

    Contact: Daniel Limberger ([email protected])

    CHANGES

    • update gl.xml to revision 30599
    • provide build status information in readme
    • decrease compile time by not using inline functions in gl headers
    • cleanup includes
    • use using for feature imports (reduces size of binaries and decreases compile time)
    • add per-feature type and value includes
    • reduce coverity defect density to zero
    • add basic logging functions
    • add option to use the statically linked runtime library (msvc only)
    • add GL_NONE_BIT
    • fix buffer storage bitfield group
    • make generation scripts more robust and consequently used
    • use separate clang platform definitions on Linux
    • define all operators in global namespace
    • add NV_command_list support
    • fix OS X rpath problem
    • show change in gl.xml on update
    • fix duplicated 'revision' file deployment
    • glfw is deployed as shared library (win32)

    DISCLAIMER OF WARRANTIES AND LIMITATION OF LIABILITY The software is supplied “as is” and all use is at your own risk. Hasso Plattner Institut and the University of Potsdam disclaim all warranties of any kind, either express or implied, as to the software, including, but not limited to, implied warranties of fitness for a particular purpose, merchantability or non‐infringement of proprietary rights. Neither this agreement nor any documentation furnished under it is intended to express or imply any warranty that the operation of the software will be uninterrupted, timely, or error‐free. Under no circumstances shall Hasso Plattner Institute and University of Potsdam be liable to any user for direct, indirect, incidental, consequential, special, or exemplary damages, arising from or relating to this agreement, the software, or userʹs use or misuse of the software or any other services provided by Hasso Plattner Institute and University of Potsdam. Such limitation of liability shall apply whether the damages arise from the use or misuse of the software or any other services supplied by Hasso Plattner Institute and University of Potsdam (including such damages incurred by third parties), or errors of the software.

    Source code(tar.gz)
    Source code(zip)
    glbinding-1.1.0-msvc12-x64-dev.zip(2.31 MB)
    glbinding-1.1.0-msvc12-x64-examples.zip(17.77 MB)
    glbinding-1.1.0-msvc12-x64-runtime.zip(1.06 MB)
    glbinding-1.1.0-msvc12-x64-tools.zip(1.14 MB)
    glbinding-1.1.0-msvc12-x64.exe(20.05 MB)
  • v1.0.5(Feb 6, 2015)

    glbinding, version 1.0.5, created by the Computer Graphics System Group at the Hasso Plattner Institute, University of Potsdam, Germany.

    Contact: Daniel Limberger ([email protected])

    CHANGES

    • update gl.xml to revision 29609
    • add per function callbacks #26
    • add context check example
    • add query example
    • split examples into examples and tools
    • adjust contexts example to print out markdown (use --markdown)
    • add context switch callback #28
    • add interface to register external functions #10
    • fix value.cpp wrapString() segfaults on nullptr #63
    • fix gcc compiler flags
    • fix msvc compile flags
    • allow for release and debug specific compile flags
    • fix compilation for gcc 4.7
    • fix msvc warnings on msvc13 (visual stuido 2014 preview)
    • fix cpack configuration type
    • reduce/unify cmake comments
    • reduce memory footprint for compilation
    • move return value in after callback signature
    • use move to save std::functions
    • provide latest version in Version
    • replace explicit std::funtion validity flag with usage of nullptr
    • prepare architecture to support multiple values per GLenum
    • fix MAX_VARYING_FLOATS GLenum name
    • interface and cubescape example fixes
    • make Qt example compatible with Qt < 5.3

    DISCLAIMER OF WARRANTIES AND LIMITATION OF LIABILITY The software is supplied “as is” and all use is at your own risk. Hasso Plattner Institut and the University of Potsdam disclaim all warranties of any kind, either express or implied, as to the software, including, but not limited to, implied warranties of fitness for a particular purpose, merchantability or non‐infringement of proprietary rights. Neither this agreement nor any documentation furnished under it is intended to express or imply any warranty that the operation of the software will be uninterrupted, timely, or error‐free. Under no circumstances shall Hasso Plattner Institute and University of Potsdam be liable to any user for direct, indirect, incidental, consequential, special, or exemplary damages, arising from or relating to this agreement, the software, or userʹs use or misuse of the software or any other services provided by Hasso Plattner Institute and University of Potsdam. Such limitation of liability shall apply whether the damages arise from the use or misuse of the software or any other services supplied by Hasso Plattner Institute and University of Potsdam (including such damages incurred by third parties), or errors of the software.

    Source code(tar.gz)
    Source code(zip)
    glbinding-1.0.5-msvc13-x64-dev.zip(2.72 MB)
    glbinding-1.0.5-msvc13-x64-examples.zip(17.39 MB)
    glbinding-1.0.5-msvc13-x64-runtime.zip(700.87 KB)
    glbinding-1.0.5-msvc13-x64-tools.zip(804.93 KB)
    glbinding-1.0.5-msvc13-x64.exe(20.50 MB)
  • v1.0.4(Nov 26, 2014)

    glbinding, version 1.0.4, created by the Computer Graphics System Group at the Hasso Plattner Institute, University of Potsdam, Germany.

    Contact: Daniel Limberger ([email protected])

    CHANGES

    • update gl.xml to revision 29026
    • increase warning level and warnings as errors
    • provide debug binaries via cmake config
    • support extension queries for OpenGL 2.1 or less
    • provide setSwapInterval for OS X in cubescape-qt
    • add specific linkers for MacOSPlatform
    • fix calling convention on windows
    • adjust find scripts of gmock and gtest
    • fix cubescape-qt and compare on os x
    • update list of authors
    • add refined info texts for examples
    • prefer WIN32 over _WIN32
    • split interface and implementation in SharedBitfield
    • provisioning of qt dependencies in debug install
    • use functions in custom cmake and unify config style

    DISCLAIMER OF WARRANTIES AND LIMITATION OF LIABILITY The software is supplied “as is” and all use is at your own risk. Hasso Plattner Institut and the University of Potsdam disclaim all warranties of any kind, either express or implied, as to the software, including, but not limited to, implied warranties of fitness for a particular purpose, merchantability or non‐infringement of proprietary rights. Neither this agreement nor any documentation furnished under it is intended to express or imply any warranty that the operation of the software will be uninterrupted, timely, or error‐free. Under no circumstances shall Hasso Plattner Institute and University of Potsdam be liable to any user for direct, indirect, incidental, consequential, special, or exemplary damages, arising from or relating to this agreement, the software, or userʹs use or misuse of the software or any other services provided by Hasso Plattner Institute and University of Potsdam. Such limitation of liability shall apply whether the damages arise from the use or misuse of the software or any other services supplied by Hasso Plattner Institute and University of Potsdam (including such damages incurred by third parties), or errors of the software.

    Source code(tar.gz)
    Source code(zip)
    glbinding-1.0.4-msvc12-x64-dev.zip(2.78 MB)
    glbinding-1.0.4-msvc12-x64-examples.zip(17.83 MB)
    glbinding-1.0.4-msvc12-x64-runtime.zip(771.08 KB)
    glbinding-1.0.4-msvc12-x64.exe(13.74 MB)
  • v1.0.3(Nov 1, 2014)

    glbinding, version 1.0.3, created by the Computer Graphics System Group at the Hasso Plattner Institute, University of Potsdam, Germany.

    Contact: Daniel Limberger ([email protected])

    CHANGES

    • updated gl.xml to revision 28798
    • add logos and nsis package graphics
    • refine git revision extraction in submodule contexts
    • update list of contributors
    • extract shaders from cubescape into separate files
    • unify cmake formating

    DISCLAIMER OF WARRANTIES AND LIMITATION OF LIABILITY The software is supplied “as is” and all use is at your own risk. Hasso Plattner Institut and the University of Potsdam disclaim all warranties of any kind, either express or implied, as to the software, including, but not limited to, implied warranties of fitness for a particular purpose, merchantability or non‐infringement of proprietary rights. Neither this agreement nor any documentation furnished under it is intended to express or imply any warranty that the operation of the software will be uninterrupted, timely, or error‐free. Under no circumstances shall Hasso Plattner Institute and University of Potsdam be liable to any user for direct, indirect, incidental, consequential, special, or exemplary damages, arising from or relating to this agreement, the software, or userʹs use or misuse of the software or any other services provided by Hasso Plattner Institute and University of Potsdam. Such limitation of liability shall apply whether the damages arise from the use or misuse of the software or any other services supplied by Hasso Plattner Institute and University of Potsdam (including such damages incurred by third parties), or errors of the software.

    Source code(tar.gz)
    Source code(zip)
    glbinding-1.0.3-msvc12-x64-dev.zip(2.78 MB)
    glbinding-1.0.3-msvc12-x64-examples.zip(17.79 MB)
    glbinding-1.0.3-msvc12-x64-runtime.zip(770.15 KB)
    glbinding-1.0.3-msvc12-x64.exe(20.39 MB)
  • v1.0.2(Sep 21, 2014)

    glbinding, version 1.0.2, created by the Computer Graphics System Group at the Hasso Plattner Institute, University of Potsdam, Germany.

    Contact: Daniel Limberger ([email protected])

    CHANGES

    • fixed cmake and cpack configuration for static build

    DISCLAIMER OF WARRANTIES AND LIMITATION OF LIABILITY The software is supplied “as is” and all use is at your own risk. Hasso Plattner Institut and the University of Potsdam disclaim all warranties of any kind, either express or implied, as to the software, including, but not limited to, implied warranties of fitness for a particular purpose, merchantability or non‐infringement of proprietary rights. Neither this agreement nor any documentation furnished under it is intended to express or imply any warranty that the operation of the software will be uninterrupted, timely, or error‐free. Under no circumstances shall Hasso Plattner Institute and University of Potsdam be liable to any user for direct, indirect, incidental, consequential, special, or exemplary damages, arising from or relating to this agreement, the software, or userʹs use or misuse of the software or any other services provided by Hasso Plattner Institute and University of Potsdam. Such limitation of liability shall apply whether the damages arise from the use or misuse of the software or any other services supplied by Hasso Plattner Institute and University of Potsdam (including such damages incurred by third parties), or errors of the software.

    Source code(tar.gz)
    Source code(zip)
    glbinding-1.0.2-msvc12-x64-dev.zip(2.76 MB)
    glbinding-1.0.2-msvc12-x64-examples.zip(17.78 MB)
    glbinding-1.0.2-msvc12-x64-installer.exe(20.33 MB)
    glbinding-1.0.2-msvc12-x64-runtime.zip(767.03 KB)
  • v1.0.1(Sep 18, 2014)

    glbinding, version 1.0.1, created by the Computer Graphics System Group at the Hasso Plattner Institute, University of Potsdam, Germany.

    Contact: Daniel Limberger ([email protected])

    DISCLAIMER OF WARRANTIES AND LIMITATION OF LIABILITY The software is supplied “as is” and all use is at your own risk. Hasso Plattner Institut and the University of Potsdam disclaim all warranties of any kind, either express or implied, as to the software, including, but not limited to, implied warranties of fitness for a particular purpose, merchantability or non‐infringement of proprietary rights. Neither this agreement nor any documentation furnished under it is intended to express or imply any warranty that the operation of the software will be uninterrupted, timely, or error‐free. Under no circumstances shall Hasso Plattner Institute and University of Potsdam be liable to any user for direct, indirect, incidental, consequential, special, or exemplary damages, arising from or relating to this agreement, the software, or userʹs use or misuse of the software or any other services provided by Hasso Plattner Institute and University of Potsdam. Such limitation of liability shall apply whether the damages arise from the use or misuse of the software or any other services supplied by Hasso Plattner Institute and University of Potsdam (including such damages incurred by third parties), or errors of the software.

    Source code(tar.gz)
    Source code(zip)
    glbinding-1.0.1-msvc12-x64-dev.zip(2.76 MB)
    glbinding-1.0.1-msvc12-x64-examples.zip(17.78 MB)
    glbinding-1.0.1-msvc12-x64-installer.exe(20.32 MB)
    glbinding-1.0.1-msvc12-x64-runtime.zip(767.03 KB)
Owner
CG Internals
Computer Graphics Internals - Software, Research, Engineering
CG Internals
This is the laplight software for enabling flashlight support on a laptop/netbook. For the specification, see: https://github.com/LapLight/

By: Seanpm2001, Et; Al. Top README.md Read this article in a different language Sorted by: A-Z Sorting options unavailable ( af Afrikaans Afrikaans |

Sean P. Myrick V19.1.7.2 2 Dec 8, 2021
The OpenEXR project provides the specification and reference implementation of the EXR file format, the professional-grade image storage format of the motion picture industry.

OpenEXR OpenEXR provides the specification and reference implementation of the EXR file format, the professional-grade image storage format of the mot

Academy Software Foundation 1.2k Jun 27, 2022
Go binding to ImageMagick's MagickWand C API

Go Imagick Go Imagick is a Go bind to ImageMagick's MagickWand C API. We support two compatibility branches: master (tag v2.x.x): 6.9.1-7 <= ImageMagi

Go Graphics community 1.5k Jun 29, 2022
Rewritten version of the MiniLibX graphics API used by 42, using glfw & glad. Running on OpenGL.

Written by W2.Wizard for the 42 Network A recreation of the MiniLibX library used by 42, using GLFW & glad, running on OpenGL. The goal of MLX42 is to

Codam 68 Jun 11, 2022
C# bindings for Sokol using Sokol's binding generator

C# bindings for Sokol using Sokol's binding generator

Michal Strehovský 25 Mar 22, 2022
XML toolkit from the GNOME project

XML toolkit from the GNOME project

GNOME Github Mirror 382 Jun 21, 2022
A library to handle Apple Property List format in binary or XML

libplist A small portable C library to handle Apple Property List files in binary or XML format. Features The project provides an interface to read an

libimobiledevice 407 Jun 13, 2022
Several GX2 test programs to compare it with OpenGL. (With additional GLFW+OpenGL implementation provided)

GX2-Tests Provided are GX2 test programs and samples for comparison with OpenGL and with additional GLFW+OpenGL implementation for test on PC. These s

AboodXD 1 Nov 15, 2021
A simple Oscilloscope application that reads the values in the serial generated by an Arduino board

Oscilloscope Serial A simple oscilloscope application that reads the values at serial port generated by an Arduino board and based on the value of the

DanielGeA 3 Jun 14, 2022
A version of Tetris with randomly generated polyominoes of varying sizes

Multris A version of Tetris with randomly generated polyominoes of varying sizes ----- CONTROLS ----- LEFT / RIGHT ARROW - Move. Hold to move quicker.

null 16 Jun 24, 2022
KDevelop plugin for automatic time tracking and metrics generated from your programming activity.

Wakatime KDevelop Plugin Installation instructions Make sure the project is configured to install to the directory of your choice: In KDevelop, select

snotr 6 Oct 13, 2021
Small stack-based DSL for procedurally generated 1-bit graphics

Bitlang Bitlang is a tiny stack-based DSL, designed for the sole purpose of producing procedurally generated 1-bit art. It is implemented in ANSI-C, a

Paul Batchelor 7 Jan 20, 2022
By putting in a lot of speed, the speed sequence is sorted and divided, three types of speed interval distribution maps are generated.(including broken line graph,histogram and curve graph)

Auto-drawing-speed-range-map By putting in a lot of speed, the speed sequence is sorted and divided, three types of speed interval distribution maps a

wellwellAllwen 4 May 14, 2022
CRC32 slice-by-16 implementation in JS with an optional native binding to speed it up even futher

CRC32 slice-by-16 implementation in JS with an optional native binding to speed it up even futher. When used with Webpack/Browserify etc, it bundles the JS version.

Mathias Buus 8 Aug 4, 2021
C++ binding to Lua

bLua C++与Lua的胶水层,b代表着bridge 特性 依赖C++17 只有一个头文件 接口简单轻量 userdata的方式管理c++指针生命周期 用法 lua调用c++ 首先注册类及需要的成员函数 // 注册全局函数 bLua::reg_global_func(L, "newA", newA

null 1 Dec 28, 2021
libmagic binding for lua.

lua-libmagic libmagic binding for lua. see man libmagic for more details. Dependencies libmagic: https://github.com/file/file Installation luarocks in

Masatoshi Fukunaga 2 Jan 14, 2022
A binding between C++11 and Lua language

lua-intf lua-intf is a binding between C++11 and Lua language, it provides three different set of API in one package: LuaBinding, Export C++ class or

Steve K. Chiu 394 Jun 26, 2022
Advanced version of lutok C++/Lua binding

Lutok2 C++/Lua binding helper for Lua 5.1 and LuaJIT 2.x+. Dependencies To use Lutok2 successfully you'll need: A standards-compliant C++11 complier L

Mário Kašuba 8 Jan 17, 2020
C++ binding to Lua

Kaguya C++ binding to Lua Licensed under Boost Software License Requirements Lua 5.1 to 5.3 (recommended: 5.3) C++03 compiler with boost library or C+

null 307 Jun 28, 2022