teien 0.0.2 → 0.0.3

data/lib/teien/physics.rb

@@ -1,3 +1,5 @@
+require "teien/physics_object_factory.rb"
+
 module Teien
 
 CollisionFilter = Struct.new(:group, :mask)
@@ -5,6 +7,7 @@ CollisionFilter = Struct.new(:group, :mask)
 class ContactResult < Bullet::ContactResultCallback
   def initialize
     super
+
     @isCollided = false
   end
 
@@ -27,18 +30,23 @@ class Physics < Bullet::TickListener
   attr_accessor :fixed_time_step
 #  attr_accessor :softBodyWorldInfo
 
-  def initialize(garden)
+  def initialize()
     super()
-    @garden = garden
+
+    @object_factory = PhysicsObjectFactory.new(self)
+    @rigid_bodies = []
 
     @max_sub_steps = 1
     @fixed_time_step = 1.0 / 60.0
+  end
 
-    @rigid_bodies = []
+  def set_gravity(vec)
+    @dynamics_world.set_gravity(vec)
   end
 
-  def setup
-    @collision_config = Bullet::BtDefaultCollisionConfiguration.new();
+  def setup(garden)
+    @garden = garden
+    @collision_config = Bullet::BtDefaultCollisionConfiguration.new()
     @collision_dispatcher = Bullet::BtCollisionDispatcher.new(@collision_config)
 
     worldAabbMin = Bullet::BtVector3.new(-3000.0,-500.0, -3000.0)
@@ -77,6 +85,35 @@ class Physics < Bullet::TickListener
 #    @dynamics_world.finalize()
   end
 
+  def add_physics_object(obj)
+    obj.physics_object = @object_factory.create_object(obj)
+
+    if (obj.physics_object.rigid_body != nil && 
+        obj.object_info.class != LightObjectInfo)
+      
+      if (obj.physics_info.collision_filter)
+        add_rigid_body(obj.physics_object.rigid_body, 
+                       obj.physics_info.collision_filter) 
+      else
+        add_rigid_body(obj.physics_object.rigid_body) 
+      end
+    end
+  end
+
+  def add_rigid_body(rigid_body, collision_filter = nil)
+    @rigid_bodies.push(rigid_body)
+    if (collision_filter)
+      @dynamics_world.add_rigid_body(rigid_body, collision_filter.group, collision_filter.mask)
+    else
+      @dynamics_world.add_rigid_body(rigid_body)
+    end
+  end
+
+  def del_rigid_body(rigid_body)
+    @rigid_bodies.delete(rigid_body)
+    @dynamics_world.remove_rigid_body(rigid_body)
+  end
+
   def update(delta)
     @dynamics_world.step_simulation(delta, @max_sub_steps, @fixed_time_step)
     return true
@@ -94,56 +131,27 @@ class Physics < Bullet::TickListener
                                                          @dynamics_world.get_dispatcher())
   end
 
-  def set_gravity(vec)
-    @dynamics_world.set_gravity(vec)
-  end
-
-=begin
-  def create_box_shape(size)
-    return Bullet::BtBoxShape.new(size)
-  end
-
-  def createSphereShape(radius)
-    return Bullet::BtSphereShape.new(radius)
-  end
-=end
-
-  def create_rigid_body(mass, motionState, colObj, inertia)
-    rigid_body = Bullet::BtRigidBody.new(mass, motionState, colObj, inertia)
-    rigid_body.instance_variable_set(:@collision_shape, colObj) # prevent this colObj from GC.
-    return rigid_body
-  end
-
-  def add_rigid_body(rigid_body, collision_filter = nil)
-    @rigid_bodies.push(rigid_body)
-    if (collision_filter)
-      @dynamics_world.add_rigid_body(rigid_body, collision_filter.group, collision_filter.mask)
-    else
-      @dynamics_world.add_rigid_body(rigid_body)
-    end
-  end
-
   def contact_pair_test(colObjA, colObjB)
     result = ContactResult.new
     @dynamics_world.contact_pair_test(colObjA, colObjB, result)
     return result
   end
 
-  def preTickCallback(timeStep)
-#    print "preTickCallback: ", timeStep * 1000, "ms\n"
+  def pre_tick_callback(timeStep)
+#    print "pre_tick_callback: ", timeStep * 1000, "ms\n"
     delta = Bullet::BtVector3.new(timeStep, timeStep, timeStep)
 
     @garden.objects.each {|name, obj|
       if (obj.get_mass() > 0)
-        newVel = obj.get_linear_velocity() + obj.get_acceleration() * delta
+        newVel = obj.get_linear_velocity() + Vector3D.to_bullet(obj.get_acceleration()) * delta
         obj.set_linear_velocity(obj.limit_velocity(newVel))
         lastVel = obj.get_linear_velocity()
       end
     }
   end
 
