teien 0.0.1 → 0.0.2

data/lib/teien/garden_object.rb

@@ -41,7 +41,7 @@ class GardenObject < Bullet::BtMotionState
 
     @rigid_body = nil
     @transform = Bullet::BtTransform.new()
-    @transform.setIdentity()
+    @transform.set_identity()
     @acceleration = Vector3D.new(0, 0, 0)
 
     @maxHorizontalVelocity = 0
@@ -53,12 +53,12 @@ class GardenObject < Bullet::BtMotionState
   #
   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.getRootSceneNode().createChildSceneNode()
+      @pivot_scene_node = @garden.view.scene_mgr.get_root_scene_node().create_child_scene_node()
     end
-    @scene_node = @pivot_scene_node.createChildSceneNode(Vector3D.to_ogre(offset), Quaternion.to_ogre(rotate))
+    @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.attachObject(entity)
+      @scene_node.attach_object(entity)
       @entity = entity
     end
     return @scene_node
@@ -71,9 +71,9 @@ class GardenObject < Bullet::BtMotionState
 #    puts "offset(#{offset.x}, #{offset.y}, #{offset.z})"
     @pivot_shape = Bullet::BtCompoundShape.new
     localTrans = Bullet::BtTransform.new
-    localTrans.setIdentity()
-    localTrans.setOrigin(offset)
-    @pivot_shape.addChildShape(localTrans, shape)
+    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
@@ -83,7 +83,7 @@ class GardenObject < Bullet::BtMotionState
   end
 
   def set_activation_state(state)
-    @rigid_body.setActivationState(state)
+    @rigid_body.set_activation_state(state)
   end
 
 
@@ -92,9 +92,9 @@ class GardenObject < Bullet::BtMotionState
   # ==== Args
   # [aPos: Vector3D] 
   def set_position(aPos)
-    @pivot_scene_node.setPosition(aPos.x, aPos.y, aPos.z) unless @garden.is_server
-    @transform.setOrigin(Bullet::BtVector3.new(aPos.x, aPos.y, aPos.z))
-    @rigid_body.setCenterOfMassTransform(@transform) if (@rigid_body != nil)
+    @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)
   end
 
   # Set a linear velocity.
@@ -103,7 +103,7 @@ class GardenObject < Bullet::BtMotionState
   # [aVel: Vector3D] 
   def set_linear_velocity(aVel)
     @rigid_body.activate(true)
-    @rigid_body.setLinearVelocity(aVel)
+    @rigid_body.set_linear_velocity(aVel)
   end
 
   # Set an angular velocity.
@@ -111,7 +111,7 @@ class GardenObject < Bullet::BtMotionState
   # ==== Args
   # [vel: Vector3D] 
   def set_angular_velocity(vel)
-    @rigid_body.setAngularVelocity(vel)
+    @rigid_body.set_angular_velocity(vel)
   end
 
   # Set a max horizontal velocity.
@@ -136,22 +136,22 @@ class GardenObject < Bullet::BtMotionState
   end
 
   def set_gravity(grav)
-    @rigid_body.setGravity(grav)
+    @rigid_body.set_gravity(grav)
   end
 
   def set_rotation(quad)
-    transform = @rigid_body.getCenterOfMassTransform()
-    transform.setRotation(quad)
-    @rigid_body.setCenterOfMassTransform(transform)
+    transform = @rigid_body.get_center_of_mass_transform()
+    transform.set_rotation(quad)
+    @rigid_body.set_center_of_mass_transform(transform)
   end
 
   def set_collision_filter(filter)
-    @garden.physics.dynamicsWorld.removeRigidBody(@rigid_body)
-    @garden.physics.dynamicsWorld.addRigidBody(@rigid_body, filter.group, filter.mask)
+    @garden.physics.dynamicsWorld.remove_rigid_body(@rigid_body)
+    @garden.physics.dynamicsWorld.add_rigid_body(@rigid_body, filter.group, filter.mask)
     physics_info.collisionFilter = filter
   end
 
-  def setWorldTransform(worldTrans)
+  def set_world_transform(worldTrans)
 #    puts "setWorldTransform"
 
     if (@mode == MODE_FREE)
@@ -159,8 +159,8 @@ class GardenObject < Bullet::BtMotionState
 #    puts "origin(#{pos.x}, #{pos.y}, #{pos.z})"
 
       @transform = Bullet::BtTransform.new(worldTrans)
-      newPos = @transform.getOrigin()
-      newRot = @transform.getRotation()
+      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})"
 
@@ -169,43 +169,43 @@ class GardenObject < Bullet::BtMotionState
       end
 
       unless @garden.is_server
-        @pivot_scene_node.setPosition(newPos.x, newPos.y, newPos.z) 
-        @pivot_scene_node.setOrientation(newRot.w, newRot.x, newRot.y, newRot.z)
+        @pivot_scene_node.set_position(newPos.x, newPos.y, newPos.z) 
+        @pivot_scene_node.set_orientation(newRot.w, newRot.x, newRot.y, newRot.z)
       end
     end
   end
 
-  def getWorldTransform(worldTrans)
+  def get_world_transform(worldTrans)
 #    puts "getWorldTransform"
   end
 
   def get_activation_state()
-    @rigid_body.getActivationState()
+    @rigid_body.get_activation_state()
   end
 
   def get_mass()
-    return 1.0 / @rigid_body.getInvMass()
+    return 1.0 / @rigid_body.get_inv_mass()
   end
 
   def get_inv_mass()
-    return @rigid_body.getInvMass()
+    return @rigid_body.get_inv_mass()
   end
 
   def get_collision_mask()
-    @rigid_body.getBroadphaseHandle().m_collisionFilterMask
+    @rigid_body.get_broadphase_handle().m_collisionFilterMask
   end
 
   def get_position()
-    newPos = @transform.getOrigin()
+    newPos = @transform.get_origin()
     return newPos
   end
 
   def get_linear_velocity()
-    return @rigid_body.getLinearVelocity()
+    return @rigid_body.get_linear_velocity()
   end
 
   def get_angular_velocity()
-    return @rigid_body.getAngularVelocity()
+    return @rigid_body.get_angular_velocity()
   end
 
   def get_acceleration()
@@ -213,15 +213,15 @@ class GardenObject < Bullet::BtMotionState
   end
 
   def get_gravity()
-    return @rigid_body.getGravity()
+    return @rigid_body.get_gravity()
   end
 
   def get_rotation()
-    return @transform.getRotation()
+    return @transform.get_rotation()
   end
 
   def get_orientation()
-    return @transform.getRotation()
+    return @transform.get_rotation()
   end
 
   def limit_velocity(vel)
@@ -245,7 +245,7 @@ class GardenObject < Bullet::BtMotionState
 
   def apply_impulse(imp, rel = Vector3D.new(0, 0, 0))
     @rigid_body.activate(true)
-    @rigid_body.applyImpulse(imp, rel)
+    @rigid_body.apply_impulse(imp, rel)
   end
 
   #
@@ -260,32 +260,32 @@ class GardenObject < Bullet::BtMotionState
     qnorm = Quaternion.new()
     qnorm.copy(quat)
     qnorm.normalize()
-    transform = @rigid_body.getCenterOfMassTransform()
-    curRot = transform.getRotation()
+    transform = @rigid_body.get_center_of_mass_transform()
+    curRot = transform.get_rotation()
     newRot = curRot * qnorm
-    transform.setRotation(newRot)
-    @rigid_body.setCenterOfMassTransform(transform)
+    transform.set_rotation(newRot)
+    @rigid_body.set_center_of_mass_transform(transform)
 
-    @pivot_scene_node.setOrientation(Quaternion.to_ogre(newRot)) unless @garden.is_server
+    @pivot_scene_node.set_orientation(Quaternion.to_ogre(newRot)) unless @garden.is_server
   end
 
   def attach_object_to_bone(boneName, obj)
-    obj.scene_node.detachObject(obj.entity)
-    tag = @entity.attachObjectToBone(boneName, obj.entity)
-    @garden.physics.dynamics_world.removeRigidBody(obj.rigid_body)
+    obj.scene_node.detach_object(obj.entity)
+    tag = @entity.attach_object_to_bone(boneName, obj.entity)
+    @garden.physics.dynamics_world.remove_rigid_body(obj.rigid_body)
     obj.mode = MODE_ATTACHED
     return tag
   end
 
   def detach_object_from_bone(obj)
-    @entity.detachObjectFromBone(obj.entity)
-    obj.scene_node.attachObject(obj.entity)
+    @entity.detach_object_from_bone(obj.entity)
+    obj.scene_node.attach_object(obj.entity)
     if obj.physics_info.collisionFilter
