rage 0.1

data/lib/rage/input.rb

@@ -0,0 +1,91 @@
+# Input handler constructs and methods
+#
+# Copyright (C) 2010 Mohammed Morsi <movitto@yahoo.com>
+# Licensed under the GPLv3+ http://www.gnu.org/licenses/gpl.txt
+
+module RAGE
+
+# FIXME turn into callback interface
+
+# Handles and redirects user events to registered callbacks.
+class InputHandler
+
+  # Invoked during main game execution cycle to handle any SDL input events
+  def self.handle(event)
+
+     @@left_button_pressed  = false unless defined? @@left_button_pressed
+     @@right_button_pressed = false unless defined? @@right_button_pressed
+
+     case event
+     when SDL::Event2::Quit
+        exit
+
+     when SDL::Event2::KeyDown
+        case event.sym
+        when SDL::Key::Q, SDL::Key::ESCAPE
+          exit
+        when SDL::Key::W
+          Game.wireframe_mode= !Game.wireframe_mode
+        end
+
+     when SDL::Event::MouseMotion
+        # get state of mouse buttons
+        left_pressed  = ((event.state & SDL::Mouse::BUTTON_LMASK) != 0)
+        right_pressed = ((event.state & SDL::Mouse::BUTTON_RMASK) != 0)
+
+        # if left button is down, rotate camera
+        if left_pressed
+          xpos, ypos, zpos    = to_3d_coordinates(event.x, event.y)
+          oxpos, oypos, ozpos = to_3d_coordinates(event.x-event.xrel, event.y-event.yrel)
+
+          if xpos > oxpos
+             Game.current_viewport.camera.xrotate += 1
+          elsif xpos < oxpos
+             Game.current_viewport.camera.xrotate -= 1
+          end
+
+          if ypos > oypos
+             Game.current_viewport.camera.yrotate += 1
+          elsif ypos < oypos
+             Game.current_viewport.camera.yrotate -= 1
+          end
+
+          if zpos > ozpos
+             Game.current_viewport.camera.zrotate += 1
+          elsif zpos < ozpos
+             Game.current_viewport.camera.zrotate -= 1
+          end
+
+        # if right is down pan camera
+        elsif right_pressed
+          if event.xrel > 0
+             Game.current_viewport.camera.pos[0]    -= 1
+          elsif event.xrel < 0
+             Game.current_viewport.camera.pos[0]    += 1
+          end
+
+          if event.yrel > 0
+             Game.current_viewport.camera.pos[1]    += 1
+          elsif event.yrel < 0
+             Game.current_viewport.camera.pos[1]    -= 1
+          end
+
+        end
+
+     when SDL::Event::MouseButtonDown
+        # zoom out the camera
+        if event.button == 5 # wheeldown
+          Game.current_viewport.camera.pos[2]    += 1
+        end
+
+     when SDL::Event::MouseButtonUp
+        # zoom in the camera
+        if event.button == 4 # wheel up
+          Game.current_viewport.camera.pos[2]    -= 1
+        end
+
+     end 
+  end
+end
+
+end

data/lib/rage/loader.rb

@@ -0,0 +1,33 @@
+# RAGE resource loader 
+#
+# Copyright (C) 2010 Mohammed Morsi <movitto@yahoo.com>
+# Licensed under the GPLv3+ http://www.gnu.org/licenses/gpl.txt
+
+require 'uri'      # use uri to parse sources
+require 'net/http' # get http:// based resources
+
+module RAGE
+
+# Loads resources from uris
+class Loader
+
+ # Loads and return text resource from specified source uri
+ def self.load(source_uri)
+    Logger.info "loading resource from uri #{source_uri}" 
+    data = nil
+    uri = URI.parse(source_uri)
+    if uri.scheme == "file"
+       data = File.read_all uri.path
+    elsif uri.scheme == "http"
+       data = Net::HTTP.get_response(uri.host, uri.path).body
+    # elsif FIXME support other uri types
+    end
+
+    return data
+
+    rescue URI::InvalidURIError
+       raise Exceptions::InvalidResourceUri
+ end
+
+end # class loader
+end # module RXSD

