shattered 0.5.0.1 → 0.7.0

data/lib/shattered_support/required.rb

@@ -0,0 +1,9 @@
+#require File.dirname(__FILE__) + '/inflector'
+#require File.dirname(__FILE__) + '/inflections'
+#require File.dirname(__FILE__) + '/core_ext'
+require File.dirname(__FILE__) + '/pre_initialize'
+require File.dirname(__FILE__) + '/unload'
+#require 'rubygems'
+#require 'activesupport' #TODO: Use activesupport, fix shatteredsupport or get rid of shatteredsupport
+require File.dirname(__FILE__) + '/core_ext'
+require File.dirname(__FILE__) + '/error'

data/lib/shattered_support/unload.rb

@@ -0,0 +1,18 @@
+module Shattered
+  module Unload #:nodoc:
+    # Add a block to call on unload.
+    def on_unload(&block)
+      @on_unload ||= []
+      @on_unload << block
+    end
+
+    # Unload the object by calling all the unload blocks.
+    def unload
+      if(@on_unload)
+        @on_unload.reverse.each do |onload_method|
+          onload_method.call
+        end
+      end
+    end
+  end
+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/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_view/ogrerb/camera.rb

@@ -0,0 +1,14 @@
+module Ogre
+  class Camera    
+  
+  	alias_method :raw_look_at, :look_at
+  	
+  	# Look at an object
+  	# You can send it a node, mesh, or anything with a position vector
+  	# Or just a vector
+  	def look_at(v)
+  		v = v.position if v.class.respond_to? :position
+  		raw_look_at v.to_v
+  	end
+  end
+end

data/lib/shattered_view/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_view/ogrerb/light.rb

@@ -0,0 +1,25 @@
+module Ogre
+	class Light
+		attr_accessor :scene_manager
+		alias_method :diffuse=, :set_diffuse_colour
+		alias_method :diffuse,  :get_diffuse_colour
+		
+		alias_method :position=, :set_position
+		alias_method :position, :get_position
+		
+		alias_method :specular=, :set_specular_colour
+		alias_method :specular, :get_specular_colour
+		
+		alias_method :direction=, :set_direction
+		alias_method :direction, :get_direction
+    #Return the scene's total ambient color
+		def ambient
+		  scene_manager.get_ambient_light
+		end
+		
+		# Set the scene's total ambient color
+		def ambient=(*args)
+		  scene_manager.set_ambient_light *args
+		end
+	end
+end

data/lib/shattered_view/ogrerb/material.rb

@@ -0,0 +1,5 @@
+module Ogre
+  class MaterialPtr
+    attr_accessor :name
+  end
+end

data/lib/shattered_view/ogrerb/mesh_instance.rb

