ruby-opengl 0.40.1 → 0.50.0

data/ext/gl/mkrf_conf.rb

@@ -25,6 +25,7 @@ Mkrf::Generator.new( 'gl' ) do |g|
         g.cflags << ' -DWIN32'
         g.include_library( 'opengl32.lib', 'glVertex3d')
     else
+        g.cflags << ' -Wall'
         g.include_library( 'GL', 'glVertex3d')
     end
 end

data/ext/glu/glu-enums.c

@@ -0,0 +1,163 @@
+/* This file was genereated on Mon Jul 23 15:17:36 +0200 2007
+   source: http://oss.sgi.com/cgi-bin/cvsweb.cgi/~checkout~/projects/ogl-sample/main/doc/registry/specs/enumglu.spec
+*/
+
+#include "../common/common.h"
+void glu_init_enums(VALUE module)
+{
+	rb_define_const(module, "GLU_AUTO_LOAD_MATRIX", INT2NUM(GLU_AUTO_LOAD_MATRIX));
+	rb_define_const(module, "GLU_BEGIN", INT2NUM(GLU_BEGIN));
+	rb_define_const(module, "GLU_CCW", INT2NUM(GLU_CCW));
+	rb_define_const(module, "GLU_CULLING", INT2NUM(GLU_CULLING));
+	rb_define_const(module, "GLU_CW", INT2NUM(GLU_CW));
+	rb_define_const(module, "GLU_DISPLAY_MODE", INT2NUM(GLU_DISPLAY_MODE));
+	rb_define_const(module, "GLU_DOMAIN_DISTANCE", INT2NUM(GLU_DOMAIN_DISTANCE));
+	rb_define_const(module, "GLU_EDGE_FLAG", INT2NUM(GLU_EDGE_FLAG));
+	rb_define_const(module, "GLU_END", INT2NUM(GLU_END));
+	rb_define_const(module, "GLU_ERROR", INT2NUM(GLU_ERROR));
+	rb_define_const(module, "GLU_EXTENSIONS", INT2NUM(GLU_EXTENSIONS));
+	rb_define_const(module, "GLU_EXTERIOR", INT2NUM(GLU_EXTERIOR));
+	rb_define_const(module, "GLU_EXT_nurbs_tessellator", INT2NUM(GLU_EXT_nurbs_tessellator));
+	rb_define_const(module, "GLU_EXT_object_space_tess", INT2NUM(GLU_EXT_object_space_tess));
+	rb_define_const(module, "GLU_FALSE", INT2NUM(GLU_FALSE));
+	rb_define_const(module, "GLU_FILL", INT2NUM(GLU_FILL));
+	rb_define_const(module, "GLU_FLAT", INT2NUM(GLU_FLAT));
+	rb_define_const(module, "GLU_INSIDE", INT2NUM(GLU_INSIDE));
+	rb_define_const(module, "GLU_INTERIOR", INT2NUM(GLU_INTERIOR));
+	rb_define_const(module, "GLU_INVALID_ENUM", INT2NUM(GLU_INVALID_ENUM));
+	rb_define_const(module, "GLU_INVALID_OPERATION", INT2NUM(GLU_INVALID_OPERATION));
+	rb_define_const(module, "GLU_INVALID_VALUE", INT2NUM(GLU_INVALID_VALUE));
+	rb_define_const(module, "GLU_LAGRANGIAN_SGI", INT2NUM(GLU_LAGRANGIAN_SGI));
+	rb_define_const(module, "GLU_LINE", INT2NUM(GLU_LINE));
+	rb_define_const(module, "GLU_MAP1_TRIM_2", INT2NUM(GLU_MAP1_TRIM_2));
+	rb_define_const(module, "GLU_MAP1_TRIM_3", INT2NUM(GLU_MAP1_TRIM_3));
+	rb_define_const(module, "GLU_MITCHELL_NETRAVALI_SGI", INT2NUM(GLU_MITCHELL_NETRAVALI_SGI));
+	rb_define_const(module, "GLU_NONE", INT2NUM(GLU_NONE));
+	rb_define_const(module, "GLU_NURBS_BEGIN", INT2NUM(GLU_NURBS_BEGIN));
+	rb_define_const(module, "GLU_NURBS_BEGIN_DATA", INT2NUM(GLU_NURBS_BEGIN_DATA));
+	rb_define_const(module, "GLU_NURBS_BEGIN_DATA_EXT", INT2NUM(GLU_NURBS_BEGIN_DATA_EXT));
+	rb_define_const(module, "GLU_NURBS_BEGIN_EXT", INT2NUM(GLU_NURBS_BEGIN_EXT));
+	rb_define_const(module, "GLU_NURBS_COLOR", INT2NUM(GLU_NURBS_COLOR));
+	rb_define_const(module, "GLU_NURBS_COLOR_DATA", INT2NUM(GLU_NURBS_COLOR_DATA));
+	rb_define_const(module, "GLU_NURBS_COLOR_DATA_EXT", INT2NUM(GLU_NURBS_COLOR_DATA_EXT));
+	rb_define_const(module, "GLU_NURBS_COLOR_EXT", INT2NUM(GLU_NURBS_COLOR_EXT));
+	rb_define_const(module, "GLU_NURBS_END", INT2NUM(GLU_NURBS_END));
+	rb_define_const(module, "GLU_NURBS_END_DATA", INT2NUM(GLU_NURBS_END_DATA));
+	rb_define_const(module, "GLU_NURBS_END_DATA_EXT", INT2NUM(GLU_NURBS_END_DATA_EXT));
+	rb_define_const(module, "GLU_NURBS_END_EXT", INT2NUM(GLU_NURBS_END_EXT));
+	rb_define_const(module, "GLU_NURBS_ERROR", INT2NUM(GLU_NURBS_ERROR));
+	rb_define_const(module, "GLU_NURBS_ERROR1", INT2NUM(GLU_NURBS_ERROR1));
+	rb_define_const(module, "GLU_NURBS_ERROR10", INT2NUM(GLU_NURBS_ERROR10));
+	rb_define_const(module, "GLU_NURBS_ERROR11", INT2NUM(GLU_NURBS_ERROR11));
+	rb_define_const(module, "GLU_NURBS_ERROR12", INT2NUM(GLU_NURBS_ERROR12));
+	rb_define_const(module, "GLU_NURBS_ERROR13", INT2NUM(GLU_NURBS_ERROR13));
+	rb_define_const(module, "GLU_NURBS_ERROR14", INT2NUM(GLU_NURBS_ERROR14));
+	rb_define_const(module, "GLU_NURBS_ERROR15", INT2NUM(GLU_NURBS_ERROR15));
+	rb_define_const(module, "GLU_NURBS_ERROR16", INT2NUM(GLU_NURBS_ERROR16));
+	rb_define_const(module, "GLU_NURBS_ERROR17", INT2NUM(GLU_NURBS_ERROR17));
+	rb_define_const(module, "GLU_NURBS_ERROR18", INT2NUM(GLU_NURBS_ERROR18));
+	rb_define_const(module, "GLU_NURBS_ERROR19", INT2NUM(GLU_NURBS_ERROR19));
+	rb_define_const(module, "GLU_NURBS_ERROR2", INT2NUM(GLU_NURBS_ERROR2));
+	rb_define_const(module, "GLU_NURBS_ERROR20", INT2NUM(GLU_NURBS_ERROR20));
+	rb_define_const(module, "GLU_NURBS_ERROR21", INT2NUM(GLU_NURBS_ERROR21));
+	rb_define_const(module, "GLU_NURBS_ERROR22", INT2NUM(GLU_NURBS_ERROR22));
+	rb_define_const(module, "GLU_NURBS_ERROR23", INT2NUM(GLU_NURBS_ERROR23));
+	rb_define_const(module, "GLU_NURBS_ERROR24", INT2NUM(GLU_NURBS_ERROR24));
+	rb_define_const(module, "GLU_NURBS_ERROR25", INT2NUM(GLU_NURBS_ERROR25));
+	rb_define_const(module, "GLU_NURBS_ERROR26", INT2NUM(GLU_NURBS_ERROR26));
+	rb_define_const(module, "GLU_NURBS_ERROR27", INT2NUM(GLU_NURBS_ERROR27));
+	rb_define_const(module, "GLU_NURBS_ERROR28", INT2NUM(GLU_NURBS_ERROR28));
+	rb_define_const(module, "GLU_NURBS_ERROR29", INT2NUM(GLU_NURBS_ERROR29));
+	rb_define_const(module, "GLU_NURBS_ERROR3", INT2NUM(GLU_NURBS_ERROR3));
+	rb_define_const(module, "GLU_NURBS_ERROR30", INT2NUM(GLU_NURBS_ERROR30));
+	rb_define_const(module, "GLU_NURBS_ERROR31", INT2NUM(GLU_NURBS_ERROR31));
+	rb_define_const(module, "GLU_NURBS_ERROR32", INT2NUM(GLU_NURBS_ERROR32));
+	rb_define_const(module, "GLU_NURBS_ERROR33", INT2NUM(GLU_NURBS_ERROR33));
+	rb_define_const(module, "GLU_NURBS_ERROR34", INT2NUM(GLU_NURBS_ERROR34));
+	rb_define_const(module, "GLU_NURBS_ERROR35", INT2NUM(GLU_NURBS_ERROR35));
+	rb_define_const(module, "GLU_NURBS_ERROR36", INT2NUM(GLU_NURBS_ERROR36));
+	rb_define_const(module, "GLU_NURBS_ERROR37", INT2NUM(GLU_NURBS_ERROR37));
+	rb_define_const(module, "GLU_NURBS_ERROR4", INT2NUM(GLU_NURBS_ERROR4));
+	rb_define_const(module, "GLU_NURBS_ERROR5", INT2NUM(GLU_NURBS_ERROR5));
+	rb_define_const(module, "GLU_NURBS_ERROR6", INT2NUM(GLU_NURBS_ERROR6));
+	rb_define_const(module, "GLU_NURBS_ERROR7", INT2NUM(GLU_NURBS_ERROR7));
+	rb_define_const(module, "GLU_NURBS_ERROR8", INT2NUM(GLU_NURBS_ERROR8));
+	rb_define_const(module, "GLU_NURBS_ERROR9", INT2NUM(GLU_NURBS_ERROR9));
+	rb_define_const(module, "GLU_NURBS_MODE", INT2NUM(GLU_NURBS_MODE));
+	rb_define_const(module, "GLU_NURBS_MODE_EXT", INT2NUM(GLU_NURBS_MODE_EXT));
+	rb_define_const(module, "GLU_NURBS_NORMAL", INT2NUM(GLU_NURBS_NORMAL));
+	rb_define_const(module, "GLU_NURBS_NORMAL_DATA", INT2NUM(GLU_NURBS_NORMAL_DATA));
+	rb_define_const(module, "GLU_NURBS_NORMAL_DATA_EXT", INT2NUM(GLU_NURBS_NORMAL_DATA_EXT));
+	rb_define_const(module, "GLU_NURBS_NORMAL_EXT", INT2NUM(GLU_NURBS_NORMAL_EXT));
+	rb_define_const(module, "GLU_NURBS_RENDERER", INT2NUM(GLU_NURBS_RENDERER));
+	rb_define_const(module, "GLU_NURBS_RENDERER_EXT", INT2NUM(GLU_NURBS_RENDERER_EXT));
+	rb_define_const(module, "GLU_NURBS_TESSELLATOR", INT2NUM(GLU_NURBS_TESSELLATOR));
+	rb_define_const(module, "GLU_NURBS_TESSELLATOR_EXT", INT2NUM(GLU_NURBS_TESSELLATOR_EXT));
+	rb_define_const(module, "GLU_NURBS_TEXTURE_COORD", INT2NUM(GLU_NURBS_TEXTURE_COORD));
+	rb_define_const(module, "GLU_NURBS_TEXTURE_COORD_DATA", INT2NUM(GLU_NURBS_TEXTURE_COORD_DATA));
+	rb_define_const(module, "GLU_NURBS_TEXTURE_COORD_DATA_EXT", INT2NUM(GLU_NURBS_TEXTURE_COORD_DATA_EXT));
+	rb_define_const(module, "GLU_NURBS_TEXTURE_COORD_EXT", INT2NUM(GLU_NURBS_TEXTURE_COORD_EXT));
+	rb_define_const(module, "GLU_NURBS_VERTEX", INT2NUM(GLU_NURBS_VERTEX));
+	rb_define_const(module, "GLU_NURBS_VERTEX_DATA", INT2NUM(GLU_NURBS_VERTEX_DATA));
+	rb_define_const(module, "GLU_NURBS_VERTEX_DATA_EXT", INT2NUM(GLU_NURBS_VERTEX_DATA_EXT));
+	rb_define_const(module, "GLU_NURBS_VERTEX_EXT", INT2NUM(GLU_NURBS_VERTEX_EXT));
+	rb_define_const(module, "GLU_OBJECT_PARAMETRIC_ERROR", INT2NUM(GLU_OBJECT_PARAMETRIC_ERROR));
+	rb_define_const(module, "GLU_OBJECT_PARAMETRIC_ERROR_EXT", INT2NUM(GLU_OBJECT_PARAMETRIC_ERROR_EXT));
+	rb_define_const(module, "GLU_OBJECT_PATH_LENGTH", INT2NUM(GLU_OBJECT_PATH_LENGTH));
+	rb_define_const(module, "GLU_OBJECT_PATH_LENGTH_EXT", INT2NUM(GLU_OBJECT_PATH_LENGTH_EXT));
+	rb_define_const(module, "GLU_OUTLINE_PATCH", INT2NUM(GLU_OUTLINE_PATCH));
+	rb_define_const(module, "GLU_OUTLINE_POLYGON", INT2NUM(GLU_OUTLINE_POLYGON));
+	rb_define_const(module, "GLU_OUTSIDE", INT2NUM(GLU_OUTSIDE));
+	rb_define_const(module, "GLU_OUT_OF_MEMORY", INT2NUM(GLU_OUT_OF_MEMORY));
+	rb_define_const(module, "GLU_PARAMETRIC_ERROR", INT2NUM(GLU_PARAMETRIC_ERROR));
+	rb_define_const(module, "GLU_PARAMETRIC_TOLERANCE", INT2NUM(GLU_PARAMETRIC_TOLERANCE));
+	rb_define_const(module, "GLU_PATH_LENGTH", INT2NUM(GLU_PATH_LENGTH));
+	rb_define_const(module, "GLU_POINT", INT2NUM(GLU_POINT));
+	rb_define_const(module, "GLU_SAMPLING_METHOD", INT2NUM(GLU_SAMPLING_METHOD));
+	rb_define_const(module, "GLU_SAMPLING_TOLERANCE", INT2NUM(GLU_SAMPLING_TOLERANCE));
+	rb_define_const(module, "GLU_SILHOUETTE", INT2NUM(GLU_SILHOUETTE));
+	rb_define_const(module, "GLU_SMOOTH", INT2NUM(GLU_SMOOTH));
+	rb_define_const(module, "GLU_TESS_BEGIN", INT2NUM(GLU_TESS_BEGIN));
+	rb_define_const(module, "GLU_TESS_BEGIN_DATA", INT2NUM(GLU_TESS_BEGIN_DATA));
+	rb_define_const(module, "GLU_TESS_BOUNDARY_ONLY", INT2NUM(GLU_TESS_BOUNDARY_ONLY));
+	rb_define_const(module, "GLU_TESS_COMBINE", INT2NUM(GLU_TESS_COMBINE));
+	rb_define_const(module, "GLU_TESS_COMBINE_DATA", INT2NUM(GLU_TESS_COMBINE_DATA));
+	rb_define_const(module, "GLU_TESS_COORD_TOO_LARGE", INT2NUM(GLU_TESS_COORD_TOO_LARGE));
+	rb_define_const(module, "GLU_TESS_EDGE_FLAG", INT2NUM(GLU_TESS_EDGE_FLAG));
+	rb_define_const(module, "GLU_TESS_EDGE_FLAG_DATA", INT2NUM(GLU_TESS_EDGE_FLAG_DATA));
+	rb_define_const(module, "GLU_TESS_END", INT2NUM(GLU_TESS_END));
+	rb_define_const(module, "GLU_TESS_END_DATA", INT2NUM(GLU_TESS_END_DATA));
+	rb_define_const(module, "GLU_TESS_ERROR", INT2NUM(GLU_TESS_ERROR));
+	rb_define_const(module, "GLU_TESS_ERROR1", INT2NUM(GLU_TESS_ERROR1));
+	rb_define_const(module, "GLU_TESS_ERROR2", INT2NUM(GLU_TESS_ERROR2));
+	rb_define_const(module, "GLU_TESS_ERROR3", INT2NUM(GLU_TESS_ERROR3));
+	rb_define_const(module, "GLU_TESS_ERROR4", INT2NUM(GLU_TESS_ERROR4));
+	rb_define_const(module, "GLU_TESS_ERROR5", INT2NUM(GLU_TESS_ERROR5));
+	rb_define_const(module, "GLU_TESS_ERROR6", INT2NUM(GLU_TESS_ERROR6));
+	rb_define_const(module, "GLU_TESS_ERROR7", INT2NUM(GLU_TESS_ERROR7));
+	rb_define_const(module, "GLU_TESS_ERROR8", INT2NUM(GLU_TESS_ERROR8));
+	rb_define_const(module, "GLU_TESS_ERROR_DATA", INT2NUM(GLU_TESS_ERROR_DATA));
+	rb_define_const(module, "GLU_TESS_MISSING_BEGIN_CONTOUR", INT2NUM(GLU_TESS_MISSING_BEGIN_CONTOUR));
+	rb_define_const(module, "GLU_TESS_MISSING_BEGIN_POLYGON", INT2NUM(GLU_TESS_MISSING_BEGIN_POLYGON));
+	rb_define_const(module, "GLU_TESS_MISSING_END_CONTOUR", INT2NUM(GLU_TESS_MISSING_END_CONTOUR));
+	rb_define_const(module, "GLU_TESS_MISSING_END_POLYGON", INT2NUM(GLU_TESS_MISSING_END_POLYGON));
+	rb_define_const(module, "GLU_TESS_NEED_COMBINE_CALLBACK", INT2NUM(GLU_TESS_NEED_COMBINE_CALLBACK));
+	rb_define_const(module, "GLU_TESS_TOLERANCE", INT2NUM(GLU_TESS_TOLERANCE));
+	rb_define_const(module, "GLU_TESS_VERTEX", INT2NUM(GLU_TESS_VERTEX));
+	rb_define_const(module, "GLU_TESS_VERTEX_DATA", INT2NUM(GLU_TESS_VERTEX_DATA));
+	rb_define_const(module, "GLU_TESS_WINDING_ABS_GEQ_TWO", INT2NUM(GLU_TESS_WINDING_ABS_GEQ_TWO));
+	rb_define_const(module, "GLU_TESS_WINDING_NEGATIVE", INT2NUM(GLU_TESS_WINDING_NEGATIVE));
+	rb_define_const(module, "GLU_TESS_WINDING_NONZERO", INT2NUM(GLU_TESS_WINDING_NONZERO));
+	rb_define_const(module, "GLU_TESS_WINDING_ODD", INT2NUM(GLU_TESS_WINDING_ODD));
+	rb_define_const(module, "GLU_TESS_WINDING_POSITIVE", INT2NUM(GLU_TESS_WINDING_POSITIVE));
+	rb_define_const(module, "GLU_TESS_WINDING_RULE", INT2NUM(GLU_TESS_WINDING_RULE));
+	rb_define_const(module, "GLU_TRUE", INT2NUM(GLU_TRUE));
+	rb_define_const(module, "GLU_UNKNOWN", INT2NUM(GLU_UNKNOWN));
+	rb_define_const(module, "GLU_U_STEP", INT2NUM(GLU_U_STEP));
+	rb_define_const(module, "GLU_VERSION", INT2NUM(GLU_VERSION));
+	rb_define_const(module, "GLU_VERSION_1_1", INT2NUM(GLU_VERSION_1_1));
+	rb_define_const(module, "GLU_VERSION_1_2", INT2NUM(GLU_VERSION_1_2));
+	rb_define_const(module, "GLU_VERSION_1_3", INT2NUM(GLU_VERSION_1_3));
+	rb_define_const(module, "GLU_VERTEX", INT2NUM(GLU_VERTEX));
+	rb_define_const(module, "GLU_V_STEP", INT2NUM(GLU_V_STEP));
+}

