shattered 0.5.0.1 → 0.7.0

data/app_generators/shattered/templates/configs/game.controls

@@ -0,0 +1,16 @@
+# Keymaps are in the form: #{action} => (press/release/hold) :#{button}
+quit     => press :escape
+
+move(-:z) => hold :w
+move(:z) => hold :s
+move(:left) => hold :a
+move(:right) => hold :d
+
+look => mouse.move
+
+#alternate controls for dvorak keyboards
+move(-:z) => hold ","
+move(:z) => hold :o
+move(:left) => hold :a
+move(:right) => hold :e
+

data/app_generators/shattered/templates/configs/ogre_plugins.linux.cfg

@@ -0,0 +1,12 @@
+# Defines plugins to load
+
+# Define plugin folder, not needed for mac
+PluginFolder=/usr/local/lib/OGRE
+
+# Define D3D rendering implementation plugin
+Plugin=RenderSystem_GL
+Plugin=Plugin_ParticleFX
+Plugin=Plugin_BSPSceneManager
+Plugin=Plugin_OctreeSceneManager
+Plugin=Plugin_CgProgramManager
+

data/app_generators/shattered/templates/configs/ogre_plugins.osx.cfg

@@ -0,0 +1,12 @@
+# Defines plugins to load
+
+# Define plugin folder, not needed for mac
+#PluginFolder=.
+
+# Define D3D rendering implementation plugin
+Plugin=RenderSystem_GL
+Plugin=Plugin_ParticleFX
+Plugin=Plugin_BSPSceneManager
+Plugin=Plugin_OctreeSceneManager
+#Plugin=Plugin_CgProgramManager
+

data/{lib → app_generators/shattered}/templates/configs/ogre_plugins.windows.cfg

@@ -4,11 +4,11 @@
 PluginFolder=.
 
 # Define D3D rendering implementation plugin
-#Plugin=RenderSystem_GL
+Plugin=RenderSystem_GL
 #Plugin=RenderSystem_Direct3D7
 Plugin=RenderSystem_Direct3D9
 Plugin=Plugin_ParticleFX
 Plugin=Plugin_BSPSceneManager
 Plugin=Plugin_OctreeSceneManager
-#Plugin=Plugin_CgProgramManager
+Plugin=Plugin_CgProgramManager
 

data/app_generators/shattered/templates/game.rb

@@ -0,0 +1,50 @@
+$:.unshift File.dirname(__FILE__)
+
+# Set the SHATTERED_ROOT to the project directory
+SHATTERED_ROOT = File.expand_path(File.dirname(__FILE__))
+  
+# Require shattered if it is in the vendor directory, otherwise use a gem
+begin
+  require 'vendor/shattered/lib/shattered'
+rescue LoadError
+  require 'rubygems'
+  require 'shattered'
+end
+
+# Game is the class that takes care of loading Actors, resources, and handles control flow.
+class Game < Shattered::Game
+  title "Insert your game name here"
+  # Initialize is called to startup ogrerb and shattered
+  def initialize
+    super
+    
+    # initialize the controls in config/game.controls.  This can also be done by specifying the filename, i.e. controls("game").on
+    controls.on 
+    
+    # create the initial scene manager, we can choose from: general, terrain, nature, indoor, or nature_paging
+    create :scene_manager, :general
+    # The camera is accessible through @camera or camera.  Must be called after create :scene_manager
+    create :camera, :position => v(0,0,0)
+    # This has to be called after create_camera
+    create :viewport, :color => rgb(0.2,0,0)
+    
+    # The default resource directory.  This will recursively load any directories under it as well
+    load_resources("media")
+    
+   	# Create scene and actors
+  end
+  
+  # Basic wasd controls
+  def move(direction)
+    @speed ||= 30
+    @camera.move_relative(time_elapsed * @speed * direction)
+  end
+  
+  # Allows the mouse to look around the scene
+  def look
+    @camera.yaw(Ogre::Radian.new(-@mouse.x*0.01))
+    @camera.pitch(Ogre::Radian.new(-@mouse.y*0.01))
+  end
+end
+
+Game.instance.play if __FILE__ == $0

data/app_generators/shattered/templates/spec/game_spec.rb

@@ -0,0 +1,5 @@
+require File.dirname(__FILE__)+"/spec_helper.rb"
+
+describe "Game" do
+  #Add your specs here
+end

