roglew 0.2.7 → 0.4.1

data/lib/roglew/render_context_extension.rb

@@ -0,0 +1,50 @@
+module Roglew
+  module RenderContextExtension
+    module ClassMethods
+      def def_gen(name, function)
+        checks_current
+        define_method "gen_#{name}", ->(count = 1) do
+          p = FFI::MemoryPointer.new(:uint, count)
+          @rh.send(function, count, p)
+          ids = p.read_array_of_uint(count)
+          count == 1 ? ids[0] : ids
+        end
+      end
+
+      def def_delete(name, function)
+        checks_current
+        define_method "delete_#{name}", ->(ids) do
+          raise Roglew::RenderContext::ContextError, 'render handle not current' unless @rh.current?
+          p = FFI::MemoryPointer.new(:uint, ids.count)
+          p.write_array_of_uint(ids)
+          send(function, ids.count, p)
+          nil
+        end
+      end
+
+      def def_object(name)
+        def_gen(name.to_s.snakecase, "glGen#{name}")
+        def_delete(name.to_s.snakecase, "glDelete#{name}")
+      end
+
+      private
+      def checks_current(msg = 'render handle not current')
+        @checks_current = msg
+      end
+
+      def method_added(name)
+        return unless @checks_current
+        msg = remove_instance_variable :@checks_current
+        m = instance_method(name)
+        define_method(name) do |*args, &block|
+          raise RenderContextError, msg unless @rh.current?
+          m.bind(self).(*args, &block)
+        end
+      end
+    end
+
+    def self.included(c)
+      c.extend ClassMethods
+    end
+  end
+end

data/lib/roglew/render_handle.rb

@@ -1,66 +1,154 @@
-#TODO
-
 module Roglew
   class RenderHandle
-    def initialize(hdc)
-      @hdc = hdc
-      init_pixel_format()
-      @hrc = GL.create_context(@hdc)
+    @registered_extensions = {}
+
+    class << self
+      def current
+        stack.empty? ? nil : peek.first
+      end
+
+      private
+      def def_function(name, func)
+        define_method(name) { |*args| func.(*args) }
+      end
+
+      def finalize(*args)
+        proc do
+          #puts 'releasing a render context'
+          GL.platform_module.delete_context(*args)
+        end
+      end
+
+      def peek
+        stack.last
+      end
 
-      @context_class = Class.new(RenderContext)
+      def push(rh, rc)
+        stack.push([rh, rc])
+      end
+
+      def stack
+        @stack ||= []
+      end
+
+      def register_extensions(extensions)
+        extensions = Hash[extensions.map { |k, v| [k.to_sym, v] }]
+        @registered_extensions.merge!(extensions)
+        nil
+      end
+
+      def unregister_extensions(*extensions)
+        extensions.map! { |e| e.to_sym }.each { |e| @registered_extensions.delete(e) }
+        nil
+      end
     end
 
-    def bind(deferred = nil)
-      deferred = [deferred, self.deferred?, self.class.deferred?].compact.first
+    # platform specific implementations:
+    #   #initialize
+    #   #get_proc_address
+    #   #make_current
+    #   #remove_current
+    #   #swap_buffers
+
+    def attribs
+      @attribs.dup
+    end
+
+    def bind
+      if current?
+        ctx = RenderContext.current
+      else
+        stack = self.class.send(:stack)
+        i = stack.rindex { |rh, _| rh == self }
+        ctx = i ? stack[i].last : create_context
+        make_current
+      end
+      self.class.send(:push, self, ctx)
 
-      ctx = @context_class.new(self, deferred)
-      GL.make_current(@hdc, @hrc) unless deferred
       return ctx unless block_given?
-      yield
-      if deferred then ctx.apply else self.class.unbind end
+      result = yield ctx
+      ctx.finished
+      result
+    end
 
-      self
+    def extension_list(*types)
+      list = types.flat_map { |type| send("extension_list_#{type}") }
+      list.uniq!
+      list
     end
 
-    def self.unbind
-      GL.make_current(nil, nil)
+    def current?
+      self.class.current == self
     end
 
-    def new_texture2d(*args)
-      Texture2d.new(self, *args)
+    def load_extension(ext)
+      LOGGER.debug "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", __dir__)
+        require filename if File.exists?(filename)
+      end
+
+      return unless Object.const_defined?(ext)
+      mod = Object.const_get(ext)
+      if mod.const_defined?(:RenderHandle)
+        modrh = mod.const_get(:RenderHandle)
+        singleton_class.send(:include, modrh)
+
+        bind do |rc|
+          modrh.functions.each do |options, list|
+            list.each do |name, parameters, ret_type|
+              function = if options.include?(:ffi)
+                           if name =~ /^(glX|wgl)/
+                             GL.platform_module.attach_function(name[3..-1], name, parameters, ret_type)
+                           else
+                             GL.attach_function(name[2..-1], name, parameters, ret_type)
+                           end
+                         else
+                           rc.get_function(name, parameters, ret_type)
+                         end
+              define_singleton_method(name) { |*a| function.(*a) } if function
+            end if !options.include?(:compatibility) || ((@version <=> [3, 0]) <= 0)
+          end if modrh.respond_to?(:functions)
+        end
+      end
+
+      nil
     end
 
-    def load_extensions(*names)
+    def loaded_extensions
+      @loaded_extensions.dup
+    end
+
+    def supports?(extension)
+      !!@loaded_extensions[extension]
+    end
 
+    def version
+      @version.dup
     end
 
     private
-    def self.init_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.choose_pixel_format(@hdc, pfd)
-      raise InvalidPixelFormatError,
-            "(ChoosePixelFormat) GetLastError returned #{Kernel32.last_error}" if pxfmt == 0
-
-      #Can't use DescribePixelFormat. Blows up remote desktop
-      #
-      #max_pfd = Gdi32.describe_pixel_format(@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.describe_pixel_format(@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
-
-      unless Gdi32.set_pixel_format(@hdc, pxfmt, pfd)
-        raise InvalidPixelFormatError,
-              "(SetPixelFormat) GetLastError returned #{Kernel32.last_error}"
-      end
+    def create_context
+      RenderContext.new(self)
+    end
+
+    def extension_list_core
+      dirs = Dir["#{File.expand_path('../extensions', __FILE__)}/GL_VERSION_*.rb"]
+      dirs.map! { |f| File.basename(f, '.rb') }
+      dirs.select! { |f| (f.gsub('GL_VERSION_', '').split('_', 2).map!(&:to_i) <=> @version) <= 0 }
+      dirs
+    end
+
+    def extension_list_gl
+      if @version[0] < 3
+        glGetString(GL::EXTENSIONS).split
+      else
+        RenderContext.current.num_extensions.times.map { |i| glGetStringi(GL::EXTENSIONS, i) }
+      end.map!(&:to_sym)
     end
   end
 end

data/lib/roglew/render_handle_extension.rb

@@ -0,0 +1,22 @@
+module Roglew
+  module RenderHandleExtension
+    module ClassMethods
+      def functions(*args)
+        if args.length > 0
+          list = args.pop
+          get_funcions << [Set.new(args), list]
+        end
+        get_funcions
+      end
+
+      private
+      def get_funcions
+        @functions ||= []
+      end
+    end
+
+    def self.included(c)
+      c.extend ClassMethods
+    end
+  end
+end

data/lib/roglew/texture2d.rb

@@ -2,18 +2,18 @@ module Roglew
   class Texture2d
     include Roglew::Contextual(Texture2dContext)
 
-    attr_reader :context, :id
+    attr_reader :handle, :id
 
-    def initialize(context)
-      @context = context
-      @id = context.gen_textures
-      ObjectSpace.define_finalizer(self, self.class.finalize(@context, @id))
+    def initialize(handle)
+      @handle = handle
+      @id = handle.bind { |context| context.gen_textures }
+      ObjectSpace.define_finalizer(self, self.class.finalize(@handle, @id))
     end
 
-    def self.finalize(ctx, id)
+    def self.finalize(handle, id)
       proc do
-        puts "releasing texture #{id}"
-        ctx.glDeleteTextures(id)
+        #puts "releasing texture #{id}"
+        handle.delete_textures [id]
       end
     end
 

data/lib/roglew/texture2d_context.rb

@@ -4,49 +4,121 @@ module Roglew
 
     attr_accessor :level
 
+    make_calls :handle, :glTexImage2D, :glTexSubImage2D
+    make_calls :context, :tex_parameter
+
     def initialize(texture, deferred, target, level, &block)
       @target, @level = target, level
-      super(texture, deferred, &block)
-    end
 
-    {
-      :min_filter   => :TEXTURE_MIN_FILTER,
-      :mag_filter   => :TEXTURE_MAG_FILTER,
-      :min_lod      => :TEXTURE_MIN_LOD,
-      :max_lod      => :TEXTURE_MAX_LOD,
-      :base_level   => :TEXTURE_BASE_LEVEL,
-      :max_level    => :TEXTURE_MAX_LEVEL,
-      :wrap_s       => :TEXTURE_WRAP_S,
-      :wrap_t       => :TEXTURE_WRAP_T,
-      :wrap_r       => :TEXTURE_WRAP_R,
-      :priority     => :TEXTURE_PRIORITY,
-      :compare_mode => :TEXTURE_COMPARE_MODE,
-      :compare_func => :TEXTURE_COMPARE_FUNC,
-      :depth_mode   => :DEPTH_TEXTURE_MODE,
-      :mipmap       => :GENERATE_MIPMAP
-    }.each do |name, cnst|
-      class_eval "def #{name}=(v) make_call(:tex_parameter, @target, GL::#{cnst}, v) end"
+      load_version_modules texture.handle.version
+      load_extensions texture.handle.loaded_extensions
+
+      super(texture, deferred, &block)
     end
 
-    def border_color(r, g, b, a)
-      make_call(:tex_parameter, @target, GL::TEXTURE_BORDER_COLOR, r, g, b, a)
+    def parameter(pname, *values)
+      tex_parameter(@target, pname, *values)
     end
 
     def tex_image_2d(width, height, internalFormat, format, type, data = nil)
-      make_call(:glTexImage2D, @target, @level, internalFormat, width, height, 0, format, type, data)
+      glTexImage2D(@target, @level, internalFormat, width, height, 0, format, type, data)
     end
 
     def tex_subimage_2d(x, y, width, height, format, type, data = nil)
-      make_call(:glTexSubImage2D, @target, @level, x, y, width, height, format, type, data)
+      glTexSubImage2D(@target, @level, x, y, width, height, format, type, data)
+    end
+
+    def border_color(r, g, b, a) parameter(GL::TEXTURE_BORDER_COLOR, r, g, b, a) end
+    def mag_filter=(v) parameter(GL::TEXTURE_MAG_FILTER, v) end
+    def min_filter=(v) parameter(GL::TEXTURE_MIN_FILTER, v) end
+    def wrap_s=(v) parameter(GL::TEXTURE_WRAP_S, v) end
+    def wrap_t=(v) parameter(GL::TEXTURE_WRAP_T, v) end
+
+    module Parameters1
+      def priority(v) parameter(GL::TEXTURE_PRIORITY, v) end
+    end
+
+    module Parameters2
+      def base_level=(v) parameter(GL::TEXTURE_BASE_LEVEL, v) end
+      def max_level=(v) parameter(GL::TEXTURE_MAX_LEVEL, v) end
+      def max_lod=(v) parameter(GL::TEXTURE_MAX_LOD, v) end
+      def min_lod=(v) parameter(GL::TEXTURE_MIN_LOD, v) end
+      def wrap_r=(v) parameter(GL::TEXTURE_WRAP_R, v) end
+      def wrap_str(s, t, r) self.wrap_s, self.wrap_t, self.wrap_r = s, t, r end
+
+      def no_mipmaps!
+        self.mag_filter = Roglew::GL::NEAREST
+        self.min_filter = Roglew::GL::NEAREST
+        self.base_level = 0
+        self.max_level  = 0
+        nil
+      end
+    end
+
+    module Parameters3
+      def depth_mode=(v) parameter(GL::DEPTH_TEXTURE_MODE, v) end
+
+      def generate_mipmap=(v)
+        v = v ? GL::TRUE : GL::FALSE if v == true || v == false
+        parameter(GL::GENERATE_MIPMAP, v)
+      end
+    end
+
+    module Parameters4
+      def compare_mode=(v) parameter(GL::TEXTURE_COMPARE_MODE, v) end
+      def compare_func=(v) parameter(GL::TEXTURE_COMPARE_FUNC, v) end
+      def lod_bias=(v) parameter(GL::TEXTURE_LOD_BIAS, v) end
+    end
+
+    module Parameters5
+      def swizzle_r=(v) parameter(GL::SWIZZLE_R, v) end
+      def swizzle_g=(v) parameter(GL::SWIZZLE_G, v) end
+      def swizzle_b=(v) parameter(GL::SWIZZLE_B, v) end
+      def swizzle_a=(v) parameter(GL::SWIZZLE_A, v) end
+      def swizzle_rgba(r, g, b, a) parameter(GL::SWIZZLE_RGBA, r, g, b, a) end
+    end
+
+    module Parameters6
+      def depth_stencil_mode=(v) parameter(GL::DEPTH_STENCIL_TEXTURE_MODE, v) end
     end
 
     private
+
     def bind
-      context.glBindTexture(@target, texture.id)
+      handle.glBindTexture(@target, texture.id)
+    end
+
+    def check_current
+      raise RenderContextError unless handle.current?
+    end
+
+    def load_extensions(extensions)
+      c = singleton_class
+      extensions.each do |ext|
+        next unless Object.const_defined?(ext)
+        mod = Object.const_get(ext)
+        next unless mod.const_defined?(:Texture2dContext)
+        c.send(:include, mod.const_get(:Texture2dContext))
+      end
+    end
+
+    def load_version_modules(version)
+      version = version[0] * 10 + version[1]
+      [
+        version >= 11 && version <= 30, #1
+        version >= 12,                  #2
+        version >= 14 && version <= 30, #3
+        version >= 14,                  #4
+        version >= 33,                  #5
+        version >= 43                   #6
+      ].each_with_index
+        .select { |cond, _| cond }
+        .map { |_, index| self.class.const_get("Parameters#{index+1}") }
+        .each { |mod| singleton_class.send(:include, mod) }
     end
 
     def unbind
-      context.glBindTexture(@target, 0)
+      handle.glBindTexture(@target, 0)
     end
   end
 end

data/lib/roglew/version.rb

@@ -0,0 +1,5 @@
+
+module Roglew
+  VERSION = '0.4.1'.freeze
+  VERSION_CODENAME = 'Donatello'.freeze
+end