-      @garden.physics.dynamics_world.addRigidBody(obj.rigid_body, 
-                                                 obj.physics_info.collisionFilter.group,
-                                                 obj.physics_info.collisionFilter.mask)
+      @garden.physics.dynamics_world.add_rigid_body(obj.rigid_body, 
+                                                    obj.physics_info.collisionFilter.group,
+                                                    obj.physics_info.collisionFilter.mask)
     else
-      @garden.physics.dynamics_world.addRigidBody(obj.rigid_body)
+      @garden.physics.dynamics_world.add_rigid_body(obj.rigid_body)
     end
     obj.mode = MODE_FREE
   end

data/lib/teien/light_object.rb

@@ -11,26 +11,26 @@ class LightObject
   def initialize(garden, name)
     @garden = garden
     @name = name
-    @light = @garden.view.scene_mgr.createLight(@name);
+    @light = @garden.view.scene_mgr.create_light(@name);
   end
 
   def set_type(type)
-    @light.setType(type)
+    @light.set_type(type)
   end
 
   def set_diffuse_color(color)
-    @light.setDiffuseColour(color);
+    @light.set_diffuse_colour(color);
   end
 
   def set_specular_color(color)
-    @light.setSpecularColour(color)
+    @light.set_specular_colour(color)
   end
 
   def set_position(vec)
-    @light.setPosition(Vector3D.to_ogre(vec));
+    @light.set_position(Vector3D.to_ogre(vec));
   end
 
   def set_direction(vec)
-    @light.setDirection(Vector3D.to_ogre(vec));
+    @light.set_direction(Vector3D.to_ogre(vec));
   end
 end

data/lib/teien/object_factory.rb

@@ -42,7 +42,7 @@ class ObjectFactory
       # Setting an entity and a node of Ogre3d.
       normal = Ogre::Vector3.new(0, 1, 0)
       up = Ogre::Vector3.new(0, 0, 1)
