opengl 0.9.2-x86-mingw32 → 0.10.0.pre1-x86-mingw32

data/ext/opengl/gl.c

@@ -17,8 +17,6 @@
 
 #include "common.h"
 
-static VALUE module;
-
 void gl_init_enums(VALUE);
 void gl_init_functions_1_0__1_1(VALUE);
 void gl_init_functions_1_2(VALUE);
@@ -34,34 +32,42 @@ void gl_init_functions_ext_ati(VALUE);
 void gl_init_functions_ext_ext(VALUE);
 void gl_init_functions_ext_gremedy(VALUE);
 void gl_init_functions_ext_nv(VALUE);
-void gl_init_buffer(void);
+void gl_init_buffer(VALUE);
+void gl_init_glimpl(VALUE);
 
-static int opengl_version[2]; /* major, minor */
-static char *opengl_extensions = NULL;
+VALUE g_default_glimpl;
 
 /* Returns current OpenGL version as major, minor or 0,0 if
  * unknown (context not yet initialised etc.) The version is
  * cached for subsequent calls.
  */
-const int *GetOpenglVersion(void)
+const int *GetOpenglVersion(VALUE obj)
 {
-	if (opengl_version[0]==0) { /* not cached, query */
-		const char *vstr = (const char *) glGetString(GL_VERSION);
-		CHECK_GLERROR_FROM("glGetString");
-		if (vstr)
-			sscanf( vstr, "%d.%d", &opengl_version[0], &opengl_version[1] );
-	}
-	return opengl_version;
+  int *opengl_version = GET_GLIMPL_VARIABLE(opengl_version);
+  DECL_GL_FUNC_PTR(const GLubyte *,glGetString,(GLenum name));
+
+  LOAD_GL_FUNC(glGetString, NULL);
+  if (opengl_version[0]==0) { /* not cached, query */
+    const char *vstr = (const char *) fptr_glGetString(GL_VERSION);
+    CHECK_GLERROR_FROM("glGetString");
+    if (vstr){
+      int v0, v1;
+      sscanf( vstr, "%d.%d", &v0, &v1 );
+      SET_GLIMPL_VARIABLE(opengl_version[0], v0);
+      SET_GLIMPL_VARIABLE(opengl_version[1], v1);
+    }
+  }
+  return opengl_version;
 }
 
 /* Checks if OpenGL version is at least the same or higher than
  * major.minor
  */