@@ -0,0 +1,85 @@
+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, options={})
+			@@entity_count ||= 0
+			@scene_manager = scene_manager
+			@parent = parent
+			@node = parent.create_child_scene_node("#{parent.to_s}.node(#{parent.num_children})")
+			# formats to '#<SceneManager:???>.entity(0)'
+			@entity = options[: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
+		
+		# Unload the mesh entity and node.
+		def unload
+		  @node.detach_object(@entity)
+		  @scene_manager.destroy_entity(@entity)
+      @parent.remove_and_destroy_child(@node.get_name)
+	  end
+		
+		[
+		  :position,
+			:position=,
+			:direction=,
+			:orientation=,
+			:orientation,
+			:translate!,
+		  :rotate,
+		  :scale=,
+		  :look_at
+		].each do |method|
+		  define_method(method) do |*args|
+				node.send(method, *args)
+			end
+	  end
+		
+		def scale(*args)
+			node.scale *args
+		end
+		
+		# Entity delegates that map differently
+		def visible=(v)
+			entity.set_visible v
+		end
+		
+		# Is the entity visible?
+		def visible?
+			entity.is_visible
+		end
+
+    # Hide the mesh and it's children
+    def hide
+      self.visible = false
+    end
+    
+    # Show the mesh and it's children
+    def show
+      self.visible = true
+    end
+		
+		# Set a material on a mesh.  You can set rmaterials or names of Ogre materials.
+		def material=(material)
+		  if(material.is_a? String)
+		    self.set_material_name(material)
+	    else
+	      self.set_material_name(material.get_name.to_s)
+      end
+	  end
+	  	
+	end	
+	
+end

data/lib/shattered_view/ogrerb/mouse_manager.rb

@@ -0,0 +1,109 @@
+module OIS
+	# One centralized place for responding to mouse input in shattered
+	# TODO: buffered?
+	# TODO: make this a singleton(the constructor takes arguments, which makes this difficult)
+	class MouseManager
+    attr_reader :x, :y, :scrolled, :abs_x, :abs_y
+
+    #Constructor requires an OIS::Mouse object    
+		def initialize(*args)
+			if(args.empty?)
+				puts "Warning:  Do not initialize MouseManager via the default constructor unless you are running tests."
+			else
+#				@mouse_events = OIS::MouseEvents.new(*args)
+#				@mouse_events.on_press lambda {|e, val| respond_to_press(e, val) }
+#				@mouse_events.on_release lambda {|e, val| respond_to_release(e, val) }
+#				@mouse_events.on_move lambda {|e| respond_to_move(e) }
+  		  @ois_mouse = args[0]
+  		end
+			@pressed=0
+			@held=0
+			@released=0
+			@scrolled=0
+			@x=0
+			@y=0
+			@abs_x=0
+			@abs_y=0
+			@buttons = 0
+		end
+		
+		# Clear out the newly pressed/released events and relative position
+		def flush
+		  @pressed=0
+		  @released=0
+			@scrolled=0
+			@x=0
+			@y=0
+		end
+		
+		#Unbuffered input processor
+    def process_events(state)
+      #TODO: What to do on buffered input
+      if @ois_mouse.nil? || !@ois_mouse.buffered
+        flush
+        respond_to_buttons(state)
+        respond_to_move(state)
+      end
+    end
+  
+    #Determine press, release, and held states  
+    def respond_to_buttons(state)
+      buttons = state.buttons
+      i = 0
+      # This code checks each bit, and does a press or release depending on the bit.
+      while i <= 7
+        bit = 1 << i
+        current = bit & buttons
+        prev = bit & @buttons
+        if current < prev
+          respond_to_release i
+        elsif prev < current
+          respond_to_press i
+        end
+        i+=1
+      end
+      @buttons = buttons
+    end
+    
+		#Called when the OIS mouse moved event is fired
+		def respond_to_move(state)
+		  @scrolled+=state.Z.rel
+		  @x+=state.X.rel
+		  @y+=state.Y.rel
+		  @abs_x=state.X.abs
+		  @abs_y=state.Y.abs
+		end
+		
+		#Called when the OIS mouse pressed event is fired
+		def respond_to_press(val)
+		  bit = (1 << val)
+		  @pressed |= bit
+		  @held |= bit
+		end
+	
+	  #Called when the OIS mouse released event is fired
+		def respond_to_release(val)
+		  bit = (1 << val)
+		  @released |= bit
+		  @held &= ~bit
+		  @pressed &= ~bit
+		end
+		
+		#Returns true if the button is pressed
+		def pressed?(button)
+		  return (@pressed & (1 << button) != 0)
+		end
+		
+		#Returns true if the button is held(between pressed and released states)
+		def held?(button)
+		  return (@held & (1 << button) != 0)
+		end
+		
+		#Returns true if the button is released
+		def released?(button)
+		  return (@released & (1 << button) != 0)
+		end
+		
+	end
+end
+		

data/lib/shattered_view/ogrerb/particle_system.rb

@@ -0,0 +1,24 @@
+module Ogre
+  class ParticleSystem
+    def node=(node)
+      puts node
+      @node = node
+      node.attach_object self
+    end
+    
+    def unload
+      unless @node.nil?
+  		  @node.detach_object self
+        @node.get_parent.remove_child @node
+      end
+    end
+    
+    def position=(v)
+      @node.position=v
+    end
+    
+    def position
+      @node.position
+    end
+  end
+end

data/lib/shattered_view/ogrerb/rgb.rb

@@ -0,0 +1,6 @@
+class Object
+  # rgb(0,0,0) is a shorthand for creating colours in Ogre.
+  def rgb(r,g,b)
+    Ogre::ColourValue.new(r,g,b)
+  end
+end

data/lib/shattered_view/ogrerb/rmaterial.rb

@@ -0,0 +1,87 @@
+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
+	#  result = rmaterial.load
+	# 
+	#Materials are parsed through erb as .rmaterials and parsed when a material is created using the create :material function of View    
+  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