-      Ogre::MeshManager::getSingleton().createPlane(name, 
+      Ogre::MeshManager::get_singleton().create_plane(name, 
                                                     Ogre::ResourceGroupManager.DEFAULT_RESOURCE_GROUP_NAME,
                                                     Ogre::Plane.new(normal, 0), 
                                                     object_info.width * 2.0, 
@@ -52,19 +52,19 @@ class ObjectFactory
                                                     true, 1, 
                                                     object_info.u_tile, 
                                                     object_info.v_tile, up)
-      entity = @garden.view.scene_mgr.createEntity(name, name)
-      entity.setCastShadows(true)
-      entity.setMaterialName(object_info.material_name)
+      entity = @garden.view.scene_mgr.create_entity(name, name)
+      entity.set_cast_shadows(true)
+      entity.set_material_name(object_info.material_name)
       node = obj.create_scene_node(entity)
     end
 
     # Setting a collision shape and rigid body of Bullet.
     cShape = Bullet::BtBoxShape.new(Vector3D.new(object_info.width, object_info.depth, object_info.height))
     rb = obj.create_rigid_body(0, cShape, Vector3D.new(0, 0, 0), Vector3D.new(0.0, -object_info.depth, 0.0))
-    rb.setAngularFactor(physics_info.angular_factor)
-    rb.setRestitution(physics_info.restitution)
-    rb.setFriction(physics_info.friction)
-    rb.setDamping(physics_info.linear_damping, physics_info.angular_damping)
+    rb.set_angular_factor(physics_info.angular_factor)
+    rb.set_restitution(physics_info.restitution)
+    rb.set_friction(physics_info.friction)
+    rb.set_damping(physics_info.linear_damping, physics_info.angular_damping)
 
     @garden.add_object(obj)
       
@@ -79,23 +79,27 @@ class ObjectFactory
 
     unless @garden.is_server
       gen = Procedural::BoxGenerator.new()
-      gen.setSizeX(object_info.size.x * 2.0).setSizeY(object_info.size.y * 2.0).setSizeZ(object_info.size.z * 2.0)
-      gen.setNumSegX(object_info.num_seg_x).setNumSegY(object_info.num_seg_y).setNumSegZ(object_info.num_seg_z)
-      gen.setUTile(object_info.u_tile).setVTile(object_info.v_tile).realizeMesh(name)
-      entity = @garden.view.scene_mgr.createEntity(name)
-      entity.setCastShadows(true)
-      entity.setMaterialName(object_info.material_name)
+      gen.set_size_x(object_info.size.x * 2.0)
+      gen.set_size_y(object_info.size.y * 2.0)
+      gen.set_size_z(object_info.size.z * 2.0)
+      gen.set_num_seg_x(object_info.num_seg_x)
+      gen.set_num_seg_y(object_info.num_seg_y)
+      gen.set_num_seg_z(object_info.num_seg_z)
+      gen.set_utile(object_info.u_tile).set_vtile(object_info.v_tile).realize_mesh(name)
+      entity = @garden.view.scene_mgr.create_entity(name)
+      entity.set_cast_shadows(true)
+      entity.set_material_name(object_info.material_name)
       node = obj.create_scene_node(entity)
     end
 
     cShape = Bullet::BtBoxShape.new(Vector3D.new(object_info.size.x, object_info.size.y, object_info.size.z))
     inertia = Bullet::BtVector3.new()
-    cShape.calculateLocalInertia(physics_info.mass, inertia)
+    cShape.calculate_local_inertia(physics_info.mass, inertia)
     rb = obj.create_rigid_body(physics_info.mass, cShape, inertia)
-    rb.setAngularFactor(physics_info.angular_factor)
-    rb.setRestitution(physics_info.restitution)
-    rb.setFriction(physics_info.friction)
-    rb.setDamping(physics_info.linear_damping, physics_info.angular_damping)
+    rb.set_angular_factor(physics_info.angular_factor)
+    rb.set_restitution(physics_info.restitution)
+    rb.set_friction(physics_info.friction)
+    rb.set_damping(physics_info.linear_damping, physics_info.angular_damping)
 
 
     @garden.add_object(obj)
@@ -111,24 +115,24 @@ class ObjectFactory
 
     unless @garden.is_server
       gen = Procedural::SphereGenerator.new()
-      gen.setRadius(object_info.radius)
-      gen.setNumRings(object_info.num_rings)
-      gen.setNumSegments(object_info.num_segments)
-      gen.setUTile(object_info.u_tile).setVTile(object_info.v_tile).realizeMesh(name)
-      entity = @garden.view.scene_mgr.createEntity(name)
-      entity.setCastShadows(true)
-      entity.setMaterialName(object_info.material_name)
+      gen.set_radius(object_info.radius)
+      gen.set_num_rings(object_info.num_rings)
+      gen.set_num_segments(object_info.num_segments)
+      gen.set_vtile(object_info.u_tile).set_vtile(object_info.v_tile).realize_mesh(name)
+      entity = @garden.view.scene_mgr.create_entity(name)
+      entity.set_cast_shadows(true)
+      entity.set_material_name(object_info.material_name)
       node = obj.create_scene_node(entity)
     end
 
     cShape = Bullet::BtSphereShape.new(object_info.radius)
     inertia = Bullet::BtVector3.new()
-    cShape.calculateLocalInertia(physics_info.mass, inertia)
+    cShape.calculate_local_inertia(physics_info.mass, inertia)
     rb = obj.create_rigid_body(physics_info.mass, cShape, inertia)
-    rb.setAngularFactor(physics_info.angular_factor)
-    rb.setRestitution(physics_info.restitution)
-    rb.setFriction(physics_info.friction)
-    rb.setDamping(physics_info.linear_damping, physics_info.angular_damping)
+    rb.set_angular_factor(physics_info.angular_factor)
+    rb.set_restitution(physics_info.restitution)
+    rb.set_friction(physics_info.friction)
+    rb.set_damping(physics_info.linear_damping, physics_info.angular_damping)
 
     
     @garden.add_object(obj)
@@ -144,23 +148,25 @@ class ObjectFactory
 
     unless @garden.is_server
       gen = Procedural::CapsuleGenerator.new()
-      gen.setRadius(object_info.radius).setHeight(object_info.height)
-      gen.setNumRings(object_info.num_rings).setNumSegments(object_info.num_segments).setNumSegHeight(object_info.num_seg_height)
-      gen.setUTile(object_info.u_tile).setVTile(object_info.v_tile).realizeMesh(name)
-      entity = @garden.view.scene_mgr.createEntity(name)
-      entity.setCastShadows(true)
-      entity.setMaterialName(object_info.material_name)
+      gen.set_radius(object_info.radius).set_height(object_info.height)
+      gen.set_num_rings(object_info.num_rings)
+      gen.set_num_segments(object_info.num_segments)
+      gen.set_num_seg_height(object_info.num_seg_height)
+      gen.set_vtile(object_info.u_tile).set_vtile(object_info.v_tile).realize_mesh(name)
+      entity = @garden.view.scene_mgr.create_entity(name)
+      entity.set_cast_shadows(true)
+      entity.set_material_name(object_info.material_name)
       node = obj.create_scene_node(entity)
     end
 
     cShape = Bullet::BtCapsuleShape.new(object_info.radius, object_info.height)
     inertia = Bullet::BtVector3.new()
-    cShape.calculateLocalInertia(physics_info.mass, inertia)
+    cShape.calculate_local_inertia(physics_info.mass, inertia)
     rb = obj.create_rigid_body(physics_info.mass, cShape, inertia)
-    rb.setAngularFactor(physics_info.angular_factor)
-    rb.setRestitution(physics_info.restitution)
-    rb.setFriction(physics_info.friction)
-    rb.setDamping(physics_info.linear_damping, physics_info.angular_damping)
+    rb.set_angular_factor(physics_info.angular_factor)
+    rb.set_restitution(physics_info.restitution)
+    rb.set_friction(physics_info.friction)
+    rb.set_damping(physics_info.linear_damping, physics_info.angular_damping)
 
 
     @garden.add_object(obj)
@@ -176,23 +182,23 @@ class ObjectFactory
 
     unless @garden.is_server
       gen = Procedural::ConeGenerator.new
-      gen.setRadius(object_info.radius).setHeight(object_info.height)
-      gen.setNumSegBase(object_info.num_seg_base).setNumSegHeight(object_info.num_seg_height)
-      gen.setUTile(object_info.u_tile).setVTile(object_info.v_tile).realizeMesh(name)
-      entity = @garden.view.scene_mgr.createEntity(name)
-      entity.setCastShadows(true)
-      entity.setMaterialName(object_info.material_name)
+      gen.set_radius(object_info.radius).set_height(object_info.height)
+      gen.set_num_seg_base(object_info.num_seg_base).set_num_seg_height(object_info.num_seg_height)
+      gen.set_utile(object_info.u_tile).set_vtile(object_info.v_tile).realize_mesh(name)
+      entity = @garden.view.scene_mgr.create_entity(name)
+      entity.set_cast_shadows(true)
+      entity.set_material_name(object_info.material_name)
       node = obj.create_scene_node(entity)
     end
 
     cShape = Bullet::BtConeShape.new(object_info.radius, object_info.height)
     inertia = Bullet::BtVector3.new()
-    cShape.calculateLocalInertia(physics_info.mass, inertia)
+    cShape.calculate_local_inertia(physics_info.mass, inertia)
     rb = obj.create_rigid_body(physics_info.mass, cShape, inertia, Vector3D.new(0, object_info.height / 2, 0))
-    rb.setAngularFactor(physics_info.angular_factor)
-    rb.setRestitution(physics_info.restitution)
-    rb.setFriction(physics_info.friction)
-    rb.setDamping(physics_info.linear_damping, physics_info.angular_damping)
+    rb.set_angular_factor(physics_info.angular_factor)
+    rb.set_restitution(physics_info.restitution)
+    rb.set_friction(physics_info.friction)
+    rb.set_damping(physics_info.linear_damping, physics_info.angular_damping)
 
 
     @garden.add_object(obj)
@@ -208,12 +214,12 @@ class ObjectFactory
 
     unless @garden.is_server
       gen = Procedural::CylinderGenerator.new
-      gen.setRadius(object_info.radius).setHeight(object_info.height).setCapped(object_info.capped)
-      gen.setNumSegBase(object_info.num_seg_base).setNumSegHeight(object_info.num_seg_height)
-      gen.setUTile(object_info.u_tile).setVTile(object_info.v_tile).realizeMesh(name)
-      entity = @garden.view.scene_mgr.createEntity(name)
-      entity.setCastShadows(true)
-      entity.setMaterialName(object_info.material_name)
+      gen.set_radius(object_info.radius).set_height(object_info.height).set_capped(object_info.capped)
+      gen.set_num_seg_base(object_info.num_seg_base).set_num_seg_height(object_info.num_seg_height)
+      gen.set_utile(object_info.u_tile).set_vtile(object_info.v_tile).realize_mesh(name)
+      entity = @garden.view.scene_mgr.create_entity(name)
+      entity.set_cast_shadows(true)
+      entity.set_material_name(object_info.material_name)
       node = obj.create_scene_node(entity, Vector3D.new(0, -object_info.height / 2, 0))
     end
 
@@ -221,12 +227,12 @@ class ObjectFactory
                                                                object_info.height / 2, 
                                                                object_info.radius))
     inertia = Bullet::BtVector3.new()
