Changeset 1870


Ignore:
Timestamp:
Sep 3, 2012, 10:40:55 PM (7 years ago)
Author:
touky
Message:

Revert

Location:
trunk/test/Physics
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/test/Physics/Include/BulletCharacterController.h

    r1869 r1870  
    3636#ifdef HAVE_PHYS_USE_BULLET
    3737
    38                 //SweepCallback used for Swweep Tests.
    39                 class ClosestNotMeConvexResultCallback : public btCollisionWorld::ClosestConvexResultCallback
     38        //SweepCallback used for Swweep Tests.
     39        class ClosestNotMeConvexResultCallback : public btCollisionWorld::ClosestConvexResultCallback
     40        {
     41        public:
     42                ClosestNotMeConvexResultCallback(btCollisionObject* NewMe, const vec3& NewUp, float MinSlopeDot) :
     43                                                btCollisionWorld::ClosestConvexResultCallback(LOL2BTU_VEC3(vec3(.0f)), LOL2BTU_VEC3(vec3(.0f))),
     44                                                m_me(NewMe),
     45                                                m_up(NewUp),
     46                                                m_min_slope_dot(MinSlopeDot) { }
     47
     48                virtual btScalar addSingleResult(btCollisionWorld::LocalConvexResult& ConvexResult, bool NormalInWorld)
    4049                {
    41                 public:
    42                         ClosestNotMeConvexResultCallback(btCollisionObject* NewMe, const vec3& NewUp, float MinSlopeDot) :
    43                                                         btCollisionWorld::ClosestConvexResultCallback(LOL2BTU_VEC3(vec3(.0f)), LOL2BTU_VEC3(vec3(.0f))),
    44                                                         m_me(NewMe),
    45                                                         m_up(NewUp),
    46                                                         m_min_slope_dot(MinSlopeDot)
    47                         {
    48                                 m_collisionFilterGroup = NewMe->getBroadphaseHandle()->m_collisionFilterGroup;
    49                                 m_collisionFilterMask = NewMe->getBroadphaseHandle()->m_collisionFilterMask;
    50                         }
    51 
    52                         virtual btScalar addSingleResult(btCollisionWorld::LocalConvexResult& ConvexResult, bool NormalInWorld)
    53                         {
    54                                 //We hit ourselves, FAIL
    55                                 if (ConvexResult.m_hitCollisionObject == m_me)
    56                                         return btScalar(1.f);
    57 
    58                                 vec3 WorldHitNomal(.0f);
    59                                 if (NormalInWorld)
    60                                         WorldHitNomal = BT2LOL_VEC3(ConvexResult.m_hitNormalLocal);
    61                                 else //need to transform Normal into worldspace
    62                                 {
    63                                         btVector3 TmpWorldHitNormal = ConvexResult.m_hitCollisionObject->getWorldTransform().getBasis() * ConvexResult.m_hitNormalLocal;
    64                                         WorldHitNomal = BT2LOL_VEC3(TmpWorldHitNormal);
    65                                 }
    66 
    67                                 float DotUp = dot(m_up, WorldHitNomal);
    68                                 //We hit below the accepted slope_dot, FAIL
    69                                 if (DotUp < m_min_slope_dot)
    70                                         return btScalar(1.f);
    71 
    72                                 //Continue to next.
    73                                 return ClosestConvexResultCallback::addSingleResult(ConvexResult, NormalInWorld);
    74                         }
    75                 protected:
    76                         btCollisionObject*      m_me;
    77                         const vec3                      m_up;
    78                         float                           m_min_slope_dot;
    79                 };
     50                        //We hit ourselves, FAIL
     51                        if (ConvexResult.m_hitCollisionObject == m_me)
     52                                return btScalar(1.f);
     53
     54                        vec3 WorldHitNomal(.0f);
     55                        if (NormalInWorld)
     56                                WorldHitNomal = BT2LOL_VEC3(ConvexResult.m_hitNormalLocal);
     57                        else //need to transform Normal into worldspace
     58                        {
     59                                btVector3 TmpWorldHitNormal = ConvexResult.m_hitCollisionObject->getWorldTransform().getBasis() * ConvexResult.m_hitNormalLocal;
     60                                WorldHitNomal = BT2LOL_VEC3(TmpWorldHitNormal);
     61                        }
     62
     63                        float DotUp = dot(m_up, WorldHitNomal);
     64                        //We hit below the accepted slope_dot, FAIL
     65                        if (DotUp < m_min_slope_dot)
     66                                return btScalar(1.f);
     67
     68                        //Continue to next.
     69                        return ClosestConvexResultCallback::addSingleResult(ConvexResult, NormalInWorld);
     70                }
     71        protected:
     72                btCollisionObject*      m_me;
     73                const vec3                      m_up;
     74                float                           m_min_slope_dot;
     75        };
    8076
    8177                ///BulletKinematicCharacterController is an object that supports a sliding motion in a world.
     
    8581                {
    8682                public:
    87                         BulletKinematicCharacterController(EasyCharacterController* NewCharacter, btPairCachingGhostObject* NewGhostObject, btConvexShape* NewConvexShape, float NewStepHeight, int NewUpAxis=1)
    88                         {
    89                                 m_character = NewCharacter;
     83                        BulletKinematicCharacterController(btPairCachingGhostObject* NewGhostObject, btConvexShape* NewConvexShape, float NewStepHeight, int NewUpAxis=1)
     84                        {
    9085                                m_convex_shape = NewConvexShape;       
    9186                                m_i_up_axis = NewUpAxis;
     
    124119
    125120                        //Returns the reflection Direction of a ray going 'Direction' hitting a surface with Normal 'Normal' from: http://www-cs-students.stanford.edu/~adityagp/final/node3.html
    126                         vec3 GetReflectedDir(const vec3& Direction, const vec3& Normal) { return Direction - (2.f * dot(Direction, Normal) * Normal); }
     121                        vec3 GetReflectedDir(const vec3& Direction, const vec3& Normal)
     122                        {
     123                                return Direction - (2.f * dot(Direction, Normal) * Normal);
     124                        }
    127125                        //Returns the portion of 'direction' that is parallel to 'normal'
    128                         vec3 ProjectDirOnNorm(const vec3& Direction, const vec3& Normal) { return Normal * dot(Direction, Normal); }
     126                        vec3 ProjectDirOnNorm(const vec3& Direction, const vec3& Normal)
     127                        {
     128                                return Normal * dot(Direction, Normal);
     129                        }
    129130                        //Returns the portion of 'Direction' that is perpindicular to 'Normal'
    130                         vec3 ProjectDirOnNormPerpindicular(const vec3& Direction, const vec3& Normal) { return Direction - ProjectDirOnNorm(Direction, Normal); }
     131                        vec3 ProjectDirOnNormPerpindicular(const vec3& Direction, const vec3& Normal)
     132                        {
     133                                return Direction - ProjectDirOnNorm(Direction, Normal);
     134                        }
    131135                        //Returns Ghost Object. -duh-
    132                         btPairCachingGhostObject* GetGhostObject() { return m_ghost_object; }
     136                        btPairCachingGhostObject* GetGhostObject()
     137                        {
     138                                return m_ghost_object;
     139                        }
    133140
    134141                        //"Real" war functions
     
    152159                        void debugDraw(btIDebugDraw* debugDrawer) { }
    153160                       
    154                         void SetUpAxis(int NewAxis) { m_i_up_axis = abs(NewAxis) % 3; }
     161                        void SetUpAxis(int NewAxis)
     162                        {
     163                                if (NewAxis < 0)
     164                                        NewAxis = 0;
     165                                if (NewAxis > 2)
     166                                        NewAxis = 2;
     167                                m_i_up_axis = NewAxis;
     168                        }
    155169
    156170                        //!!!!!! SHOULD DITCH THAT !!!!!!
     
    216230                private:
    217231
    218                         EasyCharacterController*        m_character;
    219232                        btPairCachingGhostObject*       m_ghost_object;
    220233                        btConvexShape*                          m_convex_shape; //is also in m_ghost_object, but it needs to be convex, so we store it here to avoid upcast
  • trunk/test/Physics/Include/EasyCharacterController.h

    r1869 r1870  
    4242
    4343#ifdef HAVE_PHYS_USE_BULLET
    44 
    45         friend class BulletKinematicCharacterController;
    4644
    4745public:
     
    105103        vec3                                                    m_current_velocity;
    106104
    107         //Feedback from Bullet collision :
    108         //The idea is : we tell what to do to the BCC at each Hit
    109         int                                                             MoveDidImpact(int HitType, const ClosestNotMeConvexResultCallback& SweepCallback);
    110 
    111105#else  // NO PHYSIC IMPLEMENTATION
    112106
  • trunk/test/Physics/Src/BulletCharacterController.cpp

    r1869 r1870  
    139139
    140140                ClosestNotMeConvexResultCallback SweepCallback(m_ghost_object, SweepDirNeg, .0f);
     141                SweepCallback.m_collisionFilterGroup = GetGhostObject()->getBroadphaseHandle()->m_collisionFilterGroup;
     142                SweepCallback.m_collisionFilterMask = GetGhostObject()->getBroadphaseHandle()->m_collisionFilterMask;
    141143
    142144                //The sweep test is done with an added margin, so we use it and then discard it
  • trunk/test/Physics/Src/EasyCharacterController.cpp

    r1869 r1870  
    6363
    6464                //m_character = new btKinematicCharacterController(m_pair_caching_object, m_convex_shape, m_step_height, m_up_axis);
    65                 m_character = new BulletKinematicCharacterController(this, m_pair_caching_object, m_convex_shape, m_step_height, m_up_axis);
     65                m_character = new BulletKinematicCharacterController(m_pair_caching_object, m_convex_shape, m_step_height, m_up_axis);
    6666
    6767                //Deactivate Character controller basic behaviour.
     
    147147}
    148148
    149 int EasyCharacterController::MoveDidImpact(int HitType, const ClosestNotMeConvexResultCallback& SweepCallback)
    150 {
    151         return 0;
    152 }
    153 
    154149#endif // HAVE_PHYS_USE_BULLET
    155150
Note: See TracChangeset for help on using the changeset viewer.