shattered 0.5.0.1 → 0.7.0

data/lib/shattered_view/ogrerb/scene_node.rb

@@ -0,0 +1,76 @@
+module Ogre
+  module NodeMovements
+    def self.redefine_methods(c)
+      c.class_eval do
+        # Node delegates
+    		{
+    			:position => :get_position,
+    			:position= => :set_position,
+    			:direction= => :set_direction,
+    			:orientation= => :set_orientation,
+    			:orientation => :get_orientation,
+    			:translate! => :translate,
+    		}.each do |method, delegate|
+    			define_method(method) do |*args|
+    				send(delegate, *args)
+    			end
+    		end
+    		
+     	end
+  	end
+  end
+  
+  NodeMovements.redefine_methods(SceneNode)
+  NodeMovements.redefine_methods(Camera)
+  
+  class SceneNode
+    alias_method :raw_rotate, :rotate
+   
+    # rotate works in degrees by default, and in the TS_lOCAL space
+  	def rotate(axis, amount, *args)
+  		if(args.empty?)
+  		  raw_rotate(axis.to_v, Radian.new(Degree.new(amount)))
+  		else
+  			raw_rotate(axis.to_v, Radian.new(Degree.new(amount)), args[0])
+  		end
+  	end
+  
+  	alias_method :raw_look_at, :look_at
+  	
+  	# Look at an object
+  	# This function is different than the one in the Ogre SDK because
+  	# it defaults to TS_LOCAL as the transform space
+  	# You can send it a node, mesh, or anything with a position vector
+  	# Or just a vector
+  	def look_at(*args)
+  		transform = Ogre::Node::TS_LOCAL
+  		transform = args[1] if(args.length == 2)		
+  		v = args[0]
+  		v = args[0].position if args[0].class.respond_to? :position
+  		raw_look_at v, transform
+  	end
+  	  	    		
+		# scale= works with numbers, vectors, or 3 numbers and is absolute
+		def scale=(*args)
+			v = args
+			
+			# This handles calling scale=0.5 or some other number
+			v = v(v[0], v[0], v[0]) if v[0].is_a? Numeric
+			
+			set_scale(*v)
+		end
+		
+		alias_method :raw_scale, :scale
+		
+		#scale works with numbers, vectors, or 3 numbers and is relative
+		def scale(*args)
+			return get_scale if args.length == 0
+			v = args
+			
+			# This handles calling scale=0.5 or some other number
+			v = v(v[0], v[0], v[0]) if v[0].is_a? Numeric
+			
+			raw_scale(*v)
+		end
+  end
+end

data/lib/shattered_view/ogrerb/vector.rb