-    cShape.calculateLocalInertia(physics_info.mass, inertia)
+    cShape.calculate_local_inertia(physics_info.mass, inertia)
     rb = obj.create_rigid_body(physics_info.mass, cShape, inertia)
-    rb.setAngularFactor(physics_info.angular_factor)
-    rb.setRestitution(physics_info.restitution)
-    rb.setFriction(physics_info.friction)
-    rb.setDamping(physics_info.linear_damping, physics_info.angular_damping)
+    rb.set_angular_factor(physics_info.angular_factor)
+    rb.set_restitution(physics_info.restitution)
+    rb.set_friction(physics_info.friction)
+    rb.set_damping(physics_info.linear_damping, physics_info.angular_damping)
 
     @garden.add_object(obj)
 
@@ -240,23 +246,23 @@ class ObjectFactory
     obj.physics_info = physics_info
 
     unless @garden.is_server
-      entity = @garden.view.scene_mgr.createEntity(name, object_info.mesh_path)
-      entity.setCastShadows(true)
-      entity.setMaterialName(object_info.material_name) if object_info.material_name
+      entity = @garden.view.scene_mgr.create_entity(name, object_info.mesh_path)
+      entity.set_cast_shadows(true)
+      entity.set_material_name(object_info.material_name) if object_info.material_name
       node = obj.create_scene_node(entity, object_info.view_offset, object_info.view_rotation)