data/app_generators/shattered/templates/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+begin
+  require 'spec'
+rescue LoadError
+  require 'rubygems'
+  gem 'rspec'
+  require 'spec'
+end
+
+# Lets Game know we're running specs so that it doesn't require user input
+SHATTERED_SPEC = true
+
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "game"))

data/bin/shattered

@@ -0,0 +1,39 @@
+require 'rubygems'
+require 'rubigen'
+
+if(%w(-v --version).include?(ARGV.first))
+  require File.join(File.dirname(__FILE__),'..','lib','shattered_game','version')
+  puts "#{File.basename($0)} #{ShatteredRuby::VERSION::STRING}"
+  exit(0)
+end
+
+require 'rubigen/scripts/generate'
+errored=false
+
+RubiGen::Base.use_application_sources!(:shattered, :actor)
+if(ARGV.length > 0)
+  case(ARGV.shift.downcase)
+    when "actor"
+      RubiGen::Scripts::Generate.new.run(ARGV, :generator => 'actor')
+    when "setup"
+      RubiGen::Scripts::Generate.new.run(ARGV, :generator => 'shattered')
+    when "test"
+      load "test/acceptance/game.rb"
+      Game.instance.play
+    when "console"
+      require File.dirname(__FILE__)+"/../app_generators/commands/console.rb"
+    else
+      errored=true
+  end
+else
+  errored=true
+end
+
+if(errored)
+  puts "Usage: shattered <setup/actor/console> <arguments>"
+  puts
+  puts "setup <name>: Create a basic application structure in the directory <name>"
+  puts "actor <name>: Create a templated actor and spec"
+  puts "console     : Run the irb console in the current directory."
+  puts "test        : Runs the acceptance tests."
+end

data/config/hoe.rb

