opengl 0.9.2-x64-mingw32 → 0.10.0-x64-mingw32

data/ext/opengl/funcdef.h

@@ -13,6 +13,9 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
+#ifndef _FUNCDEF_H_
+#define _FUNCDEF_H_
+
 /*
 	These macros are for simplification of function definition, as passing
 	arguments from/to OpenGL usually follows the same few patterns. It would
@@ -29,23 +32,24 @@
  * 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 { \
+    fptr_##_NAME_ = GET_GLIMPL_VARIABLE(glfuncs._NAME_); \
+    if (fptr_##_NAME_==NULL){ \
+      if (_VEREXT_) EnsureVersionExtension(obj, (_VEREXT_)); \
+      fptr_##_NAME_ = GET_GLIMPL_VARIABLE(load_gl_function)(obj,#_NAME_, 1); \
+      SET_GLIMPL_VARIABLE(glfuncs._NAME_,fptr_##_NAME_); \
+    } \
+  } while (0)
+
+#if defined(GLFUNC_MAGIC_START)
+  #define DECL_GL_FUNC_PTR(_returntype_,_name_,_args_) \
+    GLFUNC_MAGIC_START _returntype_ (GLFUNC_MAGIC_APIENTRY * _name_)_args_ GLFUNC_MAGIC_END
+#else
+  #define DECL_GL_FUNC_PTR(_returntype_,_name_,_args_) \
+    _returntype_ (APIENTRY * fptr_##_name_)_args_ = NULL
+#endif
 
-/* 
+/*
 	Macroset for defining simple functions, i.e. functions that take n arguments and
 	pass them to GL API function without any additional processing.
 
@@ -148,7 +152,7 @@
 #define PROTOPARAM9(p1,p2,p3,p4,p5,p6,p7,p8,p9,p10) p1,p2,p3,p4,p5,p6,p7,p8,p9
 #define PROTOPARAM10(p1,p2,p3,p4,p5,p6,p7,p8,p9,p10) p1,p2,p3,p4,p5,p6,p7,p8,p9,p10
 
-#define CALLCONV0(cv1,cv2,cv3,cv4,cv5,cv6,cv7,cv8,cv9,cv10) 
+#define CALLCONV0(cv1,cv2,cv3,cv4,cv5,cv6,cv7,cv8,cv9,cv10)
 #define CALLCONV1(cv1,cv2,cv3,cv4,cv5,cv6,cv7,cv8,cv9,cv10) CONV_##cv1(arg1)
 #define CALLCONV2(cv1,cv2,cv3,cv4,cv5,cv6,cv7,cv8,cv9,cv10) CONV_##cv1(arg1),CONV_##cv2(arg2)
 #define CALLCONV3(cv1,cv2,cv3,cv4,cv5,cv6,cv7,cv8,cv9,cv10) CONV_##cv1(arg1),CONV_##cv2(arg2),CONV_##cv3(arg3)
@@ -161,12 +165,12 @@
 #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 VALUE \
 gl_##_name_(obj ARGLIST##_num_) \
 VALUE obj ARGLIST##_num_; \
 { \
 	RETDECL_##_returntype_ \
+	DECL_GL_FUNC_PTR(_returntype_,gl##_name_,(PROTOPARAM##_num_(targ1,targ2,targ3,targ4,targ5,targ6,targ7,targ8,targ9,targ10))); \
 	LOAD_GL_FUNC(gl##_name_,_ver_); \
 	RETSTAT_##_returntype_ fptr_gl##_name_(CALLCONV##_num_(targ1,targ2,targ3,targ4,targ5,targ6,targ7,targ8,targ9,targ10)); \
 	CHECK_GLERROR_FROM("gl" #_name_); \
@@ -174,15 +178,7 @@ VALUE obj ARGLIST##_num_; \
 }
 
 #define GL_FUNC_STATIC(_num_,_name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,targ7,targ8,targ9,targ10) \
-	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) ; \
-}
+  GL_FUNC_LOAD(_num_,_name_,_returntype_,targ1,targ2,targ3,targ4,targ5,targ6,targ7,targ8,targ9,targ10,NULL)
 
 #define GL_FUNC_LOAD_0(_name_,_returntype_,_ver_) \
 	GL_FUNC_LOAD(0, _name_,_returntype_,0,0,0,0,0,0,0,0,0,0,_ver_)
@@ -233,13 +229,13 @@ VALUE obj ARGLIST##_num_; \
 /* Templates for glGen* and glDelete* */
 
 #define GL_FUNC_GENOBJECTS_LOAD(_name_,_ver_) \