-      node.setScale(object_info.size.x * object_info.scale.x, 
-                    object_info.size.y * object_info.scale.y, 
-                    object_info.size.z * object_info.scale.z)
+      node.set_scale(object_info.size.x * object_info.scale.x, 
+                     object_info.size.y * object_info.scale.y, 
+                     object_info.size.z * object_info.scale.z)
     end
 
     cShape = Bullet::BtBoxShape.new(object_info.size)
     inertia = Bullet::BtVector3.new()
-    cShape.calculateLocalInertia(physics_info.mass, inertia)
+    cShape.calculate_local_inertia(physics_info.mass, inertia)
     rb = obj.create_rigid_body(physics_info.mass, cShape, inertia, object_info.physics_offset)
-    rb.setAngularFactor(physics_info.angular_factor)
-    rb.setRestitution(physics_info.restitution)
-    rb.setFriction(physics_info.friction)
-    rb.setDamping(physics_info.linear_damping, physics_info.angular_damping)
+    rb.set_angular_factor(physics_info.angular_factor)
+    rb.set_restitution(physics_info.restitution)
+    rb.set_friction(physics_info.friction)
+    rb.set_damping(physics_info.linear_damping, physics_info.angular_damping)
 
     @garden.add_object(obj)
 
@@ -270,26 +276,26 @@ class ObjectFactory
     obj.physics_info = physics_info
 
     unless @garden.is_server
-      entity = @garden.view.scene_mgr.createEntity(name, object_info.mesh_path)
-      entity.setCastShadows(true)
-      entity.setMaterialName(object_info.material_name) if object_info.material_name
+      entity = @garden.view.scene_mgr.create_entity(name, object_info.mesh_path)
+      entity.set_cast_shadows(true)
+      entity.set_material_name(object_info.material_name) if object_info.material_name
       node = obj.create_scene_node(entity, object_info.view_offset)
-      node.setScale(object_info.scale.x, object_info.scale.y, object_info.scale.z)
-      strider = Teienlib::MeshStrider.new(entity.getMesh().get())
+      node.set_scale(object_info.scale.x, object_info.scale.y, object_info.scale.z)
+      strider = Teienlib::MeshStrider.new(entity.get_mesh().get())
       cShape = Bullet::BtGImpactMeshShape.new(strider)