@@ -0,0 +1,77 @@
+require 'shattered_game/version'
+
+AUTHOR = ['Martyn Garcia', 'Mikkel Garcia']  # can also be an array of Authors
+EMAIL = "shatteredruby@groups.google.com"
+DESCRIPTION = "Light Weight 3D Game Framework"
+GEM_NAME = 'shattered' # what ppl will type to install your gem
+RUBYFORGE_PROJECT = 'shattered' # The unix name for your project
+HOMEPATH = "http://www.shatteredruby.com"
+DOWNLOAD_PATH = "http://rubyforge.org/projects/#{RUBYFORGE_PROJECT}"
+
+if /win32/ === PLATFORM
+	@config_file = "./user-config.yml"
+	ENV["HOME"] = "/"
+else
+	@config_file = "~/.rubyforge/user-config.yml"
+end
+
+@config = nil
+RUBYFORGE_USERNAME = "unknown"
+def rubyforge_username
+  unless @config
+    begin
+      @config = YAML.load(File.read(File.expand_path(@config_file)))
+    rescue
+      puts <<-EOS
+ERROR: No rubyforge config file found: #{@config_file}
+Run 'rubyforge setup' to prepare your env for access to Rubyforge
+ - See http://newgem.rubyforge.org/rubyforge.html for more details
+      EOS
+      exit
+    end
+  end
+  RUBYFORGE_USERNAME.replace @config["username"]
+end
+
+
+REV = nil 
+# UNCOMMENT IF REQUIRED: 
+# REV = `svn info`.each {|line| if line =~ /^Revision:/ then k,v = line.split(': '); break v.chomp; else next; end} rescue nil
+VERS = ShatteredRuby::VERSION::STRING + (REV ? ".#{REV}" : "")
+RDOC_OPTS = ['--quiet', '--title', 'shattered_ruby documentation',
+    "--opname", "index.html",
+    "--line-numbers", 
+    "--main", "README",
+    "--inline-source"]
+
+class Hoe
+  def extra_deps 
+    @extra_deps.reject! { |x| Array(x).first == 'hoe' } 
+    @extra_deps
+  end 
+end
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+hoe = Hoe.new(GEM_NAME, VERS) do |p|
+  p.author = AUTHOR 
+  p.description = DESCRIPTION
+  p.email = EMAIL
+  p.summary = DESCRIPTION
+  p.url = HOMEPATH
+  p.rubyforge_name = RUBYFORGE_PROJECT if RUBYFORGE_PROJECT
+  p.test_globs = ["test/**/test_*.rb"]
+  p.clean_globs |= ['**/.*.sw?', '*.gem', '.config', '**/.DS_Store']  #An array of file patterns to delete on clean.
+  
+  # == Optional
+  p.changes = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+  p.extra_deps = [["ogre.rb", ">= 0.3.0"]]     # An array of rubygem dependencies [name, version], e.g. [ ['active_support', '>= 1.3.1'] ]
+  
+  #p.spec_extras = {}    # A hash of extra values to set in the gemspec.
+  
+end
+
+CHANGES = hoe.paragraphs_of('History.txt', 0..1).join("\\n\\n")
+PATH    = (RUBYFORGE_PROJECT == GEM_NAME) ? RUBYFORGE_PROJECT : "#{RUBYFORGE_PROJECT}/#{GEM_NAME}"
+hoe.remote_rdoc_dir = File.join(PATH.gsub(/^#{RUBYFORGE_PROJECT}\/?/,''), 'rdoc')
+hoe.rsync_args = '-av --delete --ignore-errors'

data/config/requirements.rb

@@ -0,0 +1,15 @@
+require 'fileutils'
+include FileUtils
+
+require 'rubygems'
+%w[rake hoe newgem rubigen rcov].each do |req_gem|
+  begin
+    require req_gem
+  rescue LoadError
+    puts "This Rakefile requires the '#{req_gem}' RubyGem."
+    puts "Installation: gem install #{req_gem} -y"
+    exit
+  end
+end
+
+$:.unshift(File.join(File.dirname(__FILE__), %w[.. lib]))

data/lib/shattered.rb

@@ -0,0 +1,40 @@
+$:.unshift File.dirname(__FILE__)
+
+#Use ruby's standard Logger package
+require 'logger'
+
+#Load OgreRB
+begin
+  require File.expand_path(File.join(File.dirname(__FILE__),"..", "vendor", "ogrerb", "ogre"))
+rescue LoadError
+  require 'rubygems'
+  require 'ogre'
+end
+
+# Load Shattered.
+%w(support view model game).each do |package|
+  path = File.expand_path("#{File.dirname(__FILE__)}/shattered_#{package}")
+  #If there is a required.rb, a specific load script is invoked
+  if File.exists?(path + "/required.rb")
+    require path + "/required.rb"
+  else
+    # Load all the ruby files.
+    Dir[path+"/**/*.rb"].each do |file|
+      require file
+    end
+  end
+end
+
+# Load the plugins
+Dir["#{SHATTERED_ROOT}/vendor/plugins/*/init.rb"].each do |plugin|
+  require plugin
+end
+
+# Note that the lib directory structure is formatted based on responsibilities:
+# shattered_support - helpers from active_support used everywhere
+# shattered_ogrerb - provides shortcuts and helpers for dealing with Ogre.rb
+# shattered_ruby - provides application startup
+# shattered_[model/view/state] - provides code for dealing with models, views, and states.
+module ShatteredRuby
+  
+end

data/lib/shattered_game/actor.rb

@@ -0,0 +1,6 @@
+module Shattered
+  class Actor #:nodoc:
+	  include Model
+	  include View
+  end
+end

data/lib/shattered_game/game.rb

@@ -0,0 +1,285 @@
+module Shattered
+  class Game #:nodoc:
+    include Model
+    include View
+    
+    attr_reader :viewport, :camera, :render_window, :root, :log
+    attr_accessor :mouse, :keyboard, :keyboard_listener
+    attr_accessor :title
+    
+    # Sets up the game's title.
+    def self.title(title)
+      before_init_call("title=", title)
+    end
+    
+    # Sets up the initial render window and initializes Ogre
+    def initialize
+      @@game_instance = self
+      setup_logger(Logger::DEBUG, STDOUT)
+      throw Shattered::Error.new("User cancelled") unless setup_ogre
+      setup_input unless running_specs?
+      #Do this once on startup, since OSX wasn't getting the event.
+      update_window_size
+	  end
+    
+    # Sets all the resources in paths to be loaded as FileSystem General resources
+    def load_resources(*paths)
+    	@media_paths = paths
+    	# setup our resource paths specified in environment.rb
+      Resources.instance.add_resource_paths(*paths)
+      Resources.instance.setup
+  	end
+    
+    #Every time this exits, a game dies.
+    def play
+      begin
+        each_frame do |time_elapsed|
+          Ogre::WindowEventUtilities::message_pump
+          unless running_specs?
+      		  @keyboard.flush
+      		  @ois_keyboard.capture
+      		  @mouse.process_events @ois_mouse.mouse_state
+      		  @ois_mouse.capture
+          end
+          Timer::Timer.update(time_elapsed)
+        end
+      rescue
+        error = "Exception:\n\n#{$!}\n"
+        
+        # Let's hide the shit that's related to shattered unless SHATTERED_STACK_TRACE is true
+        backtrace = $!.backtrace
+        unless(ENV["SHATTERED_STACK_TRACE"])
+          backtrace = backtrace.select { |bt| (bt =~ /shattered/).nil? }
+        end
+        backtrace.each do |details|
+          error += "        from #{details}\n"
+        end
+        log.error(error)
+      end
+      shutdown
+    end
+  
+  	# Main game loop
+    def each_frame
+    	timer = Ogre::Timer.new
+      while !quit? && Ogre::Root::instance.render_one_frame
+			  return false if @render_window.closed?
+      	seconds = timer.get_microseconds / 1000000.0
+  	    timer.reset
+  		  yield seconds
+      end
+  	end
+  	
+  	# Has the user quit?  Call Game.quit! to exit the game
+  	def quit?
+  	  @quit ||= false
+  	end
+
+  	# Quit the game from the game
+  	def quit
+  	  @quit = true
+  	end  
+  	
+    # Game.scene_manager returns the same scene_manager as Game.instance.scene_manager
+    def self.scene_manager
+      @@scene_manager
+    end
+    
+    # Set the scene_manager...
+    def self.scene_manager=(val)
+      @@scene_manager = val
+    end
+    
+    # Return the current scene_manager
+    def scene_manager
+      @@scene_manager
+    end
+    
+    # Load a logger with a given level and log to a specific file.
+    def setup_logger(level, where="#{SHATTERED_ROOT}/log/game.log")
+      if(where.is_a?(String))
+        @log = Logger.new(open(where, File::WRONLY | File::CREAT))
+      else
+        @log = Logger.new(where)
+      end
+      @log.level = level
+
+      @log.info("Game starting")
+    end
+    
+    # Load the root, setup the render window
+    def setup_ogre
+    	plugins = SHATTERED_ROOT + "/config/ogre_plugins.#{Platform.short_name}.cfg"
+    	log.info("Ogre plugins: '#{plugins}'")
+    	config_save = SHATTERED_ROOT + "/config/ogrerb_defaults.save"
+    	log.info("Config saved: '#{config_save}'")
+    	ogre_log = SHATTERED_ROOT + "/log/ogrerb.log"
+    	log.info("Ogre's log  : '#{ogre_log}")
+     
+    	log.debug("Creating Root")
+    	@root = ShatteredOgre.create_root(plugins, config_save, ogre_log)
+    	log.debug("Showing config dialog")
+
+      # Allows us to avoid user input for the spec suite
+      if running_specs?
+        show_spec_window
+      else
+    	  return false if !show_config_dialog
+    	end
+    	
+    	log.debug("Creating Render Window")
+    	@render_window = @root.initialise(true, @title || "No Title")
+
+    	log.debug("Adding WindowEvent Listener")
+    	@window_event = setup_window_events
+
+    	log.info("Ogre setup successfully.")
+    	return true
+    end
+    
+    # Create a blank window without user input
+    def show_spec_window
+      unless Platform.mac?
+        renderers = @root.get_available_renderers
+    	  @root.set_render_system(renderers[0])
+  	  else
+  	    show_config_dialog
+	    end
+    end
+    
+    # Returns false if we are running the spec suite, true otherwise
+    def running_specs?
+      begin
+        # The specs shouldn't require user input but should still initialize the window
+        return true if SHATTERED_SPEC == true
+      rescue NameError
+        # Specs are not running
+        return false
+      end
+
+    end
+    
+    # Sets up the window events resize and close
+    def setup_window_events
+      log.info "Registering window.resize and window.close listeners"
+      event = Ogre::WindowEvents.new @render_window
+      
+    	#Resize the window and let OIS know
+      event.on_resize do
+        update_window_size
+      end
+      
+      #This is cleanup once the window is closed
+      event.on_close do
+        quit
+      end
+      
+      return event
+    end
+    
+    # Set up the mouse and keyboard
+    def setup_input
+      log.info "Initializing mouse and keyboard"
+      window_handle = render_window.get_custom_attribute_unsigned_long("WINDOW")
+      window_options = {"WINDOW" => window_handle.to_s}
+      
+      @input_manager = OIS::InputManager.create_input_system(window_options.merge(input_options))
+      @ois_mouse = @input_manager.create_input_object( OIS::OISMouse, buffered_mouse=false)
+      @mouse = OIS::MouseManager.new(@ois_mouse)
+      
+      @ois_keyboard = @input_manager.create_input_object(OIS::OISKeyboard, true)
+  		@keyboard = OIS::KeyManager.new(@ois_keyboard)
+  		@keyboard_listener = Shattered::Input::Keyboard.new(@keyboard, @mouse) 
+    end
+    
+    # Overwrite this method to setup how you would like the window to act.
+    # DISCL_NONEXCLUSIVE means the mouse and keyboard are not bound to your program.
+    def input_options
+      { "w32_mouse" => ["DISCL_FOREGROUND", "DISCL_NONEXCLUSIVE"],
+        "w32_keyboard" => ["DISCL_FOREGROUND", "DISCL_NONEXCLUSIVE"] }
+    end
+    
+    # Overwrite this to create your own config dialog.
+    # Return true to keep going, or false to cancel the startup.
+    def show_config_dialog
+      return @root.show_config_dialog
+    end
+    
+    # Creates a viewport based off of the Camera.
+		def create_viewport(options)
+		  log.info "Creating viewport"
+			@viewport = render_window.add_viewport(camera)
+			@viewport.set_background_colour(options[:color] || rgb(0,0,0))
+		end
+		
+		# Creates a scene manager for Ogre to use.
+    def create_scene_manager(type)
+      log.info "Creating scene manager #{type}"
+    	root = Ogre::Root.instance
+  	  @@scene_manager = root.create_scene_manager(ShatteredOgre.translate_to_scene_type(type), "#{root.to_s}.scene_manager(#{type})")
+  	end
+  	
+  	 # Returns the camera used in the state. See ShatteredState::ClassMethods#camera
+    def create_camera(options)
+      log.info "Creating camera"
+      @camera = scene_manager.create_camera(options[:name] || "main")
+	 	  @camera.set_near_clip_distance(options[:near_clip] || 1)
+	 	  @camera.set_far_clip_distance(options[:far_clip] || 10000)
+   	  @camera.position = options[:position] if options[:position]
+   	  @camera.look_at(options[:look_at]) if options[:look_at]
+    end
+    
+    def self.instance
+      @@game_instance ||= self.new
+    end
+		
+		private
+		def shutdown
+		  log.info "Shutting down"
+  	  # We need to collect all references to Materials, Meshes,
+  	  # Lights, actors, and any other sort of things before we unload Ogre
+		  unload
+		  GC.start
+		  
+		  # Remove Ogre then OIS.
+		  destroy_ogre
+		  destroy_ois unless running_specs?
+		  @@game_instance = nil
+		end
+		
+		# Destroy OGRE, ogrerb style.
+		def destroy_ogre
+		  log.info "Destroying ogre"
+		  scene_manager.clear_scene
+		  @@scene_manager = nil
+		  @camera = nil
+		  @viewport = nil
+		end
+		
+		def destroy_ois
+		  log.info "Destroying input system"
+		  @input_manager.destroy_input_object(@ois_mouse)
+			@input_manager.destroy_input_object(@ois_keyboard)
+			#@input_manager.destroy_input_object(@joy_stick) unless @joy_stick.nil?
+			OIS::InputManager.destroy_input_system(@input_manager)
+      @input_manager = nil
+		  @ois_keyboard = nil
+		  @keyboard_listener = nil
+		  @keyboard = nil
+		  @mouse = nil
+		  @ois_mouse = nil
+		end
+    
+    # Called by OIS whenever the window is resized.
+    def update_window_size
+      width, height, depth, left, top = @render_window.get_metrics
+
+      if(@ois_mouse)
+		    mouse_state = @ois_mouse.mouse_state
+		    mouse_state.width = width
+		    mouse_state.height = height
+	    end
+    end
+  end
+ 
+end