shithub: zelda3

Info  •  Files  •  Log  •  Branches

OpenGL and GLSL Shader support

You need to use the OpenGL output method to use shaders.
PNG texture loading not yet implemented.

diff: cannot open b/third_party/gl_core//null: file does not exist: 'b/third_party/gl_core//null'

--- a/Makefile

+++ b/Makefile

@@ -1,9 +1,9 @@

 TARGET_EXEC:=zelda3

 ROM:=tables/zelda3.sfc

-SRCS:=$(wildcard *.c snes/*.c)

+SRCS:=$(wildcard *.c snes/*.c) third_party/gl_core/gl_core_3_1.c

 OBJS:=$(SRCS:%.c=%.o)

 PYTHON:=/usr/bin/env python3

-CFLAGS:=$(if $(CFLAGS),$(CFLAGS),-O2)

+CFLAGS:=$(if $(CFLAGS),$(CFLAGS),-O2 -Werror)

 CFLAGS:=${CFLAGS} $(shell sdl2-config --cflags) -DSYSTEM_VOLUME_MIXER_AVAILABLE=0

 LDFLAGS:=${LDFLAGS} $(shell sdl2-config --libs)

--- a/config.c

+++ b/config.c

@@ -4,8 +4,8 @@

 #include <string.h>

 #include <SDL.h>

 #include "features.h"

+#include "util.h"

-

 enum {

   kKeyMod_ScanCode = 0x200,

   kKeyMod_Alt = 0x400,

@@ -114,41 +114,6 @@

   return KeyMapHash_Find(key);

 }

-static char *NextDelim(char **s, int sep) {

-  char *r = *s;

-  if (r) {

-    while (r[0] == ' ' || r[0] == '\t')

-      r++;

-    char *t = strchr(r, sep);

-    *s = t ? (*t++ = 0, t) : NULL;

-  }

-  return r;

-}

-

-static inline int ToLower(int a) {

-  return a + (a >= 'A' && a <= 'Z') * 32;

-}

-

-static bool StringEqualsNoCase(const char *a, const char *b) {

-  for (;;) {

-    int aa = ToLower(*a++), bb = ToLower(*b++);

-    if (aa != bb)

-      return false;

-    if (aa == 0)

-      return true;

-  }

-}

-

-static bool StringStartsWithNoCase(const char *a, const char *b) {

-  for (;;) {

-    int aa = ToLower(*a++), bb = ToLower(*b++);

-    if (bb == 0)

-      return true;

-    if (aa != bb)

-      return false;

-  }

-}

-

 static void ParseKeyArray(char *value, int cmd, int size) {

   char *s;

   int i = 0;

@@ -177,7 +142,6 @@

   }

 }

-

 static void RegisterDefaultKeys() {

   for (int i = 0; i < countof(kKeyNameId); i++) {

     if (!has_keynameid[i]) {

@@ -188,7 +152,6 @@

   }

 }

-

 static int GetIniSection(const char *s) {

   if (StringEqualsNoCase(s, "[KeyMap]"))

     return 0;

@@ -203,15 +166,26 @@

   return -1;

 }

-static bool ParseBool(const char *value, bool *result) {

-  if (StringEqualsNoCase(value, "0") || StringEqualsNoCase(value, "false")) {

-    *result = false;

+bool ParseBool(const char *value, bool *result) {

+  bool rv = false;

+  switch (*value++ | 32) {

+  case '0': if (*value == 0) break; return false;

+  case 'f': if (StringEqualsNoCase(value, "alse")) break; return false;

+  case 'n': if (StringEqualsNoCase(value, "o")) break; return false;

+  case 'o':

+    rv = (*value | 32) == 'n';

+    if (StringEqualsNoCase(value, rv ? "n" : "ff")) break;

+    return false;

+  case '1': rv = true; if (*value == 0) break; return false;

+  case 'y': rv = true; if (StringEqualsNoCase(value, "es")) break; return false;

+  case 't': rv = true; if (StringEqualsNoCase(value, "rue")) break; return false;

+  default: return false;

+  }

+  if (result) {

+    *result = rv;

     return true;

-  } else if (StringEqualsNoCase(value, "1") || StringEqualsNoCase(value, "true")) {

-    *result = true;

-    return true;

   }

-  return false;

+  return rv;

 }

 static bool ParseBoolBit(const char *value, uint32 *data, uint32 mask) {

@@ -259,13 +233,20 @@

     } else if (StringEqualsNoCase(key, "WindowScale")) {

       g_config.window_scale = (uint8)strtol(value, (char**)NULL, 10);

       return true;

-    } else if (StringEqualsNoCase(key, "SoftwareRendering")) {

-      return ParseBool(value, &g_config.software_rendering);

+    } else if (StringEqualsNoCase(key, "OutputMethod")) {

+      g_config.output_method = StringEqualsNoCase(value, "SDL-Software") ? kOutputMethod_SDLSoftware :

+                               StringEqualsNoCase(value, "OpenGL") ? kOutputMethod_OpenGL : kOutputMethod_SDL;

+      return true;

+    } else if (StringEqualsNoCase(key, "LinearFiltering")) {

+      return ParseBool(value, &g_config.linear_filtering);

     } else if (StringEqualsNoCase(key, "NoSpriteLimits")) {

       return ParseBool(value, &g_config.no_sprite_limits);

     } else if (StringEqualsNoCase(key, "LinkGraphics")) {

       g_config.link_graphics = value;

       return true;

+    } else if (StringEqualsNoCase(key, "Shader")) {

+      g_config.shader = *value ? value : NULL;

+      return true;

     }

   } else if (section == 2) {

     if (StringEqualsNoCase(key, "EnableAudio")) {

@@ -351,53 +332,20 @@

   return false;

 }

-

-uint8 *ReadFile(const char *name, size_t *length) {

-  FILE *f = fopen(name, "rb");

-  if (f == NULL)

-    return NULL;

-  fseek(f, 0, SEEK_END);

-  size_t size = ftell(f);

-  rewind(f);

-  uint8 *buffer = (uint8 *)malloc(size + 1);

-  if (!buffer) Die("malloc failed");

-  // Always zero terminate so this function can be used also for strings.

-  buffer[size] = 0;

-  if (fread(buffer, 1, size, f) != size)

-    Die("fread failed");

-  fclose(f);

-  if (length) *length = size;

-  return buffer;

-}

-

 void ParseConfigFile() {

-  uint8 *file = ReadFile("zelda3.user.ini", NULL);

-  if (!file) {

-    file = ReadFile("zelda3.ini", NULL);

-    if (!file)

+  char *filedata = (char*)ReadWholeFile("zelda3.user.ini", NULL), *p;

+  if (!filedata) {

+    filedata = (char *)ReadWholeFile("zelda3.ini", NULL);

+    if (!filedata)

       return;

   }

   fprintf(stderr, "Loading zelda3.ini\n");

   int section = -2;

-  int lineno = 1;

-  char *p, *next_p = (char*)file;

-  for (; (p = next_p) != NULL; lineno++) {

-    // find end of line

-    char *eol = strchr(p, '\n');

-    next_p = eol ? eol + 1 : NULL;

-    eol = eol ? eol : p + strlen(p);

-    // strip comments

-    char *comment = memchr(p, '#', eol - p);

-    eol = (comment != 0) ? comment : eol;

-    // strip trailing whitespace

-    while (eol > p && (eol[-1] == '\r' || eol[-1] == ' ' || eol[-1] == '\t'))

-      eol--;

-    *eol = 0;

-    if (p == eol)

+  g_config.memory_buffer = filedata;

+

+  for (int lineno = 1; (p = NextLineStripComments(&filedata)) != NULL; lineno++) {

+    if (*p == 0)

       continue; // empty line

-    // strip leading whitespace

-    while (p[0] == ' ' || p[0] == '\t')

-      p++;

     if (*p == '[') {

       section = GetIniSection(p);

       if (section < 0)

@@ -405,23 +353,15 @@

     } else if (section == -2) {

       fprintf(stderr, "zelda3.ini:%d: Expecting [section]\n", lineno);

     } else {

-      char *equals = memchr(p, '=', eol - p);

-      if (equals == NULL) {

+      char *v = SplitKeyValue(p);

+      if (v == NULL) {

         fprintf(stderr, "zelda3.ini:%d: Expecting 'key=value'\n", lineno);

-      } else {

-        char *kr = equals;

-        while (kr > p && (kr[-1] == ' ' || kr[-1] == '\t'))

-          kr--;

-        *kr = 0;

-        char *v = equals + 1;

-        while (v[0] == ' ' || v[0] == '\t')

-          v++;

-        if (section >= 0 && !HandleIniConfig(section, p, v))

-          fprintf(stderr, "zelda3.ini:%d: Can't parse '%s'\n", lineno, p);

+        continue;

       }

+      if (section >= 0 && !HandleIniConfig(section, p, v))

+        fprintf(stderr, "zelda3.ini:%d: Can't parse '%s'\n", lineno, p);

     }

   }

-  g_config.memory_buffer = file;

 }

 void AfterConfigParse() {

--- a/config.h

+++ b/config.h

@@ -36,6 +36,12 @@

   kKeys_Total,

 };

+enum {

+  kOutputMethod_SDL,

+  kOutputMethod_SDLSoftware,

+  kOutputMethod_OpenGL,

+};

+

 typedef struct Config {

   int window_width;

   int window_height;

@@ -44,8 +50,9 @@

   bool ignore_aspect_ratio;

   uint8 fullscreen;

   uint8 window_scale;

-  bool software_rendering;

   bool enable_audio;

+  bool linear_filtering;

+  uint8 output_method;

   uint16 audio_freq;

   uint8 audio_channels;

   uint16 audio_samples;

@@ -59,13 +66,12 @@

   uint32 features0;

   const char *link_graphics;

-  uint8 *memory_buffer;

+  char *memory_buffer;

+  char *shader;

 } Config;

 extern Config g_config;

-uint8 *ReadFile(const char *name, size_t *length);

 void ParseConfigFile();

 void AfterConfigParse();

-

-int FindCmdForSdlKey(SDL_Keycode code, SDL_Keymod mod);

\ No newline at end of file

+int FindCmdForSdlKey(SDL_Keycode code, SDL_Keymod mod);

--- /dev/null

+++ b/glsl_shader.c

@@ -1,0 +1,601 @@

+// This file is heavily influenced by Snes9x

+#include "third_party/gl_core/gl_core_3_1.h"

+#include "glsl_shader.h"

+#include "util.h"

+#include "config.h"

+#include <stdio.h>

+#include <assert.h>

+#include <string.h>

+

+static GlslPass *ParseConfigKeyPass(GlslShader *gs, const char *key, const char *match) {

+  char *endp;

+  for (; *match; key++, match++) {

+    if (*key != *match)

+      return NULL;

+  }

+  if ((uint8)(*key - '0') >= 10)

+    return NULL;

+  uint pass = strtoul(key, &endp, 10);

+  if (pass >= gs->n_pass || *endp != 0)

+    return NULL;

+  return gs->pass + pass + 1;

+}

+

+static uint8 ParseScaleType(const char *s) {

+  return StringEqualsNoCase(s, "source") ? GLSL_SOURCE : 

+         StringEqualsNoCase(s, "viewport") ? GLSL_VIEWPORT :

+         StringEqualsNoCase(s, "absolute") ? GLSL_ABSOLUTE : GLSL_NONE;

+}

+

+static uint ParseWrapMode(const char *s) {

+  return StringEqualsNoCase(s, "repeat") ? GL_REPEAT :

+         StringEqualsNoCase(s, "clamp_to_edge") ? GL_CLAMP_TO_EDGE :

+         StringEqualsNoCase(s, "clamp") ? GL_CLAMP : GL_CLAMP_TO_BORDER;

+}

+

+static void GlslPass_Initialize(GlslPass *pass) {

+  pass->scale_x = 1.0f;

+  pass->scale_y = 1.0f;

+  pass->wrap_mode = GL_CLAMP_TO_BORDER;

+}

+

+static void ParseTextures(GlslShader *gs, char *value) {

+  char *id;

+  GlslTexture **nextp = &gs->first_texture;

+  for (int num = 0; (id = NextDelim(&value, ';')) != NULL && num < kGlslMaxTextures; num++) {

+    GlslTexture *t = calloc(sizeof(GlslTexture), 1);

+    t->id = strdup(id);

+    t->wrap_mode = GL_CLAMP_TO_BORDER;

+    t->filter = GL_NEAREST;

+    *nextp = t;

+    nextp = &t->next;

+  }

+}

+

+static bool ParseTextureKeyValue(GlslShader *gs, const char *key, const char *value) {

+  for (GlslTexture *t = gs->first_texture; t != NULL; t = t->next) {

+    const char *key2 = SkipPrefix(key, t->id);

+    if (!key2) continue;

+    if (*key2 == 0) {

+      StrSet(&t->filename, value);

+      return true;

+    } else if (!strcmp(key2, "_wrap_mode")) {

+      t->wrap_mode = ParseWrapMode(value);

+      return true;

+    } else if (!strcmp(key2, "_mipmap")) {

+      t->mipmap = ParseBool(value, NULL);

+      return true;

+    } else if (!strcmp(key2, "_linear")) {

+      t->filter = ParseBool(value, NULL) ? GL_LINEAR : GL_NEAREST;

+      return true;

+    }

+  }

+  return false;

+}

+

+static GlslParam *GlslShader_GetParam(GlslShader *gs, const char *id) {

+  GlslParam **pp = &gs->first_param;

+  for (; (*pp) != NULL; pp = &(*pp)->next)

+    if (!strcmp((*pp)->id, id))

+      return *pp;

+  GlslParam *p = (GlslParam *)calloc(1, sizeof(GlslParam));

+  *pp = p;

+  p->id = strdup(id);

+  return p;

+}

+

+static void ParseParameters(GlslShader *gs, char *value) {

+  char *id;

+  while ((id = NextDelim(&value, ';')) != NULL)

+    GlslShader_GetParam(gs, id);

+}

+

+static bool ParseParameterKeyValue(GlslShader *gs, const char *key, const char *value) {

+  for (GlslParam *p = gs->first_param; p != NULL; p = p->next) {

+    if (strcmp(p->id, key) == 0) {

+      p->value = atof(value);

+      p->has_value = true;

+      return true;

+    }

+  }

+  return false;

+}

+

+static void GlslShader_InitializePasses(GlslShader *gs, int passes) {

+  gs->n_pass = passes;

+  gs->pass = (GlslPass *)calloc(gs->n_pass + 1, sizeof(GlslPass));

+  for (int i = 0; i < gs->n_pass; i++)

+    GlslPass_Initialize(gs->pass + i + 1);

+}

+

+static bool GlslShader_ReadPresetFile(GlslShader *gs, const char *filename) {

+  bool return_value = false;

+  char *data = (char *)ReadWholeFile(filename, NULL), *data_org = data, *line;

+  GlslPass *pass;

+  if (data == NULL)

+    return false;

+  for (int lineno = 1; (line = NextLineStripComments(&data)) != NULL; lineno++) {

+    char *value = SplitKeyValue(line), *t;

+    if (value == NULL) {

+      if (*line)

+        fprintf(stderr, "%s:%d: Expecting key=value\n", filename, lineno);

+      continue;

+    }

+    if (*value == '"') {

+      for (t = ++value; *t && *t != '"'; t++);

+      if (*t) *t = 0;

+    }

+

+    if (gs->n_pass == 0) {

+      if (strcmp(line, "shaders") != 0) {

+        fprintf(stderr, "%s:%d: Expecting 'shaders'\n", filename, lineno);

+        break;

+      }

+      int passes = strtoul(value, NULL, 10);

+      if (passes < 1 || passes > kGlslMaxPasses)

+        break;

+      GlslShader_InitializePasses(gs, passes);

+      continue;

+    }

+    if ((pass = ParseConfigKeyPass(gs, line, "filter_linear")) != NULL)

+      pass->filter = ParseBool(value, NULL) ? GL_LINEAR : GL_NEAREST;

+    else if ((pass = ParseConfigKeyPass(gs, line, "scale_type")) != NULL)

+      pass->scale_type_x = pass->scale_type_y = ParseScaleType(value);

+    else if ((pass = ParseConfigKeyPass(gs, line, "scale_type_x")) != NULL)

+      pass->scale_type_x = ParseScaleType(value);

+    else if ((pass = ParseConfigKeyPass(gs, line, "scale_type_y")) != NULL)

+      pass->scale_type_y = ParseScaleType(value);

+    else if ((pass = ParseConfigKeyPass(gs, line, "scale")) != NULL)

+      pass->scale_x = pass->scale_y = atof(value);

+    else if ((pass = ParseConfigKeyPass(gs, line, "scale_x")) != NULL)

+      pass->scale_x = atof(value);

+    else if ((pass = ParseConfigKeyPass(gs, line, "scale_y")) != NULL)

+      pass->scale_y = atof(value);

+    else if ((pass = ParseConfigKeyPass(gs, line, "shader")) != NULL)

+      StrSet(&pass->filename, value);

+    else if ((pass = ParseConfigKeyPass(gs, line, "wrap_mode")) != NULL)

+      pass->wrap_mode = ParseWrapMode(value);

+    else if ((pass = ParseConfigKeyPass(gs, line, "mipmap_input")) != NULL)

+      pass->mipmap_input = ParseBool(value, NULL);

+    else if ((pass = ParseConfigKeyPass(gs, line, "frame_count_mod")) != NULL)

+      pass->frame_count_mod = atoi(value);

+    else if ((pass = ParseConfigKeyPass(gs, line, "float_framebuffer")) != NULL)

+      pass->float_framebuffer = ParseBool(value, NULL);

+    else if ((pass = ParseConfigKeyPass(gs, line, "srgb_framebuffer")) != NULL)

+      pass->srgb_framebuffer = ParseBool(value, NULL);

+    else if ((pass = ParseConfigKeyPass(gs, line, "alias")) != NULL)

+      ;

+    else if (strcmp(line, "textures") == 0 && gs->first_texture == NULL)

+      ParseTextures(gs, value);

+    else if (strcmp(line, "parameters") == 0)

+      ParseParameters(gs, value);

+    else if (!ParseTextureKeyValue(gs, line, value) && !ParseParameterKeyValue(gs, line, value))

+      fprintf(stderr, "%s:%d: Unknown key '%s'\n", filename, lineno, line);

+  }

+  free(data_org);

+  return gs->n_pass != 0;

+}

+

+void GlslShader_ReadShaderFile(GlslShader *gs, const char *filename, ByteArray *result) {

+  char *data = (char *)ReadWholeFile(filename, NULL), *data_org = data, *line;

+  if (data == NULL) {

+    fprintf(stderr, "Unable to read file '%s'\n", filename);

+    return;

+  }

+  while ((line = NextDelim(&data, '\n')) != NULL) {

+    size_t linelen = strlen(line);

+    if (linelen >= 8 && memcmp(line, "#include", 8) == 0) {

+      char *tt = line + 8;

+      char *new_filename = ReplaceFilenameWithNewPath(filename, NextPossiblyQuotedString(&tt));

+      GlslShader_ReadShaderFile(gs, new_filename, result);

+      free(new_filename);

+    } else if (linelen >= 17 && memcmp(line, "#pragma parameter", 17) == 0) {

+      char *tt = line + 17;

+      GlslParam *param = GlslShader_GetParam(gs, NextPossiblyQuotedString(&tt));

+      NextPossiblyQuotedString(&tt); // skip name

+      float value = atof(NextPossiblyQuotedString(&tt));

+      if (!param->has_value)

+        param->value = value;

+      param->min = atof(NextPossiblyQuotedString(&tt));

+      param->max = atof(NextPossiblyQuotedString(&tt));

+      // skip step

+    } else {

+      line[linelen] = '\n';

+      ByteArray_AppendData(result, (uint8 *)line, linelen + 1);

+    }

+  }

+  free(data_org);

+}

+

+static bool GlslPass_Compile(GlslPass *p, uint type, const uint8 *data, size_t size) {

+  static const char kVertexPrefix[] =   "#define VERTEX\n#define PARAMETER_UNIFORM\n";

+  static const char kFragmentPrefix[] = "#define FRAGMENT\n#define PARAMETER_UNIFORM\n";

+  const GLchar *strings[3];

+  GLint lengths[3];

+  char buffer[256];

+  GLint compile_status = 0;

+  size_t skip = 0;

+

+  if (size < 8 || memcmp(data, "#version", 8) != 0) {

+    strings[0] = "#version 330\n";

+    lengths[0] = sizeof("#version 330\n") - 1;

+  } else {

+    while (skip < size && data[skip++] != '\n') {}

+    strings[0] = (char*)data;

+    lengths[0] = (int)skip;

+  }

+  strings[1] = (type == GL_VERTEX_SHADER) ? (char*)kVertexPrefix : kFragmentPrefix;

+  lengths[1] = (type == GL_VERTEX_SHADER) ? sizeof(kVertexPrefix) - 1 : sizeof(kFragmentPrefix) - 1;

+  strings[2] = (GLchar *)data + skip;

+  lengths[2] = (int)(size - skip);

+  uint shader = glCreateShader(type);

+  glShaderSource(shader, 3, strings, lengths);

+  glCompileShader(shader);

+  glGetShaderiv(shader, GL_COMPILE_STATUS, &compile_status);

+  buffer[0] = 0;

+  glGetShaderInfoLog(shader, sizeof(buffer), NULL, buffer);

+  if (compile_status != GL_TRUE || buffer[0]) {

+    fprintf(stderr, "%s compiling %s shader in file '%s':\n%s\n",

+            compile_status != GL_TRUE ? "Error" : "While",

+            type == GL_VERTEX_SHADER ? "vertex" : "fragment", p->filename, buffer);

+  }

+  if (compile_status == GL_TRUE)

+    glAttachShader(p->gl_program, shader);

+  glDeleteShader(shader);

+  return (compile_status == GL_TRUE);

+}

+

+static void GlslTextureUniform_Read(uint program, const char *prefix, int i, GlslTextureUniform *result) {

+  char buf[40];

+  char *e = &buf[snprintf(buf, sizeof(buf), i >= 0 ? "%s%u" : "%s", prefix, i)];

+  memcpy(e, "Texture", 8);

+  result->Texture = glGetUniformLocation(program, buf);

+  memcpy(e, "InputSize", 10);

+  result->InputSize = glGetUniformLocation(program, buf);

+  memcpy(e, "TextureSize", 12);

+  result->TextureSize = glGetUniformLocation(program, buf);

+  memcpy(e, "TexCoord", 9);

+  result->TexCoord = glGetAttribLocation(program, buf);

+}

+

+static const float kMvpMatrixOrtho[16] = {

+   2.0f,  0.0f,  0.0f,  0.0f,

+   0.0f,  2.0f,  0.0f,  0.0f,

+   0.0f,  0.0f, -1.0f,  0.0f,

+  -1.0f, -1.0f,  0.0f,  1.0f

+};

+

+static void GlslShader_GetUniforms(GlslShader *gs) {

+  int pass_idx = 1;

+  gs->max_prev_frame = 0;

+  for (GlslPass *p = gs->pass + 1, *p_end = p + gs->n_pass; p < p_end; p++, pass_idx++) {

+    uint program = p->gl_program;

+    glUseProgram(program);

+

+    GLint MVPMatrix = glGetUniformLocation(program, "MVPMatrix");

+    if (MVPMatrix >= 0)

+      glUniformMatrix4fv(MVPMatrix, 1, GL_FALSE, kMvpMatrixOrtho);

+

+    GlslTextureUniform_Read(program, "", -1, &p->unif.Top);

+    p->unif.OutputSize = glGetUniformLocation(program, "OutputSize");

+    p->unif.FrameCount = glGetUniformLocation(program, "FrameCount");

+    p->unif.FrameDirection = glGetUniformLocation(program, "FrameDirection");

+    p->unif.LUTTexCoord = glGetAttribLocation(program, "LUTTexCoord");

+    p->unif.VertexCoord = glGetAttribLocation(program, "VertexCoord");

+    GlslTextureUniform_Read(program, "Orig", -1, &p->unif.Orig);

+    for (int j = 0; j < 7; j++) {

+      GlslTextureUniform_Read(program, "Prev", j ? j : -1, &p->unif.Prev[j]);

+      if (p->unif.Prev[j].Texture >= 0)

+        gs->max_prev_frame = j + 1;

+    }

+    for (int j = 0; j < gs->n_pass; j++) {

+      GlslTextureUniform_Read(program, "Pass", j, &p->unif.Pass[j]);

+      GlslTextureUniform_Read(program, "PassPrev", j, &p->unif.PassPrev[j]);

+    }

+    GlslTexture *t = gs->first_texture;

+    for (int j = 0; t != NULL; t = t->next, j++)

+      p->unif.Texture[j] = glGetUniformLocation(program, t->id);

+    for (GlslParam *pa = gs->first_param; pa != NULL; pa = pa->next)

+      pa->uniform[pass_idx] = glGetUniformLocation(program, pa->id);

+  }

+  glUseProgram(0);

+}

+

+static bool IsGlslFilename(const char *filename) {

+  size_t len = strlen(filename);

+  return len >= 5 && memcmp(filename + len - 5, ".glsl", 5) == 0;

+}

+

+GlslShader *GlslShader_CreateFromFile(const char *filename) {

+  char buffer[256];

+  GLint link_status;

+  ByteArray shader_code = { 0 };

+  bool success = false;

+  GlslShader *gs = (GlslShader *)calloc(sizeof(GlslShader), 1);

+  if (!gs)

+    return gs;

+

+  if (IsGlslFilename(filename)) {

+    GlslShader_InitializePasses(gs, 1);

+    gs->pass[1].filename = strdup(filename);

+    filename = "";

+  } else {

+    if (!GlslShader_ReadPresetFile(gs, filename)) {

+      fprintf(stderr, "Unable to read file '%s'\n", filename);

+      goto FAIL;

+    }

+  }

+  for (int i = 1; i <= gs->n_pass; i++) {

+    GlslPass *p = gs->pass + i;

+    shader_code.size = 0;

+

+    if (p->filename == NULL) {

+      fprintf(stderr, "shader%d attribute missing\n", i - 1);

+      goto FAIL;

+    }

+

+    char *new_filename = ReplaceFilenameWithNewPath(filename, p->filename);

+    GlslShader_ReadShaderFile(gs, new_filename, &shader_code);

+    free(new_filename);

+

+    if (shader_code.size == 0) {

+      fprintf(stderr, "Couldn't read shader in file '%s'\n", p->filename);

+      goto FAIL;

+    }

+    p->gl_program = glCreateProgram();

+    if (!GlslPass_Compile(p, GL_VERTEX_SHADER, shader_code.data, shader_code.size) ||

+        !GlslPass_Compile(p, GL_FRAGMENT_SHADER, shader_code.data, shader_code.size)) {

+      goto FAIL;

+    }

+    glLinkProgram(p->gl_program);

+    glGetProgramiv(p->gl_program, GL_LINK_STATUS, &link_status);

+    buffer[0] = 0;

+    glGetProgramInfoLog(p->gl_program, sizeof(buffer), NULL, buffer);

+    if (link_status != GL_TRUE || buffer[0])

+      fprintf(stderr, "%s linking shader in file '%s':\n%s\n",

+              link_status != GL_TRUE ? "Error" : "While", p->filename, buffer);

+    if (link_status != GL_TRUE)

+      goto FAIL;

+    glGenFramebuffers(1, &p->gl_fbo);

+    glGenTextures(1, &p->gl_texture);

+  }

+  for (GlslTexture *t = gs->first_texture; t; t = t->next) {

+    glGenTextures(1, &t->gl_texture);

+    glBindTexture(GL_TEXTURE_2D, t->gl_texture);

+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, t->wrap_mode);

+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, t->wrap_mode);

+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, t->filter);

+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, t->mipmap ? 

+                    (t->filter == GL_LINEAR ? GL_LINEAR_MIPMAP_LINEAR : GL_NEAREST_MIPMAP_NEAREST) : t->filter);

+    // code to load png mssing

+    fprintf(stderr, "PNG file reading not supported\n");

+    if (t->mipmap)

+      glGenerateMipmap(GL_TEXTURE_2D);

+  }

+  for (GlslParam *p = gs->first_param; p; p = p->next)

+    p->value = (p->value < p->min) ? p->min : (p->value > p->max) ? p->max : p->value;

+

+  GlslShader_GetUniforms(gs);

+

+  for (int i = 0; i < gs->max_prev_frame; i++)

+    glGenTextures(1, &gs->prev_frame[-i - 1 & 7].gl_texture);

+

+  static const GLfloat kTexCoords[16] = {

+    0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f,

+    0.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f

+  };

+  glGenBuffers(1, &gs->gl_vbo);

+  glBindBuffer(GL_ARRAY_BUFFER, gs->gl_vbo);

+  glBufferData(GL_ARRAY_BUFFER, sizeof(kTexCoords), kTexCoords, GL_STATIC_DRAW);

+  glBindBuffer(GL_ARRAY_BUFFER, 0);

+

+  success = true;

+FAIL:

+  if (!success) {

+    GlslShader_Destroy(gs);

+    gs = NULL;

+  }

+  ByteArray_Destroy(&shader_code);

+  return gs;

+}

+

+void GlslShader_Destroy(GlslShader *gs) {

+  for (GlslPass *p = gs->pass + 1, *p_end = p + gs->n_pass; p < p_end; p++) {

+    glDeleteProgram(p->gl_program);

+    glDeleteTextures(1, &p->gl_texture);

+    glDeleteFramebuffers(1, &p->gl_fbo);

+    free(p->filename);

+  }

+  free(gs->pass);

+  GlslTexture *t;

+  while ((t = gs->first_texture) != NULL) {

+    gs->first_texture = t->next;

+    glDeleteTextures(1, &t->gl_texture);

+    free(t->id);

+    free(t->filename);

+    free(t);

+  }

+  GlslParam *pp;

+  while ((pp = gs->first_param) != NULL) {

+    gs->first_param = pp->next;

+    free(pp->id);

+    free(pp);

+  }

+  for (int i = 0; i < 8; i++)

+    glDeleteTextures(1, &gs->prev_frame[i].gl_texture);

+  glDeleteBuffers(1, &gs->gl_vbo);

+  free(gs);

+}

+

+enum {

+  kMaxVaosInRenderCtx = 11 + kGlslMaxPasses * 2

+};

+

+typedef struct RenderCtx {

+  uint texture_unit;

+  uint offset;

+  uint num_vaos;

+  uint vaos[kMaxVaosInRenderCtx];

+} RenderCtx;

+

+static void RenderCtx_SetTexture(RenderCtx *ctx, int textureu, uint texture_id) {

+  if (textureu >= 0) {

+    glActiveTexture(GL_TEXTURE0 + ctx->texture_unit);

+    glBindTexture(GL_TEXTURE_2D, texture_id);

+    glUniform1i(textureu, ctx->texture_unit++);

+  }

+}

+

+static void RenderCtx_SetTexCoords(RenderCtx *ctx, int tex_coord, uintptr_t offset) {

+  if (tex_coord >= 0) {

+    assert(ctx->num_vaos < kMaxVaosInRenderCtx);

+    ctx->vaos[ctx->num_vaos++] = tex_coord;

+    glVertexAttribPointer(tex_coord, 2, GL_FLOAT, GL_FALSE, 0, (void *)offset);

+    glEnableVertexAttribArray(tex_coord);

+  }

+}

+

+static void RenderCtx_SetGlslTextureUniform(RenderCtx *ctx, GlslTextureUniform *u,

+                                            int width, int height, uint texture) {

+  float size[2] = { width, height };

+  RenderCtx_SetTexture(ctx, u->Texture, texture);

+  if (u->InputSize >= 0)

+    glUniform2fv(u->InputSize, 1, size);

+  if (u->TextureSize >= 0)

+    glUniform2fv(u->TextureSize, 1, size);

+  RenderCtx_SetTexCoords(ctx, u->TexCoord, ctx->offset);

+}

+

+static void GlslShader_SetShaderVars(GlslShader *gs, RenderCtx *ctx, int pass) {

+  GlslPass *p = &gs->pass[pass];

+    

+  RenderCtx_SetGlslTextureUniform(ctx, &p->unif.Top, p[-1].width, p[-1].height, p[-1].gl_texture);

+  if (p->unif.OutputSize >= 0) {

+    float output_size[2] = { (float)p[0].width, (float)p[0].height };

+    glUniform2fv(p->unif.OutputSize, 1, output_size);

+  }

+  if (p->unif.FrameCount >= 0)

+    glUniform1i(p->unif.FrameCount, p->frame_count_mod ? 

+                gs->frame_count % p->frame_count_mod : gs->frame_count);

+  if (p->unif.FrameDirection >= 0)

+    glUniform1i(p->unif.FrameDirection, 1);

+  RenderCtx_SetTexCoords(ctx, p->unif.LUTTexCoord, ctx->offset);

+  RenderCtx_SetTexCoords(ctx, p->unif.VertexCoord, 0);

+  RenderCtx_SetGlslTextureUniform(ctx, &p->unif.Orig, gs->pass[0].width, gs->pass[0].height, gs->pass[0].gl_texture);

+  // Prev, Prev1-Prev6 uniforms

+  for (int i = 0; i < gs->max_prev_frame; i++) {

+    GlTextureWithSize *t = &gs->prev_frame[(gs->frame_count - 1 - i) & 7];

+    assert(t->gl_texture != 0);

+    if (t->width)

+      RenderCtx_SetGlslTextureUniform(ctx, &p->unif.Prev[i], t->width, t->height, t->gl_texture);

+  }

+  // Texture uniforms

+  int tctr = 0;

+  for (GlslTexture *t = gs->first_texture; t; t = t->next, tctr++)

+    RenderCtx_SetTexture(ctx, p->unif.Texture[tctr], t->gl_texture);

+  // PassX uniforms

+  for (int i = 1; i < pass; i++)

+    RenderCtx_SetGlslTextureUniform(ctx, &p->unif.Pass[i], gs->pass[i].width, gs->pass[i].height, gs->pass[i].gl_texture);

+  // PassPrevX uniforms

+  for (int i = 1; i < pass; i++)

+    RenderCtx_SetGlslTextureUniform(ctx, &p->unif.PassPrev[pass - i], gs->pass[i].width, gs->pass[i].height, gs->pass[i].gl_texture);

+  // #parameter uniforms

+  for (GlslParam *pa = gs->first_param; pa != NULL; pa = pa->next)

+    if (pa->uniform[pass] >= 0)

+      glUniform1f(pa->uniform[pass], pa->value);

+

+  glActiveTexture(GL_TEXTURE0);

+}

+

+void GlslShader_Render(GlslShader *gs, GlTextureWithSize *tex, int viewport_x, int viewport_y, int viewport_width, int viewport_height) {

+  gs->pass[0].gl_texture = tex->gl_texture;

+  gs->pass[0].width = tex->width;

+  gs->pass[0].height = tex->height;

+

+  GLint previous_framebuffer;

+  glGetIntegerv(GL_FRAMEBUFFER_BINDING, &previous_framebuffer);

+  glBindBuffer(GL_ARRAY_BUFFER, gs->gl_vbo);

+

+  for (int pass = 1; pass <= gs->n_pass; pass++) {

+    bool last_pass = pass == gs->n_pass;

+    GlslPass *p = gs->pass + pass;

+

+    switch (p->scale_type_x) {

+    case GLSL_ABSOLUTE: p->width = (uint16)p->scale_x; break;

+    case GLSL_SOURCE: p->width = (uint16)(p[-1].width * p->scale_x); break;

+    case GLSL_VIEWPORT: p->width = (uint16)(viewport_width * p->scale_x); break;

+    default: p->width = (uint16)(last_pass ? viewport_width : (p[-1].width * p->scale_x)); break;

+    }

+

+    switch (p->scale_type_y) {

+    case GLSL_ABSOLUTE: p->height = (uint16)p->scale_y; break;

+    case GLSL_SOURCE: p->height = (uint16)(p[-1].height * p->scale_y); break;

+    case GLSL_VIEWPORT: p->height = (uint16)(viewport_height * p->scale_y); break;

+    default: p->height = (uint16)(last_pass ? viewport_height : (p[-1].height * p->scale_y)); break;

+    }

+

+    if (!last_pass) {

+      // output to a texture

+      glBindTexture(GL_TEXTURE_2D, p->gl_texture);

+      if (p->srgb_framebuffer) {

+        glEnable(GL_FRAMEBUFFER_SRGB);

+        glTexImage2D(GL_TEXTURE_2D, 0, GL_SRGB8_ALPHA8, p->width, p->height, 0, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, NULL);

+      } else {

+        glTexImage2D(GL_TEXTURE_2D, 0, p->float_framebuffer ? GL_RGBA32F : GL_RGBA,

+                     p->width, p->height, 0, GL_RGBA,

+                     p->float_framebuffer ? GL_FLOAT : GL_UNSIGNED_INT_8_8_8_8, NULL);

+      }

+      glViewport(0, 0, p->width, p->height);

+      glBindFramebuffer(GL_FRAMEBUFFER, p->gl_fbo);

+      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, p->gl_texture, 0);

+    } else {

+      // output to screen

+      glBindFramebuffer(GL_FRAMEBUFFER, previous_framebuffer);

+      glViewport(viewport_x, viewport_y, viewport_width, viewport_height);

+    }

+

+    glBindTexture(GL_TEXTURE_2D, p[-1].gl_texture);

+

+    uint filter = p->filter ? p->filter : (last_pass && g_config.linear_filtering) ? GL_LINEAR : GL_NEAREST;

+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filter);

+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, p->mipmap_input ? 

+                    (filter == GL_LINEAR ? GL_LINEAR_MIPMAP_LINEAR : GL_NEAREST_MIPMAP_NEAREST) : filter);

+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, p->wrap_mode);

+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, p->wrap_mode);

+    if (p->mipmap_input)

+      glGenerateMipmap(GL_TEXTURE_2D);

+    glUseProgram(p->gl_program);

+

+    RenderCtx ctx;

+    ctx.texture_unit = ctx.num_vaos = 0;

+    ctx.offset = last_pass ? sizeof(float) * 8 : 0;

+    GlslShader_SetShaderVars(gs, &ctx, pass);

+    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

+    for(int i = 0; i < ctx.num_vaos; i++)

+      glDisableVertexAttribArray(ctx.vaos[i]);

+    if (p->srgb_framebuffer)

+      glDisable(GL_FRAMEBUFFER_SRGB);

+  }

+

+  glBindFramebuffer(GL_FRAMEBUFFER, previous_framebuffer);

+  glUseProgram(0);

+  glBindTexture(GL_TEXTURE_2D, 0);

+  glBindBuffer(GL_ARRAY_BUFFER, 0);

+

+  // Store the input frame in the prev array, and extract the next one.

+  if (gs->max_prev_frame != 0) {

+    // 01234567

+    //    43210

+    // ^-- store pos

+    //    ^-- load pos

+    GlTextureWithSize *store_pos = &gs->prev_frame[gs->frame_count & 7];

+    GlTextureWithSize *load_pos = &gs->prev_frame[gs->frame_count - gs->max_prev_frame & 7];

+    assert(store_pos->gl_texture == 0);

+    *store_pos = *tex;

+    *tex = *load_pos;

+    memset(load_pos, 0, sizeof(GlTextureWithSize));

+  }

+

+  gs->frame_count++;

+}

+

--- /dev/null

+++ b/glsl_shader.h

@@ -1,0 +1,99 @@

+#ifndef ZELDA3_GLSL_SHADER_H_

+#define ZELDA3_GLSL_SHADER_H_

+

+#include "types.h"

+

+enum {

+  kGlslMaxPasses = 20,

+  kGlslMaxTextures = 10,

+};

+

+enum GLSLScaleType {

+  GLSL_NONE,

+  GLSL_SOURCE,

+  GLSL_VIEWPORT,

+  GLSL_ABSOLUTE

+};

+

+typedef struct GlslTextureUniform {

+  int Texture;

+  int InputSize;

+  int TextureSize;

+  int TexCoord;

+} GlslTextureUniform;

+

+typedef struct GlslUniforms {

+  GlslTextureUniform Top;

+  int OutputSize;

+  int FrameCount, FrameDirection;

+  int LUTTexCoord;

+  int VertexCoord;

+  GlslTextureUniform Orig;

+  GlslTextureUniform Prev[7];

+  GlslTextureUniform Pass[kGlslMaxPasses];

+  GlslTextureUniform PassPrev[kGlslMaxPasses];

+  int Texture[kGlslMaxTextures];

+} GlslUniforms;

+

+typedef struct GlslPass {

+  char *filename;

+  uint8 scale_type_x, scale_type_y;

+  bool float_framebuffer;

+  bool srgb_framebuffer;

+  bool mipmap_input;

+  float scale_x, scale_y;

+  uint wrap_mode;

+  uint frame_count_mod;

+  uint frame_count;

+  uint gl_program, gl_fbo;

+  uint filter;

+  uint gl_texture;

+  uint16 width, height;

+  GlslUniforms unif;

+} GlslPass;

+

+typedef struct GlTextureWithSize {

+  uint gl_texture;

+  uint16 width, height;

+} GlTextureWithSize;

+

+typedef struct GlslTexture {

+  struct GlslTexture *next;

+  char *id;

+  char *filename;

+  uint filter;

+  uint gl_texture;

+  uint wrap_mode;

+  bool mipmap;

+  int width;

+  int height;

+} GlslTexture;

+

+typedef struct GlslParam {

+  struct GlslParam *next;

+  char *id;

+  bool has_value;

+  float value;

+  float min;

+  float max;

+  uint uniform[kGlslMaxPasses];

+} GlslParam;

+

+typedef struct GlslShader {

+  int n_pass;

+  GlslPass *pass;

+  GlslParam *first_param;

+  GlslTexture *first_texture;

+  uint *gl_vao;

+  uint gl_vbo;

+  uint frame_count;

+  int max_prev_frame;

+  GlTextureWithSize prev_frame[8];

+} GlslShader;

+

+GlslShader *GlslShader_CreateFromFile(const char *filename);

+void GlslShader_Destroy(GlslShader *gs);

+void GlslShader_Render(GlslShader *gs, GlTextureWithSize *tex, int viewport_x, int viewport_y, int viewport_width, int viewport_height);

+

+

+#endif  // ZELDA3_GLSL_SHADER_H_

--- a/main.c

+++ b/main.c

@@ -24,16 +24,17 @@

 #include "config.h"

 #include "assets.h"

 #include "load_gfx.h"

+#include "util.h"

-static bool g_run_without_emu = 0;

+static bool g_run_without_emu = 1;

+void ShaderInit();

-

 // Forwards

 static bool LoadRom(const char *filename);

 static void LoadLinkGraphics();

 static void PlayAudio(SDL_AudioDeviceID device, int channels, int16 *audioBuffer);

-static void RenderScreen(SDL_Window *window, SDL_Renderer *renderer, SDL_Texture *texture, bool fullscreen);

+static void RenderNumber(uint8 *dst, size_t pitch, int n, bool big);

 static void HandleInput(int keyCode, int modCode, bool pressed);

 static void HandleCommand(uint32 j, bool pressed);

 static void HandleGamepadInput(int button, bool pressed);

@@ -41,7 +42,9 @@

 static void OpenOneGamepad(int i);

 static void HandleVolumeAdjustment(int volume_adjustment);

 static void LoadAssets();

+static void SwitchDirectory();

+

 enum {

   kDefaultFullscreen = 0,

   kMaxWindowScale = 10,

@@ -54,7 +57,7 @@

 static uint32 g_win_flags = SDL_WINDOW_RESIZABLE;

 static SDL_Window *g_window;

-static SDL_Renderer *g_renderer;

+

 static uint8 g_paused, g_turbo, g_replay_turbo = true, g_cursor = true;

 static uint8 g_current_window_scale;

 static uint8 g_gamepad_buttons;

@@ -64,6 +67,7 @@

 static int g_ppu_render_flags = 0;

 static int g_snes_width, g_snes_height;

 static int g_sdl_audio_mixer_volume = SDL_MIX_MAXVOLUME;

+static struct RendererFuncs g_renderer_funcs;

 void NORETURN Die(const char *error) {

 #if defined(NDEBUG) && defined(_WIN32)

@@ -127,12 +131,19 @@

          (SDL_GetModState() & KMOD_CTRL) != 0 ? SDL_HITTEST_DRAGGABLE : SDL_HITTEST_NORMAL;

 }

-static void RenderScreenWithPerf(uint8 *pixel_buffer, size_t pitch, uint32 render_flags) {

+static void DrawPpuFrameWithPerf() {

+  int render_scale = PpuGetCurrentRenderScale(g_zenv.ppu, g_ppu_render_flags);

+  uint8 *pixel_buffer = 0;

+  int pitch = 0;

+

+  g_renderer_funcs.BeginDraw(g_snes_width * render_scale,

+                             g_snes_height * render_scale,

+                             &pixel_buffer, &pitch);

   if (g_display_perf || g_config.display_perf_title) {

     static float history[64], average;

     static int history_pos;

     uint64 before = SDL_GetPerformanceCounter();

-    ZeldaDrawPpuFrame(pixel_buffer, pitch, render_flags);

+    ZeldaDrawPpuFrame(pixel_buffer, pitch, g_ppu_render_flags);

     uint64 after = SDL_GetPerformanceCounter();

     float v = (double)SDL_GetPerformanceFrequency() / (after - before);

     average += v - history[history_pos];

@@ -140,36 +151,13 @@

     history_pos = (history_pos + 1) & 63;

     g_curr_fps = average * (1.0f / 64);

   } else {

-    ZeldaDrawPpuFrame(pixel_buffer, pitch, render_flags);

+    ZeldaDrawPpuFrame(pixel_buffer, pitch, g_ppu_render_flags);

   }

+  if (g_display_perf)

+    RenderNumber(pixel_buffer + pitch * render_scale, pitch, g_curr_fps, render_scale == 4);

+  g_renderer_funcs.EndDraw();

 }

-// Go some steps up and find zelda3.ini

-static void SwitchDirectory() {

-  char buf[4096];

-  if (!getcwd(buf, sizeof(buf) - 32))

-    return;

-  size_t pos = strlen(buf);

-

-  for (int step = 0; pos != 0 && step < 3; step++) {

-    memcpy(buf + pos, "/zelda3.ini", 12);

-    FILE *f = fopen(buf, "rb");

-    if (f) {

-      fclose(f);

-      buf[pos] = 0;

-      if (step != 0) {

-        printf("Found zelda3.ini in %s\n", buf);

-        int err = chdir(buf);

-        (void)err;

-      }

-      return;

-    }

-    pos--;

-    while (pos != 0 && buf[pos] != '/' && buf[pos] != '\\')

-      pos--;

-  }

-}

-

 static SDL_mutex *g_audio_mutex;

 static uint8 *g_audiobuffer, *g_audiobuffer_cur, *g_audiobuffer_end;

 static int g_frames_per_block;

@@ -199,8 +187,80 @@

   SDL_UnlockMutex(g_audio_mutex);

 }

+// State for sdl renderer

+static SDL_Renderer *g_renderer;

+static SDL_Texture *g_texture;

+static SDL_Rect g_sdl_renderer_rect;

+static bool SdlRenderer_Init(SDL_Window *window) {

+  if (g_config.shader)

+    fprintf(stderr, "Warning: Shaders are supported only with the OpenGL backend\n");

+

+  SDL_Renderer *renderer = SDL_CreateRenderer(g_window, -1,

+                                              g_config.output_method == kOutputMethod_SDLSoftware ? SDL_RENDERER_SOFTWARE :

+                                              SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);

+  if (renderer == NULL) {

+    printf("Failed to create renderer: %s\n", SDL_GetError());

+    return false;

+  }

+  SDL_RendererInfo renderer_info;

+  SDL_GetRendererInfo(renderer, &renderer_info);

+  if (kDebugFlag) {

+    printf("Supported texture formats:");

+    for (int i = 0; i < renderer_info.num_texture_formats; i++)

+      printf(" %s", SDL_GetPixelFormatName(renderer_info.texture_formats[i]));

+    printf("\n");

+  }

+  g_renderer = renderer;

+  if (!g_config.ignore_aspect_ratio)

+    SDL_RenderSetLogicalSize(renderer, g_snes_width, g_snes_height);

+  if (g_config.linear_filtering)

+    SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "best");

+  g_texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_ARGB8888/*SDL_PIXELFORMAT_RGBA8888*/, SDL_TEXTUREACCESS_STREAMING,

+                                g_snes_width * 4, g_snes_height * 4);

+  if (g_texture == NULL) {

+    printf("Failed to create texture: %s\n", SDL_GetError());

+    return false;

+  }

+  return true;

+}

+

+static void SdlRenderer_Destroy() {

+  SDL_DestroyTexture(g_texture);

+  SDL_DestroyRenderer(g_renderer);

+}

+

+static void SdlRenderer_BeginDraw(int width, int height, uint8 **pixels, int *pitch) {

+  g_sdl_renderer_rect.w = width;

+  g_sdl_renderer_rect.h = height;

+  if (SDL_LockTexture(g_texture, &g_sdl_renderer_rect, (void **)pixels, pitch) != 0) {

+    printf("Failed to lock texture: %s\n", SDL_GetError());

+    return;

+  }

+}

+

+static void SdlRenderer_EndDraw() {

+

+  uint64 before = SDL_GetPerformanceCounter();

+  SDL_UnlockTexture(g_texture);

+  uint64 after = SDL_GetPerformanceCounter();

+  float v = (double)(after - before) / SDL_GetPerformanceFrequency();

+//  printf("%f ms\n", v * 1000);

+  SDL_RenderClear(g_renderer);

+  SDL_RenderCopy(g_renderer, g_texture, &g_sdl_renderer_rect, NULL);

+  SDL_RenderPresent(g_renderer); // vsyncs to 60 FPS?

+}

+

+static const struct RendererFuncs kSdlRendererFuncs  = {

+  &SdlRenderer_Init,

+  &SdlRenderer_Destroy,

+  &SdlRenderer_BeginDraw,

+  &SdlRenderer_EndDraw,

+};

+

+void OpenGLRenderer_Create(struct RendererFuncs *funcs);

+

 #undef main

 int main(int argc, char** argv) {

   SwitchDirectory();

@@ -211,7 +271,7 @@

   ZeldaInitialize();

   g_zenv.ppu->extraLeftRight = UintMin(g_config.extended_aspect_ratio, kPpuExtraLeftRight);

-  g_snes_width =  (g_config.extended_aspect_ratio * 2 + 256);

+  g_snes_width = (g_config.extended_aspect_ratio * 2 + 256);

   g_snes_height = (g_config.extend_y ? 240 : 224);

@@ -254,6 +314,13 @@

   int window_width  = custom_size ? g_config.window_width  : g_current_window_scale * g_snes_width;

   int window_height = custom_size ? g_config.window_height : g_current_window_scale * g_snes_height;

+  if (g_config.output_method == kOutputMethod_OpenGL) {

+    g_win_flags |= SDL_WINDOW_OPENGL;

+    OpenGLRenderer_Create(&g_renderer_funcs);

+  } else {

+    g_renderer_funcs = kSdlRendererFuncs;

+  }

+

   SDL_Window* window = SDL_CreateWindow(kWindowTitle, SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, window_width, window_height, g_win_flags);

   if(window == NULL) {

     printf("Failed to create window: %s\n", SDL_GetError());

@@ -261,30 +328,9 @@

   }

   g_window = window;

   SDL_SetWindowHitTest(window, HitTestCallback, NULL);

-  SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, 

-      g_config.software_rendering ? SDL_RENDERER_SOFTWARE :

-                                    SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);

-  if(renderer == NULL) {

-    printf("Failed to create renderer: %s\n", SDL_GetError());

-    return 1;

-  }

-  SDL_RendererInfo renderer_info;

-  SDL_GetRendererInfo(renderer, &renderer_info);

-  printf("Supported texture formats:");

-  for (int i = 0; i < renderer_info.num_texture_formats; i++)

-    printf(" %s", SDL_GetPixelFormatName(renderer_info.texture_formats[i]));

-  printf("\n");

-

-  g_renderer = renderer;

-  if (!g_config.ignore_aspect_ratio)

-    SDL_RenderSetLogicalSize(renderer, g_snes_width, g_snes_height);

-  SDL_Texture* texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STREAMING, g_snes_width * 4, g_snes_height * 4);

-  if(texture == NULL) {

-    printf("Failed to create texture: %s\n", SDL_GetError());

+  if (!g_renderer_funcs.Initialize(window))

     return 1;

-  }

-  SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "best");

   SDL_AudioDeviceID device;

   SDL_AudioSpec want = { 0 }, have;

@@ -396,13 +442,17 @@

       continue;

     }

-    RenderScreen(window, renderer, texture, (g_win_flags & SDL_WINDOW_FULLSCREEN_DESKTOP) != 0);

-    SDL_RenderPresent(renderer); // vsyncs to 60 FPS?

+    DrawPpuFrameWithPerf();

+    if (g_config.display_perf_title) {

+      char title[60];

+      snprintf(title, sizeof(title), "%s | FPS: %d", kWindowTitle, g_curr_fps);

+      SDL_SetWindowTitle(g_window, title);

+    }

+

     // if vsync isn't working, delay manually

     curTick = SDL_GetTicks();

-

     if (!g_config.disable_frame_delay) {

       static const uint8 delays[3] = { 17, 17, 16 }; // 60 fps

       lastTick += delays[frameCtr % 3];

@@ -413,6 +463,7 @@

           lastTick = curTick - 500;

           delta = 500;

         }

+//        printf("Sleeping %d\n", delta);

         SDL_Delay(delta);

       } else if (curTick - lastTick > 500) {

         lastTick = curTick;

@@ -428,11 +479,11 @@

     SDL_CloseAudioDevice(device);

   }

-

   SDL_DestroyMutex(g_audio_mutex);

   free(g_audiobuffer);

-  SDL_DestroyTexture(texture);

-  SDL_DestroyRenderer(renderer);

+

+  g_renderer_funcs.Destroy();

+

   SDL_DestroyWindow(window);

   SDL_Quit();

   //SaveConfigFile();

@@ -484,46 +535,6 @@

     RenderDigit(dst + (i << big), pitch, *s - '0', 0xffffff, big);

 }

-static void RenderScreen(SDL_Window *window, SDL_Renderer *renderer, SDL_Texture *texture, bool fullscreen) {

-  uint8 *pixels = 0;

-  int pitch = 0;

-  int render_scale = PpuGetCurrentRenderScale(g_zenv.ppu, g_ppu_render_flags);

-  SDL_Rect src_rect = { 0, 0, g_snes_width * render_scale, g_snes_height * render_scale};

-

-  uint64 t0 = SDL_GetPerformanceCounter();

-  if(SDL_LockTexture(texture, &src_rect, (void**)&pixels, &pitch) != 0) {

-    printf("Failed to lock texture: %s\n", SDL_GetError());

-    return;

-  }

-  uint64 t1 = SDL_GetPerformanceCounter();

-  RenderScreenWithPerf(pixels, pitch, g_ppu_render_flags);

-  if (g_display_perf) {

-    RenderNumber(pixels + pitch * render_scale, pitch, g_curr_fps, render_scale == 4);

-  }

-  uint64 t2 = SDL_GetPerformanceCounter();

-  SDL_UnlockTexture(texture);

-  uint64 t3 = SDL_GetPerformanceCounter();

-  SDL_RenderClear(renderer);

-  uint64 t4 = SDL_GetPerformanceCounter();

-  SDL_RenderCopy(renderer, texture, &src_rect, NULL);

-  uint64 t5 = SDL_GetPerformanceCounter();

-

-  double f = 1e3 / (double)SDL_GetPerformanceFrequency();

-  if (0) printf("RenderPerf %6.2f %6.2f %6.2f %6.2f %6.2f\n",

-    (t1 - t0) * f,

-    (t2 - t1) * f,

-    (t3 - t2) * f,

-    (t4 - t3) * f,

-    (t5 - t4) * f

-  );

-

-  if (g_config.display_perf_title) {

-    char title[60];

-    snprintf(title, sizeof(title), "%s | FPS: %d", kWindowTitle, g_curr_fps);

-    SDL_SetWindowTitle(window, title);

-  }

-}

-

 static void HandleCommand_Locked(uint32 j, bool pressed);

 static void HandleCommand(uint32 j, bool pressed) {

@@ -700,7 +711,7 @@

 static bool LoadRom(const char *filename) {

   size_t length = 0;

-  uint8 *file = ReadFile(filename, &length);

+  uint8 *file = ReadWholeFile(filename, &length);

   if(!file) Die("Failed to read file");

   bool result = EmuInitialize(file, length);

   free(file);

@@ -732,7 +743,7 @@

   if (g_config.link_graphics) {

     fprintf(stderr, "Loading Link Graphics: %s\n", g_config.link_graphics);

     size_t length = 0;

-    uint8 *file = ReadFile(g_config.link_graphics, &length);

+    uint8 *file = ReadWholeFile(g_config.link_graphics, &length);

     if (file == NULL || !ParseLinkGraphics(file, length))

       Die("Unable to load file");

     free(file);

@@ -745,9 +756,9 @@

 static void LoadAssets() {

   size_t length = 0;

-  uint8 *data = ReadFile("tables/zelda3_assets.dat", &length);

+  uint8 *data = ReadWholeFile("tables/zelda3_assets.dat", &length);

   if (!data)

-    data = ReadFile("zelda3_assets.dat", &length);

+    data = ReadWholeFile("zelda3_assets.dat", &length);

   if (!data) Die("Failed to read zelda3_assets.dat. Please see the README for information about how you get this file.");

   static const char kAssetsSig[] = { kAssets_Sig };

@@ -767,5 +778,31 @@

     g_asset_sizes[i] = size;

     g_asset_ptrs[i] = data + offset;

     offset += size;

+  }

+}

+

+// Go some steps up and find zelda3.ini

+static void SwitchDirectory() {

+  char buf[4096];

+  if (!getcwd(buf, sizeof(buf) - 32))

+    return;

+  size_t pos = strlen(buf);

+

+  for (int step = 0; pos != 0 && step < 3; step++) {

+    memcpy(buf + pos, "/zelda3.ini", 12);

+    FILE *f = fopen(buf, "rb");

+    if (f) {

+      fclose(f);

+      buf[pos] = 0;

+      if (step != 0) {

+        printf("Found zelda3.ini in %s\n", buf);

+        int err = chdir(buf);

+        (void)err;

+      }

+      return;

+    }

+    pos--;

+    while (pos != 0 && buf[pos] != '/' && buf[pos] != '\\')

+      pos--;

   }

 }

--- /dev/null

+++ b/opengl.c

@@ -1,0 +1,220 @@

+#include "third_party/gl_core/gl_core_3_1.h"

+#include <SDL.h>

+#include <stdio.h>

+#include <stdbool.h>

+#include "types.h"

+#include "util.h"

+#include "glsl_shader.h"

+#include "config.h"

+

+#define CODE(...) #__VA_ARGS__

+

+static SDL_Window *g_window;

+static uint8 *g_screen_buffer;

+static size_t g_screen_buffer_size;

+static int g_draw_width, g_draw_height;

+static unsigned int g_program, g_VAO;

+static GlTextureWithSize g_texture;

+static GlslShader *g_glsl_shader;

+

+static void APIENTRY MessageCallback(GLenum source,

+                GLenum type,

+                GLuint id,

+                GLenum severity,

+                GLsizei length,

+                const GLchar *message,

+                const void *userParam) {

+  if (type == GL_DEBUG_TYPE_OTHER)

+    return;

+

+  fprintf(stderr, "GL CALLBACK: %s type = 0x%x, severity = 0x%x, message = %s\n",

+          (type == GL_DEBUG_TYPE_ERROR ? "** GL ERROR **" : ""),

+          type, severity, message);

+  if (type == GL_DEBUG_TYPE_ERROR)

+    Die("OpenGL error!\n");

+}

+

+static bool OpenGLRenderer_Init(SDL_Window *window) {

+  g_window = window;

+  SDL_GLContext context = SDL_GL_CreateContext(window);

+  const char *error = SDL_GetError();

+

+  SDL_GL_SetSwapInterval(1);

+  ogl_LoadFunctions();

+

+  if (!ogl_IsVersionGEQ(3, 3))

+    Die("You need OpenGL 3.3");

+

+  if (kDebugFlag) {

+    glEnable(GL_DEBUG_OUTPUT);

+    glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);

+    glDebugMessageCallback(MessageCallback, 0);

+  }

+

+  glGenTextures(1, &g_texture.gl_texture);

+

+  static const float kVertices[] = {

+    // positions          // texture coords

+    -1.0f,  1.0f, 0.0f,   0.0f, 0.0f, // top left

+    -1.0f, -1.0f, 0.0f,   0.0f, 1.0f, // bottom left

+     1.0f,  1.0f, 0.0f,   1.0f, 0.0f, // top right

+     1.0f, -1.0f, 0.0f,   1.0f, 1.0f,  // bottom right

+  };

+

+  // create a vertex buffer object

+  unsigned int vbo;

+  glGenBuffers(1, &vbo);

+

+  // vertex array object

+  glGenVertexArrays(1, &g_VAO);

+  // 1. bind Vertex Array Object

+  glBindVertexArray(g_VAO);

+  // 2. copy our vertices array in a buffer for OpenGL to use

+  glBindBuffer(GL_ARRAY_BUFFER, vbo);

+  glBufferData(GL_ARRAY_BUFFER, sizeof(kVertices), kVertices, GL_STATIC_DRAW);

+  // position attribute

+  glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void *)0);

+  glEnableVertexAttribArray(0);

+  // texture coord attribute

+  glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void *)(3 * sizeof(float)));

+  glEnableVertexAttribArray(1);

+

+  // vertex shader

+  const GLchar *vs_code = "#version 330 core\n" CODE(

+  layout(location = 0) in vec3 aPos;

+  layout(location = 1) in vec2 aTexCoord;

+  out vec2 TexCoord;

+  void main() {

+    gl_Position = vec4(aPos, 1.0);

+    TexCoord = vec2(aTexCoord.x, aTexCoord.y);

+  }

+);

+

+  unsigned int vs = glCreateShader(GL_VERTEX_SHADER);

+  glShaderSource(vs, 1, &vs_code, NULL);

+  glCompileShader(vs);

+

+  int success;

+  char infolog[512];

+  glGetShaderiv(vs, GL_COMPILE_STATUS, &success);

+  if (!success) {

+    glGetShaderInfoLog(vs, 512, NULL, infolog);

+    printf("%s\n", infolog);

+  }

+

+  // fragment shader

+  const GLchar *fs_code = "#version 330 core\n" CODE(

+  out vec4 FragColor;

+  in vec2 TexCoord;

+  // texture samplers

+  uniform sampler2D texture1;

+  void main() {

+    FragColor = texture(texture1, TexCoord);

+  }

+);

+

+  unsigned int fs = glCreateShader(GL_FRAGMENT_SHADER);

+  glShaderSource(fs, 1, &fs_code, NULL);

+  glCompileShader(fs);

+

+  glGetShaderiv(fs, GL_COMPILE_STATUS, &success);

+  if (!success) {

+    glGetShaderInfoLog(fs, 512, NULL, infolog);

+    printf("%s\n", infolog);

+  }

+

+  // create program

+  int program = g_program = glCreateProgram();

+  glAttachShader(program, vs);

+  glAttachShader(program, fs);

+  glLinkProgram(program);

+  glGetProgramiv(program, GL_LINK_STATUS, &success);

+

+  if (!success) {

+    glGetProgramInfoLog(program, 512, NULL, infolog);

+    printf("%s\n", infolog);

+  }

+

+  if (g_config.shader)

+    g_glsl_shader = GlslShader_CreateFromFile(g_config.shader);

+  

+  return true;

+}

+

+static void OpenGLRenderer_Destroy() {

+}

+

+static void OpenGLRenderer_BeginDraw(int width, int height, uint8 **pixels, int *pitch) {

+  int size = width * height;

+

+  if (size > g_screen_buffer_size) {

+    g_screen_buffer_size = size;

+    free(g_screen_buffer);

+    g_screen_buffer = malloc(size * 4);

+  }

+

+  g_draw_width = width;

+  g_draw_height = height;

+  *pixels = g_screen_buffer;

+  *pitch = width * 4;

+}

+

+static void OpenGLRenderer_EndDraw() {

+  int drawable_width, drawable_height;

+

+  SDL_GL_GetDrawableSize(g_window, &drawable_width, &drawable_height);

+  

+  int viewport_width = drawable_width, viewport_height = drawable_height;

+

+  if (!g_config.ignore_aspect_ratio) {

+    if (viewport_width * g_draw_height < viewport_height * g_draw_width)

+      viewport_height = viewport_width * g_draw_height / g_draw_width;  // limit height

+    else

+      viewport_width = viewport_height * g_draw_width / g_draw_height;  // limit width

+  }

+

+  int viewport_x = (drawable_width - viewport_width) >> 1;

+  int viewport_y = (viewport_height - viewport_height) >> 1;

+

+  glBindTexture(GL_TEXTURE_2D, g_texture.gl_texture);

+  if (g_draw_width == g_texture.width && g_draw_height == g_texture.height) {

+    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, g_draw_width, g_draw_height, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, g_screen_buffer);

+  } else {

+    g_texture.width = g_draw_width;

+    g_texture.height = g_draw_height;

+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, g_draw_width, g_draw_height, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, g_screen_buffer);

+  }

+

+  glClearColor(0.0f, 0.0f, 0.0f, 1.0f);

+  glClear(GL_COLOR_BUFFER_BIT);

+

+  if (g_glsl_shader == NULL) {

+    glViewport(viewport_x, viewport_y, viewport_width, viewport_height);

+    glUseProgram(g_program);

+    int filter = g_config.linear_filtering ? GL_LINEAR : GL_NEAREST;

+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter);

+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filter);

+    glBindVertexArray(g_VAO);

+    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

+  } else {

+    GlslShader_Render(g_glsl_shader, &g_texture, viewport_x, viewport_y, viewport_width, viewport_height);

+  }

+

+  SDL_GL_SwapWindow(g_window);

+}

+

+

+static const struct RendererFuncs kOpenGLRendererFuncs = {

+  &OpenGLRenderer_Init,

+  &OpenGLRenderer_Destroy,

+  &OpenGLRenderer_BeginDraw,

+  &OpenGLRenderer_EndDraw,

+};

+

+void OpenGLRenderer_Create(struct RendererFuncs *funcs) {

+  SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);

+  SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);

+  SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);

+  *funcs = kOpenGLRendererFuncs;

+}

+

--- a/run_with_tcc.bat

+++ b/run_with_tcc.bat

@@ -38,7 +38,7 @@

 echo Building with TCC...

-third_party\tcc\tcc.exe -ozelda3.exe -DHAVE_STDINT_H=1 -D_HAVE_STDINT_H=1 -DSYSTEM_VOLUME_MIXER_AVAILABLE=0 -I%SDL2%/include -L%SDL2%/lib/x64 -lSDL2 *.c snes/*.c

+third_party\tcc\tcc.exe -ozelda3.exe -DHAVE_STDINT_H=1 -D_HAVE_STDINT_H=1 -DSYSTEM_VOLUME_MIXER_AVAILABLE=0 -I%SDL2%/include -L%SDL2%/lib/x64 -lSDL2 *.c snes/*.c third_party/gl_core/gl_core_3_1.c

 IF ERRORLEVEL 1 goto GETOUT

 copy %SDL2%\lib\x64\SDL2.dll .

--- a/third_party/.gitignore

+++ b/third_party/.gitignore

@@ -1,2 +1,3 @@

 /tcc/

 /SDL2-2.24.0/

+/gl_core/*.o

\ No newline at end of file

--- /dev/null

+++ b/third_party/gl_core/gl_core_3_1.c

@@ -1,0 +1,3189 @@

+#include <stdlib.h>

+#include <string.h>

+#include <stddef.h>

+#include "gl_core_3_1.h"

+

+#ifndef SDLCALL

+#if (defined(__WIN32__) || defined(__WINRT__)) && !defined(__GNUC__)

+#define SDLCALL __cdecl

+#else

+#define SDLCALL

+#endif

+#endif /* SDLCALL */

+

+extern void *SDLCALL SDL_GL_GetProcAddress(const char *proc); 

+

+#define IntGetProcAddress(name) SDL_GL_GetProcAddress(name)

+

+int ogl_ext_ARB_compressed_texture_pixel_storage = ogl_LOAD_FAILED;

+int ogl_ext_ARB_conservative_depth = ogl_LOAD_FAILED;

+int ogl_ext_ARB_ES2_compatibility = ogl_LOAD_FAILED;

+int ogl_ext_ARB_get_program_binary = ogl_LOAD_FAILED;

+int ogl_ext_ARB_explicit_uniform_location = ogl_LOAD_FAILED;

+int ogl_ext_ARB_internalformat_query = ogl_LOAD_FAILED;

+int ogl_ext_ARB_internalformat_query2 = ogl_LOAD_FAILED;

+int ogl_ext_ARB_map_buffer_alignment = ogl_LOAD_FAILED;

+int ogl_ext_ARB_program_interface_query = ogl_LOAD_FAILED;

+int ogl_ext_ARB_separate_shader_objects = ogl_LOAD_FAILED;

+int ogl_ext_ARB_shading_language_420pack = ogl_LOAD_FAILED;

+int ogl_ext_ARB_shading_language_packing = ogl_LOAD_FAILED;

+int ogl_ext_ARB_texture_buffer_range = ogl_LOAD_FAILED;

+int ogl_ext_ARB_texture_storage = ogl_LOAD_FAILED;

+int ogl_ext_ARB_texture_view = ogl_LOAD_FAILED;

+int ogl_ext_ARB_vertex_attrib_binding = ogl_LOAD_FAILED;

+int ogl_ext_ARB_viewport_array = ogl_LOAD_FAILED;

+int ogl_ext_ARB_arrays_of_arrays = ogl_LOAD_FAILED;

+int ogl_ext_ARB_clear_buffer_object = ogl_LOAD_FAILED;

+int ogl_ext_ARB_copy_image = ogl_LOAD_FAILED;

+int ogl_ext_ARB_ES3_compatibility = ogl_LOAD_FAILED;

+int ogl_ext_ARB_fragment_layer_viewport = ogl_LOAD_FAILED;

+int ogl_ext_ARB_framebuffer_no_attachments = ogl_LOAD_FAILED;

+int ogl_ext_ARB_invalidate_subdata = ogl_LOAD_FAILED;

+int ogl_ext_ARB_robust_buffer_access_behavior = ogl_LOAD_FAILED;

+int ogl_ext_ARB_stencil_texturing = ogl_LOAD_FAILED;

+int ogl_ext_ARB_texture_query_levels = ogl_LOAD_FAILED;

+int ogl_ext_ARB_texture_storage_multisample = ogl_LOAD_FAILED;

+int ogl_ext_KHR_debug = ogl_LOAD_FAILED;

+int ogl_ext_ARB_buffer_storage = ogl_LOAD_FAILED;

+int ogl_ext_ARB_clear_texture = ogl_LOAD_FAILED;

+int ogl_ext_ARB_enhanced_layouts = ogl_LOAD_FAILED;

+int ogl_ext_ARB_multi_bind = ogl_LOAD_FAILED;

+int ogl_ext_ARB_query_buffer_object = ogl_LOAD_FAILED;

+int ogl_ext_ARB_texture_mirror_clamp_to_edge = ogl_LOAD_FAILED;

+int ogl_ext_ARB_texture_stencil8 = ogl_LOAD_FAILED;

+int ogl_ext_ARB_vertex_type_10f_11f_11f_rev = ogl_LOAD_FAILED;

+int ogl_ext_ARB_seamless_cubemap_per_texture = ogl_LOAD_FAILED;

+int ogl_ext_ARB_clip_control = ogl_LOAD_FAILED;

+int ogl_ext_ARB_conditional_render_inverted = ogl_LOAD_FAILED;

+int ogl_ext_ARB_cull_distance = ogl_LOAD_FAILED;

+int ogl_ext_ARB_derivative_control = ogl_LOAD_FAILED;

+int ogl_ext_ARB_direct_state_access = ogl_LOAD_FAILED;

+int ogl_ext_ARB_get_texture_sub_image = ogl_LOAD_FAILED;

+int ogl_ext_ARB_shader_texture_image_samples = ogl_LOAD_FAILED;

+int ogl_ext_ARB_texture_barrier = ogl_LOAD_FAILED;

+int ogl_ext_KHR_context_flush_control = ogl_LOAD_FAILED;

+int ogl_ext_KHR_robust_buffer_access_behavior = ogl_LOAD_FAILED;

+int ogl_ext_KHR_robustness = ogl_LOAD_FAILED;

+int ogl_ext_EXT_texture_compression_s3tc = ogl_LOAD_FAILED;

+int ogl_ext_EXT_texture_sRGB = ogl_LOAD_FAILED;

+int ogl_ext_EXT_texture_filter_anisotropic = ogl_LOAD_FAILED;

+

+void (CODEGEN_FUNCPTR *_ptrc_glClearDepthf)(GLfloat d) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glDepthRangef)(GLfloat n, GLfloat f) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetShaderPrecisionFormat)(GLenum shadertype, GLenum precisiontype, GLint * range, GLint * precision) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glReleaseShaderCompiler)(void) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glShaderBinary)(GLsizei count, const GLuint * shaders, GLenum binaryformat, const void * binary, GLsizei length) = NULL;

+

+static int Load_ARB_ES2_compatibility(void)

+{

+	int numFailed = 0;

+	_ptrc_glClearDepthf = (void (CODEGEN_FUNCPTR *)(GLfloat))IntGetProcAddress("glClearDepthf");

+	if(!_ptrc_glClearDepthf) numFailed++;

+	_ptrc_glDepthRangef = (void (CODEGEN_FUNCPTR *)(GLfloat, GLfloat))IntGetProcAddress("glDepthRangef");

+	if(!_ptrc_glDepthRangef) numFailed++;

+	_ptrc_glGetShaderPrecisionFormat = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLint *, GLint *))IntGetProcAddress("glGetShaderPrecisionFormat");

+	if(!_ptrc_glGetShaderPrecisionFormat) numFailed++;

+	_ptrc_glReleaseShaderCompiler = (void (CODEGEN_FUNCPTR *)(void))IntGetProcAddress("glReleaseShaderCompiler");

+	if(!_ptrc_glReleaseShaderCompiler) numFailed++;

+	_ptrc_glShaderBinary = (void (CODEGEN_FUNCPTR *)(GLsizei, const GLuint *, GLenum, const void *, GLsizei))IntGetProcAddress("glShaderBinary");

+	if(!_ptrc_glShaderBinary) numFailed++;

+	return numFailed;

+}

+

+void (CODEGEN_FUNCPTR *_ptrc_glGetProgramBinary)(GLuint program, GLsizei bufSize, GLsizei * length, GLenum * binaryFormat, void * binary) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramBinary)(GLuint program, GLenum binaryFormat, const void * binary, GLsizei length) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramParameteri)(GLuint program, GLenum pname, GLint value) = NULL;

+

+static int Load_ARB_get_program_binary(void)

+{

+	int numFailed = 0;

+	_ptrc_glGetProgramBinary = (void (CODEGEN_FUNCPTR *)(GLuint, GLsizei, GLsizei *, GLenum *, void *))IntGetProcAddress("glGetProgramBinary");

+	if(!_ptrc_glGetProgramBinary) numFailed++;

+	_ptrc_glProgramBinary = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, const void *, GLsizei))IntGetProcAddress("glProgramBinary");

+	if(!_ptrc_glProgramBinary) numFailed++;

+	_ptrc_glProgramParameteri = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, GLint))IntGetProcAddress("glProgramParameteri");

+	if(!_ptrc_glProgramParameteri) numFailed++;

+	return numFailed;

+}

+

+void (CODEGEN_FUNCPTR *_ptrc_glGetInternalformativ)(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint * params) = NULL;

+

+static int Load_ARB_internalformat_query(void)

+{

+	int numFailed = 0;

+	_ptrc_glGetInternalformativ = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLenum, GLsizei, GLint *))IntGetProcAddress("glGetInternalformativ");

+	if(!_ptrc_glGetInternalformativ) numFailed++;

+	return numFailed;

+}

+

+void (CODEGEN_FUNCPTR *_ptrc_glGetInternalformati64v)(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint64 * params) = NULL;

+

+static int Load_ARB_internalformat_query2(void)

+{

+	int numFailed = 0;

+	_ptrc_glGetInternalformati64v = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLenum, GLsizei, GLint64 *))IntGetProcAddress("glGetInternalformati64v");

+	if(!_ptrc_glGetInternalformati64v) numFailed++;

+	return numFailed;

+}

+

+void (CODEGEN_FUNCPTR *_ptrc_glGetProgramInterfaceiv)(GLuint program, GLenum programInterface, GLenum pname, GLint * params) = NULL;

+GLuint (CODEGEN_FUNCPTR *_ptrc_glGetProgramResourceIndex)(GLuint program, GLenum programInterface, const GLchar * name) = NULL;

+GLint (CODEGEN_FUNCPTR *_ptrc_glGetProgramResourceLocation)(GLuint program, GLenum programInterface, const GLchar * name) = NULL;

+GLint (CODEGEN_FUNCPTR *_ptrc_glGetProgramResourceLocationIndex)(GLuint program, GLenum programInterface, const GLchar * name) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetProgramResourceName)(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei * length, GLchar * name) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetProgramResourceiv)(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum * props, GLsizei bufSize, GLsizei * length, GLint * params) = NULL;

+

+static int Load_ARB_program_interface_query(void)

+{

+	int numFailed = 0;

+	_ptrc_glGetProgramInterfaceiv = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, GLenum, GLint *))IntGetProcAddress("glGetProgramInterfaceiv");

+	if(!_ptrc_glGetProgramInterfaceiv) numFailed++;

+	_ptrc_glGetProgramResourceIndex = (GLuint (CODEGEN_FUNCPTR *)(GLuint, GLenum, const GLchar *))IntGetProcAddress("glGetProgramResourceIndex");

+	if(!_ptrc_glGetProgramResourceIndex) numFailed++;

+	_ptrc_glGetProgramResourceLocation = (GLint (CODEGEN_FUNCPTR *)(GLuint, GLenum, const GLchar *))IntGetProcAddress("glGetProgramResourceLocation");

+	if(!_ptrc_glGetProgramResourceLocation) numFailed++;

+	_ptrc_glGetProgramResourceLocationIndex = (GLint (CODEGEN_FUNCPTR *)(GLuint, GLenum, const GLchar *))IntGetProcAddress("glGetProgramResourceLocationIndex");

+	if(!_ptrc_glGetProgramResourceLocationIndex) numFailed++;

+	_ptrc_glGetProgramResourceName = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, GLuint, GLsizei, GLsizei *, GLchar *))IntGetProcAddress("glGetProgramResourceName");

+	if(!_ptrc_glGetProgramResourceName) numFailed++;

+	_ptrc_glGetProgramResourceiv = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, GLuint, GLsizei, const GLenum *, GLsizei, GLsizei *, GLint *))IntGetProcAddress("glGetProgramResourceiv");

+	if(!_ptrc_glGetProgramResourceiv) numFailed++;

+	return numFailed;

+}

+

+void (CODEGEN_FUNCPTR *_ptrc_glActiveShaderProgram)(GLuint pipeline, GLuint program) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glBindProgramPipeline)(GLuint pipeline) = NULL;

+GLuint (CODEGEN_FUNCPTR *_ptrc_glCreateShaderProgramv)(GLenum type, GLsizei count, const GLchar *const* strings) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glDeleteProgramPipelines)(GLsizei n, const GLuint * pipelines) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGenProgramPipelines)(GLsizei n, GLuint * pipelines) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetProgramPipelineInfoLog)(GLuint pipeline, GLsizei bufSize, GLsizei * length, GLchar * infoLog) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetProgramPipelineiv)(GLuint pipeline, GLenum pname, GLint * params) = NULL;

+GLboolean (CODEGEN_FUNCPTR *_ptrc_glIsProgramPipeline)(GLuint pipeline) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform1d)(GLuint program, GLint location, GLdouble v0) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform1dv)(GLuint program, GLint location, GLsizei count, const GLdouble * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform1f)(GLuint program, GLint location, GLfloat v0) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform1fv)(GLuint program, GLint location, GLsizei count, const GLfloat * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform1i)(GLuint program, GLint location, GLint v0) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform1iv)(GLuint program, GLint location, GLsizei count, const GLint * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform1ui)(GLuint program, GLint location, GLuint v0) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform1uiv)(GLuint program, GLint location, GLsizei count, const GLuint * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform2d)(GLuint program, GLint location, GLdouble v0, GLdouble v1) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform2dv)(GLuint program, GLint location, GLsizei count, const GLdouble * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform2f)(GLuint program, GLint location, GLfloat v0, GLfloat v1) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform2fv)(GLuint program, GLint location, GLsizei count, const GLfloat * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform2i)(GLuint program, GLint location, GLint v0, GLint v1) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform2iv)(GLuint program, GLint location, GLsizei count, const GLint * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform2ui)(GLuint program, GLint location, GLuint v0, GLuint v1) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform2uiv)(GLuint program, GLint location, GLsizei count, const GLuint * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform3d)(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform3dv)(GLuint program, GLint location, GLsizei count, const GLdouble * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform3f)(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform3fv)(GLuint program, GLint location, GLsizei count, const GLfloat * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform3i)(GLuint program, GLint location, GLint v0, GLint v1, GLint v2) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform3iv)(GLuint program, GLint location, GLsizei count, const GLint * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform3ui)(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform3uiv)(GLuint program, GLint location, GLsizei count, const GLuint * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform4d)(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform4dv)(GLuint program, GLint location, GLsizei count, const GLdouble * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform4f)(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform4fv)(GLuint program, GLint location, GLsizei count, const GLfloat * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform4i)(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform4iv)(GLuint program, GLint location, GLsizei count, const GLint * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform4ui)(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform4uiv)(GLuint program, GLint location, GLsizei count, const GLuint * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniformMatrix2dv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniformMatrix2fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniformMatrix2x3dv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniformMatrix2x3fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniformMatrix2x4dv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniformMatrix2x4fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniformMatrix3dv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniformMatrix3fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniformMatrix3x2dv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniformMatrix3x2fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniformMatrix3x4dv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniformMatrix3x4fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniformMatrix4dv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniformMatrix4fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniformMatrix4x2dv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniformMatrix4x2fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniformMatrix4x3dv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glProgramUniformMatrix4x3fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glUseProgramStages)(GLuint pipeline, GLbitfield stages, GLuint program) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glValidateProgramPipeline)(GLuint pipeline) = NULL;

+

+static int Load_ARB_separate_shader_objects(void)

+{

+	int numFailed = 0;

+	_ptrc_glActiveShaderProgram = (void (CODEGEN_FUNCPTR *)(GLuint, GLuint))IntGetProcAddress("glActiveShaderProgram");

+	if(!_ptrc_glActiveShaderProgram) numFailed++;

+	_ptrc_glBindProgramPipeline = (void (CODEGEN_FUNCPTR *)(GLuint))IntGetProcAddress("glBindProgramPipeline");

+	if(!_ptrc_glBindProgramPipeline) numFailed++;

+	_ptrc_glCreateShaderProgramv = (GLuint (CODEGEN_FUNCPTR *)(GLenum, GLsizei, const GLchar *const*))IntGetProcAddress("glCreateShaderProgramv");

+	if(!_ptrc_glCreateShaderProgramv) numFailed++;

+	_ptrc_glDeleteProgramPipelines = (void (CODEGEN_FUNCPTR *)(GLsizei, const GLuint *))IntGetProcAddress("glDeleteProgramPipelines");

+	if(!_ptrc_glDeleteProgramPipelines) numFailed++;

+	_ptrc_glGenProgramPipelines = (void (CODEGEN_FUNCPTR *)(GLsizei, GLuint *))IntGetProcAddress("glGenProgramPipelines");

+	if(!_ptrc_glGenProgramPipelines) numFailed++;

+	_ptrc_glGetProgramPipelineInfoLog = (void (CODEGEN_FUNCPTR *)(GLuint, GLsizei, GLsizei *, GLchar *))IntGetProcAddress("glGetProgramPipelineInfoLog");

+	if(!_ptrc_glGetProgramPipelineInfoLog) numFailed++;

+	_ptrc_glGetProgramPipelineiv = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, GLint *))IntGetProcAddress("glGetProgramPipelineiv");

+	if(!_ptrc_glGetProgramPipelineiv) numFailed++;

+	_ptrc_glIsProgramPipeline = (GLboolean (CODEGEN_FUNCPTR *)(GLuint))IntGetProcAddress("glIsProgramPipeline");

+	if(!_ptrc_glIsProgramPipeline) numFailed++;

+	_ptrc_glProgramUniform1d = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLdouble))IntGetProcAddress("glProgramUniform1d");

+	if(!_ptrc_glProgramUniform1d) numFailed++;

+	_ptrc_glProgramUniform1dv = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLsizei, const GLdouble *))IntGetProcAddress("glProgramUniform1dv");

+	if(!_ptrc_glProgramUniform1dv) numFailed++;

+	_ptrc_glProgramUniform1f = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLfloat))IntGetProcAddress("glProgramUniform1f");

+	if(!_ptrc_glProgramUniform1f) numFailed++;

+	_ptrc_glProgramUniform1fv = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLsizei, const GLfloat *))IntGetProcAddress("glProgramUniform1fv");

+	if(!_ptrc_glProgramUniform1fv) numFailed++;

+	_ptrc_glProgramUniform1i = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLint))IntGetProcAddress("glProgramUniform1i");

+	if(!_ptrc_glProgramUniform1i) numFailed++;

+	_ptrc_glProgramUniform1iv = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLsizei, const GLint *))IntGetProcAddress("glProgramUniform1iv");

+	if(!_ptrc_glProgramUniform1iv) numFailed++;

+	_ptrc_glProgramUniform1ui = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLuint))IntGetProcAddress("glProgramUniform1ui");

+	if(!_ptrc_glProgramUniform1ui) numFailed++;

+	_ptrc_glProgramUniform1uiv = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLsizei, const GLuint *))IntGetProcAddress("glProgramUniform1uiv");

+	if(!_ptrc_glProgramUniform1uiv) numFailed++;

+	_ptrc_glProgramUniform2d = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLdouble, GLdouble))IntGetProcAddress("glProgramUniform2d");

+	if(!_ptrc_glProgramUniform2d) numFailed++;

+	_ptrc_glProgramUniform2dv = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLsizei, const GLdouble *))IntGetProcAddress("glProgramUniform2dv");

+	if(!_ptrc_glProgramUniform2dv) numFailed++;

+	_ptrc_glProgramUniform2f = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLfloat, GLfloat))IntGetProcAddress("glProgramUniform2f");

+	if(!_ptrc_glProgramUniform2f) numFailed++;

+	_ptrc_glProgramUniform2fv = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLsizei, const GLfloat *))IntGetProcAddress("glProgramUniform2fv");

+	if(!_ptrc_glProgramUniform2fv) numFailed++;

+	_ptrc_glProgramUniform2i = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLint, GLint))IntGetProcAddress("glProgramUniform2i");

+	if(!_ptrc_glProgramUniform2i) numFailed++;

+	_ptrc_glProgramUniform2iv = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLsizei, const GLint *))IntGetProcAddress("glProgramUniform2iv");

+	if(!_ptrc_glProgramUniform2iv) numFailed++;

+	_ptrc_glProgramUniform2ui = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLuint, GLuint))IntGetProcAddress("glProgramUniform2ui");

+	if(!_ptrc_glProgramUniform2ui) numFailed++;

+	_ptrc_glProgramUniform2uiv = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLsizei, const GLuint *))IntGetProcAddress("glProgramUniform2uiv");

+	if(!_ptrc_glProgramUniform2uiv) numFailed++;

+	_ptrc_glProgramUniform3d = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLdouble, GLdouble, GLdouble))IntGetProcAddress("glProgramUniform3d");

+	if(!_ptrc_glProgramUniform3d) numFailed++;

+	_ptrc_glProgramUniform3dv = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLsizei, const GLdouble *))IntGetProcAddress("glProgramUniform3dv");

+	if(!_ptrc_glProgramUniform3dv) numFailed++;

+	_ptrc_glProgramUniform3f = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLfloat, GLfloat, GLfloat))IntGetProcAddress("glProgramUniform3f");

+	if(!_ptrc_glProgramUniform3f) numFailed++;

+	_ptrc_glProgramUniform3fv = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLsizei, const GLfloat *))IntGetProcAddress("glProgramUniform3fv");

+	if(!_ptrc_glProgramUniform3fv) numFailed++;

+	_ptrc_glProgramUniform3i = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLint, GLint, GLint))IntGetProcAddress("glProgramUniform3i");

+	if(!_ptrc_glProgramUniform3i) numFailed++;

+	_ptrc_glProgramUniform3iv = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLsizei, const GLint *))IntGetProcAddress("glProgramUniform3iv");

+	if(!_ptrc_glProgramUniform3iv) numFailed++;

+	_ptrc_glProgramUniform3ui = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLuint, GLuint, GLuint))IntGetProcAddress("glProgramUniform3ui");

+	if(!_ptrc_glProgramUniform3ui) numFailed++;

+	_ptrc_glProgramUniform3uiv = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLsizei, const GLuint *))IntGetProcAddress("glProgramUniform3uiv");

+	if(!_ptrc_glProgramUniform3uiv) numFailed++;

+	_ptrc_glProgramUniform4d = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLdouble, GLdouble, GLdouble, GLdouble))IntGetProcAddress("glProgramUniform4d");

+	if(!_ptrc_glProgramUniform4d) numFailed++;

+	_ptrc_glProgramUniform4dv = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLsizei, const GLdouble *))IntGetProcAddress("glProgramUniform4dv");

+	if(!_ptrc_glProgramUniform4dv) numFailed++;

+	_ptrc_glProgramUniform4f = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLfloat, GLfloat, GLfloat, GLfloat))IntGetProcAddress("glProgramUniform4f");

+	if(!_ptrc_glProgramUniform4f) numFailed++;

+	_ptrc_glProgramUniform4fv = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLsizei, const GLfloat *))IntGetProcAddress("glProgramUniform4fv");

+	if(!_ptrc_glProgramUniform4fv) numFailed++;

+	_ptrc_glProgramUniform4i = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLint, GLint, GLint, GLint))IntGetProcAddress("glProgramUniform4i");

+	if(!_ptrc_glProgramUniform4i) numFailed++;

+	_ptrc_glProgramUniform4iv = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLsizei, const GLint *))IntGetProcAddress("glProgramUniform4iv");

+	if(!_ptrc_glProgramUniform4iv) numFailed++;

+	_ptrc_glProgramUniform4ui = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLuint, GLuint, GLuint, GLuint))IntGetProcAddress("glProgramUniform4ui");

+	if(!_ptrc_glProgramUniform4ui) numFailed++;

+	_ptrc_glProgramUniform4uiv = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLsizei, const GLuint *))IntGetProcAddress("glProgramUniform4uiv");

+	if(!_ptrc_glProgramUniform4uiv) numFailed++;

+	_ptrc_glProgramUniformMatrix2dv = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLsizei, GLboolean, const GLdouble *))IntGetProcAddress("glProgramUniformMatrix2dv");

+	if(!_ptrc_glProgramUniformMatrix2dv) numFailed++;

+	_ptrc_glProgramUniformMatrix2fv = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLsizei, GLboolean, const GLfloat *))IntGetProcAddress("glProgramUniformMatrix2fv");

+	if(!_ptrc_glProgramUniformMatrix2fv) numFailed++;

+	_ptrc_glProgramUniformMatrix2x3dv = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLsizei, GLboolean, const GLdouble *))IntGetProcAddress("glProgramUniformMatrix2x3dv");

+	if(!_ptrc_glProgramUniformMatrix2x3dv) numFailed++;

+	_ptrc_glProgramUniformMatrix2x3fv = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLsizei, GLboolean, const GLfloat *))IntGetProcAddress("glProgramUniformMatrix2x3fv");

+	if(!_ptrc_glProgramUniformMatrix2x3fv) numFailed++;

+	_ptrc_glProgramUniformMatrix2x4dv = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLsizei, GLboolean, const GLdouble *))IntGetProcAddress("glProgramUniformMatrix2x4dv");

+	if(!_ptrc_glProgramUniformMatrix2x4dv) numFailed++;

+	_ptrc_glProgramUniformMatrix2x4fv = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLsizei, GLboolean, const GLfloat *))IntGetProcAddress("glProgramUniformMatrix2x4fv");

+	if(!_ptrc_glProgramUniformMatrix2x4fv) numFailed++;

+	_ptrc_glProgramUniformMatrix3dv = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLsizei, GLboolean, const GLdouble *))IntGetProcAddress("glProgramUniformMatrix3dv");

+	if(!_ptrc_glProgramUniformMatrix3dv) numFailed++;

+	_ptrc_glProgramUniformMatrix3fv = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLsizei, GLboolean, const GLfloat *))IntGetProcAddress("glProgramUniformMatrix3fv");

+	if(!_ptrc_glProgramUniformMatrix3fv) numFailed++;

+	_ptrc_glProgramUniformMatrix3x2dv = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLsizei, GLboolean, const GLdouble *))IntGetProcAddress("glProgramUniformMatrix3x2dv");

+	if(!_ptrc_glProgramUniformMatrix3x2dv) numFailed++;

+	_ptrc_glProgramUniformMatrix3x2fv = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLsizei, GLboolean, const GLfloat *))IntGetProcAddress("glProgramUniformMatrix3x2fv");

+	if(!_ptrc_glProgramUniformMatrix3x2fv) numFailed++;

+	_ptrc_glProgramUniformMatrix3x4dv = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLsizei, GLboolean, const GLdouble *))IntGetProcAddress("glProgramUniformMatrix3x4dv");

+	if(!_ptrc_glProgramUniformMatrix3x4dv) numFailed++;

+	_ptrc_glProgramUniformMatrix3x4fv = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLsizei, GLboolean, const GLfloat *))IntGetProcAddress("glProgramUniformMatrix3x4fv");

+	if(!_ptrc_glProgramUniformMatrix3x4fv) numFailed++;

+	_ptrc_glProgramUniformMatrix4dv = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLsizei, GLboolean, const GLdouble *))IntGetProcAddress("glProgramUniformMatrix4dv");

+	if(!_ptrc_glProgramUniformMatrix4dv) numFailed++;

+	_ptrc_glProgramUniformMatrix4fv = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLsizei, GLboolean, const GLfloat *))IntGetProcAddress("glProgramUniformMatrix4fv");

+	if(!_ptrc_glProgramUniformMatrix4fv) numFailed++;

+	_ptrc_glProgramUniformMatrix4x2dv = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLsizei, GLboolean, const GLdouble *))IntGetProcAddress("glProgramUniformMatrix4x2dv");

+	if(!_ptrc_glProgramUniformMatrix4x2dv) numFailed++;

+	_ptrc_glProgramUniformMatrix4x2fv = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLsizei, GLboolean, const GLfloat *))IntGetProcAddress("glProgramUniformMatrix4x2fv");

+	if(!_ptrc_glProgramUniformMatrix4x2fv) numFailed++;

+	_ptrc_glProgramUniformMatrix4x3dv = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLsizei, GLboolean, const GLdouble *))IntGetProcAddress("glProgramUniformMatrix4x3dv");

+	if(!_ptrc_glProgramUniformMatrix4x3dv) numFailed++;

+	_ptrc_glProgramUniformMatrix4x3fv = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLsizei, GLboolean, const GLfloat *))IntGetProcAddress("glProgramUniformMatrix4x3fv");

+	if(!_ptrc_glProgramUniformMatrix4x3fv) numFailed++;

+	_ptrc_glUseProgramStages = (void (CODEGEN_FUNCPTR *)(GLuint, GLbitfield, GLuint))IntGetProcAddress("glUseProgramStages");

+	if(!_ptrc_glUseProgramStages) numFailed++;

+	_ptrc_glValidateProgramPipeline = (void (CODEGEN_FUNCPTR *)(GLuint))IntGetProcAddress("glValidateProgramPipeline");

+	if(!_ptrc_glValidateProgramPipeline) numFailed++;

+	return numFailed;

+}

+

+void (CODEGEN_FUNCPTR *_ptrc_glTexBufferRange)(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size) = NULL;

+

+static int Load_ARB_texture_buffer_range(void)

+{

+	int numFailed = 0;

+	_ptrc_glTexBufferRange = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLuint, GLintptr, GLsizeiptr))IntGetProcAddress("glTexBufferRange");

+	if(!_ptrc_glTexBufferRange) numFailed++;

+	return numFailed;

+}

+

+void (CODEGEN_FUNCPTR *_ptrc_glTexStorage1D)(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexStorage2D)(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexStorage3D)(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) = NULL;

+

+static int Load_ARB_texture_storage(void)

+{

+	int numFailed = 0;

+	_ptrc_glTexStorage1D = (void (CODEGEN_FUNCPTR *)(GLenum, GLsizei, GLenum, GLsizei))IntGetProcAddress("glTexStorage1D");

+	if(!_ptrc_glTexStorage1D) numFailed++;

+	_ptrc_glTexStorage2D = (void (CODEGEN_FUNCPTR *)(GLenum, GLsizei, GLenum, GLsizei, GLsizei))IntGetProcAddress("glTexStorage2D");

+	if(!_ptrc_glTexStorage2D) numFailed++;

+	_ptrc_glTexStorage3D = (void (CODEGEN_FUNCPTR *)(GLenum, GLsizei, GLenum, GLsizei, GLsizei, GLsizei))IntGetProcAddress("glTexStorage3D");

+	if(!_ptrc_glTexStorage3D) numFailed++;

+	return numFailed;

+}

+

+void (CODEGEN_FUNCPTR *_ptrc_glTextureView)(GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers) = NULL;

+

+static int Load_ARB_texture_view(void)

+{

+	int numFailed = 0;

+	_ptrc_glTextureView = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, GLuint, GLenum, GLuint, GLuint, GLuint, GLuint))IntGetProcAddress("glTextureView");

+	if(!_ptrc_glTextureView) numFailed++;

+	return numFailed;

+}

+

+void (CODEGEN_FUNCPTR *_ptrc_glBindVertexBuffer)(GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribBinding)(GLuint attribindex, GLuint bindingindex) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribFormat)(GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribIFormat)(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribLFormat)(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexBindingDivisor)(GLuint bindingindex, GLuint divisor) = NULL;

+

+static int Load_ARB_vertex_attrib_binding(void)

+{

+	int numFailed = 0;

+	_ptrc_glBindVertexBuffer = (void (CODEGEN_FUNCPTR *)(GLuint, GLuint, GLintptr, GLsizei))IntGetProcAddress("glBindVertexBuffer");

+	if(!_ptrc_glBindVertexBuffer) numFailed++;

+	_ptrc_glVertexAttribBinding = (void (CODEGEN_FUNCPTR *)(GLuint, GLuint))IntGetProcAddress("glVertexAttribBinding");

+	if(!_ptrc_glVertexAttribBinding) numFailed++;

+	_ptrc_glVertexAttribFormat = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLenum, GLboolean, GLuint))IntGetProcAddress("glVertexAttribFormat");

+	if(!_ptrc_glVertexAttribFormat) numFailed++;

+	_ptrc_glVertexAttribIFormat = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLenum, GLuint))IntGetProcAddress("glVertexAttribIFormat");

+	if(!_ptrc_glVertexAttribIFormat) numFailed++;

+	_ptrc_glVertexAttribLFormat = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLenum, GLuint))IntGetProcAddress("glVertexAttribLFormat");

+	if(!_ptrc_glVertexAttribLFormat) numFailed++;

+	_ptrc_glVertexBindingDivisor = (void (CODEGEN_FUNCPTR *)(GLuint, GLuint))IntGetProcAddress("glVertexBindingDivisor");

+	if(!_ptrc_glVertexBindingDivisor) numFailed++;

+	return numFailed;

+}

+

+void (CODEGEN_FUNCPTR *_ptrc_glDepthRangeArrayv)(GLuint first, GLsizei count, const GLdouble * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glDepthRangeIndexed)(GLuint index, GLdouble n, GLdouble f) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetDoublei_v)(GLenum target, GLuint index, GLdouble * data) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetFloati_v)(GLenum target, GLuint index, GLfloat * data) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glScissorArrayv)(GLuint first, GLsizei count, const GLint * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glScissorIndexed)(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glScissorIndexedv)(GLuint index, const GLint * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glViewportArrayv)(GLuint first, GLsizei count, const GLfloat * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glViewportIndexedf)(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glViewportIndexedfv)(GLuint index, const GLfloat * v) = NULL;

+

+static int Load_ARB_viewport_array(void)

+{

+	int numFailed = 0;

+	_ptrc_glDepthRangeArrayv = (void (CODEGEN_FUNCPTR *)(GLuint, GLsizei, const GLdouble *))IntGetProcAddress("glDepthRangeArrayv");

+	if(!_ptrc_glDepthRangeArrayv) numFailed++;

+	_ptrc_glDepthRangeIndexed = (void (CODEGEN_FUNCPTR *)(GLuint, GLdouble, GLdouble))IntGetProcAddress("glDepthRangeIndexed");

+	if(!_ptrc_glDepthRangeIndexed) numFailed++;

+	_ptrc_glGetDoublei_v = (void (CODEGEN_FUNCPTR *)(GLenum, GLuint, GLdouble *))IntGetProcAddress("glGetDoublei_v");

+	if(!_ptrc_glGetDoublei_v) numFailed++;

+	_ptrc_glGetFloati_v = (void (CODEGEN_FUNCPTR *)(GLenum, GLuint, GLfloat *))IntGetProcAddress("glGetFloati_v");

+	if(!_ptrc_glGetFloati_v) numFailed++;

+	_ptrc_glScissorArrayv = (void (CODEGEN_FUNCPTR *)(GLuint, GLsizei, const GLint *))IntGetProcAddress("glScissorArrayv");

+	if(!_ptrc_glScissorArrayv) numFailed++;

+	_ptrc_glScissorIndexed = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLint, GLsizei, GLsizei))IntGetProcAddress("glScissorIndexed");

+	if(!_ptrc_glScissorIndexed) numFailed++;

+	_ptrc_glScissorIndexedv = (void (CODEGEN_FUNCPTR *)(GLuint, const GLint *))IntGetProcAddress("glScissorIndexedv");

+	if(!_ptrc_glScissorIndexedv) numFailed++;

+	_ptrc_glViewportArrayv = (void (CODEGEN_FUNCPTR *)(GLuint, GLsizei, const GLfloat *))IntGetProcAddress("glViewportArrayv");

+	if(!_ptrc_glViewportArrayv) numFailed++;

+	_ptrc_glViewportIndexedf = (void (CODEGEN_FUNCPTR *)(GLuint, GLfloat, GLfloat, GLfloat, GLfloat))IntGetProcAddress("glViewportIndexedf");

+	if(!_ptrc_glViewportIndexedf) numFailed++;

+	_ptrc_glViewportIndexedfv = (void (CODEGEN_FUNCPTR *)(GLuint, const GLfloat *))IntGetProcAddress("glViewportIndexedfv");

+	if(!_ptrc_glViewportIndexedfv) numFailed++;

+	return numFailed;

+}

+

+void (CODEGEN_FUNCPTR *_ptrc_glClearBufferData)(GLenum target, GLenum internalformat, GLenum format, GLenum type, const void * data) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glClearBufferSubData)(GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void * data) = NULL;

+

+static int Load_ARB_clear_buffer_object(void)

+{

+	int numFailed = 0;

+	_ptrc_glClearBufferData = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLenum, GLenum, const void *))IntGetProcAddress("glClearBufferData");

+	if(!_ptrc_glClearBufferData) numFailed++;

+	_ptrc_glClearBufferSubData = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLintptr, GLsizeiptr, GLenum, GLenum, const void *))IntGetProcAddress("glClearBufferSubData");

+	if(!_ptrc_glClearBufferSubData) numFailed++;

+	return numFailed;

+}

+

+void (CODEGEN_FUNCPTR *_ptrc_glCopyImageSubData)(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) = NULL;

+

+static int Load_ARB_copy_image(void)

+{

+	int numFailed = 0;

+	_ptrc_glCopyImageSubData = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, GLint, GLint, GLint, GLint, GLuint, GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei))IntGetProcAddress("glCopyImageSubData");

+	if(!_ptrc_glCopyImageSubData) numFailed++;

+	return numFailed;

+}

+

+void (CODEGEN_FUNCPTR *_ptrc_glFramebufferParameteri)(GLenum target, GLenum pname, GLint param) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetFramebufferParameteriv)(GLenum target, GLenum pname, GLint * params) = NULL;

+

+static int Load_ARB_framebuffer_no_attachments(void)

+{

+	int numFailed = 0;

+	_ptrc_glFramebufferParameteri = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLint))IntGetProcAddress("glFramebufferParameteri");

+	if(!_ptrc_glFramebufferParameteri) numFailed++;

+	_ptrc_glGetFramebufferParameteriv = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLint *))IntGetProcAddress("glGetFramebufferParameteriv");

+	if(!_ptrc_glGetFramebufferParameteriv) numFailed++;

+	return numFailed;

+}

+

+void (CODEGEN_FUNCPTR *_ptrc_glInvalidateBufferData)(GLuint buffer) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glInvalidateBufferSubData)(GLuint buffer, GLintptr offset, GLsizeiptr length) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glInvalidateFramebuffer)(GLenum target, GLsizei numAttachments, const GLenum * attachments) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glInvalidateSubFramebuffer)(GLenum target, GLsizei numAttachments, const GLenum * attachments, GLint x, GLint y, GLsizei width, GLsizei height) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glInvalidateTexImage)(GLuint texture, GLint level) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glInvalidateTexSubImage)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth) = NULL;

+

+static int Load_ARB_invalidate_subdata(void)

+{

+	int numFailed = 0;

+	_ptrc_glInvalidateBufferData = (void (CODEGEN_FUNCPTR *)(GLuint))IntGetProcAddress("glInvalidateBufferData");

+	if(!_ptrc_glInvalidateBufferData) numFailed++;

+	_ptrc_glInvalidateBufferSubData = (void (CODEGEN_FUNCPTR *)(GLuint, GLintptr, GLsizeiptr))IntGetProcAddress("glInvalidateBufferSubData");

+	if(!_ptrc_glInvalidateBufferSubData) numFailed++;

+	_ptrc_glInvalidateFramebuffer = (void (CODEGEN_FUNCPTR *)(GLenum, GLsizei, const GLenum *))IntGetProcAddress("glInvalidateFramebuffer");

+	if(!_ptrc_glInvalidateFramebuffer) numFailed++;

+	_ptrc_glInvalidateSubFramebuffer = (void (CODEGEN_FUNCPTR *)(GLenum, GLsizei, const GLenum *, GLint, GLint, GLsizei, GLsizei))IntGetProcAddress("glInvalidateSubFramebuffer");

+	if(!_ptrc_glInvalidateSubFramebuffer) numFailed++;

+	_ptrc_glInvalidateTexImage = (void (CODEGEN_FUNCPTR *)(GLuint, GLint))IntGetProcAddress("glInvalidateTexImage");

+	if(!_ptrc_glInvalidateTexImage) numFailed++;

+	_ptrc_glInvalidateTexSubImage = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei))IntGetProcAddress("glInvalidateTexSubImage");

+	if(!_ptrc_glInvalidateTexSubImage) numFailed++;

+	return numFailed;

+}

+

+void (CODEGEN_FUNCPTR *_ptrc_glTexStorage2DMultisample)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexStorage3DMultisample)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations) = NULL;

+

+static int Load_ARB_texture_storage_multisample(void)

+{

+	int numFailed = 0;

+	_ptrc_glTexStorage2DMultisample = (void (CODEGEN_FUNCPTR *)(GLenum, GLsizei, GLenum, GLsizei, GLsizei, GLboolean))IntGetProcAddress("glTexStorage2DMultisample");

+	if(!_ptrc_glTexStorage2DMultisample) numFailed++;

+	_ptrc_glTexStorage3DMultisample = (void (CODEGEN_FUNCPTR *)(GLenum, GLsizei, GLenum, GLsizei, GLsizei, GLsizei, GLboolean))IntGetProcAddress("glTexStorage3DMultisample");

+	if(!_ptrc_glTexStorage3DMultisample) numFailed++;

+	return numFailed;

+}

+

+void (CODEGEN_FUNCPTR *_ptrc_glDebugMessageCallback)(GLDEBUGPROC callback, const void * userParam) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glDebugMessageControl)(GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint * ids, GLboolean enabled) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glDebugMessageInsert)(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar * buf) = NULL;

+GLuint (CODEGEN_FUNCPTR *_ptrc_glGetDebugMessageLog)(GLuint count, GLsizei bufSize, GLenum * sources, GLenum * types, GLuint * ids, GLenum * severities, GLsizei * lengths, GLchar * messageLog) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetObjectLabel)(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei * length, GLchar * label) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetObjectPtrLabel)(const void * ptr, GLsizei bufSize, GLsizei * length, GLchar * label) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetPointerv)(GLenum pname, void ** params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glObjectLabel)(GLenum identifier, GLuint name, GLsizei length, const GLchar * label) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glObjectPtrLabel)(const void * ptr, GLsizei length, const GLchar * label) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glPopDebugGroup)(void) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glPushDebugGroup)(GLenum source, GLuint id, GLsizei length, const GLchar * message) = NULL;

+

+static int Load_KHR_debug(void)

+{

+	int numFailed = 0;

+	_ptrc_glDebugMessageCallback = (void (CODEGEN_FUNCPTR *)(GLDEBUGPROC, const void *))IntGetProcAddress("glDebugMessageCallback");

+	if(!_ptrc_glDebugMessageCallback) numFailed++;

+	_ptrc_glDebugMessageControl = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLenum, GLsizei, const GLuint *, GLboolean))IntGetProcAddress("glDebugMessageControl");

+	if(!_ptrc_glDebugMessageControl) numFailed++;

+	_ptrc_glDebugMessageInsert = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLuint, GLenum, GLsizei, const GLchar *))IntGetProcAddress("glDebugMessageInsert");

+	if(!_ptrc_glDebugMessageInsert) numFailed++;

+	_ptrc_glGetDebugMessageLog = (GLuint (CODEGEN_FUNCPTR *)(GLuint, GLsizei, GLenum *, GLenum *, GLuint *, GLenum *, GLsizei *, GLchar *))IntGetProcAddress("glGetDebugMessageLog");

+	if(!_ptrc_glGetDebugMessageLog) numFailed++;

+	_ptrc_glGetObjectLabel = (void (CODEGEN_FUNCPTR *)(GLenum, GLuint, GLsizei, GLsizei *, GLchar *))IntGetProcAddress("glGetObjectLabel");

+	if(!_ptrc_glGetObjectLabel) numFailed++;

+	_ptrc_glGetObjectPtrLabel = (void (CODEGEN_FUNCPTR *)(const void *, GLsizei, GLsizei *, GLchar *))IntGetProcAddress("glGetObjectPtrLabel");

+	if(!_ptrc_glGetObjectPtrLabel) numFailed++;

+	_ptrc_glGetPointerv = (void (CODEGEN_FUNCPTR *)(GLenum, void **))IntGetProcAddress("glGetPointerv");

+	if(!_ptrc_glGetPointerv) numFailed++;

+	_ptrc_glObjectLabel = (void (CODEGEN_FUNCPTR *)(GLenum, GLuint, GLsizei, const GLchar *))IntGetProcAddress("glObjectLabel");

+	if(!_ptrc_glObjectLabel) numFailed++;

+	_ptrc_glObjectPtrLabel = (void (CODEGEN_FUNCPTR *)(const void *, GLsizei, const GLchar *))IntGetProcAddress("glObjectPtrLabel");

+	if(!_ptrc_glObjectPtrLabel) numFailed++;

+	_ptrc_glPopDebugGroup = (void (CODEGEN_FUNCPTR *)(void))IntGetProcAddress("glPopDebugGroup");

+	if(!_ptrc_glPopDebugGroup) numFailed++;

+	_ptrc_glPushDebugGroup = (void (CODEGEN_FUNCPTR *)(GLenum, GLuint, GLsizei, const GLchar *))IntGetProcAddress("glPushDebugGroup");

+	if(!_ptrc_glPushDebugGroup) numFailed++;

+	return numFailed;

+}

+

+void (CODEGEN_FUNCPTR *_ptrc_glBufferStorage)(GLenum target, GLsizeiptr size, const void * data, GLbitfield flags) = NULL;

+

+static int Load_ARB_buffer_storage(void)

+{

+	int numFailed = 0;

+	_ptrc_glBufferStorage = (void (CODEGEN_FUNCPTR *)(GLenum, GLsizeiptr, const void *, GLbitfield))IntGetProcAddress("glBufferStorage");

+	if(!_ptrc_glBufferStorage) numFailed++;

+	return numFailed;

+}

+

+void (CODEGEN_FUNCPTR *_ptrc_glClearTexImage)(GLuint texture, GLint level, GLenum format, GLenum type, const void * data) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glClearTexSubImage)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * data) = NULL;

+

+static int Load_ARB_clear_texture(void)

+{

+	int numFailed = 0;

+	_ptrc_glClearTexImage = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLenum, GLenum, const void *))IntGetProcAddress("glClearTexImage");

+	if(!_ptrc_glClearTexImage) numFailed++;

+	_ptrc_glClearTexSubImage = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const void *))IntGetProcAddress("glClearTexSubImage");

+	if(!_ptrc_glClearTexSubImage) numFailed++;

+	return numFailed;

+}

+

+void (CODEGEN_FUNCPTR *_ptrc_glBindBuffersBase)(GLenum target, GLuint first, GLsizei count, const GLuint * buffers) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glBindBuffersRange)(GLenum target, GLuint first, GLsizei count, const GLuint * buffers, const GLintptr * offsets, const GLsizeiptr * sizes) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glBindImageTextures)(GLuint first, GLsizei count, const GLuint * textures) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glBindSamplers)(GLuint first, GLsizei count, const GLuint * samplers) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glBindTextures)(GLuint first, GLsizei count, const GLuint * textures) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glBindVertexBuffers)(GLuint first, GLsizei count, const GLuint * buffers, const GLintptr * offsets, const GLsizei * strides) = NULL;

+

+static int Load_ARB_multi_bind(void)

+{

+	int numFailed = 0;

+	_ptrc_glBindBuffersBase = (void (CODEGEN_FUNCPTR *)(GLenum, GLuint, GLsizei, const GLuint *))IntGetProcAddress("glBindBuffersBase");

+	if(!_ptrc_glBindBuffersBase) numFailed++;

+	_ptrc_glBindBuffersRange = (void (CODEGEN_FUNCPTR *)(GLenum, GLuint, GLsizei, const GLuint *, const GLintptr *, const GLsizeiptr *))IntGetProcAddress("glBindBuffersRange");

+	if(!_ptrc_glBindBuffersRange) numFailed++;

+	_ptrc_glBindImageTextures = (void (CODEGEN_FUNCPTR *)(GLuint, GLsizei, const GLuint *))IntGetProcAddress("glBindImageTextures");

+	if(!_ptrc_glBindImageTextures) numFailed++;

+	_ptrc_glBindSamplers = (void (CODEGEN_FUNCPTR *)(GLuint, GLsizei, const GLuint *))IntGetProcAddress("glBindSamplers");

+	if(!_ptrc_glBindSamplers) numFailed++;

+	_ptrc_glBindTextures = (void (CODEGEN_FUNCPTR *)(GLuint, GLsizei, const GLuint *))IntGetProcAddress("glBindTextures");

+	if(!_ptrc_glBindTextures) numFailed++;

+	_ptrc_glBindVertexBuffers = (void (CODEGEN_FUNCPTR *)(GLuint, GLsizei, const GLuint *, const GLintptr *, const GLsizei *))IntGetProcAddress("glBindVertexBuffers");

+	if(!_ptrc_glBindVertexBuffers) numFailed++;

+	return numFailed;

+}

+

+void (CODEGEN_FUNCPTR *_ptrc_glClipControl)(GLenum origin, GLenum depth) = NULL;

+

+static int Load_ARB_clip_control(void)

+{

+	int numFailed = 0;

+	_ptrc_glClipControl = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum))IntGetProcAddress("glClipControl");

+	if(!_ptrc_glClipControl) numFailed++;

+	return numFailed;

+}

+

+void (CODEGEN_FUNCPTR *_ptrc_glBindTextureUnit)(GLuint unit, GLuint texture) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glBlitNamedFramebuffer)(GLuint readFramebuffer, GLuint drawFramebuffer, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) = NULL;

+GLenum (CODEGEN_FUNCPTR *_ptrc_glCheckNamedFramebufferStatus)(GLuint framebuffer, GLenum target) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glClearNamedBufferData)(GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void * data) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glClearNamedBufferSubData)(GLuint buffer, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void * data) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glClearNamedFramebufferfi)(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLfloat depth, GLint stencil) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glClearNamedFramebufferfv)(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLfloat * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glClearNamedFramebufferiv)(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLint * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glClearNamedFramebufferuiv)(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLuint * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glCompressedTextureSubImage1D)(GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void * data) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glCompressedTextureSubImage2D)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void * data) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glCompressedTextureSubImage3D)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void * data) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glCopyNamedBufferSubData)(GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glCopyTextureSubImage1D)(GLuint texture, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glCopyTextureSubImage2D)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glCopyTextureSubImage3D)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glCreateBuffers)(GLsizei n, GLuint * buffers) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glCreateFramebuffers)(GLsizei n, GLuint * framebuffers) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glCreateProgramPipelines)(GLsizei n, GLuint * pipelines) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glCreateQueries)(GLenum target, GLsizei n, GLuint * ids) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glCreateRenderbuffers)(GLsizei n, GLuint * renderbuffers) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glCreateSamplers)(GLsizei n, GLuint * samplers) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glCreateTextures)(GLenum target, GLsizei n, GLuint * textures) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glCreateTransformFeedbacks)(GLsizei n, GLuint * ids) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glCreateVertexArrays)(GLsizei n, GLuint * arrays) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glDisableVertexArrayAttrib)(GLuint vaobj, GLuint index) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glEnableVertexArrayAttrib)(GLuint vaobj, GLuint index) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glFlushMappedNamedBufferRange)(GLuint buffer, GLintptr offset, GLsizeiptr length) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGenerateTextureMipmap)(GLuint texture) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetCompressedTextureImage)(GLuint texture, GLint level, GLsizei bufSize, void * pixels) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetNamedBufferParameteri64v)(GLuint buffer, GLenum pname, GLint64 * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetNamedBufferParameteriv)(GLuint buffer, GLenum pname, GLint * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetNamedBufferPointerv)(GLuint buffer, GLenum pname, void ** params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetNamedBufferSubData)(GLuint buffer, GLintptr offset, GLsizeiptr size, void * data) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetNamedFramebufferAttachmentParameteriv)(GLuint framebuffer, GLenum attachment, GLenum pname, GLint * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetNamedFramebufferParameteriv)(GLuint framebuffer, GLenum pname, GLint * param) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetNamedRenderbufferParameteriv)(GLuint renderbuffer, GLenum pname, GLint * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetQueryBufferObjecti64v)(GLuint id, GLuint buffer, GLenum pname, GLintptr offset) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetQueryBufferObjectiv)(GLuint id, GLuint buffer, GLenum pname, GLintptr offset) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetQueryBufferObjectui64v)(GLuint id, GLuint buffer, GLenum pname, GLintptr offset) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetQueryBufferObjectuiv)(GLuint id, GLuint buffer, GLenum pname, GLintptr offset) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetTextureImage)(GLuint texture, GLint level, GLenum format, GLenum type, GLsizei bufSize, void * pixels) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetTextureLevelParameterfv)(GLuint texture, GLint level, GLenum pname, GLfloat * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetTextureLevelParameteriv)(GLuint texture, GLint level, GLenum pname, GLint * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetTextureParameterIiv)(GLuint texture, GLenum pname, GLint * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetTextureParameterIuiv)(GLuint texture, GLenum pname, GLuint * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetTextureParameterfv)(GLuint texture, GLenum pname, GLfloat * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetTextureParameteriv)(GLuint texture, GLenum pname, GLint * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetTransformFeedbacki64_v)(GLuint xfb, GLenum pname, GLuint index, GLint64 * param) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetTransformFeedbacki_v)(GLuint xfb, GLenum pname, GLuint index, GLint * param) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetTransformFeedbackiv)(GLuint xfb, GLenum pname, GLint * param) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetVertexArrayIndexed64iv)(GLuint vaobj, GLuint index, GLenum pname, GLint64 * param) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetVertexArrayIndexediv)(GLuint vaobj, GLuint index, GLenum pname, GLint * param) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetVertexArrayiv)(GLuint vaobj, GLenum pname, GLint * param) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glInvalidateNamedFramebufferData)(GLuint framebuffer, GLsizei numAttachments, const GLenum * attachments) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glInvalidateNamedFramebufferSubData)(GLuint framebuffer, GLsizei numAttachments, const GLenum * attachments, GLint x, GLint y, GLsizei width, GLsizei height) = NULL;

+void * (CODEGEN_FUNCPTR *_ptrc_glMapNamedBuffer)(GLuint buffer, GLenum access) = NULL;

+void * (CODEGEN_FUNCPTR *_ptrc_glMapNamedBufferRange)(GLuint buffer, GLintptr offset, GLsizeiptr length, GLbitfield access) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glNamedBufferData)(GLuint buffer, GLsizeiptr size, const void * data, GLenum usage) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glNamedBufferStorage)(GLuint buffer, GLsizeiptr size, const void * data, GLbitfield flags) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glNamedBufferSubData)(GLuint buffer, GLintptr offset, GLsizeiptr size, const void * data) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glNamedFramebufferDrawBuffer)(GLuint framebuffer, GLenum buf) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glNamedFramebufferDrawBuffers)(GLuint framebuffer, GLsizei n, const GLenum * bufs) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glNamedFramebufferParameteri)(GLuint framebuffer, GLenum pname, GLint param) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glNamedFramebufferReadBuffer)(GLuint framebuffer, GLenum src) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glNamedFramebufferRenderbuffer)(GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glNamedFramebufferTexture)(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glNamedFramebufferTextureLayer)(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glNamedRenderbufferStorage)(GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glNamedRenderbufferStorageMultisample)(GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTextureBuffer)(GLuint texture, GLenum internalformat, GLuint buffer) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTextureBufferRange)(GLuint texture, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTextureParameterIiv)(GLuint texture, GLenum pname, const GLint * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTextureParameterIuiv)(GLuint texture, GLenum pname, const GLuint * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTextureParameterf)(GLuint texture, GLenum pname, GLfloat param) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTextureParameterfv)(GLuint texture, GLenum pname, const GLfloat * param) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTextureParameteri)(GLuint texture, GLenum pname, GLint param) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTextureParameteriv)(GLuint texture, GLenum pname, const GLint * param) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTextureStorage1D)(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTextureStorage2D)(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTextureStorage2DMultisample)(GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTextureStorage3D)(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTextureStorage3DMultisample)(GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTextureSubImage1D)(GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void * pixels) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTextureSubImage2D)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * pixels) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTextureSubImage3D)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * pixels) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTransformFeedbackBufferBase)(GLuint xfb, GLuint index, GLuint buffer) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTransformFeedbackBufferRange)(GLuint xfb, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) = NULL;

+GLboolean (CODEGEN_FUNCPTR *_ptrc_glUnmapNamedBuffer)(GLuint buffer) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexArrayAttribBinding)(GLuint vaobj, GLuint attribindex, GLuint bindingindex) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexArrayAttribFormat)(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexArrayAttribIFormat)(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexArrayAttribLFormat)(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexArrayBindingDivisor)(GLuint vaobj, GLuint bindingindex, GLuint divisor) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexArrayElementBuffer)(GLuint vaobj, GLuint buffer) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexArrayVertexBuffer)(GLuint vaobj, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexArrayVertexBuffers)(GLuint vaobj, GLuint first, GLsizei count, const GLuint * buffers, const GLintptr * offsets, const GLsizei * strides) = NULL;

+

+static int Load_ARB_direct_state_access(void)

+{

+	int numFailed = 0;

+	_ptrc_glBindTextureUnit = (void (CODEGEN_FUNCPTR *)(GLuint, GLuint))IntGetProcAddress("glBindTextureUnit");

+	if(!_ptrc_glBindTextureUnit) numFailed++;

+	_ptrc_glBlitNamedFramebuffer = (void (CODEGEN_FUNCPTR *)(GLuint, GLuint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum))IntGetProcAddress("glBlitNamedFramebuffer");

+	if(!_ptrc_glBlitNamedFramebuffer) numFailed++;

+	_ptrc_glCheckNamedFramebufferStatus = (GLenum (CODEGEN_FUNCPTR *)(GLuint, GLenum))IntGetProcAddress("glCheckNamedFramebufferStatus");

+	if(!_ptrc_glCheckNamedFramebufferStatus) numFailed++;

+	_ptrc_glClearNamedBufferData = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, GLenum, GLenum, const void *))IntGetProcAddress("glClearNamedBufferData");

+	if(!_ptrc_glClearNamedBufferData) numFailed++;

+	_ptrc_glClearNamedBufferSubData = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, GLintptr, GLsizeiptr, GLenum, GLenum, const void *))IntGetProcAddress("glClearNamedBufferSubData");

+	if(!_ptrc_glClearNamedBufferSubData) numFailed++;

+	_ptrc_glClearNamedFramebufferfi = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, GLint, const GLfloat, GLint))IntGetProcAddress("glClearNamedFramebufferfi");

+	if(!_ptrc_glClearNamedFramebufferfi) numFailed++;

+	_ptrc_glClearNamedFramebufferfv = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, GLint, const GLfloat *))IntGetProcAddress("glClearNamedFramebufferfv");

+	if(!_ptrc_glClearNamedFramebufferfv) numFailed++;

+	_ptrc_glClearNamedFramebufferiv = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, GLint, const GLint *))IntGetProcAddress("glClearNamedFramebufferiv");

+	if(!_ptrc_glClearNamedFramebufferiv) numFailed++;

+	_ptrc_glClearNamedFramebufferuiv = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, GLint, const GLuint *))IntGetProcAddress("glClearNamedFramebufferuiv");

+	if(!_ptrc_glClearNamedFramebufferuiv) numFailed++;

+	_ptrc_glCompressedTextureSubImage1D = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLint, GLsizei, GLenum, GLsizei, const void *))IntGetProcAddress("glCompressedTextureSubImage1D");

+	if(!_ptrc_glCompressedTextureSubImage1D) numFailed++;

+	_ptrc_glCompressedTextureSubImage2D = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, const void *))IntGetProcAddress("glCompressedTextureSubImage2D");

+	if(!_ptrc_glCompressedTextureSubImage2D) numFailed++;

+	_ptrc_glCompressedTextureSubImage3D = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, const void *))IntGetProcAddress("glCompressedTextureSubImage3D");

+	if(!_ptrc_glCompressedTextureSubImage3D) numFailed++;

+	_ptrc_glCopyNamedBufferSubData = (void (CODEGEN_FUNCPTR *)(GLuint, GLuint, GLintptr, GLintptr, GLsizeiptr))IntGetProcAddress("glCopyNamedBufferSubData");

+	if(!_ptrc_glCopyNamedBufferSubData) numFailed++;

+	_ptrc_glCopyTextureSubImage1D = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLint, GLint, GLint, GLsizei))IntGetProcAddress("glCopyTextureSubImage1D");

+	if(!_ptrc_glCopyTextureSubImage1D) numFailed++;

+	_ptrc_glCopyTextureSubImage2D = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei))IntGetProcAddress("glCopyTextureSubImage2D");

+	if(!_ptrc_glCopyTextureSubImage2D) numFailed++;

+	_ptrc_glCopyTextureSubImage3D = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei))IntGetProcAddress("glCopyTextureSubImage3D");

+	if(!_ptrc_glCopyTextureSubImage3D) numFailed++;

+	_ptrc_glCreateBuffers = (void (CODEGEN_FUNCPTR *)(GLsizei, GLuint *))IntGetProcAddress("glCreateBuffers");

+	if(!_ptrc_glCreateBuffers) numFailed++;

+	_ptrc_glCreateFramebuffers = (void (CODEGEN_FUNCPTR *)(GLsizei, GLuint *))IntGetProcAddress("glCreateFramebuffers");

+	if(!_ptrc_glCreateFramebuffers) numFailed++;

+	_ptrc_glCreateProgramPipelines = (void (CODEGEN_FUNCPTR *)(GLsizei, GLuint *))IntGetProcAddress("glCreateProgramPipelines");

+	if(!_ptrc_glCreateProgramPipelines) numFailed++;

+	_ptrc_glCreateQueries = (void (CODEGEN_FUNCPTR *)(GLenum, GLsizei, GLuint *))IntGetProcAddress("glCreateQueries");

+	if(!_ptrc_glCreateQueries) numFailed++;

+	_ptrc_glCreateRenderbuffers = (void (CODEGEN_FUNCPTR *)(GLsizei, GLuint *))IntGetProcAddress("glCreateRenderbuffers");

+	if(!_ptrc_glCreateRenderbuffers) numFailed++;

+	_ptrc_glCreateSamplers = (void (CODEGEN_FUNCPTR *)(GLsizei, GLuint *))IntGetProcAddress("glCreateSamplers");

+	if(!_ptrc_glCreateSamplers) numFailed++;

+	_ptrc_glCreateTextures = (void (CODEGEN_FUNCPTR *)(GLenum, GLsizei, GLuint *))IntGetProcAddress("glCreateTextures");

+	if(!_ptrc_glCreateTextures) numFailed++;

+	_ptrc_glCreateTransformFeedbacks = (void (CODEGEN_FUNCPTR *)(GLsizei, GLuint *))IntGetProcAddress("glCreateTransformFeedbacks");

+	if(!_ptrc_glCreateTransformFeedbacks) numFailed++;

+	_ptrc_glCreateVertexArrays = (void (CODEGEN_FUNCPTR *)(GLsizei, GLuint *))IntGetProcAddress("glCreateVertexArrays");

+	if(!_ptrc_glCreateVertexArrays) numFailed++;

+	_ptrc_glDisableVertexArrayAttrib = (void (CODEGEN_FUNCPTR *)(GLuint, GLuint))IntGetProcAddress("glDisableVertexArrayAttrib");

+	if(!_ptrc_glDisableVertexArrayAttrib) numFailed++;

+	_ptrc_glEnableVertexArrayAttrib = (void (CODEGEN_FUNCPTR *)(GLuint, GLuint))IntGetProcAddress("glEnableVertexArrayAttrib");

+	if(!_ptrc_glEnableVertexArrayAttrib) numFailed++;

+	_ptrc_glFlushMappedNamedBufferRange = (void (CODEGEN_FUNCPTR *)(GLuint, GLintptr, GLsizeiptr))IntGetProcAddress("glFlushMappedNamedBufferRange");

+	if(!_ptrc_glFlushMappedNamedBufferRange) numFailed++;

+	_ptrc_glGenerateTextureMipmap = (void (CODEGEN_FUNCPTR *)(GLuint))IntGetProcAddress("glGenerateTextureMipmap");

+	if(!_ptrc_glGenerateTextureMipmap) numFailed++;

+	_ptrc_glGetCompressedTextureImage = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLsizei, void *))IntGetProcAddress("glGetCompressedTextureImage");

+	if(!_ptrc_glGetCompressedTextureImage) numFailed++;

+	_ptrc_glGetNamedBufferParameteri64v = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, GLint64 *))IntGetProcAddress("glGetNamedBufferParameteri64v");

+	if(!_ptrc_glGetNamedBufferParameteri64v) numFailed++;

+	_ptrc_glGetNamedBufferParameteriv = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, GLint *))IntGetProcAddress("glGetNamedBufferParameteriv");

+	if(!_ptrc_glGetNamedBufferParameteriv) numFailed++;

+	_ptrc_glGetNamedBufferPointerv = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, void **))IntGetProcAddress("glGetNamedBufferPointerv");

+	if(!_ptrc_glGetNamedBufferPointerv) numFailed++;

+	_ptrc_glGetNamedBufferSubData = (void (CODEGEN_FUNCPTR *)(GLuint, GLintptr, GLsizeiptr, void *))IntGetProcAddress("glGetNamedBufferSubData");

+	if(!_ptrc_glGetNamedBufferSubData) numFailed++;

+	_ptrc_glGetNamedFramebufferAttachmentParameteriv = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, GLenum, GLint *))IntGetProcAddress("glGetNamedFramebufferAttachmentParameteriv");

+	if(!_ptrc_glGetNamedFramebufferAttachmentParameteriv) numFailed++;

+	_ptrc_glGetNamedFramebufferParameteriv = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, GLint *))IntGetProcAddress("glGetNamedFramebufferParameteriv");

+	if(!_ptrc_glGetNamedFramebufferParameteriv) numFailed++;

+	_ptrc_glGetNamedRenderbufferParameteriv = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, GLint *))IntGetProcAddress("glGetNamedRenderbufferParameteriv");

+	if(!_ptrc_glGetNamedRenderbufferParameteriv) numFailed++;

+	_ptrc_glGetQueryBufferObjecti64v = (void (CODEGEN_FUNCPTR *)(GLuint, GLuint, GLenum, GLintptr))IntGetProcAddress("glGetQueryBufferObjecti64v");

+	if(!_ptrc_glGetQueryBufferObjecti64v) numFailed++;

+	_ptrc_glGetQueryBufferObjectiv = (void (CODEGEN_FUNCPTR *)(GLuint, GLuint, GLenum, GLintptr))IntGetProcAddress("glGetQueryBufferObjectiv");

+	if(!_ptrc_glGetQueryBufferObjectiv) numFailed++;

+	_ptrc_glGetQueryBufferObjectui64v = (void (CODEGEN_FUNCPTR *)(GLuint, GLuint, GLenum, GLintptr))IntGetProcAddress("glGetQueryBufferObjectui64v");

+	if(!_ptrc_glGetQueryBufferObjectui64v) numFailed++;

+	_ptrc_glGetQueryBufferObjectuiv = (void (CODEGEN_FUNCPTR *)(GLuint, GLuint, GLenum, GLintptr))IntGetProcAddress("glGetQueryBufferObjectuiv");

+	if(!_ptrc_glGetQueryBufferObjectuiv) numFailed++;

+	_ptrc_glGetTextureImage = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLenum, GLenum, GLsizei, void *))IntGetProcAddress("glGetTextureImage");

+	if(!_ptrc_glGetTextureImage) numFailed++;

+	_ptrc_glGetTextureLevelParameterfv = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLenum, GLfloat *))IntGetProcAddress("glGetTextureLevelParameterfv");

+	if(!_ptrc_glGetTextureLevelParameterfv) numFailed++;

+	_ptrc_glGetTextureLevelParameteriv = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLenum, GLint *))IntGetProcAddress("glGetTextureLevelParameteriv");

+	if(!_ptrc_glGetTextureLevelParameteriv) numFailed++;

+	_ptrc_glGetTextureParameterIiv = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, GLint *))IntGetProcAddress("glGetTextureParameterIiv");

+	if(!_ptrc_glGetTextureParameterIiv) numFailed++;

+	_ptrc_glGetTextureParameterIuiv = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, GLuint *))IntGetProcAddress("glGetTextureParameterIuiv");

+	if(!_ptrc_glGetTextureParameterIuiv) numFailed++;

+	_ptrc_glGetTextureParameterfv = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, GLfloat *))IntGetProcAddress("glGetTextureParameterfv");

+	if(!_ptrc_glGetTextureParameterfv) numFailed++;

+	_ptrc_glGetTextureParameteriv = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, GLint *))IntGetProcAddress("glGetTextureParameteriv");

+	if(!_ptrc_glGetTextureParameteriv) numFailed++;

+	_ptrc_glGetTransformFeedbacki64_v = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, GLuint, GLint64 *))IntGetProcAddress("glGetTransformFeedbacki64_v");

+	if(!_ptrc_glGetTransformFeedbacki64_v) numFailed++;

+	_ptrc_glGetTransformFeedbacki_v = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, GLuint, GLint *))IntGetProcAddress("glGetTransformFeedbacki_v");

+	if(!_ptrc_glGetTransformFeedbacki_v) numFailed++;

+	_ptrc_glGetTransformFeedbackiv = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, GLint *))IntGetProcAddress("glGetTransformFeedbackiv");

+	if(!_ptrc_glGetTransformFeedbackiv) numFailed++;

+	_ptrc_glGetVertexArrayIndexed64iv = (void (CODEGEN_FUNCPTR *)(GLuint, GLuint, GLenum, GLint64 *))IntGetProcAddress("glGetVertexArrayIndexed64iv");

+	if(!_ptrc_glGetVertexArrayIndexed64iv) numFailed++;

+	_ptrc_glGetVertexArrayIndexediv = (void (CODEGEN_FUNCPTR *)(GLuint, GLuint, GLenum, GLint *))IntGetProcAddress("glGetVertexArrayIndexediv");

+	if(!_ptrc_glGetVertexArrayIndexediv) numFailed++;

+	_ptrc_glGetVertexArrayiv = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, GLint *))IntGetProcAddress("glGetVertexArrayiv");

+	if(!_ptrc_glGetVertexArrayiv) numFailed++;

+	_ptrc_glInvalidateNamedFramebufferData = (void (CODEGEN_FUNCPTR *)(GLuint, GLsizei, const GLenum *))IntGetProcAddress("glInvalidateNamedFramebufferData");

+	if(!_ptrc_glInvalidateNamedFramebufferData) numFailed++;

+	_ptrc_glInvalidateNamedFramebufferSubData = (void (CODEGEN_FUNCPTR *)(GLuint, GLsizei, const GLenum *, GLint, GLint, GLsizei, GLsizei))IntGetProcAddress("glInvalidateNamedFramebufferSubData");

+	if(!_ptrc_glInvalidateNamedFramebufferSubData) numFailed++;

+	_ptrc_glMapNamedBuffer = (void * (CODEGEN_FUNCPTR *)(GLuint, GLenum))IntGetProcAddress("glMapNamedBuffer");

+	if(!_ptrc_glMapNamedBuffer) numFailed++;

+	_ptrc_glMapNamedBufferRange = (void * (CODEGEN_FUNCPTR *)(GLuint, GLintptr, GLsizeiptr, GLbitfield))IntGetProcAddress("glMapNamedBufferRange");

+	if(!_ptrc_glMapNamedBufferRange) numFailed++;

+	_ptrc_glNamedBufferData = (void (CODEGEN_FUNCPTR *)(GLuint, GLsizeiptr, const void *, GLenum))IntGetProcAddress("glNamedBufferData");

+	if(!_ptrc_glNamedBufferData) numFailed++;

+	_ptrc_glNamedBufferStorage = (void (CODEGEN_FUNCPTR *)(GLuint, GLsizeiptr, const void *, GLbitfield))IntGetProcAddress("glNamedBufferStorage");

+	if(!_ptrc_glNamedBufferStorage) numFailed++;

+	_ptrc_glNamedBufferSubData = (void (CODEGEN_FUNCPTR *)(GLuint, GLintptr, GLsizeiptr, const void *))IntGetProcAddress("glNamedBufferSubData");

+	if(!_ptrc_glNamedBufferSubData) numFailed++;

+	_ptrc_glNamedFramebufferDrawBuffer = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum))IntGetProcAddress("glNamedFramebufferDrawBuffer");

+	if(!_ptrc_glNamedFramebufferDrawBuffer) numFailed++;

+	_ptrc_glNamedFramebufferDrawBuffers = (void (CODEGEN_FUNCPTR *)(GLuint, GLsizei, const GLenum *))IntGetProcAddress("glNamedFramebufferDrawBuffers");

+	if(!_ptrc_glNamedFramebufferDrawBuffers) numFailed++;

+	_ptrc_glNamedFramebufferParameteri = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, GLint))IntGetProcAddress("glNamedFramebufferParameteri");

+	if(!_ptrc_glNamedFramebufferParameteri) numFailed++;

+	_ptrc_glNamedFramebufferReadBuffer = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum))IntGetProcAddress("glNamedFramebufferReadBuffer");

+	if(!_ptrc_glNamedFramebufferReadBuffer) numFailed++;

+	_ptrc_glNamedFramebufferRenderbuffer = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, GLenum, GLuint))IntGetProcAddress("glNamedFramebufferRenderbuffer");

+	if(!_ptrc_glNamedFramebufferRenderbuffer) numFailed++;

+	_ptrc_glNamedFramebufferTexture = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, GLuint, GLint))IntGetProcAddress("glNamedFramebufferTexture");

+	if(!_ptrc_glNamedFramebufferTexture) numFailed++;

+	_ptrc_glNamedFramebufferTextureLayer = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, GLuint, GLint, GLint))IntGetProcAddress("glNamedFramebufferTextureLayer");

+	if(!_ptrc_glNamedFramebufferTextureLayer) numFailed++;

+	_ptrc_glNamedRenderbufferStorage = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, GLsizei, GLsizei))IntGetProcAddress("glNamedRenderbufferStorage");

+	if(!_ptrc_glNamedRenderbufferStorage) numFailed++;

+	_ptrc_glNamedRenderbufferStorageMultisample = (void (CODEGEN_FUNCPTR *)(GLuint, GLsizei, GLenum, GLsizei, GLsizei))IntGetProcAddress("glNamedRenderbufferStorageMultisample");

+	if(!_ptrc_glNamedRenderbufferStorageMultisample) numFailed++;

+	_ptrc_glTextureBuffer = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, GLuint))IntGetProcAddress("glTextureBuffer");

+	if(!_ptrc_glTextureBuffer) numFailed++;

+	_ptrc_glTextureBufferRange = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, GLuint, GLintptr, GLsizeiptr))IntGetProcAddress("glTextureBufferRange");

+	if(!_ptrc_glTextureBufferRange) numFailed++;

+	_ptrc_glTextureParameterIiv = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, const GLint *))IntGetProcAddress("glTextureParameterIiv");

+	if(!_ptrc_glTextureParameterIiv) numFailed++;

+	_ptrc_glTextureParameterIuiv = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, const GLuint *))IntGetProcAddress("glTextureParameterIuiv");

+	if(!_ptrc_glTextureParameterIuiv) numFailed++;

+	_ptrc_glTextureParameterf = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, GLfloat))IntGetProcAddress("glTextureParameterf");

+	if(!_ptrc_glTextureParameterf) numFailed++;

+	_ptrc_glTextureParameterfv = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, const GLfloat *))IntGetProcAddress("glTextureParameterfv");

+	if(!_ptrc_glTextureParameterfv) numFailed++;

+	_ptrc_glTextureParameteri = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, GLint))IntGetProcAddress("glTextureParameteri");

+	if(!_ptrc_glTextureParameteri) numFailed++;

+	_ptrc_glTextureParameteriv = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, const GLint *))IntGetProcAddress("glTextureParameteriv");

+	if(!_ptrc_glTextureParameteriv) numFailed++;

+	_ptrc_glTextureStorage1D = (void (CODEGEN_FUNCPTR *)(GLuint, GLsizei, GLenum, GLsizei))IntGetProcAddress("glTextureStorage1D");

+	if(!_ptrc_glTextureStorage1D) numFailed++;

+	_ptrc_glTextureStorage2D = (void (CODEGEN_FUNCPTR *)(GLuint, GLsizei, GLenum, GLsizei, GLsizei))IntGetProcAddress("glTextureStorage2D");

+	if(!_ptrc_glTextureStorage2D) numFailed++;

+	_ptrc_glTextureStorage2DMultisample = (void (CODEGEN_FUNCPTR *)(GLuint, GLsizei, GLenum, GLsizei, GLsizei, GLboolean))IntGetProcAddress("glTextureStorage2DMultisample");

+	if(!_ptrc_glTextureStorage2DMultisample) numFailed++;

+	_ptrc_glTextureStorage3D = (void (CODEGEN_FUNCPTR *)(GLuint, GLsizei, GLenum, GLsizei, GLsizei, GLsizei))IntGetProcAddress("glTextureStorage3D");

+	if(!_ptrc_glTextureStorage3D) numFailed++;

+	_ptrc_glTextureStorage3DMultisample = (void (CODEGEN_FUNCPTR *)(GLuint, GLsizei, GLenum, GLsizei, GLsizei, GLsizei, GLboolean))IntGetProcAddress("glTextureStorage3DMultisample");

+	if(!_ptrc_glTextureStorage3DMultisample) numFailed++;

+	_ptrc_glTextureSubImage1D = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLint, GLsizei, GLenum, GLenum, const void *))IntGetProcAddress("glTextureSubImage1D");

+	if(!_ptrc_glTextureSubImage1D) numFailed++;

+	_ptrc_glTextureSubImage2D = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const void *))IntGetProcAddress("glTextureSubImage2D");

+	if(!_ptrc_glTextureSubImage2D) numFailed++;

+	_ptrc_glTextureSubImage3D = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const void *))IntGetProcAddress("glTextureSubImage3D");

+	if(!_ptrc_glTextureSubImage3D) numFailed++;

+	_ptrc_glTransformFeedbackBufferBase = (void (CODEGEN_FUNCPTR *)(GLuint, GLuint, GLuint))IntGetProcAddress("glTransformFeedbackBufferBase");

+	if(!_ptrc_glTransformFeedbackBufferBase) numFailed++;

+	_ptrc_glTransformFeedbackBufferRange = (void (CODEGEN_FUNCPTR *)(GLuint, GLuint, GLuint, GLintptr, GLsizeiptr))IntGetProcAddress("glTransformFeedbackBufferRange");

+	if(!_ptrc_glTransformFeedbackBufferRange) numFailed++;

+	_ptrc_glUnmapNamedBuffer = (GLboolean (CODEGEN_FUNCPTR *)(GLuint))IntGetProcAddress("glUnmapNamedBuffer");

+	if(!_ptrc_glUnmapNamedBuffer) numFailed++;

+	_ptrc_glVertexArrayAttribBinding = (void (CODEGEN_FUNCPTR *)(GLuint, GLuint, GLuint))IntGetProcAddress("glVertexArrayAttribBinding");

+	if(!_ptrc_glVertexArrayAttribBinding) numFailed++;

+	_ptrc_glVertexArrayAttribFormat = (void (CODEGEN_FUNCPTR *)(GLuint, GLuint, GLint, GLenum, GLboolean, GLuint))IntGetProcAddress("glVertexArrayAttribFormat");

+	if(!_ptrc_glVertexArrayAttribFormat) numFailed++;

+	_ptrc_glVertexArrayAttribIFormat = (void (CODEGEN_FUNCPTR *)(GLuint, GLuint, GLint, GLenum, GLuint))IntGetProcAddress("glVertexArrayAttribIFormat");

+	if(!_ptrc_glVertexArrayAttribIFormat) numFailed++;

+	_ptrc_glVertexArrayAttribLFormat = (void (CODEGEN_FUNCPTR *)(GLuint, GLuint, GLint, GLenum, GLuint))IntGetProcAddress("glVertexArrayAttribLFormat");

+	if(!_ptrc_glVertexArrayAttribLFormat) numFailed++;

+	_ptrc_glVertexArrayBindingDivisor = (void (CODEGEN_FUNCPTR *)(GLuint, GLuint, GLuint))IntGetProcAddress("glVertexArrayBindingDivisor");

+	if(!_ptrc_glVertexArrayBindingDivisor) numFailed++;

+	_ptrc_glVertexArrayElementBuffer = (void (CODEGEN_FUNCPTR *)(GLuint, GLuint))IntGetProcAddress("glVertexArrayElementBuffer");

+	if(!_ptrc_glVertexArrayElementBuffer) numFailed++;

+	_ptrc_glVertexArrayVertexBuffer = (void (CODEGEN_FUNCPTR *)(GLuint, GLuint, GLuint, GLintptr, GLsizei))IntGetProcAddress("glVertexArrayVertexBuffer");

+	if(!_ptrc_glVertexArrayVertexBuffer) numFailed++;

+	_ptrc_glVertexArrayVertexBuffers = (void (CODEGEN_FUNCPTR *)(GLuint, GLuint, GLsizei, const GLuint *, const GLintptr *, const GLsizei *))IntGetProcAddress("glVertexArrayVertexBuffers");

+	if(!_ptrc_glVertexArrayVertexBuffers) numFailed++;

+	return numFailed;

+}

+

+void (CODEGEN_FUNCPTR *_ptrc_glGetCompressedTextureSubImage)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei bufSize, void * pixels) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_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) = NULL;

+

+static int Load_ARB_get_texture_sub_image(void)

+{

+	int numFailed = 0;

+	_ptrc_glGetCompressedTextureSubImage = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLsizei, void *))IntGetProcAddress("glGetCompressedTextureSubImage");

+	if(!_ptrc_glGetCompressedTextureSubImage) numFailed++;

+	_ptrc_glGetTextureSubImage = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, GLsizei, void *))IntGetProcAddress("glGetTextureSubImage");

+	if(!_ptrc_glGetTextureSubImage) numFailed++;

+	return numFailed;

+}

+

+void (CODEGEN_FUNCPTR *_ptrc_glTextureBarrier)(void) = NULL;

+

+static int Load_ARB_texture_barrier(void)

+{

+	int numFailed = 0;

+	_ptrc_glTextureBarrier = (void (CODEGEN_FUNCPTR *)(void))IntGetProcAddress("glTextureBarrier");

+	if(!_ptrc_glTextureBarrier) numFailed++;

+	return numFailed;

+}

+

+GLenum (CODEGEN_FUNCPTR *_ptrc_glGetGraphicsResetStatus)(void) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetnUniformfv)(GLuint program, GLint location, GLsizei bufSize, GLfloat * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetnUniformiv)(GLuint program, GLint location, GLsizei bufSize, GLint * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetnUniformuiv)(GLuint program, GLint location, GLsizei bufSize, GLuint * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glReadnPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void * data) = NULL;

+

+static int Load_KHR_robustness(void)

+{

+	int numFailed = 0;

+	_ptrc_glGetGraphicsResetStatus = (GLenum (CODEGEN_FUNCPTR *)(void))IntGetProcAddress("glGetGraphicsResetStatus");

+	if(!_ptrc_glGetGraphicsResetStatus) numFailed++;

+	_ptrc_glGetnUniformfv = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLsizei, GLfloat *))IntGetProcAddress("glGetnUniformfv");

+	if(!_ptrc_glGetnUniformfv) numFailed++;

+	_ptrc_glGetnUniformiv = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLsizei, GLint *))IntGetProcAddress("glGetnUniformiv");

+	if(!_ptrc_glGetnUniformiv) numFailed++;

+	_ptrc_glGetnUniformuiv = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLsizei, GLuint *))IntGetProcAddress("glGetnUniformuiv");

+	if(!_ptrc_glGetnUniformuiv) numFailed++;

+	_ptrc_glReadnPixels = (void (CODEGEN_FUNCPTR *)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLsizei, void *))IntGetProcAddress("glReadnPixels");

+	if(!_ptrc_glReadnPixels) numFailed++;

+	return numFailed;

+}

+

+void (CODEGEN_FUNCPTR *_ptrc_glAccum)(GLenum op, GLfloat value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glAlphaFunc)(GLenum func, GLfloat ref) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glBegin)(GLenum mode) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glBitmap)(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte * bitmap) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glBlendFunc)(GLenum sfactor, GLenum dfactor) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glCallList)(GLuint list) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glCallLists)(GLsizei n, GLenum type, const void * lists) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glClear)(GLbitfield mask) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glClearAccum)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glClearColor)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glClearDepth)(GLdouble depth) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glClearIndex)(GLfloat c) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glClearStencil)(GLint s) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glClipPlane)(GLenum plane, const GLdouble * equation) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glColor3b)(GLbyte red, GLbyte green, GLbyte blue) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glColor3bv)(const GLbyte * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glColor3d)(GLdouble red, GLdouble green, GLdouble blue) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glColor3dv)(const GLdouble * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glColor3f)(GLfloat red, GLfloat green, GLfloat blue) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glColor3fv)(const GLfloat * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glColor3i)(GLint red, GLint green, GLint blue) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glColor3iv)(const GLint * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glColor3s)(GLshort red, GLshort green, GLshort blue) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glColor3sv)(const GLshort * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glColor3ub)(GLubyte red, GLubyte green, GLubyte blue) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glColor3ubv)(const GLubyte * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glColor3ui)(GLuint red, GLuint green, GLuint blue) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glColor3uiv)(const GLuint * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glColor3us)(GLushort red, GLushort green, GLushort blue) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glColor3usv)(const GLushort * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glColor4b)(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glColor4bv)(const GLbyte * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glColor4d)(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glColor4dv)(const GLdouble * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glColor4f)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glColor4fv)(const GLfloat * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glColor4i)(GLint red, GLint green, GLint blue, GLint alpha) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glColor4iv)(const GLint * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glColor4s)(GLshort red, GLshort green, GLshort blue, GLshort alpha) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glColor4sv)(const GLshort * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glColor4ub)(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glColor4ubv)(const GLubyte * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glColor4ui)(GLuint red, GLuint green, GLuint blue, GLuint alpha) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glColor4uiv)(const GLuint * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glColor4us)(GLushort red, GLushort green, GLushort blue, GLushort alpha) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glColor4usv)(const GLushort * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glColorMask)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glColorMaterial)(GLenum face, GLenum mode) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glCopyPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glCullFace)(GLenum mode) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glDeleteLists)(GLuint list, GLsizei range) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glDepthFunc)(GLenum func) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glDepthMask)(GLboolean flag) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glDepthRange)(GLdouble ren_near, GLdouble ren_far) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glDisable)(GLenum cap) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glDrawBuffer)(GLenum buf) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glDrawPixels)(GLsizei width, GLsizei height, GLenum format, GLenum type, const void * pixels) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glEdgeFlag)(GLboolean flag) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glEdgeFlagv)(const GLboolean * flag) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glEnable)(GLenum cap) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glEnd)(void) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glEndList)(void) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glEvalCoord1d)(GLdouble u) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glEvalCoord1dv)(const GLdouble * u) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glEvalCoord1f)(GLfloat u) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glEvalCoord1fv)(const GLfloat * u) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glEvalCoord2d)(GLdouble u, GLdouble v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glEvalCoord2dv)(const GLdouble * u) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glEvalCoord2f)(GLfloat u, GLfloat v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glEvalCoord2fv)(const GLfloat * u) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glEvalMesh1)(GLenum mode, GLint i1, GLint i2) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glEvalMesh2)(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glEvalPoint1)(GLint i) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glEvalPoint2)(GLint i, GLint j) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glFeedbackBuffer)(GLsizei size, GLenum type, GLfloat * buffer) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glFinish)(void) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glFlush)(void) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glFogf)(GLenum pname, GLfloat param) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glFogfv)(GLenum pname, const GLfloat * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glFogi)(GLenum pname, GLint param) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glFogiv)(GLenum pname, const GLint * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glFrontFace)(GLenum mode) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glFrustum)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) = NULL;

+GLuint (CODEGEN_FUNCPTR *_ptrc_glGenLists)(GLsizei range) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetBooleanv)(GLenum pname, GLboolean * data) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetClipPlane)(GLenum plane, GLdouble * equation) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetDoublev)(GLenum pname, GLdouble * data) = NULL;

+GLenum (CODEGEN_FUNCPTR *_ptrc_glGetError)(void) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetFloatv)(GLenum pname, GLfloat * data) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetIntegerv)(GLenum pname, GLint * data) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetLightfv)(GLenum light, GLenum pname, GLfloat * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetLightiv)(GLenum light, GLenum pname, GLint * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetMapdv)(GLenum target, GLenum query, GLdouble * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetMapfv)(GLenum target, GLenum query, GLfloat * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetMapiv)(GLenum target, GLenum query, GLint * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetMaterialfv)(GLenum face, GLenum pname, GLfloat * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetMaterialiv)(GLenum face, GLenum pname, GLint * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetPixelMapfv)(GLenum map, GLfloat * values) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetPixelMapuiv)(GLenum map, GLuint * values) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetPixelMapusv)(GLenum map, GLushort * values) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetPolygonStipple)(GLubyte * mask) = NULL;

+const GLubyte * (CODEGEN_FUNCPTR *_ptrc_glGetString)(GLenum name) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetTexEnvfv)(GLenum target, GLenum pname, GLfloat * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetTexEnviv)(GLenum target, GLenum pname, GLint * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetTexGendv)(GLenum coord, GLenum pname, GLdouble * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetTexGenfv)(GLenum coord, GLenum pname, GLfloat * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetTexGeniv)(GLenum coord, GLenum pname, GLint * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetTexImage)(GLenum target, GLint level, GLenum format, GLenum type, void * pixels) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetTexLevelParameterfv)(GLenum target, GLint level, GLenum pname, GLfloat * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetTexLevelParameteriv)(GLenum target, GLint level, GLenum pname, GLint * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetTexParameterfv)(GLenum target, GLenum pname, GLfloat * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetTexParameteriv)(GLenum target, GLenum pname, GLint * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glHint)(GLenum target, GLenum mode) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glIndexMask)(GLuint mask) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glIndexd)(GLdouble c) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glIndexdv)(const GLdouble * c) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glIndexf)(GLfloat c) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glIndexfv)(const GLfloat * c) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glIndexi)(GLint c) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glIndexiv)(const GLint * c) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glIndexs)(GLshort c) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glIndexsv)(const GLshort * c) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glInitNames)(void) = NULL;

+GLboolean (CODEGEN_FUNCPTR *_ptrc_glIsEnabled)(GLenum cap) = NULL;

+GLboolean (CODEGEN_FUNCPTR *_ptrc_glIsList)(GLuint list) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glLightModelf)(GLenum pname, GLfloat param) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glLightModelfv)(GLenum pname, const GLfloat * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glLightModeli)(GLenum pname, GLint param) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glLightModeliv)(GLenum pname, const GLint * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glLightf)(GLenum light, GLenum pname, GLfloat param) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glLightfv)(GLenum light, GLenum pname, const GLfloat * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glLighti)(GLenum light, GLenum pname, GLint param) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glLightiv)(GLenum light, GLenum pname, const GLint * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glLineStipple)(GLint factor, GLushort pattern) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glLineWidth)(GLfloat width) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glListBase)(GLuint base) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glLoadIdentity)(void) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glLoadMatrixd)(const GLdouble * m) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glLoadMatrixf)(const GLfloat * m) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glLoadName)(GLuint name) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glLogicOp)(GLenum opcode) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMap1d)(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble * points) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMap1f)(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat * points) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMap2d)(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble * points) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMap2f)(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat * points) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMapGrid1d)(GLint un, GLdouble u1, GLdouble u2) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMapGrid1f)(GLint un, GLfloat u1, GLfloat u2) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMapGrid2d)(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMapGrid2f)(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMaterialf)(GLenum face, GLenum pname, GLfloat param) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMaterialfv)(GLenum face, GLenum pname, const GLfloat * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMateriali)(GLenum face, GLenum pname, GLint param) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMaterialiv)(GLenum face, GLenum pname, const GLint * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMatrixMode)(GLenum mode) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMultMatrixd)(const GLdouble * m) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMultMatrixf)(const GLfloat * m) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glNewList)(GLuint list, GLenum mode) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glNormal3b)(GLbyte nx, GLbyte ny, GLbyte nz) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glNormal3bv)(const GLbyte * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glNormal3d)(GLdouble nx, GLdouble ny, GLdouble nz) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glNormal3dv)(const GLdouble * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glNormal3f)(GLfloat nx, GLfloat ny, GLfloat nz) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glNormal3fv)(const GLfloat * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glNormal3i)(GLint nx, GLint ny, GLint nz) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glNormal3iv)(const GLint * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glNormal3s)(GLshort nx, GLshort ny, GLshort nz) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glNormal3sv)(const GLshort * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glOrtho)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glPassThrough)(GLfloat token) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glPixelMapfv)(GLenum map, GLsizei mapsize, const GLfloat * values) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glPixelMapuiv)(GLenum map, GLsizei mapsize, const GLuint * values) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glPixelMapusv)(GLenum map, GLsizei mapsize, const GLushort * values) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glPixelStoref)(GLenum pname, GLfloat param) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glPixelStorei)(GLenum pname, GLint param) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glPixelTransferf)(GLenum pname, GLfloat param) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glPixelTransferi)(GLenum pname, GLint param) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glPixelZoom)(GLfloat xfactor, GLfloat yfactor) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glPointSize)(GLfloat size) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glPolygonMode)(GLenum face, GLenum mode) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glPolygonStipple)(const GLubyte * mask) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glPopAttrib)(void) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glPopMatrix)(void) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glPopName)(void) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glPushAttrib)(GLbitfield mask) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glPushMatrix)(void) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glPushName)(GLuint name) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glRasterPos2d)(GLdouble x, GLdouble y) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glRasterPos2dv)(const GLdouble * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glRasterPos2f)(GLfloat x, GLfloat y) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glRasterPos2fv)(const GLfloat * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glRasterPos2i)(GLint x, GLint y) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glRasterPos2iv)(const GLint * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glRasterPos2s)(GLshort x, GLshort y) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glRasterPos2sv)(const GLshort * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glRasterPos3d)(GLdouble x, GLdouble y, GLdouble z) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glRasterPos3dv)(const GLdouble * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glRasterPos3f)(GLfloat x, GLfloat y, GLfloat z) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glRasterPos3fv)(const GLfloat * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glRasterPos3i)(GLint x, GLint y, GLint z) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glRasterPos3iv)(const GLint * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glRasterPos3s)(GLshort x, GLshort y, GLshort z) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glRasterPos3sv)(const GLshort * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glRasterPos4d)(GLdouble x, GLdouble y, GLdouble z, GLdouble w) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glRasterPos4dv)(const GLdouble * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glRasterPos4f)(GLfloat x, GLfloat y, GLfloat z, GLfloat w) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glRasterPos4fv)(const GLfloat * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glRasterPos4i)(GLint x, GLint y, GLint z, GLint w) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glRasterPos4iv)(const GLint * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glRasterPos4s)(GLshort x, GLshort y, GLshort z, GLshort w) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glRasterPos4sv)(const GLshort * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glReadBuffer)(GLenum src) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glReadPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void * pixels) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glRectd)(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glRectdv)(const GLdouble * v1, const GLdouble * v2) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glRectf)(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glRectfv)(const GLfloat * v1, const GLfloat * v2) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glRecti)(GLint x1, GLint y1, GLint x2, GLint y2) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glRectiv)(const GLint * v1, const GLint * v2) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glRects)(GLshort x1, GLshort y1, GLshort x2, GLshort y2) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glRectsv)(const GLshort * v1, const GLshort * v2) = NULL;

+GLint (CODEGEN_FUNCPTR *_ptrc_glRenderMode)(GLenum mode) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glRotated)(GLdouble angle, GLdouble x, GLdouble y, GLdouble z) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glRotatef)(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glScaled)(GLdouble x, GLdouble y, GLdouble z) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glScalef)(GLfloat x, GLfloat y, GLfloat z) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glScissor)(GLint x, GLint y, GLsizei width, GLsizei height) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glSelectBuffer)(GLsizei size, GLuint * buffer) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glShadeModel)(GLenum mode) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glStencilFunc)(GLenum func, GLint ref, GLuint mask) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glStencilMask)(GLuint mask) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glStencilOp)(GLenum fail, GLenum zfail, GLenum zpass) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexCoord1d)(GLdouble s) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexCoord1dv)(const GLdouble * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexCoord1f)(GLfloat s) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexCoord1fv)(const GLfloat * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexCoord1i)(GLint s) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexCoord1iv)(const GLint * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexCoord1s)(GLshort s) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexCoord1sv)(const GLshort * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexCoord2d)(GLdouble s, GLdouble t) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexCoord2dv)(const GLdouble * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexCoord2f)(GLfloat s, GLfloat t) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexCoord2fv)(const GLfloat * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexCoord2i)(GLint s, GLint t) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexCoord2iv)(const GLint * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexCoord2s)(GLshort s, GLshort t) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexCoord2sv)(const GLshort * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexCoord3d)(GLdouble s, GLdouble t, GLdouble r) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexCoord3dv)(const GLdouble * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexCoord3f)(GLfloat s, GLfloat t, GLfloat r) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexCoord3fv)(const GLfloat * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexCoord3i)(GLint s, GLint t, GLint r) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexCoord3iv)(const GLint * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexCoord3s)(GLshort s, GLshort t, GLshort r) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexCoord3sv)(const GLshort * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexCoord4d)(GLdouble s, GLdouble t, GLdouble r, GLdouble q) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexCoord4dv)(const GLdouble * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexCoord4f)(GLfloat s, GLfloat t, GLfloat r, GLfloat q) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexCoord4fv)(const GLfloat * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexCoord4i)(GLint s, GLint t, GLint r, GLint q) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexCoord4iv)(const GLint * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexCoord4s)(GLshort s, GLshort t, GLshort r, GLshort q) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexCoord4sv)(const GLshort * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexEnvf)(GLenum target, GLenum pname, GLfloat param) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexEnvfv)(GLenum target, GLenum pname, const GLfloat * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexEnvi)(GLenum target, GLenum pname, GLint param) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexEnviv)(GLenum target, GLenum pname, const GLint * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexGend)(GLenum coord, GLenum pname, GLdouble param) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexGendv)(GLenum coord, GLenum pname, const GLdouble * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexGenf)(GLenum coord, GLenum pname, GLfloat param) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexGenfv)(GLenum coord, GLenum pname, const GLfloat * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexGeni)(GLenum coord, GLenum pname, GLint param) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexGeniv)(GLenum coord, GLenum pname, const GLint * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexImage1D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void * pixels) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexImage2D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void * pixels) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexParameterf)(GLenum target, GLenum pname, GLfloat param) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexParameterfv)(GLenum target, GLenum pname, const GLfloat * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexParameteri)(GLenum target, GLenum pname, GLint param) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexParameteriv)(GLenum target, GLenum pname, const GLint * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTranslated)(GLdouble x, GLdouble y, GLdouble z) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTranslatef)(GLfloat x, GLfloat y, GLfloat z) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertex2d)(GLdouble x, GLdouble y) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertex2dv)(const GLdouble * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertex2f)(GLfloat x, GLfloat y) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertex2fv)(const GLfloat * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertex2i)(GLint x, GLint y) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertex2iv)(const GLint * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertex2s)(GLshort x, GLshort y) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertex2sv)(const GLshort * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertex3d)(GLdouble x, GLdouble y, GLdouble z) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertex3dv)(const GLdouble * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertex3f)(GLfloat x, GLfloat y, GLfloat z) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertex3fv)(const GLfloat * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertex3i)(GLint x, GLint y, GLint z) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertex3iv)(const GLint * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertex3s)(GLshort x, GLshort y, GLshort z) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertex3sv)(const GLshort * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertex4d)(GLdouble x, GLdouble y, GLdouble z, GLdouble w) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertex4dv)(const GLdouble * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertex4f)(GLfloat x, GLfloat y, GLfloat z, GLfloat w) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertex4fv)(const GLfloat * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertex4i)(GLint x, GLint y, GLint z, GLint w) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertex4iv)(const GLint * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertex4s)(GLshort x, GLshort y, GLshort z, GLshort w) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertex4sv)(const GLshort * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glViewport)(GLint x, GLint y, GLsizei width, GLsizei height) = NULL;

+

+GLboolean (CODEGEN_FUNCPTR *_ptrc_glAreTexturesResident)(GLsizei n, const GLuint * textures, GLboolean * residences) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glArrayElement)(GLint i) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glBindTexture)(GLenum target, GLuint texture) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glColorPointer)(GLint size, GLenum type, GLsizei stride, const void * pointer) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glCopyTexImage1D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glCopyTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glCopyTexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glCopyTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glDeleteTextures)(GLsizei n, const GLuint * textures) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glDisableClientState)(GLenum ren_array) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glDrawArrays)(GLenum mode, GLint first, GLsizei count) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glDrawElements)(GLenum mode, GLsizei count, GLenum type, const void * indices) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glEdgeFlagPointer)(GLsizei stride, const void * pointer) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glEnableClientState)(GLenum ren_array) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGenTextures)(GLsizei n, GLuint * textures) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glIndexPointer)(GLenum type, GLsizei stride, const void * pointer) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glIndexub)(GLubyte c) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glIndexubv)(const GLubyte * c) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glInterleavedArrays)(GLenum format, GLsizei stride, const void * pointer) = NULL;

+GLboolean (CODEGEN_FUNCPTR *_ptrc_glIsTexture)(GLuint texture) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glNormalPointer)(GLenum type, GLsizei stride, const void * pointer) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glPolygonOffset)(GLfloat factor, GLfloat units) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glPopClientAttrib)(void) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glPrioritizeTextures)(GLsizei n, const GLuint * textures, const GLfloat * priorities) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glPushClientAttrib)(GLbitfield mask) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexCoordPointer)(GLint size, GLenum type, GLsizei stride, const void * pointer) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void * pixels) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * pixels) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexPointer)(GLint size, GLenum type, GLsizei stride, const void * pointer) = NULL;

+

+void (CODEGEN_FUNCPTR *_ptrc_glCopyTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glDrawRangeElements)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void * indices) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexImage3D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void * pixels) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * pixels) = NULL;

+

+void (CODEGEN_FUNCPTR *_ptrc_glActiveTexture)(GLenum texture) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glClientActiveTexture)(GLenum texture) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glCompressedTexImage1D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void * data) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glCompressedTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void * data) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glCompressedTexImage3D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void * data) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glCompressedTexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void * data) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glCompressedTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void * data) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glCompressedTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void * data) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetCompressedTexImage)(GLenum target, GLint level, void * img) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glLoadTransposeMatrixd)(const GLdouble * m) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glLoadTransposeMatrixf)(const GLfloat * m) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMultTransposeMatrixd)(const GLdouble * m) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMultTransposeMatrixf)(const GLfloat * m) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord1d)(GLenum target, GLdouble s) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord1dv)(GLenum target, const GLdouble * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord1f)(GLenum target, GLfloat s) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord1fv)(GLenum target, const GLfloat * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord1i)(GLenum target, GLint s) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord1iv)(GLenum target, const GLint * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord1s)(GLenum target, GLshort s) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord1sv)(GLenum target, const GLshort * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord2d)(GLenum target, GLdouble s, GLdouble t) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord2dv)(GLenum target, const GLdouble * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord2f)(GLenum target, GLfloat s, GLfloat t) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord2fv)(GLenum target, const GLfloat * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord2i)(GLenum target, GLint s, GLint t) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord2iv)(GLenum target, const GLint * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord2s)(GLenum target, GLshort s, GLshort t) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord2sv)(GLenum target, const GLshort * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord3d)(GLenum target, GLdouble s, GLdouble t, GLdouble r) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord3dv)(GLenum target, const GLdouble * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord3f)(GLenum target, GLfloat s, GLfloat t, GLfloat r) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord3fv)(GLenum target, const GLfloat * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord3i)(GLenum target, GLint s, GLint t, GLint r) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord3iv)(GLenum target, const GLint * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord3s)(GLenum target, GLshort s, GLshort t, GLshort r) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord3sv)(GLenum target, const GLshort * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord4d)(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord4dv)(GLenum target, const GLdouble * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord4f)(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord4fv)(GLenum target, const GLfloat * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord4i)(GLenum target, GLint s, GLint t, GLint r, GLint q) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord4iv)(GLenum target, const GLint * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord4s)(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord4sv)(GLenum target, const GLshort * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glSampleCoverage)(GLfloat value, GLboolean invert) = NULL;

+

+void (CODEGEN_FUNCPTR *_ptrc_glBlendColor)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glBlendEquation)(GLenum mode) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glBlendFuncSeparate)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glFogCoordPointer)(GLenum type, GLsizei stride, const void * pointer) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glFogCoordd)(GLdouble coord) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glFogCoorddv)(const GLdouble * coord) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glFogCoordf)(GLfloat coord) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glFogCoordfv)(const GLfloat * coord) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMultiDrawArrays)(GLenum mode, const GLint * first, const GLsizei * count, GLsizei drawcount) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glMultiDrawElements)(GLenum mode, const GLsizei * count, GLenum type, const void *const* indices, GLsizei drawcount) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glPointParameterf)(GLenum pname, GLfloat param) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glPointParameterfv)(GLenum pname, const GLfloat * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glPointParameteri)(GLenum pname, GLint param) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glPointParameteriv)(GLenum pname, const GLint * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glSecondaryColor3b)(GLbyte red, GLbyte green, GLbyte blue) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glSecondaryColor3bv)(const GLbyte * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glSecondaryColor3d)(GLdouble red, GLdouble green, GLdouble blue) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glSecondaryColor3dv)(const GLdouble * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glSecondaryColor3f)(GLfloat red, GLfloat green, GLfloat blue) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glSecondaryColor3fv)(const GLfloat * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glSecondaryColor3i)(GLint red, GLint green, GLint blue) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glSecondaryColor3iv)(const GLint * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glSecondaryColor3s)(GLshort red, GLshort green, GLshort blue) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glSecondaryColor3sv)(const GLshort * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glSecondaryColor3ub)(GLubyte red, GLubyte green, GLubyte blue) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glSecondaryColor3ubv)(const GLubyte * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glSecondaryColor3ui)(GLuint red, GLuint green, GLuint blue) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glSecondaryColor3uiv)(const GLuint * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glSecondaryColor3us)(GLushort red, GLushort green, GLushort blue) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glSecondaryColor3usv)(const GLushort * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glSecondaryColorPointer)(GLint size, GLenum type, GLsizei stride, const void * pointer) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glWindowPos2d)(GLdouble x, GLdouble y) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glWindowPos2dv)(const GLdouble * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glWindowPos2f)(GLfloat x, GLfloat y) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glWindowPos2fv)(const GLfloat * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glWindowPos2i)(GLint x, GLint y) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glWindowPos2iv)(const GLint * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glWindowPos2s)(GLshort x, GLshort y) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glWindowPos2sv)(const GLshort * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glWindowPos3d)(GLdouble x, GLdouble y, GLdouble z) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glWindowPos3dv)(const GLdouble * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glWindowPos3f)(GLfloat x, GLfloat y, GLfloat z) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glWindowPos3fv)(const GLfloat * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glWindowPos3i)(GLint x, GLint y, GLint z) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glWindowPos3iv)(const GLint * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glWindowPos3s)(GLshort x, GLshort y, GLshort z) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glWindowPos3sv)(const GLshort * v) = NULL;

+

+void (CODEGEN_FUNCPTR *_ptrc_glBeginQuery)(GLenum target, GLuint id) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glBindBuffer)(GLenum target, GLuint buffer) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glBufferData)(GLenum target, GLsizeiptr size, const void * data, GLenum usage) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glBufferSubData)(GLenum target, GLintptr offset, GLsizeiptr size, const void * data) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glDeleteBuffers)(GLsizei n, const GLuint * buffers) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glDeleteQueries)(GLsizei n, const GLuint * ids) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glEndQuery)(GLenum target) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGenBuffers)(GLsizei n, GLuint * buffers) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGenQueries)(GLsizei n, GLuint * ids) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetBufferParameteriv)(GLenum target, GLenum pname, GLint * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetBufferPointerv)(GLenum target, GLenum pname, void ** params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetBufferSubData)(GLenum target, GLintptr offset, GLsizeiptr size, void * data) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetQueryObjectiv)(GLuint id, GLenum pname, GLint * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetQueryObjectuiv)(GLuint id, GLenum pname, GLuint * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetQueryiv)(GLenum target, GLenum pname, GLint * params) = NULL;

+GLboolean (CODEGEN_FUNCPTR *_ptrc_glIsBuffer)(GLuint buffer) = NULL;

+GLboolean (CODEGEN_FUNCPTR *_ptrc_glIsQuery)(GLuint id) = NULL;

+void * (CODEGEN_FUNCPTR *_ptrc_glMapBuffer)(GLenum target, GLenum access) = NULL;

+GLboolean (CODEGEN_FUNCPTR *_ptrc_glUnmapBuffer)(GLenum target) = NULL;

+

+void (CODEGEN_FUNCPTR *_ptrc_glAttachShader)(GLuint program, GLuint shader) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glBindAttribLocation)(GLuint program, GLuint index, const GLchar * name) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glBlendEquationSeparate)(GLenum modeRGB, GLenum modeAlpha) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glCompileShader)(GLuint shader) = NULL;

+GLuint (CODEGEN_FUNCPTR *_ptrc_glCreateProgram)(void) = NULL;

+GLuint (CODEGEN_FUNCPTR *_ptrc_glCreateShader)(GLenum type) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glDeleteProgram)(GLuint program) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glDeleteShader)(GLuint shader) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glDetachShader)(GLuint program, GLuint shader) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glDisableVertexAttribArray)(GLuint index) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glDrawBuffers)(GLsizei n, const GLenum * bufs) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glEnableVertexAttribArray)(GLuint index) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetActiveAttrib)(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetActiveUniform)(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetAttachedShaders)(GLuint program, GLsizei maxCount, GLsizei * count, GLuint * shaders) = NULL;

+GLint (CODEGEN_FUNCPTR *_ptrc_glGetAttribLocation)(GLuint program, const GLchar * name) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetProgramInfoLog)(GLuint program, GLsizei bufSize, GLsizei * length, GLchar * infoLog) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetProgramiv)(GLuint program, GLenum pname, GLint * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetShaderInfoLog)(GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * infoLog) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetShaderSource)(GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * source) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetShaderiv)(GLuint shader, GLenum pname, GLint * params) = NULL;

+GLint (CODEGEN_FUNCPTR *_ptrc_glGetUniformLocation)(GLuint program, const GLchar * name) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetUniformfv)(GLuint program, GLint location, GLfloat * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetUniformiv)(GLuint program, GLint location, GLint * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetVertexAttribPointerv)(GLuint index, GLenum pname, void ** pointer) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetVertexAttribdv)(GLuint index, GLenum pname, GLdouble * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetVertexAttribfv)(GLuint index, GLenum pname, GLfloat * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetVertexAttribiv)(GLuint index, GLenum pname, GLint * params) = NULL;

+GLboolean (CODEGEN_FUNCPTR *_ptrc_glIsProgram)(GLuint program) = NULL;

+GLboolean (CODEGEN_FUNCPTR *_ptrc_glIsShader)(GLuint shader) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glLinkProgram)(GLuint program) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glShaderSource)(GLuint shader, GLsizei count, const GLchar *const* string, const GLint * length) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glStencilFuncSeparate)(GLenum face, GLenum func, GLint ref, GLuint mask) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glStencilMaskSeparate)(GLenum face, GLuint mask) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glStencilOpSeparate)(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glUniform1f)(GLint location, GLfloat v0) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glUniform1fv)(GLint location, GLsizei count, const GLfloat * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glUniform1i)(GLint location, GLint v0) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glUniform1iv)(GLint location, GLsizei count, const GLint * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glUniform2f)(GLint location, GLfloat v0, GLfloat v1) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glUniform2fv)(GLint location, GLsizei count, const GLfloat * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glUniform2i)(GLint location, GLint v0, GLint v1) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glUniform2iv)(GLint location, GLsizei count, const GLint * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glUniform3f)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glUniform3fv)(GLint location, GLsizei count, const GLfloat * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glUniform3i)(GLint location, GLint v0, GLint v1, GLint v2) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glUniform3iv)(GLint location, GLsizei count, const GLint * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glUniform4f)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glUniform4fv)(GLint location, GLsizei count, const GLfloat * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glUniform4i)(GLint location, GLint v0, GLint v1, GLint v2, GLint v3) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glUniform4iv)(GLint location, GLsizei count, const GLint * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glUniformMatrix2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glUniformMatrix3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glUniformMatrix4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glUseProgram)(GLuint program) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glValidateProgram)(GLuint program) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib1d)(GLuint index, GLdouble x) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib1dv)(GLuint index, const GLdouble * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib1f)(GLuint index, GLfloat x) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib1fv)(GLuint index, const GLfloat * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib1s)(GLuint index, GLshort x) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib1sv)(GLuint index, const GLshort * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib2d)(GLuint index, GLdouble x, GLdouble y) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib2dv)(GLuint index, const GLdouble * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib2f)(GLuint index, GLfloat x, GLfloat y) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib2fv)(GLuint index, const GLfloat * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib2s)(GLuint index, GLshort x, GLshort y) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib2sv)(GLuint index, const GLshort * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib3d)(GLuint index, GLdouble x, GLdouble y, GLdouble z) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib3dv)(GLuint index, const GLdouble * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib3f)(GLuint index, GLfloat x, GLfloat y, GLfloat z) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib3fv)(GLuint index, const GLfloat * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib3s)(GLuint index, GLshort x, GLshort y, GLshort z) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib3sv)(GLuint index, const GLshort * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib4Nbv)(GLuint index, const GLbyte * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib4Niv)(GLuint index, const GLint * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib4Nsv)(GLuint index, const GLshort * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib4Nub)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib4Nubv)(GLuint index, const GLubyte * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib4Nuiv)(GLuint index, const GLuint * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib4Nusv)(GLuint index, const GLushort * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib4bv)(GLuint index, const GLbyte * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib4d)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib4dv)(GLuint index, const GLdouble * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib4f)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib4fv)(GLuint index, const GLfloat * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib4iv)(GLuint index, const GLint * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib4s)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib4sv)(GLuint index, const GLshort * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib4ubv)(GLuint index, const GLubyte * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib4uiv)(GLuint index, const GLuint * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib4usv)(GLuint index, const GLushort * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribPointer)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void * pointer) = NULL;

+

+void (CODEGEN_FUNCPTR *_ptrc_glUniformMatrix2x3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glUniformMatrix2x4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glUniformMatrix3x2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glUniformMatrix3x4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glUniformMatrix4x2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glUniformMatrix4x3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value) = NULL;

+

+void (CODEGEN_FUNCPTR *_ptrc_glBeginConditionalRender)(GLuint id, GLenum mode) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glBeginTransformFeedback)(GLenum primitiveMode) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glBindBufferBase)(GLenum target, GLuint index, GLuint buffer) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glBindBufferRange)(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glBindFragDataLocation)(GLuint program, GLuint color, const GLchar * name) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glBindFramebuffer)(GLenum target, GLuint framebuffer) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glBindRenderbuffer)(GLenum target, GLuint renderbuffer) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glBindVertexArray)(GLuint ren_array) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glBlitFramebuffer)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) = NULL;

+GLenum (CODEGEN_FUNCPTR *_ptrc_glCheckFramebufferStatus)(GLenum target) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glClampColor)(GLenum target, GLenum clamp) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glClearBufferfi)(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glClearBufferfv)(GLenum buffer, GLint drawbuffer, const GLfloat * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glClearBufferiv)(GLenum buffer, GLint drawbuffer, const GLint * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glClearBufferuiv)(GLenum buffer, GLint drawbuffer, const GLuint * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glColorMaski)(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glDeleteFramebuffers)(GLsizei n, const GLuint * framebuffers) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glDeleteRenderbuffers)(GLsizei n, const GLuint * renderbuffers) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glDeleteVertexArrays)(GLsizei n, const GLuint * arrays) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glDisablei)(GLenum target, GLuint index) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glEnablei)(GLenum target, GLuint index) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glEndConditionalRender)(void) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glEndTransformFeedback)(void) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glFlushMappedBufferRange)(GLenum target, GLintptr offset, GLsizeiptr length) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glFramebufferRenderbuffer)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glFramebufferTexture1D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glFramebufferTexture2D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glFramebufferTexture3D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glFramebufferTextureLayer)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGenFramebuffers)(GLsizei n, GLuint * framebuffers) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGenRenderbuffers)(GLsizei n, GLuint * renderbuffers) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGenVertexArrays)(GLsizei n, GLuint * arrays) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGenerateMipmap)(GLenum target) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetBooleani_v)(GLenum target, GLuint index, GLboolean * data) = NULL;

+GLint (CODEGEN_FUNCPTR *_ptrc_glGetFragDataLocation)(GLuint program, const GLchar * name) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetFramebufferAttachmentParameteriv)(GLenum target, GLenum attachment, GLenum pname, GLint * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetIntegeri_v)(GLenum target, GLuint index, GLint * data) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetRenderbufferParameteriv)(GLenum target, GLenum pname, GLint * params) = NULL;

+const GLubyte * (CODEGEN_FUNCPTR *_ptrc_glGetStringi)(GLenum name, GLuint index) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetTexParameterIiv)(GLenum target, GLenum pname, GLint * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetTexParameterIuiv)(GLenum target, GLenum pname, GLuint * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetTransformFeedbackVarying)(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLsizei * size, GLenum * type, GLchar * name) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetUniformuiv)(GLuint program, GLint location, GLuint * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetVertexAttribIiv)(GLuint index, GLenum pname, GLint * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetVertexAttribIuiv)(GLuint index, GLenum pname, GLuint * params) = NULL;

+GLboolean (CODEGEN_FUNCPTR *_ptrc_glIsEnabledi)(GLenum target, GLuint index) = NULL;

+GLboolean (CODEGEN_FUNCPTR *_ptrc_glIsFramebuffer)(GLuint framebuffer) = NULL;

+GLboolean (CODEGEN_FUNCPTR *_ptrc_glIsRenderbuffer)(GLuint renderbuffer) = NULL;

+GLboolean (CODEGEN_FUNCPTR *_ptrc_glIsVertexArray)(GLuint ren_array) = NULL;

+void * (CODEGEN_FUNCPTR *_ptrc_glMapBufferRange)(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glRenderbufferStorage)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glRenderbufferStorageMultisample)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexParameterIiv)(GLenum target, GLenum pname, const GLint * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexParameterIuiv)(GLenum target, GLenum pname, const GLuint * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTransformFeedbackVaryings)(GLuint program, GLsizei count, const GLchar *const* varyings, GLenum bufferMode) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glUniform1ui)(GLint location, GLuint v0) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glUniform1uiv)(GLint location, GLsizei count, const GLuint * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glUniform2ui)(GLint location, GLuint v0, GLuint v1) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glUniform2uiv)(GLint location, GLsizei count, const GLuint * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glUniform3ui)(GLint location, GLuint v0, GLuint v1, GLuint v2) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glUniform3uiv)(GLint location, GLsizei count, const GLuint * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glUniform4ui)(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glUniform4uiv)(GLint location, GLsizei count, const GLuint * value) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribI1i)(GLuint index, GLint x) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribI1iv)(GLuint index, const GLint * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribI1ui)(GLuint index, GLuint x) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribI1uiv)(GLuint index, const GLuint * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribI2i)(GLuint index, GLint x, GLint y) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribI2iv)(GLuint index, const GLint * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribI2ui)(GLuint index, GLuint x, GLuint y) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribI2uiv)(GLuint index, const GLuint * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribI3i)(GLuint index, GLint x, GLint y, GLint z) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribI3iv)(GLuint index, const GLint * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribI3ui)(GLuint index, GLuint x, GLuint y, GLuint z) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribI3uiv)(GLuint index, const GLuint * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribI4bv)(GLuint index, const GLbyte * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribI4i)(GLuint index, GLint x, GLint y, GLint z, GLint w) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribI4iv)(GLuint index, const GLint * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribI4sv)(GLuint index, const GLshort * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribI4ubv)(GLuint index, const GLubyte * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribI4ui)(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribI4uiv)(GLuint index, const GLuint * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribI4usv)(GLuint index, const GLushort * v) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribIPointer)(GLuint index, GLint size, GLenum type, GLsizei stride, const void * pointer) = NULL;

+

+void (CODEGEN_FUNCPTR *_ptrc_glCopyBufferSubData)(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glDrawArraysInstanced)(GLenum mode, GLint first, GLsizei count, GLsizei instancecount) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glDrawElementsInstanced)(GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei instancecount) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetActiveUniformBlockName)(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei * length, GLchar * uniformBlockName) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetActiveUniformBlockiv)(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint * params) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetActiveUniformName)(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei * length, GLchar * uniformName) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetActiveUniformsiv)(GLuint program, GLsizei uniformCount, const GLuint * uniformIndices, GLenum pname, GLint * params) = NULL;

+GLuint (CODEGEN_FUNCPTR *_ptrc_glGetUniformBlockIndex)(GLuint program, const GLchar * uniformBlockName) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glGetUniformIndices)(GLuint program, GLsizei uniformCount, const GLchar *const* uniformNames, GLuint * uniformIndices) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glPrimitiveRestartIndex)(GLuint index) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glTexBuffer)(GLenum target, GLenum internalformat, GLuint buffer) = NULL;

+void (CODEGEN_FUNCPTR *_ptrc_glUniformBlockBinding)(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding) = NULL;

+

+static int Load_Version_3_1(void)

+{

+	int numFailed = 0;

+	_ptrc_glAccum = (void (CODEGEN_FUNCPTR *)(GLenum, GLfloat))IntGetProcAddress("glAccum");

+	if(!_ptrc_glAccum) numFailed++;

+	_ptrc_glAlphaFunc = (void (CODEGEN_FUNCPTR *)(GLenum, GLfloat))IntGetProcAddress("glAlphaFunc");

+	if(!_ptrc_glAlphaFunc) numFailed++;

+	_ptrc_glBegin = (void (CODEGEN_FUNCPTR *)(GLenum))IntGetProcAddress("glBegin");

+	if(!_ptrc_glBegin) numFailed++;

+	_ptrc_glBitmap = (void (CODEGEN_FUNCPTR *)(GLsizei, GLsizei, GLfloat, GLfloat, GLfloat, GLfloat, const GLubyte *))IntGetProcAddress("glBitmap");

+	if(!_ptrc_glBitmap) numFailed++;

+	_ptrc_glBlendFunc = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum))IntGetProcAddress("glBlendFunc");

+	if(!_ptrc_glBlendFunc) numFailed++;

+	_ptrc_glCallList = (void (CODEGEN_FUNCPTR *)(GLuint))IntGetProcAddress("glCallList");

+	if(!_ptrc_glCallList) numFailed++;

+	_ptrc_glCallLists = (void (CODEGEN_FUNCPTR *)(GLsizei, GLenum, const void *))IntGetProcAddress("glCallLists");

+	if(!_ptrc_glCallLists) numFailed++;

+	_ptrc_glClear = (void (CODEGEN_FUNCPTR *)(GLbitfield))IntGetProcAddress("glClear");

+	if(!_ptrc_glClear) numFailed++;

+	_ptrc_glClearAccum = (void (CODEGEN_FUNCPTR *)(GLfloat, GLfloat, GLfloat, GLfloat))IntGetProcAddress("glClearAccum");

+	if(!_ptrc_glClearAccum) numFailed++;

+	_ptrc_glClearColor = (void (CODEGEN_FUNCPTR *)(GLfloat, GLfloat, GLfloat, GLfloat))IntGetProcAddress("glClearColor");

+	if(!_ptrc_glClearColor) numFailed++;

+	_ptrc_glClearDepth = (void (CODEGEN_FUNCPTR *)(GLdouble))IntGetProcAddress("glClearDepth");

+	if(!_ptrc_glClearDepth) numFailed++;

+	_ptrc_glClearIndex = (void (CODEGEN_FUNCPTR *)(GLfloat))IntGetProcAddress("glClearIndex");

+	if(!_ptrc_glClearIndex) numFailed++;

+	_ptrc_glClearStencil = (void (CODEGEN_FUNCPTR *)(GLint))IntGetProcAddress("glClearStencil");

+	if(!_ptrc_glClearStencil) numFailed++;

+	_ptrc_glClipPlane = (void (CODEGEN_FUNCPTR *)(GLenum, const GLdouble *))IntGetProcAddress("glClipPlane");

+	if(!_ptrc_glClipPlane) numFailed++;

+	_ptrc_glColor3b = (void (CODEGEN_FUNCPTR *)(GLbyte, GLbyte, GLbyte))IntGetProcAddress("glColor3b");

+	if(!_ptrc_glColor3b) numFailed++;

+	_ptrc_glColor3bv = (void (CODEGEN_FUNCPTR *)(const GLbyte *))IntGetProcAddress("glColor3bv");

+	if(!_ptrc_glColor3bv) numFailed++;

+	_ptrc_glColor3d = (void (CODEGEN_FUNCPTR *)(GLdouble, GLdouble, GLdouble))IntGetProcAddress("glColor3d");

+	if(!_ptrc_glColor3d) numFailed++;

+	_ptrc_glColor3dv = (void (CODEGEN_FUNCPTR *)(const GLdouble *))IntGetProcAddress("glColor3dv");

+	if(!_ptrc_glColor3dv) numFailed++;

+	_ptrc_glColor3f = (void (CODEGEN_FUNCPTR *)(GLfloat, GLfloat, GLfloat))IntGetProcAddress("glColor3f");

+	if(!_ptrc_glColor3f) numFailed++;

+	_ptrc_glColor3fv = (void (CODEGEN_FUNCPTR *)(const GLfloat *))IntGetProcAddress("glColor3fv");

+	if(!_ptrc_glColor3fv) numFailed++;

+	_ptrc_glColor3i = (void (CODEGEN_FUNCPTR *)(GLint, GLint, GLint))IntGetProcAddress("glColor3i");

+	if(!_ptrc_glColor3i) numFailed++;

+	_ptrc_glColor3iv = (void (CODEGEN_FUNCPTR *)(const GLint *))IntGetProcAddress("glColor3iv");

+	if(!_ptrc_glColor3iv) numFailed++;

+	_ptrc_glColor3s = (void (CODEGEN_FUNCPTR *)(GLshort, GLshort, GLshort))IntGetProcAddress("glColor3s");

+	if(!_ptrc_glColor3s) numFailed++;

+	_ptrc_glColor3sv = (void (CODEGEN_FUNCPTR *)(const GLshort *))IntGetProcAddress("glColor3sv");

+	if(!_ptrc_glColor3sv) numFailed++;

+	_ptrc_glColor3ub = (void (CODEGEN_FUNCPTR *)(GLubyte, GLubyte, GLubyte))IntGetProcAddress("glColor3ub");

+	if(!_ptrc_glColor3ub) numFailed++;

+	_ptrc_glColor3ubv = (void (CODEGEN_FUNCPTR *)(const GLubyte *))IntGetProcAddress("glColor3ubv");

+	if(!_ptrc_glColor3ubv) numFailed++;

+	_ptrc_glColor3ui = (void (CODEGEN_FUNCPTR *)(GLuint, GLuint, GLuint))IntGetProcAddress("glColor3ui");

+	if(!_ptrc_glColor3ui) numFailed++;

+	_ptrc_glColor3uiv = (void (CODEGEN_FUNCPTR *)(const GLuint *))IntGetProcAddress("glColor3uiv");

+	if(!_ptrc_glColor3uiv) numFailed++;

+	_ptrc_glColor3us = (void (CODEGEN_FUNCPTR *)(GLushort, GLushort, GLushort))IntGetProcAddress("glColor3us");

+	if(!_ptrc_glColor3us) numFailed++;

+	_ptrc_glColor3usv = (void (CODEGEN_FUNCPTR *)(const GLushort *))IntGetProcAddress("glColor3usv");

+	if(!_ptrc_glColor3usv) numFailed++;

+	_ptrc_glColor4b = (void (CODEGEN_FUNCPTR *)(GLbyte, GLbyte, GLbyte, GLbyte))IntGetProcAddress("glColor4b");

+	if(!_ptrc_glColor4b) numFailed++;

+	_ptrc_glColor4bv = (void (CODEGEN_FUNCPTR *)(const GLbyte *))IntGetProcAddress("glColor4bv");

+	if(!_ptrc_glColor4bv) numFailed++;

+	_ptrc_glColor4d = (void (CODEGEN_FUNCPTR *)(GLdouble, GLdouble, GLdouble, GLdouble))IntGetProcAddress("glColor4d");

+	if(!_ptrc_glColor4d) numFailed++;

+	_ptrc_glColor4dv = (void (CODEGEN_FUNCPTR *)(const GLdouble *))IntGetProcAddress("glColor4dv");

+	if(!_ptrc_glColor4dv) numFailed++;

+	_ptrc_glColor4f = (void (CODEGEN_FUNCPTR *)(GLfloat, GLfloat, GLfloat, GLfloat))IntGetProcAddress("glColor4f");

+	if(!_ptrc_glColor4f) numFailed++;

+	_ptrc_glColor4fv = (void (CODEGEN_FUNCPTR *)(const GLfloat *))IntGetProcAddress("glColor4fv");

+	if(!_ptrc_glColor4fv) numFailed++;

+	_ptrc_glColor4i = (void (CODEGEN_FUNCPTR *)(GLint, GLint, GLint, GLint))IntGetProcAddress("glColor4i");

+	if(!_ptrc_glColor4i) numFailed++;

+	_ptrc_glColor4iv = (void (CODEGEN_FUNCPTR *)(const GLint *))IntGetProcAddress("glColor4iv");

+	if(!_ptrc_glColor4iv) numFailed++;

+	_ptrc_glColor4s = (void (CODEGEN_FUNCPTR *)(GLshort, GLshort, GLshort, GLshort))IntGetProcAddress("glColor4s");

+	if(!_ptrc_glColor4s) numFailed++;

+	_ptrc_glColor4sv = (void (CODEGEN_FUNCPTR *)(const GLshort *))IntGetProcAddress("glColor4sv");

+	if(!_ptrc_glColor4sv) numFailed++;

+	_ptrc_glColor4ub = (void (CODEGEN_FUNCPTR *)(GLubyte, GLubyte, GLubyte, GLubyte))IntGetProcAddress("glColor4ub");

+	if(!_ptrc_glColor4ub) numFailed++;

+	_ptrc_glColor4ubv = (void (CODEGEN_FUNCPTR *)(const GLubyte *))IntGetProcAddress("glColor4ubv");

+	if(!_ptrc_glColor4ubv) numFailed++;

+	_ptrc_glColor4ui = (void (CODEGEN_FUNCPTR *)(GLuint, GLuint, GLuint, GLuint))IntGetProcAddress("glColor4ui");

+	if(!_ptrc_glColor4ui) numFailed++;

+	_ptrc_glColor4uiv = (void (CODEGEN_FUNCPTR *)(const GLuint *))IntGetProcAddress("glColor4uiv");

+	if(!_ptrc_glColor4uiv) numFailed++;

+	_ptrc_glColor4us = (void (CODEGEN_FUNCPTR *)(GLushort, GLushort, GLushort, GLushort))IntGetProcAddress("glColor4us");

+	if(!_ptrc_glColor4us) numFailed++;

+	_ptrc_glColor4usv = (void (CODEGEN_FUNCPTR *)(const GLushort *))IntGetProcAddress("glColor4usv");

+	if(!_ptrc_glColor4usv) numFailed++;

+	_ptrc_glColorMask = (void (CODEGEN_FUNCPTR *)(GLboolean, GLboolean, GLboolean, GLboolean))IntGetProcAddress("glColorMask");

+	if(!_ptrc_glColorMask) numFailed++;

+	_ptrc_glColorMaterial = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum))IntGetProcAddress("glColorMaterial");

+	if(!_ptrc_glColorMaterial) numFailed++;

+	_ptrc_glCopyPixels = (void (CODEGEN_FUNCPTR *)(GLint, GLint, GLsizei, GLsizei, GLenum))IntGetProcAddress("glCopyPixels");

+	if(!_ptrc_glCopyPixels) numFailed++;

+	_ptrc_glCullFace = (void (CODEGEN_FUNCPTR *)(GLenum))IntGetProcAddress("glCullFace");

+	if(!_ptrc_glCullFace) numFailed++;

+	_ptrc_glDeleteLists = (void (CODEGEN_FUNCPTR *)(GLuint, GLsizei))IntGetProcAddress("glDeleteLists");

+	if(!_ptrc_glDeleteLists) numFailed++;

+	_ptrc_glDepthFunc = (void (CODEGEN_FUNCPTR *)(GLenum))IntGetProcAddress("glDepthFunc");

+	if(!_ptrc_glDepthFunc) numFailed++;

+	_ptrc_glDepthMask = (void (CODEGEN_FUNCPTR *)(GLboolean))IntGetProcAddress("glDepthMask");

+	if(!_ptrc_glDepthMask) numFailed++;

+	_ptrc_glDepthRange = (void (CODEGEN_FUNCPTR *)(GLdouble, GLdouble))IntGetProcAddress("glDepthRange");

+	if(!_ptrc_glDepthRange) numFailed++;

+	_ptrc_glDisable = (void (CODEGEN_FUNCPTR *)(GLenum))IntGetProcAddress("glDisable");

+	if(!_ptrc_glDisable) numFailed++;

+	_ptrc_glDrawBuffer = (void (CODEGEN_FUNCPTR *)(GLenum))IntGetProcAddress("glDrawBuffer");

+	if(!_ptrc_glDrawBuffer) numFailed++;

+	_ptrc_glDrawPixels = (void (CODEGEN_FUNCPTR *)(GLsizei, GLsizei, GLenum, GLenum, const void *))IntGetProcAddress("glDrawPixels");

+	if(!_ptrc_glDrawPixels) numFailed++;

+	_ptrc_glEdgeFlag = (void (CODEGEN_FUNCPTR *)(GLboolean))IntGetProcAddress("glEdgeFlag");

+	if(!_ptrc_glEdgeFlag) numFailed++;

+	_ptrc_glEdgeFlagv = (void (CODEGEN_FUNCPTR *)(const GLboolean *))IntGetProcAddress("glEdgeFlagv");

+	if(!_ptrc_glEdgeFlagv) numFailed++;

+	_ptrc_glEnable = (void (CODEGEN_FUNCPTR *)(GLenum))IntGetProcAddress("glEnable");

+	if(!_ptrc_glEnable) numFailed++;

+	_ptrc_glEnd = (void (CODEGEN_FUNCPTR *)(void))IntGetProcAddress("glEnd");

+	if(!_ptrc_glEnd) numFailed++;

+	_ptrc_glEndList = (void (CODEGEN_FUNCPTR *)(void))IntGetProcAddress("glEndList");

+	if(!_ptrc_glEndList) numFailed++;

+	_ptrc_glEvalCoord1d = (void (CODEGEN_FUNCPTR *)(GLdouble))IntGetProcAddress("glEvalCoord1d");

+	if(!_ptrc_glEvalCoord1d) numFailed++;

+	_ptrc_glEvalCoord1dv = (void (CODEGEN_FUNCPTR *)(const GLdouble *))IntGetProcAddress("glEvalCoord1dv");

+	if(!_ptrc_glEvalCoord1dv) numFailed++;

+	_ptrc_glEvalCoord1f = (void (CODEGEN_FUNCPTR *)(GLfloat))IntGetProcAddress("glEvalCoord1f");

+	if(!_ptrc_glEvalCoord1f) numFailed++;

+	_ptrc_glEvalCoord1fv = (void (CODEGEN_FUNCPTR *)(const GLfloat *))IntGetProcAddress("glEvalCoord1fv");

+	if(!_ptrc_glEvalCoord1fv) numFailed++;

+	_ptrc_glEvalCoord2d = (void (CODEGEN_FUNCPTR *)(GLdouble, GLdouble))IntGetProcAddress("glEvalCoord2d");

+	if(!_ptrc_glEvalCoord2d) numFailed++;

+	_ptrc_glEvalCoord2dv = (void (CODEGEN_FUNCPTR *)(const GLdouble *))IntGetProcAddress("glEvalCoord2dv");

+	if(!_ptrc_glEvalCoord2dv) numFailed++;

+	_ptrc_glEvalCoord2f = (void (CODEGEN_FUNCPTR *)(GLfloat, GLfloat))IntGetProcAddress("glEvalCoord2f");

+	if(!_ptrc_glEvalCoord2f) numFailed++;

+	_ptrc_glEvalCoord2fv = (void (CODEGEN_FUNCPTR *)(const GLfloat *))IntGetProcAddress("glEvalCoord2fv");

+	if(!_ptrc_glEvalCoord2fv) numFailed++;

+	_ptrc_glEvalMesh1 = (void (CODEGEN_FUNCPTR *)(GLenum, GLint, GLint))IntGetProcAddress("glEvalMesh1");

+	if(!_ptrc_glEvalMesh1) numFailed++;

+	_ptrc_glEvalMesh2 = (void (CODEGEN_FUNCPTR *)(GLenum, GLint, GLint, GLint, GLint))IntGetProcAddress("glEvalMesh2");

+	if(!_ptrc_glEvalMesh2) numFailed++;

+	_ptrc_glEvalPoint1 = (void (CODEGEN_FUNCPTR *)(GLint))IntGetProcAddress("glEvalPoint1");

+	if(!_ptrc_glEvalPoint1) numFailed++;

+	_ptrc_glEvalPoint2 = (void (CODEGEN_FUNCPTR *)(GLint, GLint))IntGetProcAddress("glEvalPoint2");

+	if(!_ptrc_glEvalPoint2) numFailed++;

+	_ptrc_glFeedbackBuffer = (void (CODEGEN_FUNCPTR *)(GLsizei, GLenum, GLfloat *))IntGetProcAddress("glFeedbackBuffer");

+	if(!_ptrc_glFeedbackBuffer) numFailed++;

+	_ptrc_glFinish = (void (CODEGEN_FUNCPTR *)(void))IntGetProcAddress("glFinish");

+	if(!_ptrc_glFinish) numFailed++;

+	_ptrc_glFlush = (void (CODEGEN_FUNCPTR *)(void))IntGetProcAddress("glFlush");

+	if(!_ptrc_glFlush) numFailed++;

+	_ptrc_glFogf = (void (CODEGEN_FUNCPTR *)(GLenum, GLfloat))IntGetProcAddress("glFogf");

+	if(!_ptrc_glFogf) numFailed++;

+	_ptrc_glFogfv = (void (CODEGEN_FUNCPTR *)(GLenum, const GLfloat *))IntGetProcAddress("glFogfv");

+	if(!_ptrc_glFogfv) numFailed++;

+	_ptrc_glFogi = (void (CODEGEN_FUNCPTR *)(GLenum, GLint))IntGetProcAddress("glFogi");

+	if(!_ptrc_glFogi) numFailed++;

+	_ptrc_glFogiv = (void (CODEGEN_FUNCPTR *)(GLenum, const GLint *))IntGetProcAddress("glFogiv");

+	if(!_ptrc_glFogiv) numFailed++;

+	_ptrc_glFrontFace = (void (CODEGEN_FUNCPTR *)(GLenum))IntGetProcAddress("glFrontFace");

+	if(!_ptrc_glFrontFace) numFailed++;

+	_ptrc_glFrustum = (void (CODEGEN_FUNCPTR *)(GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble))IntGetProcAddress("glFrustum");

+	if(!_ptrc_glFrustum) numFailed++;

+	_ptrc_glGenLists = (GLuint (CODEGEN_FUNCPTR *)(GLsizei))IntGetProcAddress("glGenLists");

+	if(!_ptrc_glGenLists) numFailed++;

+	_ptrc_glGetBooleanv = (void (CODEGEN_FUNCPTR *)(GLenum, GLboolean *))IntGetProcAddress("glGetBooleanv");

+	if(!_ptrc_glGetBooleanv) numFailed++;

+	_ptrc_glGetClipPlane = (void (CODEGEN_FUNCPTR *)(GLenum, GLdouble *))IntGetProcAddress("glGetClipPlane");

+	if(!_ptrc_glGetClipPlane) numFailed++;

+	_ptrc_glGetDoublev = (void (CODEGEN_FUNCPTR *)(GLenum, GLdouble *))IntGetProcAddress("glGetDoublev");

+	if(!_ptrc_glGetDoublev) numFailed++;

+	_ptrc_glGetError = (GLenum (CODEGEN_FUNCPTR *)(void))IntGetProcAddress("glGetError");

+	if(!_ptrc_glGetError) numFailed++;

+	_ptrc_glGetFloatv = (void (CODEGEN_FUNCPTR *)(GLenum, GLfloat *))IntGetProcAddress("glGetFloatv");

+	if(!_ptrc_glGetFloatv) numFailed++;

+	_ptrc_glGetIntegerv = (void (CODEGEN_FUNCPTR *)(GLenum, GLint *))IntGetProcAddress("glGetIntegerv");

+	if(!_ptrc_glGetIntegerv) numFailed++;

+	_ptrc_glGetLightfv = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLfloat *))IntGetProcAddress("glGetLightfv");

+	if(!_ptrc_glGetLightfv) numFailed++;

+	_ptrc_glGetLightiv = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLint *))IntGetProcAddress("glGetLightiv");

+	if(!_ptrc_glGetLightiv) numFailed++;

+	_ptrc_glGetMapdv = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLdouble *))IntGetProcAddress("glGetMapdv");

+	if(!_ptrc_glGetMapdv) numFailed++;

+	_ptrc_glGetMapfv = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLfloat *))IntGetProcAddress("glGetMapfv");

+	if(!_ptrc_glGetMapfv) numFailed++;

+	_ptrc_glGetMapiv = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLint *))IntGetProcAddress("glGetMapiv");

+	if(!_ptrc_glGetMapiv) numFailed++;

+	_ptrc_glGetMaterialfv = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLfloat *))IntGetProcAddress("glGetMaterialfv");

+	if(!_ptrc_glGetMaterialfv) numFailed++;

+	_ptrc_glGetMaterialiv = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLint *))IntGetProcAddress("glGetMaterialiv");

+	if(!_ptrc_glGetMaterialiv) numFailed++;

+	_ptrc_glGetPixelMapfv = (void (CODEGEN_FUNCPTR *)(GLenum, GLfloat *))IntGetProcAddress("glGetPixelMapfv");

+	if(!_ptrc_glGetPixelMapfv) numFailed++;

+	_ptrc_glGetPixelMapuiv = (void (CODEGEN_FUNCPTR *)(GLenum, GLuint *))IntGetProcAddress("glGetPixelMapuiv");

+	if(!_ptrc_glGetPixelMapuiv) numFailed++;

+	_ptrc_glGetPixelMapusv = (void (CODEGEN_FUNCPTR *)(GLenum, GLushort *))IntGetProcAddress("glGetPixelMapusv");

+	if(!_ptrc_glGetPixelMapusv) numFailed++;

+	_ptrc_glGetPolygonStipple = (void (CODEGEN_FUNCPTR *)(GLubyte *))IntGetProcAddress("glGetPolygonStipple");

+	if(!_ptrc_glGetPolygonStipple) numFailed++;

+	_ptrc_glGetString = (const GLubyte * (CODEGEN_FUNCPTR *)(GLenum))IntGetProcAddress("glGetString");

+	if(!_ptrc_glGetString) numFailed++;

+	_ptrc_glGetTexEnvfv = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLfloat *))IntGetProcAddress("glGetTexEnvfv");

+	if(!_ptrc_glGetTexEnvfv) numFailed++;

+	_ptrc_glGetTexEnviv = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLint *))IntGetProcAddress("glGetTexEnviv");

+	if(!_ptrc_glGetTexEnviv) numFailed++;

+	_ptrc_glGetTexGendv = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLdouble *))IntGetProcAddress("glGetTexGendv");

+	if(!_ptrc_glGetTexGendv) numFailed++;

+	_ptrc_glGetTexGenfv = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLfloat *))IntGetProcAddress("glGetTexGenfv");

+	if(!_ptrc_glGetTexGenfv) numFailed++;

+	_ptrc_glGetTexGeniv = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLint *))IntGetProcAddress("glGetTexGeniv");

+	if(!_ptrc_glGetTexGeniv) numFailed++;

+	_ptrc_glGetTexImage = (void (CODEGEN_FUNCPTR *)(GLenum, GLint, GLenum, GLenum, void *))IntGetProcAddress("glGetTexImage");

+	if(!_ptrc_glGetTexImage) numFailed++;

+	_ptrc_glGetTexLevelParameterfv = (void (CODEGEN_FUNCPTR *)(GLenum, GLint, GLenum, GLfloat *))IntGetProcAddress("glGetTexLevelParameterfv");

+	if(!_ptrc_glGetTexLevelParameterfv) numFailed++;

+	_ptrc_glGetTexLevelParameteriv = (void (CODEGEN_FUNCPTR *)(GLenum, GLint, GLenum, GLint *))IntGetProcAddress("glGetTexLevelParameteriv");

+	if(!_ptrc_glGetTexLevelParameteriv) numFailed++;

+	_ptrc_glGetTexParameterfv = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLfloat *))IntGetProcAddress("glGetTexParameterfv");

+	if(!_ptrc_glGetTexParameterfv) numFailed++;

+	_ptrc_glGetTexParameteriv = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLint *))IntGetProcAddress("glGetTexParameteriv");

+	if(!_ptrc_glGetTexParameteriv) numFailed++;

+	_ptrc_glHint = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum))IntGetProcAddress("glHint");

+	if(!_ptrc_glHint) numFailed++;

+	_ptrc_glIndexMask = (void (CODEGEN_FUNCPTR *)(GLuint))IntGetProcAddress("glIndexMask");

+	if(!_ptrc_glIndexMask) numFailed++;

+	_ptrc_glIndexd = (void (CODEGEN_FUNCPTR *)(GLdouble))IntGetProcAddress("glIndexd");

+	if(!_ptrc_glIndexd) numFailed++;

+	_ptrc_glIndexdv = (void (CODEGEN_FUNCPTR *)(const GLdouble *))IntGetProcAddress("glIndexdv");

+	if(!_ptrc_glIndexdv) numFailed++;

+	_ptrc_glIndexf = (void (CODEGEN_FUNCPTR *)(GLfloat))IntGetProcAddress("glIndexf");

+	if(!_ptrc_glIndexf) numFailed++;

+	_ptrc_glIndexfv = (void (CODEGEN_FUNCPTR *)(const GLfloat *))IntGetProcAddress("glIndexfv");

+	if(!_ptrc_glIndexfv) numFailed++;

+	_ptrc_glIndexi = (void (CODEGEN_FUNCPTR *)(GLint))IntGetProcAddress("glIndexi");

+	if(!_ptrc_glIndexi) numFailed++;

+	_ptrc_glIndexiv = (void (CODEGEN_FUNCPTR *)(const GLint *))IntGetProcAddress("glIndexiv");

+	if(!_ptrc_glIndexiv) numFailed++;

+	_ptrc_glIndexs = (void (CODEGEN_FUNCPTR *)(GLshort))IntGetProcAddress("glIndexs");

+	if(!_ptrc_glIndexs) numFailed++;

+	_ptrc_glIndexsv = (void (CODEGEN_FUNCPTR *)(const GLshort *))IntGetProcAddress("glIndexsv");

+	if(!_ptrc_glIndexsv) numFailed++;

+	_ptrc_glInitNames = (void (CODEGEN_FUNCPTR *)(void))IntGetProcAddress("glInitNames");

+	if(!_ptrc_glInitNames) numFailed++;

+	_ptrc_glIsEnabled = (GLboolean (CODEGEN_FUNCPTR *)(GLenum))IntGetProcAddress("glIsEnabled");

+	if(!_ptrc_glIsEnabled) numFailed++;

+	_ptrc_glIsList = (GLboolean (CODEGEN_FUNCPTR *)(GLuint))IntGetProcAddress("glIsList");

+	if(!_ptrc_glIsList) numFailed++;

+	_ptrc_glLightModelf = (void (CODEGEN_FUNCPTR *)(GLenum, GLfloat))IntGetProcAddress("glLightModelf");

+	if(!_ptrc_glLightModelf) numFailed++;

+	_ptrc_glLightModelfv = (void (CODEGEN_FUNCPTR *)(GLenum, const GLfloat *))IntGetProcAddress("glLightModelfv");

+	if(!_ptrc_glLightModelfv) numFailed++;

+	_ptrc_glLightModeli = (void (CODEGEN_FUNCPTR *)(GLenum, GLint))IntGetProcAddress("glLightModeli");

+	if(!_ptrc_glLightModeli) numFailed++;

+	_ptrc_glLightModeliv = (void (CODEGEN_FUNCPTR *)(GLenum, const GLint *))IntGetProcAddress("glLightModeliv");

+	if(!_ptrc_glLightModeliv) numFailed++;

+	_ptrc_glLightf = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLfloat))IntGetProcAddress("glLightf");

+	if(!_ptrc_glLightf) numFailed++;

+	_ptrc_glLightfv = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, const GLfloat *))IntGetProcAddress("glLightfv");

+	if(!_ptrc_glLightfv) numFailed++;

+	_ptrc_glLighti = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLint))IntGetProcAddress("glLighti");

+	if(!_ptrc_glLighti) numFailed++;

+	_ptrc_glLightiv = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, const GLint *))IntGetProcAddress("glLightiv");

+	if(!_ptrc_glLightiv) numFailed++;

+	_ptrc_glLineStipple = (void (CODEGEN_FUNCPTR *)(GLint, GLushort))IntGetProcAddress("glLineStipple");

+	if(!_ptrc_glLineStipple) numFailed++;

+	_ptrc_glLineWidth = (void (CODEGEN_FUNCPTR *)(GLfloat))IntGetProcAddress("glLineWidth");

+	if(!_ptrc_glLineWidth) numFailed++;

+	_ptrc_glListBase = (void (CODEGEN_FUNCPTR *)(GLuint))IntGetProcAddress("glListBase");

+	if(!_ptrc_glListBase) numFailed++;

+	_ptrc_glLoadIdentity = (void (CODEGEN_FUNCPTR *)(void))IntGetProcAddress("glLoadIdentity");

+	if(!_ptrc_glLoadIdentity) numFailed++;

+	_ptrc_glLoadMatrixd = (void (CODEGEN_FUNCPTR *)(const GLdouble *))IntGetProcAddress("glLoadMatrixd");

+	if(!_ptrc_glLoadMatrixd) numFailed++;

+	_ptrc_glLoadMatrixf = (void (CODEGEN_FUNCPTR *)(const GLfloat *))IntGetProcAddress("glLoadMatrixf");

+	if(!_ptrc_glLoadMatrixf) numFailed++;

+	_ptrc_glLoadName = (void (CODEGEN_FUNCPTR *)(GLuint))IntGetProcAddress("glLoadName");

+	if(!_ptrc_glLoadName) numFailed++;

+	_ptrc_glLogicOp = (void (CODEGEN_FUNCPTR *)(GLenum))IntGetProcAddress("glLogicOp");

+	if(!_ptrc_glLogicOp) numFailed++;

+	_ptrc_glMap1d = (void (CODEGEN_FUNCPTR *)(GLenum, GLdouble, GLdouble, GLint, GLint, const GLdouble *))IntGetProcAddress("glMap1d");

+	if(!_ptrc_glMap1d) numFailed++;

+	_ptrc_glMap1f = (void (CODEGEN_FUNCPTR *)(GLenum, GLfloat, GLfloat, GLint, GLint, const GLfloat *))IntGetProcAddress("glMap1f");

+	if(!_ptrc_glMap1f) numFailed++;

+	_ptrc_glMap2d = (void (CODEGEN_FUNCPTR *)(GLenum, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, const GLdouble *))IntGetProcAddress("glMap2d");

+	if(!_ptrc_glMap2d) numFailed++;

+	_ptrc_glMap2f = (void (CODEGEN_FUNCPTR *)(GLenum, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, const GLfloat *))IntGetProcAddress("glMap2f");

+	if(!_ptrc_glMap2f) numFailed++;

+	_ptrc_glMapGrid1d = (void (CODEGEN_FUNCPTR *)(GLint, GLdouble, GLdouble))IntGetProcAddress("glMapGrid1d");

+	if(!_ptrc_glMapGrid1d) numFailed++;

+	_ptrc_glMapGrid1f = (void (CODEGEN_FUNCPTR *)(GLint, GLfloat, GLfloat))IntGetProcAddress("glMapGrid1f");

+	if(!_ptrc_glMapGrid1f) numFailed++;

+	_ptrc_glMapGrid2d = (void (CODEGEN_FUNCPTR *)(GLint, GLdouble, GLdouble, GLint, GLdouble, GLdouble))IntGetProcAddress("glMapGrid2d");

+	if(!_ptrc_glMapGrid2d) numFailed++;

+	_ptrc_glMapGrid2f = (void (CODEGEN_FUNCPTR *)(GLint, GLfloat, GLfloat, GLint, GLfloat, GLfloat))IntGetProcAddress("glMapGrid2f");

+	if(!_ptrc_glMapGrid2f) numFailed++;

+	_ptrc_glMaterialf = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLfloat))IntGetProcAddress("glMaterialf");

+	if(!_ptrc_glMaterialf) numFailed++;

+	_ptrc_glMaterialfv = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, const GLfloat *))IntGetProcAddress("glMaterialfv");

+	if(!_ptrc_glMaterialfv) numFailed++;

+	_ptrc_glMateriali = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLint))IntGetProcAddress("glMateriali");

+	if(!_ptrc_glMateriali) numFailed++;

+	_ptrc_glMaterialiv = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, const GLint *))IntGetProcAddress("glMaterialiv");

+	if(!_ptrc_glMaterialiv) numFailed++;

+	_ptrc_glMatrixMode = (void (CODEGEN_FUNCPTR *)(GLenum))IntGetProcAddress("glMatrixMode");

+	if(!_ptrc_glMatrixMode) numFailed++;

+	_ptrc_glMultMatrixd = (void (CODEGEN_FUNCPTR *)(const GLdouble *))IntGetProcAddress("glMultMatrixd");

+	if(!_ptrc_glMultMatrixd) numFailed++;

+	_ptrc_glMultMatrixf = (void (CODEGEN_FUNCPTR *)(const GLfloat *))IntGetProcAddress("glMultMatrixf");

+	if(!_ptrc_glMultMatrixf) numFailed++;

+	_ptrc_glNewList = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum))IntGetProcAddress("glNewList");

+	if(!_ptrc_glNewList) numFailed++;

+	_ptrc_glNormal3b = (void (CODEGEN_FUNCPTR *)(GLbyte, GLbyte, GLbyte))IntGetProcAddress("glNormal3b");

+	if(!_ptrc_glNormal3b) numFailed++;

+	_ptrc_glNormal3bv = (void (CODEGEN_FUNCPTR *)(const GLbyte *))IntGetProcAddress("glNormal3bv");

+	if(!_ptrc_glNormal3bv) numFailed++;

+	_ptrc_glNormal3d = (void (CODEGEN_FUNCPTR *)(GLdouble, GLdouble, GLdouble))IntGetProcAddress("glNormal3d");

+	if(!_ptrc_glNormal3d) numFailed++;

+	_ptrc_glNormal3dv = (void (CODEGEN_FUNCPTR *)(const GLdouble *))IntGetProcAddress("glNormal3dv");

+	if(!_ptrc_glNormal3dv) numFailed++;

+	_ptrc_glNormal3f = (void (CODEGEN_FUNCPTR *)(GLfloat, GLfloat, GLfloat))IntGetProcAddress("glNormal3f");

+	if(!_ptrc_glNormal3f) numFailed++;

+	_ptrc_glNormal3fv = (void (CODEGEN_FUNCPTR *)(const GLfloat *))IntGetProcAddress("glNormal3fv");

+	if(!_ptrc_glNormal3fv) numFailed++;

+	_ptrc_glNormal3i = (void (CODEGEN_FUNCPTR *)(GLint, GLint, GLint))IntGetProcAddress("glNormal3i");

+	if(!_ptrc_glNormal3i) numFailed++;

+	_ptrc_glNormal3iv = (void (CODEGEN_FUNCPTR *)(const GLint *))IntGetProcAddress("glNormal3iv");

+	if(!_ptrc_glNormal3iv) numFailed++;

+	_ptrc_glNormal3s = (void (CODEGEN_FUNCPTR *)(GLshort, GLshort, GLshort))IntGetProcAddress("glNormal3s");

+	if(!_ptrc_glNormal3s) numFailed++;

+	_ptrc_glNormal3sv = (void (CODEGEN_FUNCPTR *)(const GLshort *))IntGetProcAddress("glNormal3sv");

+	if(!_ptrc_glNormal3sv) numFailed++;

+	_ptrc_glOrtho = (void (CODEGEN_FUNCPTR *)(GLdouble, GLdouble, GLdouble, GLdouble, GLdouble, GLdouble))IntGetProcAddress("glOrtho");

+	if(!_ptrc_glOrtho) numFailed++;

+	_ptrc_glPassThrough = (void (CODEGEN_FUNCPTR *)(GLfloat))IntGetProcAddress("glPassThrough");

+	if(!_ptrc_glPassThrough) numFailed++;

+	_ptrc_glPixelMapfv = (void (CODEGEN_FUNCPTR *)(GLenum, GLsizei, const GLfloat *))IntGetProcAddress("glPixelMapfv");

+	if(!_ptrc_glPixelMapfv) numFailed++;

+	_ptrc_glPixelMapuiv = (void (CODEGEN_FUNCPTR *)(GLenum, GLsizei, const GLuint *))IntGetProcAddress("glPixelMapuiv");

+	if(!_ptrc_glPixelMapuiv) numFailed++;

+	_ptrc_glPixelMapusv = (void (CODEGEN_FUNCPTR *)(GLenum, GLsizei, const GLushort *))IntGetProcAddress("glPixelMapusv");

+	if(!_ptrc_glPixelMapusv) numFailed++;

+	_ptrc_glPixelStoref = (void (CODEGEN_FUNCPTR *)(GLenum, GLfloat))IntGetProcAddress("glPixelStoref");

+	if(!_ptrc_glPixelStoref) numFailed++;

+	_ptrc_glPixelStorei = (void (CODEGEN_FUNCPTR *)(GLenum, GLint))IntGetProcAddress("glPixelStorei");

+	if(!_ptrc_glPixelStorei) numFailed++;

+	_ptrc_glPixelTransferf = (void (CODEGEN_FUNCPTR *)(GLenum, GLfloat))IntGetProcAddress("glPixelTransferf");

+	if(!_ptrc_glPixelTransferf) numFailed++;

+	_ptrc_glPixelTransferi = (void (CODEGEN_FUNCPTR *)(GLenum, GLint))IntGetProcAddress("glPixelTransferi");

+	if(!_ptrc_glPixelTransferi) numFailed++;

+	_ptrc_glPixelZoom = (void (CODEGEN_FUNCPTR *)(GLfloat, GLfloat))IntGetProcAddress("glPixelZoom");

+	if(!_ptrc_glPixelZoom) numFailed++;

+	_ptrc_glPointSize = (void (CODEGEN_FUNCPTR *)(GLfloat))IntGetProcAddress("glPointSize");

+	if(!_ptrc_glPointSize) numFailed++;

+	_ptrc_glPolygonMode = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum))IntGetProcAddress("glPolygonMode");

+	if(!_ptrc_glPolygonMode) numFailed++;

+	_ptrc_glPolygonStipple = (void (CODEGEN_FUNCPTR *)(const GLubyte *))IntGetProcAddress("glPolygonStipple");

+	if(!_ptrc_glPolygonStipple) numFailed++;

+	_ptrc_glPopAttrib = (void (CODEGEN_FUNCPTR *)(void))IntGetProcAddress("glPopAttrib");

+	if(!_ptrc_glPopAttrib) numFailed++;

+	_ptrc_glPopMatrix = (void (CODEGEN_FUNCPTR *)(void))IntGetProcAddress("glPopMatrix");

+	if(!_ptrc_glPopMatrix) numFailed++;

+	_ptrc_glPopName = (void (CODEGEN_FUNCPTR *)(void))IntGetProcAddress("glPopName");

+	if(!_ptrc_glPopName) numFailed++;

+	_ptrc_glPushAttrib = (void (CODEGEN_FUNCPTR *)(GLbitfield))IntGetProcAddress("glPushAttrib");

+	if(!_ptrc_glPushAttrib) numFailed++;

+	_ptrc_glPushMatrix = (void (CODEGEN_FUNCPTR *)(void))IntGetProcAddress("glPushMatrix");

+	if(!_ptrc_glPushMatrix) numFailed++;

+	_ptrc_glPushName = (void (CODEGEN_FUNCPTR *)(GLuint))IntGetProcAddress("glPushName");

+	if(!_ptrc_glPushName) numFailed++;

+	_ptrc_glRasterPos2d = (void (CODEGEN_FUNCPTR *)(GLdouble, GLdouble))IntGetProcAddress("glRasterPos2d");

+	if(!_ptrc_glRasterPos2d) numFailed++;

+	_ptrc_glRasterPos2dv = (void (CODEGEN_FUNCPTR *)(const GLdouble *))IntGetProcAddress("glRasterPos2dv");

+	if(!_ptrc_glRasterPos2dv) numFailed++;

+	_ptrc_glRasterPos2f = (void (CODEGEN_FUNCPTR *)(GLfloat, GLfloat))IntGetProcAddress("glRasterPos2f");

+	if(!_ptrc_glRasterPos2f) numFailed++;

+	_ptrc_glRasterPos2fv = (void (CODEGEN_FUNCPTR *)(const GLfloat *))IntGetProcAddress("glRasterPos2fv");

+	if(!_ptrc_glRasterPos2fv) numFailed++;

+	_ptrc_glRasterPos2i = (void (CODEGEN_FUNCPTR *)(GLint, GLint))IntGetProcAddress("glRasterPos2i");

+	if(!_ptrc_glRasterPos2i) numFailed++;

+	_ptrc_glRasterPos2iv = (void (CODEGEN_FUNCPTR *)(const GLint *))IntGetProcAddress("glRasterPos2iv");

+	if(!_ptrc_glRasterPos2iv) numFailed++;

+	_ptrc_glRasterPos2s = (void (CODEGEN_FUNCPTR *)(GLshort, GLshort))IntGetProcAddress("glRasterPos2s");

+	if(!_ptrc_glRasterPos2s) numFailed++;

+	_ptrc_glRasterPos2sv = (void (CODEGEN_FUNCPTR *)(const GLshort *))IntGetProcAddress("glRasterPos2sv");

+	if(!_ptrc_glRasterPos2sv) numFailed++;

+	_ptrc_glRasterPos3d = (void (CODEGEN_FUNCPTR *)(GLdouble, GLdouble, GLdouble))IntGetProcAddress("glRasterPos3d");

+	if(!_ptrc_glRasterPos3d) numFailed++;

+	_ptrc_glRasterPos3dv = (void (CODEGEN_FUNCPTR *)(const GLdouble *))IntGetProcAddress("glRasterPos3dv");

+	if(!_ptrc_glRasterPos3dv) numFailed++;

+	_ptrc_glRasterPos3f = (void (CODEGEN_FUNCPTR *)(GLfloat, GLfloat, GLfloat))IntGetProcAddress("glRasterPos3f");

+	if(!_ptrc_glRasterPos3f) numFailed++;

+	_ptrc_glRasterPos3fv = (void (CODEGEN_FUNCPTR *)(const GLfloat *))IntGetProcAddress("glRasterPos3fv");

+	if(!_ptrc_glRasterPos3fv) numFailed++;

+	_ptrc_glRasterPos3i = (void (CODEGEN_FUNCPTR *)(GLint, GLint, GLint))IntGetProcAddress("glRasterPos3i");

+	if(!_ptrc_glRasterPos3i) numFailed++;

+	_ptrc_glRasterPos3iv = (void (CODEGEN_FUNCPTR *)(const GLint *))IntGetProcAddress("glRasterPos3iv");

+	if(!_ptrc_glRasterPos3iv) numFailed++;

+	_ptrc_glRasterPos3s = (void (CODEGEN_FUNCPTR *)(GLshort, GLshort, GLshort))IntGetProcAddress("glRasterPos3s");

+	if(!_ptrc_glRasterPos3s) numFailed++;

+	_ptrc_glRasterPos3sv = (void (CODEGEN_FUNCPTR *)(const GLshort *))IntGetProcAddress("glRasterPos3sv");

+	if(!_ptrc_glRasterPos3sv) numFailed++;

+	_ptrc_glRasterPos4d = (void (CODEGEN_FUNCPTR *)(GLdouble, GLdouble, GLdouble, GLdouble))IntGetProcAddress("glRasterPos4d");

+	if(!_ptrc_glRasterPos4d) numFailed++;

+	_ptrc_glRasterPos4dv = (void (CODEGEN_FUNCPTR *)(const GLdouble *))IntGetProcAddress("glRasterPos4dv");

+	if(!_ptrc_glRasterPos4dv) numFailed++;

+	_ptrc_glRasterPos4f = (void (CODEGEN_FUNCPTR *)(GLfloat, GLfloat, GLfloat, GLfloat))IntGetProcAddress("glRasterPos4f");

+	if(!_ptrc_glRasterPos4f) numFailed++;

+	_ptrc_glRasterPos4fv = (void (CODEGEN_FUNCPTR *)(const GLfloat *))IntGetProcAddress("glRasterPos4fv");

+	if(!_ptrc_glRasterPos4fv) numFailed++;

+	_ptrc_glRasterPos4i = (void (CODEGEN_FUNCPTR *)(GLint, GLint, GLint, GLint))IntGetProcAddress("glRasterPos4i");

+	if(!_ptrc_glRasterPos4i) numFailed++;

+	_ptrc_glRasterPos4iv = (void (CODEGEN_FUNCPTR *)(const GLint *))IntGetProcAddress("glRasterPos4iv");

+	if(!_ptrc_glRasterPos4iv) numFailed++;

+	_ptrc_glRasterPos4s = (void (CODEGEN_FUNCPTR *)(GLshort, GLshort, GLshort, GLshort))IntGetProcAddress("glRasterPos4s");

+	if(!_ptrc_glRasterPos4s) numFailed++;

+	_ptrc_glRasterPos4sv = (void (CODEGEN_FUNCPTR *)(const GLshort *))IntGetProcAddress("glRasterPos4sv");

+	if(!_ptrc_glRasterPos4sv) numFailed++;

+	_ptrc_glReadBuffer = (void (CODEGEN_FUNCPTR *)(GLenum))IntGetProcAddress("glReadBuffer");

+	if(!_ptrc_glReadBuffer) numFailed++;

+	_ptrc_glReadPixels = (void (CODEGEN_FUNCPTR *)(GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, void *))IntGetProcAddress("glReadPixels");

+	if(!_ptrc_glReadPixels) numFailed++;

+	_ptrc_glRectd = (void (CODEGEN_FUNCPTR *)(GLdouble, GLdouble, GLdouble, GLdouble))IntGetProcAddress("glRectd");

+	if(!_ptrc_glRectd) numFailed++;

+	_ptrc_glRectdv = (void (CODEGEN_FUNCPTR *)(const GLdouble *, const GLdouble *))IntGetProcAddress("glRectdv");

+	if(!_ptrc_glRectdv) numFailed++;

+	_ptrc_glRectf = (void (CODEGEN_FUNCPTR *)(GLfloat, GLfloat, GLfloat, GLfloat))IntGetProcAddress("glRectf");

+	if(!_ptrc_glRectf) numFailed++;

+	_ptrc_glRectfv = (void (CODEGEN_FUNCPTR *)(const GLfloat *, const GLfloat *))IntGetProcAddress("glRectfv");

+	if(!_ptrc_glRectfv) numFailed++;

+	_ptrc_glRecti = (void (CODEGEN_FUNCPTR *)(GLint, GLint, GLint, GLint))IntGetProcAddress("glRecti");

+	if(!_ptrc_glRecti) numFailed++;

+	_ptrc_glRectiv = (void (CODEGEN_FUNCPTR *)(const GLint *, const GLint *))IntGetProcAddress("glRectiv");

+	if(!_ptrc_glRectiv) numFailed++;

+	_ptrc_glRects = (void (CODEGEN_FUNCPTR *)(GLshort, GLshort, GLshort, GLshort))IntGetProcAddress("glRects");

+	if(!_ptrc_glRects) numFailed++;

+	_ptrc_glRectsv = (void (CODEGEN_FUNCPTR *)(const GLshort *, const GLshort *))IntGetProcAddress("glRectsv");

+	if(!_ptrc_glRectsv) numFailed++;

+	_ptrc_glRenderMode = (GLint (CODEGEN_FUNCPTR *)(GLenum))IntGetProcAddress("glRenderMode");

+	if(!_ptrc_glRenderMode) numFailed++;

+	_ptrc_glRotated = (void (CODEGEN_FUNCPTR *)(GLdouble, GLdouble, GLdouble, GLdouble))IntGetProcAddress("glRotated");

+	if(!_ptrc_glRotated) numFailed++;

+	_ptrc_glRotatef = (void (CODEGEN_FUNCPTR *)(GLfloat, GLfloat, GLfloat, GLfloat))IntGetProcAddress("glRotatef");

+	if(!_ptrc_glRotatef) numFailed++;

+	_ptrc_glScaled = (void (CODEGEN_FUNCPTR *)(GLdouble, GLdouble, GLdouble))IntGetProcAddress("glScaled");

+	if(!_ptrc_glScaled) numFailed++;

+	_ptrc_glScalef = (void (CODEGEN_FUNCPTR *)(GLfloat, GLfloat, GLfloat))IntGetProcAddress("glScalef");

+	if(!_ptrc_glScalef) numFailed++;

+	_ptrc_glScissor = (void (CODEGEN_FUNCPTR *)(GLint, GLint, GLsizei, GLsizei))IntGetProcAddress("glScissor");

+	if(!_ptrc_glScissor) numFailed++;

+	_ptrc_glSelectBuffer = (void (CODEGEN_FUNCPTR *)(GLsizei, GLuint *))IntGetProcAddress("glSelectBuffer");

+	if(!_ptrc_glSelectBuffer) numFailed++;

+	_ptrc_glShadeModel = (void (CODEGEN_FUNCPTR *)(GLenum))IntGetProcAddress("glShadeModel");

+	if(!_ptrc_glShadeModel) numFailed++;

+	_ptrc_glStencilFunc = (void (CODEGEN_FUNCPTR *)(GLenum, GLint, GLuint))IntGetProcAddress("glStencilFunc");

+	if(!_ptrc_glStencilFunc) numFailed++;

+	_ptrc_glStencilMask = (void (CODEGEN_FUNCPTR *)(GLuint))IntGetProcAddress("glStencilMask");

+	if(!_ptrc_glStencilMask) numFailed++;

+	_ptrc_glStencilOp = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLenum))IntGetProcAddress("glStencilOp");

+	if(!_ptrc_glStencilOp) numFailed++;

+	_ptrc_glTexCoord1d = (void (CODEGEN_FUNCPTR *)(GLdouble))IntGetProcAddress("glTexCoord1d");

+	if(!_ptrc_glTexCoord1d) numFailed++;

+	_ptrc_glTexCoord1dv = (void (CODEGEN_FUNCPTR *)(const GLdouble *))IntGetProcAddress("glTexCoord1dv");

+	if(!_ptrc_glTexCoord1dv) numFailed++;

+	_ptrc_glTexCoord1f = (void (CODEGEN_FUNCPTR *)(GLfloat))IntGetProcAddress("glTexCoord1f");

+	if(!_ptrc_glTexCoord1f) numFailed++;

+	_ptrc_glTexCoord1fv = (void (CODEGEN_FUNCPTR *)(const GLfloat *))IntGetProcAddress("glTexCoord1fv");

+	if(!_ptrc_glTexCoord1fv) numFailed++;

+	_ptrc_glTexCoord1i = (void (CODEGEN_FUNCPTR *)(GLint))IntGetProcAddress("glTexCoord1i");

+	if(!_ptrc_glTexCoord1i) numFailed++;

+	_ptrc_glTexCoord1iv = (void (CODEGEN_FUNCPTR *)(const GLint *))IntGetProcAddress("glTexCoord1iv");

+	if(!_ptrc_glTexCoord1iv) numFailed++;

+	_ptrc_glTexCoord1s = (void (CODEGEN_FUNCPTR *)(GLshort))IntGetProcAddress("glTexCoord1s");

+	if(!_ptrc_glTexCoord1s) numFailed++;

+	_ptrc_glTexCoord1sv = (void (CODEGEN_FUNCPTR *)(const GLshort *))IntGetProcAddress("glTexCoord1sv");

+	if(!_ptrc_glTexCoord1sv) numFailed++;

+	_ptrc_glTexCoord2d = (void (CODEGEN_FUNCPTR *)(GLdouble, GLdouble))IntGetProcAddress("glTexCoord2d");

+	if(!_ptrc_glTexCoord2d) numFailed++;

+	_ptrc_glTexCoord2dv = (void (CODEGEN_FUNCPTR *)(const GLdouble *))IntGetProcAddress("glTexCoord2dv");

+	if(!_ptrc_glTexCoord2dv) numFailed++;

+	_ptrc_glTexCoord2f = (void (CODEGEN_FUNCPTR *)(GLfloat, GLfloat))IntGetProcAddress("glTexCoord2f");

+	if(!_ptrc_glTexCoord2f) numFailed++;

+	_ptrc_glTexCoord2fv = (void (CODEGEN_FUNCPTR *)(const GLfloat *))IntGetProcAddress("glTexCoord2fv");

+	if(!_ptrc_glTexCoord2fv) numFailed++;

+	_ptrc_glTexCoord2i = (void (CODEGEN_FUNCPTR *)(GLint, GLint))IntGetProcAddress("glTexCoord2i");

+	if(!_ptrc_glTexCoord2i) numFailed++;

+	_ptrc_glTexCoord2iv = (void (CODEGEN_FUNCPTR *)(const GLint *))IntGetProcAddress("glTexCoord2iv");

+	if(!_ptrc_glTexCoord2iv) numFailed++;

+	_ptrc_glTexCoord2s = (void (CODEGEN_FUNCPTR *)(GLshort, GLshort))IntGetProcAddress("glTexCoord2s");

+	if(!_ptrc_glTexCoord2s) numFailed++;

+	_ptrc_glTexCoord2sv = (void (CODEGEN_FUNCPTR *)(const GLshort *))IntGetProcAddress("glTexCoord2sv");

+	if(!_ptrc_glTexCoord2sv) numFailed++;

+	_ptrc_glTexCoord3d = (void (CODEGEN_FUNCPTR *)(GLdouble, GLdouble, GLdouble))IntGetProcAddress("glTexCoord3d");

+	if(!_ptrc_glTexCoord3d) numFailed++;

+	_ptrc_glTexCoord3dv = (void (CODEGEN_FUNCPTR *)(const GLdouble *))IntGetProcAddress("glTexCoord3dv");

+	if(!_ptrc_glTexCoord3dv) numFailed++;

+	_ptrc_glTexCoord3f = (void (CODEGEN_FUNCPTR *)(GLfloat, GLfloat, GLfloat))IntGetProcAddress("glTexCoord3f");

+	if(!_ptrc_glTexCoord3f) numFailed++;

+	_ptrc_glTexCoord3fv = (void (CODEGEN_FUNCPTR *)(const GLfloat *))IntGetProcAddress("glTexCoord3fv");

+	if(!_ptrc_glTexCoord3fv) numFailed++;

+	_ptrc_glTexCoord3i = (void (CODEGEN_FUNCPTR *)(GLint, GLint, GLint))IntGetProcAddress("glTexCoord3i");

+	if(!_ptrc_glTexCoord3i) numFailed++;

+	_ptrc_glTexCoord3iv = (void (CODEGEN_FUNCPTR *)(const GLint *))IntGetProcAddress("glTexCoord3iv");

+	if(!_ptrc_glTexCoord3iv) numFailed++;

+	_ptrc_glTexCoord3s = (void (CODEGEN_FUNCPTR *)(GLshort, GLshort, GLshort))IntGetProcAddress("glTexCoord3s");

+	if(!_ptrc_glTexCoord3s) numFailed++;

+	_ptrc_glTexCoord3sv = (void (CODEGEN_FUNCPTR *)(const GLshort *))IntGetProcAddress("glTexCoord3sv");

+	if(!_ptrc_glTexCoord3sv) numFailed++;

+	_ptrc_glTexCoord4d = (void (CODEGEN_FUNCPTR *)(GLdouble, GLdouble, GLdouble, GLdouble))IntGetProcAddress("glTexCoord4d");

+	if(!_ptrc_glTexCoord4d) numFailed++;

+	_ptrc_glTexCoord4dv = (void (CODEGEN_FUNCPTR *)(const GLdouble *))IntGetProcAddress("glTexCoord4dv");

+	if(!_ptrc_glTexCoord4dv) numFailed++;

+	_ptrc_glTexCoord4f = (void (CODEGEN_FUNCPTR *)(GLfloat, GLfloat, GLfloat, GLfloat))IntGetProcAddress("glTexCoord4f");

+	if(!_ptrc_glTexCoord4f) numFailed++;

+	_ptrc_glTexCoord4fv = (void (CODEGEN_FUNCPTR *)(const GLfloat *))IntGetProcAddress("glTexCoord4fv");

+	if(!_ptrc_glTexCoord4fv) numFailed++;

+	_ptrc_glTexCoord4i = (void (CODEGEN_FUNCPTR *)(GLint, GLint, GLint, GLint))IntGetProcAddress("glTexCoord4i");

+	if(!_ptrc_glTexCoord4i) numFailed++;

+	_ptrc_glTexCoord4iv = (void (CODEGEN_FUNCPTR *)(const GLint *))IntGetProcAddress("glTexCoord4iv");

+	if(!_ptrc_glTexCoord4iv) numFailed++;

+	_ptrc_glTexCoord4s = (void (CODEGEN_FUNCPTR *)(GLshort, GLshort, GLshort, GLshort))IntGetProcAddress("glTexCoord4s");

+	if(!_ptrc_glTexCoord4s) numFailed++;

+	_ptrc_glTexCoord4sv = (void (CODEGEN_FUNCPTR *)(const GLshort *))IntGetProcAddress("glTexCoord4sv");

+	if(!_ptrc_glTexCoord4sv) numFailed++;

+	_ptrc_glTexEnvf = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLfloat))IntGetProcAddress("glTexEnvf");

+	if(!_ptrc_glTexEnvf) numFailed++;

+	_ptrc_glTexEnvfv = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, const GLfloat *))IntGetProcAddress("glTexEnvfv");

+	if(!_ptrc_glTexEnvfv) numFailed++;

+	_ptrc_glTexEnvi = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLint))IntGetProcAddress("glTexEnvi");

+	if(!_ptrc_glTexEnvi) numFailed++;

+	_ptrc_glTexEnviv = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, const GLint *))IntGetProcAddress("glTexEnviv");

+	if(!_ptrc_glTexEnviv) numFailed++;

+	_ptrc_glTexGend = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLdouble))IntGetProcAddress("glTexGend");

+	if(!_ptrc_glTexGend) numFailed++;

+	_ptrc_glTexGendv = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, const GLdouble *))IntGetProcAddress("glTexGendv");

+	if(!_ptrc_glTexGendv) numFailed++;

+	_ptrc_glTexGenf = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLfloat))IntGetProcAddress("glTexGenf");

+	if(!_ptrc_glTexGenf) numFailed++;

+	_ptrc_glTexGenfv = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, const GLfloat *))IntGetProcAddress("glTexGenfv");

+	if(!_ptrc_glTexGenfv) numFailed++;

+	_ptrc_glTexGeni = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLint))IntGetProcAddress("glTexGeni");

+	if(!_ptrc_glTexGeni) numFailed++;

+	_ptrc_glTexGeniv = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, const GLint *))IntGetProcAddress("glTexGeniv");

+	if(!_ptrc_glTexGeniv) numFailed++;

+	_ptrc_glTexImage1D = (void (CODEGEN_FUNCPTR *)(GLenum, GLint, GLint, GLsizei, GLint, GLenum, GLenum, const void *))IntGetProcAddress("glTexImage1D");

+	if(!_ptrc_glTexImage1D) numFailed++;

+	_ptrc_glTexImage2D = (void (CODEGEN_FUNCPTR *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const void *))IntGetProcAddress("glTexImage2D");

+	if(!_ptrc_glTexImage2D) numFailed++;

+	_ptrc_glTexParameterf = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLfloat))IntGetProcAddress("glTexParameterf");

+	if(!_ptrc_glTexParameterf) numFailed++;

+	_ptrc_glTexParameterfv = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, const GLfloat *))IntGetProcAddress("glTexParameterfv");

+	if(!_ptrc_glTexParameterfv) numFailed++;

+	_ptrc_glTexParameteri = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLint))IntGetProcAddress("glTexParameteri");

+	if(!_ptrc_glTexParameteri) numFailed++;

+	_ptrc_glTexParameteriv = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, const GLint *))IntGetProcAddress("glTexParameteriv");

+	if(!_ptrc_glTexParameteriv) numFailed++;

+	_ptrc_glTranslated = (void (CODEGEN_FUNCPTR *)(GLdouble, GLdouble, GLdouble))IntGetProcAddress("glTranslated");

+	if(!_ptrc_glTranslated) numFailed++;

+	_ptrc_glTranslatef = (void (CODEGEN_FUNCPTR *)(GLfloat, GLfloat, GLfloat))IntGetProcAddress("glTranslatef");

+	if(!_ptrc_glTranslatef) numFailed++;

+	_ptrc_glVertex2d = (void (CODEGEN_FUNCPTR *)(GLdouble, GLdouble))IntGetProcAddress("glVertex2d");

+	if(!_ptrc_glVertex2d) numFailed++;

+	_ptrc_glVertex2dv = (void (CODEGEN_FUNCPTR *)(const GLdouble *))IntGetProcAddress("glVertex2dv");

+	if(!_ptrc_glVertex2dv) numFailed++;

+	_ptrc_glVertex2f = (void (CODEGEN_FUNCPTR *)(GLfloat, GLfloat))IntGetProcAddress("glVertex2f");

+	if(!_ptrc_glVertex2f) numFailed++;

+	_ptrc_glVertex2fv = (void (CODEGEN_FUNCPTR *)(const GLfloat *))IntGetProcAddress("glVertex2fv");

+	if(!_ptrc_glVertex2fv) numFailed++;

+	_ptrc_glVertex2i = (void (CODEGEN_FUNCPTR *)(GLint, GLint))IntGetProcAddress("glVertex2i");

+	if(!_ptrc_glVertex2i) numFailed++;

+	_ptrc_glVertex2iv = (void (CODEGEN_FUNCPTR *)(const GLint *))IntGetProcAddress("glVertex2iv");

+	if(!_ptrc_glVertex2iv) numFailed++;

+	_ptrc_glVertex2s = (void (CODEGEN_FUNCPTR *)(GLshort, GLshort))IntGetProcAddress("glVertex2s");

+	if(!_ptrc_glVertex2s) numFailed++;

+	_ptrc_glVertex2sv = (void (CODEGEN_FUNCPTR *)(const GLshort *))IntGetProcAddress("glVertex2sv");

+	if(!_ptrc_glVertex2sv) numFailed++;

+	_ptrc_glVertex3d = (void (CODEGEN_FUNCPTR *)(GLdouble, GLdouble, GLdouble))IntGetProcAddress("glVertex3d");

+	if(!_ptrc_glVertex3d) numFailed++;

+	_ptrc_glVertex3dv = (void (CODEGEN_FUNCPTR *)(const GLdouble *))IntGetProcAddress("glVertex3dv");

+	if(!_ptrc_glVertex3dv) numFailed++;

+	_ptrc_glVertex3f = (void (CODEGEN_FUNCPTR *)(GLfloat, GLfloat, GLfloat))IntGetProcAddress("glVertex3f");

+	if(!_ptrc_glVertex3f) numFailed++;

+	_ptrc_glVertex3fv = (void (CODEGEN_FUNCPTR *)(const GLfloat *))IntGetProcAddress("glVertex3fv");

+	if(!_ptrc_glVertex3fv) numFailed++;

+	_ptrc_glVertex3i = (void (CODEGEN_FUNCPTR *)(GLint, GLint, GLint))IntGetProcAddress("glVertex3i");

+	if(!_ptrc_glVertex3i) numFailed++;

+	_ptrc_glVertex3iv = (void (CODEGEN_FUNCPTR *)(const GLint *))IntGetProcAddress("glVertex3iv");

+	if(!_ptrc_glVertex3iv) numFailed++;

+	_ptrc_glVertex3s = (void (CODEGEN_FUNCPTR *)(GLshort, GLshort, GLshort))IntGetProcAddress("glVertex3s");

+	if(!_ptrc_glVertex3s) numFailed++;

+	_ptrc_glVertex3sv = (void (CODEGEN_FUNCPTR *)(const GLshort *))IntGetProcAddress("glVertex3sv");

+	if(!_ptrc_glVertex3sv) numFailed++;

+	_ptrc_glVertex4d = (void (CODEGEN_FUNCPTR *)(GLdouble, GLdouble, GLdouble, GLdouble))IntGetProcAddress("glVertex4d");

+	if(!_ptrc_glVertex4d) numFailed++;

+	_ptrc_glVertex4dv = (void (CODEGEN_FUNCPTR *)(const GLdouble *))IntGetProcAddress("glVertex4dv");

+	if(!_ptrc_glVertex4dv) numFailed++;

+	_ptrc_glVertex4f = (void (CODEGEN_FUNCPTR *)(GLfloat, GLfloat, GLfloat, GLfloat))IntGetProcAddress("glVertex4f");

+	if(!_ptrc_glVertex4f) numFailed++;

+	_ptrc_glVertex4fv = (void (CODEGEN_FUNCPTR *)(const GLfloat *))IntGetProcAddress("glVertex4fv");

+	if(!_ptrc_glVertex4fv) numFailed++;

+	_ptrc_glVertex4i = (void (CODEGEN_FUNCPTR *)(GLint, GLint, GLint, GLint))IntGetProcAddress("glVertex4i");

+	if(!_ptrc_glVertex4i) numFailed++;

+	_ptrc_glVertex4iv = (void (CODEGEN_FUNCPTR *)(const GLint *))IntGetProcAddress("glVertex4iv");

+	if(!_ptrc_glVertex4iv) numFailed++;

+	_ptrc_glVertex4s = (void (CODEGEN_FUNCPTR *)(GLshort, GLshort, GLshort, GLshort))IntGetProcAddress("glVertex4s");

+	if(!_ptrc_glVertex4s) numFailed++;

+	_ptrc_glVertex4sv = (void (CODEGEN_FUNCPTR *)(const GLshort *))IntGetProcAddress("glVertex4sv");

+	if(!_ptrc_glVertex4sv) numFailed++;

+	_ptrc_glViewport = (void (CODEGEN_FUNCPTR *)(GLint, GLint, GLsizei, GLsizei))IntGetProcAddress("glViewport");

+	if(!_ptrc_glViewport) numFailed++;

+	_ptrc_glAreTexturesResident = (GLboolean (CODEGEN_FUNCPTR *)(GLsizei, const GLuint *, GLboolean *))IntGetProcAddress("glAreTexturesResident");

+	if(!_ptrc_glAreTexturesResident) numFailed++;

+	_ptrc_glArrayElement = (void (CODEGEN_FUNCPTR *)(GLint))IntGetProcAddress("glArrayElement");

+	if(!_ptrc_glArrayElement) numFailed++;

+	_ptrc_glBindTexture = (void (CODEGEN_FUNCPTR *)(GLenum, GLuint))IntGetProcAddress("glBindTexture");

+	if(!_ptrc_glBindTexture) numFailed++;

+	_ptrc_glColorPointer = (void (CODEGEN_FUNCPTR *)(GLint, GLenum, GLsizei, const void *))IntGetProcAddress("glColorPointer");

+	if(!_ptrc_glColorPointer) numFailed++;

+	_ptrc_glCopyTexImage1D = (void (CODEGEN_FUNCPTR *)(GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint))IntGetProcAddress("glCopyTexImage1D");

+	if(!_ptrc_glCopyTexImage1D) numFailed++;

+	_ptrc_glCopyTexImage2D = (void (CODEGEN_FUNCPTR *)(GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint))IntGetProcAddress("glCopyTexImage2D");

+	if(!_ptrc_glCopyTexImage2D) numFailed++;

+	_ptrc_glCopyTexSubImage1D = (void (CODEGEN_FUNCPTR *)(GLenum, GLint, GLint, GLint, GLint, GLsizei))IntGetProcAddress("glCopyTexSubImage1D");

+	if(!_ptrc_glCopyTexSubImage1D) numFailed++;

+	_ptrc_glCopyTexSubImage2D = (void (CODEGEN_FUNCPTR *)(GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei))IntGetProcAddress("glCopyTexSubImage2D");

+	if(!_ptrc_glCopyTexSubImage2D) numFailed++;

+	_ptrc_glDeleteTextures = (void (CODEGEN_FUNCPTR *)(GLsizei, const GLuint *))IntGetProcAddress("glDeleteTextures");

+	if(!_ptrc_glDeleteTextures) numFailed++;

+	_ptrc_glDisableClientState = (void (CODEGEN_FUNCPTR *)(GLenum))IntGetProcAddress("glDisableClientState");

+	if(!_ptrc_glDisableClientState) numFailed++;

+	_ptrc_glDrawArrays = (void (CODEGEN_FUNCPTR *)(GLenum, GLint, GLsizei))IntGetProcAddress("glDrawArrays");

+	if(!_ptrc_glDrawArrays) numFailed++;

+	_ptrc_glDrawElements = (void (CODEGEN_FUNCPTR *)(GLenum, GLsizei, GLenum, const void *))IntGetProcAddress("glDrawElements");

+	if(!_ptrc_glDrawElements) numFailed++;

+	_ptrc_glEdgeFlagPointer = (void (CODEGEN_FUNCPTR *)(GLsizei, const void *))IntGetProcAddress("glEdgeFlagPointer");

+	if(!_ptrc_glEdgeFlagPointer) numFailed++;

+	_ptrc_glEnableClientState = (void (CODEGEN_FUNCPTR *)(GLenum))IntGetProcAddress("glEnableClientState");

+	if(!_ptrc_glEnableClientState) numFailed++;

+	_ptrc_glGenTextures = (void (CODEGEN_FUNCPTR *)(GLsizei, GLuint *))IntGetProcAddress("glGenTextures");

+	if(!_ptrc_glGenTextures) numFailed++;

+	_ptrc_glGetPointerv = (void (CODEGEN_FUNCPTR *)(GLenum, void **))IntGetProcAddress("glGetPointerv");

+	if(!_ptrc_glGetPointerv) numFailed++;

+	_ptrc_glIndexPointer = (void (CODEGEN_FUNCPTR *)(GLenum, GLsizei, const void *))IntGetProcAddress("glIndexPointer");

+	if(!_ptrc_glIndexPointer) numFailed++;

+	_ptrc_glIndexub = (void (CODEGEN_FUNCPTR *)(GLubyte))IntGetProcAddress("glIndexub");

+	if(!_ptrc_glIndexub) numFailed++;

+	_ptrc_glIndexubv = (void (CODEGEN_FUNCPTR *)(const GLubyte *))IntGetProcAddress("glIndexubv");

+	if(!_ptrc_glIndexubv) numFailed++;

+	_ptrc_glInterleavedArrays = (void (CODEGEN_FUNCPTR *)(GLenum, GLsizei, const void *))IntGetProcAddress("glInterleavedArrays");

+	if(!_ptrc_glInterleavedArrays) numFailed++;

+	_ptrc_glIsTexture = (GLboolean (CODEGEN_FUNCPTR *)(GLuint))IntGetProcAddress("glIsTexture");

+	if(!_ptrc_glIsTexture) numFailed++;

+	_ptrc_glNormalPointer = (void (CODEGEN_FUNCPTR *)(GLenum, GLsizei, const void *))IntGetProcAddress("glNormalPointer");

+	if(!_ptrc_glNormalPointer) numFailed++;

+	_ptrc_glPolygonOffset = (void (CODEGEN_FUNCPTR *)(GLfloat, GLfloat))IntGetProcAddress("glPolygonOffset");

+	if(!_ptrc_glPolygonOffset) numFailed++;

+	_ptrc_glPopClientAttrib = (void (CODEGEN_FUNCPTR *)(void))IntGetProcAddress("glPopClientAttrib");

+	if(!_ptrc_glPopClientAttrib) numFailed++;

+	_ptrc_glPrioritizeTextures = (void (CODEGEN_FUNCPTR *)(GLsizei, const GLuint *, const GLfloat *))IntGetProcAddress("glPrioritizeTextures");

+	if(!_ptrc_glPrioritizeTextures) numFailed++;

+	_ptrc_glPushClientAttrib = (void (CODEGEN_FUNCPTR *)(GLbitfield))IntGetProcAddress("glPushClientAttrib");

+	if(!_ptrc_glPushClientAttrib) numFailed++;

+	_ptrc_glTexCoordPointer = (void (CODEGEN_FUNCPTR *)(GLint, GLenum, GLsizei, const void *))IntGetProcAddress("glTexCoordPointer");

+	if(!_ptrc_glTexCoordPointer) numFailed++;

+	_ptrc_glTexSubImage1D = (void (CODEGEN_FUNCPTR *)(GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const void *))IntGetProcAddress("glTexSubImage1D");

+	if(!_ptrc_glTexSubImage1D) numFailed++;

+	_ptrc_glTexSubImage2D = (void (CODEGEN_FUNCPTR *)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const void *))IntGetProcAddress("glTexSubImage2D");

+	if(!_ptrc_glTexSubImage2D) numFailed++;

+	_ptrc_glVertexPointer = (void (CODEGEN_FUNCPTR *)(GLint, GLenum, GLsizei, const void *))IntGetProcAddress("glVertexPointer");

+	if(!_ptrc_glVertexPointer) numFailed++;

+	_ptrc_glCopyTexSubImage3D = (void (CODEGEN_FUNCPTR *)(GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei))IntGetProcAddress("glCopyTexSubImage3D");

+	if(!_ptrc_glCopyTexSubImage3D) numFailed++;

+	_ptrc_glDrawRangeElements = (void (CODEGEN_FUNCPTR *)(GLenum, GLuint, GLuint, GLsizei, GLenum, const void *))IntGetProcAddress("glDrawRangeElements");

+	if(!_ptrc_glDrawRangeElements) numFailed++;

+	_ptrc_glTexImage3D = (void (CODEGEN_FUNCPTR *)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const void *))IntGetProcAddress("glTexImage3D");

+	if(!_ptrc_glTexImage3D) numFailed++;

+	_ptrc_glTexSubImage3D = (void (CODEGEN_FUNCPTR *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const void *))IntGetProcAddress("glTexSubImage3D");

+	if(!_ptrc_glTexSubImage3D) numFailed++;

+	_ptrc_glActiveTexture = (void (CODEGEN_FUNCPTR *)(GLenum))IntGetProcAddress("glActiveTexture");

+	if(!_ptrc_glActiveTexture) numFailed++;

+	_ptrc_glClientActiveTexture = (void (CODEGEN_FUNCPTR *)(GLenum))IntGetProcAddress("glClientActiveTexture");

+	if(!_ptrc_glClientActiveTexture) numFailed++;

+	_ptrc_glCompressedTexImage1D = (void (CODEGEN_FUNCPTR *)(GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, const void *))IntGetProcAddress("glCompressedTexImage1D");

+	if(!_ptrc_glCompressedTexImage1D) numFailed++;

+	_ptrc_glCompressedTexImage2D = (void (CODEGEN_FUNCPTR *)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, const void *))IntGetProcAddress("glCompressedTexImage2D");

+	if(!_ptrc_glCompressedTexImage2D) numFailed++;

+	_ptrc_glCompressedTexImage3D = (void (CODEGEN_FUNCPTR *)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, const void *))IntGetProcAddress("glCompressedTexImage3D");

+	if(!_ptrc_glCompressedTexImage3D) numFailed++;

+	_ptrc_glCompressedTexSubImage1D = (void (CODEGEN_FUNCPTR *)(GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, const void *))IntGetProcAddress("glCompressedTexSubImage1D");

+	if(!_ptrc_glCompressedTexSubImage1D) numFailed++;

+	_ptrc_glCompressedTexSubImage2D = (void (CODEGEN_FUNCPTR *)(GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, const void *))IntGetProcAddress("glCompressedTexSubImage2D");

+	if(!_ptrc_glCompressedTexSubImage2D) numFailed++;

+	_ptrc_glCompressedTexSubImage3D = (void (CODEGEN_FUNCPTR *)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, const void *))IntGetProcAddress("glCompressedTexSubImage3D");

+	if(!_ptrc_glCompressedTexSubImage3D) numFailed++;

+	_ptrc_glGetCompressedTexImage = (void (CODEGEN_FUNCPTR *)(GLenum, GLint, void *))IntGetProcAddress("glGetCompressedTexImage");

+	if(!_ptrc_glGetCompressedTexImage) numFailed++;

+	_ptrc_glLoadTransposeMatrixd = (void (CODEGEN_FUNCPTR *)(const GLdouble *))IntGetProcAddress("glLoadTransposeMatrixd");

+	if(!_ptrc_glLoadTransposeMatrixd) numFailed++;

+	_ptrc_glLoadTransposeMatrixf = (void (CODEGEN_FUNCPTR *)(const GLfloat *))IntGetProcAddress("glLoadTransposeMatrixf");

+	if(!_ptrc_glLoadTransposeMatrixf) numFailed++;

+	_ptrc_glMultTransposeMatrixd = (void (CODEGEN_FUNCPTR *)(const GLdouble *))IntGetProcAddress("glMultTransposeMatrixd");

+	if(!_ptrc_glMultTransposeMatrixd) numFailed++;

+	_ptrc_glMultTransposeMatrixf = (void (CODEGEN_FUNCPTR *)(const GLfloat *))IntGetProcAddress("glMultTransposeMatrixf");

+	if(!_ptrc_glMultTransposeMatrixf) numFailed++;

+	_ptrc_glMultiTexCoord1d = (void (CODEGEN_FUNCPTR *)(GLenum, GLdouble))IntGetProcAddress("glMultiTexCoord1d");

+	if(!_ptrc_glMultiTexCoord1d) numFailed++;

+	_ptrc_glMultiTexCoord1dv = (void (CODEGEN_FUNCPTR *)(GLenum, const GLdouble *))IntGetProcAddress("glMultiTexCoord1dv");

+	if(!_ptrc_glMultiTexCoord1dv) numFailed++;

+	_ptrc_glMultiTexCoord1f = (void (CODEGEN_FUNCPTR *)(GLenum, GLfloat))IntGetProcAddress("glMultiTexCoord1f");

+	if(!_ptrc_glMultiTexCoord1f) numFailed++;

+	_ptrc_glMultiTexCoord1fv = (void (CODEGEN_FUNCPTR *)(GLenum, const GLfloat *))IntGetProcAddress("glMultiTexCoord1fv");

+	if(!_ptrc_glMultiTexCoord1fv) numFailed++;

+	_ptrc_glMultiTexCoord1i = (void (CODEGEN_FUNCPTR *)(GLenum, GLint))IntGetProcAddress("glMultiTexCoord1i");

+	if(!_ptrc_glMultiTexCoord1i) numFailed++;

+	_ptrc_glMultiTexCoord1iv = (void (CODEGEN_FUNCPTR *)(GLenum, const GLint *))IntGetProcAddress("glMultiTexCoord1iv");

+	if(!_ptrc_glMultiTexCoord1iv) numFailed++;

+	_ptrc_glMultiTexCoord1s = (void (CODEGEN_FUNCPTR *)(GLenum, GLshort))IntGetProcAddress("glMultiTexCoord1s");

+	if(!_ptrc_glMultiTexCoord1s) numFailed++;

+	_ptrc_glMultiTexCoord1sv = (void (CODEGEN_FUNCPTR *)(GLenum, const GLshort *))IntGetProcAddress("glMultiTexCoord1sv");

+	if(!_ptrc_glMultiTexCoord1sv) numFailed++;

+	_ptrc_glMultiTexCoord2d = (void (CODEGEN_FUNCPTR *)(GLenum, GLdouble, GLdouble))IntGetProcAddress("glMultiTexCoord2d");

+	if(!_ptrc_glMultiTexCoord2d) numFailed++;

+	_ptrc_glMultiTexCoord2dv = (void (CODEGEN_FUNCPTR *)(GLenum, const GLdouble *))IntGetProcAddress("glMultiTexCoord2dv");

+	if(!_ptrc_glMultiTexCoord2dv) numFailed++;

+	_ptrc_glMultiTexCoord2f = (void (CODEGEN_FUNCPTR *)(GLenum, GLfloat, GLfloat))IntGetProcAddress("glMultiTexCoord2f");

+	if(!_ptrc_glMultiTexCoord2f) numFailed++;

+	_ptrc_glMultiTexCoord2fv = (void (CODEGEN_FUNCPTR *)(GLenum, const GLfloat *))IntGetProcAddress("glMultiTexCoord2fv");

+	if(!_ptrc_glMultiTexCoord2fv) numFailed++;

+	_ptrc_glMultiTexCoord2i = (void (CODEGEN_FUNCPTR *)(GLenum, GLint, GLint))IntGetProcAddress("glMultiTexCoord2i");

+	if(!_ptrc_glMultiTexCoord2i) numFailed++;

+	_ptrc_glMultiTexCoord2iv = (void (CODEGEN_FUNCPTR *)(GLenum, const GLint *))IntGetProcAddress("glMultiTexCoord2iv");

+	if(!_ptrc_glMultiTexCoord2iv) numFailed++;

+	_ptrc_glMultiTexCoord2s = (void (CODEGEN_FUNCPTR *)(GLenum, GLshort, GLshort))IntGetProcAddress("glMultiTexCoord2s");

+	if(!_ptrc_glMultiTexCoord2s) numFailed++;

+	_ptrc_glMultiTexCoord2sv = (void (CODEGEN_FUNCPTR *)(GLenum, const GLshort *))IntGetProcAddress("glMultiTexCoord2sv");

+	if(!_ptrc_glMultiTexCoord2sv) numFailed++;

+	_ptrc_glMultiTexCoord3d = (void (CODEGEN_FUNCPTR *)(GLenum, GLdouble, GLdouble, GLdouble))IntGetProcAddress("glMultiTexCoord3d");

+	if(!_ptrc_glMultiTexCoord3d) numFailed++;

+	_ptrc_glMultiTexCoord3dv = (void (CODEGEN_FUNCPTR *)(GLenum, const GLdouble *))IntGetProcAddress("glMultiTexCoord3dv");

+	if(!_ptrc_glMultiTexCoord3dv) numFailed++;

+	_ptrc_glMultiTexCoord3f = (void (CODEGEN_FUNCPTR *)(GLenum, GLfloat, GLfloat, GLfloat))IntGetProcAddress("glMultiTexCoord3f");

+	if(!_ptrc_glMultiTexCoord3f) numFailed++;

+	_ptrc_glMultiTexCoord3fv = (void (CODEGEN_FUNCPTR *)(GLenum, const GLfloat *))IntGetProcAddress("glMultiTexCoord3fv");

+	if(!_ptrc_glMultiTexCoord3fv) numFailed++;

+	_ptrc_glMultiTexCoord3i = (void (CODEGEN_FUNCPTR *)(GLenum, GLint, GLint, GLint))IntGetProcAddress("glMultiTexCoord3i");

+	if(!_ptrc_glMultiTexCoord3i) numFailed++;

+	_ptrc_glMultiTexCoord3iv = (void (CODEGEN_FUNCPTR *)(GLenum, const GLint *))IntGetProcAddress("glMultiTexCoord3iv");

+	if(!_ptrc_glMultiTexCoord3iv) numFailed++;

+	_ptrc_glMultiTexCoord3s = (void (CODEGEN_FUNCPTR *)(GLenum, GLshort, GLshort, GLshort))IntGetProcAddress("glMultiTexCoord3s");

+	if(!_ptrc_glMultiTexCoord3s) numFailed++;

+	_ptrc_glMultiTexCoord3sv = (void (CODEGEN_FUNCPTR *)(GLenum, const GLshort *))IntGetProcAddress("glMultiTexCoord3sv");

+	if(!_ptrc_glMultiTexCoord3sv) numFailed++;

+	_ptrc_glMultiTexCoord4d = (void (CODEGEN_FUNCPTR *)(GLenum, GLdouble, GLdouble, GLdouble, GLdouble))IntGetProcAddress("glMultiTexCoord4d");

+	if(!_ptrc_glMultiTexCoord4d) numFailed++;

+	_ptrc_glMultiTexCoord4dv = (void (CODEGEN_FUNCPTR *)(GLenum, const GLdouble *))IntGetProcAddress("glMultiTexCoord4dv");

+	if(!_ptrc_glMultiTexCoord4dv) numFailed++;

+	_ptrc_glMultiTexCoord4f = (void (CODEGEN_FUNCPTR *)(GLenum, GLfloat, GLfloat, GLfloat, GLfloat))IntGetProcAddress("glMultiTexCoord4f");

+	if(!_ptrc_glMultiTexCoord4f) numFailed++;

+	_ptrc_glMultiTexCoord4fv = (void (CODEGEN_FUNCPTR *)(GLenum, const GLfloat *))IntGetProcAddress("glMultiTexCoord4fv");

+	if(!_ptrc_glMultiTexCoord4fv) numFailed++;

+	_ptrc_glMultiTexCoord4i = (void (CODEGEN_FUNCPTR *)(GLenum, GLint, GLint, GLint, GLint))IntGetProcAddress("glMultiTexCoord4i");

+	if(!_ptrc_glMultiTexCoord4i) numFailed++;

+	_ptrc_glMultiTexCoord4iv = (void (CODEGEN_FUNCPTR *)(GLenum, const GLint *))IntGetProcAddress("glMultiTexCoord4iv");

+	if(!_ptrc_glMultiTexCoord4iv) numFailed++;

+	_ptrc_glMultiTexCoord4s = (void (CODEGEN_FUNCPTR *)(GLenum, GLshort, GLshort, GLshort, GLshort))IntGetProcAddress("glMultiTexCoord4s");

+	if(!_ptrc_glMultiTexCoord4s) numFailed++;

+	_ptrc_glMultiTexCoord4sv = (void (CODEGEN_FUNCPTR *)(GLenum, const GLshort *))IntGetProcAddress("glMultiTexCoord4sv");

+	if(!_ptrc_glMultiTexCoord4sv) numFailed++;

+	_ptrc_glSampleCoverage = (void (CODEGEN_FUNCPTR *)(GLfloat, GLboolean))IntGetProcAddress("glSampleCoverage");

+	if(!_ptrc_glSampleCoverage) numFailed++;

+	_ptrc_glBlendColor = (void (CODEGEN_FUNCPTR *)(GLfloat, GLfloat, GLfloat, GLfloat))IntGetProcAddress("glBlendColor");

+	if(!_ptrc_glBlendColor) numFailed++;

+	_ptrc_glBlendEquation = (void (CODEGEN_FUNCPTR *)(GLenum))IntGetProcAddress("glBlendEquation");

+	if(!_ptrc_glBlendEquation) numFailed++;

+	_ptrc_glBlendFuncSeparate = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLenum, GLenum))IntGetProcAddress("glBlendFuncSeparate");

+	if(!_ptrc_glBlendFuncSeparate) numFailed++;

+	_ptrc_glFogCoordPointer = (void (CODEGEN_FUNCPTR *)(GLenum, GLsizei, const void *))IntGetProcAddress("glFogCoordPointer");

+	if(!_ptrc_glFogCoordPointer) numFailed++;

+	_ptrc_glFogCoordd = (void (CODEGEN_FUNCPTR *)(GLdouble))IntGetProcAddress("glFogCoordd");

+	if(!_ptrc_glFogCoordd) numFailed++;

+	_ptrc_glFogCoorddv = (void (CODEGEN_FUNCPTR *)(const GLdouble *))IntGetProcAddress("glFogCoorddv");

+	if(!_ptrc_glFogCoorddv) numFailed++;

+	_ptrc_glFogCoordf = (void (CODEGEN_FUNCPTR *)(GLfloat))IntGetProcAddress("glFogCoordf");

+	if(!_ptrc_glFogCoordf) numFailed++;

+	_ptrc_glFogCoordfv = (void (CODEGEN_FUNCPTR *)(const GLfloat *))IntGetProcAddress("glFogCoordfv");

+	if(!_ptrc_glFogCoordfv) numFailed++;

+	_ptrc_glMultiDrawArrays = (void (CODEGEN_FUNCPTR *)(GLenum, const GLint *, const GLsizei *, GLsizei))IntGetProcAddress("glMultiDrawArrays");

+	if(!_ptrc_glMultiDrawArrays) numFailed++;

+	_ptrc_glMultiDrawElements = (void (CODEGEN_FUNCPTR *)(GLenum, const GLsizei *, GLenum, const void *const*, GLsizei))IntGetProcAddress("glMultiDrawElements");

+	if(!_ptrc_glMultiDrawElements) numFailed++;

+	_ptrc_glPointParameterf = (void (CODEGEN_FUNCPTR *)(GLenum, GLfloat))IntGetProcAddress("glPointParameterf");

+	if(!_ptrc_glPointParameterf) numFailed++;

+	_ptrc_glPointParameterfv = (void (CODEGEN_FUNCPTR *)(GLenum, const GLfloat *))IntGetProcAddress("glPointParameterfv");

+	if(!_ptrc_glPointParameterfv) numFailed++;

+	_ptrc_glPointParameteri = (void (CODEGEN_FUNCPTR *)(GLenum, GLint))IntGetProcAddress("glPointParameteri");

+	if(!_ptrc_glPointParameteri) numFailed++;

+	_ptrc_glPointParameteriv = (void (CODEGEN_FUNCPTR *)(GLenum, const GLint *))IntGetProcAddress("glPointParameteriv");

+	if(!_ptrc_glPointParameteriv) numFailed++;

+	_ptrc_glSecondaryColor3b = (void (CODEGEN_FUNCPTR *)(GLbyte, GLbyte, GLbyte))IntGetProcAddress("glSecondaryColor3b");

+	if(!_ptrc_glSecondaryColor3b) numFailed++;

+	_ptrc_glSecondaryColor3bv = (void (CODEGEN_FUNCPTR *)(const GLbyte *))IntGetProcAddress("glSecondaryColor3bv");

+	if(!_ptrc_glSecondaryColor3bv) numFailed++;

+	_ptrc_glSecondaryColor3d = (void (CODEGEN_FUNCPTR *)(GLdouble, GLdouble, GLdouble))IntGetProcAddress("glSecondaryColor3d");

+	if(!_ptrc_glSecondaryColor3d) numFailed++;

+	_ptrc_glSecondaryColor3dv = (void (CODEGEN_FUNCPTR *)(const GLdouble *))IntGetProcAddress("glSecondaryColor3dv");

+	if(!_ptrc_glSecondaryColor3dv) numFailed++;

+	_ptrc_glSecondaryColor3f = (void (CODEGEN_FUNCPTR *)(GLfloat, GLfloat, GLfloat))IntGetProcAddress("glSecondaryColor3f");

+	if(!_ptrc_glSecondaryColor3f) numFailed++;

+	_ptrc_glSecondaryColor3fv = (void (CODEGEN_FUNCPTR *)(const GLfloat *))IntGetProcAddress("glSecondaryColor3fv");

+	if(!_ptrc_glSecondaryColor3fv) numFailed++;

+	_ptrc_glSecondaryColor3i = (void (CODEGEN_FUNCPTR *)(GLint, GLint, GLint))IntGetProcAddress("glSecondaryColor3i");

+	if(!_ptrc_glSecondaryColor3i) numFailed++;

+	_ptrc_glSecondaryColor3iv = (void (CODEGEN_FUNCPTR *)(const GLint *))IntGetProcAddress("glSecondaryColor3iv");

+	if(!_ptrc_glSecondaryColor3iv) numFailed++;

+	_ptrc_glSecondaryColor3s = (void (CODEGEN_FUNCPTR *)(GLshort, GLshort, GLshort))IntGetProcAddress("glSecondaryColor3s");

+	if(!_ptrc_glSecondaryColor3s) numFailed++;

+	_ptrc_glSecondaryColor3sv = (void (CODEGEN_FUNCPTR *)(const GLshort *))IntGetProcAddress("glSecondaryColor3sv");

+	if(!_ptrc_glSecondaryColor3sv) numFailed++;

+	_ptrc_glSecondaryColor3ub = (void (CODEGEN_FUNCPTR *)(GLubyte, GLubyte, GLubyte))IntGetProcAddress("glSecondaryColor3ub");

+	if(!_ptrc_glSecondaryColor3ub) numFailed++;

+	_ptrc_glSecondaryColor3ubv = (void (CODEGEN_FUNCPTR *)(const GLubyte *))IntGetProcAddress("glSecondaryColor3ubv");

+	if(!_ptrc_glSecondaryColor3ubv) numFailed++;

+	_ptrc_glSecondaryColor3ui = (void (CODEGEN_FUNCPTR *)(GLuint, GLuint, GLuint))IntGetProcAddress("glSecondaryColor3ui");

+	if(!_ptrc_glSecondaryColor3ui) numFailed++;

+	_ptrc_glSecondaryColor3uiv = (void (CODEGEN_FUNCPTR *)(const GLuint *))IntGetProcAddress("glSecondaryColor3uiv");

+	if(!_ptrc_glSecondaryColor3uiv) numFailed++;

+	_ptrc_glSecondaryColor3us = (void (CODEGEN_FUNCPTR *)(GLushort, GLushort, GLushort))IntGetProcAddress("glSecondaryColor3us");

+	if(!_ptrc_glSecondaryColor3us) numFailed++;

+	_ptrc_glSecondaryColor3usv = (void (CODEGEN_FUNCPTR *)(const GLushort *))IntGetProcAddress("glSecondaryColor3usv");

+	if(!_ptrc_glSecondaryColor3usv) numFailed++;

+	_ptrc_glSecondaryColorPointer = (void (CODEGEN_FUNCPTR *)(GLint, GLenum, GLsizei, const void *))IntGetProcAddress("glSecondaryColorPointer");

+	if(!_ptrc_glSecondaryColorPointer) numFailed++;

+	_ptrc_glWindowPos2d = (void (CODEGEN_FUNCPTR *)(GLdouble, GLdouble))IntGetProcAddress("glWindowPos2d");

+	if(!_ptrc_glWindowPos2d) numFailed++;

+	_ptrc_glWindowPos2dv = (void (CODEGEN_FUNCPTR *)(const GLdouble *))IntGetProcAddress("glWindowPos2dv");

+	if(!_ptrc_glWindowPos2dv) numFailed++;

+	_ptrc_glWindowPos2f = (void (CODEGEN_FUNCPTR *)(GLfloat, GLfloat))IntGetProcAddress("glWindowPos2f");

+	if(!_ptrc_glWindowPos2f) numFailed++;

+	_ptrc_glWindowPos2fv = (void (CODEGEN_FUNCPTR *)(const GLfloat *))IntGetProcAddress("glWindowPos2fv");

+	if(!_ptrc_glWindowPos2fv) numFailed++;

+	_ptrc_glWindowPos2i = (void (CODEGEN_FUNCPTR *)(GLint, GLint))IntGetProcAddress("glWindowPos2i");

+	if(!_ptrc_glWindowPos2i) numFailed++;

+	_ptrc_glWindowPos2iv = (void (CODEGEN_FUNCPTR *)(const GLint *))IntGetProcAddress("glWindowPos2iv");

+	if(!_ptrc_glWindowPos2iv) numFailed++;

+	_ptrc_glWindowPos2s = (void (CODEGEN_FUNCPTR *)(GLshort, GLshort))IntGetProcAddress("glWindowPos2s");

+	if(!_ptrc_glWindowPos2s) numFailed++;

+	_ptrc_glWindowPos2sv = (void (CODEGEN_FUNCPTR *)(const GLshort *))IntGetProcAddress("glWindowPos2sv");

+	if(!_ptrc_glWindowPos2sv) numFailed++;

+	_ptrc_glWindowPos3d = (void (CODEGEN_FUNCPTR *)(GLdouble, GLdouble, GLdouble))IntGetProcAddress("glWindowPos3d");

+	if(!_ptrc_glWindowPos3d) numFailed++;

+	_ptrc_glWindowPos3dv = (void (CODEGEN_FUNCPTR *)(const GLdouble *))IntGetProcAddress("glWindowPos3dv");

+	if(!_ptrc_glWindowPos3dv) numFailed++;

+	_ptrc_glWindowPos3f = (void (CODEGEN_FUNCPTR *)(GLfloat, GLfloat, GLfloat))IntGetProcAddress("glWindowPos3f");

+	if(!_ptrc_glWindowPos3f) numFailed++;

+	_ptrc_glWindowPos3fv = (void (CODEGEN_FUNCPTR *)(const GLfloat *))IntGetProcAddress("glWindowPos3fv");

+	if(!_ptrc_glWindowPos3fv) numFailed++;

+	_ptrc_glWindowPos3i = (void (CODEGEN_FUNCPTR *)(GLint, GLint, GLint))IntGetProcAddress("glWindowPos3i");

+	if(!_ptrc_glWindowPos3i) numFailed++;

+	_ptrc_glWindowPos3iv = (void (CODEGEN_FUNCPTR *)(const GLint *))IntGetProcAddress("glWindowPos3iv");

+	if(!_ptrc_glWindowPos3iv) numFailed++;

+	_ptrc_glWindowPos3s = (void (CODEGEN_FUNCPTR *)(GLshort, GLshort, GLshort))IntGetProcAddress("glWindowPos3s");

+	if(!_ptrc_glWindowPos3s) numFailed++;

+	_ptrc_glWindowPos3sv = (void (CODEGEN_FUNCPTR *)(const GLshort *))IntGetProcAddress("glWindowPos3sv");

+	if(!_ptrc_glWindowPos3sv) numFailed++;

+	_ptrc_glBeginQuery = (void (CODEGEN_FUNCPTR *)(GLenum, GLuint))IntGetProcAddress("glBeginQuery");

+	if(!_ptrc_glBeginQuery) numFailed++;

+	_ptrc_glBindBuffer = (void (CODEGEN_FUNCPTR *)(GLenum, GLuint))IntGetProcAddress("glBindBuffer");

+	if(!_ptrc_glBindBuffer) numFailed++;

+	_ptrc_glBufferData = (void (CODEGEN_FUNCPTR *)(GLenum, GLsizeiptr, const void *, GLenum))IntGetProcAddress("glBufferData");

+	if(!_ptrc_glBufferData) numFailed++;

+	_ptrc_glBufferSubData = (void (CODEGEN_FUNCPTR *)(GLenum, GLintptr, GLsizeiptr, const void *))IntGetProcAddress("glBufferSubData");

+	if(!_ptrc_glBufferSubData) numFailed++;

+	_ptrc_glDeleteBuffers = (void (CODEGEN_FUNCPTR *)(GLsizei, const GLuint *))IntGetProcAddress("glDeleteBuffers");

+	if(!_ptrc_glDeleteBuffers) numFailed++;

+	_ptrc_glDeleteQueries = (void (CODEGEN_FUNCPTR *)(GLsizei, const GLuint *))IntGetProcAddress("glDeleteQueries");

+	if(!_ptrc_glDeleteQueries) numFailed++;

+	_ptrc_glEndQuery = (void (CODEGEN_FUNCPTR *)(GLenum))IntGetProcAddress("glEndQuery");

+	if(!_ptrc_glEndQuery) numFailed++;

+	_ptrc_glGenBuffers = (void (CODEGEN_FUNCPTR *)(GLsizei, GLuint *))IntGetProcAddress("glGenBuffers");

+	if(!_ptrc_glGenBuffers) numFailed++;

+	_ptrc_glGenQueries = (void (CODEGEN_FUNCPTR *)(GLsizei, GLuint *))IntGetProcAddress("glGenQueries");

+	if(!_ptrc_glGenQueries) numFailed++;

+	_ptrc_glGetBufferParameteriv = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLint *))IntGetProcAddress("glGetBufferParameteriv");

+	if(!_ptrc_glGetBufferParameteriv) numFailed++;

+	_ptrc_glGetBufferPointerv = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, void **))IntGetProcAddress("glGetBufferPointerv");

+	if(!_ptrc_glGetBufferPointerv) numFailed++;

+	_ptrc_glGetBufferSubData = (void (CODEGEN_FUNCPTR *)(GLenum, GLintptr, GLsizeiptr, void *))IntGetProcAddress("glGetBufferSubData");

+	if(!_ptrc_glGetBufferSubData) numFailed++;

+	_ptrc_glGetQueryObjectiv = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, GLint *))IntGetProcAddress("glGetQueryObjectiv");

+	if(!_ptrc_glGetQueryObjectiv) numFailed++;

+	_ptrc_glGetQueryObjectuiv = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, GLuint *))IntGetProcAddress("glGetQueryObjectuiv");

+	if(!_ptrc_glGetQueryObjectuiv) numFailed++;

+	_ptrc_glGetQueryiv = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLint *))IntGetProcAddress("glGetQueryiv");

+	if(!_ptrc_glGetQueryiv) numFailed++;

+	_ptrc_glIsBuffer = (GLboolean (CODEGEN_FUNCPTR *)(GLuint))IntGetProcAddress("glIsBuffer");

+	if(!_ptrc_glIsBuffer) numFailed++;

+	_ptrc_glIsQuery = (GLboolean (CODEGEN_FUNCPTR *)(GLuint))IntGetProcAddress("glIsQuery");

+	if(!_ptrc_glIsQuery) numFailed++;

+	_ptrc_glMapBuffer = (void * (CODEGEN_FUNCPTR *)(GLenum, GLenum))IntGetProcAddress("glMapBuffer");

+	if(!_ptrc_glMapBuffer) numFailed++;

+	_ptrc_glUnmapBuffer = (GLboolean (CODEGEN_FUNCPTR *)(GLenum))IntGetProcAddress("glUnmapBuffer");

+	if(!_ptrc_glUnmapBuffer) numFailed++;

+	_ptrc_glAttachShader = (void (CODEGEN_FUNCPTR *)(GLuint, GLuint))IntGetProcAddress("glAttachShader");

+	if(!_ptrc_glAttachShader) numFailed++;

+	_ptrc_glBindAttribLocation = (void (CODEGEN_FUNCPTR *)(GLuint, GLuint, const GLchar *))IntGetProcAddress("glBindAttribLocation");

+	if(!_ptrc_glBindAttribLocation) numFailed++;

+	_ptrc_glBlendEquationSeparate = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum))IntGetProcAddress("glBlendEquationSeparate");

+	if(!_ptrc_glBlendEquationSeparate) numFailed++;

+	_ptrc_glCompileShader = (void (CODEGEN_FUNCPTR *)(GLuint))IntGetProcAddress("glCompileShader");

+	if(!_ptrc_glCompileShader) numFailed++;

+	_ptrc_glCreateProgram = (GLuint (CODEGEN_FUNCPTR *)(void))IntGetProcAddress("glCreateProgram");

+	if(!_ptrc_glCreateProgram) numFailed++;

+	_ptrc_glCreateShader = (GLuint (CODEGEN_FUNCPTR *)(GLenum))IntGetProcAddress("glCreateShader");

+	if(!_ptrc_glCreateShader) numFailed++;

+	_ptrc_glDeleteProgram = (void (CODEGEN_FUNCPTR *)(GLuint))IntGetProcAddress("glDeleteProgram");

+	if(!_ptrc_glDeleteProgram) numFailed++;

+	_ptrc_glDeleteShader = (void (CODEGEN_FUNCPTR *)(GLuint))IntGetProcAddress("glDeleteShader");

+	if(!_ptrc_glDeleteShader) numFailed++;

+	_ptrc_glDetachShader = (void (CODEGEN_FUNCPTR *)(GLuint, GLuint))IntGetProcAddress("glDetachShader");

+	if(!_ptrc_glDetachShader) numFailed++;

+	_ptrc_glDisableVertexAttribArray = (void (CODEGEN_FUNCPTR *)(GLuint))IntGetProcAddress("glDisableVertexAttribArray");

+	if(!_ptrc_glDisableVertexAttribArray) numFailed++;

+	_ptrc_glDrawBuffers = (void (CODEGEN_FUNCPTR *)(GLsizei, const GLenum *))IntGetProcAddress("glDrawBuffers");

+	if(!_ptrc_glDrawBuffers) numFailed++;

+	_ptrc_glEnableVertexAttribArray = (void (CODEGEN_FUNCPTR *)(GLuint))IntGetProcAddress("glEnableVertexAttribArray");

+	if(!_ptrc_glEnableVertexAttribArray) numFailed++;

+	_ptrc_glGetActiveAttrib = (void (CODEGEN_FUNCPTR *)(GLuint, GLuint, GLsizei, GLsizei *, GLint *, GLenum *, GLchar *))IntGetProcAddress("glGetActiveAttrib");

+	if(!_ptrc_glGetActiveAttrib) numFailed++;

+	_ptrc_glGetActiveUniform = (void (CODEGEN_FUNCPTR *)(GLuint, GLuint, GLsizei, GLsizei *, GLint *, GLenum *, GLchar *))IntGetProcAddress("glGetActiveUniform");

+	if(!_ptrc_glGetActiveUniform) numFailed++;

+	_ptrc_glGetAttachedShaders = (void (CODEGEN_FUNCPTR *)(GLuint, GLsizei, GLsizei *, GLuint *))IntGetProcAddress("glGetAttachedShaders");

+	if(!_ptrc_glGetAttachedShaders) numFailed++;

+	_ptrc_glGetAttribLocation = (GLint (CODEGEN_FUNCPTR *)(GLuint, const GLchar *))IntGetProcAddress("glGetAttribLocation");

+	if(!_ptrc_glGetAttribLocation) numFailed++;

+	_ptrc_glGetProgramInfoLog = (void (CODEGEN_FUNCPTR *)(GLuint, GLsizei, GLsizei *, GLchar *))IntGetProcAddress("glGetProgramInfoLog");

+	if(!_ptrc_glGetProgramInfoLog) numFailed++;

+	_ptrc_glGetProgramiv = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, GLint *))IntGetProcAddress("glGetProgramiv");

+	if(!_ptrc_glGetProgramiv) numFailed++;

+	_ptrc_glGetShaderInfoLog = (void (CODEGEN_FUNCPTR *)(GLuint, GLsizei, GLsizei *, GLchar *))IntGetProcAddress("glGetShaderInfoLog");

+	if(!_ptrc_glGetShaderInfoLog) numFailed++;

+	_ptrc_glGetShaderSource = (void (CODEGEN_FUNCPTR *)(GLuint, GLsizei, GLsizei *, GLchar *))IntGetProcAddress("glGetShaderSource");

+	if(!_ptrc_glGetShaderSource) numFailed++;

+	_ptrc_glGetShaderiv = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, GLint *))IntGetProcAddress("glGetShaderiv");

+	if(!_ptrc_glGetShaderiv) numFailed++;

+	_ptrc_glGetUniformLocation = (GLint (CODEGEN_FUNCPTR *)(GLuint, const GLchar *))IntGetProcAddress("glGetUniformLocation");

+	if(!_ptrc_glGetUniformLocation) numFailed++;

+	_ptrc_glGetUniformfv = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLfloat *))IntGetProcAddress("glGetUniformfv");

+	if(!_ptrc_glGetUniformfv) numFailed++;

+	_ptrc_glGetUniformiv = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLint *))IntGetProcAddress("glGetUniformiv");

+	if(!_ptrc_glGetUniformiv) numFailed++;

+	_ptrc_glGetVertexAttribPointerv = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, void **))IntGetProcAddress("glGetVertexAttribPointerv");

+	if(!_ptrc_glGetVertexAttribPointerv) numFailed++;

+	_ptrc_glGetVertexAttribdv = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, GLdouble *))IntGetProcAddress("glGetVertexAttribdv");

+	if(!_ptrc_glGetVertexAttribdv) numFailed++;

+	_ptrc_glGetVertexAttribfv = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, GLfloat *))IntGetProcAddress("glGetVertexAttribfv");

+	if(!_ptrc_glGetVertexAttribfv) numFailed++;

+	_ptrc_glGetVertexAttribiv = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, GLint *))IntGetProcAddress("glGetVertexAttribiv");

+	if(!_ptrc_glGetVertexAttribiv) numFailed++;

+	_ptrc_glIsProgram = (GLboolean (CODEGEN_FUNCPTR *)(GLuint))IntGetProcAddress("glIsProgram");

+	if(!_ptrc_glIsProgram) numFailed++;

+	_ptrc_glIsShader = (GLboolean (CODEGEN_FUNCPTR *)(GLuint))IntGetProcAddress("glIsShader");

+	if(!_ptrc_glIsShader) numFailed++;

+	_ptrc_glLinkProgram = (void (CODEGEN_FUNCPTR *)(GLuint))IntGetProcAddress("glLinkProgram");

+	if(!_ptrc_glLinkProgram) numFailed++;

+	_ptrc_glShaderSource = (void (CODEGEN_FUNCPTR *)(GLuint, GLsizei, const GLchar *const*, const GLint *))IntGetProcAddress("glShaderSource");

+	if(!_ptrc_glShaderSource) numFailed++;

+	_ptrc_glStencilFuncSeparate = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLint, GLuint))IntGetProcAddress("glStencilFuncSeparate");

+	if(!_ptrc_glStencilFuncSeparate) numFailed++;

+	_ptrc_glStencilMaskSeparate = (void (CODEGEN_FUNCPTR *)(GLenum, GLuint))IntGetProcAddress("glStencilMaskSeparate");

+	if(!_ptrc_glStencilMaskSeparate) numFailed++;

+	_ptrc_glStencilOpSeparate = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLenum, GLenum))IntGetProcAddress("glStencilOpSeparate");

+	if(!_ptrc_glStencilOpSeparate) numFailed++;

+	_ptrc_glUniform1f = (void (CODEGEN_FUNCPTR *)(GLint, GLfloat))IntGetProcAddress("glUniform1f");

+	if(!_ptrc_glUniform1f) numFailed++;

+	_ptrc_glUniform1fv = (void (CODEGEN_FUNCPTR *)(GLint, GLsizei, const GLfloat *))IntGetProcAddress("glUniform1fv");

+	if(!_ptrc_glUniform1fv) numFailed++;

+	_ptrc_glUniform1i = (void (CODEGEN_FUNCPTR *)(GLint, GLint))IntGetProcAddress("glUniform1i");

+	if(!_ptrc_glUniform1i) numFailed++;

+	_ptrc_glUniform1iv = (void (CODEGEN_FUNCPTR *)(GLint, GLsizei, const GLint *))IntGetProcAddress("glUniform1iv");

+	if(!_ptrc_glUniform1iv) numFailed++;

+	_ptrc_glUniform2f = (void (CODEGEN_FUNCPTR *)(GLint, GLfloat, GLfloat))IntGetProcAddress("glUniform2f");

+	if(!_ptrc_glUniform2f) numFailed++;

+	_ptrc_glUniform2fv = (void (CODEGEN_FUNCPTR *)(GLint, GLsizei, const GLfloat *))IntGetProcAddress("glUniform2fv");

+	if(!_ptrc_glUniform2fv) numFailed++;

+	_ptrc_glUniform2i = (void (CODEGEN_FUNCPTR *)(GLint, GLint, GLint))IntGetProcAddress("glUniform2i");

+	if(!_ptrc_glUniform2i) numFailed++;

+	_ptrc_glUniform2iv = (void (CODEGEN_FUNCPTR *)(GLint, GLsizei, const GLint *))IntGetProcAddress("glUniform2iv");

+	if(!_ptrc_glUniform2iv) numFailed++;

+	_ptrc_glUniform3f = (void (CODEGEN_FUNCPTR *)(GLint, GLfloat, GLfloat, GLfloat))IntGetProcAddress("glUniform3f");

+	if(!_ptrc_glUniform3f) numFailed++;

+	_ptrc_glUniform3fv = (void (CODEGEN_FUNCPTR *)(GLint, GLsizei, const GLfloat *))IntGetProcAddress("glUniform3fv");

+	if(!_ptrc_glUniform3fv) numFailed++;

+	_ptrc_glUniform3i = (void (CODEGEN_FUNCPTR *)(GLint, GLint, GLint, GLint))IntGetProcAddress("glUniform3i");

+	if(!_ptrc_glUniform3i) numFailed++;

+	_ptrc_glUniform3iv = (void (CODEGEN_FUNCPTR *)(GLint, GLsizei, const GLint *))IntGetProcAddress("glUniform3iv");

+	if(!_ptrc_glUniform3iv) numFailed++;

+	_ptrc_glUniform4f = (void (CODEGEN_FUNCPTR *)(GLint, GLfloat, GLfloat, GLfloat, GLfloat))IntGetProcAddress("glUniform4f");

+	if(!_ptrc_glUniform4f) numFailed++;

+	_ptrc_glUniform4fv = (void (CODEGEN_FUNCPTR *)(GLint, GLsizei, const GLfloat *))IntGetProcAddress("glUniform4fv");

+	if(!_ptrc_glUniform4fv) numFailed++;

+	_ptrc_glUniform4i = (void (CODEGEN_FUNCPTR *)(GLint, GLint, GLint, GLint, GLint))IntGetProcAddress("glUniform4i");

+	if(!_ptrc_glUniform4i) numFailed++;

+	_ptrc_glUniform4iv = (void (CODEGEN_FUNCPTR *)(GLint, GLsizei, const GLint *))IntGetProcAddress("glUniform4iv");

+	if(!_ptrc_glUniform4iv) numFailed++;

+	_ptrc_glUniformMatrix2fv = (void (CODEGEN_FUNCPTR *)(GLint, GLsizei, GLboolean, const GLfloat *))IntGetProcAddress("glUniformMatrix2fv");

+	if(!_ptrc_glUniformMatrix2fv) numFailed++;

+	_ptrc_glUniformMatrix3fv = (void (CODEGEN_FUNCPTR *)(GLint, GLsizei, GLboolean, const GLfloat *))IntGetProcAddress("glUniformMatrix3fv");

+	if(!_ptrc_glUniformMatrix3fv) numFailed++;

+	_ptrc_glUniformMatrix4fv = (void (CODEGEN_FUNCPTR *)(GLint, GLsizei, GLboolean, const GLfloat *))IntGetProcAddress("glUniformMatrix4fv");

+	if(!_ptrc_glUniformMatrix4fv) numFailed++;

+	_ptrc_glUseProgram = (void (CODEGEN_FUNCPTR *)(GLuint))IntGetProcAddress("glUseProgram");

+	if(!_ptrc_glUseProgram) numFailed++;

+	_ptrc_glValidateProgram = (void (CODEGEN_FUNCPTR *)(GLuint))IntGetProcAddress("glValidateProgram");

+	if(!_ptrc_glValidateProgram) numFailed++;

+	_ptrc_glVertexAttrib1d = (void (CODEGEN_FUNCPTR *)(GLuint, GLdouble))IntGetProcAddress("glVertexAttrib1d");

+	if(!_ptrc_glVertexAttrib1d) numFailed++;

+	_ptrc_glVertexAttrib1dv = (void (CODEGEN_FUNCPTR *)(GLuint, const GLdouble *))IntGetProcAddress("glVertexAttrib1dv");

+	if(!_ptrc_glVertexAttrib1dv) numFailed++;

+	_ptrc_glVertexAttrib1f = (void (CODEGEN_FUNCPTR *)(GLuint, GLfloat))IntGetProcAddress("glVertexAttrib1f");

+	if(!_ptrc_glVertexAttrib1f) numFailed++;

+	_ptrc_glVertexAttrib1fv = (void (CODEGEN_FUNCPTR *)(GLuint, const GLfloat *))IntGetProcAddress("glVertexAttrib1fv");

+	if(!_ptrc_glVertexAttrib1fv) numFailed++;

+	_ptrc_glVertexAttrib1s = (void (CODEGEN_FUNCPTR *)(GLuint, GLshort))IntGetProcAddress("glVertexAttrib1s");

+	if(!_ptrc_glVertexAttrib1s) numFailed++;

+	_ptrc_glVertexAttrib1sv = (void (CODEGEN_FUNCPTR *)(GLuint, const GLshort *))IntGetProcAddress("glVertexAttrib1sv");

+	if(!_ptrc_glVertexAttrib1sv) numFailed++;

+	_ptrc_glVertexAttrib2d = (void (CODEGEN_FUNCPTR *)(GLuint, GLdouble, GLdouble))IntGetProcAddress("glVertexAttrib2d");

+	if(!_ptrc_glVertexAttrib2d) numFailed++;

+	_ptrc_glVertexAttrib2dv = (void (CODEGEN_FUNCPTR *)(GLuint, const GLdouble *))IntGetProcAddress("glVertexAttrib2dv");

+	if(!_ptrc_glVertexAttrib2dv) numFailed++;

+	_ptrc_glVertexAttrib2f = (void (CODEGEN_FUNCPTR *)(GLuint, GLfloat, GLfloat))IntGetProcAddress("glVertexAttrib2f");

+	if(!_ptrc_glVertexAttrib2f) numFailed++;

+	_ptrc_glVertexAttrib2fv = (void (CODEGEN_FUNCPTR *)(GLuint, const GLfloat *))IntGetProcAddress("glVertexAttrib2fv");

+	if(!_ptrc_glVertexAttrib2fv) numFailed++;

+	_ptrc_glVertexAttrib2s = (void (CODEGEN_FUNCPTR *)(GLuint, GLshort, GLshort))IntGetProcAddress("glVertexAttrib2s");

+	if(!_ptrc_glVertexAttrib2s) numFailed++;

+	_ptrc_glVertexAttrib2sv = (void (CODEGEN_FUNCPTR *)(GLuint, const GLshort *))IntGetProcAddress("glVertexAttrib2sv");

+	if(!_ptrc_glVertexAttrib2sv) numFailed++;

+	_ptrc_glVertexAttrib3d = (void (CODEGEN_FUNCPTR *)(GLuint, GLdouble, GLdouble, GLdouble))IntGetProcAddress("glVertexAttrib3d");

+	if(!_ptrc_glVertexAttrib3d) numFailed++;

+	_ptrc_glVertexAttrib3dv = (void (CODEGEN_FUNCPTR *)(GLuint, const GLdouble *))IntGetProcAddress("glVertexAttrib3dv");

+	if(!_ptrc_glVertexAttrib3dv) numFailed++;

+	_ptrc_glVertexAttrib3f = (void (CODEGEN_FUNCPTR *)(GLuint, GLfloat, GLfloat, GLfloat))IntGetProcAddress("glVertexAttrib3f");

+	if(!_ptrc_glVertexAttrib3f) numFailed++;

+	_ptrc_glVertexAttrib3fv = (void (CODEGEN_FUNCPTR *)(GLuint, const GLfloat *))IntGetProcAddress("glVertexAttrib3fv");

+	if(!_ptrc_glVertexAttrib3fv) numFailed++;

+	_ptrc_glVertexAttrib3s = (void (CODEGEN_FUNCPTR *)(GLuint, GLshort, GLshort, GLshort))IntGetProcAddress("glVertexAttrib3s");

+	if(!_ptrc_glVertexAttrib3s) numFailed++;

+	_ptrc_glVertexAttrib3sv = (void (CODEGEN_FUNCPTR *)(GLuint, const GLshort *))IntGetProcAddress("glVertexAttrib3sv");

+	if(!_ptrc_glVertexAttrib3sv) numFailed++;

+	_ptrc_glVertexAttrib4Nbv = (void (CODEGEN_FUNCPTR *)(GLuint, const GLbyte *))IntGetProcAddress("glVertexAttrib4Nbv");

+	if(!_ptrc_glVertexAttrib4Nbv) numFailed++;

+	_ptrc_glVertexAttrib4Niv = (void (CODEGEN_FUNCPTR *)(GLuint, const GLint *))IntGetProcAddress("glVertexAttrib4Niv");

+	if(!_ptrc_glVertexAttrib4Niv) numFailed++;

+	_ptrc_glVertexAttrib4Nsv = (void (CODEGEN_FUNCPTR *)(GLuint, const GLshort *))IntGetProcAddress("glVertexAttrib4Nsv");

+	if(!_ptrc_glVertexAttrib4Nsv) numFailed++;

+	_ptrc_glVertexAttrib4Nub = (void (CODEGEN_FUNCPTR *)(GLuint, GLubyte, GLubyte, GLubyte, GLubyte))IntGetProcAddress("glVertexAttrib4Nub");

+	if(!_ptrc_glVertexAttrib4Nub) numFailed++;

+	_ptrc_glVertexAttrib4Nubv = (void (CODEGEN_FUNCPTR *)(GLuint, const GLubyte *))IntGetProcAddress("glVertexAttrib4Nubv");

+	if(!_ptrc_glVertexAttrib4Nubv) numFailed++;

+	_ptrc_glVertexAttrib4Nuiv = (void (CODEGEN_FUNCPTR *)(GLuint, const GLuint *))IntGetProcAddress("glVertexAttrib4Nuiv");

+	if(!_ptrc_glVertexAttrib4Nuiv) numFailed++;

+	_ptrc_glVertexAttrib4Nusv = (void (CODEGEN_FUNCPTR *)(GLuint, const GLushort *))IntGetProcAddress("glVertexAttrib4Nusv");

+	if(!_ptrc_glVertexAttrib4Nusv) numFailed++;

+	_ptrc_glVertexAttrib4bv = (void (CODEGEN_FUNCPTR *)(GLuint, const GLbyte *))IntGetProcAddress("glVertexAttrib4bv");

+	if(!_ptrc_glVertexAttrib4bv) numFailed++;

+	_ptrc_glVertexAttrib4d = (void (CODEGEN_FUNCPTR *)(GLuint, GLdouble, GLdouble, GLdouble, GLdouble))IntGetProcAddress("glVertexAttrib4d");

+	if(!_ptrc_glVertexAttrib4d) numFailed++;

+	_ptrc_glVertexAttrib4dv = (void (CODEGEN_FUNCPTR *)(GLuint, const GLdouble *))IntGetProcAddress("glVertexAttrib4dv");

+	if(!_ptrc_glVertexAttrib4dv) numFailed++;

+	_ptrc_glVertexAttrib4f = (void (CODEGEN_FUNCPTR *)(GLuint, GLfloat, GLfloat, GLfloat, GLfloat))IntGetProcAddress("glVertexAttrib4f");

+	if(!_ptrc_glVertexAttrib4f) numFailed++;

+	_ptrc_glVertexAttrib4fv = (void (CODEGEN_FUNCPTR *)(GLuint, const GLfloat *))IntGetProcAddress("glVertexAttrib4fv");

+	if(!_ptrc_glVertexAttrib4fv) numFailed++;

+	_ptrc_glVertexAttrib4iv = (void (CODEGEN_FUNCPTR *)(GLuint, const GLint *))IntGetProcAddress("glVertexAttrib4iv");

+	if(!_ptrc_glVertexAttrib4iv) numFailed++;

+	_ptrc_glVertexAttrib4s = (void (CODEGEN_FUNCPTR *)(GLuint, GLshort, GLshort, GLshort, GLshort))IntGetProcAddress("glVertexAttrib4s");

+	if(!_ptrc_glVertexAttrib4s) numFailed++;

+	_ptrc_glVertexAttrib4sv = (void (CODEGEN_FUNCPTR *)(GLuint, const GLshort *))IntGetProcAddress("glVertexAttrib4sv");

+	if(!_ptrc_glVertexAttrib4sv) numFailed++;

+	_ptrc_glVertexAttrib4ubv = (void (CODEGEN_FUNCPTR *)(GLuint, const GLubyte *))IntGetProcAddress("glVertexAttrib4ubv");

+	if(!_ptrc_glVertexAttrib4ubv) numFailed++;

+	_ptrc_glVertexAttrib4uiv = (void (CODEGEN_FUNCPTR *)(GLuint, const GLuint *))IntGetProcAddress("glVertexAttrib4uiv");

+	if(!_ptrc_glVertexAttrib4uiv) numFailed++;

+	_ptrc_glVertexAttrib4usv = (void (CODEGEN_FUNCPTR *)(GLuint, const GLushort *))IntGetProcAddress("glVertexAttrib4usv");

+	if(!_ptrc_glVertexAttrib4usv) numFailed++;

+	_ptrc_glVertexAttribPointer = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLenum, GLboolean, GLsizei, const void *))IntGetProcAddress("glVertexAttribPointer");

+	if(!_ptrc_glVertexAttribPointer) numFailed++;

+	_ptrc_glUniformMatrix2x3fv = (void (CODEGEN_FUNCPTR *)(GLint, GLsizei, GLboolean, const GLfloat *))IntGetProcAddress("glUniformMatrix2x3fv");

+	if(!_ptrc_glUniformMatrix2x3fv) numFailed++;

+	_ptrc_glUniformMatrix2x4fv = (void (CODEGEN_FUNCPTR *)(GLint, GLsizei, GLboolean, const GLfloat *))IntGetProcAddress("glUniformMatrix2x4fv");

+	if(!_ptrc_glUniformMatrix2x4fv) numFailed++;

+	_ptrc_glUniformMatrix3x2fv = (void (CODEGEN_FUNCPTR *)(GLint, GLsizei, GLboolean, const GLfloat *))IntGetProcAddress("glUniformMatrix3x2fv");

+	if(!_ptrc_glUniformMatrix3x2fv) numFailed++;

+	_ptrc_glUniformMatrix3x4fv = (void (CODEGEN_FUNCPTR *)(GLint, GLsizei, GLboolean, const GLfloat *))IntGetProcAddress("glUniformMatrix3x4fv");

+	if(!_ptrc_glUniformMatrix3x4fv) numFailed++;

+	_ptrc_glUniformMatrix4x2fv = (void (CODEGEN_FUNCPTR *)(GLint, GLsizei, GLboolean, const GLfloat *))IntGetProcAddress("glUniformMatrix4x2fv");

+	if(!_ptrc_glUniformMatrix4x2fv) numFailed++;

+	_ptrc_glUniformMatrix4x3fv = (void (CODEGEN_FUNCPTR *)(GLint, GLsizei, GLboolean, const GLfloat *))IntGetProcAddress("glUniformMatrix4x3fv");

+	if(!_ptrc_glUniformMatrix4x3fv) numFailed++;

+	_ptrc_glBeginConditionalRender = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum))IntGetProcAddress("glBeginConditionalRender");

+	if(!_ptrc_glBeginConditionalRender) numFailed++;

+	_ptrc_glBeginTransformFeedback = (void (CODEGEN_FUNCPTR *)(GLenum))IntGetProcAddress("glBeginTransformFeedback");

+	if(!_ptrc_glBeginTransformFeedback) numFailed++;

+	_ptrc_glBindBufferBase = (void (CODEGEN_FUNCPTR *)(GLenum, GLuint, GLuint))IntGetProcAddress("glBindBufferBase");

+	if(!_ptrc_glBindBufferBase) numFailed++;

+	_ptrc_glBindBufferRange = (void (CODEGEN_FUNCPTR *)(GLenum, GLuint, GLuint, GLintptr, GLsizeiptr))IntGetProcAddress("glBindBufferRange");

+	if(!_ptrc_glBindBufferRange) numFailed++;

+	_ptrc_glBindFragDataLocation = (void (CODEGEN_FUNCPTR *)(GLuint, GLuint, const GLchar *))IntGetProcAddress("glBindFragDataLocation");

+	if(!_ptrc_glBindFragDataLocation) numFailed++;

+	_ptrc_glBindFramebuffer = (void (CODEGEN_FUNCPTR *)(GLenum, GLuint))IntGetProcAddress("glBindFramebuffer");

+	if(!_ptrc_glBindFramebuffer) numFailed++;

+	_ptrc_glBindRenderbuffer = (void (CODEGEN_FUNCPTR *)(GLenum, GLuint))IntGetProcAddress("glBindRenderbuffer");

+	if(!_ptrc_glBindRenderbuffer) numFailed++;

+	_ptrc_glBindVertexArray = (void (CODEGEN_FUNCPTR *)(GLuint))IntGetProcAddress("glBindVertexArray");

+	if(!_ptrc_glBindVertexArray) numFailed++;

+	_ptrc_glBlitFramebuffer = (void (CODEGEN_FUNCPTR *)(GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum))IntGetProcAddress("glBlitFramebuffer");

+	if(!_ptrc_glBlitFramebuffer) numFailed++;

+	_ptrc_glCheckFramebufferStatus = (GLenum (CODEGEN_FUNCPTR *)(GLenum))IntGetProcAddress("glCheckFramebufferStatus");

+	if(!_ptrc_glCheckFramebufferStatus) numFailed++;

+	_ptrc_glClampColor = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum))IntGetProcAddress("glClampColor");

+	if(!_ptrc_glClampColor) numFailed++;

+	_ptrc_glClearBufferfi = (void (CODEGEN_FUNCPTR *)(GLenum, GLint, GLfloat, GLint))IntGetProcAddress("glClearBufferfi");

+	if(!_ptrc_glClearBufferfi) numFailed++;

+	_ptrc_glClearBufferfv = (void (CODEGEN_FUNCPTR *)(GLenum, GLint, const GLfloat *))IntGetProcAddress("glClearBufferfv");

+	if(!_ptrc_glClearBufferfv) numFailed++;

+	_ptrc_glClearBufferiv = (void (CODEGEN_FUNCPTR *)(GLenum, GLint, const GLint *))IntGetProcAddress("glClearBufferiv");

+	if(!_ptrc_glClearBufferiv) numFailed++;

+	_ptrc_glClearBufferuiv = (void (CODEGEN_FUNCPTR *)(GLenum, GLint, const GLuint *))IntGetProcAddress("glClearBufferuiv");

+	if(!_ptrc_glClearBufferuiv) numFailed++;

+	_ptrc_glColorMaski = (void (CODEGEN_FUNCPTR *)(GLuint, GLboolean, GLboolean, GLboolean, GLboolean))IntGetProcAddress("glColorMaski");

+	if(!_ptrc_glColorMaski) numFailed++;

+	_ptrc_glDeleteFramebuffers = (void (CODEGEN_FUNCPTR *)(GLsizei, const GLuint *))IntGetProcAddress("glDeleteFramebuffers");

+	if(!_ptrc_glDeleteFramebuffers) numFailed++;

+	_ptrc_glDeleteRenderbuffers = (void (CODEGEN_FUNCPTR *)(GLsizei, const GLuint *))IntGetProcAddress("glDeleteRenderbuffers");

+	if(!_ptrc_glDeleteRenderbuffers) numFailed++;

+	_ptrc_glDeleteVertexArrays = (void (CODEGEN_FUNCPTR *)(GLsizei, const GLuint *))IntGetProcAddress("glDeleteVertexArrays");

+	if(!_ptrc_glDeleteVertexArrays) numFailed++;

+	_ptrc_glDisablei = (void (CODEGEN_FUNCPTR *)(GLenum, GLuint))IntGetProcAddress("glDisablei");

+	if(!_ptrc_glDisablei) numFailed++;

+	_ptrc_glEnablei = (void (CODEGEN_FUNCPTR *)(GLenum, GLuint))IntGetProcAddress("glEnablei");

+	if(!_ptrc_glEnablei) numFailed++;

+	_ptrc_glEndConditionalRender = (void (CODEGEN_FUNCPTR *)(void))IntGetProcAddress("glEndConditionalRender");

+	if(!_ptrc_glEndConditionalRender) numFailed++;

+	_ptrc_glEndTransformFeedback = (void (CODEGEN_FUNCPTR *)(void))IntGetProcAddress("glEndTransformFeedback");

+	if(!_ptrc_glEndTransformFeedback) numFailed++;

+	_ptrc_glFlushMappedBufferRange = (void (CODEGEN_FUNCPTR *)(GLenum, GLintptr, GLsizeiptr))IntGetProcAddress("glFlushMappedBufferRange");

+	if(!_ptrc_glFlushMappedBufferRange) numFailed++;

+	_ptrc_glFramebufferRenderbuffer = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLenum, GLuint))IntGetProcAddress("glFramebufferRenderbuffer");

+	if(!_ptrc_glFramebufferRenderbuffer) numFailed++;

+	_ptrc_glFramebufferTexture1D = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLenum, GLuint, GLint))IntGetProcAddress("glFramebufferTexture1D");

+	if(!_ptrc_glFramebufferTexture1D) numFailed++;

+	_ptrc_glFramebufferTexture2D = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLenum, GLuint, GLint))IntGetProcAddress("glFramebufferTexture2D");

+	if(!_ptrc_glFramebufferTexture2D) numFailed++;

+	_ptrc_glFramebufferTexture3D = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLenum, GLuint, GLint, GLint))IntGetProcAddress("glFramebufferTexture3D");

+	if(!_ptrc_glFramebufferTexture3D) numFailed++;

+	_ptrc_glFramebufferTextureLayer = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLuint, GLint, GLint))IntGetProcAddress("glFramebufferTextureLayer");

+	if(!_ptrc_glFramebufferTextureLayer) numFailed++;

+	_ptrc_glGenFramebuffers = (void (CODEGEN_FUNCPTR *)(GLsizei, GLuint *))IntGetProcAddress("glGenFramebuffers");

+	if(!_ptrc_glGenFramebuffers) numFailed++;

+	_ptrc_glGenRenderbuffers = (void (CODEGEN_FUNCPTR *)(GLsizei, GLuint *))IntGetProcAddress("glGenRenderbuffers");

+	if(!_ptrc_glGenRenderbuffers) numFailed++;

+	_ptrc_glGenVertexArrays = (void (CODEGEN_FUNCPTR *)(GLsizei, GLuint *))IntGetProcAddress("glGenVertexArrays");

+	if(!_ptrc_glGenVertexArrays) numFailed++;

+	_ptrc_glGenerateMipmap = (void (CODEGEN_FUNCPTR *)(GLenum))IntGetProcAddress("glGenerateMipmap");

+	if(!_ptrc_glGenerateMipmap) numFailed++;

+	_ptrc_glGetBooleani_v = (void (CODEGEN_FUNCPTR *)(GLenum, GLuint, GLboolean *))IntGetProcAddress("glGetBooleani_v");

+	if(!_ptrc_glGetBooleani_v) numFailed++;

+	_ptrc_glGetFragDataLocation = (GLint (CODEGEN_FUNCPTR *)(GLuint, const GLchar *))IntGetProcAddress("glGetFragDataLocation");

+	if(!_ptrc_glGetFragDataLocation) numFailed++;

+	_ptrc_glGetFramebufferAttachmentParameteriv = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLenum, GLint *))IntGetProcAddress("glGetFramebufferAttachmentParameteriv");

+	if(!_ptrc_glGetFramebufferAttachmentParameteriv) numFailed++;

+	_ptrc_glGetIntegeri_v = (void (CODEGEN_FUNCPTR *)(GLenum, GLuint, GLint *))IntGetProcAddress("glGetIntegeri_v");

+	if(!_ptrc_glGetIntegeri_v) numFailed++;

+	_ptrc_glGetRenderbufferParameteriv = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLint *))IntGetProcAddress("glGetRenderbufferParameteriv");

+	if(!_ptrc_glGetRenderbufferParameteriv) numFailed++;

+	_ptrc_glGetStringi = (const GLubyte * (CODEGEN_FUNCPTR *)(GLenum, GLuint))IntGetProcAddress("glGetStringi");

+	if(!_ptrc_glGetStringi) numFailed++;

+	_ptrc_glGetTexParameterIiv = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLint *))IntGetProcAddress("glGetTexParameterIiv");

+	if(!_ptrc_glGetTexParameterIiv) numFailed++;

+	_ptrc_glGetTexParameterIuiv = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLuint *))IntGetProcAddress("glGetTexParameterIuiv");

+	if(!_ptrc_glGetTexParameterIuiv) numFailed++;

+	_ptrc_glGetTransformFeedbackVarying = (void (CODEGEN_FUNCPTR *)(GLuint, GLuint, GLsizei, GLsizei *, GLsizei *, GLenum *, GLchar *))IntGetProcAddress("glGetTransformFeedbackVarying");

+	if(!_ptrc_glGetTransformFeedbackVarying) numFailed++;

+	_ptrc_glGetUniformuiv = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLuint *))IntGetProcAddress("glGetUniformuiv");

+	if(!_ptrc_glGetUniformuiv) numFailed++;

+	_ptrc_glGetVertexAttribIiv = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, GLint *))IntGetProcAddress("glGetVertexAttribIiv");

+	if(!_ptrc_glGetVertexAttribIiv) numFailed++;

+	_ptrc_glGetVertexAttribIuiv = (void (CODEGEN_FUNCPTR *)(GLuint, GLenum, GLuint *))IntGetProcAddress("glGetVertexAttribIuiv");

+	if(!_ptrc_glGetVertexAttribIuiv) numFailed++;

+	_ptrc_glIsEnabledi = (GLboolean (CODEGEN_FUNCPTR *)(GLenum, GLuint))IntGetProcAddress("glIsEnabledi");

+	if(!_ptrc_glIsEnabledi) numFailed++;

+	_ptrc_glIsFramebuffer = (GLboolean (CODEGEN_FUNCPTR *)(GLuint))IntGetProcAddress("glIsFramebuffer");

+	if(!_ptrc_glIsFramebuffer) numFailed++;

+	_ptrc_glIsRenderbuffer = (GLboolean (CODEGEN_FUNCPTR *)(GLuint))IntGetProcAddress("glIsRenderbuffer");

+	if(!_ptrc_glIsRenderbuffer) numFailed++;

+	_ptrc_glIsVertexArray = (GLboolean (CODEGEN_FUNCPTR *)(GLuint))IntGetProcAddress("glIsVertexArray");

+	if(!_ptrc_glIsVertexArray) numFailed++;

+	_ptrc_glMapBufferRange = (void * (CODEGEN_FUNCPTR *)(GLenum, GLintptr, GLsizeiptr, GLbitfield))IntGetProcAddress("glMapBufferRange");

+	if(!_ptrc_glMapBufferRange) numFailed++;

+	_ptrc_glRenderbufferStorage = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLsizei, GLsizei))IntGetProcAddress("glRenderbufferStorage");

+	if(!_ptrc_glRenderbufferStorage) numFailed++;

+	_ptrc_glRenderbufferStorageMultisample = (void (CODEGEN_FUNCPTR *)(GLenum, GLsizei, GLenum, GLsizei, GLsizei))IntGetProcAddress("glRenderbufferStorageMultisample");

+	if(!_ptrc_glRenderbufferStorageMultisample) numFailed++;

+	_ptrc_glTexParameterIiv = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, const GLint *))IntGetProcAddress("glTexParameterIiv");

+	if(!_ptrc_glTexParameterIiv) numFailed++;

+	_ptrc_glTexParameterIuiv = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, const GLuint *))IntGetProcAddress("glTexParameterIuiv");

+	if(!_ptrc_glTexParameterIuiv) numFailed++;

+	_ptrc_glTransformFeedbackVaryings = (void (CODEGEN_FUNCPTR *)(GLuint, GLsizei, const GLchar *const*, GLenum))IntGetProcAddress("glTransformFeedbackVaryings");

+	if(!_ptrc_glTransformFeedbackVaryings) numFailed++;

+	_ptrc_glUniform1ui = (void (CODEGEN_FUNCPTR *)(GLint, GLuint))IntGetProcAddress("glUniform1ui");

+	if(!_ptrc_glUniform1ui) numFailed++;

+	_ptrc_glUniform1uiv = (void (CODEGEN_FUNCPTR *)(GLint, GLsizei, const GLuint *))IntGetProcAddress("glUniform1uiv");

+	if(!_ptrc_glUniform1uiv) numFailed++;

+	_ptrc_glUniform2ui = (void (CODEGEN_FUNCPTR *)(GLint, GLuint, GLuint))IntGetProcAddress("glUniform2ui");

+	if(!_ptrc_glUniform2ui) numFailed++;

+	_ptrc_glUniform2uiv = (void (CODEGEN_FUNCPTR *)(GLint, GLsizei, const GLuint *))IntGetProcAddress("glUniform2uiv");

+	if(!_ptrc_glUniform2uiv) numFailed++;

+	_ptrc_glUniform3ui = (void (CODEGEN_FUNCPTR *)(GLint, GLuint, GLuint, GLuint))IntGetProcAddress("glUniform3ui");

+	if(!_ptrc_glUniform3ui) numFailed++;

+	_ptrc_glUniform3uiv = (void (CODEGEN_FUNCPTR *)(GLint, GLsizei, const GLuint *))IntGetProcAddress("glUniform3uiv");

+	if(!_ptrc_glUniform3uiv) numFailed++;

+	_ptrc_glUniform4ui = (void (CODEGEN_FUNCPTR *)(GLint, GLuint, GLuint, GLuint, GLuint))IntGetProcAddress("glUniform4ui");

+	if(!_ptrc_glUniform4ui) numFailed++;

+	_ptrc_glUniform4uiv = (void (CODEGEN_FUNCPTR *)(GLint, GLsizei, const GLuint *))IntGetProcAddress("glUniform4uiv");

+	if(!_ptrc_glUniform4uiv) numFailed++;

+	_ptrc_glVertexAttribI1i = (void (CODEGEN_FUNCPTR *)(GLuint, GLint))IntGetProcAddress("glVertexAttribI1i");

+	if(!_ptrc_glVertexAttribI1i) numFailed++;

+	_ptrc_glVertexAttribI1iv = (void (CODEGEN_FUNCPTR *)(GLuint, const GLint *))IntGetProcAddress("glVertexAttribI1iv");

+	if(!_ptrc_glVertexAttribI1iv) numFailed++;

+	_ptrc_glVertexAttribI1ui = (void (CODEGEN_FUNCPTR *)(GLuint, GLuint))IntGetProcAddress("glVertexAttribI1ui");

+	if(!_ptrc_glVertexAttribI1ui) numFailed++;

+	_ptrc_glVertexAttribI1uiv = (void (CODEGEN_FUNCPTR *)(GLuint, const GLuint *))IntGetProcAddress("glVertexAttribI1uiv");

+	if(!_ptrc_glVertexAttribI1uiv) numFailed++;

+	_ptrc_glVertexAttribI2i = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLint))IntGetProcAddress("glVertexAttribI2i");

+	if(!_ptrc_glVertexAttribI2i) numFailed++;

+	_ptrc_glVertexAttribI2iv = (void (CODEGEN_FUNCPTR *)(GLuint, const GLint *))IntGetProcAddress("glVertexAttribI2iv");

+	if(!_ptrc_glVertexAttribI2iv) numFailed++;

+	_ptrc_glVertexAttribI2ui = (void (CODEGEN_FUNCPTR *)(GLuint, GLuint, GLuint))IntGetProcAddress("glVertexAttribI2ui");

+	if(!_ptrc_glVertexAttribI2ui) numFailed++;

+	_ptrc_glVertexAttribI2uiv = (void (CODEGEN_FUNCPTR *)(GLuint, const GLuint *))IntGetProcAddress("glVertexAttribI2uiv");

+	if(!_ptrc_glVertexAttribI2uiv) numFailed++;

+	_ptrc_glVertexAttribI3i = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLint, GLint))IntGetProcAddress("glVertexAttribI3i");

+	if(!_ptrc_glVertexAttribI3i) numFailed++;

+	_ptrc_glVertexAttribI3iv = (void (CODEGEN_FUNCPTR *)(GLuint, const GLint *))IntGetProcAddress("glVertexAttribI3iv");

+	if(!_ptrc_glVertexAttribI3iv) numFailed++;

+	_ptrc_glVertexAttribI3ui = (void (CODEGEN_FUNCPTR *)(GLuint, GLuint, GLuint, GLuint))IntGetProcAddress("glVertexAttribI3ui");

+	if(!_ptrc_glVertexAttribI3ui) numFailed++;

+	_ptrc_glVertexAttribI3uiv = (void (CODEGEN_FUNCPTR *)(GLuint, const GLuint *))IntGetProcAddress("glVertexAttribI3uiv");

+	if(!_ptrc_glVertexAttribI3uiv) numFailed++;

+	_ptrc_glVertexAttribI4bv = (void (CODEGEN_FUNCPTR *)(GLuint, const GLbyte *))IntGetProcAddress("glVertexAttribI4bv");

+	if(!_ptrc_glVertexAttribI4bv) numFailed++;

+	_ptrc_glVertexAttribI4i = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLint, GLint, GLint))IntGetProcAddress("glVertexAttribI4i");

+	if(!_ptrc_glVertexAttribI4i) numFailed++;

+	_ptrc_glVertexAttribI4iv = (void (CODEGEN_FUNCPTR *)(GLuint, const GLint *))IntGetProcAddress("glVertexAttribI4iv");

+	if(!_ptrc_glVertexAttribI4iv) numFailed++;

+	_ptrc_glVertexAttribI4sv = (void (CODEGEN_FUNCPTR *)(GLuint, const GLshort *))IntGetProcAddress("glVertexAttribI4sv");

+	if(!_ptrc_glVertexAttribI4sv) numFailed++;

+	_ptrc_glVertexAttribI4ubv = (void (CODEGEN_FUNCPTR *)(GLuint, const GLubyte *))IntGetProcAddress("glVertexAttribI4ubv");

+	if(!_ptrc_glVertexAttribI4ubv) numFailed++;

+	_ptrc_glVertexAttribI4ui = (void (CODEGEN_FUNCPTR *)(GLuint, GLuint, GLuint, GLuint, GLuint))IntGetProcAddress("glVertexAttribI4ui");

+	if(!_ptrc_glVertexAttribI4ui) numFailed++;

+	_ptrc_glVertexAttribI4uiv = (void (CODEGEN_FUNCPTR *)(GLuint, const GLuint *))IntGetProcAddress("glVertexAttribI4uiv");

+	if(!_ptrc_glVertexAttribI4uiv) numFailed++;

+	_ptrc_glVertexAttribI4usv = (void (CODEGEN_FUNCPTR *)(GLuint, const GLushort *))IntGetProcAddress("glVertexAttribI4usv");

+	if(!_ptrc_glVertexAttribI4usv) numFailed++;

+	_ptrc_glVertexAttribIPointer = (void (CODEGEN_FUNCPTR *)(GLuint, GLint, GLenum, GLsizei, const void *))IntGetProcAddress("glVertexAttribIPointer");

+	if(!_ptrc_glVertexAttribIPointer) numFailed++;

+	_ptrc_glCopyBufferSubData = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLintptr, GLintptr, GLsizeiptr))IntGetProcAddress("glCopyBufferSubData");

+	if(!_ptrc_glCopyBufferSubData) numFailed++;

+	_ptrc_glDrawArraysInstanced = (void (CODEGEN_FUNCPTR *)(GLenum, GLint, GLsizei, GLsizei))IntGetProcAddress("glDrawArraysInstanced");

+	if(!_ptrc_glDrawArraysInstanced) numFailed++;

+	_ptrc_glDrawElementsInstanced = (void (CODEGEN_FUNCPTR *)(GLenum, GLsizei, GLenum, const void *, GLsizei))IntGetProcAddress("glDrawElementsInstanced");

+	if(!_ptrc_glDrawElementsInstanced) numFailed++;

+	_ptrc_glGetActiveUniformBlockName = (void (CODEGEN_FUNCPTR *)(GLuint, GLuint, GLsizei, GLsizei *, GLchar *))IntGetProcAddress("glGetActiveUniformBlockName");

+	if(!_ptrc_glGetActiveUniformBlockName) numFailed++;

+	_ptrc_glGetActiveUniformBlockiv = (void (CODEGEN_FUNCPTR *)(GLuint, GLuint, GLenum, GLint *))IntGetProcAddress("glGetActiveUniformBlockiv");

+	if(!_ptrc_glGetActiveUniformBlockiv) numFailed++;

+	_ptrc_glGetActiveUniformName = (void (CODEGEN_FUNCPTR *)(GLuint, GLuint, GLsizei, GLsizei *, GLchar *))IntGetProcAddress("glGetActiveUniformName");

+	if(!_ptrc_glGetActiveUniformName) numFailed++;

+	_ptrc_glGetActiveUniformsiv = (void (CODEGEN_FUNCPTR *)(GLuint, GLsizei, const GLuint *, GLenum, GLint *))IntGetProcAddress("glGetActiveUniformsiv");

+	if(!_ptrc_glGetActiveUniformsiv) numFailed++;

+	_ptrc_glGetUniformBlockIndex = (GLuint (CODEGEN_FUNCPTR *)(GLuint, const GLchar *))IntGetProcAddress("glGetUniformBlockIndex");

+	if(!_ptrc_glGetUniformBlockIndex) numFailed++;

+	_ptrc_glGetUniformIndices = (void (CODEGEN_FUNCPTR *)(GLuint, GLsizei, const GLchar *const*, GLuint *))IntGetProcAddress("glGetUniformIndices");

+	if(!_ptrc_glGetUniformIndices) numFailed++;

+	_ptrc_glPrimitiveRestartIndex = (void (CODEGEN_FUNCPTR *)(GLuint))IntGetProcAddress("glPrimitiveRestartIndex");

+	if(!_ptrc_glPrimitiveRestartIndex) numFailed++;

+	_ptrc_glTexBuffer = (void (CODEGEN_FUNCPTR *)(GLenum, GLenum, GLuint))IntGetProcAddress("glTexBuffer");

+	if(!_ptrc_glTexBuffer) numFailed++;

+	_ptrc_glUniformBlockBinding = (void (CODEGEN_FUNCPTR *)(GLuint, GLuint, GLuint))IntGetProcAddress("glUniformBlockBinding");

+	if(!_ptrc_glUniformBlockBinding) numFailed++;

+	return numFailed;

+}

+

+typedef int (*PFN_LOADFUNCPOINTERS)(void);

+typedef struct ogl_StrToExtMap_s

+{

+	char *extensionName;

+	int *extensionVariable;

+	PFN_LOADFUNCPOINTERS LoadExtension;

+} ogl_StrToExtMap;

+

+static ogl_StrToExtMap ExtensionMap[52] = {

+	{"GL_ARB_compressed_texture_pixel_storage", &ogl_ext_ARB_compressed_texture_pixel_storage, NULL},

+	{"GL_ARB_conservative_depth", &ogl_ext_ARB_conservative_depth, NULL},

+	{"GL_ARB_ES2_compatibility", &ogl_ext_ARB_ES2_compatibility, Load_ARB_ES2_compatibility},

+	{"GL_ARB_get_program_binary", &ogl_ext_ARB_get_program_binary, Load_ARB_get_program_binary},

+	{"GL_ARB_explicit_uniform_location", &ogl_ext_ARB_explicit_uniform_location, NULL},

+	{"GL_ARB_internalformat_query", &ogl_ext_ARB_internalformat_query, Load_ARB_internalformat_query},

+	{"GL_ARB_internalformat_query2", &ogl_ext_ARB_internalformat_query2, Load_ARB_internalformat_query2},

+	{"GL_ARB_map_buffer_alignment", &ogl_ext_ARB_map_buffer_alignment, NULL},

+	{"GL_ARB_program_interface_query", &ogl_ext_ARB_program_interface_query, Load_ARB_program_interface_query},

+	{"GL_ARB_separate_shader_objects", &ogl_ext_ARB_separate_shader_objects, Load_ARB_separate_shader_objects},

+	{"GL_ARB_shading_language_420pack", &ogl_ext_ARB_shading_language_420pack, NULL},

+	{"GL_ARB_shading_language_packing", &ogl_ext_ARB_shading_language_packing, NULL},

+	{"GL_ARB_texture_buffer_range", &ogl_ext_ARB_texture_buffer_range, Load_ARB_texture_buffer_range},

+	{"GL_ARB_texture_storage", &ogl_ext_ARB_texture_storage, Load_ARB_texture_storage},

+	{"GL_ARB_texture_view", &ogl_ext_ARB_texture_view, Load_ARB_texture_view},

+	{"GL_ARB_vertex_attrib_binding", &ogl_ext_ARB_vertex_attrib_binding, Load_ARB_vertex_attrib_binding},

+	{"GL_ARB_viewport_array", &ogl_ext_ARB_viewport_array, Load_ARB_viewport_array},

+	{"GL_ARB_arrays_of_arrays", &ogl_ext_ARB_arrays_of_arrays, NULL},

+	{"GL_ARB_clear_buffer_object", &ogl_ext_ARB_clear_buffer_object, Load_ARB_clear_buffer_object},

+	{"GL_ARB_copy_image", &ogl_ext_ARB_copy_image, Load_ARB_copy_image},

+	{"GL_ARB_ES3_compatibility", &ogl_ext_ARB_ES3_compatibility, NULL},

+	{"GL_ARB_fragment_layer_viewport", &ogl_ext_ARB_fragment_layer_viewport, NULL},

+	{"GL_ARB_framebuffer_no_attachments", &ogl_ext_ARB_framebuffer_no_attachments, Load_ARB_framebuffer_no_attachments},

+	{"GL_ARB_invalidate_subdata", &ogl_ext_ARB_invalidate_subdata, Load_ARB_invalidate_subdata},

+	{"GL_ARB_robust_buffer_access_behavior", &ogl_ext_ARB_robust_buffer_access_behavior, NULL},

+	{"GL_ARB_stencil_texturing", &ogl_ext_ARB_stencil_texturing, NULL},

+	{"GL_ARB_texture_query_levels", &ogl_ext_ARB_texture_query_levels, NULL},

+	{"GL_ARB_texture_storage_multisample", &ogl_ext_ARB_texture_storage_multisample, Load_ARB_texture_storage_multisample},

+	{"GL_KHR_debug", &ogl_ext_KHR_debug, Load_KHR_debug},

+	{"GL_ARB_buffer_storage", &ogl_ext_ARB_buffer_storage, Load_ARB_buffer_storage},

+	{"GL_ARB_clear_texture", &ogl_ext_ARB_clear_texture, Load_ARB_clear_texture},

+	{"GL_ARB_enhanced_layouts", &ogl_ext_ARB_enhanced_layouts, NULL},

+	{"GL_ARB_multi_bind", &ogl_ext_ARB_multi_bind, Load_ARB_multi_bind},

+	{"GL_ARB_query_buffer_object", &ogl_ext_ARB_query_buffer_object, NULL},

+	{"GL_ARB_texture_mirror_clamp_to_edge", &ogl_ext_ARB_texture_mirror_clamp_to_edge, NULL},

+	{"GL_ARB_texture_stencil8", &ogl_ext_ARB_texture_stencil8, NULL},

+	{"GL_ARB_vertex_type_10f_11f_11f_rev", &ogl_ext_ARB_vertex_type_10f_11f_11f_rev, NULL},

+	{"GL_ARB_seamless_cubemap_per_texture", &ogl_ext_ARB_seamless_cubemap_per_texture, NULL},

+	{"GL_ARB_clip_control", &ogl_ext_ARB_clip_control, Load_ARB_clip_control},

+	{"GL_ARB_conditional_render_inverted", &ogl_ext_ARB_conditional_render_inverted, NULL},

+	{"GL_ARB_cull_distance", &ogl_ext_ARB_cull_distance, NULL},

+	{"GL_ARB_derivative_control", &ogl_ext_ARB_derivative_control, NULL},

+	{"GL_ARB_direct_state_access", &ogl_ext_ARB_direct_state_access, Load_ARB_direct_state_access},

+	{"GL_ARB_get_texture_sub_image", &ogl_ext_ARB_get_texture_sub_image, Load_ARB_get_texture_sub_image},

+	{"GL_ARB_shader_texture_image_samples", &ogl_ext_ARB_shader_texture_image_samples, NULL},

+	{"GL_ARB_texture_barrier", &ogl_ext_ARB_texture_barrier, Load_ARB_texture_barrier},

+	{"GL_KHR_context_flush_control", &ogl_ext_KHR_context_flush_control, NULL},

+	{"GL_KHR_robust_buffer_access_behavior", &ogl_ext_KHR_robust_buffer_access_behavior, NULL},

+	{"GL_KHR_robustness", &ogl_ext_KHR_robustness, Load_KHR_robustness},

+	{"GL_EXT_texture_compression_s3tc", &ogl_ext_EXT_texture_compression_s3tc, NULL},

+	{"GL_EXT_texture_sRGB", &ogl_ext_EXT_texture_sRGB, NULL},

+	{"GL_EXT_texture_filter_anisotropic", &ogl_ext_EXT_texture_filter_anisotropic, NULL},

+};

+

+static int g_extensionMapSize = 52;

+

+static ogl_StrToExtMap *FindExtEntry(const char *extensionName)

+{

+	int loop;

+	ogl_StrToExtMap *currLoc = ExtensionMap;

+	for(loop = 0; loop < g_extensionMapSize; ++loop, ++currLoc)

+	{

+		if(strcmp(extensionName, currLoc->extensionName) == 0)

+			return currLoc;

+	}

+	

+	return NULL;

+}

+

+static void ClearExtensionVars(void)

+{

+	ogl_ext_ARB_compressed_texture_pixel_storage = ogl_LOAD_FAILED;

+	ogl_ext_ARB_conservative_depth = ogl_LOAD_FAILED;

+	ogl_ext_ARB_ES2_compatibility = ogl_LOAD_FAILED;

+	ogl_ext_ARB_get_program_binary = ogl_LOAD_FAILED;

+	ogl_ext_ARB_explicit_uniform_location = ogl_LOAD_FAILED;

+	ogl_ext_ARB_internalformat_query = ogl_LOAD_FAILED;

+	ogl_ext_ARB_internalformat_query2 = ogl_LOAD_FAILED;

+	ogl_ext_ARB_map_buffer_alignment = ogl_LOAD_FAILED;

+	ogl_ext_ARB_program_interface_query = ogl_LOAD_FAILED;

+	ogl_ext_ARB_separate_shader_objects = ogl_LOAD_FAILED;

+	ogl_ext_ARB_shading_language_420pack = ogl_LOAD_FAILED;

+	ogl_ext_ARB_shading_language_packing = ogl_LOAD_FAILED;

+	ogl_ext_ARB_texture_buffer_range = ogl_LOAD_FAILED;

+	ogl_ext_ARB_texture_storage = ogl_LOAD_FAILED;

+	ogl_ext_ARB_texture_view = ogl_LOAD_FAILED;

+	ogl_ext_ARB_vertex_attrib_binding = ogl_LOAD_FAILED;

+	ogl_ext_ARB_viewport_array = ogl_LOAD_FAILED;

+	ogl_ext_ARB_arrays_of_arrays = ogl_LOAD_FAILED;

+	ogl_ext_ARB_clear_buffer_object = ogl_LOAD_FAILED;

+	ogl_ext_ARB_copy_image = ogl_LOAD_FAILED;

+	ogl_ext_ARB_ES3_compatibility = ogl_LOAD_FAILED;

+	ogl_ext_ARB_fragment_layer_viewport = ogl_LOAD_FAILED;

+	ogl_ext_ARB_framebuffer_no_attachments = ogl_LOAD_FAILED;

+	ogl_ext_ARB_invalidate_subdata = ogl_LOAD_FAILED;

+	ogl_ext_ARB_robust_buffer_access_behavior = ogl_LOAD_FAILED;

+	ogl_ext_ARB_stencil_texturing = ogl_LOAD_FAILED;

+	ogl_ext_ARB_texture_query_levels = ogl_LOAD_FAILED;

+	ogl_ext_ARB_texture_storage_multisample = ogl_LOAD_FAILED;

+	ogl_ext_KHR_debug = ogl_LOAD_FAILED;

+	ogl_ext_ARB_buffer_storage = ogl_LOAD_FAILED;

+	ogl_ext_ARB_clear_texture = ogl_LOAD_FAILED;

+	ogl_ext_ARB_enhanced_layouts = ogl_LOAD_FAILED;

+	ogl_ext_ARB_multi_bind = ogl_LOAD_FAILED;

+	ogl_ext_ARB_query_buffer_object = ogl_LOAD_FAILED;

+	ogl_ext_ARB_texture_mirror_clamp_to_edge = ogl_LOAD_FAILED;

+	ogl_ext_ARB_texture_stencil8 = ogl_LOAD_FAILED;

+	ogl_ext_ARB_vertex_type_10f_11f_11f_rev = ogl_LOAD_FAILED;

+	ogl_ext_ARB_seamless_cubemap_per_texture = ogl_LOAD_FAILED;

+	ogl_ext_ARB_clip_control = ogl_LOAD_FAILED;

+	ogl_ext_ARB_conditional_render_inverted = ogl_LOAD_FAILED;

+	ogl_ext_ARB_cull_distance = ogl_LOAD_FAILED;

+	ogl_ext_ARB_derivative_control = ogl_LOAD_FAILED;

+	ogl_ext_ARB_direct_state_access = ogl_LOAD_FAILED;

+	ogl_ext_ARB_get_texture_sub_image = ogl_LOAD_FAILED;

+	ogl_ext_ARB_shader_texture_image_samples = ogl_LOAD_FAILED;

+	ogl_ext_ARB_texture_barrier = ogl_LOAD_FAILED;

+	ogl_ext_KHR_context_flush_control = ogl_LOAD_FAILED;

+	ogl_ext_KHR_robust_buffer_access_behavior = ogl_LOAD_FAILED;

+	ogl_ext_KHR_robustness = ogl_LOAD_FAILED;

+	ogl_ext_EXT_texture_compression_s3tc = ogl_LOAD_FAILED;

+	ogl_ext_EXT_texture_sRGB = ogl_LOAD_FAILED;

+	ogl_ext_EXT_texture_filter_anisotropic = ogl_LOAD_FAILED;

+}

+

+static void LoadExtByName(const char *extensionName)

+{

+	ogl_StrToExtMap *entry = NULL;

+	entry = FindExtEntry(extensionName);

+	if(entry)

+	{

+		if(entry->LoadExtension)

+		{

+			int numFailed = entry->LoadExtension();

+			if(numFailed == 0)

+			{

+				*(entry->extensionVariable) = ogl_LOAD_SUCCEEDED;

+			}

+			else

+			{

+				*(entry->extensionVariable) = ogl_LOAD_SUCCEEDED + numFailed;

+			}

+		}

+		else

+		{

+			*(entry->extensionVariable) = ogl_LOAD_SUCCEEDED;

+		}

+	}

+}

+

+static void ProcExtsFromExtString(const char *strExtList)

+{

+	size_t iExtListLen = strlen(strExtList);

+	const char *strExtListEnd = strExtList + iExtListLen;

+	const char *strCurrPos = strExtList;

+	char strWorkBuff[256];

+

+	while(*strCurrPos)

+	{

+		/*Get the extension at our position.*/

+		int iStrLen = 0;

+		const char *strEndStr = strchr(strCurrPos, ' ');

+		int iStop = 0;

+		if(strEndStr == NULL)

+		{

+			strEndStr = strExtListEnd;

+			iStop = 1;

+		}

+

+		iStrLen = (int)((ptrdiff_t)strEndStr - (ptrdiff_t)strCurrPos);

+

+		if(iStrLen > 255)

+			return;

+

+		strncpy(strWorkBuff, strCurrPos, iStrLen);

+		strWorkBuff[iStrLen] = '\0';

+

+		LoadExtByName(strWorkBuff);

+

+		strCurrPos = strEndStr + 1;

+		if(iStop) break;

+	}

+}

+

+static void ProcExtsFromExtList(void)

+{

+	GLint iLoop;

+	GLint iNumExtensions = 0;

+	_ptrc_glGetIntegerv(GL_NUM_EXTENSIONS, &iNumExtensions);

+

+	for(iLoop = 0; iLoop < iNumExtensions; iLoop++)

+	{

+		const char *strExtensionName = (const char *)_ptrc_glGetStringi(GL_EXTENSIONS, iLoop);

+		LoadExtByName(strExtensionName);

+	}

+}

+

+int ogl_LoadFunctions()

+{

+	int numFailed = 0;

+	ClearExtensionVars();

+	_ptrc_glGetString = (const GLubyte * (CODEGEN_FUNCPTR *)(GLenum))IntGetProcAddress("glGetString");

+	if(!_ptrc_glGetString) return ogl_LOAD_FAILED;

+	

+	if (ogl_GetMajorVersion() < 3)

+	{

+		ProcExtsFromExtString((const char *)_ptrc_glGetString(GL_EXTENSIONS));

+	}

+	else

+	{

+		_ptrc_glGetIntegerv = (void (CODEGEN_FUNCPTR *)(GLenum, GLint *))IntGetProcAddress("glGetIntegerv");

+		if(!_ptrc_glGetIntegerv) return ogl_LOAD_FAILED;

+		_ptrc_glGetStringi = (const GLubyte * (CODEGEN_FUNCPTR *)(GLenum, GLuint))IntGetProcAddress("glGetStringi");

+		if(!_ptrc_glGetStringi) return ogl_LOAD_FAILED;

+		ProcExtsFromExtList();

+	}

+

+	numFailed = Load_Version_3_1();

+	

+	if(numFailed == 0)

+		return ogl_LOAD_SUCCEEDED;

+	else

+		return ogl_LOAD_SUCCEEDED + numFailed;

+}

+

+static int g_major_version = 0;

+static int g_minor_version = 0;

+

+static void ParseVersionFromString(int *pOutMajor, int *pOutMinor, const char *strVersion)

+{

+	const char *strDotPos = NULL;

+	*pOutMinor = 0;

+	*pOutMajor = 0;

+

+	strDotPos = strchr(strVersion, '.');

+	if(!strDotPos)

+		return;

+

+	*pOutMajor = atoi(strVersion);

+	*pOutMinor = atoi(strDotPos + 1);

+}

+

+static void GetGLVersion(void)

+{

+	ParseVersionFromString(&g_major_version, &g_minor_version, (const char*)glGetString(GL_VERSION));

+}

+

+int ogl_GetMajorVersion(void)

+{

+	if(g_major_version == 0)

+		GetGLVersion();

+	return g_major_version;

+}

+

+int ogl_GetMinorVersion(void)

+{

+	if(g_major_version == 0) /*Yes, check the major version to get the minor one.*/

+		GetGLVersion();

+	return g_minor_version;

+}

+

+int ogl_IsVersionGEQ(int majorVersion, int minorVersion)

+{

+	if(g_major_version == 0)

+		GetGLVersion();

+

+	if(majorVersion < g_major_version) return 1;

+	if(majorVersion > g_major_version) return 0;

+	if(minorVersion <= g_minor_version) return 1;

+	return 0;

+}

--- /dev/null

+++ b/third_party/gl_core/gl_core_3_1.h

@@ -1,0 +1,3718 @@

+#ifndef POINTER_C_GENERATED_HEADER_OPENGL_H

+#define POINTER_C_GENERATED_HEADER_OPENGL_H

+

+#if defined(__glew_h__) || defined(__GLEW_H__)

+#error Attempt to include auto-generated header after including glew.h

+#endif

+#if defined(__gl_h_) || defined(__GL_H__)

+#error Attempt to include auto-generated header after including gl.h

+#endif

+#if defined(__glext_h_) || defined(__GLEXT_H_)

+#error Attempt to include auto-generated header after including glext.h

+#endif

+#if defined(__gltypes_h_)

+#error Attempt to include auto-generated header after gltypes.h

+#endif

+#if defined(__gl_ATI_h_)

+#error Attempt to include auto-generated header after including glATI.h

+#endif

+

+#define __glew_h__

+#define __GLEW_H__

+#define __gl_h_

+#define __GL_H__

+#define __glext_h_

+#define __GLEXT_H_

+#define __gltypes_h_

+#define __gl_ATI_h_

+

+#ifndef APIENTRY

+	#if defined(__MINGW32__)

+		#ifndef WIN32_LEAN_AND_MEAN

+			#define WIN32_LEAN_AND_MEAN 1

+		#endif

+		#ifndef NOMINMAX

+			#define NOMINMAX

+		#endif

+		#include <windows.h>

+	#elif (_MSC_VER >= 800) || defined(_STDCALL_SUPPORTED) || defined(__BORLANDC__)

+		#ifndef WIN32_LEAN_AND_MEAN

+			#define WIN32_LEAN_AND_MEAN 1

+		#endif

+		#ifndef NOMINMAX

+			#define NOMINMAX

+		#endif

+		#include <windows.h>

+	#else

+		#define APIENTRY

+	#endif

+#endif /*APIENTRY*/

+

+#ifndef CODEGEN_FUNCPTR

+	#define CODEGEN_REMOVE_FUNCPTR

+	#if defined(_WIN32)

+		#define CODEGEN_FUNCPTR APIENTRY

+	#else

+		#define CODEGEN_FUNCPTR

+	#endif

+#endif /*CODEGEN_FUNCPTR*/

+

+#ifndef GLAPI

+	#define GLAPI extern

+#endif

+

+

+#ifndef GL_LOAD_GEN_BASIC_OPENGL_TYPEDEFS

+#define GL_LOAD_GEN_BASIC_OPENGL_TYPEDEFS

+

+

+#endif /*GL_LOAD_GEN_BASIC_OPENGL_TYPEDEFS*/

+

+

+#include <stddef.h>

+#ifndef GLEXT_64_TYPES_DEFINED

+/* This code block is duplicated in glxext.h, so must be protected */

+#define GLEXT_64_TYPES_DEFINED

+/* Define int32_t, int64_t, and uint64_t types for UST/MSC */

+/* (as used in the GL_EXT_timer_query extension). */

+#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L

+#include <inttypes.h>

+#elif defined(__sun__) || defined(__digital__)

+#include <inttypes.h>

+#if defined(__STDC__)

+#if defined(__arch64__) || defined(_LP64)

+typedef long int int64_t;

+typedef unsigned long int uint64_t;

+#else

+typedef long long int int64_t;

+typedef unsigned long long int uint64_t;

+#endif /* __arch64__ */

+#endif /* __STDC__ */

+#elif defined( __VMS ) || defined(__sgi)

+#include <inttypes.h>

+#elif defined(__SCO__) || defined(__USLC__)

+#include <stdint.h>

+#elif defined(__UNIXOS2__) || defined(__SOL64__)

+typedef long int int32_t;

+typedef long long int int64_t;

+typedef unsigned long long int uint64_t;

+#elif defined(_WIN32) && defined(__GNUC__)

+#include <stdint.h>

+#elif defined(_WIN32)

+typedef __int32 int32_t;

+typedef __int64 int64_t;

+typedef unsigned __int64 uint64_t;

+#else

+/* Fallback if nothing above works */

+#include <inttypes.h>

+#endif

+#endif

+	typedef unsigned int GLenum;

+	typedef unsigned char GLboolean;

+	typedef unsigned int GLbitfield;

+	typedef void GLvoid;

+	typedef signed char GLbyte;

+	typedef short GLshort;

+	typedef int GLint;

+	typedef unsigned char GLubyte;

+	typedef unsigned short GLushort;

+	typedef unsigned int GLuint;

+	typedef int GLsizei;

+	typedef float GLfloat;

+	typedef float GLclampf;

+	typedef double GLdouble;

+	typedef double GLclampd;

+	typedef char GLchar;

+	typedef char GLcharARB;

+	#ifdef __APPLE__

+typedef void *GLhandleARB;

+#else

+typedef unsigned int GLhandleARB;

+#endif

+		typedef unsigned short GLhalfARB;

+		typedef unsigned short GLhalf;

+		typedef GLint GLfixed;

+		typedef ptrdiff_t GLintptr;

+		typedef ptrdiff_t GLsizeiptr;

+		typedef int64_t GLint64;

+		typedef uint64_t GLuint64;

+		typedef ptrdiff_t GLintptrARB;

+		typedef ptrdiff_t GLsizeiptrARB;

+		typedef int64_t GLint64EXT;

+		typedef uint64_t GLuint64EXT;

+		typedef struct __GLsync *GLsync;

+		struct _cl_context;

+		struct _cl_event;

+		typedef void (APIENTRY *GLDEBUGPROC)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam);

+		typedef void (APIENTRY *GLDEBUGPROCARB)(GLenum source,GLenum type,GLuint id,GLenum severity,GLsizei length,const GLchar *message,const void *userParam);

+		typedef void (APIENTRY *GLDEBUGPROCAMD)(GLuint id,GLenum category,GLenum severity,GLsizei length,const GLchar *message,void *userParam);

+		typedef unsigned short GLhalfNV;

+		typedef GLintptr GLvdpauSurfaceNV;

+

+#ifdef __cplusplus

+extern "C" {

+#endif /*__cplusplus*/

+

+extern int ogl_ext_ARB_compressed_texture_pixel_storage;

+extern int ogl_ext_ARB_conservative_depth;

+extern int ogl_ext_ARB_ES2_compatibility;

+extern int ogl_ext_ARB_get_program_binary;

+extern int ogl_ext_ARB_explicit_uniform_location;

+extern int ogl_ext_ARB_internalformat_query;

+extern int ogl_ext_ARB_internalformat_query2;

+extern int ogl_ext_ARB_map_buffer_alignment;

+extern int ogl_ext_ARB_program_interface_query;

+extern int ogl_ext_ARB_separate_shader_objects;

+extern int ogl_ext_ARB_shading_language_420pack;

+extern int ogl_ext_ARB_shading_language_packing;

+extern int ogl_ext_ARB_texture_buffer_range;

+extern int ogl_ext_ARB_texture_storage;

+extern int ogl_ext_ARB_texture_view;

+extern int ogl_ext_ARB_vertex_attrib_binding;

+extern int ogl_ext_ARB_viewport_array;

+extern int ogl_ext_ARB_arrays_of_arrays;

+extern int ogl_ext_ARB_clear_buffer_object;

+extern int ogl_ext_ARB_copy_image;

+extern int ogl_ext_ARB_ES3_compatibility;

+extern int ogl_ext_ARB_fragment_layer_viewport;

+extern int ogl_ext_ARB_framebuffer_no_attachments;

+extern int ogl_ext_ARB_invalidate_subdata;

+extern int ogl_ext_ARB_robust_buffer_access_behavior;

+extern int ogl_ext_ARB_stencil_texturing;

+extern int ogl_ext_ARB_texture_query_levels;

+extern int ogl_ext_ARB_texture_storage_multisample;

+extern int ogl_ext_KHR_debug;

+extern int ogl_ext_ARB_buffer_storage;

+extern int ogl_ext_ARB_clear_texture;

+extern int ogl_ext_ARB_enhanced_layouts;

+extern int ogl_ext_ARB_multi_bind;

+extern int ogl_ext_ARB_query_buffer_object;

+extern int ogl_ext_ARB_texture_mirror_clamp_to_edge;

+extern int ogl_ext_ARB_texture_stencil8;

+extern int ogl_ext_ARB_vertex_type_10f_11f_11f_rev;

+extern int ogl_ext_ARB_seamless_cubemap_per_texture;

+extern int ogl_ext_ARB_clip_control;

+extern int ogl_ext_ARB_conditional_render_inverted;

+extern int ogl_ext_ARB_cull_distance;

+extern int ogl_ext_ARB_derivative_control;

+extern int ogl_ext_ARB_direct_state_access;

+extern int ogl_ext_ARB_get_texture_sub_image;

+extern int ogl_ext_ARB_shader_texture_image_samples;

+extern int ogl_ext_ARB_texture_barrier;

+extern int ogl_ext_KHR_context_flush_control;

+extern int ogl_ext_KHR_robust_buffer_access_behavior;

+extern int ogl_ext_KHR_robustness;

+extern int ogl_ext_EXT_texture_compression_s3tc;

+extern int ogl_ext_EXT_texture_sRGB;

+extern int ogl_ext_EXT_texture_filter_anisotropic;

+

+#define GL_PACK_COMPRESSED_BLOCK_DEPTH 0x912D

+#define GL_PACK_COMPRESSED_BLOCK_HEIGHT 0x912C

+#define GL_PACK_COMPRESSED_BLOCK_SIZE 0x912E

+#define GL_PACK_COMPRESSED_BLOCK_WIDTH 0x912B

+#define GL_UNPACK_COMPRESSED_BLOCK_DEPTH 0x9129

+#define GL_UNPACK_COMPRESSED_BLOCK_HEIGHT 0x9128

+#define GL_UNPACK_COMPRESSED_BLOCK_SIZE 0x912A

+#define GL_UNPACK_COMPRESSED_BLOCK_WIDTH 0x9127

+

+#define GL_FIXED 0x140C

+#define GL_HIGH_FLOAT 0x8DF2

+#define GL_HIGH_INT 0x8DF5

+#define GL_IMPLEMENTATION_COLOR_READ_FORMAT 0x8B9B

+#define GL_IMPLEMENTATION_COLOR_READ_TYPE 0x8B9A

+#define GL_LOW_FLOAT 0x8DF0

+#define GL_LOW_INT 0x8DF3

+#define GL_MAX_FRAGMENT_UNIFORM_VECTORS 0x8DFD

+#define GL_MAX_VARYING_VECTORS 0x8DFC

+#define GL_MAX_VERTEX_UNIFORM_VECTORS 0x8DFB

+#define GL_MEDIUM_FLOAT 0x8DF1

+#define GL_MEDIUM_INT 0x8DF4

+#define GL_NUM_SHADER_BINARY_FORMATS 0x8DF9

+#define GL_RGB565 0x8D62

+#define GL_SHADER_BINARY_FORMATS 0x8DF8

+#define GL_SHADER_COMPILER 0x8DFA

+

+#define GL_NUM_PROGRAM_BINARY_FORMATS 0x87FE

+#define GL_PROGRAM_BINARY_FORMATS 0x87FF

+#define GL_PROGRAM_BINARY_LENGTH 0x8741

+#define GL_PROGRAM_BINARY_RETRIEVABLE_HINT 0x8257

+

+#define GL_MAX_UNIFORM_LOCATIONS 0x826E

+

+#define GL_NUM_SAMPLE_COUNTS 0x9380

+

+#define GL_AUTO_GENERATE_MIPMAP 0x8295

+#define GL_CAVEAT_SUPPORT 0x82B8

+#define GL_CLEAR_BUFFER 0x82B4

+#define GL_COLOR_COMPONENTS 0x8283

+#define GL_COLOR_ENCODING 0x8296

+#define GL_COLOR_RENDERABLE 0x8286

+#define GL_COMPUTE_TEXTURE 0x82A0

+#define GL_DEPTH_COMPONENTS 0x8284

+#define GL_DEPTH_RENDERABLE 0x8287

+#define GL_FILTER 0x829A

+#define GL_FRAGMENT_TEXTURE 0x829F

+#define GL_FRAMEBUFFER_BLEND 0x828B

+#define GL_FRAMEBUFFER_RENDERABLE 0x8289

+#define GL_FRAMEBUFFER_RENDERABLE_LAYERED 0x828A

+#define GL_FULL_SUPPORT 0x82B7

+#define GL_GEOMETRY_TEXTURE 0x829E

+#define GL_GET_TEXTURE_IMAGE_FORMAT 0x8291

+#define GL_GET_TEXTURE_IMAGE_TYPE 0x8292

+#define GL_IMAGE_CLASS_10_10_10_2 0x82C3

+#define GL_IMAGE_CLASS_11_11_10 0x82C2

+#define GL_IMAGE_CLASS_1_X_16 0x82BE

+#define GL_IMAGE_CLASS_1_X_32 0x82BB

+#define GL_IMAGE_CLASS_1_X_8 0x82C1

+#define GL_IMAGE_CLASS_2_X_16 0x82BD

+#define GL_IMAGE_CLASS_2_X_32 0x82BA

+#define GL_IMAGE_CLASS_2_X_8 0x82C0

+#define GL_IMAGE_CLASS_4_X_16 0x82BC

+#define GL_IMAGE_CLASS_4_X_32 0x82B9

+#define GL_IMAGE_CLASS_4_X_8 0x82BF

+#define GL_IMAGE_COMPATIBILITY_CLASS 0x82A8

+#define GL_IMAGE_FORMAT_COMPATIBILITY_TYPE 0x90C7

+#define GL_IMAGE_PIXEL_FORMAT 0x82A9

+#define GL_IMAGE_PIXEL_TYPE 0x82AA

+#define GL_IMAGE_TEXEL_SIZE 0x82A7

+#define GL_INTERNALFORMAT_ALPHA_SIZE 0x8274

+#define GL_INTERNALFORMAT_ALPHA_TYPE 0x827B

+#define GL_INTERNALFORMAT_BLUE_SIZE 0x8273

+#define GL_INTERNALFORMAT_BLUE_TYPE 0x827A

+#define GL_INTERNALFORMAT_DEPTH_SIZE 0x8275

+#define GL_INTERNALFORMAT_DEPTH_TYPE 0x827C

+#define GL_INTERNALFORMAT_GREEN_SIZE 0x8272

+#define GL_INTERNALFORMAT_GREEN_TYPE 0x8279

+#define GL_INTERNALFORMAT_PREFERRED 0x8270

+#define GL_INTERNALFORMAT_RED_SIZE 0x8271

+#define GL_INTERNALFORMAT_RED_TYPE 0x8278

+#define GL_INTERNALFORMAT_SHARED_SIZE 0x8277

+#define GL_INTERNALFORMAT_STENCIL_SIZE 0x8276

+#define GL_INTERNALFORMAT_STENCIL_TYPE 0x827D

+#define GL_INTERNALFORMAT_SUPPORTED 0x826F

+#define GL_MANUAL_GENERATE_MIPMAP 0x8294

+#define GL_MAX_COMBINED_DIMENSIONS 0x8282

+#define GL_MAX_DEPTH 0x8280

+#define GL_MAX_HEIGHT 0x827F

+#define GL_MAX_LAYERS 0x8281

+#define GL_MAX_WIDTH 0x827E

+#define GL_MIPMAP 0x8293

+/*Copied GL_NUM_SAMPLE_COUNTS From: ARB_internalformat_query*/

+#define GL_READ_PIXELS 0x828C

+#define GL_READ_PIXELS_FORMAT 0x828D

+#define GL_READ_PIXELS_TYPE 0x828E

+#define GL_RENDERBUFFER 0x8D41

+#define GL_SAMPLES 0x80A9

+#define GL_SHADER_IMAGE_ATOMIC 0x82A6

+#define GL_SHADER_IMAGE_LOAD 0x82A4

+#define GL_SHADER_IMAGE_STORE 0x82A5

+#define GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST 0x82AC

+#define GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE 0x82AE

+#define GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST 0x82AD

+#define GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE 0x82AF

+#define GL_SRGB_DECODE_ARB 0x8299

+#define GL_SRGB_READ 0x8297

+#define GL_SRGB_WRITE 0x8298

+#define GL_STENCIL_COMPONENTS 0x8285

+#define GL_STENCIL_RENDERABLE 0x8288

+#define GL_TESS_CONTROL_TEXTURE 0x829C

+#define GL_TESS_EVALUATION_TEXTURE 0x829D

+#define GL_TEXTURE_1D 0x0DE0

+#define GL_TEXTURE_1D_ARRAY 0x8C18

+#define GL_TEXTURE_2D 0x0DE1

+#define GL_TEXTURE_2D_ARRAY 0x8C1A

+#define GL_TEXTURE_2D_MULTISAMPLE 0x9100

+#define GL_TEXTURE_2D_MULTISAMPLE_ARRAY 0x9102

+#define GL_TEXTURE_3D 0x806F

+#define GL_TEXTURE_BUFFER 0x8C2A

+#define GL_TEXTURE_COMPRESSED 0x86A1

+#define GL_TEXTURE_COMPRESSED_BLOCK_HEIGHT 0x82B2

+#define GL_TEXTURE_COMPRESSED_BLOCK_SIZE 0x82B3

+#define GL_TEXTURE_COMPRESSED_BLOCK_WIDTH 0x82B1

+#define GL_TEXTURE_CUBE_MAP 0x8513

+#define GL_TEXTURE_CUBE_MAP_ARRAY 0x9009

+#define GL_TEXTURE_GATHER 0x82A2

+#define GL_TEXTURE_GATHER_SHADOW 0x82A3

+#define GL_TEXTURE_IMAGE_FORMAT 0x828F

+#define GL_TEXTURE_IMAGE_TYPE 0x8290

+#define GL_TEXTURE_RECTANGLE 0x84F5

+#define GL_TEXTURE_SHADOW 0x82A1

+#define GL_TEXTURE_VIEW 0x82B5

+#define GL_VERTEX_TEXTURE 0x829B

+#define GL_VIEW_CLASS_128_BITS 0x82C4

+#define GL_VIEW_CLASS_16_BITS 0x82CA

+#define GL_VIEW_CLASS_24_BITS 0x82C9

+#define GL_VIEW_CLASS_32_BITS 0x82C8

+#define GL_VIEW_CLASS_48_BITS 0x82C7

+#define GL_VIEW_CLASS_64_BITS 0x82C6

+#define GL_VIEW_CLASS_8_BITS 0x82CB

+#define GL_VIEW_CLASS_96_BITS 0x82C5

+#define GL_VIEW_CLASS_BPTC_FLOAT 0x82D3

+#define GL_VIEW_CLASS_BPTC_UNORM 0x82D2

+#define GL_VIEW_CLASS_RGTC1_RED 0x82D0

+#define GL_VIEW_CLASS_RGTC2_RG 0x82D1

+#define GL_VIEW_CLASS_S3TC_DXT1_RGB 0x82CC

+#define GL_VIEW_CLASS_S3TC_DXT1_RGBA 0x82CD

+#define GL_VIEW_CLASS_S3TC_DXT3_RGBA 0x82CE

+#define GL_VIEW_CLASS_S3TC_DXT5_RGBA 0x82CF

+#define GL_VIEW_COMPATIBILITY_CLASS 0x82B6

+

+#define GL_MIN_MAP_BUFFER_ALIGNMENT 0x90BC

+

+#define GL_ACTIVE_RESOURCES 0x92F5

+#define GL_ACTIVE_VARIABLES 0x9305

+#define GL_ARRAY_SIZE 0x92FB

+#define GL_ARRAY_STRIDE 0x92FE

+#define GL_ATOMIC_COUNTER_BUFFER 0x92C0

+#define GL_ATOMIC_COUNTER_BUFFER_INDEX 0x9301

+#define GL_BLOCK_INDEX 0x92FD

+#define GL_BUFFER_BINDING 0x9302

+#define GL_BUFFER_DATA_SIZE 0x9303

+#define GL_BUFFER_VARIABLE 0x92E5

+#define GL_COMPATIBLE_SUBROUTINES 0x8E4B

+#define GL_COMPUTE_SUBROUTINE 0x92ED

+#define GL_COMPUTE_SUBROUTINE_UNIFORM 0x92F3

+#define GL_FRAGMENT_SUBROUTINE 0x92EC

+#define GL_FRAGMENT_SUBROUTINE_UNIFORM 0x92F2

+#define GL_GEOMETRY_SUBROUTINE 0x92EB

+#define GL_GEOMETRY_SUBROUTINE_UNIFORM 0x92F1

+#define GL_IS_PER_PATCH 0x92E7

+#define GL_IS_ROW_MAJOR 0x9300

+#define GL_LOCATION 0x930E

+#define GL_LOCATION_INDEX 0x930F

+#define GL_MATRIX_STRIDE 0x92FF

+#define GL_MAX_NAME_LENGTH 0x92F6

+#define GL_MAX_NUM_ACTIVE_VARIABLES 0x92F7

+#define GL_MAX_NUM_COMPATIBLE_SUBROUTINES 0x92F8

+#define GL_NAME_LENGTH 0x92F9

+#define GL_NUM_ACTIVE_VARIABLES 0x9304

+#define GL_NUM_COMPATIBLE_SUBROUTINES 0x8E4A

+#define GL_OFFSET 0x92FC

+#define GL_PROGRAM_INPUT 0x92E3

+#define GL_PROGRAM_OUTPUT 0x92E4

+#define GL_REFERENCED_BY_COMPUTE_SHADER 0x930B

+#define GL_REFERENCED_BY_FRAGMENT_SHADER 0x930A

+#define GL_REFERENCED_BY_GEOMETRY_SHADER 0x9309

+#define GL_REFERENCED_BY_TESS_CONTROL_SHADER 0x9307

+#define GL_REFERENCED_BY_TESS_EVALUATION_SHADER 0x9308

+#define GL_REFERENCED_BY_VERTEX_SHADER 0x9306

+#define GL_SHADER_STORAGE_BLOCK 0x92E6

+#define GL_TESS_CONTROL_SUBROUTINE 0x92E9

+#define GL_TESS_CONTROL_SUBROUTINE_UNIFORM 0x92EF

+#define GL_TESS_EVALUATION_SUBROUTINE 0x92EA

+#define GL_TESS_EVALUATION_SUBROUTINE_UNIFORM 0x92F0

+#define GL_TOP_LEVEL_ARRAY_SIZE 0x930C

+#define GL_TOP_LEVEL_ARRAY_STRIDE 0x930D

+#define GL_TRANSFORM_FEEDBACK_VARYING 0x92F4

+#define GL_TYPE 0x92FA

+#define GL_UNIFORM 0x92E1

+#define GL_UNIFORM_BLOCK 0x92E2

+#define GL_VERTEX_SUBROUTINE 0x92E8

+#define GL_VERTEX_SUBROUTINE_UNIFORM 0x92EE

+

+#define GL_ACTIVE_PROGRAM 0x8259

+#define GL_ALL_SHADER_BITS 0xFFFFFFFF

+#define GL_FRAGMENT_SHADER_BIT 0x00000002

+#define GL_GEOMETRY_SHADER_BIT 0x00000004

+#define GL_PROGRAM_PIPELINE_BINDING 0x825A

+#define GL_PROGRAM_SEPARABLE 0x8258

+#define GL_TESS_CONTROL_SHADER_BIT 0x00000008

+#define GL_TESS_EVALUATION_SHADER_BIT 0x00000010

+#define GL_VERTEX_SHADER_BIT 0x00000001

+

+#define GL_TEXTURE_BUFFER_OFFSET 0x919D

+#define GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT 0x919F

+#define GL_TEXTURE_BUFFER_SIZE 0x919E

+

+#define GL_TEXTURE_IMMUTABLE_FORMAT 0x912F

+

+#define GL_TEXTURE_IMMUTABLE_LEVELS 0x82DF

+#define GL_TEXTURE_VIEW_MIN_LAYER 0x82DD

+#define GL_TEXTURE_VIEW_MIN_LEVEL 0x82DB

+#define GL_TEXTURE_VIEW_NUM_LAYERS 0x82DE

+#define GL_TEXTURE_VIEW_NUM_LEVELS 0x82DC

+

+#define GL_MAX_VERTEX_ATTRIB_BINDINGS 0x82DA

+#define GL_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET 0x82D9

+#define GL_VERTEX_ATTRIB_BINDING 0x82D4

+#define GL_VERTEX_ATTRIB_RELATIVE_OFFSET 0x82D5

+#define GL_VERTEX_BINDING_DIVISOR 0x82D6

+#define GL_VERTEX_BINDING_OFFSET 0x82D7

+#define GL_VERTEX_BINDING_STRIDE 0x82D8

+

+#define GL_DEPTH_RANGE 0x0B70

+#define GL_FIRST_VERTEX_CONVENTION 0x8E4D

+#define GL_LAST_VERTEX_CONVENTION 0x8E4E

+#define GL_LAYER_PROVOKING_VERTEX 0x825E

+#define GL_MAX_VIEWPORTS 0x825B

+#define GL_PROVOKING_VERTEX 0x8E4F

+#define GL_SCISSOR_BOX 0x0C10

+#define GL_SCISSOR_TEST 0x0C11

+#define GL_UNDEFINED_VERTEX 0x8260

+#define GL_VIEWPORT 0x0BA2

+#define GL_VIEWPORT_BOUNDS_RANGE 0x825D

+#define GL_VIEWPORT_INDEX_PROVOKING_VERTEX 0x825F

+#define GL_VIEWPORT_SUBPIXEL_BITS 0x825C

+

+#define GL_ANY_SAMPLES_PASSED_CONSERVATIVE 0x8D6A

+#define GL_COMPRESSED_R11_EAC 0x9270

+#define GL_COMPRESSED_RG11_EAC 0x9272

+#define GL_COMPRESSED_RGB8_ETC2 0x9274

+#define GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 0x9276

+#define GL_COMPRESSED_RGBA8_ETC2_EAC 0x9278

+#define GL_COMPRESSED_SIGNED_R11_EAC 0x9271

+#define GL_COMPRESSED_SIGNED_RG11_EAC 0x9273

+#define GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC 0x9279

+#define GL_COMPRESSED_SRGB8_ETC2 0x9275

+#define GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 0x9277

+#define GL_MAX_ELEMENT_INDEX 0x8D6B

+#define GL_PRIMITIVE_RESTART_FIXED_INDEX 0x8D69

+

+#define GL_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS 0x9314

+#define GL_FRAMEBUFFER_DEFAULT_HEIGHT 0x9311

+#define GL_FRAMEBUFFER_DEFAULT_LAYERS 0x9312

+#define GL_FRAMEBUFFER_DEFAULT_SAMPLES 0x9313

+#define GL_FRAMEBUFFER_DEFAULT_WIDTH 0x9310

+#define GL_MAX_FRAMEBUFFER_HEIGHT 0x9316

+#define GL_MAX_FRAMEBUFFER_LAYERS 0x9317

+#define GL_MAX_FRAMEBUFFER_SAMPLES 0x9318

+#define GL_MAX_FRAMEBUFFER_WIDTH 0x9315

+

+#define GL_DEPTH_STENCIL_TEXTURE_MODE 0x90EA

+

+#define GL_BUFFER 0x82E0

+#define GL_CONTEXT_FLAG_DEBUG_BIT 0x00000002

+#define GL_DEBUG_CALLBACK_FUNCTION 0x8244

+#define GL_DEBUG_CALLBACK_USER_PARAM 0x8245

+#define GL_DEBUG_GROUP_STACK_DEPTH 0x826D

+#define GL_DEBUG_LOGGED_MESSAGES 0x9145

+#define GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH 0x8243

+#define GL_DEBUG_OUTPUT 0x92E0

+#define GL_DEBUG_OUTPUT_SYNCHRONOUS 0x8242

+#define GL_DEBUG_SEVERITY_HIGH 0x9146

+#define GL_DEBUG_SEVERITY_LOW 0x9148

+#define GL_DEBUG_SEVERITY_MEDIUM 0x9147

+#define GL_DEBUG_SEVERITY_NOTIFICATION 0x826B

+#define GL_DEBUG_SOURCE_API 0x8246

+#define GL_DEBUG_SOURCE_APPLICATION 0x824A

+#define GL_DEBUG_SOURCE_OTHER 0x824B

+#define GL_DEBUG_SOURCE_SHADER_COMPILER 0x8248

+#define GL_DEBUG_SOURCE_THIRD_PARTY 0x8249

+#define GL_DEBUG_SOURCE_WINDOW_SYSTEM 0x8247

+#define GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR 0x824D

+#define GL_DEBUG_TYPE_ERROR 0x824C

+#define GL_DEBUG_TYPE_MARKER 0x8268

+#define GL_DEBUG_TYPE_OTHER 0x8251

+#define GL_DEBUG_TYPE_PERFORMANCE 0x8250

+#define GL_DEBUG_TYPE_POP_GROUP 0x826A

+#define GL_DEBUG_TYPE_PORTABILITY 0x824F

+#define GL_DEBUG_TYPE_PUSH_GROUP 0x8269

+#define GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR 0x824E

+#define GL_DISPLAY_LIST 0x82E7

+#define GL_MAX_DEBUG_GROUP_STACK_DEPTH 0x826C

+#define GL_MAX_DEBUG_LOGGED_MESSAGES 0x9144

+#define GL_MAX_DEBUG_MESSAGE_LENGTH 0x9143

+#define GL_MAX_LABEL_LENGTH 0x82E8

+#define GL_PROGRAM 0x82E2

+#define GL_PROGRAM_PIPELINE 0x82E4

+#define GL_QUERY 0x82E3

+#define GL_SAMPLER 0x82E6

+#define GL_SHADER 0x82E1

+#define GL_STACK_OVERFLOW 0x0503

+#define GL_STACK_UNDERFLOW 0x0504

+#define GL_VERTEX_ARRAY 0x8074

+

+#define GL_BUFFER_IMMUTABLE_STORAGE 0x821F

+#define GL_BUFFER_STORAGE_FLAGS 0x8220

+#define GL_CLIENT_MAPPED_BUFFER_BARRIER_BIT 0x00004000

+#define GL_CLIENT_STORAGE_BIT 0x0200

+#define GL_DYNAMIC_STORAGE_BIT 0x0100

+#define GL_MAP_COHERENT_BIT 0x0080

+#define GL_MAP_PERSISTENT_BIT 0x0040

+#define GL_MAP_READ_BIT 0x0001

+#define GL_MAP_WRITE_BIT 0x0002

+

+#define GL_CLEAR_TEXTURE 0x9365

+

+#define GL_LOCATION_COMPONENT 0x934A

+#define GL_TRANSFORM_FEEDBACK_BUFFER 0x8C8E

+#define GL_TRANSFORM_FEEDBACK_BUFFER_INDEX 0x934B

+#define GL_TRANSFORM_FEEDBACK_BUFFER_STRIDE 0x934C

+

+#define GL_QUERY_BUFFER 0x9192

+#define GL_QUERY_BUFFER_BARRIER_BIT 0x00008000

+#define GL_QUERY_BUFFER_BINDING 0x9193

+#define GL_QUERY_RESULT_NO_WAIT 0x9194

+

+#define GL_MIRROR_CLAMP_TO_EDGE 0x8743

+

+#define GL_STENCIL_INDEX 0x1901

+#define GL_STENCIL_INDEX8 0x8D48

+

+#define GL_UNSIGNED_INT_10F_11F_11F_REV 0x8C3B

+

+#define GL_TEXTURE_CUBE_MAP_SEAMLESS 0x884F

+

+#define GL_CLIP_DEPTH_MODE 0x935D

+#define GL_CLIP_ORIGIN 0x935C

+#define GL_LOWER_LEFT 0x8CA1

+#define GL_NEGATIVE_ONE_TO_ONE 0x935E

+#define GL_UPPER_LEFT 0x8CA2

+#define GL_ZERO_TO_ONE 0x935F

+

+#define GL_QUERY_BY_REGION_NO_WAIT_INVERTED 0x8E1A

+#define GL_QUERY_BY_REGION_WAIT_INVERTED 0x8E19

+#define GL_QUERY_NO_WAIT_INVERTED 0x8E18

+#define GL_QUERY_WAIT_INVERTED 0x8E17

+

+#define GL_MAX_COMBINED_CLIP_AND_CULL_DISTANCES 0x82FA

+#define GL_MAX_CULL_DISTANCES 0x82F9

+

+#define GL_QUERY_TARGET 0x82EA

+#define GL_TEXTURE_BINDING_1D 0x8068

+#define GL_TEXTURE_BINDING_1D_ARRAY 0x8C1C

+#define GL_TEXTURE_BINDING_2D 0x8069

+#define GL_TEXTURE_BINDING_2D_ARRAY 0x8C1D

+#define GL_TEXTURE_BINDING_2D_MULTISAMPLE 0x9104

+#define GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY 0x9105

+#define GL_TEXTURE_BINDING_3D 0x806A

+#define GL_TEXTURE_BINDING_BUFFER 0x8C2C

+#define GL_TEXTURE_BINDING_CUBE_MAP 0x8514

+#define GL_TEXTURE_BINDING_CUBE_MAP_ARRAY 0x900A

+#define GL_TEXTURE_BINDING_RECTANGLE 0x84F6

+#define GL_TEXTURE_TARGET 0x1006

+

+#define GL_CONTEXT_RELEASE_BEHAVIOR 0x82FB

+#define GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH 0x82FC

+#define GL_NONE 0

+

+#define GL_CONTEXT_LOST 0x0507

+#define GL_CONTEXT_ROBUST_ACCESS 0x90F3

+#define GL_GUILTY_CONTEXT_RESET 0x8253

+#define GL_INNOCENT_CONTEXT_RESET 0x8254

+#define GL_LOSE_CONTEXT_ON_RESET 0x8252

+#define GL_NO_ERROR 0

+#define GL_NO_RESET_NOTIFICATION 0x8261

+#define GL_RESET_NOTIFICATION_STRATEGY 0x8256

+#define GL_UNKNOWN_CONTEXT_RESET 0x8255

+

+#define GL_COMPRESSED_RGBA_S3TC_DXT1_EXT 0x83F1

+#define GL_COMPRESSED_RGBA_S3TC_DXT3_EXT 0x83F2

+#define GL_COMPRESSED_RGBA_S3TC_DXT5_EXT 0x83F3

+#define GL_COMPRESSED_RGB_S3TC_DXT1_EXT 0x83F0

+

+#define GL_COMPRESSED_SLUMINANCE_ALPHA_EXT 0x8C4B

+#define GL_COMPRESSED_SLUMINANCE_EXT 0x8C4A

+#define GL_COMPRESSED_SRGB_ALPHA_EXT 0x8C49

+#define GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT 0x8C4D

+#define GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT 0x8C4E

+#define GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT 0x8C4F

+#define GL_COMPRESSED_SRGB_EXT 0x8C48

+#define GL_COMPRESSED_SRGB_S3TC_DXT1_EXT 0x8C4C

+#define GL_SLUMINANCE8_ALPHA8_EXT 0x8C45

+#define GL_SLUMINANCE8_EXT 0x8C47

+#define GL_SLUMINANCE_ALPHA_EXT 0x8C44

+#define GL_SLUMINANCE_EXT 0x8C46

+#define GL_SRGB8_ALPHA8_EXT 0x8C43

+#define GL_SRGB8_EXT 0x8C41

+#define GL_SRGB_ALPHA_EXT 0x8C42

+#define GL_SRGB_EXT 0x8C40

+

+#define GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT 0x84FF

+#define GL_TEXTURE_MAX_ANISOTROPY_EXT 0x84FE

+

+#define GL_2D 0x0600

+#define GL_2_BYTES 0x1407

+#define GL_3D 0x0601

+#define GL_3D_COLOR 0x0602

+#define GL_3D_COLOR_TEXTURE 0x0603

+#define GL_3_BYTES 0x1408

+#define GL_4D_COLOR_TEXTURE 0x0604

+#define GL_4_BYTES 0x1409

+#define GL_ACCUM 0x0100

+#define GL_ACCUM_ALPHA_BITS 0x0D5B

+#define GL_ACCUM_BLUE_BITS 0x0D5A

+#define GL_ACCUM_BUFFER_BIT 0x00000200

+#define GL_ACCUM_CLEAR_VALUE 0x0B80

+#define GL_ACCUM_GREEN_BITS 0x0D59

+#define GL_ACCUM_RED_BITS 0x0D58

+#define GL_ADD 0x0104

+#define GL_ALL_ATTRIB_BITS 0xFFFFFFFF

+#define GL_ALPHA 0x1906

+#define GL_ALPHA12 0x803D

+#define GL_ALPHA16 0x803E

+#define GL_ALPHA4 0x803B

+#define GL_ALPHA8 0x803C

+#define GL_ALPHA_BIAS 0x0D1D

+#define GL_ALPHA_BITS 0x0D55

+#define GL_ALPHA_SCALE 0x0D1C

+#define GL_ALPHA_TEST 0x0BC0

+#define GL_ALPHA_TEST_FUNC 0x0BC1

+#define GL_ALPHA_TEST_REF 0x0BC2

+#define GL_ALWAYS 0x0207

+#define GL_AMBIENT 0x1200

+#define GL_AMBIENT_AND_DIFFUSE 0x1602

+#define GL_AND 0x1501

+#define GL_AND_INVERTED 0x1504

+#define GL_AND_REVERSE 0x1502

+#define GL_ATTRIB_STACK_DEPTH 0x0BB0

+#define GL_AUTO_NORMAL 0x0D80

+#define GL_AUX0 0x0409

+#define GL_AUX1 0x040A

+#define GL_AUX2 0x040B

+#define GL_AUX3 0x040C

+#define GL_AUX_BUFFERS 0x0C00

+#define GL_BACK 0x0405

+#define GL_BACK_LEFT 0x0402

+#define GL_BACK_RIGHT 0x0403

+#define GL_BITMAP 0x1A00

+#define GL_BITMAP_TOKEN 0x0704

+#define GL_BLEND 0x0BE2

+#define GL_BLEND_DST 0x0BE0

+#define GL_BLEND_SRC 0x0BE1

+#define GL_BLUE 0x1905

+#define GL_BLUE_BIAS 0x0D1B

+#define GL_BLUE_BITS 0x0D54

+#define GL_BLUE_SCALE 0x0D1A

+#define GL_BYTE 0x1400

+#define GL_C3F_V3F 0x2A24

+#define GL_C4F_N3F_V3F 0x2A26

+#define GL_C4UB_V2F 0x2A22

+#define GL_C4UB_V3F 0x2A23

+#define GL_CCW 0x0901

+#define GL_CLAMP 0x2900

+#define GL_CLEAR 0x1500

+#define GL_CLIENT_ALL_ATTRIB_BITS 0xFFFFFFFF

+#define GL_CLIENT_ATTRIB_STACK_DEPTH 0x0BB1

+#define GL_CLIENT_PIXEL_STORE_BIT 0x00000001

+#define GL_CLIENT_VERTEX_ARRAY_BIT 0x00000002

+#define GL_CLIP_PLANE0 0x3000

+#define GL_CLIP_PLANE1 0x3001

+#define GL_CLIP_PLANE2 0x3002

+#define GL_CLIP_PLANE3 0x3003

+#define GL_CLIP_PLANE4 0x3004

+#define GL_CLIP_PLANE5 0x3005

+#define GL_COEFF 0x0A00

+#define GL_COLOR 0x1800

+#define GL_COLOR_ARRAY 0x8076

+#define GL_COLOR_ARRAY_POINTER 0x8090

+#define GL_COLOR_ARRAY_SIZE 0x8081

+#define GL_COLOR_ARRAY_STRIDE 0x8083

+#define GL_COLOR_ARRAY_TYPE 0x8082

+#define GL_COLOR_BUFFER_BIT 0x00004000

+#define GL_COLOR_CLEAR_VALUE 0x0C22

+#define GL_COLOR_INDEX 0x1900

+#define GL_COLOR_INDEXES 0x1603

+#define GL_COLOR_LOGIC_OP 0x0BF2

+#define GL_COLOR_MATERIAL 0x0B57

+#define GL_COLOR_MATERIAL_FACE 0x0B55

+#define GL_COLOR_MATERIAL_PARAMETER 0x0B56

+#define GL_COLOR_WRITEMASK 0x0C23

+#define GL_COMPILE 0x1300

+#define GL_COMPILE_AND_EXECUTE 0x1301

+#define GL_CONSTANT_ATTENUATION 0x1207

+#define GL_COPY 0x1503

+#define GL_COPY_INVERTED 0x150C

+#define GL_COPY_PIXEL_TOKEN 0x0706

+#define GL_CULL_FACE 0x0B44

+#define GL_CULL_FACE_MODE 0x0B45

+#define GL_CURRENT_BIT 0x00000001

+#define GL_CURRENT_COLOR 0x0B00

+#define GL_CURRENT_INDEX 0x0B01

+#define GL_CURRENT_NORMAL 0x0B02

+#define GL_CURRENT_RASTER_COLOR 0x0B04

+#define GL_CURRENT_RASTER_DISTANCE 0x0B09

+#define GL_CURRENT_RASTER_INDEX 0x0B05

+#define GL_CURRENT_RASTER_POSITION 0x0B07

+#define GL_CURRENT_RASTER_POSITION_VALID 0x0B08

+#define GL_CURRENT_RASTER_TEXTURE_COORDS 0x0B06

+#define GL_CURRENT_TEXTURE_COORDS 0x0B03

+#define GL_CW 0x0900

+#define GL_DECAL 0x2101

+#define GL_DECR 0x1E03

+#define GL_DEPTH 0x1801

+#define GL_DEPTH_BIAS 0x0D1F

+#define GL_DEPTH_BITS 0x0D56

+#define GL_DEPTH_BUFFER_BIT 0x00000100

+#define GL_DEPTH_CLEAR_VALUE 0x0B73

+#define GL_DEPTH_COMPONENT 0x1902

+#define GL_DEPTH_FUNC 0x0B74

+/*Copied GL_DEPTH_RANGE From: ARB_viewport_array*/

+#define GL_DEPTH_SCALE 0x0D1E

+#define GL_DEPTH_TEST 0x0B71

+#define GL_DEPTH_WRITEMASK 0x0B72

+#define GL_DIFFUSE 0x1201

+#define GL_DITHER 0x0BD0

+#define GL_DOMAIN 0x0A02

+#define GL_DONT_CARE 0x1100

+#define GL_DOUBLE 0x140A

+#define GL_DOUBLEBUFFER 0x0C32

+#define GL_DRAW_BUFFER 0x0C01

+#define GL_DRAW_PIXEL_TOKEN 0x0705

+#define GL_DST_ALPHA 0x0304

+#define GL_DST_COLOR 0x0306

+#define GL_EDGE_FLAG 0x0B43

+#define GL_EDGE_FLAG_ARRAY 0x8079

+#define GL_EDGE_FLAG_ARRAY_POINTER 0x8093

+#define GL_EDGE_FLAG_ARRAY_STRIDE 0x808C

+#define GL_EMISSION 0x1600

+#define GL_ENABLE_BIT 0x00002000

+#define GL_EQUAL 0x0202

+#define GL_EQUIV 0x1509

+#define GL_EVAL_BIT 0x00010000

+#define GL_EXP 0x0800

+#define GL_EXP2 0x0801

+#define GL_EXTENSIONS 0x1F03

+#define GL_EYE_LINEAR 0x2400

+#define GL_EYE_PLANE 0x2502

+#define GL_FALSE 0

+#define GL_FASTEST 0x1101

+#define GL_FEEDBACK 0x1C01

+#define GL_FEEDBACK_BUFFER_POINTER 0x0DF0

+#define GL_FEEDBACK_BUFFER_SIZE 0x0DF1

+#define GL_FEEDBACK_BUFFER_TYPE 0x0DF2

+#define GL_FILL 0x1B02

+#define GL_FLAT 0x1D00

+#define GL_FLOAT 0x1406

+#define GL_FOG 0x0B60

+#define GL_FOG_BIT 0x00000080

+#define GL_FOG_COLOR 0x0B66

+#define GL_FOG_DENSITY 0x0B62

+#define GL_FOG_END 0x0B64

+#define GL_FOG_HINT 0x0C54

+#define GL_FOG_INDEX 0x0B61

+#define GL_FOG_MODE 0x0B65

+#define GL_FOG_START 0x0B63

+#define GL_FRONT 0x0404

+#define GL_FRONT_AND_BACK 0x0408

+#define GL_FRONT_FACE 0x0B46

+#define GL_FRONT_LEFT 0x0400

+#define GL_FRONT_RIGHT 0x0401

+#define GL_GEQUAL 0x0206

+#define GL_GREATER 0x0204

+#define GL_GREEN 0x1904

+#define GL_GREEN_BIAS 0x0D19

+#define GL_GREEN_BITS 0x0D53

+#define GL_GREEN_SCALE 0x0D18

+#define GL_HINT_BIT 0x00008000

+#define GL_INCR 0x1E02

+#define GL_INDEX_ARRAY 0x8077

+#define GL_INDEX_ARRAY_POINTER 0x8091

+#define GL_INDEX_ARRAY_STRIDE 0x8086

+#define GL_INDEX_ARRAY_TYPE 0x8085

+#define GL_INDEX_BITS 0x0D51

+#define GL_INDEX_CLEAR_VALUE 0x0C20

+#define GL_INDEX_LOGIC_OP 0x0BF1

+#define GL_INDEX_MODE 0x0C30

+#define GL_INDEX_OFFSET 0x0D13

+#define GL_INDEX_SHIFT 0x0D12

+#define GL_INDEX_WRITEMASK 0x0C21

+#define GL_INT 0x1404

+#define GL_INTENSITY 0x8049

+#define GL_INTENSITY12 0x804C

+#define GL_INTENSITY16 0x804D

+#define GL_INTENSITY4 0x804A

+#define GL_INTENSITY8 0x804B

+#define GL_INVALID_ENUM 0x0500

+#define GL_INVALID_OPERATION 0x0502

+#define GL_INVALID_VALUE 0x0501

+#define GL_INVERT 0x150A

+#define GL_KEEP 0x1E00

+#define GL_LEFT 0x0406

+#define GL_LEQUAL 0x0203

+#define GL_LESS 0x0201

+#define GL_LIGHT0 0x4000

+#define GL_LIGHT1 0x4001

+#define GL_LIGHT2 0x4002

+#define GL_LIGHT3 0x4003

+#define GL_LIGHT4 0x4004

+#define GL_LIGHT5 0x4005

+#define GL_LIGHT6 0x4006

+#define GL_LIGHT7 0x4007

+#define GL_LIGHTING 0x0B50

+#define GL_LIGHTING_BIT 0x00000040

+#define GL_LIGHT_MODEL_AMBIENT 0x0B53

+#define GL_LIGHT_MODEL_LOCAL_VIEWER 0x0B51

+#define GL_LIGHT_MODEL_TWO_SIDE 0x0B52

+#define GL_LINE 0x1B01

+#define GL_LINEAR 0x2601

+#define GL_LINEAR_ATTENUATION 0x1208

+#define GL_LINEAR_MIPMAP_LINEAR 0x2703

+#define GL_LINEAR_MIPMAP_NEAREST 0x2701

+#define GL_LINES 0x0001

+#define GL_LINE_BIT 0x00000004

+#define GL_LINE_LOOP 0x0002

+#define GL_LINE_RESET_TOKEN 0x0707

+#define GL_LINE_SMOOTH 0x0B20

+#define GL_LINE_SMOOTH_HINT 0x0C52

+#define GL_LINE_STIPPLE 0x0B24

+#define GL_LINE_STIPPLE_PATTERN 0x0B25

+#define GL_LINE_STIPPLE_REPEAT 0x0B26

+#define GL_LINE_STRIP 0x0003

+#define GL_LINE_TOKEN 0x0702

+#define GL_LINE_WIDTH 0x0B21

+#define GL_LINE_WIDTH_GRANULARITY 0x0B23

+#define GL_LINE_WIDTH_RANGE 0x0B22

+#define GL_LIST_BASE 0x0B32

+#define GL_LIST_BIT 0x00020000

+#define GL_LIST_INDEX 0x0B33

+#define GL_LIST_MODE 0x0B30

+#define GL_LOAD 0x0101

+#define GL_LOGIC_OP 0x0BF1

+#define GL_LOGIC_OP_MODE 0x0BF0

+#define GL_LUMINANCE 0x1909

+#define GL_LUMINANCE12 0x8041

+#define GL_LUMINANCE12_ALPHA12 0x8047

+#define GL_LUMINANCE12_ALPHA4 0x8046

+#define GL_LUMINANCE16 0x8042

+#define GL_LUMINANCE16_ALPHA16 0x8048

+#define GL_LUMINANCE4 0x803F

+#define GL_LUMINANCE4_ALPHA4 0x8043

+#define GL_LUMINANCE6_ALPHA2 0x8044

+#define GL_LUMINANCE8 0x8040

+#define GL_LUMINANCE8_ALPHA8 0x8045

+#define GL_LUMINANCE_ALPHA 0x190A

+#define GL_MAP1_COLOR_4 0x0D90

+#define GL_MAP1_GRID_DOMAIN 0x0DD0

+#define GL_MAP1_GRID_SEGMENTS 0x0DD1

+#define GL_MAP1_INDEX 0x0D91

+#define GL_MAP1_NORMAL 0x0D92

+#define GL_MAP1_TEXTURE_COORD_1 0x0D93

+#define GL_MAP1_TEXTURE_COORD_2 0x0D94

+#define GL_MAP1_TEXTURE_COORD_3 0x0D95

+#define GL_MAP1_TEXTURE_COORD_4 0x0D96

+#define GL_MAP1_VERTEX_3 0x0D97

+#define GL_MAP1_VERTEX_4 0x0D98

+#define GL_MAP2_COLOR_4 0x0DB0

+#define GL_MAP2_GRID_DOMAIN 0x0DD2

+#define GL_MAP2_GRID_SEGMENTS 0x0DD3

+#define GL_MAP2_INDEX 0x0DB1

+#define GL_MAP2_NORMAL 0x0DB2

+#define GL_MAP2_TEXTURE_COORD_1 0x0DB3

+#define GL_MAP2_TEXTURE_COORD_2 0x0DB4

+#define GL_MAP2_TEXTURE_COORD_3 0x0DB5

+#define GL_MAP2_TEXTURE_COORD_4 0x0DB6

+#define GL_MAP2_VERTEX_3 0x0DB7

+#define GL_MAP2_VERTEX_4 0x0DB8

+#define GL_MAP_COLOR 0x0D10

+#define GL_MAP_STENCIL 0x0D11

+#define GL_MATRIX_MODE 0x0BA0

+#define GL_MAX_ATTRIB_STACK_DEPTH 0x0D35

+#define GL_MAX_CLIENT_ATTRIB_STACK_DEPTH 0x0D3B

+#define GL_MAX_CLIP_PLANES 0x0D32

+#define GL_MAX_EVAL_ORDER 0x0D30

+#define GL_MAX_LIGHTS 0x0D31

+#define GL_MAX_LIST_NESTING 0x0B31

+#define GL_MAX_MODELVIEW_STACK_DEPTH 0x0D36

+#define GL_MAX_NAME_STACK_DEPTH 0x0D37

+#define GL_MAX_PIXEL_MAP_TABLE 0x0D34

+#define GL_MAX_PROJECTION_STACK_DEPTH 0x0D38

+#define GL_MAX_TEXTURE_SIZE 0x0D33

+#define GL_MAX_TEXTURE_STACK_DEPTH 0x0D39

+#define GL_MAX_VIEWPORT_DIMS 0x0D3A

+#define GL_MODELVIEW 0x1700

+#define GL_MODELVIEW_MATRIX 0x0BA6

+#define GL_MODELVIEW_STACK_DEPTH 0x0BA3

+#define GL_MODULATE 0x2100

+#define GL_MULT 0x0103

+#define GL_N3F_V3F 0x2A25

+#define GL_NAME_STACK_DEPTH 0x0D70

+#define GL_NAND 0x150E

+#define GL_NEAREST 0x2600

+#define GL_NEAREST_MIPMAP_LINEAR 0x2702

+#define GL_NEAREST_MIPMAP_NEAREST 0x2700

+#define GL_NEVER 0x0200

+#define GL_NICEST 0x1102

+/*Copied GL_NONE From: KHR_context_flush_control*/

+#define GL_NOOP 0x1505

+#define GL_NOR 0x1508

+#define GL_NORMALIZE 0x0BA1

+#define GL_NORMAL_ARRAY 0x8075

+#define GL_NORMAL_ARRAY_POINTER 0x808F

+#define GL_NORMAL_ARRAY_STRIDE 0x807F

+#define GL_NORMAL_ARRAY_TYPE 0x807E

+#define GL_NOTEQUAL 0x0205

+/*Copied GL_NO_ERROR From: KHR_robustness*/

+#define GL_OBJECT_LINEAR 0x2401

+#define GL_OBJECT_PLANE 0x2501

+#define GL_ONE 1

+#define GL_ONE_MINUS_DST_ALPHA 0x0305

+#define GL_ONE_MINUS_DST_COLOR 0x0307

+#define GL_ONE_MINUS_SRC_ALPHA 0x0303

+#define GL_ONE_MINUS_SRC_COLOR 0x0301

+#define GL_OR 0x1507

+#define GL_ORDER 0x0A01

+#define GL_OR_INVERTED 0x150D

+#define GL_OR_REVERSE 0x150B

+#define GL_OUT_OF_MEMORY 0x0505

+#define GL_PACK_ALIGNMENT 0x0D05

+#define GL_PACK_LSB_FIRST 0x0D01

+#define GL_PACK_ROW_LENGTH 0x0D02

+#define GL_PACK_SKIP_PIXELS 0x0D04

+#define GL_PACK_SKIP_ROWS 0x0D03

+#define GL_PACK_SWAP_BYTES 0x0D00

+#define GL_PASS_THROUGH_TOKEN 0x0700

+#define GL_PERSPECTIVE_CORRECTION_HINT 0x0C50

+#define GL_PIXEL_MAP_A_TO_A 0x0C79

+#define GL_PIXEL_MAP_A_TO_A_SIZE 0x0CB9

+#define GL_PIXEL_MAP_B_TO_B 0x0C78

+#define GL_PIXEL_MAP_B_TO_B_SIZE 0x0CB8

+#define GL_PIXEL_MAP_G_TO_G 0x0C77

+#define GL_PIXEL_MAP_G_TO_G_SIZE 0x0CB7

+#define GL_PIXEL_MAP_I_TO_A 0x0C75

+#define GL_PIXEL_MAP_I_TO_A_SIZE 0x0CB5

+#define GL_PIXEL_MAP_I_TO_B 0x0C74

+#define GL_PIXEL_MAP_I_TO_B_SIZE 0x0CB4

+#define GL_PIXEL_MAP_I_TO_G 0x0C73

+#define GL_PIXEL_MAP_I_TO_G_SIZE 0x0CB3

+#define GL_PIXEL_MAP_I_TO_I 0x0C70

+#define GL_PIXEL_MAP_I_TO_I_SIZE 0x0CB0

+#define GL_PIXEL_MAP_I_TO_R 0x0C72

+#define GL_PIXEL_MAP_I_TO_R_SIZE 0x0CB2

+#define GL_PIXEL_MAP_R_TO_R 0x0C76

+#define GL_PIXEL_MAP_R_TO_R_SIZE 0x0CB6

+#define GL_PIXEL_MAP_S_TO_S 0x0C71

+#define GL_PIXEL_MAP_S_TO_S_SIZE 0x0CB1

+#define GL_PIXEL_MODE_BIT 0x00000020

+#define GL_POINT 0x1B00

+#define GL_POINTS 0x0000

+#define GL_POINT_BIT 0x00000002

+#define GL_POINT_SIZE 0x0B11

+#define GL_POINT_SIZE_GRANULARITY 0x0B13

+#define GL_POINT_SIZE_RANGE 0x0B12

+#define GL_POINT_SMOOTH 0x0B10

+#define GL_POINT_SMOOTH_HINT 0x0C51

+#define GL_POINT_TOKEN 0x0701

+#define GL_POLYGON 0x0009

+#define GL_POLYGON_BIT 0x00000008

+#define GL_POLYGON_MODE 0x0B40

+#define GL_POLYGON_OFFSET_FACTOR 0x8038

+#define GL_POLYGON_OFFSET_FILL 0x8037

+#define GL_POLYGON_OFFSET_LINE 0x2A02

+#define GL_POLYGON_OFFSET_POINT 0x2A01

+#define GL_POLYGON_OFFSET_UNITS 0x2A00

+#define GL_POLYGON_SMOOTH 0x0B41

+#define GL_POLYGON_SMOOTH_HINT 0x0C53

+#define GL_POLYGON_STIPPLE 0x0B42

+#define GL_POLYGON_STIPPLE_BIT 0x00000010

+#define GL_POLYGON_TOKEN 0x0703

+#define GL_POSITION 0x1203

+#define GL_PROJECTION 0x1701

+#define GL_PROJECTION_MATRIX 0x0BA7

+#define GL_PROJECTION_STACK_DEPTH 0x0BA4

+#define GL_PROXY_TEXTURE_1D 0x8063

+#define GL_PROXY_TEXTURE_2D 0x8064

+#define GL_Q 0x2003

+#define GL_QUADRATIC_ATTENUATION 0x1209

+#define GL_QUADS 0x0007

+#define GL_QUAD_STRIP 0x0008

+#define GL_R 0x2002

+#define GL_R3_G3_B2 0x2A10

+#define GL_READ_BUFFER 0x0C02

+#define GL_RED 0x1903

+#define GL_RED_BIAS 0x0D15

+#define GL_RED_BITS 0x0D52

+#define GL_RED_SCALE 0x0D14

+#define GL_RENDER 0x1C00

+#define GL_RENDERER 0x1F01

+#define GL_RENDER_MODE 0x0C40

+#define GL_REPEAT 0x2901

+#define GL_REPLACE 0x1E01

+#define GL_RETURN 0x0102

+#define GL_RGB 0x1907

+#define GL_RGB10 0x8052

+#define GL_RGB10_A2 0x8059

+#define GL_RGB12 0x8053

+#define GL_RGB16 0x8054

+#define GL_RGB4 0x804F

+#define GL_RGB5 0x8050

+#define GL_RGB5_A1 0x8057

+#define GL_RGB8 0x8051

+#define GL_RGBA 0x1908

+#define GL_RGBA12 0x805A

+#define GL_RGBA16 0x805B

+#define GL_RGBA2 0x8055

+#define GL_RGBA4 0x8056

+#define GL_RGBA8 0x8058

+#define GL_RGBA_MODE 0x0C31

+#define GL_RIGHT 0x0407

+#define GL_S 0x2000

+#define GL_SCISSOR_BIT 0x00080000

+/*Copied GL_SCISSOR_BOX From: ARB_viewport_array*/

+/*Copied GL_SCISSOR_TEST From: ARB_viewport_array*/

+#define GL_SELECT 0x1C02

+#define GL_SELECTION_BUFFER_POINTER 0x0DF3

+#define GL_SELECTION_BUFFER_SIZE 0x0DF4

+#define GL_SET 0x150F

+#define GL_SHADE_MODEL 0x0B54

+#define GL_SHININESS 0x1601

+#define GL_SHORT 0x1402

+#define GL_SMOOTH 0x1D01

+#define GL_SPECULAR 0x1202

+#define GL_SPHERE_MAP 0x2402

+#define GL_SPOT_CUTOFF 0x1206

+#define GL_SPOT_DIRECTION 0x1204

+#define GL_SPOT_EXPONENT 0x1205

+#define GL_SRC_ALPHA 0x0302

+#define GL_SRC_ALPHA_SATURATE 0x0308

+#define GL_SRC_COLOR 0x0300

+/*Copied GL_STACK_OVERFLOW From: KHR_debug*/

+/*Copied GL_STACK_UNDERFLOW From: KHR_debug*/

+#define GL_STENCIL 0x1802

+#define GL_STENCIL_BITS 0x0D57

+#define GL_STENCIL_BUFFER_BIT 0x00000400

+#define GL_STENCIL_CLEAR_VALUE 0x0B91

+#define GL_STENCIL_FAIL 0x0B94

+#define GL_STENCIL_FUNC 0x0B92

+/*Copied GL_STENCIL_INDEX From: ARB_texture_stencil8*/

+#define GL_STENCIL_PASS_DEPTH_FAIL 0x0B95

+#define GL_STENCIL_PASS_DEPTH_PASS 0x0B96

+#define GL_STENCIL_REF 0x0B97

+#define GL_STENCIL_TEST 0x0B90

+#define GL_STENCIL_VALUE_MASK 0x0B93

+#define GL_STENCIL_WRITEMASK 0x0B98

+#define GL_STEREO 0x0C33

+#define GL_SUBPIXEL_BITS 0x0D50

+#define GL_T 0x2001

+#define GL_T2F_C3F_V3F 0x2A2A

+#define GL_T2F_C4F_N3F_V3F 0x2A2C

+#define GL_T2F_C4UB_V3F 0x2A29

+#define GL_T2F_N3F_V3F 0x2A2B

+#define GL_T2F_V3F 0x2A27

+#define GL_T4F_C4F_N3F_V4F 0x2A2D

+#define GL_T4F_V4F 0x2A28

+#define GL_TEXTURE 0x1702

+/*Copied GL_TEXTURE_1D From: ARB_internalformat_query2*/

+/*Copied GL_TEXTURE_2D From: ARB_internalformat_query2*/

+#define GL_TEXTURE_ALPHA_SIZE 0x805F

+/*Copied GL_TEXTURE_BINDING_1D From: ARB_direct_state_access*/

+/*Copied GL_TEXTURE_BINDING_2D From: ARB_direct_state_access*/

+#define GL_TEXTURE_BIT 0x00040000

+#define GL_TEXTURE_BLUE_SIZE 0x805E

+#define GL_TEXTURE_BORDER 0x1005

+#define GL_TEXTURE_BORDER_COLOR 0x1004

+#define GL_TEXTURE_COMPONENTS 0x1003

+#define GL_TEXTURE_COORD_ARRAY 0x8078

+#define GL_TEXTURE_COORD_ARRAY_POINTER 0x8092

+#define GL_TEXTURE_COORD_ARRAY_SIZE 0x8088

+#define GL_TEXTURE_COORD_ARRAY_STRIDE 0x808A

+#define GL_TEXTURE_COORD_ARRAY_TYPE 0x8089

+#define GL_TEXTURE_ENV 0x2300

+#define GL_TEXTURE_ENV_COLOR 0x2201

+#define GL_TEXTURE_ENV_MODE 0x2200

+#define GL_TEXTURE_GEN_MODE 0x2500

+#define GL_TEXTURE_GEN_Q 0x0C63

+#define GL_TEXTURE_GEN_R 0x0C62

+#define GL_TEXTURE_GEN_S 0x0C60

+#define GL_TEXTURE_GEN_T 0x0C61

+#define GL_TEXTURE_GREEN_SIZE 0x805D

+#define GL_TEXTURE_HEIGHT 0x1001

+#define GL_TEXTURE_INTENSITY_SIZE 0x8061

+#define GL_TEXTURE_INTERNAL_FORMAT 0x1003

+#define GL_TEXTURE_LUMINANCE_SIZE 0x8060

+#define GL_TEXTURE_MAG_FILTER 0x2800

+#define GL_TEXTURE_MATRIX 0x0BA8

+#define GL_TEXTURE_MIN_FILTER 0x2801

+#define GL_TEXTURE_PRIORITY 0x8066

+#define GL_TEXTURE_RED_SIZE 0x805C

+#define GL_TEXTURE_RESIDENT 0x8067

+#define GL_TEXTURE_STACK_DEPTH 0x0BA5

+#define GL_TEXTURE_WIDTH 0x1000

+#define GL_TEXTURE_WRAP_S 0x2802

+#define GL_TEXTURE_WRAP_T 0x2803

+#define GL_TRANSFORM_BIT 0x00001000

+#define GL_TRIANGLES 0x0004

+#define GL_TRIANGLE_FAN 0x0006

+#define GL_TRIANGLE_STRIP 0x0005

+#define GL_TRUE 1

+#define GL_UNPACK_ALIGNMENT 0x0CF5

+#define GL_UNPACK_LSB_FIRST 0x0CF1

+#define GL_UNPACK_ROW_LENGTH 0x0CF2

+#define GL_UNPACK_SKIP_PIXELS 0x0CF4

+#define GL_UNPACK_SKIP_ROWS 0x0CF3

+#define GL_UNPACK_SWAP_BYTES 0x0CF0

+#define GL_UNSIGNED_BYTE 0x1401

+#define GL_UNSIGNED_INT 0x1405

+#define GL_UNSIGNED_SHORT 0x1403

+#define GL_V2F 0x2A20

+#define GL_V3F 0x2A21

+#define GL_VENDOR 0x1F00

+#define GL_VERSION 0x1F02

+/*Copied GL_VERTEX_ARRAY From: KHR_debug*/

+#define GL_VERTEX_ARRAY_POINTER 0x808E

+#define GL_VERTEX_ARRAY_SIZE 0x807A

+#define GL_VERTEX_ARRAY_STRIDE 0x807C

+#define GL_VERTEX_ARRAY_TYPE 0x807B

+/*Copied GL_VIEWPORT From: ARB_viewport_array*/

+#define GL_VIEWPORT_BIT 0x00000800

+#define GL_XOR 0x1506

+#define GL_ZERO 0

+#define GL_ZOOM_X 0x0D16

+#define GL_ZOOM_Y 0x0D17

+

+#define GL_ALIASED_LINE_WIDTH_RANGE 0x846E

+#define GL_ALIASED_POINT_SIZE_RANGE 0x846D

+#define GL_BGR 0x80E0

+#define GL_BGRA 0x80E1

+#define GL_CLAMP_TO_EDGE 0x812F

+#define GL_LIGHT_MODEL_COLOR_CONTROL 0x81F8

+#define GL_MAX_3D_TEXTURE_SIZE 0x8073

+#define GL_MAX_ELEMENTS_INDICES 0x80E9

+#define GL_MAX_ELEMENTS_VERTICES 0x80E8

+#define GL_PACK_IMAGE_HEIGHT 0x806C

+#define GL_PACK_SKIP_IMAGES 0x806B

+#define GL_PROXY_TEXTURE_3D 0x8070

+#define GL_RESCALE_NORMAL 0x803A

+#define GL_SEPARATE_SPECULAR_COLOR 0x81FA

+#define GL_SINGLE_COLOR 0x81F9

+#define GL_SMOOTH_LINE_WIDTH_GRANULARITY 0x0B23

+#define GL_SMOOTH_LINE_WIDTH_RANGE 0x0B22

+#define GL_SMOOTH_POINT_SIZE_GRANULARITY 0x0B13

+#define GL_SMOOTH_POINT_SIZE_RANGE 0x0B12

+/*Copied GL_TEXTURE_3D From: ARB_internalformat_query2*/

+#define GL_TEXTURE_BASE_LEVEL 0x813C

+/*Copied GL_TEXTURE_BINDING_3D From: ARB_direct_state_access*/

+#define GL_TEXTURE_DEPTH 0x8071

+#define GL_TEXTURE_MAX_LEVEL 0x813D

+#define GL_TEXTURE_MAX_LOD 0x813B

+#define GL_TEXTURE_MIN_LOD 0x813A

+#define GL_TEXTURE_WRAP_R 0x8072

+#define GL_UNPACK_IMAGE_HEIGHT 0x806E

+#define GL_UNPACK_SKIP_IMAGES 0x806D

+#define GL_UNSIGNED_BYTE_2_3_3_REV 0x8362

+#define GL_UNSIGNED_BYTE_3_3_2 0x8032

+#define GL_UNSIGNED_INT_10_10_10_2 0x8036

+#define GL_UNSIGNED_INT_2_10_10_10_REV 0x8368

+#define GL_UNSIGNED_INT_8_8_8_8 0x8035

+#define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367

+#define GL_UNSIGNED_SHORT_1_5_5_5_REV 0x8366

+#define GL_UNSIGNED_SHORT_4_4_4_4 0x8033

+#define GL_UNSIGNED_SHORT_4_4_4_4_REV 0x8365

+#define GL_UNSIGNED_SHORT_5_5_5_1 0x8034

+#define GL_UNSIGNED_SHORT_5_6_5 0x8363

+#define GL_UNSIGNED_SHORT_5_6_5_REV 0x8364

+

+#define GL_ACTIVE_TEXTURE 0x84E0

+#define GL_ADD_SIGNED 0x8574

+#define GL_CLAMP_TO_BORDER 0x812D

+#define GL_CLIENT_ACTIVE_TEXTURE 0x84E1

+#define GL_COMBINE 0x8570

+#define GL_COMBINE_ALPHA 0x8572

+#define GL_COMBINE_RGB 0x8571

+#define GL_COMPRESSED_ALPHA 0x84E9

+#define GL_COMPRESSED_INTENSITY 0x84EC

+#define GL_COMPRESSED_LUMINANCE 0x84EA

+#define GL_COMPRESSED_LUMINANCE_ALPHA 0x84EB

+#define GL_COMPRESSED_RGB 0x84ED

+#define GL_COMPRESSED_RGBA 0x84EE

+#define GL_COMPRESSED_TEXTURE_FORMATS 0x86A3

+#define GL_CONSTANT 0x8576

+#define GL_DOT3_RGB 0x86AE

+#define GL_DOT3_RGBA 0x86AF

+#define GL_INTERPOLATE 0x8575

+#define GL_MAX_CUBE_MAP_TEXTURE_SIZE 0x851C

+#define GL_MAX_TEXTURE_UNITS 0x84E2

+#define GL_MULTISAMPLE 0x809D

+#define GL_MULTISAMPLE_BIT 0x20000000

+#define GL_NORMAL_MAP 0x8511

+#define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2

+#define GL_OPERAND0_ALPHA 0x8598

+#define GL_OPERAND0_RGB 0x8590

+#define GL_OPERAND1_ALPHA 0x8599

+#define GL_OPERAND1_RGB 0x8591

+#define GL_OPERAND2_ALPHA 0x859A

+#define GL_OPERAND2_RGB 0x8592

+#define GL_PREVIOUS 0x8578

+#define GL_PRIMARY_COLOR 0x8577

+#define GL_PROXY_TEXTURE_CUBE_MAP 0x851B

+#define GL_REFLECTION_MAP 0x8512

+#define GL_RGB_SCALE 0x8573

+/*Copied GL_SAMPLES From: ARB_internalformat_query2*/

+#define GL_SAMPLE_ALPHA_TO_COVERAGE 0x809E

+#define GL_SAMPLE_ALPHA_TO_ONE 0x809F

+#define GL_SAMPLE_BUFFERS 0x80A8

+#define GL_SAMPLE_COVERAGE 0x80A0

+#define GL_SAMPLE_COVERAGE_INVERT 0x80AB

+#define GL_SAMPLE_COVERAGE_VALUE 0x80AA

+#define GL_SOURCE0_ALPHA 0x8588

+#define GL_SOURCE0_RGB 0x8580

+#define GL_SOURCE1_ALPHA 0x8589

+#define GL_SOURCE1_RGB 0x8581

+#define GL_SOURCE2_ALPHA 0x858A

+#define GL_SOURCE2_RGB 0x8582

+#define GL_SUBTRACT 0x84E7

+#define GL_TEXTURE0 0x84C0

+#define GL_TEXTURE1 0x84C1

+#define GL_TEXTURE10 0x84CA

+#define GL_TEXTURE11 0x84CB

+#define GL_TEXTURE12 0x84CC

+#define GL_TEXTURE13 0x84CD

+#define GL_TEXTURE14 0x84CE

+#define GL_TEXTURE15 0x84CF

+#define GL_TEXTURE16 0x84D0

+#define GL_TEXTURE17 0x84D1

+#define GL_TEXTURE18 0x84D2

+#define GL_TEXTURE19 0x84D3

+#define GL_TEXTURE2 0x84C2

+#define GL_TEXTURE20 0x84D4

+#define GL_TEXTURE21 0x84D5

+#define GL_TEXTURE22 0x84D6

+#define GL_TEXTURE23 0x84D7

+#define GL_TEXTURE24 0x84D8

+#define GL_TEXTURE25 0x84D9

+#define GL_TEXTURE26 0x84DA

+#define GL_TEXTURE27 0x84DB

+#define GL_TEXTURE28 0x84DC

+#define GL_TEXTURE29 0x84DD

+#define GL_TEXTURE3 0x84C3

+#define GL_TEXTURE30 0x84DE

+#define GL_TEXTURE31 0x84DF

+#define GL_TEXTURE4 0x84C4

+#define GL_TEXTURE5 0x84C5

+#define GL_TEXTURE6 0x84C6

+#define GL_TEXTURE7 0x84C7

+#define GL_TEXTURE8 0x84C8

+#define GL_TEXTURE9 0x84C9

+/*Copied GL_TEXTURE_BINDING_CUBE_MAP From: ARB_direct_state_access*/

+/*Copied GL_TEXTURE_COMPRESSED From: ARB_internalformat_query2*/

+#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE 0x86A0

+#define GL_TEXTURE_COMPRESSION_HINT 0x84EF

+/*Copied GL_TEXTURE_CUBE_MAP From: ARB_internalformat_query2*/

+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x8516

+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x8518

+#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x851A

+#define GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x8515

+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x8517

+#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x8519

+#define GL_TRANSPOSE_COLOR_MATRIX 0x84E6

+#define GL_TRANSPOSE_MODELVIEW_MATRIX 0x84E3

+#define GL_TRANSPOSE_PROJECTION_MATRIX 0x84E4

+#define GL_TRANSPOSE_TEXTURE_MATRIX 0x84E5

+

+#define GL_BLEND_COLOR 0x8005

+#define GL_BLEND_DST_ALPHA 0x80CA

+#define GL_BLEND_DST_RGB 0x80C8

+#define GL_BLEND_SRC_ALPHA 0x80CB

+#define GL_BLEND_SRC_RGB 0x80C9

+#define GL_COLOR_SUM 0x8458

+#define GL_COMPARE_R_TO_TEXTURE 0x884E

+#define GL_CONSTANT_ALPHA 0x8003

+#define GL_CONSTANT_COLOR 0x8001

+#define GL_CURRENT_FOG_COORDINATE 0x8453

+#define GL_CURRENT_SECONDARY_COLOR 0x8459

+#define GL_DECR_WRAP 0x8508

+#define GL_DEPTH_COMPONENT16 0x81A5

+#define GL_DEPTH_COMPONENT24 0x81A6

+#define GL_DEPTH_COMPONENT32 0x81A7

+#define GL_DEPTH_TEXTURE_MODE 0x884B

+#define GL_FOG_COORDINATE 0x8451

+#define GL_FOG_COORDINATE_ARRAY 0x8457

+#define GL_FOG_COORDINATE_ARRAY_POINTER 0x8456

+#define GL_FOG_COORDINATE_ARRAY_STRIDE 0x8455

+#define GL_FOG_COORDINATE_ARRAY_TYPE 0x8454

+#define GL_FOG_COORDINATE_SOURCE 0x8450

+#define GL_FRAGMENT_DEPTH 0x8452

+#define GL_FUNC_ADD 0x8006

+#define GL_FUNC_REVERSE_SUBTRACT 0x800B

+#define GL_FUNC_SUBTRACT 0x800A

+#define GL_GENERATE_MIPMAP 0x8191

+#define GL_GENERATE_MIPMAP_HINT 0x8192

+#define GL_INCR_WRAP 0x8507

+#define GL_MAX 0x8008

+#define GL_MAX_TEXTURE_LOD_BIAS 0x84FD

+#define GL_MIN 0x8007

+#define GL_MIRRORED_REPEAT 0x8370

+#define GL_ONE_MINUS_CONSTANT_ALPHA 0x8004

+#define GL_ONE_MINUS_CONSTANT_COLOR 0x8002

+#define GL_POINT_DISTANCE_ATTENUATION 0x8129

+#define GL_POINT_FADE_THRESHOLD_SIZE 0x8128

+#define GL_POINT_SIZE_MAX 0x8127

+#define GL_POINT_SIZE_MIN 0x8126

+#define GL_SECONDARY_COLOR_ARRAY 0x845E

+#define GL_SECONDARY_COLOR_ARRAY_POINTER 0x845D

+#define GL_SECONDARY_COLOR_ARRAY_SIZE 0x845A

+#define GL_SECONDARY_COLOR_ARRAY_STRIDE 0x845C

+#define GL_SECONDARY_COLOR_ARRAY_TYPE 0x845B

+#define GL_TEXTURE_COMPARE_FUNC 0x884D

+#define GL_TEXTURE_COMPARE_MODE 0x884C

+#define GL_TEXTURE_DEPTH_SIZE 0x884A

+#define GL_TEXTURE_FILTER_CONTROL 0x8500

+#define GL_TEXTURE_LOD_BIAS 0x8501

+

+#define GL_ARRAY_BUFFER 0x8892

+#define GL_ARRAY_BUFFER_BINDING 0x8894

+#define GL_BUFFER_ACCESS 0x88BB

+#define GL_BUFFER_MAPPED 0x88BC

+#define GL_BUFFER_MAP_POINTER 0x88BD

+#define GL_BUFFER_SIZE 0x8764

+#define GL_BUFFER_USAGE 0x8765

+#define GL_COLOR_ARRAY_BUFFER_BINDING 0x8898

+#define GL_CURRENT_FOG_COORD 0x8453

+#define GL_CURRENT_QUERY 0x8865

+#define GL_DYNAMIC_COPY 0x88EA

+#define GL_DYNAMIC_DRAW 0x88E8

+#define GL_DYNAMIC_READ 0x88E9

+#define GL_EDGE_FLAG_ARRAY_BUFFER_BINDING 0x889B

+#define GL_ELEMENT_ARRAY_BUFFER 0x8893

+#define GL_ELEMENT_ARRAY_BUFFER_BINDING 0x8895

+#define GL_FOG_COORD 0x8451

+#define GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING 0x889D

+#define GL_FOG_COORD_ARRAY 0x8457

+#define GL_FOG_COORD_ARRAY_BUFFER_BINDING 0x889D

+#define GL_FOG_COORD_ARRAY_POINTER 0x8456

+#define GL_FOG_COORD_ARRAY_STRIDE 0x8455

+#define GL_FOG_COORD_ARRAY_TYPE 0x8454

+#define GL_FOG_COORD_SRC 0x8450

+#define GL_INDEX_ARRAY_BUFFER_BINDING 0x8899

+#define GL_NORMAL_ARRAY_BUFFER_BINDING 0x8897

+#define GL_QUERY_COUNTER_BITS 0x8864

+#define GL_QUERY_RESULT 0x8866

+#define GL_QUERY_RESULT_AVAILABLE 0x8867

+#define GL_READ_ONLY 0x88B8

+#define GL_READ_WRITE 0x88BA

+#define GL_SAMPLES_PASSED 0x8914

+#define GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING 0x889C

+#define GL_SRC0_ALPHA 0x8588

+#define GL_SRC0_RGB 0x8580

+#define GL_SRC1_ALPHA 0x8589

+#define GL_SRC1_RGB 0x8581

+#define GL_SRC2_ALPHA 0x858A

+#define GL_SRC2_RGB 0x8582

+#define GL_STATIC_COPY 0x88E6

+#define GL_STATIC_DRAW 0x88E4

+#define GL_STATIC_READ 0x88E5

+#define GL_STREAM_COPY 0x88E2

+#define GL_STREAM_DRAW 0x88E0

+#define GL_STREAM_READ 0x88E1

+#define GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING 0x889A

+#define GL_VERTEX_ARRAY_BUFFER_BINDING 0x8896

+#define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING 0x889F

+#define GL_WEIGHT_ARRAY_BUFFER_BINDING 0x889E

+#define GL_WRITE_ONLY 0x88B9

+

+#define GL_ACTIVE_ATTRIBUTES 0x8B89

+#define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH 0x8B8A

+#define GL_ACTIVE_UNIFORMS 0x8B86

+#define GL_ACTIVE_UNIFORM_MAX_LENGTH 0x8B87

+#define GL_ATTACHED_SHADERS 0x8B85

+#define GL_BLEND_EQUATION_ALPHA 0x883D

+#define GL_BLEND_EQUATION_RGB 0x8009

+#define GL_BOOL 0x8B56

+#define GL_BOOL_VEC2 0x8B57

+#define GL_BOOL_VEC3 0x8B58

+#define GL_BOOL_VEC4 0x8B59

+#define GL_COMPILE_STATUS 0x8B81

+#define GL_COORD_REPLACE 0x8862

+#define GL_CURRENT_PROGRAM 0x8B8D

+#define GL_CURRENT_VERTEX_ATTRIB 0x8626

+#define GL_DELETE_STATUS 0x8B80

+#define GL_DRAW_BUFFER0 0x8825

+#define GL_DRAW_BUFFER1 0x8826

+#define GL_DRAW_BUFFER10 0x882F

+#define GL_DRAW_BUFFER11 0x8830

+#define GL_DRAW_BUFFER12 0x8831

+#define GL_DRAW_BUFFER13 0x8832

+#define GL_DRAW_BUFFER14 0x8833

+#define GL_DRAW_BUFFER15 0x8834

+#define GL_DRAW_BUFFER2 0x8827

+#define GL_DRAW_BUFFER3 0x8828

+#define GL_DRAW_BUFFER4 0x8829

+#define GL_DRAW_BUFFER5 0x882A

+#define GL_DRAW_BUFFER6 0x882B

+#define GL_DRAW_BUFFER7 0x882C

+#define GL_DRAW_BUFFER8 0x882D

+#define GL_DRAW_BUFFER9 0x882E

+#define GL_FLOAT_MAT2 0x8B5A

+#define GL_FLOAT_MAT3 0x8B5B

+#define GL_FLOAT_MAT4 0x8B5C

+#define GL_FLOAT_VEC2 0x8B50

+#define GL_FLOAT_VEC3 0x8B51

+#define GL_FLOAT_VEC4 0x8B52

+#define GL_FRAGMENT_SHADER 0x8B30

+#define GL_FRAGMENT_SHADER_DERIVATIVE_HINT 0x8B8B

+#define GL_INFO_LOG_LENGTH 0x8B84

+#define GL_INT_VEC2 0x8B53

+#define GL_INT_VEC3 0x8B54

+#define GL_INT_VEC4 0x8B55

+#define GL_LINK_STATUS 0x8B82

+/*Copied GL_LOWER_LEFT From: ARB_clip_control*/

+#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 0x8B4D

+#define GL_MAX_DRAW_BUFFERS 0x8824

+#define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS 0x8B49

+#define GL_MAX_TEXTURE_COORDS 0x8871

+#define GL_MAX_TEXTURE_IMAGE_UNITS 0x8872

+#define GL_MAX_VARYING_FLOATS 0x8B4B

+#define GL_MAX_VERTEX_ATTRIBS 0x8869

+#define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS 0x8B4C

+#define GL_MAX_VERTEX_UNIFORM_COMPONENTS 0x8B4A

+#define GL_POINT_SPRITE 0x8861

+#define GL_POINT_SPRITE_COORD_ORIGIN 0x8CA0

+#define GL_SAMPLER_1D 0x8B5D

+#define GL_SAMPLER_1D_SHADOW 0x8B61

+#define GL_SAMPLER_2D 0x8B5E

+#define GL_SAMPLER_2D_SHADOW 0x8B62

+#define GL_SAMPLER_3D 0x8B5F

+#define GL_SAMPLER_CUBE 0x8B60

+#define GL_SHADER_SOURCE_LENGTH 0x8B88

+#define GL_SHADER_TYPE 0x8B4F

+#define GL_SHADING_LANGUAGE_VERSION 0x8B8C

+#define GL_STENCIL_BACK_FAIL 0x8801

+#define GL_STENCIL_BACK_FUNC 0x8800

+#define GL_STENCIL_BACK_PASS_DEPTH_FAIL 0x8802

+#define GL_STENCIL_BACK_PASS_DEPTH_PASS 0x8803

+#define GL_STENCIL_BACK_REF 0x8CA3

+#define GL_STENCIL_BACK_VALUE_MASK 0x8CA4

+#define GL_STENCIL_BACK_WRITEMASK 0x8CA5

+/*Copied GL_UPPER_LEFT From: ARB_clip_control*/

+#define GL_VALIDATE_STATUS 0x8B83

+#define GL_VERTEX_ATTRIB_ARRAY_ENABLED 0x8622

+#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED 0x886A

+#define GL_VERTEX_ATTRIB_ARRAY_POINTER 0x8645

+#define GL_VERTEX_ATTRIB_ARRAY_SIZE 0x8623

+#define GL_VERTEX_ATTRIB_ARRAY_STRIDE 0x8624

+#define GL_VERTEX_ATTRIB_ARRAY_TYPE 0x8625

+#define GL_VERTEX_PROGRAM_POINT_SIZE 0x8642

+#define GL_VERTEX_PROGRAM_TWO_SIDE 0x8643

+#define GL_VERTEX_SHADER 0x8B31

+

+#define GL_COMPRESSED_SLUMINANCE 0x8C4A

+#define GL_COMPRESSED_SLUMINANCE_ALPHA 0x8C4B

+#define GL_COMPRESSED_SRGB 0x8C48

+#define GL_COMPRESSED_SRGB_ALPHA 0x8C49

+#define GL_CURRENT_RASTER_SECONDARY_COLOR 0x845F

+#define GL_FLOAT_MAT2x3 0x8B65

+#define GL_FLOAT_MAT2x4 0x8B66

+#define GL_FLOAT_MAT3x2 0x8B67

+#define GL_FLOAT_MAT3x4 0x8B68

+#define GL_FLOAT_MAT4x2 0x8B69

+#define GL_FLOAT_MAT4x3 0x8B6A

+#define GL_PIXEL_PACK_BUFFER 0x88EB

+#define GL_PIXEL_PACK_BUFFER_BINDING 0x88ED

+#define GL_PIXEL_UNPACK_BUFFER 0x88EC

+#define GL_PIXEL_UNPACK_BUFFER_BINDING 0x88EF

+#define GL_SLUMINANCE 0x8C46

+#define GL_SLUMINANCE8 0x8C47

+#define GL_SLUMINANCE8_ALPHA8 0x8C45

+#define GL_SLUMINANCE_ALPHA 0x8C44

+#define GL_SRGB 0x8C40

+#define GL_SRGB8 0x8C41

+#define GL_SRGB8_ALPHA8 0x8C43

+#define GL_SRGB_ALPHA 0x8C42

+

+#define GL_ALPHA_INTEGER 0x8D97

+#define GL_BGRA_INTEGER 0x8D9B

+#define GL_BGR_INTEGER 0x8D9A

+#define GL_BLUE_INTEGER 0x8D96

+#define GL_BUFFER_ACCESS_FLAGS 0x911F

+#define GL_BUFFER_MAP_LENGTH 0x9120

+#define GL_BUFFER_MAP_OFFSET 0x9121

+#define GL_CLAMP_FRAGMENT_COLOR 0x891B

+#define GL_CLAMP_READ_COLOR 0x891C

+#define GL_CLAMP_VERTEX_COLOR 0x891A

+#define GL_CLIP_DISTANCE0 0x3000

+#define GL_CLIP_DISTANCE1 0x3001

+#define GL_CLIP_DISTANCE2 0x3002

+#define GL_CLIP_DISTANCE3 0x3003

+#define GL_CLIP_DISTANCE4 0x3004

+#define GL_CLIP_DISTANCE5 0x3005

+#define GL_CLIP_DISTANCE6 0x3006

+#define GL_CLIP_DISTANCE7 0x3007

+#define GL_COLOR_ATTACHMENT0 0x8CE0

+#define GL_COLOR_ATTACHMENT1 0x8CE1

+#define GL_COLOR_ATTACHMENT10 0x8CEA

+#define GL_COLOR_ATTACHMENT11 0x8CEB

+#define GL_COLOR_ATTACHMENT12 0x8CEC

+#define GL_COLOR_ATTACHMENT13 0x8CED

+#define GL_COLOR_ATTACHMENT14 0x8CEE

+#define GL_COLOR_ATTACHMENT15 0x8CEF

+#define GL_COLOR_ATTACHMENT16 0x8CF0

+#define GL_COLOR_ATTACHMENT17 0x8CF1

+#define GL_COLOR_ATTACHMENT18 0x8CF2

+#define GL_COLOR_ATTACHMENT19 0x8CF3

+#define GL_COLOR_ATTACHMENT2 0x8CE2

+#define GL_COLOR_ATTACHMENT20 0x8CF4

+#define GL_COLOR_ATTACHMENT21 0x8CF5

+#define GL_COLOR_ATTACHMENT22 0x8CF6

+#define GL_COLOR_ATTACHMENT23 0x8CF7

+#define GL_COLOR_ATTACHMENT24 0x8CF8

+#define GL_COLOR_ATTACHMENT25 0x8CF9

+#define GL_COLOR_ATTACHMENT26 0x8CFA

+#define GL_COLOR_ATTACHMENT27 0x8CFB

+#define GL_COLOR_ATTACHMENT28 0x8CFC

+#define GL_COLOR_ATTACHMENT29 0x8CFD

+#define GL_COLOR_ATTACHMENT3 0x8CE3

+#define GL_COLOR_ATTACHMENT30 0x8CFE

+#define GL_COLOR_ATTACHMENT31 0x8CFF

+#define GL_COLOR_ATTACHMENT4 0x8CE4

+#define GL_COLOR_ATTACHMENT5 0x8CE5

+#define GL_COLOR_ATTACHMENT6 0x8CE6

+#define GL_COLOR_ATTACHMENT7 0x8CE7

+#define GL_COLOR_ATTACHMENT8 0x8CE8

+#define GL_COLOR_ATTACHMENT9 0x8CE9

+#define GL_COMPARE_REF_TO_TEXTURE 0x884E

+#define GL_COMPRESSED_RED 0x8225

+#define GL_COMPRESSED_RED_RGTC1 0x8DBB

+#define GL_COMPRESSED_RG 0x8226

+#define GL_COMPRESSED_RG_RGTC2 0x8DBD

+#define GL_COMPRESSED_SIGNED_RED_RGTC1 0x8DBC

+#define GL_COMPRESSED_SIGNED_RG_RGTC2 0x8DBE

+#define GL_CONTEXT_FLAGS 0x821E

+#define GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT 0x00000001

+#define GL_DEPTH24_STENCIL8 0x88F0

+#define GL_DEPTH32F_STENCIL8 0x8CAD

+#define GL_DEPTH_ATTACHMENT 0x8D00

+#define GL_DEPTH_COMPONENT32F 0x8CAC

+#define GL_DEPTH_STENCIL 0x84F9

+#define GL_DEPTH_STENCIL_ATTACHMENT 0x821A

+#define GL_DRAW_FRAMEBUFFER 0x8CA9

+#define GL_DRAW_FRAMEBUFFER_BINDING 0x8CA6

+#define GL_FIXED_ONLY 0x891D

+#define GL_FLOAT_32_UNSIGNED_INT_24_8_REV 0x8DAD

+#define GL_FRAMEBUFFER 0x8D40

+#define GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE 0x8215

+#define GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE 0x8214

+#define GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING 0x8210

+#define GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE 0x8211

+#define GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE 0x8216

+#define GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE 0x8213

+#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME 0x8CD1

+#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE 0x8CD0

+#define GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE 0x8212

+#define GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE 0x8217

+#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE 0x8CD3

+#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER 0x8CD4

+#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL 0x8CD2

+#define GL_FRAMEBUFFER_BINDING 0x8CA6

+#define GL_FRAMEBUFFER_COMPLETE 0x8CD5

+#define GL_FRAMEBUFFER_DEFAULT 0x8218

+#define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT 0x8CD6

+#define GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER 0x8CDB

+#define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT 0x8CD7

+#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE 0x8D56

+#define GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER 0x8CDC

+#define GL_FRAMEBUFFER_SRGB 0x8DB9

+#define GL_FRAMEBUFFER_UNDEFINED 0x8219

+#define GL_FRAMEBUFFER_UNSUPPORTED 0x8CDD

+#define GL_GREEN_INTEGER 0x8D95

+#define GL_HALF_FLOAT 0x140B

+#define GL_INTERLEAVED_ATTRIBS 0x8C8C

+#define GL_INT_SAMPLER_1D 0x8DC9

+#define GL_INT_SAMPLER_1D_ARRAY 0x8DCE

+#define GL_INT_SAMPLER_2D 0x8DCA

+#define GL_INT_SAMPLER_2D_ARRAY 0x8DCF

+#define GL_INT_SAMPLER_3D 0x8DCB

+#define GL_INT_SAMPLER_CUBE 0x8DCC

+#define GL_INVALID_FRAMEBUFFER_OPERATION 0x0506

+#define GL_MAJOR_VERSION 0x821B

+#define GL_MAP_FLUSH_EXPLICIT_BIT 0x0010

+#define GL_MAP_INVALIDATE_BUFFER_BIT 0x0008

+#define GL_MAP_INVALIDATE_RANGE_BIT 0x0004

+/*Copied GL_MAP_READ_BIT From: ARB_buffer_storage*/

+#define GL_MAP_UNSYNCHRONIZED_BIT 0x0020

+/*Copied GL_MAP_WRITE_BIT From: ARB_buffer_storage*/

+#define GL_MAX_ARRAY_TEXTURE_LAYERS 0x88FF

+#define GL_MAX_CLIP_DISTANCES 0x0D32

+#define GL_MAX_COLOR_ATTACHMENTS 0x8CDF

+#define GL_MAX_PROGRAM_TEXEL_OFFSET 0x8905

+#define GL_MAX_RENDERBUFFER_SIZE 0x84E8

+#define GL_MAX_SAMPLES 0x8D57

+#define GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS 0x8C8A

+#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS 0x8C8B

+#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS 0x8C80

+#define GL_MAX_VARYING_COMPONENTS 0x8B4B

+#define GL_MINOR_VERSION 0x821C

+#define GL_MIN_PROGRAM_TEXEL_OFFSET 0x8904

+#define GL_NUM_EXTENSIONS 0x821D

+#define GL_PRIMITIVES_GENERATED 0x8C87

+#define GL_PROXY_TEXTURE_1D_ARRAY 0x8C19

+#define GL_PROXY_TEXTURE_2D_ARRAY 0x8C1B

+#define GL_QUERY_BY_REGION_NO_WAIT 0x8E16

+#define GL_QUERY_BY_REGION_WAIT 0x8E15

+#define GL_QUERY_NO_WAIT 0x8E14

+#define GL_QUERY_WAIT 0x8E13

+#define GL_R11F_G11F_B10F 0x8C3A

+#define GL_R16 0x822A

+#define GL_R16F 0x822D

+#define GL_R16I 0x8233

+#define GL_R16UI 0x8234

+#define GL_R32F 0x822E

+#define GL_R32I 0x8235

+#define GL_R32UI 0x8236

+#define GL_R8 0x8229

+#define GL_R8I 0x8231

+#define GL_R8UI 0x8232

+#define GL_RASTERIZER_DISCARD 0x8C89

+#define GL_READ_FRAMEBUFFER 0x8CA8

+#define GL_READ_FRAMEBUFFER_BINDING 0x8CAA

+#define GL_RED_INTEGER 0x8D94

+/*Copied GL_RENDERBUFFER From: ARB_internalformat_query2*/

+#define GL_RENDERBUFFER_ALPHA_SIZE 0x8D53

+#define GL_RENDERBUFFER_BINDING 0x8CA7

+#define GL_RENDERBUFFER_BLUE_SIZE 0x8D52

+#define GL_RENDERBUFFER_DEPTH_SIZE 0x8D54

+#define GL_RENDERBUFFER_GREEN_SIZE 0x8D51

+#define GL_RENDERBUFFER_HEIGHT 0x8D43

+#define GL_RENDERBUFFER_INTERNAL_FORMAT 0x8D44

+#define GL_RENDERBUFFER_RED_SIZE 0x8D50

+#define GL_RENDERBUFFER_SAMPLES 0x8CAB

+#define GL_RENDERBUFFER_STENCIL_SIZE 0x8D55

+#define GL_RENDERBUFFER_WIDTH 0x8D42

+#define GL_RG 0x8227

+#define GL_RG16 0x822C

+#define GL_RG16F 0x822F

+#define GL_RG16I 0x8239

+#define GL_RG16UI 0x823A

+#define GL_RG32F 0x8230

+#define GL_RG32I 0x823B

+#define GL_RG32UI 0x823C

+#define GL_RG8 0x822B

+#define GL_RG8I 0x8237

+#define GL_RG8UI 0x8238

+#define GL_RGB16F 0x881B

+#define GL_RGB16I 0x8D89

+#define GL_RGB16UI 0x8D77

+#define GL_RGB32F 0x8815

+#define GL_RGB32I 0x8D83

+#define GL_RGB32UI 0x8D71

+#define GL_RGB8I 0x8D8F

+#define GL_RGB8UI 0x8D7D

+#define GL_RGB9_E5 0x8C3D

+#define GL_RGBA16F 0x881A

+#define GL_RGBA16I 0x8D88

+#define GL_RGBA16UI 0x8D76

+#define GL_RGBA32F 0x8814

+#define GL_RGBA32I 0x8D82

+#define GL_RGBA32UI 0x8D70

+#define GL_RGBA8I 0x8D8E

+#define GL_RGBA8UI 0x8D7C

+#define GL_RGBA_INTEGER 0x8D99

+#define GL_RGB_INTEGER 0x8D98

+#define GL_RG_INTEGER 0x8228

+#define GL_SAMPLER_1D_ARRAY 0x8DC0

+#define GL_SAMPLER_1D_ARRAY_SHADOW 0x8DC3

+#define GL_SAMPLER_2D_ARRAY 0x8DC1

+#define GL_SAMPLER_2D_ARRAY_SHADOW 0x8DC4

+#define GL_SAMPLER_CUBE_SHADOW 0x8DC5

+#define GL_SEPARATE_ATTRIBS 0x8C8D

+#define GL_STENCIL_ATTACHMENT 0x8D20

+#define GL_STENCIL_INDEX1 0x8D46

+#define GL_STENCIL_INDEX16 0x8D49

+#define GL_STENCIL_INDEX4 0x8D47

+/*Copied GL_STENCIL_INDEX8 From: ARB_texture_stencil8*/

+/*Copied GL_TEXTURE_1D_ARRAY From: ARB_internalformat_query2*/

+/*Copied GL_TEXTURE_2D_ARRAY From: ARB_internalformat_query2*/

+#define GL_TEXTURE_ALPHA_TYPE 0x8C13

+/*Copied GL_TEXTURE_BINDING_1D_ARRAY From: ARB_direct_state_access*/

+/*Copied GL_TEXTURE_BINDING_2D_ARRAY From: ARB_direct_state_access*/

+#define GL_TEXTURE_BLUE_TYPE 0x8C12

+#define GL_TEXTURE_DEPTH_TYPE 0x8C16

+#define GL_TEXTURE_GREEN_TYPE 0x8C11

+#define GL_TEXTURE_RED_TYPE 0x8C10

+#define GL_TEXTURE_SHARED_SIZE 0x8C3F

+#define GL_TEXTURE_STENCIL_SIZE 0x88F1

+/*Copied GL_TRANSFORM_FEEDBACK_BUFFER From: ARB_enhanced_layouts*/

+#define GL_TRANSFORM_FEEDBACK_BUFFER_BINDING 0x8C8F

+#define GL_TRANSFORM_FEEDBACK_BUFFER_MODE 0x8C7F

+#define GL_TRANSFORM_FEEDBACK_BUFFER_SIZE 0x8C85

+#define GL_TRANSFORM_FEEDBACK_BUFFER_START 0x8C84

+#define GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN 0x8C88

+#define GL_TRANSFORM_FEEDBACK_VARYINGS 0x8C83

+#define GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH 0x8C76

+/*Copied GL_UNSIGNED_INT_10F_11F_11F_REV From: ARB_vertex_type_10f_11f_11f_rev*/

+#define GL_UNSIGNED_INT_24_8 0x84FA

+#define GL_UNSIGNED_INT_5_9_9_9_REV 0x8C3E

+#define GL_UNSIGNED_INT_SAMPLER_1D 0x8DD1

+#define GL_UNSIGNED_INT_SAMPLER_1D_ARRAY 0x8DD6

+#define GL_UNSIGNED_INT_SAMPLER_2D 0x8DD2

+#define GL_UNSIGNED_INT_SAMPLER_2D_ARRAY 0x8DD7

+#define GL_UNSIGNED_INT_SAMPLER_3D 0x8DD3

+#define GL_UNSIGNED_INT_SAMPLER_CUBE 0x8DD4

+#define GL_UNSIGNED_INT_VEC2 0x8DC6

+#define GL_UNSIGNED_INT_VEC3 0x8DC7

+#define GL_UNSIGNED_INT_VEC4 0x8DC8

+#define GL_UNSIGNED_NORMALIZED 0x8C17

+#define GL_VERTEX_ARRAY_BINDING 0x85B5

+#define GL_VERTEX_ATTRIB_ARRAY_INTEGER 0x88FD

+

+#define GL_ACTIVE_UNIFORM_BLOCKS 0x8A36

+#define GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH 0x8A35

+#define GL_COPY_READ_BUFFER 0x8F36

+#define GL_COPY_WRITE_BUFFER 0x8F37

+#define GL_INT_SAMPLER_2D_RECT 0x8DCD

+#define GL_INT_SAMPLER_BUFFER 0x8DD0

+#define GL_INVALID_INDEX 0xFFFFFFFF

+#define GL_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS 0x8A33

+#define GL_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS 0x8A32

+#define GL_MAX_COMBINED_UNIFORM_BLOCKS 0x8A2E

+#define GL_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS 0x8A31

+#define GL_MAX_FRAGMENT_UNIFORM_BLOCKS 0x8A2D

+#define GL_MAX_GEOMETRY_UNIFORM_BLOCKS 0x8A2C

+#define GL_MAX_RECTANGLE_TEXTURE_SIZE 0x84F8

+#define GL_MAX_TEXTURE_BUFFER_SIZE 0x8C2B

+#define GL_MAX_UNIFORM_BLOCK_SIZE 0x8A30

+#define GL_MAX_UNIFORM_BUFFER_BINDINGS 0x8A2F

+#define GL_MAX_VERTEX_UNIFORM_BLOCKS 0x8A2B

+#define GL_PRIMITIVE_RESTART 0x8F9D

+#define GL_PRIMITIVE_RESTART_INDEX 0x8F9E

+#define GL_PROXY_TEXTURE_RECTANGLE 0x84F7

+#define GL_R16_SNORM 0x8F98

+#define GL_R8_SNORM 0x8F94

+#define GL_RG16_SNORM 0x8F99

+#define GL_RG8_SNORM 0x8F95

+#define GL_RGB16_SNORM 0x8F9A

+#define GL_RGB8_SNORM 0x8F96

+#define GL_RGBA16_SNORM 0x8F9B

+#define GL_RGBA8_SNORM 0x8F97

+#define GL_SAMPLER_2D_RECT 0x8B63

+#define GL_SAMPLER_2D_RECT_SHADOW 0x8B64

+#define GL_SAMPLER_BUFFER 0x8DC2

+#define GL_SIGNED_NORMALIZED 0x8F9C

+/*Copied GL_TEXTURE_BINDING_BUFFER From: ARB_direct_state_access*/

+/*Copied GL_TEXTURE_BINDING_RECTANGLE From: ARB_direct_state_access*/

+/*Copied GL_TEXTURE_BUFFER From: ARB_internalformat_query2*/

+#define GL_TEXTURE_BUFFER_DATA_STORE_BINDING 0x8C2D

+/*Copied GL_TEXTURE_RECTANGLE From: ARB_internalformat_query2*/

+#define GL_UNIFORM_ARRAY_STRIDE 0x8A3C

+#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORMS 0x8A42

+#define GL_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES 0x8A43

+#define GL_UNIFORM_BLOCK_BINDING 0x8A3F

+#define GL_UNIFORM_BLOCK_DATA_SIZE 0x8A40

+#define GL_UNIFORM_BLOCK_INDEX 0x8A3A

+#define GL_UNIFORM_BLOCK_NAME_LENGTH 0x8A41

+#define GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER 0x8A46

+#define GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER 0x8A45

+#define GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER 0x8A44

+#define GL_UNIFORM_BUFFER 0x8A11

+#define GL_UNIFORM_BUFFER_BINDING 0x8A28

+#define GL_UNIFORM_BUFFER_OFFSET_ALIGNMENT 0x8A34

+#define GL_UNIFORM_BUFFER_SIZE 0x8A2A

+#define GL_UNIFORM_BUFFER_START 0x8A29

+#define GL_UNIFORM_IS_ROW_MAJOR 0x8A3E

+#define GL_UNIFORM_MATRIX_STRIDE 0x8A3D

+#define GL_UNIFORM_NAME_LENGTH 0x8A39

+#define GL_UNIFORM_OFFSET 0x8A3B

+#define GL_UNIFORM_SIZE 0x8A38

+#define GL_UNIFORM_TYPE 0x8A37

+#define GL_UNSIGNED_INT_SAMPLER_2D_RECT 0x8DD5

+#define GL_UNSIGNED_INT_SAMPLER_BUFFER 0x8DD8

+

+

+

+#ifndef GL_ARB_ES2_compatibility

+#define GL_ARB_ES2_compatibility 1

+extern void (CODEGEN_FUNCPTR *_ptrc_glClearDepthf)(GLfloat d);

+#define glClearDepthf _ptrc_glClearDepthf

+extern void (CODEGEN_FUNCPTR *_ptrc_glDepthRangef)(GLfloat n, GLfloat f);

+#define glDepthRangef _ptrc_glDepthRangef

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetShaderPrecisionFormat)(GLenum shadertype, GLenum precisiontype, GLint * range, GLint * precision);

+#define glGetShaderPrecisionFormat _ptrc_glGetShaderPrecisionFormat

+extern void (CODEGEN_FUNCPTR *_ptrc_glReleaseShaderCompiler)(void);

+#define glReleaseShaderCompiler _ptrc_glReleaseShaderCompiler

+extern void (CODEGEN_FUNCPTR *_ptrc_glShaderBinary)(GLsizei count, const GLuint * shaders, GLenum binaryformat, const void * binary, GLsizei length);

+#define glShaderBinary _ptrc_glShaderBinary

+#endif /*GL_ARB_ES2_compatibility*/ 

+

+#ifndef GL_ARB_get_program_binary

+#define GL_ARB_get_program_binary 1

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetProgramBinary)(GLuint program, GLsizei bufSize, GLsizei * length, GLenum * binaryFormat, void * binary);

+#define glGetProgramBinary _ptrc_glGetProgramBinary

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramBinary)(GLuint program, GLenum binaryFormat, const void * binary, GLsizei length);

+#define glProgramBinary _ptrc_glProgramBinary

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramParameteri)(GLuint program, GLenum pname, GLint value);

+#define glProgramParameteri _ptrc_glProgramParameteri

+#endif /*GL_ARB_get_program_binary*/ 

+

+

+#ifndef GL_ARB_internalformat_query

+#define GL_ARB_internalformat_query 1

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetInternalformativ)(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint * params);

+#define glGetInternalformativ _ptrc_glGetInternalformativ

+#endif /*GL_ARB_internalformat_query*/ 

+

+#ifndef GL_ARB_internalformat_query2

+#define GL_ARB_internalformat_query2 1

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetInternalformati64v)(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint64 * params);

+#define glGetInternalformati64v _ptrc_glGetInternalformati64v

+#endif /*GL_ARB_internalformat_query2*/ 

+

+

+#ifndef GL_ARB_program_interface_query

+#define GL_ARB_program_interface_query 1

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetProgramInterfaceiv)(GLuint program, GLenum programInterface, GLenum pname, GLint * params);

+#define glGetProgramInterfaceiv _ptrc_glGetProgramInterfaceiv

+extern GLuint (CODEGEN_FUNCPTR *_ptrc_glGetProgramResourceIndex)(GLuint program, GLenum programInterface, const GLchar * name);

+#define glGetProgramResourceIndex _ptrc_glGetProgramResourceIndex

+extern GLint (CODEGEN_FUNCPTR *_ptrc_glGetProgramResourceLocation)(GLuint program, GLenum programInterface, const GLchar * name);

+#define glGetProgramResourceLocation _ptrc_glGetProgramResourceLocation

+extern GLint (CODEGEN_FUNCPTR *_ptrc_glGetProgramResourceLocationIndex)(GLuint program, GLenum programInterface, const GLchar * name);

+#define glGetProgramResourceLocationIndex _ptrc_glGetProgramResourceLocationIndex

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetProgramResourceName)(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei * length, GLchar * name);

+#define glGetProgramResourceName _ptrc_glGetProgramResourceName

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetProgramResourceiv)(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum * props, GLsizei bufSize, GLsizei * length, GLint * params);

+#define glGetProgramResourceiv _ptrc_glGetProgramResourceiv

+#endif /*GL_ARB_program_interface_query*/ 

+

+#ifndef GL_ARB_separate_shader_objects

+#define GL_ARB_separate_shader_objects 1

+extern void (CODEGEN_FUNCPTR *_ptrc_glActiveShaderProgram)(GLuint pipeline, GLuint program);

+#define glActiveShaderProgram _ptrc_glActiveShaderProgram

+extern void (CODEGEN_FUNCPTR *_ptrc_glBindProgramPipeline)(GLuint pipeline);

+#define glBindProgramPipeline _ptrc_glBindProgramPipeline

+extern GLuint (CODEGEN_FUNCPTR *_ptrc_glCreateShaderProgramv)(GLenum type, GLsizei count, const GLchar *const* strings);

+#define glCreateShaderProgramv _ptrc_glCreateShaderProgramv

+extern void (CODEGEN_FUNCPTR *_ptrc_glDeleteProgramPipelines)(GLsizei n, const GLuint * pipelines);

+#define glDeleteProgramPipelines _ptrc_glDeleteProgramPipelines

+extern void (CODEGEN_FUNCPTR *_ptrc_glGenProgramPipelines)(GLsizei n, GLuint * pipelines);

+#define glGenProgramPipelines _ptrc_glGenProgramPipelines

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetProgramPipelineInfoLog)(GLuint pipeline, GLsizei bufSize, GLsizei * length, GLchar * infoLog);

+#define glGetProgramPipelineInfoLog _ptrc_glGetProgramPipelineInfoLog

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetProgramPipelineiv)(GLuint pipeline, GLenum pname, GLint * params);

+#define glGetProgramPipelineiv _ptrc_glGetProgramPipelineiv

+extern GLboolean (CODEGEN_FUNCPTR *_ptrc_glIsProgramPipeline)(GLuint pipeline);

+#define glIsProgramPipeline _ptrc_glIsProgramPipeline

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform1d)(GLuint program, GLint location, GLdouble v0);

+#define glProgramUniform1d _ptrc_glProgramUniform1d

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform1dv)(GLuint program, GLint location, GLsizei count, const GLdouble * value);

+#define glProgramUniform1dv _ptrc_glProgramUniform1dv

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform1f)(GLuint program, GLint location, GLfloat v0);

+#define glProgramUniform1f _ptrc_glProgramUniform1f

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform1fv)(GLuint program, GLint location, GLsizei count, const GLfloat * value);

+#define glProgramUniform1fv _ptrc_glProgramUniform1fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform1i)(GLuint program, GLint location, GLint v0);

+#define glProgramUniform1i _ptrc_glProgramUniform1i

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform1iv)(GLuint program, GLint location, GLsizei count, const GLint * value);

+#define glProgramUniform1iv _ptrc_glProgramUniform1iv

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform1ui)(GLuint program, GLint location, GLuint v0);

+#define glProgramUniform1ui _ptrc_glProgramUniform1ui

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform1uiv)(GLuint program, GLint location, GLsizei count, const GLuint * value);

+#define glProgramUniform1uiv _ptrc_glProgramUniform1uiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform2d)(GLuint program, GLint location, GLdouble v0, GLdouble v1);

+#define glProgramUniform2d _ptrc_glProgramUniform2d

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform2dv)(GLuint program, GLint location, GLsizei count, const GLdouble * value);

+#define glProgramUniform2dv _ptrc_glProgramUniform2dv

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform2f)(GLuint program, GLint location, GLfloat v0, GLfloat v1);

+#define glProgramUniform2f _ptrc_glProgramUniform2f

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform2fv)(GLuint program, GLint location, GLsizei count, const GLfloat * value);

+#define glProgramUniform2fv _ptrc_glProgramUniform2fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform2i)(GLuint program, GLint location, GLint v0, GLint v1);

+#define glProgramUniform2i _ptrc_glProgramUniform2i

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform2iv)(GLuint program, GLint location, GLsizei count, const GLint * value);

+#define glProgramUniform2iv _ptrc_glProgramUniform2iv

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform2ui)(GLuint program, GLint location, GLuint v0, GLuint v1);

+#define glProgramUniform2ui _ptrc_glProgramUniform2ui

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform2uiv)(GLuint program, GLint location, GLsizei count, const GLuint * value);

+#define glProgramUniform2uiv _ptrc_glProgramUniform2uiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform3d)(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2);

+#define glProgramUniform3d _ptrc_glProgramUniform3d

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform3dv)(GLuint program, GLint location, GLsizei count, const GLdouble * value);

+#define glProgramUniform3dv _ptrc_glProgramUniform3dv

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform3f)(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2);

+#define glProgramUniform3f _ptrc_glProgramUniform3f

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform3fv)(GLuint program, GLint location, GLsizei count, const GLfloat * value);

+#define glProgramUniform3fv _ptrc_glProgramUniform3fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform3i)(GLuint program, GLint location, GLint v0, GLint v1, GLint v2);

+#define glProgramUniform3i _ptrc_glProgramUniform3i

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform3iv)(GLuint program, GLint location, GLsizei count, const GLint * value);

+#define glProgramUniform3iv _ptrc_glProgramUniform3iv

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform3ui)(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2);

+#define glProgramUniform3ui _ptrc_glProgramUniform3ui

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform3uiv)(GLuint program, GLint location, GLsizei count, const GLuint * value);

+#define glProgramUniform3uiv _ptrc_glProgramUniform3uiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform4d)(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3);

+#define glProgramUniform4d _ptrc_glProgramUniform4d

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform4dv)(GLuint program, GLint location, GLsizei count, const GLdouble * value);

+#define glProgramUniform4dv _ptrc_glProgramUniform4dv

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform4f)(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);

+#define glProgramUniform4f _ptrc_glProgramUniform4f

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform4fv)(GLuint program, GLint location, GLsizei count, const GLfloat * value);

+#define glProgramUniform4fv _ptrc_glProgramUniform4fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform4i)(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3);

+#define glProgramUniform4i _ptrc_glProgramUniform4i

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform4iv)(GLuint program, GLint location, GLsizei count, const GLint * value);

+#define glProgramUniform4iv _ptrc_glProgramUniform4iv

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform4ui)(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);

+#define glProgramUniform4ui _ptrc_glProgramUniform4ui

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniform4uiv)(GLuint program, GLint location, GLsizei count, const GLuint * value);

+#define glProgramUniform4uiv _ptrc_glProgramUniform4uiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniformMatrix2dv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value);

+#define glProgramUniformMatrix2dv _ptrc_glProgramUniformMatrix2dv

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniformMatrix2fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);

+#define glProgramUniformMatrix2fv _ptrc_glProgramUniformMatrix2fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniformMatrix2x3dv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value);

+#define glProgramUniformMatrix2x3dv _ptrc_glProgramUniformMatrix2x3dv

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniformMatrix2x3fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);

+#define glProgramUniformMatrix2x3fv _ptrc_glProgramUniformMatrix2x3fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniformMatrix2x4dv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value);

+#define glProgramUniformMatrix2x4dv _ptrc_glProgramUniformMatrix2x4dv

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniformMatrix2x4fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);

+#define glProgramUniformMatrix2x4fv _ptrc_glProgramUniformMatrix2x4fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniformMatrix3dv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value);

+#define glProgramUniformMatrix3dv _ptrc_glProgramUniformMatrix3dv

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniformMatrix3fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);

+#define glProgramUniformMatrix3fv _ptrc_glProgramUniformMatrix3fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniformMatrix3x2dv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value);

+#define glProgramUniformMatrix3x2dv _ptrc_glProgramUniformMatrix3x2dv

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniformMatrix3x2fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);

+#define glProgramUniformMatrix3x2fv _ptrc_glProgramUniformMatrix3x2fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniformMatrix3x4dv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value);

+#define glProgramUniformMatrix3x4dv _ptrc_glProgramUniformMatrix3x4dv

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniformMatrix3x4fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);

+#define glProgramUniformMatrix3x4fv _ptrc_glProgramUniformMatrix3x4fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniformMatrix4dv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value);

+#define glProgramUniformMatrix4dv _ptrc_glProgramUniformMatrix4dv

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniformMatrix4fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);

+#define glProgramUniformMatrix4fv _ptrc_glProgramUniformMatrix4fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniformMatrix4x2dv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value);

+#define glProgramUniformMatrix4x2dv _ptrc_glProgramUniformMatrix4x2dv

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniformMatrix4x2fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);

+#define glProgramUniformMatrix4x2fv _ptrc_glProgramUniformMatrix4x2fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniformMatrix4x3dv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble * value);

+#define glProgramUniformMatrix4x3dv _ptrc_glProgramUniformMatrix4x3dv

+extern void (CODEGEN_FUNCPTR *_ptrc_glProgramUniformMatrix4x3fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);

+#define glProgramUniformMatrix4x3fv _ptrc_glProgramUniformMatrix4x3fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glUseProgramStages)(GLuint pipeline, GLbitfield stages, GLuint program);

+#define glUseProgramStages _ptrc_glUseProgramStages

+extern void (CODEGEN_FUNCPTR *_ptrc_glValidateProgramPipeline)(GLuint pipeline);

+#define glValidateProgramPipeline _ptrc_glValidateProgramPipeline

+#endif /*GL_ARB_separate_shader_objects*/ 

+

+

+

+#ifndef GL_ARB_texture_buffer_range

+#define GL_ARB_texture_buffer_range 1

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexBufferRange)(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size);

+#define glTexBufferRange _ptrc_glTexBufferRange

+#endif /*GL_ARB_texture_buffer_range*/ 

+

+#ifndef GL_ARB_texture_storage

+#define GL_ARB_texture_storage 1

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexStorage1D)(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width);

+#define glTexStorage1D _ptrc_glTexStorage1D

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexStorage2D)(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);

+#define glTexStorage2D _ptrc_glTexStorage2D

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexStorage3D)(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);

+#define glTexStorage3D _ptrc_glTexStorage3D

+#endif /*GL_ARB_texture_storage*/ 

+

+#ifndef GL_ARB_texture_view

+#define GL_ARB_texture_view 1

+extern void (CODEGEN_FUNCPTR *_ptrc_glTextureView)(GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers);

+#define glTextureView _ptrc_glTextureView

+#endif /*GL_ARB_texture_view*/ 

+

+#ifndef GL_ARB_vertex_attrib_binding

+#define GL_ARB_vertex_attrib_binding 1

+extern void (CODEGEN_FUNCPTR *_ptrc_glBindVertexBuffer)(GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride);

+#define glBindVertexBuffer _ptrc_glBindVertexBuffer

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribBinding)(GLuint attribindex, GLuint bindingindex);

+#define glVertexAttribBinding _ptrc_glVertexAttribBinding

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribFormat)(GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset);

+#define glVertexAttribFormat _ptrc_glVertexAttribFormat

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribIFormat)(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);

+#define glVertexAttribIFormat _ptrc_glVertexAttribIFormat

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribLFormat)(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);

+#define glVertexAttribLFormat _ptrc_glVertexAttribLFormat

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexBindingDivisor)(GLuint bindingindex, GLuint divisor);

+#define glVertexBindingDivisor _ptrc_glVertexBindingDivisor

+#endif /*GL_ARB_vertex_attrib_binding*/ 

+

+#ifndef GL_ARB_viewport_array

+#define GL_ARB_viewport_array 1

+extern void (CODEGEN_FUNCPTR *_ptrc_glDepthRangeArrayv)(GLuint first, GLsizei count, const GLdouble * v);

+#define glDepthRangeArrayv _ptrc_glDepthRangeArrayv

+extern void (CODEGEN_FUNCPTR *_ptrc_glDepthRangeIndexed)(GLuint index, GLdouble n, GLdouble f);

+#define glDepthRangeIndexed _ptrc_glDepthRangeIndexed

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetDoublei_v)(GLenum target, GLuint index, GLdouble * data);

+#define glGetDoublei_v _ptrc_glGetDoublei_v

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetFloati_v)(GLenum target, GLuint index, GLfloat * data);

+#define glGetFloati_v _ptrc_glGetFloati_v

+extern void (CODEGEN_FUNCPTR *_ptrc_glScissorArrayv)(GLuint first, GLsizei count, const GLint * v);

+#define glScissorArrayv _ptrc_glScissorArrayv

+extern void (CODEGEN_FUNCPTR *_ptrc_glScissorIndexed)(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height);

+#define glScissorIndexed _ptrc_glScissorIndexed

+extern void (CODEGEN_FUNCPTR *_ptrc_glScissorIndexedv)(GLuint index, const GLint * v);

+#define glScissorIndexedv _ptrc_glScissorIndexedv

+extern void (CODEGEN_FUNCPTR *_ptrc_glViewportArrayv)(GLuint first, GLsizei count, const GLfloat * v);

+#define glViewportArrayv _ptrc_glViewportArrayv

+extern void (CODEGEN_FUNCPTR *_ptrc_glViewportIndexedf)(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h);

+#define glViewportIndexedf _ptrc_glViewportIndexedf

+extern void (CODEGEN_FUNCPTR *_ptrc_glViewportIndexedfv)(GLuint index, const GLfloat * v);

+#define glViewportIndexedfv _ptrc_glViewportIndexedfv

+#endif /*GL_ARB_viewport_array*/ 

+

+

+#ifndef GL_ARB_clear_buffer_object

+#define GL_ARB_clear_buffer_object 1

+extern void (CODEGEN_FUNCPTR *_ptrc_glClearBufferData)(GLenum target, GLenum internalformat, GLenum format, GLenum type, const void * data);

+#define glClearBufferData _ptrc_glClearBufferData

+extern void (CODEGEN_FUNCPTR *_ptrc_glClearBufferSubData)(GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void * data);

+#define glClearBufferSubData _ptrc_glClearBufferSubData

+#endif /*GL_ARB_clear_buffer_object*/ 

+

+#ifndef GL_ARB_copy_image

+#define GL_ARB_copy_image 1

+extern void (CODEGEN_FUNCPTR *_ptrc_glCopyImageSubData)(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);

+#define glCopyImageSubData _ptrc_glCopyImageSubData

+#endif /*GL_ARB_copy_image*/ 

+

+

+

+#ifndef GL_ARB_framebuffer_no_attachments

+#define GL_ARB_framebuffer_no_attachments 1

+extern void (CODEGEN_FUNCPTR *_ptrc_glFramebufferParameteri)(GLenum target, GLenum pname, GLint param);

+#define glFramebufferParameteri _ptrc_glFramebufferParameteri

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetFramebufferParameteriv)(GLenum target, GLenum pname, GLint * params);

+#define glGetFramebufferParameteriv _ptrc_glGetFramebufferParameteriv

+#endif /*GL_ARB_framebuffer_no_attachments*/ 

+

+#ifndef GL_ARB_invalidate_subdata

+#define GL_ARB_invalidate_subdata 1

+extern void (CODEGEN_FUNCPTR *_ptrc_glInvalidateBufferData)(GLuint buffer);

+#define glInvalidateBufferData _ptrc_glInvalidateBufferData

+extern void (CODEGEN_FUNCPTR *_ptrc_glInvalidateBufferSubData)(GLuint buffer, GLintptr offset, GLsizeiptr length);

+#define glInvalidateBufferSubData _ptrc_glInvalidateBufferSubData

+extern void (CODEGEN_FUNCPTR *_ptrc_glInvalidateFramebuffer)(GLenum target, GLsizei numAttachments, const GLenum * attachments);

+#define glInvalidateFramebuffer _ptrc_glInvalidateFramebuffer

+extern void (CODEGEN_FUNCPTR *_ptrc_glInvalidateSubFramebuffer)(GLenum target, GLsizei numAttachments, const GLenum * attachments, GLint x, GLint y, GLsizei width, GLsizei height);

+#define glInvalidateSubFramebuffer _ptrc_glInvalidateSubFramebuffer

+extern void (CODEGEN_FUNCPTR *_ptrc_glInvalidateTexImage)(GLuint texture, GLint level);

+#define glInvalidateTexImage _ptrc_glInvalidateTexImage

+extern void (CODEGEN_FUNCPTR *_ptrc_glInvalidateTexSubImage)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth);

+#define glInvalidateTexSubImage _ptrc_glInvalidateTexSubImage

+#endif /*GL_ARB_invalidate_subdata*/ 

+

+

+

+

+#ifndef GL_ARB_texture_storage_multisample

+#define GL_ARB_texture_storage_multisample 1

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexStorage2DMultisample)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);

+#define glTexStorage2DMultisample _ptrc_glTexStorage2DMultisample

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexStorage3DMultisample)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);

+#define glTexStorage3DMultisample _ptrc_glTexStorage3DMultisample

+#endif /*GL_ARB_texture_storage_multisample*/ 

+

+#ifndef GL_KHR_debug

+#define GL_KHR_debug 1

+extern void (CODEGEN_FUNCPTR *_ptrc_glDebugMessageCallback)(GLDEBUGPROC callback, const void * userParam);

+#define glDebugMessageCallback _ptrc_glDebugMessageCallback

+extern void (CODEGEN_FUNCPTR *_ptrc_glDebugMessageControl)(GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint * ids, GLboolean enabled);

+#define glDebugMessageControl _ptrc_glDebugMessageControl

+extern void (CODEGEN_FUNCPTR *_ptrc_glDebugMessageInsert)(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar * buf);

+#define glDebugMessageInsert _ptrc_glDebugMessageInsert

+extern GLuint (CODEGEN_FUNCPTR *_ptrc_glGetDebugMessageLog)(GLuint count, GLsizei bufSize, GLenum * sources, GLenum * types, GLuint * ids, GLenum * severities, GLsizei * lengths, GLchar * messageLog);

+#define glGetDebugMessageLog _ptrc_glGetDebugMessageLog

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetObjectLabel)(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei * length, GLchar * label);

+#define glGetObjectLabel _ptrc_glGetObjectLabel

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetObjectPtrLabel)(const void * ptr, GLsizei bufSize, GLsizei * length, GLchar * label);

+#define glGetObjectPtrLabel _ptrc_glGetObjectPtrLabel

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetPointerv)(GLenum pname, void ** params);

+#define glGetPointerv _ptrc_glGetPointerv

+extern void (CODEGEN_FUNCPTR *_ptrc_glObjectLabel)(GLenum identifier, GLuint name, GLsizei length, const GLchar * label);

+#define glObjectLabel _ptrc_glObjectLabel

+extern void (CODEGEN_FUNCPTR *_ptrc_glObjectPtrLabel)(const void * ptr, GLsizei length, const GLchar * label);

+#define glObjectPtrLabel _ptrc_glObjectPtrLabel

+extern void (CODEGEN_FUNCPTR *_ptrc_glPopDebugGroup)(void);

+#define glPopDebugGroup _ptrc_glPopDebugGroup

+extern void (CODEGEN_FUNCPTR *_ptrc_glPushDebugGroup)(GLenum source, GLuint id, GLsizei length, const GLchar * message);

+#define glPushDebugGroup _ptrc_glPushDebugGroup

+#endif /*GL_KHR_debug*/ 

+

+#ifndef GL_ARB_buffer_storage

+#define GL_ARB_buffer_storage 1

+extern void (CODEGEN_FUNCPTR *_ptrc_glBufferStorage)(GLenum target, GLsizeiptr size, const void * data, GLbitfield flags);

+#define glBufferStorage _ptrc_glBufferStorage

+#endif /*GL_ARB_buffer_storage*/ 

+

+#ifndef GL_ARB_clear_texture

+#define GL_ARB_clear_texture 1

+extern void (CODEGEN_FUNCPTR *_ptrc_glClearTexImage)(GLuint texture, GLint level, GLenum format, GLenum type, const void * data);

+#define glClearTexImage _ptrc_glClearTexImage

+extern void (CODEGEN_FUNCPTR *_ptrc_glClearTexSubImage)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * data);

+#define glClearTexSubImage _ptrc_glClearTexSubImage

+#endif /*GL_ARB_clear_texture*/ 

+

+

+#ifndef GL_ARB_multi_bind

+#define GL_ARB_multi_bind 1

+extern void (CODEGEN_FUNCPTR *_ptrc_glBindBuffersBase)(GLenum target, GLuint first, GLsizei count, const GLuint * buffers);

+#define glBindBuffersBase _ptrc_glBindBuffersBase

+extern void (CODEGEN_FUNCPTR *_ptrc_glBindBuffersRange)(GLenum target, GLuint first, GLsizei count, const GLuint * buffers, const GLintptr * offsets, const GLsizeiptr * sizes);

+#define glBindBuffersRange _ptrc_glBindBuffersRange

+extern void (CODEGEN_FUNCPTR *_ptrc_glBindImageTextures)(GLuint first, GLsizei count, const GLuint * textures);

+#define glBindImageTextures _ptrc_glBindImageTextures

+extern void (CODEGEN_FUNCPTR *_ptrc_glBindSamplers)(GLuint first, GLsizei count, const GLuint * samplers);

+#define glBindSamplers _ptrc_glBindSamplers

+extern void (CODEGEN_FUNCPTR *_ptrc_glBindTextures)(GLuint first, GLsizei count, const GLuint * textures);

+#define glBindTextures _ptrc_glBindTextures

+extern void (CODEGEN_FUNCPTR *_ptrc_glBindVertexBuffers)(GLuint first, GLsizei count, const GLuint * buffers, const GLintptr * offsets, const GLsizei * strides);

+#define glBindVertexBuffers _ptrc_glBindVertexBuffers

+#endif /*GL_ARB_multi_bind*/ 

+

+

+

+

+

+

+#ifndef GL_ARB_clip_control

+#define GL_ARB_clip_control 1

+extern void (CODEGEN_FUNCPTR *_ptrc_glClipControl)(GLenum origin, GLenum depth);

+#define glClipControl _ptrc_glClipControl

+#endif /*GL_ARB_clip_control*/ 

+

+

+

+

+#ifndef GL_ARB_direct_state_access

+#define GL_ARB_direct_state_access 1

+extern void (CODEGEN_FUNCPTR *_ptrc_glBindTextureUnit)(GLuint unit, GLuint texture);

+#define glBindTextureUnit _ptrc_glBindTextureUnit

+extern void (CODEGEN_FUNCPTR *_ptrc_glBlitNamedFramebuffer)(GLuint readFramebuffer, GLuint drawFramebuffer, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);

+#define glBlitNamedFramebuffer _ptrc_glBlitNamedFramebuffer

+extern GLenum (CODEGEN_FUNCPTR *_ptrc_glCheckNamedFramebufferStatus)(GLuint framebuffer, GLenum target);

+#define glCheckNamedFramebufferStatus _ptrc_glCheckNamedFramebufferStatus

+extern void (CODEGEN_FUNCPTR *_ptrc_glClearNamedBufferData)(GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void * data);

+#define glClearNamedBufferData _ptrc_glClearNamedBufferData

+extern void (CODEGEN_FUNCPTR *_ptrc_glClearNamedBufferSubData)(GLuint buffer, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void * data);

+#define glClearNamedBufferSubData _ptrc_glClearNamedBufferSubData

+extern void (CODEGEN_FUNCPTR *_ptrc_glClearNamedFramebufferfi)(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLfloat depth, GLint stencil);

+#define glClearNamedFramebufferfi _ptrc_glClearNamedFramebufferfi

+extern void (CODEGEN_FUNCPTR *_ptrc_glClearNamedFramebufferfv)(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLfloat * value);

+#define glClearNamedFramebufferfv _ptrc_glClearNamedFramebufferfv

+extern void (CODEGEN_FUNCPTR *_ptrc_glClearNamedFramebufferiv)(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLint * value);

+#define glClearNamedFramebufferiv _ptrc_glClearNamedFramebufferiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glClearNamedFramebufferuiv)(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLuint * value);

+#define glClearNamedFramebufferuiv _ptrc_glClearNamedFramebufferuiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glCompressedTextureSubImage1D)(GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void * data);

+#define glCompressedTextureSubImage1D _ptrc_glCompressedTextureSubImage1D

+extern void (CODEGEN_FUNCPTR *_ptrc_glCompressedTextureSubImage2D)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void * data);

+#define glCompressedTextureSubImage2D _ptrc_glCompressedTextureSubImage2D

+extern void (CODEGEN_FUNCPTR *_ptrc_glCompressedTextureSubImage3D)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void * data);

+#define glCompressedTextureSubImage3D _ptrc_glCompressedTextureSubImage3D

+extern void (CODEGEN_FUNCPTR *_ptrc_glCopyNamedBufferSubData)(GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);

+#define glCopyNamedBufferSubData _ptrc_glCopyNamedBufferSubData

+extern void (CODEGEN_FUNCPTR *_ptrc_glCopyTextureSubImage1D)(GLuint texture, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);

+#define glCopyTextureSubImage1D _ptrc_glCopyTextureSubImage1D

+extern void (CODEGEN_FUNCPTR *_ptrc_glCopyTextureSubImage2D)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);

+#define glCopyTextureSubImage2D _ptrc_glCopyTextureSubImage2D

+extern void (CODEGEN_FUNCPTR *_ptrc_glCopyTextureSubImage3D)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);

+#define glCopyTextureSubImage3D _ptrc_glCopyTextureSubImage3D

+extern void (CODEGEN_FUNCPTR *_ptrc_glCreateBuffers)(GLsizei n, GLuint * buffers);

+#define glCreateBuffers _ptrc_glCreateBuffers

+extern void (CODEGEN_FUNCPTR *_ptrc_glCreateFramebuffers)(GLsizei n, GLuint * framebuffers);

+#define glCreateFramebuffers _ptrc_glCreateFramebuffers

+extern void (CODEGEN_FUNCPTR *_ptrc_glCreateProgramPipelines)(GLsizei n, GLuint * pipelines);

+#define glCreateProgramPipelines _ptrc_glCreateProgramPipelines

+extern void (CODEGEN_FUNCPTR *_ptrc_glCreateQueries)(GLenum target, GLsizei n, GLuint * ids);

+#define glCreateQueries _ptrc_glCreateQueries

+extern void (CODEGEN_FUNCPTR *_ptrc_glCreateRenderbuffers)(GLsizei n, GLuint * renderbuffers);

+#define glCreateRenderbuffers _ptrc_glCreateRenderbuffers

+extern void (CODEGEN_FUNCPTR *_ptrc_glCreateSamplers)(GLsizei n, GLuint * samplers);

+#define glCreateSamplers _ptrc_glCreateSamplers

+extern void (CODEGEN_FUNCPTR *_ptrc_glCreateTextures)(GLenum target, GLsizei n, GLuint * textures);

+#define glCreateTextures _ptrc_glCreateTextures

+extern void (CODEGEN_FUNCPTR *_ptrc_glCreateTransformFeedbacks)(GLsizei n, GLuint * ids);

+#define glCreateTransformFeedbacks _ptrc_glCreateTransformFeedbacks

+extern void (CODEGEN_FUNCPTR *_ptrc_glCreateVertexArrays)(GLsizei n, GLuint * arrays);

+#define glCreateVertexArrays _ptrc_glCreateVertexArrays

+extern void (CODEGEN_FUNCPTR *_ptrc_glDisableVertexArrayAttrib)(GLuint vaobj, GLuint index);

+#define glDisableVertexArrayAttrib _ptrc_glDisableVertexArrayAttrib

+extern void (CODEGEN_FUNCPTR *_ptrc_glEnableVertexArrayAttrib)(GLuint vaobj, GLuint index);

+#define glEnableVertexArrayAttrib _ptrc_glEnableVertexArrayAttrib

+extern void (CODEGEN_FUNCPTR *_ptrc_glFlushMappedNamedBufferRange)(GLuint buffer, GLintptr offset, GLsizeiptr length);

+#define glFlushMappedNamedBufferRange _ptrc_glFlushMappedNamedBufferRange

+extern void (CODEGEN_FUNCPTR *_ptrc_glGenerateTextureMipmap)(GLuint texture);

+#define glGenerateTextureMipmap _ptrc_glGenerateTextureMipmap

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetCompressedTextureImage)(GLuint texture, GLint level, GLsizei bufSize, void * pixels);

+#define glGetCompressedTextureImage _ptrc_glGetCompressedTextureImage

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetNamedBufferParameteri64v)(GLuint buffer, GLenum pname, GLint64 * params);

+#define glGetNamedBufferParameteri64v _ptrc_glGetNamedBufferParameteri64v

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetNamedBufferParameteriv)(GLuint buffer, GLenum pname, GLint * params);

+#define glGetNamedBufferParameteriv _ptrc_glGetNamedBufferParameteriv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetNamedBufferPointerv)(GLuint buffer, GLenum pname, void ** params);

+#define glGetNamedBufferPointerv _ptrc_glGetNamedBufferPointerv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetNamedBufferSubData)(GLuint buffer, GLintptr offset, GLsizeiptr size, void * data);

+#define glGetNamedBufferSubData _ptrc_glGetNamedBufferSubData

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetNamedFramebufferAttachmentParameteriv)(GLuint framebuffer, GLenum attachment, GLenum pname, GLint * params);

+#define glGetNamedFramebufferAttachmentParameteriv _ptrc_glGetNamedFramebufferAttachmentParameteriv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetNamedFramebufferParameteriv)(GLuint framebuffer, GLenum pname, GLint * param);

+#define glGetNamedFramebufferParameteriv _ptrc_glGetNamedFramebufferParameteriv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetNamedRenderbufferParameteriv)(GLuint renderbuffer, GLenum pname, GLint * params);

+#define glGetNamedRenderbufferParameteriv _ptrc_glGetNamedRenderbufferParameteriv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetQueryBufferObjecti64v)(GLuint id, GLuint buffer, GLenum pname, GLintptr offset);

+#define glGetQueryBufferObjecti64v _ptrc_glGetQueryBufferObjecti64v

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetQueryBufferObjectiv)(GLuint id, GLuint buffer, GLenum pname, GLintptr offset);

+#define glGetQueryBufferObjectiv _ptrc_glGetQueryBufferObjectiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetQueryBufferObjectui64v)(GLuint id, GLuint buffer, GLenum pname, GLintptr offset);

+#define glGetQueryBufferObjectui64v _ptrc_glGetQueryBufferObjectui64v

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetQueryBufferObjectuiv)(GLuint id, GLuint buffer, GLenum pname, GLintptr offset);

+#define glGetQueryBufferObjectuiv _ptrc_glGetQueryBufferObjectuiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetTextureImage)(GLuint texture, GLint level, GLenum format, GLenum type, GLsizei bufSize, void * pixels);

+#define glGetTextureImage _ptrc_glGetTextureImage

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetTextureLevelParameterfv)(GLuint texture, GLint level, GLenum pname, GLfloat * params);

+#define glGetTextureLevelParameterfv _ptrc_glGetTextureLevelParameterfv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetTextureLevelParameteriv)(GLuint texture, GLint level, GLenum pname, GLint * params);

+#define glGetTextureLevelParameteriv _ptrc_glGetTextureLevelParameteriv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetTextureParameterIiv)(GLuint texture, GLenum pname, GLint * params);

+#define glGetTextureParameterIiv _ptrc_glGetTextureParameterIiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetTextureParameterIuiv)(GLuint texture, GLenum pname, GLuint * params);

+#define glGetTextureParameterIuiv _ptrc_glGetTextureParameterIuiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetTextureParameterfv)(GLuint texture, GLenum pname, GLfloat * params);

+#define glGetTextureParameterfv _ptrc_glGetTextureParameterfv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetTextureParameteriv)(GLuint texture, GLenum pname, GLint * params);

+#define glGetTextureParameteriv _ptrc_glGetTextureParameteriv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetTransformFeedbacki64_v)(GLuint xfb, GLenum pname, GLuint index, GLint64 * param);

+#define glGetTransformFeedbacki64_v _ptrc_glGetTransformFeedbacki64_v

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetTransformFeedbacki_v)(GLuint xfb, GLenum pname, GLuint index, GLint * param);

+#define glGetTransformFeedbacki_v _ptrc_glGetTransformFeedbacki_v

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetTransformFeedbackiv)(GLuint xfb, GLenum pname, GLint * param);

+#define glGetTransformFeedbackiv _ptrc_glGetTransformFeedbackiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetVertexArrayIndexed64iv)(GLuint vaobj, GLuint index, GLenum pname, GLint64 * param);

+#define glGetVertexArrayIndexed64iv _ptrc_glGetVertexArrayIndexed64iv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetVertexArrayIndexediv)(GLuint vaobj, GLuint index, GLenum pname, GLint * param);

+#define glGetVertexArrayIndexediv _ptrc_glGetVertexArrayIndexediv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetVertexArrayiv)(GLuint vaobj, GLenum pname, GLint * param);

+#define glGetVertexArrayiv _ptrc_glGetVertexArrayiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glInvalidateNamedFramebufferData)(GLuint framebuffer, GLsizei numAttachments, const GLenum * attachments);

+#define glInvalidateNamedFramebufferData _ptrc_glInvalidateNamedFramebufferData

+extern void (CODEGEN_FUNCPTR *_ptrc_glInvalidateNamedFramebufferSubData)(GLuint framebuffer, GLsizei numAttachments, const GLenum * attachments, GLint x, GLint y, GLsizei width, GLsizei height);

+#define glInvalidateNamedFramebufferSubData _ptrc_glInvalidateNamedFramebufferSubData

+extern void * (CODEGEN_FUNCPTR *_ptrc_glMapNamedBuffer)(GLuint buffer, GLenum access);

+#define glMapNamedBuffer _ptrc_glMapNamedBuffer

+extern void * (CODEGEN_FUNCPTR *_ptrc_glMapNamedBufferRange)(GLuint buffer, GLintptr offset, GLsizeiptr length, GLbitfield access);

+#define glMapNamedBufferRange _ptrc_glMapNamedBufferRange

+extern void (CODEGEN_FUNCPTR *_ptrc_glNamedBufferData)(GLuint buffer, GLsizeiptr size, const void * data, GLenum usage);

+#define glNamedBufferData _ptrc_glNamedBufferData

+extern void (CODEGEN_FUNCPTR *_ptrc_glNamedBufferStorage)(GLuint buffer, GLsizeiptr size, const void * data, GLbitfield flags);

+#define glNamedBufferStorage _ptrc_glNamedBufferStorage

+extern void (CODEGEN_FUNCPTR *_ptrc_glNamedBufferSubData)(GLuint buffer, GLintptr offset, GLsizeiptr size, const void * data);

+#define glNamedBufferSubData _ptrc_glNamedBufferSubData

+extern void (CODEGEN_FUNCPTR *_ptrc_glNamedFramebufferDrawBuffer)(GLuint framebuffer, GLenum buf);

+#define glNamedFramebufferDrawBuffer _ptrc_glNamedFramebufferDrawBuffer

+extern void (CODEGEN_FUNCPTR *_ptrc_glNamedFramebufferDrawBuffers)(GLuint framebuffer, GLsizei n, const GLenum * bufs);

+#define glNamedFramebufferDrawBuffers _ptrc_glNamedFramebufferDrawBuffers

+extern void (CODEGEN_FUNCPTR *_ptrc_glNamedFramebufferParameteri)(GLuint framebuffer, GLenum pname, GLint param);

+#define glNamedFramebufferParameteri _ptrc_glNamedFramebufferParameteri

+extern void (CODEGEN_FUNCPTR *_ptrc_glNamedFramebufferReadBuffer)(GLuint framebuffer, GLenum src);

+#define glNamedFramebufferReadBuffer _ptrc_glNamedFramebufferReadBuffer

+extern void (CODEGEN_FUNCPTR *_ptrc_glNamedFramebufferRenderbuffer)(GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);

+#define glNamedFramebufferRenderbuffer _ptrc_glNamedFramebufferRenderbuffer

+extern void (CODEGEN_FUNCPTR *_ptrc_glNamedFramebufferTexture)(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level);

+#define glNamedFramebufferTexture _ptrc_glNamedFramebufferTexture

+extern void (CODEGEN_FUNCPTR *_ptrc_glNamedFramebufferTextureLayer)(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer);

+#define glNamedFramebufferTextureLayer _ptrc_glNamedFramebufferTextureLayer

+extern void (CODEGEN_FUNCPTR *_ptrc_glNamedRenderbufferStorage)(GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height);

+#define glNamedRenderbufferStorage _ptrc_glNamedRenderbufferStorage

+extern void (CODEGEN_FUNCPTR *_ptrc_glNamedRenderbufferStorageMultisample)(GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);

+#define glNamedRenderbufferStorageMultisample _ptrc_glNamedRenderbufferStorageMultisample

+extern void (CODEGEN_FUNCPTR *_ptrc_glTextureBuffer)(GLuint texture, GLenum internalformat, GLuint buffer);

+#define glTextureBuffer _ptrc_glTextureBuffer

+extern void (CODEGEN_FUNCPTR *_ptrc_glTextureBufferRange)(GLuint texture, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size);

+#define glTextureBufferRange _ptrc_glTextureBufferRange

+extern void (CODEGEN_FUNCPTR *_ptrc_glTextureParameterIiv)(GLuint texture, GLenum pname, const GLint * params);

+#define glTextureParameterIiv _ptrc_glTextureParameterIiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glTextureParameterIuiv)(GLuint texture, GLenum pname, const GLuint * params);

+#define glTextureParameterIuiv _ptrc_glTextureParameterIuiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glTextureParameterf)(GLuint texture, GLenum pname, GLfloat param);

+#define glTextureParameterf _ptrc_glTextureParameterf

+extern void (CODEGEN_FUNCPTR *_ptrc_glTextureParameterfv)(GLuint texture, GLenum pname, const GLfloat * param);

+#define glTextureParameterfv _ptrc_glTextureParameterfv

+extern void (CODEGEN_FUNCPTR *_ptrc_glTextureParameteri)(GLuint texture, GLenum pname, GLint param);

+#define glTextureParameteri _ptrc_glTextureParameteri

+extern void (CODEGEN_FUNCPTR *_ptrc_glTextureParameteriv)(GLuint texture, GLenum pname, const GLint * param);

+#define glTextureParameteriv _ptrc_glTextureParameteriv

+extern void (CODEGEN_FUNCPTR *_ptrc_glTextureStorage1D)(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width);

+#define glTextureStorage1D _ptrc_glTextureStorage1D

+extern void (CODEGEN_FUNCPTR *_ptrc_glTextureStorage2D)(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);

+#define glTextureStorage2D _ptrc_glTextureStorage2D

+extern void (CODEGEN_FUNCPTR *_ptrc_glTextureStorage2DMultisample)(GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);

+#define glTextureStorage2DMultisample _ptrc_glTextureStorage2DMultisample

+extern void (CODEGEN_FUNCPTR *_ptrc_glTextureStorage3D)(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);

+#define glTextureStorage3D _ptrc_glTextureStorage3D

+extern void (CODEGEN_FUNCPTR *_ptrc_glTextureStorage3DMultisample)(GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);

+#define glTextureStorage3DMultisample _ptrc_glTextureStorage3DMultisample

+extern void (CODEGEN_FUNCPTR *_ptrc_glTextureSubImage1D)(GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void * pixels);

+#define glTextureSubImage1D _ptrc_glTextureSubImage1D

+extern void (CODEGEN_FUNCPTR *_ptrc_glTextureSubImage2D)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * pixels);

+#define glTextureSubImage2D _ptrc_glTextureSubImage2D

+extern void (CODEGEN_FUNCPTR *_ptrc_glTextureSubImage3D)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * pixels);

+#define glTextureSubImage3D _ptrc_glTextureSubImage3D

+extern void (CODEGEN_FUNCPTR *_ptrc_glTransformFeedbackBufferBase)(GLuint xfb, GLuint index, GLuint buffer);

+#define glTransformFeedbackBufferBase _ptrc_glTransformFeedbackBufferBase

+extern void (CODEGEN_FUNCPTR *_ptrc_glTransformFeedbackBufferRange)(GLuint xfb, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);

+#define glTransformFeedbackBufferRange _ptrc_glTransformFeedbackBufferRange

+extern GLboolean (CODEGEN_FUNCPTR *_ptrc_glUnmapNamedBuffer)(GLuint buffer);

+#define glUnmapNamedBuffer _ptrc_glUnmapNamedBuffer

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexArrayAttribBinding)(GLuint vaobj, GLuint attribindex, GLuint bindingindex);

+#define glVertexArrayAttribBinding _ptrc_glVertexArrayAttribBinding

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexArrayAttribFormat)(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset);

+#define glVertexArrayAttribFormat _ptrc_glVertexArrayAttribFormat

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexArrayAttribIFormat)(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);

+#define glVertexArrayAttribIFormat _ptrc_glVertexArrayAttribIFormat

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexArrayAttribLFormat)(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);

+#define glVertexArrayAttribLFormat _ptrc_glVertexArrayAttribLFormat

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexArrayBindingDivisor)(GLuint vaobj, GLuint bindingindex, GLuint divisor);

+#define glVertexArrayBindingDivisor _ptrc_glVertexArrayBindingDivisor

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexArrayElementBuffer)(GLuint vaobj, GLuint buffer);

+#define glVertexArrayElementBuffer _ptrc_glVertexArrayElementBuffer

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexArrayVertexBuffer)(GLuint vaobj, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride);

+#define glVertexArrayVertexBuffer _ptrc_glVertexArrayVertexBuffer

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexArrayVertexBuffers)(GLuint vaobj, GLuint first, GLsizei count, const GLuint * buffers, const GLintptr * offsets, const GLsizei * strides);

+#define glVertexArrayVertexBuffers _ptrc_glVertexArrayVertexBuffers

+#endif /*GL_ARB_direct_state_access*/ 

+

+#ifndef GL_ARB_get_texture_sub_image

+#define GL_ARB_get_texture_sub_image 1

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetCompressedTextureSubImage)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei bufSize, void * pixels);

+#define glGetCompressedTextureSubImage _ptrc_glGetCompressedTextureSubImage

+extern void (CODEGEN_FUNCPTR *_ptrc_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);

+#define glGetTextureSubImage _ptrc_glGetTextureSubImage

+#endif /*GL_ARB_get_texture_sub_image*/ 

+

+

+#ifndef GL_ARB_texture_barrier

+#define GL_ARB_texture_barrier 1

+extern void (CODEGEN_FUNCPTR *_ptrc_glTextureBarrier)(void);

+#define glTextureBarrier _ptrc_glTextureBarrier

+#endif /*GL_ARB_texture_barrier*/ 

+

+

+

+#ifndef GL_KHR_robustness

+#define GL_KHR_robustness 1

+extern GLenum (CODEGEN_FUNCPTR *_ptrc_glGetGraphicsResetStatus)(void);

+#define glGetGraphicsResetStatus _ptrc_glGetGraphicsResetStatus

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetnUniformfv)(GLuint program, GLint location, GLsizei bufSize, GLfloat * params);

+#define glGetnUniformfv _ptrc_glGetnUniformfv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetnUniformiv)(GLuint program, GLint location, GLsizei bufSize, GLint * params);

+#define glGetnUniformiv _ptrc_glGetnUniformiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetnUniformuiv)(GLuint program, GLint location, GLsizei bufSize, GLuint * params);

+#define glGetnUniformuiv _ptrc_glGetnUniformuiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glReadnPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void * data);

+#define glReadnPixels _ptrc_glReadnPixels

+#endif /*GL_KHR_robustness*/ 

+

+

+

+

+extern void (CODEGEN_FUNCPTR *_ptrc_glAccum)(GLenum op, GLfloat value);

+#define glAccum _ptrc_glAccum

+extern void (CODEGEN_FUNCPTR *_ptrc_glAlphaFunc)(GLenum func, GLfloat ref);

+#define glAlphaFunc _ptrc_glAlphaFunc

+extern void (CODEGEN_FUNCPTR *_ptrc_glBegin)(GLenum mode);

+#define glBegin _ptrc_glBegin

+extern void (CODEGEN_FUNCPTR *_ptrc_glBitmap)(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte * bitmap);

+#define glBitmap _ptrc_glBitmap

+extern void (CODEGEN_FUNCPTR *_ptrc_glBlendFunc)(GLenum sfactor, GLenum dfactor);

+#define glBlendFunc _ptrc_glBlendFunc

+extern void (CODEGEN_FUNCPTR *_ptrc_glCallList)(GLuint list);

+#define glCallList _ptrc_glCallList

+extern void (CODEGEN_FUNCPTR *_ptrc_glCallLists)(GLsizei n, GLenum type, const void * lists);

+#define glCallLists _ptrc_glCallLists

+extern void (CODEGEN_FUNCPTR *_ptrc_glClear)(GLbitfield mask);

+#define glClear _ptrc_glClear

+extern void (CODEGEN_FUNCPTR *_ptrc_glClearAccum)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);

+#define glClearAccum _ptrc_glClearAccum

+extern void (CODEGEN_FUNCPTR *_ptrc_glClearColor)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);

+#define glClearColor _ptrc_glClearColor

+extern void (CODEGEN_FUNCPTR *_ptrc_glClearDepth)(GLdouble depth);

+#define glClearDepth _ptrc_glClearDepth

+extern void (CODEGEN_FUNCPTR *_ptrc_glClearIndex)(GLfloat c);

+#define glClearIndex _ptrc_glClearIndex

+extern void (CODEGEN_FUNCPTR *_ptrc_glClearStencil)(GLint s);

+#define glClearStencil _ptrc_glClearStencil

+extern void (CODEGEN_FUNCPTR *_ptrc_glClipPlane)(GLenum plane, const GLdouble * equation);

+#define glClipPlane _ptrc_glClipPlane

+extern void (CODEGEN_FUNCPTR *_ptrc_glColor3b)(GLbyte red, GLbyte green, GLbyte blue);

+#define glColor3b _ptrc_glColor3b

+extern void (CODEGEN_FUNCPTR *_ptrc_glColor3bv)(const GLbyte * v);

+#define glColor3bv _ptrc_glColor3bv

+extern void (CODEGEN_FUNCPTR *_ptrc_glColor3d)(GLdouble red, GLdouble green, GLdouble blue);

+#define glColor3d _ptrc_glColor3d

+extern void (CODEGEN_FUNCPTR *_ptrc_glColor3dv)(const GLdouble * v);

+#define glColor3dv _ptrc_glColor3dv

+extern void (CODEGEN_FUNCPTR *_ptrc_glColor3f)(GLfloat red, GLfloat green, GLfloat blue);

+#define glColor3f _ptrc_glColor3f

+extern void (CODEGEN_FUNCPTR *_ptrc_glColor3fv)(const GLfloat * v);

+#define glColor3fv _ptrc_glColor3fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glColor3i)(GLint red, GLint green, GLint blue);

+#define glColor3i _ptrc_glColor3i

+extern void (CODEGEN_FUNCPTR *_ptrc_glColor3iv)(const GLint * v);

+#define glColor3iv _ptrc_glColor3iv

+extern void (CODEGEN_FUNCPTR *_ptrc_glColor3s)(GLshort red, GLshort green, GLshort blue);

+#define glColor3s _ptrc_glColor3s

+extern void (CODEGEN_FUNCPTR *_ptrc_glColor3sv)(const GLshort * v);

+#define glColor3sv _ptrc_glColor3sv

+extern void (CODEGEN_FUNCPTR *_ptrc_glColor3ub)(GLubyte red, GLubyte green, GLubyte blue);

+#define glColor3ub _ptrc_glColor3ub

+extern void (CODEGEN_FUNCPTR *_ptrc_glColor3ubv)(const GLubyte * v);

+#define glColor3ubv _ptrc_glColor3ubv

+extern void (CODEGEN_FUNCPTR *_ptrc_glColor3ui)(GLuint red, GLuint green, GLuint blue);

+#define glColor3ui _ptrc_glColor3ui

+extern void (CODEGEN_FUNCPTR *_ptrc_glColor3uiv)(const GLuint * v);

+#define glColor3uiv _ptrc_glColor3uiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glColor3us)(GLushort red, GLushort green, GLushort blue);

+#define glColor3us _ptrc_glColor3us

+extern void (CODEGEN_FUNCPTR *_ptrc_glColor3usv)(const GLushort * v);

+#define glColor3usv _ptrc_glColor3usv

+extern void (CODEGEN_FUNCPTR *_ptrc_glColor4b)(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);

+#define glColor4b _ptrc_glColor4b

+extern void (CODEGEN_FUNCPTR *_ptrc_glColor4bv)(const GLbyte * v);

+#define glColor4bv _ptrc_glColor4bv

+extern void (CODEGEN_FUNCPTR *_ptrc_glColor4d)(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);

+#define glColor4d _ptrc_glColor4d

+extern void (CODEGEN_FUNCPTR *_ptrc_glColor4dv)(const GLdouble * v);

+#define glColor4dv _ptrc_glColor4dv

+extern void (CODEGEN_FUNCPTR *_ptrc_glColor4f)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);

+#define glColor4f _ptrc_glColor4f

+extern void (CODEGEN_FUNCPTR *_ptrc_glColor4fv)(const GLfloat * v);

+#define glColor4fv _ptrc_glColor4fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glColor4i)(GLint red, GLint green, GLint blue, GLint alpha);

+#define glColor4i _ptrc_glColor4i

+extern void (CODEGEN_FUNCPTR *_ptrc_glColor4iv)(const GLint * v);

+#define glColor4iv _ptrc_glColor4iv

+extern void (CODEGEN_FUNCPTR *_ptrc_glColor4s)(GLshort red, GLshort green, GLshort blue, GLshort alpha);

+#define glColor4s _ptrc_glColor4s

+extern void (CODEGEN_FUNCPTR *_ptrc_glColor4sv)(const GLshort * v);

+#define glColor4sv _ptrc_glColor4sv

+extern void (CODEGEN_FUNCPTR *_ptrc_glColor4ub)(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);

+#define glColor4ub _ptrc_glColor4ub

+extern void (CODEGEN_FUNCPTR *_ptrc_glColor4ubv)(const GLubyte * v);

+#define glColor4ubv _ptrc_glColor4ubv

+extern void (CODEGEN_FUNCPTR *_ptrc_glColor4ui)(GLuint red, GLuint green, GLuint blue, GLuint alpha);

+#define glColor4ui _ptrc_glColor4ui

+extern void (CODEGEN_FUNCPTR *_ptrc_glColor4uiv)(const GLuint * v);

+#define glColor4uiv _ptrc_glColor4uiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glColor4us)(GLushort red, GLushort green, GLushort blue, GLushort alpha);

+#define glColor4us _ptrc_glColor4us

+extern void (CODEGEN_FUNCPTR *_ptrc_glColor4usv)(const GLushort * v);

+#define glColor4usv _ptrc_glColor4usv

+extern void (CODEGEN_FUNCPTR *_ptrc_glColorMask)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);

+#define glColorMask _ptrc_glColorMask

+extern void (CODEGEN_FUNCPTR *_ptrc_glColorMaterial)(GLenum face, GLenum mode);

+#define glColorMaterial _ptrc_glColorMaterial

+extern void (CODEGEN_FUNCPTR *_ptrc_glCopyPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);

+#define glCopyPixels _ptrc_glCopyPixels

+extern void (CODEGEN_FUNCPTR *_ptrc_glCullFace)(GLenum mode);

+#define glCullFace _ptrc_glCullFace

+extern void (CODEGEN_FUNCPTR *_ptrc_glDeleteLists)(GLuint list, GLsizei range);

+#define glDeleteLists _ptrc_glDeleteLists

+extern void (CODEGEN_FUNCPTR *_ptrc_glDepthFunc)(GLenum func);

+#define glDepthFunc _ptrc_glDepthFunc

+extern void (CODEGEN_FUNCPTR *_ptrc_glDepthMask)(GLboolean flag);

+#define glDepthMask _ptrc_glDepthMask

+extern void (CODEGEN_FUNCPTR *_ptrc_glDepthRange)(GLdouble ren_near, GLdouble ren_far);

+#define glDepthRange _ptrc_glDepthRange

+extern void (CODEGEN_FUNCPTR *_ptrc_glDisable)(GLenum cap);

+#define glDisable _ptrc_glDisable

+extern void (CODEGEN_FUNCPTR *_ptrc_glDrawBuffer)(GLenum buf);

+#define glDrawBuffer _ptrc_glDrawBuffer

+extern void (CODEGEN_FUNCPTR *_ptrc_glDrawPixels)(GLsizei width, GLsizei height, GLenum format, GLenum type, const void * pixels);

+#define glDrawPixels _ptrc_glDrawPixels

+extern void (CODEGEN_FUNCPTR *_ptrc_glEdgeFlag)(GLboolean flag);

+#define glEdgeFlag _ptrc_glEdgeFlag

+extern void (CODEGEN_FUNCPTR *_ptrc_glEdgeFlagv)(const GLboolean * flag);

+#define glEdgeFlagv _ptrc_glEdgeFlagv

+extern void (CODEGEN_FUNCPTR *_ptrc_glEnable)(GLenum cap);

+#define glEnable _ptrc_glEnable

+extern void (CODEGEN_FUNCPTR *_ptrc_glEnd)(void);

+#define glEnd _ptrc_glEnd

+extern void (CODEGEN_FUNCPTR *_ptrc_glEndList)(void);

+#define glEndList _ptrc_glEndList

+extern void (CODEGEN_FUNCPTR *_ptrc_glEvalCoord1d)(GLdouble u);

+#define glEvalCoord1d _ptrc_glEvalCoord1d

+extern void (CODEGEN_FUNCPTR *_ptrc_glEvalCoord1dv)(const GLdouble * u);

+#define glEvalCoord1dv _ptrc_glEvalCoord1dv

+extern void (CODEGEN_FUNCPTR *_ptrc_glEvalCoord1f)(GLfloat u);

+#define glEvalCoord1f _ptrc_glEvalCoord1f

+extern void (CODEGEN_FUNCPTR *_ptrc_glEvalCoord1fv)(const GLfloat * u);

+#define glEvalCoord1fv _ptrc_glEvalCoord1fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glEvalCoord2d)(GLdouble u, GLdouble v);

+#define glEvalCoord2d _ptrc_glEvalCoord2d

+extern void (CODEGEN_FUNCPTR *_ptrc_glEvalCoord2dv)(const GLdouble * u);

+#define glEvalCoord2dv _ptrc_glEvalCoord2dv

+extern void (CODEGEN_FUNCPTR *_ptrc_glEvalCoord2f)(GLfloat u, GLfloat v);

+#define glEvalCoord2f _ptrc_glEvalCoord2f

+extern void (CODEGEN_FUNCPTR *_ptrc_glEvalCoord2fv)(const GLfloat * u);

+#define glEvalCoord2fv _ptrc_glEvalCoord2fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glEvalMesh1)(GLenum mode, GLint i1, GLint i2);

+#define glEvalMesh1 _ptrc_glEvalMesh1

+extern void (CODEGEN_FUNCPTR *_ptrc_glEvalMesh2)(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);

+#define glEvalMesh2 _ptrc_glEvalMesh2

+extern void (CODEGEN_FUNCPTR *_ptrc_glEvalPoint1)(GLint i);

+#define glEvalPoint1 _ptrc_glEvalPoint1

+extern void (CODEGEN_FUNCPTR *_ptrc_glEvalPoint2)(GLint i, GLint j);

+#define glEvalPoint2 _ptrc_glEvalPoint2

+extern void (CODEGEN_FUNCPTR *_ptrc_glFeedbackBuffer)(GLsizei size, GLenum type, GLfloat * buffer);

+#define glFeedbackBuffer _ptrc_glFeedbackBuffer

+extern void (CODEGEN_FUNCPTR *_ptrc_glFinish)(void);

+#define glFinish _ptrc_glFinish

+extern void (CODEGEN_FUNCPTR *_ptrc_glFlush)(void);

+#define glFlush _ptrc_glFlush

+extern void (CODEGEN_FUNCPTR *_ptrc_glFogf)(GLenum pname, GLfloat param);

+#define glFogf _ptrc_glFogf

+extern void (CODEGEN_FUNCPTR *_ptrc_glFogfv)(GLenum pname, const GLfloat * params);

+#define glFogfv _ptrc_glFogfv

+extern void (CODEGEN_FUNCPTR *_ptrc_glFogi)(GLenum pname, GLint param);

+#define glFogi _ptrc_glFogi

+extern void (CODEGEN_FUNCPTR *_ptrc_glFogiv)(GLenum pname, const GLint * params);

+#define glFogiv _ptrc_glFogiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glFrontFace)(GLenum mode);

+#define glFrontFace _ptrc_glFrontFace

+extern void (CODEGEN_FUNCPTR *_ptrc_glFrustum)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);

+#define glFrustum _ptrc_glFrustum

+extern GLuint (CODEGEN_FUNCPTR *_ptrc_glGenLists)(GLsizei range);

+#define glGenLists _ptrc_glGenLists

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetBooleanv)(GLenum pname, GLboolean * data);

+#define glGetBooleanv _ptrc_glGetBooleanv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetClipPlane)(GLenum plane, GLdouble * equation);

+#define glGetClipPlane _ptrc_glGetClipPlane

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetDoublev)(GLenum pname, GLdouble * data);

+#define glGetDoublev _ptrc_glGetDoublev

+extern GLenum (CODEGEN_FUNCPTR *_ptrc_glGetError)(void);

+#define glGetError _ptrc_glGetError

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetFloatv)(GLenum pname, GLfloat * data);

+#define glGetFloatv _ptrc_glGetFloatv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetIntegerv)(GLenum pname, GLint * data);

+#define glGetIntegerv _ptrc_glGetIntegerv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetLightfv)(GLenum light, GLenum pname, GLfloat * params);

+#define glGetLightfv _ptrc_glGetLightfv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetLightiv)(GLenum light, GLenum pname, GLint * params);

+#define glGetLightiv _ptrc_glGetLightiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetMapdv)(GLenum target, GLenum query, GLdouble * v);

+#define glGetMapdv _ptrc_glGetMapdv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetMapfv)(GLenum target, GLenum query, GLfloat * v);

+#define glGetMapfv _ptrc_glGetMapfv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetMapiv)(GLenum target, GLenum query, GLint * v);

+#define glGetMapiv _ptrc_glGetMapiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetMaterialfv)(GLenum face, GLenum pname, GLfloat * params);

+#define glGetMaterialfv _ptrc_glGetMaterialfv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetMaterialiv)(GLenum face, GLenum pname, GLint * params);

+#define glGetMaterialiv _ptrc_glGetMaterialiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetPixelMapfv)(GLenum map, GLfloat * values);

+#define glGetPixelMapfv _ptrc_glGetPixelMapfv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetPixelMapuiv)(GLenum map, GLuint * values);

+#define glGetPixelMapuiv _ptrc_glGetPixelMapuiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetPixelMapusv)(GLenum map, GLushort * values);

+#define glGetPixelMapusv _ptrc_glGetPixelMapusv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetPolygonStipple)(GLubyte * mask);

+#define glGetPolygonStipple _ptrc_glGetPolygonStipple

+extern const GLubyte * (CODEGEN_FUNCPTR *_ptrc_glGetString)(GLenum name);

+#define glGetString _ptrc_glGetString

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetTexEnvfv)(GLenum target, GLenum pname, GLfloat * params);

+#define glGetTexEnvfv _ptrc_glGetTexEnvfv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetTexEnviv)(GLenum target, GLenum pname, GLint * params);

+#define glGetTexEnviv _ptrc_glGetTexEnviv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetTexGendv)(GLenum coord, GLenum pname, GLdouble * params);

+#define glGetTexGendv _ptrc_glGetTexGendv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetTexGenfv)(GLenum coord, GLenum pname, GLfloat * params);

+#define glGetTexGenfv _ptrc_glGetTexGenfv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetTexGeniv)(GLenum coord, GLenum pname, GLint * params);

+#define glGetTexGeniv _ptrc_glGetTexGeniv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetTexImage)(GLenum target, GLint level, GLenum format, GLenum type, void * pixels);

+#define glGetTexImage _ptrc_glGetTexImage

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetTexLevelParameterfv)(GLenum target, GLint level, GLenum pname, GLfloat * params);

+#define glGetTexLevelParameterfv _ptrc_glGetTexLevelParameterfv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetTexLevelParameteriv)(GLenum target, GLint level, GLenum pname, GLint * params);

+#define glGetTexLevelParameteriv _ptrc_glGetTexLevelParameteriv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetTexParameterfv)(GLenum target, GLenum pname, GLfloat * params);

+#define glGetTexParameterfv _ptrc_glGetTexParameterfv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetTexParameteriv)(GLenum target, GLenum pname, GLint * params);

+#define glGetTexParameteriv _ptrc_glGetTexParameteriv

+extern void (CODEGEN_FUNCPTR *_ptrc_glHint)(GLenum target, GLenum mode);

+#define glHint _ptrc_glHint

+extern void (CODEGEN_FUNCPTR *_ptrc_glIndexMask)(GLuint mask);

+#define glIndexMask _ptrc_glIndexMask

+extern void (CODEGEN_FUNCPTR *_ptrc_glIndexd)(GLdouble c);

+#define glIndexd _ptrc_glIndexd

+extern void (CODEGEN_FUNCPTR *_ptrc_glIndexdv)(const GLdouble * c);

+#define glIndexdv _ptrc_glIndexdv

+extern void (CODEGEN_FUNCPTR *_ptrc_glIndexf)(GLfloat c);

+#define glIndexf _ptrc_glIndexf

+extern void (CODEGEN_FUNCPTR *_ptrc_glIndexfv)(const GLfloat * c);

+#define glIndexfv _ptrc_glIndexfv

+extern void (CODEGEN_FUNCPTR *_ptrc_glIndexi)(GLint c);

+#define glIndexi _ptrc_glIndexi

+extern void (CODEGEN_FUNCPTR *_ptrc_glIndexiv)(const GLint * c);

+#define glIndexiv _ptrc_glIndexiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glIndexs)(GLshort c);

+#define glIndexs _ptrc_glIndexs

+extern void (CODEGEN_FUNCPTR *_ptrc_glIndexsv)(const GLshort * c);

+#define glIndexsv _ptrc_glIndexsv

+extern void (CODEGEN_FUNCPTR *_ptrc_glInitNames)(void);

+#define glInitNames _ptrc_glInitNames

+extern GLboolean (CODEGEN_FUNCPTR *_ptrc_glIsEnabled)(GLenum cap);

+#define glIsEnabled _ptrc_glIsEnabled

+extern GLboolean (CODEGEN_FUNCPTR *_ptrc_glIsList)(GLuint list);

+#define glIsList _ptrc_glIsList

+extern void (CODEGEN_FUNCPTR *_ptrc_glLightModelf)(GLenum pname, GLfloat param);

+#define glLightModelf _ptrc_glLightModelf

+extern void (CODEGEN_FUNCPTR *_ptrc_glLightModelfv)(GLenum pname, const GLfloat * params);

+#define glLightModelfv _ptrc_glLightModelfv

+extern void (CODEGEN_FUNCPTR *_ptrc_glLightModeli)(GLenum pname, GLint param);

+#define glLightModeli _ptrc_glLightModeli

+extern void (CODEGEN_FUNCPTR *_ptrc_glLightModeliv)(GLenum pname, const GLint * params);

+#define glLightModeliv _ptrc_glLightModeliv

+extern void (CODEGEN_FUNCPTR *_ptrc_glLightf)(GLenum light, GLenum pname, GLfloat param);

+#define glLightf _ptrc_glLightf

+extern void (CODEGEN_FUNCPTR *_ptrc_glLightfv)(GLenum light, GLenum pname, const GLfloat * params);

+#define glLightfv _ptrc_glLightfv

+extern void (CODEGEN_FUNCPTR *_ptrc_glLighti)(GLenum light, GLenum pname, GLint param);

+#define glLighti _ptrc_glLighti

+extern void (CODEGEN_FUNCPTR *_ptrc_glLightiv)(GLenum light, GLenum pname, const GLint * params);

+#define glLightiv _ptrc_glLightiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glLineStipple)(GLint factor, GLushort pattern);

+#define glLineStipple _ptrc_glLineStipple

+extern void (CODEGEN_FUNCPTR *_ptrc_glLineWidth)(GLfloat width);

+#define glLineWidth _ptrc_glLineWidth

+extern void (CODEGEN_FUNCPTR *_ptrc_glListBase)(GLuint base);

+#define glListBase _ptrc_glListBase

+extern void (CODEGEN_FUNCPTR *_ptrc_glLoadIdentity)(void);

+#define glLoadIdentity _ptrc_glLoadIdentity

+extern void (CODEGEN_FUNCPTR *_ptrc_glLoadMatrixd)(const GLdouble * m);

+#define glLoadMatrixd _ptrc_glLoadMatrixd

+extern void (CODEGEN_FUNCPTR *_ptrc_glLoadMatrixf)(const GLfloat * m);

+#define glLoadMatrixf _ptrc_glLoadMatrixf

+extern void (CODEGEN_FUNCPTR *_ptrc_glLoadName)(GLuint name);

+#define glLoadName _ptrc_glLoadName

+extern void (CODEGEN_FUNCPTR *_ptrc_glLogicOp)(GLenum opcode);

+#define glLogicOp _ptrc_glLogicOp

+extern void (CODEGEN_FUNCPTR *_ptrc_glMap1d)(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble * points);

+#define glMap1d _ptrc_glMap1d

+extern void (CODEGEN_FUNCPTR *_ptrc_glMap1f)(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat * points);

+#define glMap1f _ptrc_glMap1f

+extern void (CODEGEN_FUNCPTR *_ptrc_glMap2d)(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble * points);

+#define glMap2d _ptrc_glMap2d

+extern void (CODEGEN_FUNCPTR *_ptrc_glMap2f)(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat * points);

+#define glMap2f _ptrc_glMap2f

+extern void (CODEGEN_FUNCPTR *_ptrc_glMapGrid1d)(GLint un, GLdouble u1, GLdouble u2);

+#define glMapGrid1d _ptrc_glMapGrid1d

+extern void (CODEGEN_FUNCPTR *_ptrc_glMapGrid1f)(GLint un, GLfloat u1, GLfloat u2);

+#define glMapGrid1f _ptrc_glMapGrid1f

+extern void (CODEGEN_FUNCPTR *_ptrc_glMapGrid2d)(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);

+#define glMapGrid2d _ptrc_glMapGrid2d

+extern void (CODEGEN_FUNCPTR *_ptrc_glMapGrid2f)(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);

+#define glMapGrid2f _ptrc_glMapGrid2f

+extern void (CODEGEN_FUNCPTR *_ptrc_glMaterialf)(GLenum face, GLenum pname, GLfloat param);

+#define glMaterialf _ptrc_glMaterialf

+extern void (CODEGEN_FUNCPTR *_ptrc_glMaterialfv)(GLenum face, GLenum pname, const GLfloat * params);

+#define glMaterialfv _ptrc_glMaterialfv

+extern void (CODEGEN_FUNCPTR *_ptrc_glMateriali)(GLenum face, GLenum pname, GLint param);

+#define glMateriali _ptrc_glMateriali

+extern void (CODEGEN_FUNCPTR *_ptrc_glMaterialiv)(GLenum face, GLenum pname, const GLint * params);

+#define glMaterialiv _ptrc_glMaterialiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glMatrixMode)(GLenum mode);

+#define glMatrixMode _ptrc_glMatrixMode

+extern void (CODEGEN_FUNCPTR *_ptrc_glMultMatrixd)(const GLdouble * m);

+#define glMultMatrixd _ptrc_glMultMatrixd

+extern void (CODEGEN_FUNCPTR *_ptrc_glMultMatrixf)(const GLfloat * m);

+#define glMultMatrixf _ptrc_glMultMatrixf

+extern void (CODEGEN_FUNCPTR *_ptrc_glNewList)(GLuint list, GLenum mode);

+#define glNewList _ptrc_glNewList

+extern void (CODEGEN_FUNCPTR *_ptrc_glNormal3b)(GLbyte nx, GLbyte ny, GLbyte nz);

+#define glNormal3b _ptrc_glNormal3b

+extern void (CODEGEN_FUNCPTR *_ptrc_glNormal3bv)(const GLbyte * v);

+#define glNormal3bv _ptrc_glNormal3bv

+extern void (CODEGEN_FUNCPTR *_ptrc_glNormal3d)(GLdouble nx, GLdouble ny, GLdouble nz);

+#define glNormal3d _ptrc_glNormal3d

+extern void (CODEGEN_FUNCPTR *_ptrc_glNormal3dv)(const GLdouble * v);

+#define glNormal3dv _ptrc_glNormal3dv

+extern void (CODEGEN_FUNCPTR *_ptrc_glNormal3f)(GLfloat nx, GLfloat ny, GLfloat nz);

+#define glNormal3f _ptrc_glNormal3f

+extern void (CODEGEN_FUNCPTR *_ptrc_glNormal3fv)(const GLfloat * v);

+#define glNormal3fv _ptrc_glNormal3fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glNormal3i)(GLint nx, GLint ny, GLint nz);

+#define glNormal3i _ptrc_glNormal3i

+extern void (CODEGEN_FUNCPTR *_ptrc_glNormal3iv)(const GLint * v);

+#define glNormal3iv _ptrc_glNormal3iv

+extern void (CODEGEN_FUNCPTR *_ptrc_glNormal3s)(GLshort nx, GLshort ny, GLshort nz);

+#define glNormal3s _ptrc_glNormal3s

+extern void (CODEGEN_FUNCPTR *_ptrc_glNormal3sv)(const GLshort * v);

+#define glNormal3sv _ptrc_glNormal3sv

+extern void (CODEGEN_FUNCPTR *_ptrc_glOrtho)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);

+#define glOrtho _ptrc_glOrtho

+extern void (CODEGEN_FUNCPTR *_ptrc_glPassThrough)(GLfloat token);

+#define glPassThrough _ptrc_glPassThrough

+extern void (CODEGEN_FUNCPTR *_ptrc_glPixelMapfv)(GLenum map, GLsizei mapsize, const GLfloat * values);

+#define glPixelMapfv _ptrc_glPixelMapfv

+extern void (CODEGEN_FUNCPTR *_ptrc_glPixelMapuiv)(GLenum map, GLsizei mapsize, const GLuint * values);

+#define glPixelMapuiv _ptrc_glPixelMapuiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glPixelMapusv)(GLenum map, GLsizei mapsize, const GLushort * values);

+#define glPixelMapusv _ptrc_glPixelMapusv

+extern void (CODEGEN_FUNCPTR *_ptrc_glPixelStoref)(GLenum pname, GLfloat param);

+#define glPixelStoref _ptrc_glPixelStoref

+extern void (CODEGEN_FUNCPTR *_ptrc_glPixelStorei)(GLenum pname, GLint param);

+#define glPixelStorei _ptrc_glPixelStorei

+extern void (CODEGEN_FUNCPTR *_ptrc_glPixelTransferf)(GLenum pname, GLfloat param);

+#define glPixelTransferf _ptrc_glPixelTransferf

+extern void (CODEGEN_FUNCPTR *_ptrc_glPixelTransferi)(GLenum pname, GLint param);

+#define glPixelTransferi _ptrc_glPixelTransferi

+extern void (CODEGEN_FUNCPTR *_ptrc_glPixelZoom)(GLfloat xfactor, GLfloat yfactor);

+#define glPixelZoom _ptrc_glPixelZoom

+extern void (CODEGEN_FUNCPTR *_ptrc_glPointSize)(GLfloat size);

+#define glPointSize _ptrc_glPointSize

+extern void (CODEGEN_FUNCPTR *_ptrc_glPolygonMode)(GLenum face, GLenum mode);

+#define glPolygonMode _ptrc_glPolygonMode

+extern void (CODEGEN_FUNCPTR *_ptrc_glPolygonStipple)(const GLubyte * mask);

+#define glPolygonStipple _ptrc_glPolygonStipple

+extern void (CODEGEN_FUNCPTR *_ptrc_glPopAttrib)(void);

+#define glPopAttrib _ptrc_glPopAttrib

+extern void (CODEGEN_FUNCPTR *_ptrc_glPopMatrix)(void);

+#define glPopMatrix _ptrc_glPopMatrix

+extern void (CODEGEN_FUNCPTR *_ptrc_glPopName)(void);

+#define glPopName _ptrc_glPopName

+extern void (CODEGEN_FUNCPTR *_ptrc_glPushAttrib)(GLbitfield mask);

+#define glPushAttrib _ptrc_glPushAttrib

+extern void (CODEGEN_FUNCPTR *_ptrc_glPushMatrix)(void);

+#define glPushMatrix _ptrc_glPushMatrix

+extern void (CODEGEN_FUNCPTR *_ptrc_glPushName)(GLuint name);

+#define glPushName _ptrc_glPushName

+extern void (CODEGEN_FUNCPTR *_ptrc_glRasterPos2d)(GLdouble x, GLdouble y);

+#define glRasterPos2d _ptrc_glRasterPos2d

+extern void (CODEGEN_FUNCPTR *_ptrc_glRasterPos2dv)(const GLdouble * v);

+#define glRasterPos2dv _ptrc_glRasterPos2dv

+extern void (CODEGEN_FUNCPTR *_ptrc_glRasterPos2f)(GLfloat x, GLfloat y);

+#define glRasterPos2f _ptrc_glRasterPos2f

+extern void (CODEGEN_FUNCPTR *_ptrc_glRasterPos2fv)(const GLfloat * v);

+#define glRasterPos2fv _ptrc_glRasterPos2fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glRasterPos2i)(GLint x, GLint y);

+#define glRasterPos2i _ptrc_glRasterPos2i

+extern void (CODEGEN_FUNCPTR *_ptrc_glRasterPos2iv)(const GLint * v);

+#define glRasterPos2iv _ptrc_glRasterPos2iv

+extern void (CODEGEN_FUNCPTR *_ptrc_glRasterPos2s)(GLshort x, GLshort y);

+#define glRasterPos2s _ptrc_glRasterPos2s

+extern void (CODEGEN_FUNCPTR *_ptrc_glRasterPos2sv)(const GLshort * v);

+#define glRasterPos2sv _ptrc_glRasterPos2sv

+extern void (CODEGEN_FUNCPTR *_ptrc_glRasterPos3d)(GLdouble x, GLdouble y, GLdouble z);

+#define glRasterPos3d _ptrc_glRasterPos3d

+extern void (CODEGEN_FUNCPTR *_ptrc_glRasterPos3dv)(const GLdouble * v);

+#define glRasterPos3dv _ptrc_glRasterPos3dv

+extern void (CODEGEN_FUNCPTR *_ptrc_glRasterPos3f)(GLfloat x, GLfloat y, GLfloat z);

+#define glRasterPos3f _ptrc_glRasterPos3f

+extern void (CODEGEN_FUNCPTR *_ptrc_glRasterPos3fv)(const GLfloat * v);

+#define glRasterPos3fv _ptrc_glRasterPos3fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glRasterPos3i)(GLint x, GLint y, GLint z);

+#define glRasterPos3i _ptrc_glRasterPos3i

+extern void (CODEGEN_FUNCPTR *_ptrc_glRasterPos3iv)(const GLint * v);

+#define glRasterPos3iv _ptrc_glRasterPos3iv

+extern void (CODEGEN_FUNCPTR *_ptrc_glRasterPos3s)(GLshort x, GLshort y, GLshort z);

+#define glRasterPos3s _ptrc_glRasterPos3s

+extern void (CODEGEN_FUNCPTR *_ptrc_glRasterPos3sv)(const GLshort * v);

+#define glRasterPos3sv _ptrc_glRasterPos3sv

+extern void (CODEGEN_FUNCPTR *_ptrc_glRasterPos4d)(GLdouble x, GLdouble y, GLdouble z, GLdouble w);

+#define glRasterPos4d _ptrc_glRasterPos4d

+extern void (CODEGEN_FUNCPTR *_ptrc_glRasterPos4dv)(const GLdouble * v);

+#define glRasterPos4dv _ptrc_glRasterPos4dv

+extern void (CODEGEN_FUNCPTR *_ptrc_glRasterPos4f)(GLfloat x, GLfloat y, GLfloat z, GLfloat w);

+#define glRasterPos4f _ptrc_glRasterPos4f

+extern void (CODEGEN_FUNCPTR *_ptrc_glRasterPos4fv)(const GLfloat * v);

+#define glRasterPos4fv _ptrc_glRasterPos4fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glRasterPos4i)(GLint x, GLint y, GLint z, GLint w);

+#define glRasterPos4i _ptrc_glRasterPos4i

+extern void (CODEGEN_FUNCPTR *_ptrc_glRasterPos4iv)(const GLint * v);

+#define glRasterPos4iv _ptrc_glRasterPos4iv

+extern void (CODEGEN_FUNCPTR *_ptrc_glRasterPos4s)(GLshort x, GLshort y, GLshort z, GLshort w);

+#define glRasterPos4s _ptrc_glRasterPos4s

+extern void (CODEGEN_FUNCPTR *_ptrc_glRasterPos4sv)(const GLshort * v);

+#define glRasterPos4sv _ptrc_glRasterPos4sv

+extern void (CODEGEN_FUNCPTR *_ptrc_glReadBuffer)(GLenum src);

+#define glReadBuffer _ptrc_glReadBuffer

+extern void (CODEGEN_FUNCPTR *_ptrc_glReadPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void * pixels);

+#define glReadPixels _ptrc_glReadPixels

+extern void (CODEGEN_FUNCPTR *_ptrc_glRectd)(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);

+#define glRectd _ptrc_glRectd

+extern void (CODEGEN_FUNCPTR *_ptrc_glRectdv)(const GLdouble * v1, const GLdouble * v2);

+#define glRectdv _ptrc_glRectdv

+extern void (CODEGEN_FUNCPTR *_ptrc_glRectf)(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);

+#define glRectf _ptrc_glRectf

+extern void (CODEGEN_FUNCPTR *_ptrc_glRectfv)(const GLfloat * v1, const GLfloat * v2);

+#define glRectfv _ptrc_glRectfv

+extern void (CODEGEN_FUNCPTR *_ptrc_glRecti)(GLint x1, GLint y1, GLint x2, GLint y2);

+#define glRecti _ptrc_glRecti

+extern void (CODEGEN_FUNCPTR *_ptrc_glRectiv)(const GLint * v1, const GLint * v2);

+#define glRectiv _ptrc_glRectiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glRects)(GLshort x1, GLshort y1, GLshort x2, GLshort y2);

+#define glRects _ptrc_glRects

+extern void (CODEGEN_FUNCPTR *_ptrc_glRectsv)(const GLshort * v1, const GLshort * v2);

+#define glRectsv _ptrc_glRectsv

+extern GLint (CODEGEN_FUNCPTR *_ptrc_glRenderMode)(GLenum mode);

+#define glRenderMode _ptrc_glRenderMode

+extern void (CODEGEN_FUNCPTR *_ptrc_glRotated)(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);

+#define glRotated _ptrc_glRotated

+extern void (CODEGEN_FUNCPTR *_ptrc_glRotatef)(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);

+#define glRotatef _ptrc_glRotatef

+extern void (CODEGEN_FUNCPTR *_ptrc_glScaled)(GLdouble x, GLdouble y, GLdouble z);

+#define glScaled _ptrc_glScaled

+extern void (CODEGEN_FUNCPTR *_ptrc_glScalef)(GLfloat x, GLfloat y, GLfloat z);

+#define glScalef _ptrc_glScalef

+extern void (CODEGEN_FUNCPTR *_ptrc_glScissor)(GLint x, GLint y, GLsizei width, GLsizei height);

+#define glScissor _ptrc_glScissor

+extern void (CODEGEN_FUNCPTR *_ptrc_glSelectBuffer)(GLsizei size, GLuint * buffer);

+#define glSelectBuffer _ptrc_glSelectBuffer

+extern void (CODEGEN_FUNCPTR *_ptrc_glShadeModel)(GLenum mode);

+#define glShadeModel _ptrc_glShadeModel

+extern void (CODEGEN_FUNCPTR *_ptrc_glStencilFunc)(GLenum func, GLint ref, GLuint mask);

+#define glStencilFunc _ptrc_glStencilFunc

+extern void (CODEGEN_FUNCPTR *_ptrc_glStencilMask)(GLuint mask);

+#define glStencilMask _ptrc_glStencilMask

+extern void (CODEGEN_FUNCPTR *_ptrc_glStencilOp)(GLenum fail, GLenum zfail, GLenum zpass);

+#define glStencilOp _ptrc_glStencilOp

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexCoord1d)(GLdouble s);

+#define glTexCoord1d _ptrc_glTexCoord1d

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexCoord1dv)(const GLdouble * v);

+#define glTexCoord1dv _ptrc_glTexCoord1dv

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexCoord1f)(GLfloat s);

+#define glTexCoord1f _ptrc_glTexCoord1f

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexCoord1fv)(const GLfloat * v);

+#define glTexCoord1fv _ptrc_glTexCoord1fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexCoord1i)(GLint s);

+#define glTexCoord1i _ptrc_glTexCoord1i

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexCoord1iv)(const GLint * v);

+#define glTexCoord1iv _ptrc_glTexCoord1iv

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexCoord1s)(GLshort s);

+#define glTexCoord1s _ptrc_glTexCoord1s

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexCoord1sv)(const GLshort * v);

+#define glTexCoord1sv _ptrc_glTexCoord1sv

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexCoord2d)(GLdouble s, GLdouble t);

+#define glTexCoord2d _ptrc_glTexCoord2d

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexCoord2dv)(const GLdouble * v);

+#define glTexCoord2dv _ptrc_glTexCoord2dv

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexCoord2f)(GLfloat s, GLfloat t);

+#define glTexCoord2f _ptrc_glTexCoord2f

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexCoord2fv)(const GLfloat * v);

+#define glTexCoord2fv _ptrc_glTexCoord2fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexCoord2i)(GLint s, GLint t);

+#define glTexCoord2i _ptrc_glTexCoord2i

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexCoord2iv)(const GLint * v);

+#define glTexCoord2iv _ptrc_glTexCoord2iv

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexCoord2s)(GLshort s, GLshort t);

+#define glTexCoord2s _ptrc_glTexCoord2s

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexCoord2sv)(const GLshort * v);

+#define glTexCoord2sv _ptrc_glTexCoord2sv

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexCoord3d)(GLdouble s, GLdouble t, GLdouble r);

+#define glTexCoord3d _ptrc_glTexCoord3d

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexCoord3dv)(const GLdouble * v);

+#define glTexCoord3dv _ptrc_glTexCoord3dv

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexCoord3f)(GLfloat s, GLfloat t, GLfloat r);

+#define glTexCoord3f _ptrc_glTexCoord3f

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexCoord3fv)(const GLfloat * v);

+#define glTexCoord3fv _ptrc_glTexCoord3fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexCoord3i)(GLint s, GLint t, GLint r);

+#define glTexCoord3i _ptrc_glTexCoord3i

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexCoord3iv)(const GLint * v);

+#define glTexCoord3iv _ptrc_glTexCoord3iv

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexCoord3s)(GLshort s, GLshort t, GLshort r);

+#define glTexCoord3s _ptrc_glTexCoord3s

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexCoord3sv)(const GLshort * v);

+#define glTexCoord3sv _ptrc_glTexCoord3sv

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexCoord4d)(GLdouble s, GLdouble t, GLdouble r, GLdouble q);

+#define glTexCoord4d _ptrc_glTexCoord4d

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexCoord4dv)(const GLdouble * v);

+#define glTexCoord4dv _ptrc_glTexCoord4dv

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexCoord4f)(GLfloat s, GLfloat t, GLfloat r, GLfloat q);

+#define glTexCoord4f _ptrc_glTexCoord4f

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexCoord4fv)(const GLfloat * v);

+#define glTexCoord4fv _ptrc_glTexCoord4fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexCoord4i)(GLint s, GLint t, GLint r, GLint q);

+#define glTexCoord4i _ptrc_glTexCoord4i

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexCoord4iv)(const GLint * v);

+#define glTexCoord4iv _ptrc_glTexCoord4iv

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexCoord4s)(GLshort s, GLshort t, GLshort r, GLshort q);

+#define glTexCoord4s _ptrc_glTexCoord4s

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexCoord4sv)(const GLshort * v);

+#define glTexCoord4sv _ptrc_glTexCoord4sv

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexEnvf)(GLenum target, GLenum pname, GLfloat param);

+#define glTexEnvf _ptrc_glTexEnvf

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexEnvfv)(GLenum target, GLenum pname, const GLfloat * params);

+#define glTexEnvfv _ptrc_glTexEnvfv

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexEnvi)(GLenum target, GLenum pname, GLint param);

+#define glTexEnvi _ptrc_glTexEnvi

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexEnviv)(GLenum target, GLenum pname, const GLint * params);

+#define glTexEnviv _ptrc_glTexEnviv

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexGend)(GLenum coord, GLenum pname, GLdouble param);

+#define glTexGend _ptrc_glTexGend

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexGendv)(GLenum coord, GLenum pname, const GLdouble * params);

+#define glTexGendv _ptrc_glTexGendv

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexGenf)(GLenum coord, GLenum pname, GLfloat param);

+#define glTexGenf _ptrc_glTexGenf

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexGenfv)(GLenum coord, GLenum pname, const GLfloat * params);

+#define glTexGenfv _ptrc_glTexGenfv

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexGeni)(GLenum coord, GLenum pname, GLint param);

+#define glTexGeni _ptrc_glTexGeni

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexGeniv)(GLenum coord, GLenum pname, const GLint * params);

+#define glTexGeniv _ptrc_glTexGeniv

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexImage1D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void * pixels);

+#define glTexImage1D _ptrc_glTexImage1D

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexImage2D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void * pixels);

+#define glTexImage2D _ptrc_glTexImage2D

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexParameterf)(GLenum target, GLenum pname, GLfloat param);

+#define glTexParameterf _ptrc_glTexParameterf

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexParameterfv)(GLenum target, GLenum pname, const GLfloat * params);

+#define glTexParameterfv _ptrc_glTexParameterfv

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexParameteri)(GLenum target, GLenum pname, GLint param);

+#define glTexParameteri _ptrc_glTexParameteri

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexParameteriv)(GLenum target, GLenum pname, const GLint * params);

+#define glTexParameteriv _ptrc_glTexParameteriv

+extern void (CODEGEN_FUNCPTR *_ptrc_glTranslated)(GLdouble x, GLdouble y, GLdouble z);

+#define glTranslated _ptrc_glTranslated

+extern void (CODEGEN_FUNCPTR *_ptrc_glTranslatef)(GLfloat x, GLfloat y, GLfloat z);

+#define glTranslatef _ptrc_glTranslatef

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertex2d)(GLdouble x, GLdouble y);

+#define glVertex2d _ptrc_glVertex2d

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertex2dv)(const GLdouble * v);

+#define glVertex2dv _ptrc_glVertex2dv

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertex2f)(GLfloat x, GLfloat y);

+#define glVertex2f _ptrc_glVertex2f

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertex2fv)(const GLfloat * v);

+#define glVertex2fv _ptrc_glVertex2fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertex2i)(GLint x, GLint y);

+#define glVertex2i _ptrc_glVertex2i

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertex2iv)(const GLint * v);

+#define glVertex2iv _ptrc_glVertex2iv

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertex2s)(GLshort x, GLshort y);

+#define glVertex2s _ptrc_glVertex2s

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertex2sv)(const GLshort * v);

+#define glVertex2sv _ptrc_glVertex2sv

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertex3d)(GLdouble x, GLdouble y, GLdouble z);

+#define glVertex3d _ptrc_glVertex3d

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertex3dv)(const GLdouble * v);

+#define glVertex3dv _ptrc_glVertex3dv

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertex3f)(GLfloat x, GLfloat y, GLfloat z);

+#define glVertex3f _ptrc_glVertex3f

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertex3fv)(const GLfloat * v);

+#define glVertex3fv _ptrc_glVertex3fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertex3i)(GLint x, GLint y, GLint z);

+#define glVertex3i _ptrc_glVertex3i

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertex3iv)(const GLint * v);

+#define glVertex3iv _ptrc_glVertex3iv

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertex3s)(GLshort x, GLshort y, GLshort z);

+#define glVertex3s _ptrc_glVertex3s

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertex3sv)(const GLshort * v);

+#define glVertex3sv _ptrc_glVertex3sv

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertex4d)(GLdouble x, GLdouble y, GLdouble z, GLdouble w);

+#define glVertex4d _ptrc_glVertex4d

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertex4dv)(const GLdouble * v);

+#define glVertex4dv _ptrc_glVertex4dv

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertex4f)(GLfloat x, GLfloat y, GLfloat z, GLfloat w);

+#define glVertex4f _ptrc_glVertex4f

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertex4fv)(const GLfloat * v);

+#define glVertex4fv _ptrc_glVertex4fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertex4i)(GLint x, GLint y, GLint z, GLint w);

+#define glVertex4i _ptrc_glVertex4i

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertex4iv)(const GLint * v);

+#define glVertex4iv _ptrc_glVertex4iv

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertex4s)(GLshort x, GLshort y, GLshort z, GLshort w);

+#define glVertex4s _ptrc_glVertex4s

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertex4sv)(const GLshort * v);

+#define glVertex4sv _ptrc_glVertex4sv

+extern void (CODEGEN_FUNCPTR *_ptrc_glViewport)(GLint x, GLint y, GLsizei width, GLsizei height);

+#define glViewport _ptrc_glViewport

+

+extern GLboolean (CODEGEN_FUNCPTR *_ptrc_glAreTexturesResident)(GLsizei n, const GLuint * textures, GLboolean * residences);

+#define glAreTexturesResident _ptrc_glAreTexturesResident

+extern void (CODEGEN_FUNCPTR *_ptrc_glArrayElement)(GLint i);

+#define glArrayElement _ptrc_glArrayElement

+extern void (CODEGEN_FUNCPTR *_ptrc_glBindTexture)(GLenum target, GLuint texture);

+#define glBindTexture _ptrc_glBindTexture

+extern void (CODEGEN_FUNCPTR *_ptrc_glColorPointer)(GLint size, GLenum type, GLsizei stride, const void * pointer);

+#define glColorPointer _ptrc_glColorPointer

+extern void (CODEGEN_FUNCPTR *_ptrc_glCopyTexImage1D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);

+#define glCopyTexImage1D _ptrc_glCopyTexImage1D

+extern void (CODEGEN_FUNCPTR *_ptrc_glCopyTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);

+#define glCopyTexImage2D _ptrc_glCopyTexImage2D

+extern void (CODEGEN_FUNCPTR *_ptrc_glCopyTexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);

+#define glCopyTexSubImage1D _ptrc_glCopyTexSubImage1D

+extern void (CODEGEN_FUNCPTR *_ptrc_glCopyTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);

+#define glCopyTexSubImage2D _ptrc_glCopyTexSubImage2D

+extern void (CODEGEN_FUNCPTR *_ptrc_glDeleteTextures)(GLsizei n, const GLuint * textures);

+#define glDeleteTextures _ptrc_glDeleteTextures

+extern void (CODEGEN_FUNCPTR *_ptrc_glDisableClientState)(GLenum ren_array);

+#define glDisableClientState _ptrc_glDisableClientState

+extern void (CODEGEN_FUNCPTR *_ptrc_glDrawArrays)(GLenum mode, GLint first, GLsizei count);

+#define glDrawArrays _ptrc_glDrawArrays

+extern void (CODEGEN_FUNCPTR *_ptrc_glDrawElements)(GLenum mode, GLsizei count, GLenum type, const void * indices);

+#define glDrawElements _ptrc_glDrawElements

+extern void (CODEGEN_FUNCPTR *_ptrc_glEdgeFlagPointer)(GLsizei stride, const void * pointer);

+#define glEdgeFlagPointer _ptrc_glEdgeFlagPointer

+extern void (CODEGEN_FUNCPTR *_ptrc_glEnableClientState)(GLenum ren_array);

+#define glEnableClientState _ptrc_glEnableClientState

+extern void (CODEGEN_FUNCPTR *_ptrc_glGenTextures)(GLsizei n, GLuint * textures);

+#define glGenTextures _ptrc_glGenTextures

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetPointerv)(GLenum pname, void ** params);

+#define glGetPointerv _ptrc_glGetPointerv

+extern void (CODEGEN_FUNCPTR *_ptrc_glIndexPointer)(GLenum type, GLsizei stride, const void * pointer);

+#define glIndexPointer _ptrc_glIndexPointer

+extern void (CODEGEN_FUNCPTR *_ptrc_glIndexub)(GLubyte c);

+#define glIndexub _ptrc_glIndexub

+extern void (CODEGEN_FUNCPTR *_ptrc_glIndexubv)(const GLubyte * c);

+#define glIndexubv _ptrc_glIndexubv

+extern void (CODEGEN_FUNCPTR *_ptrc_glInterleavedArrays)(GLenum format, GLsizei stride, const void * pointer);

+#define glInterleavedArrays _ptrc_glInterleavedArrays

+extern GLboolean (CODEGEN_FUNCPTR *_ptrc_glIsTexture)(GLuint texture);

+#define glIsTexture _ptrc_glIsTexture

+extern void (CODEGEN_FUNCPTR *_ptrc_glNormalPointer)(GLenum type, GLsizei stride, const void * pointer);

+#define glNormalPointer _ptrc_glNormalPointer

+extern void (CODEGEN_FUNCPTR *_ptrc_glPolygonOffset)(GLfloat factor, GLfloat units);

+#define glPolygonOffset _ptrc_glPolygonOffset

+extern void (CODEGEN_FUNCPTR *_ptrc_glPopClientAttrib)(void);

+#define glPopClientAttrib _ptrc_glPopClientAttrib

+extern void (CODEGEN_FUNCPTR *_ptrc_glPrioritizeTextures)(GLsizei n, const GLuint * textures, const GLfloat * priorities);

+#define glPrioritizeTextures _ptrc_glPrioritizeTextures

+extern void (CODEGEN_FUNCPTR *_ptrc_glPushClientAttrib)(GLbitfield mask);

+#define glPushClientAttrib _ptrc_glPushClientAttrib

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexCoordPointer)(GLint size, GLenum type, GLsizei stride, const void * pointer);

+#define glTexCoordPointer _ptrc_glTexCoordPointer

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void * pixels);

+#define glTexSubImage1D _ptrc_glTexSubImage1D

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void * pixels);

+#define glTexSubImage2D _ptrc_glTexSubImage2D

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexPointer)(GLint size, GLenum type, GLsizei stride, const void * pointer);

+#define glVertexPointer _ptrc_glVertexPointer

+

+extern void (CODEGEN_FUNCPTR *_ptrc_glCopyTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);

+#define glCopyTexSubImage3D _ptrc_glCopyTexSubImage3D

+extern void (CODEGEN_FUNCPTR *_ptrc_glDrawRangeElements)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void * indices);

+#define glDrawRangeElements _ptrc_glDrawRangeElements

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexImage3D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void * pixels);

+#define glTexImage3D _ptrc_glTexImage3D

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * pixels);

+#define glTexSubImage3D _ptrc_glTexSubImage3D

+

+extern void (CODEGEN_FUNCPTR *_ptrc_glActiveTexture)(GLenum texture);

+#define glActiveTexture _ptrc_glActiveTexture

+extern void (CODEGEN_FUNCPTR *_ptrc_glClientActiveTexture)(GLenum texture);

+#define glClientActiveTexture _ptrc_glClientActiveTexture

+extern void (CODEGEN_FUNCPTR *_ptrc_glCompressedTexImage1D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void * data);

+#define glCompressedTexImage1D _ptrc_glCompressedTexImage1D

+extern void (CODEGEN_FUNCPTR *_ptrc_glCompressedTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void * data);

+#define glCompressedTexImage2D _ptrc_glCompressedTexImage2D

+extern void (CODEGEN_FUNCPTR *_ptrc_glCompressedTexImage3D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void * data);

+#define glCompressedTexImage3D _ptrc_glCompressedTexImage3D

+extern void (CODEGEN_FUNCPTR *_ptrc_glCompressedTexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void * data);

+#define glCompressedTexSubImage1D _ptrc_glCompressedTexSubImage1D

+extern void (CODEGEN_FUNCPTR *_ptrc_glCompressedTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void * data);

+#define glCompressedTexSubImage2D _ptrc_glCompressedTexSubImage2D

+extern void (CODEGEN_FUNCPTR *_ptrc_glCompressedTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void * data);

+#define glCompressedTexSubImage3D _ptrc_glCompressedTexSubImage3D

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetCompressedTexImage)(GLenum target, GLint level, void * img);

+#define glGetCompressedTexImage _ptrc_glGetCompressedTexImage

+extern void (CODEGEN_FUNCPTR *_ptrc_glLoadTransposeMatrixd)(const GLdouble * m);

+#define glLoadTransposeMatrixd _ptrc_glLoadTransposeMatrixd

+extern void (CODEGEN_FUNCPTR *_ptrc_glLoadTransposeMatrixf)(const GLfloat * m);

+#define glLoadTransposeMatrixf _ptrc_glLoadTransposeMatrixf

+extern void (CODEGEN_FUNCPTR *_ptrc_glMultTransposeMatrixd)(const GLdouble * m);

+#define glMultTransposeMatrixd _ptrc_glMultTransposeMatrixd

+extern void (CODEGEN_FUNCPTR *_ptrc_glMultTransposeMatrixf)(const GLfloat * m);

+#define glMultTransposeMatrixf _ptrc_glMultTransposeMatrixf

+extern void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord1d)(GLenum target, GLdouble s);

+#define glMultiTexCoord1d _ptrc_glMultiTexCoord1d

+extern void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord1dv)(GLenum target, const GLdouble * v);

+#define glMultiTexCoord1dv _ptrc_glMultiTexCoord1dv

+extern void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord1f)(GLenum target, GLfloat s);

+#define glMultiTexCoord1f _ptrc_glMultiTexCoord1f

+extern void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord1fv)(GLenum target, const GLfloat * v);

+#define glMultiTexCoord1fv _ptrc_glMultiTexCoord1fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord1i)(GLenum target, GLint s);

+#define glMultiTexCoord1i _ptrc_glMultiTexCoord1i

+extern void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord1iv)(GLenum target, const GLint * v);

+#define glMultiTexCoord1iv _ptrc_glMultiTexCoord1iv

+extern void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord1s)(GLenum target, GLshort s);

+#define glMultiTexCoord1s _ptrc_glMultiTexCoord1s

+extern void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord1sv)(GLenum target, const GLshort * v);

+#define glMultiTexCoord1sv _ptrc_glMultiTexCoord1sv

+extern void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord2d)(GLenum target, GLdouble s, GLdouble t);

+#define glMultiTexCoord2d _ptrc_glMultiTexCoord2d

+extern void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord2dv)(GLenum target, const GLdouble * v);

+#define glMultiTexCoord2dv _ptrc_glMultiTexCoord2dv

+extern void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord2f)(GLenum target, GLfloat s, GLfloat t);

+#define glMultiTexCoord2f _ptrc_glMultiTexCoord2f

+extern void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord2fv)(GLenum target, const GLfloat * v);

+#define glMultiTexCoord2fv _ptrc_glMultiTexCoord2fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord2i)(GLenum target, GLint s, GLint t);

+#define glMultiTexCoord2i _ptrc_glMultiTexCoord2i

+extern void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord2iv)(GLenum target, const GLint * v);

+#define glMultiTexCoord2iv _ptrc_glMultiTexCoord2iv

+extern void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord2s)(GLenum target, GLshort s, GLshort t);

+#define glMultiTexCoord2s _ptrc_glMultiTexCoord2s

+extern void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord2sv)(GLenum target, const GLshort * v);

+#define glMultiTexCoord2sv _ptrc_glMultiTexCoord2sv

+extern void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord3d)(GLenum target, GLdouble s, GLdouble t, GLdouble r);

+#define glMultiTexCoord3d _ptrc_glMultiTexCoord3d

+extern void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord3dv)(GLenum target, const GLdouble * v);

+#define glMultiTexCoord3dv _ptrc_glMultiTexCoord3dv

+extern void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord3f)(GLenum target, GLfloat s, GLfloat t, GLfloat r);

+#define glMultiTexCoord3f _ptrc_glMultiTexCoord3f

+extern void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord3fv)(GLenum target, const GLfloat * v);

+#define glMultiTexCoord3fv _ptrc_glMultiTexCoord3fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord3i)(GLenum target, GLint s, GLint t, GLint r);

+#define glMultiTexCoord3i _ptrc_glMultiTexCoord3i

+extern void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord3iv)(GLenum target, const GLint * v);

+#define glMultiTexCoord3iv _ptrc_glMultiTexCoord3iv

+extern void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord3s)(GLenum target, GLshort s, GLshort t, GLshort r);

+#define glMultiTexCoord3s _ptrc_glMultiTexCoord3s

+extern void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord3sv)(GLenum target, const GLshort * v);

+#define glMultiTexCoord3sv _ptrc_glMultiTexCoord3sv

+extern void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord4d)(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);

+#define glMultiTexCoord4d _ptrc_glMultiTexCoord4d

+extern void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord4dv)(GLenum target, const GLdouble * v);

+#define glMultiTexCoord4dv _ptrc_glMultiTexCoord4dv

+extern void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord4f)(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);

+#define glMultiTexCoord4f _ptrc_glMultiTexCoord4f

+extern void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord4fv)(GLenum target, const GLfloat * v);

+#define glMultiTexCoord4fv _ptrc_glMultiTexCoord4fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord4i)(GLenum target, GLint s, GLint t, GLint r, GLint q);

+#define glMultiTexCoord4i _ptrc_glMultiTexCoord4i

+extern void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord4iv)(GLenum target, const GLint * v);

+#define glMultiTexCoord4iv _ptrc_glMultiTexCoord4iv

+extern void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord4s)(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);

+#define glMultiTexCoord4s _ptrc_glMultiTexCoord4s

+extern void (CODEGEN_FUNCPTR *_ptrc_glMultiTexCoord4sv)(GLenum target, const GLshort * v);

+#define glMultiTexCoord4sv _ptrc_glMultiTexCoord4sv

+extern void (CODEGEN_FUNCPTR *_ptrc_glSampleCoverage)(GLfloat value, GLboolean invert);

+#define glSampleCoverage _ptrc_glSampleCoverage

+

+extern void (CODEGEN_FUNCPTR *_ptrc_glBlendColor)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);

+#define glBlendColor _ptrc_glBlendColor

+extern void (CODEGEN_FUNCPTR *_ptrc_glBlendEquation)(GLenum mode);

+#define glBlendEquation _ptrc_glBlendEquation

+extern void (CODEGEN_FUNCPTR *_ptrc_glBlendFuncSeparate)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);

+#define glBlendFuncSeparate _ptrc_glBlendFuncSeparate

+extern void (CODEGEN_FUNCPTR *_ptrc_glFogCoordPointer)(GLenum type, GLsizei stride, const void * pointer);

+#define glFogCoordPointer _ptrc_glFogCoordPointer

+extern void (CODEGEN_FUNCPTR *_ptrc_glFogCoordd)(GLdouble coord);

+#define glFogCoordd _ptrc_glFogCoordd

+extern void (CODEGEN_FUNCPTR *_ptrc_glFogCoorddv)(const GLdouble * coord);

+#define glFogCoorddv _ptrc_glFogCoorddv

+extern void (CODEGEN_FUNCPTR *_ptrc_glFogCoordf)(GLfloat coord);

+#define glFogCoordf _ptrc_glFogCoordf

+extern void (CODEGEN_FUNCPTR *_ptrc_glFogCoordfv)(const GLfloat * coord);

+#define glFogCoordfv _ptrc_glFogCoordfv

+extern void (CODEGEN_FUNCPTR *_ptrc_glMultiDrawArrays)(GLenum mode, const GLint * first, const GLsizei * count, GLsizei drawcount);

+#define glMultiDrawArrays _ptrc_glMultiDrawArrays

+extern void (CODEGEN_FUNCPTR *_ptrc_glMultiDrawElements)(GLenum mode, const GLsizei * count, GLenum type, const void *const* indices, GLsizei drawcount);

+#define glMultiDrawElements _ptrc_glMultiDrawElements

+extern void (CODEGEN_FUNCPTR *_ptrc_glPointParameterf)(GLenum pname, GLfloat param);

+#define glPointParameterf _ptrc_glPointParameterf

+extern void (CODEGEN_FUNCPTR *_ptrc_glPointParameterfv)(GLenum pname, const GLfloat * params);

+#define glPointParameterfv _ptrc_glPointParameterfv

+extern void (CODEGEN_FUNCPTR *_ptrc_glPointParameteri)(GLenum pname, GLint param);

+#define glPointParameteri _ptrc_glPointParameteri

+extern void (CODEGEN_FUNCPTR *_ptrc_glPointParameteriv)(GLenum pname, const GLint * params);

+#define glPointParameteriv _ptrc_glPointParameteriv

+extern void (CODEGEN_FUNCPTR *_ptrc_glSecondaryColor3b)(GLbyte red, GLbyte green, GLbyte blue);

+#define glSecondaryColor3b _ptrc_glSecondaryColor3b

+extern void (CODEGEN_FUNCPTR *_ptrc_glSecondaryColor3bv)(const GLbyte * v);

+#define glSecondaryColor3bv _ptrc_glSecondaryColor3bv

+extern void (CODEGEN_FUNCPTR *_ptrc_glSecondaryColor3d)(GLdouble red, GLdouble green, GLdouble blue);

+#define glSecondaryColor3d _ptrc_glSecondaryColor3d

+extern void (CODEGEN_FUNCPTR *_ptrc_glSecondaryColor3dv)(const GLdouble * v);

+#define glSecondaryColor3dv _ptrc_glSecondaryColor3dv

+extern void (CODEGEN_FUNCPTR *_ptrc_glSecondaryColor3f)(GLfloat red, GLfloat green, GLfloat blue);

+#define glSecondaryColor3f _ptrc_glSecondaryColor3f

+extern void (CODEGEN_FUNCPTR *_ptrc_glSecondaryColor3fv)(const GLfloat * v);

+#define glSecondaryColor3fv _ptrc_glSecondaryColor3fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glSecondaryColor3i)(GLint red, GLint green, GLint blue);

+#define glSecondaryColor3i _ptrc_glSecondaryColor3i

+extern void (CODEGEN_FUNCPTR *_ptrc_glSecondaryColor3iv)(const GLint * v);

+#define glSecondaryColor3iv _ptrc_glSecondaryColor3iv

+extern void (CODEGEN_FUNCPTR *_ptrc_glSecondaryColor3s)(GLshort red, GLshort green, GLshort blue);

+#define glSecondaryColor3s _ptrc_glSecondaryColor3s

+extern void (CODEGEN_FUNCPTR *_ptrc_glSecondaryColor3sv)(const GLshort * v);

+#define glSecondaryColor3sv _ptrc_glSecondaryColor3sv

+extern void (CODEGEN_FUNCPTR *_ptrc_glSecondaryColor3ub)(GLubyte red, GLubyte green, GLubyte blue);

+#define glSecondaryColor3ub _ptrc_glSecondaryColor3ub

+extern void (CODEGEN_FUNCPTR *_ptrc_glSecondaryColor3ubv)(const GLubyte * v);

+#define glSecondaryColor3ubv _ptrc_glSecondaryColor3ubv

+extern void (CODEGEN_FUNCPTR *_ptrc_glSecondaryColor3ui)(GLuint red, GLuint green, GLuint blue);

+#define glSecondaryColor3ui _ptrc_glSecondaryColor3ui

+extern void (CODEGEN_FUNCPTR *_ptrc_glSecondaryColor3uiv)(const GLuint * v);

+#define glSecondaryColor3uiv _ptrc_glSecondaryColor3uiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glSecondaryColor3us)(GLushort red, GLushort green, GLushort blue);

+#define glSecondaryColor3us _ptrc_glSecondaryColor3us

+extern void (CODEGEN_FUNCPTR *_ptrc_glSecondaryColor3usv)(const GLushort * v);

+#define glSecondaryColor3usv _ptrc_glSecondaryColor3usv

+extern void (CODEGEN_FUNCPTR *_ptrc_glSecondaryColorPointer)(GLint size, GLenum type, GLsizei stride, const void * pointer);

+#define glSecondaryColorPointer _ptrc_glSecondaryColorPointer

+extern void (CODEGEN_FUNCPTR *_ptrc_glWindowPos2d)(GLdouble x, GLdouble y);

+#define glWindowPos2d _ptrc_glWindowPos2d

+extern void (CODEGEN_FUNCPTR *_ptrc_glWindowPos2dv)(const GLdouble * v);

+#define glWindowPos2dv _ptrc_glWindowPos2dv

+extern void (CODEGEN_FUNCPTR *_ptrc_glWindowPos2f)(GLfloat x, GLfloat y);

+#define glWindowPos2f _ptrc_glWindowPos2f

+extern void (CODEGEN_FUNCPTR *_ptrc_glWindowPos2fv)(const GLfloat * v);

+#define glWindowPos2fv _ptrc_glWindowPos2fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glWindowPos2i)(GLint x, GLint y);

+#define glWindowPos2i _ptrc_glWindowPos2i

+extern void (CODEGEN_FUNCPTR *_ptrc_glWindowPos2iv)(const GLint * v);

+#define glWindowPos2iv _ptrc_glWindowPos2iv

+extern void (CODEGEN_FUNCPTR *_ptrc_glWindowPos2s)(GLshort x, GLshort y);

+#define glWindowPos2s _ptrc_glWindowPos2s

+extern void (CODEGEN_FUNCPTR *_ptrc_glWindowPos2sv)(const GLshort * v);

+#define glWindowPos2sv _ptrc_glWindowPos2sv

+extern void (CODEGEN_FUNCPTR *_ptrc_glWindowPos3d)(GLdouble x, GLdouble y, GLdouble z);

+#define glWindowPos3d _ptrc_glWindowPos3d

+extern void (CODEGEN_FUNCPTR *_ptrc_glWindowPos3dv)(const GLdouble * v);

+#define glWindowPos3dv _ptrc_glWindowPos3dv

+extern void (CODEGEN_FUNCPTR *_ptrc_glWindowPos3f)(GLfloat x, GLfloat y, GLfloat z);

+#define glWindowPos3f _ptrc_glWindowPos3f

+extern void (CODEGEN_FUNCPTR *_ptrc_glWindowPos3fv)(const GLfloat * v);

+#define glWindowPos3fv _ptrc_glWindowPos3fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glWindowPos3i)(GLint x, GLint y, GLint z);

+#define glWindowPos3i _ptrc_glWindowPos3i

+extern void (CODEGEN_FUNCPTR *_ptrc_glWindowPos3iv)(const GLint * v);

+#define glWindowPos3iv _ptrc_glWindowPos3iv

+extern void (CODEGEN_FUNCPTR *_ptrc_glWindowPos3s)(GLshort x, GLshort y, GLshort z);

+#define glWindowPos3s _ptrc_glWindowPos3s

+extern void (CODEGEN_FUNCPTR *_ptrc_glWindowPos3sv)(const GLshort * v);

+#define glWindowPos3sv _ptrc_glWindowPos3sv

+

+extern void (CODEGEN_FUNCPTR *_ptrc_glBeginQuery)(GLenum target, GLuint id);

+#define glBeginQuery _ptrc_glBeginQuery

+extern void (CODEGEN_FUNCPTR *_ptrc_glBindBuffer)(GLenum target, GLuint buffer);

+#define glBindBuffer _ptrc_glBindBuffer

+extern void (CODEGEN_FUNCPTR *_ptrc_glBufferData)(GLenum target, GLsizeiptr size, const void * data, GLenum usage);

+#define glBufferData _ptrc_glBufferData

+extern void (CODEGEN_FUNCPTR *_ptrc_glBufferSubData)(GLenum target, GLintptr offset, GLsizeiptr size, const void * data);

+#define glBufferSubData _ptrc_glBufferSubData

+extern void (CODEGEN_FUNCPTR *_ptrc_glDeleteBuffers)(GLsizei n, const GLuint * buffers);

+#define glDeleteBuffers _ptrc_glDeleteBuffers

+extern void (CODEGEN_FUNCPTR *_ptrc_glDeleteQueries)(GLsizei n, const GLuint * ids);

+#define glDeleteQueries _ptrc_glDeleteQueries

+extern void (CODEGEN_FUNCPTR *_ptrc_glEndQuery)(GLenum target);

+#define glEndQuery _ptrc_glEndQuery

+extern void (CODEGEN_FUNCPTR *_ptrc_glGenBuffers)(GLsizei n, GLuint * buffers);

+#define glGenBuffers _ptrc_glGenBuffers

+extern void (CODEGEN_FUNCPTR *_ptrc_glGenQueries)(GLsizei n, GLuint * ids);

+#define glGenQueries _ptrc_glGenQueries

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetBufferParameteriv)(GLenum target, GLenum pname, GLint * params);

+#define glGetBufferParameteriv _ptrc_glGetBufferParameteriv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetBufferPointerv)(GLenum target, GLenum pname, void ** params);

+#define glGetBufferPointerv _ptrc_glGetBufferPointerv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetBufferSubData)(GLenum target, GLintptr offset, GLsizeiptr size, void * data);

+#define glGetBufferSubData _ptrc_glGetBufferSubData

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetQueryObjectiv)(GLuint id, GLenum pname, GLint * params);

+#define glGetQueryObjectiv _ptrc_glGetQueryObjectiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetQueryObjectuiv)(GLuint id, GLenum pname, GLuint * params);

+#define glGetQueryObjectuiv _ptrc_glGetQueryObjectuiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetQueryiv)(GLenum target, GLenum pname, GLint * params);

+#define glGetQueryiv _ptrc_glGetQueryiv

+extern GLboolean (CODEGEN_FUNCPTR *_ptrc_glIsBuffer)(GLuint buffer);

+#define glIsBuffer _ptrc_glIsBuffer

+extern GLboolean (CODEGEN_FUNCPTR *_ptrc_glIsQuery)(GLuint id);

+#define glIsQuery _ptrc_glIsQuery

+extern void * (CODEGEN_FUNCPTR *_ptrc_glMapBuffer)(GLenum target, GLenum access);

+#define glMapBuffer _ptrc_glMapBuffer

+extern GLboolean (CODEGEN_FUNCPTR *_ptrc_glUnmapBuffer)(GLenum target);

+#define glUnmapBuffer _ptrc_glUnmapBuffer

+

+extern void (CODEGEN_FUNCPTR *_ptrc_glAttachShader)(GLuint program, GLuint shader);

+#define glAttachShader _ptrc_glAttachShader

+extern void (CODEGEN_FUNCPTR *_ptrc_glBindAttribLocation)(GLuint program, GLuint index, const GLchar * name);

+#define glBindAttribLocation _ptrc_glBindAttribLocation

+extern void (CODEGEN_FUNCPTR *_ptrc_glBlendEquationSeparate)(GLenum modeRGB, GLenum modeAlpha);

+#define glBlendEquationSeparate _ptrc_glBlendEquationSeparate

+extern void (CODEGEN_FUNCPTR *_ptrc_glCompileShader)(GLuint shader);

+#define glCompileShader _ptrc_glCompileShader

+extern GLuint (CODEGEN_FUNCPTR *_ptrc_glCreateProgram)(void);

+#define glCreateProgram _ptrc_glCreateProgram

+extern GLuint (CODEGEN_FUNCPTR *_ptrc_glCreateShader)(GLenum type);

+#define glCreateShader _ptrc_glCreateShader

+extern void (CODEGEN_FUNCPTR *_ptrc_glDeleteProgram)(GLuint program);

+#define glDeleteProgram _ptrc_glDeleteProgram

+extern void (CODEGEN_FUNCPTR *_ptrc_glDeleteShader)(GLuint shader);

+#define glDeleteShader _ptrc_glDeleteShader

+extern void (CODEGEN_FUNCPTR *_ptrc_glDetachShader)(GLuint program, GLuint shader);

+#define glDetachShader _ptrc_glDetachShader

+extern void (CODEGEN_FUNCPTR *_ptrc_glDisableVertexAttribArray)(GLuint index);

+#define glDisableVertexAttribArray _ptrc_glDisableVertexAttribArray

+extern void (CODEGEN_FUNCPTR *_ptrc_glDrawBuffers)(GLsizei n, const GLenum * bufs);

+#define glDrawBuffers _ptrc_glDrawBuffers

+extern void (CODEGEN_FUNCPTR *_ptrc_glEnableVertexAttribArray)(GLuint index);

+#define glEnableVertexAttribArray _ptrc_glEnableVertexAttribArray

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetActiveAttrib)(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name);

+#define glGetActiveAttrib _ptrc_glGetActiveAttrib

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetActiveUniform)(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLint * size, GLenum * type, GLchar * name);

+#define glGetActiveUniform _ptrc_glGetActiveUniform

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetAttachedShaders)(GLuint program, GLsizei maxCount, GLsizei * count, GLuint * shaders);

+#define glGetAttachedShaders _ptrc_glGetAttachedShaders

+extern GLint (CODEGEN_FUNCPTR *_ptrc_glGetAttribLocation)(GLuint program, const GLchar * name);

+#define glGetAttribLocation _ptrc_glGetAttribLocation

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetProgramInfoLog)(GLuint program, GLsizei bufSize, GLsizei * length, GLchar * infoLog);

+#define glGetProgramInfoLog _ptrc_glGetProgramInfoLog

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetProgramiv)(GLuint program, GLenum pname, GLint * params);

+#define glGetProgramiv _ptrc_glGetProgramiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetShaderInfoLog)(GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * infoLog);

+#define glGetShaderInfoLog _ptrc_glGetShaderInfoLog

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetShaderSource)(GLuint shader, GLsizei bufSize, GLsizei * length, GLchar * source);

+#define glGetShaderSource _ptrc_glGetShaderSource

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetShaderiv)(GLuint shader, GLenum pname, GLint * params);

+#define glGetShaderiv _ptrc_glGetShaderiv

+extern GLint (CODEGEN_FUNCPTR *_ptrc_glGetUniformLocation)(GLuint program, const GLchar * name);

+#define glGetUniformLocation _ptrc_glGetUniformLocation

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetUniformfv)(GLuint program, GLint location, GLfloat * params);

+#define glGetUniformfv _ptrc_glGetUniformfv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetUniformiv)(GLuint program, GLint location, GLint * params);

+#define glGetUniformiv _ptrc_glGetUniformiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetVertexAttribPointerv)(GLuint index, GLenum pname, void ** pointer);

+#define glGetVertexAttribPointerv _ptrc_glGetVertexAttribPointerv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetVertexAttribdv)(GLuint index, GLenum pname, GLdouble * params);

+#define glGetVertexAttribdv _ptrc_glGetVertexAttribdv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetVertexAttribfv)(GLuint index, GLenum pname, GLfloat * params);

+#define glGetVertexAttribfv _ptrc_glGetVertexAttribfv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetVertexAttribiv)(GLuint index, GLenum pname, GLint * params);

+#define glGetVertexAttribiv _ptrc_glGetVertexAttribiv

+extern GLboolean (CODEGEN_FUNCPTR *_ptrc_glIsProgram)(GLuint program);

+#define glIsProgram _ptrc_glIsProgram

+extern GLboolean (CODEGEN_FUNCPTR *_ptrc_glIsShader)(GLuint shader);

+#define glIsShader _ptrc_glIsShader

+extern void (CODEGEN_FUNCPTR *_ptrc_glLinkProgram)(GLuint program);

+#define glLinkProgram _ptrc_glLinkProgram

+extern void (CODEGEN_FUNCPTR *_ptrc_glShaderSource)(GLuint shader, GLsizei count, const GLchar *const* string, const GLint * length);

+#define glShaderSource _ptrc_glShaderSource

+extern void (CODEGEN_FUNCPTR *_ptrc_glStencilFuncSeparate)(GLenum face, GLenum func, GLint ref, GLuint mask);

+#define glStencilFuncSeparate _ptrc_glStencilFuncSeparate

+extern void (CODEGEN_FUNCPTR *_ptrc_glStencilMaskSeparate)(GLenum face, GLuint mask);

+#define glStencilMaskSeparate _ptrc_glStencilMaskSeparate

+extern void (CODEGEN_FUNCPTR *_ptrc_glStencilOpSeparate)(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);

+#define glStencilOpSeparate _ptrc_glStencilOpSeparate

+extern void (CODEGEN_FUNCPTR *_ptrc_glUniform1f)(GLint location, GLfloat v0);

+#define glUniform1f _ptrc_glUniform1f

+extern void (CODEGEN_FUNCPTR *_ptrc_glUniform1fv)(GLint location, GLsizei count, const GLfloat * value);

+#define glUniform1fv _ptrc_glUniform1fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glUniform1i)(GLint location, GLint v0);

+#define glUniform1i _ptrc_glUniform1i

+extern void (CODEGEN_FUNCPTR *_ptrc_glUniform1iv)(GLint location, GLsizei count, const GLint * value);

+#define glUniform1iv _ptrc_glUniform1iv

+extern void (CODEGEN_FUNCPTR *_ptrc_glUniform2f)(GLint location, GLfloat v0, GLfloat v1);

+#define glUniform2f _ptrc_glUniform2f

+extern void (CODEGEN_FUNCPTR *_ptrc_glUniform2fv)(GLint location, GLsizei count, const GLfloat * value);

+#define glUniform2fv _ptrc_glUniform2fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glUniform2i)(GLint location, GLint v0, GLint v1);

+#define glUniform2i _ptrc_glUniform2i

+extern void (CODEGEN_FUNCPTR *_ptrc_glUniform2iv)(GLint location, GLsizei count, const GLint * value);

+#define glUniform2iv _ptrc_glUniform2iv

+extern void (CODEGEN_FUNCPTR *_ptrc_glUniform3f)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);

+#define glUniform3f _ptrc_glUniform3f

+extern void (CODEGEN_FUNCPTR *_ptrc_glUniform3fv)(GLint location, GLsizei count, const GLfloat * value);

+#define glUniform3fv _ptrc_glUniform3fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glUniform3i)(GLint location, GLint v0, GLint v1, GLint v2);

+#define glUniform3i _ptrc_glUniform3i

+extern void (CODEGEN_FUNCPTR *_ptrc_glUniform3iv)(GLint location, GLsizei count, const GLint * value);

+#define glUniform3iv _ptrc_glUniform3iv

+extern void (CODEGEN_FUNCPTR *_ptrc_glUniform4f)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);

+#define glUniform4f _ptrc_glUniform4f

+extern void (CODEGEN_FUNCPTR *_ptrc_glUniform4fv)(GLint location, GLsizei count, const GLfloat * value);

+#define glUniform4fv _ptrc_glUniform4fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glUniform4i)(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);

+#define glUniform4i _ptrc_glUniform4i

+extern void (CODEGEN_FUNCPTR *_ptrc_glUniform4iv)(GLint location, GLsizei count, const GLint * value);

+#define glUniform4iv _ptrc_glUniform4iv

+extern void (CODEGEN_FUNCPTR *_ptrc_glUniformMatrix2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);

+#define glUniformMatrix2fv _ptrc_glUniformMatrix2fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glUniformMatrix3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);

+#define glUniformMatrix3fv _ptrc_glUniformMatrix3fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glUniformMatrix4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);

+#define glUniformMatrix4fv _ptrc_glUniformMatrix4fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glUseProgram)(GLuint program);

+#define glUseProgram _ptrc_glUseProgram

+extern void (CODEGEN_FUNCPTR *_ptrc_glValidateProgram)(GLuint program);

+#define glValidateProgram _ptrc_glValidateProgram

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib1d)(GLuint index, GLdouble x);

+#define glVertexAttrib1d _ptrc_glVertexAttrib1d

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib1dv)(GLuint index, const GLdouble * v);

+#define glVertexAttrib1dv _ptrc_glVertexAttrib1dv

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib1f)(GLuint index, GLfloat x);

+#define glVertexAttrib1f _ptrc_glVertexAttrib1f

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib1fv)(GLuint index, const GLfloat * v);

+#define glVertexAttrib1fv _ptrc_glVertexAttrib1fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib1s)(GLuint index, GLshort x);

+#define glVertexAttrib1s _ptrc_glVertexAttrib1s

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib1sv)(GLuint index, const GLshort * v);

+#define glVertexAttrib1sv _ptrc_glVertexAttrib1sv

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib2d)(GLuint index, GLdouble x, GLdouble y);

+#define glVertexAttrib2d _ptrc_glVertexAttrib2d

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib2dv)(GLuint index, const GLdouble * v);

+#define glVertexAttrib2dv _ptrc_glVertexAttrib2dv

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib2f)(GLuint index, GLfloat x, GLfloat y);

+#define glVertexAttrib2f _ptrc_glVertexAttrib2f

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib2fv)(GLuint index, const GLfloat * v);

+#define glVertexAttrib2fv _ptrc_glVertexAttrib2fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib2s)(GLuint index, GLshort x, GLshort y);

+#define glVertexAttrib2s _ptrc_glVertexAttrib2s

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib2sv)(GLuint index, const GLshort * v);

+#define glVertexAttrib2sv _ptrc_glVertexAttrib2sv

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib3d)(GLuint index, GLdouble x, GLdouble y, GLdouble z);

+#define glVertexAttrib3d _ptrc_glVertexAttrib3d

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib3dv)(GLuint index, const GLdouble * v);

+#define glVertexAttrib3dv _ptrc_glVertexAttrib3dv

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib3f)(GLuint index, GLfloat x, GLfloat y, GLfloat z);

+#define glVertexAttrib3f _ptrc_glVertexAttrib3f

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib3fv)(GLuint index, const GLfloat * v);

+#define glVertexAttrib3fv _ptrc_glVertexAttrib3fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib3s)(GLuint index, GLshort x, GLshort y, GLshort z);

+#define glVertexAttrib3s _ptrc_glVertexAttrib3s

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib3sv)(GLuint index, const GLshort * v);

+#define glVertexAttrib3sv _ptrc_glVertexAttrib3sv

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib4Nbv)(GLuint index, const GLbyte * v);

+#define glVertexAttrib4Nbv _ptrc_glVertexAttrib4Nbv

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib4Niv)(GLuint index, const GLint * v);

+#define glVertexAttrib4Niv _ptrc_glVertexAttrib4Niv

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib4Nsv)(GLuint index, const GLshort * v);

+#define glVertexAttrib4Nsv _ptrc_glVertexAttrib4Nsv

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib4Nub)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);

+#define glVertexAttrib4Nub _ptrc_glVertexAttrib4Nub

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib4Nubv)(GLuint index, const GLubyte * v);

+#define glVertexAttrib4Nubv _ptrc_glVertexAttrib4Nubv

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib4Nuiv)(GLuint index, const GLuint * v);

+#define glVertexAttrib4Nuiv _ptrc_glVertexAttrib4Nuiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib4Nusv)(GLuint index, const GLushort * v);

+#define glVertexAttrib4Nusv _ptrc_glVertexAttrib4Nusv

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib4bv)(GLuint index, const GLbyte * v);

+#define glVertexAttrib4bv _ptrc_glVertexAttrib4bv

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib4d)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);

+#define glVertexAttrib4d _ptrc_glVertexAttrib4d

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib4dv)(GLuint index, const GLdouble * v);

+#define glVertexAttrib4dv _ptrc_glVertexAttrib4dv

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib4f)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);

+#define glVertexAttrib4f _ptrc_glVertexAttrib4f

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib4fv)(GLuint index, const GLfloat * v);

+#define glVertexAttrib4fv _ptrc_glVertexAttrib4fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib4iv)(GLuint index, const GLint * v);

+#define glVertexAttrib4iv _ptrc_glVertexAttrib4iv

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib4s)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);

+#define glVertexAttrib4s _ptrc_glVertexAttrib4s

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib4sv)(GLuint index, const GLshort * v);

+#define glVertexAttrib4sv _ptrc_glVertexAttrib4sv

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib4ubv)(GLuint index, const GLubyte * v);

+#define glVertexAttrib4ubv _ptrc_glVertexAttrib4ubv

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib4uiv)(GLuint index, const GLuint * v);

+#define glVertexAttrib4uiv _ptrc_glVertexAttrib4uiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttrib4usv)(GLuint index, const GLushort * v);

+#define glVertexAttrib4usv _ptrc_glVertexAttrib4usv

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribPointer)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void * pointer);

+#define glVertexAttribPointer _ptrc_glVertexAttribPointer

+

+extern void (CODEGEN_FUNCPTR *_ptrc_glUniformMatrix2x3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);

+#define glUniformMatrix2x3fv _ptrc_glUniformMatrix2x3fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glUniformMatrix2x4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);

+#define glUniformMatrix2x4fv _ptrc_glUniformMatrix2x4fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glUniformMatrix3x2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);

+#define glUniformMatrix3x2fv _ptrc_glUniformMatrix3x2fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glUniformMatrix3x4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);

+#define glUniformMatrix3x4fv _ptrc_glUniformMatrix3x4fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glUniformMatrix4x2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);

+#define glUniformMatrix4x2fv _ptrc_glUniformMatrix4x2fv

+extern void (CODEGEN_FUNCPTR *_ptrc_glUniformMatrix4x3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value);

+#define glUniformMatrix4x3fv _ptrc_glUniformMatrix4x3fv

+

+extern void (CODEGEN_FUNCPTR *_ptrc_glBeginConditionalRender)(GLuint id, GLenum mode);

+#define glBeginConditionalRender _ptrc_glBeginConditionalRender

+extern void (CODEGEN_FUNCPTR *_ptrc_glBeginTransformFeedback)(GLenum primitiveMode);

+#define glBeginTransformFeedback _ptrc_glBeginTransformFeedback

+extern void (CODEGEN_FUNCPTR *_ptrc_glBindBufferBase)(GLenum target, GLuint index, GLuint buffer);

+#define glBindBufferBase _ptrc_glBindBufferBase

+extern void (CODEGEN_FUNCPTR *_ptrc_glBindBufferRange)(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);

+#define glBindBufferRange _ptrc_glBindBufferRange

+extern void (CODEGEN_FUNCPTR *_ptrc_glBindFragDataLocation)(GLuint program, GLuint color, const GLchar * name);

+#define glBindFragDataLocation _ptrc_glBindFragDataLocation

+extern void (CODEGEN_FUNCPTR *_ptrc_glBindFramebuffer)(GLenum target, GLuint framebuffer);

+#define glBindFramebuffer _ptrc_glBindFramebuffer

+extern void (CODEGEN_FUNCPTR *_ptrc_glBindRenderbuffer)(GLenum target, GLuint renderbuffer);

+#define glBindRenderbuffer _ptrc_glBindRenderbuffer

+extern void (CODEGEN_FUNCPTR *_ptrc_glBindVertexArray)(GLuint ren_array);

+#define glBindVertexArray _ptrc_glBindVertexArray

+extern void (CODEGEN_FUNCPTR *_ptrc_glBlitFramebuffer)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);

+#define glBlitFramebuffer _ptrc_glBlitFramebuffer

+extern GLenum (CODEGEN_FUNCPTR *_ptrc_glCheckFramebufferStatus)(GLenum target);

+#define glCheckFramebufferStatus _ptrc_glCheckFramebufferStatus

+extern void (CODEGEN_FUNCPTR *_ptrc_glClampColor)(GLenum target, GLenum clamp);

+#define glClampColor _ptrc_glClampColor

+extern void (CODEGEN_FUNCPTR *_ptrc_glClearBufferfi)(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);

+#define glClearBufferfi _ptrc_glClearBufferfi

+extern void (CODEGEN_FUNCPTR *_ptrc_glClearBufferfv)(GLenum buffer, GLint drawbuffer, const GLfloat * value);

+#define glClearBufferfv _ptrc_glClearBufferfv

+extern void (CODEGEN_FUNCPTR *_ptrc_glClearBufferiv)(GLenum buffer, GLint drawbuffer, const GLint * value);

+#define glClearBufferiv _ptrc_glClearBufferiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glClearBufferuiv)(GLenum buffer, GLint drawbuffer, const GLuint * value);

+#define glClearBufferuiv _ptrc_glClearBufferuiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glColorMaski)(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a);

+#define glColorMaski _ptrc_glColorMaski

+extern void (CODEGEN_FUNCPTR *_ptrc_glDeleteFramebuffers)(GLsizei n, const GLuint * framebuffers);

+#define glDeleteFramebuffers _ptrc_glDeleteFramebuffers

+extern void (CODEGEN_FUNCPTR *_ptrc_glDeleteRenderbuffers)(GLsizei n, const GLuint * renderbuffers);

+#define glDeleteRenderbuffers _ptrc_glDeleteRenderbuffers

+extern void (CODEGEN_FUNCPTR *_ptrc_glDeleteVertexArrays)(GLsizei n, const GLuint * arrays);

+#define glDeleteVertexArrays _ptrc_glDeleteVertexArrays

+extern void (CODEGEN_FUNCPTR *_ptrc_glDisablei)(GLenum target, GLuint index);

+#define glDisablei _ptrc_glDisablei

+extern void (CODEGEN_FUNCPTR *_ptrc_glEnablei)(GLenum target, GLuint index);

+#define glEnablei _ptrc_glEnablei

+extern void (CODEGEN_FUNCPTR *_ptrc_glEndConditionalRender)(void);

+#define glEndConditionalRender _ptrc_glEndConditionalRender

+extern void (CODEGEN_FUNCPTR *_ptrc_glEndTransformFeedback)(void);

+#define glEndTransformFeedback _ptrc_glEndTransformFeedback

+extern void (CODEGEN_FUNCPTR *_ptrc_glFlushMappedBufferRange)(GLenum target, GLintptr offset, GLsizeiptr length);

+#define glFlushMappedBufferRange _ptrc_glFlushMappedBufferRange

+extern void (CODEGEN_FUNCPTR *_ptrc_glFramebufferRenderbuffer)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);

+#define glFramebufferRenderbuffer _ptrc_glFramebufferRenderbuffer

+extern void (CODEGEN_FUNCPTR *_ptrc_glFramebufferTexture1D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);

+#define glFramebufferTexture1D _ptrc_glFramebufferTexture1D

+extern void (CODEGEN_FUNCPTR *_ptrc_glFramebufferTexture2D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);

+#define glFramebufferTexture2D _ptrc_glFramebufferTexture2D

+extern void (CODEGEN_FUNCPTR *_ptrc_glFramebufferTexture3D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);

+#define glFramebufferTexture3D _ptrc_glFramebufferTexture3D

+extern void (CODEGEN_FUNCPTR *_ptrc_glFramebufferTextureLayer)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);

+#define glFramebufferTextureLayer _ptrc_glFramebufferTextureLayer

+extern void (CODEGEN_FUNCPTR *_ptrc_glGenFramebuffers)(GLsizei n, GLuint * framebuffers);

+#define glGenFramebuffers _ptrc_glGenFramebuffers

+extern void (CODEGEN_FUNCPTR *_ptrc_glGenRenderbuffers)(GLsizei n, GLuint * renderbuffers);

+#define glGenRenderbuffers _ptrc_glGenRenderbuffers

+extern void (CODEGEN_FUNCPTR *_ptrc_glGenVertexArrays)(GLsizei n, GLuint * arrays);

+#define glGenVertexArrays _ptrc_glGenVertexArrays

+extern void (CODEGEN_FUNCPTR *_ptrc_glGenerateMipmap)(GLenum target);

+#define glGenerateMipmap _ptrc_glGenerateMipmap

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetBooleani_v)(GLenum target, GLuint index, GLboolean * data);

+#define glGetBooleani_v _ptrc_glGetBooleani_v

+extern GLint (CODEGEN_FUNCPTR *_ptrc_glGetFragDataLocation)(GLuint program, const GLchar * name);

+#define glGetFragDataLocation _ptrc_glGetFragDataLocation

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetFramebufferAttachmentParameteriv)(GLenum target, GLenum attachment, GLenum pname, GLint * params);

+#define glGetFramebufferAttachmentParameteriv _ptrc_glGetFramebufferAttachmentParameteriv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetIntegeri_v)(GLenum target, GLuint index, GLint * data);

+#define glGetIntegeri_v _ptrc_glGetIntegeri_v

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetRenderbufferParameteriv)(GLenum target, GLenum pname, GLint * params);

+#define glGetRenderbufferParameteriv _ptrc_glGetRenderbufferParameteriv

+extern const GLubyte * (CODEGEN_FUNCPTR *_ptrc_glGetStringi)(GLenum name, GLuint index);

+#define glGetStringi _ptrc_glGetStringi

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetTexParameterIiv)(GLenum target, GLenum pname, GLint * params);

+#define glGetTexParameterIiv _ptrc_glGetTexParameterIiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetTexParameterIuiv)(GLenum target, GLenum pname, GLuint * params);

+#define glGetTexParameterIuiv _ptrc_glGetTexParameterIuiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetTransformFeedbackVarying)(GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLsizei * size, GLenum * type, GLchar * name);

+#define glGetTransformFeedbackVarying _ptrc_glGetTransformFeedbackVarying

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetUniformuiv)(GLuint program, GLint location, GLuint * params);

+#define glGetUniformuiv _ptrc_glGetUniformuiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetVertexAttribIiv)(GLuint index, GLenum pname, GLint * params);

+#define glGetVertexAttribIiv _ptrc_glGetVertexAttribIiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetVertexAttribIuiv)(GLuint index, GLenum pname, GLuint * params);

+#define glGetVertexAttribIuiv _ptrc_glGetVertexAttribIuiv

+extern GLboolean (CODEGEN_FUNCPTR *_ptrc_glIsEnabledi)(GLenum target, GLuint index);

+#define glIsEnabledi _ptrc_glIsEnabledi

+extern GLboolean (CODEGEN_FUNCPTR *_ptrc_glIsFramebuffer)(GLuint framebuffer);

+#define glIsFramebuffer _ptrc_glIsFramebuffer

+extern GLboolean (CODEGEN_FUNCPTR *_ptrc_glIsRenderbuffer)(GLuint renderbuffer);

+#define glIsRenderbuffer _ptrc_glIsRenderbuffer

+extern GLboolean (CODEGEN_FUNCPTR *_ptrc_glIsVertexArray)(GLuint ren_array);

+#define glIsVertexArray _ptrc_glIsVertexArray

+extern void * (CODEGEN_FUNCPTR *_ptrc_glMapBufferRange)(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);

+#define glMapBufferRange _ptrc_glMapBufferRange

+extern void (CODEGEN_FUNCPTR *_ptrc_glRenderbufferStorage)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);

+#define glRenderbufferStorage _ptrc_glRenderbufferStorage

+extern void (CODEGEN_FUNCPTR *_ptrc_glRenderbufferStorageMultisample)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);

+#define glRenderbufferStorageMultisample _ptrc_glRenderbufferStorageMultisample

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexParameterIiv)(GLenum target, GLenum pname, const GLint * params);

+#define glTexParameterIiv _ptrc_glTexParameterIiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexParameterIuiv)(GLenum target, GLenum pname, const GLuint * params);

+#define glTexParameterIuiv _ptrc_glTexParameterIuiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glTransformFeedbackVaryings)(GLuint program, GLsizei count, const GLchar *const* varyings, GLenum bufferMode);

+#define glTransformFeedbackVaryings _ptrc_glTransformFeedbackVaryings

+extern void (CODEGEN_FUNCPTR *_ptrc_glUniform1ui)(GLint location, GLuint v0);

+#define glUniform1ui _ptrc_glUniform1ui

+extern void (CODEGEN_FUNCPTR *_ptrc_glUniform1uiv)(GLint location, GLsizei count, const GLuint * value);

+#define glUniform1uiv _ptrc_glUniform1uiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glUniform2ui)(GLint location, GLuint v0, GLuint v1);

+#define glUniform2ui _ptrc_glUniform2ui

+extern void (CODEGEN_FUNCPTR *_ptrc_glUniform2uiv)(GLint location, GLsizei count, const GLuint * value);

+#define glUniform2uiv _ptrc_glUniform2uiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glUniform3ui)(GLint location, GLuint v0, GLuint v1, GLuint v2);

+#define glUniform3ui _ptrc_glUniform3ui

+extern void (CODEGEN_FUNCPTR *_ptrc_glUniform3uiv)(GLint location, GLsizei count, const GLuint * value);

+#define glUniform3uiv _ptrc_glUniform3uiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glUniform4ui)(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);

+#define glUniform4ui _ptrc_glUniform4ui

+extern void (CODEGEN_FUNCPTR *_ptrc_glUniform4uiv)(GLint location, GLsizei count, const GLuint * value);

+#define glUniform4uiv _ptrc_glUniform4uiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribI1i)(GLuint index, GLint x);

+#define glVertexAttribI1i _ptrc_glVertexAttribI1i

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribI1iv)(GLuint index, const GLint * v);

+#define glVertexAttribI1iv _ptrc_glVertexAttribI1iv

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribI1ui)(GLuint index, GLuint x);

+#define glVertexAttribI1ui _ptrc_glVertexAttribI1ui

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribI1uiv)(GLuint index, const GLuint * v);

+#define glVertexAttribI1uiv _ptrc_glVertexAttribI1uiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribI2i)(GLuint index, GLint x, GLint y);

+#define glVertexAttribI2i _ptrc_glVertexAttribI2i

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribI2iv)(GLuint index, const GLint * v);

+#define glVertexAttribI2iv _ptrc_glVertexAttribI2iv

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribI2ui)(GLuint index, GLuint x, GLuint y);

+#define glVertexAttribI2ui _ptrc_glVertexAttribI2ui

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribI2uiv)(GLuint index, const GLuint * v);

+#define glVertexAttribI2uiv _ptrc_glVertexAttribI2uiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribI3i)(GLuint index, GLint x, GLint y, GLint z);

+#define glVertexAttribI3i _ptrc_glVertexAttribI3i

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribI3iv)(GLuint index, const GLint * v);

+#define glVertexAttribI3iv _ptrc_glVertexAttribI3iv

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribI3ui)(GLuint index, GLuint x, GLuint y, GLuint z);

+#define glVertexAttribI3ui _ptrc_glVertexAttribI3ui

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribI3uiv)(GLuint index, const GLuint * v);

+#define glVertexAttribI3uiv _ptrc_glVertexAttribI3uiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribI4bv)(GLuint index, const GLbyte * v);

+#define glVertexAttribI4bv _ptrc_glVertexAttribI4bv

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribI4i)(GLuint index, GLint x, GLint y, GLint z, GLint w);

+#define glVertexAttribI4i _ptrc_glVertexAttribI4i

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribI4iv)(GLuint index, const GLint * v);

+#define glVertexAttribI4iv _ptrc_glVertexAttribI4iv

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribI4sv)(GLuint index, const GLshort * v);

+#define glVertexAttribI4sv _ptrc_glVertexAttribI4sv

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribI4ubv)(GLuint index, const GLubyte * v);

+#define glVertexAttribI4ubv _ptrc_glVertexAttribI4ubv

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribI4ui)(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);

+#define glVertexAttribI4ui _ptrc_glVertexAttribI4ui

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribI4uiv)(GLuint index, const GLuint * v);

+#define glVertexAttribI4uiv _ptrc_glVertexAttribI4uiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribI4usv)(GLuint index, const GLushort * v);

+#define glVertexAttribI4usv _ptrc_glVertexAttribI4usv

+extern void (CODEGEN_FUNCPTR *_ptrc_glVertexAttribIPointer)(GLuint index, GLint size, GLenum type, GLsizei stride, const void * pointer);

+#define glVertexAttribIPointer _ptrc_glVertexAttribIPointer

+

+extern void (CODEGEN_FUNCPTR *_ptrc_glCopyBufferSubData)(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);

+#define glCopyBufferSubData _ptrc_glCopyBufferSubData

+extern void (CODEGEN_FUNCPTR *_ptrc_glDrawArraysInstanced)(GLenum mode, GLint first, GLsizei count, GLsizei instancecount);

+#define glDrawArraysInstanced _ptrc_glDrawArraysInstanced

+extern void (CODEGEN_FUNCPTR *_ptrc_glDrawElementsInstanced)(GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei instancecount);

+#define glDrawElementsInstanced _ptrc_glDrawElementsInstanced

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetActiveUniformBlockName)(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei * length, GLchar * uniformBlockName);

+#define glGetActiveUniformBlockName _ptrc_glGetActiveUniformBlockName

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetActiveUniformBlockiv)(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint * params);

+#define glGetActiveUniformBlockiv _ptrc_glGetActiveUniformBlockiv

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetActiveUniformName)(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei * length, GLchar * uniformName);

+#define glGetActiveUniformName _ptrc_glGetActiveUniformName

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetActiveUniformsiv)(GLuint program, GLsizei uniformCount, const GLuint * uniformIndices, GLenum pname, GLint * params);

+#define glGetActiveUniformsiv _ptrc_glGetActiveUniformsiv

+extern GLuint (CODEGEN_FUNCPTR *_ptrc_glGetUniformBlockIndex)(GLuint program, const GLchar * uniformBlockName);

+#define glGetUniformBlockIndex _ptrc_glGetUniformBlockIndex

+extern void (CODEGEN_FUNCPTR *_ptrc_glGetUniformIndices)(GLuint program, GLsizei uniformCount, const GLchar *const* uniformNames, GLuint * uniformIndices);

+#define glGetUniformIndices _ptrc_glGetUniformIndices

+extern void (CODEGEN_FUNCPTR *_ptrc_glPrimitiveRestartIndex)(GLuint index);

+#define glPrimitiveRestartIndex _ptrc_glPrimitiveRestartIndex

+extern void (CODEGEN_FUNCPTR *_ptrc_glTexBuffer)(GLenum target, GLenum internalformat, GLuint buffer);

+#define glTexBuffer _ptrc_glTexBuffer

+extern void (CODEGEN_FUNCPTR *_ptrc_glUniformBlockBinding)(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);

+#define glUniformBlockBinding _ptrc_glUniformBlockBinding

+

+enum ogl_LoadStatus

+{

+	ogl_LOAD_FAILED = 0,

+	ogl_LOAD_SUCCEEDED = 1,

+};

+

+int ogl_LoadFunctions();

+

+int ogl_GetMinorVersion(void);

+int ogl_GetMajorVersion(void);

+int ogl_IsVersionGEQ(int majorVersion, int minorVersion);

+

+#ifdef __cplusplus

+}

+#endif /*__cplusplus*/

+

+#endif /*POINTER_C_GENERATED_HEADER_OPENGL_H*/

--- a/types.h

+++ b/types.h

@@ -38,6 +38,12 @@

 #define NOINLINE

 #endif

+#ifdef _DEBUG

+#define kDebugFlag 1

+#else

+#define kDebugFlag 0

+#endif

+

 static FORCEINLINE uint16 abs16(uint16 t) { return sign16(t) ? -t : t; }

 static FORCEINLINE uint8 abs8(uint8 t) { return sign8(t) ? -t : t; }

 static FORCEINLINE int IntMin(int a, int b) { return a < b ? a : b; }

@@ -44,6 +50,11 @@

 static FORCEINLINE int IntMax(int a, int b) { return a > b ? a : b; }

 static FORCEINLINE uint UintMin(uint a, uint b) { return a < b ? a : b; }

 static FORCEINLINE uint UintMax(uint a, uint b) { return a > b ? a : b; }

+

+// windows.h defines this too

+#ifdef HIBYTE

+#undef HIBYTE

+#endif

 #define BYTE(x) (*(uint8*)&(x))

 #define HIBYTE(x) (((uint8*)&(x))[1])

--- /dev/null

+++ b/util.c

@@ -1,0 +1,172 @@

+#include "util.h"

+#include <stdio.h>

+#include <string.h>

+#include <stdarg.h>

+

+char *NextDelim(char **s, int sep) {

+  char *r = *s;

+  if (r) {

+    while (r[0] == ' ' || r[0] == '\t')

+      r++;

+    char *t = strchr(r, sep);

+    *s = t ? (*t++ = 0, t) : NULL;

+  }

+  return r;

+}

+

+static inline int ToLower(int a) {

+  return a + (a >= 'A' && a <= 'Z') * 32;

+}

+

+bool StringEqualsNoCase(const char *a, const char *b) {

+  for (;;) {

+    int aa = ToLower(*a++), bb = ToLower(*b++);

+    if (aa != bb)

+      return false;

+    if (aa == 0)

+      return true;

+  }

+}

+

+bool StringStartsWithNoCase(const char *a, const char *b) {

+  for (;;) {

+    int aa = ToLower(*a++), bb = ToLower(*b++);

+    if (bb == 0)

+      return true;

+    if (aa != bb)

+      return false;

+  }

+}

+

+uint8 *ReadWholeFile(const char *name, size_t *length) {

+  FILE *f = fopen(name, "rb");

+  if (f == NULL)

+    return NULL;

+  fseek(f, 0, SEEK_END);

+  size_t size = ftell(f);

+  rewind(f);

+  uint8 *buffer = (uint8 *)malloc(size + 1);

+  if (!buffer) Die("malloc failed");

+  // Always zero terminate so this function can be used also for strings.

+  buffer[size] = 0;

+  if (fread(buffer, 1, size, f) != size)

+    Die("fread failed");

+  fclose(f);

+  if (length) *length = size;

+  return buffer;

+}

+

+char *NextLineStripComments(char **s) {

+  char *p = *s;

+  if (p == NULL)

+    return NULL;

+  // find end of line

+  char *eol = strchr(p, '\n');

+  *s = eol ? eol + 1 : NULL;

+  eol = eol ? eol : p + strlen(p);

+  // strip comments

+  char *comment = memchr(p, '#', eol - p);

+  eol = comment ? comment : eol;

+  // strip trailing whitespace

+  while (eol > p && (eol[-1] == '\r' || eol[-1] == ' ' || eol[-1] == '\t'))

+    eol--;

+  *eol = 0;

+  // strip leading whitespace

+  while (p[0] == ' ' || p[0] == '\t')

+    p++;

+  return p;

+}

+

+// Return the next possibly quoted string, space separated, or the empty string

+char *NextPossiblyQuotedString(char **s) {

+  char *r = *s, *t;

+  while (*r == ' ' || *r == '\t')

+    r++;

+  if (*r == '"') {

+    for (t = ++r; *t && *t != '"'; t++);

+  } else {

+    for (t = r; *t && *t != ' ' && *t != '\t'; t++);

+  }

+  if (*t) *t++ = 0;

+  while (*t == ' ' || *t == '\t')

+    t++;

+  *s = t;

+  return r;

+}

+

+char *ReplaceFilenameWithNewPath(const char *old_path, const char *new_path) {

+  size_t olen = strlen(old_path);

+  size_t nlen = strlen(new_path) + 1;

+  while (olen && old_path[olen - 1] != '/' && old_path[olen - 1] != '\\')

+    olen--;

+  char *result = malloc(olen + nlen);

+  memcpy(result, old_path, olen);

+  memcpy(result + olen, new_path, nlen);

+  return result;

+}

+

+char *SplitKeyValue(char *p) {

+  char *equals = strchr(p, '=');

+  if (equals == NULL)

+    return NULL;

+  char *kr = equals;

+  while (kr > p && (kr[-1] == ' ' || kr[-1] == '\t'))

+    kr--;

+  *kr = 0;

+  char *v = equals + 1;

+  while (v[0] == ' ' || v[0] == '\t')

+    v++;

+  return v;

+}

+

+const char *SkipPrefix(const char *big, const char *little) {

+  for (; *little; big++, little++) {

+    if (*little != *big)

+      return NULL;

+  }

+  return big;

+}

+

+void StrSet(char **rv, const char *s) {

+  char *news = strdup(s);

+  char *old = *rv;

+  *rv = news;

+  free(old);

+}

+

+char *StrFmt(const char *fmt, ...) {

+  char buf[4096];

+  va_list va;

+  va_start(va, fmt);

+  int n = vsnprintf(buf, sizeof(buf), fmt, va);

+  if (n < 0 || n >= sizeof(buf)) Die("vsnprintf failed");

+  va_end(va);

+  return strdup(buf);

+}

+

+void ByteArray_Resize(ByteArray *arr, size_t new_size) {

+  arr->size = new_size;

+  if (new_size > arr->capacity) {

+    size_t minsize = arr->capacity + (arr->capacity >> 1) + 8;

+    arr->capacity = new_size < minsize ? minsize : new_size;

+    void *data = realloc(arr->data, arr->capacity);

+    if (!data) Die("memory allocation failed");

+    arr->data = data;

+  }

+}

+

+void ByteArray_Destroy(ByteArray *arr) {

+  void *data = arr->data;

+  arr->data = NULL;

+  free(data);

+}

+

+void ByteArray_AppendData(ByteArray *arr, const uint8 *data, size_t data_size) {

+  ByteArray_Resize(arr, arr->size + data_size);

+  memcpy(arr->data + arr->size - data_size, data, data_size);

+}

+

+void ByteArray_AppendByte(ByteArray *arr, uint8 v) {

+  ByteArray_Resize(arr, arr->size + 1);

+  arr->data[arr->size - 1] = v;

+}

--- /dev/null

+++ b/util.h

@@ -1,0 +1,39 @@

+#ifndef ZELDA3_UTIL_H_

+#define ZELDA3_UTIL_H_

+

+#include "types.h"

+

+typedef struct SDL_Window SDL_Window;

+

+struct RendererFuncs {

+  bool (*Initialize)(SDL_Window *window);

+  void (*Destroy)();

+  void (*BeginDraw)(int width, int height, uint8 **pixels, int *pitch);

+  void (*EndDraw)();

+};

+

+

+typedef struct ByteArray {

+  uint8 *data;

+  size_t size, capacity;

+} ByteArray;

+

+void ByteArray_Resize(ByteArray *arr, size_t new_size);

+void ByteArray_Destroy(ByteArray *arr);

+void ByteArray_AppendData(ByteArray *arr, const uint8 *data, size_t data_size);

+void ByteArray_AppendByte(ByteArray *arr, uint8 v);

+

+uint8 *ReadWholeFile(const char *name, size_t *length);

+char *NextDelim(char **s, int sep);

+char *NextLineStripComments(char **s);

+char *NextPossiblyQuotedString(char **s);

+char *SplitKeyValue(char *p);

+bool StringEqualsNoCase(const char *a, const char *b);

+bool StringStartsWithNoCase(const char *a, const char *b);

+bool ParseBool(const char *value, bool *result);

+const char *SkipPrefix(const char *big, const char *little);

+void StrSet(char **rv, const char *s);

+char *StrFmt(const char *fmt, ...);

+char *ReplaceFilenameWithNewPath(const char *old_path, const char *new_path);

+

+#endif  // ZELDA3_UTIL_H_

\ No newline at end of file

--- a/zelda3.ini

+++ b/zelda3.ini

@@ -22,13 +22,16 @@

 # Fullscreen mode (0=windowed, 1=desktop fullscreen, 2=fullscreen w/mode change)

 Fullscreen = 0

-# Set to 1 to use SDL software rendering. Might give better performance on Raspberry pi.

-SoftwareRendering = 0

-

 # Window scale (1=100%, 2=200%, 3=300%, etc.)

 WindowScale = 3

+

+# Use an optimized (but potentially more buggy) SNES PPU implementation

 NewRenderer = 1

+

+# Display the world map with higher resolution

 EnhancedMode7 = 1

+

+# Don't keep the aspect ratio

 IgnoreAspectRatio = 0

 # Enable this option to remove the sprite limits per scan line

@@ -39,6 +42,17 @@

 # Download the files with "git clone https://github.com/snesrev/sprites-gfx.git"

 # LinkGraphics = sprites-gfx/snes/zelda3/link/sheets/megaman-x.2.zspr

+# Use either SDL, SDL-Software, or OpenGL as the output method

+# SDL-Software rendering might give better performance on Raspberry pi.

+OutputMethod = SDL

+

+# Set to true to use linear filtering. Gives less crisp pixels. Works with SDL and OpenGL.

+LinearFiltering = 0

+

+# Set a glsl shader. Only supported with the OpenGL output method

+# This can be the path to a .glsl or .glslp file

+# Get them with: git clone https://github.com/snesrev/glsl-shaders

+Shader =

 [Sound]

 EnableAudio = 1

--- a/zelda3.vcxproj

+++ b/zelda3.vcxproj

@@ -217,6 +217,7 @@

     <ClCompile Include="config.c" />

     <ClCompile Include="dungeon.c" />

     <ClCompile Include="ending.c" />

+    <ClCompile Include="glsl_shader.c" />

     <ClCompile Include="hud.c" />

     <ClCompile Include="load_gfx.c" />

     <ClCompile Include="main.c">

@@ -234,6 +235,7 @@

     <ClCompile Include="player_oam.c" />

     <ClCompile Include="poly.c" />

     <ClCompile Include="select_file.c" />

+    <ClCompile Include="opengl.c" />

     <ClCompile Include="snes\apu.c">

       <Optimization Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Disabled</Optimization>

       <InlineFunctionExpansion Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Disabled</InlineFunctionExpansion>

@@ -280,7 +282,9 @@

       <Optimization Condition="'$(Configuration)|$(Platform)'=='ReleaseDeploy|x64'">MaxSpeed</Optimization>

     </ClCompile>

     <ClCompile Include="tagalong.c" />

+    <ClCompile Include="third_party\gl_core\gl_core_3_1.c" />

     <ClCompile Include="tile_detect.c" />

+    <ClCompile Include="util.c" />

     <ClCompile Include="zelda_cpu_infra.c" />

     <ClCompile Include="zelda_rtl.c" />

   </ItemGroup>

@@ -292,6 +296,7 @@

     <ClInclude Include="dungeon.h" />

     <ClInclude Include="ending.h" />

     <ClInclude Include="features.h" />

+    <ClInclude Include="glsl_shader.h" />

     <ClInclude Include="hud.h" />

     <ClInclude Include="load_gfx.h" />

     <ClInclude Include="messaging.h" />

@@ -322,8 +327,10 @@

     <ClInclude Include="sprite.h" />

     <ClInclude Include="sprite_main.h" />

     <ClInclude Include="tagalong.h" />

+    <ClInclude Include="third_party\gl_core\gl_core_3_1.h" />

     <ClInclude Include="tile_detect.h" />

     <ClInclude Include="types.h" />

+    <ClInclude Include="util.h" />

     <ClInclude Include="variables.h" />

     <ClInclude Include="zelda_cpu_infra.h" />

     <ClInclude Include="zelda_rtl.h" />

--- a/zelda3.vcxproj.filters

+++ b/zelda3.vcxproj.filters

@@ -23,6 +23,9 @@

     <Filter Include="Deploy\tables">

       <UniqueIdentifier>{af7accb3-a27b-402b-ab20-86bbb57bd9a3}</UniqueIdentifier>

     </Filter>

+    <Filter Include="third_party">

+      <UniqueIdentifier>{29eb2519-e785-4828-a9e2-1d6eca0d4087}</UniqueIdentifier>

+    </Filter>

   </ItemGroup>

   <ItemGroup>

     <ClCompile Include="snes\apu.c">

@@ -133,6 +136,18 @@

     <ClCompile Include="snes\tracing.c">

       <Filter>Snes</Filter>

     </ClCompile>

+    <ClCompile Include="opengl.c">

+      <Filter>Zelda</Filter>

+    </ClCompile>

+    <ClCompile Include="glsl_shader.c">

+      <Filter>Zelda</Filter>

+    </ClCompile>

+    <ClCompile Include="util.c">

+      <Filter>Zelda</Filter>

+    </ClCompile>

+    <ClCompile Include="third_party\gl_core\gl_core_3_1.c">

+      <Filter>third_party</Filter>

+    </ClCompile>

   </ItemGroup>

   <ItemGroup>

     <ClInclude Include="snes\apu.h">

@@ -260,6 +275,15 @@

     </ClInclude>

     <ClInclude Include="snes\tracing.h">

       <Filter>Snes</Filter>

+    </ClInclude>

+    <ClInclude Include="glsl_shader.h">

+      <Filter>Zelda</Filter>

+    </ClInclude>

+    <ClInclude Include="util.h">

+      <Filter>Zelda</Filter>

+    </ClInclude>

+    <ClInclude Include="third_party\gl_core\gl_core_3_1.h">

+      <Filter>third_party</Filter>

     </ClInclude>

   </ItemGroup>

   <ItemGroup>

--- a/zelda_rtl.c

+++ b/zelda_rtl.c

@@ -8,6 +8,7 @@

 #include "snes/snes_regs.h"

 #include "snes/dma.h"

 #include "spc_player.h"

+#include "util.h"

 ZeldaEnv g_zenv;

 uint8 g_ram[131072];

@@ -387,38 +388,6 @@

   flag_update_cgram_in_nmi++;

 }

-

-typedef struct ByteArray {

-  uint8 *data;

-  size_t size, capacity;

-} ByteArray;

-

-void ByteArray_Resize(ByteArray *arr, size_t new_size) {

-  arr->size = new_size;

-  if (new_size > arr->capacity) {

-    size_t minsize = arr->capacity + (arr->capacity >> 1) + 8;

-    arr->capacity = new_size < minsize ? minsize : new_size;

-    void *data = realloc(arr->data, arr->capacity);

-    if (!data) Die("memory allocation failed");

-    arr->data = data;

-  }

-}

-

-void ByteArray_Destroy(ByteArray *arr) {

-  free(arr->data);

-  arr->data = NULL;

-}

-

-void ByteArray_AppendData(ByteArray *arr, const uint8 *data, size_t data_size) {

-  ByteArray_Resize(arr, arr->size + data_size);

-  memcpy(arr->data + arr->size - data_size, data, data_size);

-}

-

-void ByteArray_AppendByte(ByteArray *arr, uint8 v) {

-  ByteArray_Resize(arr, arr->size + 1);

-  arr->data[arr->size - 1] = v;

-}

-

 void ByteArray_AppendVl(ByteArray *arr, uint32 v) {

   for (; v >= 255; v -= 255)

     ByteArray_AppendByte(arr, 255);

@@ -888,8 +857,6 @@

     fclose(f);

   }

 }

-

-

 typedef struct StateRecoderMultiPatch {

   uint32 count;