opengl 0.8.0-x86-mingw32 → 0.9.0-x86-mingw32

data/ext/opengl/common.h

@@ -31,14 +31,6 @@
 #include <OpenGL/gl.h>
 #endif
 
-#ifdef HAVE_OPENGL_GLU_H
-#include <OpenGL/glu.h>
-#endif
-
-#ifdef HAVE_GLUT_GLUT_H
-#include <GLUT/glut.h>
-#endif
-
 #ifdef HAVE_DLFCN_H
 #include <dlfcn.h>
 #endif
@@ -55,21 +47,12 @@
 #include <GL/gl.h>
 #endif
 
-#ifdef HAVE_GL_GLU_H
-#include <GL/glu.h>
-#endif
-
-#ifdef HAVE_GL_GLUT_H
-#include <GL/glut.h>
-#endif
-
 #ifdef HAVE_GL_GLX_H
 #include <GL/glx.h>
 #endif
 
 #include "gl-types.h"
 #include "gl-enums.h"
-#include "glu-enums.h"
 #include "gl-error.h"
 
 #include "funcdef.h"
@@ -83,10 +66,6 @@
 #define CALLBACK
 #endif
 
-#ifndef GLUTCALLBACK
-#define GLUTCALLBACK
-#endif
-
 #ifdef HAVE_WINDOWS_H
 #define DLLEXPORT __declspec(dllexport)
 #else
@@ -387,13 +366,25 @@ static inline void *load_gl_function(const char *name,int raise)
 
 #if defined(__APPLE__)
 	void *library = NULL;
-  library = dlopen("/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL", RTLD_LAZY | RTLD_LOCAL | RTLD_FIRST);
+	library = dlopen("/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL", RTLD_LAZY | RTLD_LOCAL | RTLD_FIRST);
 
 	if (library == NULL)
 		rb_raise(rb_eRuntimeError,"Can't load OpenGL library for dynamic loading");
-		
-  func_ptr = dlsym(library, name);
-  dlclose(library);
+
+	func_ptr = dlsym(library, name);
+
+	if(func_ptr == NULL)
+	{
+		/* prepend a '_' for the Unix C symbol mangling convention */
+		char *symbol_name = ALLOC_N(char, strlen(name) + 2);
+		symbol_name[0] = '_';
+		strcpy(symbol_name + 1, name);
+		func_ptr = dlsym(library, symbol_name);
+		xfree(symbol_name);
+	}
+
+	dlclose(library);
+
 #elif HAVE_WGLGETPROCADDRESS
 	func_ptr = wglGetProcAddress((LPCSTR)name);
 #elif defined(GLX_VERSION_1_4)
@@ -434,17 +425,4 @@ static inline VALUE pack_array_or_pass_string(GLenum type,VALUE ary)
 	return rb_funcall(ary,rb_intern("pack"),1,rb_str_new2(type_str));
 }
 
-/* GLUT */
-
-#define GLUT_SIMPLE_FUNCTION(_name_) \
-static VALUE \
-glut_##_name_(obj) \
-VALUE obj; \
-{ \
-    glut##_name_(); \
-    return Qnil; \
-}
-
-VALUE rb_glut_check_callback(VALUE, VALUE);
-
 #endif

data/ext/opengl/conv.h

@@ -16,15 +16,15 @@
 /* Functions and macros for datatype conversion between Ruby and C */
 
 /*
-   Fast inline conversion functions as a replacement for the ones in libruby.
-   FIXNUM_P is simple logical AND check so it comes first, TYPE() is simple function,
-   and specified in header file so it can be inlined. For conversion, FIX2LONG is
-   simple right shift, and RFLOAT()-> just pointer dereference. For converting
-   Fixnum and Float types (which accounts for 99.9% of things you would want to pass
-   to OpenGL), there is large performance boost as result.
-
-	 Also ruby 'true' and 'false' are converted to GL_TRUE/GL_FALSE for compatibility, and
-	 finally, we fallback to library functions for any other data types (and error handling).
+	Fast inline conversion functions as a replacement for the ones in libruby.
+	FIXNUM_P is simple logical AND check so it comes first, TYPE() is simple function,
+	and specified in header file so it can be inlined. For conversion, FIX2LONG is
+	simple right shift, and RFLOAT()-> just pointer dereference. For converting
+	Fixnum and Float types (which accounts for 99.9% of things you would want to pass
+	to OpenGL), there is large performance boost as result.
+
+	Also ruby 'true' and 'false' are converted to GL_TRUE/GL_FALSE for compatibility, and
+	finally, we fallback to library functions for any other data types (and error handling).
 */
 
 #if HAVE_STRUCT_RFLOAT_FLOAT_VALUE
