opengl 0.7.0-x86-mingw32 → 0.8.0.pre1-x86-mingw32

data/History.rdoc

@@ -1,18 +1,6 @@
-=== 0.7.0 / 2013-02-03
+=== 0.8 / master HEAD
 
-* Better support of 64 bit systems.
-* Replace mkrf with extconf.rb, hoe and rake-compiler.
-* Switch to dlopen() from deprecated NSAddImage() and friends for OS X.
-* glBegin, glPushMatrix, glEnable and glEnableClientState now accept a block.
-* glEnable/glDisable and glEnableClientState/glDisableClientState now accept
-  multiple arguments.
-* Allow to_a-able objects for glColor*v, glRasterPos*v, glRect*v, glTexCoord*v,
-  glMaterial, glNormal and glVertex.
-* Fix unused param count in ARY2CMAT.
-* Fix a lot of bugs in the test suite.
-* Merge opengl C extensions into a single extension to avoid code duplication
-  in extconf.rb and simplify rebuilding based on header changes.
-* Add cross compilation tasks with download of freeglut for binary windows gems
+* drop support for Ruby 1.8
 
 === 0.60.1 / 2009-02-16
 

data/Manifest.txt

@@ -121,10 +121,12 @@ ext/opengl/gl-ext-gremedy.c
 ext/opengl/gl-ext-nv.c
 ext/opengl/gl-types.h
 ext/opengl/gl.c
+ext/opengl/gl_buffer.c
 ext/opengl/glu-enums.c
 ext/opengl/glu-enums.h
 ext/opengl/glu.c
 ext/opengl/glut.c
+ext/opengl/glut_callbacks.c
 ext/opengl/opengl.c
 lib/gl.rb
 lib/glu.rb
@@ -145,6 +147,7 @@ test/test_gl_ext_ext.rb
 test/test_gl_ext_gremedy.rb
 test/test_gl_ext_nv.rb
 test/test_glu.rb
+test/test_opengl_buffer.rb
 utils/README
 utils/enumgen.rb
 utils/extlistgen.rb

data/README.rdoc

@@ -1,6 +1,6 @@
 = opengl
 
-source :: https://github.com/larskanis/opengl/tree/0.7
+source :: https://github.com/drbrain/opengl
 docs   :: http://ruby-opengl.rubyforge.org
 bugs   :: https://github.com/drbrain/opengl/issues
 email  :: mailto:ruby-opengl-devel@rubyforge.org
@@ -10,9 +10,6 @@ email  :: mailto:ruby-opengl-devel@rubyforge.org
 An OpenGL wrapper for Ruby.  ruby-opengl contains bindings for OpenGL and the
 GLU and GLUT libraries.
 
-* This branch is for compatibility with Ruby 1.8. Latest development is for
-  Ruby 1.9.2+ only, on master branch: https://github.com/larskanis/opengl
-
 == Features and Problems
 
 * available for Windows, Linux, OS-X
@@ -24,12 +21,13 @@ GLU and GLUT libraries.
 
 == Requirements
 
-* Ruby 1.8.7+
+* Ruby 1.9.2+
+  *  see https://github.com/larskanis/opengl/tree/0.7 for Ruby 1.8.x compatible branch
 * proper OpenGL, GLU and (free-)GLUT development files installed
 
 == Install
 
-  gem install opengl -v "~>0.7.0"
+  gem install opengl --pre
 
 == Developers
 
@@ -50,11 +48,9 @@ DLLs.
 
 Install mingw32 or w64 using the instructions in rake-compiler's README.
 For Debian/Ubuntu it is <tt>apt-get install gcc-mingw-w64</tt> .
-Use ruby-1.8.7 for the following commands.
 
-Download and cross compile ruby 1.8 and 1.9 for win32 with:
+Download and cross compile ruby 1.9 for win32 with:
 
-  rake-compiler cross-ruby VERSION=1.8.7-p357
   rake-compiler cross-ruby VERSION=1.9.3-p0
 
 Download and cross compile opengl for win32:
@@ -63,7 +59,7 @@ Download and cross compile opengl for win32:
 
 or with custom versions:
 
-  rake cross native gem RUBY_CC_VERSION=1.8.7:1.9.3 LIBFREEGLUT_VERSION=2.8.0
+  rake cross native gem RUBY_CC_VERSION=1.9.3 LIBFREEGLUT_VERSION=2.8.0
 
 If everything works, there should be ruby-opengl-VERSION-x86-mingw32.gem in the pkg
 directory.

data/Rakefile

@@ -32,11 +32,10 @@ hoe = Hoe.spec 'opengl' do
   self.extra_rdoc_files = FileList['*.rdoc']
 
   extra_dev_deps << ['rake-compiler', '~> 0.7', '>= 0.7.9']
-  extra_dev_deps << ['minitest', '~> 3.0']
 
   self.spec_extras = {
     :extensions            => %w[ext/opengl/extconf.rb],
-    :required_ruby_version => '>= 1.8.7',
+    :required_ruby_version => '>= 1.9.2',
   }
 end
 

data/Rakefile.cross

@@ -9,7 +9,7 @@ require 'uri'
 require 'rbconfig'
 require 'pathname'
 
-ENV['RUBY_CC_VERSION'] ||= '1.8.7:1.9.3'
+ENV['RUBY_CC_VERSION'] ||= '1.9.3'
 
 # Cross-compilation constants
 COMPILE_HOME               = Pathname( "build" ).expand_path

data/ext/opengl/common.h

@@ -434,6 +434,17 @@ static inline VALUE pack_array_or_pass_string(GLenum type,VALUE ary)
 	return rb_funcall(ary,rb_intern("pack"),1,rb_str_new2(type_str));
 }
 
-/* -------------------------------------------------------------------- */
+/* GLUT */
+
+#define GLUT_SIMPLE_FUNCTION(_name_) \
+static VALUE \
+glut_##_name_(obj) \
+VALUE obj; \
+{ \
+    glut##_name_(); \
+    return Qnil; \
+}
 
-#endif /* _COMMON_H_ */
+VALUE rb_glut_check_callback(VALUE, VALUE);
+
+#endif

data/ext/opengl/funcdef.h

@@ -123,6 +123,7 @@
 #define RETCONV_GLbitfield(x) UINT2NUM(x)
 #define RETCONV_GLbyte(x) INT2NUM(x)
 #define RETCONV_GLshort(x) INT2NUM(x)
+#define RETCONV_GLsizeiptr(x) ULONG2NUM(x)
 #define RETCONV_GLint(x) INT2NUM(x)
 #define RETCONV_GLubyte(x) UINT2NUM(x)
 #define RETCONV_GLushort(x) UINT2NUM(x)

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