-	static void (APIENTRY * fptr_gl##_name_)(GLsizei,GLuint *); \
 static VALUE gl_##_name_(VALUE obj,VALUE arg1) \
 { \
 	GLsizei n; \
 	GLuint *objects; \
 	VALUE ret; \
 	GLsizei i; \
+  DECL_GL_FUNC_PTR(GLvoid,gl##_name_,(GLsizei,GLuint *)); \
 	LOAD_GL_FUNC(gl##_name_,_ver_); \
 	n = CONV_GLsizei(arg1); \
 	objects = ALLOC_N(GLuint, n); \
@@ -253,28 +249,13 @@ static VALUE gl_##_name_(VALUE obj,VALUE arg1) \
 }
 
 #define GL_FUNC_GENOBJECTS(_name_) \
-	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; \
-}
+  GL_FUNC_GENOBJECTS_LOAD(_name_,"1.1")
 
 #define GL_FUNC_DELETEOBJECTS_LOAD(_name_,_ver_) \
-	static void (APIENTRY * fptr_gl##_name_)(GLsizei,const GLuint *); \
 static VALUE gl_##_name_(VALUE obj,VALUE arg1) \
 { \
 	GLsizei n; \
+  DECL_GL_FUNC_PTR(GLvoid,gl##_name_,(GLsizei,const GLuint *)); \
 	LOAD_GL_FUNC(gl##_name_,_ver_); \
 	if (TYPE(arg1)==T_ARRAY) { \
 		GLuint *objects; \
@@ -293,21 +274,6 @@ static VALUE gl_##_name_(VALUE obj,VALUE arg1) \
 }
 
 #define GL_FUNC_DELETEOBJECTS(_name_) \
-	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; \
-}
+  GL_FUNC_DELETEOBJECTS_LOAD(_name_,"1.1")
+
+#endif

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

@@ -197,15 +197,21 @@ GL_FUNC_STATIC_4(Vertex4i,GLvoid, GLint,GLint,GLint,GLint)
 GL_FUNC_STATIC_4(Vertex4s,GLvoid, GLshort,GLshort,GLshort,GLshort)
 GL_FUNC_STATIC_4(Viewport,GLvoid, GLuint,GLuint,GLuint,GLuint)
 
-VALUE inside_begin_end = Qfalse;
+struct gl_endisable_args {
+    VALUE obj;
+    VALUE caps;
+  };
 
 static VALUE
-gl_Enable1(VALUE caps)
+gl_Enable1(struct gl_endisable_args *args)
 {
   long i;
+  VALUE obj = args->obj;
+  DECL_GL_FUNC_PTR(void,glEnable,(GLenum cap));
 
-  for (i = 0; i < RARRAY_LEN(caps); i++) {
-    glEnable(CONV_GLenum(rb_ary_entry(caps, i)));
+  LOAD_GL_FUNC(glEnable, NULL);
+  for (i = 0; i < RARRAY_LEN(args->caps); i++) {
+    fptr_glEnable(CONV_GLenum(rb_ary_entry(args->caps, i)));
 
     CHECK_GLERROR_FROM("glEnable");
   }
@@ -214,9 +220,9 @@ gl_Enable1(VALUE caps)
 }
 
 static VALUE
-gl_Enable0(VALUE caps)
+gl_Enable0(struct gl_endisable_args *args)
 {
-  gl_Enable1(caps);
+  gl_Enable1(args);
 
   if (rb_block_given_p())
     rb_yield(Qundef);
@@ -225,11 +231,15 @@ gl_Enable0(VALUE caps)
 }
 
 static VALUE
-gl_Disable1(VALUE caps)
+gl_Disable1(struct gl_endisable_args *args)
 {
   long i;
-  for (i = 0; i < RARRAY_LEN(caps); i++) {
-    glDisable(CONV_GLenum(rb_ary_entry(caps, i)));
+  VALUE obj = args->obj;
+  DECL_GL_FUNC_PTR(void,glDisable,(GLenum cap));
+
+  LOAD_GL_FUNC(glDisable, NULL);
+  for (i = 0; i < RARRAY_LEN(args->caps); i++) {
+    fptr_glDisable(CONV_GLenum(rb_ary_entry(args->caps, i)));
 
     CHECK_GLERROR_FROM("glDisable");
   }
@@ -238,9 +248,9 @@ gl_Disable1(VALUE caps)
 }
 
 static VALUE
-gl_Disable0(VALUE caps)
+gl_Disable0(struct gl_endisable_args *args)
 {
-  gl_Disable1(caps);
+  gl_Disable1(args);
 
   if (rb_block_given_p())
     rb_yield(Qundef);
@@ -249,7 +259,7 @@ gl_Disable0(VALUE caps)
 }
 
 static VALUE
-gl_Enable(int argc, VALUE *argv, VALUE self)
+gl_Enable(int argc, VALUE *argv, VALUE obj)
 {
   int i;
   VALUE caps, rev;
@@ -263,16 +273,20 @@ gl_Enable(int argc, VALUE *argv, VALUE self)
 
   rev = rb_ary_reverse(caps);
 
-  if (rb_block_given_p())
-    return rb_ensure(gl_Enable0, caps, gl_Disable1, rev);
-  else
-    gl_Enable0(caps);
+  if (rb_block_given_p()){
+    struct gl_endisable_args enargs = { obj, caps };
+    struct gl_endisable_args disargs = { obj, rev };
+    return rb_ensure(gl_Enable0, (VALUE)&enargs, gl_Disable1, (VALUE)&disargs);
+  } else {
+    struct gl_endisable_args args = { obj, caps };
+    gl_Enable0(&args);
+  }
 
   return Qnil;
 }
 
 static VALUE
-gl_Disable(int argc, VALUE *argv, VALUE self)
+gl_Disable(int argc, VALUE *argv, VALUE obj)
 {
   int i;
   VALUE caps, rev;
@@ -286,20 +300,33 @@ gl_Disable(int argc, VALUE *argv, VALUE self)
 
   rev = rb_ary_reverse(caps);
 
-  if (rb_block_given_p())
-    return rb_ensure(gl_Disable0, caps, gl_Enable1, rev);
-  else
-    gl_Disable0(caps);
+  if (rb_block_given_p()){
+    struct gl_endisable_args disargs = { obj, caps };
+    struct gl_endisable_args enargs = { obj, rev };
+    return rb_ensure(gl_Disable0, (VALUE)&disargs, gl_Enable1, (VALUE)&enargs);
+  } else {
+    struct gl_endisable_args args = { obj, caps };
+    gl_Disable0(&args);
+  }
 
   return Qnil;
 }
 
+struct gl_client_state_args {
+    VALUE obj;
+    VALUE ary;
+  };
+
 static VALUE
-gl_EnableClientState1(VALUE ary)
+gl_EnableClientState1(struct gl_client_state_args *args)
 {
   long i;
-  for (i = 0; i < RARRAY_LEN(ary); i++) {
-    glEnableClientState(CONV_GLenum(rb_ary_entry(ary, i)));
+  VALUE obj = args->obj;
+  DECL_GL_FUNC_PTR(void,glEnableClientState,(GLenum cap));
+
+  LOAD_GL_FUNC(glEnableClientState, NULL);
+  for (i = 0; i < RARRAY_LEN(args->ary); i++) {
+    fptr_glEnableClientState(CONV_GLenum(rb_ary_entry(args->ary, i)));
 
     CHECK_GLERROR_FROM("glEnableClientState");
   }
@@ -308,9 +335,9 @@ gl_EnableClientState1(VALUE ary)
 }
 
 static VALUE
-gl_EnableClientState0(VALUE ary)
+gl_EnableClientState0(struct gl_client_state_args *args)
 {
-  gl_EnableClientState1(ary);
+  gl_EnableClientState1(args);
 
   if (rb_block_given_p())
     rb_yield(Qundef);
@@ -319,11 +346,15 @@ gl_EnableClientState0(VALUE ary)
 }
 
 static VALUE
-gl_DisableClientState1(VALUE ary)
+gl_DisableClientState1(struct gl_client_state_args *args)
 {
   long i;
-  for (i = 0; i < RARRAY_LEN(ary); i++) {
-    glDisableClientState(CONV_GLenum(rb_ary_entry(ary, i)));
+  VALUE obj = args->obj;
+  DECL_GL_FUNC_PTR(void,glDisableClientState,(GLenum cap));
+
+  LOAD_GL_FUNC(glDisableClientState, NULL);
+  for (i = 0; i < RARRAY_LEN(args->ary); i++) {
+    fptr_glDisableClientState(CONV_GLenum(rb_ary_entry(args->ary, i)));
 
     CHECK_GLERROR_FROM("glDisableClientState");
   }
@@ -332,9 +363,9 @@ gl_DisableClientState1(VALUE ary)
 }
 
 static VALUE
-gl_DisableClientState0(VALUE ary)
+gl_DisableClientState0(struct gl_client_state_args *args)
 {
-  gl_DisableClientState1(ary);
+  gl_DisableClientState1(args);
 
   if (rb_block_given_p())
     rb_yield(Qundef);
@@ -343,7 +374,7 @@ gl_DisableClientState0(VALUE ary)
 }
 
 static VALUE
-gl_EnableClientState(int argc, VALUE *argv, VALUE self)
+gl_EnableClientState(int argc, VALUE *argv, VALUE obj)
 {
   int i;
   VALUE ary, rev;
@@ -357,16 +388,20 @@ gl_EnableClientState(int argc, VALUE *argv, VALUE self)
 
   rev = rb_ary_reverse(ary);
 
-  if (rb_block_given_p())
-    return rb_ensure(gl_EnableClientState0, ary, gl_DisableClientState1, rev);
-  else
-    gl_EnableClientState0(ary);
+  if (rb_block_given_p()){
+    struct gl_client_state_args enargs = { obj, ary };
+    struct gl_client_state_args disargs = { obj, rev };
+    return rb_ensure(gl_EnableClientState0, (VALUE)&enargs, gl_DisableClientState1, (VALUE)&disargs);
+  } else {
+    struct gl_client_state_args args = { obj, ary };
+    gl_EnableClientState0(&args);
+  }
 
   return Qnil;
 }
 
 static VALUE
-gl_DisableClientState(int argc, VALUE *argv, VALUE self)
+gl_DisableClientState(int argc, VALUE *argv, VALUE obj)
 {
   int i;
   VALUE ary, rev;
@@ -380,18 +415,31 @@ gl_DisableClientState(int argc, VALUE *argv, VALUE self)
 
   rev = rb_ary_reverse(ary);
 
-  if (rb_block_given_p())
-    return rb_ensure(gl_DisableClientState0, ary, gl_EnableClientState1, rev);
-  else
-    gl_DisableClientState0(ary);
+  if (rb_block_given_p()){
+    struct gl_client_state_args disargs = { obj, ary };
+    struct gl_client_state_args enargs = { obj, rev };
+    return rb_ensure(gl_DisableClientState0, (VALUE)&disargs, gl_EnableClientState1, (VALUE)&enargs);
+  } else {
+    struct gl_client_state_args args = { obj, ary };
+    gl_DisableClientState0(&args);
+  }
 
   return Qnil;
 }
 
+struct gl_begin0_args {
+    VALUE obj;
+    GLenum mode;
+  };
+
 static VALUE
-gl_Begin0(GLenum mode)
+gl_Begin0(struct gl_begin0_args *args)
 {
-  glBegin(mode);
+  VALUE obj = args->obj;
+  DECL_GL_FUNC_PTR(void,glBegin,(GLenum mode));
+
+  LOAD_GL_FUNC(glBegin, NULL);
+  fptr_glBegin(args->mode);
 
   if (rb_block_given_p())
     rb_yield(Qundef);
@@ -400,11 +448,14 @@ gl_Begin0(GLenum mode)
 }
 
 static VALUE
-gl_End(VALUE self)
+gl_End(VALUE obj)
 {
-  inside_begin_end = Qfalse;
+  DECL_GL_FUNC_PTR(void,glEnd,(void));
+
+  LOAD_GL_FUNC(glEnd, NULL);
+  SET_GLIMPL_VARIABLE(inside_begin_end, Qfalse);
 
-  glEnd();
+  fptr_glEnd();
 
   CHECK_GLERROR_FROM("glEnd");
 
@@ -412,23 +463,27 @@ gl_End(VALUE self)
 }
 
 static VALUE
-gl_Begin(VALUE self, VALUE mode)
+gl_Begin(VALUE obj, VALUE mode)
 {
-  GLenum begin_mode = CONV_GLenum(mode);
-  inside_begin_end = Qtrue;
+  struct gl_begin0_args args = { obj, CONV_GLenum(mode) };
+
+  SET_GLIMPL_VARIABLE(inside_begin_end, Qtrue);
 
   if (rb_block_given_p())
-    return rb_ensure(gl_Begin0, (VALUE)begin_mode, gl_End, self);
+    return rb_ensure(gl_Begin0, (VALUE)&args, gl_End, obj);
   else
-    gl_Begin0(begin_mode);
+    gl_Begin0(&args);
 
   return Qnil;
 }
 
 static VALUE
-gl_PopMatrix(VALUE self)
+gl_PopMatrix(VALUE obj)
 {
-  glPopMatrix();
+  DECL_GL_FUNC_PTR(void,glPopMatrix,(void));
+
+  LOAD_GL_FUNC(glPopMatrix, NULL);
+  fptr_glPopMatrix();
 
   CHECK_GLERROR_FROM("glPopMatrix");
 
@@ -436,9 +491,12 @@ gl_PopMatrix(VALUE self)
 }
 
 static VALUE
-gl_PushMatrix0(void)
+gl_PushMatrix0(VALUE obj)
 {
-  glPushMatrix();
+  DECL_GL_FUNC_PTR(void,glPushMatrix,(void));
+
+  LOAD_GL_FUNC(glPushMatrix, NULL);
+  fptr_glPushMatrix();
 
   if (rb_block_given_p())
     rb_yield(Qnil);
@@ -447,26 +505,38 @@ gl_PushMatrix0(void)
 }
 
 static VALUE
-gl_PushMatrix(VALUE self)
+gl_PushMatrix(VALUE obj)
 {
   if (rb_block_given_p())
-    return rb_ensure(gl_PushMatrix0, (VALUE)NULL, gl_PopMatrix, self);
-  else
-    glPushMatrix();
+    return rb_ensure(gl_PushMatrix0, obj, gl_PopMatrix, obj);
+  else {
+    DECL_GL_FUNC_PTR(void,glPushMatrix,(void));
+    LOAD_GL_FUNC(glPushMatrix, NULL);
+    fptr_glPushMatrix();
+  }
 
   return Qnil;
 }
 
+struct gl_list_args {
+  VALUE obj;
+  VALUE list;
+  VALUE mode;
+};
+
 static VALUE
-gl_NewList0(VALUE args)
+gl_NewList0(struct gl_list_args *args)
 {
   GLuint list;
   GLenum mode;
+  VALUE obj = args->obj;
+  DECL_GL_FUNC_PTR(void,glNewList,(GLuint list, GLenum mode));
 
-  list = (GLuint)NUM2UINT(rb_ary_entry(args, 0));
-  mode = RUBY2GLENUM(rb_ary_entry(args, 1));
+  LOAD_GL_FUNC(glNewList, NULL);
+  list = (GLuint)NUM2UINT(args->list);
+  mode = RUBY2GLENUM(args->mode);
 
-  glNewList(list, mode);
+  fptr_glNewList(list, mode);
 
   if (rb_block_given_p())
     rb_yield(Qundef);
@@ -475,24 +545,25 @@ gl_NewList0(VALUE args)
 }
 
 static VALUE
-gl_EndList(VALUE self)
+gl_EndList(VALUE obj)
 {
-  glEndList();
+  DECL_GL_FUNC_PTR(void,glEndList,(void));
+
+  LOAD_GL_FUNC(glEndList, NULL);
+  fptr_glEndList();
 
   return Qnil;
 }
 
 static VALUE
-gl_NewList(VALUE self, VALUE list, VALUE mode)
+gl_NewList(VALUE obj, VALUE list, VALUE mode)
 {
-  VALUE args = rb_ary_new2(2);
-  rb_ary_push(args, list);
-  rb_ary_push(args, mode);
+  struct gl_list_args args = { obj, list, mode };
 
   if (rb_block_given_p())
-    return rb_ensure(gl_NewList0, args, gl_EndList, self);
+    return rb_ensure(gl_NewList0, (VALUE)&args, gl_EndList, obj);
   else
-    gl_NewList0(args);
+    gl_NewList0(&args);
 
   return Qnil;
 }
@@ -504,10 +575,13 @@ VALUE obj,arg1,arg2;
   GLsizei n;
   GLenum type;
   VALUE lists;
+  DECL_GL_FUNC_PTR(GLvoid,glCallLists,(GLsizei n, GLenum type, const GLvoid *lists));
+
+  LOAD_GL_FUNC(glCallLists, NULL);
   type = CONV_GLenum(arg1);
   lists = pack_array_or_pass_string(type,arg2);
   n = (GLsizei)RSTRING_LENINT(lists) / gltype_glformat_unit_size(type,1);
-  glCallLists(n, type, RSTRING_PTR(lists));
+  fptr_glCallLists(n, type, RSTRING_PTR(lists));
   CHECK_GLERROR_FROM("glCallLists");
   return Qnil;
 }
@@ -522,14 +596,17 @@ VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6,arg7;
   GLfloat yorig;
   GLfloat xmove;
   GLfloat ymove;
+  DECL_GL_FUNC_PTR(void,glBitmap,(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap));
+
+  LOAD_GL_FUNC(glBitmap, NULL);
   width = (GLsizei)NUM2UINT(arg1);
   height = (GLsizei)NUM2UINT(arg2);
   xorig = (GLfloat)NUM2DBL(arg3);
   yorig = (GLfloat)NUM2DBL(arg4);
   xmove = (GLfloat)NUM2DBL(arg5);
   ymove = (GLfloat)NUM2DBL(arg6);
-  if (CheckBufferBinding(GL_PIXEL_UNPACK_BUFFER_BINDING)) {
-    glBitmap(width, height, xorig, yorig, xmove, ymove, (GLubyte *)NUM2SIZET(arg7));
+  if (CHECK_BUFFER_BINDING(GL_PIXEL_UNPACK_BUFFER_BINDING)) {
+    fptr_glBitmap(width, height, xorig, yorig, xmove, ymove, (GLubyte *)NUM2SIZET(arg7));
   } else {
     VALUE data;
     data = pack_array_or_pass_string(GL_UNSIGNED_BYTE,arg7);
@@ -537,7 +614,7 @@ VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6,arg7;
     if ((RSTRING_LEN(data)*8) < (width * height))
       rb_raise(rb_eArgError, "string length:%li", RSTRING_LEN(data));
 
-    glBitmap(width, height, xorig, yorig, xmove, ymove, (const GLubyte *)RSTRING_PTR(data));
+    fptr_glBitmap(width, height, xorig, yorig, xmove, ymove, (const GLubyte *)RSTRING_PTR(data));
   }
   CHECK_GLERROR_FROM("glBitmap");
   return Qnil;
@@ -548,9 +625,12 @@ gl_EdgeFlagv(obj,arg1)
 VALUE obj,arg1;
 {
   GLboolean flag[1] = { GL_FALSE };
+  DECL_GL_FUNC_PTR(void,glEdgeFlagv,(const GLboolean *flag));
+
+  LOAD_GL_FUNC(glEdgeFlagv, NULL);
   Check_Type(arg1,T_ARRAY);
   ary2cboolean(arg1,flag,1);
-  glEdgeFlagv(flag);
+  fptr_glEdgeFlagv(flag);
   CHECK_GLERROR_FROM("glEdgeFlagv");
   return Qnil;
 }
@@ -560,9 +640,12 @@ gl_Indexdv(obj,arg1)
 VALUE obj,arg1;
 {
   GLdouble c[1] = {0.0};
+  DECL_GL_FUNC_PTR(void,glIndexdv,(const GLdouble *c));
+
+  LOAD_GL_FUNC(glIndexdv, NULL);
   Check_Type(arg1,T_ARRAY);
   ary2cdbl(arg1,c,1);
-  glIndexdv(c);
+  fptr_glIndexdv(c);
   CHECK_GLERROR_FROM("glIndexdv");
   return Qnil;
 }
@@ -572,9 +655,12 @@ gl_Indexfv(obj,arg1)
 VALUE obj,arg1;
 {
   GLfloat c[1] = { (GLfloat)0.0 };
+  DECL_GL_FUNC_PTR(void,glIndexfv,(const GLfloat *c));
+
+  LOAD_GL_FUNC(glIndexfv, NULL);
   Check_Type(arg1,T_ARRAY);
   ary2cflt(arg1,c,1);
-  glIndexfv(c);
+  fptr_glIndexfv(c);
   CHECK_GLERROR_FROM("glIndexfv");
   return Qnil;
 }
@@ -584,9 +670,12 @@ gl_Indexiv(obj,arg1)
 VALUE obj,arg1;
 {
   GLint c[1] = {0};
+  DECL_GL_FUNC_PTR(void,glIndexiv,(const GLint *c));
+
+  LOAD_GL_FUNC(glIndexiv, NULL);
   Check_Type(arg1,T_ARRAY);
   ary2cint(arg1,c,1);
-  glIndexiv(c);
+  fptr_glIndexiv(c);
   CHECK_GLERROR_FROM("glIndexiv");
   return Qnil;
 }
@@ -596,9 +685,12 @@ gl_Indexsv(obj,arg1)
 VALUE obj,arg1;
 {
   GLshort c[1] = {0};
+  DECL_GL_FUNC_PTR(void,glIndexsv,(const GLshort *c));
+
+  LOAD_GL_FUNC(glIndexsv, NULL);
   Check_Type(arg1,T_ARRAY);
   ary2cshort(arg1,c,1);
-  glIndexsv(c);
+  fptr_glIndexsv(c);
   CHECK_GLERROR_FROM("glIndexsv");
   return Qnil;
 }
@@ -609,10 +701,13 @@ VALUE obj,arg1,arg2;
 {
   GLenum plane;
   GLdouble equation[4];
+  DECL_GL_FUNC_PTR(void,glClipPlane,(GLenum plane, const GLdouble *equation));
+
+  LOAD_GL_FUNC(glClipPlane, NULL);
   plane = (GLenum)NUM2INT(arg1);
   Check_Type(arg2,T_ARRAY);
   ary2cdbl(arg2, equation, 4);
-  glClipPlane(plane,equation);
+  fptr_glClipPlane(plane,equation);
   CHECK_GLERROR_FROM("glClipPlane");
   return Qnil;
 }
@@ -623,10 +718,13 @@ VALUE obj,arg1,arg2;
 {
   GLenum pname;
   GLfloat params[4] = {(GLfloat)0.0, (GLfloat)0.0, (GLfloat)0.0, (GLfloat)0.0};
+  DECL_GL_FUNC_PTR(void,glFogfv,(GLenum pname, const GLfloat *params));
+
+  LOAD_GL_FUNC(glFogfv, NULL);
   pname = (GLenum)NUM2INT(arg1);
   Check_Type(arg2,T_ARRAY);
   ary2cflt(arg2,params,4);
-  glFogfv(pname,params);
+  fptr_glFogfv(pname,params);
   CHECK_GLERROR_FROM("glFogfv");
   return Qnil;
 }
@@ -637,10 +735,13 @@ VALUE obj,arg1,arg2;
 {
   GLenum pname;
   GLint params[4] = {0,0,0,0};
+  DECL_GL_FUNC_PTR(void,glFogiv,(GLenum pname, const GLint *params));
+
+  LOAD_GL_FUNC(glFogiv, NULL);
   pname = (GLenum)NUM2INT(arg1);
   Check_Type(arg2,T_ARRAY);
   ary2cint(arg2,params,4);
-  glFogiv(pname,params);
+  fptr_glFogiv(pname,params);
   CHECK_GLERROR_FROM("glFogiv");
   return Qnil;
 }
@@ -652,11 +753,14 @@ VALUE obj,arg1,arg2,arg3;
   GLenum light;
   GLenum pname;
   GLfloat params[4] = {(GLfloat)0.0, (GLfloat)0.0, (GLfloat)0.0, (GLfloat)0.0};
+  DECL_GL_FUNC_PTR(void,glLightfv,(GLenum light, GLenum pname, const GLfloat *params));
+
+  LOAD_GL_FUNC(glLightfv, NULL);
   light = (GLenum)NUM2INT(arg1);
   pname = (GLenum)NUM2INT(arg2);
   Check_Type(arg3,T_ARRAY);
   ary2cflt(arg3,params,4);
-  glLightfv(light,pname,params);
+  fptr_glLightfv(light,pname,params);
   CHECK_GLERROR_FROM("glLightfv");
   return Qnil;
 }
@@ -668,11 +772,14 @@ VALUE obj,arg1,arg2,arg3;
   GLenum light;
   GLenum pname;
   GLint params[4]={0,0,0,0};
+  DECL_GL_FUNC_PTR(void,glLightiv,(GLenum light, GLenum pname, const GLint *params));
+
+  LOAD_GL_FUNC(glLightiv, NULL);
   light = (GLenum)NUM2INT(arg1);
   pname = (GLenum)NUM2INT(arg2);
   Check_Type(arg3,T_ARRAY);
   ary2cint(arg3,params,4);
-  glLightiv(light,pname,params);
+  fptr_glLightiv(light,pname,params);
   CHECK_GLERROR_FROM("glLightiv");
   return Qnil;
 }
@@ -683,10 +790,13 @@ VALUE obj,arg1,arg2;
 {
   GLenum pname;
   GLfloat params[4] = {(GLfloat)0.0, (GLfloat)0.0, (GLfloat)0.0, (GLfloat)0.0};
+  DECL_GL_FUNC_PTR(void,glLightModelfv,(GLenum pname, const GLfloat *params));
+
+  LOAD_GL_FUNC(glLightModelfv, NULL);
   pname = (GLenum)NUM2INT(arg1);
   Check_Type(arg2,T_ARRAY);
   ary2cflt(arg2,params,4);
-  glLightModelfv(pname,params);
+  fptr_glLightModelfv(pname,params);
   CHECK_GLERROR_FROM("glLightModelfv");
   return Qnil;
 }
@@ -697,10 +807,13 @@ VALUE obj,arg1,arg2;
 {
   GLenum pname;
   GLint params[4] = {0,0,0,0};
+  DECL_GL_FUNC_PTR(void,glLightModeliv,(GLenum pname, const GLint *params));
+
+  LOAD_GL_FUNC(glLightModeliv, NULL);
   pname = (GLenum)NUM2INT(arg1);
   Check_Type(arg2,T_ARRAY);
   ary2cint(arg2,params,4);
-  glLightModeliv(pname,params);
+  fptr_glLightModeliv(pname,params);
   CHECK_GLERROR_FROM("glLightModeliv");
   return Qnil;
 }
@@ -713,11 +826,14 @@ VALUE obj,arg1,arg2,arg3;
   GLenum face;
   GLenum pname;
   GLfloat params[4] = {(GLfloat)0.0, (GLfloat)0.0, (GLfloat)0.0, (GLfloat)0.0};
+  DECL_GL_FUNC_PTR(void,glMaterialfv,(GLenum face, GLenum pname, const GLfloat *params));
+
+  LOAD_GL_FUNC(glMaterialfv, NULL);
   face = (GLenum)NUM2INT(arg1);
   pname = (GLenum)NUM2INT(arg2);
   Check_Type(arg3,T_ARRAY);
   ary2cflt(arg3,params,4);
-  glMaterialfv(face,pname,params);
+  fptr_glMaterialfv(face,pname,params);
   CHECK_GLERROR_FROM("glMaterialfv");
   return Qnil;
 }
@@ -729,11 +845,14 @@ VALUE obj,arg1,arg2,arg3;
   GLenum face;
   GLenum pname;
   GLint params[4] = {0,0,0,0};
+  DECL_GL_FUNC_PTR(void,glMaterialiv,(GLenum face, GLenum pname, const GLint *params));
+
+  LOAD_GL_FUNC(glMaterialiv, NULL);
   face = (GLenum)NUM2INT(arg1);
   pname = (GLenum)NUM2INT(arg2);
   Check_Type(arg3,T_ARRAY);
   ary2cint(arg3,params,4);
-  glMaterialiv(face,pname,params);
+  fptr_glMaterialiv(face,pname,params);
   CHECK_GLERROR_FROM("glMaterialiv");
   return Qnil;
 }
@@ -742,15 +861,18 @@ static VALUE
 gl_PolygonStipple(obj,arg1)
 VALUE obj,arg1;
 {
-  if (CheckBufferBinding(GL_PIXEL_UNPACK_BUFFER_BINDING)) {
-    glPolygonStipple((GLubyte *)NUM2SIZET(arg1));
+  DECL_GL_FUNC_PTR(void,glPolygonStipple,(const GLubyte *mask));
+
+  LOAD_GL_FUNC(glPolygonStipple, NULL);
+  if (CHECK_BUFFER_BINDING(GL_PIXEL_UNPACK_BUFFER_BINDING)) {
+    fptr_glPolygonStipple((GLubyte *)NUM2SIZET(arg1));
   } else {
     VALUE data;
     data = pack_array_or_pass_string(GL_UNSIGNED_BYTE,arg1);
     if (RSTRING_LEN(data) < 128)
       rb_raise(rb_eArgError, "string length:%li", RSTRING_LEN(data));
 
-    glPolygonStipple((GLubyte *)RSTRING_PTR(data));
+    fptr_glPolygonStipple((GLubyte *)RSTRING_PTR(data));
   }
   CHECK_GLERROR_FROM("glPolygonStipple");
   return Qnil;
@@ -764,11 +886,14 @@ VALUE obj,arg1,arg2,arg3;
   GLenum target;
   GLenum pname;
   GLfloat params[4] = {(GLfloat)0.0, (GLfloat)0.0, (GLfloat)0.0, (GLfloat)0.0};
+  DECL_GL_FUNC_PTR(void,glTexParameterfv,(GLenum target, GLenum pname, const GLfloat *params));
+
+  LOAD_GL_FUNC(glTexParameterfv, NULL);
   target = (GLenum)NUM2INT(arg1);
   pname = (GLenum)NUM2INT(arg2);
   Check_Type(arg3,T_ARRAY);
   ary2cflt(arg3,params,4);
-  glTexParameterfv(target,pname,params);
+  fptr_glTexParameterfv(target,pname,params);
   CHECK_GLERROR_FROM("glTexParameterfv");
   return Qnil;
 }
@@ -780,11 +905,14 @@ VALUE obj,arg1,arg2,arg3;
   GLenum target;
   GLenum pname;
   GLint params[4] = {0,0,0,0};
+  DECL_GL_FUNC_PTR(void,glTexParameteriv,(GLenum target, GLenum pname, const GLint *params));
+
+  LOAD_GL_FUNC(glTexParameteriv, NULL);
   target = (GLenum)NUM2INT(arg1);
   pname = (GLenum)NUM2INT(arg2);
   Check_Type(arg3,T_ARRAY);
   ary2cint(arg3,params,4);
-  glTexParameteriv(target,pname,params);
+  fptr_glTexParameteriv(target,pname,params);
   CHECK_GLERROR_FROM("glTexParameteriv");
   return Qnil;
 }
@@ -801,6 +929,9 @@ VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8;
   GLenum format;
   GLenum type;
   const char *pixels;
+  DECL_GL_FUNC_PTR(void,glTexImage1D,(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels));
+
+  LOAD_GL_FUNC(glTexImage1D, NULL);
   target = (GLenum)NUM2INT(arg1);
   level = (GLint)NUM2INT(arg2);
   components = (GLint)NUM2INT(arg3);
@@ -809,8 +940,8 @@ VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8;
   format = (GLenum)NUM2INT(arg6);
   type = (GLenum)NUM2INT(arg7);
 
-  if (CheckBufferBinding(GL_PIXEL_UNPACK_BUFFER_BINDING)) {
-    glTexImage1D(target,level,components,width,border,format,type,(GLvoid *)NUM2SIZET(arg8));
+  if (CHECK_BUFFER_BINDING(GL_PIXEL_UNPACK_BUFFER_BINDING)) {
+    fptr_glTexImage1D(target,level,components,width,border,format,type,(GLvoid *)NUM2SIZET(arg8));
     CHECK_GLERROR_FROM("glTexImage1D");
     return Qnil;
   }
@@ -823,7 +954,7 @@ VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8;
     CheckDataSize(type,format,width,data);
     pixels = RSTRING_PTR(data);
   }
-  glTexImage1D(target,level,components,width,border,format,type,pixels);
+  fptr_glTexImage1D(target,level,components,width,border,format,type,pixels);
   CHECK_GLERROR_FROM("glTexImage1D");
   return Qnil;
 }
@@ -841,6 +972,9 @@ VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9;
   GLenum format;
   GLenum type;
   const char *pixels;
+  DECL_GL_FUNC_PTR(void,glTexImage2D,(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels));
+
+  LOAD_GL_FUNC(glTexImage2D, NULL);
   target = (GLenum)NUM2INT(arg1);
   level = (GLint)NUM2INT(arg2);
   components = (GLint)NUM2INT(arg3);
@@ -850,8 +984,8 @@ VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9;
   format = (GLenum)NUM2INT(arg7);
   type = (GLenum)NUM2INT(arg8);
 
-  if (CheckBufferBinding(GL_PIXEL_UNPACK_BUFFER_BINDING)) {
-    glTexImage2D(target,level,components,width,height,border,format,type,(GLvoid *)NUM2SIZET(arg9));
+  if (CHECK_BUFFER_BINDING(GL_PIXEL_UNPACK_BUFFER_BINDING)) {
+    fptr_glTexImage2D(target,level,components,width,height,border,format,type,(GLvoid *)NUM2SIZET(arg9));
     CHECK_GLERROR_FROM("glTexImage2D");
     return Qnil;
   }
@@ -864,7 +998,7 @@ VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9;
     CheckDataSize(type,format,width*height,data);
     pixels = RSTRING_PTR(data);
   }
-  glTexImage2D(target,level,components,width,height,border,format,type,pixels);
+  fptr_glTexImage2D(target,level,components,width,height,border,format,type,pixels);
   CHECK_GLERROR_FROM("glTexImage2D");
   return Qnil;
 }
@@ -876,11 +1010,14 @@ VALUE obj,arg1,arg2,arg3;
   GLenum target;
   GLenum pname;
   GLfloat params[4] = {(GLfloat)0.0, (GLfloat)0.0, (GLfloat)0.0, (GLfloat)0.0};
+  DECL_GL_FUNC_PTR(void,glTexEnvfv,(GLenum target, GLenum pname, const GLfloat *params));
+
+  LOAD_GL_FUNC(glTexEnvfv, NULL);
   target = (GLenum)NUM2INT(arg1);
   pname = (GLenum)NUM2INT(arg2);
   Check_Type(arg3,T_ARRAY);
   ary2cflt(arg3,params,4);
-  glTexEnvfv(target,pname,params);
+  fptr_glTexEnvfv(target,pname,params);
   CHECK_GLERROR_FROM("glTexEnvfv");
   return Qnil;
 }
@@ -892,11 +1029,14 @@ VALUE obj,arg1,arg2,arg3;
   GLenum target;
   GLenum pname;
   GLint params[4] = {0,0,0,0};
+  DECL_GL_FUNC_PTR(void,glTexEnviv,(GLenum target, GLenum pname, const GLint *params));
+
+  LOAD_GL_FUNC(glTexEnviv, NULL);
   target = (GLenum)NUM2INT(arg1);
   pname = (GLenum)NUM2INT(arg2);
   Check_Type(arg3,T_ARRAY);
   ary2cint(arg3,params,4);
-  glTexEnviv(target,pname,params);
+  fptr_glTexEnviv(target,pname,params);
   CHECK_GLERROR_FROM("glTexEnviv");
   return Qnil;
 }
@@ -909,11 +1049,14 @@ VALUE obj,arg1,arg2,arg3;
   GLenum coord;
   GLenum pname;
   GLdouble params[4] = {0.0,0.0,0.0,0.0};
+  DECL_GL_FUNC_PTR(void,glTexGendv,(GLenum coord, GLenum pname, const GLdouble *params));
+
+  LOAD_GL_FUNC(glTexGendv, NULL);
   coord = (GLenum)NUM2INT(arg1);
   pname = (GLenum)NUM2INT(arg2);
   Check_Type(arg3,T_ARRAY);
   ary2cdbl(arg3,params,4);
-  glTexGendv(coord,pname,params);
+  fptr_glTexGendv(coord,pname,params);
   CHECK_GLERROR_FROM("glTexGendv");
   return Qnil;
 }
