roglew 0.2.7 → 0.4.1

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

@@ -1,6 +1,6 @@
 module Roglew
   module GL
-    LIBRARY = 'opengl32'.freeze
+    LIBRARY = "C:\\Windows\\System32\\opengl32.dll".freeze
 
     def self.platform_module
       WGL

data/lib/roglew/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_handle.rb

@@ -0,0 +1,94 @@
+module Roglew
+  class RenderHandle
+    def initialize(hdc, version = nil)
+      @hdc = hdc
+
+      initialize_pixel_format
+
+      @hrc, @loaded_extensions, old_hrc = WGL.CreateContext(@hdc), Set.new, nil
+
+      bind do
+        #check version
+        max_version = glGetString(GL::VERSION).split('.', 2).map!(&:to_i)
+        LOGGER.info("OpenGL #{max_version.join('.')}")
+
+        #if max OpenGL version is less than requested, give error
+        raise ArgumentError, "unsupported version: #{version.join('.')}" if version && (max_version <=> version < 0)
+
+        @version = version || max_version
+        extension_list_core.each { |ext| load_extension(ext) }
+        old_hrc, @hrc = @hrc, upgrade_context if @version[0] > 2
+        extension_list_gl.each { |ext| load_extension(ext) }
+        extension_list_platform.each { |ext| load_extension(ext) }
+      end
+
+      @attribs = Set[GL::DITHER]
+      @attribs << GL::MULTISAMPLE if (@version <=> [1, 3]) >= 0
+
+      WGL.DeleteContext(old_hrc) if old_hrc
+
+      ObjectSpace.define_finalizer(self, self.class.send(:finalize, @hrc))
+    end
+
+    private #-------------------------------------------------------------------------
+
+    def extension_list_platform
+      rc = RenderContext.current
+      if (func = rc.get_function(:wglGetExtensionsStringARB, [:pointer], :string))
+        func.(@hdc)
+      elsif (func = rc.get_function(:wglGetExtensionsStringEXT, [], :string))
+        func.()
+      else
+        ''
+      end.split.map!(&:to_sym)
+    end
+
+    def get_proc_address(function_name)
+      WGL.GetProcAddress(function_name)
+    end
+
+    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
+
+      #NOTE: Don't use DescribePixelFormat.
+
+      return if Gdi32.SetPixelFormat(@hdc, pxfmt, pfd)
+
+      raise InvalidPixelFormatError, "(SetPixelFormat) GetLastError returned #{Kernel32.GetLastError}"
+    end
+
+    def make_current
+      WGL.MakeCurrent(@hdc, @hrc)
+    end
+
+    def remove_current
+      WGL.MakeCurrent(nil, nil)
+    end
+
+    def swap_buffers
+      Gdi32.SwapBuffers(@hdc)
+    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
+  end
+end

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

@@ -4,6 +4,8 @@ module Roglew
 
     ENCODING = 'W'
 
+    WGL_SWAPMULTIPLE_MAX = 16
+
     class RECT < FFI::Struct
       layout :left,   :long,
              :top,    :long,
@@ -81,57 +83,56 @@ module Roglew
     end
 
     [
-      #HGLRC WINAPI wglCreateContext(HDC hdc)
+      # HGLRC WINAPI wglCreateContext(HDC hdc)
       [ :CreateContext, [:pointer], :pointer ],
 
-      #HGLRC wglCreateLayerContext(HDC hdc, int iLayerPlane)
+      # HGLRC wglCreateLayerContext(HDC hdc, int iLayerPlane)
       [ :CreateLayerContext, [:pointer, :int], :pointer ],
 
-      #BOOL wglCopyContext(HGLRC hglrcSrc, HGLRC hglrcDst, UINT mask)
+      # BOOL wglCopyContext(HGLRC hglrcSrc, HGLRC hglrcDst, UINT mask)
       [ :CopyContext, [:pointer, :pointer, :uint], :bool ],
 
-      #BOOL wglDeleteContext(HGLRC hglrc)
+      # BOOL wglDeleteContext(HGLRC hglrc)
       [ :DeleteContext, [:pointer], :bool ],
 
-      #BOOL wglDescribeLayerPlane(HDC hdc, int iPixelFormat, int iLayerPlane, UINT nBytes, LPLAYERPLANEDESCRIPTOR plpd)
+      # BOOL wglDescribeLayerPlane(HDC hdc, int iPixelFormat, int iLayerPlane, UINT nBytes, LPLAYERPLANEDESCRIPTOR plpd)
       [ :DescribeLayerPlane, [:pointer, :int, :int, :uint, LAYERPLANEDESCRIPTOR.ptr], :bool ],
 
-      #HGLRC wglGetCurrentContext()
+      # HGLRC wglGetCurrentContext()
       [ :GetCurrentContext, [], :pointer ],
 
-      #HDC wglGetCurrentDC()
+      # HDC wglGetCurrentDC()
       [ :GetCurrentDC, [], :pointer ],
 
-      #int wglGetLayerPaletteEntries(HDC hdc, int iLayerPlane, int iStart, int cEntries, COLORREF *pcr)
+      # int wglGetLayerPaletteEntries(HDC hdc, int iLayerPlane, int iStart, int cEntries, COLORREF *pcr)
       [ :GetLayerPaletteEntries, [:pointer, :int, :int, :int, :pointer], :int ],
 
-      #PROC wglGetProcAddress(LPCSTR lpszProc)
+      # PROC wglGetProcAddress(LPCSTR lpszProc)
       [ :GetProcAddress, [:string], :pointer ],
 
-      #BOOL wglMakeCurrent(HDC hdc, HGLRC hglrc)
+      # BOOL wglMakeCurrent(HDC hdc, HGLRC hglrc)
       [ :MakeCurrent, [:pointer, :pointer], :bool ],
 
-      #BOOL wglRealizeLayerPalette(HDC hdc, int iLayerPlane, BOOL bRealize)
+      # BOOL wglRealizeLayerPalette(HDC hdc, int iLayerPlane, BOOL bRealize)
       [ :RealizeLayerPalette, [:pointer, :int, :bool], :bool ],
 
-      #int wglSetLayerPaletteEntries(HDC hdc, int iLayerPlane, int iStart, int cEntries, const COLORREF *pcr)
+      # int wglSetLayerPaletteEntries(HDC hdc, int iLayerPlane, int iStart, int cEntries, const COLORREF *pcr)
       [ :SetLayerPaletteEntries, [:pointer, :int, :int, :int, :pointer], :int ],
 
-      #BOOL wglShareLists(HGLRC hglrc1, HGLRC hglrc2)
+      # BOOL wglShareLists(HGLRC hglrc1, HGLRC hglrc2)
       [ :ShareLists, [:pointer, :pointer], :bool ],
 
-      #BOOL wglSwapLayerBuffers(HDC hdc, UINT fuPlanes)
+      # BOOL wglSwapLayerBuffers(HDC hdc, UINT fuPlanes)
       [ :SwapLayerBuffers, [:pointer, :uint], :bool ],
 
-      #BOOL wglUseFontBitmaps(HDC hdc, DWORD first, DWORD count, DWORD listBase)
+      # BOOL wglUseFontBitmaps(HDC hdc, DWORD first, DWORD count, DWORD listBase)
       [ :UseFontBitmaps, "wglUseFontBitmaps#{ENCODING}", [:pointer, :uint, :uint, :uint], :bool ],
 
-      #BOOL wglUseFontOutlines(HDC hdc, DWORD first, DWORD count, DWORD listBase, FLOAT deviation, FLOAT extrusion, int format, LPGLYPHMETRICSFLOAT lpgmf)
+      # BOOL wglUseFontOutlines(HDC hdc, DWORD first, DWORD count, DWORD listBase, FLOAT deviation, FLOAT extrusion, int format, LPGLYPHMETRICSFLOAT lpgmf)
       [ :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
-      func = attach_function *args
-      RenderContext.send(:define_method, args[1]) { |*parms| func.call(*parms) }
+      RenderHandle.send(:def_function, args[1], attach_function(*args))
     end
 
     class << self

data/lib/roglew/render_context.rb

@@ -1,156 +1,195 @@
 module Roglew
   class RenderContext
-    include GLObject, Roglew::Contextual(nil)
+    include RenderContextExtension
 
-    @registered_extensions = {}
+    class << self
+      def current
+        stack.empty? ? nil : peek.last
+      end
+
+      private
+      def stack
+        @stack ||= RenderHandle.send(:stack)
+      end
 
-    def self.finalize(*args)
-      proc do
-        puts 'releasing a render context'
-        GL.platform_module.delete_context(*args)
+      def peek
+        stack.last
       end
     end
 
-    def self.register_extensions(extensions)
-      extensions = Hash[extensions.map { |k, v| [k.to_sym, v] }]
-      @registered_extensions.merge!(extensions)
-      nil
+    def initialize(rh)
+      @rh = rh
+
+      c = singleton_class
+      @rh.loaded_extensions.each do |ext|
+        next unless Object.const_defined?(ext)
+        mod = Object.const_get(ext)
+        next unless mod.const_defined?(:RenderContext)
+        c.send(:include, mod.const_get(:RenderContext))
+      end
     end
 
-    def self.unregister_extensions(*extensions)
-      extensions.map! { |e| e.to_sym }.each { |e| @registered_extensions.delete(e) }
+    def bind
+      return unless current?
+      @rh.class.send(:push, @rh, self)
+      @rh.send(:make_current)
       nil
     end
 
-    def begin(mode)
-      glBegin(mode)
-      return unless block_given?
-      yield
-      glEnd
+    checks_current
+    def blend_func(src, dst)
+      @rh.glBlendFunc(src, dst)
     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")
+    checks_current
+    def clear(*flags)
+      @rh.glClear(flags
+        .map { |f| f.is_a?(Integer) ? f : GL.const_get("#{f.to_s.upcase}_BUFFER_BIT") }
+        .reduce(&:|))
     end
 
-    def bind
-      make_current
-      if block_given?
-        yield
-        unbind
-      end
-      self
+    checks_current
+    def clear_color
+      get_floats(GL::COLOR_CLEAR_VALUE, 4)
     end
 
-    def clear(*flags)
-      glClear(flags.reduce(&:|))
+    checks_current
+    def clear_color=(c)
+      @rh.glClearColor(*c)
     end
 
-    def create_texture2d(*args)
-      Texture2d.new(self, *args)
+    checks_current
+    def clear_depth=(v)
+      @rh.glClearDepth(v)
+    end
+
+    checks_current
+    def clear_stencil=(v)
+      @rh.glClearStencil(v)
+    end
+
+    checks_current
+    def color_mask(r, g, b, a)
+      @rh.glColorMask(r, g, b, a)
     end
 
     def_object :Textures
 
+    def create_texture2d(*args)
+      Roglew::Texture2d.new(@rh, *args)
+    end
+
+    def current?
+      RenderContext.current == self
+    end
+
+    checks_current
     def disable(*caps)
-      caps = Set[*caps] & @attribs
-      caps.each do |cap|
-        glDisable(cap)
-        @attribs.delete(cap)
-      end
+      attribs = @rh.instance_variable_get(:@attribs)
+      a1 = attribs.dup
+
+      caps = Set[*caps] & attribs
+      caps.each { |cap| @rh.glDisable(cap) }
+      attribs.subtract(caps)
       return unless block_given?
       yield
-      enable(caps)
+
+      disable *(attribs - a1)
+      enable  *(a1 - attribs)
     end
 
+    checks_current
     def enable(*caps)
-      caps = Set[*caps] - @attribs
-      caps.each { |cap| glEnable(cap) }
-      @attribs.merge(caps)
+      attribs = @rh.instance_variable_get(:@attribs)
+      a1 = attribs.dup
+
+      caps = Set[*caps] - attribs
+      caps.each { |cap| @rh.glEnable(cap) }
+      attribs.merge(caps)
       return unless block_given?
       yield
-      disable(*caps)
-    end
 
-    def extension_list(*types)
-      list = types.flat_map { |type| send("extension_list_#{type}") }
-      list.uniq!
-      list
+      disable *(attribs - a1)
+      enable  *(a1 - attribs)
     end
 
-    def get_integers(pname, count = 1)
-      p = FFI::MemoryPointer.new(:int, count)
-      glGetIntegerv(pname, p)
-      result = p.read_array_of_int(count)
-      count == 1 ? result[0] : result
+    checks_current 'finished out of order: context must be current'
+    def finished
+      stack = RenderContext.send(:stack)
+      stack.pop
+      if stack.empty?
+        @rh.send(:remove_current)
+      elsif stack.last.last != self
+        stack.last.first.send(:make_current)
+      end
+      nil
     end
 
+    checks_current
     def get_errors
       errors = []
-      while (error = glGetError) != 0
+      while (error = @rh.glGetError) != 0
         errors << GL::ERROR[error] || error
       end
       errors
     end
 
+    checks_current
+    def get_floats(pname, count = 1)
+      p = FFI::MemoryPointer.new(:float, count)
+      @rh.glGetFloatv(pname, p)
+      result = p.read_array_of_float(count)
+      count == 1 ? result[0] : result
+    end
+
+    checks_current
     def get_function(function_name, parameters, return_type)
       ptr = get_proc_address(function_name.to_s)
-      return nil if ptr.null?
+      if ptr.null?
+        LOGGER.warn "couldn't find function: #{return_type} #{function_name}(#{parameters.join(', ')})"
+        return
+      end
       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 load_extension(ext)
-      ext = ext.to_sym
-      @loaded_extensions << ext
-
-      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
-
-      return unless Object.const_defined?(ext)
-      mod = Object.const_get(ext)
-      return unless mod.const_defined?(:RenderContext)
-      mod = mod::RenderContext
-      return unless mod
+    checks_current
+    def get_integers(pname, count = 1)
+      p = FFI::MemoryPointer.new(:int, count)
+      @rh.glGetIntegerv(pname, p)
+      result = p.read_array_of_int(count)
+      count == 1 ? result[0] : result
+    end
 
-      singleton_class.send(:include, mod)
+    checks_current
+    def get_proc_address(function_name)
+      @rh.send(:get_proc_address, function_name)
+    end
 
-      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
+    def num_extensions
+      get_integers(GL::NUM_EXTENSIONS)
     end
 
-    def loaded_extensions; @loaded_extensions.dup end
+    def render_handle
+      @rh
+    end
 
-    def supports?(extension); !!@loaded_extensions[extension] end
+    checks_current
+    def swap_buffers
+      @rh.send(:swap_buffers)
+    end
 
+    checks_current
     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 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 }
+      @rh.send("glTexParameter#{type[0]}v", target, pname, ptr)
     end
 
-    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
+    alias_method :handle, :render_handle
+    alias_method :rh, :render_handle
   end
 end