shattered_pack 0.3.3

data/lib/shattered_view/node.rb

@@ -0,0 +1,113 @@
+module ShatteredView
+  class Node
+    attr_reader :position
+    attr_accessor :scene_node
+    
+    #Returns the SceneManager::RootNode wrapped in ShatteredView::Node
+    def Node.root 
+      @@root ||= Node.new
+      @@root.scene_node = ShatteredOgre::Scene.getSingleton.getRootSceneNode
+      return @@root
+    end
+    
+    #Everything attached to this object
+    def children
+      @children ||= []
+    end
+
+    def initialize(parent = nil)
+      @position = v(0,0,0)
+      # Create an empty unassociated node.
+      @scene_node = ShatteredOgre::Scene.getSingleton.createSceneNode
+      attach_to(parent)
+    end
+    
+    # Use attach_to instead
+    def attach_child(child)
+      children << child
+      child.scene_node.attachTo(scene_node)
+    end
+    
+    # Use attach_to on the child node (with nil if you want to clear the parent)
+    def remove_child(child)
+      @children.delete child
+    end
+    
+    #Set a new parent node for the object
+    def attach_to(new_parent)
+      @parent.remove_child(self) unless @parent.nil?
+      @parent = new_parent
+      new_parent.attach_child(self) unless new_parent.nil?
+    end
+    
+    # Move the node a certain amount
+    def translate(v)
+      @position += v
+      synchronize
+    end
+    
+    def position=(v)
+      @position = v.to_v
+      synchronize
+    end
+    
+    # uses #look_at
+    def looking_at=( *look_toward )
+      look_toward = look_toward[0] if(look_toward.length == 1)
+      look_at(look_toward)
+    end
+    
+    alias_method :look_at=, :looking_at=
+  
+    # 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_node.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_node.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_node.scale scale.to_v3
+    end
+    
+    def scale(amount)
+      amount = amount.to_v3 unless amount.is_a? Fixnum
+      scene_node.scale amount
+    end
+  
+    def material=( material )
+      if material.is_a? RMaterial
+        scene_node.generateTangents if material.tangent_space
+        material = material.name
+      end
+      scene_node.setMaterial(material.to_s)
+    end
+  
+    def visible=(visible)
+      scene_node.setVisible(visible)
+    end
+    
+    # Synchronize the position with C++, this is called every frame. However
+		# there are times where scene_node hasn't been initialized quite yet
+		# (such as right when a new actor is in the process of being created), so
+		# only synchronize if there's something to synchronize
+    def synchronize
+      @scene_node.setPosition(position.to_v3) unless @scene_node.nil?
+    end
+  end
+end

data/lib/shattered_view/resources.rb

@@ -0,0 +1,47 @@
+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.
+  class Resources
+    include Singleton
+    
+    # Instance Methods
+    attr_reader :resource_paths
+    def initialize
+      @resource_paths=[]
+    end
+    
+    def add_resource_paths(*paths)
+      paths.each do |path|
+        path = SHATTERED_ROOT + "/"+path
+        @resource_paths << path
+        each_directory_in_path(path) do |sub_path|
+          ShatteredOgre::ResourceHandler.getSingleton.addResourcePath(sub_path) unless defined? TESTING
+        end
+      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
+  end
+end

data/lib/shattered_view/rmaterial.rb

@@ -0,0 +1,43 @@
+require 'erb'
+
+module ShatteredView
+  class RMaterial
+    attr_reader :result, :name
+    def load!(file)
+      begin
+        evaluate!(File.open(file).readlines.join(''))
+      rescue Errno::ENOENT => bang
+        raise Errno::ENOENT, "RMaterial for #{name} not found: #{bang.message}"
+      end
+    end
+    def create_ogre_material!
+      ShatteredOgre::ResourceHandler.getSingleton.addCustomMaterial(name.to_s, result)
+    end
+    def create_ogre_material=(*args)
+      load!("#{SHATTERED_ROOT}/media/templates/#{template}.rmaterial")
+      create_ogre_material!
+    end
+    def method_missing(name, *args)
+      # Check if the method is a setter
+      if name.to_s[-1].chr == "="
+        name = name.to_s[0...-1].to_sym
+        # Set the instance variable to the sent variable
+        ivar = :"@#{ name }"
+        instance_variable_set(ivar, args[0])
+      else
+        begin
+          return eval("@#{name}")
+        rescue StandardError => bang
+          raise NoMethodError, "Rmaterial could not find the #{name} attribute: #{bang.message}"
+        end
+      end
+    end
+    def evaluate!(template)
+      evaluator = ERB.new(template)
+      return @result ||= evaluator.result(binding)
+    end
+    def tangent_space
+      false
+    end
+  end
+end

data/lib/shattered_view/runner.rb

