/[gzz]/gzz/gfx/libcallgl/GL_kludge.cxx
ViewVC logotype

Diff of /gzz/gfx/libcallgl/GL_kludge.cxx

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.2 by mudyc, Mon Sep 23 18:21:46 2002 UTC revision 1.3 by mudyc, Mon Sep 23 18:49:53 2002 UTC
# Line 64  void stub_glAddSwapHintRectWIN(GLint x, Line 64  void stub_glAddSwapHintRectWIN(GLint x,
64     return _glAddSwapHintRectWIN(x , y , width , height);     return _glAddSwapHintRectWIN(x , y , width , height);
65  }  }
66    
 void stub_glAlphaFunc(GLenum func, GLclampf ref);  
 void (* _glAlphaFunc)(GLenum func, GLclampf ref) = &stub_glAlphaFunc;  
   
 void stub_glAlphaFunc(GLenum func, GLclampf ref) {  
    if (Os::getExtendedProcAddress("glAlphaFunc") == NULL) {  
       return GL_kludge_error_void("glAlphaFunc");  
    }  
    _glAlphaFunc = (void (*)(GLenum , GLclampf))Os::getExtendedProcAddress("glAlphaFunc");  
    return _glAlphaFunc(func , ref);  
 }  
   
67  GLboolean stub_glAreProgramsResidentNV(GLsizei n, const GLuint *programs, GLboolean *residences);  GLboolean stub_glAreProgramsResidentNV(GLsizei n, const GLuint *programs, GLboolean *residences);
68  GLboolean (* _glAreProgramsResidentNV)(GLsizei n, const GLuint *programs, GLboolean *residences) = &stub_glAreProgramsResidentNV;  GLboolean (* _glAreProgramsResidentNV)(GLsizei n, const GLuint *programs, GLboolean *residences) = &stub_glAreProgramsResidentNV;
69    
# Line 86  GLboolean stub_glAreProgramsResidentNV(G Line 75  GLboolean stub_glAreProgramsResidentNV(G
75     return _glAreProgramsResidentNV(n , programs , residences);     return _glAreProgramsResidentNV(n , programs , residences);
76  }  }
77    
 GLboolean stub_glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences);  
 GLboolean (* _glAreTexturesResident)(GLsizei n, const GLuint *textures, GLboolean *residences) = &stub_glAreTexturesResident;  
   
 GLboolean stub_glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences) {  
    if (Os::getExtendedProcAddress("glAreTexturesResident") == NULL) {  
       return GL_kludge_error_GLboolean("glAreTexturesResident");  
    }  
    _glAreTexturesResident = (GLboolean (*)(GLsizei , const GLuint * , GLboolean *))Os::getExtendedProcAddress("glAreTexturesResident");  
    return _glAreTexturesResident(n , textures , residences);  
 }  
   
78  GLboolean stub_glAreTexturesResidentEXT(GLsizei n, const GLuint *textures, GLboolean *residences);  GLboolean stub_glAreTexturesResidentEXT(GLsizei n, const GLuint *textures, GLboolean *residences);
79  GLboolean (* _glAreTexturesResidentEXT)(GLsizei n, const GLuint *textures, GLboolean *residences) = &stub_glAreTexturesResidentEXT;  GLboolean (* _glAreTexturesResidentEXT)(GLsizei n, const GLuint *textures, GLboolean *residences) = &stub_glAreTexturesResidentEXT;
80    
# Line 108  GLboolean stub_glAreTexturesResidentEXT( Line 86  GLboolean stub_glAreTexturesResidentEXT(
86     return _glAreTexturesResidentEXT(n , textures , residences);     return _glAreTexturesResidentEXT(n , textures , residences);
87  }  }
88    
 void stub_glArrayElement(GLint i);  
 void (* _glArrayElement)(GLint i) = &stub_glArrayElement;  
   
 void stub_glArrayElement(GLint i) {  
    if (Os::getExtendedProcAddress("glArrayElement") == NULL) {  
       return GL_kludge_error_void("glArrayElement");  
    }  
    _glArrayElement = (void (*)(GLint))Os::getExtendedProcAddress("glArrayElement");  
    return _glArrayElement(i);  
 }  
   
89  void stub_glArrayElementEXT(GLint i);  void stub_glArrayElementEXT(GLint i);
90  void (* _glArrayElementEXT)(GLint i) = &stub_glArrayElementEXT;  void (* _glArrayElementEXT)(GLint i) = &stub_glArrayElementEXT;
91    
# Line 130  void stub_glArrayElementEXT(GLint i) { Line 97  void stub_glArrayElementEXT(GLint i) {
97     return _glArrayElementEXT(i);     return _glArrayElementEXT(i);
98  }  }
99    
 void stub_glBegin(GLenum mode);  
 void (* _glBegin)(GLenum mode) = &stub_glBegin;  
   
 void stub_glBegin(GLenum mode) {  
    if (Os::getExtendedProcAddress("glBegin") == NULL) {  
       return GL_kludge_error_void("glBegin");  
    }  
    _glBegin = (void (*)(GLenum))Os::getExtendedProcAddress("glBegin");  
    return _glBegin(mode);  
 }  
   
100  void stub_glBeginOcclusionQueryNV(GLuint id);  void stub_glBeginOcclusionQueryNV(GLuint id);
101  void (* _glBeginOcclusionQueryNV)(GLuint id) = &stub_glBeginOcclusionQueryNV;  void (* _glBeginOcclusionQueryNV)(GLuint id) = &stub_glBeginOcclusionQueryNV;
102    
# Line 163  void stub_glBindProgramNV(GLenum target, Line 119  void stub_glBindProgramNV(GLenum target,
119     return _glBindProgramNV(target , id);     return _glBindProgramNV(target , id);
120  }  }
121    
 void stub_glBindTexture(GLenum target, GLuint texture);  
 void (* _glBindTexture)(GLenum target, GLuint texture) = &stub_glBindTexture;  
   
 void stub_glBindTexture(GLenum target, GLuint texture) {  
    if (Os::getExtendedProcAddress("glBindTexture") == NULL) {  
       return GL_kludge_error_void("glBindTexture");  
    }  
    _glBindTexture = (void (*)(GLenum , GLuint))Os::getExtendedProcAddress("glBindTexture");  
    return _glBindTexture(target , texture);  
 }  
   
122  void stub_glBindTextureEXT(GLenum target, GLuint texture);  void stub_glBindTextureEXT(GLenum target, GLuint texture);
123  void (* _glBindTextureEXT)(GLenum target, GLuint texture) = &stub_glBindTextureEXT;  void (* _glBindTextureEXT)(GLenum target, GLuint texture) = &stub_glBindTextureEXT;
124    
# Line 185  void stub_glBindTextureEXT(GLenum target Line 130  void stub_glBindTextureEXT(GLenum target
130     return _glBindTextureEXT(target , texture);     return _glBindTextureEXT(target , texture);
131  }  }
132    
 void stub_glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);  
 void (* _glBitmap)(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap) = &stub_glBitmap;  
   
 void stub_glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap) {  
    if (Os::getExtendedProcAddress("glBitmap") == NULL) {  
       return GL_kludge_error_void("glBitmap");  
    }  
    _glBitmap = (void (*)(GLsizei , GLsizei , GLfloat , GLfloat , GLfloat , GLfloat , const GLubyte *))Os::getExtendedProcAddress("glBitmap");  
    return _glBitmap(width , height , xorig , yorig , xmove , ymove , bitmap);  
 }  
   
133  void stub_glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);  void stub_glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
134  void (* _glBlendColor)(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) = &stub_glBlendColor;  void (* _glBlendColor)(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) = &stub_glBlendColor;
135    
# Line 240  void stub_glBlendEquationEXT(GLenum mode Line 174  void stub_glBlendEquationEXT(GLenum mode
174     return _glBlendEquationEXT(mode);     return _glBlendEquationEXT(mode);
175  }  }
176    
 void stub_glBlendFunc(GLenum sfactor, GLenum dfactor);  
 void (* _glBlendFunc)(GLenum sfactor, GLenum dfactor) = &stub_glBlendFunc;  
   
 void stub_glBlendFunc(GLenum sfactor, GLenum dfactor) {  
    if (Os::getExtendedProcAddress("glBlendFunc") == NULL) {  
       return GL_kludge_error_void("glBlendFunc");  
    }  
    _glBlendFunc = (void (*)(GLenum , GLenum))Os::getExtendedProcAddress("glBlendFunc");  
    return _glBlendFunc(sfactor , dfactor);  
 }  
   
 void stub_glCallList(GLuint list);  
 void (* _glCallList)(GLuint list) = &stub_glCallList;  
   
 void stub_glCallList(GLuint list) {  
    if (Os::getExtendedProcAddress("glCallList") == NULL) {  
       return GL_kludge_error_void("glCallList");  
    }  
    _glCallList = (void (*)(GLuint))Os::getExtendedProcAddress("glCallList");  
    return _glCallList(list);  
 }  
   
 void stub_glCallLists(GLsizei n, GLenum type, const GLvoid *lists);  
 void (* _glCallLists)(GLsizei n, GLenum type, const GLvoid *lists) = &stub_glCallLists;  
   
 void stub_glCallLists(GLsizei n, GLenum type, const GLvoid *lists) {  
    if (Os::getExtendedProcAddress("glCallLists") == NULL) {  
       return GL_kludge_error_void("glCallLists");  
    }  
    _glCallLists = (void (*)(GLsizei , GLenum , const GLvoid *))Os::getExtendedProcAddress("glCallLists");  
    return _glCallLists(n , type , lists);  
 }  
   
 void stub_glClear(GLbitfield mask);  
 void (* _glClear)(GLbitfield mask) = &stub_glClear;  
   
 void stub_glClear(GLbitfield mask) {  
    if (Os::getExtendedProcAddress("glClear") == NULL) {  
       return GL_kludge_error_void("glClear");  
    }  
    _glClear = (void (*)(GLbitfield))Os::getExtendedProcAddress("glClear");  
    return _glClear(mask);  
 }  
   
 void stub_glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);  
 void (* _glClearAccum)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) = &stub_glClearAccum;  
   
 void stub_glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {  
    if (Os::getExtendedProcAddress("glClearAccum") == NULL) {  
       return GL_kludge_error_void("glClearAccum");  
    }  
    _glClearAccum = (void (*)(GLfloat , GLfloat , GLfloat , GLfloat))Os::getExtendedProcAddress("glClearAccum");  
    return _glClearAccum(red , green , blue , alpha);  
 }  
   
 void stub_glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);  
 void (* _glClearColor)(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) = &stub_glClearColor;  
   
 void stub_glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) {  
    if (Os::getExtendedProcAddress("glClearColor") == NULL) {  
       return GL_kludge_error_void("glClearColor");  
    }  
    _glClearColor = (void (*)(GLclampf , GLclampf , GLclampf , GLclampf))Os::getExtendedProcAddress("glClearColor");  
    return _glClearColor(red , green , blue , alpha);  
 }  
   
 void stub_glClearDepth(GLclampd depth);  
 void (* _glClearDepth)(GLclampd depth) = &stub_glClearDepth;  
   
 void stub_glClearDepth(GLclampd depth) {  
    if (Os::getExtendedProcAddress("glClearDepth") == NULL) {  
       return GL_kludge_error_void("glClearDepth");  
    }  
    _glClearDepth = (void (*)(GLclampd))Os::getExtendedProcAddress("glClearDepth");  
    return _glClearDepth(depth);  
 }  
   
 void stub_glClearIndex(GLfloat c);  
 void (* _glClearIndex)(GLfloat c) = &stub_glClearIndex;  
   
 void stub_glClearIndex(GLfloat c) {  
    if (Os::getExtendedProcAddress("glClearIndex") == NULL) {  
       return GL_kludge_error_void("glClearIndex");  
    }  
    _glClearIndex = (void (*)(GLfloat))Os::getExtendedProcAddress("glClearIndex");  
    return _glClearIndex(c);  
 }  
   
 void stub_glClearStencil(GLint s);  
 void (* _glClearStencil)(GLint s) = &stub_glClearStencil;  
   
 void stub_glClearStencil(GLint s) {  
    if (Os::getExtendedProcAddress("glClearStencil") == NULL) {  
       return GL_kludge_error_void("glClearStencil");  
    }  
    _glClearStencil = (void (*)(GLint))Os::getExtendedProcAddress("glClearStencil");  
    return _glClearStencil(s);  
 }  
   
177  void stub_glClientActiveTexture(GLenum texture);  void stub_glClientActiveTexture(GLenum texture);
178  void (* _glClientActiveTexture)(GLenum texture) = &stub_glClientActiveTexture;  void (* _glClientActiveTexture)(GLenum texture) = &stub_glClientActiveTexture;
179    
# Line 361  void stub_glClientActiveTextureARB(GLenu Line 196  void stub_glClientActiveTextureARB(GLenu
196     return _glClientActiveTextureARB(texture);     return _glClientActiveTextureARB(texture);
197  }  }
198    
 void stub_glClipPlane(GLenum plane, const GLdouble *equation);  
 void (* _glClipPlane)(GLenum plane, const GLdouble *equation) = &stub_glClipPlane;  
   
 void stub_glClipPlane(GLenum plane, const GLdouble *equation) {  
    if (Os::getExtendedProcAddress("glClipPlane") == NULL) {  
       return GL_kludge_error_void("glClipPlane");  
    }  
    _glClipPlane = (void (*)(GLenum , const GLdouble *))Os::getExtendedProcAddress("glClipPlane");  
    return _glClipPlane(plane , equation);  
 }  
   
 void stub_glColor3b(GLbyte red, GLbyte green, GLbyte blue);  
 void (* _glColor3b)(GLbyte red, GLbyte green, GLbyte blue) = &stub_glColor3b;  
   
 void stub_glColor3b(GLbyte red, GLbyte green, GLbyte blue) {  
    if (Os::getExtendedProcAddress("glColor3b") == NULL) {  
       return GL_kludge_error_void("glColor3b");  
    }  
    _glColor3b = (void (*)(GLbyte , GLbyte , GLbyte))Os::getExtendedProcAddress("glColor3b");  
    return _glColor3b(red , green , blue);  
 }  
   
 void stub_glColor3bv(const GLbyte *v);  
 void (* _glColor3bv)(const GLbyte *v) = &stub_glColor3bv;  
   
 void stub_glColor3bv(const GLbyte *v) {  
    if (Os::getExtendedProcAddress("glColor3bv") == NULL) {  
       return GL_kludge_error_void("glColor3bv");  
    }  
    _glColor3bv = (void (*)(const GLbyte *))Os::getExtendedProcAddress("glColor3bv");  
    return _glColor3bv(v);  
 }  
   
 void stub_glColor3d(GLdouble red, GLdouble green, GLdouble blue);  
 void (* _glColor3d)(GLdouble red, GLdouble green, GLdouble blue) = &stub_glColor3d;  
   
 void stub_glColor3d(GLdouble red, GLdouble green, GLdouble blue) {  
    if (Os::getExtendedProcAddress("glColor3d") == NULL) {  
       return GL_kludge_error_void("glColor3d");  
    }  
    _glColor3d = (void (*)(GLdouble , GLdouble , GLdouble))Os::getExtendedProcAddress("glColor3d");  
    return _glColor3d(red , green , blue);  
 }  
   
 void stub_glColor3dv(const GLdouble *v);  
 void (* _glColor3dv)(const GLdouble *v) = &stub_glColor3dv;  
   
 void stub_glColor3dv(const GLdouble *v) {  
    if (Os::getExtendedProcAddress("glColor3dv") == NULL) {  
       return GL_kludge_error_void("glColor3dv");  
    }  
    _glColor3dv = (void (*)(const GLdouble *))Os::getExtendedProcAddress("glColor3dv");  
    return _glColor3dv(v);  
 }  
   
 void stub_glColor3f(GLfloat red, GLfloat green, GLfloat blue);  
 void (* _glColor3f)(GLfloat red, GLfloat green, GLfloat blue) = &stub_glColor3f;  
   
 void stub_glColor3f(GLfloat red, GLfloat green, GLfloat blue) {  
    if (Os::getExtendedProcAddress("glColor3f") == NULL) {  
       return GL_kludge_error_void("glColor3f");  
    }  
    _glColor3f = (void (*)(GLfloat , GLfloat , GLfloat))Os::getExtendedProcAddress("glColor3f");  
    return _glColor3f(red , green , blue);  
 }  
   
 void stub_glColor3fv(const GLfloat *v);  
 void (* _glColor3fv)(const GLfloat *v) = &stub_glColor3fv;  
   
 void stub_glColor3fv(const GLfloat *v) {  
    if (Os::getExtendedProcAddress("glColor3fv") == NULL) {  
       return GL_kludge_error_void("glColor3fv");  
    }  
    _glColor3fv = (void (*)(const GLfloat *))Os::getExtendedProcAddress("glColor3fv");  
    return _glColor3fv(v);  
 }  
   
 void stub_glColor3i(GLint red, GLint green, GLint blue);  
 void (* _glColor3i)(GLint red, GLint green, GLint blue) = &stub_glColor3i;  
   
 void stub_glColor3i(GLint red, GLint green, GLint blue) {  
    if (Os::getExtendedProcAddress("glColor3i") == NULL) {  
       return GL_kludge_error_void("glColor3i");  
    }  
    _glColor3i = (void (*)(GLint , GLint , GLint))Os::getExtendedProcAddress("glColor3i");  
    return _glColor3i(red , green , blue);  
 }  
   
 void stub_glColor3iv(const GLint *v);  
 void (* _glColor3iv)(const GLint *v) = &stub_glColor3iv;  
   
 void stub_glColor3iv(const GLint *v) {  
    if (Os::getExtendedProcAddress("glColor3iv") == NULL) {  
       return GL_kludge_error_void("glColor3iv");  
    }  
    _glColor3iv = (void (*)(const GLint *))Os::getExtendedProcAddress("glColor3iv");  
    return _glColor3iv(v);  
 }  
   
 void stub_glColor3s(GLshort red, GLshort green, GLshort blue);  
 void (* _glColor3s)(GLshort red, GLshort green, GLshort blue) = &stub_glColor3s;  
   
 void stub_glColor3s(GLshort red, GLshort green, GLshort blue) {  
    if (Os::getExtendedProcAddress("glColor3s") == NULL) {  
       return GL_kludge_error_void("glColor3s");  
    }  
    _glColor3s = (void (*)(GLshort , GLshort , GLshort))Os::getExtendedProcAddress("glColor3s");  
    return _glColor3s(red , green , blue);  
 }  
   
 void stub_glColor3sv(const GLshort *v);  
 void (* _glColor3sv)(const GLshort *v) = &stub_glColor3sv;  
   
 void stub_glColor3sv(const GLshort *v) {  
    if (Os::getExtendedProcAddress("glColor3sv") == NULL) {  
       return GL_kludge_error_void("glColor3sv");  
    }  
    _glColor3sv = (void (*)(const GLshort *))Os::getExtendedProcAddress("glColor3sv");  
    return _glColor3sv(v);  
 }  
   
 void stub_glColor3ub(GLubyte red, GLubyte green, GLubyte blue);  
 void (* _glColor3ub)(GLubyte red, GLubyte green, GLubyte blue) = &stub_glColor3ub;  
   
 void stub_glColor3ub(GLubyte red, GLubyte green, GLubyte blue) {  
    if (Os::getExtendedProcAddress("glColor3ub") == NULL) {  
       return GL_kludge_error_void("glColor3ub");  
    }  
    _glColor3ub = (void (*)(GLubyte , GLubyte , GLubyte))Os::getExtendedProcAddress("glColor3ub");  
    return _glColor3ub(red , green , blue);  
 }  
   
 void stub_glColor3ubv(const GLubyte *v);  
 void (* _glColor3ubv)(const GLubyte *v) = &stub_glColor3ubv;  
   
 void stub_glColor3ubv(const GLubyte *v) {  
    if (Os::getExtendedProcAddress("glColor3ubv") == NULL) {  
       return GL_kludge_error_void("glColor3ubv");  
    }  
    _glColor3ubv = (void (*)(const GLubyte *))Os::getExtendedProcAddress("glColor3ubv");  
    return _glColor3ubv(v);  
 }  
   
 void stub_glColor3ui(GLuint red, GLuint green, GLuint blue);  
 void (* _glColor3ui)(GLuint red, GLuint green, GLuint blue) = &stub_glColor3ui;  
   
 void stub_glColor3ui(GLuint red, GLuint green, GLuint blue) {  
    if (Os::getExtendedProcAddress("glColor3ui") == NULL) {  
       return GL_kludge_error_void("glColor3ui");  
    }  
    _glColor3ui = (void (*)(GLuint , GLuint , GLuint))Os::getExtendedProcAddress("glColor3ui");  
    return _glColor3ui(red , green , blue);  
 }  
   
 void stub_glColor3uiv(const GLuint *v);  
 void (* _glColor3uiv)(const GLuint *v) = &stub_glColor3uiv;  
   
 void stub_glColor3uiv(const GLuint *v) {  
    if (Os::getExtendedProcAddress("glColor3uiv") == NULL) {  
       return GL_kludge_error_void("glColor3uiv");  
    }  
    _glColor3uiv = (void (*)(const GLuint *))Os::getExtendedProcAddress("glColor3uiv");  
    return _glColor3uiv(v);  
 }  
   
 void stub_glColor3us(GLushort red, GLushort green, GLushort blue);  
 void (* _glColor3us)(GLushort red, GLushort green, GLushort blue) = &stub_glColor3us;  
   
 void stub_glColor3us(GLushort red, GLushort green, GLushort blue) {  
    if (Os::getExtendedProcAddress("glColor3us") == NULL) {  
       return GL_kludge_error_void("glColor3us");  
    }  
    _glColor3us = (void (*)(GLushort , GLushort , GLushort))Os::getExtendedProcAddress("glColor3us");  
    return _glColor3us(red , green , blue);  
 }  
   
 void stub_glColor3usv(const GLushort *v);  
 void (* _glColor3usv)(const GLushort *v) = &stub_glColor3usv;  
   
 void stub_glColor3usv(const GLushort *v) {  
    if (Os::getExtendedProcAddress("glColor3usv") == NULL) {  
       return GL_kludge_error_void("glColor3usv");  
    }  
    _glColor3usv = (void (*)(const GLushort *))Os::getExtendedProcAddress("glColor3usv");  
    return _glColor3usv(v);  
 }  
   
 void stub_glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);  
 void (* _glColor4b)(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha) = &stub_glColor4b;  
   
 void stub_glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha) {  
    if (Os::getExtendedProcAddress("glColor4b") == NULL) {  
       return GL_kludge_error_void("glColor4b");  
    }  
    _glColor4b = (void (*)(GLbyte , GLbyte , GLbyte , GLbyte))Os::getExtendedProcAddress("glColor4b");  
    return _glColor4b(red , green , blue , alpha);  
 }  
   
 void stub_glColor4bv(const GLbyte *v);  
 void (* _glColor4bv)(const GLbyte *v) = &stub_glColor4bv;  
   
 void stub_glColor4bv(const GLbyte *v) {  
    if (Os::getExtendedProcAddress("glColor4bv") == NULL) {  
       return GL_kludge_error_void("glColor4bv");  
    }  
    _glColor4bv = (void (*)(const GLbyte *))Os::getExtendedProcAddress("glColor4bv");  
    return _glColor4bv(v);  
 }  
   
 void stub_glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);  
 void (* _glColor4d)(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha) = &stub_glColor4d;  
   
 void stub_glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha) {  
    if (Os::getExtendedProcAddress("glColor4d") == NULL) {  
       return GL_kludge_error_void("glColor4d");  
    }  
    _glColor4d = (void (*)(GLdouble , GLdouble , GLdouble , GLdouble))Os::getExtendedProcAddress("glColor4d");  
    return _glColor4d(red , green , blue , alpha);  
 }  
   
 void stub_glColor4dv(const GLdouble *v);  
 void (* _glColor4dv)(const GLdouble *v) = &stub_glColor4dv;  
   
 void stub_glColor4dv(const GLdouble *v) {  
    if (Os::getExtendedProcAddress("glColor4dv") == NULL) {  
       return GL_kludge_error_void("glColor4dv");  
    }  
    _glColor4dv = (void (*)(const GLdouble *))Os::getExtendedProcAddress("glColor4dv");  
    return _glColor4dv(v);  
 }  
   
 void stub_glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);  
 void (* _glColor4f)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) = &stub_glColor4f;  
   
 void stub_glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {  
    if (Os::getExtendedProcAddress("glColor4f") == NULL) {  
       return GL_kludge_error_void("glColor4f");  
    }  
    _glColor4f = (void (*)(GLfloat , GLfloat , GLfloat , GLfloat))Os::getExtendedProcAddress("glColor4f");  
    return _glColor4f(red , green , blue , alpha);  
 }  
   
 void stub_glColor4fv(const GLfloat *v);  
 void (* _glColor4fv)(const GLfloat *v) = &stub_glColor4fv;  
   
 void stub_glColor4fv(const GLfloat *v) {  
    if (Os::getExtendedProcAddress("glColor4fv") == NULL) {  
       return GL_kludge_error_void("glColor4fv");  
    }  
    _glColor4fv = (void (*)(const GLfloat *))Os::getExtendedProcAddress("glColor4fv");  
    return _glColor4fv(v);  
 }  
   
 void stub_glColor4i(GLint red, GLint green, GLint blue, GLint alpha);  
 void (* _glColor4i)(GLint red, GLint green, GLint blue, GLint alpha) = &stub_glColor4i;  
   
 void stub_glColor4i(GLint red, GLint green, GLint blue, GLint alpha) {  
    if (Os::getExtendedProcAddress("glColor4i") == NULL) {  
       return GL_kludge_error_void("glColor4i");  
    }  
    _glColor4i = (void (*)(GLint , GLint , GLint , GLint))Os::getExtendedProcAddress("glColor4i");  
    return _glColor4i(red , green , blue , alpha);  
 }  
   
 void stub_glColor4iv(const GLint *v);  
 void (* _glColor4iv)(const GLint *v) = &stub_glColor4iv;  
   
 void stub_glColor4iv(const GLint *v) {  
    if (Os::getExtendedProcAddress("glColor4iv") == NULL) {  
       return GL_kludge_error_void("glColor4iv");  
    }  
    _glColor4iv = (void (*)(const GLint *))Os::getExtendedProcAddress("glColor4iv");  
    return _glColor4iv(v);  
 }  
   
 void stub_glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha);  
 void (* _glColor4s)(GLshort red, GLshort green, GLshort blue, GLshort alpha) = &stub_glColor4s;  
   
 void stub_glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha) {  
    if (Os::getExtendedProcAddress("glColor4s") == NULL) {  
       return GL_kludge_error_void("glColor4s");  
    }  
    _glColor4s = (void (*)(GLshort , GLshort , GLshort , GLshort))Os::getExtendedProcAddress("glColor4s");  
    return _glColor4s(red , green , blue , alpha);  
 }  
   
 void stub_glColor4sv(const GLshort *v);  
 void (* _glColor4sv)(const GLshort *v) = &stub_glColor4sv;  
   
 void stub_glColor4sv(const GLshort *v) {  
    if (Os::getExtendedProcAddress("glColor4sv") == NULL) {  
       return GL_kludge_error_void("glColor4sv");  
    }  
    _glColor4sv = (void (*)(const GLshort *))Os::getExtendedProcAddress("glColor4sv");  
    return _glColor4sv(v);  
 }  
   
 void stub_glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);  
 void (* _glColor4ub)(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) = &stub_glColor4ub;  
   
 void stub_glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) {  
    if (Os::getExtendedProcAddress("glColor4ub") == NULL) {  
       return GL_kludge_error_void("glColor4ub");  
    }  
    _glColor4ub = (void (*)(GLubyte , GLubyte , GLubyte , GLubyte))Os::getExtendedProcAddress("glColor4ub");  
    return _glColor4ub(red , green , blue , alpha);  
 }  
   
 void stub_glColor4ubv(const GLubyte *v);  
 void (* _glColor4ubv)(const GLubyte *v) = &stub_glColor4ubv;  
   
 void stub_glColor4ubv(const GLubyte *v) {  
    if (Os::getExtendedProcAddress("glColor4ubv") == NULL) {  
       return GL_kludge_error_void("glColor4ubv");  
    }  
    _glColor4ubv = (void (*)(const GLubyte *))Os::getExtendedProcAddress("glColor4ubv");  
    return _glColor4ubv(v);  
 }  
   
 void stub_glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha);  
 void (* _glColor4ui)(GLuint red, GLuint green, GLuint blue, GLuint alpha) = &stub_glColor4ui;  
   
 void stub_glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha) {  
    if (Os::getExtendedProcAddress("glColor4ui") == NULL) {  
       return GL_kludge_error_void("glColor4ui");  
    }  
    _glColor4ui = (void (*)(GLuint , GLuint , GLuint , GLuint))Os::getExtendedProcAddress("glColor4ui");  
    return _glColor4ui(red , green , blue , alpha);  
 }  
   
 void stub_glColor4uiv(const GLuint *v);  
 void (* _glColor4uiv)(const GLuint *v) = &stub_glColor4uiv;  
   
 void stub_glColor4uiv(const GLuint *v) {  
    if (Os::getExtendedProcAddress("glColor4uiv") == NULL) {  
       return GL_kludge_error_void("glColor4uiv");  
    }  
    _glColor4uiv = (void (*)(const GLuint *))Os::getExtendedProcAddress("glColor4uiv");  
    return _glColor4uiv(v);  
 }  
   
 void stub_glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha);  
 void (* _glColor4us)(GLushort red, GLushort green, GLushort blue, GLushort alpha) = &stub_glColor4us;  
   
 void stub_glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha) {  
    if (Os::getExtendedProcAddress("glColor4us") == NULL) {  
       return GL_kludge_error_void("glColor4us");  
    }  
    _glColor4us = (void (*)(GLushort , GLushort , GLushort , GLushort))Os::getExtendedProcAddress("glColor4us");  
    return _glColor4us(red , green , blue , alpha);  
 }  
   
 void stub_glColor4usv(const GLushort *v);  
 void (* _glColor4usv)(const GLushort *v) = &stub_glColor4usv;  
   
 void stub_glColor4usv(const GLushort *v) {  
    if (Os::getExtendedProcAddress("glColor4usv") == NULL) {  
       return GL_kludge_error_void("glColor4usv");  
    }  
    _glColor4usv = (void (*)(const GLushort *))Os::getExtendedProcAddress("glColor4usv");  
    return _glColor4usv(v);  
 }  
   
 void stub_glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);  
 void (* _glColorMask)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) = &stub_glColorMask;  
   
 void stub_glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) {  
    if (Os::getExtendedProcAddress("glColorMask") == NULL) {  
       return GL_kludge_error_void("glColorMask");  
    }  
    _glColorMask = (void (*)(GLboolean , GLboolean , GLboolean , GLboolean))Os::getExtendedProcAddress("glColorMask");  
    return _glColorMask(red , green , blue , alpha);  
 }  
   
 void stub_glColorMaterial(GLenum face, GLenum mode);  
 void (* _glColorMaterial)(GLenum face, GLenum mode) = &stub_glColorMaterial;  
   
 void stub_glColorMaterial(GLenum face, GLenum mode) {  
    if (Os::getExtendedProcAddress("glColorMaterial") == NULL) {  
       return GL_kludge_error_void("glColorMaterial");  
    }  
    _glColorMaterial = (void (*)(GLenum , GLenum))Os::getExtendedProcAddress("glColorMaterial");  
    return _glColorMaterial(face , mode);  
 }  
   
 void stub_glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);  
 void (* _glColorPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) = &stub_glColorPointer;  
   
 void stub_glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) {  
    if (Os::getExtendedProcAddress("glColorPointer") == NULL) {  
       return GL_kludge_error_void("glColorPointer");  
    }  
    _glColorPointer = (void (*)(GLint , GLenum , GLsizei , const GLvoid *))Os::getExtendedProcAddress("glColorPointer");  
    return _glColorPointer(size , type , stride , pointer);  
 }  
   
