gl_common.h

Go to the documentation of this file.

 
#ifndef GL_COMMON_H
#define GL_COMMON_H
 
#ifndef GL_COMMON_NO_GLAD
#include "glad/glad.h"  // IWYU pragma: export
#else
#ifndef GLFW_INCLUDE_NONE
#define GLFW_INCLUDE_NONE
#endif
/* Minimal GL types fallback */
typedef unsigned int GLuint;
typedef int GLint;
typedef unsigned int GLenum;
typedef int GLsizei;
typedef float GLfloat;
typedef unsigned char GLboolean;
typedef long GLsizeiptr;
typedef long GLintptr;
typedef void* GLsync;
typedef unsigned long long GLuint64;
typedef char GLchar;
typedef unsigned int GLbitfield;
 
#define GL_TRUE 1
#define GL_FALSE 0
#define GL_TEXTURE_2D 0x0DE1
#define GL_TEXTURE_MIN_FILTER 0x2801
#define GL_TEXTURE_MAG_FILTER 0x2800
#define GL_TEXTURE_WRAP_S 0x2802
#define GL_TEXTURE_WRAP_T 0x2803
#define GL_TEXTURE_WIDTH 0x1000
#define GL_TEXTURE_HEIGHT 0x1001
#define GL_TEXTURE_INTERNAL_FORMAT 0x1003
#define GL_LINEAR 0x2601
#define GL_LINEAR_MIPMAP_LINEAR 0x2703
#define GL_CLAMP_TO_EDGE 0x812F
#define GL_REPEAT 0x2901
#define GL_RGBA32F 0x8814
#define GL_RGBA16F 0x881A
#define GL_RGB32F 0x8815
#define GL_RGB16F 0x881B
#define GL_RGB 0x1907
#define GL_RGBA 0x1908
#define GL_FLOAT 0x1406
#define GL_HALF_FLOAT 0x140B
#define GL_UNSIGNED_BYTE 0x1401
#define GL_UNSIGNED_INT 0x1405
#define GL_PIXEL_UNPACK_BUFFER 0x88EC
#define GL_STREAM_DRAW 0x88E0
#define GL_WRITE_ONLY 0x88B9
#define GL_UNPACK_ALIGNMENT 0x0CF5
#define GL_NO_ERROR 0
#define GL_DEBUG_SOURCE_APPLICATION 0x824A
 
#define GL_MAP_UNSYNCHRONIZED_BIT 0x0020
#define GL_MAP_WRITE_BIT 0x0010
#define GL_MAP_INVALIDATE_BUFFER_BIT 0x0008
#define GL_TIMESTAMP 0x8E28
#define GL_QUERY_RESULT 0x8866
#define GL_QUERY_RESULT_AVAILABLE 0x8867
#define GL_TIME_ELAPSED 0x88BF
 
/* Prototype declarations for mocks */
GLenum glGetError(void);
void glGenTextures(GLsizei n, GLuint* ids);
void glBindTexture(GLenum target, GLuint id);
void glPixelStorei(GLenum pname, GLint param);
void glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat,
                    GLsizei width, GLsizei height);
void glTexImage2D(GLenum t, GLint l, GLint i, GLsizei w, GLsizei h, GLint b,
                  GLenum f, GLenum ty, const void* p);
void glTexSubImage2D(GLenum t, GLint l, GLint x, GLint y, GLsizei w, GLsizei h,
                     GLenum f, GLenum ty, const void* p);
/* Prototype pour garantir la compilation de texture.c dans les tests unitaires
 */
#undef glCompressedTexSubImage2D
void glCompressedTexSubImage2D(unsigned int target, int level, int xoffset,
                               int yoffset, int width, int height,
                               unsigned int format, int imageSize,
                               const void* data);
void glTexParameteri(GLenum target, GLenum pname, GLint param);
void glGenerateMipmap(GLenum target);
void glDeleteTextures(GLsizei n, const GLuint* ids);
void glActiveTexture(GLenum texture);
void glGenBuffers(GLsizei n, GLuint* buffers);
void glBindBuffer(GLenum target, GLuint buffer);
void glBufferData(GLenum target, GLsizeiptr size, const void* data,
                  GLenum usage);
void glDeleteBuffers(GLsizei n, const GLuint* buffers);
void* glMapBuffer(GLenum target, GLenum access);
void* glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length,
                       GLbitfield access);
GLboolean glUnmapBuffer(GLenum target);
void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname,
                              GLint* params);
void glGenQueries(GLsizei n, GLuint* ids);
void glDeleteQueries(GLsizei n, const GLuint* ids);
void glQueryCounter(GLuint id, GLenum target);
void glGetQueryObjectiv(GLuint id, GLenum pname, GLint* params);
void glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64* params);
void glFlush(void);
void glFinish(void);
void glUseProgram(GLuint program);
void glPopDebugGroup(void);
void glPushDebugGroup(GLenum source, GLuint id, GLsizei length,
                      const GLchar* message);
void glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b,
                  GLboolean a);
void glVertexAttribFormat(GLuint attribindex, GLint size, GLenum type,
                          GLboolean normalized, GLuint relativeoffset);
void glVertexAttribBinding(GLuint attribindex, GLuint bindingindex);
void glBindVertexBuffer(GLuint bindingindex, GLuint buffer, GLintptr offset,
                        GLsizei stride);
void glVertexBindingDivisor(GLuint bindingindex, GLuint divisor);
#endif
 
#ifndef GL_COMMON_NO_GLFW
#include <GLFW/glfw3.h>  // IWYU pragma: export
#endif
#include <stddef.h>  // IWYU pragma: export
#include <stdint.h>  // IWYU pragma: export
 
enum { MAX_VERTEX_ATTRIBS_BASELINE = 16 };
 
enum { INSTANCE_ATTR_START = 2 };
 
enum { SYNC_ATTR_START = 9 };
 
enum { SCREEN_QUAD_VERTEX_COUNT = 6 };
 
enum { SIMD_ALIGNMENT = 64 };
 
enum { GL_UBO_ALIGNMENT = 32 };
 
#define GL_UBO_ALIGNED __attribute__((aligned(GL_UBO_ALIGNMENT)))
 
#define GL_ASSERT_UBO_ALIGNMENT(type)                      \
    _Static_assert(_Alignof(type) >= GL_UBO_ALIGNMENT, \
                   #type " must be >= 32-byte aligned for AVX (cglm)")
 
#define GL_DEBUG_PUSH(name) \
    glPushDebugGroup(GL_DEBUG_SOURCE_APPLICATION, 0, -1, name)
 
#define GL_DEBUG_POP() glPopDebugGroup()
 
static inline void cleanup_gl_debug_group(const char** dummy)
{
    (void)dummy;
    glPopDebugGroup();
}
 
#define GL_SCOPE_DEBUG_GROUP(name)                                  \
    glPushDebugGroup(GL_DEBUG_SOURCE_APPLICATION, 0, -1, name); \
    const char* _gl_dbg_##__LINE__                              \
        __attribute__((cleanup(cleanup_gl_debug_group)))        \
        __attribute__((unused)) = name
 
static inline void cleanup_gl_use_program(const GLuint* dummy)
{
    (void)dummy;
    glUseProgram(0);
}
 
#define GL_SCOPE_USE_PROGRAM(prog)                           \
    glUseProgram(prog);                                  \
    GLuint _gl_prog_##__LINE__                           \
        __attribute__((cleanup(cleanup_gl_use_program))) \
        __attribute__((unused)) = prog
 
static inline void cleanup_gl_texture(GLuint* tex)
{
    if (tex && *tex) {
        glDeleteTextures(1, tex);
    }
}
 
#define CLEANUP_TEXTURE __attribute__((cleanup(cleanup_gl_texture)))
 
#define GL_SAFE_DELETE_TEXTURE(tex)                  \
    do {                                         \
        if ((tex) != 0) {                    \
            glDeleteTextures(1, &(tex)); \
            (tex) = 0;                   \
        }                                    \
    } while (0)
 
#define GL_SAFE_DELETE_BUFFER(buf)                  \
    do {                                        \
        if ((buf) != 0) {                   \
            glDeleteBuffers(1, &(buf)); \
            (buf) = 0;                  \
        }                                   \
    } while (0)
 
#define GL_SAFE_DELETE_BUFFERS(count, ids)                  \
    do {                                                \
        if ((ids) != NULL) {                        \
            glDeleteBuffers(count, ids);        \
            for (int i = 0; i < (count); i++) { \
                (ids)[i] = 0;               \
            }                                   \
        }                                           \
    } while (0)
 
#define GL_SAFE_DELETE_VAO(vao)                          \
    do {                                             \
        if ((vao) != 0) {                        \
            glDeleteVertexArrays(1, &(vao)); \
            (vao) = 0;                       \
        }                                        \
    } while (0)
 
#define GL_SAFE_DELETE_VAOS(count, vaos)                    \
    do {                                                \
        if ((vaos) != NULL) {                       \
            glDeleteVertexArrays(count, vaos);  \
            for (int i = 0; i < (count); i++) { \
                (vaos)[i] = 0;              \
            }                                   \
        }                                           \
    } while (0)
 
#define GL_SAFE_DELETE_PROGRAM(prog)           \
    do {                                   \
        if ((prog) != 0) {             \
            glDeleteProgram(prog); \
            (prog) = 0;            \
        }                              \
    } while (0)
 
#define GL_SAFE_DELETE_FRAMEBUFFER(fbo)                  \
    do {                                             \
        if ((fbo) != 0) {                        \
            glDeleteFramebuffers(1, &(fbo)); \
            (fbo) = 0;                       \
        }                                        \
    } while (0)
 
#endif /* GL_COMMON_H */