From fca5b64083fb107e54f0854965aa967b32ebb307 Mon Sep 17 00:00:00 2001 From: Nick Hayashi <43279719+churchianity@users.noreply.github.com> Date: Wed, 23 Aug 2023 22:13:29 -0400 Subject: [PATCH] first --- glad.c | 1140 ++++++++++ glad.h | 2129 ++++++++++++++++++ glfw3.dll | Bin 0 -> 415744 bytes glfw3.h | 5913 +++++++++++++++++++++++++++++++++++++++++++++++++ glfw3.lib | Bin 0 -> 30306 bytes khrplatform.h | 311 +++ main.cpp | 564 +++++ 7 files changed, 10057 insertions(+) create mode 100644 glad.c create mode 100644 glad.h create mode 100644 glfw3.dll create mode 100644 glfw3.h create mode 100644 glfw3.lib create mode 100644 khrplatform.h create mode 100644 main.cpp diff --git a/glad.c b/glad.c new file mode 100644 index 0000000..a844b4f --- /dev/null +++ b/glad.c @@ -0,0 +1,1140 @@ +/* + + OpenGL loader generated by glad 0.1.36 on Fri Jan 27 01:11:54 2023. + + Language/Generator: C/C++ + Specification: gl + APIs: gl=3.3 + Profile: core + Extensions: + + Loader: True + Local files: False + Omit khrplatform: False + Reproducible: False + + Commandline: + --profile="core" --api="gl=3.3" --generator="c" --spec="gl" --extensions="" + Online: + https://glad.dav1d.de/#profile=core&language=c&specification=gl&loader=on&api=gl%3D3.3 +*/ + +#include +#include +#include +#include "glad.h" + +static void* get_proc(const char *namez); + +#if defined(_WIN32) || defined(__CYGWIN__) +#ifndef _WINDOWS_ +#undef APIENTRY +#endif +#include +static HMODULE libGL; + +typedef void* (APIENTRYP PFNWGLGETPROCADDRESSPROC_PRIVATE)(const char*); +static PFNWGLGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr; + +#ifdef _MSC_VER +#ifdef __has_include + #if __has_include() + #define HAVE_WINAPIFAMILY 1 + #endif +#elif _MSC_VER >= 1700 && !_USING_V110_SDK71_ + #define HAVE_WINAPIFAMILY 1 +#endif +#endif + +#ifdef HAVE_WINAPIFAMILY + #include + #if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + #define IS_UWP 1 + #endif +#endif + +static +int open_gl(void) { +#ifndef IS_UWP + libGL = LoadLibraryW(L"opengl32.dll"); + if(libGL != NULL) { + void (* tmp)(void); + tmp = (void(*)(void)) GetProcAddress(libGL, "wglGetProcAddress"); + gladGetProcAddressPtr = (PFNWGLGETPROCADDRESSPROC_PRIVATE) tmp; + return gladGetProcAddressPtr != NULL; + } +#endif + + return 0; +} + +static +void close_gl(void) { + if(libGL != NULL) { + FreeLibrary((HMODULE) libGL); + libGL = NULL; + } +} +#else +#include +static void* libGL; + +#if !defined(__APPLE__) && !defined(__HAIKU__) +typedef void* (APIENTRYP PFNGLXGETPROCADDRESSPROC_PRIVATE)(const char*); +static PFNGLXGETPROCADDRESSPROC_PRIVATE gladGetProcAddressPtr; +#endif + +static +int open_gl(void) { +#ifdef __APPLE__ + static const char *NAMES[] = { + "../Frameworks/OpenGL.framework/OpenGL", + "/Library/Frameworks/OpenGL.framework/OpenGL", + "/System/Library/Frameworks/OpenGL.framework/OpenGL", + "/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL" + }; +#else + static const char *NAMES[] = {"libGL.so.1", "libGL.so"}; +#endif + + unsigned int index = 0; + for(index = 0; index < (sizeof(NAMES) / sizeof(NAMES[0])); index++) { + libGL = dlopen(NAMES[index], RTLD_NOW | RTLD_GLOBAL); + + if(libGL != NULL) { +#if defined(__APPLE__) || defined(__HAIKU__) + return 1; +#else + gladGetProcAddressPtr = (PFNGLXGETPROCADDRESSPROC_PRIVATE)dlsym(libGL, + "glXGetProcAddressARB"); + return gladGetProcAddressPtr != NULL; +#endif + } + } + + return 0; +} + +static +void close_gl(void) { + if(libGL != NULL) { + dlclose(libGL); + libGL = NULL; + } +} +#endif + +static +void* get_proc(const char *namez) { + void* result = NULL; + if(libGL == NULL) return NULL; + +#if !defined(__APPLE__) && !defined(__HAIKU__) + if(gladGetProcAddressPtr != NULL) { + result = gladGetProcAddressPtr(namez); + } +#endif + if(result == NULL) { +#if defined(_WIN32) || defined(__CYGWIN__) + result = (void*)GetProcAddress((HMODULE) libGL, namez); +#else + result = dlsym(libGL, namez); +#endif + } + + return result; +} + +int gladLoadGL(void) { + int status = 0; + + if(open_gl()) { + status = gladLoadGLLoader(&get_proc); + close_gl(); + } + + return status; +} + +struct gladGLversionStruct GLVersion = { 0, 0 }; + +#if defined(GL_ES_VERSION_3_0) || defined(GL_VERSION_3_0) +#define _GLAD_IS_SOME_NEW_VERSION 1 +#endif + +static int max_loaded_major; +static int max_loaded_minor; + +static const char *exts = NULL; +static int num_exts_i = 0; +static char **exts_i = NULL; + +static int get_exts(void) { +#ifdef _GLAD_IS_SOME_NEW_VERSION + if(max_loaded_major < 3) { +#endif + exts = (const char *)glGetString(GL_EXTENSIONS); +#ifdef _GLAD_IS_SOME_NEW_VERSION + } else { + unsigned int index; + + num_exts_i = 0; + glGetIntegerv(GL_NUM_EXTENSIONS, &num_exts_i); + if (num_exts_i > 0) { + exts_i = (char **)malloc((size_t)num_exts_i * (sizeof *exts_i)); + } + + if (exts_i == NULL) { + return 0; + } + + for(index = 0; index < (unsigned)num_exts_i; index++) { + const char *gl_str_tmp = (const char*)glGetStringi(GL_EXTENSIONS, index); + size_t len = strlen(gl_str_tmp); + + char *local_str = (char*)malloc((len+1) * sizeof(char)); + if(local_str != NULL) { + memcpy(local_str, gl_str_tmp, (len+1) * sizeof(char)); + } + exts_i[index] = local_str; + } + } +#endif + return 1; +} + +static void free_exts(void) { + if (exts_i != NULL) { + int index; + for(index = 0; index < num_exts_i; index++) { + free((char *)exts_i[index]); + } + free((void *)exts_i); + exts_i = NULL; + } +} + +static int has_ext(const char *ext) { +#ifdef _GLAD_IS_SOME_NEW_VERSION + if(max_loaded_major < 3) { +#endif + const char *extensions; + const char *loc; + const char *terminator; + extensions = exts; + if(extensions == NULL || ext == NULL) { + return 0; + } + + while(1) { + loc = strstr(extensions, ext); + if(loc == NULL) { + return 0; + } + + terminator = loc + strlen(ext); + if((loc == extensions || *(loc - 1) == ' ') && + (*terminator == ' ' || *terminator == '\0')) { + return 1; + } + extensions = terminator; + } +#ifdef _GLAD_IS_SOME_NEW_VERSION + } else { + int index; + if(exts_i == NULL) return 0; + for(index = 0; index < num_exts_i; index++) { + const char *e = exts_i[index]; + + if(exts_i[index] != NULL && strcmp(e, ext) == 0) { + return 1; + } + } + } +#endif + + return 0; +} +int GLAD_GL_VERSION_1_0 = 0; +int GLAD_GL_VERSION_1_1 = 0; +int GLAD_GL_VERSION_1_2 = 0; +int GLAD_GL_VERSION_1_3 = 0; +int GLAD_GL_VERSION_1_4 = 0; +int GLAD_GL_VERSION_1_5 = 0; +int GLAD_GL_VERSION_2_0 = 0; +int GLAD_GL_VERSION_2_1 = 0; +int GLAD_GL_VERSION_3_0 = 0; +int GLAD_GL_VERSION_3_1 = 0; +int GLAD_GL_VERSION_3_2 = 0; +int GLAD_GL_VERSION_3_3 = 0; +PFNGLACTIVETEXTUREPROC glad_glActiveTexture = NULL; +PFNGLATTACHSHADERPROC glad_glAttachShader = NULL; +PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender = NULL; +PFNGLBEGINQUERYPROC glad_glBeginQuery = NULL; +PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback = NULL; +PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation = NULL; +PFNGLBINDBUFFERPROC glad_glBindBuffer = NULL; +PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase = NULL; +PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange = NULL; +PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation = NULL; +PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glad_glBindFragDataLocationIndexed = NULL; +PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer = NULL; +PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer = NULL; +PFNGLBINDSAMPLERPROC glad_glBindSampler = NULL; +PFNGLBINDTEXTUREPROC glad_glBindTexture = NULL; +PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray = NULL; +PFNGLBLENDCOLORPROC glad_glBlendColor = NULL; +PFNGLBLENDEQUATIONPROC glad_glBlendEquation = NULL; +PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate = NULL; +PFNGLBLENDFUNCPROC glad_glBlendFunc = NULL; +PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate = NULL; +PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer = NULL; +PFNGLBUFFERDATAPROC glad_glBufferData = NULL; +PFNGLBUFFERSUBDATAPROC glad_glBufferSubData = NULL; +PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus = NULL; +PFNGLCLAMPCOLORPROC glad_glClampColor = NULL; +PFNGLCLEARPROC glad_glClear = NULL; +PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi = NULL; +PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv = NULL; +PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv = NULL; +PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv = NULL; +PFNGLCLEARCOLORPROC glad_glClearColor = NULL; +PFNGLCLEARDEPTHPROC glad_glClearDepth = NULL; +PFNGLCLEARSTENCILPROC glad_glClearStencil = NULL; +PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync = NULL; +PFNGLCOLORMASKPROC glad_glColorMask = NULL; +PFNGLCOLORMASKIPROC glad_glColorMaski = NULL; +PFNGLCOLORP3UIPROC glad_glColorP3ui = NULL; +PFNGLCOLORP3UIVPROC glad_glColorP3uiv = NULL; +PFNGLCOLORP4UIPROC glad_glColorP4ui = NULL; +PFNGLCOLORP4UIVPROC glad_glColorP4uiv = NULL; +PFNGLCOMPILESHADERPROC glad_glCompileShader = NULL; +PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D = NULL; +PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D = NULL; +PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D = NULL; +PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData = NULL; +PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D = NULL; +PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D = NULL; +PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D = NULL; +PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D = NULL; +PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D = NULL; +PFNGLCREATEPROGRAMPROC glad_glCreateProgram = NULL; +PFNGLCREATESHADERPROC glad_glCreateShader = NULL; +PFNGLCULLFACEPROC glad_glCullFace = NULL; +PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers = NULL; +PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers = NULL; +PFNGLDELETEPROGRAMPROC glad_glDeleteProgram = NULL; +PFNGLDELETEQUERIESPROC glad_glDeleteQueries = NULL; +PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers = NULL; +PFNGLDELETESAMPLERSPROC glad_glDeleteSamplers = NULL; +PFNGLDELETESHADERPROC glad_glDeleteShader = NULL; +PFNGLDELETESYNCPROC glad_glDeleteSync = NULL; +PFNGLDELETETEXTURESPROC glad_glDeleteTextures = NULL; +PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays = NULL; +PFNGLDEPTHFUNCPROC glad_glDepthFunc = NULL; +PFNGLDEPTHMASKPROC glad_glDepthMask = NULL; +PFNGLDEPTHRANGEPROC glad_glDepthRange = NULL; +PFNGLDETACHSHADERPROC glad_glDetachShader = NULL; +PFNGLDISABLEPROC glad_glDisable = NULL; +PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray = NULL; +PFNGLDISABLEIPROC glad_glDisablei = NULL; +PFNGLDRAWARRAYSPROC glad_glDrawArrays = NULL; +PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced = NULL; +PFNGLDRAWBUFFERPROC glad_glDrawBuffer = NULL; +PFNGLDRAWBUFFERSPROC glad_glDrawBuffers = NULL; +PFNGLDRAWELEMENTSPROC glad_glDrawElements = NULL; +PFNGLDRAWELEMENTSBASEVERTEXPROC glad_glDrawElementsBaseVertex = NULL; +PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced = NULL; +PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex = NULL; +PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements = NULL; +PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex = NULL; +PFNGLENABLEPROC glad_glEnable = NULL; +PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray = NULL; +PFNGLENABLEIPROC glad_glEnablei = NULL; +PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender = NULL; +PFNGLENDQUERYPROC glad_glEndQuery = NULL; +PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback = NULL; +PFNGLFENCESYNCPROC glad_glFenceSync = NULL; +PFNGLFINISHPROC glad_glFinish = NULL; +PFNGLFLUSHPROC glad_glFlush = NULL; +PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange = NULL; +PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer = NULL; +PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture = NULL; +PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D = NULL; +PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D = NULL; +PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D = NULL; +PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer = NULL; +PFNGLFRONTFACEPROC glad_glFrontFace = NULL; +PFNGLGENBUFFERSPROC glad_glGenBuffers = NULL; +PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers = NULL; +PFNGLGENQUERIESPROC glad_glGenQueries = NULL; +PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers = NULL; +PFNGLGENSAMPLERSPROC glad_glGenSamplers = NULL; +PFNGLGENTEXTURESPROC glad_glGenTextures = NULL; +PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays = NULL; +PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap = NULL; +PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib = NULL; +PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform = NULL; +PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName = NULL; +PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv = NULL; +PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName = NULL; +PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv = NULL; +PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders = NULL; +PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation = NULL; +PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v = NULL; +PFNGLGETBOOLEANVPROC glad_glGetBooleanv = NULL; +PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v = NULL; +PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv = NULL; +PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv = NULL; +PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData = NULL; +PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage = NULL; +PFNGLGETDOUBLEVPROC glad_glGetDoublev = NULL; +PFNGLGETERRORPROC glad_glGetError = NULL; +PFNGLGETFLOATVPROC glad_glGetFloatv = NULL; +PFNGLGETFRAGDATAINDEXPROC glad_glGetFragDataIndex = NULL; +PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation = NULL; +PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv = NULL; +PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v = NULL; +PFNGLGETINTEGER64VPROC glad_glGetInteger64v = NULL; +PFNGLGETINTEGERI_VPROC glad_glGetIntegeri_v = NULL; +PFNGLGETINTEGERVPROC glad_glGetIntegerv = NULL; +PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv = NULL; +PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog = NULL; +PFNGLGETPROGRAMIVPROC glad_glGetProgramiv = NULL; +PFNGLGETQUERYOBJECTI64VPROC glad_glGetQueryObjecti64v = NULL; +PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv = NULL; +PFNGLGETQUERYOBJECTUI64VPROC glad_glGetQueryObjectui64v = NULL; +PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv = NULL; +PFNGLGETQUERYIVPROC glad_glGetQueryiv = NULL; +PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv = NULL; +PFNGLGETSAMPLERPARAMETERIIVPROC glad_glGetSamplerParameterIiv = NULL; +PFNGLGETSAMPLERPARAMETERIUIVPROC glad_glGetSamplerParameterIuiv = NULL; +PFNGLGETSAMPLERPARAMETERFVPROC glad_glGetSamplerParameterfv = NULL; +PFNGLGETSAMPLERPARAMETERIVPROC glad_glGetSamplerParameteriv = NULL; +PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog = NULL; +PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource = NULL; +PFNGLGETSHADERIVPROC glad_glGetShaderiv = NULL; +PFNGLGETSTRINGPROC glad_glGetString = NULL; +PFNGLGETSTRINGIPROC glad_glGetStringi = NULL; +PFNGLGETSYNCIVPROC glad_glGetSynciv = NULL; +PFNGLGETTEXIMAGEPROC glad_glGetTexImage = NULL; +PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv = NULL; +PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv = NULL; +PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv = NULL; +PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv = NULL; +PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv = NULL; +PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv = NULL; +PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying = NULL; +PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex = NULL; +PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices = NULL; +PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation = NULL; +PFNGLGETUNIFORMFVPROC glad_glGetUniformfv = NULL; +PFNGLGETUNIFORMIVPROC glad_glGetUniformiv = NULL; +PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv = NULL; +PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv = NULL; +PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv = NULL; +PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv = NULL; +PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv = NULL; +PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv = NULL; +PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv = NULL; +PFNGLHINTPROC glad_glHint = NULL; +PFNGLISBUFFERPROC glad_glIsBuffer = NULL; +PFNGLISENABLEDPROC glad_glIsEnabled = NULL; +PFNGLISENABLEDIPROC glad_glIsEnabledi = NULL; +PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer = NULL; +PFNGLISPROGRAMPROC glad_glIsProgram = NULL; +PFNGLISQUERYPROC glad_glIsQuery = NULL; +PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer = NULL; +PFNGLISSAMPLERPROC glad_glIsSampler = NULL; +PFNGLISSHADERPROC glad_glIsShader = NULL; +PFNGLISSYNCPROC glad_glIsSync = NULL; +PFNGLISTEXTUREPROC glad_glIsTexture = NULL; +PFNGLISVERTEXARRAYPROC glad_glIsVertexArray = NULL; +PFNGLLINEWIDTHPROC glad_glLineWidth = NULL; +PFNGLLINKPROGRAMPROC glad_glLinkProgram = NULL; +PFNGLLOGICOPPROC glad_glLogicOp = NULL; +PFNGLMAPBUFFERPROC glad_glMapBuffer = NULL; +PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange = NULL; +PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays = NULL; +PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements = NULL; +PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex = NULL; +PFNGLMULTITEXCOORDP1UIPROC glad_glMultiTexCoordP1ui = NULL; +PFNGLMULTITEXCOORDP1UIVPROC glad_glMultiTexCoordP1uiv = NULL; +PFNGLMULTITEXCOORDP2UIPROC glad_glMultiTexCoordP2ui = NULL; +PFNGLMULTITEXCOORDP2UIVPROC glad_glMultiTexCoordP2uiv = NULL; +PFNGLMULTITEXCOORDP3UIPROC glad_glMultiTexCoordP3ui = NULL; +PFNGLMULTITEXCOORDP3UIVPROC glad_glMultiTexCoordP3uiv = NULL; +PFNGLMULTITEXCOORDP4UIPROC glad_glMultiTexCoordP4ui = NULL; +PFNGLMULTITEXCOORDP4UIVPROC glad_glMultiTexCoordP4uiv = NULL; +PFNGLNORMALP3UIPROC glad_glNormalP3ui = NULL; +PFNGLNORMALP3UIVPROC glad_glNormalP3uiv = NULL; +PFNGLPIXELSTOREFPROC glad_glPixelStoref = NULL; +PFNGLPIXELSTOREIPROC glad_glPixelStorei = NULL; +PFNGLPOINTPARAMETERFPROC glad_glPointParameterf = NULL; +PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv = NULL; +PFNGLPOINTPARAMETERIPROC glad_glPointParameteri = NULL; +PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv = NULL; +PFNGLPOINTSIZEPROC glad_glPointSize = NULL; +PFNGLPOLYGONMODEPROC glad_glPolygonMode = NULL; +PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset = NULL; +PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex = NULL; +PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex = NULL; +PFNGLQUERYCOUNTERPROC glad_glQueryCounter = NULL; +PFNGLREADBUFFERPROC glad_glReadBuffer = NULL; +PFNGLREADPIXELSPROC glad_glReadPixels = NULL; +PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage = NULL; +PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample = NULL; +PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage = NULL; +PFNGLSAMPLEMASKIPROC glad_glSampleMaski = NULL; +PFNGLSAMPLERPARAMETERIIVPROC glad_glSamplerParameterIiv = NULL; +PFNGLSAMPLERPARAMETERIUIVPROC glad_glSamplerParameterIuiv = NULL; +PFNGLSAMPLERPARAMETERFPROC glad_glSamplerParameterf = NULL; +PFNGLSAMPLERPARAMETERFVPROC glad_glSamplerParameterfv = NULL; +PFNGLSAMPLERPARAMETERIPROC glad_glSamplerParameteri = NULL; +PFNGLSAMPLERPARAMETERIVPROC glad_glSamplerParameteriv = NULL; +PFNGLSCISSORPROC glad_glScissor = NULL; +PFNGLSECONDARYCOLORP3UIPROC glad_glSecondaryColorP3ui = NULL; +PFNGLSECONDARYCOLORP3UIVPROC glad_glSecondaryColorP3uiv = NULL; +PFNGLSHADERSOURCEPROC glad_glShaderSource = NULL; +PFNGLSTENCILFUNCPROC glad_glStencilFunc = NULL; +PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate = NULL; +PFNGLSTENCILMASKPROC glad_glStencilMask = NULL; +PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate = NULL; +PFNGLSTENCILOPPROC glad_glStencilOp = NULL; +PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate = NULL; +PFNGLTEXBUFFERPROC glad_glTexBuffer = NULL; +PFNGLTEXCOORDP1UIPROC glad_glTexCoordP1ui = NULL; +PFNGLTEXCOORDP1UIVPROC glad_glTexCoordP1uiv = NULL; +PFNGLTEXCOORDP2UIPROC glad_glTexCoordP2ui = NULL; +PFNGLTEXCOORDP2UIVPROC glad_glTexCoordP2uiv = NULL; +PFNGLTEXCOORDP3UIPROC glad_glTexCoordP3ui = NULL; +PFNGLTEXCOORDP3UIVPROC glad_glTexCoordP3uiv = NULL; +PFNGLTEXCOORDP4UIPROC glad_glTexCoordP4ui = NULL; +PFNGLTEXCOORDP4UIVPROC glad_glTexCoordP4uiv = NULL; +PFNGLTEXIMAGE1DPROC glad_glTexImage1D = NULL; +PFNGLTEXIMAGE2DPROC glad_glTexImage2D = NULL; +PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample = NULL; +PFNGLTEXIMAGE3DPROC glad_glTexImage3D = NULL; +PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample = NULL; +PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv = NULL; +PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv = NULL; +PFNGLTEXPARAMETERFPROC glad_glTexParameterf = NULL; +PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv = NULL; +PFNGLTEXPARAMETERIPROC glad_glTexParameteri = NULL; +PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv = NULL; +PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D = NULL; +PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D = NULL; +PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D = NULL; +PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings = NULL; +PFNGLUNIFORM1FPROC glad_glUniform1f = NULL; +PFNGLUNIFORM1FVPROC glad_glUniform1fv = NULL; +PFNGLUNIFORM1IPROC glad_glUniform1i = NULL; +PFNGLUNIFORM1IVPROC glad_glUniform1iv = NULL; +PFNGLUNIFORM1UIPROC glad_glUniform1ui = NULL; +PFNGLUNIFORM1UIVPROC glad_glUniform1uiv = NULL; +PFNGLUNIFORM2FPROC glad_glUniform2f = NULL; +PFNGLUNIFORM2FVPROC glad_glUniform2fv = NULL; +PFNGLUNIFORM2IPROC glad_glUniform2i = NULL; +PFNGLUNIFORM2IVPROC glad_glUniform2iv = NULL; +PFNGLUNIFORM2UIPROC glad_glUniform2ui = NULL; +PFNGLUNIFORM2UIVPROC glad_glUniform2uiv = NULL; +PFNGLUNIFORM3FPROC glad_glUniform3f = NULL; +PFNGLUNIFORM3FVPROC glad_glUniform3fv = NULL; +PFNGLUNIFORM3IPROC glad_glUniform3i = NULL; +PFNGLUNIFORM3IVPROC glad_glUniform3iv = NULL; +PFNGLUNIFORM3UIPROC glad_glUniform3ui = NULL; +PFNGLUNIFORM3UIVPROC glad_glUniform3uiv = NULL; +PFNGLUNIFORM4FPROC glad_glUniform4f = NULL; +PFNGLUNIFORM4FVPROC glad_glUniform4fv = NULL; +PFNGLUNIFORM4IPROC glad_glUniform4i = NULL; +PFNGLUNIFORM4IVPROC glad_glUniform4iv = NULL; +PFNGLUNIFORM4UIPROC glad_glUniform4ui = NULL; +PFNGLUNIFORM4UIVPROC glad_glUniform4uiv = NULL; +PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding = NULL; +PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv = NULL; +PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv = NULL; +PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv = NULL; +PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv = NULL; +PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv = NULL; +PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv = NULL; +PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv = NULL; +PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv = NULL; +PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv = NULL; +PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer = NULL; +PFNGLUSEPROGRAMPROC glad_glUseProgram = NULL; +PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram = NULL; +PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d = NULL; +PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv = NULL; +PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f = NULL; +PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv = NULL; +PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s = NULL; +PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv = NULL; +PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d = NULL; +PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv = NULL; +PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f = NULL; +PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv = NULL; +PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s = NULL; +PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv = NULL; +PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d = NULL; +PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv = NULL; +PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f = NULL; +PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv = NULL; +PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s = NULL; +PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv = NULL; +PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv = NULL; +PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv = NULL; +PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv = NULL; +PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub = NULL; +PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv = NULL; +PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv = NULL; +PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv = NULL; +PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv = NULL; +PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d = NULL; +PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv = NULL; +PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f = NULL; +PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv = NULL; +PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv = NULL; +PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s = NULL; +PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv = NULL; +PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv = NULL; +PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv = NULL; +PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv = NULL; +PFNGLVERTEXATTRIBDIVISORPROC glad_glVertexAttribDivisor = NULL; +PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i = NULL; +PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv = NULL; +PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui = NULL; +PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv = NULL; +PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i = NULL; +PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv = NULL; +PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui = NULL; +PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv = NULL; +PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i = NULL; +PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv = NULL; +PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui = NULL; +PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv = NULL; +PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv = NULL; +PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i = NULL; +PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv = NULL; +PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv = NULL; +PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv = NULL; +PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui = NULL; +PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv = NULL; +PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv = NULL; +PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer = NULL; +PFNGLVERTEXATTRIBP1UIPROC glad_glVertexAttribP1ui = NULL; +PFNGLVERTEXATTRIBP1UIVPROC glad_glVertexAttribP1uiv = NULL; +PFNGLVERTEXATTRIBP2UIPROC glad_glVertexAttribP2ui = NULL; +PFNGLVERTEXATTRIBP2UIVPROC glad_glVertexAttribP2uiv = NULL; +PFNGLVERTEXATTRIBP3UIPROC glad_glVertexAttribP3ui = NULL; +PFNGLVERTEXATTRIBP3UIVPROC glad_glVertexAttribP3uiv = NULL; +PFNGLVERTEXATTRIBP4UIPROC glad_glVertexAttribP4ui = NULL; +PFNGLVERTEXATTRIBP4UIVPROC glad_glVertexAttribP4uiv = NULL; +PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer = NULL; +PFNGLVERTEXP2UIPROC glad_glVertexP2ui = NULL; +PFNGLVERTEXP2UIVPROC glad_glVertexP2uiv = NULL; +PFNGLVERTEXP3UIPROC glad_glVertexP3ui = NULL; +PFNGLVERTEXP3UIVPROC glad_glVertexP3uiv = NULL; +PFNGLVERTEXP4UIPROC glad_glVertexP4ui = NULL; +PFNGLVERTEXP4UIVPROC glad_glVertexP4uiv = NULL; +PFNGLVIEWPORTPROC glad_glViewport = NULL; +PFNGLWAITSYNCPROC glad_glWaitSync = NULL; +static void load_GL_VERSION_1_0(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_0) return; + glad_glCullFace = (PFNGLCULLFACEPROC)load("glCullFace"); + glad_glFrontFace = (PFNGLFRONTFACEPROC)load("glFrontFace"); + glad_glHint = (PFNGLHINTPROC)load("glHint"); + glad_glLineWidth = (PFNGLLINEWIDTHPROC)load("glLineWidth"); + glad_glPointSize = (PFNGLPOINTSIZEPROC)load("glPointSize"); + glad_glPolygonMode = (PFNGLPOLYGONMODEPROC)load("glPolygonMode"); + glad_glScissor = (PFNGLSCISSORPROC)load("glScissor"); + glad_glTexParameterf = (PFNGLTEXPARAMETERFPROC)load("glTexParameterf"); + glad_glTexParameterfv = (PFNGLTEXPARAMETERFVPROC)load("glTexParameterfv"); + glad_glTexParameteri = (PFNGLTEXPARAMETERIPROC)load("glTexParameteri"); + glad_glTexParameteriv = (PFNGLTEXPARAMETERIVPROC)load("glTexParameteriv"); + glad_glTexImage1D = (PFNGLTEXIMAGE1DPROC)load("glTexImage1D"); + glad_glTexImage2D = (PFNGLTEXIMAGE2DPROC)load("glTexImage2D"); + glad_glDrawBuffer = (PFNGLDRAWBUFFERPROC)load("glDrawBuffer"); + glad_glClear = (PFNGLCLEARPROC)load("glClear"); + glad_glClearColor = (PFNGLCLEARCOLORPROC)load("glClearColor"); + glad_glClearStencil = (PFNGLCLEARSTENCILPROC)load("glClearStencil"); + glad_glClearDepth = (PFNGLCLEARDEPTHPROC)load("glClearDepth"); + glad_glStencilMask = (PFNGLSTENCILMASKPROC)load("glStencilMask"); + glad_glColorMask = (PFNGLCOLORMASKPROC)load("glColorMask"); + glad_glDepthMask = (PFNGLDEPTHMASKPROC)load("glDepthMask"); + glad_glDisable = (PFNGLDISABLEPROC)load("glDisable"); + glad_glEnable = (PFNGLENABLEPROC)load("glEnable"); + glad_glFinish = (PFNGLFINISHPROC)load("glFinish"); + glad_glFlush = (PFNGLFLUSHPROC)load("glFlush"); + glad_glBlendFunc = (PFNGLBLENDFUNCPROC)load("glBlendFunc"); + glad_glLogicOp = (PFNGLLOGICOPPROC)load("glLogicOp"); + glad_glStencilFunc = (PFNGLSTENCILFUNCPROC)load("glStencilFunc"); + glad_glStencilOp = (PFNGLSTENCILOPPROC)load("glStencilOp"); + glad_glDepthFunc = (PFNGLDEPTHFUNCPROC)load("glDepthFunc"); + glad_glPixelStoref = (PFNGLPIXELSTOREFPROC)load("glPixelStoref"); + glad_glPixelStorei = (PFNGLPIXELSTOREIPROC)load("glPixelStorei"); + glad_glReadBuffer = (PFNGLREADBUFFERPROC)load("glReadBuffer"); + glad_glReadPixels = (PFNGLREADPIXELSPROC)load("glReadPixels"); + glad_glGetBooleanv = (PFNGLGETBOOLEANVPROC)load("glGetBooleanv"); + glad_glGetDoublev = (PFNGLGETDOUBLEVPROC)load("glGetDoublev"); + glad_glGetError = (PFNGLGETERRORPROC)load("glGetError"); + glad_glGetFloatv = (PFNGLGETFLOATVPROC)load("glGetFloatv"); + glad_glGetIntegerv = (PFNGLGETINTEGERVPROC)load("glGetIntegerv"); + glad_glGetString = (PFNGLGETSTRINGPROC)load("glGetString"); + glad_glGetTexImage = (PFNGLGETTEXIMAGEPROC)load("glGetTexImage"); + glad_glGetTexParameterfv = (PFNGLGETTEXPARAMETERFVPROC)load("glGetTexParameterfv"); + glad_glGetTexParameteriv = (PFNGLGETTEXPARAMETERIVPROC)load("glGetTexParameteriv"); + glad_glGetTexLevelParameterfv = (PFNGLGETTEXLEVELPARAMETERFVPROC)load("glGetTexLevelParameterfv"); + glad_glGetTexLevelParameteriv = (PFNGLGETTEXLEVELPARAMETERIVPROC)load("glGetTexLevelParameteriv"); + glad_glIsEnabled = (PFNGLISENABLEDPROC)load("glIsEnabled"); + glad_glDepthRange = (PFNGLDEPTHRANGEPROC)load("glDepthRange"); + glad_glViewport = (PFNGLVIEWPORTPROC)load("glViewport"); +} +static void load_GL_VERSION_1_1(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_1) return; + glad_glDrawArrays = (PFNGLDRAWARRAYSPROC)load("glDrawArrays"); + glad_glDrawElements = (PFNGLDRAWELEMENTSPROC)load("glDrawElements"); + glad_glPolygonOffset = (PFNGLPOLYGONOFFSETPROC)load("glPolygonOffset"); + glad_glCopyTexImage1D = (PFNGLCOPYTEXIMAGE1DPROC)load("glCopyTexImage1D"); + glad_glCopyTexImage2D = (PFNGLCOPYTEXIMAGE2DPROC)load("glCopyTexImage2D"); + glad_glCopyTexSubImage1D = (PFNGLCOPYTEXSUBIMAGE1DPROC)load("glCopyTexSubImage1D"); + glad_glCopyTexSubImage2D = (PFNGLCOPYTEXSUBIMAGE2DPROC)load("glCopyTexSubImage2D"); + glad_glTexSubImage1D = (PFNGLTEXSUBIMAGE1DPROC)load("glTexSubImage1D"); + glad_glTexSubImage2D = (PFNGLTEXSUBIMAGE2DPROC)load("glTexSubImage2D"); + glad_glBindTexture = (PFNGLBINDTEXTUREPROC)load("glBindTexture"); + glad_glDeleteTextures = (PFNGLDELETETEXTURESPROC)load("glDeleteTextures"); + glad_glGenTextures = (PFNGLGENTEXTURESPROC)load("glGenTextures"); + glad_glIsTexture = (PFNGLISTEXTUREPROC)load("glIsTexture"); +} +static void load_GL_VERSION_1_2(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_2) return; + glad_glDrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC)load("glDrawRangeElements"); + glad_glTexImage3D = (PFNGLTEXIMAGE3DPROC)load("glTexImage3D"); + glad_glTexSubImage3D = (PFNGLTEXSUBIMAGE3DPROC)load("glTexSubImage3D"); + glad_glCopyTexSubImage3D = (PFNGLCOPYTEXSUBIMAGE3DPROC)load("glCopyTexSubImage3D"); +} +static void load_GL_VERSION_1_3(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_3) return; + glad_glActiveTexture = (PFNGLACTIVETEXTUREPROC)load("glActiveTexture"); + glad_glSampleCoverage = (PFNGLSAMPLECOVERAGEPROC)load("glSampleCoverage"); + glad_glCompressedTexImage3D = (PFNGLCOMPRESSEDTEXIMAGE3DPROC)load("glCompressedTexImage3D"); + glad_glCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC)load("glCompressedTexImage2D"); + glad_glCompressedTexImage1D = (PFNGLCOMPRESSEDTEXIMAGE1DPROC)load("glCompressedTexImage1D"); + glad_glCompressedTexSubImage3D = (PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)load("glCompressedTexSubImage3D"); + glad_glCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)load("glCompressedTexSubImage2D"); + glad_glCompressedTexSubImage1D = (PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)load("glCompressedTexSubImage1D"); + glad_glGetCompressedTexImage = (PFNGLGETCOMPRESSEDTEXIMAGEPROC)load("glGetCompressedTexImage"); +} +static void load_GL_VERSION_1_4(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_4) return; + glad_glBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC)load("glBlendFuncSeparate"); + glad_glMultiDrawArrays = (PFNGLMULTIDRAWARRAYSPROC)load("glMultiDrawArrays"); + glad_glMultiDrawElements = (PFNGLMULTIDRAWELEMENTSPROC)load("glMultiDrawElements"); + glad_glPointParameterf = (PFNGLPOINTPARAMETERFPROC)load("glPointParameterf"); + glad_glPointParameterfv = (PFNGLPOINTPARAMETERFVPROC)load("glPointParameterfv"); + glad_glPointParameteri = (PFNGLPOINTPARAMETERIPROC)load("glPointParameteri"); + glad_glPointParameteriv = (PFNGLPOINTPARAMETERIVPROC)load("glPointParameteriv"); + glad_glBlendColor = (PFNGLBLENDCOLORPROC)load("glBlendColor"); + glad_glBlendEquation = (PFNGLBLENDEQUATIONPROC)load("glBlendEquation"); +} +static void load_GL_VERSION_1_5(GLADloadproc load) { + if(!GLAD_GL_VERSION_1_5) return; + glad_glGenQueries = (PFNGLGENQUERIESPROC)load("glGenQueries"); + glad_glDeleteQueries = (PFNGLDELETEQUERIESPROC)load("glDeleteQueries"); + glad_glIsQuery = (PFNGLISQUERYPROC)load("glIsQuery"); + glad_glBeginQuery = (PFNGLBEGINQUERYPROC)load("glBeginQuery"); + glad_glEndQuery = (PFNGLENDQUERYPROC)load("glEndQuery"); + glad_glGetQueryiv = (PFNGLGETQUERYIVPROC)load("glGetQueryiv"); + glad_glGetQueryObjectiv = (PFNGLGETQUERYOBJECTIVPROC)load("glGetQueryObjectiv"); + glad_glGetQueryObjectuiv = (PFNGLGETQUERYOBJECTUIVPROC)load("glGetQueryObjectuiv"); + glad_glBindBuffer = (PFNGLBINDBUFFERPROC)load("glBindBuffer"); + glad_glDeleteBuffers = (PFNGLDELETEBUFFERSPROC)load("glDeleteBuffers"); + glad_glGenBuffers = (PFNGLGENBUFFERSPROC)load("glGenBuffers"); + glad_glIsBuffer = (PFNGLISBUFFERPROC)load("glIsBuffer"); + glad_glBufferData = (PFNGLBUFFERDATAPROC)load("glBufferData"); + glad_glBufferSubData = (PFNGLBUFFERSUBDATAPROC)load("glBufferSubData"); + glad_glGetBufferSubData = (PFNGLGETBUFFERSUBDATAPROC)load("glGetBufferSubData"); + glad_glMapBuffer = (PFNGLMAPBUFFERPROC)load("glMapBuffer"); + glad_glUnmapBuffer = (PFNGLUNMAPBUFFERPROC)load("glUnmapBuffer"); + glad_glGetBufferParameteriv = (PFNGLGETBUFFERPARAMETERIVPROC)load("glGetBufferParameteriv"); + glad_glGetBufferPointerv = (PFNGLGETBUFFERPOINTERVPROC)load("glGetBufferPointerv"); +} +static void load_GL_VERSION_2_0(GLADloadproc load) { + if(!GLAD_GL_VERSION_2_0) return; + glad_glBlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC)load("glBlendEquationSeparate"); + glad_glDrawBuffers = (PFNGLDRAWBUFFERSPROC)load("glDrawBuffers"); + glad_glStencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC)load("glStencilOpSeparate"); + glad_glStencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC)load("glStencilFuncSeparate"); + glad_glStencilMaskSeparate = (PFNGLSTENCILMASKSEPARATEPROC)load("glStencilMaskSeparate"); + glad_glAttachShader = (PFNGLATTACHSHADERPROC)load("glAttachShader"); + glad_glBindAttribLocation = (PFNGLBINDATTRIBLOCATIONPROC)load("glBindAttribLocation"); + glad_glCompileShader = (PFNGLCOMPILESHADERPROC)load("glCompileShader"); + glad_glCreateProgram = (PFNGLCREATEPROGRAMPROC)load("glCreateProgram"); + glad_glCreateShader = (PFNGLCREATESHADERPROC)load("glCreateShader"); + glad_glDeleteProgram = (PFNGLDELETEPROGRAMPROC)load("glDeleteProgram"); + glad_glDeleteShader = (PFNGLDELETESHADERPROC)load("glDeleteShader"); + glad_glDetachShader = (PFNGLDETACHSHADERPROC)load("glDetachShader"); + glad_glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC)load("glDisableVertexAttribArray"); + glad_glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC)load("glEnableVertexAttribArray"); + glad_glGetActiveAttrib = (PFNGLGETACTIVEATTRIBPROC)load("glGetActiveAttrib"); + glad_glGetActiveUniform = (PFNGLGETACTIVEUNIFORMPROC)load("glGetActiveUniform"); + glad_glGetAttachedShaders = (PFNGLGETATTACHEDSHADERSPROC)load("glGetAttachedShaders"); + glad_glGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC)load("glGetAttribLocation"); + glad_glGetProgramiv = (PFNGLGETPROGRAMIVPROC)load("glGetProgramiv"); + glad_glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)load("glGetProgramInfoLog"); + glad_glGetShaderiv = (PFNGLGETSHADERIVPROC)load("glGetShaderiv"); + glad_glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)load("glGetShaderInfoLog"); + glad_glGetShaderSource = (PFNGLGETSHADERSOURCEPROC)load("glGetShaderSource"); + glad_glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)load("glGetUniformLocation"); + glad_glGetUniformfv = (PFNGLGETUNIFORMFVPROC)load("glGetUniformfv"); + glad_glGetUniformiv = (PFNGLGETUNIFORMIVPROC)load("glGetUniformiv"); + glad_glGetVertexAttribdv = (PFNGLGETVERTEXATTRIBDVPROC)load("glGetVertexAttribdv"); + glad_glGetVertexAttribfv = (PFNGLGETVERTEXATTRIBFVPROC)load("glGetVertexAttribfv"); + glad_glGetVertexAttribiv = (PFNGLGETVERTEXATTRIBIVPROC)load("glGetVertexAttribiv"); + glad_glGetVertexAttribPointerv = (PFNGLGETVERTEXATTRIBPOINTERVPROC)load("glGetVertexAttribPointerv"); + glad_glIsProgram = (PFNGLISPROGRAMPROC)load("glIsProgram"); + glad_glIsShader = (PFNGLISSHADERPROC)load("glIsShader"); + glad_glLinkProgram = (PFNGLLINKPROGRAMPROC)load("glLinkProgram"); + glad_glShaderSource = (PFNGLSHADERSOURCEPROC)load("glShaderSource"); + glad_glUseProgram = (PFNGLUSEPROGRAMPROC)load("glUseProgram"); + glad_glUniform1f = (PFNGLUNIFORM1FPROC)load("glUniform1f"); + glad_glUniform2f = (PFNGLUNIFORM2FPROC)load("glUniform2f"); + glad_glUniform3f = (PFNGLUNIFORM3FPROC)load("glUniform3f"); + glad_glUniform4f = (PFNGLUNIFORM4FPROC)load("glUniform4f"); + glad_glUniform1i = (PFNGLUNIFORM1IPROC)load("glUniform1i"); + glad_glUniform2i = (PFNGLUNIFORM2IPROC)load("glUniform2i"); + glad_glUniform3i = (PFNGLUNIFORM3IPROC)load("glUniform3i"); + glad_glUniform4i = (PFNGLUNIFORM4IPROC)load("glUniform4i"); + glad_glUniform1fv = (PFNGLUNIFORM1FVPROC)load("glUniform1fv"); + glad_glUniform2fv = (PFNGLUNIFORM2FVPROC)load("glUniform2fv"); + glad_glUniform3fv = (PFNGLUNIFORM3FVPROC)load("glUniform3fv"); + glad_glUniform4fv = (PFNGLUNIFORM4FVPROC)load("glUniform4fv"); + glad_glUniform1iv = (PFNGLUNIFORM1IVPROC)load("glUniform1iv"); + glad_glUniform2iv = (PFNGLUNIFORM2IVPROC)load("glUniform2iv"); + glad_glUniform3iv = (PFNGLUNIFORM3IVPROC)load("glUniform3iv"); + glad_glUniform4iv = (PFNGLUNIFORM4IVPROC)load("glUniform4iv"); + glad_glUniformMatrix2fv = (PFNGLUNIFORMMATRIX2FVPROC)load("glUniformMatrix2fv"); + glad_glUniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC)load("glUniformMatrix3fv"); + glad_glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC)load("glUniformMatrix4fv"); + glad_glValidateProgram = (PFNGLVALIDATEPROGRAMPROC)load("glValidateProgram"); + glad_glVertexAttrib1d = (PFNGLVERTEXATTRIB1DPROC)load("glVertexAttrib1d"); + glad_glVertexAttrib1dv = (PFNGLVERTEXATTRIB1DVPROC)load("glVertexAttrib1dv"); + glad_glVertexAttrib1f = (PFNGLVERTEXATTRIB1FPROC)load("glVertexAttrib1f"); + glad_glVertexAttrib1fv = (PFNGLVERTEXATTRIB1FVPROC)load("glVertexAttrib1fv"); + glad_glVertexAttrib1s = (PFNGLVERTEXATTRIB1SPROC)load("glVertexAttrib1s"); + glad_glVertexAttrib1sv = (PFNGLVERTEXATTRIB1SVPROC)load("glVertexAttrib1sv"); + glad_glVertexAttrib2d = (PFNGLVERTEXATTRIB2DPROC)load("glVertexAttrib2d"); + glad_glVertexAttrib2dv = (PFNGLVERTEXATTRIB2DVPROC)load("glVertexAttrib2dv"); + glad_glVertexAttrib2f = (PFNGLVERTEXATTRIB2FPROC)load("glVertexAttrib2f"); + glad_glVertexAttrib2fv = (PFNGLVERTEXATTRIB2FVPROC)load("glVertexAttrib2fv"); + glad_glVertexAttrib2s = (PFNGLVERTEXATTRIB2SPROC)load("glVertexAttrib2s"); + glad_glVertexAttrib2sv = (PFNGLVERTEXATTRIB2SVPROC)load("glVertexAttrib2sv"); + glad_glVertexAttrib3d = (PFNGLVERTEXATTRIB3DPROC)load("glVertexAttrib3d"); + glad_glVertexAttrib3dv = (PFNGLVERTEXATTRIB3DVPROC)load("glVertexAttrib3dv"); + glad_glVertexAttrib3f = (PFNGLVERTEXATTRIB3FPROC)load("glVertexAttrib3f"); + glad_glVertexAttrib3fv = (PFNGLVERTEXATTRIB3FVPROC)load("glVertexAttrib3fv"); + glad_glVertexAttrib3s = (PFNGLVERTEXATTRIB3SPROC)load("glVertexAttrib3s"); + glad_glVertexAttrib3sv = (PFNGLVERTEXATTRIB3SVPROC)load("glVertexAttrib3sv"); + glad_glVertexAttrib4Nbv = (PFNGLVERTEXATTRIB4NBVPROC)load("glVertexAttrib4Nbv"); + glad_glVertexAttrib4Niv = (PFNGLVERTEXATTRIB4NIVPROC)load("glVertexAttrib4Niv"); + glad_glVertexAttrib4Nsv = (PFNGLVERTEXATTRIB4NSVPROC)load("glVertexAttrib4Nsv"); + glad_glVertexAttrib4Nub = (PFNGLVERTEXATTRIB4NUBPROC)load("glVertexAttrib4Nub"); + glad_glVertexAttrib4Nubv = (PFNGLVERTEXATTRIB4NUBVPROC)load("glVertexAttrib4Nubv"); + glad_glVertexAttrib4Nuiv = (PFNGLVERTEXATTRIB4NUIVPROC)load("glVertexAttrib4Nuiv"); + glad_glVertexAttrib4Nusv = (PFNGLVERTEXATTRIB4NUSVPROC)load("glVertexAttrib4Nusv"); + glad_glVertexAttrib4bv = (PFNGLVERTEXATTRIB4BVPROC)load("glVertexAttrib4bv"); + glad_glVertexAttrib4d = (PFNGLVERTEXATTRIB4DPROC)load("glVertexAttrib4d"); + glad_glVertexAttrib4dv = (PFNGLVERTEXATTRIB4DVPROC)load("glVertexAttrib4dv"); + glad_glVertexAttrib4f = (PFNGLVERTEXATTRIB4FPROC)load("glVertexAttrib4f"); + glad_glVertexAttrib4fv = (PFNGLVERTEXATTRIB4FVPROC)load("glVertexAttrib4fv"); + glad_glVertexAttrib4iv = (PFNGLVERTEXATTRIB4IVPROC)load("glVertexAttrib4iv"); + glad_glVertexAttrib4s = (PFNGLVERTEXATTRIB4SPROC)load("glVertexAttrib4s"); + glad_glVertexAttrib4sv = (PFNGLVERTEXATTRIB4SVPROC)load("glVertexAttrib4sv"); + glad_glVertexAttrib4ubv = (PFNGLVERTEXATTRIB4UBVPROC)load("glVertexAttrib4ubv"); + glad_glVertexAttrib4uiv = (PFNGLVERTEXATTRIB4UIVPROC)load("glVertexAttrib4uiv"); + glad_glVertexAttrib4usv = (PFNGLVERTEXATTRIB4USVPROC)load("glVertexAttrib4usv"); + glad_glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)load("glVertexAttribPointer"); +} +static void load_GL_VERSION_2_1(GLADloadproc load) { + if(!GLAD_GL_VERSION_2_1) return; + glad_glUniformMatrix2x3fv = (PFNGLUNIFORMMATRIX2X3FVPROC)load("glUniformMatrix2x3fv"); + glad_glUniformMatrix3x2fv = (PFNGLUNIFORMMATRIX3X2FVPROC)load("glUniformMatrix3x2fv"); + glad_glUniformMatrix2x4fv = (PFNGLUNIFORMMATRIX2X4FVPROC)load("glUniformMatrix2x4fv"); + glad_glUniformMatrix4x2fv = (PFNGLUNIFORMMATRIX4X2FVPROC)load("glUniformMatrix4x2fv"); + glad_glUniformMatrix3x4fv = (PFNGLUNIFORMMATRIX3X4FVPROC)load("glUniformMatrix3x4fv"); + glad_glUniformMatrix4x3fv = (PFNGLUNIFORMMATRIX4X3FVPROC)load("glUniformMatrix4x3fv"); +} +static void load_GL_VERSION_3_0(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_0) return; + glad_glColorMaski = (PFNGLCOLORMASKIPROC)load("glColorMaski"); + glad_glGetBooleani_v = (PFNGLGETBOOLEANI_VPROC)load("glGetBooleani_v"); + glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load("glGetIntegeri_v"); + glad_glEnablei = (PFNGLENABLEIPROC)load("glEnablei"); + glad_glDisablei = (PFNGLDISABLEIPROC)load("glDisablei"); + glad_glIsEnabledi = (PFNGLISENABLEDIPROC)load("glIsEnabledi"); + glad_glBeginTransformFeedback = (PFNGLBEGINTRANSFORMFEEDBACKPROC)load("glBeginTransformFeedback"); + glad_glEndTransformFeedback = (PFNGLENDTRANSFORMFEEDBACKPROC)load("glEndTransformFeedback"); + glad_glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)load("glBindBufferRange"); + glad_glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)load("glBindBufferBase"); + glad_glTransformFeedbackVaryings = (PFNGLTRANSFORMFEEDBACKVARYINGSPROC)load("glTransformFeedbackVaryings"); + glad_glGetTransformFeedbackVarying = (PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)load("glGetTransformFeedbackVarying"); + glad_glClampColor = (PFNGLCLAMPCOLORPROC)load("glClampColor"); + glad_glBeginConditionalRender = (PFNGLBEGINCONDITIONALRENDERPROC)load("glBeginConditionalRender"); + glad_glEndConditionalRender = (PFNGLENDCONDITIONALRENDERPROC)load("glEndConditionalRender"); + glad_glVertexAttribIPointer = (PFNGLVERTEXATTRIBIPOINTERPROC)load("glVertexAttribIPointer"); + glad_glGetVertexAttribIiv = (PFNGLGETVERTEXATTRIBIIVPROC)load("glGetVertexAttribIiv"); + glad_glGetVertexAttribIuiv = (PFNGLGETVERTEXATTRIBIUIVPROC)load("glGetVertexAttribIuiv"); + glad_glVertexAttribI1i = (PFNGLVERTEXATTRIBI1IPROC)load("glVertexAttribI1i"); + glad_glVertexAttribI2i = (PFNGLVERTEXATTRIBI2IPROC)load("glVertexAttribI2i"); + glad_glVertexAttribI3i = (PFNGLVERTEXATTRIBI3IPROC)load("glVertexAttribI3i"); + glad_glVertexAttribI4i = (PFNGLVERTEXATTRIBI4IPROC)load("glVertexAttribI4i"); + glad_glVertexAttribI1ui = (PFNGLVERTEXATTRIBI1UIPROC)load("glVertexAttribI1ui"); + glad_glVertexAttribI2ui = (PFNGLVERTEXATTRIBI2UIPROC)load("glVertexAttribI2ui"); + glad_glVertexAttribI3ui = (PFNGLVERTEXATTRIBI3UIPROC)load("glVertexAttribI3ui"); + glad_glVertexAttribI4ui = (PFNGLVERTEXATTRIBI4UIPROC)load("glVertexAttribI4ui"); + glad_glVertexAttribI1iv = (PFNGLVERTEXATTRIBI1IVPROC)load("glVertexAttribI1iv"); + glad_glVertexAttribI2iv = (PFNGLVERTEXATTRIBI2IVPROC)load("glVertexAttribI2iv"); + glad_glVertexAttribI3iv = (PFNGLVERTEXATTRIBI3IVPROC)load("glVertexAttribI3iv"); + glad_glVertexAttribI4iv = (PFNGLVERTEXATTRIBI4IVPROC)load("glVertexAttribI4iv"); + glad_glVertexAttribI1uiv = (PFNGLVERTEXATTRIBI1UIVPROC)load("glVertexAttribI1uiv"); + glad_glVertexAttribI2uiv = (PFNGLVERTEXATTRIBI2UIVPROC)load("glVertexAttribI2uiv"); + glad_glVertexAttribI3uiv = (PFNGLVERTEXATTRIBI3UIVPROC)load("glVertexAttribI3uiv"); + glad_glVertexAttribI4uiv = (PFNGLVERTEXATTRIBI4UIVPROC)load("glVertexAttribI4uiv"); + glad_glVertexAttribI4bv = (PFNGLVERTEXATTRIBI4BVPROC)load("glVertexAttribI4bv"); + glad_glVertexAttribI4sv = (PFNGLVERTEXATTRIBI4SVPROC)load("glVertexAttribI4sv"); + glad_glVertexAttribI4ubv = (PFNGLVERTEXATTRIBI4UBVPROC)load("glVertexAttribI4ubv"); + glad_glVertexAttribI4usv = (PFNGLVERTEXATTRIBI4USVPROC)load("glVertexAttribI4usv"); + glad_glGetUniformuiv = (PFNGLGETUNIFORMUIVPROC)load("glGetUniformuiv"); + glad_glBindFragDataLocation = (PFNGLBINDFRAGDATALOCATIONPROC)load("glBindFragDataLocation"); + glad_glGetFragDataLocation = (PFNGLGETFRAGDATALOCATIONPROC)load("glGetFragDataLocation"); + glad_glUniform1ui = (PFNGLUNIFORM1UIPROC)load("glUniform1ui"); + glad_glUniform2ui = (PFNGLUNIFORM2UIPROC)load("glUniform2ui"); + glad_glUniform3ui = (PFNGLUNIFORM3UIPROC)load("glUniform3ui"); + glad_glUniform4ui = (PFNGLUNIFORM4UIPROC)load("glUniform4ui"); + glad_glUniform1uiv = (PFNGLUNIFORM1UIVPROC)load("glUniform1uiv"); + glad_glUniform2uiv = (PFNGLUNIFORM2UIVPROC)load("glUniform2uiv"); + glad_glUniform3uiv = (PFNGLUNIFORM3UIVPROC)load("glUniform3uiv"); + glad_glUniform4uiv = (PFNGLUNIFORM4UIVPROC)load("glUniform4uiv"); + glad_glTexParameterIiv = (PFNGLTEXPARAMETERIIVPROC)load("glTexParameterIiv"); + glad_glTexParameterIuiv = (PFNGLTEXPARAMETERIUIVPROC)load("glTexParameterIuiv"); + glad_glGetTexParameterIiv = (PFNGLGETTEXPARAMETERIIVPROC)load("glGetTexParameterIiv"); + glad_glGetTexParameterIuiv = (PFNGLGETTEXPARAMETERIUIVPROC)load("glGetTexParameterIuiv"); + glad_glClearBufferiv = (PFNGLCLEARBUFFERIVPROC)load("glClearBufferiv"); + glad_glClearBufferuiv = (PFNGLCLEARBUFFERUIVPROC)load("glClearBufferuiv"); + glad_glClearBufferfv = (PFNGLCLEARBUFFERFVPROC)load("glClearBufferfv"); + glad_glClearBufferfi = (PFNGLCLEARBUFFERFIPROC)load("glClearBufferfi"); + glad_glGetStringi = (PFNGLGETSTRINGIPROC)load("glGetStringi"); + glad_glIsRenderbuffer = (PFNGLISRENDERBUFFERPROC)load("glIsRenderbuffer"); + glad_glBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC)load("glBindRenderbuffer"); + glad_glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC)load("glDeleteRenderbuffers"); + glad_glGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC)load("glGenRenderbuffers"); + glad_glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC)load("glRenderbufferStorage"); + glad_glGetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIVPROC)load("glGetRenderbufferParameteriv"); + glad_glIsFramebuffer = (PFNGLISFRAMEBUFFERPROC)load("glIsFramebuffer"); + glad_glBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC)load("glBindFramebuffer"); + glad_glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC)load("glDeleteFramebuffers"); + glad_glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC)load("glGenFramebuffers"); + glad_glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC)load("glCheckFramebufferStatus"); + glad_glFramebufferTexture1D = (PFNGLFRAMEBUFFERTEXTURE1DPROC)load("glFramebufferTexture1D"); + glad_glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC)load("glFramebufferTexture2D"); + glad_glFramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3DPROC)load("glFramebufferTexture3D"); + glad_glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC)load("glFramebufferRenderbuffer"); + glad_glGetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)load("glGetFramebufferAttachmentParameteriv"); + glad_glGenerateMipmap = (PFNGLGENERATEMIPMAPPROC)load("glGenerateMipmap"); + glad_glBlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC)load("glBlitFramebuffer"); + glad_glRenderbufferStorageMultisample = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)load("glRenderbufferStorageMultisample"); + glad_glFramebufferTextureLayer = (PFNGLFRAMEBUFFERTEXTURELAYERPROC)load("glFramebufferTextureLayer"); + glad_glMapBufferRange = (PFNGLMAPBUFFERRANGEPROC)load("glMapBufferRange"); + glad_glFlushMappedBufferRange = (PFNGLFLUSHMAPPEDBUFFERRANGEPROC)load("glFlushMappedBufferRange"); + glad_glBindVertexArray = (PFNGLBINDVERTEXARRAYPROC)load("glBindVertexArray"); + glad_glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC)load("glDeleteVertexArrays"); + glad_glGenVertexArrays = (PFNGLGENVERTEXARRAYSPROC)load("glGenVertexArrays"); + glad_glIsVertexArray = (PFNGLISVERTEXARRAYPROC)load("glIsVertexArray"); +} +static void load_GL_VERSION_3_1(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_1) return; + glad_glDrawArraysInstanced = (PFNGLDRAWARRAYSINSTANCEDPROC)load("glDrawArraysInstanced"); + glad_glDrawElementsInstanced = (PFNGLDRAWELEMENTSINSTANCEDPROC)load("glDrawElementsInstanced"); + glad_glTexBuffer = (PFNGLTEXBUFFERPROC)load("glTexBuffer"); + glad_glPrimitiveRestartIndex = (PFNGLPRIMITIVERESTARTINDEXPROC)load("glPrimitiveRestartIndex"); + glad_glCopyBufferSubData = (PFNGLCOPYBUFFERSUBDATAPROC)load("glCopyBufferSubData"); + glad_glGetUniformIndices = (PFNGLGETUNIFORMINDICESPROC)load("glGetUniformIndices"); + glad_glGetActiveUniformsiv = (PFNGLGETACTIVEUNIFORMSIVPROC)load("glGetActiveUniformsiv"); + glad_glGetActiveUniformName = (PFNGLGETACTIVEUNIFORMNAMEPROC)load("glGetActiveUniformName"); + glad_glGetUniformBlockIndex = (PFNGLGETUNIFORMBLOCKINDEXPROC)load("glGetUniformBlockIndex"); + glad_glGetActiveUniformBlockiv = (PFNGLGETACTIVEUNIFORMBLOCKIVPROC)load("glGetActiveUniformBlockiv"); + glad_glGetActiveUniformBlockName = (PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)load("glGetActiveUniformBlockName"); + glad_glUniformBlockBinding = (PFNGLUNIFORMBLOCKBINDINGPROC)load("glUniformBlockBinding"); + glad_glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)load("glBindBufferRange"); + glad_glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)load("glBindBufferBase"); + glad_glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)load("glGetIntegeri_v"); +} +static void load_GL_VERSION_3_2(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_2) return; + glad_glDrawElementsBaseVertex = (PFNGLDRAWELEMENTSBASEVERTEXPROC)load("glDrawElementsBaseVertex"); + glad_glDrawRangeElementsBaseVertex = (PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)load("glDrawRangeElementsBaseVertex"); + glad_glDrawElementsInstancedBaseVertex = (PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)load("glDrawElementsInstancedBaseVertex"); + glad_glMultiDrawElementsBaseVertex = (PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)load("glMultiDrawElementsBaseVertex"); + glad_glProvokingVertex = (PFNGLPROVOKINGVERTEXPROC)load("glProvokingVertex"); + glad_glFenceSync = (PFNGLFENCESYNCPROC)load("glFenceSync"); + glad_glIsSync = (PFNGLISSYNCPROC)load("glIsSync"); + glad_glDeleteSync = (PFNGLDELETESYNCPROC)load("glDeleteSync"); + glad_glClientWaitSync = (PFNGLCLIENTWAITSYNCPROC)load("glClientWaitSync"); + glad_glWaitSync = (PFNGLWAITSYNCPROC)load("glWaitSync"); + glad_glGetInteger64v = (PFNGLGETINTEGER64VPROC)load("glGetInteger64v"); + glad_glGetSynciv = (PFNGLGETSYNCIVPROC)load("glGetSynciv"); + glad_glGetInteger64i_v = (PFNGLGETINTEGER64I_VPROC)load("glGetInteger64i_v"); + glad_glGetBufferParameteri64v = (PFNGLGETBUFFERPARAMETERI64VPROC)load("glGetBufferParameteri64v"); + glad_glFramebufferTexture = (PFNGLFRAMEBUFFERTEXTUREPROC)load("glFramebufferTexture"); + glad_glTexImage2DMultisample = (PFNGLTEXIMAGE2DMULTISAMPLEPROC)load("glTexImage2DMultisample"); + glad_glTexImage3DMultisample = (PFNGLTEXIMAGE3DMULTISAMPLEPROC)load("glTexImage3DMultisample"); + glad_glGetMultisamplefv = (PFNGLGETMULTISAMPLEFVPROC)load("glGetMultisamplefv"); + glad_glSampleMaski = (PFNGLSAMPLEMASKIPROC)load("glSampleMaski"); +} +static void load_GL_VERSION_3_3(GLADloadproc load) { + if(!GLAD_GL_VERSION_3_3) return; + glad_glBindFragDataLocationIndexed = (PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)load("glBindFragDataLocationIndexed"); + glad_glGetFragDataIndex = (PFNGLGETFRAGDATAINDEXPROC)load("glGetFragDataIndex"); + glad_glGenSamplers = (PFNGLGENSAMPLERSPROC)load("glGenSamplers"); + glad_glDeleteSamplers = (PFNGLDELETESAMPLERSPROC)load("glDeleteSamplers"); + glad_glIsSampler = (PFNGLISSAMPLERPROC)load("glIsSampler"); + glad_glBindSampler = (PFNGLBINDSAMPLERPROC)load("glBindSampler"); + glad_glSamplerParameteri = (PFNGLSAMPLERPARAMETERIPROC)load("glSamplerParameteri"); + glad_glSamplerParameteriv = (PFNGLSAMPLERPARAMETERIVPROC)load("glSamplerParameteriv"); + glad_glSamplerParameterf = (PFNGLSAMPLERPARAMETERFPROC)load("glSamplerParameterf"); + glad_glSamplerParameterfv = (PFNGLSAMPLERPARAMETERFVPROC)load("glSamplerParameterfv"); + glad_glSamplerParameterIiv = (PFNGLSAMPLERPARAMETERIIVPROC)load("glSamplerParameterIiv"); + glad_glSamplerParameterIuiv = (PFNGLSAMPLERPARAMETERIUIVPROC)load("glSamplerParameterIuiv"); + glad_glGetSamplerParameteriv = (PFNGLGETSAMPLERPARAMETERIVPROC)load("glGetSamplerParameteriv"); + glad_glGetSamplerParameterIiv = (PFNGLGETSAMPLERPARAMETERIIVPROC)load("glGetSamplerParameterIiv"); + glad_glGetSamplerParameterfv = (PFNGLGETSAMPLERPARAMETERFVPROC)load("glGetSamplerParameterfv"); + glad_glGetSamplerParameterIuiv = (PFNGLGETSAMPLERPARAMETERIUIVPROC)load("glGetSamplerParameterIuiv"); + glad_glQueryCounter = (PFNGLQUERYCOUNTERPROC)load("glQueryCounter"); + glad_glGetQueryObjecti64v = (PFNGLGETQUERYOBJECTI64VPROC)load("glGetQueryObjecti64v"); + glad_glGetQueryObjectui64v = (PFNGLGETQUERYOBJECTUI64VPROC)load("glGetQueryObjectui64v"); + glad_glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISORPROC)load("glVertexAttribDivisor"); + glad_glVertexAttribP1ui = (PFNGLVERTEXATTRIBP1UIPROC)load("glVertexAttribP1ui"); + glad_glVertexAttribP1uiv = (PFNGLVERTEXATTRIBP1UIVPROC)load("glVertexAttribP1uiv"); + glad_glVertexAttribP2ui = (PFNGLVERTEXATTRIBP2UIPROC)load("glVertexAttribP2ui"); + glad_glVertexAttribP2uiv = (PFNGLVERTEXATTRIBP2UIVPROC)load("glVertexAttribP2uiv"); + glad_glVertexAttribP3ui = (PFNGLVERTEXATTRIBP3UIPROC)load("glVertexAttribP3ui"); + glad_glVertexAttribP3uiv = (PFNGLVERTEXATTRIBP3UIVPROC)load("glVertexAttribP3uiv"); + glad_glVertexAttribP4ui = (PFNGLVERTEXATTRIBP4UIPROC)load("glVertexAttribP4ui"); + glad_glVertexAttribP4uiv = (PFNGLVERTEXATTRIBP4UIVPROC)load("glVertexAttribP4uiv"); + glad_glVertexP2ui = (PFNGLVERTEXP2UIPROC)load("glVertexP2ui"); + glad_glVertexP2uiv = (PFNGLVERTEXP2UIVPROC)load("glVertexP2uiv"); + glad_glVertexP3ui = (PFNGLVERTEXP3UIPROC)load("glVertexP3ui"); + glad_glVertexP3uiv = (PFNGLVERTEXP3UIVPROC)load("glVertexP3uiv"); + glad_glVertexP4ui = (PFNGLVERTEXP4UIPROC)load("glVertexP4ui"); + glad_glVertexP4uiv = (PFNGLVERTEXP4UIVPROC)load("glVertexP4uiv"); + glad_glTexCoordP1ui = (PFNGLTEXCOORDP1UIPROC)load("glTexCoordP1ui"); + glad_glTexCoordP1uiv = (PFNGLTEXCOORDP1UIVPROC)load("glTexCoordP1uiv"); + glad_glTexCoordP2ui = (PFNGLTEXCOORDP2UIPROC)load("glTexCoordP2ui"); + glad_glTexCoordP2uiv = (PFNGLTEXCOORDP2UIVPROC)load("glTexCoordP2uiv"); + glad_glTexCoordP3ui = (PFNGLTEXCOORDP3UIPROC)load("glTexCoordP3ui"); + glad_glTexCoordP3uiv = (PFNGLTEXCOORDP3UIVPROC)load("glTexCoordP3uiv"); + glad_glTexCoordP4ui = (PFNGLTEXCOORDP4UIPROC)load("glTexCoordP4ui"); + glad_glTexCoordP4uiv = (PFNGLTEXCOORDP4UIVPROC)load("glTexCoordP4uiv"); + glad_glMultiTexCoordP1ui = (PFNGLMULTITEXCOORDP1UIPROC)load("glMultiTexCoordP1ui"); + glad_glMultiTexCoordP1uiv = (PFNGLMULTITEXCOORDP1UIVPROC)load("glMultiTexCoordP1uiv"); + glad_glMultiTexCoordP2ui = (PFNGLMULTITEXCOORDP2UIPROC)load("glMultiTexCoordP2ui"); + glad_glMultiTexCoordP2uiv = (PFNGLMULTITEXCOORDP2UIVPROC)load("glMultiTexCoordP2uiv"); + glad_glMultiTexCoordP3ui = (PFNGLMULTITEXCOORDP3UIPROC)load("glMultiTexCoordP3ui"); + glad_glMultiTexCoordP3uiv = (PFNGLMULTITEXCOORDP3UIVPROC)load("glMultiTexCoordP3uiv"); + glad_glMultiTexCoordP4ui = (PFNGLMULTITEXCOORDP4UIPROC)load("glMultiTexCoordP4ui"); + glad_glMultiTexCoordP4uiv = (PFNGLMULTITEXCOORDP4UIVPROC)load("glMultiTexCoordP4uiv"); + glad_glNormalP3ui = (PFNGLNORMALP3UIPROC)load("glNormalP3ui"); + glad_glNormalP3uiv = (PFNGLNORMALP3UIVPROC)load("glNormalP3uiv"); + glad_glColorP3ui = (PFNGLCOLORP3UIPROC)load("glColorP3ui"); + glad_glColorP3uiv = (PFNGLCOLORP3UIVPROC)load("glColorP3uiv"); + glad_glColorP4ui = (PFNGLCOLORP4UIPROC)load("glColorP4ui"); + glad_glColorP4uiv = (PFNGLCOLORP4UIVPROC)load("glColorP4uiv"); + glad_glSecondaryColorP3ui = (PFNGLSECONDARYCOLORP3UIPROC)load("glSecondaryColorP3ui"); + glad_glSecondaryColorP3uiv = (PFNGLSECONDARYCOLORP3UIVPROC)load("glSecondaryColorP3uiv"); +} +static int find_extensionsGL(void) { + if (!get_exts()) return 0; + (void)&has_ext; + free_exts(); + return 1; +} + +static void find_coreGL(void) { + + /* Thank you @elmindreda + * https://github.com/elmindreda/greg/blob/master/templates/greg.c.in#L176 + * https://github.com/glfw/glfw/blob/master/src/context.c#L36 + */ + int i, major, minor; + + const char* version; + const char* prefixes[] = { + "OpenGL ES-CM ", + "OpenGL ES-CL ", + "OpenGL ES ", + NULL + }; + + version = (const char*) glGetString(GL_VERSION); + if (!version) return; + + for (i = 0; prefixes[i]; i++) { + const size_t length = strlen(prefixes[i]); + if (strncmp(version, prefixes[i], length) == 0) { + version += length; + break; + } + } + +/* PR #18 */ +#ifdef _MSC_VER + sscanf_s(version, "%d.%d", &major, &minor); +#else + sscanf(version, "%d.%d", &major, &minor); +#endif + + GLVersion.major = major; GLVersion.minor = minor; + max_loaded_major = major; max_loaded_minor = minor; + GLAD_GL_VERSION_1_0 = (major == 1 && minor >= 0) || major > 1; + GLAD_GL_VERSION_1_1 = (major == 1 && minor >= 1) || major > 1; + GLAD_GL_VERSION_1_2 = (major == 1 && minor >= 2) || major > 1; + GLAD_GL_VERSION_1_3 = (major == 1 && minor >= 3) || major > 1; + GLAD_GL_VERSION_1_4 = (major == 1 && minor >= 4) || major > 1; + GLAD_GL_VERSION_1_5 = (major == 1 && minor >= 5) || major > 1; + GLAD_GL_VERSION_2_0 = (major == 2 && minor >= 0) || major > 2; + GLAD_GL_VERSION_2_1 = (major == 2 && minor >= 1) || major > 2; + GLAD_GL_VERSION_3_0 = (major == 3 && minor >= 0) || major > 3; + GLAD_GL_VERSION_3_1 = (major == 3 && minor >= 1) || major > 3; + GLAD_GL_VERSION_3_2 = (major == 3 && minor >= 2) || major > 3; + GLAD_GL_VERSION_3_3 = (major == 3 && minor >= 3) || major > 3; + if (GLVersion.major > 3 || (GLVersion.major >= 3 && GLVersion.minor >= 3)) { + max_loaded_major = 3; + max_loaded_minor = 3; + } +} + +int gladLoadGLLoader(GLADloadproc load) { + GLVersion.major = 0; GLVersion.minor = 0; + glGetString = (PFNGLGETSTRINGPROC)load("glGetString"); + if(glGetString == NULL) return 0; + if(glGetString(GL_VERSION) == NULL) return 0; + find_coreGL(); + load_GL_VERSION_1_0(load); + load_GL_VERSION_1_1(load); + load_GL_VERSION_1_2(load); + load_GL_VERSION_1_3(load); + load_GL_VERSION_1_4(load); + load_GL_VERSION_1_5(load); + load_GL_VERSION_2_0(load); + load_GL_VERSION_2_1(load); + load_GL_VERSION_3_0(load); + load_GL_VERSION_3_1(load); + load_GL_VERSION_3_2(load); + load_GL_VERSION_3_3(load); + + if (!find_extensionsGL()) return 0; + return GLVersion.major != 0 || GLVersion.minor != 0; +} + diff --git a/glad.h b/glad.h new file mode 100644 index 0000000..7e2d924 --- /dev/null +++ b/glad.h @@ -0,0 +1,2129 @@ +/* + + OpenGL loader generated by glad 0.1.36 on Fri Jan 27 01:11:54 2023. + + Language/Generator: C/C++ + Specification: gl + APIs: gl=3.3 + Profile: core + Extensions: + + Loader: True + Local files: False + Omit khrplatform: False + Reproducible: False + + Commandline: + --profile="core" --api="gl=3.3" --generator="c" --spec="gl" --extensions="" + Online: + https://glad.dav1d.de/#profile=core&language=c&specification=gl&loader=on&api=gl%3D3.3 +*/ + + +#ifndef __glad_h_ +#define __glad_h_ + +#ifdef __gl_h_ +#error OpenGL header already included, remove this include, glad already provides it +#endif +#define __gl_h_ + +#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__) +#define APIENTRY __stdcall +#endif + +#ifndef APIENTRY +#define APIENTRY +#endif +#ifndef APIENTRYP +#define APIENTRYP APIENTRY * +#endif + +#ifndef GLAPIENTRY +#define GLAPIENTRY APIENTRY +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +struct gladGLversionStruct { + int major; + int minor; +}; + +typedef void* (* GLADloadproc)(const char *name); + +#ifndef GLAPI +# if defined(GLAD_GLAPI_EXPORT) +# if defined(_WIN32) || defined(__CYGWIN__) +# if defined(GLAD_GLAPI_EXPORT_BUILD) +# if defined(__GNUC__) +# define GLAPI __attribute__ ((dllexport)) extern +# else +# define GLAPI __declspec(dllexport) extern +# endif +# else +# if defined(__GNUC__) +# define GLAPI __attribute__ ((dllimport)) extern +# else +# define GLAPI __declspec(dllimport) extern +# endif +# endif +# elif defined(__GNUC__) && defined(GLAD_GLAPI_EXPORT_BUILD) +# define GLAPI __attribute__ ((visibility ("default"))) extern +# else +# define GLAPI extern +# endif +# else +# define GLAPI extern +# endif +#endif + +GLAPI struct gladGLversionStruct GLVersion; + +GLAPI int gladLoadGL(void); + +GLAPI int gladLoadGLLoader(GLADloadproc); + +#include "khrplatform.h" +typedef unsigned int GLenum; +typedef unsigned char GLboolean; +typedef unsigned int GLbitfield; +typedef void GLvoid; +typedef khronos_int8_t GLbyte; +typedef khronos_uint8_t GLubyte; +typedef khronos_int16_t GLshort; +typedef khronos_uint16_t GLushort; +typedef int GLint; +typedef unsigned int GLuint; +typedef khronos_int32_t GLclampx; +typedef int GLsizei; +typedef khronos_float_t GLfloat; +typedef khronos_float_t GLclampf; +typedef double GLdouble; +typedef double GLclampd; +typedef void *GLeglClientBufferEXT; +typedef void *GLeglImageOES; +typedef char GLchar; +typedef char GLcharARB; +#ifdef __APPLE__ +typedef void *GLhandleARB; +#else +typedef unsigned int GLhandleARB; +#endif +typedef khronos_uint16_t GLhalf; +typedef khronos_uint16_t GLhalfARB; +typedef khronos_int32_t GLfixed; +typedef khronos_intptr_t GLintptr; +typedef khronos_intptr_t GLintptrARB; +typedef khronos_ssize_t GLsizeiptr; +typedef khronos_ssize_t GLsizeiptrARB; +typedef khronos_int64_t GLint64; +typedef khronos_int64_t GLint64EXT; +typedef khronos_uint64_t GLuint64; +typedef khronos_uint64_t GLuint64EXT; +typedef struct __GLsync *GLsync; +struct _cl_context; +struct _cl_event; +typedef void (APIENTRY *GLDEBUGPROC)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (APIENTRY *GLDEBUGPROCARB)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (APIENTRY *GLDEBUGPROCKHR)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam); +typedef void (APIENTRY *GLDEBUGPROCAMD)(GLuint id,GLenum category,GLenum severity,GLsizei length,const GLchar *message,void *userParam); +typedef unsigned short GLhalfNV; +typedef GLintptr GLvdpauSurfaceNV; +typedef void (APIENTRY *GLVULKANPROCNV)(void); +#define GL_DEPTH_BUFFER_BIT 0x00000100 +#define GL_STENCIL_BUFFER_BIT 0x00000400 +#define GL_COLOR_BUFFER_BIT 0x00004000 +#define GL_FALSE 0 +#define GL_TRUE 1 +#define GL_POINTS 0x0000 +#define GL_LINES 0x0001 +#define GL_LINE_LOOP 0x0002 +#define GL_LINE_STRIP 0x0003 +#define GL_TRIANGLES 0x0004 +#define GL_TRIANGLE_STRIP 0x0005 +#define GL_TRIANGLE_FAN 0x0006 +#define GL_NEVER 0x0200 +#define GL_LESS 0x0201 +#define GL_EQUAL 0x0202 +#define GL_LEQUAL 0x0203 +#define GL_GREATER 0x0204 +#define GL_NOTEQUAL 0x0205 +#define GL_GEQUAL 0x0206 +#define GL_ALWAYS 0x0207 +#define GL_ZERO 0 +#define GL_ONE 1 +#define GL_SRC_COLOR 0x0300 +#define GL_ONE_MINUS_SRC_COLOR 0x0301 +#define GL_SRC_ALPHA 0x0302 +#define GL_ONE_MINUS_SRC_ALPHA 0x0303 +#define GL_DST_ALPHA 0x0304 +#define GL_ONE_MINUS_DST_ALPHA 0x0305 +#define GL_DST_COLOR 0x0306 +#define GL_ONE_MINUS_DST_COLOR 0x0307 +#define GL_SRC_ALPHA_SATURATE 0x0308 +#define GL_NONE 0 +#define GL_FRONT_LEFT 0x0400 +#define GL_FRONT_RIGHT 0x0401 +#define GL_BACK_LEFT 0x0402 +#define GL_BACK_RIGHT 0x0403 +#define GL_FRONT 0x0404 +#define GL_BACK 0x0405 +#define GL_LEFT 0x0406 +#define GL_RIGHT 0x0407 +#define GL_FRONT_AND_BACK 0x0408 +#define GL_NO_ERROR 0 +#define GL_INVALID_ENUM 0x0500 +#define GL_INVALID_VALUE 0x0501 +#define GL_INVALID_OPERATION 0x0502 +#define GL_OUT_OF_MEMORY 0x0505 +#define GL_CW 0x0900 +#define GL_CCW 0x0901 +#define GL_POINT_SIZE 0x0B11 +#define GL_POINT_SIZE_RANGE 0x0B12 +#define GL_POINT_SIZE_GRANULARITY 0x0B13 +#define GL_LINE_SMOOTH 0x0B20 +#define GL_LINE_WIDTH 0x0B21 +#define GL_LINE_WIDTH_RANGE 0x0B22 +#define GL_LINE_WIDTH_GRANULARITY 0x0B23 +#define GL_POLYGON_MODE 0x0B40 +#define GL_POLYGON_SMOOTH 0x0B41 +#define GL_CULL_FACE 0x0B44 +#define GL_CULL_FACE_MODE 0x0B45 +#define GL_FRONT_FACE 0x0B46 +#define GL_DEPTH_RANGE 0x0B70 +#define GL_DEPTH_TEST 0x0B71 +#define GL_DEPTH_WRITEMASK 0x0B72 +#define GL_DEPTH_CLEAR_VALUE 0x0B73 +#define GL_DEPTH_FUNC 0x0B74 +#define GL_STENCIL_TEST 0x0B90 +#define GL_STENCIL_CLEAR_VALUE 0x0B91 +#define GL_STENCIL_FUNC 0x0B92 +#define GL_STENCIL_VALUE_MASK 0x0B93 +#define GL_STENCIL_FAIL 0x0B94 +#define GL_STENCIL_PASS_DEPTH_FAIL 0x0B95 +#define GL_STENCIL_PASS_DEPTH_PASS 0x0B96 +#define GL_STENCIL_REF 0x0B97 +#define GL_STENCIL_WRITEMASK 0x0B98 +#define GL_VIEWPORT 0x0BA2 +#define GL_DITHER 0x0BD0 +#define GL_BLEND_DST 0x0BE0 +#define GL_BLEND_SRC 0x0BE1 +#define GL_BLEND 0x0BE2 +#define GL_LOGIC_OP_MODE 0x0BF0 +#define GL_DRAW_BUFFER 0x0C01 +#define GL_READ_BUFFER 0x0C02 +#define GL_SCISSOR_BOX 0x0C10 +#define GL_SCISSOR_TEST 0x0C11 +#define GL_COLOR_CLEAR_VALUE 0x0C22 +#define GL_COLOR_WRITEMASK 0x0C23 +#define GL_DOUBLEBUFFER 0x0C32 +#define GL_STEREO 0x0C33 +#define GL_LINE_SMOOTH_HINT 0x0C52 +#define GL_POLYGON_SMOOTH_HINT 0x0C53 +#define GL_UNPACK_SWAP_BYTES 0x0CF0 +#define GL_UNPACK_LSB_FIRST 0x0CF1 +#define GL_UNPACK_ROW_LENGTH 0x0CF2 +#define GL_UNPACK_SKIP_ROWS 0x0CF3 +#define GL_UNPACK_SKIP_PIXELS 0x0CF4 +#define GL_UNPACK_ALIGNMENT 0x0CF5 +#define GL_PACK_SWAP_BYTES 0x0D00 +#define GL_PACK_LSB_FIRST 0x0D01 +#define GL_PACK_ROW_LENGTH 0x0D02 +#define GL_PACK_SKIP_ROWS 0x0D03 +#define GL_PACK_SKIP_PIXELS 0x0D04 +#define GL_PACK_ALIGNMENT 0x0D05 +#define GL_MAX_TEXTURE_SIZE 0x0D33 +#define GL_MAX_VIEWPORT_DIMS 0x0D3A +#define GL_SUBPIXEL_BITS 0x0D50 +#define GL_TEXTURE_1D 0x0DE0 +#define GL_TEXTURE_2D 0x0DE1 +#define GL_TEXTURE_WIDTH 0x1000 +#define GL_TEXTURE_HEIGHT 0x1001 +#define GL_TEXTURE_BORDER_COLOR 0x1004 +#define GL_DONT_CARE 0x1100 +#define GL_FASTEST 0x1101 +#define GL_NICEST 0x1102 +#define GL_BYTE 0x1400 +#define GL_UNSIGNED_BYTE 0x1401 +#define GL_SHORT 0x1402 +#define GL_UNSIGNED_SHORT 0x1403 +#define GL_INT 0x1404 +#define GL_UNSIGNED_INT 0x1405 +#define GL_FLOAT 0x1406 +#define GL_CLEAR 0x1500 +#define GL_AND 0x1501 +#define GL_AND_REVERSE 0x1502 +#define GL_COPY 0x1503 +#define GL_AND_INVERTED 0x1504 +#define GL_NOOP 0x1505 +#define GL_XOR 0x1506 +#define GL_OR 0x1507 +#define GL_NOR 0x1508 +#define GL_EQUIV 0x1509 +#define GL_INVERT 0x150A +#define GL_OR_REVERSE 0x150B +#define GL_COPY_INVERTED 0x150C +#define GL_OR_INVERTED 0x150D +#define GL_NAND 0x150E +#define GL_SET 0x150F +#define GL_TEXTURE 0x1702 +#define GL_COLOR 0x1800 +#define GL_DEPTH 0x1801 +#define GL_STENCIL 0x1802 +#define GL_STENCIL_INDEX 0x1901 +#define GL_DEPTH_COMPONENT 0x1902 +#define GL_RED 0x1903 +#define GL_GREEN 0x1904 +#define GL_BLUE 0x1905 +#define GL_ALPHA 0x1906 +#define GL_RGB 0x1907 +#define GL_RGBA 0x1908 +#define GL_POINT 0x1B00 +#define GL_LINE 0x1B01 +#define GL_FILL 0x1B02 +#define GL_KEEP 0x1E00 +#define GL_REPLACE 0x1E01 +#define GL_INCR 0x1E02 +#define GL_DECR 0x1E03 +#define GL_VENDOR 0x1F00 +#define GL_RENDERER 0x1F01 +#define GL_VERSION 0x1F02 +#define GL_EXTENSIONS 0x1F03 +#define GL_NEAREST 0x2600 +#define GL_LINEAR 0x2601 +#define GL_NEAREST_MIPMAP_NEAREST 0x2700 +#define GL_LINEAR_MIPMAP_NEAREST 0x2701 +#define GL_NEAREST_MIPMAP_LINEAR 0x2702 +#define GL_LINEAR_MIPMAP_LINEAR 0x2703 +#define GL_TEXTURE_MAG_FILTER 0x2800 +#define GL_TEXTURE_MIN_FILTER 0x2801 +#define GL_TEXTURE_WRAP_S 0x2802 +#define GL_TEXTURE_WRAP_T 0x2803 +#define GL_REPEAT 0x2901 +#define GL_COLOR_LOGIC_OP 0x0BF2 +#define GL_POLYGON_OFFSET_UNITS 0x2A00 +#define GL_POLYGON_OFFSET_POINT 0x2A01 +#define GL_POLYGON_OFFSET_LINE 0x2A02 +#define GL_POLYGON_OFFSET_FILL 0x8037 +#define GL_POLYGON_OFFSET_FACTOR 0x8038 +#define GL_TEXTURE_BINDING_1D 0x8068 +#define GL_TEXTURE_BINDING_2D 0x8069 +#define GL_TEXTURE_INTERNAL_FORMAT 0x1003 +#define GL_TEXTURE_RED_SIZE 0x805C +#define GL_TEXTURE_GREEN_SIZE 0x805D +#define GL_TEXTURE_BLUE_SIZE 0x805E +#define GL_TEXTURE_ALPHA_SIZE 0x805F +#define GL_DOUBLE 0x140A +#define GL_PROXY_TEXTURE_1D 0x8063 +#define GL_PROXY_TEXTURE_2D 0x8064 +#define GL_R3_G3_B2 0x2A10 +#define GL_RGB4 0x804F +#define GL_RGB5 0x8050 +#define GL_RGB8 0x8051 +#define GL_RGB10 0x8052 +#define GL_RGB12 0x8053 +#define GL_RGB16 0x8054 +#define GL_RGBA2 0x8055 +#define GL_RGBA4 0x8056 +#define GL_RGB5_A1 0x8057 +#define GL_RGBA8 0x8058 +#define GL_RGB10_A2 0x8059 +#define GL_RGBA12 0x805A +#define GL_RGBA16 0x805B +#define GL_UNSIGNED_BYTE_3_3_2 0x8032 +#define GL_UNSIGNED_SHORT_4_4_4_4 0x8033 +#define GL_UNSIGNED_SHORT_5_5_5_1 0x8034 +#define GL_UNSIGNED_INT_8_8_8_8 0x8035 +#define GL_UNSIGNED_INT_10_10_10_2 0x8036 +#define GL_TEXTURE_BINDING_3D 0x806A +#define GL_PACK_SKIP_IMAGES 0x806B +#define GL_PACK_IMAGE_HEIGHT 0x806C +#define GL_UNPACK_SKIP_IMAGES 0x806D +#define GL_UNPACK_IMAGE_HEIGHT 0x806E +#define GL_TEXTURE_3D 0x806F +#define GL_PROXY_TEXTURE_3D 0x8070 +#define GL_TEXTURE_DEPTH 0x8071 +#define GL_TEXTURE_WRAP_R 0x8072 +#define GL_MAX_3D_TEXTURE_SIZE 0x8073 +#define GL_UNSIGNED_BYTE_2_3_3_REV 0x8362 +#define GL_UNSIGNED_SHORT_5_6_5 0x8363 +#define GL_UNSIGNED_SHORT_5_6_5_REV 0x8364 +#define GL_UNSIGNED_SHORT_4_4_4_4_REV 0x8365 +#define GL_UNSIGNED_SHORT_1_5_5_5_REV 0x8366 +#define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367 +#define GL_UNSIGNED_INT_2_10_10_10_REV 0x8368 +#define GL_BGR 0x80E0 +#define GL_BGRA 0x80E1 +#define GL_MAX_ELEMENTS_VERTICES 0x80E8 +#define GL_MAX_ELEMENTS_INDICES 0x80E9 +#define GL_CLAMP_TO_EDGE 0x812F +#define GL_TEXTURE_MIN_LOD 0x813A +#define GL_TEXTURE_MAX_LOD 0x813B +#define GL_TEXTURE_BASE_LEVEL 0x813C +#define GL_TEXTURE_MAX_LEVEL 0x813D +#define GL_SMOOTH_POINT_SIZE_RANGE 0x0B12 +#define GL_SMOOTH_POINT_SIZE_GRANULARITY 0x0B13 +#define GL_SMOOTH_LINE_WIDTH_RANGE 0x0B22 +#define GL_SMOOTH_LINE_WIDTH_GRANULARITY 0x0B23 +#define GL_ALIASED_LINE_WIDTH_RANGE 0x846E +#define GL_TEXTURE0 0x84C0 +#define GL_TEXTURE1 0x84C1 +#define GL_TEXTURE2 0x84C2 +#define GL_TEXTURE3 0x84C3 +#define GL_TEXTURE4 0x84C4 +#define GL_TEXTURE5 0x84C5 +#define GL_TEXTURE6 0x84C6 +#define GL_TEXTURE7 0x84C7 +#define GL_TEXTURE8 0x84C8 +#define GL_TEXTURE9 0x84C9 +#define GL_TEXTURE10 0x84CA +#define GL_TEXTURE11 0x84CB +#define GL_TEXTURE12 0x84CC +#define GL_TEXTURE13 0x84CD +#define GL_TEXTURE14 0x84CE +#define GL_TEXTURE15 0x84CF +#define GL_TEXTURE16 0x84D0 +#define GL_TEXTURE17 0x84D1 +#define GL_TEXTURE18 0x84D2 +#define GL_TEXTURE19 0x84D3 +#define GL_TEXTURE20 0x84D4 +#define GL_TEXTURE21 0x84D5 +#define GL_TEXTURE22 0x84D6 +#define GL_TEXTURE23 0x84D7 +#define GL_TEXTURE24 0x84D8 +#define GL_TEXTURE25 0x84D9 +#define GL_TEXTURE26 0x84DA +#define GL_TEXTURE27 0x84DB +#define GL_TEXTURE28 0x84DC +#define GL_TEXTURE29 0x84DD +#define GL_TEXTURE30 0x84DE +#define GL_TEXTURE31 0x84DF +#define GL_ACTIVE_TEXTURE 0x84E0 +#define GL_MULTISAMPLE 0x809D +#define GL_SAMPLE_ALPHA_TO_COVERAGE 0x809E +#define GL_SAMPLE_ALPHA_TO_ONE 0x809F +#define GL_SAMPLE_COVERAGE 0x80A0 +#define GL_SAMPLE_BUFFERS 0x80A8 +#define GL_SAMPLES 0x80A9 +#define GL_SAMPLE_COVERAGE_VALUE 0x80AA +#define GL_SAMPLE_COVERAGE_INVERT 0x80AB +#define GL_TEXTURE_CUBE_MAP 0x8513 +#define GL_TEXTURE_BINDING_CUBE_MAP 0x8514 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x8515 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x8516 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x8517 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x8518 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x8519 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x851A +#define GL_PROXY_TEXTURE_CUBE_MAP 0x851B +#define GL_MAX_CUBE_MAP_TEXTURE_SIZE 0x851C +#define GL_COMPRESSED_RGB 0x84ED +#define GL_COMPRESSED_RGBA 0x84EE +#define GL_TEXTURE_COMPRESSION_HINT 0x84EF +#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE 0x86A0 +#define GL_TEXTURE_COMPRESSED 0x86A1 +#define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2 +#define GL_COMPRESSED_TEXTURE_FORMATS 0x86A3 +#define GL_CLAMP_TO_BORDER 0x812D +#define GL_BLEND_DST_RGB 0x80C8 +#define GL_BLEND_SRC_RGB 0x80C9 +#define GL_BLEND_DST_ALPHA 0x80CA +#define GL_BLEND_SRC_ALPHA 0x80CB +#define GL_POINT_FADE_THRESHOLD_SIZE 0x8128 +#define GL_DEPTH_COMPONENT16 0x81A5 +#define GL_DEPTH_COMPONENT24 0x81A6 +#define GL_DEPTH_COMPONENT32 0x81A7 +#define GL_MIRRORED_REPEAT 0x8370 +#define GL_MAX_TEXTURE_LOD_BIAS 0x84FD +#define GL_TEXTURE_LOD_BIAS 0x8501 +#define GL_INCR_WRAP 0x8507 +#define GL_DECR_WRAP 0x8508 +#define GL_TEXTURE_DEPTH_SIZE 0x884A +#define GL_TEXTURE_COMPARE_MODE 0x884C +#define GL_TEXTURE_COMPARE_FUNC 0x884D +#define GL_BLEND_COLOR 0x8005 +#define GL_BLEND_EQUATION 0x8009 +#define GL_CONSTANT_COLOR 0x8001 +#define GL_ONE_MINUS_CONSTANT_COLOR 0x8002 +#define GL_CONSTANT_ALPHA 0x8003 +#define GL_ONE_MINUS_CONSTANT_ALPHA 0x8004 +#define GL_FUNC_ADD 0x8006 +#define GL_FUNC_REVERSE_SUBTRACT 0x800B +#define GL_FUNC_SUBTRACT 0x800A +#define GL_MIN 0x8007 +#define GL_MAX 0x8008 +#define GL_BUFFER_SIZE 0x8764 +#define GL_BUFFER_USAGE 0x8765 +#define GL_QUERY_COUNTER_BITS 0x8864 +#define GL_CURRENT_QUERY 0x8865 +#define GL_QUERY_RESULT 0x8866 +#define GL_QUERY_RESULT_AVAILABLE 0x8867 +#define GL_ARRAY_BUFFER 0x8892 +#define GL_ELEMENT_ARRAY_BUFFER 0x8893 +#define GL_ARRAY_BUFFER_BINDING 0x8894 +#define GL_ELEMENT_ARRAY_BUFFER_BINDING 0x8895 +#define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING 0x889F +#define GL_READ_ONLY 0x88B8 +#define GL_WRITE_ONLY 0x88B9 +#define GL_READ_WRITE 0x88BA +#define GL_BUFFER_ACCESS 0x88BB +#define GL_BUFFER_MAPPED 0x88BC +#define GL_BUFFER_MAP_POINTER 0x88BD +#define GL_STREAM_DRAW 0x88E0 +#define GL_STREAM_READ 0x88E1 +#define GL_STREAM_COPY 0x88E2 +#define GL_STATIC_DRAW 0x88E4 +#define GL_STATIC_READ 0x88E5 +#define GL_STATIC_COPY 0x88E6 +#define GL_DYNAMIC_DRAW 0x88E8 +#define GL_DYNAMIC_READ 0x88E9 +#define GL_DYNAMIC_COPY 0x88EA +#define GL_SAMPLES_PASSED 0x8914 +#define GL_SRC1_ALPHA 0x8589 +#define GL_BLEND_EQUATION_RGB 0x8009 +#define GL_VERTEX_ATTRIB_ARRAY_ENABLED 0x8622 +#define GL_VERTEX_ATTRIB_ARRAY_SIZE 0x8623 +#define GL_VERTEX_ATTRIB_ARRAY_STRIDE 0x8624 +#define GL_VERTEX_ATTRIB_ARRAY_TYPE 0x8625 +#define GL_CURRENT_VERTEX_ATTRIB 0x8626 +#define GL_VERTEX_PROGRAM_POINT_SIZE 0x8642 +#define GL_VERTEX_ATTRIB_ARRAY_POINTER 0x8645 +#define GL_STENCIL_BACK_FUNC 0x8800 +#define GL_STENCIL_BACK_FAIL 0x8801 +#define GL_STENCIL_BACK_PASS_DEPTH_FAIL 0x8802 +#define GL_STENCIL_BACK_PASS_DEPTH_PASS 0x8803 +#define GL_MAX_DRAW_BUFFERS 0x8824 +#define GL_DRAW_BUFFER0 0x8825 +#define GL_DRAW_BUFFER1 0x8826 +#define GL_DRAW_BUFFER2 0x8827 +#define GL_DRAW_BUFFER3 0x8828 +#define GL_DRAW_BUFFER4 0x8829 +#define GL_DRAW_BUFFER5 0x882A +#define GL_DRAW_BUFFER6 0x882B +#define GL_DRAW_BUFFER7 0x882C +#define GL_DRAW_BUFFER8 0x882D +#define GL_DRAW_BUFFER9 0x882E +#define GL_DRAW_BUFFER10 0x882F +#define GL_DRAW_BUFFER11 0x8830 +#define GL_DRAW_BUFFER12 0x8831 +#define GL_DRAW_BUFFER13 0x8832 +#define GL_DRAW_BUFFER14 0x8833 +#define GL_DRAW_BUFFER15 0x8834 +#define GL_BLEND_EQUATION_ALPHA 0x883D +#define GL_MAX_VERTEX_ATTRIBS 0x8869 +#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED 0x886A +#define GL_MAX_TEXTURE_IMAGE_UNITS 0x8872 +#define GL_FRAGMENT_SHADER 0x8B30 +#define GL_VERTEX_SHADER 0x8B31 +#define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS 0x8B49 +#define GL_MAX_VERTEX_UNIFORM_COMPONENTS 0x8B4A +#define GL_MAX_VARYING_FLOATS 0x8B4B +#define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS 0x8B4C +#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 0x8B4D +#define GL_SHADER_TYPE 0x8B4F +#define GL_FLOAT_VEC2 0x8B50 +#define GL_FLOAT_VEC3 0x8B51 +#define GL_FLOAT_VEC4 0x8B52 +#define GL_INT_VEC2 0x8B53 +#define GL_INT_VEC3 0x8B54 +#define GL_INT_VEC4 0x8B55 +#define GL_BOOL 0x8B56 +#define GL_BOOL_VEC2 0x8B57 +#define GL_BOOL_VEC3 0x8B58 +#define GL_BOOL_VEC4 0x8B59 +#define GL_FLOAT_MAT2 0x8B5A +#define GL_FLOAT_MAT3 0x8B5B +#define GL_FLOAT_MAT4 0x8B5C +#define GL_SAMPLER_1D 0x8B5D +#define GL_SAMPLER_2D 0x8B5E +#define GL_SAMPLER_3D 0x8B5F +#define GL_SAMPLER_CUBE 0x8B60 +#define GL_SAMPLER_1D_SHADOW 0x8B61 +#define GL_SAMPLER_2D_SHADOW 0x8B62 +#define GL_DELETE_STATUS 0x8B80 +#define GL_COMPILE_STATUS 0x8B81 +#define GL_LINK_STATUS 0x8B82 +#define GL_VALIDATE_STATUS 0x8B83 +#define GL_INFO_LOG_LENGTH 0x8B84 +#define GL_ATTACHED_SHADERS 0x8B85 +#define GL_ACTIVE_UNIFORMS 0x8B86 +#define GL_ACTIVE_UNIFORM_MAX_LENGTH 0x8B87 +#define GL_SHADER_SOURCE_LENGTH 0x8B88 +#define GL_ACTIVE_ATTRIBUTES 0x8B89 +#define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH 0x8B8A +#define GL_FRAGMENT_SHADER_DERIVATIVE_HINT 0x8B8B +#define GL_SHADING_LANGUAGE_VERSION 0x8B8C +#define GL_CURRENT_PROGRAM 0x8B8D +#define GL_POINT_SPRITE_COORD_ORIGIN 0x8CA0 +#define GL_LOWER_LEFT 0x8CA1 +#define GL_UPPER_LEFT 0x8CA2 +#define GL_STENCIL_BACK_REF 0x8CA3 +#define GL_STENCIL_BACK_VALUE_MASK 0x8CA4 +#define GL_STENCIL_BACK_WRITEMASK 0x8CA5 +#define GL_PIXEL_PACK_BUFFER 0x88EB +#define GL_PIXEL_UNPACK_BUFFER 0x88EC +#define GL_PIXEL_PACK_BUFFER_BINDING 0x88ED +#define GL_PIXEL_UNPACK_BUFFER_BINDING 0x88EF +#define GL_FLOAT_MAT2x3 0x8B65 +#define GL_FLOAT_MAT2x4 0x8B66 +#define GL_FLOAT_MAT3x2 0x8B67 +#define GL_FLOAT_MAT3x4 0x8B68 +#define GL_FLOAT_MAT4x2 0x8B69 +#define GL_FLOAT_MAT4x3 0x8B6A +#define GL_SRGB 0x8C40 +#define GL_SRGB8 0x8C41 +#define GL_SRGB_ALPHA 0x8C42 +#define GL_SRGB8_ALPHA8 0x8C43 +#define GL_COMPRESSED_SRGB 0x8C48 +#define GL_COMPRESSED_SRGB_ALPHA 0x8C49 +#define GL_COMPARE_REF_TO_TEXTURE 0x884E +#define GL_CLIP_DISTANCE0 0x3000 +#define GL_CLIP_DISTANCE1 0x3001 +#define GL_CLIP_DISTANCE2 0x3002 +#define GL_CLIP_DISTANCE3 0x3003 +#define GL_CLIP_DISTANCE4 0x3004 +#define GL_CLIP_DISTANCE5 0x3005 +#define GL_CLIP_DISTANCE6 0x3006 +#define GL_CLIP_DISTANCE7 0x3007 +#define GL_MAX_CLIP_DISTANCES 0x0D32 +#define GL_MAJOR_VERSION 0x821B +#define GL_MINOR_VERSION 0x821C +#define GL_NUM_EXTENSIONS 0x821D +#define GL_CONTEXT_FLAGS 0x821E +#define GL_COMPRESSED_RED 0x8225 +#define GL_COMPRESSED_RG 0x8226 +#define GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT 0x00000001 +#define GL_RGBA32F 0x8814 +#define GL_RGB32F 0x8815 +#define GL_RGBA16F 0x881A +#define GL_RGB16F 0x881B +#define GL_VERTEX_ATTRIB_ARRAY_INTEGER 0x88FD +#define GL_MAX_ARRAY_TEXTURE_LAYERS 0x88FF +#define GL_MIN_PROGRAM_TEXEL_OFFSET 0x8904 +#define GL_MAX_PROGRAM_TEXEL_OFFSET 0x8905 +#define GL_CLAMP_READ_COLOR 0x891C +#define GL_FIXED_ONLY 0x891D +#define GL_MAX_VARYING_COMPONENTS 0x8B4B +#define GL_TEXTURE_1D_ARRAY 0x8C18 +#define GL_PROXY_TEXTURE_1D_ARRAY 0x8C19 +#define GL_TEXTURE_2D_ARRAY 0x8C1A +#define GL_PROXY_TEXTURE_2D_ARRAY 0x8C1B +#define GL_TEXTURE_BINDING_1D_ARRAY 0x8C1C +#define GL_TEXTURE_BINDING_2D_ARRAY 0x8C1D +#define GL_R11F_G11F_B10F 0x8C3A +#define GL_UNSIGNED_INT_10F_11F_11F_REV 0x8C3B +#define GL_RGB9_E5 0x8C3D +#define GL_UNSIGNED_INT_5_9_9_9_REV 0x8C3E +#define GL_TEXTURE_SHARED_SIZE 0x8C3F +#define GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH 0x8C76 +#define GL_TRANSFORM_FEEDBACK_BUFFER_MODE 0x8C7F +#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS 0x8C80 +#define GL_TRANSFORM_FEEDBACK_VARYINGS 0x8C83 +#define GL_TRANSFORM_FEEDBACK_BUFFER_START 0x8C84 +#define GL_TRANSFORM_FEEDBACK_BUFFER_SIZE 0x8C85 +#define GL_PRIMITIVES_GENERATED 0x8C87 +#define GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN 0x8C88 +#define GL_RASTERIZER_DISCARD 0x8C89 +#define GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS 0x8C8A +#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS 0x8C8B +#define GL_INTERLEAVED_ATTRIBS 0x8C8C +#define GL_SEPARATE_ATTRIBS 0x8C8D +#define GL_TRANSFORM_FEEDBACK_BUFFER 0x8C8E +#define GL_TRANSFORM_FEEDBACK_BUFFER_BINDING 0x8C8F +#define GL_RGBA32UI 0x8D70 +#define GL_RGB32UI 0x8D71 +#define GL_RGBA16UI 0x8D76 +#define GL_RGB16UI 0x8D77 +#define GL_RGBA8UI 0x8D7C +#define GL_RGB8UI 0x8D7D +#define GL_RGBA32I 0x8D82 +#define GL_RGB32I 0x8D83 +#define GL_RGBA16I 0x8D88 +#define GL_RGB16I 0x8D89 +#define GL_RGBA8I 0x8D8E +#define GL_RGB8I 0x8D8F +#define GL_RED_INTEGER 0x8D94 +#define GL_GREEN_INTEGER 0x8D95 +#define GL_BLUE_INTEGER 0x8D96 +#define GL_RGB_INTEGER 0x8D98 +#define GL_RGBA_INTEGER 0x8D99 +#define GL_BGR_INTEGER 0x8D9A +#define GL_BGRA_INTEGER 0x8D9B +#define GL_SAMPLER_1D_ARRAY 0x8DC0 +#define GL_SAMPLER_2D_ARRAY 0x8DC1 +#define GL_SAMPLER_1D_ARRAY_SHADOW 0x8DC3 +#define GL_SAMPLER_2D_ARRAY_SHADOW 0x8DC4 +#define GL_SAMPLER_CUBE_SHADOW 0x8DC5 +#define GL_UNSIGNED_INT_VEC2 0x8DC6 +#define GL_UNSIGNED_INT_VEC3 0x8DC7 +#define GL_UNSIGNED_INT_VEC4 0x8DC8 +#define GL_INT_SAMPLER_1D 0x8DC9 +#define GL_INT_SAMPLER_2D 0x8DCA +#define GL_INT_SAMPLER_3D 0x8DCB +#define GL_INT_SAMPLER_CUBE 0x8DCC +#define GL_INT_SAMPLER_1D_ARRAY 0x8DCE +#define GL_INT_SAMPLER_2D_ARRAY 0x8DCF +#define GL_UNSIGNED_INT_SAMPLER_1D 0x8DD1 +#define GL_UNSIGNED_INT_SAMPLER_2D 0x8DD2 +#define GL_UNSIGNED_INT_SAMPLER_3D 0x8DD3 +#define GL_UNSIGNED_INT_SAMPLER_CUBE 0x8DD4 +#define GL_UNSIGNED_INT_SAMPLER_1D_ARRAY 0x8DD6 +#define GL_UNSIGNED_INT_SAMPLER_2D_ARRAY 0x8DD7 +#define GL_QUERY_WAIT 0x8E13 +#define GL_QUERY_NO_WAIT 0x8E14 +#define GL_QUERY_BY_REGION_WAIT 0x8E15 +#define GL_QUERY_BY_REGION_NO_WAIT 0x8E16 +#define GL_BUFFER_ACCESS_FLAGS 0x911F +#define GL_BUFFER_MAP_LENGTH 0x9120 +#define GL_BUFFER_MAP_OFFSET 0x9121 +#define GL_DEPTH_COMPONENT32F 0x8CAC +#define GL_DEPTH32F_STENCIL8 0x8CAD +#define GL_FLOAT_32_UNSIGNED_INT_24_8_REV 0x8DAD +#define GL_INVALID_FRAMEBUFFER_OPERATION 0x0506 +#define GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING 0x8210 +#define GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE 0x8211 +#define GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE 0x8212 +#define GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE 0x8213 +#define GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE 0x8214 +#define GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE 0x8215 +#define GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE 0x8216 +#define GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE 0x8217 +#define GL_FRAMEBUFFER_DEFAULT 0x8218 +#define GL_FRAMEBUFFER_UNDEFINED 0x8219 +#define GL_DEPTH_STENCIL_ATTACHMENT 0x821A +#define GL_MAX_RENDERBUFFER_SIZE 0x84E8 +#define GL_DEPTH_STENCIL 0x84F9 +#define GL_UNSIGNED_INT_24_8 0x84FA +#define GL_DEPTH24_STENCIL8 0x88F0 +#define GL_TEXTURE_STENCIL_SIZE 0x88F1 +#define GL_TEXTURE_RED_TYPE 0x8C10 +#define GL_TEXTURE_GREEN_TYPE 0x8C11 +#define GL_TEXTURE_BLUE_TYPE 0x8C12 +#define GL_TEXTURE_ALPHA_TYPE 0x8C13 +#define GL_TEXTURE_DEPTH_TYPE 0x8C16 +#define GL_UNSIGNED_NORMALIZED 0x8C17 +#define GL_FRAMEBUFFER_BINDING 0x8CA6 +#define GL_DRAW_FRAMEBUFFER_BINDING 0x8CA6 +#define GL_RENDERBUFFER_BINDING 0x8CA7 +#define GL_READ_FRAMEBUFFER 0x8CA8 +#define GL_DRAW_FRAMEBUFFER 0x8CA9 +#define GL_READ_FRAMEBUFFER_BINDING 0x8CAA +#define GL_RENDERBUFFER_SAMPLES 0x8CAB +#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE 0x8CD0 +#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME 0x8CD1 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL 0x8CD2 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE 0x8CD3 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER 0x8CD4 +#define GL_FRAMEBUFFER_COMPLETE 0x8CD5 +#define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT 0x8CD6 +#define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT 0x8CD7 +#define GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER 0x8CDB +#define GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER 0x8CDC +#define GL_FRAMEBUFFER_UNSUPPORTED 0x8CDD +#define GL_MAX_COLOR_ATTACHMENTS 0x8CDF +#define GL_COLOR_ATTACHMENT0 0x8CE0 +#define GL_COLOR_ATTACHMENT1 0x8CE1 +#define GL_COLOR_ATTACHMENT2 0x8CE2 +#define GL_COLOR_ATTACHMENT3 0x8CE3 +#define GL_COLOR_ATTACHMENT4 0x8CE4 +#define GL_COLOR_ATTACHMENT5 0x8CE5 +#define GL_COLOR_ATTACHMENT6 0x8CE6 +#define GL_COLOR_ATTACHMENT7 0x8CE7 +#define GL_COLOR_ATTACHMENT8 0x8CE8 +#define GL_COLOR_ATTACHMENT9 0x8CE9 +#define GL_COLOR_ATTACHMENT10 0x8CEA +#define GL_COLOR_ATTACHMENT11 0x8CEB +#define GL_COLOR_ATTACHMENT12 0x8CEC +#define GL_COLOR_ATTACHMENT13 0x8CED +#define GL_COLOR_ATTACHMENT14 0x8CEE +#define GL_COLOR_ATTACHMENT15 0x8CEF +#define GL_COLOR_ATTACHMENT16 0x8CF0 +#define GL_COLOR_ATTACHMENT17 0x8CF1 +#define GL_COLOR_ATTACHMENT18 0x8CF2 +#define GL_COLOR_ATTACHMENT19 0x8CF3 +#define GL_COLOR_ATTACHMENT20 0x8CF4 +#define GL_COLOR_ATTACHMENT21 0x8CF5 +#define GL_COLOR_ATTACHMENT22 0x8CF6 +#define GL_COLOR_ATTACHMENT23 0x8CF7 +#define GL_COLOR_ATTACHMENT24 0x8CF8 +#define GL_COLOR_ATTACHMENT25 0x8CF9 +#define GL_COLOR_ATTACHMENT26 0x8CFA +#define GL_COLOR_ATTACHMENT27 0x8CFB +#define GL_COLOR_ATTACHMENT28 0x8CFC +#define GL_COLOR_ATTACHMENT29 0x8CFD +#define GL_COLOR_ATTACHMENT30 0x8CFE +#define GL_COLOR_ATTACHMENT31 0x8CFF +#define GL_DEPTH_ATTACHMENT 0x8D00 +#define GL_STENCIL_ATTACHMENT 0x8D20 +#define GL_FRAMEBUFFER 0x8D40 +#define GL_RENDERBUFFER 0x8D41 +#define GL_RENDERBUFFER_WIDTH 0x8D42 +#define GL_RENDERBUFFER_HEIGHT 0x8D43 +#define GL_RENDERBUFFER_INTERNAL_FORMAT 0x8D44 +#define GL_STENCIL_INDEX1 0x8D46 +#define GL_STENCIL_INDEX4 0x8D47 +#define GL_STENCIL_INDEX8 0x8D48 +#define GL_STENCIL_INDEX16 0x8D49 +#define GL_RENDERBUFFER_RED_SIZE 0x8D50 +#define GL_RENDERBUFFER_GREEN_SIZE 0x8D51 +#define GL_RENDERBUFFER_BLUE_SIZE 0x8D52 +#define GL_RENDERBUFFER_ALPHA_SIZE 0x8D53 +#define GL_RENDERBUFFER_DEPTH_SIZE 0x8D54 +#define GL_RENDERBUFFER_STENCIL_SIZE 0x8D55 +#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE 0x8D56 +#define GL_MAX_SAMPLES 0x8D57 +#define GL_FRAMEBUFFER_SRGB 0x8DB9 +#define GL_HALF_FLOAT 0x140B +#define GL_MAP_READ_BIT 0x0001 +#define GL_MAP_WRITE_BIT 0x0002 +#define GL_MAP_INVALIDATE_RANGE_BIT 0x0004 +#define GL_MAP_INVALIDATE_BUFFER_BIT 0x0008 +#define GL_MAP_FLUSH_EXPLICIT_BIT 0x0010 +#define GL_MAP_UNSYNCHRONIZED_BIT 0x0020 +#define GL_COMPRESSED_RED_RGTC1 0x8DBB +#define GL_COMPRESSED_SIGNED_RED_RGTC1 0x8DBC +#define GL_COMPRESSED_RG_RGTC2 0x8DBD +#define GL_COMPRESSED_SIGNED_RG_RGTC2 0x8DBE +#define GL_RG 0x8227 +#define GL_RG_INTEGER 0x8228 +#define GL_R8 0x8229 +#define GL_R16 0x822A +#define GL_RG8 0x822B +#define GL_RG16 0x822C +#define GL_R16F 0x822D +#define GL_R32F 0x822E +#define GL_RG16F 0x822F +#define GL_RG32F 0x8230 +#define GL_R8I 0x8231 +#define GL_R8UI 0x8232 +#define GL_R16I 0x8233 +#define GL_R16UI 0x8234 +#define GL_R32I 0x8235 +#define GL_R32UI 0x8236 +#define GL_RG8I 0x8237 +#define GL_RG8UI 0x8238 +#define GL_RG16I 0x8239 +#define GL_RG16UI 0x823A +#define GL_RG32I 0x823B +#define GL_RG32UI 0x823C +#define GL_VERTEX_ARRAY_BINDING 0x85B5 +#define GL_SAMPLER_2D_RECT 0x8B63 +#define GL_SAMPLER_2D_RECT_SHADOW 0x8B64 +#define GL_SAMPLER_BUFFER 0x8DC2 +#define GL_INT_SAMPLER_2D_RECT 0x8DCD +#define GL_INT_SAMPLER_BUFFER 0x8DD0 +#define GL_UNSIGNED_INT_SAMPLER_2D_RECT 0x8DD5 +#define GL_UNSIGNED_INT_SAMPLER_BUFFER 0x8DD8 +#define GL_TEXTURE_BUFFER 0x8C2A +#define GL_MAX_TEXTURE_BUFFER_SIZE 0x8C2B +#define GL_TEXTURE_BINDING_BUFFER 0x8C2C +#define GL_TEXTURE_BUFFER_DATA_STORE_BINDING 0x8C2D +#define GL_TEXTURE_RECTANGLE 0x84F5 +#define GL_TEXTURE_BINDING_RECTANGLE 0x84F6 +#define GL_PROXY_TEXTURE_RECTANGLE 0x84F7 +#define GL_MAX_RECTANGLE_TEXTURE_SIZE 0x84F8 +#define GL_R8_SNORM 0x8F94 +#define GL_RG8_SNORM 0x8F95 +#define GL_RGB8_SNORM 0x8F96 +#define GL_RGBA8_SNORM 0x8F97 +#define GL_R16_SNORM 0x8F98 +#define GL_RG16_SNORM 0x8F99 +#define GL_RGB16_SNORM 0x8F9A +#define GL_RGBA16_SNORM 0x8F9B +#define GL_SIGNED_NORMALIZED 0x8F9C +#define GL_PRIMITIVE_RESTART 0x8F9D +#define GL_PRIMITIVE_RESTART_INDEX 0x8F9E +#define GL_COPY_READ_BUFFER 0x8F36 +#define GL_COPY_WRITE_BUFFER 0x8F37 +#define GL_UNIFORM_BUFFER 0x8A11 +#define GL_UNIFORM_BUFFER_BINDING 0x8A28 +#define GL_UNIFORM_BUFFER_START 0x8A29 +#define GL_UNIFORM_BUFFER_SIZE 0x8A2A +#define GL_MAX_VERTEX_UNIFORM_BLOCKS 0x8A2B +#define GL_MAX_GEOMETRY_UNIFORM_BLOCKS 0x8A2C +#define GL_MAX_FRAGMENT_UNIFORM_BLOCKS 0x8A2D +#define GL_MAX_COMBINED_UNIFORM_BLOCKS 0x8A2E +#define GL_MAX_UNIFORM_BUFFER_BINDINGS 0x8A2F +#define GL_MAX_UNIFORM_BLOCK_SIZE 0x8A30 +#define GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS 0x8A31 +#define GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS 0x8A32 +#define GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS 0x8A33 +#define GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT 0x8A34 +#define GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH 0x8A35 +#define GL_ACTIVE_UNIFORM_BLOCKS 0x8A36 +#define GL_UNIFORM_TYPE 0x8A37 +#define GL_UNIFORM_SIZE 0x8A38 +#define GL_UNIFORM_NAME_LENGTH 0x8A39 +#define GL_UNIFORM_BLOCK_INDEX 0x8A3A +#define GL_UNIFORM_OFFSET 0x8A3B +#define GL_UNIFORM_ARRAY_STRIDE 0x8A3C +#define GL_UNIFORM_MATRIX_STRIDE 0x8A3D +#define GL_UNIFORM_IS_ROW_MAJOR 0x8A3E +#define GL_UNIFORM_BLOCK_BINDING 0x8A3F +#define GL_UNIFORM_BLOCK_DATA_SIZE 0x8A40 +#define GL_UNIFORM_BLOCK_NAME_LENGTH 0x8A41 +#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS 0x8A42 +#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES 0x8A43 +#define GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER 0x8A44 +#define GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER 0x8A45 +#define GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER 0x8A46 +#define GL_INVALID_INDEX 0xFFFFFFFF +#define GL_CONTEXT_CORE_PROFILE_BIT 0x00000001 +#define GL_CONTEXT_COMPATIBILITY_PROFILE_BIT 0x00000002 +#define GL_LINES_ADJACENCY 0x000A +#define GL_LINE_STRIP_ADJACENCY 0x000B +#define GL_TRIANGLES_ADJACENCY 0x000C +#define GL_TRIANGLE_STRIP_ADJACENCY 0x000D +#define GL_PROGRAM_POINT_SIZE 0x8642 +#define GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS 0x8C29 +#define GL_FRAMEBUFFER_ATTACHMENT_LAYERED 0x8DA7 +#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS 0x8DA8 +#define GL_GEOMETRY_SHADER 0x8DD9 +#define GL_GEOMETRY_VERTICES_OUT 0x8916 +#define GL_GEOMETRY_INPUT_TYPE 0x8917 +#define GL_GEOMETRY_OUTPUT_TYPE 0x8918 +#define GL_MAX_GEOMETRY_UNIFORM_COMPONENTS 0x8DDF +#define GL_MAX_GEOMETRY_OUTPUT_VERTICES 0x8DE0 +#define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS 0x8DE1 +#define GL_MAX_VERTEX_OUTPUT_COMPONENTS 0x9122 +#define GL_MAX_GEOMETRY_INPUT_COMPONENTS 0x9123 +#define GL_MAX_GEOMETRY_OUTPUT_COMPONENTS 0x9124 +#define GL_MAX_FRAGMENT_INPUT_COMPONENTS 0x9125 +#define GL_CONTEXT_PROFILE_MASK 0x9126 +#define GL_DEPTH_CLAMP 0x864F +#define GL_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION 0x8E4C +#define GL_FIRST_VERTEX_CONVENTION 0x8E4D +#define GL_LAST_VERTEX_CONVENTION 0x8E4E +#define GL_PROVOKING_VERTEX 0x8E4F +#define GL_TEXTURE_CUBE_MAP_SEAMLESS 0x884F +#define GL_MAX_SERVER_WAIT_TIMEOUT 0x9111 +#define GL_OBJECT_TYPE 0x9112 +#define GL_SYNC_CONDITION 0x9113 +#define GL_SYNC_STATUS 0x9114 +#define GL_SYNC_FLAGS 0x9115 +#define GL_SYNC_FENCE 0x9116 +#define GL_SYNC_GPU_COMMANDS_COMPLETE 0x9117 +#define GL_UNSIGNALED 0x9118 +#define GL_SIGNALED 0x9119 +#define GL_ALREADY_SIGNALED 0x911A +#define GL_TIMEOUT_EXPIRED 0x911B +#define GL_CONDITION_SATISFIED 0x911C +#define GL_WAIT_FAILED 0x911D +#define GL_TIMEOUT_IGNORED 0xFFFFFFFFFFFFFFFF +#define GL_SYNC_FLUSH_COMMANDS_BIT 0x00000001 +#define GL_SAMPLE_POSITION 0x8E50 +#define GL_SAMPLE_MASK 0x8E51 +#define GL_SAMPLE_MASK_VALUE 0x8E52 +#define GL_MAX_SAMPLE_MASK_WORDS 0x8E59 +#define GL_TEXTURE_2D_MULTISAMPLE 0x9100 +#define GL_PROXY_TEXTURE_2D_MULTISAMPLE 0x9101 +#define GL_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9102 +#define GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9103 +#define GL_TEXTURE_BINDING_2D_MULTISAMPLE 0x9104 +#define GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY 0x9105 +#define GL_TEXTURE_SAMPLES 0x9106 +#define GL_TEXTURE_FIXED_SAMPLE_LOCATIONS 0x9107 +#define GL_SAMPLER_2D_MULTISAMPLE 0x9108 +#define GL_INT_SAMPLER_2D_MULTISAMPLE 0x9109 +#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE 0x910A +#define GL_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910B +#define GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910C +#define GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY 0x910D +#define GL_MAX_COLOR_TEXTURE_SAMPLES 0x910E +#define GL_MAX_DEPTH_TEXTURE_SAMPLES 0x910F +#define GL_MAX_INTEGER_SAMPLES 0x9110 +#define GL_VERTEX_ATTRIB_ARRAY_DIVISOR 0x88FE +#define GL_SRC1_COLOR 0x88F9 +#define GL_ONE_MINUS_SRC1_COLOR 0x88FA +#define GL_ONE_MINUS_SRC1_ALPHA 0x88FB +#define GL_MAX_DUAL_SOURCE_DRAW_BUFFERS 0x88FC +#define GL_ANY_SAMPLES_PASSED 0x8C2F +#define GL_SAMPLER_BINDING 0x8919 +#define GL_RGB10_A2UI 0x906F +#define GL_TEXTURE_SWIZZLE_R 0x8E42 +#define GL_TEXTURE_SWIZZLE_G 0x8E43 +#define GL_TEXTURE_SWIZZLE_B 0x8E44 +#define GL_TEXTURE_SWIZZLE_A 0x8E45 +#define GL_TEXTURE_SWIZZLE_RGBA 0x8E46 +#define GL_TIME_ELAPSED 0x88BF +#define GL_TIMESTAMP 0x8E28 +#define GL_INT_2_10_10_10_REV 0x8D9F +#ifndef GL_VERSION_1_0 +#define GL_VERSION_1_0 1 +GLAPI int GLAD_GL_VERSION_1_0; +typedef void (APIENTRYP PFNGLCULLFACEPROC)(GLenum mode); +GLAPI PFNGLCULLFACEPROC glad_glCullFace; +#define glCullFace glad_glCullFace +typedef void (APIENTRYP PFNGLFRONTFACEPROC)(GLenum mode); +GLAPI PFNGLFRONTFACEPROC glad_glFrontFace; +#define glFrontFace glad_glFrontFace +typedef void (APIENTRYP PFNGLHINTPROC)(GLenum target, GLenum mode); +GLAPI PFNGLHINTPROC glad_glHint; +#define glHint glad_glHint +typedef void (APIENTRYP PFNGLLINEWIDTHPROC)(GLfloat width); +GLAPI PFNGLLINEWIDTHPROC glad_glLineWidth; +#define glLineWidth glad_glLineWidth +typedef void (APIENTRYP PFNGLPOINTSIZEPROC)(GLfloat size); +GLAPI PFNGLPOINTSIZEPROC glad_glPointSize; +#define glPointSize glad_glPointSize +typedef void (APIENTRYP PFNGLPOLYGONMODEPROC)(GLenum face, GLenum mode); +GLAPI PFNGLPOLYGONMODEPROC glad_glPolygonMode; +#define glPolygonMode glad_glPolygonMode +typedef void (APIENTRYP PFNGLSCISSORPROC)(GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLSCISSORPROC glad_glScissor; +#define glScissor glad_glScissor +typedef void (APIENTRYP PFNGLTEXPARAMETERFPROC)(GLenum target, GLenum pname, GLfloat param); +GLAPI PFNGLTEXPARAMETERFPROC glad_glTexParameterf; +#define glTexParameterf glad_glTexParameterf +typedef void (APIENTRYP PFNGLTEXPARAMETERFVPROC)(GLenum target, GLenum pname, const GLfloat *params); +GLAPI PFNGLTEXPARAMETERFVPROC glad_glTexParameterfv; +#define glTexParameterfv glad_glTexParameterfv +typedef void (APIENTRYP PFNGLTEXPARAMETERIPROC)(GLenum target, GLenum pname, GLint param); +GLAPI PFNGLTEXPARAMETERIPROC glad_glTexParameteri; +#define glTexParameteri glad_glTexParameteri +typedef void (APIENTRYP PFNGLTEXPARAMETERIVPROC)(GLenum target, GLenum pname, const GLint *params); +GLAPI PFNGLTEXPARAMETERIVPROC glad_glTexParameteriv; +#define glTexParameteriv glad_glTexParameteriv +typedef void (APIENTRYP PFNGLTEXIMAGE1DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXIMAGE1DPROC glad_glTexImage1D; +#define glTexImage1D glad_glTexImage1D +typedef void (APIENTRYP PFNGLTEXIMAGE2DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXIMAGE2DPROC glad_glTexImage2D; +#define glTexImage2D glad_glTexImage2D +typedef void (APIENTRYP PFNGLDRAWBUFFERPROC)(GLenum buf); +GLAPI PFNGLDRAWBUFFERPROC glad_glDrawBuffer; +#define glDrawBuffer glad_glDrawBuffer +typedef void (APIENTRYP PFNGLCLEARPROC)(GLbitfield mask); +GLAPI PFNGLCLEARPROC glad_glClear; +#define glClear glad_glClear +typedef void (APIENTRYP PFNGLCLEARCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +GLAPI PFNGLCLEARCOLORPROC glad_glClearColor; +#define glClearColor glad_glClearColor +typedef void (APIENTRYP PFNGLCLEARSTENCILPROC)(GLint s); +GLAPI PFNGLCLEARSTENCILPROC glad_glClearStencil; +#define glClearStencil glad_glClearStencil +typedef void (APIENTRYP PFNGLCLEARDEPTHPROC)(GLdouble depth); +GLAPI PFNGLCLEARDEPTHPROC glad_glClearDepth; +#define glClearDepth glad_glClearDepth +typedef void (APIENTRYP PFNGLSTENCILMASKPROC)(GLuint mask); +GLAPI PFNGLSTENCILMASKPROC glad_glStencilMask; +#define glStencilMask glad_glStencilMask +typedef void (APIENTRYP PFNGLCOLORMASKPROC)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +GLAPI PFNGLCOLORMASKPROC glad_glColorMask; +#define glColorMask glad_glColorMask +typedef void (APIENTRYP PFNGLDEPTHMASKPROC)(GLboolean flag); +GLAPI PFNGLDEPTHMASKPROC glad_glDepthMask; +#define glDepthMask glad_glDepthMask +typedef void (APIENTRYP PFNGLDISABLEPROC)(GLenum cap); +GLAPI PFNGLDISABLEPROC glad_glDisable; +#define glDisable glad_glDisable +typedef void (APIENTRYP PFNGLENABLEPROC)(GLenum cap); +GLAPI PFNGLENABLEPROC glad_glEnable; +#define glEnable glad_glEnable +typedef void (APIENTRYP PFNGLFINISHPROC)(void); +GLAPI PFNGLFINISHPROC glad_glFinish; +#define glFinish glad_glFinish +typedef void (APIENTRYP PFNGLFLUSHPROC)(void); +GLAPI PFNGLFLUSHPROC glad_glFlush; +#define glFlush glad_glFlush +typedef void (APIENTRYP PFNGLBLENDFUNCPROC)(GLenum sfactor, GLenum dfactor); +GLAPI PFNGLBLENDFUNCPROC glad_glBlendFunc; +#define glBlendFunc glad_glBlendFunc +typedef void (APIENTRYP PFNGLLOGICOPPROC)(GLenum opcode); +GLAPI PFNGLLOGICOPPROC glad_glLogicOp; +#define glLogicOp glad_glLogicOp +typedef void (APIENTRYP PFNGLSTENCILFUNCPROC)(GLenum func, GLint ref, GLuint mask); +GLAPI PFNGLSTENCILFUNCPROC glad_glStencilFunc; +#define glStencilFunc glad_glStencilFunc +typedef void (APIENTRYP PFNGLSTENCILOPPROC)(GLenum fail, GLenum zfail, GLenum zpass); +GLAPI PFNGLSTENCILOPPROC glad_glStencilOp; +#define glStencilOp glad_glStencilOp +typedef void (APIENTRYP PFNGLDEPTHFUNCPROC)(GLenum func); +GLAPI PFNGLDEPTHFUNCPROC glad_glDepthFunc; +#define glDepthFunc glad_glDepthFunc +typedef void (APIENTRYP PFNGLPIXELSTOREFPROC)(GLenum pname, GLfloat param); +GLAPI PFNGLPIXELSTOREFPROC glad_glPixelStoref; +#define glPixelStoref glad_glPixelStoref +typedef void (APIENTRYP PFNGLPIXELSTOREIPROC)(GLenum pname, GLint param); +GLAPI PFNGLPIXELSTOREIPROC glad_glPixelStorei; +#define glPixelStorei glad_glPixelStorei +typedef void (APIENTRYP PFNGLREADBUFFERPROC)(GLenum src); +GLAPI PFNGLREADBUFFERPROC glad_glReadBuffer; +#define glReadBuffer glad_glReadBuffer +typedef void (APIENTRYP PFNGLREADPIXELSPROC)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels); +GLAPI PFNGLREADPIXELSPROC glad_glReadPixels; +#define glReadPixels glad_glReadPixels +typedef void (APIENTRYP PFNGLGETBOOLEANVPROC)(GLenum pname, GLboolean *data); +GLAPI PFNGLGETBOOLEANVPROC glad_glGetBooleanv; +#define glGetBooleanv glad_glGetBooleanv +typedef void (APIENTRYP PFNGLGETDOUBLEVPROC)(GLenum pname, GLdouble *data); +GLAPI PFNGLGETDOUBLEVPROC glad_glGetDoublev; +#define glGetDoublev glad_glGetDoublev +typedef GLenum (APIENTRYP PFNGLGETERRORPROC)(void); +GLAPI PFNGLGETERRORPROC glad_glGetError; +#define glGetError glad_glGetError +typedef void (APIENTRYP PFNGLGETFLOATVPROC)(GLenum pname, GLfloat *data); +GLAPI PFNGLGETFLOATVPROC glad_glGetFloatv; +#define glGetFloatv glad_glGetFloatv +typedef void (APIENTRYP PFNGLGETINTEGERVPROC)(GLenum pname, GLint *data); +GLAPI PFNGLGETINTEGERVPROC glad_glGetIntegerv; +#define glGetIntegerv glad_glGetIntegerv +typedef const GLubyte * (APIENTRYP PFNGLGETSTRINGPROC)(GLenum name); +GLAPI PFNGLGETSTRINGPROC glad_glGetString; +#define glGetString glad_glGetString +typedef void (APIENTRYP PFNGLGETTEXIMAGEPROC)(GLenum target, GLint level, GLenum format, GLenum type, void *pixels); +GLAPI PFNGLGETTEXIMAGEPROC glad_glGetTexImage; +#define glGetTexImage glad_glGetTexImage +typedef void (APIENTRYP PFNGLGETTEXPARAMETERFVPROC)(GLenum target, GLenum pname, GLfloat *params); +GLAPI PFNGLGETTEXPARAMETERFVPROC glad_glGetTexParameterfv; +#define glGetTexParameterfv glad_glGetTexParameterfv +typedef void (APIENTRYP PFNGLGETTEXPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETTEXPARAMETERIVPROC glad_glGetTexParameteriv; +#define glGetTexParameteriv glad_glGetTexParameteriv +typedef void (APIENTRYP PFNGLGETTEXLEVELPARAMETERFVPROC)(GLenum target, GLint level, GLenum pname, GLfloat *params); +GLAPI PFNGLGETTEXLEVELPARAMETERFVPROC glad_glGetTexLevelParameterfv; +#define glGetTexLevelParameterfv glad_glGetTexLevelParameterfv +typedef void (APIENTRYP PFNGLGETTEXLEVELPARAMETERIVPROC)(GLenum target, GLint level, GLenum pname, GLint *params); +GLAPI PFNGLGETTEXLEVELPARAMETERIVPROC glad_glGetTexLevelParameteriv; +#define glGetTexLevelParameteriv glad_glGetTexLevelParameteriv +typedef GLboolean (APIENTRYP PFNGLISENABLEDPROC)(GLenum cap); +GLAPI PFNGLISENABLEDPROC glad_glIsEnabled; +#define glIsEnabled glad_glIsEnabled +typedef void (APIENTRYP PFNGLDEPTHRANGEPROC)(GLdouble n, GLdouble f); +GLAPI PFNGLDEPTHRANGEPROC glad_glDepthRange; +#define glDepthRange glad_glDepthRange +typedef void (APIENTRYP PFNGLVIEWPORTPROC)(GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLVIEWPORTPROC glad_glViewport; +#define glViewport glad_glViewport +#endif +#ifndef GL_VERSION_1_1 +#define GL_VERSION_1_1 1 +GLAPI int GLAD_GL_VERSION_1_1; +typedef void (APIENTRYP PFNGLDRAWARRAYSPROC)(GLenum mode, GLint first, GLsizei count); +GLAPI PFNGLDRAWARRAYSPROC glad_glDrawArrays; +#define glDrawArrays glad_glDrawArrays +typedef void (APIENTRYP PFNGLDRAWELEMENTSPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices); +GLAPI PFNGLDRAWELEMENTSPROC glad_glDrawElements; +#define glDrawElements glad_glDrawElements +typedef void (APIENTRYP PFNGLPOLYGONOFFSETPROC)(GLfloat factor, GLfloat units); +GLAPI PFNGLPOLYGONOFFSETPROC glad_glPolygonOffset; +#define glPolygonOffset glad_glPolygonOffset +typedef void (APIENTRYP PFNGLCOPYTEXIMAGE1DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); +GLAPI PFNGLCOPYTEXIMAGE1DPROC glad_glCopyTexImage1D; +#define glCopyTexImage1D glad_glCopyTexImage1D +typedef void (APIENTRYP PFNGLCOPYTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +GLAPI PFNGLCOPYTEXIMAGE2DPROC glad_glCopyTexImage2D; +#define glCopyTexImage2D glad_glCopyTexImage2D +typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +GLAPI PFNGLCOPYTEXSUBIMAGE1DPROC glad_glCopyTexSubImage1D; +#define glCopyTexSubImage1D glad_glCopyTexSubImage1D +typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLCOPYTEXSUBIMAGE2DPROC glad_glCopyTexSubImage2D; +#define glCopyTexSubImage2D glad_glCopyTexSubImage2D +typedef void (APIENTRYP PFNGLTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXSUBIMAGE1DPROC glad_glTexSubImage1D; +#define glTexSubImage1D glad_glTexSubImage1D +typedef void (APIENTRYP PFNGLTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXSUBIMAGE2DPROC glad_glTexSubImage2D; +#define glTexSubImage2D glad_glTexSubImage2D +typedef void (APIENTRYP PFNGLBINDTEXTUREPROC)(GLenum target, GLuint texture); +GLAPI PFNGLBINDTEXTUREPROC glad_glBindTexture; +#define glBindTexture glad_glBindTexture +typedef void (APIENTRYP PFNGLDELETETEXTURESPROC)(GLsizei n, const GLuint *textures); +GLAPI PFNGLDELETETEXTURESPROC glad_glDeleteTextures; +#define glDeleteTextures glad_glDeleteTextures +typedef void (APIENTRYP PFNGLGENTEXTURESPROC)(GLsizei n, GLuint *textures); +GLAPI PFNGLGENTEXTURESPROC glad_glGenTextures; +#define glGenTextures glad_glGenTextures +typedef GLboolean (APIENTRYP PFNGLISTEXTUREPROC)(GLuint texture); +GLAPI PFNGLISTEXTUREPROC glad_glIsTexture; +#define glIsTexture glad_glIsTexture +#endif +#ifndef GL_VERSION_1_2 +#define GL_VERSION_1_2 1 +GLAPI int GLAD_GL_VERSION_1_2; +typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTSPROC)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices); +GLAPI PFNGLDRAWRANGEELEMENTSPROC glad_glDrawRangeElements; +#define glDrawRangeElements glad_glDrawRangeElements +typedef void (APIENTRYP PFNGLTEXIMAGE3DPROC)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXIMAGE3DPROC glad_glTexImage3D; +#define glTexImage3D glad_glTexImage3D +typedef void (APIENTRYP PFNGLTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels); +GLAPI PFNGLTEXSUBIMAGE3DPROC glad_glTexSubImage3D; +#define glTexSubImage3D glad_glTexSubImage3D +typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI PFNGLCOPYTEXSUBIMAGE3DPROC glad_glCopyTexSubImage3D; +#define glCopyTexSubImage3D glad_glCopyTexSubImage3D +#endif +#ifndef GL_VERSION_1_3 +#define GL_VERSION_1_3 1 +GLAPI int GLAD_GL_VERSION_1_3; +typedef void (APIENTRYP PFNGLACTIVETEXTUREPROC)(GLenum texture); +GLAPI PFNGLACTIVETEXTUREPROC glad_glActiveTexture; +#define glActiveTexture glad_glActiveTexture +typedef void (APIENTRYP PFNGLSAMPLECOVERAGEPROC)(GLfloat value, GLboolean invert); +GLAPI PFNGLSAMPLECOVERAGEPROC glad_glSampleCoverage; +#define glSampleCoverage glad_glSampleCoverage +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE3DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXIMAGE3DPROC glad_glCompressedTexImage3D; +#define glCompressedTexImage3D glad_glCompressedTexImage3D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE2DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXIMAGE2DPROC glad_glCompressedTexImage2D; +#define glCompressedTexImage2D glad_glCompressedTexImage2D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE1DPROC)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXIMAGE1DPROC glad_glCompressedTexImage1D; +#define glCompressedTexImage1D glad_glCompressedTexImage1D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC glad_glCompressedTexSubImage3D; +#define glCompressedTexSubImage3D glad_glCompressedTexSubImage3D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC glad_glCompressedTexSubImage2D; +#define glCompressedTexSubImage2D glad_glCompressedTexSubImage2D +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data); +GLAPI PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC glad_glCompressedTexSubImage1D; +#define glCompressedTexSubImage1D glad_glCompressedTexSubImage1D +typedef void (APIENTRYP PFNGLGETCOMPRESSEDTEXIMAGEPROC)(GLenum target, GLint level, void *img); +GLAPI PFNGLGETCOMPRESSEDTEXIMAGEPROC glad_glGetCompressedTexImage; +#define glGetCompressedTexImage glad_glGetCompressedTexImage +#endif +#ifndef GL_VERSION_1_4 +#define GL_VERSION_1_4 1 +GLAPI int GLAD_GL_VERSION_1_4; +typedef void (APIENTRYP PFNGLBLENDFUNCSEPARATEPROC)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); +GLAPI PFNGLBLENDFUNCSEPARATEPROC glad_glBlendFuncSeparate; +#define glBlendFuncSeparate glad_glBlendFuncSeparate +typedef void (APIENTRYP PFNGLMULTIDRAWARRAYSPROC)(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount); +GLAPI PFNGLMULTIDRAWARRAYSPROC glad_glMultiDrawArrays; +#define glMultiDrawArrays glad_glMultiDrawArrays +typedef void (APIENTRYP PFNGLMULTIDRAWELEMENTSPROC)(GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount); +GLAPI PFNGLMULTIDRAWELEMENTSPROC glad_glMultiDrawElements; +#define glMultiDrawElements glad_glMultiDrawElements +typedef void (APIENTRYP PFNGLPOINTPARAMETERFPROC)(GLenum pname, GLfloat param); +GLAPI PFNGLPOINTPARAMETERFPROC glad_glPointParameterf; +#define glPointParameterf glad_glPointParameterf +typedef void (APIENTRYP PFNGLPOINTPARAMETERFVPROC)(GLenum pname, const GLfloat *params); +GLAPI PFNGLPOINTPARAMETERFVPROC glad_glPointParameterfv; +#define glPointParameterfv glad_glPointParameterfv +typedef void (APIENTRYP PFNGLPOINTPARAMETERIPROC)(GLenum pname, GLint param); +GLAPI PFNGLPOINTPARAMETERIPROC glad_glPointParameteri; +#define glPointParameteri glad_glPointParameteri +typedef void (APIENTRYP PFNGLPOINTPARAMETERIVPROC)(GLenum pname, const GLint *params); +GLAPI PFNGLPOINTPARAMETERIVPROC glad_glPointParameteriv; +#define glPointParameteriv glad_glPointParameteriv +typedef void (APIENTRYP PFNGLBLENDCOLORPROC)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +GLAPI PFNGLBLENDCOLORPROC glad_glBlendColor; +#define glBlendColor glad_glBlendColor +typedef void (APIENTRYP PFNGLBLENDEQUATIONPROC)(GLenum mode); +GLAPI PFNGLBLENDEQUATIONPROC glad_glBlendEquation; +#define glBlendEquation glad_glBlendEquation +#endif +#ifndef GL_VERSION_1_5 +#define GL_VERSION_1_5 1 +GLAPI int GLAD_GL_VERSION_1_5; +typedef void (APIENTRYP PFNGLGENQUERIESPROC)(GLsizei n, GLuint *ids); +GLAPI PFNGLGENQUERIESPROC glad_glGenQueries; +#define glGenQueries glad_glGenQueries +typedef void (APIENTRYP PFNGLDELETEQUERIESPROC)(GLsizei n, const GLuint *ids); +GLAPI PFNGLDELETEQUERIESPROC glad_glDeleteQueries; +#define glDeleteQueries glad_glDeleteQueries +typedef GLboolean (APIENTRYP PFNGLISQUERYPROC)(GLuint id); +GLAPI PFNGLISQUERYPROC glad_glIsQuery; +#define glIsQuery glad_glIsQuery +typedef void (APIENTRYP PFNGLBEGINQUERYPROC)(GLenum target, GLuint id); +GLAPI PFNGLBEGINQUERYPROC glad_glBeginQuery; +#define glBeginQuery glad_glBeginQuery +typedef void (APIENTRYP PFNGLENDQUERYPROC)(GLenum target); +GLAPI PFNGLENDQUERYPROC glad_glEndQuery; +#define glEndQuery glad_glEndQuery +typedef void (APIENTRYP PFNGLGETQUERYIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETQUERYIVPROC glad_glGetQueryiv; +#define glGetQueryiv glad_glGetQueryiv +typedef void (APIENTRYP PFNGLGETQUERYOBJECTIVPROC)(GLuint id, GLenum pname, GLint *params); +GLAPI PFNGLGETQUERYOBJECTIVPROC glad_glGetQueryObjectiv; +#define glGetQueryObjectiv glad_glGetQueryObjectiv +typedef void (APIENTRYP PFNGLGETQUERYOBJECTUIVPROC)(GLuint id, GLenum pname, GLuint *params); +GLAPI PFNGLGETQUERYOBJECTUIVPROC glad_glGetQueryObjectuiv; +#define glGetQueryObjectuiv glad_glGetQueryObjectuiv +typedef void (APIENTRYP PFNGLBINDBUFFERPROC)(GLenum target, GLuint buffer); +GLAPI PFNGLBINDBUFFERPROC glad_glBindBuffer; +#define glBindBuffer glad_glBindBuffer +typedef void (APIENTRYP PFNGLDELETEBUFFERSPROC)(GLsizei n, const GLuint *buffers); +GLAPI PFNGLDELETEBUFFERSPROC glad_glDeleteBuffers; +#define glDeleteBuffers glad_glDeleteBuffers +typedef void (APIENTRYP PFNGLGENBUFFERSPROC)(GLsizei n, GLuint *buffers); +GLAPI PFNGLGENBUFFERSPROC glad_glGenBuffers; +#define glGenBuffers glad_glGenBuffers +typedef GLboolean (APIENTRYP PFNGLISBUFFERPROC)(GLuint buffer); +GLAPI PFNGLISBUFFERPROC glad_glIsBuffer; +#define glIsBuffer glad_glIsBuffer +typedef void (APIENTRYP PFNGLBUFFERDATAPROC)(GLenum target, GLsizeiptr size, const void *data, GLenum usage); +GLAPI PFNGLBUFFERDATAPROC glad_glBufferData; +#define glBufferData glad_glBufferData +typedef void (APIENTRYP PFNGLBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, const void *data); +GLAPI PFNGLBUFFERSUBDATAPROC glad_glBufferSubData; +#define glBufferSubData glad_glBufferSubData +typedef void (APIENTRYP PFNGLGETBUFFERSUBDATAPROC)(GLenum target, GLintptr offset, GLsizeiptr size, void *data); +GLAPI PFNGLGETBUFFERSUBDATAPROC glad_glGetBufferSubData; +#define glGetBufferSubData glad_glGetBufferSubData +typedef void * (APIENTRYP PFNGLMAPBUFFERPROC)(GLenum target, GLenum access); +GLAPI PFNGLMAPBUFFERPROC glad_glMapBuffer; +#define glMapBuffer glad_glMapBuffer +typedef GLboolean (APIENTRYP PFNGLUNMAPBUFFERPROC)(GLenum target); +GLAPI PFNGLUNMAPBUFFERPROC glad_glUnmapBuffer; +#define glUnmapBuffer glad_glUnmapBuffer +typedef void (APIENTRYP PFNGLGETBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETBUFFERPARAMETERIVPROC glad_glGetBufferParameteriv; +#define glGetBufferParameteriv glad_glGetBufferParameteriv +typedef void (APIENTRYP PFNGLGETBUFFERPOINTERVPROC)(GLenum target, GLenum pname, void **params); +GLAPI PFNGLGETBUFFERPOINTERVPROC glad_glGetBufferPointerv; +#define glGetBufferPointerv glad_glGetBufferPointerv +#endif +#ifndef GL_VERSION_2_0 +#define GL_VERSION_2_0 1 +GLAPI int GLAD_GL_VERSION_2_0; +typedef void (APIENTRYP PFNGLBLENDEQUATIONSEPARATEPROC)(GLenum modeRGB, GLenum modeAlpha); +GLAPI PFNGLBLENDEQUATIONSEPARATEPROC glad_glBlendEquationSeparate; +#define glBlendEquationSeparate glad_glBlendEquationSeparate +typedef void (APIENTRYP PFNGLDRAWBUFFERSPROC)(GLsizei n, const GLenum *bufs); +GLAPI PFNGLDRAWBUFFERSPROC glad_glDrawBuffers; +#define glDrawBuffers glad_glDrawBuffers +typedef void (APIENTRYP PFNGLSTENCILOPSEPARATEPROC)(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); +GLAPI PFNGLSTENCILOPSEPARATEPROC glad_glStencilOpSeparate; +#define glStencilOpSeparate glad_glStencilOpSeparate +typedef void (APIENTRYP PFNGLSTENCILFUNCSEPARATEPROC)(GLenum face, GLenum func, GLint ref, GLuint mask); +GLAPI PFNGLSTENCILFUNCSEPARATEPROC glad_glStencilFuncSeparate; +#define glStencilFuncSeparate glad_glStencilFuncSeparate +typedef void (APIENTRYP PFNGLSTENCILMASKSEPARATEPROC)(GLenum face, GLuint mask); +GLAPI PFNGLSTENCILMASKSEPARATEPROC glad_glStencilMaskSeparate; +#define glStencilMaskSeparate glad_glStencilMaskSeparate +typedef void (APIENTRYP PFNGLATTACHSHADERPROC)(GLuint program, GLuint shader); +GLAPI PFNGLATTACHSHADERPROC glad_glAttachShader; +#define glAttachShader glad_glAttachShader +typedef void (APIENTRYP PFNGLBINDATTRIBLOCATIONPROC)(GLuint program, GLuint index, const GLchar *name); +GLAPI PFNGLBINDATTRIBLOCATIONPROC glad_glBindAttribLocation; +#define glBindAttribLocation glad_glBindAttribLocation +typedef void (APIENTRYP PFNGLCOMPILESHADERPROC)(GLuint shader); +GLAPI PFNGLCOMPILESHADERPROC glad_glCompileShader; +#define glCompileShader glad_glCompileShader +typedef GLuint (APIENTRYP PFNGLCREATEPROGRAMPROC)(void); +GLAPI PFNGLCREATEPROGRAMPROC glad_glCreateProgram; +#define glCreateProgram glad_glCreateProgram +typedef GLuint (APIENTRYP PFNGLCREATESHADERPROC)(GLenum type); +GLAPI PFNGLCREATESHADERPROC glad_glCreateShader; +#define glCreateShader glad_glCreateShader +typedef void (APIENTRYP PFNGLDELETEPROGRAMPROC)(GLuint program); +GLAPI PFNGLDELETEPROGRAMPROC glad_glDeleteProgram; +#define glDeleteProgram glad_glDeleteProgram +typedef void (APIENTRYP PFNGLDELETESHADERPROC)(GLuint shader); +GLAPI PFNGLDELETESHADERPROC glad_glDeleteShader; +#define glDeleteShader glad_glDeleteShader +typedef void (APIENTRYP PFNGLDETACHSHADERPROC)(GLuint program, GLuint shader); +GLAPI PFNGLDETACHSHADERPROC glad_glDetachShader; +#define glDetachShader glad_glDetachShader +typedef void (APIENTRYP PFNGLDISABLEVERTEXATTRIBARRAYPROC)(GLuint index); +GLAPI PFNGLDISABLEVERTEXATTRIBARRAYPROC glad_glDisableVertexAttribArray; +#define glDisableVertexAttribArray glad_glDisableVertexAttribArray +typedef void (APIENTRYP PFNGLENABLEVERTEXATTRIBARRAYPROC)(GLuint index); +GLAPI PFNGLENABLEVERTEXATTRIBARRAYPROC glad_glEnableVertexAttribArray; +#define glEnableVertexAttribArray glad_glEnableVertexAttribArray +typedef void (APIENTRYP PFNGLGETACTIVEATTRIBPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); +GLAPI PFNGLGETACTIVEATTRIBPROC glad_glGetActiveAttrib; +#define glGetActiveAttrib glad_glGetActiveAttrib +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); +GLAPI PFNGLGETACTIVEUNIFORMPROC glad_glGetActiveUniform; +#define glGetActiveUniform glad_glGetActiveUniform +typedef void (APIENTRYP PFNGLGETATTACHEDSHADERSPROC)(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders); +GLAPI PFNGLGETATTACHEDSHADERSPROC glad_glGetAttachedShaders; +#define glGetAttachedShaders glad_glGetAttachedShaders +typedef GLint (APIENTRYP PFNGLGETATTRIBLOCATIONPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETATTRIBLOCATIONPROC glad_glGetAttribLocation; +#define glGetAttribLocation glad_glGetAttribLocation +typedef void (APIENTRYP PFNGLGETPROGRAMIVPROC)(GLuint program, GLenum pname, GLint *params); +GLAPI PFNGLGETPROGRAMIVPROC glad_glGetProgramiv; +#define glGetProgramiv glad_glGetProgramiv +typedef void (APIENTRYP PFNGLGETPROGRAMINFOLOGPROC)(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog); +GLAPI PFNGLGETPROGRAMINFOLOGPROC glad_glGetProgramInfoLog; +#define glGetProgramInfoLog glad_glGetProgramInfoLog +typedef void (APIENTRYP PFNGLGETSHADERIVPROC)(GLuint shader, GLenum pname, GLint *params); +GLAPI PFNGLGETSHADERIVPROC glad_glGetShaderiv; +#define glGetShaderiv glad_glGetShaderiv +typedef void (APIENTRYP PFNGLGETSHADERINFOLOGPROC)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog); +GLAPI PFNGLGETSHADERINFOLOGPROC glad_glGetShaderInfoLog; +#define glGetShaderInfoLog glad_glGetShaderInfoLog +typedef void (APIENTRYP PFNGLGETSHADERSOURCEPROC)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source); +GLAPI PFNGLGETSHADERSOURCEPROC glad_glGetShaderSource; +#define glGetShaderSource glad_glGetShaderSource +typedef GLint (APIENTRYP PFNGLGETUNIFORMLOCATIONPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETUNIFORMLOCATIONPROC glad_glGetUniformLocation; +#define glGetUniformLocation glad_glGetUniformLocation +typedef void (APIENTRYP PFNGLGETUNIFORMFVPROC)(GLuint program, GLint location, GLfloat *params); +GLAPI PFNGLGETUNIFORMFVPROC glad_glGetUniformfv; +#define glGetUniformfv glad_glGetUniformfv +typedef void (APIENTRYP PFNGLGETUNIFORMIVPROC)(GLuint program, GLint location, GLint *params); +GLAPI PFNGLGETUNIFORMIVPROC glad_glGetUniformiv; +#define glGetUniformiv glad_glGetUniformiv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBDVPROC)(GLuint index, GLenum pname, GLdouble *params); +GLAPI PFNGLGETVERTEXATTRIBDVPROC glad_glGetVertexAttribdv; +#define glGetVertexAttribdv glad_glGetVertexAttribdv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBFVPROC)(GLuint index, GLenum pname, GLfloat *params); +GLAPI PFNGLGETVERTEXATTRIBFVPROC glad_glGetVertexAttribfv; +#define glGetVertexAttribfv glad_glGetVertexAttribfv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIVPROC)(GLuint index, GLenum pname, GLint *params); +GLAPI PFNGLGETVERTEXATTRIBIVPROC glad_glGetVertexAttribiv; +#define glGetVertexAttribiv glad_glGetVertexAttribiv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBPOINTERVPROC)(GLuint index, GLenum pname, void **pointer); +GLAPI PFNGLGETVERTEXATTRIBPOINTERVPROC glad_glGetVertexAttribPointerv; +#define glGetVertexAttribPointerv glad_glGetVertexAttribPointerv +typedef GLboolean (APIENTRYP PFNGLISPROGRAMPROC)(GLuint program); +GLAPI PFNGLISPROGRAMPROC glad_glIsProgram; +#define glIsProgram glad_glIsProgram +typedef GLboolean (APIENTRYP PFNGLISSHADERPROC)(GLuint shader); +GLAPI PFNGLISSHADERPROC glad_glIsShader; +#define glIsShader glad_glIsShader +typedef void (APIENTRYP PFNGLLINKPROGRAMPROC)(GLuint program); +GLAPI PFNGLLINKPROGRAMPROC glad_glLinkProgram; +#define glLinkProgram glad_glLinkProgram +typedef void (APIENTRYP PFNGLSHADERSOURCEPROC)(GLuint shader, GLsizei count, const GLchar *const*string, const GLint *length); +GLAPI PFNGLSHADERSOURCEPROC glad_glShaderSource; +#define glShaderSource glad_glShaderSource +typedef void (APIENTRYP PFNGLUSEPROGRAMPROC)(GLuint program); +GLAPI PFNGLUSEPROGRAMPROC glad_glUseProgram; +#define glUseProgram glad_glUseProgram +typedef void (APIENTRYP PFNGLUNIFORM1FPROC)(GLint location, GLfloat v0); +GLAPI PFNGLUNIFORM1FPROC glad_glUniform1f; +#define glUniform1f glad_glUniform1f +typedef void (APIENTRYP PFNGLUNIFORM2FPROC)(GLint location, GLfloat v0, GLfloat v1); +GLAPI PFNGLUNIFORM2FPROC glad_glUniform2f; +#define glUniform2f glad_glUniform2f +typedef void (APIENTRYP PFNGLUNIFORM3FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +GLAPI PFNGLUNIFORM3FPROC glad_glUniform3f; +#define glUniform3f glad_glUniform3f +typedef void (APIENTRYP PFNGLUNIFORM4FPROC)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +GLAPI PFNGLUNIFORM4FPROC glad_glUniform4f; +#define glUniform4f glad_glUniform4f +typedef void (APIENTRYP PFNGLUNIFORM1IPROC)(GLint location, GLint v0); +GLAPI PFNGLUNIFORM1IPROC glad_glUniform1i; +#define glUniform1i glad_glUniform1i +typedef void (APIENTRYP PFNGLUNIFORM2IPROC)(GLint location, GLint v0, GLint v1); +GLAPI PFNGLUNIFORM2IPROC glad_glUniform2i; +#define glUniform2i glad_glUniform2i +typedef void (APIENTRYP PFNGLUNIFORM3IPROC)(GLint location, GLint v0, GLint v1, GLint v2); +GLAPI PFNGLUNIFORM3IPROC glad_glUniform3i; +#define glUniform3i glad_glUniform3i +typedef void (APIENTRYP PFNGLUNIFORM4IPROC)(GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +GLAPI PFNGLUNIFORM4IPROC glad_glUniform4i; +#define glUniform4i glad_glUniform4i +typedef void (APIENTRYP PFNGLUNIFORM1FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM1FVPROC glad_glUniform1fv; +#define glUniform1fv glad_glUniform1fv +typedef void (APIENTRYP PFNGLUNIFORM2FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM2FVPROC glad_glUniform2fv; +#define glUniform2fv glad_glUniform2fv +typedef void (APIENTRYP PFNGLUNIFORM3FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM3FVPROC glad_glUniform3fv; +#define glUniform3fv glad_glUniform3fv +typedef void (APIENTRYP PFNGLUNIFORM4FVPROC)(GLint location, GLsizei count, const GLfloat *value); +GLAPI PFNGLUNIFORM4FVPROC glad_glUniform4fv; +#define glUniform4fv glad_glUniform4fv +typedef void (APIENTRYP PFNGLUNIFORM1IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM1IVPROC glad_glUniform1iv; +#define glUniform1iv glad_glUniform1iv +typedef void (APIENTRYP PFNGLUNIFORM2IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM2IVPROC glad_glUniform2iv; +#define glUniform2iv glad_glUniform2iv +typedef void (APIENTRYP PFNGLUNIFORM3IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM3IVPROC glad_glUniform3iv; +#define glUniform3iv glad_glUniform3iv +typedef void (APIENTRYP PFNGLUNIFORM4IVPROC)(GLint location, GLsizei count, const GLint *value); +GLAPI PFNGLUNIFORM4IVPROC glad_glUniform4iv; +#define glUniform4iv glad_glUniform4iv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX2FVPROC glad_glUniformMatrix2fv; +#define glUniformMatrix2fv glad_glUniformMatrix2fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX3FVPROC glad_glUniformMatrix3fv; +#define glUniformMatrix3fv glad_glUniformMatrix3fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX4FVPROC glad_glUniformMatrix4fv; +#define glUniformMatrix4fv glad_glUniformMatrix4fv +typedef void (APIENTRYP PFNGLVALIDATEPROGRAMPROC)(GLuint program); +GLAPI PFNGLVALIDATEPROGRAMPROC glad_glValidateProgram; +#define glValidateProgram glad_glValidateProgram +typedef void (APIENTRYP PFNGLVERTEXATTRIB1DPROC)(GLuint index, GLdouble x); +GLAPI PFNGLVERTEXATTRIB1DPROC glad_glVertexAttrib1d; +#define glVertexAttrib1d glad_glVertexAttrib1d +typedef void (APIENTRYP PFNGLVERTEXATTRIB1DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB1DVPROC glad_glVertexAttrib1dv; +#define glVertexAttrib1dv glad_glVertexAttrib1dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB1FPROC)(GLuint index, GLfloat x); +GLAPI PFNGLVERTEXATTRIB1FPROC glad_glVertexAttrib1f; +#define glVertexAttrib1f glad_glVertexAttrib1f +typedef void (APIENTRYP PFNGLVERTEXATTRIB1FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB1FVPROC glad_glVertexAttrib1fv; +#define glVertexAttrib1fv glad_glVertexAttrib1fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB1SPROC)(GLuint index, GLshort x); +GLAPI PFNGLVERTEXATTRIB1SPROC glad_glVertexAttrib1s; +#define glVertexAttrib1s glad_glVertexAttrib1s +typedef void (APIENTRYP PFNGLVERTEXATTRIB1SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB1SVPROC glad_glVertexAttrib1sv; +#define glVertexAttrib1sv glad_glVertexAttrib1sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB2DPROC)(GLuint index, GLdouble x, GLdouble y); +GLAPI PFNGLVERTEXATTRIB2DPROC glad_glVertexAttrib2d; +#define glVertexAttrib2d glad_glVertexAttrib2d +typedef void (APIENTRYP PFNGLVERTEXATTRIB2DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB2DVPROC glad_glVertexAttrib2dv; +#define glVertexAttrib2dv glad_glVertexAttrib2dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB2FPROC)(GLuint index, GLfloat x, GLfloat y); +GLAPI PFNGLVERTEXATTRIB2FPROC glad_glVertexAttrib2f; +#define glVertexAttrib2f glad_glVertexAttrib2f +typedef void (APIENTRYP PFNGLVERTEXATTRIB2FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB2FVPROC glad_glVertexAttrib2fv; +#define glVertexAttrib2fv glad_glVertexAttrib2fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB2SPROC)(GLuint index, GLshort x, GLshort y); +GLAPI PFNGLVERTEXATTRIB2SPROC glad_glVertexAttrib2s; +#define glVertexAttrib2s glad_glVertexAttrib2s +typedef void (APIENTRYP PFNGLVERTEXATTRIB2SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB2SVPROC glad_glVertexAttrib2sv; +#define glVertexAttrib2sv glad_glVertexAttrib2sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB3DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z); +GLAPI PFNGLVERTEXATTRIB3DPROC glad_glVertexAttrib3d; +#define glVertexAttrib3d glad_glVertexAttrib3d +typedef void (APIENTRYP PFNGLVERTEXATTRIB3DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB3DVPROC glad_glVertexAttrib3dv; +#define glVertexAttrib3dv glad_glVertexAttrib3dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB3FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z); +GLAPI PFNGLVERTEXATTRIB3FPROC glad_glVertexAttrib3f; +#define glVertexAttrib3f glad_glVertexAttrib3f +typedef void (APIENTRYP PFNGLVERTEXATTRIB3FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB3FVPROC glad_glVertexAttrib3fv; +#define glVertexAttrib3fv glad_glVertexAttrib3fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB3SPROC)(GLuint index, GLshort x, GLshort y, GLshort z); +GLAPI PFNGLVERTEXATTRIB3SPROC glad_glVertexAttrib3s; +#define glVertexAttrib3s glad_glVertexAttrib3s +typedef void (APIENTRYP PFNGLVERTEXATTRIB3SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB3SVPROC glad_glVertexAttrib3sv; +#define glVertexAttrib3sv glad_glVertexAttrib3sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NBVPROC)(GLuint index, const GLbyte *v); +GLAPI PFNGLVERTEXATTRIB4NBVPROC glad_glVertexAttrib4Nbv; +#define glVertexAttrib4Nbv glad_glVertexAttrib4Nbv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NIVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIB4NIVPROC glad_glVertexAttrib4Niv; +#define glVertexAttrib4Niv glad_glVertexAttrib4Niv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NSVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB4NSVPROC glad_glVertexAttrib4Nsv; +#define glVertexAttrib4Nsv glad_glVertexAttrib4Nsv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBPROC)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); +GLAPI PFNGLVERTEXATTRIB4NUBPROC glad_glVertexAttrib4Nub; +#define glVertexAttrib4Nub glad_glVertexAttrib4Nub +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBVPROC)(GLuint index, const GLubyte *v); +GLAPI PFNGLVERTEXATTRIB4NUBVPROC glad_glVertexAttrib4Nubv; +#define glVertexAttrib4Nubv glad_glVertexAttrib4Nubv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIB4NUIVPROC glad_glVertexAttrib4Nuiv; +#define glVertexAttrib4Nuiv glad_glVertexAttrib4Nuiv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUSVPROC)(GLuint index, const GLushort *v); +GLAPI PFNGLVERTEXATTRIB4NUSVPROC glad_glVertexAttrib4Nusv; +#define glVertexAttrib4Nusv glad_glVertexAttrib4Nusv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4BVPROC)(GLuint index, const GLbyte *v); +GLAPI PFNGLVERTEXATTRIB4BVPROC glad_glVertexAttrib4bv; +#define glVertexAttrib4bv glad_glVertexAttrib4bv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4DPROC)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +GLAPI PFNGLVERTEXATTRIB4DPROC glad_glVertexAttrib4d; +#define glVertexAttrib4d glad_glVertexAttrib4d +typedef void (APIENTRYP PFNGLVERTEXATTRIB4DVPROC)(GLuint index, const GLdouble *v); +GLAPI PFNGLVERTEXATTRIB4DVPROC glad_glVertexAttrib4dv; +#define glVertexAttrib4dv glad_glVertexAttrib4dv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4FPROC)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +GLAPI PFNGLVERTEXATTRIB4FPROC glad_glVertexAttrib4f; +#define glVertexAttrib4f glad_glVertexAttrib4f +typedef void (APIENTRYP PFNGLVERTEXATTRIB4FVPROC)(GLuint index, const GLfloat *v); +GLAPI PFNGLVERTEXATTRIB4FVPROC glad_glVertexAttrib4fv; +#define glVertexAttrib4fv glad_glVertexAttrib4fv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIB4IVPROC glad_glVertexAttrib4iv; +#define glVertexAttrib4iv glad_glVertexAttrib4iv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4SPROC)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); +GLAPI PFNGLVERTEXATTRIB4SPROC glad_glVertexAttrib4s; +#define glVertexAttrib4s glad_glVertexAttrib4s +typedef void (APIENTRYP PFNGLVERTEXATTRIB4SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIB4SVPROC glad_glVertexAttrib4sv; +#define glVertexAttrib4sv glad_glVertexAttrib4sv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4UBVPROC)(GLuint index, const GLubyte *v); +GLAPI PFNGLVERTEXATTRIB4UBVPROC glad_glVertexAttrib4ubv; +#define glVertexAttrib4ubv glad_glVertexAttrib4ubv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIB4UIVPROC glad_glVertexAttrib4uiv; +#define glVertexAttrib4uiv glad_glVertexAttrib4uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIB4USVPROC)(GLuint index, const GLushort *v); +GLAPI PFNGLVERTEXATTRIB4USVPROC glad_glVertexAttrib4usv; +#define glVertexAttrib4usv glad_glVertexAttrib4usv +typedef void (APIENTRYP PFNGLVERTEXATTRIBPOINTERPROC)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer); +GLAPI PFNGLVERTEXATTRIBPOINTERPROC glad_glVertexAttribPointer; +#define glVertexAttribPointer glad_glVertexAttribPointer +#endif +#ifndef GL_VERSION_2_1 +#define GL_VERSION_2_1 1 +GLAPI int GLAD_GL_VERSION_2_1; +typedef void (APIENTRYP PFNGLUNIFORMMATRIX2X3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX2X3FVPROC glad_glUniformMatrix2x3fv; +#define glUniformMatrix2x3fv glad_glUniformMatrix2x3fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX3X2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX3X2FVPROC glad_glUniformMatrix3x2fv; +#define glUniformMatrix3x2fv glad_glUniformMatrix3x2fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX2X4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX2X4FVPROC glad_glUniformMatrix2x4fv; +#define glUniformMatrix2x4fv glad_glUniformMatrix2x4fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX4X2FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX4X2FVPROC glad_glUniformMatrix4x2fv; +#define glUniformMatrix4x2fv glad_glUniformMatrix4x2fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX3X4FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX3X4FVPROC glad_glUniformMatrix3x4fv; +#define glUniformMatrix3x4fv glad_glUniformMatrix3x4fv +typedef void (APIENTRYP PFNGLUNIFORMMATRIX4X3FVPROC)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +GLAPI PFNGLUNIFORMMATRIX4X3FVPROC glad_glUniformMatrix4x3fv; +#define glUniformMatrix4x3fv glad_glUniformMatrix4x3fv +#endif +#ifndef GL_VERSION_3_0 +#define GL_VERSION_3_0 1 +GLAPI int GLAD_GL_VERSION_3_0; +typedef void (APIENTRYP PFNGLCOLORMASKIPROC)(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a); +GLAPI PFNGLCOLORMASKIPROC glad_glColorMaski; +#define glColorMaski glad_glColorMaski +typedef void (APIENTRYP PFNGLGETBOOLEANI_VPROC)(GLenum target, GLuint index, GLboolean *data); +GLAPI PFNGLGETBOOLEANI_VPROC glad_glGetBooleani_v; +#define glGetBooleani_v glad_glGetBooleani_v +typedef void (APIENTRYP PFNGLGETINTEGERI_VPROC)(GLenum target, GLuint index, GLint *data); +GLAPI PFNGLGETINTEGERI_VPROC glad_glGetIntegeri_v; +#define glGetIntegeri_v glad_glGetIntegeri_v +typedef void (APIENTRYP PFNGLENABLEIPROC)(GLenum target, GLuint index); +GLAPI PFNGLENABLEIPROC glad_glEnablei; +#define glEnablei glad_glEnablei +typedef void (APIENTRYP PFNGLDISABLEIPROC)(GLenum target, GLuint index); +GLAPI PFNGLDISABLEIPROC glad_glDisablei; +#define glDisablei glad_glDisablei +typedef GLboolean (APIENTRYP PFNGLISENABLEDIPROC)(GLenum target, GLuint index); +GLAPI PFNGLISENABLEDIPROC glad_glIsEnabledi; +#define glIsEnabledi glad_glIsEnabledi +typedef void (APIENTRYP PFNGLBEGINTRANSFORMFEEDBACKPROC)(GLenum primitiveMode); +GLAPI PFNGLBEGINTRANSFORMFEEDBACKPROC glad_glBeginTransformFeedback; +#define glBeginTransformFeedback glad_glBeginTransformFeedback +typedef void (APIENTRYP PFNGLENDTRANSFORMFEEDBACKPROC)(void); +GLAPI PFNGLENDTRANSFORMFEEDBACKPROC glad_glEndTransformFeedback; +#define glEndTransformFeedback glad_glEndTransformFeedback +typedef void (APIENTRYP PFNGLBINDBUFFERRANGEPROC)(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); +GLAPI PFNGLBINDBUFFERRANGEPROC glad_glBindBufferRange; +#define glBindBufferRange glad_glBindBufferRange +typedef void (APIENTRYP PFNGLBINDBUFFERBASEPROC)(GLenum target, GLuint index, GLuint buffer); +GLAPI PFNGLBINDBUFFERBASEPROC glad_glBindBufferBase; +#define glBindBufferBase glad_glBindBufferBase +typedef void (APIENTRYP PFNGLTRANSFORMFEEDBACKVARYINGSPROC)(GLuint program, GLsizei count, const GLchar *const*varyings, GLenum bufferMode); +GLAPI PFNGLTRANSFORMFEEDBACKVARYINGSPROC glad_glTransformFeedbackVaryings; +#define glTransformFeedbackVaryings glad_glTransformFeedbackVaryings +typedef void (APIENTRYP PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name); +GLAPI PFNGLGETTRANSFORMFEEDBACKVARYINGPROC glad_glGetTransformFeedbackVarying; +#define glGetTransformFeedbackVarying glad_glGetTransformFeedbackVarying +typedef void (APIENTRYP PFNGLCLAMPCOLORPROC)(GLenum target, GLenum clamp); +GLAPI PFNGLCLAMPCOLORPROC glad_glClampColor; +#define glClampColor glad_glClampColor +typedef void (APIENTRYP PFNGLBEGINCONDITIONALRENDERPROC)(GLuint id, GLenum mode); +GLAPI PFNGLBEGINCONDITIONALRENDERPROC glad_glBeginConditionalRender; +#define glBeginConditionalRender glad_glBeginConditionalRender +typedef void (APIENTRYP PFNGLENDCONDITIONALRENDERPROC)(void); +GLAPI PFNGLENDCONDITIONALRENDERPROC glad_glEndConditionalRender; +#define glEndConditionalRender glad_glEndConditionalRender +typedef void (APIENTRYP PFNGLVERTEXATTRIBIPOINTERPROC)(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer); +GLAPI PFNGLVERTEXATTRIBIPOINTERPROC glad_glVertexAttribIPointer; +#define glVertexAttribIPointer glad_glVertexAttribIPointer +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIIVPROC)(GLuint index, GLenum pname, GLint *params); +GLAPI PFNGLGETVERTEXATTRIBIIVPROC glad_glGetVertexAttribIiv; +#define glGetVertexAttribIiv glad_glGetVertexAttribIiv +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIUIVPROC)(GLuint index, GLenum pname, GLuint *params); +GLAPI PFNGLGETVERTEXATTRIBIUIVPROC glad_glGetVertexAttribIuiv; +#define glGetVertexAttribIuiv glad_glGetVertexAttribIuiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1IPROC)(GLuint index, GLint x); +GLAPI PFNGLVERTEXATTRIBI1IPROC glad_glVertexAttribI1i; +#define glVertexAttribI1i glad_glVertexAttribI1i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2IPROC)(GLuint index, GLint x, GLint y); +GLAPI PFNGLVERTEXATTRIBI2IPROC glad_glVertexAttribI2i; +#define glVertexAttribI2i glad_glVertexAttribI2i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3IPROC)(GLuint index, GLint x, GLint y, GLint z); +GLAPI PFNGLVERTEXATTRIBI3IPROC glad_glVertexAttribI3i; +#define glVertexAttribI3i glad_glVertexAttribI3i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4IPROC)(GLuint index, GLint x, GLint y, GLint z, GLint w); +GLAPI PFNGLVERTEXATTRIBI4IPROC glad_glVertexAttribI4i; +#define glVertexAttribI4i glad_glVertexAttribI4i +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1UIPROC)(GLuint index, GLuint x); +GLAPI PFNGLVERTEXATTRIBI1UIPROC glad_glVertexAttribI1ui; +#define glVertexAttribI1ui glad_glVertexAttribI1ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2UIPROC)(GLuint index, GLuint x, GLuint y); +GLAPI PFNGLVERTEXATTRIBI2UIPROC glad_glVertexAttribI2ui; +#define glVertexAttribI2ui glad_glVertexAttribI2ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3UIPROC)(GLuint index, GLuint x, GLuint y, GLuint z); +GLAPI PFNGLVERTEXATTRIBI3UIPROC glad_glVertexAttribI3ui; +#define glVertexAttribI3ui glad_glVertexAttribI3ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UIPROC)(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); +GLAPI PFNGLVERTEXATTRIBI4UIPROC glad_glVertexAttribI4ui; +#define glVertexAttribI4ui glad_glVertexAttribI4ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI1IVPROC glad_glVertexAttribI1iv; +#define glVertexAttribI1iv glad_glVertexAttribI1iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI2IVPROC glad_glVertexAttribI2iv; +#define glVertexAttribI2iv glad_glVertexAttribI2iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI3IVPROC glad_glVertexAttribI3iv; +#define glVertexAttribI3iv glad_glVertexAttribI3iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4IVPROC)(GLuint index, const GLint *v); +GLAPI PFNGLVERTEXATTRIBI4IVPROC glad_glVertexAttribI4iv; +#define glVertexAttribI4iv glad_glVertexAttribI4iv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI1UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI1UIVPROC glad_glVertexAttribI1uiv; +#define glVertexAttribI1uiv glad_glVertexAttribI1uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI2UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI2UIVPROC glad_glVertexAttribI2uiv; +#define glVertexAttribI2uiv glad_glVertexAttribI2uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI3UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI3UIVPROC glad_glVertexAttribI3uiv; +#define glVertexAttribI3uiv glad_glVertexAttribI3uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UIVPROC)(GLuint index, const GLuint *v); +GLAPI PFNGLVERTEXATTRIBI4UIVPROC glad_glVertexAttribI4uiv; +#define glVertexAttribI4uiv glad_glVertexAttribI4uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4BVPROC)(GLuint index, const GLbyte *v); +GLAPI PFNGLVERTEXATTRIBI4BVPROC glad_glVertexAttribI4bv; +#define glVertexAttribI4bv glad_glVertexAttribI4bv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4SVPROC)(GLuint index, const GLshort *v); +GLAPI PFNGLVERTEXATTRIBI4SVPROC glad_glVertexAttribI4sv; +#define glVertexAttribI4sv glad_glVertexAttribI4sv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4UBVPROC)(GLuint index, const GLubyte *v); +GLAPI PFNGLVERTEXATTRIBI4UBVPROC glad_glVertexAttribI4ubv; +#define glVertexAttribI4ubv glad_glVertexAttribI4ubv +typedef void (APIENTRYP PFNGLVERTEXATTRIBI4USVPROC)(GLuint index, const GLushort *v); +GLAPI PFNGLVERTEXATTRIBI4USVPROC glad_glVertexAttribI4usv; +#define glVertexAttribI4usv glad_glVertexAttribI4usv +typedef void (APIENTRYP PFNGLGETUNIFORMUIVPROC)(GLuint program, GLint location, GLuint *params); +GLAPI PFNGLGETUNIFORMUIVPROC glad_glGetUniformuiv; +#define glGetUniformuiv glad_glGetUniformuiv +typedef void (APIENTRYP PFNGLBINDFRAGDATALOCATIONPROC)(GLuint program, GLuint color, const GLchar *name); +GLAPI PFNGLBINDFRAGDATALOCATIONPROC glad_glBindFragDataLocation; +#define glBindFragDataLocation glad_glBindFragDataLocation +typedef GLint (APIENTRYP PFNGLGETFRAGDATALOCATIONPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETFRAGDATALOCATIONPROC glad_glGetFragDataLocation; +#define glGetFragDataLocation glad_glGetFragDataLocation +typedef void (APIENTRYP PFNGLUNIFORM1UIPROC)(GLint location, GLuint v0); +GLAPI PFNGLUNIFORM1UIPROC glad_glUniform1ui; +#define glUniform1ui glad_glUniform1ui +typedef void (APIENTRYP PFNGLUNIFORM2UIPROC)(GLint location, GLuint v0, GLuint v1); +GLAPI PFNGLUNIFORM2UIPROC glad_glUniform2ui; +#define glUniform2ui glad_glUniform2ui +typedef void (APIENTRYP PFNGLUNIFORM3UIPROC)(GLint location, GLuint v0, GLuint v1, GLuint v2); +GLAPI PFNGLUNIFORM3UIPROC glad_glUniform3ui; +#define glUniform3ui glad_glUniform3ui +typedef void (APIENTRYP PFNGLUNIFORM4UIPROC)(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +GLAPI PFNGLUNIFORM4UIPROC glad_glUniform4ui; +#define glUniform4ui glad_glUniform4ui +typedef void (APIENTRYP PFNGLUNIFORM1UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM1UIVPROC glad_glUniform1uiv; +#define glUniform1uiv glad_glUniform1uiv +typedef void (APIENTRYP PFNGLUNIFORM2UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM2UIVPROC glad_glUniform2uiv; +#define glUniform2uiv glad_glUniform2uiv +typedef void (APIENTRYP PFNGLUNIFORM3UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM3UIVPROC glad_glUniform3uiv; +#define glUniform3uiv glad_glUniform3uiv +typedef void (APIENTRYP PFNGLUNIFORM4UIVPROC)(GLint location, GLsizei count, const GLuint *value); +GLAPI PFNGLUNIFORM4UIVPROC glad_glUniform4uiv; +#define glUniform4uiv glad_glUniform4uiv +typedef void (APIENTRYP PFNGLTEXPARAMETERIIVPROC)(GLenum target, GLenum pname, const GLint *params); +GLAPI PFNGLTEXPARAMETERIIVPROC glad_glTexParameterIiv; +#define glTexParameterIiv glad_glTexParameterIiv +typedef void (APIENTRYP PFNGLTEXPARAMETERIUIVPROC)(GLenum target, GLenum pname, const GLuint *params); +GLAPI PFNGLTEXPARAMETERIUIVPROC glad_glTexParameterIuiv; +#define glTexParameterIuiv glad_glTexParameterIuiv +typedef void (APIENTRYP PFNGLGETTEXPARAMETERIIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETTEXPARAMETERIIVPROC glad_glGetTexParameterIiv; +#define glGetTexParameterIiv glad_glGetTexParameterIiv +typedef void (APIENTRYP PFNGLGETTEXPARAMETERIUIVPROC)(GLenum target, GLenum pname, GLuint *params); +GLAPI PFNGLGETTEXPARAMETERIUIVPROC glad_glGetTexParameterIuiv; +#define glGetTexParameterIuiv glad_glGetTexParameterIuiv +typedef void (APIENTRYP PFNGLCLEARBUFFERIVPROC)(GLenum buffer, GLint drawbuffer, const GLint *value); +GLAPI PFNGLCLEARBUFFERIVPROC glad_glClearBufferiv; +#define glClearBufferiv glad_glClearBufferiv +typedef void (APIENTRYP PFNGLCLEARBUFFERUIVPROC)(GLenum buffer, GLint drawbuffer, const GLuint *value); +GLAPI PFNGLCLEARBUFFERUIVPROC glad_glClearBufferuiv; +#define glClearBufferuiv glad_glClearBufferuiv +typedef void (APIENTRYP PFNGLCLEARBUFFERFVPROC)(GLenum buffer, GLint drawbuffer, const GLfloat *value); +GLAPI PFNGLCLEARBUFFERFVPROC glad_glClearBufferfv; +#define glClearBufferfv glad_glClearBufferfv +typedef void (APIENTRYP PFNGLCLEARBUFFERFIPROC)(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil); +GLAPI PFNGLCLEARBUFFERFIPROC glad_glClearBufferfi; +#define glClearBufferfi glad_glClearBufferfi +typedef const GLubyte * (APIENTRYP PFNGLGETSTRINGIPROC)(GLenum name, GLuint index); +GLAPI PFNGLGETSTRINGIPROC glad_glGetStringi; +#define glGetStringi glad_glGetStringi +typedef GLboolean (APIENTRYP PFNGLISRENDERBUFFERPROC)(GLuint renderbuffer); +GLAPI PFNGLISRENDERBUFFERPROC glad_glIsRenderbuffer; +#define glIsRenderbuffer glad_glIsRenderbuffer +typedef void (APIENTRYP PFNGLBINDRENDERBUFFERPROC)(GLenum target, GLuint renderbuffer); +GLAPI PFNGLBINDRENDERBUFFERPROC glad_glBindRenderbuffer; +#define glBindRenderbuffer glad_glBindRenderbuffer +typedef void (APIENTRYP PFNGLDELETERENDERBUFFERSPROC)(GLsizei n, const GLuint *renderbuffers); +GLAPI PFNGLDELETERENDERBUFFERSPROC glad_glDeleteRenderbuffers; +#define glDeleteRenderbuffers glad_glDeleteRenderbuffers +typedef void (APIENTRYP PFNGLGENRENDERBUFFERSPROC)(GLsizei n, GLuint *renderbuffers); +GLAPI PFNGLGENRENDERBUFFERSPROC glad_glGenRenderbuffers; +#define glGenRenderbuffers glad_glGenRenderbuffers +typedef void (APIENTRYP PFNGLRENDERBUFFERSTORAGEPROC)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height); +GLAPI PFNGLRENDERBUFFERSTORAGEPROC glad_glRenderbufferStorage; +#define glRenderbufferStorage glad_glRenderbufferStorage +typedef void (APIENTRYP PFNGLGETRENDERBUFFERPARAMETERIVPROC)(GLenum target, GLenum pname, GLint *params); +GLAPI PFNGLGETRENDERBUFFERPARAMETERIVPROC glad_glGetRenderbufferParameteriv; +#define glGetRenderbufferParameteriv glad_glGetRenderbufferParameteriv +typedef GLboolean (APIENTRYP PFNGLISFRAMEBUFFERPROC)(GLuint framebuffer); +GLAPI PFNGLISFRAMEBUFFERPROC glad_glIsFramebuffer; +#define glIsFramebuffer glad_glIsFramebuffer +typedef void (APIENTRYP PFNGLBINDFRAMEBUFFERPROC)(GLenum target, GLuint framebuffer); +GLAPI PFNGLBINDFRAMEBUFFERPROC glad_glBindFramebuffer; +#define glBindFramebuffer glad_glBindFramebuffer +typedef void (APIENTRYP PFNGLDELETEFRAMEBUFFERSPROC)(GLsizei n, const GLuint *framebuffers); +GLAPI PFNGLDELETEFRAMEBUFFERSPROC glad_glDeleteFramebuffers; +#define glDeleteFramebuffers glad_glDeleteFramebuffers +typedef void (APIENTRYP PFNGLGENFRAMEBUFFERSPROC)(GLsizei n, GLuint *framebuffers); +GLAPI PFNGLGENFRAMEBUFFERSPROC glad_glGenFramebuffers; +#define glGenFramebuffers glad_glGenFramebuffers +typedef GLenum (APIENTRYP PFNGLCHECKFRAMEBUFFERSTATUSPROC)(GLenum target); +GLAPI PFNGLCHECKFRAMEBUFFERSTATUSPROC glad_glCheckFramebufferStatus; +#define glCheckFramebufferStatus glad_glCheckFramebufferStatus +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE1DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +GLAPI PFNGLFRAMEBUFFERTEXTURE1DPROC glad_glFramebufferTexture1D; +#define glFramebufferTexture1D glad_glFramebufferTexture1D +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE2DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +GLAPI PFNGLFRAMEBUFFERTEXTURE2DPROC glad_glFramebufferTexture2D; +#define glFramebufferTexture2D glad_glFramebufferTexture2D +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE3DPROC)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); +GLAPI PFNGLFRAMEBUFFERTEXTURE3DPROC glad_glFramebufferTexture3D; +#define glFramebufferTexture3D glad_glFramebufferTexture3D +typedef void (APIENTRYP PFNGLFRAMEBUFFERRENDERBUFFERPROC)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +GLAPI PFNGLFRAMEBUFFERRENDERBUFFERPROC glad_glFramebufferRenderbuffer; +#define glFramebufferRenderbuffer glad_glFramebufferRenderbuffer +typedef void (APIENTRYP PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)(GLenum target, GLenum attachment, GLenum pname, GLint *params); +GLAPI PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC glad_glGetFramebufferAttachmentParameteriv; +#define glGetFramebufferAttachmentParameteriv glad_glGetFramebufferAttachmentParameteriv +typedef void (APIENTRYP PFNGLGENERATEMIPMAPPROC)(GLenum target); +GLAPI PFNGLGENERATEMIPMAPPROC glad_glGenerateMipmap; +#define glGenerateMipmap glad_glGenerateMipmap +typedef void (APIENTRYP PFNGLBLITFRAMEBUFFERPROC)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +GLAPI PFNGLBLITFRAMEBUFFERPROC glad_glBlitFramebuffer; +#define glBlitFramebuffer glad_glBlitFramebuffer +typedef void (APIENTRYP PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); +GLAPI PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC glad_glRenderbufferStorageMultisample; +#define glRenderbufferStorageMultisample glad_glRenderbufferStorageMultisample +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURELAYERPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); +GLAPI PFNGLFRAMEBUFFERTEXTURELAYERPROC glad_glFramebufferTextureLayer; +#define glFramebufferTextureLayer glad_glFramebufferTextureLayer +typedef void * (APIENTRYP PFNGLMAPBUFFERRANGEPROC)(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access); +GLAPI PFNGLMAPBUFFERRANGEPROC glad_glMapBufferRange; +#define glMapBufferRange glad_glMapBufferRange +typedef void (APIENTRYP PFNGLFLUSHMAPPEDBUFFERRANGEPROC)(GLenum target, GLintptr offset, GLsizeiptr length); +GLAPI PFNGLFLUSHMAPPEDBUFFERRANGEPROC glad_glFlushMappedBufferRange; +#define glFlushMappedBufferRange glad_glFlushMappedBufferRange +typedef void (APIENTRYP PFNGLBINDVERTEXARRAYPROC)(GLuint array); +GLAPI PFNGLBINDVERTEXARRAYPROC glad_glBindVertexArray; +#define glBindVertexArray glad_glBindVertexArray +typedef void (APIENTRYP PFNGLDELETEVERTEXARRAYSPROC)(GLsizei n, const GLuint *arrays); +GLAPI PFNGLDELETEVERTEXARRAYSPROC glad_glDeleteVertexArrays; +#define glDeleteVertexArrays glad_glDeleteVertexArrays +typedef void (APIENTRYP PFNGLGENVERTEXARRAYSPROC)(GLsizei n, GLuint *arrays); +GLAPI PFNGLGENVERTEXARRAYSPROC glad_glGenVertexArrays; +#define glGenVertexArrays glad_glGenVertexArrays +typedef GLboolean (APIENTRYP PFNGLISVERTEXARRAYPROC)(GLuint array); +GLAPI PFNGLISVERTEXARRAYPROC glad_glIsVertexArray; +#define glIsVertexArray glad_glIsVertexArray +#endif +#ifndef GL_VERSION_3_1 +#define GL_VERSION_3_1 1 +GLAPI int GLAD_GL_VERSION_3_1; +typedef void (APIENTRYP PFNGLDRAWARRAYSINSTANCEDPROC)(GLenum mode, GLint first, GLsizei count, GLsizei instancecount); +GLAPI PFNGLDRAWARRAYSINSTANCEDPROC glad_glDrawArraysInstanced; +#define glDrawArraysInstanced glad_glDrawArraysInstanced +typedef void (APIENTRYP PFNGLDRAWELEMENTSINSTANCEDPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount); +GLAPI PFNGLDRAWELEMENTSINSTANCEDPROC glad_glDrawElementsInstanced; +#define glDrawElementsInstanced glad_glDrawElementsInstanced +typedef void (APIENTRYP PFNGLTEXBUFFERPROC)(GLenum target, GLenum internalformat, GLuint buffer); +GLAPI PFNGLTEXBUFFERPROC glad_glTexBuffer; +#define glTexBuffer glad_glTexBuffer +typedef void (APIENTRYP PFNGLPRIMITIVERESTARTINDEXPROC)(GLuint index); +GLAPI PFNGLPRIMITIVERESTARTINDEXPROC glad_glPrimitiveRestartIndex; +#define glPrimitiveRestartIndex glad_glPrimitiveRestartIndex +typedef void (APIENTRYP PFNGLCOPYBUFFERSUBDATAPROC)(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); +GLAPI PFNGLCOPYBUFFERSUBDATAPROC glad_glCopyBufferSubData; +#define glCopyBufferSubData glad_glCopyBufferSubData +typedef void (APIENTRYP PFNGLGETUNIFORMINDICESPROC)(GLuint program, GLsizei uniformCount, const GLchar *const*uniformNames, GLuint *uniformIndices); +GLAPI PFNGLGETUNIFORMINDICESPROC glad_glGetUniformIndices; +#define glGetUniformIndices glad_glGetUniformIndices +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMSIVPROC)(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params); +GLAPI PFNGLGETACTIVEUNIFORMSIVPROC glad_glGetActiveUniformsiv; +#define glGetActiveUniformsiv glad_glGetActiveUniformsiv +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMNAMEPROC)(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName); +GLAPI PFNGLGETACTIVEUNIFORMNAMEPROC glad_glGetActiveUniformName; +#define glGetActiveUniformName glad_glGetActiveUniformName +typedef GLuint (APIENTRYP PFNGLGETUNIFORMBLOCKINDEXPROC)(GLuint program, const GLchar *uniformBlockName); +GLAPI PFNGLGETUNIFORMBLOCKINDEXPROC glad_glGetUniformBlockIndex; +#define glGetUniformBlockIndex glad_glGetUniformBlockIndex +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMBLOCKIVPROC)(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params); +GLAPI PFNGLGETACTIVEUNIFORMBLOCKIVPROC glad_glGetActiveUniformBlockiv; +#define glGetActiveUniformBlockiv glad_glGetActiveUniformBlockiv +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC)(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName); +GLAPI PFNGLGETACTIVEUNIFORMBLOCKNAMEPROC glad_glGetActiveUniformBlockName; +#define glGetActiveUniformBlockName glad_glGetActiveUniformBlockName +typedef void (APIENTRYP PFNGLUNIFORMBLOCKBINDINGPROC)(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding); +GLAPI PFNGLUNIFORMBLOCKBINDINGPROC glad_glUniformBlockBinding; +#define glUniformBlockBinding glad_glUniformBlockBinding +#endif +#ifndef GL_VERSION_3_2 +#define GL_VERSION_3_2 1 +GLAPI int GLAD_GL_VERSION_3_2; +typedef void (APIENTRYP PFNGLDRAWELEMENTSBASEVERTEXPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex); +GLAPI PFNGLDRAWELEMENTSBASEVERTEXPROC glad_glDrawElementsBaseVertex; +#define glDrawElementsBaseVertex glad_glDrawElementsBaseVertex +typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex); +GLAPI PFNGLDRAWRANGEELEMENTSBASEVERTEXPROC glad_glDrawRangeElementsBaseVertex; +#define glDrawRangeElementsBaseVertex glad_glDrawRangeElementsBaseVertex +typedef void (APIENTRYP PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex); +GLAPI PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXPROC glad_glDrawElementsInstancedBaseVertex; +#define glDrawElementsInstancedBaseVertex glad_glDrawElementsInstancedBaseVertex +typedef void (APIENTRYP PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC)(GLenum mode, const GLsizei *count, GLenum type, const void *const*indices, GLsizei drawcount, const GLint *basevertex); +GLAPI PFNGLMULTIDRAWELEMENTSBASEVERTEXPROC glad_glMultiDrawElementsBaseVertex; +#define glMultiDrawElementsBaseVertex glad_glMultiDrawElementsBaseVertex +typedef void (APIENTRYP PFNGLPROVOKINGVERTEXPROC)(GLenum mode); +GLAPI PFNGLPROVOKINGVERTEXPROC glad_glProvokingVertex; +#define glProvokingVertex glad_glProvokingVertex +typedef GLsync (APIENTRYP PFNGLFENCESYNCPROC)(GLenum condition, GLbitfield flags); +GLAPI PFNGLFENCESYNCPROC glad_glFenceSync; +#define glFenceSync glad_glFenceSync +typedef GLboolean (APIENTRYP PFNGLISSYNCPROC)(GLsync sync); +GLAPI PFNGLISSYNCPROC glad_glIsSync; +#define glIsSync glad_glIsSync +typedef void (APIENTRYP PFNGLDELETESYNCPROC)(GLsync sync); +GLAPI PFNGLDELETESYNCPROC glad_glDeleteSync; +#define glDeleteSync glad_glDeleteSync +typedef GLenum (APIENTRYP PFNGLCLIENTWAITSYNCPROC)(GLsync sync, GLbitfield flags, GLuint64 timeout); +GLAPI PFNGLCLIENTWAITSYNCPROC glad_glClientWaitSync; +#define glClientWaitSync glad_glClientWaitSync +typedef void (APIENTRYP PFNGLWAITSYNCPROC)(GLsync sync, GLbitfield flags, GLuint64 timeout); +GLAPI PFNGLWAITSYNCPROC glad_glWaitSync; +#define glWaitSync glad_glWaitSync +typedef void (APIENTRYP PFNGLGETINTEGER64VPROC)(GLenum pname, GLint64 *data); +GLAPI PFNGLGETINTEGER64VPROC glad_glGetInteger64v; +#define glGetInteger64v glad_glGetInteger64v +typedef void (APIENTRYP PFNGLGETSYNCIVPROC)(GLsync sync, GLenum pname, GLsizei count, GLsizei *length, GLint *values); +GLAPI PFNGLGETSYNCIVPROC glad_glGetSynciv; +#define glGetSynciv glad_glGetSynciv +typedef void (APIENTRYP PFNGLGETINTEGER64I_VPROC)(GLenum target, GLuint index, GLint64 *data); +GLAPI PFNGLGETINTEGER64I_VPROC glad_glGetInteger64i_v; +#define glGetInteger64i_v glad_glGetInteger64i_v +typedef void (APIENTRYP PFNGLGETBUFFERPARAMETERI64VPROC)(GLenum target, GLenum pname, GLint64 *params); +GLAPI PFNGLGETBUFFERPARAMETERI64VPROC glad_glGetBufferParameteri64v; +#define glGetBufferParameteri64v glad_glGetBufferParameteri64v +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTUREPROC)(GLenum target, GLenum attachment, GLuint texture, GLint level); +GLAPI PFNGLFRAMEBUFFERTEXTUREPROC glad_glFramebufferTexture; +#define glFramebufferTexture glad_glFramebufferTexture +typedef void (APIENTRYP PFNGLTEXIMAGE2DMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations); +GLAPI PFNGLTEXIMAGE2DMULTISAMPLEPROC glad_glTexImage2DMultisample; +#define glTexImage2DMultisample glad_glTexImage2DMultisample +typedef void (APIENTRYP PFNGLTEXIMAGE3DMULTISAMPLEPROC)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations); +GLAPI PFNGLTEXIMAGE3DMULTISAMPLEPROC glad_glTexImage3DMultisample; +#define glTexImage3DMultisample glad_glTexImage3DMultisample +typedef void (APIENTRYP PFNGLGETMULTISAMPLEFVPROC)(GLenum pname, GLuint index, GLfloat *val); +GLAPI PFNGLGETMULTISAMPLEFVPROC glad_glGetMultisamplefv; +#define glGetMultisamplefv glad_glGetMultisamplefv +typedef void (APIENTRYP PFNGLSAMPLEMASKIPROC)(GLuint maskNumber, GLbitfield mask); +GLAPI PFNGLSAMPLEMASKIPROC glad_glSampleMaski; +#define glSampleMaski glad_glSampleMaski +#endif +#ifndef GL_VERSION_3_3 +#define GL_VERSION_3_3 1 +GLAPI int GLAD_GL_VERSION_3_3; +typedef void (APIENTRYP PFNGLBINDFRAGDATALOCATIONINDEXEDPROC)(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name); +GLAPI PFNGLBINDFRAGDATALOCATIONINDEXEDPROC glad_glBindFragDataLocationIndexed; +#define glBindFragDataLocationIndexed glad_glBindFragDataLocationIndexed +typedef GLint (APIENTRYP PFNGLGETFRAGDATAINDEXPROC)(GLuint program, const GLchar *name); +GLAPI PFNGLGETFRAGDATAINDEXPROC glad_glGetFragDataIndex; +#define glGetFragDataIndex glad_glGetFragDataIndex +typedef void (APIENTRYP PFNGLGENSAMPLERSPROC)(GLsizei count, GLuint *samplers); +GLAPI PFNGLGENSAMPLERSPROC glad_glGenSamplers; +#define glGenSamplers glad_glGenSamplers +typedef void (APIENTRYP PFNGLDELETESAMPLERSPROC)(GLsizei count, const GLuint *samplers); +GLAPI PFNGLDELETESAMPLERSPROC glad_glDeleteSamplers; +#define glDeleteSamplers glad_glDeleteSamplers +typedef GLboolean (APIENTRYP PFNGLISSAMPLERPROC)(GLuint sampler); +GLAPI PFNGLISSAMPLERPROC glad_glIsSampler; +#define glIsSampler glad_glIsSampler +typedef void (APIENTRYP PFNGLBINDSAMPLERPROC)(GLuint unit, GLuint sampler); +GLAPI PFNGLBINDSAMPLERPROC glad_glBindSampler; +#define glBindSampler glad_glBindSampler +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIPROC)(GLuint sampler, GLenum pname, GLint param); +GLAPI PFNGLSAMPLERPARAMETERIPROC glad_glSamplerParameteri; +#define glSamplerParameteri glad_glSamplerParameteri +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIVPROC)(GLuint sampler, GLenum pname, const GLint *param); +GLAPI PFNGLSAMPLERPARAMETERIVPROC glad_glSamplerParameteriv; +#define glSamplerParameteriv glad_glSamplerParameteriv +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERFPROC)(GLuint sampler, GLenum pname, GLfloat param); +GLAPI PFNGLSAMPLERPARAMETERFPROC glad_glSamplerParameterf; +#define glSamplerParameterf glad_glSamplerParameterf +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERFVPROC)(GLuint sampler, GLenum pname, const GLfloat *param); +GLAPI PFNGLSAMPLERPARAMETERFVPROC glad_glSamplerParameterfv; +#define glSamplerParameterfv glad_glSamplerParameterfv +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIIVPROC)(GLuint sampler, GLenum pname, const GLint *param); +GLAPI PFNGLSAMPLERPARAMETERIIVPROC glad_glSamplerParameterIiv; +#define glSamplerParameterIiv glad_glSamplerParameterIiv +typedef void (APIENTRYP PFNGLSAMPLERPARAMETERIUIVPROC)(GLuint sampler, GLenum pname, const GLuint *param); +GLAPI PFNGLSAMPLERPARAMETERIUIVPROC glad_glSamplerParameterIuiv; +#define glSamplerParameterIuiv glad_glSamplerParameterIuiv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIVPROC)(GLuint sampler, GLenum pname, GLint *params); +GLAPI PFNGLGETSAMPLERPARAMETERIVPROC glad_glGetSamplerParameteriv; +#define glGetSamplerParameteriv glad_glGetSamplerParameteriv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIIVPROC)(GLuint sampler, GLenum pname, GLint *params); +GLAPI PFNGLGETSAMPLERPARAMETERIIVPROC glad_glGetSamplerParameterIiv; +#define glGetSamplerParameterIiv glad_glGetSamplerParameterIiv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERFVPROC)(GLuint sampler, GLenum pname, GLfloat *params); +GLAPI PFNGLGETSAMPLERPARAMETERFVPROC glad_glGetSamplerParameterfv; +#define glGetSamplerParameterfv glad_glGetSamplerParameterfv +typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIUIVPROC)(GLuint sampler, GLenum pname, GLuint *params); +GLAPI PFNGLGETSAMPLERPARAMETERIUIVPROC glad_glGetSamplerParameterIuiv; +#define glGetSamplerParameterIuiv glad_glGetSamplerParameterIuiv +typedef void (APIENTRYP PFNGLQUERYCOUNTERPROC)(GLuint id, GLenum target); +GLAPI PFNGLQUERYCOUNTERPROC glad_glQueryCounter; +#define glQueryCounter glad_glQueryCounter +typedef void (APIENTRYP PFNGLGETQUERYOBJECTI64VPROC)(GLuint id, GLenum pname, GLint64 *params); +GLAPI PFNGLGETQUERYOBJECTI64VPROC glad_glGetQueryObjecti64v; +#define glGetQueryObjecti64v glad_glGetQueryObjecti64v +typedef void (APIENTRYP PFNGLGETQUERYOBJECTUI64VPROC)(GLuint id, GLenum pname, GLuint64 *params); +GLAPI PFNGLGETQUERYOBJECTUI64VPROC glad_glGetQueryObjectui64v; +#define glGetQueryObjectui64v glad_glGetQueryObjectui64v +typedef void (APIENTRYP PFNGLVERTEXATTRIBDIVISORPROC)(GLuint index, GLuint divisor); +GLAPI PFNGLVERTEXATTRIBDIVISORPROC glad_glVertexAttribDivisor; +#define glVertexAttribDivisor glad_glVertexAttribDivisor +typedef void (APIENTRYP PFNGLVERTEXATTRIBP1UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP1UIPROC glad_glVertexAttribP1ui; +#define glVertexAttribP1ui glad_glVertexAttribP1ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP1UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP1UIVPROC glad_glVertexAttribP1uiv; +#define glVertexAttribP1uiv glad_glVertexAttribP1uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBP2UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP2UIPROC glad_glVertexAttribP2ui; +#define glVertexAttribP2ui glad_glVertexAttribP2ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP2UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP2UIVPROC glad_glVertexAttribP2uiv; +#define glVertexAttribP2uiv glad_glVertexAttribP2uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBP3UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP3UIPROC glad_glVertexAttribP3ui; +#define glVertexAttribP3ui glad_glVertexAttribP3ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP3UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP3UIVPROC glad_glVertexAttribP3uiv; +#define glVertexAttribP3uiv glad_glVertexAttribP3uiv +typedef void (APIENTRYP PFNGLVERTEXATTRIBP4UIPROC)(GLuint index, GLenum type, GLboolean normalized, GLuint value); +GLAPI PFNGLVERTEXATTRIBP4UIPROC glad_glVertexAttribP4ui; +#define glVertexAttribP4ui glad_glVertexAttribP4ui +typedef void (APIENTRYP PFNGLVERTEXATTRIBP4UIVPROC)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value); +GLAPI PFNGLVERTEXATTRIBP4UIVPROC glad_glVertexAttribP4uiv; +#define glVertexAttribP4uiv glad_glVertexAttribP4uiv +typedef void (APIENTRYP PFNGLVERTEXP2UIPROC)(GLenum type, GLuint value); +GLAPI PFNGLVERTEXP2UIPROC glad_glVertexP2ui; +#define glVertexP2ui glad_glVertexP2ui +typedef void (APIENTRYP PFNGLVERTEXP2UIVPROC)(GLenum type, const GLuint *value); +GLAPI PFNGLVERTEXP2UIVPROC glad_glVertexP2uiv; +#define glVertexP2uiv glad_glVertexP2uiv +typedef void (APIENTRYP PFNGLVERTEXP3UIPROC)(GLenum type, GLuint value); +GLAPI PFNGLVERTEXP3UIPROC glad_glVertexP3ui; +#define glVertexP3ui glad_glVertexP3ui +typedef void (APIENTRYP PFNGLVERTEXP3UIVPROC)(GLenum type, const GLuint *value); +GLAPI PFNGLVERTEXP3UIVPROC glad_glVertexP3uiv; +#define glVertexP3uiv glad_glVertexP3uiv +typedef void (APIENTRYP PFNGLVERTEXP4UIPROC)(GLenum type, GLuint value); +GLAPI PFNGLVERTEXP4UIPROC glad_glVertexP4ui; +#define glVertexP4ui glad_glVertexP4ui +typedef void (APIENTRYP PFNGLVERTEXP4UIVPROC)(GLenum type, const GLuint *value); +GLAPI PFNGLVERTEXP4UIVPROC glad_glVertexP4uiv; +#define glVertexP4uiv glad_glVertexP4uiv +typedef void (APIENTRYP PFNGLTEXCOORDP1UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP1UIPROC glad_glTexCoordP1ui; +#define glTexCoordP1ui glad_glTexCoordP1ui +typedef void (APIENTRYP PFNGLTEXCOORDP1UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP1UIVPROC glad_glTexCoordP1uiv; +#define glTexCoordP1uiv glad_glTexCoordP1uiv +typedef void (APIENTRYP PFNGLTEXCOORDP2UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP2UIPROC glad_glTexCoordP2ui; +#define glTexCoordP2ui glad_glTexCoordP2ui +typedef void (APIENTRYP PFNGLTEXCOORDP2UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP2UIVPROC glad_glTexCoordP2uiv; +#define glTexCoordP2uiv glad_glTexCoordP2uiv +typedef void (APIENTRYP PFNGLTEXCOORDP3UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP3UIPROC glad_glTexCoordP3ui; +#define glTexCoordP3ui glad_glTexCoordP3ui +typedef void (APIENTRYP PFNGLTEXCOORDP3UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP3UIVPROC glad_glTexCoordP3uiv; +#define glTexCoordP3uiv glad_glTexCoordP3uiv +typedef void (APIENTRYP PFNGLTEXCOORDP4UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLTEXCOORDP4UIPROC glad_glTexCoordP4ui; +#define glTexCoordP4ui glad_glTexCoordP4ui +typedef void (APIENTRYP PFNGLTEXCOORDP4UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLTEXCOORDP4UIVPROC glad_glTexCoordP4uiv; +#define glTexCoordP4uiv glad_glTexCoordP4uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP1UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP1UIPROC glad_glMultiTexCoordP1ui; +#define glMultiTexCoordP1ui glad_glMultiTexCoordP1ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP1UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP1UIVPROC glad_glMultiTexCoordP1uiv; +#define glMultiTexCoordP1uiv glad_glMultiTexCoordP1uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP2UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP2UIPROC glad_glMultiTexCoordP2ui; +#define glMultiTexCoordP2ui glad_glMultiTexCoordP2ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP2UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP2UIVPROC glad_glMultiTexCoordP2uiv; +#define glMultiTexCoordP2uiv glad_glMultiTexCoordP2uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP3UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP3UIPROC glad_glMultiTexCoordP3ui; +#define glMultiTexCoordP3ui glad_glMultiTexCoordP3ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP3UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP3UIVPROC glad_glMultiTexCoordP3uiv; +#define glMultiTexCoordP3uiv glad_glMultiTexCoordP3uiv +typedef void (APIENTRYP PFNGLMULTITEXCOORDP4UIPROC)(GLenum texture, GLenum type, GLuint coords); +GLAPI PFNGLMULTITEXCOORDP4UIPROC glad_glMultiTexCoordP4ui; +#define glMultiTexCoordP4ui glad_glMultiTexCoordP4ui +typedef void (APIENTRYP PFNGLMULTITEXCOORDP4UIVPROC)(GLenum texture, GLenum type, const GLuint *coords); +GLAPI PFNGLMULTITEXCOORDP4UIVPROC glad_glMultiTexCoordP4uiv; +#define glMultiTexCoordP4uiv glad_glMultiTexCoordP4uiv +typedef void (APIENTRYP PFNGLNORMALP3UIPROC)(GLenum type, GLuint coords); +GLAPI PFNGLNORMALP3UIPROC glad_glNormalP3ui; +#define glNormalP3ui glad_glNormalP3ui +typedef void (APIENTRYP PFNGLNORMALP3UIVPROC)(GLenum type, const GLuint *coords); +GLAPI PFNGLNORMALP3UIVPROC glad_glNormalP3uiv; +#define glNormalP3uiv glad_glNormalP3uiv +typedef void (APIENTRYP PFNGLCOLORP3UIPROC)(GLenum type, GLuint color); +GLAPI PFNGLCOLORP3UIPROC glad_glColorP3ui; +#define glColorP3ui glad_glColorP3ui +typedef void (APIENTRYP PFNGLCOLORP3UIVPROC)(GLenum type, const GLuint *color); +GLAPI PFNGLCOLORP3UIVPROC glad_glColorP3uiv; +#define glColorP3uiv glad_glColorP3uiv +typedef void (APIENTRYP PFNGLCOLORP4UIPROC)(GLenum type, GLuint color); +GLAPI PFNGLCOLORP4UIPROC glad_glColorP4ui; +#define glColorP4ui glad_glColorP4ui +typedef void (APIENTRYP PFNGLCOLORP4UIVPROC)(GLenum type, const GLuint *color); +GLAPI PFNGLCOLORP4UIVPROC glad_glColorP4uiv; +#define glColorP4uiv glad_glColorP4uiv +typedef void (APIENTRYP PFNGLSECONDARYCOLORP3UIPROC)(GLenum type, GLuint color); +GLAPI PFNGLSECONDARYCOLORP3UIPROC glad_glSecondaryColorP3ui; +#define glSecondaryColorP3ui glad_glSecondaryColorP3ui +typedef void (APIENTRYP PFNGLSECONDARYCOLORP3UIVPROC)(GLenum type, const GLuint *color); +GLAPI PFNGLSECONDARYCOLORP3UIVPROC glad_glSecondaryColorP3uiv; +#define glSecondaryColorP3uiv glad_glSecondaryColorP3uiv +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/glfw3.dll b/glfw3.dll new file mode 100644 index 0000000000000000000000000000000000000000..691e77184aa202df532ad16dc4c9699922a39912 GIT binary patch literal 415744 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%0Acc>y>m1OM=J<$>r}8>EJ0CTU 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 literal 0 HcmV?d00001 diff --git a/glfw3.h b/glfw3.h new file mode 100644 index 0000000..d074de1 --- /dev/null +++ b/glfw3.h @@ -0,0 +1,5913 @@ +/************************************************************************* + * GLFW 3.3 - www.glfw.org + * A library for OpenGL, window and input + *------------------------------------------------------------------------ + * Copyright (c) 2002-2006 Marcus Geelnard + * Copyright (c) 2006-2019 Camilla Löwy + * + * This software is provided 'as-is', without any express or implied + * warranty. In no event will the authors be held liable for any damages + * arising from the use of this software. + * + * Permission is granted to anyone to use this software for any purpose, + * including commercial applications, and to alter it and redistribute it + * freely, subject to the following restrictions: + * + * 1. The origin of this software must not be misrepresented; you must not + * claim that you wrote the original software. If you use this software + * in a product, an acknowledgment in the product documentation would + * be appreciated but is not required. + * + * 2. Altered source versions must be plainly marked as such, and must not + * be misrepresented as being the original software. + * + * 3. This notice may not be removed or altered from any source + * distribution. + * + *************************************************************************/ + +#ifndef _glfw3_h_ +#define _glfw3_h_ + +#ifdef __cplusplus +extern "C" { +#endif + + +/************************************************************************* + * Doxygen documentation + *************************************************************************/ + +/*! @file glfw3.h + * @brief The header of the GLFW 3 API. + * + * This is the header file of the GLFW 3 API. It defines all its types and + * declares all its functions. + * + * For more information about how to use this file, see @ref build_include. + */ +/*! @defgroup context Context reference + * @brief Functions and types related to OpenGL and OpenGL ES contexts. + * + * This is the reference documentation for OpenGL and OpenGL ES context related + * functions. For more task-oriented information, see the @ref context_guide. + */ +/*! @defgroup vulkan Vulkan support reference + * @brief Functions and types related to Vulkan. + * + * This is the reference documentation for Vulkan related functions and types. + * For more task-oriented information, see the @ref vulkan_guide. + */ +/*! @defgroup init Initialization, version and error reference + * @brief Functions and types related to initialization and error handling. + * + * This is the reference documentation for initialization and termination of + * the library, version management and error handling. For more task-oriented + * information, see the @ref intro_guide. + */ +/*! @defgroup input Input reference + * @brief Functions and types related to input handling. + * + * This is the reference documentation for input related functions and types. + * For more task-oriented information, see the @ref input_guide. + */ +/*! @defgroup monitor Monitor reference + * @brief Functions and types related to monitors. + * + * This is the reference documentation for monitor related functions and types. + * For more task-oriented information, see the @ref monitor_guide. + */ +/*! @defgroup window Window reference + * @brief Functions and types related to windows. + * + * This is the reference documentation for window related functions and types, + * including creation, deletion and event polling. For more task-oriented + * information, see the @ref window_guide. + */ + + +/************************************************************************* + * Compiler- and platform-specific preprocessor work + *************************************************************************/ + +/* If we are we on Windows, we want a single define for it. + */ +#if !defined(_WIN32) && (defined(__WIN32__) || defined(WIN32) || defined(__MINGW32__)) + #define _WIN32 +#endif /* _WIN32 */ + +/* Include because most Windows GLU headers need wchar_t and + * the macOS OpenGL header blocks the definition of ptrdiff_t by glext.h. + * Include it unconditionally to avoid surprising side-effects. + */ +#include + +/* Include because it is needed by Vulkan and related functions. + * Include it unconditionally to avoid surprising side-effects. + */ +#include + +#if defined(GLFW_INCLUDE_VULKAN) + #include +#endif /* Vulkan header */ + +/* The Vulkan header may have indirectly included windows.h (because of + * VK_USE_PLATFORM_WIN32_KHR) so we offer our replacement symbols after it. + */ + +/* It is customary to use APIENTRY for OpenGL function pointer declarations on + * all platforms. Additionally, the Windows OpenGL header needs APIENTRY. + */ +#if !defined(APIENTRY) + #if defined(_WIN32) + #define APIENTRY __stdcall + #else + #define APIENTRY + #endif + #define GLFW_APIENTRY_DEFINED +#endif /* APIENTRY */ + +/* Some Windows OpenGL headers need this. + */ +#if !defined(WINGDIAPI) && defined(_WIN32) + #define WINGDIAPI __declspec(dllimport) + #define GLFW_WINGDIAPI_DEFINED +#endif /* WINGDIAPI */ + +/* Some Windows GLU headers need this. + */ +#if !defined(CALLBACK) && defined(_WIN32) + #define CALLBACK __stdcall + #define GLFW_CALLBACK_DEFINED +#endif /* CALLBACK */ + +/* Include the chosen OpenGL or OpenGL ES headers. + */ +#if defined(GLFW_INCLUDE_ES1) + + #include + #if defined(GLFW_INCLUDE_GLEXT) + #include + #endif + +#elif defined(GLFW_INCLUDE_ES2) + + #include + #if defined(GLFW_INCLUDE_GLEXT) + #include + #endif + +#elif defined(GLFW_INCLUDE_ES3) + + #include + #if defined(GLFW_INCLUDE_GLEXT) + #include + #endif + +#elif defined(GLFW_INCLUDE_ES31) + + #include + #if defined(GLFW_INCLUDE_GLEXT) + #include + #endif + +#elif defined(GLFW_INCLUDE_ES32) + + #include + #if defined(GLFW_INCLUDE_GLEXT) + #include + #endif + +#elif defined(GLFW_INCLUDE_GLCOREARB) + + #if defined(__APPLE__) + + #include + #if defined(GLFW_INCLUDE_GLEXT) + #include + #endif /*GLFW_INCLUDE_GLEXT*/ + + #else /*__APPLE__*/ + + #include + #if defined(GLFW_INCLUDE_GLEXT) + #include + #endif + + #endif /*__APPLE__*/ + +#elif defined(GLFW_INCLUDE_GLU) + + #if defined(__APPLE__) + + #if defined(GLFW_INCLUDE_GLU) + #include + #endif + + #else /*__APPLE__*/ + + #if defined(GLFW_INCLUDE_GLU) + #include + #endif + + #endif /*__APPLE__*/ + +#elif !defined(GLFW_INCLUDE_NONE) && \ + !defined(__gl_h_) && \ + !defined(__gles1_gl_h_) && \ + !defined(__gles2_gl2_h_) && \ + !defined(__gles2_gl3_h_) && \ + !defined(__gles2_gl31_h_) && \ + !defined(__gles2_gl32_h_) && \ + !defined(__gl_glcorearb_h_) && \ + !defined(__gl2_h_) /*legacy*/ && \ + !defined(__gl3_h_) /*legacy*/ && \ + !defined(__gl31_h_) /*legacy*/ && \ + !defined(__gl32_h_) /*legacy*/ && \ + !defined(__glcorearb_h_) /*legacy*/ && \ + !defined(__GL_H__) /*non-standard*/ && \ + !defined(__gltypes_h_) /*non-standard*/ && \ + !defined(__glee_h_) /*non-standard*/ + + #if defined(__APPLE__) + + #if !defined(GLFW_INCLUDE_GLEXT) + #define GL_GLEXT_LEGACY + #endif + #include + + #else /*__APPLE__*/ + + #include + #if defined(GLFW_INCLUDE_GLEXT) + #include + #endif + + #endif /*__APPLE__*/ + +#endif /* OpenGL and OpenGL ES headers */ + +#if defined(GLFW_DLL) && defined(_GLFW_BUILD_DLL) + /* GLFW_DLL must be defined by applications that are linking against the DLL + * version of the GLFW library. _GLFW_BUILD_DLL is defined by the GLFW + * configuration header when compiling the DLL version of the library. + */ + #error "You must not have both GLFW_DLL and _GLFW_BUILD_DLL defined" +#endif + +/* GLFWAPI is used to declare public API functions for export + * from the DLL / shared library / dynamic library. + */ +#if defined(_WIN32) && defined(_GLFW_BUILD_DLL) + /* We are building GLFW as a Win32 DLL */ + #define GLFWAPI __declspec(dllexport) +#elif defined(_WIN32) && defined(GLFW_DLL) + /* We are calling GLFW as a Win32 DLL */ + #define GLFWAPI __declspec(dllimport) +#elif defined(__GNUC__) && defined(_GLFW_BUILD_DLL) + /* We are building GLFW as a shared / dynamic library */ + #define GLFWAPI __attribute__((visibility("default"))) +#else + /* We are building or calling GLFW as a static library */ + #define GLFWAPI +#endif + + +/************************************************************************* + * GLFW API tokens + *************************************************************************/ + +/*! @name GLFW version macros + * @{ */ +/*! @brief The major version number of the GLFW header. + * + * The major version number of the GLFW header. This is incremented when the + * API is changed in non-compatible ways. + * @ingroup init + */ +#define GLFW_VERSION_MAJOR 3 +/*! @brief The minor version number of the GLFW header. + * + * The minor version number of the GLFW header. This is incremented when + * features are added to the API but it remains backward-compatible. + * @ingroup init + */ +#define GLFW_VERSION_MINOR 3 +/*! @brief The revision number of the GLFW header. + * + * The revision number of the GLFW header. This is incremented when a bug fix + * release is made that does not contain any API changes. + * @ingroup init + */ +#define GLFW_VERSION_REVISION 7 +/*! @} */ + +/*! @brief One. + * + * This is only semantic sugar for the number 1. You can instead use `1` or + * `true` or `_True` or `GL_TRUE` or `VK_TRUE` or anything else that is equal + * to one. + * + * @ingroup init + */ +#define GLFW_TRUE 1 +/*! @brief Zero. + * + * This is only semantic sugar for the number 0. You can instead use `0` or + * `false` or `_False` or `GL_FALSE` or `VK_FALSE` or anything else that is + * equal to zero. + * + * @ingroup init + */ +#define GLFW_FALSE 0 + +/*! @name Key and button actions + * @{ */ +/*! @brief The key or mouse button was released. + * + * The key or mouse button was released. + * + * @ingroup input + */ +#define GLFW_RELEASE 0 +/*! @brief The key or mouse button was pressed. + * + * The key or mouse button was pressed. + * + * @ingroup input + */ +#define GLFW_PRESS 1 +/*! @brief The key was held down until it repeated. + * + * The key was held down until it repeated. + * + * @ingroup input + */ +#define GLFW_REPEAT 2 +/*! @} */ + +/*! @defgroup hat_state Joystick hat states + * @brief Joystick hat states. + * + * See [joystick hat input](@ref joystick_hat) for how these are used. + * + * @ingroup input + * @{ */ +#define GLFW_HAT_CENTERED 0 +#define GLFW_HAT_UP 1 +#define GLFW_HAT_RIGHT 2 +#define GLFW_HAT_DOWN 4 +#define GLFW_HAT_LEFT 8 +#define GLFW_HAT_RIGHT_UP (GLFW_HAT_RIGHT | GLFW_HAT_UP) +#define GLFW_HAT_RIGHT_DOWN (GLFW_HAT_RIGHT | GLFW_HAT_DOWN) +#define GLFW_HAT_LEFT_UP (GLFW_HAT_LEFT | GLFW_HAT_UP) +#define GLFW_HAT_LEFT_DOWN (GLFW_HAT_LEFT | GLFW_HAT_DOWN) +/*! @} */ + +/*! @defgroup keys Keyboard keys + * @brief Keyboard key IDs. + * + * See [key input](@ref input_key) for how these are used. + * + * These key codes are inspired by the _USB HID Usage Tables v1.12_ (p. 53-60), + * but re-arranged to map to 7-bit ASCII for printable keys (function keys are + * put in the 256+ range). + * + * The naming of the key codes follow these rules: + * - The US keyboard layout is used + * - Names of printable alpha-numeric characters are used (e.g. "A", "R", + * "3", etc.) + * - For non-alphanumeric characters, Unicode:ish names are used (e.g. + * "COMMA", "LEFT_SQUARE_BRACKET", etc.). Note that some names do not + * correspond to the Unicode standard (usually for brevity) + * - Keys that lack a clear US mapping are named "WORLD_x" + * - For non-printable keys, custom names are used (e.g. "F4", + * "BACKSPACE", etc.) + * + * @ingroup input + * @{ + */ + +/* The unknown key */ +#define GLFW_KEY_UNKNOWN -1 + +/* Printable keys */ +#define GLFW_KEY_SPACE 32 +#define GLFW_KEY_APOSTROPHE 39 /* ' */ +#define GLFW_KEY_COMMA 44 /* , */ +#define GLFW_KEY_MINUS 45 /* - */ +#define GLFW_KEY_PERIOD 46 /* . */ +#define GLFW_KEY_SLASH 47 /* / */ +#define GLFW_KEY_0 48 +#define GLFW_KEY_1 49 +#define GLFW_KEY_2 50 +#define GLFW_KEY_3 51 +#define GLFW_KEY_4 52 +#define GLFW_KEY_5 53 +#define GLFW_KEY_6 54 +#define GLFW_KEY_7 55 +#define GLFW_KEY_8 56 +#define GLFW_KEY_9 57 +#define GLFW_KEY_SEMICOLON 59 /* ; */ +#define GLFW_KEY_EQUAL 61 /* = */ +#define GLFW_KEY_A 65 +#define GLFW_KEY_B 66 +#define GLFW_KEY_C 67 +#define GLFW_KEY_D 68 +#define GLFW_KEY_E 69 +#define GLFW_KEY_F 70 +#define GLFW_KEY_G 71 +#define GLFW_KEY_H 72 +#define GLFW_KEY_I 73 +#define GLFW_KEY_J 74 +#define GLFW_KEY_K 75 +#define GLFW_KEY_L 76 +#define GLFW_KEY_M 77 +#define GLFW_KEY_N 78 +#define GLFW_KEY_O 79 +#define GLFW_KEY_P 80 +#define GLFW_KEY_Q 81 +#define GLFW_KEY_R 82 +#define GLFW_KEY_S 83 +#define GLFW_KEY_T 84 +#define GLFW_KEY_U 85 +#define GLFW_KEY_V 86 +#define GLFW_KEY_W 87 +#define GLFW_KEY_X 88 +#define GLFW_KEY_Y 89 +#define GLFW_KEY_Z 90 +#define GLFW_KEY_LEFT_BRACKET 91 /* [ */ +#define GLFW_KEY_BACKSLASH 92 /* \ */ +#define GLFW_KEY_RIGHT_BRACKET 93 /* ] */ +#define GLFW_KEY_GRAVE_ACCENT 96 /* ` */ +#define GLFW_KEY_WORLD_1 161 /* non-US #1 */ +#define GLFW_KEY_WORLD_2 162 /* non-US #2 */ + +/* Function keys */ +#define GLFW_KEY_ESCAPE 256 +#define GLFW_KEY_ENTER 257 +#define GLFW_KEY_TAB 258 +#define GLFW_KEY_BACKSPACE 259 +#define GLFW_KEY_INSERT 260 +#define GLFW_KEY_DELETE 261 +#define GLFW_KEY_RIGHT 262 +#define GLFW_KEY_LEFT 263 +#define GLFW_KEY_DOWN 264 +#define GLFW_KEY_UP 265 +#define GLFW_KEY_PAGE_UP 266 +#define GLFW_KEY_PAGE_DOWN 267 +#define GLFW_KEY_HOME 268 +#define GLFW_KEY_END 269 +#define GLFW_KEY_CAPS_LOCK 280 +#define GLFW_KEY_SCROLL_LOCK 281 +#define GLFW_KEY_NUM_LOCK 282 +#define GLFW_KEY_PRINT_SCREEN 283 +#define GLFW_KEY_PAUSE 284 +#define GLFW_KEY_F1 290 +#define GLFW_KEY_F2 291 +#define GLFW_KEY_F3 292 +#define GLFW_KEY_F4 293 +#define GLFW_KEY_F5 294 +#define GLFW_KEY_F6 295 +#define GLFW_KEY_F7 296 +#define GLFW_KEY_F8 297 +#define GLFW_KEY_F9 298 +#define GLFW_KEY_F10 299 +#define GLFW_KEY_F11 300 +#define GLFW_KEY_F12 301 +#define GLFW_KEY_F13 302 +#define GLFW_KEY_F14 303 +#define GLFW_KEY_F15 304 +#define GLFW_KEY_F16 305 +#define GLFW_KEY_F17 306 +#define GLFW_KEY_F18 307 +#define GLFW_KEY_F19 308 +#define GLFW_KEY_F20 309 +#define GLFW_KEY_F21 310 +#define GLFW_KEY_F22 311 +#define GLFW_KEY_F23 312 +#define GLFW_KEY_F24 313 +#define GLFW_KEY_F25 314 +#define GLFW_KEY_KP_0 320 +#define GLFW_KEY_KP_1 321 +#define GLFW_KEY_KP_2 322 +#define GLFW_KEY_KP_3 323 +#define GLFW_KEY_KP_4 324 +#define GLFW_KEY_KP_5 325 +#define GLFW_KEY_KP_6 326 +#define GLFW_KEY_KP_7 327 +#define GLFW_KEY_KP_8 328 +#define GLFW_KEY_KP_9 329 +#define GLFW_KEY_KP_DECIMAL 330 +#define GLFW_KEY_KP_DIVIDE 331 +#define GLFW_KEY_KP_MULTIPLY 332 +#define GLFW_KEY_KP_SUBTRACT 333 +#define GLFW_KEY_KP_ADD 334 +#define GLFW_KEY_KP_ENTER 335 +#define GLFW_KEY_KP_EQUAL 336 +#define GLFW_KEY_LEFT_SHIFT 340 +#define GLFW_KEY_LEFT_CONTROL 341 +#define GLFW_KEY_LEFT_ALT 342 +#define GLFW_KEY_LEFT_SUPER 343 +#define GLFW_KEY_RIGHT_SHIFT 344 +#define GLFW_KEY_RIGHT_CONTROL 345 +#define GLFW_KEY_RIGHT_ALT 346 +#define GLFW_KEY_RIGHT_SUPER 347 +#define GLFW_KEY_MENU 348 + +#define GLFW_KEY_LAST GLFW_KEY_MENU + +/*! @} */ + +/*! @defgroup mods Modifier key flags + * @brief Modifier key flags. + * + * See [key input](@ref input_key) for how these are used. + * + * @ingroup input + * @{ */ + +/*! @brief If this bit is set one or more Shift keys were held down. + * + * If this bit is set one or more Shift keys were held down. + */ +#define GLFW_MOD_SHIFT 0x0001 +/*! @brief If this bit is set one or more Control keys were held down. + * + * If this bit is set one or more Control keys were held down. + */ +#define GLFW_MOD_CONTROL 0x0002 +/*! @brief If this bit is set one or more Alt keys were held down. + * + * If this bit is set one or more Alt keys were held down. + */ +#define GLFW_MOD_ALT 0x0004 +/*! @brief If this bit is set one or more Super keys were held down. + * + * If this bit is set one or more Super keys were held down. + */ +#define GLFW_MOD_SUPER 0x0008 +/*! @brief If this bit is set the Caps Lock key is enabled. + * + * If this bit is set the Caps Lock key is enabled and the @ref + * GLFW_LOCK_KEY_MODS input mode is set. + */ +#define GLFW_MOD_CAPS_LOCK 0x0010 +/*! @brief If this bit is set the Num Lock key is enabled. + * + * If this bit is set the Num Lock key is enabled and the @ref + * GLFW_LOCK_KEY_MODS input mode is set. + */ +#define GLFW_MOD_NUM_LOCK 0x0020 + +/*! @} */ + +/*! @defgroup buttons Mouse buttons + * @brief Mouse button IDs. + * + * See [mouse button input](@ref input_mouse_button) for how these are used. + * + * @ingroup input + * @{ */ +#define GLFW_MOUSE_BUTTON_1 0 +#define GLFW_MOUSE_BUTTON_2 1 +#define GLFW_MOUSE_BUTTON_3 2 +#define GLFW_MOUSE_BUTTON_4 3 +#define GLFW_MOUSE_BUTTON_5 4 +#define GLFW_MOUSE_BUTTON_6 5 +#define GLFW_MOUSE_BUTTON_7 6 +#define GLFW_MOUSE_BUTTON_8 7 +#define GLFW_MOUSE_BUTTON_LAST GLFW_MOUSE_BUTTON_8 +#define GLFW_MOUSE_BUTTON_LEFT GLFW_MOUSE_BUTTON_1 +#define GLFW_MOUSE_BUTTON_RIGHT GLFW_MOUSE_BUTTON_2 +#define GLFW_MOUSE_BUTTON_MIDDLE GLFW_MOUSE_BUTTON_3 +/*! @} */ + +/*! @defgroup joysticks Joysticks + * @brief Joystick IDs. + * + * See [joystick input](@ref joystick) for how these are used. + * + * @ingroup input + * @{ */ +#define GLFW_JOYSTICK_1 0 +#define GLFW_JOYSTICK_2 1 +#define GLFW_JOYSTICK_3 2 +#define GLFW_JOYSTICK_4 3 +#define GLFW_JOYSTICK_5 4 +#define GLFW_JOYSTICK_6 5 +#define GLFW_JOYSTICK_7 6 +#define GLFW_JOYSTICK_8 7 +#define GLFW_JOYSTICK_9 8 +#define GLFW_JOYSTICK_10 9 +#define GLFW_JOYSTICK_11 10 +#define GLFW_JOYSTICK_12 11 +#define GLFW_JOYSTICK_13 12 +#define GLFW_JOYSTICK_14 13 +#define GLFW_JOYSTICK_15 14 +#define GLFW_JOYSTICK_16 15 +#define GLFW_JOYSTICK_LAST GLFW_JOYSTICK_16 +/*! @} */ + +/*! @defgroup gamepad_buttons Gamepad buttons + * @brief Gamepad buttons. + * + * See @ref gamepad for how these are used. + * + * @ingroup input + * @{ */ +#define GLFW_GAMEPAD_BUTTON_A 0 +#define GLFW_GAMEPAD_BUTTON_B 1 +#define GLFW_GAMEPAD_BUTTON_X 2 +#define GLFW_GAMEPAD_BUTTON_Y 3 +#define GLFW_GAMEPAD_BUTTON_LEFT_BUMPER 4 +#define GLFW_GAMEPAD_BUTTON_RIGHT_BUMPER 5 +#define GLFW_GAMEPAD_BUTTON_BACK 6 +#define GLFW_GAMEPAD_BUTTON_START 7 +#define GLFW_GAMEPAD_BUTTON_GUIDE 8 +#define GLFW_GAMEPAD_BUTTON_LEFT_THUMB 9 +#define GLFW_GAMEPAD_BUTTON_RIGHT_THUMB 10 +#define GLFW_GAMEPAD_BUTTON_DPAD_UP 11 +#define GLFW_GAMEPAD_BUTTON_DPAD_RIGHT 12 +#define GLFW_GAMEPAD_BUTTON_DPAD_DOWN 13 +#define GLFW_GAMEPAD_BUTTON_DPAD_LEFT 14 +#define GLFW_GAMEPAD_BUTTON_LAST GLFW_GAMEPAD_BUTTON_DPAD_LEFT + +#define GLFW_GAMEPAD_BUTTON_CROSS GLFW_GAMEPAD_BUTTON_A +#define GLFW_GAMEPAD_BUTTON_CIRCLE GLFW_GAMEPAD_BUTTON_B +#define GLFW_GAMEPAD_BUTTON_SQUARE GLFW_GAMEPAD_BUTTON_X +#define GLFW_GAMEPAD_BUTTON_TRIANGLE GLFW_GAMEPAD_BUTTON_Y +/*! @} */ + +/*! @defgroup gamepad_axes Gamepad axes + * @brief Gamepad axes. + * + * See @ref gamepad for how these are used. + * + * @ingroup input + * @{ */ +#define GLFW_GAMEPAD_AXIS_LEFT_X 0 +#define GLFW_GAMEPAD_AXIS_LEFT_Y 1 +#define GLFW_GAMEPAD_AXIS_RIGHT_X 2 +#define GLFW_GAMEPAD_AXIS_RIGHT_Y 3 +#define GLFW_GAMEPAD_AXIS_LEFT_TRIGGER 4 +#define GLFW_GAMEPAD_AXIS_RIGHT_TRIGGER 5 +#define GLFW_GAMEPAD_AXIS_LAST GLFW_GAMEPAD_AXIS_RIGHT_TRIGGER +/*! @} */ + +/*! @defgroup errors Error codes + * @brief Error codes. + * + * See [error handling](@ref error_handling) for how these are used. + * + * @ingroup init + * @{ */ +/*! @brief No error has occurred. + * + * No error has occurred. + * + * @analysis Yay. + */ +#define GLFW_NO_ERROR 0 +/*! @brief GLFW has not been initialized. + * + * This occurs if a GLFW function was called that must not be called unless the + * library is [initialized](@ref intro_init). + * + * @analysis Application programmer error. Initialize GLFW before calling any + * function that requires initialization. + */ +#define GLFW_NOT_INITIALIZED 0x00010001 +/*! @brief No context is current for this thread. + * + * This occurs if a GLFW function was called that needs and operates on the + * current OpenGL or OpenGL ES context but no context is current on the calling + * thread. One such function is @ref glfwSwapInterval. + * + * @analysis Application programmer error. Ensure a context is current before + * calling functions that require a current context. + */ +#define GLFW_NO_CURRENT_CONTEXT 0x00010002 +/*! @brief One of the arguments to the function was an invalid enum value. + * + * One of the arguments to the function was an invalid enum value, for example + * requesting @ref GLFW_RED_BITS with @ref glfwGetWindowAttrib. + * + * @analysis Application programmer error. Fix the offending call. + */ +#define GLFW_INVALID_ENUM 0x00010003 +/*! @brief One of the arguments to the function was an invalid value. + * + * One of the arguments to the function was an invalid value, for example + * requesting a non-existent OpenGL or OpenGL ES version like 2.7. + * + * Requesting a valid but unavailable OpenGL or OpenGL ES version will instead + * result in a @ref GLFW_VERSION_UNAVAILABLE error. + * + * @analysis Application programmer error. Fix the offending call. + */ +#define GLFW_INVALID_VALUE 0x00010004 +/*! @brief A memory allocation failed. + * + * A memory allocation failed. + * + * @analysis A bug in GLFW or the underlying operating system. Report the bug + * to our [issue tracker](https://github.com/glfw/glfw/issues). + */ +#define GLFW_OUT_OF_MEMORY 0x00010005 +/*! @brief GLFW could not find support for the requested API on the system. + * + * GLFW could not find support for the requested API on the system. + * + * @analysis The installed graphics driver does not support the requested + * API, or does not support it via the chosen context creation backend. + * Below are a few examples. + * + * @par + * Some pre-installed Windows graphics drivers do not support OpenGL. AMD only + * supports OpenGL ES via EGL, while Nvidia and Intel only support it via + * a WGL or GLX extension. macOS does not provide OpenGL ES at all. The Mesa + * EGL, OpenGL and OpenGL ES libraries do not interface with the Nvidia binary + * driver. Older graphics drivers do not support Vulkan. + */ +#define GLFW_API_UNAVAILABLE 0x00010006 +/*! @brief The requested OpenGL or OpenGL ES version is not available. + * + * The requested OpenGL or OpenGL ES version (including any requested context + * or framebuffer hints) is not available on this machine. + * + * @analysis The machine does not support your requirements. If your + * application is sufficiently flexible, downgrade your requirements and try + * again. Otherwise, inform the user that their machine does not match your + * requirements. + * + * @par + * Future invalid OpenGL and OpenGL ES versions, for example OpenGL 4.8 if 5.0 + * comes out before the 4.x series gets that far, also fail with this error and + * not @ref GLFW_INVALID_VALUE, because GLFW cannot know what future versions + * will exist. + */ +#define GLFW_VERSION_UNAVAILABLE 0x00010007 +/*! @brief A platform-specific error occurred that does not match any of the + * more specific categories. + * + * A platform-specific error occurred that does not match any of the more + * specific categories. + * + * @analysis A bug or configuration error in GLFW, the underlying operating + * system or its drivers, or a lack of required resources. Report the issue to + * our [issue tracker](https://github.com/glfw/glfw/issues). + */ +#define GLFW_PLATFORM_ERROR 0x00010008 +/*! @brief The requested format is not supported or available. + * + * If emitted during window creation, the requested pixel format is not + * supported. + * + * If emitted when querying the clipboard, the contents of the clipboard could + * not be converted to the requested format. + * + * @analysis If emitted during window creation, one or more + * [hard constraints](@ref window_hints_hard) did not match any of the + * available pixel formats. If your application is sufficiently flexible, + * downgrade your requirements and try again. Otherwise, inform the user that + * their machine does not match your requirements. + * + * @par + * If emitted when querying the clipboard, ignore the error or report it to + * the user, as appropriate. + */ +#define GLFW_FORMAT_UNAVAILABLE 0x00010009 +/*! @brief The specified window does not have an OpenGL or OpenGL ES context. + * + * A window that does not have an OpenGL or OpenGL ES context was passed to + * a function that requires it to have one. + * + * @analysis Application programmer error. Fix the offending call. + */ +#define GLFW_NO_WINDOW_CONTEXT 0x0001000A +/*! @} */ + +/*! @addtogroup window + * @{ */ +/*! @brief Input focus window hint and attribute + * + * Input focus [window hint](@ref GLFW_FOCUSED_hint) or + * [window attribute](@ref GLFW_FOCUSED_attrib). + */ +#define GLFW_FOCUSED 0x00020001 +/*! @brief Window iconification window attribute + * + * Window iconification [window attribute](@ref GLFW_ICONIFIED_attrib). + */ +#define GLFW_ICONIFIED 0x00020002 +/*! @brief Window resize-ability window hint and attribute + * + * Window resize-ability [window hint](@ref GLFW_RESIZABLE_hint) and + * [window attribute](@ref GLFW_RESIZABLE_attrib). + */ +#define GLFW_RESIZABLE 0x00020003 +/*! @brief Window visibility window hint and attribute + * + * Window visibility [window hint](@ref GLFW_VISIBLE_hint) and + * [window attribute](@ref GLFW_VISIBLE_attrib). + */ +#define GLFW_VISIBLE 0x00020004 +/*! @brief Window decoration window hint and attribute + * + * Window decoration [window hint](@ref GLFW_DECORATED_hint) and + * [window attribute](@ref GLFW_DECORATED_attrib). + */ +#define GLFW_DECORATED 0x00020005 +/*! @brief Window auto-iconification window hint and attribute + * + * Window auto-iconification [window hint](@ref GLFW_AUTO_ICONIFY_hint) and + * [window attribute](@ref GLFW_AUTO_ICONIFY_attrib). + */ +#define GLFW_AUTO_ICONIFY 0x00020006 +/*! @brief Window decoration window hint and attribute + * + * Window decoration [window hint](@ref GLFW_FLOATING_hint) and + * [window attribute](@ref GLFW_FLOATING_attrib). + */ +#define GLFW_FLOATING 0x00020007 +/*! @brief Window maximization window hint and attribute + * + * Window maximization [window hint](@ref GLFW_MAXIMIZED_hint) and + * [window attribute](@ref GLFW_MAXIMIZED_attrib). + */ +#define GLFW_MAXIMIZED 0x00020008 +/*! @brief Cursor centering window hint + * + * Cursor centering [window hint](@ref GLFW_CENTER_CURSOR_hint). + */ +#define GLFW_CENTER_CURSOR 0x00020009 +/*! @brief Window framebuffer transparency hint and attribute + * + * Window framebuffer transparency + * [window hint](@ref GLFW_TRANSPARENT_FRAMEBUFFER_hint) and + * [window attribute](@ref GLFW_TRANSPARENT_FRAMEBUFFER_attrib). + */ +#define GLFW_TRANSPARENT_FRAMEBUFFER 0x0002000A +/*! @brief Mouse cursor hover window attribute. + * + * Mouse cursor hover [window attribute](@ref GLFW_HOVERED_attrib). + */ +#define GLFW_HOVERED 0x0002000B +/*! @brief Input focus on calling show window hint and attribute + * + * Input focus [window hint](@ref GLFW_FOCUS_ON_SHOW_hint) or + * [window attribute](@ref GLFW_FOCUS_ON_SHOW_attrib). + */ +#define GLFW_FOCUS_ON_SHOW 0x0002000C + +/*! @brief Framebuffer bit depth hint. + * + * Framebuffer bit depth [hint](@ref GLFW_RED_BITS). + */ +#define GLFW_RED_BITS 0x00021001 +/*! @brief Framebuffer bit depth hint. + * + * Framebuffer bit depth [hint](@ref GLFW_GREEN_BITS). + */ +#define GLFW_GREEN_BITS 0x00021002 +/*! @brief Framebuffer bit depth hint. + * + * Framebuffer bit depth [hint](@ref GLFW_BLUE_BITS). + */ +#define GLFW_BLUE_BITS 0x00021003 +/*! @brief Framebuffer bit depth hint. + * + * Framebuffer bit depth [hint](@ref GLFW_ALPHA_BITS). + */ +#define GLFW_ALPHA_BITS 0x00021004 +/*! @brief Framebuffer bit depth hint. + * + * Framebuffer bit depth [hint](@ref GLFW_DEPTH_BITS). + */ +#define GLFW_DEPTH_BITS 0x00021005 +/*! @brief Framebuffer bit depth hint. + * + * Framebuffer bit depth [hint](@ref GLFW_STENCIL_BITS). + */ +#define GLFW_STENCIL_BITS 0x00021006 +/*! @brief Framebuffer bit depth hint. + * + * Framebuffer bit depth [hint](@ref GLFW_ACCUM_RED_BITS). + */ +#define GLFW_ACCUM_RED_BITS 0x00021007 +/*! @brief Framebuffer bit depth hint. + * + * Framebuffer bit depth [hint](@ref GLFW_ACCUM_GREEN_BITS). + */ +#define GLFW_ACCUM_GREEN_BITS 0x00021008 +/*! @brief Framebuffer bit depth hint. + * + * Framebuffer bit depth [hint](@ref GLFW_ACCUM_BLUE_BITS). + */ +#define GLFW_ACCUM_BLUE_BITS 0x00021009 +/*! @brief Framebuffer bit depth hint. + * + * Framebuffer bit depth [hint](@ref GLFW_ACCUM_ALPHA_BITS). + */ +#define GLFW_ACCUM_ALPHA_BITS 0x0002100A +/*! @brief Framebuffer auxiliary buffer hint. + * + * Framebuffer auxiliary buffer [hint](@ref GLFW_AUX_BUFFERS). + */ +#define GLFW_AUX_BUFFERS 0x0002100B +/*! @brief OpenGL stereoscopic rendering hint. + * + * OpenGL stereoscopic rendering [hint](@ref GLFW_STEREO). + */ +#define GLFW_STEREO 0x0002100C +/*! @brief Framebuffer MSAA samples hint. + * + * Framebuffer MSAA samples [hint](@ref GLFW_SAMPLES). + */ +#define GLFW_SAMPLES 0x0002100D +/*! @brief Framebuffer sRGB hint. + * + * Framebuffer sRGB [hint](@ref GLFW_SRGB_CAPABLE). + */ +#define GLFW_SRGB_CAPABLE 0x0002100E +/*! @brief Monitor refresh rate hint. + * + * Monitor refresh rate [hint](@ref GLFW_REFRESH_RATE). + */ +#define GLFW_REFRESH_RATE 0x0002100F +/*! @brief Framebuffer double buffering hint. + * + * Framebuffer double buffering [hint](@ref GLFW_DOUBLEBUFFER). + */ +#define GLFW_DOUBLEBUFFER 0x00021010 + +/*! @brief Context client API hint and attribute. + * + * Context client API [hint](@ref GLFW_CLIENT_API_hint) and + * [attribute](@ref GLFW_CLIENT_API_attrib). + */ +#define GLFW_CLIENT_API 0x00022001 +/*! @brief Context client API major version hint and attribute. + * + * Context client API major version [hint](@ref GLFW_CONTEXT_VERSION_MAJOR_hint) + * and [attribute](@ref GLFW_CONTEXT_VERSION_MAJOR_attrib). + */ +#define GLFW_CONTEXT_VERSION_MAJOR 0x00022002 +/*! @brief Context client API minor version hint and attribute. + * + * Context client API minor version [hint](@ref GLFW_CONTEXT_VERSION_MINOR_hint) + * and [attribute](@ref GLFW_CONTEXT_VERSION_MINOR_attrib). + */ +#define GLFW_CONTEXT_VERSION_MINOR 0x00022003 +/*! @brief Context client API revision number attribute. + * + * Context client API revision number + * [attribute](@ref GLFW_CONTEXT_REVISION_attrib). + */ +#define GLFW_CONTEXT_REVISION 0x00022004 +/*! @brief Context robustness hint and attribute. + * + * Context client API revision number [hint](@ref GLFW_CONTEXT_ROBUSTNESS_hint) + * and [attribute](@ref GLFW_CONTEXT_ROBUSTNESS_attrib). + */ +#define GLFW_CONTEXT_ROBUSTNESS 0x00022005 +/*! @brief OpenGL forward-compatibility hint and attribute. + * + * OpenGL forward-compatibility [hint](@ref GLFW_OPENGL_FORWARD_COMPAT_hint) + * and [attribute](@ref GLFW_OPENGL_FORWARD_COMPAT_attrib). + */ +#define GLFW_OPENGL_FORWARD_COMPAT 0x00022006 +/*! @brief Debug mode context hint and attribute. + * + * Debug mode context [hint](@ref GLFW_OPENGL_DEBUG_CONTEXT_hint) and + * [attribute](@ref GLFW_OPENGL_DEBUG_CONTEXT_attrib). + */ +#define GLFW_OPENGL_DEBUG_CONTEXT 0x00022007 +/*! @brief OpenGL profile hint and attribute. + * + * OpenGL profile [hint](@ref GLFW_OPENGL_PROFILE_hint) and + * [attribute](@ref GLFW_OPENGL_PROFILE_attrib). + */ +#define GLFW_OPENGL_PROFILE 0x00022008 +/*! @brief Context flush-on-release hint and attribute. + * + * Context flush-on-release [hint](@ref GLFW_CONTEXT_RELEASE_BEHAVIOR_hint) and + * [attribute](@ref GLFW_CONTEXT_RELEASE_BEHAVIOR_attrib). + */ +#define GLFW_CONTEXT_RELEASE_BEHAVIOR 0x00022009 +/*! @brief Context error suppression hint and attribute. + * + * Context error suppression [hint](@ref GLFW_CONTEXT_NO_ERROR_hint) and + * [attribute](@ref GLFW_CONTEXT_NO_ERROR_attrib). + */ +#define GLFW_CONTEXT_NO_ERROR 0x0002200A +/*! @brief Context creation API hint and attribute. + * + * Context creation API [hint](@ref GLFW_CONTEXT_CREATION_API_hint) and + * [attribute](@ref GLFW_CONTEXT_CREATION_API_attrib). + */ +#define GLFW_CONTEXT_CREATION_API 0x0002200B +/*! @brief Window content area scaling window + * [window hint](@ref GLFW_SCALE_TO_MONITOR). + */ +#define GLFW_SCALE_TO_MONITOR 0x0002200C +/*! @brief macOS specific + * [window hint](@ref GLFW_COCOA_RETINA_FRAMEBUFFER_hint). + */ +#define GLFW_COCOA_RETINA_FRAMEBUFFER 0x00023001 +/*! @brief macOS specific + * [window hint](@ref GLFW_COCOA_FRAME_NAME_hint). + */ +#define GLFW_COCOA_FRAME_NAME 0x00023002 +/*! @brief macOS specific + * [window hint](@ref GLFW_COCOA_GRAPHICS_SWITCHING_hint). + */ +#define GLFW_COCOA_GRAPHICS_SWITCHING 0x00023003 +/*! @brief X11 specific + * [window hint](@ref GLFW_X11_CLASS_NAME_hint). + */ +#define GLFW_X11_CLASS_NAME 0x00024001 +/*! @brief X11 specific + * [window hint](@ref GLFW_X11_CLASS_NAME_hint). + */ +#define GLFW_X11_INSTANCE_NAME 0x00024002 +/*! @} */ + +#define GLFW_NO_API 0 +#define GLFW_OPENGL_API 0x00030001 +#define GLFW_OPENGL_ES_API 0x00030002 + +#define GLFW_NO_ROBUSTNESS 0 +#define GLFW_NO_RESET_NOTIFICATION 0x00031001 +#define GLFW_LOSE_CONTEXT_ON_RESET 0x00031002 + +#define GLFW_OPENGL_ANY_PROFILE 0 +#define GLFW_OPENGL_CORE_PROFILE 0x00032001 +#define GLFW_OPENGL_COMPAT_PROFILE 0x00032002 + +#define GLFW_CURSOR 0x00033001 +#define GLFW_STICKY_KEYS 0x00033002 +#define GLFW_STICKY_MOUSE_BUTTONS 0x00033003 +#define GLFW_LOCK_KEY_MODS 0x00033004 +#define GLFW_RAW_MOUSE_MOTION 0x00033005 + +#define GLFW_CURSOR_NORMAL 0x00034001 +#define GLFW_CURSOR_HIDDEN 0x00034002 +#define GLFW_CURSOR_DISABLED 0x00034003 + +#define GLFW_ANY_RELEASE_BEHAVIOR 0 +#define GLFW_RELEASE_BEHAVIOR_FLUSH 0x00035001 +#define GLFW_RELEASE_BEHAVIOR_NONE 0x00035002 + +#define GLFW_NATIVE_CONTEXT_API 0x00036001 +#define GLFW_EGL_CONTEXT_API 0x00036002 +#define GLFW_OSMESA_CONTEXT_API 0x00036003 + +/*! @defgroup shapes Standard cursor shapes + * @brief Standard system cursor shapes. + * + * See [standard cursor creation](@ref cursor_standard) for how these are used. + * + * @ingroup input + * @{ */ + +/*! @brief The regular arrow cursor shape. + * + * The regular arrow cursor. + */ +#define GLFW_ARROW_CURSOR 0x00036001 +/*! @brief The text input I-beam cursor shape. + * + * The text input I-beam cursor shape. + */ +#define GLFW_IBEAM_CURSOR 0x00036002 +/*! @brief The crosshair shape. + * + * The crosshair shape. + */ +#define GLFW_CROSSHAIR_CURSOR 0x00036003 +/*! @brief The hand shape. + * + * The hand shape. + */ +#define GLFW_HAND_CURSOR 0x00036004 +/*! @brief The horizontal resize arrow shape. + * + * The horizontal resize arrow shape. + */ +#define GLFW_HRESIZE_CURSOR 0x00036005 +/*! @brief The vertical resize arrow shape. + * + * The vertical resize arrow shape. + */ +#define GLFW_VRESIZE_CURSOR 0x00036006 +/*! @} */ + +#define GLFW_CONNECTED 0x00040001 +#define GLFW_DISCONNECTED 0x00040002 + +/*! @addtogroup init + * @{ */ +/*! @brief Joystick hat buttons init hint. + * + * Joystick hat buttons [init hint](@ref GLFW_JOYSTICK_HAT_BUTTONS). + */ +#define GLFW_JOYSTICK_HAT_BUTTONS 0x00050001 +/*! @brief macOS specific init hint. + * + * macOS specific [init hint](@ref GLFW_COCOA_CHDIR_RESOURCES_hint). + */ +#define GLFW_COCOA_CHDIR_RESOURCES 0x00051001 +/*! @brief macOS specific init hint. + * + * macOS specific [init hint](@ref GLFW_COCOA_MENUBAR_hint). + */ +#define GLFW_COCOA_MENUBAR 0x00051002 +/*! @} */ + +#define GLFW_DONT_CARE -1 + + +/************************************************************************* + * GLFW API types + *************************************************************************/ + +/*! @brief Client API function pointer type. + * + * Generic function pointer used for returning client API function pointers + * without forcing a cast from a regular pointer. + * + * @sa @ref context_glext + * @sa @ref glfwGetProcAddress + * + * @since Added in version 3.0. + * + * @ingroup context + */ +typedef void (*GLFWglproc)(void); + +/*! @brief Vulkan API function pointer type. + * + * Generic function pointer used for returning Vulkan API function pointers + * without forcing a cast from a regular pointer. + * + * @sa @ref vulkan_proc + * @sa @ref glfwGetInstanceProcAddress + * + * @since Added in version 3.2. + * + * @ingroup vulkan + */ +typedef void (*GLFWvkproc)(void); + +/*! @brief Opaque monitor object. + * + * Opaque monitor object. + * + * @see @ref monitor_object + * + * @since Added in version 3.0. + * + * @ingroup monitor + */ +typedef struct GLFWmonitor GLFWmonitor; + +/*! @brief Opaque window object. + * + * Opaque window object. + * + * @see @ref window_object + * + * @since Added in version 3.0. + * + * @ingroup window + */ +typedef struct GLFWwindow GLFWwindow; + +/*! @brief Opaque cursor object. + * + * Opaque cursor object. + * + * @see @ref cursor_object + * + * @since Added in version 3.1. + * + * @ingroup input + */ +typedef struct GLFWcursor GLFWcursor; + +/*! @brief The function pointer type for error callbacks. + * + * This is the function pointer type for error callbacks. An error callback + * function has the following signature: + * @code + * void callback_name(int error_code, const char* description) + * @endcode + * + * @param[in] error_code An [error code](@ref errors). Future releases may add + * more error codes. + * @param[in] description A UTF-8 encoded string describing the error. + * + * @pointer_lifetime The error description string is valid until the callback + * function returns. + * + * @sa @ref error_handling + * @sa @ref glfwSetErrorCallback + * + * @since Added in version 3.0. + * + * @ingroup init + */ +typedef void (* GLFWerrorfun)(int error_code, const char* description); + +/*! @brief The function pointer type for window position callbacks. + * + * This is the function pointer type for window position callbacks. A window + * position callback function has the following signature: + * @code + * void callback_name(GLFWwindow* window, int xpos, int ypos) + * @endcode + * + * @param[in] window The window that was moved. + * @param[in] xpos The new x-coordinate, in screen coordinates, of the + * upper-left corner of the content area of the window. + * @param[in] ypos The new y-coordinate, in screen coordinates, of the + * upper-left corner of the content area of the window. + * + * @sa @ref window_pos + * @sa @ref glfwSetWindowPosCallback + * + * @since Added in version 3.0. + * + * @ingroup window + */ +typedef void (* GLFWwindowposfun)(GLFWwindow* window, int xpos, int ypos); + +/*! @brief The function pointer type for window size callbacks. + * + * This is the function pointer type for window size callbacks. A window size + * callback function has the following signature: + * @code + * void callback_name(GLFWwindow* window, int width, int height) + * @endcode + * + * @param[in] window The window that was resized. + * @param[in] width The new width, in screen coordinates, of the window. + * @param[in] height The new height, in screen coordinates, of the window. + * + * @sa @ref window_size + * @sa @ref glfwSetWindowSizeCallback + * + * @since Added in version 1.0. + * @glfw3 Added window handle parameter. + * + * @ingroup window + */ +typedef void (* GLFWwindowsizefun)(GLFWwindow* window, int width, int height); + +/*! @brief The function pointer type for window close callbacks. + * + * This is the function pointer type for window close callbacks. A window + * close callback function has the following signature: + * @code + * void function_name(GLFWwindow* window) + * @endcode + * + * @param[in] window The window that the user attempted to close. + * + * @sa @ref window_close + * @sa @ref glfwSetWindowCloseCallback + * + * @since Added in version 2.5. + * @glfw3 Added window handle parameter. + * + * @ingroup window + */ +typedef void (* GLFWwindowclosefun)(GLFWwindow* window); + +/*! @brief The function pointer type for window content refresh callbacks. + * + * This is the function pointer type for window content refresh callbacks. + * A window content refresh callback function has the following signature: + * @code + * void function_name(GLFWwindow* window); + * @endcode + * + * @param[in] window The window whose content needs to be refreshed. + * + * @sa @ref window_refresh + * @sa @ref glfwSetWindowRefreshCallback + * + * @since Added in version 2.5. + * @glfw3 Added window handle parameter. + * + * @ingroup window + */ +typedef void (* GLFWwindowrefreshfun)(GLFWwindow* window); + +/*! @brief The function pointer type for window focus callbacks. + * + * This is the function pointer type for window focus callbacks. A window + * focus callback function has the following signature: + * @code + * void function_name(GLFWwindow* window, int focused) + * @endcode + * + * @param[in] window The window that gained or lost input focus. + * @param[in] focused `GLFW_TRUE` if the window was given input focus, or + * `GLFW_FALSE` if it lost it. + * + * @sa @ref window_focus + * @sa @ref glfwSetWindowFocusCallback + * + * @since Added in version 3.0. + * + * @ingroup window + */ +typedef void (* GLFWwindowfocusfun)(GLFWwindow* window, int focused); + +/*! @brief The function pointer type for window iconify callbacks. + * + * This is the function pointer type for window iconify callbacks. A window + * iconify callback function has the following signature: + * @code + * void function_name(GLFWwindow* window, int iconified) + * @endcode + * + * @param[in] window The window that was iconified or restored. + * @param[in] iconified `GLFW_TRUE` if the window was iconified, or + * `GLFW_FALSE` if it was restored. + * + * @sa @ref window_iconify + * @sa @ref glfwSetWindowIconifyCallback + * + * @since Added in version 3.0. + * + * @ingroup window + */ +typedef void (* GLFWwindowiconifyfun)(GLFWwindow* window, int iconified); + +/*! @brief The function pointer type for window maximize callbacks. + * + * This is the function pointer type for window maximize callbacks. A window + * maximize callback function has the following signature: + * @code + * void function_name(GLFWwindow* window, int maximized) + * @endcode + * + * @param[in] window The window that was maximized or restored. + * @param[in] maximized `GLFW_TRUE` if the window was maximized, or + * `GLFW_FALSE` if it was restored. + * + * @sa @ref window_maximize + * @sa glfwSetWindowMaximizeCallback + * + * @since Added in version 3.3. + * + * @ingroup window + */ +typedef void (* GLFWwindowmaximizefun)(GLFWwindow* window, int maximized); + +/*! @brief The function pointer type for framebuffer size callbacks. + * + * This is the function pointer type for framebuffer size callbacks. + * A framebuffer size callback function has the following signature: + * @code + * void function_name(GLFWwindow* window, int width, int height) + * @endcode + * + * @param[in] window The window whose framebuffer was resized. + * @param[in] width The new width, in pixels, of the framebuffer. + * @param[in] height The new height, in pixels, of the framebuffer. + * + * @sa @ref window_fbsize + * @sa @ref glfwSetFramebufferSizeCallback + * + * @since Added in version 3.0. + * + * @ingroup window + */ +typedef void (* GLFWframebuffersizefun)(GLFWwindow* window, int width, int height); + +/*! @brief The function pointer type for window content scale callbacks. + * + * This is the function pointer type for window content scale callbacks. + * A window content scale callback function has the following signature: + * @code + * void function_name(GLFWwindow* window, float xscale, float yscale) + * @endcode + * + * @param[in] window The window whose content scale changed. + * @param[in] xscale The new x-axis content scale of the window. + * @param[in] yscale The new y-axis content scale of the window. + * + * @sa @ref window_scale + * @sa @ref glfwSetWindowContentScaleCallback + * + * @since Added in version 3.3. + * + * @ingroup window + */ +typedef void (* GLFWwindowcontentscalefun)(GLFWwindow* window, float xscale, float yscale); + +/*! @brief The function pointer type for mouse button callbacks. + * + * This is the function pointer type for mouse button callback functions. + * A mouse button callback function has the following signature: + * @code + * void function_name(GLFWwindow* window, int button, int action, int mods) + * @endcode + * + * @param[in] window The window that received the event. + * @param[in] button The [mouse button](@ref buttons) that was pressed or + * released. + * @param[in] action One of `GLFW_PRESS` or `GLFW_RELEASE`. Future releases + * may add more actions. + * @param[in] mods Bit field describing which [modifier keys](@ref mods) were + * held down. + * + * @sa @ref input_mouse_button + * @sa @ref glfwSetMouseButtonCallback + * + * @since Added in version 1.0. + * @glfw3 Added window handle and modifier mask parameters. + * + * @ingroup input + */ +typedef void (* GLFWmousebuttonfun)(GLFWwindow* window, int button, int action, int mods); + +/*! @brief The function pointer type for cursor position callbacks. + * + * This is the function pointer type for cursor position callbacks. A cursor + * position callback function has the following signature: + * @code + * void function_name(GLFWwindow* window, double xpos, double ypos); + * @endcode + * + * @param[in] window The window that received the event. + * @param[in] xpos The new cursor x-coordinate, relative to the left edge of + * the content area. + * @param[in] ypos The new cursor y-coordinate, relative to the top edge of the + * content area. + * + * @sa @ref cursor_pos + * @sa @ref glfwSetCursorPosCallback + * + * @since Added in version 3.0. Replaces `GLFWmouseposfun`. + * + * @ingroup input + */ +typedef void (* GLFWcursorposfun)(GLFWwindow* window, double xpos, double ypos); + +/*! @brief The function pointer type for cursor enter/leave callbacks. + * + * This is the function pointer type for cursor enter/leave callbacks. + * A cursor enter/leave callback function has the following signature: + * @code + * void function_name(GLFWwindow* window, int entered) + * @endcode + * + * @param[in] window The window that received the event. + * @param[in] entered `GLFW_TRUE` if the cursor entered the window's content + * area, or `GLFW_FALSE` if it left it. + * + * @sa @ref cursor_enter + * @sa @ref glfwSetCursorEnterCallback + * + * @since Added in version 3.0. + * + * @ingroup input + */ +typedef void (* GLFWcursorenterfun)(GLFWwindow* window, int entered); + +/*! @brief The function pointer type for scroll callbacks. + * + * This is the function pointer type for scroll callbacks. A scroll callback + * function has the following signature: + * @code + * void function_name(GLFWwindow* window, double xoffset, double yoffset) + * @endcode + * + * @param[in] window The window that received the event. + * @param[in] xoffset The scroll offset along the x-axis. + * @param[in] yoffset The scroll offset along the y-axis. + * + * @sa @ref scrolling + * @sa @ref glfwSetScrollCallback + * + * @since Added in version 3.0. Replaces `GLFWmousewheelfun`. + * + * @ingroup input + */ +typedef void (* GLFWscrollfun)(GLFWwindow* window, double xoffset, double yoffset); + +/*! @brief The function pointer type for keyboard key callbacks. + * + * This is the function pointer type for keyboard key callbacks. A keyboard + * key callback function has the following signature: + * @code + * void function_name(GLFWwindow* window, int key, int scancode, int action, int mods) + * @endcode + * + * @param[in] window The window that received the event. + * @param[in] key The [keyboard key](@ref keys) that was pressed or released. + * @param[in] scancode The system-specific scancode of the key. + * @param[in] action `GLFW_PRESS`, `GLFW_RELEASE` or `GLFW_REPEAT`. Future + * releases may add more actions. + * @param[in] mods Bit field describing which [modifier keys](@ref mods) were + * held down. + * + * @sa @ref input_key + * @sa @ref glfwSetKeyCallback + * + * @since Added in version 1.0. + * @glfw3 Added window handle, scancode and modifier mask parameters. + * + * @ingroup input + */ +typedef void (* GLFWkeyfun)(GLFWwindow* window, int key, int scancode, int action, int mods); + +/*! @brief The function pointer type for Unicode character callbacks. + * + * This is the function pointer type for Unicode character callbacks. + * A Unicode character callback function has the following signature: + * @code + * void function_name(GLFWwindow* window, unsigned int codepoint) + * @endcode + * + * @param[in] window The window that received the event. + * @param[in] codepoint The Unicode code point of the character. + * + * @sa @ref input_char + * @sa @ref glfwSetCharCallback + * + * @since Added in version 2.4. + * @glfw3 Added window handle parameter. + * + * @ingroup input + */ +typedef void (* GLFWcharfun)(GLFWwindow* window, unsigned int codepoint); + +/*! @brief The function pointer type for Unicode character with modifiers + * callbacks. + * + * This is the function pointer type for Unicode character with modifiers + * callbacks. It is called for each input character, regardless of what + * modifier keys are held down. A Unicode character with modifiers callback + * function has the following signature: + * @code + * void function_name(GLFWwindow* window, unsigned int codepoint, int mods) + * @endcode + * + * @param[in] window The window that received the event. + * @param[in] codepoint The Unicode code point of the character. + * @param[in] mods Bit field describing which [modifier keys](@ref mods) were + * held down. + * + * @sa @ref input_char + * @sa @ref glfwSetCharModsCallback + * + * @deprecated Scheduled for removal in version 4.0. + * + * @since Added in version 3.1. + * + * @ingroup input + */ +typedef void (* GLFWcharmodsfun)(GLFWwindow* window, unsigned int codepoint, int mods); + +/*! @brief The function pointer type for path drop callbacks. + * + * This is the function pointer type for path drop callbacks. A path drop + * callback function has the following signature: + * @code + * void function_name(GLFWwindow* window, int path_count, const char* paths[]) + * @endcode + * + * @param[in] window The window that received the event. + * @param[in] path_count The number of dropped paths. + * @param[in] paths The UTF-8 encoded file and/or directory path names. + * + * @pointer_lifetime The path array and its strings are valid until the + * callback function returns. + * + * @sa @ref path_drop + * @sa @ref glfwSetDropCallback + * + * @since Added in version 3.1. + * + * @ingroup input + */ +typedef void (* GLFWdropfun)(GLFWwindow* window, int path_count, const char* paths[]); + +/*! @brief The function pointer type for monitor configuration callbacks. + * + * This is the function pointer type for monitor configuration callbacks. + * A monitor callback function has the following signature: + * @code + * void function_name(GLFWmonitor* monitor, int event) + * @endcode + * + * @param[in] monitor The monitor that was connected or disconnected. + * @param[in] event One of `GLFW_CONNECTED` or `GLFW_DISCONNECTED`. Future + * releases may add more events. + * + * @sa @ref monitor_event + * @sa @ref glfwSetMonitorCallback + * + * @since Added in version 3.0. + * + * @ingroup monitor + */ +typedef void (* GLFWmonitorfun)(GLFWmonitor* monitor, int event); + +/*! @brief The function pointer type for joystick configuration callbacks. + * + * This is the function pointer type for joystick configuration callbacks. + * A joystick configuration callback function has the following signature: + * @code + * void function_name(int jid, int event) + * @endcode + * + * @param[in] jid The joystick that was connected or disconnected. + * @param[in] event One of `GLFW_CONNECTED` or `GLFW_DISCONNECTED`. Future + * releases may add more events. + * + * @sa @ref joystick_event + * @sa @ref glfwSetJoystickCallback + * + * @since Added in version 3.2. + * + * @ingroup input + */ +typedef void (* GLFWjoystickfun)(int jid, int event); + +/*! @brief Video mode type. + * + * This describes a single video mode. + * + * @sa @ref monitor_modes + * @sa @ref glfwGetVideoMode + * @sa @ref glfwGetVideoModes + * + * @since Added in version 1.0. + * @glfw3 Added refresh rate member. + * + * @ingroup monitor + */ +typedef struct GLFWvidmode +{ + /*! The width, in screen coordinates, of the video mode. + */ + int width; + /*! The height, in screen coordinates, of the video mode. + */ + int height; + /*! The bit depth of the red channel of the video mode. + */ + int redBits; + /*! The bit depth of the green channel of the video mode. + */ + int greenBits; + /*! The bit depth of the blue channel of the video mode. + */ + int blueBits; + /*! The refresh rate, in Hz, of the video mode. + */ + int refreshRate; +} GLFWvidmode; + +/*! @brief Gamma ramp. + * + * This describes the gamma ramp for a monitor. + * + * @sa @ref monitor_gamma + * @sa @ref glfwGetGammaRamp + * @sa @ref glfwSetGammaRamp + * + * @since Added in version 3.0. + * + * @ingroup monitor + */ +typedef struct GLFWgammaramp +{ + /*! An array of value describing the response of the red channel. + */ + unsigned short* red; + /*! An array of value describing the response of the green channel. + */ + unsigned short* green; + /*! An array of value describing the response of the blue channel. + */ + unsigned short* blue; + /*! The number of elements in each array. + */ + unsigned int size; +} GLFWgammaramp; + +/*! @brief Image data. + * + * This describes a single 2D image. See the documentation for each related + * function what the expected pixel format is. + * + * @sa @ref cursor_custom + * @sa @ref window_icon + * + * @since Added in version 2.1. + * @glfw3 Removed format and bytes-per-pixel members. + * + * @ingroup window + */ +typedef struct GLFWimage +{ + /*! The width, in pixels, of this image. + */ + int width; + /*! The height, in pixels, of this image. + */ + int height; + /*! The pixel data of this image, arranged left-to-right, top-to-bottom. + */ + unsigned char* pixels; +} GLFWimage; + +/*! @brief Gamepad input state + * + * This describes the input state of a gamepad. + * + * @sa @ref gamepad + * @sa @ref glfwGetGamepadState + * + * @since Added in version 3.3. + * + * @ingroup input + */ +typedef struct GLFWgamepadstate +{ + /*! The states of each [gamepad button](@ref gamepad_buttons), `GLFW_PRESS` + * or `GLFW_RELEASE`. + */ + unsigned char buttons[15]; + /*! The states of each [gamepad axis](@ref gamepad_axes), in the range -1.0 + * to 1.0 inclusive. + */ + float axes[6]; +} GLFWgamepadstate; + + +/************************************************************************* + * GLFW API functions + *************************************************************************/ + +/*! @brief Initializes the GLFW library. + * + * This function initializes the GLFW library. Before most GLFW functions can + * be used, GLFW must be initialized, and before an application terminates GLFW + * should be terminated in order to free any resources allocated during or + * after initialization. + * + * If this function fails, it calls @ref glfwTerminate before returning. If it + * succeeds, you should call @ref glfwTerminate before the application exits. + * + * Additional calls to this function after successful initialization but before + * termination will return `GLFW_TRUE` immediately. + * + * @return `GLFW_TRUE` if successful, or `GLFW_FALSE` if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_PLATFORM_ERROR. + * + * @remark @macos This function will change the current directory of the + * application to the `Contents/Resources` subdirectory of the application's + * bundle, if present. This can be disabled with the @ref + * GLFW_COCOA_CHDIR_RESOURCES init hint. + * + * @remark @x11 This function will set the `LC_CTYPE` category of the + * application locale according to the current environment if that category is + * still "C". This is because the "C" locale breaks Unicode text input. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref intro_init + * @sa @ref glfwTerminate + * + * @since Added in version 1.0. + * + * @ingroup init + */ +GLFWAPI int glfwInit(void); + +/*! @brief Terminates the GLFW library. + * + * This function destroys all remaining windows and cursors, restores any + * modified gamma ramps and frees any other allocated resources. Once this + * function is called, you must again call @ref glfwInit successfully before + * you will be able to use most GLFW functions. + * + * If GLFW has been successfully initialized, this function should be called + * before the application exits. If initialization fails, there is no need to + * call this function, as it is called by @ref glfwInit before it returns + * failure. + * + * This function has no effect if GLFW is not initialized. + * + * @errors Possible errors include @ref GLFW_PLATFORM_ERROR. + * + * @remark This function may be called before @ref glfwInit. + * + * @warning The contexts of any remaining windows must not be current on any + * other thread when this function is called. + * + * @reentrancy This function must not be called from a callback. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref intro_init + * @sa @ref glfwInit + * + * @since Added in version 1.0. + * + * @ingroup init + */ +GLFWAPI void glfwTerminate(void); + +/*! @brief Sets the specified init hint to the desired value. + * + * This function sets hints for the next initialization of GLFW. + * + * The values you set hints to are never reset by GLFW, but they only take + * effect during initialization. Once GLFW has been initialized, any values + * you set will be ignored until the library is terminated and initialized + * again. + * + * Some hints are platform specific. These may be set on any platform but they + * will only affect their specific platform. Other platforms will ignore them. + * Setting these hints requires no platform specific headers or functions. + * + * @param[in] hint The [init hint](@ref init_hints) to set. + * @param[in] value The new value of the init hint. + * + * @errors Possible errors include @ref GLFW_INVALID_ENUM and @ref + * GLFW_INVALID_VALUE. + * + * @remarks This function may be called before @ref glfwInit. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa init_hints + * @sa glfwInit + * + * @since Added in version 3.3. + * + * @ingroup init + */ +GLFWAPI void glfwInitHint(int hint, int value); + +/*! @brief Retrieves the version of the GLFW library. + * + * This function retrieves the major, minor and revision numbers of the GLFW + * library. It is intended for when you are using GLFW as a shared library and + * want to ensure that you are using the minimum required version. + * + * Any or all of the version arguments may be `NULL`. + * + * @param[out] major Where to store the major version number, or `NULL`. + * @param[out] minor Where to store the minor version number, or `NULL`. + * @param[out] rev Where to store the revision number, or `NULL`. + * + * @errors None. + * + * @remark This function may be called before @ref glfwInit. + * + * @thread_safety This function may be called from any thread. + * + * @sa @ref intro_version + * @sa @ref glfwGetVersionString + * + * @since Added in version 1.0. + * + * @ingroup init + */ +GLFWAPI void glfwGetVersion(int* major, int* minor, int* rev); + +/*! @brief Returns a string describing the compile-time configuration. + * + * This function returns the compile-time generated + * [version string](@ref intro_version_string) of the GLFW library binary. It + * describes the version, platform, compiler and any platform-specific + * compile-time options. It should not be confused with the OpenGL or OpenGL + * ES version string, queried with `glGetString`. + * + * __Do not use the version string__ to parse the GLFW library version. The + * @ref glfwGetVersion function provides the version of the running library + * binary in numerical format. + * + * @return The ASCII encoded GLFW version string. + * + * @errors None. + * + * @remark This function may be called before @ref glfwInit. + * + * @pointer_lifetime The returned string is static and compile-time generated. + * + * @thread_safety This function may be called from any thread. + * + * @sa @ref intro_version + * @sa @ref glfwGetVersion + * + * @since Added in version 3.0. + * + * @ingroup init + */ +GLFWAPI const char* glfwGetVersionString(void); + +/*! @brief Returns and clears the last error for the calling thread. + * + * This function returns and clears the [error code](@ref errors) of the last + * error that occurred on the calling thread, and optionally a UTF-8 encoded + * human-readable description of it. If no error has occurred since the last + * call, it returns @ref GLFW_NO_ERROR (zero) and the description pointer is + * set to `NULL`. + * + * @param[in] description Where to store the error description pointer, or `NULL`. + * @return The last error code for the calling thread, or @ref GLFW_NO_ERROR + * (zero). + * + * @errors None. + * + * @pointer_lifetime The returned string is allocated and freed by GLFW. You + * should not free it yourself. It is guaranteed to be valid only until the + * next error occurs or the library is terminated. + * + * @remark This function may be called before @ref glfwInit. + * + * @thread_safety This function may be called from any thread. + * + * @sa @ref error_handling + * @sa @ref glfwSetErrorCallback + * + * @since Added in version 3.3. + * + * @ingroup init + */ +GLFWAPI int glfwGetError(const char** description); + +/*! @brief Sets the error callback. + * + * This function sets the error callback, which is called with an error code + * and a human-readable description each time a GLFW error occurs. + * + * The error code is set before the callback is called. Calling @ref + * glfwGetError from the error callback will return the same value as the error + * code argument. + * + * The error callback is called on the thread where the error occurred. If you + * are using GLFW from multiple threads, your error callback needs to be + * written accordingly. + * + * Because the description string may have been generated specifically for that + * error, it is not guaranteed to be valid after the callback has returned. If + * you wish to use it after the callback returns, you need to make a copy. + * + * Once set, the error callback remains set even after the library has been + * terminated. + * + * @param[in] callback The new callback, or `NULL` to remove the currently set + * callback. + * @return The previously set callback, or `NULL` if no callback was set. + * + * @callback_signature + * @code + * void callback_name(int error_code, const char* description) + * @endcode + * For more information about the callback parameters, see the + * [callback pointer type](@ref GLFWerrorfun). + * + * @errors None. + * + * @remark This function may be called before @ref glfwInit. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref error_handling + * @sa @ref glfwGetError + * + * @since Added in version 3.0. + * + * @ingroup init + */ +GLFWAPI GLFWerrorfun glfwSetErrorCallback(GLFWerrorfun callback); + +/*! @brief Returns the currently connected monitors. + * + * This function returns an array of handles for all currently connected + * monitors. The primary monitor is always first in the returned array. If no + * monitors were found, this function returns `NULL`. + * + * @param[out] count Where to store the number of monitors in the returned + * array. This is set to zero if an error occurred. + * @return An array of monitor handles, or `NULL` if no monitors were found or + * if an [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @pointer_lifetime The returned array is allocated and freed by GLFW. You + * should not free it yourself. It is guaranteed to be valid only until the + * monitor configuration changes or the library is terminated. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref monitor_monitors + * @sa @ref monitor_event + * @sa @ref glfwGetPrimaryMonitor + * + * @since Added in version 3.0. + * + * @ingroup monitor + */ +GLFWAPI GLFWmonitor** glfwGetMonitors(int* count); + +/*! @brief Returns the primary monitor. + * + * This function returns the primary monitor. This is usually the monitor + * where elements like the task bar or global menu bar are located. + * + * @return The primary monitor, or `NULL` if no monitors were found or if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function must only be called from the main thread. + * + * @remark The primary monitor is always first in the array returned by @ref + * glfwGetMonitors. + * + * @sa @ref monitor_monitors + * @sa @ref glfwGetMonitors + * + * @since Added in version 3.0. + * + * @ingroup monitor + */ +GLFWAPI GLFWmonitor* glfwGetPrimaryMonitor(void); + +/*! @brief Returns the position of the monitor's viewport on the virtual screen. + * + * This function returns the position, in screen coordinates, of the upper-left + * corner of the specified monitor. + * + * Any or all of the position arguments may be `NULL`. If an error occurs, all + * non-`NULL` position arguments will be set to zero. + * + * @param[in] monitor The monitor to query. + * @param[out] xpos Where to store the monitor x-coordinate, or `NULL`. + * @param[out] ypos Where to store the monitor y-coordinate, or `NULL`. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref monitor_properties + * + * @since Added in version 3.0. + * + * @ingroup monitor + */ +GLFWAPI void glfwGetMonitorPos(GLFWmonitor* monitor, int* xpos, int* ypos); + +/*! @brief Retrieves the work area of the monitor. + * + * This function returns the position, in screen coordinates, of the upper-left + * corner of the work area of the specified monitor along with the work area + * size in screen coordinates. The work area is defined as the area of the + * monitor not occluded by the operating system task bar where present. If no + * task bar exists then the work area is the monitor resolution in screen + * coordinates. + * + * Any or all of the position and size arguments may be `NULL`. If an error + * occurs, all non-`NULL` position and size arguments will be set to zero. + * + * @param[in] monitor The monitor to query. + * @param[out] xpos Where to store the monitor x-coordinate, or `NULL`. + * @param[out] ypos Where to store the monitor y-coordinate, or `NULL`. + * @param[out] width Where to store the monitor width, or `NULL`. + * @param[out] height Where to store the monitor height, or `NULL`. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref monitor_workarea + * + * @since Added in version 3.3. + * + * @ingroup monitor + */ +GLFWAPI void glfwGetMonitorWorkarea(GLFWmonitor* monitor, int* xpos, int* ypos, int* width, int* height); + +/*! @brief Returns the physical size of the monitor. + * + * This function returns the size, in millimetres, of the display area of the + * specified monitor. + * + * Some systems do not provide accurate monitor size information, either + * because the monitor + * [EDID](https://en.wikipedia.org/wiki/Extended_display_identification_data) + * data is incorrect or because the driver does not report it accurately. + * + * Any or all of the size arguments may be `NULL`. If an error occurs, all + * non-`NULL` size arguments will be set to zero. + * + * @param[in] monitor The monitor to query. + * @param[out] widthMM Where to store the width, in millimetres, of the + * monitor's display area, or `NULL`. + * @param[out] heightMM Where to store the height, in millimetres, of the + * monitor's display area, or `NULL`. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @remark @win32 On Windows 8 and earlier the physical size is calculated from + * the current resolution and system DPI instead of querying the monitor EDID data. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref monitor_properties + * + * @since Added in version 3.0. + * + * @ingroup monitor + */ +GLFWAPI void glfwGetMonitorPhysicalSize(GLFWmonitor* monitor, int* widthMM, int* heightMM); + +/*! @brief Retrieves the content scale for the specified monitor. + * + * This function retrieves the content scale for the specified monitor. The + * content scale is the ratio between the current DPI and the platform's + * default DPI. This is especially important for text and any UI elements. If + * the pixel dimensions of your UI scaled by this look appropriate on your + * machine then it should appear at a reasonable size on other machines + * regardless of their DPI and scaling settings. This relies on the system DPI + * and scaling settings being somewhat correct. + * + * The content scale may depend on both the monitor resolution and pixel + * density and on user settings. It may be very different from the raw DPI + * calculated from the physical size and current resolution. + * + * @param[in] monitor The monitor to query. + * @param[out] xscale Where to store the x-axis content scale, or `NULL`. + * @param[out] yscale Where to store the y-axis content scale, or `NULL`. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref monitor_scale + * @sa @ref glfwGetWindowContentScale + * + * @since Added in version 3.3. + * + * @ingroup monitor + */ +GLFWAPI void glfwGetMonitorContentScale(GLFWmonitor* monitor, float* xscale, float* yscale); + +/*! @brief Returns the name of the specified monitor. + * + * This function returns a human-readable name, encoded as UTF-8, of the + * specified monitor. The name typically reflects the make and model of the + * monitor and is not guaranteed to be unique among the connected monitors. + * + * @param[in] monitor The monitor to query. + * @return The UTF-8 encoded name of the monitor, or `NULL` if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @pointer_lifetime The returned string is allocated and freed by GLFW. You + * should not free it yourself. It is valid until the specified monitor is + * disconnected or the library is terminated. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref monitor_properties + * + * @since Added in version 3.0. + * + * @ingroup monitor + */ +GLFWAPI const char* glfwGetMonitorName(GLFWmonitor* monitor); + +/*! @brief Sets the user pointer of the specified monitor. + * + * This function sets the user-defined pointer of the specified monitor. The + * current value is retained until the monitor is disconnected. The initial + * value is `NULL`. + * + * This function may be called from the monitor callback, even for a monitor + * that is being disconnected. + * + * @param[in] monitor The monitor whose pointer to set. + * @param[in] pointer The new value. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function may be called from any thread. Access is not + * synchronized. + * + * @sa @ref monitor_userptr + * @sa @ref glfwGetMonitorUserPointer + * + * @since Added in version 3.3. + * + * @ingroup monitor + */ +GLFWAPI void glfwSetMonitorUserPointer(GLFWmonitor* monitor, void* pointer); + +/*! @brief Returns the user pointer of the specified monitor. + * + * This function returns the current value of the user-defined pointer of the + * specified monitor. The initial value is `NULL`. + * + * This function may be called from the monitor callback, even for a monitor + * that is being disconnected. + * + * @param[in] monitor The monitor whose pointer to return. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function may be called from any thread. Access is not + * synchronized. + * + * @sa @ref monitor_userptr + * @sa @ref glfwSetMonitorUserPointer + * + * @since Added in version 3.3. + * + * @ingroup monitor + */ +GLFWAPI void* glfwGetMonitorUserPointer(GLFWmonitor* monitor); + +/*! @brief Sets the monitor configuration callback. + * + * This function sets the monitor configuration callback, or removes the + * currently set callback. This is called when a monitor is connected to or + * disconnected from the system. + * + * @param[in] callback The new callback, or `NULL` to remove the currently set + * callback. + * @return The previously set callback, or `NULL` if no callback was set or the + * library had not been [initialized](@ref intro_init). + * + * @callback_signature + * @code + * void function_name(GLFWmonitor* monitor, int event) + * @endcode + * For more information about the callback parameters, see the + * [function pointer type](@ref GLFWmonitorfun). + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref monitor_event + * + * @since Added in version 3.0. + * + * @ingroup monitor + */ +GLFWAPI GLFWmonitorfun glfwSetMonitorCallback(GLFWmonitorfun callback); + +/*! @brief Returns the available video modes for the specified monitor. + * + * This function returns an array of all video modes supported by the specified + * monitor. The returned array is sorted in ascending order, first by color + * bit depth (the sum of all channel depths), then by resolution area (the + * product of width and height), then resolution width and finally by refresh + * rate. + * + * @param[in] monitor The monitor to query. + * @param[out] count Where to store the number of video modes in the returned + * array. This is set to zero if an error occurred. + * @return An array of video modes, or `NULL` if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @pointer_lifetime The returned array is allocated and freed by GLFW. You + * should not free it yourself. It is valid until the specified monitor is + * disconnected, this function is called again for that monitor or the library + * is terminated. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref monitor_modes + * @sa @ref glfwGetVideoMode + * + * @since Added in version 1.0. + * @glfw3 Changed to return an array of modes for a specific monitor. + * + * @ingroup monitor + */ +GLFWAPI const GLFWvidmode* glfwGetVideoModes(GLFWmonitor* monitor, int* count); + +/*! @brief Returns the current mode of the specified monitor. + * + * This function returns the current video mode of the specified monitor. If + * you have created a full screen window for that monitor, the return value + * will depend on whether that window is iconified. + * + * @param[in] monitor The monitor to query. + * @return The current mode of the monitor, or `NULL` if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @pointer_lifetime The returned array is allocated and freed by GLFW. You + * should not free it yourself. It is valid until the specified monitor is + * disconnected or the library is terminated. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref monitor_modes + * @sa @ref glfwGetVideoModes + * + * @since Added in version 3.0. Replaces `glfwGetDesktopMode`. + * + * @ingroup monitor + */ +GLFWAPI const GLFWvidmode* glfwGetVideoMode(GLFWmonitor* monitor); + +/*! @brief Generates a gamma ramp and sets it for the specified monitor. + * + * This function generates an appropriately sized gamma ramp from the specified + * exponent and then calls @ref glfwSetGammaRamp with it. The value must be + * a finite number greater than zero. + * + * The software controlled gamma ramp is applied _in addition_ to the hardware + * gamma correction, which today is usually an approximation of sRGB gamma. + * This means that setting a perfectly linear ramp, or gamma 1.0, will produce + * the default (usually sRGB-like) behavior. + * + * For gamma correct rendering with OpenGL or OpenGL ES, see the @ref + * GLFW_SRGB_CAPABLE hint. + * + * @param[in] monitor The monitor whose gamma ramp to set. + * @param[in] gamma The desired exponent. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_INVALID_VALUE and @ref GLFW_PLATFORM_ERROR. + * + * @remark @wayland Gamma handling is a privileged protocol, this function + * will thus never be implemented and emits @ref GLFW_PLATFORM_ERROR. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref monitor_gamma + * + * @since Added in version 3.0. + * + * @ingroup monitor + */ +GLFWAPI void glfwSetGamma(GLFWmonitor* monitor, float gamma); + +/*! @brief Returns the current gamma ramp for the specified monitor. + * + * This function returns the current gamma ramp of the specified monitor. + * + * @param[in] monitor The monitor to query. + * @return The current gamma ramp, or `NULL` if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @remark @wayland Gamma handling is a privileged protocol, this function + * will thus never be implemented and emits @ref GLFW_PLATFORM_ERROR while + * returning `NULL`. + * + * @pointer_lifetime The returned structure and its arrays are allocated and + * freed by GLFW. You should not free them yourself. They are valid until the + * specified monitor is disconnected, this function is called again for that + * monitor or the library is terminated. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref monitor_gamma + * + * @since Added in version 3.0. + * + * @ingroup monitor + */ +GLFWAPI const GLFWgammaramp* glfwGetGammaRamp(GLFWmonitor* monitor); + +/*! @brief Sets the current gamma ramp for the specified monitor. + * + * This function sets the current gamma ramp for the specified monitor. The + * original gamma ramp for that monitor is saved by GLFW the first time this + * function is called and is restored by @ref glfwTerminate. + * + * The software controlled gamma ramp is applied _in addition_ to the hardware + * gamma correction, which today is usually an approximation of sRGB gamma. + * This means that setting a perfectly linear ramp, or gamma 1.0, will produce + * the default (usually sRGB-like) behavior. + * + * For gamma correct rendering with OpenGL or OpenGL ES, see the @ref + * GLFW_SRGB_CAPABLE hint. + * + * @param[in] monitor The monitor whose gamma ramp to set. + * @param[in] ramp The gamma ramp to use. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @remark The size of the specified gamma ramp should match the size of the + * current ramp for that monitor. + * + * @remark @win32 The gamma ramp size must be 256. + * + * @remark @wayland Gamma handling is a privileged protocol, this function + * will thus never be implemented and emits @ref GLFW_PLATFORM_ERROR. + * + * @pointer_lifetime The specified gamma ramp is copied before this function + * returns. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref monitor_gamma + * + * @since Added in version 3.0. + * + * @ingroup monitor + */ +GLFWAPI void glfwSetGammaRamp(GLFWmonitor* monitor, const GLFWgammaramp* ramp); + +/*! @brief Resets all window hints to their default values. + * + * This function resets all window hints to their + * [default values](@ref window_hints_values). + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_hints + * @sa @ref glfwWindowHint + * @sa @ref glfwWindowHintString + * + * @since Added in version 3.0. + * + * @ingroup window + */ +GLFWAPI void glfwDefaultWindowHints(void); + +/*! @brief Sets the specified window hint to the desired value. + * + * This function sets hints for the next call to @ref glfwCreateWindow. The + * hints, once set, retain their values until changed by a call to this + * function or @ref glfwDefaultWindowHints, or until the library is terminated. + * + * Only integer value hints can be set with this function. String value hints + * are set with @ref glfwWindowHintString. + * + * This function does not check whether the specified hint values are valid. + * If you set hints to invalid values this will instead be reported by the next + * call to @ref glfwCreateWindow. + * + * Some hints are platform specific. These may be set on any platform but they + * will only affect their specific platform. Other platforms will ignore them. + * Setting these hints requires no platform specific headers or functions. + * + * @param[in] hint The [window hint](@ref window_hints) to set. + * @param[in] value The new value of the window hint. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_INVALID_ENUM. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_hints + * @sa @ref glfwWindowHintString + * @sa @ref glfwDefaultWindowHints + * + * @since Added in version 3.0. Replaces `glfwOpenWindowHint`. + * + * @ingroup window + */ +GLFWAPI void glfwWindowHint(int hint, int value); + +/*! @brief Sets the specified window hint to the desired value. + * + * This function sets hints for the next call to @ref glfwCreateWindow. The + * hints, once set, retain their values until changed by a call to this + * function or @ref glfwDefaultWindowHints, or until the library is terminated. + * + * Only string type hints can be set with this function. Integer value hints + * are set with @ref glfwWindowHint. + * + * This function does not check whether the specified hint values are valid. + * If you set hints to invalid values this will instead be reported by the next + * call to @ref glfwCreateWindow. + * + * Some hints are platform specific. These may be set on any platform but they + * will only affect their specific platform. Other platforms will ignore them. + * Setting these hints requires no platform specific headers or functions. + * + * @param[in] hint The [window hint](@ref window_hints) to set. + * @param[in] value The new value of the window hint. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_INVALID_ENUM. + * + * @pointer_lifetime The specified string is copied before this function + * returns. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_hints + * @sa @ref glfwWindowHint + * @sa @ref glfwDefaultWindowHints + * + * @since Added in version 3.3. + * + * @ingroup window + */ +GLFWAPI void glfwWindowHintString(int hint, const char* value); + +/*! @brief Creates a window and its associated context. + * + * This function creates a window and its associated OpenGL or OpenGL ES + * context. Most of the options controlling how the window and its context + * should be created are specified with [window hints](@ref window_hints). + * + * Successful creation does not change which context is current. Before you + * can use the newly created context, you need to + * [make it current](@ref context_current). For information about the `share` + * parameter, see @ref context_sharing. + * + * The created window, framebuffer and context may differ from what you + * requested, as not all parameters and hints are + * [hard constraints](@ref window_hints_hard). This includes the size of the + * window, especially for full screen windows. To query the actual attributes + * of the created window, framebuffer and context, see @ref + * glfwGetWindowAttrib, @ref glfwGetWindowSize and @ref glfwGetFramebufferSize. + * + * To create a full screen window, you need to specify the monitor the window + * will cover. If no monitor is specified, the window will be windowed mode. + * Unless you have a way for the user to choose a specific monitor, it is + * recommended that you pick the primary monitor. For more information on how + * to query connected monitors, see @ref monitor_monitors. + * + * For full screen windows, the specified size becomes the resolution of the + * window's _desired video mode_. As long as a full screen window is not + * iconified, the supported video mode most closely matching the desired video + * mode is set for the specified monitor. For more information about full + * screen windows, including the creation of so called _windowed full screen_ + * or _borderless full screen_ windows, see @ref window_windowed_full_screen. + * + * Once you have created the window, you can switch it between windowed and + * full screen mode with @ref glfwSetWindowMonitor. This will not affect its + * OpenGL or OpenGL ES context. + * + * By default, newly created windows use the placement recommended by the + * window system. To create the window at a specific position, make it + * initially invisible using the [GLFW_VISIBLE](@ref GLFW_VISIBLE_hint) window + * hint, set its [position](@ref window_pos) and then [show](@ref window_hide) + * it. + * + * As long as at least one full screen window is not iconified, the screensaver + * is prohibited from starting. + * + * Window systems put limits on window sizes. Very large or very small window + * dimensions may be overridden by the window system on creation. Check the + * actual [size](@ref window_size) after creation. + * + * The [swap interval](@ref buffer_swap) is not set during window creation and + * the initial value may vary depending on driver settings and defaults. + * + * @param[in] width The desired width, in screen coordinates, of the window. + * This must be greater than zero. + * @param[in] height The desired height, in screen coordinates, of the window. + * This must be greater than zero. + * @param[in] title The initial, UTF-8 encoded window title. + * @param[in] monitor The monitor to use for full screen mode, or `NULL` for + * windowed mode. + * @param[in] share The window whose context to share resources with, or `NULL` + * to not share resources. + * @return The handle of the created window, or `NULL` if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_INVALID_ENUM, @ref GLFW_INVALID_VALUE, @ref GLFW_API_UNAVAILABLE, @ref + * GLFW_VERSION_UNAVAILABLE, @ref GLFW_FORMAT_UNAVAILABLE and @ref + * GLFW_PLATFORM_ERROR. + * + * @remark @win32 Window creation will fail if the Microsoft GDI software + * OpenGL implementation is the only one available. + * + * @remark @win32 If the executable has an icon resource named `GLFW_ICON,` it + * will be set as the initial icon for the window. If no such icon is present, + * the `IDI_APPLICATION` icon will be used instead. To set a different icon, + * see @ref glfwSetWindowIcon. + * + * @remark @win32 The context to share resources with must not be current on + * any other thread. + * + * @remark @macos The OS only supports forward-compatible core profile contexts + * for OpenGL versions 3.2 and later. Before creating an OpenGL context of + * version 3.2 or later you must set the + * [GLFW_OPENGL_FORWARD_COMPAT](@ref GLFW_OPENGL_FORWARD_COMPAT_hint) and + * [GLFW_OPENGL_PROFILE](@ref GLFW_OPENGL_PROFILE_hint) hints accordingly. + * OpenGL 3.0 and 3.1 contexts are not supported at all on macOS. + * + * @remark @macos The GLFW window has no icon, as it is not a document + * window, but the dock icon will be the same as the application bundle's icon. + * For more information on bundles, see the + * [Bundle Programming Guide](https://developer.apple.com/library/mac/documentation/CoreFoundation/Conceptual/CFBundles/) + * in the Mac Developer Library. + * + * @remark @macos The first time a window is created the menu bar is created. + * If GLFW finds a `MainMenu.nib` it is loaded and assumed to contain a menu + * bar. Otherwise a minimal menu bar is created manually with common commands + * like Hide, Quit and About. The About entry opens a minimal about dialog + * with information from the application's bundle. Menu bar creation can be + * disabled entirely with the @ref GLFW_COCOA_MENUBAR init hint. + * + * @remark @macos On OS X 10.10 and later the window frame will not be rendered + * at full resolution on Retina displays unless the + * [GLFW_COCOA_RETINA_FRAMEBUFFER](@ref GLFW_COCOA_RETINA_FRAMEBUFFER_hint) + * hint is `GLFW_TRUE` and the `NSHighResolutionCapable` key is enabled in the + * application bundle's `Info.plist`. For more information, see + * [High Resolution Guidelines for OS X](https://developer.apple.com/library/mac/documentation/GraphicsAnimation/Conceptual/HighResolutionOSX/Explained/Explained.html) + * in the Mac Developer Library. The GLFW test and example programs use + * a custom `Info.plist` template for this, which can be found as + * `CMake/MacOSXBundleInfo.plist.in` in the source tree. + * + * @remark @macos When activating frame autosaving with + * [GLFW_COCOA_FRAME_NAME](@ref GLFW_COCOA_FRAME_NAME_hint), the specified + * window size and position may be overridden by previously saved values. + * + * @remark @x11 Some window managers will not respect the placement of + * initially hidden windows. + * + * @remark @x11 Due to the asynchronous nature of X11, it may take a moment for + * a window to reach its requested state. This means you may not be able to + * query the final size, position or other attributes directly after window + * creation. + * + * @remark @x11 The class part of the `WM_CLASS` window property will by + * default be set to the window title passed to this function. The instance + * part will use the contents of the `RESOURCE_NAME` environment variable, if + * present and not empty, or fall back to the window title. Set the + * [GLFW_X11_CLASS_NAME](@ref GLFW_X11_CLASS_NAME_hint) and + * [GLFW_X11_INSTANCE_NAME](@ref GLFW_X11_INSTANCE_NAME_hint) window hints to + * override this. + * + * @remark @wayland Compositors should implement the xdg-decoration protocol + * for GLFW to decorate the window properly. If this protocol isn't + * supported, or if the compositor prefers client-side decorations, a very + * simple fallback frame will be drawn using the wp_viewporter protocol. A + * compositor can still emit close, maximize or fullscreen events, using for + * instance a keybind mechanism. If neither of these protocols is supported, + * the window won't be decorated. + * + * @remark @wayland A full screen window will not attempt to change the mode, + * no matter what the requested size or refresh rate. + * + * @remark @wayland Screensaver inhibition requires the idle-inhibit protocol + * to be implemented in the user's compositor. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_creation + * @sa @ref glfwDestroyWindow + * + * @since Added in version 3.0. Replaces `glfwOpenWindow`. + * + * @ingroup window + */ +GLFWAPI GLFWwindow* glfwCreateWindow(int width, int height, const char* title, GLFWmonitor* monitor, GLFWwindow* share); + +/*! @brief Destroys the specified window and its context. + * + * This function destroys the specified window and its context. On calling + * this function, no further callbacks will be called for that window. + * + * If the context of the specified window is current on the main thread, it is + * detached before being destroyed. + * + * @param[in] window The window to destroy. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @note The context of the specified window must not be current on any other + * thread when this function is called. + * + * @reentrancy This function must not be called from a callback. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_creation + * @sa @ref glfwCreateWindow + * + * @since Added in version 3.0. Replaces `glfwCloseWindow`. + * + * @ingroup window + */ +GLFWAPI void glfwDestroyWindow(GLFWwindow* window); + +/*! @brief Checks the close flag of the specified window. + * + * This function returns the value of the close flag of the specified window. + * + * @param[in] window The window to query. + * @return The value of the close flag. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function may be called from any thread. Access is not + * synchronized. + * + * @sa @ref window_close + * + * @since Added in version 3.0. + * + * @ingroup window + */ +GLFWAPI int glfwWindowShouldClose(GLFWwindow* window); + +/*! @brief Sets the close flag of the specified window. + * + * This function sets the value of the close flag of the specified window. + * This can be used to override the user's attempt to close the window, or + * to signal that it should be closed. + * + * @param[in] window The window whose flag to change. + * @param[in] value The new value. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function may be called from any thread. Access is not + * synchronized. + * + * @sa @ref window_close + * + * @since Added in version 3.0. + * + * @ingroup window + */ +GLFWAPI void glfwSetWindowShouldClose(GLFWwindow* window, int value); + +/*! @brief Sets the title of the specified window. + * + * This function sets the window title, encoded as UTF-8, of the specified + * window. + * + * @param[in] window The window whose title to change. + * @param[in] title The UTF-8 encoded window title. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @remark @macos The window title will not be updated until the next time you + * process events. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_title + * + * @since Added in version 1.0. + * @glfw3 Added window handle parameter. + * + * @ingroup window + */ +GLFWAPI void glfwSetWindowTitle(GLFWwindow* window, const char* title); + +/*! @brief Sets the icon for the specified window. + * + * This function sets the icon of the specified window. If passed an array of + * candidate images, those of or closest to the sizes desired by the system are + * selected. If no images are specified, the window reverts to its default + * icon. + * + * The pixels are 32-bit, little-endian, non-premultiplied RGBA, i.e. eight + * bits per channel with the red channel first. They are arranged canonically + * as packed sequential rows, starting from the top-left corner. + * + * The desired image sizes varies depending on platform and system settings. + * The selected images will be rescaled as needed. Good sizes include 16x16, + * 32x32 and 48x48. + * + * @param[in] window The window whose icon to set. + * @param[in] count The number of images in the specified array, or zero to + * revert to the default window icon. + * @param[in] images The images to create the icon from. This is ignored if + * count is zero. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @pointer_lifetime The specified image data is copied before this function + * returns. + * + * @remark @macos The GLFW window has no icon, as it is not a document + * window, so this function does nothing. The dock icon will be the same as + * the application bundle's icon. For more information on bundles, see the + * [Bundle Programming Guide](https://developer.apple.com/library/mac/documentation/CoreFoundation/Conceptual/CFBundles/) + * in the Mac Developer Library. + * + * @remark @wayland There is no existing protocol to change an icon, the + * window will thus inherit the one defined in the application's desktop file. + * This function always emits @ref GLFW_PLATFORM_ERROR. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_icon + * + * @since Added in version 3.2. + * + * @ingroup window + */ +GLFWAPI void glfwSetWindowIcon(GLFWwindow* window, int count, const GLFWimage* images); + +/*! @brief Retrieves the position of the content area of the specified window. + * + * This function retrieves the position, in screen coordinates, of the + * upper-left corner of the content area of the specified window. + * + * Any or all of the position arguments may be `NULL`. If an error occurs, all + * non-`NULL` position arguments will be set to zero. + * + * @param[in] window The window to query. + * @param[out] xpos Where to store the x-coordinate of the upper-left corner of + * the content area, or `NULL`. + * @param[out] ypos Where to store the y-coordinate of the upper-left corner of + * the content area, or `NULL`. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @remark @wayland There is no way for an application to retrieve the global + * position of its windows, this function will always emit @ref + * GLFW_PLATFORM_ERROR. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_pos + * @sa @ref glfwSetWindowPos + * + * @since Added in version 3.0. + * + * @ingroup window + */ +GLFWAPI void glfwGetWindowPos(GLFWwindow* window, int* xpos, int* ypos); + +/*! @brief Sets the position of the content area of the specified window. + * + * This function sets the position, in screen coordinates, of the upper-left + * corner of the content area of the specified windowed mode window. If the + * window is a full screen window, this function does nothing. + * + * __Do not use this function__ to move an already visible window unless you + * have very good reasons for doing so, as it will confuse and annoy the user. + * + * The window manager may put limits on what positions are allowed. GLFW + * cannot and should not override these limits. + * + * @param[in] window The window to query. + * @param[in] xpos The x-coordinate of the upper-left corner of the content area. + * @param[in] ypos The y-coordinate of the upper-left corner of the content area. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @remark @wayland There is no way for an application to set the global + * position of its windows, this function will always emit @ref + * GLFW_PLATFORM_ERROR. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_pos + * @sa @ref glfwGetWindowPos + * + * @since Added in version 1.0. + * @glfw3 Added window handle parameter. + * + * @ingroup window + */ +GLFWAPI void glfwSetWindowPos(GLFWwindow* window, int xpos, int ypos); + +/*! @brief Retrieves the size of the content area of the specified window. + * + * This function retrieves the size, in screen coordinates, of the content area + * of the specified window. If you wish to retrieve the size of the + * framebuffer of the window in pixels, see @ref glfwGetFramebufferSize. + * + * Any or all of the size arguments may be `NULL`. If an error occurs, all + * non-`NULL` size arguments will be set to zero. + * + * @param[in] window The window whose size to retrieve. + * @param[out] width Where to store the width, in screen coordinates, of the + * content area, or `NULL`. + * @param[out] height Where to store the height, in screen coordinates, of the + * content area, or `NULL`. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_size + * @sa @ref glfwSetWindowSize + * + * @since Added in version 1.0. + * @glfw3 Added window handle parameter. + * + * @ingroup window + */ +GLFWAPI void glfwGetWindowSize(GLFWwindow* window, int* width, int* height); + +/*! @brief Sets the size limits of the specified window. + * + * This function sets the size limits of the content area of the specified + * window. If the window is full screen, the size limits only take effect + * once it is made windowed. If the window is not resizable, this function + * does nothing. + * + * The size limits are applied immediately to a windowed mode window and may + * cause it to be resized. + * + * The maximum dimensions must be greater than or equal to the minimum + * dimensions and all must be greater than or equal to zero. + * + * @param[in] window The window to set limits for. + * @param[in] minwidth The minimum width, in screen coordinates, of the content + * area, or `GLFW_DONT_CARE`. + * @param[in] minheight The minimum height, in screen coordinates, of the + * content area, or `GLFW_DONT_CARE`. + * @param[in] maxwidth The maximum width, in screen coordinates, of the content + * area, or `GLFW_DONT_CARE`. + * @param[in] maxheight The maximum height, in screen coordinates, of the + * content area, or `GLFW_DONT_CARE`. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_INVALID_VALUE and @ref GLFW_PLATFORM_ERROR. + * + * @remark If you set size limits and an aspect ratio that conflict, the + * results are undefined. + * + * @remark @wayland The size limits will not be applied until the window is + * actually resized, either by the user or by the compositor. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_sizelimits + * @sa @ref glfwSetWindowAspectRatio + * + * @since Added in version 3.2. + * + * @ingroup window + */ +GLFWAPI void glfwSetWindowSizeLimits(GLFWwindow* window, int minwidth, int minheight, int maxwidth, int maxheight); + +/*! @brief Sets the aspect ratio of the specified window. + * + * This function sets the required aspect ratio of the content area of the + * specified window. If the window is full screen, the aspect ratio only takes + * effect once it is made windowed. If the window is not resizable, this + * function does nothing. + * + * The aspect ratio is specified as a numerator and a denominator and both + * values must be greater than zero. For example, the common 16:9 aspect ratio + * is specified as 16 and 9, respectively. + * + * If the numerator and denominator is set to `GLFW_DONT_CARE` then the aspect + * ratio limit is disabled. + * + * The aspect ratio is applied immediately to a windowed mode window and may + * cause it to be resized. + * + * @param[in] window The window to set limits for. + * @param[in] numer The numerator of the desired aspect ratio, or + * `GLFW_DONT_CARE`. + * @param[in] denom The denominator of the desired aspect ratio, or + * `GLFW_DONT_CARE`. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_INVALID_VALUE and @ref GLFW_PLATFORM_ERROR. + * + * @remark If you set size limits and an aspect ratio that conflict, the + * results are undefined. + * + * @remark @wayland The aspect ratio will not be applied until the window is + * actually resized, either by the user or by the compositor. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_sizelimits + * @sa @ref glfwSetWindowSizeLimits + * + * @since Added in version 3.2. + * + * @ingroup window + */ +GLFWAPI void glfwSetWindowAspectRatio(GLFWwindow* window, int numer, int denom); + +/*! @brief Sets the size of the content area of the specified window. + * + * This function sets the size, in screen coordinates, of the content area of + * the specified window. + * + * For full screen windows, this function updates the resolution of its desired + * video mode and switches to the video mode closest to it, without affecting + * the window's context. As the context is unaffected, the bit depths of the + * framebuffer remain unchanged. + * + * If you wish to update the refresh rate of the desired video mode in addition + * to its resolution, see @ref glfwSetWindowMonitor. + * + * The window manager may put limits on what sizes are allowed. GLFW cannot + * and should not override these limits. + * + * @param[in] window The window to resize. + * @param[in] width The desired width, in screen coordinates, of the window + * content area. + * @param[in] height The desired height, in screen coordinates, of the window + * content area. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @remark @wayland A full screen window will not attempt to change the mode, + * no matter what the requested size. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_size + * @sa @ref glfwGetWindowSize + * @sa @ref glfwSetWindowMonitor + * + * @since Added in version 1.0. + * @glfw3 Added window handle parameter. + * + * @ingroup window + */ +GLFWAPI void glfwSetWindowSize(GLFWwindow* window, int width, int height); + +/*! @brief Retrieves the size of the framebuffer of the specified window. + * + * This function retrieves the size, in pixels, of the framebuffer of the + * specified window. If you wish to retrieve the size of the window in screen + * coordinates, see @ref glfwGetWindowSize. + * + * Any or all of the size arguments may be `NULL`. If an error occurs, all + * non-`NULL` size arguments will be set to zero. + * + * @param[in] window The window whose framebuffer to query. + * @param[out] width Where to store the width, in pixels, of the framebuffer, + * or `NULL`. + * @param[out] height Where to store the height, in pixels, of the framebuffer, + * or `NULL`. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_fbsize + * @sa @ref glfwSetFramebufferSizeCallback + * + * @since Added in version 3.0. + * + * @ingroup window + */ +GLFWAPI void glfwGetFramebufferSize(GLFWwindow* window, int* width, int* height); + +/*! @brief Retrieves the size of the frame of the window. + * + * This function retrieves the size, in screen coordinates, of each edge of the + * frame of the specified window. This size includes the title bar, if the + * window has one. The size of the frame may vary depending on the + * [window-related hints](@ref window_hints_wnd) used to create it. + * + * Because this function retrieves the size of each window frame edge and not + * the offset along a particular coordinate axis, the retrieved values will + * always be zero or positive. + * + * Any or all of the size arguments may be `NULL`. If an error occurs, all + * non-`NULL` size arguments will be set to zero. + * + * @param[in] window The window whose frame size to query. + * @param[out] left Where to store the size, in screen coordinates, of the left + * edge of the window frame, or `NULL`. + * @param[out] top Where to store the size, in screen coordinates, of the top + * edge of the window frame, or `NULL`. + * @param[out] right Where to store the size, in screen coordinates, of the + * right edge of the window frame, or `NULL`. + * @param[out] bottom Where to store the size, in screen coordinates, of the + * bottom edge of the window frame, or `NULL`. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_size + * + * @since Added in version 3.1. + * + * @ingroup window + */ +GLFWAPI void glfwGetWindowFrameSize(GLFWwindow* window, int* left, int* top, int* right, int* bottom); + +/*! @brief Retrieves the content scale for the specified window. + * + * This function retrieves the content scale for the specified window. The + * content scale is the ratio between the current DPI and the platform's + * default DPI. This is especially important for text and any UI elements. If + * the pixel dimensions of your UI scaled by this look appropriate on your + * machine then it should appear at a reasonable size on other machines + * regardless of their DPI and scaling settings. This relies on the system DPI + * and scaling settings being somewhat correct. + * + * On systems where each monitors can have its own content scale, the window + * content scale will depend on which monitor the system considers the window + * to be on. + * + * @param[in] window The window to query. + * @param[out] xscale Where to store the x-axis content scale, or `NULL`. + * @param[out] yscale Where to store the y-axis content scale, or `NULL`. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_scale + * @sa @ref glfwSetWindowContentScaleCallback + * @sa @ref glfwGetMonitorContentScale + * + * @since Added in version 3.3. + * + * @ingroup window + */ +GLFWAPI void glfwGetWindowContentScale(GLFWwindow* window, float* xscale, float* yscale); + +/*! @brief Returns the opacity of the whole window. + * + * This function returns the opacity of the window, including any decorations. + * + * The opacity (or alpha) value is a positive finite number between zero and + * one, where zero is fully transparent and one is fully opaque. If the system + * does not support whole window transparency, this function always returns one. + * + * The initial opacity value for newly created windows is one. + * + * @param[in] window The window to query. + * @return The opacity value of the specified window. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_transparency + * @sa @ref glfwSetWindowOpacity + * + * @since Added in version 3.3. + * + * @ingroup window + */ +GLFWAPI float glfwGetWindowOpacity(GLFWwindow* window); + +/*! @brief Sets the opacity of the whole window. + * + * This function sets the opacity of the window, including any decorations. + * + * The opacity (or alpha) value is a positive finite number between zero and + * one, where zero is fully transparent and one is fully opaque. + * + * The initial opacity value for newly created windows is one. + * + * A window created with framebuffer transparency may not use whole window + * transparency. The results of doing this are undefined. + * + * @param[in] window The window to set the opacity for. + * @param[in] opacity The desired opacity of the specified window. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_transparency + * @sa @ref glfwGetWindowOpacity + * + * @since Added in version 3.3. + * + * @ingroup window + */ +GLFWAPI void glfwSetWindowOpacity(GLFWwindow* window, float opacity); + +/*! @brief Iconifies the specified window. + * + * This function iconifies (minimizes) the specified window if it was + * previously restored. If the window is already iconified, this function does + * nothing. + * + * If the specified window is a full screen window, the original monitor + * resolution is restored until the window is restored. + * + * @param[in] window The window to iconify. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @remark @wayland There is no concept of iconification in wl_shell, this + * function will emit @ref GLFW_PLATFORM_ERROR when using this deprecated + * protocol. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_iconify + * @sa @ref glfwRestoreWindow + * @sa @ref glfwMaximizeWindow + * + * @since Added in version 2.1. + * @glfw3 Added window handle parameter. + * + * @ingroup window + */ +GLFWAPI void glfwIconifyWindow(GLFWwindow* window); + +/*! @brief Restores the specified window. + * + * This function restores the specified window if it was previously iconified + * (minimized) or maximized. If the window is already restored, this function + * does nothing. + * + * If the specified window is a full screen window, the resolution chosen for + * the window is restored on the selected monitor. + * + * @param[in] window The window to restore. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_iconify + * @sa @ref glfwIconifyWindow + * @sa @ref glfwMaximizeWindow + * + * @since Added in version 2.1. + * @glfw3 Added window handle parameter. + * + * @ingroup window + */ +GLFWAPI void glfwRestoreWindow(GLFWwindow* window); + +/*! @brief Maximizes the specified window. + * + * This function maximizes the specified window if it was previously not + * maximized. If the window is already maximized, this function does nothing. + * + * If the specified window is a full screen window, this function does nothing. + * + * @param[in] window The window to maximize. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @par Thread Safety + * This function may only be called from the main thread. + * + * @sa @ref window_iconify + * @sa @ref glfwIconifyWindow + * @sa @ref glfwRestoreWindow + * + * @since Added in GLFW 3.2. + * + * @ingroup window + */ +GLFWAPI void glfwMaximizeWindow(GLFWwindow* window); + +/*! @brief Makes the specified window visible. + * + * This function makes the specified window visible if it was previously + * hidden. If the window is already visible or is in full screen mode, this + * function does nothing. + * + * By default, windowed mode windows are focused when shown + * Set the [GLFW_FOCUS_ON_SHOW](@ref GLFW_FOCUS_ON_SHOW_hint) window hint + * to change this behavior for all newly created windows, or change the + * behavior for an existing window with @ref glfwSetWindowAttrib. + * + * @param[in] window The window to make visible. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @remark @wayland Because Wayland wants every frame of the desktop to be + * complete, this function does not immediately make the window visible. + * Instead it will become visible the next time the window framebuffer is + * updated after this call. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_hide + * @sa @ref glfwHideWindow + * + * @since Added in version 3.0. + * + * @ingroup window + */ +GLFWAPI void glfwShowWindow(GLFWwindow* window); + +/*! @brief Hides the specified window. + * + * This function hides the specified window if it was previously visible. If + * the window is already hidden or is in full screen mode, this function does + * nothing. + * + * @param[in] window The window to hide. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_hide + * @sa @ref glfwShowWindow + * + * @since Added in version 3.0. + * + * @ingroup window + */ +GLFWAPI void glfwHideWindow(GLFWwindow* window); + +/*! @brief Brings the specified window to front and sets input focus. + * + * This function brings the specified window to front and sets input focus. + * The window should already be visible and not iconified. + * + * By default, both windowed and full screen mode windows are focused when + * initially created. Set the [GLFW_FOCUSED](@ref GLFW_FOCUSED_hint) to + * disable this behavior. + * + * Also by default, windowed mode windows are focused when shown + * with @ref glfwShowWindow. Set the + * [GLFW_FOCUS_ON_SHOW](@ref GLFW_FOCUS_ON_SHOW_hint) to disable this behavior. + * + * __Do not use this function__ to steal focus from other applications unless + * you are certain that is what the user wants. Focus stealing can be + * extremely disruptive. + * + * For a less disruptive way of getting the user's attention, see + * [attention requests](@ref window_attention). + * + * @param[in] window The window to give input focus. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @remark @wayland It is not possible for an application to bring its windows + * to front, this function will always emit @ref GLFW_PLATFORM_ERROR. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_focus + * @sa @ref window_attention + * + * @since Added in version 3.2. + * + * @ingroup window + */ +GLFWAPI void glfwFocusWindow(GLFWwindow* window); + +/*! @brief Requests user attention to the specified window. + * + * This function requests user attention to the specified window. On + * platforms where this is not supported, attention is requested to the + * application as a whole. + * + * Once the user has given attention, usually by focusing the window or + * application, the system will end the request automatically. + * + * @param[in] window The window to request attention to. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @remark @macos Attention is requested to the application as a whole, not the + * specific window. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_attention + * + * @since Added in version 3.3. + * + * @ingroup window + */ +GLFWAPI void glfwRequestWindowAttention(GLFWwindow* window); + +/*! @brief Returns the monitor that the window uses for full screen mode. + * + * This function returns the handle of the monitor that the specified window is + * in full screen on. + * + * @param[in] window The window to query. + * @return The monitor, or `NULL` if the window is in windowed mode or an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_monitor + * @sa @ref glfwSetWindowMonitor + * + * @since Added in version 3.0. + * + * @ingroup window + */ +GLFWAPI GLFWmonitor* glfwGetWindowMonitor(GLFWwindow* window); + +/*! @brief Sets the mode, monitor, video mode and placement of a window. + * + * This function sets the monitor that the window uses for full screen mode or, + * if the monitor is `NULL`, makes it windowed mode. + * + * When setting a monitor, this function updates the width, height and refresh + * rate of the desired video mode and switches to the video mode closest to it. + * The window position is ignored when setting a monitor. + * + * When the monitor is `NULL`, the position, width and height are used to + * place the window content area. The refresh rate is ignored when no monitor + * is specified. + * + * If you only wish to update the resolution of a full screen window or the + * size of a windowed mode window, see @ref glfwSetWindowSize. + * + * When a window transitions from full screen to windowed mode, this function + * restores any previous window settings such as whether it is decorated, + * floating, resizable, has size or aspect ratio limits, etc. + * + * @param[in] window The window whose monitor, size or video mode to set. + * @param[in] monitor The desired monitor, or `NULL` to set windowed mode. + * @param[in] xpos The desired x-coordinate of the upper-left corner of the + * content area. + * @param[in] ypos The desired y-coordinate of the upper-left corner of the + * content area. + * @param[in] width The desired with, in screen coordinates, of the content + * area or video mode. + * @param[in] height The desired height, in screen coordinates, of the content + * area or video mode. + * @param[in] refreshRate The desired refresh rate, in Hz, of the video mode, + * or `GLFW_DONT_CARE`. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @remark The OpenGL or OpenGL ES context will not be destroyed or otherwise + * affected by any resizing or mode switching, although you may need to update + * your viewport if the framebuffer size has changed. + * + * @remark @wayland The desired window position is ignored, as there is no way + * for an application to set this property. + * + * @remark @wayland Setting the window to full screen will not attempt to + * change the mode, no matter what the requested size or refresh rate. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_monitor + * @sa @ref window_full_screen + * @sa @ref glfwGetWindowMonitor + * @sa @ref glfwSetWindowSize + * + * @since Added in version 3.2. + * + * @ingroup window + */ +GLFWAPI void glfwSetWindowMonitor(GLFWwindow* window, GLFWmonitor* monitor, int xpos, int ypos, int width, int height, int refreshRate); + +/*! @brief Returns an attribute of the specified window. + * + * This function returns the value of an attribute of the specified window or + * its OpenGL or OpenGL ES context. + * + * @param[in] window The window to query. + * @param[in] attrib The [window attribute](@ref window_attribs) whose value to + * return. + * @return The value of the attribute, or zero if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_INVALID_ENUM and @ref GLFW_PLATFORM_ERROR. + * + * @remark Framebuffer related hints are not window attributes. See @ref + * window_attribs_fb for more information. + * + * @remark Zero is a valid value for many window and context related + * attributes so you cannot use a return value of zero as an indication of + * errors. However, this function should not fail as long as it is passed + * valid arguments and the library has been [initialized](@ref intro_init). + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_attribs + * @sa @ref glfwSetWindowAttrib + * + * @since Added in version 3.0. Replaces `glfwGetWindowParam` and + * `glfwGetGLVersion`. + * + * @ingroup window + */ +GLFWAPI int glfwGetWindowAttrib(GLFWwindow* window, int attrib); + +/*! @brief Sets an attribute of the specified window. + * + * This function sets the value of an attribute of the specified window. + * + * The supported attributes are [GLFW_DECORATED](@ref GLFW_DECORATED_attrib), + * [GLFW_RESIZABLE](@ref GLFW_RESIZABLE_attrib), + * [GLFW_FLOATING](@ref GLFW_FLOATING_attrib), + * [GLFW_AUTO_ICONIFY](@ref GLFW_AUTO_ICONIFY_attrib) and + * [GLFW_FOCUS_ON_SHOW](@ref GLFW_FOCUS_ON_SHOW_attrib). + * + * Some of these attributes are ignored for full screen windows. The new + * value will take effect if the window is later made windowed. + * + * Some of these attributes are ignored for windowed mode windows. The new + * value will take effect if the window is later made full screen. + * + * @param[in] window The window to set the attribute for. + * @param[in] attrib A supported window attribute. + * @param[in] value `GLFW_TRUE` or `GLFW_FALSE`. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_INVALID_ENUM, @ref GLFW_INVALID_VALUE and @ref GLFW_PLATFORM_ERROR. + * + * @remark Calling @ref glfwGetWindowAttrib will always return the latest + * value, even if that value is ignored by the current mode of the window. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_attribs + * @sa @ref glfwGetWindowAttrib + * + * @since Added in version 3.3. + * + * @ingroup window + */ +GLFWAPI void glfwSetWindowAttrib(GLFWwindow* window, int attrib, int value); + +/*! @brief Sets the user pointer of the specified window. + * + * This function sets the user-defined pointer of the specified window. The + * current value is retained until the window is destroyed. The initial value + * is `NULL`. + * + * @param[in] window The window whose pointer to set. + * @param[in] pointer The new value. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function may be called from any thread. Access is not + * synchronized. + * + * @sa @ref window_userptr + * @sa @ref glfwGetWindowUserPointer + * + * @since Added in version 3.0. + * + * @ingroup window + */ +GLFWAPI void glfwSetWindowUserPointer(GLFWwindow* window, void* pointer); + +/*! @brief Returns the user pointer of the specified window. + * + * This function returns the current value of the user-defined pointer of the + * specified window. The initial value is `NULL`. + * + * @param[in] window The window whose pointer to return. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function may be called from any thread. Access is not + * synchronized. + * + * @sa @ref window_userptr + * @sa @ref glfwSetWindowUserPointer + * + * @since Added in version 3.0. + * + * @ingroup window + */ +GLFWAPI void* glfwGetWindowUserPointer(GLFWwindow* window); + +/*! @brief Sets the position callback for the specified window. + * + * This function sets the position callback of the specified window, which is + * called when the window is moved. The callback is provided with the + * position, in screen coordinates, of the upper-left corner of the content + * area of the window. + * + * @param[in] window The window whose callback to set. + * @param[in] callback The new callback, or `NULL` to remove the currently set + * callback. + * @return The previously set callback, or `NULL` if no callback was set or the + * library had not been [initialized](@ref intro_init). + * + * @callback_signature + * @code + * void function_name(GLFWwindow* window, int xpos, int ypos) + * @endcode + * For more information about the callback parameters, see the + * [function pointer type](@ref GLFWwindowposfun). + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @remark @wayland This callback will never be called, as there is no way for + * an application to know its global position. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_pos + * + * @since Added in version 3.0. + * + * @ingroup window + */ +GLFWAPI GLFWwindowposfun glfwSetWindowPosCallback(GLFWwindow* window, GLFWwindowposfun callback); + +/*! @brief Sets the size callback for the specified window. + * + * This function sets the size callback of the specified window, which is + * called when the window is resized. The callback is provided with the size, + * in screen coordinates, of the content area of the window. + * + * @param[in] window The window whose callback to set. + * @param[in] callback The new callback, or `NULL` to remove the currently set + * callback. + * @return The previously set callback, or `NULL` if no callback was set or the + * library had not been [initialized](@ref intro_init). + * + * @callback_signature + * @code + * void function_name(GLFWwindow* window, int width, int height) + * @endcode + * For more information about the callback parameters, see the + * [function pointer type](@ref GLFWwindowsizefun). + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_size + * + * @since Added in version 1.0. + * @glfw3 Added window handle parameter and return value. + * + * @ingroup window + */ +GLFWAPI GLFWwindowsizefun glfwSetWindowSizeCallback(GLFWwindow* window, GLFWwindowsizefun callback); + +/*! @brief Sets the close callback for the specified window. + * + * This function sets the close callback of the specified window, which is + * called when the user attempts to close the window, for example by clicking + * the close widget in the title bar. + * + * The close flag is set before this callback is called, but you can modify it + * at any time with @ref glfwSetWindowShouldClose. + * + * The close callback is not triggered by @ref glfwDestroyWindow. + * + * @param[in] window The window whose callback to set. + * @param[in] callback The new callback, or `NULL` to remove the currently set + * callback. + * @return The previously set callback, or `NULL` if no callback was set or the + * library had not been [initialized](@ref intro_init). + * + * @callback_signature + * @code + * void function_name(GLFWwindow* window) + * @endcode + * For more information about the callback parameters, see the + * [function pointer type](@ref GLFWwindowclosefun). + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @remark @macos Selecting Quit from the application menu will trigger the + * close callback for all windows. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_close + * + * @since Added in version 2.5. + * @glfw3 Added window handle parameter and return value. + * + * @ingroup window + */ +GLFWAPI GLFWwindowclosefun glfwSetWindowCloseCallback(GLFWwindow* window, GLFWwindowclosefun callback); + +/*! @brief Sets the refresh callback for the specified window. + * + * This function sets the refresh callback of the specified window, which is + * called when the content area of the window needs to be redrawn, for example + * if the window has been exposed after having been covered by another window. + * + * On compositing window systems such as Aero, Compiz, Aqua or Wayland, where + * the window contents are saved off-screen, this callback may be called only + * very infrequently or never at all. + * + * @param[in] window The window whose callback to set. + * @param[in] callback The new callback, or `NULL` to remove the currently set + * callback. + * @return The previously set callback, or `NULL` if no callback was set or the + * library had not been [initialized](@ref intro_init). + * + * @callback_signature + * @code + * void function_name(GLFWwindow* window); + * @endcode + * For more information about the callback parameters, see the + * [function pointer type](@ref GLFWwindowrefreshfun). + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_refresh + * + * @since Added in version 2.5. + * @glfw3 Added window handle parameter and return value. + * + * @ingroup window + */ +GLFWAPI GLFWwindowrefreshfun glfwSetWindowRefreshCallback(GLFWwindow* window, GLFWwindowrefreshfun callback); + +/*! @brief Sets the focus callback for the specified window. + * + * This function sets the focus callback of the specified window, which is + * called when the window gains or loses input focus. + * + * After the focus callback is called for a window that lost input focus, + * synthetic key and mouse button release events will be generated for all such + * that had been pressed. For more information, see @ref glfwSetKeyCallback + * and @ref glfwSetMouseButtonCallback. + * + * @param[in] window The window whose callback to set. + * @param[in] callback The new callback, or `NULL` to remove the currently set + * callback. + * @return The previously set callback, or `NULL` if no callback was set or the + * library had not been [initialized](@ref intro_init). + * + * @callback_signature + * @code + * void function_name(GLFWwindow* window, int focused) + * @endcode + * For more information about the callback parameters, see the + * [function pointer type](@ref GLFWwindowfocusfun). + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_focus + * + * @since Added in version 3.0. + * + * @ingroup window + */ +GLFWAPI GLFWwindowfocusfun glfwSetWindowFocusCallback(GLFWwindow* window, GLFWwindowfocusfun callback); + +/*! @brief Sets the iconify callback for the specified window. + * + * This function sets the iconification callback of the specified window, which + * is called when the window is iconified or restored. + * + * @param[in] window The window whose callback to set. + * @param[in] callback The new callback, or `NULL` to remove the currently set + * callback. + * @return The previously set callback, or `NULL` if no callback was set or the + * library had not been [initialized](@ref intro_init). + * + * @callback_signature + * @code + * void function_name(GLFWwindow* window, int iconified) + * @endcode + * For more information about the callback parameters, see the + * [function pointer type](@ref GLFWwindowiconifyfun). + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @remark @wayland The wl_shell protocol has no concept of iconification, + * this callback will never be called when using this deprecated protocol. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_iconify + * + * @since Added in version 3.0. + * + * @ingroup window + */ +GLFWAPI GLFWwindowiconifyfun glfwSetWindowIconifyCallback(GLFWwindow* window, GLFWwindowiconifyfun callback); + +/*! @brief Sets the maximize callback for the specified window. + * + * This function sets the maximization callback of the specified window, which + * is called when the window is maximized or restored. + * + * @param[in] window The window whose callback to set. + * @param[in] callback The new callback, or `NULL` to remove the currently set + * callback. + * @return The previously set callback, or `NULL` if no callback was set or the + * library had not been [initialized](@ref intro_init). + * + * @callback_signature + * @code + * void function_name(GLFWwindow* window, int maximized) + * @endcode + * For more information about the callback parameters, see the + * [function pointer type](@ref GLFWwindowmaximizefun). + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_maximize + * + * @since Added in version 3.3. + * + * @ingroup window + */ +GLFWAPI GLFWwindowmaximizefun glfwSetWindowMaximizeCallback(GLFWwindow* window, GLFWwindowmaximizefun callback); + +/*! @brief Sets the framebuffer resize callback for the specified window. + * + * This function sets the framebuffer resize callback of the specified window, + * which is called when the framebuffer of the specified window is resized. + * + * @param[in] window The window whose callback to set. + * @param[in] callback The new callback, or `NULL` to remove the currently set + * callback. + * @return The previously set callback, or `NULL` if no callback was set or the + * library had not been [initialized](@ref intro_init). + * + * @callback_signature + * @code + * void function_name(GLFWwindow* window, int width, int height) + * @endcode + * For more information about the callback parameters, see the + * [function pointer type](@ref GLFWframebuffersizefun). + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_fbsize + * + * @since Added in version 3.0. + * + * @ingroup window + */ +GLFWAPI GLFWframebuffersizefun glfwSetFramebufferSizeCallback(GLFWwindow* window, GLFWframebuffersizefun callback); + +/*! @brief Sets the window content scale callback for the specified window. + * + * This function sets the window content scale callback of the specified window, + * which is called when the content scale of the specified window changes. + * + * @param[in] window The window whose callback to set. + * @param[in] callback The new callback, or `NULL` to remove the currently set + * callback. + * @return The previously set callback, or `NULL` if no callback was set or the + * library had not been [initialized](@ref intro_init). + * + * @callback_signature + * @code + * void function_name(GLFWwindow* window, float xscale, float yscale) + * @endcode + * For more information about the callback parameters, see the + * [function pointer type](@ref GLFWwindowcontentscalefun). + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref window_scale + * @sa @ref glfwGetWindowContentScale + * + * @since Added in version 3.3. + * + * @ingroup window + */ +GLFWAPI GLFWwindowcontentscalefun glfwSetWindowContentScaleCallback(GLFWwindow* window, GLFWwindowcontentscalefun callback); + +/*! @brief Processes all pending events. + * + * This function processes only those events that are already in the event + * queue and then returns immediately. Processing events will cause the window + * and input callbacks associated with those events to be called. + * + * On some platforms, a window move, resize or menu operation will cause event + * processing to block. This is due to how event processing is designed on + * those platforms. You can use the + * [window refresh callback](@ref window_refresh) to redraw the contents of + * your window when necessary during such operations. + * + * Do not assume that callbacks you set will _only_ be called in response to + * event processing functions like this one. While it is necessary to poll for + * events, window systems that require GLFW to register callbacks of its own + * can pass events to GLFW in response to many window system function calls. + * GLFW will pass those events on to the application callbacks before + * returning. + * + * Event processing is not required for joystick input to work. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @reentrancy This function must not be called from a callback. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref events + * @sa @ref glfwWaitEvents + * @sa @ref glfwWaitEventsTimeout + * + * @since Added in version 1.0. + * + * @ingroup window + */ +GLFWAPI void glfwPollEvents(void); + +/*! @brief Waits until events are queued and processes them. + * + * This function puts the calling thread to sleep until at least one event is + * available in the event queue. Once one or more events are available, + * it behaves exactly like @ref glfwPollEvents, i.e. the events in the queue + * are processed and the function then returns immediately. Processing events + * will cause the window and input callbacks associated with those events to be + * called. + * + * Since not all events are associated with callbacks, this function may return + * without a callback having been called even if you are monitoring all + * callbacks. + * + * On some platforms, a window move, resize or menu operation will cause event + * processing to block. This is due to how event processing is designed on + * those platforms. You can use the + * [window refresh callback](@ref window_refresh) to redraw the contents of + * your window when necessary during such operations. + * + * Do not assume that callbacks you set will _only_ be called in response to + * event processing functions like this one. While it is necessary to poll for + * events, window systems that require GLFW to register callbacks of its own + * can pass events to GLFW in response to many window system function calls. + * GLFW will pass those events on to the application callbacks before + * returning. + * + * Event processing is not required for joystick input to work. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @reentrancy This function must not be called from a callback. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref events + * @sa @ref glfwPollEvents + * @sa @ref glfwWaitEventsTimeout + * + * @since Added in version 2.5. + * + * @ingroup window + */ +GLFWAPI void glfwWaitEvents(void); + +/*! @brief Waits with timeout until events are queued and processes them. + * + * This function puts the calling thread to sleep until at least one event is + * available in the event queue, or until the specified timeout is reached. If + * one or more events are available, it behaves exactly like @ref + * glfwPollEvents, i.e. the events in the queue are processed and the function + * then returns immediately. Processing events will cause the window and input + * callbacks associated with those events to be called. + * + * The timeout value must be a positive finite number. + * + * Since not all events are associated with callbacks, this function may return + * without a callback having been called even if you are monitoring all + * callbacks. + * + * On some platforms, a window move, resize or menu operation will cause event + * processing to block. This is due to how event processing is designed on + * those platforms. You can use the + * [window refresh callback](@ref window_refresh) to redraw the contents of + * your window when necessary during such operations. + * + * Do not assume that callbacks you set will _only_ be called in response to + * event processing functions like this one. While it is necessary to poll for + * events, window systems that require GLFW to register callbacks of its own + * can pass events to GLFW in response to many window system function calls. + * GLFW will pass those events on to the application callbacks before + * returning. + * + * Event processing is not required for joystick input to work. + * + * @param[in] timeout The maximum amount of time, in seconds, to wait. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_INVALID_VALUE and @ref GLFW_PLATFORM_ERROR. + * + * @reentrancy This function must not be called from a callback. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref events + * @sa @ref glfwPollEvents + * @sa @ref glfwWaitEvents + * + * @since Added in version 3.2. + * + * @ingroup window + */ +GLFWAPI void glfwWaitEventsTimeout(double timeout); + +/*! @brief Posts an empty event to the event queue. + * + * This function posts an empty event from the current thread to the event + * queue, causing @ref glfwWaitEvents or @ref glfwWaitEventsTimeout to return. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @thread_safety This function may be called from any thread. + * + * @sa @ref events + * @sa @ref glfwWaitEvents + * @sa @ref glfwWaitEventsTimeout + * + * @since Added in version 3.1. + * + * @ingroup window + */ +GLFWAPI void glfwPostEmptyEvent(void); + +/*! @brief Returns the value of an input option for the specified window. + * + * This function returns the value of an input option for the specified window. + * The mode must be one of @ref GLFW_CURSOR, @ref GLFW_STICKY_KEYS, + * @ref GLFW_STICKY_MOUSE_BUTTONS, @ref GLFW_LOCK_KEY_MODS or + * @ref GLFW_RAW_MOUSE_MOTION. + * + * @param[in] window The window to query. + * @param[in] mode One of `GLFW_CURSOR`, `GLFW_STICKY_KEYS`, + * `GLFW_STICKY_MOUSE_BUTTONS`, `GLFW_LOCK_KEY_MODS` or + * `GLFW_RAW_MOUSE_MOTION`. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_INVALID_ENUM. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref glfwSetInputMode + * + * @since Added in version 3.0. + * + * @ingroup input + */ +GLFWAPI int glfwGetInputMode(GLFWwindow* window, int mode); + +/*! @brief Sets an input option for the specified window. + * + * This function sets an input mode option for the specified window. The mode + * must be one of @ref GLFW_CURSOR, @ref GLFW_STICKY_KEYS, + * @ref GLFW_STICKY_MOUSE_BUTTONS, @ref GLFW_LOCK_KEY_MODS or + * @ref GLFW_RAW_MOUSE_MOTION. + * + * If the mode is `GLFW_CURSOR`, the value must be one of the following cursor + * modes: + * - `GLFW_CURSOR_NORMAL` makes the cursor visible and behaving normally. + * - `GLFW_CURSOR_HIDDEN` makes the cursor invisible when it is over the + * content area of the window but does not restrict the cursor from leaving. + * - `GLFW_CURSOR_DISABLED` hides and grabs the cursor, providing virtual + * and unlimited cursor movement. This is useful for implementing for + * example 3D camera controls. + * + * If the mode is `GLFW_STICKY_KEYS`, the value must be either `GLFW_TRUE` to + * enable sticky keys, or `GLFW_FALSE` to disable it. If sticky keys are + * enabled, a key press will ensure that @ref glfwGetKey returns `GLFW_PRESS` + * the next time it is called even if the key had been released before the + * call. This is useful when you are only interested in whether keys have been + * pressed but not when or in which order. + * + * If the mode is `GLFW_STICKY_MOUSE_BUTTONS`, the value must be either + * `GLFW_TRUE` to enable sticky mouse buttons, or `GLFW_FALSE` to disable it. + * If sticky mouse buttons are enabled, a mouse button press will ensure that + * @ref glfwGetMouseButton returns `GLFW_PRESS` the next time it is called even + * if the mouse button had been released before the call. This is useful when + * you are only interested in whether mouse buttons have been pressed but not + * when or in which order. + * + * If the mode is `GLFW_LOCK_KEY_MODS`, the value must be either `GLFW_TRUE` to + * enable lock key modifier bits, or `GLFW_FALSE` to disable them. If enabled, + * callbacks that receive modifier bits will also have the @ref + * GLFW_MOD_CAPS_LOCK bit set when the event was generated with Caps Lock on, + * and the @ref GLFW_MOD_NUM_LOCK bit when Num Lock was on. + * + * If the mode is `GLFW_RAW_MOUSE_MOTION`, the value must be either `GLFW_TRUE` + * to enable raw (unscaled and unaccelerated) mouse motion when the cursor is + * disabled, or `GLFW_FALSE` to disable it. If raw motion is not supported, + * attempting to set this will emit @ref GLFW_PLATFORM_ERROR. Call @ref + * glfwRawMouseMotionSupported to check for support. + * + * @param[in] window The window whose input mode to set. + * @param[in] mode One of `GLFW_CURSOR`, `GLFW_STICKY_KEYS`, + * `GLFW_STICKY_MOUSE_BUTTONS`, `GLFW_LOCK_KEY_MODS` or + * `GLFW_RAW_MOUSE_MOTION`. + * @param[in] value The new value of the specified input mode. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_INVALID_ENUM and @ref GLFW_PLATFORM_ERROR. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref glfwGetInputMode + * + * @since Added in version 3.0. Replaces `glfwEnable` and `glfwDisable`. + * + * @ingroup input + */ +GLFWAPI void glfwSetInputMode(GLFWwindow* window, int mode, int value); + +/*! @brief Returns whether raw mouse motion is supported. + * + * This function returns whether raw mouse motion is supported on the current + * system. This status does not change after GLFW has been initialized so you + * only need to check this once. If you attempt to enable raw motion on + * a system that does not support it, @ref GLFW_PLATFORM_ERROR will be emitted. + * + * Raw mouse motion is closer to the actual motion of the mouse across + * a surface. It is not affected by the scaling and acceleration applied to + * the motion of the desktop cursor. That processing is suitable for a cursor + * while raw motion is better for controlling for example a 3D camera. Because + * of this, raw mouse motion is only provided when the cursor is disabled. + * + * @return `GLFW_TRUE` if raw mouse motion is supported on the current machine, + * or `GLFW_FALSE` otherwise. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref raw_mouse_motion + * @sa @ref glfwSetInputMode + * + * @since Added in version 3.3. + * + * @ingroup input + */ +GLFWAPI int glfwRawMouseMotionSupported(void); + +/*! @brief Returns the layout-specific name of the specified printable key. + * + * This function returns the name of the specified printable key, encoded as + * UTF-8. This is typically the character that key would produce without any + * modifier keys, intended for displaying key bindings to the user. For dead + * keys, it is typically the diacritic it would add to a character. + * + * __Do not use this function__ for [text input](@ref input_char). You will + * break text input for many languages even if it happens to work for yours. + * + * If the key is `GLFW_KEY_UNKNOWN`, the scancode is used to identify the key, + * otherwise the scancode is ignored. If you specify a non-printable key, or + * `GLFW_KEY_UNKNOWN` and a scancode that maps to a non-printable key, this + * function returns `NULL` but does not emit an error. + * + * This behavior allows you to always pass in the arguments in the + * [key callback](@ref input_key) without modification. + * + * The printable keys are: + * - `GLFW_KEY_APOSTROPHE` + * - `GLFW_KEY_COMMA` + * - `GLFW_KEY_MINUS` + * - `GLFW_KEY_PERIOD` + * - `GLFW_KEY_SLASH` + * - `GLFW_KEY_SEMICOLON` + * - `GLFW_KEY_EQUAL` + * - `GLFW_KEY_LEFT_BRACKET` + * - `GLFW_KEY_RIGHT_BRACKET` + * - `GLFW_KEY_BACKSLASH` + * - `GLFW_KEY_WORLD_1` + * - `GLFW_KEY_WORLD_2` + * - `GLFW_KEY_0` to `GLFW_KEY_9` + * - `GLFW_KEY_A` to `GLFW_KEY_Z` + * - `GLFW_KEY_KP_0` to `GLFW_KEY_KP_9` + * - `GLFW_KEY_KP_DECIMAL` + * - `GLFW_KEY_KP_DIVIDE` + * - `GLFW_KEY_KP_MULTIPLY` + * - `GLFW_KEY_KP_SUBTRACT` + * - `GLFW_KEY_KP_ADD` + * - `GLFW_KEY_KP_EQUAL` + * + * Names for printable keys depend on keyboard layout, while names for + * non-printable keys are the same across layouts but depend on the application + * language and should be localized along with other user interface text. + * + * @param[in] key The key to query, or `GLFW_KEY_UNKNOWN`. + * @param[in] scancode The scancode of the key to query. + * @return The UTF-8 encoded, layout-specific name of the key, or `NULL`. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @remark The contents of the returned string may change when a keyboard + * layout change event is received. + * + * @pointer_lifetime The returned string is allocated and freed by GLFW. You + * should not free it yourself. It is valid until the library is terminated. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref input_key_name + * + * @since Added in version 3.2. + * + * @ingroup input + */ +GLFWAPI const char* glfwGetKeyName(int key, int scancode); + +/*! @brief Returns the platform-specific scancode of the specified key. + * + * This function returns the platform-specific scancode of the specified key. + * + * If the key is `GLFW_KEY_UNKNOWN` or does not exist on the keyboard this + * method will return `-1`. + * + * @param[in] key Any [named key](@ref keys). + * @return The platform-specific scancode for the key, or `-1` if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_INVALID_ENUM and @ref GLFW_PLATFORM_ERROR. + * + * @thread_safety This function may be called from any thread. + * + * @sa @ref input_key + * + * @since Added in version 3.3. + * + * @ingroup input + */ +GLFWAPI int glfwGetKeyScancode(int key); + +/*! @brief Returns the last reported state of a keyboard key for the specified + * window. + * + * This function returns the last state reported for the specified key to the + * specified window. The returned state is one of `GLFW_PRESS` or + * `GLFW_RELEASE`. The higher-level action `GLFW_REPEAT` is only reported to + * the key callback. + * + * If the @ref GLFW_STICKY_KEYS input mode is enabled, this function returns + * `GLFW_PRESS` the first time you call it for a key that was pressed, even if + * that key has already been released. + * + * The key functions deal with physical keys, with [key tokens](@ref keys) + * named after their use on the standard US keyboard layout. If you want to + * input text, use the Unicode character callback instead. + * + * The [modifier key bit masks](@ref mods) are not key tokens and cannot be + * used with this function. + * + * __Do not use this function__ to implement [text input](@ref input_char). + * + * @param[in] window The desired window. + * @param[in] key The desired [keyboard key](@ref keys). `GLFW_KEY_UNKNOWN` is + * not a valid key for this function. + * @return One of `GLFW_PRESS` or `GLFW_RELEASE`. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_INVALID_ENUM. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref input_key + * + * @since Added in version 1.0. + * @glfw3 Added window handle parameter. + * + * @ingroup input + */ +GLFWAPI int glfwGetKey(GLFWwindow* window, int key); + +/*! @brief Returns the last reported state of a mouse button for the specified + * window. + * + * This function returns the last state reported for the specified mouse button + * to the specified window. The returned state is one of `GLFW_PRESS` or + * `GLFW_RELEASE`. + * + * If the @ref GLFW_STICKY_MOUSE_BUTTONS input mode is enabled, this function + * returns `GLFW_PRESS` the first time you call it for a mouse button that was + * pressed, even if that mouse button has already been released. + * + * @param[in] window The desired window. + * @param[in] button The desired [mouse button](@ref buttons). + * @return One of `GLFW_PRESS` or `GLFW_RELEASE`. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_INVALID_ENUM. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref input_mouse_button + * + * @since Added in version 1.0. + * @glfw3 Added window handle parameter. + * + * @ingroup input + */ +GLFWAPI int glfwGetMouseButton(GLFWwindow* window, int button); + +/*! @brief Retrieves the position of the cursor relative to the content area of + * the window. + * + * This function returns the position of the cursor, in screen coordinates, + * relative to the upper-left corner of the content area of the specified + * window. + * + * If the cursor is disabled (with `GLFW_CURSOR_DISABLED`) then the cursor + * position is unbounded and limited only by the minimum and maximum values of + * a `double`. + * + * The coordinate can be converted to their integer equivalents with the + * `floor` function. Casting directly to an integer type works for positive + * coordinates, but fails for negative ones. + * + * Any or all of the position arguments may be `NULL`. If an error occurs, all + * non-`NULL` position arguments will be set to zero. + * + * @param[in] window The desired window. + * @param[out] xpos Where to store the cursor x-coordinate, relative to the + * left edge of the content area, or `NULL`. + * @param[out] ypos Where to store the cursor y-coordinate, relative to the to + * top edge of the content area, or `NULL`. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref cursor_pos + * @sa @ref glfwSetCursorPos + * + * @since Added in version 3.0. Replaces `glfwGetMousePos`. + * + * @ingroup input + */ +GLFWAPI void glfwGetCursorPos(GLFWwindow* window, double* xpos, double* ypos); + +/*! @brief Sets the position of the cursor, relative to the content area of the + * window. + * + * This function sets the position, in screen coordinates, of the cursor + * relative to the upper-left corner of the content area of the specified + * window. The window must have input focus. If the window does not have + * input focus when this function is called, it fails silently. + * + * __Do not use this function__ to implement things like camera controls. GLFW + * already provides the `GLFW_CURSOR_DISABLED` cursor mode that hides the + * cursor, transparently re-centers it and provides unconstrained cursor + * motion. See @ref glfwSetInputMode for more information. + * + * If the cursor mode is `GLFW_CURSOR_DISABLED` then the cursor position is + * unconstrained and limited only by the minimum and maximum values of + * a `double`. + * + * @param[in] window The desired window. + * @param[in] xpos The desired x-coordinate, relative to the left edge of the + * content area. + * @param[in] ypos The desired y-coordinate, relative to the top edge of the + * content area. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @remark @wayland This function will only work when the cursor mode is + * `GLFW_CURSOR_DISABLED`, otherwise it will do nothing. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref cursor_pos + * @sa @ref glfwGetCursorPos + * + * @since Added in version 3.0. Replaces `glfwSetMousePos`. + * + * @ingroup input + */ +GLFWAPI void glfwSetCursorPos(GLFWwindow* window, double xpos, double ypos); + +/*! @brief Creates a custom cursor. + * + * Creates a new custom cursor image that can be set for a window with @ref + * glfwSetCursor. The cursor can be destroyed with @ref glfwDestroyCursor. + * Any remaining cursors are destroyed by @ref glfwTerminate. + * + * The pixels are 32-bit, little-endian, non-premultiplied RGBA, i.e. eight + * bits per channel with the red channel first. They are arranged canonically + * as packed sequential rows, starting from the top-left corner. + * + * The cursor hotspot is specified in pixels, relative to the upper-left corner + * of the cursor image. Like all other coordinate systems in GLFW, the X-axis + * points to the right and the Y-axis points down. + * + * @param[in] image The desired cursor image. + * @param[in] xhot The desired x-coordinate, in pixels, of the cursor hotspot. + * @param[in] yhot The desired y-coordinate, in pixels, of the cursor hotspot. + * @return The handle of the created cursor, or `NULL` if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @pointer_lifetime The specified image data is copied before this function + * returns. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref cursor_object + * @sa @ref glfwDestroyCursor + * @sa @ref glfwCreateStandardCursor + * + * @since Added in version 3.1. + * + * @ingroup input + */ +GLFWAPI GLFWcursor* glfwCreateCursor(const GLFWimage* image, int xhot, int yhot); + +/*! @brief Creates a cursor with a standard shape. + * + * Returns a cursor with a [standard shape](@ref shapes), that can be set for + * a window with @ref glfwSetCursor. + * + * @param[in] shape One of the [standard shapes](@ref shapes). + * @return A new cursor ready to use or `NULL` if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_INVALID_ENUM and @ref GLFW_PLATFORM_ERROR. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref cursor_object + * @sa @ref glfwCreateCursor + * + * @since Added in version 3.1. + * + * @ingroup input + */ +GLFWAPI GLFWcursor* glfwCreateStandardCursor(int shape); + +/*! @brief Destroys a cursor. + * + * This function destroys a cursor previously created with @ref + * glfwCreateCursor. Any remaining cursors will be destroyed by @ref + * glfwTerminate. + * + * If the specified cursor is current for any window, that window will be + * reverted to the default cursor. This does not affect the cursor mode. + * + * @param[in] cursor The cursor object to destroy. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @reentrancy This function must not be called from a callback. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref cursor_object + * @sa @ref glfwCreateCursor + * + * @since Added in version 3.1. + * + * @ingroup input + */ +GLFWAPI void glfwDestroyCursor(GLFWcursor* cursor); + +/*! @brief Sets the cursor for the window. + * + * This function sets the cursor image to be used when the cursor is over the + * content area of the specified window. The set cursor will only be visible + * when the [cursor mode](@ref cursor_mode) of the window is + * `GLFW_CURSOR_NORMAL`. + * + * On some platforms, the set cursor may not be visible unless the window also + * has input focus. + * + * @param[in] window The window to set the cursor for. + * @param[in] cursor The cursor to set, or `NULL` to switch back to the default + * arrow cursor. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref cursor_object + * + * @since Added in version 3.1. + * + * @ingroup input + */ +GLFWAPI void glfwSetCursor(GLFWwindow* window, GLFWcursor* cursor); + +/*! @brief Sets the key callback. + * + * This function sets the key callback of the specified window, which is called + * when a key is pressed, repeated or released. + * + * The key functions deal with physical keys, with layout independent + * [key tokens](@ref keys) named after their values in the standard US keyboard + * layout. If you want to input text, use the + * [character callback](@ref glfwSetCharCallback) instead. + * + * When a window loses input focus, it will generate synthetic key release + * events for all pressed keys. You can tell these events from user-generated + * events by the fact that the synthetic ones are generated after the focus + * loss event has been processed, i.e. after the + * [window focus callback](@ref glfwSetWindowFocusCallback) has been called. + * + * The scancode of a key is specific to that platform or sometimes even to that + * machine. Scancodes are intended to allow users to bind keys that don't have + * a GLFW key token. Such keys have `key` set to `GLFW_KEY_UNKNOWN`, their + * state is not saved and so it cannot be queried with @ref glfwGetKey. + * + * Sometimes GLFW needs to generate synthetic key events, in which case the + * scancode may be zero. + * + * @param[in] window The window whose callback to set. + * @param[in] callback The new key callback, or `NULL` to remove the currently + * set callback. + * @return The previously set callback, or `NULL` if no callback was set or the + * library had not been [initialized](@ref intro_init). + * + * @callback_signature + * @code + * void function_name(GLFWwindow* window, int key, int scancode, int action, int mods) + * @endcode + * For more information about the callback parameters, see the + * [function pointer type](@ref GLFWkeyfun). + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref input_key + * + * @since Added in version 1.0. + * @glfw3 Added window handle parameter and return value. + * + * @ingroup input + */ +GLFWAPI GLFWkeyfun glfwSetKeyCallback(GLFWwindow* window, GLFWkeyfun callback); + +/*! @brief Sets the Unicode character callback. + * + * This function sets the character callback of the specified window, which is + * called when a Unicode character is input. + * + * The character callback is intended for Unicode text input. As it deals with + * characters, it is keyboard layout dependent, whereas the + * [key callback](@ref glfwSetKeyCallback) is not. Characters do not map 1:1 + * to physical keys, as a key may produce zero, one or more characters. If you + * want to know whether a specific physical key was pressed or released, see + * the key callback instead. + * + * The character callback behaves as system text input normally does and will + * not be called if modifier keys are held down that would prevent normal text + * input on that platform, for example a Super (Command) key on macOS or Alt key + * on Windows. + * + * @param[in] window The window whose callback to set. + * @param[in] callback The new callback, or `NULL` to remove the currently set + * callback. + * @return The previously set callback, or `NULL` if no callback was set or the + * library had not been [initialized](@ref intro_init). + * + * @callback_signature + * @code + * void function_name(GLFWwindow* window, unsigned int codepoint) + * @endcode + * For more information about the callback parameters, see the + * [function pointer type](@ref GLFWcharfun). + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref input_char + * + * @since Added in version 2.4. + * @glfw3 Added window handle parameter and return value. + * + * @ingroup input + */ +GLFWAPI GLFWcharfun glfwSetCharCallback(GLFWwindow* window, GLFWcharfun callback); + +/*! @brief Sets the Unicode character with modifiers callback. + * + * This function sets the character with modifiers callback of the specified + * window, which is called when a Unicode character is input regardless of what + * modifier keys are used. + * + * The character with modifiers callback is intended for implementing custom + * Unicode character input. For regular Unicode text input, see the + * [character callback](@ref glfwSetCharCallback). Like the character + * callback, the character with modifiers callback deals with characters and is + * keyboard layout dependent. Characters do not map 1:1 to physical keys, as + * a key may produce zero, one or more characters. If you want to know whether + * a specific physical key was pressed or released, see the + * [key callback](@ref glfwSetKeyCallback) instead. + * + * @param[in] window The window whose callback to set. + * @param[in] callback The new callback, or `NULL` to remove the currently set + * callback. + * @return The previously set callback, or `NULL` if no callback was set or an + * [error](@ref error_handling) occurred. + * + * @callback_signature + * @code + * void function_name(GLFWwindow* window, unsigned int codepoint, int mods) + * @endcode + * For more information about the callback parameters, see the + * [function pointer type](@ref GLFWcharmodsfun). + * + * @deprecated Scheduled for removal in version 4.0. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref input_char + * + * @since Added in version 3.1. + * + * @ingroup input + */ +GLFWAPI GLFWcharmodsfun glfwSetCharModsCallback(GLFWwindow* window, GLFWcharmodsfun callback); + +/*! @brief Sets the mouse button callback. + * + * This function sets the mouse button callback of the specified window, which + * is called when a mouse button is pressed or released. + * + * When a window loses input focus, it will generate synthetic mouse button + * release events for all pressed mouse buttons. You can tell these events + * from user-generated events by the fact that the synthetic ones are generated + * after the focus loss event has been processed, i.e. after the + * [window focus callback](@ref glfwSetWindowFocusCallback) has been called. + * + * @param[in] window The window whose callback to set. + * @param[in] callback The new callback, or `NULL` to remove the currently set + * callback. + * @return The previously set callback, or `NULL` if no callback was set or the + * library had not been [initialized](@ref intro_init). + * + * @callback_signature + * @code + * void function_name(GLFWwindow* window, int button, int action, int mods) + * @endcode + * For more information about the callback parameters, see the + * [function pointer type](@ref GLFWmousebuttonfun). + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref input_mouse_button + * + * @since Added in version 1.0. + * @glfw3 Added window handle parameter and return value. + * + * @ingroup input + */ +GLFWAPI GLFWmousebuttonfun glfwSetMouseButtonCallback(GLFWwindow* window, GLFWmousebuttonfun callback); + +/*! @brief Sets the cursor position callback. + * + * This function sets the cursor position callback of the specified window, + * which is called when the cursor is moved. The callback is provided with the + * position, in screen coordinates, relative to the upper-left corner of the + * content area of the window. + * + * @param[in] window The window whose callback to set. + * @param[in] callback The new callback, or `NULL` to remove the currently set + * callback. + * @return The previously set callback, or `NULL` if no callback was set or the + * library had not been [initialized](@ref intro_init). + * + * @callback_signature + * @code + * void function_name(GLFWwindow* window, double xpos, double ypos); + * @endcode + * For more information about the callback parameters, see the + * [function pointer type](@ref GLFWcursorposfun). + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref cursor_pos + * + * @since Added in version 3.0. Replaces `glfwSetMousePosCallback`. + * + * @ingroup input + */ +GLFWAPI GLFWcursorposfun glfwSetCursorPosCallback(GLFWwindow* window, GLFWcursorposfun callback); + +/*! @brief Sets the cursor enter/leave callback. + * + * This function sets the cursor boundary crossing callback of the specified + * window, which is called when the cursor enters or leaves the content area of + * the window. + * + * @param[in] window The window whose callback to set. + * @param[in] callback The new callback, or `NULL` to remove the currently set + * callback. + * @return The previously set callback, or `NULL` if no callback was set or the + * library had not been [initialized](@ref intro_init). + * + * @callback_signature + * @code + * void function_name(GLFWwindow* window, int entered) + * @endcode + * For more information about the callback parameters, see the + * [function pointer type](@ref GLFWcursorenterfun). + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref cursor_enter + * + * @since Added in version 3.0. + * + * @ingroup input + */ +GLFWAPI GLFWcursorenterfun glfwSetCursorEnterCallback(GLFWwindow* window, GLFWcursorenterfun callback); + +/*! @brief Sets the scroll callback. + * + * This function sets the scroll callback of the specified window, which is + * called when a scrolling device is used, such as a mouse wheel or scrolling + * area of a touchpad. + * + * The scroll callback receives all scrolling input, like that from a mouse + * wheel or a touchpad scrolling area. + * + * @param[in] window The window whose callback to set. + * @param[in] callback The new scroll callback, or `NULL` to remove the + * currently set callback. + * @return The previously set callback, or `NULL` if no callback was set or the + * library had not been [initialized](@ref intro_init). + * + * @callback_signature + * @code + * void function_name(GLFWwindow* window, double xoffset, double yoffset) + * @endcode + * For more information about the callback parameters, see the + * [function pointer type](@ref GLFWscrollfun). + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref scrolling + * + * @since Added in version 3.0. Replaces `glfwSetMouseWheelCallback`. + * + * @ingroup input + */ +GLFWAPI GLFWscrollfun glfwSetScrollCallback(GLFWwindow* window, GLFWscrollfun callback); + +/*! @brief Sets the path drop callback. + * + * This function sets the path drop callback of the specified window, which is + * called when one or more dragged paths are dropped on the window. + * + * Because the path array and its strings may have been generated specifically + * for that event, they are not guaranteed to be valid after the callback has + * returned. If you wish to use them after the callback returns, you need to + * make a deep copy. + * + * @param[in] window The window whose callback to set. + * @param[in] callback The new file drop callback, or `NULL` to remove the + * currently set callback. + * @return The previously set callback, or `NULL` if no callback was set or the + * library had not been [initialized](@ref intro_init). + * + * @callback_signature + * @code + * void function_name(GLFWwindow* window, int path_count, const char* paths[]) + * @endcode + * For more information about the callback parameters, see the + * [function pointer type](@ref GLFWdropfun). + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @remark @wayland File drop is currently unimplemented. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref path_drop + * + * @since Added in version 3.1. + * + * @ingroup input + */ +GLFWAPI GLFWdropfun glfwSetDropCallback(GLFWwindow* window, GLFWdropfun callback); + +/*! @brief Returns whether the specified joystick is present. + * + * This function returns whether the specified joystick is present. + * + * There is no need to call this function before other functions that accept + * a joystick ID, as they all check for presence before performing any other + * work. + * + * @param[in] jid The [joystick](@ref joysticks) to query. + * @return `GLFW_TRUE` if the joystick is present, or `GLFW_FALSE` otherwise. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_INVALID_ENUM and @ref GLFW_PLATFORM_ERROR. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref joystick + * + * @since Added in version 3.0. Replaces `glfwGetJoystickParam`. + * + * @ingroup input + */ +GLFWAPI int glfwJoystickPresent(int jid); + +/*! @brief Returns the values of all axes of the specified joystick. + * + * This function returns the values of all axes of the specified joystick. + * Each element in the array is a value between -1.0 and 1.0. + * + * If the specified joystick is not present this function will return `NULL` + * but will not generate an error. This can be used instead of first calling + * @ref glfwJoystickPresent. + * + * @param[in] jid The [joystick](@ref joysticks) to query. + * @param[out] count Where to store the number of axis values in the returned + * array. This is set to zero if the joystick is not present or an error + * occurred. + * @return An array of axis values, or `NULL` if the joystick is not present or + * an [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_INVALID_ENUM and @ref GLFW_PLATFORM_ERROR. + * + * @pointer_lifetime The returned array is allocated and freed by GLFW. You + * should not free it yourself. It is valid until the specified joystick is + * disconnected or the library is terminated. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref joystick_axis + * + * @since Added in version 3.0. Replaces `glfwGetJoystickPos`. + * + * @ingroup input + */ +GLFWAPI const float* glfwGetJoystickAxes(int jid, int* count); + +/*! @brief Returns the state of all buttons of the specified joystick. + * + * This function returns the state of all buttons of the specified joystick. + * Each element in the array is either `GLFW_PRESS` or `GLFW_RELEASE`. + * + * For backward compatibility with earlier versions that did not have @ref + * glfwGetJoystickHats, the button array also includes all hats, each + * represented as four buttons. The hats are in the same order as returned by + * __glfwGetJoystickHats__ and are in the order _up_, _right_, _down_ and + * _left_. To disable these extra buttons, set the @ref + * GLFW_JOYSTICK_HAT_BUTTONS init hint before initialization. + * + * If the specified joystick is not present this function will return `NULL` + * but will not generate an error. This can be used instead of first calling + * @ref glfwJoystickPresent. + * + * @param[in] jid The [joystick](@ref joysticks) to query. + * @param[out] count Where to store the number of button states in the returned + * array. This is set to zero if the joystick is not present or an error + * occurred. + * @return An array of button states, or `NULL` if the joystick is not present + * or an [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_INVALID_ENUM and @ref GLFW_PLATFORM_ERROR. + * + * @pointer_lifetime The returned array is allocated and freed by GLFW. You + * should not free it yourself. It is valid until the specified joystick is + * disconnected or the library is terminated. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref joystick_button + * + * @since Added in version 2.2. + * @glfw3 Changed to return a dynamic array. + * + * @ingroup input + */ +GLFWAPI const unsigned char* glfwGetJoystickButtons(int jid, int* count); + +/*! @brief Returns the state of all hats of the specified joystick. + * + * This function returns the state of all hats of the specified joystick. + * Each element in the array is one of the following values: + * + * Name | Value + * ---- | ----- + * `GLFW_HAT_CENTERED` | 0 + * `GLFW_HAT_UP` | 1 + * `GLFW_HAT_RIGHT` | 2 + * `GLFW_HAT_DOWN` | 4 + * `GLFW_HAT_LEFT` | 8 + * `GLFW_HAT_RIGHT_UP` | `GLFW_HAT_RIGHT` \| `GLFW_HAT_UP` + * `GLFW_HAT_RIGHT_DOWN` | `GLFW_HAT_RIGHT` \| `GLFW_HAT_DOWN` + * `GLFW_HAT_LEFT_UP` | `GLFW_HAT_LEFT` \| `GLFW_HAT_UP` + * `GLFW_HAT_LEFT_DOWN` | `GLFW_HAT_LEFT` \| `GLFW_HAT_DOWN` + * + * The diagonal directions are bitwise combinations of the primary (up, right, + * down and left) directions and you can test for these individually by ANDing + * it with the corresponding direction. + * + * @code + * if (hats[2] & GLFW_HAT_RIGHT) + * { + * // State of hat 2 could be right-up, right or right-down + * } + * @endcode + * + * If the specified joystick is not present this function will return `NULL` + * but will not generate an error. This can be used instead of first calling + * @ref glfwJoystickPresent. + * + * @param[in] jid The [joystick](@ref joysticks) to query. + * @param[out] count Where to store the number of hat states in the returned + * array. This is set to zero if the joystick is not present or an error + * occurred. + * @return An array of hat states, or `NULL` if the joystick is not present + * or an [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_INVALID_ENUM and @ref GLFW_PLATFORM_ERROR. + * + * @pointer_lifetime The returned array is allocated and freed by GLFW. You + * should not free it yourself. It is valid until the specified joystick is + * disconnected, this function is called again for that joystick or the library + * is terminated. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref joystick_hat + * + * @since Added in version 3.3. + * + * @ingroup input + */ +GLFWAPI const unsigned char* glfwGetJoystickHats(int jid, int* count); + +/*! @brief Returns the name of the specified joystick. + * + * This function returns the name, encoded as UTF-8, of the specified joystick. + * The returned string is allocated and freed by GLFW. You should not free it + * yourself. + * + * If the specified joystick is not present this function will return `NULL` + * but will not generate an error. This can be used instead of first calling + * @ref glfwJoystickPresent. + * + * @param[in] jid The [joystick](@ref joysticks) to query. + * @return The UTF-8 encoded name of the joystick, or `NULL` if the joystick + * is not present or an [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_INVALID_ENUM and @ref GLFW_PLATFORM_ERROR. + * + * @pointer_lifetime The returned string is allocated and freed by GLFW. You + * should not free it yourself. It is valid until the specified joystick is + * disconnected or the library is terminated. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref joystick_name + * + * @since Added in version 3.0. + * + * @ingroup input + */ +GLFWAPI const char* glfwGetJoystickName(int jid); + +/*! @brief Returns the SDL compatible GUID of the specified joystick. + * + * This function returns the SDL compatible GUID, as a UTF-8 encoded + * hexadecimal string, of the specified joystick. The returned string is + * allocated and freed by GLFW. You should not free it yourself. + * + * The GUID is what connects a joystick to a gamepad mapping. A connected + * joystick will always have a GUID even if there is no gamepad mapping + * assigned to it. + * + * If the specified joystick is not present this function will return `NULL` + * but will not generate an error. This can be used instead of first calling + * @ref glfwJoystickPresent. + * + * The GUID uses the format introduced in SDL 2.0.5. This GUID tries to + * uniquely identify the make and model of a joystick but does not identify + * a specific unit, e.g. all wired Xbox 360 controllers will have the same + * GUID on that platform. The GUID for a unit may vary between platforms + * depending on what hardware information the platform specific APIs provide. + * + * @param[in] jid The [joystick](@ref joysticks) to query. + * @return The UTF-8 encoded GUID of the joystick, or `NULL` if the joystick + * is not present or an [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_INVALID_ENUM and @ref GLFW_PLATFORM_ERROR. + * + * @pointer_lifetime The returned string is allocated and freed by GLFW. You + * should not free it yourself. It is valid until the specified joystick is + * disconnected or the library is terminated. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref gamepad + * + * @since Added in version 3.3. + * + * @ingroup input + */ +GLFWAPI const char* glfwGetJoystickGUID(int jid); + +/*! @brief Sets the user pointer of the specified joystick. + * + * This function sets the user-defined pointer of the specified joystick. The + * current value is retained until the joystick is disconnected. The initial + * value is `NULL`. + * + * This function may be called from the joystick callback, even for a joystick + * that is being disconnected. + * + * @param[in] jid The joystick whose pointer to set. + * @param[in] pointer The new value. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function may be called from any thread. Access is not + * synchronized. + * + * @sa @ref joystick_userptr + * @sa @ref glfwGetJoystickUserPointer + * + * @since Added in version 3.3. + * + * @ingroup input + */ +GLFWAPI void glfwSetJoystickUserPointer(int jid, void* pointer); + +/*! @brief Returns the user pointer of the specified joystick. + * + * This function returns the current value of the user-defined pointer of the + * specified joystick. The initial value is `NULL`. + * + * This function may be called from the joystick callback, even for a joystick + * that is being disconnected. + * + * @param[in] jid The joystick whose pointer to return. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function may be called from any thread. Access is not + * synchronized. + * + * @sa @ref joystick_userptr + * @sa @ref glfwSetJoystickUserPointer + * + * @since Added in version 3.3. + * + * @ingroup input + */ +GLFWAPI void* glfwGetJoystickUserPointer(int jid); + +/*! @brief Returns whether the specified joystick has a gamepad mapping. + * + * This function returns whether the specified joystick is both present and has + * a gamepad mapping. + * + * If the specified joystick is present but does not have a gamepad mapping + * this function will return `GLFW_FALSE` but will not generate an error. Call + * @ref glfwJoystickPresent to check if a joystick is present regardless of + * whether it has a mapping. + * + * @param[in] jid The [joystick](@ref joysticks) to query. + * @return `GLFW_TRUE` if a joystick is both present and has a gamepad mapping, + * or `GLFW_FALSE` otherwise. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_INVALID_ENUM. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref gamepad + * @sa @ref glfwGetGamepadState + * + * @since Added in version 3.3. + * + * @ingroup input + */ +GLFWAPI int glfwJoystickIsGamepad(int jid); + +/*! @brief Sets the joystick configuration callback. + * + * This function sets the joystick configuration callback, or removes the + * currently set callback. This is called when a joystick is connected to or + * disconnected from the system. + * + * For joystick connection and disconnection events to be delivered on all + * platforms, you need to call one of the [event processing](@ref events) + * functions. Joystick disconnection may also be detected and the callback + * called by joystick functions. The function will then return whatever it + * returns if the joystick is not present. + * + * @param[in] callback The new callback, or `NULL` to remove the currently set + * callback. + * @return The previously set callback, or `NULL` if no callback was set or the + * library had not been [initialized](@ref intro_init). + * + * @callback_signature + * @code + * void function_name(int jid, int event) + * @endcode + * For more information about the callback parameters, see the + * [function pointer type](@ref GLFWjoystickfun). + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref joystick_event + * + * @since Added in version 3.2. + * + * @ingroup input + */ +GLFWAPI GLFWjoystickfun glfwSetJoystickCallback(GLFWjoystickfun callback); + +/*! @brief Adds the specified SDL_GameControllerDB gamepad mappings. + * + * This function parses the specified ASCII encoded string and updates the + * internal list with any gamepad mappings it finds. This string may + * contain either a single gamepad mapping or many mappings separated by + * newlines. The parser supports the full format of the `gamecontrollerdb.txt` + * source file including empty lines and comments. + * + * See @ref gamepad_mapping for a description of the format. + * + * If there is already a gamepad mapping for a given GUID in the internal list, + * it will be replaced by the one passed to this function. If the library is + * terminated and re-initialized the internal list will revert to the built-in + * default. + * + * @param[in] string The string containing the gamepad mappings. + * @return `GLFW_TRUE` if successful, or `GLFW_FALSE` if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_INVALID_VALUE. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref gamepad + * @sa @ref glfwJoystickIsGamepad + * @sa @ref glfwGetGamepadName + * + * @since Added in version 3.3. + * + * @ingroup input + */ +GLFWAPI int glfwUpdateGamepadMappings(const char* string); + +/*! @brief Returns the human-readable gamepad name for the specified joystick. + * + * This function returns the human-readable name of the gamepad from the + * gamepad mapping assigned to the specified joystick. + * + * If the specified joystick is not present or does not have a gamepad mapping + * this function will return `NULL` but will not generate an error. Call + * @ref glfwJoystickPresent to check whether it is present regardless of + * whether it has a mapping. + * + * @param[in] jid The [joystick](@ref joysticks) to query. + * @return The UTF-8 encoded name of the gamepad, or `NULL` if the + * joystick is not present, does not have a mapping or an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref GLFW_INVALID_ENUM. + * + * @pointer_lifetime The returned string is allocated and freed by GLFW. You + * should not free it yourself. It is valid until the specified joystick is + * disconnected, the gamepad mappings are updated or the library is terminated. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref gamepad + * @sa @ref glfwJoystickIsGamepad + * + * @since Added in version 3.3. + * + * @ingroup input + */ +GLFWAPI const char* glfwGetGamepadName(int jid); + +/*! @brief Retrieves the state of the specified joystick remapped as a gamepad. + * + * This function retrieves the state of the specified joystick remapped to + * an Xbox-like gamepad. + * + * If the specified joystick is not present or does not have a gamepad mapping + * this function will return `GLFW_FALSE` but will not generate an error. Call + * @ref glfwJoystickPresent to check whether it is present regardless of + * whether it has a mapping. + * + * The Guide button may not be available for input as it is often hooked by the + * system or the Steam client. + * + * Not all devices have all the buttons or axes provided by @ref + * GLFWgamepadstate. Unavailable buttons and axes will always report + * `GLFW_RELEASE` and 0.0 respectively. + * + * @param[in] jid The [joystick](@ref joysticks) to query. + * @param[out] state The gamepad input state of the joystick. + * @return `GLFW_TRUE` if successful, or `GLFW_FALSE` if no joystick is + * connected, it has no gamepad mapping or an [error](@ref error_handling) + * occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_INVALID_ENUM. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref gamepad + * @sa @ref glfwUpdateGamepadMappings + * @sa @ref glfwJoystickIsGamepad + * + * @since Added in version 3.3. + * + * @ingroup input + */ +GLFWAPI int glfwGetGamepadState(int jid, GLFWgamepadstate* state); + +/*! @brief Sets the clipboard to the specified string. + * + * This function sets the system clipboard to the specified, UTF-8 encoded + * string. + * + * @param[in] window Deprecated. Any valid window or `NULL`. + * @param[in] string A UTF-8 encoded string. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_PLATFORM_ERROR. + * + * @pointer_lifetime The specified string is copied before this function + * returns. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref clipboard + * @sa @ref glfwGetClipboardString + * + * @since Added in version 3.0. + * + * @ingroup input + */ +GLFWAPI void glfwSetClipboardString(GLFWwindow* window, const char* string); + +/*! @brief Returns the contents of the clipboard as a string. + * + * This function returns the contents of the system clipboard, if it contains + * or is convertible to a UTF-8 encoded string. If the clipboard is empty or + * if its contents cannot be converted, `NULL` is returned and a @ref + * GLFW_FORMAT_UNAVAILABLE error is generated. + * + * @param[in] window Deprecated. Any valid window or `NULL`. + * @return The contents of the clipboard as a UTF-8 encoded string, or `NULL` + * if an [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_FORMAT_UNAVAILABLE and @ref GLFW_PLATFORM_ERROR. + * + * @pointer_lifetime The returned string is allocated and freed by GLFW. You + * should not free it yourself. It is valid until the next call to @ref + * glfwGetClipboardString or @ref glfwSetClipboardString, or until the library + * is terminated. + * + * @thread_safety This function must only be called from the main thread. + * + * @sa @ref clipboard + * @sa @ref glfwSetClipboardString + * + * @since Added in version 3.0. + * + * @ingroup input + */ +GLFWAPI const char* glfwGetClipboardString(GLFWwindow* window); + +/*! @brief Returns the GLFW time. + * + * This function returns the current GLFW time, in seconds. Unless the time + * has been set using @ref glfwSetTime it measures time elapsed since GLFW was + * initialized. + * + * This function and @ref glfwSetTime are helper functions on top of @ref + * glfwGetTimerFrequency and @ref glfwGetTimerValue. + * + * The resolution of the timer is system dependent, but is usually on the order + * of a few micro- or nanoseconds. It uses the highest-resolution monotonic + * time source on each supported platform. + * + * @return The current time, in seconds, or zero if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function may be called from any thread. Reading and + * writing of the internal base time is not atomic, so it needs to be + * externally synchronized with calls to @ref glfwSetTime. + * + * @sa @ref time + * + * @since Added in version 1.0. + * + * @ingroup input + */ +GLFWAPI double glfwGetTime(void); + +/*! @brief Sets the GLFW time. + * + * This function sets the current GLFW time, in seconds. The value must be + * a positive finite number less than or equal to 18446744073.0, which is + * approximately 584.5 years. + * + * This function and @ref glfwGetTime are helper functions on top of @ref + * glfwGetTimerFrequency and @ref glfwGetTimerValue. + * + * @param[in] time The new value, in seconds. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_INVALID_VALUE. + * + * @remark The upper limit of GLFW time is calculated as + * floor((264 - 1) / 109) and is due to implementations + * storing nanoseconds in 64 bits. The limit may be increased in the future. + * + * @thread_safety This function may be called from any thread. Reading and + * writing of the internal base time is not atomic, so it needs to be + * externally synchronized with calls to @ref glfwGetTime. + * + * @sa @ref time + * + * @since Added in version 2.2. + * + * @ingroup input + */ +GLFWAPI void glfwSetTime(double time); + +/*! @brief Returns the current value of the raw timer. + * + * This function returns the current value of the raw timer, measured in + * 1 / frequency seconds. To get the frequency, call @ref + * glfwGetTimerFrequency. + * + * @return The value of the timer, or zero if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function may be called from any thread. + * + * @sa @ref time + * @sa @ref glfwGetTimerFrequency + * + * @since Added in version 3.2. + * + * @ingroup input + */ +GLFWAPI uint64_t glfwGetTimerValue(void); + +/*! @brief Returns the frequency, in Hz, of the raw timer. + * + * This function returns the frequency, in Hz, of the raw timer. + * + * @return The frequency of the timer, in Hz, or zero if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function may be called from any thread. + * + * @sa @ref time + * @sa @ref glfwGetTimerValue + * + * @since Added in version 3.2. + * + * @ingroup input + */ +GLFWAPI uint64_t glfwGetTimerFrequency(void); + +/*! @brief Makes the context of the specified window current for the calling + * thread. + * + * This function makes the OpenGL or OpenGL ES context of the specified window + * current on the calling thread. A context must only be made current on + * a single thread at a time and each thread can have only a single current + * context at a time. + * + * When moving a context between threads, you must make it non-current on the + * old thread before making it current on the new one. + * + * By default, making a context non-current implicitly forces a pipeline flush. + * On machines that support `GL_KHR_context_flush_control`, you can control + * whether a context performs this flush by setting the + * [GLFW_CONTEXT_RELEASE_BEHAVIOR](@ref GLFW_CONTEXT_RELEASE_BEHAVIOR_hint) + * hint. + * + * The specified window must have an OpenGL or OpenGL ES context. Specifying + * a window without a context will generate a @ref GLFW_NO_WINDOW_CONTEXT + * error. + * + * @param[in] window The window whose context to make current, or `NULL` to + * detach the current context. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_NO_WINDOW_CONTEXT and @ref GLFW_PLATFORM_ERROR. + * + * @thread_safety This function may be called from any thread. + * + * @sa @ref context_current + * @sa @ref glfwGetCurrentContext + * + * @since Added in version 3.0. + * + * @ingroup context + */ +GLFWAPI void glfwMakeContextCurrent(GLFWwindow* window); + +/*! @brief Returns the window whose context is current on the calling thread. + * + * This function returns the window whose OpenGL or OpenGL ES context is + * current on the calling thread. + * + * @return The window whose context is current, or `NULL` if no window's + * context is current. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function may be called from any thread. + * + * @sa @ref context_current + * @sa @ref glfwMakeContextCurrent + * + * @since Added in version 3.0. + * + * @ingroup context + */ +GLFWAPI GLFWwindow* glfwGetCurrentContext(void); + +/*! @brief Swaps the front and back buffers of the specified window. + * + * This function swaps the front and back buffers of the specified window when + * rendering with OpenGL or OpenGL ES. If the swap interval is greater than + * zero, the GPU driver waits the specified number of screen updates before + * swapping the buffers. + * + * The specified window must have an OpenGL or OpenGL ES context. Specifying + * a window without a context will generate a @ref GLFW_NO_WINDOW_CONTEXT + * error. + * + * This function does not apply to Vulkan. If you are rendering with Vulkan, + * see `vkQueuePresentKHR` instead. + * + * @param[in] window The window whose buffers to swap. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_NO_WINDOW_CONTEXT and @ref GLFW_PLATFORM_ERROR. + * + * @remark __EGL:__ The context of the specified window must be current on the + * calling thread. + * + * @thread_safety This function may be called from any thread. + * + * @sa @ref buffer_swap + * @sa @ref glfwSwapInterval + * + * @since Added in version 1.0. + * @glfw3 Added window handle parameter. + * + * @ingroup window + */ +GLFWAPI void glfwSwapBuffers(GLFWwindow* window); + +/*! @brief Sets the swap interval for the current context. + * + * This function sets the swap interval for the current OpenGL or OpenGL ES + * context, i.e. the number of screen updates to wait from the time @ref + * glfwSwapBuffers was called before swapping the buffers and returning. This + * is sometimes called _vertical synchronization_, _vertical retrace + * synchronization_ or just _vsync_. + * + * A context that supports either of the `WGL_EXT_swap_control_tear` and + * `GLX_EXT_swap_control_tear` extensions also accepts _negative_ swap + * intervals, which allows the driver to swap immediately even if a frame + * arrives a little bit late. You can check for these extensions with @ref + * glfwExtensionSupported. + * + * A context must be current on the calling thread. Calling this function + * without a current context will cause a @ref GLFW_NO_CURRENT_CONTEXT error. + * + * This function does not apply to Vulkan. If you are rendering with Vulkan, + * see the present mode of your swapchain instead. + * + * @param[in] interval The minimum number of screen updates to wait for + * until the buffers are swapped by @ref glfwSwapBuffers. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_NO_CURRENT_CONTEXT and @ref GLFW_PLATFORM_ERROR. + * + * @remark This function is not called during context creation, leaving the + * swap interval set to whatever is the default on that platform. This is done + * because some swap interval extensions used by GLFW do not allow the swap + * interval to be reset to zero once it has been set to a non-zero value. + * + * @remark Some GPU drivers do not honor the requested swap interval, either + * because of a user setting that overrides the application's request or due to + * bugs in the driver. + * + * @thread_safety This function may be called from any thread. + * + * @sa @ref buffer_swap + * @sa @ref glfwSwapBuffers + * + * @since Added in version 1.0. + * + * @ingroup context + */ +GLFWAPI void glfwSwapInterval(int interval); + +/*! @brief Returns whether the specified extension is available. + * + * This function returns whether the specified + * [API extension](@ref context_glext) is supported by the current OpenGL or + * OpenGL ES context. It searches both for client API extension and context + * creation API extensions. + * + * A context must be current on the calling thread. Calling this function + * without a current context will cause a @ref GLFW_NO_CURRENT_CONTEXT error. + * + * As this functions retrieves and searches one or more extension strings each + * call, it is recommended that you cache its results if it is going to be used + * frequently. The extension strings will not change during the lifetime of + * a context, so there is no danger in doing this. + * + * This function does not apply to Vulkan. If you are using Vulkan, see @ref + * glfwGetRequiredInstanceExtensions, `vkEnumerateInstanceExtensionProperties` + * and `vkEnumerateDeviceExtensionProperties` instead. + * + * @param[in] extension The ASCII encoded name of the extension. + * @return `GLFW_TRUE` if the extension is available, or `GLFW_FALSE` + * otherwise. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_NO_CURRENT_CONTEXT, @ref GLFW_INVALID_VALUE and @ref + * GLFW_PLATFORM_ERROR. + * + * @thread_safety This function may be called from any thread. + * + * @sa @ref context_glext + * @sa @ref glfwGetProcAddress + * + * @since Added in version 1.0. + * + * @ingroup context + */ +GLFWAPI int glfwExtensionSupported(const char* extension); + +/*! @brief Returns the address of the specified function for the current + * context. + * + * This function returns the address of the specified OpenGL or OpenGL ES + * [core or extension function](@ref context_glext), if it is supported + * by the current context. + * + * A context must be current on the calling thread. Calling this function + * without a current context will cause a @ref GLFW_NO_CURRENT_CONTEXT error. + * + * This function does not apply to Vulkan. If you are rendering with Vulkan, + * see @ref glfwGetInstanceProcAddress, `vkGetInstanceProcAddr` and + * `vkGetDeviceProcAddr` instead. + * + * @param[in] procname The ASCII encoded name of the function. + * @return The address of the function, or `NULL` if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_NO_CURRENT_CONTEXT and @ref GLFW_PLATFORM_ERROR. + * + * @remark The address of a given function is not guaranteed to be the same + * between contexts. + * + * @remark This function may return a non-`NULL` address despite the + * associated version or extension not being available. Always check the + * context version or extension string first. + * + * @pointer_lifetime The returned function pointer is valid until the context + * is destroyed or the library is terminated. + * + * @thread_safety This function may be called from any thread. + * + * @sa @ref context_glext + * @sa @ref glfwExtensionSupported + * + * @since Added in version 1.0. + * + * @ingroup context + */ +GLFWAPI GLFWglproc glfwGetProcAddress(const char* procname); + +/*! @brief Returns whether the Vulkan loader and an ICD have been found. + * + * This function returns whether the Vulkan loader and any minimally functional + * ICD have been found. + * + * The availability of a Vulkan loader and even an ICD does not by itself guarantee that + * surface creation or even instance creation is possible. Call @ref + * glfwGetRequiredInstanceExtensions to check whether the extensions necessary for Vulkan + * surface creation are available and @ref glfwGetPhysicalDevicePresentationSupport to + * check whether a queue family of a physical device supports image presentation. + * + * @return `GLFW_TRUE` if Vulkan is minimally available, or `GLFW_FALSE` + * otherwise. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED. + * + * @thread_safety This function may be called from any thread. + * + * @sa @ref vulkan_support + * + * @since Added in version 3.2. + * + * @ingroup vulkan + */ +GLFWAPI int glfwVulkanSupported(void); + +/*! @brief Returns the Vulkan instance extensions required by GLFW. + * + * This function returns an array of names of Vulkan instance extensions required + * by GLFW for creating Vulkan surfaces for GLFW windows. If successful, the + * list will always contain `VK_KHR_surface`, so if you don't require any + * additional extensions you can pass this list directly to the + * `VkInstanceCreateInfo` struct. + * + * If Vulkan is not available on the machine, this function returns `NULL` and + * generates a @ref GLFW_API_UNAVAILABLE error. Call @ref glfwVulkanSupported + * to check whether Vulkan is at least minimally available. + * + * If Vulkan is available but no set of extensions allowing window surface + * creation was found, this function returns `NULL`. You may still use Vulkan + * for off-screen rendering and compute work. + * + * @param[out] count Where to store the number of extensions in the returned + * array. This is set to zero if an error occurred. + * @return An array of ASCII encoded extension names, or `NULL` if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_API_UNAVAILABLE. + * + * @remark Additional extensions may be required by future versions of GLFW. + * You should check if any extensions you wish to enable are already in the + * returned array, as it is an error to specify an extension more than once in + * the `VkInstanceCreateInfo` struct. + * + * @pointer_lifetime The returned array is allocated and freed by GLFW. You + * should not free it yourself. It is guaranteed to be valid only until the + * library is terminated. + * + * @thread_safety This function may be called from any thread. + * + * @sa @ref vulkan_ext + * @sa @ref glfwCreateWindowSurface + * + * @since Added in version 3.2. + * + * @ingroup vulkan + */ +GLFWAPI const char** glfwGetRequiredInstanceExtensions(uint32_t* count); + +#if defined(VK_VERSION_1_0) + +/*! @brief Returns the address of the specified Vulkan instance function. + * + * This function returns the address of the specified Vulkan core or extension + * function for the specified instance. If instance is set to `NULL` it can + * return any function exported from the Vulkan loader, including at least the + * following functions: + * + * - `vkEnumerateInstanceExtensionProperties` + * - `vkEnumerateInstanceLayerProperties` + * - `vkCreateInstance` + * - `vkGetInstanceProcAddr` + * + * If Vulkan is not available on the machine, this function returns `NULL` and + * generates a @ref GLFW_API_UNAVAILABLE error. Call @ref glfwVulkanSupported + * to check whether Vulkan is at least minimally available. + * + * This function is equivalent to calling `vkGetInstanceProcAddr` with + * a platform-specific query of the Vulkan loader as a fallback. + * + * @param[in] instance The Vulkan instance to query, or `NULL` to retrieve + * functions related to instance creation. + * @param[in] procname The ASCII encoded name of the function. + * @return The address of the function, or `NULL` if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED and @ref + * GLFW_API_UNAVAILABLE. + * + * @pointer_lifetime The returned function pointer is valid until the library + * is terminated. + * + * @thread_safety This function may be called from any thread. + * + * @sa @ref vulkan_proc + * + * @since Added in version 3.2. + * + * @ingroup vulkan + */ +GLFWAPI GLFWvkproc glfwGetInstanceProcAddress(VkInstance instance, const char* procname); + +/*! @brief Returns whether the specified queue family can present images. + * + * This function returns whether the specified queue family of the specified + * physical device supports presentation to the platform GLFW was built for. + * + * If Vulkan or the required window surface creation instance extensions are + * not available on the machine, or if the specified instance was not created + * with the required extensions, this function returns `GLFW_FALSE` and + * generates a @ref GLFW_API_UNAVAILABLE error. Call @ref glfwVulkanSupported + * to check whether Vulkan is at least minimally available and @ref + * glfwGetRequiredInstanceExtensions to check what instance extensions are + * required. + * + * @param[in] instance The instance that the physical device belongs to. + * @param[in] device The physical device that the queue family belongs to. + * @param[in] queuefamily The index of the queue family to query. + * @return `GLFW_TRUE` if the queue family supports presentation, or + * `GLFW_FALSE` otherwise. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_API_UNAVAILABLE and @ref GLFW_PLATFORM_ERROR. + * + * @remark @macos This function currently always returns `GLFW_TRUE`, as the + * `VK_MVK_macos_surface` and `VK_EXT_metal_surface` extensions do not provide + * a `vkGetPhysicalDevice*PresentationSupport` type function. + * + * @thread_safety This function may be called from any thread. For + * synchronization details of Vulkan objects, see the Vulkan specification. + * + * @sa @ref vulkan_present + * + * @since Added in version 3.2. + * + * @ingroup vulkan + */ +GLFWAPI int glfwGetPhysicalDevicePresentationSupport(VkInstance instance, VkPhysicalDevice device, uint32_t queuefamily); + +/*! @brief Creates a Vulkan surface for the specified window. + * + * This function creates a Vulkan surface for the specified window. + * + * If the Vulkan loader or at least one minimally functional ICD were not found, + * this function returns `VK_ERROR_INITIALIZATION_FAILED` and generates a @ref + * GLFW_API_UNAVAILABLE error. Call @ref glfwVulkanSupported to check whether + * Vulkan is at least minimally available. + * + * If the required window surface creation instance extensions are not + * available or if the specified instance was not created with these extensions + * enabled, this function returns `VK_ERROR_EXTENSION_NOT_PRESENT` and + * generates a @ref GLFW_API_UNAVAILABLE error. Call @ref + * glfwGetRequiredInstanceExtensions to check what instance extensions are + * required. + * + * The window surface cannot be shared with another API so the window must + * have been created with the [client api hint](@ref GLFW_CLIENT_API_attrib) + * set to `GLFW_NO_API` otherwise it generates a @ref GLFW_INVALID_VALUE error + * and returns `VK_ERROR_NATIVE_WINDOW_IN_USE_KHR`. + * + * The window surface must be destroyed before the specified Vulkan instance. + * It is the responsibility of the caller to destroy the window surface. GLFW + * does not destroy it for you. Call `vkDestroySurfaceKHR` to destroy the + * surface. + * + * @param[in] instance The Vulkan instance to create the surface in. + * @param[in] window The window to create the surface for. + * @param[in] allocator The allocator to use, or `NULL` to use the default + * allocator. + * @param[out] surface Where to store the handle of the surface. This is set + * to `VK_NULL_HANDLE` if an error occurred. + * @return `VK_SUCCESS` if successful, or a Vulkan error code if an + * [error](@ref error_handling) occurred. + * + * @errors Possible errors include @ref GLFW_NOT_INITIALIZED, @ref + * GLFW_API_UNAVAILABLE, @ref GLFW_PLATFORM_ERROR and @ref GLFW_INVALID_VALUE + * + * @remark If an error occurs before the creation call is made, GLFW returns + * the Vulkan error code most appropriate for the error. Appropriate use of + * @ref glfwVulkanSupported and @ref glfwGetRequiredInstanceExtensions should + * eliminate almost all occurrences of these errors. + * + * @remark @macos GLFW prefers the `VK_EXT_metal_surface` extension, with the + * `VK_MVK_macos_surface` extension as a fallback. The name of the selected + * extension, if any, is included in the array returned by @ref + * glfwGetRequiredInstanceExtensions. + * + * @remark @macos This function creates and sets a `CAMetalLayer` instance for + * the window content view, which is required for MoltenVK to function. + * + * @thread_safety This function may be called from any thread. For + * synchronization details of Vulkan objects, see the Vulkan specification. + * + * @sa @ref vulkan_surface + * @sa @ref glfwGetRequiredInstanceExtensions + * + * @since Added in version 3.2. + * + * @ingroup vulkan + */ +GLFWAPI VkResult glfwCreateWindowSurface(VkInstance instance, GLFWwindow* window, const VkAllocationCallbacks* allocator, VkSurfaceKHR* surface); + +#endif /*VK_VERSION_1_0*/ + + +/************************************************************************* + * Global definition cleanup + *************************************************************************/ + +/* ------------------- BEGIN SYSTEM/COMPILER SPECIFIC -------------------- */ + +#ifdef GLFW_WINGDIAPI_DEFINED + #undef WINGDIAPI + #undef GLFW_WINGDIAPI_DEFINED +#endif + +#ifdef GLFW_CALLBACK_DEFINED + #undef CALLBACK + #undef GLFW_CALLBACK_DEFINED +#endif + +/* Some OpenGL related headers need GLAPIENTRY, but it is unconditionally + * defined by some gl.h variants (OpenBSD) so define it after if needed. + */ +#ifndef GLAPIENTRY + #define GLAPIENTRY APIENTRY +#endif + +/* -------------------- END SYSTEM/COMPILER SPECIFIC --------------------- */ + + +#ifdef __cplusplus +} +#endif + +#endif /* _glfw3_h_ */ + diff --git a/glfw3.lib b/glfw3.lib new file mode 100644 index 0000000000000000000000000000000000000000..863c6190c85d5dc8acbc119d8ad406a46ba3af9c GIT binary patch literal 30306 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 H{1W$n3Zm9| literal 0 HcmV?d00001 diff --git a/khrplatform.h b/khrplatform.h new file mode 100644 index 0000000..0164644 --- /dev/null +++ b/khrplatform.h @@ -0,0 +1,311 @@ +#ifndef __khrplatform_h_ +#define __khrplatform_h_ + +/* +** Copyright (c) 2008-2018 The Khronos Group Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a +** copy of this software and/or associated documentation files (the +** "Materials"), to deal in the Materials without restriction, including +** without limitation the rights to use, copy, modify, merge, publish, +** distribute, sublicense, and/or sell copies of the Materials, and to +** permit persons to whom the Materials are furnished to do so, subject to +** the following conditions: +** +** The above copyright notice and this permission notice shall be included +** in all copies or substantial portions of the Materials. +** +** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. +*/ + +/* Khronos platform-specific types and definitions. + * + * The master copy of khrplatform.h is maintained in the Khronos EGL + * Registry repository at https://github.com/KhronosGroup/EGL-Registry + * The last semantic modification to khrplatform.h was at commit ID: + * 67a3e0864c2d75ea5287b9f3d2eb74a745936692 + * + * Adopters may modify this file to suit their platform. Adopters are + * encouraged to submit platform specific modifications to the Khronos + * group so that they can be included in future versions of this file. + * Please submit changes by filing pull requests or issues on + * the EGL Registry repository linked above. + * + * + * See the Implementer's Guidelines for information about where this file + * should be located on your system and for more details of its use: + * http://www.khronos.org/registry/implementers_guide.pdf + * + * This file should be included as + * #include + * by Khronos client API header files that use its types and defines. + * + * The types in khrplatform.h should only be used to define API-specific types. + * + * Types defined in khrplatform.h: + * khronos_int8_t signed 8 bit + * khronos_uint8_t unsigned 8 bit + * khronos_int16_t signed 16 bit + * khronos_uint16_t unsigned 16 bit + * khronos_int32_t signed 32 bit + * khronos_uint32_t unsigned 32 bit + * khronos_int64_t signed 64 bit + * khronos_uint64_t unsigned 64 bit + * khronos_intptr_t signed same number of bits as a pointer + * khronos_uintptr_t unsigned same number of bits as a pointer + * khronos_ssize_t signed size + * khronos_usize_t unsigned size + * khronos_float_t signed 32 bit floating point + * khronos_time_ns_t unsigned 64 bit time in nanoseconds + * khronos_utime_nanoseconds_t unsigned time interval or absolute time in + * nanoseconds + * khronos_stime_nanoseconds_t signed time interval in nanoseconds + * khronos_boolean_enum_t enumerated boolean type. This should + * only be used as a base type when a client API's boolean type is + * an enum. Client APIs which use an integer or other type for + * booleans cannot use this as the base type for their boolean. + * + * Tokens defined in khrplatform.h: + * + * KHRONOS_FALSE, KHRONOS_TRUE Enumerated boolean false/true values. + * + * KHRONOS_SUPPORT_INT64 is 1 if 64 bit integers are supported; otherwise 0. + * KHRONOS_SUPPORT_FLOAT is 1 if floats are supported; otherwise 0. + * + * Calling convention macros defined in this file: + * KHRONOS_APICALL + * KHRONOS_APIENTRY + * KHRONOS_APIATTRIBUTES + * + * These may be used in function prototypes as: + * + * KHRONOS_APICALL void KHRONOS_APIENTRY funcname( + * int arg1, + * int arg2) KHRONOS_APIATTRIBUTES; + */ + +#if defined(__SCITECH_SNAP__) && !defined(KHRONOS_STATIC) +# define KHRONOS_STATIC 1 +#endif + +/*------------------------------------------------------------------------- + * Definition of KHRONOS_APICALL + *------------------------------------------------------------------------- + * This precedes the return type of the function in the function prototype. + */ +#if defined(KHRONOS_STATIC) + /* If the preprocessor constant KHRONOS_STATIC is defined, make the + * header compatible with static linking. */ +# define KHRONOS_APICALL +#elif defined(_WIN32) +# define KHRONOS_APICALL __declspec(dllimport) +#elif defined (__SYMBIAN32__) +# define KHRONOS_APICALL IMPORT_C +#elif defined(__ANDROID__) +# define KHRONOS_APICALL __attribute__((visibility("default"))) +#else +# define KHRONOS_APICALL +#endif + +/*------------------------------------------------------------------------- + * Definition of KHRONOS_APIENTRY + *------------------------------------------------------------------------- + * This follows the return type of the function and precedes the function + * name in the function prototype. + */ +#if defined(_WIN32) && !defined(_WIN32_WCE) && !defined(__SCITECH_SNAP__) + /* Win32 but not WinCE */ +# define KHRONOS_APIENTRY __stdcall +#else +# define KHRONOS_APIENTRY +#endif + +/*------------------------------------------------------------------------- + * Definition of KHRONOS_APIATTRIBUTES + *------------------------------------------------------------------------- + * This follows the closing parenthesis of the function prototype arguments. + */ +#if defined (__ARMCC_2__) +#define KHRONOS_APIATTRIBUTES __softfp +#else +#define KHRONOS_APIATTRIBUTES +#endif + +/*------------------------------------------------------------------------- + * basic type definitions + *-----------------------------------------------------------------------*/ +#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(__GNUC__) || defined(__SCO__) || defined(__USLC__) + + +/* + * Using + */ +#include +typedef int32_t khronos_int32_t; +typedef uint32_t khronos_uint32_t; +typedef int64_t khronos_int64_t; +typedef uint64_t khronos_uint64_t; +#define KHRONOS_SUPPORT_INT64 1 +#define KHRONOS_SUPPORT_FLOAT 1 +/* + * To support platform where unsigned long cannot be used interchangeably with + * inptr_t (e.g. CHERI-extended ISAs), we can use the stdint.h intptr_t. + * Ideally, we could just use (u)intptr_t everywhere, but this could result in + * ABI breakage if khronos_uintptr_t is changed from unsigned long to + * unsigned long long or similar (this results in different C++ name mangling). + * To avoid changes for existing platforms, we restrict usage of intptr_t to + * platforms where the size of a pointer is larger than the size of long. + */ +#if defined(__SIZEOF_LONG__) && defined(__SIZEOF_POINTER__) +#if __SIZEOF_POINTER__ > __SIZEOF_LONG__ +#define KHRONOS_USE_INTPTR_T +#endif +#endif + +#elif defined(__VMS ) || defined(__sgi) + +/* + * Using + */ +#include +typedef int32_t khronos_int32_t; +typedef uint32_t khronos_uint32_t; +typedef int64_t khronos_int64_t; +typedef uint64_t khronos_uint64_t; +#define KHRONOS_SUPPORT_INT64 1 +#define KHRONOS_SUPPORT_FLOAT 1 + +#elif defined(_WIN32) && !defined(__SCITECH_SNAP__) + +/* + * Win32 + */ +typedef __int32 khronos_int32_t; +typedef unsigned __int32 khronos_uint32_t; +typedef __int64 khronos_int64_t; +typedef unsigned __int64 khronos_uint64_t; +#define KHRONOS_SUPPORT_INT64 1 +#define KHRONOS_SUPPORT_FLOAT 1 + +#elif defined(__sun__) || defined(__digital__) + +/* + * Sun or Digital + */ +typedef int khronos_int32_t; +typedef unsigned int khronos_uint32_t; +#if defined(__arch64__) || defined(_LP64) +typedef long int khronos_int64_t; +typedef unsigned long int khronos_uint64_t; +#else +typedef long long int khronos_int64_t; +typedef unsigned long long int khronos_uint64_t; +#endif /* __arch64__ */ +#define KHRONOS_SUPPORT_INT64 1 +#define KHRONOS_SUPPORT_FLOAT 1 + +#elif 0 + +/* + * Hypothetical platform with no float or int64 support + */ +typedef int khronos_int32_t; +typedef unsigned int khronos_uint32_t; +#define KHRONOS_SUPPORT_INT64 0 +#define KHRONOS_SUPPORT_FLOAT 0 + +#else + +/* + * Generic fallback + */ +#include +typedef int32_t khronos_int32_t; +typedef uint32_t khronos_uint32_t; +typedef int64_t khronos_int64_t; +typedef uint64_t khronos_uint64_t; +#define KHRONOS_SUPPORT_INT64 1 +#define KHRONOS_SUPPORT_FLOAT 1 + +#endif + + +/* + * Types that are (so far) the same on all platforms + */ +typedef signed char khronos_int8_t; +typedef unsigned char khronos_uint8_t; +typedef signed short int khronos_int16_t; +typedef unsigned short int khronos_uint16_t; + +/* + * Types that differ between LLP64 and LP64 architectures - in LLP64, + * pointers are 64 bits, but 'long' is still 32 bits. Win64 appears + * to be the only LLP64 architecture in current use. + */ +#ifdef KHRONOS_USE_INTPTR_T +typedef intptr_t khronos_intptr_t; +typedef uintptr_t khronos_uintptr_t; +#elif defined(_WIN64) +typedef signed long long int khronos_intptr_t; +typedef unsigned long long int khronos_uintptr_t; +#else +typedef signed long int khronos_intptr_t; +typedef unsigned long int khronos_uintptr_t; +#endif + +#if defined(_WIN64) +typedef signed long long int khronos_ssize_t; +typedef unsigned long long int khronos_usize_t; +#else +typedef signed long int khronos_ssize_t; +typedef unsigned long int khronos_usize_t; +#endif + +#if KHRONOS_SUPPORT_FLOAT +/* + * Float type + */ +typedef float khronos_float_t; +#endif + +#if KHRONOS_SUPPORT_INT64 +/* Time types + * + * These types can be used to represent a time interval in nanoseconds or + * an absolute Unadjusted System Time. Unadjusted System Time is the number + * of nanoseconds since some arbitrary system event (e.g. since the last + * time the system booted). The Unadjusted System Time is an unsigned + * 64 bit value that wraps back to 0 every 584 years. Time intervals + * may be either signed or unsigned. + */ +typedef khronos_uint64_t khronos_utime_nanoseconds_t; +typedef khronos_int64_t khronos_stime_nanoseconds_t; +#endif + +/* + * Dummy value used to pad enum types to 32 bits. + */ +#ifndef KHRONOS_MAX_ENUM +#define KHRONOS_MAX_ENUM 0x7FFFFFFF +#endif + +/* + * Enumerated boolean type + * + * Values other than zero should be considered to be true. Therefore + * comparisons should not be made against KHRONOS_TRUE. + */ +typedef enum { + KHRONOS_FALSE = 0, + KHRONOS_TRUE = 1, + KHRONOS_BOOLEAN_ENUM_FORCE_SIZE = KHRONOS_MAX_ENUM +} khronos_boolean_enum_t; + +#endif /* __khrplatform_h_ */ diff --git a/main.cpp b/main.cpp new file mode 100644 index 0000000..fddb040 --- /dev/null +++ b/main.cpp @@ -0,0 +1,564 @@ + +#include // printf, snprintf +#include // uint16_t +#include // srand, rand +#include // time +#include // cos, sin + +#include "glad.h" +#include "glfw3.h" + + +/* + you can compile this (windows only, debug version, assuming you have cl.exe available) using: + + cl.exe glad.c main.cpp /nologo /W3 /MTd /Od /Zi /RTC1 /fsanitize=address /link /out:game.exe /incremental:no glfw3.lib + + the .exe will be around 1.5mb in this case. + + + or, in release version with a smaller .exe size and better perf (181kb with clang-cl, dang just barely missed 128kb total size!), no debugging symbols etc. + + clang-cl.exe glad.c main.cpp /nologo /W3 /O2 /GS /clang:-fno-asynchronous-unwind-tables /link /out:game.exe /fixed /incremental:no /opt:icf /opt:ref libvcruntime.lib glfw3.lib + + OR + + cl.exe glad.c main.cpp /nologo /W3 /O2 /GS /link /out:game.exe /fixed /incremental:no /opt:icf /opt:ref libvcruntime.lib glfw3.lib + + + the first 10-20 frames in debug mode are prone to run below 60fps on my machine, which I unfortunately wasn't able to fix in 16 hours + - my computer is fairly weak though, it's about 10 years old and has no external GPU. You may fare better :). Subsequent frames perfome + many times better. + + + - [Y] - snake-like 0 player game + - [Y] - need to support on the order of 8k+ snakes concurrently (we're going to choose a max of 8192) + - [Y] - if the head of a snake touches the tail of another, the snake who's head touched the tail will merge up with the 'eaten' snake. + - [Y] - all snakes start with one segment + - [Y] - when there is only one snake left, the game must restart + - [Y?] - game data under 128kb - achieved if this means game state, not quite if it means .exe size (we're about ~1mb .exe size after trying to minimize size) + - [Y] - 60fps minimum, or locked + - [Y] - static memory allocation, avoid heap + - [Y] - minimal or zero usage of libraries (except glfw and opengl) +*/ + +static GLFWwindow *Window; + +inline bool checkError__(int line) { + GLenum errorCode; + while ((errorCode = glGetError()) != GL_NO_ERROR) { + switch (errorCode) { + case GL_INVALID_ENUM: + printf("%d, INVALID_ENUM", line); + break; + case GL_INVALID_VALUE: + printf("%d, INVALID_VALUE", line); + break; + case GL_INVALID_OPERATION: + printf("%d, INVALID_OPERATION", line); + break; + case GL_OUT_OF_MEMORY: + printf("%d, OUT_OF_MEMORY", line); + break; + case GL_INVALID_FRAMEBUFFER_OPERATION: + printf("%d, INVALID_FRAMEBUFFER_OPERATION", line); + break; + } + return true; + } + return false; +} +#define checkError() checkError__(__LINE__) + + +static const float PI = 3.14159f; + +//-------------------------------------------------------------------------------- +// game-data +// between QUADRANTS and pointBuffer, the only real data structures in use, +// you have 116.736kb of game state, assuming 8192 snakes. + +int windowWidth; +int windowHeight; + +struct Snake { + // coordinates are normalized unsigned integers. + // |numSegments| is just a count, where 0 indicates a dead snake. + uint16_t numSegments, headX, headY, theta; +}; +static constexpr float SNAKE_SEGMENT_RADIUS = 8; // glPointSize +static constexpr unsigned int NUM_SNAKES = 8192; // must be greater than 1 + +struct Rectangle { + uint16_t left, bottom, right, top; +}; +static constexpr uint32_t NUM_QUADRANTS = 64; +static constexpr unsigned int SNAKES_PER_QUADRANT = NUM_SNAKES/NUM_QUADRANTS; +struct Quadrant { + Snake snakes[SNAKES_PER_QUADRANT]; + Rectangle rect; +}; +static Quadrant QUADRANTS[NUM_QUADRANTS]; + +struct Point { + uint16_t x, y; + uint16_t weight; +}; +static Point pointBuffer[NUM_SNAKES]; // each snake starts as one segment which is represented as a point, so you can have at most NUM_SNAKES points. + +uint32_t numDead = 0; +uint32_t longest = 0; +uint32_t numPoints = 0; + +double msPerFrame = 0.0; +double deltaTime = 0.0; +double lastFrameCountTime = 0.0; +double lastFrameStartTime = 0.0; +bool doFancyRestart = false; + +long long int numFramesInLastSecond = 0; +long long int frameCounter = 0; +//-------------------------------------------------------------------------------- + +static inline uint16_t normalizeUint(uint16_t input, uint32_t oldMax) { + return input * USHRT_MAX / oldMax; +} + +static inline float invlerp(float a, float b, float v) { + return (v - a) / (b - a); +} +static inline float lerp(float a, float b, float t) { + return a + t * (b - a); +} + +static inline float snakeThetaToRadians(uint16_t a) { + return ((float)a/(float)USHRT_MAX)*2.f*PI; +} +static inline uint16_t radiansToSnakeTheta(float r) { + return (uint16_t) ((r + (0.f*PI)) / (2.f*PI) * (float)USHRT_MAX); +} + +static inline void splitRectangleIntoQuadrants(Rectangle input, Rectangle quadrants[4]) { + auto centerX = (input.left + input.right) / 2; + auto centerY = (input.top + input.bottom) / 2; + + // top-left quadrant, proceeding clockwise + quadrants[0].left = input.left; + quadrants[0].right = centerX; + quadrants[0].top = input.top; + quadrants[0].bottom = centerY; + + quadrants[1].left = centerX; + quadrants[1].right = input.right; + quadrants[1].top = input.top; + quadrants[1].bottom = centerY; + + quadrants[2].left = centerX; + quadrants[2].right = input.right; + quadrants[2].top = centerY; + quadrants[2].bottom = input.bottom; + + quadrants[3].left = input.left; + quadrants[3].right = centerX; + quadrants[3].top = centerY; + quadrants[3].bottom = input.bottom; +} + +static inline uint16_t randInRange(unsigned int min, unsigned int max) { + const unsigned int range = max - min + 1; + return (uint16_t) (min + (unsigned int)((double)rand() / (RAND_MAX + 1.0) * range)); +} + +static inline void calculateSegment(Snake* snake, uint16_t segmentNumber, Point* outPoint) { + const float weight = (float)segmentNumber / (float)snake->numSegments; + const float radians = snakeThetaToRadians(snake->theta); + const float dx = cos(radians); + const float dy = sin(radians); + + outPoint->x = snake->headX + dx * segmentNumber * SNAKE_SEGMENT_RADIUS; + outPoint->y = snake->headY + dy * segmentNumber * SNAKE_SEGMENT_RADIUS; + outPoint->weight = (uint16_t) (weight * USHRT_MAX); +} + +static inline void initializeQuadrants(int windowWidth, int windowHeight) { + Rectangle windowQuad = { 0, 0, normalizeUint(windowWidth, windowWidth), normalizeUint(windowHeight, windowHeight) }; + Rectangle topLevelQuads[4]; + splitRectangleIntoQuadrants(windowQuad, topLevelQuads); + + // there's probably a better way to iteratively construct a quadtree... + for (int i = 0; i < 4; i++) { + Rectangle iquads[4]; + splitRectangleIntoQuadrants(topLevelQuads[i], iquads); + + for (int j = 0; j < 4; j++) { + Rectangle jquads[4]; + splitRectangleIntoQuadrants(iquads[j], jquads); + + for (int k = 0; k < 4; k++) { + QUADRANTS[i*16+j*4+k].rect = jquads[k]; + } + } + } + + for (int i = 0; i < NUM_QUADRANTS; i++) { + Quadrant* q= &QUADRANTS[i]; + for (int j = 0; j < SNAKES_PER_QUADRANT; j++) { + Snake* snake = &q->snakes[j]; + snake->numSegments = 1; + snake->headX = randInRange(q->rect.left, q->rect.right); + snake->headY = randInRange(q->rect.bottom, q->rect.top); + //printf("Snake #%d, quadrant %d - head (x/y): %u/%u, numSegments: %u\n", j+1, i, snake->headX, snake->headY, snake->numSegments); + } + } +} + +static inline unsigned int computeQuadrant(int x, int y, int left, int top, int bottom, int right) { + if (x < left || y < bottom || x > right || y > top) { + printf("outside rect!\n"); + return -1; + + } else if (x < right/2 && y < top/2) { + return 0; + + } else if (x >= right/2 && y < top/2) { + return 1; + + } else if (x < right/2 && y >= top/2) { + return 2; + + } else { + return 3; + } +} + +static inline bool findNearestSnakeInQuad( + Quadrant* quad, + Snake* snake, + int searchingSnakeIndex, + float& nearestD, + uint16_t& nearestX, + uint16_t& nearestY, + bool* outHadLiveSnake +) { + for (int j = 0; j < SNAKES_PER_QUADRANT; j++) { + if (searchingSnakeIndex == j) continue; + + Snake* other = &quad->snakes[j]; + if (other->numSegments == 0) continue; // dead snake, can't bite it + + // if we have at least one snake that has a segment, that means this quad has at least one other live snake. + if (outHadLiveSnake) *outHadLiveSnake = true; + + // find tail coordinates for this snake + Point tail; + calculateSegment(other, other->numSegments-1, &tail); + + // compute distance, check if it's closer than previously recorded + float dx = ((float)snake->headX - (float)tail.x); + float dy = ((float)snake->headY - (float)tail.y); + float distance = sqrt(dx*dx + dy*dy); + if (distance < nearestD) { + nearestD = distance; + nearestX = tail.x; + nearestY = tail.y; + + if (distance < SNAKE_SEGMENT_RADIUS*3) { + // if we're close enough, we can call it a bite and early-out. + snake->numSegments += other->numSegments; + other->numSegments = 0; + return 1; + } + } + } + return 0; +} + +static inline bool updateQuadrant(unsigned int quadIndex) { + Quadrant* quad = &QUADRANTS[quadIndex]; + + for (int i = 0; i < SNAKES_PER_QUADRANT; i++) { + // update each snake in the quad. there are only really a few things to do: + // - find nearest neighbour to snake + // - check if bite + // - move and rotate snake + bool foundAtLeastOneOtherLiveSnakeInQuad = false; + Snake* snake = &quad->snakes[i]; + + uint16_t numSegments = snake->numSegments; + if (numSegments == 0) continue; + + if (numSegments > longest) { + longest = numSegments; // just for fun. + } + + // we now linear search for nearest tail to bite, early-outing on dead snakes, + // and very-close snakes (we technically do not always garuntee finding the 'nearest') + const uint16_t headX = snake->headX; + const uint16_t headY = snake->headY; + float nearestD = 999999.f; // arbitrary large-ish number + uint16_t nearestX = 0; + uint16_t nearestY = 0; + if (findNearestSnakeInQuad(quad, snake, i, nearestD, nearestX, nearestY, &foundAtLeastOneOtherLiveSnakeInQuad)) { + numDead++; + goto nextSnake; // we killed another snake, we can move on to the next snake. + }; + + if (!foundAtLeastOneOtherLiveSnakeInQuad) { + // we found 0 snakes in this quad (besides ourselves) + // this circumstance can only arise when there are a small number of snakes left + // , less than 2k at least, so we can just lazily iterate the rest of the quadrants. + for (int j = 0; j < NUM_QUADRANTS; j++) { + if (quadIndex == j) continue; + + if (findNearestSnakeInQuad(&QUADRANTS[j], snake, -1, nearestD, nearestX, nearestY, &foundAtLeastOneOtherLiveSnakeInQuad)) { + numDead++; + goto nextSnake; // we killed another snake, we can move on to the next snake, after appending our draw data + } + } + } + if (!foundAtLeastOneOtherLiveSnakeInQuad) { + // we must be the only snake left! + return true; + } + + // do the movement and rotation for this snake. + const float angle = atan2f((float)headY - (float)nearestY, (float)headX - (float)nearestX); + // it probably makes more sense for the smaller guys to be faster, but the simulation gets quite slow towards the end of it, so I do the opposite. + const float dx = -cos(angle) * 500.f*log(0.25f*snake->numSegments + 1) * deltaTime; + const float dy = -sin(angle) * 500.f*log(0.25f*snake->numSegments + 1) * deltaTime; + snake->headX += dx; + snake->headY += dy; +#if 1 + // move the snake's angle towards angle |angle|, with some fixed radial speed, smoothly + const float snakeAngle = snakeThetaToRadians(snake->theta); + const float angleDelta = angle - snakeAngle; + //snake->theta = radiansToSnakeTheta(snakeAngle + ((2.f*PI*angleDelta)*0.0015f/(2.f*PI)); + //snake->theta = radiansToSnakeTheta(fmin(snakeAngle + (2.f*PI*angleDelta)*(deltaTime/snake->numSegments)/(2.f*PI), angle)); + snake->theta = radiansToSnakeTheta(snakeAngle + (angleDelta+2.f*PI)*deltaTime*100.f/snake->numSegments); +#else + snake->theta = radiansToSnakeTheta(angle); +#endif + // at this point, we know everything we need to know about this snake to populate the draw data for it. + // we have the head position, an angle, and a count of the number of segments, so we use this to generate + // points from head --> tail. + for (uint16_t p = 0; p < snake->numSegments; p++) { + Point* point = &pointBuffer[numPoints++]; + calculateSegment(snake, p, point); + } +nextSnake: continue; + } + + return false; +} + +int main(void) { + glfwInit(); + glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); + glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); + glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); + glfwWindowHint(GLFW_VISIBLE, false); // hide window initially - while we set up stuff. show after. + glfwWindowHint(GLFW_RESIZABLE, false); // don't allow the user to re-size the window + glfwWindowHint(GLFW_CENTER_CURSOR, true); // center the cursor in the window when opening a fullscreen window + glfwWindowHint(GLFW_FOCUS_ON_SHOW, true); // focus the window when glfwShowWindow is called + + #ifdef __APPLE__ + // removes all deprecated opengl functionality from older opengl versions, required on MacOSX + glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); + #endif + + GLFWmonitor* primaryMonitor = glfwGetPrimaryMonitor(); + const GLFWvidmode* primaryMonitorMode = glfwGetVideoMode(primaryMonitor); + float initialWidth = 1138.0f; + float initialHeight = 640.0f; + // scale up the dimensions of the initial size of the window until it exceeds the size of the screen, then go with the one just before that + while (1) { + if ((initialHeight * 1.2f > primaryMonitorMode->height) || (initialWidth * 1.2f) > primaryMonitorMode->width) { + break; + } + initialHeight *= 1.2f; + initialWidth *= 1.2f; + } + windowWidth = (int) initialWidth; + windowHeight = (int) initialHeight; + + Window = glfwCreateWindow(windowWidth, windowHeight, "flOw MMo", nullptr, nullptr); + if (Window == nullptr) { + printf("%s", "Failed to initialize GLFWwindow\n"); + return 1; + } + + glfwMakeContextCurrent(Window); + + //-------------------------------------------------------------------------------- + // initialize glad, resolve OpenGL function pointers + if (!gladLoadGLLoader((GLADloadproc) glfwGetProcAddress)) { + printf("%s", "Failed to initialize GLAD\n"); + return 1; + } + + //-------------------------------------------------------------------------------- + // compile and link our shader. + // my apologies if this fails compilation on your machine. + // My main computer's OpenGL driver has been known to allow compilations where others fail it. + int success; + char infoLog[512]; + // vertex... + const char* vertexShaderCode = R"( + #version 330 core + layout (location = 0) in vec2 aPos; + layout (location = 1) in float aWeight; + + flat out float vWeight; + + void main() { + vWeight = aWeight; + gl_Position = vec4(aPos*2.0-1.0, 0.0, 1.0); + gl_PointSize = 10 + (1.0f - aWeight)*10; + } + )"; + unsigned int vertexShaderId = glCreateShader(GL_VERTEX_SHADER); + glShaderSource(vertexShaderId, 1, &vertexShaderCode, nullptr); + glCompileShader(vertexShaderId); + glGetShaderiv(vertexShaderId, GL_COMPILE_STATUS, &success); + if (!success) { + glGetShaderInfoLog(vertexShaderId, 512, nullptr, infoLog); + printf("Failure compiling vertex shader!\n%s\nSource: %s\n", infoLog, vertexShaderCode); + return 1; + } + + // fragment... + const char* fragmentShaderCode = R"( + #version 330 core + + flat in float vWeight; + + out vec4 FragColor; + + void main() { + FragColor = vec4(vWeight + 0.5, 0.5f * vWeight, 0.2f / (vWeight+0.01), 1.0f); + } + )"; + unsigned int fragmentShaderId = glCreateShader(GL_FRAGMENT_SHADER); + glShaderSource(fragmentShaderId, 1, &fragmentShaderCode, nullptr); + glCompileShader(fragmentShaderId); + glGetShaderiv(fragmentShaderId, GL_COMPILE_STATUS, &success); + if (!success) { + glGetShaderInfoLog(fragmentShaderId, 512, nullptr, infoLog); + printf("Failure compiling fragment shader!\n%s\nSource: %s\n", infoLog, fragmentShaderCode); + return 1; + } + + unsigned int shaderId = glCreateProgram(); + glAttachShader(shaderId, vertexShaderId); + glAttachShader(shaderId, fragmentShaderId); + glLinkProgram(shaderId); + glGetProgramiv(shaderId, GL_LINK_STATUS, &success); + if (!success) { + glGetProgramInfoLog(shaderId, 512, nullptr, infoLog); + printf("Failure linking shader!\n%s\n", infoLog); + return 1; + } + checkError(); + + // use it, we only have one shader + glUseProgram(shaderId); + checkError(); + + //-------------------------------------------------------------------------------- + srand(time(nullptr)); + for (int i = 0; i < rand(); i++) rand(); // discard first few calls, randomly. 'rand()' has poor entropy + + // initialize the game state. set up all the initial snake positions, etc. + initializeQuadrants(windowWidth, windowHeight); + + //-------------------------------------------------------------------------------- + // setup the VAO/VBO + unsigned int VAO, VBO; + glGenVertexArrays(1, &VAO); + glBindVertexArray(VAO); + glGenBuffers(1, &VBO); + glBindBuffer(GL_ARRAY_BUFFER, VBO); + glEnableVertexAttribArray(0); + glVertexAttribPointer(0, 2, GL_UNSIGNED_SHORT, GL_TRUE, sizeof(Point), (void*)offsetof(Point, x)); + glEnableVertexAttribArray(1); + glVertexAttribPointer(1, 1, GL_UNSIGNED_SHORT, GL_TRUE, sizeof(Point), (void*)offsetof(Point, weight)); + + //-------------------------------------------------------------------------------- + // set global opengl state + glClearColor(0.25f, 0.52f, 0.54f, 1.0f); + glEnable(GL_PROGRAM_POINT_SIZE); + glEnable(GL_DEPTH_TEST); + glDepthFunc(GL_LESS); + glEnable(GL_CULL_FACE); + + glfwShowWindow(Window); // make window visible before entering main loop + glfwRequestWindowAttention(Window); + + while (!glfwWindowShouldClose(Window)) { + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + + // calculate timing metrics, delta time, etc. + double currentTime = glfwGetTime(); + frameCounter++; + if (currentTime - lastFrameCountTime >= 1.0) { + msPerFrame = 1000.0/frameCounter; + numFramesInLastSecond = frameCounter; + frameCounter = 0; + lastFrameCountTime += 1.0; + + static char windowTitle[256]; + snprintf(windowTitle, 256, "flOw MMo - %.2f ms per frame, %lld fps, delta %.2f, num snakes: %u, num alive: %u, dead: %u, longest boi: %u", msPerFrame, numFramesInLastSecond, deltaTime, NUM_SNAKES, NUM_SNAKES-numDead, numDead, longest); + glfwSetWindowTitle(Window, windowTitle); // <-- this call is very slow :( + } + deltaTime = currentTime - lastFrameStartTime; + lastFrameStartTime = currentTime; + + // set ourselves to close if you press escape + if (glfwGetKey(Window, GLFW_KEY_ESCAPE) == GLFW_PRESS) { + glfwSetWindowShouldClose(Window, true); + continue; + } + + static double lastUpdateTime = 0.0f; + if ((currentTime - lastUpdateTime) < 0.0167f) { + continue; // we already updated in the last 16ms, skip to next frame + } + + if (doFancyRestart) { + initializeQuadrants(windowWidth, windowHeight); + doFancyRestart = false; + + } else { + // update game state: + bool gameOver = false; + for (int q = 0; q < NUM_QUADRANTS; q++) { + gameOver = updateQuadrant(q); + if (gameOver) break; + } + if (gameOver) { + printf("game over!\n"); + doFancyRestart = true; + continue; + } + } + + // upload draw data and render + glBufferData(GL_ARRAY_BUFFER, sizeof(Point)*NUM_SNAKES, nullptr, GL_DYNAMIC_DRAW); + glBufferData(GL_ARRAY_BUFFER, sizeof(Point)*NUM_SNAKES, pointBuffer, GL_DYNAMIC_DRAW); + glDrawArrays(GL_POINTS, 0, numPoints); + numPoints = 0; + checkError(); + + glfwSwapBuffers(Window); + glfwPollEvents(); // performs better on windows at the end of frame vs. start + } + + glDeleteShader(vertexShaderId); + glDeleteShader(fragmentShaderId); + glDeleteProgram(shaderId); + + glfwTerminate(); + + return 0; +} +