199  void stub_glColorPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer);  void stub_glColorPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer);
200  void (* _glColorPointerEXT)(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer) = &stub_glColorPointerEXT;  void (* _glColorPointerEXT)(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer) = &stub_glColorPointerEXT;
201    
# Line 768  void stub_glColorPointerEXT(GLint size, Line 207  void stub_glColorPointerEXT(GLint size,
207     return _glColorPointerEXT(size , type , stride , count , pointer);     return _glColorPointerEXT(size , type , stride , count , pointer);
208  }  }
209    
 void stub_glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data);  
 void (* _glColorSubTable)(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data) = &stub_glColorSubTable;  
   
 void stub_glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data) {  
    if (Os::getExtendedProcAddress("glColorSubTable") == NULL) {  
       return GL_kludge_error_void("glColorSubTable");  
    }  
    _glColorSubTable = (void (*)(GLenum , GLsizei , GLsizei , GLenum , GLenum , const GLvoid *))Os::getExtendedProcAddress("glColorSubTable");  
    return _glColorSubTable(target , start , count , format , type , data);  
 }  
   
210  void stub_glColorSubTableEXT(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *table);  void stub_glColorSubTableEXT(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *table);
211  void (* _glColorSubTableEXT)(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *table) = &stub_glColorSubTableEXT;  void (* _glColorSubTableEXT)(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *table) = &stub_glColorSubTableEXT;
212    
# Line 790  void stub_glColorSubTableEXT(GLenum targ Line 218  void stub_glColorSubTableEXT(GLenum targ
218     return _glColorSubTableEXT(target , start , count , format , type , table);     return _glColorSubTableEXT(target , start , count , format , type , table);
219  }  }
220    
 void stub_glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table);  
 void (* _glColorTable)(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table) = &stub_glColorTable;  
   
 void stub_glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table) {  
    if (Os::getExtendedProcAddress("glColorTable") == NULL) {  
       return GL_kludge_error_void("glColorTable");  
    }  
    _glColorTable = (void (*)(GLenum , GLenum , GLsizei , GLenum , GLenum , const GLvoid *))Os::getExtendedProcAddress("glColorTable");  
    return _glColorTable(target , internalformat , width , format , type , table);  
 }  
   
221  void stub_glColorTableEXT(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table);  void stub_glColorTableEXT(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table);
222  void (* _glColorTableEXT)(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table) = &stub_glColorTableEXT;  void (* _glColorTableEXT)(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table) = &stub_glColorTableEXT;
223    
# Line 812  void stub_glColorTableEXT(GLenum target, Line 229  void stub_glColorTableEXT(GLenum target,
229     return _glColorTableEXT(target , internalformat , width , format , type , table);     return _glColorTableEXT(target , internalformat , width , format , type , table);
230  }  }
231    
 void stub_glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params);  
 void (* _glColorTableParameterfv)(GLenum target, GLenum pname, const GLfloat *params) = &stub_glColorTableParameterfv;  
   
 void stub_glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params) {  
    if (Os::getExtendedProcAddress("glColorTableParameterfv") == NULL) {  
       return GL_kludge_error_void("glColorTableParameterfv");  
    }  
    _glColorTableParameterfv = (void (*)(GLenum , GLenum , const GLfloat *))Os::getExtendedProcAddress("glColorTableParameterfv");  
    return _glColorTableParameterfv(target , pname , params);  
 }  
   
 void stub_glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params);  
 void (* _glColorTableParameteriv)(GLenum target, GLenum pname, const GLint *params) = &stub_glColorTableParameteriv;  
   
 void stub_glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params) {  
    if (Os::getExtendedProcAddress("glColorTableParameteriv") == NULL) {  
       return GL_kludge_error_void("glColorTableParameteriv");  
    }  
    _glColorTableParameteriv = (void (*)(GLenum , GLenum , const GLint *))Os::getExtendedProcAddress("glColorTableParameteriv");  
    return _glColorTableParameteriv(target , pname , params);  
 }  
   
232  void stub_glCombinerInputNV(GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage);  void stub_glCombinerInputNV(GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage);
233  void (* _glCombinerInputNV)(GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage) = &stub_glCombinerInputNV;  void (* _glCombinerInputNV)(GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage) = &stub_glCombinerInputNV;
234    
# Line 1153  void stub_glCopyConvolutionFilter2D(GLen Line 548  void stub_glCopyConvolutionFilter2D(GLen
548     return _glCopyConvolutionFilter2D(target , internalformat , x , y , width , height);     return _glCopyConvolutionFilter2D(target , internalformat , x , y , width , height);
549  }  }
550    
 void stub_glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);  
 void (* _glCopyPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type) = &stub_glCopyPixels;  
   
 void stub_glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type) {  
    if (Os::getExtendedProcAddress("glCopyPixels") == NULL) {  
       return GL_kludge_error_void("glCopyPixels");  
    }  
    _glCopyPixels = (void (*)(GLint , GLint , GLsizei , GLsizei , GLenum))Os::getExtendedProcAddress("glCopyPixels");  
    return _glCopyPixels(x , y , width , height , type);  
 }  
   
 void stub_glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);  
 void (* _glCopyTexImage1D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border) = &stub_glCopyTexImage1D;  
   
 void stub_glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border) {  
    if (Os::getExtendedProcAddress("glCopyTexImage1D") == NULL) {  
       return GL_kludge_error_void("glCopyTexImage1D");  
    }  
    _glCopyTexImage1D = (void (*)(GLenum , GLint , GLenum , GLint , GLint , GLsizei , GLint))Os::getExtendedProcAddress("glCopyTexImage1D");  
    return _glCopyTexImage1D(target , level , internalformat , x , y , width , border);  
 }  
   
 void stub_glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);  
 void (* _glCopyTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) = &stub_glCopyTexImage2D;  
   
 void stub_glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) {  
    if (Os::getExtendedProcAddress("glCopyTexImage2D") == NULL) {  
       return GL_kludge_error_void("glCopyTexImage2D");  
    }  
    _glCopyTexImage2D = (void (*)(GLenum , GLint , GLenum , GLint , GLint , GLsizei , GLsizei , GLint))Os::getExtendedProcAddress("glCopyTexImage2D");  
    return _glCopyTexImage2D(target , level , internalformat , x , y , width , height , border);  
 }  
   
 void stub_glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);  
 void (* _glCopyTexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) = &stub_glCopyTexSubImage1D;  
   
 void stub_glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width) {  
    if (Os::getExtendedProcAddress("glCopyTexSubImage1D") == NULL) {  
       return GL_kludge_error_void("glCopyTexSubImage1D");  
    }  
    _glCopyTexSubImage1D = (void (*)(GLenum , GLint , GLint , GLint , GLint , GLsizei))Os::getExtendedProcAddress("glCopyTexSubImage1D");  
    return _glCopyTexSubImage1D(target , level , xoffset , x , y , width);  
 }  
   
 void stub_glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);  
 void (* _glCopyTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) = &stub_glCopyTexSubImage2D;  
   
 void stub_glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) {  
    if (Os::getExtendedProcAddress("glCopyTexSubImage2D") == NULL) {  
       return GL_kludge_error_void("glCopyTexSubImage2D");  
    }  
    _glCopyTexSubImage2D = (void (*)(GLenum , GLint , GLint , GLint , GLint , GLint , GLsizei , GLsizei))Os::getExtendedProcAddress("glCopyTexSubImage2D");  
    return _glCopyTexSubImage2D(target , level , xoffset , yoffset , x , y , width , height);  
 }  
   
551  void stub_glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);  void stub_glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
552  void (* _glCopyTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) = &stub_glCopyTexSubImage3D;  void (* _glCopyTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height) = &stub_glCopyTexSubImage3D;
553    
# Line 1230  void stub_glCopyTexSubImage3DEXT(GLenum Line 570  void stub_glCopyTexSubImage3DEXT(GLenum
570     return _glCopyTexSubImage3DEXT(target , level , xoffset , yoffset , zoffset , x , y , width , height);     return _glCopyTexSubImage3DEXT(target , level , xoffset , yoffset , zoffset , x , y , width , height);
571  }  }
572    
 void stub_glCullFace(GLenum mode);  
 void (* _glCullFace)(GLenum mode) = &stub_glCullFace;  
   
 void stub_glCullFace(GLenum mode) {  
    if (Os::getExtendedProcAddress("glCullFace") == NULL) {  
       return GL_kludge_error_void("glCullFace");  
    }  
    _glCullFace = (void (*)(GLenum))Os::getExtendedProcAddress("glCullFace");  
    return _glCullFace(mode);  
 }  
   
573  void stub_glDeleteFencesNV(GLsizei n, const GLuint *fences);  void stub_glDeleteFencesNV(GLsizei n, const GLuint *fences);
574  void (* _glDeleteFencesNV)(GLsizei n, const GLuint *fences) = &stub_glDeleteFencesNV;  void (* _glDeleteFencesNV)(GLsizei n, const GLuint *fences) = &stub_glDeleteFencesNV;
575    
# Line 1252  void stub_glDeleteFencesNV(GLsizei n, co Line 581  void stub_glDeleteFencesNV(GLsizei n, co
581     return _glDeleteFencesNV(n , fences);     return _glDeleteFencesNV(n , fences);
582  }  }
583    
 void stub_glDeleteLists(GLuint list, GLsizei range);  
 void (* _glDeleteLists)(GLuint list, GLsizei range) = &stub_glDeleteLists;  
   
 void stub_glDeleteLists(GLuint list, GLsizei range) {  
    if (Os::getExtendedProcAddress("glDeleteLists") == NULL) {  
       return GL_kludge_error_void("glDeleteLists");  
    }  
    _glDeleteLists = (void (*)(GLuint , GLsizei))Os::getExtendedProcAddress("glDeleteLists");  
    return _glDeleteLists(list , range);  
 }  
   
584  void stub_glDeleteOcclusionQueriesNV(GLsizei n, const GLuint *ids);  void stub_glDeleteOcclusionQueriesNV(GLsizei n, const GLuint *ids);
585  void (* _glDeleteOcclusionQueriesNV)(GLsizei n, const GLuint *ids) = &stub_glDeleteOcclusionQueriesNV;  void (* _glDeleteOcclusionQueriesNV)(GLsizei n, const GLuint *ids) = &stub_glDeleteOcclusionQueriesNV;
586    
# Line 1285  void stub_glDeleteProgramsNV(GLsizei n, Line 603  void stub_glDeleteProgramsNV(GLsizei n,
603     return _glDeleteProgramsNV(n , programs);     return _glDeleteProgramsNV(n , programs);
604  }  }
605    
 void stub_glDeleteTextures(GLsizei n, const GLuint *textures);  
 void (* _glDeleteTextures)(GLsizei n, const GLuint *textures) = &stub_glDeleteTextures;  
   
 void stub_glDeleteTextures(GLsizei n, const GLuint *textures) {  
    if (Os::getExtendedProcAddress("glDeleteTextures") == NULL) {  
       return GL_kludge_error_void("glDeleteTextures");  
    }  
    _glDeleteTextures = (void (*)(GLsizei , const GLuint *))Os::getExtendedProcAddress("glDeleteTextures");  
    return _glDeleteTextures(n , textures);  
 }  
   
606  void stub_glDeleteTexturesEXT(GLsizei n, const GLuint *textures);  void stub_glDeleteTexturesEXT(GLsizei n, const GLuint *textures);
607  void (* _glDeleteTexturesEXT)(GLsizei n, const GLuint *textures) = &stub_glDeleteTexturesEXT;  void (* _glDeleteTexturesEXT)(GLsizei n, const GLuint *textures) = &stub_glDeleteTexturesEXT;
608    
# Line 1307  void stub_glDeleteTexturesEXT(GLsizei n, Line 614  void stub_glDeleteTexturesEXT(GLsizei n,
614     return _glDeleteTexturesEXT(n , textures);     return _glDeleteTexturesEXT(n , textures);
615  }  }
616    
 void stub_glDepthFunc(GLenum func);  
 void (* _glDepthFunc)(GLenum func) = &stub_glDepthFunc;  
   
 void stub_glDepthFunc(GLenum func) {  
    if (Os::getExtendedProcAddress("glDepthFunc") == NULL) {  
       return GL_kludge_error_void("glDepthFunc");  
    }  
    _glDepthFunc = (void (*)(GLenum))Os::getExtendedProcAddress("glDepthFunc");  
    return _glDepthFunc(func);  
 }  
   
 void stub_glDepthMask(GLboolean flag);  
 void (* _glDepthMask)(GLboolean flag) = &stub_glDepthMask;  
   
 void stub_glDepthMask(GLboolean flag) {  
    if (Os::getExtendedProcAddress("glDepthMask") == NULL) {  
       return GL_kludge_error_void("glDepthMask");  
    }  
    _glDepthMask = (void (*)(GLboolean))Os::getExtendedProcAddress("glDepthMask");  
    return _glDepthMask(flag);  
 }  
   
 void stub_glDepthRange(GLclampd zNear, GLclampd zFar);  
 void (* _glDepthRange)(GLclampd zNear, GLclampd zFar) = &stub_glDepthRange;  
   
 void stub_glDepthRange(GLclampd zNear, GLclampd zFar) {  
    if (Os::getExtendedProcAddress("glDepthRange") == NULL) {  
       return GL_kludge_error_void("glDepthRange");  
    }  
    _glDepthRange = (void (*)(GLclampd , GLclampd))Os::getExtendedProcAddress("glDepthRange");  
    return _glDepthRange(zNear , zFar);  
 }  
   
 void stub_glDisable(GLenum cap);  
 void (* _glDisable)(GLenum cap) = &stub_glDisable;  
   
 void stub_glDisable(GLenum cap) {  
    if (Os::getExtendedProcAddress("glDisable") == NULL) {  
       return GL_kludge_error_void("glDisable");  
    }  
    _glDisable = (void (*)(GLenum))Os::getExtendedProcAddress("glDisable");  
    return _glDisable(cap);  
 }  
   
 void stub_glDisableClientState(GLenum array);  
 void (* _glDisableClientState)(GLenum array) = &stub_glDisableClientState;  
   
 void stub_glDisableClientState(GLenum array) {  
    if (Os::getExtendedProcAddress("glDisableClientState") == NULL) {  
       return GL_kludge_error_void("glDisableClientState");  
    }  
    _glDisableClientState = (void (*)(GLenum))Os::getExtendedProcAddress("glDisableClientState");  
    return _glDisableClientState(array);  
 }  
   
 void stub_glDrawArrays(GLenum mode, GLint first, GLsizei count);  
 void (* _glDrawArrays)(GLenum mode, GLint first, GLsizei count) = &stub_glDrawArrays;  
   
 void stub_glDrawArrays(GLenum mode, GLint first, GLsizei count) {  
    if (Os::getExtendedProcAddress("glDrawArrays") == NULL) {  
       return GL_kludge_error_void("glDrawArrays");  
    }  
    _glDrawArrays = (void (*)(GLenum , GLint , GLsizei))Os::getExtendedProcAddress("glDrawArrays");  
    return _glDrawArrays(mode , first , count);  
 }  
   
617  void stub_glDrawArraysEXT(GLenum mode, GLint first, GLsizei count);  void stub_glDrawArraysEXT(GLenum mode, GLint first, GLsizei count);
618  void (* _glDrawArraysEXT)(GLenum mode, GLint first, GLsizei count) = &stub_glDrawArraysEXT;  void (* _glDrawArraysEXT)(GLenum mode, GLint first, GLsizei count) = &stub_glDrawArraysEXT;
619    
# Line 1384  void stub_glDrawArraysEXT(GLenum mode, G Line 625  void stub_glDrawArraysEXT(GLenum mode, G
625     return _glDrawArraysEXT(mode , first , count);     return _glDrawArraysEXT(mode , first , count);
626  }  }
627    
 void stub_glDrawBuffer(GLenum mode);  
 void (* _glDrawBuffer)(GLenum mode) = &stub_glDrawBuffer;  
   
 void stub_glDrawBuffer(GLenum mode) {  
    if (Os::getExtendedProcAddress("glDrawBuffer") == NULL) {  
       return GL_kludge_error_void("glDrawBuffer");  
    }  
    _glDrawBuffer = (void (*)(GLenum))Os::getExtendedProcAddress("glDrawBuffer");  
    return _glDrawBuffer(mode);  
 }  
   
 void stub_glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);  
 void (* _glDrawElements)(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices) = &stub_glDrawElements;  
   
 void stub_glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices) {  
    if (Os::getExtendedProcAddress("glDrawElements") == NULL) {  
       return GL_kludge_error_void("glDrawElements");  
    }  
    _glDrawElements = (void (*)(GLenum , GLsizei , GLenum , const GLvoid *))Os::getExtendedProcAddress("glDrawElements");  
    return _glDrawElements(mode , count , type , indices);  
 }  
   
628  void stub_glDrawMeshNV(GLenum mode, GLsizei count, GLenum type, GLsizei stride, const GLvoid *indicesTexCoord, const GLvoid *indicesNormal, const GLvoid *indicesVertex);  void stub_glDrawMeshNV(GLenum mode, GLsizei count, GLenum type, GLsizei stride, const GLvoid *indicesTexCoord, const GLvoid *indicesNormal, const GLvoid *indicesVertex);
629  void (* _glDrawMeshNV)(GLenum mode, GLsizei count, GLenum type, GLsizei stride, const GLvoid *indicesTexCoord, const GLvoid *indicesNormal, const GLvoid *indicesVertex) = &stub_glDrawMeshNV;  void (* _glDrawMeshNV)(GLenum mode, GLsizei count, GLenum type, GLsizei stride, const GLvoid *indicesTexCoord, const GLvoid *indicesNormal, const GLvoid *indicesVertex) = &stub_glDrawMeshNV;
630    
# Line 1417  void stub_glDrawMeshNV(GLenum mode, GLsi Line 636  void stub_glDrawMeshNV(GLenum mode, GLsi
636     return _glDrawMeshNV(mode , count , type , stride , indicesTexCoord , indicesNormal , indicesVertex);     return _glDrawMeshNV(mode , count , type , stride , indicesTexCoord , indicesNormal , indicesVertex);
637  }  }
638    
 void stub_glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);  
 void (* _glDrawPixels)(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels) = &stub_glDrawPixels;  
   
 void stub_glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels) {  
    if (Os::getExtendedProcAddress("glDrawPixels") == NULL) {  
       return GL_kludge_error_void("glDrawPixels");  
    }  
    _glDrawPixels = (void (*)(GLsizei , GLsizei , GLenum , GLenum , const GLvoid *))Os::getExtendedProcAddress("glDrawPixels");  
    return _glDrawPixels(width , height , format , type , pixels);  
 }  
   
639  void stub_glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);  void stub_glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);
640  void (* _glDrawRangeElements)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices) = &stub_glDrawRangeElements;  void (* _glDrawRangeElements)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices) = &stub_glDrawRangeElements;
641    
# Line 1450  void stub_glDrawRangeElementsEXT(GLenum Line 658  void stub_glDrawRangeElementsEXT(GLenum
658     return _glDrawRangeElementsEXT(mode , start , end , count , type , indices);     return _glDrawRangeElementsEXT(mode , start , end , count , type , indices);
659  }  }
660    
 void stub_glEdgeFlag(GLboolean flag);  
 void (* _glEdgeFlag)(GLboolean flag) = &stub_glEdgeFlag;  
   
 void stub_glEdgeFlag(GLboolean flag) {  
    if (Os::getExtendedProcAddress("glEdgeFlag") == NULL) {  
       return GL_kludge_error_void("glEdgeFlag");  
    }  
    _glEdgeFlag = (void (*)(GLboolean))Os::getExtendedProcAddress("glEdgeFlag");  
    return _glEdgeFlag(flag);  
 }  
   
 void stub_glEdgeFlagPointer(GLsizei stride, const GLboolean *pointer);  
 void (* _glEdgeFlagPointer)(GLsizei stride, const GLboolean *pointer) = &stub_glEdgeFlagPointer;  
   
 void stub_glEdgeFlagPointer(GLsizei stride, const GLboolean *pointer) {  
    if (Os::getExtendedProcAddress("glEdgeFlagPointer") == NULL) {  
       return GL_kludge_error_void("glEdgeFlagPointer");  
    }  
    _glEdgeFlagPointer = (void (*)(GLsizei , const GLboolean *))Os::getExtendedProcAddress("glEdgeFlagPointer");  
    return _glEdgeFlagPointer(stride , pointer);  
 }  
   
661  void stub_glEdgeFlagPointerEXT(GLsizei stride, GLsizei count, const GLboolean *pointer);  void stub_glEdgeFlagPointerEXT(GLsizei stride, GLsizei count, const GLboolean *pointer);
662  void (* _glEdgeFlagPointerEXT)(GLsizei stride, GLsizei count, const GLboolean *pointer) = &stub_glEdgeFlagPointerEXT;  void (* _glEdgeFlagPointerEXT)(GLsizei stride, GLsizei count, const GLboolean *pointer) = &stub_glEdgeFlagPointerEXT;
663    
# Line 1483  void stub_glEdgeFlagPointerEXT(GLsizei s Line 669  void stub_glEdgeFlagPointerEXT(GLsizei s
669     return _glEdgeFlagPointerEXT(stride , count , pointer);     return _glEdgeFlagPointerEXT(stride , count , pointer);
670  }  }
671    
 void stub_glEdgeFlagv(const GLboolean *flag);  
 void (* _glEdgeFlagv)(const GLboolean *flag) = &stub_glEdgeFlagv;  
   
 void stub_glEdgeFlagv(const GLboolean *flag) {  
    if (Os::getExtendedProcAddress("glEdgeFlagv") == NULL) {  
       return GL_kludge_error_void("glEdgeFlagv");  
    }  
    _glEdgeFlagv = (void (*)(const GLboolean *))Os::getExtendedProcAddress("glEdgeFlagv");  
    return _glEdgeFlagv(flag);  
 }  
   
 void stub_glEnable(GLenum cap);  
 void (* _glEnable)(GLenum cap) = &stub_glEnable;  
   
 void stub_glEnable(GLenum cap) {  
    if (Os::getExtendedProcAddress("glEnable") == NULL) {  
       return GL_kludge_error_void("glEnable");  
    }  
    _glEnable = (void (*)(GLenum))Os::getExtendedProcAddress("glEnable");  
    return _glEnable(cap);  
 }  
   
 void stub_glEnableClientState(GLenum array);  
 void (* _glEnableClientState)(GLenum array) = &stub_glEnableClientState;  
   
 void stub_glEnableClientState(GLenum array) {  
    if (Os::getExtendedProcAddress("glEnableClientState") == NULL) {  
       return GL_kludge_error_void("glEnableClientState");  
    }  
    _glEnableClientState = (void (*)(GLenum))Os::getExtendedProcAddress("glEnableClientState");  
    return _glEnableClientState(array);  
 }  
   
 void stub_glEnd(void);  
 void (* _glEnd)(void) = &stub_glEnd;  
   
 void stub_glEnd(void) {  
    if (Os::getExtendedProcAddress("glEnd") == NULL) {  
       return GL_kludge_error_void("glEnd");  
    }  
    _glEnd = (void (*)())Os::getExtendedProcAddress("glEnd");  
    return _glEnd();  
 }  
   
 void stub_glEndList(void);  
 void (* _glEndList)(void) = &stub_glEndList;  
   
 void stub_glEndList(void) {  
    if (Os::getExtendedProcAddress("glEndList") == NULL) {  
       return GL_kludge_error_void("glEndList");  
    }  
    _glEndList = (void (*)())Os::getExtendedProcAddress("glEndList");  
    return _glEndList();  
 }  
   
