ruby-opengl 0.33.0 → 0.40.0

data/ext/gl/gl-1.3.c

@@ -0,0 +1,725 @@
+/*
+ * Copyright (C) 2007 Jan Dvorak <jan.dvorak@kraxnet.cz>
+ *
+ * This program is distributed under the terms of the MIT license.
+ * See the included MIT-LICENSE file for the terms of this license.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifdef __APPLE__
+#include <OpenGL/gl.h>
+#elif defined WIN32
+#include <windows.h>
+#include <GL/gl.h>
+#else
+#include <GL/gl.h>
+#endif
+#include "../common/common.h"
+
+/* OpenGL 1.3 functions */
+
+static void (APIENTRY * fptr_glActiveTexture)(GLenum);
+static VALUE
+gl_ActiveTexture(obj,arg1)
+VALUE obj,arg1;
+{
+	GLenum texture;
+	LOAD_GL_FUNC(glActiveTexture)
+	texture = (GLenum)NUM2INT(arg1);
+	fptr_glActiveTexture(texture);
+	return Qnil;
+}
+
+static void (APIENTRY * fptr_glClientActiveTexture)(GLenum);
+static VALUE
+gl_ClientActiveTexture(obj,arg1)
+VALUE obj,arg1;
+{
+	GLenum texture;
+	LOAD_GL_FUNC(glClientActiveTexture)
+	texture = (GLenum)NUM2INT(arg1);
+	fptr_glClientActiveTexture(texture);
+	return Qnil;
+}
+
+static void (APIENTRY * fptr_glMultiTexCoord1d)(GLenum,GLdouble);
+static VALUE
+gl_MultiTexCoord1d(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLenum target;
+	GLdouble s;
+	LOAD_GL_FUNC(glMultiTexCoord1d)
+	target = (GLenum)NUM2INT(arg1);
+	s = (GLdouble)NUM2DBL(arg2);
+	fptr_glMultiTexCoord1d(target,s);
+	return Qnil;
+}
+
+static void (APIENTRY * fptr_glMultiTexCoord1f)(GLenum,GLfloat);
+static VALUE
+gl_MultiTexCoord1f(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLenum target;
+	GLfloat s;
+	LOAD_GL_FUNC(glMultiTexCoord1f)
+	target = (GLenum)NUM2INT(arg1);
+	s = (GLfloat)NUM2DBL(arg2);
+	fptr_glMultiTexCoord1f(target,s);
+	return Qnil;
+}
+
+static void (APIENTRY * fptr_glMultiTexCoord1i)(GLenum,GLint);
+static VALUE
+gl_MultiTexCoord1i(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLenum target;
+	GLint s;
+	LOAD_GL_FUNC(glMultiTexCoord1i)
+	target = (GLenum)NUM2INT(arg1);
+	s = (GLint)NUM2INT(arg2);
+	fptr_glMultiTexCoord1i(target,s);
+	return Qnil;
+}
+
+static void (APIENTRY * fptr_glMultiTexCoord1s)(GLenum,GLshort);
+static VALUE
+gl_MultiTexCoord1s(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLenum target;
+	GLshort s;
+	LOAD_GL_FUNC(glMultiTexCoord1s)
+	target = (GLenum)NUM2INT(arg1);
+	s = (GLshort)NUM2INT(arg2);
+	fptr_glMultiTexCoord1s(target,s);
+	return Qnil;
+}
+
+static void (APIENTRY * fptr_glMultiTexCoord2d)(GLenum,GLdouble,GLdouble);
+static VALUE
+gl_MultiTexCoord2d(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLenum target;
+	GLdouble s;
+	GLdouble t;
+	LOAD_GL_FUNC(glMultiTexCoord2d)
+	target = (GLenum)NUM2INT(arg1);
+	s = (GLdouble)NUM2DBL(arg2);
+	t = (GLdouble)NUM2DBL(arg3);
+	fptr_glMultiTexCoord2d(target,s,t);
+	return Qnil;
+}
+
+static void (APIENTRY * fptr_glMultiTexCoord2f)(GLenum,GLfloat,GLfloat);
+static VALUE
+gl_MultiTexCoord2f(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLenum target;
+	GLfloat s;
+	GLfloat t;
+	LOAD_GL_FUNC(glMultiTexCoord2f)
+	target = (GLenum)NUM2INT(arg1);
+	s = (GLfloat)NUM2DBL(arg2);
+	t = (GLfloat)NUM2DBL(arg3);
+	fptr_glMultiTexCoord2f(target,s,t);
+	return Qnil;
+}
+
+static void (APIENTRY * fptr_glMultiTexCoord2i)(GLenum,GLint,GLint);
+static VALUE
+gl_MultiTexCoord2i(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLenum target;
+	GLint s;
+	GLint t;
+	LOAD_GL_FUNC(glMultiTexCoord2i)
+	target = (GLenum)NUM2INT(arg1);
+	s = (GLint)NUM2INT(arg2);
+	t = (GLint)NUM2INT(arg3);
+	fptr_glMultiTexCoord2i(target,s,t);
+	return Qnil;
+}
+
+static void (APIENTRY * fptr_glMultiTexCoord2s)(GLenum,GLshort,GLshort);
+static VALUE
+gl_MultiTexCoord2s(obj,arg1,arg2,arg3)
+VALUE obj,arg1,arg2,arg3;
+{
+	GLenum target;
+	GLshort s;
+	GLshort t;
+	LOAD_GL_FUNC(glMultiTexCoord2s)
+	target = (GLenum)NUM2INT(arg1);
+	s = (GLshort)NUM2INT(arg2);
+	t = (GLshort)NUM2INT(arg3);
+	fptr_glMultiTexCoord2s(target,s,t);
+	return Qnil;
+}
+
+static void (APIENTRY * fptr_glMultiTexCoord3d)(GLenum,GLdouble,GLdouble,GLdouble);
+static VALUE
+gl_MultiTexCoord3d(obj,arg1,arg2,arg3,arg4)
+VALUE obj,arg1,arg2,arg3,arg4;
+{
+	GLenum target;
+	GLdouble s;
+	GLdouble t;
+	GLdouble r;
+	LOAD_GL_FUNC(glMultiTexCoord3d)
+	target = (GLenum)NUM2INT(arg1);
+	s = (GLdouble)NUM2DBL(arg2);
+	t = (GLdouble)NUM2DBL(arg3);
+	r = (GLdouble)NUM2DBL(arg4);
+	fptr_glMultiTexCoord3d(target,s,t,r);
+	return Qnil;
+}
+
+static void (APIENTRY * fptr_glMultiTexCoord3f)(GLenum,GLfloat,GLfloat,GLfloat);
+static VALUE
+gl_MultiTexCoord3f(obj,arg1,arg2,arg3,arg4)
+VALUE obj,arg1,arg2,arg3,arg4;
+{
+	GLenum target;
+	GLfloat s;
+	GLfloat t;
+	GLfloat r;
+	LOAD_GL_FUNC(glMultiTexCoord3f)
+	target = (GLenum)NUM2INT(arg1);
+	s = (GLfloat)NUM2DBL(arg2);
+	t = (GLfloat)NUM2DBL(arg3);
+	r = (GLfloat)NUM2DBL(arg4);
+	fptr_glMultiTexCoord3f(target,s,t,r);
+	return Qnil;
+}
+
+static void (APIENTRY * fptr_glMultiTexCoord3i)(GLenum,GLint,GLint,GLint);
+static VALUE
+gl_MultiTexCoord3i(obj,arg1,arg2,arg3,arg4)
+VALUE obj,arg1,arg2,arg3,arg4;
+{
+	GLenum target;
+	GLint s;
+	GLint t;
+	GLint r;
+	LOAD_GL_FUNC(glMultiTexCoord3i)
+	target = (GLenum)NUM2INT(arg1);
+	s = (GLint)NUM2INT(arg2);
+	t = (GLint)NUM2INT(arg3);
+	r = (GLint)NUM2INT(arg4);
+	fptr_glMultiTexCoord3i(target,s,t,r);
+	return Qnil;
+}
+
+static void (APIENTRY * fptr_glMultiTexCoord3s)(GLenum,GLshort,GLshort,GLshort);
+static VALUE
+gl_MultiTexCoord3s(obj,arg1,arg2,arg3,arg4)
+VALUE obj,arg1,arg2,arg3,arg4;
+{
+	GLenum target;
+	GLshort s;
+	GLshort t;
+	GLshort r;
+	LOAD_GL_FUNC(glMultiTexCoord3s)
+	target = (GLenum)NUM2INT(arg1);
+	s = (GLshort)NUM2INT(arg2);
+	t = (GLshort)NUM2INT(arg3);
+	r = (GLshort)NUM2INT(arg4);
+	fptr_glMultiTexCoord3s(target,s,t,r);
+	return Qnil;
+}
+
+static void (APIENTRY * fptr_glMultiTexCoord4d)(GLenum,GLdouble,GLdouble,GLdouble,GLdouble);
+static VALUE
+gl_MultiTexCoord4d(obj,arg1,arg2,arg3,arg4,arg5)
+VALUE obj,arg1,arg2,arg3,arg4,arg5;
+{
+	GLenum target;
+	GLdouble s;
+	GLdouble t;
+	GLdouble r;
+	GLdouble q;
+	LOAD_GL_FUNC(glMultiTexCoord4d)
+	target = (GLenum)NUM2INT(arg1);
+	s = (GLdouble)NUM2DBL(arg2);
+	t = (GLdouble)NUM2DBL(arg3);
+	r = (GLdouble)NUM2DBL(arg4);
+	q = (GLdouble)NUM2DBL(arg5);
+	fptr_glMultiTexCoord4d(target,s,t,r,q);
+	return Qnil;
+}
+
+static void (APIENTRY * fptr_glMultiTexCoord4f)(GLenum,GLfloat,GLfloat,GLfloat,GLfloat);
+static VALUE
+gl_MultiTexCoord4f(obj,arg1,arg2,arg3,arg4,arg5)
+VALUE obj,arg1,arg2,arg3,arg4,arg5;
+{
+	GLenum target;
+	GLfloat s;
+	GLfloat t;
+	GLfloat r;
+	GLfloat q;
+	LOAD_GL_FUNC(glMultiTexCoord4f)
+	target = (GLenum)NUM2INT(arg1);
+	s = (GLfloat)NUM2DBL(arg2);
+	t = (GLfloat)NUM2DBL(arg3);
+	r = (GLfloat)NUM2DBL(arg4);
+	q = (GLfloat)NUM2DBL(arg5);
+	fptr_glMultiTexCoord4f(target,s,t,r,q);
+	return Qnil;
+}
+
+static void (APIENTRY * fptr_glMultiTexCoord4i)(GLenum,GLint,GLint,GLint,GLint);
+static VALUE
+gl_MultiTexCoord4i(obj,arg1,arg2,arg3,arg4,arg5)
+VALUE obj,arg1,arg2,arg3,arg4,arg5;
+{
+	GLenum target;
+	GLint s;
+	GLint t;
+	GLint r;
+	GLint q;
+	LOAD_GL_FUNC(glMultiTexCoord4i)
+	target = (GLenum)NUM2INT(arg1);
+	s = (GLint)NUM2INT(arg2);
+	t = (GLint)NUM2INT(arg3);
+	r = (GLint)NUM2INT(arg4);
+	q = (GLint)NUM2INT(arg5);
+	fptr_glMultiTexCoord4i(target,s,t,r,q);
+	return Qnil;
+}
+
+static void (APIENTRY * fptr_glMultiTexCoord4s)(GLenum,GLshort,GLshort,GLshort,GLshort);
+static VALUE
+gl_MultiTexCoord4s(obj,arg1,arg2,arg3,arg4,arg5)
+VALUE obj,arg1,arg2,arg3,arg4,arg5;
+{
+	GLenum target;
+	GLshort s;
+	GLshort t;
+	GLshort r;
+	GLshort q;
+	LOAD_GL_FUNC(glMultiTexCoord4s)
+	target = (GLenum)NUM2INT(arg1);
+	s = (GLshort)NUM2INT(arg2);
+	t = (GLshort)NUM2INT(arg3);
+	r = (GLshort)NUM2INT(arg4);
+	q = (GLshort)NUM2INT(arg5);
+	fptr_glMultiTexCoord4s(target,s,t,r,q);
+	return Qnil;
+}
+
+#define GLMULTITEXCOORD_VFUNC(_type_) \
+static VALUE \
+gl_MultiTexCoord##_type_##v(argc,argv,obj) \
+int argc; \
+VALUE *argv; \
+VALUE obj; \
+{ \
+	int num; \
+	VALUE args[5]; \
+	RArray *ary; \
+	switch (num = rb_scan_args(argc, argv, "23", &args[0], &args[1], &args[2], &args[3],&args[4])) { \
+	case 2: \
+		if (TYPE(args[1]) == T_ARRAY) { \
+		ary = RARRAY(args[1]); \
+		switch (ary->len) { \
+			case 1: \
+			gl_MultiTexCoord1##_type_(obj,args[0],ary->ptr[0]); \
+			break; \
+			case 2: \
+			gl_MultiTexCoord2##_type_(obj,args[0],ary->ptr[0],ary->ptr[1]); \
+			break; \
+			case 3: \
+			gl_MultiTexCoord3##_type_(obj,args[0],ary->ptr[0],ary->ptr[1],ary->ptr[2]); \
+			break; \
+			case 4: \
+			gl_MultiTexCoord4##_type_(obj,args[0],ary->ptr[0],ary->ptr[1],ary->ptr[2],ary->ptr[3]); \
+			break; \
+			default: \
+			rb_raise(rb_eArgError, "array length:%d", num); \
+		} \
+		} \
+		else {	\
+			gl_MultiTexCoord1##_type_(obj,args[0], args[1]); \
+			break; \
+		} \
+		break; \
+	case 3: \
+		gl_MultiTexCoord2##_type_(obj,args[0], args[1], args[2]); \
+		break; \
+	case 4: \
+		gl_MultiTexCoord3##_type_(obj,args[0], args[1], args[2], args[3]); \
+		break; \
+	case 5: \
+		gl_MultiTexCoord4##_type_(obj,args[0], args[1], args[2], args[3], args[4]); \
+		break; \
+	default: \
+		rb_raise(rb_eArgError, "too many arguments"); \
+		break; \
+	} \
+	return Qnil; \
+}
+
+GLMULTITEXCOORD_VFUNC(d)
+GLMULTITEXCOORD_VFUNC(f)
+GLMULTITEXCOORD_VFUNC(i)
+GLMULTITEXCOORD_VFUNC(s)
+#undef GLTEXCOORD_VFUNC
+
+
+static void (APIENTRY * fptr_glLoadTransposeMatrixf)(const GLfloat[]);
+static VALUE
+gl_LoadTransposeMatrixf(obj,arg1)
+VALUE obj,arg1;
+{
+	GLfloat m[4*4];
+	LOAD_GL_FUNC(glLoadTransposeMatrixf)
+	ary2cmat4x4flt(arg1, m);
+	fptr_glLoadTransposeMatrixf(m);
+	return Qnil;
+}
+
+static void (APIENTRY * fptr_glLoadTransposeMatrixd)(const GLdouble[]);
+static VALUE
+gl_LoadTransposeMatrixd(obj,arg1)
+VALUE obj,arg1;
+{
+	GLdouble m[4*4];
+	LOAD_GL_FUNC(glLoadTransposeMatrixd)
+	ary2cmat4x4dbl(arg1, m);
+	fptr_glLoadTransposeMatrixd(m);
+	return Qnil;
+}
+
+static void (APIENTRY * fptr_glMultTransposeMatrixf)(const GLfloat[]);
+static VALUE
+gl_MultTransposeMatrixf(obj,arg1)
+VALUE obj,arg1;
+{
+	GLfloat m[4*4];
+	LOAD_GL_FUNC(glMultTransposeMatrixf)
+	ary2cmat4x4flt(arg1, m);
+	fptr_glMultTransposeMatrixf(m);
+	return Qnil;
+}
+
+static void (APIENTRY * fptr_glMultTransposeMatrixd)(const GLdouble[]);
+static VALUE
+gl_MultTransposeMatrixd(obj,arg1)
+VALUE obj,arg1;
+{
+	GLdouble m[4*4];
+	LOAD_GL_FUNC(glMultTransposeMatrixd)
+	ary2cmat4x4dbl(arg1, m);
+	fptr_glMultTransposeMatrixd(m);
+	return Qnil;
+}
+
+static void (APIENTRY * fptr_glSampleCoverage)(GLclampf,GLboolean);
+static VALUE
+gl_SampleCoverage(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLclampf value;
+	GLboolean invert;
+	LOAD_GL_FUNC(glSampleCoverage)
+	value = (GLclampf)NUM2DBL(arg1);
+	invert = (GLboolean)NUM2INT(arg2);
+	fptr_glSampleCoverage(value,invert);
+	return Qnil;
+}
+
+static void (APIENTRY * fptr_glCompressedTexImage3D)(GLenum,GLint,GLenum,GLsizei,GLsizei,GLsizei,GLint,GLsizei,GLvoid*);
+static VALUE
+gl_CompressedTexImage3D(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;
+	GLenum internalformat;
+	GLsizei width;
+	GLsizei height;
+	GLsizei depth;
+	GLint border;
+	GLsizei imagesize;
+	GLvoid *pixels;
+	LOAD_GL_FUNC(glCompressedTexImage3D)
+	target = (GLenum)NUM2INT(arg1);
+	level = (GLint)NUM2INT(arg2);
+	internalformat = (GLenum)NUM2INT(arg3);
+	width = (GLsizei)NUM2UINT(arg4);
+	height = (GLsizei)NUM2UINT(arg5);
+	depth = (GLsizei)NUM2UINT(arg6);
+	border = (GLint)NUM2INT(arg7);
+	imagesize = (GLsizei)NUM2UINT(arg8);
+	if (TYPE(arg9) == T_STRING) {
+		if (RSTRING(arg9)->len < imagesize)
+			rb_raise(rb_eArgError, "string length:%d",RSTRING(arg9)->len);
+		pixels = RSTRING(arg9)->ptr;
+	} else if (NIL_P(arg9)) {
+		pixels = NULL;
+	} else {
+		Check_Type(arg9,T_STRING); /* force exception */
+		return Qnil;
+	}
+	fptr_glCompressedTexImage3D(target,level,internalformat,width,height,depth,border,imagesize,pixels);
+	return Qnil;
+}
+
+static void (APIENTRY * fptr_glCompressedTexImage2D)(GLenum,GLint,GLenum,GLsizei,GLsizei,GLint,GLsizei,GLvoid*);
+static VALUE
+gl_CompressedTexImage2D(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;
+	GLsizei width;
+	GLsizei height;
+	GLint border;
+	GLsizei imagesize;
+	GLvoid *pixels;
+	LOAD_GL_FUNC(glCompressedTexImage2D)
+	target = (GLenum)NUM2INT(arg1);
+	level = (GLint)NUM2INT(arg2);
+	internalformat = (GLenum)NUM2INT(arg3);
+	width = (GLsizei)NUM2UINT(arg4);
+	height = (GLsizei)NUM2UINT(arg5);
+	border = (GLint)NUM2INT(arg6);
+	imagesize = (GLsizei)NUM2UINT(arg7);
+	if (TYPE(arg8) == T_STRING) {
+		if (RSTRING(arg8)->len < imagesize)
+			rb_raise(rb_eArgError, "string length:%d",RSTRING(arg8)->len);
+		pixels = RSTRING(arg8)->ptr;
+	} else if (NIL_P(arg8)) {
+		pixels = NULL;
+	} else {
+		Check_Type(arg8,T_STRING); /* force exception */
+		return Qnil;
+	}
+	fptr_glCompressedTexImage2D(target,level,internalformat,width,height,border,imagesize,pixels);
+	return Qnil;
+}
+
+static void (APIENTRY * fptr_glCompressedTexImage1D)(GLenum,GLint,GLenum,GLsizei,GLint,GLsizei,GLvoid*);
+static VALUE
+gl_CompressedTexImage1D(obj,arg1,arg2,arg3,arg4,arg5,arg6,arg7)
+VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6,arg7;
+{
+	GLenum target;
+	GLint level;
+	GLenum internalformat;
+	GLsizei width;
+	GLint border;
+	GLsizei imagesize;
+	GLvoid *pixels;
+	LOAD_GL_FUNC(glCompressedTexImage1D)
+	target = (GLenum)NUM2INT(arg1);
+	level = (GLint)NUM2INT(arg2);
+	internalformat = (GLenum)NUM2INT(arg3);
+	width = (GLsizei)NUM2UINT(arg4);
+	border = (GLint)NUM2INT(arg5);
+	imagesize = (GLsizei)NUM2UINT(arg6);
+	if (TYPE(arg7) == T_STRING) {
+		if (RSTRING(arg7)->len < imagesize)
+			rb_raise(rb_eArgError, "string length:%d",RSTRING(arg7)->len);
+		pixels = RSTRING(arg7)->ptr;
+	} else if (NIL_P(arg7)) {
+		pixels = NULL;
+	} else {
+		Check_Type(arg7,T_STRING); /* force exception */
+		return Qnil;
+	}
+	fptr_glCompressedTexImage1D(target,level,internalformat,width,border,imagesize,pixels);
+	return Qnil;
+}
+
+static void (APIENTRY * fptr_glCompressedTexSubImage3D)(GLenum,GLint,GLint,GLint,GLint,GLsizei,GLsizei,GLsizei,GLenum,GLsizei,GLvoid*);
+static VALUE
+gl_CompressedTexSubImage3D(obj,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11)
+VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11;
+{
+	GLenum target;
+	GLint level;
+	GLint xoffset;
+	GLint yoffset;
+	GLint zoffset;
+	GLsizei width;
+	GLsizei height;
+	GLsizei depth;
+	GLenum format;
+	GLsizei imagesize;
+	GLvoid *pixels;
+	LOAD_GL_FUNC(glCompressedTexSubImage3D)
+	target = (GLenum)NUM2INT(arg1);
+	level = (GLint)NUM2INT(arg2);
+	xoffset = (GLint)NUM2INT(arg3);
+	yoffset = (GLint)NUM2INT(arg4);
+	zoffset = (GLint)NUM2INT(arg5);
+	width = (GLsizei)NUM2UINT(arg6);
+	height = (GLsizei)NUM2UINT(arg7);
+	depth = (GLsizei)NUM2UINT(arg8);
+	format = (GLenum)NUM2INT(arg9);
+	imagesize = (GLsizei)NUM2UINT(arg10);
+	if (TYPE(arg11) == T_STRING) {
+		if (RSTRING(arg11)->len < imagesize)
+			rb_raise(rb_eArgError, "string length:%d",RSTRING(arg11)->len);
+		 pixels = RSTRING(arg11)->ptr;
+	} else {
+		Check_Type(arg11,T_STRING); /* force exception */
+		return Qnil;
+	}
+	fptr_glCompressedTexSubImage3D(target,level,xoffset,yoffset,zoffset,width,height,depth,format,imagesize,pixels);
+	return Qnil;
+}
+
+static void (APIENTRY * fptr_glCompressedTexSubImage2D)(GLenum,GLint,GLint,GLint,GLsizei,GLsizei,GLenum,GLsizei,GLvoid*);
+static VALUE
+gl_CompressedTexSubImage2D(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;
+	GLsizei imagesize;
+	GLvoid *pixels;
+	LOAD_GL_FUNC(glCompressedTexSubImage2D)
+	target = (GLenum)NUM2INT(arg1);
+	level = (GLint)NUM2INT(arg2);
+	xoffset = (GLint)NUM2INT(arg3);
+	yoffset = (GLint)NUM2INT(arg4);
+	width = (GLsizei)NUM2UINT(arg5);
+	height = (GLsizei)NUM2UINT(arg6);
+	format = (GLenum)NUM2INT(arg7);
+	imagesize = (GLsizei)NUM2UINT(arg8);
+	if (TYPE(arg9) == T_STRING) {
+		if (RSTRING(arg9)->len < imagesize)
+			rb_raise(rb_eArgError, "string length:%d",RSTRING(arg9)->len);
+		 pixels = RSTRING(arg9)->ptr;
+	} else {
+		Check_Type(arg9,T_STRING); /* force exception */
+		return Qnil;
+	}
+	fptr_glCompressedTexSubImage2D(target,level,xoffset,yoffset,width,height,format,imagesize,pixels);
+	return Qnil;
+}
+
+static void (APIENTRY * fptr_glCompressedTexSubImage1D)(GLenum,GLint,GLint,GLsizei,GLenum,GLsizei,GLvoid*);
+static VALUE
+gl_CompressedTexSubImage1D(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;
+	GLsizei imagesize;
+	GLvoid *pixels;
+	LOAD_GL_FUNC(glCompressedTexSubImage1D)
+	target = (GLenum)NUM2INT(arg1);
+	level = (GLint)NUM2INT(arg2);
+	xoffset = (GLint)NUM2INT(arg3);
+	width = (GLsizei)NUM2UINT(arg4);
+	format = (GLenum)NUM2INT(arg5);
+	imagesize = (GLsizei)NUM2UINT(arg6);
+	if (TYPE(arg7) == T_STRING) {
+		if (RSTRING(arg7)->len < imagesize)
+			rb_raise(rb_eArgError, "string length:%d",RSTRING(arg7)->len);
+		 pixels = RSTRING(arg7)->ptr;
+	} else {
+		Check_Type(arg7,T_STRING); /* force exception */
+		return Qnil;
+	}
+	fptr_glCompressedTexSubImage1D(target,level,xoffset,width,format,imagesize,pixels);
+	return Qnil;
+}
+
+static void (APIENTRY * fptr_glGetCompressedTexImage)(GLenum,GLint,GLvoid*);
+static VALUE
+gl_GetCompressedTexImage(obj,arg1,arg2)
+VALUE obj,arg1,arg2;
+{
+	GLenum target;
+	GLint lod;
+	GLsizei size = 0;
+	VALUE data;
+	LOAD_GL_FUNC(glGetCompressedTexImage)
+	target = (GLenum)NUM2INT(arg1);
+	lod = (GLenum)NUM2INT(arg2);
+	glGetTexLevelParameteriv(target,lod,GL_TEXTURE_COMPRESSED_IMAGE_SIZE,&size); /* 1.0 function */
+	data = allocate_buffer_with_string(size);
+	fptr_glGetCompressedTexImage(target,lod,(GLvoid*)RSTRING(data)->ptr);
+	return data;
+}
+
+void gl_init_functions_1_3(VALUE module)
+{
+	rb_define_module_function(module, "glActiveTexture", gl_ActiveTexture, 1);
+	rb_define_module_function(module, "glClientActiveTexture", gl_ClientActiveTexture, 1);
+	rb_define_module_function(module, "glMultiTexCoord1d", gl_MultiTexCoord1d, 2);
+	rb_define_module_function(module, "glMultiTexCoord1f", gl_MultiTexCoord1f, 2);
+	rb_define_module_function(module, "glMultiTexCoord1i", gl_MultiTexCoord1i, 2);
+	rb_define_module_function(module, "glMultiTexCoord1s", gl_MultiTexCoord1s, 2);
+	rb_define_module_function(module, "glMultiTexCoord2d", gl_MultiTexCoord2d, 3);
+	rb_define_module_function(module, "glMultiTexCoord2f", gl_MultiTexCoord2f, 3);
+	rb_define_module_function(module, "glMultiTexCoord2i", gl_MultiTexCoord2i, 3);
+	rb_define_module_function(module, "glMultiTexCoord2s", gl_MultiTexCoord2s, 3);
+	rb_define_module_function(module, "glMultiTexCoord3d", gl_MultiTexCoord3d, 4);
+	rb_define_module_function(module, "glMultiTexCoord3f", gl_MultiTexCoord3f, 4);
+	rb_define_module_function(module, "glMultiTexCoord3i", gl_MultiTexCoord3i, 4);
+	rb_define_module_function(module, "glMultiTexCoord3s", gl_MultiTexCoord3s, 4);
+	rb_define_module_function(module, "glMultiTexCoord4d", gl_MultiTexCoord4d, 5);
+	rb_define_module_function(module, "glMultiTexCoord4f", gl_MultiTexCoord4f, 5);
+	rb_define_module_function(module, "glMultiTexCoord4i", gl_MultiTexCoord4i, 5);
+	rb_define_module_function(module, "glMultiTexCoord4s", gl_MultiTexCoord4s, 5);
+	rb_define_module_function(module, "glLoadTransposeMatrixf", gl_LoadTransposeMatrixf, 1);
+	rb_define_module_function(module, "glLoadTransposeMatrixd", gl_LoadTransposeMatrixd, 1);
+	rb_define_module_function(module, "glMultTransposeMatrixf", gl_MultTransposeMatrixf, 1);
+	rb_define_module_function(module, "glMultTransposeMatrixd", gl_MultTransposeMatrixd, 1);
+	rb_define_module_function(module, "glSampleCoverage", gl_SampleCoverage, 2);
+	rb_define_module_function(module, "glCompressedTexImage3D", gl_CompressedTexImage3D, 9);
+	rb_define_module_function(module, "glCompressedTexImage2D", gl_CompressedTexImage2D, 8);
+	rb_define_module_function(module, "glCompressedTexImage1D", gl_CompressedTexImage1D, 7);
+	rb_define_module_function(module, "glCompressedTexSubImage3D", gl_CompressedTexSubImage3D, 11);
+	rb_define_module_function(module, "glCompressedTexSubImage2D", gl_CompressedTexSubImage2D, 9);
+	rb_define_module_function(module, "glCompressedTexSubImage1D", gl_CompressedTexSubImage1D, 7);
+	rb_define_module_function(module, "glGetCompressedTexImage", gl_GetCompressedTexImage, 2);
+
+	/* Additional functions */
+
+	rb_define_module_function(module, "glMultiTexCoord", gl_MultiTexCoorddv, -1);
+	rb_define_module_function(module, "glMultiTexCoord1dv", gl_MultiTexCoorddv, -1);
+	rb_define_module_function(module, "glMultiTexCoord1fv", gl_MultiTexCoordfv, -1);
+	rb_define_module_function(module, "glMultiTexCoord1iv", gl_MultiTexCoordiv, -1);
+	rb_define_module_function(module, "glMultiTexCoord1sv", gl_MultiTexCoordsv, -1);
+	rb_define_module_function(module, "glMultiTexCoord2dv", gl_MultiTexCoorddv, -1);
+	rb_define_module_function(module, "glMultiTexCoord2fv", gl_MultiTexCoordfv, -1);
+	rb_define_module_function(module, "glMultiTexCoord2iv", gl_MultiTexCoordiv, -1);
+	rb_define_module_function(module, "glMultiTexCoord2sv", gl_MultiTexCoordsv, -1);
+	rb_define_module_function(module, "glMultiTexCoord3dv", gl_MultiTexCoorddv, -1);
+	rb_define_module_function(module, "glMultiTexCoord3fv", gl_MultiTexCoordfv, -1);
+	rb_define_module_function(module, "glMultiTexCoord3iv", gl_MultiTexCoordiv, -1);
+	rb_define_module_function(module, "glMultiTexCoord3sv", gl_MultiTexCoordsv, -1);
+	rb_define_module_function(module, "glMultiTexCoord4dv", gl_MultiTexCoorddv, -1);
+	rb_define_module_function(module, "glMultiTexCoord4fv", gl_MultiTexCoordfv, -1);
+	rb_define_module_function(module, "glMultiTexCoord4iv", gl_MultiTexCoordiv, -1);
+	rb_define_module_function(module, "glMultiTexCoord4sv", gl_MultiTexCoordsv, -1);
+}