teien 0.0.2 → 0.0.3

data/lib/teien/garden_base.rb

@@ -0,0 +1,117 @@
+require "teien/garden_object.rb"
+require "teien/sky_dome.rb"
+require "teien/physics.rb"
+#require "teien/user_interface.rb"
+#require "teien/event_router.rb"
+require "teien/dispatcher.rb"
+
+require "eventmachine"
+require "teien/network.rb"
+
+module Teien
+
+# This is a top object of 3D world.
+class GardenBase
+  include Dispatcher
+
+  attr_accessor :resources_cfg
+  attr_accessor :plugins_cfg
+  attr_accessor :physics
+  attr_accessor :objects
+  attr_accessor :actors
+
+  attr_accessor :gravity
+  attr_accessor :ambient_light_color
+
+  #
+  # _script_klass_:: : set a user define class.
+  # 
+  def initialize()
+    super()
+
+    @physics = Physics.new()
+    @actors = Hash.new()
+
+    @resources_cfg = nil
+    @plugins_cfg = nil
+
+    @objects = {}
+    @object_num = 0
+
+    @debug_draw = false
+    @quit = false
+    @last_time = 0
+
+    # environment value
+    @gravity = nil
+    @ambient_light_color = nil
+    @sky_dome = nil
+  end
+
+  #
+  # set the gravity of the world.
+  #
+  # _grav_ :: : set a vector(Vector3D) as the gravity.
+  #
+  def set_gravity(grav)
+    @gravity = grav
+    @physics.set_gravity(grav)
+  end
+
+  #
+  # set the ambient light of the world.
+  #
+  # _color_:: : set a color(Color).
+  #
+  def set_ambient_light(color)
+    @ambient_light_color = color
+    notify(:set_ambient_light, color)
+  end
+
+  def set_sky_dome(enable, materialName, curvature = 10, tiling = 8, distance = 4000)
+    @sky_dome = SkyDome.new(enable, materialName, curvature, tiling, distance)
+    notify(:set_sky_dome, enable, materialName, curvature, tiling, distance)
+  end
+
+  def create_object(name, object_info, physics_info)
+    if (@objects[name])
+      #raise RuntimeError, "There is a object with the same name (#{obj.name})"
+      puts "There is a object with the same name (#{name})"
+      return @objects[name]
+    else
+      obj = GardenObject.new()
+      obj.name = name
+      obj.object_info = object_info
+      obj.physics_info = physics_info
+
+      obj.garden = @garden
+      @objects[obj.name] = obj
+      obj.id = @object_num
+      @object_num += 1
+      @physics.add_physics_object(obj)
+      notify(:create_object, obj)
+      return obj
+    end
+  end
+
+  def add_actor(actor)
+    if (@actors[actor.name] == nil)
+      actors[name] = actor
+      notify(:add_actor, actor)
+    else
+      raise RuntimeError, "There is an actor with the same name (#{actor.name})"
+    end
+  end
+
+  def check_collision(objectA, objectB)
+    result = @physics.contact_pair_test(objectA.rigid_body, objectB.rigid_body)
+    return result.collided?()
+  end
+
+  # quit the current running garden.
+  def quit()
+    @quit = true
+  end
+end
+
+end # module 

data/lib/teien/garden_object.rb

@@ -1,5 +1,6 @@
 require "teien/tools.rb"
-require "teien/animation_operator.rb"
+require "teien/physics_object.rb"
+require "teien/view_object.rb"
 
 module Teien
 
@@ -14,76 +15,33 @@ class GardenObject < Bullet::BtMotionState
 
   attr_accessor :object_info
   attr_accessor :physics_info
+  attr_accessor :animation_info
 
-  # Bullet accessor
-  attr_accessor :rigid_body # shows the center of this object.
-  attr_accessor :pivot_shape
-  attr_accessor :shape
-
-  # Ogre3D accessor
-  ## center of view objects(sceneNode) and kept to equal with the rigid_body position.
-  attr_accessor :pivot_scene_node 
-  attr_accessor :scene_node
-  attr_accessor :entity
+  attr_accessor :garden
+  attr_accessor :physics_object
+  attr_accessor :view_object
 
   MODE_FREE = 0
   MODE_ATTACHED = 1
 