@@ -926,11 +1069,14 @@ VALUE obj,arg1,arg2,arg3;
   GLenum coord;
   GLenum pname;
   GLfloat params[4] = {(GLfloat)0.0, (GLfloat)0.0, (GLfloat)0.0, (GLfloat)0.0};
+  DECL_GL_FUNC_PTR(void,glTexGenfv,(GLenum coord, GLenum pname, const GLfloat *params));
+
+  LOAD_GL_FUNC(glTexGenfv, NULL);
   coord = (GLenum)NUM2INT(arg1);
   pname = (GLenum)NUM2INT(arg2);
   Check_Type(arg3,T_ARRAY);
   ary2cflt(arg3,params,4);
-  glTexGenfv(coord,pname,params);
+  fptr_glTexGenfv(coord,pname,params);
   CHECK_GLERROR_FROM("glTexGenfv");
   return Qnil;
 }
@@ -943,42 +1089,53 @@ VALUE obj,arg1,arg2,arg3;
   GLenum coord;
   GLenum pname;
   GLint params[4] = {0,0,0,0};
+  DECL_GL_FUNC_PTR(void,glTexGeniv,(GLenum coord, GLenum pname, const GLint *params));
+
+  LOAD_GL_FUNC(glTexGeniv, NULL);
   coord = (GLenum)NUM2INT(arg1);
   pname = (GLenum)NUM2INT(arg2);
   Check_Type(arg3,T_ARRAY);
   ary2cint(arg3,params,4);
-  glTexGeniv(coord,pname,params);
+  fptr_glTexGeniv(coord,pname,params);
   CHECK_GLERROR_FROM("glTexGeniv");
   return Qnil;
 }
-static VALUE g_current_feed_buffer;
 static VALUE
 gl_FeedbackBuffer(obj,arg1,arg2)
 VALUE obj,arg1,arg2;
 {
   GLsizei size;
   GLenum type;
+  VALUE current_feed_buffer;
+  DECL_GL_FUNC_PTR(void,glFeedbackBuffer,(GLsizei size, GLenum type, GLfloat *buffer));
+
+  LOAD_GL_FUNC(glFeedbackBuffer, NULL);
   size = (GLsizei)NUM2UINT(arg1);
   type = (GLenum)NUM2INT(arg2);
-  g_current_feed_buffer = allocate_buffer_with_string(sizeof(GLfloat)*size);
-  rb_str_freeze(g_current_feed_buffer);
-  glFeedbackBuffer(size, type, (GLfloat*)RSTRING_PTR(g_current_feed_buffer));
+  current_feed_buffer = allocate_buffer_with_string(sizeof(GLfloat)*size);
+  rb_str_freeze(current_feed_buffer);
+  fptr_glFeedbackBuffer(size, type, (GLfloat*)RSTRING_PTR(current_feed_buffer));
   CHECK_GLERROR_FROM("glFeedbackBuffer");
-  return g_current_feed_buffer;
+  SET_GLIMPL_VARIABLE(current_feed_buffer, current_feed_buffer);
+  return current_feed_buffer;
 }
 
-static VALUE g_current_sel_buffer;
 static VALUE
 gl_SelectBuffer(obj,arg1)
 VALUE obj,arg1;
 {
   GLsizei size;
+  VALUE current_sel_buffer;
+  DECL_GL_FUNC_PTR(void,glSelectBuffer,(GLsizei size, GLuint *buffer));
+
+  LOAD_GL_FUNC(glSelectBuffer, NULL);
   size = (GLsizei)NUM2UINT(arg1);
-  g_current_sel_buffer = allocate_buffer_with_string(sizeof(GLuint)*size);
-  rb_str_freeze(g_current_sel_buffer);
-  glSelectBuffer(size, (GLuint*)RSTRING_PTR(g_current_sel_buffer));
+  current_sel_buffer = allocate_buffer_with_string(sizeof(GLuint)*size);
+  rb_str_freeze(current_sel_buffer);
+  fptr_glSelectBuffer(size, (GLuint*)RSTRING_PTR(current_sel_buffer));
   CHECK_GLERROR_FROM("glSelectBuffer");
-  return g_current_sel_buffer;
+  SET_GLIMPL_VARIABLE(current_sel_buffer, current_sel_buffer);
+  return current_sel_buffer;
 }
 
 
@@ -994,7 +1151,9 @@ VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6;
   GLdouble *points;
 
   VALUE work_ary;
+  DECL_GL_FUNC_PTR(void,glMap1d,(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points));
 
+  LOAD_GL_FUNC(glMap1d, NULL);
   target = (GLenum)NUM2INT(arg1);
   u1 = (GLdouble)NUM2DBL(arg2);
   u2 = (GLdouble)NUM2DBL(arg3);
@@ -1003,7 +1162,7 @@ VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6;
   points = ALLOC_N(GLdouble, order*stride);
   work_ary = rb_funcall(arg6,rb_intern("flatten"),0);
   ary2cdbl(work_ary, points, order*stride);
-  glMap1d(target, u1, u2, stride, order, points);
+  fptr_glMap1d(target, u1, u2, stride, order, points);
   xfree(points);
   CHECK_GLERROR_FROM("glMap1d");
   return Qnil;
@@ -1021,7 +1180,9 @@ VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6;
   GLfloat *points;
 
   VALUE work_ary;
+  DECL_GL_FUNC_PTR(void,glMap1f,(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points));
 
+  LOAD_GL_FUNC(glMap1f, NULL);
   target = (GLenum)NUM2INT(arg1);
   u1 = (GLfloat)NUM2DBL(arg2);
   u2 = (GLfloat)NUM2DBL(arg3);
@@ -1030,7 +1191,7 @@ VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6;
   points = ALLOC_N(GLfloat, order*stride);
   work_ary = rb_funcall(arg6,rb_intern("flatten"),0);
   ary2cflt(work_ary, points, order*stride);
-  glMap1f(target, u1, u2, stride, order, points);
+  fptr_glMap1f(target, u1, u2, stride, order, points);
   xfree(points);
   CHECK_GLERROR_FROM("glMap1f");
   return Qnil;
@@ -1052,7 +1213,9 @@ VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10;
   GLdouble *points;
 
   VALUE work_ary;
+  DECL_GL_FUNC_PTR(void,glMap2d,(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points));
 
+  LOAD_GL_FUNC(glMap2d, NULL);
   target = (GLenum)NUM2INT(arg1);
   u1 = (GLdouble)NUM2INT(arg2);
   u2 = (GLdouble)NUM2INT(arg3);
@@ -1065,7 +1228,7 @@ VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10;
   points = ALLOC_N(GLdouble, MAX(ustride*uorder, vstride*vorder));
   work_ary = rb_funcall(arg10,rb_intern("flatten"),0);
   ary2cdbl(work_ary, points, MAX(ustride*uorder, vstride*vorder));
-  glMap2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
+  fptr_glMap2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
   xfree(points);
   CHECK_GLERROR_FROM("glMap2d");
   return Qnil;
@@ -1087,7 +1250,9 @@ VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10;
   GLfloat *points;
 
   VALUE work_ary;
+  DECL_GL_FUNC_PTR(void,glMap2f,(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points));
 
+  LOAD_GL_FUNC(glMap2f, NULL);
   target = (GLenum)NUM2INT(arg1);
   u1 = (GLfloat)NUM2INT(arg2);
   u2 = (GLfloat)NUM2INT(arg3);
@@ -1100,7 +1265,7 @@ VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10;
   points = ALLOC_N(GLfloat, MAX(ustride*uorder, vstride*vorder));
   work_ary = rb_funcall(arg10,rb_intern("flatten"),0);
   ary2cflt(work_ary, points, MAX(ustride*uorder, vstride*vorder));
-  glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
+  fptr_glMap2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
   xfree(points);
   CHECK_GLERROR_FROM("glMap2f");
   return Qnil;
@@ -1111,9 +1276,12 @@ gl_EvalCoord1dv(obj,arg1)
 VALUE obj,arg1;
 {
   GLdouble params[1] = {0.0};
+  DECL_GL_FUNC_PTR(void,glEvalCoord1dv,(const GLdouble *u));
+
+  LOAD_GL_FUNC(glEvalCoord1dv, NULL);
   Check_Type(arg1,T_ARRAY);
   ary2cdbl(arg1,params,1);
-  glEvalCoord1dv(params);
+  fptr_glEvalCoord1dv(params);
   CHECK_GLERROR_FROM("glEvalCoord1dv");
   return Qnil;
 }
