glimr 0.1.0

data/lib/glimr/renderer/light.rb

@@ -0,0 +1,43 @@
+require 'glimr/renderer/sceneobject'
+
+
+module GlimR
+
+
+  class Light < SceneObject
+
+    LIGHTS = GL::constants.grep(/^LIGHT[0-9]+/).map{|l| GL.const_get l }
+
+    def self.reserve_light_id
+      @index ||= 0
+      return false if LIGHTS.size <= @index
+      l = LIGHTS[@index]
+      @index += 1
+      l
+    end
+    
+    def self.reset_lights
+      @index = 0
+      LIGHTS.each{|l| Disable(l) }
+    end
+    
+    attr_accessor :position, :diffuse, :specular, :ambient
+    attr_accessor :constant_attenuation, :linear_attenuation, :quadratic_attenuation
+    
+    def setup
+      light_id = self.class.reserve_light_id
+      return unless light_id
+      Enable(light_id)
+      Lightfv(light_id, POSITION, position ) if position
+      Lightfv(light_id, DIFFUSE, diffuse ) if diffuse
+      Lightfv( light_id, SPECULAR, specular ) if specular
+      Lightfv( light_id, AMBIENT, ambient ) if ambient
+      Lightf( light_id, CONSTANT_ATTENUATION, constant_attenuation) if constant_attenuation
+      Lightf( light_id, LINEAR_ATTENUATION, linear_attenuation) if linear_attenuation
+      Lightf( light_id, QUADRATIC_ATTENUATION, quadratic_attenuation) if quadratic_attenuation
+    end
+    
+  end
+  
+
+end

data/lib/glimr/renderer/material.rb

@@ -0,0 +1,66 @@
+require 'glimr/renderer/sceneobject'
+
+
+module GlimR
+  
+  
+  # A Material node controls OpenGL surface material parameters.
+  # It has accessors for ambient, diffuse, specular, shininess and emission.
+  #
+  # Look up glMaterial and Blinn-Phong shading to find out more.  
+  #
+  class Material < SceneObject
+    
+    touching_accessor :ambient, :diffuse, :specular, :shininess, :emission
+    
+    # The absolute material of a Material is the parent's absolute material
+    # merged with the Material.
+    def absolute_material
+      @__pama ||= (
+        pam = parent.absolute_material
+        pam.ambient = ambient if ambient
+        pam.diffuse = diffuse if diffuse
+        pam.specular = specular if specular
+        pam.shininess = shininess if shininess
+        pam.emission = emission if emission
+        pam
+      )
+    end
+    
+    # Applies the material by calling GL::Material to set the material properties.
+    def apply
+      Material(FRONT_AND_BACK, AMBIENT, ambient) if ambient
+      Material(FRONT_AND_BACK, DIFFUSE, diffuse) if diffuse
+      Material(FRONT_AND_BACK, SPECULAR, specular) if specular
+      Material(FRONT_AND_BACK, SHININESS, shininess) if shininess
+      Material(FRONT_AND_BACK, EMISSION, emission) if emission
+    end
+
+    # Pushes the LIGHTING_BIT to attrib stack.
+    def push_state
+      PushAttrib(LIGHTING_BIT)
+    end
+    
+    # Pops the attrib stack.
+    def pop_state
+      PopAttrib()
+    end
+    
+    # Replaces the instance variables of the Material with
+    # the other's.
+    def replace!(other)
+      @ambient = other.ambient
+      @diffuse = other.diffuse
+      @specular = other.specular
+      @shininess = other.shininess
+      @emission = other.emission
+      self
+    end
+    
+    touching :touch!, :replace!
+    
+  end
+  
+
+end
+

data/lib/glimr/renderer/model.rb

