danabr75-opengl 0.10.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);
+}

data/ext/opengl/glimpl.h

@@ -0,0 +1,47 @@
+#ifndef _GLIMPL_H_
+#define _GLIMPL_H_
+
+#ifndef GLFUNC_MAGIC_START
+#include "fptr_struct.h"
+#endif
+
+#define GET_GLIMPL_VARIABLE(_name_) \
+  (((struct glimpl *)DATA_PTR(obj))->_name_)
+
+#define SET_GLIMPL_VARIABLE(_name_,_val_) \
+  ((struct glimpl *)DATA_PTR(obj))->_name_ = (_val_)
+
+/* at least GL_MAX_VERTEX_ATTRIBS - usually 16 or 32 on today's high-end cards */
+#define _MAX_VERTEX_ATTRIBS 64
+
+extern VALUE g_default_glimpl;
+
+struct glimpl {
+  struct glfunc_ptrs glfuncs;
+
+  int opengl_version[2]; /* major, minor */
+  char *opengl_extensions;
+
+  void * (* load_gl_function)(VALUE self, const char *name,int raise);
+
+  VALUE current_feed_buffer;
+  VALUE current_sel_buffer;
+  VALUE Vertex_ptr;
+  VALUE Normal_ptr;
+  VALUE Color_ptr;
+  VALUE Index_ptr;
+  VALUE TexCoord_ptr;
+  VALUE EdgeFlag_ptr;
+  VALUE FogCoord_ptr; /* OpenGL 1.4 */
+  VALUE SecondaryColor_ptr; /* OpenGL 1.4 */
+  VALUE VertexAttrib_ptr[_MAX_VERTEX_ATTRIBS];
+
+  VALUE error_checking;
+  VALUE inside_begin_end;
+
+  void *dl;
+  void * (APIENTRY * fptr_GetProcAddress)(const char *name);
+};
+
+
+#endif /* _GLIMPL_H_ */

data/ext/opengl/opengl.c

@@ -0,0 +1,9 @@
+#include "common.h"
+
+void Init_gl(VALUE);
+
+void Init_opengl() {
+	VALUE module = rb_define_module("Gl");
+
+	Init_gl(module);
+}

data/lib/gl.rb

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

data/lib/opengl.rb

@@ -0,0 +1,79 @@
+#
+# Copyright (C) 2006 Peter McLain <peter.mclain@gmail.com>
+# Copyright (C) 2007 Jan Dvorak <jan.dvorak@kraxnet.cz>
+#
+# This program is distributed under the terms of the MIT license.
+# See the included MIT-LICENSE file for the terms of this license.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+# This module provides access to the GL,GLU and GLUT methods and constants
+# in the way that they were available in previous versions of ruby-opengl.
+#
+# Thanks to Ilmari Heikkinen for a previous "reversed" version of this code,
+# and to Bill Kelly for a version before that one.
+
+begin
+  RUBY_VERSION =~ /(\d+.\d+)/
+  require "opengl/#{$1}/opengl"
+rescue LoadError
+  require 'opengl/opengl'
+end
+
+require 'opengl/implementation'
+require 'opengl/bindings_version'
+
+module Gl
+  meths = Gl::Implementation.instance_methods.select{|mn| mn=~/^gl/ }
+  meths += %w[is_available? is_supported?
+              extension_available? extension_supported?
+              version_available? version_supported?
+              enable_error_checking disable_error_checking is_error_checking_enabled?
+             ]
+
+  meths.each do |mn|
+    define_singleton_method(mn) do |*args,&block|
+      begin
+        implementation.send(mn, *args, &block)
+      rescue
+      end
+    end
+    define_method(mn) do |*args,&block|
+      begin
+        implementation.send(mn, *args, &block)
+      rescue
+      end
+    end
+    private mn
+  end
+end
+
+# (Gl.)glVertex -> GL.Vertex
+# (Gl::)GL_TRUE -> GL::TRUE
+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]/
+    const_set( n, Gl.const_get( cn ) )
+  end
+
+  Gl.methods( false ).each do |mn|
+    n = mn.to_s.sub(/^gl/,'')
+    alias_method( n, mn )
+    public( n )
+  end
+end
+
+OpenGL = Gl

