glu 8.1.0 → 8.2.0

data/ext/glu/glu.c

@@ -33,24 +33,24 @@ typedef GLUtesselator tesselatorObj;
   and free them after that call */
 
 struct glu_MesaStack {
-	int len;
-	GLfloat **ptr;
+  int len;
+  GLfloat **ptr;
 };
 
 static struct glu_MesaStack gms = {0, NULL};
 
 struct nurbsdata {
-	GLUnurbsObj *nobj;
-	VALUE n_ref;
+  GLUnurbsObj *nobj;
+  VALUE n_ref;
 };
 struct tessdata {
-	tesselatorObj *tobj;
-	VALUE t_ref;
+  tesselatorObj *tobj;
+  VALUE t_ref;
 };
 
 struct quaddata {
-	GLUquadricObj *qobj;
-	VALUE q_ref;
+  GLUquadricObj *qobj;
+  VALUE q_ref;
 };
 
 static VALUE cNurbs;
@@ -60,156 +60,156 @@ 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;
 static ID refId;
 
 /*
- * GLU Implementation
- */
+* GLU Implementation
+*/
 
 /*
- * Nurbs
- */
+* Nurbs
+*/
 /* from nurbscrv.c */
 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:
-			rb_raise(rb_eArgError,"Unknown curve type '%i'",type);
-	}
-	return 0; /* never gets 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:
-			rb_raise(rb_eArgError,"Unknown surface type '%i'",type);
-	}
-	return 0; /* never gets 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 */
 }
 
 VALUE GLUError_initialize(VALUE obj,VALUE message, VALUE error_id)
 {
-	rb_call_super(1, &message);
-	rb_iv_set(obj, "@id", error_id);
+  rb_call_super(1, &message);
+  rb_iv_set(obj, "@id", error_id);
 
-	return obj;
+  return obj;
 }
 
 void check_for_gluerror(GLenum error)
 {
-	const char *error_string;
-	VALUE exc;
-	
-	/* no error */
-	if (error==0)
-		return;
-	
-	switch(error) {
-		case GLU_INVALID_ENUM: error_string = "invalid enumerant"; break;
-		case GLU_INVALID_VALUE: error_string = "invalid value"; break;
-		case GLU_INVALID_OPERATION: error_string = "invalid operation"; break;
-		case GLU_OUT_OF_MEMORY: error_string = "out of memory"; break;
-		default: error_string = "unknown error"; break;
-	}
-
-	exc = rb_funcall(Class_GLUError, rb_intern("new"), 2, rb_str_new2(error_string), RETCONV_GLenum(error));
-	rb_funcall(rb_cObject, rb_intern("raise"), 1, exc);
+  const char *error_string;
+  VALUE exc;
+
+  /* no error */
+  if (error==0)
+    return;
+
+  switch(error) {
+    case GLU_INVALID_ENUM: error_string = "invalid enumerant"; break;
+    case GLU_INVALID_VALUE: error_string = "invalid value"; break;
+    case GLU_INVALID_OPERATION: error_string = "invalid operation"; break;
+    case GLU_OUT_OF_MEMORY: error_string = "out of memory"; break;
+    default: error_string = "unknown error"; break;
+  }
+
+  exc = rb_funcall(Class_GLUError, rb_intern("new"), 2, rb_str_new2(error_string), UINT2NUM(error));
+  rb_funcall(rb_cObject, rb_intern("raise"), 1, exc);
 }
 
 /*
- * NURBS API
- */
+* NURBS API
+*/
 static VALUE n_current;
 
 static void
 free_nurbs(ndata)
 struct nurbsdata *ndata;
 {
-	if (ndata->nobj) gluDeleteNurbsRenderer(ndata->nobj);
-		ndata->nobj = NULL;
-	ndata->n_ref = Qnil;
+  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);
+  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));
+  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)));
+  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;
+  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);
+  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;
+  return Qnil;
 }
 
 
