Changeset 1768 for trunk/test/Physics/IncludeTweet

Timestamp:

Aug 17, 2012, 7:41:36 PM (11 years ago)

Author:

touky

Message:

Added Attachment/base logic with working attachment with EasyCharacterController.
Added RayCastResult & a naïve integration for EasyCharacterController.
Enjoy !

Location:

trunk/test/Physics/Include

Files:

• EasyCharacterController.h (modified) (4 diffs)
• EasyPhysics.h (modified) (8 diffs)
• LolBtPhysicsIntegration.h (modified) (2 diffs)
• LolPhysics.h (modified) (5 diffs)

trunk/test/Physics/Include/EasyCharacterController.h

@@ -30 +30 @@
 {
 
-class EasyCharacterController : public EasyPhysic
+class EasyCharacterController : public EasyPhysic,
+                                                                public Entity
 {
 
@@ -38 +39 @@
         EasyCharacterController(WorldEntity* NewOwnerEntity) :
                 EasyPhysic(NewOwnerEntity),
-                m_character(NULL)
+                m_pair_caching_object(NULL),
+                m_character(NULL),
+                m_step_height(.0f),
+                m_base_is_updating(false),
+                m_base_cached_movement(vec3(0.f)),
+                m_frame_cached_movement(vec3(0.f))
         {
+                m_gamegroup = GAMEGROUP_EZP_CHAR_CTRLR;
                 m_up_axis = 1;
         }
@@ -53 +60 @@
         virtual void SetMovementForFrame(vec3 const &MoveQuantity);
 
+        virtual void SetTransform(const lol::vec3& base_location, const lol::quat& base_rotation);
+protected:
+        virtual void BaseTransformChanged(const lol::mat4& PreviousMatrix, const lol::mat4& NewMatrix);
+public:
+        virtual void TickGame(float seconds);
+
 protected:
 
-        virtual btGhostObject* GetGhostObject();
+        virtual btGhostObject* GetGhostObjectInstance();
 
         btPairCachingGhostObject*               m_pair_caching_object;
@@ -62 +75 @@
         float                                                   m_step_height;
         int                                                             m_up_axis;
+        bool                                                    m_base_is_updating;
+        vec3                                                    m_base_cached_movement;
+        vec3                                                    m_frame_cached_movement;
 
 #else  // NO PHYSIC IMPLEMENTATION

trunk/test/Physics/Include/EasyPhysics.h

@@ -35 +35 @@
 
         friend class EasyConstraint;
+        friend class Simulation;
 
 #ifdef HAVE_PHYS_USE_BULLET
@@ -49 +50 @@
 
         virtual bool CanChangeCollisionChannel() { return (m_rigid_body == NULL); }
+        virtual mat4 GetTransform();
         virtual void SetTransform(const lol::vec3& base_location, const lol::quat& base_rotation=lol::quat(lol::mat4(1.0f)));
-private:
+protected:
         virtual void BaseTransformChanged(const lol::mat4& PreviousMatrix, const lol::mat4& NewMatrix);
 public:
@@ -58 +60 @@
         virtual void AddToSimulation(class Simulation* current_simulation);
         virtual void RemoveFromSimulation(class Simulation* current_simulation);
-        virtual mat4 GetTransform();
 
 protected:
@@ -64 +65 @@
         virtual void SetShapeTo(btCollisionShape* collision_shape);
 
-        virtual btGhostObject* GetGhostObject();
+        virtual btGhostObject* GetGhostObjectInstance();
 
         btCollisionObject*                                                      m_collision_object;
@@ -89 +90 @@
 
         virtual bool CanChangeCollisionChannel() { return true; }
+        virtual mat4 GetTransform() { return mat4(1.0f); }
         virtual void SetTransform(const lol::vec3& base_location, const lol::quat& base_rotation=lol::quat(lol::mat4(1.0f))) { }
 private:
@@ -98 +100 @@
         virtual void AddToSimulation(class Simulation* current_simulation) { }
         virtual void RemoveFromSimulation(class Simulation* current_simulation) { }
-        virtual mat4 GetTransform() { return mat4(1.0f); }
 
         virtual void InitBodyToGhost() { }
@@ -123 +124 @@
         virtual void AttachTo(EasyPhysic* NewBase, bool NewBaseLockLocation = true, bool NewBaseLockRotation = true)
         {
-                if (NewBase == this || NewBase->m_base_physic == this)
+                if (NewBase == this || (NewBase && NewBase->m_base_physic == this))
                         return;
 
@@ -138 +139 @@
                         m_base_lock_rotation = NewBaseLockRotation;
                 }
-                else
+                else if (m_base_physic)
                 {
-                        for (int i = 0; i < NewBase->m_based_physic_list.Count(); ++i)
-                                if (NewBase->m_based_physic_list[i] == this)
-                                        NewBase->m_based_physic_list.Remove(i--);
+                        for (int i = 0; i < m_base_physic->m_based_physic_list.Count(); ++i)
+                                if (m_base_physic->m_based_physic_list[i] == this)
+                                        m_base_physic->m_based_physic_list.Remove(i--);
                         m_base_physic = NULL;
                 }

trunk/test/Physics/Include/LolBtPhysicsIntegration.h

@@ -20 +20 @@
 namespace lol
 {
+        //Override Gamegroups names for Physic-useage
+        //"_ENT_" means that this is a group for Entities that use EasyPhysic primitives.
+        //"_EZP_" means that this is a group for EasyPhysic primitives.
+#define GAMEGROUP_ENT_PLATFORM          GAMEGROUP_BEFORE
+#define GAMEGROUP_ENT_MAIN                      GAMEGROUP_DEFAULT
+#define GAMEGROUP_EZP_CHAR_CTRLR        GAMEGROUP_AFTER
+#define GAMEGROUP_SIMULATION            GAMEGROUP_AFTER_POST
 
 #ifdef HAVE_PHYS_USE_BULLET
@@ -32 +39 @@
 #define BT2LOL_VEC3(ELEMENT)    (*(lol::vec3*)(&(ELEMENT)))
 
+//Same as above with Unit taken into account
+#define LOL2BTU_VEC3(ELEMENT)   btVector3((ELEMENT).x * LOL2BT_UNIT, (ELEMENT).y * LOL2BT_UNIT, (ELEMENT).z * LOL2BT_UNIT)
+#define BT2LOLU_VEC3(ELEMENT)   (*(lol::vec3*)(&(ELEMENT))) * BT2LOL_UNIT
+
 #define LOL2BT_QUAT(ELEMENT)    btQuaternion((ELEMENT).x, (ELEMENT).y, (ELEMENT).z, (ELEMENT).w)
 #define BT2LOL_QUAT(ELEMENT)    lol::quat((ELEMENT).getW(), BT2LOL_VEC3((ELEMENT).getAxis())

trunk/test/Physics/Include/LolPhysics.h

@@ -10 +10 @@
 
 #ifdef HAVE_PHYS_USE_BULLET
+#include <cstring>
 #include <bullet/btBulletDynamicsCommon.h>
 #include <bullet/btBulletCollisionCommon.h>
+#include <BulletDynamics/Character/btKinematicCharacterController.h>
 #include "LolBtPhysicsIntegration.h"
 #include "EasyPhysics.h"
@@ -22 +24 @@
 namespace phys
 {
+
+enum eRaycastType
+{
+        ERT_Closest,
+        ERT_AllHit,
+        ERT_AnyHit, //Will stop at the first hit. Hit data are supposed to be irrelevant
+
+        ERT_MAX
+};
+
+struct RayCastResult
+{
+        RayCastResult(int CollisionFilterGroup=1, int CollisionFilterMask=(0xFF))
+        {
+                memset(this, 0, sizeof(RayCastResult));
+
+                m_collision_filter_group = CollisionFilterGroup;
+                m_collision_filter_mask = CollisionFilterMask;
+        }
+        void Reset()
+        {
+                m_collider_list.Empty();
+                m_hit_normal_list.Empty();
+                m_hit_point_list.Empty();
+                m_hit_fraction_list.Empty();
+        }
+
+        Array<EasyPhysic*>              m_collider_list;
+        Array<vec3>                             m_hit_normal_list;
+        Array<vec3>                             m_hit_point_list;
+        Array<float>                    m_hit_fraction_list;
+
+        short int                               m_collision_filter_group;
+        short int                               m_collision_filter_mask;
+        unsigned int                    m_flags; //???
+};
 
 class Simulation : public Entity
@@ -34 +72 @@
                 m_timestep(1.f/60.f)
         {
+                m_gamegroup = GAMEGROUP_SIMULATION;
         }
         ~Simulation()
@@ -80 +119 @@
         }
 
+        //Reap-Off of the btKinematicClosestNotMeRayResultCallback
+        class LolClosestNotMeRayResultCallback : public btCollisionWorld::ClosestRayResultCallback
+        {
+        public:
+                LolClosestNotMeRayResultCallback(btCollisionObject* Me, const btVector3& rayFromWorld, const btVector3& rayToWorld) :
+                  btCollisionWorld::ClosestRayResultCallback(rayFromWorld, rayToWorld)
+                {
+                        m_me = Me;
+                }
+
+                virtual btScalar addSingleResult(btCollisionWorld::LocalRayResult& rayResult,bool normalInWorldSpace)
+                {
+                        if (rayResult.m_collisionObject == m_me)
+                                return 1.0;
+
+                        return ClosestRayResultCallback::addSingleResult(rayResult, normalInWorldSpace);
+                }
+        protected:
+                btCollisionObject* m_me;
+        };
+
+        //Will stop at the first hit. Hit data are supposed to be irrelevant
+        class AnyHitRayResultCallback : public btCollisionWorld::ClosestRayResultCallback
+        {
+        public:
+                AnyHitRayResultCallback(const btVector3& rayFromWorld, const btVector3& rayToWorld) :
+                  btCollisionWorld::ClosestRayResultCallback(rayFromWorld, rayToWorld)
+                {
+                }
+
+                virtual btScalar addSingleResult(btCollisionWorld::LocalRayResult& rayResult,bool normalInWorldSpace)
+                {
+                        return .0f;
+                }
+        };
+
+        //Returns true when hitting something. If SourceCaster is set, it will be ignored by Raycast.
+        bool RayHits(RayCastResult& HitResult, eRaycastType RaycastType, const vec3& RayFrom, const vec3& RayTo, EasyPhysic* SourceCaster=NULL)
+        {
+                bool bResult = false;
+
+                btCollisionWorld::RayResultCallback* BtRayResult = NULL;
+                btCollisionWorld::ClosestRayResultCallback* BtRayResult_Closest;
+                btCollisionWorld::AllHitsRayResultCallback* BtRayResult_AllHits;
+
+                switch (RaycastType)
+                {
+                        case ERT_Closest:
+                        {
+                                if (SourceCaster)
+                                        BtRayResult_Closest = new LolClosestNotMeRayResultCallback(SourceCaster->m_collision_object, LOL2BTU_VEC3(RayFrom), LOL2BTU_VEC3(RayTo));
+                                else
+                                        BtRayResult_Closest = new btCollisionWorld::ClosestRayResultCallback(LOL2BTU_VEC3(RayFrom), LOL2BTU_VEC3(RayTo));
+                                BtRayResult = BtRayResult_Closest;
+                                break;
+                        }
+                        case ERT_AllHit:
+                        {
+                                BtRayResult_AllHits = new btCollisionWorld::AllHitsRayResultCallback(LOL2BTU_VEC3(RayFrom), LOL2BTU_VEC3(RayTo));
+                                BtRayResult = BtRayResult_AllHits;
+                                break;
+                        }
+                        case ERT_AnyHit:
+                        {
+                                BtRayResult_Closest = new AnyHitRayResultCallback(LOL2BTU_VEC3(RayFrom), LOL2BTU_VEC3(RayTo));
+                                BtRayResult = BtRayResult_Closest;
+                                break;
+                        }
+                }
+
+                m_dynamics_world->rayTest(LOL2BTU_VEC3(RayFrom), LOL2BTU_VEC3(RayTo), *BtRayResult);
+                if (BtRayResult->hasHit())
+                {
+                        bResult = true;
+
+                        switch (RaycastType)
+                        {
+                                case ERT_Closest:
+                                {
+                                        HitResult.m_collider_list               << (EasyPhysic*)BtRayResult_Closest->m_collisionObject->getUserPointer();
+                                        HitResult.m_hit_normal_list             << BT2LOLU_VEC3(BtRayResult_Closest->m_hitNormalWorld);
+                                        HitResult.m_hit_point_list              << BT2LOLU_VEC3(BtRayResult_Closest->m_hitPointWorld);
+                                        HitResult.m_hit_fraction_list   << BtRayResult_Closest->m_closestHitFraction;
+                                        break;
+                                }
+                                case ERT_AllHit:
+                                {
+                                        for (int i = 0; i < BtRayResult_AllHits->m_collisionObjects.size(); i++)
+                                        {
+                                                HitResult.m_collider_list               << (EasyPhysic*)BtRayResult_AllHits->m_collisionObjects[i]->getUserPointer();
+                                                HitResult.m_hit_normal_list             << BT2LOLU_VEC3(BtRayResult_AllHits->m_hitNormalWorld[i]);
+                                                HitResult.m_hit_point_list              << BT2LOLU_VEC3(BtRayResult_AllHits->m_hitPointWorld[i]);
+                                                HitResult.m_hit_fraction_list   << BtRayResult_AllHits->m_hitFractions[i];
+                                        }
+                                        break;
+                                }
+                        }
+                }
+
+                delete BtRayResult;
+
+                return bResult;
+        }
+
+
         void Exit()
         {
@@ -129 +273 @@
         void Init() { }
         void TickGame(float seconds) { }
+        bool RayHits(RayCastResult& HitResult, eRaycastType RaycastType, const vec3& RayFrom, const vec3& RayTo, EasyPhysic* SourceCaster=NULL) { return false; }
         void Exit() { }
 private: