shattered_pack 0.3.3

data/lib/shattered_pack/runner.rb

@@ -0,0 +1,11 @@
+module ShatteredPack
+  class Configuration #:nodoc:
+    def self.environment
+      @@environment={} unless defined? @@environment
+      return @@environment 
+    end
+    def self.environment=(environment)
+      @@environment=environment
+    end
+  end
+end

data/lib/shattered_pack/timer/timed_event.rb

@@ -0,0 +1,77 @@
+module ShatteredPack
+  module Timer #:nodoc:all
+    
+    class Timer
+      attr_reader :events_remaining
+      def initialize
+        @events_remaining = []
+      end
+      def in(seconds, &block)
+        @events_remaining << TimedEvent.new(seconds, &block)
+      end
+      def every(seconds, &block)
+        @events_remaining << ContinuousTimedEvent.new(seconds,&block)
+      end
+      def update(time_elapsed)
+        events_for_update = @events_remaining.dup
+        events_for_update.each do |event|
+          event.update(time_elapsed)
+          @events_remaining.delete(event) if event.processed?
+        end
+      end
+    end
+
+    class TimedEvent
+      attr_accessor :time_remaining
+      def initialize(seconds, &block)
+        @event = block
+        if(seconds != :frame)
+          @time_remaining = seconds
+          @initial_time = @time_remaining
+        else
+          @time_remaining = 0
+          @initial_time = 0
+        end
+      end
+      def update(time_elapsed)
+        return if processed?
+        @time_remaining -= time_elapsed
+        if time_up?
+          process_event
+          @processed=true
+        end
+      end
+      def processed?
+        return @processed == true
+      end
+      def reset
+        @time_remaining = @initial_time
+      end
+      private
+      def process_event
+        @event.call(@initial_time - @time_remaining)
+      end
+      def time_up?
+        return @time_remaining <= 0
+      end
+    end
+
+    class ContinuousTimedEvent < TimedEvent
+      def update(time_elapsed)
+        @time_remaining -= time_elapsed
+        if(time_up?)
+          process_event
+          reset
+        end
+      end
+      def reset
+        @time_remaining += @initial_time
+        @time_remaining = 0 if @time_remaining < 0
+      end
+      def processed?
+        false
+      end
+    end
+
+  end
+end

data/lib/shattered_pack/timer/timer.rb

@@ -0,0 +1,75 @@
+require File.dirname(__FILE__)+'/timed_event'
+
+module ShatteredPack
+  module Timer #:nodoc:
+    def self.append_features(base)
+      super
+      base.extend(ClassMethods)
+      base.send(:include, InstanceMethods)
+    end
+    module ClassMethods
+      # Timers are controller events that occur after a specified period of time.
+      # The time values are seconds by default.
+      #
+      # timer :in
+      #  If you want an event to occur once after a specified amount of time, use
+      #     timer :in => 3.seconds, :action => :method_to_call
+      #
+      # timer :every
+      #  If you want an event to occur once every specified amount of time, use
+      #     timer :every => 3.seconds, :action => :method_to_call
+      #  If you want to be notified of every frame update, use
+      #     timer :every => :frame, :action => :method_to_call
+      #
+      # Inside the instance, you can still create timer events, using the timer object:
+      #    timer.in( 3.seconds ) { ... }
+      #    timer.every( 3.seconds ) { ... }
+      def timer(options = {})
+        if options[:action].nil?
+          throw ShatteredPack::Error, 
+            "Timer event must specify an :action => :method" 
+        end
+        if options[:in].nil? && options[:every].nil?
+          throw ShatteredPack::Error,
+            "Timer event must specify a time.  (timer :in or timer :every)"
+        end
+        time = options[:in] || options[:every]
+        action = options[:action]
+        before_init_call(:timer_in, time, action) unless options[:in].nil?
+        before_init_call(:timer_every, time, action) unless options[:every].nil?
+      end
+    end
+    module InstanceMethods
+      def timer
+        @timer ||= Timer.new
+      end
+      private
+        def timer_in(time, action)
+          timer.in(time) do |time_elapsed| 
+            timer_enactment(action, time_elapsed)
+          end
+        end
+        def timer_every(time, action)
+          timer.every(time) do |time_elapsed|
+            timer_enactment(action, time_elapsed)
+          end
+        end
+        def timer_enactment(action, time_elapsed)
+            begin
+              if(action.is_a? Hash)
+                if(action.values[0].is_a?(Array))
+                  send(action.keys[0], *(action.values[0]))
+                else
+                  send(action.keys[0], action.values[0])
+                end
+              else
+                send(action.to_sym)
+              end
+            rescue ArgumentError => argument_error
+              raise argument_error unless argument_error.message.to_sym == :"wrong number of arguments (0 for 1)"
+              send(action.to_sym,time_elapsed)
+            end
+        end
+    end
+  end
+end

