ruby-opengl 0.40.1 → 0.50.0

data/ext/gl/gl-ext-arb.c

@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2007 Jan Dvorak <jan.dvorak@kraxnet.cz>
+ *
+ * This program is distributed under the terms of the MIT license.
+ * See the included MIT-LICENSE file for the terms of this license.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "../common/common.h"
+
+/* OpenGL ARB extensions */
+
+/* #3 GL_ARB_transpose_matrix */
+#define TRANSPOSEMATRIX_FUNC(_name_,_type_,_shorttype_) \
+static void (APIENTRY * fptr_gl##_name_)(const _type_[]); \
+static VALUE \
+gl_##_name_(obj,arg1) \
+VALUE obj,arg1; \
+{ \
+	_type_ m[4*4]; \
+	LOAD_GL_EXT_FUNC(gl##_name_,"GL_ARB_transpose_matrix") \
+	ary2cmat4x4##_shorttype_(arg1, m); \
+	fptr_gl##_name_(m); \
+	return Qnil; \
+}
+
+TRANSPOSEMATRIX_FUNC(LoadTransposeMatrixfARB,GLfloat,flt)
+TRANSPOSEMATRIX_FUNC(LoadTransposeMatrixdARB,GLdouble,dbl)
+TRANSPOSEMATRIX_FUNC(MultTransposeMatrixfARB,GLfloat,flt)
+TRANSPOSEMATRIX_FUNC(MultTransposeMatrixdARB,GLdouble,dbl)
+
+#undef TRANSPOSEMATRIX_FUNC
+
+/* #5 GL_ARB_multisample */
+static void (APIENTRY * fptr_glSampleCoverageARB)(GLclampf,GLboolean);
+static VALUE gl_SampleCoverageARB(VALUE obj,VALUE arg1,VALUE arg2)
+{
+	LOAD_GL_EXT_FUNC(glSampleCoverageARB,"GL_ARB_multisample")
+	fptr_glSampleCoverageARB((GLclampf)NUM2DBL(arg1),(GLboolean)NUM2INT(arg2));
+	return Qnil;
+}
+
+/* #39 GL_ARB_color_buffer_float */
+GL_EXT_SIMPLE_FUNC_LOAD(ClampColorARB,2,GLenum,NUM2INT,"GL_ARB_color_buffer_float")
+
+void gl_init_functions_ext_arb(VALUE module)
+{
+/* #3 GL_ARB_transpose_matrix */
+	rb_define_module_function(module, "glLoadTransposeMatrixfARB", gl_LoadTransposeMatrixfARB, 1);
+	rb_define_module_function(module, "glLoadTransposeMatrixdARB", gl_LoadTransposeMatrixdARB, 1);
+	rb_define_module_function(module, "glMultTransposeMatrixfARB", gl_MultTransposeMatrixfARB, 1);
+	rb_define_module_function(module, "glMultTransposeMatrixdARB", gl_MultTransposeMatrixdARB, 1);
+
+/* #5 GL_ARB_multisample */
+	rb_define_module_function(module, "glSampleCoverageARB", gl_SampleCoverageARB, 2);
+
+/* #39 GL_ARB_color_buffer_float */
+	rb_define_module_function(module, "glClampColorARB", gl_ClampColorARB, 2);
+}

data/ext/gl/gl-ext-ext.c

@@ -0,0 +1,218 @@
+/*
+ * Copyright (C) 2007 Jan Dvorak <jan.dvorak@kraxnet.cz>
+ *
+ * This program is distributed under the terms of the MIT license.
+ * See the included MIT-LICENSE file for the terms of this license.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "../common/common.h"
+
+/* OpenGL EXT extensions */
+/* Those are extensions that are not blessed by ARB committee but were
+   created or agreed upon by multiple vendors */
+
+/* #310 - GL_EXT_framebuffer_object */
+static GLboolean (APIENTRY * fptr_glIsRenderbufferEXT)(GLuint);
+static VALUE gl_IsRenderbufferEXT(VALUE obj,VALUE arg1)
+{
+	GLboolean ret;
+	LOAD_GL_EXT_FUNC(glIsRenderbufferEXT,"GL_EXT_framebuffer_object")
+	ret = fptr_glIsRenderbufferEXT((GLuint)NUM2UINT(arg1));
+	return INT2NUM(ret);
+}
+
+static void (APIENTRY * fptr_glBindRenderbufferEXT)(GLenum,GLuint);
+static VALUE gl_BindRenderbufferEXT(VALUE obj,VALUE arg1,VALUE arg2)
+{
+	LOAD_GL_EXT_FUNC(glBindRenderbufferEXT,"GL_EXT_framebuffer_object")
+	fptr_glBindRenderbufferEXT((GLenum)NUM2INT(arg1),(GLuint)NUM2UINT(arg2));
+	return Qnil;
+}
+
+static void (APIENTRY * fptr_glDeleteRenderbuffersEXT)(GLsizei,const GLuint *);
+static VALUE gl_DeleteRenderbuffersEXT(VALUE obj,VALUE arg1)
+{
+	GLsizei n;
+	LOAD_GL_EXT_FUNC(glDeleteRenderbuffersEXT,"GL_EXT_framebuffer_object")
+	if (TYPE(arg1)==T_ARRAY) {
+		GLuint *renderbuffers;
+		n = RARRAY(arg1)->len;
+		renderbuffers = ALLOC_N(GLuint,n);
+		ary2cuint(arg1,renderbuffers,n); 
+		fptr_glDeleteRenderbuffersEXT(n,renderbuffers);
+		xfree(renderbuffers);
+	} else {
+		GLuint renderbuffer;
+		renderbuffer = NUM2UINT(arg1);
+		fptr_glDeleteRenderbuffersEXT(1,&renderbuffer);
+	}
+	return Qnil;
+}
+
+static void (APIENTRY * fptr_glGenRenderbuffersEXT)(GLsizei,GLuint *);
+static VALUE gl_GenRenderbuffersEXT(VALUE obj,VALUE arg1)
+{
+	GLsizei n;
+	GLuint *renderbuffers;
+	VALUE ret;
+	int i;
+	LOAD_GL_EXT_FUNC(glGenRenderbuffersEXT,"GL_EXT_framebuffer_object")
+	n = (GLsizei)NUM2UINT(arg1);
+	renderbuffers = ALLOC_N(GLuint, n);
+	fptr_glGenRenderbuffersEXT(n,renderbuffers);
+	ret = rb_ary_new2(n);
+	for (i = 0; i < n; i++)
+		rb_ary_push(ret, INT2NUM(renderbuffers[i]));
+	xfree(renderbuffers);
+	return ret;
+}
+
+static void (APIENTRY * fptr_glRenderbufferStorageEXT)(GLenum,GLenum,GLsizei,GLsizei);
+static VALUE gl_RenderbufferStorageEXT(VALUE obj,VALUE arg1,VALUE arg2,VALUE arg3,VALUE arg4)
+{
+	LOAD_GL_EXT_FUNC(glRenderbufferStorageEXT,"GL_EXT_framebuffer_object")
+	fptr_glRenderbufferStorageEXT(NUM2UINT(arg1),NUM2UINT(arg2),NUM2INT(arg3),NUM2INT(arg4));
+	return Qnil;
+}
+
+static void (APIENTRY * fptr_glGetRenderbufferParameterivEXT)(GLenum,GLenum,GLint *);
+static VALUE gl_GetRenderbufferParameterivEXT(VALUE obj,VALUE arg1,VALUE arg2)
+{
+	GLint param = 0;
+	LOAD_GL_EXT_FUNC(glGetRenderbufferParameterivEXT,"GL_EXT_framebuffer_object")
+	fptr_glGetRenderbufferParameterivEXT(NUM2UINT(arg1),NUM2UINT(arg2),&param);
+	return INT2NUM(param);
+}
+
+static GLboolean (APIENTRY * fptr_glIsFramebufferEXT)(GLuint);
+static VALUE gl_IsFramebufferEXT(VALUE obj,VALUE arg1)
+{
+	GLboolean ret;
+	LOAD_GL_EXT_FUNC(glIsFramebufferEXT,"GL_EXT_framebuffer_object")
+	ret = fptr_glIsFramebufferEXT(NUM2UINT(arg1));
+	return INT2NUM(ret);
+}
+
+static void (APIENTRY * fptr_glBindFramebufferEXT)(GLenum,GLuint);
+static VALUE gl_BindFramebufferEXT(VALUE obj,VALUE arg1,VALUE arg2)
+{
+	LOAD_GL_EXT_FUNC(glBindFramebufferEXT,"GL_EXT_framebuffer_object")
+	fptr_glBindFramebufferEXT((GLenum)NUM2INT(arg1),(GLuint)NUM2UINT(arg2));
+	return Qnil;
+}
+
+static void (APIENTRY * fptr_glDeleteFramebuffersEXT)(GLsizei,const GLuint *);
+static VALUE gl_DeleteFramebuffersEXT(VALUE obj,VALUE arg1)
+{
+	GLsizei n;
+	LOAD_GL_EXT_FUNC(glDeleteFramebuffersEXT,"GL_EXT_framebuffer_object")
+	if (TYPE(arg1)==T_ARRAY) {
+		GLuint *framebuffers;
+		n = RARRAY(arg1)->len;
+		framebuffers = ALLOC_N(GLuint,n);
+		ary2cuint(arg1,framebuffers,n); 
+		fptr_glDeleteFramebuffersEXT(n,framebuffers);
+		xfree(framebuffers);
+	} else {
+		GLuint framebuffer;
+		framebuffer = NUM2UINT(arg1);
+		fptr_glDeleteFramebuffersEXT(1,&framebuffer);
+	}
+	return Qnil;
+}
+
+static void (APIENTRY * fptr_glGenFramebuffersEXT)(GLsizei,GLuint *);
+static VALUE gl_GenFramebuffersEXT(VALUE obj,VALUE arg1)
+{
+	GLsizei n;
+	GLuint *framebuffers;
+	VALUE ret;
+	int i;
+	LOAD_GL_EXT_FUNC(glGenFramebuffersEXT,"GL_EXT_framebuffer_object")
+	n = (GLsizei)NUM2UINT(arg1);
+	framebuffers = ALLOC_N(GLuint, n);
+	fptr_glGenFramebuffersEXT(n,framebuffers);
+	ret = rb_ary_new2(n);
+	for (i = 0; i < n; i++)
+		rb_ary_push(ret, INT2NUM(framebuffers[i]));
+	xfree(framebuffers);
+	return ret;
+}
+
+static GLenum (APIENTRY * fptr_glCheckFramebufferStatusEXT)(GLenum);
+static VALUE gl_CheckFramebufferStatusEXT(VALUE obj,VALUE arg1)
+{
+	GLenum ret;
+	LOAD_GL_EXT_FUNC(glCheckFramebufferStatusEXT,"GL_EXT_framebuffer_object")
+	ret = fptr_glCheckFramebufferStatusEXT(NUM2UINT(arg1));
+	return INT2NUM(ret);
+}
+
+static void (APIENTRY * fptr_glFramebufferTexture1DEXT)(GLenum,GLenum,GLenum,GLuint,GLint);
+static VALUE gl_FramebufferTexture1DEXT(VALUE obj,VALUE arg1,VALUE arg2,VALUE arg3,VALUE arg4,VALUE arg5)
+{
+	LOAD_GL_EXT_FUNC(glFramebufferTexture1DEXT,"GL_EXT_framebuffer_object")
+	fptr_glFramebufferTexture1DEXT(NUM2UINT(arg1),NUM2UINT(arg2),NUM2UINT(arg3),NUM2UINT(arg4),NUM2INT(arg5));
+	return Qnil;
+}
+
+static void (APIENTRY * fptr_glFramebufferTexture2DEXT)(GLenum,GLenum,GLenum,GLuint,GLint);
+static VALUE gl_FramebufferTexture2DEXT(VALUE obj,VALUE arg1,VALUE arg2,VALUE arg3,VALUE arg4,VALUE arg5)
+{
+	LOAD_GL_EXT_FUNC(glFramebufferTexture2DEXT,"GL_EXT_framebuffer_object")
+	fptr_glFramebufferTexture2DEXT(NUM2UINT(arg1),NUM2UINT(arg2),NUM2UINT(arg3),NUM2UINT(arg4),NUM2INT(arg5));
+	return Qnil;
+}
+
+static void (APIENTRY * fptr_glFramebufferTexture3DEXT)(GLenum,GLenum,GLenum,GLuint,GLint,GLint);
+static VALUE gl_FramebufferTexture3DEXT(VALUE obj,VALUE arg1,VALUE arg2,VALUE arg3,VALUE arg4,VALUE arg5,VALUE arg6)
+{
+	LOAD_GL_EXT_FUNC(glFramebufferTexture3DEXT,"GL_EXT_framebuffer_object")
+	fptr_glFramebufferTexture3DEXT(NUM2UINT(arg1),NUM2UINT(arg2),NUM2UINT(arg3),NUM2UINT(arg4),NUM2INT(arg5),NUM2INT(arg6));
+	return Qnil;
+}
+
+GL_EXT_SIMPLE_FUNC_LOAD(FramebufferRenderbufferEXT,4,GLuint,NUM2UINT,"GL_EXT_framebuffer_object")
+
+
+static void (APIENTRY * fptr_glGetFramebufferAttachmentParameterivEXT)(GLenum,GLenum,GLenum,GLint *);
+static VALUE gl_GetFramebufferAttachmentParameterivEXT(VALUE obj,VALUE arg1, VALUE arg2, VALUE arg3)
+{
+	GLint ret = 0;
+	LOAD_GL_EXT_FUNC(glGetFramebufferAttachmentParameterivEXT,"GL_EXT_framebuffer_object")
+	fptr_glGetFramebufferAttachmentParameterivEXT(NUM2UINT(arg1),NUM2UINT(arg2),NUM2UINT(arg3),&ret);
+	return INT2NUM(ret);
+}
+
+GL_EXT_SIMPLE_FUNC_LOAD(GenerateMipmapEXT,1,GLenum,NUM2UINT,"GL_EXT_framebuffer_object")
+
+void gl_init_functions_ext_ext(VALUE module)
+{
+/* #310 - GL_EXT_framebuffer_object */
+	rb_define_module_function(module, "glIsRenderbufferEXT", gl_IsRenderbufferEXT, 1);
+	rb_define_module_function(module, "glBindRenderbufferEXT", gl_BindRenderbufferEXT, 2);
+	rb_define_module_function(module, "glDeleteRenderbuffersEXT", gl_DeleteRenderbuffersEXT, 1);
+	rb_define_module_function(module, "glGenRenderbuffersEXT", gl_GenRenderbuffersEXT, 1);
+	rb_define_module_function(module, "glRenderbufferStorageEXT", gl_RenderbufferStorageEXT, 4);
+	rb_define_module_function(module, "glGetRenderbufferParameterivEXT", gl_GetRenderbufferParameterivEXT, 2);
+	rb_define_module_function(module, "glIsFramebufferEXT", gl_IsFramebufferEXT, 1);
+	rb_define_module_function(module, "glBindFramebufferEXT", gl_BindFramebufferEXT, 2);
+	rb_define_module_function(module, "glDeleteFramebuffersEXT", gl_DeleteFramebuffersEXT, 1);
+	rb_define_module_function(module, "glGenFramebuffersEXT", gl_GenFramebuffersEXT, 1);
+	rb_define_module_function(module, "glCheckFramebufferStatusEXT", gl_CheckFramebufferStatusEXT, 1);
+	rb_define_module_function(module, "glFramebufferTexture1DEXT", gl_FramebufferTexture1DEXT, 5);
+	rb_define_module_function(module, "glFramebufferTexture2DEXT", gl_FramebufferTexture2DEXT, 5);
+	rb_define_module_function(module, "glFramebufferTexture3DEXT", gl_FramebufferTexture3DEXT, 6);
+	rb_define_module_function(module, "glFramebufferRenderbufferEXT", gl_FramebufferRenderbufferEXT, 4);
+	rb_define_module_function(module, "glGetFramebufferAttachmentParameterivEXT", gl_GetFramebufferAttachmentParameterivEXT, 3);
+	rb_define_module_function(module, "glGenerateMipmapEXT", gl_GenerateMipmapEXT, 1);
+
+}

data/ext/gl/gl.c

@@ -1,6 +1,7 @@
 /*
  * Copyright (C) 1999 - 2005 Yoshi <yoshi@giganet.net>
  * Copyright (C) 2006 John M. Gabriele <jmg3000@gmail.com>
+ * Copyright (C) 2007 Jan Dvorak <jan.dvorak@kraxnet.cz>
  *
  * This program is distributed under the terms of the MIT license.
  * See the included MIT-LICENSE file for the terms of this license.
@@ -14,22 +15,8 @@
  * 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"
 
-#ifdef WIN32
-#define DLLEXPORT __declspec(dllexport)
-#else
-#define DLLEXPORT
-#endif
-
 static VALUE module;
 
 void gl_init_enums(VALUE);
@@ -40,40 +27,158 @@ void gl_init_functions_1_4(VALUE);
 void gl_init_functions_1_5(VALUE);
 void gl_init_functions_2_0(VALUE);
 void gl_init_functions_2_1(VALUE);
+void gl_init_functions_ext_arb(VALUE);
+void gl_init_functions_ext_ext(VALUE);
+
+static int opengl_version[2]; /* major, minor */
+static char *opengl_extensions = NULL;
 
-VALUE IsFunctionAvailable(char *name)
+/* Returns current OpenGL version as major, minor or 0,0 if
+ * unknown (context not yet initialised etc.) The version is
+ * cached for subsequent calls.
+ */
+const int *GetOpenglVersion(void)
 {
-	GLvoid *ret;
-	ret = load_gl_function(name,0); /* won't raise */
-	if (ret==NULL)
-		return Qfalse;
+	if (opengl_version[0]==0) { /* not cached, query */
+		const char *vstr = (const char *) glGetString(GL_VERSION);
+    if (vstr)
+			sscanf( vstr, "%d.%d", &opengl_version[0], &opengl_version[1] );
+	}
+	return opengl_version;
+}
+
+/* Checks if OpenGL version is at least the same or higher than
+ * major.minor
+ */
+GLboolean CheckOpenglVersion(int major, int minor)
+{
+	const int *version;
+
+	version = GetOpenglVersion();
+
+	if (version[0]>major || (version[0]==major && version[1] >=minor))
+		return GL_TRUE;
 	else
-		return Qtrue;
+		return GL_FALSE;
+}
+
+/* Returns supported OpenGL extensions as char* or NULL
+ * if unknown (context not yet initialised etc.) The list is
+ * cached for subsequent calls.
+ */
+const char *GetOpenglExtensions(void)
+{
+	if (opengl_extensions == NULL) {
+		const char *estr = (const char *) glGetString(GL_EXTENSIONS);
+    if (estr) {
+			int len = strlen(estr);
+			opengl_extensions = ALLOC_N(GLchar,len+1+1); /* terminating null and added space */
+			strcpy(opengl_extensions,estr);
+			opengl_extensions[len] = ' '; /* add space char for easy searchs */
+			opengl_extensions[len+1] = '\0';
+		}
+	}
+	return opengl_extensions;	
+}
+
+/* Checks if extension is supported by the current OpenGL implementation
+ */
+GLboolean CheckExtension(const char *name)
+{
+	const char *extensions;
+	char *name_tmp;
+	int name_len;
+	GLboolean res;
+	
+	extensions = GetOpenglExtensions();
+	
+	if(extensions==NULL)
+		return GL_FALSE;
+
+	/* add trailing space */
+	name_len = strlen(name);
+	name_tmp = ALLOC_N(GLchar,name_len+1+1); /* terminating null and added space */
+	strcpy(name_tmp,name);
+	name_tmp[name_len] = ' '; /* add space char for search */
+	name_tmp[name_len+1] = '\0';
+
+	if (strstr(extensions,name_tmp))
+		res = GL_TRUE;
+	else
+		res = GL_FALSE;
+
+	xfree(name_tmp);
+	return res;	
 }
 
 static VALUE
 IsAvailable(obj,arg1)
 VALUE obj,arg1;
 {
-	char *name = RSTRING(arg1)->ptr;
-	Check_Type(arg1, T_STRING);
-	if (name && name[0] && (name[0]=='G' || name[0]=='W')) { /* GL_, GLX_, WGL_ extension */
-		char buf[512+128];
-		if (strlen(name)>(512))
+	char *name = NULL;
+	VALUE s;
+
+	s = rb_funcall(arg1, rb_intern("to_s"),0);
+	name = RSTRING(s)->ptr;
+
+	if (name && name[0] && name[0]>='0' && name[0]<='9') { /* GL version query */
+		int major,minor;
+
+		if (sscanf( name, "%d.%d", &major, &minor ) != 2)
+				return Qfalse;
+	
+		if (CheckOpenglVersion(major,minor)==1)
+			return Qtrue;
+		else
 			return Qfalse;
-		if (glGetString(GL_EXTENSIONS)==0)
+	} else if (name && name[0] && (name[0]=='G' || name[0]=='W')) { /* GL_, GLX_, WGL_ extension */
+		GLboolean res;
+		
+		res = CheckExtension(name);
+		if (res==GL_TRUE)
+			return Qtrue;
+		else
 			return Qfalse;
-
-		sprintf(buf,"Gl.glGetString(Gl::GL_EXTENSIONS).split(' ').include?('%s')", name);
-		return rb_eval_string(buf);
 	} else { /* function */
-		return IsFunctionAvailable(name);
+		GLvoid *ret;
+		ret = load_gl_function(name,0); /* won't raise */
+		if (ret==NULL)
+			return Qfalse;
+		else
+			return Qtrue;
+	}
+}
+
+/* Checks whether non-zero buffer of type $buffer is bound
+ * - this affects several functions that pass data from/to OpenGL.
+ */
+GLint CheckBufferBinding(GLint buffer)
+{
+	GLint result = 0;
+	
+	/* check if the buffer functionality is supported */
+	switch(buffer) {
+		case GL_ARRAY_BUFFER_BINDING:
+		case GL_ELEMENT_ARRAY_BUFFER_BINDING:
+			if (!CheckOpenglVersion(1,5))
+				return 0;
+			break;
+		case GL_PIXEL_PACK_BUFFER_BINDING:
+		case GL_PIXEL_UNPACK_BUFFER_BINDING:
+			if (!CheckOpenglVersion(2,1))
+				return 0;
+			break;
+		default:
+			rb_raise(rb_eRuntimeError,"Internal Error: buffer type '%i' does not exist", buffer);
+			break;
 	}
+	glGetIntegerv(buffer,&result);
+	return result;
 }
 
 DLLEXPORT void Init_gl()
 {
-    module = rb_define_module("Gl");
+	module = rb_define_module("Gl");
 	gl_init_enums(module);
 	gl_init_functions_1_0__1_1(module);
 	gl_init_functions_1_2(module);
@@ -82,6 +187,8 @@ DLLEXPORT void Init_gl()
 	gl_init_functions_1_5(module);
 	gl_init_functions_2_0(module);
 	gl_init_functions_2_1(module);
+	gl_init_functions_ext_arb(module);
+	gl_init_functions_ext_ext(module);
 
 	rb_define_module_function(module, "is_available?", IsAvailable, 1);
 }