rage 0.1

data/README.rdoc

@@ -0,0 +1,48 @@
+== RAGE - The Ruby Advanced Gaming Engine
+
+Copyright (C) 2010 Mohammed Morsi <movitto@yahoo.com>
+
+RAGE is made available under the GNU GENERAL PUBLIC LICENSE
+as published by the Free Software Foundation, either version 3
+of the License, or (at your option) any later version.
+
+== Info
+RAGE is a Ruby dsl geared towards providing a simple / intuitive 
+interface to perform 3D graphics and many other types of operations
+in the context of a simulation/gaming environment.
+
+The goal is to provide the developer w/ simple syntax that they can use to easily
+display a window w/ viewports, render 3D geometries and textures/materials,
+handle user input, play audio files, and execute a slew of other actions.
+
+== Installation
+
+To install rage simply run:
+   gem install rage
+
+Source code is available via:
+   git clone http://github.com/movitto/rage
+
+== Usage
+
+  # create a mesh w/ blender and export it to /home/user/mesh.x3d using File > Export > X3D
+
+  require 'rage'
+  
+  resource :type => :mesh, :uri => "file:///home/user/mesh.x3d" do |mesh|
+    mesh.show_at 0, 0, 0
+  end
+
+  window(:width => 512, :height => 512) { |win|
+     win.create_viewport
+  }.show
+
+  game.run
+
+== Mesh Viewer
+
+Also see bin/mesh-viewer.rb in the project which can be run like so:
+
+  ruby bin/mesh-viewer.rb -m file:///path/to/rage/spec/content/cube.x3d
+
+The -m may be specified any number of times to view multiple meshes simultaneously.

data/Rakefile