@@ -0,0 +1,103 @@
+require 'glimr/renderer/sceneobject'
+require 'glimr/renderer/transform'
+require 'glimr/renderer/texture'
+require 'glimr/renderer/geometry'
+require 'glimr/renderer/material'
+require 'glimr/renderer/shader'
+
+
+module GlimR
+
+  # A Model is a convenience SceneObject that
+  # has its own transform, material, texture, shader, and geometry.
+  #
+  # The state nodes are attached to the Model after super initialization
+  # and form a five-node subtree ordered like this (from top to bottom): 
+  # transform - material - texture - shader - geometry.
+  #
+  # Model delegates many accessors to the corresponding state nodes
+  #
+  # Example:
+  #   m = Model.new
+  #   m.texture.load('foo.jpg')
+  #   m.position = [10, 20, 30]
+  #   m.texcoords = make texcoords
+  #   m.vertices = make vertices
+  #
+  class Model < SceneObject
+  
+    attr_reader :texture, :geometry, :transform, :material, :shader
+    
+    delegate_accessor :geometry, :type, :vertices, :texcoords, :colors, :normals
+    delegate_accessor :transform, :position, :rotation, :scale, :matrix, :x, :y, :z, :angle
+    delegate_accessor :material, :ambient, :diffuse, :specular, :shininess, :emission
+    
+    def initialize(*a,&b)
+      @transform = Transform.new
+      @material = Material.new
+      @texture = Texture.new
+      @shader = Shader.new
+      @geometry = Geometry.new
+      super
+      attach @material
+      @material.attach @texture
+      @texture.attach @shader
+      @shader.attach @geometry
+    end
+    
+    def push_state
+      @transform.push_state
+      super
+    end
+    
+    def pop_state
+      @transform.pop_state
+      super
+    end
+    
+    def apply
+      @transform.apply
+      super
+    end
+    
+    def absolute_transform
+      @transform.instance_variable_set :@parent , @parent
+      @transform.absolute_transform
+    end
+    
+    # Replaces transform with t using Transform#replace!
+    # If t is a matrix, creates a Transform with t as the collapsed matrix.
+    def transform= t
+      unless t.is_a? Transform
+        t = Transform.new(:collapsed_matrix => t, :position => nil, :rotation => nil, :scale => nil, :matrix => nil)
+      end
+      @transform.replace! t
+    end
+    
+    # Replaces texture with t. Uses Texture#replace!
+    def texture= t
+      @texture.replace! t 
+    end
+    
+    # Replaces geometry with g using Geometry#replace!
+    def geometry= g 
+      @geometry.replace! g
+    end
+    
+    # Replaces material with m using Material#replace!
+    def material= m
+      @material.replace! m
+    end
+    
+    # Replaces shader with s using Shader#replace!
+    def shader= s
+      @shader.replace! s 
+    end
+    
+    def inspect
+      super[0..-2] + "::#{ [@transform, @material, @texture, @shader, @geometry].map{|i|i.inspect[9..-2]}.join("::") }>"
+    end
+    
+  end
+
+end

data/lib/glimr/renderer/orthoprojection.rb

@@ -0,0 +1,21 @@
+require 'glimr/renderer/sceneobject'
+
+
+module GlimR
+
+  class OrthoProjection < SceneObject
+    
+    attr_accessor :width, :height, :x, :y, :near, :far
+
+    def apply(x=x, y=y, width=width, height=height)
+      MatrixMode(PROJECTION)
+      LoadIdentity()
+      Ortho(x,width, y,height, near,far)
+      MatrixMode(MODELVIEW)
+      LoadIdentity()
+    end
+  
+  end
+
+end
+

data/lib/glimr/renderer/raw.rb

