ruby-opengl 0.33.0

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

@@ -0,0 +1,5152 @@
+/*
+ * Copyright (C) 1999 - 2005 Yoshi <yoshi@giganet.net>
+ * Copyright (C) 2006 John M. Gabriele <jmg3000@gmail.com>
+ *
+ * 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.
+ */
+
+#ifdef __APPLE__
+#include <OpenGL/gl.h>
+#elif defined WIN32
+#include <windows.h>
+#include <GL/gl.h>
+#else
+#include <GL/gl.h>
+#endif
+#include "../common/rbogl.h"
+#include "../common/gl-enums.h"
+
+#ifndef MAX
+#define MAX(a, b)  (((a) > (b)) ? (a) : (b))
+#endif
+
+/* OpenGL 1.0 + 1.1 functions */
+
+static VALUE
+gl_NewList(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLuint list;
+	GLenum mode;
+	list = (GLuint)NUM2INT(arg1);
+	mode = (GLenum)NUM2INT(arg2);
+	glNewList(list,mode);
+	return Qnil;
+}
+
+static VALUE
+gl_EndList(obj)
+VALUE obj;
+{
+	glEndList();
+	return Qnil;
+}
+
+static VALUE
+gl_CallList(obj,arg1)
+VALUE obj,arg1;
+{
+	GLuint list;
+	list = (GLuint)NUM2INT(arg1);
+	glCallList(list);
+	return Qnil;
+}
+
+static VALUE
+gl_CallLists(obj,arg1)
+VALUE obj,arg1;
+{
+	GLsizei n;
+	GLenum type;
+	GLvoid *lists;
+	if (TYPE(arg1) == T_STRING) {
+		type = GL_BYTE;
+		lists = RSTRING(arg1)->ptr;
+		n = RSTRING(arg1)->len;
+	} else if (TYPE(arg1) == T_ARRAY) {
+		type = GL_INT;
+		lists = ALLOC_N(int, RARRAY(arg1)->len);
+		n = ary2cint(arg1,lists,0);
+	} else {
+		rb_raise(rb_eArgError,"GL.CallLists wrong arguments");
+		return Qnil; /* not reached */
+	}
+	glCallLists(n, type, lists);
+	if (type == GL_INT) xfree(lists);
+	return Qnil;
+}
+
+static VALUE
+gl_DeleteLists(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLuint list;
+	GLsizei range;
+	list = (GLuint)NUM2INT(arg1);
+	range = (GLsizei)NUM2INT(arg2);
+	glDeleteLists(list,range);
+	return Qnil;
+}
+
+static VALUE
+gl_GenLists(obj,arg1)
+VALUE obj,arg1;
+{
+	GLsizei range;
+	GLuint ret;
+	range = (GLsizei)NUM2INT(arg1);
+	ret = glGenLists(range);
+	return INT2NUM(ret);
+}
+
+static VALUE
+gl_ListBase(obj,arg1)
+VALUE obj,arg1;
+{
+	GLuint base;
+	base = (GLuint)NUM2INT(arg1);
+	glListBase(base);
+	return Qnil;
+}
+
+static VALUE
+gl_Begin(obj,arg1)
+VALUE obj,arg1;
+{
+	GLenum mode;
+	mode = (GLenum)NUM2INT(arg1);
+	glBegin(mode);
+	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;
+	const GLubyte *bitmap;
+	width = (GLsizei)NUM2INT(arg1);
+	height = (GLsizei)NUM2INT(arg2);
+	xorig = (GLfloat)NUM2DBL(arg3);
+	yorig = (GLfloat)NUM2DBL(arg4);
+	xmove = (GLfloat)NUM2DBL(arg5);
+	ymove = (GLfloat)NUM2DBL(arg6);
+	if (TYPE(arg7) != T_STRING)
+		rb_raise(rb_eTypeError, "type mismatch:%s", rb_class2name(CLASS_OF(arg7)));
+	if (RSTRING(arg7)->len < (width * height / 8))
+		rb_raise(rb_eArgError, "string length:%d", RSTRING(arg7)->len);
+	bitmap = (const GLubyte*)RSTRING(arg7)->ptr;
+	glBitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
+	return Qnil;
+}
+
+static VALUE
+gl_Color3b(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLbyte red;
+	GLbyte green;
+	GLbyte blue;
+	red = (GLbyte)NUM2INT(arg1);
+	green = (GLbyte)NUM2INT(arg2);
+	blue = (GLbyte)NUM2INT(arg3);
+	glColor3b(red,green,blue);
+	return Qnil;
+}
+
+static VALUE
+gl_Color3d(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLdouble red;
+	GLdouble green;
+	GLdouble blue;
+	red = (GLdouble)NUM2DBL(arg1);
+	green = (GLdouble)NUM2DBL(arg2);
+	blue = (GLdouble)NUM2DBL(arg3);
+	glColor3d(red,green,blue);
+	return Qnil;
+}
+
+static VALUE
+gl_Color3f(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLfloat red;
+	GLfloat green;
+	GLfloat blue;
+	red = (GLfloat)NUM2DBL(arg1);
+	green = (GLfloat)NUM2DBL(arg2);
+	blue = (GLfloat)NUM2DBL(arg3);
+	glColor3f(red,green,blue);
+	return Qnil;
+}
+
+static VALUE
+gl_Color3i(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLint red;
+	GLint green;
+	GLint blue;
+	red = (GLint)NUM2INT(arg1);
+	green = (GLint)NUM2INT(arg2);
+	blue = (GLint)NUM2INT(arg3);
+	glColor3i(red,green,blue);
+	return Qnil;
+}
+
+static VALUE
+gl_Color3s(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLshort red;
+	GLshort green;
+	GLshort blue;
+	red = (GLshort)NUM2INT(arg1);
+	green = (GLshort)NUM2INT(arg2);
+	blue = (GLshort)NUM2INT(arg3);
+	glColor3s(red,green,blue);
+	return Qnil;
+}
+
+static VALUE
+gl_Color3ub(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLubyte red;
+	GLubyte green;
+	GLubyte blue;
+	red = (GLubyte)NUM2INT(arg1);
+	green = (GLubyte)NUM2INT(arg2);
+	blue = (GLubyte)NUM2INT(arg3);
+	glColor3ub(red,green,blue);
+	return Qnil;
+}
+
+static VALUE
+gl_Color3ui(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLuint red;
+	GLuint green;
+	GLuint blue;
+	red = (GLuint)NUM2INT(arg1);
+	green = (GLuint)NUM2INT(arg2);
+	blue = (GLuint)NUM2INT(arg3);
+	glColor3ui(red,green,blue);
+	return Qnil;
+}
+
+static VALUE
+gl_Color3us(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLushort red;
+	GLushort green;
+	GLushort blue;
+	red = (GLushort)NUM2INT(arg1);
+	green = (GLushort)NUM2INT(arg2);
+	blue = (GLushort)NUM2INT(arg3);
+	glColor3us(red,green,blue);
+	return Qnil;
+}
+
+static VALUE
+gl_Color4b(obj,arg1,arg2,arg3,arg4)
+VALUE obj,arg1,arg2,arg3,arg4;
+{
+	GLbyte red;
+	GLbyte green;
+	GLbyte blue;
+	GLbyte alpha;
+	red = (GLbyte)NUM2INT(arg1);
+	green = (GLbyte)NUM2INT(arg2);
+	blue = (GLbyte)NUM2INT(arg3);
+	alpha = (GLbyte)NUM2INT(arg4);
+	glColor4b(red,green,blue,alpha);
+	return Qnil;
+}
+
+static VALUE
+gl_Color4d(obj,arg1,arg2,arg3,arg4)
+VALUE obj,arg1,arg2,arg3,arg4;
+{
+	GLdouble red;
+	GLdouble green;
+	GLdouble blue;
+	GLdouble alpha;
+	red = (GLdouble)NUM2DBL(arg1);
+	green = (GLdouble)NUM2DBL(arg2);
+	blue = (GLdouble)NUM2DBL(arg3);
+	alpha = (GLdouble)NUM2DBL(arg4);
+	glColor4d(red,green,blue,alpha);
+	return Qnil;
+}
+
+static VALUE
+gl_Color4f(obj,arg1,arg2,arg3,arg4)
+VALUE obj,arg1,arg2,arg3,arg4;
+{
+	GLfloat red;
+	GLfloat green;
+	GLfloat blue;
+	GLfloat alpha;
+	red = (GLfloat)NUM2DBL(arg1);
+	green = (GLfloat)NUM2DBL(arg2);
+	blue = (GLfloat)NUM2DBL(arg3);
+	alpha = (GLfloat)NUM2DBL(arg4);
+	glColor4f(red,green,blue,alpha);
+	return Qnil;
+}
+
+static VALUE
+gl_Color4i(obj,arg1,arg2,arg3,arg4)
+VALUE obj,arg1,arg2,arg3,arg4;
+{
+	GLint red;
+	GLint green;
+	GLint blue;
+	GLint alpha;
+	red = (GLint)NUM2INT(arg1);
+	green = (GLint)NUM2INT(arg2);
+	blue = (GLint)NUM2INT(arg3);
+	alpha = (GLint)NUM2INT(arg4);
+	glColor4i(red,green,blue,alpha);
+	return Qnil;
+}
+
+static VALUE
+gl_Color4s(obj,arg1,arg2,arg3,arg4)
+VALUE obj,arg1,arg2,arg3,arg4;
+{
+	GLshort red;
+	GLshort green;
+	GLshort blue;
+	GLshort alpha;
+	red = (GLshort)NUM2INT(arg1);
+	green = (GLshort)NUM2INT(arg2);
+	blue = (GLshort)NUM2INT(arg3);
+	alpha = (GLshort)NUM2INT(arg4);
+	glColor4s(red,green,blue,alpha);
+	return Qnil;
+}
+
+static VALUE
+gl_Color4ub(obj,arg1,arg2,arg3,arg4)
+VALUE obj,arg1,arg2,arg3,arg4;
+{
+	GLubyte red;
+	GLubyte green;
+	GLubyte blue;
+	GLubyte alpha;
+	red = (GLubyte)NUM2INT(arg1);
+	green = (GLubyte)NUM2INT(arg2);
+	blue = (GLubyte)NUM2INT(arg3);
+	alpha = (GLubyte)NUM2INT(arg4);
+	glColor4ub(red,green,blue,alpha);
+	return Qnil;
+}
+
+static VALUE
+gl_Color4ui(obj,arg1,arg2,arg3,arg4)
+VALUE obj,arg1,arg2,arg3,arg4;
+{
+	GLuint red;
+	GLuint green;
+	GLuint blue;
+	GLuint alpha;
+	red = (GLuint)NUM2INT(arg1);
+	green = (GLuint)NUM2INT(arg2);
+	blue = (GLuint)NUM2INT(arg3);
+	alpha = (GLuint)NUM2INT(arg4);
+	glColor4ui(red,green,blue,alpha);
+	return Qnil;
+}
+
+static VALUE
+gl_Color4us(obj,arg1,arg2,arg3,arg4)
+VALUE obj,arg1,arg2,arg3,arg4;
+{
+	GLushort red;
+	GLushort green;
+	GLushort blue;
+	GLushort alpha;
+	red = (GLushort)NUM2INT(arg1);
+	green = (GLushort)NUM2INT(arg2);
+	blue = (GLushort)NUM2INT(arg3);
+	alpha = (GLushort)NUM2INT(arg4);
+	glColor4us(red,green,blue,alpha);
+	return Qnil;
+}
+
+static VALUE
+gl_EdgeFlag(obj,arg1)
+VALUE obj,arg1;
+{
+	GLboolean flag;
+	flag = (GLboolean)NUM2INT(arg1);
+	glEdgeFlag(flag);
+	return Qnil;
+}
+
+static VALUE
+gl_EdgeFlagv(obj,arg1)
+VALUE obj,arg1;
+{
+	GLboolean flag[1] = { GL_FALSE };
+	if (TYPE(arg1) != T_ARRAY) 
+		rb_raise(rb_eTypeError, "type mismatch:%s",rb_class2name(arg1));
+	ary2cboolean(arg1,flag,1);
+	glEdgeFlagv(flag);
+	return Qnil;
+}
+
+static VALUE
+gl_End(obj)
+VALUE obj;
+{
+	glEnd();
+	return Qnil;
+}
+
+static VALUE
+gl_Indexd(obj,arg1)
+VALUE obj,arg1;
+{
+	GLdouble c;
+	c = (GLdouble)NUM2DBL(arg1);
+	glIndexd(c);
+	return Qnil;
+}
+
+static VALUE
+gl_Indexdv(obj,arg1)
+VALUE obj,arg1;
+{
+	GLdouble c[1] = {0.0};
+	if (TYPE(arg1) != T_ARRAY) 
+		rb_raise(rb_eTypeError, "type mismatch:%s",rb_class2name(arg1));
+	ary2cdbl(arg1,c,1);
+	glIndexdv(c);
+	return Qnil;
+}
+
+static VALUE
+gl_Indexf(obj,arg1)
+VALUE obj,arg1;
+{
+	GLfloat c;
+	c = (GLfloat)NUM2DBL(arg1);
+	glIndexf(c);
+	return Qnil;
+}
+
+static VALUE
+gl_Indexfv(obj,arg1)
+VALUE obj,arg1;
+{
+	GLfloat c[1] = {0.0};
+	if (TYPE(arg1) != T_ARRAY) 
+		rb_raise(rb_eTypeError, "type mismatch:%s",rb_class2name(arg1));
+	ary2cflt(arg1,c,1);
+	glIndexfv(c);
+	return Qnil;
+}
+
+static VALUE
+gl_Indexi(obj,arg1)
+VALUE obj,arg1;
+{
+	GLint c;
+	c = (GLint)NUM2INT(arg1);
+	glIndexi(c);
+	return Qnil;
+}
+
+static VALUE
+gl_Indexiv(obj,arg1)
+VALUE obj,arg1;
+{
+	GLint c[1] = {0.0};
+	if (TYPE(arg1) != T_ARRAY) 
+		rb_raise(rb_eTypeError, "type mismatch:%s",rb_class2name(arg1));
+	ary2cint(arg1,c,1);
+	glIndexiv(c);
+	return Qnil;
+}
+
+static VALUE
+gl_Indexs(obj,arg1)
+VALUE obj,arg1;
+{
+	GLshort c;
+	c = (GLshort)NUM2INT(arg1);
+	glIndexs(c);
+	return Qnil;
+}
+
+static VALUE
+gl_Indexsv(obj,arg1)
+VALUE obj,arg1;
+{
+	GLshort c[1] = {0};
+	if (TYPE(arg1) != T_ARRAY) 
+		rb_raise(rb_eTypeError, "type mismatch:%s",rb_class2name(arg1));
+	ary2cshort(arg1,c,1);
+	glIndexsv(c);
+	return Qnil;
+}
+
+static VALUE
+gl_Normal3b(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLbyte nx;
+	GLbyte ny;
+	GLbyte nz;
+	nx = (GLbyte)NUM2INT(arg1);
+	ny = (GLbyte)NUM2INT(arg2);
+	nz = (GLbyte)NUM2INT(arg3);
+	glNormal3b(nx,ny,nz);
+	return Qnil;
+}
+
+static VALUE
+gl_Normal3d(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLdouble nx;
+	GLdouble ny;
+	GLdouble nz;
+	nx = (GLdouble)NUM2DBL(arg1);
+	ny = (GLdouble)NUM2DBL(arg2);
+	nz = (GLdouble)NUM2DBL(arg3);
+	glNormal3d(nx,ny,nz);
+	return Qnil;
+}
+
+static VALUE
+gl_Normal3f(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLfloat nx;
+	GLfloat ny;
+	GLfloat nz;
+	nx = (GLfloat)NUM2DBL(arg1);
+	ny = (GLfloat)NUM2DBL(arg2);
+	nz = (GLfloat)NUM2DBL(arg3);
+	glNormal3f(nx,ny,nz);
+	return Qnil;
+}
+
+static VALUE
+gl_Normal3i(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLint nx;
+	GLint ny;
+	GLint nz;
+	nx = (GLint)NUM2INT(arg1);
+	ny = (GLint)NUM2INT(arg2);
+	nz = (GLint)NUM2INT(arg3);
+	glNormal3i(nx,ny,nz);
+	return Qnil;
+}
+
+static VALUE
+gl_Normal3s(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLshort nx;
+	GLshort ny;
+	GLshort nz;
+	nx = (GLshort)NUM2INT(arg1);
+	ny = (GLshort)NUM2INT(arg2);
+	nz = (GLshort)NUM2INT(arg3);
+	glNormal3s(nx,ny,nz);
+	return Qnil;
+}
+
+static VALUE
+gl_RasterPos2d(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLdouble x;
+	GLdouble y;
+	x = (GLdouble)NUM2DBL(arg1);
+	y = (GLdouble)NUM2DBL(arg2);
+	glRasterPos2d(x,y);
+	return Qnil;
+}
+
+static VALUE
+gl_RasterPos2f(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLfloat x;
+	GLfloat y;
+	x = (GLfloat)NUM2DBL(arg1);
+	y = (GLfloat)NUM2DBL(arg2);
+	glRasterPos2f(x,y);
+	return Qnil;
+}
+
+static VALUE
+gl_RasterPos2i(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLint x;
+	GLint y;
+	x = (GLint)NUM2INT(arg1);
+	y = (GLint)NUM2INT(arg2);
+	glRasterPos2i(x,y);
+	return Qnil;
+}
+
+static VALUE
+gl_RasterPos2s(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLshort x;
+	GLshort y;
+	x = (GLshort)NUM2INT(arg1);
+	y = (GLshort)NUM2INT(arg2);
+	glRasterPos2s(x,y);
+	return Qnil;
+}
+
+static VALUE
+gl_RasterPos3d(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLdouble x;
+	GLdouble y;
+	GLdouble z;
+	x = (GLdouble)NUM2DBL(arg1);
+	y = (GLdouble)NUM2DBL(arg2);
+	z = (GLdouble)NUM2DBL(arg3);
+	glRasterPos3d(x,y,z);
+	return Qnil;
+}
+
+static VALUE
+gl_RasterPos3f(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLfloat x;
+	GLfloat y;
+	GLfloat z;
+	x = (GLfloat)NUM2DBL(arg1);
+	y = (GLfloat)NUM2DBL(arg2);
+	z = (GLfloat)NUM2DBL(arg3);
+	glRasterPos3f(x,y,z);
+	return Qnil;
+}
+
+static VALUE
+gl_RasterPos3i(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLint x;
+	GLint y;
+	GLint z;
+	x = (GLint)NUM2INT(arg1);
+	y = (GLint)NUM2INT(arg2);
+	z = (GLint)NUM2INT(arg3);
+	glRasterPos3i(x,y,z);
+	return Qnil;
+}
+
+static VALUE
+gl_RasterPos3s(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLshort x;
+	GLshort y;
+	GLshort z;
+	x = (GLshort)NUM2INT(arg1);
+	y = (GLshort)NUM2INT(arg2);
+	z = (GLshort)NUM2INT(arg3);
+	glRasterPos3s(x,y,z);
+	return Qnil;
+}
+
+static VALUE
+gl_RasterPos4d(obj,arg1,arg2,arg3,arg4)
+VALUE obj,arg1,arg2,arg3,arg4;
+{
+	GLdouble x;
+	GLdouble y;
+	GLdouble z;
+	GLdouble w;
+	x = (GLdouble)NUM2DBL(arg1);
+	y = (GLdouble)NUM2DBL(arg2);
+	z = (GLdouble)NUM2DBL(arg3);
+	w = (GLdouble)NUM2DBL(arg4);
+	glRasterPos4d(x,y,z,w);
+	return Qnil;
+}
+
+static VALUE
+gl_RasterPos4f(obj,arg1,arg2,arg3,arg4)
+VALUE obj,arg1,arg2,arg3,arg4;
+{
+	GLfloat x;
+	GLfloat y;
+	GLfloat z;
+	GLfloat w;
+	x = (GLfloat)NUM2DBL(arg1);
+	y = (GLfloat)NUM2DBL(arg2);
+	z = (GLfloat)NUM2DBL(arg3);
+	w = (GLfloat)NUM2DBL(arg4);
+	glRasterPos4f(x,y,z,w);
+	return Qnil;
+}
+
+static VALUE
+gl_RasterPos4i(obj,arg1,arg2,arg3,arg4)
+VALUE obj,arg1,arg2,arg3,arg4;
+{
+	GLint x;
+	GLint y;
+	GLint z;
+	GLint w;
+	x = (GLint)NUM2INT(arg1);
+	y = (GLint)NUM2INT(arg2);
+	z = (GLint)NUM2INT(arg3);
+	w = (GLint)NUM2INT(arg4);
+	glRasterPos4i(x,y,z,w);
+	return Qnil;
+}
+
+static VALUE
+gl_RasterPos4s(obj,arg1,arg2,arg3,arg4)
+VALUE obj,arg1,arg2,arg3,arg4;
+{
+	GLshort x;
+	GLshort y;
+	GLshort z;
+	GLshort w;
+	x = (GLshort)NUM2INT(arg1);
+	y = (GLshort)NUM2INT(arg2);
+	z = (GLshort)NUM2INT(arg3);
+	w = (GLshort)NUM2INT(arg4);
+	glRasterPos4s(x,y,z,w);
+	return Qnil;
+}
+
+static VALUE
+gl_Rectd(obj,arg1,arg2,arg3,arg4)
+VALUE obj,arg1,arg2,arg3,arg4;
+{
+	GLdouble x1;
+	GLdouble y1;
+	GLdouble x2;
+	GLdouble y2;
+	x1 = (GLdouble)NUM2DBL(arg1);
+	y1 = (GLdouble)NUM2DBL(arg2);
+	x2 = (GLdouble)NUM2DBL(arg3);
+	y2 = (GLdouble)NUM2DBL(arg4);
+	glRectd(x1,y1,x2,y2);
+	return Qnil;
+}
+
+static VALUE
+gl_Rectf(obj,arg1,arg2,arg3,arg4)
+VALUE obj,arg1,arg2,arg3,arg4;
+{
+	GLfloat x1;
+	GLfloat y1;
+	GLfloat x2;
+	GLfloat y2;
+	x1 = (GLfloat)NUM2DBL(arg1);
+	y1 = (GLfloat)NUM2DBL(arg2);
+	x2 = (GLfloat)NUM2DBL(arg3);
+	y2 = (GLfloat)NUM2DBL(arg4);
+	glRectf(x1,y1,x2,y2);
+	return Qnil;
+}
+
+static VALUE
+gl_Recti(obj,arg1,arg2,arg3,arg4)
+VALUE obj,arg1,arg2,arg3,arg4;
+{
+	GLint x1;
+	GLint y1;
+	GLint x2;
+	GLint y2;
+	x1 = (GLint)NUM2INT(arg1);
+	y1 = (GLint)NUM2INT(arg2);
+	x2 = (GLint)NUM2INT(arg3);
+	y2 = (GLint)NUM2INT(arg4);
+	glRecti(x1,y1,x2,y2);
+	return Qnil;
+}
+
+static VALUE
+gl_Rects(obj,arg1,arg2,arg3,arg4)
+VALUE obj,arg1,arg2,arg3,arg4;
+{
+	GLshort x1;
+	GLshort y1;
+	GLshort x2;
+	GLshort y2;
+	x1 = (GLshort)NUM2INT(arg1);
+	y1 = (GLshort)NUM2INT(arg2);
+	x2 = (GLshort)NUM2INT(arg3);
+	y2 = (GLshort)NUM2INT(arg4);
+	glRects(x1,y1,x2,y2);
+	return Qnil;
+}
+
+static VALUE
+gl_TexCoord1d(obj,arg1)
+VALUE obj,arg1;
+{
+	GLdouble s;
+	s = (GLdouble)NUM2DBL(arg1);
+	glTexCoord1d(s);
+	return Qnil;
+}
+
+static VALUE
+gl_TexCoord1f(obj,arg1)
+VALUE obj,arg1;
+{
+	GLfloat s;
+	s = (GLfloat)NUM2DBL(arg1);
+	glTexCoord1f(s);
+	return Qnil;
+}
+
+static VALUE
+gl_TexCoord1i(obj,arg1)
+VALUE obj,arg1;
+{
+	GLint s;
+	s = (GLint)NUM2INT(arg1);
+	glTexCoord1i(s);
+	return Qnil;
+}
+
+static VALUE
+gl_TexCoord1s(obj,arg1)
+VALUE obj,arg1;
+{
+	GLshort s;
+	s = (GLshort)NUM2INT(arg1);
+	glTexCoord1s(s);
+	return Qnil;
+}
+
+static VALUE
+gl_TexCoord2d(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLdouble s;
+	GLdouble t;
+	s = (GLdouble)NUM2DBL(arg1);
+	t = (GLdouble)NUM2DBL(arg2);
+	glTexCoord2d(s,t);
+	return Qnil;
+}
+
+static VALUE
+gl_TexCoord2f(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLfloat s;
+	GLfloat t;
+	s = (GLfloat)NUM2DBL(arg1);
+	t = (GLfloat)NUM2DBL(arg2);
+	glTexCoord2f(s,t);
+	return Qnil;
+}
+
+static VALUE
+gl_TexCoord2i(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLint s;
+	GLint t;
+	s = (GLint)NUM2INT(arg1);
+	t = (GLint)NUM2INT(arg2);
+	glTexCoord2i(s,t);
+	return Qnil;
+}
+
+static VALUE
+gl_TexCoord2s(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLshort s;
+	GLshort t;
+	s = (GLshort)NUM2INT(arg1);
+	t = (GLshort)NUM2INT(arg2);
+	glTexCoord2s(s,t);
+	return Qnil;
+}
+
+static VALUE
+gl_TexCoord3d(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLdouble s;
+	GLdouble t;
+	GLdouble r;
+	s = (GLdouble)NUM2DBL(arg1);
+	t = (GLdouble)NUM2DBL(arg2);
+	r = (GLdouble)NUM2DBL(arg3);
+	glTexCoord3d(s,t,r);
+	return Qnil;
+}
+
+static VALUE
+gl_TexCoord3f(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLfloat s;
+	GLfloat t;
+	GLfloat r;
+	s = (GLfloat)NUM2DBL(arg1);
+	t = (GLfloat)NUM2DBL(arg2);
+	r = (GLfloat)NUM2DBL(arg3);
+	glTexCoord3f(s,t,r);
+	return Qnil;
+}
+
+static VALUE
+gl_TexCoord3i(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLint s;
+	GLint t;
+	GLint r;
+	s = (GLint)NUM2INT(arg1);
+	t = (GLint)NUM2INT(arg2);
+	r = (GLint)NUM2INT(arg3);
+	glTexCoord3i(s,t,r);
+	return Qnil;
+}
+
+static VALUE
+gl_TexCoord3s(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLshort s;
+	GLshort t;
+	GLshort r;
+	s = (GLshort)NUM2INT(arg1);
+	t = (GLshort)NUM2INT(arg2);
+	r = (GLshort)NUM2INT(arg3);
+	glTexCoord3s(s,t,r);
+	return Qnil;
+}
+
+static VALUE
+gl_TexCoord4d(obj,arg1,arg2,arg3,arg4)
+VALUE obj,arg1,arg2,arg3,arg4;
+{
+	GLdouble s;
+	GLdouble t;
+	GLdouble r;
+	GLdouble q;
+	s = (GLdouble)NUM2DBL(arg1);
+	t = (GLdouble)NUM2DBL(arg2);
+	r = (GLdouble)NUM2DBL(arg3);
+	q = (GLdouble)NUM2DBL(arg4);
+	glTexCoord4d(s,t,r,q);
+	return Qnil;
+}
+
+static VALUE
+gl_TexCoord4f(obj,arg1,arg2,arg3,arg4)
+VALUE obj,arg1,arg2,arg3,arg4;
+{
+	GLfloat s;
+	GLfloat t;
+	GLfloat r;
+	GLfloat q;
+	s = (GLfloat)NUM2DBL(arg1);
+	t = (GLfloat)NUM2DBL(arg2);
+	r = (GLfloat)NUM2DBL(arg3);
+	q = (GLfloat)NUM2DBL(arg4);
+	glTexCoord4f(s,t,r,q);
+	return Qnil;
+}
+
+static VALUE
+gl_TexCoord4i(obj,arg1,arg2,arg3,arg4)
+VALUE obj,arg1,arg2,arg3,arg4;
+{
+	GLint s;
+	GLint t;
+	GLint r;
+	GLint q;
+	s = (GLint)NUM2INT(arg1);
+	t = (GLint)NUM2INT(arg2);
+	r = (GLint)NUM2INT(arg3);
+	q = (GLint)NUM2INT(arg4);
+	glTexCoord4i(s,t,r,q);
+	return Qnil;
+}
+
+static VALUE
+gl_TexCoord4s(obj,arg1,arg2,arg3,arg4)
+VALUE obj,arg1,arg2,arg3,arg4;
+{
+	GLshort s;
+	GLshort t;
+	GLshort r;
+	GLshort q;
+	s = (GLshort)NUM2INT(arg1);
+	t = (GLshort)NUM2INT(arg2);
+	r = (GLshort)NUM2INT(arg3);
+	q = (GLshort)NUM2INT(arg4);
+	glTexCoord4s(s,t,r,q);
+	return Qnil;
+}
+
+static VALUE
+gl_Vertex2d(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLdouble x;
+	GLdouble y;
+	x = (GLdouble)NUM2DBL(arg1);
+	y = (GLdouble)NUM2DBL(arg2);
+	glVertex2d(x,y);
+	return Qnil;
+}
+
+static VALUE
+gl_Vertex2f(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLfloat x;
+	GLfloat y;
+	x = (GLfloat)NUM2DBL(arg1);
+	y = (GLfloat)NUM2DBL(arg2);
+	glVertex2f(x,y);
+	return Qnil;
+}
+
+static VALUE
+gl_Vertex2i(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLint x;
+	GLint y;
+	x = (GLint)NUM2INT(arg1);
+	y = (GLint)NUM2INT(arg2);
+	glVertex2i(x,y);
+	return Qnil;
+}
+
+static VALUE
+gl_Vertex2s(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLshort x;
+	GLshort y;
+	x = (GLshort)NUM2INT(arg1);
+	y = (GLshort)NUM2INT(arg2);
+	glVertex2s(x,y);
+	return Qnil;
+}
+
+static VALUE
+gl_Vertex3d(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLdouble x;
+	GLdouble y;
+	GLdouble z;
+	x = (GLdouble)NUM2DBL(arg1);
+	y = (GLdouble)NUM2DBL(arg2);
+	z = (GLdouble)NUM2DBL(arg3);
+	glVertex3d(x,y,z);
+	return Qnil;
+}
+
+static VALUE
+gl_Vertex3f(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLfloat x;
+	GLfloat y;
+	GLfloat z;
+	x = (GLfloat)NUM2DBL(arg1);
+	y = (GLfloat)NUM2DBL(arg2);
+	z = (GLfloat)NUM2DBL(arg3);
+	glVertex3f(x,y,z);
+	return Qnil;
+}
+
+static VALUE
+gl_Vertex3i(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLint x;
+	GLint y;
+	GLint z;
+	x = (GLint)NUM2INT(arg1);
+	y = (GLint)NUM2INT(arg2);
+	z = (GLint)NUM2INT(arg3);
+	glVertex3i(x,y,z);
+	return Qnil;
+}
+
+static VALUE
+gl_Vertex3s(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLshort x;
+	GLshort y;
+	GLshort z;
+	x = (GLshort)NUM2INT(arg1);
+	y = (GLshort)NUM2INT(arg2);
+	z = (GLshort)NUM2INT(arg3);
+	glVertex3s(x,y,z);
+	return Qnil;
+}
+
+static VALUE
+gl_Vertex4d(obj,arg1,arg2,arg3,arg4)
+VALUE obj,arg1,arg2,arg3,arg4;
+{
+	GLdouble x;
+	GLdouble y;
+	GLdouble z;
+	GLdouble w;
+	x = (GLdouble)NUM2DBL(arg1);
+	y = (GLdouble)NUM2DBL(arg2);
+	z = (GLdouble)NUM2DBL(arg3);
+	w = (GLdouble)NUM2DBL(arg4);
+	glVertex4d(x,y,z,w);
+	return Qnil;
+}
+
+static VALUE
+gl_Vertex4f(obj,arg1,arg2,arg3,arg4)
+VALUE obj,arg1,arg2,arg3,arg4;
+{
+	GLfloat x;
+	GLfloat y;
+	GLfloat z;
+	GLfloat w;
+	x = (GLfloat)NUM2DBL(arg1);
+	y = (GLfloat)NUM2DBL(arg2);
+	z = (GLfloat)NUM2DBL(arg3);
+	w = (GLfloat)NUM2DBL(arg4);
+	glVertex4f(x,y,z,w);
+	return Qnil;
+}
+
+static VALUE
+gl_Vertex4i(obj,arg1,arg2,arg3,arg4)
+VALUE obj,arg1,arg2,arg3,arg4;
+{
+	GLint x;
+	GLint y;
+	GLint z;
+	GLint w;
+	x = (GLint)NUM2INT(arg1);
+	y = (GLint)NUM2INT(arg2);
+	z = (GLint)NUM2INT(arg3);
+	w = (GLint)NUM2INT(arg4);
+	glVertex4i(x,y,z,w);
+	return Qnil;
+}
+
+static VALUE
+gl_Vertex4s(obj,arg1,arg2,arg3,arg4)
+VALUE obj,arg1,arg2,arg3,arg4;
+{
+	GLshort x;
+	GLshort y;
+	GLshort z;
+	GLshort w;
+	x = (GLshort)NUM2INT(arg1);
+	y = (GLshort)NUM2INT(arg2);
+	z = (GLshort)NUM2INT(arg3);
+	w = (GLshort)NUM2INT(arg4);
+	glVertex4s(x,y,z,w);
+	return Qnil;
+}
+
+static VALUE
+gl_ClipPlane(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLenum plane;
+	GLdouble equation[4];
+	plane = (GLenum)NUM2INT(arg1);
+	if (TYPE(arg2) == T_ARRAY)
+		ary2cdbl(arg2, equation, 4);
+	else
+		rb_raise(rb_eTypeError, "type mismatch:%s",rb_class2name(arg1));
+	glClipPlane(plane,equation);
+	return Qnil;
+}
+
+static VALUE
+gl_ColorMaterial(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLenum face;
+	GLenum mode;
+	face = (GLenum)NUM2INT(arg1);
+	mode = (GLenum)NUM2INT(arg2);
+	glColorMaterial(face,mode);
+	return Qnil;
+}
+
+static VALUE
+gl_CullFace(obj,arg1)
+VALUE obj,arg1;
+{
+	GLenum mode;
+	mode = (GLenum)NUM2INT(arg1);
+	glCullFace(mode);
+	return Qnil;
+}
+
+static VALUE
+gl_Fogf(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLenum pname;
+	GLfloat param;
+	pname = (GLenum)NUM2INT(arg1);
+	param = (GLfloat)NUM2DBL(arg2);
+	glFogf(pname,param);
+	return Qnil;
+}
+
+static VALUE
+gl_Fogfv(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLenum pname;
+	GLfloat params[4] = {0.0,0.0,0.0,0.0};
+	pname = (GLenum)NUM2INT(arg1);
+	if (TYPE(arg2) != T_ARRAY) 
+		rb_raise(rb_eTypeError, "type mismatch:%s",rb_class2name(arg2));
+	ary2cflt(arg2,params,4);
+	glFogfv(pname,params);
+	return Qnil;
+}
+
+static VALUE
+gl_Fogi(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLenum pname;
+	GLint param;
+	pname = (GLenum)NUM2INT(arg1);
+	param = (GLint)NUM2INT(arg2);
+	glFogi(pname,param);
+	return Qnil;
+}
+
+static VALUE
+gl_Fogiv(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLenum pname;
+	GLint params[4] = {0,0,0,0};
+	pname = (GLenum)NUM2INT(arg1);
+	if (TYPE(arg2) != T_ARRAY) 
+		rb_raise(rb_eTypeError, "type mismatch:%s",rb_class2name(arg2));
+	ary2cint(arg2,params,4);
+	glFogiv(pname,params);
+	return Qnil;
+}
+
+static VALUE
+gl_FrontFace(obj,arg1)
+VALUE obj,arg1;
+{
+	GLenum mode;
+	mode = (GLenum)NUM2INT(arg1);
+	glFrontFace(mode);
+	return Qnil;
+}
+
+static VALUE
+gl_Hint(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLenum target;
+	GLenum mode;
+	target = (GLenum)NUM2INT(arg1);
+	mode = (GLenum)NUM2INT(arg2);
+	glHint(target,mode);
+	return Qnil;
+}
+
+static VALUE
+gl_Lightf(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLenum light;
+	GLenum pname;
+	GLfloat param;
+	light = (GLenum)NUM2INT(arg1);
+	pname = (GLenum)NUM2INT(arg2);
+	param = (GLfloat)NUM2DBL(arg3);
+	glLightf(light,pname,param);
+	return Qnil;
+}
+
+static VALUE
+gl_Lightfv(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLenum light;
+	GLenum pname;
+	GLfloat params[4] = {0.0,0.0,0.0,0.0};
+	light = (GLenum)NUM2INT(arg1);
+	pname = (GLenum)NUM2INT(arg2);
+	if (TYPE(arg3) != T_ARRAY) 
+		rb_raise(rb_eTypeError, "type mismatch:%s",rb_class2name(arg3));
+	ary2cflt(arg3,params,4);
+	glLightfv(light,pname,params);
+	return Qnil;
+}
+
+static VALUE
+gl_Lighti(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLenum light;
+	GLenum pname;
+	GLint param;
+	light = (GLenum)NUM2INT(arg1);
+	pname = (GLenum)NUM2INT(arg2);
+	param = (GLint)NUM2INT(arg3);
+	glLighti(light,pname,param);
+	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};
+	light = (GLenum)NUM2INT(arg1);
+	pname = (GLenum)NUM2INT(arg2);
+	if (TYPE(arg3) != T_ARRAY) 
+		rb_raise(rb_eTypeError, "type mismatch:%s",rb_class2name(arg3));
+	ary2cint(arg3,params,4);
+	glLightiv(light,pname,params);
+	return Qnil;
+}
+
+static VALUE
+gl_LightModelf(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLenum pname;
+	GLfloat param;
+	pname = (GLenum)NUM2INT(arg1);
+	param = (GLfloat)NUM2DBL(arg2);
+	glLightModelf(pname,param);
+	return Qnil;
+}
+
+static VALUE
+gl_LightModelfv(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLenum pname;
+	GLfloat params[4] = {0.0,0.0,0.0,0.0};
+	pname = (GLenum)NUM2INT(arg1);
+	if (TYPE(arg2) != T_ARRAY) 
+		rb_raise(rb_eTypeError, "type mismatch:%s",rb_class2name(arg2));
+	ary2cflt(arg2,params,4);
+	glLightModelfv(pname,params);
+	return Qnil;
+}
+
+static VALUE
+gl_LightModeli(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLenum pname;
+	GLint param;
+	pname = (GLenum)NUM2INT(arg1);
+	param = (GLint)NUM2INT(arg2);
+	glLightModeli(pname,param);
+	return Qnil;
+}
+
+static VALUE
+gl_LightModeliv(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLenum pname;
+	GLint params[4] = {0,0,0,0};
+	pname = (GLenum)NUM2INT(arg1);
+	if (TYPE(arg2) != T_ARRAY) 
+		rb_raise(rb_eTypeError, "type mismatch:%s",rb_class2name(arg2));
+	ary2cint(arg2,params,4);
+	glLightModeliv(pname,params);
+	return Qnil;
+}
+
+static VALUE
+gl_LineStipple(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLint factor;
+	GLushort pattern;
+	factor = (GLint)NUM2INT(arg1);
+	pattern = (GLushort)(NUM2INT(arg2) & 0xFFFF);
+	glLineStipple(factor,pattern);
+	return Qnil;
+}
+
+static VALUE
+gl_LineWidth(obj,arg1)
+VALUE obj,arg1;
+{
+	GLfloat width;
+	width = (GLfloat)NUM2DBL(arg1);
+	glLineWidth(width);
+	return Qnil;
+}
+
+static VALUE
+gl_Materialf(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLenum face;
+	GLenum pname;
+	GLfloat param;
+	face = (GLenum)NUM2INT(arg1);
+	pname = (GLenum)NUM2INT(arg2);
+	param = (GLfloat)NUM2DBL(arg3);
+	glMaterialf(face,pname,param);
+	return Qnil;
+}
+
+static VALUE
+gl_Materialfv(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLenum face;
+	GLenum pname;
+	GLfloat params[4] = {0.0,0.0,0.0,0.0};
+	face = (GLenum)NUM2INT(arg1);
+	pname = (GLenum)NUM2INT(arg2);
+	if (TYPE(arg3) != T_ARRAY)
+		rb_raise(rb_eTypeError, "type mismatch:%s", rb_class2name(arg3));
+	ary2cflt(arg3,params,4);
+	glMaterialfv(face,pname,params);
+	return Qnil;
+}
+
+static VALUE
+gl_Materiali(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLenum face;
+	GLenum pname;
+	GLint param;
+	face = (GLenum)NUM2INT(arg1);
+	pname = (GLenum)NUM2INT(arg2);
+	param = (GLint)NUM2INT(arg3);
+	glMateriali(face,pname,param);
+	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};
+	face = (GLenum)NUM2INT(arg1);
+	pname = (GLenum)NUM2INT(arg2);
+	if (TYPE(arg3) != T_ARRAY)
+		rb_raise(rb_eTypeError, "type mismatch:%s", rb_class2name(arg3));
+	ary2cint(arg3,params,4);
+	glMaterialiv(face,pname,params);
+	return Qnil;
+}
+
+static VALUE
+gl_PointSize(obj,arg1)
+VALUE obj,arg1;
+{
+	GLfloat size;
+	size = (GLfloat)NUM2DBL(arg1);
+	glPointSize(size);
+	return Qnil;
+}
+
+static VALUE
+gl_PolygonMode(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLenum face;
+	GLenum mode;
+	face = (GLenum)NUM2INT(arg1);
+	mode = (GLenum)NUM2INT(arg2);
+	glPolygonMode(face,mode);
+	return Qnil;
+}
+
+static VALUE
+gl_PolygonStipple(obj,arg1)
+VALUE obj,arg1;
+{
+	GLubyte mask[128];
+	RArray* ary;
+	int i;
+	memset(mask, 0x0, sizeof(GLubyte[128]));
+	if (TYPE(arg1) == T_ARRAY) {
+		ary = RARRAY(arg1);
+		for(i = 0; i < ary->len && i < 128; i++)
+			mask[i] = (GLubyte)NUM2INT(ary->ptr[i]);
+	}
+	else if (TYPE(arg1) == T_STRING) {
+		if (RSTRING(arg1)->len < 128)
+			rb_raise(rb_eArgError, "string length:%d", RSTRING(arg1)->len);
+		memcpy(mask, RSTRING(arg1)->ptr, 128);
+	}
+	else
+		rb_raise(rb_eTypeError, "type mismatch:%s", rb_class2name(arg1));
+	glPolygonStipple(mask);
+	return Qnil;
+}
+
+static VALUE
+gl_Scissor(obj,arg1,arg2,arg3,arg4)
+VALUE obj,arg1,arg2,arg3,arg4;
+{
+	GLint x;
+	GLint y;
+	GLsizei width;
+	GLsizei height;
+	x = (GLint)NUM2INT(arg1);
+	y = (GLint)NUM2INT(arg2);
+	width = (GLsizei)NUM2INT(arg3);
+	height = (GLsizei)NUM2INT(arg4);
+	glScissor(x,y,width,height);
+	return Qnil;
+}
+
+static VALUE
+gl_ShadeModel(obj,arg1)
+VALUE obj,arg1;
+{
+	GLenum mode;
+	mode = (GLenum)NUM2INT(arg1);
+	glShadeModel(mode);
+	return Qnil;
+}
+
+static VALUE
+gl_TexParameterf(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLenum target;
+	GLenum pname;
+	GLfloat param;
+	target = (GLenum)NUM2INT(arg1);
+	pname = (GLenum)NUM2INT(arg2);
+	param = (GLfloat)NUM2DBL(arg3);
+	glTexParameterf(target,pname,param);
+	return Qnil;
+}
+
+static VALUE
+gl_TexParameterfv(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLenum target;
+	GLenum pname;
+	GLfloat params[4] = {0.0,0.0,0.0,0.0};
+	target = (GLenum)NUM2INT(arg1);
+	pname = (GLenum)NUM2INT(arg2);
+	if (TYPE(arg3) != T_ARRAY) 
+		rb_raise(rb_eTypeError, "type mismatch:%s",rb_class2name(arg3));
+	ary2cflt(arg3,params,4);
+	glTexParameterfv(target,pname,params);
+	return Qnil;
+}
+
+static VALUE
+gl_TexParameteri(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLenum target;
+	GLenum pname;
+	GLint param;
+	target = (GLenum)NUM2INT(arg1);
+	pname = (GLenum)NUM2INT(arg2);
+	param = (GLint)NUM2INT(arg3);
+	glTexParameteri(target,pname,param);
+	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};
+	target = (GLenum)NUM2INT(arg1);
+	pname = (GLenum)NUM2INT(arg2);
+	if (TYPE(arg3) != T_ARRAY) 
+		rb_raise(rb_eTypeError, "type mismatch:%s",rb_class2name(arg3));
+	ary2cint(arg3,params,4);
+	glTexParameteriv(target,pname,params);
+	return Qnil;
+}
+
+/* FIXME: spatna funkce ? */
+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;
+	int size;
+	int type_size;
+	int format_size;
+	target = (GLenum)NUM2INT(arg1);
+	level = (GLint)NUM2INT(arg2);
+	components = (GLint)NUM2INT(arg3);
+	width = (GLsizei)NUM2INT(arg4);
+	border = (GLint)NUM2INT(arg5);
+	format = (GLenum)NUM2INT(arg6);
+	type = (GLenum)NUM2INT(arg7);
+	if (TYPE(arg8) == T_STRING) {
+		type_size = gltype_size(type) / 8;
+		format_size = glformat_size(format);
+		if (type_size <= 0 || format_size == -1)
+			return Qnil;
+		size = type_size*format_size*width;
+		if (RSTRING(arg8)->len < size)
+			rb_raise(rb_eArgError, "string length:%d",RSTRING(arg8)->len);
+		pixels = RSTRING(arg8)->ptr;
+	} else if (NIL_P(arg8)) {
+		type_size = gltype_size(type) / 8;
+		format_size = glformat_size(format);
+		if (type_size <= 0 || format_size == -1)
+			return Qnil;
+		size = type_size*format_size*width;
+		pixels = NULL;
+	} else
+		rb_raise(rb_eTypeError, "type mismatch:%s",rb_class2name(arg8));
+	glTexImage1D(target,level,components,width,border,format,type,pixels);
+	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;
+	int size;
+	int type_size;
+	int format_size;
+	target = (GLenum)NUM2INT(arg1);
+	level = (GLint)NUM2INT(arg2);
+	components = (GLint)NUM2INT(arg3);
+	width = (GLsizei)NUM2INT(arg4);
+	height = (GLsizei)NUM2INT(arg5);
+	border = (GLint)NUM2INT(arg6);
+	format = (GLenum)NUM2INT(arg7);
+	type = (GLenum)NUM2INT(arg8);
+	if (TYPE(arg9) == T_STRING) {
+		type_size = gltype_size(type) / 8;
+		format_size = glformat_size(format);
+		if (type_size <= 0 || format_size == -1)
+			return Qnil;
+		size = type_size*format_size*height*width;
+		if (RSTRING(arg9)->len < size)
+			rb_raise(rb_eArgError, "string length:%d",RSTRING(arg9)->len);
+		pixels = RSTRING(arg9)->ptr;
+	} else if (NIL_P(arg9)) {
+		type_size = gltype_size(type) / 8;
+		format_size = glformat_size(format);
+		if (type_size <= 0 || format_size == -1)
+			return Qnil;
+		size = type_size*format_size*height*width;
+		pixels = NULL;
+	} else
+		rb_raise(rb_eTypeError, "type mismatch:%s",rb_class2name(arg9));
+	glTexImage2D(target,level,components,width,height,border,format,type,pixels);
+	return Qnil;
+}
+
+static VALUE
+gl_TexEnvf(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLenum target;
+	GLenum pname;
+	GLfloat param;
+	target = (GLenum)NUM2INT(arg1);
+	pname = (GLenum)NUM2INT(arg2);
+	param = (GLfloat)NUM2DBL(arg3);
+	glTexEnvf(target,pname,param);
+	return Qnil;
+}
+
+static VALUE
+gl_TexEnvfv(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLenum target;
+	GLenum pname;
+	GLfloat params[4] = {0.0,0.0,0.0,0.0};
+	target = (GLenum)NUM2INT(arg1);
+	pname = (GLenum)NUM2INT(arg2);
+	if (TYPE(arg3) != T_ARRAY) 
+		rb_raise(rb_eTypeError, "type mismatch:%s",rb_class2name(arg3));
+	ary2cflt(arg3,params,4);
+	glTexEnvfv(target,pname,params);
+	return Qnil;
+}
+
+static VALUE
+gl_TexEnvi(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLenum target;
+	GLenum pname;
+	GLint param;
+	target = (GLenum)NUM2INT(arg1);
+	pname = (GLenum)NUM2INT(arg2);
+	param = (GLint)NUM2INT(arg3);
+	glTexEnvi(target,pname,param);
+	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};
+	target = (GLenum)NUM2INT(arg1);
+	pname = (GLenum)NUM2INT(arg2);
+	if (TYPE(arg3) != T_ARRAY) 
+		rb_raise(rb_eTypeError, "type mismatch:%s",rb_class2name(arg3));
+	ary2cint(arg3,params,4);
+	glTexEnviv(target,pname,params);
+	return Qnil;
+}
+
+static VALUE
+gl_TexGend(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLenum coord;
+	GLenum pname;
+	GLdouble param;
+	coord = (GLenum)NUM2INT(arg1);
+	pname = (GLenum)NUM2INT(arg2);
+	param = (GLdouble)NUM2DBL(arg3);
+	glTexGend(coord,pname,param);
+	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};
+	coord = (GLenum)NUM2INT(arg1);
+	pname = (GLenum)NUM2INT(arg2);
+	if (TYPE(arg3) != T_ARRAY) 
+		rb_raise(rb_eTypeError, "type mismatch:%s",rb_class2name(arg3));
+	ary2cdbl(arg3,params,4);
+	glTexGendv(coord,pname,params);
+	return Qnil;
+}
+
+
+static VALUE
+gl_TexGenf(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLenum coord;
+	GLenum pname;
+	GLfloat param;
+	coord = (GLenum)NUM2INT(arg1);
+	pname = (GLenum)NUM2INT(arg2);
+	param = (GLfloat)NUM2DBL(arg3);
+	glTexGenf(coord,pname,param);
+	return Qnil;
+}
+
+static VALUE
+gl_TexGenfv(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLenum coord;
+	GLenum pname;
+	GLfloat params[4] = {0.0,0.0,0.0,0.0};
+	coord = (GLenum)NUM2INT(arg1);
+	pname = (GLenum)NUM2INT(arg2);
+	if (TYPE(arg3) != T_ARRAY) 
+		rb_raise(rb_eTypeError, "type mismatch:%s",rb_class2name(arg3));
+	ary2cflt(arg3,params,4);
+	glTexGenfv(coord,pname,params);
+	return Qnil;
+}
+
+static VALUE
+gl_TexGeni(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLenum coord;
+	GLenum pname;
+	GLint param;
+	coord = (GLenum)NUM2INT(arg1);
+	pname = (GLenum)NUM2INT(arg2);
+	param = (GLint)NUM2INT(arg3);
+	glTexGeni(coord,pname,param);
+	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};
+	coord = (GLenum)NUM2INT(arg1);
+	pname = (GLenum)NUM2INT(arg2);
+	if (TYPE(arg3) != T_ARRAY) 
+		rb_raise(rb_eTypeError, "type mismatch:%s",rb_class2name(arg3));
+	ary2cint(arg3,params,4);
+	glTexGeniv(coord,pname,params);
+	return Qnil;
+}
+
+#define DEFAULT_BUFFER	512
+static VALUE g_current_feed_buffer;
+static VALUE
+gl_FeedbackBuffer(argc, argv, obj)
+int argc;
+VALUE* argv;
+VALUE obj;
+{
+	GLsizei size;
+	GLenum type;
+	if (argc == 0) {
+		size = DEFAULT_BUFFER;
+		type = GL_4D_COLOR_TEXTURE;
+	}
+	else if (argc == 2) {
+		size = NUM2INT(argv[0]);
+		type = NUM2INT(argv[1]);
+	}
+	else {
+		rb_raise(rb_eTypeError, "GL.FeedbackBuffer");
+	}
+	g_current_feed_buffer = allocate_buffer_with_string(sizeof(GLfloat)*size);
+	rb_str_freeze(g_current_feed_buffer);
+	glFeedbackBuffer(size, type, (GLfloat*)RSTRING(g_current_feed_buffer)->ptr);
+	return g_current_feed_buffer;
+}
+
+static VALUE g_current_sel_buffer;
+static VALUE
+gl_SelectBuffer(argc,argv,obj)
+int argc;
+VALUE *argv;
+VALUE obj;
+{
+	VALUE args;
+	GLsizei size;
+	size = DEFAULT_BUFFER;
+	rb_scan_args(argc, argv, "01", &args);
+	if (args != Qnil)
+		size = (GLsizei)NUM2INT(args);
+	g_current_sel_buffer = allocate_buffer_with_string(sizeof(GLuint)*size);
+	rb_str_freeze(g_current_sel_buffer);
+	glSelectBuffer(size, (GLuint*)RSTRING(g_current_sel_buffer)->ptr);
+	return g_current_sel_buffer;
+}
+
+static VALUE
+gl_RenderMode(obj,arg1)
+VALUE obj,arg1;
+{
+	GLenum mode;
+	GLint ret;
+	mode = (GLenum)NUM2INT(arg1);
+	ret = glRenderMode(mode);
+	return INT2NUM(ret);
+}
+
+static VALUE
+gl_InitNames(obj)
+VALUE obj;
+{
+	glInitNames();
+	return Qnil;
+}
+
+static VALUE
+gl_LoadName(obj,arg1)
+VALUE obj,arg1;
+{
+	GLuint name;
+	name = (GLuint)NUM2INT(arg1);
+	glLoadName(name);
+	return Qnil;
+}
+
+static VALUE
+gl_PassThrough(obj,arg1)
+VALUE obj,arg1;
+{
+	GLfloat token;
+	token = (GLfloat)NUM2DBL(arg1);
+	glPassThrough(token);
+	return Qnil;
+}
+
+static VALUE
+gl_PopName(obj)
+VALUE obj;
+{
+	glPopName();
+	return Qnil;
+}
+
+static VALUE
+gl_PushName(obj,arg1)
+VALUE obj,arg1;
+{
+	GLuint name;
+	name = (GLuint)NUM2INT(arg1);
+	glPushName(name);
+	return Qnil;
+}
+
+static VALUE
+gl_DrawBuffer(obj,arg1)
+VALUE obj,arg1;
+{
+	GLenum mode;
+	mode = (GLenum)NUM2INT(arg1);
+	glDrawBuffer(mode);
+	return Qnil;
+}
+
+static VALUE
+gl_Clear(obj,arg1)
+VALUE obj,arg1;
+{
+	GLbitfield mask;
+	mask = (GLbitfield)NUM2INT(arg1);
+	glClear(mask);
+	return Qnil;
+}
+
+static VALUE
+gl_ClearAccum(obj,arg1,arg2,arg3,arg4)
+VALUE obj,arg1,arg2,arg3,arg4;
+{
+	GLfloat red;
+	GLfloat green;
+	GLfloat blue;
+	GLfloat alpha;
+	red = (GLfloat)NUM2DBL(arg1);
+	green = (GLfloat)NUM2DBL(arg2);
+	blue = (GLfloat)NUM2DBL(arg3);
+	alpha = (GLfloat)NUM2DBL(arg4);
+	glClearAccum(red,green,blue,alpha);
+	return Qnil;
+}
+
+static VALUE
+gl_ClearIndex(obj,arg1)
+VALUE obj,arg1;
+{
+	GLfloat c;
+	c = (GLfloat)NUM2DBL(arg1);
+	glClearIndex(c);
+	return Qnil;
+}
+
+static VALUE
+gl_ClearColor(obj,arg1,arg2,arg3,arg4)
+VALUE obj,arg1,arg2,arg3,arg4;
+{
+	GLclampf red;
+	GLclampf green;
+	GLclampf blue;
+	GLclampf alpha;
+	red = (GLclampf)NUM2DBL(arg1);
+	green = (GLclampf)NUM2DBL(arg2);
+	blue = (GLclampf)NUM2DBL(arg3);
+	alpha = (GLclampf)NUM2DBL(arg4);
+	glClearColor(red,green,blue,alpha);
+	return Qnil;
+}
+
+static VALUE
+gl_ClearStencil(obj,arg1)
+VALUE obj,arg1;
+{
+	GLint s;
+	s = (GLint)NUM2INT(arg1);
+	glClearStencil(s);
+	return Qnil;
+}
+
+static VALUE
+gl_ClearDepth(obj,arg1)
+VALUE obj,arg1;
+{
+	GLclampd depth;
+	depth = (GLclampd)NUM2DBL(arg1);
+	glClearDepth(depth);
+	return Qnil;
+}
+
+static VALUE
+gl_StencilMask(obj,arg1)
+VALUE obj,arg1;
+{
+	GLuint mask;
+	mask = (GLuint)NUM2INT(arg1);
+	glStencilMask(mask);
+	return Qnil;
+}
+
+static VALUE
+gl_ColorMask(obj,arg1,arg2,arg3,arg4)
+VALUE obj,arg1,arg2,arg3,arg4;
+{
+	GLboolean red;
+	GLboolean green;
+	GLboolean blue;
+	GLboolean alpha;
+	red = (GLboolean)NUM2INT(arg1);
+	green = (GLboolean)NUM2INT(arg2);
+	blue = (GLboolean)NUM2INT(arg3);
+	alpha = (GLboolean)NUM2INT(arg4);
+	glColorMask(red,green,blue,alpha);
+	return Qnil;
+}
+
+static VALUE
+gl_DepthMask(obj,arg1)
+VALUE obj,arg1;
+{
+	GLboolean flag;
+	flag = (GLboolean)NUM2INT(arg1);
+	glDepthMask(flag);
+	return Qnil;
+}
+
+static VALUE
+gl_IndexMask(obj,arg1)
+VALUE obj,arg1;
+{
+	GLuint mask;
+	mask = (GLuint)NUM2INT(arg1);
+	glIndexMask(mask);
+	return Qnil;
+}
+
+static VALUE
+gl_Accum(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLenum op;
+	GLfloat value;
+	op = (GLenum)NUM2INT(arg1);
+	value = (GLfloat)NUM2DBL(arg2);
+	glAccum(op,value);
+	return Qnil;
+}
+
+static VALUE
+gl_Disable(obj,arg1)
+VALUE obj,arg1;
+{
+	GLenum cap;
+	cap = (GLenum)NUM2INT(arg1);
+	glDisable(cap);
+	return Qnil;
+}
+
+static VALUE
+gl_Enable(obj,arg1)
+VALUE obj,arg1;
+{
+	GLenum cap;
+	cap = (GLenum)NUM2INT(arg1);
+	glEnable(cap);
+	return Qnil;
+}
+
+static VALUE
+gl_Finish(obj)
+VALUE obj;
+{
+	glFinish();
+	return Qnil;
+}
+
+static VALUE
+gl_Flush(obj)
+VALUE obj;
+{
+	glFlush();
+	return Qnil;
+}
+
+static VALUE
+gl_PopAttrib(obj)
+VALUE obj;
+{
+	glPopAttrib();
+	return Qnil;
+}
+
+static VALUE
+gl_PushAttrib(obj,arg1)
+VALUE obj,arg1;
+{
+	GLbitfield mask;
+	mask = (GLbitfield)NUM2INT(arg1);
+	glPushAttrib(mask);
+	return Qnil;
+}
+
+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;
+
+	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_ary_new();
+	mary2ary(arg6, work_ary);
+	ary2cdbl(work_ary, points, order*stride);
+	glMap1d(target, u1, u2, stride, order, points);
+	xfree(points);
+	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;
+
+	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_ary_new();
+	mary2ary(arg6, work_ary);
+	ary2cflt(work_ary, points, order*stride);
+	glMap1f(target, u1, u2, stride, order, points);
+	xfree(points);
+	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;
+
+	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_ary_new();
+	mary2ary(arg10, work_ary);
+	ary2cdbl(arg10, points, MAX(ustride*uorder, vstride*vorder));
+	glMap2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
+	xfree(points);
+	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;
+
+	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_ary_new();
+	mary2ary(arg10, work_ary);
+	ary2cflt(arg10, points, MAX(ustride*uorder, vstride*vorder));
+	glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
+	xfree(points);
+	return Qnil;
+}
+
+static VALUE
+gl_MapGrid1d(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLint un;
+	GLdouble u1;
+	GLdouble u2;
+	un = (GLint)NUM2INT(arg1);
+	u1 = (GLdouble)NUM2DBL(arg2);
+	u2 = (GLdouble)NUM2DBL(arg3);
+	glMapGrid1d(un,u1,u2);
+	return Qnil;
+}
+
+static VALUE
+gl_MapGrid1f(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLint un;
+	GLfloat u1;
+	GLfloat u2;
+	un = (GLint)NUM2INT(arg1);
+	u1 = (GLfloat)NUM2DBL(arg2);
+	u2 = (GLfloat)NUM2DBL(arg3);
+	glMapGrid1f(un,u1,u2);
+	return Qnil;
+}
+
+static VALUE
+gl_MapGrid2d(obj,arg1,arg2,arg3,arg4,arg5,arg6)
+VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6;
+{
+	GLint un;
+	GLdouble u1;
+	GLdouble u2;
+	GLint vn;
+	GLdouble v1;
+	GLdouble v2;
+	un = (GLint)NUM2INT(arg1);
+	u1 = (GLdouble)NUM2DBL(arg2);
+	u2 = (GLdouble)NUM2DBL(arg3);
+	vn = (GLint)NUM2INT(arg4);
+	v1 = (GLdouble)NUM2DBL(arg5);
+	v2 = (GLdouble)NUM2DBL(arg6);
+	glMapGrid2d(un,u1,u2,vn,v1,v2);
+	return Qnil;
+}
+
+static VALUE
+gl_MapGrid2f(obj,arg1,arg2,arg3,arg4,arg5,arg6)
+VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6;
+{
+	GLint un;
+	GLfloat u1;
+	GLfloat u2;
+	GLint vn;
+	GLfloat v1;
+	GLfloat v2;
+	un = (GLint)NUM2INT(arg1);
+	u1 = (GLfloat)NUM2DBL(arg2);
+	u2 = (GLfloat)NUM2DBL(arg3);
+	vn = (GLint)NUM2INT(arg4);
+	v1 = (GLfloat)NUM2DBL(arg5);
+	v2 = (GLfloat)NUM2DBL(arg6);
+	glMapGrid2f(un,u1,u2,vn,v1,v2);
+	return Qnil;
+}
+
+static VALUE
+gl_EvalCoord1d(obj,arg1)
+VALUE obj,arg1;
+{
+	GLdouble u;
+	u = (GLdouble)NUM2DBL(arg1);
+	glEvalCoord1d(u);
+	return Qnil;
+}
+
+static VALUE
+gl_EvalCoord1dv(obj,arg1)
+VALUE obj,arg1;
+{
+	GLdouble params[1] = {0.0};
+	if (TYPE(arg1) != T_ARRAY) 
+		rb_raise(rb_eTypeError, "type mismatch:%s",rb_class2name(arg1));
+	ary2cdbl(arg1,params,1);
+	glEvalCoord1dv(params);
+	return Qnil;
+}
+
+static VALUE
+gl_EvalCoord1f(obj,arg1)
+VALUE obj,arg1;
+{
+	GLfloat u;
+	u = (GLfloat)NUM2DBL(arg1);
+	glEvalCoord1f(u);
+	return Qnil;
+}
+
+static VALUE
+gl_EvalCoord1fv(obj,arg1)
+VALUE obj,arg1;
+{
+	GLfloat params[1] = {0.0};
+	if (TYPE(arg1) != T_ARRAY) 
+		rb_raise(rb_eTypeError, "type mismatch:%s",rb_class2name(arg1));
+	ary2cflt(arg1,params,1);
+	glEvalCoord1fv(params);
+	return Qnil;
+}
+
+static VALUE
+gl_EvalCoord2d(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLdouble u;
+	GLdouble v;
+	u = (GLdouble)NUM2DBL(arg1);
+	v = (GLdouble)NUM2DBL(arg2);
+	glEvalCoord2d(u,v);
+	return Qnil;
+}
+
+static VALUE
+gl_EvalCoord2dv(obj,arg1)
+VALUE obj,arg1;
+{
+	GLdouble params[2] = {0.0,0.0};
+	if (TYPE(arg1) != T_ARRAY) 
+		rb_raise(rb_eTypeError, "type mismatch:%s",rb_class2name(arg1));
+	ary2cdbl(arg1,params,2);
+	glEvalCoord2dv(params);
+	return Qnil;
+}
+
+static VALUE
+gl_EvalCoord2f(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLfloat u;
+	GLfloat v;
+	u = (GLfloat)NUM2DBL(arg1);
+	v = (GLfloat)NUM2DBL(arg2);
+	glEvalCoord2f(u,v);
+	return Qnil;
+}
+
+static VALUE
+gl_EvalCoord2fv(obj,arg1)
+VALUE obj,arg1;
+{
+	GLfloat params[2] = {0.0,0.0};
+	if (TYPE(arg1) != T_ARRAY) 
+		rb_raise(rb_eTypeError, "type mismatch:%s",rb_class2name(arg1));
+	ary2cflt(arg1,params,2);
+	glEvalCoord2fv(params);
+	return Qnil;
+}
+
+static VALUE
+gl_EvalMesh1(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLenum mode;
+	GLint i1;
+	GLint i2;
+	mode = (GLenum)NUM2INT(arg1);
+	i1 = (GLint)NUM2INT(arg2);
+	i2 = (GLint)NUM2INT(arg3);
+	glEvalMesh1(mode,i1,i2);
+	return Qnil;
+}
+
+static VALUE
+gl_EvalPoint1(obj,arg1)
+VALUE obj,arg1;
+{
+	GLint i;
+	i = (GLint)NUM2INT(arg1);
+	glEvalPoint1(i);
+	return Qnil;
+}
+
+static VALUE
+gl_EvalMesh2(obj,arg1,arg2,arg3,arg4,arg5)
+VALUE obj,arg1,arg2,arg3,arg4,arg5;
+{
+	GLenum mode;
+	GLint i1;
+	GLint i2;
+	GLint j1;
+	GLint j2;
+	mode = (GLenum)NUM2INT(arg1);
+	i1 = (GLint)NUM2INT(arg2);
+	i2 = (GLint)NUM2INT(arg3);
+	j1 = (GLint)NUM2INT(arg4);
+	j2 = (GLint)NUM2INT(arg5);
+	glEvalMesh2(mode,i1,i2,j1,j2);
+	return Qnil;
+}
+
+static VALUE
+gl_EvalPoint2(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLint i;
+	GLint j;
+	i = (GLint)NUM2INT(arg1);
+	j = (GLint)NUM2INT(arg2);
+	glEvalPoint2(i,j);
+	return Qnil;
+}
+
+static VALUE
+gl_AlphaFunc(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLenum func;
+	GLclampf ref;
+	func = (GLenum)NUM2INT(arg1);
+	ref = (GLclampf)NUM2DBL(arg2);
+	glAlphaFunc(func,ref);
+	return Qnil;
+}
+
+static VALUE
+gl_BlendFunc(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLenum sfactor;
+	GLenum dfactor;
+	sfactor = (GLenum)NUM2INT(arg1);
+	dfactor = (GLenum)NUM2INT(arg2);
+	glBlendFunc(sfactor,dfactor);
+	return Qnil;
+}
+
+static VALUE
+gl_LogicOp(obj,arg1)
+VALUE obj,arg1;
+{
+	GLenum opcode;
+	opcode = (GLenum)NUM2INT(arg1);
+	glLogicOp(opcode);
+	return Qnil;
+}
+
+static VALUE
+gl_StencilFunc(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLenum func;
+	GLint ref;
+	GLuint mask;
+	func = (GLenum)NUM2INT(arg1);
+	ref = (GLint)NUM2INT(arg2);
+	mask = (GLuint)NUM2INT(arg3);
+	glStencilFunc(func,ref,mask);
+	return Qnil;
+}
+
+static VALUE
+gl_StencilOp(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLenum fail;
+	GLenum zfail;
+	GLenum zpass;
+	fail = (GLenum)NUM2INT(arg1);
+	zfail = (GLenum)NUM2INT(arg2);
+	zpass = (GLenum)NUM2INT(arg3);
+	glStencilOp(fail,zfail,zpass);
+	return Qnil;
+}
+
+static VALUE
+gl_DepthFunc(obj,arg1)
+VALUE obj,arg1;
+{
+	GLenum func;
+	func = (GLenum)NUM2INT(arg1);
+	glDepthFunc(func);
+	return Qnil;
+}
+
+static VALUE
+gl_PixelZoom(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLfloat xfactor;
+	GLfloat yfactor;
+	xfactor = (GLfloat)NUM2DBL(arg1);
+	yfactor = (GLfloat)NUM2DBL(arg2);
+	glPixelZoom(xfactor,yfactor);
+	return Qnil;
+}
+
+static VALUE
+gl_PixelTransferf(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLenum pname;
+	GLfloat param;
+	pname = (GLenum)NUM2INT(arg1);
+	param = (GLfloat)NUM2DBL(arg2);
+	glPixelTransferf(pname,param);
+	return Qnil;
+}
+
+static VALUE
+gl_PixelTransferi(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLenum pname;
+	GLint param;
+	pname = (GLenum)NUM2INT(arg1);
+	param = (GLint)NUM2INT(arg2);
+	glPixelTransferi(pname,param);
+	return Qnil;
+}
+
+static VALUE
+gl_PixelStoref(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLenum pname;
+	GLfloat param;
+	pname = (GLenum)NUM2INT(arg1);
+	param = (GLfloat)NUM2DBL(arg2);
+	glPixelStoref(pname,param);
+	return Qnil;
+}
+
+static VALUE
+gl_PixelStorei(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLenum pname;
+	GLint param;
+	pname = (GLenum)NUM2INT(arg1);
+	param = (GLint)NUM2INT(arg2);
+	glPixelStorei(pname,param);
+	return Qnil;
+}
+
+static VALUE
+gl_PixelMapfv(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLenum map;
+	GLfloat *values;
+	GLsizei size;
+	map = (GLenum)NUM2INT(arg1);	
+	if (TYPE(arg2) != T_ARRAY)
+		rb_raise(rb_eTypeError, "type mismatch:%s", rb_class2name(arg2));
+	size = RARRAY(arg2)->len;
+	values = ALLOC_N(GLfloat,size);
+	ary2cflt(arg2,values,size);
+	glPixelMapfv(map,size,values);
+	xfree(values);
+	return Qnil;
+}
+
+static VALUE
+gl_PixelMapuiv(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLenum map;
+	GLuint *values;
+	GLsizei size;
+	map = (GLenum)NUM2INT(arg1);
+	if (TYPE(arg2) != T_ARRAY)
+		rb_raise(rb_eTypeError, "type mismatch:%s", rb_class2name(arg2));
+	size = RARRAY(arg2)->len;
+	values = ALLOC_N(GLuint,size);
+	ary2cuint(arg2,values,size);
+	glPixelMapuiv(map,size,values);
+	xfree(values);
+	return Qnil;
+}
+
+static VALUE
+gl_PixelMapusv(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLenum map;
+	GLushort *values;
+	GLsizei size;
+	map = (GLenum)NUM2INT(arg1);
+	if (TYPE(arg2) != T_ARRAY)
+		rb_raise(rb_eTypeError, "type mismatch:%s", rb_class2name(arg2));
+	size = RARRAY(arg2)->len;
+	values = ALLOC_N(GLushort,size);
+	ary2cushort(arg2,values,size);
+	glPixelMapusv(map,size,values);
+	xfree(values);
+	return Qnil;
+}
+
+static VALUE
+gl_ReadBuffer(obj,arg1)
+VALUE obj,arg1;
+{
+	GLenum mode;
+	mode = (GLenum)NUM2INT(arg1);
+	glReadBuffer(mode);
+	return Qnil;
+}
+
+static VALUE
+gl_CopyPixels(obj,arg1,arg2,arg3,arg4,arg5)
+VALUE obj,arg1,arg2,arg3,arg4,arg5;
+{
+	GLint x;
+	GLint y;
+	GLsizei width;
+	GLsizei height;
+	GLenum type;
+	x = (GLint)NUM2INT(arg1);
+	y = (GLint)NUM2INT(arg2);
+	width = (GLsizei)NUM2INT(arg3);
+	height = (GLsizei)NUM2INT(arg4);
+	type = (GLenum)NUM2INT(arg5);
+	glCopyPixels(x,y,width,height,type);
+	return Qnil;
+}
+
+static VALUE
+gl_ReadPixels(obj,arg1,arg2,arg3,arg4,arg5,arg6)
+VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6;
+{
+	GLint x;
+	GLint y;
+	GLsizei width;
+	GLsizei height;
+	int format;
+	int type;
+	VALUE pixels;
+	x = (GLint)NUM2INT(arg1);
+	y = (GLint)NUM2INT(arg2);
+	width = (GLsizei)NUM2INT(arg3);
+	height = (GLsizei)NUM2INT(arg4);
+	format = NUM2INT(arg5);
+	type = NUM2INT(arg6);
+	if (format != -1 && type != -1) {
+		int type_size;
+		int format_size;
+		type_size = gltype_size(type) / 8;
+		format_size = glformat_size(format);
+		pixels = allocate_buffer_with_string(width*height*format_size*type_size);
+		glReadPixels(x,y,width,height,format,type,(GLvoid*)RSTRING(pixels)->ptr);
+		return pixels;
+	}
+	return Qnil;
+}
+
+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;
+	width = (GLsizei)NUM2INT(arg1);
+	height = (GLsizei)NUM2INT(arg2);
+	format = (GLenum)NUM2INT(arg3);
+	type = (GLenum)NUM2INT(arg4);
+	if (format != -1 && type != -1) {
+		if (TYPE(arg5) != T_STRING)
+			rb_raise(rb_eTypeError, "type mismatch:%s", rb_class2name(arg5));
+		if (RSTRING(arg5)->len < width * height * glformat_size(format) * gltype_size(type) / 8)
+			rb_raise(rb_eArgError, "string length:%d", RSTRING(arg5)->len);
+		pixels = RSTRING(arg5)->ptr;
+		glDrawPixels(width,height,format,type,pixels);
+	}
+	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;
+	plane = (GLenum)NUM2INT(arg1);
+	glGetClipPlane(plane,equation);
+	retary = rb_ary_new2(4);
+	for(i=0;i<4;i++)
+		rb_ary_push(retary, rb_float_new(equation[i]));
+	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[32];  \
+	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: \
+		nitems = 4; \
+		break; \
+	case GL_CURRENT_NORMAL: \
+	case GL_POINT_DISTANCE_ATTENUATION: \
+		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: \
+		nitems = 2; \
+		break; \
+	case GL_MODELVIEW_MATRIX: \
+	case GL_PROJECTION_MATRIX: \
+	case GL_TEXTURE_MATRIX: \
+		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])); \
+		} \
+		return ary; \
+	case GL_POLYGON_STIPPLE: \
+		glGet##_name_##v(pname, items); \
+		return rb_str_new((const char*)items, 32); \
+	default: /* size=1 */ \
+		glGet##_name_##v(pname, items); \
+		return _conv_(items[0]); \
+	} \
+	glGet##_name_##v(pname, items); \
+	ary = rb_ary_new2(nitems); \
+	for (i = 0; i < nitems; i++) \
+		rb_ary_push(ary, _conv_(items[i])); \
+	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,INT2NUM)
+
+#undef GLGET_FUNC
+
+static VALUE
+gl_GetError(obj)
+VALUE obj;
+{
+	GLenum ret;
+	ret = glGetError();
+	return INT2NUM(ret);
+}
+
+static VALUE
+gl_GetLightfv(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLenum light;
+	GLenum pname;
+	GLsizei size;
+	GLfloat params[4] = {0.0,0.0,0.0,0.0};
+	VALUE retary;
+	int i;
+	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 */
+	}
+	glGetLightfv(light,pname,params);
+	retary = rb_ary_new2(size);
+	for(i=0;i<size;i++)
+		rb_ary_push(retary, rb_float_new(params[i]));
+	return retary;
+}
+
+static VALUE
+gl_GetLightiv(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLenum light;
+	GLenum pname;
+	GLsizei size;
+	GLint params[4] = {0,0,0,0};
+	VALUE retary;
+	int i;
+	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 */
+	}
+	glGetLightiv(light,pname,params);
+	retary = rb_ary_new2(size);
+	for(i=0;i<size;i++)
+		rb_ary_push(retary, INT2FIX(params[i]));
+	return retary;
+}
+
+static VALUE
+gl_GetMapdv(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLenum target;
+	GLenum query;
+	int dims;
+	int pointsize;
+	int size=0;
+	int i;
+	GLdouble *points;
+	VALUE retary;
+	GLint order[2] = {0,0}; /* for GL_COEFF, [order] or [uorder,vorder] (MAP1/MAP2) */
+	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:
+			glGetMapiv(target,GL_ORDER,order);
+			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(GLdouble,size);
+	glGetMapdv(target,query,points);
+	retary = rb_ary_new2(size);
+	for(i=0;i<size;i++)
+		rb_ary_push(retary, rb_float_new(points[i]));
+	xfree(points);
+	return retary;
+}
+
+static VALUE
+gl_GetMapfv(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLenum target;
+	GLenum query;
+	int dims;
+	int pointsize;
+	int size=0;
+	int i;
+	GLfloat *points;
+	VALUE retary;
+	GLint order[2] = {0,0}; /* for GL_COEFF, [order] or [uorder,vorder] (MAP1/MAP2) */
+	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:
+			glGetMapiv(target,GL_ORDER,order);
+			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(GLfloat,size);
+	glGetMapfv(target,query,points);
+	retary = rb_ary_new2(size);
+	for(i=0;i<size;i++)
+		rb_ary_push(retary, rb_float_new(points[i]));
+	xfree(points);
+	return retary;
+}
+
+static VALUE
+gl_GetMapiv(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLenum target;
+	GLenum query;
+	int dims;
+	int pointsize;
+	int size=0;
+	int i;
+	GLint *points;
+	VALUE retary;
+	GLint order[2] = {0,0}; /* for GL_COEFF, [order] or [uorder,vorder] (MAP1/MAP2) */
+	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:
+			glGetMapiv(target,GL_ORDER,order);
+			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(GLint,size);
+	glGetMapiv(target,query,points);
+	retary = rb_ary_new2(size);
+	for(i=0;i<size;i++)
+		rb_ary_push(retary, INT2FIX(points[i]));
+	xfree(points);
+	return retary;
+}
+
+static VALUE
+gl_GetMaterialfv(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLenum face;
+	GLenum pname;
+	GLfloat params[4] = {0.0,0.0,0.0,0.0};
+	int size;
+	VALUE retary;
+	int i;
+	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 */
+	}
+	glGetMaterialfv(face,pname,params);
+	retary = rb_ary_new2(size);
+	for(i=0;i<size;i++)
+		rb_ary_push(retary, rb_ary_new2(params[i]));
+	return retary;
+}
+
+static VALUE
+gl_GetMaterialiv(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLenum face;
+	GLenum pname;
+	GLint params[4] = {0,0,0,0};
+	int size;
+	VALUE retary;
+	int i;
+	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 */
+	}
+	glGetMaterialiv(face,pname,params);
+	retary = rb_ary_new2(size);
+	for(i=0;i<size;i++)
+		rb_ary_push(retary, INT2FIX(params[i]));
+	return retary;
+}
+
+static VALUE
+gl_GetPixelMapfv(obj,arg1)
+VALUE obj,arg1;
+{
+	GLenum map;
+	GLenum map_size;
+	GLint size;
+	GLfloat *values;
+	VALUE retary;
+	int i;
+	map = (GLenum)NUM2INT(arg1);
+	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; /* not reached */
+	}
+	glGetIntegerv(map_size,&size);
+	values = ALLOC_N(GLfloat,size);
+	glGetPixelMapfv(map,values);
+	retary = rb_ary_new2(size);
+	for(i=0;i<size;i++)
+		rb_ary_push(retary, rb_float_new(values[i]));
+	xfree(values);
+	return retary;
+}
+
+static VALUE
+gl_GetPixelMapuiv(obj,arg1)
+VALUE obj,arg1;
+{
+	GLenum map;
+	GLenum map_size;
+	GLint size;
+	GLuint *values;
+	VALUE retary;
+	int i;
+	map = (GLenum)NUM2INT(arg1);
+	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; /* not reached */
+	}
+	glGetIntegerv(map_size,&size);
+	values = ALLOC_N(GLuint,size);
+	glGetPixelMapuiv(map,values);
+	retary = rb_ary_new2(size);
+	for(i=0;i<size;i++)
+		rb_ary_push(retary, INT2FIX(values[i]));
+	xfree(values);
+	return retary;
+}
+
+static VALUE
+gl_GetPixelMapusv(obj,arg1)
+VALUE obj,arg1;
+{
+	GLenum map;
+	GLenum map_size;
+	GLint size;
+	GLushort *values;
+	VALUE retary;
+	int i;
+	map = (GLenum)NUM2INT(arg1);
+	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; /* not reached */
+	}
+	glGetIntegerv(map_size,&size);
+	values = ALLOC_N(GLushort,size);
+	glGetPixelMapusv(map,values);
+	retary = rb_ary_new2(size);
+	for(i=0;i<size;i++)
+		rb_ary_push(retary, INT2FIX(values[i]));
+	xfree(values);
+	return retary;
+}
+
+static VALUE
+gl_GetPolygonStipple(obj,arg1)
+VALUE obj,arg1;
+{
+	GLubyte mask[128];
+	glGetPolygonStipple(mask);
+	return rb_str_new((const char*)mask, 128);
+}
+
+static VALUE
+gl_GetString(obj,arg1)
+VALUE obj,arg1;
+{
+	GLenum name;
+	const GLubyte *ret;
+	name = (GLenum)NUM2INT(arg1);
+	ret = glGetString(name);
+	return rb_str_new2((const char*)ret);
+}
+
+static VALUE
+gl_GetTexEnvfv(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLenum target;
+	GLenum pname;
+	GLfloat params[4] = {0.0,0.0,0.0,0.0};
+	int size;
+	VALUE retary;
+	int i;
+	target = (GLenum)NUM2INT(arg1);
+	pname = (GLenum)NUM2INT(arg2);
+	switch(pname) {
+		case GL_TEXTURE_ENV_COLOR:
+			size = 4;
+			break;
+		case GL_TEXTURE_ENV_MODE:
+		case GL_COORD_REPLACE:
+		case GL_TEXTURE_LOD_BIAS:
+		case GL_COMBINE_RGB:
+		case GL_COMBINE_ALPHA:
+		case GL_SRC0_RGB:
+		case GL_SRC1_RGB:
+		case GL_SRC2_RGB:
+		case GL_SRC0_ALPHA:
+		case GL_SRC1_ALPHA:
+		case GL_SRC2_ALPHA:
+		case GL_OPERAND0_RGB:
+		case GL_OPERAND1_RGB:
+		case GL_OPERAND2_RGB:
+		case GL_OPERAND0_ALPHA:
+		case GL_OPERAND1_ALPHA:
+		case GL_OPERAND2_ALPHA:
+		case GL_RGB_SCALE:
+		case GL_ALPHA_SCALE:
+			size = 1;
+			break;
+		default:
+			rb_raise(rb_eArgError, "unknown pname:%d",pname);
+			break; /* not reached */
+	}
+	glGetTexEnvfv(target,pname,params);
+	retary = rb_ary_new2(size);
+	for(i=0;i<size;i++)
+		rb_ary_push(retary, rb_ary_new2(params[i]));
+	return retary;
+}
+
+static VALUE
+gl_GetTexEnviv(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLenum target;
+	GLenum pname;
+	GLint params[4] = {0,0,0,0};
+	int size;
+	VALUE retary;
+	int i;
+	target = (GLenum)NUM2INT(arg1);
+	pname = (GLenum)NUM2INT(arg2);
+	switch(pname) {
+		case GL_TEXTURE_ENV_COLOR:
+			size = 4;
+			break;
+		case GL_TEXTURE_ENV_MODE:
+		case GL_COORD_REPLACE:
+		case GL_TEXTURE_LOD_BIAS:
+		case GL_COMBINE_RGB:
+		case GL_COMBINE_ALPHA:
+		case GL_SRC0_RGB:
+		case GL_SRC1_RGB:
+		case GL_SRC2_RGB:
+		case GL_SRC0_ALPHA:
+		case GL_SRC1_ALPHA:
+		case GL_SRC2_ALPHA:
+		case GL_OPERAND0_RGB:
+		case GL_OPERAND1_RGB:
+		case GL_OPERAND2_RGB:
+		case GL_OPERAND0_ALPHA:
+		case GL_OPERAND1_ALPHA:
+		case GL_OPERAND2_ALPHA:
+		case GL_RGB_SCALE:
+		case GL_ALPHA_SCALE:
+			size = 1;
+			break;
+		default:
+			rb_raise(rb_eArgError, "unknown pname:%d",pname);
+			break; /* not reached */
+	}
+	glGetTexEnviv(target,pname,params);
+	retary = rb_ary_new2(size);
+	for(i=0;i<size;i++)
+		rb_ary_push(retary, INT2FIX(params[i]));
+	return retary;
+}
+
+static VALUE
+gl_GetTexGendv(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLenum coord;
+	GLenum pname;
+	GLdouble params[4] = {0.0,0.0,0.0,0.0};
+	int size;
+	VALUE retary;
+	int i;
+	coord = (GLenum)NUM2INT(arg1);
+	pname = (GLenum)NUM2INT(arg2);
+	switch(pname) {
+		case GL_OBJECT_PLANE:
+		case GL_EYE_PLANE:
+			size = 4;
+			break;
+		case GL_TEXTURE_GEN_MODE:
+			size = 1;
+			break;
+		default:
+			rb_raise(rb_eArgError, "unknown pname:%d",pname);
+			break; /* not reached */
+	}
+	glGetTexGendv(coord,pname,params);
+	retary = rb_ary_new2(size);
+	for(i=0;i<size;i++)
+		rb_ary_push(retary, rb_ary_new2(params[i]));
+	return retary;
+}
+
+static VALUE
+gl_GetTexGenfv(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLenum coord;
+	GLenum pname;
+	GLfloat params[4] = {0.0,0.0,0.0,0.0};
+	int size;
+	VALUE retary;
+	int i;
+	coord = (GLenum)NUM2INT(arg1);
+	pname = (GLenum)NUM2INT(arg2);
+	switch(pname) {
+		case GL_OBJECT_PLANE:
+		case GL_EYE_PLANE:
+			size = 4;
+			break;
+		case GL_TEXTURE_GEN_MODE:
+			size = 1;
+			break;
+		default:
+			rb_raise(rb_eArgError, "unknown pname:%d",pname);
+			break; /* not reached */
+	}
+	glGetTexGenfv(coord,pname,params);
+	retary = rb_ary_new2(size);
+	for(i=0;i<size;i++)
+		rb_ary_push(retary, rb_ary_new2(params[i]));
+	return retary;
+}
+
+static VALUE
+gl_GetTexGeniv(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLenum coord;
+	GLenum pname;
+	GLint params[4] = {0,0,0,0};
+	int size;
+	VALUE retary;
+	int i;
+	coord = (GLenum)NUM2INT(arg1);
+	pname = (GLenum)NUM2INT(arg2);
+	switch(pname) {
+		case GL_OBJECT_PLANE:
+		case GL_EYE_PLANE:
+			size = 4;
+			break;
+		case GL_TEXTURE_GEN_MODE:
+			size = 1;
+			break;
+		default:
+			rb_raise(rb_eArgError, "unknown pname:%d",pname);
+			break; /* not reached */
+	}
+	glGetTexGeniv(coord,pname,params);
+	retary = rb_ary_new2(size);
+	for(i=0;i<size;i++)
+		rb_ary_push(retary, INT2FIX(params[i]));
+	return retary;
+}
+
+/*
+static VALUE
+gl_GetTexImage(obj,arg1,arg2,arg3,arg4,arg5)
+VALUE obj,arg1,arg2,arg3,arg4,arg5;
+{
+	#warning glGetTexImage not implemented
+	return Qnil;
+}
+*/
+
+static VALUE
+gl_GetTexParameterfv(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLenum target;
+	GLenum pname;
+	GLfloat params[4] = {0.0,0.0,0.0,0.0};
+	int size;
+	VALUE retary;
+	int i;
+	target = (GLenum)NUM2INT(arg1);
+	pname = (GLenum)NUM2INT(arg2);
+	switch(pname) {
+		case GL_TEXTURE_BORDER_COLOR:
+			size = 4;
+			break;
+		default:
+			size = 1;
+			break;
+	}
+	glGetTexParameterfv(target,pname,params);
+	retary = rb_ary_new2(size);
+	for(i=0;i<size;i++)
+		rb_ary_push(retary, rb_float_new(params[i]));
+	return retary;
+}
+
+static VALUE
+gl_GetTexParameteriv(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLenum target;
+	GLenum pname;
+	GLint params[4] = {0,0,0,0};
+	int size;
+	VALUE retary;
+	int i;
+	target = (GLenum)NUM2INT(arg1);
+	pname = (GLenum)NUM2INT(arg2);
+	switch(pname) {
+		case GL_TEXTURE_BORDER_COLOR:
+			size = 4;
+			break;
+		default:
+			size = 1;
+			break;
+	}
+	glGetTexParameteriv(target,pname,params);
+	retary = rb_ary_new2(size);
+	for(i=0;i<size;i++)
+		rb_ary_push(retary, INT2FIX(params[i]));
+	return retary;
+}
+
+static VALUE
+gl_GetTexLevelParameterfv(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLenum target;
+	GLint level;
+	GLenum pname;
+	GLfloat params; 
+	VALUE retary;
+	target = (GLenum)NUM2INT(arg1);
+	level = (GLint)NUM2INT(arg2);
+	pname = (GLenum)NUM2INT(arg3);
+	glGetTexLevelParameterfv(target,level,pname,&params);
+	retary = rb_ary_new2(1);
+	rb_ary_push(retary, rb_float_new(params));
+	return retary;
+}
+
+static VALUE
+gl_GetTexLevelParameteriv(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLenum target;
+	GLint level;
+	GLenum pname;
+	GLint params; 
+	VALUE retary;
+	target = (GLenum)NUM2INT(arg1);
+	level = (GLint)NUM2INT(arg2);
+	pname = (GLenum)NUM2INT(arg3);
+	glGetTexLevelParameteriv(target,level,pname,&params);
+	retary = rb_ary_new2(1);
+	rb_ary_push(retary, INT2FIX(params));
+	return retary;
+}
+
+static VALUE
+gl_IsEnabled(obj,arg1)
+VALUE obj,arg1;
+{
+	GLenum cap;
+	GLboolean ret;
+	cap = (GLenum)NUM2INT(arg1);
+	ret = glIsEnabled(cap);
+	return INT2NUM(ret);
+}
+
+static VALUE
+gl_IsList(obj,arg1)
+VALUE obj,arg1;
+{
+	GLuint list;
+	GLboolean ret;
+	list = (GLuint)NUM2INT(arg1);
+	ret = glIsList(list);
+	return INT2NUM(ret);
+}
+
+static VALUE
+gl_DepthRange(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLclampd near_val;
+	GLclampd far_val;
+	near_val = (GLclampd)NUM2DBL(arg1);
+	far_val = (GLclampd)NUM2DBL(arg2);
+	glDepthRange(near_val,far_val);
+	return Qnil;
+}
+
+static VALUE
+gl_Frustum(obj,arg1,arg2,arg3,arg4,arg5,arg6)
+VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6;
+{
+	GLdouble left;
+	GLdouble right;
+	GLdouble bottom;
+	GLdouble top;
+	GLdouble near_val;
+	GLdouble far_val;
+	left = (GLdouble)NUM2DBL(arg1);
+	right = (GLdouble)NUM2DBL(arg2);
+	bottom = (GLdouble)NUM2DBL(arg3);
+	top = (GLdouble)NUM2DBL(arg4);
+	near_val = (GLdouble)NUM2DBL(arg5);
+	far_val = (GLdouble)NUM2DBL(arg6);
+	glFrustum(left,right,bottom,top,near_val,far_val);
+	return Qnil;
+}
+
+static VALUE
+gl_LoadIdentity(obj)
+VALUE obj;
+{
+	glLoadIdentity();
+	return Qnil;
+}
+
+static VALUE
+gl_LoadMatrixf(obj,arg1)
+VALUE obj,arg1;
+{
+	GLfloat m[4*4];
+	ary2cmat4x4flt(arg1, m);
+	glLoadMatrixf(m);
+	return Qnil;
+}
+
+static VALUE
+gl_LoadMatrixd(obj,arg1)
+VALUE obj,arg1;
+{
+	GLdouble m[4*4];
+	ary2cmat4x4dbl(arg1, m);
+	glLoadMatrixd(m);
+	return Qnil;
+}
+
+static VALUE
+gl_MatrixMode(obj,arg1)
+VALUE obj,arg1;
+{
+	GLenum mode;
+	mode = (GLenum)NUM2INT(arg1);
+	glMatrixMode(mode);
+	return Qnil;
+}
+
+static VALUE
+gl_MultMatrixf(obj,arg1)
+VALUE obj,arg1;
+{
+	GLfloat m[4*4];
+	ary2cmat4x4flt(arg1, m);
+	glMultMatrixf(m);
+	return Qnil;
+}
+
+static VALUE
+gl_MultMatrixd(obj,arg1)
+VALUE obj,arg1;
+{
+	GLdouble m[4*4];
+	ary2cmat4x4dbl(arg1, m);
+	glMultMatrixd(m);
+	return Qnil;
+}
+
+static VALUE
+gl_Ortho(obj,arg1,arg2,arg3,arg4,arg5,arg6)
+VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6;
+{
+	GLdouble left;
+	GLdouble right;
+	GLdouble bottom;
+	GLdouble top;
+	GLdouble near_val;
+	GLdouble far_val;
+	left = (GLdouble)NUM2DBL(arg1);
+	right = (GLdouble)NUM2DBL(arg2);
+	bottom = (GLdouble)NUM2DBL(arg3);
+	top = (GLdouble)NUM2DBL(arg4);
+	near_val = (GLdouble)NUM2DBL(arg5);
+	far_val = (GLdouble)NUM2DBL(arg6);
+	glOrtho(left,right,bottom,top,near_val,far_val);
+	return Qnil;
+}
+
+static VALUE
+gl_PopMatrix(obj)
+VALUE obj;
+{
+	glPopMatrix();
+	return Qnil;
+}
+
+static VALUE
+gl_PushMatrix(obj)
+VALUE obj;
+{
+	glPushMatrix();
+	return Qnil;
+}
+
+static VALUE
+gl_Rotated(obj,arg1,arg2,arg3,arg4)
+VALUE obj,arg1,arg2,arg3,arg4;
+{
+	GLdouble angle;
+	GLdouble x;
+	GLdouble y;
+	GLdouble z;
+	angle = (GLdouble)NUM2DBL(arg1);
+	x = (GLdouble)NUM2DBL(arg2);
+	y = (GLdouble)NUM2DBL(arg3);
+	z = (GLdouble)NUM2DBL(arg4);
+	glRotated(angle,x,y,z);
+	return Qnil;
+}
+
+static VALUE
+gl_Rotatef(obj,arg1,arg2,arg3,arg4)
+VALUE obj,arg1,arg2,arg3,arg4;
+{
+	GLfloat angle;
+	GLfloat x;
+	GLfloat y;
+	GLfloat z;
+	angle = (GLfloat)NUM2DBL(arg1);
+	x = (GLfloat)NUM2DBL(arg2);
+	y = (GLfloat)NUM2DBL(arg3);
+	z = (GLfloat)NUM2DBL(arg4);
+	glRotatef(angle,x,y,z);
+	return Qnil;
+}
+
+static VALUE
+gl_Scaled(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLdouble x;
+	GLdouble y;
+	GLdouble z;
+	x = (GLdouble)NUM2DBL(arg1);
+	y = (GLdouble)NUM2DBL(arg2);
+	z = (GLdouble)NUM2DBL(arg3);
+	glScaled(x,y,z);
+	return Qnil;
+}
+
+static VALUE
+gl_Scalef(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLfloat x;
+	GLfloat y;
+	GLfloat z;
+	x = (GLfloat)NUM2DBL(arg1);
+	y = (GLfloat)NUM2DBL(arg2);
+	z = (GLfloat)NUM2DBL(arg3);
+	glScalef(x,y,z);
+	return Qnil;
+}
+
+static VALUE
+gl_Translated(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLdouble x;
+	GLdouble y;
+	GLdouble z;
+	x = (GLdouble)NUM2DBL(arg1);
+	y = (GLdouble)NUM2DBL(arg2);
+	z = (GLdouble)NUM2DBL(arg3);
+	glTranslated(x,y,z);
+	return Qnil;
+}
+
+static VALUE
+gl_Translatef(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLfloat x;
+	GLfloat y;
+	GLfloat z;
+	x = (GLfloat)NUM2DBL(arg1);
+	y = (GLfloat)NUM2DBL(arg2);
+	z = (GLfloat)NUM2DBL(arg3);
+	glTranslatef(x,y,z);
+	return Qnil;
+}
+
+static VALUE
+gl_Viewport(obj,arg1,arg2,arg3,arg4)
+VALUE obj,arg1,arg2,arg3,arg4;
+{
+	GLint x;
+	GLint y;
+	GLsizei width;
+	GLsizei height;
+	x = (GLint)NUM2INT(arg1);
+	y = (GLint)NUM2INT(arg2);
+	width = (GLsizei)NUM2INT(arg3);
+	height = (GLsizei)NUM2INT(arg4);
+	glViewport(x,y,width,height);
+	return Qnil;
+}
+
+static VALUE
+gl_ArrayElement(obj,arg1)
+VALUE obj,arg1;
+{
+	GLint i;
+	i = (GLint)NUM2INT(arg1);
+	glArrayElement(i);
+	return Qnil;
+}
+
+static VALUE g_Vertex_ptr;
+static VALUE g_Normal_ptr;
+static VALUE g_Color_ptr;
+static VALUE g_Index_ptr;
+static VALUE g_TexCoord_ptr;
+static VALUE g_EdgeFlag_ptr;
+VALUE g_FogCoord_ptr = 0;
+VALUE g_SecondaryColor_ptr = 0;
+#define POINTER_FUNC(_func_) \
+static VALUE \
+gl_##_func_##Pointer(obj, arg1, arg2, arg3, arg4) \
+VALUE obj, arg1, arg2, arg3, arg4; \
+{ \
+	GLint size; \
+	GLenum type; \
+	GLsizei stride; \
+	size = (GLint)NUM2INT(arg1); \
+	type = (GLenum)NUM2INT(arg2); \
+	stride = (GLsizei)NUM2INT(arg3); \
+	Check_Type(arg4, T_STRING); \
+	rb_str_freeze(arg4); \
+	g_##_func_##_ptr = arg4; \
+	gl##_func_##Pointer(size, type, stride, (const GLvoid*)RSTRING(arg4)->ptr); \
+	return Qnil; \
+}
+
+POINTER_FUNC(Vertex)
+POINTER_FUNC(Color)
+POINTER_FUNC(TexCoord)
+
+#undef POINTER_FUNC
+
+static VALUE
+gl_DisableClientState(obj,arg1)
+VALUE obj,arg1;
+{
+	GLenum cap;
+	cap = (GLenum)NUM2INT(arg1);
+	glDisableClientState(cap);
+	return Qnil;
+}
+
+static VALUE
+gl_DrawArrays(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLenum mode;
+	GLint first;
+	GLsizei count;
+	mode = (GLenum)NUM2INT(arg1);
+	first = (GLint)NUM2INT(arg2);
+	count = (GLsizei)NUM2INT(arg3);
+	glDrawArrays(mode,first,count);
+	return Qnil;
+}
+
+static VALUE
+gl_DrawElements(obj,arg1,arg2,arg3,arg4)
+VALUE obj,arg1,arg2,arg3,arg4;
+{
+	GLenum mode;
+	GLsizei count;
+	GLenum type;
+	mode = (GLenum)NUM2INT(arg1);
+	count = (GLsizei)NUM2INT(arg2);
+	type = (GLenum)NUM2INT(arg3);
+	Check_Type(arg4, T_STRING);
+	glDrawElements(mode, count, type, (const GLvoid*)RSTRING(arg4)->ptr);
+	return Qnil;
+}
+
+static VALUE
+gl_EdgeFlagPointer(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLsizei stride;
+	stride = (GLsizei)NUM2INT(arg1);
+	Check_Type(arg2, T_STRING);
+	rb_str_freeze(arg2);
+	g_EdgeFlag_ptr = arg2;
+	glEdgeFlagPointer(stride, (const GLboolean*)RSTRING(arg2)->ptr);
+	return Qnil;
+}
+
+static VALUE
+gl_EnableClientState(obj,arg1)
+VALUE obj,arg1;
+{
+	GLenum cap;
+	cap = (GLenum)NUM2INT(arg1);
+	glEnableClientState(cap);
+	return Qnil;
+}
+
+static VALUE
+gl_GetPointerv(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLenum pname;
+	pname = (GLenum)NUM2INT(arg1);
+	switch (pname) {
+		case GL_VERTEX_ARRAY_POINTER: 
+			return g_Vertex_ptr;
+		case GL_NORMAL_ARRAY_POINTER: 
+			return g_Normal_ptr;
+		case GL_COLOR_ARRAY_POINTER: 
+			return g_Color_ptr;
+		case GL_INDEX_ARRAY_POINTER: 
+			return g_Index_ptr;
+		case GL_TEXTURE_COORD_ARRAY_POINTER: 
+			return g_TexCoord_ptr;
+		case GL_EDGE_FLAG_ARRAY_POINTER: 
+			return g_EdgeFlag_ptr;
+		case GL_FOG_COORD_ARRAY_POINTER:
+			return g_FogCoord_ptr;
+		case GL_SECONDARY_COLOR_ARRAY_POINTER:
+			return g_SecondaryColor_ptr;
+		default:
+			rb_raise(rb_eArgError, "Invalid pname %d",pname);
+			break; /* not reached */
+	}
+	return Qnil;
+}
+
+static VALUE
+gl_IndexPointer(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLenum type;
+	GLsizei stride;
+	type = (GLenum)NUM2INT(arg1);
+	stride = (GLsizei)NUM2INT(arg2);
+	Check_Type(arg3, T_STRING);
+	rb_str_freeze(arg3);
+	g_Index_ptr = arg3;
+	glIndexPointer(type, stride, (const GLvoid*)RSTRING(arg3)->ptr);
+	return Qnil;
+}
+
+static VALUE
+gl_InterleavedArrays(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLenum format;
+	GLsizei stride;
+	format = (GLenum)NUM2INT(arg1);
+	stride = (GLsizei)NUM2INT(arg2);
+	Check_Type(arg3, T_STRING);
+	glInterleavedArrays(format, stride, (const GLvoid*)RSTRING(arg3)->ptr);
+	return Qnil;
+}
+
+static VALUE
+gl_NormalPointer(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLenum type;
+	GLsizei stride;
+	type = (GLenum)NUM2INT(arg1);
+	stride = (GLsizei)NUM2INT(arg2);
+	Check_Type(arg3, T_STRING);
+	rb_str_freeze(arg3);
+	g_Normal_ptr = arg3;
+	glNormalPointer(type, stride, (const GLvoid*)RSTRING(arg3)->ptr);
+	return Qnil;
+}
+
+static VALUE
+gl_PolygonOffset(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLfloat factor;
+	GLfloat units;
+	factor = (GLfloat)NUM2DBL(arg1);
+	units = (GLfloat)NUM2DBL(arg2);
+	glPolygonOffset(factor,units);
+	return Qnil;
+}
+
+static VALUE
+gl_CopyTexImage1D(obj,arg1,arg2,arg3,arg4,arg5,arg6,arg7)
+VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6,arg7;
+{
+	GLenum target;
+	GLint level;
+	GLenum internalformat;
+	GLint x;
+	GLint y;
+	GLsizei width;
+	GLint border;
+	target = (GLenum)NUM2INT(arg1);
+	level = (GLint)NUM2INT(arg2);
+	internalformat = (GLenum)NUM2INT(arg3);
+	x = (GLint)NUM2INT(arg4);
+	y = (GLint)NUM2INT(arg5);
+	width = (GLsizei)NUM2INT(arg6);
+	border = (GLint)NUM2INT(arg7);
+	glCopyTexImage1D(target,level,internalformat,x,y,width,border);
+	return Qnil;
+}
+
+static VALUE
+gl_CopyTexImage2D(obj,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8)
+VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8;
+{
+	GLenum target;
+	GLint level;
+	GLenum internalformat;
+	GLint x;
+	GLint y;
+	GLsizei width;
+	GLsizei height;
+	GLint border;
+	target = (GLenum)NUM2INT(arg1);
+	level = (GLint)NUM2INT(arg2);
+	internalformat = (GLenum)NUM2INT(arg3);
+	x = (GLint)NUM2INT(arg4);
+	y = (GLint)NUM2INT(arg5);
+	width = (GLsizei)NUM2INT(arg6);
+	height = (GLsizei)NUM2INT(arg7);
+	border = (GLint)NUM2INT(arg8);
+	glCopyTexImage2D(target,level,internalformat,x,y,width,height,border);
+	return Qnil;
+}
+
+static VALUE
+gl_CopyTexSubImage1D(obj,arg1,arg2,arg3,arg4,arg5,arg6)
+VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6;
+{
+	GLenum target;
+	GLint level;
+	GLint xoffset;
+	GLint x;
+	GLint y;
+	GLsizei width;
+	target = (GLenum)NUM2INT(arg1);
+	level = (GLint)NUM2INT(arg2);
+	xoffset = (GLint)NUM2INT(arg3);
+	x = (GLint)NUM2INT(arg4);
+	y = (GLint)NUM2INT(arg5);
+	width = (GLsizei)NUM2INT(arg6);
+	glCopyTexSubImage1D(target,level,xoffset,x,y,width);
+	return Qnil;
+}
+
+static VALUE
+gl_CopyTexSubImage2D(obj,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8)
+VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8;
+{
+	GLenum target;
+	GLint level;
+	GLint xoffset;
+	GLint yoffset;
+	GLint x;
+	GLint y;
+	GLsizei width;
+	GLsizei height;
+	target = (GLenum)NUM2INT(arg1);
+	level = (GLint)NUM2INT(arg2);
+	xoffset = (GLint)NUM2INT(arg3);
+	yoffset = (GLint)NUM2INT(arg4);
+	x = (GLint)NUM2INT(arg5);
+	y = (GLint)NUM2INT(arg6);
+	width = (GLsizei)NUM2INT(arg7);
+	height = (GLsizei)NUM2INT(arg8);
+	glCopyTexSubImage2D(target,level,xoffset,yoffset,x,y,width,height);
+	return Qnil;
+}
+
+static VALUE
+gl_TexSubImage1D(obj,arg1,arg2,arg3,arg4,arg5,arg6,arg7)
+VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6,arg7;
+{
+	GLenum target;
+	GLint level;
+	GLint xoffset;
+	GLsizei width;
+	GLenum format;
+	GLenum type;
+	const char *pixels;
+	int size;
+	int type_size;
+	int format_size;
+	target = (GLenum)NUM2INT(arg1);
+	level = (GLint)NUM2INT(arg2);
+	xoffset = (GLint)NUM2INT(arg3);
+	width = (GLsizei)NUM2INT(arg4);
+	format = (GLenum)NUM2INT(arg5);
+	type = (GLenum)NUM2INT(arg6);
+	if (TYPE(arg7) == T_STRING) {
+		type_size = gltype_size(type) / 8;
+		format_size = glformat_size(format);
+		if (type_size < 0 || format_size == -1)
+			return Qnil;
+		size = type_size*format_size*width;
+		if (RSTRING(arg7)->len < size)
+			rb_raise(rb_eArgError, "string length:%d",RSTRING(arg7)->len);
+		 pixels = RSTRING(arg7)->ptr;
+	} else
+		rb_raise(rb_eTypeError, "type mismatch:%s",rb_class2name(arg7));
+	glTexSubImage1D(target,level,xoffset,width,format,type,pixels);
+	return Qnil;
+}
+
+static VALUE
+gl_TexSubImage2D(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 xoffset;
+	GLint yoffset;
+	GLsizei width;
+	GLsizei height;
+	GLenum format;
+	GLenum type;
+	const char *pixels;
+	int size;
+	int type_size;
+	int format_size;
+	target = (GLenum)NUM2INT(arg1);
+	level = (GLint)NUM2INT(arg2);
+	xoffset = (GLint)NUM2INT(arg3);
+	yoffset = (GLint)NUM2INT(arg4);
+	width = (GLsizei)NUM2INT(arg5);
+	height = (GLsizei)NUM2INT(arg6);
+	format = (GLenum)NUM2INT(arg7);
+	type = (GLenum)NUM2INT(arg8);
+	if (TYPE(arg9) == T_STRING) {
+		type_size = gltype_size(type) / 8;
+		format_size = glformat_size(format);
+		if (type_size < 0 || format_size == -1)
+			return Qnil;
+		size = type_size*format_size*height*width;
+		if (RSTRING(arg9)->len < size)
+			rb_raise(rb_eArgError, "string length:%d",RSTRING(arg9)->len);
+		 pixels = RSTRING(arg9)->ptr;
+	} else
+		rb_raise(rb_eTypeError, "type mismatch:%s",rb_class2name(arg9));
+	glTexSubImage2D(target,level,xoffset,yoffset,width,height,format,type,pixels);
+	return Qnil;
+}
+
+static VALUE
+gl_AreTexturesResident(obj,arg1)
+VALUE obj,arg1;
+{
+	GLuint *textures;
+	GLboolean *residences;
+	GLsizei size;
+	GLboolean r;
+	VALUE retary;
+	int i;
+	if (TYPE(arg1) != T_ARRAY)
+		rb_raise(rb_eTypeError, "type mismatch:%s", rb_class2name(arg1));
+	size = RARRAY(arg1)->len;
+	textures = ALLOC_N(GLuint,size);
+	residences = ALLOC_N(GLboolean,size);
+	ary2cuint(arg1,textures,size);	
+	r = glAreTexturesResident(size,textures,residences);
+	retary = rb_ary_new2(size);
+	if (r==GL_TRUE) { /* all are resident */
+		for(i=0;i<size;i++)
+			rb_ary_push(retary, INT2FIX(GL_TRUE));
+	} else {
+		for(i=0;i<size;i++)
+			rb_ary_push(retary, INT2FIX(residences[i]));
+	}
+	xfree(textures);
+	xfree(residences);
+	return retary;
+}
+
+static VALUE
+gl_BindTexture(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLenum target;
+	GLuint texture;
+	target = (GLenum)NUM2INT(arg1);
+	texture = (GLuint)NUM2INT(arg2);
+	glBindTexture(target,texture);
+	return Qnil;
+}
+
+static VALUE
+gl_DeleteTextures(obj,arg1)
+VALUE obj,arg1;
+{
+	GLsizei n;
+	GLuint *textures;
+	RArray *ary;
+	if (TYPE(arg1) != T_ARRAY)
+		rb_raise(rb_eTypeError, "type mismatch:%s", rb_class2name(arg1));
+	ary = RARRAY(arg1);
+	n = ary->len;
+	textures = ALLOC_N(GLuint,n);
+	ary2cuint(arg1,textures,n); 
+	glDeleteTextures( n, textures);
+	xfree(textures);
+	return Qnil;
+}
+
+static VALUE
+gl_GenTextures(obj,arg1)
+VALUE obj,arg1;
+{
+	GLsizei n;
+	GLuint *textures;
+	RArray *ret;
+	int i;
+	n = (GLsizei)NUM2INT(arg1);
+	textures = ALLOC_N(GLuint, n);
+	glGenTextures(n, textures);
+	ret = RARRAY(rb_ary_new2(n));
+	for (i = 0; i < n; i++)
+		rb_ary_push((VALUE)ret, INT2NUM(textures[i]));
+	xfree(textures);
+	return (VALUE)ret;
+}
+
+static VALUE
+gl_IsTexture(obj,arg1)
+VALUE obj,arg1;
+{
+	GLuint texture;
+	GLboolean ret;
+	texture = (GLuint)NUM2INT(arg1);
+	ret = glIsTexture(texture);
+	return INT2NUM(ret);
+}
+
+static VALUE
+gl_PrioritizeTextures(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLuint *textures;
+	GLclampf *priorities;
+	GLsizei size;
+	if (TYPE(arg1) != T_ARRAY)
+		rb_raise(rb_eTypeError, "type mismatch:%s", rb_class2name(arg1));
+	if (TYPE(arg2) != T_ARRAY)
+		rb_raise(rb_eTypeError, "type mismatch:%s", rb_class2name(arg2));
+	if ((size = RARRAY(arg1)->len) != RARRAY(arg2)->len)
+		rb_raise(rb_eArgError, "passed arrays must have the same length");
+	textures = ALLOC_N(GLuint,size);
+	priorities = ALLOC_N(GLclampf,size);
+	ary2cuint(arg1,textures,size);	
+	ary2cflt(arg2,priorities,size);	
+	glPrioritizeTextures(size,textures,priorities);
+	xfree(textures);
+	xfree(priorities);
+	return Qnil;
+}
+
+static VALUE
+gl_Indexub(obj,arg1)
+VALUE obj,arg1;
+{
+	GLubyte c;
+	c = (GLubyte)NUM2INT(arg1);
+	glIndexub(c);
+	return Qnil;
+}
+
+static VALUE
+gl_Indexubv(obj,arg1)
+VALUE obj,arg1;
+{
+	GLubyte c[1] = {0};
+	if (TYPE(arg1) != T_ARRAY) 
+		rb_raise(rb_eTypeError, "type mismatch:%s",rb_class2name(arg1));
+	ary2cubyte(arg1,c,1);
+	glIndexubv(c);
+	return Qnil;
+}
+
+static VALUE
+gl_PopClientAttrib(obj)
+VALUE obj;
+{
+	glPopClientAttrib();
+	return Qnil;
+}
+
+static VALUE
+gl_PushClientAttrib(obj,arg1)
+VALUE obj,arg1;
+{
+	GLbitfield mask;
+	mask = (GLbitfield)NUM2INT(arg1);
+	glPushClientAttrib(mask);
+	return Qnil;
+}
+
+/* additional functions */
+
+#define GLCOLOR_VFUNC(_type_) \
+static VALUE \
+gl_Color##_type_##v(argc,argv,obj) \
+int argc; \
+VALUE *argv; \
+VALUE obj; \
+{ \
+	int num; \
+	VALUE args[4]; \
+	RArray *ary; \
+	switch (num = rb_scan_args(argc, argv, "13", &args[0], &args[1], &args[2], &args[3])) { \
+	case 1: \
+		if (TYPE(args[0]) == T_ARRAY) { \
+		ary = RARRAY(args[0]); \
+		switch (ary->len) { \
+			case 3: \
+			gl_Color3##_type_(obj,ary->ptr[0],ary->ptr[1],ary->ptr[2]); \
+			break; \
+			case 4: \
+			gl_Color4##_type_(obj,ary->ptr[0],ary->ptr[1],ary->ptr[2],ary->ptr[3]); \
+			break; \
+			default: \
+			rb_raise(rb_eArgError, "array length:%d", ary->len); \
+		} \
+		} \
+		else \
+			rb_raise(rb_eTypeError, "type mismatch:%s", rb_class2name(CLASS_OF(args[0]))); \
+		break; \
+	case 3: \
+		gl_Color3##_type_(obj,args[0], args[1], args[2]); \
+		break; \
+	case 4: \
+		gl_Color4##_type_(obj,args[0], args[1], args[2], args[3]); \
+		break; \
+	default: \
+		rb_raise(rb_eArgError, "arg length:%d", num); \
+	} \
+	return Qnil; \
+}
+
+GLCOLOR_VFUNC(b)
+GLCOLOR_VFUNC(d)
+GLCOLOR_VFUNC(f)
+GLCOLOR_VFUNC(i)
+GLCOLOR_VFUNC(s)
+GLCOLOR_VFUNC(ub)
+GLCOLOR_VFUNC(ui)
+GLCOLOR_VFUNC(us)
+#undef GLCOLOR_VFUNC
+
+#define GLNORMAL_VFUNC(_type_) \
+static VALUE \
+gl_Normal##_type_##v(argc,argv,obj) \
+int argc; \
+VALUE *argv; \
+VALUE obj; \
+{ \
+	int num; \
+	VALUE args[3]; \
+	RArray* ary; \
+	switch (num = rb_scan_args(argc, argv, "12", &args[0], &args[1], &args[2])) { \
+	case 1: \
+		if (TYPE(args[0]) == T_ARRAY) { \
+		ary = RARRAY(args[0]); \
+		switch (ary->len) { \
+			case 3: \
+			gl_Normal3##_type_(obj,ary->ptr[0], ary->ptr[1],ary->ptr[2]); \
+			break; \
+			default: \
+			rb_raise(rb_eArgError, "array length:%d", ary->len); \
+		} \
+		} \
+		else \
+		rb_raise(rb_eTypeError, "type mismatch:%s", rb_class2name(CLASS_OF(args[0]))); \
+		break; \
+	case 3: \
+		gl_Normal3##_type_(obj,args[0], args[1], args[2]); \
+		break; \
+	default: \
+		rb_raise(rb_eArgError, "arg length:%d",num); \
+	} \
+	return Qnil; \
+}
+
+GLNORMAL_VFUNC(b)
+GLNORMAL_VFUNC(d)
+GLNORMAL_VFUNC(f)
+GLNORMAL_VFUNC(i)
+GLNORMAL_VFUNC(s)
+#undef GLNORMAL_VFUNC
+
+#define GLRASTERPOS_VFUNC(_type_) \
+static VALUE \
+gl_RasterPos##_type_##v(argc,argv,obj) \
+int argc; \
+VALUE *argv; \
+VALUE obj; \
+{ \
+	int num; \
+	VALUE args[4]; \
+	RArray *ary; \
+	switch (num = rb_scan_args(argc, argv, "13", &args[0], &args[1], &args[2], &args[3])) { \
+	case 1: \
+		if (TYPE(args[0]) == T_ARRAY) { \
+		ary = RARRAY(args[0]); \
+		switch (ary->len) { \
+			case 2: \
+			gl_RasterPos2##_type_(obj,ary->ptr[0],ary->ptr[1]); \
+			break; \
+			case 3: \
+			gl_RasterPos3##_type_(obj,ary->ptr[0],ary->ptr[1],ary->ptr[2]); \
+			break; \
+			case 4: \
+			gl_RasterPos4##_type_(obj,ary->ptr[0],ary->ptr[1],ary->ptr[2],ary->ptr[3]); \
+			break; \
+			default: \
+			rb_raise(rb_eArgError, "array length:%d", num); \
+		} \
+		} \
+		else \
+		rb_raise(rb_eTypeError, "type mismatch:%s", rb_class2name(CLASS_OF(args[0]))); \
+		break; \
+	case 2: \
+		gl_RasterPos2##_type_(obj,args[0], args[1]); \
+		break; \
+	case 3: \
+		gl_RasterPos3##_type_(obj,args[0], args[1], args[2]); \
+		break; \
+	case 4: \
+		gl_RasterPos4##_type_(obj,args[0], args[1], args[2], args[3]); \
+		break; \
+	default: \
+		rb_raise(rb_eArgError, "too many arguments"); \
+	} \
+	return Qnil; \
+}
+
+GLRASTERPOS_VFUNC(d)
+GLRASTERPOS_VFUNC(f)
+GLRASTERPOS_VFUNC(i)
+GLRASTERPOS_VFUNC(s)
+#undef GLRASTERPOS_VFUNC
+
+#define GLRECT_VFUNC(_type_) \
+static VALUE \
+gl_Rect##_type_##v(argc,argv,obj) \
+int argc; \
+VALUE *argv; \
+VALUE obj; \
+{ \
+	int num; \
+	VALUE args[4]; \
+	RArray *ary; \
+	switch (num = rb_scan_args(argc, argv, "13", &args[0], &args[1], &args[2], &args[3])) { \
+	case 1: \
+		if (TYPE(args[0]) == T_ARRAY) { \
+		ary = RARRAY(args[0]); \
+		switch (ary->len) { \
+			case 4: \
+			gl_Rect##_type_(obj,ary->ptr[0],ary->ptr[1],ary->ptr[2],ary->ptr[3]); \
+			break; \
+			default: \
+			rb_raise(rb_eArgError, "array length:%d", ary->len); \
+		} \
+		} \
+		else \
+			rb_raise(rb_eTypeError, "type mismatch:%s", rb_class2name(CLASS_OF(args[0]))); \
+		break; \
+	case 4: \
+		gl_Rect##_type_(obj,args[0], args[1], args[2], args[3]); \
+		break; \
+	default: \
+		rb_raise(rb_eArgError, "arg length:%d", num); \
+	} \
+	return Qnil; \
+}
+
+GLRECT_VFUNC(d)
+GLRECT_VFUNC(f)
+GLRECT_VFUNC(i)
+GLRECT_VFUNC(s)
+#undef GLRECT_VFUNC
+
+#define GLTEXCOORD_VFUNC(_type_) \
+static VALUE \
+gl_TexCoord##_type_##v(argc,argv,obj) \
+int argc; \
+VALUE *argv; \
+VALUE obj; \
+{ \
+	int num; \
+	VALUE args[4]; \
+	RArray *ary; \
+	switch (num = rb_scan_args(argc, argv, "13", &args[0], &args[1], &args[2], &args[3])) { \
+	case 1: \
+		if (TYPE(args[0]) == T_ARRAY) { \
+		ary = RARRAY(args[0]); \
+		switch (ary->len) { \
+			case 2: \
+			gl_TexCoord2##_type_(obj,ary->ptr[0],ary->ptr[1]); \
+			break; \
+			case 3: \
+			gl_TexCoord3##_type_(obj,ary->ptr[0],ary->ptr[1],ary->ptr[2]); \
+			break; \
+			case 4: \
+			gl_TexCoord4##_type_(obj,ary->ptr[0],ary->ptr[1],ary->ptr[2],ary->ptr[3]); \
+			break; \
+			default: \
+			rb_raise(rb_eArgError, "array length:%d", num); \
+		} \
+		} \
+		else \
+			rb_raise(rb_eTypeError, "type mismatch:%s", rb_class2name(CLASS_OF(args[0]))); \
+		break; \
+	case 2: \
+		gl_TexCoord2##_type_(obj,args[0], args[1]); \
+		break; \
+	case 3: \
+		gl_TexCoord3##_type_(obj,args[0], args[1], args[2]); \
+		break; \
+	case 4: \
+		gl_TexCoord4##_type_(obj,args[0], args[1], args[2], args[3]); \
+		break; \
+	default: \
+		rb_raise(rb_eArgError, "too many arguments"); \
+		break; \
+	} \
+	return Qnil; \
+}
+
+GLTEXCOORD_VFUNC(d)
+GLTEXCOORD_VFUNC(f)
+GLTEXCOORD_VFUNC(i)
+GLTEXCOORD_VFUNC(s)
+#undef GLTEXCOORD_VFUNC
+
+#define GLVERTEX_VFUNC(_type_) \
+static VALUE \
+gl_Vertex##_type_##v(argc,argv,obj) \
+int argc; \
+VALUE *argv; \
+VALUE obj; \
+{ \
+	VALUE args[4]; \
+	RArray *ary; \
+	switch (rb_scan_args(argc, argv, "13", &args[0], &args[1], &args[2], &args[3])) { \
+	case 1: \
+		if (TYPE(args[0]) == T_ARRAY) { \
+		ary = RARRAY(args[0]); \
+		switch (ary->len) { \
+			case 2: \
+			gl_Vertex2##_type_(obj,ary->ptr[0],ary->ptr[1]); \
+			break; \
+			case 3: \
+			gl_Vertex3##_type_(obj,ary->ptr[0],ary->ptr[1],ary->ptr[2]); \
+			break; \
+			case 4: \
+			gl_Vertex4##_type_(obj,ary->ptr[0],ary->ptr[1],ary->ptr[2],ary->ptr[3]); \
+			break; \
+			default: \
+			rb_raise(rb_eRuntimeError, "glVertex vertex num error!:%d", ary->len); \
+		} \
+		} \
+		else \
+			rb_raise(rb_eTypeError, "type mismatch:%s", rb_class2name(CLASS_OF(args[0]))); \
+		break; \
+	case 2: \
+		gl_Vertex2##_type_(obj,args[0], args[1]); \
+		break; \
+	case 3: \
+		gl_Vertex3##_type_(obj,args[0], args[1], args[2]); \
+		break; \
+	case 4: \
+		gl_Vertex4##_type_(obj,args[0], args[1], args[2], args[3]); \
+		break; \
+	default: \
+		rb_raise(rb_eArgError, "too many arguments"); \
+		break; \
+	} \
+	return Qnil; \
+}
+
+GLVERTEX_VFUNC(d)
+GLVERTEX_VFUNC(f)
+GLVERTEX_VFUNC(i)
+GLVERTEX_VFUNC(s)
+#undef GLVERTEX_VFUNC
+
+/* */
+
+static VALUE
+gl_LightModel(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	if (TYPE(arg2) == T_ARRAY)
+		gl_LightModelfv(obj,arg1,arg2);
+	else
+		gl_LightModelf(obj,arg1,arg2);
+
+	return Qnil; 
+}
+
+static VALUE
+gl_Material(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	if (TYPE(arg3) == T_ARRAY)
+		gl_Materialfv(obj,arg1,arg2,arg3);
+	else
+		gl_Materialf(obj,arg1,arg2,arg3);
+
+	return Qnil;
+}
+
+static VALUE
+gl_Fog(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	if (TYPE(arg2) == T_ARRAY)
+		gl_Fogfv(obj,arg1,arg2);
+	else
+		gl_Fogf(obj,arg1,arg2);
+
+	return Qnil; 
+}
+
+static VALUE
+gl_Light(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	if (TYPE(arg3) == T_ARRAY)
+		gl_Lightfv(obj,arg1,arg2,arg3);
+	else
+		gl_Lightf(obj,arg1,arg2,arg3);
+
+	return Qnil; 
+}
+
+static VALUE
+gl_TexParameter(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	if (TYPE(arg3) == T_ARRAY)
+		gl_TexParameterfv(obj,arg1,arg2,arg3);
+	else
+		gl_TexParameterf(obj,arg1,arg2,arg3);
+
+	return Qnil; 
+}
+
+static VALUE
+gl_TexEnv(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	if (TYPE(arg3) == T_ARRAY)
+		gl_TexEnvfv(obj,arg1,arg2,arg3);
+	else
+		gl_TexEnvf(obj,arg1,arg2,arg3);
+
+	return Qnil; 
+}
+
+static VALUE
+gl_TexGen(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	if (TYPE(arg3) == T_ARRAY)
+		gl_TexGenfv(obj,arg1,arg2,arg3);
+	else
+		gl_TexGenf(obj,arg1,arg2,arg3);
+
+	return Qnil; 
+}
+
+/* init */
+void gl_init_functions_1_0__1_1(VALUE module)
+{
+	/* OpenGL 1.0 functions */
+	rb_define_module_function(module, "glNewList", gl_NewList, 2);
+	rb_define_module_function(module, "glEndList", gl_EndList, 0);
+	rb_define_module_function(module, "glCallList", gl_CallList, 1);
+	rb_define_module_function(module, "glCallLists", gl_CallLists, 1);
+	rb_define_module_function(module, "glDeleteLists", gl_DeleteLists, 2);
+	rb_define_module_function(module, "glGenLists", gl_GenLists, 1);
+	rb_define_module_function(module, "glListBase", gl_ListBase, 1);
+	rb_define_module_function(module, "glBegin", gl_Begin, 1);
+	rb_define_module_function(module, "glBitmap", gl_Bitmap, 7);
+	rb_define_module_function(module, "glColor3b", gl_Color3b, 3);
+	rb_define_module_function(module, "glColor3d", gl_Color3d, 3);
+	rb_define_module_function(module, "glColor3f", gl_Color3f, 3);
+	rb_define_module_function(module, "glColor3i", gl_Color3i, 3);
+	rb_define_module_function(module, "glColor3s", gl_Color3s, 3);
+	rb_define_module_function(module, "glColor3ub", gl_Color3ub, 3);
+	rb_define_module_function(module, "glColor3ui", gl_Color3ui, 3);
+	rb_define_module_function(module, "glColor3us", gl_Color3us, 3);
+	rb_define_module_function(module, "glColor4b", gl_Color4b, 4);
+	rb_define_module_function(module, "glColor4d", gl_Color4d, 4);
+	rb_define_module_function(module, "glColor4f", gl_Color4f, 4);
+	rb_define_module_function(module, "glColor4i", gl_Color4i, 4);
+	rb_define_module_function(module, "glColor4s", gl_Color4s, 4);
+	rb_define_module_function(module, "glColor4ub", gl_Color4ub, 4);
+	rb_define_module_function(module, "glColor4ui", gl_Color4ui, 4);
+	rb_define_module_function(module, "glColor4us", gl_Color4us, 4);
+	rb_define_module_function(module, "glEdgeFlag", gl_EdgeFlag, 1);
+	rb_define_module_function(module, "glEdgeFlagv", gl_EdgeFlagv, 1);
+	rb_define_module_function(module, "glEnd", gl_End, 0);
+	rb_define_module_function(module, "glIndexd", gl_Indexd, 1);
+	rb_define_module_function(module, "glIndexdv", gl_Indexdv, 1);
+	rb_define_module_function(module, "glIndexf", gl_Indexf, 1);
+	rb_define_module_function(module, "glIndexfv", gl_Indexfv, 1);
+	rb_define_module_function(module, "glIndexi", gl_Indexi, 1);
+	rb_define_module_function(module, "glIndexiv", gl_Indexiv, 1);
+	rb_define_module_function(module, "glIndexs", gl_Indexs, 1);
+	rb_define_module_function(module, "glIndexsv", gl_Indexsv, 1);
+	rb_define_module_function(module, "glNormal3b", gl_Normal3b, 3);
+	rb_define_module_function(module, "glNormal3d", gl_Normal3d, 3);
+	rb_define_module_function(module, "glNormal3f", gl_Normal3f, 3);
+	rb_define_module_function(module, "glNormal3i", gl_Normal3i, 3);
+	rb_define_module_function(module, "glNormal3s", gl_Normal3s, 3);
+	rb_define_module_function(module, "glRasterPos2d", gl_RasterPos2d, 2);
+	rb_define_module_function(module, "glRasterPos2f", gl_RasterPos2f, 2);
+	rb_define_module_function(module, "glRasterPos2i", gl_RasterPos2i, 2);
+	rb_define_module_function(module, "glRasterPos2s", gl_RasterPos2s, 2);
+	rb_define_module_function(module, "glRasterPos3d", gl_RasterPos3d, 3);
+	rb_define_module_function(module, "glRasterPos3f", gl_RasterPos3f, 3);
+	rb_define_module_function(module, "glRasterPos3i", gl_RasterPos3i, 3);
+	rb_define_module_function(module, "glRasterPos3s", gl_RasterPos3s, 3);
+	rb_define_module_function(module, "glRasterPos4d", gl_RasterPos4d, 4);
+	rb_define_module_function(module, "glRasterPos4f", gl_RasterPos4f, 4);
+	rb_define_module_function(module, "glRasterPos4i", gl_RasterPos4i, 4);
+	rb_define_module_function(module, "glRasterPos4s", gl_RasterPos4s, 4);
+	rb_define_module_function(module, "glRectd", gl_Rectd, 4);
+	rb_define_module_function(module, "glRectf", gl_Rectf, 4);
+	rb_define_module_function(module, "glRecti", gl_Recti, 4);
+	rb_define_module_function(module, "glRects", gl_Rects, 4);
+	rb_define_module_function(module, "glTexCoord1d", gl_TexCoord1d, 1);
+	rb_define_module_function(module, "glTexCoord1f", gl_TexCoord1f, 1);
+	rb_define_module_function(module, "glTexCoord1i", gl_TexCoord1i, 1);
+	rb_define_module_function(module, "glTexCoord1s", gl_TexCoord1s, 1);
+	rb_define_module_function(module, "glTexCoord2d", gl_TexCoord2d, 2);
+	rb_define_module_function(module, "glTexCoord2f", gl_TexCoord2f, 2);
+	rb_define_module_function(module, "glTexCoord2i", gl_TexCoord2i, 2);
+	rb_define_module_function(module, "glTexCoord2s", gl_TexCoord2s, 2);
+	rb_define_module_function(module, "glTexCoord3d", gl_TexCoord3d, 3);
+	rb_define_module_function(module, "glTexCoord3f", gl_TexCoord3f, 3);
+	rb_define_module_function(module, "glTexCoord3i", gl_TexCoord3i, 3);
+	rb_define_module_function(module, "glTexCoord3s", gl_TexCoord3s, 3);
+	rb_define_module_function(module, "glTexCoord4d", gl_TexCoord4d, 4);
+	rb_define_module_function(module, "glTexCoord4f", gl_TexCoord4f, 4);
+	rb_define_module_function(module, "glTexCoord4i", gl_TexCoord4i, 4);
+	rb_define_module_function(module, "glTexCoord4s", gl_TexCoord4s, 4);
+	rb_define_module_function(module, "glVertex2d", gl_Vertex2d, 2);
+	rb_define_module_function(module, "glVertex2f", gl_Vertex2f, 2);
+	rb_define_module_function(module, "glVertex2i", gl_Vertex2i, 2);
+	rb_define_module_function(module, "glVertex2s", gl_Vertex2s, 2);
+	rb_define_module_function(module, "glVertex3d", gl_Vertex3d, 3);
+	rb_define_module_function(module, "glVertex3f", gl_Vertex3f, 3);
+	rb_define_module_function(module, "glVertex3i", gl_Vertex3i, 3);
+	rb_define_module_function(module, "glVertex3s", gl_Vertex3s, 3);
+	rb_define_module_function(module, "glVertex4d", gl_Vertex4d, 4);
+	rb_define_module_function(module, "glVertex4f", gl_Vertex4f, 4);
+	rb_define_module_function(module, "glVertex4i", gl_Vertex4i, 4);
+	rb_define_module_function(module, "glVertex4s", gl_Vertex4s, 4);
+	rb_define_module_function(module, "glClipPlane", gl_ClipPlane, 2);
+	rb_define_module_function(module, "glColorMaterial", gl_ColorMaterial, 2);
+	rb_define_module_function(module, "glCullFace", gl_CullFace, 1);
+	rb_define_module_function(module, "glFogf", gl_Fogf, 2);
+	rb_define_module_function(module, "glFogfv", gl_Fogfv, 2);
+	rb_define_module_function(module, "glFogi", gl_Fogi, 2);
+	rb_define_module_function(module, "glFogiv", gl_Fogiv, 2);
+	rb_define_module_function(module, "glFrontFace", gl_FrontFace, 1);
+	rb_define_module_function(module, "glHint", gl_Hint, 2);
+	rb_define_module_function(module, "glLightf", gl_Lightf, 3);
+	rb_define_module_function(module, "glLightfv", gl_Lightfv, 3);
+	rb_define_module_function(module, "glLighti", gl_Lighti, 3);
+	rb_define_module_function(module, "glLightiv", gl_Lightiv, 3);
+	rb_define_module_function(module, "glLightModelf", gl_LightModelf, 2);
+	rb_define_module_function(module, "glLightModelfv", gl_LightModelfv, 2);
+	rb_define_module_function(module, "glLightModeli", gl_LightModeli, 2);
+	rb_define_module_function(module, "glLightModeliv", gl_LightModeliv, 2);
+	rb_define_module_function(module, "glLineStipple", gl_LineStipple, 2);
+	rb_define_module_function(module, "glLineWidth", gl_LineWidth, 1);
+	rb_define_module_function(module, "glMaterialf", gl_Materialf, 3);
+	rb_define_module_function(module, "glMaterialfv", gl_Materialfv, 3);
+	rb_define_module_function(module, "glMateriali", gl_Materiali, 3);
+	rb_define_module_function(module, "glMaterialiv", gl_Materialiv, 3);
+	rb_define_module_function(module, "glPointSize", gl_PointSize, 1);
+	rb_define_module_function(module, "glPolygonMode", gl_PolygonMode, 2);
+	rb_define_module_function(module, "glPolygonStipple", gl_PolygonStipple, 1);
+	rb_define_module_function(module, "glScissor", gl_Scissor, 4);
+	rb_define_module_function(module, "glShadeModel", gl_ShadeModel, 1);
+	rb_define_module_function(module, "glTexParameterf", gl_TexParameterf, 3);
+	rb_define_module_function(module, "glTexParameterfv", gl_TexParameterfv, 3);
+	rb_define_module_function(module, "glTexParameteri", gl_TexParameteri, 3);
+	rb_define_module_function(module, "glTexParameteriv", gl_TexParameteriv, 3);
+	rb_define_module_function(module, "glTexImage1D", gl_TexImage1D, 8);
+	rb_define_module_function(module, "glTexImage2D", gl_TexImage2D, 9);
+	rb_define_module_function(module, "glTexEnvf", gl_TexEnvf, 3);
+	rb_define_module_function(module, "glTexEnvfv", gl_TexEnvfv, 3);
+	rb_define_module_function(module, "glTexEnvi", gl_TexEnvi, 3);
+	rb_define_module_function(module, "glTexEnviv", gl_TexEnviv, 3);
+	rb_define_module_function(module, "glTexGend", gl_TexGend, 3);
+	rb_define_module_function(module, "glTexGendv", gl_TexGendv, 3);
+	rb_define_module_function(module, "glTexGenf", gl_TexGenf, 3);
+	rb_define_module_function(module, "glTexGenfv", gl_TexGenfv, 3);
+	rb_define_module_function(module, "glTexGeni", gl_TexGeni, 3);
+	rb_define_module_function(module, "glTexGeniv", gl_TexGeniv, 3);
+	rb_define_module_function(module, "glFeedbackBuffer", gl_FeedbackBuffer, -1);
+	rb_define_module_function(module, "glSelectBuffer", gl_SelectBuffer, -1);
+	rb_define_module_function(module, "glRenderMode", gl_RenderMode, 1);
+	rb_define_module_function(module, "glInitNames", gl_InitNames, 0);
+	rb_define_module_function(module, "glLoadName", gl_LoadName, 1);
+	rb_define_module_function(module, "glPassThrough", gl_PassThrough, 1);
+	rb_define_module_function(module, "glPopName", gl_PopName, 0);
+	rb_define_module_function(module, "glPushName", gl_PushName, 1);
+	rb_define_module_function(module, "glDrawBuffer", gl_DrawBuffer, 1);
+	rb_define_module_function(module, "glClear", gl_Clear, 1);
+	rb_define_module_function(module, "glClearAccum", gl_ClearAccum, 4);
+	rb_define_module_function(module, "glClearIndex", gl_ClearIndex, 1);
+	rb_define_module_function(module, "glClearColor", gl_ClearColor, 4);
+	rb_define_module_function(module, "glClearStencil", gl_ClearStencil, 1);
+	rb_define_module_function(module, "glClearDepth", gl_ClearDepth, 1);
+	rb_define_module_function(module, "glStencilMask", gl_StencilMask, 1);
+	rb_define_module_function(module, "glColorMask", gl_ColorMask, 4);
+	rb_define_module_function(module, "glDepthMask", gl_DepthMask, 1);
+	rb_define_module_function(module, "glIndexMask", gl_IndexMask, 1);
+	rb_define_module_function(module, "glAccum", gl_Accum, 2);
+	rb_define_module_function(module, "glDisable", gl_Disable, 1);
+	rb_define_module_function(module, "glEnable", gl_Enable, 1);
+	rb_define_module_function(module, "glFinish", gl_Finish, 0);
+	rb_define_module_function(module, "glFlush", gl_Flush, 0);
+	rb_define_module_function(module, "glPopAttrib", gl_PopAttrib, 0);
+	rb_define_module_function(module, "glPushAttrib", gl_PushAttrib, 1);
+	rb_define_module_function(module, "glMap1d", gl_Map1d, 6);
+	rb_define_module_function(module, "glMap1f", gl_Map1f, 6);
+	rb_define_module_function(module, "glMap2d", gl_Map2d, 10);
+	rb_define_module_function(module, "glMap2f", gl_Map2f, 10);
+	rb_define_module_function(module, "glMapGrid1d", gl_MapGrid1d, 3);
+	rb_define_module_function(module, "glMapGrid1f", gl_MapGrid1f, 3);
+	rb_define_module_function(module, "glMapGrid2d", gl_MapGrid2d, 6);
+	rb_define_module_function(module, "glMapGrid2f", gl_MapGrid2f, 6);
+	rb_define_module_function(module, "glEvalCoord1d", gl_EvalCoord1d, 1);
+	rb_define_module_function(module, "glEvalCoord1dv", gl_EvalCoord1dv, 1);
+	rb_define_module_function(module, "glEvalCoord1f", gl_EvalCoord1f, 1);
+	rb_define_module_function(module, "glEvalCoord1fv", gl_EvalCoord1fv, 1);
+	rb_define_module_function(module, "glEvalCoord2d", gl_EvalCoord2d, 2);
+	rb_define_module_function(module, "glEvalCoord2dv", gl_EvalCoord2dv, 1);
+	rb_define_module_function(module, "glEvalCoord2f", gl_EvalCoord2f, 2);
+	rb_define_module_function(module, "glEvalCoord2fv", gl_EvalCoord2fv, 1);
+	rb_define_module_function(module, "glEvalMesh1", gl_EvalMesh1, 3);
+	rb_define_module_function(module, "glEvalPoint1", gl_EvalPoint1, 1);
+	rb_define_module_function(module, "glEvalMesh2", gl_EvalMesh2, 5);
+	rb_define_module_function(module, "glEvalPoint2", gl_EvalPoint2, 2);
+	rb_define_module_function(module, "glAlphaFunc", gl_AlphaFunc, 2);
+	rb_define_module_function(module, "glBlendFunc", gl_BlendFunc, 2);
+	rb_define_module_function(module, "glLogicOp", gl_LogicOp, 1);
+	rb_define_module_function(module, "glStencilFunc", gl_StencilFunc, 3);
+	rb_define_module_function(module, "glStencilOp", gl_StencilOp, 3);
+	rb_define_module_function(module, "glDepthFunc", gl_DepthFunc, 1);
+	rb_define_module_function(module, "glPixelZoom", gl_PixelZoom, 2);
+	rb_define_module_function(module, "glPixelTransferf", gl_PixelTransferf, 2);
+	rb_define_module_function(module, "glPixelTransferi", gl_PixelTransferi, 2);
+	rb_define_module_function(module, "glPixelStoref", gl_PixelStoref, 2);
+	rb_define_module_function(module, "glPixelStorei", gl_PixelStorei, 2);
+	rb_define_module_function(module, "glPixelMapfv", gl_PixelMapfv, 2);
+	rb_define_module_function(module, "glPixelMapuiv", gl_PixelMapuiv, 2);
+	rb_define_module_function(module, "glPixelMapusv", gl_PixelMapusv, 2);
+	rb_define_module_function(module, "glReadBuffer", gl_ReadBuffer, 1);
+	rb_define_module_function(module, "glCopyPixels", gl_CopyPixels, 5);
+	rb_define_module_function(module, "glReadPixels", gl_ReadPixels, 6);
+	rb_define_module_function(module, "glDrawPixels", gl_DrawPixels, 5);
+	rb_define_module_function(module, "glGetBooleanv", gl_GetBooleanv, 2);
+	rb_define_module_function(module, "glGetClipPlane", gl_GetClipPlane, 1);
+	rb_define_module_function(module, "glGetDoublev", gl_GetDoublev, 1);
+	rb_define_module_function(module, "glGetError", gl_GetError, 0);
+	rb_define_module_function(module, "glGetFloatv", gl_GetFloatv, 2);
+	rb_define_module_function(module, "glGetIntegerv", gl_GetIntegerv, 2);
+	rb_define_module_function(module, "glGetLightfv", gl_GetLightfv, 2);
+	rb_define_module_function(module, "glGetLightiv", gl_GetLightiv, 2);
+	rb_define_module_function(module, "glGetMapdv", gl_GetMapdv, 2);
+	rb_define_module_function(module, "glGetMapfv", gl_GetMapfv, 2); 
+	rb_define_module_function(module, "glGetMapiv", gl_GetMapiv, 2);
+	rb_define_module_function(module, "glGetMaterialfv", gl_GetMaterialfv, 2);
+	rb_define_module_function(module, "glGetMaterialiv", gl_GetMaterialiv, 2);
+	rb_define_module_function(module, "glGetPixelMapfv", gl_GetPixelMapfv, 1);
+	rb_define_module_function(module, "glGetPixelMapuiv", gl_GetPixelMapuiv, 1);
+	rb_define_module_function(module, "glGetPixelMapusv", gl_GetPixelMapusv, 1);
+	rb_define_module_function(module, "glGetPolygonStipple", gl_GetPolygonStipple, 1);
+	rb_define_module_function(module, "glGetString", gl_GetString, 1);
+	rb_define_module_function(module, "glGetTexEnvfv", gl_GetTexEnvfv, 2);
+	rb_define_module_function(module, "glGetTexEnviv", gl_GetTexEnviv, 2);
+	rb_define_module_function(module, "glGetTexGendv", gl_GetTexGendv, 2);
+	rb_define_module_function(module, "glGetTexGenfv", gl_GetTexGenfv, 2);
+	rb_define_module_function(module, "glGetTexGeniv", gl_GetTexGeniv, 2);
+/*	rb_define_module_function(module, "glGetTexImage", gl_GetTexImage, 5); */
+	rb_define_module_function(module, "glGetTexParameterfv", gl_GetTexParameterfv, 2);
+	rb_define_module_function(module, "glGetTexParameteriv", gl_GetTexParameteriv, 2);
+	rb_define_module_function(module, "glGetTexLevelParameterfv", gl_GetTexLevelParameterfv, 3);
+	rb_define_module_function(module, "glGetTexLevelParameteriv", gl_GetTexLevelParameteriv, 3);
+	rb_define_module_function(module, "glIsEnabled", gl_IsEnabled, 1);
+	rb_define_module_function(module, "glIsList", gl_IsList, 1);
+	rb_define_module_function(module, "glDepthRange", gl_DepthRange, 2);
+	rb_define_module_function(module, "glFrustum", gl_Frustum, 6);
+	rb_define_module_function(module, "glLoadIdentity", gl_LoadIdentity, 0);
+	rb_define_module_function(module, "glLoadMatrixf", gl_LoadMatrixf, 1);
+	rb_define_module_function(module, "glLoadMatrixd", gl_LoadMatrixd, 1);
+	rb_define_module_function(module, "glMatrixMode", gl_MatrixMode, 1);
+	rb_define_module_function(module, "glMultMatrixf", gl_MultMatrixf, 1);
+	rb_define_module_function(module, "glMultMatrixd", gl_MultMatrixd, 1);
+	rb_define_module_function(module, "glOrtho", gl_Ortho, 6);
+	rb_define_module_function(module, "glPopMatrix", gl_PopMatrix, 0);
+	rb_define_module_function(module, "glPushMatrix", gl_PushMatrix, 0);
+	rb_define_module_function(module, "glRotated", gl_Rotated, 4);
+	rb_define_module_function(module, "glRotatef", gl_Rotatef, 4);
+	rb_define_module_function(module, "glScaled", gl_Scaled, 3);
+	rb_define_module_function(module, "glScalef", gl_Scalef, 3);
+	rb_define_module_function(module, "glTranslated", gl_Translated, 3);
+	rb_define_module_function(module, "glTranslatef", gl_Translatef, 3);
+	rb_define_module_function(module, "glViewport", gl_Viewport, 4);
+
+	/* OpenGL 1.1 functions */
+	rb_define_module_function(module, "glArrayElement", gl_ArrayElement, 1);
+	rb_define_module_function(module, "glColorPointer", gl_ColorPointer, 4);
+	rb_define_module_function(module, "glDisableClientState", gl_DisableClientState, 1);
+	rb_define_module_function(module, "glDrawArrays", gl_DrawArrays, 3);
+	rb_define_module_function(module, "glDrawElements", gl_DrawElements, 4);
+	rb_define_module_function(module, "glEdgeFlagPointer", gl_EdgeFlagPointer, 2);
+	rb_define_module_function(module, "glEnableClientState", gl_EnableClientState, 1);
+	rb_define_module_function(module, "glGetPointerv", gl_GetPointerv, 2);
+	rb_define_module_function(module, "glIndexPointer", gl_IndexPointer, 3);
+	rb_define_module_function(module, "glInterleavedArrays", gl_InterleavedArrays, 3);
+	rb_define_module_function(module, "glNormalPointer", gl_NormalPointer, 3);
+	rb_define_module_function(module, "glTexCoordPointer", gl_TexCoordPointer, 4);
+	rb_define_module_function(module, "glVertexPointer", gl_VertexPointer, 4);
+	rb_define_module_function(module, "glPolygonOffset", gl_PolygonOffset, 2);
+	rb_define_module_function(module, "glCopyTexImage1D", gl_CopyTexImage1D, 7);
+	rb_define_module_function(module, "glCopyTexImage2D", gl_CopyTexImage2D, 8);
+	rb_define_module_function(module, "glCopyTexSubImage1D", gl_CopyTexSubImage1D, 6);
+	rb_define_module_function(module, "glCopyTexSubImage2D", gl_CopyTexSubImage2D, 8);
+	rb_define_module_function(module, "glTexSubImage1D", gl_TexSubImage1D, 7);
+	rb_define_module_function(module, "glTexSubImage2D", gl_TexSubImage2D, 9);
+	rb_define_module_function(module, "glAreTexturesResident", gl_AreTexturesResident, 1);
+	rb_define_module_function(module, "glBindTexture", gl_BindTexture, 2);
+	rb_define_module_function(module, "glDeleteTextures", gl_DeleteTextures, 1);
+	rb_define_module_function(module, "glGenTextures", gl_GenTextures, 1);
+	rb_define_module_function(module, "glIsTexture", gl_IsTexture, 1);
+	rb_define_module_function(module, "glPrioritizeTextures", gl_PrioritizeTextures, 2);
+	rb_define_module_function(module, "glIndexub", gl_Indexub, 1);
+	rb_define_module_function(module, "glIndexubv", gl_Indexubv, 1);
+	rb_define_module_function(module, "glPopClientAttrib", gl_PopClientAttrib, 0);
+	rb_define_module_function(module, "glPushClientAttrib", gl_PushClientAttrib, 1);
+	
+	/* additional functions */
+	rb_define_module_function(module, "glColor", gl_Colordv, -1);
+	rb_define_module_function(module, "glColor3bv", gl_Colorbv, -1);
+	rb_define_module_function(module, "glColor3dv", gl_Colordv, -1);
+	rb_define_module_function(module, "glColor3fv", gl_Colorfv, -1);
+	rb_define_module_function(module, "glColor3iv", gl_Coloriv, -1);
+	rb_define_module_function(module, "glColor3sv", gl_Colorsv, -1);
+	rb_define_module_function(module, "glColor3ubv", gl_Colorubv, -1);
+	rb_define_module_function(module, "glColor3uiv", gl_Coloruiv, -1);
+	rb_define_module_function(module, "glColor3usv", gl_Colorusv, -1);
+	rb_define_module_function(module, "glColor4bv", gl_Colorbv, -1);
+	rb_define_module_function(module, "glColor4dv", gl_Colordv, -1);
+	rb_define_module_function(module, "glColor4fv", gl_Colorfv, -1);
+	rb_define_module_function(module, "glColor4iv", gl_Coloriv, -1);
+	rb_define_module_function(module, "glColor4sv", gl_Colorsv, -1);
+	rb_define_module_function(module, "glColor4ubv", gl_Colorubv, -1);
+	rb_define_module_function(module, "glColor4uiv", gl_Coloruiv, -1);
+	rb_define_module_function(module, "glColor4usv", gl_Colorusv, -1);
+
+	rb_define_module_function(module, "glNormal", gl_Normaldv, -1);
+	rb_define_module_function(module, "glNormal3bv", gl_Normalbv, -1);
+	rb_define_module_function(module, "glNormal3dv", gl_Normaldv, -1);
+	rb_define_module_function(module, "glNormal3fv", gl_Normalfv, -1);
+	rb_define_module_function(module, "glNormal3iv", gl_Normaliv, -1);
+	rb_define_module_function(module, "glNormal3sv", gl_Normalsv, -1);
+
+	rb_define_module_function(module, "glRasterPos", gl_RasterPosdv, -1);
+	rb_define_module_function(module, "glRasterPos2d", gl_RasterPosdv, -1);
+	rb_define_module_function(module, "glRasterPos2f", gl_RasterPosfv, -1);
+	rb_define_module_function(module, "glRasterPos2i", gl_RasterPosiv, -1);
+	rb_define_module_function(module, "glRasterPos2s", gl_RasterPossv, -1);
+	rb_define_module_function(module, "glRasterPos3d", gl_RasterPosdv, -1);
+	rb_define_module_function(module, "glRasterPos3f", gl_RasterPosfv, -1);
+	rb_define_module_function(module, "glRasterPos3i", gl_RasterPosiv, -1);
+	rb_define_module_function(module, "glRasterPos3s", gl_RasterPossv, -1);
+	rb_define_module_function(module, "glRasterPos4d", gl_RasterPosdv, -1);
+	rb_define_module_function(module, "glRasterPos4f", gl_RasterPosfv, -1);
+	rb_define_module_function(module, "glRasterPos4i", gl_RasterPosiv, -1);
+	rb_define_module_function(module, "glRasterPos4s", gl_RasterPossv, -1);
+
+	rb_define_module_function(module, "glRect", gl_Rectdv, -1);
+	rb_define_module_function(module, "glRectdv", gl_Rectdv, -1);
+	rb_define_module_function(module, "glRectfv", gl_Rectfv, -1);
+	rb_define_module_function(module, "glRectiv", gl_Rectiv, -1);
+	rb_define_module_function(module, "glRectsv", gl_Rectsv, -1);
+
+	rb_define_module_function(module, "glTexCoord", gl_TexCoorddv, -1);
+	rb_define_module_function(module, "glTexCoord1dv", gl_TexCoorddv, -1);
+	rb_define_module_function(module, "glTexCoord1fv", gl_TexCoordfv, -1);
+	rb_define_module_function(module, "glTexCoord1iv", gl_TexCoordiv, -1);
+	rb_define_module_function(module, "glTexCoord1sv", gl_TexCoordsv, -1);
+	rb_define_module_function(module, "glTexCoord2dv", gl_TexCoorddv, -1);
+	rb_define_module_function(module, "glTexCoord2fv", gl_TexCoordfv, -1);
+	rb_define_module_function(module, "glTexCoord2iv", gl_TexCoordiv, -1);
+	rb_define_module_function(module, "glTexCoord2sv", gl_TexCoordsv, -1);
+	rb_define_module_function(module, "glTexCoord3dv", gl_TexCoorddv, -1);
+	rb_define_module_function(module, "glTexCoord3fv", gl_TexCoordfv, -1);
+	rb_define_module_function(module, "glTexCoord3iv", gl_TexCoordiv, -1);
+	rb_define_module_function(module, "glTexCoord3sv", gl_TexCoordsv, -1);
+	rb_define_module_function(module, "glTexCoord4dv", gl_TexCoorddv, -1);
+	rb_define_module_function(module, "glTexCoord4fv", gl_TexCoordfv, -1);
+	rb_define_module_function(module, "glTexCoord4iv", gl_TexCoordiv, -1);
+	rb_define_module_function(module, "glTexCoord4sv", gl_TexCoordsv, -1);
+
+	rb_define_module_function(module, "glVertex", gl_Vertexdv, -1);
+	rb_define_module_function(module, "glVertex2dv", gl_Vertexdv, -1);
+	rb_define_module_function(module, "glVertex2fv", gl_Vertexfv, -1);
+	rb_define_module_function(module, "glVertex2iv", gl_Vertexiv, -1);
+	rb_define_module_function(module, "glVertex2sv", gl_Vertexsv, -1);
+	rb_define_module_function(module, "glVertex3dv", gl_Vertexdv, -1);
+	rb_define_module_function(module, "glVertex3fv", gl_Vertexfv, -1);
+	rb_define_module_function(module, "glVertex3iv", gl_Vertexiv, -1);
+	rb_define_module_function(module, "glVertex3sv", gl_Vertexsv, -1);
+	rb_define_module_function(module, "glVertex4dv", gl_Vertexdv, -1);
+	rb_define_module_function(module, "glVertex4fv", gl_Vertexfv, -1);
+	rb_define_module_function(module, "glVertex4iv", gl_Vertexiv, -1);
+	rb_define_module_function(module, "glVertex4sv", gl_Vertexsv, -1);
+
+	/* these simply calls normal or vector (*v) function depending on
+	   if array or single value is passed to them */
+	rb_define_module_function(module, "glLightModel", gl_LightModel, 2);
+	rb_define_module_function(module, "glMaterial", gl_Material, 3);
+	rb_define_module_function(module, "glFog", gl_Fog, 2);
+	rb_define_module_function(module, "glLight", gl_Light, 3);
+	rb_define_module_function(module, "glTexParameter", gl_TexParameter, 3);
+	rb_define_module_function(module, "glTexEnv", gl_TexEnv, 3);
+	rb_define_module_function(module, "glTexGen", gl_TexGen, 3);
+
+	/* aliases */
+	rb_define_module_function(module, "glMultMatrix", gl_MultMatrixd, 1);
+	rb_define_module_function(module, "glLoadMatrix", gl_LoadMatrixd, 1);
+	rb_define_module_function(module, "glRotate", gl_Rotated, 4);
+	rb_define_module_function(module, "glScale", gl_Scaled, 3);
+	rb_define_module_function(module, "glTranslate", gl_Translated, 3);
+
+	rb_define_module_function(module, "glPixelStore", gl_PixelStoref, 2);
+	rb_define_module_function(module, "glPixelTransfer", gl_PixelTransferf, 2);
+	rb_define_module_function(module, "glIndex", gl_Indexi, 1);
+	rb_define_module_function(module, "glGetMaterial", gl_GetMaterialfv, 2);
+	rb_define_module_function(module, "glGetDouble", gl_GetDoublev, 1);
+
+	rb_global_variable(&g_current_sel_buffer);
+	rb_global_variable(&g_current_feed_buffer);
+	rb_global_variable(&g_Vertex_ptr);
+	rb_global_variable(&g_Normal_ptr);
+	rb_global_variable(&g_Color_ptr);
+	rb_global_variable(&g_Index_ptr);
+	rb_global_variable(&g_TexCoord_ptr);
+	rb_global_variable(&g_EdgeFlag_ptr);
+	rb_global_variable(&g_FogCoord_ptr);
+	rb_global_variable(&g_SecondaryColor_ptr);
+}