@@ -0,0 +1,46 @@
+# rage project Rakefile
+#
+# Copyright (C) 2010 Mohammed Morsi <movitto@yahoo.com>
+# Licensed under the GPLv3+ http://www.gnu.org/licenses/gpl.txt
+
+require 'rake/rdoctask'
+require 'spec/rake/spectask'
+require 'rake/gempackagetask'
+
+
+GEM_NAME="rage"
+PKG_VERSION='0.1'
+
+desc "Run all specs"
+Spec::Rake::SpecTask.new('spec') do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Rake::RDocTask.new do |rd|
+    rd.main = "README.rdoc"
+    rd.rdoc_dir = "doc/site/api"
+    rd.rdoc_files.include("README.rdoc", "lib/**/*.rb")
+end
+
+PKG_FILES = FileList['bin/**/*', 'lib/**/*.rb', 'COPYING', 'LICENSE', 'Rakefile', 'README.rdoc', 'spec/**/*.rb' ]
+
+SPEC = Gem::Specification.new do |s|
+    s.name = GEM_NAME
+    s.version = PKG_VERSION
+    s.files = PKG_FILES
+
+    s.required_ruby_version = '>= 1.8.1'
+    s.required_rubygems_version = Gem::Requirement.new(">= 1.3.3")
+
+    s.author = "Mohammed Morsi"
+    s.email = "movitto@yahoo.com"
+    s.date = %q{2010-03-20}
+    s.description = %q{The Ruby Advanced Gaming Engine}
+    s.summary = %q{The Ruby Advanced Gaming Engine}
+    s.homepage = %q{http://morsi.org/projects/RAGE}
+end
+
+Rake::GemPackageTask.new(SPEC) do |pkg|
+    pkg.need_tar = true
+    pkg.need_zip = true
+end

data/bin/mesh-viewer.rb

@@ -0,0 +1,91 @@
+#!/usr/bin/ruby
+# use rage to view meshes
+#
+# Flags:
+#  -h --help
+#  -m --mesh [file]
+#
+# Multiple -m options may be specified
+#
+# Copyright (C) 2010 Mohammed Morsi <movitto@yahoo.com>
+# Licensed under the GPLv3+ http://www.gnu.org/licenses/gpl.txt
+
+require 'rubygems'
+require 'optparse'
+
+require 'lib/rage'
+
+include RAGE
+
+# process cmd line args and run main routines
+def main()
+  meshes = []
+
+  # setup cmd line options
+  opts = OptionParser.new do |opts|
+    opts.on("-h", "--help", "Print help message") do
+       puts opts
+       exit
+    end
+    opts.on("-m", "--mesh [uri]", "URI to the mesh file to load (eg file://path)") do |path|
+       meshes.push path
+    end
+  end
+
+  # TODO display any number of meshes (set coordinates/camera appropriately)
+
+  # parse cmd line
+  begin
+    opts.parse!(ARGV)
+  rescue OptionParser::InvalidOption
+    puts opts
+    return
+  end
+
+  if meshes.size == 0
+    puts "at least one valid mesh path required"
+    puts opts
+    return
+  end
+
+  resources = []
+  tx = ty = tz = 0
+  meshes.each do |mesh|
+    resource :type => :mesh, :uri => mesh do |mr|
+      resources << mr
+      boundaries = mr.boundaries
+      scale = mr.scale
+      tx += (boundaries[0] - boundaries[3]) * scale[0]
+      ty += (boundaries[1] - boundaries[4]) * scale[1]
+      tz += (boundaries[2] - boundaries[5]) * scale[2]
+    end
+  end
+
+  # add in addition tenth for padding
+  tx += 0.1 * tx
+  ty += 0.1 * ty
+  tz += 0.1 * tz
+
+  # go through each object, set center to iterator * total length / (number_of_meshes - 1) -  total_length / 2
+  resources.each_index do |i|
+    mx = my = mz = 0
+    unless resources.size == 1
+      mx = i * tx / (resources.size - 1) - tx / 2
+      my = i * ty / (resources.size - 1) - ty / 2
+      mz = i * tz / (resources.size - 1) - tz / 2
+    end
+    resources[i].show_at :x => mx, :y => my, :z => mz
+  end
+
+  window(:width => 512, :height => 512) { |win|
+     win.create_viewport
+  }.show
+
+  game.run
+end
+
+begin
+  main()
+rescue Exception => e
+ puts "#{e} #{e.backtrace.join("\n")}"
+end

data/lib/rage.rb

@@ -0,0 +1,30 @@
+# include all rage modules
+#
+# Copyright (C) 2010 Mohammed Morsi <movitto@yahoo.com>
+# Licensed under the GPLv3+ http://www.gnu.org/licenses/gpl.txt
+
+lib = File.dirname(__FILE__)
+
+$: << lib + '/rage/'
+
+require 'rubygems'
+
+require 'sdl'
+require "gl"
+require "glu"
+
+# The Ruby Advanced Gaming Engine
+module RAGE ; end
+
+require lib + '/rage/common'
+require lib + '/rage/window'
+require lib + '/rage/resource'
+require lib + '/rage/game'
+require lib + '/rage/input'
+require lib + '/rage/location'
+require lib + '/rage/loader'
+require lib + '/rage/color'
+require lib + '/rage/mesh'
+require lib + '/rage/camera'
+require lib + '/rage/viewport'
+require lib + '/rage/dsl'

data/lib/rage/camera.rb

@@ -0,0 +1,59 @@
+# Camera constructs and methods
+#
+# Copyright (C) 2010 Mohammed Morsi <movitto@yahoo.com>
+# Licensed under the GPLv3+ http://www.gnu.org/licenses/gpl.txt
+
+module RAGE
+
+# Camera is the end user's view into the world.
+# It is instantiated as part of a viewport and controls the
+# projection matrix through which the 3D world is viewed.
+class Camera
+
+   # Projection matrix to use, managed internally
+   attr_accessor :projection
+
+   # Camera coordinates
+   attr_accessor :pos
+
+   # Degrees to rotate camera around x,y,z axes
+   attr_accessor :xrotate, :yrotate, :zrotate
+
+   def initialize
+     # FIXME this needs to be parameterized more
+
+     # initialize projection params from window
+     depth = (Window.width + Window.height)/4
+     @projection = [45, Window.width / Window.height, 1, depth]
+
+     # initialize lookat params
+     @pos    = [0, 0, 1]
+
+     # initial rotation params
+     @xrotate, @yrotate, @zrotate = 0,0,0
+   end
+
+   # Invoked during draw cycle to setup projection matrix
+   def draw
+    # setup projection matrix
+    Gl.glMatrixMode(Gl::GL_PROJECTION)
+    Gl.glLoadIdentity
+
+    # TODO at some point make this more modular, allowing user to
+    # select glOrtho or glFrustrum w/ configurable params
+    Glu.gluPerspective(*@projection)
+
+    Gl.glMatrixMode(Gl::GL_MODELVIEW)
+    Gl.glLoadIdentity
+
+    # translate the world by inverse camera position
+    Gl.glTranslatef *(@pos.collect { |p| p * -1 })
+
+    # rotate camera according to params
+    Gl.glRotatef(@xrotate, 1, 0, 0)
+    Gl.glRotatef(@yrotate, 0, 1, 0)
+    Gl.glRotatef(@zrotate, 0, 0, 1)
+   end
+end
+
+end

data/lib/rage/color.rb

@@ -0,0 +1,18 @@
+# Color Resource
+#
+# Copyright (C) 2010 Mohammed Morsi <movitto@yahoo.com>
+# Licensed under the GPLv3+ http://www.gnu.org/licenses/gpl.txt
+
+module RAGE
+
+# Represents a rgb color in the framework
+class Color
+  attr_accessor :color
+
+  def initialize(args = {})
+    rgb = args[:rgb]
+    @color = Window.screen.format.map_rgb(*rgb)
+  end
+end
+
+end

data/lib/rage/common.rb

@@ -0,0 +1,52 @@
+# Things that don't fit elsewhere
+#
+# Copyright (C) 2010 Mohammed Morsi <movitto@yahoo.com>
+# Licensed under the GPLv3+ http://www.gnu.org/licenses/gpl.txt
+
+# logger support
+require 'logger'
+
+# Override default logger format
+class Logger
+  def format_message(severity, timestamp, progname, msg)
+    "#{severity} #{timestamp} (#{$$}) #{msg}\n"
+  end
+end
+
+module RAGE
+    # Logger helper class
+    class Logger
+      private
+        LOG_LEVEL = ::Logger::FATAL # FATAL ERROR WARN INFO DEBUG
+
+        def self._instantiate_logger
+           unless defined? @@logger
+             @@logger = ::Logger.new(STDOUT)
+             @@logger.level = LOG_LEVEL
+           end 
+        end 
+
+      public
+        def self.method_missing(method_id, *args)
+           _instantiate_logger
+           @@logger.send(method_id, args)
+        end 
+        def self.logger
+           _instantiate_logger
+           @@logger
+        end
+    end
+end
+
+class Module
+
+  # Helper method to define class attributes
+  def class_attr(*sym)
+    syms = [sym].flatten # can pass either a single value or array to this method
+    syms.each { |sym|
+      module_eval "def self.#{sym}() @@#{sym} end"
+      module_eval "def self.#{sym}=(x) @@#{sym}=x end"
+    }
+  end
+
+end

data/lib/rage/dsl.rb

@@ -0,0 +1,36 @@
+# RAGE DSL
+#
+# Copyright (C) 2010 Mohammed Morsi <movitto@yahoo.com>
+# Licensed under the GPLv3+ http://www.gnu.org/licenses/gpl.txt
+
+# Sets attributes on the Window w/ any specified arguments and then 
+# invokes block w/ the Window class. Finally Window is returned.
+def window(args = {}, &block)
+   Window.set_attrs args
+   block.call Window unless block.nil?
+   return Window
+end
+
+# Instantiate new viewport w/ specified args and invoke block, using
+# viewport as an arg. Finally return viewport
+def viewport(args = {}, &block)
+   vp = Viewport.new args
+   block.call vp unless block.nil?
+   return vp
+end
+
+# Load resource w/ specified args and invoke blockm using resource as an arg.
+# Finally return resource.
+def resource(args = {}, &block)
+   resource = ResourcesManager.instance.load_resource args
+   block.call resource unless block.nil?
+   return resource
+end
+
+# Set attributes on Game w/ specified args and invoke block
+# using Game as an arg. Finally return Game
+def game(args = {}, &block)
+   #Game.set_attrs(args)
+   block.call Game unless block.nil?
+   return Game
+end

data/lib/rage/game.rb

@@ -0,0 +1,64 @@
+# High level game constructs and methods
+#
+# Copyright (C) 2010 Mohammed Morsi <movitto@yahoo.com>
+# Licensed under the GPLv3+ http://www.gnu.org/licenses/gpl.txt
+
+require 'singleton'
+
+module RAGE
+
+# Manages the overall game execution, end users only need to call run
+# on this class.
+class Game
+  include Singleton
+
+  class_attr :current_viewport
+
+  # Invoked during main game execution cycle to run through a single game draw operation
+  def self.draw
+    Window.draw
+
+    Window.viewports.each { |vp|
+      @@current_viewport = vp
+      vp.draw
+
+      # draw each location
+      LocationsManager.instance.locations.each { |lm|
+        lm.draw
+      }
+    }
+
+    Window.refresh
+  end
+
+  # Run game and block
+  def self.run
+    Gl.glEnable( Gl::GL_TEXTURE_2D )
+    Gl.glEnable(Gl::GL_DEPTH_TEST)
+    Gl.glDepthMask(Gl::GL_TRUE)
+
+    @@wireframe_mode = false
+
+    while true
+      while event = SDL::Event2.poll
+        InputHandler.handle event
+      end
+
+      draw
+      sleep 0.01
+    end
+     
+  end
+
+  # Bool indicating if game should be run in wireframe mode or not
+  class_attr :wireframe_mode
+
+  # Set wireframe mode on / off
+  def self.wireframe_mode=(val)
+    @@wireframe_mode= val
+    Gl.glPolygonMode( Gl::GL_FRONT_AND_BACK, val ? Gl::GL_LINE : Gl::GL_FILL )
+  end
+
+end
+
+end