@@ -0,0 +1,243 @@
+class Object
+  # This is a shorthand to define vector object coordinates.
+  #
+  # Creates a vector object at coordinates x,y,z
+  def v(x, y, z) 
+    Ogre::Vector3.new(x, y, z) 
+  end
+end
+
+# The following allows multiplication to be written like
+#  10 * v(1,0,0)
+# or 
+#  10 * :x
+# implemented for both Float and Fixnum
+class Float
+  alias_method :numeric_times, :*
+  def *(val)
+    unless val.is_a? Numeric
+      return val*self
+    end
+    return numeric_times(val)
+  end
+end
+
+class Fixnum
+  alias_method :numeric_times, :*
+  def *(val)
+    unless val.is_a? Numeric
+      return val*self
+    end
+    return numeric_times(val)
+  end
+end
+
+class SymbolToVectorError < StandardError #:nodoc:
+end
+
+class Symbol #:nodoc:
+  #  Vectors in symbol form can be any of the following:
+  #  :x => v(1,0,0)
+  #  :y => v(0,1,0)
+  #  :z => v(0,0,1),
+  #  :up => v(0,1,0)
+  #  :down => v(0,-1,0)
+  #  :left => v(-1,0,0)
+  #  :right => v(1,0,0)
+  #  :forward => v(0,0,1)
+  #  :backward => v(0,0,-1)
+  #  :zero => v(0,0,0)
+  def to_v
+    @definitions ||= {:x => v(1,0,0),:y => v(0,1,0),:z => v(0,0,1),
+                    :up => v(0,1,0),:down => v(0,-1,0),
+                    :left => v(-1,0,0),:right => v(1,0,0),
+                    :forward => v(0,0,1),:backward => v(0,0,-1),
+                    :zero => v(0,0,0)}
+    return @definitions[self] unless @definitions[self].nil?
+    raise SymbolToVectorError, "Undefined vector for symbol #{self}"
+  end
+  
+  # Multiplication defined for vectors carries over to their symbolic equivalence.
+  def *(number)
+    to_v * number
+  end
+  
+  # Addition for vectors
+  def +(number)
+    to_v + number
+  end
+  
+  # Subtraction for vectors
+  def -(number)
+		to_v - number
+	end
+	
+	# Negation for vector symbols
+	def -@
+	  -to_v
+  end
+end
+
+class Array #:nodoc:
+  # Vector extensions for array.  Allows for coersion of a 3 element Array into a vector.
+  
+  # Randomize the order of an array
+  #
+  #   [1, 2, 3].shuffle #=> [2, 3, 1]
+  #
+  def shuffle
+    sort_by {rand}
+  end
+  
+  # Create a vector from an array.
+  #
+  #   [1, 2, 3].to_v #=> same as Vector.new(1, 2, 3)
+  #
+  def to_v
+    raise StandardError, "vector #{self.inspect} does not have 3 elements" if self.length < 3
+    Ogre::Vector3.new self[0], self[1] ,self[2]
+  end
+end
+  
+module Ogre
+# Vector is a three dimensional array, that allows for various operations on itself.
+# To create a vector, use the shorthand:
+#   v(0,0,0) # Creates a zero vector
+#
+#
+# *NOTE:* The recomended way to create Vector objects is to use the <tt>v(1,2,3)</tt> shorthand.
+
+class Vector3
+
+	
+	# Iterate through x, y and z with a block.  The passed value is the value of each component of 
+	# the vector.
+	def each(&block)
+		[x,y,z].each do |component|
+			yield component
+		end
+	end
+	
+	# Returns self
+	def to_v
+		self
+	end
+	
+	# Returned an array with x, y and z dumped into its elements.
+	#   v(1, 2, 3).to_a #=> [1.0, 2.0, 3.0]
+	# Deprecated because *v(0,0,0) is [0,0,0] (three arguments) and breaks DSLs
+	#def to_a
+	#	raise "Vector#to_a is deprecated.  Use vectors as vectors, not as arrays."
+	#end
+	
+	# Add 2 Vectors together.
+	#   v(1,1,1) + v(1,2,3) #=> v(2,3,4)
+	alias_method :ogre_plus, :+
+	def +(*args)
+		v = convert_args_to_vector args
+		ogre_plus v
+	end
+	
+	# Subtract one Vector from another.
+	#   v(1,2,3) - v(1,1,1) #=> v(0,1,2)
+	alias_method :ogre_minus, :-
+	def -(*args)
+		v = convert_args_to_vector args
+		ogre_minus v
+	end
+	
+	# Multiply all components of a vector by a scalar amount.
+	#   v(1,2,3) * 3 #=> v(3,6,9)
+	alias_method :ogre_multiply, :*
+	def *(*args)
+		#Handle numbers and vectors
+		unless args[0].is_a? Symbol 
+			return ogre_multiply(args[0])
+		end
+		#Symbol to vector conversion
+		v = convert_args_to_vector args
+		ogre_multiply v
+	end
+	
+	
+	# Returns this Vector but normalized to a length of 1.
+	#   v(9, 0, 0).normalize #=> v(1,0,0)
+	alias_method :normalize, :normalised_copy
+	alias_method :normalise, :normalised_copy
+	
+	# Same as #normalize but modifies the receiver in place.
+	alias_method :normalize!, :normalise!
+	
+	# Return the value specified by bracket notation.  Integers, Symbols or Strings
+	# are accepted as keys.
+	#   
+	#   vector = v(1,2,3)
+	#   vector[:x]  #=> 1
+	#   vector['y'] #=> 2
+	#   vector[2]   #=> 3
+	def [](index)
+		case
+			when index == 0 || index == :x || index == 'x'
+				x
+			when index == 1 || index == :y || index == 'y'
+				y
+			when index == 2 || index == :z || index == 'z'
+				z
+		end
+	end
+	
+	# Set the value specified by bracket notation.  Accepts the same keys as the #[] 
+	# method.
+	def []=(index, value)
+		case
+			when index == 0 || index == :x || index == 'x'
+				self.x = value.to_f
+			when index == 1 || index == :y || index == 'y'
+				self.y = value.to_f
+			when index == 2 || index == :z || index == 'z'
+				self.z = value.to_f
+		end
+	end	
+	
+	
+	# Converts the vector into an easily identifiable form.  Mostly used for debugging
+	# and console output.
+	#   v(1,2,3).to_s #=> "#<Vector [1.0, 2.0, 3.0]>"
+	def to_s
+		"#<Vector [#{x}, #{y}, #{z}]>"
+	end
+	
+	# Equality test.  This method will return true if all components of both vectors are
+	# indentical.
+	def ==(vector)
+	  vector = vector.to_v if vector.is_a?(Symbol)
+		vector.kind_of?(Ogre::Vector3) && 
+		x == vector.x           && 
+		y == vector.y           &&
+		z == vector.z
+	end
+	
+	# Create a unique identifier based on x, y and z.
+	def hash
+	  [x,y,z].hash
+  end
+  
+  # Equality test for hash indexes.
+  def eql?(other)
+    x == other.x && y == other.y && z == other.z
+  end
+	
+private
+	
+	# Convert passed in arguments to vector form.
+	# Supports Symbol, Array, and vectors
+	def convert_args_to_vector(*args)
+		args.flatten!
+		if(args.first.is_a?(Ogre::Vector3) || args.first.is_a?(Symbol))
+			args.first.to_v
+		else
+			args.to_v
+		end
+	end
+end
+end