672  void stub_glEndOcclusionQueryNV(void);  void stub_glEndOcclusionQueryNV(void);
673  void (* _glEndOcclusionQueryNV)(void) = &stub_glEndOcclusionQueryNV;  void (* _glEndOcclusionQueryNV)(void) = &stub_glEndOcclusionQueryNV;
674    
# Line 1549  void stub_glEndOcclusionQueryNV(void) { Line 680  void stub_glEndOcclusionQueryNV(void) {
680     return _glEndOcclusionQueryNV();     return _glEndOcclusionQueryNV();
681  }  }
682    
 void stub_glEvalCoord1d(GLdouble u);  
 void (* _glEvalCoord1d)(GLdouble u) = &stub_glEvalCoord1d;  
   
 void stub_glEvalCoord1d(GLdouble u) {  
    if (Os::getExtendedProcAddress("glEvalCoord1d") == NULL) {  
       return GL_kludge_error_void("glEvalCoord1d");  
    }  
    _glEvalCoord1d = (void (*)(GLdouble))Os::getExtendedProcAddress("glEvalCoord1d");  
    return _glEvalCoord1d(u);  
 }  
   
 void stub_glEvalCoord1dv(const GLdouble *u);  
 void (* _glEvalCoord1dv)(const GLdouble *u) = &stub_glEvalCoord1dv;  
   
 void stub_glEvalCoord1dv(const GLdouble *u) {  
    if (Os::getExtendedProcAddress("glEvalCoord1dv") == NULL) {  
       return GL_kludge_error_void("glEvalCoord1dv");  
    }  
    _glEvalCoord1dv = (void (*)(const GLdouble *))Os::getExtendedProcAddress("glEvalCoord1dv");  
    return _glEvalCoord1dv(u);  
 }  
   
 void stub_glEvalCoord1f(GLfloat u);  
 void (* _glEvalCoord1f)(GLfloat u) = &stub_glEvalCoord1f;  
   
 void stub_glEvalCoord1f(GLfloat u) {  
    if (Os::getExtendedProcAddress("glEvalCoord1f") == NULL) {  
       return GL_kludge_error_void("glEvalCoord1f");  
    }  
    _glEvalCoord1f = (void (*)(GLfloat))Os::getExtendedProcAddress("glEvalCoord1f");  
    return _glEvalCoord1f(u);  
 }  
   
 void stub_glEvalCoord1fv(const GLfloat *u);  
 void (* _glEvalCoord1fv)(const GLfloat *u) = &stub_glEvalCoord1fv;  
   
 void stub_glEvalCoord1fv(const GLfloat *u) {  
    if (Os::getExtendedProcAddress("glEvalCoord1fv") == NULL) {  
       return GL_kludge_error_void("glEvalCoord1fv");  
    }  
    _glEvalCoord1fv = (void (*)(const GLfloat *))Os::getExtendedProcAddress("glEvalCoord1fv");  
    return _glEvalCoord1fv(u);  
 }  
   
 void stub_glEvalCoord2d(GLdouble u, GLdouble v);  
 void (* _glEvalCoord2d)(GLdouble u, GLdouble v) = &stub_glEvalCoord2d;  
   
 void stub_glEvalCoord2d(GLdouble u, GLdouble v) {  
    if (Os::getExtendedProcAddress("glEvalCoord2d") == NULL) {  
       return GL_kludge_error_void("glEvalCoord2d");  
    }  
    _glEvalCoord2d = (void (*)(GLdouble , GLdouble))Os::getExtendedProcAddress("glEvalCoord2d");  
    return _glEvalCoord2d(u , v);  
 }  
   
 void stub_glEvalCoord2dv(const GLdouble *u);  
 void (* _glEvalCoord2dv)(const GLdouble *u) = &stub_glEvalCoord2dv;  
   
 void stub_glEvalCoord2dv(const GLdouble *u) {  
    if (Os::getExtendedProcAddress("glEvalCoord2dv") == NULL) {  
       return GL_kludge_error_void("glEvalCoord2dv");  
    }  
    _glEvalCoord2dv = (void (*)(const GLdouble *))Os::getExtendedProcAddress("glEvalCoord2dv");  
    return _glEvalCoord2dv(u);  
 }  
   
 void stub_glEvalCoord2f(GLfloat u, GLfloat v);  
 void (* _glEvalCoord2f)(GLfloat u, GLfloat v) = &stub_glEvalCoord2f;  
   
 void stub_glEvalCoord2f(GLfloat u, GLfloat v) {  
    if (Os::getExtendedProcAddress("glEvalCoord2f") == NULL) {  
       return GL_kludge_error_void("glEvalCoord2f");  
    }  
    _glEvalCoord2f = (void (*)(GLfloat , GLfloat))Os::getExtendedProcAddress("glEvalCoord2f");  
    return _glEvalCoord2f(u , v);  
 }  
   
 void stub_glEvalCoord2fv(const GLfloat *u);  
 void (* _glEvalCoord2fv)(const GLfloat *u) = &stub_glEvalCoord2fv;  
   
 void stub_glEvalCoord2fv(const GLfloat *u) {  
    if (Os::getExtendedProcAddress("glEvalCoord2fv") == NULL) {  
       return GL_kludge_error_void("glEvalCoord2fv");  
    }  
    _glEvalCoord2fv = (void (*)(const GLfloat *))Os::getExtendedProcAddress("glEvalCoord2fv");  
    return _glEvalCoord2fv(u);  
 }  
   
683  void stub_glEvalMapsNV(GLenum target, GLenum mode);  void stub_glEvalMapsNV(GLenum target, GLenum mode);
684  void (* _glEvalMapsNV)(GLenum target, GLenum mode) = &stub_glEvalMapsNV;  void (* _glEvalMapsNV)(GLenum target, GLenum mode) = &stub_glEvalMapsNV;
685    
# Line 1648  void stub_glEvalMapsNV(GLenum target, GL Line 691  void stub_glEvalMapsNV(GLenum target, GL
691     return _glEvalMapsNV(target , mode);     return _glEvalMapsNV(target , mode);
692  }  }
693    
 void stub_glEvalMesh1(GLenum mode, GLint i1, GLint i2);  
 void (* _glEvalMesh1)(GLenum mode, GLint i1, GLint i2) = &stub_glEvalMesh1;  
   
 void stub_glEvalMesh1(GLenum mode, GLint i1, GLint i2) {  
    if (Os::getExtendedProcAddress("glEvalMesh1") == NULL) {  
       return GL_kludge_error_void("glEvalMesh1");  
    }  
    _glEvalMesh1 = (void (*)(GLenum , GLint , GLint))Os::getExtendedProcAddress("glEvalMesh1");  
    return _glEvalMesh1(mode , i1 , i2);  
 }  
   
 void stub_glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);  
 void (* _glEvalMesh2)(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2) = &stub_glEvalMesh2;  
   
 void stub_glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2) {  
    if (Os::getExtendedProcAddress("glEvalMesh2") == NULL) {  
       return GL_kludge_error_void("glEvalMesh2");  
    }  
    _glEvalMesh2 = (void (*)(GLenum , GLint , GLint , GLint , GLint))Os::getExtendedProcAddress("glEvalMesh2");  
    return _glEvalMesh2(mode , i1 , i2 , j1 , j2);  
 }  
   
 void stub_glEvalPoint1(GLint i);  
 void (* _glEvalPoint1)(GLint i) = &stub_glEvalPoint1;  
   
 void stub_glEvalPoint1(GLint i) {  
    if (Os::getExtendedProcAddress("glEvalPoint1") == NULL) {  
       return GL_kludge_error_void("glEvalPoint1");  
    }  
    _glEvalPoint1 = (void (*)(GLint))Os::getExtendedProcAddress("glEvalPoint1");  
    return _glEvalPoint1(i);  
 }  
   
 void stub_glEvalPoint2(GLint i, GLint j);  
 void (* _glEvalPoint2)(GLint i, GLint j) = &stub_glEvalPoint2;  
   
 void stub_glEvalPoint2(GLint i, GLint j) {  
    if (Os::getExtendedProcAddress("glEvalPoint2") == NULL) {  
       return GL_kludge_error_void("glEvalPoint2");  
    }  
    _glEvalPoint2 = (void (*)(GLint , GLint))Os::getExtendedProcAddress("glEvalPoint2");  
    return _glEvalPoint2(i , j);  
 }  
   
694  void stub_glExecuteProgramNV(GLenum target, GLuint id, const GLfloat *params);  void stub_glExecuteProgramNV(GLenum target, GLuint id, const GLfloat *params);
695  void (* _glExecuteProgramNV)(GLenum target, GLuint id, const GLfloat *params) = &stub_glExecuteProgramNV;  void (* _glExecuteProgramNV)(GLenum target, GLuint id, const GLfloat *params) = &stub_glExecuteProgramNV;
696    
# Line 1703  void stub_glExecuteProgramNV(GLenum targ Line 702  void stub_glExecuteProgramNV(GLenum targ
702     return _glExecuteProgramNV(target , id , params);     return _glExecuteProgramNV(target , id , params);
703  }  }
704    
 void stub_glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer);  
 void (* _glFeedbackBuffer)(GLsizei size, GLenum type, GLfloat *buffer) = &stub_glFeedbackBuffer;  
   
 void stub_glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer) {  
    if (Os::getExtendedProcAddress("glFeedbackBuffer") == NULL) {  
       return GL_kludge_error_void("glFeedbackBuffer");  
    }  
    _glFeedbackBuffer = (void (*)(GLsizei , GLenum , GLfloat *))Os::getExtendedProcAddress("glFeedbackBuffer");  
    return _glFeedbackBuffer(size , type , buffer);  
 }  
   
705  void stub_glFinalCombinerInputNV(GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage);  void stub_glFinalCombinerInputNV(GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage);
706  void (* _glFinalCombinerInputNV)(GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage) = &stub_glFinalCombinerInputNV;  void (* _glFinalCombinerInputNV)(GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage) = &stub_glFinalCombinerInputNV;
707    
# Line 1725  void stub_glFinalCombinerInputNV(GLenum Line 713  void stub_glFinalCombinerInputNV(GLenum
713     return _glFinalCombinerInputNV(variable , input , mapping , componentUsage);     return _glFinalCombinerInputNV(variable , input , mapping , componentUsage);
714  }  }
715    
 void stub_glFinish(void);  
 void (* _glFinish)(void) = &stub_glFinish;  
   
 void stub_glFinish(void) {  
    if (Os::getExtendedProcAddress("glFinish") == NULL) {  
       return GL_kludge_error_void("glFinish");  
    }  
    _glFinish = (void (*)())Os::getExtendedProcAddress("glFinish");  
    return _glFinish();  
 }  
   
716  void stub_glFinishFenceNV(GLuint fence);  void stub_glFinishFenceNV(GLuint fence);
717  void (* _glFinishFenceNV)(GLuint fence) = &stub_glFinishFenceNV;  void (* _glFinishFenceNV)(GLuint fence) = &stub_glFinishFenceNV;
718    
# Line 1747  void stub_glFinishFenceNV(GLuint fence) Line 724  void stub_glFinishFenceNV(GLuint fence)
724     return _glFinishFenceNV(fence);     return _glFinishFenceNV(fence);
725  }  }
726    
 void stub_glFlush(void);  
 void (* _glFlush)(void) = &stub_glFlush;  
   
 void stub_glFlush(void) {  
    if (Os::getExtendedProcAddress("glFlush") == NULL) {  
       return GL_kludge_error_void("glFlush");  
    }  
    _glFlush = (void (*)())Os::getExtendedProcAddress("glFlush");  
    return _glFlush();  
 }  
   
 GLvoid* stub_glFlushHold(void);  
 GLvoid* (* _glFlushHold)(void) = &stub_glFlushHold;  
   
 GLvoid* stub_glFlushHold(void) {  
    if (Os::getExtendedProcAddress("glFlushHold") == NULL) {  
       return GL_kludge_error_GLvoid_p_("glFlushHold");  
    }  
    _glFlushHold = (GLvoid* (*)())Os::getExtendedProcAddress("glFlushHold");  
    return _glFlushHold();  
 }  
   
727  void stub_glFlushPixelDataRangeNV(GLenum target);  void stub_glFlushPixelDataRangeNV(GLenum target);
728  void (* _glFlushPixelDataRangeNV)(GLenum target) = &stub_glFlushPixelDataRangeNV;  void (* _glFlushPixelDataRangeNV)(GLenum target) = &stub_glFlushPixelDataRangeNV;
729    
# Line 1846  void stub_glFogCoordfvEXT(const GLfloat Line 801  void stub_glFogCoordfvEXT(const GLfloat
801     return _glFogCoordfvEXT(fog);     return _glFogCoordfvEXT(fog);
802  }  }
803    
 void stub_glFogf(GLenum pname, GLfloat param);  
 void (* _glFogf)(GLenum pname, GLfloat param) = &stub_glFogf;  
   
 void stub_glFogf(GLenum pname, GLfloat param) {  
    if (Os::getExtendedProcAddress("glFogf") == NULL) {  
       return GL_kludge_error_void("glFogf");  
    }  
    _glFogf = (void (*)(GLenum , GLfloat))Os::getExtendedProcAddress("glFogf");  
    return _glFogf(pname , param);  
 }  
   
 void stub_glFogfv(GLenum pname, const GLfloat *params);  
 void (* _glFogfv)(GLenum pname, const GLfloat *params) = &stub_glFogfv;  
   
 void stub_glFogfv(GLenum pname, const GLfloat *params) {  
    if (Os::getExtendedProcAddress("glFogfv") == NULL) {  
       return GL_kludge_error_void("glFogfv");  
    }  
    _glFogfv = (void (*)(GLenum , const GLfloat *))Os::getExtendedProcAddress("glFogfv");  
    return _glFogfv(pname , params);  
 }  
   
 void stub_glFogi(GLenum pname, GLint param);  
 void (* _glFogi)(GLenum pname, GLint param) = &stub_glFogi;  
   
 void stub_glFogi(GLenum pname, GLint param) {  
    if (Os::getExtendedProcAddress("glFogi") == NULL) {  
       return GL_kludge_error_void("glFogi");  
    }  
    _glFogi = (void (*)(GLenum , GLint))Os::getExtendedProcAddress("glFogi");  
    return _glFogi(pname , param);  
 }  
   
 void stub_glFogiv(GLenum pname, const GLint *params);  
 void (* _glFogiv)(GLenum pname, const GLint *params) = &stub_glFogiv;  
   
 void stub_glFogiv(GLenum pname, const GLint *params) {  
    if (Os::getExtendedProcAddress("glFogiv") == NULL) {  
       return GL_kludge_error_void("glFogiv");  
    }  
    _glFogiv = (void (*)(GLenum , const GLint *))Os::getExtendedProcAddress("glFogiv");  
    return _glFogiv(pname , params);  
 }  
   
 void stub_glFrontFace(GLenum mode);  
 void (* _glFrontFace)(GLenum mode) = &stub_glFrontFace;  
   
 void stub_glFrontFace(GLenum mode) {  
    if (Os::getExtendedProcAddress("glFrontFace") == NULL) {  
       return GL_kludge_error_void("glFrontFace");  
    }  
    _glFrontFace = (void (*)(GLenum))Os::getExtendedProcAddress("glFrontFace");  
    return _glFrontFace(mode);  
 }  
   
 void stub_glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);  
 void (* _glFrustum)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) = &stub_glFrustum;  
   
 void stub_glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) {  
    if (Os::getExtendedProcAddress("glFrustum") == NULL) {  
       return GL_kludge_error_void("glFrustum");  
    }  
    _glFrustum = (void (*)(GLdouble , GLdouble , GLdouble , GLdouble , GLdouble , GLdouble))Os::getExtendedProcAddress("glFrustum");  
    return _glFrustum(left , right , bottom , top , zNear , zFar);  
 }  
   
804  void stub_glGenFencesNV(GLsizei n, GLuint *fences);  void stub_glGenFencesNV(GLsizei n, GLuint *fences);
805  void (* _glGenFencesNV)(GLsizei n, GLuint *fences) = &stub_glGenFencesNV;  void (* _glGenFencesNV)(GLsizei n, GLuint *fences) = &stub_glGenFencesNV;
806    
# Line 1923  void stub_glGenFencesNV(GLsizei n, GLuin Line 812  void stub_glGenFencesNV(GLsizei n, GLuin
812     return _glGenFencesNV(n , fences);     return _glGenFencesNV(n , fences);
813  }  }
814    
 GLuint stub_glGenLists(GLsizei range);  
 GLuint (* _glGenLists)(GLsizei range) = &stub_glGenLists;  
   
 GLuint stub_glGenLists(GLsizei range) {  
    if (Os::getExtendedProcAddress("glGenLists") == NULL) {  
       return GL_kludge_error_GLuint("glGenLists");  
    }  
    _glGenLists = (GLuint (*)(GLsizei))Os::getExtendedProcAddress("glGenLists");  
    return _glGenLists(range);  
 }  
   
815  void stub_glGenOcclusionQueriesNV(GLsizei n, GLuint *ids);  void stub_glGenOcclusionQueriesNV(GLsizei n, GLuint *ids);
816  void (* _glGenOcclusionQueriesNV)(GLsizei n, GLuint *ids) = &stub_glGenOcclusionQueriesNV;  void (* _glGenOcclusionQueriesNV)(GLsizei n, GLuint *ids) = &stub_glGenOcclusionQueriesNV;
817    
# Line 1956  void stub_glGenProgramsNV(GLsizei n, GLu Line 834  void stub_glGenProgramsNV(GLsizei n, GLu
834     return _glGenProgramsNV(n , programs);     return _glGenProgramsNV(n , programs);
835  }  }
836    
 void stub_glGenTextures(GLsizei n, GLuint *textures);  
 void (* _glGenTextures)(GLsizei n, GLuint *textures) = &stub_glGenTextures;  
   
 void stub_glGenTextures(GLsizei n, GLuint *textures) {  
    if (Os::getExtendedProcAddress("glGenTextures") == NULL) {  
       return GL_kludge_error_void("glGenTextures");  
    }  
    _glGenTextures = (void (*)(GLsizei , GLuint *))Os::getExtendedProcAddress("glGenTextures");  
    return _glGenTextures(n , textures);  
 }  
   
837  void stub_glGenTexturesEXT(GLsizei n, GLuint *textures);  void stub_glGenTexturesEXT(GLsizei n, GLuint *textures);
838  void (* _glGenTexturesEXT)(GLsizei n, GLuint *textures) = &stub_glGenTexturesEXT;  void (* _glGenTexturesEXT)(GLsizei n, GLuint *textures) = &stub_glGenTexturesEXT;
839    
# Line 1978  void stub_glGenTexturesEXT(GLsizei n, GL Line 845  void stub_glGenTexturesEXT(GLsizei n, GL
845     return _glGenTexturesEXT(n , textures);     return _glGenTexturesEXT(n , textures);
846  }  }
847    
 void stub_glGetBooleanv(GLenum pname, GLboolean *params);  
 void (* _glGetBooleanv)(GLenum pname, GLboolean *params) = &stub_glGetBooleanv;  
   
 void stub_glGetBooleanv(GLenum pname, GLboolean *params) {  
    if (Os::getExtendedProcAddress("glGetBooleanv") == NULL) {  
       return GL_kludge_error_void("glGetBooleanv");  
    }  
    _glGetBooleanv = (void (*)(GLenum , GLboolean *))Os::getExtendedProcAddress("glGetBooleanv");  
    return _glGetBooleanv(pname , params);  
 }  
   
 void stub_glGetClipPlane(GLenum plane, GLdouble *equation);  
 void (* _glGetClipPlane)(GLenum plane, GLdouble *equation) = &stub_glGetClipPlane;  
   
 void stub_glGetClipPlane(GLenum plane, GLdouble *equation) {  
    if (Os::getExtendedProcAddress("glGetClipPlane") == NULL) {  
       return GL_kludge_error_void("glGetClipPlane");  
    }  
    _glGetClipPlane = (void (*)(GLenum , GLdouble *))Os::getExtendedProcAddress("glGetClipPlane");  
    return _glGetClipPlane(plane , equation);  
 }  
   
848  void stub_glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table);  void stub_glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table);
849  void (* _glGetColorTable)(GLenum target, GLenum format, GLenum type, GLvoid *table) = &stub_glGetColorTable;  void (* _glGetColorTable)(GLenum target, GLenum format, GLenum type, GLvoid *table) = &stub_glGetColorTable;
850    
# Line 2176  void stub_glGetConvolutionParameteriv(GL Line 1021  void stub_glGetConvolutionParameteriv(GL
1021     return _glGetConvolutionParameteriv(target , pname , params);     return _glGetConvolutionParameteriv(target , pname , params);
1022  }  }
1023    
 void stub_glGetDoublev(GLenum pname, GLdouble *params);  
 void (* _glGetDoublev)(GLenum pname, GLdouble *params) = &stub_glGetDoublev;  
   
 void stub_glGetDoublev(GLenum pname, GLdouble *params) {  
    if (Os::getExtendedProcAddress("glGetDoublev") == NULL) {  
       return GL_kludge_error_void("glGetDoublev");  
    }  
    _glGetDoublev = (void (*)(GLenum , GLdouble *))Os::getExtendedProcAddress("glGetDoublev");  
    return _glGetDoublev(pname , params);  
 }  
   
 GLenum stub_glGetError(void);  
 GLenum (* _glGetError)(void) = &stub_glGetError;  
   
 GLenum stub_glGetError(void) {  
    if (Os::getExtendedProcAddress("glGetError") == NULL) {  
       return GL_kludge_error_GLenum("glGetError");  
    }  
    _glGetError = (GLenum (*)())Os::getExtendedProcAddress("glGetError");  
    return _glGetError();  
 }  
   
1024  void stub_glGetFenceivNV(GLuint fence, GLenum pname, GLint *params);  void stub_glGetFenceivNV(GLuint fence, GLenum pname, GLint *params);
1025  void (* _glGetFenceivNV)(GLuint fence, GLenum pname, GLint *params) = &stub_glGetFenceivNV;  void (* _glGetFenceivNV)(GLuint fence, GLenum pname, GLint *params) = &stub_glGetFenceivNV;
1026    
# Line 2231  void stub_glGetFinalCombinerInputParamet Line 1054  void stub_glGetFinalCombinerInputParamet
1054     return _glGetFinalCombinerInputParameterivNV(variable , pname , params);     return _glGetFinalCombinerInputParameterivNV(variable , pname , params);
1055  }  }
1056    
 void stub_glGetFloatv(GLenum pname, GLfloat *params);  
 void (* _glGetFloatv)(GLenum pname, GLfloat *params) = &stub_glGetFloatv;  
   
 void stub_glGetFloatv(GLenum pname, GLfloat *params) {  
    if (Os::getExtendedProcAddress("glGetFloatv") == NULL) {  
       return GL_kludge_error_void("glGetFloatv");  
    }  
    _glGetFloatv = (void (*)(GLenum , GLfloat *))Os::getExtendedProcAddress("glGetFloatv");  
    return _glGetFloatv(pname , params);  
 }  
   
1057  void stub_glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);  void stub_glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
1058  void (* _glGetHistogram)(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values) = &stub_glGetHistogram;  void (* _glGetHistogram)(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values) = &stub_glGetHistogram;
1059    
# Line 2275  void stub_glGetHistogramParameteriv(GLen Line 1087  void stub_glGetHistogramParameteriv(GLen
1087     return _glGetHistogramParameteriv(target , pname , params);     return _glGetHistogramParameteriv(target , pname , params);
1088  }  }
1089    
 void stub_glGetIntegerv(GLenum pname, GLint *params);  
 void (* _glGetIntegerv)(GLenum pname, GLint *params) = &stub_glGetIntegerv;  
   
 void stub_glGetIntegerv(GLenum pname, GLint *params) {  
    if (Os::getExtendedProcAddress("glGetIntegerv") == NULL) {  
       return GL_kludge_error_void("glGetIntegerv");  
    }  
    _glGetIntegerv = (void (*)(GLenum , GLint *))Os::getExtendedProcAddress("glGetIntegerv");  
    return _glGetIntegerv(pname , params);  
 }  
   
 void stub_glGetLightfv(GLenum light, GLenum pname, GLfloat *params);  
 void (* _glGetLightfv)(GLenum light, GLenum pname, GLfloat *params) = &stub_glGetLightfv;  
   
 void stub_glGetLightfv(GLenum light, GLenum pname, GLfloat *params) {  
    if (Os::getExtendedProcAddress("glGetLightfv") == NULL) {  
       return GL_kludge_error_void("glGetLightfv");  
    }  
    _glGetLightfv = (void (*)(GLenum , GLenum , GLfloat *))Os::getExtendedProcAddress("glGetLightfv");  
    return _glGetLightfv(light , pname , params);  
 }  
   
 void stub_glGetLightiv(GLenum light, GLenum pname, GLint *params);  
 void (* _glGetLightiv)(GLenum light, GLenum pname, GLint *params) = &stub_glGetLightiv;  
   
 void stub_glGetLightiv(GLenum light, GLenum pname, GLint *params) {  
    if (Os::getExtendedProcAddress("glGetLightiv") == NULL) {  
       return GL_kludge_error_void("glGetLightiv");  
    }  
    _glGetLightiv = (void (*)(GLenum , GLenum , GLint *))Os::getExtendedProcAddress("glGetLightiv");  
    return _glGetLightiv(light , pname , params);  
 }  
   
1090  void stub_glGetMapAttribParameterfvNV(GLenum target, GLuint index, GLenum pname, GLfloat *params);  void stub_glGetMapAttribParameterfvNV(GLenum target, GLuint index, GLenum pname, GLfloat *params);
1091  void (* _glGetMapAttribParameterfvNV)(GLenum target, GLuint index, GLenum pname, GLfloat *params) = &stub_glGetMapAttribParameterfvNV;  void (* _glGetMapAttribParameterfvNV)(GLenum target, GLuint index, GLenum pname, GLfloat *params) = &stub_glGetMapAttribParameterfvNV;
1092    
# Line 2363  void stub_glGetMapParameterivNV(GLenum t Line 1142  void stub_glGetMapParameterivNV(GLenum t
1142     return _glGetMapParameterivNV(target , pname , params);     return _glGetMapParameterivNV(target , pname , params);
1143  }  }
1144    
 void stub_glGetMapdv(GLenum target, GLenum query, GLdouble *v);  
 void (* _glGetMapdv)(GLenum target, GLenum query, GLdouble *v) = &stub_glGetMapdv;  
   
 void stub_glGetMapdv(GLenum target, GLenum query, GLdouble *v) {  
    if (Os::getExtendedProcAddress("glGetMapdv") == NULL) {  
       return GL_kludge_error_void("glGetMapdv");  
    }  
    _glGetMapdv = (void (*)(GLenum , GLenum , GLdouble *))Os::getExtendedProcAddress("glGetMapdv");  
    return _glGetMapdv(target , query , v);  
 }  
   
 void stub_glGetMapfv(GLenum target, GLenum query, GLfloat *v);  
 void (* _glGetMapfv)(GLenum target, GLenum query, GLfloat *v) = &stub_glGetMapfv;  
   
 void stub_glGetMapfv(GLenum target, GLenum query, GLfloat *v) {  
    if (Os::getExtendedProcAddress("glGetMapfv") == NULL) {  
       return GL_kludge_error_void("glGetMapfv");  
    }  
    _glGetMapfv = (void (*)(GLenum , GLenum , GLfloat *))Os::getExtendedProcAddress("glGetMapfv");  
    return _glGetMapfv(target , query , v);  
 }  
   
 void stub_glGetMapiv(GLenum target, GLenum query, GLint *v);  
 void (* _glGetMapiv)(GLenum target, GLenum query, GLint *v) = &stub_glGetMapiv;  
   
 void stub_glGetMapiv(GLenum target, GLenum query, GLint *v) {  
    if (Os::getExtendedProcAddress("glGetMapiv") == NULL) {  
       return GL_kludge_error_void("glGetMapiv");  
    }  
    _glGetMapiv = (void (*)(GLenum , GLenum , GLint *))Os::getExtendedProcAddress("glGetMapiv");  
    return _glGetMapiv(target , query , v);  
 }  
   
 void stub_glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params);  
 void (* _glGetMaterialfv)(GLenum face, GLenum pname, GLfloat *params) = &stub_glGetMaterialfv;  
   
 void stub_glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params) {  
    if (Os::getExtendedProcAddress("glGetMaterialfv") == NULL) {  
       return GL_kludge_error_void("glGetMaterialfv");  
    }  
    _glGetMaterialfv = (void (*)(GLenum , GLenum , GLfloat *))Os::getExtendedProcAddress("glGetMaterialfv");  
    return _glGetMaterialfv(face , pname , params);  
 }  
   
 void stub_glGetMaterialiv(GLenum face, GLenum pname, GLint *params);  
 void (* _glGetMaterialiv)(GLenum face, GLenum pname, GLint *params) = &stub_glGetMaterialiv;  
   
 void stub_glGetMaterialiv(GLenum face, GLenum pname, GLint *params) {  
    if (Os::getExtendedProcAddress("glGetMaterialiv") == NULL) {  
       return GL_kludge_error_void("glGetMaterialiv");  
    }  
    _glGetMaterialiv = (void (*)(GLenum , GLenum , GLint *))Os::getExtendedProcAddress("glGetMaterialiv");  
    return _glGetMaterialiv(face , pname , params);  
 }  
   
1145  void stub_glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);  void stub_glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
1146  void (* _glGetMinmax)(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values) = &stub_glGetMinmax;  void (* _glGetMinmax)(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values) = &stub_glGetMinmax;
1147    
# Line 2473  void stub_glGetOcclusionQueryuivNV(GLuin Line 1197  void stub_glGetOcclusionQueryuivNV(GLuin
1197     return _glGetOcclusionQueryuivNV(id , pname , params);     return _glGetOcclusionQueryuivNV(id , pname , params);
1198  }  }
1199    
 void stub_glGetPixelMapfv(GLenum map, GLfloat *values);  
 void (* _glGetPixelMapfv)(GLenum map, GLfloat *values) = &stub_glGetPixelMapfv;  
   
 void stub_glGetPixelMapfv(GLenum map, GLfloat *values) {  
    if (Os::getExtendedProcAddress("glGetPixelMapfv") == NULL) {  
       return GL_kludge_error_void("glGetPixelMapfv");  
    }  
    _glGetPixelMapfv = (void (*)(GLenum , GLfloat *))Os::getExtendedProcAddress("glGetPixelMapfv");  
    return _glGetPixelMapfv(map , values);  
 }  
   
 void stub_glGetPixelMapuiv(GLenum map, GLuint *values);  
 void (* _glGetPixelMapuiv)(GLenum map, GLuint *values) = &stub_glGetPixelMapuiv;  
   
 void stub_glGetPixelMapuiv(GLenum map, GLuint *values) {  
    if (Os::getExtendedProcAddress("glGetPixelMapuiv") == NULL) {  
       return GL_kludge_error_void("glGetPixelMapuiv");  
    }  
    _glGetPixelMapuiv = (void (*)(GLenum , GLuint *))Os::getExtendedProcAddress("glGetPixelMapuiv");  
    return _glGetPixelMapuiv(map , values);  
 }  
   
 void stub_glGetPixelMapusv(GLenum map, GLushort *values);  
 void (* _glGetPixelMapusv)(GLenum map, GLushort *values) = &stub_glGetPixelMapusv;  
   
 void stub_glGetPixelMapusv(GLenum map, GLushort *values) {  
    if (Os::getExtendedProcAddress("glGetPixelMapusv") == NULL) {  
       return GL_kludge_error_void("glGetPixelMapusv");  
    }  
    _glGetPixelMapusv = (void (*)(GLenum , GLushort *))Os::getExtendedProcAddress("glGetPixelMapusv");  
    return _glGetPixelMapusv(map , values);  
 }  
   
 void stub_glGetPointerv(GLenum pname, GLvoid* *params);  
 void (* _glGetPointerv)(GLenum pname, GLvoid* *params) = &stub_glGetPointerv;  
   
 void stub_glGetPointerv(GLenum pname, GLvoid* *params) {  
    if (Os::getExtendedProcAddress("glGetPointerv") == NULL) {  
       return GL_kludge_error_void("glGetPointerv");  
    }  
    _glGetPointerv = (void (*)(GLenum , GLvoid * *))Os::getExtendedProcAddress("glGetPointerv");  
    return _glGetPointerv(pname , params);  
 }  
   
