/[gzz]/gzz/gfx/libglwrapper/GL_wrapper.cxx
ViewVC logotype

Diff of /gzz/gfx/libglwrapper/GL_wrapper.cxx

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

revision 1.4 by jvk, Sat Oct 12 13:18:23 2002 UTC revision 1.5 by tjl, Sat Dec 14 08:11:34 2002 UTC
# Line 73  GLint GL_kludge_error_GLint(const char * Line 73  GLint GL_kludge_error_GLint(const char *
73   * ==============   * ==============
74   */   */
75    
76    void stub_glActiveStencilFaceEXT(GLenum face);
77    void (* _glActiveStencilFaceEXT)(GLenum face) = &stub_glActiveStencilFaceEXT;
78    void stub_glActiveStencilFaceEXT(GLenum face) {
79       if (getExtendedProcAddress("glActiveStencilFaceEXT") == NULL) {
80          return GL_kludge_error_void("glActiveStencilFaceEXT");
81       }
82       _glActiveStencilFaceEXT = (void (*)(GLenum))getExtendedProcAddress("glActiveStencilFaceEXT");
83       return _glActiveStencilFaceEXT(face);
84    }
85    
86  void stub_glActiveTextureARB(GLenum texture);  void stub_glActiveTextureARB(GLenum texture);
87  void (* _glActiveTextureARB)(GLenum texture) = &stub_glActiveTextureARB;  void (* _glActiveTextureARB)(GLenum texture) = &stub_glActiveTextureARB;
88  void stub_glActiveTextureARB(GLenum texture) {  void stub_glActiveTextureARB(GLenum texture) {
# Line 133  void stub_glBeginOcclusionQueryNV(GLuint Line 143  void stub_glBeginOcclusionQueryNV(GLuint
143     return _glBeginOcclusionQueryNV(id);     return _glBeginOcclusionQueryNV(id);
144  }  }
145    
146    void stub_glBindProgramARB(GLenum target, GLuint program);
147    void (* _glBindProgramARB)(GLenum target, GLuint program) = &stub_glBindProgramARB;
148    void stub_glBindProgramARB(GLenum target, GLuint program) {
149       if (getExtendedProcAddress("glBindProgramARB") == NULL) {
150          return GL_kludge_error_void("glBindProgramARB");
151       }
152       _glBindProgramARB = (void (*)(GLenum , GLuint))getExtendedProcAddress("glBindProgramARB");
153       return _glBindProgramARB(target , program);
154    }
155    
156  void stub_glBindProgramNV(GLenum target, GLuint id);  void stub_glBindProgramNV(GLenum target, GLuint id);
157  void (* _glBindProgramNV)(GLenum target, GLuint id) = &stub_glBindProgramNV;  void (* _glBindProgramNV)(GLenum target, GLuint id) = &stub_glBindProgramNV;
158  void stub_glBindProgramNV(GLenum target, GLuint id) {  void stub_glBindProgramNV(GLenum target, GLuint id) {
# Line 193  void stub_glBlendEquationEXT(GLenum mode Line 213  void stub_glBlendEquationEXT(GLenum mode
213     return _glBlendEquationEXT(mode);     return _glBlendEquationEXT(mode);
214  }  }
215    
216    void stub_glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
217    void (* _glBlendFuncSeparate)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) = &stub_glBlendFuncSeparate;
218    void stub_glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) {
219       if (getExtendedProcAddress("glBlendFuncSeparate") == NULL) {
220          return GL_kludge_error_void("glBlendFuncSeparate");
221       }
222       _glBlendFuncSeparate = (void (*)(GLenum , GLenum , GLenum , GLenum))getExtendedProcAddress("glBlendFuncSeparate");
223       return _glBlendFuncSeparate(sfactorRGB , dfactorRGB , sfactorAlpha , dfactorAlpha);
224    }
225    
226    void stub_glBlendFuncSeparateEXT(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
227    void (* _glBlendFuncSeparateEXT)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) = &stub_glBlendFuncSeparateEXT;
228    void stub_glBlendFuncSeparateEXT(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha) {
229       if (getExtendedProcAddress("glBlendFuncSeparateEXT") == NULL) {
230          return GL_kludge_error_void("glBlendFuncSeparateEXT");
231       }
232       _glBlendFuncSeparateEXT = (void (*)(GLenum , GLenum , GLenum , GLenum))getExtendedProcAddress("glBlendFuncSeparateEXT");
233       return _glBlendFuncSeparateEXT(sfactorRGB , dfactorRGB , sfactorAlpha , dfactorAlpha);
234    }
235    
236  void stub_glClientActiveTextureARB(GLenum texture);  void stub_glClientActiveTextureARB(GLenum texture);
237  void (* _glClientActiveTextureARB)(GLenum texture) = &stub_glClientActiveTextureARB;  void (* _glClientActiveTextureARB)(GLenum texture) = &stub_glClientActiveTextureARB;
238  void stub_glClientActiveTextureARB(GLenum texture) {  void stub_glClientActiveTextureARB(GLenum texture) {
# Line 543  void stub_glDeleteOcclusionQueriesNV(GLs Line 583  void stub_glDeleteOcclusionQueriesNV(GLs
583     return _glDeleteOcclusionQueriesNV(n , ids);     return _glDeleteOcclusionQueriesNV(n , ids);
584  }  }
585    
586    void stub_glDeleteProgramsARB(GLsizei n, const GLuint *programs);
587    void (* _glDeleteProgramsARB)(GLsizei n, const GLuint *programs) = &stub_glDeleteProgramsARB;
588    void stub_glDeleteProgramsARB(GLsizei n, const GLuint *programs) {
589       if (getExtendedProcAddress("glDeleteProgramsARB") == NULL) {
590          return GL_kludge_error_void("glDeleteProgramsARB");
591       }
592       _glDeleteProgramsARB = (void (*)(GLsizei , const GLuint *))getExtendedProcAddress("glDeleteProgramsARB");
593       return _glDeleteProgramsARB(n , programs);
594    }
595    
596  void stub_glDeleteProgramsNV(GLsizei n, const GLuint *programs);  void stub_glDeleteProgramsNV(GLsizei n, const GLuint *programs);
597  void (* _glDeleteProgramsNV)(GLsizei n, const GLuint *programs) = &stub_glDeleteProgramsNV;  void (* _glDeleteProgramsNV)(GLsizei n, const GLuint *programs) = &stub_glDeleteProgramsNV;
598  void stub_glDeleteProgramsNV(GLsizei n, const GLuint *programs) {  void stub_glDeleteProgramsNV(GLsizei n, const GLuint *programs) {
# Line 563  void stub_glDeleteTexturesEXT(GLsizei n, Line 613  void stub_glDeleteTexturesEXT(GLsizei n,
613     return _glDeleteTexturesEXT(n , textures);     return _glDeleteTexturesEXT(n , textures);
614  }  }
615    
616    void stub_glDepthBoundsNV(GLclampd zmin, GLclampd zmax);
617    void (* _glDepthBoundsNV)(GLclampd zmin, GLclampd zmax) = &stub_glDepthBoundsNV;
618    void stub_glDepthBoundsNV(GLclampd zmin, GLclampd zmax) {
619       if (getExtendedProcAddress("glDepthBoundsNV") == NULL) {
620          return GL_kludge_error_void("glDepthBoundsNV");
621       }
622       _glDepthBoundsNV = (void (*)(GLclampd , GLclampd))getExtendedProcAddress("glDepthBoundsNV");
623       return _glDepthBoundsNV(zmin , zmax);
624    }
625    
626    void stub_glDisableVertexAttribArrayARB(GLuint index);
627    void (* _glDisableVertexAttribArrayARB)(GLuint index) = &stub_glDisableVertexAttribArrayARB;
628    void stub_glDisableVertexAttribArrayARB(GLuint index) {
629       if (getExtendedProcAddress("glDisableVertexAttribArrayARB") == NULL) {
630          return GL_kludge_error_void("glDisableVertexAttribArrayARB");
631       }
632       _glDisableVertexAttribArrayARB = (void (*)(GLuint))getExtendedProcAddress("glDisableVertexAttribArrayARB");
633       return _glDisableVertexAttribArrayARB(index);
634    }
635    
636  void stub_glDrawArraysEXT(GLenum mode, GLint first, GLsizei count);  void stub_glDrawArraysEXT(GLenum mode, GLint first, GLsizei count);
637  void (* _glDrawArraysEXT)(GLenum mode, GLint first, GLsizei count) = &stub_glDrawArraysEXT;  void (* _glDrawArraysEXT)(GLenum mode, GLint first, GLsizei count) = &stub_glDrawArraysEXT;
638  void stub_glDrawArraysEXT(GLenum mode, GLint first, GLsizei count) {  void stub_glDrawArraysEXT(GLenum mode, GLint first, GLsizei count) {
# Line 613  void stub_glEdgeFlagPointerEXT(GLsizei s Line 683  void stub_glEdgeFlagPointerEXT(GLsizei s
683     return _glEdgeFlagPointerEXT(stride , count , pointer);     return _glEdgeFlagPointerEXT(stride , count , pointer);
684  }  }
685    
686    void stub_glEnableVertexAttribArrayARB(GLuint index);
687    void (* _glEnableVertexAttribArrayARB)(GLuint index) = &stub_glEnableVertexAttribArrayARB;
688    void stub_glEnableVertexAttribArrayARB(GLuint index) {
689       if (getExtendedProcAddress("glEnableVertexAttribArrayARB") == NULL) {
690          return GL_kludge_error_void("glEnableVertexAttribArrayARB");
691       }
692       _glEnableVertexAttribArrayARB = (void (*)(GLuint))getExtendedProcAddress("glEnableVertexAttribArrayARB");
693       return _glEnableVertexAttribArrayARB(index);
694    }
695    
696  void stub_glEndOcclusionQueryNV(void);  void stub_glEndOcclusionQueryNV(void);
697  void (* _glEndOcclusionQueryNV)(void) = &stub_glEndOcclusionQueryNV;  void (* _glEndOcclusionQueryNV)(void) = &stub_glEndOcclusionQueryNV;
698  void stub_glEndOcclusionQueryNV(void) {  void stub_glEndOcclusionQueryNV(void) {
# Line 623  void stub_glEndOcclusionQueryNV(void) { Line 703  void stub_glEndOcclusionQueryNV(void) {
703     return _glEndOcclusionQueryNV();     return _glEndOcclusionQueryNV();
704  }  }
705    
 void stub_glEvalMapsNV(GLenum target, GLenum mode);  
 void (* _glEvalMapsNV)(GLenum target, GLenum mode) = &stub_glEvalMapsNV;  
 void stub_glEvalMapsNV(GLenum target, GLenum mode) {  
    if (getExtendedProcAddress("glEvalMapsNV") == NULL) {  
       return GL_kludge_error_void("glEvalMapsNV");  
    }  
    _glEvalMapsNV = (void (*)(GLenum , GLenum))getExtendedProcAddress("glEvalMapsNV");  
    return _glEvalMapsNV(target , mode);  
 }  
   
706  void stub_glExecuteProgramNV(GLenum target, GLuint id, const GLfloat *params);  void stub_glExecuteProgramNV(GLenum target, GLuint id, const GLfloat *params);
707  void (* _glExecuteProgramNV)(GLenum target, GLuint id, const GLfloat *params) = &stub_glExecuteProgramNV;  void (* _glExecuteProgramNV)(GLenum target, GLuint id, const GLfloat *params) = &stub_glExecuteProgramNV;
708  void stub_glExecuteProgramNV(GLenum target, GLuint id, const GLfloat *params) {  void stub_glExecuteProgramNV(GLenum target, GLuint id, const GLfloat *params) {
# Line 663  void stub_glFinishFenceNV(GLuint fence) Line 733  void stub_glFinishFenceNV(GLuint fence)
733     return _glFinishFenceNV(fence);     return _glFinishFenceNV(fence);
734  }  }
735    
736  GLvoid* stub_glFlushHold(void);  GLuint stub_glFlushHold(void);
737  GLvoid* (* _glFlushHold)(void) = &stub_glFlushHold;  GLuint (* _glFlushHold)(void) = &stub_glFlushHold;
738  GLvoid* stub_glFlushHold(void) {  GLuint stub_glFlushHold(void) {
739     if (getExtendedProcAddress("glFlushHold") == NULL) {     if (getExtendedProcAddress("glFlushHold") == NULL) {
740        return GL_kludge_error_GLvoid_p_("glFlushHold");        return GL_kludge_error_GLuint("glFlushHold");
741     }     }
742     _glFlushHold = (GLvoid* (*)())getExtendedProcAddress("glFlushHold");     _glFlushHold = (GLuint (*)())getExtendedProcAddress("glFlushHold");
743     return _glFlushHold();     return _glFlushHold();
744  }  }
745    
# Line 693  void stub_glFlushVertexArrayRangeNV(void Line 763  void stub_glFlushVertexArrayRangeNV(void
763     return _glFlushVertexArrayRangeNV();     return _glFlushVertexArrayRangeNV();
764  }  }
765    
766    void stub_glFogCoordPointer(GLenum type, GLsizei stride, const GLvoid *pointer);
767    void (* _glFogCoordPointer)(GLenum type, GLsizei stride, const GLvoid *pointer) = &stub_glFogCoordPointer;
768    void stub_glFogCoordPointer(GLenum type, GLsizei stride, const GLvoid *pointer) {
769       if (getExtendedProcAddress("glFogCoordPointer") == NULL) {
770          return GL_kludge_error_void("glFogCoordPointer");
771       }
772       _glFogCoordPointer = (void (*)(GLenum , GLsizei , const GLvoid *))getExtendedProcAddress("glFogCoordPointer");
773       return _glFogCoordPointer(type , stride , pointer);
774    }
775    
776  void stub_glFogCoordPointerEXT(GLenum type, GLsizei stride, const GLvoid *pointer);  void stub_glFogCoordPointerEXT(GLenum type, GLsizei stride, const GLvoid *pointer);
777  void (* _glFogCoordPointerEXT)(GLenum type, GLsizei stride, const GLvoid *pointer) = &stub_glFogCoordPointerEXT;  void (* _glFogCoordPointerEXT)(GLenum type, GLsizei stride, const GLvoid *pointer) = &stub_glFogCoordPointerEXT;
778  void stub_glFogCoordPointerEXT(GLenum type, GLsizei stride, const GLvoid *pointer) {  void stub_glFogCoordPointerEXT(GLenum type, GLsizei stride, const GLvoid *pointer) {
# Line 703  void stub_glFogCoordPointerEXT(GLenum ty Line 783  void stub_glFogCoordPointerEXT(GLenum ty
783     return _glFogCoordPointerEXT(type , stride , pointer);     return _glFogCoordPointerEXT(type , stride , pointer);
784  }  }
785    
786    void stub_glFogCoordd(GLdouble fog);
787    void (* _glFogCoordd)(GLdouble fog) = &stub_glFogCoordd;
788    void stub_glFogCoordd(GLdouble fog) {
789       if (getExtendedProcAddress("glFogCoordd") == NULL) {
790          return GL_kludge_error_void("glFogCoordd");
791       }
792       _glFogCoordd = (void (*)(GLdouble))getExtendedProcAddress("glFogCoordd");
793       return _glFogCoordd(fog);
794    }
795    
796  void stub_glFogCoorddEXT(GLdouble fog);  void stub_glFogCoorddEXT(GLdouble fog);
797  void (* _glFogCoorddEXT)(GLdouble fog) = &stub_glFogCoorddEXT;  void (* _glFogCoorddEXT)(GLdouble fog) = &stub_glFogCoorddEXT;
798  void stub_glFogCoorddEXT(GLdouble fog) {  void stub_glFogCoorddEXT(GLdouble fog) {
# Line 713  void stub_glFogCoorddEXT(GLdouble fog) { Line 803  void stub_glFogCoorddEXT(GLdouble fog) {
803     return _glFogCoorddEXT(fog);     return _glFogCoorddEXT(fog);
804  }  }
805    
806    void stub_glFogCoorddv(const GLdouble *fog);
807    void (* _glFogCoorddv)(const GLdouble *fog) = &stub_glFogCoorddv;
808    void stub_glFogCoorddv(const GLdouble *fog) {
809       if (getExtendedProcAddress("glFogCoorddv") == NULL) {
810          return GL_kludge_error_void("glFogCoorddv");
811       }
812       _glFogCoorddv = (void (*)(const GLdouble *))getExtendedProcAddress("glFogCoorddv");
813       return _glFogCoorddv(fog);
814    }
815    
816  void stub_glFogCoorddvEXT(const GLdouble *fog);  void stub_glFogCoorddvEXT(const GLdouble *fog);
817  void (* _glFogCoorddvEXT)(const GLdouble *fog) = &stub_glFogCoorddvEXT;  void (* _glFogCoorddvEXT)(const GLdouble *fog) = &stub_glFogCoorddvEXT;
818  void stub_glFogCoorddvEXT(const GLdouble *fog) {  void stub_glFogCoorddvEXT(const GLdouble *fog) {
# Line 723  void stub_glFogCoorddvEXT(const GLdouble Line 823  void stub_glFogCoorddvEXT(const GLdouble
823     return _glFogCoorddvEXT(fog);     return _glFogCoorddvEXT(fog);
824  }  }
825    
826    void stub_glFogCoordf(GLfloat fog);
827    void (* _glFogCoordf)(GLfloat fog) = &stub_glFogCoordf;
828    void stub_glFogCoordf(GLfloat fog) {
829       if (getExtendedProcAddress("glFogCoordf") == NULL) {
830          return GL_kludge_error_void("glFogCoordf");
831       }
832       _glFogCoordf = (void (*)(GLfloat))getExtendedProcAddress("glFogCoordf");
833       return _glFogCoordf(fog);
834    }
835    
836  void stub_glFogCoordfEXT(GLfloat fog);  void stub_glFogCoordfEXT(GLfloat fog);
837  void (* _glFogCoordfEXT)(GLfloat fog) = &stub_glFogCoordfEXT;  void (* _glFogCoordfEXT)(GLfloat fog) = &stub_glFogCoordfEXT;
838  void stub_glFogCoordfEXT(GLfloat fog) {  void stub_glFogCoordfEXT(GLfloat fog) {
# Line 733  void stub_glFogCoordfEXT(GLfloat fog) { Line 843  void stub_glFogCoordfEXT(GLfloat fog) {
843     return _glFogCoordfEXT(fog);     return _glFogCoordfEXT(fog);
844  }  }
845    
846    void stub_glFogCoordfv(const GLfloat *fog);
847    void (* _glFogCoordfv)(const GLfloat *fog) = &stub_glFogCoordfv;
848    void stub_glFogCoordfv(const GLfloat *fog) {
849       if (getExtendedProcAddress("glFogCoordfv") == NULL) {
850          return GL_kludge_error_void("glFogCoordfv");
851       }
852       _glFogCoordfv = (void (*)(const GLfloat *))getExtendedProcAddress("glFogCoordfv");
853       return _glFogCoordfv(fog);
854    }
855    
856  void stub_glFogCoordfvEXT(const GLfloat *fog);  void stub_glFogCoordfvEXT(const GLfloat *fog);
857  void (* _glFogCoordfvEXT)(const GLfloat *fog) = &stub_glFogCoordfvEXT;  void (* _glFogCoordfvEXT)(const GLfloat *fog) = &stub_glFogCoordfvEXT;
858  void stub_glFogCoordfvEXT(const GLfloat *fog) {  void stub_glFogCoordfvEXT(const GLfloat *fog) {
# Line 763  void stub_glGenOcclusionQueriesNV(GLsize Line 883  void stub_glGenOcclusionQueriesNV(GLsize
883     return _glGenOcclusionQueriesNV(n , ids);     return _glGenOcclusionQueriesNV(n , ids);
884  }  }
885    
886    void stub_glGenProgramsARB(GLsizei n, GLuint *programs);
887    void (* _glGenProgramsARB)(GLsizei n, GLuint *programs) = &stub_glGenProgramsARB;
888    void stub_glGenProgramsARB(GLsizei n, GLuint *programs) {
889       if (getExtendedProcAddress("glGenProgramsARB") == NULL) {
890          return GL_kludge_error_void("glGenProgramsARB");
891       }
892       _glGenProgramsARB = (void (*)(GLsizei , GLuint *))getExtendedProcAddress("glGenProgramsARB");
893       return _glGenProgramsARB(n , programs);
894    }
895    
896  void stub_glGenProgramsNV(GLsizei n, GLuint *programs);  void stub_glGenProgramsNV(GLsizei n, GLuint *programs);
897  void (* _glGenProgramsNV)(GLsizei n, GLuint *programs) = &stub_glGenProgramsNV;  void (* _glGenProgramsNV)(GLsizei n, GLuint *programs) = &stub_glGenProgramsNV;
898  void stub_glGenProgramsNV(GLsizei n, GLuint *programs) {  void stub_glGenProgramsNV(GLsizei n, GLuint *programs) {
# Line 993  void stub_glGetHistogramParameteriv(GLen Line 1123  void stub_glGetHistogramParameteriv(GLen
1123     return _glGetHistogramParameteriv(target , pname , params);     return _glGetHistogramParameteriv(target , pname , params);
1124  }  }
1125    
 void stub_glGetMapAttribParameterfvNV(GLenum target, GLuint index, GLenum pname, GLfloat *params);  
 void (* _glGetMapAttribParameterfvNV)(GLenum target, GLuint index, GLenum pname, GLfloat *params) = &stub_glGetMapAttribParameterfvNV;  
 void stub_glGetMapAttribParameterfvNV(GLenum target, GLuint index, GLenum pname, GLfloat *params) {  
    if (getExtendedProcAddress("glGetMapAttribParameterfvNV") == NULL) {  
       return GL_kludge_error_void("glGetMapAttribParameterfvNV");  
    }  
    _glGetMapAttribParameterfvNV = (void (*)(GLenum , GLuint , GLenum , GLfloat *))getExtendedProcAddress("glGetMapAttribParameterfvNV");  
    return _glGetMapAttribParameterfvNV(target , index , pname , params);  
 }  
   
 void stub_glGetMapAttribParameterivNV(GLenum target, GLuint index, GLenum pname, GLint *params);  
 void (* _glGetMapAttribParameterivNV)(GLenum target, GLuint index, GLenum pname, GLint *params) = &stub_glGetMapAttribParameterivNV;  
 void stub_glGetMapAttribParameterivNV(GLenum target, GLuint index, GLenum pname, GLint *params) {  
    if (getExtendedProcAddress("glGetMapAttribParameterivNV") == NULL) {  
       return GL_kludge_error_void("glGetMapAttribParameterivNV");  
    }  
    _glGetMapAttribParameterivNV = (void (*)(GLenum , GLuint , GLenum , GLint *))getExtendedProcAddress("glGetMapAttribParameterivNV");  
    return _glGetMapAttribParameterivNV(target , index , pname , params);  
 }  
   
 void stub_glGetMapControlPointsNV(GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLboolean packed, GLvoid *points);  
 void (* _glGetMapControlPointsNV)(GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLboolean packed, GLvoid *points) = &stub_glGetMapControlPointsNV;  
 void stub_glGetMapControlPointsNV(GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLboolean packed, GLvoid *points) {  
    if (getExtendedProcAddress("glGetMapControlPointsNV") == NULL) {  
       return GL_kludge_error_void("glGetMapControlPointsNV");  
    }  
    _glGetMapControlPointsNV = (void (*)(GLenum , GLuint , GLenum , GLsizei , GLsizei , GLboolean , GLvoid *))getExtendedProcAddress("glGetMapControlPointsNV");  
    return _glGetMapControlPointsNV(target , index , type , ustride , vstride , packed , points);  
 }  
   
 void stub_glGetMapParameterfvNV(GLenum target, GLenum pname, GLfloat *params);  
 void (* _glGetMapParameterfvNV)(GLenum target, GLenum pname, GLfloat *params) = &stub_glGetMapParameterfvNV;  
 void stub_glGetMapParameterfvNV(GLenum target, GLenum pname, GLfloat *params) {  
    if (getExtendedProcAddress("glGetMapParameterfvNV") == NULL) {  
       return GL_kludge_error_void("glGetMapParameterfvNV");  
    }  
    _glGetMapParameterfvNV = (void (*)(GLenum , GLenum , GLfloat *))getExtendedProcAddress("glGetMapParameterfvNV");  
    return _glGetMapParameterfvNV(target , pname , params);  
 }  
   
 void stub_glGetMapParameterivNV(GLenum target, GLenum pname, GLint *params);  
 void (* _glGetMapParameterivNV)(GLenum target, GLenum pname, GLint *params) = &stub_glGetMapParameterivNV;  
 void stub_glGetMapParameterivNV(GLenum target, GLenum pname, GLint *params) {  
    if (getExtendedProcAddress("glGetMapParameterivNV") == NULL) {  
       return GL_kludge_error_void("glGetMapParameterivNV");  
    }  
    _glGetMapParameterivNV = (void (*)(GLenum , GLenum , GLint *))getExtendedProcAddress("glGetMapParameterivNV");  
    return _glGetMapParameterivNV(target , pname , params);  
 }  
   