data/ext/glu/glu.c

@@ -17,73 +17,59 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#ifdef __APPLE__
-#include <OpenGL/gl.h>
-#include <OpenGL/glu.h>
-#elif defined WIN32
-#include <windows.h>
-#include <GL/gl.h>
-#include <GL/glu.h>
-#else
-#include <GL/gl.h>
-#include <GL/glu.h>
-#endif
-
-#include <ruby.h>
 #include "../common/common.h"
 
-#ifdef WIN32
-#define DLLEXPORT __declspec(dllexport)
-typedef void (CALLBACK*(VOIDFUNC))();
-#else
-#define DLLEXPORT
-typedef void (*VOIDFUNC)();
-#endif
+static VALUE module;
+
+void glu_init_enums(VALUE);
 
-#if defined(GLU_VERSION_1_2)
 typedef GLUtesselator tesselatorObj;
-#else /* GLU_VERSION_1_2 */
-typedef GLUtriangulatorObj tesselatorObj;
-#endif /* !GLU_VERSION_1_2 */
 
-#ifdef MESA
+/* pointers passed to gluNurbsCurve/Surface etc.,
+  - some implementations (Mesa) needs these to be valid
+  at EndCurve/Surface etc. call., so we store them here
+  and free them after that call */
+
 struct glu_MesaStack {
-    int len;
-    GLfloat **ptr;
+	int len;
+	GLfloat **ptr;
 };
 
 static struct glu_MesaStack gms = {0, NULL};
-#endif
 
 struct nurbsdata {
-    GLUnurbsObj *nobj;
+	GLUnurbsObj *nobj;
+	VALUE n_ref;
 };
 struct tessdata {
-    tesselatorObj *tobj;
-    VALUE t_ref;
+	tesselatorObj *tobj;
+	VALUE t_ref;
 };
 
 struct quaddata {
-    GLUquadricObj *qobj;
+	GLUquadricObj *qobj;
+	VALUE q_ref;
 };
 
 static VALUE cNurbs;
 static VALUE cTess;
 static VALUE cQuad;
 
+#define REF_LAST    15
+
 #define GetNURBS(obj, ndata) {\
-    Data_Get_Struct(obj, struct nurbsdata, ndata);\
-    if (ndata->nobj == NULL) rb_raise(rb_eRuntimeError, "Nurbs Object already deleted!");\
+	Data_Get_Struct(obj, struct nurbsdata, ndata);\
+	if (ndata->nobj == NULL) rb_raise(rb_eRuntimeError, "Nurbs Object already deleted!");\
 }
 
 #define GetTESS(obj, tdata) {\
-    Data_Get_Struct(obj, struct tessdata, tdata);\
-    if (tdata->tobj == NULL) rb_raise(rb_eRuntimeError, "Triangulator Object already deleted!");\
+	Data_Get_Struct(obj, struct tessdata, tdata);\
+	if (tdata->tobj == NULL) rb_raise(rb_eRuntimeError, "Triangulator Object already deleted!");\
 }
 
 #define GetQUAD(obj, qdata) {\
-    Data_Get_Struct(obj, struct quaddata, qdata);\
-    if (qdata->qobj == NULL) rb_raise(rb_eRuntimeError, "Quadric Object already deleted!");\
+	Data_Get_Struct(obj, struct quaddata, qdata);\
+	if (qdata->qobj == NULL) rb_raise(rb_eRuntimeError, "Quadric Object already deleted!");\
 }
 
 static ID callId;
@@ -101,119 +87,172 @@ static int
 get_curve_dim(type)
 GLenum type;
 {
-    switch(type)
-    {
-        case GL_MAP1_VERTEX_3:          return 3;
-        case GL_MAP1_VERTEX_4:          return 4;  
-        case GL_MAP1_INDEX:             return 1;
-        case GL_MAP1_COLOR_4:           return 4;
-        case GL_MAP1_NORMAL:            return 3;
-        case GL_MAP1_TEXTURE_COORD_1:   return 1;
-        case GL_MAP1_TEXTURE_COORD_2:   return 2;
-        case GL_MAP1_TEXTURE_COORD_3:   return 3;
-        case GL_MAP1_TEXTURE_COORD_4:   return 4;
-        default:  abort();  /* TODO: is this OK? */
-    }
-    return 0; /*never get here*/
+	switch(type)
+	{
+		case GL_MAP1_VERTEX_3:          return 3;
+		case GL_MAP1_VERTEX_4:          return 4;  
+		case GL_MAP1_INDEX:             return 1;
+		case GL_MAP1_COLOR_4:           return 4;
+		case GL_MAP1_NORMAL:            return 3;
+		case GL_MAP1_TEXTURE_COORD_1:   return 1;
+		case GL_MAP1_TEXTURE_COORD_2:   return 2;
+		case GL_MAP1_TEXTURE_COORD_3:   return 3;
+		case GL_MAP1_TEXTURE_COORD_4:   return 4;
+		default:
+			rb_raise(rb_eArgError,"Unknown curve type '%i'",type);
+	}
+	return 0; /* never gets here */
 }
 /* from nurbssrf.c */
 static int
 get_surface_dim(GLenum type)
 {
-    switch(type)
-    {
-        case GL_MAP2_VERTEX_3:          return 3;
-        case GL_MAP2_VERTEX_4:          return 4;
-        case GL_MAP2_INDEX:             return 1;
-        case GL_MAP2_COLOR_4:           return 4;
-        case GL_MAP2_NORMAL:            return 3;
-        case GL_MAP2_TEXTURE_COORD_1:   return 1; 
-        case GL_MAP2_TEXTURE_COORD_2:   return 2;
-        case GL_MAP2_TEXTURE_COORD_3:   return 3;
-        case GL_MAP2_TEXTURE_COORD_4:   return 4;
-        default:  abort();  /* TODO: is this OK? */
-    }
-    return 0; /*never get here*/
+	switch(type)
+	{
+		case GL_MAP2_VERTEX_3:          return 3;
+		case GL_MAP2_VERTEX_4:          return 4;
+		case GL_MAP2_INDEX:             return 1;
+		case GL_MAP2_COLOR_4:           return 4;
+		case GL_MAP2_NORMAL:            return 3;
+		case GL_MAP2_TEXTURE_COORD_1:   return 1; 
+		case GL_MAP2_TEXTURE_COORD_2:   return 2;
+		case GL_MAP2_TEXTURE_COORD_3:   return 3;
+		case GL_MAP2_TEXTURE_COORD_4:   return 4;
+		default:
+			rb_raise(rb_eArgError,"Unknown surface type '%i'",type);
+	}
+	return 0; /* never gets here */
 }
 
 /*
  * NURBS API
  */
+static VALUE n_current;
+
 static void
 free_nurbs(ndata)
 struct nurbsdata *ndata;
 {
-  if (ndata->nobj) gluDeleteNurbsRenderer(ndata->nobj);
-  ndata->nobj = NULL;
+	if (ndata->nobj) gluDeleteNurbsRenderer(ndata->nobj);
+		ndata->nobj = NULL;
+	ndata->n_ref = Qnil;
+}
+static void
+mark_nurbs(ndata)
+struct nurbsdata* ndata;
+{
+	if (ndata->nobj)
+		rb_gc_mark(ndata->n_ref);
 }
+
+static void CALLBACK
+n_error(errorno)
+GLenum errorno;
+{
+	VALUE nurbs;
+	struct nurbsdata *ndata;
+	nurbs = rb_ary_entry(n_current, -1);
+	if (nurbs == Qnil)
+		return;
+	GetNURBS(nurbs, ndata);
+	rb_funcall(rb_ary_entry(ndata->n_ref, GLU_ERROR), callId, 1, INT2NUM(errorno));
+}
+
+static VALUE
+glu_NurbsCallback(obj, arg1, arg2, arg3)
+VALUE obj, arg1, arg2, arg3;
+{
+	struct nurbsdata* ndata;
+	GLenum type;
+	GetNURBS(arg1, ndata);
+	type = (GLenum)NUM2INT(arg2);
+	if (!rb_obj_is_kind_of(arg3,rb_cProc) && !NIL_P(arg3))
+		rb_raise(rb_eTypeError, "gluNurbsCallback needs Proc Object:%s",rb_class2name(CLASS_OF(arg3)));
+
+	if (type!=GLU_ERROR)
+		return Qnil;
+
+	rb_ary_store(ndata->n_ref, type, arg3);
+	if (NIL_P(arg3))
+		gluNurbsCallback(ndata->nobj, type, NULL);
+	else
+		gluNurbsCallback(ndata->nobj, type, n_error);
+	
+	return Qnil;
+}
+
+
 static VALUE
 glu_NewNurbsRenderer(obj)
 VALUE obj;
 {
-    VALUE ret;
-    struct nurbsdata *ndata;
-    ret = Data_Make_Struct(cNurbs, struct nurbsdata, 0, free_nurbs, ndata);
-    ndata->nobj = gluNewNurbsRenderer();
-    return ret;
+	VALUE ret;
+	struct nurbsdata *ndata;
+	ret = Data_Make_Struct(cNurbs, struct nurbsdata, mark_nurbs, free_nurbs, ndata);
+	ndata->nobj = gluNewNurbsRenderer();
+	ndata->n_ref = rb_ary_new2(REF_LAST);
+	return ret;
 }
 static VALUE
 glu_DeleteNurbsRenderer(obj, arg1)
 VALUE obj, arg1;
 {
-    struct nurbsdata *ndata;
-    GetNURBS(arg1, ndata);
-    free_nurbs(ndata);
-    return Qnil;
+	struct nurbsdata *ndata;
+	GetNURBS(arg1, ndata);
+	free_nurbs(ndata);
+	return Qnil;
 }
 static VALUE
 glu_NurbsProperty(obj, arg1, arg2, arg3)
 VALUE obj, arg1, arg2, arg3;
 {
-    struct nurbsdata *ndata;
-    GLenum property;
-    GLfloat value;
-    GetNURBS(arg1, ndata);
-    property = (GLenum)NUM2INT(arg2);
-    value = (GLfloat)NUM2DBL(arg3);
-    gluNurbsProperty(ndata->nobj, property, value);
-    return Qnil;
+	struct nurbsdata *ndata;
+	GLenum property;
+	GLfloat value;
+	GetNURBS(arg1, ndata);
+	property = (GLenum)NUM2INT(arg2);
+	value = (GLfloat)NUM2DBL(arg3);
+	gluNurbsProperty(ndata->nobj, property, value);
+	return Qnil;
 }
 static VALUE
 glu_GetNurbsProperty(obj, arg1, arg2)
 VALUE obj, arg1, arg2;
 {
-    struct nurbsdata *ndata;
-    GLenum property;
-    GLfloat value;
-    GetNURBS(arg1, ndata);
-    property = (GLenum)NUM2INT(arg2);
-    gluGetNurbsProperty(ndata->nobj, property, &value);
-    return rb_float_new(value);
+	struct nurbsdata *ndata;
+	GLenum property;
+	GLfloat value;
+	GetNURBS(arg1, ndata);
+	property = (GLenum)NUM2INT(arg2);
+	gluGetNurbsProperty(ndata->nobj, property, &value);
+	return rb_float_new(value);
 }
 static VALUE
 glu_BeginCurve(obj, arg1)
 VALUE obj, arg1;
 {
-    struct nurbsdata *ndata;
-    GetNURBS(arg1, ndata);
-    gluBeginCurve(ndata->nobj);
-    return Qnil;
+	struct nurbsdata *ndata;
+	GetNURBS(arg1, ndata);
+	rb_ary_push(n_current, arg1);
+	gluBeginCurve(ndata->nobj);
+	return Qnil;
 }
 static VALUE
 glu_EndCurve(obj, arg1)
 VALUE obj, arg1;
 {
-    struct nurbsdata *ndata;
-    GetNURBS(arg1, ndata);
-    gluEndCurve(ndata->nobj);
-    /* hack for Mesa 3.1 */
-#ifdef MESA
-    for (gms.len;gms.len>0;gms.len--)
-    free(gms.ptr[gms.len-1]);
-    free(gms.ptr);
-    gms.ptr = NULL;
-#endif
-    return Qnil;
+	struct nurbsdata *ndata;
+	GetNURBS(arg1, ndata);
+	gluEndCurve(ndata->nobj);
+
+	for (;gms.len>0;gms.len--)
+		free(gms.ptr[gms.len-1]);
+	free(gms.ptr);
+	gms.ptr = NULL;
+
+	rb_ary_pop(n_current);
+
+	return Qnil;
 }
 static VALUE
 glu_NurbsCurve(argc,argv,obj)