@@ -2609,7 +2609,7 @@ gl_Material(VALUE self, VALUE face, VALUE pname, VALUE param)
 {
   VALUE ary;
 
-	if (TYPE(param) == T_ARRAY) {
+	if (RB_TYPE_P(param, T_ARRAY)) {
 		gl_Materialfv(self, face, pname, param);
   } else if (ary = rb_convert_type(param, T_ARRAY, "Array", "to_a")) {
 		gl_Materialfv(self, face, pname, ary);

data/ext/opengl/gl.c

@@ -33,7 +33,7 @@ void gl_init_functions_ext_ati(VALUE);
 void gl_init_functions_ext_ext(VALUE);
 void gl_init_functions_ext_gremedy(VALUE);
 void gl_init_functions_ext_nv(VALUE);
-
+void gl_init_buffer(void);
 
 static int opengl_version[2]; /* major, minor */
 static char *opengl_extensions = NULL;
@@ -182,12 +182,16 @@ GLint CheckBufferBinding(GLint buffer)
 
 DLLEXPORT void Init_gl()
 {
-	VALUE VERSION = rb_str_new2("0.60");
+  VALUE mOpenGL = rb_path2class("OpenGL");
+	VALUE version = rb_const_get(mOpenGL, rb_intern("VERSION"));
+
+  gl_init_buffer();
 
 	module = rb_define_module("Gl");
 
-	rb_define_const(module, "BINDINGS_VERSION", VERSION);
-	rb_define_const(module, "RUBY_OPENGL_VERSION", VERSION);
+  /* TODO remove */
+	rb_define_const(module, "BINDINGS_VERSION", version);
+	rb_define_const(module, "RUBY_OPENGL_VERSION", version);
 
 	gl_init_error(module);
 	gl_init_enums(module);

data/ext/opengl/gl_buffer.c

@@ -0,0 +1,177 @@
+#include "common.h"
+
+static GLvoid * (APIENTRY * fptr_glMapBuffer)(GLenum,GLenum);
+static GLboolean (APIENTRY * fptr_glUnmapBuffer)(GLenum);
+
+struct buffer {
+  GLenum target;
+  void *ptr;
+  GLsizeiptr len;
+};
+
+static void
+buffer_free(void *ptr) {
+  struct buffer *buf = ptr;
+  LOAD_GL_FUNC(glUnmapBuffer, "1.5");
+
+  if (buf->ptr != NULL)
+    fptr_glUnmapBuffer(buf->target);
+}
+
+static size_t
+buffer_memsize(const void *ptr) {
+  const struct buffer *buf = ptr;
+  return sizeof(struct buffer) + (size_t)buf->len;
+}
+
+static const rb_data_type_t buffer_type = {
+  "OpenGL/buffer",
+  { NULL, buffer_free, buffer_memsize, },
+};
+
+VALUE
+rb_gl_buffer_s_map(VALUE klass, VALUE _target, VALUE _access) {
+  struct buffer *buf = ALLOC(struct buffer);
+  LOAD_GL_FUNC(glMapBuffer, "1.5");
+
+  buf->target = RUBY2GLENUM(_target);
+  buf->len    = 0;
+
+  buf->ptr = fptr_glMapBuffer(buf->target, RUBY2GLENUM(_access));
+
+  if (buf->ptr == NULL) {
+    xfree(buf);
+    CHECK_GLERROR_FROM("glMapBuffer");
+  }
+
+  return TypedData_Wrap_Struct(klass, &buffer_type, buf);
+}
+
+static VALUE
+rb_gl_buffer_addr(VALUE self) {
+  struct buffer *buf;
+
+  TypedData_Get_Struct(self, struct buffer, &buffer_type, buf);
+
+  return ULONG2NUM((unsigned long)buf->ptr);
+}
+
+static VALUE
+rb_gl_buffer_length(VALUE self) {
+  struct buffer *buf;
+
+  TypedData_Get_Struct(self, struct buffer, &buffer_type, buf);
+
+  return RETCONV_GLsizeiptr(buf->len);
+}
+
+static VALUE
+rb_gl_buffer_read(int argc, VALUE *argv, VALUE self) {
+  struct buffer *buf;
+  VALUE _length, _offset;
+  GLsizeiptr offset, length;
+
+  TypedData_Get_Struct(self, struct buffer, &buffer_type, buf);
+
+  rb_scan_args(argc, argv, "02", &_length, &_offset);
+
+  if (buf->len == 0 && NIL_P(_length))
+    rb_raise(rb_eArgError, "length must be provided for unbounded buffer");
+
+  length = NUM2ULONG(_length);
+
+  if (NIL_P(_offset)) {
+    offset = 0;
+  } else {
+    offset = NUM2ULONG(_offset);
+  }
+
+  if (buf->len != 0 && length + offset > buf->len)
+    rb_raise(rb_eArgError, "read to %ld past end of buffer %ld",
+        length + offset, buf->len);
+
+  return rb_str_new((char *)buf->ptr + offset, length);
+}
+
+static VALUE
+rb_gl_buffer_target(VALUE self) {
+  struct buffer *buf;
+
+  TypedData_Get_Struct(self, struct buffer, &buffer_type, buf);
+
+  return RETCONV_GLenum(buf->target);
+}
+
+static VALUE
+rb_gl_buffer_unmap(VALUE self) {
+  struct buffer *buf;
+  LOAD_GL_FUNC(glUnmapBuffer, "1.5");
+
+  TypedData_Get_Struct(self, struct buffer, &buffer_type, buf);
+
+  if (!buf->ptr)
+    return self;
+
+  fptr_glUnmapBuffer(buf->target);
+
+  CHECK_GLERROR_FROM("glUnmapBuffer");
+
+  buf->ptr = NULL;
+  buf->len = 0;
+  buf->target = 0;
+
+  return self;
+}
+
+static VALUE
+rb_gl_buffer_write(int argc, VALUE *argv, VALUE self) {
+  struct buffer *buf;
+  VALUE _data, _offset;
+  GLsizeiptr offset;
+  long length;
+
+  TypedData_Get_Struct(self, struct buffer, &buffer_type, buf);
+
+  if (!buf->ptr)
+    rb_raise(rb_eArgError, "write to unmapped buffer");
+
+  rb_scan_args(argc, argv, "11", &_data, &_offset);
+
+  if (NIL_P(_data))
+    rb_raise(rb_eArgError, "cannot write nil to buffer");
+
+  _data = rb_String(_data);
+
+  length = RSTRING_LEN(_data);
+
+  if (NIL_P(_offset)) {
+    offset = 0;
+  } else {
+    offset = NUM2ULONG(_offset);
+  }
+
+  if (buf->len != 0 && length + offset > buf->len)
+    rb_raise(rb_eArgError, "write to %ld past end of buffer %ld",
+        length + offset, buf->len);
+
+  memcpy((char *)buf->ptr + offset, RSTRING_PTR(_data), RSTRING_LEN(_data));
+
+  return self;
+}
+
+void
+gl_init_buffer(void) {
+  VALUE mOpenGL = rb_path2class("OpenGL");
+  VALUE cBuffer = rb_define_class_under(mOpenGL, "Buffer", rb_cObject);
+
+  rb_undef_alloc_func(cBuffer);
+  rb_define_singleton_method(cBuffer, "map", rb_gl_buffer_s_map, 2);
+
+  rb_define_method(cBuffer, "addr", rb_gl_buffer_addr, 0);
+  rb_define_method(cBuffer, "length", rb_gl_buffer_length, 0);
+  rb_define_method(cBuffer, "read", rb_gl_buffer_read, -1);
+  rb_define_method(cBuffer, "target", rb_gl_buffer_target, 0);
+  rb_define_method(cBuffer, "unmap", rb_gl_buffer_unmap, 0);
+  rb_define_method(cBuffer, "write", rb_gl_buffer_write, -1);
+}
+

data/ext/opengl/glut.c

@@ -22,59 +22,18 @@
 
 #include "common.h"
 
-static ID callId; /* 'call' method id */
+static VALUE menu_callback = Qnil;
+static ID call_id; /* 'call' method id */
 
-/*
-  macros for registering callbacks -
-  
-  most GLUT callback functions are part of specific window state, so
-  the same callback may have different functions for each GLUT window
-  
-  callbacks that are not tied to specific window (idle,timer,menustate) are registered manually
-*/
-
-#define WINDOW_CALLBACK_SETUP(_funcname) \
-static VALUE _funcname = Qnil; \
-static VALUE \
-glut_ ## _funcname(obj, callback) \
-VALUE obj, callback; \
-{ \
-    int win; \
-    callback = check_callback(obj, callback); \
-    win = glutGetWindow(); \
-    if (win == 0) \
-        rb_raise(rb_eRuntimeError, "glut%s needs current window", #_funcname); \
-    rb_ary_store(_funcname, win, callback); \
-		if(NIL_P(callback)) \
-			glut ## _funcname(NULL); \
-		else \
-			glut##_funcname(&glut_##_funcname##Callback); \
-    return Qnil; \
-}
-
-#define WINDOW_CALLBACK_DEFINE(_funcname) \
-    rb_define_module_function(module, "glut" # _funcname, glut_ ## _funcname , 1); \
-    rb_global_variable(&_funcname); \
-    _funcname = rb_ary_new()
-
-#define GLUT_SIMPLE_FUNCTION(_name_) \
-static VALUE \
-glut_##_name_(obj) \
-VALUE obj; \
-{ \
-    glut##_name_(); \
-    return Qnil; \
-}
-
-static VALUE
-check_callback(VALUE self, VALUE callback)
+VALUE
+rb_glut_check_callback(VALUE self, VALUE callback)
 {
   VALUE inspect;
 
 	if (NIL_P(callback))
     return callback;
 
-  if (rb_respond_to(callback, callId))
+  if (rb_respond_to(callback, call_id))
     return callback;
 
   if (SYMBOL_P(callback))
@@ -84,12 +43,6 @@ check_callback(VALUE self, VALUE callback)
   rb_raise(rb_eArgError, "%s must respond to call", StringValueCStr(inspect));
 }
 
-/*
- * GLUT Implementation
- */
-
-/* GLUT initialization sub-API. */
-
 static VALUE glut_Init( int argc, VALUE * argv, VALUE obj)
 {
 	int largc;
@@ -100,9 +53,9 @@ static VALUE glut_Init( int argc, VALUE * argv, VALUE obj)
 
 	if (rb_scan_args(argc, argv, "01", &orig_arg) == 0)
 		orig_arg = rb_eval_string("[$0] + ARGV");
-	else
+	else 
 		Check_Type(orig_arg, T_ARRAY);
-
+	
 	/* converts commandline parameters from ruby to C, passes them
 	to glutInit and returns the parameters stripped of glut-specific
 	commands ("-display","-geometry" etc.) */
@@ -110,9 +63,9 @@ static VALUE glut_Init( int argc, VALUE * argv, VALUE obj)
 	largv = ALLOCA_N(char*, largc);
 	for (i = 0; i < largc; i++)
 		largv[i] = StringValueCStr(RARRAY_PTR(orig_arg)[i]);
-
+	
 	glutInit(&largc, largv);
-
+	
 	new_argv = rb_ary_new2(largc);
 	for (i = 0; i < largc; i++)
 		rb_ary_push(new_argv,rb_str_new2(largv[i]));
@@ -122,7 +75,6 @@ static VALUE glut_Init( int argc, VALUE * argv, VALUE obj)
 	return new_argv;
 }
 
-
 static VALUE glut_InitDisplayMode(obj,arg1)
 VALUE obj,arg1;
 {
@@ -152,7 +104,6 @@ VALUE obj,arg1,arg2;
 	return Qnil;
 }
 
-
 static VALUE
 glut_InitWindowSize(obj, arg1, arg2)
 VALUE obj,arg1,arg2;
@@ -164,99 +115,29 @@ VALUE obj,arg1,arg2;
 	return Qnil;
 }
 
-/*
- * No way to unblock glutMainLoop, so fake it?
- */
-static void
-glut_MainLoop_unblock(void *ignored) {
-}
-
-static VALUE glut_MainLoop0(void *ignored) {
+VALUE glut_MainLoop0(void *ignored) {
   glutMainLoop();
 
-  return Qnil;
+  return Qnil; /* never reached */
 }
 
 static VALUE
 glut_MainLoop(void) {
-  /* need to acquire GVL in callbacks */
-  /*rb_thread_blocking_region(glut_MainLoop0, (void *)NULL, glut_MainLoop_unblock, NULL);*/
-
-  glut_MainLoop0(NULL);
+  rb_thread_blocking_region(glut_MainLoop0, NULL, NULL, NULL);
 
   return Qnil; /* never reached */
 }
 
-static void GLUTCALLBACK glut_DisplayFuncCallback(void);
-static void GLUTCALLBACK glut_ReshapeFuncCallback(int,int);
-static void GLUTCALLBACK glut_KeyboardFuncCallback(unsigned char, int, int);
-static void GLUTCALLBACK glut_MouseFuncCallback(int, int, int, int);
-static void GLUTCALLBACK glut_MotionFuncCallback(int, int);
-static void GLUTCALLBACK glut_PassiveMotionFuncCallback(int, int);
-static void GLUTCALLBACK glut_EntryFuncCallback(int);
-static void GLUTCALLBACK glut_VisibilityFuncCallback(int);
-static void GLUTCALLBACK glut_SpecialFuncCallback(int,int,int);
-static void GLUTCALLBACK glut_SpaceballMotionFuncCallback(int,int,int);
-static void GLUTCALLBACK glut_SpaceballRotateFuncCallback(int,int,int);
-static void GLUTCALLBACK glut_SpaceballButtonFuncCallback(int,int);
-static void GLUTCALLBACK glut_ButtonBoxFuncCallback(int,int);
-static void GLUTCALLBACK glut_DialsFuncCallback(int,int);
-static void GLUTCALLBACK glut_TabletMotionFuncCallback(int,int);
-static void GLUTCALLBACK glut_TabletButtonFuncCallback(int,int,int,int);
-static void GLUTCALLBACK glut_OverlayDisplayFuncCallback(void);
-static void GLUTCALLBACK glut_WindowStatusFuncCallback(int);
-static void GLUTCALLBACK glut_JoystickFuncCallback(unsigned int,int,int,int);
-static void GLUTCALLBACK glut_KeyboardUpFuncCallback(unsigned char,int,int);
-static void GLUTCALLBACK glut_SpecialUpFuncCallback(int,int,int);
-
-WINDOW_CALLBACK_SETUP(DisplayFunc)
-WINDOW_CALLBACK_SETUP(ReshapeFunc)
-WINDOW_CALLBACK_SETUP(KeyboardFunc)
-WINDOW_CALLBACK_SETUP(MouseFunc)
-WINDOW_CALLBACK_SETUP(MotionFunc)
-WINDOW_CALLBACK_SETUP(PassiveMotionFunc)
-WINDOW_CALLBACK_SETUP(EntryFunc)
-WINDOW_CALLBACK_SETUP(VisibilityFunc)
-WINDOW_CALLBACK_SETUP(SpecialFunc)
-WINDOW_CALLBACK_SETUP(SpaceballMotionFunc)
-WINDOW_CALLBACK_SETUP(SpaceballRotateFunc)
-WINDOW_CALLBACK_SETUP(SpaceballButtonFunc)
-WINDOW_CALLBACK_SETUP(ButtonBoxFunc)
-WINDOW_CALLBACK_SETUP(DialsFunc)
-WINDOW_CALLBACK_SETUP(TabletMotionFunc)
-WINDOW_CALLBACK_SETUP(TabletButtonFunc)
-WINDOW_CALLBACK_SETUP(OverlayDisplayFunc)
-WINDOW_CALLBACK_SETUP(WindowStatusFunc)
-WINDOW_CALLBACK_SETUP(KeyboardUpFunc)
-WINDOW_CALLBACK_SETUP(SpecialUpFunc)
-
-/* special case, 2 params */
-static VALUE JoystickFunc = Qnil;
 static VALUE
-glut_JoystickFunc(obj,callback,arg2)
-VALUE obj,callback,arg2;
-{
-	int win;
-	int pollinterval;
+glut_CheckLoop(void) {
+  rb_warn("calling fake CheckLoop implementation which never returns");
 
-  callback = check_callback(obj, callback);
-	pollinterval=NUM2INT(arg2);
-	win = glutGetWindow();
+  glut_MainLoop();
 
-	if (win == 0)
-		rb_raise(rb_eRuntimeError, "glutJoystickFunc needs current window");
-
-	rb_ary_store(JoystickFunc, win, callback);
-
-	if (NIL_P(callback))
-		glutJoystickFunc(NULL, pollinterval);
-	else
-		glutJoystickFunc(glut_JoystickFuncCallback, pollinterval);
-
-	return Qnil;
+  return Qnil;
 }
 
-/* GLUT window sub-API. */
+/* GLUT window sub-API. */ 
 static VALUE glut_CreateWindow(argc, argv, obj)
 int argc;
 VALUE* argv;
@@ -272,7 +153,6 @@ VALUE obj;
 	return INT2NUM(ret);
 }
 
-
 static VALUE
 glut_CreateSubWindow(obj,arg1,arg2,arg3,arg4,arg5)
 VALUE obj,arg1,arg2,arg3,arg4,arg5;
@@ -299,7 +179,6 @@ VALUE obj,arg1;
 }
 
 GLUT_SIMPLE_FUNCTION(PostRedisplay)
-
 GLUT_SIMPLE_FUNCTION(SwapBuffers)
 
 static VALUE
@@ -311,7 +190,6 @@ VALUE obj;
 	return INT2NUM(ret);
 }
 
-
 static VALUE
 glut_SetWindow(obj,arg1)
 VALUE obj,arg1;
@@ -322,7 +200,6 @@ VALUE obj,arg1;
 	return Qnil;
 }
 
-
 static VALUE
 glut_SetWindowTitle(obj,arg1)
 VALUE obj,arg1;
@@ -332,7 +209,6 @@ VALUE obj,arg1;
 	return Qnil;
 }
 
-
 static VALUE
 glut_SetIconTitle(obj, arg1)
 VALUE obj,arg1;
@@ -342,7 +218,6 @@ VALUE obj,arg1;
 	return Qnil;
 }
 
-
 static VALUE
 glut_PositionWindow(obj,arg1,arg2)
 VALUE obj,arg1,arg2;
@@ -354,7 +229,6 @@ VALUE obj,arg1,arg2;
 	return Qnil;
 }
 
-
 static VALUE
 glut_ReshapeWindow(obj,arg1,arg2)
 VALUE obj,arg1,arg2;
@@ -366,7 +240,6 @@ VALUE obj,arg1,arg2;
 	return Qnil;
 }
 
-
 GLUT_SIMPLE_FUNCTION(PopWindow)
 GLUT_SIMPLE_FUNCTION(PushWindow)
 GLUT_SIMPLE_FUNCTION(IconifyWindow)
@@ -374,7 +247,6 @@ GLUT_SIMPLE_FUNCTION(ShowWindow)
 GLUT_SIMPLE_FUNCTION(HideWindow)
 GLUT_SIMPLE_FUNCTION(FullScreen)
 
-
 static VALUE
 glut_SetCursor(obj,arg1)
 VALUE obj,arg1;
@@ -413,38 +285,33 @@ VALUE obj, arg1;
 	return Qnil;
 }
 
-/* GLUT menu sub-API. */
-static VALUE g_menucallback = Qnil;
 static void GLUTCALLBACK
 glut_CreateMenuCallback(int value)
 {
 	VALUE func;
 	int menu;
 	menu = glutGetMenu();
-	func = rb_ary_entry(g_menucallback,menu);
-	rb_funcall(func, callId, 1, INT2NUM(value));
+	func = rb_ary_entry(menu_callback, menu);
+
+	rb_funcall(func, call_id, 1, INT2NUM(value));
 }
 
-    
 static VALUE
-glut_CreateMenu(obj,callback)
-VALUE obj,callback;
-{
+glut_CreateMenu(VALUE obj, VALUE callback) {
 	int menu;
 
-  callback = check_callback(obj, callback);
+  callback = rb_glut_check_callback(obj, callback);
 
 	if (NIL_P(callback))
 		menu = glutCreateMenu(NULL);
 	else
 		menu = glutCreateMenu(glut_CreateMenuCallback);
 
-	rb_ary_store(g_menucallback, menu, callback);
+	rb_ary_store(menu_callback, menu, callback);
 
 	return INT2FIX(menu);
 }
 
-    
 static VALUE
 glut_DestroyMenu(obj,arg1)
 VALUE obj,arg1;
@@ -457,7 +324,6 @@ VALUE obj,arg1;
 	return Qnil;
 }
 
-
 static VALUE
 glut_GetMenu(obj)
 VALUE obj;
@@ -467,7 +333,6 @@ VALUE obj;
 	return INT2NUM(ret);
 }
 
-
 static VALUE
 glut_SetMenu(obj,arg1)
 VALUE obj,arg1;
@@ -476,7 +341,6 @@ VALUE obj,arg1;
 	return Qnil;
 }
 
-
 static VALUE
 glut_AddMenuEntry(obj,arg1,arg2)
 VALUE obj,arg1,arg2;
@@ -486,7 +350,6 @@ VALUE obj,arg1,arg2;
 	return Qnil;
 }
 
-
 static VALUE
 glut_AddSubMenu(obj,arg1,arg2)
 VALUE obj,arg1,arg2;
@@ -496,7 +359,6 @@ VALUE obj,arg1,arg2;
 	return Qnil;
 }
 
-
 static VALUE glut_ChangeToMenuEntry(obj,arg1,arg2,arg3)
 VALUE obj,arg1,arg2,arg3;
 {
@@ -505,7 +367,6 @@ VALUE obj,arg1,arg2,arg3;
 	return Qnil;
 }
 
-
 static VALUE glut_ChangeToSubMenu(obj,arg1,arg2,arg3)
 VALUE obj,arg1,arg2,arg3;
 {
@@ -514,14 +375,12 @@ VALUE obj,arg1,arg2,arg3;
 	return Qnil;
 }
 
-
 static VALUE glut_RemoveMenuItem( VALUE obj, VALUE arg1 )
 {
 	glutRemoveMenuItem(NUM2INT(arg1));
 	return Qnil;
 }
 
-
 static VALUE
 glut_AttachMenu(obj,arg1)
 VALUE obj, arg1;
@@ -530,7 +389,6 @@ VALUE obj, arg1;
 	return Qnil;
 }
 
