shattered_view 0.3

data/lib/animation.rb

@@ -0,0 +1,17 @@
+module ShatteredView
+class Animation
+  def initialize(mesh, name)
+    @animation = mesh.getAnimation name
+    @animation.addAsFrameListener
+  end
+  def play
+    @animation.play
+  end
+  def loop=(looping)
+    @animation.setLoop(looping);
+  end
+  def time_scale=(scale)
+    @animation.setTimeScale(scale);
+  end
+end
+end

data/lib/base.rb

@@ -0,0 +1,199 @@
+
+include ShatteredOgre
+include ShatteredSupport
+
+module ShatteredView
+
+  class Error < StandardError; end
+  
+  def self.append_features(base)
+    super
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    # Materials are parsed through erb as .rmaterials and parsed when a material
+    # metafunction is called.
+    #  
+    # Example:
+    #   material :wall_material, :template => 'normal_map', :texture => 'wall.png', :normal => 'brick_normals.png', :tangent_space => true
+    #   mesh :wall, :material => :wall_material
+    #
+    #  You must make sure that your material name is unique, or Ogre will fail.
+    #
+    #  All rmaterial files are included within media/templates, you can add your own there.
+    #  TODO:  ruby script/generate material (?)
+    def material(name, options = {})
+      before_init_set "self", {:new_material => [name]}
+      before_init_set name, options
+      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.
+    #  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.
+    #
+    #   Spotlight - this light has both a direction and a position, as well as other factors.
+    #   Example:  light :flashlight...
+    #   TODO: This type of light is not currently implemented in shattered.
+
+    def light(name, options = {})
+      before_init_set "self", {:new_light => [name]}
+      before_init_set name, options
+    end
+
+  end
+
+  class Base < ShatteredSupport::Base
+    attr_reader :meshes
+
+    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
+      @materials[name] = RMaterial.new
+      @materials[name].name=name
+      self.class.send(:define_method, name) do
+        @materials[name]
+      end
+    end
+
+    def new_light=(name)
+      @lights ||= {}
+      @lights[name] = ShatteredView::Light.new 
+      self.class.class_eval <<-EOF
+      define_method(:#{name}) do
+        @lights[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
+    end
+
+    protected
+    def mesh_public_methods
+      methods=[]
+      meshes.each do |mesh|
+        methods |= mesh.public_methods
+      end
+      return methods
+    end
+  end
+end

data/lib/camera.rb

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

data/lib/extensions.rb

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

data/lib/game.rb

@@ -0,0 +1,42 @@
+require 'ruby/utilities'
+require 'view/View'
+include View
+
+class Game
+  @@instance = MockObject.new
+  def initialize( sceneType)
+    @renderer = Renderer.new
+    @scene = Scene.new sceneType
+    @camera = @scene.getCamera()
+    @camera.setDirection(Vector3.UNIT_Z)
+    @listeners = []
+    @timeScale = 1.0
+    
+    @@instance = self
+    @@gameOver=false
+  end
+  def Game.end
+    @@gameOver = true
+  end
+  def Game.instance
+    return @@instance
+  end
+  def each_frame
+  	while( !@@gameOver && @renderer.nextFrame ) do
+      @listeners.each do |listener| 
+        listener.frameStarted @renderer.timeSinceLastFrame * timeScale
+      end
+  		yield @renderer.timeSinceLastFrame * timeScale
+		end
+	end
+  def addFrameListener( instance )
+    @listeners << instance
+  end
+  def removeFrameListener( instance )
+		@listeners.delete instance
+ 	end
+
+  attr_reader :scene, :camera
+  attr_accessor :timeScale
+end
+

data/lib/light.rb

@@ -0,0 +1,29 @@
+module ShatteredView
+  class Light
+    def light
+      @light ||= Scene.getSingleton().createLight
+    end
+    def direction=(*direction)
+      light.setType(ShatteredOgre::Light::LT_DIRECTIONAL) 
+      light.setDirection(direction.to_v)
+    end
+    def diffuse=(r,g,b)
+      light.setDiffuseColour(r,g,b)
+    end
+    def specular=(r,g,b)
+      light.setSpecularColour(r,g,b)
+    end
+    def position=(*pos)
+      light.setType(ShatteredOgre::Light::LT_POINT) 
+      pos = pos[0] if pos.length < 3
+      light.setPosition(pos.to_v)
+    end
+    def ambient=(r,g,b)
+      Scene.getSingleton().setAmbientLight(r,g,b);
+    end
+    def attenuation=(range, const, linear, quad)
+      light.setType(ShatteredOgre::Light::LT_POINT)
+      light.setAttenuation(range, const, linear, quad)
+    end
+  end
+end

data/lib/mesh.rb

@@ -0,0 +1,79 @@
+
+   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

data/lib/resources.rb

@@ -0,0 +1,63 @@
+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)
+        end
+      end
+    end
+    
+    def destroy_paths
+      @resource_paths = []
+    end
+
+    # This is useful for any extension wanting to load resource files:
+    #
+    # Usage:
+    #   ResourceHandler.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
+    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
+    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
+    end
+  end
+end

data/lib/rmaterial.rb

@@ -0,0 +1,41 @@
+require 'erb'
+
+module ShatteredView
+  class RMaterial
+    attr_reader :result
+    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(result)
+    end
+    def create_ogre_material=(*args)
+      load!("#{SHATTERED_ROOT}/media/templates/#{template}.rmaterial")
+      create_ogre_material!
+    end
+    def method_missing(name, *args)
+      if name.to_s[-1].chr == "="
+        name = name.to_s[0...-1].to_sym
+        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/runner.rb

@@ -0,0 +1,24 @@
+
+module ShatteredView
+  class Runner
+    def initialize(options = {})
+      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 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.rb

@@ -0,0 +1,22 @@
+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
+    require 'rubygems'
+    require dependency
+  end
+end
+
+
+require File.dirname(__FILE__) + '/animation'
+require File.dirname(__FILE__) + '/utilities'
+require File.dirname(__FILE__) + '/mesh'
+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'

data/lib/utilities.rb

@@ -0,0 +1,58 @@
+
+  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

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: shattered_view
+version: !ruby/object:Gem::Version 
+  version: "0.3"
+date: 2006-04-28 00:00:00 -05:00
+summary: "Shattered View: Manipulates OGRE in a ruby-esque fashion."
+require_paths: 
+- lib
+email: 
+homepage: http://www.hastilymade.com
+rubyforge_project: 
+description: Shattered View uses Ogre and Ruby to create an accessible interface to normally convoluted common game tasks.
+autorequire: shattered_view
+default_executable: 
+bindir: bin
+has_rdoc: "true"
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !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
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: 
+- Shattered View is reliant on OGRE.
+dependencies: []
+