teien 0.0.1

data/lib/teien/object_info.rb

@@ -0,0 +1,171 @@
+module Teien
+
+class MeshBBObjectInfo 
+  attr_accessor :mesh_path
+  attr_accessor :size          # Loading mesh only: bounding box size
+  attr_accessor :scale         # Loading mesh only: scales mesh
+  attr_accessor :view_offset    # Loading mesh only: offset of Mesh
+  attr_accessor :view_rotation  # Loading mesh only: rotation offset of Mesh
+  attr_accessor :physics_offset # Loading mesh only: offset of collision Box 
+  attr_accessor :material_name
+
+  def initialize(mesh_path, size, scale = Vector3D.new(1, 1, 1),
+                 view_offset = Vector3D.new(0, 0, 0),
+                 view_rotation = Quaternion.new(0, 0, 0, 1.0),
+                 physics_offset = Vector3D.new(0, 0, 0))
+    @size = size
+    @mesh_path = mesh_path
+    @scale = scale
+    @view_offset = view_offset
+    @view_rotation = view_rotation
+    @physics_offset = physics_offset
+    @material_name = nil
+  end
+end
+
+class MeshObjectInfo 
+  attr_accessor :mesh_path
+  attr_accessor :scale         # Loading mesh only: scales mesh
+  attr_accessor :view_offset    # Loading mesh only: offset of Mesh
+  attr_accessor :view_rotation  # Loading mesh only: rotation offset of Mesh
+  attr_accessor :physics_offset # Loading mesh only: offset of collision Box 
+  attr_accessor :material_name
+
+  def initialize(mesh_path, scale = Vector3D.new(1, 1, 1),
+                 view_offset = Vector3D.new(0, 0, 0),
+                 view_rotation = Quaternion.new(0, 0, 0, 1.0),
+                 physics_offset = Vector3D.new(0, 0, 0))
+    @mesh_path = mesh_path
+    @scale = scale
+    @view_offset = view_offset
+    @view_rotation = view_rotation
+    @physics_offset = physics_offset
+    @material_name = nil
+  end
+end
+
+class FloorObjectInfo
+  attr_accessor :width
+  attr_accessor :height
+  attr_accessor :depth
+  attr_accessor :num_seg_x
+  attr_accessor :num_seg_y
+  attr_accessor :u_tile
+  attr_accessor :v_tile
+  attr_accessor :material_name
+
+  def initialize(width, height, depth = 0.5, num_seg_x = 1, num_seg_y = 1, u_tile = 1.0, v_tile = 1.0)
+    @width   = width
+    @height  = height
+    @depth   = depth
+    @num_seg_x = num_seg_x
+    @num_seg_y = num_seg_y
+    @u_tile   = u_tile
+    @v_tile   = v_tile
+    @material_name = nil
+  end
+end
+
+class BoxObjectInfo
+  attr_accessor :size
+  attr_accessor :num_seg_x
+  attr_accessor :num_seg_y
+  attr_accessor :num_seg_z
+  attr_accessor :u_tile
+  attr_accessor :v_tile
+  attr_accessor :material_name
+
+  def initialize(size, num_seg_x = 1, num_seg_y = 1, num_seg_z = 1, u_tile = 1.0, v_tile = 1.0)
+    @size = size
+    @num_seg_x = num_seg_x
+    @num_seg_y = num_seg_y
+    @num_seg_z = num_seg_z
+    @u_tile   = u_tile
+    @v_tile   = v_tile
+    @material_name = nil
+  end
+end
+
+class SphereObjectInfo
+  attr_accessor :radius
+  attr_accessor :num_rings
+  attr_accessor :num_segments
+  attr_accessor :u_tile
+  attr_accessor :v_tile
+  attr_accessor :material_name
+
+  def initialize(radius, num_rings = 16, num_segments = 16, u_tile = 1.0, v_tile = 1.0)
+    @radius = radius
+    @num_rings = num_rings
+    @num_segments = num_segments
+    @u_tile = u_tile
+    @v_tile = v_tile
+    @material_name = nil
+  end
+end
+
+class CapsuleObjectInfo
+  attr_accessor :radius
+  attr_accessor :height
+  attr_accessor :num_rings
+  attr_accessor :num_segments
+  attr_accessor :num_seg_height
+  attr_accessor :u_tile
+  attr_accessor :v_tile
+  attr_accessor :material_name
+
+  def initialize(radius, height, num_rings = 8, num_segments = 16, num_seg_height = 1, u_tile = 1.0, v_tile = 1.0)
+    @radius = radius
+    @height = height
+    @num_rings = num_rings
+    @num_segments = num_segments
+    @num_seg_height = num_seg_height
+    @u_tile = u_tile
+    @v_tile = v_tile
+    @material_name = nil
+  end
+end
+
+class ConeObjectInfo
+  attr_accessor :radius
+  attr_accessor :height
+  attr_accessor :num_seg_base
+  attr_accessor :num_seg_height
+  attr_accessor :u_tile
+  attr_accessor :v_tile
+  attr_accessor :material_name
+
+  def initialize(radius, height, num_seg_base = 16, num_seg_height = 1, u_tile = 1.0, v_tile = 1.0)
+    @radius = radius
+    @height = height
+    @num_seg_base = num_seg_base
+    @num_seg_height = num_seg_height
+    @u_tile = u_tile
+    @v_tile = v_tile
+    @material_name = nil
+  end
+end
+
+class CylinderObjectInfo
+  attr_accessor :radius
+  attr_accessor :height
+  attr_accessor :capped
+  attr_accessor :num_seg_base
+  attr_accessor :num_seg_height
+  attr_accessor :u_tile
+  attr_accessor :v_tile
+  attr_accessor :material_name
+
+  def initialize(radius, height, capped = true, num_seg_base = 16, num_seg_height = 1, u_tile = 1.0, v_tile = 1.0)
+    @radius = radius
+    @height = height
+    @capped = capped
+    @num_seg_base = num_seg_base
+    @num_seg_height = num_seg_height
+    @u_tile = u_tile
+    @v_tile = v_tile
+    @material_name = nil
+  end
+end
+
+end

