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