glad
====
GL/GLES/EGL/GLX/WGL Loader-Generator based on the official specs.
Checkout the [webservice](http://glad.dav1d.de) to generate the files you need!
```c
// GLAD_DEBUG is only defined if the c-debug generator was used
#ifdef GLAD_DEBUG
// logs every gl call to the console
void pre_gl_call(const char *name, void *funcptr, int len_args, ...) {
printf("Calling: %s (%d arguments)\n", name, len_args);
}
#endif
int main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE);
glutInitWindowSize(width, height);
glutCreateWindow("cookie");
glutReshapeFunc(reshape);
glutDisplayFunc(display);
if(!gladLoadGL()) {
printf("Something went wrong!\n");
exit(-1);
}
#ifdef GLAD_DEBUG
// before every opengl call call pre_gl_call
glad_set_pre_callback(pre_gl_call);
// post callback checks for glGetError by default
// don't use the callback for glClear
// (glClear could be replaced with your own function)
glad_debug_glClear = glad_glClear;
#endif
// gladLoadGLLoader(&glutGetProcAddress);
printf("OpenGL %d.%d\n", GLVersion.major, GLVersion.minor);
if (GLVersion.major < 2) {
printf("Your system doesn't support OpenGL >= 2!\n");
return -1;
}
printf("OpenGL %s, GLSL %s\n", glGetString(GL_VERSION),
glGetString(GL_SHADING_LANGUAGE_VERSION));
glutMainLoop();
return 0;
}
```
Checkout the full example: [simple.c](https://github.com/Dav1dde/glad/blob/master/example/c/simple.c)
Or the C++ example using [GLFW](http://glfw.org):
[hellowindow2.cpp](https://github.com/Dav1dde/glad/blob/master/example/c%2B%2B/hellowindow2.cpp)
## Usage ##
**If you don't want to install glad you can use the [webservice](http://glad.dav1d.de)**
Otherwise either install glad via pip:
# Windows
pip install glad
# Linux
pip install --user glad
# Linux global (root)
pip install glad
glad --help
To install the most recent version from Github:
pip install --upgrade git+https://github.com/dav1dde/glad.git#egg=glad
Or launch glad directly (after cloning the repository):
python -m glad --help
Possible commandline options:
usage: glad [-h] [--profile {core,compatibility}] --out-path OUT
[--api API] --generator {c,d,volt}
[--extensions EXTENSIONS] [--spec {gl,egl,glx,wgl}]
[--no-loader]
Uses the official Khronos-XML specs to generate a GL/GLES/EGL/GLX/WGL Loader
made for your needs. Glad currently supports the languages C, D and Volt.
optional arguments:
-h, --help show this help message and exit
--profile {core,compatibility}
OpenGL profile (defaults to compatibility)
--out-path OUT Output path for loader
--api API API type/version pairs, like "gl=3.2,gles=", no
version means latest
--generator {c,c-debug,d,volt}
Language to generate the binding for
--extensions EXTENSIONS
Path to extensions file or comma separated list of
extensions, if missing all extensions are included
--spec {gl,egl,glx,wgl}
Name of the spec
--no-loader
--omit-khrplatform Omits inclusion of the khrplatform.h file which is
often unnecessary. Only has an effect if used
together with c generators.
--local-files Forces every file directly into the output directory.
No src or include subdirectories are generated. Only
has an effect if used together with c generators.
To generate a loader for C with two extensions, it could look like this:
python main.py --generator=c --extensions=GL_EXT_framebuffer_multisample,GL_EXT_texture_filter_anisotropic --out-path=GL
`--out-path` and `--generator` are required!
If the `--extensions` option is missing, glad adds support for all extensions found in the OpenGL spec.
## Generators ##
### C/C++ ###
```c
struct gladGLversionStruct {
int major;
int minor;
};
extern struct gladGLversionStruct GLVersion;
typedef void* (* GLADloadproc)(const char *name);
/*
* Load OpenGL using the internal loader.
* Returns the true/1 if loading succeeded.
*
*/
int gladLoadGL(void);
/*
* Load OpenGL using an external loader like SDL_GL_GetProcAddress.
*
* Substitute GL with the API you generated
*
*/
void gladLoadGLLoader(GLADloadproc);
```
`glad.h` completely replaces any `gl.h` or `gl3.h` only include `glad.h`.
```c
if(!gladLoadGL()) { exit(-1) };
printf("OpenGL Version %d.%d loaded", GLVersion.major, GLVersion.minor);
if(GLAD_GL_EXT_framebuffer_multisample) {
/* GL_EXT_framebuffer_multisample is supported */
}
if(GLAD_GL_VERSION_3_0) {
/* We support at least OpenGL version 3 */
}
```
On non-Windows platforms glad requires `libdl`, make sure to link with it (`-ldl` for gcc)!
Note, there are two kinds of extension/version symbols, e.g. `GL_VERSION_3_0` and
`GLAD_VERSION_3_0`. Latter is a runtime boolean (represented as integer), whereas
the first (not prefixed with `GLAD_`) is a compiletime-constant, indicating that this
header supports this version (the official headers define these symbols as well).
The runtime booleans are only valid *after* a succesful call to `gladLoadGL` or `gladLoadGLLoader`.
### C/C++ Debug ###
The C-Debug generator extends the API by these two functions:
```c
// this symbol only exists if generated with the c-debug generator
#define GLAD_DEBUG
typedef void (* GLADcallback)(const char *name, void *funcptr, int len_args, ...);
/*
* Sets a callback which will be called before every function call
* to a function loaded by glad.
*
*/
GLAPI void glad_set_pre_callback(GLADcallback cb);
/*
* Sets a callback which will be called after every function call
* to a function loaded by glad.
*
*/
GLAPI void glad_set_post_callback(GLADcallback cb);
```
To call a function like `glGetError` in a callback prefix it with `glad_`, e.g.
the default post callback looks like this:
```c
void _post_call_callback_default(const char *name, void *funcptr, int len_args, ...) {
GLenum error_code;
error_code = glad_glGetError();
if (error_code != GL_NO_ERROR) {
fprintf(stderr, "ERROR %d in %s\n", error_code, name);
}
}
```
You can also submit own implementations for every call made by overwriting
the function pointer with the name of the function prefixed by `glad_debug_`.
E.g. you could disable the callbacks for glClear with `glad_debug_glClear = glad_glClear`, where
`glad_glClear` is the function pointer loaded by glad.
The `glClear` macro is defined as `#define glClear glad_debug_glClear`,
`glad_debug_glClear` is initialized with a default implementation, which calls
the two callbacks and the real function, in this case `glad_glClear`.
### D ###
Import `glad.gl` for OpenGL functions/extensions, import `glad.loader` to import
the functions needed to initialize glad and load the OpenGL functions.
```d
enforce(gladLoadGL()); // optionally you can pass a loader to this function
writefln("OpenGL Version %d.%d loaded", GLVersion.major, GLVersion.minor);
if(GL_EXT_framebuffer_multisample) {
/* GL_EXT_framebuffer_multisample is supported */
}
if(GL_VERSION_3_0) {
/* We support at least OpenGL version 3 */
}
```
On non-Windows platforms glad requires `libdl`, make sure to link with it (`L-ldl` for dmd)!
## FAQ ##
### glad includes windows.h which breaks my code!
Defining `APIENTRY` before including `glad.h` solves this problem:
```c
#ifdef _WIN32
#define APIENTRY __stdcall
#endif
#include <glad/glad.h>
```
But make sure you have the correct definition of `APIENTRY` for platforms which define `_WIN32` but don't use `__stdcall`
Relevant issue: [#42](https://github.com/Dav1dde/glad/issues/42)
## Contribute ##
Contributing is easy! Found a bug? Message me or make a pull request! Added a new generator backend?
Make a pull request!
Special thanks for all the people who contributed and are going to contribute!
Also to these who helped me solve a problem when I simply could not think of a solution.