-      cShape.setLocalScaling(Bullet::BtVector3.new(object_info.scale.x, 
-                                                   object_info.scale.y, 
-                                                   object_info.scale.z))
+      cShape.set_local_scaling(Bullet::BtVector3.new(object_info.scale.x, 
+                                                     object_info.scale.y, 
+                                                     object_info.scale.z))
       cShape.instance_variable_set(:@strider, strider) # prevent this from GC.
-      cShape.postUpdate()
-      cShape.updateBound()
+      cShape.post_update()
+      cShape.update_bound()
       inertia = Bullet::BtVector3.new()
-      cShape.calculateLocalInertia(physics_info.mass, inertia)
+      cShape.calculate_local_inertia(physics_info.mass, inertia)
       rb = obj.create_rigid_body(physics_info.mass, cShape, inertia, object_info.physics_offset)
-      rb.setAngularFactor(physics_info.angular_factor)
-      rb.setRestitution(physics_info.restitution)
-      rb.setFriction(physics_info.friction)
-      rb.setDamping(physics_info.linear_damping, physics_info.angular_damping)
+      rb.set_angular_factor(physics_info.angular_factor)
+      rb.set_restitution(physics_info.restitution)
+      rb.set_friction(physics_info.friction)
+      rb.set_damping(physics_info.linear_damping, physics_info.angular_damping)
     end
     
     @garden.add_object(obj)

data/lib/teien/physics.rb

@@ -12,9 +12,9 @@ class ContactResult < Bullet::ContactResultCallback
     return @isCollided
   end
 
-  def addSingleResult(cp, 
-                      colObj0, partId0, index0,
-                      colObj1, partId1, index1)
+  def add_single_result(cp, 
+                        colObj0, partId0, index0,
+                        colObj1, partId1, index1)
     @isCollided = true
     return 0
   end
@@ -51,10 +51,10 @@ class Physics < Bullet::TickListener
     @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.set_gravity(gravity)
 
-    @dynamics_world.setInternalTickCallback(self, true);     
-    @dynamics_world.setInternalTickCallback(self, false);     
+    @dynamics_world.set_internal_tick_callback(self, true);     
+    @dynamics_world.set_internal_tick_callback(self, false);     
 =begin
     worldAabbCache->getOverlappingPairCache()->setInternalGhostPairCallback(new btGhostPairCallback());
 =end    
@@ -70,7 +70,7 @@ class Physics < Bullet::TickListener
   def finalize
     # clear all objects.
     @rigid_bodies.each{|body|
-      @dynamics_world.removeRigidBody(body)
+      @dynamics_world.remove_rigid_body(body)
     }
     @rigid_bodies = []
 
@@ -78,24 +78,24 @@ class Physics < Bullet::TickListener
   end
 
   def update(delta)
-    @dynamics_world.stepSimulation(delta, @max_sub_steps, @fixed_time_step)
+    @dynamics_world.step_simulation(delta, @max_sub_steps, @fixed_time_step)
     return true
   end
 
-  def frameRenderingQueued(evt)
+  def frame_rendering_queued(evt)
 #    print "Physics::tick: ", evt.timeSinceLastFrame * 1000, "ms\n"
-    @dynamics_world.stepSimulation(evt.timeSinceLastFrame, @max_sub_steps, @fixed_time_step)
+    @dynamics_world.step_simulation(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())
+    pair_cache = @dynamics_world.get_broadphase().get_overlapping_pair_cache()
+    pair_cache.remove_overlapping_pairs_containing_proxy(rigid_body.get_broadphase_handle(), 
+                                                         @dynamics_world.get_dispatcher())
   end
 
   def set_gravity(vec)
-    @dynamics_world.setGravity(vec)
+    @dynamics_world.set_gravity(vec)
   end
 
 =begin
@@ -117,15 +117,15 @@ class Physics < Bullet::TickListener
   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)
+      @dynamics_world.add_rigid_body(rigid_body, collision_filter.group, collision_filter.mask)
     else
-      @dynamics_world.addRigidBody(rigid_body)
+      @dynamics_world.add_rigid_body(rigid_body)
     end
   end
 
   def contact_pair_test(colObjA, colObjB)
     result = ContactResult.new
-    @dynamics_world.contactPairTest(colObjA, colObjB, result)
+    @dynamics_world.contact_pair_test(colObjA, colObjB, result)
     return result
   end