1200  void stub_glGetPointervEXT(GLenum pname, GLvoid* *params);  void stub_glGetPointervEXT(GLenum pname, GLvoid* *params);
1201  void (* _glGetPointervEXT)(GLenum pname, GLvoid* *params) = &stub_glGetPointervEXT;  void (* _glGetPointervEXT)(GLenum pname, GLvoid* *params) = &stub_glGetPointervEXT;
1202    
# Line 2528  void stub_glGetPointervEXT(GLenum pname, Line 1208  void stub_glGetPointervEXT(GLenum pname,
1208     return _glGetPointervEXT(pname , params);     return _glGetPointervEXT(pname , params);
1209  }  }
1210    
 void stub_glGetPolygonStipple(GLubyte *mask);  
 void (* _glGetPolygonStipple)(GLubyte *mask) = &stub_glGetPolygonStipple;  
   
 void stub_glGetPolygonStipple(GLubyte *mask) {  
    if (Os::getExtendedProcAddress("glGetPolygonStipple") == NULL) {  
       return GL_kludge_error_void("glGetPolygonStipple");  
    }  
    _glGetPolygonStipple = (void (*)(GLubyte *))Os::getExtendedProcAddress("glGetPolygonStipple");  
    return _glGetPolygonStipple(mask);  
 }  
   
1211  void stub_glGetProgramLocalParameterdvNV(GLenum target, GLsizei len, const GLubyte *name, GLdouble *params);  void stub_glGetProgramLocalParameterdvNV(GLenum target, GLsizei len, const GLubyte *name, GLdouble *params);
1212  void (* _glGetProgramLocalParameterdvNV)(GLenum target, GLsizei len, const GLubyte *name, GLdouble *params) = &stub_glGetProgramLocalParameterdvNV;  void (* _glGetProgramLocalParameterdvNV)(GLenum target, GLsizei len, const GLubyte *name, GLdouble *params) = &stub_glGetProgramLocalParameterdvNV;
1213    
# Line 2638  void stub_glGetSeparableFilter(GLenum ta Line 1307  void stub_glGetSeparableFilter(GLenum ta
1307     return _glGetSeparableFilter(target , format , type , row , column , span);     return _glGetSeparableFilter(target , format , type , row , column , span);
1308  }  }
1309    
 void stub_glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params);  
 void (* _glGetTexEnvfv)(GLenum target, GLenum pname, GLfloat *params) = &stub_glGetTexEnvfv;  
   
 void stub_glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params) {  
    if (Os::getExtendedProcAddress("glGetTexEnvfv") == NULL) {  
       return GL_kludge_error_void("glGetTexEnvfv");  
    }  
    _glGetTexEnvfv = (void (*)(GLenum , GLenum , GLfloat *))Os::getExtendedProcAddress("glGetTexEnvfv");  
    return _glGetTexEnvfv(target , pname , params);  
 }  
   
 void stub_glGetTexEnviv(GLenum target, GLenum pname, GLint *params);  
 void (* _glGetTexEnviv)(GLenum target, GLenum pname, GLint *params) = &stub_glGetTexEnviv;  
   
 void stub_glGetTexEnviv(GLenum target, GLenum pname, GLint *params) {  
    if (Os::getExtendedProcAddress("glGetTexEnviv") == NULL) {  
       return GL_kludge_error_void("glGetTexEnviv");  
    }  
    _glGetTexEnviv = (void (*)(GLenum , GLenum , GLint *))Os::getExtendedProcAddress("glGetTexEnviv");  
    return _glGetTexEnviv(target , pname , params);  
 }  
   
 void stub_glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params);  
 void (* _glGetTexGendv)(GLenum coord, GLenum pname, GLdouble *params) = &stub_glGetTexGendv;  
   
 void stub_glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params) {  
    if (Os::getExtendedProcAddress("glGetTexGendv") == NULL) {  
       return GL_kludge_error_void("glGetTexGendv");  
    }  
    _glGetTexGendv = (void (*)(GLenum , GLenum , GLdouble *))Os::getExtendedProcAddress("glGetTexGendv");  
    return _glGetTexGendv(coord , pname , params);  
 }  
   
 void stub_glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params);  
 void (* _glGetTexGenfv)(GLenum coord, GLenum pname, GLfloat *params) = &stub_glGetTexGenfv;  
   
 void stub_glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params) {  
    if (Os::getExtendedProcAddress("glGetTexGenfv") == NULL) {  
       return GL_kludge_error_void("glGetTexGenfv");  
    }  
    _glGetTexGenfv = (void (*)(GLenum , GLenum , GLfloat *))Os::getExtendedProcAddress("glGetTexGenfv");  
    return _glGetTexGenfv(coord , pname , params);  
 }  
   
 void stub_glGetTexGeniv(GLenum coord, GLenum pname, GLint *params);  
 void (* _glGetTexGeniv)(GLenum coord, GLenum pname, GLint *params) = &stub_glGetTexGeniv;  
   
 void stub_glGetTexGeniv(GLenum coord, GLenum pname, GLint *params) {  
    if (Os::getExtendedProcAddress("glGetTexGeniv") == NULL) {  
       return GL_kludge_error_void("glGetTexGeniv");  
    }  
    _glGetTexGeniv = (void (*)(GLenum , GLenum , GLint *))Os::getExtendedProcAddress("glGetTexGeniv");  
    return _glGetTexGeniv(coord , pname , params);  
 }  
   
 void stub_glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);  
 void (* _glGetTexImage)(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels) = &stub_glGetTexImage;  
   
 void stub_glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels) {  
    if (Os::getExtendedProcAddress("glGetTexImage") == NULL) {  
       return GL_kludge_error_void("glGetTexImage");  
    }  
    _glGetTexImage = (void (*)(GLenum , GLint , GLenum , GLenum , GLvoid *))Os::getExtendedProcAddress("glGetTexImage");  
    return _glGetTexImage(target , level , format , type , pixels);  
 }  
   
 void stub_glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params);  
 void (* _glGetTexLevelParameterfv)(GLenum target, GLint level, GLenum pname, GLfloat *params) = &stub_glGetTexLevelParameterfv;  
   
 void stub_glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params) {  
    if (Os::getExtendedProcAddress("glGetTexLevelParameterfv") == NULL) {  
       return GL_kludge_error_void("glGetTexLevelParameterfv");  
    }  
    _glGetTexLevelParameterfv = (void (*)(GLenum , GLint , GLenum , GLfloat *))Os::getExtendedProcAddress("glGetTexLevelParameterfv");  
    return _glGetTexLevelParameterfv(target , level , pname , params);  
 }  
   
 void stub_glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params);  
 void (* _glGetTexLevelParameteriv)(GLenum target, GLint level, GLenum pname, GLint *params) = &stub_glGetTexLevelParameteriv;  
   
 void stub_glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params) {  
    if (Os::getExtendedProcAddress("glGetTexLevelParameteriv") == NULL) {  
       return GL_kludge_error_void("glGetTexLevelParameteriv");  
    }  
    _glGetTexLevelParameteriv = (void (*)(GLenum , GLint , GLenum , GLint *))Os::getExtendedProcAddress("glGetTexLevelParameteriv");  
    return _glGetTexLevelParameteriv(target , level , pname , params);  
 }  
   
 void stub_glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params);  
 void (* _glGetTexParameterfv)(GLenum target, GLenum pname, GLfloat *params) = &stub_glGetTexParameterfv;  
   
 void stub_glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params) {  
    if (Os::getExtendedProcAddress("glGetTexParameterfv") == NULL) {  
       return GL_kludge_error_void("glGetTexParameterfv");  
    }  
    _glGetTexParameterfv = (void (*)(GLenum , GLenum , GLfloat *))Os::getExtendedProcAddress("glGetTexParameterfv");  
    return _glGetTexParameterfv(target , pname , params);  
 }  
   
 void stub_glGetTexParameteriv(GLenum target, GLenum pname, GLint *params);  
 void (* _glGetTexParameteriv)(GLenum target, GLenum pname, GLint *params) = &stub_glGetTexParameteriv;  
   
 void stub_glGetTexParameteriv(GLenum target, GLenum pname, GLint *params) {  
    if (Os::getExtendedProcAddress("glGetTexParameteriv") == NULL) {  
       return GL_kludge_error_void("glGetTexParameteriv");  
    }  
    _glGetTexParameteriv = (void (*)(GLenum , GLenum , GLint *))Os::getExtendedProcAddress("glGetTexParameteriv");  
    return _glGetTexParameteriv(target , pname , params);  
 }  
   
1310  void stub_glGetTrackMatrixivNV(GLenum target, GLuint address, GLenum pname, GLint *params);  void stub_glGetTrackMatrixivNV(GLenum target, GLuint address, GLenum pname, GLint *params);
1311  void (* _glGetTrackMatrixivNV)(GLenum target, GLuint address, GLenum pname, GLint *params) = &stub_glGetTrackMatrixivNV;  void (* _glGetTrackMatrixivNV)(GLenum target, GLuint address, GLenum pname, GLint *params) = &stub_glGetTrackMatrixivNV;
1312    
# Line 2803  void stub_glGetVertexAttribivNV(GLuint i Line 1362  void stub_glGetVertexAttribivNV(GLuint i
1362     return _glGetVertexAttribivNV(index , pname , params);     return _glGetVertexAttribivNV(index , pname , params);
1363  }  }
1364    
 void stub_glHint(GLenum target, GLenum mode);  
 void (* _glHint)(GLenum target, GLenum mode) = &stub_glHint;  
   
 void stub_glHint(GLenum target, GLenum mode) {  
    if (Os::getExtendedProcAddress("glHint") == NULL) {  
       return GL_kludge_error_void("glHint");  
    }  
    _glHint = (void (*)(GLenum , GLenum))Os::getExtendedProcAddress("glHint");  
    return _glHint(target , mode);  
 }  
   
1365  void stub_glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink);  void stub_glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink);
1366  void (* _glHistogram)(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink) = &stub_glHistogram;  void (* _glHistogram)(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink) = &stub_glHistogram;
1367    
# Line 2825  void stub_glHistogram(GLenum target, GLs Line 1373  void stub_glHistogram(GLenum target, GLs
1373     return _glHistogram(target , width , internalformat , sink);     return _glHistogram(target , width , internalformat , sink);
1374  }  }
1375    
 void stub_glIndexMask(GLuint mask);  
 void (* _glIndexMask)(GLuint mask) = &stub_glIndexMask;  
   
 void stub_glIndexMask(GLuint mask) {  
    if (Os::getExtendedProcAddress("glIndexMask") == NULL) {  
       return GL_kludge_error_void("glIndexMask");  
    }  
    _glIndexMask = (void (*)(GLuint))Os::getExtendedProcAddress("glIndexMask");  
    return _glIndexMask(mask);  
 }  
   
 void stub_glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer);  
 void (* _glIndexPointer)(GLenum type, GLsizei stride, const GLvoid *pointer) = &stub_glIndexPointer;  
   
 void stub_glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer) {  
    if (Os::getExtendedProcAddress("glIndexPointer") == NULL) {  
       return GL_kludge_error_void("glIndexPointer");  
    }  
    _glIndexPointer = (void (*)(GLenum , GLsizei , const GLvoid *))Os::getExtendedProcAddress("glIndexPointer");  
    return _glIndexPointer(type , stride , pointer);  
 }  
   
1376  void stub_glIndexPointerEXT(GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer);  void stub_glIndexPointerEXT(GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer);
1377  void (* _glIndexPointerEXT)(GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer) = &stub_glIndexPointerEXT;  void (* _glIndexPointerEXT)(GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer) = &stub_glIndexPointerEXT;
1378    
# Line 2858  void stub_glIndexPointerEXT(GLenum type, Line 1384  void stub_glIndexPointerEXT(GLenum type,
1384     return _glIndexPointerEXT(type , stride , count , pointer);     return _glIndexPointerEXT(type , stride , count , pointer);
1385  }  }
1386    
 void stub_glIndexd(GLdouble c);  
 void (* _glIndexd)(GLdouble c) = &stub_glIndexd;  
   
 void stub_glIndexd(GLdouble c) {  
    if (Os::getExtendedProcAddress("glIndexd") == NULL) {  
       return GL_kludge_error_void("glIndexd");  
    }  
    _glIndexd = (void (*)(GLdouble))Os::getExtendedProcAddress("glIndexd");  
    return _glIndexd(c);  
 }  
   
 void stub_glIndexdv(const GLdouble *c);  
 void (* _glIndexdv)(const GLdouble *c) = &stub_glIndexdv;  
   
 void stub_glIndexdv(const GLdouble *c) {  
    if (Os::getExtendedProcAddress("glIndexdv") == NULL) {  
       return GL_kludge_error_void("glIndexdv");  
    }  
    _glIndexdv = (void (*)(const GLdouble *))Os::getExtendedProcAddress("glIndexdv");  
    return _glIndexdv(c);  
 }  
   
 void stub_glIndexf(GLfloat c);  
 void (* _glIndexf)(GLfloat c) = &stub_glIndexf;  
   
 void stub_glIndexf(GLfloat c) {  
    if (Os::getExtendedProcAddress("glIndexf") == NULL) {  
       return GL_kludge_error_void("glIndexf");  
    }  
    _glIndexf = (void (*)(GLfloat))Os::getExtendedProcAddress("glIndexf");  
    return _glIndexf(c);  
 }  
   
 void stub_glIndexfv(const GLfloat *c);  
 void (* _glIndexfv)(const GLfloat *c) = &stub_glIndexfv;  
   
 void stub_glIndexfv(const GLfloat *c) {  
    if (Os::getExtendedProcAddress("glIndexfv") == NULL) {  
       return GL_kludge_error_void("glIndexfv");  
    }  
    _glIndexfv = (void (*)(const GLfloat *))Os::getExtendedProcAddress("glIndexfv");  
    return _glIndexfv(c);  
 }  
   
 void stub_glIndexi(GLint c);  
 void (* _glIndexi)(GLint c) = &stub_glIndexi;  
   
 void stub_glIndexi(GLint c) {  
    if (Os::getExtendedProcAddress("glIndexi") == NULL) {  
       return GL_kludge_error_void("glIndexi");  
    }  
    _glIndexi = (void (*)(GLint))Os::getExtendedProcAddress("glIndexi");  
    return _glIndexi(c);  
 }  
   
 void stub_glIndexiv(const GLint *c);  
 void (* _glIndexiv)(const GLint *c) = &stub_glIndexiv;  
   
 void stub_glIndexiv(const GLint *c) {  
    if (Os::getExtendedProcAddress("glIndexiv") == NULL) {  
       return GL_kludge_error_void("glIndexiv");  
    }  
    _glIndexiv = (void (*)(const GLint *))Os::getExtendedProcAddress("glIndexiv");  
    return _glIndexiv(c);  
 }  
   
 void stub_glIndexs(GLshort c);  
 void (* _glIndexs)(GLshort c) = &stub_glIndexs;  
   
 void stub_glIndexs(GLshort c) {  
    if (Os::getExtendedProcAddress("glIndexs") == NULL) {  
       return GL_kludge_error_void("glIndexs");  
    }  
    _glIndexs = (void (*)(GLshort))Os::getExtendedProcAddress("glIndexs");  
    return _glIndexs(c);  
 }  
   
 void stub_glIndexsv(const GLshort *c);  
 void (* _glIndexsv)(const GLshort *c) = &stub_glIndexsv;  
   
 void stub_glIndexsv(const GLshort *c) {  
    if (Os::getExtendedProcAddress("glIndexsv") == NULL) {  
       return GL_kludge_error_void("glIndexsv");  
    }  
    _glIndexsv = (void (*)(const GLshort *))Os::getExtendedProcAddress("glIndexsv");  
    return _glIndexsv(c);  
 }  
   
 void stub_glIndexub(GLubyte c);  
 void (* _glIndexub)(GLubyte c) = &stub_glIndexub;  
   
 void stub_glIndexub(GLubyte c) {  
    if (Os::getExtendedProcAddress("glIndexub") == NULL) {  
       return GL_kludge_error_void("glIndexub");  
    }  
    _glIndexub = (void (*)(GLubyte))Os::getExtendedProcAddress("glIndexub");  
    return _glIndexub(c);  
 }  
   
 void stub_glIndexubv(const GLubyte *c);  
 void (* _glIndexubv)(const GLubyte *c) = &stub_glIndexubv;  
   
 void stub_glIndexubv(const GLubyte *c) {  
    if (Os::getExtendedProcAddress("glIndexubv") == NULL) {  
       return GL_kludge_error_void("glIndexubv");  
    }  
    _glIndexubv = (void (*)(const GLubyte *))Os::getExtendedProcAddress("glIndexubv");  
    return _glIndexubv(c);  
 }  
   
 void stub_glInitNames(void);  
 void (* _glInitNames)(void) = &stub_glInitNames;  
   
 void stub_glInitNames(void) {  
    if (Os::getExtendedProcAddress("glInitNames") == NULL) {  
       return GL_kludge_error_void("glInitNames");  
    }  
    _glInitNames = (void (*)())Os::getExtendedProcAddress("glInitNames");  
    return _glInitNames();  
 }  
   
 void stub_glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer);  
 void (* _glInterleavedArrays)(GLenum format, GLsizei stride, const GLvoid *pointer) = &stub_glInterleavedArrays;  
   
 void stub_glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer) {  
    if (Os::getExtendedProcAddress("glInterleavedArrays") == NULL) {  
       return GL_kludge_error_void("glInterleavedArrays");  
    }  
    _glInterleavedArrays = (void (*)(GLenum , GLsizei , const GLvoid *))Os::getExtendedProcAddress("glInterleavedArrays");  
    return _glInterleavedArrays(format , stride , pointer);  
 }  
   
 GLboolean stub_glIsEnabled(GLenum cap);  
 GLboolean (* _glIsEnabled)(GLenum cap) = &stub_glIsEnabled;  
   
 GLboolean stub_glIsEnabled(GLenum cap) {  
    if (Os::getExtendedProcAddress("glIsEnabled") == NULL) {  
       return GL_kludge_error_GLboolean("glIsEnabled");  
    }  
    _glIsEnabled = (GLboolean (*)(GLenum))Os::getExtendedProcAddress("glIsEnabled");  
    return _glIsEnabled(cap);  
 }  
   
1387  GLboolean stub_glIsFenceNV(GLuint fence);  GLboolean stub_glIsFenceNV(GLuint fence);
1388  GLboolean (* _glIsFenceNV)(GLuint fence) = &stub_glIsFenceNV;  GLboolean (* _glIsFenceNV)(GLuint fence) = &stub_glIsFenceNV;
1389    
# Line 3012  GLboolean stub_glIsFenceNV(GLuint fence) Line 1395  GLboolean stub_glIsFenceNV(GLuint fence)
1395     return _glIsFenceNV(fence);     return _glIsFenceNV(fence);
1396  }  }
1397    
 GLboolean stub_glIsList(GLuint list);  
 GLboolean (* _glIsList)(GLuint list) = &stub_glIsList;  
   
 GLboolean stub_glIsList(GLuint list) {  
    if (Os::getExtendedProcAddress("glIsList") == NULL) {  
       return GL_kludge_error_GLboolean("glIsList");  
    }  
    _glIsList = (GLboolean (*)(GLuint))Os::getExtendedProcAddress("glIsList");  
    return _glIsList(list);  
 }  
   
1398  GLboolean stub_glIsOcclusionQueryNV(GLuint id);  GLboolean stub_glIsOcclusionQueryNV(GLuint id);
1399  GLboolean (* _glIsOcclusionQueryNV)(GLuint id) = &stub_glIsOcclusionQueryNV;  GLboolean (* _glIsOcclusionQueryNV)(GLuint id) = &stub_glIsOcclusionQueryNV;
1400    
# Line 3045  GLboolean stub_glIsProgramNV(GLuint id) Line 1417  GLboolean stub_glIsProgramNV(GLuint id)
1417     return _glIsProgramNV(id);     return _glIsProgramNV(id);
1418  }  }
1419    
 GLboolean stub_glIsTexture(GLuint texture);  
 GLboolean (* _glIsTexture)(GLuint texture) = &stub_glIsTexture;  
   
 GLboolean stub_glIsTexture(GLuint texture) {  
    if (Os::getExtendedProcAddress("glIsTexture") == NULL) {  
       return GL_kludge_error_GLboolean("glIsTexture");  
    }  
    _glIsTexture = (GLboolean (*)(GLuint))Os::getExtendedProcAddress("glIsTexture");  
    return _glIsTexture(texture);  
 }  
   
1420  GLboolean stub_glIsTextureEXT(GLuint texture);  GLboolean stub_glIsTextureEXT(GLuint texture);
1421  GLboolean (* _glIsTextureEXT)(GLuint texture) = &stub_glIsTextureEXT;  GLboolean (* _glIsTextureEXT)(GLuint texture) = &stub_glIsTextureEXT;
1422    
# Line 3067  GLboolean stub_glIsTextureEXT(GLuint tex Line 1428  GLboolean stub_glIsTextureEXT(GLuint tex
1428     return _glIsTextureEXT(texture);     return _glIsTextureEXT(texture);
1429  }  }
1430    
 void stub_glLightModelf(GLenum pname, GLfloat param);  
 void (* _glLightModelf)(GLenum pname, GLfloat param) = &stub_glLightModelf;  
   
 void stub_glLightModelf(GLenum pname, GLfloat param) {  
    if (Os::getExtendedProcAddress("glLightModelf") == NULL) {  
       return GL_kludge_error_void("glLightModelf");  
    }  
    _glLightModelf = (void (*)(GLenum , GLfloat))Os::getExtendedProcAddress("glLightModelf");  
    return _glLightModelf(pname , param);  
 }  
   
 void stub_glLightModelfv(GLenum pname, const GLfloat *params);  
 void (* _glLightModelfv)(GLenum pname, const GLfloat *params) = &stub_glLightModelfv;  
   
 void stub_glLightModelfv(GLenum pname, const GLfloat *params) {  
    if (Os::getExtendedProcAddress("glLightModelfv") == NULL) {  
       return GL_kludge_error_void("glLightModelfv");  
    }  
    _glLightModelfv = (void (*)(GLenum , const GLfloat *))Os::getExtendedProcAddress("glLightModelfv");  
    return _glLightModelfv(pname , params);  
 }  
   
 void stub_glLightModeli(GLenum pname, GLint param);  
 void (* _glLightModeli)(GLenum pname, GLint param) = &stub_glLightModeli;  
   
 void stub_glLightModeli(GLenum pname, GLint param) {  
    if (Os::getExtendedProcAddress("glLightModeli") == NULL) {  
       return GL_kludge_error_void("glLightModeli");  
    }  
    _glLightModeli = (void (*)(GLenum , GLint))Os::getExtendedProcAddress("glLightModeli");  
    return _glLightModeli(pname , param);  
 }  
   
 void stub_glLightModeliv(GLenum pname, const GLint *params);  
 void (* _glLightModeliv)(GLenum pname, const GLint *params) = &stub_glLightModeliv;  
   
 void stub_glLightModeliv(GLenum pname, const GLint *params) {  
    if (Os::getExtendedProcAddress("glLightModeliv") == NULL) {  
       return GL_kludge_error_void("glLightModeliv");  
    }  
    _glLightModeliv = (void (*)(GLenum , const GLint *))Os::getExtendedProcAddress("glLightModeliv");  
    return _glLightModeliv(pname , params);  
 }  
   
 void stub_glLightf(GLenum light, GLenum pname, GLfloat param);  
 void (* _glLightf)(GLenum light, GLenum pname, GLfloat param) = &stub_glLightf;  
   
 void stub_glLightf(GLenum light, GLenum pname, GLfloat param) {  
    if (Os::getExtendedProcAddress("glLightf") == NULL) {  
       return GL_kludge_error_void("glLightf");  
    }  
    _glLightf = (void (*)(GLenum , GLenum , GLfloat))Os::getExtendedProcAddress("glLightf");  
    return _glLightf(light , pname , param);  
 }  
   
 void stub_glLightfv(GLenum light, GLenum pname, const GLfloat *params);  
 void (* _glLightfv)(GLenum light, GLenum pname, const GLfloat *params) = &stub_glLightfv;  
   
 void stub_glLightfv(GLenum light, GLenum pname, const GLfloat *params) {  
    if (Os::getExtendedProcAddress("glLightfv") == NULL) {  
       return GL_kludge_error_void("glLightfv");  
    }  
    _glLightfv = (void (*)(GLenum , GLenum , const GLfloat *))Os::getExtendedProcAddress("glLightfv");  
    return _glLightfv(light , pname , params);  
 }  
   
 void stub_glLighti(GLenum light, GLenum pname, GLint param);  
 void (* _glLighti)(GLenum light, GLenum pname, GLint param) = &stub_glLighti;  
   
 void stub_glLighti(GLenum light, GLenum pname, GLint param) {  
    if (Os::getExtendedProcAddress("glLighti") == NULL) {  
       return GL_kludge_error_void("glLighti");  
    }  
    _glLighti = (void (*)(GLenum , GLenum , GLint))Os::getExtendedProcAddress("glLighti");  
    return _glLighti(light , pname , param);  
 }  
   
 void stub_glLightiv(GLenum light, GLenum pname, const GLint *params);  
 void (* _glLightiv)(GLenum light, GLenum pname, const GLint *params) = &stub_glLightiv;  
   
 void stub_glLightiv(GLenum light, GLenum pname, const GLint *params) {  
    if (Os::getExtendedProcAddress("glLightiv") == NULL) {  
       return GL_kludge_error_void("glLightiv");  
    }  
    _glLightiv = (void (*)(GLenum , GLenum , const GLint *))Os::getExtendedProcAddress("glLightiv");  
    return _glLightiv(light , pname , params);  
 }  
   
 void stub_glLineStipple(GLint factor, GLushort pattern);  
 void (* _glLineStipple)(GLint factor, GLushort pattern) = &stub_glLineStipple;  
   
 void stub_glLineStipple(GLint factor, GLushort pattern) {  
    if (Os::getExtendedProcAddress("glLineStipple") == NULL) {  
       return GL_kludge_error_void("glLineStipple");  
    }  
    _glLineStipple = (void (*)(GLint , GLushort))Os::getExtendedProcAddress("glLineStipple");  
    return _glLineStipple(factor , pattern);  
 }  
   
 void stub_glLineWidth(GLfloat width);  
 void (* _glLineWidth)(GLfloat width) = &stub_glLineWidth;  
   
 void stub_glLineWidth(GLfloat width) {  
    if (Os::getExtendedProcAddress("glLineWidth") == NULL) {  
       return GL_kludge_error_void("glLineWidth");  
    }  
    _glLineWidth = (void (*)(GLfloat))Os::getExtendedProcAddress("glLineWidth");  
    return _glLineWidth(width);  
 }  
   
 void stub_glListBase(GLuint base);  
 void (* _glListBase)(GLuint base) = &stub_glListBase;  
   
 void stub_glListBase(GLuint base) {  
    if (Os::getExtendedProcAddress("glListBase") == NULL) {  
       return GL_kludge_error_void("glListBase");  
    }  
    _glListBase = (void (*)(GLuint))Os::getExtendedProcAddress("glListBase");  
    return _glListBase(base);  
 }  
   
 void stub_glLoadIdentity(void);  
 void (* _glLoadIdentity)(void) = &stub_glLoadIdentity;  
   
 void stub_glLoadIdentity(void) {  
    if (Os::getExtendedProcAddress("glLoadIdentity") == NULL) {  
       return GL_kludge_error_void("glLoadIdentity");  
    }  
    _glLoadIdentity = (void (*)())Os::getExtendedProcAddress("glLoadIdentity");  
    return _glLoadIdentity();  
 }  
   
 void stub_glLoadMatrixd(const GLdouble *m);  
 void (* _glLoadMatrixd)(const GLdouble *m) = &stub_glLoadMatrixd;  
   
 void stub_glLoadMatrixd(const GLdouble *m) {  
    if (Os::getExtendedProcAddress("glLoadMatrixd") == NULL) {  
       return GL_kludge_error_void("glLoadMatrixd");  
    }  
    _glLoadMatrixd = (void (*)(const GLdouble *))Os::getExtendedProcAddress("glLoadMatrixd");  
    return _glLoadMatrixd(m);  
 }  
   
 void stub_glLoadMatrixf(const GLfloat *m);  
 void (* _glLoadMatrixf)(const GLfloat *m) = &stub_glLoadMatrixf;  
   
 void stub_glLoadMatrixf(const GLfloat *m) {  
    if (Os::getExtendedProcAddress("glLoadMatrixf") == NULL) {  
       return GL_kludge_error_void("glLoadMatrixf");  
    }  
    _glLoadMatrixf = (void (*)(const GLfloat *))Os::getExtendedProcAddress("glLoadMatrixf");  
    return _glLoadMatrixf(m);  
 }  
   
 void stub_glLoadName(GLuint name);  
 void (* _glLoadName)(GLuint name) = &stub_glLoadName;  
   
 void stub_glLoadName(GLuint name) {  
    if (Os::getExtendedProcAddress("glLoadName") == NULL) {  
       return GL_kludge_error_void("glLoadName");  
    }  
    _glLoadName = (void (*)(GLuint))Os::getExtendedProcAddress("glLoadName");  
    return _glLoadName(name);  
 }  
   
1431  void stub_glLoadProgramNV(GLenum target, GLuint id, GLsizei len, const GLubyte *program);  void stub_glLoadProgramNV(GLenum target, GLuint id, GLsizei len, const GLubyte *program);
1432  void (* _glLoadProgramNV)(GLenum target, GLuint id, GLsizei len, const GLubyte *program) = &stub_glLoadProgramNV;  void (* _glLoadProgramNV)(GLenum target, GLuint id, GLsizei len, const GLubyte *program) = &stub_glLoadProgramNV;
1433    
# Line 3298  void stub_glLockArraysEXT(GLint first, G Line 1494  void stub_glLockArraysEXT(GLint first, G
1494     return _glLockArraysEXT(first , count);     return _glLockArraysEXT(first , count);
1495  }  }
1496    
 void stub_glLogicOp(GLenum opcode);  
 void (* _glLogicOp)(GLenum opcode) = &stub_glLogicOp;  
   
 void stub_glLogicOp(GLenum opcode) {  
    if (Os::getExtendedProcAddress("glLogicOp") == NULL) {  
       return GL_kludge_error_void("glLogicOp");  
    }  
    _glLogicOp = (void (*)(GLenum))Os::getExtendedProcAddress("glLogicOp");  
    return _glLogicOp(opcode);  
 }  
   
 void stub_glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);  
 void (* _glMap1d)(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points) = &stub_glMap1d;  
   
 void stub_glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points) {  
    if (Os::getExtendedProcAddress("glMap1d") == NULL) {  
       return GL_kludge_error_void("glMap1d");  
    }  
    _glMap1d = (void (*)(GLenum , GLdouble , GLdouble , GLint , GLint , const GLdouble *))Os::getExtendedProcAddress("glMap1d");  
    return _glMap1d(target , u1 , u2 , stride , order , points);  
 }  
   
 void stub_glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);  
 void (* _glMap1f)(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points) = &stub_glMap1f;  
   
 void stub_glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points) {  
    if (Os::getExtendedProcAddress("glMap1f") == NULL) {  
       return GL_kludge_error_void("glMap1f");  
    }  
    _glMap1f = (void (*)(GLenum , GLfloat , GLfloat , GLint , GLint , const GLfloat *))Os::getExtendedProcAddress("glMap1f");  
    return _glMap1f(target , u1 , u2 , stride , order , points);  
 }  
   
 void stub_glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);  
 void (* _glMap2d)(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points) = &stub_glMap2d;  
   
 void stub_glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points) {  
    if (Os::getExtendedProcAddress("glMap2d") == NULL) {  
       return GL_kludge_error_void("glMap2d");  
    }  
    _glMap2d = (void (*)(GLenum , GLdouble , GLdouble , GLint , GLint , GLdouble , GLdouble , GLint , GLint , const GLdouble *))Os::getExtendedProcAddress("glMap2d");  
    return _glMap2d(target , u1 , u2 , ustride , uorder , v1 , v2 , vstride , vorder , points);  
 }  
   
 void stub_glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);  
 void (* _glMap2f)(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points) = &stub_glMap2f;  
   
 void stub_glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points) {  
    if (Os::getExtendedProcAddress("glMap2f") == NULL) {  
       return GL_kludge_error_void("glMap2f");  
    }  
    _glMap2f = (void (*)(GLenum , GLfloat , GLfloat , GLint , GLint , GLfloat , GLfloat , GLint , GLint , const GLfloat *))Os::getExtendedProcAddress("glMap2f");  
    return _glMap2f(target , u1 , u2 , ustride , uorder , v1 , v2 , vstride , vorder , points);  
 }  
   
1497  void stub_glMapControlPointsNV(GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, GLboolean packed, const GLvoid *points);  void stub_glMapControlPointsNV(GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, GLboolean packed, const GLvoid *points);
1498  void (* _glMapControlPointsNV)(GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, GLboolean packed, const GLvoid *points) = &stub_glMapControlPointsNV;  void (* _glMapControlPointsNV)(GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, GLboolean packed, const GLvoid *points) = &stub_glMapControlPointsNV;
1499    
# Line 3364  void stub_glMapControlPointsNV(GLenum ta Line 1505  void stub_glMapControlPointsNV(GLenum ta
1505     return _glMapControlPointsNV(target , index , type , ustride , vstride , uorder , vorder , packed , points);     return _glMapControlPointsNV(target , index , type , ustride , vstride , uorder , vorder , packed , points);
1506  }  }
1507    
 void stub_glMapGrid1d(GLint un, GLdouble u1, GLdouble u2);  
 void (* _glMapGrid1d)(GLint un, GLdouble u1, GLdouble u2) = &stub_glMapGrid1d;  
   
 void stub_glMapGrid1d(GLint un, GLdouble u1, GLdouble u2) {  
    if (Os::getExtendedProcAddress("glMapGrid1d") == NULL) {  
       return GL_kludge_error_void("glMapGrid1d");  
    }  
    _glMapGrid1d = (void (*)(GLint , GLdouble , GLdouble))Os::getExtendedProcAddress("glMapGrid1d");  
    return _glMapGrid1d(un , u1 , u2);  
 }  
   
 void stub_glMapGrid1f(GLint un, GLfloat u1, GLfloat u2);  
 void (* _glMapGrid1f)(GLint un, GLfloat u1, GLfloat u2) = &stub_glMapGrid1f;  
   
 void stub_glMapGrid1f(GLint un, GLfloat u1, GLfloat u2) {  
    if (Os::getExtendedProcAddress("glMapGrid1f") == NULL) {  
       return GL_kludge_error_void("glMapGrid1f");  
    }  
    _glMapGrid1f = (void (*)(GLint , GLfloat , GLfloat))Os::getExtendedProcAddress("glMapGrid1f");  
    return _glMapGrid1f(un , u1 , u2);  
 }  
   
 void stub_glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);  
 void (* _glMapGrid2d)(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2) = &stub_glMapGrid2d;  
   
 void stub_glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2) {  
    if (Os::getExtendedProcAddress("glMapGrid2d") == NULL) {  
       return GL_kludge_error_void("glMapGrid2d");  
    }  
    _glMapGrid2d = (void (*)(GLint , GLdouble , GLdouble , GLint , GLdouble , GLdouble))Os::getExtendedProcAddress("glMapGrid2d");  
    return _glMapGrid2d(un , u1 , u2 , vn , v1 , v2);  
 }  
   
 void stub_glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);  
 void (* _glMapGrid2f)(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2) = &stub_glMapGrid2f;  
   
 void stub_glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2) {  
    if (Os::getExtendedProcAddress("glMapGrid2f") == NULL) {  
       return GL_kludge_error_void("glMapGrid2f");  
    }  
    _glMapGrid2f = (void (*)(GLint , GLfloat , GLfloat , GLint , GLfloat , GLfloat))Os::getExtendedProcAddress("glMapGrid2f");  
    return _glMapGrid2f(un , u1 , u2 , vn , v1 , v2);  
 }  
   
1508  void stub_glMapParameterfvNV(GLenum target, GLenum pname, const GLfloat *params);  void stub_glMapParameterfvNV(GLenum target, GLenum pname, const GLfloat *params);
1509  void (* _glMapParameterfvNV)(GLenum target, GLenum pname, const GLfloat *params) = &stub_glMapParameterfvNV;  void (* _glMapParameterfvNV)(GLenum target, GLenum pname, const GLfloat *params) = &stub_glMapParameterfvNV;
1510    
# Line 3430  void stub_glMapParameterivNV(GLenum targ Line 1527  void stub_glMapParameterivNV(GLenum targ
1527     return _glMapParameterivNV(target , pname , params);     return _glMapParameterivNV(target , pname , params);
1528  }  }
1529    
 void stub_glMaterialf(GLenum face, GLenum pname, GLfloat param);  
 void (* _glMaterialf)(GLenum face, GLenum pname, GLfloat param) = &stub_glMaterialf;  
   
 void stub_glMaterialf(GLenum face, GLenum pname, GLfloat param) {  
    if (Os::getExtendedProcAddress("glMaterialf") == NULL) {  
       return GL_kludge_error_void("glMaterialf");  
    }  
    _glMaterialf = (void (*)(GLenum , GLenum , GLfloat))Os::getExtendedProcAddress("glMaterialf");  
    return _glMaterialf(face , pname , param);  
 }  
   
 void stub_glMaterialfv(GLenum face, GLenum pname, const GLfloat *params);  
 void (* _glMaterialfv)(GLenum face, GLenum pname, const GLfloat *params) = &stub_glMaterialfv;  
   
 void stub_glMaterialfv(GLenum face, GLenum pname, const GLfloat *params) {  
    if (Os::getExtendedProcAddress("glMaterialfv") == NULL) {  
       return GL_kludge_error_void("glMaterialfv");  
    }  
    _glMaterialfv = (void (*)(GLenum , GLenum , const GLfloat *))Os::getExtendedProcAddress("glMaterialfv");  
    return _glMaterialfv(face , pname , params);  
 }  
   
 void stub_glMateriali(GLenum face, GLenum pname, GLint param);  
 void (* _glMateriali)(GLenum face, GLenum pname, GLint param) = &stub_glMateriali;  
   
 void stub_glMateriali(GLenum face, GLenum pname, GLint param) {  
    if (Os::getExtendedProcAddress("glMateriali") == NULL) {  
       return GL_kludge_error_void("glMateriali");  
    }  
    _glMateriali = (void (*)(GLenum , GLenum , GLint))Os::getExtendedProcAddress("glMateriali");  
    return _glMateriali(face , pname , param);  
 }  
   
 void stub_glMaterialiv(GLenum face, GLenum pname, const GLint *params);  
 void (* _glMaterialiv)(GLenum face, GLenum pname, const GLint *params) = &stub_glMaterialiv;  
   
 void stub_glMaterialiv(GLenum face, GLenum pname, const GLint *params) {  
    if (Os::getExtendedProcAddress("glMaterialiv") == NULL) {  
       return GL_kludge_error_void("glMaterialiv");  
    }  
    _glMaterialiv = (void (*)(GLenum , GLenum , const GLint *))Os::getExtendedProcAddress("glMaterialiv");  
    return _glMaterialiv(face , pname , params);  
 }  
   
 void stub_glMatrixMode(GLenum mode);  
 void (* _glMatrixMode)(GLenum mode) = &stub_glMatrixMode;  
   
 void stub_glMatrixMode(GLenum mode) {  
    if (Os::getExtendedProcAddress("glMatrixMode") == NULL) {  
       return GL_kludge_error_void("glMatrixMode");  
    }  
    _glMatrixMode = (void (*)(GLenum))Os::getExtendedProcAddress("glMatrixMode");  
    return _glMatrixMode(mode);  
 }  
   
1530  void stub_glMinmax(GLenum target, GLenum internalformat, GLboolean sink);  void stub_glMinmax(GLenum target, GLenum internalformat, GLboolean sink);
1531  void (* _glMinmax)(GLenum target, GLenum internalformat, GLboolean sink) = &stub_glMinmax;  void (* _glMinmax)(GLenum target, GLenum internalformat, GLboolean sink) = &stub_glMinmax;
1532    
# Line 3496  void stub_glMinmax(GLenum target, GLenum Line 1538  void stub_glMinmax(GLenum target, GLenum
1538     return _glMinmax(target , internalformat , sink);     return _glMinmax(target , internalformat , sink);
1539  }  }
1540    
 void stub_glMultMatrixd(const GLdouble *m);  
 void (* _glMultMatrixd)(const GLdouble *m) = &stub_glMultMatrixd;  
   
 void stub_glMultMatrixd(const GLdouble *m) {  
    if (Os::getExtendedProcAddress("glMultMatrixd") == NULL) {  
       return GL_kludge_error_void("glMultMatrixd");  
    }  
    _glMultMatrixd = (void (*)(const GLdouble *))Os::getExtendedProcAddress("glMultMatrixd");  
    return _glMultMatrixd(m);  
 }  
   
 void stub_glMultMatrixf(const GLfloat *m);  
 void (* _glMultMatrixf)(const GLfloat *m) = &stub_glMultMatrixf;  
   
 void stub_glMultMatrixf(const GLfloat *m) {  
    if (Os::getExtendedProcAddress("glMultMatrixf") == NULL) {  
       return GL_kludge_error_void("glMultMatrixf");  
    }  
    _glMultMatrixf = (void (*)(const GLfloat *))Os::getExtendedProcAddress("glMultMatrixf");  
    return _glMultMatrixf(m);  
 }  
   
1541  void stub_glMultTransposeMatrixd(const GLdouble *m);  void stub_glMultTransposeMatrixd(const GLdouble *m);
1542  void (* _glMultTransposeMatrixd)(const GLdouble *m) = &stub_glMultTransposeMatrixd;  void (* _glMultTransposeMatrixd)(const GLdouble *m) = &stub_glMultTransposeMatrixd;
1543    
# Line 4651  void stub_glMultiTexCoordPointerSGIS(GLe Line 2671  void stub_glMultiTexCoordPointerSGIS(GLe
2671     return _glMultiTexCoordPointerSGIS(target , size , type , stride , pointer);     return _glMultiTexCoordPointerSGIS(target , size , type , stride , pointer);
2672  }  }
2673    
 void stub_glNewList(GLuint list, GLenum mode);  
 void (* _glNewList)(GLuint list, GLenum mode) = &stub_glNewList;  
   
 void stub_glNewList(GLuint list, GLenum mode) {  
    if (Os::getExtendedProcAddress("glNewList") == NULL) {  
       return GL_kludge_error_void("glNewList");  
    }  
    _glNewList = (void (*)(GLuint , GLenum))Os::getExtendedProcAddress("glNewList");  
    return _glNewList(list , mode);  
 }  
   
 void stub_glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz);  
 void (* _glNormal3b)(GLbyte nx, GLbyte ny, GLbyte nz) = &stub_glNormal3b;  
   
 void stub_glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz) {  
    if (Os::getExtendedProcAddress("glNormal3b") == NULL) {  
       return GL_kludge_error_void("glNormal3b");  
    }  
    _glNormal3b = (void (*)(GLbyte , GLbyte , GLbyte))Os::getExtendedProcAddress("glNormal3b");  
    return _glNormal3b(nx , ny , nz);  
 }  
   
 void stub_glNormal3bv(const GLbyte *v);  
 void (* _glNormal3bv)(const GLbyte *v) = &stub_glNormal3bv;  
   
 void stub_glNormal3bv(const GLbyte *v) {  
    if (Os::getExtendedProcAddress("glNormal3bv") == NULL) {  
       return GL_kludge_error_void("glNormal3bv");  
    }  
    _glNormal3bv = (void (*)(const GLbyte *))Os::getExtendedProcAddress("glNormal3bv");  
    return _glNormal3bv(v);  
 }  
   
 void stub_glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz);  
 void (* _glNormal3d)(GLdouble nx, GLdouble ny, GLdouble nz) = &stub_glNormal3d;  
   
 void stub_glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz) {  
    if (Os::getExtendedProcAddress("glNormal3d") == NULL) {  
       return GL_kludge_error_void("glNormal3d");  
    }  
    _glNormal3d = (void (*)(GLdouble , GLdouble , GLdouble))Os::getExtendedProcAddress("glNormal3d");  
    return _glNormal3d(nx , ny , nz);  
 }  
   
 void stub_glNormal3dv(const GLdouble *v);  
 void (* _glNormal3dv)(const GLdouble *v) = &stub_glNormal3dv;  
   
 void stub_glNormal3dv(const GLdouble *v) {  
    if (Os::getExtendedProcAddress("glNormal3dv") == NULL) {  
       return GL_kludge_error_void("glNormal3dv");  
    }  
    _glNormal3dv = (void (*)(const GLdouble *))Os::getExtendedProcAddress("glNormal3dv");  
    return _glNormal3dv(v);  
 }  
   
 void stub_glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz);  
 void (* _glNormal3f)(GLfloat nx, GLfloat ny, GLfloat nz) = &stub_glNormal3f;  
   
 void stub_glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz) {  
    if (Os::getExtendedProcAddress("glNormal3f") == NULL) {  
       return GL_kludge_error_void("glNormal3f");  
    }  
    _glNormal3f = (void (*)(GLfloat , GLfloat , GLfloat))Os::getExtendedProcAddress("glNormal3f");  
    return _glNormal3f(nx , ny , nz);  
 }  
   
 void stub_glNormal3fv(const GLfloat *v);  
 void (* _glNormal3fv)(const GLfloat *v) = &stub_glNormal3fv;  
   
 void stub_glNormal3fv(const GLfloat *v) {  
    if (Os::getExtendedProcAddress("glNormal3fv") == NULL) {  
       return GL_kludge_error_void("glNormal3fv");  
    }  
    _glNormal3fv = (void (*)(const GLfloat *))Os::getExtendedProcAddress("glNormal3fv");  
    return _glNormal3fv(v);  
 }  
   
 void stub_glNormal3i(GLint nx, GLint ny, GLint nz);  
 void (* _glNormal3i)(GLint nx, GLint ny, GLint nz) = &stub_glNormal3i;  
   
 void stub_glNormal3i(GLint nx, GLint ny, GLint nz) {  
    if (Os::getExtendedProcAddress("glNormal3i") == NULL) {  
       return GL_kludge_error_void("glNormal3i");  
    }  
    _glNormal3i = (void (*)(GLint , GLint , GLint))Os::getExtendedProcAddress("glNormal3i");  
    return _glNormal3i(nx , ny , nz);  
 }  
   
 void stub_glNormal3iv(const GLint *v);  
 void (* _glNormal3iv)(const GLint *v) = &stub_glNormal3iv;  
   
 void stub_glNormal3iv(const GLint *v) {  
    if (Os::getExtendedProcAddress("glNormal3iv") == NULL) {  
       return GL_kludge_error_void("glNormal3iv");  
    }  
    _glNormal3iv = (void (*)(const GLint *))Os::getExtendedProcAddress("glNormal3iv");  
    return _glNormal3iv(v);  
 }  
   
 void stub_glNormal3s(GLshort nx, GLshort ny, GLshort nz);  
 void (* _glNormal3s)(GLshort nx, GLshort ny, GLshort nz) = &stub_glNormal3s;  
   
 void stub_glNormal3s(GLshort nx, GLshort ny, GLshort nz) {  
    if (Os::getExtendedProcAddress("glNormal3s") == NULL) {  
       return GL_kludge_error_void("glNormal3s");  
    }  
    _glNormal3s = (void (*)(GLshort , GLshort , GLshort))Os::getExtendedProcAddress("glNormal3s");  
    return _glNormal3s(nx , ny , nz);  
 }  
   
 void stub_glNormal3sv(const GLshort *v);  
 void (* _glNormal3sv)(const GLshort *v) = &stub_glNormal3sv;  
   
 void stub_glNormal3sv(const GLshort *v) {  
    if (Os::getExtendedProcAddress("glNormal3sv") == NULL) {  
       return GL_kludge_error_void("glNormal3sv");  
    }  
    _glNormal3sv = (void (*)(const GLshort *))Os::getExtendedProcAddress("glNormal3sv");  
    return _glNormal3sv(v);  
 }  
   
 void stub_glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer);  
 void (* _glNormalPointer)(GLenum type, GLsizei stride, const GLvoid *pointer) = &stub_glNormalPointer;  
   
 void stub_glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer) {  
    if (Os::getExtendedProcAddress("glNormalPointer") == NULL) {  
       return GL_kludge_error_void("glNormalPointer");  
    }  
    _glNormalPointer = (void (*)(GLenum , GLsizei , const GLvoid *))Os::getExtendedProcAddress("glNormalPointer");  
    return _glNormalPointer(type , stride , pointer);  
 }  
   
2674  void stub_glNormalPointerEXT(GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer);  void stub_glNormalPointerEXT(GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer);
2675  void (* _glNormalPointerEXT)(GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer) = &stub_glNormalPointerEXT;  void (* _glNormalPointerEXT)(GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer) = &stub_glNormalPointerEXT;
2676    
# Line 4794  void stub_glNormalPointerEXT(GLenum type Line 2682  void stub_glNormalPointerEXT(GLenum type
2682     return _glNormalPointerEXT(type , stride , count , pointer);     return _glNormalPointerEXT(type , stride , count , pointer);
2683  }  }
2684    
 void stub_glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);  
 void (* _glOrtho)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) = &stub_glOrtho;  
   
 void stub_glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) {  
    if (Os::getExtendedProcAddress("glOrtho") == NULL) {  
       return GL_kludge_error_void("glOrtho");  
    }  
    _glOrtho = (void (*)(GLdouble , GLdouble , GLdouble , GLdouble , GLdouble , GLdouble))Os::getExtendedProcAddress("glOrtho");  
    return _glOrtho(left , right , bottom , top , zNear , zFar);  
 }  
   
 void stub_glPassThrough(GLfloat token);  
 void (* _glPassThrough)(GLfloat token) = &stub_glPassThrough;  
   
 void stub_glPassThrough(GLfloat token) {  
    if (Os::getExtendedProcAddress("glPassThrough") == NULL) {  
       return GL_kludge_error_void("glPassThrough");  
    }  
    _glPassThrough = (void (*)(GLfloat))Os::getExtendedProcAddress("glPassThrough");  
    return _glPassThrough(token);  
 }  
   
2685  void stub_glPixelDataRangeNV(GLenum target, GLsizei size, const GLvoid *pointer);  void stub_glPixelDataRangeNV(GLenum target, GLsizei size, const GLvoid *pointer);
2686  void (* _glPixelDataRangeNV)(GLenum target, GLsizei size, const GLvoid *pointer) = &stub_glPixelDataRangeNV;  void (* _glPixelDataRangeNV)(GLenum target, GLsizei size, const GLvoid *pointer) = &stub_glPixelDataRangeNV;
2687    
# Line 4827  void stub_glPixelDataRangeNV(GLenum targ Line 2693  void stub_glPixelDataRangeNV(GLenum targ
2693     return _glPixelDataRangeNV(target , size , pointer);     return _glPixelDataRangeNV(target , size , pointer);
2694  }  }
2695    
 void stub_glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values);  
 void (* _glPixelMapfv)(GLenum map, GLint mapsize, const GLfloat *values) = &stub_glPixelMapfv;  
   
 void stub_glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values) {  
    if (Os::getExtendedProcAddress("glPixelMapfv") == NULL) {  
       return GL_kludge_error_void("glPixelMapfv");  
    }  
    _glPixelMapfv = (void (*)(GLenum , GLint , const GLfloat *))Os::getExtendedProcAddress("glPixelMapfv");  
    return _glPixelMapfv(map , mapsize , values);  
 }  
   
 void stub_glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values);  
 void (* _glPixelMapuiv)(GLenum map, GLint mapsize, const GLuint *values) = &stub_glPixelMapuiv;  
   
 void stub_glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values) {  
    if (Os::getExtendedProcAddress("glPixelMapuiv") == NULL) {  
       return GL_kludge_error_void("glPixelMapuiv");  
    }  
    _glPixelMapuiv = (void (*)(GLenum , GLint , const GLuint *))Os::getExtendedProcAddress("glPixelMapuiv");  
    return _glPixelMapuiv(map , mapsize , values);  
 }  
   
 void stub_glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values);  
 void (* _glPixelMapusv)(GLenum map, GLint mapsize, const GLushort *values) = &stub_glPixelMapusv;  
   
 void stub_glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values) {  
    if (Os::getExtendedProcAddress("glPixelMapusv") == NULL) {  
       return GL_kludge_error_void("glPixelMapusv");  
    }  
    _glPixelMapusv = (void (*)(GLenum , GLint , const GLushort *))Os::getExtendedProcAddress("glPixelMapusv");  
    return _glPixelMapusv(map , mapsize , values);  
 }  
   
 void stub_glPixelStoref(GLenum pname, GLfloat param);  
 void (* _glPixelStoref)(GLenum pname, GLfloat param) = &stub_glPixelStoref;  
   
 void stub_glPixelStoref(GLenum pname, GLfloat param) {  
    if (Os::getExtendedProcAddress("glPixelStoref") == NULL) {  
       return GL_kludge_error_void("glPixelStoref");  
    }  
    _glPixelStoref = (void (*)(GLenum , GLfloat))Os::getExtendedProcAddress("glPixelStoref");  
    return _glPixelStoref(pname , param);  
 }  
   
 void stub_glPixelStorei(GLenum pname, GLint param);  
 void (* _glPixelStorei)(GLenum pname, GLint param) = &stub_glPixelStorei;  
   
 void stub_glPixelStorei(GLenum pname, GLint param) {  
    if (Os::getExtendedProcAddress("glPixelStorei") == NULL) {  
       return GL_kludge_error_void("glPixelStorei");  
    }  
    _glPixelStorei = (void (*)(GLenum , GLint))Os::getExtendedProcAddress("glPixelStorei");  
    return _glPixelStorei(pname , param);  
 }  
   
 void stub_glPixelTransferf(GLenum pname, GLfloat param);  
 void (* _glPixelTransferf)(GLenum pname, GLfloat param) = &stub_glPixelTransferf;  
   
 void stub_glPixelTransferf(GLenum pname, GLfloat param) {  
    if (Os::getExtendedProcAddress("glPixelTransferf") == NULL) {  
       return GL_kludge_error_void("glPixelTransferf");  
    }  
    _glPixelTransferf = (void (*)(GLenum , GLfloat))Os::getExtendedProcAddress("glPixelTransferf");  
    return _glPixelTransferf(pname , param);  
 }  
   
 void stub_glPixelTransferi(GLenum pname, GLint param);  
 void (* _glPixelTransferi)(GLenum pname, GLint param) = &stub_glPixelTransferi;  
   
 void stub_glPixelTransferi(GLenum pname, GLint param) {  
    if (Os::getExtendedProcAddress("glPixelTransferi") == NULL) {  
       return GL_kludge_error_void("glPixelTransferi");  
    }  
    _glPixelTransferi = (void (*)(GLenum , GLint))Os::getExtendedProcAddress("glPixelTransferi");  
    return _glPixelTransferi(pname , param);  
 }  
   
 void stub_glPixelZoom(GLfloat xfactor, GLfloat yfactor);  
 void (* _glPixelZoom)(GLfloat xfactor, GLfloat yfactor) = &stub_glPixelZoom;  
   
 void stub_glPixelZoom(GLfloat xfactor, GLfloat yfactor) {  
    if (Os::getExtendedProcAddress("glPixelZoom") == NULL) {  
       return GL_kludge_error_void("glPixelZoom");  
    }  
    _glPixelZoom = (void (*)(GLfloat , GLfloat))Os::getExtendedProcAddress("glPixelZoom");  
    return _glPixelZoom(xfactor , yfactor);  
 }  
   
2696  void stub_glPointParameterfEXT(GLenum pname, GLfloat param);  void stub_glPointParameterfEXT(GLenum pname, GLfloat param);
2697  void (* _glPointParameterfEXT)(GLenum pname, GLfloat param) = &stub_glPointParameterfEXT;  void (* _glPointParameterfEXT)(GLenum pname, GLfloat param) = &stub_glPointParameterfEXT;
2698    
# Line 4959  void stub_glPointParameterivNV(GLenum pn Line 2737  void stub_glPointParameterivNV(GLenum pn
2737     return _glPointParameterivNV(pname , params);     return _glPointParameterivNV(pname , params);
2738  }  }
2739    
 void stub_glPointSize(GLfloat size);  
 void (* _glPointSize)(GLfloat size) = &stub_glPointSize;  
   
 void stub_glPointSize(GLfloat size) {  
    if (Os::getExtendedProcAddress("glPointSize") == NULL) {  
       return GL_kludge_error_void("glPointSize");  
    }  
    _glPointSize = (void (*)(GLfloat))Os::getExtendedProcAddress("glPointSize");  
    return _glPointSize(size);  
 }  
   
 void stub_glPolygonMode(GLenum face, GLenum mode);  
 void (* _glPolygonMode)(GLenum face, GLenum mode) = &stub_glPolygonMode;  
   
 void stub_glPolygonMode(GLenum face, GLenum mode) {  
    if (Os::getExtendedProcAddress("glPolygonMode") == NULL) {  
       return GL_kludge_error_void("glPolygonMode");  
    }  
    _glPolygonMode = (void (*)(GLenum , GLenum))Os::getExtendedProcAddress("glPolygonMode");  
    return _glPolygonMode(face , mode);  
 }  
   
 void stub_glPolygonOffset(GLfloat factor, GLfloat units);  
 void (* _glPolygonOffset)(GLfloat factor, GLfloat units) = &stub_glPolygonOffset;  
   
 void stub_glPolygonOffset(GLfloat factor, GLfloat units) {  
    if (Os::getExtendedProcAddress("glPolygonOffset") == NULL) {  
       return GL_kludge_error_void("glPolygonOffset");  
    }  
    _glPolygonOffset = (void (*)(GLfloat , GLfloat))Os::getExtendedProcAddress("glPolygonOffset");  
    return _glPolygonOffset(factor , units);  
 }  
   
 void stub_glPolygonStipple(const GLubyte *mask);  
 void (* _glPolygonStipple)(const GLubyte *mask) = &stub_glPolygonStipple;  
   
 void stub_glPolygonStipple(const GLubyte *mask) {  
    if (Os::getExtendedProcAddress("glPolygonStipple") == NULL) {  
       return GL_kludge_error_void("glPolygonStipple");  
    }  
    _glPolygonStipple = (void (*)(const GLubyte *))Os::getExtendedProcAddress("glPolygonStipple");  
    return _glPolygonStipple(mask);  
 }  
   
 void stub_glPopAttrib(void);  
 void (* _glPopAttrib)(void) = &stub_glPopAttrib;  
   
 void stub_glPopAttrib(void) {  
    if (Os::getExtendedProcAddress("glPopAttrib") == NULL) {  
       return GL_kludge_error_void("glPopAttrib");  
    }  
    _glPopAttrib = (void (*)())Os::getExtendedProcAddress("glPopAttrib");  
    return _glPopAttrib();  
 }  
   
 void stub_glPopClientAttrib(void);  
 void (* _glPopClientAttrib)(void) = &stub_glPopClientAttrib;  
   
 void stub_glPopClientAttrib(void) {  
    if (Os::getExtendedProcAddress("glPopClientAttrib") == NULL) {  
       return GL_kludge_error_void("glPopClientAttrib");  
    }  
    _glPopClientAttrib = (void (*)())Os::getExtendedProcAddress("glPopClientAttrib");  
    return _glPopClientAttrib();  
 }  
   
 void stub_glPopMatrix(void);  
 void (* _glPopMatrix)(void) = &stub_glPopMatrix;  
   
 void stub_glPopMatrix(void) {  
    if (Os::getExtendedProcAddress("glPopMatrix") == NULL) {  
       return GL_kludge_error_void("glPopMatrix");  
    }  
    _glPopMatrix = (void (*)())Os::getExtendedProcAddress("glPopMatrix");  
    return _glPopMatrix();  
 }  
   
 void stub_glPopName(void);  
 void (* _glPopName)(void) = &stub_glPopName;  
   
 void stub_glPopName(void) {  
    if (Os::getExtendedProcAddress("glPopName") == NULL) {  
       return GL_kludge_error_void("glPopName");  
    }  
    _glPopName = (void (*)())Os::getExtendedProcAddress("glPopName");  
    return _glPopName();  
 }  
   
 void stub_glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLclampf *priorities);  
 void (* _glPrioritizeTextures)(GLsizei n, const GLuint *textures, const GLclampf *priorities) = &stub_glPrioritizeTextures;  
   
 void stub_glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLclampf *priorities) {  
    if (Os::getExtendedProcAddress("glPrioritizeTextures") == NULL) {  
       return GL_kludge_error_void("glPrioritizeTextures");  
    }  
    _glPrioritizeTextures = (void (*)(GLsizei , const GLuint * , const GLclampf *))Os::getExtendedProcAddress("glPrioritizeTextures");  
    return _glPrioritizeTextures(n , textures , priorities);  
 }  
   
2740  void stub_glPrioritizeTexturesEXT(GLsizei n, const GLuint *textures, const GLclampf *priorities);  void stub_glPrioritizeTexturesEXT(GLsizei n, const GLuint *textures, const GLclampf *priorities);
2741  void (* _glPrioritizeTexturesEXT)(GLsizei n, const GLuint *textures, const GLclampf *priorities) = &stub_glPrioritizeTexturesEXT;  void (* _glPrioritizeTexturesEXT)(GLsizei n, const GLuint *textures, const GLclampf *priorities) = &stub_glPrioritizeTexturesEXT;
2742    
# Line 5245  void stub_glProgramParametersSigned4fvNV Line 2924  void stub_glProgramParametersSigned4fvNV
2924     return _glProgramParametersSigned4fvNV(target , index , count , v);     return _glProgramParametersSigned4fvNV(target , index , count , v);
2925  }  }
2926    
 void stub_glPushAttrib(GLbitfield mask);  
 void (* _glPushAttrib)(GLbitfield mask) = &stub_glPushAttrib;  
   
 void stub_glPushAttrib(GLbitfield mask) {  
    if (Os::getExtendedProcAddress("glPushAttrib") == NULL) {  
       return GL_kludge_error_void("glPushAttrib");  
    }  
    _glPushAttrib = (void (*)(GLbitfield))Os::getExtendedProcAddress("glPushAttrib");  
    return _glPushAttrib(mask);  
 }  
   
 void stub_glPushClientAttrib(GLbitfield mask);  
 void (* _glPushClientAttrib)(GLbitfield mask) = &stub_glPushClientAttrib;  
   
 void stub_glPushClientAttrib(GLbitfield mask) {  
    if (Os::getExtendedProcAddress("glPushClientAttrib") == NULL) {  
       return GL_kludge_error_void("glPushClientAttrib");  
    }  
    _glPushClientAttrib = (void (*)(GLbitfield))Os::getExtendedProcAddress("glPushClientAttrib");  
    return _glPushClientAttrib(mask);  
 }  
   
 void stub_glPushMatrix(void);  
 void (* _glPushMatrix)(void) = &stub_glPushMatrix;  
   
 void stub_glPushMatrix(void) {  
    if (Os::getExtendedProcAddress("glPushMatrix") == NULL) {  
       return GL_kludge_error_void("glPushMatrix");  
    }  
    _glPushMatrix = (void (*)())Os::getExtendedProcAddress("glPushMatrix");  
    return _glPushMatrix();  
 }  
   
 void stub_glPushName(GLuint name);  
 void (* _glPushName)(GLuint name) = &stub_glPushName;  
   
 void stub_glPushName(GLuint name) {  
    if (Os::getExtendedProcAddress("glPushName") == NULL) {  
       return GL_kludge_error_void("glPushName");  
    }  
    _glPushName = (void (*)(GLuint))Os::getExtendedProcAddress("glPushName");  
    return _glPushName(name);  
 }  
   
 void stub_glRasterPos2d(GLdouble x, GLdouble y);  
 void (* _glRasterPos2d)(GLdouble x, GLdouble y) = &stub_glRasterPos2d;  
   
 void stub_glRasterPos2d(GLdouble x, GLdouble y) {  
    if (Os::getExtendedProcAddress("glRasterPos2d") == NULL) {  
       return GL_kludge_error_void("glRasterPos2d");  
    }  
    _glRasterPos2d = (void (*)(GLdouble , GLdouble))Os::getExtendedProcAddress("glRasterPos2d");  
    return _glRasterPos2d(x , y);  
 }  
   
 void stub_glRasterPos2dv(const GLdouble *v);  
 void (* _glRasterPos2dv)(const GLdouble *v) = &stub_glRasterPos2dv;  
   
 void stub_glRasterPos2dv(const GLdouble *v) {  
    if (Os::getExtendedProcAddress("glRasterPos2dv") == NULL) {  
       return GL_kludge_error_void("glRasterPos2dv");  
    }  
    _glRasterPos2dv = (void (*)(const GLdouble *))Os::getExtendedProcAddress("glRasterPos2dv");  
    return _glRasterPos2dv(v);  
 }  
   
 void stub_glRasterPos2f(GLfloat x, GLfloat y);  
 void (* _glRasterPos2f)(GLfloat x, GLfloat y) = &stub_glRasterPos2f;  
   
 void stub_glRasterPos2f(GLfloat x, GLfloat y) {  
    if (Os::getExtendedProcAddress("glRasterPos2f") == NULL) {  
       return GL_kludge_error_void("glRasterPos2f");  
    }  
    _glRasterPos2f = (void (*)(GLfloat , GLfloat))Os::getExtendedProcAddress("glRasterPos2f");  
    return _glRasterPos2f(x , y);  
 }  
   
 void stub_glRasterPos2fv(const GLfloat *v);  
 void (* _glRasterPos2fv)(const GLfloat *v) = &stub_glRasterPos2fv;  
   
 void stub_glRasterPos2fv(const GLfloat *v) {  
    if (Os::getExtendedProcAddress("glRasterPos2fv") == NULL) {  
       return GL_kludge_error_void("glRasterPos2fv");  
    }  
    _glRasterPos2fv = (void (*)(const GLfloat *))Os::getExtendedProcAddress("glRasterPos2fv");  
    return _glRasterPos2fv(v);  
 }  
   
 void stub_glRasterPos2i(GLint x, GLint y);  
 void (* _glRasterPos2i)(GLint x, GLint y) = &stub_glRasterPos2i;  
   
 void stub_glRasterPos2i(GLint x, GLint y) {  
    if (Os::getExtendedProcAddress("glRasterPos2i") == NULL) {  
       return GL_kludge_error_void("glRasterPos2i");  
    }  
    _glRasterPos2i = (void (*)(GLint , GLint))Os::getExtendedProcAddress("glRasterPos2i");  
    return _glRasterPos2i(x , y);  
 }  
   
 void stub_glRasterPos2iv(const GLint *v);  
 void (* _glRasterPos2iv)(const GLint *v) = &stub_glRasterPos2iv;  
   
 void stub_glRasterPos2iv(const GLint *v) {  
    if (Os::getExtendedProcAddress("glRasterPos2iv") == NULL) {  
       return GL_kludge_error_void("glRasterPos2iv");  
    }  
    _glRasterPos2iv = (void (*)(const GLint *))Os::getExtendedProcAddress("glRasterPos2iv");  
    return _glRasterPos2iv(v);  
 }  
   
 void stub_glRasterPos2s(GLshort x, GLshort y);  
 void (* _glRasterPos2s)(GLshort x, GLshort y) = &stub_glRasterPos2s;  
   
 void stub_glRasterPos2s(GLshort x, GLshort y) {  
    if (Os::getExtendedProcAddress("glRasterPos2s") == NULL) {  
       return GL_kludge_error_void("glRasterPos2s");  
    }  
    _glRasterPos2s = (void (*)(GLshort , GLshort))Os::getExtendedProcAddress("glRasterPos2s");  
    return _glRasterPos2s(x , y);  
 }  
   
 void stub_glRasterPos2sv(const GLshort *v);  
 void (* _glRasterPos2sv)(const GLshort *v) = &stub_glRasterPos2sv;  
   
 void stub_glRasterPos2sv(const GLshort *v) {  
    if (Os::getExtendedProcAddress("glRasterPos2sv") == NULL) {  
       return GL_kludge_error_void("glRasterPos2sv");  
    }  
    _glRasterPos2sv = (void (*)(const GLshort *))Os::getExtendedProcAddress("glRasterPos2sv");  
    return _glRasterPos2sv(v);  
 }  
   
 void stub_glRasterPos3d(GLdouble x, GLdouble y, GLdouble z);  
 void (* _glRasterPos3d)(GLdouble x, GLdouble y, GLdouble z) = &stub_glRasterPos3d;  
   
 void stub_glRasterPos3d(GLdouble x, GLdouble y, GLdouble z) {  
    if (Os::getExtendedProcAddress("glRasterPos3d") == NULL) {  
       return GL_kludge_error_void("glRasterPos3d");  
    }  
    _glRasterPos3d = (void (*)(GLdouble , GLdouble , GLdouble))Os::getExtendedProcAddress("glRasterPos3d");  
    return _glRasterPos3d(x , y , z);  
 }  
   
 void stub_glRasterPos3dv(const GLdouble *v);  
 void (* _glRasterPos3dv)(const GLdouble *v) = &stub_glRasterPos3dv;  
   
 void stub_glRasterPos3dv(const GLdouble *v) {  
    if (Os::getExtendedProcAddress("glRasterPos3dv") == NULL) {  
       return GL_kludge_error_void("glRasterPos3dv");  
    }  
    _glRasterPos3dv = (void (*)(const GLdouble *))Os::getExtendedProcAddress("glRasterPos3dv");  
    return _glRasterPos3dv(v);  
 }  
   
 void stub_glRasterPos3f(GLfloat x, GLfloat y, GLfloat z);  
 void (* _glRasterPos3f)(GLfloat x, GLfloat y, GLfloat z) = &stub_glRasterPos3f;  
   
 void stub_glRasterPos3f(GLfloat x, GLfloat y, GLfloat z) {  
    if (Os::getExtendedProcAddress("glRasterPos3f") == NULL) {  
       return GL_kludge_error_void("glRasterPos3f");  
    }  
    _glRasterPos3f = (void (*)(GLfloat , GLfloat , GLfloat))Os::getExtendedProcAddress("glRasterPos3f");  
    return _glRasterPos3f(x , y , z);  
 }  
   
 void stub_glRasterPos3fv(const GLfloat *v);  
 void (* _glRasterPos3fv)(const GLfloat *v) = &stub_glRasterPos3fv;  
   
 void stub_glRasterPos3fv(const GLfloat *v) {  
    if (Os::getExtendedProcAddress("glRasterPos3fv") == NULL) {  
       return GL_kludge_error_void("glRasterPos3fv");  
    }  
    _glRasterPos3fv = (void (*)(const GLfloat *))Os::getExtendedProcAddress("glRasterPos3fv");  
    return _glRasterPos3fv(v);  
 }  
   
 void stub_glRasterPos3i(GLint x, GLint y, GLint z);  
 void (* _glRasterPos3i)(GLint x, GLint y, GLint z) = &stub_glRasterPos3i;  
   
 void stub_glRasterPos3i(GLint x, GLint y, GLint z) {  
    if (Os::getExtendedProcAddress("glRasterPos3i") == NULL) {  
       return GL_kludge_error_void("glRasterPos3i");  
    }  
    _glRasterPos3i = (void (*)(GLint , GLint , GLint))Os::getExtendedProcAddress("glRasterPos3i");  
    return _glRasterPos3i(x , y , z);  
 }  
   
 void stub_glRasterPos3iv(const GLint *v);  
 void (* _glRasterPos3iv)(const GLint *v) = &stub_glRasterPos3iv;  
   
 void stub_glRasterPos3iv(const GLint *v) {  
    if (Os::getExtendedProcAddress("glRasterPos3iv") == NULL) {  
       return GL_kludge_error_void("glRasterPos3iv");  
    }  
    _glRasterPos3iv = (void (*)(const GLint *))Os::getExtendedProcAddress("glRasterPos3iv");  
    return _glRasterPos3iv(v);  
 }  
   
 void stub_glRasterPos3s(GLshort x, GLshort y, GLshort z);  
 void (* _glRasterPos3s)(GLshort x, GLshort y, GLshort z) = &stub_glRasterPos3s;  
   
 void stub_glRasterPos3s(GLshort x, GLshort y, GLshort z) {  
    if (Os::getExtendedProcAddress("glRasterPos3s") == NULL) {  
       return GL_kludge_error_void("glRasterPos3s");  
    }  
    _glRasterPos3s = (void (*)(GLshort , GLshort , GLshort))Os::getExtendedProcAddress("glRasterPos3s");  
    return _glRasterPos3s(x , y , z);  
 }  
   
 void stub_glRasterPos3sv(const GLshort *v);  
 void (* _glRasterPos3sv)(const GLshort *v) = &stub_glRasterPos3sv;  
   
 void stub_glRasterPos3sv(const GLshort *v) {  
    if (Os::getExtendedProcAddress("glRasterPos3sv") == NULL) {  
       return GL_kludge_error_void("glRasterPos3sv");  
    }  
    _glRasterPos3sv = (void (*)(const GLshort *))Os::getExtendedProcAddress("glRasterPos3sv");  
    return _glRasterPos3sv(v);  
 }  
   
 void stub_glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);  
 void (* _glRasterPos4d)(GLdouble x, GLdouble y, GLdouble z, GLdouble w) = &stub_glRasterPos4d;  
   
 void stub_glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w) {  
    if (Os::getExtendedProcAddress("glRasterPos4d") == NULL) {  
       return GL_kludge_error_void("glRasterPos4d");  
    }  
    _glRasterPos4d = (void (*)(GLdouble , GLdouble , GLdouble , GLdouble))Os::getExtendedProcAddress("glRasterPos4d");  
    return _glRasterPos4d(x , y , z , w);  
 }  
   
 void stub_glRasterPos4dv(const GLdouble *v);  
 void (* _glRasterPos4dv)(const GLdouble *v) = &stub_glRasterPos4dv;  
   
 void stub_glRasterPos4dv(const GLdouble *v) {  
    if (Os::getExtendedProcAddress("glRasterPos4dv") == NULL) {  
       return GL_kludge_error_void("glRasterPos4dv");  
    }  
    _glRasterPos4dv = (void (*)(const GLdouble *))Os::getExtendedProcAddress("glRasterPos4dv");  
    return _glRasterPos4dv(v);  
 }  
   
 void stub_glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);  
 void (* _glRasterPos4f)(GLfloat x, GLfloat y, GLfloat z, GLfloat w) = &stub_glRasterPos4f;  
   
 void stub_glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w) {  
    if (Os::getExtendedProcAddress("glRasterPos4f") == NULL) {  
       return GL_kludge_error_void("glRasterPos4f");  
    }  
    _glRasterPos4f = (void (*)(GLfloat , GLfloat , GLfloat , GLfloat))Os::getExtendedProcAddress("glRasterPos4f");  
    return _glRasterPos4f(x , y , z , w);  
 }  
   
 void stub_glRasterPos4fv(const GLfloat *v);  
 void (* _glRasterPos4fv)(const GLfloat *v) = &stub_glRasterPos4fv;  
   
 void stub_glRasterPos4fv(const GLfloat *v) {  
    if (Os::getExtendedProcAddress("glRasterPos4fv") == NULL) {  
       return GL_kludge_error_void("glRasterPos4fv");  
    }  
    _glRasterPos4fv = (void (*)(const GLfloat *))Os::getExtendedProcAddress("glRasterPos4fv");  
    return _glRasterPos4fv(v);  
 }  
   
 void stub_glRasterPos4i(GLint x, GLint y, GLint z, GLint w);  
 void (* _glRasterPos4i)(GLint x, GLint y, GLint z, GLint w) = &stub_glRasterPos4i;  
   
 void stub_glRasterPos4i(GLint x, GLint y, GLint z, GLint w) {  
    if (Os::getExtendedProcAddress("glRasterPos4i") == NULL) {  
       return GL_kludge_error_void("glRasterPos4i");  
    }  
    _glRasterPos4i = (void (*)(GLint , GLint , GLint , GLint))Os::getExtendedProcAddress("glRasterPos4i");  
    return _glRasterPos4i(x , y , z , w);  
 }  
   
 void stub_glRasterPos4iv(const GLint *v);  
 void (* _glRasterPos4iv)(const GLint *v) = &stub_glRasterPos4iv;  
   
 void stub_glRasterPos4iv(const GLint *v) {  
    if (Os::getExtendedProcAddress("glRasterPos4iv") == NULL) {  
       return GL_kludge_error_void("glRasterPos4iv");  
    }  
    _glRasterPos4iv = (void (*)(const GLint *))Os::getExtendedProcAddress("glRasterPos4iv");  
    return _glRasterPos4iv(v);  
 }  
   
 void stub_glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w);  
 void (* _glRasterPos4s)(GLshort x, GLshort y, GLshort z, GLshort w) = &stub_glRasterPos4s;  
   
 void stub_glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w) {  
    if (Os::getExtendedProcAddress("glRasterPos4s") == NULL) {  
       return GL_kludge_error_void("glRasterPos4s");  
    }  
    _glRasterPos4s = (void (*)(GLshort , GLshort , GLshort , GLshort))Os::getExtendedProcAddress("glRasterPos4s");  
    return _glRasterPos4s(x , y , z , w);  
 }  
   
 void stub_glRasterPos4sv(const GLshort *v);  
 void (* _glRasterPos4sv)(const GLshort *v) = &stub_glRasterPos4sv;  
   
 void stub_glRasterPos4sv(const GLshort *v) {  
    if (Os::getExtendedProcAddress("glRasterPos4sv") == NULL) {  
       return GL_kludge_error_void("glRasterPos4sv");  
    }  
    _glRasterPos4sv = (void (*)(const GLshort *))Os::getExtendedProcAddress("glRasterPos4sv");  
    return _glRasterPos4sv(v);  
 }  
   
 void stub_glReadBuffer(GLenum mode);  
 void (* _glReadBuffer)(GLenum mode) = &stub_glReadBuffer;  
   
 void stub_glReadBuffer(GLenum mode) {  
    if (Os::getExtendedProcAddress("glReadBuffer") == NULL) {  
       return GL_kludge_error_void("glReadBuffer");  
    }  
    _glReadBuffer = (void (*)(GLenum))Os::getExtendedProcAddress("glReadBuffer");  
    return _glReadBuffer(mode);  
 }  
   
 void stub_glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);  
 void (* _glReadPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels) = &stub_glReadPixels;  
   
 void stub_glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels) {  
    if (Os::getExtendedProcAddress("glReadPixels") == NULL) {  
       return GL_kludge_error_void("glReadPixels");  
    }  
    _glReadPixels = (void (*)(GLint , GLint , GLsizei , GLsizei , GLenum , GLenum , GLvoid *))Os::getExtendedProcAddress("glReadPixels");  
    return _glReadPixels(x , y , width , height , format , type , pixels);  
 }  
   
 void stub_glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);  
 void (* _glRectd)(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2) = &stub_glRectd;  
   
 void stub_glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2) {  
    if (Os::getExtendedProcAddress("glRectd") == NULL) {  
       return GL_kludge_error_void("glRectd");  
    }  
    _glRectd = (void (*)(GLdouble , GLdouble , GLdouble , GLdouble))Os::getExtendedProcAddress("glRectd");  
    return _glRectd(x1 , y1 , x2 , y2);  
 }  
   
 void stub_glRectdv(const GLdouble *v1, const GLdouble *v2);  
 void (* _glRectdv)(const GLdouble *v1, const GLdouble *v2) = &stub_glRectdv;  
   
 void stub_glRectdv(const GLdouble *v1, const GLdouble *v2) {  
    if (Os::getExtendedProcAddress("glRectdv") == NULL) {  
       return GL_kludge_error_void("glRectdv");  
    }  
    _glRectdv = (void (*)(const GLdouble * , const GLdouble *))Os::getExtendedProcAddress("glRectdv");  
    return _glRectdv(v1 , v2);  
 }  
   
 void stub_glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);  
 void (* _glRectf)(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2) = &stub_glRectf;  
   
 void stub_glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2) {  
    if (Os::getExtendedProcAddress("glRectf") == NULL) {  
       return GL_kludge_error_void("glRectf");  
    }  
    _glRectf = (void (*)(GLfloat , GLfloat , GLfloat , GLfloat))Os::getExtendedProcAddress("glRectf");  
    return _glRectf(x1 , y1 , x2 , y2);  
 }  
   
 void stub_glRectfv(const GLfloat *v1, const GLfloat *v2);  
 void (* _glRectfv)(const GLfloat *v1, const GLfloat *v2) = &stub_glRectfv;  
   
 void stub_glRectfv(const GLfloat *v1, const GLfloat *v2) {  
    if (Os::getExtendedProcAddress("glRectfv") == NULL) {  
       return GL_kludge_error_void("glRectfv");  
    }  
    _glRectfv = (void (*)(const GLfloat * , const GLfloat *))Os::getExtendedProcAddress("glRectfv");  
    return _glRectfv(v1 , v2);  
 }  
   
 void stub_glRecti(GLint x1, GLint y1, GLint x2, GLint y2);  
 void (* _glRecti)(GLint x1, GLint y1, GLint x2, GLint y2) = &stub_glRecti;  
   
 void stub_glRecti(GLint x1, GLint y1, GLint x2, GLint y2) {  
    if (Os::getExtendedProcAddress("glRecti") == NULL) {  
       return GL_kludge_error_void("glRecti");  
    }  
    _glRecti = (void (*)(GLint , GLint , GLint , GLint))Os::getExtendedProcAddress("glRecti");  
    return _glRecti(x1 , y1 , x2 , y2);  
 }  
   
 void stub_glRectiv(const GLint *v1, const GLint *v2);  
 void (* _glRectiv)(const GLint *v1, const GLint *v2) = &stub_glRectiv;  
   
 void stub_glRectiv(const GLint *v1, const GLint *v2) {  
    if (Os::getExtendedProcAddress("glRectiv") == NULL) {  
       return GL_kludge_error_void("glRectiv");  
    }  
    _glRectiv = (void (*)(const GLint * , const GLint *))Os::getExtendedProcAddress("glRectiv");  
    return _glRectiv(v1 , v2);  
 }  
   
 void stub_glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2);  
 void (* _glRects)(GLshort x1, GLshort y1, GLshort x2, GLshort y2) = &stub_glRects;  
   
 void stub_glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2) {  
    if (Os::getExtendedProcAddress("glRects") == NULL) {  
       return GL_kludge_error_void("glRects");  
    }  
    _glRects = (void (*)(GLshort , GLshort , GLshort , GLshort))Os::getExtendedProcAddress("glRects");  
    return _glRects(x1 , y1 , x2 , y2);  
 }  
   
 void stub_glRectsv(const GLshort *v1, const GLshort *v2);  
 void (* _glRectsv)(const GLshort *v1, const GLshort *v2) = &stub_glRectsv;  
   
 void stub_glRectsv(const GLshort *v1, const GLshort *v2) {  
    if (Os::getExtendedProcAddress("glRectsv") == NULL) {  
       return GL_kludge_error_void("glRectsv");  
    }  
    _glRectsv = (void (*)(const GLshort * , const GLshort *))Os::getExtendedProcAddress("glRectsv");  
    return _glRectsv(v1 , v2);  
 }  
   
2927  GLenum stub_glReleaseFlushHold(const GLvoid *id);  GLenum stub_glReleaseFlushHold(const GLvoid *id);
2928  GLenum (* _glReleaseFlushHold)(const GLvoid *id) = &stub_glReleaseFlushHold;  GLenum (* _glReleaseFlushHold)(const GLvoid *id) = &stub_glReleaseFlushHold;
2929    
# Line 5674  GLenum stub_glReleaseFlushHold(const GLv Line 2935  GLenum stub_glReleaseFlushHold(const GLv
2935     return _glReleaseFlushHold(id);     return _glReleaseFlushHold(id);
2936  }  }
2937    
 GLint stub_glRenderMode(GLenum mode);  
 GLint (* _glRenderMode)(GLenum mode) = &stub_glRenderMode;  
   
 GLint stub_glRenderMode(GLenum mode) {  
    if (Os::getExtendedProcAddress("glRenderMode") == NULL) {  
       return GL_kludge_error_GLint("glRenderMode");  
    }  
    _glRenderMode = (GLint (*)(GLenum))Os::getExtendedProcAddress("glRenderMode");  
    return _glRenderMode(mode);  
 }  
   