@@ -221,96 +260,83 @@ int argc;
 VALUE *argv;
 VALUE obj;
 {
-    struct nurbsdata *ndata;
-    GLint uknot_count;
-    GLfloat *uknot;
-    GLint u_stride;
-    GLint uorder;
-    GLfloat *ctlarray;
-    GLenum type;
-
-    VALUE args[7];
-    GLfloat tmp[4];
-    int i;
-    struct RArray *ary_ctl1;
-
-    switch (rb_scan_args(argc, argv, "43", &args[0], &args[1], &args[2], &args[3], &args[4], &args[5], &args[6])) {
-        case 3:
-        uknot_count = RARRAY(rb_Array(args[1]))->len;
-        uknot = ALLOC_N(GLfloat, uknot_count);
-        ary2cflt(args[1], uknot, uknot_count);
-        ary_ctl1 = RARRAY(rb_Array(args[2]));
-        type = (GLenum)NUM2INT(args[3]);
-        u_stride = get_curve_dim(type);
-        uorder = ary_ctl1->len;
-        ctlarray = ALLOC_N(GLfloat, u_stride*uorder);
-        for (i = 0; i < ary_ctl1->len; i++) {
-        ary2cflt(ary_ctl1->ptr[i], tmp, 4);
-        memcpy(&ctlarray[i*u_stride], tmp, u_stride);
-        }
-        break;
-    case 7:
-        uknot_count = (GLint)NUM2INT(args[1]);
-        uknot = ALLOC_N(GLfloat, uknot_count);
-        ary2cflt(args[2], uknot, uknot_count);
-        u_stride = (GLint)NUM2INT(args[3]);
-        uorder = (GLint)NUM2INT(args[5]);
-            type = (GLenum)NUM2INT(args[6]);  /* ---> line was missing */
-            /* ctlarray = ALLOC_N(GLfloat, u_stride*uorder); //--->Mathematically incorrect */
-            ctlarray = ALLOC_N(GLfloat, u_stride*(uknot_count-uorder));
-        ary_ctl1 = RARRAY(rb_Array(args[4]));
-        if (TYPE(ary_ctl1->ptr[0]) == T_ARRAY)
-        for (i = 0; i < ary_ctl1->len; i++) {
-            ary2cflt(ary_ctl1->ptr[i], tmp, 4);
-            memcpy(&ctlarray[i*u_stride], tmp, u_stride);
-            }
-        else {
-                /* ary2cflt((VALUE)ary_ctl1, ctlarray, u_stride*uorder); //--->Mathematically incorrect */
-                ary2cflt((VALUE)ary_ctl1, ctlarray, (uknot_count-uorder)*u_stride);
-        }
-        break;
-    default:
-        rb_raise(rb_eArgError, "arg num:%d",argc);
-    }
-    GetNURBS(args[0], ndata);
-    gluNurbsCurve(ndata->nobj, uknot_count, uknot, u_stride, ctlarray, uorder, type);
-/*  as of Mesa 3.1, Mesa assumes all data that following pointers
-    points to is valid at gluEndCurve.  so, free them in
-    glu_EndCurve() */
-#ifdef MESA
-    gms.ptr = REALLOC_N(gms.ptr, GLfloat*, gms.len+=2);
-    gms.ptr[gms.len - 2] = uknot;
-    gms.ptr[gms.len - 1] = ctlarray;
-#else
-    free(uknot);
-    free(ctlarray);
-#endif
-    return Qnil;
+	struct nurbsdata *ndata;
+	GLint uknot_count;
+	GLfloat *uknot;
+	GLint u_stride;
+	GLint uorder;
+	GLfloat *ctlarray;
+	GLenum type;
+	
+	VALUE args[7];
+	VALUE ary_ctl1;
+	
+	switch (rb_scan_args(argc, argv, "52", &args[0], &args[1], &args[2], &args[3], &args[4], &args[5], &args[6])) {
+		case 5:
+			uknot_count = RARRAY(args[1])->len;
+			uorder = (GLenum)NUM2INT(args[3]);
+			type = (GLenum)NUM2INT(args[4]);
+			u_stride = get_curve_dim(type);
+		
+			uknot = ALLOC_N(GLfloat, uknot_count);
+			ary2cflt(args[1], uknot, uknot_count);
+
+			ary_ctl1 = rb_ary_new();
+			mary2ary(args[2], ary_ctl1); /* flatten */
+			break;
+		case 7:
+			uknot_count = (GLint)NUM2INT(args[1]);
+			u_stride = (GLint)NUM2INT(args[3]);
+			uorder = (GLint)NUM2INT(args[5]);
+			type = (GLenum)NUM2INT(args[6]);
+
+			uknot = ALLOC_N(GLfloat, uknot_count);
+			ary2cflt(args[2], uknot, uknot_count);
+
+			ary_ctl1 = rb_ary_new();
+			mary2ary(args[4], ary_ctl1); /* flatten */
+			break;
+		default:
+			rb_raise(rb_eArgError, "gluNurbsCurve needs 5 or 7 arguments",argc);
+	}
+	ctlarray = ALLOC_N(GLfloat, u_stride*(uknot_count-uorder));
+	ary2cflt((VALUE)ary_ctl1, ctlarray, (uknot_count-uorder)*u_stride);
+
+	GetNURBS(args[0], ndata);
+	gluNurbsCurve(ndata->nobj, uknot_count, uknot, u_stride, ctlarray, uorder, type);
+
+	/* store the pointers */
+	gms.ptr = REALLOC_N(gms.ptr, GLfloat*, gms.len+=2);
+	gms.ptr[gms.len - 2] = uknot;
+	gms.ptr[gms.len - 1] = ctlarray;
+	return Qnil;
 }
 static VALUE
 glu_BeginSurface(obj, arg1)
 VALUE obj, arg1;
 {
-    struct nurbsdata *ndata;
-    GetNURBS(arg1, ndata);
-    gluBeginSurface(ndata->nobj);
-    return Qnil;
+	struct nurbsdata *ndata;
+	GetNURBS(arg1, ndata);
+	rb_ary_push(n_current, arg1);
+	gluBeginSurface(ndata->nobj);
+	return Qnil;
 }
 static VALUE
 glu_EndSurface(obj, arg1)
 VALUE obj, arg1;
 {
-    struct nurbsdata *ndata;
-    GetNURBS(arg1, ndata);
-    gluEndSurface(ndata->nobj);
-    /* hack for Mesa 3.1 */
-#ifdef MESA
-    for(gms.len; gms.len>0; gms.len--)
-    free(gms.ptr[gms.len-1]);
-    free(gms.ptr);
-    gms.ptr = NULL;
-#endif
-    return Qnil;
+	struct nurbsdata *ndata;
+	GetNURBS(arg1, ndata);
+	gluEndSurface(ndata->nobj);
+	
+	for(; gms.len>0; gms.len--)
+		free(gms.ptr[gms.len-1]);
+	free(gms.ptr);
+	gms.ptr = NULL;
+
+	rb_ary_pop(n_current);
+	
+	return Qnil;
 }
 
 static VALUE
@@ -319,107 +345,102 @@ int argc;
 VALUE *argv;
 VALUE obj;
 {
-    struct nurbsdata *ndata;
-    GLint sknot_count;
-    GLfloat *sknot;
-    GLint tknot_count;
-    GLfloat *tknot;
-    GLint s_stride;
-    GLint t_stride;
-    GLfloat *ctlarray;
-    GLint sorder;
-    GLint torder;
-    GLenum type;
-    VALUE work_ary;
-
-    VALUE args[11];
-    struct RArray *ary_ctl1;
-    int type_len;
-
-    switch (rb_scan_args(argc, argv, "56", &args[0], &args[1], &args[2], &args[3], &args[4], &args[5], &args[6], &args[7], &args[8], &args[9], &args[10])) {
-    case 5:
-        sknot_count = RARRAY(rb_Array(args[1]))->len;
-        sknot = ALLOC_N(GLfloat, sknot_count);
-        ary2cflt(args[1], sknot, sknot_count);
-        tknot_count = RARRAY(rb_Array(args[2]))->len;
-        tknot = ALLOC_N(GLfloat, tknot_count);
-        ary2cflt(args[2], tknot, tknot_count);
-        ary_ctl1 = RARRAY(rb_Array(args[3]));
-        sorder = ary_ctl1->len;
-        torder = RARRAY(rb_Array(ary_ctl1->ptr[0]))->len;
-        type = (GLenum)NUM2INT(args[4]);
-        t_stride = get_surface_dim(type);
-        s_stride = t_stride * sorder;
-        ctlarray = ALLOC_N(GLfloat, t_stride*s_stride);
-        work_ary = rb_ary_new();
-        mary2ary((VALUE)ary_ctl1, work_ary);
-        ary2cflt(work_ary, ctlarray, t_stride*s_stride);
-    case 11:
-        sknot_count = (GLint)NUM2INT(args[1]);
-        sknot = ALLOC_N(GLfloat, sknot_count);
-        ary2cflt(args[2], sknot, sknot_count);
-        tknot_count = (GLint)NUM2INT(args[3]);
-        tknot = ALLOC_N(GLfloat, tknot_count);
-        ary2cflt(args[4], tknot, tknot_count);
-        s_stride = (GLint)NUM2INT(args[5]);
-        t_stride = (GLint)NUM2INT(args[6]);
-        sorder = (GLint)NUM2INT(args[8]);
-        torder = (GLint)NUM2INT(args[9]);
-        type = (GLint)NUM2INT(args[10]);
-        type_len = get_surface_dim(type);
-            /* ctlarray = ALLOC_N(GLfloat, sorder*torder*type_len); //--->Mathematically incorrect */
-            ctlarray = ALLOC_N(GLfloat, (sknot_count-sorder)*(tknot_count-torder)*type_len);
-        ary_ctl1 = RARRAY(rb_Array(args[7]));
-        if (TYPE(ary_ctl1->ptr[0]) == T_ARRAY) {
-        work_ary = rb_ary_new();
-        mary2ary((VALUE)ary_ctl1, work_ary);
-                /* ary2cflt(work_ary, ctlarray, sorder*torder*type_len); //--->Mathematically incorrect */
-                ary2cflt(work_ary, ctlarray, (sknot_count-sorder)*(tknot_count-torder)*type_len);
-        }
-        else {
-                /* ary2cflt((VALUE)ary_ctl1, ctlarray, sorder*torder*type_len); //--->Mathematically incorrect */
-                ary2cflt((VALUE)ary_ctl1, ctlarray, (sknot_count-sorder)*(tknot_count-torder)*type_len);
-        }
-            break;
-        default:
-        rb_raise(rb_eArgError, "arg num:%d",argc);
-    }
-    GetNURBS(args[0], ndata);
-    gluNurbsSurface(ndata->nobj, sknot_count, sknot, tknot_count, tknot,
-    s_stride, t_stride, ctlarray, sorder, torder, type);
-
-/*  as of Mesa 3.1, Mesa assumes all data that following pointers
-    points to is valid at gluEndSurface.  so, free them in
-    glu_EndSurface() */
-#ifdef MESA
-    gms.ptr = REALLOC_N(gms.ptr, GLfloat*, gms.len+=3);
-    gms.ptr[gms.len-3] = sknot;
-    gms.ptr[gms.len-2] = tknot;
-    gms.ptr[gms.len-1] = ctlarray;
-#else
-    free(sknot);
-    free(tknot);
-    free(ctlarray);
-#endif
-    return Qnil;
+	struct nurbsdata *ndata;
+	GLint sknot_count;
+	GLfloat *sknot;
+	GLint tknot_count;
+	GLfloat *tknot;
+	GLint s_stride;
+	GLint t_stride;
+	GLfloat *ctlarray;
+	GLint sorder;
+	GLint torder;
+	GLenum type;
+	
+	VALUE args[11];
+	VALUE ary_ctl1;
+	int type_len;
+	
+	switch (rb_scan_args(argc, argv, "74", &args[0], &args[1], &args[2], &args[3], &args[4], &args[5], &args[6], &args[7], &args[8], &args[9], &args[10])) {
+		case 7:
+			sknot_count = RARRAY(args[1])->len;
+			sknot = ALLOC_N(GLfloat, sknot_count);
+			ary2cflt(args[1], sknot, sknot_count);
+
+			tknot_count = RARRAY(args[2])->len;
+			tknot = ALLOC_N(GLfloat, tknot_count);
+			ary2cflt(args[2], tknot, tknot_count);
+
+			sorder = (GLint)NUM2INT(args[4]);
+			torder = (GLint)NUM2INT(args[5]);
+			type = (GLenum)NUM2INT(args[6]);
+
+			t_stride = get_surface_dim(type);
+			s_stride = t_stride * sorder;
+
+			ctlarray = ALLOC_N(GLfloat, (sknot_count-sorder)*(tknot_count-torder)*t_stride);
+			ary_ctl1 = rb_ary_new();
+			mary2ary(args[3], ary_ctl1); /* flatten */
+			ary2cflt(ary_ctl1, ctlarray, (sknot_count-sorder)*(tknot_count-torder)*t_stride);
+			break;
+		case 11:
+			sknot_count = (GLint)NUM2INT(args[1]);
+			sknot = ALLOC_N(GLfloat, sknot_count);
+			ary2cflt(args[2], sknot, sknot_count);
+			
+			tknot_count = (GLint)NUM2INT(args[3]);
+			tknot = ALLOC_N(GLfloat, tknot_count);
+			ary2cflt(args[4], tknot, tknot_count);
+			
+			s_stride = (GLint)NUM2INT(args[5]);
+			t_stride = (GLint)NUM2INT(args[6]);
+			sorder = (GLint)NUM2INT(args[8]);
+			torder = (GLint)NUM2INT(args[9]);
+			type = (GLint)NUM2INT(args[10]);
+			type_len = get_surface_dim(type);
+			
+			ctlarray = ALLOC_N(GLfloat, (sknot_count-sorder)*(tknot_count-torder)*type_len);
+			
+			ary_ctl1 = rb_ary_new();
+			mary2ary(args[7], ary_ctl1); /* flatten */
+			ary2cflt(ary_ctl1, ctlarray, (sknot_count-sorder)*(tknot_count-torder)*type_len);
+			break;
+		default:
+			rb_raise(rb_eArgError, "gluNurbsSurface needs 7 or 11 arguments",argc);
+			return Qnil; /* not reached */
+	}
+	GetNURBS(args[0], ndata);
+	gluNurbsSurface(ndata->nobj, sknot_count, sknot, tknot_count, tknot,
+	s_stride, t_stride, ctlarray, sorder, torder, type);
+	
+	/* store the pointers */
+	
+	gms.ptr = REALLOC_N(gms.ptr, GLfloat*, gms.len+=3);
+	gms.ptr[gms.len-3] = sknot;
+	gms.ptr[gms.len-2] = tknot;
+	gms.ptr[gms.len-1] = ctlarray;
+	
+	return Qnil;
 }
 static VALUE
 glu_BeginTrim(obj, arg1)
 VALUE obj, arg1;
 {
-    struct nurbsdata *ndata;
-    GetNURBS(arg1, ndata);
-    gluBeginTrim(ndata->nobj);
-    return Qnil;
+	struct nurbsdata *ndata;
+	GetNURBS(arg1, ndata);
+	rb_ary_push(n_current, arg1);
+	gluBeginTrim(ndata->nobj);
+	return Qnil;
 }
 static VALUE
 glu_EndTrim(obj, arg1)
 VALUE obj, arg1;
 {
-    struct nurbsdata *ndata;
-    GetNURBS(arg1, ndata);
-    gluEndTrim(ndata->nobj);
-    return Qnil;
+	struct nurbsdata *ndata;
+	GetNURBS(arg1, ndata);
+	gluEndTrim(ndata->nobj);
+	rb_ary_pop(n_current);
+	return Qnil;
 }
 static VALUE
 glu_PwlCurve(argc, argv, obj)