@@ -0,0 +1,48 @@
+require 'erb'
+
+module ShatteredView
+  class Runner #:nodoc:
+    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)
+      return ShatteredOgre::Scene::Nature if(symbol == :nature)
+      return ShatteredOgre::Scene::NaturePaging if(symbol == :paging)
+      return ShatteredOgre::Scene::Indoor if(symbol == :indoor)
+    end
+    def add_to_environment(environment)
+      environment[:scene]=@scene
+      environment[:renderer]=@renderer
+      environment[:camera]=Camera.new @scene
+      environment[:input]=ShatteredOgre::Input.new
+    end
+  end
+end

data/lib/shattered_view/utilities.rb

@@ -0,0 +1,7 @@
+module ShatteredView
+  class MockObject
+    def method_missing(sym, *args)
+      MockObject.new
+    end
+  end
+end

data/lib/shattered_view/vector.rb

@@ -0,0 +1,242 @@
+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) 
+    Vector.new(x, y, z) 
+  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)
+    return to_v * number
+  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
+    Vector.new self[0], self[1] ,self[2]
+  end
+  
+  # Returns this Array as an Ogre vector object: Vector3.  Should only be used internally by
+  # Shattered to communicate with the Ogre engine.
+  def to_v3
+    self.to_v.to_v3
+  end
+end
+  
+# 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
+class Vector
+	
+	attr_reader :x, :y, :z
+	
+	# Create a new Vector object.  It requires exactly 3 arguments: x, y and z.  Any value that
+	# can be converted to a float is acceptable.
+	#
+	# *NOTE:* The recomended way to create Vector objects is to use the <tt>v(1,2,3)</tt> shorthand.
+	def initialize(x_val, y_val, z_val)
+		@x, @y, @z = [x_val, y_val, z_val].collect{ |x| x.to_f }
+	end
+	
+	# Iterate through x, y and z with a block.  The passed value is the value of each component of 
+	# the vector.
+	def each(&block)
+		self.to_a.each do |component|
+			yield component
+		end
+	end
+	
+	# Returns this Vector as an Ogre vector object: Vector3.  Should only be used internally by
+	# Shattered to communicate with the Ogre engine.
+	def to_v3 # :nodoc:
+		ShatteredOgre::Vector3.new @x, @y, @z
+	end
+	
+	# Returns self
+	def to_v
+		self
+	end
+	
+	# Returns an array with x, y and z dumped into its elements.
+	#   v(1, 2, 3).to_a #=> [1.0, 2.0, 3.0]
+	def to_a
+		[@x, @y, @z]
+	end
+	
+	# Add 2 Vectors together.
+	#   v(1,1,1) + v(1,2,3) #=> v(2,3,4)
+	def +(*args)
+		vector = convert_args_to_vector(args)
+		Vector.new(
+			self.x + vector.x,
+			self.y + vector.y,
+			self.z + vector.z
+		)
+	end
+	
+	# Subtract one Vector from another.
+	#   v(1,2,3) - v(1,1,1) #=> v(0,1,2)
+	def -(args)
+		vector = convert_args_to_vector(args)
+		Vector.new(
+			self.x - vector.x,
+			self.y - vector.y,
+			self.z - vector.z
+		)
+	end
+	
+	# Multiply all components of a vector by a scalar amount.
+	#   v(1,2,3) * 3 #=> v(3,6,9)
+	def *(value)
+		result = []
+		each do |i|
+			result << i * value
+		end
+		result.to_v
+	end
+	
+	# Divide all components of a vector by a scalar amount
+	#   v(5,10,15) / 5 #=> v(1,2,3)
+	def /(value)
+		result = Array.new
+		self.each do |i|
+			result << i/value.to_f
+		end
+		result.to_v
+	end
+	
+	# Returns this Vector but normalized to a length of 1.
+	#   v(9, 0, 0).normalize #=> v(1,0,0)
+	def normalize
+		self * (1 / length)
+	end
+	alias_method :normalise, :normalize
+	
+	# Same as #normalize but modifies the receiver in place.
+	def normalize!
+		@x, @y, @z = normalize.to_a
+	end
+	alias_method :normalise!, :normalize!
+	
+	# 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'
+				@x = value.to_f
+			when index == 1 || index == :y || index == 'y'
+				@y = value.to_f
+			when index == 2 || index == :z || index == 'z'
+				@z = value.to_f
+		end
+	end
+	
+	# Set the value of the X component.
+	def x=(value)
+		@x = value.to_f
+	end
+	
+	# Set the value of the Y component.
+	def y=(value)
+		@y = value.to_f
+	end
+	
+	# Set the value of the Z component.
+	def z=(value)
+		@z = value.to_f
+	end
+	
+	
+	# Returns the length of this vector.
+	#   v(0,0,7).length #=> 7
+	def length
+		Math.sqrt(x**2 + y**2 + z**2)
+	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.kind_of?(Vector) && 
+		x == vector.x           && 
+		y == vector.y           &&
+		z == vector.z
+	end
+	
+private
+	
+	def convert_args_to_vector(*args)
+		args.flatten!
+		if args.first.is_a? Vector
+			args.first
+		else
+			args.to_v
+		end
+	end
+end