Changeset 1698Tweet

Timestamp:

Aug 5, 2012, 7:06:28 PM (10 years ago)

Author:

touky

Message:

Lazy WE :
Small tweaks in the BtPhysTest demo.
Added Ghost Object skeleton (not tested)

Location:

trunk/test

Files:

• BtPhysTest.cpp (modified) (4 diffs)
• BtPhysTest.h (modified) (1 diff)
• PhysicObject.h (modified) (1 diff)
• Physics/EasyPhysics.cpp (modified) (5 diffs)
• Physics/EasyPhysics.h (modified) (4 diffs)
• Physics/LolPhysics.h (modified) (2 diffs)

trunk/test/BtPhysTest.cpp

@@ -97 +97 @@
         }
 
+        {
+                quat NewRotation = quat(1.f);
+                vec3 NewPosition = pos_offset + vec3(5.0f, -20.0f, -15.0f);
+
+                PhysicsObject* NewPhyobj = new PhysicsObject(m_simulation, NewPosition, NewRotation, 0);
+
+                m_platform_list << NewPhyobj;
+                Ticker::Ref(NewPhyobj);
+
+                NewPosition = pos_offset + vec3(-20.0f, -25.0f, 5.0f);
+
+                NewPhyobj = new PhysicsObject(m_simulation, NewPosition, NewRotation, 0);
+
+                m_platform_list << NewPhyobj;
+                Ticker::Ref(NewPhyobj);
+        }
+
         if (1)
         {
@@ -325 +342 @@
         }
 
-        if (1)
+        if (0)
         {
                 for (int i = 0; i < m_ground_list.Count(); i++)
@@ -338 +355 @@
                                                 * GroundMat;
                         PhysObj->SetTransform(GroundMat.v3.xyz, quat(GroundMat));
+                }
+        }
+
+        {
+                for (int i = 0; i < m_platform_list.Count(); i++)
+                {
+                        PhysicsObject* PhysObj = m_platform_list[i];
+
+                        mat4 GroundMat = PhysObj->GetTransform();
+                        if (i == 0)
+                        {
+                                GroundMat = GroundMat * mat4(quat::fromeuler_xyz(vec3(20.f, .0f, .0f) * seconds));
+                                PhysObj->SetTransform(GroundMat.v3.xyz, quat(GroundMat));
+                        }
+                        else
+                        {
+                                GroundMat = GroundMat * mat4::translate(vec3(.0f, .0f, 10.0f) * seconds);
+                                if (GroundMat.v3.z > 40.0f)
+                                        GroundMat = GroundMat * mat4::translate(vec3(.0f, .0f, -80.0f));
+                                PhysObj->SetTransform(GroundMat.v3.xyz, quat(GroundMat));
+                        }
                 }
         }
@@ -448 +486 @@
                 Ticker::Unref(CurPop);
         }
+        while (m_platform_list.Count())
+        {
+                PhysicsObject* CurPop = m_platform_list.Last();
+                m_platform_list.Pop();
+                CurPop->GetPhysic()->RemoveFromSimulation(m_simulation);
+                Ticker::Unref(CurPop);
+        }
         while (m_physobj_list.Count())
         {

trunk/test/BtPhysTest.h

@@ -29 +29 @@
         Array<PhysicsObject*>                           m_physobj_list;
         Array<PhysicsObject*>                           m_ground_list;
+        Array<PhysicsObject*>                           m_platform_list;
 
 #if 0

trunk/test/PhysicObject.h

@@ -35 +35 @@
         }
 
+        PhysicsObject(Simulation* new_sim, const vec3 &base_location, const quat &base_rotation, int dummy)
+                : m_ready(false), m_should_render(true)
+        {
+                m_mesh.Compile("[sc#ddd afcb20 1 20 -.1]");
+                vec3 BoxSize = vec3(20.f, 1.f, 20.f);
+                m_physics.SetCollisionChannel(0, 0xFF);
+                m_physics.SetShapeToBox(BoxSize);
+                m_physics.SetMass(.0f);
+                m_physics.SetTransform(base_location, base_rotation);
+                m_physics.InitBodyToRigid(true);
+                m_physics.AddToSimulation(new_sim);
+        }
+
         PhysicsObject(Simulation* new_sim, float base_mass, const vec3 &base_location, int RandValue = -1)
                 : m_ready(false), m_should_render(true)

trunk/test/Physics/EasyPhysics.cpp

@@ -33 +33 @@
         m_collision_object(NULL),
         m_rigid_body(NULL),
