Home Explore Help
Sign In
cpp
/
love2d.love
mirror of https://github.com/love2d/love.git
2
0
Fork 0
Files Issues 0 Wiki
Browse Source

Updated GLAD for the latest GL and GLES extensions.

Alex Szpakowski 10 years ago
parent
bd271ce5cb
commit
d00773b974
4 changed files with 960 additions and 81 deletions
Split View Show Diff Stats
  1. 347 14
      src/libraries/glad/glad.cpp
  2. 489 45
      src/libraries/glad/glad.hpp
  3. 123 21
      src/libraries/glad/gladfuncs.hpp
  4. 1 1
      src/modules/graphics/opengl/Canvas.cpp

+ 347 - 14
src/libraries/glad/glad.cpp
View File 

@@ -135,6 +135,7 @@ pfn_glBlendFuncSeparate fp_glBlendFuncSeparate;
 
 pfn_glVertex4fv fp_glVertex4fv;
 
 pfn_glMinSampleShading fp_glMinSampleShading;
 
 pfn_glClearNamedFramebufferfi fp_glClearNamedFramebufferfi;
 
+pfn_glGetQueryBufferObjectuiv fp_glGetQueryBufferObjectuiv;
 
 pfn_glBindTexture fp_glBindTexture;
 
 pfn_glVertexAttrib1s fp_glVertexAttrib1s;
 
 pfn_glTexCoord2fv fp_glTexCoord2fv;
 
@@ -189,6 +190,7 @@ pfn_glBindImageTexture fp_glBindImageTexture;
 
 pfn_glVertexAttrib3f fp_glVertexAttrib3f;
 
 pfn_glProgramUniformMatrix4fv fp_glProgramUniformMatrix4fv;
 
 pfn_glVertex2iv fp_glVertex2iv;
 
+pfn_glGetQueryBufferObjecti64v fp_glGetQueryBufferObjecti64v;
 
 pfn_glColor3sv fp_glColor3sv;
 
 pfn_glGetVertexAttribdv fp_glGetVertexAttribdv;
 
 pfn_glActiveShaderProgram fp_glActiveShaderProgram;
 
@@ -801,6 +803,7 @@ pfn_glRasterPos2iv fp_glRasterPos2iv;
 
 pfn_glGetBufferSubData fp_glGetBufferSubData;
 
 pfn_glGetVertexAttribLdv fp_glGetVertexAttribLdv;
 
 pfn_glGetnUniformuiv fp_glGetnUniformuiv;
 
+pfn_glGetQueryBufferObjectiv fp_glGetQueryBufferObjectiv;
 
 pfn_glTexEnviv fp_glTexEnviv;
 
 pfn_glBlendEquationSeparate fp_glBlendEquationSeparate;
 
 pfn_glVertexAttribI1ui fp_glVertexAttribI1ui;
 
@@ -1015,6 +1018,7 @@ pfn_glTexCoord1sv fp_glTexCoord1sv;
 
 pfn_glBufferData fp_glBufferData;
 
 pfn_glEvalPoint1 fp_glEvalPoint1;
 
 pfn_glGetTexParameterIiv fp_glGetTexParameterIiv;
 
+pfn_glGetQueryBufferObjectui64v fp_glGetQueryBufferObjectui64v;
 
 pfn_glTexCoord1dv fp_glTexCoord1dv;
 
 pfn_glTexCoordP1ui fp_glTexCoordP1ui;
 
 pfn_glGetError fp_glGetError;
 
@@ -1194,6 +1198,9 @@ pfn_glNamedBufferPageCommitmentEXT fp_glNamedBufferPageCommitmentEXT;
 
 pfn_glNamedBufferPageCommitmentARB fp_glNamedBufferPageCommitmentARB;
 
 pfn_glTexPageCommitmentARB fp_glTexPageCommitmentARB;
 
 pfn_glTexBufferARB fp_glTexBufferARB;
 
+pfn_glDrawArraysInstancedBaseInstanceEXT fp_glDrawArraysInstancedBaseInstanceEXT;
 
+pfn_glDrawElementsInstancedBaseInstanceEXT fp_glDrawElementsInstancedBaseInstanceEXT;
 
+pfn_glDrawElementsInstancedBaseVertexBaseInstanceEXT fp_glDrawElementsInstancedBaseVertexBaseInstanceEXT;
 
 pfn_glUniformBufferEXT fp_glUniformBufferEXT;
 
 pfn_glGetUniformBufferSizeEXT fp_glGetUniformBufferSizeEXT;
 
 pfn_glGetUniformOffsetEXT fp_glGetUniformOffsetEXT;
 
@@ -1480,6 +1487,10 @@ pfn_glBlendFunciEXT fp_glBlendFunciEXT;
 
 pfn_glBlendFuncSeparateiEXT fp_glBlendFuncSeparateiEXT;
 
 pfn_glColorMaskiEXT fp_glColorMaskiEXT;
 
 pfn_glIsEnablediEXT fp_glIsEnablediEXT;
 
+pfn_glDrawElementsBaseVertexEXT fp_glDrawElementsBaseVertexEXT;
 
+pfn_glDrawRangeElementsBaseVertexEXT fp_glDrawRangeElementsBaseVertexEXT;
 
+pfn_glDrawElementsInstancedBaseVertexEXT fp_glDrawElementsInstancedBaseVertexEXT;
 
+pfn_glMultiDrawElementsBaseVertexEXT fp_glMultiDrawElementsBaseVertexEXT;
 
 pfn_glDrawArraysInstancedEXT fp_glDrawArraysInstancedEXT;
 
 pfn_glDrawElementsInstancedEXT fp_glDrawElementsInstancedEXT;
 
 pfn_glBlitFramebufferEXT fp_glBlitFramebufferEXT;
 
@@ -1519,12 +1530,16 @@ pfn_glUniform4uivEXT fp_glUniform4uivEXT;
 
 pfn_glVertexAttribDivisorEXT fp_glVertexAttribDivisorEXT;
 
 pfn_glMapBufferRangeEXT fp_glMapBufferRangeEXT;
 
 pfn_glFlushMappedBufferRangeEXT fp_glFlushMappedBufferRangeEXT;
 
+pfn_glMultiDrawArraysIndirectEXT fp_glMultiDrawArraysIndirectEXT;
 
+pfn_glMultiDrawElementsIndirectEXT fp_glMultiDrawElementsIndirectEXT;
 
 pfn_glFramebufferTexture2DMultisampleEXT fp_glFramebufferTexture2DMultisampleEXT;
 
 pfn_glReadBufferIndexedEXT fp_glReadBufferIndexedEXT;
 
 pfn_glDrawBuffersIndexedEXT fp_glDrawBuffersIndexedEXT;
 
 pfn_glGetIntegeri_vEXT fp_glGetIntegeri_vEXT;
 
+pfn_glPolygonOffsetClampEXT fp_glPolygonOffsetClampEXT;
 
 pfn_glPrimitiveBoundingBoxEXT fp_glPrimitiveBoundingBoxEXT;
 
 pfn_glProvokingVertexEXT fp_glProvokingVertexEXT;
 
+pfn_glRasterSamplesEXT fp_glRasterSamplesEXT;
 
 pfn_glGetGraphicsResetStatusEXT fp_glGetGraphicsResetStatusEXT;
 
 pfn_glReadnPixelsEXT fp_glReadnPixelsEXT;
 
 pfn_glGetnUniformfvEXT fp_glGetnUniformfvEXT;
 
@@ -1581,21 +1596,48 @@ pfn_glVertexAttribL4dvEXT fp_glVertexAttribL4dvEXT;
 
 pfn_glVertexAttribLPointerEXT fp_glVertexAttribLPointerEXT;
 
 pfn_glGetVertexAttribLdvEXT fp_glGetVertexAttribLdvEXT;
 
 pfn_glImportSyncEXT fp_glImportSyncEXT;
 
+pfn_glCopyImageSubDataOES fp_glCopyImageSubDataOES;
 
+pfn_glEnableiOES fp_glEnableiOES;
 
+pfn_glDisableiOES fp_glDisableiOES;
 
+pfn_glBlendEquationiOES fp_glBlendEquationiOES;
 
+pfn_glBlendEquationSeparateiOES fp_glBlendEquationSeparateiOES;
 
+pfn_glBlendFunciOES fp_glBlendFunciOES;
 
+pfn_glBlendFuncSeparateiOES fp_glBlendFuncSeparateiOES;
 
+pfn_glColorMaskiOES fp_glColorMaskiOES;
 
+pfn_glIsEnablediOES fp_glIsEnablediOES;
 
+pfn_glDrawElementsBaseVertexOES fp_glDrawElementsBaseVertexOES;
 
+pfn_glDrawRangeElementsBaseVertexOES fp_glDrawRangeElementsBaseVertexOES;
 
+pfn_glDrawElementsInstancedBaseVertexOES fp_glDrawElementsInstancedBaseVertexOES;
 
+pfn_glMultiDrawElementsBaseVertexOES fp_glMultiDrawElementsBaseVertexOES;
 
 pfn_glEGLImageTargetTexture2DOES fp_glEGLImageTargetTexture2DOES;
 
 pfn_glEGLImageTargetRenderbufferStorageOES fp_glEGLImageTargetRenderbufferStorageOES;
 
+pfn_glFramebufferTextureOES fp_glFramebufferTextureOES;
 
 pfn_glGetProgramBinaryOES fp_glGetProgramBinaryOES;
 
 pfn_glProgramBinaryOES fp_glProgramBinaryOES;
 
 pfn_glMapBufferOES fp_glMapBufferOES;
 
 pfn_glUnmapBufferOES fp_glUnmapBufferOES;
 
 pfn_glGetBufferPointervOES fp_glGetBufferPointervOES;
 
+pfn_glPrimitiveBoundingBoxOES fp_glPrimitiveBoundingBoxOES;
 
 pfn_glMinSampleShadingOES fp_glMinSampleShadingOES;
 
+pfn_glPatchParameteriOES fp_glPatchParameteriOES;
 
 pfn_glTexImage3DOES fp_glTexImage3DOES;
 
 pfn_glTexSubImage3DOES fp_glTexSubImage3DOES;
 
 pfn_glCopyTexSubImage3DOES fp_glCopyTexSubImage3DOES;
 
 pfn_glCompressedTexImage3DOES fp_glCompressedTexImage3DOES;
 
 pfn_glCompressedTexSubImage3DOES fp_glCompressedTexSubImage3DOES;
 
 pfn_glFramebufferTexture3DOES fp_glFramebufferTexture3DOES;
 
+pfn_glTexParameterIivOES fp_glTexParameterIivOES;
 
+pfn_glTexParameterIuivOES fp_glTexParameterIuivOES;
 
+pfn_glGetTexParameterIivOES fp_glGetTexParameterIivOES;
 
+pfn_glGetTexParameterIuivOES fp_glGetTexParameterIuivOES;
 
+pfn_glSamplerParameterIivOES fp_glSamplerParameterIivOES;
 
+pfn_glSamplerParameterIuivOES fp_glSamplerParameterIuivOES;
 
+pfn_glGetSamplerParameterIivOES fp_glGetSamplerParameterIivOES;
 
+pfn_glGetSamplerParameterIuivOES fp_glGetSamplerParameterIuivOES;
 
+pfn_glTexBufferOES fp_glTexBufferOES;
 
+pfn_glTexBufferRangeOES fp_glTexBufferRangeOES;
 
 pfn_glTexStorage3DMultisampleOES fp_glTexStorage3DMultisampleOES;
 
+pfn_glTextureViewOES fp_glTextureViewOES;
 
 pfn_glBindVertexArrayOES fp_glBindVertexArrayOES;
 
 pfn_glDeleteVertexArraysOES fp_glDeleteVertexArraysOES;
 
 pfn_glGenVertexArraysOES fp_glGenVertexArraysOES;
 
@@ -1755,6 +1797,7 @@ pfn_glBlendParameteriNV fp_glBlendParameteriNV;
 
 pfn_glBlendBarrierNV fp_glBlendBarrierNV;
 
 pfn_glBeginConditionalRenderNV fp_glBeginConditionalRenderNV;
 
 pfn_glEndConditionalRenderNV fp_glEndConditionalRenderNV;
 
+pfn_glSubpixelPrecisionBiasNV fp_glSubpixelPrecisionBiasNV;
 
 pfn_glCopyBufferSubDataNV fp_glCopyBufferSubDataNV;
 
 pfn_glCopyImageSubDataNV fp_glCopyImageSubDataNV;
 
 pfn_glCoverageMaskNV fp_glCoverageMaskNV;
 
@@ -1776,7 +1819,11 @@ pfn_glTestFenceNV fp_glTestFenceNV;
 
 pfn_glGetFenceivNV fp_glGetFenceivNV;
 
 pfn_glFinishFenceNV fp_glFinishFenceNV;
 
 pfn_glSetFenceNV fp_glSetFenceNV;
 
+pfn_glFragmentCoverageColorNV fp_glFragmentCoverageColorNV;
 
 pfn_glBlitFramebufferNV fp_glBlitFramebufferNV;
 
+pfn_glCoverageModulationTableNV fp_glCoverageModulationTableNV;
 
+pfn_glGetCoverageModulationTableNV fp_glGetCoverageModulationTableNV;
 
+pfn_glCoverageModulationNV fp_glCoverageModulationNV;
 
 pfn_glRenderbufferStorageMultisampleNV fp_glRenderbufferStorageMultisampleNV;
 
 pfn_glRenderbufferStorageMultisampleCoverageNV fp_glRenderbufferStorageMultisampleCoverageNV;
 
 pfn_glProgramVertexLimitNV fp_glProgramVertexLimitNV;
 
@@ -1846,6 +1893,7 @@ pfn_glVertexAttribs2hvNV fp_glVertexAttribs2hvNV;
 
 pfn_glVertexAttribs3hvNV fp_glVertexAttribs3hvNV;
 
 pfn_glVertexAttribs4hvNV fp_glVertexAttribs4hvNV;
 
 pfn_glVertexAttribDivisorNV fp_glVertexAttribDivisorNV;
 
+pfn_glGetInternalformatSampleivNV fp_glGetInternalformatSampleivNV;
 
 pfn_glUniformMatrix2x3fvNV fp_glUniformMatrix2x3fvNV;
 
 pfn_glUniformMatrix3x2fvNV fp_glUniformMatrix3x2fvNV;
 
 pfn_glUniformMatrix2x4fvNV fp_glUniformMatrix2x4fvNV;
 
@@ -1888,9 +1936,6 @@ pfn_glStencilStrokePathNV fp_glStencilStrokePathNV;
 
 pfn_glStencilFillPathInstancedNV fp_glStencilFillPathInstancedNV;
 
 pfn_glStencilStrokePathInstancedNV fp_glStencilStrokePathInstancedNV;
 
 pfn_glPathCoverDepthFuncNV fp_glPathCoverDepthFuncNV;
 
-pfn_glPathColorGenNV fp_glPathColorGenNV;
 
-pfn_glPathTexGenNV fp_glPathTexGenNV;
 
-pfn_glPathFogGenNV fp_glPathFogGenNV;
 
 pfn_glCoverFillPathNV fp_glCoverFillPathNV;
 
 pfn_glCoverStrokePathNV fp_glCoverStrokePathNV;
 
 pfn_glCoverFillPathInstancedNV fp_glCoverFillPathInstancedNV;
 
@@ -1903,10 +1948,6 @@ pfn_glGetPathDashArrayNV fp_glGetPathDashArrayNV;
 
 pfn_glGetPathMetricsNV fp_glGetPathMetricsNV;
 
 pfn_glGetPathMetricRangeNV fp_glGetPathMetricRangeNV;
 
 pfn_glGetPathSpacingNV fp_glGetPathSpacingNV;
 
-pfn_glGetPathColorGenivNV fp_glGetPathColorGenivNV;
 
-pfn_glGetPathColorGenfvNV fp_glGetPathColorGenfvNV;
 
-pfn_glGetPathTexGenivNV fp_glGetPathTexGenivNV;
 
-pfn_glGetPathTexGenfvNV fp_glGetPathTexGenfvNV;
 
 pfn_glIsPointInFillPathNV fp_glIsPointInFillPathNV;
 
 pfn_glIsPointInStrokePathNV fp_glIsPointInStrokePathNV;
 
 pfn_glGetPathLengthNV fp_glGetPathLengthNV;
 
@@ -1926,6 +1967,13 @@ pfn_glPathGlyphIndexArrayNV fp_glPathGlyphIndexArrayNV;
 
 pfn_glPathMemoryGlyphIndexArrayNV fp_glPathMemoryGlyphIndexArrayNV;
 
 pfn_glProgramPathFragmentInputGenNV fp_glProgramPathFragmentInputGenNV;
 
 pfn_glGetProgramResourcefvNV fp_glGetProgramResourcefvNV;
 
+pfn_glPathColorGenNV fp_glPathColorGenNV;
 
+pfn_glPathTexGenNV fp_glPathTexGenNV;
 
+pfn_glPathFogGenNV fp_glPathFogGenNV;
 
+pfn_glGetPathColorGenivNV fp_glGetPathColorGenivNV;
 
+pfn_glGetPathColorGenfvNV fp_glGetPathColorGenfvNV;
 
+pfn_glGetPathTexGenivNV fp_glGetPathTexGenivNV;
 
+pfn_glGetPathTexGenfvNV fp_glGetPathTexGenfvNV;
 
 pfn_glPresentFrameKeyedNV fp_glPresentFrameKeyedNV;
 
 pfn_glPresentFrameDualFillNV fp_glPresentFrameDualFillNV;
 
 pfn_glGetVideoivNV fp_glGetVideoivNV;
 
@@ -1935,6 +1983,9 @@ pfn_glGetVideoui64vNV fp_glGetVideoui64vNV;
 
 pfn_glPrimitiveRestartNV fp_glPrimitiveRestartNV;
 
 pfn_glPrimitiveRestartIndexNV fp_glPrimitiveRestartIndexNV;
 
 pfn_glReadBufferNV fp_glReadBufferNV;
 
+pfn_glFramebufferSampleLocationsfvNV fp_glFramebufferSampleLocationsfvNV;
 
+pfn_glNamedFramebufferSampleLocationsfvNV fp_glNamedFramebufferSampleLocationsfvNV;
 
+pfn_glResolveDepthValuesNV fp_glResolveDepthValuesNV;
 
 pfn_glMakeBufferResidentNV fp_glMakeBufferResidentNV;
 
 pfn_glMakeBufferNonResidentNV fp_glMakeBufferNonResidentNV;
 
 pfn_glIsBufferResidentNV fp_glIsBufferResidentNV;
 
@@ -2050,6 +2101,18 @@ pfn_glVideoCaptureNV fp_glVideoCaptureNV;
 
 pfn_glVideoCaptureStreamParameterivNV fp_glVideoCaptureStreamParameterivNV;
 
 pfn_glVideoCaptureStreamParameterfvNV fp_glVideoCaptureStreamParameterfvNV;
 
 pfn_glVideoCaptureStreamParameterdvNV fp_glVideoCaptureStreamParameterdvNV;
 
+pfn_glViewportArrayvNV fp_glViewportArrayvNV;
 
+pfn_glViewportIndexedfNV fp_glViewportIndexedfNV;
 
+pfn_glViewportIndexedfvNV fp_glViewportIndexedfvNV;
 
+pfn_glScissorArrayvNV fp_glScissorArrayvNV;
 
+pfn_glScissorIndexedNV fp_glScissorIndexedNV;
 
+pfn_glScissorIndexedvNV fp_glScissorIndexedvNV;
 
+pfn_glDepthRangeArrayfvNV fp_glDepthRangeArrayfvNV;
 
+pfn_glDepthRangeIndexedfNV fp_glDepthRangeIndexedfNV;
 
+pfn_glGetFloati_vNV fp_glGetFloati_vNV;
 
+pfn_glEnableiNV fp_glEnableiNV;
 
+pfn_glDisableiNV fp_glDisableiNV;
 
+pfn_glIsEnablediNV fp_glIsEnablediNV;
 
 pfn_glBeginConditionalRenderNVX fp_glBeginConditionalRenderNVX;
 
 pfn_glEndConditionalRenderNVX fp_glEndConditionalRenderNVX;
 
 pfn_glAlphaFuncQCOM fp_glAlphaFuncQCOM;
 