-
 static VALUE
 glut_DetachMenu(obj,arg1)
 VALUE obj, arg1;
@@ -539,344 +397,6 @@ VALUE obj, arg1;
 	return Qnil;
 }
 
-
-/* GLUT  sub-API. */
-static void GLUTCALLBACK glut_DisplayFuncCallback(void)
-{
-	VALUE func;
-	func = rb_ary_entry(DisplayFunc, glutGetWindow());
-	if (!NIL_P(func))
-		rb_funcall(func, callId, 0);
-}
-
-
-static void GLUTCALLBACK
-glut_ReshapeFuncCallback(width, height)
-int width, height;
-{
-	VALUE func;
-	func = rb_ary_entry( ReshapeFunc, glutGetWindow());
-	if (!NIL_P(func))
-		rb_funcall(func, callId, 2, INT2FIX(width), INT2FIX(height));
-}
-
-
-static void GLUTCALLBACK
-glut_KeyboardFuncCallback(unsigned char key, int x, int y)
-{
-	VALUE func;
-	func = rb_ary_entry(KeyboardFunc, glutGetWindow());
-	if (!NIL_P(func))
-#if HAVE_SINGLE_BYTE_STRINGS
-		rb_funcall(func, callId, 3, rb_str_new((char *)&key, 1), INT2FIX(x), INT2FIX(y));
-#else
-		rb_funcall(func, callId, 3, INT2FIX(key), INT2FIX(x), INT2FIX(y));
-#endif
-}
-
-
-static void GLUTCALLBACK
-glut_MouseFuncCallback(button, state, x, y)
-int button, state, x, y;
-{
-	VALUE func;
-	func = rb_ary_entry(MouseFunc, glutGetWindow());
-	if (!NIL_P(func))
-		rb_funcall(func, callId, 4, INT2FIX(button), INT2FIX(state), INT2FIX(x), INT2FIX(y));
-}
-
-
-static void GLUTCALLBACK
-glut_MotionFuncCallback(x, y)
-int x, y;
-{
-	VALUE func;
-	func = rb_ary_entry(MotionFunc, glutGetWindow());
-	if (!NIL_P(func))
-		rb_funcall(func, callId, 2,INT2FIX(x), INT2FIX(y));
-}
-
-
-static void GLUTCALLBACK
-glut_PassiveMotionFuncCallback(x, y)
-int x, y;
-{
-	VALUE func;
-	func = rb_ary_entry(PassiveMotionFunc, glutGetWindow());
-	if (!NIL_P(func))
-		rb_funcall(func, callId, 2,INT2FIX(x), INT2FIX(y));
-}
-
-
-static void GLUTCALLBACK
-glut_EntryFuncCallback(state)
-int state;
-{
-	VALUE func;
-	func = rb_ary_entry(EntryFunc,glutGetWindow());
-	if (!NIL_P(func))
-		rb_funcall(func, callId, 1, INT2NUM(state));
-}
-
-
-static void GLUTCALLBACK
-glut_VisibilityFuncCallback(state)
-int state;
-{
-	VALUE func;
-	func = rb_ary_entry(VisibilityFunc, glutGetWindow());
-	if (!NIL_P(func))
-		rb_funcall(func, callId, 1, INT2NUM(state));
-}
-
-
-static VALUE idle_func = Qnil;
-static void GLUTCALLBACK
-glut_IdleFuncCallback(void)
-{
-	if (!NIL_P(idle_func))
-		rb_funcall(idle_func, callId, 0);
-}
-
-
-static VALUE
-glut_IdleFunc(obj, callback)
-VALUE obj, callback;
-{
-  callback = check_callback(obj, callback);
-
-	idle_func = callback;
-
-	if (NIL_P(callback))
-		glutIdleFunc(NULL);
-	else
-		glutIdleFunc(glut_IdleFuncCallback);
-
-	return Qnil;
-}
-
-
-static VALUE timer_func = Qnil;
-static void GLUTCALLBACK
-glut_TimerFuncCallback(int value)
-{
-	if (!NIL_P(timer_func))
-		rb_funcall(timer_func, callId, 1, INT2NUM(value));
-}
-
-
-static VALUE
-glut_TimerFunc(obj, arg1, callback, arg3)
-VALUE obj,arg1,callback,arg3;
-{
-	unsigned int millis;
-	int value;
-	millis = (unsigned int)NUM2INT(arg1);
-	value = NUM2INT(arg3);
-  callback = check_callback(obj, callback);
-
-	timer_func = callback;
-
-	glutTimerFunc(millis, glut_TimerFuncCallback, value);
-
-	return Qnil;
-}
-
-
-static VALUE menustate_func = Qnil;
-static void GLUTCALLBACK
-glut_MenuStateFuncCallback(int state)
-{
-	if (!NIL_P(menustate_func))
-		rb_funcall(menustate_func, callId, 1, INT2NUM(state));
-}
-
-
-static VALUE
-glut_MenuStateFunc(obj, callback)
-VALUE obj, callback;
-{
-  callback = check_callback(obj, callback);
-
-	menustate_func = callback;
-
-	if (NIL_P(callback))
-		glutMenuStateFunc(NULL);
-	else
-		glutMenuStateFunc(glut_MenuStateFuncCallback);
-
-	return Qnil;
-}
-
-static VALUE menustatus_func = Qnil;
-static void GLUTCALLBACK
-glut_MenuStatusFuncCallback(int state,int x,int y)
-{
-	if (!NIL_P(menustatus_func))
-		rb_funcall(menustatus_func, callId, 3, INT2NUM(state),INT2NUM(x),INT2NUM(y));
-}
-
-static VALUE
-glut_MenuStatusFunc(obj, callback)
-VALUE obj, callback;
-{
-  callback = check_callback(obj, callback);
-
-	menustatus_func = callback;
-
-	if (NIL_P(callback))
-		glutMenuStatusFunc(NULL);
-	else
-		glutMenuStatusFunc(glut_MenuStatusFuncCallback);
-
-	return Qnil;
-}
-
-static void GLUTCALLBACK
-glut_SpecialFuncCallback(key, x, y)
-int key, x, y;
-{
-	VALUE func;
-	func = rb_ary_entry(SpecialFunc, glutGetWindow());
-	if (!NIL_P(func))
-		rb_funcall(func, callId, 3,INT2NUM(key), INT2FIX(x), INT2FIX(y));
-}
-
-
-static void GLUTCALLBACK
-glut_SpaceballMotionFuncCallback(x, y, z)
-int x,y,z;
-{
-	VALUE func;
-	func = rb_ary_entry(SpaceballMotionFunc, glutGetWindow());
-	if (!NIL_P(func))
-		rb_funcall(func, callId, 3,INT2NUM(x), INT2FIX(y), INT2FIX(z));
-}
-
-
-static void GLUTCALLBACK
-glut_SpaceballRotateFuncCallback(x, y, z)
-int x,y,z;
-{
-	VALUE func;
-	func = rb_ary_entry(SpaceballRotateFunc, glutGetWindow());
-	if (!NIL_P(func))
-		rb_funcall(func, callId, 3,INT2NUM(x), INT2FIX(y), INT2FIX(z));
-}
-
-
-static void GLUTCALLBACK
-glut_SpaceballButtonFuncCallback(button, state)
-int button, state;
-{
-	VALUE func;
-	func = rb_ary_entry(SpaceballButtonFunc, glutGetWindow());
-	if (!NIL_P(func))
-		rb_funcall(func, callId, 2,INT2NUM(button), INT2NUM(state));
-}
-
-
-static void GLUTCALLBACK
-glut_ButtonBoxFuncCallback(button, state)
-int button, state;
-{
-	VALUE func;
-	func = rb_ary_entry(ButtonBoxFunc, glutGetWindow());
-	if (!NIL_P(func))
-		rb_funcall(func, callId, 2,INT2NUM(button), INT2NUM(state));
-}
-
-
-static void GLUTCALLBACK
-glut_DialsFuncCallback(dial, value)
-int dial, value;
-{
-	VALUE func;
-	func = rb_ary_entry(DialsFunc, glutGetWindow());
-	if (!NIL_P(func))
-		rb_funcall(func, callId, 2,INT2NUM(dial), INT2NUM(value));
-}
-
-
-static void GLUTCALLBACK
-glut_TabletMotionFuncCallback(x, y)
-int x, y;
-{
-	VALUE func;
-	func = rb_ary_entry(TabletMotionFunc, glutGetWindow());
-	if (!NIL_P(func))
-		rb_funcall(func, callId, 2,INT2NUM(x), INT2NUM(y));
-}
-
-
-static void GLUTCALLBACK
-glut_TabletButtonFuncCallback(button, state, x, y)
-int button, state, x, y;
-{
-	VALUE func;
-	func = rb_ary_entry(TabletButtonFunc, glutGetWindow());
-	if (!NIL_P(func))
-		rb_funcall(func, callId, 4, INT2FIX(button), INT2NUM(state), INT2NUM(x), INT2NUM(y));
-}
-
-
-static void GLUTCALLBACK
-glut_OverlayDisplayFuncCallback()
-{
-	VALUE func;
-	func = rb_ary_entry(OverlayDisplayFunc, glutGetWindow());
-	if (!NIL_P(func))
-		rb_funcall(func, callId, 0);
-}
-
-
-static void GLUTCALLBACK
-glut_WindowStatusFuncCallback(state)
-int state;
-{
-	VALUE func;
-	func = rb_ary_entry(WindowStatusFunc, glutGetWindow());
-	if (!NIL_P(func))
-		rb_funcall(func, callId, 1, INT2NUM(state));
-}
-
-
-static void GLUTCALLBACK
-glut_JoystickFuncCallback(buttonMask,x,y,z)
-unsigned int buttonMask;
-int x,y,z;
-{
-	VALUE func;
-	func = rb_ary_entry(JoystickFunc, glutGetWindow());
-	if (!NIL_P(func))
-		rb_funcall(func, callId, 4, INT2NUM(buttonMask),INT2NUM(x),INT2NUM(y),INT2NUM(z));
-}
-
-static void GLUTCALLBACK
-glut_KeyboardUpFuncCallback(unsigned char key, int x, int y)
-{
-	VALUE func;
-	func = rb_ary_entry(KeyboardUpFunc, glutGetWindow());
-	if (!NIL_P(func))
-#if HAVE_SINGLE_BYTE_STRINGS
-		rb_funcall(func, callId, 3, rb_funcall(INT2FIX(key),rb_intern("chr"),0), INT2FIX(x), INT2FIX(y));
-#else
-		rb_funcall(func, callId, 3, INT2FIX(key), INT2FIX(x), INT2FIX(y));
-#endif
-}
-
-static void GLUTCALLBACK
-glut_SpecialUpFuncCallback(key,x,y)
-int key;
-int x,y;
-{
-	VALUE func;
-	func = rb_ary_entry(SpecialUpFunc, glutGetWindow());
-	if (!NIL_P(func))
-		rb_funcall(func, callId, 3, INT2NUM(key),INT2NUM(x),INT2NUM(y));
-}
-
-
 /* GLUT color index sub-API. */
 static VALUE
 glut_SetColor(obj,arg1,arg2,arg3,arg4)
@@ -894,7 +414,6 @@ VALUE obj,arg1,arg2,arg3,arg4;
 	return Qnil;
 }
 
-
 static VALUE
 glut_GetColor(obj,arg1,arg2)
 VALUE obj,arg1,arg2;
@@ -908,7 +427,6 @@ VALUE obj,arg1,arg2;
 	return rb_float_new(ret);
 }
 
-
 static VALUE
 glut_CopyColormap(obj,arg1)
 VALUE obj,arg1;
@@ -919,7 +437,6 @@ VALUE obj,arg1;
 	return Qnil;
 }
 
-
 /* GLUT state retrieval sub-API. */
 static VALUE
 glut_Get(obj,arg1)
@@ -932,7 +449,6 @@ VALUE obj,arg1;
 	return INT2NUM(ret);
 }
 
-
 static VALUE
 glut_DeviceGet(obj,arg1)
 VALUE obj,arg1;
@@ -944,7 +460,6 @@ VALUE obj,arg1;
 	return INT2NUM(ret);
 }
 
-
 /* GLUT extension support sub-API */
 static VALUE
 glut_ExtensionSupported(obj,arg1)
@@ -965,7 +480,6 @@ VALUE obj;
 	return INT2NUM(ret);
 }
 
-
 static VALUE
 glut_LayerGet(obj,arg1)
 VALUE obj,arg1;
@@ -980,21 +494,23 @@ VALUE obj,arg1;
 /* GLUT font sub-API */
 
 /* Some glut implementations define font enums as addresses of local functions
-  which are then called by glut internally. This may lead to crashes or bus errors
-  on some platforms, so to be safe we hardcode the values passed to/from ruby */
+ * which are then called by glut internally. This may lead to crashes or bus
+ * errors on some platforms, so to be safe we hardcode the values passed
+ * to/from ruby
+ */
 
 static inline void * bitmap_font_map(int f)
 {
 	switch (f) {
 		case 0: return (void *)GLUT_BITMAP_9_BY_15;
 		case 1: return (void *)GLUT_BITMAP_8_BY_13;
-		case 2: return (void *)GLUT_BITMAP_TIMES_ROMAN_10;
+		case 2: return (void *)GLUT_BITMAP_TIMES_ROMAN_10; 
 		case 3: return (void *)GLUT_BITMAP_TIMES_ROMAN_24;
 		case 4: return (void *)GLUT_BITMAP_HELVETICA_10;
 		case 5: return (void *)GLUT_BITMAP_HELVETICA_12;
 		case 6: return (void *)GLUT_BITMAP_HELVETICA_18;
 		default:
-			rb_raise(rb_eArgError, "Unsupported font");
+			rb_raise(rb_eArgError, "Unsupported font %d", f);
 	}
 
 	return (void *) 0; /* not reached */
@@ -1006,7 +522,7 @@ static inline void * stroke_font_map(int f)
 		case 7: return (void *)GLUT_STROKE_ROMAN;
 		case 8: return (void *)GLUT_STROKE_MONO_ROMAN;
 		default:
-			rb_raise(rb_eArgError, "Unsupported font");
+			rb_raise(rb_eArgError, "Unsupported font %d", f);
 	}
 
 	return (void *) 0; /* not reached */
@@ -1037,7 +553,6 @@ VALUE obj,arg1,arg2;
 	return INT2NUM(ret);
 }
 
-
 static VALUE
 glut_StrokeCharacter(obj,arg1,arg2)
 VALUE obj,arg1,arg2;