-GLboolean CheckOpenglVersion(int major, int minor)
+GLboolean CheckOpenglVersion(VALUE obj, int major, int minor)
 {
 	const int *version;
 
-	version = GetOpenglVersion();
+	version = GetOpenglVersion(obj);
 
 	if (version[0]>major || (version[0]==major && version[1] >=minor))
 		return GL_TRUE;
@@ -73,33 +79,38 @@ GLboolean CheckOpenglVersion(int major, int minor)
  * if unknown (context not yet initialised etc.) The list is
  * cached for subsequent calls.
  */
-const char *GetOpenglExtensions(void)
+const char *GetOpenglExtensions(VALUE obj)
 {
-	if (opengl_extensions == NULL) {
-		const char *estr = (const char *) glGetString(GL_EXTENSIONS);
-		CHECK_GLERROR_FROM("glGetString");
-		if (estr) {
-			long len = strlen(estr);
-			opengl_extensions = ALLOC_N(GLchar,len+1+1); /* terminating null and added space */
-			strcpy(opengl_extensions,estr);
-			opengl_extensions[len] = ' '; /* add space char for easy searchs */
-			opengl_extensions[len+1] = '\0';
-		}
-	}
-	return opengl_extensions;	
+  char *opengl_extensions = GET_GLIMPL_VARIABLE(opengl_extensions);
+  DECL_GL_FUNC_PTR(const GLubyte *,glGetString,(GLenum name));
+
+  LOAD_GL_FUNC(glGetString, NULL);
+  if (opengl_extensions == NULL) {
+    const char *estr = (const char *) fptr_glGetString(GL_EXTENSIONS);
+    CHECK_GLERROR_FROM("glGetString");
+    if (estr) {
+      long len = strlen(estr);
+      opengl_extensions = ALLOC_N(GLchar,len+1+1); /* terminating null and added space */
+      strcpy(opengl_extensions,estr);
+      opengl_extensions[len] = ' '; /* add space char for easy searchs */
+      opengl_extensions[len+1] = '\0';
+      SET_GLIMPL_VARIABLE(opengl_extensions, opengl_extensions);
+    }
+  }
+  return opengl_extensions;
 }
 
 /* Checks if extension is supported by the current OpenGL implementation
  */
-GLboolean CheckExtension(const char *name)
+GLboolean CheckExtension(VALUE obj, const char *name)
 {
 	const char *extensions;
 	char *name_tmp;
 	long name_len;
 	GLboolean res;
-	
-	extensions = GetOpenglExtensions();
-	
+
+	extensions = GetOpenglExtensions(obj);
+
 	if(extensions==NULL)
 		return GL_FALSE;
 
@@ -116,30 +127,42 @@ GLboolean CheckExtension(const char *name)
 		res = GL_FALSE;
 
 	xfree(name_tmp);
-	return res;	
+	return res;
 }
 
 /* wrapper for CheckOpenglVersion and CheckExtension, also used by macros
  */
-GLboolean CheckVersionExtension(const char *name)
+GLboolean CheckVersionExtension(VALUE obj, const char *name)
 {
 	if (name && name[0] && name[0]>='0' && name[0]<='9') { /* GL version query */
 		int major,minor;
 
 		if (sscanf( name, "%d.%d", &major, &minor ) != 2)
 				return GL_FALSE;
-	
-		return (CheckOpenglVersion(major,minor));
+
+		return (CheckOpenglVersion(obj, major,minor));
 	} else {
-		return (CheckExtension(name));
+		return (CheckExtension(obj, name));
 	}
 }
 
+void EnsureVersionExtension(VALUE obj, const char *verext)
+{
+  if (CheckVersionExtension(obj, verext) == GL_FALSE) {
+    if (isdigit(verext[0])) {
+      rb_raise(rb_eNotImpError,
+        "OpenGL version %s is not available on this system",verext);
+    } else {
+      rb_raise(rb_eNotImpError,
+        "Extension %s is not available on this system",verext);
+    }
+  }
+}
+
 /* Checks if given OpenGL version or extension is available
  */
 static VALUE
-IsAvailable(obj,arg1)
-VALUE obj,arg1;
+IsAvailable(VALUE obj, VALUE arg1)
 {
 	char *name = NULL;
 	VALUE s;
@@ -148,7 +171,7 @@ VALUE obj,arg1;
 	s = rb_funcall(arg1, rb_intern("to_s"), 0);
 	name = RSTRING_PTR(s);
 
-	res = CheckVersionExtension(name);
+	res = CheckVersionExtension(obj, name);
 
 	return GLBOOL2RUBY(res);
 }
@@ -156,65 +179,87 @@ VALUE obj,arg1;
 /* Checks whether non-zero buffer of type $buffer is bound
  * - this affects several functions that pass data from/to OpenGL.
  */
-GLint CheckBufferBinding(GLint buffer)
+GLint CheckBufferBinding(VALUE obj, GLint buffer)
 {
 	GLint result = 0;
-	
+  DECL_GL_FUNC_PTR(void,glGetIntegerv,(GLenum pname, GLint *params));
+
+  LOAD_GL_FUNC(glGetIntegerv, NULL);
+
 	/* check if the buffer functionality is supported */
 	switch(buffer) {
 		case GL_ARRAY_BUFFER_BINDING:
 		case GL_ELEMENT_ARRAY_BUFFER_BINDING:
-			if (!CheckOpenglVersion(1,5))
+			if (!CheckOpenglVersion(obj, 1,5))
 				return 0;
 			break;
 		case GL_PIXEL_PACK_BUFFER_BINDING:
 		case GL_PIXEL_UNPACK_BUFFER_BINDING:
-			if (!CheckOpenglVersion(2,1))
+			if (!CheckOpenglVersion(obj, 2,1))
 				return 0;
 			break;
 		default:
 			rb_raise(rb_eRuntimeError,"Internal Error: buffer type '%i' does not exist", buffer);
 			break;
 	}
-	glGetIntegerv(buffer,&result);
+	fptr_glGetIntegerv(buffer,&result);
 	CHECK_GLERROR_FROM("glGetIntegerv");
 	return result;
 }
 
-DLLEXPORT void Init_gl()
+static VALUE
+rb_gl_s_get_implementation( VALUE module )
+{
+  if( NIL_P(g_default_glimpl) ){
+    VALUE rb_cGlimpl = rb_path2class("Gl::DefaultImplementation");
+    g_default_glimpl = rb_funcall(rb_cGlimpl, rb_intern("open"), 0);
+  }
+  return g_default_glimpl;
+}
+
+static VALUE
+rb_gl_s_set_implementation( VALUE module, VALUE glimpl )
+{
+  if(!rb_obj_is_kind_of(glimpl, rb_cGlimpl)){
+    rb_raise(rb_eArgError, "wrong argument type %s (expected kind of Gl::Implementation)", rb_obj_classname(glimpl));
+  }
+  g_default_glimpl = glimpl;
+  return glimpl;
+}
+
+void Init_gl(VALUE module)
 {
-  VALUE mOpenGL = rb_path2class("OpenGL");
-	VALUE version = rb_const_get(mOpenGL, rb_intern("VERSION"));
+  gl_init_glimpl(module);
+	gl_init_error(rb_cGlimpl, module);
+	gl_init_enums(module);
+	gl_init_functions_1_0__1_1(rb_cGlimpl);
+	gl_init_functions_1_2(rb_cGlimpl);
+	gl_init_functions_1_3(rb_cGlimpl);
+	gl_init_functions_1_4(rb_cGlimpl);
+	gl_init_functions_1_5(rb_cGlimpl);
+	gl_init_functions_2_0(rb_cGlimpl);
+	gl_init_functions_2_1(rb_cGlimpl);
+	gl_init_functions_3_0(rb_cGlimpl);
+	gl_init_functions_ext_3dfx(rb_cGlimpl);
+	gl_init_functions_ext_arb(rb_cGlimpl);
+	gl_init_functions_ext_ati(rb_cGlimpl);
+	gl_init_functions_ext_ext(rb_cGlimpl);
+	gl_init_functions_ext_gremedy(rb_cGlimpl);
+	gl_init_functions_ext_nv(rb_cGlimpl);
+	gl_init_buffer(module);
 
-  gl_init_buffer();
 
-	module = rb_define_module("Gl");
+	rb_define_method(rb_cGlimpl, "is_available?", IsAvailable, 1);
+	rb_define_method(rb_cGlimpl, "is_supported?", IsAvailable, 1);
+	rb_define_method(rb_cGlimpl, "extension_available?", IsAvailable, 1);
+	rb_define_method(rb_cGlimpl, "extension_supported?", IsAvailable, 1);
+	rb_define_method(rb_cGlimpl, "version_available?", IsAvailable, 1);
+	rb_define_method(rb_cGlimpl, "version_supported?", IsAvailable, 1);
 
-  /* TODO remove */
-	rb_define_const(module, "BINDINGS_VERSION", version);
-	rb_define_const(module, "RUBY_OPENGL_VERSION", version);
 
-	gl_init_error(module);
-	gl_init_enums(module);
-	gl_init_functions_1_0__1_1(module);
-	gl_init_functions_1_2(module);
-	gl_init_functions_1_3(module);
-	gl_init_functions_1_4(module);
-	gl_init_functions_1_5(module);
-	gl_init_functions_2_0(module);
-	gl_init_functions_2_1(module);
-	gl_init_functions_3_0(module);
-	gl_init_functions_ext_3dfx(module);
-	gl_init_functions_ext_arb(module);
-	gl_init_functions_ext_ati(module);
-	gl_init_functions_ext_ext(module);
-	gl_init_functions_ext_gremedy(module);
-	gl_init_functions_ext_nv(module);
-
-	rb_define_module_function(module, "is_available?", IsAvailable, 1);
-	rb_define_module_function(module, "is_supported?", IsAvailable, 1);
-	rb_define_module_function(module, "extension_available?", IsAvailable, 1);
-	rb_define_module_function(module, "extension_supported?", IsAvailable, 1);
-	rb_define_module_function(module, "version_available?", IsAvailable, 1);
-	rb_define_module_function(module, "version_supported?", IsAvailable, 1);
+  rb_define_module_function(module, "implementation", rb_gl_s_get_implementation, 0);
+  rb_define_module_function(module, "implementation=", rb_gl_s_set_implementation, 1);
+
+  g_default_glimpl = Qnil;
+  rb_global_variable(&g_default_glimpl);
 }

data/ext/opengl/gl_buffer.c

@@ -1,18 +1,25 @@
 #include "common.h"
 
-static GLvoid * (APIENTRY * fptr_glMapBuffer)(GLenum,GLenum);
-static GLboolean (APIENTRY * fptr_glUnmapBuffer)(GLenum);
-
 struct buffer {
-	GLenum target;
-	void *ptr;
-	GLsizeiptr len;
+  VALUE glimpl;
+  void *ptr;
+  GLsizeiptr len;
+  GLenum target;
 };
 
+static void
+buffer_mark(void *ptr)
+{
+  struct buffer *this = ptr;
+  rb_gc_mark(this->glimpl);
+}
+
 static void
 buffer_free(void *ptr) {
-	struct buffer *buf = ptr;
-	LOAD_GL_FUNC(glUnmapBuffer, "1.5");
+  struct buffer *buf = ptr;
+  VALUE obj = buf->glimpl;
+  DECL_GL_FUNC_PTR(GLboolean,glUnmapBuffer,(GLenum));
+  LOAD_GL_FUNC(glUnmapBuffer, "1.5");
 
 	if (buf->ptr != NULL)
 		fptr_glUnmapBuffer(buf->target);
@@ -26,16 +33,31 @@ buffer_memsize(const void *ptr) {
 
 static const rb_data_type_t buffer_type = {
 	"OpenGL/buffer",
-	{ NULL, buffer_free, buffer_memsize, },
+	{ buffer_mark, buffer_free, buffer_memsize, },
 };
 
 VALUE
-rb_gl_buffer_s_map(VALUE klass, VALUE _target, VALUE _access) {
-	struct buffer *buf = ALLOC(struct buffer);
+rb_gl_buffer_s_map(int argc, VALUE *argv, VALUE klass)
+{
+  VALUE _target;
+  VALUE _access;
+  VALUE obj;
+  struct buffer *buf;
+  DECL_GL_FUNC_PTR(GLvoid *,glMapBuffer,(GLenum,GLenum));
+
+  rb_scan_args(argc, argv, "21", &_target, &_access, &obj);
+  if(NIL_P(obj)){
+    obj = g_default_glimpl;
+  } else if(!rb_obj_is_kind_of(obj, rb_cGlimpl)){
+    rb_raise(rb_eArgError, "wrong argument type %s (expected kind of Gl::Implementation)", rb_obj_classname(obj));
+  }
+
+	buf = ALLOC(struct buffer);
 	LOAD_GL_FUNC(glMapBuffer, "1.5");
 
 	buf->target = RUBY2GLENUM(_target);
-	buf->len		= 0;
+	buf->len = 0;
+  buf->glimpl = obj;
 
 	buf->ptr = fptr_glMapBuffer(buf->target, RUBY2GLENUM(_access));
 
@@ -104,10 +126,14 @@ rb_gl_buffer_target(VALUE self) {
 
 static VALUE
 rb_gl_buffer_unmap(VALUE self) {
-	struct buffer *buf;
-	LOAD_GL_FUNC(glUnmapBuffer, "1.5");
+  struct buffer *buf;
+  VALUE obj;
+  DECL_GL_FUNC_PTR(GLboolean,glUnmapBuffer,(GLenum));
 
-	TypedData_Get_Struct(self, struct buffer, &buffer_type, buf);
+  TypedData_Get_Struct(self, struct buffer, &buffer_type, buf);
+  obj = buf->glimpl;
+
+  LOAD_GL_FUNC(glUnmapBuffer, "1.5");
 
 	if (!buf->ptr)
 		return self;
@@ -160,12 +186,11 @@ rb_gl_buffer_write(int argc, VALUE *argv, VALUE self) {
 }
 
 void
-gl_init_buffer(void) {
-	VALUE mOpenGL = rb_path2class("OpenGL");
-	VALUE cBuffer = rb_define_class_under(mOpenGL, "Buffer", rb_cObject);
+gl_init_buffer(VALUE module) {
+	VALUE cBuffer = rb_define_class_under(module, "Buffer", rb_cObject);
 
 	rb_undef_alloc_func(cBuffer);
-	rb_define_singleton_method(cBuffer, "map", rb_gl_buffer_s_map, 2);
+	rb_define_singleton_method(cBuffer, "map", rb_gl_buffer_s_map, -1);
 
 	rb_define_method(cBuffer, "addr", rb_gl_buffer_addr, 0);
 	rb_define_method(cBuffer, "length", rb_gl_buffer_length, 0);

data/ext/opengl/glimpl.c

@@ -0,0 +1,187 @@
+#include "common.h"
+
+#ifdef HAVE_DLFCN_H
+#include <dlfcn.h>
+#endif
+#ifdef HAVE_WINDOWS_H
+#include <windows.h>
+#endif
+
+VALUE rb_cGlimpl;
+
+static void *gl_load_library(const char *name)
+{
+  void *dl = NULL;
+
+#if defined(HAVE_DLFCN_H)
+  dl = dlopen(name, RTLD_LAZY | RTLD_LOCAL
+#if defined(RTLD_FIRST)
+    | RTLD_FIRST
+#endif
+  );
+  if (dl == NULL)
+    rb_raise(rb_eLoadError,"Can't load OpenGL library %s: %s", name, dlerror());
+
+#elif defined(HAVE_WINDOWS_H)
+  dl = LoadLibrary(name);
+  if (dl == NULL) {
+    char error_text[999] = "LoadLibrary() error";
+    FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_MAX_WIDTH_MASK,
+                NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+                (LPTSTR)&error_text, sizeof(error_text), NULL);
+    rb_raise(rb_eLoadError,"Can't load OpenGL library %s: %s", name, error_text);
+  }
+#else
+#error No loading mechanism available
+#endif
+
+  return dl;
+}
+
+static void *gl_load_symbol(void *dl, const char *name, int raise)
+{
+  void *fptr = NULL;
+
+#if defined(HAVE_DLFCN_H)
+  fptr = dlsym(dl, name);
+  if (fptr == NULL && raise)
+    rb_raise(rb_eNotImpError,"Function %s is not available on this system: %s",name, dlerror());
+
+#elif defined(HAVE_WINDOWS_H)
+  fptr = GetProcAddress(dl, name);
+  if (fptr == NULL && raise){
+    char error_text[999] = "GetProcAddress() error";
+    FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_MAX_WIDTH_MASK,
+                NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+                (LPTSTR)&error_text, sizeof(error_text), NULL);
+    rb_raise(rb_eNotImpError,"Function %s is not available on this system: %s",name, error_text);
+  }
+#else
+#error No loading mechanism available
+#endif
+
+  return fptr;
+}
+
+static void gl_close_library(void *dl)
+{
+#if defined(HAVE_DLFCN_H)
+  dlclose(dl);
+#elif defined(HAVE_WINDOWS_H)
+  FreeLibrary(dl);
+#else
+#error No loading mechanism available
+#endif
+}
+
+
+static struct glimpl *
+rb_glimpl_struct( VALUE self )
+{
+  return DATA_PTR(self);
+}
+
+static void *load_gl_function(VALUE self, const char *name, int raise)
+{
+  struct glimpl *this = rb_glimpl_struct(self);
+  void *func_ptr = NULL;
+
+  if(this->fptr_GetProcAddress){
+    func_ptr = this->fptr_GetProcAddress(name);
+  }
+
+  if(func_ptr == NULL){
+    func_ptr = gl_load_symbol(this->dl, name, 0);
+  }
+
+  if(func_ptr == NULL)
+  {
+    /* prepend a '_' for the Unix C symbol mangling convention */
+    char *symbol_name = ALLOC_N(char, strlen(name) + 2);
+    symbol_name[0] = '_';
+    strcpy(symbol_name + 1, name);
+    func_ptr = gl_load_symbol(this->dl, symbol_name, 0);
+    xfree(symbol_name);
+  }
+
+  if(func_ptr == NULL && raise == 1)
+    rb_raise(rb_eNotImpError,"Function %s is not available on this system",name);
+
+  return func_ptr;
+}
+
+static void
+rb_glimpl_mark( struct glimpl *this )
+{
+  int i;
+  rb_gc_mark(this->current_sel_buffer);
+  rb_gc_mark(this->current_feed_buffer);
+  rb_gc_mark(this->Vertex_ptr);
+  rb_gc_mark(this->Normal_ptr);
+  rb_gc_mark(this->Color_ptr);
+  rb_gc_mark(this->Index_ptr);
+  rb_gc_mark(this->TexCoord_ptr);
+  rb_gc_mark(this->EdgeFlag_ptr);
+  rb_gc_mark(this->FogCoord_ptr);
+  rb_gc_mark(this->SecondaryColor_ptr);
+  rb_gc_mark(this->error_checking);
+  rb_gc_mark(this->inside_begin_end);
+
+  for (i=0;i<_MAX_VERTEX_ATTRIBS;i++){
+    rb_gc_mark(this->VertexAttrib_ptr[i]);
+  }
+}
+
+static void rb_glimpl_free( struct glimpl *this )
+{
+  if(this->dl) gl_close_library(this->dl);
+  this->dl = NULL;
+  xfree(this);
+}
+
+static VALUE
+rb_glimpl_s_open(int argc, VALUE *argv, VALUE klass)
+{
+  VALUE self;
+  struct glimpl *this;
+  VALUE dl_name;
+  VALUE proc_address_function;
+  char *p_dl_name;
+
+  rb_scan_args(argc, argv, "11", &dl_name, &proc_address_function);
+
+  p_dl_name = StringValueCStr(dl_name);
+
+  self = Data_Make_Struct( klass, struct glimpl, rb_glimpl_mark, rb_glimpl_free, this );
+
+  this->error_checking = Qtrue;
+  this->inside_begin_end = Qfalse;
+  this->load_gl_function = load_gl_function;
+  this->dl = gl_load_library(p_dl_name);
+
+  if( NIL_P(proc_address_function) ){
+    this->fptr_GetProcAddress = NULL;
+  } else {
+    char *p_proc_address_function = StringValueCStr(proc_address_function);
+    this->fptr_GetProcAddress = gl_load_symbol(this->dl, p_proc_address_function, 1);
+  }
+
+  return self;
+}
+
+static VALUE rb_glimpl_close(VALUE self)
+{
+  struct glimpl *this = rb_glimpl_struct(self);
+  if(this->dl) gl_close_library(this->dl);
+  this->dl = NULL;
+  return Qnil;
+}
+
+void gl_init_glimpl(VALUE module)
+{
+  rb_cGlimpl = rb_define_class_under(module, "Implementation", rb_cObject);
+
+  rb_undef_alloc_func(rb_cGlimpl);
+  rb_define_singleton_method(rb_cGlimpl, "open", rb_glimpl_s_open, -1);
+  rb_define_method(rb_cGlimpl, "close", rb_glimpl_close, 0);
+}