@@ -0,0 +1,34 @@
+require 'glimr/renderer/sceneobject'
+
+
+module GlimR
+
+
+  # Raw is a SceneObject that calls its #renderer
+  # when applied.
+  #
+  # Use for doing custom OpenGL calls and such.
+  #
+  # Raw doesn't work with the Viewport's collapsing #render, 
+  # so is pretty much useless at the moment.
+  #
+  # Example:
+  #
+  #   r = Raw.new
+  #   r.renderer = lambda do
+  #     puts 'Hi, I was just applied!'
+  #   end
+  #
+  class Raw < SceneObject
+    
+    attr_accessor :renderer
+    
+    # Calls #renderer if renderer is set.
+    def apply
+      renderer.call if renderer
+    end
+    
+  end
+
+
+end

data/lib/glimr/renderer/sceneobject.rb

@@ -0,0 +1,279 @@
+require 'glimr/eventlistener'
+require 'glimr/util'
+require 'opengl'
+require 'set'
+
+
+module GlimR
+
+
+  # The SceneObject is the root class of the GlimR scene graph class hierarchy.
+  #
+  # A SceneObject may have a parent and children, and usually will.
+  # All actual OpenGL state manipulation should be done with its
+  # specific subclasses like Transform, Geometry and Texture.
+  #
+  # The SceneObject is an EventListener, and as such you can tell
+  # it to listen and respond to events.
+  #
+  # SceneObjects also maintain a list of drawable objects underneath them.
+  # This is mainly used to speed up rendering by removing the need to traverse
+  # the whole scene graph to draw the scene.
+  #
+  # Example:
+  #   s = SceneObject.new
+  #   t = Texture.new
+  #   s.attach t
+  #   s.detach t
+  #
+  class SceneObject
+    include GL
+    include EventListener
+    include Configurable
+
+    attr_accessor :parent, :children, :viewport, :drawables
+    attr_reader :mtime
+    touching_accessor :visible
+
+    def default_config
+      super.merge(
+        :visible => true,
+        :mtime => Time.now.to_f
+      )
+    end
+
+    # Configurable initialize.
+    def initialize(*arg_hash, &config_block)
+      @children = []
+      @drawables = Set.new
+      super
+    end
+
+    # Returns the viewport or possible parent's viewport.
+    def viewport
+      @viewport ||= (parent and parent.viewport)
+    end
+
+    # Returns the scene root.
+    # This is either the viewport,
+    # the parent's scene root if there is no viewport,
+    # or self if there is no parent.
+    #
+    def root
+      (viewport || (parent ? parent.root : self))
+    end
+
+    # Sets viewport to vp.
+    # Passes viewport change to children.
+    #
+    def viewport= vp
+      if vp != @viewport
+        @viewport = vp
+        children.each{|c| c.viewport = vp}
+      end
+    end
+
+    # Attaches new_children to the scene graph below self.
+    def attach(*new_children)
+      new_children.each{|c|
+        adopt(c)
+      }
+    end
+
+    # Attach single child.
+    def <<(new_child)
+      attach new_child
+      self
+    end
+
+    # Detaches children_to_detach from self.
+    def detach(*children_to_detach)
+      children_to_detach.each{|c|
+        orphan(c)
+      }
+    end
+
+    # Detaches self from parent if there is a parent.
+    def detach_self
+      parent.detach(self) if parent
+    end
+
+    # Sets parent to p.
+    #
+    # Causes viewport to be set to nil and drawables to
+    # be added to parent's drawables.
+    def parent= new_parent
+      #~ if @parent
+        #~ puts object_id, "reparenting #{self} from #{@parent} to #{new_parent.inspect}"
+        #~ d = @parent
+      #~ end
+      @parent.remove_drawables drawables if @parent
+      @parent = new_parent
+      self.viewport = nil
+      @parent.add_drawables drawables if @parent
+      #~ p [:after, d.drawables] if d
+      #~ puts '','' if d
+    end
+
+    # A node is visible if its @visible is true and its parent is visible (if it has a parent.)
+    def visible
+      @visible and (parent ? parent.visible : true)
+    end
+
+    # Adds d to drawables and parent's drawables.
+    def add_drawables(d)
+      parent.add_drawables d if parent
+      @drawables += d
+    end
+
+    # Removes d from drawables and parent's drawables.
+    def remove_drawables(d)
+      parent.remove_drawables d if parent
+      @drawables -= d
+    end
+
+    # Sets drawables to d and updates parent's drawables.
+    def drawables= d
+      if (d != @drawables) and parent
+        parent.drawables = ((parent.drawables - @drawables) + d)
+      end
+      @drawables = d
+    end
+
+    # Replaces orig node in scene graph with replacement by
+    # Attaching the replacement to orig's parent, and attaching
+    # orig's children to replacement.
+    #
+    # If no replacement is given, removes orig from scenegraph
+    # and attaches its children to its parent. If there is no parent or
+    # replacement, does nothing.
+    #
+    def replace_node(orig, replacement=nil)
+      return unless orig
+      replacement ||= orig.parent
+      return unless replacement
+      replacement.detach(*orig.children)
+      replacement.attach(*orig.children)
+      orig.detach(*orig.children)
+      orig.parent.attach(replacement) if orig.parent
+      orig.detach_self
+    end
+
+    # Renders the SceneObject by pushing state, applying, calling render
+    # for each child, and popping state.
+    #
+    # Not used with collapsing Viewport #render.
+    def render(*a)
+      push_state
+      apply
+      children.each{|c| c.render if c.visible }
+      pop_state
+    end
+
+    # The collapsed state of a SceneObject is its parent's collapsed state,
+    # which fits in with SceneObjects not editing OpenGL state.
+    def absolute_transform
+      parent.absolute_transform
+    end
+
+    def absolute_transform_for_drawing
+      absolute_transform
+    end
+
+    def absolute_material
+      #~ unless parent
+        #~ puts object_id, geometry.object_id, self, geometry
+        #~ ObjectSpace.each_object(Button){|b|
+          #~ if b.drawables.include? geometry
+            #~ puts b
+            #~ p b.drawables.to_a, b.children
+            #~ puts
+            #~ puts
+            #~ cc = b.children.find{|c|
+              #~ c.geometry == geometry if c.is_a? Model
+            #~ }
+            #~ p cc
+          #~ end
+        #~ }
+      #~ end
+      parent.absolute_material
+    end
+
+    def absolute_texture
+      parent.absolute_texture
+    end
+
+    def absolute_geometry
+      parent.absolute_geometry
+    end
+
+    def absolute_shader
+      parent.absolute_shader
+    end
+
+    # Applies the SceneObject to OpenGL state.
+    # For SceneObject, this is empty.
+    def apply
+    end
+
+    # Pushes the relevant OpenGL state stack.
+    # Empty for SceneObject.
+    def push_state
+    end
+
+    # Pops the relevant OpenGL state stack.
+    # Empty for SceneObject.
+    def pop_state
+    end
+
+    # Creates a clone of the SceneObject.
+    # If deep is set to true, also clones the children.
+    # If deep is false, clears children.
+    #
+    def clone(deep=false)
+      c = super()
+      if deep
+        c.children = []
+        c.drawables.clear
+        cchildren = c.children.map{|ch| ch.clone(deep) }
+        c.attach *cchildren
+      else
+        c.children = []
+        c.drawables.clear
+      end
+      c.parent = nil
+      c
+    end
+
+    def inspect
+      "#<#{self.class.name}:#{object_id}>"
+    end
+
+    def touch!(mtime=Time.now.to_f)
+      @mtime = mtime
+      parent.touch!(@mtime) if parent
+      nil
+    end
+
+    private
+
+    def adopt(c)
+      children.push c
+      c.parent = self
+      c.listener_count.each{|k,v| increment_listener_count k, v }
+      touch!
+    end
+
+    def orphan(c)
+      if children.include? c
+        children.delete c
+        c.parent = nil
+        c.listener_count.each{|k,v| decrement_listener_count k, v }
+        touch!
+      end
+    end
+
+  end
+
+
+end