2938  void stub_glRequestResidentProgramsNV(GLsizei n, const GLuint *programs);  void stub_glRequestResidentProgramsNV(GLsizei n, const GLuint *programs);
2939  void (* _glRequestResidentProgramsNV)(GLsizei n, const GLuint *programs) = &stub_glRequestResidentProgramsNV;  void (* _glRequestResidentProgramsNV)(GLsizei n, const GLuint *programs) = &stub_glRequestResidentProgramsNV;
2940    
# Line 5718  void stub_glResetMinmax(GLenum target) { Line 2968  void stub_glResetMinmax(GLenum target) {
2968     return _glResetMinmax(target);     return _glResetMinmax(target);
2969  }  }
2970    
 void stub_glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);  
 void (* _glRotated)(GLdouble angle, GLdouble x, GLdouble y, GLdouble z) = &stub_glRotated;  
   
 void stub_glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z) {  
    if (Os::getExtendedProcAddress("glRotated") == NULL) {  
       return GL_kludge_error_void("glRotated");  
    }  
    _glRotated = (void (*)(GLdouble , GLdouble , GLdouble , GLdouble))Os::getExtendedProcAddress("glRotated");  
    return _glRotated(angle , x , y , z);  
 }  
   
 void stub_glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);  
 void (* _glRotatef)(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) = &stub_glRotatef;  
   
 void stub_glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) {  
    if (Os::getExtendedProcAddress("glRotatef") == NULL) {  
       return GL_kludge_error_void("glRotatef");  
    }  
    _glRotatef = (void (*)(GLfloat , GLfloat , GLfloat , GLfloat))Os::getExtendedProcAddress("glRotatef");  
    return _glRotatef(angle , x , y , z);  
 }  
   
2971  void stub_glSampleCoverage(GLclampf value, GLboolean invert);  void stub_glSampleCoverage(GLclampf value, GLboolean invert);
2972  void (* _glSampleCoverage)(GLclampf value, GLboolean invert) = &stub_glSampleCoverage;  void (* _glSampleCoverage)(GLclampf value, GLboolean invert) = &stub_glSampleCoverage;
2973    
# Line 5762  void stub_glSampleCoverageARB(GLclampf v Line 2990  void stub_glSampleCoverageARB(GLclampf v
2990     return _glSampleCoverageARB(value , invert);     return _glSampleCoverageARB(value , invert);
2991  }  }
2992    
 void stub_glScaled(GLdouble x, GLdouble y, GLdouble z);  
 void (* _glScaled)(GLdouble x, GLdouble y, GLdouble z) = &stub_glScaled;  
   
 void stub_glScaled(GLdouble x, GLdouble y, GLdouble z) {  
    if (Os::getExtendedProcAddress("glScaled") == NULL) {  
       return GL_kludge_error_void("glScaled");  
    }  
    _glScaled = (void (*)(GLdouble , GLdouble , GLdouble))Os::getExtendedProcAddress("glScaled");  
    return _glScaled(x , y , z);  
 }  
   
 void stub_glScalef(GLfloat x, GLfloat y, GLfloat z);  
 void (* _glScalef)(GLfloat x, GLfloat y, GLfloat z) = &stub_glScalef;  
   
 void stub_glScalef(GLfloat x, GLfloat y, GLfloat z) {  
    if (Os::getExtendedProcAddress("glScalef") == NULL) {  
       return GL_kludge_error_void("glScalef");  
    }  
    _glScalef = (void (*)(GLfloat , GLfloat , GLfloat))Os::getExtendedProcAddress("glScalef");  
    return _glScalef(x , y , z);  
 }  
   
 void stub_glScissor(GLint x, GLint y, GLsizei width, GLsizei height);  
 void (* _glScissor)(GLint x, GLint y, GLsizei width, GLsizei height) = &stub_glScissor;  
   
 void stub_glScissor(GLint x, GLint y, GLsizei width, GLsizei height) {  
    if (Os::getExtendedProcAddress("glScissor") == NULL) {  
       return GL_kludge_error_void("glScissor");  
    }  
    _glScissor = (void (*)(GLint , GLint , GLsizei , GLsizei))Os::getExtendedProcAddress("glScissor");  
    return _glScissor(x , y , width , height);  
 }  
   
2993  void stub_glSecondaryColor3bEXT(GLbyte red, GLbyte green, GLbyte blue);  void stub_glSecondaryColor3bEXT(GLbyte red, GLbyte green, GLbyte blue);
2994  void (* _glSecondaryColor3bEXT)(GLbyte red, GLbyte green, GLbyte blue) = &stub_glSecondaryColor3bEXT;  void (* _glSecondaryColor3bEXT)(GLbyte red, GLbyte green, GLbyte blue) = &stub_glSecondaryColor3bEXT;
2995    
# Line 5982  void stub_glSecondaryColorPointerEXT(GLi Line 3177  void stub_glSecondaryColorPointerEXT(GLi
3177     return _glSecondaryColorPointerEXT(size , type , stride , pointer);     return _glSecondaryColorPointerEXT(size , type , stride , pointer);
3178  }  }
3179    
 void stub_glSelectBuffer(GLsizei size, GLuint *buffer);  
 void (* _glSelectBuffer)(GLsizei size, GLuint *buffer) = &stub_glSelectBuffer;  
   
 void stub_glSelectBuffer(GLsizei size, GLuint *buffer) {  
    if (Os::getExtendedProcAddress("glSelectBuffer") == NULL) {  
       return GL_kludge_error_void("glSelectBuffer");  
    }  
    _glSelectBuffer = (void (*)(GLsizei , GLuint *))Os::getExtendedProcAddress("glSelectBuffer");  
    return _glSelectBuffer(size , buffer);  
 }  
   
3180  void stub_glSelectTextureCoordSetSGIS(GLenum target);  void stub_glSelectTextureCoordSetSGIS(GLenum target);
3181  void (* _glSelectTextureCoordSetSGIS)(GLenum target) = &stub_glSelectTextureCoordSetSGIS;  void (* _glSelectTextureCoordSetSGIS)(GLenum target) = &stub_glSelectTextureCoordSetSGIS;
3182    
# Line 6048  void stub_glSetWindowStereoModeNV(GLbool Line 3232  void stub_glSetWindowStereoModeNV(GLbool
3232     return _glSetWindowStereoModeNV(displayMode);     return _glSetWindowStereoModeNV(displayMode);
3233  }  }
3234    
 void stub_glShadeModel(GLenum mode);  
 void (* _glShadeModel)(GLenum mode) = &stub_glShadeModel;  
   
 void stub_glShadeModel(GLenum mode) {  
    if (Os::getExtendedProcAddress("glShadeModel") == NULL) {  
       return GL_kludge_error_void("glShadeModel");  
    }  
    _glShadeModel = (void (*)(GLenum))Os::getExtendedProcAddress("glShadeModel");  
    return _glShadeModel(mode);  
 }  
   
 void stub_glStencilFunc(GLenum func, GLint ref, GLuint mask);  
 void (* _glStencilFunc)(GLenum func, GLint ref, GLuint mask) = &stub_glStencilFunc;  
   
 void stub_glStencilFunc(GLenum func, GLint ref, GLuint mask) {  
    if (Os::getExtendedProcAddress("glStencilFunc") == NULL) {  
       return GL_kludge_error_void("glStencilFunc");  
    }  
    _glStencilFunc = (void (*)(GLenum , GLint , GLuint))Os::getExtendedProcAddress("glStencilFunc");  
    return _glStencilFunc(func , ref , mask);  
 }  
   
 void stub_glStencilMask(GLuint mask);  
 void (* _glStencilMask)(GLuint mask) = &stub_glStencilMask;  
   
 void stub_glStencilMask(GLuint mask) {  
    if (Os::getExtendedProcAddress("glStencilMask") == NULL) {  
       return GL_kludge_error_void("glStencilMask");  
    }  
    _glStencilMask = (void (*)(GLuint))Os::getExtendedProcAddress("glStencilMask");  
    return _glStencilMask(mask);  
 }  
   
 void stub_glStencilOp(GLenum fail, GLenum zfail, GLenum zpass);  
 void (* _glStencilOp)(GLenum fail, GLenum zfail, GLenum zpass) = &stub_glStencilOp;  
   
 void stub_glStencilOp(GLenum fail, GLenum zfail, GLenum zpass) {  
    if (Os::getExtendedProcAddress("glStencilOp") == NULL) {  
       return GL_kludge_error_void("glStencilOp");  
    }  
    _glStencilOp = (void (*)(GLenum , GLenum , GLenum))Os::getExtendedProcAddress("glStencilOp");  
    return _glStencilOp(fail , zfail , zpass);  
 }  
   
3235  void stub_glTbufferMask3DFX(GLuint mask);  void stub_glTbufferMask3DFX(GLuint mask);
3236  void (* _glTbufferMask3DFX)(GLuint mask) = &stub_glTbufferMask3DFX;  void (* _glTbufferMask3DFX)(GLuint mask) = &stub_glTbufferMask3DFX;
3237    
# Line 6114  GLboolean stub_glTestFenceNV(GLuint fenc Line 3254  GLboolean stub_glTestFenceNV(GLuint fenc
3254     return _glTestFenceNV(fence);     return _glTestFenceNV(fence);
3255  }  }
3256    
 void stub_glTexCoord1d(GLdouble s);  
 void (* _glTexCoord1d)(GLdouble s) = &stub_glTexCoord1d;  
   
 void stub_glTexCoord1d(GLdouble s) {  
    if (Os::getExtendedProcAddress("glTexCoord1d") == NULL) {  
       return GL_kludge_error_void("glTexCoord1d");  
    }  
    _glTexCoord1d = (void (*)(GLdouble))Os::getExtendedProcAddress("glTexCoord1d");  
    return _glTexCoord1d(s);  
 }  
   
 void stub_glTexCoord1dv(const GLdouble *v);  
 void (* _glTexCoord1dv)(const GLdouble *v) = &stub_glTexCoord1dv;  
   
 void stub_glTexCoord1dv(const GLdouble *v) {  
    if (Os::getExtendedProcAddress("glTexCoord1dv") == NULL) {  
       return GL_kludge_error_void("glTexCoord1dv");  
    }  
    _glTexCoord1dv = (void (*)(const GLdouble *))Os::getExtendedProcAddress("glTexCoord1dv");  
    return _glTexCoord1dv(v);  
 }  
   
 void stub_glTexCoord1f(GLfloat s);  
 void (* _glTexCoord1f)(GLfloat s) = &stub_glTexCoord1f;  
   
 void stub_glTexCoord1f(GLfloat s) {  
    if (Os::getExtendedProcAddress("glTexCoord1f") == NULL) {  
       return GL_kludge_error_void("glTexCoord1f");  
    }  
    _glTexCoord1f = (void (*)(GLfloat))Os::getExtendedProcAddress("glTexCoord1f");  
    return _glTexCoord1f(s);  
 }  
   
 void stub_glTexCoord1fv(const GLfloat *v);  
 void (* _glTexCoord1fv)(const GLfloat *v) = &stub_glTexCoord1fv;  
   
 void stub_glTexCoord1fv(const GLfloat *v) {  
    if (Os::getExtendedProcAddress("glTexCoord1fv") == NULL) {  
       return GL_kludge_error_void("glTexCoord1fv");  
    }  
    _glTexCoord1fv = (void (*)(const GLfloat *))Os::getExtendedProcAddress("glTexCoord1fv");  
    return _glTexCoord1fv(v);  
 }  
   
 void stub_glTexCoord1i(GLint s);  
 void (* _glTexCoord1i)(GLint s) = &stub_glTexCoord1i;  
   
 void stub_glTexCoord1i(GLint s) {  
    if (Os::getExtendedProcAddress("glTexCoord1i") == NULL) {  
       return GL_kludge_error_void("glTexCoord1i");  
    }  
    _glTexCoord1i = (void (*)(GLint))Os::getExtendedProcAddress("glTexCoord1i");  
    return _glTexCoord1i(s);  
 }  
   
 void stub_glTexCoord1iv(const GLint *v);  
 void (* _glTexCoord1iv)(const GLint *v) = &stub_glTexCoord1iv;  
   
 void stub_glTexCoord1iv(const GLint *v) {  
    if (Os::getExtendedProcAddress("glTexCoord1iv") == NULL) {  
       return GL_kludge_error_void("glTexCoord1iv");  
    }  
    _glTexCoord1iv = (void (*)(const GLint *))Os::getExtendedProcAddress("glTexCoord1iv");  
    return _glTexCoord1iv(v);  
 }  
   
 void stub_glTexCoord1s(GLshort s);  
 void (* _glTexCoord1s)(GLshort s) = &stub_glTexCoord1s;  
   
 void stub_glTexCoord1s(GLshort s) {  
    if (Os::getExtendedProcAddress("glTexCoord1s") == NULL) {  
       return GL_kludge_error_void("glTexCoord1s");  
    }  
    _glTexCoord1s = (void (*)(GLshort))Os::getExtendedProcAddress("glTexCoord1s");  
    return _glTexCoord1s(s);  
 }  
   
 void stub_glTexCoord1sv(const GLshort *v);  
 void (* _glTexCoord1sv)(const GLshort *v) = &stub_glTexCoord1sv;  
   
 void stub_glTexCoord1sv(const GLshort *v) {  
    if (Os::getExtendedProcAddress("glTexCoord1sv") == NULL) {  
       return GL_kludge_error_void("glTexCoord1sv");  
    }  
    _glTexCoord1sv = (void (*)(const GLshort *))Os::getExtendedProcAddress("glTexCoord1sv");  
    return _glTexCoord1sv(v);  
 }  
   
 void stub_glTexCoord2d(GLdouble s, GLdouble t);  
 void (* _glTexCoord2d)(GLdouble s, GLdouble t) = &stub_glTexCoord2d;  
   
 void stub_glTexCoord2d(GLdouble s, GLdouble t) {  
    if (Os::getExtendedProcAddress("glTexCoord2d") == NULL) {  
       return GL_kludge_error_void("glTexCoord2d");  
    }  
    _glTexCoord2d = (void (*)(GLdouble , GLdouble))Os::getExtendedProcAddress("glTexCoord2d");  
    return _glTexCoord2d(s , t);  
 }  
   
 void stub_glTexCoord2dv(const GLdouble *v);  
 void (* _glTexCoord2dv)(const GLdouble *v) = &stub_glTexCoord2dv;  
   
 void stub_glTexCoord2dv(const GLdouble *v) {  
    if (Os::getExtendedProcAddress("glTexCoord2dv") == NULL) {  
       return GL_kludge_error_void("glTexCoord2dv");  
    }  
    _glTexCoord2dv = (void (*)(const GLdouble *))Os::getExtendedProcAddress("glTexCoord2dv");  
    return _glTexCoord2dv(v);  
 }  
   
 void stub_glTexCoord2f(GLfloat s, GLfloat t);  
 void (* _glTexCoord2f)(GLfloat s, GLfloat t) = &stub_glTexCoord2f;  
   
 void stub_glTexCoord2f(GLfloat s, GLfloat t) {  
    if (Os::getExtendedProcAddress("glTexCoord2f") == NULL) {  
       return GL_kludge_error_void("glTexCoord2f");  
    }  
    _glTexCoord2f = (void (*)(GLfloat , GLfloat))Os::getExtendedProcAddress("glTexCoord2f");  
    return _glTexCoord2f(s , t);  
 }  
   
 void stub_glTexCoord2fv(const GLfloat *v);  
 void (* _glTexCoord2fv)(const GLfloat *v) = &stub_glTexCoord2fv;  
   
 void stub_glTexCoord2fv(const GLfloat *v) {  
    if (Os::getExtendedProcAddress("glTexCoord2fv") == NULL) {  
       return GL_kludge_error_void("glTexCoord2fv");  
    }  
    _glTexCoord2fv = (void (*)(const GLfloat *))Os::getExtendedProcAddress("glTexCoord2fv");  
    return _glTexCoord2fv(v);  
 }  
   
 void stub_glTexCoord2i(GLint s, GLint t);  
 void (* _glTexCoord2i)(GLint s, GLint t) = &stub_glTexCoord2i;  
   
 void stub_glTexCoord2i(GLint s, GLint t) {  
    if (Os::getExtendedProcAddress("glTexCoord2i") == NULL) {  
       return GL_kludge_error_void("glTexCoord2i");  
    }  
    _glTexCoord2i = (void (*)(GLint , GLint))Os::getExtendedProcAddress("glTexCoord2i");  
    return _glTexCoord2i(s , t);  
 }  
   
 void stub_glTexCoord2iv(const GLint *v);  
 void (* _glTexCoord2iv)(const GLint *v) = &stub_glTexCoord2iv;  
   
 void stub_glTexCoord2iv(const GLint *v) {  
    if (Os::getExtendedProcAddress("glTexCoord2iv") == NULL) {  
       return GL_kludge_error_void("glTexCoord2iv");  
    }  
    _glTexCoord2iv = (void (*)(const GLint *))Os::getExtendedProcAddress("glTexCoord2iv");  
    return _glTexCoord2iv(v);  
 }  
   
 void stub_glTexCoord2s(GLshort s, GLshort t);  
 void (* _glTexCoord2s)(GLshort s, GLshort t) = &stub_glTexCoord2s;  
   
 void stub_glTexCoord2s(GLshort s, GLshort t) {  
    if (Os::getExtendedProcAddress("glTexCoord2s") == NULL) {  
       return GL_kludge_error_void("glTexCoord2s");  
    }  
    _glTexCoord2s = (void (*)(GLshort , GLshort))Os::getExtendedProcAddress("glTexCoord2s");  
    return _glTexCoord2s(s , t);  
 }  
   
 void stub_glTexCoord2sv(const GLshort *v);  
 void (* _glTexCoord2sv)(const GLshort *v) = &stub_glTexCoord2sv;  
   
 void stub_glTexCoord2sv(const GLshort *v) {  
    if (Os::getExtendedProcAddress("glTexCoord2sv") == NULL) {  
       return GL_kludge_error_void("glTexCoord2sv");  
    }  
    _glTexCoord2sv = (void (*)(const GLshort *))Os::getExtendedProcAddress("glTexCoord2sv");  
    return _glTexCoord2sv(v);  
 }  
   
 void stub_glTexCoord3d(GLdouble s, GLdouble t, GLdouble r);  
 void (* _glTexCoord3d)(GLdouble s, GLdouble t, GLdouble r) = &stub_glTexCoord3d;  
   
 void stub_glTexCoord3d(GLdouble s, GLdouble t, GLdouble r) {  
    if (Os::getExtendedProcAddress("glTexCoord3d") == NULL) {  
       return GL_kludge_error_void("glTexCoord3d");  
    }  
    _glTexCoord3d = (void (*)(GLdouble , GLdouble , GLdouble))Os::getExtendedProcAddress("glTexCoord3d");  
    return _glTexCoord3d(s , t , r);  
 }  
   
 void stub_glTexCoord3dv(const GLdouble *v);  
 void (* _glTexCoord3dv)(const GLdouble *v) = &stub_glTexCoord3dv;  
   
 void stub_glTexCoord3dv(const GLdouble *v) {  
    if (Os::getExtendedProcAddress("glTexCoord3dv") == NULL) {  
       return GL_kludge_error_void("glTexCoord3dv");  
    }  
    _glTexCoord3dv = (void (*)(const GLdouble *))Os::getExtendedProcAddress("glTexCoord3dv");  
    return _glTexCoord3dv(v);  
 }  
   
 void stub_glTexCoord3f(GLfloat s, GLfloat t, GLfloat r);  
 void (* _glTexCoord3f)(GLfloat s, GLfloat t, GLfloat r) = &stub_glTexCoord3f;  
   
 void stub_glTexCoord3f(GLfloat s, GLfloat t, GLfloat r) {  
    if (Os::getExtendedProcAddress("glTexCoord3f") == NULL) {  
       return GL_kludge_error_void("glTexCoord3f");  
    }  
    _glTexCoord3f = (void (*)(GLfloat , GLfloat , GLfloat))Os::getExtendedProcAddress("glTexCoord3f");  
    return _glTexCoord3f(s , t , r);  
 }  
   
 void stub_glTexCoord3fv(const GLfloat *v);  
 void (* _glTexCoord3fv)(const GLfloat *v) = &stub_glTexCoord3fv;  
   
 void stub_glTexCoord3fv(const GLfloat *v) {  
    if (Os::getExtendedProcAddress("glTexCoord3fv") == NULL) {  
       return GL_kludge_error_void("glTexCoord3fv");  
    }  
    _glTexCoord3fv = (void (*)(const GLfloat *))Os::getExtendedProcAddress("glTexCoord3fv");  
    return _glTexCoord3fv(v);  
 }  
   
 void stub_glTexCoord3i(GLint s, GLint t, GLint r);  
 void (* _glTexCoord3i)(GLint s, GLint t, GLint r) = &stub_glTexCoord3i;  
   
 void stub_glTexCoord3i(GLint s, GLint t, GLint r) {  
    if (Os::getExtendedProcAddress("glTexCoord3i") == NULL) {  
       return GL_kludge_error_void("glTexCoord3i");  
    }  
    _glTexCoord3i = (void (*)(GLint , GLint , GLint))Os::getExtendedProcAddress("glTexCoord3i");  
    return _glTexCoord3i(s , t , r);  
 }  
   
 void stub_glTexCoord3iv(const GLint *v);  
 void (* _glTexCoord3iv)(const GLint *v) = &stub_glTexCoord3iv;  
   
 void stub_glTexCoord3iv(const GLint *v) {  
    if (Os::getExtendedProcAddress("glTexCoord3iv") == NULL) {  
       return GL_kludge_error_void("glTexCoord3iv");  
    }  
    _glTexCoord3iv = (void (*)(const GLint *))Os::getExtendedProcAddress("glTexCoord3iv");  
    return _glTexCoord3iv(v);  
 }  
   
 void stub_glTexCoord3s(GLshort s, GLshort t, GLshort r);  
 void (* _glTexCoord3s)(GLshort s, GLshort t, GLshort r) = &stub_glTexCoord3s;  
   
 void stub_glTexCoord3s(GLshort s, GLshort t, GLshort r) {  
    if (Os::getExtendedProcAddress("glTexCoord3s") == NULL) {  
       return GL_kludge_error_void("glTexCoord3s");  
    }  
    _glTexCoord3s = (void (*)(GLshort , GLshort , GLshort))Os::getExtendedProcAddress("glTexCoord3s");  
    return _glTexCoord3s(s , t , r);  
 }  
   
 void stub_glTexCoord3sv(const GLshort *v);  
 void (* _glTexCoord3sv)(const GLshort *v) = &stub_glTexCoord3sv;  
   
 void stub_glTexCoord3sv(const GLshort *v) {  
    if (Os::getExtendedProcAddress("glTexCoord3sv") == NULL) {  
       return GL_kludge_error_void("glTexCoord3sv");  
    }  
    _glTexCoord3sv = (void (*)(const GLshort *))Os::getExtendedProcAddress("glTexCoord3sv");  
    return _glTexCoord3sv(v);  
 }  
   
 void stub_glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q);  
 void (* _glTexCoord4d)(GLdouble s, GLdouble t, GLdouble r, GLdouble q) = &stub_glTexCoord4d;  
   
 void stub_glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q) {  
    if (Os::getExtendedProcAddress("glTexCoord4d") == NULL) {  
       return GL_kludge_error_void("glTexCoord4d");  
    }  
    _glTexCoord4d = (void (*)(GLdouble , GLdouble , GLdouble , GLdouble))Os::getExtendedProcAddress("glTexCoord4d");  
    return _glTexCoord4d(s , t , r , q);  
 }  
   
 void stub_glTexCoord4dv(const GLdouble *v);  
 void (* _glTexCoord4dv)(const GLdouble *v) = &stub_glTexCoord4dv;  
   
 void stub_glTexCoord4dv(const GLdouble *v) {  
    if (Os::getExtendedProcAddress("glTexCoord4dv") == NULL) {  
       return GL_kludge_error_void("glTexCoord4dv");  
    }  
    _glTexCoord4dv = (void (*)(const GLdouble *))Os::getExtendedProcAddress("glTexCoord4dv");  
    return _glTexCoord4dv(v);  
 }  
   
 void stub_glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q);  
 void (* _glTexCoord4f)(GLfloat s, GLfloat t, GLfloat r, GLfloat q) = &stub_glTexCoord4f;  
   
 void stub_glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q) {  
    if (Os::getExtendedProcAddress("glTexCoord4f") == NULL) {  
       return GL_kludge_error_void("glTexCoord4f");  
    }  
    _glTexCoord4f = (void (*)(GLfloat , GLfloat , GLfloat , GLfloat))Os::getExtendedProcAddress("glTexCoord4f");  
    return _glTexCoord4f(s , t , r , q);  
 }  
   
 void stub_glTexCoord4fv(const GLfloat *v);  
 void (* _glTexCoord4fv)(const GLfloat *v) = &stub_glTexCoord4fv;  
   
 void stub_glTexCoord4fv(const GLfloat *v) {  
    if (Os::getExtendedProcAddress("glTexCoord4fv") == NULL) {  
       return GL_kludge_error_void("glTexCoord4fv");  
    }  
    _glTexCoord4fv = (void (*)(const GLfloat *))Os::getExtendedProcAddress("glTexCoord4fv");  
    return _glTexCoord4fv(v);  
 }  
   
 void stub_glTexCoord4i(GLint s, GLint t, GLint r, GLint q);  
 void (* _glTexCoord4i)(GLint s, GLint t, GLint r, GLint q) = &stub_glTexCoord4i;  
   
 void stub_glTexCoord4i(GLint s, GLint t, GLint r, GLint q) {  
    if (Os::getExtendedProcAddress("glTexCoord4i") == NULL) {  
       return GL_kludge_error_void("glTexCoord4i");  
    }  
    _glTexCoord4i = (void (*)(GLint , GLint , GLint , GLint))Os::getExtendedProcAddress("glTexCoord4i");  
    return _glTexCoord4i(s , t , r , q);  
 }  
   
 void stub_glTexCoord4iv(const GLint *v);  
 void (* _glTexCoord4iv)(const GLint *v) = &stub_glTexCoord4iv;  
   
 void stub_glTexCoord4iv(const GLint *v) {  
    if (Os::getExtendedProcAddress("glTexCoord4iv") == NULL) {  
       return GL_kludge_error_void("glTexCoord4iv");  
    }  
    _glTexCoord4iv = (void (*)(const GLint *))Os::getExtendedProcAddress("glTexCoord4iv");  
    return _glTexCoord4iv(v);  
 }  
   
 void stub_glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q);  
 void (* _glTexCoord4s)(GLshort s, GLshort t, GLshort r, GLshort q) = &stub_glTexCoord4s;  
   
 void stub_glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q) {  
    if (Os::getExtendedProcAddress("glTexCoord4s") == NULL) {  
       return GL_kludge_error_void("glTexCoord4s");  
    }  
    _glTexCoord4s = (void (*)(GLshort , GLshort , GLshort , GLshort))Os::getExtendedProcAddress("glTexCoord4s");  
    return _glTexCoord4s(s , t , r , q);  
 }  
   
 void stub_glTexCoord4sv(const GLshort *v);  
 void (* _glTexCoord4sv)(const GLshort *v) = &stub_glTexCoord4sv;  
   
 void stub_glTexCoord4sv(const GLshort *v) {  
    if (Os::getExtendedProcAddress("glTexCoord4sv") == NULL) {  
       return GL_kludge_error_void("glTexCoord4sv");  
    }  
    _glTexCoord4sv = (void (*)(const GLshort *))Os::getExtendedProcAddress("glTexCoord4sv");  
    return _glTexCoord4sv(v);  
 }  
   
 void stub_glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);  
 void (* _glTexCoordPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) = &stub_glTexCoordPointer;  
   
 void stub_glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) {  
    if (Os::getExtendedProcAddress("glTexCoordPointer") == NULL) {  
       return GL_kludge_error_void("glTexCoordPointer");  
    }  
    _glTexCoordPointer = (void (*)(GLint , GLenum , GLsizei , const GLvoid *))Os::getExtendedProcAddress("glTexCoordPointer");  
    return _glTexCoordPointer(size , type , stride , pointer);  
 }  
   