@@ -1050,7 +565,6 @@ VALUE obj,arg1,arg2;
 	return Qnil;
 }
 
-
 static VALUE
 glut_StrokeWidth(obj,arg1,arg2)
 VALUE obj,arg1,arg2;
@@ -1064,7 +578,6 @@ VALUE obj,arg1,arg2;
 	return INT2NUM(ret);
 }
 
-
 static VALUE
 glut_BitmapLength(obj,arg1,arg2)
 VALUE obj,arg1,arg2;
@@ -1077,7 +590,6 @@ VALUE obj,arg1,arg2;
 	return INT2NUM(ret);
 }
 
-
 static VALUE
 glut_StrokeLength(obj,arg1,arg2)
 VALUE obj,arg1,arg2;
@@ -1105,7 +617,6 @@ VALUE obj,arg1,arg2,arg3;
 	return Qnil;
 }
 
-
 static VALUE
 glut_SolidSphere(obj,arg1,arg2,arg3)
 VALUE obj,arg1,arg2,arg3;
@@ -1120,7 +631,6 @@ VALUE obj,arg1,arg2,arg3;
 	return Qnil;
 }
 
-
 static VALUE
 glut_WireCone(obj,arg1,arg2,arg3,arg4)
 VALUE obj,arg1,arg2,arg3,arg4;
@@ -1137,7 +647,6 @@ VALUE obj,arg1,arg2,arg3,arg4;
 	return Qnil;
 }
 
-
 static VALUE
 glut_SolidCone(obj,arg1,arg2,arg3,arg4)
 VALUE obj,arg1,arg2,arg3,arg4;
@@ -1154,7 +663,6 @@ VALUE obj,arg1,arg2,arg3,arg4;
 	return Qnil;
 }
 
-
 static VALUE
 glut_WireCube(obj,arg1)
 VALUE obj,arg1;
@@ -1165,7 +673,6 @@ VALUE obj,arg1;
 	return Qnil;
 }
 
-
 static VALUE
 glut_SolidCube(obj,arg1)
 VALUE obj,arg1;
@@ -1176,7 +683,6 @@ VALUE obj,arg1;
 	return Qnil;
 }
 
-
 static VALUE
 glut_WireTorus(obj,arg1,arg2,arg3,arg4)
 VALUE obj,arg1,arg2,arg3,arg4;
@@ -1193,7 +699,6 @@ VALUE obj,arg1,arg2,arg3,arg4;
 	return Qnil;
 }
 
-
 static VALUE
 glut_SolidTorus(obj,arg1,arg2,arg3,arg4)
 VALUE obj,arg1,arg2,arg3,arg4;
@@ -1210,7 +715,6 @@ VALUE obj,arg1,arg2,arg3,arg4;
 	return Qnil;
 }
 
-
 GLUT_SIMPLE_FUNCTION(WireDodecahedron)
 GLUT_SIMPLE_FUNCTION(SolidDodecahedron)
 GLUT_SIMPLE_FUNCTION(WireOctahedron)
@@ -1230,7 +734,6 @@ VALUE obj,arg1;
 	return Qnil;
 }
 
-
 static VALUE
 glut_SolidTeapot(obj,arg1)
 VALUE obj,arg1;
@@ -1253,7 +756,6 @@ VALUE obj,arg1;
 	return INT2NUM(ret);
 }
 
-
 GLUT_SIMPLE_FUNCTION(SetupVideoResizing)
 GLUT_SIMPLE_FUNCTION(StopVideoResizing)
 
@@ -1304,8 +806,6 @@ VALUE obj,arg1;
 GLUT_SIMPLE_FUNCTION(EnterGameMode)
 GLUT_SIMPLE_FUNCTION(LeaveGameMode)
 
-GLUT_SIMPLE_FUNCTION(ForceJoystickFunc)
-
 static VALUE
 glut_GameModeGet(obj,arg1)
 VALUE obj,arg1;
@@ -1357,326 +857,281 @@ VALUE obj,arg1;
 	return Qnil;
 }
 