-  def initialize(garden)
+  def initialize()
     super()
     @id = -1
-    @garden = garden
     @mode = MODE_FREE
 
-    @pivot_scene_node = nil
-    @scene_node = nil
-    @entity = nil
-
-    @rigid_body = nil
-    @transform = Bullet::BtTransform.new()
-    @transform.set_identity()
-    @acceleration = Vector3D.new(0, 0, 0)
-
-    @maxHorizontalVelocity = 0
-    @maxVerticalVelocity = 0
+    @garden = nil
+    @physics_object = nil
+    @view_object = nil
+    @animation_info = Animation.new
   end
 
-  #
-  # The offset changes the local position of the created scene_node in Object.
-  #
-  def create_scene_node(entity, offset = Vector3D.new(0, 0, 0), rotate = Quaternion.new(0, 0, 0, 1.0))
-    if (@pivot_scene_node == nil)
-      @pivot_scene_node = @garden.view.scene_mgr.get_root_scene_node().create_child_scene_node()
-    end
-    @scene_node = @pivot_scene_node.create_child_scene_node(Vector3D.to_ogre(offset), Quaternion.to_ogre(rotate))
-    @pivot_scene_node.instance_variable_set(:@child, @scene_node) # prevent this from GC.
-    if entity
-      @scene_node.attach_object(entity)
-      @entity = entity
-    end
-    return @scene_node
-  end
-
-  #
-  # The offset changes the local position of the shape(collision shape) in Object.
-  #
-  def create_rigid_body(mass, shape, inertia, offset = Vector3D.new(0, 0, 0))
-#    puts "offset(#{offset.x}, #{offset.y}, #{offset.z})"
-    @pivot_shape = Bullet::BtCompoundShape.new
-    localTrans = Bullet::BtTransform.new
-    localTrans.set_identity()
-    localTrans.set_origin(offset)
-    @pivot_shape.add_child_shape(localTrans, shape)
-    @shape = shape
-    @rigid_body = @garden.physics.create_rigid_body(mass, self, @pivot_shape, inertia)
-  end
-
-  def create_animation_operator()
-    return AnimationOperator.new(@entity)
+  def finalize()
+    @view_object.finalize() if @view_object
+    @physics_object.finalize()
   end
 
   def set_activation_state(state)
-    @rigid_body.set_activation_state(state)
+    @physics_object.rigid_body.set_activation_state(state)
   end
 
 
@@ -92,9 +50,25 @@ class GardenObject < Bullet::BtMotionState
   # ==== Args
   # [aPos: Vector3D] 
   def set_position(aPos)
-    @pivot_scene_node.set_position(aPos.x, aPos.y, aPos.z) unless @garden.is_server
-    @transform.set_origin(Bullet::BtVector3.new(aPos.x, aPos.y, aPos.z))
-    @rigid_body.set_center_of_mass_transform(@transform) if (@rigid_body != nil)
+    
+#    @pivot_scene_node.set_position(aPos.x, aPos.y, aPos.z) unless @garden.is_server
+    @physics_object.transform.set_origin(Bullet::BtVector3.new(aPos.x, aPos.y, aPos.z))
+    @physics_object.rigid_body.set_center_of_mass_transform(@physics_object.transform) if (@physics_object.rigid_body != nil)
+
+    # view
+    if (@view_object)
+      if (object_info.class == LightObjectInfo)
+        @view_object.entity.set_position(Vector3D.to_ogre(aPos))
+      else        
+        @view_object.pivot_scene_node.set_position(aPos.x, aPos.y, aPos.z)
+      end
+    end
+  end
+
+  def set_position_with_interpolation(pos)
+    ip_pos = (get_position() + Vector3D.to_bullet(pos)) / 2
+    @physics_object.transform.set_origin(ip_pos)
+    @physics_object.rigid_body.set_center_of_mass_transform(@physics_object.transform) if (@physics_object.rigid_body != nil)
   end
 
   # Set a linear velocity.