3257  void stub_glTexCoordPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer);  void stub_glTexCoordPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer);
3258  void (* _glTexCoordPointerEXT)(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer) = &stub_glTexCoordPointerEXT;  void (* _glTexCoordPointerEXT)(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer) = &stub_glTexCoordPointerEXT;
3259    
# Line 6488  void stub_glTexCoordPointerEXT(GLint siz Line 3265  void stub_glTexCoordPointerEXT(GLint siz
3265     return _glTexCoordPointerEXT(size , type , stride , count , pointer);     return _glTexCoordPointerEXT(size , type , stride , count , pointer);
3266  }  }
3267    
 void stub_glTexEnvf(GLenum target, GLenum pname, GLfloat param);  
 void (* _glTexEnvf)(GLenum target, GLenum pname, GLfloat param) = &stub_glTexEnvf;  
   
 void stub_glTexEnvf(GLenum target, GLenum pname, GLfloat param) {  
    if (Os::getExtendedProcAddress("glTexEnvf") == NULL) {  
       return GL_kludge_error_void("glTexEnvf");  
    }  
    _glTexEnvf = (void (*)(GLenum , GLenum , GLfloat))Os::getExtendedProcAddress("glTexEnvf");  
    return _glTexEnvf(target , pname , param);  
 }  
   
 void stub_glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params);  
 void (* _glTexEnvfv)(GLenum target, GLenum pname, const GLfloat *params) = &stub_glTexEnvfv;  
   
 void stub_glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params) {  
    if (Os::getExtendedProcAddress("glTexEnvfv") == NULL) {  
       return GL_kludge_error_void("glTexEnvfv");  
    }  
    _glTexEnvfv = (void (*)(GLenum , GLenum , const GLfloat *))Os::getExtendedProcAddress("glTexEnvfv");  
    return _glTexEnvfv(target , pname , params);  
 }  
   
 void stub_glTexEnvi(GLenum target, GLenum pname, GLint param);  
 void (* _glTexEnvi)(GLenum target, GLenum pname, GLint param) = &stub_glTexEnvi;  
   
 void stub_glTexEnvi(GLenum target, GLenum pname, GLint param) {  
    if (Os::getExtendedProcAddress("glTexEnvi") == NULL) {  
       return GL_kludge_error_void("glTexEnvi");  
    }  
    _glTexEnvi = (void (*)(GLenum , GLenum , GLint))Os::getExtendedProcAddress("glTexEnvi");  
    return _glTexEnvi(target , pname , param);  
 }  
   
 void stub_glTexEnviv(GLenum target, GLenum pname, const GLint *params);  
 void (* _glTexEnviv)(GLenum target, GLenum pname, const GLint *params) = &stub_glTexEnviv;  
   
 void stub_glTexEnviv(GLenum target, GLenum pname, const GLint *params) {  
    if (Os::getExtendedProcAddress("glTexEnviv") == NULL) {  
       return GL_kludge_error_void("glTexEnviv");  
    }  
    _glTexEnviv = (void (*)(GLenum , GLenum , const GLint *))Os::getExtendedProcAddress("glTexEnviv");  
    return _glTexEnviv(target , pname , params);  
 }  
   
 void stub_glTexGend(GLenum coord, GLenum pname, GLdouble param);  
 void (* _glTexGend)(GLenum coord, GLenum pname, GLdouble param) = &stub_glTexGend;  
   
 void stub_glTexGend(GLenum coord, GLenum pname, GLdouble param) {  
    if (Os::getExtendedProcAddress("glTexGend") == NULL) {  
       return GL_kludge_error_void("glTexGend");  
    }  
    _glTexGend = (void (*)(GLenum , GLenum , GLdouble))Os::getExtendedProcAddress("glTexGend");  
    return _glTexGend(coord , pname , param);  
 }  
   
 void stub_glTexGendv(GLenum coord, GLenum pname, const GLdouble *params);  
 void (* _glTexGendv)(GLenum coord, GLenum pname, const GLdouble *params) = &stub_glTexGendv;  
   
 void stub_glTexGendv(GLenum coord, GLenum pname, const GLdouble *params) {  
    if (Os::getExtendedProcAddress("glTexGendv") == NULL) {  
       return GL_kludge_error_void("glTexGendv");  
    }  
    _glTexGendv = (void (*)(GLenum , GLenum , const GLdouble *))Os::getExtendedProcAddress("glTexGendv");  
    return _glTexGendv(coord , pname , params);  
 }  
   
 void stub_glTexGenf(GLenum coord, GLenum pname, GLfloat param);  
 void (* _glTexGenf)(GLenum coord, GLenum pname, GLfloat param) = &stub_glTexGenf;  
   
 void stub_glTexGenf(GLenum coord, GLenum pname, GLfloat param) {  
    if (Os::getExtendedProcAddress("glTexGenf") == NULL) {  
       return GL_kludge_error_void("glTexGenf");  
    }  
    _glTexGenf = (void (*)(GLenum , GLenum , GLfloat))Os::getExtendedProcAddress("glTexGenf");  
    return _glTexGenf(coord , pname , param);  
 }  
   
 void stub_glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params);  
 void (* _glTexGenfv)(GLenum coord, GLenum pname, const GLfloat *params) = &stub_glTexGenfv;  
   
 void stub_glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params) {  
    if (Os::getExtendedProcAddress("glTexGenfv") == NULL) {  
       return GL_kludge_error_void("glTexGenfv");  
    }  
    _glTexGenfv = (void (*)(GLenum , GLenum , const GLfloat *))Os::getExtendedProcAddress("glTexGenfv");  
    return _glTexGenfv(coord , pname , params);  
 }  
   
 void stub_glTexGeni(GLenum coord, GLenum pname, GLint param);  
 void (* _glTexGeni)(GLenum coord, GLenum pname, GLint param) = &stub_glTexGeni;  
   
 void stub_glTexGeni(GLenum coord, GLenum pname, GLint param) {  
    if (Os::getExtendedProcAddress("glTexGeni") == NULL) {  
       return GL_kludge_error_void("glTexGeni");  
    }  
    _glTexGeni = (void (*)(GLenum , GLenum , GLint))Os::getExtendedProcAddress("glTexGeni");  
    return _glTexGeni(coord , pname , param);  
 }  
   
 void stub_glTexGeniv(GLenum coord, GLenum pname, const GLint *params);  
 void (* _glTexGeniv)(GLenum coord, GLenum pname, const GLint *params) = &stub_glTexGeniv;  
   
 void stub_glTexGeniv(GLenum coord, GLenum pname, const GLint *params) {  
    if (Os::getExtendedProcAddress("glTexGeniv") == NULL) {  
       return GL_kludge_error_void("glTexGeniv");  
    }  
    _glTexGeniv = (void (*)(GLenum , GLenum , const GLint *))Os::getExtendedProcAddress("glTexGeniv");  
    return _glTexGeniv(coord , pname , params);  
 }  
   
 void stub_glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);  
 void (* _glTexImage1D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels) = &stub_glTexImage1D;  
   
 void stub_glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels) {  
    if (Os::getExtendedProcAddress("glTexImage1D") == NULL) {  
       return GL_kludge_error_void("glTexImage1D");  
    }  
    _glTexImage1D = (void (*)(GLenum , GLint , GLint , GLsizei , GLint , GLenum , GLenum , const GLvoid *))Os::getExtendedProcAddress("glTexImage1D");  
    return _glTexImage1D(target , level , internalformat , width , border , format , type , pixels);  
 }  
   
 void stub_glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);  
 void (* _glTexImage2D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels) = &stub_glTexImage2D;  
   
 void stub_glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels) {  
    if (Os::getExtendedProcAddress("glTexImage2D") == NULL) {  
       return GL_kludge_error_void("glTexImage2D");  
    }  
    _glTexImage2D = (void (*)(GLenum , GLint , GLint , GLsizei , GLsizei , GLint , GLenum , GLenum , const GLvoid *))Os::getExtendedProcAddress("glTexImage2D");  
    return _glTexImage2D(target , level , internalformat , width , height , border , format , type , pixels);  
 }  
   
3268  void stub_glTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);  void stub_glTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
3269  void (* _glTexImage3D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels) = &stub_glTexImage3D;  void (* _glTexImage3D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels) = &stub_glTexImage3D;
3270    
# Line 6642  void stub_glTexImage3DEXT(GLenum target, Line 3287  void stub_glTexImage3DEXT(GLenum target,
3287     return _glTexImage3DEXT(target , level , internalformat , width , height , depth , border , format , type , pixels);     return _glTexImage3DEXT(target , level , internalformat , width , height , depth , border , format , type , pixels);
3288  }  }
3289    
 void stub_glTexParameterf(GLenum target, GLenum pname, GLfloat param);  
 void (* _glTexParameterf)(GLenum target, GLenum pname, GLfloat param) = &stub_glTexParameterf;  
   
 void stub_glTexParameterf(GLenum target, GLenum pname, GLfloat param) {  
    if (Os::getExtendedProcAddress("glTexParameterf") == NULL) {  
       return GL_kludge_error_void("glTexParameterf");  
    }  
    _glTexParameterf = (void (*)(GLenum , GLenum , GLfloat))Os::getExtendedProcAddress("glTexParameterf");  
    return _glTexParameterf(target , pname , param);  
 }  
   
 void stub_glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params);  
 void (* _glTexParameterfv)(GLenum target, GLenum pname, const GLfloat *params) = &stub_glTexParameterfv;  
   
 void stub_glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params) {  
    if (Os::getExtendedProcAddress("glTexParameterfv") == NULL) {  
       return GL_kludge_error_void("glTexParameterfv");  
    }  
    _glTexParameterfv = (void (*)(GLenum , GLenum , const GLfloat *))Os::getExtendedProcAddress("glTexParameterfv");  
    return _glTexParameterfv(target , pname , params);  
 }  
   
 void stub_glTexParameteri(GLenum target, GLenum pname, GLint param);  
 void (* _glTexParameteri)(GLenum target, GLenum pname, GLint param) = &stub_glTexParameteri;  
   
 void stub_glTexParameteri(GLenum target, GLenum pname, GLint param) {  
    if (Os::getExtendedProcAddress("glTexParameteri") == NULL) {  
       return GL_kludge_error_void("glTexParameteri");  
    }  
    _glTexParameteri = (void (*)(GLenum , GLenum , GLint))Os::getExtendedProcAddress("glTexParameteri");  
    return _glTexParameteri(target , pname , param);  
 }  
   
 void stub_glTexParameteriv(GLenum target, GLenum pname, const GLint *params);  
 void (* _glTexParameteriv)(GLenum target, GLenum pname, const GLint *params) = &stub_glTexParameteriv;  
   
 void stub_glTexParameteriv(GLenum target, GLenum pname, const GLint *params) {  
    if (Os::getExtendedProcAddress("glTexParameteriv") == NULL) {  
       return GL_kludge_error_void("glTexParameteriv");  
    }  
    _glTexParameteriv = (void (*)(GLenum , GLenum , const GLint *))Os::getExtendedProcAddress("glTexParameteriv");  
    return _glTexParameteriv(target , pname , params);  
 }  
   
 void stub_glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);  
 void (* _glTexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels) = &stub_glTexSubImage1D;  
   
 void stub_glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels) {  
    if (Os::getExtendedProcAddress("glTexSubImage1D") == NULL) {  
       return GL_kludge_error_void("glTexSubImage1D");  
    }  
    _glTexSubImage1D = (void (*)(GLenum , GLint , GLint , GLsizei , GLenum , GLenum , const GLvoid *))Os::getExtendedProcAddress("glTexSubImage1D");  
    return _glTexSubImage1D(target , level , xoffset , width , format , type , pixels);  
 }  
   
 void stub_glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);  
 void (* _glTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels) = &stub_glTexSubImage2D;  
   
 void stub_glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels) {  
    if (Os::getExtendedProcAddress("glTexSubImage2D") == NULL) {  
       return GL_kludge_error_void("glTexSubImage2D");  
    }  
    _glTexSubImage2D = (void (*)(GLenum , GLint , GLint , GLint , GLsizei , GLsizei , GLenum , GLenum , const GLvoid *))Os::getExtendedProcAddress("glTexSubImage2D");  
    return _glTexSubImage2D(target , level , xoffset , yoffset , width , height , format , type , pixels);  
 }  
   
3290  void stub_glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);  void stub_glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
3291  void (* _glTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels) = &stub_glTexSubImage3D;  void (* _glTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels) = &stub_glTexSubImage3D;
3292    
# Line 6741  void stub_glTrackMatrixNV(GLenum target, Line 3320  void stub_glTrackMatrixNV(GLenum target,
3320     return _glTrackMatrixNV(target , address , matrix , transform);     return _glTrackMatrixNV(target , address , matrix , transform);
3321  }  }
3322    
 void stub_glTranslated(GLdouble x, GLdouble y, GLdouble z);  
 void (* _glTranslated)(GLdouble x, GLdouble y, GLdouble z) = &stub_glTranslated;  
   
 void stub_glTranslated(GLdouble x, GLdouble y, GLdouble z) {  
    if (Os::getExtendedProcAddress("glTranslated") == NULL) {  
       return GL_kludge_error_void("glTranslated");  
    }  
    _glTranslated = (void (*)(GLdouble , GLdouble , GLdouble))Os::getExtendedProcAddress("glTranslated");  
    return _glTranslated(x , y , z);  
 }  
   
 void stub_glTranslatef(GLfloat x, GLfloat y, GLfloat z);  
 void (* _glTranslatef)(GLfloat x, GLfloat y, GLfloat z) = &stub_glTranslatef;  
   
 void stub_glTranslatef(GLfloat x, GLfloat y, GLfloat z) {  
    if (Os::getExtendedProcAddress("glTranslatef") == NULL) {  
       return GL_kludge_error_void("glTranslatef");  
    }  
    _glTranslatef = (void (*)(GLfloat , GLfloat , GLfloat))Os::getExtendedProcAddress("glTranslatef");  
    return _glTranslatef(x , y , z);  
 }  
   
3323  void stub_glUnlockArraysEXT(void);  void stub_glUnlockArraysEXT(void);
3324  void (* _glUnlockArraysEXT)(void) = &stub_glUnlockArraysEXT;  void (* _glUnlockArraysEXT)(void) = &stub_glUnlockArraysEXT;
3325    
# Line 6785  GLboolean stub_glValidBackBufferHintAuto Line 3342  GLboolean stub_glValidBackBufferHintAuto
3342     return _glValidBackBufferHintAutodesk(x , y , width , height);     return _glValidBackBufferHintAutodesk(x , y , width , height);
3343  }  }
3344    
 void stub_glVertex2d(GLdouble x, GLdouble y);  
 void (* _glVertex2d)(GLdouble x, GLdouble y) = &stub_glVertex2d;  
   
 void stub_glVertex2d(GLdouble x, GLdouble y) {  
    if (Os::getExtendedProcAddress("glVertex2d") == NULL) {  
       return GL_kludge_error_void("glVertex2d");  
    }  
    _glVertex2d = (void (*)(GLdouble , GLdouble))Os::getExtendedProcAddress("glVertex2d");  
    return _glVertex2d(x , y);  
 }  
   
 void stub_glVertex2dv(const GLdouble *v);  
 void (* _glVertex2dv)(const GLdouble *v) = &stub_glVertex2dv;  
   
 void stub_glVertex2dv(const GLdouble *v) {  
    if (Os::getExtendedProcAddress("glVertex2dv") == NULL) {  
       return GL_kludge_error_void("glVertex2dv");  
    }  
    _glVertex2dv = (void (*)(const GLdouble *))Os::getExtendedProcAddress("glVertex2dv");  
    return _glVertex2dv(v);  
 }  
   
 void stub_glVertex2f(GLfloat x, GLfloat y);  
 void (* _glVertex2f)(GLfloat x, GLfloat y) = &stub_glVertex2f;  
   
 void stub_glVertex2f(GLfloat x, GLfloat y) {  
    if (Os::getExtendedProcAddress("glVertex2f") == NULL) {  
       return GL_kludge_error_void("glVertex2f");  
    }  
    _glVertex2f = (void (*)(GLfloat , GLfloat))Os::getExtendedProcAddress("glVertex2f");  
    return _glVertex2f(x , y);  
 }  
   
 void stub_glVertex2fv(const GLfloat *v);  
 void (* _glVertex2fv)(const GLfloat *v) = &stub_glVertex2fv;  
   
 void stub_glVertex2fv(const GLfloat *v) {  
    if (Os::getExtendedProcAddress("glVertex2fv") == NULL) {  
       return GL_kludge_error_void("glVertex2fv");  
    }  
    _glVertex2fv = (void (*)(const GLfloat *))Os::getExtendedProcAddress("glVertex2fv");  
    return _glVertex2fv(v);  
 }  
   
 void stub_glVertex2i(GLint x, GLint y);  
 void (* _glVertex2i)(GLint x, GLint y) = &stub_glVertex2i;  
   
 void stub_glVertex2i(GLint x, GLint y) {  
    if (Os::getExtendedProcAddress("glVertex2i") == NULL) {  
       return GL_kludge_error_void("glVertex2i");  
    }  
    _glVertex2i = (void (*)(GLint , GLint))Os::getExtendedProcAddress("glVertex2i");  
    return _glVertex2i(x , y);  
 }  
   
 void stub_glVertex2iv(const GLint *v);  
 void (* _glVertex2iv)(const GLint *v) = &stub_glVertex2iv;  
   
 void stub_glVertex2iv(const GLint *v) {  
    if (Os::getExtendedProcAddress("glVertex2iv") == NULL) {  
       return GL_kludge_error_void("glVertex2iv");  
    }  
    _glVertex2iv = (void (*)(const GLint *))Os::getExtendedProcAddress("glVertex2iv");  
    return _glVertex2iv(v);  
 }  
   
 void stub_glVertex2s(GLshort x, GLshort y);  
 void (* _glVertex2s)(GLshort x, GLshort y) = &stub_glVertex2s;  
   
 void stub_glVertex2s(GLshort x, GLshort y) {  
    if (Os::getExtendedProcAddress("glVertex2s") == NULL) {  
       return GL_kludge_error_void("glVertex2s");  
    }  
    _glVertex2s = (void (*)(GLshort , GLshort))Os::getExtendedProcAddress("glVertex2s");  
    return _glVertex2s(x , y);  
 }  
   
 void stub_glVertex2sv(const GLshort *v);  
 void (* _glVertex2sv)(const GLshort *v) = &stub_glVertex2sv;  
   
 void stub_glVertex2sv(const GLshort *v) {  
    if (Os::getExtendedProcAddress("glVertex2sv") == NULL) {  
       return GL_kludge_error_void("glVertex2sv");  
    }  
    _glVertex2sv = (void (*)(const GLshort *))Os::getExtendedProcAddress("glVertex2sv");  
    return _glVertex2sv(v);  
 }  
   
 void stub_glVertex3d(GLdouble x, GLdouble y, GLdouble z);  
 void (* _glVertex3d)(GLdouble x, GLdouble y, GLdouble z) = &stub_glVertex3d;  
   
 void stub_glVertex3d(GLdouble x, GLdouble y, GLdouble z) {  
    if (Os::getExtendedProcAddress("glVertex3d") == NULL) {  
       return GL_kludge_error_void("glVertex3d");  
    }  
    _glVertex3d = (void (*)(GLdouble , GLdouble , GLdouble))Os::getExtendedProcAddress("glVertex3d");  
    return _glVertex3d(x , y , z);  
 }  
   
 void stub_glVertex3dv(const GLdouble *v);  
 void (* _glVertex3dv)(const GLdouble *v) = &stub_glVertex3dv;  
   
 void stub_glVertex3dv(const GLdouble *v) {  
    if (Os::getExtendedProcAddress("glVertex3dv") == NULL) {  
       return GL_kludge_error_void("glVertex3dv");  
    }  
    _glVertex3dv = (void (*)(const GLdouble *))Os::getExtendedProcAddress("glVertex3dv");  
    return _glVertex3dv(v);  
 }  
   
 void stub_glVertex3f(GLfloat x, GLfloat y, GLfloat z);  
 void (* _glVertex3f)(GLfloat x, GLfloat y, GLfloat z) = &stub_glVertex3f;  
   
 void stub_glVertex3f(GLfloat x, GLfloat y, GLfloat z) {  
    if (Os::getExtendedProcAddress("glVertex3f") == NULL) {  
       return GL_kludge_error_void("glVertex3f");  
    }  
    _glVertex3f = (void (*)(GLfloat , GLfloat , GLfloat))Os::getExtendedProcAddress("glVertex3f");  
    return _glVertex3f(x , y , z);  
 }  
   
 void stub_glVertex3fv(const GLfloat *v);  
 void (* _glVertex3fv)(const GLfloat *v) = &stub_glVertex3fv;  
   
 void stub_glVertex3fv(const GLfloat *v) {  
    if (Os::getExtendedProcAddress("glVertex3fv") == NULL) {  
       return GL_kludge_error_void("glVertex3fv");  
    }  
    _glVertex3fv = (void (*)(const GLfloat *))Os::getExtendedProcAddress("glVertex3fv");  
    return _glVertex3fv(v);  
 }  
   
 void stub_glVertex3i(GLint x, GLint y, GLint z);  
 void (* _glVertex3i)(GLint x, GLint y, GLint z) = &stub_glVertex3i;  
   
 void stub_glVertex3i(GLint x, GLint y, GLint z) {  
    if (Os::getExtendedProcAddress("glVertex3i") == NULL) {  
       return GL_kludge_error_void("glVertex3i");  
    }  
    _glVertex3i = (void (*)(GLint , GLint , GLint))Os::getExtendedProcAddress("glVertex3i");  
    return _glVertex3i(x , y , z);  
 }  
   
 void stub_glVertex3iv(const GLint *v);  
 void (* _glVertex3iv)(const GLint *v) = &stub_glVertex3iv;  
   
 void stub_glVertex3iv(const GLint *v) {  
    if (Os::getExtendedProcAddress("glVertex3iv") == NULL) {  
       return GL_kludge_error_void("glVertex3iv");  
    }  
    _glVertex3iv = (void (*)(const GLint *))Os::getExtendedProcAddress("glVertex3iv");  
    return _glVertex3iv(v);  
 }  
   
 void stub_glVertex3s(GLshort x, GLshort y, GLshort z);  
 void (* _glVertex3s)(GLshort x, GLshort y, GLshort z) = &stub_glVertex3s;  
   
 void stub_glVertex3s(GLshort x, GLshort y, GLshort z) {  
    if (Os::getExtendedProcAddress("glVertex3s") == NULL) {  
       return GL_kludge_error_void("glVertex3s");  
    }  
    _glVertex3s = (void (*)(GLshort , GLshort , GLshort))Os::getExtendedProcAddress("glVertex3s");  
    return _glVertex3s(x , y , z);  
 }  
   
 void stub_glVertex3sv(const GLshort *v);  
 void (* _glVertex3sv)(const GLshort *v) = &stub_glVertex3sv;  
   
 void stub_glVertex3sv(const GLshort *v) {  
    if (Os::getExtendedProcAddress("glVertex3sv") == NULL) {  
       return GL_kludge_error_void("glVertex3sv");  
    }  
    _glVertex3sv = (void (*)(const GLshort *))Os::getExtendedProcAddress("glVertex3sv");  
    return _glVertex3sv(v);  
 }  
   
 void stub_glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w);  
 void (* _glVertex4d)(GLdouble x, GLdouble y, GLdouble z, GLdouble w) = &stub_glVertex4d;  
   
 void stub_glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w) {  
    if (Os::getExtendedProcAddress("glVertex4d") == NULL) {  
       return GL_kludge_error_void("glVertex4d");  
    }  
    _glVertex4d = (void (*)(GLdouble , GLdouble , GLdouble , GLdouble))Os::getExtendedProcAddress("glVertex4d");  
    return _glVertex4d(x , y , z , w);  
 }  
   
 void stub_glVertex4dv(const GLdouble *v);  
 void (* _glVertex4dv)(const GLdouble *v) = &stub_glVertex4dv;  
   
 void stub_glVertex4dv(const GLdouble *v) {  
    if (Os::getExtendedProcAddress("glVertex4dv") == NULL) {  
       return GL_kludge_error_void("glVertex4dv");  
    }  
    _glVertex4dv = (void (*)(const GLdouble *))Os::getExtendedProcAddress("glVertex4dv");  
    return _glVertex4dv(v);  
 }  
   
 void stub_glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w);  
 void (* _glVertex4f)(GLfloat x, GLfloat y, GLfloat z, GLfloat w) = &stub_glVertex4f;  
   
 void stub_glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w) {  
    if (Os::getExtendedProcAddress("glVertex4f") == NULL) {  
       return GL_kludge_error_void("glVertex4f");  
    }  
    _glVertex4f = (void (*)(GLfloat , GLfloat , GLfloat , GLfloat))Os::getExtendedProcAddress("glVertex4f");  
    return _glVertex4f(x , y , z , w);  
 }  
   
 void stub_glVertex4fv(const GLfloat *v);  
 void (* _glVertex4fv)(const GLfloat *v) = &stub_glVertex4fv;  
   
 void stub_glVertex4fv(const GLfloat *v) {  
    if (Os::getExtendedProcAddress("glVertex4fv") == NULL) {  
       return GL_kludge_error_void("glVertex4fv");  
    }  
    _glVertex4fv = (void (*)(const GLfloat *))Os::getExtendedProcAddress("glVertex4fv");  
    return _glVertex4fv(v);  
 }  
   
 void stub_glVertex4i(GLint x, GLint y, GLint z, GLint w);  
 void (* _glVertex4i)(GLint x, GLint y, GLint z, GLint w) = &stub_glVertex4i;  
   
 void stub_glVertex4i(GLint x, GLint y, GLint z, GLint w) {  
    if (Os::getExtendedProcAddress("glVertex4i") == NULL) {  
       return GL_kludge_error_void("glVertex4i");  
    }  
    _glVertex4i = (void (*)(GLint , GLint , GLint , GLint))Os::getExtendedProcAddress("glVertex4i");  
    return _glVertex4i(x , y , z , w);  
 }  
   
 void stub_glVertex4iv(const GLint *v);  
 void (* _glVertex4iv)(const GLint *v) = &stub_glVertex4iv;  
   
 void stub_glVertex4iv(const GLint *v) {  
    if (Os::getExtendedProcAddress("glVertex4iv") == NULL) {  
       return GL_kludge_error_void("glVertex4iv");  
    }  
    _glVertex4iv = (void (*)(const GLint *))Os::getExtendedProcAddress("glVertex4iv");  
    return _glVertex4iv(v);  
 }  
   
 void stub_glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w);  
 void (* _glVertex4s)(GLshort x, GLshort y, GLshort z, GLshort w) = &stub_glVertex4s;  
   
 void stub_glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w) {  
    if (Os::getExtendedProcAddress("glVertex4s") == NULL) {  
       return GL_kludge_error_void("glVertex4s");  
    }  
    _glVertex4s = (void (*)(GLshort , GLshort , GLshort , GLshort))Os::getExtendedProcAddress("glVertex4s");  
    return _glVertex4s(x , y , z , w);  
 }  
   
 void stub_glVertex4sv(const GLshort *v);  
 void (* _glVertex4sv)(const GLshort *v) = &stub_glVertex4sv;  
   
 void stub_glVertex4sv(const GLshort *v) {  
    if (Os::getExtendedProcAddress("glVertex4sv") == NULL) {  
       return GL_kludge_error_void("glVertex4sv");  
    }  
    _glVertex4sv = (void (*)(const GLshort *))Os::getExtendedProcAddress("glVertex4sv");  
    return _glVertex4sv(v);  
 }  
   
3345  void stub_glVertexArrayRangeNV(GLsizei size, const GLvoid *pointer);  void stub_glVertexArrayRangeNV(GLsizei size, const GLvoid *pointer);
3346  void (* _glVertexArrayRangeNV)(GLsizei size, const GLvoid *pointer) = &stub_glVertexArrayRangeNV;  void (* _glVertexArrayRangeNV)(GLsizei size, const GLvoid *pointer) = &stub_glVertexArrayRangeNV;
3347    
# Line 7500  void stub_glVertexAttribs4ubvNV(GLuint i Line 3793  void stub_glVertexAttribs4ubvNV(GLuint i
3793     return _glVertexAttribs4ubvNV(index , count , v);     return _glVertexAttribs4ubvNV(index , count , v);
3794  }  }
3795    
 void stub_glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);  
 void (* _glVertexPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) = &stub_glVertexPointer;  
   
 void stub_glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) {  
    if (Os::getExtendedProcAddress("glVertexPointer") == NULL) {  
       return GL_kludge_error_void("glVertexPointer");  
    }  
    _glVertexPointer = (void (*)(GLint , GLenum , GLsizei , const GLvoid *))Os::getExtendedProcAddress("glVertexPointer");  
    return _glVertexPointer(size , type , stride , pointer);  
 }  
   
3796  void stub_glVertexPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer);  void stub_glVertexPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer);
3797  void (* _glVertexPointerEXT)(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer) = &stub_glVertexPointerEXT;  void (* _glVertexPointerEXT)(GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer) = &stub_glVertexPointerEXT;
3798    
# Line 7555  void stub_glVertexWeightfvEXT(const GLfl Line 3837  void stub_glVertexWeightfvEXT(const GLfl
3837     return _glVertexWeightfvEXT(weight);     return _glVertexWeightfvEXT(weight);
3838  }  }
3839    
 void stub_glViewport(GLint x, GLint y, GLsizei width, GLsizei height);  
 void (* _glViewport)(GLint x, GLint y, GLsizei width, GLsizei height) = &stub_glViewport;  
   
 void stub_glViewport(GLint x, GLint y, GLsizei width, GLsizei height) {  
    if (Os::getExtendedProcAddress("glViewport") == NULL) {  
       return GL_kludge_error_void("glViewport");  
    }  
    _glViewport = (void (*)(GLint , GLint , GLsizei , GLsizei))Os::getExtendedProcAddress("glViewport");  
    return _glViewport(x , y , width , height);  
 }  
   
3840  void stub_glWindowBackBufferHintAutodesk(void);  void stub_glWindowBackBufferHintAutodesk(void);
3841  void (* _glWindowBackBufferHintAutodesk)(void) = &stub_glWindowBackBufferHintAutodesk;  void (* _glWindowBackBufferHintAutodesk)(void) = &stub_glWindowBackBufferHintAutodesk;
3842    

Legend:
Removed from v.1.2  
changed lines
  Added in v.1.3

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26