shattered_view 0.3 → 0.3.1

data/lib/base.rb

@@ -1,5 +1,9 @@
 
-include ShatteredOgre
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+  
+require 'mesh/mesh'
+
 include ShatteredSupport
 
 module ShatteredView
@@ -29,41 +33,6 @@ module ShatteredView
       before_init_set name, {:create_ogre_material => []}
     end
 
-    # This deserves a larger explanation
-    #
-    # options can include:
-    # - :animation => (not implemented yet)
-    # - - :speed => speed in game_seconds/animation_seconds
-    # - - :start_at => animation name to start the animation
-    # - - :loops => default for looping
-    def mesh(file, options = {})
-      name = file.underscore
-      before_init_set( "self", {:new_mesh => file })
-
-      define_method(name.to_sym) do
-        return instance_variable_get(:"@#{name}")
-      end
-
-      #What is this?
-      options = options.dup
-      options.delete :file
-      options.delete :name
-
-      before_init_set( name, options )
-    end
-
-    #
-    #
-    # options can include any function in animation.rb
-    # and :alias => :alias_name
-    def animation(name, options = {}) 
-      alias_option = options.delete(:alias)
-      before_init_set("animation(:#{name})", options)
-      before_init_set("self", {:new_animation => [name]}) 
-      if not alias_option.nil?
-        before_init_set("self", {:new_animation_alias => [name, alias_option]})
-      end
-    end
 
 
     #  Any view can create a light.
@@ -98,54 +67,23 @@ module ShatteredView
       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 < ShatteredSupport::Base
     attr_reader :meshes
+    attr_accessor :model
 
-    def unload!
-      meshes.each { |mesh| mesh.remove_from_scene }
-    end
-
-    #Note that this method is very similiar to ShatteredController::Actor.
-    #And that a common function can be refactored from both.
-    def method_missing(method, *args)
-      super(method,*args) if !method_defined?(method)
-      retv=nil
-      meshes.each do |mesh| 
-        retv =mesh.send(method, *args) if mesh.method_defined? method
-      end
-      
-      return retv
-    end
-
-    def method_defined?(method)
-      meshes.each { |mesh| return true if mesh.method_defined? method }
-      return super(method)
-    end
-
-    def mesh(file, options={})
-      self.class.mesh(file,options)
-      pre_initialize
-      retv = meshes[-1] # Return the last created mesh
-      return retv
-    end
-
-    def new_mesh=(file)
-      options = {}
-      options[:name]=file.underscore
-      options[:file]=file
-      name = options[:name]
-      mesh = Mesh.new(options)
-      eval("@#{name}=mesh")
-      #keep track of the meshes we create
-      meshes << mesh
-    end
     
-    def meshes
-      @meshes ||= []
-    end
-
     def new_material=(name)
       @materials ||= {}
       name = name.to_sym
@@ -156,44 +94,31 @@ module ShatteredView
       end
     end
 
-    def new_light=(name)
-      @lights ||= {}
-      @lights[name] = ShatteredView::Light.new 
+    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
-        @lights[name]
+        #{array}[\"#{name}\"]
       end
       EOF
     end
 