data/lib/opengl/bindings_version.rb

@@ -0,0 +1,4 @@
+module Gl
+  BINDINGS_VERSION = '0.10.0'
+  RUBY_OPENGL_VERSION = BINDINGS_VERSION
+end

data/lib/opengl/implementation.rb

@@ -0,0 +1,38 @@
+
+module Gl
+  if RUBY_PLATFORM =~ /mingw|mswin/i
+    class ImplementationWindows < Implementation
+      DLPATH = "opengl32.dll"
+      def self.open
+        super(DLPATH, "wglGetProcAddress")
+      end
+    end
+
+    Gl::DefaultImplementation = ImplementationWindows
+
+  elsif RUBY_PLATFORM =~ /darwin/i
+    class ImplementationOSX < Implementation
+      DLPATH = "/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL"
+      def self.open
+        super(DLPATH)
+      end
+    end
+
+    Gl::DefaultImplementation = ImplementationOSX
+
+  else
+    class ImplementationGLX < Implementation
+      DLPATH = "libGL.so"
+      def self.open
+        begin
+          super(DLPATH, "glXGetProcAddress")
+        rescue NotImplementedError
+          super(DLPATH, "glXGetProcAddressARB")
+        end
+      end
+    end
+
+    Gl::DefaultImplementation = ImplementationGLX
+
+  end
+end

data/lib/opengl/test_case.rb

@@ -0,0 +1,86 @@
+#
+# Copyright (C) 2007 Jan Dvorak <jan.dvorak@kraxnet.cz>
+#
+# This program is distributed under the terms of the MIT license.
+# See the included MIT-LICENSE file for the terms of this license.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+
+require 'rubygems'
+begin
+  gem 'minitest'
+rescue Gem::LoadError
+end
+
+require 'minitest/autorun'
+require 'gl'
+require 'glu'
+require 'glut'
+require 'matrix'
+
+include Gl
+include Glu
+include Glut
+
+Gl.enable_error_checking
+
+module OpenGL; end
+
+class OpenGL::TestCase < MiniTest::Unit::TestCase
+
+  WINDOW_SIZE = 512
+
+  glutInit
+  glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA | GLUT_STENCIL |
+                      GLUT_ACCUM | GLUT_ALPHA)
+
+  def setup
+    glutInitWindowPosition 1, 1
+    glutInitWindowSize WINDOW_SIZE, WINDOW_SIZE
+    @window = glutCreateWindow "test"
+
+    glPushAttrib GL_ALL_ATTRIB_BITS
+    glPushClientAttrib GL_CLIENT_ALL_ATTRIB_BITS
+    glMatrixMode GL_MODELVIEW
+    glLoadIdentity
+    glMatrixMode GL_PROJECTION
+    glLoadIdentity
+
+    glClearColor 0, 0, 0, 0
+    glClear GL_COLOR_BUFFER_BIT
+  end
+
+  def teardown
+    glPopAttrib
+    glPopClientAttrib
+    glRenderMode GL_RENDER
+
+    # in case there is an GL error that escaped error checking routines ...
+    error = glGetError
+    assert_equal 0, error, gluErrorString(error)
+
+    glutDestroyWindow @window
+  end
+
+  def assert_each_in_delta expected, actual, epsilon = 0.01
+    assert_equal expected.length, actual.length, 'array lengths do not match'
+
+    expected.flatten.zip(actual.flatten).each_with_index do |(e, a), i|
+      assert_in_delta e, a, epsilon, "element #{i}"
+    end
+  end
+
+  def supported? funcs
+    Array(funcs).each do |name| # convert to array if it isn't already
+      skip "#{name} is not supported" unless Gl.is_available? name
+    end
+  end
+
+end