@@ -66,12 +66,14 @@ FASTCONV(num2uint,unsigned long,FIX2ULONG,(unsigned int)NUM2ULONG)
 #undef FASTCONV
 
 #define RUBY2GLENUM(x) \
-    (x) == Qtrue ? GL_TRUE : (((x) == Qfalse) ? GL_FALSE : NUM2INT(x))
+	(x) == Qtrue ? GL_TRUE : ((x) == Qfalse ? GL_FALSE : NUM2INT(x))
 
 /* For conversion between ruby and GL boolean values */
 #define GLBOOL2RUBY(x) \
-    (x) == GL_TRUE ? Qtrue : ((x)==GL_FALSE ? Qfalse : INT2NUM((x)))
-#define RUBYBOOL2GL(x) (x)==Qtrue? GL_TRUE : GL_FALSE
+	(x) == GL_TRUE ? Qtrue : ((x)==GL_FALSE ? Qfalse : INT2NUM((x)))
+
+#define RUBYBOOL2GL(x) \
+	(x) == Qtrue ? GL_TRUE : GL_FALSE
 
 #define cond_GLBOOL2RUBY_FUNC(_name_,_type_,_conv_) \
 static inline VALUE _name_(GLenum pname,_type_ value) \
@@ -97,9 +99,6 @@ static inline VALUE _name_(GLenum pname,_type_ value) \
 	case GL_TEXTURE_FLOAT_COMPONENTS_NV: \
 	case GL_SHADER_CONSISTENT_NV: \
 	case GL_TEXTURE_COMPARE_SGIX: \
-	case GLU_TESS_BOUNDARY_ONLY: \
-	case GLU_CULLING: \
-	case GLU_AUTO_LOAD_MATRIX: \
 		return GLBOOL2RUBY(value); \
 	default: \
 		return _conv_(value); \