@@ -217,79 +217,79 @@ static VALUE
 glu_NewNurbsRenderer(obj)
 VALUE obj;
 {
-	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;
+  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 cond_GLBOOL2RUBY_F(property,value);
+  struct nurbsdata *ndata;
+  GLenum property;
+  GLfloat value;
+  GetNURBS(arg1, ndata);
+  property = (GLenum)NUM2INT(arg2);
+  gluGetNurbsProperty(ndata->nobj, property, &value);
+
+  return cond_GLBOOL2RUBY_F(property,value);
 }
 static VALUE
 glu_BeginCurve(obj, arg1)
 VALUE obj, arg1;
 {
-	struct nurbsdata *ndata;
-	GetNURBS(arg1, ndata);
-	rb_ary_push(n_current, arg1);
-	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);
+  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;
 
-	for (;gms.len>0;gms.len--)
-		free(gms.ptr[gms.len-1]);
-	free(gms.ptr);
-	gms.ptr = NULL;
+  rb_ary_pop(n_current);
 
-	rb_ary_pop(n_current);
 
-		
-	return Qnil;
+  return Qnil;
 }
 static VALUE
 glu_NurbsCurve(argc,argv,obj)
@@ -297,84 +297,86 @@ 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];
-	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 = (GLint)RARRAY_LENINT(args[1]);
-			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_funcall(args[2],rb_intern("flatten"),0);
-			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_funcall(args[4],rb_intern("flatten"),0);
-			break;
-		default:
-			rb_raise(rb_eArgError, "gluNurbsCurve needs 5 or 7 arguments");
-	}
-	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;
+  struct nurbsdata *ndata;
+  GLint uknot_count;
+  GLfloat *uknot;
+  GLint u_stride;
+  GLint uorder;
+  GLfloat *ctlarray;
+  GLenum type;
+  GLfloat **gms_ptr;
+
+  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 = (GLint)RARRAY_LENINT(args[1]);
+      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_funcall(args[2],rb_intern("flatten"),0);
+      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_funcall(args[4],rb_intern("flatten"),0);
+      break;
+    default:
+      rb_raise(rb_eArgError, "gluNurbsCurve needs 5 or 7 arguments");
+  }
+  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 = gms.ptr;
+  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);
-	rb_ary_push(n_current, arg1);
-	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);
-	
-	for(; gms.len>0; gms.len--)
-		free(gms.ptr[gms.len-1]);
-	free(gms.ptr);
-	gms.ptr = NULL;
+  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;
+  rb_ary_pop(n_current);
+
+
+  return Qnil;
 }
 
 static VALUE