-    def new_animation=(name)
-      meshes.each do |mesh|
-        mesh.instance_eval <<-EOF
-        class << self
-          define_method(:#{name}) do
-            animation(:#{name})
-          end
-        end
-        EOF
-      end
-    end
-    def new_animation_alias=(name, alias_option)
-      self.class.class_eval <<-EOF
-      define_method(:#{alias_option}) do
-        meshes.each do |mesh|
-          mesh.#{name}.play
-        end
-      end
-      EOF
+    def new_light=(name)
+      define_accessor("@lights", ShatteredView::Light.new, name)
     end
 
-    protected
-    def mesh_public_methods
-      methods=[]
-      meshes.each do |mesh|
-        methods |= mesh.public_methods
-      end
-      return methods
-    end
+    def new_particle_system=(name, template) 
+      define_accessor("@particle_systems", ShatteredView::ParticleSystem.new(template), name)
+    end
+    
   end
 end
+
+
+ShatteredView::Base.class_eval do
+	include ShatteredView::Mesh
+end
+

data/lib/camera.rb

@@ -1,5 +1,5 @@
 module ShatteredView
-  class Camera < Mesh
+  class Camera < Node
     def initialize( scene )
       @scene_object = scene.getCamera
     end

data/lib/extensions.rb

@@ -1,7 +1,10 @@
 module ShatteredOgre
   class Vector3
     def to_a
-      Vector.new(x,y,z)
+      [x, y, z]
+    end
+    def to_v
+      Vector.new x, y, z
     end
   end
 end

data/lib/{animation.rb → mesh/animation.rb}

@@ -7,6 +7,9 @@ class Animation
   def play
     @animation.play
   end
+  def stop
+    @animation.stop
+  end
   def loop=(looping)
     @animation.setLoop(looping);
   end

data/lib/mesh/mesh.rb

@@ -0,0 +1,174 @@
+$:.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 => [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
+    
+      def unload!
+        meshes.each { |mesh| mesh.remove_from_scene }
+      end
+
+      #Note that this method is very similiar to ShatteredController::Actor.
+      #And that a common function can be refactored from both.
+      def method_missing(method, *args)
+        super(method,*args) if !method_defined?(method)
+        retv=nil
+        meshes.each do |mesh| 
+          retv =mesh.send(method, *args) if mesh.method_defined? method
+        end
+
+        return retv
+      end
+
+      def method_defined?(method)
+        meshes.each { |mesh| return true if mesh.method_defined? method }
+        return super(method)
+      end
+
+      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
+        @meshes ||= []
+        @meshes << mesh
+      end
+
+      def meshes
+        @meshes ||= []
+      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
+
+
+      protected
+      def mesh_public_methods
+        methods=[]
+        meshes.each do |mesh|
+          methods |= mesh.public_methods
+        end
+        return methods
+      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 = {} )
+        @name = file.underscore
+        unless defined?(TESTING)
+          @scene_object = ShatteredOgre::Scene.getSingleton.createMesh( [0,0,0].to_v3, "#{file}.mesh" ) 
+          puts "Loading Mesh: #{@scene_object} from #{:file}.mesh"
+          populate_animations
+        else
+          @scene_object = MockObject.new
+        end
+      end
+      # This is overriden from ShatteredSupport's extension to Object 
+      # missing alias's
+      def method_defined?( method )
+        return (super(method) or @animations.include?(method))
+      end
+      
+      # Access a given animation.  Returns nil on failure.
+      def animation( animation )
+        return @animations[animation]
+      end
+      
+
+    private
+  
+      # populate_animations queries ShatteredOgre and adds the found animations to the mesh.
+      def populate_animations
+        @animations = {}
+        (0...@scene_object.getNumberOfAnimations).each do |idx|
+          name = @scene_object.getAnimationName(idx)
+          @animations[name.downcase.to_sym] = ShatteredView::Animation.new(@scene_object, name)
+        end
+      end
+      
+      
+    end
+  end
+end

data/lib/node.rb

@@ -0,0 +1,69 @@
+module ShatteredView
+  class Node
+    
+    # Remove the Ogre Mesh from the scene
+    def remove_from_scene
+      @scene_object.removeFromScene
+    end
+    
+    def position=( *array )
+      array = array[0] if(array.length == 1)
+      @scene_object.setPosition array.to_v3
+    end
+  
+    # uses #look_at
+    def looking_at=( *look_toward )
+      look_toward = look_toward[0] if(look_toward.length == 1)
+      look_at(look_toward)
+    end
+  
+    def position
+      @scene_object.getPosition.to_v
+    end
+  
+    # look_at a Vector, Mesh, or Actor.
+    def look_at( position )
+      position = position.position unless position.is_a?(ShatteredOgre::Vector3) || position.is_a?(Vector) || position.is_a?(Array)
+      position = position.to_v3 unless position.is_a?(ShatteredOgre::Vector3) 
+      @scene_object.lookAt(position)
+      #  raise ArgumentError, "#{position.inspect} is not a Mesh, Actor, or Vector."
+    end
+  
+    # rotate along axis, degrees amount
+    def rotate( axis, degrees )
+      axis = axis.to_v.normalize
+      @scene_object.rotate(axis.to_v3, degrees)
+    end
+  
+    def rotation=(axis, degrees)
+      rotate axis, degrees
+    end
+  
+    def scale=(*scale)
+      scale = scale[0]                    if scale.length == 1
+      scale = [scale, scale, scale].to_v  if scale.kind_of?(Numeric)
+      scale = scale.to_v
+      
+      @scene_object.scale scale.to_v3
+    end
+    
+    def scale(amount)
+      amount = amount.to_v3 unless amount.is_a? Fixnum
+      @scene_object.scale amount
+    end
+  
+    def material=( material )
+      if material.is_a? RMaterial
+        @scene_object.generateTangents if material.tangent_space
+        material = material.name
+      end
+      @scene_object.setMaterial(material.to_s)
+    end
+  
+    def visible=(visible)
+      @scene_object.setVisible(visible)
+    end
+  
+    
+  end
+end

data/lib/resources.rb

@@ -1,6 +1,5 @@
 require 'singleton'
 
-
 module ShatteredView
   # Resource Handler is the ruby binding around Ogre's resource handler
   # It provides all types of shortcuts for finding files and adding new paths.
@@ -15,10 +14,10 @@ module ShatteredView
     
     def add_resource_paths(*paths)
       paths.each do |path|
-        path = SHATTERED_ROOT + path
+        path = SHATTERED_ROOT + "/"+path
         @resource_paths << path
         each_directory_in_path(path) do |sub_path|
-          ShatteredOgre::ResourceHandler.getSingleton.addResourcePath(sub_path)
+          ShatteredOgre::ResourceHandler.getSingleton.addResourcePath(sub_path)
         end
       end
     end
@@ -30,34 +29,19 @@ module ShatteredView
     # This is useful for any extension wanting to load resource files:
     #
     # Usage:
-    #   ResourceHandler.instance.find_files_by_extensions("ogg","mp3","wav")
+    #   Resources.instance.find_files_by_extensions("ogg","mp3","wav")
     def find_files_by_extensions(*extensions)
-      reg_exp = /\.(#{extensions.join("|")})$/
-      files = []
-      @resource_paths.each do |path|
-        each_file_in_path(path) do |filename|
-          files << filename if filename =~ reg_exp
-        end
-      end
-      return files
+      File.find_by_extensions(@resource_paths,*extensions)
     end
     
-    def each_file_in_path(path)
-      each_directory_in_path do |directory|
-        Dir.foreach( directory ) do |filename|
-          resource = directory + "/#{filename}"
-          yield(resource) if File.file? resource
-        end
-      end
+    # This is deprecated in favor of File.each_in_path
+    def each_file_in_path(path, &block)
+      File.each_in_path(path, &block)
     end
     
-    def each_directory_in_path(path,&block)
-      Dir.foreach(path) do |directory|
-        next if directory =~ /\..*/
-        full_path = "#{path}/#{directory}"
-        yield full_path
-        each_directory_in_path(full_path, &block)
-      end
+    # This is deprecated in favor of Dir.each_in_path
+    def each_directory_in_path(path,&block)
+      Dir.each_in_path(path, &block)
     end
   end
 end

data/lib/runner.rb

@@ -1,12 +1,36 @@
+require 'erb'
 
 module ShatteredView
   class Runner
     def initialize(options = {})
+      generate_plugin_config
       Resources.instance.add_resource_paths("/app/views", "/media")
       @renderer = ShatteredOgre::Renderer.new
       raise Error, "Renderer failed to initialize Ogre" if @renderer.failed
       @scene = ShatteredOgre::Scene.new(translate_to_scene_type(options[:scene_manager]))
     end
+    def generate_plugin_config
+      plugin_directory = SHATTERED_ROOT+"/config/"
+      generated_plugin = plugin_directory+ "plugins."
+      generator = plugin_directory + "ogre_plugins.rcfg"
+      if PLATFORM =~ /mswin/
+        generated_plugin += "win32"
+      elsif PLATFORM =~ /darwin/
+        generated_plugin += "darwin" 
+      else
+        generated_plugin += "linux"
+      end
+      process_plugin(generator, generated_plugin+".cfg")
+    end
+    def process_plugin(base, generate_to)
+      puts "Generating #{generate_to} from #{base}, #{File.exists?(base)}"
+      return unless File.exists?(base)
+      generated_banner = "\n\r//=== This file is generated.  Modify the .rcfg instead. ===\n\r\n\r"
+      to_write = generated_banner + ERB.new(File.open(base,"r").read).result + generated_banner
+      output = File.open(generate_to, "w")
+      output.syswrite(to_write)
+      output.close
+    end
     def translate_to_scene_type( symbol )
       return ShatteredOgre::Scene::Generic if(symbol == :general)
       return ShatteredOgre::Scene::Terrain if(symbol == :terrain)

data/lib/shattered_view.rb

@@ -1,22 +1,23 @@
-require "active_support"
 ["shattered_support","shattered_ogre"].each do |dependency|
   begin
-    # require File.dirname(__FILE__)+"/../../#{dependency}/lib/#{dependency}"
-    #shattered_ogre is not getting included????
     require dependency
-  rescue MissingSourceFile
+  rescue LoadError => e
     require 'rubygems'
     require dependency
   end
 end
 
+raise( ShatteredSupport::Error, "Could not find ShatteredOgre (a ShatteredView dependency)" ) if not defined? ShatteredOgre
+
+require 'rubygems'
+require "active_support"
 
-require File.dirname(__FILE__) + '/animation'
 require File.dirname(__FILE__) + '/utilities'
-require File.dirname(__FILE__) + '/mesh'
+require File.dirname(__FILE__) + '/node'
 require File.dirname(__FILE__) + '/camera'
 require File.dirname(__FILE__) + '/extensions'
 require File.dirname(__FILE__) + '/runner'
-require File.dirname(__FILE__) + '/base'
 require File.dirname(__FILE__) + '/rmaterial'
-require File.dirname(__FILE__) + '/resource_handler'
+#require File.dirname(__FILE__) + '/particle_system'
+require File.dirname(__FILE__) + '/base'
+require File.dirname(__FILE__) + '/resources'

data/lib/utilities.rb

@@ -1,58 +1,7 @@
-
-  class Array
-    def shuffle; sort_by {rand}; end
-    def to_v; 
-      raise StandardError, "vector #{self.inspect} does not have 3 elements" if self.length < 3
-      return Vector3.new(self[0],self[1],self[2]); 
-      end
-  end
-  
 module ShatteredView
-  class Vector < Array
-    def initialize(*args)
-      raise ArgumentError, "Vector takes three inputs on initialize" if args.length != 3
-      args.each { |value| self << value }
-    end
-    def +(args)
-      return (self.to_v + args.to_v).to_a
-    end
-    def -(args)
-      return (self.to_v - args.to_v).to_a
-    end
-    def *(value)
-      return (self.to_v*value).to_a
-    end
-    def x
-      self[0]
-    end
-    def y
-      self[1]
-    end
-    def z
-      self[2]
-    end
-#     def x=(ix)
-#       self[0] = ix
-#     end
-#     def y=(iy)
-#       self[1] = iy
-#     end
-#     def z=(iz)
-#       self[2] = iz
-#     end
-  end
   class MockObject
     def method_missing(sym, *args)
       MockObject.new
     end
   end
-
-
-#  class Vector3
-#    def to_s
-#      return "(#{x},#{y},#{z})"
-#    end
-#  end
-
-
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.8.11
+rubygems_version: 0.8.10
 specification_version: 1
 name: shattered_view
 version: !ruby/object:Gem::Version 
-  version: "0.3"
-date: 2006-04-28 00:00:00 -05:00
+  version: 0.3.1
+date: 2006-05-16
 summary: "Shattered View: Manipulates OGRE in a ruby-esque fashion."
 require_paths: 
-- lib
+  - lib
 email: 
 homepage: http://www.hastilymade.com
 rubyforge_project: 
@@ -18,39 +18,32 @@ bindir: bin
 has_rdoc: "true"
 required_ruby_version: !ruby/object:Gem::Version::Requirement 
   requirements: 
-  - - ">"
-    - !ruby/object:Gem::Version 
-      version: 0.0.0
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
   version: 
 platform: ruby
-signing_key: 
-cert_chain: 
 authors: []
-
 files: 
-- lib/animation.rb
-- lib/base.rb
-- lib/camera.rb
-- lib/extensions.rb
-- lib/game.rb
-- lib/light.rb
-- lib/mesh.rb
-- lib/resources.rb
-- lib/rmaterial.rb
-- lib/runner.rb
-- lib/shattered_view.rb
-- lib/utilities.rb
+  - lib/base.rb
+  - lib/camera.rb
+  - lib/extensions.rb
+  - lib/game.rb
+  - lib/light.rb
+  - lib/node.rb
+  - lib/resources.rb
+  - lib/rmaterial.rb
+  - lib/runner.rb
+  - lib/shattered_view.rb
+  - lib/utilities.rb
+  - lib/mesh/animation.rb
+  - lib/mesh/mesh.rb
 test_files: []
-
 rdoc_options: []
-
 extra_rdoc_files: []
-
 executables: []
-
 extensions: []
-
 requirements: 
-- Shattered View is reliant on OGRE.
-dependencies: []
-
+  - Shattered View is reliant on OGRE.
+dependencies: []

data/lib/mesh.rb

@@ -1,79 +0,0 @@
-
-   module ShatteredView
-    class Mesh
-      def remove_from_scene
-        @scene_object.removeFromScene
-      end
-      def initialize( options = {} )
-        if options[:test] != true
-          puts "Loading Mesh: #{@scene_object} from #{options[:file]}.mesh"
-          @scene_object = Scene.getSingleton.createMesh( Vector3.new(0,0,0), "#{options[:file]}.mesh" ) 
-          populate_animations
-        else
-          @scene_object = MockObject.new
-        end
-      end
-      def populate_animations
-        @animations = {}
-        (0...@scene_object.getNumberOfAnimations).each do |idx|
-          name = @scene_object.getAnimationName(idx)
-          @animations[name.downcase.to_sym] = ShatteredView::Animation.new(@scene_object, name)
-        end
-      end
-      def position=( *array )
-        array = array[0] if(array.length == 1)
-        @scene_object.setPosition array.to_v
-      end
-      def looking_at=( *look_toward )
-        look_toward = look_toward[0] if(look_toward.length == 1)
-        look_at(look_toward)
-      end
-      def position
-        @scene_object.getPosition.to_a
-      end
-      def look_at( position )
-        if position.is_a?(Array)
-          @scene_object.lookAt(position.to_v)
-        elsif position.is_a?(ShatteredOgre::Vector3)
-          @scene_object.lookAt(position)
-        elsif(position.is_a?(Mesh) || position.is_a?(Actor))
-          @scene_object.lookAt(position.position.to_v)
-          elsif position.is_a?(ShatteredOgre::Vector3)
-        else 
-          raise ArgumentError, "#{position.inspect} is not a Mesh, Actor, or Vector."
-        end
-      end
-      def rotate( axis, degrees )
-        @scene_object.rotate(axis.to_v, degrees)
-      end
-      def rotation=(axis, degrees)
-        rotate axis, degrees
-      end
-      def animation( animation )
-        return @animations[animation]
-      end
-      def scale=( *scale )
-        if(scale.length == 1)
-          scale=scale[0]
-          @scene_object.scale( [scale,scale,scale].to_v )
-        else
-          @scene_object.scale( scale.to_v )
-        end
-      end
-      def material=( material )
-        if material.is_a? RMaterial
-          @scene_object.generateTangents if material.tangent_space
-          material = material.name
-        end
-        @scene_object.setMaterial(material.to_s)
-      end
-      def visible=(visible)
-        @scene_object.setVisible(visible)
-      end
-      # This is overriden from ShatteredSupport's extension to Object 
-      # missing alias's
-      def method_defined?( method )
-        return (super(method) or @animations.include?(method))
-      end
-    end
-  end