@@ -102,8 +76,14 @@ class GardenObject < Bullet::BtMotionState
   # ==== Args
   # [aVel: Vector3D] 
   def set_linear_velocity(aVel)
-    @rigid_body.activate(true)
-    @rigid_body.set_linear_velocity(aVel)
+    @physics_object.rigid_body.activate(true)
+    @physics_object.rigid_body.set_linear_velocity(aVel)
+  end
+
+  def set_linear_velocity_with_interpolation(vel)
+    ip_vel = (get_linear_velocity() + Vector3D.to_bullet(vel)) / 2
+    @physics_object.rigid_body.activate(true)
+    @physics_object.rigid_body.set_linear_velocity(ip_vel)
   end
 
   # Set an angular velocity.
@@ -111,7 +91,14 @@ class GardenObject < Bullet::BtMotionState
   # ==== Args
   # [vel: Vector3D] 
   def set_angular_velocity(vel)
-    @rigid_body.set_angular_velocity(vel)
+    @physics_object.rigid_body.activate(true)
+    @physics_object.rigid_body.set_angular_velocity(vel)
+  end
+
+  def set_angular_velocity_with_interpolation(vel)
+    @physics_object.rigid_body.activate(true)
+    ip_vel = (get_angular_velocity() + Vector3D.to_bullet(vel)) / 2
+    @physics_object.rigid_body.set_angular_velocity(ip_vel)
   end
 
   # Set a max horizontal velocity.
@@ -119,7 +106,7 @@ class GardenObject < Bullet::BtMotionState
   # ==== Args
   # [vel: Vector3D] vel is the max velocity. 0 means there is no limit.
   def set_max_horizontal_velocity(vel_len)
-    @maxHorizontalVelocity = vel_len
+    @physics_object.maxHorizontalVelocity = vel_len
   end
 
   # Set a max vertical velocity.
@@ -127,50 +114,60 @@ class GardenObject < Bullet::BtMotionState
   # ==== Args
   # [vel: Vector3D] vel is the max velocity. 0 means there is no limit.
   def set_max_vertical_velocity(vel_le)
-    @maxVerticalVelocity = vel_len
+    @physics_object.maxVerticalVelocity = vel_len
   end
 
   # Set the object's acceleration.
   def set_acceleration(acc)
-    @acceleration = acc
+    @physics_object.acceleration = acc
   end
 
   def set_gravity(grav)
-    @rigid_body.set_gravity(grav)
+    @physics_object.rigid_body.set_gravity(grav)
+  end
+
+  def set_damping(linear_damping, angular_damping)
+    @physics_object.rigid_body.set_damping(linear_damping, angular_damping)
+    @physics_info.linear_damping = linear_damping
+    @physics_info.angular_damping = angular_damping
+    # notify?
   end
 
   def set_rotation(quad)
-    transform = @rigid_body.get_center_of_mass_transform()
-    transform.set_rotation(quad)
-    @rigid_body.set_center_of_mass_transform(transform)
+    @physics_object.rigid_body.activate(true)
+    @physics_object.transform = @physics_object.rigid_body.get_center_of_mass_transform()
+    @physics_object.transform.set_rotation(quad)
+    @physics_object.rigid_body.set_center_of_mass_transform(@physics_object.transform)
+  end
+
+  def set_rotation_with_interpolation(quad)
+    @physics_object.rigid_body.activate(true)
+    ip_quad = get_rotation().slerp(Quaternion.to_bullet(quad), 0.5)
+    @physics_object.transform = @physics_object.rigid_body.get_center_of_mass_transform()
+    @physics_object.transform.set_rotation(ip_quad)
+    @physics_object.rigid_body.set_center_of_mass_transform(@physics_object.transform)
   end
 
   def set_collision_filter(filter)