@@ -383,102 +385,104 @@ 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 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 = (GLint)RARRAY_LENINT(args[1]);
-			sknot = ALLOC_N(GLfloat, sknot_count);
-			ary2cflt(args[1], sknot, sknot_count);
-
-			tknot_count = (GLint)RARRAY_LENINT(args[2]);
-			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_funcall(args[3],rb_intern("flatten"),0);
-			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_funcall(args[7],rb_intern("flatten"),0);
-			ary2cflt(ary_ctl1, ctlarray, (sknot_count-sorder)*(tknot_count-torder)*type_len);
-			break;
-		default:
-			rb_raise(rb_eArgError, "gluNurbsSurface needs 7 or 11 arguments");
-			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;
+  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;
+  GLfloat **gms_ptr;
+
+  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 = (GLint)RARRAY_LENINT(args[1]);
+      sknot = ALLOC_N(GLfloat, sknot_count);
+      ary2cflt(args[1], sknot, sknot_count);
+
+      tknot_count = (GLint)RARRAY_LENINT(args[2]);
+      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_funcall(args[3],rb_intern("flatten"),0);
+      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_funcall(args[7],rb_intern("flatten"),0);
+      ary2cflt(ary_ctl1, ctlarray, (sknot_count-sorder)*(tknot_count-torder)*type_len);
+      break;
+    default:
+      rb_raise(rb_eArgError, "gluNurbsSurface needs 7 or 11 arguments");
+      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 = gms.ptr;
+  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);
-	rb_ary_push(n_current, arg1);
-	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);
-	rb_ary_pop(n_current);
-		
-	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)
@@ -486,68 +490,68 @@ int argc;
 VALUE *argv;
 VALUE obj;
 {
-	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 = (GLint)RARRAY_LENINT(args[1]);
-			type = NUM2INT(args[2]);
-			stride = (type == GLU_MAP1_TRIM_2 ? 2 : 3);
-
-			array = ALLOC_N(GLfloat, count*stride);
-			ary_ctl1 = rb_funcall(args[1],rb_intern("flatten"),0);
-			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_funcall(args[2],rb_intern("flatten"),0);
-			ary2cflt(ary_ctl1, array, count*stride);
-			break;
-		default:
-			rb_raise(rb_eArgError, "gluPwlCurve needs 3 or 5 arguments");
-			return Qnil; /* not reached */
-	}
-
-	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 = (GLint)RARRAY_LENINT(args[1]);
+      type = NUM2INT(args[2]);
+      stride = (type == GLU_MAP1_TRIM_2 ? 2 : 3);
+
+      array = ALLOC_N(GLfloat, count*stride);
+      ary_ctl1 = rb_funcall(args[1],rb_intern("flatten"),0);
+      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_funcall(args[2],rb_intern("flatten"),0);
+      ary2cflt(ary_ctl1, array, count*stride);
+      break;
+    default:
+      rb_raise(rb_eArgError, "gluPwlCurve needs 3 or 5 arguments");
+      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];
+  struct nurbsdata *ndata;
+  GLfloat mdl_mtx[4*4];
+  GLfloat persp_mtx[4*4];
+  GLint viewport[4];
 
-	GetNURBS(arg1, ndata);
-	ary2cmatfloat(arg2,mdl_mtx,4,4);
-	ary2cmatfloat(arg3,persp_mtx,4,4);
-	ary2cint(arg4,viewport,4);
+  GetNURBS(arg1, ndata);
+  ary2cmatfloat(arg2,mdl_mtx,4,4);
+  ary2cmatfloat(arg3,persp_mtx,4,4);
+  ary2cint(arg4,viewport,4);
 
-	gluLoadSamplingMatrices(ndata->nobj,mdl_mtx,persp_mtx,viewport);
+  gluLoadSamplingMatrices(ndata->nobj,mdl_mtx,persp_mtx,viewport);
 
-		
-	return Qnil;
+
+  return Qnil;
 }
 
 /*
- * Tesselation API
- */
+* Tesselation API
+*/
 static VALUE t_current;
 #define TESS_DATA   0
 #define TESS_BEGIN  1
@@ -569,39 +573,39 @@ 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;
 {
-	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;
 }
 
 /* tess* callback function wrappers */
@@ -610,81 +614,81 @@ VALUE tess; \
 struct tessdata *tdata; \
 tess = rb_ary_entry(t_current, -1); \
 if (tess == Qnil) \
