shattered_ogrerb 0.5.0.1

data/lib/shattered_ogrerb.rb

@@ -0,0 +1,17 @@
+
+# adds dll search paths
+def add_dll_paths(*directories)
+	directories.each do |dir|
+		absolute_path = File.expand_path(File.dirname(__FILE__)+"/../vendor/#{dir}/")
+		ENV["path"] += ";#{absolute_path};"
+		$:.unshift(absolute_path)
+	end
+end
+
+add_dll_paths("Ogre", "Navi")
+
+require File.dirname(__FILE__)+'/../vendor/ogrerb/ogre'
+
+Dir[File.dirname(__FILE__)+"/shattered_ogrerb/**/*.rb"].each do |dependency|
+	require dependency
+end

data/lib/shattered_ogrerb/base.rb

@@ -0,0 +1,28 @@
+
+class ShatteredOgre
+	def self.create_root(plugins="ogrerb_plugins.cfg", configs="ogrerb_defaults.save", log="ogrerb.log")			
+		# Disable the default stdout.  All ogre errors redirect to the ogre log.
+		@@log_manager = Ogre::LogManager.new
+		@@log_manager.create_log(log,true,false,false)
+		
+		# Create our core and load platform managers
+		@@root = Ogre::Root.new(plugins, configs, log)
+		return @@root
+	end
+
+	# Translates from symbols to scene manager types.  Valid options are:
+	# 	:general => ST_GENERIC
+	#		:terrain => ST_EXTERIOR_CLOSE
+	#   :nature => ST_EXTERIOR_FAR
+	#   :indoor => ST_INTERIOR
+	#   :nature_paging => ST_EXTERIOR_REAL_FAR
+	def self.translate_to_scene_type( symbol )
+    return Ogre::ST_GENERIC if(symbol == :general)
+    return Ogre::ST_EXTERIOR_CLOSE if(symbol == :terrain)
+    return Ogre::ST_EXTERIOR_FAR if(symbol == :nature)
+    return Ogre::ST_EXTERIOR_REAL_FAR if(symbol == :paging)
+    return Ogre::ST_INTERIOR if(symbol == :indoor)
+    raise StandardError, "#{symbol} is not a valid scene manager type"
+  end
+
+end

data/lib/shattered_ogrerb/camera.rb

@@ -0,0 +1,6 @@
+module Ogre
+	class Camera
+		alias_method :position, :get_position
+		alias_method :position=, :set_position
+	end
+end

data/lib/shattered_ogrerb/key_manager.rb

@@ -0,0 +1,54 @@
+module OIS
+	# One centralized place for responding to keyboard input in shattered
+	# TODO: buffered input
+	# TODO: make this a singleton(the constructor takes arguments, which makes this difficult)
+	class KeyManager < KeyListenerProxy
+		def initialize(*args)
+			if(args.empty?)
+				puts "Warning:  Do not initialize KeyManager via the default constructor unless you are running tests."
+			else
+				super(*args)
+			end
+			@pressed={}
+			@held={}
+			@released={}
+		end
+		
+		# Is key new from the last flush event?
+		def key_pressed?(key)
+			return @pressed[key] || false
+		end
+		
+		# Is key not pressed new from the last flush event?
+		def key_released?(key)
+			return @released[key] || false
+		end
+		
+		# Is the key pressed or pressed from a previous frame
+		def key_held?(key)
+			return @held[key] || false
+		end
+		
+		# Clear out the newly pressed/released events
+		def flush
+			@released={}
+			@pressed={}
+		end
+		
+		# Called from the key listener
+		def key_pressed(e)
+			@pressed[e.key]=true
+			@held[e.key]=true
+			@released[e.key]=false
+		end
+		
+		# Called from the key listener
+		def key_released(e)
+			@released[e.key]=true
+			@held[e.key]=false
+			@pressed[e.key]=false
+		end
+
+	end
+end
+		

data/lib/shattered_ogrerb/light.rb

@@ -0,0 +1,5 @@
+module Ogre
+	class Light
+		alias_method :diffuse=, :set_diffuse_colour
+	end
+end

data/lib/shattered_ogrerb/mesh_instance.rb