-    @garden.physics.dynamicsWorld.remove_rigid_body(@rigid_body)
-    @garden.physics.dynamicsWorld.add_rigid_body(@rigid_body, filter.group, filter.mask)
+    @garden.physics.dynamicsWorld.remove_rigid_body(@physics_object.rigid_body)
+    @garden.physics.dynamicsWorld.add_rigid_body(@physics_object.rigid_body, filter.group, filter.mask)
     physics_info.collisionFilter = filter
   end
 
   def set_world_transform(worldTrans)
-#    puts "setWorldTransform"
-
-    if (@mode == MODE_FREE)
-#    pos = worldTrans.getOrigin()
-#    puts "origin(#{pos.x}, #{pos.y}, #{pos.z})"
-
-      @transform = Bullet::BtTransform.new(worldTrans)
-      newPos = @transform.get_origin()
-      newRot = @transform.get_rotation()
-#    puts "newRot(#{id}: #{newRot.x}, #{newRot.y}, #{newRot.z}, #{newRot.w})"
-#    puts "newPos(#{id}: #{newPos.x}, #{newPos.y}, #{newPos.z})"
-
-      if (newRot.x.nan?)
-        return
-      end
-
-      unless @garden.is_server
-        @pivot_scene_node.set_position(newPos.x, newPos.y, newPos.z) 
-        @pivot_scene_node.set_orientation(newRot.w, newRot.x, newRot.y, newRot.z)
+    @physics_object.transform = Bullet::BtTransform.new(worldTrans) if (@mode == MODE_FREE)
+
+    if (@view_object)
+      if (@mode == MODE_FREE)
+        newPos = @physics_object.transform.get_origin()
+        newRot = @physics_object.transform.get_rotation()
+        # puts "newRot(#{id}: #{newRot.x}, #{newRot.y}, #{newRot.z}, #{newRot.w})"
+        # puts "newPos(#{id}: #{newPos.x}, #{newPos.y}, #{newPos.z})"
+        
+        return if (newRot.x.nan?)
+        
+        @view_object.pivot_scene_node.set_position(newPos.x, newPos.y, newPos.z) 
+        @view_object.pivot_scene_node.set_orientation(newRot.w, newRot.x, newRot.y, newRot.z)
       end
     end
   end
@@ -180,62 +177,62 @@ class GardenObject < Bullet::BtMotionState
   end
 
   def get_activation_state()
-    @rigid_body.get_activation_state()
+    @physics_object.rigid_body.get_activation_state()
   end
 
   def get_mass()
-    return 1.0 / @rigid_body.get_inv_mass()
+    return 1.0 / @physics_object.rigid_body.get_inv_mass()
   end
 
   def get_inv_mass()
-    return @rigid_body.get_inv_mass()
+    return @physics_object.rigid_body.get_inv_mass()
   end
 
   def get_collision_mask()
-    @rigid_body.get_broadphase_handle().m_collisionFilterMask
+    @physics_object.rigid_body.get_broadphase_handle().m_collisionFilterMask
   end
 
   def get_position()
-    newPos = @transform.get_origin()
+    newPos = @physics_object.transform.get_origin()
     return newPos
   end
 
   def get_linear_velocity()
-    return @rigid_body.get_linear_velocity()
+    return @physics_object.rigid_body.get_linear_velocity()
   end
 
   def get_angular_velocity()
-    return @rigid_body.get_angular_velocity()
+    return @physics_object.rigid_body.get_angular_velocity()
   end
 
   def get_acceleration()
-    return @acceleration
+    return @physics_object.acceleration
   end
 
   def get_gravity()
-    return @rigid_body.get_gravity()
+    return @physics_object.rigid_body.get_gravity()
   end
 
   def get_rotation()
-    return @transform.get_rotation()
+    return @physics_object.transform.get_rotation()
   end
 
   def get_orientation()
-    return @transform.get_rotation()
+    return @physics_object.transform.get_rotation()
   end
 
   def limit_velocity(vel)
     newVel = Bullet::BtVector3.new(vel.x, vel.y, vel.z)
 
     hLen = Math::sqrt(vel.x * vel.x + vel.z * vel.z)