data/lib/shattered_view/ogrerb/window_event.rb

@@ -0,0 +1,14 @@
+
+module Ogre
+  class WindowEvents
+    alias_method :ogre_on_resize, :on_resize
+    alias_method :ogre_on_close, :on_close
+    def on_resize(&block)
+      ogre_on_resize block
+    end
+    
+    def on_close(&block)
+      ogre_on_close block
+    end
+  end
+end

data/lib/shattered_view/resources.rb

@@ -0,0 +1,64 @@
+require 'singleton'
+
+module Shattered
+  # Resource Handler is the ruby binding around Ogre's resource handler
+  # It provides all types of shortcuts for finding files and adding new paths.
+  class Resources
+    include Singleton
+    
+    # Instance Methods
+    attr_reader :resource_paths
+    def initialize
+      @resource_paths=[]
+    end
+    
+    def add_resource_paths(*paths)
+      paths.each do |path|
+      	next if path.nil?
+        path = SHATTERED_ROOT + "/"+path unless path =~ /^\//
+        
+        @resource_paths << path
+        each_directory_in_path(path) do |sub_path|
+       	  Ogre::ResourceGroupManager.instance.add_resource_location(sub_path, "FileSystem", "General")
+        end
+      end
+    end
+    
+    # Called once all resource groups have been added
+    def setup
+    	begin
+				Ogre::ResourceGroupManager::instance.initialise_all_resource_groups
+  		rescue StandardError => bang
+  			puts "WARNING #{bang.message}"
+			end
+  	end
+    
+    def destroy_paths
+      @resource_paths = []
+    end
+
+    # This is useful for any extension wanting to load resource files:
+    #
+    # Usage:
+    #   Resources.instance.find_files_by_extensions("ogg","mp3","wav")
+    def find_files_by_extensions(*extensions)
+      File.find_by_extensions(@resource_paths,*extensions)
+    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
+    
+    # This is deprecated in favor of Dir.each_in_path
+    def each_directory_in_path(path,&block)
+      Dir.each_in_path(path, &block)
+    end
+    
+    # find a particular file in the resource paths
+    def find_file(filename)
+      File.find(@resource_paths, filename)
+    end
+
+  end
+end

data/lib/shattered_view/shattered_view.rb