@@ -0,0 +1,92 @@
+require 'delegate'
+
+module Ogre
+	# A MeshInstance is a class representing an Ogre::Entity attached to an
+	# Ogre::Node.  This allows for moving / rotation of a Mesh without having
+	# to worry about about this dichotomy.
+	#
+	# Delegation occurs in the node for rotation and translation.
+	# Delegation occurs to the entity for all other cases.
+	# The node and entity are accessible, for the fringe cases where specific methods
+	# are not delegated respectfully.
+	class MeshInstance < SimpleDelegator
+		attr_reader :node, :entity
+		def initialize(parent, scene_manager, mesh_name)
+			@@entity_count ||= 0
+			@node = parent.create_child_scene_node
+			# formats to '#<SceneManager:???>.entity(0)'
+			@entity = scene_manager.create_entity("#{scene_manager.to_s}.entity(#{@@entity_count})", mesh_name)
+			@node.attach_object(@entity)
+			@@entity_count += 1
+			# delegate all unknown methods to the entity object
+			__setobj__(@entity)
+		end
+		
+		# Node delegates
+		{
+			:position => :get_position,
+			:position= => :set_position,
+			:direction= => :set_direction,
+			:orientation= => :set_orientation,
+			:orientation => :get_orientation,
+			:scale => :get_scale,
+			:translate! => :translate
+		}.each do |method, delegate|
+			define_method(method) do |*args|
+				node.send(delegate, *args)
+			end
+		end
+		
+		# rotate works in degrees by default, and in the TS_lOCAL space
+		def rotate(axis, amount, *args)
+			if(args.empty?)
+				node.rotate(axis, Radian.new(Degree.new(amount)))
+			else
+				node.rotate(axis,Radian.new(Degree.new(amount)), args[0])
+			end
+		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
+			
+			node.set_scale(*v)
+		end
+		
+		#scale! works with numbers, vectors, or 3 numbers and is relative
+		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
+			
+			node.scale(*v)
+		end
+		
+		# 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
+			node.look_at v, transform
+		end
+		
+		#Entity delegates that map differently
+		def visible=(v)
+			entity.set_visible v
+		end
+		
+		def visible?
+			entity.is_visible
+		end
+		
+	end	
+end

data/lib/shattered_ogrerb/rmaterial.rb

@@ -0,0 +1,86 @@
+require 'erb'
+
+module Ogre
+	# An rmaterial is a material template, sample rmaterials
+	# A basic RMaterial looks as follows:
+	#
+	#  // This is an example rmaterial, a basic single textured, uniformly lit mesh.
+	#  // The only argument is texture, which defaults to <material_name>.png
+  #  <% @texture ||= "#{name}.png" %>
+	#  material <%= name %>
+	#  {
+	#   technique 
+	#   { 
+	#      pass 
+	#      { 
+	#        lighting off
+	#		texture_unit 
+	#        { 
+	#			texture <%= texture %>
+	#        } 
+	#	   }
+	#  }
+	# 
+	# Example:
+	#  rmaterial = RMaterial.load("my.material") do |rm|
+	#  	rm.name = "Ogre"
+	#  end
+	#  rmaterial.parse!
+	#  result = rmaterial.load!
+  class RMaterial
+    attr_reader :result, :name
+    
+    # Used to create an rmaterial with a block.
+    # Returns an Ogre material
+    def self.load(file)
+    	rmaterial = self.new(file)
+    	yield rmaterial
+    	rmaterial.parse!
+    	return rmaterial.create_ogre_material!
+  	end
+    
+    def initialize(rmaterial)
+    	@rmaterial = rmaterial
+  	end
+    
+    # Parses through ERB to create a ogre-compatible material
+    def parse!
+      begin
+        evaluate!(File.open(@rmaterial).readlines.join(''))
+      rescue Errno::ENOENT => bang
+        raise Errno::ENOENT, "RMaterial for '#{name}' not found: #{bang.message}"
+      end
+    end
+    
+    # Loads the rmaterial from Ogre.  Must call parse! first.
+    def create_ogre_material!
+    	unless(MaterialManager.instance.resource_exists(name.to_s))
+      	MaterialManager.instance.parse_script(result, "General")
+    	end
+    	return MaterialManager.instance.get_by_name(name.to_s)
+    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 }".to_sym
+        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_ogrerb/vector.rb

@@ -0,0 +1,211 @@
+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
+
+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
+  
+  # Addition for vectors
+  def +(number)
+    return to_v + number
+  end
+  
+  # Subtraction for numbers
+  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
+    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)
+		self.to_a.each do |component|
+			yield component
+		end
+	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)
+	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
+	  return self.to_a.hash
+  end
+  
+  # Equality test for hash indexes.
+  def eql?(other)
+    return self.to_a.eql?(other.to_a)
+  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