-    if (@maxHorizontalVelocity != 0 && hLen > @maxHorizontalVelocity)
-      newVel.x = vel.x / hLen * @maxHorizontalVelocity
-      newVel.z = vel.z / hLen * @maxHorizontalVelocity
+    if (@physics_object.maxHorizontalVelocity != 0 && hLen > @physics_object.maxHorizontalVelocity)
+      newVel.x = vel.x / hLen * @physics_object.maxHorizontalVelocity
+      newVel.z = vel.z / hLen * @physics_object.maxHorizontalVelocity
     end
 
     vLen = vel.y
-    if (@maxVerticalVelocity != 0 && vLen > @maxVerticalVelocity)
-      newVel.y = @maxVerticalVelocity
+    if (@physics_object.maxVerticalVelocity != 0 && vLen > @physics_object.maxVerticalVelocity)
+      newVel.y = @physics_object.maxVerticalVelocity
     end
 
 #    puts "newVel: (#{newVel.x}, #{newVel.y}, #{newVel.z})"
@@ -244,8 +241,8 @@ class GardenObject < Bullet::BtMotionState
   end
 
   def apply_impulse(imp, rel = Vector3D.new(0, 0, 0))
-    @rigid_body.activate(true)
-    @rigid_body.apply_impulse(imp, rel)
+    @physics_object.rigid_body.activate(true)
+    @physics_object.rigid_body.apply_impulse(imp, rel)
   end
 
   #
@@ -260,15 +257,18 @@ class GardenObject < Bullet::BtMotionState
     qnorm = Quaternion.new()
     qnorm.copy(quat)
     qnorm.normalize()
-    transform = @rigid_body.get_center_of_mass_transform()
+    transform = @physics_object.rigid_body.get_center_of_mass_transform()
     curRot = transform.get_rotation()
-    newRot = curRot * qnorm
-    transform.set_rotation(newRot)
-    @rigid_body.set_center_of_mass_transform(transform)
+    @newRot = curRot * qnorm
+    transform.set_rotation(@newRot)
+    @physics_object.rigid_body.set_center_of_mass_transform(transform)
 
-    @pivot_scene_node.set_orientation(Quaternion.to_ogre(newRot)) unless @garden.is_server
+    if (@view_object)
+      @view_object.pivot_scene_node.set_orientation(Quaternion.to_ogre(@newRot))
+    end
   end
-
+  
+=begin
   def attach_object_to_bone(boneName, obj)
     obj.scene_node.detach_object(obj.entity)
     tag = @entity.attach_object_to_bone(boneName, obj.entity)
@@ -280,34 +280,17 @@ class GardenObject < Bullet::BtMotionState
   def detach_object_from_bone(obj)
     @entity.detach_object_from_bone(obj.entity)
     obj.scene_node.attach_object(obj.entity)
-    if obj.physics_info.collisionFilter
+    if obj.physics_info.collision_filter
       @garden.physics.dynamics_world.add_rigid_body(obj.rigid_body, 
-                                                    obj.physics_info.collisionFilter.group,
-                                                    obj.physics_info.collisionFilter.mask)
+                                                    obj.physics_info.collision_filter.group,
+                                                    obj.physics_info.collision_filter.mask)
     else
       @garden.physics.dynamics_world.add_rigid_body(obj.rigid_body)
     end
     obj.mode = MODE_FREE
   end
+=end
 
-  def update(delta)
-  end
-
-  def pull()
-    pos = get_position()
-    return [@id, pos.x, pos.y, pos.z].pack("NNNN")
-  end
-  
-  def push(packedData)
-    data = packedData.unpack("NNNN")
-    posX = data[1]
-    posY = data[2]
-    posZ = data[3]
-    
-    puts "#{@id}: (#{posX}, #{posY}, #{posZ})"
-    
-    set_position(Vector3D.new(posX, posY, posZ))
-  end
 end
 
 

data/lib/teien/model.rb