@@ -427,50 +448,63 @@ int argc;
 VALUE *argv;
 VALUE obj;
 {
-    struct nurbsdata *ndata;
-    GLint count;
-    GLfloat *array;
-    GLint stride;
-    GLenum type;
-
-    VALUE args[5];
-    GLfloat tmp[3];
-    struct RArray* ary_ctl1;
-    int i;
-
-    switch (rb_scan_args(argc, argv, "32", &args[0], &args[1], &args[2], &args[3], &args[4])) {
-    case 3:
-        ary_ctl1 = RARRAY(rb_Array(args[2]));
-        count = ary_ctl1->len;
-        type = NUM2INT(args[2]);
-        stride = (type == GLU_MAP1_TRIM_2 ? 2 : 3);
-        array = ALLOC_N(GLfloat, count*stride);
-        for (i = 0; i < ary_ctl1->len; i++) {
-        ary2cflt(ary_ctl1->ptr[i], tmp, 3);
-        memcpy(&array[i*stride], tmp, stride);
-        }
-        break;
-    case 5:
-        count = NUM2INT(args[1]);
-        stride = NUM2INT(args[3]);
-        type = NUM2INT(args[4]);
-        array = ALLOC_N(GLfloat, count*stride);
-        ary_ctl1 = RARRAY(rb_Array(args[2]));
-        if (TYPE(ary_ctl1->ptr[0]) == T_ARRAY)
-        for (i = 0; i < ary_ctl1->len; i++) {
-            ary2cflt(ary_ctl1->ptr[i], tmp, 3);
-            memcpy(&array[i*stride], tmp, stride);
-            }
-        else
-        ary2cflt((VALUE)ary_ctl1, array, count*stride);
-        break;
-    default:
-        rb_raise(rb_eArgError, "arg num:%d",argc);
-    }
-    GetNURBS(args[0], ndata);
-    gluPwlCurve(ndata->nobj, count, array, stride, type);
-    free(array);
-    return Qnil;
+	struct nurbsdata *ndata;
+	GLint count;
+	GLfloat *array;
+	GLint stride;
+	GLenum type;
+	
+	VALUE args[5];
+	VALUE ary_ctl1;
+	
+	switch (rb_scan_args(argc, argv, "32", &args[0], &args[1], &args[2], &args[3], &args[4])) {
+		case 3:
+			count = RARRAY(args[1])->len;
+			type = NUM2INT(args[2]);
+			stride = (type == GLU_MAP1_TRIM_2 ? 2 : 3);
+
+			array = ALLOC_N(GLfloat, count*stride);
+			ary_ctl1 = rb_ary_new();
+			mary2ary(args[1], ary_ctl1); /* flatten */
+			ary2cflt(ary_ctl1, array, count*stride);
+			break;
+		case 5:
+			count = NUM2INT(args[1]);
+			stride = NUM2INT(args[3]);
+			type = NUM2INT(args[4]);
+
+			array = ALLOC_N(GLfloat, count*stride);
+			ary_ctl1 = rb_ary_new();
+			mary2ary(args[2], ary_ctl1); /* flatten */
+			ary2cflt(ary_ctl1, array, count*stride);
+			break;
+		default:
+			rb_raise(rb_eArgError, "gluPwlCurve needs 3 or 5 arguments",argc);
+			return Qnil; /* not reached */
+	}
+
+	GetNURBS(args[0], ndata);
+	gluPwlCurve(ndata->nobj, count, array, stride, type);
+	free(array);
+	return Qnil;
+}
+
+static VALUE glu_LoadSamplingMatrices(obj,arg1,arg2,arg3,arg4)
+VALUE obj, arg1,arg2,arg3,arg4;
+{
+	struct nurbsdata *ndata;
+	GLfloat mdl_mtx[4*4];
+	GLfloat persp_mtx[4*4];
+	GLint viewport[4];
+
+	GetNURBS(arg1, ndata);
+	ary2cmat4x4flt(arg2,mdl_mtx);
+	ary2cmat4x4flt(arg3,persp_mtx);
+	ary2cint(arg4,viewport,4);
+
+	gluLoadSamplingMatrices(ndata->nobj,mdl_mtx,persp_mtx,viewport);
+
+	return Qnil;
 }
 
 /*
@@ -482,214 +516,162 @@ static VALUE t_current;
 #define TESS_VERTEX 2
 #define TESS_END    3
 #define TESS_ERROR  4
-#define TESS_EDGE   5
-#if defined(GLU_VERSION_1_2)
-#  define TESS_OUTDATA     6
-#  define TESS_COMBINE     7
-#  define TESS_BEGIN_DATA  8
-#  define TESS_VERTEX_DATA 9
-#  define TESS_END_DATA    10
-#  define TESS_ERROR_DATA  11
-#  define TESS_EDGE_DATA   12
-#  define TESS_COMBINE_DATA    13
-#  define TESS_USERDATA   14
-#  define REF_LAST    15
-#else /* !GLU_VERSION_1_2 */
-#  define REF_LAST    6
-#endif /* GLU_VERSION_1_2 */
+#define TESS_EDGE_FLAG   5
+#define TESS_OUTDATA     6
+#define TESS_COMBINE     7
+#define TESS_BEGIN_DATA  8
+#define TESS_VERTEX_DATA 9
+#define TESS_END_DATA    10
+#define TESS_ERROR_DATA  11
+#define TESS_EDGE_FLAG_DATA   12
+#define TESS_COMBINE_DATA    13
+#define TESS_USERDATA   14
+
 static void
 mark_tess(tdata)
 struct tessdata* tdata;
 {
-    if (tdata->tobj)
-        rb_gc_mark(tdata->t_ref);
+	if (tdata->tobj)
+		rb_gc_mark(tdata->t_ref);
 }
 static void
 free_tess(tdata)
 struct tessdata *tdata;
 {
-    ID id;
-    VALUE call_key;
-
-    if (tdata->tobj) {
-    gluDeleteTess(tdata->tobj);
-    }
-    tdata->t_ref = Qnil;
-    tdata->tobj = NULL;
+	if (tdata->tobj)
+		gluDeleteTess(tdata->tobj);
+	tdata->t_ref = Qnil;
+	tdata->tobj = NULL;
 }
 static VALUE
 glu_NewTess(obj)
 VALUE obj;
 {
-    VALUE ret;
-    struct tessdata *tdata;
-    ret = Data_Make_Struct(cTess, struct tessdata, mark_tess, free_tess, tdata);
-    tdata->tobj = gluNewTess();
-    tdata->t_ref = rb_ary_new2(REF_LAST);
-    return ret;
+	VALUE ret;
+	struct tessdata *tdata;
+	ret = Data_Make_Struct(cTess, struct tessdata, mark_tess, free_tess, tdata);
+	tdata->tobj = gluNewTess();
+	tdata->t_ref = rb_ary_new2(REF_LAST);
+	return ret;
 }
 static VALUE
 glu_DeleteTess(obj, arg1)
 VALUE obj, arg1;
 {
-    struct tessdata *tdata;
-    GetTESS(arg1, tdata);
-    free_tess(tdata);
-    return Qnil;
+	struct tessdata *tdata;
+	GetTESS(arg1, tdata);
+	free_tess(tdata);
+	return Qnil;
 }
-void
+
+/* tess* callback function wrappers */
+#define TESS_CALLBACK_COMMON \
+VALUE tess; \
+struct tessdata *tdata; \
+tess = rb_ary_entry(t_current, -1); \
+if (tess == Qnil) \
+	return; \
+GetTESS(tess, tdata);
+
+static void CALLBACK
 t_begin(type)
 GLenum type;
 {
-    VALUE tess;
-    struct tessdata *tdata;
-    tess = rb_ary_entry(t_current, -1);
-    if (tess != Qnil) {
-        GetTESS(tess, tdata);
-        rb_funcall(rb_ary_entry(tdata->t_ref, TESS_BEGIN), callId, 1, INT2NUM(type));
-    }
+	TESS_CALLBACK_COMMON
+	rb_funcall(rb_ary_entry(tdata->t_ref, TESS_BEGIN), callId, 1, INT2NUM(type));
 }
-static void
+static void CALLBACK
 t_edgeFlag(flag)
 GLboolean flag;
 {
-    VALUE tess;
-    struct tessdata *tdata;
-    tess = rb_ary_entry(t_current, -1);
-    if (tess != Qnil) {
-        GetTESS(tess, tdata);
-        rb_funcall(rb_ary_entry(tdata->t_ref, TESS_EDGE), callId, 1, INT2NUM(flag));
-    }
+	TESS_CALLBACK_COMMON
+	rb_funcall(rb_ary_entry(tdata->t_ref, TESS_EDGE_FLAG), callId, 1, INT2NUM(flag));
 }
-static void
+static void CALLBACK
 t_vertex(data)
 void* data;
 {
-    VALUE tess;
-    struct tessdata *tdata;
-    tess = rb_ary_entry(t_current, -1);
-    if (tess != Qnil) {
-        GetTESS(tess, tdata);
-        rb_funcall(rb_ary_entry(tdata->t_ref, TESS_VERTEX), callId, 1, data);
-    }
+	TESS_CALLBACK_COMMON
+	rb_funcall(rb_ary_entry(tdata->t_ref, TESS_VERTEX), callId, 1, data);
 }
-static void
+static void CALLBACK
 t_end()
 {
-    VALUE tess;
-    struct tessdata *tdata;
-    tess = rb_ary_entry(t_current, -1);
-    if (tess != Qnil) {
-        GetTESS(tess, tdata);
-        rb_funcall(rb_ary_entry(tdata->t_ref, TESS_END), callId, 0);
-    }
+	TESS_CALLBACK_COMMON
+	rb_funcall(rb_ary_entry(tdata->t_ref, TESS_END), callId, 0);
 }
-static void
+static void CALLBACK
 t_error(errorno)
 GLenum errorno;
 {
-    VALUE tess;
-    struct tessdata *tdata;
-    tess = rb_ary_entry(t_current, -1);
-    if (tess != Qnil) {
-        GetTESS(tess, tdata);
-        rb_funcall(rb_ary_entry(tdata->t_ref, TESS_ERROR), callId, 1, INT2NUM(errorno));
-    }
+	TESS_CALLBACK_COMMON
+	rb_funcall(rb_ary_entry(tdata->t_ref, TESS_ERROR), callId, 1, INT2NUM(errorno));
 }
-
-#if defined(GLU_VERSION_1_2)
-static void
+static void CALLBACK
 t_begin_data(type, user_data)
 GLenum type;
 void* user_data;
 {
-    VALUE tess;
-    struct tessdata *tdata;
-    tess = rb_ary_entry(t_current, -1);
-    if (tess != Qnil) {
-        GetTESS(tess, tdata);
-        rb_funcall(rb_ary_entry(tdata->t_ref, TESS_BEGIN_DATA), callId, 2, INT2NUM(type), user_data);
-    }
+	TESS_CALLBACK_COMMON
+	rb_funcall(rb_ary_entry(tdata->t_ref, TESS_BEGIN_DATA), callId, 2, INT2NUM(type), user_data);
 }
-static void
+static void CALLBACK
 t_edgeFlag_data(flag, user_data)
 GLboolean flag;
 void* user_data;
 {
-    VALUE tess;
-    struct tessdata *tdata;
-    tess = rb_ary_entry(t_current, -1);
-    if (tess != Qnil) {
-        GetTESS(tess, tdata);
-        rb_funcall(rb_ary_entry(tdata->t_ref, TESS_EDGE_DATA), callId, 2, INT2NUM(flag), user_data);
-    }
+	TESS_CALLBACK_COMMON
+	rb_funcall(rb_ary_entry(tdata->t_ref, TESS_EDGE_FLAG_DATA), callId, 2, INT2NUM(flag), user_data);
 }
-static void
+static void CALLBACK
 t_vertex_data(data, user_data)
 void* data;
 void* user_data;
 {
-    VALUE tess;
-    struct tessdata *tdata;
-    tess = rb_ary_entry(t_current, -1);
-    if (tess != Qnil) {
-        GetTESS(tess, tdata);
-        rb_funcall(rb_ary_entry(tdata->t_ref, TESS_VERTEX_DATA), callId, 2, data, user_data);
-    }
+	TESS_CALLBACK_COMMON
+	rb_funcall(rb_ary_entry(tdata->t_ref, TESS_VERTEX_DATA), callId, 2, data, user_data);
 }
-static void
+static void CALLBACK
 t_end_data(user_data)
 void* user_data;
 {
-    VALUE tess;
-    struct tessdata *tdata;
-    tess = rb_ary_entry(t_current, -1);
-    if (tess != Qnil) {
-        GetTESS(tess, tdata);
-        rb_funcall(rb_ary_entry(tdata->t_ref, TESS_END_DATA), callId, 1, user_data);
-    }
+	TESS_CALLBACK_COMMON
+	rb_funcall(rb_ary_entry(tdata->t_ref, TESS_END_DATA), callId, 1, user_data);
 }
-static void
+static void CALLBACK
 t_error_data(errorno, user_data)
 GLenum errorno;
 void* user_data;
 {
-    VALUE tess;
-    struct tessdata *tdata;
-    tess = rb_ary_entry(t_current, -1);
-    if (tess != Qnil) {
-        GetTESS(tess, tdata);
-        rb_funcall(rb_ary_entry(tdata->t_ref, TESS_ERROR_DATA), callId, 2, INT2NUM(errorno), user_data);
-    }
+	TESS_CALLBACK_COMMON
+	rb_funcall(rb_ary_entry(tdata->t_ref, TESS_ERROR_DATA), callId, 2, INT2NUM(errorno), user_data);
 }
-static void
+
+static void CALLBACK
 t_combine(coords, vertex_data, weight, outData)
 GLdouble coords[3];
 void* vertex_data[4];
 GLfloat weight[4];
 void** outData;
 {
-    VALUE tess;
-    struct tessdata *tdata;
-    VALUE rb_coord, rb_vertex_data, rb_weight;
-    int i;
-    tess = rb_ary_entry(t_current, -1);
-    if (tess != Qnil) {
-        GetTESS(tess, tdata);
-        rb_coord = rb_ary_new2(3);
-        for (i = 0; i < 3; i++)
-            rb_ary_store(rb_coord, i, rb_float_new(coords[i]));
-        rb_vertex_data = rb_ary_new2(4);
-        for (i = 0; i < 4; i++)
-            rb_ary_store(rb_vertex_data, i, (VALUE)vertex_data[i]);
-        rb_weight = rb_ary_new2(4);
-        for (i = 0; i < 4; i++)
-            rb_ary_store(rb_weight, i, rb_float_new(weight[i]));
-        *outData = (void*)rb_funcall(rb_ary_entry(tdata->t_ref, TESS_COMBINE), callId, 3, rb_coord, rb_vertex_data, rb_weight);
-        rb_ary_push(rb_ary_entry(tdata->t_ref, TESS_OUTDATA), (VALUE)*outData);
-    }
+	VALUE rb_coord, rb_vertex_data, rb_weight;
+	int i;
+	TESS_CALLBACK_COMMON
+
+	rb_coord = rb_ary_new2(3);
+	for (i = 0; i < 3; i++)
+			rb_ary_store(rb_coord, i, rb_float_new(coords[i]));
+	rb_vertex_data = rb_ary_new2(4);
+	for (i = 0; i < 4; i++)
+			rb_ary_store(rb_vertex_data, i, (VALUE)vertex_data[i]);
+	rb_weight = rb_ary_new2(4);
+	for (i = 0; i < 4; i++)
+			rb_ary_store(rb_weight, i, rb_float_new(weight[i]));
+	*outData = (void*)rb_funcall(rb_ary_entry(tdata->t_ref, TESS_COMBINE), callId, 3, rb_coord, rb_vertex_data, rb_weight);
+	rb_ary_push(rb_ary_entry(tdata->t_ref, TESS_OUTDATA), (VALUE)*outData);
 }
-static void
+
+static void CALLBACK
 t_combine_data(coords, vertex_data, weight, outData, user_data)
 GLdouble coords[3];
 void* vertex_data[4];
@@ -697,487 +679,460 @@ GLfloat weight[4];
 void** outData;
 void* user_data;
 {
-    VALUE tess;
-    struct tessdata *tdata;
-    VALUE rb_coord, rb_vertex_data, rb_weight;
-    int i;
-    tess = rb_ary_entry(t_current, -1);
-    if (tess != Qnil) {
-        GetTESS(tess, tdata);
-        rb_coord = rb_ary_new2(3);
-        for (i = 0; i < 3; i++)
-            rb_ary_store(rb_coord, i, rb_float_new(coords[i]));
-        rb_vertex_data = rb_ary_new2(4);
-        for (i = 0; i < 4; i++)
-            rb_ary_store(rb_vertex_data, i, (VALUE)vertex_data[i]);
-        rb_weight = rb_ary_new2(4);
-        for (i = 0; i < 4; i++)
-            rb_ary_store(rb_weight, i, rb_float_new(weight[i]));
-        *outData = (void*)rb_funcall(rb_ary_entry(tdata->t_ref, TESS_COMBINE_DATA), callId, 4, rb_coord, rb_vertex_data, rb_weight, (VALUE)user_data);
-        rb_ary_push(rb_ary_entry(tdata->t_ref, TESS_OUTDATA), (VALUE)*outData);
-    }
+	VALUE rb_coord, rb_vertex_data, rb_weight;
+	int i;
+	TESS_CALLBACK_COMMON
+	
+	rb_coord = rb_ary_new2(3);
+	for (i = 0; i < 3; i++)
+		rb_ary_store(rb_coord, i, rb_float_new(coords[i]));
+	rb_vertex_data = rb_ary_new2(4);
+	for (i = 0; i < 4; i++)
+		rb_ary_store(rb_vertex_data, i, (VALUE)vertex_data[i]);
+	rb_weight = rb_ary_new2(4);
+	for (i = 0; i < 4; i++)
+		rb_ary_store(rb_weight, i, rb_float_new(weight[i]));
+
+	*outData = (void*)rb_funcall(rb_ary_entry(tdata->t_ref, TESS_COMBINE_DATA), callId, 4, rb_coord, rb_vertex_data, rb_weight, (VALUE)user_data);
+
+	rb_ary_push(rb_ary_entry(tdata->t_ref, TESS_OUTDATA), (VALUE)*outData);
 }
