roglew 0.1.4 → 0.2.1

data/lib/roglew/platform/windows/gl.rb

@@ -0,0 +1,9 @@
+module Roglew
+  module GL
+    LIBRARY = 'opengl32'.freeze
+
+    def self.platform_module
+      WGL
+    end
+  end
+end

data/lib/roglew/{native → platform/windows}/kernel32.rb

@@ -1,9 +1,9 @@
-module Roglew
-	module Kernel32
-		extend ::FFI::Library
-		ffi_lib 'kernel32'
-		ffi_convention :stdcall
-
-		attach_function :GetLastError, [], :uint
-	end
+module Roglew
+	module Kernel32
+		extend ::FFI::Library
+		ffi_lib 'kernel32'
+		ffi_convention :stdcall
+
+		attach_function :GetLastError, [], :uint
+	end
 end

data/lib/roglew/platform/windows/render_context.rb

@@ -0,0 +1,100 @@
+module Roglew
+  class RenderContext
+    #if version not passed, builds context with latest version
+    def initialize(hdc, version = nil)
+      @hdc = hdc
+
+      initialize_pixel_format
+
+      @hrc, old_hrc = wglCreateContext(@hdc), nil
+
+      bind do
+        #check version
+        max_version = glGetString(GL::VERSION).split('.', 2).map!(&:to_i)
+
+        #if max OpelGL version is less than requested, give error
+        raise ArgumentError, "unsupported version #{version.join('.')}" if version && (max_version <=> version < 0)
+
+        @version = version || max_version
+        @loaded_extensions = Set.new
+        extension_list(:core).each { |ext| load_extension(ext) }
+        old_hrc, @hrc = @hrc, upgrade_context if @version[0] > 2
+        extension_list(:gl, :platform).each { |ext| load_extension(ext) }
+      end
+
+      @attribs = Set[GL::DITHER, GL::MULTISAMPLE]
+
+      wglDeleteContext(old_hrc) if old_hrc
+
+      self.class.finalize(self, @hrc)
+    end
+
+    alias_method :get_proc_address, :wglGetProcAddress
+
+    def swap_buffers
+      Gdi32.SwapBuffers(@hdc)
+    end
+
+    def unbind
+      wglMakeCurrent(nil, nil)
+    end
+
+    #------
+    private
+
+    def initialize_pixel_format
+      pfd = Gdi32::PIXELFORMATDESCRIPTOR.new
+      pfd.dwFlags = [:DOUBLEBUFFER, :SUPPORT_OPENGL, :DRAW_TO_WINDOW]
+      pfd.cColorBits = 24
+      pfd.cAlphaBits = 8
+      pfd.cDepthBits = 32
+
+      pxfmt = Gdi32.ChoosePixelFormat(@hdc, pfd)
+      raise InvalidPixelFormatError,
+            "(ChoosePixelFormat) GetLastError returned #{Kernel32.GetLastError}" if pxfmt == 0
+
+      #Can't use DescribePixelFormat. Blows up remote desktop
+      #
+      #max_pfd = Gdi32.DescribePixelFormat(@hdc, pxfmt, Gdi32::PIXELFORMATDESCRIPTOR.size, pfd)
+      #puts "#\t" + Gdi32::PIXELFORMATDESCRIPTOR.members.select { |x| x != :nSize }.join("\t")
+      #max_pfd.times do |i|
+      #	pfd2 = Gdi32::PIXELFORMATDESCRIPTOR.new
+      #	Gdi32.DescribePixelFormat(@hdc, i+1, Gdi32::PIXELFORMATDESCRIPTOR.size, pfd2)
+      #	puts "#{i + 1}\t" + Gdi32::PIXELFORMATDESCRIPTOR.
+      #      members.select { |x| x != :nSize }.map { |x| pfd2.send(x).inspect }.join("\t")
+      #end
+
+      raise InvalidPixelFormatError,
+            "(SetPixelFormat) GetLastError returned #{Kernel32.GetLastError}" unless Gdi32.SetPixelFormat(@hdc, pxfmt, pfd)
+    end
+
+    def upgrade_context
+      load_extension :WGL_ARB_create_context
+
+      raise 'undefined function wglCreateContextAttribsARB' unless respond_to?(:wglCreateContextAttribsARB)
+
+      attribs = [WGL::CONTEXT_MAJOR_VERSION_ARB, @version[0],
+                 WGL::CONTEXT_MINOR_VERSION_ARB, @version[1],
+                 WGL::CONTEXT_FLAGS_ARB,         WGL::CONTEXT_FORWARD_COMPATIBLE_BIT_ARB,
+                 0]
+      ptr_attribs = FFI::MemoryPointer.new(:int, attribs.length)
+      ptr_attribs.write_array_of_int(attribs)
+
+      wglCreateContextAttribsARB(@hdc, nil, ptr_attribs)
+    end
+
+    def extension_list_platform
+      if (func = get_function(:wglGetExtensionsStringARB, [:pointer], :string))
+        func.(@hdc)
+      elsif (func = get_function(:wglGetExtensionsStringEXT, [], :string))
+        func.()
+      else
+        ''
+      end.split.map!(&:to_sym)
+    end
+
+    def make_current
+      wglMakeCurrent(@hdc, @hrc)
+    end
+  end
+end