data/lib/teien/physics.rb

@@ -0,0 +1,150 @@
+module Teien
+
+CollisionFilter = Struct.new(:group, :mask)
+
+class ContactResult < Bullet::ContactResultCallback
+  def initialize
+    super
+    @isCollided = false
+  end
+
+  def collided?
+    return @isCollided
+  end
+
+  def addSingleResult(cp, 
+                      colObj0, partId0, index0,
+                      colObj1, partId1, index1)
+    @isCollided = true
+    return 0
+  end
+end
+
+
+class Physics < Bullet::TickListener
+  attr_accessor :dynamics_world
+  attr_accessor :max_sub_steps
+  attr_accessor :fixed_time_step
+#  attr_accessor :softBodyWorldInfo
+
+  def initialize(garden)
+    super()
+    @garden = garden
+
+    @max_sub_steps = 1
+    @fixed_time_step = 1.0 / 60.0
+
+    @rigid_bodies = []
+  end
+
+  def setup
+    @collision_config = Bullet::BtDefaultCollisionConfiguration.new();
+    @collision_dispatcher = Bullet::BtCollisionDispatcher.new(@collision_config)
+
+    worldAabbMin = Bullet::BtVector3.new(-3000.0,-500.0, -3000.0)
+    worldAabbMax = Bullet::BtVector3.new(3000.0, 500.0, 3000.0)
+    maxProxies = 1024 * 4
+    @aabb_cache = Bullet::BtAxisSweep3.new( worldAabbMin, worldAabbMax, maxProxies )
+
+    @solver = Bullet::BtSequentialImpulseConstraintSolver.new();
+
+    @dynamics_world = Bullet::BtDiscreteDynamicsWorld.new(@collision_dispatcher, @aabb_cache,
+                                                          @solver, @collision_config)
+    gravity = Bullet::BtVector3.new(0.0, -9.8, 0.0)
+    @dynamics_world.setGravity(gravity)
+
+    @dynamics_world.setInternalTickCallback(self, true);     
+    @dynamics_world.setInternalTickCallback(self, false);     
+=begin
+    worldAabbCache->getOverlappingPairCache()->setInternalGhostPairCallback(new btGhostPairCallback());
+=end    
+=begin
+    @softBodyWorldInfo = Bullet::BtSoftBodyWorldInfo.new
+    softBodyWorldInfo.m_dispatcher = @collisionDispatcher
+    softBodyWorldInfo.m_broadphase = @gardenAabbCache
+    softBodyWorldInfo.m_gravity.setValue(0, -9.8, 0)
+#    softBodyWorldInfo.m_sparsesdf.Initialize();
+=end
+  end
+
+  def finalize
+    # clear all objects.
+    @rigid_bodies.each{|body|
+      @dynamics_world.removeRigidBody(body)
+    }
+    @rigid_bodies = []
+
+#    @dynamics_world.finalize()
+  end
+
+  def update(delta)
+    @dynamics_world.stepSimulation(delta, @max_sub_steps, @fixed_time_step)
+    return true
+  end
+
+  def frameRenderingQueued(evt)
+#    print "Physics::tick: ", evt.timeSinceLastFrame * 1000, "ms\n"
+    @dynamics_world.stepSimulation(evt.timeSinceLastFrame, @max_sub_steps, @fixed_time_step)
+    return true
+  end
+
+  def flush_pair_cache(rigid_body)
+    pair_cache = @dynamics_world.getBroadphase().getOverlappingPairCache()
+    pair_cache.removeOverlappingPairsContainingProxy(rigid_body.getBroadphaseHandle(), 
+                                                     @dynamics_world.getDispatcher())
+  end
+
+  def set_gravity(vec)
+    @dynamics_world.setGravity(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.addRigidBody(rigid_body, collision_filter.group, collision_filter.mask)
+    else
+      @dynamics_world.addRigidBody(rigid_body)
+    end
+  end
+
+  def contact_pair_test(colObjA, colObjB)
+    result = ContactResult.new
+    @dynamics_world.contactPairTest(colObjA, colObjB, result)
+    return result
+  end
+
+  def preTickCallback(timeStep)
+#    print "preTickCallback: ", 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
+        obj.set_linear_velocity(obj.limit_velocity(newVel))
+        lastVel = obj.get_linear_velocity()
+      end
+    }
+  end
+
+  def tickCallback(timeStep)
+#    print "tickCallback: ", timeStep * 1000, "ms\n"
+  end
+end
+
+end