@@ -1123,9 +1291,12 @@ gl_EvalCoord1fv(obj,arg1)
 VALUE obj,arg1;
 {
   GLfloat params[1] = {(GLfloat)0.0};
+  DECL_GL_FUNC_PTR(void,glEvalCoord1fv,(const GLfloat *u));
+
+  LOAD_GL_FUNC(glEvalCoord1fv, NULL);
   Check_Type(arg1,T_ARRAY);
   ary2cflt(arg1,params,1);
-  glEvalCoord1fv(params);
+  fptr_glEvalCoord1fv(params);
   CHECK_GLERROR_FROM("glEvalCoord1fv");
   return Qnil;
 }
@@ -1135,9 +1306,12 @@ gl_EvalCoord2dv(obj,arg1)
 VALUE obj,arg1;
 {
   GLdouble params[2] = {0.0,0.0};
+  DECL_GL_FUNC_PTR(void,glEvalCoord2dv,(const GLdouble *u));
+
+  LOAD_GL_FUNC(glEvalCoord2dv, NULL);
   Check_Type(arg1,T_ARRAY);
   ary2cdbl(arg1,params,2);
-  glEvalCoord2dv(params);
+  fptr_glEvalCoord2dv(params);
   CHECK_GLERROR_FROM("glEvalCoord2fv");
   return Qnil;
 }
@@ -1147,9 +1321,12 @@ gl_EvalCoord2fv(obj,arg1)
 VALUE obj,arg1;
 {
   GLfloat params[2] = {(GLfloat)0.0,(GLfloat)0.0};
+  DECL_GL_FUNC_PTR(void,glEvalCoord2fv,(const GLfloat *u));
+
+  LOAD_GL_FUNC(glEvalCoord2fv, NULL);
   Check_Type(arg1,T_ARRAY);
   ary2cflt(arg1,params,2);
-  glEvalCoord2fv(params);
+  fptr_glEvalCoord2fv(params);
   CHECK_GLERROR_FROM("glEvalCoord2fv");
   return Qnil;
 }
@@ -1166,25 +1343,27 @@ VALUE obj; \
   _vartype_ *values; \
   GLsizei size; \
   VALUE args[4]; \