data/lib/rage/location.rb

@@ -0,0 +1,141 @@
+# Location related constructs
+#
+# Copyright (C) 2010 Mohammed Morsi <movitto@yahoo.com>
+# Licensed under the GPLv3+ http://www.gnu.org/licenses/gpl.txt
+
+module RAGE
+
+# Location w/ coordinates in the 3D system. 
+# Various entities may be associated with Location to be drawn.
+class Location
+   # x, y, z coordinates of the location,
+   attr_reader :x, :y, :z
+
+   # Mesh which to draw at location
+   attr_reader :mesh
+
+   # TODO lights, other entities to draw at locations
+   
+   # Initialize Location with argument hash, which may include
+   # * :x location coordinate
+   # * :y location coordinate
+   # * :z location coordinate
+   # * :mesh resource to draw at location
+   def initialize(args = {})
+      @x = args.has_key?(:x) ? args[:x] : 0
+      @y = args.has_key?(:y) ? args[:y] : 0
+      @z = args.has_key?(:z) ? args[:z] : 0
+      @mesh = args[:mesh]
+   end
+
+   # Update location w/ args, which may include
+   # * :x location coordinate
+   # * :y location coordinate
+   # * :z location coordinate
+   def update(args = {})
+      @x = args[:x] if args.has_key?(:x)
+      @y = args[:y] if args.has_key?(:y)
+      @z = args[:z] if args.has_key?(:z)
+   end
+
+   # Return location boundaries. This is generated by determining maxima/minima
+   # local coordinates of entity associated w/ location and adding those to
+   # the location's coordinates. Return value is an array of six values as follows
+   #   max_x, max_y, max_z, min_x, min_y, min_z
+   def boundaries
+     max_x = max_y = max_z = min_x = min_y = min_z = 0
+     unless mesh.nil?
+       max_x, max_y, max_z, min_x, min_y, min_z = mesh.boundaries
+     end
+     return x + max_x, y + max_y, z + max_z, x + min_x, y + min_y, z + min_z
+   end
+
+
+   # Invoked during draw cycle to draw location & entity associated w/ it
+   def draw
+     Gl.glPushMatrix();
+
+     # translate coordinate system to location's coordinates
+     Gl.glTranslatef(x, y, z)
+
+     # draw mesh
+     mesh.draw
+
+     Gl.glPopMatrix();
+   end
+end
+
+# Singleton class managing all locations
+class LocationsManager
+   include Singleton
+
+   # Array of locations being managed
+   attr_accessor :locations
+
+   def initialize
+     @locations = []
+   end
+
+   # Add location to be managed
+   def add(location)
+     @locations.push location unless @locations.include? location
+   end
+
+   # Empty the array of managed locations
+   def clear
+     @locations.clear
+   end
+
+   # Return the maxima and minima of the x,y,z coordinate values for all the
+   # locations being managed. Return value is an array of six values as follows
+   #   max_x, max_y, max_z, min_x, min_y, min_z
+   # This method essentially gives you the "box" in which all locations being managed are in
+   def boundaries
+     max_x = max_y = max_z = min_x = min_y = min_z = 0
+     @locations.each { |loc|
+        locb = loc.boundaries
+        max_x = locb[0] if locb[0] > max_x
+        max_y = locb[1] if locb[1] > max_y
+        max_z = locb[2] if locb[2] > max_z
+        min_x = locb[3] if locb[3] < min_x
+        min_y = locb[4] if locb[4] < min_y
+        min_z = locb[5] if locb[5] < min_z
+     }
+     return max_x, max_y, max_z, min_x, min_y, min_z
+   end
+
+   # Return the center coordinate of location system.
+   # Must specify the metric which to generate center, which may be either
+   # * :avg  - compute and return bounaries averages
+   # * :mean - compute and return mean of all coords
+   def center(metric = :mean)
+      if metric == :mean
+         ls = @locations.size
+         mx = my = mz = 0
+         @locations.each { |lm|
+            mx += lm.x / ls
+            my += lm.y / ls
+            mz += lm.z / ls
+         }
+         return mx,my,mz
+
+      elsif metric == :avg
+         b = self.boundaries
+         return (b[0] + b[3]) / 2, (b[1] + b[4]) / 2, (b[2] + b[5]) / 2
+
+      end
+   end
+
+end
+
+# Helper method to get 3d coords cooresponding to 2d ones via OPENGL unprojection
+def to_3d_coordinates(x2, y2)
+  model_view = Gl.glGetDoublev Gl::GL_MODELVIEW_MATRIX
+  projection = Gl.glGetDoublev Gl::GL_PROJECTION_MATRIX
+  viewport   = Gl.glGetIntegerv Gl::GL_VIEWPORT
+  depth      = Gl.glReadPixels x2, y2, 1, 1, Gl::GL_DEPTH_COMPONENT, Gl::GL_FLOAT
+  x3, y3, z3 = Glu.gluUnProject x2, y2, depth[0], model_view, projection, viewport
+  return [x3, y3, z3]
+end
+
+end