-  def tickCallback(timeStep)
-#    print "tickCallback: ", timeStep * 1000, "ms\n"
+  def tick_callback(timeStep)
+#    print "tick_callback: ", timeStep * 1000, "ms\n"
   end
 end
 

data/lib/teien/physics_object.rb

@@ -0,0 +1,57 @@
+module Teien
+
+class PhysicsObject
+  # Bullet accessor
+  attr_accessor :rigid_body # shows the center of this object.
+  attr_accessor :transform
+  attr_accessor :pivot_shape
+  attr_accessor :shape
+  attr_accessor :acceleration
+  attr_accessor :maxHorizontalVelocity
+  attr_accessor :maxVerticalVelocity
+
+  def initialize(physics)
+    @physics = physics
+    @rigid_body = nil
+    @transform = Bullet::BtTransform.new()
+    @transform.set_identity()
+    @acceleration = Vector3D.new(0, 0, 0)
+
+    @maxHorizontalVelocity = 0
+    @maxVerticalVelocity = 0
+  end
+
+  def finalize()
+    @physics.del_rigid_body(@rigid_body)
+  end
+
+  #
+  # The offset changes the local position of the shape(collision shape) in Object.
+  #
+  def set_rigid_body(obj, 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 = @physics.create_rigid_body(obj.physics_info.mass, obj, @pivot_shape, inertia)
+    @rigid_body = create_rigid_body(obj.physics_info.mass, obj, @pivot_shape, inertia)
+    @rigid_body.set_angular_factor(obj.physics_info.angular_factor)
+    @rigid_body.set_restitution(obj.physics_info.restitution)
+    @rigid_body.set_friction(obj.physics_info.friction)
+    @rigid_body.set_damping(obj.physics_info.linear_damping, 
+                            obj.physics_info.angular_damping)
+    return @rigid_body
+  end
+
+  def create_rigid_body(mass, motionState, colObj, inertia)
+    rigid_body = Bullet::BtRigidBody.new(mass, motionState, colObj, inertia)
+    rigid_body.instance_variable_set(:@collision_shape, colObj) # prevent this colObj from GC.
+    return rigid_body
+  end
+
+end
+
+end

data/lib/teien/physics_object_factory.rb

@@ -0,0 +1,170 @@
+require 'teien/garden_object'
+
+module Teien
+
+class PhysicsObjectFactory
+  def initialize(physics)
+    @physics = physics
+  end
+
+  def create_object(obj)
+    case obj.object_info
+    when LightObjectInfo
+      return create_light_object(obj)
+    when FloorObjectInfo
+      return create_floor_object(obj)
+    when BoxObjectInfo
+      return create_box_object(obj)
+    when SphereObjectInfo
+      return create_sphere_object(obj)
+    when CapsuleObjectInfo
+      return create_capsule_object(obj)
+    when ConeObjectInfo
+      return create_cone_object(obj)
+    when CylinderObjectInfo
+      return create_cylinder_object(obj)
+    when MeshBBObjectInfo
+      return create_meshBB_object(obj)
+    when MeshObjectInfo
+      return create_mesh_object(obj)
+    else
+      puts "Error: passed no supported object_info."
+      return nil
+    end
+  end
+
+  def create_light_object(obj)
+    physics_object = PhysicsObject.new(@physics)
+    cShape = Bullet::BtSphereShape.new(0.1)
+    inertia = Bullet::BtVector3.new()
+    cShape.calculate_local_inertia(0, inertia)
+    physics_object.set_rigid_body(obj, cShape, inertia)
+    return physics_object
+  end
+
+  #
+  # Floor Object
+  #
+
+  # Setting a collision shape and a rigid body of Bullet.
+  def create_floor_object(obj)
+    physics_object = PhysicsObject.new(@physics)
+    cShape = Bullet::BtBoxShape.new(Vector3D.new(obj.object_info.width, 
+                                                 obj.object_info.depth, 
+                                                 obj.object_info.height))
+    physics_object.set_rigid_body(obj, cShape, 
+                                  Vector3D.new(0, 0, 0), 
+                                  Vector3D.new(0.0, -obj.object_info.depth, 0.0))
+    return physics_object
+  end
+
+  #
+  # Box Object
+  #
+
+  def create_box_object(obj)
+    physics_object = PhysicsObject.new(@physics)
+    cShape = Bullet::BtBoxShape.new(Vector3D.new(obj.object_info.size.x, 
+                                                 obj.object_info.size.y, 
+                                                 obj.object_info.size.z))
+    inertia = Bullet::BtVector3.new()
+    cShape.calculate_local_inertia(obj.physics_info.mass, inertia)
+    physics_object.set_rigid_body(obj, cShape, inertia)
+    return physics_object
+  end
+
+  # 
+  # Sphere Object
+  #
+
+  def create_sphere_object(obj)
+    physics_object = PhysicsObject.new(@physics)
+    cShape = Bullet::BtSphereShape.new(obj.object_info.radius)
+    inertia = Bullet::BtVector3.new()
+    cShape.calculate_local_inertia(obj.physics_info.mass, inertia)
+    physics_object.set_rigid_body(obj, cShape, inertia)
+    return physics_object
+  end
+
+  #
+  # Capsule Object
+  #
+
+  def create_capsule_object(obj)
+    physics_object = PhysicsObject.new(@physics)
+    cShape = Bullet::BtCapsuleShape.new(obj.object_info.radius, 
+                                        obj.object_info.height)
+    inertia = Bullet::BtVector3.new()
+    cShape.calculate_local_inertia(obj.physics_info.mass, inertia)
+    physics_object.set_rigid_body(obj, cShape, inertia)
+    return physics_object
+  end
+
+  #
+  # Cone Object
+  #
+
+  def create_cone_object(obj)
+    physics_object = PhysicsObject.new(@physics)
+    cShape = Bullet::BtConeShape.new(obj.object_info.radius, obj.object_info.height)
+    inertia = Bullet::BtVector3.new()
+    cShape.calculate_local_inertia(obj.physics_info.mass, inertia)
+    physics_object.set_rigid_body(obj, cShape, inertia, 
+                                  Vector3D.new(0, obj.object_info.height / 2, 0))
+    return physics_object
+  end
+
+  #
+  # Cylinder Object
+  #
+
+  def create_cylinder_object(obj)
+    physics_object = PhysicsObject.new(@physics)
+    cShape = Bullet::BtCylinderShape.new(Bullet::BtVector3.new(obj.object_info.radius, 
+                                                               obj.object_info.height / 2, 
+                                                               obj.object_info.radius))
+    inertia = Bullet::BtVector3.new()
+    cShape.calculate_local_inertia(obj.physics_info.mass, inertia)
+    physics_object.set_rigid_body(obj, cShape, inertia)
+    return physics_object
+  end
+
+  #
+  # MeshBB Object
+  #
+
+  def create_meshBB_object(obj)
+    physics_object = PhysicsObject.new(@physics)
+    cShape = Bullet::BtBoxShape.new(obj.object_info.size)
+    inertia = Bullet::BtVector3.new()
+    cShape.calculate_local_inertia(obj.physics_info.mass, inertia)
+    physics_object.set_rigid_body(obj, cShape, inertia, obj.object_info.physics_offset)
+    return physics_object
+  end
+
+  #
+  # Mesh Object
+  #
+
+  # This method needs the obj.entity to create a collision shape. 
+  # So it's not support to use this method on server(physics only) currently.
+  def add_mesh_object(obj)
+    physics_object = PhysicsObject.new(@physics)
+    strider = Teienlib::MeshStrider.new(obj.entity.get_mesh().get())
+    cShape = Bullet::BtGImpactMeshShape.new(strider)
+    cShape.set_local_scaling(Bullet::BtVector3.new(obj.object_info.scale.x, 
+                                                   obj.object_info.scale.y, 
+                                                   obj.object_info.scale.z))
+    cShape.instance_variable_set(:@strider, strider) # prevent this from GC.
+    cShape.post_update()
+    cShape.update_bound()
+    inertia = Bullet::BtVector3.new()
+    cShape.calculate_local_inertia(obj.physics_info.mass, inertia)
+    physics_object.set_rigid_body(obj, cShape, inertia, 
+                                  obj.object_info.physics_offset)
+    return physics_object
+  end
+end
+
+
+end

data/lib/teien/proxy_garden.rb

@@ -0,0 +1,118 @@
+require "teien/garden_base.rb"
+
+module Teien
+
+class ProxyGarden < GardenBase
+  attr_accessor :view
+  attr_accessor :ui
+
+  def initialize()
+    super
+  end
+
+  def set_window_title(title)
+    @view.window_title = title
+  end
+
+  #
+  # mainloop
+  #
+  def run(ip = nil, port = 11922)
+    return false unless setup()
+
+    EM.run do
+      EM.add_periodic_timer(0.001) do
+        @last_time = Time.now.to_f if @last_time == 0
+
+        now_time = Time.now.to_f
+        delta = now_time - @last_time
+        @last_time = now_time
+
+        unless update(delta)
+          EM.stop
+          self.finalize()
+        end
+      end
+
+      Signal.trap("INT")  { EM.stop; self.finalize() }
+      Signal.trap("TERM") { EM.stop; self.finalize() }
+
+      if (ip)
+        EM.connect(ip, port, Network, self)
+      end
+    end
+  end    
+
+  def setup()
+    @physics.setup(self)
+    notify(:setup, self)
+    return true
+  end
+
+  def update(delta)
+    @physics.update(delta)
+    @actors.each_value {|actor|
+      actor.update(delta)
+    }
+    notify(:update, delta)
+    return !@quit
+  end
+
+  def receive_event(event, from)
+    case event
+    when Event::SyncEnv
+#      puts "SyncEnv"
+      set_gravity(event.gravity)
+      set_ambient_light(event.ambient_light_color)
+      set_sky_dome(event.sky_dome.enable, event.sky_dome.materialName)
+    when Event::SyncObject
+      if @objects[event.name]
+#        puts "sync"
+        sync_object_with_event(event, @objects[event.name])
+      else
+#        puts "add"
+        create_object_from_event(event)
+      end
+
+    end
+    notify(:receive_event, event, from)    
+  end
+
+  def send_event(event, to = nil)
+    if (to)
+      to.send_object(event)
+    else
+      Network::send_all(event)
+    end
+  end
+
+  def create_object_from_event(event)
+    obj = create_object(event.name, event.object_info, event.physics_info)
+    obj.set_position(event.pos)
+    obj.set_linear_velocity(event.linear_vel)
+    obj.set_angular_velocity(event.angular_vel)
+    obj.set_rotation(event.quat)
+    obj.set_acceleration(event.accel)
+#    obj.animation_info = event.animation_info
+  end
+
+  def sync_object_with_event(event, obj)
+    obj.set_position_with_interpolation(event.pos)
+    obj.set_linear_velocity(event.linear_vel)
+#    obj.set_linear_velocity_with_interpolation(event.linear_vel)
+#    obj.set_angular_velocity(event.angular_vel)
+    obj.set_angular_velocity_with_interpolation(event.angular_vel)
+    obj.set_rotation(event.quat)
+    obj.set_acceleration(event.accel)
+ #   obj.animation_info = event.animation_info
+  end
+
+  # called by Garden class.
+  # clear all managers.
+  def finalize()
+    @physics.finalize()
+    @objects = {}
+  end
+end
+
+end

data/lib/teien/remote_info.rb

@@ -0,0 +1,20 @@
+module Teien
+
+class RemoteInfo
+  @@total_cnt = 0
+  attr_accessor :id
+  attr_accessor :ip
+  attr_accessor :port
+  attr_accessor :connection
+
+  def initialize(con)
+    @ip = nil
+    @port = 0
+    @port, @ip = Socket.unpack_sockaddr_in(con.get_peername) if con.get_peername
+    @connection = con
+    @id = @@total_cnt
+    @@total_cnt += 1
+  end
+end
+
+end

data/lib/teien/sky_dome.rb

@@ -0,0 +1,15 @@
+class SkyDome
+  attr_accessor :enable
+  attr_accessor :materialName
+  attr_accessor :curvature
+  attr_accessor :tiling
+  attr_accessor :distance
+
+  def initialize(enable, materialName, curvature = 10, tiling = 8, distance = 4000)
+    @enable = enable
+    @materialName = materialName
+    @curvature = curvature
+    @tiling = tiling
+    @distance = distance
+  end
+end

data/lib/teien/smooth_mover.rb

@@ -3,22 +3,18 @@ class SmoothMover
   TURN_SPEED = 500.0
 
   attr_accessor :acceleration
-  attr_accessor :turnSpeed
+  attr_accessor :turn_speed
   attr_accessor :movable
 
-  def initialize(targetObject)
-    @targetObject = targetObject
-
+  def initialize(target_object)
+    @target_object = target_object
     @acceleration = ACCELERATION
-    @turnSpeed = TURN_SPEED
-
-    clearAction()
-
+    @turn_speed = TURN_SPEED
+    @move_dir = Ogre::Vector3.new(0, 0, 0)
+    @forward_dir = Ogre::Vector3.new(0, 0, 0)
+    @zero_vector = Vector3D.new(0, 0, 0)
+    clear_action()
     @movable = true
-
-    @zeroVector = Bullet::BtVector3.new(0, 0, 0)
-    @moveDir = Ogre::Vector3.new(0, 0, 0)
-    @cameraDir = Ogre::Vector3.new(0, 0, 0)
   end
 
   def clear_action()
@@ -28,10 +24,17 @@ class SmoothMover
     @right = false
   end
 
-  def is_move()
+  def moving?()
     return (@forward || @backward || @left || @right)
   end
 
+  #
+  # This direction is the forward.
+  #
+  def set_forward_direction(forward_dir)
+    @forward_dir = forward_dir
+  end
+
   def move_forward(bool)
     @forward = bool
   end
@@ -48,61 +51,47 @@ class SmoothMover
     @right = bool
   end
 
-  #
-  # This direction is the forward.
-  #
-  def move_camera_direction(cameraDir)
-    @cameraDir = cameraDir
-  end
 
   def update_target(delta)
-    @moveDir.x = 0
-    @moveDir.y = 0
-    @moveDir.z = 0
+    @move_dir.x = 0
+    @move_dir.y = 0
+    @move_dir.z = 0
 
     # update target's acceleration
     if (@forward)
-      @moveDir += Ogre::Vector3.new(@cameraDir.x, @cameraDir.y, @cameraDir.z)
+      @move_dir += Ogre::Vector3.new(@forward_dir.x, @forward_dir.y, @forward_dir.z)
     end
     if (@backward)
-      @moveDir += Ogre::Vector3.new(-@cameraDir.x, -@cameraDir.y, -@cameraDir.z)
+      @move_dir += Ogre::Vector3.new(-@forward_dir.x, -@forward_dir.y, -@forward_dir.z)
     end
     if (@left)
-      @moveDir += Ogre::Vector3.new(@cameraDir.z, 0,  -@cameraDir.x)
+      @move_dir += Ogre::Vector3.new(@forward_dir.z, 0,  -@forward_dir.x)
     end
     if (@right)
-      @moveDir += Ogre::Vector3.new(-@cameraDir.z, 0, @cameraDir.x)
+      @move_dir += Ogre::Vector3.new(-@forward_dir.z, 0, @forward_dir.x)
     end
 
-    @moveDir.y = 0
-    @moveDir.normalise()
+    @move_dir.y = 0
+    @move_dir.normalise()
 
     if (@movable)
-      newAcc = @moveDir * @acceleration
-      @targetObject.set_acceleration(Vector3D::to_bullet(newAcc))
+      newAcc = @move_dir * @acceleration
+      @target_object.set_acceleration(Vector3D.to_self(newAcc))
     else
-      @targetObject.set_acceleration(@zeroVector)
+      @target_object.set_acceleration(@zero_vector)
     end
 
     # update target's direction
-=begin
-    ogreDir = -@targetObject.pivotSceneNode.getOrientation().zAxis()
-    bulletDir = -@targetObject.getOrientation().zAxis()
-    puts "OgreDir: (#{ogreDir.x}, #{ogreDir.y}, #{ogreDir.z})"
-    puts "BulletDir: (#{bulletDir.x}, #{bulletDir.y}, #{bulletDir.z})"
-=end
-
-    toGoal = Vector3D.to_ogre(-@targetObject.get_orientation().z_axis()).get_rotation_to(@moveDir)
+    toGoal = Vector3D.to_ogre(-@target_object.get_orientation().z_axis()).get_rotation_to(@move_dir)
     yawToGoal = toGoal.get_yaw().value_degrees()
-    yawAtSpeed = yawToGoal / yawToGoal.abs * delta * @turnSpeed
+    yawAtSpeed = yawToGoal / yawToGoal.abs * delta * @turn_speed
 
     if (yawToGoal < 0) 
       yawToGoal = [0, [yawToGoal, yawAtSpeed].max].min
-
     elsif (yawToGoal > 0) 
       yawToGoal = [0, [yawToGoal, yawAtSpeed].min].max
     end
 
-    @targetObject.yaw(Ogre::Degree.new(yawToGoal).value_radians())
+    @target_object.yaw(Ogre::Degree.new(yawToGoal).value_radians())
   end
 end

data/lib/teien/synchronizer.rb

@@ -0,0 +1,26 @@
+module Teien
+
+class Synchronizer
+  def initialize(garden, sync_period)
+    @garden = garden
+    @garden.register_receiver(self)
+    @sync_period = sync_period
+    @sync_timer = sync_period
+  end
+
+  def setup(garden)
+  end
+
+  def update(delta)
+    @sync_timer += delta
+    if (@sync_timer > @sync_period)
+      @garden.notify_objects()
+      @sync_timer = 0
+    end
+  end
+
+  def add_actor(actor)
+  end
+end
+
+end