danabr75-opengl 0.10.0

data/ext/opengl/funcdef.h

@@ -0,0 +1,279 @@
+/*
+ * Copyright (C) 2007 Jan Dvorak <jan.dvorak@kraxnet.cz>
+ *
+ * This program is distributed under the terms of the MIT license.
+ * See the included MIT-LICENSE file for the terms of this license.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef _FUNCDEF_H_
+#define _FUNCDEF_H_
+
+/*
+	These macros are for simplification of function definition, as passing
+	arguments from/to OpenGL usually follows the same few patterns. It would
+	be probably wise to adapt the whole bindings to C++ (templates, overloaded
+	functions, etc.), but for now supporting ruby extension for Windows means
+	MSVC6, and that in turn means unspeakable horrors and pains for everyone
+	attempting to merely write, much less debug or maintain any template-based
+	code.
+ */
+
+/*
+ * Loads the function pointer for function _NAME_ on first call to the
+ * function, or raises a NotImplementedError if the OpenGL version is less
+ * then required or the required extension is not supported.
+ */
+#define LOAD_GL_FUNC(_NAME_, _VEREXT_) \
+  do { \
+    fptr_##_NAME_ = GET_GLIMPL_VARIABLE(glfuncs._NAME_); \
+    if (fptr_##_NAME_==NULL){ \
+      if (_VEREXT_) EnsureVersionExtension(obj, (_VEREXT_)); \
+      fptr_##_NAME_ = GET_GLIMPL_VARIABLE(load_gl_function)(obj,#_NAME_, 1); \
+      SET_GLIMPL_VARIABLE(glfuncs._NAME_,fptr_##_NAME_); \
+    } \
+  } while (0)
+
+#if defined(GLFUNC_MAGIC_START)
+  #define DECL_GL_FUNC_PTR(_returntype_,_name_,_args_) \
+    GLFUNC_MAGIC_START _returntype_ (GLFUNC_MAGIC_APIENTRY * _name_)_args_ GLFUNC_MAGIC_END
+#else
+  #define DECL_GL_FUNC_PTR(_returntype_,_name_,_args_) \
+    _returntype_ (APIENTRY * fptr_##_name_)_args_ = NULL
+#endif
+
+/*
+	Macroset for defining simple functions, i.e. functions that take n arguments and
+	pass them to GL API function without any additional processing.
+
+	Some checking is implicit in _conversion_ argument - e.g. NUM2INT makes sure that
+	user is really passing type that can be converted to INT, otherwire raises.
+
+	*_LOAD version of macros are for defining functions where we load function pointer
+	instead of direct call - that means all functions above OpenGL 1.1 (including all extensions)
+ */
+
+#define ARGLIST0
+#define ARGLIST1 ,arg1
+#define ARGLIST2 ,arg1,arg2
+#define ARGLIST3 ,arg1,arg2,arg3
+#define ARGLIST4 ,arg1,arg2,arg3,arg4
+#define ARGLIST5 ,arg1,arg2,arg3,arg4,arg5
+#define ARGLIST6 ,arg1,arg2,arg3,arg4,arg5,arg6
+#define ARGLIST7 ,arg1,arg2,arg3,arg4,arg5,arg6,arg7
+#define ARGLIST8 ,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8
+#define ARGLIST9 ,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9
+#define ARGLIST10 ,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10
+
+#define CONV_GLenum (GLenum)RUBY2GLENUM
+#define CONV_GLboolean (GLboolean)RUBYBOOL2GL
+#define CONV_GLbitfield (GLbitfield)NUM2UINT
+#define CONV_GLbyte (GLbyte)NUM2INT
+#define CONV_GLshort (GLshort)NUM2INT
+#define CONV_GLint (GLint)NUM2INT
+#define CONV_GLubyte (GLubyte)NUM2UINT
+#define CONV_GLushort (GLushort)NUM2UINT
+#define CONV_GLuint (GLuint)NUM2UINT
+#define CONV_GLsizei (GLsizei)NUM2INT
+#define CONV_GLfloat (GLfloat)NUM2DBL
+#define CONV_GLclampf (GLclampf)NUM2DBL
+#define CONV_GLdouble (GLdouble)NUM2DBL
+#define CONV_GLclampd (GLclampd)NUM2DBL
+
+#define RETDECL_BASE(_t_) _t_ ret = (_t_) 0;
+#define RETDECL_GLvoid
+#define RETDECL_void
+#define RETDECL_GLenum RETDECL_BASE(GLenum)
+#define RETDECL_GLboolean RETDECL_BASE(GLboolean)
+#define RETDECL_GLbitfield RETDECL_BASE(GLbitfield)
+#define RETDECL_GLbyte RETDECL_BASE(GLbyte)
+#define RETDECL_GLshort RETDECL_BASE(GLshort)
+#define RETDECL_GLint RETDECL_BASE(GLint)
+#define RETDECL_GLubyte RETDECL_BASE(GLubyte)
+#define RETDECL_GLushort RETDECL_BASE(GLushort)
+#define RETDECL_GLuint RETDECL_BASE(GLuint)
+#define RETDECL_GLsizei RETDECL_BASE(GLsizei)
+#define RETDECL_GLfloat RETDECL_BASE(GLfloat)
+#define RETDECL_GLclampf RETDECL_BASE(GLclampf)
+#define RETDECL_GLdouble RETDECL_BASE(GLdouble)
+#define RETDECL_GLclampd RETDECL_BASE(GLclampd)
+
+#define RETSTAT_GLvoid
+#define RETSTAT_void
+#define RETSTAT_GLenum ret=
+#define RETSTAT_GLboolean ret=
+#define RETSTAT_GLbitfield ret=
+#define RETSTAT_GLbyte ret=
+#define RETSTAT_GLshort ret=
+#define RETSTAT_GLint ret=
+#define RETSTAT_GLubyte ret=
+#define RETSTAT_GLushort ret=
+#define RETSTAT_GLuint ret=
+#define RETSTAT_GLsizei ret=
+#define RETSTAT_GLfloat ret=
+#define RETSTAT_GLclampf ret=
+#define RETSTAT_GLdouble ret=
+#define RETSTAT_GLclampd ret=
+
+#define RETCONV_GLvoid(x) Qnil
+#define RETCONV_void(x) Qnil
+#define RETCONV_GLenum(x) UINT2NUM(x)
+#define RETCONV_GLboolean(x) GLBOOL2RUBY(x)
+#define RETCONV_GLbitfield(x) UINT2NUM(x)
+#define RETCONV_GLbyte(x) INT2NUM(x)
+#define RETCONV_GLshort(x) INT2NUM(x)
+#define RETCONV_GLsizeiptr(x) ULONG2NUM(x)
+#define RETCONV_GLint(x) INT2NUM(x)
+#define RETCONV_GLubyte(x) UINT2NUM(x)
+#define RETCONV_GLushort(x) UINT2NUM(x)
+#define RETCONV_GLuint(x) UINT2NUM(x)
+#define RETCONV_GLsizei(x) INT2NUM(x)
+#define RETCONV_GLfloat(x) rb_float_new(x)
+#define RETCONV_GLclampf(x) rb_float_new(x)
+#define RETCONV_GLdouble(x) rb_float_new(x)
+#define RETCONV_GLclampd(x) rb_float_new(x)
+
+#define PROTOPARAM0(p1,p2,p3,p4,p5,p6,p7,p8,p9,p10) void
+#define PROTOPARAM1(p1,p2,p3,p4,p5,p6,p7,p8,p9,p10) p1
+#define PROTOPARAM2(p1,p2,p3,p4,p5,p6,p7,p8,p9,p10) p1,p2
+#define PROTOPARAM3(p1,p2,p3,p4,p5,p6,p7,p8,p9,p10) p1,p2,p3
+#define PROTOPARAM4(p1,p2,p3,p4,p5,p6,p7,p8,p9,p10) p1,p2,p3,p4
+#define PROTOPARAM5(p1,p2,p3,p4,p5,p6,p7,p8,p9,p10) p1,p2,p3,p4,p5
+#define PROTOPARAM6(p1,p2,p3,p4,p5,p6,p7,p8,p9,p10) p1,p2,p3,p4,p5,p6
+#define PROTOPARAM7(p1,p2,p3,p4,p5,p6,p7,p8,p9,p10) p1,p2,p3,p4,p5,p6,p7
+#define PROTOPARAM8(p1,p2,p3,p4,p5,p6,p7,p8,p9,p10) p1,p2,p3,p4,p5,p6,p7,p8
+#define PROTOPARAM9(p1,p2,p3,p4,p5,p6,p7,p8,p9,p10) p1,p2,p3,p4,p5,p6,p7,p8,p9
+#define PROTOPARAM10(p1,p2,p3,p4,p5,p6,p7,p8,p9,p10) p1,p2,p3,p4,p5,p6,p7,p8,p9,p10
+
+#define CALLCONV0(cv1,cv2,cv3,cv4,cv5,cv6,cv7,cv8,cv9,cv10)
+#define CALLCONV1(cv1,cv2,cv3,cv4,cv5,cv6,cv7,cv8,cv9,cv10) CONV_##cv1(arg1)
+#define CALLCONV2(cv1,cv2,cv3,cv4,cv5,cv6,cv7,cv8,cv9,cv10) CONV_##cv1(arg1),CONV_##cv2(arg2)
+#define CALLCONV3(cv1,cv2,cv3,cv4,cv5,cv6,cv7,cv8,cv9,cv10) CONV_##cv1(arg1),CONV_##cv2(arg2),CONV_##cv3(arg3)
+#define CALLCONV4(cv1,cv2,cv3,cv4,cv5,cv6,cv7,cv8,cv9,cv10) CONV_##cv1(arg1),CONV_##cv2(arg2),CONV_##cv3(arg3),CONV_##cv4(arg4)
+#define CALLCONV5(cv1,cv2,cv3,cv4,cv5,cv6,cv7,cv8,cv9,cv10) CONV_##cv1(arg1),CONV_##cv2(arg2),CONV_##cv3(arg3),CONV_##cv4(arg4),CONV_##cv5(arg5)
+#define CALLCONV6(cv1,cv2,cv3,cv4,cv5,cv6,cv7,cv8,cv9,cv10) CONV_##cv1(arg1),CONV_##cv2(arg2),CONV_##cv3(arg3),CONV_##cv4(arg4),CONV_##cv5(arg5),CONV_##cv6(arg6)
+#define CALLCONV7(cv1,cv2,cv3,cv4,cv5,cv6,cv7,cv8,cv9,cv10) CONV_##cv1(arg1),CONV_##cv2(arg2),CONV_##cv3(arg3),CONV_##cv4(arg4),CONV_##cv5(arg5),CONV_##cv6(arg6),CONV_##cv7(arg7)
+#define CALLCONV8(cv1,cv2,cv3,cv4,cv5,cv6,cv7,cv8,cv9,cv10) CONV_##cv1(arg1),CONV_##cv2(arg2),CONV_##cv3(arg3),CONV_##cv4(arg4),CONV_##cv5(arg5),CONV_##cv6(arg6),CONV_##cv7(arg7),CONV_##cv8(arg8)
+#define CALLCONV9(cv1,cv2,cv3,cv4,cv5,cv6,cv7,cv8,cv9,cv10) CONV_##cv1(arg1),CONV_##cv2(arg2),CONV_##cv3(arg3),CONV_##cv4(arg4),CONV_##cv5(arg5),CONV_##cv6(arg6),CONV_##cv7(arg7),CONV_##cv8(arg8),CONV_##cv9(arg9)
+#define CALLCONV10(cv1,cv2,cv3,cv4,cv5,cv6,cv7,cv8,cv9,cv10) CONV_##cv1(arg1),CONV_##cv2(arg2),CONV_##cv3(arg3),CONV_##cv4(arg4),CONV_##cv5(arg5),CONV_##cv6(arg6),CONV_##cv7(arg7),CONV_##cv8(arg8),CONV_##cv9(arg9),CONV_##cv10(arg10)
+
+#define GL_FUNC_LOAD(_num_,_name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,targ7,targ8,targ9,targ10,_ver_) \
+static VALUE \
+gl_##_name_(obj ARGLIST##_num_) \
+VALUE obj ARGLIST##_num_; \
+{ \
+	RETDECL_##_returntype_ \
+	DECL_GL_FUNC_PTR(_returntype_,gl##_name_,(PROTOPARAM##_num_(targ1,targ2,targ3,targ4,targ5,targ6,targ7,targ8,targ9,targ10))); \
+	LOAD_GL_FUNC(gl##_name_,_ver_); \
+	RETSTAT_##_returntype_ fptr_gl##_name_(CALLCONV##_num_(targ1,targ2,targ3,targ4,targ5,targ6,targ7,targ8,targ9,targ10)); \
+	CHECK_GLERROR_FROM("gl" #_name_); \
+	return RETCONV_##_returntype_(ret) ; \
+}
+
+#define GL_FUNC_STATIC(_num_,_name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,targ7,targ8,targ9,targ10) \
+  GL_FUNC_LOAD(_num_,_name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,targ7,targ8,targ9,targ10,NULL)
+
+#define GL_FUNC_LOAD_0(_name_,_returntype_,_ver_) \
+	GL_FUNC_LOAD(0, _name_,_returntype_,0,0,0,0,0,0,0,0,0,0,_ver_)
+#define GL_FUNC_LOAD_1(_name_,_returntype_,targ1,_ver_) \
+	GL_FUNC_LOAD(1, _name_,_returntype_,targ1,0,0,0,0,0,0,0,0,0,_ver_)
+#define GL_FUNC_LOAD_2(_name_,_returntype_,targ1,targ2,_ver_) \
+	GL_FUNC_LOAD(2, _name_,_returntype_,targ1,targ2,0,0,0,0,0,0,0,0,_ver_)
+#define GL_FUNC_LOAD_3(_name_,_returntype_,targ1,targ2,targ3,_ver_) \
+	GL_FUNC_LOAD(3, _name_,_returntype_,targ1,targ2,targ3,0,0,0,0,0,0,0,_ver_)
+#define GL_FUNC_LOAD_4(_name_,_returntype_,targ1,targ2,targ3,targ4,_ver_) \
+	GL_FUNC_LOAD(4, _name_,_returntype_,targ1,targ2,targ3,targ4,0,0,0,0,0,0,_ver_)
+#define GL_FUNC_LOAD_5(_name_,_returntype_,targ1,targ2,targ3,targ4,targ5,_ver_) \
+	GL_FUNC_LOAD(5, _name_,_returntype_,targ1,targ2,targ3,targ4,targ5,0,0,0,0,0,_ver_)
+#define GL_FUNC_LOAD_6(_name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,_ver_) \
+	GL_FUNC_LOAD(6, _name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,0,0,0,0,_ver_)
+#define GL_FUNC_LOAD_7(_name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,targ7,_ver_) \
+	GL_FUNC_LOAD(7, _name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,targ7,0,0,0,_ver_)
+#define GL_FUNC_LOAD_8(_name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,targ7,targ8,_ver_) \
+	GL_FUNC_LOAD(8, _name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,targ7,targ8,0,0,_ver_)
+#define GL_FUNC_LOAD_9(_name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,targ7,targ8,targ9,_ver_) \
+	GL_FUNC_LOAD(9, _name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,targ7,targ8,targ9,0,_ver_)
+#define GL_FUNC_LOAD_10(_name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,targ7,targ8,targ9,targ10,_ver_) \
+	GL_FUNC_LOAD(10, _name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,targ7,targ8,targ9,targ10,_ver_)
+
+#define GL_FUNC_STATIC_0(_name_,_returntype_) \
+	GL_FUNC_STATIC(0, _name_,_returntype_,0,0,0,0,0,0,0,0,0,0)
+#define GL_FUNC_STATIC_1(_name_,_returntype_,targ1) \
+	GL_FUNC_STATIC(1, _name_,_returntype_,targ1,0,0,0,0,0,0,0,0,0)
+#define GL_FUNC_STATIC_2(_name_,_returntype_,targ1,targ2) \
+	GL_FUNC_STATIC(2, _name_,_returntype_,targ1,targ2,0,0,0,0,0,0,0,0)
+#define GL_FUNC_STATIC_3(_name_,_returntype_,targ1,targ2,targ3) \
+	GL_FUNC_STATIC(3, _name_,_returntype_,targ1,targ2,targ3,0,0,0,0,0,0,0)
+#define GL_FUNC_STATIC_4(_name_,_returntype_,targ1,targ2,targ3,targ4) \
+	GL_FUNC_STATIC(4, _name_,_returntype_,targ1,targ2,targ3,targ4,0,0,0,0,0,0)
+#define GL_FUNC_STATIC_5(_name_,_returntype_,targ1,targ2,targ3,targ4,targ5) \
+	GL_FUNC_STATIC(5, _name_,_returntype_,targ1,targ2,targ3,targ4,targ5,0,0,0,0,0)
+#define GL_FUNC_STATIC_6(_name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6) \
+	GL_FUNC_STATIC(6, _name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,0,0,0,0)
+#define GL_FUNC_STATIC_7(_name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,targ7) \
+	GL_FUNC_STATIC(7, _name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,targ7,0,0,0)
+#define GL_FUNC_STATIC_8(_name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,targ7,targ8) \
+	GL_FUNC_STATIC(8, _name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,targ7,targ8,0,0)
+#define GL_FUNC_STATIC_9(_name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,targ7,targ8,targ9) \
+	GL_FUNC_STATIC(9, _name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,targ7,targ8,targ9,0)
+#define GL_FUNC_STATIC_10(_name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,targ7,targ8,targ9,targ10_ver_) \
+	GL_FUNC_STATIC(10, _name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,targ7,targ8,targ9,targ10)
+
+/* Templates for glGen* and glDelete* */
+
+#define GL_FUNC_GENOBJECTS_LOAD(_name_,_ver_) \
+static VALUE gl_##_name_(VALUE obj,VALUE arg1) \
+{ \
+	GLsizei n; \
+	GLuint *objects; \
+	VALUE ret; \
+	GLsizei i; \
+  DECL_GL_FUNC_PTR(GLvoid,gl##_name_,(GLsizei,GLuint *)); \
+	LOAD_GL_FUNC(gl##_name_,_ver_); \
+	n = CONV_GLsizei(arg1); \
+	objects = ALLOC_N(GLuint, n); \
+	fptr_gl##_name_(n,objects); \
+	ret = rb_ary_new2(n); \
+	for (i = 0; i < n; i++) \
+	rb_ary_push(ret, RETCONV_GLuint(objects[i])); \
+	xfree(objects); \
+	CHECK_GLERROR_FROM("gl" #_name_); \
+	return ret; \
+}
+
+#define GL_FUNC_GENOBJECTS(_name_) \
+  GL_FUNC_GENOBJECTS_LOAD(_name_,"1.1")
+
+#define GL_FUNC_DELETEOBJECTS_LOAD(_name_,_ver_) \
+static VALUE gl_##_name_(VALUE obj,VALUE arg1) \
+{ \
+	GLsizei n; \
+  DECL_GL_FUNC_PTR(GLvoid,gl##_name_,(GLsizei,const GLuint *)); \
+	LOAD_GL_FUNC(gl##_name_,_ver_); \
+	if (TYPE(arg1)==T_ARRAY) { \
+		GLuint *objects; \
+		n = (GLsizei)RARRAY_LENINT(arg1); \
+		objects = ALLOC_N(GLuint,n); \
+		ary2cuint(arg1,objects,n);  \
+		fptr_gl##_name_(n,objects); \
+		xfree(objects); \
+	} else { \
+		GLuint object; \
+		object = CONV_GLsizei(arg1); \
+		fptr_gl##_name_(1,&object);  \
+	} \
+	CHECK_GLERROR_FROM("gl" #_name_); \
+	return Qnil; \
+}
+
+#define GL_FUNC_DELETEOBJECTS(_name_) \
+  GL_FUNC_DELETEOBJECTS_LOAD(_name_,"1.1")
+
+#endif

data/ext/opengl/gl-1.0-1.1.c

@@ -0,0 +1,3345 @@
+/*
+* Copyright (C) 1999 - 2005 Yoshi <yoshi@giganet.net>
+* Copyright (C) 2006 John M. Gabriele <jmg3000@gmail.com>
+* Copyright (C) 2007 Jan Dvorak <jan.dvorak@kraxnet.cz>
+*
+* This program is distributed under the terms of the MIT license.
+* See the included MIT-LICENSE file for the terms of this license.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#include "common.h"
+
+#ifndef MAX
+#define MAX(a, b)  (((a) > (b)) ? (a) : (b))
+#endif
+
+/* OpenGL 1.0 + 1.1 functions */
+
+GL_FUNC_STATIC_2(Accum,GLvoid, GLenum,GLfloat)
+GL_FUNC_STATIC_2(AlphaFunc,GLvoid, GLenum,GLclampf)
+GL_FUNC_STATIC_1(ArrayElement,GLvoid, GLint)
+GL_FUNC_STATIC_2(BindTexture,GLvoid, GLenum,GLuint)
+GL_FUNC_STATIC_2(BlendFunc,GLvoid, GLenum,GLenum)
+GL_FUNC_STATIC_1(CallList,GLvoid, GLuint)
+GL_FUNC_STATIC_1(Clear,GLvoid, GLbitfield)
+GL_FUNC_STATIC_4(ClearAccum,GLvoid, GLfloat,GLfloat,GLfloat,GLfloat)
+GL_FUNC_STATIC_4(ClearColor,GLvoid, GLfloat,GLfloat,GLfloat,GLfloat)
+GL_FUNC_STATIC_1(ClearDepth,GLvoid, GLclampd)
+GL_FUNC_STATIC_1(ClearIndex,GLvoid, GLfloat)
+GL_FUNC_STATIC_1(ClearStencil,GLvoid, GLint)
+GL_FUNC_STATIC_3(Color3b,GLvoid, GLbyte,GLbyte,GLbyte)
+GL_FUNC_STATIC_3(Color3d,GLvoid, GLdouble,GLdouble,GLdouble)
+GL_FUNC_STATIC_3(Color3f,GLvoid, GLfloat,GLfloat,GLfloat)
+GL_FUNC_STATIC_3(Color3i,GLvoid, GLint,GLint,GLint)
+GL_FUNC_STATIC_3(Color3s,GLvoid, GLshort,GLshort,GLshort)
+GL_FUNC_STATIC_3(Color3ub,GLvoid, GLubyte,GLubyte,GLubyte)
+GL_FUNC_STATIC_3(Color3ui,GLvoid, GLuint,GLuint,GLuint)
+GL_FUNC_STATIC_3(Color3us,GLvoid, GLushort,GLushort,GLushort)
+GL_FUNC_STATIC_4(Color4b,GLvoid, GLbyte,GLbyte,GLbyte,GLbyte)
+GL_FUNC_STATIC_4(Color4d,GLvoid, GLdouble,GLdouble,GLdouble,GLdouble)
+GL_FUNC_STATIC_4(Color4f,GLvoid, GLfloat,GLfloat,GLfloat,GLfloat)
+GL_FUNC_STATIC_4(Color4i,GLvoid, GLint,GLint,GLint,GLint)
+GL_FUNC_STATIC_4(Color4s,GLvoid, GLshort,GLshort,GLshort,GLshort)
+GL_FUNC_STATIC_4(Color4ub,GLvoid, GLubyte,GLubyte,GLubyte,GLubyte)
+GL_FUNC_STATIC_4(Color4ui,GLvoid, GLuint,GLuint,GLuint,GLuint)
+GL_FUNC_STATIC_4(Color4us,GLvoid, GLushort,GLushort,GLushort,GLushort)
+GL_FUNC_STATIC_4(ColorMask,GLvoid, GLboolean,GLboolean,GLboolean,GLboolean)
+GL_FUNC_STATIC_2(ColorMaterial,GLvoid, GLenum,GLenum)
+GL_FUNC_STATIC_5(CopyPixels,GLvoid, GLint,GLint,GLsizei,GLsizei,GLenum)
+GL_FUNC_STATIC_7(CopyTexImage1D,GLvoid, GLenum,GLint,GLenum,GLint,GLint,GLsizei,GLint)
+GL_FUNC_STATIC_8(CopyTexImage2D,GLvoid, GLenum,GLint,GLenum,GLint,GLint,GLsizei,GLsizei,GLint)
+GL_FUNC_STATIC_6(CopyTexSubImage1D,GLvoid, GLenum,GLint,GLint,GLint,GLint,GLsizei)
+GL_FUNC_STATIC_8(CopyTexSubImage2D,GLvoid, GLenum,GLint,GLint,GLint,GLint,GLint,GLsizei,GLsizei)
+GL_FUNC_STATIC_1(CullFace,GLvoid, GLenum)
+GL_FUNC_STATIC_2(DeleteLists,GLvoid, GLuint,GLuint)
+GL_FUNC_STATIC_1(DepthFunc,GLvoid, GLenum)
+GL_FUNC_STATIC_1(DepthMask,GLvoid, GLboolean)
+GL_FUNC_STATIC_2(DepthRange,GLvoid, GLclampd,GLclampd)
+GL_FUNC_STATIC_3(DrawArrays,GLvoid, GLenum,GLint,GLsizei)
+GL_FUNC_STATIC_1(DrawBuffer,GLvoid, GLenum)
+GL_FUNC_STATIC_1(EdgeFlag,GLvoid, GLboolean)
+GL_FUNC_STATIC_1(EvalCoord1d,GLvoid, GLdouble)
+GL_FUNC_STATIC_1(EvalCoord1f,GLvoid, GLfloat)
+GL_FUNC_STATIC_2(EvalCoord2d,GLvoid, GLdouble,GLdouble)
+GL_FUNC_STATIC_2(EvalCoord2f,GLvoid, GLfloat,GLfloat)
+GL_FUNC_STATIC_3(EvalMesh1,GLvoid, GLenum,GLint,GLint)
+GL_FUNC_STATIC_5(EvalMesh2,GLvoid, GLenum,GLint,GLint,GLint,GLint)
+GL_FUNC_STATIC_1(EvalPoint1,GLvoid, GLint)
+GL_FUNC_STATIC_2(EvalPoint2,GLvoid, GLint,GLint)
+GL_FUNC_STATIC_0(Finish,GLvoid)
+GL_FUNC_STATIC_0(Flush,GLvoid)
+GL_FUNC_STATIC_2(Fogi,GLvoid, GLenum,GLint)
+GL_FUNC_STATIC_2(Fogf,GLvoid, GLenum,GLfloat)
+GL_FUNC_STATIC_1(FrontFace,GLvoid, GLenum)
+GL_FUNC_STATIC_6(Frustum,GLvoid, GLdouble,GLdouble,GLdouble,GLdouble,GLdouble,GLdouble)
+GL_FUNC_STATIC_1(GenLists,GLuint, GLsizei)
+GL_FUNC_STATIC_0(GetError,GLenum)
+GL_FUNC_STATIC_2(Hint,GLvoid, GLenum,GLenum)
+GL_FUNC_STATIC_1(Indexd,GLvoid, GLdouble)
+GL_FUNC_STATIC_1(Indexf,GLvoid, GLfloat)
+GL_FUNC_STATIC_1(Indexi,GLvoid, GLint)
+GL_FUNC_STATIC_1(IndexMask,GLvoid, GLuint)
+GL_FUNC_STATIC_1(Indexs,GLvoid, GLshort)
+GL_FUNC_STATIC_1(Indexub,GLvoid, GLubyte)
+GL_FUNC_STATIC_0(InitNames,GLvoid)
+GL_FUNC_STATIC_1(IsEnabled,GLboolean, GLenum)
+GL_FUNC_STATIC_1(IsList,GLboolean, GLuint)
+GL_FUNC_STATIC_1(IsTexture,GLboolean, GLuint)
+GL_FUNC_STATIC_2(LightModelf,GLvoid, GLenum,GLfloat)
+GL_FUNC_STATIC_2(LightModeli,GLvoid, GLenum,GLint)
+GL_FUNC_STATIC_3(Lightf,GLvoid, GLenum,GLenum,GLfloat)
+GL_FUNC_STATIC_3(Lighti,GLvoid, GLenum,GLenum,GLint)
+GL_FUNC_STATIC_2(LineStipple,GLvoid, GLint,GLushort)
+GL_FUNC_STATIC_1(LineWidth,GLvoid, GLfloat)
+GL_FUNC_STATIC_1(ListBase,GLvoid, GLuint)
+GL_FUNC_STATIC_0(LoadIdentity,GLvoid)
+GL_FUNC_STATIC_1(LoadName,GLvoid, GLuint)
+GL_FUNC_STATIC_1(LogicOp,GLvoid, GLenum)
+GL_FUNC_STATIC_3(MapGrid1d,GLvoid, GLint,GLdouble,GLdouble)
+GL_FUNC_STATIC_3(MapGrid1f,GLvoid, GLint,GLfloat,GLfloat)
+GL_FUNC_STATIC_6(MapGrid2d,GLvoid, GLint,GLdouble,GLdouble,GLint,GLdouble,GLdouble)
+GL_FUNC_STATIC_6(MapGrid2f,GLvoid, GLint,GLfloat,GLfloat,GLint,GLfloat,GLfloat)
+GL_FUNC_STATIC_3(Materialf,GLvoid, GLenum,GLenum,GLfloat)
+GL_FUNC_STATIC_3(Materiali,GLvoid, GLenum,GLenum,GLint)
+GL_FUNC_STATIC_1(MatrixMode,GLvoid, GLenum)
+GL_FUNC_STATIC_3(Normal3b,GLvoid, GLbyte,GLbyte,GLbyte)
+GL_FUNC_STATIC_3(Normal3d,GLvoid, GLdouble,GLdouble,GLdouble)
+GL_FUNC_STATIC_3(Normal3f,GLvoid, GLfloat,GLfloat,GLfloat)
+GL_FUNC_STATIC_3(Normal3i,GLvoid, GLint,GLint,GLint)
+GL_FUNC_STATIC_3(Normal3s,GLvoid, GLshort,GLshort,GLshort)
+GL_FUNC_STATIC_6(Ortho,GLvoid, GLdouble,GLdouble,GLdouble,GLdouble,GLdouble,GLdouble)
+GL_FUNC_STATIC_1(PassThrough,GLvoid, GLfloat)
+GL_FUNC_STATIC_2(PixelStoref,GLvoid, GLenum,GLfloat)
+GL_FUNC_STATIC_2(PixelStorei,GLvoid, GLenum,GLint)
+GL_FUNC_STATIC_2(PixelTransferf,GLvoid, GLenum,GLfloat)
+GL_FUNC_STATIC_2(PixelTransferi,GLvoid, GLenum,GLint)
+GL_FUNC_STATIC_2(PixelZoom,GLvoid, GLfloat,GLfloat)
+GL_FUNC_STATIC_1(PointSize,GLvoid, GLfloat)
+GL_FUNC_STATIC_2(PolygonMode,GLvoid, GLenum,GLenum)
+GL_FUNC_STATIC_2(PolygonOffset,GLvoid, GLfloat,GLfloat)
+GL_FUNC_STATIC_0(PopAttrib,GLvoid)
+GL_FUNC_STATIC_0(PopClientAttrib,GLvoid)
+GL_FUNC_STATIC_0(PopName,GLvoid)
+GL_FUNC_STATIC_1(PushAttrib,GLvoid, GLbitfield)
+GL_FUNC_STATIC_1(PushClientAttrib,GLvoid, GLbitfield)
+GL_FUNC_STATIC_1(PushName,GLvoid, GLuint)
+GL_FUNC_STATIC_2(RasterPos2d,GLvoid, GLdouble,GLdouble)
+GL_FUNC_STATIC_2(RasterPos2f,GLvoid, GLfloat,GLfloat)
+GL_FUNC_STATIC_2(RasterPos2i,GLvoid, GLint,GLint)
+GL_FUNC_STATIC_2(RasterPos2s,GLvoid, GLshort,GLshort)
+GL_FUNC_STATIC_3(RasterPos3d,GLvoid, GLdouble,GLdouble,GLdouble)
+GL_FUNC_STATIC_3(RasterPos3f,GLvoid, GLfloat,GLfloat,GLfloat)
+GL_FUNC_STATIC_3(RasterPos3i,GLvoid, GLint,GLint,GLint)
+GL_FUNC_STATIC_3(RasterPos3s,GLvoid, GLshort,GLshort,GLshort)
+GL_FUNC_STATIC_4(RasterPos4d,GLvoid, GLdouble,GLdouble,GLdouble,GLdouble)
+GL_FUNC_STATIC_4(RasterPos4f,GLvoid, GLfloat,GLfloat,GLfloat,GLfloat)
+GL_FUNC_STATIC_4(RasterPos4i,GLvoid, GLint,GLint,GLint,GLint)
+GL_FUNC_STATIC_4(RasterPos4s,GLvoid, GLshort,GLshort,GLshort,GLshort)
+GL_FUNC_STATIC_1(ReadBuffer,GLvoid, GLenum)
+GL_FUNC_STATIC_4(Rectd,GLvoid, GLdouble,GLdouble,GLdouble,GLdouble)
+GL_FUNC_STATIC_4(Rectf,GLvoid, GLfloat,GLfloat,GLfloat,GLfloat)
+GL_FUNC_STATIC_4(Recti,GLvoid, GLint,GLint,GLint,GLint)
+GL_FUNC_STATIC_4(Rects,GLvoid, GLshort,GLshort,GLshort,GLshort)
+GL_FUNC_STATIC_1(RenderMode,GLint, GLenum)
+GL_FUNC_STATIC_4(Rotated,GLvoid, GLdouble,GLdouble,GLdouble,GLdouble)
+GL_FUNC_STATIC_4(Rotatef,GLvoid, GLfloat,GLfloat,GLfloat,GLfloat)
+GL_FUNC_STATIC_3(Scaled,GLvoid, GLdouble,GLdouble,GLdouble)
+GL_FUNC_STATIC_3(Scalef,GLvoid, GLfloat,GLfloat,GLfloat)
+GL_FUNC_STATIC_4(Scissor,GLvoid, GLint,GLint,GLint,GLint)
+GL_FUNC_STATIC_1(ShadeModel,GLvoid, GLenum)
+GL_FUNC_STATIC_3(StencilFunc,GLvoid, GLenum,GLint,GLuint)
+GL_FUNC_STATIC_1(StencilMask,GLvoid, GLuint)
+GL_FUNC_STATIC_3(StencilOp,GLvoid, GLenum,GLenum,GLenum)
+GL_FUNC_STATIC_1(TexCoord1d,GLvoid, GLdouble)
+GL_FUNC_STATIC_1(TexCoord1f,GLvoid, GLfloat)
+GL_FUNC_STATIC_1(TexCoord1i,GLvoid, GLint)
+GL_FUNC_STATIC_1(TexCoord1s,GLvoid, GLshort)
+GL_FUNC_STATIC_2(TexCoord2d,GLvoid, GLdouble,GLdouble)
+GL_FUNC_STATIC_2(TexCoord2f,GLvoid, GLfloat,GLfloat)
+GL_FUNC_STATIC_2(TexCoord2i,GLvoid, GLint,GLint)
+GL_FUNC_STATIC_2(TexCoord2s,GLvoid, GLshort,GLshort)
+GL_FUNC_STATIC_3(TexCoord3d,GLvoid, GLdouble,GLdouble,GLdouble)
+GL_FUNC_STATIC_3(TexCoord3f,GLvoid, GLfloat,GLfloat,GLfloat)
+GL_FUNC_STATIC_3(TexCoord3i,GLvoid, GLint,GLint,GLint)
+GL_FUNC_STATIC_3(TexCoord3s,GLvoid, GLshort,GLshort,GLshort)
+GL_FUNC_STATIC_4(TexCoord4d,GLvoid, GLdouble,GLdouble,GLdouble,GLdouble)
+GL_FUNC_STATIC_4(TexCoord4f,GLvoid, GLfloat,GLfloat,GLfloat,GLfloat)
+GL_FUNC_STATIC_4(TexCoord4i,GLvoid, GLint,GLint,GLint,GLint)
+GL_FUNC_STATIC_4(TexCoord4s,GLvoid, GLshort,GLshort,GLshort,GLshort)
+GL_FUNC_STATIC_3(TexEnvf,GLvoid, GLenum,GLenum,GLfloat)
+GL_FUNC_STATIC_3(TexEnvi,GLvoid, GLenum,GLenum,GLint)
+GL_FUNC_STATIC_3(TexGend,GLvoid, GLenum,GLenum,GLdouble)
+GL_FUNC_STATIC_3(TexGenf,GLvoid, GLenum,GLenum,GLfloat)
+GL_FUNC_STATIC_3(TexGeni,GLvoid, GLenum,GLenum,GLint)
+GL_FUNC_STATIC_3(TexParameterf,GLvoid, GLenum,GLenum,GLfloat)
+GL_FUNC_STATIC_3(TexParameteri,GLvoid, GLenum,GLenum,GLint)
+GL_FUNC_STATIC_3(Translated,GLvoid, GLdouble,GLdouble,GLdouble)
+GL_FUNC_STATIC_3(Translatef,GLvoid, GLfloat,GLfloat,GLfloat)
+GL_FUNC_STATIC_2(Vertex2d,GLvoid, GLdouble,GLdouble)
+GL_FUNC_STATIC_2(Vertex2f,GLvoid, GLfloat,GLfloat)
+GL_FUNC_STATIC_2(Vertex2i,GLvoid, GLint,GLint)
+GL_FUNC_STATIC_2(Vertex2s,GLvoid, GLshort,GLshort)
+GL_FUNC_STATIC_3(Vertex3d,GLvoid, GLdouble,GLdouble,GLdouble)
+GL_FUNC_STATIC_3(Vertex3f,GLvoid, GLfloat,GLfloat,GLfloat)
+GL_FUNC_STATIC_3(Vertex3i,GLvoid, GLint,GLint,GLint)
+GL_FUNC_STATIC_3(Vertex3s,GLvoid, GLshort,GLshort,GLshort)
+GL_FUNC_STATIC_4(Vertex4d,GLvoid, GLdouble,GLdouble,GLdouble,GLdouble)
+GL_FUNC_STATIC_4(Vertex4f,GLvoid, GLfloat,GLfloat,GLfloat,GLfloat)
+GL_FUNC_STATIC_4(Vertex4i,GLvoid, GLint,GLint,GLint,GLint)
+GL_FUNC_STATIC_4(Vertex4s,GLvoid, GLshort,GLshort,GLshort,GLshort)
+GL_FUNC_STATIC_4(Viewport,GLvoid, GLuint,GLuint,GLuint,GLuint)
+
+struct gl_endisable_args {
+    VALUE obj;
+    VALUE caps;
+  };
+
+static VALUE
+gl_Enable1(struct gl_endisable_args *args)
+{
+  long i;
+  VALUE obj = args->obj;
+  DECL_GL_FUNC_PTR(void,glEnable,(GLenum cap));
+
+  LOAD_GL_FUNC(glEnable, NULL);
+  for (i = 0; i < RARRAY_LEN(args->caps); i++) {
+    fptr_glEnable(CONV_GLenum(rb_ary_entry(args->caps, i)));
+
+    CHECK_GLERROR_FROM("glEnable");
+  }
+
+  return Qnil;
+}
+
+static VALUE
+gl_Enable0(struct gl_endisable_args *args)
+{
+  gl_Enable1(args);
+
+  if (rb_block_given_p())
+    rb_yield(Qundef);
+
+  return Qnil;
+}
+
+static VALUE
+gl_Disable1(struct gl_endisable_args *args)
+{
+  long i;
+  VALUE obj = args->obj;
+  DECL_GL_FUNC_PTR(void,glDisable,(GLenum cap));
+
+  LOAD_GL_FUNC(glDisable, NULL);
+  for (i = 0; i < RARRAY_LEN(args->caps); i++) {
+    fptr_glDisable(CONV_GLenum(rb_ary_entry(args->caps, i)));
+
+    CHECK_GLERROR_FROM("glDisable");
+  }
+
+  return Qnil;
+}
+
+static VALUE
+gl_Disable0(struct gl_endisable_args *args)
+{
+  gl_Disable1(args);
+
+  if (rb_block_given_p())
+    rb_yield(Qundef);
+
+  return Qnil;
+}
+
+static VALUE
+gl_Enable(int argc, VALUE *argv, VALUE obj)
+{
+  int i;
+  VALUE caps, rev;
+
+  rb_scan_args(argc, argv, "1*", NULL, NULL);
+
+  caps = rb_ary_new2(argc);
+
+  for (i = 0; i < argc; i++)
+    rb_ary_push(caps, argv[i]);
+
+  rev = rb_ary_reverse(caps);
+
+  if (rb_block_given_p()){
+    struct gl_endisable_args enargs = { obj, caps };
+    struct gl_endisable_args disargs = { obj, rev };
+    return rb_ensure(gl_Enable0, (VALUE)&enargs, gl_Disable1, (VALUE)&disargs);
+  } else {
+    struct gl_endisable_args args = { obj, caps };
+    gl_Enable0(&args);
+  }
+
+  return Qnil;
+}
+
+static VALUE
+gl_Disable(int argc, VALUE *argv, VALUE obj)
+{
+  int i;
+  VALUE caps, rev;
+
+  rb_scan_args(argc, argv, "1*", NULL, NULL);
+
+  caps = rb_ary_new2(argc);
+
+  for (i = 0; i < argc; i++)
+    rb_ary_push(caps, argv[i]);
+
+  rev = rb_ary_reverse(caps);
+
+  if (rb_block_given_p()){
+    struct gl_endisable_args disargs = { obj, caps };
+    struct gl_endisable_args enargs = { obj, rev };
+    return rb_ensure(gl_Disable0, (VALUE)&disargs, gl_Enable1, (VALUE)&enargs);
+  } else {
+    struct gl_endisable_args args = { obj, caps };
+    gl_Disable0(&args);
+  }
+
+  return Qnil;
+}
+
+struct gl_client_state_args {
+    VALUE obj;
+    VALUE ary;
+  };
+
+static VALUE
+gl_EnableClientState1(struct gl_client_state_args *args)
+{
+  long i;
+  VALUE obj = args->obj;
+  DECL_GL_FUNC_PTR(void,glEnableClientState,(GLenum cap));
+
+  LOAD_GL_FUNC(glEnableClientState, NULL);
+  for (i = 0; i < RARRAY_LEN(args->ary); i++) {
+    fptr_glEnableClientState(CONV_GLenum(rb_ary_entry(args->ary, i)));
+
+    CHECK_GLERROR_FROM("glEnableClientState");
+  }
+
+  return Qnil;
+}
+
+static VALUE
+gl_EnableClientState0(struct gl_client_state_args *args)
+{
+  gl_EnableClientState1(args);
+
+  if (rb_block_given_p())
+    rb_yield(Qundef);
+
+  return Qnil;
+}
+
+static VALUE
+gl_DisableClientState1(struct gl_client_state_args *args)
+{
+  long i;
+  VALUE obj = args->obj;
+  DECL_GL_FUNC_PTR(void,glDisableClientState,(GLenum cap));
+
+  LOAD_GL_FUNC(glDisableClientState, NULL);
+  for (i = 0; i < RARRAY_LEN(args->ary); i++) {
+    fptr_glDisableClientState(CONV_GLenum(rb_ary_entry(args->ary, i)));
+
+    CHECK_GLERROR_FROM("glDisableClientState");
+  }
+
+  return Qnil;
+}
+
+static VALUE
+gl_DisableClientState0(struct gl_client_state_args *args)
+{
+  gl_DisableClientState1(args);
+
+  if (rb_block_given_p())
+    rb_yield(Qundef);
+
+  return Qnil;
+}
+
+static VALUE
+gl_EnableClientState(int argc, VALUE *argv, VALUE obj)
+{
+  int i;
+  VALUE ary, rev;
+
+  rb_scan_args(argc, argv, "1*", NULL, NULL);
+
+  ary = rb_ary_new2(argc);
+
+  for (i = 0; i < argc; i++)
+    rb_ary_push(ary, argv[i]);
+
+  rev = rb_ary_reverse(ary);
+
+  if (rb_block_given_p()){
+    struct gl_client_state_args enargs = { obj, ary };
+    struct gl_client_state_args disargs = { obj, rev };
+    return rb_ensure(gl_EnableClientState0, (VALUE)&enargs, gl_DisableClientState1, (VALUE)&disargs);
+  } else {
+    struct gl_client_state_args args = { obj, ary };
+    gl_EnableClientState0(&args);
+  }
+
+  return Qnil;
+}
+
+static VALUE
+gl_DisableClientState(int argc, VALUE *argv, VALUE obj)
+{
+  int i;
+  VALUE ary, rev;
+
+  rb_scan_args(argc, argv, "1*", NULL, NULL);
+
+  ary = rb_ary_new2(argc);
+
+  for (i = 0; i < argc; i++)
+    rb_ary_push(ary, argv[i]);
+
+  rev = rb_ary_reverse(ary);
+
+  if (rb_block_given_p()){
+    struct gl_client_state_args disargs = { obj, ary };
+    struct gl_client_state_args enargs = { obj, rev };
+    return rb_ensure(gl_DisableClientState0, (VALUE)&disargs, gl_EnableClientState1, (VALUE)&enargs);
+  } else {
+    struct gl_client_state_args args = { obj, ary };
+    gl_DisableClientState0(&args);
+  }
+
+  return Qnil;
+}
+
+struct gl_begin0_args {
+    VALUE obj;
+    GLenum mode;
+  };
+
+static VALUE
+gl_Begin0(struct gl_begin0_args *args)
+{
+  VALUE obj = args->obj;
+  DECL_GL_FUNC_PTR(void,glBegin,(GLenum mode));
+
+  LOAD_GL_FUNC(glBegin, NULL);
+  fptr_glBegin(args->mode);
+
+  if (rb_block_given_p())
+    rb_yield(Qundef);
+
+  return Qnil;
+}
+
+static VALUE
+gl_End(VALUE obj)
+{
+  DECL_GL_FUNC_PTR(void,glEnd,(void));
+
+  LOAD_GL_FUNC(glEnd, NULL);
+  SET_GLIMPL_VARIABLE(inside_begin_end, Qfalse);
+
+  fptr_glEnd();
+
+  CHECK_GLERROR_FROM("glEnd");
+
+  return Qnil;
+}
+
+static VALUE
+gl_Begin(VALUE obj, VALUE mode)
+{
+  struct gl_begin0_args args = { obj, CONV_GLenum(mode) };
+
+  SET_GLIMPL_VARIABLE(inside_begin_end, Qtrue);
+
+  if (rb_block_given_p())
+    return rb_ensure(gl_Begin0, (VALUE)&args, gl_End, obj);
+  else
+    gl_Begin0(&args);
+
+  return Qnil;
+}
+
+static VALUE
+gl_PopMatrix(VALUE obj)
+{
+  DECL_GL_FUNC_PTR(void,glPopMatrix,(void));
+
+  LOAD_GL_FUNC(glPopMatrix, NULL);
+  fptr_glPopMatrix();
+
+  CHECK_GLERROR_FROM("glPopMatrix");
+
+  return Qnil;
+}
+
+static VALUE
+gl_PushMatrix0(VALUE obj)
+{
+  DECL_GL_FUNC_PTR(void,glPushMatrix,(void));
+
+  LOAD_GL_FUNC(glPushMatrix, NULL);
+  fptr_glPushMatrix();
+
+  if (rb_block_given_p())
+    rb_yield(Qnil);
+
+  return Qnil;
+}
+
+static VALUE
+gl_PushMatrix(VALUE obj)
+{
+  if (rb_block_given_p())
+    return rb_ensure(gl_PushMatrix0, obj, gl_PopMatrix, obj);
+  else {
+    DECL_GL_FUNC_PTR(void,glPushMatrix,(void));
+    LOAD_GL_FUNC(glPushMatrix, NULL);
+    fptr_glPushMatrix();
+  }
+
+  return Qnil;
+}
+
+struct gl_list_args {
+  VALUE obj;
+  VALUE list;
+  VALUE mode;
+};
+
+static VALUE
+gl_NewList0(struct gl_list_args *args)
+{
+  GLuint list;
+  GLenum mode;
+  VALUE obj = args->obj;
+  DECL_GL_FUNC_PTR(void,glNewList,(GLuint list, GLenum mode));
+
+  LOAD_GL_FUNC(glNewList, NULL);
+  list = (GLuint)NUM2UINT(args->list);
+  mode = RUBY2GLENUM(args->mode);
+
+  fptr_glNewList(list, mode);
+
+  if (rb_block_given_p())
+    rb_yield(Qundef);
+
+  return Qnil;
+}
+
+static VALUE
+gl_EndList(VALUE obj)
+{
+  DECL_GL_FUNC_PTR(void,glEndList,(void));
+
+  LOAD_GL_FUNC(glEndList, NULL);
+  fptr_glEndList();
+
+  return Qnil;
+}
+
+static VALUE
+gl_NewList(VALUE obj, VALUE list, VALUE mode)
+{
+  struct gl_list_args args = { obj, list, mode };
+
+  if (rb_block_given_p())
+    return rb_ensure(gl_NewList0, (VALUE)&args, gl_EndList, obj);
+  else
+    gl_NewList0(&args);
+
+  return Qnil;
+}
+
+static VALUE
+gl_CallLists(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+  GLsizei n;
+  GLenum type;
+  VALUE lists;
+  DECL_GL_FUNC_PTR(GLvoid,glCallLists,(GLsizei n, GLenum type, const GLvoid *lists));
+
+  LOAD_GL_FUNC(glCallLists, NULL);
+  type = CONV_GLenum(arg1);
+  lists = pack_array_or_pass_string(type,arg2);
+  n = (GLsizei)RSTRING_LENINT(lists) / gltype_glformat_unit_size(type,1);
+  fptr_glCallLists(n, type, RSTRING_PTR(lists));
+  CHECK_GLERROR_FROM("glCallLists");
+  return Qnil;
+}
+
+static VALUE
+gl_Bitmap(obj,arg1,arg2,arg3,arg4,arg5,arg6,arg7)
+VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6,arg7;
+{
+  GLsizei width;
+  GLsizei height;
+  GLfloat xorig;
+  GLfloat yorig;
+  GLfloat xmove;
+  GLfloat ymove;
+  DECL_GL_FUNC_PTR(void,glBitmap,(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap));
+
+  LOAD_GL_FUNC(glBitmap, NULL);
+  width = (GLsizei)NUM2UINT(arg1);
+  height = (GLsizei)NUM2UINT(arg2);
+  xorig = (GLfloat)NUM2DBL(arg3);
+  yorig = (GLfloat)NUM2DBL(arg4);
+  xmove = (GLfloat)NUM2DBL(arg5);
+  ymove = (GLfloat)NUM2DBL(arg6);
+  if (CHECK_BUFFER_BINDING(GL_PIXEL_UNPACK_BUFFER_BINDING)) {
+    fptr_glBitmap(width, height, xorig, yorig, xmove, ymove, (GLubyte *)NUM2SIZET(arg7));
+  } else {
+    VALUE data;
+    data = pack_array_or_pass_string(GL_UNSIGNED_BYTE,arg7);
+
+    if ((RSTRING_LEN(data)*8) < (width * height))
+      rb_raise(rb_eArgError, "string length:%li", RSTRING_LEN(data));
+
+    fptr_glBitmap(width, height, xorig, yorig, xmove, ymove, (const GLubyte *)RSTRING_PTR(data));
+  }
+  CHECK_GLERROR_FROM("glBitmap");
+  return Qnil;
+}
+
+static VALUE
+gl_EdgeFlagv(obj,arg1)
+VALUE obj,arg1;
+{
+  GLboolean flag[1] = { GL_FALSE };
+  DECL_GL_FUNC_PTR(void,glEdgeFlagv,(const GLboolean *flag));
+
+  LOAD_GL_FUNC(glEdgeFlagv, NULL);
+  Check_Type(arg1,T_ARRAY);
+  ary2cboolean(arg1,flag,1);
+  fptr_glEdgeFlagv(flag);
+  CHECK_GLERROR_FROM("glEdgeFlagv");
+  return Qnil;
+}
+
+static VALUE
+gl_Indexdv(obj,arg1)
+VALUE obj,arg1;
+{
+  GLdouble c[1] = {0.0};
+  DECL_GL_FUNC_PTR(void,glIndexdv,(const GLdouble *c));
+
+  LOAD_GL_FUNC(glIndexdv, NULL);
+  Check_Type(arg1,T_ARRAY);
+  ary2cdbl(arg1,c,1);
+  fptr_glIndexdv(c);
+  CHECK_GLERROR_FROM("glIndexdv");
+  return Qnil;
+}
+
+static VALUE
+gl_Indexfv(obj,arg1)
+VALUE obj,arg1;
+{
+  GLfloat c[1] = { (GLfloat)0.0 };
+  DECL_GL_FUNC_PTR(void,glIndexfv,(const GLfloat *c));
+
+  LOAD_GL_FUNC(glIndexfv, NULL);
+  Check_Type(arg1,T_ARRAY);
+  ary2cflt(arg1,c,1);
+  fptr_glIndexfv(c);
+  CHECK_GLERROR_FROM("glIndexfv");
+  return Qnil;
+}
+
+static VALUE
+gl_Indexiv(obj,arg1)
+VALUE obj,arg1;
+{
+  GLint c[1] = {0};
+  DECL_GL_FUNC_PTR(void,glIndexiv,(const GLint *c));
+
+  LOAD_GL_FUNC(glIndexiv, NULL);
+  Check_Type(arg1,T_ARRAY);
+  ary2cint(arg1,c,1);
+  fptr_glIndexiv(c);
+  CHECK_GLERROR_FROM("glIndexiv");
+  return Qnil;
+}
+
+static VALUE
+gl_Indexsv(obj,arg1)
+VALUE obj,arg1;
+{
+  GLshort c[1] = {0};
+  DECL_GL_FUNC_PTR(void,glIndexsv,(const GLshort *c));
+
+  LOAD_GL_FUNC(glIndexsv, NULL);
+  Check_Type(arg1,T_ARRAY);
+  ary2cshort(arg1,c,1);
+  fptr_glIndexsv(c);
+  CHECK_GLERROR_FROM("glIndexsv");
+  return Qnil;
+}
+
+static VALUE
+gl_ClipPlane(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+  GLenum plane;
+  GLdouble equation[4];
+  DECL_GL_FUNC_PTR(void,glClipPlane,(GLenum plane, const GLdouble *equation));
+
+  LOAD_GL_FUNC(glClipPlane, NULL);
+  plane = (GLenum)NUM2INT(arg1);
+  Check_Type(arg2,T_ARRAY);
+  ary2cdbl(arg2, equation, 4);
+  fptr_glClipPlane(plane,equation);
+  CHECK_GLERROR_FROM("glClipPlane");
+  return Qnil;
+}
+
+static VALUE
+gl_Fogfv(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+  GLenum pname;
+  GLfloat params[4] = {(GLfloat)0.0, (GLfloat)0.0, (GLfloat)0.0, (GLfloat)0.0};
+  DECL_GL_FUNC_PTR(void,glFogfv,(GLenum pname, const GLfloat *params));
+
+  LOAD_GL_FUNC(glFogfv, NULL);
+  pname = (GLenum)NUM2INT(arg1);
+  Check_Type(arg2,T_ARRAY);
+  ary2cflt(arg2,params,4);
+  fptr_glFogfv(pname,params);
+  CHECK_GLERROR_FROM("glFogfv");
+  return Qnil;
+}
+
+static VALUE
+gl_Fogiv(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+  GLenum pname;
+  GLint params[4] = {0,0,0,0};
+  DECL_GL_FUNC_PTR(void,glFogiv,(GLenum pname, const GLint *params));
+
+  LOAD_GL_FUNC(glFogiv, NULL);
+  pname = (GLenum)NUM2INT(arg1);
+  Check_Type(arg2,T_ARRAY);
+  ary2cint(arg2,params,4);
+  fptr_glFogiv(pname,params);
+  CHECK_GLERROR_FROM("glFogiv");
+  return Qnil;
+}
+
+static VALUE
+gl_Lightfv(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+  GLenum light;
+  GLenum pname;
+  GLfloat params[4] = {(GLfloat)0.0, (GLfloat)0.0, (GLfloat)0.0, (GLfloat)0.0};
+  DECL_GL_FUNC_PTR(void,glLightfv,(GLenum light, GLenum pname, const GLfloat *params));
+
+  LOAD_GL_FUNC(glLightfv, NULL);
+  light = (GLenum)NUM2INT(arg1);
+  pname = (GLenum)NUM2INT(arg2);
+  Check_Type(arg3,T_ARRAY);
+  ary2cflt(arg3,params,4);
+  fptr_glLightfv(light,pname,params);
+  CHECK_GLERROR_FROM("glLightfv");
+  return Qnil;
+}
+
+static VALUE
+gl_Lightiv(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+  GLenum light;
+  GLenum pname;
+  GLint params[4]={0,0,0,0};
+  DECL_GL_FUNC_PTR(void,glLightiv,(GLenum light, GLenum pname, const GLint *params));
+
+  LOAD_GL_FUNC(glLightiv, NULL);
+  light = (GLenum)NUM2INT(arg1);
+  pname = (GLenum)NUM2INT(arg2);
+  Check_Type(arg3,T_ARRAY);
+  ary2cint(arg3,params,4);
+  fptr_glLightiv(light,pname,params);
+  CHECK_GLERROR_FROM("glLightiv");
+  return Qnil;
+}
+
+static VALUE
+gl_LightModelfv(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+  GLenum pname;
+  GLfloat params[4] = {(GLfloat)0.0, (GLfloat)0.0, (GLfloat)0.0, (GLfloat)0.0};
+  DECL_GL_FUNC_PTR(void,glLightModelfv,(GLenum pname, const GLfloat *params));
+
+  LOAD_GL_FUNC(glLightModelfv, NULL);
+  pname = (GLenum)NUM2INT(arg1);
+  Check_Type(arg2,T_ARRAY);
+  ary2cflt(arg2,params,4);
+  fptr_glLightModelfv(pname,params);
+  CHECK_GLERROR_FROM("glLightModelfv");
+  return Qnil;
+}
+
+static VALUE
+gl_LightModeliv(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+  GLenum pname;
+  GLint params[4] = {0,0,0,0};
+  DECL_GL_FUNC_PTR(void,glLightModeliv,(GLenum pname, const GLint *params));
+
+  LOAD_GL_FUNC(glLightModeliv, NULL);
+  pname = (GLenum)NUM2INT(arg1);
+  Check_Type(arg2,T_ARRAY);
+  ary2cint(arg2,params,4);
+  fptr_glLightModeliv(pname,params);
+  CHECK_GLERROR_FROM("glLightModeliv");
+  return Qnil;
+}
+
+
+static VALUE
+gl_Materialfv(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+  GLenum face;
+  GLenum pname;
+  GLfloat params[4] = {(GLfloat)0.0, (GLfloat)0.0, (GLfloat)0.0, (GLfloat)0.0};
+  DECL_GL_FUNC_PTR(void,glMaterialfv,(GLenum face, GLenum pname, const GLfloat *params));
+
+  LOAD_GL_FUNC(glMaterialfv, NULL);
+  face = (GLenum)NUM2INT(arg1);
+  pname = (GLenum)NUM2INT(arg2);
+  Check_Type(arg3,T_ARRAY);
+  ary2cflt(arg3,params,4);
+  fptr_glMaterialfv(face,pname,params);
+  CHECK_GLERROR_FROM("glMaterialfv");
+  return Qnil;
+}
+
+static VALUE
+gl_Materialiv(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+  GLenum face;
+  GLenum pname;
+  GLint params[4] = {0,0,0,0};
+  DECL_GL_FUNC_PTR(void,glMaterialiv,(GLenum face, GLenum pname, const GLint *params));
+
+  LOAD_GL_FUNC(glMaterialiv, NULL);
+  face = (GLenum)NUM2INT(arg1);
+  pname = (GLenum)NUM2INT(arg2);
+  Check_Type(arg3,T_ARRAY);
+  ary2cint(arg3,params,4);
+  fptr_glMaterialiv(face,pname,params);
+  CHECK_GLERROR_FROM("glMaterialiv");
+  return Qnil;
+}
+
+static VALUE
+gl_PolygonStipple(obj,arg1)
+VALUE obj,arg1;
+{
+  DECL_GL_FUNC_PTR(void,glPolygonStipple,(const GLubyte *mask));
+
+  LOAD_GL_FUNC(glPolygonStipple, NULL);
+  if (CHECK_BUFFER_BINDING(GL_PIXEL_UNPACK_BUFFER_BINDING)) {
+    fptr_glPolygonStipple((GLubyte *)NUM2SIZET(arg1));
+  } else {
+    VALUE data;
+    data = pack_array_or_pass_string(GL_UNSIGNED_BYTE,arg1);
+    if (RSTRING_LEN(data) < 128)
+      rb_raise(rb_eArgError, "string length:%li", RSTRING_LEN(data));
+
+    fptr_glPolygonStipple((GLubyte *)RSTRING_PTR(data));
+  }
+  CHECK_GLERROR_FROM("glPolygonStipple");
+  return Qnil;
+}
+
+
+static VALUE
+gl_TexParameterfv(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+  GLenum target;
+  GLenum pname;
+  GLfloat params[4] = {(GLfloat)0.0, (GLfloat)0.0, (GLfloat)0.0, (GLfloat)0.0};
+  DECL_GL_FUNC_PTR(void,glTexParameterfv,(GLenum target, GLenum pname, const GLfloat *params));
+
+  LOAD_GL_FUNC(glTexParameterfv, NULL);
+  target = (GLenum)NUM2INT(arg1);
+  pname = (GLenum)NUM2INT(arg2);
+  Check_Type(arg3,T_ARRAY);
+  ary2cflt(arg3,params,4);
+  fptr_glTexParameterfv(target,pname,params);
+  CHECK_GLERROR_FROM("glTexParameterfv");
+  return Qnil;
+}
+
+static VALUE
+gl_TexParameteriv(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+  GLenum target;
+  GLenum pname;
+  GLint params[4] = {0,0,0,0};
+  DECL_GL_FUNC_PTR(void,glTexParameteriv,(GLenum target, GLenum pname, const GLint *params));
+
+  LOAD_GL_FUNC(glTexParameteriv, NULL);
+  target = (GLenum)NUM2INT(arg1);
+  pname = (GLenum)NUM2INT(arg2);
+  Check_Type(arg3,T_ARRAY);
+  ary2cint(arg3,params,4);
+  fptr_glTexParameteriv(target,pname,params);
+  CHECK_GLERROR_FROM("glTexParameteriv");
+  return Qnil;
+}
+
+static VALUE
+gl_TexImage1D(obj,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8)
+VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8;
+{
+  GLenum target;
+  GLint level;
+  GLint components;
+  GLsizei width;
+  GLint border;
+  GLenum format;
+  GLenum type;
+  const char *pixels;
+  DECL_GL_FUNC_PTR(void,glTexImage1D,(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels));
+
+  LOAD_GL_FUNC(glTexImage1D, NULL);
+  target = (GLenum)NUM2INT(arg1);
+  level = (GLint)NUM2INT(arg2);
+  components = (GLint)NUM2INT(arg3);
+  width = (GLsizei)NUM2UINT(arg4);
+  border = (GLint)NUM2INT(arg5);
+  format = (GLenum)NUM2INT(arg6);
+  type = (GLenum)NUM2INT(arg7);
+
+  if (CHECK_BUFFER_BINDING(GL_PIXEL_UNPACK_BUFFER_BINDING)) {
+    fptr_glTexImage1D(target,level,components,width,border,format,type,(GLvoid *)NUM2SIZET(arg8));
+    CHECK_GLERROR_FROM("glTexImage1D");
+    return Qnil;
+  }
+
+  if (target == GL_PROXY_TEXTURE_1D || NIL_P(arg8)) { /* proxy texture, no data read */
+    pixels = NULL;
+  } else {
+    VALUE data;
+    data = pack_array_or_pass_string(type,arg8);
+    CheckDataSize(type,format,width,data);
+    pixels = RSTRING_PTR(data);
+  }
+  fptr_glTexImage1D(target,level,components,width,border,format,type,pixels);
+  CHECK_GLERROR_FROM("glTexImage1D");
+  return Qnil;
+}
+
+static VALUE
+gl_TexImage2D(obj,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9)
+VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9;
+{
+  GLenum target;
+  GLint level;
+  GLint components;
+  GLsizei width;
+  GLsizei height;
+  GLint border;
+  GLenum format;
+  GLenum type;
+  const char *pixels;
+  DECL_GL_FUNC_PTR(void,glTexImage2D,(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels));
+
+  LOAD_GL_FUNC(glTexImage2D, NULL);
+  target = (GLenum)NUM2INT(arg1);
+  level = (GLint)NUM2INT(arg2);
+  components = (GLint)NUM2INT(arg3);
+  width = (GLsizei)NUM2UINT(arg4);
+  height = (GLsizei)NUM2UINT(arg5);
+  border = (GLint)NUM2INT(arg6);
+  format = (GLenum)NUM2INT(arg7);
+  type = (GLenum)NUM2INT(arg8);
+
+  if (CHECK_BUFFER_BINDING(GL_PIXEL_UNPACK_BUFFER_BINDING)) {
+    fptr_glTexImage2D(target,level,components,width,height,border,format,type,(GLvoid *)NUM2SIZET(arg9));
+    CHECK_GLERROR_FROM("glTexImage2D");
+    return Qnil;
+  }
+
+  if (target == GL_PROXY_TEXTURE_2D || target == GL_PROXY_TEXTURE_1D_ARRAY_EXT || target == GL_PROXY_TEXTURE_CUBE_MAP || NIL_P(arg9)) { /* proxy texture, no data read */
+    pixels = NULL;
+  } else {
+    VALUE data;
+    data = pack_array_or_pass_string(type,arg9);
+    CheckDataSize(type,format,width*height,data);
+    pixels = RSTRING_PTR(data);
+  }
+  fptr_glTexImage2D(target,level,components,width,height,border,format,type,pixels);
+  CHECK_GLERROR_FROM("glTexImage2D");
+  return Qnil;
+}
+
+static VALUE
+gl_TexEnvfv(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+  GLenum target;
+  GLenum pname;
+  GLfloat params[4] = {(GLfloat)0.0, (GLfloat)0.0, (GLfloat)0.0, (GLfloat)0.0};
+  DECL_GL_FUNC_PTR(void,glTexEnvfv,(GLenum target, GLenum pname, const GLfloat *params));
+
+  LOAD_GL_FUNC(glTexEnvfv, NULL);
+  target = (GLenum)NUM2INT(arg1);
+  pname = (GLenum)NUM2INT(arg2);
+  Check_Type(arg3,T_ARRAY);
+  ary2cflt(arg3,params,4);
+  fptr_glTexEnvfv(target,pname,params);
+  CHECK_GLERROR_FROM("glTexEnvfv");
+  return Qnil;
+}
+
+static VALUE
+gl_TexEnviv(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+  GLenum target;
+  GLenum pname;
+  GLint params[4] = {0,0,0,0};
+  DECL_GL_FUNC_PTR(void,glTexEnviv,(GLenum target, GLenum pname, const GLint *params));
+
+  LOAD_GL_FUNC(glTexEnviv, NULL);
+  target = (GLenum)NUM2INT(arg1);
+  pname = (GLenum)NUM2INT(arg2);
+  Check_Type(arg3,T_ARRAY);
+  ary2cint(arg3,params,4);
+  fptr_glTexEnviv(target,pname,params);
+  CHECK_GLERROR_FROM("glTexEnviv");
+  return Qnil;
+}
+
+
+static VALUE
+gl_TexGendv(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+  GLenum coord;
+  GLenum pname;
+  GLdouble params[4] = {0.0,0.0,0.0,0.0};
+  DECL_GL_FUNC_PTR(void,glTexGendv,(GLenum coord, GLenum pname, const GLdouble *params));
+
+  LOAD_GL_FUNC(glTexGendv, NULL);
+  coord = (GLenum)NUM2INT(arg1);
+  pname = (GLenum)NUM2INT(arg2);
+  Check_Type(arg3,T_ARRAY);
+  ary2cdbl(arg3,params,4);
+  fptr_glTexGendv(coord,pname,params);
+  CHECK_GLERROR_FROM("glTexGendv");
+  return Qnil;
+}
+
+
+static VALUE
+gl_TexGenfv(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+  GLenum coord;
+  GLenum pname;
+  GLfloat params[4] = {(GLfloat)0.0, (GLfloat)0.0, (GLfloat)0.0, (GLfloat)0.0};
+  DECL_GL_FUNC_PTR(void,glTexGenfv,(GLenum coord, GLenum pname, const GLfloat *params));
+
+  LOAD_GL_FUNC(glTexGenfv, NULL);
+  coord = (GLenum)NUM2INT(arg1);
+  pname = (GLenum)NUM2INT(arg2);
+  Check_Type(arg3,T_ARRAY);
+  ary2cflt(arg3,params,4);
+  fptr_glTexGenfv(coord,pname,params);
+  CHECK_GLERROR_FROM("glTexGenfv");
+  return Qnil;
+}
+
+
+static VALUE
+gl_TexGeniv(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+  GLenum coord;
+  GLenum pname;
+  GLint params[4] = {0,0,0,0};
+  DECL_GL_FUNC_PTR(void,glTexGeniv,(GLenum coord, GLenum pname, const GLint *params));
+
+  LOAD_GL_FUNC(glTexGeniv, NULL);
+  coord = (GLenum)NUM2INT(arg1);
+  pname = (GLenum)NUM2INT(arg2);
+  Check_Type(arg3,T_ARRAY);
+  ary2cint(arg3,params,4);
+  fptr_glTexGeniv(coord,pname,params);
+  CHECK_GLERROR_FROM("glTexGeniv");
+  return Qnil;
+}
+static VALUE
+gl_FeedbackBuffer(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+  GLsizei size;
+  GLenum type;
+  VALUE current_feed_buffer;
+  DECL_GL_FUNC_PTR(void,glFeedbackBuffer,(GLsizei size, GLenum type, GLfloat *buffer));
+
+  LOAD_GL_FUNC(glFeedbackBuffer, NULL);
+  size = (GLsizei)NUM2UINT(arg1);
+  type = (GLenum)NUM2INT(arg2);
+  current_feed_buffer = allocate_buffer_with_string(sizeof(GLfloat)*size);
+  rb_str_freeze(current_feed_buffer);
+  fptr_glFeedbackBuffer(size, type, (GLfloat*)RSTRING_PTR(current_feed_buffer));
+  CHECK_GLERROR_FROM("glFeedbackBuffer");
+  SET_GLIMPL_VARIABLE(current_feed_buffer, current_feed_buffer);
+  return current_feed_buffer;
+}
+
+static VALUE
+gl_SelectBuffer(obj,arg1)
+VALUE obj,arg1;
+{
+  GLsizei size;
+  VALUE current_sel_buffer;
+  DECL_GL_FUNC_PTR(void,glSelectBuffer,(GLsizei size, GLuint *buffer));
+
+  LOAD_GL_FUNC(glSelectBuffer, NULL);
+  size = (GLsizei)NUM2UINT(arg1);
+  current_sel_buffer = allocate_buffer_with_string(sizeof(GLuint)*size);
+  rb_str_freeze(current_sel_buffer);
+  fptr_glSelectBuffer(size, (GLuint*)RSTRING_PTR(current_sel_buffer));
+  CHECK_GLERROR_FROM("glSelectBuffer");
+  SET_GLIMPL_VARIABLE(current_sel_buffer, current_sel_buffer);
+  return current_sel_buffer;
+}
+
+
+static VALUE
+gl_Map1d(obj,arg1,arg2,arg3,arg4,arg5,arg6)
+VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6;
+{
+  GLenum target;
+  GLdouble u1;
+  GLdouble u2;
+  GLint stride;
+  GLint order;
+  GLdouble *points;
+
+  VALUE work_ary;
+  DECL_GL_FUNC_PTR(void,glMap1d,(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points));
+
+  LOAD_GL_FUNC(glMap1d, NULL);
+  target = (GLenum)NUM2INT(arg1);
+  u1 = (GLdouble)NUM2DBL(arg2);
+  u2 = (GLdouble)NUM2DBL(arg3);
+  stride = (GLint)NUM2INT(arg4);
+  order = (GLint)NUM2INT(arg5);
+  points = ALLOC_N(GLdouble, order*stride);
+  work_ary = rb_funcall(arg6,rb_intern("flatten"),0);
+  ary2cdbl(work_ary, points, order*stride);
+  fptr_glMap1d(target, u1, u2, stride, order, points);
+  xfree(points);
+  CHECK_GLERROR_FROM("glMap1d");
+  return Qnil;
+}
+
+static VALUE
+gl_Map1f(obj,arg1,arg2,arg3,arg4,arg5,arg6)
+VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6;
+{
+  GLenum target;
+  GLfloat u1;
+  GLfloat u2;
+  GLint stride;
+  GLint order;
+  GLfloat *points;
+
+  VALUE work_ary;
+  DECL_GL_FUNC_PTR(void,glMap1f,(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points));
+
+  LOAD_GL_FUNC(glMap1f, NULL);
+  target = (GLenum)NUM2INT(arg1);
+  u1 = (GLfloat)NUM2DBL(arg2);
+  u2 = (GLfloat)NUM2DBL(arg3);
+  stride = (GLint)NUM2INT(arg4);
+  order = (GLint)NUM2INT(arg5);
+  points = ALLOC_N(GLfloat, order*stride);
+  work_ary = rb_funcall(arg6,rb_intern("flatten"),0);
+  ary2cflt(work_ary, points, order*stride);
+  fptr_glMap1f(target, u1, u2, stride, order, points);
+  xfree(points);
+  CHECK_GLERROR_FROM("glMap1f");
+  return Qnil;
+}
+
+static VALUE
+gl_Map2d(obj,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10)
+VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10;
+{
+  GLenum target;
+  GLdouble u1;
+  GLdouble u2;
+  GLint ustride;
+  GLint uorder;
+  GLdouble v1;
+  GLdouble v2;
+  GLint vstride;
+  GLint vorder;
+  GLdouble *points;
+
+  VALUE work_ary;
+  DECL_GL_FUNC_PTR(void,glMap2d,(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points));
+
+  LOAD_GL_FUNC(glMap2d, NULL);
+  target = (GLenum)NUM2INT(arg1);
+  u1 = (GLdouble)NUM2INT(arg2);
+  u2 = (GLdouble)NUM2INT(arg3);
+  ustride = (GLint)NUM2INT(arg4);
+  uorder = (GLint)NUM2INT(arg5);
+  v1 = (GLdouble)NUM2INT(arg6);
+  v2 = (GLdouble)NUM2INT(arg7);
+  vstride = (GLint)NUM2INT(arg8);
+  vorder = (GLint)NUM2INT(arg9);
+  points = ALLOC_N(GLdouble, MAX(ustride*uorder, vstride*vorder));
+  work_ary = rb_funcall(arg10,rb_intern("flatten"),0);
+  ary2cdbl(work_ary, points, MAX(ustride*uorder, vstride*vorder));
+  fptr_glMap2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
+  xfree(points);
+  CHECK_GLERROR_FROM("glMap2d");
+  return Qnil;
+}
+
+static VALUE
+gl_Map2f(obj,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10)
+VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10;
+{
+  GLenum target;
+  GLfloat u1;
+  GLfloat u2;
+  GLint ustride;
+  GLint uorder;
+  GLfloat v1;
+  GLfloat v2;
+  GLint vstride;
+  GLint vorder;
+  GLfloat *points;
+
+  VALUE work_ary;
+  DECL_GL_FUNC_PTR(void,glMap2f,(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points));
+
+  LOAD_GL_FUNC(glMap2f, NULL);
+  target = (GLenum)NUM2INT(arg1);
+  u1 = (GLfloat)NUM2INT(arg2);
+  u2 = (GLfloat)NUM2INT(arg3);
+  ustride = (GLint)NUM2INT(arg4);
+  uorder = (GLint)NUM2INT(arg5);
+  v1 = (GLfloat)NUM2INT(arg6);
+  v2 = (GLfloat)NUM2INT(arg7);
+  vstride = (GLint)NUM2INT(arg8);
+  vorder = (GLint)NUM2INT(arg9);
+  points = ALLOC_N(GLfloat, MAX(ustride*uorder, vstride*vorder));
+  work_ary = rb_funcall(arg10,rb_intern("flatten"),0);
+  ary2cflt(work_ary, points, MAX(ustride*uorder, vstride*vorder));
+  fptr_glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
+  xfree(points);
+  CHECK_GLERROR_FROM("glMap2f");
+  return Qnil;
+}
+
+static VALUE
+gl_EvalCoord1dv(obj,arg1)
+VALUE obj,arg1;
+{
+  GLdouble params[1] = {0.0};
+  DECL_GL_FUNC_PTR(void,glEvalCoord1dv,(const GLdouble *u));
+
+  LOAD_GL_FUNC(glEvalCoord1dv, NULL);
+  Check_Type(arg1,T_ARRAY);
+  ary2cdbl(arg1,params,1);
+  fptr_glEvalCoord1dv(params);
+  CHECK_GLERROR_FROM("glEvalCoord1dv");
+  return Qnil;
+}
+
+static VALUE
+gl_EvalCoord1fv(obj,arg1)
+VALUE obj,arg1;
+{
+  GLfloat params[1] = {(GLfloat)0.0};
+  DECL_GL_FUNC_PTR(void,glEvalCoord1fv,(const GLfloat *u));
+
+  LOAD_GL_FUNC(glEvalCoord1fv, NULL);
+  Check_Type(arg1,T_ARRAY);
+  ary2cflt(arg1,params,1);
+  fptr_glEvalCoord1fv(params);
+  CHECK_GLERROR_FROM("glEvalCoord1fv");
+  return Qnil;
+}
+
+static VALUE
+gl_EvalCoord2dv(obj,arg1)
+VALUE obj,arg1;
+{
+  GLdouble params[2] = {0.0,0.0};
+  DECL_GL_FUNC_PTR(void,glEvalCoord2dv,(const GLdouble *u));
+
+  LOAD_GL_FUNC(glEvalCoord2dv, NULL);
+  Check_Type(arg1,T_ARRAY);
+  ary2cdbl(arg1,params,2);
+  fptr_glEvalCoord2dv(params);
+  CHECK_GLERROR_FROM("glEvalCoord2fv");
+  return Qnil;
+}
+
+static VALUE
+gl_EvalCoord2fv(obj,arg1)
+VALUE obj,arg1;
+{
+  GLfloat params[2] = {(GLfloat)0.0,(GLfloat)0.0};
+  DECL_GL_FUNC_PTR(void,glEvalCoord2fv,(const GLfloat *u));
+
+  LOAD_GL_FUNC(glEvalCoord2fv, NULL);
+  Check_Type(arg1,T_ARRAY);
+  ary2cflt(arg1,params,2);
+  fptr_glEvalCoord2fv(params);
+  CHECK_GLERROR_FROM("glEvalCoord2fv");
+  return Qnil;
+}
+
+
+#define GLPIXELMAP_FUNC(_type_,_vartype_,_convert_) \
+static VALUE \
+gl_PixelMap##_type_##v(argc,argv,obj) \
+int argc; \
+VALUE *argv; \
+VALUE obj; \
+{ \
+  GLenum map; \
+  _vartype_ *values; \
+  GLsizei size; \
+  VALUE args[4]; \
+  DECL_GL_FUNC_PTR(void,glPixelMap##_type_##v,(GLenum map, GLsizei mapsize, const _vartype_ *values)); \
+  LOAD_GL_FUNC(glPixelMap##_type_##v, NULL); \
+  switch(rb_scan_args(argc, argv, "21", &args[0], &args[1], &args[2])) { \
+    default: \
+    case 2: \
+      if (CHECK_BUFFER_BINDING(GL_PIXEL_UNPACK_BUFFER_BINDING)) \
+        rb_raise(rb_eArgError, "Pixel unpack buffer bound, but offset argument missing"); \
+      map = (GLenum)NUM2INT(args[0]); \
+      Check_Type(args[1],T_ARRAY); \
+      size = (int)RARRAY_LENINT(args[1]); \
+      values = ALLOC_N(_vartype_,size); \
+      _convert_(args[1],values,size); \
+      fptr_glPixelMap##_type_##v(map,size,values); \
+      xfree(values); \
+      break; \
+    case 3: \
+      if (!CHECK_BUFFER_BINDING(GL_PIXEL_UNPACK_BUFFER_BINDING)) \
+        rb_raise(rb_eArgError, "Pixel unpack buffer not bound"); \
+      map = (GLenum)NUM2INT(args[0]);	 \
+      size = (GLsizei)NUM2INT(args[1]); \
+      fptr_glPixelMap##_type_##v(map,size,(GLvoid *)NUM2SIZET(args[2])); \
+      break; \
+  } \
+  CHECK_GLERROR_FROM("glPixelMap" #_type_ "v"); \
+  return Qnil; \
+}
+
+GLPIXELMAP_FUNC(f,GLfloat,ary2cflt)
+GLPIXELMAP_FUNC(ui,GLuint,ary2cuint)
+GLPIXELMAP_FUNC(us,GLushort,ary2cushort)
+#undef GLPIXELMAP_FUNC
+
+
+static VALUE
+gl_ReadPixels(argc,argv,obj)
+int argc;
+VALUE *argv;
+VALUE obj;
+{
+  GLint x;
+  GLint y;
+  GLsizei width;
+  GLsizei height;
+  int format;
+  int type;
+  VALUE pixels;
+  VALUE args[7];
+  int numargs;
+  DECL_GL_FUNC_PTR(void,glReadPixels,(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels));
+
+  LOAD_GL_FUNC(glReadPixels, NULL);
+  numargs = rb_scan_args(argc, argv, "61", &args[0], &args[1], &args[2], &args[3], &args[4], &args[5], &args[6]);
+  x = (GLint)NUM2INT(args[0]);
+  y = (GLint)NUM2INT(args[1]);
+  width = (GLsizei)NUM2UINT(args[2]);
+  height = (GLsizei)NUM2UINT(args[3]);
+  format = NUM2INT(args[4]);
+  type = NUM2INT(args[5]);
+
+  switch(numargs) {
+    default:
+    case 6:
+      if (CHECK_BUFFER_BINDING(GL_PIXEL_PACK_BUFFER_BINDING))
+        rb_raise(rb_eArgError, "Pixel pack buffer bound, but offset argument missing");
+      pixels = allocate_buffer_with_string(GetDataSize(type,format,width*height));
+      FORCE_PIXEL_STORE_MODE
+      fptr_glReadPixels(x,y,width,height,format,type,(GLvoid*)RSTRING_PTR(pixels));
+      RESTORE_PIXEL_STORE_MODE
+      CHECK_GLERROR_FROM("glReadPixels");
+      return pixels;
+      break;
+    case 7:
+      if (!CHECK_BUFFER_BINDING(GL_PIXEL_PACK_BUFFER_BINDING))
+        rb_raise(rb_eArgError, "Pixel pack buffer not bound");
+      FORCE_PIXEL_STORE_MODE
+      fptr_glReadPixels(x,y,width,height,format,type,(GLvoid*)NUM2SIZET(args[6]));
+      RESTORE_PIXEL_STORE_MODE
+      CHECK_GLERROR_FROM("glReadPixels");
+      return Qnil;
+      break;
+  }
+}
+
+static VALUE
+gl_DrawPixels(obj,arg1,arg2,arg3,arg4,arg5)
+VALUE obj,arg1,arg2,arg3,arg4,arg5;
+{
+  GLsizei width;
+  GLsizei height;
+  GLenum format;
+  GLenum type;
+  const char *pixels;
+  DECL_GL_FUNC_PTR(void,glDrawPixels,(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels));
+
+  LOAD_GL_FUNC(glDrawPixels, NULL);
+  width = (GLsizei)NUM2UINT(arg1);
+  height = (GLsizei)NUM2UINT(arg2);
+  format = (GLenum)NUM2INT(arg3);
+  type = (GLenum)NUM2INT(arg4);
+  if (CHECK_BUFFER_BINDING(GL_PIXEL_UNPACK_BUFFER_BINDING)) {
+    fptr_glDrawPixels(width,height,format,type,(GLvoid *)NUM2SIZET(arg5));
+  } else {
+    VALUE data;
+    data = pack_array_or_pass_string(type,arg5);
+    CheckDataSize(type,format,width*height,data);
+    pixels = RSTRING_PTR(data);
+    fptr_glDrawPixels(width,height,format,type,pixels);
+  }
+  CHECK_GLERROR_FROM("glDrawPixels");
+  return Qnil;
+}
+
+static VALUE
+gl_GetClipPlane(obj,arg1)
+VALUE obj,arg1;
+{
+  GLenum plane;
+  GLdouble equation[4] = {0.0,0.0,0.0,0.0};
+  VALUE retary;
+  int i;
+  DECL_GL_FUNC_PTR(void,glGetClipPlane,(GLenum plane, GLdouble *equation));
+
+  LOAD_GL_FUNC(glGetClipPlane, NULL);
+  plane = (GLenum)NUM2INT(arg1);
+  fptr_glGetClipPlane(plane,equation);
+  retary = rb_ary_new2(4);
+  for(i=0;i<4;i++)
+    rb_ary_push(retary, rb_float_new(equation[i]));
+  CHECK_GLERROR_FROM("glGetClipPlane");
+  return retary;
+}
+
+#define GLGET_FUNC(_name_,_type_,_conv_) \
+static VALUE \
+gl_Get##_name_##v(obj,arg1) \
+VALUE obj,arg1; \
+{ \
+  GLenum pname; \
+  int nitems; \
+  VALUE ary, ary2; \
+  int i,j; \
+  _type_ items[64];  \
+  DECL_GL_FUNC_PTR(void,glGet##_name_##v,(GLenum pname, _type_ *params)); \
+  LOAD_GL_FUNC(glGet##_name_##v, NULL); \
+  pname = NUM2INT(arg1); \
+  switch(pname) { \
+  case GL_ACCUM_CLEAR_VALUE: \
+  case GL_BLEND_COLOR: \
+  case GL_COLOR_CLEAR_VALUE: \
+  case GL_COLOR_WRITEMASK: \
+  case GL_CURRENT_COLOR: \
+  case GL_CURRENT_RASTER_COLOR: \
+  case GL_CURRENT_RASTER_POSITION: \
+  case GL_CURRENT_RASTER_SECONDARY_COLOR: \
+  case GL_CURRENT_RASTER_TEXTURE_COORDS: \
+  case GL_CURRENT_TEXTURE_COORDS: \
+  case GL_FOG_COLOR: \
+  case GL_LIGHT_MODEL_AMBIENT: \
+  case GL_MAP2_GRID_DOMAIN: \
+  case GL_CURRENT_SECONDARY_COLOR: \
+  case GL_SCISSOR_BOX: \
+  case GL_TEXTURE_ENV_COLOR: \
+  case GL_VIEWPORT: \
+  case GL_REFERENCE_PLANE_EQUATION_SGIX: \
+  case GL_FOG_OFFSET_VALUE_SGIX: \
+  case GL_TEXTURE_ENV_BIAS_SGIX: \
+  case GL_CULL_VERTEX_OBJECT_POSITION_EXT: \
+  case GL_CULL_VERTEX_EYE_POSITION_EXT: \
+  case GL_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX: \
+  case GL_CONSTANT_COLOR0_NV: \
+  case GL_CONSTANT_COLOR1_NV: \
+  case GL_TEXTURE_COLOR_WRITEMASK_SGIS: \
+  case GL_FLOAT_CLEAR_COLOR_VALUE_NV: \
+  case GL_RGBA_SIGNED_COMPONENTS_EXT: \
+    nitems = 4; \
+    break; \
+  case GL_CURRENT_NORMAL: \
+  case GL_POINT_DISTANCE_ATTENUATION: \
+  case GL_SPRITE_AXIS_SGIX: \
+  case GL_SPRITE_TRANSLATION_SGIX: \
+  case GL_CURRENT_RASTER_NORMAL_SGIX: \
+  case GL_CURRENT_TANGENT_EXT: \
+  case GL_CURRENT_BINORMAL_EXT: \
+    nitems = 3; \
+    break; \
+  case GL_DEPTH_RANGE:	 \
+  case GL_LINE_WIDTH_RANGE: \
+  case GL_MAP1_GRID_DOMAIN: \
+  case GL_MAP2_GRID_SEGMENTS: \
+  case GL_MAX_VIEWPORT_DIMS: \
+  case GL_POINT_SIZE_RANGE: \
+  case GL_POLYGON_MODE: \
+  case GL_ALIASED_LINE_WIDTH_RANGE: \
+  case GL_ALIASED_POINT_SIZE_RANGE: \
+  case GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX: \
+  case GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX: \
+  case GL_FOG_FUNC_SGIS: \
+  case GL_DEPTH_BOUNDS_EXT: \
+    nitems = 2; \
+    break; \
+  case GL_MODELVIEW_MATRIX: \
+  case GL_PROJECTION_MATRIX: \
+  case GL_TEXTURE_MATRIX: \
+  case GL_COLOR_MATRIX: \
+  case GL_TRANSPOSE_MODELVIEW_MATRIX: \
+  case GL_TRANSPOSE_PROJECTION_MATRIX: \
+  case GL_TRANSPOSE_TEXTURE_MATRIX: \
+  case GL_TRANSPOSE_COLOR_MATRIX: \
+  case GL_TRANSPOSE_CURRENT_MATRIX_ARB: \
+  case GL_MODELVIEW0_ARB: \
+  case GL_MODELVIEW1_ARB: \
+  case GL_MODELVIEW2_ARB: \
+  case GL_MODELVIEW3_ARB: \
+  case GL_MODELVIEW4_ARB: \
+  case GL_MODELVIEW5_ARB: \
+  case GL_MODELVIEW6_ARB: \
+  case GL_MODELVIEW7_ARB: \
+  case GL_MODELVIEW8_ARB: \
+  case GL_MODELVIEW9_ARB: \
+  case GL_MODELVIEW10_ARB: \
+  case GL_MODELVIEW11_ARB: \
+  case GL_MODELVIEW12_ARB: \
+  case GL_MODELVIEW13_ARB: \
+  case GL_MODELVIEW14_ARB: \
+  case GL_MODELVIEW15_ARB: \
+  case GL_MODELVIEW16_ARB: \
+  case GL_MODELVIEW17_ARB: \
+  case GL_MODELVIEW18_ARB: \
+  case GL_MODELVIEW19_ARB: \
+  case GL_MODELVIEW20_ARB: \
+  case GL_MODELVIEW21_ARB: \
+  case GL_MODELVIEW22_ARB: \
+  case GL_MODELVIEW23_ARB: \
+  case GL_MODELVIEW24_ARB: \
+  case GL_MODELVIEW25_ARB: \
+  case GL_MODELVIEW26_ARB: \
+  case GL_MODELVIEW27_ARB: \
+  case GL_MODELVIEW28_ARB: \
+  case GL_MODELVIEW29_ARB: \
+  case GL_MODELVIEW30_ARB: \
+  case GL_MODELVIEW31_ARB: \
+  case GL_MATRIX_PALETTE_ARB: \
+  case GL_PIXEL_TRANSFORM_2D_MATRIX_EXT: \
+  case GL_MODELVIEW1_MATRIX_EXT: \
+  case GL_CURRENT_MATRIX_NV: \
+    fptr_glGet##_name_##v(pname, items); \
+    ary = rb_ary_new2(4); \
+    for (i = 0; i < 4; i++) { \
+      ary2 = rb_ary_new2(4); \
+      rb_ary_push(ary, ary2); \
+      for (j = 0; j < 4; j++) \
+        rb_ary_push(ary2, _conv_(items[i*4+j])); \
+    } \
+    CHECK_GLERROR_FROM("glGet" #_name_ "v"); \
+    return ary; \
+  case GL_POLYGON_STIPPLE: \
+    fptr_glGet##_name_##v(pname, items); \
+    CHECK_GLERROR_FROM("glGet" #_name_ "v"); \
+    return rb_str_new((const char*)items, 32); \
+  case GL_COMPRESSED_TEXTURE_FORMATS: \
+    { \
+      DECL_GL_FUNC_PTR(void,glGetIntegerv,(GLenum pname, GLint *params)); \
+      LOAD_GL_FUNC(glGetIntegerv, NULL); \
+      fptr_glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &nitems); \
+      CHECK_GLERROR_FROM("glGetIntegerv"); \
+      if (nitems<=0||nitems>64) \
+        return INT2NUM(0); \
+    } \
+    break; \
+  default: /* size=1 */ \
+    fptr_glGet##_name_##v(pname, items); \
+    CHECK_GLERROR_FROM("glGet" #_name_ "v"); \
+    return _conv_(items[0]); \
+  } \
+  fptr_glGet##_name_##v(pname, items); \
+  ary = rb_ary_new2(nitems); \
+  for (i = 0; i < nitems; i++) \
+    rb_ary_push(ary, _conv_(items[i])); \
+  CHECK_GLERROR_FROM("glGet" #_name_ "v"); \
+  return ary; \
+}
+
+GLGET_FUNC(Double,GLdouble,rb_float_new)
+GLGET_FUNC(Float,GLfloat,rb_float_new)
+GLGET_FUNC(Integer,GLint,INT2NUM)
+GLGET_FUNC(Boolean,GLboolean,GLBOOL2RUBY)
+
+#undef GLGET_FUNC
+
+
+static VALUE
+gl_GetLightfv(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+  GLenum light;
+  GLenum pname;
+  GLsizei size;
+  GLfloat params[4] = {(GLfloat)0.0, (GLfloat)0.0, (GLfloat)0.0, (GLfloat)0.0};
+  DECL_GL_FUNC_PTR(void,glGetLightfv,(GLenum light, GLenum pname, GLfloat *params));
+
+  LOAD_GL_FUNC(glGetLightfv, NULL);
+  light = (GLenum)NUM2INT(arg1);
+  pname = (GLenum)NUM2INT(arg2);
+  switch(pname) {
+    case GL_AMBIENT:
+    case GL_DIFFUSE:
+    case GL_SPECULAR:
+    case GL_POSITION:
+      size = 4;
+      break;
+    case GL_SPOT_DIRECTION:
+      size = 3;
+      break;
+    case GL_CONSTANT_ATTENUATION:
+    case GL_LINEAR_ATTENUATION:
+    case GL_QUADRATIC_ATTENUATION:
+    case GL_SPOT_EXPONENT:
+    case GL_SPOT_CUTOFF:
+      size = 1;
+      break;
+    default:
+      rb_raise(rb_eArgError, "unknown pname:%d",pname);
+      break; /* not reached */
+  }
+  fptr_glGetLightfv(light,pname,params);
+  RET_ARRAY_OR_SINGLE("glGetLightfv", size, rb_float_new, params);
+}
+
+static VALUE
+gl_GetLightiv(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+  GLenum light;
+  GLenum pname;
+  GLsizei size;
+  GLint params[4] = {0,0,0,0};
+  DECL_GL_FUNC_PTR(void,glGetLightiv,(GLenum light, GLenum pname, GLint *params));
+
+  LOAD_GL_FUNC(glGetLightiv, NULL);
+  light = (GLenum)NUM2INT(arg1);
+  pname = (GLenum)NUM2INT(arg2);
+  switch(pname) {
+    case GL_AMBIENT:
+    case GL_DIFFUSE:
+    case GL_SPECULAR:
+    case GL_POSITION:
+      size = 4;
+      break;
+    case GL_SPOT_DIRECTION:
+      size = 3;
+      break;
+    case GL_CONSTANT_ATTENUATION:
+    case GL_LINEAR_ATTENUATION:
+    case GL_QUADRATIC_ATTENUATION:
+    case GL_SPOT_EXPONENT:
+    case GL_SPOT_CUTOFF:
+      size = 1;
+      break;
+    default:
+      rb_raise(rb_eArgError, "unknown pname:%d",pname);
+      break; /* not reached */
+  }
+  fptr_glGetLightiv(light,pname,params);
+  RET_ARRAY_OR_SINGLE("glGetLightiv", size, INT2NUM, params);
+}
+
+#define GETMAP_FUNC(_name_,_type_) \
+static VALUE \
+gl_##_name_(obj,arg1,arg2) \
+VALUE obj,arg1,arg2; \
+{ \
+  GLenum target; \
+  GLenum query; \
+  int dims; \
+  int pointsize; \
+  int size=0; \
+  _type_ *points; \
+  GLint order[2] = {0,0}; /* for GL_COEFF, [order] or [uorder,vorder] (MAP1/MAP2) */ \
+  DECL_GL_FUNC_PTR(void,gl##_name_,(GLenum target, GLenum query, _type_ *v)); \
+  LOAD_GL_FUNC(gl##_name_, NULL); \
+  target = (GLenum)NUM2INT(arg1); \
+  query = (GLenum)NUM2INT(arg2); \
+  switch(target) { \
+    case GL_MAP1_INDEX: \
+    case GL_MAP1_TEXTURE_COORD_1: dims=1; pointsize=1; break; \
+    case GL_MAP1_TEXTURE_COORD_2: dims=1; pointsize=2; break; \
+    case GL_MAP1_VERTEX_3: \
+    case GL_MAP1_NORMAL: \
+    case GL_MAP1_TEXTURE_COORD_3: dims=1; pointsize=3; break; \
+    case GL_MAP1_COLOR_4: \
+    case GL_MAP1_TEXTURE_COORD_4: \
+    case GL_MAP1_VERTEX_4: dims=1; pointsize=4; break; \
+    case GL_MAP2_INDEX: \
+    case GL_MAP2_TEXTURE_COORD_1: dims=2; pointsize=1; break; \
+    case GL_MAP2_TEXTURE_COORD_2: dims=2; pointsize=2; break; \
+    case GL_MAP2_VERTEX_3: \
+    case GL_MAP2_NORMAL:  \
+    case GL_MAP2_TEXTURE_COORD_3: dims=2; pointsize=3; break; \
+    case GL_MAP2_COLOR_4:  \
+    case GL_MAP2_TEXTURE_COORD_4: \
+    case GL_MAP2_VERTEX_4: dims=2; pointsize=4; break; \
+    default: \
+      rb_raise(rb_eArgError, "unknown target:%d",target); \
+      break; /* not reached */ \
+  } \
+  switch(query) { \
+    case GL_ORDER: size = dims;	break; \
+    case GL_DOMAIN: size = dims*2; break; \
+    case GL_COEFF: \
+      { \
+        DECL_GL_FUNC_PTR(void,glGetMapiv,(GLenum target, GLenum query, GLint *v)); \
+        LOAD_GL_FUNC(glGetMapiv, NULL); \
+        fptr_glGetMapiv(target,GL_ORDER,order); \
+        CHECK_GLERROR_FROM("glGetMapiv"); \
+        if (dims==1) \
+          size = order[0] * pointsize; \
+        else \
+          size = (order[0]*order[1]) * pointsize; \
+      } \
+      break; \
+    default: \
+      rb_raise(rb_eArgError, "unknown target:%d",target); \
+      break; /* not reached */ \
+  } \
+  points = ALLOC_N(_type_,size); \
+  fptr_gl##_name_(target,query,points); \
+\
+  RET_ARRAY_OR_SINGLE_FREE("gl" #_name_, size, RETCONV_##_type_, points); \
+}
+
+GETMAP_FUNC(GetMapdv,GLdouble)
+GETMAP_FUNC(GetMapfv,GLfloat)
+GETMAP_FUNC(GetMapiv,GLint)
+#undef GETMAP_FUNC
+
+static VALUE
+gl_GetMaterialfv(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+  GLenum face;
+  GLenum pname;
+  GLfloat params[4] = {(GLfloat)0.0, (GLfloat)0.0, (GLfloat)0.0, (GLfloat)0.0};
+  int size;
+  DECL_GL_FUNC_PTR(void,glGetMaterialfv,(GLenum face, GLenum pname, GLfloat *params));
+
+  LOAD_GL_FUNC(glGetMaterialfv, NULL);
+  face = (GLenum)NUM2INT(arg1);
+  pname = (GLenum)NUM2INT(arg2);
+  switch(pname) {
+    case GL_AMBIENT:
+    case GL_DIFFUSE:
+    case GL_SPECULAR:
+    case GL_EMISSION:
+      size = 4;
+      break;
+    case GL_COLOR_INDEXES:
+      size = 3;
+      break;
+    case GL_SHININESS:
+      size = 1;
+      break;
+    default:
+      rb_raise(rb_eArgError, "unknown pname:%d",pname);
+      break; /* not reached */
+  }
+  fptr_glGetMaterialfv(face,pname,params);
+  RET_ARRAY_OR_SINGLE("glGetMaterialfv", size, rb_float_new, params);
+}
+
+static VALUE
+gl_GetMaterialiv(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+  GLenum face;
+  GLenum pname;
+  GLint params[4] = {0,0,0,0};
+  int size;
+  DECL_GL_FUNC_PTR(void,glGetMaterialiv,(GLenum face, GLenum pname, GLint *params));
+
+  LOAD_GL_FUNC(glGetMaterialiv, NULL);
+  face = (GLenum)NUM2INT(arg1);
+  pname = (GLenum)NUM2INT(arg2);
+  switch(pname) {
+    case GL_AMBIENT:
+    case GL_DIFFUSE:
+    case GL_SPECULAR:
+    case GL_EMISSION:
+      size = 4;
+      break;
+    case GL_COLOR_INDEXES:
+      size = 3;
+      break;
+    case GL_SHININESS:
+      size = 1;
+      break;
+    default:
+      rb_raise(rb_eArgError, "unknown pname:%d",pname);
+      break; /* not reached */
+  }
+  fptr_glGetMaterialiv(face,pname,params);
+  RET_ARRAY_OR_SINGLE("glGetMaterialiv", size, INT2NUM, params);
+}
+
+#define GLGETPIXELMAP_FUNC(_type_,_vartype_,_convert_) \
+static VALUE \
+gl_GetPixelMap##_type_##v(argc,argv,obj) \
+int argc; \
+VALUE *argv; \
+VALUE obj; \
+{ \
+  GLenum map; \
+  GLenum map_size; \
+  GLint size = 0; \
+  _vartype_ *values; \
+  VALUE args[2]; \
+  DECL_GL_FUNC_PTR(void,glGetPixelMap##_type_##v,(GLenum map, _vartype_ *values)); \
+  LOAD_GL_FUNC(glGetPixelMap##_type_##v, NULL); \
+  switch (rb_scan_args(argc, argv, "11", &args[0], &args[1])) { \
+    default: \
+    case 1: \
+      if (CHECK_BUFFER_BINDING(GL_PIXEL_PACK_BUFFER_BINDING)) \
+        rb_raise(rb_eArgError, \
+            "Pixel pack buffer bound, but offset argument missing"); \
+\
+      map = (GLenum)NUM2INT(args[0]); \
+      switch(map) { \
+        case GL_PIXEL_MAP_I_TO_I: map_size=GL_PIXEL_MAP_I_TO_I_SIZE; break; \
+        case GL_PIXEL_MAP_S_TO_S: map_size=GL_PIXEL_MAP_S_TO_S_SIZE; break; \
+        case GL_PIXEL_MAP_I_TO_R: map_size=GL_PIXEL_MAP_I_TO_R_SIZE; break; \
+        case GL_PIXEL_MAP_I_TO_G: map_size=GL_PIXEL_MAP_I_TO_G_SIZE; break; \
+        case GL_PIXEL_MAP_I_TO_B: map_size=GL_PIXEL_MAP_I_TO_B_SIZE; break; \
+        case GL_PIXEL_MAP_I_TO_A: map_size=GL_PIXEL_MAP_I_TO_A_SIZE; break; \
+        case GL_PIXEL_MAP_R_TO_R: map_size=GL_PIXEL_MAP_R_TO_R_SIZE; break; \
+        case GL_PIXEL_MAP_G_TO_G: map_size=GL_PIXEL_MAP_G_TO_G_SIZE; break; \
+        case GL_PIXEL_MAP_B_TO_B: map_size=GL_PIXEL_MAP_B_TO_B_SIZE; break; \
+        case GL_PIXEL_MAP_A_TO_A: map_size=GL_PIXEL_MAP_A_TO_A_SIZE; break; \
+        default: \
+          rb_raise(rb_eArgError, "unknown map:%d",map); \
+          break; \
+      } \
+      { \
+        DECL_GL_FUNC_PTR(void,glGetIntegerv,(GLenum pname, GLint *params)); \
+        LOAD_GL_FUNC(glGetIntegerv, NULL); \
+        fptr_glGetIntegerv(map_size,&size); \
+      } \
+      CHECK_GLERROR_FROM("glGetIntegerv"); \
+      values = ALLOC_N(_vartype_,size); \
+      fptr_glGetPixelMap##_type_##v(map,values); \
+      RET_ARRAY_OR_SINGLE_FREE("glGetPixelMap" #_type_ "v", size, _convert_, \
+          values); \
+      break; \
+    case 2: \
+      if (!CHECK_BUFFER_BINDING(GL_PIXEL_PACK_BUFFER_BINDING)) \
+        rb_raise(rb_eArgError, "Pixel pack buffer not bound"); \
+\
+      map = (GLenum)NUM2INT(args[0]); \
+      fptr_glGetPixelMap##_type_##v(map,(GLvoid*)NUM2SIZET(args[1])); \
+      CHECK_GLERROR_FROM("glGetPixelMap" #_type_ "v"); \
+      return Qnil; \
+  } \
+}
+
+GLGETPIXELMAP_FUNC(f,GLfloat,rb_float_new)
+GLGETPIXELMAP_FUNC(ui,GLuint,INT2NUM)
+GLGETPIXELMAP_FUNC(us,GLushort,INT2NUM)
+#undef GLGETPIXELMAP_FUNC
+
+static VALUE
+gl_GetPolygonStipple(argc,argv,obj)
+int argc;
+VALUE *argv;
+VALUE obj;
+{
+  VALUE args[1];
+  GLubyte mask[128];
+  DECL_GL_FUNC_PTR(void,glGetPolygonStipple,(GLubyte *mask));
+
+  LOAD_GL_FUNC(glGetPolygonStipple, NULL);
+  switch(rb_scan_args(argc, argv, "01", &args[0])) {
+    default:
+    case 0:
+      if (CHECK_BUFFER_BINDING(GL_PIXEL_PACK_BUFFER_BINDING))
+        rb_raise(rb_eArgError, "Pixel pack buffer bound, but offset argument missing");
+      memset(mask, 0x0, sizeof(GLubyte)*128);
+      FORCE_PIXEL_STORE_MODE
+      fptr_glGetPolygonStipple(mask);
+      RESTORE_PIXEL_STORE_MODE
+      CHECK_GLERROR_FROM("glGetPolygonStipple");
+      return rb_str_new((const char*)mask, 128);
+    case 1:
+      if (!CHECK_BUFFER_BINDING(GL_PIXEL_PACK_BUFFER_BINDING))
+        rb_raise(rb_eArgError, "Pixel pack buffer not bound");
+      fptr_glGetPolygonStipple((GLvoid *)NUM2SIZET(args[0]));
+      CHECK_GLERROR_FROM("glGetPolygonStipple");
+      return Qnil;
+  }
+}
+
+static VALUE
+gl_GetString(obj,arg1)
+VALUE obj,arg1;
+{
+  GLenum name;
+  const GLubyte *ret;
+  DECL_GL_FUNC_PTR(const GLubyte *,glGetString,(GLenum name));
+
+  LOAD_GL_FUNC(glGetString, NULL);
+  name = (GLenum)NUM2INT(arg1);
+  ret = fptr_glGetString(name);
+  CHECK_GLERROR_FROM("glGetString");