-static VALUE module;
-
-DLLEXPORT void Init_glut()
-{
-	module = rb_define_module("Glut");
+void Init_glut() {
+  VALUE mGlut;
+
+	call_id = rb_intern("call");
+	mGlut = rb_define_module("Glut");
+
+	menu_callback = rb_ary_new();
+	rb_global_variable(&menu_callback);
+
+	rb_define_module_function(mGlut, "glutInit", glut_Init, -1);
+	rb_define_module_function(mGlut, "glutInitDisplayMode", glut_InitDisplayMode, 1);
+	rb_define_module_function(mGlut, "glutInitDisplayString", glut_InitDisplayString, 1);
+	rb_define_module_function(mGlut, "glutInitWindowPosition", glut_InitWindowPosition, 2);
+	rb_define_module_function(mGlut, "glutInitWindowSize", glut_InitWindowSize, 2);
+	rb_define_module_function(mGlut, "glutMainLoop", glut_MainLoop, 0);
+	rb_define_module_function(mGlut, "glutCheckLoop", glut_CheckLoop, 0);
+	rb_define_module_function(mGlut, "glutGameModeString", glut_GameModeString, 1);
+	rb_define_module_function(mGlut, "glutEnterGameMode", glut_EnterGameMode, 0);
+	rb_define_module_function(mGlut, "glutLeaveGameMode", glut_LeaveGameMode, 0);
+	rb_define_module_function(mGlut, "glutCreateWindow", glut_CreateWindow, -1);
+	rb_define_module_function(mGlut, "glutCreateSubWindow", glut_CreateSubWindow, 5);
+	rb_define_module_function(mGlut, "glutDestroyWindow", glut_DestroyWindow, 1);
+	rb_define_module_function(mGlut, "glutPostRedisplay", glut_PostRedisplay, 0);
+	rb_define_module_function(mGlut, "glutSwapBuffers", glut_SwapBuffers, 0);
+	rb_define_module_function(mGlut, "glutGetWindow", glut_GetWindow, 0);
+	rb_define_module_function(mGlut, "glutSetWindow", glut_SetWindow, 1);
+	rb_define_module_function(mGlut, "glutSetWindowTitle", glut_SetWindowTitle, 1);
+	rb_define_module_function(mGlut, "glutSetIconTitle", glut_SetIconTitle, 1);
+	rb_define_module_function(mGlut, "glutPositionWindow", glut_PositionWindow, 2);
+	rb_define_module_function(mGlut, "glutReshapeWindow", glut_ReshapeWindow, 2);
+	rb_define_module_function(mGlut, "glutPopWindow", glut_PopWindow, 0);
+	rb_define_module_function(mGlut, "glutPushWindow", glut_PushWindow, 0);
+	rb_define_module_function(mGlut, "glutIconifyWindow", glut_IconifyWindow, 0);
+	rb_define_module_function(mGlut, "glutShowWindow", glut_ShowWindow, 0);
+	rb_define_module_function(mGlut, "glutHideWindow", glut_HideWindow, 0);
+	rb_define_module_function(mGlut, "glutFullScreen", glut_FullScreen, 0);
+	rb_define_module_function(mGlut, "glutSetCursor", glut_SetCursor, 1);
+	rb_define_module_function(mGlut, "glutWarpPointer", glut_WarpPointer, 2);
+	rb_define_module_function(mGlut, "glutEstablishOverlay", glut_EstablishOverlay, 0);
+	rb_define_module_function(mGlut, "glutRemoveOverlay", glut_RemoveOverlay, 0);
+	rb_define_module_function(mGlut, "glutUseLayer", glut_UseLayer, 1);
+	rb_define_module_function(mGlut, "glutPostOverlayRedisplay", glut_PostOverlayRedisplay, 0);
+	rb_define_module_function(mGlut, "glutShowOverlay", glut_ShowOverlay, 0);
+	rb_define_module_function(mGlut, "glutHideOverlay", glut_HideOverlay, 0);
+	rb_define_module_function(mGlut, "glutCreateMenu", glut_CreateMenu, 1);
+	rb_define_module_function(mGlut, "glutDestroyMenu", glut_DestroyMenu, 1);
+	rb_define_module_function(mGlut, "glutGetMenu", glut_GetMenu, 0);
+	rb_define_module_function(mGlut, "glutSetMenu", glut_SetMenu, 1);
+	rb_define_module_function(mGlut, "glutAddMenuEntry", glut_AddMenuEntry, 2);
+	rb_define_module_function(mGlut, "glutAddSubMenu", glut_AddSubMenu, 2);
+	rb_define_module_function(mGlut, "glutChangeToMenuEntry", glut_ChangeToMenuEntry, 3);
+	rb_define_module_function(mGlut, "glutChangeToSubMenu", glut_ChangeToSubMenu, 3);
+	rb_define_module_function(mGlut, "glutRemoveMenuItem", glut_RemoveMenuItem, 1);
+	rb_define_module_function(mGlut, "glutAttachMenu", glut_AttachMenu, 1);
+	rb_define_module_function(mGlut, "glutDetachMenu", glut_DetachMenu, 1);
+	rb_define_module_function(mGlut, "glutSetColor", glut_SetColor, 4);
+	rb_define_module_function(mGlut, "glutGetColor", glut_GetColor, 2);
+	rb_define_module_function(mGlut, "glutCopyColormap", glut_CopyColormap, 1);
+	rb_define_module_function(mGlut, "glutGet", glut_Get, 1);
+	rb_define_module_function(mGlut, "glutDeviceGet", glut_DeviceGet, 1);
+	rb_define_module_function(mGlut, "glutExtensionSupported", glut_ExtensionSupported, 1);
+	rb_define_module_function(mGlut, "glutGetModifiers", glut_GetModifiers, 0);
+	rb_define_module_function(mGlut, "glutLayerGet", glut_LayerGet, 1);
+	rb_define_module_function(mGlut, "glutBitmapCharacter", glut_BitmapCharacter, 2);
+	rb_define_module_function(mGlut, "glutBitmapWidth", glut_BitmapWidth, 2);
+	rb_define_module_function(mGlut, "glutStrokeCharacter", glut_StrokeCharacter, 2);
+	rb_define_module_function(mGlut, "glutStrokeWidth", glut_StrokeWidth, 2);
+	rb_define_module_function(mGlut, "glutBitmapLength", glut_BitmapLength, 2);
+	rb_define_module_function(mGlut, "glutStrokeLength", glut_StrokeLength, 2);
+	rb_define_module_function(mGlut, "glutWireSphere", glut_WireSphere, 3);
+	rb_define_module_function(mGlut, "glutSolidSphere", glut_SolidSphere, 3);
+	rb_define_module_function(mGlut, "glutWireCone", glut_WireCone, 4);
+	rb_define_module_function(mGlut, "glutSolidCone", glut_SolidCone, 4);
+	rb_define_module_function(mGlut, "glutWireCube", glut_WireCube, 1);
+	rb_define_module_function(mGlut, "glutSolidCube", glut_SolidCube, 1);
+	rb_define_module_function(mGlut, "glutWireTorus", glut_WireTorus, 4);
+	rb_define_module_function(mGlut, "glutSolidTorus", glut_SolidTorus, 4);
+	rb_define_module_function(mGlut, "glutWireDodecahedron", glut_WireDodecahedron, 0);
+	rb_define_module_function(mGlut, "glutSolidDodecahedron", glut_SolidDodecahedron, 0);
+	rb_define_module_function(mGlut, "glutWireTeapot", glut_WireTeapot, 1);
+	rb_define_module_function(mGlut, "glutSolidTeapot", glut_SolidTeapot, 1);
+	rb_define_module_function(mGlut, "glutWireOctahedron", glut_WireOctahedron, 0);
+	rb_define_module_function(mGlut, "glutSolidOctahedron", glut_SolidOctahedron, 0);
+	rb_define_module_function(mGlut, "glutWireTetrahedron", glut_WireTetrahedron, 0);
+	rb_define_module_function(mGlut, "glutSolidTetrahedron", glut_SolidTetrahedron, 0);
+	rb_define_module_function(mGlut, "glutWireIcosahedron", glut_WireIcosahedron, 0);
+	rb_define_module_function(mGlut, "glutSolidIcosahedron", glut_SolidIcosahedron, 0);
+	rb_define_module_function(mGlut, "glutVideoResizeGet", glut_VideoResizeGet, 1);
+	rb_define_module_function(mGlut, "glutSetupVideoResizing", glut_SetupVideoResizing, 0);
+	rb_define_module_function(mGlut, "glutStopVideoResizing", glut_StopVideoResizing, 0);
+	rb_define_module_function(mGlut, "glutVideoResize", glut_VideoResize, 4);
+	rb_define_module_function(mGlut, "glutVideoPan", glut_VideoPan, 4);
+	rb_define_module_function(mGlut, "glutReportErrors", glut_ReportErrors, 0);
+
+	rb_define_module_function(mGlut, "glutGameModeGet", glut_GameModeGet, 1);
+	rb_define_module_function(mGlut, "glutSetKeyRepeat", glut_SetKeyRepeat, 1);
+	rb_define_module_function(mGlut, "glutIgnoreKeyRepeat", glut_IgnoreKeyRepeat, 1);
+	rb_define_module_function(mGlut, "glutPostWindowOverlayRedisplay", glut_PostWindowOverlayRedisplay, 1);
+	rb_define_module_function(mGlut, "glutPostWindowRedisplay", glut_PostWindowRedisplay, 1);
 	
-	rb_global_variable( &g_menucallback );
-	g_menucallback = rb_ary_new();
-	
-	rb_define_module_function(module, "glutInit", glut_Init, -1);
-	rb_define_module_function(module, "glutInitDisplayMode", glut_InitDisplayMode, 1);
-	rb_define_module_function(module, "glutInitDisplayString", glut_InitDisplayString, 1);
-	rb_define_module_function(module, "glutInitWindowPosition", glut_InitWindowPosition, 2);
-	rb_define_module_function(module, "glutInitWindowSize", glut_InitWindowSize, 2);
-	rb_define_module_function(module, "glutMainLoop", glut_MainLoop, 0);
-	rb_define_module_function(module, "glutCheckLoop", glut_MainLoop, 0);
-	rb_define_module_function(module, "glutGameModeString", glut_GameModeString, 1);
-	rb_define_module_function(module, "glutEnterGameMode", glut_EnterGameMode, 0);
-	rb_define_module_function(module, "glutLeaveGameMode", glut_LeaveGameMode, 0);
-	rb_define_module_function(module, "glutCreateWindow", glut_CreateWindow, -1);
-	rb_define_module_function(module, "glutCreateSubWindow", glut_CreateSubWindow, 5);
-	rb_define_module_function(module, "glutDestroyWindow", glut_DestroyWindow, 1);
-	rb_define_module_function(module, "glutPostRedisplay", glut_PostRedisplay, 0);
-	rb_define_module_function(module, "glutSwapBuffers", glut_SwapBuffers, 0);
-	rb_define_module_function(module, "glutGetWindow", glut_GetWindow, 0);
-	rb_define_module_function(module, "glutSetWindow", glut_SetWindow, 1);
-	rb_define_module_function(module, "glutSetWindowTitle", glut_SetWindowTitle, 1);
-	rb_define_module_function(module, "glutSetIconTitle", glut_SetIconTitle, 1);
-	rb_define_module_function(module, "glutPositionWindow", glut_PositionWindow, 2);
-	rb_define_module_function(module, "glutReshapeWindow", glut_ReshapeWindow, 2);
-	rb_define_module_function(module, "glutPopWindow", glut_PopWindow, 0);
-	rb_define_module_function(module, "glutPushWindow", glut_PushWindow, 0);
-	rb_define_module_function(module, "glutIconifyWindow", glut_IconifyWindow, 0);
-	rb_define_module_function(module, "glutShowWindow", glut_ShowWindow, 0);
-	rb_define_module_function(module, "glutHideWindow", glut_HideWindow, 0);
-	rb_define_module_function(module, "glutFullScreen", glut_FullScreen, 0);
-	rb_define_module_function(module, "glutSetCursor", glut_SetCursor, 1);
-	rb_define_module_function(module, "glutWarpPointer", glut_WarpPointer, 2);
-	rb_define_module_function(module, "glutEstablishOverlay", glut_EstablishOverlay, 0);
-	rb_define_module_function(module, "glutRemoveOverlay", glut_RemoveOverlay, 0);
-	rb_define_module_function(module, "glutUseLayer", glut_UseLayer, 1);
-	rb_define_module_function(module, "glutPostOverlayRedisplay", glut_PostOverlayRedisplay, 0);
-	rb_define_module_function(module, "glutShowOverlay", glut_ShowOverlay, 0);
-	rb_define_module_function(module, "glutHideOverlay", glut_HideOverlay, 0);
-	rb_define_module_function(module, "glutCreateMenu", glut_CreateMenu, 1);
-	rb_define_module_function(module, "glutDestroyMenu", glut_DestroyMenu, 1);
-	rb_define_module_function(module, "glutGetMenu", glut_GetMenu, 0);
-	rb_define_module_function(module, "glutSetMenu", glut_SetMenu, 1);
-	rb_define_module_function(module, "glutAddMenuEntry", glut_AddMenuEntry, 2);
-	rb_define_module_function(module, "glutAddSubMenu", glut_AddSubMenu, 2);
-	rb_define_module_function(module, "glutChangeToMenuEntry", glut_ChangeToMenuEntry, 3);
-	rb_define_module_function(module, "glutChangeToSubMenu", glut_ChangeToSubMenu, 3);
-	rb_define_module_function(module, "glutRemoveMenuItem", glut_RemoveMenuItem, 1);
-	rb_define_module_function(module, "glutAttachMenu", glut_AttachMenu, 1);
-	rb_define_module_function(module, "glutDetachMenu", glut_DetachMenu, 1);
-	rb_define_module_function(module, "glutSetColor", glut_SetColor, 4);
-	rb_define_module_function(module, "glutGetColor", glut_GetColor, 2);
-	rb_define_module_function(module, "glutCopyColormap", glut_CopyColormap, 1);
-	rb_define_module_function(module, "glutGet", glut_Get, 1);
-	rb_define_module_function(module, "glutDeviceGet", glut_DeviceGet, 1);
-	rb_define_module_function(module, "glutExtensionSupported", glut_ExtensionSupported, 1);
-	rb_define_module_function(module, "glutGetModifiers", glut_GetModifiers, 0);
-	rb_define_module_function(module, "glutLayerGet", glut_LayerGet, 1);
-	rb_define_module_function(module, "glutBitmapCharacter", glut_BitmapCharacter, 2);
-	rb_define_module_function(module, "glutBitmapWidth", glut_BitmapWidth, 2);
-	rb_define_module_function(module, "glutStrokeCharacter", glut_StrokeCharacter, 2);
-	rb_define_module_function(module, "glutStrokeWidth", glut_StrokeWidth, 2);
-	rb_define_module_function(module, "glutBitmapLength", glut_BitmapLength, 2);
-	rb_define_module_function(module, "glutStrokeLength", glut_StrokeLength, 2);
-	rb_define_module_function(module, "glutWireSphere", glut_WireSphere, 3);
-	rb_define_module_function(module, "glutSolidSphere", glut_SolidSphere, 3);
-	rb_define_module_function(module, "glutWireCone", glut_WireCone, 4);
-	rb_define_module_function(module, "glutSolidCone", glut_SolidCone, 4);
-	rb_define_module_function(module, "glutWireCube", glut_WireCube, 1);
-	rb_define_module_function(module, "glutSolidCube", glut_SolidCube, 1);
-	rb_define_module_function(module, "glutWireTorus", glut_WireTorus, 4);
-	rb_define_module_function(module, "glutSolidTorus", glut_SolidTorus, 4);
-	rb_define_module_function(module, "glutWireDodecahedron", glut_WireDodecahedron, 0);
-	rb_define_module_function(module, "glutSolidDodecahedron", glut_SolidDodecahedron, 0);
-	rb_define_module_function(module, "glutWireTeapot", glut_WireTeapot, 1);
-	rb_define_module_function(module, "glutSolidTeapot", glut_SolidTeapot, 1);
-	rb_define_module_function(module, "glutWireOctahedron", glut_WireOctahedron, 0);
-	rb_define_module_function(module, "glutSolidOctahedron", glut_SolidOctahedron, 0);
-	rb_define_module_function(module, "glutWireTetrahedron", glut_WireTetrahedron, 0);
-	rb_define_module_function(module, "glutSolidTetrahedron", glut_SolidTetrahedron, 0);
-	rb_define_module_function(module, "glutWireIcosahedron", glut_WireIcosahedron, 0);
-	rb_define_module_function(module, "glutSolidIcosahedron", glut_SolidIcosahedron, 0);
-	rb_define_module_function(module, "glutVideoResizeGet", glut_VideoResizeGet, 1);
-	rb_define_module_function(module, "glutSetupVideoResizing", glut_SetupVideoResizing, 0);
-	rb_define_module_function(module, "glutStopVideoResizing", glut_StopVideoResizing, 0);
-	rb_define_module_function(module, "glutVideoResize", glut_VideoResize, 4);
-	rb_define_module_function(module, "glutVideoPan", glut_VideoPan, 4);
-	rb_define_module_function(module, "glutReportErrors", glut_ReportErrors, 0);
-	rb_define_module_function(module, "glutIdleFunc", glut_IdleFunc, 1);
-	rb_define_module_function(module, "glutTimerFunc", glut_TimerFunc, 3);
-	rb_define_module_function(module, "glutMenuStateFunc", glut_MenuStateFunc, 1);
-	rb_define_module_function(module, "glutMenuStatusFunc", glut_MenuStatusFunc, 1);
-	rb_define_module_function(module, "glutForceJoystickFunc", glut_ForceJoystickFunc, 0);
-	rb_define_module_function(module, "glutGameModeGet", glut_GameModeGet, 1);
-	rb_define_module_function(module, "glutSetKeyRepeat", glut_SetKeyRepeat, 1);
-	rb_define_module_function(module, "glutIgnoreKeyRepeat", glut_IgnoreKeyRepeat, 1);
-	rb_define_module_function(module, "glutPostWindowOverlayRedisplay", glut_PostWindowOverlayRedisplay, 1);
-	rb_define_module_function(module, "glutPostWindowRedisplay", glut_PostWindowRedisplay, 1);
-
-	rb_define_const(module, "GLUT_API_VERSION", INT2NUM(GLUT_API_VERSION));
-	rb_define_const(module, "GLUT_XLIB_IMPLEMENTATION", INT2NUM(GLUT_XLIB_IMPLEMENTATION));
-	rb_define_const(module, "GLUT_RGB", INT2NUM(GLUT_RGB));
-	rb_define_const(module, "GLUT_RGBA", INT2NUM(GLUT_RGBA));
-	rb_define_const(module, "GLUT_INDEX", INT2NUM(GLUT_INDEX));
-	rb_define_const(module, "GLUT_SINGLE", INT2NUM(GLUT_SINGLE));
-	rb_define_const(module, "GLUT_DOUBLE", INT2NUM(GLUT_DOUBLE));
-	rb_define_const(module, "GLUT_ACCUM", INT2NUM(GLUT_ACCUM));
-	rb_define_const(module, "GLUT_ALPHA", INT2NUM(GLUT_ALPHA));
-	rb_define_const(module, "GLUT_DEPTH", INT2NUM(GLUT_DEPTH));
-	rb_define_const(module, "GLUT_STENCIL", INT2NUM(GLUT_STENCIL));
-	rb_define_const(module, "GLUT_MULTISAMPLE", INT2NUM(GLUT_MULTISAMPLE));
-	rb_define_const(module, "GLUT_STEREO", INT2NUM(GLUT_STEREO));
-	rb_define_const(module, "GLUT_LUMINANCE", INT2NUM(GLUT_LUMINANCE));
-	rb_define_const(module, "GLUT_LEFT_BUTTON", INT2NUM(GLUT_LEFT_BUTTON));
-	rb_define_const(module, "GLUT_MIDDLE_BUTTON", INT2NUM(GLUT_MIDDLE_BUTTON));
-	rb_define_const(module, "GLUT_RIGHT_BUTTON", INT2NUM(GLUT_RIGHT_BUTTON));
-	rb_define_const(module, "GLUT_DOWN", INT2NUM(GLUT_DOWN));
-	rb_define_const(module, "GLUT_UP", INT2NUM(GLUT_UP));
-	rb_define_const(module, "GLUT_KEY_F1", INT2NUM(GLUT_KEY_F1));
-	rb_define_const(module, "GLUT_KEY_F2", INT2NUM(GLUT_KEY_F2));
-	rb_define_const(module, "GLUT_KEY_F3", INT2NUM(GLUT_KEY_F3));
-	rb_define_const(module, "GLUT_KEY_F4", INT2NUM(GLUT_KEY_F4));
-	rb_define_const(module, "GLUT_KEY_F5", INT2NUM(GLUT_KEY_F5));
-	rb_define_const(module, "GLUT_KEY_F6", INT2NUM(GLUT_KEY_F6));
-	rb_define_const(module, "GLUT_KEY_F7", INT2NUM(GLUT_KEY_F7));
-	rb_define_const(module, "GLUT_KEY_F8", INT2NUM(GLUT_KEY_F8));
-	rb_define_const(module, "GLUT_KEY_F9", INT2NUM(GLUT_KEY_F9));
-	rb_define_const(module, "GLUT_KEY_F10", INT2NUM(GLUT_KEY_F10));
-	rb_define_const(module, "GLUT_KEY_F11", INT2NUM(GLUT_KEY_F11));
-	rb_define_const(module, "GLUT_KEY_F12", INT2NUM(GLUT_KEY_F12));
-	rb_define_const(module, "GLUT_KEY_LEFT", INT2NUM(GLUT_KEY_LEFT));
-	rb_define_const(module, "GLUT_KEY_UP", INT2NUM(GLUT_KEY_UP));
-	rb_define_const(module, "GLUT_KEY_RIGHT", INT2NUM(GLUT_KEY_RIGHT));
-	rb_define_const(module, "GLUT_KEY_DOWN", INT2NUM(GLUT_KEY_DOWN));
-	rb_define_const(module, "GLUT_KEY_PAGE_UP", INT2NUM(GLUT_KEY_PAGE_UP));
-	rb_define_const(module, "GLUT_KEY_PAGE_DOWN", INT2NUM(GLUT_KEY_PAGE_DOWN));
-	rb_define_const(module, "GLUT_KEY_HOME", INT2NUM(GLUT_KEY_HOME));
-	rb_define_const(module, "GLUT_KEY_END", INT2NUM(GLUT_KEY_END));
-	rb_define_const(module, "GLUT_KEY_INSERT", INT2NUM(GLUT_KEY_INSERT));
-	rb_define_const(module, "GLUT_LEFT", INT2NUM(GLUT_LEFT));
-	rb_define_const(module, "GLUT_ENTERED", INT2NUM(GLUT_ENTERED));
-	rb_define_const(module, "GLUT_MENU_NOT_IN_USE", INT2NUM(GLUT_MENU_NOT_IN_USE));
-	rb_define_const(module, "GLUT_MENU_IN_USE", INT2NUM(GLUT_MENU_IN_USE));
-	rb_define_const(module, "GLUT_NOT_VISIBLE", INT2NUM(GLUT_NOT_VISIBLE));
-	rb_define_const(module, "GLUT_VISIBLE", INT2NUM(GLUT_VISIBLE));
-	rb_define_const(module, "GLUT_HIDDEN", INT2NUM(GLUT_HIDDEN));
-	rb_define_const(module, "GLUT_FULLY_RETAINED", INT2NUM(GLUT_FULLY_RETAINED));
-	rb_define_const(module, "GLUT_PARTIALLY_RETAINED", INT2NUM(GLUT_PARTIALLY_RETAINED));
-	rb_define_const(module, "GLUT_FULLY_COVERED", INT2NUM(GLUT_FULLY_COVERED));
-	rb_define_const(module, "GLUT_RED", INT2NUM(GLUT_RED));
-	rb_define_const(module, "GLUT_GREEN", INT2NUM(GLUT_GREEN));
-	rb_define_const(module, "GLUT_BLUE", INT2NUM(GLUT_BLUE));
-	rb_define_const(module, "GLUT_WINDOW_X", INT2NUM(GLUT_WINDOW_X));
-	rb_define_const(module, "GLUT_WINDOW_Y", INT2NUM(GLUT_WINDOW_Y));
-	rb_define_const(module, "GLUT_WINDOW_WIDTH", INT2NUM(GLUT_WINDOW_WIDTH));
-	rb_define_const(module, "GLUT_WINDOW_HEIGHT", INT2NUM(GLUT_WINDOW_HEIGHT));
-	rb_define_const(module, "GLUT_WINDOW_BUFFER_SIZE", INT2NUM(GLUT_WINDOW_BUFFER_SIZE));
-	rb_define_const(module, "GLUT_WINDOW_STENCIL_SIZE", INT2NUM(GLUT_WINDOW_STENCIL_SIZE));
-	rb_define_const(module, "GLUT_WINDOW_DEPTH_SIZE", INT2NUM(GLUT_WINDOW_DEPTH_SIZE));
-	rb_define_const(module, "GLUT_WINDOW_RED_SIZE", INT2NUM(GLUT_WINDOW_RED_SIZE));
-	rb_define_const(module, "GLUT_WINDOW_GREEN_SIZE", INT2NUM(GLUT_WINDOW_GREEN_SIZE));
-	rb_define_const(module, "GLUT_WINDOW_BLUE_SIZE", INT2NUM(GLUT_WINDOW_BLUE_SIZE));
-	rb_define_const(module, "GLUT_WINDOW_ALPHA_SIZE", INT2NUM(GLUT_WINDOW_ALPHA_SIZE));
-	rb_define_const(module, "GLUT_WINDOW_ACCUM_RED_SIZE", INT2NUM(GLUT_WINDOW_ACCUM_RED_SIZE));
-	rb_define_const(module, "GLUT_WINDOW_ACCUM_GREEN_SIZE", INT2NUM(GLUT_WINDOW_ACCUM_GREEN_SIZE));
-	rb_define_const(module, "GLUT_WINDOW_ACCUM_BLUE_SIZE", INT2NUM(GLUT_WINDOW_ACCUM_BLUE_SIZE));
-	rb_define_const(module, "GLUT_WINDOW_ACCUM_ALPHA_SIZE", INT2NUM(GLUT_WINDOW_ACCUM_ALPHA_SIZE));
-	rb_define_const(module, "GLUT_WINDOW_DOUBLEBUFFER", INT2NUM(GLUT_WINDOW_DOUBLEBUFFER));
-	rb_define_const(module, "GLUT_WINDOW_RGBA", INT2NUM(GLUT_WINDOW_RGBA));
-	rb_define_const(module, "GLUT_WINDOW_PARENT", INT2NUM(GLUT_WINDOW_PARENT));
-	rb_define_const(module, "GLUT_WINDOW_NUM_CHILDREN", INT2NUM(GLUT_WINDOW_NUM_CHILDREN));
-	rb_define_const(module, "GLUT_WINDOW_COLORMAP_SIZE", INT2NUM(GLUT_WINDOW_COLORMAP_SIZE));
-	rb_define_const(module, "GLUT_WINDOW_NUM_SAMPLES", INT2NUM(GLUT_WINDOW_NUM_SAMPLES));
-	rb_define_const(module, "GLUT_WINDOW_STEREO", INT2NUM(GLUT_WINDOW_STEREO));
-	rb_define_const(module, "GLUT_WINDOW_CURSOR", INT2NUM(GLUT_WINDOW_CURSOR));
-	rb_define_const(module, "GLUT_SCREEN_WIDTH", INT2NUM(GLUT_SCREEN_WIDTH));
-	rb_define_const(module, "GLUT_SCREEN_HEIGHT", INT2NUM(GLUT_SCREEN_HEIGHT));
-	rb_define_const(module, "GLUT_SCREEN_WIDTH_MM", INT2NUM(GLUT_SCREEN_WIDTH_MM));
-	rb_define_const(module, "GLUT_SCREEN_HEIGHT_MM", INT2NUM(GLUT_SCREEN_HEIGHT_MM));
-	rb_define_const(module, "GLUT_MENU_NUM_ITEMS", INT2NUM(GLUT_MENU_NUM_ITEMS));
-	rb_define_const(module, "GLUT_DISPLAY_MODE_POSSIBLE", INT2NUM(GLUT_DISPLAY_MODE_POSSIBLE));
-	rb_define_const(module, "GLUT_INIT_WINDOW_X", INT2NUM(GLUT_INIT_WINDOW_X));
-	rb_define_const(module, "GLUT_INIT_WINDOW_Y", INT2NUM(GLUT_INIT_WINDOW_Y));
-	rb_define_const(module, "GLUT_INIT_WINDOW_WIDTH", INT2NUM(GLUT_INIT_WINDOW_WIDTH));
-	rb_define_const(module, "GLUT_INIT_WINDOW_HEIGHT", INT2NUM(GLUT_INIT_WINDOW_HEIGHT));
-	rb_define_const(module, "GLUT_INIT_DISPLAY_MODE", INT2NUM(GLUT_INIT_DISPLAY_MODE));
-	rb_define_const(module, "GLUT_ELAPSED_TIME", INT2NUM(GLUT_ELAPSED_TIME));
-	rb_define_const(module, "GLUT_HAS_KEYBOARD", INT2NUM(GLUT_HAS_KEYBOARD));
-	rb_define_const(module, "GLUT_HAS_MOUSE", INT2NUM(GLUT_HAS_MOUSE));
-	rb_define_const(module, "GLUT_HAS_SPACEBALL", INT2NUM(GLUT_HAS_SPACEBALL));
-	rb_define_const(module, "GLUT_HAS_DIAL_AND_BUTTON_BOX", INT2NUM(GLUT_HAS_DIAL_AND_BUTTON_BOX));
-	rb_define_const(module, "GLUT_HAS_TABLET", INT2NUM(GLUT_HAS_TABLET));
-	rb_define_const(module, "GLUT_NUM_MOUSE_BUTTONS", INT2NUM(GLUT_NUM_MOUSE_BUTTONS));
-	rb_define_const(module, "GLUT_NUM_SPACEBALL_BUTTONS", INT2NUM(GLUT_NUM_SPACEBALL_BUTTONS));
-	rb_define_const(module, "GLUT_NUM_BUTTON_BOX_BUTTONS", INT2NUM(GLUT_NUM_BUTTON_BOX_BUTTONS));
-	rb_define_const(module, "GLUT_NUM_DIALS", INT2NUM(GLUT_NUM_DIALS));
-	rb_define_const(module, "GLUT_NUM_TABLET_BUTTONS", INT2NUM(GLUT_NUM_TABLET_BUTTONS));
-	rb_define_const(module, "GLUT_OVERLAY_POSSIBLE", INT2NUM(GLUT_OVERLAY_POSSIBLE));
-	rb_define_const(module, "GLUT_LAYER_IN_USE", INT2NUM(GLUT_LAYER_IN_USE));
-	rb_define_const(module, "GLUT_HAS_OVERLAY", INT2NUM(GLUT_HAS_OVERLAY));
-	rb_define_const(module, "GLUT_TRANSPARENT_INDEX", INT2NUM(GLUT_TRANSPARENT_INDEX));
-	rb_define_const(module, "GLUT_NORMAL_DAMAGED", INT2NUM(GLUT_NORMAL_DAMAGED));
-	rb_define_const(module, "GLUT_OVERLAY_DAMAGED", INT2NUM(GLUT_OVERLAY_DAMAGED));
-	rb_define_const(module, "GLUT_VIDEO_RESIZE_POSSIBLE", INT2NUM(GLUT_VIDEO_RESIZE_POSSIBLE));
-	rb_define_const(module, "GLUT_VIDEO_RESIZE_IN_USE", INT2NUM(GLUT_VIDEO_RESIZE_IN_USE));
-	rb_define_const(module, "GLUT_VIDEO_RESIZE_X_DELTA", INT2NUM(GLUT_VIDEO_RESIZE_X_DELTA));
-	rb_define_const(module, "GLUT_VIDEO_RESIZE_Y_DELTA", INT2NUM(GLUT_VIDEO_RESIZE_Y_DELTA));
-	rb_define_const(module, "GLUT_VIDEO_RESIZE_WIDTH_DELTA", INT2NUM(GLUT_VIDEO_RESIZE_WIDTH_DELTA));
-	rb_define_const(module, "GLUT_VIDEO_RESIZE_HEIGHT_DELTA", INT2NUM(GLUT_VIDEO_RESIZE_HEIGHT_DELTA));
-	rb_define_const(module, "GLUT_VIDEO_RESIZE_X", INT2NUM(GLUT_VIDEO_RESIZE_X));
-	rb_define_const(module, "GLUT_VIDEO_RESIZE_Y", INT2NUM(GLUT_VIDEO_RESIZE_Y));
-	rb_define_const(module, "GLUT_VIDEO_RESIZE_WIDTH", INT2NUM(GLUT_VIDEO_RESIZE_WIDTH));
-	rb_define_const(module, "GLUT_VIDEO_RESIZE_HEIGHT", INT2NUM(GLUT_VIDEO_RESIZE_HEIGHT));
-	rb_define_const(module, "GLUT_NORMAL", INT2NUM(GLUT_NORMAL));
-	rb_define_const(module, "GLUT_OVERLAY", INT2NUM(GLUT_OVERLAY));
-	rb_define_const(module, "GLUT_ACTIVE_SHIFT", INT2NUM(GLUT_ACTIVE_SHIFT));
-	rb_define_const(module, "GLUT_ACTIVE_CTRL", INT2NUM(GLUT_ACTIVE_CTRL));
-	rb_define_const(module, "GLUT_ACTIVE_ALT", INT2NUM(GLUT_ACTIVE_ALT));
-	rb_define_const(module, "GLUT_CURSOR_RIGHT_ARROW", INT2NUM(GLUT_CURSOR_RIGHT_ARROW));
-	rb_define_const(module, "GLUT_CURSOR_LEFT_ARROW", INT2NUM(GLUT_CURSOR_LEFT_ARROW));
-	rb_define_const(module, "GLUT_CURSOR_INFO", INT2NUM(GLUT_CURSOR_INFO));
-	rb_define_const(module, "GLUT_CURSOR_DESTROY", INT2NUM(GLUT_CURSOR_DESTROY));
-	rb_define_const(module, "GLUT_CURSOR_HELP", INT2NUM(GLUT_CURSOR_HELP));
-	rb_define_const(module, "GLUT_CURSOR_CYCLE", INT2NUM(GLUT_CURSOR_CYCLE));
-	rb_define_const(module, "GLUT_CURSOR_SPRAY", INT2NUM(GLUT_CURSOR_SPRAY));
-	rb_define_const(module, "GLUT_CURSOR_WAIT", INT2NUM(GLUT_CURSOR_WAIT));
-	rb_define_const(module, "GLUT_CURSOR_TEXT", INT2NUM(GLUT_CURSOR_TEXT));
-	rb_define_const(module, "GLUT_CURSOR_CROSSHAIR", INT2NUM(GLUT_CURSOR_CROSSHAIR));
-	rb_define_const(module, "GLUT_CURSOR_UP_DOWN", INT2NUM(GLUT_CURSOR_UP_DOWN));
-	rb_define_const(module, "GLUT_CURSOR_LEFT_RIGHT", INT2NUM(GLUT_CURSOR_LEFT_RIGHT));
-	rb_define_const(module, "GLUT_CURSOR_TOP_SIDE", INT2NUM(GLUT_CURSOR_TOP_SIDE));
-	rb_define_const(module, "GLUT_CURSOR_BOTTOM_SIDE", INT2NUM(GLUT_CURSOR_BOTTOM_SIDE));
-	rb_define_const(module, "GLUT_CURSOR_LEFT_SIDE", INT2NUM(GLUT_CURSOR_LEFT_SIDE));
-	rb_define_const(module, "GLUT_CURSOR_RIGHT_SIDE", INT2NUM(GLUT_CURSOR_RIGHT_SIDE));
-	rb_define_const(module, "GLUT_CURSOR_TOP_LEFT_CORNER", INT2NUM(GLUT_CURSOR_TOP_LEFT_CORNER));
-	rb_define_const(module, "GLUT_CURSOR_TOP_RIGHT_CORNER", INT2NUM(GLUT_CURSOR_TOP_RIGHT_CORNER));
-	rb_define_const(module, "GLUT_CURSOR_BOTTOM_RIGHT_CORNER", INT2NUM(GLUT_CURSOR_BOTTOM_RIGHT_CORNER));
-	rb_define_const(module, "GLUT_CURSOR_BOTTOM_LEFT_CORNER", INT2NUM(GLUT_CURSOR_BOTTOM_LEFT_CORNER));
-	rb_define_const(module, "GLUT_CURSOR_INHERIT", INT2NUM(GLUT_CURSOR_INHERIT));
-	rb_define_const(module, "GLUT_CURSOR_NONE", INT2NUM(GLUT_CURSOR_NONE));
-	rb_define_const(module, "GLUT_CURSOR_FULL_CROSSHAIR", INT2NUM(GLUT_CURSOR_FULL_CROSSHAIR));
+	rb_define_const(mGlut, "GLUT_API_VERSION", INT2NUM(GLUT_API_VERSION));
+	rb_define_const(mGlut, "GLUT_XLIB_IMPLEMENTATION", INT2NUM(GLUT_XLIB_IMPLEMENTATION));
+	rb_define_const(mGlut, "GLUT_RGB", INT2NUM(GLUT_RGB));
+	rb_define_const(mGlut, "GLUT_RGBA", INT2NUM(GLUT_RGBA));
+	rb_define_const(mGlut, "GLUT_INDEX", INT2NUM(GLUT_INDEX));
+	rb_define_const(mGlut, "GLUT_SINGLE", INT2NUM(GLUT_SINGLE));
+	rb_define_const(mGlut, "GLUT_DOUBLE", INT2NUM(GLUT_DOUBLE));
+	rb_define_const(mGlut, "GLUT_ACCUM", INT2NUM(GLUT_ACCUM));
+	rb_define_const(mGlut, "GLUT_ALPHA", INT2NUM(GLUT_ALPHA));
+	rb_define_const(mGlut, "GLUT_DEPTH", INT2NUM(GLUT_DEPTH));
+	rb_define_const(mGlut, "GLUT_STENCIL", INT2NUM(GLUT_STENCIL));
+	rb_define_const(mGlut, "GLUT_MULTISAMPLE", INT2NUM(GLUT_MULTISAMPLE));
+	rb_define_const(mGlut, "GLUT_STEREO", INT2NUM(GLUT_STEREO));
+	rb_define_const(mGlut, "GLUT_LUMINANCE", INT2NUM(GLUT_LUMINANCE));
+	rb_define_const(mGlut, "GLUT_LEFT_BUTTON", INT2NUM(GLUT_LEFT_BUTTON));
+	rb_define_const(mGlut, "GLUT_MIDDLE_BUTTON", INT2NUM(GLUT_MIDDLE_BUTTON));
+	rb_define_const(mGlut, "GLUT_RIGHT_BUTTON", INT2NUM(GLUT_RIGHT_BUTTON));
+	rb_define_const(mGlut, "GLUT_DOWN", INT2NUM(GLUT_DOWN));
+	rb_define_const(mGlut, "GLUT_UP", INT2NUM(GLUT_UP));
+	rb_define_const(mGlut, "GLUT_KEY_F1", INT2NUM(GLUT_KEY_F1));
+	rb_define_const(mGlut, "GLUT_KEY_F2", INT2NUM(GLUT_KEY_F2));
+	rb_define_const(mGlut, "GLUT_KEY_F3", INT2NUM(GLUT_KEY_F3));
+	rb_define_const(mGlut, "GLUT_KEY_F4", INT2NUM(GLUT_KEY_F4));
+	rb_define_const(mGlut, "GLUT_KEY_F5", INT2NUM(GLUT_KEY_F5));
+	rb_define_const(mGlut, "GLUT_KEY_F6", INT2NUM(GLUT_KEY_F6));
+	rb_define_const(mGlut, "GLUT_KEY_F7", INT2NUM(GLUT_KEY_F7));
+	rb_define_const(mGlut, "GLUT_KEY_F8", INT2NUM(GLUT_KEY_F8));
+	rb_define_const(mGlut, "GLUT_KEY_F9", INT2NUM(GLUT_KEY_F9));
+	rb_define_const(mGlut, "GLUT_KEY_F10", INT2NUM(GLUT_KEY_F10));
+	rb_define_const(mGlut, "GLUT_KEY_F11", INT2NUM(GLUT_KEY_F11));
+	rb_define_const(mGlut, "GLUT_KEY_F12", INT2NUM(GLUT_KEY_F12));
+	rb_define_const(mGlut, "GLUT_KEY_LEFT", INT2NUM(GLUT_KEY_LEFT));
+	rb_define_const(mGlut, "GLUT_KEY_UP", INT2NUM(GLUT_KEY_UP));
+	rb_define_const(mGlut, "GLUT_KEY_RIGHT", INT2NUM(GLUT_KEY_RIGHT));
+	rb_define_const(mGlut, "GLUT_KEY_DOWN", INT2NUM(GLUT_KEY_DOWN));
+	rb_define_const(mGlut, "GLUT_KEY_PAGE_UP", INT2NUM(GLUT_KEY_PAGE_UP));
+	rb_define_const(mGlut, "GLUT_KEY_PAGE_DOWN", INT2NUM(GLUT_KEY_PAGE_DOWN));
+	rb_define_const(mGlut, "GLUT_KEY_HOME", INT2NUM(GLUT_KEY_HOME));
+	rb_define_const(mGlut, "GLUT_KEY_END", INT2NUM(GLUT_KEY_END));
+	rb_define_const(mGlut, "GLUT_KEY_INSERT", INT2NUM(GLUT_KEY_INSERT));
+	rb_define_const(mGlut, "GLUT_LEFT", INT2NUM(GLUT_LEFT));
+	rb_define_const(mGlut, "GLUT_ENTERED", INT2NUM(GLUT_ENTERED));
+	rb_define_const(mGlut, "GLUT_MENU_NOT_IN_USE", INT2NUM(GLUT_MENU_NOT_IN_USE));
+	rb_define_const(mGlut, "GLUT_MENU_IN_USE", INT2NUM(GLUT_MENU_IN_USE));
+	rb_define_const(mGlut, "GLUT_NOT_VISIBLE", INT2NUM(GLUT_NOT_VISIBLE));
+	rb_define_const(mGlut, "GLUT_VISIBLE", INT2NUM(GLUT_VISIBLE));
+	rb_define_const(mGlut, "GLUT_HIDDEN", INT2NUM(GLUT_HIDDEN));
+	rb_define_const(mGlut, "GLUT_FULLY_RETAINED", INT2NUM(GLUT_FULLY_RETAINED));
+	rb_define_const(mGlut, "GLUT_PARTIALLY_RETAINED", INT2NUM(GLUT_PARTIALLY_RETAINED));
+	rb_define_const(mGlut, "GLUT_FULLY_COVERED", INT2NUM(GLUT_FULLY_COVERED));
+	rb_define_const(mGlut, "GLUT_RED", INT2NUM(GLUT_RED));
+	rb_define_const(mGlut, "GLUT_GREEN", INT2NUM(GLUT_GREEN));
+	rb_define_const(mGlut, "GLUT_BLUE", INT2NUM(GLUT_BLUE));
+	rb_define_const(mGlut, "GLUT_WINDOW_X", INT2NUM(GLUT_WINDOW_X));
+	rb_define_const(mGlut, "GLUT_WINDOW_Y", INT2NUM(GLUT_WINDOW_Y));
+	rb_define_const(mGlut, "GLUT_WINDOW_WIDTH", INT2NUM(GLUT_WINDOW_WIDTH));
+	rb_define_const(mGlut, "GLUT_WINDOW_HEIGHT", INT2NUM(GLUT_WINDOW_HEIGHT));
+	rb_define_const(mGlut, "GLUT_WINDOW_BUFFER_SIZE", INT2NUM(GLUT_WINDOW_BUFFER_SIZE));
+	rb_define_const(mGlut, "GLUT_WINDOW_STENCIL_SIZE", INT2NUM(GLUT_WINDOW_STENCIL_SIZE));
+	rb_define_const(mGlut, "GLUT_WINDOW_DEPTH_SIZE", INT2NUM(GLUT_WINDOW_DEPTH_SIZE));
+	rb_define_const(mGlut, "GLUT_WINDOW_RED_SIZE", INT2NUM(GLUT_WINDOW_RED_SIZE));
+	rb_define_const(mGlut, "GLUT_WINDOW_GREEN_SIZE", INT2NUM(GLUT_WINDOW_GREEN_SIZE));
+	rb_define_const(mGlut, "GLUT_WINDOW_BLUE_SIZE", INT2NUM(GLUT_WINDOW_BLUE_SIZE));
+	rb_define_const(mGlut, "GLUT_WINDOW_ALPHA_SIZE", INT2NUM(GLUT_WINDOW_ALPHA_SIZE));
+	rb_define_const(mGlut, "GLUT_WINDOW_ACCUM_RED_SIZE", INT2NUM(GLUT_WINDOW_ACCUM_RED_SIZE));
+	rb_define_const(mGlut, "GLUT_WINDOW_ACCUM_GREEN_SIZE", INT2NUM(GLUT_WINDOW_ACCUM_GREEN_SIZE));
+	rb_define_const(mGlut, "GLUT_WINDOW_ACCUM_BLUE_SIZE", INT2NUM(GLUT_WINDOW_ACCUM_BLUE_SIZE));
+	rb_define_const(mGlut, "GLUT_WINDOW_ACCUM_ALPHA_SIZE", INT2NUM(GLUT_WINDOW_ACCUM_ALPHA_SIZE));
+	rb_define_const(mGlut, "GLUT_WINDOW_DOUBLEBUFFER", INT2NUM(GLUT_WINDOW_DOUBLEBUFFER));
+	rb_define_const(mGlut, "GLUT_WINDOW_RGBA", INT2NUM(GLUT_WINDOW_RGBA));
+	rb_define_const(mGlut, "GLUT_WINDOW_PARENT", INT2NUM(GLUT_WINDOW_PARENT));
+	rb_define_const(mGlut, "GLUT_WINDOW_NUM_CHILDREN", INT2NUM(GLUT_WINDOW_NUM_CHILDREN));
+	rb_define_const(mGlut, "GLUT_WINDOW_COLORMAP_SIZE", INT2NUM(GLUT_WINDOW_COLORMAP_SIZE));
+	rb_define_const(mGlut, "GLUT_WINDOW_NUM_SAMPLES", INT2NUM(GLUT_WINDOW_NUM_SAMPLES));
+	rb_define_const(mGlut, "GLUT_WINDOW_STEREO", INT2NUM(GLUT_WINDOW_STEREO));
+	rb_define_const(mGlut, "GLUT_WINDOW_CURSOR", INT2NUM(GLUT_WINDOW_CURSOR));
+	rb_define_const(mGlut, "GLUT_SCREEN_WIDTH", INT2NUM(GLUT_SCREEN_WIDTH));
+	rb_define_const(mGlut, "GLUT_SCREEN_HEIGHT", INT2NUM(GLUT_SCREEN_HEIGHT));
+	rb_define_const(mGlut, "GLUT_SCREEN_WIDTH_MM", INT2NUM(GLUT_SCREEN_WIDTH_MM));
+	rb_define_const(mGlut, "GLUT_SCREEN_HEIGHT_MM", INT2NUM(GLUT_SCREEN_HEIGHT_MM));
+	rb_define_const(mGlut, "GLUT_MENU_NUM_ITEMS", INT2NUM(GLUT_MENU_NUM_ITEMS));
+	rb_define_const(mGlut, "GLUT_DISPLAY_MODE_POSSIBLE", INT2NUM(GLUT_DISPLAY_MODE_POSSIBLE));
+	rb_define_const(mGlut, "GLUT_INIT_WINDOW_X", INT2NUM(GLUT_INIT_WINDOW_X));
+	rb_define_const(mGlut, "GLUT_INIT_WINDOW_Y", INT2NUM(GLUT_INIT_WINDOW_Y));
+	rb_define_const(mGlut, "GLUT_INIT_WINDOW_WIDTH", INT2NUM(GLUT_INIT_WINDOW_WIDTH));
+	rb_define_const(mGlut, "GLUT_INIT_WINDOW_HEIGHT", INT2NUM(GLUT_INIT_WINDOW_HEIGHT));
+	rb_define_const(mGlut, "GLUT_INIT_DISPLAY_MODE", INT2NUM(GLUT_INIT_DISPLAY_MODE));
+	rb_define_const(mGlut, "GLUT_ELAPSED_TIME", INT2NUM(GLUT_ELAPSED_TIME));
+	rb_define_const(mGlut, "GLUT_HAS_KEYBOARD", INT2NUM(GLUT_HAS_KEYBOARD));
+	rb_define_const(mGlut, "GLUT_HAS_MOUSE", INT2NUM(GLUT_HAS_MOUSE));
+	rb_define_const(mGlut, "GLUT_HAS_SPACEBALL", INT2NUM(GLUT_HAS_SPACEBALL));
+	rb_define_const(mGlut, "GLUT_HAS_DIAL_AND_BUTTON_BOX", INT2NUM(GLUT_HAS_DIAL_AND_BUTTON_BOX));
+	rb_define_const(mGlut, "GLUT_HAS_TABLET", INT2NUM(GLUT_HAS_TABLET));
+	rb_define_const(mGlut, "GLUT_NUM_MOUSE_BUTTONS", INT2NUM(GLUT_NUM_MOUSE_BUTTONS));
+	rb_define_const(mGlut, "GLUT_NUM_SPACEBALL_BUTTONS", INT2NUM(GLUT_NUM_SPACEBALL_BUTTONS));
+	rb_define_const(mGlut, "GLUT_NUM_BUTTON_BOX_BUTTONS", INT2NUM(GLUT_NUM_BUTTON_BOX_BUTTONS));
+	rb_define_const(mGlut, "GLUT_NUM_DIALS", INT2NUM(GLUT_NUM_DIALS));
+	rb_define_const(mGlut, "GLUT_NUM_TABLET_BUTTONS", INT2NUM(GLUT_NUM_TABLET_BUTTONS));
+	rb_define_const(mGlut, "GLUT_OVERLAY_POSSIBLE", INT2NUM(GLUT_OVERLAY_POSSIBLE));
+	rb_define_const(mGlut, "GLUT_LAYER_IN_USE", INT2NUM(GLUT_LAYER_IN_USE));
+	rb_define_const(mGlut, "GLUT_HAS_OVERLAY", INT2NUM(GLUT_HAS_OVERLAY));
+	rb_define_const(mGlut, "GLUT_TRANSPARENT_INDEX", INT2NUM(GLUT_TRANSPARENT_INDEX));
+	rb_define_const(mGlut, "GLUT_NORMAL_DAMAGED", INT2NUM(GLUT_NORMAL_DAMAGED));
+	rb_define_const(mGlut, "GLUT_OVERLAY_DAMAGED", INT2NUM(GLUT_OVERLAY_DAMAGED));
+	rb_define_const(mGlut, "GLUT_VIDEO_RESIZE_POSSIBLE", INT2NUM(GLUT_VIDEO_RESIZE_POSSIBLE));
+	rb_define_const(mGlut, "GLUT_VIDEO_RESIZE_IN_USE", INT2NUM(GLUT_VIDEO_RESIZE_IN_USE));
+	rb_define_const(mGlut, "GLUT_VIDEO_RESIZE_X_DELTA", INT2NUM(GLUT_VIDEO_RESIZE_X_DELTA));
+	rb_define_const(mGlut, "GLUT_VIDEO_RESIZE_Y_DELTA", INT2NUM(GLUT_VIDEO_RESIZE_Y_DELTA));
+	rb_define_const(mGlut, "GLUT_VIDEO_RESIZE_WIDTH_DELTA", INT2NUM(GLUT_VIDEO_RESIZE_WIDTH_DELTA));
+	rb_define_const(mGlut, "GLUT_VIDEO_RESIZE_HEIGHT_DELTA", INT2NUM(GLUT_VIDEO_RESIZE_HEIGHT_DELTA));
+	rb_define_const(mGlut, "GLUT_VIDEO_RESIZE_X", INT2NUM(GLUT_VIDEO_RESIZE_X));
+	rb_define_const(mGlut, "GLUT_VIDEO_RESIZE_Y", INT2NUM(GLUT_VIDEO_RESIZE_Y));
+	rb_define_const(mGlut, "GLUT_VIDEO_RESIZE_WIDTH", INT2NUM(GLUT_VIDEO_RESIZE_WIDTH));
+	rb_define_const(mGlut, "GLUT_VIDEO_RESIZE_HEIGHT", INT2NUM(GLUT_VIDEO_RESIZE_HEIGHT));
+	rb_define_const(mGlut, "GLUT_NORMAL", INT2NUM(GLUT_NORMAL));
+	rb_define_const(mGlut, "GLUT_OVERLAY", INT2NUM(GLUT_OVERLAY));
+	rb_define_const(mGlut, "GLUT_ACTIVE_SHIFT", INT2NUM(GLUT_ACTIVE_SHIFT));
+	rb_define_const(mGlut, "GLUT_ACTIVE_CTRL", INT2NUM(GLUT_ACTIVE_CTRL));
+	rb_define_const(mGlut, "GLUT_ACTIVE_ALT", INT2NUM(GLUT_ACTIVE_ALT));
+	rb_define_const(mGlut, "GLUT_CURSOR_RIGHT_ARROW", INT2NUM(GLUT_CURSOR_RIGHT_ARROW));
+	rb_define_const(mGlut, "GLUT_CURSOR_LEFT_ARROW", INT2NUM(GLUT_CURSOR_LEFT_ARROW));
+	rb_define_const(mGlut, "GLUT_CURSOR_INFO", INT2NUM(GLUT_CURSOR_INFO));
+	rb_define_const(mGlut, "GLUT_CURSOR_DESTROY", INT2NUM(GLUT_CURSOR_DESTROY));
+	rb_define_const(mGlut, "GLUT_CURSOR_HELP", INT2NUM(GLUT_CURSOR_HELP));
+	rb_define_const(mGlut, "GLUT_CURSOR_CYCLE", INT2NUM(GLUT_CURSOR_CYCLE));
+	rb_define_const(mGlut, "GLUT_CURSOR_SPRAY", INT2NUM(GLUT_CURSOR_SPRAY));
+	rb_define_const(mGlut, "GLUT_CURSOR_WAIT", INT2NUM(GLUT_CURSOR_WAIT));
+	rb_define_const(mGlut, "GLUT_CURSOR_TEXT", INT2NUM(GLUT_CURSOR_TEXT));
+	rb_define_const(mGlut, "GLUT_CURSOR_CROSSHAIR", INT2NUM(GLUT_CURSOR_CROSSHAIR));
+	rb_define_const(mGlut, "GLUT_CURSOR_UP_DOWN", INT2NUM(GLUT_CURSOR_UP_DOWN));
+	rb_define_const(mGlut, "GLUT_CURSOR_LEFT_RIGHT", INT2NUM(GLUT_CURSOR_LEFT_RIGHT));
+	rb_define_const(mGlut, "GLUT_CURSOR_TOP_SIDE", INT2NUM(GLUT_CURSOR_TOP_SIDE));
+	rb_define_const(mGlut, "GLUT_CURSOR_BOTTOM_SIDE", INT2NUM(GLUT_CURSOR_BOTTOM_SIDE));
+	rb_define_const(mGlut, "GLUT_CURSOR_LEFT_SIDE", INT2NUM(GLUT_CURSOR_LEFT_SIDE));
+	rb_define_const(mGlut, "GLUT_CURSOR_RIGHT_SIDE", INT2NUM(GLUT_CURSOR_RIGHT_SIDE));
+	rb_define_const(mGlut, "GLUT_CURSOR_TOP_LEFT_CORNER", INT2NUM(GLUT_CURSOR_TOP_LEFT_CORNER));
+	rb_define_const(mGlut, "GLUT_CURSOR_TOP_RIGHT_CORNER", INT2NUM(GLUT_CURSOR_TOP_RIGHT_CORNER));
+	rb_define_const(mGlut, "GLUT_CURSOR_BOTTOM_RIGHT_CORNER", INT2NUM(GLUT_CURSOR_BOTTOM_RIGHT_CORNER));
+	rb_define_const(mGlut, "GLUT_CURSOR_BOTTOM_LEFT_CORNER", INT2NUM(GLUT_CURSOR_BOTTOM_LEFT_CORNER));
+	rb_define_const(mGlut, "GLUT_CURSOR_INHERIT", INT2NUM(GLUT_CURSOR_INHERIT));
+	rb_define_const(mGlut, "GLUT_CURSOR_NONE", INT2NUM(GLUT_CURSOR_NONE));
+	rb_define_const(mGlut, "GLUT_CURSOR_FULL_CROSSHAIR", INT2NUM(GLUT_CURSOR_FULL_CROSSHAIR));
 
 	/* hardcoded, see bitmap_font_map for explanation */
-	rb_define_const(module, "GLUT_BITMAP_9_BY_15", INT2NUM(0));
-	rb_define_const(module, "GLUT_BITMAP_8_BY_13", INT2NUM(1));
-	rb_define_const(module, "GLUT_BITMAP_TIMES_ROMAN_10", INT2NUM(2));
-	rb_define_const(module, "GLUT_BITMAP_TIMES_ROMAN_24", INT2NUM(3));
-	rb_define_const(module, "GLUT_BITMAP_HELVETICA_10", INT2NUM(4));
-	rb_define_const(module, "GLUT_BITMAP_HELVETICA_12", INT2NUM(5));
-	rb_define_const(module, "GLUT_BITMAP_HELVETICA_18", INT2NUM(6));
-	rb_define_const(module, "GLUT_STROKE_ROMAN", INT2NUM(7));
-	rb_define_const(module, "GLUT_STROKE_MONO_ROMAN", INT2NUM(8));
-
-	rb_define_const(module, "GLUT_WINDOW_FORMAT_ID", INT2NUM(GLUT_WINDOW_FORMAT_ID));
-	rb_define_const(module, "GLUT_DEVICE_IGNORE_KEY_REPEAT", INT2NUM(GLUT_DEVICE_IGNORE_KEY_REPEAT));
-	rb_define_const(module, "GLUT_DEVICE_KEY_REPEAT", INT2NUM(GLUT_DEVICE_KEY_REPEAT));
-	rb_define_const(module, "GLUT_HAS_JOYSTICK", INT2NUM(GLUT_HAS_JOYSTICK));
-	rb_define_const(module, "GLUT_OWNS_JOYSTICK", INT2NUM(GLUT_OWNS_JOYSTICK));
-	rb_define_const(module, "GLUT_JOYSTICK_BUTTONS", INT2NUM(GLUT_JOYSTICK_BUTTONS));
-	rb_define_const(module, "GLUT_JOYSTICK_AXES", INT2NUM(GLUT_JOYSTICK_AXES));
-	rb_define_const(module, "GLUT_JOYSTICK_POLL_RATE", INT2NUM(GLUT_JOYSTICK_POLL_RATE));
-	rb_define_const(module, "GLUT_KEY_REPEAT_OFF", INT2NUM(GLUT_KEY_REPEAT_OFF));
-	rb_define_const(module, "GLUT_KEY_REPEAT_ON", INT2NUM(GLUT_KEY_REPEAT_ON));
-	rb_define_const(module, "GLUT_KEY_REPEAT_DEFAULT", INT2NUM(GLUT_KEY_REPEAT_DEFAULT));
-	rb_define_const(module, "GLUT_JOYSTICK_BUTTON_A", INT2NUM(GLUT_JOYSTICK_BUTTON_A));
-	rb_define_const(module, "GLUT_JOYSTICK_BUTTON_B", INT2NUM(GLUT_JOYSTICK_BUTTON_B));
-	rb_define_const(module, "GLUT_JOYSTICK_BUTTON_C", INT2NUM(GLUT_JOYSTICK_BUTTON_C));
-	rb_define_const(module, "GLUT_JOYSTICK_BUTTON_D", INT2NUM(GLUT_JOYSTICK_BUTTON_D));
-	rb_define_const(module, "GLUT_GAME_MODE_ACTIVE", INT2NUM(GLUT_GAME_MODE_ACTIVE));
-	rb_define_const(module, "GLUT_GAME_MODE_POSSIBLE", INT2NUM(GLUT_GAME_MODE_POSSIBLE));
-	rb_define_const(module, "GLUT_GAME_MODE_WIDTH", INT2NUM(GLUT_GAME_MODE_WIDTH));
-	rb_define_const(module, "GLUT_GAME_MODE_HEIGHT", INT2NUM(GLUT_GAME_MODE_HEIGHT));
-	rb_define_const(module, "GLUT_GAME_MODE_PIXEL_DEPTH", INT2NUM(GLUT_GAME_MODE_PIXEL_DEPTH));
-	rb_define_const(module, "GLUT_GAME_MODE_REFRESH_RATE", INT2NUM(GLUT_GAME_MODE_REFRESH_RATE));
-	rb_define_const(module, "GLUT_GAME_MODE_DISPLAY_CHANGED", INT2NUM(GLUT_GAME_MODE_DISPLAY_CHANGED));
- 
-	// Some OSX specific constants
-#ifdef GLUT_NO_RECOVERY
-	rb_define_const(mGlut, "GLUT_NO_RECOVERY", INT2NUM(GLUT_NO_RECOVERY));
-#endif
-#ifdef GLUT_3_2_CORE_PROFILE
-	rb_define_const(mGlut, "GLUT_3_2_CORE_PROFILE", INT2NUM(GLUT_3_2_CORE_PROFILE));
-#endif
-	
-	
-	callId = rb_intern("call");
-	
-	WINDOW_CALLBACK_DEFINE(DisplayFunc);
-	WINDOW_CALLBACK_DEFINE(ReshapeFunc);
-	WINDOW_CALLBACK_DEFINE(KeyboardFunc);
-	WINDOW_CALLBACK_DEFINE(MouseFunc);
-	WINDOW_CALLBACK_DEFINE(MotionFunc);
-	WINDOW_CALLBACK_DEFINE(PassiveMotionFunc);
-	WINDOW_CALLBACK_DEFINE(EntryFunc);
-	WINDOW_CALLBACK_DEFINE(VisibilityFunc);
-	WINDOW_CALLBACK_DEFINE(SpecialFunc);
-	WINDOW_CALLBACK_DEFINE(SpaceballMotionFunc);
-	WINDOW_CALLBACK_DEFINE(SpaceballRotateFunc);
-	WINDOW_CALLBACK_DEFINE(SpaceballButtonFunc);
-	WINDOW_CALLBACK_DEFINE(ButtonBoxFunc);
-	WINDOW_CALLBACK_DEFINE(DialsFunc);
-	WINDOW_CALLBACK_DEFINE(TabletMotionFunc);
-	WINDOW_CALLBACK_DEFINE(TabletButtonFunc);
-	WINDOW_CALLBACK_DEFINE(OverlayDisplayFunc);
-	WINDOW_CALLBACK_DEFINE(WindowStatusFunc);
-	WINDOW_CALLBACK_DEFINE(KeyboardUpFunc);
-	WINDOW_CALLBACK_DEFINE(SpecialUpFunc);
-	
-	/* special case, 2 params */
-	rb_define_module_function(module, "glutJoystickFunc",glut_JoystickFunc , 2);
-	rb_global_variable(&JoystickFunc);
-	JoystickFunc = rb_ary_new();
-	
-	rb_gc_register_address(&idle_func);
-	rb_gc_register_address(&timer_func);
-	rb_gc_register_address(&menustate_func);
+	rb_define_const(mGlut, "GLUT_BITMAP_9_BY_15", INT2NUM(0));
+	rb_define_const(mGlut, "GLUT_BITMAP_8_BY_13", INT2NUM(1));
+	rb_define_const(mGlut, "GLUT_BITMAP_TIMES_ROMAN_10", INT2NUM(2));
+	rb_define_const(mGlut, "GLUT_BITMAP_TIMES_ROMAN_24", INT2NUM(3));
+	rb_define_const(mGlut, "GLUT_BITMAP_HELVETICA_10", INT2NUM(4));
+	rb_define_const(mGlut, "GLUT_BITMAP_HELVETICA_12", INT2NUM(5));
+	rb_define_const(mGlut, "GLUT_BITMAP_HELVETICA_18", INT2NUM(6));
+	rb_define_const(mGlut, "GLUT_STROKE_ROMAN", INT2NUM(7));
+	rb_define_const(mGlut, "GLUT_STROKE_MONO_ROMAN", INT2NUM(8));
+
+	rb_define_const(mGlut, "GLUT_WINDOW_FORMAT_ID", INT2NUM(GLUT_WINDOW_FORMAT_ID));
+	rb_define_const(mGlut, "GLUT_DEVICE_IGNORE_KEY_REPEAT", INT2NUM(GLUT_DEVICE_IGNORE_KEY_REPEAT));
+	rb_define_const(mGlut, "GLUT_DEVICE_KEY_REPEAT", INT2NUM(GLUT_DEVICE_KEY_REPEAT));
+	rb_define_const(mGlut, "GLUT_HAS_JOYSTICK", INT2NUM(GLUT_HAS_JOYSTICK));
+	rb_define_const(mGlut, "GLUT_OWNS_JOYSTICK", INT2NUM(GLUT_OWNS_JOYSTICK));
+	rb_define_const(mGlut, "GLUT_JOYSTICK_BUTTONS", INT2NUM(GLUT_JOYSTICK_BUTTONS));
+	rb_define_const(mGlut, "GLUT_JOYSTICK_AXES", INT2NUM(GLUT_JOYSTICK_AXES));
+	rb_define_const(mGlut, "GLUT_JOYSTICK_POLL_RATE", INT2NUM(GLUT_JOYSTICK_POLL_RATE));
+	rb_define_const(mGlut, "GLUT_KEY_REPEAT_OFF", INT2NUM(GLUT_KEY_REPEAT_OFF));
+	rb_define_const(mGlut, "GLUT_KEY_REPEAT_ON", INT2NUM(GLUT_KEY_REPEAT_ON));
+	rb_define_const(mGlut, "GLUT_KEY_REPEAT_DEFAULT", INT2NUM(GLUT_KEY_REPEAT_DEFAULT));
+	rb_define_const(mGlut, "GLUT_JOYSTICK_BUTTON_A", INT2NUM(GLUT_JOYSTICK_BUTTON_A));
+	rb_define_const(mGlut, "GLUT_JOYSTICK_BUTTON_B", INT2NUM(GLUT_JOYSTICK_BUTTON_B));
+	rb_define_const(mGlut, "GLUT_JOYSTICK_BUTTON_C", INT2NUM(GLUT_JOYSTICK_BUTTON_C));
+	rb_define_const(mGlut, "GLUT_JOYSTICK_BUTTON_D", INT2NUM(GLUT_JOYSTICK_BUTTON_D));
+	rb_define_const(mGlut, "GLUT_GAME_MODE_ACTIVE", INT2NUM(GLUT_GAME_MODE_ACTIVE));
+	rb_define_const(mGlut, "GLUT_GAME_MODE_POSSIBLE", INT2NUM(GLUT_GAME_MODE_POSSIBLE));
+	rb_define_const(mGlut, "GLUT_GAME_MODE_WIDTH", INT2NUM(GLUT_GAME_MODE_WIDTH));
+	rb_define_const(mGlut, "GLUT_GAME_MODE_HEIGHT", INT2NUM(GLUT_GAME_MODE_HEIGHT));
+	rb_define_const(mGlut, "GLUT_GAME_MODE_PIXEL_DEPTH", INT2NUM(GLUT_GAME_MODE_PIXEL_DEPTH));
+	rb_define_const(mGlut, "GLUT_GAME_MODE_REFRESH_RATE", INT2NUM(GLUT_GAME_MODE_REFRESH_RATE));
+	rb_define_const(mGlut, "GLUT_GAME_MODE_DISPLAY_CHANGED", INT2NUM(GLUT_GAME_MODE_DISPLAY_CHANGED));
 }