1126  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);
1127  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;
1128  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) {
# Line 1103  void stub_glGetPointervEXT(GLenum pname, Line 1183  void stub_glGetPointervEXT(GLenum pname,
1183     return _glGetPointervEXT(pname , params);     return _glGetPointervEXT(pname , params);
1184  }  }
1185    
1186  void stub_glGetProgramParameterSigneddvNV(GLenum target, GLint index, GLenum pname, GLdouble *params);  void stub_glGetProgramEnvParameterdvARB(GLenum target, GLuint index, GLdouble *params);
1187  void (* _glGetProgramParameterSigneddvNV)(GLenum target, GLint index, GLenum pname, GLdouble *params) = &stub_glGetProgramParameterSigneddvNV;  void (* _glGetProgramEnvParameterdvARB)(GLenum target, GLuint index, GLdouble *params) = &stub_glGetProgramEnvParameterdvARB;
1188  void stub_glGetProgramParameterSigneddvNV(GLenum target, GLint index, GLenum pname, GLdouble *params) {  void stub_glGetProgramEnvParameterdvARB(GLenum target, GLuint index, GLdouble *params) {
1189     if (getExtendedProcAddress("glGetProgramParameterSigneddvNV") == NULL) {     if (getExtendedProcAddress("glGetProgramEnvParameterdvARB") == NULL) {
1190        return GL_kludge_error_void("glGetProgramParameterSigneddvNV");        return GL_kludge_error_void("glGetProgramEnvParameterdvARB");
1191     }     }
1192     _glGetProgramParameterSigneddvNV = (void (*)(GLenum , GLint , GLenum , GLdouble *))getExtendedProcAddress("glGetProgramParameterSigneddvNV");     _glGetProgramEnvParameterdvARB = (void (*)(GLenum , GLuint , GLdouble *))getExtendedProcAddress("glGetProgramEnvParameterdvARB");
1193     return _glGetProgramParameterSigneddvNV(target , index , pname , params);     return _glGetProgramEnvParameterdvARB(target , index , params);
1194  }  }
1195    
1196  void stub_glGetProgramParameterSignedfvNV(GLenum target, GLint index, GLenum pname, GLfloat *params);  void stub_glGetProgramEnvParameterfvARB(GLenum target, GLuint index, GLfloat *params);
1197  void (* _glGetProgramParameterSignedfvNV)(GLenum target, GLint index, GLenum pname, GLfloat *params) = &stub_glGetProgramParameterSignedfvNV;  void (* _glGetProgramEnvParameterfvARB)(GLenum target, GLuint index, GLfloat *params) = &stub_glGetProgramEnvParameterfvARB;
1198  void stub_glGetProgramParameterSignedfvNV(GLenum target, GLint index, GLenum pname, GLfloat *params) {  void stub_glGetProgramEnvParameterfvARB(GLenum target, GLuint index, GLfloat *params) {
1199     if (getExtendedProcAddress("glGetProgramParameterSignedfvNV") == NULL) {     if (getExtendedProcAddress("glGetProgramEnvParameterfvARB") == NULL) {
1200        return GL_kludge_error_void("glGetProgramParameterSignedfvNV");        return GL_kludge_error_void("glGetProgramEnvParameterfvARB");
1201       }
1202       _glGetProgramEnvParameterfvARB = (void (*)(GLenum , GLuint , GLfloat *))getExtendedProcAddress("glGetProgramEnvParameterfvARB");
1203       return _glGetProgramEnvParameterfvARB(target , index , params);
1204    }
1205    
1206    void stub_glGetProgramLocalParameterdvARB(GLenum target, GLuint index, GLdouble *params);
1207    void (* _glGetProgramLocalParameterdvARB)(GLenum target, GLuint index, GLdouble *params) = &stub_glGetProgramLocalParameterdvARB;
1208    void stub_glGetProgramLocalParameterdvARB(GLenum target, GLuint index, GLdouble *params) {
1209       if (getExtendedProcAddress("glGetProgramLocalParameterdvARB") == NULL) {
1210          return GL_kludge_error_void("glGetProgramLocalParameterdvARB");
1211       }
1212       _glGetProgramLocalParameterdvARB = (void (*)(GLenum , GLuint , GLdouble *))getExtendedProcAddress("glGetProgramLocalParameterdvARB");
1213       return _glGetProgramLocalParameterdvARB(target , index , params);
1214    }
1215    
1216    void stub_glGetProgramLocalParameterfvARB(GLenum target, GLuint index, GLfloat *params);
1217    void (* _glGetProgramLocalParameterfvARB)(GLenum target, GLuint index, GLfloat *params) = &stub_glGetProgramLocalParameterfvARB;
1218    void stub_glGetProgramLocalParameterfvARB(GLenum target, GLuint index, GLfloat *params) {
1219       if (getExtendedProcAddress("glGetProgramLocalParameterfvARB") == NULL) {
1220          return GL_kludge_error_void("glGetProgramLocalParameterfvARB");
1221       }
1222       _glGetProgramLocalParameterfvARB = (void (*)(GLenum , GLuint , GLfloat *))getExtendedProcAddress("glGetProgramLocalParameterfvARB");
1223       return _glGetProgramLocalParameterfvARB(target , index , params);
1224    }
1225    
1226    void stub_glGetProgramNamedParameterdvNV(GLuint id, GLsizei len, const GLubyte *name, GLdouble *params);
1227    void (* _glGetProgramNamedParameterdvNV)(GLuint id, GLsizei len, const GLubyte *name, GLdouble *params) = &stub_glGetProgramNamedParameterdvNV;
1228    void stub_glGetProgramNamedParameterdvNV(GLuint id, GLsizei len, const GLubyte *name, GLdouble *params) {
1229       if (getExtendedProcAddress("glGetProgramNamedParameterdvNV") == NULL) {
1230          return GL_kludge_error_void("glGetProgramNamedParameterdvNV");
1231     }     }
1232     _glGetProgramParameterSignedfvNV = (void (*)(GLenum , GLint , GLenum , GLfloat *))getExtendedProcAddress("glGetProgramParameterSignedfvNV");     _glGetProgramNamedParameterdvNV = (void (*)(GLuint , GLsizei , const GLubyte * , GLdouble *))getExtendedProcAddress("glGetProgramNamedParameterdvNV");
1233     return _glGetProgramParameterSignedfvNV(target , index , pname , params);     return _glGetProgramNamedParameterdvNV(id , len , name , params);
1234    }
1235    
1236    void stub_glGetProgramNamedParameterfvNV(GLuint id, GLsizei len, const GLubyte *name, GLfloat *params);
1237    void (* _glGetProgramNamedParameterfvNV)(GLuint id, GLsizei len, const GLubyte *name, GLfloat *params) = &stub_glGetProgramNamedParameterfvNV;
1238    void stub_glGetProgramNamedParameterfvNV(GLuint id, GLsizei len, const GLubyte *name, GLfloat *params) {
1239       if (getExtendedProcAddress("glGetProgramNamedParameterfvNV") == NULL) {
1240          return GL_kludge_error_void("glGetProgramNamedParameterfvNV");
1241       }
1242       _glGetProgramNamedParameterfvNV = (void (*)(GLuint , GLsizei , const GLubyte * , GLfloat *))getExtendedProcAddress("glGetProgramNamedParameterfvNV");
1243       return _glGetProgramNamedParameterfvNV(id , len , name , params);
1244  }  }
1245    
1246  void stub_glGetProgramParameterdvNV(GLenum target, GLuint index, GLenum pname, GLdouble *params);  void stub_glGetProgramParameterdvNV(GLenum target, GLuint index, GLenum pname, GLdouble *params);
# Line 1143  void stub_glGetProgramParameterfvNV(GLen Line 1263  void stub_glGetProgramParameterfvNV(GLen
1263     return _glGetProgramParameterfvNV(target , index , pname , params);     return _glGetProgramParameterfvNV(target , index , pname , params);
1264  }  }
1265    
1266    void stub_glGetProgramStringARB(GLenum target, GLenum pname, GLvoid *string);
1267    void (* _glGetProgramStringARB)(GLenum target, GLenum pname, GLvoid *string) = &stub_glGetProgramStringARB;
1268    void stub_glGetProgramStringARB(GLenum target, GLenum pname, GLvoid *string) {
1269       if (getExtendedProcAddress("glGetProgramStringARB") == NULL) {
1270          return GL_kludge_error_void("glGetProgramStringARB");
1271       }
1272       _glGetProgramStringARB = (void (*)(GLenum , GLenum , GLvoid *))getExtendedProcAddress("glGetProgramStringARB");
1273       return _glGetProgramStringARB(target , pname , string);
1274    }
1275    
1276  void stub_glGetProgramStringNV(GLuint id, GLenum pname, GLubyte *program);  void stub_glGetProgramStringNV(GLuint id, GLenum pname, GLubyte *program);
1277  void (* _glGetProgramStringNV)(GLuint id, GLenum pname, GLubyte *program) = &stub_glGetProgramStringNV;  void (* _glGetProgramStringNV)(GLuint id, GLenum pname, GLubyte *program) = &stub_glGetProgramStringNV;
1278  void stub_glGetProgramStringNV(GLuint id, GLenum pname, GLubyte *program) {  void stub_glGetProgramStringNV(GLuint id, GLenum pname, GLubyte *program) {
# Line 1153  void stub_glGetProgramStringNV(GLuint id Line 1283  void stub_glGetProgramStringNV(GLuint id
1283     return _glGetProgramStringNV(id , pname , program);     return _glGetProgramStringNV(id , pname , program);
1284  }  }
1285    
1286    void stub_glGetProgramivARB(GLenum target, GLenum pname, GLint *params);
1287    void (* _glGetProgramivARB)(GLenum target, GLenum pname, GLint *params) = &stub_glGetProgramivARB;
1288    void stub_glGetProgramivARB(GLenum target, GLenum pname, GLint *params) {
1289       if (getExtendedProcAddress("glGetProgramivARB") == NULL) {
1290          return GL_kludge_error_void("glGetProgramivARB");
1291       }
1292       _glGetProgramivARB = (void (*)(GLenum , GLenum , GLint *))getExtendedProcAddress("glGetProgramivARB");
1293       return _glGetProgramivARB(target , pname , params);
1294    }
1295    
1296  void stub_glGetProgramivNV(GLuint id, GLenum pname, GLint *params);  void stub_glGetProgramivNV(GLuint id, GLenum pname, GLint *params);
1297  void (* _glGetProgramivNV)(GLuint id, GLenum pname, GLint *params) = &stub_glGetProgramivNV;  void (* _glGetProgramivNV)(GLuint id, GLenum pname, GLint *params) = &stub_glGetProgramivNV;
1298  void stub_glGetProgramivNV(GLuint id, GLenum pname, GLint *params) {  void stub_glGetProgramivNV(GLuint id, GLenum pname, GLint *params) {
# Line 1193  void stub_glGetTrackMatrixivNV(GLenum ta Line 1333  void stub_glGetTrackMatrixivNV(GLenum ta
1333     return _glGetTrackMatrixivNV(target , address , pname , params);     return _glGetTrackMatrixivNV(target , address , pname , params);
1334  }  }
1335    
1336    void stub_glGetVertexAttribPointervARB(GLuint index, GLenum pname, GLvoid* *pointer);
1337    void (* _glGetVertexAttribPointervARB)(GLuint index, GLenum pname, GLvoid* *pointer) = &stub_glGetVertexAttribPointervARB;
1338    void stub_glGetVertexAttribPointervARB(GLuint index, GLenum pname, GLvoid* *pointer) {
1339       if (getExtendedProcAddress("glGetVertexAttribPointervARB") == NULL) {
1340          return GL_kludge_error_void("glGetVertexAttribPointervARB");
1341       }
1342       _glGetVertexAttribPointervARB = (void (*)(GLuint , GLenum , GLvoid * *))getExtendedProcAddress("glGetVertexAttribPointervARB");
1343       return _glGetVertexAttribPointervARB(index , pname , pointer);
1344    }
1345    
1346  void stub_glGetVertexAttribPointervNV(GLuint index, GLenum pname, GLvoid* *pointer);  void stub_glGetVertexAttribPointervNV(GLuint index, GLenum pname, GLvoid* *pointer);
1347  void (* _glGetVertexAttribPointervNV)(GLuint index, GLenum pname, GLvoid* *pointer) = &stub_glGetVertexAttribPointervNV;  void (* _glGetVertexAttribPointervNV)(GLuint index, GLenum pname, GLvoid* *pointer) = &stub_glGetVertexAttribPointervNV;
1348  void stub_glGetVertexAttribPointervNV(GLuint index, GLenum pname, GLvoid* *pointer) {  void stub_glGetVertexAttribPointervNV(GLuint index, GLenum pname, GLvoid* *pointer) {
# Line 1203  void stub_glGetVertexAttribPointervNV(GL Line 1353  void stub_glGetVertexAttribPointervNV(GL
1353     return _glGetVertexAttribPointervNV(index , pname , pointer);     return _glGetVertexAttribPointervNV(index , pname , pointer);
1354  }  }
1355    
1356    void stub_glGetVertexAttribdvARB(GLuint index, GLenum pname, GLdouble *params);
1357    void (* _glGetVertexAttribdvARB)(GLuint index, GLenum pname, GLdouble *params) = &stub_glGetVertexAttribdvARB;
1358    void stub_glGetVertexAttribdvARB(GLuint index, GLenum pname, GLdouble *params) {
1359       if (getExtendedProcAddress("glGetVertexAttribdvARB") == NULL) {
1360          return GL_kludge_error_void("glGetVertexAttribdvARB");
1361       }
1362       _glGetVertexAttribdvARB = (void (*)(GLuint , GLenum , GLdouble *))getExtendedProcAddress("glGetVertexAttribdvARB");
1363       return _glGetVertexAttribdvARB(index , pname , params);
1364    }
1365    
1366  void stub_glGetVertexAttribdvNV(GLuint index, GLenum pname, GLdouble *params);  void stub_glGetVertexAttribdvNV(GLuint index, GLenum pname, GLdouble *params);
1367  void (* _glGetVertexAttribdvNV)(GLuint index, GLenum pname, GLdouble *params) = &stub_glGetVertexAttribdvNV;  void (* _glGetVertexAttribdvNV)(GLuint index, GLenum pname, GLdouble *params) = &stub_glGetVertexAttribdvNV;
1368  void stub_glGetVertexAttribdvNV(GLuint index, GLenum pname, GLdouble *params) {  void stub_glGetVertexAttribdvNV(GLuint index, GLenum pname, GLdouble *params) {
# Line 1213  void stub_glGetVertexAttribdvNV(GLuint i Line 1373  void stub_glGetVertexAttribdvNV(GLuint i
1373     return _glGetVertexAttribdvNV(index , pname , params);     return _glGetVertexAttribdvNV(index , pname , params);
1374  }  }
1375    
1376    void stub_glGetVertexAttribfvARB(GLuint index, GLenum pname, GLfloat *params);
1377    void (* _glGetVertexAttribfvARB)(GLuint index, GLenum pname, GLfloat *params) = &stub_glGetVertexAttribfvARB;
1378    void stub_glGetVertexAttribfvARB(GLuint index, GLenum pname, GLfloat *params) {
1379       if (getExtendedProcAddress("glGetVertexAttribfvARB") == NULL) {
1380          return GL_kludge_error_void("glGetVertexAttribfvARB");
1381       }
1382       _glGetVertexAttribfvARB = (void (*)(GLuint , GLenum , GLfloat *))getExtendedProcAddress("glGetVertexAttribfvARB");
1383       return _glGetVertexAttribfvARB(index , pname , params);
1384    }
1385    
1386  void stub_glGetVertexAttribfvNV(GLuint index, GLenum pname, GLfloat *params);  void stub_glGetVertexAttribfvNV(GLuint index, GLenum pname, GLfloat *params);
1387  void (* _glGetVertexAttribfvNV)(GLuint index, GLenum pname, GLfloat *params) = &stub_glGetVertexAttribfvNV;  void (* _glGetVertexAttribfvNV)(GLuint index, GLenum pname, GLfloat *params) = &stub_glGetVertexAttribfvNV;
1388  void stub_glGetVertexAttribfvNV(GLuint index, GLenum pname, GLfloat *params) {  void stub_glGetVertexAttribfvNV(GLuint index, GLenum pname, GLfloat *params) {
# Line 1223  void stub_glGetVertexAttribfvNV(GLuint i Line 1393  void stub_glGetVertexAttribfvNV(GLuint i
1393     return _glGetVertexAttribfvNV(index , pname , params);     return _glGetVertexAttribfvNV(index , pname , params);
1394  }  }
1395    
1396    void stub_glGetVertexAttribivARB(GLuint index, GLenum pname, GLint *params);
1397    void (* _glGetVertexAttribivARB)(GLuint index, GLenum pname, GLint *params) = &stub_glGetVertexAttribivARB;
1398    void stub_glGetVertexAttribivARB(GLuint index, GLenum pname, GLint *params) {
1399       if (getExtendedProcAddress("glGetVertexAttribivARB") == NULL) {
1400          return GL_kludge_error_void("glGetVertexAttribivARB");
1401       }
1402       _glGetVertexAttribivARB = (void (*)(GLuint , GLenum , GLint *))getExtendedProcAddress("glGetVertexAttribivARB");
1403       return _glGetVertexAttribivARB(index , pname , params);
1404    }
1405    
1406  void stub_glGetVertexAttribivNV(GLuint index, GLenum pname, GLint *params);  void stub_glGetVertexAttribivNV(GLuint index, GLenum pname, GLint *params);
1407  void (* _glGetVertexAttribivNV)(GLuint index, GLenum pname, GLint *params) = &stub_glGetVertexAttribivNV;  void (* _glGetVertexAttribivNV)(GLuint index, GLenum pname, GLint *params) = &stub_glGetVertexAttribivNV;
1408  void stub_glGetVertexAttribivNV(GLuint index, GLenum pname, GLint *params) {  void stub_glGetVertexAttribivNV(GLuint index, GLenum pname, GLint *params) {
# Line 1273  GLboolean stub_glIsOcclusionQueryNV(GLui Line 1453  GLboolean stub_glIsOcclusionQueryNV(GLui
1453     return _glIsOcclusionQueryNV(id);     return _glIsOcclusionQueryNV(id);
1454  }  }
1455    
1456    GLboolean stub_glIsProgramARB(GLuint program);
1457    GLboolean (* _glIsProgramARB)(GLuint program) = &stub_glIsProgramARB;
1458    GLboolean stub_glIsProgramARB(GLuint program) {
1459       if (getExtendedProcAddress("glIsProgramARB") == NULL) {
1460          return GL_kludge_error_GLboolean("glIsProgramARB");
1461       }
1462       _glIsProgramARB = (GLboolean (*)(GLuint))getExtendedProcAddress("glIsProgramARB");
1463       return _glIsProgramARB(program);
1464    }
1465    
1466  GLboolean stub_glIsProgramNV(GLuint id);  GLboolean stub_glIsProgramNV(GLuint id);
1467  GLboolean (* _glIsProgramNV)(GLuint id) = &stub_glIsProgramNV;  GLboolean (* _glIsProgramNV)(GLuint id) = &stub_glIsProgramNV;
1468  GLboolean stub_glIsProgramNV(GLuint id) {  GLboolean stub_glIsProgramNV(GLuint id) {
# Line 1333  void stub_glLockArraysEXT(GLint first, G Line 1523  void stub_glLockArraysEXT(GLint first, G
1523     return _glLockArraysEXT(first , count);     return _glLockArraysEXT(first , count);
1524  }  }
1525    
 void stub_glMapControlPointsNV(GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, GLboolean packed, const GLvoid *points);  
 void (* _glMapControlPointsNV)(GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, GLboolean packed, const GLvoid *points) = &stub_glMapControlPointsNV;  
 void stub_glMapControlPointsNV(GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, GLboolean packed, const GLvoid *points) {  
    if (getExtendedProcAddress("glMapControlPointsNV") == NULL) {  
       return GL_kludge_error_void("glMapControlPointsNV");  
    }  
    _glMapControlPointsNV = (void (*)(GLenum , GLuint , GLenum , GLsizei , GLsizei , GLint , GLint , GLboolean , const GLvoid *))getExtendedProcAddress("glMapControlPointsNV");  
    return _glMapControlPointsNV(target , index , type , ustride , vstride , uorder , vorder , packed , points);  
 }  
   
 void stub_glMapParameterfvNV(GLenum target, GLenum pname, const GLfloat *params);  
 void (* _glMapParameterfvNV)(GLenum target, GLenum pname, const GLfloat *params) = &stub_glMapParameterfvNV;  
 void stub_glMapParameterfvNV(GLenum target, GLenum pname, const GLfloat *params) {  
    if (getExtendedProcAddress("glMapParameterfvNV") == NULL) {  
       return GL_kludge_error_void("glMapParameterfvNV");  
    }  
    _glMapParameterfvNV = (void (*)(GLenum , GLenum , const GLfloat *))getExtendedProcAddress("glMapParameterfvNV");  
    return _glMapParameterfvNV(target , pname , params);  
 }  
   
 void stub_glMapParameterivNV(GLenum target, GLenum pname, const GLint *params);  
 void (* _glMapParameterivNV)(GLenum target, GLenum pname, const GLint *params) = &stub_glMapParameterivNV;  
 void stub_glMapParameterivNV(GLenum target, GLenum pname, const GLint *params) {  
    if (getExtendedProcAddress("glMapParameterivNV") == NULL) {  
       return GL_kludge_error_void("glMapParameterivNV");  
    }  
    _glMapParameterivNV = (void (*)(GLenum , GLenum , const GLint *))getExtendedProcAddress("glMapParameterivNV");  
    return _glMapParameterivNV(target , pname , params);  
 }  
   
