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

data/ext/{gl → opengl}/gl.c

@@ -15,9 +15,7 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#include "../common/common.h"
-
-static const char *VERSION = "0.7.0.pre1";
+#include "common.h"
 
 static VALUE module;
 
@@ -48,7 +46,7 @@ const int *GetOpenglVersion(void)
 {
 	if (opengl_version[0]==0) { /* not cached, query */
 		const char *vstr = (const char *) glGetString(GL_VERSION);
-		CHECK_GLERROR
+		CHECK_GLERROR_FROM("glGetString");
 		if (vstr)
 			sscanf( vstr, "%d.%d", &opengl_version[0], &opengl_version[1] );
 	}
@@ -78,7 +76,7 @@ const char *GetOpenglExtensions(void)
 {
 	if (opengl_extensions == NULL) {
 		const char *estr = (const char *) glGetString(GL_EXTENSIONS);
-		CHECK_GLERROR
+		CHECK_GLERROR_FROM("glGetString");
 		if (estr) {
 			long len = strlen(estr);
 			opengl_extensions = ALLOC_N(GLchar,len+1+1); /* terminating null and added space */
@@ -146,7 +144,7 @@ VALUE obj,arg1;
 	VALUE s;
 	GLboolean res;
 
-	s = rb_funcall(arg1, rb_intern("to_s"),0);
+	s = rb_funcall(arg1, rb_intern("to_s"), 0);
 	name = RSTRING_PTR(s);
 
 	res = CheckVersionExtension(name);
@@ -178,18 +176,18 @@ GLint CheckBufferBinding(GLint buffer)
 			break;
 	}
 	glGetIntegerv(buffer,&result);
-	CHECK_GLERROR
+	CHECK_GLERROR_FROM("glGetIntegerv");
 	return result;
 }
 
 DLLEXPORT void Init_gl()
 {
-	VALUE vVERSION = rb_str_new2(VERSION);
+	VALUE VERSION = rb_str_new2("0.60");
 
 	module = rb_define_module("Gl");
 
-	rb_define_const(module, "BINDINGS_VERSION", vVERSION);
-	rb_define_const(module, "RUBY_OPENGL_VERSION", vVERSION);
+	rb_define_const(module, "BINDINGS_VERSION", VERSION);
+	rb_define_const(module, "RUBY_OPENGL_VERSION", VERSION);
 
 	gl_init_error(module);
 	gl_init_enums(module);

data/ext/{glu → opengl}/glu-enums.c

@@ -2,7 +2,7 @@
    source: http://oss.sgi.com/cgi-bin/cvsweb.cgi/~checkout~/projects/ogl-sample/main/doc/registry/specs/enumglu.spec
 */
 
-#include "../common/common.h"
+#include "common.h"
 void glu_init_enums(VALUE module)
 {
 	rb_define_const(module, "GLU_TRUE", Qtrue);

data/ext/{glu → opengl}/glu.c

@@ -17,7 +17,7 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#include "../common/common.h"
+#include "common.h"
 
 static VALUE module;
 
@@ -749,7 +749,11 @@ VALUE obj, arg1, arg2, arg3;
 	GLdouble value;
 	GetTESS(arg1, tdata);
 	property = (GLenum)NUM2INT(arg2);
-	value = (GLdouble)NUM2DBL(arg3);
+  if (property == GLU_TESS_BOUNDARY_ONLY) {
+    value = (GLdouble)RUBYBOOL2GL(arg3);
+  } else {
+    value = (GLdouble)NUM2DBL(arg3);
+  }
 	gluTessProperty(tdata->tobj, property, value);
 		
 	return Qnil;
@@ -1019,7 +1023,7 @@ VALUE obj, arg1, arg2;
 	struct quaddata* qdata;
 	GLboolean textureCoords;
 	GetQUAD(arg1, qdata);
-	textureCoords = (GLboolean)NUM2INT(arg2);
+	textureCoords = (GLboolean)RUBYBOOL2GL(arg2);
 	gluQuadricTexture(qdata->qobj, textureCoords);
 		
 	return Qnil;

data/ext/{glut → opengl}/glut.c

@@ -20,7 +20,7 @@
  *
  */
 
-#include "../common/common.h"
+#include "common.h"
 
 static ID callId; /* 'call' method id */
 
@@ -36,17 +36,16 @@ static ID callId; /* 'call' method id */
 #define WINDOW_CALLBACK_SETUP(_funcname) \
 static VALUE _funcname = Qnil; \
 static VALUE \
-glut_ ## _funcname(obj,arg1) \
-VALUE obj,arg1; \
+glut_ ## _funcname(obj, callback) \
+VALUE obj, callback; \
 { \
     int win; \
-    if (!rb_obj_is_kind_of(arg1,rb_cProc) && !NIL_P(arg1)) \
-        rb_raise(rb_eTypeError, "glut%s:%s",#_funcname, rb_class2name(CLASS_OF(arg1))); \
+    callback = check_callback(obj, callback); \
     win = glutGetWindow(); \
     if (win == 0) \
         rb_raise(rb_eRuntimeError, "glut%s needs current window", #_funcname); \
-    rb_ary_store(_funcname, win, arg1); \
-		if(NIL_P(arg1)) \
+    rb_ary_store(_funcname, win, callback); \
+		if(NIL_P(callback)) \
 			glut ## _funcname(NULL); \
 		else \
 			glut##_funcname(&glut_##_funcname##Callback); \
@@ -67,6 +66,23 @@ VALUE obj; \
     return Qnil; \
 }
 
+static VALUE
+check_callback(VALUE self, VALUE callback)
+{
+  VALUE inspect;
+
+	if (NIL_P(callback))
+    return callback;
+
+  if (rb_respond_to(callback, callId))
+    return callback;
+
+  if (SYMBOL_P(callback))
+    return rb_obj_method(self, callback);
+
+  inspect = rb_inspect(callback);
+  rb_raise(rb_eArgError, "%s must respond to call", StringValueCStr(inspect));
+}
 
 /*
  * GLUT Implementation
@@ -148,7 +164,28 @@ VALUE obj,arg1,arg2;
 	return Qnil;
 }
 
-GLUT_SIMPLE_FUNCTION(MainLoop)
+/*
+ * No way to unblock glutMainLoop, so fake it?
+ */
+static void
+glut_MainLoop_unblock(void *ignored) {
+}
+
+static VALUE glut_MainLoop0(void *ignored) {
+  glutMainLoop();
+
+  return Qnil;
+}
+
+static VALUE
+glut_MainLoop(void) {
+  /* need to acquire GVL in callbacks */
+  /*rb_thread_blocking_region(glut_MainLoop0, (void *)NULL, glut_MainLoop_unblock, NULL);*/
+
+  glut_MainLoop0(NULL);
+
+  return Qnil; /* never reached */
+}
 
 static void GLUTCALLBACK glut_DisplayFuncCallback(void);
 static void GLUTCALLBACK glut_ReshapeFuncCallback(int,int);
@@ -196,22 +233,26 @@ WINDOW_CALLBACK_SETUP(SpecialUpFunc)
 /* special case, 2 params */
 static VALUE JoystickFunc = Qnil;
 static VALUE
-glut_JoystickFunc(obj,arg1,arg2)
-VALUE obj,arg1,arg2;
+glut_JoystickFunc(obj,callback,arg2)
+VALUE obj,callback,arg2;
 {
 	int win;
 	int pollinterval;
-	if (!rb_obj_is_kind_of(arg1,rb_cProc) && !NIL_P(arg1))
-		rb_raise(rb_eTypeError, "glutJoystickFunc:%s", rb_class2name(CLASS_OF(arg1)));
+
+  callback = check_callback(obj, callback);
 	pollinterval=NUM2INT(arg2);
 	win = glutGetWindow();
+
 	if (win == 0)
 		rb_raise(rb_eRuntimeError, "glutJoystickFunc needs current window");
-	rb_ary_store(JoystickFunc, win, arg1);
-	if (NIL_P(arg1))
-		glutJoystickFunc(NULL,pollinterval);
+
+	rb_ary_store(JoystickFunc, win, callback);
+
+	if (NIL_P(callback))
+		glutJoystickFunc(NULL, pollinterval);
 	else
-		glutJoystickFunc(glut_JoystickFuncCallback,pollinterval);
+		glutJoystickFunc(glut_JoystickFuncCallback, pollinterval);
+
 	return Qnil;
 }
 
@@ -386,19 +427,20 @@ glut_CreateMenuCallback(int value)
 
     
 static VALUE
-glut_CreateMenu(obj,arg1)
-VALUE obj,arg1;
+glut_CreateMenu(obj,callback)
+VALUE obj,callback;
 {
 	int menu;
-	if (!rb_obj_is_kind_of(arg1,rb_cProc) && !NIL_P(arg1))
-		rb_raise(rb_eTypeError, "glutCreateMenu:%s", rb_class2name(CLASS_OF(arg1)));
 
-	if (NIL_P(arg1))
+  callback = check_callback(obj, callback);
+
+	if (NIL_P(callback))
 		menu = glutCreateMenu(NULL);
 	else
 		menu = glutCreateMenu(glut_CreateMenuCallback);
 
-	rb_ary_store(g_menucallback,menu,arg1);
+	rb_ary_store(g_menucallback, menu, callback);
+
 	return INT2FIX(menu);
 }
 
@@ -525,10 +567,10 @@ glut_KeyboardFuncCallback(unsigned char key, int x, int y)
 	VALUE func;
 	func = rb_ary_entry(KeyboardFunc, glutGetWindow());
 	if (!NIL_P(func))
-#if RUBY_VERSION <190
-		rb_funcall(func, callId, 3, INT2FIX(key), INT2FIX(x), INT2FIX(y));
+#if HAVE_SINGLE_BYTE_STRINGS
+		rb_funcall(func, callId, 3, rb_str_new((char *)&key, 1), INT2FIX(x), INT2FIX(y));
 #else
-		rb_funcall(func, callId, 3, rb_funcall(INT2FIX(key),rb_intern("chr"),0), INT2FIX(x), INT2FIX(y));
+		rb_funcall(func, callId, 3, INT2FIX(key), INT2FIX(x), INT2FIX(y));
 #endif
 }
 
@@ -598,16 +640,18 @@ glut_IdleFuncCallback(void)
 
 
 static VALUE
-glut_IdleFunc(obj, arg1)
-VALUE obj,arg1;
+glut_IdleFunc(obj, callback)
+VALUE obj, callback;
 {
-	if (!rb_obj_is_kind_of(arg1,rb_cProc) && !NIL_P(arg1)) 
-		rb_raise(rb_eTypeError, "glutIdleFunc:%s", rb_class2name(CLASS_OF(arg1)));
-	idle_func = arg1;
-	if (NIL_P(arg1))
+  callback = check_callback(obj, callback);
+
+	idle_func = callback;
+
+	if (NIL_P(callback))
 		glutIdleFunc(NULL);
 	else
 		glutIdleFunc(glut_IdleFuncCallback);
+
 	return Qnil;
 }
 
@@ -622,17 +666,19 @@ glut_TimerFuncCallback(int value)
 
 
 static VALUE
-glut_TimerFunc(obj, arg1, arg2, arg3)
-VALUE obj,arg1,arg2,arg3;
+glut_TimerFunc(obj, arg1, callback, arg3)
+VALUE obj,arg1,callback,arg3;
 {
 	unsigned int millis;
 	int value;
 	millis = (unsigned int)NUM2INT(arg1);
 	value = NUM2INT(arg3);
-	if (!rb_obj_is_kind_of(arg2,rb_cProc)) 
-		rb_raise(rb_eTypeError, "glutTimerFunc:%s", rb_class2name(CLASS_OF(arg2)));
-	timer_func = arg2;
+  callback = check_callback(obj, callback);
+
+	timer_func = callback;
+
 	glutTimerFunc(millis, glut_TimerFuncCallback, value);
+
 	return Qnil;
 }
 
@@ -647,16 +693,18 @@ glut_MenuStateFuncCallback(int state)
 
 
 static VALUE
-glut_MenuStateFunc(obj, arg1)
-VALUE obj,arg1;
+glut_MenuStateFunc(obj, callback)
+VALUE obj, callback;
 {
-	if (!rb_obj_is_kind_of(arg1,rb_cProc) && !(NIL_P(arg1)))
-		rb_raise(rb_eTypeError, "glutMenuStateFunc:%s", rb_class2name(CLASS_OF(arg1)));
-	menustate_func = arg1;
-	if (NIL_P(arg1))
+  callback = check_callback(obj, callback);
+
+	menustate_func = callback;
+
+	if (NIL_P(callback))
 		glutMenuStateFunc(NULL);
 	else
 		glutMenuStateFunc(glut_MenuStateFuncCallback);
+
 	return Qnil;
 }
 
@@ -669,16 +717,18 @@ glut_MenuStatusFuncCallback(int state,int x,int y)
 }
 
 static VALUE
-glut_MenuStatusFunc(obj, arg1)
-VALUE obj,arg1;
+glut_MenuStatusFunc(obj, callback)
+VALUE obj, callback;
 {
-	if (!rb_obj_is_kind_of(arg1,rb_cProc) && !(NIL_P(arg1)))
-		rb_raise(rb_eTypeError, "glutMenuStatusFunc:%s", rb_class2name(CLASS_OF(arg1)));
-	menustatus_func = arg1;
-	if (NIL_P(arg1))
+  callback = check_callback(obj, callback);
+
+	menustatus_func = callback;
+
+	if (NIL_P(callback))
 		glutMenuStatusFunc(NULL);
 	else
 		glutMenuStatusFunc(glut_MenuStatusFuncCallback);
+
 	return Qnil;
 }
 

data/ext/opengl/opengl.c

@@ -0,0 +1,11 @@
+#include "common.h"
+
+void Init_gl(void);
+void Init_glu(void);
+void Init_glut(void);
+
+DLLEXPORT void Init_opengl() {
+  Init_gl();
+  Init_glu();
+  Init_glut();
+}

data/lib/gl.rb

@@ -0,0 +1 @@
+require 'opengl'

data/lib/glu.rb

@@ -0,0 +1 @@
+require 'opengl'

data/lib/glut.rb

@@ -0,0 +1 @@
+require 'opengl'

data/lib/opengl.rb

@@ -20,14 +20,13 @@
 # Thanks to Ilmari Heikkinen for a previous "reversed" version of this code,
 # and to Bill Kelly for a version before that one.
 
-# Extend the search path for Windows binary gem, depending of the current ruby version
-major_minor = RUBY_VERSION[ /^(\d+\.\d+)/ ] or
-  raise "Oops, can't extract the major/minor version from #{RUBY_VERSION.dump}"
-$: << File.join(File.dirname(__FILE__), major_minor)
+module OpenGL
 
-require 'gl'
-require 'glu'
-require 'glut'
+  VERSION = '0.7.0.pre2'
+
+end
+
+require 'opengl/opengl'
 
 include Gl,Glu,Glut
 
@@ -36,15 +35,15 @@ include Gl,Glu,Glut
 module GL
 	extend self
 	include Gl
-	
+
 	Gl.constants.each do |cn|
 		n = cn.to_s.sub(/^GL_/,'')
 		# due to ruby naming scheme, we can't export constants with leading decimal,
 		# e.g. (Gl::)GL_2D would under old syntax become (GL::)2D which is illegal
-		next if n =~ /^[0-9]/ 
+		next if n =~ /^[0-9]/
 		const_set( n, Gl.const_get( cn ) )
 	end
-	
+
 	Gl.methods( false ).each do |mn|
 		n = mn.to_s.sub(/^gl/,'')
 		alias_method( n, mn )
@@ -57,12 +56,12 @@ end
 module GLU
 	extend self
 	include Glu
-	
+
 	Glu.constants.each do |cn|
 		n = cn.to_s.sub(/^GLU_/,'')
 		const_set( n, Glu.const_get( cn ) )
 	end
-	
+
 	Glu.methods( false ).each do |mn|
 		n = mn.to_s.sub(/^glu/,'')
 		alias_method( n, mn )
@@ -75,12 +74,12 @@ end
 module GLUT
 	extend self
 	include Glut
-	
+
 	Glut.constants.each do |cn|
 		n = cn.to_s.sub(/^GLUT_/,'')
 		const_set( n, Glut.const_get( cn ) )
 	end
-	
+
 	Glut.methods( false ).each do |mn|
 		n = mn.to_s.sub(/^glut/,'')
 		alias_method( n, mn )