+
+#undef TESS_CALLBACK_COMMON
+
 static VALUE
 glu_TessProperty(obj, arg1, arg2, arg3)
 VALUE obj, arg1, arg2;
 {
-    struct tessdata* tdata;
-    GLenum property;
-    GLdouble value;
-    GetTESS(arg1, tdata);
-    property = (GLenum)NUM2INT(arg2);
-    value = (GLdouble)NUM2DBL(arg3);
-    gluTessProperty(tdata->tobj, property, value);
-    return Qnil;
+	struct tessdata* tdata;
+	GLenum property;
+	GLdouble value;
+	GetTESS(arg1, tdata);
+	property = (GLenum)NUM2INT(arg2);
+	value = (GLdouble)NUM2DBL(arg3);
+	gluTessProperty(tdata->tobj, property, value);
+	return Qnil;
 }
 static VALUE
 glu_GetTessProperty(obj, arg1, arg2)
 VALUE obj, arg1, arg2;
 {
-    struct tessdata* tdata;
-    GLenum property;
-    GLdouble value;
-    GetTESS(arg1, tdata);
-    property = (GLenum)NUM2INT(arg2);
-    gluGetTessProperty(tdata->tobj, property, &value);
-    return rb_float_new(value);
+	struct tessdata* tdata;
+	GLenum property;
+	GLdouble value;
+	GetTESS(arg1, tdata);
+	property = (GLenum)NUM2INT(arg2);
+	gluGetTessProperty(tdata->tobj, property, &value);
+	return rb_float_new(value);
 }
 static VALUE
 glu_TessNormal(obj, arg1, arg2, arg3, arg4)
 VALUE obj, arg1, arg2, arg3, arg4;
 {
-    struct tessdata* tdata;
-    GLdouble x, y, z;
-    GetTESS(arg1, tdata);
-    x = (GLdouble)NUM2DBL(arg2);
-    y = (GLdouble)NUM2DBL(arg3);
-    z = (GLdouble)NUM2DBL(arg4);
-    gluTessNormal(tdata->tobj, x, y, z);
-    return Qnil;
+	struct tessdata* tdata;
+	GLdouble x, y, z;
+	GetTESS(arg1, tdata);
+	x = (GLdouble)NUM2DBL(arg2);
+	y = (GLdouble)NUM2DBL(arg3);
+	z = (GLdouble)NUM2DBL(arg4);
+	gluTessNormal(tdata->tobj, x, y, z);
+	return Qnil;
 }
 static VALUE
 glu_TessBeginPolygon(obj, arg1, arg2)
 VALUE obj, arg1, arg2;
 {
-    struct tessdata* tdata;
-    GetTESS(arg1, tdata);
-    rb_ary_store(tdata->t_ref, TESS_USERDATA, arg2);
-    rb_ary_store(tdata->t_ref, TESS_OUTDATA, rb_ary_new());
-    rb_ary_store(tdata->t_ref, TESS_DATA, rb_ary_new());
-    rb_ary_push(t_current, arg1);
-    gluTessBeginPolygon(tdata->tobj, (void*)arg2);
-    return Qnil;
+	struct tessdata* tdata;
+	GetTESS(arg1, tdata);
+	rb_ary_store(tdata->t_ref, TESS_USERDATA, arg2);
+	rb_ary_store(tdata->t_ref, TESS_OUTDATA, rb_ary_new());
+	rb_ary_store(tdata->t_ref, TESS_DATA, rb_ary_new());
+	rb_ary_push(t_current, arg1);
+	gluTessBeginPolygon(tdata->tobj, (void*)arg2);
+	return Qnil;
 }
 static VALUE
 glu_TessEndPolygon(obj, arg1)
 VALUE obj, arg1;
 {
-    struct tessdata* tdata;
-    GetTESS(arg1, tdata);
-    gluTessEndPolygon(tdata->tobj);
-    rb_ary_store(tdata->t_ref, TESS_USERDATA, Qnil);
-    rb_ary_store(tdata->t_ref, TESS_OUTDATA, Qnil);
-    rb_ary_store(tdata->t_ref, TESS_DATA, Qnil);
-    rb_ary_pop(t_current);
-    return Qnil;
+	struct tessdata* tdata;
+	GetTESS(arg1, tdata);
+	gluTessEndPolygon(tdata->tobj);
+	rb_ary_store(tdata->t_ref, TESS_USERDATA, Qnil);
+	rb_ary_store(tdata->t_ref, TESS_OUTDATA, Qnil);
+	rb_ary_store(tdata->t_ref, TESS_DATA, Qnil);
+	rb_ary_pop(t_current);
+	return Qnil;
 }
 static VALUE
 glu_TessBeginContour(obj, arg1)
 VALUE obj, arg1;
 {
-    struct tessdata* tdata;
-    GetTESS(arg1, tdata);
-    gluTessBeginContour(tdata->tobj);
-    return Qnil;
+	struct tessdata* tdata;
+	GetTESS(arg1, tdata);
+	gluTessBeginContour(tdata->tobj);
+	return Qnil;
 }
 static VALUE
 glu_TessEndContour(obj, arg1)
 {
-    struct tessdata* tdata;
-    GetTESS(arg1, tdata);
-    gluTessEndContour(tdata->tobj);
-    return Qnil;
+	struct tessdata* tdata;
+	GetTESS(arg1, tdata);
+	gluTessEndContour(tdata->tobj);
+	return Qnil;
 }
-#endif /* GLU_VERSION_1_2 */
+
+#define TESS_CALLBACK_CASE(_type_,_function_) \
+    case GLU_##_type_: \
+            rb_ary_store(tdata->t_ref, _type_, arg3); \
+            if (NIL_P(arg3)) \
+                gluTessCallback(tdata->tobj, type, NULL); \
+            else \
+                gluTessCallback(tdata->tobj, type, _function_); \
+        break;
 
 static VALUE
 glu_TessCallback(obj, arg1, arg2, arg3)
 VALUE obj, arg1, arg2, arg3;
 {
-    struct tessdata* tdata;
-    GLenum type;
-    ID id;
-    GetTESS(arg1, tdata);
-    type = (GLenum)NUM2INT(arg2);
-    id = rb_intern("[]=");
-    if (!rb_obj_is_kind_of(arg3,rb_cProc) && NIL_P(arg3))
-     rb_raise(rb_eTypeError, "GLU.TessCallback needs Proc Object:%s",rb_class2name(CLASS_OF(arg3)));
-    
-    switch (type) {
-#if defined(GLU_VERSION_1_2)
-    case GLU_TESS_BEGIN:
-#else
-    case GLU_BEGIN:
-#endif
-            rb_ary_store(tdata->t_ref, TESS_BEGIN, arg3);
-            if (NIL_P(arg3))
-                gluTessCallback(tdata->tobj, type, NULL);
-            else
-                gluTessCallback(tdata->tobj, type, (VOIDFUNC)(t_begin));
-        break;
-#if defined(GLU_VERSION_1_2)
-    case GLU_TESS_EDGE_FLAG:
-#else
-    case GLU_EDGE_FLAG:
-#endif
-            rb_ary_store(tdata->t_ref, TESS_EDGE, arg3);
-            if (NIL_P(arg3))
-                gluTessCallback(tdata->tobj, type, NULL);
-            else
-                gluTessCallback(tdata->tobj, type, (VOIDFUNC)t_edgeFlag);
-        break;
-#if defined(GLU_VERSION_1_2)
-    case GLU_TESS_VERTEX:
-#else
-    case GLU_VERTEX:
-#endif
-            rb_ary_store(tdata->t_ref, TESS_VERTEX, arg3);
-            if (NIL_P(arg3))
-                gluTessCallback(tdata->tobj, type, NULL);
-            else
-                gluTessCallback(tdata->tobj, type, (VOIDFUNC)t_vertex);
-        break;
-#if defined(GLU_VERSION_1_2)
-    case GLU_TESS_END:
-#else
-    case GLU_END:
-#endif
-            rb_ary_store(tdata->t_ref, TESS_END, arg3);
-            if (NIL_P(arg3))
-                gluTessCallback(tdata->tobj, type, NULL);
-            else
-                gluTessCallback(tdata->tobj, type, (VOIDFUNC)t_end);
-        break;
-#if defined(GLU_VERSION_1_2)
-    case GLU_TESS_ERROR:
-#else
-    case GLU_ERROR:
-#endif
-            rb_ary_store(tdata->t_ref, TESS_ERROR, arg3);
-            if (NIL_P(arg3))
-                gluTessCallback(tdata->tobj, type, NULL);
-            else
-                gluTessCallback(tdata->tobj, type, (VOIDFUNC)t_error);
-        break;
-#if defined(GLU_VERSION_1_2)
-        case GLU_TESS_COMBINE:
-            rb_ary_store(tdata->t_ref, TESS_COMBINE, arg3);
-            if (NIL_P(arg3))
-                gluTessCallback(tdata->tobj, type, NULL);
-            else
-                gluTessCallback(tdata->tobj, type, (VOIDFUNC)(t_combine));
-            break;
-        case GLU_TESS_BEGIN_DATA:
-            rb_ary_store(tdata->t_ref, TESS_BEGIN_DATA, arg3);
-            if (NIL_P(arg3))
-                gluTessCallback(tdata->tobj, type, NULL);
-            else
-                gluTessCallback(tdata->tobj, type, (VOIDFUNC)(t_begin_data));
-            break;
-        case GLU_TESS_VERTEX_DATA:
-            rb_ary_store(tdata->t_ref, TESS_VERTEX_DATA, arg3);
-            if (NIL_P(arg3))
-                gluTessCallback(tdata->tobj, type, NULL);
-            else
-                gluTessCallback(tdata->tobj, type, (VOIDFUNC)(t_vertex_data));
-            break;
-        case GLU_TESS_END_DATA:
-            rb_ary_store(tdata->t_ref, TESS_END_DATA, arg3);
-            if (NIL_P(arg3))
-                gluTessCallback(tdata->tobj, type, NULL);
-            else
-                gluTessCallback(tdata->tobj, type, (VOIDFUNC)(t_end_data));
-            break;
-        case GLU_TESS_ERROR_DATA:
-            rb_ary_store(tdata->t_ref, TESS_ERROR_DATA, arg3);
-            if (NIL_P(arg3))
-                gluTessCallback(tdata->tobj, type, NULL);
-            else
-                gluTessCallback(tdata->tobj, type, (VOIDFUNC)(t_error_data));
-            break;
-        case GLU_TESS_EDGE_FLAG_DATA:
-            rb_ary_store(tdata->t_ref, TESS_EDGE_DATA, arg3);
-            if (NIL_P(arg3))
-                gluTessCallback(tdata->tobj, type, NULL);
-            else
-                gluTessCallback(tdata->tobj, type, (VOIDFUNC)(t_edgeFlag_data));
-            break;
-        case GLU_TESS_COMBINE_DATA:
-            rb_ary_store(tdata->t_ref, TESS_COMBINE_DATA, arg3);
-            if (NIL_P(arg3))
-                gluTessCallback(tdata->tobj, type, NULL);
-            else
-                gluTessCallback(tdata->tobj, type, (VOIDFUNC)(t_combine_data));
-            break;
-#endif /* GLU_VERSION_1_2 */
-    }
-    return Qnil;
-}
+	struct tessdata* tdata;
+	GLenum type;
+	GetTESS(arg1, tdata);
+	type = (GLenum)NUM2INT(arg2);
+	if (!rb_obj_is_kind_of(arg3,rb_cProc) && !NIL_P(arg3))
+		rb_raise(rb_eTypeError, "gluTessCallback needs Proc Object:%s",rb_class2name(CLASS_OF(arg3)));
+	
+	switch (type) {
+		TESS_CALLBACK_CASE(TESS_BEGIN,t_begin)
+		TESS_CALLBACK_CASE(TESS_BEGIN_DATA,t_begin_data)
+		TESS_CALLBACK_CASE(TESS_EDGE_FLAG,t_edgeFlag)
+		TESS_CALLBACK_CASE(TESS_EDGE_FLAG_DATA,t_edgeFlag_data)
+		TESS_CALLBACK_CASE(TESS_VERTEX,t_vertex)
+		TESS_CALLBACK_CASE(TESS_VERTEX_DATA,t_vertex_data)
+		TESS_CALLBACK_CASE(TESS_END,t_end)
+		TESS_CALLBACK_CASE(TESS_END_DATA,t_end_data)
+		TESS_CALLBACK_CASE(TESS_ERROR,t_error)
+		TESS_CALLBACK_CASE(TESS_ERROR_DATA,t_error_data)
+		TESS_CALLBACK_CASE(TESS_COMBINE,t_combine)
+		TESS_CALLBACK_CASE(TESS_COMBINE_DATA,t_combine_data)
+	}
+	return Qnil;
+}
+#undef TESS_CALLBACK_CASE
+
 static VALUE
 glu_BeginPolygon(obj, arg1)
 VALUE obj, arg1;
 {
-    struct tessdata* tdata;
-    GetTESS(arg1, tdata);
-    rb_ary_store(tdata->t_ref, TESS_DATA, rb_ary_new());
-    rb_ary_push(t_current, arg1);
-    gluBeginPolygon(tdata->tobj);
-    return Qnil;
+	struct tessdata* tdata;
+	GetTESS(arg1, tdata);
+	rb_ary_store(tdata->t_ref, TESS_DATA, rb_ary_new());
+	rb_ary_push(t_current, arg1);
+	gluBeginPolygon(tdata->tobj);
+	return Qnil;
 }
 static VALUE
 glu_TessVertex(obj, arg1, arg2, arg3)
 VALUE obj, arg1, arg2, arg3;
 {
-    struct tessdata* tdata;
-    GLdouble v[3];
-    VALUE call_key;
-    ID id;
-    GetTESS(arg1, tdata);
-    rb_ary_push(rb_ary_entry(tdata->t_ref, TESS_DATA), arg3);
-    ary2cdbl(arg2, v, 3);
-    gluTessVertex(tdata->tobj, v,(void *)arg3);
-    return Qnil;
+	struct tessdata* tdata;
+	GLdouble v[3] = {0.0,0.0,0.0};
+	GetTESS(arg1, tdata);
+	rb_ary_push(rb_ary_entry(tdata->t_ref, TESS_DATA), arg3);
+	Check_Type(arg2,T_ARRAY);
+	ary2cdbl(arg2, v, 3);
+	gluTessVertex(tdata->tobj, v,(void *)arg3);
+	return Qnil;
 }
 static VALUE
 glu_NextContour(obj, arg1, arg2)
 VALUE obj, arg1, arg2;
 {
-    struct tessdata* tdata;
-    GLenum type;
-    GetTESS(arg1, tdata);
-    type = (GLenum)NUM2INT(arg2);
-    gluNextContour(tdata->tobj, type);
-    return Qnil;
+	struct tessdata* tdata;
+	GLenum type;
+	GetTESS(arg1, tdata);
+	type = (GLenum)NUM2INT(arg2);
+	gluNextContour(tdata->tobj, type);
+	return Qnil;
 }
 static VALUE
 glu_EndPolygon(obj, arg1)
 VALUE obj, arg1;
 {
-    struct tessdata* tdata;
-    GetTESS(arg1, tdata);
-    gluEndPolygon(tdata->tobj);
-    rb_ary_store(tdata->t_ref, TESS_DATA, Qnil);
-    rb_ary_pop(t_current);
-    return Qnil;
+	struct tessdata* tdata;
+	GetTESS(arg1, tdata);
+	gluEndPolygon(tdata->tobj);
+	rb_ary_store(tdata->t_ref, TESS_DATA, Qnil);
+	rb_ary_pop(t_current);
+	return Qnil;
 }
 
 /*
  * Quadric API
  */