-	return; \
+  return; \
 GetTESS(tess, tdata);
 
 static void CALLBACK
 t_begin(type)
 GLenum type;
 {
-	TESS_CALLBACK_COMMON
-	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 CALLBACK
 t_edgeFlag(flag)
 GLboolean flag;
 {
-	TESS_CALLBACK_COMMON
-	rb_funcall(rb_ary_entry(tdata->t_ref, TESS_EDGE_FLAG), callId, 1, GLBOOL2RUBY(flag));
+  TESS_CALLBACK_COMMON
+  rb_funcall(rb_ary_entry(tdata->t_ref, TESS_EDGE_FLAG), callId, 1, GLBOOL2RUBY(flag));
 }
 static void CALLBACK
 t_vertex(data)
 void* data;
 {
-	TESS_CALLBACK_COMMON
-	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 CALLBACK
 t_end()
 {
-	TESS_CALLBACK_COMMON
-	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 CALLBACK
 t_error(errorno)
 GLenum errorno;
 {
-	TESS_CALLBACK_COMMON
-	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));
 }
 static void CALLBACK
 t_begin_data(type, user_data)
 GLenum type;
 void* user_data;
 {
-	TESS_CALLBACK_COMMON
-	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 CALLBACK
 t_edgeFlag_data(flag, user_data)
 GLboolean flag;
 void* user_data;
 {
-	TESS_CALLBACK_COMMON
-	rb_funcall(rb_ary_entry(tdata->t_ref, TESS_EDGE_FLAG_DATA), callId, 2, GLBOOL2RUBY(flag), user_data);
+  TESS_CALLBACK_COMMON
+  rb_funcall(rb_ary_entry(tdata->t_ref, TESS_EDGE_FLAG_DATA), callId, 2, GLBOOL2RUBY(flag), user_data);
 }
 static void CALLBACK
 t_vertex_data(data, user_data)
 void* data;
 void* user_data;
 {
-	TESS_CALLBACK_COMMON
-	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 CALLBACK
 t_end_data(user_data)
 void* user_data;
 {
-	TESS_CALLBACK_COMMON
-	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 CALLBACK
 t_error_data(errorno, user_data)
 GLenum errorno;
 void* user_data;
 {
-	TESS_CALLBACK_COMMON
-	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 CALLBACK
@@ -694,21 +698,21 @@ void* vertex_data[4];
 GLfloat weight[4];
 void** outData;
 {
-	VALUE rb_coord, rb_vertex_data, rb_weight;
-	int i;
-	TESS_CALLBACK_COMMON
+  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);
+  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 CALLBACK
@@ -719,23 +723,23 @@ GLfloat weight[4];
 void** outData;
 void* user_data;
 {
-	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]));
+  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);
+  *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);
+  rb_ary_push(rb_ary_entry(tdata->t_ref, TESS_OUTDATA), (VALUE)*outData);
 }
 
 #undef TESS_CALLBACK_COMMON
@@ -744,94 +748,94 @@ static VALUE
 glu_TessProperty(obj, arg1, arg2, arg3)
 VALUE obj, arg1, arg2, arg3;
 {
-	struct tessdata* tdata;
-	GLenum property;
-	GLdouble value;
-	GetTESS(arg1, tdata);
-	property = (GLenum)NUM2INT(arg2);
+  struct tessdata* tdata;
+  GLenum property;
+  GLdouble value;
+  GetTESS(arg1, tdata);
+  property = (GLenum)NUM2INT(arg2);
   if (property == GLU_TESS_BOUNDARY_ONLY) {
     value = (GLdouble)RUBYBOOL2GL(arg3);
   } else {
     value = (GLdouble)NUM2DBL(arg3);
   }
-	gluTessProperty(tdata->tobj, property, value);
-		
-	return Qnil;
+  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 cond_GLBOOL2RUBY_D(property,value);
+  struct tessdata* tdata;
+  GLenum property;
+  GLdouble value;
+  GetTESS(arg1, tdata);
+  property = (GLenum)NUM2INT(arg2);
+  gluGetTessProperty(tdata->tobj, property, &value);
+
+  return cond_GLBOOL2RUBY_D(property,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)
 VALUE obj, arg1;
 {
-	struct tessdata* tdata;
-	GetTESS(arg1, tdata);
-	gluTessEndContour(tdata->tobj);
-		
-	return Qnil;
+  struct tessdata* tdata;
+  GetTESS(arg1, tdata);
+  gluTessEndContour(tdata->tobj);
+
+  return Qnil;
 }
 
 #define TESS_CALLBACK_CASE(_type_,_function_) \
@@ -847,29 +851,29 @@ static VALUE
 glu_TessCallback(obj, arg1, arg2, arg3)
 VALUE obj, arg1, arg2, arg3;
 {
-	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;
+  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
 
@@ -877,94 +881,94 @@ 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] = {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;
+  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
- */
+* 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));
+  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)));
+  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;
 