data/lib/teien/physics_info.rb

@@ -0,0 +1,23 @@
+module Teien
+
+class PhysicsInfo
+  attr_accessor :mass
+  attr_accessor :angular_factor # rotate along Y axis if 1.0
+  attr_accessor :friction      
+  attr_accessor :restitution   
+  attr_accessor :linear_damping
+  attr_accessor :angular_damping
+  attr_accessor :collision_filter
+
+  def initialize(mass = 1.0)
+    @mass = mass
+    @angular_factor = 1.0
+    @restitution = 0.2
+    @friction = 1.0
+    @linear_damping = 0.0
+    @angular_damping = 0.0
+    @collision_filter = nil
+  end
+end
+
+end

data/lib/teien/smooth_mover.rb

@@ -0,0 +1,108 @@
+class SmoothMover
+  ACCELERATION = 5.0
+  TURN_SPEED = 500.0
+
+  attr_accessor :acceleration
+  attr_accessor :turnSpeed
+  attr_accessor :movable
+
+  def initialize(targetObject)
+    @targetObject = targetObject
+
+    @acceleration = ACCELERATION
+    @turnSpeed = TURN_SPEED
+
+    clearAction()
+
+    @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 clearAction()
+    @forward = false
+    @backward = false
+    @left = false
+    @right = false
+  end
+
+  def isMove()
+    return (@forward || @backward || @left || @right)
+  end
+
+  def moveForward(bool)
+    @forward = bool
+  end
+
+  def moveBackward(bool)
+    @backward = bool
+  end
+
+  def moveLeft(bool)
+    @left = bool
+  end
+
+  def moveRight(bool)
+    @right = bool
+  end
+
+  #
+  # This direction is the forward.
+  #
+  def moveCameraDirection(cameraDir)
+    @cameraDir = cameraDir
+  end
+
+  def updateTarget(delta)
+    @moveDir.x = 0
+    @moveDir.y = 0
+    @moveDir.z = 0
+
+    # update target's acceleration
+    if (@forward)
+      @moveDir += Ogre::Vector3.new(@cameraDir.x, @cameraDir.y, @cameraDir.z)
+    end
+    if (@backward)
+      @moveDir += Ogre::Vector3.new(-@cameraDir.x, -@cameraDir.y, -@cameraDir.z)
+    end
+    if (@left)
+      @moveDir += Ogre::Vector3.new(@cameraDir.z, 0,  -@cameraDir.x)
+    end
+    if (@right)
+      @moveDir += Ogre::Vector3.new(-@cameraDir.z, 0, @cameraDir.x)
+    end
+
+    @moveDir.y = 0
+    @moveDir.normalise()
+
+    if (@movable)
+      newAcc = @moveDir * @acceleration
+      @targetObject.setAcceleration(Vector3D::to_bullet(newAcc))
+    else
+      @targetObject.setAcceleration(@zeroVector)
+    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.getOrientation().zAxis()).getRotationTo(@moveDir)
+    yawToGoal = toGoal.getYaw().valueDegrees()
+    yawAtSpeed = yawToGoal / yawToGoal.abs * delta * @turnSpeed
+
+    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).valueRadians())
+  end
+end