data/lib/roglew/{native → platform/windows}/wgl.rb

@@ -1,7 +1,6 @@
 module Roglew
   module WGL
     include GL::Native
-    extend NativeObject
 
     ENCODING = 'W'
 
@@ -131,8 +130,12 @@ module Roglew
       [ :UseFontOutlines, "wglUseFontOutlines#{ENCODING}", [:pointer, :uint, :uint, :uint, :float, :float, :int, GLYPHMETRICSFLOAT.ptr], :bool ]
     ].each do |args|
       args[1, 0] = "wgl#{args[0]}" if args.length == 3
-      attach_function *args
-      RenderContext.class_eval "def wgl#{args[0]}(*args) WGL.#{args[0]}(*args) end"
+      func = attach_function *args
+      RenderContext.send(:define_method, args[1]) { |*parms| func.call(*parms) }
+    end
+
+    class << self
+      alias_method :delete_context, :DeleteContext
     end
   end
 end

data/lib/roglew/platform/windows.rb

@@ -0,0 +1,5 @@
+%w'kernel32
+   gdi32
+   wgl
+   render_context
+'.each { |f| require "roglew/platform/windows/#{f}" }

data/lib/roglew/render_context.rb

@@ -5,63 +5,37 @@ module Roglew
 
     @registered_extensions = {}
 
-    #if version not passed, builds context with latest version
-    def initialize(hdc, version = nil)
-      @hdc = hdc
-
-      initialize_pixel_format
-
-      @hrc, old_hrc = wglCreateContext(@hdc), nil
-
-      bind do
-        #check version
-        max_version = glGetString(GL::VERSION).split('.', 2).map!(&:to_i)
-
-        #if max OpelGL version is less than requested, give error
-        raise ArgumentError, "unsupported version #{version.join('.')}" if version && (max_version <=> version < 0)
-
-        @version = version || max_version
-        @loaded_extensions = Set.new
-        core_extension_list.each { |ext| load_extension(ext) }
-
-        old_hrc, @hrc = @hrc, upgrade_context if @version[0] > 2
-
-        (gl_extension_list + platform_extension_list).each { |ext| load_extension(ext) }
-      end
-
-      @attribs = Set[GL::DITHER, GL::MULTISAMPLE]
-
-      wglDeleteContext(old_hrc) if old_hrc
-
-      self.class.finalize(self, @hrc)
-    end
-
-    def self.finalize(obj, hrc)
+    def self.finalize(obj, *args)
       ObjectSpace.define_finalizer(obj, proc do
-        WGL.DeleteContext(hrc) #assumes that context was unbound
+        puts 'releasing a render context'
+        GL.platform_module.delete_context(*args)
       end)
     end
 
-    def load_extension(ext)
-      ext = ext.to_sym
-      @loaded_extensions << ext
+    def self.register_extensions(extensions)
+      extensions = Hash[extensions.map { |k, v| [k.to_sym, v] }]
+      @registered_extensions.merge!(extensions)
+      nil
+    end
 
-      unless Object.const_defined?(ext)
-        reg = self.class.instance_variable_get(:@registered_extensions)
-        filename = reg[ext] || File.expand_path("../extensions/#{ext}.rb", __FILE__)
-        require filename if File.exists?(filename)
-      end
+    def self.unregister_extensions(*extensions)
+      extensions.map! { |e| e.to_sym }.each { |e| @registered_extensions.delete(e) }
+      nil
+    end
 
-      return unless Object.const_defined?(ext)
-      mod = Object.const_get(ext)
-      return unless mod.const_defined?(:RenderContext)
-      mod = mod::RenderContext
+    def begin(mode)
+      glBegin(mode)
+      return unless block_given?
+      yield
+      glEnd
+    end
 
-      singleton_class.send(:include, mod) if mod
+    %w'points lines line_strip line_loop triangles triangle_strip triangle_fan quads quad_strip polygon'.each do |v|
+      class_eval("def #{v}(&block) self.begin(GL::#{v.upcase}, &block) end")
     end
 
     def bind
-      wglMakeCurrent(@hdc, @hrc)
+      make_current
       if block_given?
         yield
         unbind
@@ -69,37 +43,16 @@ module Roglew
       self
     end
 