-		
-	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);
 
-	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;
+
+  return Qnil;
 }
 
 static void
@@ -973,177 +977,177 @@ struct quaddata *qdata;
 {
   if (qdata->qobj) gluDeleteQuadric(qdata->qobj);
   qdata->qobj = NULL;
-	qdata->q_ref = Qnil;
+  qdata->q_ref = Qnil;
 }
 static void
 mark_quad(qdata)
 struct quaddata* qdata;
 {
-	if (qdata->qobj)
-		rb_gc_mark(qdata->q_ref);
+  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, mark_quad, free_quad, qdata);
-	qdata->qobj = gluNewQuadric();
-	qdata->q_ref = rb_ary_new2(REF_LAST);
-		
-	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)RUBYBOOL2GL(arg2);
-	gluQuadricTexture(qdata->qobj, textureCoords);
-		
-	return Qnil;
+  struct quaddata* qdata;
+  GLboolean textureCoords;
+  GetQUAD(arg1, qdata);
+  textureCoords = (GLboolean)RUBYBOOL2GL(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;
-
-	GetQUAD(arg1, qdata);
-	baseRadius = (GLdouble)NUM2DBL(arg2);
-	topRadius = (GLdouble)NUM2DBL(arg3);
-	height = (GLdouble)NUM2DBL(arg4);
-	slices = (GLint)NUM2INT(arg5);
-	stacks = (GLint)NUM2INT(arg6);
-
-	rb_ary_push(q_current, arg1);
-	gluCylinder(qdata->qobj, baseRadius, topRadius, height, slices, stacks);
-	rb_ary_pop(q_current);
-		
-	return Qnil;
+  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);
+
+  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;
-	
-	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);
-	rb_ary_pop(q_current);
-		
-	return Qnil;
+  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);
+
+  rb_ary_push(q_current, arg1);
+
+  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);
-
-	rb_ary_push(q_current, arg1);
-	gluPartialDisk(qdata->qobj, innerRadius, outerRadius, slices, loops, startAngle, sweepAngle);
-	rb_ary_pop(q_current);
-		
-	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);
+  rb_ary_push(q_current, arg1);
+  gluSphere(qdata->qobj, radius, slices, stacks);
+  rb_ary_pop(q_current);
 
-	rb_ary_push(q_current, arg1);
-	gluSphere(qdata->qobj, radius, slices, stacks);
-	rb_ary_pop(q_current);
-		
-	return Qnil;
+  return Qnil;
 }
 
 /* */
@@ -1152,59 +1156,59 @@ 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)
@@ -1212,38 +1216,38 @@ 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, "gluPickMatrix needs 2,4 or 5 parameters");
-	}
-	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");
+  }
+  x = (GLdouble)NUM2DBL(args[0]);
+  y = (GLdouble)NUM2DBL(args[1]);
+  gluPickMatrix(x, y, width, height, viewport);
+
+  return Qnil;
 }
 
 static VALUE
@@ -1252,44 +1256,44 @@ 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];
-	
-	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:
-			ary2cmatdouble(args[3], mdl_mtx, 4, 4);
-			ary2cmatdouble(args[4], prj_mtx, 4, 4);
-			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 {
-			
-		check_for_gluerror(GLU_INVALID_VALUE);
-		return Qnil; /* not reached */
-	}
+  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:
+      ary2cmatdouble(args[3], mdl_mtx, 4, 4);
+      ary2cmatdouble(args[4], prj_mtx, 4, 4);
+      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 {
+
+    check_for_gluerror(GLU_INVALID_VALUE);
+    return Qnil; /* not reached */
+  }
 }
 static VALUE
 glu_UnProject(argc,argv,obj)