@@ -3178,6 +3241,10 @@ static void load_GL_VERSION_4_5(LOADER load) {
 
 	fp_glCreateSamplers = (pfn_glCreateSamplers)load("glCreateSamplers");
 
 	fp_glCreateProgramPipelines = (pfn_glCreateProgramPipelines)load("glCreateProgramPipelines");
 
 	fp_glCreateQueries = (pfn_glCreateQueries)load("glCreateQueries");
 
+	fp_glGetQueryBufferObjecti64v = (pfn_glGetQueryBufferObjecti64v)load("glGetQueryBufferObjecti64v");
 
+	fp_glGetQueryBufferObjectiv = (pfn_glGetQueryBufferObjectiv)load("glGetQueryBufferObjectiv");
 
+	fp_glGetQueryBufferObjectui64v = (pfn_glGetQueryBufferObjectui64v)load("glGetQueryBufferObjectui64v");
 
+	fp_glGetQueryBufferObjectuiv = (pfn_glGetQueryBufferObjectuiv)load("glGetQueryBufferObjectuiv");
 
 	fp_glMemoryBarrierByRegion = (pfn_glMemoryBarrierByRegion)load("glMemoryBarrierByRegion");
 
 	fp_glGetTextureSubImage = (pfn_glGetTextureSubImage)load("glGetTextureSubImage");
 
 	fp_glGetCompressedTextureSubImage = (pfn_glGetCompressedTextureSubImage)load("glGetCompressedTextureSubImage");
 
@@ -3799,6 +3866,10 @@ static void load_GL_ARB_direct_state_access(LOADER load) {
 
 	fp_glCreateSamplers = (pfn_glCreateSamplers)load("glCreateSamplers");
 
 	fp_glCreateProgramPipelines = (pfn_glCreateProgramPipelines)load("glCreateProgramPipelines");
 
 	fp_glCreateQueries = (pfn_glCreateQueries)load("glCreateQueries");
 
+	fp_glGetQueryBufferObjecti64v = (pfn_glGetQueryBufferObjecti64v)load("glGetQueryBufferObjecti64v");
 
+	fp_glGetQueryBufferObjectiv = (pfn_glGetQueryBufferObjectiv)load("glGetQueryBufferObjectiv");
 
+	fp_glGetQueryBufferObjectui64v = (pfn_glGetQueryBufferObjectui64v)load("glGetQueryBufferObjectui64v");
 
+	fp_glGetQueryBufferObjectuiv = (pfn_glGetQueryBufferObjectuiv)load("glGetQueryBufferObjectuiv");
 
 }
 
 
 GLboolean GLAD_ARB_draw_buffers_blend = GL_FALSE;
 
@@ -4433,6 +4504,14 @@ static void load_GL_ARB_viewport_array(LOADER load) {
 
 	fp_glGetDoublei_v = (pfn_glGetDoublei_v)load("glGetDoublei_v");
 
 }
 
 
+GLboolean GLAD_EXT_base_instance = GL_FALSE;
 
+static void load_GL_EXT_base_instance(LOADER load) {
 
+	if(!GLAD_EXT_base_instance) return;
 
+	fp_glDrawArraysInstancedBaseInstanceEXT = (pfn_glDrawArraysInstancedBaseInstanceEXT)load("glDrawArraysInstancedBaseInstanceEXT");
 
+	fp_glDrawElementsInstancedBaseInstanceEXT = (pfn_glDrawElementsInstancedBaseInstanceEXT)load("glDrawElementsInstancedBaseInstanceEXT");
 
+	fp_glDrawElementsInstancedBaseVertexBaseInstanceEXT = (pfn_glDrawElementsInstancedBaseVertexBaseInstanceEXT)load("glDrawElementsInstancedBaseVertexBaseInstanceEXT");
 
+}
 
+
 
 GLboolean GLAD_EXT_bgra = GL_FALSE;
 
 GLboolean GLAD_EXT_bindable_uniform = GL_FALSE;
 
 static void load_GL_EXT_bindable_uniform(LOADER load) {
 
@@ -4776,6 +4855,15 @@ static void load_GL_EXT_draw_buffers_indexed(LOADER load) {
 
 	fp_glIsEnablediEXT = (pfn_glIsEnablediEXT)load("glIsEnablediEXT");
 
 }
 
 
+GLboolean GLAD_EXT_draw_elements_base_vertex = GL_FALSE;
 
+static void load_GL_EXT_draw_elements_base_vertex(LOADER load) {
 
+	if(!GLAD_EXT_draw_elements_base_vertex) return;
 
+	fp_glDrawElementsBaseVertexEXT = (pfn_glDrawElementsBaseVertexEXT)load("glDrawElementsBaseVertexEXT");
 
+	fp_glDrawRangeElementsBaseVertexEXT = (pfn_glDrawRangeElementsBaseVertexEXT)load("glDrawRangeElementsBaseVertexEXT");
 
+	fp_glDrawElementsInstancedBaseVertexEXT = (pfn_glDrawElementsInstancedBaseVertexEXT)load("glDrawElementsInstancedBaseVertexEXT");
 
+	fp_glMultiDrawElementsBaseVertexEXT = (pfn_glMultiDrawElementsBaseVertexEXT)load("glMultiDrawElementsBaseVertexEXT");
 
+}
 
+
 
 GLboolean GLAD_EXT_draw_instanced = GL_FALSE;
 
 static void load_GL_EXT_draw_instanced(LOADER load) {
 
 	if(!GLAD_EXT_draw_instanced) return;
 
@@ -4871,6 +4959,13 @@ static void load_GL_EXT_map_buffer_range(LOADER load) {
 
 	fp_glFlushMappedBufferRangeEXT = (pfn_glFlushMappedBufferRangeEXT)load("glFlushMappedBufferRangeEXT");
 
 }
 
 
+GLboolean GLAD_EXT_multi_draw_indirect = GL_FALSE;
 
+static void load_GL_EXT_multi_draw_indirect(LOADER load) {
 
+	if(!GLAD_EXT_multi_draw_indirect) return;
 
+	fp_glMultiDrawArraysIndirectEXT = (pfn_glMultiDrawArraysIndirectEXT)load("glMultiDrawArraysIndirectEXT");
 
+	fp_glMultiDrawElementsIndirectEXT = (pfn_glMultiDrawElementsIndirectEXT)load("glMultiDrawElementsIndirectEXT");
 
+}
 
+
 
 GLboolean GLAD_EXT_multisampled_render_to_texture = GL_FALSE;
 
 static void load_GL_EXT_multisampled_render_to_texture(LOADER load) {
 
 	if(!GLAD_EXT_multisampled_render_to_texture) return;
 
@@ -4901,6 +4996,13 @@ static void load_GL_EXT_occlusion_query_boolean(LOADER load) {
 
 GLboolean GLAD_EXT_packed_depth_stencil = GL_FALSE;
 
 GLboolean GLAD_EXT_packed_float = GL_FALSE;
 
 GLboolean GLAD_EXT_pixel_buffer_object = GL_FALSE;
 
+GLboolean GLAD_EXT_polygon_offset_clamp = GL_FALSE;
 
+static void load_GL_EXT_polygon_offset_clamp(LOADER load) {
 
+	if(!GLAD_EXT_polygon_offset_clamp) return;
 
+	fp_glPolygonOffsetClampEXT = (pfn_glPolygonOffsetClampEXT)load("glPolygonOffsetClampEXT");
 
+}
 
+
 
+GLboolean GLAD_EXT_post_depth_coverage = GL_FALSE;
 
 GLboolean GLAD_EXT_primitive_bounding_box = GL_FALSE;
 
 static void load_GL_EXT_primitive_bounding_box(LOADER load) {
 
 	if(!GLAD_EXT_primitive_bounding_box) return;
 
@@ -4914,7 +5016,14 @@ static void load_GL_EXT_provoking_vertex(LOADER load) {
 
 }
 
 
 GLboolean GLAD_EXT_pvrtc_sRGB = GL_FALSE;
 
+GLboolean GLAD_EXT_raster_multisample = GL_FALSE;
 
+static void load_GL_EXT_raster_multisample(LOADER load) {
 
+	if(!GLAD_EXT_raster_multisample) return;
 
+	fp_glRasterSamplesEXT = (pfn_glRasterSamplesEXT)load("glRasterSamplesEXT");
 
+}
 
+
 
 GLboolean GLAD_EXT_read_format_bgra = GL_FALSE;
 
+GLboolean GLAD_EXT_render_snorm = GL_FALSE;
 
 GLboolean GLAD_EXT_robustness = GL_FALSE;
 
 static void load_GL_EXT_robustness(LOADER load) {
 
 	if(!GLAD_EXT_robustness) return;
 
@@ -4992,6 +5101,7 @@ GLboolean GLAD_EXT_shader_io_blocks = GL_FALSE;
 
 GLboolean GLAD_EXT_shader_pixel_local_storage = GL_FALSE;
 
 GLboolean GLAD_EXT_shader_texture_lod = GL_FALSE;
 
 GLboolean GLAD_EXT_shadow_samplers = GL_FALSE;
 
+GLboolean GLAD_EXT_sparse_texture2 = GL_FALSE;
 
 GLboolean GLAD_EXT_sRGB = GL_FALSE;
 
 GLboolean GLAD_EXT_sRGB_write_control = GL_FALSE;
 
 GLboolean GLAD_EXT_stencil_clear_tag = GL_FALSE;
 
@@ -5046,6 +5156,12 @@ GLboolean GLAD_EXT_texture_compression_s3tc = GL_FALSE;
 
 GLboolean GLAD_EXT_texture_cube_map = GL_FALSE;
 
 GLboolean GLAD_EXT_texture_cube_map_array = GL_FALSE;
 
 GLboolean GLAD_EXT_texture_filter_anisotropic = GL_FALSE;
 
+GLboolean GLAD_EXT_texture_filter_minmax = GL_FALSE;
 
+static void load_GL_EXT_texture_filter_minmax(LOADER load) {
 
+	if(!GLAD_EXT_texture_filter_minmax) return;
 
+	fp_glRasterSamplesEXT = (pfn_glRasterSamplesEXT)load("glRasterSamplesEXT");
 
+}
 
+
 
 GLboolean GLAD_EXT_texture_format_BGRA8888 = GL_FALSE;
 
 GLboolean GLAD_EXT_texture_integer = GL_FALSE;
 
 static void load_GL_EXT_texture_integer(LOADER load) {
 
@@ -5058,11 +5174,14 @@ static void load_GL_EXT_texture_integer(LOADER load) {
 
 	fp_glClearColorIuiEXT = (pfn_glClearColorIuiEXT)load("glClearColorIuiEXT");
 
 }
 
 
+GLboolean GLAD_EXT_texture_norm16 = GL_FALSE;
 
 GLboolean GLAD_EXT_texture_rg = GL_FALSE;
 
 GLboolean GLAD_EXT_texture_shared_exponent = GL_FALSE;
 
 GLboolean GLAD_EXT_texture_snorm = GL_FALSE;
 
 GLboolean GLAD_EXT_texture_sRGB = GL_FALSE;
 
 GLboolean GLAD_EXT_texture_sRGB_decode = GL_FALSE;
 
+GLboolean GLAD_EXT_texture_sRGB_R8 = GL_FALSE;
 
+GLboolean GLAD_EXT_texture_sRGB_RG8 = GL_FALSE;
 
 GLboolean GLAD_EXT_texture_storage = GL_FALSE;
 
 static void load_GL_EXT_texture_storage(LOADER load) {
 
 	if(!GLAD_EXT_texture_storage) return;
 
@@ -5124,11 +5243,40 @@ static void load_GL_EXT_x11_sync_object(LOADER load) {
 
 	fp_glImportSyncEXT = (pfn_glImportSyncEXT)load("glImportSyncEXT");
 
 }
 
 
+GLboolean GLAD_EXT_YUV_target = GL_FALSE;
 
 GLboolean GLAD_OES_compressed_ETC1_RGB8_sub_texture = GL_FALSE;
 
 GLboolean GLAD_OES_compressed_ETC1_RGB8_texture = GL_FALSE;
 
+GLboolean GLAD_OES_copy_image = GL_FALSE;
 
+static void load_GL_OES_copy_image(LOADER load) {
 
+	if(!GLAD_OES_copy_image) return;
 
+	fp_glCopyImageSubDataOES = (pfn_glCopyImageSubDataOES)load("glCopyImageSubDataOES");
 
+}
 
+
 
 GLboolean GLAD_OES_depth24 = GL_FALSE;
 
 GLboolean GLAD_OES_depth32 = GL_FALSE;
 
 GLboolean GLAD_OES_depth_texture = GL_FALSE;
 
+GLboolean GLAD_OES_draw_buffers_indexed = GL_FALSE;
 
+static void load_GL_OES_draw_buffers_indexed(LOADER load) {
 
+	if(!GLAD_OES_draw_buffers_indexed) return;
 
+	fp_glEnableiOES = (pfn_glEnableiOES)load("glEnableiOES");
 
+	fp_glDisableiOES = (pfn_glDisableiOES)load("glDisableiOES");
 
+	fp_glBlendEquationiOES = (pfn_glBlendEquationiOES)load("glBlendEquationiOES");
 
+	fp_glBlendEquationSeparateiOES = (pfn_glBlendEquationSeparateiOES)load("glBlendEquationSeparateiOES");
 
+	fp_glBlendFunciOES = (pfn_glBlendFunciOES)load("glBlendFunciOES");
 
+	fp_glBlendFuncSeparateiOES = (pfn_glBlendFuncSeparateiOES)load("glBlendFuncSeparateiOES");
 
+	fp_glColorMaskiOES = (pfn_glColorMaskiOES)load("glColorMaskiOES");
 
+	fp_glIsEnablediOES = (pfn_glIsEnablediOES)load("glIsEnablediOES");
 
+}
 
+
 
+GLboolean GLAD_OES_draw_elements_base_vertex = GL_FALSE;
 
+static void load_GL_OES_draw_elements_base_vertex(LOADER load) {
 
+	if(!GLAD_OES_draw_elements_base_vertex) return;
 
+	fp_glDrawElementsBaseVertexOES = (pfn_glDrawElementsBaseVertexOES)load("glDrawElementsBaseVertexOES");
 
+	fp_glDrawRangeElementsBaseVertexOES = (pfn_glDrawRangeElementsBaseVertexOES)load("glDrawRangeElementsBaseVertexOES");
 
+	fp_glDrawElementsInstancedBaseVertexOES = (pfn_glDrawElementsInstancedBaseVertexOES)load("glDrawElementsInstancedBaseVertexOES");
 
+	fp_glMultiDrawElementsBaseVertexOES = (pfn_glMultiDrawElementsBaseVertexOES)load("glMultiDrawElementsBaseVertexOES");
 
+}
 
+
 
 GLboolean GLAD_OES_EGL_image = GL_FALSE;
 
 static void load_GL_OES_EGL_image(LOADER load) {
 
 	if(!GLAD_OES_EGL_image) return;
 
@@ -5137,9 +5285,17 @@ static void load_GL_OES_EGL_image(LOADER load) {
 
 }
 
 
 GLboolean GLAD_OES_EGL_image_external = GL_FALSE;
 
+GLboolean GLAD_OES_EGL_image_external_essl3 = GL_FALSE;
 
 GLboolean GLAD_OES_element_index_uint = GL_FALSE;
 
 GLboolean GLAD_OES_fbo_render_mipmap = GL_FALSE;
 
 GLboolean GLAD_OES_fragment_precision_high = GL_FALSE;
 
+GLboolean GLAD_OES_geometry_point_size = GL_FALSE;
 
+GLboolean GLAD_OES_geometry_shader = GL_FALSE;
 
+static void load_GL_OES_geometry_shader(LOADER load) {
 
+	if(!GLAD_OES_geometry_shader) return;
 
+	fp_glFramebufferTextureOES = (pfn_glFramebufferTextureOES)load("glFramebufferTextureOES");
 
+}
 
+
 
 GLboolean GLAD_OES_get_program_binary = GL_FALSE;
 
 static void load_GL_OES_get_program_binary(LOADER load) {
 
 	if(!GLAD_OES_get_program_binary) return;
 
@@ -5147,6 +5303,7 @@ static void load_GL_OES_get_program_binary(LOADER load) {
 
 	fp_glProgramBinaryOES = (pfn_glProgramBinaryOES)load("glProgramBinaryOES");
 
 }
 
 
+GLboolean GLAD_OES_gpu_shader5 = GL_FALSE;
 
 GLboolean GLAD_OES_mapbuffer = GL_FALSE;
 
 static void load_GL_OES_mapbuffer(LOADER load) {
 
 	if(!GLAD_OES_mapbuffer) return;
 
@@ -5156,6 +5313,12 @@ static void load_GL_OES_mapbuffer(LOADER load) {
 
 }
 
 
 GLboolean GLAD_OES_packed_depth_stencil = GL_FALSE;
 
+GLboolean GLAD_OES_primitive_bounding_box = GL_FALSE;
 
+static void load_GL_OES_primitive_bounding_box(LOADER load) {
 
+	if(!GLAD_OES_primitive_bounding_box) return;
 
+	fp_glPrimitiveBoundingBoxOES = (pfn_glPrimitiveBoundingBoxOES)load("glPrimitiveBoundingBoxOES");
 
+}
 
+
 
 GLboolean GLAD_OES_required_internalformat = GL_FALSE;
 
 GLboolean GLAD_OES_rgb8_rgba8 = GL_FALSE;
 
 GLboolean GLAD_OES_sample_shading = GL_FALSE;
 
@@ -5166,11 +5329,19 @@ static void load_GL_OES_sample_shading(LOADER load) {
 
 
 GLboolean GLAD_OES_sample_variables = GL_FALSE;
 
 GLboolean GLAD_OES_shader_image_atomic = GL_FALSE;
 
+GLboolean GLAD_OES_shader_io_blocks = GL_FALSE;
 
 GLboolean GLAD_OES_shader_multisample_interpolation = GL_FALSE;
 
 GLboolean GLAD_OES_standard_derivatives = GL_FALSE;
 
 GLboolean GLAD_OES_stencil1 = GL_FALSE;
 
 GLboolean GLAD_OES_stencil4 = GL_FALSE;
 
 GLboolean GLAD_OES_surfaceless_context = GL_FALSE;
 
+GLboolean GLAD_OES_tessellation_point_size = GL_FALSE;
 
+GLboolean GLAD_OES_tessellation_shader = GL_FALSE;
 
+static void load_GL_OES_tessellation_shader(LOADER load) {
 
+	if(!GLAD_OES_tessellation_shader) return;
 
+	fp_glPatchParameteriOES = (pfn_glPatchParameteriOES)load("glPatchParameteriOES");
 
+}
 
+
 
 GLboolean GLAD_OES_texture_3D = GL_FALSE;
 
 static void load_GL_OES_texture_3D(LOADER load) {
 
 	if(!GLAD_OES_texture_3D) return;
 
@@ -5182,7 +5353,28 @@ static void load_GL_OES_texture_3D(LOADER load) {
 
 	fp_glFramebufferTexture3DOES = (pfn_glFramebufferTexture3DOES)load("glFramebufferTexture3DOES");
 
 }
 
 
+GLboolean GLAD_OES_texture_border_clamp = GL_FALSE;
 
+static void load_GL_OES_texture_border_clamp(LOADER load) {
 
+	if(!GLAD_OES_texture_border_clamp) return;
 
+	fp_glTexParameterIivOES = (pfn_glTexParameterIivOES)load("glTexParameterIivOES");
 
+	fp_glTexParameterIuivOES = (pfn_glTexParameterIuivOES)load("glTexParameterIuivOES");
 
+	fp_glGetTexParameterIivOES = (pfn_glGetTexParameterIivOES)load("glGetTexParameterIivOES");
 
+	fp_glGetTexParameterIuivOES = (pfn_glGetTexParameterIuivOES)load("glGetTexParameterIuivOES");
 
+	fp_glSamplerParameterIivOES = (pfn_glSamplerParameterIivOES)load("glSamplerParameterIivOES");
 
+	fp_glSamplerParameterIuivOES = (pfn_glSamplerParameterIuivOES)load("glSamplerParameterIuivOES");
 
+	fp_glGetSamplerParameterIivOES = (pfn_glGetSamplerParameterIivOES)load("glGetSamplerParameterIivOES");
 
+	fp_glGetSamplerParameterIuivOES = (pfn_glGetSamplerParameterIuivOES)load("glGetSamplerParameterIuivOES");
 
+}
 
+
 
+GLboolean GLAD_OES_texture_buffer = GL_FALSE;
 
+static void load_GL_OES_texture_buffer(LOADER load) {
 
+	if(!GLAD_OES_texture_buffer) return;
 
+	fp_glTexBufferOES = (pfn_glTexBufferOES)load("glTexBufferOES");
 
+	fp_glTexBufferRangeOES = (pfn_glTexBufferRangeOES)load("glTexBufferRangeOES");
 
+}
 
+
 
 GLboolean GLAD_OES_texture_compression_astc = GL_FALSE;
 
+GLboolean GLAD_OES_texture_cube_map_array = GL_FALSE;
 
 GLboolean GLAD_OES_texture_float = GL_FALSE;
 
 GLboolean GLAD_OES_texture_float_linear = GL_FALSE;
 
 GLboolean GLAD_OES_texture_half_float = GL_FALSE;
 
@@ -5195,6 +5387,12 @@ static void load_GL_OES_texture_storage_multisample_2d_array(LOADER load) {
 
 	fp_glTexStorage3DMultisampleOES = (pfn_glTexStorage3DMultisampleOES)load("glTexStorage3DMultisampleOES");
 
 }
 
 
+GLboolean GLAD_OES_texture_view = GL_FALSE;
 
+static void load_GL_OES_texture_view(LOADER load) {
 
+	if(!GLAD_OES_texture_view) return;
 
+	fp_glTextureViewOES = (pfn_glTextureViewOES)load("glTextureViewOES");
 
+}
 
+
 
 GLboolean GLAD_OES_vertex_array_object = GL_FALSE;
 
 static void load_GL_OES_vertex_array_object(LOADER load) {
 
 	if(!GLAD_OES_vertex_array_object) return;
 
@@ -5385,6 +5583,8 @@ static void load_GL_ANGLE_translated_shader_source(LOADER load) {
 
 
 GLboolean GLAD_APPLE_aux_depth_stencil = GL_FALSE;
 
 GLboolean GLAD_APPLE_client_storage = GL_FALSE;
 
+GLboolean GLAD_APPLE_clip_distance = GL_FALSE;
 
+GLboolean GLAD_APPLE_color_buffer_packed_float = GL_FALSE;
 
 GLboolean GLAD_APPLE_copy_texture_levels = GL_FALSE;
 
 static void load_GL_APPLE_copy_texture_levels(LOADER load) {
 
 	if(!GLAD_APPLE_copy_texture_levels) return;
 
@@ -5453,6 +5653,7 @@ static void load_GL_APPLE_sync(LOADER load) {
 
 
 GLboolean GLAD_APPLE_texture_format_BGRA8888 = GL_FALSE;
 
 GLboolean GLAD_APPLE_texture_max_level = GL_FALSE;
 
+GLboolean GLAD_APPLE_texture_packed_float = GL_FALSE;
 
 GLboolean GLAD_APPLE_texture_range = GL_FALSE;
 
 static void load_GL_APPLE_texture_range(LOADER load) {
 
 	if(!GLAD_APPLE_texture_range) return;
 
@@ -5497,6 +5698,7 @@ GLboolean GLAD_ARM_shader_framebuffer_fetch = GL_FALSE;
 
 GLboolean GLAD_ARM_shader_framebuffer_fetch_depth_stencil = GL_FALSE;
 
 GLboolean GLAD_ATI_meminfo = GL_FALSE;
 
 GLboolean GLAD_ATI_pixel_format_float = GL_FALSE;
 
+GLboolean GLAD_DMP_program_binary = GL_FALSE;
 
 GLboolean GLAD_DMP_shader_binary = GL_FALSE;
 
 GLboolean GLAD_FJ_shader_binary_GCCSO = GL_FALSE;
 
 GLboolean GLAD_GREMEDY_frame_terminator = GL_FALSE;
 
@@ -5604,6 +5806,12 @@ static void load_GL_NV_conditional_render(LOADER load) {
 
 	fp_glEndConditionalRenderNV = (pfn_glEndConditionalRenderNV)load("glEndConditionalRenderNV");
 
 }
 
 
+GLboolean GLAD_NV_conservative_raster = GL_FALSE;
 
+static void load_GL_NV_conservative_raster(LOADER load) {
 
+	if(!GLAD_NV_conservative_raster) return;
 
+	fp_glSubpixelPrecisionBiasNV = (pfn_glSubpixelPrecisionBiasNV)load("glSubpixelPrecisionBiasNV");
 
+}
 
+
 
 GLboolean GLAD_NV_copy_buffer = GL_FALSE;
 
 static void load_GL_NV_copy_buffer(LOADER load) {
 
 	if(!GLAD_NV_copy_buffer) return;
 
@@ -5675,14 +5883,31 @@ static void load_GL_NV_fence(LOADER load) {
 
 	fp_glSetFenceNV = (pfn_glSetFenceNV)load("glSetFenceNV");
 
 }
 
 
+GLboolean GLAD_NV_fill_rectangle = GL_FALSE;
 
 GLboolean GLAD_NV_float_buffer = GL_FALSE;
 
+GLboolean GLAD_NV_fragment_coverage_to_color = GL_FALSE;
 
+static void load_GL_NV_fragment_coverage_to_color(LOADER load) {
 
+	if(!GLAD_NV_fragment_coverage_to_color) return;
 
+	fp_glFragmentCoverageColorNV = (pfn_glFragmentCoverageColorNV)load("glFragmentCoverageColorNV");
 
+}
 
+
 
 GLboolean GLAD_NV_fragment_program4 = GL_FALSE;
 
+GLboolean GLAD_NV_fragment_shader_interlock = GL_FALSE;
 
 GLboolean GLAD_NV_framebuffer_blit = GL_FALSE;
 
 static void load_GL_NV_framebuffer_blit(LOADER load) {
 
 	if(!GLAD_NV_framebuffer_blit) return;
 
 	fp_glBlitFramebufferNV = (pfn_glBlitFramebufferNV)load("glBlitFramebufferNV");
 
 }
 
 
+GLboolean GLAD_NV_framebuffer_mixed_samples = GL_FALSE;
 
+static void load_GL_NV_framebuffer_mixed_samples(LOADER load) {
 
+	if(!GLAD_NV_framebuffer_mixed_samples) return;
 
+	fp_glRasterSamplesEXT = (pfn_glRasterSamplesEXT)load("glRasterSamplesEXT");
 
+	fp_glCoverageModulationTableNV = (pfn_glCoverageModulationTableNV)load("glCoverageModulationTableNV");
 
+	fp_glGetCoverageModulationTableNV = (pfn_glGetCoverageModulationTableNV)load("glGetCoverageModulationTableNV");
 
+	fp_glCoverageModulationNV = (pfn_glCoverageModulationNV)load("glCoverageModulationNV");
 
+}
 
+
 
 GLboolean GLAD_NV_framebuffer_multisample = GL_FALSE;
 
 static void load_GL_NV_framebuffer_multisample(LOADER load) {
 
 	if(!GLAD_NV_framebuffer_multisample) return;
 
@@ -5706,6 +5931,7 @@ static void load_GL_NV_geometry_program4(LOADER load) {
 
 }
 
 
 GLboolean GLAD_NV_geometry_shader4 = GL_FALSE;
 
+GLboolean GLAD_NV_geometry_shader_passthrough = GL_FALSE;
 
 GLboolean GLAD_NV_gpu_program4 = GL_FALSE;
 
 static void load_GL_NV_gpu_program4(LOADER load) {
 
 	if(!GLAD_NV_gpu_program4) return;
 
@@ -5824,12 +6050,19 @@ static void load_GL_NV_half_float(LOADER load) {
 
 	fp_glVertexAttribs4hvNV = (pfn_glVertexAttribs4hvNV)load("glVertexAttribs4hvNV");
 
 }
 
 
+GLboolean GLAD_NV_image_formats = GL_FALSE;
 
 GLboolean GLAD_NV_instanced_arrays = GL_FALSE;
 
 static void load_GL_NV_instanced_arrays(LOADER load) {
 
 	if(!GLAD_NV_instanced_arrays) return;
 
 	fp_glVertexAttribDivisorNV = (pfn_glVertexAttribDivisorNV)load("glVertexAttribDivisorNV");
 
 }
 
 
+GLboolean GLAD_NV_internalformat_sample_query = GL_FALSE;
 
+static void load_GL_NV_internalformat_sample_query(LOADER load) {
 
+	if(!GLAD_NV_internalformat_sample_query) return;
 
+	fp_glGetInternalformatSampleivNV = (pfn_glGetInternalformatSampleivNV)load("glGetInternalformatSampleivNV");
 
+}
 
+
 
 GLboolean GLAD_NV_multisample_coverage = GL_FALSE;
 
 GLboolean GLAD_NV_non_square_matrices = GL_FALSE;
 
 static void load_GL_NV_non_square_matrices(LOADER load) {
 
@@ -5892,9 +6125,6 @@ static void load_GL_NV_path_rendering(LOADER load) {
 
 	fp_glStencilFillPathInstancedNV = (pfn_glStencilFillPathInstancedNV)load("glStencilFillPathInstancedNV");
 
 	fp_glStencilStrokePathInstancedNV = (pfn_glStencilStrokePathInstancedNV)load("glStencilStrokePathInstancedNV");
 
 	fp_glPathCoverDepthFuncNV = (pfn_glPathCoverDepthFuncNV)load("glPathCoverDepthFuncNV");
 
-	fp_glPathColorGenNV = (pfn_glPathColorGenNV)load("glPathColorGenNV");
 
-	fp_glPathTexGenNV = (pfn_glPathTexGenNV)load("glPathTexGenNV");
 
-	fp_glPathFogGenNV = (pfn_glPathFogGenNV)load("glPathFogGenNV");
 
 	fp_glCoverFillPathNV = (pfn_glCoverFillPathNV)load("glCoverFillPathNV");
 
 	fp_glCoverStrokePathNV = (pfn_glCoverStrokePathNV)load("glCoverStrokePathNV");
 
 	fp_glCoverFillPathInstancedNV = (pfn_glCoverFillPathInstancedNV)load("glCoverFillPathInstancedNV");
 
@@ -5907,10 +6137,6 @@ static void load_GL_NV_path_rendering(LOADER load) {
 
 	fp_glGetPathMetricsNV = (pfn_glGetPathMetricsNV)load("glGetPathMetricsNV");
 
 	fp_glGetPathMetricRangeNV = (pfn_glGetPathMetricRangeNV)load("glGetPathMetricRangeNV");
 
 	fp_glGetPathSpacingNV = (pfn_glGetPathSpacingNV)load("glGetPathSpacingNV");
 
-	fp_glGetPathColorGenivNV = (pfn_glGetPathColorGenivNV)load("glGetPathColorGenivNV");
 
-	fp_glGetPathColorGenfvNV = (pfn_glGetPathColorGenfvNV)load("glGetPathColorGenfvNV");
 
-	fp_glGetPathTexGenivNV = (pfn_glGetPathTexGenivNV)load("glGetPathTexGenivNV");
 
-	fp_glGetPathTexGenfvNV = (pfn_glGetPathTexGenfvNV)load("glGetPathTexGenfvNV");
 
 	fp_glIsPointInFillPathNV = (pfn_glIsPointInFillPathNV)load("glIsPointInFillPathNV");
 
 	fp_glIsPointInStrokePathNV = (pfn_glIsPointInStrokePathNV)load("glIsPointInStrokePathNV");
 
 	fp_glGetPathLengthNV = (pfn_glGetPathLengthNV)load("glGetPathLengthNV");
 
@@ -5930,8 +6156,16 @@ static void load_GL_NV_path_rendering(LOADER load) {
 
 	fp_glPathMemoryGlyphIndexArrayNV = (pfn_glPathMemoryGlyphIndexArrayNV)load("glPathMemoryGlyphIndexArrayNV");
 
 	fp_glProgramPathFragmentInputGenNV = (pfn_glProgramPathFragmentInputGenNV)load("glProgramPathFragmentInputGenNV");
 
 	fp_glGetProgramResourcefvNV = (pfn_glGetProgramResourcefvNV)load("glGetProgramResourcefvNV");
 
+	fp_glPathColorGenNV = (pfn_glPathColorGenNV)load("glPathColorGenNV");
 
+	fp_glPathTexGenNV = (pfn_glPathTexGenNV)load("glPathTexGenNV");
 
+	fp_glPathFogGenNV = (pfn_glPathFogGenNV)load("glPathFogGenNV");
 
+	fp_glGetPathColorGenivNV = (pfn_glGetPathColorGenivNV)load("glGetPathColorGenivNV");
 
+	fp_glGetPathColorGenfvNV = (pfn_glGetPathColorGenfvNV)load("glGetPathColorGenfvNV");
 
+	fp_glGetPathTexGenivNV = (pfn_glGetPathTexGenivNV)load("glGetPathTexGenivNV");
 
+	fp_glGetPathTexGenfvNV = (pfn_glGetPathTexGenfvNV)load("glGetPathTexGenfvNV");
 
 }
 
 
+GLboolean GLAD_NV_path_rendering_shared_edge = GL_FALSE;
 
 GLboolean GLAD_NV_present_video = GL_FALSE;
 
 static void load_GL_NV_present_video(LOADER load) {
 
 	if(!GLAD_NV_present_video) return;
 
@@ -5960,8 +6194,18 @@ GLboolean GLAD_NV_read_buffer_front = GL_FALSE;
 
 GLboolean GLAD_NV_read_depth = GL_FALSE;
 
 GLboolean GLAD_NV_read_depth_stencil = GL_FALSE;
 
 GLboolean GLAD_NV_read_stencil = GL_FALSE;
 
+GLboolean GLAD_NV_sample_locations = GL_FALSE;
 
+static void load_GL_NV_sample_locations(LOADER load) {
 
+	if(!GLAD_NV_sample_locations) return;
 
+	fp_glFramebufferSampleLocationsfvNV = (pfn_glFramebufferSampleLocationsfvNV)load("glFramebufferSampleLocationsfvNV");
 
+	fp_glNamedFramebufferSampleLocationsfvNV = (pfn_glNamedFramebufferSampleLocationsfvNV)load("glNamedFramebufferSampleLocationsfvNV");
 
+	fp_glResolveDepthValuesNV = (pfn_glResolveDepthValuesNV)load("glResolveDepthValuesNV");
 
+}
 
+
 
+GLboolean GLAD_NV_sample_mask_override_coverage = GL_FALSE;
 
 GLboolean GLAD_NV_shader_atomic_counters = GL_FALSE;
 
 GLboolean GLAD_NV_shader_atomic_float = GL_FALSE;
 
+GLboolean GLAD_NV_shader_atomic_fp16_vector = GL_FALSE;
 
 GLboolean GLAD_NV_shader_atomic_int64 = GL_FALSE;
 
 GLboolean GLAD_NV_shader_buffer_load = GL_FALSE;
 
 static void load_GL_NV_shader_buffer_load(LOADER load) {
 
@@ -5983,6 +6227,7 @@ static void load_GL_NV_shader_buffer_load(LOADER load) {
 
 }
 
 
 GLboolean GLAD_NV_shader_buffer_store = GL_FALSE;
 
+GLboolean GLAD_NV_shader_noperspective_interpolation = GL_FALSE;
 
 GLboolean GLAD_NV_shader_storage_buffer_object = GL_FALSE;
 
 GLboolean GLAD_NV_shader_thread_group = GL_FALSE;
 
 GLboolean GLAD_NV_shader_thread_shuffle = GL_FALSE;
 
@@ -6039,6 +6284,7 @@ static void load_GL_NV_transform_feedback2(LOADER load) {
 
 	fp_glDrawTransformFeedbackNV = (pfn_glDrawTransformFeedbackNV)load("glDrawTransformFeedbackNV");
 
 }
 
 
+GLboolean GLAD_NV_uniform_buffer_unified_memory = GL_FALSE;
 
 GLboolean GLAD_NV_vdpau_interop = GL_FALSE;
 
 static void load_GL_NV_vdpau_interop(LOADER load) {
 
 	if(!GLAD_NV_vdpau_interop) return;
 
@@ -6140,6 +6386,24 @@ static void load_GL_NV_video_capture(LOADER load) {
 
 	fp_glVideoCaptureStreamParameterdvNV = (pfn_glVideoCaptureStreamParameterdvNV)load("glVideoCaptureStreamParameterdvNV");
 
 }
 
 
+GLboolean GLAD_NV_viewport_array = GL_FALSE;
 
+static void load_GL_NV_viewport_array(LOADER load) {
 
+	if(!GLAD_NV_viewport_array) return;
 
+	fp_glViewportArrayvNV = (pfn_glViewportArrayvNV)load("glViewportArrayvNV");
 
+	fp_glViewportIndexedfNV = (pfn_glViewportIndexedfNV)load("glViewportIndexedfNV");
 
+	fp_glViewportIndexedfvNV = (pfn_glViewportIndexedfvNV)load("glViewportIndexedfvNV");
 
+	fp_glScissorArrayvNV = (pfn_glScissorArrayvNV)load("glScissorArrayvNV");
 
+	fp_glScissorIndexedNV = (pfn_glScissorIndexedNV)load("glScissorIndexedNV");
 
+	fp_glScissorIndexedvNV = (pfn_glScissorIndexedvNV)load("glScissorIndexedvNV");
 
+	fp_glDepthRangeArrayfvNV = (pfn_glDepthRangeArrayfvNV)load("glDepthRangeArrayfvNV");
 
+	fp_glDepthRangeIndexedfNV = (pfn_glDepthRangeIndexedfNV)load("glDepthRangeIndexedfNV");
 
+	fp_glGetFloati_vNV = (pfn_glGetFloati_vNV)load("glGetFloati_vNV");
 
+	fp_glEnableiNV = (pfn_glEnableiNV)load("glEnableiNV");
 
+	fp_glDisableiNV = (pfn_glDisableiNV)load("glDisableiNV");
 
+	fp_glIsEnablediNV = (pfn_glIsEnablediNV)load("glIsEnablediNV");
 
+}
 
+
 
+GLboolean GLAD_NV_viewport_array2 = GL_FALSE;
 
 GLboolean GLAD_NVX_conditional_render = GL_FALSE;
 
 static void load_GL_NVX_conditional_render(LOADER load) {
 
 	if(!GLAD_NVX_conditional_render) return;
 
@@ -6335,6 +6599,7 @@ static void find_extensions(void) {
 
 	GLAD_ARB_vertex_type_10f_11f_11f_rev = has_ext("GL_ARB_vertex_type_10f_11f_11f_rev");
 
 	GLAD_ARB_vertex_type_2_10_10_10_rev = has_ext("GL_ARB_vertex_type_2_10_10_10_rev");
 
 	GLAD_ARB_viewport_array = has_ext("GL_ARB_viewport_array");
 
+	GLAD_EXT_base_instance = has_ext("GL_EXT_base_instance");
 
 	GLAD_EXT_bgra = has_ext("GL_EXT_bgra");
 
 	GLAD_EXT_bindable_uniform = has_ext("GL_EXT_bindable_uniform");
 
 	GLAD_EXT_color_buffer_half_float = has_ext("GL_EXT_color_buffer_half_float");
 
@@ -6347,6 +6612,7 @@ static void find_extensions(void) {
 
 	GLAD_EXT_draw_buffers = has_ext("GL_EXT_draw_buffers");
 
 	GLAD_EXT_draw_buffers2 = has_ext("GL_EXT_draw_buffers2");
 
 	GLAD_EXT_draw_buffers_indexed = has_ext("GL_EXT_draw_buffers_indexed");
 
+	GLAD_EXT_draw_elements_base_vertex = has_ext("GL_EXT_draw_elements_base_vertex");
 
 	GLAD_EXT_draw_instanced = has_ext("GL_EXT_draw_instanced");
 
 	GLAD_EXT_framebuffer_blit = has_ext("GL_EXT_framebuffer_blit");
 
 	GLAD_EXT_framebuffer_multisample = has_ext("GL_EXT_framebuffer_multisample");
 
@@ -6361,16 +6627,21 @@ static void find_extensions(void) {
 
 	GLAD_EXT_gpu_shader5 = has_ext("GL_EXT_gpu_shader5");
 
 	GLAD_EXT_instanced_arrays = has_ext("GL_EXT_instanced_arrays");
 
 	GLAD_EXT_map_buffer_range = has_ext("GL_EXT_map_buffer_range");
 
+	GLAD_EXT_multi_draw_indirect = has_ext("GL_EXT_multi_draw_indirect");
 
 	GLAD_EXT_multisampled_render_to_texture = has_ext("GL_EXT_multisampled_render_to_texture");
 
 	GLAD_EXT_multiview_draw_buffers = has_ext("GL_EXT_multiview_draw_buffers");
 
 	GLAD_EXT_occlusion_query_boolean = has_ext("GL_EXT_occlusion_query_boolean");
 
 	GLAD_EXT_packed_depth_stencil = has_ext("GL_EXT_packed_depth_stencil");
 
 	GLAD_EXT_packed_float = has_ext("GL_EXT_packed_float");
 
 	GLAD_EXT_pixel_buffer_object = has_ext("GL_EXT_pixel_buffer_object");
 
+	GLAD_EXT_polygon_offset_clamp = has_ext("GL_EXT_polygon_offset_clamp");
 
+	GLAD_EXT_post_depth_coverage = has_ext("GL_EXT_post_depth_coverage");
 
 	GLAD_EXT_primitive_bounding_box = has_ext("GL_EXT_primitive_bounding_box");
 
 	GLAD_EXT_provoking_vertex = has_ext("GL_EXT_provoking_vertex");
 
 	GLAD_EXT_pvrtc_sRGB = has_ext("GL_EXT_pvrtc_sRGB");
 
+	GLAD_EXT_raster_multisample = has_ext("GL_EXT_raster_multisample");
 
 	GLAD_EXT_read_format_bgra = has_ext("GL_EXT_read_format_bgra");
 
+	GLAD_EXT_render_snorm = has_ext("GL_EXT_render_snorm");
 
 	GLAD_EXT_robustness = has_ext("GL_EXT_robustness");
 
 	GLAD_EXT_separate_shader_objects = has_ext("GL_EXT_separate_shader_objects");
 
 	GLAD_EXT_shader_framebuffer_fetch = has_ext("GL_EXT_shader_framebuffer_fetch");
 
@@ -6382,6 +6653,7 @@ static void find_extensions(void) {
 
 	GLAD_EXT_shader_pixel_local_storage = has_ext("GL_EXT_shader_pixel_local_storage");
 
 	GLAD_EXT_shader_texture_lod = has_ext("GL_EXT_shader_texture_lod");
 
 	GLAD_EXT_shadow_samplers = has_ext("GL_EXT_shadow_samplers");
 
+	GLAD_EXT_sparse_texture2 = has_ext("GL_EXT_sparse_texture2");
 
 	GLAD_EXT_sRGB = has_ext("GL_EXT_sRGB");
 
 	GLAD_EXT_sRGB_write_control = has_ext("GL_EXT_sRGB_write_control");
 
 	GLAD_EXT_stencil_clear_tag = has_ext("GL_EXT_stencil_clear_tag");
 
@@ -6398,13 +6670,17 @@ static void find_extensions(void) {
 
 	GLAD_EXT_texture_cube_map = has_ext("GL_EXT_texture_cube_map");
 
 	GLAD_EXT_texture_cube_map_array = has_ext("GL_EXT_texture_cube_map_array");
 
 	GLAD_EXT_texture_filter_anisotropic = has_ext("GL_EXT_texture_filter_anisotropic");
 
+	GLAD_EXT_texture_filter_minmax = has_ext("GL_EXT_texture_filter_minmax");
 
 	GLAD_EXT_texture_format_BGRA8888 = has_ext("GL_EXT_texture_format_BGRA8888");
 
 	GLAD_EXT_texture_integer = has_ext("GL_EXT_texture_integer");
 
+	GLAD_EXT_texture_norm16 = has_ext("GL_EXT_texture_norm16");
 
 	GLAD_EXT_texture_rg = has_ext("GL_EXT_texture_rg");
 
 	GLAD_EXT_texture_shared_exponent = has_ext("GL_EXT_texture_shared_exponent");
 
 	GLAD_EXT_texture_snorm = has_ext("GL_EXT_texture_snorm");
 
 	GLAD_EXT_texture_sRGB = has_ext("GL_EXT_texture_sRGB");
 
 	GLAD_EXT_texture_sRGB_decode = has_ext("GL_EXT_texture_sRGB_decode");
 
+	GLAD_EXT_texture_sRGB_R8 = has_ext("GL_EXT_texture_sRGB_R8");
 
+	GLAD_EXT_texture_sRGB_RG8 = has_ext("GL_EXT_texture_sRGB_RG8");
 
 	GLAD_EXT_texture_storage = has_ext("GL_EXT_texture_storage");
 
 	GLAD_EXT_texture_swizzle = has_ext("GL_EXT_texture_swizzle");
 
 	GLAD_EXT_texture_type_2_10_10_10_REV = has_ext("GL_EXT_texture_type_2_10_10_10_REV");
 
@@ -6415,31 +6691,46 @@ static void find_extensions(void) {
 
 	GLAD_EXT_vertex_array_bgra = has_ext("GL_EXT_vertex_array_bgra");
 
 	GLAD_EXT_vertex_attrib_64bit = has_ext("GL_EXT_vertex_attrib_64bit");
 
 	GLAD_EXT_x11_sync_object = has_ext("GL_EXT_x11_sync_object");
 
+	GLAD_EXT_YUV_target = has_ext("GL_EXT_YUV_target");
 
 	GLAD_OES_compressed_ETC1_RGB8_sub_texture = has_ext("GL_OES_compressed_ETC1_RGB8_sub_texture");
 
 	GLAD_OES_compressed_ETC1_RGB8_texture = has_ext("GL_OES_compressed_ETC1_RGB8_texture");
 
+	GLAD_OES_copy_image = has_ext("GL_OES_copy_image");
 
 	GLAD_OES_depth24 = has_ext("GL_OES_depth24");
 
 	GLAD_OES_depth32 = has_ext("GL_OES_depth32");
 
 	GLAD_OES_depth_texture = has_ext("GL_OES_depth_texture");
 
+	GLAD_OES_draw_buffers_indexed = has_ext("GL_OES_draw_buffers_indexed");
 
+	GLAD_OES_draw_elements_base_vertex = has_ext("GL_OES_draw_elements_base_vertex");
 
 	GLAD_OES_EGL_image = has_ext("GL_OES_EGL_image");
 
 	GLAD_OES_EGL_image_external = has_ext("GL_OES_EGL_image_external");
 
+	GLAD_OES_EGL_image_external_essl3 = has_ext("GL_OES_EGL_image_external_essl3");
 
 	GLAD_OES_element_index_uint = has_ext("GL_OES_element_index_uint");
 
 	GLAD_OES_fbo_render_mipmap = has_ext("GL_OES_fbo_render_mipmap");
 
 	GLAD_OES_fragment_precision_high = has_ext("GL_OES_fragment_precision_high");
 
+	GLAD_OES_geometry_point_size = has_ext("GL_OES_geometry_point_size");
 
+	GLAD_OES_geometry_shader = has_ext("GL_OES_geometry_shader");
 
 	GLAD_OES_get_program_binary = has_ext("GL_OES_get_program_binary");
 
+	GLAD_OES_gpu_shader5 = has_ext("GL_OES_gpu_shader5");
 
 	GLAD_OES_mapbuffer = has_ext("GL_OES_mapbuffer");
 
 	GLAD_OES_packed_depth_stencil = has_ext("GL_OES_packed_depth_stencil");
 
+	GLAD_OES_primitive_bounding_box = has_ext("GL_OES_primitive_bounding_box");
 
 	GLAD_OES_required_internalformat = has_ext("GL_OES_required_internalformat");
 
 	GLAD_OES_rgb8_rgba8 = has_ext("GL_OES_rgb8_rgba8");
 
 	GLAD_OES_sample_shading = has_ext("GL_OES_sample_shading");
 
 	GLAD_OES_sample_variables = has_ext("GL_OES_sample_variables");
 
 	GLAD_OES_shader_image_atomic = has_ext("GL_OES_shader_image_atomic");
 
+	GLAD_OES_shader_io_blocks = has_ext("GL_OES_shader_io_blocks");
 
 	GLAD_OES_shader_multisample_interpolation = has_ext("GL_OES_shader_multisample_interpolation");
 
 	GLAD_OES_standard_derivatives = has_ext("GL_OES_standard_derivatives");
 
 	GLAD_OES_stencil1 = has_ext("GL_OES_stencil1");
 
 	GLAD_OES_stencil4 = has_ext("GL_OES_stencil4");
 
 	GLAD_OES_surfaceless_context = has_ext("GL_OES_surfaceless_context");
 
+	GLAD_OES_tessellation_point_size = has_ext("GL_OES_tessellation_point_size");
 
+	GLAD_OES_tessellation_shader = has_ext("GL_OES_tessellation_shader");
 
 	GLAD_OES_texture_3D = has_ext("GL_OES_texture_3D");
 
+	GLAD_OES_texture_border_clamp = has_ext("GL_OES_texture_border_clamp");
 
+	GLAD_OES_texture_buffer = has_ext("GL_OES_texture_buffer");
 
 	GLAD_OES_texture_compression_astc = has_ext("GL_OES_texture_compression_astc");
 
+	GLAD_OES_texture_cube_map_array = has_ext("GL_OES_texture_cube_map_array");
 
 	GLAD_OES_texture_float = has_ext("GL_OES_texture_float");
 
 	GLAD_OES_texture_float_linear = has_ext("GL_OES_texture_float_linear");
 
 	GLAD_OES_texture_half_float = has_ext("GL_OES_texture_half_float");
 
@@ -6447,6 +6738,7 @@ static void find_extensions(void) {
 
 	GLAD_OES_texture_npot = has_ext("GL_OES_texture_npot");
 
 	GLAD_OES_texture_stencil8 = has_ext("GL_OES_texture_stencil8");
 
 	GLAD_OES_texture_storage_multisample_2d_array = has_ext("GL_OES_texture_storage_multisample_2d_array");
 
+	GLAD_OES_texture_view = has_ext("GL_OES_texture_view");
 
 	GLAD_OES_vertex_array_object = has_ext("GL_OES_vertex_array_object");
 
 	GLAD_OES_vertex_half_float = has_ext("GL_OES_vertex_half_float");
 
 	GLAD_OES_vertex_type_10_10_10_2 = has_ext("GL_OES_vertex_type_10_10_10_2");
 
@@ -6493,6 +6785,8 @@ static void find_extensions(void) {
 
 	GLAD_ANGLE_translated_shader_source = has_ext("GL_ANGLE_translated_shader_source");
 
 	GLAD_APPLE_aux_depth_stencil = has_ext("GL_APPLE_aux_depth_stencil");
 
 	GLAD_APPLE_client_storage = has_ext("GL_APPLE_client_storage");
 
+	GLAD_APPLE_clip_distance = has_ext("GL_APPLE_clip_distance");
 
+	GLAD_APPLE_color_buffer_packed_float = has_ext("GL_APPLE_color_buffer_packed_float");
 
 	GLAD_APPLE_copy_texture_levels = has_ext("GL_APPLE_copy_texture_levels");
 
 	GLAD_APPLE_element_array = has_ext("GL_APPLE_element_array");
 
 	GLAD_APPLE_fence = has_ext("GL_APPLE_fence");
 
@@ -6505,6 +6799,7 @@ static void find_extensions(void) {
 
 	GLAD_APPLE_sync = has_ext("GL_APPLE_sync");
 
 	GLAD_APPLE_texture_format_BGRA8888 = has_ext("GL_APPLE_texture_format_BGRA8888");
 
 	GLAD_APPLE_texture_max_level = has_ext("GL_APPLE_texture_max_level");
 
+	GLAD_APPLE_texture_packed_float = has_ext("GL_APPLE_texture_packed_float");
 
 	GLAD_APPLE_texture_range = has_ext("GL_APPLE_texture_range");
 
 	GLAD_APPLE_vertex_array_object = has_ext("GL_APPLE_vertex_array_object");
 
 	GLAD_APPLE_vertex_array_range = has_ext("GL_APPLE_vertex_array_range");
 
@@ -6517,6 +6812,7 @@ static void find_extensions(void) {
 
 	GLAD_ARM_shader_framebuffer_fetch_depth_stencil = has_ext("GL_ARM_shader_framebuffer_fetch_depth_stencil");
 
 	GLAD_ATI_meminfo = has_ext("GL_ATI_meminfo");
 
 	GLAD_ATI_pixel_format_float = has_ext("GL_ATI_pixel_format_float");
 
+	GLAD_DMP_program_binary = has_ext("GL_DMP_program_binary");
 
 	GLAD_DMP_shader_binary = has_ext("GL_DMP_shader_binary");
 
 	GLAD_FJ_shader_binary_GCCSO = has_ext("GL_FJ_shader_binary_GCCSO");
 
 	GLAD_GREMEDY_frame_terminator = has_ext("GL_GREMEDY_frame_terminator");
 
@@ -6541,6 +6837,7 @@ static void find_extensions(void) {
 
 	GLAD_NV_blend_equation_advanced_coherent = has_ext("GL_NV_blend_equation_advanced_coherent");
 
 	GLAD_NV_compute_program5 = has_ext("GL_NV_compute_program5");
 
 	GLAD_NV_conditional_render = has_ext("GL_NV_conditional_render");
 
+	GLAD_NV_conservative_raster = has_ext("GL_NV_conservative_raster");
 
 	GLAD_NV_copy_buffer = has_ext("GL_NV_copy_buffer");
 
 	GLAD_NV_copy_image = has_ext("GL_NV_copy_image");
 
 	GLAD_NV_coverage_sample = has_ext("GL_NV_coverage_sample");
 
@@ -6555,26 +6852,34 @@ static void find_extensions(void) {
 
 	GLAD_NV_explicit_multisample = has_ext("GL_NV_explicit_multisample");
 
 	GLAD_NV_fbo_color_attachments = has_ext("GL_NV_fbo_color_attachments");
 
 	GLAD_NV_fence = has_ext("GL_NV_fence");
 
+	GLAD_NV_fill_rectangle = has_ext("GL_NV_fill_rectangle");
 
 	GLAD_NV_float_buffer = has_ext("GL_NV_float_buffer");
 
+	GLAD_NV_fragment_coverage_to_color = has_ext("GL_NV_fragment_coverage_to_color");
 
 	GLAD_NV_fragment_program4 = has_ext("GL_NV_fragment_program4");
 
+	GLAD_NV_fragment_shader_interlock = has_ext("GL_NV_fragment_shader_interlock");
 
 	GLAD_NV_framebuffer_blit = has_ext("GL_NV_framebuffer_blit");
 
+	GLAD_NV_framebuffer_mixed_samples = has_ext("GL_NV_framebuffer_mixed_samples");
 
 	GLAD_NV_framebuffer_multisample = has_ext("GL_NV_framebuffer_multisample");
 
 	GLAD_NV_framebuffer_multisample_coverage = has_ext("GL_NV_framebuffer_multisample_coverage");
 
 	GLAD_NV_generate_mipmap_sRGB = has_ext("GL_NV_generate_mipmap_sRGB");
 
 	GLAD_NV_geometry_program4 = has_ext("GL_NV_geometry_program4");
 
 	GLAD_NV_geometry_shader4 = has_ext("GL_NV_geometry_shader4");
 
+	GLAD_NV_geometry_shader_passthrough = has_ext("GL_NV_geometry_shader_passthrough");
 
 	GLAD_NV_gpu_program4 = has_ext("GL_NV_gpu_program4");
 
 	GLAD_NV_gpu_program5 = has_ext("GL_NV_gpu_program5");
 
 	GLAD_NV_gpu_program5_mem_extended = has_ext("GL_NV_gpu_program5_mem_extended");
 
 	GLAD_NV_gpu_shader5 = has_ext("GL_NV_gpu_shader5");
 
 	GLAD_NV_half_float = has_ext("GL_NV_half_float");
 
+	GLAD_NV_image_formats = has_ext("GL_NV_image_formats");
 
 	GLAD_NV_instanced_arrays = has_ext("GL_NV_instanced_arrays");
 
+	GLAD_NV_internalformat_sample_query = has_ext("GL_NV_internalformat_sample_query");
 
 	GLAD_NV_multisample_coverage = has_ext("GL_NV_multisample_coverage");
 
 	GLAD_NV_non_square_matrices = has_ext("GL_NV_non_square_matrices");
 
 	GLAD_NV_occlusion_query = has_ext("GL_NV_occlusion_query");
 
 	GLAD_NV_parameter_buffer_object = has_ext("GL_NV_parameter_buffer_object");
 
 	GLAD_NV_parameter_buffer_object2 = has_ext("GL_NV_parameter_buffer_object2");
 
 	GLAD_NV_path_rendering = has_ext("GL_NV_path_rendering");
 
+	GLAD_NV_path_rendering_shared_edge = has_ext("GL_NV_path_rendering_shared_edge");
 
 	GLAD_NV_present_video = has_ext("GL_NV_present_video");
 
 	GLAD_NV_primitive_restart = has_ext("GL_NV_primitive_restart");
 
 	GLAD_NV_read_buffer = has_ext("GL_NV_read_buffer");
 
@@ -6582,11 +6887,15 @@ static void find_extensions(void) {
 
 	GLAD_NV_read_depth = has_ext("GL_NV_read_depth");
 
 	GLAD_NV_read_depth_stencil = has_ext("GL_NV_read_depth_stencil");
 
 	GLAD_NV_read_stencil = has_ext("GL_NV_read_stencil");
 
+	GLAD_NV_sample_locations = has_ext("GL_NV_sample_locations");
 
+	GLAD_NV_sample_mask_override_coverage = has_ext("GL_NV_sample_mask_override_coverage");
 
 	GLAD_NV_shader_atomic_counters = has_ext("GL_NV_shader_atomic_counters");
 
 	GLAD_NV_shader_atomic_float = has_ext("GL_NV_shader_atomic_float");
 
+	GLAD_NV_shader_atomic_fp16_vector = has_ext("GL_NV_shader_atomic_fp16_vector");
 
 	GLAD_NV_shader_atomic_int64 = has_ext("GL_NV_shader_atomic_int64");
 
 	GLAD_NV_shader_buffer_load = has_ext("GL_NV_shader_buffer_load");
 
 	GLAD_NV_shader_buffer_store = has_ext("GL_NV_shader_buffer_store");
 
+	GLAD_NV_shader_noperspective_interpolation = has_ext("GL_NV_shader_noperspective_interpolation");
 
 	GLAD_NV_shader_storage_buffer_object = has_ext("GL_NV_shader_storage_buffer_object");
 
 	GLAD_NV_shader_thread_group = has_ext("GL_NV_shader_thread_group");
 
 	GLAD_NV_shader_thread_shuffle = has_ext("GL_NV_shader_thread_shuffle");
 
@@ -6601,11 +6910,14 @@ static void find_extensions(void) {
 
 	GLAD_NV_texture_npot_2D_mipmap = has_ext("GL_NV_texture_npot_2D_mipmap");
 
 	GLAD_NV_transform_feedback = has_ext("GL_NV_transform_feedback");
 
 	GLAD_NV_transform_feedback2 = has_ext("GL_NV_transform_feedback2");
 
+	GLAD_NV_uniform_buffer_unified_memory = has_ext("GL_NV_uniform_buffer_unified_memory");
 
 	GLAD_NV_vdpau_interop = has_ext("GL_NV_vdpau_interop");
 
 	GLAD_NV_vertex_attrib_integer_64bit = has_ext("GL_NV_vertex_attrib_integer_64bit");
 
 	GLAD_NV_vertex_buffer_unified_memory = has_ext("GL_NV_vertex_buffer_unified_memory");
 
 	GLAD_NV_vertex_program4 = has_ext("GL_NV_vertex_program4");
 
 	GLAD_NV_video_capture = has_ext("GL_NV_video_capture");
 
+	GLAD_NV_viewport_array = has_ext("GL_NV_viewport_array");
 
+	GLAD_NV_viewport_array2 = has_ext("GL_NV_viewport_array2");
 
 	GLAD_NVX_conditional_render = has_ext("GL_NVX_conditional_render");
 
 	GLAD_NVX_gpu_memory_info = has_ext("GL_NVX_gpu_memory_info");
 
 	GLAD_QCOM_alpha_test = has_ext("GL_QCOM_alpha_test");
 
@@ -6755,6 +7067,7 @@ bool gladLoadGLLoader(LOADER load) {
 
 	load_GL_ARB_vertex_attrib_binding(load);
 
 	load_GL_ARB_vertex_type_2_10_10_10_rev(load);
 
 	load_GL_ARB_viewport_array(load);
 
+	load_GL_EXT_base_instance(load);
 
 	load_GL_EXT_bindable_uniform(load);
 
 	load_GL_EXT_copy_image(load);
 
 	load_GL_EXT_debug_label(load);
 
@@ -6765,6 +7078,7 @@ bool gladLoadGLLoader(LOADER load) {
 
 	load_GL_EXT_draw_buffers(load);
 
 	load_GL_EXT_draw_buffers2(load);
 
 	load_GL_EXT_draw_buffers_indexed(load);
 
+	load_GL_EXT_draw_elements_base_vertex(load);
 
 	load_GL_EXT_draw_instanced(load);
 
 	load_GL_EXT_framebuffer_blit(load);
 
 	load_GL_EXT_framebuffer_multisample(load);
 
@@ -6775,11 +7089,14 @@ bool gladLoadGLLoader(LOADER load) {
 
 	load_GL_EXT_gpu_shader4(load);
 
 	load_GL_EXT_instanced_arrays(load);
 
 	load_GL_EXT_map_buffer_range(load);
 
+	load_GL_EXT_multi_draw_indirect(load);
 
 	load_GL_EXT_multisampled_render_to_texture(load);
 
 	load_GL_EXT_multiview_draw_buffers(load);
 
 	load_GL_EXT_occlusion_query_boolean(load);
 
+	load_GL_EXT_polygon_offset_clamp(load);
 
 	load_GL_EXT_primitive_bounding_box(load);
 
 	load_GL_EXT_provoking_vertex(load);
 
+	load_GL_EXT_raster_multisample(load);
 
 	load_GL_EXT_robustness(load);
 
 	load_GL_EXT_separate_shader_objects(load);
 
 	load_GL_EXT_shader_image_load_store(load);
 
@@ -6789,6 +7106,7 @@ bool gladLoadGLLoader(LOADER load) {
 
 	load_GL_EXT_texture_border_clamp(load);
 
 	load_GL_EXT_texture_buffer(load);
 
 	load_GL_EXT_texture_buffer_object(load);
 
+	load_GL_EXT_texture_filter_minmax(load);
 
 	load_GL_EXT_texture_integer(load);
 
 	load_GL_EXT_texture_storage(load);
 
 	load_GL_EXT_texture_view(load);
 
@@ -6796,12 +7114,21 @@ bool gladLoadGLLoader(LOADER load) {
 
 	load_GL_EXT_transform_feedback(load);
 
 	load_GL_EXT_vertex_attrib_64bit(load);
 
 	load_GL_EXT_x11_sync_object(load);
 
+	load_GL_OES_copy_image(load);
 
+	load_GL_OES_draw_buffers_indexed(load);
 
+	load_GL_OES_draw_elements_base_vertex(load);
 
 	load_GL_OES_EGL_image(load);
 
+	load_GL_OES_geometry_shader(load);
 
 	load_GL_OES_get_program_binary(load);
 
 	load_GL_OES_mapbuffer(load);
 
+	load_GL_OES_primitive_bounding_box(load);
 
 	load_GL_OES_sample_shading(load);
 
+	load_GL_OES_tessellation_shader(load);
 
 	load_GL_OES_texture_3D(load);
 
+	load_GL_OES_texture_border_clamp(load);
 
+	load_GL_OES_texture_buffer(load);
 
 	load_GL_OES_texture_storage_multisample_2d_array(load);
 
+	load_GL_OES_texture_view(load);
 
 	load_GL_OES_vertex_array_object(load);
 
 	load_GL_AMD_debug_output(load);
 
 	load_GL_AMD_draw_buffers_blend(load);
 
@@ -6841,6 +7168,7 @@ bool gladLoadGLLoader(LOADER load) {
 
 	load_GL_NV_bindless_texture(load);
 
 	load_GL_NV_blend_equation_advanced(load);
 
 	load_GL_NV_conditional_render(load);
 
+	load_GL_NV_conservative_raster(load);
 
 	load_GL_NV_copy_buffer(load);
 
 	load_GL_NV_copy_image(load);
 
 	load_GL_NV_coverage_sample(load);
 
@@ -6850,7 +7178,9 @@ bool gladLoadGLLoader(LOADER load) {
 
 	load_GL_NV_draw_texture(load);
 
 	load_GL_NV_explicit_multisample(load);
 
 	load_GL_NV_fence(load);
 
+	load_GL_NV_fragment_coverage_to_color(load);
 
 	load_GL_NV_framebuffer_blit(load);
 
+	load_GL_NV_framebuffer_mixed_samples(load);
 
 	load_GL_NV_framebuffer_multisample(load);
 
 	load_GL_NV_framebuffer_multisample_coverage(load);
 
 	load_GL_NV_geometry_program4(load);
 
@@ -6859,6 +7189,7 @@ bool gladLoadGLLoader(LOADER load) {
 
 	load_GL_NV_gpu_shader5(load);
 
 	load_GL_NV_half_float(load);
 
 	load_GL_NV_instanced_arrays(load);
 
+	load_GL_NV_internalformat_sample_query(load);
 
 	load_GL_NV_non_square_matrices(load);
 
 	load_GL_NV_occlusion_query(load);
 
 	load_GL_NV_parameter_buffer_object(load);
 
@@ -6866,6 +7197,7 @@ bool gladLoadGLLoader(LOADER load) {
 
 	load_GL_NV_present_video(load);
 
 	load_GL_NV_primitive_restart(load);
 
 	load_GL_NV_read_buffer(load);
 
+	load_GL_NV_sample_locations(load);
 
 	load_GL_NV_shader_buffer_load(load);
 
 	load_GL_NV_texture_barrier(load);
 
 	load_GL_NV_texture_multisample(load);
 
@@ -6876,6 +7208,7 @@ bool gladLoadGLLoader(LOADER load) {
 
 	load_GL_NV_vertex_buffer_unified_memory(load);
 
 	load_GL_NV_vertex_program4(load);
 
 	load_GL_NV_video_capture(load);
 
+	load_GL_NV_viewport_array(load);
 
 	load_GL_NVX_conditional_render(load);
 
 	load_GL_QCOM_alpha_test(load);
 
 	load_GL_QCOM_driver_control(load);

+ 489 - 45
src/libraries/glad/glad.hpp
View File 

@@ -2,7 +2,7 @@
 
 /**
 
  * The MIT License (MIT)
 
  * 
- * Copyright (c) 2013 David Herberth, modified by Alex Szpakowski and Bart van Strien
 
+ * Copyright (c) 2013 David Herberth, modified by Alex Szpakowski
 
  * 
  * Permission is hereby granted, free of charge, to any person obtaining a copy of
 
  * this software and associated documentation files (the "Software"), to deal in
 
@@ -37,6 +37,7 @@
 
 #ifndef WIN32_LEAN_AND_MEAN
 
 #define WIN32_LEAN_AND_MEAN 1
 
 #endif
 
+
 
 #include <windows.h>
 
 
 #ifdef near
 
@@ -59,10 +60,9 @@
 
 #define GLAPI extern
 
 #endif
 
 
-// Change by Bart van Strien
 
-// Move stddef.h outside of the namespace to prevent importing all types into
 
-// that namespace, breaking compilation further on.
 
+/* Moved here from inside the namespace to prevent some compilation issues. */
 
 #include <stddef.h>
 
+
 
 namespace glad {
 
 
 bool gladLoadGL(void);
 
@@ -3257,6 +3257,10 @@ extern pfn_glGetDoublei_v fp_glGetDoublei_v;
 
 
  /* GL_VERSION_4_2 */
 
 extern GLboolean GLAD_VERSION_4_2;
 
+#define GL_COPY_READ_BUFFER_BINDING            0x8F36
 
+#define GL_COPY_WRITE_BUFFER_BINDING           0x8F37
 
+#define GL_TRANSFORM_FEEDBACK_ACTIVE           0x8E24
 
+#define GL_TRANSFORM_FEEDBACK_PAUSED           0x8E23
 
 #define GL_UNPACK_COMPRESSED_BLOCK_WIDTH       0x9127
 
 #define GL_UNPACK_COMPRESSED_BLOCK_HEIGHT      0x9128
 
 #define GL_UNPACK_COMPRESSED_BLOCK_DEPTH       0x9129
 
@@ -3793,7 +3797,6 @@ extern GLboolean GLAD_VERSION_4_5;
 
 #define GL_MAX_COMBINED_CLIP_AND_CULL_DISTANCES  0x82FA
 
 #define GL_TEXTURE_TARGET                      0x1006
 
 #define GL_QUERY_TARGET                        0x82EA
 
-#define GL_TEXTURE_BINDING                     0x82EB
 
 #define GL_GUILTY_CONTEXT_RESET                0x8253
 
 #define GL_INNOCENT_CONTEXT_RESET              0x8254
 
 #define GL_UNKNOWN_CONTEXT_RESET               0x8255
 
@@ -3809,7 +3812,7 @@ typedef void (APIENTRYP pfn_glCreateTransformFeedbacks) (GLsizei, GLuint*);
 
 extern pfn_glCreateTransformFeedbacks fp_glCreateTransformFeedbacks;
 
 typedef void (APIENTRYP pfn_glTransformFeedbackBufferBase) (GLuint, GLuint, GLuint);
 
 extern pfn_glTransformFeedbackBufferBase fp_glTransformFeedbackBufferBase;
 
-typedef void (APIENTRYP pfn_glTransformFeedbackBufferRange) (GLuint, GLuint, GLuint, GLintptr, GLsizei);
 
+typedef void (APIENTRYP pfn_glTransformFeedbackBufferRange) (GLuint, GLuint, GLuint, GLintptr, GLsizeiptr);
 
 extern pfn_glTransformFeedbackBufferRange fp_glTransformFeedbackBufferRange;
 
 typedef void (APIENTRYP pfn_glGetTransformFeedbackiv) (GLuint, GLenum, GLint*);
 
 extern pfn_glGetTransformFeedbackiv fp_glGetTransformFeedbackiv;
 
@@ -3819,25 +3822,25 @@ typedef void (APIENTRYP pfn_glGetTransformFeedbacki64_v) (GLuint, GLenum, GLuint
 
 extern pfn_glGetTransformFeedbacki64_v fp_glGetTransformFeedbacki64_v;
 
 typedef void (APIENTRYP pfn_glCreateBuffers) (GLsizei, GLuint*);
 
 extern pfn_glCreateBuffers fp_glCreateBuffers;
 
-typedef void (APIENTRYP pfn_glNamedBufferStorage) (GLuint, GLsizei, const void*, GLbitfield);
 
+typedef void (APIENTRYP pfn_glNamedBufferStorage) (GLuint, GLsizeiptr, const void*, GLbitfield);
 
 extern pfn_glNamedBufferStorage fp_glNamedBufferStorage;
 
-typedef void (APIENTRYP pfn_glNamedBufferData) (GLuint, GLsizei, const void*, GLenum);
 
+typedef void (APIENTRYP pfn_glNamedBufferData) (GLuint, GLsizeiptr, const void*, GLenum);
 
 extern pfn_glNamedBufferData fp_glNamedBufferData;
 
-typedef void (APIENTRYP pfn_glNamedBufferSubData) (GLuint, GLintptr, GLsizei, const void*);
 
+typedef void (APIENTRYP pfn_glNamedBufferSubData) (GLuint, GLintptr, GLsizeiptr, const void*);
 
 extern pfn_glNamedBufferSubData fp_glNamedBufferSubData;
 
-typedef void (APIENTRYP pfn_glCopyNamedBufferSubData) (GLuint, GLuint, GLintptr, GLintptr, GLsizei);
 
+typedef void (APIENTRYP pfn_glCopyNamedBufferSubData) (GLuint, GLuint, GLintptr, GLintptr, GLsizeiptr);
 
 extern pfn_glCopyNamedBufferSubData fp_glCopyNamedBufferSubData;
 
 typedef void (APIENTRYP pfn_glClearNamedBufferData) (GLuint, GLenum, GLenum, GLenum, const void*);
 
 extern pfn_glClearNamedBufferData fp_glClearNamedBufferData;
 
-typedef void (APIENTRYP pfn_glClearNamedBufferSubData) (GLuint, GLenum, GLintptr, GLsizei, GLenum, GLenum, const void*);
 
+typedef void (APIENTRYP pfn_glClearNamedBufferSubData) (GLuint, GLenum, GLintptr, GLsizeiptr, GLenum, GLenum, const void*);
 
 extern pfn_glClearNamedBufferSubData fp_glClearNamedBufferSubData;
 
 typedef void* (APIENTRYP pfn_glMapNamedBuffer) (GLuint, GLenum);
 
 extern pfn_glMapNamedBuffer fp_glMapNamedBuffer;
 
-typedef void* (APIENTRYP pfn_glMapNamedBufferRange) (GLuint, GLintptr, GLsizei, GLbitfield);
 
+typedef void* (APIENTRYP pfn_glMapNamedBufferRange) (GLuint, GLintptr, GLsizeiptr, GLbitfield);
 
 extern pfn_glMapNamedBufferRange fp_glMapNamedBufferRange;
 
 typedef GLboolean (APIENTRYP pfn_glUnmapNamedBuffer) (GLuint);
 
 extern pfn_glUnmapNamedBuffer fp_glUnmapNamedBuffer;
 
-typedef void (APIENTRYP pfn_glFlushMappedNamedBufferRange) (GLuint, GLintptr, GLsizei);
 
+typedef void (APIENTRYP pfn_glFlushMappedNamedBufferRange) (GLuint, GLintptr, GLsizeiptr);
 
 extern pfn_glFlushMappedNamedBufferRange fp_glFlushMappedNamedBufferRange;
 
 typedef void (APIENTRYP pfn_glGetNamedBufferParameteriv) (GLuint, GLenum, GLint*);
 
 extern pfn_glGetNamedBufferParameteriv fp_glGetNamedBufferParameteriv;
 
@@ -3845,7 +3848,7 @@ typedef void (APIENTRYP pfn_glGetNamedBufferParameteri64v) (GLuint, GLenum, GLin
 
 extern pfn_glGetNamedBufferParameteri64v fp_glGetNamedBufferParameteri64v;
 
 typedef void (APIENTRYP pfn_glGetNamedBufferPointerv) (GLuint, GLenum, void**);
 
 extern pfn_glGetNamedBufferPointerv fp_glGetNamedBufferPointerv;
 
-typedef void (APIENTRYP pfn_glGetNamedBufferSubData) (GLuint, GLintptr, GLsizei, void*);
 
+typedef void (APIENTRYP pfn_glGetNamedBufferSubData) (GLuint, GLintptr, GLsizeiptr, void*);
 
 extern pfn_glGetNamedBufferSubData fp_glGetNamedBufferSubData;
 
 typedef void (APIENTRYP pfn_glCreateFramebuffers) (GLsizei, GLuint*);
 
 extern pfn_glCreateFramebuffers fp_glCreateFramebuffers;
 
@@ -3895,7 +3898,7 @@ typedef void (APIENTRYP pfn_glCreateTextures) (GLenum, GLsizei, GLuint*);
 
 extern pfn_glCreateTextures fp_glCreateTextures;
 
 typedef void (APIENTRYP pfn_glTextureBuffer) (GLuint, GLenum, GLuint);
 
 extern pfn_glTextureBuffer fp_glTextureBuffer;
 
-typedef void (APIENTRYP pfn_glTextureBufferRange) (GLuint, GLenum, GLuint, GLintptr, GLsizei);
 
+typedef void (APIENTRYP pfn_glTextureBufferRange) (GLuint, GLenum, GLuint, GLintptr, GLsizeiptr);
 
 extern pfn_glTextureBufferRange fp_glTextureBufferRange;
 
 typedef void (APIENTRYP pfn_glTextureStorage1D) (GLuint, GLsizei, GLenum, GLsizei);
 
 extern pfn_glTextureStorage1D fp_glTextureStorage1D;
 
@@ -3991,6 +3994,14 @@ typedef void (APIENTRYP pfn_glCreateProgramPipelines) (GLsizei, GLuint*);
 
 extern pfn_glCreateProgramPipelines fp_glCreateProgramPipelines;
 
 typedef void (APIENTRYP pfn_glCreateQueries) (GLenum, GLsizei, GLuint*);
 
 extern pfn_glCreateQueries fp_glCreateQueries;
 
+typedef void (APIENTRYP pfn_glGetQueryBufferObjecti64v) (GLuint, GLuint, GLenum, GLintptr);
 
+extern pfn_glGetQueryBufferObjecti64v fp_glGetQueryBufferObjecti64v;
 
+typedef void (APIENTRYP pfn_glGetQueryBufferObjectiv) (GLuint, GLuint, GLenum, GLintptr);
 
+extern pfn_glGetQueryBufferObjectiv fp_glGetQueryBufferObjectiv;
 
+typedef void (APIENTRYP pfn_glGetQueryBufferObjectui64v) (GLuint, GLuint, GLenum, GLintptr);
 
+extern pfn_glGetQueryBufferObjectui64v fp_glGetQueryBufferObjectui64v;
 
+typedef void (APIENTRYP pfn_glGetQueryBufferObjectuiv) (GLuint, GLuint, GLenum, GLintptr);
 
+extern pfn_glGetQueryBufferObjectuiv fp_glGetQueryBufferObjectuiv;
 
 typedef void (APIENTRYP pfn_glMemoryBarrierByRegion) (GLbitfield);
 
 extern pfn_glMemoryBarrierByRegion fp_glMemoryBarrierByRegion;
 
 typedef void (APIENTRYP pfn_glGetTextureSubImage) (GLuint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, GLsizei, void*);
 
@@ -4048,10 +4059,6 @@ extern GLboolean GLAD_ES_VERSION_2_0;
 
 
  /* GL_ES_VERSION_3_0 */
 
 extern GLboolean GLAD_ES_VERSION_3_0;
 
-#define GL_COPY_READ_BUFFER_BINDING            0x8F36
 
-#define GL_COPY_WRITE_BUFFER_BINDING           0x8F37
 
-#define GL_TRANSFORM_FEEDBACK_PAUSED           0x8E23
 
-#define GL_TRANSFORM_FEEDBACK_ACTIVE           0x8E24
 
 
  /* GL_ES_VERSION_3_1 */
 
 extern GLboolean GLAD_ES_VERSION_3_1;
 
@@ -4114,6 +4121,7 @@ extern GLboolean GLAD_KHR_debug;
 
 #define GL_PROGRAM_KHR                         0x82E2
 
 #define GL_VERTEX_ARRAY_KHR                    0x8074
 
 #define GL_QUERY_KHR                           0x82E3
 
+#define GL_PROGRAM_PIPELINE_KHR                0x82E4
 
 #define GL_SAMPLER_KHR                         0x82E6
 
 #define GL_MAX_LABEL_LENGTH_KHR                0x82E8
 
 #define GL_MAX_DEBUG_MESSAGE_LENGTH_KHR        0x9143
 
@@ -4673,18 +4681,18 @@ extern GLboolean GLAD_ARB_shading_language_packing;
 
 extern GLboolean GLAD_ARB_sparse_buffer;
 
 #define GL_SPARSE_STORAGE_BIT_ARB              0x0400
 
 #define GL_SPARSE_BUFFER_PAGE_SIZE_ARB         0x82F8
 
-typedef void (APIENTRYP pfn_glBufferPageCommitmentARB) (GLenum, GLintptr, GLsizei, GLboolean);
 
+typedef void (APIENTRYP pfn_glBufferPageCommitmentARB) (GLenum, GLintptr, GLsizeiptr, GLboolean);
 
 extern pfn_glBufferPageCommitmentARB fp_glBufferPageCommitmentARB;
 
-typedef void (APIENTRYP pfn_glNamedBufferPageCommitmentEXT) (GLuint, GLintptr, GLsizei, GLboolean);
 
+typedef void (APIENTRYP pfn_glNamedBufferPageCommitmentEXT) (GLuint, GLintptr, GLsizeiptr, GLboolean);
 
 extern pfn_glNamedBufferPageCommitmentEXT fp_glNamedBufferPageCommitmentEXT;
 
-typedef void (APIENTRYP pfn_glNamedBufferPageCommitmentARB) (GLuint, GLintptr, GLsizei, GLboolean);
 
+typedef void (APIENTRYP pfn_glNamedBufferPageCommitmentARB) (GLuint, GLintptr, GLsizeiptr, GLboolean);
 
 extern pfn_glNamedBufferPageCommitmentARB fp_glNamedBufferPageCommitmentARB;
 
 
  /* GL_ARB_sparse_texture */
 
 extern GLboolean GLAD_ARB_sparse_texture;
 
 #define GL_TEXTURE_SPARSE_ARB                  0x91A6
 
 #define GL_VIRTUAL_PAGE_SIZE_INDEX_ARB         0x91A7
 
-#define GL_MIN_SPARSE_LEVEL_ARB                0x919B
 
+#define GL_NUM_SPARSE_LEVELS_ARB               0x91AA
 
 #define GL_NUM_VIRTUAL_PAGE_SIZES_ARB          0x91A8
 
 #define GL_VIRTUAL_PAGE_SIZE_X_ARB             0x9195
 
 #define GL_VIRTUAL_PAGE_SIZE_Y_ARB             0x9196
 
@@ -4854,6 +4862,15 @@ extern GLboolean GLAD_ARB_vertex_type_2_10_10_10_rev;
 
  /* GL_ARB_viewport_array */
 
 extern GLboolean GLAD_ARB_viewport_array;
 
 
+ /* GL_EXT_base_instance */
 
+extern GLboolean GLAD_EXT_base_instance;
 
+typedef void (APIENTRYP pfn_glDrawArraysInstancedBaseInstanceEXT) (GLenum, GLint, GLsizei, GLsizei, GLuint);
 
+extern pfn_glDrawArraysInstancedBaseInstanceEXT fp_glDrawArraysInstancedBaseInstanceEXT;
 
+typedef void (APIENTRYP pfn_glDrawElementsInstancedBaseInstanceEXT) (GLenum, GLsizei, GLenum, const void*, GLsizei, GLuint);
 
+extern pfn_glDrawElementsInstancedBaseInstanceEXT fp_glDrawElementsInstancedBaseInstanceEXT;
 
+typedef void (APIENTRYP pfn_glDrawElementsInstancedBaseVertexBaseInstanceEXT) (GLenum, GLsizei, GLenum, const void*, GLsizei, GLint, GLuint);
 
+extern pfn_glDrawElementsInstancedBaseVertexBaseInstanceEXT fp_glDrawElementsInstancedBaseVertexBaseInstanceEXT;
 
+
 
  /* GL_EXT_bgra */
 
 extern GLboolean GLAD_EXT_bgra;
 
 #define GL_BGR_EXT                             0x80E0
 
@@ -5529,6 +5546,17 @@ extern pfn_glColorMaskiEXT fp_glColorMaskiEXT;
 
 typedef GLboolean (APIENTRYP pfn_glIsEnablediEXT) (GLenum, GLuint);
 
 extern pfn_glIsEnablediEXT fp_glIsEnablediEXT;
 
 
+ /* GL_EXT_draw_elements_base_vertex */
 
+extern GLboolean GLAD_EXT_draw_elements_base_vertex;
 
+typedef void (APIENTRYP pfn_glDrawElementsBaseVertexEXT) (GLenum, GLsizei, GLenum, const void*, GLint);
 
+extern pfn_glDrawElementsBaseVertexEXT fp_glDrawElementsBaseVertexEXT;
 
+typedef void (APIENTRYP pfn_glDrawRangeElementsBaseVertexEXT) (GLenum, GLuint, GLuint, GLsizei, GLenum, const void*, GLint);
 
+extern pfn_glDrawRangeElementsBaseVertexEXT fp_glDrawRangeElementsBaseVertexEXT;
 
+typedef void (APIENTRYP pfn_glDrawElementsInstancedBaseVertexEXT) (GLenum, GLsizei, GLenum, const void*, GLsizei, GLint);
 
+extern pfn_glDrawElementsInstancedBaseVertexEXT fp_glDrawElementsInstancedBaseVertexEXT;
 
+typedef void (APIENTRYP pfn_glMultiDrawElementsBaseVertexEXT) (GLenum, const GLsizei*, GLenum, const void**, GLsizei, const GLint*);
 
+extern pfn_glMultiDrawElementsBaseVertexEXT fp_glMultiDrawElementsBaseVertexEXT;
 
+
 
  /* GL_EXT_draw_instanced */
 
 extern GLboolean GLAD_EXT_draw_instanced;
 
 typedef void (APIENTRYP pfn_glDrawArraysInstancedEXT) (GLenum, GLint, GLsizei, GLsizei);
 
@@ -5771,6 +5799,13 @@ extern pfn_glMapBufferRangeEXT fp_glMapBufferRangeEXT;
 
 typedef void (APIENTRYP pfn_glFlushMappedBufferRangeEXT) (GLenum, GLintptr, GLsizeiptr);
 
 extern pfn_glFlushMappedBufferRangeEXT fp_glFlushMappedBufferRangeEXT;
 
 
+ /* GL_EXT_multi_draw_indirect */
 
+extern GLboolean GLAD_EXT_multi_draw_indirect;
 
+typedef void (APIENTRYP pfn_glMultiDrawArraysIndirectEXT) (GLenum, const void*, GLsizei, GLsizei);
 
+extern pfn_glMultiDrawArraysIndirectEXT fp_glMultiDrawArraysIndirectEXT;
 
+typedef void (APIENTRYP pfn_glMultiDrawElementsIndirectEXT) (GLenum, GLenum, const void*, GLsizei, GLsizei);
 
+extern pfn_glMultiDrawElementsIndirectEXT fp_glMultiDrawElementsIndirectEXT;
 
+
 
  /* GL_EXT_multisampled_render_to_texture */
 
 extern GLboolean GLAD_EXT_multisampled_render_to_texture;
 
 #define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_SAMPLES_EXT  0x8D6C
 
@@ -5816,6 +5851,15 @@ extern GLboolean GLAD_EXT_pixel_buffer_object;
 
 #define GL_PIXEL_PACK_BUFFER_BINDING_EXT       0x88ED
 
 #define GL_PIXEL_UNPACK_BUFFER_BINDING_EXT     0x88EF
 
 
+ /* GL_EXT_polygon_offset_clamp */
 
+extern GLboolean GLAD_EXT_polygon_offset_clamp;
 
+#define GL_POLYGON_OFFSET_CLAMP_EXT            0x8E1B
 
+typedef void (APIENTRYP pfn_glPolygonOffsetClampEXT) (GLfloat, GLfloat, GLfloat);
 
+extern pfn_glPolygonOffsetClampEXT fp_glPolygonOffsetClampEXT;
 
+
 
+ /* GL_EXT_post_depth_coverage */
 
+extern GLboolean GLAD_EXT_post_depth_coverage;
 
+
 
  /* GL_EXT_primitive_bounding_box */
 
 extern GLboolean GLAD_EXT_primitive_bounding_box;
 
 #define GL_PRIMITIVE_BOUNDING_BOX_EXT          0x92BE
 
@@ -5838,11 +5882,28 @@ extern GLboolean GLAD_EXT_pvrtc_sRGB;
 
 #define GL_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV2_IMG  0x93F0
 
 #define GL_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV2_IMG  0x93F1
 
 
+ /* GL_EXT_raster_multisample */
 
+extern GLboolean GLAD_EXT_raster_multisample;
 
+#define GL_RASTER_MULTISAMPLE_EXT              0x9327
 
+#define GL_RASTER_SAMPLES_EXT                  0x9328
 
+#define GL_MAX_RASTER_SAMPLES_EXT              0x9329
 
+#define GL_RASTER_FIXED_SAMPLE_LOCATIONS_EXT   0x932A
 
+#define GL_MULTISAMPLE_RASTERIZATION_ALLOWED_EXT  0x932B
 
+#define GL_EFFECTIVE_RASTER_SAMPLES_EXT        0x932C
 
+typedef void (APIENTRYP pfn_glRasterSamplesEXT) (GLuint, GLboolean);
 
+extern pfn_glRasterSamplesEXT fp_glRasterSamplesEXT;
 
+
 
  /* GL_EXT_read_format_bgra */
 
 extern GLboolean GLAD_EXT_read_format_bgra;
 
 #define GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT      0x8365
 
 #define GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT      0x8366
 
 
+ /* GL_EXT_render_snorm */
 
+extern GLboolean GLAD_EXT_render_snorm;
 
+#define GL_R16_SNORM_EXT                       0x8F98
 
+#define GL_RG16_SNORM_EXT                      0x8F99
 
+#define GL_RGBA16_SNORM_EXT                    0x8F9B
 
+
 
  /* GL_EXT_robustness */
 
 extern GLboolean GLAD_EXT_robustness;
 
 #define GL_GUILTY_CONTEXT_RESET_EXT            0x8253
 
@@ -5990,6 +6051,9 @@ extern GLboolean GLAD_EXT_shadow_samplers;
 
 #define GL_COMPARE_REF_TO_TEXTURE_EXT          0x884E
 
 #define GL_SAMPLER_2D_SHADOW_EXT               0x8B62
 
 
+ /* GL_EXT_sparse_texture2 */
 
+extern GLboolean GLAD_EXT_sparse_texture2;
 
+
 
  /* GL_EXT_sRGB */
 
 extern GLboolean GLAD_EXT_sRGB;
 
 #define GL_SRGB_EXT                            0x8C40
 
@@ -6163,6 +6227,9 @@ extern GLboolean GLAD_EXT_texture_filter_anisotropic;
 
 #define GL_TEXTURE_MAX_ANISOTROPY_EXT          0x84FE
 
 #define GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT      0x84FF
 
 
+ /* GL_EXT_texture_filter_minmax */
 
+extern GLboolean GLAD_EXT_texture_filter_minmax;
 
+
 
  /* GL_EXT_texture_format_BGRA8888 */
 
 extern GLboolean GLAD_EXT_texture_format_BGRA8888;
 
 
@@ -6220,6 +6287,14 @@ extern pfn_glClearColorIiEXT fp_glClearColorIiEXT;
 
 typedef void (APIENTRYP pfn_glClearColorIuiEXT) (GLuint, GLuint, GLuint, GLuint);
 
 extern pfn_glClearColorIuiEXT fp_glClearColorIuiEXT;
 
 
+ /* GL_EXT_texture_norm16 */
 
+extern GLboolean GLAD_EXT_texture_norm16;
 
+#define GL_R16_EXT                             0x822A
 
+#define GL_RG16_EXT                            0x822C
 
+#define GL_RGBA16_EXT                          0x805B
 
+#define GL_RGB16_EXT                           0x8054
 
+#define GL_RGB16_SNORM_EXT                     0x8F9A
 
+
 
  /* GL_EXT_texture_rg */
 
 extern GLboolean GLAD_EXT_texture_rg;
 
 #define GL_RED_EXT                             0x1903
 
@@ -6274,6 +6349,14 @@ extern GLboolean GLAD_EXT_texture_sRGB_decode;
 
 #define GL_DECODE_EXT                          0x8A49
 
 #define GL_SKIP_DECODE_EXT                     0x8A4A
 
 
+ /* GL_EXT_texture_sRGB_R8 */
 
+extern GLboolean GLAD_EXT_texture_sRGB_R8;
 
+#define GL_SR8_EXT                             0x8FBD
 
+
 
+ /* GL_EXT_texture_sRGB_RG8 */
 
+extern GLboolean GLAD_EXT_texture_sRGB_RG8;
 
+#define GL_SRG8_EXT                            0x8FBE
 
+
 
  /* GL_EXT_texture_storage */
 
 extern GLboolean GLAD_EXT_texture_storage;
 
 #define GL_TEXTURE_IMMUTABLE_FORMAT_EXT        0x912F
 
@@ -6405,6 +6488,13 @@ extern GLboolean GLAD_EXT_x11_sync_object;
 
 typedef GLsync (APIENTRYP pfn_glImportSyncEXT) (GLenum, GLintptr, GLbitfield);
 
 extern pfn_glImportSyncEXT fp_glImportSyncEXT;
 
 
+ /* GL_EXT_YUV_target */
 
+extern GLboolean GLAD_EXT_YUV_target;
 
+#define GL_SAMPLER_EXTERNAL_2D_Y2Y_EXT         0x8BE7
 
+#define GL_TEXTURE_EXTERNAL_OES                0x8D65
 
+#define GL_TEXTURE_BINDING_EXTERNAL_OES        0x8D67
 
+#define GL_REQUIRED_TEXTURE_IMAGE_UNITS_OES    0x8D68
 
+
 
  /* GL_OES_compressed_ETC1_RGB8_sub_texture */
 
 extern GLboolean GLAD_OES_compressed_ETC1_RGB8_sub_texture;
 
 
@@ -6412,6 +6502,11 @@ extern GLboolean GLAD_OES_compressed_ETC1_RGB8_sub_texture;
 
 extern GLboolean GLAD_OES_compressed_ETC1_RGB8_texture;
 
 #define GL_ETC1_RGB8_OES                       0x8D64
 
 
+ /* GL_OES_copy_image */
 
+extern GLboolean GLAD_OES_copy_image;
 
+typedef void (APIENTRYP pfn_glCopyImageSubDataOES) (GLuint, GLenum, GLint, GLint, GLint, GLint, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei);
 
+extern pfn_glCopyImageSubDataOES fp_glCopyImageSubDataOES;
 
+
 
  /* GL_OES_depth24 */
 
 extern GLboolean GLAD_OES_depth24;
 
 #define GL_DEPTH_COMPONENT24_OES               0x81A6
 
@@ -6423,6 +6518,36 @@ extern GLboolean GLAD_OES_depth32;
 
  /* GL_OES_depth_texture */
 
 extern GLboolean GLAD_OES_depth_texture;
 
 
+ /* GL_OES_draw_buffers_indexed */
 
+extern GLboolean GLAD_OES_draw_buffers_indexed;
 
+typedef void (APIENTRYP pfn_glEnableiOES) (GLenum, GLuint);
 
+extern pfn_glEnableiOES fp_glEnableiOES;
 
+typedef void (APIENTRYP pfn_glDisableiOES) (GLenum, GLuint);
 
+extern pfn_glDisableiOES fp_glDisableiOES;
 
+typedef void (APIENTRYP pfn_glBlendEquationiOES) (GLuint, GLenum);
 
+extern pfn_glBlendEquationiOES fp_glBlendEquationiOES;
 
+typedef void (APIENTRYP pfn_glBlendEquationSeparateiOES) (GLuint, GLenum, GLenum);
 
+extern pfn_glBlendEquationSeparateiOES fp_glBlendEquationSeparateiOES;
 
+typedef void (APIENTRYP pfn_glBlendFunciOES) (GLuint, GLenum, GLenum);
 
+extern pfn_glBlendFunciOES fp_glBlendFunciOES;
 
+typedef void (APIENTRYP pfn_glBlendFuncSeparateiOES) (GLuint, GLenum, GLenum, GLenum, GLenum);
 
+extern pfn_glBlendFuncSeparateiOES fp_glBlendFuncSeparateiOES;
 
+typedef void (APIENTRYP pfn_glColorMaskiOES) (GLuint, GLboolean, GLboolean, GLboolean, GLboolean);
 
+extern pfn_glColorMaskiOES fp_glColorMaskiOES;
 
+typedef GLboolean (APIENTRYP pfn_glIsEnablediOES) (GLenum, GLuint);
 
+extern pfn_glIsEnablediOES fp_glIsEnablediOES;
 
+
 
+ /* GL_OES_draw_elements_base_vertex */
 
+extern GLboolean GLAD_OES_draw_elements_base_vertex;
 
+typedef void (APIENTRYP pfn_glDrawElementsBaseVertexOES) (GLenum, GLsizei, GLenum, const void*, GLint);
 
+extern pfn_glDrawElementsBaseVertexOES fp_glDrawElementsBaseVertexOES;
 
+typedef void (APIENTRYP pfn_glDrawRangeElementsBaseVertexOES) (GLenum, GLuint, GLuint, GLsizei, GLenum, const void*, GLint);
 
+extern pfn_glDrawRangeElementsBaseVertexOES fp_glDrawRangeElementsBaseVertexOES;
 
+typedef void (APIENTRYP pfn_glDrawElementsInstancedBaseVertexOES) (GLenum, GLsizei, GLenum, const void*, GLsizei, GLint);
 
+extern pfn_glDrawElementsInstancedBaseVertexOES fp_glDrawElementsInstancedBaseVertexOES;
 
+typedef void (APIENTRYP pfn_glMultiDrawElementsBaseVertexOES) (GLenum, const GLsizei*, GLenum, const void**, GLsizei, const GLint*);
 
+extern pfn_glMultiDrawElementsBaseVertexOES fp_glMultiDrawElementsBaseVertexOES;
 
+
 
  /* GL_OES_EGL_image */
 
 extern GLboolean GLAD_OES_EGL_image;
 
 typedef void (APIENTRYP pfn_glEGLImageTargetTexture2DOES) (GLenum, GLeglImageOES);
 
@@ -6432,11 +6557,11 @@ extern pfn_glEGLImageTargetRenderbufferStorageOES fp_glEGLImageTargetRenderbuffe
 
 
  /* GL_OES_EGL_image_external */
 
 extern GLboolean GLAD_OES_EGL_image_external;
 
-#define GL_TEXTURE_EXTERNAL_OES                0x8D65
 
-#define GL_TEXTURE_BINDING_EXTERNAL_OES        0x8D67
 
-#define GL_REQUIRED_TEXTURE_IMAGE_UNITS_OES    0x8D68
 
 #define GL_SAMPLER_EXTERNAL_OES                0x8D66
 
 
+ /* GL_OES_EGL_image_external_essl3 */
 
+extern GLboolean GLAD_OES_EGL_image_external_essl3;
 
+
 
  /* GL_OES_element_index_uint */
 
 extern GLboolean GLAD_OES_element_index_uint;
 
 
@@ -6446,6 +6571,47 @@ extern GLboolean GLAD_OES_fbo_render_mipmap;
 
  /* GL_OES_fragment_precision_high */
 
 extern GLboolean GLAD_OES_fragment_precision_high;
 
 
+ /* GL_OES_geometry_point_size */
 
+extern GLboolean GLAD_OES_geometry_point_size;
 
+
 
+ /* GL_OES_geometry_shader */
 
+extern GLboolean GLAD_OES_geometry_shader;
 
+#define GL_GEOMETRY_SHADER_OES                 0x8DD9
 
+#define GL_GEOMETRY_SHADER_BIT_OES             0x00000004
 
+#define GL_GEOMETRY_LINKED_VERTICES_OUT_OES    0x8916
 
+#define GL_GEOMETRY_LINKED_INPUT_TYPE_OES      0x8917
 
+#define GL_GEOMETRY_LINKED_OUTPUT_TYPE_OES     0x8918
 
+#define GL_GEOMETRY_SHADER_INVOCATIONS_OES     0x887F
 
+#define GL_LAYER_PROVOKING_VERTEX_OES          0x825E
 
+#define GL_LINES_ADJACENCY_OES                 0x000A
 
+#define GL_LINE_STRIP_ADJACENCY_OES            0x000B
 
+#define GL_TRIANGLES_ADJACENCY_OES             0x000C
 
+#define GL_TRIANGLE_STRIP_ADJACENCY_OES        0x000D
 
+#define GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_OES  0x8DDF
 
+#define GL_MAX_GEOMETRY_UNIFORM_BLOCKS_OES     0x8A2C
 
+#define GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS_OES  0x8A32
 
+#define GL_MAX_GEOMETRY_INPUT_COMPONENTS_OES   0x9123
 
+#define GL_MAX_GEOMETRY_OUTPUT_COMPONENTS_OES  0x9124
 
+#define GL_MAX_GEOMETRY_OUTPUT_VERTICES_OES    0x8DE0
 
+#define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_OES  0x8DE1
 
+#define GL_MAX_GEOMETRY_SHADER_INVOCATIONS_OES  0x8E5A
 
+#define GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_OES  0x8C29
 
+#define GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS_OES  0x92CF
 
+#define GL_MAX_GEOMETRY_ATOMIC_COUNTERS_OES    0x92D5
 
+#define GL_MAX_GEOMETRY_IMAGE_UNIFORMS_OES     0x90CD
 
+#define GL_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS_OES  0x90D7
 
+#define GL_FIRST_VERTEX_CONVENTION_OES         0x8E4D
 
+#define GL_LAST_VERTEX_CONVENTION_OES          0x8E4E
 
+#define GL_UNDEFINED_VERTEX_OES                0x8260
 
+#define GL_PRIMITIVES_GENERATED_OES            0x8C87
 
+#define GL_FRAMEBUFFER_DEFAULT_LAYERS_OES      0x9312
 
+#define GL_MAX_FRAMEBUFFER_LAYERS_OES          0x9317
 
+#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_OES  0x8DA8
 
+#define GL_FRAMEBUFFER_ATTACHMENT_LAYERED_OES  0x8DA7
 
+#define GL_REFERENCED_BY_GEOMETRY_SHADER_OES   0x9309
 
+typedef void (APIENTRYP pfn_glFramebufferTextureOES) (GLenum, GLenum, GLuint, GLint);
 
+extern pfn_glFramebufferTextureOES fp_glFramebufferTextureOES;
 
+
 
  /* GL_OES_get_program_binary */
 
 extern GLboolean GLAD_OES_get_program_binary;
 
 #define GL_PROGRAM_BINARY_LENGTH_OES           0x8741
 
@@ -6456,6 +6622,9 @@ extern pfn_glGetProgramBinaryOES fp_glGetProgramBinaryOES;
 
 typedef void (APIENTRYP pfn_glProgramBinaryOES) (GLuint, GLenum, const void*, GLint);
 
 extern pfn_glProgramBinaryOES fp_glProgramBinaryOES;
 
 
+ /* GL_OES_gpu_shader5 */
 
+extern GLboolean GLAD_OES_gpu_shader5;
 
+
 
  /* GL_OES_mapbuffer */
 
 extern GLboolean GLAD_OES_mapbuffer;
 
 #define GL_WRITE_ONLY_OES                      0x88B9
 
@@ -6475,6 +6644,12 @@ extern GLboolean GLAD_OES_packed_depth_stencil;
 
 #define GL_UNSIGNED_INT_24_8_OES               0x84FA
 
 #define GL_DEPTH24_STENCIL8_OES                0x88F0
 
 
+ /* GL_OES_primitive_bounding_box */
 
+extern GLboolean GLAD_OES_primitive_bounding_box;
 
+#define GL_PRIMITIVE_BOUNDING_BOX_OES          0x92BE
 
+typedef void (APIENTRYP pfn_glPrimitiveBoundingBoxOES) (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat);
 
+extern pfn_glPrimitiveBoundingBoxOES fp_glPrimitiveBoundingBoxOES;
 
+
 
  /* GL_OES_required_internalformat */
 
 extern GLboolean GLAD_OES_required_internalformat;
 
 #define GL_ALPHA8_OES                          0x803C
 
@@ -6504,6 +6679,9 @@ extern GLboolean GLAD_OES_sample_variables;
 
  /* GL_OES_shader_image_atomic */
 
 extern GLboolean GLAD_OES_shader_image_atomic;
 
 
+ /* GL_OES_shader_io_blocks */
 
+extern GLboolean GLAD_OES_shader_io_blocks;
 
+
 
  /* GL_OES_shader_multisample_interpolation */
 
 extern GLboolean GLAD_OES_shader_multisample_interpolation;
 
 #define GL_MIN_FRAGMENT_INTERPOLATION_OFFSET_OES  0x8E5B
 
@@ -6526,6 +6704,57 @@ extern GLboolean GLAD_OES_stencil4;
 
 extern GLboolean GLAD_OES_surfaceless_context;
 
 #define GL_FRAMEBUFFER_UNDEFINED_OES           0x8219
 
 
+ /* GL_OES_tessellation_point_size */
 
+extern GLboolean GLAD_OES_tessellation_point_size;
 
+
 
+ /* GL_OES_tessellation_shader */
 
+extern GLboolean GLAD_OES_tessellation_shader;
 
+#define GL_PATCHES_OES                         0x000E
 
+#define GL_PATCH_VERTICES_OES                  0x8E72
 
+#define GL_TESS_CONTROL_OUTPUT_VERTICES_OES    0x8E75
 
+#define GL_TESS_GEN_MODE_OES                   0x8E76
 
+#define GL_TESS_GEN_SPACING_OES                0x8E77
 
+#define GL_TESS_GEN_VERTEX_ORDER_OES           0x8E78
 
+#define GL_TESS_GEN_POINT_MODE_OES             0x8E79
 
+#define GL_ISOLINES_OES                        0x8E7A
 
+#define GL_QUADS_OES                           0x0007
 
+#define GL_FRACTIONAL_ODD_OES                  0x8E7B
 
+#define GL_FRACTIONAL_EVEN_OES                 0x8E7C
 
+#define GL_MAX_PATCH_VERTICES_OES              0x8E7D
 
+#define GL_MAX_TESS_GEN_LEVEL_OES              0x8E7E
 
+#define GL_MAX_TESS_CONTROL_UNIFORM_COMPONENTS_OES  0x8E7F
 
+#define GL_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS_OES  0x8E80
 
+#define GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS_OES  0x8E81
 
+#define GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS_OES  0x8E82
 
+#define GL_MAX_TESS_CONTROL_OUTPUT_COMPONENTS_OES  0x8E83
 
+#define GL_MAX_TESS_PATCH_COMPONENTS_OES       0x8E84
 
+#define GL_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS_OES  0x8E85
 
+#define GL_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS_OES  0x8E86
 
+#define GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS_OES  0x8E89
 
+#define GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS_OES  0x8E8A
 
+#define GL_MAX_TESS_CONTROL_INPUT_COMPONENTS_OES  0x886C
 
+#define GL_MAX_TESS_EVALUATION_INPUT_COMPONENTS_OES  0x886D
 
+#define GL_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS_OES  0x8E1E
 
+#define GL_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS_OES  0x8E1F
 
+#define GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS_OES  0x92CD
 
+#define GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS_OES  0x92CE
 
+#define GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS_OES  0x92D3
 
+#define GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS_OES  0x92D4
 
+#define GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS_OES  0x90CB
 
+#define GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS_OES  0x90CC
 
+#define GL_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS_OES  0x90D8
 
+#define GL_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS_OES  0x90D9
 
+#define GL_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED_OES  0x8221
 
+#define GL_IS_PER_PATCH_OES                    0x92E7
 
+#define GL_REFERENCED_BY_TESS_CONTROL_SHADER_OES  0x9307
 
+#define GL_REFERENCED_BY_TESS_EVALUATION_SHADER_OES  0x9308
 
+#define GL_TESS_CONTROL_SHADER_OES             0x8E88
 
+#define GL_TESS_EVALUATION_SHADER_OES          0x8E87
 
+#define GL_TESS_CONTROL_SHADER_BIT_OES         0x00000008
 
+#define GL_TESS_EVALUATION_SHADER_BIT_OES      0x00000010
 
+typedef void (APIENTRYP pfn_glPatchParameteriOES) (GLenum, GLint);
 
+extern pfn_glPatchParameteriOES fp_glPatchParameteriOES;
 
+
 
  /* GL_OES_texture_3D */
 
 extern GLboolean GLAD_OES_texture_3D;
 
 #define GL_TEXTURE_WRAP_R_OES                  0x8072
 
@@ -6547,6 +6776,48 @@ extern pfn_glCompressedTexSubImage3DOES fp_glCompressedTexSubImage3DOES;
 
 typedef void (APIENTRYP pfn_glFramebufferTexture3DOES) (GLenum, GLenum, GLenum, GLuint, GLint, GLint);
 
 extern pfn_glFramebufferTexture3DOES fp_glFramebufferTexture3DOES;
 
 
+ /* GL_OES_texture_border_clamp */
 
+extern GLboolean GLAD_OES_texture_border_clamp;
 
+#define GL_TEXTURE_BORDER_COLOR_OES            0x1004
 
+#define GL_CLAMP_TO_BORDER_OES                 0x812D
 
+typedef void (APIENTRYP pfn_glTexParameterIivOES) (GLenum, GLenum, const GLint*);
 
+extern pfn_glTexParameterIivOES fp_glTexParameterIivOES;
 
+typedef void (APIENTRYP pfn_glTexParameterIuivOES) (GLenum, GLenum, const GLuint*);
 
+extern pfn_glTexParameterIuivOES fp_glTexParameterIuivOES;
 
+typedef void (APIENTRYP pfn_glGetTexParameterIivOES) (GLenum, GLenum, GLint*);
 
+extern pfn_glGetTexParameterIivOES fp_glGetTexParameterIivOES;
 
+typedef void (APIENTRYP pfn_glGetTexParameterIuivOES) (GLenum, GLenum, GLuint*);
 
+extern pfn_glGetTexParameterIuivOES fp_glGetTexParameterIuivOES;
 
+typedef void (APIENTRYP pfn_glSamplerParameterIivOES) (GLuint, GLenum, const GLint*);
 
+extern pfn_glSamplerParameterIivOES fp_glSamplerParameterIivOES;
 
+typedef void (APIENTRYP pfn_glSamplerParameterIuivOES) (GLuint, GLenum, const GLuint*);
 
+extern pfn_glSamplerParameterIuivOES fp_glSamplerParameterIuivOES;
 
+typedef void (APIENTRYP pfn_glGetSamplerParameterIivOES) (GLuint, GLenum, GLint*);
 
+extern pfn_glGetSamplerParameterIivOES fp_glGetSamplerParameterIivOES;
 
+typedef void (APIENTRYP pfn_glGetSamplerParameterIuivOES) (GLuint, GLenum, GLuint*);
 
+extern pfn_glGetSamplerParameterIuivOES fp_glGetSamplerParameterIuivOES;
 
+
 
+ /* GL_OES_texture_buffer */
 
+extern GLboolean GLAD_OES_texture_buffer;
 
+#define GL_TEXTURE_BUFFER_OES                  0x8C2A
 
+#define GL_TEXTURE_BUFFER_BINDING_OES          0x8C2A
 
+#define GL_MAX_TEXTURE_BUFFER_SIZE_OES         0x8C2B
 
+#define GL_TEXTURE_BINDING_BUFFER_OES          0x8C2C
 
+#define GL_TEXTURE_BUFFER_DATA_STORE_BINDING_OES  0x8C2D
 
+#define GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT_OES  0x919F
 
+#define GL_SAMPLER_BUFFER_OES                  0x8DC2
 
+#define GL_INT_SAMPLER_BUFFER_OES              0x8DD0
 
+#define GL_UNSIGNED_INT_SAMPLER_BUFFER_OES     0x8DD8
 
+#define GL_IMAGE_BUFFER_OES                    0x9051
 
+#define GL_INT_IMAGE_BUFFER_OES                0x905C
 
+#define GL_UNSIGNED_INT_IMAGE_BUFFER_OES       0x9067
 
+#define GL_TEXTURE_BUFFER_OFFSET_OES           0x919D
 
+#define GL_TEXTURE_BUFFER_SIZE_OES             0x919E
 
+typedef void (APIENTRYP pfn_glTexBufferOES) (GLenum, GLenum, GLuint);
 
+extern pfn_glTexBufferOES fp_glTexBufferOES;
 
+typedef void (APIENTRYP pfn_glTexBufferRangeOES) (GLenum, GLenum, GLuint, GLintptr, GLsizeiptr);
 
+extern pfn_glTexBufferRangeOES fp_glTexBufferRangeOES;
 
+
 
  /* GL_OES_texture_compression_astc */
 
 extern GLboolean GLAD_OES_texture_compression_astc;
 
 #define GL_COMPRESSED_RGBA_ASTC_3x3x3_OES      0x93C0
 
@@ -6570,6 +6841,18 @@ extern GLboolean GLAD_OES_texture_compression_astc;
 
 #define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x5_OES  0x93E8
 
 #define GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x6_OES  0x93E9
 
 
+ /* GL_OES_texture_cube_map_array */
 
+extern GLboolean GLAD_OES_texture_cube_map_array;
 
+#define GL_TEXTURE_CUBE_MAP_ARRAY_OES          0x9009
 
+#define GL_TEXTURE_BINDING_CUBE_MAP_ARRAY_OES  0x900A
 
+#define GL_SAMPLER_CUBE_MAP_ARRAY_OES          0x900C
 
+#define GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW_OES   0x900D
 
+#define GL_INT_SAMPLER_CUBE_MAP_ARRAY_OES      0x900E
 
+#define GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_OES  0x900F
 
+#define GL_IMAGE_CUBE_MAP_ARRAY_OES            0x9054
 
+#define GL_INT_IMAGE_CUBE_MAP_ARRAY_OES        0x905F
 
+#define GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY_OES  0x906A
 
+
 
  /* GL_OES_texture_float */
 
 extern GLboolean GLAD_OES_texture_float;
 
 
@@ -6601,6 +6884,15 @@ extern GLboolean GLAD_OES_texture_storage_multisample_2d_array;
 
 typedef void (APIENTRYP pfn_glTexStorage3DMultisampleOES) (GLenum, GLsizei, GLenum, GLsizei, GLsizei, GLsizei, GLboolean);
 
 extern pfn_glTexStorage3DMultisampleOES fp_glTexStorage3DMultisampleOES;
 
 
+ /* GL_OES_texture_view */
 
+extern GLboolean GLAD_OES_texture_view;
 
+#define GL_TEXTURE_VIEW_MIN_LEVEL_OES          0x82DB
 
+#define GL_TEXTURE_VIEW_NUM_LEVELS_OES         0x82DC
 
+#define GL_TEXTURE_VIEW_MIN_LAYER_OES          0x82DD
 
+#define GL_TEXTURE_VIEW_NUM_LAYERS_OES         0x82DE
 
+typedef void (APIENTRYP pfn_glTextureViewOES) (GLuint, GLenum, GLuint, GLenum, GLuint, GLuint, GLuint, GLuint);
 
+extern pfn_glTextureViewOES fp_glTextureViewOES;
 
+
 
  /* GL_OES_vertex_array_object */
 
 extern GLboolean GLAD_OES_vertex_array_object;
 
 #define GL_VERTEX_ARRAY_BINDING_OES            0x85B5
 
@@ -7009,6 +7301,21 @@ extern GLboolean GLAD_APPLE_aux_depth_stencil;
 
 extern GLboolean GLAD_APPLE_client_storage;
 
 #define GL_UNPACK_CLIENT_STORAGE_APPLE         0x85B2
 
 
+ /* GL_APPLE_clip_distance */
 
+extern GLboolean GLAD_APPLE_clip_distance;
 
+#define GL_MAX_CLIP_DISTANCES_APPLE            0x0D32
 
+#define GL_CLIP_DISTANCE0_APPLE                0x3000
 
+#define GL_CLIP_DISTANCE1_APPLE                0x3001
 
+#define GL_CLIP_DISTANCE2_APPLE                0x3002
 
+#define GL_CLIP_DISTANCE3_APPLE                0x3003
 
+#define GL_CLIP_DISTANCE4_APPLE                0x3004
 
+#define GL_CLIP_DISTANCE5_APPLE                0x3005
 
+#define GL_CLIP_DISTANCE6_APPLE                0x3006
 
+#define GL_CLIP_DISTANCE7_APPLE                0x3007
 
+
 
+ /* GL_APPLE_color_buffer_packed_float */
 
+extern GLboolean GLAD_APPLE_color_buffer_packed_float;
 
+
 
  /* GL_APPLE_copy_texture_levels */
 
 extern GLboolean GLAD_APPLE_copy_texture_levels;
 
 typedef void (APIENTRYP pfn_glCopyTextureLevelsAPPLE) (GLuint, GLuint, GLint, GLsizei);
 
@@ -7158,6 +7465,13 @@ extern GLboolean GLAD_APPLE_texture_format_BGRA8888;
 
 extern GLboolean GLAD_APPLE_texture_max_level;
 
 #define GL_TEXTURE_MAX_LEVEL_APPLE             0x813D
 
 
+ /* GL_APPLE_texture_packed_float */
 
+extern GLboolean GLAD_APPLE_texture_packed_float;
 
+#define GL_UNSIGNED_INT_10F_11F_11F_REV_APPLE  0x8C3B
 
+#define GL_UNSIGNED_INT_5_9_9_9_REV_APPLE      0x8C3E
 
+#define GL_R11F_G11F_B10F_APPLE                0x8C3A
 
+#define GL_RGB9_E5_APPLE                       0x8C3D
 
+
 
  /* GL_APPLE_texture_range */
 
 extern GLboolean GLAD_APPLE_texture_range;
 
 #define GL_TEXTURE_RANGE_LENGTH_APPLE          0x85B7
 
@@ -7258,6 +7572,12 @@ extern GLboolean GLAD_ATI_pixel_format_float;
 
 #define GL_RGBA_FLOAT_MODE_ATI                 0x8820
 
 #define GL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI     0x8835
 
 
+ /* GL_DMP_program_binary */
 
+extern GLboolean GLAD_DMP_program_binary;
 
+#define GL_SMAPHS30_PROGRAM_BINARY_DMP         0x9251
 
+#define GL_SMAPHS_PROGRAM_BINARY_DMP           0x9252
 
+#define GL_DMP_PROGRAM_BINARY_DMP              0x9253
 
+
 
  /* GL_DMP_shader_binary */
 
 extern GLboolean GLAD_DMP_shader_binary;
 
 #define GL_SHADER_BINARY_DMP                   0x9250
 
@@ -7514,6 +7834,15 @@ extern pfn_glBeginConditionalRenderNV fp_glBeginConditionalRenderNV;
 
 typedef void (APIENTRYP pfn_glEndConditionalRenderNV) ();
 
 extern pfn_glEndConditionalRenderNV fp_glEndConditionalRenderNV;
 
 
+ /* GL_NV_conservative_raster */
 
+extern GLboolean GLAD_NV_conservative_raster;
 
+#define GL_CONSERVATIVE_RASTERIZATION_NV       0x9346
 
+#define GL_SUBPIXEL_PRECISION_BIAS_X_BITS_NV   0x9347
 
+#define GL_SUBPIXEL_PRECISION_BIAS_Y_BITS_NV   0x9348
 
+#define GL_MAX_SUBPIXEL_PRECISION_BIAS_BITS_NV  0x9349
 
+typedef void (APIENTRYP pfn_glSubpixelPrecisionBiasNV) (GLuint, GLuint);
 
+extern pfn_glSubpixelPrecisionBiasNV fp_glSubpixelPrecisionBiasNV;
 
+
 
  /* GL_NV_copy_buffer */
 
 extern GLboolean GLAD_NV_copy_buffer;
 
 #define GL_COPY_READ_BUFFER_NV                 0x8F36
 
@@ -7664,6 +7993,10 @@ extern pfn_glFinishFenceNV fp_glFinishFenceNV;
 
 typedef void (APIENTRYP pfn_glSetFenceNV) (GLuint, GLenum);
 
 extern pfn_glSetFenceNV fp_glSetFenceNV;
 
 
+ /* GL_NV_fill_rectangle */
 
+extern GLboolean GLAD_NV_fill_rectangle;
 
+#define GL_FILL_RECTANGLE_NV                   0x933C
 
+
 
  /* GL_NV_float_buffer */
 
 extern GLboolean GLAD_NV_float_buffer;
 
 #define GL_FLOAT_R_NV                          0x8880
 
@@ -7682,9 +8015,19 @@ extern GLboolean GLAD_NV_float_buffer;
 
 #define GL_FLOAT_CLEAR_COLOR_VALUE_NV          0x888D
 
 #define GL_FLOAT_RGBA_MODE_NV                  0x888E
 
 
+ /* GL_NV_fragment_coverage_to_color */
 
+extern GLboolean GLAD_NV_fragment_coverage_to_color;
 
+#define GL_FRAGMENT_COVERAGE_TO_COLOR_NV       0x92DD
 
+#define GL_FRAGMENT_COVERAGE_COLOR_NV          0x92DE
 
+typedef void (APIENTRYP pfn_glFragmentCoverageColorNV) (GLuint);
 
+extern pfn_glFragmentCoverageColorNV fp_glFragmentCoverageColorNV;
 
+
 
  /* GL_NV_fragment_program4 */
 
 extern GLboolean GLAD_NV_fragment_program4;
 
 
+ /* GL_NV_fragment_shader_interlock */
 
+extern GLboolean GLAD_NV_fragment_shader_interlock;
 
+
 
  /* GL_NV_framebuffer_blit */
 
 extern GLboolean GLAD_NV_framebuffer_blit;
 
 #define GL_READ_FRAMEBUFFER_NV                 0x8CA8
 
@@ -7694,6 +8037,23 @@ extern GLboolean GLAD_NV_framebuffer_blit;
 
 typedef void (APIENTRYP pfn_glBlitFramebufferNV) (GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum);
 
 extern pfn_glBlitFramebufferNV fp_glBlitFramebufferNV;
 
 
+ /* GL_NV_framebuffer_mixed_samples */
 
+extern GLboolean GLAD_NV_framebuffer_mixed_samples;
 
+#define GL_COVERAGE_MODULATION_TABLE_NV        0x9331
 
+#define GL_COLOR_SAMPLES_NV                    0x8E20
 
+#define GL_DEPTH_SAMPLES_NV                    0x932D
 
+#define GL_STENCIL_SAMPLES_NV                  0x932E
 
+#define GL_MIXED_DEPTH_SAMPLES_SUPPORTED_NV    0x932F
 
+#define GL_MIXED_STENCIL_SAMPLES_SUPPORTED_NV  0x9330
 
+#define GL_COVERAGE_MODULATION_NV              0x9332
 
+#define GL_COVERAGE_MODULATION_TABLE_SIZE_NV   0x9333
 
+typedef void (APIENTRYP pfn_glCoverageModulationTableNV) (GLsizei, const GLfloat*);
 
+extern pfn_glCoverageModulationTableNV fp_glCoverageModulationTableNV;
 
+typedef void (APIENTRYP pfn_glGetCoverageModulationTableNV) (GLsizei, GLfloat*);
 
+extern pfn_glGetCoverageModulationTableNV fp_glGetCoverageModulationTableNV;
 
+typedef void (APIENTRYP pfn_glCoverageModulationNV) (GLenum);
 
+extern pfn_glCoverageModulationNV fp_glCoverageModulationNV;
 
+
 
  /* GL_NV_framebuffer_multisample */
 
 extern GLboolean GLAD_NV_framebuffer_multisample;
 
 #define GL_RENDERBUFFER_SAMPLES_NV             0x8CAB
 
@@ -7727,6 +8087,9 @@ extern pfn_glFramebufferTextureFaceEXT fp_glFramebufferTextureFaceEXT;
 
  /* GL_NV_geometry_shader4 */
 
 extern GLboolean GLAD_NV_geometry_shader4;
 
 
+ /* GL_NV_geometry_shader_passthrough */
 
+extern GLboolean GLAD_NV_geometry_shader_passthrough;
 
+
 
  /* GL_NV_gpu_program4 */
 
 extern GLboolean GLAD_NV_gpu_program4;
 
 #define GL_MIN_PROGRAM_TEXEL_OFFSET_NV         0x8904
 
@@ -7887,16 +8250,27 @@ extern pfn_glVertexAttribs3hvNV fp_glVertexAttribs3hvNV;
 
 typedef void (APIENTRYP pfn_glVertexAttribs4hvNV) (GLuint, GLsizei, const GLhalfNV*);
 
 extern pfn_glVertexAttribs4hvNV fp_glVertexAttribs4hvNV;
 
 
+ /* GL_NV_image_formats */
 
+extern GLboolean GLAD_NV_image_formats;
 
+
 
  /* GL_NV_instanced_arrays */
 
 extern GLboolean GLAD_NV_instanced_arrays;
 
 #define GL_VERTEX_ATTRIB_ARRAY_DIVISOR_NV      0x88FE
 
 typedef void (APIENTRYP pfn_glVertexAttribDivisorNV) (GLuint, GLuint);
 
 extern pfn_glVertexAttribDivisorNV fp_glVertexAttribDivisorNV;
 
 
+ /* GL_NV_internalformat_sample_query */
 
+extern GLboolean GLAD_NV_internalformat_sample_query;
 
+#define GL_MULTISAMPLES_NV                     0x9371
 
+#define GL_SUPERSAMPLE_SCALE_X_NV              0x9372
 
+#define GL_SUPERSAMPLE_SCALE_Y_NV              0x9373
 
+#define GL_CONFORMANT_NV                       0x9374
 
+typedef void (APIENTRYP pfn_glGetInternalformatSampleivNV) (GLenum, GLenum, GLsizei, GLenum, GLsizei, GLint*);
 
+extern pfn_glGetInternalformatSampleivNV fp_glGetInternalformatSampleivNV;
 
+
 
  /* GL_NV_multisample_coverage */
 
 extern GLboolean GLAD_NV_multisample_coverage;
 
 #define GL_SAMPLES_ARB                         0x80A9
 
-#define GL_COLOR_SAMPLES_NV                    0x8E20
 
 
  /* GL_NV_non_square_matrices */
 
 extern GLboolean GLAD_NV_non_square_matrices;
 
@@ -8011,13 +8385,11 @@ extern GLboolean GLAD_NV_path_rendering;
 
 #define GL_SKIP_MISSING_GLYPH_NV               0x90A9
 
 #define GL_USE_MISSING_GLYPH_NV                0x90AA
 
 #define GL_PATH_ERROR_POSITION_NV              0x90AB
 
-#define GL_PATH_FOG_GEN_MODE_NV                0x90AC
 
 #define GL_ACCUM_ADJACENT_PAIRS_NV             0x90AD
 
 #define GL_ADJACENT_PAIRS_NV                   0x90AE
 
 #define GL_FIRST_TO_REST_NV                    0x90AF
 
 #define GL_PATH_GEN_MODE_NV                    0x90B0
 
 #define GL_PATH_GEN_COEFF_NV                   0x90B1
 
-#define GL_PATH_GEN_COLOR_FORMAT_NV            0x90B2
 
 #define GL_PATH_GEN_COMPONENTS_NV              0x90B3
 
 #define GL_PATH_STENCIL_FUNC_NV                0x90B7
 
 #define GL_PATH_STENCIL_REF_NV                 0x90B8
 
@@ -8086,8 +8458,6 @@ extern GLboolean GLAD_NV_path_rendering;
 
 #define GL_FONT_UNDERLINE_POSITION_BIT_NV      0x04000000
 
 #define GL_FONT_UNDERLINE_THICKNESS_BIT_NV     0x08000000
 
 #define GL_FONT_HAS_KERNING_BIT_NV             0x10000000
 
-#define GL_PRIMARY_COLOR_NV                    0x852C
 
-#define GL_SECONDARY_COLOR_NV                  0x852D
 
 #define GL_ROUNDED_RECT_NV                     0xE8
 
 #define GL_RELATIVE_ROUNDED_RECT_NV            0xE9
 
 #define GL_ROUNDED_RECT2_NV                    0xEA
 
@@ -8111,6 +8481,10 @@ extern GLboolean GLAD_NV_path_rendering;
 
 #define GL_EYE_LINEAR_NV                       0x2400
 
 #define GL_OBJECT_LINEAR_NV                    0x2401
 
 #define GL_CONSTANT_NV                         0x8576
 
+#define GL_PATH_FOG_GEN_MODE_NV                0x90AC
 
+#define GL_PRIMARY_COLOR_NV                    0x852C
 
+#define GL_SECONDARY_COLOR_NV                  0x852D
 
+#define GL_PATH_GEN_COLOR_FORMAT_NV            0x90B2
 
 #define GL_PATH_PROJECTION_NV                  0x1701
 
 #define GL_PATH_MODELVIEW_NV                   0x1700
 
 #define GL_PATH_MODELVIEW_STACK_DEPTH_NV       0x0BA3
 
@@ -8174,12 +8548,6 @@ typedef void (APIENTRYP pfn_glStencilStrokePathInstancedNV) (GLsizei, GLenum, co
 
 extern pfn_glStencilStrokePathInstancedNV fp_glStencilStrokePathInstancedNV;
 
 typedef void (APIENTRYP pfn_glPathCoverDepthFuncNV) (GLenum);
 
 extern pfn_glPathCoverDepthFuncNV fp_glPathCoverDepthFuncNV;
 
-typedef void (APIENTRYP pfn_glPathColorGenNV) (GLenum, GLenum, GLenum, const GLfloat*);
 
-extern pfn_glPathColorGenNV fp_glPathColorGenNV;
 
-typedef void (APIENTRYP pfn_glPathTexGenNV) (GLenum, GLenum, GLint, const GLfloat*);
 
-extern pfn_glPathTexGenNV fp_glPathTexGenNV;
 
-typedef void (APIENTRYP pfn_glPathFogGenNV) (GLenum);
 
-extern pfn_glPathFogGenNV fp_glPathFogGenNV;
 
 typedef void (APIENTRYP pfn_glCoverFillPathNV) (GLuint, GLenum);
 
 extern pfn_glCoverFillPathNV fp_glCoverFillPathNV;
 
 typedef void (APIENTRYP pfn_glCoverStrokePathNV) (GLuint, GLenum);
 
@@ -8204,14 +8572,6 @@ typedef void (APIENTRYP pfn_glGetPathMetricRangeNV) (GLbitfield, GLuint, GLsizei
 
 extern pfn_glGetPathMetricRangeNV fp_glGetPathMetricRangeNV;
 
 typedef void (APIENTRYP pfn_glGetPathSpacingNV) (GLenum, GLsizei, GLenum, const void*, GLuint, GLfloat, GLfloat, GLenum, GLfloat*);
 
 extern pfn_glGetPathSpacingNV fp_glGetPathSpacingNV;
 
-typedef void (APIENTRYP pfn_glGetPathColorGenivNV) (GLenum, GLenum, GLint*);
 
-extern pfn_glGetPathColorGenivNV fp_glGetPathColorGenivNV;
 
-typedef void (APIENTRYP pfn_glGetPathColorGenfvNV) (GLenum, GLenum, GLfloat*);
 
-extern pfn_glGetPathColorGenfvNV fp_glGetPathColorGenfvNV;
 
-typedef void (APIENTRYP pfn_glGetPathTexGenivNV) (GLenum, GLenum, GLint*);
 
-extern pfn_glGetPathTexGenivNV fp_glGetPathTexGenivNV;
 
-typedef void (APIENTRYP pfn_glGetPathTexGenfvNV) (GLenum, GLenum, GLfloat*);
 
-extern pfn_glGetPathTexGenfvNV fp_glGetPathTexGenfvNV;
 
 typedef GLboolean (APIENTRYP pfn_glIsPointInFillPathNV) (GLuint, GLuint, GLfloat, GLfloat);
 
 extern pfn_glIsPointInFillPathNV fp_glIsPointInFillPathNV;
 
 typedef GLboolean (APIENTRYP pfn_glIsPointInStrokePathNV) (GLuint, GLfloat, GLfloat);
 
@@ -8250,6 +8610,24 @@ typedef void (APIENTRYP pfn_glProgramPathFragmentInputGenNV) (GLuint, GLint, GLe
 
 extern pfn_glProgramPathFragmentInputGenNV fp_glProgramPathFragmentInputGenNV;
 
 typedef void (APIENTRYP pfn_glGetProgramResourcefvNV) (GLuint, GLenum, GLuint, GLsizei, const GLenum*, GLsizei, GLsizei*, GLfloat*);
 
 extern pfn_glGetProgramResourcefvNV fp_glGetProgramResourcefvNV;
 
+typedef void (APIENTRYP pfn_glPathColorGenNV) (GLenum, GLenum, GLenum, const GLfloat*);
 
+extern pfn_glPathColorGenNV fp_glPathColorGenNV;
 
+typedef void (APIENTRYP pfn_glPathTexGenNV) (GLenum, GLenum, GLint, const GLfloat*);
 
+extern pfn_glPathTexGenNV fp_glPathTexGenNV;
 
+typedef void (APIENTRYP pfn_glPathFogGenNV) (GLenum);
 
+extern pfn_glPathFogGenNV fp_glPathFogGenNV;
 
+typedef void (APIENTRYP pfn_glGetPathColorGenivNV) (GLenum, GLenum, GLint*);
 
+extern pfn_glGetPathColorGenivNV fp_glGetPathColorGenivNV;
 
+typedef void (APIENTRYP pfn_glGetPathColorGenfvNV) (GLenum, GLenum, GLfloat*);
 
+extern pfn_glGetPathColorGenfvNV fp_glGetPathColorGenfvNV;
 
+typedef void (APIENTRYP pfn_glGetPathTexGenivNV) (GLenum, GLenum, GLint*);
 
+extern pfn_glGetPathTexGenivNV fp_glGetPathTexGenivNV;
 
+typedef void (APIENTRYP pfn_glGetPathTexGenfvNV) (GLenum, GLenum, GLfloat*);
 
+extern pfn_glGetPathTexGenfvNV fp_glGetPathTexGenfvNV;
 
+
 
+ /* GL_NV_path_rendering_shared_edge */
 
+extern GLboolean GLAD_NV_path_rendering_shared_edge;
 
+#define GL_SHARED_EDGE_NV                      0xC0
 
 
  /* GL_NV_present_video */
 
 extern GLboolean GLAD_NV_present_video;
 
@@ -8299,12 +8677,35 @@ extern GLboolean GLAD_NV_read_depth_stencil;
 
  /* GL_NV_read_stencil */
 
 extern GLboolean GLAD_NV_read_stencil;
 
 
+ /* GL_NV_sample_locations */
 
+extern GLboolean GLAD_NV_sample_locations;
 
+#define GL_SAMPLE_LOCATION_SUBPIXEL_BITS_NV    0x933D
 
+#define GL_SAMPLE_LOCATION_PIXEL_GRID_WIDTH_NV  0x933E
 
+#define GL_SAMPLE_LOCATION_PIXEL_GRID_HEIGHT_NV  0x933F
 
+#define GL_PROGRAMMABLE_SAMPLE_LOCATION_TABLE_SIZE_NV  0x9340
 
+#define GL_SAMPLE_LOCATION_NV                  0x8E50
 
+#define GL_PROGRAMMABLE_SAMPLE_LOCATION_NV     0x9341
 
+#define GL_FRAMEBUFFER_PROGRAMMABLE_SAMPLE_LOCATIONS_NV  0x9342
 
+#define GL_FRAMEBUFFER_SAMPLE_LOCATION_PIXEL_GRID_NV  0x9343
 
+typedef void (APIENTRYP pfn_glFramebufferSampleLocationsfvNV) (GLenum, GLuint, GLsizei, const GLfloat*);
 
+extern pfn_glFramebufferSampleLocationsfvNV fp_glFramebufferSampleLocationsfvNV;
 
+typedef void (APIENTRYP pfn_glNamedFramebufferSampleLocationsfvNV) (GLuint, GLuint, GLsizei, const GLfloat*);
 
+extern pfn_glNamedFramebufferSampleLocationsfvNV fp_glNamedFramebufferSampleLocationsfvNV;
 
+typedef void (APIENTRYP pfn_glResolveDepthValuesNV) ();
 
+extern pfn_glResolveDepthValuesNV fp_glResolveDepthValuesNV;
 
+
 
+ /* GL_NV_sample_mask_override_coverage */
 
+extern GLboolean GLAD_NV_sample_mask_override_coverage;
 
+
 
  /* GL_NV_shader_atomic_counters */
 
 extern GLboolean GLAD_NV_shader_atomic_counters;
 
 
  /* GL_NV_shader_atomic_float */
 
 extern GLboolean GLAD_NV_shader_atomic_float;
 
 
+ /* GL_NV_shader_atomic_fp16_vector */
 
+extern GLboolean GLAD_NV_shader_atomic_fp16_vector;
 
+
 
  /* GL_NV_shader_atomic_int64 */
 
 extern GLboolean GLAD_NV_shader_atomic_int64;
 
 
@@ -8344,6 +8745,9 @@ extern pfn_glProgramUniformui64vNV fp_glProgramUniformui64vNV;
 
 extern GLboolean GLAD_NV_shader_buffer_store;
 
 #define GL_SHADER_GLOBAL_ACCESS_BARRIER_BIT_NV  0x00000010
 
 
+ /* GL_NV_shader_noperspective_interpolation */
 
+extern GLboolean GLAD_NV_shader_noperspective_interpolation;
 
+
 
  /* GL_NV_shader_storage_buffer_object */
 
 extern GLboolean GLAD_NV_shader_storage_buffer_object;
 
 
@@ -8497,6 +8901,12 @@ extern pfn_glResumeTransformFeedbackNV fp_glResumeTransformFeedbackNV;
 
 typedef void (APIENTRYP pfn_glDrawTransformFeedbackNV) (GLenum, GLuint);
 
 extern pfn_glDrawTransformFeedbackNV fp_glDrawTransformFeedbackNV;
 
 
+ /* GL_NV_uniform_buffer_unified_memory */
 
+extern GLboolean GLAD_NV_uniform_buffer_unified_memory;
 
+#define GL_UNIFORM_BUFFER_UNIFIED_NV           0x936E
 
+#define GL_UNIFORM_BUFFER_ADDRESS_NV           0x936F
 
+#define GL_UNIFORM_BUFFER_LENGTH_NV            0x9370
 
+
 
  /* GL_NV_vdpau_interop */
 
 extern GLboolean GLAD_NV_vdpau_interop;
 
 #define GL_SURFACE_STATE_NV                    0x86EB
 
@@ -8723,6 +9133,40 @@ extern pfn_glVideoCaptureStreamParameterfvNV fp_glVideoCaptureStreamParameterfvN
 
 typedef void (APIENTRYP pfn_glVideoCaptureStreamParameterdvNV) (GLuint, GLuint, GLenum, const GLdouble*);
 
 extern pfn_glVideoCaptureStreamParameterdvNV fp_glVideoCaptureStreamParameterdvNV;
 
 
+ /* GL_NV_viewport_array */
 
+extern GLboolean GLAD_NV_viewport_array;
 
+#define GL_MAX_VIEWPORTS_NV                    0x825B
 
+#define GL_VIEWPORT_SUBPIXEL_BITS_NV           0x825C
 
+#define GL_VIEWPORT_BOUNDS_RANGE_NV            0x825D
 
+#define GL_VIEWPORT_INDEX_PROVOKING_VERTEX_NV  0x825F
 
+typedef void (APIENTRYP pfn_glViewportArrayvNV) (GLuint, GLsizei, const GLfloat*);
 
+extern pfn_glViewportArrayvNV fp_glViewportArrayvNV;
 
+typedef void (APIENTRYP pfn_glViewportIndexedfNV) (GLuint, GLfloat, GLfloat, GLfloat, GLfloat);
 
+extern pfn_glViewportIndexedfNV fp_glViewportIndexedfNV;
 
+typedef void (APIENTRYP pfn_glViewportIndexedfvNV) (GLuint, const GLfloat*);
 
+extern pfn_glViewportIndexedfvNV fp_glViewportIndexedfvNV;
 
+typedef void (APIENTRYP pfn_glScissorArrayvNV) (GLuint, GLsizei, const GLint*);
 
+extern pfn_glScissorArrayvNV fp_glScissorArrayvNV;
 
+typedef void (APIENTRYP pfn_glScissorIndexedNV) (GLuint, GLint, GLint, GLsizei, GLsizei);
 
+extern pfn_glScissorIndexedNV fp_glScissorIndexedNV;
 
+typedef void (APIENTRYP pfn_glScissorIndexedvNV) (GLuint, const GLint*);
 
+extern pfn_glScissorIndexedvNV fp_glScissorIndexedvNV;
 
+typedef void (APIENTRYP pfn_glDepthRangeArrayfvNV) (GLuint, GLsizei, const GLfloat*);
 
+extern pfn_glDepthRangeArrayfvNV fp_glDepthRangeArrayfvNV;
 
+typedef void (APIENTRYP pfn_glDepthRangeIndexedfNV) (GLuint, GLfloat, GLfloat);
 
+extern pfn_glDepthRangeIndexedfNV fp_glDepthRangeIndexedfNV;
 
+typedef void (APIENTRYP pfn_glGetFloati_vNV) (GLenum, GLuint, GLfloat*);
 
+extern pfn_glGetFloati_vNV fp_glGetFloati_vNV;
 
+typedef void (APIENTRYP pfn_glEnableiNV) (GLenum, GLuint);
 
+extern pfn_glEnableiNV fp_glEnableiNV;
 
+typedef void (APIENTRYP pfn_glDisableiNV) (GLenum, GLuint);
 
+extern pfn_glDisableiNV fp_glDisableiNV;
 
+typedef GLboolean (APIENTRYP pfn_glIsEnablediNV) (GLenum, GLuint);
 
+extern pfn_glIsEnablediNV fp_glIsEnablediNV;
 
+
 
+ /* GL_NV_viewport_array2 */
 
+extern GLboolean GLAD_NV_viewport_array2;
 
+
 
  /* GL_NVX_conditional_render */
 
 extern GLboolean GLAD_NVX_conditional_render;
 
 typedef void (APIENTRYP pfn_glBeginConditionalRenderNVX) (GLuint);

+ 123 - 21
src/libraries/glad/gladfuncs.hpp
View File 

@@ -30,7 +30,6 @@
 
 
 namespace glad {
 
 
-
 
 /* GL_VERSION_1_0 */
 
 inline void glCullFace(GLenum mode) { fp_glCullFace(mode); }
 
 inline void glFrontFace(GLenum mode) { fp_glFrontFace(mode); }
 
@@ -991,25 +990,25 @@ inline void glBindVertexBuffers(GLuint first, GLsizei count, const GLuint* buffe
 
 inline void glClipControl(GLenum origin, GLenum depth) { fp_glClipControl(origin, depth); }
 
 inline void glCreateTransformFeedbacks(GLsizei n, GLuint* ids) { fp_glCreateTransformFeedbacks(n, ids); }
 
 inline void glTransformFeedbackBufferBase(GLuint xfb, GLuint index, GLuint buffer) { fp_glTransformFeedbackBufferBase(xfb, index, buffer); }
 
-inline void glTransformFeedbackBufferRange(GLuint xfb, GLuint index, GLuint buffer, GLintptr offset, GLsizei size) { fp_glTransformFeedbackBufferRange(xfb, index, buffer, offset, size); }
 
+inline void glTransformFeedbackBufferRange(GLuint xfb, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) { fp_glTransformFeedbackBufferRange(xfb, index, buffer, offset, size); }
 
 inline void glGetTransformFeedbackiv(GLuint xfb, GLenum pname, GLint* param) { fp_glGetTransformFeedbackiv(xfb, pname, param); }
 
 inline void glGetTransformFeedbacki_v(GLuint xfb, GLenum pname, GLuint index, GLint* param) { fp_glGetTransformFeedbacki_v(xfb, pname, index, param); }
 
 inline void glGetTransformFeedbacki64_v(GLuint xfb, GLenum pname, GLuint index, GLint64* param) { fp_glGetTransformFeedbacki64_v(xfb, pname, index, param); }
 
 inline void glCreateBuffers(GLsizei n, GLuint* buffers) { fp_glCreateBuffers(n, buffers); }
 
-inline void glNamedBufferStorage(GLuint buffer, GLsizei size, const void* data, GLbitfield flags) { fp_glNamedBufferStorage(buffer, size, data, flags); }
 
-inline void glNamedBufferData(GLuint buffer, GLsizei size, const void* data, GLenum usage) { fp_glNamedBufferData(buffer, size, data, usage); }
 
-inline void glNamedBufferSubData(GLuint buffer, GLintptr offset, GLsizei size, const void* data) { fp_glNamedBufferSubData(buffer, offset, size, data); }
 
-inline void glCopyNamedBufferSubData(GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizei size) { fp_glCopyNamedBufferSubData(readBuffer, writeBuffer, readOffset, writeOffset, size); }
 
+inline void glNamedBufferStorage(GLuint buffer, GLsizeiptr size, const void* data, GLbitfield flags) { fp_glNamedBufferStorage(buffer, size, data, flags); }
 
+inline void glNamedBufferData(GLuint buffer, GLsizeiptr size, const void* data, GLenum usage) { fp_glNamedBufferData(buffer, size, data, usage); }
 
+inline void glNamedBufferSubData(GLuint buffer, GLintptr offset, GLsizeiptr size, const void* data) { fp_glNamedBufferSubData(buffer, offset, size, data); }
 
+inline void glCopyNamedBufferSubData(GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) { fp_glCopyNamedBufferSubData(readBuffer, writeBuffer, readOffset, writeOffset, size); }
 
 inline void glClearNamedBufferData(GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void* data) { fp_glClearNamedBufferData(buffer, internalformat, format, type, data); }
 
-inline void glClearNamedBufferSubData(GLuint buffer, GLenum internalformat, GLintptr offset, GLsizei size, GLenum format, GLenum type, const void* data) { fp_glClearNamedBufferSubData(buffer, internalformat, offset, size, format, type, data); }
 
+inline void glClearNamedBufferSubData(GLuint buffer, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void* data) { fp_glClearNamedBufferSubData(buffer, internalformat, offset, size, format, type, data); }
 
 inline void* glMapNamedBuffer(GLuint buffer, GLenum access) { return fp_glMapNamedBuffer(buffer, access); }
 
-inline void* glMapNamedBufferRange(GLuint buffer, GLintptr offset, GLsizei length, GLbitfield access) { return fp_glMapNamedBufferRange(buffer, offset, length, access); }
 
+inline void* glMapNamedBufferRange(GLuint buffer, GLintptr offset, GLsizeiptr length, GLbitfield access) { return fp_glMapNamedBufferRange(buffer, offset, length, access); }
 
 inline GLboolean glUnmapNamedBuffer(GLuint buffer) { return fp_glUnmapNamedBuffer(buffer); }
 
-inline void glFlushMappedNamedBufferRange(GLuint buffer, GLintptr offset, GLsizei length) { fp_glFlushMappedNamedBufferRange(buffer, offset, length); }
 
+inline void glFlushMappedNamedBufferRange(GLuint buffer, GLintptr offset, GLsizeiptr length) { fp_glFlushMappedNamedBufferRange(buffer, offset, length); }
 
 inline void glGetNamedBufferParameteriv(GLuint buffer, GLenum pname, GLint* params) { fp_glGetNamedBufferParameteriv(buffer, pname, params); }
 
 inline void glGetNamedBufferParameteri64v(GLuint buffer, GLenum pname, GLint64* params) { fp_glGetNamedBufferParameteri64v(buffer, pname, params); }
 
 inline void glGetNamedBufferPointerv(GLuint buffer, GLenum pname, void** params) { fp_glGetNamedBufferPointerv(buffer, pname, params); }
 
-inline void glGetNamedBufferSubData(GLuint buffer, GLintptr offset, GLsizei size, void* data) { fp_glGetNamedBufferSubData(buffer, offset, size, data); }
 
+inline void glGetNamedBufferSubData(GLuint buffer, GLintptr offset, GLsizeiptr size, void* data) { fp_glGetNamedBufferSubData(buffer, offset, size, data); }
 
 inline void glCreateFramebuffers(GLsizei n, GLuint* framebuffers) { fp_glCreateFramebuffers(n, framebuffers); }
 
 inline void glNamedFramebufferRenderbuffer(GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) { fp_glNamedFramebufferRenderbuffer(framebuffer, attachment, renderbuffertarget, renderbuffer); }
 
 inline void glNamedFramebufferParameteri(GLuint framebuffer, GLenum pname, GLint param) { fp_glNamedFramebufferParameteri(framebuffer, pname, param); }
 
@@ -1034,7 +1033,7 @@ inline void glNamedRenderbufferStorageMultisample(GLuint renderbuffer, GLsizei s
 
 inline void glGetNamedRenderbufferParameteriv(GLuint renderbuffer, GLenum pname, GLint* params) { fp_glGetNamedRenderbufferParameteriv(renderbuffer, pname, params); }
 
 inline void glCreateTextures(GLenum target, GLsizei n, GLuint* textures) { fp_glCreateTextures(target, n, textures); }
 
 inline void glTextureBuffer(GLuint texture, GLenum internalformat, GLuint buffer) { fp_glTextureBuffer(texture, internalformat, buffer); }
 
-inline void glTextureBufferRange(GLuint texture, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizei size) { fp_glTextureBufferRange(texture, internalformat, buffer, offset, size); }
 
+inline void glTextureBufferRange(GLuint texture, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size) { fp_glTextureBufferRange(texture, internalformat, buffer, offset, size); }
 
 inline void glTextureStorage1D(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width) { fp_glTextureStorage1D(texture, levels, internalformat, width); }
 
 inline void glTextureStorage2D(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) { fp_glTextureStorage2D(texture, levels, internalformat, width, height); }
 
 inline void glTextureStorage3D(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) { fp_glTextureStorage3D(texture, levels, internalformat, width, height, depth); }
 
@@ -1082,6 +1081,10 @@ inline void glGetVertexArrayIndexed64iv(GLuint vaobj, GLuint index, GLenum pname
 
 inline void glCreateSamplers(GLsizei n, GLuint* samplers) { fp_glCreateSamplers(n, samplers); }
 
 inline void glCreateProgramPipelines(GLsizei n, GLuint* pipelines) { fp_glCreateProgramPipelines(n, pipelines); }
 
 inline void glCreateQueries(GLenum target, GLsizei n, GLuint* ids) { fp_glCreateQueries(target, n, ids); }
 
+inline void glGetQueryBufferObjecti64v(GLuint id, GLuint buffer, GLenum pname, GLintptr offset) { fp_glGetQueryBufferObjecti64v(id, buffer, pname, offset); }
 
+inline void glGetQueryBufferObjectiv(GLuint id, GLuint buffer, GLenum pname, GLintptr offset) { fp_glGetQueryBufferObjectiv(id, buffer, pname, offset); }
 
+inline void glGetQueryBufferObjectui64v(GLuint id, GLuint buffer, GLenum pname, GLintptr offset) { fp_glGetQueryBufferObjectui64v(id, buffer, pname, offset); }
 
+inline void glGetQueryBufferObjectuiv(GLuint id, GLuint buffer, GLenum pname, GLintptr offset) { fp_glGetQueryBufferObjectuiv(id, buffer, pname, offset); }
 
 inline void glMemoryBarrierByRegion(GLbitfield barriers) { fp_glMemoryBarrierByRegion(barriers); }
 
 inline void glGetTextureSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLsizei bufSize, void* pixels) { fp_glGetTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bufSize, pixels); }
 
 inline void glGetCompressedTextureSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei bufSize, void* pixels) { fp_glGetCompressedTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, bufSize, pixels); }
 
@@ -1220,9 +1223,9 @@ inline void glGetNamedStringARB(GLint namelen, const GLchar* name, GLsizei bufSi
 
 inline void glGetNamedStringivARB(GLint namelen, const GLchar* name, GLenum pname, GLint* params) { fp_glGetNamedStringivARB(namelen, name, pname, params); }
 
 
 /* GL_ARB_sparse_buffer */
 
-inline void glBufferPageCommitmentARB(GLenum target, GLintptr offset, GLsizei size, GLboolean commit) { fp_glBufferPageCommitmentARB(target, offset, size, commit); }
 
-inline void glNamedBufferPageCommitmentEXT(GLuint buffer, GLintptr offset, GLsizei size, GLboolean commit) { fp_glNamedBufferPageCommitmentEXT(buffer, offset, size, commit); }
 
-inline void glNamedBufferPageCommitmentARB(GLuint buffer, GLintptr offset, GLsizei size, GLboolean commit) { fp_glNamedBufferPageCommitmentARB(buffer, offset, size, commit); }
 
+inline void glBufferPageCommitmentARB(GLenum target, GLintptr offset, GLsizeiptr size, GLboolean commit) { fp_glBufferPageCommitmentARB(target, offset, size, commit); }
 
+inline void glNamedBufferPageCommitmentEXT(GLuint buffer, GLintptr offset, GLsizeiptr size, GLboolean commit) { fp_glNamedBufferPageCommitmentEXT(buffer, offset, size, commit); }
 
+inline void glNamedBufferPageCommitmentARB(GLuint buffer, GLintptr offset, GLsizeiptr size, GLboolean commit) { fp_glNamedBufferPageCommitmentARB(buffer, offset, size, commit); }
 
 
 /* GL_ARB_sparse_texture */
 
 inline void glTexPageCommitmentARB(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLboolean resident) { fp_glTexPageCommitmentARB(target, level, xoffset, yoffset, zoffset, width, height, depth, resident); }
 
@@ -1230,6 +1233,11 @@ inline void glTexPageCommitmentARB(GLenum target, GLint level, GLint xoffset, GL
 
 /* GL_ARB_texture_buffer_object */
 
 inline void glTexBufferARB(GLenum target, GLenum internalformat, GLuint buffer) { fp_glTexBufferARB(target, internalformat, buffer); }
 
 
+/* GL_EXT_base_instance */
 
+inline void glDrawArraysInstancedBaseInstanceEXT(GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance) { fp_glDrawArraysInstancedBaseInstanceEXT(mode, first, count, instancecount, baseinstance); }
 
+inline void glDrawElementsInstancedBaseInstanceEXT(GLenum mode, GLsizei count, GLenum type, const void* indices, GLsizei instancecount, GLuint baseinstance) { fp_glDrawElementsInstancedBaseInstanceEXT(mode, count, type, indices, instancecount, baseinstance); }
 
+inline void glDrawElementsInstancedBaseVertexBaseInstanceEXT(GLenum mode, GLsizei count, GLenum type, const void* indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance) { fp_glDrawElementsInstancedBaseVertexBaseInstanceEXT(mode, count, type, indices, instancecount, basevertex, baseinstance); }
 
+
 
 /* GL_EXT_bindable_uniform */
 
 inline void glUniformBufferEXT(GLuint program, GLint location, GLuint buffer) { fp_glUniformBufferEXT(program, location, buffer); }
 
 inline GLint glGetUniformBufferSizeEXT(GLuint program, GLint location) { return fp_glGetUniformBufferSizeEXT(program, location); }
 
@@ -1536,6 +1544,12 @@ inline void glBlendFuncSeparateiEXT(GLuint buf, GLenum srcRGB, GLenum dstRGB, GL
 
 inline void glColorMaskiEXT(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a) { fp_glColorMaskiEXT(index, r, g, b, a); }
 
 inline GLboolean glIsEnablediEXT(GLenum target, GLuint index) { return fp_glIsEnablediEXT(target, index); }
 
 
+/* GL_EXT_draw_elements_base_vertex */
 
+inline void glDrawElementsBaseVertexEXT(GLenum mode, GLsizei count, GLenum type, const void* indices, GLint basevertex) { fp_glDrawElementsBaseVertexEXT(mode, count, type, indices, basevertex); }
 
+inline void glDrawRangeElementsBaseVertexEXT(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void* indices, GLint basevertex) { fp_glDrawRangeElementsBaseVertexEXT(mode, start, end, count, type, indices, basevertex); }
 
+inline void glDrawElementsInstancedBaseVertexEXT(GLenum mode, GLsizei count, GLenum type, const void* indices, GLsizei instancecount, GLint basevertex) { fp_glDrawElementsInstancedBaseVertexEXT(mode, count, type, indices, instancecount, basevertex); }
 
+inline void glMultiDrawElementsBaseVertexEXT(GLenum mode, const GLsizei* count, GLenum type, const void** indices, GLsizei primcount, const GLint* basevertex) { fp_glMultiDrawElementsBaseVertexEXT(mode, count, type, indices, primcount, basevertex); }
 
+
 
 /* GL_EXT_draw_instanced */
 
 inline void glDrawArraysInstancedEXT(GLenum mode, GLint start, GLsizei count, GLsizei primcount) { fp_glDrawArraysInstancedEXT(mode, start, count, primcount); }
 
 inline void glDrawElementsInstancedEXT(GLenum mode, GLsizei count, GLenum type, const void* indices, GLsizei primcount) { fp_glDrawElementsInstancedEXT(mode, count, type, indices, primcount); }
 
@@ -1595,6 +1609,10 @@ inline void glVertexAttribDivisorEXT(GLuint index, GLuint divisor) { fp_glVertex
 
 inline void* glMapBufferRangeEXT(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) { return fp_glMapBufferRangeEXT(target, offset, length, access); }
 
 inline void glFlushMappedBufferRangeEXT(GLenum target, GLintptr offset, GLsizeiptr length) { fp_glFlushMappedBufferRangeEXT(target, offset, length); }
 
 
+/* GL_EXT_multi_draw_indirect */
 
+inline void glMultiDrawArraysIndirectEXT(GLenum mode, const void* indirect, GLsizei drawcount, GLsizei stride) { fp_glMultiDrawArraysIndirectEXT(mode, indirect, drawcount, stride); }
 
+inline void glMultiDrawElementsIndirectEXT(GLenum mode, GLenum type, const void* indirect, GLsizei drawcount, GLsizei stride) { fp_glMultiDrawElementsIndirectEXT(mode, type, indirect, drawcount, stride); }
 
+
 
 /* GL_EXT_multisampled_render_to_texture */
 
 inline void glFramebufferTexture2DMultisampleEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples) { fp_glFramebufferTexture2DMultisampleEXT(target, attachment, textarget, texture, level, samples); }
 
 
@@ -1603,12 +1621,18 @@ inline void glReadBufferIndexedEXT(GLenum src, GLint index) { fp_glReadBufferInd
 
 inline void glDrawBuffersIndexedEXT(GLint n, const GLenum* location, const GLint* indices) { fp_glDrawBuffersIndexedEXT(n, location, indices); }
 
 inline void glGetIntegeri_vEXT(GLenum target, GLuint index, GLint* data) { fp_glGetIntegeri_vEXT(target, index, data); }
 
 
+/* GL_EXT_polygon_offset_clamp */
 
+inline void glPolygonOffsetClampEXT(GLfloat factor, GLfloat units, GLfloat clamp) { fp_glPolygonOffsetClampEXT(factor, units, clamp); }
 
+
 
 /* GL_EXT_primitive_bounding_box */
 
 inline void glPrimitiveBoundingBoxEXT(GLfloat minX, GLfloat minY, GLfloat minZ, GLfloat minW, GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW) { fp_glPrimitiveBoundingBoxEXT(minX, minY, minZ, minW, maxX, maxY, maxZ, maxW); }
 
 
 /* GL_EXT_provoking_vertex */
 
 inline void glProvokingVertexEXT(GLenum mode) { fp_glProvokingVertexEXT(mode); }
 
 
+/* GL_EXT_raster_multisample */
 
+inline void glRasterSamplesEXT(GLuint samples, GLboolean fixedsamplelocations) { fp_glRasterSamplesEXT(samples, fixedsamplelocations); }
 
+
 
 /* GL_EXT_robustness */
 
 inline GLenum glGetGraphicsResetStatusEXT() { return fp_glGetGraphicsResetStatusEXT(); }
 
 inline void glReadnPixelsEXT(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void* data) { fp_glReadnPixelsEXT(x, y, width, height, format, type, bufSize, data); }
 
@@ -1693,10 +1717,32 @@ inline void glGetVertexAttribLdvEXT(GLuint index, GLenum pname, GLdouble* params
 
 /* GL_EXT_x11_sync_object */
 
 inline GLsync glImportSyncEXT(GLenum external_sync_type, GLintptr external_sync, GLbitfield flags) { return fp_glImportSyncEXT(external_sync_type, external_sync, flags); }
 
 
+/* GL_OES_copy_image */
 
+inline void glCopyImageSubDataOES(GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth) { fp_glCopyImageSubDataOES(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth); }
 
+
 
+/* GL_OES_draw_buffers_indexed */
 
+inline void glEnableiOES(GLenum target, GLuint index) { fp_glEnableiOES(target, index); }
 
+inline void glDisableiOES(GLenum target, GLuint index) { fp_glDisableiOES(target, index); }
 
+inline void glBlendEquationiOES(GLuint buf, GLenum mode) { fp_glBlendEquationiOES(buf, mode); }
 
+inline void glBlendEquationSeparateiOES(GLuint buf, GLenum modeRGB, GLenum modeAlpha) { fp_glBlendEquationSeparateiOES(buf, modeRGB, modeAlpha); }
 
+inline void glBlendFunciOES(GLuint buf, GLenum src, GLenum dst) { fp_glBlendFunciOES(buf, src, dst); }
 
+inline void glBlendFuncSeparateiOES(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) { fp_glBlendFuncSeparateiOES(buf, srcRGB, dstRGB, srcAlpha, dstAlpha); }
 
+inline void glColorMaskiOES(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a) { fp_glColorMaskiOES(index, r, g, b, a); }
 
+inline GLboolean glIsEnablediOES(GLenum target, GLuint index) { return fp_glIsEnablediOES(target, index); }
 
+
 
+/* GL_OES_draw_elements_base_vertex */
 
+inline void glDrawElementsBaseVertexOES(GLenum mode, GLsizei count, GLenum type, const void* indices, GLint basevertex) { fp_glDrawElementsBaseVertexOES(mode, count, type, indices, basevertex); }
 
+inline void glDrawRangeElementsBaseVertexOES(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void* indices, GLint basevertex) { fp_glDrawRangeElementsBaseVertexOES(mode, start, end, count, type, indices, basevertex); }
 
+inline void glDrawElementsInstancedBaseVertexOES(GLenum mode, GLsizei count, GLenum type, const void* indices, GLsizei instancecount, GLint basevertex) { fp_glDrawElementsInstancedBaseVertexOES(mode, count, type, indices, instancecount, basevertex); }
 
+inline void glMultiDrawElementsBaseVertexOES(GLenum mode, const GLsizei* count, GLenum type, const void** indices, GLsizei primcount, const GLint* basevertex) { fp_glMultiDrawElementsBaseVertexOES(mode, count, type, indices, primcount, basevertex); }
 
+
 
 /* GL_OES_EGL_image */
 
 inline void glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image) { fp_glEGLImageTargetTexture2DOES(target, image); }
 
 inline void glEGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image) { fp_glEGLImageTargetRenderbufferStorageOES(target, image); }
 
 
+/* GL_OES_geometry_shader */
 
+inline void glFramebufferTextureOES(GLenum target, GLenum attachment, GLuint texture, GLint level) { fp_glFramebufferTextureOES(target, attachment, texture, level); }
 
+
 
 /* GL_OES_get_program_binary */
 
 inline void glGetProgramBinaryOES(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, void* binary) { fp_glGetProgramBinaryOES(program, bufSize, length, binaryFormat, binary); }
 
 inline void glProgramBinaryOES(GLuint program, GLenum binaryFormat, const void* binary, GLint length) { fp_glProgramBinaryOES(program, binaryFormat, binary, length); }
 
@@ -1706,9 +1752,15 @@ inline void* glMapBufferOES(GLenum target, GLenum access) { return fp_glMapBuffe
 
 inline GLboolean glUnmapBufferOES(GLenum target) { return fp_glUnmapBufferOES(target); }
 
 inline void glGetBufferPointervOES(GLenum target, GLenum pname, void** params) { fp_glGetBufferPointervOES(target, pname, params); }
 
 
+/* GL_OES_primitive_bounding_box */
 
+inline void glPrimitiveBoundingBoxOES(GLfloat minX, GLfloat minY, GLfloat minZ, GLfloat minW, GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW) { fp_glPrimitiveBoundingBoxOES(minX, minY, minZ, minW, maxX, maxY, maxZ, maxW); }
 
+
 
 /* GL_OES_sample_shading */
 
 inline void glMinSampleShadingOES(GLfloat value) { fp_glMinSampleShadingOES(value); }
 
 
+/* GL_OES_tessellation_shader */
 
+inline void glPatchParameteriOES(GLenum pname, GLint value) { fp_glPatchParameteriOES(pname, value); }
 
+
 
 /* GL_OES_texture_3D */
 
 inline void glTexImage3DOES(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void* pixels) { fp_glTexImage3DOES(target, level, internalformat, width, height, depth, border, format, type, pixels); }
 
 inline void glTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void* pixels) { fp_glTexSubImage3DOES(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); }
 
@@ -1717,9 +1769,26 @@ inline void glCompressedTexImage3DOES(GLenum target, GLint level, GLenum interna
 
 inline void glCompressedTexSubImage3DOES(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void* data) { fp_glCompressedTexSubImage3DOES(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data); }
 
 inline void glFramebufferTexture3DOES(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) { fp_glFramebufferTexture3DOES(target, attachment, textarget, texture, level, zoffset); }
 
 
+/* GL_OES_texture_border_clamp */
 
+inline void glTexParameterIivOES(GLenum target, GLenum pname, const GLint* params) { fp_glTexParameterIivOES(target, pname, params); }
 
+inline void glTexParameterIuivOES(GLenum target, GLenum pname, const GLuint* params) { fp_glTexParameterIuivOES(target, pname, params); }
 
+inline void glGetTexParameterIivOES(GLenum target, GLenum pname, GLint* params) { fp_glGetTexParameterIivOES(target, pname, params); }
 
+inline void glGetTexParameterIuivOES(GLenum target, GLenum pname, GLuint* params) { fp_glGetTexParameterIuivOES(target, pname, params); }
 
+inline void glSamplerParameterIivOES(GLuint sampler, GLenum pname, const GLint* param) { fp_glSamplerParameterIivOES(sampler, pname, param); }
 
+inline void glSamplerParameterIuivOES(GLuint sampler, GLenum pname, const GLuint* param) { fp_glSamplerParameterIuivOES(sampler, pname, param); }
 
+inline void glGetSamplerParameterIivOES(GLuint sampler, GLenum pname, GLint* params) { fp_glGetSamplerParameterIivOES(sampler, pname, params); }
 
+inline void glGetSamplerParameterIuivOES(GLuint sampler, GLenum pname, GLuint* params) { fp_glGetSamplerParameterIuivOES(sampler, pname, params); }
 
+
 
+/* GL_OES_texture_buffer */
 
+inline void glTexBufferOES(GLenum target, GLenum internalformat, GLuint buffer) { fp_glTexBufferOES(target, internalformat, buffer); }
 
+inline void glTexBufferRangeOES(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size) { fp_glTexBufferRangeOES(target, internalformat, buffer, offset, size); }
 
+
 
 /* GL_OES_texture_storage_multisample_2d_array */
 
 inline void glTexStorage3DMultisampleOES(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations) { fp_glTexStorage3DMultisampleOES(target, samples, internalformat, width, height, depth, fixedsamplelocations); }
 
 
+/* GL_OES_texture_view */
 
+inline void glTextureViewOES(GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers) { fp_glTextureViewOES(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers); }
 
+
 
 /* GL_OES_vertex_array_object */
 
 inline void glBindVertexArrayOES(GLuint array) { fp_glBindVertexArrayOES(array); }
 
 inline void glDeleteVertexArraysOES(GLsizei n, const GLuint* arrays) { fp_glDeleteVertexArraysOES(n, arrays); }
 
@@ -1957,6 +2026,9 @@ inline void glBlendBarrierNV() { fp_glBlendBarrierNV(); }
 
 inline void glBeginConditionalRenderNV(GLuint id, GLenum mode) { fp_glBeginConditionalRenderNV(id, mode); }
 
 inline void glEndConditionalRenderNV() { fp_glEndConditionalRenderNV(); }
 
 
+/* GL_NV_conservative_raster */
 
+inline void glSubpixelPrecisionBiasNV(GLuint xbits, GLuint ybits) { fp_glSubpixelPrecisionBiasNV(xbits, ybits); }
 
+
 
 /* GL_NV_copy_buffer */
 
 inline void glCopyBufferSubDataNV(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) { fp_glCopyBufferSubDataNV(readTarget, writeTarget, readOffset, writeOffset, size); }
 
 
@@ -1996,9 +2068,17 @@ inline void glGetFenceivNV(GLuint fence, GLenum pname, GLint* params) { fp_glGet
 
 inline void glFinishFenceNV(GLuint fence) { fp_glFinishFenceNV(fence); }
 
 inline void glSetFenceNV(GLuint fence, GLenum condition) { fp_glSetFenceNV(fence, condition); }
 
 
+/* GL_NV_fragment_coverage_to_color */
 
+inline void glFragmentCoverageColorNV(GLuint color) { fp_glFragmentCoverageColorNV(color); }
 
+
 
 /* GL_NV_framebuffer_blit */
 
 inline void glBlitFramebufferNV(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) { fp_glBlitFramebufferNV(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); }
 
 
+/* GL_NV_framebuffer_mixed_samples */
 
+inline void glCoverageModulationTableNV(GLsizei n, const GLfloat* v) { fp_glCoverageModulationTableNV(n, v); }
 
+inline void glGetCoverageModulationTableNV(GLsizei bufsize, GLfloat* v) { fp_glGetCoverageModulationTableNV(bufsize, v); }
 
+inline void glCoverageModulationNV(GLenum components) { fp_glCoverageModulationNV(components); }
 
+
 
 /* GL_NV_framebuffer_multisample */
 
 inline void glRenderbufferStorageMultisampleNV(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) { fp_glRenderbufferStorageMultisampleNV(target, samples, internalformat, width, height); }
 
 
@@ -2082,6 +2162,9 @@ inline void glVertexAttribs4hvNV(GLuint index, GLsizei n, const GLhalfNV* v) { f
 
 /* GL_NV_instanced_arrays */
 
 inline void glVertexAttribDivisorNV(GLuint index, GLuint divisor) { fp_glVertexAttribDivisorNV(index, divisor); }
 
 
+/* GL_NV_internalformat_sample_query */
 
+inline void glGetInternalformatSampleivNV(GLenum target, GLenum internalformat, GLsizei samples, GLenum pname, GLsizei bufSize, GLint* params) { fp_glGetInternalformatSampleivNV(target, internalformat, samples, pname, bufSize, params); }
 
+
 
 /* GL_NV_non_square_matrices */
 
 inline void glUniformMatrix2x3fvNV(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) { fp_glUniformMatrix2x3fvNV(location, count, transpose, value); }
 
 inline void glUniformMatrix3x2fvNV(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) { fp_glUniformMatrix3x2fvNV(location, count, transpose, value); }
 
@@ -2131,9 +2214,6 @@ inline void glStencilStrokePathNV(GLuint path, GLint reference, GLuint mask) { f
 
 inline void glStencilFillPathInstancedNV(GLsizei numPaths, GLenum pathNameType, const void* paths, GLuint pathBase, GLenum fillMode, GLuint mask, GLenum transformType, const GLfloat* transformValues) { fp_glStencilFillPathInstancedNV(numPaths, pathNameType, paths, pathBase, fillMode, mask, transformType, transformValues); }
 
 inline void glStencilStrokePathInstancedNV(GLsizei numPaths, GLenum pathNameType, const void* paths, GLuint pathBase, GLint reference, GLuint mask, GLenum transformType, const GLfloat* transformValues) { fp_glStencilStrokePathInstancedNV(numPaths, pathNameType, paths, pathBase, reference, mask, transformType, transformValues); }
 
 inline void glPathCoverDepthFuncNV(GLenum func) { fp_glPathCoverDepthFuncNV(func); }
 
-inline void glPathColorGenNV(GLenum color, GLenum genMode, GLenum colorFormat, const GLfloat* coeffs) { fp_glPathColorGenNV(color, genMode, colorFormat, coeffs); }
 
-inline void glPathTexGenNV(GLenum texCoordSet, GLenum genMode, GLint components, const GLfloat* coeffs) { fp_glPathTexGenNV(texCoordSet, genMode, components, coeffs); }
 
-inline void glPathFogGenNV(GLenum genMode) { fp_glPathFogGenNV(genMode); }
 
 inline void glCoverFillPathNV(GLuint path, GLenum coverMode) { fp_glCoverFillPathNV(path, coverMode); }
 
 inline void glCoverStrokePathNV(GLuint path, GLenum coverMode) { fp_glCoverStrokePathNV(path, coverMode); }
 
 inline void glCoverFillPathInstancedNV(GLsizei numPaths, GLenum pathNameType, const void* paths, GLuint pathBase, GLenum coverMode, GLenum transformType, const GLfloat* transformValues) { fp_glCoverFillPathInstancedNV(numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues); }
 
@@ -2146,10 +2226,6 @@ inline void glGetPathDashArrayNV(GLuint path, GLfloat* dashArray) { fp_glGetPath
 
 inline void glGetPathMetricsNV(GLbitfield metricQueryMask, GLsizei numPaths, GLenum pathNameType, const void* paths, GLuint pathBase, GLsizei stride, GLfloat* metrics) { fp_glGetPathMetricsNV(metricQueryMask, numPaths, pathNameType, paths, pathBase, stride, metrics); }
 
 inline void glGetPathMetricRangeNV(GLbitfield metricQueryMask, GLuint firstPathName, GLsizei numPaths, GLsizei stride, GLfloat* metrics) { fp_glGetPathMetricRangeNV(metricQueryMask, firstPathName, numPaths, stride, metrics); }
 
 inline void glGetPathSpacingNV(GLenum pathListMode, GLsizei numPaths, GLenum pathNameType, const void* paths, GLuint pathBase, GLfloat advanceScale, GLfloat kerningScale, GLenum transformType, GLfloat* returnedSpacing) { fp_glGetPathSpacingNV(pathListMode, numPaths, pathNameType, paths, pathBase, advanceScale, kerningScale, transformType, returnedSpacing); }
 
-inline void glGetPathColorGenivNV(GLenum color, GLenum pname, GLint* value) { fp_glGetPathColorGenivNV(color, pname, value); }
 
-inline void glGetPathColorGenfvNV(GLenum color, GLenum pname, GLfloat* value) { fp_glGetPathColorGenfvNV(color, pname, value); }
 
-inline void glGetPathTexGenivNV(GLenum texCoordSet, GLenum pname, GLint* value) { fp_glGetPathTexGenivNV(texCoordSet, pname, value); }
 
-inline void glGetPathTexGenfvNV(GLenum texCoordSet, GLenum pname, GLfloat* value) { fp_glGetPathTexGenfvNV(texCoordSet, pname, value); }
 
 inline GLboolean glIsPointInFillPathNV(GLuint path, GLuint mask, GLfloat x, GLfloat y) { return fp_glIsPointInFillPathNV(path, mask, x, y); }
 
 inline GLboolean glIsPointInStrokePathNV(GLuint path, GLfloat x, GLfloat y) { return fp_glIsPointInStrokePathNV(path, x, y); }
 
 inline GLfloat glGetPathLengthNV(GLuint path, GLsizei startSegment, GLsizei numSegments) { return fp_glGetPathLengthNV(path, startSegment, numSegments); }
 
@@ -2169,6 +2245,13 @@ inline GLenum glPathGlyphIndexArrayNV(GLuint firstPathName, GLenum fontTarget, c
 
 inline GLenum glPathMemoryGlyphIndexArrayNV(GLuint firstPathName, GLenum fontTarget, GLsizeiptr fontSize, const void* fontData, GLsizei faceIndex, GLuint firstGlyphIndex, GLsizei numGlyphs, GLuint pathParameterTemplate, GLfloat emScale) { return fp_glPathMemoryGlyphIndexArrayNV(firstPathName, fontTarget, fontSize, fontData, faceIndex, firstGlyphIndex, numGlyphs, pathParameterTemplate, emScale); }
 
 inline void glProgramPathFragmentInputGenNV(GLuint program, GLint location, GLenum genMode, GLint components, const GLfloat* coeffs) { fp_glProgramPathFragmentInputGenNV(program, location, genMode, components, coeffs); }
 
 inline void glGetProgramResourcefvNV(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum* props, GLsizei bufSize, GLsizei* length, GLfloat* params) { fp_glGetProgramResourcefvNV(program, programInterface, index, propCount, props, bufSize, length, params); }
 
+inline void glPathColorGenNV(GLenum color, GLenum genMode, GLenum colorFormat, const GLfloat* coeffs) { fp_glPathColorGenNV(color, genMode, colorFormat, coeffs); }
 
+inline void glPathTexGenNV(GLenum texCoordSet, GLenum genMode, GLint components, const GLfloat* coeffs) { fp_glPathTexGenNV(texCoordSet, genMode, components, coeffs); }
 
+inline void glPathFogGenNV(GLenum genMode) { fp_glPathFogGenNV(genMode); }
 
+inline void glGetPathColorGenivNV(GLenum color, GLenum pname, GLint* value) { fp_glGetPathColorGenivNV(color, pname, value); }
 
+inline void glGetPathColorGenfvNV(GLenum color, GLenum pname, GLfloat* value) { fp_glGetPathColorGenfvNV(color, pname, value); }
 
+inline void glGetPathTexGenivNV(GLenum texCoordSet, GLenum pname, GLint* value) { fp_glGetPathTexGenivNV(texCoordSet, pname, value); }
 
+inline void glGetPathTexGenfvNV(GLenum texCoordSet, GLenum pname, GLfloat* value) { fp_glGetPathTexGenfvNV(texCoordSet, pname, value); }
 
 
 /* GL_NV_present_video */
 
 inline void glPresentFrameKeyedNV(GLuint video_slot, GLuint64EXT minPresentTime, GLuint beginPresentTimeId, GLuint presentDurationId, GLenum type, GLenum target0, GLuint fill0, GLuint key0, GLenum target1, GLuint fill1, GLuint key1) { fp_glPresentFrameKeyedNV(video_slot, minPresentTime, beginPresentTimeId, presentDurationId, type, target0, fill0, key0, target1, fill1, key1); }
 
@@ -2185,6 +2268,11 @@ inline void glPrimitiveRestartIndexNV(GLuint index) { fp_glPrimitiveRestartIndex
 
 /* GL_NV_read_buffer */
 
 inline void glReadBufferNV(GLenum mode) { fp_glReadBufferNV(mode); }
 
 
+/* GL_NV_sample_locations */
 
+inline void glFramebufferSampleLocationsfvNV(GLenum target, GLuint start, GLsizei count, const GLfloat* v) { fp_glFramebufferSampleLocationsfvNV(target, start, count, v); }
 
+inline void glNamedFramebufferSampleLocationsfvNV(GLuint framebuffer, GLuint start, GLsizei count, const GLfloat* v) { fp_glNamedFramebufferSampleLocationsfvNV(framebuffer, start, count, v); }
 
+inline void glResolveDepthValuesNV() { fp_glResolveDepthValuesNV(); }
 
+
 
 /* GL_NV_shader_buffer_load */
 
 inline void glMakeBufferResidentNV(GLenum target, GLenum access) { fp_glMakeBufferResidentNV(target, access); }
 
 inline void glMakeBufferNonResidentNV(GLenum target) { fp_glMakeBufferNonResidentNV(target); }
 
@@ -2320,6 +2408,20 @@ inline void glVideoCaptureStreamParameterivNV(GLuint video_capture_slot, GLuint
 
 inline void glVideoCaptureStreamParameterfvNV(GLuint video_capture_slot, GLuint stream, GLenum pname, const GLfloat* params) { fp_glVideoCaptureStreamParameterfvNV(video_capture_slot, stream, pname, params); }
 
 inline void glVideoCaptureStreamParameterdvNV(GLuint video_capture_slot, GLuint stream, GLenum pname, const GLdouble* params) { fp_glVideoCaptureStreamParameterdvNV(video_capture_slot, stream, pname, params); }
 
 
+/* GL_NV_viewport_array */
 
+inline void glViewportArrayvNV(GLuint first, GLsizei count, const GLfloat* v) { fp_glViewportArrayvNV(first, count, v); }
 
+inline void glViewportIndexedfNV(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h) { fp_glViewportIndexedfNV(index, x, y, w, h); }
 
+inline void glViewportIndexedfvNV(GLuint index, const GLfloat* v) { fp_glViewportIndexedfvNV(index, v); }
 
+inline void glScissorArrayvNV(GLuint first, GLsizei count, const GLint* v) { fp_glScissorArrayvNV(first, count, v); }
 
+inline void glScissorIndexedNV(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height) { fp_glScissorIndexedNV(index, left, bottom, width, height); }
 
+inline void glScissorIndexedvNV(GLuint index, const GLint* v) { fp_glScissorIndexedvNV(index, v); }
 
+inline void glDepthRangeArrayfvNV(GLuint first, GLsizei count, const GLfloat* v) { fp_glDepthRangeArrayfvNV(first, count, v); }
 
+inline void glDepthRangeIndexedfNV(GLuint index, GLfloat n, GLfloat f) { fp_glDepthRangeIndexedfNV(index, n, f); }
 
+inline void glGetFloati_vNV(GLenum target, GLuint index, GLfloat* data) { fp_glGetFloati_vNV(target, index, data); }
 
+inline void glEnableiNV(GLenum target, GLuint index) { fp_glEnableiNV(target, index); }
 
+inline void glDisableiNV(GLenum target, GLuint index) { fp_glDisableiNV(target, index); }
 
+inline GLboolean glIsEnablediNV(GLenum target, GLuint index) { return fp_glIsEnablediNV(target, index); }
 
+
 
 /* GL_NVX_conditional_render */
 
 inline void glBeginConditionalRenderNVX(GLuint id) { fp_glBeginConditionalRenderNVX(id); }
 
 inline void glEndConditionalRenderNVX() { fp_glEndConditionalRenderNVX(); }

+ 1 - 1
src/modules/graphics/opengl/Canvas.cpp
View File 

@@ -826,7 +826,7 @@ bool Canvas::isFormatSupported(Canvas::Format format)
 
 		supported = GLAD_ES_VERSION_3_0 || GLAD_VERSION_1_0;
 
 		break;
 
 	case FORMAT_RG11B10F:
 
-		supported = GLAD_VERSION_3_0 || GLAD_EXT_packed_float /*|| GLAD_APPLE_color_buffer_packed_float*/;
 
+		supported = GLAD_VERSION_3_0 || GLAD_EXT_packed_float || GLAD_APPLE_color_buffer_packed_float;
 
 		break;
 
 	case FORMAT_R16F:
 
 	case FORMAT_RG16F: