glimr 0.1.0

data/lib/glimr/renderer/viewport.rb

@@ -0,0 +1,349 @@
+require 'glimr/renderer/sceneobject'
+require 'glimr/renderer/material'
+require 'glimr/renderer/texture'
+require 'glimr/renderer/camera'
+require 'glimr/renderer/transform'
+
+
+module GlimR
+
+  # Viewport is a scene graph root node and takes care of
+  # drawing its subtree and mapping mouse events to
+  # its child nodes.
+  #
+  class Viewport < SceneObject
+
+    attr_accessor :width, :height, :x, :y, :camera
+    touching_accessor :clear_depth_buffer, :background
+
+    def default_config
+      super.merge(
+        :click_time => 0.3,
+        :click_radius => 4,
+        :background => nil,
+        :clear_depth_buffer => false,
+        :camera => Camera.new,
+        :x => 0, :y => 0, :width => 1, :height => 1
+      )
+    end
+
+    def initialize(*a,&b)
+      @down_x = 0
+      @down_y = 0
+      @old_collisions = []
+      @mouse_down_collisions = []
+      @drag_targets = {}
+      super
+      add_event_listener(:mouse_move, :mouse_move_handler, true)
+      add_event_listener(:click, :click_handler, true)
+      add_event_listener(:mouse_down, :mouse_down_handler, true)
+      add_event_listener(:mouse_up, :mouse_up_handler, true)
+      add_event_listener(:resize, :resize_handler, true)
+    end
+
+    # Acts as root node for dispatched events
+    def event_root
+      true
+    end
+
+    def min_x
+      @x
+    end
+
+    def max_x
+      viewport_width
+    end
+
+    def min_y
+      @y
+    end
+
+    def max_y
+      viewport_height
+    end
+
+    def viewport_x
+      if parent
+        abs_x = @x + parent.absolute_transform.flatten[12]
+      else
+        @x
+      end
+    end
+
+    def viewport_y
+      if parent
+        abs_y = @y + parent.absolute_transform.flatten[13]
+        parent.viewport.height - abs_y - @height
+      else
+        -@y
+      end
+    end
+
+    def viewport_width
+      if parent
+        @width * parent.absolute_transform.flatten[0]
+      else
+        @width
+      end
+    end
+
+    def viewport_height
+      if parent
+        @height * parent.absolute_transform.flatten[5]
+      else
+        @height
+      end
+    end
+
+    def resize_handler(o,e)
+      if !parent
+        self.width = e.width
+        self.height = e.height
+      end
+    end
+
+    # Tracks mouse pointer position and sends hover, mouse_out, and mouse_over
+    # -events to nodes interacting with the mouse pointer.
+    #
+    def mouse_move_handler(o,e)
+      params = e.params.clone
+      params[:x] += x
+      params[:y] += y
+      if Vector[@down_x - params[:x], @down_y - params[:y]].r > @click_radius
+        @click_valid = false
+      end
+      duc = drawables_under_cursor(e)
+      collisions = duc.map{|rx,ry,c| c }
+      (@old_collisions - collisions).each{|oc|
+        evt = Event.new(:mouse_out,
+          params.merge(:sender => self, :target => oc))
+        oc.dispatch_event(evt)
+      }
+      (collisions - @old_collisions).each{|oc|
+        evt = Event.new(:mouse_over,
+          params.merge(:sender => self, :target => oc))
+        oc.dispatch_event(evt)
+      }
+      @old_collisions = collisions
+      children.each{|c|
+        c.multicast_event(Event.new(:mouse_move, params))
+      }
+      @drag_targets.each{|k,t|
+        t.dispatch_event(Event.new(:drag, params.merge(:button => k)))
+      }
+      e.phase = :bubble
+    end
+
+    def mouse_down_handler(o,e)
+      params = e.params.clone
+      params[:x] += x
+      params[:y] += y
+      @down_x = params[:x]
+      @down_y = params[:y]
+      @click_valid = true
+      @down_time = Time.now.to_f
+      collisions = drawables_under_cursor(e)
+      @mouse_down_collisions = collisions.map{|rx,ry,c| c }
+      collisions.each{|rx, ry, c|
+        evt = Event.new(:mouse_down,
+          e.params.merge(:sender => self, :target => c, :rx => rx, :ry => ry))
+        c.dispatch_event(evt)
+      }
+      if collisions.first
+        @drag_targets[e.button] = collisions.first[2]
+      else
+        @drag_targets.delete(e.button)
+      end
+      e.phase = :bubble
+    end
+
+    def mouse_up_handler(o,e)
+      params = e.params.clone
+      params[:x] += x
+      params[:y] += y
+      if Vector[@down_x - params[:x], @down_y - params[:y]].r > @click_radius or (Time.now.to_f - @down_time) > @click_time
+        @click_valid = false
+      end
+      children.each{|c|
+        c.multicast_event(Event.new(:mouse_up, params))
+      }
+      if @click_valid or @drag_targets[e.button]
+        collisions = drawables_under_cursor(e)
+        if @click_valid
+          collisions.each{|rx,ry,c|
+            if @mouse_down_collisions.include? c
+              evt = Event.new(:click, params.merge(:sender => self, :rx => rx, :ry => ry))
+              c.dispatch_event(evt)
+            end
+            break
+          }
+        end
+        if @drag_targets[e.button]
+          if collisions.first
+            @drag_targets[e.button].dispatch_event(
+              Event.new(
+                :drop,
+                params.merge(:drop_target => collisions.first[2], :rx => collisions.first[0], :ry => collisions.first[1])
+              )
+            )
+          end
+          @drag_targets.delete(e.button)
+        end
+      end
+      @mouse_down_collisions.clear
+      e.phase = :bubble
+    end
+
+    def click_handler(o,e)
+      e.phase = :bubble
+    end
+
+    def drawables_under_cursor(e)
+      collapsed = (@drawables - [self])
+      collisions = collapsed.map{|d|
+        collides?( d, e.x, e.y ) if d.visible
+      }.compact
+      collisions.sort_by{|c| -c[2].absolute_transform.flatten[14] } # reverse z-sort
+    end
+
+    # Tests if the coordinates ex and ey fall within the rectangle of drawable d.
+    def collides?( d, ex, ey )
+      MatrixMode MODELVIEW
+      PushMatrix()
+        LoadIdentity()
+        MultMatrix(d.absolute_transform_for_drawing)
+        Translate(-ex,-ey,0)
+        camatrix = GetDoublev(MODELVIEW_MATRIX)
+      PopMatrix()
+      if (camatrix[3][0]+d.min_x+d.max_x >= d.min_x and camatrix[3][0]+d.min_x+d.max_x <= d.max_x and
+          camatrix[3][1]+d.min_y+d.max_y >= d.min_y and camatrix[3][1]+d.min_y+d.max_y <= d.max_y)
+        [-camatrix[3][0], -camatrix[3][1], d] # return relative x & y -coordinates and the drawable
+      else
+        nil
+      end
+    end
+
+    # Draws the viewport drawables using painter's algorithm.
+    def render
+      apply
+    end
+
+    # The absolute state of a viewport is empty starter state.
+    # This to provide the SceneObject absolute state methods
+    # a starting point.
+    #
+    def absolute_transform
+      camera.absolute_transform
+    end
+    
+    # Behave like a square when going through drawing list.
+    def absolute_transform_for_drawing
+      parent.absolute_transform
+    end
+
+    def absolute_material
+      Material.new
+    end
+
+    def absolute_texture
+      Texture.new
+    end
+
+    def absolute_geometry
+      Geometry.new
+    end
+
+    def absolute_shader
+      Shader.new
+    end
+
+    def changed?
+      @last_frame_time != @mtime
+    end
+
+     # Applies viewport to OpenGL state, scissor to viewport,
+     # enable blending and apply camera.
+    def apply
+      @last_frame_time = @mtime
+      apply_clip
+      clear_viewport
+      apply_camera
+      apply_blend
+      draw_drawables
+    end
+
+    def apply_clip
+      Viewport(viewport_x, viewport_y, viewport_width, viewport_height)
+      Enable SCISSOR_TEST
+      Scissor(viewport_x, viewport_y, viewport_width, viewport_height)
+    end
+
+    def clear_viewport
+      if background
+        GL.ClearColor(*background)
+        GL.Clear(GL::COLOR_BUFFER_BIT)
+        GL.Clear(GL::DEPTH_BUFFER_BIT) if clear_depth_buffer
+      end
+    end
+
+    def apply_blend
+      Enable GL::BLEND
+      BlendFunc(GL::SRC_ALPHA, GL::ONE_MINUS_SRC_ALPHA)
+    end
+
+    def apply_camera
+      if camera
+        camera.viewport = self
+        camera.apply
+      end
+    end
+
+    # Draws the viewport drawables using painter's algorithm.
+    def draw_drawables
+      collapsed = (@drawables).find_all{|d| d.visible }
+      collapsed = collapsed.sort_by{|d|
+        d.absolute_transform.flatten[14]
+      }
+      collapsed.each{|d|
+        PushAttrib( TEXTURE_BIT | LIGHTING_BIT )
+          LoadMatrix(d.absolute_transform_for_drawing)
+          d.absolute_texture.apply
+          d.absolute_material.apply
+          d.push_state
+            d.apply
+          d.pop_state
+        PopAttrib()
+        if d.is_a? Viewport
+          apply_clip
+          apply_camera
+        end
+      }
+    end
+
+    # The viewport of a Viewport is the Viewport itself.
+    def viewport
+      self
+    end
+
+    # Viewport presents only itself to its parent.
+    def drawables
+      Set.new + [self]
+    end
+
+    # Width per height aspect of the viewport.
+    def aspect
+      width.to_f / height
+    end
+
+    private
+
+    def adopt(c)
+      super
+      c.viewport = self
+    end
+
+  end
+
+end
+
+

data/lib/glimr/renderer_core.rb

@@ -0,0 +1,10 @@
+require 'glimr/renderer/sceneobject'
+require 'glimr/renderer/transform'
+require 'glimr/renderer/shader'
+require 'glimr/renderer/texture'
+require 'glimr/renderer/material'
+require 'glimr/renderer/geometry'
+require 'glimr/renderer/light'
+require 'glimr/renderer/raw'
+require 'glimr/renderer/model'
+require 'glimr/renderer/viewport'

data/lib/glimr/util.rb

@@ -0,0 +1,247 @@
+require 'glimr/configurable'
+
+
+MAC_OS_X = !(RUBY_PLATFORM =~ /darwin/).nil?
+WINDOWS = !(RUBY_PLATFORM =~ /win32/).nil?
+
+
+class Percentage
+
+  attr_accessor :value
+
+  def initialize(value)
+    @value = value
+  end
+
+  def to_f
+    value / 100.0
+  end
+
+  def method_missing(*args, &block)
+    to_f.__send__(*args, &block)
+  rescue => e
+    raise e
+  end
+
+end
+
+
+class Numeric
+
+  def pct
+    Percentage.new(self)
+  end
+
+end
+
+
+class Module
+
+  def attr_accessor_delegate(*method_names, &delegate)
+    method_names.each{|mn|
+      define_method(mn){|*args| instance_eval(&delegate).__send__(mn,*args) }
+      setter = "#{mn}=".to_sym
+      define_method(setter){|*args| instance_eval(&delegate).__send__(setter,*args) }
+    }
+  end
+
+  def ivar_delegate(ivar_name, *method_names)
+    method_names.each{|mn|
+      define_method(mn){|*args|
+        instance_variable_get(ivar_name).__send__(mn, *args)
+      }
+    }
+  end
+
+  def ivar_accessor_delegate(ivar_name, *method_names)
+    method_names.each{|mn|
+      define_method(mn){|*args| instance_variable_get(ivar_name).__send__(mn,*args) }
+      setter = "#{mn}=".to_sym
+      define_method(setter){|*args|
+        instance_variable_get(ivar_name).__send__(setter,*args)
+      }
+    }
+  end
+
+  def delegate(target, *mnames)
+    mnames.each{|mn|
+      args = "*a, &b"
+      args = "a" if mn.to_s[-1,1] == "="
+      class_eval <<-EOF
+        def #{mn}(#{args})
+          #{target}.#{mn}(#{args})
+        end
+      EOF
+    }
+  end
+      
+  def delegate_accessor(target, *mnames)
+    delegate(target, *mnames.map{|mn| [mn, "#{mn}="]  }.flatten)
+  end
+
+  def block_delegate(*method_names, &delegate)
+    method_names.each{|mn|
+      define_method(mn){|*args|
+        instance_eval(&delegate).__send__(mn,*args)
+      }
+    }
+  end
+
+  def touching(touch_method_name, *mnames)
+    mnames.each{|mn|
+      non_touching_mn = "__non_touching_#{mn}"
+      alias_method non_touching_mn, mn
+      private(non_touching_mn)
+      define_method(mn){|*args|
+        rv = __send__(non_touching_mn,*args)
+        __send__(touch_method_name)
+        rv
+      }
+    }
+  end
+
+  def touching_accessor *names
+    attr_accessor *names
+    touching :touch!, *names.map{|n| n.to_s+"=" }
+  end
+    
+end
+
+
+class Class
+
+  def wrap_obj_count(*mnames)
+    mnames.each{|mn|
+      alias_method "__orig__#{mn}", mn
+      class_eval <<-EOF
+        def #{mn}(*args, &block)
+          acount = fcount = hcount = 0
+          ObjectSpace.each_object(Array){|o|
+            acount -= 1
+          }
+          ObjectSpace.each_object(Hash){|o|
+            hcount -= 1
+          }
+          ObjectSpace.each_object(Float){|o|
+            fcount -= 1
+          }
+          rv = self.__send__(:__orig__#{mn}, *args, &block)
+          ObjectSpace.each_object(Array){|o|
+            acount += 1
+          }
+          ObjectSpace.each_object(Hash){|o|
+            hcount += 1
+          }
+          ObjectSpace.each_object(Float){|o|
+            fcount += 1
+          }
+          puts "After #{self}##{mn}:\n"+
+                "      Arrays:  "+(acount-1).to_s+"\n"+ # *args == +1
+                "      Hashes:  "+hcount.to_s+"\n"+
+                "      Floats:  "+fcount.to_s+"\n"+
+                "\n"
+          rv
+        end
+      EOF
+    }
+  end
+
+end
+
+
+class Object
+
+  def touch!
+    @mtime = Time.now.to_f
+  end
+
+  def silently_fail(exception = StandardError)
+    yield
+  rescue exception => e
+    e
+  end
+  alias_method :silently, :silently_fail
+
+  def print_obj_count(label="block", &block)
+    acount = fcount = hcount = 0
+    ObjectSpace.each_object(Array){|o|
+      acount -= 1
+    }
+    ObjectSpace.each_object(Hash){|o|
+      hcount -= 1
+    }
+    ObjectSpace.each_object(Float){|o|
+      fcount -= 1
+    }
+    rv = yield
+    ObjectSpace.each_object(Array){|o|
+      acount += 1
+    }
+    ObjectSpace.each_object(Hash){|o|
+      hcount += 1
+    }
+    ObjectSpace.each_object(Float){|o|
+      fcount += 1
+    }
+    puts "After #{label}:\n"+
+          "      Arrays:  "+acount.to_s+"\n"+
+          "      Hashes:  "+hcount.to_s+"\n"+
+          "      Floats:  "+fcount.to_s+"\n"+
+          "\n"
+    rv
+  end
+
+end
+
+
+class Array
+
+  def add(x)
+    i = 0
+    x.each{|v|
+      self[i] += v
+      i += 1
+    }
+    self
+  end
+
+  def sub(x)
+    i = 0
+    x.each{|v|
+      self[i] -= v
+      i += 1
+    }
+    self
+  end
+
+  alias_method :add!, :add
+  alias_method :sub!, :sub
+
+  def dot(x)
+    if x.is_a? Array
+      zip(x).map{|i,j| i*j}
+    else
+      map{|i| i*x}
+    end
+  end
+
+  def cross_product(v)
+    u = self
+    [ u[1]*v[2] - v[1]*u[2],
+      v[0]*u[2] - u[0]*v[2],
+      u[0]*v[1] - v[0]*u[1]]
+  end
+
+  def normalize
+    l = Math.sqrt(inject(0){|s,i| s+i**2})
+    map{|i| i / l }
+  end
+
+  def -@
+    map{|i| -i}
+  end
+
+end
+  
+
+