data/lib/teien/tools.rb

@@ -0,0 +1,261 @@
+require 'matrix'
+
+# deep copy
+def deep_copy(object)
+  return Marshal.load(Marshal.dump(object))
+end
+
+module Teien
+
+#
+# 2d vector
+#
+class Vector2D
+  attr_accessor :x
+  attr_accessor :y
+  def initialize(x = 0.0, y = 0.0)
+    set(x, y)
+  end
+
+  def set(x, y)
+    @x = x
+    @y = y
+  end
+
+  def ==(o)
+    if o.is_a?(Vector2D)
+      return @x == o.x && @y == o.y
+    else
+      return false
+    end
+  end
+end
+
+#
+# 3d vector
+#
+class Vector3D < Bullet::BtVector3
+  def self.to_ogre(bullet)
+    return Ogre::Vector3.new(bullet.x, bullet.y, bullet.z)
+  end
+
+  def self.to_bullet(ogre)
+    return Bullet::BtVector3.new(ogre.x, ogre.y, ogre.z)
+  end
+
+  def self.to_self(vec)
+    return Vector3D.new(vec.x, vec.y, vec.z)
+  end
+
+  def self.to_s(vec)
+    return sprintf("(%f, %f, %f)", vec.x, vec.y, vec.z)
+  end
+
+  def copy(vec)
+    setValue(vec.x, vec.y, vec.z)
+  end
+end
+
+
+class Quaternion < Bullet::BtQuaternion
+  def self.to_ogre(bullet)
+    return Ogre::Quaternion.new(bullet.w, bullet.x, bullet.y, bullet.z)
+  end
+
+  def self.to_bullet(ogre)
+    return Bullet::BtQuaternion.new(ogre.x, ogre.y, ogre.z, ogre.w)
+  end
+
+  def self.to_self(qt)
+    return Quaternion.new(qt.x, qt.y, qt.z, qt.w)
+  end
+
+  def self.to_s(qt)
+    return sprintf("(%f, %f, %f, %f)", qt.x, qt.y, qt.z, qt.w)
+  end
+
+  def copy(qt)
+    setValue(qt.x, qt.y, qt.z, qt.w)
+  end
+
+end
+
+class Color < Ogre::ColourValue
+end
+
+class Radian < Ogre::Radian
+end
+
+class Degree < Ogre::Degree
+end
+
+
+
+
+=begin
+class Vector3D
+  attr_accessor :x
+  attr_accessor :y
+  attr_accessor :z
+  def initialize(x = 0.0, y = 0.0, z = 0.0)
+    set(x, y, z)
+  end
+
+  def set(x, y, z)
+    @x = x
+    @y = y
+    @z = z
+  end
+
+  def copy(vec)
+    set(vec.x, vec.y, vec.z)
+  end
+
+  def +(pt)
+    return Vector3D.new(@x + pt.x, @y + pt.y, @z + pt.z)
+  end
+
+  def -(pt)
+    return Vector3D.new(@x - pt.x, @y - pt.y, @z - pt.z)
+  end
+
+  def -@
+    return Vector3D.new(-@x, -@y, -@z)
+  end
+
+  def *(f)
+    if (f.class == Vector3D)
+      return Vector3D.new(@x * f.x, @y * f.y, @z * f.z)
+    else
+      return Vector3D.new(@x * f, @y * f, @z * f)
+    end
+  end
+
+  def /(f)
+    if (f.class == Vector3D)
+      return Vector3D.new(@x / f.x, @y / f.y, @z / f.z)
+    else
+      return Vector3D.new(@x / f, @y / f, @z / f)
+    end
+  end
+
+  def ==(pt)
+    return (((@x - pt.x).abs <= Float::EPSILON * [@x.abs, pt.x.abs].max) && 
+            ((@y - pt.y).abs <= Float::EPSILON * [@y.abs, pt.y.abs].max) && 
+            ((@z - pt.z).abs <= Float::EPSILON * [@z.abs, pt.z.abs].max))
+  end
+
+  def nearTo(pt)
+    return (((@x - pt.x).abs <= 0.000001) && 
+            ((@y - pt.y).abs <= 0.000001) && 
+            ((@z - pt.z).abs <= 0.000001))
+  end
+
+  def dot(pt)
+    return (@x * pt.x + @y * pt.y + @z * pt.z)
+  end
+
+  def len()
+    return Math.sqrt(@x * @x + @y * @y + @z * @z)
+  end
+
+  def lenSquared()
+    return @x * @x + @y * @y + @z * @z
+  end
+
+
+  def normalize(newLen = 1.0) 
+    l = len();
+    if (l == 0)
+      @x = 0
+      @y = 0
+      @z = 0
+      return false
+    else
+      l = newLen / l
+      @x *= l
+      @y *= l
+      @z *= l
+      return true
+    end
+  end
+
+  def toString
+    return sprintf("(%f, %f, %f)", @x, @y, @z)
+  end
+end
+=end
+
+
+#
+# Now constructing =)
+# It's only data.
+#
+
+#class Quaternion < Bullet::BtQuaternion
+#end
+
+=begin
+class Quaternion
+  attr_accessor :x
+  attr_accessor :y
+  attr_accessor :z
+  attr_accessor :w
+  def initialize(x = 0.0, y = 0.0, z = 0.0, w = 0.0)
+    set(x, y, z, w)
+  end
+
+  def set(x, y, z, w)
+    @x = x
+    @y = y
+    @z = z
+    @w = w
+  end
+
+  def setYPR(yaw, pitch, roll)
+    halfYaw = yaw * 0.5;  
+    halfPitch = pitch * 0.5;  
+    halfRoll = roll * 0.5;  
+    cosYaw = Math::cos(halfYaw);
+    sinYaw = Math::sin(halfYaw);
+    cosPitch = Math::cos(halfPitch);
+    sinPitch = Math::sin(halfPitch);
+    cosRoll = Math::cos(halfRoll);
+    sinRoll = Math::sin(halfRoll);
+                
+    @x = cosRoll * sinPitch * cosYaw + sinRoll * cosPitch * sinYaw;
+    @y = cosRoll * cosPitch * sinYaw - sinRoll * sinPitch * cosYaw;
+    @z = sinRoll * cosPitch * cosYaw - cosRoll * sinPitch * sinYaw;
+    @w = cosRoll * cosPitch * cosYaw + sinRoll * sinPitch * sinYaw;
+
+    return self
+  end
+
+  def copy(quat)
+    set(quat.x, quat.y, quat.z, quat.w)
+  end
+
+  def +(pt)
+    return Quaternion.new(@x + pt.x, @y + pt.y, @z + pt.z, @w + pt.w);
+  end
+
+  def -(pt)
+    return Quaternion.new(@x - pt.x, @y - pt.y, @z - pt.z, @w - pt.w);
+  end
+
+  def *(f)
+      return Quaternion.new(@x * f, @y * f, @z * f, @w * f)
+  end
+
+  def dot(pt)
+    return (@x * pt.x + @y * pt.y + @z * pt.z + @w * pt.w);
+  end
+
+  def len()
+    return Math.sqrt(dot(self))
+  end
+
+end
+=end
+
+end # module