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