-    def unbind
-      wglMakeCurrent(nil, nil)
+    def clear(*flags)
+      glClear(flags.reduce(&:|))
     end
 
-    def version; @version.dup end
-
-    def loaded_extensions; @loaded_extensions.dup end
-
-    def supports?(extension); !!@loaded_extensions[extension] end
-
     def create_texture2d(*args)
       Texture2d.new(self, *args)
     end
 
     def_object :Textures
 
-    def begin(mode)
-      glBegin(mode)
-      return unless block_given?
-      yield
-      glEnd
-    end
-
-    %w'points lines line_strip line_loop triangles triangle_strip triangle_fan quads quad_strip polygon'.each do |v|
-      class_eval("def #{v}(&block) self.begin(GL::#{v.upcase}, &block) end")
-    end
-
-    def clear(*flags)
-      glClear(flags.reduce(&:|))
-    end
-
     def disable(*caps)
       caps = Set[*caps] & @attribs
       caps.each do |cap|
@@ -120,12 +73,10 @@ module Roglew
       disable(*caps)
     end
 
-    def get_errors
-      errors = []
-      while (error = glGetError) != 0
-        errors << GL::ERROR[error] || error
-      end
-      errors
+    def extension_list(*types)
+      list = types.flat_map { |type| send("extension_list_#{type}") }
+      list.uniq!
+      list
     end
 
     def get_integers(pname, count = 1)
@@ -135,95 +86,72 @@ module Roglew
       count == 1 ? result[0] : result
     end
 
-    def swap_buffers
-      Gdi32.SwapBuffers(@hdc)
-    end
-
-    def tex_parameter(target, pname, *params)
-      params.flatten!
-      type = params.all? { |param| param.is_a? Integer } ? 'int' : 'float'
-      ptr = FFI::MemoryPointer.new(type.to_sym, params.length)
-      ptr.send("write_array_of_#{type}", params)
-      send("glTexParameter#{type[0]}v", target, pname, ptr)
+    def get_errors
+      errors = []
+      while (error = glGetError) != 0
+        errors << GL::ERROR[error] || error
+      end
+      errors
     end
 
-    def self.register_extensions(extensions)
-      extensions = Hash[extensions.map { |k, v| [k.to_sym, v] }]
-      @registered_extensions.merge!(extensions)
-      nil
+    def get_function(function_name, parameters, return_type)
+      ptr = get_proc_address(function_name.to_s)
+      return nil if ptr.null?
+      return_type = GL.find_type(return_type) || return_type
+      parameters = parameters.map { |p| GL.find_type(p) || p }
+      FFI::Function.new(return_type, parameters, ptr, convention: :stdcall)
     end
 
-    def self.unregister_extensions(*extensions)
-      extensions.map! { |e| e.to_sym }.each { |e| @registered_extensions.delete(e) }
-      nil
-    end
-
-    #------
-    private
+    def load_extension(ext)
+      ext = ext.to_sym
+      @loaded_extensions << ext
 
-    def initialize_pixel_format
-      pfd = Gdi32::PIXELFORMATDESCRIPTOR.new
-      pfd.dwFlags = [:DOUBLEBUFFER, :SUPPORT_OPENGL, :DRAW_TO_WINDOW]
-      pfd.cColorBits = 24
-      pfd.cAlphaBits = 8
-      pfd.cDepthBits = 32
+      unless Object.const_defined?(ext)
+        reg = self.class.instance_variable_get(:@registered_extensions)
+        filename = reg[ext] || File.expand_path("../extensions/#{ext}.rb", __FILE__)
+        require filename if File.exists?(filename)
+      end
 
-      pxfmt = Gdi32.ChoosePixelFormat(@hdc, pfd)
-      raise InvalidPixelFormatError,
-            "(ChoosePixelFormat) GetLastError returned #{Kernel32.GetLastError}" if pxfmt == 0
+      return unless Object.const_defined?(ext)
+      mod = Object.const_get(ext)
+      return unless mod.const_defined?(:RenderContext)
+      mod = mod::RenderContext
+      return unless mod
 
-      #Can't use DescribePixelFormat. Blows up remote desktop
-      #
-      #max_pfd = Gdi32.DescribePixelFormat(@hdc, pxfmt, Gdi32::PIXELFORMATDESCRIPTOR.size, pfd)
-      #puts "#\t" + Gdi32::PIXELFORMATDESCRIPTOR.members.select { |x| x != :nSize }.join("\t")
-      #max_pfd.times do |i|
-      #	pfd2 = Gdi32::PIXELFORMATDESCRIPTOR.new
-      #	Gdi32.DescribePixelFormat(@hdc, i+1, Gdi32::PIXELFORMATDESCRIPTOR.size, pfd2)
-      #	puts "#{i + 1}\t" + Gdi32::PIXELFORMATDESCRIPTOR.
-      #      members.select { |x| x != :nSize }.map { |x| pfd2.send(x).inspect }.join("\t")
-      #end
+      singleton_class.send(:include, mod)
 
-      raise InvalidPixelFormatError,
-            "(SetPixelFormat) GetLastError returned #{Kernel32.GetLastError}" unless Gdi32.SetPixelFormat(@hdc, pxfmt, pfd)
+      return unless mod.respond_to? :functions
+      mod.functions.each do |name, parameters, ret_type|
+        function = get_function(name, parameters, ret_type)
+        define_singleton_method(name) { |*a| function.call(*a) } if function
+      end
     end
 
-    def upgrade_context
-      load_extension(:WGL_ARB_create_context)
-
-      raise 'undefined function wglCreateContextAttribsARB' unless respond_to?(:wglCreateContextAttribsARB)
+    def loaded_extensions; @loaded_extensions.dup end
 
-      attribs = [WGL::CONTEXT_MAJOR_VERSION_ARB, @version[0],
-                 WGL::CONTEXT_MINOR_VERSION_ARB, @version[1],
-                 WGL::CONTEXT_FLAGS_ARB,         WGL::CONTEXT_FORWARD_COMPATIBLE_BIT_ARB,
-                 0]
-      ptr_attribs = FFI::MemoryPointer.new(:int, attribs.length)
-      ptr_attribs.write_array_of_int(attribs)
+    def supports?(extension); !!@loaded_extensions[extension] end
 
-      wglCreateContextAttribsARB(@hdc, nil, ptr_attribs)
+    def tex_parameter(target, pname, *params)
+      params.flatten!
+      type = params.all? { |param| param.is_a? Integer } ? 'int' : 'float'
+      ptr = FFI::MemoryPointer.new(type.to_sym, params.length)
+      ptr.send("write_array_of_#{type}", params)
+      send("glTexParameter#{type[0]}v", target, pname, ptr)
     end
 
-    def core_extension_list
+    def version; @version.dup end
+
+    private
+    def extension_list_core
       Dir["#{File.expand_path('../extensions', __FILE__)}/GL_VERSION_*.rb"].
         map! { |f| File.basename(f, '.rb') }.
         select! { |f| (f.gsub('GL_VERSION_', '').split('_', 2).map!(&:to_i) <=> @version) <= 0 }
     end
 
-    def gl_extension_list
-      if @version[0] < 3
-        glGetString(GL::EXTENSIONS).split
-      else
-        get_integers(GL::NUM_EXTENSIONS).times.map { |i| glGetStringi(GL::EXTENSIONS, i) }
-      end.map!(&:to_sym)
-    end
-
-    def platform_extension_list
-      if (func = WGL.get_function(:wglGetExtensionsStringARB, [:pointer], :string))
-        func.(@hdc)
-      elsif (func = WGL.get_function(:wglGetExtensionsStringEXT, [], :string))
-        func.()
-      else
-        ''
-      end.split.map!(&:to_sym)
+    def extension_list_gl
+      (@version[0] < 3 ?
+        glGetString(GL::EXTENSIONS).split :
+        get_integers(GL::NUM_EXTENSIONS).times.map { |i| glGetStringi(GL::EXTENSIONS, i) }).map!(&:to_sym)
     end
   end
 end

data/lib/roglew.rb

@@ -1,31 +1,35 @@
 #Raw Glue - the Ruby OpenGL and Extensions Wrapper
 
-module Roglew
-  VERSION = '0.1.4'
-end
-
 #external dependencies
-%w'
-  set
-  ffi
-  facets/module/module_load
-  facets/string/camelcase
-  facets/string/snakecase
+%w'set
+   ffi
+   facets/module/module_load
+   facets/string/camelcase
+   facets/string/snakecase
+   facets/platform
 '.each { |f| require f }
 
+module Roglew
+  VERSION = '0.2.1'
+
+  PLATFORM = case
+               when Platform.local.windows? then 'windows'
+               when Platform.local.linux?   then 'linux'
+               else raise 'Unknown platform'
+             end
+end
+
 #internal files
-%w'
-  contexts/base
-  contexts/deferred
-  contexts/immediate
-  ext/ffi_struct_ext
-  errors
-  native/kernel32
-  native/gdi32
-  contextual
-  gl_extension
-  gl_object
-  native/native_object
-  native/gl
-  render_context
+%W'ext/ffi_struct_ext
+   contexts/base
+   contexts/deferred
+   contexts/immediate
+   errors
+   contextual
+   gl_extension
+   gl_object
+   platform/#{Roglew::PLATFORM}/gl
+   gl
+   platform/#{Roglew::PLATFORM}
+   render_context
 '.each { |f| require "roglew/#{f}" }