data/lib/rage/mesh.rb

@@ -0,0 +1,147 @@
+# Mesh Resource
+#
+# Currently manages X3D meshes
+#
+# Copyright (C) 2010 Mohammed Morsi <movitto@yahoo.com>
+# Licensed under the GPLv3+ http://www.gnu.org/licenses/gpl.txt
+
+# use rxsd to load x3d xsd schema, declare xsd classes, instantiate scenes
+require 'rxsd'
+
+module RAGE
+
+# 3D mesh to be displayed on the screen. 
+# Contains geometry and visual properties.
+# Currently implements certain parts of the X3D graphics schema.
+# http://en.wikipedia.org/wiki/X3D
+class Mesh
+  # Optional transformation params, set these to 
+  # transformations to be factored in if needed
+  attr_accessor :op_translation, :op_scale, :op_rotation
+
+  # X3D schema for shared access
+  class_attr :x3d_schema
+
+  # X3D schema classes for shared access
+  class_attr :x3d_schema_classes
+
+
+  # Create new mesh from raw X3D mesh
+  def initialize(data)
+     # set default attributes
+     @op_translation =  [0,0,0]
+     @op_scale       =  [1,1,1]
+
+     # load the x3d xsd schema and classes if not already done so
+     unless defined? @@x3d_schema
+       @@x3d_schema = RXSD::Parser.parse_xsd :uri => 'http://www.web3d.org/specifications/x3d-3.0.xsd' # TODO allow location which this is pulled from to be configured
+       @@x3d_schema_classes = @@x3d_schema.to :ruby_classes
+     end
+
+     # load the scene from the x3d schema instance
+     objs = RXSD::Parser.parse_xml(:raw => data).to(:ruby_objects, :schema => @@x3d_schema)
+     @scene = objs[0].scene
+
+     # FIXME get all transformations (and groups of) under scene
+     @tf = @scene.collision.transform
+     @translation = @tf.translation.to_a :type => XSDFloat
+     @scale       = @tf.scale.to_a :type => XSDFloat
+     #diffuse     = tf.shape.appearance.material.diffuse_color.split.collect { |c| c.to_f }
+     #specular    = tf.shape.appearance.material.specular_color.split.collect { |c| c.to_f }
+     #emissive    = tf.shape.appearance.material.emissive_color.split.collect { |c| c.to_f }
+     @coord_index  = @tf.shape.indexed_face_set.coord_index.
+                                     to_a(:type => String, :delim => ",").
+                                     collect { |coords| a = coords.to_a(:type => XSDInteger); a[0...a.size-1]}.flatten # cut off the last -1
+     @coord_point  = @tf.shape.indexed_face_set.coordinate.point.
+                                     to_a(:type => String, :delim => ",").
+                                     collect { |coords| coords.to_a :type => XSDFloat }.flatten
+  end
+
+  # Create location w/ specified args, associated mesh w/ it and add it to the LocationsManager
+  def show_at(args = {})
+    # XXX not a huge fan of storing location interally,
+    # but this is best way to do this for now
+    if ! defined? @location
+      args[:mesh] = self
+      @location = Location.new(args)
+      LocationsManager.instance.add @location
+    else
+      @location.update args
+    end
+    return @location
+  end
+
+
+  # Return center point of mesh from mesh translation provided in mesh 
+  # and op_translation
+  def center
+     return @op_translation[0] + @translation[0],
+            @op_translation[1] + @translation[1],
+            @op_translation[2] + @translation[2]
+  end
+
+  # Return factor which mesh should scale to
+  def scale
+     return @scale[0] * @op_scale[0],
+            @scale[1] * @op_scale[1],
+            @scale[2] * @op_scale[2]
+  end
+
+  # Return mesh boundaries. This is generated by determining the maxima/minima
+  # coordinate points. Return value is an array of six values as follows
+  #   max_x, max_y, max_z, min_x, min_y, min_z
+  def boundaries
+     centerx, centery, centerz = *center
+     max_x = max_y = max_z = min_x = min_y = min_z = 0
+     @coord_point.each_index {  |cpi|
+        if cpi % 3 == 0
+          adjx = centerx + @coord_point[cpi]
+          if  adjx > max_x
+             max_x = adjx
+          elsif adjx < min_x
+             min_x = adjx
+          end
+        elsif cpi % 3 == 1 
+          adjy = centery + @coord_point[cpi]
+          if adjy > max_y
+             max_y = adjy
+          elsif adjy < min_y
+             min_y = adjy
+          end
+        else
+          adjz = centerz + @coord_point[cpi]
+          if adjz > max_z
+             max_z = adjz
+          elsif adjz < min_z
+             min_z = adjz
+          end
+        end
+     }
+     return max_x, max_y, max_z, min_x, min_y, min_z
+  end
+
+
+  # Invoked during draw cycle to draw mesh
+  def draw
+     # FIXME mesh material
+     #Gl.glMaterial(Gl::GL_FRONT, Gl::GL_DIFFUSE,  diffuse)
+     #Gl.glMaterial(Gl::GL_FRONT, Gl::GL_SPECULAR, specular)
+     #Gl.glMaterial(Gl::GL_FRONT, Gl::GL_EMISSIVE, emissive)
+
+     # translate coordinate system to center position of mesh
+     Gl.glTranslatef(*center)
+
+     # scale as specified 
+     Gl.glScalef(*scale)
+
+     # FIXME rotate according to mesh and optional params
+
+     # draw mesh
+     Gl.glEnableClientState(Gl::GL_VERTEX_ARRAY);
+     Gl.glVertexPointer(3, Gl::GL_FLOAT, 0, @coord_point);
+     Gl.glDrawElements(Gl::GL_QUADS, @coord_index.size, Gl::GL_UNSIGNED_INT, @coord_index);
+     Gl.glDisableClientState(Gl::GL_VERTEX_ARRAY);
+  end
+end
+
+end

data/lib/rage/resource.rb

@@ -0,0 +1,49 @@
+# Resources 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
+
+# Singleton class managing all RAGE resources.
+# Resources should be loaded here instead as opposed to creating them manually
+# so as to mantain a central management repository during game execution.
+class ResourcesManager
+ include Singleton
+
+  # Hash of ids -> resources we are managing
+  attr_accessor :resources
+
+  def initialize
+    @resources = {}
+  end
+
+  # Load resource from specified args and add to manager. Args may include
+  # * :type type of resource to load
+  # * :id   unique identifier to give resource
+  # * :uri  uri of resource if appropriate
+  # * :color resource color if appropriate
+  def load_resource(args = {})
+    type = args[:type]
+    id = args[:id]
+
+    resource = nil
+
+    if type == :mesh
+      uri  = args[:uri]
+      data = Loader.load uri
+      resource = Mesh.new(data)
+    elsif type == :color
+      color = args[:color]
+      resource = Color.new(:rgb => color)
+    # elsif other resource types
+    end
+
+    @resources[id] = resource
+    return resource
+  end
+end
+
+end