+        m_ghost_object(NULL),
         m_collision_shape(NULL),
         m_motion_state(NULL),
@@ -107 +108 @@
 void EasyPhysic::SetTransform(const lol::vec3& base_location, const lol::quat& base_rotation)
 {
-        if (m_motion_state)
-                m_motion_state->setWorldTransform(btTransform(LOL2BT_QUAT(base_rotation), LOL2BT_VEC3(base_location * LOL2BT_UNIT)));
+        if (m_ghost_object)
+                m_ghost_object->setWorldTransform(btTransform(LOL2BT_QUAT(base_rotation), LOL2BT_VEC3(base_location * LOL2BT_UNIT)));
         else
-                m_motion_state = new btDefaultMotionState(btTransform(LOL2BT_QUAT(base_rotation), LOL2BT_VEC3(base_location * LOL2BT_UNIT)));
+        {
+                if (m_motion_state)
+                        m_motion_state->setWorldTransform(btTransform(LOL2BT_QUAT(base_rotation), LOL2BT_VEC3(base_location * LOL2BT_UNIT)));
+                else
+                        m_motion_state = new btDefaultMotionState(btTransform(LOL2BT_QUAT(base_rotation), LOL2BT_VEC3(base_location * LOL2BT_UNIT)));
+        }
 }
 
@@ -138 +144 @@
                 delete m_collision_object;
 
-        SetLocalInertia(m_mass);
         if (!m_motion_state)
                 SetTransform(vec3(.0f));
@@ -153 +158 @@
 }
 
+//Init to Ghost object, for Overlap/Sweep Test/Touching logic
+void EasyPhysic::InitBodyToGhost()
+{
+        if (m_collision_object)
+                delete m_collision_object;
+
+        m_ghost_object = new btGhostObject();
+        m_ghost_object->setCollisionShape(m_collision_shape);
+        m_collision_object = m_ghost_object;
+
+        SetTransform(vec3(.0f));
+
+        m_ghost_object->setCollisionFlags(m_ghost_object->getCollisionFlags());
+        //btCollisionObject::CF_CHARACTER_OBJECT
+}
+
+//Add Physic object to the simulation
 void EasyPhysic::AddToSimulation(class Simulation* current_simulation)
 {
@@ -158 +180 @@
         if (dynamics_world)
         {
-                if (m_rigid_body)
+                if (m_ghost_object)
+                {
+                        dynamics_world->addCollisionObject(m_ghost_object, m_collision_group, m_collision_mask);
+                        current_simulation->AddToGhost(this);
+                }
+                else if (m_rigid_body)
                 {
                         dynamics_world->addRigidBody(m_rigid_body, m_collision_group, m_collision_mask);

trunk/test/Physics/EasyPhysics.h

@@ -22 +22 @@
 #include <bullet/btBulletDynamicsCommon.h>
 #include <bullet/btBulletCollisionCommon.h>
+#include <bullet/BulletCollision/CollisionDispatch/btGhostObject.h>
 #endif
 
@@ -51 +52 @@
         void SetMass(float mass);
         void InitBodyToRigid(bool ZeroMassIsKinematic=false);
+        void InitBodyToGhost();
         void AddToSimulation(class Simulation* current_simulation);
         void RemoveFromSimulation(class Simulation* current_simulation);
@@ -60 +62 @@
 
         btCollisionObject*                                                      m_collision_object;
+
+        btGhostObject*                                                          m_ghost_object;
 
         btRigidBody*                                                            m_rigid_body;
@@ -82 +86 @@
         void SetMass(float mass) { }
         void InitBodyToRigid() { }
+        void InitBodyToGhost() { }
         void AddToSimulation(class Simulation* current_simulation) { }
         void RemoveFromSimulation(class Simulation* current_simulation) { }

trunk/test/Physics/LolPhysics.h

@@ -160 +160 @@
         void AddToDynamic(EasyPhysic* NewEPDynamic)     { m_dynamic_list << NewEPDynamic; }
         void AddToStatic(EasyPhysic* NewEPStatic)       { m_static_list << NewEPStatic; }
+        void AddToGhost(EasyPhysic* NewEPGhost)         { m_ghost_list << NewEPGhost; }
         void AddToConstraint(EasyConstraint* NewEC)     { m_constraint_list     << NewEC; }
 
@@ -165 +166 @@
         Array<EasyPhysic*>                                              m_dynamic_list;
         Array<EasyPhysic*>                                              m_static_list;
+        Array<EasyPhysic*>                                              m_ghost_list;
         Array<EasyConstraint*>                                  m_constraint_list;