1526  void stub_glMinmax(GLenum target, GLenum internalformat, GLboolean sink);  void stub_glMinmax(GLenum target, GLenum internalformat, GLboolean sink);
1527  void (* _glMinmax)(GLenum target, GLenum internalformat, GLboolean sink) = &stub_glMinmax;  void (* _glMinmax)(GLenum target, GLenum internalformat, GLboolean sink) = &stub_glMinmax;
1528  void stub_glMinmax(GLenum target, GLenum internalformat, GLboolean sink) {  void stub_glMinmax(GLenum target, GLenum internalformat, GLboolean sink) {
# Line 1393  void stub_glMultTransposeMatrixfARB(cons Line 1553  void stub_glMultTransposeMatrixfARB(cons
1553     return _glMultTransposeMatrixfARB(m);     return _glMultTransposeMatrixfARB(m);
1554  }  }
1555    
1556    void stub_glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount);
1557    void (* _glMultiDrawArrays)(GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount) = &stub_glMultiDrawArrays;
1558    void stub_glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount) {
1559       if (getExtendedProcAddress("glMultiDrawArrays") == NULL) {
1560          return GL_kludge_error_void("glMultiDrawArrays");
1561       }
1562       _glMultiDrawArrays = (void (*)(GLenum , const GLint * , const GLsizei * , GLsizei))getExtendedProcAddress("glMultiDrawArrays");
1563       return _glMultiDrawArrays(mode , first , count , primcount);
1564    }
1565    
1566  void stub_glMultiDrawArraysEXT(GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount);  void stub_glMultiDrawArraysEXT(GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount);
1567  void (* _glMultiDrawArraysEXT)(GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount) = &stub_glMultiDrawArraysEXT;  void (* _glMultiDrawArraysEXT)(GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount) = &stub_glMultiDrawArraysEXT;
1568  void stub_glMultiDrawArraysEXT(GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount) {  void stub_glMultiDrawArraysEXT(GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount) {
# Line 1403  void stub_glMultiDrawArraysEXT(GLenum mo Line 1573  void stub_glMultiDrawArraysEXT(GLenum mo
1573     return _glMultiDrawArraysEXT(mode , first , count , primcount);     return _glMultiDrawArraysEXT(mode , first , count , primcount);
1574  }  }
1575    
1576    void stub_glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount);
1577    void (* _glMultiDrawElements)(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount) = &stub_glMultiDrawElements;
1578    void stub_glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount) {
1579       if (getExtendedProcAddress("glMultiDrawElements") == NULL) {
1580          return GL_kludge_error_void("glMultiDrawElements");
1581       }
1582       _glMultiDrawElements = (void (*)(GLenum , const GLsizei * , GLenum , const GLvoid * * , GLsizei))getExtendedProcAddress("glMultiDrawElements");
1583       return _glMultiDrawElements(mode , count , type , indices , primcount);
1584    }
1585    
1586  void stub_glMultiDrawElementsEXT(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount);  void stub_glMultiDrawElementsEXT(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount);
1587  void (* _glMultiDrawElementsEXT)(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount) = &stub_glMultiDrawElementsEXT;  void (* _glMultiDrawElementsEXT)(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount) = &stub_glMultiDrawElementsEXT;
1588  void stub_glMultiDrawElementsEXT(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount) {  void stub_glMultiDrawElementsEXT(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount) {
# Line 2083  void stub_glPixelDataRangeNV(GLenum targ Line 2263  void stub_glPixelDataRangeNV(GLenum targ
2263     return _glPixelDataRangeNV(target , size , pointer);     return _glPixelDataRangeNV(target , size , pointer);
2264  }  }
2265    
2266    void stub_glPointParameterfARB(GLenum pname, GLfloat param);
2267    void (* _glPointParameterfARB)(GLenum pname, GLfloat param) = &stub_glPointParameterfARB;
2268    void stub_glPointParameterfARB(GLenum pname, GLfloat param) {
2269       if (getExtendedProcAddress("glPointParameterfARB") == NULL) {
2270          return GL_kludge_error_void("glPointParameterfARB");
2271       }
2272       _glPointParameterfARB = (void (*)(GLenum , GLfloat))getExtendedProcAddress("glPointParameterfARB");
2273       return _glPointParameterfARB(pname , param);
2274    }
2275    
2276  void stub_glPointParameterfEXT(GLenum pname, GLfloat param);  void stub_glPointParameterfEXT(GLenum pname, GLfloat param);
2277  void (* _glPointParameterfEXT)(GLenum pname, GLfloat param) = &stub_glPointParameterfEXT;  void (* _glPointParameterfEXT)(GLenum pname, GLfloat param) = &stub_glPointParameterfEXT;
2278  void stub_glPointParameterfEXT(GLenum pname, GLfloat param) {  void stub_glPointParameterfEXT(GLenum pname, GLfloat param) {
# Line 2093  void stub_glPointParameterfEXT(GLenum pn Line 2283  void stub_glPointParameterfEXT(GLenum pn
2283     return _glPointParameterfEXT(pname , param);     return _glPointParameterfEXT(pname , param);
2284  }  }
2285    
2286    void stub_glPointParameterfvARB(GLenum pname, const GLfloat *params);
2287    void (* _glPointParameterfvARB)(GLenum pname, const GLfloat *params) = &stub_glPointParameterfvARB;
2288    void stub_glPointParameterfvARB(GLenum pname, const GLfloat *params) {
2289       if (getExtendedProcAddress("glPointParameterfvARB") == NULL) {
2290          return GL_kludge_error_void("glPointParameterfvARB");
2291       }
2292       _glPointParameterfvARB = (void (*)(GLenum , const GLfloat *))getExtendedProcAddress("glPointParameterfvARB");
2293       return _glPointParameterfvARB(pname , params);
2294    }
2295    
2296  void stub_glPointParameterfvEXT(GLenum pname, const GLfloat *params);  void stub_glPointParameterfvEXT(GLenum pname, const GLfloat *params);
2297  void (* _glPointParameterfvEXT)(GLenum pname, const GLfloat *params) = &stub_glPointParameterfvEXT;  void (* _glPointParameterfvEXT)(GLenum pname, const GLfloat *params) = &stub_glPointParameterfvEXT;
2298  void stub_glPointParameterfvEXT(GLenum pname, const GLfloat *params) {  void stub_glPointParameterfvEXT(GLenum pname, const GLfloat *params) {
# Line 2103  void stub_glPointParameterfvEXT(GLenum p Line 2303  void stub_glPointParameterfvEXT(GLenum p
2303     return _glPointParameterfvEXT(pname , params);     return _glPointParameterfvEXT(pname , params);
2304  }  }
2305    
2306    void stub_glPointParameteri(GLenum pname, GLint param);
2307    void (* _glPointParameteri)(GLenum pname, GLint param) = &stub_glPointParameteri;
2308    void stub_glPointParameteri(GLenum pname, GLint param) {
2309       if (getExtendedProcAddress("glPointParameteri") == NULL) {
2310          return GL_kludge_error_void("glPointParameteri");
2311       }
2312       _glPointParameteri = (void (*)(GLenum , GLint))getExtendedProcAddress("glPointParameteri");
2313       return _glPointParameteri(pname , param);
2314    }
2315    
2316  void stub_glPointParameteriNV(GLenum pname, GLint param);  void stub_glPointParameteriNV(GLenum pname, GLint param);
2317  void (* _glPointParameteriNV)(GLenum pname, GLint param) = &stub_glPointParameteriNV;  void (* _glPointParameteriNV)(GLenum pname, GLint param) = &stub_glPointParameteriNV;
2318  void stub_glPointParameteriNV(GLenum pname, GLint param) {  void stub_glPointParameteriNV(GLenum pname, GLint param) {
# Line 2113  void stub_glPointParameteriNV(GLenum pna Line 2323  void stub_glPointParameteriNV(GLenum pna
2323     return _glPointParameteriNV(pname , param);     return _glPointParameteriNV(pname , param);
2324  }  }
2325    
2326    void stub_glPointParameteriv(GLenum pname, const GLint *params);
2327    void (* _glPointParameteriv)(GLenum pname, const GLint *params) = &stub_glPointParameteriv;
2328    void stub_glPointParameteriv(GLenum pname, const GLint *params) {
2329       if (getExtendedProcAddress("glPointParameteriv") == NULL) {
2330          return GL_kludge_error_void("glPointParameteriv");
2331       }
2332       _glPointParameteriv = (void (*)(GLenum , const GLint *))getExtendedProcAddress("glPointParameteriv");
2333       return _glPointParameteriv(pname , params);
2334    }
2335    
2336  void stub_glPointParameterivNV(GLenum pname, const GLint *params);  void stub_glPointParameterivNV(GLenum pname, const GLint *params);
2337  void (* _glPointParameterivNV)(GLenum pname, const GLint *params) = &stub_glPointParameterivNV;  void (* _glPointParameterivNV)(GLenum pname, const GLint *params) = &stub_glPointParameterivNV;
2338  void stub_glPointParameterivNV(GLenum pname, const GLint *params) {  void stub_glPointParameterivNV(GLenum pname, const GLint *params) {
# Line 2123  void stub_glPointParameterivNV(GLenum pn Line 2343  void stub_glPointParameterivNV(GLenum pn
2343     return _glPointParameterivNV(pname , params);     return _glPointParameterivNV(pname , params);
2344  }  }
2345    
2346    void stub_glPrimitiveRestartIndexNV(GLuint index);
2347    void (* _glPrimitiveRestartIndexNV)(GLuint index) = &stub_glPrimitiveRestartIndexNV;
2348    void stub_glPrimitiveRestartIndexNV(GLuint index) {
2349       if (getExtendedProcAddress("glPrimitiveRestartIndexNV") == NULL) {
2350          return GL_kludge_error_void("glPrimitiveRestartIndexNV");
2351       }
2352       _glPrimitiveRestartIndexNV = (void (*)(GLuint))getExtendedProcAddress("glPrimitiveRestartIndexNV");
2353       return _glPrimitiveRestartIndexNV(index);
2354    }
2355    
2356    void stub_glPrimitiveRestartNV(void);
2357    void (* _glPrimitiveRestartNV)(void) = &stub_glPrimitiveRestartNV;
2358    void stub_glPrimitiveRestartNV(void) {
2359       if (getExtendedProcAddress("glPrimitiveRestartNV") == NULL) {
2360          return GL_kludge_error_void("glPrimitiveRestartNV");
2361       }
2362       _glPrimitiveRestartNV = (void (*)())getExtendedProcAddress("glPrimitiveRestartNV");
2363       return _glPrimitiveRestartNV();
2364    }
2365    
2366  void stub_glPrioritizeTexturesEXT(GLsizei n, const GLuint *textures, const GLclampf *priorities);  void stub_glPrioritizeTexturesEXT(GLsizei n, const GLuint *textures, const GLclampf *priorities);
2367  void (* _glPrioritizeTexturesEXT)(GLsizei n, const GLuint *textures, const GLclampf *priorities) = &stub_glPrioritizeTexturesEXT;  void (* _glPrioritizeTexturesEXT)(GLsizei n, const GLuint *textures, const GLclampf *priorities) = &stub_glPrioritizeTexturesEXT;
2368  void stub_glPrioritizeTexturesEXT(GLsizei n, const GLuint *textures, const GLclampf *priorities) {  void stub_glPrioritizeTexturesEXT(GLsizei n, const GLuint *textures, const GLclampf *priorities) {
# Line 2133  void stub_glPrioritizeTexturesEXT(GLsize Line 2373  void stub_glPrioritizeTexturesEXT(GLsize
2373     return _glPrioritizeTexturesEXT(n , textures , priorities);     return _glPrioritizeTexturesEXT(n , textures , priorities);
2374  }  }
2375    
2376    void stub_glProgramEnvParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
2377    void (* _glProgramEnvParameter4dARB)(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) = &stub_glProgramEnvParameter4dARB;
2378    void stub_glProgramEnvParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) {
2379       if (getExtendedProcAddress("glProgramEnvParameter4dARB") == NULL) {
2380          return GL_kludge_error_void("glProgramEnvParameter4dARB");
2381       }
2382       _glProgramEnvParameter4dARB = (void (*)(GLenum , GLuint , GLdouble , GLdouble , GLdouble , GLdouble))getExtendedProcAddress("glProgramEnvParameter4dARB");
2383       return _glProgramEnvParameter4dARB(target , index , x , y , z , w);
2384    }
2385    
2386    void stub_glProgramEnvParameter4dvARB(GLenum target, GLuint index, const GLdouble *params);
2387    void (* _glProgramEnvParameter4dvARB)(GLenum target, GLuint index, const GLdouble *params) = &stub_glProgramEnvParameter4dvARB;
2388    void stub_glProgramEnvParameter4dvARB(GLenum target, GLuint index, const GLdouble *params) {
2389       if (getExtendedProcAddress("glProgramEnvParameter4dvARB") == NULL) {
2390          return GL_kludge_error_void("glProgramEnvParameter4dvARB");
2391       }
2392       _glProgramEnvParameter4dvARB = (void (*)(GLenum , GLuint , const GLdouble *))getExtendedProcAddress("glProgramEnvParameter4dvARB");
2393       return _glProgramEnvParameter4dvARB(target , index , params);
2394    }
2395    
2396    void stub_glProgramEnvParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
2397    void (* _glProgramEnvParameter4fARB)(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) = &stub_glProgramEnvParameter4fARB;
2398    void stub_glProgramEnvParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
2399       if (getExtendedProcAddress("glProgramEnvParameter4fARB") == NULL) {
2400          return GL_kludge_error_void("glProgramEnvParameter4fARB");
2401       }
2402       _glProgramEnvParameter4fARB = (void (*)(GLenum , GLuint , GLfloat , GLfloat , GLfloat , GLfloat))getExtendedProcAddress("glProgramEnvParameter4fARB");
2403       return _glProgramEnvParameter4fARB(target , index , x , y , z , w);
2404    }
2405    
2406    void stub_glProgramEnvParameter4fvARB(GLenum target, GLuint index, const GLfloat *params);
2407    void (* _glProgramEnvParameter4fvARB)(GLenum target, GLuint index, const GLfloat *params) = &stub_glProgramEnvParameter4fvARB;
2408    void stub_glProgramEnvParameter4fvARB(GLenum target, GLuint index, const GLfloat *params) {
2409       if (getExtendedProcAddress("glProgramEnvParameter4fvARB") == NULL) {
2410          return GL_kludge_error_void("glProgramEnvParameter4fvARB");
2411       }
2412       _glProgramEnvParameter4fvARB = (void (*)(GLenum , GLuint , const GLfloat *))getExtendedProcAddress("glProgramEnvParameter4fvARB");
2413       return _glProgramEnvParameter4fvARB(target , index , params);
2414    }
2415    
2416    void stub_glProgramLocalParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
2417    void (* _glProgramLocalParameter4dARB)(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) = &stub_glProgramLocalParameter4dARB;
2418    void stub_glProgramLocalParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) {
2419       if (getExtendedProcAddress("glProgramLocalParameter4dARB") == NULL) {
2420          return GL_kludge_error_void("glProgramLocalParameter4dARB");
2421       }
2422       _glProgramLocalParameter4dARB = (void (*)(GLenum , GLuint , GLdouble , GLdouble , GLdouble , GLdouble))getExtendedProcAddress("glProgramLocalParameter4dARB");
2423       return _glProgramLocalParameter4dARB(target , index , x , y , z , w);
2424    }
2425    
2426    void stub_glProgramLocalParameter4dvARB(GLenum target, GLuint index, const GLdouble *params);
2427    void (* _glProgramLocalParameter4dvARB)(GLenum target, GLuint index, const GLdouble *params) = &stub_glProgramLocalParameter4dvARB;
2428    void stub_glProgramLocalParameter4dvARB(GLenum target, GLuint index, const GLdouble *params) {
2429       if (getExtendedProcAddress("glProgramLocalParameter4dvARB") == NULL) {
2430          return GL_kludge_error_void("glProgramLocalParameter4dvARB");
2431       }
2432       _glProgramLocalParameter4dvARB = (void (*)(GLenum , GLuint , const GLdouble *))getExtendedProcAddress("glProgramLocalParameter4dvARB");
2433       return _glProgramLocalParameter4dvARB(target , index , params);
2434    }
2435    
2436    void stub_glProgramLocalParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
2437    void (* _glProgramLocalParameter4fARB)(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) = &stub_glProgramLocalParameter4fARB;
2438    void stub_glProgramLocalParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
2439       if (getExtendedProcAddress("glProgramLocalParameter4fARB") == NULL) {
2440          return GL_kludge_error_void("glProgramLocalParameter4fARB");
2441       }
2442       _glProgramLocalParameter4fARB = (void (*)(GLenum , GLuint , GLfloat , GLfloat , GLfloat , GLfloat))getExtendedProcAddress("glProgramLocalParameter4fARB");
2443       return _glProgramLocalParameter4fARB(target , index , x , y , z , w);
2444    }
2445    
2446    void stub_glProgramLocalParameter4fvARB(GLenum target, GLuint index, const GLfloat *params);
2447    void (* _glProgramLocalParameter4fvARB)(GLenum target, GLuint index, const GLfloat *params) = &stub_glProgramLocalParameter4fvARB;
2448    void stub_glProgramLocalParameter4fvARB(GLenum target, GLuint index, const GLfloat *params) {
2449       if (getExtendedProcAddress("glProgramLocalParameter4fvARB") == NULL) {
2450          return GL_kludge_error_void("glProgramLocalParameter4fvARB");
2451       }
2452       _glProgramLocalParameter4fvARB = (void (*)(GLenum , GLuint , const GLfloat *))getExtendedProcAddress("glProgramLocalParameter4fvARB");
2453       return _glProgramLocalParameter4fvARB(target , index , params);
2454    }
2455    
2456    void stub_glProgramNamedParameter4dNV(GLuint id, GLsizei len, const GLubyte *name, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
2457    void (* _glProgramNamedParameter4dNV)(GLuint id, GLsizei len, const GLubyte *name, GLdouble x, GLdouble y, GLdouble z, GLdouble w) = &stub_glProgramNamedParameter4dNV;
2458    void stub_glProgramNamedParameter4dNV(GLuint id, GLsizei len, const GLubyte *name, GLdouble x, GLdouble y, GLdouble z, GLdouble w) {
2459       if (getExtendedProcAddress("glProgramNamedParameter4dNV") == NULL) {
2460          return GL_kludge_error_void("glProgramNamedParameter4dNV");
2461       }
2462       _glProgramNamedParameter4dNV = (void (*)(GLuint , GLsizei , const GLubyte * , GLdouble , GLdouble , GLdouble , GLdouble))getExtendedProcAddress("glProgramNamedParameter4dNV");
2463       return _glProgramNamedParameter4dNV(id , len , name , x , y , z , w);
2464    }
2465    
2466    void stub_glProgramNamedParameter4dvNV(GLuint id, GLsizei len, const GLubyte *name, const GLdouble *v);
2467    void (* _glProgramNamedParameter4dvNV)(GLuint id, GLsizei len, const GLubyte *name, const GLdouble *v) = &stub_glProgramNamedParameter4dvNV;
2468    void stub_glProgramNamedParameter4dvNV(GLuint id, GLsizei len, const GLubyte *name, const GLdouble *v) {
2469       if (getExtendedProcAddress("glProgramNamedParameter4dvNV") == NULL) {
2470          return GL_kludge_error_void("glProgramNamedParameter4dvNV");
2471       }
2472       _glProgramNamedParameter4dvNV = (void (*)(GLuint , GLsizei , const GLubyte * , const GLdouble *))getExtendedProcAddress("glProgramNamedParameter4dvNV");
2473       return _glProgramNamedParameter4dvNV(id , len , name , v);
2474    }
2475    
2476    void stub_glProgramNamedParameter4fNV(GLuint id, GLsizei len, const GLubyte *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
2477    void (* _glProgramNamedParameter4fNV)(GLuint id, GLsizei len, const GLubyte *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w) = &stub_glProgramNamedParameter4fNV;
2478    void stub_glProgramNamedParameter4fNV(GLuint id, GLsizei len, const GLubyte *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
2479       if (getExtendedProcAddress("glProgramNamedParameter4fNV") == NULL) {
2480          return GL_kludge_error_void("glProgramNamedParameter4fNV");
2481       }
2482       _glProgramNamedParameter4fNV = (void (*)(GLuint , GLsizei , const GLubyte * , GLfloat , GLfloat , GLfloat , GLfloat))getExtendedProcAddress("glProgramNamedParameter4fNV");
2483       return _glProgramNamedParameter4fNV(id , len , name , x , y , z , w);
2484    }
2485    
2486    void stub_glProgramNamedParameter4fvNV(GLuint id, GLsizei len, const GLubyte *name, const GLfloat *v);
2487    void (* _glProgramNamedParameter4fvNV)(GLuint id, GLsizei len, const GLubyte *name, const GLfloat *v) = &stub_glProgramNamedParameter4fvNV;
2488    void stub_glProgramNamedParameter4fvNV(GLuint id, GLsizei len, const GLubyte *name, const GLfloat *v) {
2489       if (getExtendedProcAddress("glProgramNamedParameter4fvNV") == NULL) {
2490          return GL_kludge_error_void("glProgramNamedParameter4fvNV");
2491       }
2492       _glProgramNamedParameter4fvNV = (void (*)(GLuint , GLsizei , const GLubyte * , const GLfloat *))getExtendedProcAddress("glProgramNamedParameter4fvNV");
2493       return _glProgramNamedParameter4fvNV(id , len , name , v);
2494    }
2495    
2496  void stub_glProgramParameter4dNV(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);  void stub_glProgramParameter4dNV(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
2497  void (* _glProgramParameter4dNV)(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) = &stub_glProgramParameter4dNV;  void (* _glProgramParameter4dNV)(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) = &stub_glProgramParameter4dNV;
2498  void stub_glProgramParameter4dNV(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) {  void stub_glProgramParameter4dNV(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) {
# Line 2173  void stub_glProgramParameter4fvNV(GLenum Line 2533  void stub_glProgramParameter4fvNV(GLenum
2533     return _glProgramParameter4fvNV(target , index , v);     return _glProgramParameter4fvNV(target , index , v);
2534  }  }
2535    
 void stub_glProgramParameterSigned4dNV(GLenum target, GLint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);  
 void (* _glProgramParameterSigned4dNV)(GLenum target, GLint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) = &stub_glProgramParameterSigned4dNV;  
 void stub_glProgramParameterSigned4dNV(GLenum target, GLint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) {  
    if (getExtendedProcAddress("glProgramParameterSigned4dNV") == NULL) {  
       return GL_kludge_error_void("glProgramParameterSigned4dNV");  
    }  
    _glProgramParameterSigned4dNV = (void (*)(GLenum , GLint , GLdouble , GLdouble , GLdouble , GLdouble))getExtendedProcAddress("glProgramParameterSigned4dNV");  
    return _glProgramParameterSigned4dNV(target , index , x , y , z , w);  
 }  
   
 void stub_glProgramParameterSigned4dvNV(GLenum target, GLint index, const GLdouble *v);  
 void (* _glProgramParameterSigned4dvNV)(GLenum target, GLint index, const GLdouble *v) = &stub_glProgramParameterSigned4dvNV;  
 void stub_glProgramParameterSigned4dvNV(GLenum target, GLint index, const GLdouble *v) {  
    if (getExtendedProcAddress("glProgramParameterSigned4dvNV") == NULL) {  
       return GL_kludge_error_void("glProgramParameterSigned4dvNV");  
    }  
    _glProgramParameterSigned4dvNV = (void (*)(GLenum , GLint , const GLdouble *))getExtendedProcAddress("glProgramParameterSigned4dvNV");  
    return _glProgramParameterSigned4dvNV(target , index , v);  
 }  
   
 void stub_glProgramParameterSigned4fNV(GLenum target, GLint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);  
 void (* _glProgramParameterSigned4fNV)(GLenum target, GLint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) = &stub_glProgramParameterSigned4fNV;  
 void stub_glProgramParameterSigned4fNV(GLenum target, GLint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {  
    if (getExtendedProcAddress("glProgramParameterSigned4fNV") == NULL) {  
       return GL_kludge_error_void("glProgramParameterSigned4fNV");  
    }  
    _glProgramParameterSigned4fNV = (void (*)(GLenum , GLint , GLfloat , GLfloat , GLfloat , GLfloat))getExtendedProcAddress("glProgramParameterSigned4fNV");  
    return _glProgramParameterSigned4fNV(target , index , x , y , z , w);  
 }  
   
 void stub_glProgramParameterSigned4fvNV(GLenum target, GLint index, const GLfloat *v);  
 void (* _glProgramParameterSigned4fvNV)(GLenum target, GLint index, const GLfloat *v) = &stub_glProgramParameterSigned4fvNV;  
 void stub_glProgramParameterSigned4fvNV(GLenum target, GLint index, const GLfloat *v) {  
    if (getExtendedProcAddress("glProgramParameterSigned4fvNV") == NULL) {  
       return GL_kludge_error_void("glProgramParameterSigned4fvNV");  
    }  
    _glProgramParameterSigned4fvNV = (void (*)(GLenum , GLint , const GLfloat *))getExtendedProcAddress("glProgramParameterSigned4fvNV");  
    return _glProgramParameterSigned4fvNV(target , index , v);  
 }  
   
2536  void stub_glProgramParameters4dvNV(GLenum target, GLuint index, GLsizei count, const GLdouble *v);  void stub_glProgramParameters4dvNV(GLenum target, GLuint index, GLsizei count, const GLdouble *v);
2537  void (* _glProgramParameters4dvNV)(GLenum target, GLuint index, GLsizei count, const GLdouble *v) = &stub_glProgramParameters4dvNV;  void (* _glProgramParameters4dvNV)(GLenum target, GLuint index, GLsizei count, const GLdouble *v) = &stub_glProgramParameters4dvNV;
2538  void stub_glProgramParameters4dvNV(GLenum target, GLuint index, GLsizei count, const GLdouble *v) {  void stub_glProgramParameters4dvNV(GLenum target, GLuint index, GLsizei count, const GLdouble *v) {
# Line 2233  void stub_glProgramParameters4fvNV(GLenu Line 2553  void stub_glProgramParameters4fvNV(GLenu
2553     return _glProgramParameters4fvNV(target , index , count , v);     return _glProgramParameters4fvNV(target , index , count , v);
2554  }  }
2555    
2556  void stub_glProgramParametersSigned4dvNV(GLenum target, GLint index, GLsizei count, const GLdouble *v);  void stub_glProgramStringARB(GLenum target, GLenum format, GLsizei len, const GLvoid *string);
2557  void (* _glProgramParametersSigned4dvNV)(GLenum target, GLint index, GLsizei count, const GLdouble *v) = &stub_glProgramParametersSigned4dvNV;  void (* _glProgramStringARB)(GLenum target, GLenum format, GLsizei len, const GLvoid *string) = &stub_glProgramStringARB;
2558  void stub_glProgramParametersSigned4dvNV(GLenum target, GLint index, GLsizei count, const GLdouble *v) {  void stub_glProgramStringARB(GLenum target, GLenum format, GLsizei len, const GLvoid *string) {
2559     if (getExtendedProcAddress("glProgramParametersSigned4dvNV") == NULL) {     if (getExtendedProcAddress("glProgramStringARB") == NULL) {
2560        return GL_kludge_error_void("glProgramParametersSigned4dvNV");        return GL_kludge_error_void("glProgramStringARB");
2561     }     }
2562     _glProgramParametersSigned4dvNV = (void (*)(GLenum , GLint , GLsizei , const GLdouble *))getExtendedProcAddress("glProgramParametersSigned4dvNV");     _glProgramStringARB = (void (*)(GLenum , GLenum , GLsizei , const GLvoid *))getExtendedProcAddress("glProgramStringARB");
2563     return _glProgramParametersSigned4dvNV(target , index , count , v);     return _glProgramStringARB(target , format , len , string);
 }  
   
 void stub_glProgramParametersSigned4fvNV(GLenum target, GLint index, GLsizei count, const GLfloat *v);  
 void (* _glProgramParametersSigned4fvNV)(GLenum target, GLint index, GLsizei count, const GLfloat *v) = &stub_glProgramParametersSigned4fvNV;  
 void stub_glProgramParametersSigned4fvNV(GLenum target, GLint index, GLsizei count, const GLfloat *v) {  
    if (getExtendedProcAddress("glProgramParametersSigned4fvNV") == NULL) {  
       return GL_kludge_error_void("glProgramParametersSigned4fvNV");  
    }  
    _glProgramParametersSigned4fvNV = (void (*)(GLenum , GLint , GLsizei , const GLfloat *))getExtendedProcAddress("glProgramParametersSigned4fvNV");  
    return _glProgramParametersSigned4fvNV(target , index , count , v);  
2564  }  }
2565    
2566  GLenum stub_glReleaseFlushHold(const GLvoid *id);  GLenum stub_glReleaseFlushHold(GLuint id);
2567  GLenum (* _glReleaseFlushHold)(const GLvoid *id) = &stub_glReleaseFlushHold;  GLenum (* _glReleaseFlushHold)(GLuint id) = &stub_glReleaseFlushHold;
2568  GLenum stub_glReleaseFlushHold(const GLvoid *id) {  GLenum stub_glReleaseFlushHold(GLuint id) {
2569     if (getExtendedProcAddress("glReleaseFlushHold") == NULL) {     if (getExtendedProcAddress("glReleaseFlushHold") == NULL) {
2570        return GL_kludge_error_GLenum("glReleaseFlushHold");        return GL_kludge_error_GLenum("glReleaseFlushHold");
2571     }     }
2572     _glReleaseFlushHold = (GLenum (*)(const GLvoid *))getExtendedProcAddress("glReleaseFlushHold");     _glReleaseFlushHold = (GLenum (*)(GLuint))getExtendedProcAddress("glReleaseFlushHold");
2573     return _glReleaseFlushHold(id);     return _glReleaseFlushHold(id);
2574  }  }
2575    
# Line 2303  void stub_glSampleCoverageARB(GLclampf v Line 2613  void stub_glSampleCoverageARB(GLclampf v
2613     return _glSampleCoverageARB(value , invert);     return _glSampleCoverageARB(value , invert);
2614  }  }
2615    
2616    void stub_glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue);
2617    void (* _glSecondaryColor3b)(GLbyte red, GLbyte green, GLbyte blue) = &stub_glSecondaryColor3b;
2618    void stub_glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue) {
2619       if (getExtendedProcAddress("glSecondaryColor3b") == NULL) {
2620          return GL_kludge_error_void("glSecondaryColor3b");
2621       }
2622       _glSecondaryColor3b = (void (*)(GLbyte , GLbyte , GLbyte))getExtendedProcAddress("glSecondaryColor3b");
2623       return _glSecondaryColor3b(red , green , blue);
2624    }
2625    
2626  void stub_glSecondaryColor3bEXT(GLbyte red, GLbyte green, GLbyte blue);  void stub_glSecondaryColor3bEXT(GLbyte red, GLbyte green, GLbyte blue);
2627  void (* _glSecondaryColor3bEXT)(GLbyte red, GLbyte green, GLbyte blue) = &stub_glSecondaryColor3bEXT;  void (* _glSecondaryColor3bEXT)(GLbyte red, GLbyte green, GLbyte blue) = &stub_glSecondaryColor3bEXT;
2628  void stub_glSecondaryColor3bEXT(GLbyte red, GLbyte green, GLbyte blue) {  void stub_glSecondaryColor3bEXT(GLbyte red, GLbyte green, GLbyte blue) {
# Line 2313  void stub_glSecondaryColor3bEXT(GLbyte r Line 2633  void stub_glSecondaryColor3bEXT(GLbyte r
2633     return _glSecondaryColor3bEXT(red , green , blue);     return _glSecondaryColor3bEXT(red , green , blue);
2634  }  }
2635    
2636    void stub_glSecondaryColor3bv(const GLbyte *v);
2637    void (* _glSecondaryColor3bv)(const GLbyte *v) = &stub_glSecondaryColor3bv;
2638    void stub_glSecondaryColor3bv(const GLbyte *v) {
2639       if (getExtendedProcAddress("glSecondaryColor3bv") == NULL) {
2640          return GL_kludge_error_void("glSecondaryColor3bv");
2641       }
2642       _glSecondaryColor3bv = (void (*)(const GLbyte *))getExtendedProcAddress("glSecondaryColor3bv");
2643       return _glSecondaryColor3bv(v);
2644    }
2645    
2646  void stub_glSecondaryColor3bvEXT(const GLbyte *v);  void stub_glSecondaryColor3bvEXT(const GLbyte *v);
2647  void (* _glSecondaryColor3bvEXT)(const GLbyte *v) = &stub_glSecondaryColor3bvEXT;  void (* _glSecondaryColor3bvEXT)(const GLbyte *v) = &stub_glSecondaryColor3bvEXT;
2648  void stub_glSecondaryColor3bvEXT(const GLbyte *v) {  void stub_glSecondaryColor3bvEXT(const GLbyte *v) {
# Line 2323  void stub_glSecondaryColor3bvEXT(const G Line 2653  void stub_glSecondaryColor3bvEXT(const G
2653     return _glSecondaryColor3bvEXT(v);     return _glSecondaryColor3bvEXT(v);
2654  }  }
2655    
2656    void stub_glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue);
2657    void (* _glSecondaryColor3d)(GLdouble red, GLdouble green, GLdouble blue) = &stub_glSecondaryColor3d;
2658    void stub_glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue) {
2659       if (getExtendedProcAddress("glSecondaryColor3d") == NULL) {
2660          return GL_kludge_error_void("glSecondaryColor3d");
2661       }
2662       _glSecondaryColor3d = (void (*)(GLdouble , GLdouble , GLdouble))getExtendedProcAddress("glSecondaryColor3d");
2663       return _glSecondaryColor3d(red , green , blue);
2664    }
2665    
2666  void stub_glSecondaryColor3dEXT(GLdouble red, GLdouble green, GLdouble blue);  void stub_glSecondaryColor3dEXT(GLdouble red, GLdouble green, GLdouble blue);
2667  void (* _glSecondaryColor3dEXT)(GLdouble red, GLdouble green, GLdouble blue) = &stub_glSecondaryColor3dEXT;  void (* _glSecondaryColor3dEXT)(GLdouble red, GLdouble green, GLdouble blue) = &stub_glSecondaryColor3dEXT;
2668  void stub_glSecondaryColor3dEXT(GLdouble red, GLdouble green, GLdouble blue) {  void stub_glSecondaryColor3dEXT(GLdouble red, GLdouble green, GLdouble blue) {
# Line 2333  void stub_glSecondaryColor3dEXT(GLdouble Line 2673  void stub_glSecondaryColor3dEXT(GLdouble
2673     return _glSecondaryColor3dEXT(red , green , blue);     return _glSecondaryColor3dEXT(red , green , blue);
2674  }  }
2675    
2676    void stub_glSecondaryColor3dv(const GLdouble *v);
2677    void (* _glSecondaryColor3dv)(const GLdouble *v) = &stub_glSecondaryColor3dv;
2678    void stub_glSecondaryColor3dv(const GLdouble *v) {
2679       if (getExtendedProcAddress("glSecondaryColor3dv") == NULL) {
2680          return GL_kludge_error_void("glSecondaryColor3dv");
2681       }
2682       _glSecondaryColor3dv = (void (*)(const GLdouble *))getExtendedProcAddress("glSecondaryColor3dv");
2683       return _glSecondaryColor3dv(v);
2684    }
2685    
2686  void stub_glSecondaryColor3dvEXT(const GLdouble *v);  void stub_glSecondaryColor3dvEXT(const GLdouble *v);
2687  void (* _glSecondaryColor3dvEXT)(const GLdouble *v) = &stub_glSecondaryColor3dvEXT;  void (* _glSecondaryColor3dvEXT)(const GLdouble *v) = &stub_glSecondaryColor3dvEXT;
2688  void stub_glSecondaryColor3dvEXT(const GLdouble *v) {  void stub_glSecondaryColor3dvEXT(const GLdouble *v) {
# Line 2343  void stub_glSecondaryColor3dvEXT(const G Line 2693  void stub_glSecondaryColor3dvEXT(const G
2693     return _glSecondaryColor3dvEXT(v);     return _glSecondaryColor3dvEXT(v);
2694  }  }
2695    
2696    void stub_glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue);
2697    void (* _glSecondaryColor3f)(GLfloat red, GLfloat green, GLfloat blue) = &stub_glSecondaryColor3f;
2698    void stub_glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue) {
2699       if (getExtendedProcAddress("glSecondaryColor3f") == NULL) {
2700          return GL_kludge_error_void("glSecondaryColor3f");
2701       }
2702       _glSecondaryColor3f = (void (*)(GLfloat , GLfloat , GLfloat))getExtendedProcAddress("glSecondaryColor3f");
2703       return _glSecondaryColor3f(red , green , blue);
2704    }
2705    
2706  void stub_glSecondaryColor3fEXT(GLfloat red, GLfloat green, GLfloat blue);  void stub_glSecondaryColor3fEXT(GLfloat red, GLfloat green, GLfloat blue);
2707  void (* _glSecondaryColor3fEXT)(GLfloat red, GLfloat green, GLfloat blue) = &stub_glSecondaryColor3fEXT;  void (* _glSecondaryColor3fEXT)(GLfloat red, GLfloat green, GLfloat blue) = &stub_glSecondaryColor3fEXT;
2708  void stub_glSecondaryColor3fEXT(GLfloat red, GLfloat green, GLfloat blue) {  void stub_glSecondaryColor3fEXT(GLfloat red, GLfloat green, GLfloat blue) {
# Line 2353  void stub_glSecondaryColor3fEXT(GLfloat Line 2713  void stub_glSecondaryColor3fEXT(GLfloat
2713     return _glSecondaryColor3fEXT(red , green , blue);     return _glSecondaryColor3fEXT(red , green , blue);
2714  }  }
2715    
2716    void stub_glSecondaryColor3fv(const GLfloat *v);
2717    void (* _glSecondaryColor3fv)(const GLfloat *v) = &stub_glSecondaryColor3fv;
2718    void stub_glSecondaryColor3fv(const GLfloat *v) {
2719       if (getExtendedProcAddress("glSecondaryColor3fv") == NULL) {
2720          return GL_kludge_error_void("glSecondaryColor3fv");
2721       }
2722       _glSecondaryColor3fv = (void (*)(const GLfloat *))getExtendedProcAddress("glSecondaryColor3fv");
2723       return _glSecondaryColor3fv(v);
2724    }
2725    
2726  void stub_glSecondaryColor3fvEXT(const GLfloat *v);  void stub_glSecondaryColor3fvEXT(const GLfloat *v);
2727  void (* _glSecondaryColor3fvEXT)(const GLfloat *v) = &stub_glSecondaryColor3fvEXT;  void (* _glSecondaryColor3fvEXT)(const GLfloat *v) = &stub_glSecondaryColor3fvEXT;
2728  void stub_glSecondaryColor3fvEXT(const GLfloat *v) {  void stub_glSecondaryColor3fvEXT(const GLfloat *v) {
# Line 2363  void stub_glSecondaryColor3fvEXT(const G Line 2733  void stub_glSecondaryColor3fvEXT(const G
2733     return _glSecondaryColor3fvEXT(v);     return _glSecondaryColor3fvEXT(v);
2734  }  }
2735    
2736    void stub_glSecondaryColor3i(GLint red, GLint green, GLint blue);
2737    void (* _glSecondaryColor3i)(GLint red, GLint green, GLint blue) = &stub_glSecondaryColor3i;
2738    void stub_glSecondaryColor3i(GLint red, GLint green, GLint blue) {
2739       if (getExtendedProcAddress("glSecondaryColor3i") == NULL) {
2740          return GL_kludge_error_void("glSecondaryColor3i");
2741       }
2742       _glSecondaryColor3i = (void (*)(GLint , GLint , GLint))getExtendedProcAddress("glSecondaryColor3i");
2743       return _glSecondaryColor3i(red , green , blue);
2744    }
2745    
2746  void stub_glSecondaryColor3iEXT(GLint red, GLint green, GLint blue);  void stub_glSecondaryColor3iEXT(GLint red, GLint green, GLint blue);
2747  void (* _glSecondaryColor3iEXT)(GLint red, GLint green, GLint blue) = &stub_glSecondaryColor3iEXT;  void (* _glSecondaryColor3iEXT)(GLint red, GLint green, GLint blue) = &stub_glSecondaryColor3iEXT;
2748  void stub_glSecondaryColor3iEXT(GLint red, GLint green, GLint blue) {  void stub_glSecondaryColor3iEXT(GLint red, GLint green, GLint blue) {
# Line 2373  void stub_glSecondaryColor3iEXT(GLint re Line 2753  void stub_glSecondaryColor3iEXT(GLint re
2753     return _glSecondaryColor3iEXT(red , green , blue);     return _glSecondaryColor3iEXT(red , green , blue);
2754  }  }
2755    
2756    void stub_glSecondaryColor3iv(const GLint *v);
2757    void (* _glSecondaryColor3iv)(const GLint *v) = &stub_glSecondaryColor3iv;
2758    void stub_glSecondaryColor3iv(const GLint *v) {
2759       if (getExtendedProcAddress("glSecondaryColor3iv") == NULL) {
2760          return GL_kludge_error_void("glSecondaryColor3iv");
2761       }
2762       _glSecondaryColor3iv = (void (*)(const GLint *))getExtendedProcAddress("glSecondaryColor3iv");
2763       return _glSecondaryColor3iv(v);
2764    }
2765    
2766  void stub_glSecondaryColor3ivEXT(const GLint *v);  void stub_glSecondaryColor3ivEXT(const GLint *v);
2767  void (* _glSecondaryColor3ivEXT)(const GLint *v) = &stub_glSecondaryColor3ivEXT;  void (* _glSecondaryColor3ivEXT)(const GLint *v) = &stub_glSecondaryColor3ivEXT;
2768  void stub_glSecondaryColor3ivEXT(const GLint *v) {  void stub_glSecondaryColor3ivEXT(const GLint *v) {
# Line 2383  void stub_glSecondaryColor3ivEXT(const G Line 2773  void stub_glSecondaryColor3ivEXT(const G
2773     return _glSecondaryColor3ivEXT(v);     return _glSecondaryColor3ivEXT(v);
2774  }  }
2775    
2776    void stub_glSecondaryColor3s(GLshort red, GLshort green, GLshort blue);
2777    void (* _glSecondaryColor3s)(GLshort red, GLshort green, GLshort blue) = &stub_glSecondaryColor3s;
2778    void stub_glSecondaryColor3s(GLshort red, GLshort green, GLshort blue) {
2779       if (getExtendedProcAddress("glSecondaryColor3s") == NULL) {
2780          return GL_kludge_error_void("glSecondaryColor3s");
2781       }
2782       _glSecondaryColor3s = (void (*)(GLshort , GLshort , GLshort))getExtendedProcAddress("glSecondaryColor3s");
2783       return _glSecondaryColor3s(red , green , blue);
2784    }
2785    
2786  void stub_glSecondaryColor3sEXT(GLshort red, GLshort green, GLshort blue);  void stub_glSecondaryColor3sEXT(GLshort red, GLshort green, GLshort blue);
2787  void (* _glSecondaryColor3sEXT)(GLshort red, GLshort green, GLshort blue) = &stub_glSecondaryColor3sEXT;  void (* _glSecondaryColor3sEXT)(GLshort red, GLshort green, GLshort blue) = &stub_glSecondaryColor3sEXT;
2788  void stub_glSecondaryColor3sEXT(GLshort red, GLshort green, GLshort blue) {  void stub_glSecondaryColor3sEXT(GLshort red, GLshort green, GLshort blue) {
# Line 2393  void stub_glSecondaryColor3sEXT(GLshort Line 2793  void stub_glSecondaryColor3sEXT(GLshort
2793     return _glSecondaryColor3sEXT(red , green , blue);     return _glSecondaryColor3sEXT(red , green , blue);
2794  }  }
2795    
2796    void stub_glSecondaryColor3sv(const GLshort *v);
2797    void (* _glSecondaryColor3sv)(const GLshort *v) = &stub_glSecondaryColor3sv;
2798    void stub_glSecondaryColor3sv(const GLshort *v) {
2799       if (getExtendedProcAddress("glSecondaryColor3sv") == NULL) {
2800          return GL_kludge_error_void("glSecondaryColor3sv");
2801       }
2802       _glSecondaryColor3sv = (void (*)(const GLshort *))getExtendedProcAddress("glSecondaryColor3sv");
2803       return _glSecondaryColor3sv(v);
2804    }
2805    
2806  void stub_glSecondaryColor3svEXT(const GLshort *v);  void stub_glSecondaryColor3svEXT(const GLshort *v);
2807  void (* _glSecondaryColor3svEXT)(const GLshort *v) = &stub_glSecondaryColor3svEXT;  void (* _glSecondaryColor3svEXT)(const GLshort *v) = &stub_glSecondaryColor3svEXT;
2808  void stub_glSecondaryColor3svEXT(const GLshort *v) {  void stub_glSecondaryColor3svEXT(const GLshort *v) {
# Line 2403  void stub_glSecondaryColor3svEXT(const G Line 2813  void stub_glSecondaryColor3svEXT(const G
2813     return _glSecondaryColor3svEXT(v);     return _glSecondaryColor3svEXT(v);
2814  }  }
2815    
2816    void stub_glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue);
2817    void (* _glSecondaryColor3ub)(GLubyte red, GLubyte green, GLubyte blue) = &stub_glSecondaryColor3ub;
2818    void stub_glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue) {
2819       if (getExtendedProcAddress("glSecondaryColor3ub") == NULL) {
2820          return GL_kludge_error_void("glSecondaryColor3ub");
2821       }
2822       _glSecondaryColor3ub = (void (*)(GLubyte , GLubyte , GLubyte))getExtendedProcAddress("glSecondaryColor3ub");
2823       return _glSecondaryColor3ub(red , green , blue);
2824    }
2825    
2826  void stub_glSecondaryColor3ubEXT(GLubyte red, GLubyte green, GLubyte blue);  void stub_glSecondaryColor3ubEXT(GLubyte red, GLubyte green, GLubyte blue);
2827  void (* _glSecondaryColor3ubEXT)(GLubyte red, GLubyte green, GLubyte blue) = &stub_glSecondaryColor3ubEXT;  void (* _glSecondaryColor3ubEXT)(GLubyte red, GLubyte green, GLubyte blue) = &stub_glSecondaryColor3ubEXT;
2828  void stub_glSecondaryColor3ubEXT(GLubyte red, GLubyte green, GLubyte blue) {  void stub_glSecondaryColor3ubEXT(GLubyte red, GLubyte green, GLubyte blue) {
# Line 2413  void stub_glSecondaryColor3ubEXT(GLubyte Line 2833  void stub_glSecondaryColor3ubEXT(GLubyte
2833     return _glSecondaryColor3ubEXT(red , green , blue);     return _glSecondaryColor3ubEXT(red , green , blue);
2834  }  }
2835    
2836    void stub_glSecondaryColor3ubv(const GLubyte *v);
2837    void (* _glSecondaryColor3ubv)(const GLubyte *v) = &stub_glSecondaryColor3ubv;
2838    void stub_glSecondaryColor3ubv(const GLubyte *v) {
2839       if (getExtendedProcAddress("glSecondaryColor3ubv") == NULL) {
2840          return GL_kludge_error_void("glSecondaryColor3ubv");
2841       }
2842       _glSecondaryColor3ubv = (void (*)(const GLubyte *))getExtendedProcAddress("glSecondaryColor3ubv");
2843       return _glSecondaryColor3ubv(v);
2844    }
2845    
2846  void stub_glSecondaryColor3ubvEXT(const GLubyte *v);  void stub_glSecondaryColor3ubvEXT(const GLubyte *v);
2847  void (* _glSecondaryColor3ubvEXT)(const GLubyte *v) = &stub_glSecondaryColor3ubvEXT;  void (* _glSecondaryColor3ubvEXT)(const GLubyte *v) = &stub_glSecondaryColor3ubvEXT;
2848  void stub_glSecondaryColor3ubvEXT(const GLubyte *v) {  void stub_glSecondaryColor3ubvEXT(const GLubyte *v) {
# Line 2423  void stub_glSecondaryColor3ubvEXT(const Line 2853  void stub_glSecondaryColor3ubvEXT(const
2853     return _glSecondaryColor3ubvEXT(v);     return _glSecondaryColor3ubvEXT(v);
2854  }  }
2855    
2856    void stub_glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue);
2857    void (* _glSecondaryColor3ui)(GLuint red, GLuint green, GLuint blue) = &stub_glSecondaryColor3ui;
2858    void stub_glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue) {
2859       if (getExtendedProcAddress("glSecondaryColor3ui") == NULL) {
2860          return GL_kludge_error_void("glSecondaryColor3ui");
2861       }
2862       _glSecondaryColor3ui = (void (*)(GLuint , GLuint , GLuint))getExtendedProcAddress("glSecondaryColor3ui");
2863       return _glSecondaryColor3ui(red , green , blue);
2864    }
2865    
2866  void stub_glSecondaryColor3uiEXT(GLuint red, GLuint green, GLuint blue);  void stub_glSecondaryColor3uiEXT(GLuint red, GLuint green, GLuint blue);
2867  void (* _glSecondaryColor3uiEXT)(GLuint red, GLuint green, GLuint blue) = &stub_glSecondaryColor3uiEXT;  void (* _glSecondaryColor3uiEXT)(GLuint red, GLuint green, GLuint blue) = &stub_glSecondaryColor3uiEXT;
2868  void stub_glSecondaryColor3uiEXT(GLuint red, GLuint green, GLuint blue) {  void stub_glSecondaryColor3uiEXT(GLuint red, GLuint green, GLuint blue) {
# Line 2433  void stub_glSecondaryColor3uiEXT(GLuint Line 2873  void stub_glSecondaryColor3uiEXT(GLuint
2873     return _glSecondaryColor3uiEXT(red , green , blue);     return _glSecondaryColor3uiEXT(red , green , blue);
2874  }  }
2875    
2876    void stub_glSecondaryColor3uiv(const GLuint *v);
2877    void (* _glSecondaryColor3uiv)(const GLuint *v) = &stub_glSecondaryColor3uiv;
2878    void stub_glSecondaryColor3uiv(const GLuint *v) {
2879       if (getExtendedProcAddress("glSecondaryColor3uiv") == NULL) {
2880          return GL_kludge_error_void("glSecondaryColor3uiv");
2881       }
2882       _glSecondaryColor3uiv = (void (*)(const GLuint *))getExtendedProcAddress("glSecondaryColor3uiv");
2883       return _glSecondaryColor3uiv(v);
2884    }
2885    
2886  void stub_glSecondaryColor3uivEXT(const GLuint *v);  void stub_glSecondaryColor3uivEXT(const GLuint *v);
2887  void (* _glSecondaryColor3uivEXT)(const GLuint *v) = &stub_glSecondaryColor3uivEXT;  void (* _glSecondaryColor3uivEXT)(const GLuint *v) = &stub_glSecondaryColor3uivEXT;
2888  void stub_glSecondaryColor3uivEXT(const GLuint *v) {  void stub_glSecondaryColor3uivEXT(const GLuint *v) {
# Line 2443  void stub_glSecondaryColor3uivEXT(const Line 2893  void stub_glSecondaryColor3uivEXT(const
2893     return _glSecondaryColor3uivEXT(v);     return _glSecondaryColor3uivEXT(v);
2894  }  }
2895    
2896    void stub_glSecondaryColor3us(GLushort red, GLushort green, GLushort blue);
2897    void (* _glSecondaryColor3us)(GLushort red, GLushort green, GLushort blue) = &stub_glSecondaryColor3us;
2898    void stub_glSecondaryColor3us(GLushort red, GLushort green, GLushort blue) {
2899       if (getExtendedProcAddress("glSecondaryColor3us") == NULL) {
2900          return GL_kludge_error_void("glSecondaryColor3us");
2901       }
2902       _glSecondaryColor3us = (void (*)(GLushort , GLushort , GLushort))getExtendedProcAddress("glSecondaryColor3us");
2903       return _glSecondaryColor3us(red , green , blue);
2904    }
2905    
2906  void stub_glSecondaryColor3usEXT(GLushort red, GLushort green, GLushort blue);  void stub_glSecondaryColor3usEXT(GLushort red, GLushort green, GLushort blue);
2907  void (* _glSecondaryColor3usEXT)(GLushort red, GLushort green, GLushort blue) = &stub_glSecondaryColor3usEXT;  void (* _glSecondaryColor3usEXT)(GLushort red, GLushort green, GLushort blue) = &stub_glSecondaryColor3usEXT;
2908  void stub_glSecondaryColor3usEXT(GLushort red, GLushort green, GLushort blue) {  void stub_glSecondaryColor3usEXT(GLushort red, GLushort green, GLushort blue) {
# Line 2453  void stub_glSecondaryColor3usEXT(GLushor Line 2913  void stub_glSecondaryColor3usEXT(GLushor
2913     return _glSecondaryColor3usEXT(red , green , blue);     return _glSecondaryColor3usEXT(red , green , blue);
2914  }  }
2915    
2916    void stub_glSecondaryColor3usv(const GLushort *v);
2917    void (* _glSecondaryColor3usv)(const GLushort *v) = &stub_glSecondaryColor3usv;
2918    void stub_glSecondaryColor3usv(const GLushort *v) {
2919       if (getExtendedProcAddress("glSecondaryColor3usv") == NULL) {
2920          return GL_kludge_error_void("glSecondaryColor3usv");
2921       }
2922       _glSecondaryColor3usv = (void (*)(const GLushort *))getExtendedProcAddress("glSecondaryColor3usv");
2923       return _glSecondaryColor3usv(v);
2924    }
2925    
2926  void stub_glSecondaryColor3usvEXT(const GLushort *v);  void stub_glSecondaryColor3usvEXT(const GLushort *v);
2927  void (* _glSecondaryColor3usvEXT)(const GLushort *v) = &stub_glSecondaryColor3usvEXT;  void (* _glSecondaryColor3usvEXT)(const GLushort *v) = &stub_glSecondaryColor3usvEXT;
2928  void stub_glSecondaryColor3usvEXT(const GLushort *v) {  void stub_glSecondaryColor3usvEXT(const GLushort *v) {
# Line 2463  void stub_glSecondaryColor3usvEXT(const Line 2933  void stub_glSecondaryColor3usvEXT(const
2933     return _glSecondaryColor3usvEXT(v);     return _glSecondaryColor3usvEXT(v);
2934  }  }
2935    
2936    void stub_glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
2937    void (* _glSecondaryColorPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) = &stub_glSecondaryColorPointer;
2938    void stub_glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) {
2939       if (getExtendedProcAddress("glSecondaryColorPointer") == NULL) {
2940          return GL_kludge_error_void("glSecondaryColorPointer");
2941       }
2942       _glSecondaryColorPointer = (void (*)(GLint , GLenum , GLsizei , const GLvoid *))getExtendedProcAddress("glSecondaryColorPointer");
2943       return _glSecondaryColorPointer(size , type , stride , pointer);
2944    }
2945    
2946  void stub_glSecondaryColorPointerEXT(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);  void stub_glSecondaryColorPointerEXT(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
2947  void (* _glSecondaryColorPointerEXT)(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) = &stub_glSecondaryColorPointerEXT;  void (* _glSecondaryColorPointerEXT)(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) = &stub_glSecondaryColorPointerEXT;
2948  void stub_glSecondaryColorPointerEXT(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) {  void stub_glSecondaryColorPointerEXT(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) {
# Line 2553  void stub_glTexCoordPointerEXT(GLint siz Line 3033  void stub_glTexCoordPointerEXT(GLint siz
3033     return _glTexCoordPointerEXT(size , type , stride , count , pointer);     return _glTexCoordPointerEXT(size , type , stride , count , pointer);
3034  }  }
3035    
3036  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, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
3037  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, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels) = &stub_glTexImage3D;
3038  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, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels) {
3039     if (getExtendedProcAddress("glTexImage3D") == NULL) {     if (getExtendedProcAddress("glTexImage3D") == NULL) {
3040        return GL_kludge_error_void("glTexImage3D");        return GL_kludge_error_void("glTexImage3D");
3041     }     }
3042     _glTexImage3D = (void (*)(GLenum , GLint , GLenum , GLsizei , GLsizei , GLsizei , GLint , GLenum , GLenum , const GLvoid *))getExtendedProcAddress("glTexImage3D");     _glTexImage3D = (void (*)(GLenum , GLint , GLint , GLsizei , GLsizei , GLsizei , GLint , GLenum , GLenum , const GLvoid *))getExtendedProcAddress("glTexImage3D");
3043     return _glTexImage3D(target , level , internalformat , width , height , depth , border , format , type , pixels);     return _glTexImage3D(target , level , internalformat , width , height , depth , border , format , type , pixels);
3044  }  }
3045    
# Line 2593  void stub_glTexSubImage3DEXT(GLenum targ Line 3073  void stub_glTexSubImage3DEXT(GLenum targ
3073     return _glTexSubImage3DEXT(target , level , xoffset , yoffset , zoffset , width , height , depth , format , type , pixels);     return _glTexSubImage3DEXT(target , level , xoffset , yoffset , zoffset , width , height , depth , format , type , pixels);
3074  }  }
3075    
3076    void stub_glTextureColorMaskSGIS(GLboolean r, GLboolean g, GLboolean b, GLboolean a);
3077    void (* _glTextureColorMaskSGIS)(GLboolean r, GLboolean g, GLboolean b, GLboolean a) = &stub_glTextureColorMaskSGIS;
3078    void stub_glTextureColorMaskSGIS(GLboolean r, GLboolean g, GLboolean b, GLboolean a) {
3079       if (getExtendedProcAddress("glTextureColorMaskSGIS") == NULL) {
3080          return GL_kludge_error_void("glTextureColorMaskSGIS");
3081       }
3082       _glTextureColorMaskSGIS = (void (*)(GLboolean , GLboolean , GLboolean , GLboolean))getExtendedProcAddress("glTextureColorMaskSGIS");
3083       return _glTextureColorMaskSGIS(r , g , b , a);
3084    }
3085    
3086  void stub_glTrackMatrixNV(GLenum target, GLuint address, GLenum matrix, GLenum transform);  void stub_glTrackMatrixNV(GLenum target, GLuint address, GLenum matrix, GLenum transform);
3087  void (* _glTrackMatrixNV)(GLenum target, GLuint address, GLenum matrix, GLenum transform) = &stub_glTrackMatrixNV;  void (* _glTrackMatrixNV)(GLenum target, GLuint address, GLenum matrix, GLenum transform) = &stub_glTrackMatrixNV;
3088  void stub_glTrackMatrixNV(GLenum target, GLuint address, GLenum matrix, GLenum transform) {  void stub_glTrackMatrixNV(GLenum target, GLuint address, GLenum matrix, GLenum transform) {
# Line 2633  void stub_glVertexArrayRangeNV(GLsizei s Line 3123  void stub_glVertexArrayRangeNV(GLsizei s
3123     return _glVertexArrayRangeNV(size , pointer);     return _glVertexArrayRangeNV(size , pointer);
3124  }  }
3125    
3126    void stub_glVertexAttrib1dARB(GLuint index, GLdouble x);
3127    void (* _glVertexAttrib1dARB)(GLuint index, GLdouble x) = &stub_glVertexAttrib1dARB;
3128    void stub_glVertexAttrib1dARB(GLuint index, GLdouble x) {
3129       if (getExtendedProcAddress("glVertexAttrib1dARB") == NULL) {
3130          return GL_kludge_error_void("glVertexAttrib1dARB");
3131       }
3132       _glVertexAttrib1dARB = (void (*)(GLuint , GLdouble))getExtendedProcAddress("glVertexAttrib1dARB");
3133       return _glVertexAttrib1dARB(index , x);
3134    }
3135    
3136  void stub_glVertexAttrib1dNV(GLuint index, GLdouble x);  void stub_glVertexAttrib1dNV(GLuint index, GLdouble x);
3137  void (* _glVertexAttrib1dNV)(GLuint index, GLdouble x) = &stub_glVertexAttrib1dNV;  void (* _glVertexAttrib1dNV)(GLuint index, GLdouble x) = &stub_glVertexAttrib1dNV;
3138  void stub_glVertexAttrib1dNV(GLuint index, GLdouble x) {  void stub_glVertexAttrib1dNV(GLuint index, GLdouble x) {
# Line 2643  void stub_glVertexAttrib1dNV(GLuint inde Line 3143  void stub_glVertexAttrib1dNV(GLuint inde
3143     return _glVertexAttrib1dNV(index , x);     return _glVertexAttrib1dNV(index , x);
3144  }  }
3145    
3146    void stub_glVertexAttrib1dvARB(GLuint index, const GLdouble *v);
3147    void (* _glVertexAttrib1dvARB)(GLuint index, const GLdouble *v) = &stub_glVertexAttrib1dvARB;
3148    void stub_glVertexAttrib1dvARB(GLuint index, const GLdouble *v) {
3149       if (getExtendedProcAddress("glVertexAttrib1dvARB") == NULL) {
3150          return GL_kludge_error_void("glVertexAttrib1dvARB");
3151       }
3152       _glVertexAttrib1dvARB = (void (*)(GLuint , const GLdouble *))getExtendedProcAddress("glVertexAttrib1dvARB");
3153       return _glVertexAttrib1dvARB(index , v);
3154    }
3155    
3156  void stub_glVertexAttrib1dvNV(GLuint index, const GLdouble *v);  void stub_glVertexAttrib1dvNV(GLuint index, const GLdouble *v);
3157  void (* _glVertexAttrib1dvNV)(GLuint index, const GLdouble *v) = &stub_glVertexAttrib1dvNV;  void (* _glVertexAttrib1dvNV)(GLuint index, const GLdouble *v) = &stub_glVertexAttrib1dvNV;
3158  void stub_glVertexAttrib1dvNV(GLuint index, const GLdouble *v) {  void stub_glVertexAttrib1dvNV(GLuint index, const GLdouble *v) {
# Line 2653  void stub_glVertexAttrib1dvNV(GLuint ind Line 3163  void stub_glVertexAttrib1dvNV(GLuint ind
3163     return _glVertexAttrib1dvNV(index , v);     return _glVertexAttrib1dvNV(index , v);
3164  }  }
3165    
3166    void stub_glVertexAttrib1fARB(GLuint index, GLfloat x);
3167    void (* _glVertexAttrib1fARB)(GLuint index, GLfloat x) = &stub_glVertexAttrib1fARB;
3168    void stub_glVertexAttrib1fARB(GLuint index, GLfloat x) {
3169       if (getExtendedProcAddress("glVertexAttrib1fARB") == NULL) {
3170          return GL_kludge_error_void("glVertexAttrib1fARB");
3171       }
3172       _glVertexAttrib1fARB = (void (*)(GLuint , GLfloat))getExtendedProcAddress("glVertexAttrib1fARB");
3173       return _glVertexAttrib1fARB(index , x);
3174    }
3175    
3176  void stub_glVertexAttrib1fNV(GLuint index, GLfloat x);  void stub_glVertexAttrib1fNV(GLuint index, GLfloat x);
3177  void (* _glVertexAttrib1fNV)(GLuint index, GLfloat x) = &stub_glVertexAttrib1fNV;  void (* _glVertexAttrib1fNV)(GLuint index, GLfloat x) = &stub_glVertexAttrib1fNV;
3178  void stub_glVertexAttrib1fNV(GLuint index, GLfloat x) {  void stub_glVertexAttrib1fNV(GLuint index, GLfloat x) {
# Line 2663  void stub_glVertexAttrib1fNV(GLuint inde Line 3183  void stub_glVertexAttrib1fNV(GLuint inde
3183     return _glVertexAttrib1fNV(index , x);     return _glVertexAttrib1fNV(index , x);
3184  }  }
3185    
3186    void stub_glVertexAttrib1fvARB(GLuint index, const GLfloat *v);
3187    void (* _glVertexAttrib1fvARB)(GLuint index, const GLfloat *v) = &stub_glVertexAttrib1fvARB;
3188    void stub_glVertexAttrib1fvARB(GLuint index, const GLfloat *v) {
3189       if (getExtendedProcAddress("glVertexAttrib1fvARB") == NULL) {
3190          return GL_kludge_error_void("glVertexAttrib1fvARB");
3191       }
3192       _glVertexAttrib1fvARB = (void (*)(GLuint , const GLfloat *))getExtendedProcAddress("glVertexAttrib1fvARB");
3193       return _glVertexAttrib1fvARB(index , v);
3194    }
3195    
3196  void stub_glVertexAttrib1fvNV(GLuint index, const GLfloat *v);  void stub_glVertexAttrib1fvNV(GLuint index, const GLfloat *v);
3197  void (* _glVertexAttrib1fvNV)(GLuint index, const GLfloat *v) = &stub_glVertexAttrib1fvNV;  void (* _glVertexAttrib1fvNV)(GLuint index, const GLfloat *v) = &stub_glVertexAttrib1fvNV;
3198  void stub_glVertexAttrib1fvNV(GLuint index, const GLfloat *v) {  void stub_glVertexAttrib1fvNV(GLuint index, const GLfloat *v) {
# Line 2673  void stub_glVertexAttrib1fvNV(GLuint ind Line 3203  void stub_glVertexAttrib1fvNV(GLuint ind
3203     return _glVertexAttrib1fvNV(index , v);     return _glVertexAttrib1fvNV(index , v);
3204  }  }
3205    
3206    void stub_glVertexAttrib1sARB(GLuint index, GLshort x);
3207    void (* _glVertexAttrib1sARB)(GLuint index, GLshort x) = &stub_glVertexAttrib1sARB;
3208    void stub_glVertexAttrib1sARB(GLuint index, GLshort x) {
3209       if (getExtendedProcAddress("glVertexAttrib1sARB") == NULL) {
3210          return GL_kludge_error_void("glVertexAttrib1sARB");
3211       }
3212       _glVertexAttrib1sARB = (void (*)(GLuint , GLshort))getExtendedProcAddress("glVertexAttrib1sARB");
3213       return _glVertexAttrib1sARB(index , x);
3214    }
3215    
3216  void stub_glVertexAttrib1sNV(GLuint index, GLshort x);  void stub_glVertexAttrib1sNV(GLuint index, GLshort x);
3217  void (* _glVertexAttrib1sNV)(GLuint index, GLshort x) = &stub_glVertexAttrib1sNV;  void (* _glVertexAttrib1sNV)(GLuint index, GLshort x) = &stub_glVertexAttrib1sNV;
3218  void stub_glVertexAttrib1sNV(GLuint index, GLshort x) {  void stub_glVertexAttrib1sNV(GLuint index, GLshort x) {
# Line 2683  void stub_glVertexAttrib1sNV(GLuint inde Line 3223  void stub_glVertexAttrib1sNV(GLuint inde
3223     return _glVertexAttrib1sNV(index , x);     return _glVertexAttrib1sNV(index , x);
3224  }  }
3225    
3226    void stub_glVertexAttrib1svARB(GLuint index, const GLshort *v);
3227    void (* _glVertexAttrib1svARB)(GLuint index, const GLshort *v) = &stub_glVertexAttrib1svARB;
3228    void stub_glVertexAttrib1svARB(GLuint index, const GLshort *v) {
3229       if (getExtendedProcAddress("glVertexAttrib1svARB") == NULL) {
3230          return GL_kludge_error_void("glVertexAttrib1svARB");
3231       }
3232       _glVertexAttrib1svARB = (void (*)(GLuint , const GLshort *))getExtendedProcAddress("glVertexAttrib1svARB");
3233       return _glVertexAttrib1svARB(index , v);
3234    }
3235    
3236  void stub_glVertexAttrib1svNV(GLuint index, const GLshort *v);  void stub_glVertexAttrib1svNV(GLuint index, const GLshort *v);
3237  void (* _glVertexAttrib1svNV)(GLuint index, const GLshort *v) = &stub_glVertexAttrib1svNV;  void (* _glVertexAttrib1svNV)(GLuint index, const GLshort *v) = &stub_glVertexAttrib1svNV;
3238  void stub_glVertexAttrib1svNV(GLuint index, const GLshort *v) {  void stub_glVertexAttrib1svNV(GLuint index, const GLshort *v) {
# Line 2693  void stub_glVertexAttrib1svNV(GLuint ind Line 3243  void stub_glVertexAttrib1svNV(GLuint ind
3243     return _glVertexAttrib1svNV(index , v);     return _glVertexAttrib1svNV(index , v);
3244  }  }
3245    
3246    void stub_glVertexAttrib2dARB(GLuint index, GLdouble x, GLdouble y);
3247    void (* _glVertexAttrib2dARB)(GLuint index, GLdouble x, GLdouble y) = &stub_glVertexAttrib2dARB;
3248    void stub_glVertexAttrib2dARB(GLuint index, GLdouble x, GLdouble y) {
3249       if (getExtendedProcAddress("glVertexAttrib2dARB") == NULL) {
3250          return GL_kludge_error_void("glVertexAttrib2dARB");
3251       }
3252       _glVertexAttrib2dARB = (void (*)(GLuint , GLdouble , GLdouble))getExtendedProcAddress("glVertexAttrib2dARB");
3253       return _glVertexAttrib2dARB(index , x , y);
3254    }
3255    
3256  void stub_glVertexAttrib2dNV(GLuint index, GLdouble x, GLdouble y);  void stub_glVertexAttrib2dNV(GLuint index, GLdouble x, GLdouble y);
3257  void (* _glVertexAttrib2dNV)(GLuint index, GLdouble x, GLdouble y) = &stub_glVertexAttrib2dNV;  void (* _glVertexAttrib2dNV)(GLuint index, GLdouble x, GLdouble y) = &stub_glVertexAttrib2dNV;
3258  void stub_glVertexAttrib2dNV(GLuint index, GLdouble x, GLdouble y) {  void stub_glVertexAttrib2dNV(GLuint index, GLdouble x, GLdouble y) {
# Line 2703  void stub_glVertexAttrib2dNV(GLuint inde Line 3263  void stub_glVertexAttrib2dNV(GLuint inde
3263     return _glVertexAttrib2dNV(index , x , y);     return _glVertexAttrib2dNV(index , x , y);
3264  }  }
3265    
3266    void stub_glVertexAttrib2dvARB(GLuint index, const GLdouble *v);
3267    void (* _glVertexAttrib2dvARB)(GLuint index, const GLdouble *v) = &stub_glVertexAttrib2dvARB;
3268    void stub_glVertexAttrib2dvARB(GLuint index, const GLdouble *v) {
3269       if (getExtendedProcAddress("glVertexAttrib2dvARB") == NULL) {
3270          return GL_kludge_error_void("glVertexAttrib2dvARB");
3271       }
3272       _glVertexAttrib2dvARB = (void (*)(GLuint , const GLdouble *))getExtendedProcAddress("glVertexAttrib2dvARB");
3273       return _glVertexAttrib2dvARB(index , v);
3274    }
3275    
3276  void stub_glVertexAttrib2dvNV(GLuint index, const GLdouble *v);  void stub_glVertexAttrib2dvNV(GLuint index, const GLdouble *v);
3277  void (* _glVertexAttrib2dvNV)(GLuint index, const GLdouble *v) = &stub_glVertexAttrib2dvNV;  void (* _glVertexAttrib2dvNV)(GLuint index, const GLdouble *v) = &stub_glVertexAttrib2dvNV;
3278  void stub_glVertexAttrib2dvNV(GLuint index, const GLdouble *v) {  void stub_glVertexAttrib2dvNV(GLuint index, const GLdouble *v) {
# Line 2713  void stub_glVertexAttrib2dvNV(GLuint ind Line 3283  void stub_glVertexAttrib2dvNV(GLuint ind
3283     return _glVertexAttrib2dvNV(index , v);     return _glVertexAttrib2dvNV(index , v);
3284  }  }
3285    
3286    void stub_glVertexAttrib2fARB(GLuint index, GLfloat x, GLfloat y);
3287    void (* _glVertexAttrib2fARB)(GLuint index, GLfloat x, GLfloat y) = &stub_glVertexAttrib2fARB;
3288    void stub_glVertexAttrib2fARB(GLuint index, GLfloat x, GLfloat y) {
3289       if (getExtendedProcAddress("glVertexAttrib2fARB") == NULL) {
3290          return GL_kludge_error_void("glVertexAttrib2fARB");
3291       }
3292       _glVertexAttrib2fARB = (void (*)(GLuint , GLfloat , GLfloat))getExtendedProcAddress("glVertexAttrib2fARB");
3293       return _glVertexAttrib2fARB(index , x , y);
3294    }
3295    
3296  void stub_glVertexAttrib2fNV(GLuint index, GLfloat x, GLfloat y);  void stub_glVertexAttrib2fNV(GLuint index, GLfloat x, GLfloat y);
3297  void (* _glVertexAttrib2fNV)(GLuint index, GLfloat x, GLfloat y) = &stub_glVertexAttrib2fNV;  void (* _glVertexAttrib2fNV)(GLuint index, GLfloat x, GLfloat y) = &stub_glVertexAttrib2fNV;
3298  void stub_glVertexAttrib2fNV(GLuint index, GLfloat x, GLfloat y) {  void stub_glVertexAttrib2fNV(GLuint index, GLfloat x, GLfloat y) {
# Line 2723  void stub_glVertexAttrib2fNV(GLuint inde Line 3303  void stub_glVertexAttrib2fNV(GLuint inde
3303     return _glVertexAttrib2fNV(index , x , y);     return _glVertexAttrib2fNV(index , x , y);
3304  }  }
3305    
3306    void stub_glVertexAttrib2fvARB(GLuint index, const GLfloat *v);
3307    void (* _glVertexAttrib2fvARB)(GLuint index, const GLfloat *v) = &stub_glVertexAttrib2fvARB;
3308    void stub_glVertexAttrib2fvARB(GLuint index, const GLfloat *v) {
3309       if (getExtendedProcAddress("glVertexAttrib2fvARB") == NULL) {
3310          return GL_kludge_error_void("glVertexAttrib2fvARB");
3311       }
3312       _glVertexAttrib2fvARB = (void (*)(GLuint , const GLfloat *))getExtendedProcAddress("glVertexAttrib2fvARB");
3313       return _glVertexAttrib2fvARB(index , v);
3314    }
3315    
3316  void stub_glVertexAttrib2fvNV(GLuint index, const GLfloat *v);  void stub_glVertexAttrib2fvNV(GLuint index, const GLfloat *v);
3317  void (* _glVertexAttrib2fvNV)(GLuint index, const GLfloat *v) = &stub_glVertexAttrib2fvNV;  void (* _glVertexAttrib2fvNV)(GLuint index, const GLfloat *v) = &stub_glVertexAttrib2fvNV;
3318  void stub_glVertexAttrib2fvNV(GLuint index, const GLfloat *v) {  void stub_glVertexAttrib2fvNV(GLuint index, const GLfloat *v) {
# Line 2733  void stub_glVertexAttrib2fvNV(GLuint ind Line 3323  void stub_glVertexAttrib2fvNV(GLuint ind
3323     return _glVertexAttrib2fvNV(index , v);     return _glVertexAttrib2fvNV(index , v);
3324  }  }
3325    
3326    void stub_glVertexAttrib2sARB(GLuint index, GLshort x, GLshort y);
3327    void (* _glVertexAttrib2sARB)(GLuint index, GLshort x, GLshort y) = &stub_glVertexAttrib2sARB;
3328    void stub_glVertexAttrib2sARB(GLuint index, GLshort x, GLshort y) {
3329       if (getExtendedProcAddress("glVertexAttrib2sARB") == NULL) {
3330          return GL_kludge_error_void("glVertexAttrib2sARB");
3331       }
3332       _glVertexAttrib2sARB = (void (*)(GLuint , GLshort , GLshort))getExtendedProcAddress("glVertexAttrib2sARB");
3333       return _glVertexAttrib2sARB(index , x , y);
3334    }
3335    
3336  void stub_glVertexAttrib2sNV(GLuint index, GLshort x, GLshort y);  void stub_glVertexAttrib2sNV(GLuint index, GLshort x, GLshort y);
3337  void (* _glVertexAttrib2sNV)(GLuint index, GLshort x, GLshort y) = &stub_glVertexAttrib2sNV;  void (* _glVertexAttrib2sNV)(GLuint index, GLshort x, GLshort y) = &stub_glVertexAttrib2sNV;
3338  void stub_glVertexAttrib2sNV(GLuint index, GLshort x, GLshort y) {  void stub_glVertexAttrib2sNV(GLuint index, GLshort x, GLshort y) {
# Line 2743  void stub_glVertexAttrib2sNV(GLuint inde Line 3343  void stub_glVertexAttrib2sNV(GLuint inde
3343     return _glVertexAttrib2sNV(index , x , y);     return _glVertexAttrib2sNV(index , x , y);
3344  }  }
3345    
3346    void stub_glVertexAttrib2svARB(GLuint index, const GLshort *v);
3347    void (* _glVertexAttrib2svARB)(GLuint index, const GLshort *v) = &stub_glVertexAttrib2svARB;
3348    void stub_glVertexAttrib2svARB(GLuint index, const GLshort *v) {
3349       if (getExtendedProcAddress("glVertexAttrib2svARB") == NULL) {
3350          return GL_kludge_error_void("glVertexAttrib2svARB");
3351       }
3352       _glVertexAttrib2svARB = (void (*)(GLuint , const GLshort *))getExtendedProcAddress("glVertexAttrib2svARB");
3353       return _glVertexAttrib2svARB(index , v);
3354    }
3355    
3356  void stub_glVertexAttrib2svNV(GLuint index, const GLshort *v);  void stub_glVertexAttrib2svNV(GLuint index, const GLshort *v);
3357  void (* _glVertexAttrib2svNV)(GLuint index, const GLshort *v) = &stub_glVertexAttrib2svNV;  void (* _glVertexAttrib2svNV)(GLuint index, const GLshort *v) = &stub_glVertexAttrib2svNV;
3358  void stub_glVertexAttrib2svNV(GLuint index, const GLshort *v) {  void stub_glVertexAttrib2svNV(GLuint index, const GLshort *v) {
# Line 2753  void stub_glVertexAttrib2svNV(GLuint ind Line 3363  void stub_glVertexAttrib2svNV(GLuint ind
3363     return _glVertexAttrib2svNV(index , v);     return _glVertexAttrib2svNV(index , v);
3364  }  }
3365    
3366    void stub_glVertexAttrib3dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z);
3367    void (* _glVertexAttrib3dARB)(GLuint index, GLdouble x, GLdouble y, GLdouble z) = &stub_glVertexAttrib3dARB;
3368    void stub_glVertexAttrib3dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z) {
3369       if (getExtendedProcAddress("glVertexAttrib3dARB") == NULL) {
3370          return GL_kludge_error_void("glVertexAttrib3dARB");
3371       }
3372       _glVertexAttrib3dARB = (void (*)(GLuint , GLdouble , GLdouble , GLdouble))getExtendedProcAddress("glVertexAttrib3dARB");
3373       return _glVertexAttrib3dARB(index , x , y , z);
3374    }
3375    
3376  void stub_glVertexAttrib3dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z);  void stub_glVertexAttrib3dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z);
3377  void (* _glVertexAttrib3dNV)(GLuint index, GLdouble x, GLdouble y, GLdouble z) = &stub_glVertexAttrib3dNV;  void (* _glVertexAttrib3dNV)(GLuint index, GLdouble x, GLdouble y, GLdouble z) = &stub_glVertexAttrib3dNV;
3378  void stub_glVertexAttrib3dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z) {  void stub_glVertexAttrib3dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z) {
# Line 2763  void stub_glVertexAttrib3dNV(GLuint inde Line 3383  void stub_glVertexAttrib3dNV(GLuint inde
3383     return _glVertexAttrib3dNV(index , x , y , z);     return _glVertexAttrib3dNV(index , x , y , z);
3384  }  }
3385    
3386    void stub_glVertexAttrib3dvARB(GLuint index, const GLdouble *v);
3387    void (* _glVertexAttrib3dvARB)(GLuint index, const GLdouble *v) = &stub_glVertexAttrib3dvARB;
3388    void stub_glVertexAttrib3dvARB(GLuint index, const GLdouble *v) {
3389       if (getExtendedProcAddress("glVertexAttrib3dvARB") == NULL) {
3390          return GL_kludge_error_void("glVertexAttrib3dvARB");
3391       }
3392       _glVertexAttrib3dvARB = (void (*)(GLuint , const GLdouble *))getExtendedProcAddress("glVertexAttrib3dvARB");
3393       return _glVertexAttrib3dvARB(index , v);
3394    }
3395    
3396  void stub_glVertexAttrib3dvNV(GLuint index, const GLdouble *v);  void stub_glVertexAttrib3dvNV(GLuint index, const GLdouble *v);
3397  void (* _glVertexAttrib3dvNV)(GLuint index, const GLdouble *v) = &stub_glVertexAttrib3dvNV;  void (* _glVertexAttrib3dvNV)(GLuint index, const GLdouble *v) = &stub_glVertexAttrib3dvNV;
3398  void stub_glVertexAttrib3dvNV(GLuint index, const GLdouble *v) {  void stub_glVertexAttrib3dvNV(GLuint index, const GLdouble *v) {
# Line 2773  void stub_glVertexAttrib3dvNV(GLuint ind Line 3403  void stub_glVertexAttrib3dvNV(GLuint ind
3403     return _glVertexAttrib3dvNV(index , v);     return _glVertexAttrib3dvNV(index , v);
3404  }  }
3405    
3406    void stub_glVertexAttrib3fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z);
3407    void (* _glVertexAttrib3fARB)(GLuint index, GLfloat x, GLfloat y, GLfloat z) = &stub_glVertexAttrib3fARB;
3408    void stub_glVertexAttrib3fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z) {
3409       if (getExtendedProcAddress("glVertexAttrib3fARB") == NULL) {
3410          return GL_kludge_error_void("glVertexAttrib3fARB");
3411       }
3412       _glVertexAttrib3fARB = (void (*)(GLuint , GLfloat , GLfloat , GLfloat))getExtendedProcAddress("glVertexAttrib3fARB");
3413       return _glVertexAttrib3fARB(index , x , y , z);
3414    }
3415    
3416  void stub_glVertexAttrib3fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z);  void stub_glVertexAttrib3fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z);
3417  void (* _glVertexAttrib3fNV)(GLuint index, GLfloat x, GLfloat y, GLfloat z) = &stub_glVertexAttrib3fNV;  void (* _glVertexAttrib3fNV)(GLuint index, GLfloat x, GLfloat y, GLfloat z) = &stub_glVertexAttrib3fNV;
3418  void stub_glVertexAttrib3fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z) {  void stub_glVertexAttrib3fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z) {
# Line 2783  void stub_glVertexAttrib3fNV(GLuint inde Line 3423  void stub_glVertexAttrib3fNV(GLuint inde
3423     return _glVertexAttrib3fNV(index , x , y , z);     return _glVertexAttrib3fNV(index , x , y , z);
3424  }  }
3425    
3426    void stub_glVertexAttrib3fvARB(GLuint index, const GLfloat *v);
3427    void (* _glVertexAttrib3fvARB)(GLuint index, const GLfloat *v) = &stub_glVertexAttrib3fvARB;
3428    void stub_glVertexAttrib3fvARB(GLuint index, const GLfloat *v) {
3429       if (getExtendedProcAddress("glVertexAttrib3fvARB") == NULL) {
3430          return GL_kludge_error_void("glVertexAttrib3fvARB");
3431       }
3432       _glVertexAttrib3fvARB = (void (*)(GLuint , const GLfloat *))getExtendedProcAddress("glVertexAttrib3fvARB");
3433       return _glVertexAttrib3fvARB(index , v);
3434    }
3435    
3436  void stub_glVertexAttrib3fvNV(GLuint index, const GLfloat *v);  void stub_glVertexAttrib3fvNV(GLuint index, const GLfloat *v);
3437  void (* _glVertexAttrib3fvNV)(GLuint index, const GLfloat *v) = &stub_glVertexAttrib3fvNV;  void (* _glVertexAttrib3fvNV)(GLuint index, const GLfloat *v) = &stub_glVertexAttrib3fvNV;
3438  void stub_glVertexAttrib3fvNV(GLuint index, const GLfloat *v) {  void stub_glVertexAttrib3fvNV(GLuint index, const GLfloat *v) {
# Line 2793  void stub_glVertexAttrib3fvNV(GLuint ind Line 3443  void stub_glVertexAttrib3fvNV(GLuint ind
3443     return _glVertexAttrib3fvNV(index , v);     return _glVertexAttrib3fvNV(index , v);
3444  }  }
3445    
3446    void stub_glVertexAttrib3sARB(GLuint index, GLshort x, GLshort y, GLshort z);
3447    void (* _glVertexAttrib3sARB)(GLuint index, GLshort x, GLshort y, GLshort z) = &stub_glVertexAttrib3sARB;
3448    void stub_glVertexAttrib3sARB(GLuint index, GLshort x, GLshort y, GLshort z) {
3449       if (getExtendedProcAddress("glVertexAttrib3sARB") == NULL) {
3450          return GL_kludge_error_void("glVertexAttrib3sARB");
3451       }
3452       _glVertexAttrib3sARB = (void (*)(GLuint , GLshort , GLshort , GLshort))getExtendedProcAddress("glVertexAttrib3sARB");
3453       return _glVertexAttrib3sARB(index , x , y , z);
3454    }
3455    
3456  void stub_glVertexAttrib3sNV(GLuint index, GLshort x, GLshort y, GLshort z);  void stub_glVertexAttrib3sNV(GLuint index, GLshort x, GLshort y, GLshort z);
3457  void (* _glVertexAttrib3sNV)(GLuint index, GLshort x, GLshort y, GLshort z) = &stub_glVertexAttrib3sNV;  void (* _glVertexAttrib3sNV)(GLuint index, GLshort x, GLshort y, GLshort z) = &stub_glVertexAttrib3sNV;
3458  void stub_glVertexAttrib3sNV(GLuint index, GLshort x, GLshort y, GLshort z) {  void stub_glVertexAttrib3sNV(GLuint index, GLshort x, GLshort y, GLshort z) {
# Line 2803  void stub_glVertexAttrib3sNV(GLuint inde Line 3463  void stub_glVertexAttrib3sNV(GLuint inde
3463     return _glVertexAttrib3sNV(index , x , y , z);     return _glVertexAttrib3sNV(index , x , y , z);
3464  }  }
3465    
3466    void stub_glVertexAttrib3svARB(GLuint index, const GLshort *v);
3467    void (* _glVertexAttrib3svARB)(GLuint index, const GLshort *v) = &stub_glVertexAttrib3svARB;
3468    void stub_glVertexAttrib3svARB(GLuint index, const GLshort *v) {
3469       if (getExtendedProcAddress("glVertexAttrib3svARB") == NULL) {
3470          return GL_kludge_error_void("glVertexAttrib3svARB");
3471       }
3472       _glVertexAttrib3svARB = (void (*)(GLuint , const GLshort *))getExtendedProcAddress("glVertexAttrib3svARB");
3473       return _glVertexAttrib3svARB(index , v);
3474    }
3475    
3476  void stub_glVertexAttrib3svNV(GLuint index, const GLshort *v);  void stub_glVertexAttrib3svNV(GLuint index, const GLshort *v);
3477  void (* _glVertexAttrib3svNV)(GLuint index, const GLshort *v) = &stub_glVertexAttrib3svNV;  void (* _glVertexAttrib3svNV)(GLuint index, const GLshort *v) = &stub_glVertexAttrib3svNV;
3478  void stub_glVertexAttrib3svNV(GLuint index, const GLshort *v) {  void stub_glVertexAttrib3svNV(GLuint index, const GLshort *v) {
# Line 2813  void stub_glVertexAttrib3svNV(GLuint ind Line 3483  void stub_glVertexAttrib3svNV(GLuint ind
3483     return _glVertexAttrib3svNV(index , v);     return _glVertexAttrib3svNV(index , v);
3484  }  }
3485    
3486    void stub_glVertexAttrib4NbvARB(GLuint index, const GLbyte *v);
3487    void (* _glVertexAttrib4NbvARB)(GLuint index, const GLbyte *v) = &stub_glVertexAttrib4NbvARB;
3488    void stub_glVertexAttrib4NbvARB(GLuint index, const GLbyte *v) {
3489       if (getExtendedProcAddress("glVertexAttrib4NbvARB") == NULL) {
3490          return GL_kludge_error_void("glVertexAttrib4NbvARB");
3491       }
3492       _glVertexAttrib4NbvARB = (void (*)(GLuint , const GLbyte *))getExtendedProcAddress("glVertexAttrib4NbvARB");
3493       return _glVertexAttrib4NbvARB(index , v);
3494    }
3495    
3496    void stub_glVertexAttrib4NivARB(GLuint index, const GLint *v);
3497    void (* _glVertexAttrib4NivARB)(GLuint index, const GLint *v) = &stub_glVertexAttrib4NivARB;
3498    void stub_glVertexAttrib4NivARB(GLuint index, const GLint *v) {
3499       if (getExtendedProcAddress("glVertexAttrib4NivARB") == NULL) {
3500          return GL_kludge_error_void("glVertexAttrib4NivARB");
3501       }
3502       _glVertexAttrib4NivARB = (void (*)(GLuint , const GLint *))getExtendedProcAddress("glVertexAttrib4NivARB");
3503       return _glVertexAttrib4NivARB(index , v);
3504    }
3505    
3506    void stub_glVertexAttrib4NsvARB(GLuint index, const GLshort *v);
3507    void (* _glVertexAttrib4NsvARB)(GLuint index, const GLshort *v) = &stub_glVertexAttrib4NsvARB;
3508    void stub_glVertexAttrib4NsvARB(GLuint index, const GLshort *v) {
3509       if (getExtendedProcAddress("glVertexAttrib4NsvARB") == NULL) {
3510          return GL_kludge_error_void("glVertexAttrib4NsvARB");
3511       }
3512       _glVertexAttrib4NsvARB = (void (*)(GLuint , const GLshort *))getExtendedProcAddress("glVertexAttrib4NsvARB");
3513       return _glVertexAttrib4NsvARB(index , v);
3514    }
3515    
3516    void stub_glVertexAttrib4NubARB(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
3517    void (* _glVertexAttrib4NubARB)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w) = &stub_glVertexAttrib4NubARB;
3518    void stub_glVertexAttrib4NubARB(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w) {
3519       if (getExtendedProcAddress("glVertexAttrib4NubARB") == NULL) {
3520          return GL_kludge_error_void("glVertexAttrib4NubARB");
3521       }
3522       _glVertexAttrib4NubARB = (void (*)(GLuint , GLubyte , GLubyte , GLubyte , GLubyte))getExtendedProcAddress("glVertexAttrib4NubARB");
3523       return _glVertexAttrib4NubARB(index , x , y , z , w);
3524    }
3525    
3526    void stub_glVertexAttrib4NubvARB(GLuint index, const GLubyte *v);
3527    void (* _glVertexAttrib4NubvARB)(GLuint index, const GLubyte *v) = &stub_glVertexAttrib4NubvARB;
3528    void stub_glVertexAttrib4NubvARB(GLuint index, const GLubyte *v) {
3529       if (getExtendedProcAddress("glVertexAttrib4NubvARB") == NULL) {
3530          return GL_kludge_error_void("glVertexAttrib4NubvARB");
3531       }
3532       _glVertexAttrib4NubvARB = (void (*)(GLuint , const GLubyte *))getExtendedProcAddress("glVertexAttrib4NubvARB");
3533       return _glVertexAttrib4NubvARB(index , v);
3534    }
3535    
3536    void stub_glVertexAttrib4NuivARB(GLuint index, const GLuint *v);
3537    void (* _glVertexAttrib4NuivARB)(GLuint index, const GLuint *v) = &stub_glVertexAttrib4NuivARB;
3538    void stub_glVertexAttrib4NuivARB(GLuint index, const GLuint *v) {
3539       if (getExtendedProcAddress("glVertexAttrib4NuivARB") == NULL) {
3540          return GL_kludge_error_void("glVertexAttrib4NuivARB");
3541       }
3542       _glVertexAttrib4NuivARB = (void (*)(GLuint , const GLuint *))getExtendedProcAddress("glVertexAttrib4NuivARB");
3543       return _glVertexAttrib4NuivARB(index , v);
3544    }
3545    
3546    void stub_glVertexAttrib4NusvARB(GLuint index, const GLushort *v);
3547    void (* _glVertexAttrib4NusvARB)(GLuint index, const GLushort *v) = &stub_glVertexAttrib4NusvARB;
3548    void stub_glVertexAttrib4NusvARB(GLuint index, const GLushort *v) {
3549       if (getExtendedProcAddress("glVertexAttrib4NusvARB") == NULL) {
3550          return GL_kludge_error_void("glVertexAttrib4NusvARB");
3551       }
3552       _glVertexAttrib4NusvARB = (void (*)(GLuint , const GLushort *))getExtendedProcAddress("glVertexAttrib4NusvARB");
3553       return _glVertexAttrib4NusvARB(index , v);
3554    }
3555    
3556    void stub_glVertexAttrib4bvARB(GLuint index, const GLbyte *v);
3557    void (* _glVertexAttrib4bvARB)(GLuint index, const GLbyte *v) = &stub_glVertexAttrib4bvARB;
3558    void stub_glVertexAttrib4bvARB(GLuint index, const GLbyte *v) {
3559       if (getExtendedProcAddress("glVertexAttrib4bvARB") == NULL) {
3560          return GL_kludge_error_void("glVertexAttrib4bvARB");
3561       }
3562       _glVertexAttrib4bvARB = (void (*)(GLuint , const GLbyte *))getExtendedProcAddress("glVertexAttrib4bvARB");
3563       return _glVertexAttrib4bvARB(index , v);
3564    }
3565    
3566    void stub_glVertexAttrib4dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
3567    void (* _glVertexAttrib4dARB)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) = &stub_glVertexAttrib4dARB;
3568    void stub_glVertexAttrib4dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) {
3569       if (getExtendedProcAddress("glVertexAttrib4dARB") == NULL) {
3570          return GL_kludge_error_void("glVertexAttrib4dARB");
3571       }
3572       _glVertexAttrib4dARB = (void (*)(GLuint , GLdouble , GLdouble , GLdouble , GLdouble))getExtendedProcAddress("glVertexAttrib4dARB");
3573       return _glVertexAttrib4dARB(index , x , y , z , w);
3574    }
3575    
3576  void stub_glVertexAttrib4dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);  void stub_glVertexAttrib4dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
3577  void (* _glVertexAttrib4dNV)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) = &stub_glVertexAttrib4dNV;  void (* _glVertexAttrib4dNV)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) = &stub_glVertexAttrib4dNV;
3578  void stub_glVertexAttrib4dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) {  void stub_glVertexAttrib4dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w) {
# Line 2823  void stub_glVertexAttrib4dNV(GLuint inde Line 3583  void stub_glVertexAttrib4dNV(GLuint inde
3583     return _glVertexAttrib4dNV(index , x , y , z , w);     return _glVertexAttrib4dNV(index , x , y , z , w);
3584  }  }
3585    
3586    void stub_glVertexAttrib4dvARB(GLuint index, const GLdouble *v);
3587    void (* _glVertexAttrib4dvARB)(GLuint index, const GLdouble *v) = &stub_glVertexAttrib4dvARB;
3588    void stub_glVertexAttrib4dvARB(GLuint index, const GLdouble *v) {
3589       if (getExtendedProcAddress("glVertexAttrib4dvARB") == NULL) {
3590          return GL_kludge_error_void("glVertexAttrib4dvARB");
3591       }
3592       _glVertexAttrib4dvARB = (void (*)(GLuint , const GLdouble *))getExtendedProcAddress("glVertexAttrib4dvARB");
3593       return _glVertexAttrib4dvARB(index , v);
3594    }
3595    
3596  void stub_glVertexAttrib4dvNV(GLuint index, const GLdouble *v);  void stub_glVertexAttrib4dvNV(GLuint index, const GLdouble *v);
3597  void (* _glVertexAttrib4dvNV)(GLuint index, const GLdouble *v) = &stub_glVertexAttrib4dvNV;  void (* _glVertexAttrib4dvNV)(GLuint index, const GLdouble *v) = &stub_glVertexAttrib4dvNV;
3598  void stub_glVertexAttrib4dvNV(GLuint index, const GLdouble *v) {  void stub_glVertexAttrib4dvNV(GLuint index, const GLdouble *v) {
# Line 2833  void stub_glVertexAttrib4dvNV(GLuint ind Line 3603  void stub_glVertexAttrib4dvNV(GLuint ind
3603     return _glVertexAttrib4dvNV(index , v);     return _glVertexAttrib4dvNV(index , v);
3604  }  }
3605    
3606    void stub_glVertexAttrib4fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
3607    void (* _glVertexAttrib4fARB)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) = &stub_glVertexAttrib4fARB;
3608    void stub_glVertexAttrib4fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
3609       if (getExtendedProcAddress("glVertexAttrib4fARB") == NULL) {
3610          return GL_kludge_error_void("glVertexAttrib4fARB");
3611       }
3612       _glVertexAttrib4fARB = (void (*)(GLuint , GLfloat , GLfloat , GLfloat , GLfloat))getExtendedProcAddress("glVertexAttrib4fARB");
3613       return _glVertexAttrib4fARB(index , x , y , z , w);
3614    }
3615    
3616  void stub_glVertexAttrib4fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);  void stub_glVertexAttrib4fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
3617  void (* _glVertexAttrib4fNV)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) = &stub_glVertexAttrib4fNV;  void (* _glVertexAttrib4fNV)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) = &stub_glVertexAttrib4fNV;
3618  void stub_glVertexAttrib4fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {  void stub_glVertexAttrib4fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w) {
# Line 2843  void stub_glVertexAttrib4fNV(GLuint inde Line 3623  void stub_glVertexAttrib4fNV(GLuint inde
3623     return _glVertexAttrib4fNV(index , x , y , z , w);     return _glVertexAttrib4fNV(index , x , y , z , w);
3624  }  }
3625    
3626    void stub_glVertexAttrib4fvARB(GLuint index, const GLfloat *v);
3627    void (* _glVertexAttrib4fvARB)(GLuint index, const GLfloat *v) = &stub_glVertexAttrib4fvARB;
3628    void stub_glVertexAttrib4fvARB(GLuint index, const GLfloat *v) {
3629       if (getExtendedProcAddress("glVertexAttrib4fvARB") == NULL) {
3630          return GL_kludge_error_void("glVertexAttrib4fvARB");
3631       }
3632       _glVertexAttrib4fvARB = (void (*)(GLuint , const GLfloat *))getExtendedProcAddress("glVertexAttrib4fvARB");
3633       return _glVertexAttrib4fvARB(index , v);
3634    }
3635    
3636  void stub_glVertexAttrib4fvNV(GLuint index, const GLfloat *v);  void stub_glVertexAttrib4fvNV(GLuint index, const GLfloat *v);
3637  void (* _glVertexAttrib4fvNV)(GLuint index, const GLfloat *v) = &stub_glVertexAttrib4fvNV;  void (* _glVertexAttrib4fvNV)(GLuint index, const GLfloat *v) = &stub_glVertexAttrib4fvNV;
3638  void stub_glVertexAttrib4fvNV(GLuint index, const GLfloat *v) {  void stub_glVertexAttrib4fvNV(GLuint index, const GLfloat *v) {
# Line 2853  void stub_glVertexAttrib4fvNV(GLuint ind Line 3643  void stub_glVertexAttrib4fvNV(GLuint ind
3643     return _glVertexAttrib4fvNV(index , v);     return _glVertexAttrib4fvNV(index , v);
3644  }  }
3645    
3646    void stub_glVertexAttrib4ivARB(GLuint index, const GLint *v);
3647    void (* _glVertexAttrib4ivARB)(GLuint index, const GLint *v) = &stub_glVertexAttrib4ivARB;
3648    void stub_glVertexAttrib4ivARB(GLuint index, const GLint *v) {
3649       if (getExtendedProcAddress("glVertexAttrib4ivARB") == NULL) {
3650          return GL_kludge_error_void("glVertexAttrib4ivARB");
3651       }
3652       _glVertexAttrib4ivARB = (void (*)(GLuint , const GLint *))getExtendedProcAddress("glVertexAttrib4ivARB");
3653       return _glVertexAttrib4ivARB(index , v);
3654    }
3655    
3656    void stub_glVertexAttrib4sARB(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
3657    void (* _glVertexAttrib4sARB)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w) = &stub_glVertexAttrib4sARB;
3658    void stub_glVertexAttrib4sARB(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w) {
3659       if (getExtendedProcAddress("glVertexAttrib4sARB") == NULL) {
3660          return GL_kludge_error_void("glVertexAttrib4sARB");
3661       }
3662       _glVertexAttrib4sARB = (void (*)(GLuint , GLshort , GLshort , GLshort , GLshort))getExtendedProcAddress("glVertexAttrib4sARB");
3663       return _glVertexAttrib4sARB(index , x , y , z , w);
3664    }
3665    
3666  void stub_glVertexAttrib4sNV(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);  void stub_glVertexAttrib4sNV(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
3667  void (* _glVertexAttrib4sNV)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w) = &stub_glVertexAttrib4sNV;  void (* _glVertexAttrib4sNV)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w) = &stub_glVertexAttrib4sNV;
3668  void stub_glVertexAttrib4sNV(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w) {  void stub_glVertexAttrib4sNV(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w) {
# Line 2863  void stub_glVertexAttrib4sNV(GLuint inde Line 3673  void stub_glVertexAttrib4sNV(GLuint inde
3673     return _glVertexAttrib4sNV(index , x , y , z , w);     return _glVertexAttrib4sNV(index , x , y , z , w);
3674  }  }
3675    
3676    void stub_glVertexAttrib4svARB(GLuint index, const GLshort *v);
3677    void (* _glVertexAttrib4svARB)(GLuint index, const GLshort *v) = &stub_glVertexAttrib4svARB;
3678    void stub_glVertexAttrib4svARB(GLuint index, const GLshort *v) {
3679       if (getExtendedProcAddress("glVertexAttrib4svARB") == NULL) {
3680          return GL_kludge_error_void("glVertexAttrib4svARB");
3681       }
3682       _glVertexAttrib4svARB = (void (*)(GLuint , const GLshort *))getExtendedProcAddress("glVertexAttrib4svARB");
3683       return _glVertexAttrib4svARB(index , v);
3684    }
3685    
3686  void stub_glVertexAttrib4svNV(GLuint index, const GLshort *v);  void stub_glVertexAttrib4svNV(GLuint index, const GLshort *v);
3687  void (* _glVertexAttrib4svNV)(GLuint index, const GLshort *v) = &stub_glVertexAttrib4svNV;  void (* _glVertexAttrib4svNV)(GLuint index, const GLshort *v) = &stub_glVertexAttrib4svNV;
3688  void stub_glVertexAttrib4svNV(GLuint index, const GLshort *v) {  void stub_glVertexAttrib4svNV(GLuint index, const GLshort *v) {
# Line 2883  void stub_glVertexAttrib4ubNV(GLuint ind Line 3703  void stub_glVertexAttrib4ubNV(GLuint ind
3703     return _glVertexAttrib4ubNV(index , x , y , z , w);     return _glVertexAttrib4ubNV(index , x , y , z , w);
3704  }  }
3705    
3706    void stub_glVertexAttrib4ubvARB(GLuint index, const GLubyte *v);
3707    void (* _glVertexAttrib4ubvARB)(GLuint index, const GLubyte *v) = &stub_glVertexAttrib4ubvARB;
3708    void stub_glVertexAttrib4ubvARB(GLuint index, const GLubyte *v) {
3709       if (getExtendedProcAddress("glVertexAttrib4ubvARB") == NULL) {
3710          return GL_kludge_error_void("glVertexAttrib4ubvARB");
3711       }
3712       _glVertexAttrib4ubvARB = (void (*)(GLuint , const GLubyte *))getExtendedProcAddress("glVertexAttrib4ubvARB");
3713       return _glVertexAttrib4ubvARB(index , v);
3714    }
3715    
3716  void stub_glVertexAttrib4ubvNV(GLuint index, const GLubyte *v);  void stub_glVertexAttrib4ubvNV(GLuint index, const GLubyte *v);
3717  void (* _glVertexAttrib4ubvNV)(GLuint index, const GLubyte *v) = &stub_glVertexAttrib4ubvNV;  void (* _glVertexAttrib4ubvNV)(GLuint index, const GLubyte *v) = &stub_glVertexAttrib4ubvNV;
3718  void stub_glVertexAttrib4ubvNV(GLuint index, const GLubyte *v) {  void stub_glVertexAttrib4ubvNV(GLuint index, const GLubyte *v) {
# Line 2893  void stub_glVertexAttrib4ubvNV(GLuint in Line 3723  void stub_glVertexAttrib4ubvNV(GLuint in
3723     return _glVertexAttrib4ubvNV(index , v);     return _glVertexAttrib4ubvNV(index , v);
3724  }  }
3725    
3726    void stub_glVertexAttrib4uivARB(GLuint index, const GLuint *v);
3727    void (* _glVertexAttrib4uivARB)(GLuint index, const GLuint *v) = &stub_glVertexAttrib4uivARB;
3728    void stub_glVertexAttrib4uivARB(GLuint index, const GLuint *v) {
3729       if (getExtendedProcAddress("glVertexAttrib4uivARB") == NULL) {
3730          return GL_kludge_error_void("glVertexAttrib4uivARB");
3731       }
3732       _glVertexAttrib4uivARB = (void (*)(GLuint , const GLuint *))getExtendedProcAddress("glVertexAttrib4uivARB");
3733       return _glVertexAttrib4uivARB(index , v);
3734    }
3735    
3736    void stub_glVertexAttrib4usvARB(GLuint index, const GLushort *v);
3737    void (* _glVertexAttrib4usvARB)(GLuint index, const GLushort *v) = &stub_glVertexAttrib4usvARB;
3738    void stub_glVertexAttrib4usvARB(GLuint index, const GLushort *v) {
3739       if (getExtendedProcAddress("glVertexAttrib4usvARB") == NULL) {
3740          return GL_kludge_error_void("glVertexAttrib4usvARB");
3741       }
3742       _glVertexAttrib4usvARB = (void (*)(GLuint , const GLushort *))getExtendedProcAddress("glVertexAttrib4usvARB");
3743       return _glVertexAttrib4usvARB(index , v);
3744    }
3745    
3746    void stub_glVertexAttribPointerARB(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer);
3747    void (* _glVertexAttribPointerARB)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer) = &stub_glVertexAttribPointerARB;
3748    void stub_glVertexAttribPointerARB(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer) {
3749       if (getExtendedProcAddress("glVertexAttribPointerARB") == NULL) {
3750          return GL_kludge_error_void("glVertexAttribPointerARB");
3751       }
3752       _glVertexAttribPointerARB = (void (*)(GLuint , GLint , GLenum , GLboolean , GLsizei , const GLvoid *))getExtendedProcAddress("glVertexAttribPointerARB");
3753       return _glVertexAttribPointerARB(index , size , type , normalized , stride , pointer);
3754    }
3755    
3756  void stub_glVertexAttribPointerNV(GLuint index, GLint fsize, GLenum type, GLsizei stride, const GLvoid *pointer);  void stub_glVertexAttribPointerNV(GLuint index, GLint fsize, GLenum type, GLsizei stride, const GLvoid *pointer);
3757  void (* _glVertexAttribPointerNV)(GLuint index, GLint fsize, GLenum type, GLsizei stride, const GLvoid *pointer) = &stub_glVertexAttribPointerNV;  void (* _glVertexAttribPointerNV)(GLuint index, GLint fsize, GLenum type, GLsizei stride, const GLvoid *pointer) = &stub_glVertexAttribPointerNV;
3758  void stub_glVertexAttribPointerNV(GLuint index, GLint fsize, GLenum type, GLsizei stride, const GLvoid *pointer) {  void stub_glVertexAttribPointerNV(GLuint index, GLint fsize, GLenum type, GLsizei stride, const GLvoid *pointer) {

Legend:
Removed from v.1.4  
changed lines
  Added in v.1.5

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