+static VALUE q_current;
+
+static void CALLBACK
+q_error(errorno)
+GLenum errorno;
+{
+	VALUE quad;
+	struct quaddata *qdata;
+	quad = rb_ary_entry(q_current, -1);
+	if (quad == Qnil)
+		return;
+	GetQUAD(quad, qdata);
+	rb_funcall(rb_ary_entry(qdata->q_ref, GLU_ERROR), callId, 1, INT2NUM(errorno));
+}
+
+static VALUE
+glu_QuadricCallback(obj, arg1, arg2, arg3)
+VALUE obj, arg1, arg2, arg3;
+{
+	struct quaddata* qdata;
+	GLenum type;
+	GetQUAD(arg1, qdata);
+	type = (GLenum)NUM2INT(arg2);
+	if (!rb_obj_is_kind_of(arg3,rb_cProc) && !NIL_P(arg3))
+		rb_raise(rb_eTypeError, "gluQuadricCallback needs Proc Object:%s",rb_class2name(CLASS_OF(arg3)));
+
+	if (type!=GLU_ERROR)
+		return Qnil;
+
+	rb_ary_store(qdata->q_ref, type, arg3);
+	if (NIL_P(arg3))
+		gluQuadricCallback(qdata->qobj, type, NULL);
+	else
+		gluQuadricCallback(qdata->qobj, type, q_error);
+	
+	return Qnil;
+}
+
 static void
 free_quad(qdata)
 struct quaddata *qdata;
 {
   if (qdata->qobj) gluDeleteQuadric(qdata->qobj);
   qdata->qobj = NULL;
+	qdata->q_ref = Qnil;
+}
+static void
+mark_quad(qdata)
+struct quaddata* qdata;
+{
+	if (qdata->qobj)
+		rb_gc_mark(qdata->q_ref);
 }
 static VALUE
 glu_NewQuadric(obj)
 VALUE obj;
 {
-    VALUE ret;
-    struct quaddata *qdata;
-    ret = Data_Make_Struct(cQuad, struct quaddata, 0, free_quad, qdata);
-    qdata->qobj = gluNewQuadric();
-    return ret;
+	VALUE ret;
+	struct quaddata *qdata;
+	ret = Data_Make_Struct(cQuad, struct quaddata, mark_quad, free_quad, qdata);
+	qdata->qobj = gluNewQuadric();
+	qdata->q_ref = rb_ary_new2(REF_LAST);
+	return ret;
 }
 static VALUE
 glu_DeleteQuadric(obj, arg1)
 VALUE obj, arg1;
 {
-    struct quaddata *qdata;
-    GetQUAD(arg1, qdata);
-    free_quad(qdata);
-    return Qnil;
+	struct quaddata *qdata;
+	GetQUAD(arg1, qdata);
+	free_quad(qdata);
+	return Qnil;
 }
 static VALUE
 glu_QuadricNormals(obj, arg1, arg2)
 VALUE obj, arg1, arg2;
 {
-    struct quaddata* qdata;
-    GLenum normals;
-    GetQUAD(arg1, qdata);
-    normals = (GLenum)NUM2INT(arg2);
-    gluQuadricNormals(qdata->qobj, normals);
-    return Qnil;
+	struct quaddata* qdata;
+	GLenum normals;
+	GetQUAD(arg1, qdata);
+	normals = (GLenum)NUM2INT(arg2);
+	gluQuadricNormals(qdata->qobj, normals);
+	return Qnil;
 }
 static VALUE
 glu_QuadricTexture(obj, arg1, arg2)
 VALUE obj, arg1, arg2;
 {
-    struct quaddata* qdata;
-    GLboolean textureCoords;
-    GetQUAD(arg1, qdata);
-    textureCoords = (GLboolean)NUM2INT(arg2);
-    gluQuadricTexture(qdata->qobj, textureCoords);
-    return Qnil;
+	struct quaddata* qdata;
+	GLboolean textureCoords;
+	GetQUAD(arg1, qdata);
+	textureCoords = (GLboolean)NUM2INT(arg2);
+	gluQuadricTexture(qdata->qobj, textureCoords);
+	return Qnil;
 }
 static VALUE
 glu_QuadricOrientation(obj, arg1, arg2)
 VALUE obj, arg1, arg2;
 {
-    struct quaddata* qdata;
-    GLenum orientation;
-    GetQUAD(arg1, qdata);
-    orientation = (GLenum)NUM2INT(arg2);
-    gluQuadricOrientation(qdata->qobj, orientation);
-    return Qnil;
+	struct quaddata* qdata;
+	GLenum orientation;
+	GetQUAD(arg1, qdata);
+	orientation = (GLenum)NUM2INT(arg2);
+	gluQuadricOrientation(qdata->qobj, orientation);
+	return Qnil;
 }
 static VALUE
 glu_QuadricDrawStyle(obj, arg1, arg2)
 VALUE obj, arg1, arg2;
 {
-    struct quaddata* qdata;
-    GLenum drawStyle;
-    GetQUAD(arg1, qdata);
-    drawStyle = (GLenum)NUM2INT(arg2);
-    gluQuadricDrawStyle(qdata->qobj, drawStyle);
-    return Qnil;
+	struct quaddata* qdata;
+	GLenum drawStyle;
+	GetQUAD(arg1, qdata);
+	drawStyle = (GLenum)NUM2INT(arg2);
+	gluQuadricDrawStyle(qdata->qobj, drawStyle);
+	return Qnil;
 }
 static VALUE
 glu_Cylinder(obj, arg1, arg2, arg3, arg4, arg5, arg6)
 VALUE obj, arg1, arg2, arg3, arg4, arg5, arg6;
 {
-    struct quaddata* qdata;
-    GLdouble baseRadius;
-    GLdouble topRadius;
-    GLdouble height;
-    GLint slices;
-    GLint stacks;
+	struct quaddata* qdata;
+	GLdouble baseRadius;
+	GLdouble topRadius;
+	GLdouble height;
+	GLint slices;
+	GLint stacks;
 
-    GetQUAD(arg1, qdata);
-    baseRadius = (GLdouble)NUM2DBL(arg2);
-    topRadius = (GLdouble)NUM2DBL(arg3);
-    height = (GLdouble)NUM2DBL(arg4);
-    slices = (GLint)NUM2INT(arg5);
-    stacks = (GLint)NUM2INT(arg6);
+	GetQUAD(arg1, qdata);
+	baseRadius = (GLdouble)NUM2DBL(arg2);
+	topRadius = (GLdouble)NUM2DBL(arg3);
+	height = (GLdouble)NUM2DBL(arg4);
+	slices = (GLint)NUM2INT(arg5);
+	stacks = (GLint)NUM2INT(arg6);
 
-    gluCylinder(qdata->qobj, baseRadius, topRadius, height, slices, stacks);
-    return Qnil;
+	rb_ary_push(q_current, arg1);
+	gluCylinder(qdata->qobj, baseRadius, topRadius, height, slices, stacks);
+	rb_ary_pop(q_current);
+	return Qnil;
 }
 static VALUE
 glu_Disk(obj, arg1, arg2, arg3, arg4, arg5)
 VALUE obj, arg1, arg2, arg3, arg4, arg5;
 {
-    struct quaddata* qdata;
-    GLdouble innerRadius;
-    GLdouble outerRadius;
-    GLint slices;
-    GLint loops;
+	struct quaddata* qdata;
+	GLdouble innerRadius;
+	GLdouble outerRadius;
+	GLint slices;
+	GLint loops;
+	
+	GetQUAD(arg1, qdata);
+	innerRadius = (GLdouble)NUM2DBL(arg2);
+	outerRadius = (GLdouble)NUM2DBL(arg3);
+	slices = (GLint)NUM2INT(arg4);
+	loops = (GLint)NUM2INT(arg5);
 
-    GetQUAD(arg1, qdata);
-    innerRadius = (GLdouble)NUM2DBL(arg2);
-    outerRadius = (GLdouble)NUM2DBL(arg3);
-    slices = (GLint)NUM2INT(arg4);
-    loops = (GLint)NUM2INT(arg5);
+	rb_ary_push(q_current, arg1);
 
-    gluDisk(qdata->qobj, innerRadius, outerRadius, slices, loops);
-    return Qnil;
+	gluDisk(qdata->qobj, innerRadius, outerRadius, slices, loops);
+	rb_ary_pop(q_current);
+	return Qnil;
 }
 static VALUE
 glu_PartialDisk(obj, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
 VALUE obj, arg1, arg2, arg3, arg4, arg5, arg6, arg7;
 {
-    struct quaddata* qdata;
-    GLdouble innerRadius;
-    GLdouble outerRadius;
-    GLint slices;
-    GLint loops;
-    GLdouble startAngle;
-    GLdouble sweepAngle;
-
-    GetQUAD(arg1, qdata);
-    innerRadius = (GLdouble)NUM2DBL(arg2);
-    outerRadius = (GLdouble)NUM2DBL(arg3);
-    slices = (GLint)NUM2INT(arg4);
-    loops = (GLint)NUM2INT(arg5);
-    startAngle = (GLdouble)NUM2DBL(arg6);
-    sweepAngle = (GLdouble)NUM2DBL(arg7);
-
-    gluPartialDisk(qdata->qobj, innerRadius, outerRadius, slices, loops, startAngle, sweepAngle);
-    return Qnil;
+	struct quaddata* qdata;
+	GLdouble innerRadius;
+	GLdouble outerRadius;
+	GLint slices;
+	GLint loops;
+	GLdouble startAngle;
+	GLdouble sweepAngle;
+	
+	GetQUAD(arg1, qdata);
+	innerRadius = (GLdouble)NUM2DBL(arg2);
+	outerRadius = (GLdouble)NUM2DBL(arg3);
+	slices = (GLint)NUM2INT(arg4);
+	loops = (GLint)NUM2INT(arg5);
+	startAngle = (GLdouble)NUM2DBL(arg6);
+	sweepAngle = (GLdouble)NUM2DBL(arg7);
+
+	rb_ary_push(q_current, arg1);
+	gluPartialDisk(qdata->qobj, innerRadius, outerRadius, slices, loops, startAngle, sweepAngle);
+	rb_ary_pop(q_current);
+	return Qnil;
 }
 static VALUE
 glu_Sphere(obj, arg1, arg2, arg3, arg4)
 VALUE obj, arg1, arg2, arg3, arg4;
 {
-    struct quaddata* qdata;
-    GLdouble radius;
-    GLint slices;
-    GLint stacks;
+	struct quaddata* qdata;
+	GLdouble radius;
+	GLint slices;
+	GLint stacks;
 
-    GetQUAD(arg1, qdata);
-    radius = (GLdouble)NUM2DBL(arg2);
-    slices = (GLint)NUM2INT(arg3);
-    stacks = (GLint)NUM2INT(arg4);
+	GetQUAD(arg1, qdata);
+	radius = (GLdouble)NUM2DBL(arg2);
+	slices = (GLint)NUM2INT(arg3);
+	stacks = (GLint)NUM2INT(arg4);
 
-    gluSphere(qdata->qobj, radius, slices, stacks);
-    return Qnil;
+	rb_ary_push(q_current, arg1);
+	gluSphere(qdata->qobj, radius, slices, stacks);
+	rb_ary_pop(q_current);
+	return Qnil;
 }
+
+/* */
+
 static VALUE
 glu_LookAt(obj,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9)
 VALUE obj,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9;
 {
-    GLdouble eyex;
-    GLdouble eyey;
-    GLdouble eyez;
-    GLdouble centerx;
-    GLdouble centery;
-    GLdouble centerz;
-    GLdouble upx;
-    GLdouble upy;
-    GLdouble upz;
-    eyex = (GLdouble)NUM2DBL(arg1);
-    eyey = (GLdouble)NUM2DBL(arg2);
-    eyez = (GLdouble)NUM2DBL(arg3);
-    centerx = (GLdouble)NUM2DBL(arg4);
-    centery = (GLdouble)NUM2DBL(arg5);
-    centerz = (GLdouble)NUM2DBL(arg6);
-    upx = (GLdouble)NUM2DBL(arg7);
-    upy = (GLdouble)NUM2DBL(arg8);
-    upz = (GLdouble)NUM2DBL(arg9);
-    gluLookAt( eyex, eyey, eyez, centerx, centery, centerz, upx, upy, upz );
-    return Qnil;
+	GLdouble eyex;
+	GLdouble eyey;
+	GLdouble eyez;
+	GLdouble centerx;
+	GLdouble centery;
+	GLdouble centerz;
+	GLdouble upx;
+	GLdouble upy;
+	GLdouble upz;
+	eyex = (GLdouble)NUM2DBL(arg1);
+	eyey = (GLdouble)NUM2DBL(arg2);
+	eyez = (GLdouble)NUM2DBL(arg3);
+	centerx = (GLdouble)NUM2DBL(arg4);
+	centery = (GLdouble)NUM2DBL(arg5);
+	centerz = (GLdouble)NUM2DBL(arg6);
+	upx = (GLdouble)NUM2DBL(arg7);
+	upy = (GLdouble)NUM2DBL(arg8);
+	upz = (GLdouble)NUM2DBL(arg9);
+	gluLookAt( eyex, eyey, eyez, centerx, centery, centerz, upx, upy, upz );
+	return Qnil;
 }
 static VALUE
 glu_Ortho2D(obj,arg1,arg2,arg3,arg4)
 VALUE obj,arg1,arg2,arg3,arg4;
 {
-    GLdouble left;
-    GLdouble right;
-    GLdouble bottom;
-    GLdouble top;
-    left = (GLdouble)NUM2DBL(arg1);
-    right = (GLdouble)NUM2DBL(arg2);
-    bottom = (GLdouble)NUM2DBL(arg3);
-    top = (GLdouble)NUM2DBL(arg4);
-    gluOrtho2D(left,right,bottom,top);
-    return Qnil;
+	GLdouble left;
+	GLdouble right;
+	GLdouble bottom;
+	GLdouble top;
+	left = (GLdouble)NUM2DBL(arg1);
+	right = (GLdouble)NUM2DBL(arg2);
+	bottom = (GLdouble)NUM2DBL(arg3);
+	top = (GLdouble)NUM2DBL(arg4);
+	gluOrtho2D(left,right,bottom,top);
+	return Qnil;
 }
 static VALUE
 glu_Perspective(obj,arg1,arg2,arg3,arg4)
 VALUE obj,arg1,arg2,arg3,arg4;
 {
-    GLdouble fovy;
-    GLdouble aspect;
-    GLdouble zNear;
-    GLdouble zFar;
-    fovy = (GLdouble)NUM2DBL(arg1);
-    aspect = (GLdouble)NUM2DBL(arg2);
-    zNear = (GLdouble)NUM2DBL(arg3);
-    zFar = (GLdouble)NUM2DBL(arg4);
-    gluPerspective(fovy,aspect,zNear,zFar);
-    return Qnil;
+	GLdouble fovy;
+	GLdouble aspect;
+	GLdouble zNear;
+	GLdouble zFar;
+	fovy = (GLdouble)NUM2DBL(arg1);
+	aspect = (GLdouble)NUM2DBL(arg2);
+	zNear = (GLdouble)NUM2DBL(arg3);
+	zFar = (GLdouble)NUM2DBL(arg4);
+	gluPerspective(fovy,aspect,zNear,zFar);
+	return Qnil;
 }
 static VALUE
 glu_PickMatrix(argc,argv,obj)
@@ -1185,37 +1140,37 @@ int argc;
 VALUE* argv;
 VALUE obj;
 {
-    GLdouble x;
-    GLdouble y;
-    GLdouble width;
-    GLdouble height;
-    GLint viewport[4];
-
-    VALUE args[5];
-
-    switch (rb_scan_args(argc, argv, "23", &args[0], &args[1], &args[2], &args[3], &args[4])) {
-        case 2:
-        width = 5.0f;
-        height = 5.0f;
-        glGetIntegerv(GL_VIEWPORT, viewport);
-        break;
-    case 4:
-        width = (GLdouble)NUM2DBL(args[2]);
-        height = (GLdouble)NUM2DBL(args[3]);
-        glGetIntegerv(GL_VIEWPORT, viewport);
-        break;
-        case 5:
-        width = (GLdouble)NUM2DBL(args[2]);
-        height = (GLdouble)NUM2DBL(args[3]);
-        ary2cint(args[4], viewport, 4);
-        break;
-        default:
-        rb_raise(rb_eArgError, "GLU.PickMatrix args len:%d",argc);
-    }
-    x = (GLdouble)NUM2DBL(args[0]);
-    y = (GLdouble)NUM2DBL(args[1]);
-    gluPickMatrix(x, y, width, height, viewport);
-    return Qnil;
+	GLdouble x;
+	GLdouble y;
+	GLdouble width;
+	GLdouble height;
+	GLint viewport[4];
+	
+	VALUE args[5];
+	
+	switch (rb_scan_args(argc, argv, "23", &args[0], &args[1], &args[2], &args[3], &args[4])) {
+		case 2:
+			width = 5.0f;
+			height = 5.0f;
+			glGetIntegerv(GL_VIEWPORT, viewport);
+			break;
+		case 4:
+			width = (GLdouble)NUM2DBL(args[2]);
+			height = (GLdouble)NUM2DBL(args[3]);
+			glGetIntegerv(GL_VIEWPORT, viewport);
+			break;
+		case 5:
+			width = (GLdouble)NUM2DBL(args[2]);
+			height = (GLdouble)NUM2DBL(args[3]);
+			ary2cint(args[4], viewport, 4);
+			break;
+		default:
+			rb_raise(rb_eArgError, "gluPickMatrix needs 2,4 or 5 parameters",argc);
+	}
+	x = (GLdouble)NUM2DBL(args[0]);
+	y = (GLdouble)NUM2DBL(args[1]);
+	gluPickMatrix(x, y, width, height, viewport);
+	return Qnil;
 }
 
 static VALUE
@@ -1224,44 +1179,40 @@ int argc;
 VALUE* argv;
 VALUE obj;
 {
-    GLdouble ox;
-    GLdouble oy;
-    GLdouble oz;
-    GLdouble mdl_mtx[4*4];
-    GLdouble prj_mtx[4*4];
-    GLint vport[4];
-    GLdouble wx;
-    GLdouble wy;
-    GLdouble wz;
-
-    VALUE args[6];
-    VALUE ret;
-    
-    switch (rb_scan_args(argc, argv, "33", &args[0], &args[1], &args[2], &args[3], &args[4], &args[5])) {
-    case 3:
-        glGetDoublev(GL_MODELVIEW_MATRIX, mdl_mtx);
-        glGetDoublev(GL_PROJECTION_MATRIX, prj_mtx);
-        glGetIntegerv(GL_VIEWPORT, vport);
-        break;
-    case 6:
-        ary2cmat4x4dbl(args[3], mdl_mtx);
-        ary2cmat4x4dbl(args[4], prj_mtx);
-        ary2cint(args[5], vport, 4);
-        break;
-    default:
-        rb_raise(rb_eArgError, "GLU.Project args len:%d",argc);
-    }
-    ox = (GLdouble)NUM2DBL(args[0]);
-    oy = (GLdouble)NUM2DBL(args[1]);
-    oz = (GLdouble)NUM2DBL(args[2]);
-
-    if (gluProject(ox, oy, oz, mdl_mtx, prj_mtx, vport, &wx, &wy, &wz)
-    == GL_TRUE) {
-    ret = rb_ary_new3(3, rb_float_new(wx), rb_float_new(wy), rb_float_new(wz));
-    return ret;
-    }
-    else
-    return Qnil;
+	GLdouble ox;
+	GLdouble oy;
+	GLdouble oz;
+	GLdouble mdl_mtx[4*4];
+	GLdouble prj_mtx[4*4];
+	GLint vport[4];
+	GLdouble wx;
+	GLdouble wy;
+	GLdouble wz;
+
+	VALUE args[6];
+	
+	switch (rb_scan_args(argc, argv, "33", &args[0], &args[1], &args[2], &args[3], &args[4], &args[5])) {
+		case 3:
+			glGetDoublev(GL_MODELVIEW_MATRIX, mdl_mtx);
+			glGetDoublev(GL_PROJECTION_MATRIX, prj_mtx);
+			glGetIntegerv(GL_VIEWPORT, vport);
+			break;
+		case 6:
+			ary2cmat4x4dbl(args[3], mdl_mtx);
+			ary2cmat4x4dbl(args[4], prj_mtx);
+			ary2cint(args[5], vport, 4);
+			break;
+		default:
+			rb_raise(rb_eArgError, "gluProject needs 3 or 6 parameters");
+	}
+	ox = (GLdouble)NUM2DBL(args[0]);
+	oy = (GLdouble)NUM2DBL(args[1]);
+	oz = (GLdouble)NUM2DBL(args[2]);
+	
+	if (gluProject(ox, oy, oz, mdl_mtx, prj_mtx, vport, &wx, &wy, &wz) == GL_TRUE)
+		return rb_ary_new3(3, rb_float_new(wx), rb_float_new(wy), rb_float_new(wz));
+	else
+		return Qnil;
 }
 static VALUE
 glu_UnProject(argc,argv,obj)
@@ -1269,369 +1220,216 @@ int argc;
 VALUE* argv;
 VALUE obj;
 {
-    GLdouble wx;
-    GLdouble wy;
-    GLdouble wz;
-    GLdouble mdl_mtx[4*4];
-    GLdouble prj_mtx[4*4];
-    GLint vport[4];
-    GLdouble ox;
-    GLdouble oy;
-    GLdouble oz;
-
-    VALUE args[6];
-    VALUE ret;
-
-    switch (rb_scan_args(argc, argv, "33", &args[0], &args[1], &args[2], &args[3], &args[4], &args[5])) {
-    case 3:
-        glGetDoublev(GL_MODELVIEW_MATRIX, mdl_mtx);
-        glGetDoublev(GL_PROJECTION_MATRIX, prj_mtx);
-        glGetIntegerv(GL_VIEWPORT, vport);
-        break;
-    case 6:
-        ary2cmat4x4dbl(args[3], mdl_mtx);
-        ary2cmat4x4dbl(args[4], prj_mtx);
-        ary2cint(args[5], vport, 4);
-        break;
-    default:
-        rb_raise(rb_eArgError, "GLU.UnProject args len:%d",argc);
-    }
-    wx = (GLdouble)NUM2DBL(args[0]);
-    wy = (GLdouble)NUM2DBL(args[1]);
-    wz = (GLdouble)NUM2DBL(args[2]);
-
-    if (gluUnProject(wx, wy, wz, mdl_mtx, prj_mtx, vport, &ox, &oy, &oz)
-    == GL_TRUE) {
-        ret = rb_ary_new3(3, rb_float_new(ox), rb_float_new(oy), rb_float_new(oz));
-    return ret;
-    }
-    else
-    return Qnil;
+	GLdouble wx;
+	GLdouble wy;
+	GLdouble wz;
+	GLdouble mdl_mtx[4*4];
+	GLdouble prj_mtx[4*4];
+	GLint vport[4];
+	GLdouble ox;
+	GLdouble oy;
+	GLdouble oz;
+	
+	VALUE args[6];
+	
+	switch (rb_scan_args(argc, argv, "33", &args[0], &args[1], &args[2], &args[3], &args[4], &args[5])) {
+		case 3:
+			glGetDoublev(GL_MODELVIEW_MATRIX, mdl_mtx);
+			glGetDoublev(GL_PROJECTION_MATRIX, prj_mtx);
+			glGetIntegerv(GL_VIEWPORT, vport);
+			break;
+		case 6:
+			ary2cmat4x4dbl(args[3], mdl_mtx);
+			ary2cmat4x4dbl(args[4], prj_mtx);
+			ary2cint(args[5], vport, 4);
+			break;
+		default:
+			rb_raise(rb_eArgError, "gluUnProject needs 3 or 6 parameters");
+	}
+	wx = (GLdouble)NUM2DBL(args[0]);
+	wy = (GLdouble)NUM2DBL(args[1]);
+	wz = (GLdouble)NUM2DBL(args[2]);
+	
+	if (gluUnProject(wx, wy, wz, mdl_mtx, prj_mtx, vport, &ox, &oy, &oz) == GL_TRUE)
+		return rb_ary_new3(3, rb_float_new(ox), rb_float_new(oy), rb_float_new(oz));
+	else
+		return Qnil;
+}
+
+static VALUE
+glu_Build1DMipmaps(obj, arg1, arg2, arg3, arg4, arg5, arg6)
+VALUE obj, arg1, arg2, arg3, arg4, arg5, arg6;
+{
+	GLenum target;
+	GLint components;
+	GLint width;
+	GLenum format;
+	GLenum type;
+	
+	target = (GLenum)NUM2INT(arg1);
+	components = (GLint)NUM2INT(arg2);
+	width = (GLint)NUM2INT(arg3);
+	format = (GLenum)NUM2INT(arg4);
+	type = (GLenum)NUM2INT(arg5);
+	Check_Type(arg6,T_STRING);
+	CheckDataSize(type,format,width,arg6);
+
+	return INT2NUM(gluBuild1DMipmaps(target, components, width, format, type, RSTRING(arg6)->ptr));
 }
 
 static VALUE
 glu_Build2DMipmaps(obj, arg1, arg2, arg3, arg4, arg5, arg6, arg7)
 VALUE obj, arg1, arg2, arg3, arg4, arg5, arg6, arg7;
 {
-    GLenum target;
-    GLint components;
-    GLint width;
-    GLint height;
-    GLenum format;
-    GLenum type;
-    void* data;
-
-    int type_size;
-    int format_size;
-    int size;
-
-    target = (GLenum)NUM2INT(arg1);
-    components = (GLint)NUM2INT(arg2);
-    width = (GLint)NUM2INT(arg3);
-    height = (GLint)NUM2INT(arg4);
-    format = (GLenum)NUM2INT(arg5);
-    type = (GLenum)NUM2INT(arg6);
-    if (TYPE(arg7) == T_STRING) {
-        type_size = gltype_size(type) / 8;
-        format_size = glformat_size(format);
-        if (type_size == -1 || format_size == -1)
-            return Qnil;
-        size = type_size*format_size*height*width;
-        if (RSTRING(arg7)->len < size)
-            rb_raise(rb_eArgError, "string length:%d",RSTRING(arg7)->len);
-        data = RSTRING(arg7)->ptr;
-    } else 
-        rb_raise(rb_eTypeError, "type mismatch:%s",rb_class2name(arg7));
-    return INT2NUM(gluBuild2DMipmaps(target, components, width, height, format, type, data));
+	GLenum target;
+	GLint components;
+	GLint width;
+	GLint height;
+	GLenum format;
+	GLenum type;
+	
+	target = (GLenum)NUM2INT(arg1);
+	components = (GLint)NUM2INT(arg2);
+	width = (GLint)NUM2INT(arg3);
+	height = (GLint)NUM2INT(arg4);
+	format = (GLenum)NUM2INT(arg5);
+	type = (GLenum)NUM2INT(arg6);
+	Check_Type(arg7,T_STRING);
+	CheckDataSize(type,format,width*height,arg7);
+
+	return INT2NUM(gluBuild2DMipmaps(target, components, width, height, format, type, RSTRING(arg7)->ptr));
 }
 
 static VALUE
 glu_ScaleImage(obj, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8)
 VALUE obj, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8;
 {
-    GLenum format;
-    GLint widthin;
-    GLint heightin;
-    GLenum typein;
-    void* datain;
-    GLint widthout;
-    GLint heightout;
-    GLenum typeout;
-    int type_size;
-    int format_size;
-    int size;
-    VALUE ret;
-
-    format = (GLenum)NUM2INT(arg1);
-    widthin = (GLint)NUM2INT(arg2);
-    heightin = (GLint)NUM2INT(arg3);
-    typein = (GLenum)NUM2INT(arg4);
-    if (TYPE(arg5) == T_STRING) {
-        type_size = gltype_size(typein) / 8;
-        format_size = glformat_size(format);
-        if (type_size == -1 || format_size == -1)
-            return Qnil;
-        size = type_size*format_size*heightin*widthin;
-        if (RSTRING(arg5)->len < size)
-            rb_raise(rb_eArgError, "string length:%d",RSTRING(arg5)->len);
-        datain = RSTRING(arg5)->ptr;
-    } else 
-        rb_raise(rb_eTypeError, "type mismatch:%s",rb_class2name(arg5));
-
-    widthout = (GLint)NUM2INT(arg6);
-    heightout = (GLint)NUM2INT(arg7);
-    typeout = (GLenum)NUM2INT(arg8);
-    type_size = gltype_size(typeout) / 8;
-    ret = allocate_buffer_with_string(widthout*heightout*format_size*type_size);
-    gluScaleImage(format, widthin, heightin, typein, datain,
-        widthout, heightout, typeout, (GLvoid*)RSTRING(ret)->ptr);
-    return ret;
+	GLenum format;
+	GLint widthin;
+	GLint heightin;
+	GLenum typein;
+	void* datain;
+	GLint widthout;
+	GLint heightout;
+	GLenum typeout;
+	VALUE ret;
+	
+	format = (GLenum)NUM2INT(arg1);
+	widthin = (GLint)NUM2INT(arg2);
+	heightin = (GLint)NUM2INT(arg3);
+	typein = (GLenum)NUM2INT(arg4);
+	Check_Type(arg5,T_STRING);
+	CheckDataSize(typein,format,heightin*widthin,arg5);
+	datain = RSTRING(arg5)->ptr;
+	widthout = (GLint)NUM2INT(arg6);
+	heightout = (GLint)NUM2INT(arg7);
+	typeout = (GLenum)NUM2INT(arg8);
+	ret = allocate_buffer_with_string(GetDataSize(typeout,format,widthout*heightout));
+	gluScaleImage(format, widthin, heightin, typein, datain,
+		widthout, heightout, typeout, (GLvoid*)RSTRING(ret)->ptr);
+	return ret;
 }
 
 static VALUE
 glu_ErrorString(obj, arg1)
 VALUE obj, arg1;
 {
-    GLenum errorCode;
-    GLubyte* error;
-    errorCode = (GLenum)NUM2INT(arg1);
-    error = (GLubyte*)gluErrorString(errorCode);
-    if (error)
-        return rb_str_new2(error);
-    else
-        return Qnil;
+	GLenum errorCode;
+	GLubyte* error;
+	errorCode = (GLenum)NUM2INT(arg1);
+	error = (GLubyte*)gluErrorString(errorCode);
+	if (error)
+		return rb_str_new2((char *)error);
+	else
+		return Qnil;
 }
-#if defined(GLU_VERSION_1_1)
 static VALUE
 glu_GetString(obj, arg1)
 VALUE obj, arg1;
 {
-    GLenum name;
-    GLubyte* str;
-    name = (GLenum)NUM2INT(arg1);
-    str = (GLubyte*)gluGetString(name);
-    if (str)
-        return rb_str_new2(str);
-    else
-        return Qnil;
+	GLenum name;
+	GLubyte* str;
+	name = (GLenum)NUM2INT(arg1);
+	str = (GLubyte*)gluGetString(name);
+	if (str)
+		return rb_str_new2((char *)str);
+	else
+		return Qnil;
 }
-#endif
 
 static VALUE module;
 
-#ifndef GLU_BEGIN
-#define GLU_BEGIN                          100100
-#endif
-#ifndef GLU_VERTEX
-#define GLU_VERTEX                         100101
-#endif
-#ifndef GLU_END
-#define GLU_END                            100102
-#endif
-#ifndef GLU_EDGE_FLAG
-#define GLU_EDGE_FLAG                      100104
-#endif
-#ifndef GLU_CW
-#define GLU_CW                             100120
-#endif
-#ifndef GLU_CCW
-#define GLU_CCW                            100121
-#endif
-#ifndef GLU_INTERIOR
-#define GLU_INTERIOR                       100122
-#endif
-#ifndef GLU_EXTERIOR
-#define GLU_EXTERIOR                       100123
-#endif
-#ifndef GLU_UNKNOWN
-#define GLU_UNKNOWN                        100124
-#endif
-#ifndef GLU_ERROR
-#define GLU_ERROR                          100103
-#endif
-
 DLLEXPORT void Init_glu()
 {
-    callId = rb_intern("call");
-    refId = rb_intern("[]");
-    module = rb_define_module("Glu");
-    rb_define_module_function(module, "gluNewNurbsRenderer", glu_NewNurbsRenderer, 0);
-    rb_define_module_function(module, "gluDeleteNurbsRenderer", glu_DeleteNurbsRenderer, 1);
-    rb_define_module_function(module, "gluNurbsProperty", glu_NurbsProperty, 3);
-    rb_define_module_function(module, "gluGetNurbsProperty", glu_GetNurbsProperty, 2);
-    rb_define_module_function(module, "gluBeginCurve", glu_BeginCurve, 1);
-    rb_define_module_function(module, "gluEndCurve", glu_EndCurve, 1);
-    rb_define_module_function(module, "gluNurbsCurve", glu_NurbsCurve, -1);
-    rb_define_module_function(module, "gluBeginSurface", glu_BeginSurface, 1);
-    rb_define_module_function(module, "gluEndSurface", glu_EndSurface, 1);
-    rb_define_module_function(module, "gluNurbsSurface", glu_NurbsSurface, -1);
-    rb_define_module_function(module, "gluBeginTrim", glu_BeginTrim, 1);
-    rb_define_module_function(module, "gluEndTrim", glu_EndTrim, 1);
-    rb_define_module_function(module, "gluPwlCurve", glu_PwlCurve, -1);
-    rb_define_module_function(module, "gluNewTess", glu_NewTess, 0);
-    rb_define_module_function(module, "gluDeleteTess", glu_DeleteTess, 1);
-    rb_define_module_function(module, "gluTessCallback", glu_TessCallback, 3);
-    rb_define_module_function(module, "gluBeginPolygon", glu_BeginPolygon, 1);
-    rb_define_module_function(module, "gluTessVertex", glu_TessVertex, 3);
-    rb_define_module_function(module, "gluNextContour", glu_NextContour, 2);
-    rb_define_module_function(module, "gluEndPolygon", glu_EndPolygon, 1);
-#if defined(GLU_VERSION_1_2)
-    rb_define_module_function(module, "gluTessBeginPolygon", glu_TessBeginPolygon, 2);
-    rb_define_module_function(module, "gluTessBeginContour",  glu_TessBeginContour, 1);
-    rb_define_module_function(module, "gluTessEndContour", glu_TessEndContour, 1);
-    rb_define_module_function(module, "gluTessEndPolygon", glu_TessEndPolygon, 1);
-    rb_define_module_function(module, "gluTessProperty", glu_TessProperty, 3);
-    rb_define_module_function(module, "gluTessNormal", glu_TessNormal, 4);
-    rb_define_module_function(module, "gluGetTessProperty", glu_GetTessProperty, 2);
-#endif /* GLU_VERSION_1_2 */
-    rb_define_module_function(module, "gluNewQuadric", glu_NewQuadric, 0);
-    rb_define_module_function(module, "gluDeleteQuadric", glu_DeleteQuadric, 1);
-    rb_define_module_function(module, "gluQuadricNormals", glu_QuadricNormals, 2);
-    rb_define_module_function(module, "gluQuadricTexture", glu_QuadricTexture, 2);
-    rb_define_module_function(module, "gluQuadricOrientation", glu_QuadricOrientation, 2);
-    rb_define_module_function(module, "gluQuadricDrawStyle", glu_QuadricDrawStyle, 2);
-    rb_define_module_function(module, "gluCylinder", glu_Cylinder, 6);
-    rb_define_module_function(module, "gluDisk", glu_Disk, 5);
-    rb_define_module_function(module, "gluPartialDisk", glu_PartialDisk, 7);
-    rb_define_module_function(module, "gluSphere", glu_Sphere, 4);
-
-    rb_define_module_function(module, "gluLookAt", glu_LookAt, 9);
-    rb_define_module_function(module, "gluOrtho2D", glu_Ortho2D, 4);
-    rb_define_module_function(module, "gluPerspective", glu_Perspective, 4);
-    rb_define_module_function(module, "gluPickMatrix", glu_PickMatrix, -1);
-    rb_define_module_function(module, "gluProject", glu_Project, -1);
-    rb_define_module_function(module, "gluUnProject", glu_UnProject, -1);
-    rb_define_module_function(module, "gluBuild2DMipmaps", glu_Build2DMipmaps, 7);
-    rb_define_module_function(module, "gluScaleImage", glu_ScaleImage, 8);
-    rb_define_module_function(module, "gluErrorString", glu_ErrorString, 1);
-#if defined(GLU_VERSION_1_1)
-    rb_define_module_function(module, "gluGetString", glu_GetString, 1);
-#endif
-
-    rb_define_const(module, "GLU_SMOOTH", INT2NUM(GLU_SMOOTH));
-    rb_define_const(module, "GLU_FLAT", INT2NUM(GLU_FLAT));
-    rb_define_const(module, "GLU_NONE", INT2NUM(GLU_NONE));
-    rb_define_const(module, "GLU_POINT", INT2NUM(GLU_POINT));
-    rb_define_const(module, "GLU_LINE", INT2NUM(GLU_LINE));
-    rb_define_const(module, "GLU_FILL", INT2NUM(GLU_FILL));
-    rb_define_const(module, "GLU_SILHOUETTE", INT2NUM(GLU_SILHOUETTE));
-    rb_define_const(module, "GLU_OUTSIDE", INT2NUM(GLU_OUTSIDE));
-    rb_define_const(module, "GLU_INSIDE", INT2NUM(GLU_INSIDE));
-#if defined(GLU_VERSION_1_2)
-    rb_define_const(module, "GLU_TESS_BEGIN", INT2NUM(GLU_TESS_BEGIN));
-    rb_define_const(module, "GLU_TESS_VERTEX", INT2NUM(GLU_TESS_VERTEX));
-    rb_define_const(module, "GLU_TESS_END", INT2NUM(GLU_TESS_END));
-    rb_define_const(module, "GLU_TESS_ERROR", INT2NUM(GLU_TESS_ERROR));
-    rb_define_const(module, "GLU_TESS_EDGE_FLAG", INT2NUM(GLU_TESS_EDGE_FLAG));
-    rb_define_const(module, "GLU_TESS_COMBINE", INT2NUM(GLU_TESS_COMBINE));
-
-    rb_define_const(module, "GLU_TESS_BEGIN_DATA", INT2NUM(GLU_TESS_BEGIN_DATA));
-    rb_define_const(module, "GLU_TESS_VERTEX_DATA", INT2NUM(GLU_TESS_VERTEX_DATA));
-    rb_define_const(module, "GLU_TESS_END_DATA", INT2NUM(GLU_TESS_END_DATA));
-    rb_define_const(module, "GLU_TESS_ERROR_DATA", INT2NUM(GLU_TESS_ERROR_DATA));
-    rb_define_const(module, "GLU_TESS_EDGE_FLAG_DATA", INT2NUM(GLU_TESS_EDGE_FLAG_DATA));
-    rb_define_const(module, "GLU_TESS_COMBINE_DATA", INT2NUM(GLU_TESS_COMBINE_DATA));
-
-    /* Winding rules */
-    rb_define_const(module, "GLU_TESS_WINDING_ODD", INT2NUM(GLU_TESS_WINDING_ODD));
-    rb_define_const(module, "GLU_TESS_WINDING_NONZERO", INT2NUM(GLU_TESS_WINDING_NONZERO));
-    rb_define_const(module, "GLU_TESS_WINDING_POSITIVE", INT2NUM(GLU_TESS_WINDING_POSITIVE));
-    rb_define_const(module, "GLU_TESS_WINDING_NEGATIVE", INT2NUM(GLU_TESS_WINDING_NEGATIVE));
-    rb_define_const(module, "GLU_TESS_WINDING_ABS_GEQ_TWO", INT2NUM(GLU_TESS_WINDING_ABS_GEQ_TWO));
-
-    /* Tessellation properties */
-    rb_define_const(module, "GLU_TESS_WINDING_RULE", INT2NUM(GLU_TESS_WINDING_RULE));
-    rb_define_const(module, "GLU_TESS_BOUNDARY_ONLY", INT2NUM(GLU_TESS_BOUNDARY_ONLY));
-    rb_define_const(module, "GLU_TESS_TOLERANCE", INT2NUM(GLU_TESS_TOLERANCE));
-#endif /* GLU_VERSION_1_2 */
-
-    rb_define_const(module, "GLU_BEGIN", INT2NUM(GLU_BEGIN));
-    rb_define_const(module, "GLU_VERTEX", INT2NUM(GLU_VERTEX));
-    rb_define_const(module, "GLU_END", INT2NUM(GLU_END));
-    rb_define_const(module, "GLU_ERROR", INT2NUM(GLU_ERROR));
-    rb_define_const(module, "GLU_EDGE_FLAG", INT2NUM(GLU_EDGE_FLAG));
-    rb_define_const(module, "GLU_CW", INT2NUM(GLU_CW));
-    rb_define_const(module, "GLU_CCW", INT2NUM(GLU_CCW));
-    rb_define_const(module, "GLU_INTERIOR", INT2NUM(GLU_INTERIOR));
-    rb_define_const(module, "GLU_EXTERIOR", INT2NUM(GLU_EXTERIOR));
-    rb_define_const(module, "GLU_UNKNOWN", INT2NUM(GLU_UNKNOWN));
-    rb_define_const(module, "GLU_TESS_ERROR1", INT2NUM(GLU_TESS_ERROR1));
-    rb_define_const(module, "GLU_TESS_ERROR2", INT2NUM(GLU_TESS_ERROR2));
-    rb_define_const(module, "GLU_TESS_ERROR3", INT2NUM(GLU_TESS_ERROR3));
-    rb_define_const(module, "GLU_TESS_ERROR4", INT2NUM(GLU_TESS_ERROR4));
-    rb_define_const(module, "GLU_TESS_ERROR5", INT2NUM(GLU_TESS_ERROR5));
-    rb_define_const(module, "GLU_TESS_ERROR6", INT2NUM(GLU_TESS_ERROR6));
-    rb_define_const(module, "GLU_TESS_ERROR7", INT2NUM(GLU_TESS_ERROR7));
-    rb_define_const(module, "GLU_TESS_ERROR8", INT2NUM(GLU_TESS_ERROR8));
-#if defined(TESS_ERROR9)
-    rb_define_const(module, "GLU_TESS_ERROR9", INT2NUM(GLU_TESS_ERROR9));
-#endif
-#if defined(GLU_VERSION_1_3)
-    rb_define_const(module, "GLU_AUTO_LOAD_MATRIX", INT2NUM(GLU_AUTO_LOAD_MATRIX));
-    rb_define_const(module, "GLU_CULLING", INT2NUM(GLU_CULLING));
-    rb_define_const(module, "GLU_SAMPLING_TOLERANCE", INT2NUM(GLU_SAMPLING_TOLERANCE));
-    rb_define_const(module, "GLU_DISPLAY_MODE", INT2NUM(GLU_DISPLAY_MODE));
-    rb_define_const(module, "GLU_SAMPLING_METHOD", INT2NUM(GLU_SAMPLING_METHOD));
-    rb_define_const(module, "GLU_U_STEP", INT2NUM(GLU_U_STEP));
-    rb_define_const(module, "GLU_V_STEP", INT2NUM(GLU_V_STEP));
-#endif
-    rb_define_const(module, "GLU_PATH_LENGTH", INT2NUM(GLU_PATH_LENGTH));
-    rb_define_const(module, "GLU_PARAMETRIC_ERROR", INT2NUM(GLU_PARAMETRIC_ERROR));
-    rb_define_const(module, "GLU_DOMAIN_DISTANCE", INT2NUM(GLU_DOMAIN_DISTANCE));
-    rb_define_const(module, "GLU_MAP1_TRIM_2", INT2NUM(GLU_MAP1_TRIM_2));
-    rb_define_const(module, "GLU_MAP1_TRIM_3", INT2NUM(GLU_MAP1_TRIM_3));
-    rb_define_const(module, "GLU_OUTLINE_POLYGON", INT2NUM(GLU_OUTLINE_POLYGON));
-    rb_define_const(module, "GLU_OUTLINE_PATCH", INT2NUM(GLU_OUTLINE_PATCH));
-    rb_define_const(module, "GLU_NURBS_ERROR1", INT2NUM(GLU_NURBS_ERROR1));
-    rb_define_const(module, "GLU_NURBS_ERROR2", INT2NUM(GLU_NURBS_ERROR2));
-    rb_define_const(module, "GLU_NURBS_ERROR3", INT2NUM(GLU_NURBS_ERROR3));
-    rb_define_const(module, "GLU_NURBS_ERROR4", INT2NUM(GLU_NURBS_ERROR4));
-    rb_define_const(module, "GLU_NURBS_ERROR5", INT2NUM(GLU_NURBS_ERROR5));
-    rb_define_const(module, "GLU_NURBS_ERROR6", INT2NUM(GLU_NURBS_ERROR6));
-    rb_define_const(module, "GLU_NURBS_ERROR7", INT2NUM(GLU_NURBS_ERROR7));
-    rb_define_const(module, "GLU_NURBS_ERROR8", INT2NUM(GLU_NURBS_ERROR8));
-    rb_define_const(module, "GLU_NURBS_ERROR9", INT2NUM(GLU_NURBS_ERROR9));
-    rb_define_const(module, "GLU_NURBS_ERROR10", INT2NUM(GLU_NURBS_ERROR10));
-    rb_define_const(module, "GLU_NURBS_ERROR11", INT2NUM(GLU_NURBS_ERROR11));
-    rb_define_const(module, "GLU_NURBS_ERROR12", INT2NUM(GLU_NURBS_ERROR12));
-    rb_define_const(module, "GLU_NURBS_ERROR13", INT2NUM(GLU_NURBS_ERROR13));
-    rb_define_const(module, "GLU_NURBS_ERROR14", INT2NUM(GLU_NURBS_ERROR14));
-    rb_define_const(module, "GLU_NURBS_ERROR15", INT2NUM(GLU_NURBS_ERROR15));
-    rb_define_const(module, "GLU_NURBS_ERROR16", INT2NUM(GLU_NURBS_ERROR16));
-    rb_define_const(module, "GLU_NURBS_ERROR17", INT2NUM(GLU_NURBS_ERROR17));
-    rb_define_const(module, "GLU_NURBS_ERROR18", INT2NUM(GLU_NURBS_ERROR18));
-    rb_define_const(module, "GLU_NURBS_ERROR19", INT2NUM(GLU_NURBS_ERROR19));
-    rb_define_const(module, "GLU_NURBS_ERROR20", INT2NUM(GLU_NURBS_ERROR20));
-    rb_define_const(module, "GLU_NURBS_ERROR21", INT2NUM(GLU_NURBS_ERROR21));
-    rb_define_const(module, "GLU_NURBS_ERROR22", INT2NUM(GLU_NURBS_ERROR22));
-    rb_define_const(module, "GLU_NURBS_ERROR23", INT2NUM(GLU_NURBS_ERROR23));
-    rb_define_const(module, "GLU_NURBS_ERROR24", INT2NUM(GLU_NURBS_ERROR24));
-    rb_define_const(module, "GLU_NURBS_ERROR25", INT2NUM(GLU_NURBS_ERROR25));
-    rb_define_const(module, "GLU_NURBS_ERROR26", INT2NUM(GLU_NURBS_ERROR26));
-    rb_define_const(module, "GLU_NURBS_ERROR27", INT2NUM(GLU_NURBS_ERROR27));
-    rb_define_const(module, "GLU_NURBS_ERROR28", INT2NUM(GLU_NURBS_ERROR28));
-    rb_define_const(module, "GLU_NURBS_ERROR29", INT2NUM(GLU_NURBS_ERROR29));
-    rb_define_const(module, "GLU_NURBS_ERROR30", INT2NUM(GLU_NURBS_ERROR30));
-    rb_define_const(module, "GLU_NURBS_ERROR31", INT2NUM(GLU_NURBS_ERROR31));
-    rb_define_const(module, "GLU_NURBS_ERROR32", INT2NUM(GLU_NURBS_ERROR32));
-    rb_define_const(module, "GLU_NURBS_ERROR33", INT2NUM(GLU_NURBS_ERROR33));
-    rb_define_const(module, "GLU_NURBS_ERROR34", INT2NUM(GLU_NURBS_ERROR34));
-    rb_define_const(module, "GLU_NURBS_ERROR35", INT2NUM(GLU_NURBS_ERROR35));
-    rb_define_const(module, "GLU_NURBS_ERROR36", INT2NUM(GLU_NURBS_ERROR36));
-    rb_define_const(module, "GLU_NURBS_ERROR37", INT2NUM(GLU_NURBS_ERROR37));
-    rb_define_const(module, "GLU_INVALID_ENUM", INT2NUM(GLU_INVALID_ENUM));
-    rb_define_const(module, "GLU_INVALID_VALUE", INT2NUM(GLU_INVALID_VALUE));
-    rb_define_const(module, "GLU_OUT_OF_MEMORY", INT2NUM(GLU_OUT_OF_MEMORY));
-#ifdef GLU_INCOMPATIBLE_GL_VERSION
-    rb_define_const(module, "GLU_INCOMPATIBLE_GL_VERSION", INT2NUM(GLU_INCOMPATIBLE_GL_VERSION));
-#endif
-    rb_define_const(module, "GLU_VERSION", INT2NUM(GLU_VERSION));
-    rb_define_const(module, "GLU_EXTENSIONS", INT2NUM(GLU_EXTENSIONS));
-
-    cNurbs = rb_define_class("Nurbs", rb_cObject);
-    cTess = rb_define_class("Tess", rb_cObject);
-    cQuad = rb_define_class("Quadric", rb_cObject);
-
-    rb_global_variable(&t_current);
-    t_current = rb_ary_new();
+	callId = rb_intern("call");
+	refId = rb_intern("[]");
+	module = rb_define_module("Glu");
+	
+	glu_init_enums(module);
+	
+	rb_define_module_function(module, "gluNewNurbsRenderer", glu_NewNurbsRenderer, 0);
+	rb_define_module_function(module, "gluDeleteNurbsRenderer", glu_DeleteNurbsRenderer, 1);
+	rb_define_module_function(module, "gluNurbsProperty", glu_NurbsProperty, 3);
+	rb_define_module_function(module, "gluGetNurbsProperty", glu_GetNurbsProperty, 2);
+	rb_define_module_function(module, "gluBeginCurve", glu_BeginCurve, 1);
+	rb_define_module_function(module, "gluEndCurve", glu_EndCurve, 1);
+	rb_define_module_function(module, "gluNurbsCurve", glu_NurbsCurve, -1);
+	rb_define_module_function(module, "gluBeginSurface", glu_BeginSurface, 1);
+	rb_define_module_function(module, "gluEndSurface", glu_EndSurface, 1);
+	rb_define_module_function(module, "gluNurbsSurface", glu_NurbsSurface, -1);
+	rb_define_module_function(module, "gluBeginTrim", glu_BeginTrim, 1);
+	rb_define_module_function(module, "gluEndTrim", glu_EndTrim, 1);
+	rb_define_module_function(module, "gluPwlCurve", glu_PwlCurve, -1);
+	rb_define_module_function(module, "gluNewTess", glu_NewTess, 0);
+	rb_define_module_function(module, "gluDeleteTess", glu_DeleteTess, 1);
+	rb_define_module_function(module, "gluTessCallback", glu_TessCallback, 3);
+	rb_define_module_function(module, "gluBeginPolygon", glu_BeginPolygon, 1);
+	rb_define_module_function(module, "gluTessVertex", glu_TessVertex, 3);
+	rb_define_module_function(module, "gluNextContour", glu_NextContour, 2);
+	rb_define_module_function(module, "gluEndPolygon", glu_EndPolygon, 1);
+	rb_define_module_function(module, "gluTessBeginPolygon", glu_TessBeginPolygon, 2);
+	rb_define_module_function(module, "gluTessBeginContour",  glu_TessBeginContour, 1);
+	rb_define_module_function(module, "gluTessEndContour", glu_TessEndContour, 1);
+	rb_define_module_function(module, "gluTessEndPolygon", glu_TessEndPolygon, 1);
+	rb_define_module_function(module, "gluTessProperty", glu_TessProperty, 3);
+	rb_define_module_function(module, "gluTessNormal", glu_TessNormal, 4);
+	rb_define_module_function(module, "gluGetTessProperty", glu_GetTessProperty, 2);
+	rb_define_module_function(module, "gluNewQuadric", glu_NewQuadric, 0);
+	rb_define_module_function(module, "gluDeleteQuadric", glu_DeleteQuadric, 1);
+	rb_define_module_function(module, "gluQuadricNormals", glu_QuadricNormals, 2);
+	rb_define_module_function(module, "gluQuadricTexture", glu_QuadricTexture, 2);
+	rb_define_module_function(module, "gluQuadricOrientation", glu_QuadricOrientation, 2);
+	rb_define_module_function(module, "gluQuadricDrawStyle", glu_QuadricDrawStyle, 2);
+	rb_define_module_function(module, "gluCylinder", glu_Cylinder, 6);
+	rb_define_module_function(module, "gluDisk", glu_Disk, 5);
+	rb_define_module_function(module, "gluPartialDisk", glu_PartialDisk, 7);
+	rb_define_module_function(module, "gluSphere", glu_Sphere, 4);
+	
+	rb_define_module_function(module, "gluLookAt", glu_LookAt, 9);
+	rb_define_module_function(module, "gluOrtho2D", glu_Ortho2D, 4);
+	rb_define_module_function(module, "gluPerspective", glu_Perspective, 4);
+	rb_define_module_function(module, "gluPickMatrix", glu_PickMatrix, -1);
+	rb_define_module_function(module, "gluProject", glu_Project, -1);
+	rb_define_module_function(module, "gluUnProject", glu_UnProject, -1);
+	rb_define_module_function(module, "gluBuild1DMipmaps", glu_Build1DMipmaps, 6);
+	rb_define_module_function(module, "gluBuild2DMipmaps", glu_Build2DMipmaps, 7);
+	rb_define_module_function(module, "gluScaleImage", glu_ScaleImage, 8);
+	rb_define_module_function(module, "gluErrorString", glu_ErrorString, 1);
+	rb_define_module_function(module, "gluGetString", glu_GetString, 1);
+	
+	rb_define_module_function(module, "gluLoadSamplingMatrices",glu_LoadSamplingMatrices,4);
+	rb_define_module_function(module, "gluQuadricCallback", glu_QuadricCallback, 3);
+	rb_define_module_function(module, "gluNurbsCallback", glu_NurbsCallback, 3);
+
+	
+	cNurbs = rb_define_class("Nurbs", rb_cObject);
+	cTess = rb_define_class("Tess", rb_cObject);
+	cQuad = rb_define_class("Quadric", rb_cObject);
+	
+	rb_global_variable(&t_current); /* current active tesselator, nurbs and quadric, used for callbacks */
+	t_current = rb_ary_new();
+	rb_global_variable(&n_current); 
+	n_current = rb_ary_new();
+	rb_global_variable(&q_current); 
+	q_current = rb_ary_new();
 }