@@ -124,15 +123,15 @@ VALUE arg; \
 GL##_type_ cary[]; \
 long maxlen; \
 { \
-    long i; \
-    VALUE ary = rb_Array(arg); \
-    if (maxlen < 1) \
-        maxlen = RARRAY_LEN(ary); \
-    else \
-        maxlen = maxlen < RARRAY_LEN(ary) ? maxlen : RARRAY_LEN(ary); \
-    for (i=0; i < maxlen; i++) \
-        cary[i] = (GL##_type_)_convert_(rb_ary_entry(ary,i)); \
-    return i; \
+	long i; \
+	VALUE ary = rb_Array(arg); \
+	if (maxlen < 1) \
+		maxlen = RARRAY_LEN(ary); \
+	else \
+		maxlen = maxlen < RARRAY_LEN(ary) ? maxlen : RARRAY_LEN(ary); \
+	for (i=0; i < maxlen; i++) \
+		cary[i] = (GL##_type_)_convert_(rb_ary_entry(ary,i)); \
+	return i; \
 }
 
 ARY2CTYPE(int,NUM2INT)
@@ -201,32 +200,32 @@ ARY2CMATCNT(float)
 #define FREE(_x_) xfree(_x_);
 
 #define RET_ARRAY_OR_SINGLE(_name_, _size_, _conv_, _params_) \
-    RET_ARRAY_OR_SINGLE_FUNC(_name_, _size_, _conv_, _params_, EMPTY)
+	RET_ARRAY_OR_SINGLE_FUNC(_name_, _size_, _conv_, _params_, EMPTY)
 
 #define RET_ARRAY_OR_SINGLE_FREE(_name, _size_, _conv_, _params_) \
-    RET_ARRAY_OR_SINGLE_FUNC(_name, _size_, _conv_, _params_, FREE(_params_))
+	RET_ARRAY_OR_SINGLE_FUNC(_name, _size_, _conv_, _params_, FREE(_params_))
 
 #define RET_ARRAY_OR_SINGLE_FUNC(_name_, _size_, _conv_, _params_, _extra_) \
 do { \
-  int iter; \
-  VALUE return_array; \
-  if (_size_ == 1) { \
-    return_array = _conv_(_params_[0]); \
-  } else { \
-    return_array = rb_ary_new2(_size_); \
-    for(iter=0;iter<_size_;iter++) \
-    rb_ary_push(return_array, _conv_(_params_[iter])); \
-  } \
-  _extra_ \
-  CHECK_GLERROR_FROM(_name_); \
-  return return_array; \
+	int iter; \
+	VALUE return_array; \
+	if (_size_ == 1) { \
+		return_array = _conv_(_params_[0]); \
+	} else { \
+		return_array = rb_ary_new2(_size_); \
+		for(iter=0;iter<_size_;iter++) \
+		rb_ary_push(return_array, _conv_(_params_[iter])); \
+	} \
+	_extra_ \
+	CHECK_GLERROR_FROM(_name_); \
+	return return_array; \
 } while (0)
 
 #define RET_ARRAY_OR_SINGLE_BOOL(_name_, _size_, _conv_, _enum_, _params_) \
-    RET_ARRAY_OR_SINGLE_BOOL_FUNC(_name_, _size_, _conv_, _enum_, _params_, EMPTY)
+	RET_ARRAY_OR_SINGLE_BOOL_FUNC(_name_, _size_, _conv_, _enum_, _params_, EMPTY)
 
 #define RET_ARRAY_OR_SINGLE_BOOL_FREE(_name_, _size_, _conv_, _enum_, _params_) \
-    RET_ARRAY_OR_SINGLE_BOOL_FUNC(_name_, _size_, _conv_, _enum_, _params_, FREE(_params_))
+	RET_ARRAY_OR_SINGLE_BOOL_FUNC(_name_, _size_, _conv_, _enum_, _params_, FREE(_params_))
 
 #define RET_ARRAY_OR_SINGLE_BOOL_FUNC(_name_, _size_, _conv_, _enum_, _params_, _extra_) \
 do { \
@@ -243,4 +242,3 @@ do { \
 	CHECK_GLERROR_FROM(_name_); \
 	return return_array; \
 } while (0)
-

data/ext/opengl/extconf.rb

@@ -15,40 +15,18 @@ end unless respond_to? :have_framework
 
 if ENV['CROSS_COMPILING']
   dir_config("installed")
-
-  $defs.push "-DFREEGLUT_EXPORTS"
-
-  # libfreeglut is linked to gdi32 and winmm
-  have_library( 'gdi32', 'CreateDC' ) && append_library( $libs, 'gdi32' )
-  have_library( 'winmm', 'timeBeginPeriod' ) && append_library( $libs, 'winmm' )
 end
 
 ok =
-  (have_library('opengl32.lib', 'glVertex3d') &&
-   have_library('glu32.lib',    'gluLookAt') &&
-   have_library('glut32.lib',   'gluSolidTeapot')) ||
-  (have_library('opengl32') &&
-   have_library('glu32') &&
-   have_library('glut')) ||
-  (have_library('GL',   'glVertex3d') &&
-   have_library('GLU',  'gluLookAt') &&
-   have_library('glut', 'glutSolidTeapot')) ||
-  (have_framework('OpenGL') &&
-   have_framework('GLUT') &&
-   have_framework('Cocoa'))
+  (have_framework('OpenGL') && have_framework('Cocoa')) ||
+  have_library('opengl32.lib', 'glVertex3d') ||
+  have_library('opengl32') ||
+  have_library('GL',   'glVertex3d')
 
 ok &&=
   have_header('GL/gl.h') ||
   have_header('OpenGL/gl.h') # OS X
 
-ok &&=
-  have_header('GL/glu.h') ||
-  have_header('OpenGL/glu.h') # OS X
-
-ok &&=
-  have_header('GL/glut.h') ||
-  have_header('GLUT/glut.h') # OS X
-
 have_header 'GL/glx.h'  # *NIX only?
 have_header 'dlfcn.h'   # OS X dynamic loader
 have_header 'windows.h'
@@ -63,12 +41,7 @@ have_struct_member 'struct RFloat', 'float_value'
 have_type 'int64_t', 'stdint.h'
 have_type 'uint64_t', 'stdint.h'
 
-if String === ?a then
-  $defs.push "-DHAVE_SINGLE_BYTE_STRINGS"
-end
-
 if ok then
   create_header
   create_makefile 'opengl/opengl'
 end
-

data/ext/opengl/funcdef.h

@@ -13,13 +13,14 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-/* These macros are for simplification of function definition, as passing
-   arguments from/to OpenGL usually follows the same few patterns. It would
-   be probably wise to adapt the whole bindings to C++ (templates, overloaded
-   functions, etc.), but for now supporting ruby extension for Windows means
-   MSVC6, and that in turn means unspeakable horrors and pains for everyone
-   attempting to merely write, much less debug or maintain any template-based
-   code.
+/*
+	These macros are for simplification of function definition, as passing
+	arguments from/to OpenGL usually follows the same few patterns. It would
+	be probably wise to adapt the whole bindings to C++ (templates, overloaded
+	functions, etc.), but for now supporting ruby extension for Windows means
+	MSVC6, and that in turn means unspeakable horrors and pains for everyone
+	attempting to merely write, much less debug or maintain any template-based
+	code.
  */
 
 /*
@@ -28,30 +29,31 @@
  * then required or the required extension is not supported.
  */
 #define LOAD_GL_FUNC(_NAME_, _VEREXT_) \
-  do { \
-    if (fptr_##_NAME_==NULL) { \
-      if (CheckVersionExtension(_VEREXT_) == GL_FALSE) { \
-        if (isdigit(_VEREXT_[0])) { \
-          rb_raise(rb_eNotImpError, \
-              "OpenGL version %s is not available on this system",_VEREXT_); \
-        } else { \
-          rb_raise(rb_eNotImpError, \
-              "Extension %s is not available on this system",_VEREXT_); \
-        } \
-      } \
-      \
-      fptr_##_NAME_ = load_gl_function(#_NAME_, 1); \
-    } \
-  } while (0)
+	do { \
+		if (fptr_##_NAME_==NULL) { \
+			if (CheckVersionExtension(_VEREXT_) == GL_FALSE) { \
+				if (isdigit(_VEREXT_[0])) { \
+					rb_raise(rb_eNotImpError, \
+						"OpenGL version %s is not available on this system",_VEREXT_); \
+				} else { \
+					rb_raise(rb_eNotImpError, \
+						"Extension %s is not available on this system",_VEREXT_); \
+				} \
+			} \
+			\
+			fptr_##_NAME_ = load_gl_function(#_NAME_, 1); \
+		} \
+	} while (0)
 
-/* Macroset for defining simple functions, i.e. functions that take n arguments and
-   pass them to GL API function without any additional processing.
+/* 
+	Macroset for defining simple functions, i.e. functions that take n arguments and
+	pass them to GL API function without any additional processing.
 
-   Some checking is implicit in _conversion_ argument - e.g. NUM2INT makes sure that
-   user is really passing type that can be converted to INT, otherwire raises.
+	Some checking is implicit in _conversion_ argument - e.g. NUM2INT makes sure that
+	user is really passing type that can be converted to INT, otherwire raises.
 
- *_LOAD version of macros are for defining functions where we load function pointer
- instead of direct call - that means all functions above OpenGL 1.1 (including all extensions)
+	*_LOAD version of macros are for defining functions where we load function pointer
+	instead of direct call - that means all functions above OpenGL 1.1 (including all extensions)
  */
 
 #define ARGLIST0
@@ -67,7 +69,7 @@
 #define ARGLIST10 ,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10
 
 #define CONV_GLenum (GLenum)RUBY2GLENUM
-#define CONV_GLboolean (GLboolean)GLBOOL2RUBY
+#define CONV_GLboolean (GLboolean)RUBYBOOL2GL
 #define CONV_GLbitfield (GLbitfield)NUM2UINT
 #define CONV_GLbyte (GLbyte)NUM2INT
 #define CONV_GLshort (GLshort)NUM2INT
@@ -159,153 +161,153 @@
 #define CALLCONV10(cv1,cv2,cv3,cv4,cv5,cv6,cv7,cv8,cv9,cv10) CONV_##cv1(arg1),CONV_##cv2(arg2),CONV_##cv3(arg3),CONV_##cv4(arg4),CONV_##cv5(arg5),CONV_##cv6(arg6),CONV_##cv7(arg7),CONV_##cv8(arg8),CONV_##cv9(arg9),CONV_##cv10(arg10)
 
 #define GL_FUNC_LOAD(_num_,_name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,targ7,targ8,targ9,targ10,_ver_) \
-  static _returntype_ (APIENTRY * fptr_gl##_name_)(PROTOPARAM##_num_(targ1,targ2,targ3,targ4,targ5,targ6,targ7,targ8,targ9,targ10)); \
+	static _returntype_ (APIENTRY * fptr_gl##_name_)(PROTOPARAM##_num_(targ1,targ2,targ3,targ4,targ5,targ6,targ7,targ8,targ9,targ10)); \
 static VALUE \
 gl_##_name_(obj ARGLIST##_num_) \
 VALUE obj ARGLIST##_num_; \
 { \
-  RETDECL_##_returntype_ \
-  LOAD_GL_FUNC(gl##_name_,_ver_); \
-  RETSTAT_##_returntype_ fptr_gl##_name_(CALLCONV##_num_(targ1,targ2,targ3,targ4,targ5,targ6,targ7,targ8,targ9,targ10)); \
-  CHECK_GLERROR_FROM("gl" #_name_); \
-  return RETCONV_##_returntype_(ret) ; \
+	RETDECL_##_returntype_ \
+	LOAD_GL_FUNC(gl##_name_,_ver_); \
+	RETSTAT_##_returntype_ fptr_gl##_name_(CALLCONV##_num_(targ1,targ2,targ3,targ4,targ5,targ6,targ7,targ8,targ9,targ10)); \
+	CHECK_GLERROR_FROM("gl" #_name_); \
+	return RETCONV_##_returntype_(ret) ; \
 }
 
 #define GL_FUNC_STATIC(_num_,_name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,targ7,targ8,targ9,targ10) \
-  static VALUE \
+	static VALUE \
 gl_##_name_(obj ARGLIST##_num_) \
 VALUE obj ARGLIST##_num_; \
 { \
-  RETDECL_##_returntype_ \
-  RETSTAT_##_returntype_ gl##_name_(CALLCONV##_num_(targ1,targ2,targ3,targ4,targ5,targ6,targ7,targ8,targ9,targ10)); \
-  CHECK_GLERROR_FROM("gl" #_name_); \
-  return RETCONV_##_returntype_(ret) ; \
+	RETDECL_##_returntype_ \
+	RETSTAT_##_returntype_ gl##_name_(CALLCONV##_num_(targ1,targ2,targ3,targ4,targ5,targ6,targ7,targ8,targ9,targ10)); \
+	CHECK_GLERROR_FROM("gl" #_name_); \
+	return RETCONV_##_returntype_(ret) ; \
 }
 
 #define GL_FUNC_LOAD_0(_name_,_returntype_,_ver_) \
-  GL_FUNC_LOAD(0, _name_,_returntype_,0,0,0,0,0,0,0,0,0,0,_ver_)
+	GL_FUNC_LOAD(0, _name_,_returntype_,0,0,0,0,0,0,0,0,0,0,_ver_)
 #define GL_FUNC_LOAD_1(_name_,_returntype_,targ1,_ver_) \
-  GL_FUNC_LOAD(1, _name_,_returntype_,targ1,0,0,0,0,0,0,0,0,0,_ver_)
+	GL_FUNC_LOAD(1, _name_,_returntype_,targ1,0,0,0,0,0,0,0,0,0,_ver_)
 #define GL_FUNC_LOAD_2(_name_,_returntype_,targ1,targ2,_ver_) \
-  GL_FUNC_LOAD(2, _name_,_returntype_,targ1,targ2,0,0,0,0,0,0,0,0,_ver_)
+	GL_FUNC_LOAD(2, _name_,_returntype_,targ1,targ2,0,0,0,0,0,0,0,0,_ver_)
 #define GL_FUNC_LOAD_3(_name_,_returntype_,targ1,targ2,targ3,_ver_) \
-  GL_FUNC_LOAD(3, _name_,_returntype_,targ1,targ2,targ3,0,0,0,0,0,0,0,_ver_)
+	GL_FUNC_LOAD(3, _name_,_returntype_,targ1,targ2,targ3,0,0,0,0,0,0,0,_ver_)
 #define GL_FUNC_LOAD_4(_name_,_returntype_,targ1,targ2,targ3,targ4,_ver_) \
-  GL_FUNC_LOAD(4, _name_,_returntype_,targ1,targ2,targ3,targ4,0,0,0,0,0,0,_ver_)
+	GL_FUNC_LOAD(4, _name_,_returntype_,targ1,targ2,targ3,targ4,0,0,0,0,0,0,_ver_)
 #define GL_FUNC_LOAD_5(_name_,_returntype_,targ1,targ2,targ3,targ4,targ5,_ver_) \
-  GL_FUNC_LOAD(5, _name_,_returntype_,targ1,targ2,targ3,targ4,targ5,0,0,0,0,0,_ver_)
+	GL_FUNC_LOAD(5, _name_,_returntype_,targ1,targ2,targ3,targ4,targ5,0,0,0,0,0,_ver_)
 #define GL_FUNC_LOAD_6(_name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,_ver_) \
-  GL_FUNC_LOAD(6, _name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,0,0,0,0,_ver_)
+	GL_FUNC_LOAD(6, _name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,0,0,0,0,_ver_)
 #define GL_FUNC_LOAD_7(_name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,targ7,_ver_) \
-  GL_FUNC_LOAD(7, _name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,targ7,0,0,0,_ver_)
+	GL_FUNC_LOAD(7, _name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,targ7,0,0,0,_ver_)
 #define GL_FUNC_LOAD_8(_name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,targ7,targ8,_ver_) \
-  GL_FUNC_LOAD(8, _name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,targ7,targ8,0,0,_ver_)
+	GL_FUNC_LOAD(8, _name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,targ7,targ8,0,0,_ver_)
 #define GL_FUNC_LOAD_9(_name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,targ7,targ8,targ9,_ver_) \
-  GL_FUNC_LOAD(9, _name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,targ7,targ8,targ9,0,_ver_)
+	GL_FUNC_LOAD(9, _name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,targ7,targ8,targ9,0,_ver_)
 #define GL_FUNC_LOAD_10(_name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,targ7,targ8,targ9,targ10,_ver_) \
-  GL_FUNC_LOAD(10, _name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,targ7,targ8,targ9,targ10,_ver_)
+	GL_FUNC_LOAD(10, _name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,targ7,targ8,targ9,targ10,_ver_)
 
 #define GL_FUNC_STATIC_0(_name_,_returntype_) \
-  GL_FUNC_STATIC(0, _name_,_returntype_,0,0,0,0,0,0,0,0,0,0)
+	GL_FUNC_STATIC(0, _name_,_returntype_,0,0,0,0,0,0,0,0,0,0)
 #define GL_FUNC_STATIC_1(_name_,_returntype_,targ1) \
-  GL_FUNC_STATIC(1, _name_,_returntype_,targ1,0,0,0,0,0,0,0,0,0)
+	GL_FUNC_STATIC(1, _name_,_returntype_,targ1,0,0,0,0,0,0,0,0,0)
 #define GL_FUNC_STATIC_2(_name_,_returntype_,targ1,targ2) \
-  GL_FUNC_STATIC(2, _name_,_returntype_,targ1,targ2,0,0,0,0,0,0,0,0)
+	GL_FUNC_STATIC(2, _name_,_returntype_,targ1,targ2,0,0,0,0,0,0,0,0)
 #define GL_FUNC_STATIC_3(_name_,_returntype_,targ1,targ2,targ3) \
-  GL_FUNC_STATIC(3, _name_,_returntype_,targ1,targ2,targ3,0,0,0,0,0,0,0)
+	GL_FUNC_STATIC(3, _name_,_returntype_,targ1,targ2,targ3,0,0,0,0,0,0,0)
 #define GL_FUNC_STATIC_4(_name_,_returntype_,targ1,targ2,targ3,targ4) \
-  GL_FUNC_STATIC(4, _name_,_returntype_,targ1,targ2,targ3,targ4,0,0,0,0,0,0)
+	GL_FUNC_STATIC(4, _name_,_returntype_,targ1,targ2,targ3,targ4,0,0,0,0,0,0)
 #define GL_FUNC_STATIC_5(_name_,_returntype_,targ1,targ2,targ3,targ4,targ5) \
-  GL_FUNC_STATIC(5, _name_,_returntype_,targ1,targ2,targ3,targ4,targ5,0,0,0,0,0)
+	GL_FUNC_STATIC(5, _name_,_returntype_,targ1,targ2,targ3,targ4,targ5,0,0,0,0,0)
 #define GL_FUNC_STATIC_6(_name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6) \
-  GL_FUNC_STATIC(6, _name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,0,0,0,0)
+	GL_FUNC_STATIC(6, _name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,0,0,0,0)
 #define GL_FUNC_STATIC_7(_name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,targ7) \
-  GL_FUNC_STATIC(7, _name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,targ7,0,0,0)
+	GL_FUNC_STATIC(7, _name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,targ7,0,0,0)
 #define GL_FUNC_STATIC_8(_name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,targ7,targ8) \
-  GL_FUNC_STATIC(8, _name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,targ7,targ8,0,0)
+	GL_FUNC_STATIC(8, _name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,targ7,targ8,0,0)
 #define GL_FUNC_STATIC_9(_name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,targ7,targ8,targ9) \
-  GL_FUNC_STATIC(9, _name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,targ7,targ8,targ9,0)
+	GL_FUNC_STATIC(9, _name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,targ7,targ8,targ9,0)
 #define GL_FUNC_STATIC_10(_name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,targ7,targ8,targ9,targ10_ver_) \
-  GL_FUNC_STATIC(10, _name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,targ7,targ8,targ9,targ10)
+	GL_FUNC_STATIC(10, _name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,targ7,targ8,targ9,targ10)
 
 /* Templates for glGen* and glDelete* */
 
 #define GL_FUNC_GENOBJECTS_LOAD(_name_,_ver_) \
-  static void (APIENTRY * fptr_gl##_name_)(GLsizei,GLuint *); \
+	static void (APIENTRY * fptr_gl##_name_)(GLsizei,GLuint *); \
 static VALUE gl_##_name_(VALUE obj,VALUE arg1) \
 { \
-  GLsizei n; \
-  GLuint *objects; \
-  VALUE ret; \
-  GLsizei i; \
-  LOAD_GL_FUNC(gl##_name_,_ver_); \
-  n = CONV_GLsizei(arg1); \
-  objects = ALLOC_N(GLuint, n); \
-  fptr_gl##_name_(n,objects); \
-  ret = rb_ary_new2(n); \
-  for (i = 0; i < n; i++) \
-  rb_ary_push(ret, RETCONV_GLuint(objects[i])); \
-  xfree(objects); \
-  CHECK_GLERROR_FROM("gl" #_name_); \
-  return ret; \
+	GLsizei n; \
+	GLuint *objects; \
+	VALUE ret; \
+	GLsizei i; \
+	LOAD_GL_FUNC(gl##_name_,_ver_); \
+	n = CONV_GLsizei(arg1); \
+	objects = ALLOC_N(GLuint, n); \
+	fptr_gl##_name_(n,objects); \
+	ret = rb_ary_new2(n); \
+	for (i = 0; i < n; i++) \
+	rb_ary_push(ret, RETCONV_GLuint(objects[i])); \
+	xfree(objects); \
+	CHECK_GLERROR_FROM("gl" #_name_); \
+	return ret; \
 }
 
 #define GL_FUNC_GENOBJECTS(_name_) \
-  static VALUE gl_##_name_(VALUE obj,VALUE arg1) \
+	static VALUE gl_##_name_(VALUE obj,VALUE arg1) \
 { \
-  GLsizei n; \
-  GLuint *objects; \
-  VALUE ret; \
-  GLsizei i; \
-  n = CONV_GLsizei(arg1); \
-  objects = ALLOC_N(GLuint, n); \
-  gl##_name_(n,objects); \
-  ret = rb_ary_new2(n); \
-  for (i = 0; i < n; i++) \
-  rb_ary_push(ret, RETCONV_GLuint(objects[i])); \
-  xfree(objects); \
-  CHECK_GLERROR_FROM("gl" #_name_); \
-  return ret; \
+	GLsizei n; \
+	GLuint *objects; \
+	VALUE ret; \
+	GLsizei i; \
+	n = CONV_GLsizei(arg1); \
+	objects = ALLOC_N(GLuint, n); \
+	gl##_name_(n,objects); \
+	ret = rb_ary_new2(n); \
+	for (i = 0; i < n; i++) \
+	rb_ary_push(ret, RETCONV_GLuint(objects[i])); \
+	xfree(objects); \
+	CHECK_GLERROR_FROM("gl" #_name_); \
+	return ret; \
 }
 
 #define GL_FUNC_DELETEOBJECTS_LOAD(_name_,_ver_) \
-  static void (APIENTRY * fptr_gl##_name_)(GLsizei,const GLuint *); \
+	static void (APIENTRY * fptr_gl##_name_)(GLsizei,const GLuint *); \
 static VALUE gl_##_name_(VALUE obj,VALUE arg1) \
 { \
-  GLsizei n; \
-  LOAD_GL_FUNC(gl##_name_,_ver_); \
-  if (TYPE(arg1)==T_ARRAY) { \
-    GLuint *objects; \
-    n = (GLsizei)RARRAY_LENINT(arg1); \
-    objects = ALLOC_N(GLuint,n); \
-    ary2cuint(arg1,objects,n);  \
-    fptr_gl##_name_(n,objects); \
-    xfree(objects); \
-  } else { \
-    GLuint object; \
-    object = CONV_GLsizei(arg1); \
-    fptr_gl##_name_(1,&object);  \
-  } \
-  CHECK_GLERROR_FROM("gl" #_name_); \
-  return Qnil; \
+	GLsizei n; \
+	LOAD_GL_FUNC(gl##_name_,_ver_); \
+	if (TYPE(arg1)==T_ARRAY) { \
+		GLuint *objects; \
+		n = (GLsizei)RARRAY_LENINT(arg1); \
+		objects = ALLOC_N(GLuint,n); \
+		ary2cuint(arg1,objects,n);  \
+		fptr_gl##_name_(n,objects); \
+		xfree(objects); \
+	} else { \
+		GLuint object; \
+		object = CONV_GLsizei(arg1); \
+		fptr_gl##_name_(1,&object);  \
+	} \
+	CHECK_GLERROR_FROM("gl" #_name_); \
+	return Qnil; \
 }
 
 #define GL_FUNC_DELETEOBJECTS(_name_) \
-  static VALUE gl_##_name_(VALUE obj,VALUE arg1) \
+	static VALUE gl_##_name_(VALUE obj,VALUE arg1) \
 { \
-  GLsizei n; \
-  if (TYPE(arg1)==T_ARRAY) { \
-    GLuint *objects; \
-    n = (GLsizei)RARRAY_LENINT(arg1); \
-    objects = ALLOC_N(GLuint,n); \
-    ary2cuint(arg1,objects,n);  \
-    gl##_name_(n,objects); \
-    xfree(objects); \
-  } else { \
-    GLuint object; \
-    object = CONV_GLsizei(arg1); \
-    gl##_name_(1,&object);  \
-  } \
-  CHECK_GLERROR_FROM("gl" #_name_); \
-  return Qnil; \
+	GLsizei n; \
+	if (TYPE(arg1)==T_ARRAY) { \
+		GLuint *objects; \
+		n = (GLsizei)RARRAY_LENINT(arg1); \
+		objects = ALLOC_N(GLuint,n); \
+		ary2cuint(arg1,objects,n);  \
+		gl##_name_(n,objects); \
+		xfree(objects); \
+	} else { \
+		GLuint object; \
+		object = CONV_GLsizei(arg1); \
+		gl##_name_(1,&object);  \
+	} \
+	CHECK_GLERROR_FROM("gl" #_name_); \
+	return Qnil; \
 }