@@ -1297,238 +1301,238 @@ 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];
-	
-	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:
-			ary2cmatdouble(args[3], mdl_mtx, 4, 4);
-			ary2cmatdouble(args[4], prj_mtx, 4, 4);
-			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 {
-			
-		check_for_gluerror(GLU_INVALID_VALUE);
-		return Qnil; /* not reached */
-	}
+  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:
+      ary2cmatdouble(args[3], mdl_mtx, 4, 4);
+      ary2cmatdouble(args[4], prj_mtx, 4, 4);
+      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 {
+
+    check_for_gluerror(GLU_INVALID_VALUE);
+    return Qnil; /* not reached */
+  }
 }
 
 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;
-	int ret;
-	
-	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);
-
-	ret = gluBuild1DMipmaps(target, components, width, format, type, RSTRING_PTR(arg6));
-	check_for_gluerror(ret);
-		
-	return INT2NUM(ret);
+  GLenum target;
+  GLint components;
+  GLint width;
+  GLenum format;
+  GLenum type;
+  int ret;
+
+  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);
+
+  ret = gluBuild1DMipmaps(target, components, width, format, type, RSTRING_PTR(arg6));
+  check_for_gluerror(ret);
+
+  return INT2NUM(ret);
 }
 
 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;
-	int ret;
-	
-	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);
-
-	ret = gluBuild2DMipmaps(target, components, width, height, format, type, RSTRING_PTR(arg7));
-	check_for_gluerror(ret);
-		
-	return INT2NUM(ret);
+  GLenum target;
+  GLint components;
+  GLint width;
+  GLint height;
+  GLenum format;
+  GLenum type;
+  int ret;
+
+  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);
+
+  ret = gluBuild2DMipmaps(target, components, width, height, format, type, RSTRING_PTR(arg7));
+  check_for_gluerror(ret);
+
+  return INT2NUM(ret);
 }
 
 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;
-	VALUE ret;
-	GLint retcode;
-	
-	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_PTR(arg5);
-	widthout = (GLint)NUM2INT(arg6);
-	heightout = (GLint)NUM2INT(arg7);
-	typeout = (GLenum)NUM2INT(arg8);
-	ret = allocate_buffer_with_string(GetDataSize(typeout,format,widthout*heightout));
-	retcode = gluScaleImage(format, widthin, heightin, typein, datain,
-		widthout, heightout, typeout, (GLvoid*)RSTRING_PTR(ret));
-
-	check_for_gluerror(retcode);
-		
-	return ret;
+  GLenum format;
+  GLint widthin;
+  GLint heightin;
+  GLenum typein;
+  void* datain;
+  GLint widthout;
+  GLint heightout;
+  GLenum typeout;
+  VALUE ret;
+  GLint retcode;
+
+  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_PTR(arg5);
+  widthout = (GLint)NUM2INT(arg6);
+  heightout = (GLint)NUM2INT(arg7);
+  typeout = (GLenum)NUM2INT(arg8);
+  ret = allocate_buffer_with_string(GetDataSize(typeout,format,widthout*heightout));
+  retcode = gluScaleImage(format, widthin, heightin, typein, datain,
+    widthout, heightout, typeout, (GLvoid*)RSTRING_PTR(ret));
+
+  check_for_gluerror(retcode);
+
+  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((char *)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;
 }
 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((char *)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;
 }
 
 static VALUE module;
 
 DLLEXPORT void Init_glu()
 {
-	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);
-
-	Class_GLUError = rb_define_class_under(module, "Error", rb_eStandardError);
-
-	rb_define_method(Class_GLUError, "initialize", GLUError_initialize, 2);
-	rb_define_attr(Class_GLUError, "id", 1, 0);
-
-	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();
+  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);
+
+  Class_GLUError = rb_define_class_under(module, "Error", rb_eStandardError);
+
+  rb_define_method(Class_GLUError, "initialize", GLUError_initialize, 2);
+  rb_define_attr(Class_GLUError, "id", 1, 0);
+
+  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();
 }