@@ -0,0 +1,34 @@
+require 'teien'
+
+module Teien
+
+class Model
+  @@models = Array.new
+  @@loaded_models = Array.new
+
+  @garden = nil
+
+  def initialize(garden)
+    @garden = garden
+    @garden.register_receiver(self)
+
+=begin
+    # set config files.
+    fileDir = File.dirname(File.expand_path(__FILE__))
+    @garden.plugins_cfg = "#{fileDir}/plugins.cfg"
+    @garden.resources_cfg = "#{fileDir}/resources.cfg"
+=end
+  end
+
+  def self.inherited(klass)
+    @@models.push(klass)
+  end
+
+  def self.load(garden)
+    @@models.each {|ctl|
+      @@loaded_models.push(ctl.new(garden))
+    }
+  end
+end
+
+end

data/lib/teien/network.rb

@@ -0,0 +1,108 @@
+require 'teien/remote_info'
+
+module Teien
+
+class Network < EM::Connection
+  @@connected_clients = Hash.new
+  @@garden = nil
+
+  def initialize(garden)
+    @@garden = garden
+  end
+
+  def self.connected_clients
+    @@connected_clients
+  end
+
+  def post_init
+    puts "A client has connected."
+    @@connected_clients[self] = RemoteInfo.new(self)
+    @@garden.receive_event(Event::ClientConnected.new, self)
+  end
+
+  def unbind
+    puts "A client has unbinded."
+    @@garden.receive_event(Event::ClientUnbinded.new, self)
+    @@connected_clients.delete(self)
+  end
+
+  include EM::P::ObjectProtocol
+
+  def receive_object(obj)
+    @@garden.receive_event(obj, self)
+  end
+
+  def self.send_all(obj)
+    @@connected_clients.each_value { |c|
+      c.connection.send_object(obj)
+    }
+  end
+end
+
+=begin
+class ServerNetwork < EM::Connection
+  @@connected_clients = Array.new
+
+  def initialize(event_router)
+    @event_router = event_router
+    @event_router.register_receiver(Event::ToControllerGroup, self)
+  end
+
+  def receive_event(event)
+    send_all(event)
+  end
+
+  def post_init
+    puts "A client has connected."
+    @@connected_clients.push(self)
+    @event_router.notify(Event::ClientConnected.new)
+  end
+
+  def unbind
+    puts "A client has unbinded."
+    @@connected_clients.delete(self)
+  end
+
+  include EM::P::ObjectProtocol
+
+  def receive_object(obj)
+    @event_router.notify(obj)
+#    puts "A object is received"
+#    obj.print
+  end
+
+  def send_all(obj)
+    @@connected_clients.each { |c|
+      c.send_object(obj)
+    }
+  end
+end
+
+class ClientNetwork < EM::Connection
+  def initialize(event_router)
+    @event_router = event_router
+    @event_router.register_receiver(Event::ToModelGroup, self)
+  end
+
+  def receive_event(event)
+    send_object(event)
+  end
+
+  def connection_completed
+    puts "The connection is completed."
+  end
+
+  def unbind
+    puts "The connection is closed."
+  end
+
+  include EM::P::ObjectProtocol
+
+  def receive_object(obj)
+    @event_router.notify(obj)
+  end
+end
+
+=end
+
+end

data/lib/teien/object_info.rb

@@ -1,5 +1,26 @@
 module Teien
 
+class LightObjectInfo
+  POINT = Ogre::Light::LT_POINT
+  DIRECTIONAL = Ogre::Light::LT_DIRECTIONAL
+  SPOTLIGHT = Ogre::Light::LT_SPOTLIGHT
+
+  attr_accessor :type
+  attr_accessor :diffuse_color
+  attr_accessor :specular_color
+  attr_accessor :direction
+
+  def initialize(type,
+                 diffuse_color = Color.new(1.0, 1.0, 1.0),
+                 specular_color = Color.new(0.25, 0.25, 0),
+                 direction = Vector3D.new( -1, -1, -1 ))
+    @type = type
+    @diffuse_color = diffuse_color
+    @specular_color = specular_color
+    @direction = direction
+  end
+end
+
 class MeshBBObjectInfo 
   attr_accessor :mesh_path
   attr_accessor :size          # Loading mesh only: bounding box size