@@ -0,0 +1,248 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+  
+module Shattered #:nodoc:
+
+  module View
+    def self.append_features(base)
+      super
+      base.extend(ClassMethods)
+	    base.send(:include, InstanceMethods)
+	    base.send(:include, PreInitialize)
+      base.send(:before_init_call, "setup_variables")
+      base.send(:include, Unload)
+    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.
+      #
+      #    class DirtyRubyView
+      #      mesh "dirty_ruby", :position => v(0,0,1)
+      #    end
+      #
+      def mesh(name, options = {})
+      	before_init_call :dsl_create, :mesh, name, options
+      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.
+      #
+      #   Note: The following type of light is not currently implemented in shattered.
+      #   Spotlight - this light has both a direction and a position, as well as other factors.
+      #   Example:  light :flashlight...
+
+      def light(name, type = nil, options = {})
+        before_init_call :dsl_create, :metalight, name, type, options
+      end
+
+      #  The following is not yet implemented:
+      #  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 = {})
+      #  before_init_call :dsl_create, :particle_system, name
+      #end
+    end
+
+    module InstanceMethods
+      attr_accessor :controller, :model
+      attr_reader :lights, :meshes, :materials
+
+		  def setup_variables
+			  @lights = []
+			  on_unload do
+ 			    @lights.each { |light| scene_manager.destroy_light(light) }
+          @lights = []
+		    end
+		    
+		    @materials = []
+		    on_unload do
+		      @materials.each { |material| Ogre::MaterialManager.instance.remove(material.name) }
+		      @materials = []
+	      end
+	      
+			  @meshes = []			  
+        on_unload do 
+          @meshes.each { |mesh| mesh.unload }
+          @meshes = []
+        end
+		    
+		    @particle_systems = []
+		    on_unload do
+		      @particle_systems.each { |ps| ps.unload }
+		    end
+		  end
+		      
+      def visible=(visible)
+        node.visible=(visible)
+      end
+      
+      def rotate(vector, amount)
+        node.rotate(vector, amount)
+      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 dsl_create(type, *args)
+			  name = args[0]
+			  options = args[-1]
+			  object = create(type, *args) 
+			
+        # Create an accessor for the object
+        self.class.send(:define_method, name) do 
+        	object
+        end
+     		call_object_function_for_each_key(object, options)   
+		  end
+		
+		  # The method of creating new view objects,
+		  # IE: create(:light)
+		  # or create :mesh, :ogre
+		  # or create :material, :basic, :texture => "blank.jpg"
+      def create(type, *args)
+    		return self.send(:"create_#{type}", *args)
+      end
+      
+      
+      def position
+        node.position
+      end
+
+		  def position=(val)
+			  node.position = val
+		  end
+      
+      def translate(v)
+        node.translate(v)
+      end
+      
+      def node
+        @scene_node ||= scene_manager.root_scene_node.create_child_scene_node
+      end
+      
+      def scene_manager
+        Game.instance.scene_manager
+      end
+      
+    private
+      #Called from the meta function
+      def create_metalight(name, *args)
+        create_light(*args)
+      end
+      
+      #Create a light and add it to the lights array
+      def create_light(type = nil, options = {})
+        @@unnamed_light_index ||= -1
+        light = scene_manager.create_light("#{self.to_s}.light(#{@@unnamed_light_index+=1})")
+      	
+      	if type == :spotlight
+      	  light.set_type Ogre::Light::LT_POINT
+      	elsif type == :directional
+      	  light.set_type Ogre::Light::LT_DIRECTIONAL
+      	elsif type == :point
+      	  light.set_type Ogre::Light::LT_POINT
+    	  elsif type != nil
+    	    raise Exception.new("Invalid light type '#{type}'")
+    	  end
+    	  
+    	  light.scene_manager = scene_manager
+ 			  
+ 			  @lights << light
+   			return light
+    	end
+
+		  #Creates a mesh and adds it to the mesh array
+      def create_mesh(name, options={})
+        mesh = Ogre::MeshInstance.new(node, scene_manager, name.to_s+".mesh")
+    		@meshes << mesh
+    		return mesh
+    	end
+
+		  #Create a node using the view's node as a parent
+		  def create_node(options={})
+			  node.create_child_scene_node
+		  end
+		
+		  #Create a material and add it to the materials array
+		  def create_material(template, options={})
+	      #pull the rmaterial from any resource path
+	      file = Resources.instance.find_file("#{template}.rmaterial")
+	      
+	      name = options[:name]
+	      @@unnamed_material_index ||= -1
+        name = "UnnamedMaterial(#{@@unnamed_material_index+=1})" if name.nil?
+        name = name.to_sym
+        
+        rmaterial = Ogre::RMaterial.new(file)
+        rmaterial.name = name
+        #Set values
+        options.each do |option|
+      		rmaterial.send("#{option[0]}=".to_sym, option[1])	
+	    	end
+        rmaterial.parse
+      	@materials << rmaterial.create_ogre_material
+				@materials.last.name = name.to_s
+				return @materials.last
+		  end
+
+      # Creates an ogre particle system from a template.  Will create a new template if one is not requested
+      def create_particle_system(template=nil, options={})
+        @@unnamed_particle_system_index = -1
+        template = "UnnamedParticleSystem#{@@unnamed_particle_system_index+=1}" if template.nil?
+        particle_system = Ogre::ParticleSystemManager.instance.get_template(template.to_s)
+        if particle_system.nil? #Todo:  Resource groups?
+          particle_system = Ogre::ParticleSystemManager.instance.create_template(template.to_s, "General") 
+          log.info "Creating new particle system template '#{template}'"
+        end
+        
+        # Sometimes the particle system will already have a parent node... what do we do then?
+        particle_system.node = create :node if particle_system.get_parent_node.nil?
+        
+        @particle_systems << particle_system
+        return particle_system
+      end
+      
+      #Returns the logger
+      def log
+        return Game.instance.log
+      end
+
+    end
+  end
+end
+
+