data/lib/shattered_view.rb

@@ -0,0 +1,7 @@
+require 'shattered_ogre'
+require 'shattered_pack'
+raise( ShatteredPack::Error, "Could not find ShatteredOgre (a ShatteredView dependency)" ) unless defined? ShatteredOgre
+
+%w(vector utilities node camera extensions runner rmaterial base resources).each do |dependency|
+  require "shattered_view/#{dependency}"
+end

data/lib/shattered_view/base.rb

@@ -0,0 +1,151 @@
+
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+  
+require 'mesh/mesh'
+
+module ShatteredView #:nodoc:
+
+  class Error < StandardError; end
+  
+  def self.append_features(base)
+    super
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    # Materials are parsed through erb as .rmaterials and parsed when a material
+    # metafunction is called.
+    #  
+    # Example:
+    #   material :wall_material, :template => 'normal_map', :texture => 'wall.png', :normal => 'brick_normals.png', :tangent_space => true
+    #   mesh :wall, :material => :wall_material
+    #
+    #  You must make sure that your material name is unique, or Ogre will fail.
+    #
+    #  All rmaterial files are included within media/templates, you can add your own there.
+    #  TODO:  ruby script/generate material (?)
+    def material(name, options = {})
+      before_init_set "self", {:new_material => [name]}
+      before_init_set name, options
+      before_init_set name, {:create_ogre_material => []}
+    end
+
+
+
+    #  Any view can create a light.
+    #  There are 4 types of possible lights.
+    #   Ambient Light - this type of light lights everything in the scene equally.
+    #   Example:   light :sun, :ambient => [1,1,1]
+    #   
+    #   Point Light - this type of light emanates from a point in space and lights all 
+    #               directions equally.
+    #   Example:  light :fireplace, :position => [0,-5,20], :diffuse => [1,0.5,0.5], :specular => [1,0,0], :attenuation => [8000,0,4,0.3]  
+    #   Parameters:
+    #   :position: the x,y,z position or vector position
+    #   :diffuse: the r,g,b value of the diffuse color 
+    #   :specular: the r,g,b value of the specular color
+    #   :attenuation:  arguments are range, constant, linear, quadratic 
+    #     range is how far the light will extend
+    #     constant 	The constant factor in the attenuation formula: 1.0 means never attenuate, 0.0 is complete attenuation
+    #     linear 	The linear factor in the attenuation formula: 1 means attenuate evenly over the distance
+    #     quadratic 	The quadratic factor in the attenuation formula: adds a curvature to the attenuation formula.
+    #
+    #   Directional Light - this light is like the positional light, except instead of position it has only direction
+    #   Example:  light :sun, :direction => [0,-1,-1], :diffuse => [1,1,1], :specular => [1,1,1]
+    #   :direction:  the direction light emanates from
+    #   : other : same as point light above.
+    #
+    #   Spotlight - this light has both a direction and a position, as well as other factors.
+    #   Example:  light :flashlight...
+    #   TODO: This type of light is not currently implemented in shattered.
+
+    def light(name, options = {})
+      before_init_set "self", {:new_light => [name]}
+      before_init_set name, options
+    end
+
+    #  Particle systems are defined in .particle files 
+    #  - This works for first order particle systems --
+    #  - We need to look into second and third order particle systems
+    #
+    def particle_system(name, options = {})
+      raise Error, "Must supply a template for your particle system." if options[:template].nil?
+      before_init_set "self", {:new_particle_system, [name, options[:template]]}
+      options.delete :template
+      before_init_set name, options
+    end
+  end
+
+  class Base < ShatteredPack::Base
+    attr_reader :meshes
+    attr_accessor :model
+    
+    def rotate(vector, amount)
+      node.rotate(vector, amount)
+    end
+    
+    def new_material=(name)
+      @materials ||= {}
+      name = name.to_sym
+      @materials[name] = RMaterial.new
+      @materials[name].name=name
+      self.class.send(:define_method, name) do
+        @materials[name]
+      end
+    end
+    
+    def define_accessor(array, new_obj, name)
+      instance_eval("#{array} ||= {}")
+      instance_eval("#{array}[\"#{name}\"] = new_obj")
+      
+      self.class.class_eval <<-EOF
+      define_method(:#{name}) do
+        #{array}[\"#{name}\"]
+      end
+      EOF
+    end
+
+    def new_light=(name)
+      define_accessor("@lights", ShatteredView::Light.new, name)
+    end
+
+    def new_particle_system=(name, template) 
+      define_accessor("@particle_systems", ShatteredView::ParticleSystem.new(template), name)
+    end
+    
    
+    #Return all of the children attached to this view's scene node
+    def children
+      node.children
+    end
+    
+    def position
+      node.position
+    end
+
+		def position=(val)
+			node.position = val
+		end
+    
+    def translate(v)
+      node.translate(v)
+    end
+    
+    def node
+      @scene_node ||= Node.new(Node.root)
+    end
+    
+  private
+    #This is called when a view is removed from the scene
+    def unload!
+      children.each { |child| child.remove_from_scene }
+    end
+    
+  end
+end
+
+
+ShatteredView::Base.class_eval do
+	include ShatteredView::Mesh
+end
+

data/lib/shattered_view/camera.rb

@@ -0,0 +1,7 @@
+module ShatteredView
+  class Camera < Node
+    def initialize( scene )
+      @scene_node = scene.getCamera
+    end
+  end
+end

data/lib/shattered_view/extensions.rb

@@ -0,0 +1,10 @@
+module ShatteredOgre #:nodoc:
+  class Vector3 #:nodoc:
+    def to_a
+      [x, y, z]
+    end
+    def to_v
+      Vector.new x, y, z
+    end
+  end
+end

data/lib/shattered_view/light.rb

@@ -0,0 +1,28 @@
+module ShatteredView
+  class Light
+    def light
+      @light ||= Scene.getSingleton().createLight
+    end
+    def direction=(*direction)
+      light.setType(ShatteredOgre::Light::LT_DIRECTIONAL) 
+      light.setDirection(direction.to_v)
+    end
+    def diffuse=(r,g,b)
+      light.setDiffuseColour(r,g,b)
+    end
+    def specular=(r,g,b)
+      light.setSpecularColour(r,g,b)
+    end
+    def position=(pos)
+      light.setType(ShatteredOgre::Light::LT_POINT) 
+      light.setPosition(pos.to_v)
+    end
+    def ambient=(r,g,b)
+      Scene.getSingleton().setAmbientLight(r,g,b);
+    end
+    def attenuation=(range, const, linear, quad)
+      light.setType(ShatteredOgre::Light::LT_POINT)
+      light.setAttenuation(range, const, linear, quad)
+    end
+  end
+end

data/lib/shattered_view/mesh/animation.rb

@@ -0,0 +1,20 @@
+module ShatteredView
+class Animation
+  def initialize(mesh, name)
+    @animation = mesh.getAnimation name
+    @animation.addAsFrameListener
+  end
+  def play
+    @animation.play
+  end
+  def stop
+    @animation.stop
+  end
+  def loop=(looping)
+    @animation.setLoop(looping);
+  end
+  def time_scale=(scale)
+    @animation.setTimeScale(scale);
+  end
+end
+end

data/lib/shattered_view/mesh/mesh.rb

@@ -0,0 +1,135 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'animation'
+module ShatteredView
+  module Mesh
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.send(:include, InstanceMethods)
+    end
+    
+    module ClassMethods
+      # Meshes are the foundation for your world.
+      #
+      # They tie in to Ogre's .mesh file format, and display a 3d object onto the screen.
+      #
+      # Shattered has support for loading meshes, creating materials for those meshes (using RMaterials)
+      # and skeletal animation support.
+      #
+      #    class DirtyRubyView
+      #      mesh "dirty_ruby", :position => v(0,0,1)
+      #    end
+      #
+      # When a Mesh is created, all animations found in that mesh are loaded, and added
+      # as functions to that mesh.
+      #
+      # example:  Tim.mesh has animations kick and punch
+      #
+      # after loading Tim.mesh,  View has the Mesh object tim
+      #    tim.kick.play
+      #    tim.animation(:kick).play
+      #
+      # See Rmaterials and Animation for more details.
+      def mesh(file, options = {})
+        before_init_call( :mesh, file, options )
+      end
+
+      # Animations declare helper functions for mesh animations.
+      #
+      #   class AnimatedRubyView < ...
+      #     mesh :animated_ruby, ...
+      #     animation "shatter"
+      #
+      #     def initialize
+      #       shatter # same as animated_ruby.shatter
+      #     end
+      #   end
+      #
+      # options can include any function in animation.rb
+      # and :alias => :alias_name
+      def animation(name, options = {}) 
+        play_alias = options.delete(:alias)
+        before_init_call(:animation, name, options)
+        unless play_alias.nil?
+          before_init_call(:animation_alias, name, play_alias)
+        end
+      end
+    end
+    
+    module InstanceMethods
+      
+      private
+      def mesh(file, options={})
+        mesh = Mesh.new(file)
+        name = mesh.name
+        attr_reader name.to_sym, mesh
+        
+        call_object_function_for_each_key(name, options)
+        #keep track of the meshes we create
+        mesh.attach_to(node)
+      end
+
+      def meshes
+        children.collect { |child| child.is_a? Mesh }
+      end
+      
+      def animation(name, options={})
+        meshes.each do |mesh|
+          mesh.instance_eval <<-EOF
+          class << self
+            define_method(:#{name}) do
+              animation(:#{name})
+            end
+          end
+          EOF
+          call_object_function_for_each_key(:"#{mesh.name}.#{name}", options)
+        end
+      end
+
+      def animation_alias(name, renamed)
+        define_method(renamed.to_sym) do
+          meshes.each do |mesh|
+            mesh.animation(name.to_sym).play
+          end
+        end
+      end
+    end
+    
+    # This Mesh class corresponds (almost 1 to 1) with ShatteredOgre's mesh class
+    class Mesh < ShatteredView::Node
+      attr_reader :name
+      
+      def initialize( file, options = {} )
+        super( )
+        @name = file.underscore
+        @scene_node = ShatteredOgre::Scene.getSingleton.createMesh( [0,0,0].to_v3, "#{file}.mesh" ) 
+				# TODO Log this
+#        puts "Loading Mesh: #{scene_node} from #{file}.mesh"
+        populate_animations
+      end
+      
+      # Access a given animation.  Returns nil on failure.
+      def animation( animation )
+        return @animations[animation]
+      end
+      
+      # Remove the Ogre Mesh from the scene
+      def remove_from_scene
+        scene_node.removeFromScene
+      end
+    private
+  
+      # populate_animations queries ShatteredOgre and adds the found animations to the mesh.
+      def populate_animations
+        @animations = {}
+        (0...scene_node.getNumberOfAnimations).each do |idx|
+          name = scene_node.getAnimationName(idx)
+          @animations[name.downcase.to_sym] = ShatteredView::Animation.new(scene_node, name)
+        end
+      end
+      
+      
+    end
+  end
+end