+  DECL_GL_FUNC_PTR(void,glPixelMap##_type_##v,(GLenum map, GLsizei mapsize, const _vartype_ *values)); \
+  LOAD_GL_FUNC(glPixelMap##_type_##v, NULL); \
   switch(rb_scan_args(argc, argv, "21", &args[0], &args[1], &args[2])) { \
     default: \
     case 2: \
-      if (CheckBufferBinding(GL_PIXEL_UNPACK_BUFFER_BINDING)) \
+      if (CHECK_BUFFER_BINDING(GL_PIXEL_UNPACK_BUFFER_BINDING)) \
         rb_raise(rb_eArgError, "Pixel unpack buffer bound, but offset argument missing"); \
       map = (GLenum)NUM2INT(args[0]); \
       Check_Type(args[1],T_ARRAY); \
       size = (int)RARRAY_LENINT(args[1]); \
       values = ALLOC_N(_vartype_,size); \
       _convert_(args[1],values,size); \
-      glPixelMap##_type_##v(map,size,values); \
+      fptr_glPixelMap##_type_##v(map,size,values); \
       xfree(values); \
       break; \
     case 3: \
-      if (!CheckBufferBinding(GL_PIXEL_UNPACK_BUFFER_BINDING)) \
+      if (!CHECK_BUFFER_BINDING(GL_PIXEL_UNPACK_BUFFER_BINDING)) \
         rb_raise(rb_eArgError, "Pixel unpack buffer not bound"); \
       map = (GLenum)NUM2INT(args[0]);	 \
       size = (GLsizei)NUM2INT(args[1]); \
-      glPixelMap##_type_##v(map,size,(GLvoid *)NUM2SIZET(args[2])); \
+      fptr_glPixelMap##_type_##v(map,size,(GLvoid *)NUM2SIZET(args[2])); \
       break; \
   } \
   CHECK_GLERROR_FROM("glPixelMap" #_type_ "v"); \
@@ -1212,6 +1391,9 @@ VALUE obj;
   VALUE pixels;
   VALUE args[7];
   int numargs;
+  DECL_GL_FUNC_PTR(void,glReadPixels,(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels));
+
+  LOAD_GL_FUNC(glReadPixels, NULL);
   numargs = rb_scan_args(argc, argv, "61", &args[0], &args[1], &args[2], &args[3], &args[4], &args[5], &args[6]);
   x = (GLint)NUM2INT(args[0]);
   y = (GLint)NUM2INT(args[1]);
@@ -1223,20 +1405,20 @@ VALUE obj;
   switch(numargs) {
     default:
     case 6:
-      if (CheckBufferBinding(GL_PIXEL_PACK_BUFFER_BINDING))
+      if (CHECK_BUFFER_BINDING(GL_PIXEL_PACK_BUFFER_BINDING))
         rb_raise(rb_eArgError, "Pixel pack buffer bound, but offset argument missing");
       pixels = allocate_buffer_with_string(GetDataSize(type,format,width*height));
       FORCE_PIXEL_STORE_MODE
-      glReadPixels(x,y,width,height,format,type,(GLvoid*)RSTRING_PTR(pixels));
+      fptr_glReadPixels(x,y,width,height,format,type,(GLvoid*)RSTRING_PTR(pixels));
       RESTORE_PIXEL_STORE_MODE
       CHECK_GLERROR_FROM("glReadPixels");
       return pixels;
       break;
     case 7:
-      if (!CheckBufferBinding(GL_PIXEL_PACK_BUFFER_BINDING))
+      if (!CHECK_BUFFER_BINDING(GL_PIXEL_PACK_BUFFER_BINDING))
         rb_raise(rb_eArgError, "Pixel pack buffer not bound");
       FORCE_PIXEL_STORE_MODE
-      glReadPixels(x,y,width,height,format,type,(GLvoid*)NUM2SIZET(args[6]));
+      fptr_glReadPixels(x,y,width,height,format,type,(GLvoid*)NUM2SIZET(args[6]));
       RESTORE_PIXEL_STORE_MODE
       CHECK_GLERROR_FROM("glReadPixels");
       return Qnil;
@@ -1253,18 +1435,21 @@ VALUE obj,arg1,arg2,arg3,arg4,arg5;
   GLenum format;
   GLenum type;
   const char *pixels;
+  DECL_GL_FUNC_PTR(void,glDrawPixels,(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels));
+
+  LOAD_GL_FUNC(glDrawPixels, NULL);
   width = (GLsizei)NUM2UINT(arg1);
   height = (GLsizei)NUM2UINT(arg2);
   format = (GLenum)NUM2INT(arg3);
   type = (GLenum)NUM2INT(arg4);
-  if (CheckBufferBinding(GL_PIXEL_UNPACK_BUFFER_BINDING)) {
-    glDrawPixels(width,height,format,type,(GLvoid *)NUM2SIZET(arg5));
+  if (CHECK_BUFFER_BINDING(GL_PIXEL_UNPACK_BUFFER_BINDING)) {
+    fptr_glDrawPixels(width,height,format,type,(GLvoid *)NUM2SIZET(arg5));
   } else {
     VALUE data;
     data = pack_array_or_pass_string(type,arg5);
     CheckDataSize(type,format,width*height,data);
     pixels = RSTRING_PTR(data);
-    glDrawPixels(width,height,format,type,pixels);
+    fptr_glDrawPixels(width,height,format,type,pixels);
   }
   CHECK_GLERROR_FROM("glDrawPixels");
   return Qnil;
@@ -1278,8 +1463,11 @@ VALUE obj,arg1;
   GLdouble equation[4] = {0.0,0.0,0.0,0.0};
   VALUE retary;
   int i;
+  DECL_GL_FUNC_PTR(void,glGetClipPlane,(GLenum plane, GLdouble *equation));
+
+  LOAD_GL_FUNC(glGetClipPlane, NULL);
   plane = (GLenum)NUM2INT(arg1);
-  glGetClipPlane(plane,equation);
+  fptr_glGetClipPlane(plane,equation);
   retary = rb_ary_new2(4);
   for(i=0;i<4;i++)
     rb_ary_push(retary, rb_float_new(equation[i]));
@@ -1297,6 +1485,8 @@ VALUE obj,arg1; \
   VALUE ary, ary2; \
   int i,j; \
   _type_ items[64];  \
+  DECL_GL_FUNC_PTR(void,glGet##_name_##v,(GLenum pname, _type_ *params)); \
+  LOAD_GL_FUNC(glGet##_name_##v, NULL); \
   pname = NUM2INT(arg1); \
   switch(pname) { \
   case GL_ACCUM_CLEAR_VALUE: \
@@ -1398,7 +1588,7 @@ VALUE obj,arg1; \
   case GL_PIXEL_TRANSFORM_2D_MATRIX_EXT: \
   case GL_MODELVIEW1_MATRIX_EXT: \
   case GL_CURRENT_MATRIX_NV: \
-    glGet##_name_##v(pname, items); \
+    fptr_glGet##_name_##v(pname, items); \
     ary = rb_ary_new2(4); \
     for (i = 0; i < 4; i++) { \
       ary2 = rb_ary_new2(4); \
@@ -1409,21 +1599,25 @@ VALUE obj,arg1; \
     CHECK_GLERROR_FROM("glGet" #_name_ "v"); \
     return ary; \
   case GL_POLYGON_STIPPLE: \
-    glGet##_name_##v(pname, items); \
+    fptr_glGet##_name_##v(pname, items); \
     CHECK_GLERROR_FROM("glGet" #_name_ "v"); \
     return rb_str_new((const char*)items, 32); \
   case GL_COMPRESSED_TEXTURE_FORMATS: \
-    glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &nitems); \
-    CHECK_GLERROR_FROM("glGetIntegerv"); \
-    if (nitems<=0||nitems>64) \
-      return INT2NUM(0); \
+    { \
+      DECL_GL_FUNC_PTR(void,glGetIntegerv,(GLenum pname, GLint *params)); \
+      LOAD_GL_FUNC(glGetIntegerv, NULL); \
+      fptr_glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS, &nitems); \
+      CHECK_GLERROR_FROM("glGetIntegerv"); \
+      if (nitems<=0||nitems>64) \
+        return INT2NUM(0); \
+    } \
     break; \
   default: /* size=1 */ \
-    glGet##_name_##v(pname, items); \
+    fptr_glGet##_name_##v(pname, items); \
     CHECK_GLERROR_FROM("glGet" #_name_ "v"); \
     return _conv_(items[0]); \
   } \
-  glGet##_name_##v(pname, items); \
+  fptr_glGet##_name_##v(pname, items); \
   ary = rb_ary_new2(nitems); \
   for (i = 0; i < nitems; i++) \
     rb_ary_push(ary, _conv_(items[i])); \
@@ -1447,6 +1641,9 @@ VALUE obj,arg1,arg2;
   GLenum pname;
   GLsizei size;
   GLfloat params[4] = {(GLfloat)0.0, (GLfloat)0.0, (GLfloat)0.0, (GLfloat)0.0};
+  DECL_GL_FUNC_PTR(void,glGetLightfv,(GLenum light, GLenum pname, GLfloat *params));
+
+  LOAD_GL_FUNC(glGetLightfv, NULL);
   light = (GLenum)NUM2INT(arg1);
   pname = (GLenum)NUM2INT(arg2);
   switch(pname) {
@@ -1470,7 +1667,7 @@ VALUE obj,arg1,arg2;
       rb_raise(rb_eArgError, "unknown pname:%d",pname);
       break; /* not reached */
   }
-  glGetLightfv(light,pname,params);
+  fptr_glGetLightfv(light,pname,params);
   RET_ARRAY_OR_SINGLE("glGetLightfv", size, rb_float_new, params);
 }
 
@@ -1482,6 +1679,9 @@ VALUE obj,arg1,arg2;
   GLenum pname;
   GLsizei size;
   GLint params[4] = {0,0,0,0};
+  DECL_GL_FUNC_PTR(void,glGetLightiv,(GLenum light, GLenum pname, GLint *params));
+
+  LOAD_GL_FUNC(glGetLightiv, NULL);
   light = (GLenum)NUM2INT(arg1);
   pname = (GLenum)NUM2INT(arg2);
   switch(pname) {
@@ -1505,7 +1705,7 @@ VALUE obj,arg1,arg2;
       rb_raise(rb_eArgError, "unknown pname:%d",pname);
       break; /* not reached */
   }
-  glGetLightiv(light,pname,params);
+  fptr_glGetLightiv(light,pname,params);
   RET_ARRAY_OR_SINGLE("glGetLightiv", size, INT2NUM, params);
 }
 
@@ -1521,6 +1721,8 @@ VALUE obj,arg1,arg2; \
   int size=0; \
   _type_ *points; \
   GLint order[2] = {0,0}; /* for GL_COEFF, [order] or [uorder,vorder] (MAP1/MAP2) */ \
+  DECL_GL_FUNC_PTR(void,gl##_name_,(GLenum target, GLenum query, _type_ *v)); \
+  LOAD_GL_FUNC(gl##_name_, NULL); \
   target = (GLenum)NUM2INT(arg1); \
   query = (GLenum)NUM2INT(arg2); \
   switch(target) { \
@@ -1550,19 +1752,23 @@ VALUE obj,arg1,arg2; \
     case GL_ORDER: size = dims;	break; \
     case GL_DOMAIN: size = dims*2; break; \
     case GL_COEFF: \
-      glGetMapiv(target,GL_ORDER,order); \
-      CHECK_GLERROR_FROM("glGetMapiv"); \
-      if (dims==1) \
-        size = order[0] * pointsize; \
-      else \
-        size = (order[0]*order[1]) * pointsize; \
+      { \
+        DECL_GL_FUNC_PTR(void,glGetMapiv,(GLenum target, GLenum query, GLint *v)); \
+        LOAD_GL_FUNC(glGetMapiv, NULL); \
+        fptr_glGetMapiv(target,GL_ORDER,order); \
+        CHECK_GLERROR_FROM("glGetMapiv"); \
+        if (dims==1) \
+          size = order[0] * pointsize; \
+        else \
+          size = (order[0]*order[1]) * pointsize; \
+      } \
       break; \
     default: \
       rb_raise(rb_eArgError, "unknown target:%d",target); \
       break; /* not reached */ \
   } \
   points = ALLOC_N(_type_,size); \
-  gl##_name_(target,query,points); \
+  fptr_gl##_name_(target,query,points); \
 \
   RET_ARRAY_OR_SINGLE_FREE("gl" #_name_, size, RETCONV_##_type_, points); \
 }
@@ -1580,6 +1786,9 @@ VALUE obj,arg1,arg2;
   GLenum pname;
   GLfloat params[4] = {(GLfloat)0.0, (GLfloat)0.0, (GLfloat)0.0, (GLfloat)0.0};
   int size;
+  DECL_GL_FUNC_PTR(void,glGetMaterialfv,(GLenum face, GLenum pname, GLfloat *params));
+
+  LOAD_GL_FUNC(glGetMaterialfv, NULL);
   face = (GLenum)NUM2INT(arg1);
   pname = (GLenum)NUM2INT(arg2);
   switch(pname) {
@@ -1599,7 +1808,7 @@ VALUE obj,arg1,arg2;
       rb_raise(rb_eArgError, "unknown pname:%d",pname);
       break; /* not reached */
   }
-  glGetMaterialfv(face,pname,params);
+  fptr_glGetMaterialfv(face,pname,params);
   RET_ARRAY_OR_SINGLE("glGetMaterialfv", size, rb_float_new, params);
 }
 
@@ -1611,6 +1820,9 @@ VALUE obj,arg1,arg2;
   GLenum pname;
   GLint params[4] = {0,0,0,0};
   int size;
+  DECL_GL_FUNC_PTR(void,glGetMaterialiv,(GLenum face, GLenum pname, GLint *params));
+
+  LOAD_GL_FUNC(glGetMaterialiv, NULL);
   face = (GLenum)NUM2INT(arg1);
   pname = (GLenum)NUM2INT(arg2);
   switch(pname) {
@@ -1630,7 +1842,7 @@ VALUE obj,arg1,arg2;
       rb_raise(rb_eArgError, "unknown pname:%d",pname);
       break; /* not reached */
   }
-  glGetMaterialiv(face,pname,params);
+  fptr_glGetMaterialiv(face,pname,params);
   RET_ARRAY_OR_SINGLE("glGetMaterialiv", size, INT2NUM, params);
 }
 
@@ -1646,10 +1858,12 @@ VALUE obj; \
   GLint size = 0; \
   _vartype_ *values; \
   VALUE args[2]; \
+  DECL_GL_FUNC_PTR(void,glGetPixelMap##_type_##v,(GLenum map, _vartype_ *values)); \
+  LOAD_GL_FUNC(glGetPixelMap##_type_##v, NULL); \
   switch (rb_scan_args(argc, argv, "11", &args[0], &args[1])) { \
     default: \
     case 1: \
-      if (CheckBufferBinding(GL_PIXEL_PACK_BUFFER_BINDING)) \
+      if (CHECK_BUFFER_BINDING(GL_PIXEL_PACK_BUFFER_BINDING)) \
         rb_raise(rb_eArgError, \
             "Pixel pack buffer bound, but offset argument missing"); \
 \
@@ -1669,19 +1883,23 @@ VALUE obj; \
           rb_raise(rb_eArgError, "unknown map:%d",map); \
           break; \
       } \
-      glGetIntegerv(map_size,&size); \
+      { \
+        DECL_GL_FUNC_PTR(void,glGetIntegerv,(GLenum pname, GLint *params)); \
+        LOAD_GL_FUNC(glGetIntegerv, NULL); \
+        fptr_glGetIntegerv(map_size,&size); \
+      } \
       CHECK_GLERROR_FROM("glGetIntegerv"); \
       values = ALLOC_N(_vartype_,size); \
-      glGetPixelMap##_type_##v(map,values); \
+      fptr_glGetPixelMap##_type_##v(map,values); \
       RET_ARRAY_OR_SINGLE_FREE("glGetPixelMap" #_type_ "v", size, _convert_, \
           values); \
       break; \
     case 2: \
-      if (!CheckBufferBinding(GL_PIXEL_PACK_BUFFER_BINDING)) \
+      if (!CHECK_BUFFER_BINDING(GL_PIXEL_PACK_BUFFER_BINDING)) \
         rb_raise(rb_eArgError, "Pixel pack buffer not bound"); \
 \
       map = (GLenum)NUM2INT(args[0]); \
-      glGetPixelMap##_type_##v(map,(GLvoid*)NUM2SIZET(args[1])); \
+      fptr_glGetPixelMap##_type_##v(map,(GLvoid*)NUM2SIZET(args[1])); \
       CHECK_GLERROR_FROM("glGetPixelMap" #_type_ "v"); \
       return Qnil; \
   } \
@@ -1700,21 +1918,24 @@ VALUE obj;
 {
   VALUE args[1];
   GLubyte mask[128];
+  DECL_GL_FUNC_PTR(void,glGetPolygonStipple,(GLubyte *mask));
+
+  LOAD_GL_FUNC(glGetPolygonStipple, NULL);
   switch(rb_scan_args(argc, argv, "01", &args[0])) {
     default:
     case 0:
-      if (CheckBufferBinding(GL_PIXEL_PACK_BUFFER_BINDING))
+      if (CHECK_BUFFER_BINDING(GL_PIXEL_PACK_BUFFER_BINDING))
         rb_raise(rb_eArgError, "Pixel pack buffer bound, but offset argument missing");
       memset(mask, 0x0, sizeof(GLubyte)*128);
       FORCE_PIXEL_STORE_MODE
-      glGetPolygonStipple(mask);
+      fptr_glGetPolygonStipple(mask);
       RESTORE_PIXEL_STORE_MODE
       CHECK_GLERROR_FROM("glGetPolygonStipple");
       return rb_str_new((const char*)mask, 128);
     case 1:
-      if (!CheckBufferBinding(GL_PIXEL_PACK_BUFFER_BINDING))
+      if (!CHECK_BUFFER_BINDING(GL_PIXEL_PACK_BUFFER_BINDING))
         rb_raise(rb_eArgError, "Pixel pack buffer not bound");
-      glGetPolygonStipple((GLvoid *)NUM2SIZET(args[0]));
+      fptr_glGetPolygonStipple((GLvoid *)NUM2SIZET(args[0]));
       CHECK_GLERROR_FROM("glGetPolygonStipple");
       return Qnil;
   }
@@ -1726,8 +1947,11 @@ VALUE obj,arg1;
 {
   GLenum name;
   const GLubyte *ret;
+  DECL_GL_FUNC_PTR(const GLubyte *,glGetString,(GLenum name));
+
+  LOAD_GL_FUNC(glGetString, NULL);
   name = (GLenum)NUM2INT(arg1);
-  ret = glGetString(name);
+  ret = fptr_glGetString(name);
   CHECK_GLERROR_FROM("glGetString");
   return rb_str_new2((const char*)ret);
 }
@@ -1741,6 +1965,8 @@ VALUE obj,arg1,arg2; \
   GLenum pname; \
   _type_ params[4] = {(_type_)0.0, (_type_)0.0, (_type_)0.0, (_type_)0.0}; \
   int size; \
+  DECL_GL_FUNC_PTR(GLvoid,gl##_name_,(GLenum target, GLenum pname, _type_ *params)); \
+  LOAD_GL_FUNC(gl##_name_, NULL); \
   target = (GLenum)NUM2INT(arg1); \
   pname = (GLenum)NUM2INT(arg2); \
   switch(pname) { \
@@ -1757,7 +1983,7 @@ VALUE obj,arg1,arg2; \
       size = 1; \
       break; \
   } \
-  gl##_name_(target,pname,params); \
+  fptr_gl##_name_(target,pname,params); \
   RET_ARRAY_OR_SINGLE("gl" #_name_, size, RETCONV_##_type_, params); \
 }
 
@@ -1774,6 +2000,8 @@ VALUE obj,arg1,arg2; \
   GLenum pname; \
   _type_ params[4] = {(_type_)0.0, (_type_)0.0, (_type_)0.0, (_type_)0.0}; \
   int size; \
+  DECL_GL_FUNC_PTR(GLvoid,gl##_name_,(GLenum coord, GLenum pname, _type_ *params)); \
+  LOAD_GL_FUNC(gl##_name_, NULL); \
   coord = (GLenum)NUM2INT(arg1); \
   pname = (GLenum)NUM2INT(arg2); \
   switch(pname) { \
@@ -1785,7 +2013,7 @@ VALUE obj,arg1,arg2; \
       size = 1; \
       break; \
   } \
-  gl##_name_(coord,pname,params); \
+  fptr_gl##_name_(coord,pname,params); \
   RET_ARRAY_OR_SINGLE("gl" #_name_, size, RETCONV_##_type_, params); \
 }
 
@@ -1812,6 +2040,9 @@ VALUE obj;
   VALUE pixels;
   VALUE args[5];
   int numargs;
+  DECL_GL_FUNC_PTR(void,glGetTexImage,(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels));
+
+  LOAD_GL_FUNC(glGetTexImage, NULL);
   numargs = rb_scan_args(argc, argv, "41", &args[0], &args[1], &args[2], &args[3], &args[4]);
   tex = (GLenum)NUM2INT(args[0]);
   lod = (GLint)NUM2INT(args[1]);
@@ -1820,55 +2051,59 @@ VALUE obj;
   switch(numargs) {
     default:
     case 4:
-      if (CheckBufferBinding(GL_PIXEL_PACK_BUFFER_BINDING))
-        rb_raise(rb_eArgError, "Pixel pack buffer bound, but offset argument missing");
-
-      size = 1;
-      switch(tex) {
-        case GL_TEXTURE_4D_SGIS:
-          glGetTexLevelParameteriv(tex,lod,GL_TEXTURE_4DSIZE_SGIS,&size4d);
-          size *= size4d;
-          /* fall through */
-        case GL_TEXTURE_3D:
-        case GL_TEXTURE_1D_STACK_MESAX:
-        case GL_TEXTURE_2D_STACK_MESAX:
-          glGetTexLevelParameteriv(tex,lod,GL_TEXTURE_DEPTH,&depth);
-          size *= depth;
-          /* fall through */
-        case GL_TEXTURE_2D:
-        case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
-        case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
-        case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
-        case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
-        case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
-        case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
-        case GL_TEXTURE_RECTANGLE_ARB:
-        case GL_DETAIL_TEXTURE_2D_SGIS:
-          glGetTexLevelParameteriv(tex,lod,GL_TEXTURE_HEIGHT,&height);
-          size *= height;
-          /* fall through */
-        case GL_TEXTURE_1D:
-          glGetTexLevelParameteriv(tex,lod,GL_TEXTURE_WIDTH,&width);
-          size *= width;
-          break;
-        default:
-          rb_raise(rb_eArgError, "Target type not supported");
+      {
+        DECL_GL_FUNC_PTR(void,glGetTexLevelParameteriv,(GLenum target, GLint level, GLenum pname, GLint *params));
+        LOAD_GL_FUNC(glGetTexLevelParameteriv, NULL);
+        if (CHECK_BUFFER_BINDING(GL_PIXEL_PACK_BUFFER_BINDING))
+          rb_raise(rb_eArgError, "Pixel pack buffer bound, but offset argument missing");
+
+        size = 1;
+        switch(tex) {
+          case GL_TEXTURE_4D_SGIS:
+            fptr_glGetTexLevelParameteriv(tex,lod,GL_TEXTURE_4DSIZE_SGIS,&size4d);
+            size *= size4d;
+            /* fall through */
+          case GL_TEXTURE_3D:
+          case GL_TEXTURE_1D_STACK_MESAX:
+          case GL_TEXTURE_2D_STACK_MESAX:
+            fptr_glGetTexLevelParameteriv(tex,lod,GL_TEXTURE_DEPTH,&depth);
+            size *= depth;
+            /* fall through */
+          case GL_TEXTURE_2D:
+          case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
+          case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
+          case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
+          case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
+          case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
+          case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
+          case GL_TEXTURE_RECTANGLE_ARB:
+          case GL_DETAIL_TEXTURE_2D_SGIS:
+            fptr_glGetTexLevelParameteriv(tex,lod,GL_TEXTURE_HEIGHT,&height);
+            size *= height;
+            /* fall through */
+          case GL_TEXTURE_1D:
+            fptr_glGetTexLevelParameteriv(tex,lod,GL_TEXTURE_WIDTH,&width);
+            size *= width;
+            break;
+          default:
+            rb_raise(rb_eArgError, "Target type not supported");
+        }
+        CHECK_GLERROR_FROM("glGetTexLevelParameteriv");
+        pixels = allocate_buffer_with_string(GetDataSize(type,format,size));
+
+        FORCE_PIXEL_STORE_MODE
+        fptr_glGetTexImage(tex,lod,format,type,(GLvoid*)RSTRING_PTR(pixels));
+        RESTORE_PIXEL_STORE_MODE
+        CHECK_GLERROR_FROM("glGetTexImage");
+        return pixels;
       }
-      CHECK_GLERROR_FROM("glGetTexLevelParameteriv");
-      pixels = allocate_buffer_with_string(GetDataSize(type,format,size));
-
-      FORCE_PIXEL_STORE_MODE
-      glGetTexImage(tex,lod,format,type,(GLvoid*)RSTRING_PTR(pixels));
-      RESTORE_PIXEL_STORE_MODE
-      CHECK_GLERROR_FROM("glGetTexImage");
-      return pixels;
       break;
     case 5:
-      if (!CheckBufferBinding(GL_PIXEL_PACK_BUFFER_BINDING))
+      if (!CHECK_BUFFER_BINDING(GL_PIXEL_PACK_BUFFER_BINDING))
         rb_raise(rb_eArgError, "Pixel pack buffer not bound");
 
       FORCE_PIXEL_STORE_MODE
-      glGetTexImage(tex,lod,format,type,(GLvoid*)NUM2SIZET(args[4]));
+      fptr_glGetTexImage(tex,lod,format,type,(GLvoid*)NUM2SIZET(args[4]));
       RESTORE_PIXEL_STORE_MODE
       CHECK_GLERROR_FROM("glGetTexImage");
     return Qnil;
@@ -1883,6 +2118,9 @@ VALUE obj,arg1,arg2;
   GLenum pname;
   GLfloat params[4] = {(GLfloat)0.0, (GLfloat)0.0, (GLfloat)0.0, (GLfloat)0.0};
   int size;
+  DECL_GL_FUNC_PTR(void,glGetTexParameterfv,(GLenum target, GLenum pname, GLfloat *params));
+
+  LOAD_GL_FUNC(glGetTexParameterfv, NULL);
   target = (GLenum)NUM2INT(arg1);
   pname = (GLenum)NUM2INT(arg2);
   switch(pname) {
@@ -1896,7 +2134,7 @@ VALUE obj,arg1,arg2;
       size = 1;
       break;
   }
-  glGetTexParameterfv(target,pname,params);
+  fptr_glGetTexParameterfv(target,pname,params);
   RET_ARRAY_OR_SINGLE("glGetTexParameterfv", size, RETCONV_GLfloat, params);
 }
 
@@ -1908,6 +2146,9 @@ VALUE obj,arg1,arg2;
   GLenum pname;
   GLint params[4] = {0,0,0,0};
   int size;
+  DECL_GL_FUNC_PTR(void,glGetTexParameteriv,(GLenum target, GLenum pname, GLint *params));
+
+  LOAD_GL_FUNC(glGetTexParameteriv, NULL);
   target = (GLenum)NUM2INT(arg1);
   pname = (GLenum)NUM2INT(arg2);
   switch(pname) {
@@ -1921,7 +2162,7 @@ VALUE obj,arg1,arg2;
       size = 1;
       break;
   }
-  glGetTexParameteriv(target,pname,params);
+  fptr_glGetTexParameteriv(target,pname,params);
   RET_ARRAY_OR_SINGLE_BOOL("glGetTexParameteriv", size, cond_GLBOOL2RUBY,
       pname, params);
 }
@@ -1934,10 +2175,13 @@ VALUE obj,arg1,arg2,arg3;
   GLint level;
   GLenum pname;
   GLfloat params = (GLfloat)0.0;
+  DECL_GL_FUNC_PTR(void,glGetTexLevelParameterfv,(GLenum target, GLint level, GLenum pname, GLfloat *params));
+
+  LOAD_GL_FUNC(glGetTexLevelParameterfv, NULL);
   target = (GLenum)NUM2INT(arg1);
   level = (GLint)NUM2INT(arg2);
   pname = (GLenum)NUM2INT(arg3);
-  glGetTexLevelParameterfv(target,level,pname,&params);
+  fptr_glGetTexLevelParameterfv(target,level,pname,&params);
   CHECK_GLERROR_FROM("glGetTexLevelParameterfv");
   return RETCONV_GLfloat(params);
 }
@@ -1950,10 +2194,13 @@ VALUE obj,arg1,arg2,arg3;
   GLint level;
   GLenum pname;
   GLint params = 0;
+  DECL_GL_FUNC_PTR(void,glGetTexLevelParameteriv,(GLenum target, GLint level, GLenum pname, GLint *params));
+
+  LOAD_GL_FUNC(glGetTexLevelParameteriv, NULL);
   target = (GLenum)NUM2INT(arg1);
   level = (GLint)NUM2INT(arg2);
   pname = (GLenum)NUM2INT(arg3);
-  glGetTexLevelParameteriv(target,level,pname,&params);
+  fptr_glGetTexLevelParameteriv(target,level,pname,&params);
   CHECK_GLERROR_FROM("glGetTexLevelParameteriv");
   return cond_GLBOOL2RUBY(pname,params);
 }
@@ -1964,8 +2211,11 @@ gl_LoadMatrixf(obj,arg1)
 VALUE obj,arg1;
 {
   GLfloat m[4*4];
+  DECL_GL_FUNC_PTR(void,glLoadMatrixf,(const GLfloat *m));
+
+  LOAD_GL_FUNC(glLoadMatrixf, NULL);
   ary2cmatfloat(arg1, m, 4, 4);
-  glLoadMatrixf(m);
+  fptr_glLoadMatrixf(m);
   CHECK_GLERROR_FROM("glLoadMatrixf");
   return Qnil;
 }
@@ -1975,8 +2225,11 @@ gl_LoadMatrixd(obj,arg1)
 VALUE obj,arg1;
 {
   GLdouble m[4*4];
+  DECL_GL_FUNC_PTR(void,glLoadMatrixd,(const GLdouble *m));
+
+  LOAD_GL_FUNC(glLoadMatrixd, NULL);
   ary2cmatdouble(arg1, m, 4, 4);
-  glLoadMatrixd(m);
+  fptr_glLoadMatrixd(m);
   CHECK_GLERROR_FROM("glLoadMatrixd");
   return Qnil;
 }
@@ -1986,8 +2239,11 @@ gl_MultMatrixf(obj,arg1)
 VALUE obj,arg1;
 {
   GLfloat m[4*4];
+  DECL_GL_FUNC_PTR(void,glMultMatrixf,(const GLfloat *m));
+
+  LOAD_GL_FUNC(glMultMatrixf, NULL);
   ary2cmatfloat(arg1, m, 4, 4);
-  glMultMatrixf(m);
+  fptr_glMultMatrixf(m);
   CHECK_GLERROR_FROM("glMultMatrixf");
   return Qnil;
 }
@@ -1997,21 +2253,16 @@ gl_MultMatrixd(obj,arg1)
 VALUE obj,arg1;
 {
   GLdouble m[4*4];
+  DECL_GL_FUNC_PTR(void,glMultMatrixd,(const GLdouble *m));
+
+  LOAD_GL_FUNC(glMultMatrixd, NULL);
   ary2cmatdouble(arg1, m, 4, 4);
-  glMultMatrixd(m);
+  fptr_glMultMatrixd(m);
   CHECK_GLERROR_FROM("glMultMatrixd");
   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; /* OpenGL 1.4 */
-VALUE g_SecondaryColor_ptr; /* OpenGL 1.4 */
 #define POINTER_FUNC(_func_) \
 static VALUE \
 gl_##_func_##Pointer(obj, arg1, arg2, arg3, arg4) \
@@ -2020,18 +2271,20 @@ VALUE obj, arg1, arg2, arg3, arg4; \
   GLint size; \
   GLenum type; \
   GLsizei stride; \
+  DECL_GL_FUNC_PTR(GLvoid,gl##_func_##Pointer,(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr)); \
+  LOAD_GL_FUNC(gl##_func_##Pointer, NULL); \
   size = (GLint)NUM2INT(arg1); \
   type = (GLenum)NUM2INT(arg2); \
   stride = (GLsizei)NUM2UINT(arg3); \
-  if (CheckBufferBinding(GL_ARRAY_BUFFER_BINDING)) { \
-    g_##_func_##_ptr = arg4; \
-    gl##_func_##Pointer(size, type, stride, (const GLvoid*)NUM2SIZET(arg4)); \
+  if (CHECK_BUFFER_BINDING(GL_ARRAY_BUFFER_BINDING)) { \
+    SET_GLIMPL_VARIABLE(_func_##_ptr, arg4); \
+    fptr_gl##_func_##Pointer(size, type, stride, (const GLvoid*)NUM2SIZET(arg4)); \
   } else { \
     VALUE data; \
     data = pack_array_or_pass_string(type,arg4); \
     rb_str_freeze(data); \
-    g_##_func_##_ptr = data; \
-    gl##_func_##Pointer(size, type, stride, (const GLvoid*)RSTRING_PTR(data)); \
+    SET_GLIMPL_VARIABLE(_func_##_ptr, data); \
+    fptr_gl##_func_##Pointer(size, type, stride, (const GLvoid*)RSTRING_PTR(data)); \
   } \
   CHECK_GLERROR_FROM("gl" #_func_ "Pointer"); \
   return Qnil; \
@@ -2050,15 +2303,18 @@ VALUE obj,arg1,arg2,arg3,arg4;
   GLenum mode;
   GLsizei count;
   GLenum type;
+  DECL_GL_FUNC_PTR(void,glDrawElements,(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices));
+
+  LOAD_GL_FUNC(glDrawElements, NULL);
   mode = (GLenum)NUM2INT(arg1);
   count = (GLsizei)NUM2UINT(arg2);
   type = (GLenum)NUM2INT(arg3);
-  if (CheckBufferBinding(GL_ELEMENT_ARRAY_BUFFER_BINDING)) {
-    glDrawElements(mode, count, type, (const GLvoid*)NUM2SIZET(arg4));
+  if (CHECK_BUFFER_BINDING(GL_ELEMENT_ARRAY_BUFFER_BINDING)) {
+    fptr_glDrawElements(mode, count, type, (const GLvoid*)NUM2SIZET(arg4));
   } else {
     VALUE data;
     data = pack_array_or_pass_string(type,arg4);
-    glDrawElements(mode, count, type, (const GLvoid*)RSTRING_PTR(data));
+    fptr_glDrawElements(mode, count, type, (const GLvoid*)RSTRING_PTR(data));
   }
   CHECK_GLERROR_FROM("glDrawElements");
   return Qnil;
@@ -2069,16 +2325,19 @@ gl_EdgeFlagPointer(obj,arg1,arg2)
 VALUE obj,arg1,arg2;
 {
   GLsizei stride;
+  DECL_GL_FUNC_PTR(void,glEdgeFlagPointer,(GLsizei stride, const GLvoid *ptr));
+
+  LOAD_GL_FUNC(glEdgeFlagPointer, NULL);
   stride = (GLsizei)NUM2UINT(arg1);
-  if (CheckBufferBinding(GL_ARRAY_BUFFER_BINDING)) {
-    g_EdgeFlag_ptr = arg2;
-    glEdgeFlagPointer(stride, (const GLvoid*) NUM2SIZET(arg2));
+  if (CHECK_BUFFER_BINDING(GL_ARRAY_BUFFER_BINDING)) {
+    SET_GLIMPL_VARIABLE(EdgeFlag_ptr, arg2);
+    fptr_glEdgeFlagPointer(stride, (const GLvoid*) NUM2SIZET(arg2));
   } else {
     VALUE data;
     data = pack_array_or_pass_string(GL_UNSIGNED_BYTE,arg2);
     rb_str_freeze(data);
-    g_EdgeFlag_ptr = data;
-    glEdgeFlagPointer(stride, (const GLvoid*)RSTRING_PTR(data));
+    SET_GLIMPL_VARIABLE(EdgeFlag_ptr, data);
+    fptr_glEdgeFlagPointer(stride, (const GLvoid*)RSTRING_PTR(data));
   }
   CHECK_GLERROR_FROM("glEdgeFlagPointer");
   return Qnil;
@@ -2089,28 +2348,29 @@ gl_GetPointerv(obj,arg1)
 VALUE obj,arg1;
 {
   GLenum pname;
+
   pname = (GLenum)NUM2INT(arg1);
   switch (pname) {
     case GL_VERTEX_ARRAY_POINTER:
-      return g_Vertex_ptr;
+      return GET_GLIMPL_VARIABLE(Vertex_ptr);
     case GL_NORMAL_ARRAY_POINTER:
-      return g_Normal_ptr;
+      return GET_GLIMPL_VARIABLE(Normal_ptr);
     case GL_COLOR_ARRAY_POINTER:
-      return g_Color_ptr;
+      return GET_GLIMPL_VARIABLE(Color_ptr);
     case GL_INDEX_ARRAY_POINTER:
-      return g_Index_ptr;
+      return GET_GLIMPL_VARIABLE(Index_ptr);
     case GL_TEXTURE_COORD_ARRAY_POINTER:
-      return g_TexCoord_ptr;
+      return GET_GLIMPL_VARIABLE(TexCoord_ptr);
     case GL_EDGE_FLAG_ARRAY_POINTER:
-      return g_EdgeFlag_ptr;
+      return GET_GLIMPL_VARIABLE(EdgeFlag_ptr);
     case GL_FOG_COORD_ARRAY_POINTER:
-      return g_FogCoord_ptr;
+      return GET_GLIMPL_VARIABLE(FogCoord_ptr);
     case GL_SECONDARY_COLOR_ARRAY_POINTER:
-      return g_SecondaryColor_ptr;
+      return GET_GLIMPL_VARIABLE(SecondaryColor_ptr);
     case GL_FEEDBACK_BUFFER_POINTER:
-      return g_current_feed_buffer;
+      return GET_GLIMPL_VARIABLE(current_feed_buffer);
     case GL_SELECTION_BUFFER_POINTER:
-      return g_current_sel_buffer;
+      return GET_GLIMPL_VARIABLE(current_sel_buffer);
     default:
       rb_raise(rb_eArgError, "Invalid pname %d",pname);
       break; /* not reached */
@@ -2124,16 +2384,19 @@ VALUE obj,arg1,arg2,arg3;
 {
   GLenum type;
   GLsizei stride;
+  DECL_GL_FUNC_PTR(void,glIndexPointer,(GLenum type, GLsizei stride, const GLvoid *ptr));
+
+  LOAD_GL_FUNC(glIndexPointer, NULL);
   type = (GLenum)NUM2INT(arg1);
   stride = (GLsizei)NUM2UINT(arg2);
-  if (CheckBufferBinding(GL_ARRAY_BUFFER_BINDING)) {
-    g_Index_ptr = arg3;
-    glIndexPointer(type, stride, (const GLvoid*)NUM2SIZET(arg3));
+  if (CHECK_BUFFER_BINDING(GL_ARRAY_BUFFER_BINDING)) {
+    SET_GLIMPL_VARIABLE(Index_ptr, arg3);
+    fptr_glIndexPointer(type, stride, (const GLvoid*)NUM2SIZET(arg3));
   } else {
     VALUE data;
     data = pack_array_or_pass_string(type,arg3);
-    g_Index_ptr = data;
-    glIndexPointer(type, stride, (const GLvoid*)RSTRING_PTR(data));
+    SET_GLIMPL_VARIABLE(Index_ptr, data);
+    fptr_glIndexPointer(type, stride, (const GLvoid*)RSTRING_PTR(data));
   }
   CHECK_GLERROR_FROM("glIndexPointer");
   return Qnil;
@@ -2146,12 +2409,15 @@ VALUE obj,arg1,arg2,arg3;
   GLenum format;
   GLsizei stride;
   VALUE data;
+  DECL_GL_FUNC_PTR(void,glInterleavedArrays,(GLenum format, GLsizei stride, const GLvoid *pointer));
+
+  LOAD_GL_FUNC(glInterleavedArrays, NULL);
   format = (GLenum)NUM2INT(arg1);
   stride = (GLsizei)NUM2UINT(arg2);
   /* FIXME: add support for GL_C4UB_V2F,GL_C4UB_V3F, GL_T2F_C4UB_V3 */
   data = pack_array_or_pass_string(GL_FLOAT,arg3);
   rb_str_freeze(data);
-  glInterleavedArrays(format, stride, (const GLvoid*)RSTRING_PTR(data));
+  fptr_glInterleavedArrays(format, stride, (const GLvoid*)RSTRING_PTR(data));
   CHECK_GLERROR_FROM("glInterleavedArrays");
   return Qnil;
 }
@@ -2162,17 +2428,20 @@ VALUE obj,arg1,arg2,arg3;
 {
   GLenum type;
   GLsizei stride;
+  DECL_GL_FUNC_PTR(void,glNormalPointer,(GLenum type, GLsizei stride, const GLvoid *ptr));
+
+  LOAD_GL_FUNC(glNormalPointer, NULL);
   type = (GLenum)NUM2INT(arg1);
   stride = (GLsizei)NUM2UINT(arg2);
-  if (CheckBufferBinding(GL_ARRAY_BUFFER_BINDING)) {
-    g_Normal_ptr = arg3;
-    glNormalPointer(type, stride, (const GLvoid*)NUM2SIZET(arg3));
+  if (CHECK_BUFFER_BINDING(GL_ARRAY_BUFFER_BINDING)) {
+    SET_GLIMPL_VARIABLE(Normal_ptr, arg3);
+    fptr_glNormalPointer(type, stride, (const GLvoid*)NUM2SIZET(arg3));
   } else {
     VALUE data;
     data = pack_array_or_pass_string(type,arg3);
     rb_str_freeze(data);
-    g_Normal_ptr = data;
-    glNormalPointer(type, stride, (const GLvoid*)RSTRING_PTR(data));
+    SET_GLIMPL_VARIABLE(Normal_ptr, data);
+    fptr_glNormalPointer(type, stride, (const GLvoid*)RSTRING_PTR(data));
   }
   CHECK_GLERROR_FROM("glNormalPointer");
   return Qnil;
@@ -2190,6 +2459,9 @@ VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6,arg7;
   GLenum format;
   GLenum type;
   VALUE data;
+  DECL_GL_FUNC_PTR(void,glTexSubImage1D,(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels));
+
+  LOAD_GL_FUNC(glTexSubImage1D, NULL);
   target = (GLenum)NUM2INT(arg1);
   level = (GLint)NUM2INT(arg2);
   xoffset = (GLint)NUM2INT(arg3);
@@ -2197,8 +2469,8 @@ VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6,arg7;
   format = (GLenum)NUM2INT(arg5);
   type = (GLenum)NUM2INT(arg6);
 
-  if (CheckBufferBinding(GL_PIXEL_UNPACK_BUFFER_BINDING)) {
-    glTexSubImage1D(target,level,xoffset,width,format,type,(GLvoid *)NUM2SIZET(arg7));
+  if (CHECK_BUFFER_BINDING(GL_PIXEL_UNPACK_BUFFER_BINDING)) {
+    fptr_glTexSubImage1D(target,level,xoffset,width,format,type,(GLvoid *)NUM2SIZET(arg7));
     CHECK_GLERROR_FROM("glTexSubImage1D");
     return Qnil;
   }
@@ -2206,7 +2478,7 @@ VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6,arg7;
   data = pack_array_or_pass_string(type,arg7);
   CheckDataSize(type,format,width,data);
 
-  glTexSubImage1D(target,level,xoffset,width,format,type,RSTRING_PTR(data));
+  fptr_glTexSubImage1D(target,level,xoffset,width,format,type,RSTRING_PTR(data));
   CHECK_GLERROR_FROM("glTexSubImage1D");
   return Qnil;
 }
@@ -2224,6 +2496,9 @@ VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9;
   GLenum format;
   GLenum type;
   VALUE data;
+  DECL_GL_FUNC_PTR(void,glTexSubImage2D,(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels));
+
+  LOAD_GL_FUNC(glTexSubImage2D, NULL);
   target = (GLenum)NUM2INT(arg1);
   level = (GLint)NUM2INT(arg2);
   xoffset = (GLint)NUM2INT(arg3);
@@ -2233,8 +2508,8 @@ VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9;
   format = (GLenum)NUM2INT(arg7);
   type = (GLenum)NUM2INT(arg8);
 
-  if (CheckBufferBinding(GL_PIXEL_UNPACK_BUFFER_BINDING)) {
-    glTexSubImage2D(target,level,xoffset,yoffset,width,height,format,type,(GLvoid *)NUM2SIZET(arg9));
+  if (CHECK_BUFFER_BINDING(GL_PIXEL_UNPACK_BUFFER_BINDING)) {
+    fptr_glTexSubImage2D(target,level,xoffset,yoffset,width,height,format,type,(GLvoid *)NUM2SIZET(arg9));
     CHECK_GLERROR_FROM("glTexSubImage2D");
     return Qnil;
   }
@@ -2242,7 +2517,7 @@ VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9;
   data = pack_array_or_pass_string(type,arg9);
   CheckDataSize(type,format,width*height,data);
 
-  glTexSubImage2D(target,level,xoffset,yoffset,width,height,format,type,RSTRING_PTR(data));
+  fptr_glTexSubImage2D(target,level,xoffset,yoffset,width,height,format,type,RSTRING_PTR(data));
   CHECK_GLERROR_FROM("glTexSubImage2D");
   return Qnil;
 }
@@ -2258,12 +2533,15 @@ VALUE obj,arg1;
   VALUE retary;
   VALUE ary;
   int i;
+  DECL_GL_FUNC_PTR(GLboolean,glAreTexturesResident,(GLsizei n, const GLuint *textures, GLboolean *residences));
+
+  LOAD_GL_FUNC(glAreTexturesResident, NULL);
   ary = rb_Array(arg1);
   size = (int)RARRAY_LENINT(ary);
   textures = ALLOC_N(GLuint,size);
   residences = ALLOC_N(GLboolean,size);
   ary2cuint(ary,textures,size);
-  r = glAreTexturesResident(size,textures,residences);
+  r = fptr_glAreTexturesResident(size,textures,residences);
   retary = rb_ary_new2(size);
   if (r==GL_TRUE) { /* all are resident */
     for(i=0;i<size;i++)
@@ -2288,6 +2566,9 @@ VALUE obj,arg1,arg2;
   GLuint *textures;
   GLclampf *priorities;
   GLsizei size;
+  DECL_GL_FUNC_PTR(void,glPrioritizeTextures,(GLsizei n, const GLuint *textures, const GLclampf *priorities));
+
+  LOAD_GL_FUNC(glPrioritizeTextures, NULL);
   Check_Type(arg1,T_ARRAY);
   Check_Type(arg2,T_ARRAY);
   if ((size = (GLsizei)RARRAY_LENINT(arg1)) != (GLsizei)RARRAY_LENINT(arg2))
@@ -2296,7 +2577,7 @@ VALUE obj,arg1,arg2;
   priorities = ALLOC_N(GLclampf,size);
   ary2cuint(arg1,textures,size);
   ary2cflt(arg2,priorities,size);
-  glPrioritizeTextures(size,textures,priorities);
+  fptr_glPrioritizeTextures(size,textures,priorities);
   xfree(textures);
   xfree(priorities);
   CHECK_GLERROR_FROM("glPrioritizeTextures");
@@ -2308,9 +2589,12 @@ gl_Indexubv(obj,arg1)
 VALUE obj,arg1;
 {
   GLubyte c[1] = {0};
+  DECL_GL_FUNC_PTR(void,glIndexubv,(const GLubyte *c));
+
+  LOAD_GL_FUNC(glIndexubv, NULL);
   Check_Type(arg1,T_ARRAY);
   ary2cubyte(arg1,c,1);
-  glIndexubv(c);
+  fptr_glIndexubv(c);
   CHECK_GLERROR_FROM("glIndexubv");
   return Qnil;
 }
@@ -2681,395 +2965,381 @@ VALUE obj,arg1,arg2,arg3;
 }
 
 /* init */
-void gl_init_functions_1_0__1_1(VALUE module)
+void gl_init_functions_1_0__1_1(VALUE klass)
 {
-  g_FogCoord_ptr = 0; /* for use in gl-1.4.c */
-  g_SecondaryColor_ptr = 0; /* for use in gl-1.4.c */
-
   /* 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, 2);
-  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, 2);
-  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, -1);
-  rb_define_module_function(module, "glPixelMapuiv", gl_PixelMapuiv, -1);
-  rb_define_module_function(module, "glPixelMapusv", gl_PixelMapusv, -1);
-  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, -1);
-  rb_define_module_function(module, "glDrawPixels", gl_DrawPixels, 5);
-  rb_define_module_function(module, "glGetBooleanv", gl_GetBooleanv, 1);
-  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, 1);
-  rb_define_module_function(module, "glGetIntegerv", gl_GetIntegerv, 1);
-  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, -1);
-  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);
+  rb_define_method(klass, "glNewList", gl_NewList, 2);
+  rb_define_method(klass, "glEndList", gl_EndList, 0);
+  rb_define_method(klass, "glCallList", gl_CallList, 1);
+  rb_define_method(klass, "glCallLists", gl_CallLists, 2);
+  rb_define_method(klass, "glDeleteLists", gl_DeleteLists, 2);
+  rb_define_method(klass, "glGenLists", gl_GenLists, 1);
+  rb_define_method(klass, "glListBase", gl_ListBase, 1);
+  rb_define_method(klass, "glBegin", gl_Begin, 1);
+  rb_define_method(klass, "glBitmap", gl_Bitmap, 7);
+  rb_define_method(klass, "glColor3b", gl_Color3b, 3);
+  rb_define_method(klass, "glColor3d", gl_Color3d, 3);
+  rb_define_method(klass, "glColor3f", gl_Color3f, 3);
+  rb_define_method(klass, "glColor3i", gl_Color3i, 3);
+  rb_define_method(klass, "glColor3s", gl_Color3s, 3);
+  rb_define_method(klass, "glColor3ub", gl_Color3ub, 3);
+  rb_define_method(klass, "glColor3ui", gl_Color3ui, 3);
+  rb_define_method(klass, "glColor3us", gl_Color3us, 3);
+  rb_define_method(klass, "glColor4b", gl_Color4b, 4);
+  rb_define_method(klass, "glColor4d", gl_Color4d, 4);
+  rb_define_method(klass, "glColor4f", gl_Color4f, 4);
+  rb_define_method(klass, "glColor4i", gl_Color4i, 4);
+  rb_define_method(klass, "glColor4s", gl_Color4s, 4);
+  rb_define_method(klass, "glColor4ub", gl_Color4ub, 4);
+  rb_define_method(klass, "glColor4ui", gl_Color4ui, 4);
+  rb_define_method(klass, "glColor4us", gl_Color4us, 4);
+  rb_define_method(klass, "glEdgeFlag", gl_EdgeFlag, 1);
+  rb_define_method(klass, "glEdgeFlagv", gl_EdgeFlagv, 1);
+  rb_define_method(klass, "glEnd", gl_End, 0);
+  rb_define_method(klass, "glIndexd", gl_Indexd, 1);
+  rb_define_method(klass, "glIndexdv", gl_Indexdv, 1);
+  rb_define_method(klass, "glIndexf", gl_Indexf, 1);
+  rb_define_method(klass, "glIndexfv", gl_Indexfv, 1);
+  rb_define_method(klass, "glIndexi", gl_Indexi, 1);
+  rb_define_method(klass, "glIndexiv", gl_Indexiv, 1);
+  rb_define_method(klass, "glIndexs", gl_Indexs, 1);
+  rb_define_method(klass, "glIndexsv", gl_Indexsv, 1);
+  rb_define_method(klass, "glNormal3b", gl_Normal3b, 3);
+  rb_define_method(klass, "glNormal3d", gl_Normal3d, 3);
+  rb_define_method(klass, "glNormal3f", gl_Normal3f, 3);
+  rb_define_method(klass, "glNormal3i", gl_Normal3i, 3);
+  rb_define_method(klass, "glNormal3s", gl_Normal3s, 3);
+  rb_define_method(klass, "glRasterPos2d", gl_RasterPos2d, 2);
+  rb_define_method(klass, "glRasterPos2f", gl_RasterPos2f, 2);
+  rb_define_method(klass, "glRasterPos2i", gl_RasterPos2i, 2);
+  rb_define_method(klass, "glRasterPos2s", gl_RasterPos2s, 2);
+  rb_define_method(klass, "glRasterPos3d", gl_RasterPos3d, 3);
+  rb_define_method(klass, "glRasterPos3f", gl_RasterPos3f, 3);
+  rb_define_method(klass, "glRasterPos3i", gl_RasterPos3i, 3);
+  rb_define_method(klass, "glRasterPos3s", gl_RasterPos3s, 3);
+  rb_define_method(klass, "glRasterPos4d", gl_RasterPos4d, 4);
+  rb_define_method(klass, "glRasterPos4f", gl_RasterPos4f, 4);
+  rb_define_method(klass, "glRasterPos4i", gl_RasterPos4i, 4);
+  rb_define_method(klass, "glRasterPos4s", gl_RasterPos4s, 4);
+  rb_define_method(klass, "glRectd", gl_Rectd, 4);
+  rb_define_method(klass, "glRectf", gl_Rectf, 4);
+  rb_define_method(klass, "glRecti", gl_Recti, 4);
+  rb_define_method(klass, "glRects", gl_Rects, 4);
+  rb_define_method(klass, "glTexCoord1d", gl_TexCoord1d, 1);
+  rb_define_method(klass, "glTexCoord1f", gl_TexCoord1f, 1);
+  rb_define_method(klass, "glTexCoord1i", gl_TexCoord1i, 1);
+  rb_define_method(klass, "glTexCoord1s", gl_TexCoord1s, 1);
+  rb_define_method(klass, "glTexCoord2d", gl_TexCoord2d, 2);
+  rb_define_method(klass, "glTexCoord2f", gl_TexCoord2f, 2);
+  rb_define_method(klass, "glTexCoord2i", gl_TexCoord2i, 2);
+  rb_define_method(klass, "glTexCoord2s", gl_TexCoord2s, 2);
+  rb_define_method(klass, "glTexCoord3d", gl_TexCoord3d, 3);
+  rb_define_method(klass, "glTexCoord3f", gl_TexCoord3f, 3);
+  rb_define_method(klass, "glTexCoord3i", gl_TexCoord3i, 3);
+  rb_define_method(klass, "glTexCoord3s", gl_TexCoord3s, 3);
+  rb_define_method(klass, "glTexCoord4d", gl_TexCoord4d, 4);
+  rb_define_method(klass, "glTexCoord4f", gl_TexCoord4f, 4);
+  rb_define_method(klass, "glTexCoord4i", gl_TexCoord4i, 4);
+  rb_define_method(klass, "glTexCoord4s", gl_TexCoord4s, 4);
+  rb_define_method(klass, "glVertex2d", gl_Vertex2d, 2);
+  rb_define_method(klass, "glVertex2f", gl_Vertex2f, 2);
+  rb_define_method(klass, "glVertex2i", gl_Vertex2i, 2);
+  rb_define_method(klass, "glVertex2s", gl_Vertex2s, 2);
+  rb_define_method(klass, "glVertex3d", gl_Vertex3d, 3);
+  rb_define_method(klass, "glVertex3f", gl_Vertex3f, 3);
+  rb_define_method(klass, "glVertex3i", gl_Vertex3i, 3);
+  rb_define_method(klass, "glVertex3s", gl_Vertex3s, 3);
+  rb_define_method(klass, "glVertex4d", gl_Vertex4d, 4);
+  rb_define_method(klass, "glVertex4f", gl_Vertex4f, 4);
+  rb_define_method(klass, "glVertex4i", gl_Vertex4i, 4);
+  rb_define_method(klass, "glVertex4s", gl_Vertex4s, 4);
+  rb_define_method(klass, "glClipPlane", gl_ClipPlane, 2);
+  rb_define_method(klass, "glColorMaterial", gl_ColorMaterial, 2);
+  rb_define_method(klass, "glCullFace", gl_CullFace, 1);
+  rb_define_method(klass, "glFogf", gl_Fogf, 2);
+  rb_define_method(klass, "glFogfv", gl_Fogfv, 2);
+  rb_define_method(klass, "glFogi", gl_Fogi, 2);
+  rb_define_method(klass, "glFogiv", gl_Fogiv, 2);
+  rb_define_method(klass, "glFrontFace", gl_FrontFace, 1);
+  rb_define_method(klass, "glHint", gl_Hint, 2);
+  rb_define_method(klass, "glLightf", gl_Lightf, 3);
+  rb_define_method(klass, "glLightfv", gl_Lightfv, 3);
+  rb_define_method(klass, "glLighti", gl_Lighti, 3);
+  rb_define_method(klass, "glLightiv", gl_Lightiv, 3);
+  rb_define_method(klass, "glLightModelf", gl_LightModelf, 2);
+  rb_define_method(klass, "glLightModelfv", gl_LightModelfv, 2);
+  rb_define_method(klass, "glLightModeli", gl_LightModeli, 2);
+  rb_define_method(klass, "glLightModeliv", gl_LightModeliv, 2);
+  rb_define_method(klass, "glLineStipple", gl_LineStipple, 2);
+  rb_define_method(klass, "glLineWidth", gl_LineWidth, 1);
+  rb_define_method(klass, "glMaterialf", gl_Materialf, 3);
+  rb_define_method(klass, "glMaterialfv", gl_Materialfv, 3);
+  rb_define_method(klass, "glMateriali", gl_Materiali, 3);
+  rb_define_method(klass, "glMaterialiv", gl_Materialiv, 3);
+  rb_define_method(klass, "glPointSize", gl_PointSize, 1);
+  rb_define_method(klass, "glPolygonMode", gl_PolygonMode, 2);
+  rb_define_method(klass, "glPolygonStipple", gl_PolygonStipple, 1);
+  rb_define_method(klass, "glScissor", gl_Scissor, 4);
+  rb_define_method(klass, "glShadeModel", gl_ShadeModel, 1);
+  rb_define_method(klass, "glTexParameterf", gl_TexParameterf, 3);
+  rb_define_method(klass, "glTexParameterfv", gl_TexParameterfv, 3);
+  rb_define_method(klass, "glTexParameteri", gl_TexParameteri, 3);
+  rb_define_method(klass, "glTexParameteriv", gl_TexParameteriv, 3);
+  rb_define_method(klass, "glTexImage1D", gl_TexImage1D, 8);
+  rb_define_method(klass, "glTexImage2D", gl_TexImage2D, 9);
+  rb_define_method(klass, "glTexEnvf", gl_TexEnvf, 3);
+  rb_define_method(klass, "glTexEnvfv", gl_TexEnvfv, 3);
+  rb_define_method(klass, "glTexEnvi", gl_TexEnvi, 3);
+  rb_define_method(klass, "glTexEnviv", gl_TexEnviv, 3);
+  rb_define_method(klass, "glTexGend", gl_TexGend, 3);
+  rb_define_method(klass, "glTexGendv", gl_TexGendv, 3);
+  rb_define_method(klass, "glTexGenf", gl_TexGenf, 3);
+  rb_define_method(klass, "glTexGenfv", gl_TexGenfv, 3);
+  rb_define_method(klass, "glTexGeni", gl_TexGeni, 3);
+  rb_define_method(klass, "glTexGeniv", gl_TexGeniv, 3);
+  rb_define_method(klass, "glFeedbackBuffer", gl_FeedbackBuffer, 2);
+  rb_define_method(klass, "glSelectBuffer", gl_SelectBuffer, 1);
+  rb_define_method(klass, "glRenderMode", gl_RenderMode, 1);
+  rb_define_method(klass, "glInitNames", gl_InitNames, 0);
+  rb_define_method(klass, "glLoadName", gl_LoadName, 1);
+  rb_define_method(klass, "glPassThrough", gl_PassThrough, 1);
+  rb_define_method(klass, "glPopName", gl_PopName, 0);
+  rb_define_method(klass, "glPushName", gl_PushName, 1);
+  rb_define_method(klass, "glDrawBuffer", gl_DrawBuffer, 1);
+  rb_define_method(klass, "glClear", gl_Clear, 1);
+  rb_define_method(klass, "glClearAccum", gl_ClearAccum, 4);
+  rb_define_method(klass, "glClearIndex", gl_ClearIndex, 1);
+  rb_define_method(klass, "glClearColor", gl_ClearColor, 4);
+  rb_define_method(klass, "glClearStencil", gl_ClearStencil, 1);
+  rb_define_method(klass, "glClearDepth", gl_ClearDepth, 1);
+  rb_define_method(klass, "glStencilMask", gl_StencilMask, 1);
+  rb_define_method(klass, "glColorMask", gl_ColorMask, 4);
+  rb_define_method(klass, "glDepthMask", gl_DepthMask, 1);
+  rb_define_method(klass, "glIndexMask", gl_IndexMask, 1);
+  rb_define_method(klass, "glAccum", gl_Accum, 2);
+  rb_define_method(klass, "glDisable", gl_Disable, -1);
+  rb_define_method(klass, "glEnable", gl_Enable, -1);
+  rb_define_method(klass, "glFinish", gl_Finish, 0);
+  rb_define_method(klass, "glFlush", gl_Flush, 0);
+  rb_define_method(klass, "glPopAttrib", gl_PopAttrib, 0);
+  rb_define_method(klass, "glPushAttrib", gl_PushAttrib, 1);
+  rb_define_method(klass, "glMap1d", gl_Map1d, 6);
+  rb_define_method(klass, "glMap1f", gl_Map1f, 6);
+  rb_define_method(klass, "glMap2d", gl_Map2d, 10);
+  rb_define_method(klass, "glMap2f", gl_Map2f, 10);
+  rb_define_method(klass, "glMapGrid1d", gl_MapGrid1d, 3);
+  rb_define_method(klass, "glMapGrid1f", gl_MapGrid1f, 3);
+  rb_define_method(klass, "glMapGrid2d", gl_MapGrid2d, 6);
+  rb_define_method(klass, "glMapGrid2f", gl_MapGrid2f, 6);
+  rb_define_method(klass, "glEvalCoord1d", gl_EvalCoord1d, 1);
+  rb_define_method(klass, "glEvalCoord1dv", gl_EvalCoord1dv, 1);
+  rb_define_method(klass, "glEvalCoord1f", gl_EvalCoord1f, 1);
+  rb_define_method(klass, "glEvalCoord1fv", gl_EvalCoord1fv, 1);
+  rb_define_method(klass, "glEvalCoord2d", gl_EvalCoord2d, 2);
+  rb_define_method(klass, "glEvalCoord2dv", gl_EvalCoord2dv, 1);
+  rb_define_method(klass, "glEvalCoord2f", gl_EvalCoord2f, 2);
+  rb_define_method(klass, "glEvalCoord2fv", gl_EvalCoord2fv, 1);
+  rb_define_method(klass, "glEvalMesh1", gl_EvalMesh1, 3);
+  rb_define_method(klass, "glEvalPoint1", gl_EvalPoint1, 1);
+  rb_define_method(klass, "glEvalMesh2", gl_EvalMesh2, 5);
+  rb_define_method(klass, "glEvalPoint2", gl_EvalPoint2, 2);
+  rb_define_method(klass, "glAlphaFunc", gl_AlphaFunc, 2);
+  rb_define_method(klass, "glBlendFunc", gl_BlendFunc, 2);
+  rb_define_method(klass, "glLogicOp", gl_LogicOp, 1);
+  rb_define_method(klass, "glStencilFunc", gl_StencilFunc, 3);
+  rb_define_method(klass, "glStencilOp", gl_StencilOp, 3);
+  rb_define_method(klass, "glDepthFunc", gl_DepthFunc, 1);
+  rb_define_method(klass, "glPixelZoom", gl_PixelZoom, 2);
+  rb_define_method(klass, "glPixelTransferf", gl_PixelTransferf, 2);
+  rb_define_method(klass, "glPixelTransferi", gl_PixelTransferi, 2);
+  rb_define_method(klass, "glPixelStoref", gl_PixelStoref, 2);
+  rb_define_method(klass, "glPixelStorei", gl_PixelStorei, 2);
+  rb_define_method(klass, "glPixelMapfv", gl_PixelMapfv, -1);
+  rb_define_method(klass, "glPixelMapuiv", gl_PixelMapuiv, -1);
+  rb_define_method(klass, "glPixelMapusv", gl_PixelMapusv, -1);
+  rb_define_method(klass, "glReadBuffer", gl_ReadBuffer, 1);
+  rb_define_method(klass, "glCopyPixels", gl_CopyPixels, 5);
+  rb_define_method(klass, "glReadPixels", gl_ReadPixels, -1);
+  rb_define_method(klass, "glDrawPixels", gl_DrawPixels, 5);
+  rb_define_method(klass, "glGetBooleanv", gl_GetBooleanv, 1);
+  rb_define_method(klass, "glGetClipPlane", gl_GetClipPlane, 1);
+  rb_define_method(klass, "glGetDoublev", gl_GetDoublev, 1);
+  rb_define_method(klass, "glGetError", gl_GetError, 0);
+  rb_define_method(klass, "glGetFloatv", gl_GetFloatv, 1);
+  rb_define_method(klass, "glGetIntegerv", gl_GetIntegerv, 1);
+  rb_define_method(klass, "glGetLightfv", gl_GetLightfv, 2);
+  rb_define_method(klass, "glGetLightiv", gl_GetLightiv, 2);
+  rb_define_method(klass, "glGetMapdv", gl_GetMapdv, 2);
+  rb_define_method(klass, "glGetMapfv", gl_GetMapfv, 2);
+  rb_define_method(klass, "glGetMapiv", gl_GetMapiv, 2);
+  rb_define_method(klass, "glGetMaterialfv", gl_GetMaterialfv, 2);
+  rb_define_method(klass, "glGetMaterialiv", gl_GetMaterialiv, 2);
+  rb_define_method(klass, "glGetPixelMapfv", gl_GetPixelMapfv, -1);
+  rb_define_method(klass, "glGetPixelMapuiv", gl_GetPixelMapuiv, -1);
+  rb_define_method(klass, "glGetPixelMapusv", gl_GetPixelMapusv, -1);
+  rb_define_method(klass, "glGetPolygonStipple", gl_GetPolygonStipple, -1);
+  rb_define_method(klass, "glGetString", gl_GetString, 1);
+  rb_define_method(klass, "glGetTexEnvfv", gl_GetTexEnvfv, 2);
+  rb_define_method(klass, "glGetTexEnviv", gl_GetTexEnviv, 2);
+  rb_define_method(klass, "glGetTexGendv", gl_GetTexGendv, 2);
+  rb_define_method(klass, "glGetTexGenfv", gl_GetTexGenfv, 2);
+  rb_define_method(klass, "glGetTexGeniv", gl_GetTexGeniv, 2);
+  rb_define_method(klass, "glGetTexImage", gl_GetTexImage, -1);
+  rb_define_method(klass, "glGetTexParameterfv", gl_GetTexParameterfv, 2);
+  rb_define_method(klass, "glGetTexParameteriv", gl_GetTexParameteriv, 2);
+  rb_define_method(klass, "glGetTexLevelParameterfv", gl_GetTexLevelParameterfv, 3);
+  rb_define_method(klass, "glGetTexLevelParameteriv", gl_GetTexLevelParameteriv, 3);
+  rb_define_method(klass, "glIsEnabled", gl_IsEnabled, 1);
+  rb_define_method(klass, "glIsList", gl_IsList, 1);
+  rb_define_method(klass, "glDepthRange", gl_DepthRange, 2);
+  rb_define_method(klass, "glFrustum", gl_Frustum, 6);
+  rb_define_method(klass, "glLoadIdentity", gl_LoadIdentity, 0);
+  rb_define_method(klass, "glLoadMatrixf", gl_LoadMatrixf, 1);
+  rb_define_method(klass, "glLoadMatrixd", gl_LoadMatrixd, 1);
+  rb_define_method(klass, "glMatrixMode", gl_MatrixMode, 1);
+  rb_define_method(klass, "glMultMatrixf", gl_MultMatrixf, 1);
+  rb_define_method(klass, "glMultMatrixd", gl_MultMatrixd, 1);
+  rb_define_method(klass, "glOrtho", gl_Ortho, 6);
+  rb_define_method(klass, "glPopMatrix", gl_PopMatrix, 0);
+  rb_define_method(klass, "glPushMatrix", gl_PushMatrix, 0);
+  rb_define_method(klass, "glRotated", gl_Rotated, 4);
+  rb_define_method(klass, "glRotatef", gl_Rotatef, 4);
+  rb_define_method(klass, "glScaled", gl_Scaled, 3);
+  rb_define_method(klass, "glScalef", gl_Scalef, 3);
+  rb_define_method(klass, "glTranslated", gl_Translated, 3);
+  rb_define_method(klass, "glTranslatef", gl_Translatef, 3);
+  rb_define_method(klass, "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, 1);
-  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);
+  rb_define_method(klass, "glArrayElement", gl_ArrayElement, 1);
+  rb_define_method(klass, "glColorPointer", gl_ColorPointer, 4);
+  rb_define_method(klass, "glDisableClientState", gl_DisableClientState, -1);
+  rb_define_method(klass, "glDrawArrays", gl_DrawArrays, 3);
+  rb_define_method(klass, "glDrawElements", gl_DrawElements, 4);
+  rb_define_method(klass, "glEdgeFlagPointer", gl_EdgeFlagPointer, 2);
+  rb_define_method(klass, "glEnableClientState", gl_EnableClientState, -1);
+  rb_define_method(klass, "glGetPointerv", gl_GetPointerv, 1);
+  rb_define_method(klass, "glIndexPointer", gl_IndexPointer, 3);
+  rb_define_method(klass, "glInterleavedArrays", gl_InterleavedArrays, 3);
+  rb_define_method(klass, "glNormalPointer", gl_NormalPointer, 3);
+  rb_define_method(klass, "glTexCoordPointer", gl_TexCoordPointer, 4);
+  rb_define_method(klass, "glVertexPointer", gl_VertexPointer, 4);
+  rb_define_method(klass, "glPolygonOffset", gl_PolygonOffset, 2);
+  rb_define_method(klass, "glCopyTexImage1D", gl_CopyTexImage1D, 7);
+  rb_define_method(klass, "glCopyTexImage2D", gl_CopyTexImage2D, 8);
+  rb_define_method(klass, "glCopyTexSubImage1D", gl_CopyTexSubImage1D, 6);
+  rb_define_method(klass, "glCopyTexSubImage2D", gl_CopyTexSubImage2D, 8);
+  rb_define_method(klass, "glTexSubImage1D", gl_TexSubImage1D, 7);
+  rb_define_method(klass, "glTexSubImage2D", gl_TexSubImage2D, 9);
+  rb_define_method(klass, "glAreTexturesResident", gl_AreTexturesResident, 1);
+  rb_define_method(klass, "glBindTexture", gl_BindTexture, 2);
+  rb_define_method(klass, "glDeleteTextures", gl_DeleteTextures, 1);
+  rb_define_method(klass, "glGenTextures", gl_GenTextures, 1);
+  rb_define_method(klass, "glIsTexture", gl_IsTexture, 1);
+  rb_define_method(klass, "glPrioritizeTextures", gl_PrioritizeTextures, 2);
+  rb_define_method(klass, "glIndexub", gl_Indexub, 1);
+  rb_define_method(klass, "glIndexubv", gl_Indexubv, 1);
+  rb_define_method(klass, "glPopClientAttrib", gl_PopClientAttrib, 0);
+  rb_define_method(klass, "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, "glRasterPos2dv", gl_RasterPosdv, -1);
-  rb_define_module_function(module, "glRasterPos2fv", gl_RasterPosfv, -1);
-  rb_define_module_function(module, "glRasterPos2iv", gl_RasterPosiv, -1);
-  rb_define_module_function(module, "glRasterPos2sv", gl_RasterPossv, -1);
-  rb_define_module_function(module, "glRasterPos3dv", gl_RasterPosdv, -1);
-  rb_define_module_function(module, "glRasterPos3fv", gl_RasterPosfv, -1);
-  rb_define_module_function(module, "glRasterPos3iv", gl_RasterPosiv, -1);
-  rb_define_module_function(module, "glRasterPos3sv", gl_RasterPossv, -1);
-  rb_define_module_function(module, "glRasterPos4dv", gl_RasterPosdv, -1);
-  rb_define_module_function(module, "glRasterPos4fv", gl_RasterPosfv, -1);
-  rb_define_module_function(module, "glRasterPos4iv", gl_RasterPosiv, -1);
-  rb_define_module_function(module, "glRasterPos4sv", 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);
+  rb_define_method(klass, "glColor", gl_Colordv, -1);
+  rb_define_method(klass, "glColor3bv", gl_Colorbv, -1);
+  rb_define_method(klass, "glColor3dv", gl_Colordv, -1);
+  rb_define_method(klass, "glColor3fv", gl_Colorfv, -1);
+  rb_define_method(klass, "glColor3iv", gl_Coloriv, -1);
+  rb_define_method(klass, "glColor3sv", gl_Colorsv, -1);
+  rb_define_method(klass, "glColor3ubv", gl_Colorubv, -1);
+  rb_define_method(klass, "glColor3uiv", gl_Coloruiv, -1);
+  rb_define_method(klass, "glColor3usv", gl_Colorusv, -1);
+  rb_define_method(klass, "glColor4bv", gl_Colorbv, -1);
+  rb_define_method(klass, "glColor4dv", gl_Colordv, -1);
+  rb_define_method(klass, "glColor4fv", gl_Colorfv, -1);
+  rb_define_method(klass, "glColor4iv", gl_Coloriv, -1);
+  rb_define_method(klass, "glColor4sv", gl_Colorsv, -1);
+  rb_define_method(klass, "glColor4ubv", gl_Colorubv, -1);
+  rb_define_method(klass, "glColor4uiv", gl_Coloruiv, -1);
+  rb_define_method(klass, "glColor4usv", gl_Colorusv, -1);
+
+  rb_define_method(klass, "glNormal", gl_Normaldv, -1);
+  rb_define_method(klass, "glNormal3bv", gl_Normalbv, -1);
+  rb_define_method(klass, "glNormal3dv", gl_Normaldv, -1);
+  rb_define_method(klass, "glNormal3fv", gl_Normalfv, -1);
+  rb_define_method(klass, "glNormal3iv", gl_Normaliv, -1);
+  rb_define_method(klass, "glNormal3sv", gl_Normalsv, -1);
+
+  rb_define_method(klass, "glRasterPos", gl_RasterPosdv, -1);
+  rb_define_method(klass, "glRasterPos2dv", gl_RasterPosdv, -1);
+  rb_define_method(klass, "glRasterPos2fv", gl_RasterPosfv, -1);
+  rb_define_method(klass, "glRasterPos2iv", gl_RasterPosiv, -1);
+  rb_define_method(klass, "glRasterPos2sv", gl_RasterPossv, -1);
+  rb_define_method(klass, "glRasterPos3dv", gl_RasterPosdv, -1);
+  rb_define_method(klass, "glRasterPos3fv", gl_RasterPosfv, -1);
+  rb_define_method(klass, "glRasterPos3iv", gl_RasterPosiv, -1);
+  rb_define_method(klass, "glRasterPos3sv", gl_RasterPossv, -1);
+  rb_define_method(klass, "glRasterPos4dv", gl_RasterPosdv, -1);
+  rb_define_method(klass, "glRasterPos4fv", gl_RasterPosfv, -1);
+  rb_define_method(klass, "glRasterPos4iv", gl_RasterPosiv, -1);
+  rb_define_method(klass, "glRasterPos4sv", gl_RasterPossv, -1);
+
+  rb_define_method(klass, "glRect", gl_Rectdv, -1);
+  rb_define_method(klass, "glRectdv", gl_Rectdv, -1);
+  rb_define_method(klass, "glRectfv", gl_Rectfv, -1);
+  rb_define_method(klass, "glRectiv", gl_Rectiv, -1);
+  rb_define_method(klass, "glRectsv", gl_Rectsv, -1);
+
+  rb_define_method(klass, "glTexCoord", gl_TexCoorddv, -1);
+  rb_define_method(klass, "glTexCoord1dv", gl_TexCoorddv, -1);
+  rb_define_method(klass, "glTexCoord1fv", gl_TexCoordfv, -1);
+  rb_define_method(klass, "glTexCoord1iv", gl_TexCoordiv, -1);
+  rb_define_method(klass, "glTexCoord1sv", gl_TexCoordsv, -1);
+  rb_define_method(klass, "glTexCoord2dv", gl_TexCoorddv, -1);
+  rb_define_method(klass, "glTexCoord2fv", gl_TexCoordfv, -1);
+  rb_define_method(klass, "glTexCoord2iv", gl_TexCoordiv, -1);
+  rb_define_method(klass, "glTexCoord2sv", gl_TexCoordsv, -1);
+  rb_define_method(klass, "glTexCoord3dv", gl_TexCoorddv, -1);
+  rb_define_method(klass, "glTexCoord3fv", gl_TexCoordfv, -1);
+  rb_define_method(klass, "glTexCoord3iv", gl_TexCoordiv, -1);
+  rb_define_method(klass, "glTexCoord3sv", gl_TexCoordsv, -1);
+  rb_define_method(klass, "glTexCoord4dv", gl_TexCoorddv, -1);
+  rb_define_method(klass, "glTexCoord4fv", gl_TexCoordfv, -1);
+  rb_define_method(klass, "glTexCoord4iv", gl_TexCoordiv, -1);
+  rb_define_method(klass, "glTexCoord4sv", gl_TexCoordsv, -1);
+
+  rb_define_method(klass, "glVertex", gl_Vertexdv, -1);
+  rb_define_method(klass, "glVertex2dv", gl_Vertexdv, -1);
+  rb_define_method(klass, "glVertex2fv", gl_Vertexfv, -1);
+  rb_define_method(klass, "glVertex2iv", gl_Vertexiv, -1);
+  rb_define_method(klass, "glVertex2sv", gl_Vertexsv, -1);
+  rb_define_method(klass, "glVertex3dv", gl_Vertexdv, -1);
+  rb_define_method(klass, "glVertex3fv", gl_Vertexfv, -1);
+  rb_define_method(klass, "glVertex3iv", gl_Vertexiv, -1);
+  rb_define_method(klass, "glVertex3sv", gl_Vertexsv, -1);
+  rb_define_method(klass, "glVertex4dv", gl_Vertexdv, -1);
+  rb_define_method(klass, "glVertex4fv", gl_Vertexfv, -1);
+  rb_define_method(klass, "glVertex4iv", gl_Vertexiv, -1);
+  rb_define_method(klass, "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);
+  rb_define_method(klass, "glLightModel", gl_LightModel, 2);
+  rb_define_method(klass, "glMaterial", gl_Material, 3);
+  rb_define_method(klass, "glFog", gl_Fog, 2);
+  rb_define_method(klass, "glLight", gl_Light, 3);
+  rb_define_method(klass, "glTexParameter", gl_TexParameter, 3);
+  rb_define_method(klass, "glTexEnv", gl_TexEnv, 3);
+  rb_define_method(klass, "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);
+  rb_define_method(klass, "glMultMatrix", gl_MultMatrixd, 1);
+  rb_define_method(klass, "glLoadMatrix", gl_LoadMatrixd, 1);
+  rb_define_method(klass, "glRotate", gl_Rotated, 4);
+  rb_define_method(klass, "glScale", gl_Scaled, 3);
+  rb_define_method(klass, "glTranslate", gl_Translated, 3);
+
+  rb_define_method(klass, "glPixelStore", gl_PixelStoref, 2);
+  rb_define_method(klass, "glPixelTransfer", gl_PixelTransferf, 2);
+  rb_define_method(klass, "glIndex", gl_Indexi, 1);
+  rb_define_method(klass, "glGetMaterial", gl_GetMaterialfv, 2);
+  rb_define_method(klass, "glGetDouble", gl_GetDoublev, 1);
 }