Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 8393


Ignore:
Timestamp:
May 3, 2011, 5:07:42 AM (9 years ago)
Author:
rgrieder
Message:

Updated Bullet from v2.77 to v2.78.
(I'm not going to make a branch for that since the update from 2.74 to 2.77 hasn't been tested that much either).

You will HAVE to do a complete RECOMPILE! I tested with MSVC and MinGW and they both threw linker errors at me.

Location:
code/trunk/src/external/bullet
Files:
6 added
161 edited

Legend:

Unmodified
Added
Removed
  • code/trunk/src/external/bullet/Bullet-C-Api.h

    r8351 r8393  
    6666*/
    6767
    68         extern  plPhysicsSdkHandle      plNewBulletSdk(); //this could be also another sdk, like ODE, PhysX etc.
     68        extern  plPhysicsSdkHandle      plNewBulletSdk(void); //this could be also another sdk, like ODE, PhysX etc.
    6969        extern  void            plDeletePhysicsSdk(plPhysicsSdkHandle   physicsSdk);
    7070
     
    117117        extern  plCollisionShapeHandle plNewConeShape(plReal radius, plReal height);
    118118        extern  plCollisionShapeHandle plNewCylinderShape(plReal radius, plReal height);
    119         extern  plCollisionShapeHandle plNewCompoundShape();
     119        extern  plCollisionShapeHandle plNewCompoundShape(void);
    120120        extern  void    plAddChildShape(plCollisionShapeHandle compoundShape,plCollisionShapeHandle childShape, plVector3 childPos,plQuaternion childOrn);
    121121
     
    123123
    124124        /* Convex Meshes */
    125         extern  plCollisionShapeHandle plNewConvexHullShape();
     125        extern  plCollisionShapeHandle plNewConvexHullShape(void);
    126126        extern  void            plAddVertex(plCollisionShapeHandle convexHull, plReal x,plReal y,plReal z);
    127127/* Concave static triangle meshes */
    128         extern  plMeshInterfaceHandle              plNewMeshInterface();
     128        extern  plMeshInterfaceHandle              plNewMeshInterface(void);
    129129        extern  void            plAddTriangle(plMeshInterfaceHandle meshHandle, plVector3 v0,plVector3 v1,plVector3 v2);
    130130        extern  plCollisionShapeHandle plNewStaticTriangleMeshShape(plMeshInterfaceHandle);
  • code/trunk/src/external/bullet/BulletCollision/BroadphaseCollision/btAxisSweep3.h

    r8351 r8393  
    1717// 3. This notice may not be removed or altered from any source distribution.
    1818
    19 #ifndef AXIS_SWEEP_3_H
    20 #define AXIS_SWEEP_3_H
     19#ifndef BT_AXIS_SWEEP_3_H
     20#define BT_AXIS_SWEEP_3_H
    2121
    2222#include "LinearMath/btVector3.h"
  • code/trunk/src/external/bullet/BulletCollision/BroadphaseCollision/btBroadphaseInterface.h

    r8351 r8393  
    1414*/
    1515
    16 #ifndef         BROADPHASE_INTERFACE_H
    17 #define         BROADPHASE_INTERFACE_H
     16#ifndef         BT_BROADPHASE_INTERFACE_H
     17#define         BT_BROADPHASE_INTERFACE_H
    1818
    1919
     
    8080};
    8181
    82 #endif //BROADPHASE_INTERFACE_H
     82#endif //BT_BROADPHASE_INTERFACE_H
  • code/trunk/src/external/bullet/BulletCollision/BroadphaseCollision/btBroadphaseProxy.h

    r8351 r8393  
    1414*/
    1515
    16 #ifndef BROADPHASE_PROXY_H
    17 #define BROADPHASE_PROXY_H
     16#ifndef BT_BROADPHASE_PROXY_H
     17#define BT_BROADPHASE_PROXY_H
    1818
    1919#include "LinearMath/btScalar.h" //for SIMD_FORCE_INLINE
     
    267267
    268268
    269 #endif //BROADPHASE_PROXY_H
    270 
     269#endif //BT_BROADPHASE_PROXY_H
     270
  • code/trunk/src/external/bullet/BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h

    r5781 r8393  
    1414*/
    1515
    16 #ifndef COLLISION_ALGORITHM_H
    17 #define COLLISION_ALGORITHM_H
     16#ifndef BT_COLLISION_ALGORITHM_H
     17#define BT_COLLISION_ALGORITHM_H
    1818
    1919#include "LinearMath/btScalar.h"
     
    4545        btPersistentManifold*   m_manifold;
    4646
    47         int     getDispatcherId();
     47//      int     getDispatcherId();
    4848
    4949};
     
    6060
    6161protected:
    62         int     getDispatcherId();
     62//      int     getDispatcherId();
    6363       
    6464public:
     
    7878
    7979
    80 #endif //COLLISION_ALGORITHM_H
     80#endif //BT_COLLISION_ALGORITHM_H
  • code/trunk/src/external/bullet/BulletCollision/BroadphaseCollision/btDispatcher.h

    r8351 r8393  
    1414*/
    1515
    16 #ifndef _DISPATCHER_H
    17 #define _DISPATCHER_H
    18 
     16#ifndef BT_DISPATCHER_H
     17#define BT_DISPATCHER_H
    1918#include "LinearMath/btScalar.h"
    2019
     
    2827class btPersistentManifold;
    2928class btStackAlloc;
     29class btPoolAllocator;
    3030
    3131struct btDispatcherInfo
     
    4141                m_dispatchFunc(DISPATCH_DISCRETE),
    4242                m_timeOfImpact(btScalar(1.)),
    43                 m_useContinuous(false),
     43                m_useContinuous(true),
    4444                m_debugDraw(0),
    4545                m_enableSatConvex(false),
     
    4949                m_useConvexConservativeDistanceUtil(false),
    5050                m_convexConservativeDistanceThreshold(0.0f),
    51                 m_convexMaxDistanceUseCPT(false),
    5251                m_stackAllocator(0)
    5352        {
     
    6665        bool            m_useConvexConservativeDistanceUtil;
    6766        btScalar        m_convexConservativeDistanceThreshold;
    68         bool            m_convexMaxDistanceUseCPT;
    6967        btStackAlloc*   m_stackAllocator;
    7068};
     
    9997        virtual btPersistentManifold**  getInternalManifoldPointer() = 0;
    10098
     99        virtual btPoolAllocator*        getInternalManifoldPool() = 0;
     100
     101        virtual const btPoolAllocator*  getInternalManifoldPool() const = 0;
     102
    101103        virtual void* allocateCollisionAlgorithm(int size)  = 0;
    102104
     
    106108
    107109
    108 #endif //_DISPATCHER_H
     110#endif //BT_DISPATCHER_H
  • code/trunk/src/external/bullet/BulletCollision/BroadphaseCollision/btOverlappingPairCache.h

    r8351 r8393  
    1414*/
    1515
    16 #ifndef OVERLAPPING_PAIR_CACHE_H
    17 #define OVERLAPPING_PAIR_CACHE_H
     16#ifndef BT_OVERLAPPING_PAIR_CACHE_H
     17#define BT_OVERLAPPING_PAIR_CACHE_H
    1818
    1919
     
    465465
    466466
    467 #endif //OVERLAPPING_PAIR_CACHE_H
    468 
    469 
     467#endif //BT_OVERLAPPING_PAIR_CACHE_H
     468
     469
  • code/trunk/src/external/bullet/BulletCollision/BroadphaseCollision/btQuantizedBvh.h

    r8351 r8393  
    1414*/
    1515
    16 #ifndef QUANTIZED_BVH_H
    17 #define QUANTIZED_BVH_H
     16#ifndef BT_QUANTIZED_BVH_H
     17#define BT_QUANTIZED_BVH_H
    1818
    1919class btSerializer;
     
    577577
    578578
    579 #endif //QUANTIZED_BVH_H
     579#endif //BT_QUANTIZED_BVH_H
  • code/trunk/src/external/bullet/BulletCollision/BroadphaseCollision/btSimpleBroadphase.h

    r8351 r8393  
    1414*/
    1515
    16 #ifndef SIMPLE_BROADPHASE_H
    17 #define SIMPLE_BROADPHASE_H
     16#ifndef BT_SIMPLE_BROADPHASE_H
     17#define BT_SIMPLE_BROADPHASE_H
    1818
    1919
     
    168168
    169169
    170 #endif //SIMPLE_BROADPHASE_H
     170#endif //BT_SIMPLE_BROADPHASE_H
    171171
  • code/trunk/src/external/bullet/BulletCollision/CMakeLists.txt

    r8351 r8393  
    5050        CollisionShapes/btConvexInternalShape.cpp
    5151        CollisionShapes/btConvexPointCloudShape.cpp
     52        CollisionShapes/btConvexPolyhedron.cpp
    5253        CollisionShapes/btConvexShape.cpp
    5354        CollisionShapes/btConvex2dShape.cpp
     
    8889
    8990COMPILATION_END
     91
     92    # Raises compiler errors when compiled inside the compilation
     93        NarrowPhaseCollision/btPolyhedralContactClipping.cpp
    9094
    9195        # Headers
     
    140144        CollisionShapes/btConvexInternalShape.h
    141145        CollisionShapes/btConvexPointCloudShape.h
     146        CollisionShapes/btConvexPolyhedron.h
    142147        CollisionShapes/btConvexShape.h
    143148        CollisionShapes/btConvex2dShape.h
     
    184189        NarrowPhaseCollision/btSubSimplexConvexCast.h
    185190        NarrowPhaseCollision/btVoronoiSimplexSolver.h
     191        NarrowPhaseCollision/btPolyhedralContactClipping.h
    186192)
  • code/trunk/src/external/bullet/BulletCollision/CollisionDispatch/SphereTriangleDetector.cpp

    r8351 r8393  
    5858}
    5959
    60 #define MAX_OVERLAP btScalar(0.)
    61 
    6260
    6361
     
    9492}
    9593
    96 ///combined discrete/continuous sphere-triangle
    9794bool SphereTriangleDetector::collide(const btVector3& sphereCenter,btVector3 &point, btVector3& resultNormal, btScalar& depth, btScalar &timeOfImpact, btScalar contactBreakingThreshold)
    9895{
    9996
    10097        const btVector3* vertices = &m_triangle->getVertexPtr(0);
    101         const btVector3& c = sphereCenter;
    102         btScalar r = m_sphere->getRadius();
    103 
    104         btVector3 delta (0,0,0);
     98       
     99        btScalar radius = m_sphere->getRadius();
     100        btScalar radiusWithThreshold = radius + contactBreakingThreshold;
    105101
    106102        btVector3 normal = (vertices[1]-vertices[0]).cross(vertices[2]-vertices[0]);
    107103        normal.normalize();
    108         btVector3 p1ToCentre = c - vertices[0];
     104        btVector3 p1ToCentre = sphereCenter - vertices[0];
    109105        btScalar distanceFromPlane = p1ToCentre.dot(normal);
    110106
     
    112108        {
    113109                //triangle facing the other way
    114        
    115110                distanceFromPlane *= btScalar(-1.);
    116111                normal *= btScalar(-1.);
    117112        }
    118113
    119         btScalar contactMargin = contactBreakingThreshold;
    120         bool isInsideContactPlane = distanceFromPlane < r + contactMargin;
    121         bool isInsideShellPlane = distanceFromPlane < r;
    122        
    123         btScalar deltaDotNormal = delta.dot(normal);
    124         if (!isInsideShellPlane && deltaDotNormal >= btScalar(0.0))
    125                 return false;
    126 
     114        bool isInsideContactPlane = distanceFromPlane < radiusWithThreshold;
     115       
    127116        // Check for contact / intersection
    128117        bool hasContact = false;
    129118        btVector3 contactPoint;
    130119        if (isInsideContactPlane) {
    131                 if (facecontains(c,vertices,normal)) {
     120                if (facecontains(sphereCenter,vertices,normal)) {
    132121                        // Inside the contact wedge - touches a point on the shell plane
    133122                        hasContact = true;
    134                         contactPoint = c - normal*distanceFromPlane;
     123                        contactPoint = sphereCenter - normal*distanceFromPlane;
    135124                } else {
    136125                        // Could be inside one of the contact capsules
    137                         btScalar contactCapsuleRadiusSqr = (r + contactMargin) * (r + contactMargin);
     126                        btScalar contactCapsuleRadiusSqr = radiusWithThreshold*radiusWithThreshold;
    138127                        btVector3 nearestOnEdge;
    139128                        for (int i = 0; i < m_triangle->getNumEdges(); i++) {
     
    144133                                m_triangle->getEdge(i,pa,pb);
    145134
    146                                 btScalar distanceSqr = SegmentSqrDistance(pa,pb,c, nearestOnEdge);
     135                                btScalar distanceSqr = SegmentSqrDistance(pa,pb,sphereCenter, nearestOnEdge);
    147136                                if (distanceSqr < contactCapsuleRadiusSqr) {
    148137                                        // Yep, we're inside a capsule
     
    156145
    157146        if (hasContact) {
    158                 btVector3 contactToCentre = c - contactPoint;
     147                btVector3 contactToCentre = sphereCenter - contactPoint;
    159148                btScalar distanceSqr = contactToCentre.length2();
    160                 if (distanceSqr < (r - MAX_OVERLAP)*(r - MAX_OVERLAP)) {
    161                         btScalar distance = btSqrt(distanceSqr);
    162                         resultNormal = contactToCentre;
    163                         resultNormal.normalize();
    164                         point = contactPoint;
    165                         depth = -(r-distance);
     149
     150                if (distanceSqr < radiusWithThreshold*radiusWithThreshold)
     151                {
     152                        if (distanceSqr>SIMD_EPSILON)
     153                        {
     154                                btScalar distance = btSqrt(distanceSqr);
     155                                resultNormal = contactToCentre;
     156                                resultNormal.normalize();
     157                                point = contactPoint;
     158                                depth = -(radius-distance);
     159                        } else
     160                        {
     161                                btScalar distance = 0.f;
     162                                resultNormal = normal;
     163                                point = contactPoint;
     164                                depth = -radius;
     165                        }
    166166                        return true;
    167167                }
    168 
    169                 if (delta.dot(contactToCentre) >= btScalar(0.0))
    170                         return false;
    171                
    172                 // Moving towards the contact point -> collision
    173                 point = contactPoint;
    174                 timeOfImpact = btScalar(0.0);
    175                 return true;
    176168        }
    177169       
  • code/trunk/src/external/bullet/BulletCollision/CollisionDispatch/SphereTriangleDetector.h

    r8351 r8393  
    1414*/
    1515
    16 #ifndef SPHERE_TRIANGLE_DETECTOR_H
    17 #define SPHERE_TRIANGLE_DETECTOR_H
     16#ifndef BT_SPHERE_TRIANGLE_DETECTOR_H
     17#define BT_SPHERE_TRIANGLE_DETECTOR_H
    1818
    1919#include "BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h"
     
    4848       
    4949};
    50 #endif //SPHERE_TRIANGLE_DETECTOR_H
     50#endif //BT_SPHERE_TRIANGLE_DETECTOR_H
    5151
  • code/trunk/src/external/bullet/BulletCollision/CollisionDispatch/btBox2dBox2dCollisionAlgorithm.h

    r8351 r8393  
    1414*/
    1515
    16 #ifndef BOX_2D_BOX_2D__COLLISION_ALGORITHM_H
    17 #define BOX_2D_BOX_2D__COLLISION_ALGORITHM_H
     16#ifndef BT_BOX_2D_BOX_2D__COLLISION_ALGORITHM_H
     17#define BT_BOX_2D_BOX_2D__COLLISION_ALGORITHM_H
    1818
    1919#include "BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.h"
     
    6363};
    6464
    65 #endif //BOX_2D_BOX_2D__COLLISION_ALGORITHM_H
     65#endif //BT_BOX_2D_BOX_2D__COLLISION_ALGORITHM_H
    6666
  • code/trunk/src/external/bullet/BulletCollision/CollisionDispatch/btBoxBoxCollisionAlgorithm.h

    r5781 r8393  
    1414*/
    1515
    16 #ifndef BOX_BOX__COLLISION_ALGORITHM_H
    17 #define BOX_BOX__COLLISION_ALGORITHM_H
     16#ifndef BT_BOX_BOX__COLLISION_ALGORITHM_H
     17#define BT_BOX_BOX__COLLISION_ALGORITHM_H
    1818
    1919#include "btActivatingCollisionAlgorithm.h"
     
    6363};
    6464
    65 #endif //BOX_BOX__COLLISION_ALGORITHM_H
     65#endif //BT_BOX_BOX__COLLISION_ALGORITHM_H
    6666
  • code/trunk/src/external/bullet/BulletCollision/CollisionDispatch/btBoxBoxDetector.h

    r5781 r8393  
    17173. This notice may not be removed or altered from any source distribution.
    1818*/
    19 #ifndef BOX_BOX_DETECTOR_H
    20 #define BOX_BOX_DETECTOR_H
     19#ifndef BT_BOX_BOX_DETECTOR_H
     20#define BT_BOX_BOX_DETECTOR_H
    2121
    2222
  • code/trunk/src/external/bullet/BulletCollision/CollisionDispatch/btCollisionConfiguration.h

    r5781 r8393  
    1616#ifndef BT_COLLISION_CONFIGURATION
    1717#define BT_COLLISION_CONFIGURATION
     18
    1819struct btCollisionAlgorithmCreateFunc;
    1920
  • code/trunk/src/external/bullet/BulletCollision/CollisionDispatch/btCollisionCreateFunc.h

    r5781 r8393  
    1414*/
    1515
    16 #ifndef COLLISION_CREATE_FUNC
    17 #define COLLISION_CREATE_FUNC
     16#ifndef BT_COLLISION_CREATE_FUNC
     17#define BT_COLLISION_CREATE_FUNC
    1818
    1919#include "LinearMath/btAlignedObjectArray.h"
     
    4242        }
    4343};
    44 #endif //COLLISION_CREATE_FUNC
     44#endif //BT_COLLISION_CREATE_FUNC
    4545
  • code/trunk/src/external/bullet/BulletCollision/CollisionDispatch/btCollisionDispatcher.cpp

    r8351 r8393  
    9393        } else
    9494        {
    95                 mem = btAlignedAlloc(sizeof(btPersistentManifold),16);
    96 
     95                //we got a pool memory overflow, by default we fallback to dynamically allocate memory. If we require a contiguous contact pool then assert.
     96                if ((m_dispatcherFlags&CD_DISABLE_CONTACTPOOL_DYNAMIC_ALLOCATION)==0)
     97                {
     98                        mem = btAlignedAlloc(sizeof(btPersistentManifold),16);
     99                } else
     100                {
     101                        btAssert(0);
     102                        //make sure to increase the m_defaultMaxPersistentManifoldPoolSize in the btDefaultCollisionConstructionInfo/btDefaultCollisionConfiguration
     103                        return 0;
     104                }
    97105        }
    98106        btPersistentManifold* manifold = new(mem) btPersistentManifold (body0,body1,0,contactBreakingThreshold,contactProcessingThreshold);
     
    173181        {
    174182                //broadphase filtering already deals with this
    175                 if ((body0->isStaticObject() || body0->isKinematicObject()) &&
    176                         (body1->isStaticObject() || body1->isKinematicObject()))
     183                if (body0->isStaticOrKinematicObject() && body1->isStaticOrKinematicObject())
    177184                {
    178185                        m_dispatcherFlags |= btCollisionDispatcher::CD_STATIC_STATIC_REPORTED;
  • code/trunk/src/external/bullet/BulletCollision/CollisionDispatch/btCollisionDispatcher.h

    r8351 r8393  
    1414*/
    1515
    16 #ifndef COLLISION__DISPATCHER_H
    17 #define COLLISION__DISPATCHER_H
     16#ifndef BT_COLLISION__DISPATCHER_H
     17#define BT_COLLISION__DISPATCHER_H
    1818
    1919#include "BulletCollision/BroadphaseCollision/btDispatcher.h"
     
    4343class btCollisionDispatcher : public btDispatcher
    4444{
     45
     46protected:
     47
    4548        int             m_dispatcherFlags;
    46        
     49
    4750        btAlignedObjectArray<btPersistentManifold*>     m_manifoldsPtr;
    4851
     
    6568        {
    6669                CD_STATIC_STATIC_REPORTED = 1,
    67                 CD_USE_RELATIVE_CONTACT_BREAKING_THRESHOLD = 2
     70                CD_USE_RELATIVE_CONTACT_BREAKING_THRESHOLD = 2,
     71                CD_DISABLE_CONTACTPOOL_DYNAMIC_ALLOCATION = 4
    6872        };
    6973
     
    7579        void    setDispatcherFlags(int flags)
    7680        {
    77         (void) flags;
    78                 m_dispatcherFlags = 0;
     81                m_dispatcherFlags = flags;
    7982        }
    8083
     
    154157        }
    155158
     159        virtual btPoolAllocator*        getInternalManifoldPool()
     160        {
     161                return m_persistentManifoldPoolAllocator;
     162        }
     163
     164        virtual const btPoolAllocator*  getInternalManifoldPool() const
     165        {
     166                return m_persistentManifoldPoolAllocator;
     167        }
     168
    156169};
    157170
    158 #endif //COLLISION__DISPATCHER_H
     171#endif //BT_COLLISION__DISPATCHER_H
    159172
  • code/trunk/src/external/bullet/BulletCollision/CollisionDispatch/btCollisionObject.h

    r8351 r8393  
    1414*/
    1515
    16 #ifndef COLLISION_OBJECT_H
    17 #define COLLISION_OBJECT_H
     16#ifndef BT_COLLISION_OBJECT_H
     17#define BT_COLLISION_OBJECT_H
    1818
    1919#include "LinearMath/btTransform.h"
     
    522522
    523523
    524 #endif //COLLISION_OBJECT_H
     524#endif //BT_COLLISION_OBJECT_H
  • code/trunk/src/external/bullet/BulletCollision/CollisionDispatch/btCollisionWorld.cpp

    r8351 r8393  
    2929#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
    3030#include "BulletCollision/BroadphaseCollision/btBroadphaseInterface.h"
     31#include "BulletCollision/BroadphaseCollision/btDbvt.h"
    3132#include "LinearMath/btAabbUtil2.h"
    3233#include "LinearMath/btQuickprof.h"
    3334#include "LinearMath/btStackAlloc.h"
    3435#include "LinearMath/btSerializer.h"
     36#include "BulletCollision/CollisionShapes/btConvexPolyhedron.h"
     37
     38//#define DISABLE_DBVT_COMPOUNDSHAPE_RAYCAST_ACCELERATION
     39
    3540
    3641//#define USE_BRUTEFORCE_RAYBROADPHASE 1
     
    151156        maxAabb += contactThreshold;
    152157
     158        if(getDispatchInfo().m_useContinuous && colObj->getInternalType()==btCollisionObject::CO_RIGID_BODY)
     159        {
     160                btVector3 minAabb2,maxAabb2;
     161                colObj->getCollisionShape()->getAabb(colObj->getInterpolationWorldTransform(),minAabb2,maxAabb2);
     162                minAabb2 -= contactThreshold;
     163                maxAabb2 += contactThreshold;
     164                minAabb.setMin(minAabb2);
     165                maxAabb.setMax(maxAabb2);
     166        }
     167
    153168        btBroadphaseInterface* bp = (btBroadphaseInterface*)m_broadphasePairCache;
    154169
     
    421436                } else {
    422437                        //                      BT_PROFILE("rayTestCompound");
    423                         ///@todo: use AABB tree or other BVH acceleration structure, see btDbvt
    424438                        if (collisionShape->isCompound())
    425439                        {
     440                                struct LocalInfoAdder2 : public RayResultCallback
     441                                {
     442                                        RayResultCallback* m_userCallback;
     443                                        int m_i;
     444                                       
     445                                        LocalInfoAdder2 (int i, RayResultCallback *user)
     446                                                : m_userCallback(user), m_i(i)
     447                                        {
     448                                                m_closestHitFraction = m_userCallback->m_closestHitFraction;
     449                                        }
     450                                        virtual bool needsCollision(btBroadphaseProxy* p) const
     451                                        {
     452                                                return m_userCallback->needsCollision(p);
     453                                        }
     454
     455                                        virtual btScalar addSingleResult (btCollisionWorld::LocalRayResult &r, bool b)
     456                                        {
     457                                                btCollisionWorld::LocalShapeInfo shapeInfo;
     458                                                shapeInfo.m_shapePart = -1;
     459                                                shapeInfo.m_triangleIndex = m_i;
     460                                                if (r.m_localShapeInfo == NULL)
     461                                                        r.m_localShapeInfo = &shapeInfo;
     462
     463                                                const btScalar result = m_userCallback->addSingleResult(r, b);
     464                                                m_closestHitFraction = m_userCallback->m_closestHitFraction;
     465                                                return result;
     466                                        }
     467                                };
     468                               
     469                                struct RayTester : btDbvt::ICollide
     470                                {
     471                                        btCollisionObject* m_collisionObject;
     472                                        const btCompoundShape* m_compoundShape;
     473                                        const btTransform& m_colObjWorldTransform;
     474                                        const btTransform& m_rayFromTrans;
     475                                        const btTransform& m_rayToTrans;
     476                                        RayResultCallback& m_resultCallback;
     477                                       
     478                                        RayTester(btCollisionObject* collisionObject,
     479                                                        const btCompoundShape* compoundShape,
     480                                                        const btTransform& colObjWorldTransform,
     481                                                        const btTransform& rayFromTrans,
     482                                                        const btTransform& rayToTrans,
     483                                                        RayResultCallback& resultCallback):
     484                                                m_collisionObject(collisionObject),
     485                                                m_compoundShape(compoundShape),
     486                                                m_colObjWorldTransform(colObjWorldTransform),
     487                                                m_rayFromTrans(rayFromTrans),
     488                                                m_rayToTrans(rayToTrans),
     489                                                m_resultCallback(resultCallback)
     490                                        {
     491                                               
     492                                        }
     493                                       
     494                                        void Process(int i)
     495                                        {
     496                                                const btCollisionShape* childCollisionShape = m_compoundShape->getChildShape(i);
     497                                                const btTransform& childTrans = m_compoundShape->getChildTransform(i);
     498                                                btTransform childWorldTrans = m_colObjWorldTransform * childTrans;
     499                                               
     500                                                // replace collision shape so that callback can determine the triangle
     501                                                btCollisionShape* saveCollisionShape = m_collisionObject->getCollisionShape();
     502                                                m_collisionObject->internalSetTemporaryCollisionShape((btCollisionShape*)childCollisionShape);
     503
     504                                                LocalInfoAdder2 my_cb(i, &m_resultCallback);
     505
     506                                                rayTestSingle(
     507                                                        m_rayFromTrans,
     508                                                        m_rayToTrans,
     509                                                        m_collisionObject,
     510                                                        childCollisionShape,
     511                                                        childWorldTrans,
     512                                                        my_cb);
     513                                               
     514                                                // restore
     515                                                m_collisionObject->internalSetTemporaryCollisionShape(saveCollisionShape);
     516                                        }
     517                                       
     518                                        void Process(const btDbvtNode* leaf)
     519                                        {
     520                                                Process(leaf->dataAsInt);
     521                                        }
     522                                };
     523                               
    426524                                const btCompoundShape* compoundShape = static_cast<const btCompoundShape*>(collisionShape);
    427                                 int i=0;
    428                                 for (i=0;i<compoundShape->getNumChildShapes();i++)
    429                                 {
    430                                         btTransform childTrans = compoundShape->getChildTransform(i);
    431                                         const btCollisionShape* childCollisionShape = compoundShape->getChildShape(i);
    432                                         btTransform childWorldTrans = colObjWorldTransform * childTrans;
    433                                         // replace collision shape so that callback can determine the triangle
    434                                         btCollisionShape* saveCollisionShape = collisionObject->getCollisionShape();
    435                                         collisionObject->internalSetTemporaryCollisionShape((btCollisionShape*)childCollisionShape);
    436                     struct LocalInfoAdder2 : public RayResultCallback {
    437                                                 RayResultCallback* m_userCallback;
    438                                                 int m_i;
    439                         LocalInfoAdder2 (int i, RayResultCallback *user)
    440                                                         : m_userCallback(user),
    441                                                         m_i(i)
    442                                                 {
    443                                                         m_closestHitFraction = m_userCallback->m_closestHitFraction;
    444                                                 }
    445                                                 virtual btScalar addSingleResult (btCollisionWorld::LocalRayResult &r, bool b)
    446                             {
    447                                     btCollisionWorld::LocalShapeInfo    shapeInfo;
    448                                     shapeInfo.m_shapePart = -1;
    449                                     shapeInfo.m_triangleIndex = m_i;
    450                                     if (r.m_localShapeInfo == NULL)
    451                                         r.m_localShapeInfo = &shapeInfo;
    452 
    453                                                                         const btScalar result = m_userCallback->addSingleResult(r, b);
    454                                                                         m_closestHitFraction = m_userCallback->m_closestHitFraction;
    455                                                                         return result;
    456                             }
    457                     };
    458 
    459                     LocalInfoAdder2 my_cb(i, &resultCallback);
    460 
    461                                         rayTestSingle(rayFromTrans,rayToTrans,
    462                                                 collisionObject,
    463                                                 childCollisionShape,
    464                                                 childWorldTrans,
    465                                                 my_cb);
    466                                         // restore
    467                                         collisionObject->internalSetTemporaryCollisionShape(saveCollisionShape);
     525                                const btDbvt* dbvt = compoundShape->getDynamicAabbTree();
     526
     527
     528                                RayTester rayCB(
     529                                        collisionObject,
     530                                        compoundShape,
     531                                        colObjWorldTransform,
     532                                        rayFromTrans,
     533                                        rayToTrans,
     534                                        resultCallback);
     535#ifndef DISABLE_DBVT_COMPOUNDSHAPE_RAYCAST_ACCELERATION
     536                                if (dbvt)
     537                                {
     538                                        btVector3 localRayFrom = colObjWorldTransform.inverseTimes(rayFromTrans).getOrigin();
     539                                        btVector3 localRayTo = colObjWorldTransform.inverseTimes(rayToTrans).getOrigin();
     540                                        btDbvt::rayTest(dbvt->m_root, localRayFrom , localRayTo, rayCB);
     541                                }
     542                                else
     543#endif //DISABLE_DBVT_COMPOUNDSHAPE_RAYCAST_ACCELERATION
     544                                {
     545                                        for (int i = 0, n = compoundShape->getNumChildShapes(); i < n; ++i)
     546                                        {
     547                                                rayCB.Process(i);
     548                                        }       
    468549                                }
    469550                        }
     
    577658                                BridgeTriangleConvexcastCallback tccb(castShape, convexFromTrans,convexToTrans,&resultCallback,collisionObject,triangleMesh, colObjWorldTransform);
    578659                                tccb.m_hitFraction = resultCallback.m_closestHitFraction;
     660                                tccb.m_allowedPenetration = allowedPenetration;
    579661                                btVector3 boxMinLocal, boxMaxLocal;
    580662                                castShape->getAabb(rotationXform, boxMinLocal, boxMaxLocal);
     
    582664                        } else
    583665                        {
    584                                 //BT_PROFILE("convexSweepConcave");
    585                                 btConcaveShape* concaveShape = (btConcaveShape*)collisionShape;
    586                                 btTransform worldTocollisionObject = colObjWorldTransform.inverse();
    587                                 btVector3 convexFromLocal = worldTocollisionObject * convexFromTrans.getOrigin();
    588                                 btVector3 convexToLocal = worldTocollisionObject * convexToTrans.getOrigin();
    589                                 // rotation of box in local mesh space = MeshRotation^-1 * ConvexToRotation
    590                                 btTransform rotationXform = btTransform(worldTocollisionObject.getBasis() * convexToTrans.getBasis());
    591 
    592                                 //ConvexCast::CastResult
    593                                 struct BridgeTriangleConvexcastCallback : public btTriangleConvexcastCallback
    594                                 {
    595                                         btCollisionWorld::ConvexResultCallback* m_resultCallback;
    596                                         btCollisionObject*      m_collisionObject;
    597                                         btConcaveShape* m_triangleMesh;
    598 
    599                                         BridgeTriangleConvexcastCallback(const btConvexShape* castShape, const btTransform& from,const btTransform& to,
    600                                                 btCollisionWorld::ConvexResultCallback* resultCallback, btCollisionObject* collisionObject,btConcaveShape*      triangleMesh, const btTransform& triangleToWorld):
    601                                         btTriangleConvexcastCallback(castShape, from,to, triangleToWorld, triangleMesh->getMargin()),
    602                                                 m_resultCallback(resultCallback),
    603                                                 m_collisionObject(collisionObject),
    604                                                 m_triangleMesh(triangleMesh)
    605                                         {
     666                                if (collisionShape->getShapeType()==STATIC_PLANE_PROXYTYPE)
     667                                {
     668                                        btConvexCast::CastResult castResult;
     669                                        castResult.m_allowedPenetration = allowedPenetration;
     670                                        castResult.m_fraction = resultCallback.m_closestHitFraction;
     671                                        btStaticPlaneShape* planeShape = (btStaticPlaneShape*) collisionShape;
     672                                        btContinuousConvexCollision convexCaster1(castShape,planeShape);
     673                                        btConvexCast* castPtr = &convexCaster1;
     674
     675                                        if (castPtr->calcTimeOfImpact(convexFromTrans,convexToTrans,colObjWorldTransform,colObjWorldTransform,castResult))
     676                                        {
     677                                                //add hit
     678                                                if (castResult.m_normal.length2() > btScalar(0.0001))
     679                                                {
     680                                                        if (castResult.m_fraction < resultCallback.m_closestHitFraction)
     681                                                        {
     682                                                                castResult.m_normal.normalize();
     683                                                                btCollisionWorld::LocalConvexResult localConvexResult
     684                                                                        (
     685                                                                        collisionObject,
     686                                                                        0,
     687                                                                        castResult.m_normal,
     688                                                                        castResult.m_hitPoint,
     689                                                                        castResult.m_fraction
     690                                                                        );
     691
     692                                                                bool normalInWorldSpace = true;
     693                                                                resultCallback.addSingleResult(localConvexResult, normalInWorldSpace);
     694                                                        }
     695                                                }
    606696                                        }
    607697
    608 
    609                                         virtual btScalar reportHit(const btVector3& hitNormalLocal, const btVector3& hitPointLocal, btScalar hitFraction, int partId, int triangleIndex )
    610                                         {
    611                                                 btCollisionWorld::LocalShapeInfo        shapeInfo;
    612                                                 shapeInfo.m_shapePart = partId;
    613                                                 shapeInfo.m_triangleIndex = triangleIndex;
    614                                                 if (hitFraction <= m_resultCallback->m_closestHitFraction)
     698                                } else
     699                                {
     700                                        //BT_PROFILE("convexSweepConcave");
     701                                        btConcaveShape* concaveShape = (btConcaveShape*)collisionShape;
     702                                        btTransform worldTocollisionObject = colObjWorldTransform.inverse();
     703                                        btVector3 convexFromLocal = worldTocollisionObject * convexFromTrans.getOrigin();
     704                                        btVector3 convexToLocal = worldTocollisionObject * convexToTrans.getOrigin();
     705                                        // rotation of box in local mesh space = MeshRotation^-1 * ConvexToRotation
     706                                        btTransform rotationXform = btTransform(worldTocollisionObject.getBasis() * convexToTrans.getBasis());
     707
     708                                        //ConvexCast::CastResult
     709                                        struct BridgeTriangleConvexcastCallback : public btTriangleConvexcastCallback
     710                                        {
     711                                                btCollisionWorld::ConvexResultCallback* m_resultCallback;
     712                                                btCollisionObject*      m_collisionObject;
     713                                                btConcaveShape* m_triangleMesh;
     714
     715                                                BridgeTriangleConvexcastCallback(const btConvexShape* castShape, const btTransform& from,const btTransform& to,
     716                                                        btCollisionWorld::ConvexResultCallback* resultCallback, btCollisionObject* collisionObject,btConcaveShape*      triangleMesh, const btTransform& triangleToWorld):
     717                                                btTriangleConvexcastCallback(castShape, from,to, triangleToWorld, triangleMesh->getMargin()),
     718                                                        m_resultCallback(resultCallback),
     719                                                        m_collisionObject(collisionObject),
     720                                                        m_triangleMesh(triangleMesh)
    615721                                                {
    616 
    617                                                         btCollisionWorld::LocalConvexResult convexResult
    618                                                                 (m_collisionObject,
    619                                                                 &shapeInfo,
    620                                                                 hitNormalLocal,
    621                                                                 hitPointLocal,
    622                                                                 hitFraction);
    623 
    624                                                         bool    normalInWorldSpace = false;
    625 
    626                                                         return m_resultCallback->addSingleResult(convexResult,normalInWorldSpace);
    627722                                                }
    628                                                 return hitFraction;
    629                                         }
    630 
    631                                 };
    632 
    633                                 BridgeTriangleConvexcastCallback tccb(castShape, convexFromTrans,convexToTrans,&resultCallback,collisionObject,concaveShape, colObjWorldTransform);
    634                                 tccb.m_hitFraction = resultCallback.m_closestHitFraction;
    635                                 btVector3 boxMinLocal, boxMaxLocal;
    636                                 castShape->getAabb(rotationXform, boxMinLocal, boxMaxLocal);
    637 
    638                                 btVector3 rayAabbMinLocal = convexFromLocal;
    639                                 rayAabbMinLocal.setMin(convexToLocal);
    640                                 btVector3 rayAabbMaxLocal = convexFromLocal;
    641                                 rayAabbMaxLocal.setMax(convexToLocal);
    642                                 rayAabbMinLocal += boxMinLocal;
    643                                 rayAabbMaxLocal += boxMaxLocal;
    644                                 concaveShape->processAllTriangles(&tccb,rayAabbMinLocal,rayAabbMaxLocal);
     723
     724
     725                                                virtual btScalar reportHit(const btVector3& hitNormalLocal, const btVector3& hitPointLocal, btScalar hitFraction, int partId, int triangleIndex )
     726                                                {
     727                                                        btCollisionWorld::LocalShapeInfo        shapeInfo;
     728                                                        shapeInfo.m_shapePart = partId;
     729                                                        shapeInfo.m_triangleIndex = triangleIndex;
     730                                                        if (hitFraction <= m_resultCallback->m_closestHitFraction)
     731                                                        {
     732
     733                                                                btCollisionWorld::LocalConvexResult convexResult
     734                                                                        (m_collisionObject,
     735                                                                        &shapeInfo,
     736                                                                        hitNormalLocal,
     737                                                                        hitPointLocal,
     738                                                                        hitFraction);
     739
     740                                                                bool    normalInWorldSpace = false;
     741
     742                                                                return m_resultCallback->addSingleResult(convexResult,normalInWorldSpace);
     743                                                        }
     744                                                        return hitFraction;
     745                                                }
     746
     747                                        };
     748
     749                                        BridgeTriangleConvexcastCallback tccb(castShape, convexFromTrans,convexToTrans,&resultCallback,collisionObject,concaveShape, colObjWorldTransform);
     750                                        tccb.m_hitFraction = resultCallback.m_closestHitFraction;
     751                                        tccb.m_allowedPenetration = allowedPenetration;
     752                                        btVector3 boxMinLocal, boxMaxLocal;
     753                                        castShape->getAabb(rotationXform, boxMinLocal, boxMaxLocal);
     754
     755                                        btVector3 rayAabbMinLocal = convexFromLocal;
     756                                        rayAabbMinLocal.setMin(convexToLocal);
     757                                        btVector3 rayAabbMaxLocal = convexFromLocal;
     758                                        rayAabbMaxLocal.setMax(convexToLocal);
     759                                        rayAabbMinLocal += boxMinLocal;
     760                                        rayAabbMaxLocal += boxMaxLocal;
     761                                        concaveShape->processAllTriangles(&tccb,rayAabbMinLocal,rayAabbMaxLocal);
     762                                }
    645763                        }
    646764                } else {
     
    667785                                                        {
    668786                                                                m_closestHitFraction = m_userCallback->m_closestHitFraction;
     787                                                        }
     788                                                        virtual bool needsCollision(btBroadphaseProxy* p) const
     789                                                        {
     790                                                                return m_userCallback->needsCollision(p);
    669791                                                        }
    670792                            virtual btScalar addSingleResult (btCollisionWorld::LocalConvexResult&      r,      bool b)
     
    11521274
    11531275                                int upAxis = capsuleShape->getUpAxis();
    1154 
    1155 
    1156                                 btVector3 capStart(0.f,0.f,0.f);
    1157                                 capStart[upAxis] = -halfHeight;
    1158 
    1159                                 btVector3 capEnd(0.f,0.f,0.f);
    1160                                 capEnd[upAxis] = halfHeight;
    1161 
    1162                                 // Draw the ends
    1163                                 {
    1164 
    1165                                         btTransform childTransform = worldTransform;
    1166                                         childTransform.getOrigin() = worldTransform * capStart;
    1167                                         getDebugDrawer()->drawSphere(radius, childTransform, color);
    1168                                 }
    1169 
    1170                                 {
    1171                                         btTransform childTransform = worldTransform;
    1172                                         childTransform.getOrigin() = worldTransform * capEnd;
    1173                                         getDebugDrawer()->drawSphere(radius, childTransform, color);
    1174                                 }
    1175 
    1176                                 // Draw some additional lines
    1177                                 btVector3 start = worldTransform.getOrigin();
    1178 
    1179 
    1180                                 capStart[(upAxis+1)%3] = radius;
    1181                                 capEnd[(upAxis+1)%3] = radius;
    1182                                 getDebugDrawer()->drawLine(start+worldTransform.getBasis() * capStart,start+worldTransform.getBasis() * capEnd, color);
    1183                                 capStart[(upAxis+1)%3] = -radius;
    1184                                 capEnd[(upAxis+1)%3] = -radius;
    1185                                 getDebugDrawer()->drawLine(start+worldTransform.getBasis() * capStart,start+worldTransform.getBasis() * capEnd, color);
    1186 
    1187                                 capStart[(upAxis+1)%3] = 0.f;
    1188                                 capEnd[(upAxis+1)%3] = 0.f;
    1189 
    1190                                 capStart[(upAxis+2)%3] = radius;
    1191                                 capEnd[(upAxis+2)%3] = radius;
    1192                                 getDebugDrawer()->drawLine(start+worldTransform.getBasis() * capStart,start+worldTransform.getBasis() * capEnd, color);
    1193                                 capStart[(upAxis+2)%3] = -radius;
    1194                                 capEnd[(upAxis+2)%3] = -radius;
    1195                                 getDebugDrawer()->drawLine(start+worldTransform.getBasis() * capStart,start+worldTransform.getBasis() * capEnd, color);
    1196 
    1197 
     1276                                getDebugDrawer()->drawCapsule(radius, halfHeight, upAxis, worldTransform, color);
    11981277                                break;
    11991278                        }
     
    12031282                                btScalar radius = coneShape->getRadius();//+coneShape->getMargin();
    12041283                                btScalar height = coneShape->getHeight();//+coneShape->getMargin();
    1205                                 btVector3 start = worldTransform.getOrigin();
    12061284
    12071285                                int upAxis= coneShape->getConeUpIndex();
    1208 
    1209 
    1210                                 btVector3       offsetHeight(0,0,0);
    1211                                 offsetHeight[upAxis] = height * btScalar(0.5);
    1212                                 btVector3       offsetRadius(0,0,0);
    1213                                 offsetRadius[(upAxis+1)%3] = radius;
    1214                                 btVector3       offset2Radius(0,0,0);
    1215                                 offset2Radius[(upAxis+2)%3] = radius;
    1216 
    1217                                 getDebugDrawer()->drawLine(start+worldTransform.getBasis() * (offsetHeight),start+worldTransform.getBasis() * (-offsetHeight+offsetRadius),color);
    1218                                 getDebugDrawer()->drawLine(start+worldTransform.getBasis() * (offsetHeight),start+worldTransform.getBasis() * (-offsetHeight-offsetRadius),color);
    1219                                 getDebugDrawer()->drawLine(start+worldTransform.getBasis() * (offsetHeight),start+worldTransform.getBasis() * (-offsetHeight+offset2Radius),color);
    1220                                 getDebugDrawer()->drawLine(start+worldTransform.getBasis() * (offsetHeight),start+worldTransform.getBasis() * (-offsetHeight-offset2Radius),color);
    1221 
    1222                                 // Drawing the base of the cone
    1223                                 btVector3 yaxis(0,0,0);
    1224                                 yaxis[upAxis] = btScalar(1.0);
    1225                                 btVector3 xaxis(0,0,0);
    1226                                 xaxis[(upAxis+1)%3] = btScalar(1.0);
    1227                                 getDebugDrawer()->drawArc(start-worldTransform.getBasis()*(offsetHeight),worldTransform.getBasis()*yaxis,worldTransform.getBasis()*xaxis,radius,radius,0,SIMD_2_PI,color,false,10.0);
    1228                 break;
     1286                                getDebugDrawer()->drawCone(radius, height, upAxis, worldTransform, color);
     1287                                break;
    12291288
    12301289                        }
     
    12351294                                btScalar radius = cylinder->getRadius();
    12361295                                btScalar halfHeight = cylinder->getHalfExtentsWithMargin()[upAxis];
    1237                                 btVector3 start = worldTransform.getOrigin();
    1238                                 btVector3       offsetHeight(0,0,0);
    1239                                 offsetHeight[upAxis] = halfHeight;
    1240                                 btVector3       offsetRadius(0,0,0);
    1241                                 offsetRadius[(upAxis+1)%3] = radius;
    1242                                 getDebugDrawer()->drawLine(start+worldTransform.getBasis() * (offsetHeight+offsetRadius),start+worldTransform.getBasis() * (-offsetHeight+offsetRadius),color);
    1243                                 getDebugDrawer()->drawLine(start+worldTransform.getBasis() * (offsetHeight-offsetRadius),start+worldTransform.getBasis() * (-offsetHeight-offsetRadius),color);
    1244 
    1245                                 // Drawing top and bottom caps of the cylinder
    1246                                 btVector3 yaxis(0,0,0);
    1247                                 yaxis[upAxis] = btScalar(1.0);
    1248                                 btVector3 xaxis(0,0,0);
    1249                                 xaxis[(upAxis+1)%3] = btScalar(1.0);
    1250                                 getDebugDrawer()->drawArc(start-worldTransform.getBasis()*(offsetHeight),worldTransform.getBasis()*yaxis,worldTransform.getBasis()*xaxis,radius,radius,0,SIMD_2_PI,color,false,btScalar(10.0));
    1251                                 getDebugDrawer()->drawArc(start+worldTransform.getBasis()*(offsetHeight),worldTransform.getBasis()*yaxis,worldTransform.getBasis()*xaxis,radius,radius,0,SIMD_2_PI,color,false,btScalar(10.0));
     1296                                getDebugDrawer()->drawCylinder(radius, halfHeight, upAxis, worldTransform, color);
    12521297                                break;
    12531298                        }
     
    12581303                                btScalar planeConst = staticPlaneShape->getPlaneConstant();
    12591304                                const btVector3& planeNormal = staticPlaneShape->getPlaneNormal();
    1260                                 btVector3 planeOrigin = planeNormal * planeConst;
    1261                                 btVector3 vec0,vec1;
    1262                                 btPlaneSpace1(planeNormal,vec0,vec1);
    1263                                 btScalar vecLen = 100.f;
    1264                                 btVector3 pt0 = planeOrigin + vec0*vecLen;
    1265                                 btVector3 pt1 = planeOrigin - vec0*vecLen;
    1266                                 btVector3 pt2 = planeOrigin + vec1*vecLen;
    1267                                 btVector3 pt3 = planeOrigin - vec1*vecLen;
    1268                                 getDebugDrawer()->drawLine(worldTransform*pt0,worldTransform*pt1,color);
    1269                                 getDebugDrawer()->drawLine(worldTransform*pt2,worldTransform*pt3,color);
     1305                                getDebugDrawer()->drawPlane(planeNormal, planeConst,worldTransform, color);
    12701306                                break;
    12711307
     
    13051341
    13061342                                        int i;
    1307                                         for (i=0;i<polyshape->getNumEdges();i++)
    1308                                         {
    1309                                                 btVector3 a,b;
    1310                                                 polyshape->getEdge(i,a,b);
    1311                                                 btVector3 wa = worldTransform * a;
    1312                                                 btVector3 wb = worldTransform * b;
    1313                                                 getDebugDrawer()->drawLine(wa,wb,color);
    1314 
     1343                                        if (polyshape->getConvexPolyhedron())
     1344                                        {
     1345                                                const btConvexPolyhedron* poly = polyshape->getConvexPolyhedron();
     1346                                                for (i=0;i<poly->m_faces.size();i++)
     1347                                                {
     1348                                                        btVector3 centroid(0,0,0);
     1349                                                        int numVerts = poly->m_faces[i].m_indices.size();
     1350                                                        if (numVerts)
     1351                                                        {
     1352                                                                int lastV = poly->m_faces[i].m_indices[numVerts-1];
     1353                                                                for (int v=0;v<poly->m_faces[i].m_indices.size();v++)
     1354                                                                {
     1355                                                                        int curVert = poly->m_faces[i].m_indices[v];
     1356                                                                        centroid+=poly->m_vertices[curVert];
     1357                                                                        getDebugDrawer()->drawLine(worldTransform*poly->m_vertices[lastV],worldTransform*poly->m_vertices[curVert],color);
     1358                                                                        lastV = curVert;
     1359                                                                }
     1360                                                        }
     1361                                                        centroid*= 1./btScalar(numVerts);
     1362
     1363                                                        btVector3 normalColor(1,1,0);
     1364                                                        btVector3 faceNormal(poly->m_faces[i].m_plane[0],poly->m_faces[i].m_plane[1],poly->m_faces[i].m_plane[2]);
     1365                                                        getDebugDrawer()->drawLine(worldTransform*centroid,worldTransform*(centroid+faceNormal),normalColor);
     1366                                                       
     1367                                                       
     1368                                                }
     1369
     1370                                               
     1371                                        } else
     1372                                        {
     1373                                                for (i=0;i<polyshape->getNumEdges();i++)
     1374                                                {
     1375                                                        btVector3 a,b;
     1376                                                        polyshape->getEdge(i,a,b);
     1377                                                        btVector3 wa = worldTransform * a;
     1378                                                        btVector3 wb = worldTransform * b;
     1379                                                        getDebugDrawer()->drawLine(wa,wb,color);
     1380                                                }
    13151381                                        }
    13161382
     
    13811447                                        btVector3 colorvec(1,0,0);
    13821448                                        colObj->getCollisionShape()->getAabb(colObj->getWorldTransform(), minAabb,maxAabb);
     1449                                        btVector3 contactThreshold(gContactBreakingThreshold,gContactBreakingThreshold,gContactBreakingThreshold);
     1450                                        minAabb -= contactThreshold;
     1451                                        maxAabb += contactThreshold;
     1452
     1453                                        btVector3 minAabb2,maxAabb2;
     1454
     1455                                        if(colObj->getInternalType()==btCollisionObject::CO_RIGID_BODY)
     1456                                        {
     1457                                                colObj->getCollisionShape()->getAabb(colObj->getInterpolationWorldTransform(),minAabb2,maxAabb2);
     1458                                                minAabb2 -= contactThreshold;
     1459                                                maxAabb2 += contactThreshold;
     1460                                                minAabb.setMin(minAabb2);
     1461                                                maxAabb.setMax(maxAabb2);
     1462                                        }
     1463
    13831464                                        m_debugDrawer->drawAabb(minAabb,maxAabb,colorvec);
    13841465                                }
  • code/trunk/src/external/bullet/BulletCollision/CollisionDispatch/btCollisionWorld.h

    r8351 r8393  
    6363 
    6464
    65 #ifndef COLLISION_WORLD_H
    66 #define COLLISION_WORLD_H
     65#ifndef BT_COLLISION_WORLD_H
     66#define BT_COLLISION_WORLD_H
    6767
    6868class btStackAlloc;
     
    507507
    508508
    509 #endif //COLLISION_WORLD_H
     509#endif //BT_COLLISION_WORLD_H
  • code/trunk/src/external/bullet/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.cpp

    r8351 r8393  
    235235                                        }
    236236                                }
    237                                 manifoldArray.clear();
     237                                manifoldArray.resize(0);
    238238                        }
    239239                }
  • code/trunk/src/external/bullet/BulletCollision/CollisionDispatch/btCompoundCollisionAlgorithm.h

    r5781 r8393  
    1414*/
    1515
    16 #ifndef COMPOUND_COLLISION_ALGORITHM_H
    17 #define COMPOUND_COLLISION_ALGORITHM_H
     16#ifndef BT_COMPOUND_COLLISION_ALGORITHM_H
     17#define BT_COMPOUND_COLLISION_ALGORITHM_H
    1818
    1919#include "btActivatingCollisionAlgorithm.h"
     
    8484};
    8585
    86 #endif //COMPOUND_COLLISION_ALGORITHM_H
     86#endif //BT_COMPOUND_COLLISION_ALGORITHM_H
  • code/trunk/src/external/bullet/BulletCollision/CollisionDispatch/btConvex2dConvex2dAlgorithm.h

    r8351 r8393  
    1414*/
    1515
    16 #ifndef CONVEX_2D_CONVEX_2D_ALGORITHM_H
    17 #define CONVEX_2D_CONVEX_2D_ALGORITHM_H
     16#ifndef BT_CONVEX_2D_CONVEX_2D_ALGORITHM_H
     17#define BT_CONVEX_2D_CONVEX_2D_ALGORITHM_H
    1818
    1919#include "BulletCollision/CollisionDispatch/btActivatingCollisionAlgorithm.h"
     
    9393};
    9494
    95 #endif //CONVEX_2D_CONVEX_2D_ALGORITHM_H
     95#endif //BT_CONVEX_2D_CONVEX_2D_ALGORITHM_H
  • code/trunk/src/external/bullet/BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.cpp

    r8351 r8393  
    9292
    9393
    94        
     94#if 0   
    9595        ///debug drawing of the overlapping triangles
    9696        if (m_dispatchInfoPtr && m_dispatchInfoPtr->m_debugDraw && (m_dispatchInfoPtr->m_debugDraw->getDebugMode() &btIDebugDraw::DBG_DrawWireframe ))
     
    101101                m_dispatchInfoPtr->m_debugDraw->drawLine(tr(triangle[1]),tr(triangle[2]),color);
    102102                m_dispatchInfoPtr->m_debugDraw->drawLine(tr(triangle[2]),tr(triangle[0]),color);
    103 
    104                 //btVector3 center = triangle[0] + triangle[1]+triangle[2];
    105                 //center *= btScalar(0.333333);
    106                 //m_dispatchInfoPtr->m_debugDraw->drawLine(tr(triangle[0]),tr(center),color);
    107                 //m_dispatchInfoPtr->m_debugDraw->drawLine(tr(triangle[1]),tr(center),color);
    108                 //m_dispatchInfoPtr->m_debugDraw->drawLine(tr(triangle[2]),tr(center),color);
    109 
    110         }
    111 
    112 
    113         //btCollisionObject* colObj = static_cast<btCollisionObject*>(m_convexProxy->m_clientObject);
     103        }
     104#endif
    114105       
    115106        if (m_convexBody->getCollisionShape()->isConvex())
     
    120111                btCollisionShape* tmpShape = ob->getCollisionShape();
    121112                ob->internalSetTemporaryCollisionShape( &tm );
    122                
     113
    123114                btCollisionAlgorithm* colAlgo = ci.m_dispatcher1->findAlgorithm(m_convexBody,m_triBody,m_manifoldPtr);
    124115
  • code/trunk/src/external/bullet/BulletCollision/CollisionDispatch/btConvexConcaveCollisionAlgorithm.h

    r5781 r8393  
    1414*/
    1515
    16 #ifndef CONVEX_CONCAVE_COLLISION_ALGORITHM_H
    17 #define CONVEX_CONCAVE_COLLISION_ALGORITHM_H
     16#ifndef BT_CONVEX_CONCAVE_COLLISION_ALGORITHM_H
     17#define BT_CONVEX_CONCAVE_COLLISION_ALGORITHM_H
    1818
    1919#include "btActivatingCollisionAlgorithm.h"
     
    114114};
    115115
    116 #endif //CONVEX_CONCAVE_COLLISION_ALGORITHM_H
     116#endif //BT_CONVEX_CONCAVE_COLLISION_ALGORITHM_H
  • code/trunk/src/external/bullet/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.cpp

    r8351 r8393  
    2727#include "BulletCollision/CollisionShapes/btConvexShape.h"
    2828#include "BulletCollision/CollisionShapes/btCapsuleShape.h"
     29#include "BulletCollision/CollisionShapes/btTriangleShape.h"
     30
    2931
    3032
     
    4951#include "BulletCollision/NarrowPhaseCollision/btGjkEpa2.h"
    5052#include "BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.h"
    51 
     53#include "BulletCollision/NarrowPhaseCollision/btPolyhedralContactClipping.h"
    5254
    5355
     
    332334
    333335
     336
     337
    334338#ifdef USE_SEPDISTANCE_UTIL2
    335339        if (dispatchInfo.m_useConvexConservativeDistanceUtil)
     
    358362#endif //USE_SEPDISTANCE_UTIL2
    359363        {
    360                 if (dispatchInfo.m_convexMaxDistanceUseCPT)
    361                 {
    362                         input.m_maximumDistanceSquared = min0->getMargin() + min1->getMargin() + m_manifoldPtr->getContactProcessingThreshold();
    363                 } else
    364                 {
    365                         input.m_maximumDistanceSquared = min0->getMargin() + min1->getMargin() + m_manifoldPtr->getContactBreakingThreshold();
    366                 }
     364                //if (dispatchInfo.m_convexMaxDistanceUseCPT)
     365                //{
     366                //      input.m_maximumDistanceSquared = min0->getMargin() + min1->getMargin() + m_manifoldPtr->getContactProcessingThreshold();
     367                //} else
     368                //{
     369                input.m_maximumDistanceSquared = min0->getMargin() + min1->getMargin() + m_manifoldPtr->getContactBreakingThreshold();
     370//              }
     371
    367372                input.m_maximumDistanceSquared*= input.m_maximumDistanceSquared;
    368373        }
     
    372377        input.m_transformB = body1->getWorldTransform();
    373378
    374         gjkPairDetector.getClosestPoints(input,*resultOut,dispatchInfo.m_debugDraw);
     379
    375380
    376381       
     
    389394        }
    390395#endif //USE_SEPDISTANCE_UTIL2
     396
     397        if (min0->isPolyhedral() && min1->isPolyhedral())
     398        {
     399
     400
     401                struct btDummyResult : public btDiscreteCollisionDetectorInterface::Result
     402                {
     403                        virtual void setShapeIdentifiersA(int partId0,int index0){}
     404                        virtual void setShapeIdentifiersB(int partId1,int index1){}
     405                        virtual void addContactPoint(const btVector3& normalOnBInWorld,const btVector3& pointInWorld,btScalar depth)
     406                        {
     407                        }
     408                };
     409               
     410                btDummyResult dummy;
     411
     412
     413                btPolyhedralConvexShape* polyhedronA = (btPolyhedralConvexShape*) min0;
     414                btPolyhedralConvexShape* polyhedronB = (btPolyhedralConvexShape*) min1;
     415                if (polyhedronA->getConvexPolyhedron() && polyhedronB->getConvexPolyhedron())
     416                {
     417
     418
     419                        gjkPairDetector.getClosestPoints(input,dummy,dispatchInfo.m_debugDraw);
     420                       
     421
     422                        btScalar threshold = m_manifoldPtr->getContactBreakingThreshold();
     423
     424                        btScalar minDist = 0.f;
     425                        btVector3 sepNormalWorldSpace;
     426                        bool foundSepAxis  = true;
     427
     428                        if (dispatchInfo.m_enableSatConvex)
     429                        {
     430                                foundSepAxis = btPolyhedralContactClipping::findSeparatingAxis(
     431                                        *polyhedronA->getConvexPolyhedron(), *polyhedronB->getConvexPolyhedron(),
     432                                        body0->getWorldTransform(),
     433                                        body1->getWorldTransform(),
     434                                        sepNormalWorldSpace);
     435                        } else
     436                        {
     437                                sepNormalWorldSpace = gjkPairDetector.getCachedSeparatingAxis().normalized();
     438                                minDist = gjkPairDetector.getCachedSeparatingDistance();
     439                        }
     440                        if (foundSepAxis)
     441                        {
     442//                              printf("sepNormalWorldSpace=%f,%f,%f\n",sepNormalWorldSpace.getX(),sepNormalWorldSpace.getY(),sepNormalWorldSpace.getZ());
     443
     444                                btPolyhedralContactClipping::clipHullAgainstHull(sepNormalWorldSpace, *polyhedronA->getConvexPolyhedron(), *polyhedronB->getConvexPolyhedron(),
     445                                        body0->getWorldTransform(),
     446                                        body1->getWorldTransform(), minDist-threshold, threshold, *resultOut);
     447                               
     448                        }
     449                        if (m_ownManifold)
     450                        {
     451                                resultOut->refreshContactPoints();
     452                        }
     453                        return;
     454
     455                } else
     456                {
     457                        //we can also deal with convex versus triangle (without connectivity data)
     458                        if (polyhedronA->getConvexPolyhedron() && polyhedronB->getShapeType()==TRIANGLE_SHAPE_PROXYTYPE)
     459                        {
     460                                gjkPairDetector.getClosestPoints(input,dummy,dispatchInfo.m_debugDraw);
     461               
     462                                btVector3 sepNormalWorldSpace = gjkPairDetector.getCachedSeparatingAxis().normalized();
     463
     464                                btVertexArray vertices;
     465                                btTriangleShape* tri = (btTriangleShape*)polyhedronB;
     466                                vertices.push_back(     body1->getWorldTransform()*tri->m_vertices1[0]);
     467                                vertices.push_back(     body1->getWorldTransform()*tri->m_vertices1[1]);
     468                                vertices.push_back(     body1->getWorldTransform()*tri->m_vertices1[2]);
     469
     470                                btScalar threshold = m_manifoldPtr->getContactBreakingThreshold();
     471                                btScalar minDist = gjkPairDetector.getCachedSeparatingDistance();
     472                                btPolyhedralContactClipping::clipFaceAgainstHull(sepNormalWorldSpace, *polyhedronA->getConvexPolyhedron(),
     473                                        body0->getWorldTransform(), vertices, minDist-threshold, threshold, *resultOut);
     474                               
     475                               
     476                                if (m_ownManifold)
     477                                {
     478                                        resultOut->refreshContactPoints();
     479                                }
     480                               
     481                                return;
     482                        }
     483                       
     484                }
     485
     486
     487        }
     488       
     489        gjkPairDetector.getClosestPoints(input,*resultOut,dispatchInfo.m_debugDraw);
    391490
    392491        //now perform 'm_numPerturbationIterations' collision queries with the perturbated collision objects
  • code/trunk/src/external/bullet/BulletCollision/CollisionDispatch/btConvexConvexAlgorithm.h

    r8351 r8393  
    1414*/
    1515
    16 #ifndef CONVEX_CONVEX_ALGORITHM_H
    17 #define CONVEX_CONVEX_ALGORITHM_H
     16#ifndef BT_CONVEX_CONVEX_ALGORITHM_H
     17#define BT_CONVEX_CONVEX_ALGORITHM_H
    1818
    1919#include "btActivatingCollisionAlgorithm.h"
     
    107107};
    108108
    109 #endif //CONVEX_CONVEX_ALGORITHM_H
     109#endif //BT_CONVEX_CONVEX_ALGORITHM_H
  • code/trunk/src/external/bullet/BulletCollision/CollisionDispatch/btConvexPlaneCollisionAlgorithm.h

    r8351 r8393  
    1414*/
    1515
    16 #ifndef CONVEX_PLANE_COLLISION_ALGORITHM_H
    17 #define CONVEX_PLANE_COLLISION_ALGORITHM_H
     16#ifndef BT_CONVEX_PLANE_COLLISION_ALGORITHM_H
     17#define BT_CONVEX_PLANE_COLLISION_ALGORITHM_H
    1818
    1919#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
     
    8181};
    8282
    83 #endif //CONVEX_PLANE_COLLISION_ALGORITHM_H
     83#endif //BT_CONVEX_PLANE_COLLISION_ALGORITHM_H
    8484
  • code/trunk/src/external/bullet/BulletCollision/CollisionDispatch/btEmptyCollisionAlgorithm.h

    r5781 r8393  
    1414*/
    1515
    16 #ifndef EMPTY_ALGORITH
    17 #define EMPTY_ALGORITH
     16#ifndef BT_EMPTY_ALGORITH
     17#define BT_EMPTY_ALGORITH
    1818#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
    1919#include "btCollisionCreateFunc.h"
     
    5252} ATTRIBUTE_ALIGNED(16);
    5353
    54 #endif //EMPTY_ALGORITH
     54#endif //BT_EMPTY_ALGORITH
  • code/trunk/src/external/bullet/BulletCollision/CollisionDispatch/btInternalEdgeUtility.cpp

    r8351 r8393  
    22
    33#include "BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h"
     4#include "BulletCollision/CollisionShapes/btScaledBvhTriangleMeshShape.h"
    45#include "BulletCollision/CollisionShapes/btTriangleShape.h"
    56#include "BulletCollision/CollisionDispatch/btCollisionObject.h"
     
    910
    1011//#define DEBUG_INTERNAL_EDGE
    11 
    1212
    1313#ifdef DEBUG_INTERNAL_EDGE
     
    457457                return;
    458458
    459         btBvhTriangleMeshShape* trimesh = (btBvhTriangleMeshShape*)colObj0->getRootCollisionShape();
    460         btTriangleInfoMap* triangleInfoMapPtr = (btTriangleInfoMap*) trimesh->getTriangleInfoMap();
     459        btBvhTriangleMeshShape* trimesh = 0;
     460       
     461        if( colObj0->getRootCollisionShape()->getShapeType() == SCALED_TRIANGLE_MESH_SHAPE_PROXYTYPE )
     462           trimesh = ((btScaledBvhTriangleMeshShape*)colObj0->getRootCollisionShape())->getChildShape();
     463   else   
     464           trimesh = (btBvhTriangleMeshShape*)colObj0->getRootCollisionShape();
     465           
     466        btTriangleInfoMap* triangleInfoMapPtr = (btTriangleInfoMap*) trimesh->getTriangleInfoMap();
    461467        if (!triangleInfoMapPtr)
    462468                return;
     
    502508        btVector3 localContactNormalOnB = colObj0->getWorldTransform().getBasis().transpose() * cp.m_normalWorldOnB;
    503509        localContactNormalOnB.normalize();//is this necessary?
    504 
    505         if ((info->m_edgeV0V1Angle)< SIMD_2_PI)
     510       
     511        // Get closest edge
     512        int      bestedge=-1;
     513        float    disttobestedge=BT_LARGE_FLOAT;
     514        //
     515        // Edge 0 -> 1
     516        if (btFabs(info->m_edgeV0V1Angle)< triangleInfoMapPtr->m_maxEdgeAngleThreshold)
     517        {       
     518           btVector3 nearest;
     519           btNearestPointInLineSegment( cp.m_localPointB, v0, v1, nearest );
     520           float     len=(contact-nearest).length();
     521           //
     522           if( len < disttobestedge )
     523           {
     524              bestedge=0;
     525              disttobestedge=len;
     526      }       
     527   }       
     528        // Edge 1 -> 2
     529        if (btFabs(info->m_edgeV1V2Angle)< triangleInfoMapPtr->m_maxEdgeAngleThreshold)
     530        {       
     531           btVector3 nearest;
     532           btNearestPointInLineSegment( cp.m_localPointB, v1, v2, nearest );
     533           float     len=(contact-nearest).length();
     534           //
     535           if( len < disttobestedge )
     536           {
     537              bestedge=1;
     538              disttobestedge=len;
     539      }       
     540   }       
     541        // Edge 2 -> 0
     542        if (btFabs(info->m_edgeV2V0Angle)< triangleInfoMapPtr->m_maxEdgeAngleThreshold)
     543        {       
     544           btVector3 nearest;
     545           btNearestPointInLineSegment( cp.m_localPointB, v2, v0, nearest );
     546           float     len=(contact-nearest).length();
     547           //
     548           if( len < disttobestedge )
     549           {
     550              bestedge=2;
     551              disttobestedge=len;
     552      }       
     553   }           
     554       
     555#ifdef BT_INTERNAL_EDGE_DEBUG_DRAW
     556   btVector3 upfix=tri_normal * btVector3(0.1f,0.1f,0.1f);
     557   btDebugDrawLine(tr * v0 + upfix, tr * v1 + upfix, red );
     558#endif   
     559        if (btFabs(info->m_edgeV0V1Angle)< triangleInfoMapPtr->m_maxEdgeAngleThreshold)
    506560        {
    507561#ifdef BT_INTERNAL_EDGE_DEBUG_DRAW
     
    510564                btScalar len = (contact-nearest).length();
    511565                if(len<triangleInfoMapPtr->m_edgeDistanceThreshold)
     566                if( bestedge==0 )
    512567                {
    513568                        btVector3 edge(v0-v1);
     
    578633#endif //BT_INTERNAL_EDGE_DEBUG_DRAW
    579634
    580         if ((info->m_edgeV1V2Angle)< SIMD_2_PI)
     635#ifdef BT_INTERNAL_EDGE_DEBUG_DRAW
     636   btDebugDrawLine(tr * v1 + upfix, tr * v2 + upfix , green );
     637#endif   
     638
     639        if (btFabs(info->m_edgeV1V2Angle)< triangleInfoMapPtr->m_maxEdgeAngleThreshold)
    581640        {
    582641#ifdef BT_INTERNAL_EDGE_DEBUG_DRAW
     
    588647                btScalar len = (contact-nearest).length();
    589648                if(len<triangleInfoMapPtr->m_edgeDistanceThreshold)
     649                if( bestedge==1 )
    590650                {
    591651                        isNearEdge = true;
     
    659719        btDebugDrawLine(tr*nearest,tr*cp.m_localPointB,blue);
    660720#endif //BT_INTERNAL_EDGE_DEBUG_DRAW
    661 
    662         if ((info->m_edgeV2V0Angle)< SIMD_2_PI)
     721#ifdef BT_INTERNAL_EDGE_DEBUG_DRAW
     722   btDebugDrawLine(tr * v2 + upfix, tr * v0 + upfix , blue );
     723#endif   
     724
     725        if (btFabs(info->m_edgeV2V0Angle)< triangleInfoMapPtr->m_maxEdgeAngleThreshold)
    663726        {
    664727
     
    669732                btScalar len = (contact-nearest).length();
    670733                if(len<triangleInfoMapPtr->m_edgeDistanceThreshold)
     734                if( bestedge==2 )
    671735                {
    672736                        isNearEdge = true;
     
    760824                        } else
    761825                        {
     826                                btVector3 newNormal = tri_normal *frontFacing;
     827                                //if the tri_normal is pointing opposite direction as the current local contact normal, skip it
     828                                btScalar d = newNormal.dot(localContactNormalOnB) ;
     829                                if (d< 0)
     830                                {
     831                                        return;
     832                                }
    762833                                //modify the normal to be the triangle normal (or backfacing normal)
    763                                 cp.m_normalWorldOnB = colObj0->getWorldTransform().getBasis() *(tri_normal *frontFacing);
    764                         }
    765                        
    766                        
     834                                cp.m_normalWorldOnB = colObj0->getWorldTransform().getBasis() *newNormal;
     835                        }
     836                                               
    767837                        // Reproject collision point along normal.
    768838                        cp.m_positionWorldOnB = cp.m_positionWorldOnA - cp.m_normalWorldOnB * cp.m_distance1;
  • code/trunk/src/external/bullet/BulletCollision/CollisionDispatch/btManifoldResult.cpp

    r8351 r8393  
    6464        btAssert(m_manifoldPtr);
    6565        //order in manifold needs to match
    66        
    67         if (depth > m_manifoldPtr->getContactBreakingThreshold())
     66
     67//      if (depth > m_manifoldPtr->getContactBreakingThreshold())
     68        if (depth > m_manifoldPtr->getContactProcessingThreshold())
    6869                return;
    6970
  • code/trunk/src/external/bullet/BulletCollision/CollisionDispatch/btManifoldResult.h

    r8351 r8393  
    1515
    1616
    17 #ifndef MANIFOLD_RESULT_H
    18 #define MANIFOLD_RESULT_H
     17#ifndef BT_MANIFOLD_RESULT_H
     18#define BT_MANIFOLD_RESULT_H
    1919
    2020class btCollisionObject;
     
    126126};
    127127
    128 #endif //MANIFOLD_RESULT_H
     128#endif //BT_MANIFOLD_RESULT_H
  • code/trunk/src/external/bullet/BulletCollision/CollisionDispatch/btSimulationIslandManager.cpp

    r8351 r8393  
    393393
    394394
    395                            bool islandSleeping = false;
     395                           bool islandSleeping = true;
    396396                       
    397397                                        for (endIslandIndex = startIslandIndex;(endIslandIndex<numElem) && (getUnionFind().getElement(endIslandIndex).m_id == islandId);endIslandIndex++)
     
    400400                                                        btCollisionObject* colObj0 = collisionObjects[i];
    401401                                                        m_islandBodies.push_back(colObj0);
    402                                                         if (!colObj0->isActive())
    403                                                                         islandSleeping = true;
     402                                                        if (colObj0->isActive())
     403                                                                        islandSleeping = false;
    404404                                        }
    405405                       
  • code/trunk/src/external/bullet/BulletCollision/CollisionDispatch/btSimulationIslandManager.h

    r5781 r8393  
    1414*/
    1515
    16 #ifndef SIMULATION_ISLAND_MANAGER_H
    17 #define SIMULATION_ISLAND_MANAGER_H
     16#ifndef BT_SIMULATION_ISLAND_MANAGER_H
     17#define BT_SIMULATION_ISLAND_MANAGER_H
    1818
    1919#include "BulletCollision/CollisionDispatch/btUnionFind.h"
     
    7878};
    7979
    80 #endif //SIMULATION_ISLAND_MANAGER_H
     80#endif //BT_SIMULATION_ISLAND_MANAGER_H
    8181
  • code/trunk/src/external/bullet/BulletCollision/CollisionDispatch/btSphereBoxCollisionAlgorithm.h

    r5781 r8393  
    1414*/
    1515
    16 #ifndef SPHERE_BOX_COLLISION_ALGORITHM_H
    17 #define SPHERE_BOX_COLLISION_ALGORITHM_H
     16#ifndef BT_SPHERE_BOX_COLLISION_ALGORITHM_H
     17#define BT_SPHERE_BOX_COLLISION_ALGORITHM_H
    1818
    1919#include "btActivatingCollisionAlgorithm.h"
     
    7272};
    7373
    74 #endif //SPHERE_BOX_COLLISION_ALGORITHM_H
     74#endif //BT_SPHERE_BOX_COLLISION_ALGORITHM_H
    7575
  • code/trunk/src/external/bullet/BulletCollision/CollisionDispatch/btSphereSphereCollisionAlgorithm.h

    r5781 r8393  
    1414*/
    1515
    16 #ifndef SPHERE_SPHERE_COLLISION_ALGORITHM_H
    17 #define SPHERE_SPHERE_COLLISION_ALGORITHM_H
     16#ifndef BT_SPHERE_SPHERE_COLLISION_ALGORITHM_H
     17#define BT_SPHERE_SPHERE_COLLISION_ALGORITHM_H
    1818
    1919#include "btActivatingCollisionAlgorithm.h"
     
    6363};
    6464
    65 #endif //SPHERE_SPHERE_COLLISION_ALGORITHM_H
     65#endif //BT_SPHERE_SPHERE_COLLISION_ALGORITHM_H
    6666
  • code/trunk/src/external/bullet/BulletCollision/CollisionDispatch/btSphereTriangleCollisionAlgorithm.h

    r5781 r8393  
    1414*/
    1515
    16 #ifndef SPHERE_TRIANGLE_COLLISION_ALGORITHM_H
    17 #define SPHERE_TRIANGLE_COLLISION_ALGORITHM_H
     16#ifndef BT_SPHERE_TRIANGLE_COLLISION_ALGORITHM_H
     17#define BT_SPHERE_TRIANGLE_COLLISION_ALGORITHM_H
    1818
    1919#include "btActivatingCollisionAlgorithm.h"
     
    6666};
    6767
    68 #endif //SPHERE_TRIANGLE_COLLISION_ALGORITHM_H
     68#endif //BT_SPHERE_TRIANGLE_COLLISION_ALGORITHM_H
    6969
  • code/trunk/src/external/bullet/BulletCollision/CollisionDispatch/btUnionFind.h

    r8351 r8393  
    1414*/
    1515
    16 #ifndef UNION_FIND_H
    17 #define UNION_FIND_H
     16#ifndef BT_UNION_FIND_H
     17#define BT_UNION_FIND_H
    1818
    1919#include "LinearMath/btAlignedObjectArray.h"
     
    127127
    128128
    129 #endif //UNION_FIND_H
     129#endif //BT_UNION_FIND_H
  • code/trunk/src/external/bullet/BulletCollision/CollisionShapes/btBox2dShape.h

    r8351 r8393  
    1414*/
    1515
    16 #ifndef OBB_BOX_2D_SHAPE_H
    17 #define OBB_BOX_2D_SHAPE_H
     16#ifndef BT_OBB_BOX_2D_SHAPE_H
     17#define BT_OBB_BOX_2D_SHAPE_H
    1818
    1919#include "BulletCollision/CollisionShapes/btPolyhedralConvexShape.h"
     
    359359};
    360360
    361 #endif //OBB_BOX_2D_SHAPE_H
    362 
    363 
     361#endif //BT_OBB_BOX_2D_SHAPE_H
     362
     363
  • code/trunk/src/external/bullet/BulletCollision/CollisionShapes/btBoxShape.h

    r8351 r8393  
    1414*/
    1515
    16 #ifndef OBB_BOX_MINKOWSKI_H
    17 #define OBB_BOX_MINKOWSKI_H
     16#ifndef BT_OBB_BOX_MINKOWSKI_H
     17#define BT_OBB_BOX_MINKOWSKI_H
    1818
    1919#include "btPolyhedralConvexShape.h"
     
    146146        virtual void getVertex(int i,btVector3& vtx) const
    147147        {
    148                 btVector3 halfExtents = getHalfExtentsWithoutMargin();
     148                btVector3 halfExtents = getHalfExtentsWithMargin();
    149149
    150150                vtx = btVector3(
     
    314314
    315315
    316 #endif //OBB_BOX_MINKOWSKI_H
    317 
    318 
     316#endif //BT_OBB_BOX_MINKOWSKI_H
     317
     318
  • code/trunk/src/external/bullet/BulletCollision/CollisionShapes/btBvhTriangleMeshShape.cpp

    r8351 r8393  
    278278
    279279                        unsigned int* gfxbase = (unsigned int*)(indexbase+nodeTriangleIndex*indexstride);
    280                         btAssert(indicestype==PHY_INTEGER||indicestype==PHY_SHORT);
     280                        btAssert(indicestype==PHY_INTEGER||indicestype==PHY_SHORT||indicestype==PHY_UCHAR);
    281281       
    282282                        const btVector3& meshScaling = m_meshInterface->getScaling();
     
    284284                        {
    285285                               
    286                                 int graphicsindex = indicestype==PHY_SHORT?((unsigned short*)gfxbase)[j]:gfxbase[j];
     286                                int graphicsindex = indicestype==PHY_SHORT?((unsigned short*)gfxbase)[j]:indicestype==PHY_INTEGER?gfxbase[j]:((unsigned char*)gfxbase)[j];
    287287
    288288
  • code/trunk/src/external/bullet/BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h

    r8351 r8393  
    1414*/
    1515
    16 #ifndef BVH_TRIANGLE_MESH_SHAPE_H
    17 #define BVH_TRIANGLE_MESH_SHAPE_H
     16#ifndef BT_BVH_TRIANGLE_MESH_SHAPE_H
     17#define BT_BVH_TRIANGLE_MESH_SHAPE_H
    1818
    1919#include "btTriangleMeshShape.h"
     
    4040        BT_DECLARE_ALIGNED_ALLOCATOR();
    4141
    42         btBvhTriangleMeshShape() : btTriangleMeshShape(0),m_bvh(0),m_triangleInfoMap(0),m_ownsBvh(false) {m_shapeType = TRIANGLE_MESH_SHAPE_PROXYTYPE;};
     42       
    4343        btBvhTriangleMeshShape(btStridingMeshInterface* meshInterface, bool useQuantizedAabbCompression, bool buildBvh = true);
    4444
     
    137137
    138138
    139 #endif //BVH_TRIANGLE_MESH_SHAPE_H
     139#endif //BT_BVH_TRIANGLE_MESH_SHAPE_H
  • code/trunk/src/external/bullet/BulletCollision/CollisionShapes/btCollisionMargin.h

    r8351 r8393  
    1414*/
    1515
    16 #ifndef COLLISION_MARGIN_H
    17 #define COLLISION_MARGIN_H
     16#ifndef BT_COLLISION_MARGIN_H
     17#define BT_COLLISION_MARGIN_H
    1818
    1919//used by Gjk and some other algorithms
     
    2323
    2424
    25 #endif //COLLISION_MARGIN_H
     25#endif //BT_COLLISION_MARGIN_H
    2626
  • code/trunk/src/external/bullet/BulletCollision/CollisionShapes/btCollisionShape.h

    r8351 r8393  
    1414*/
    1515
    16 #ifndef COLLISION_SHAPE_H
    17 #define COLLISION_SHAPE_H
     16#ifndef BT_COLLISION_SHAPE_H
     17#define BT_COLLISION_SHAPE_H
    1818
    1919#include "LinearMath/btTransform.h"
     
    147147
    148148
    149 #endif //COLLISION_SHAPE_H
     149#endif //BT_COLLISION_SHAPE_H
    150150
  • code/trunk/src/external/bullet/BulletCollision/CollisionShapes/btCompoundShape.cpp

    r8351 r8393  
    8686}
    8787
    88 void    btCompoundShape::updateChildTransform(int childIndex, const btTransform& newChildTransform)
     88void    btCompoundShape::updateChildTransform(int childIndex, const btTransform& newChildTransform,bool shouldRecalculateLocalAabb)
    8989{
    9090        m_children[childIndex].m_transform = newChildTransform;
     
    100100        }
    101101
    102         recalculateLocalAabb();
     102        if (shouldRecalculateLocalAabb)
     103        {
     104                recalculateLocalAabb();
     105        }
    103106}
    104107
     
    284287                m_children[i].m_childShape->setLocalScaling(childScale);
    285288                childTrans.setOrigin((childTrans.getOrigin())*scaling);
    286                 updateChildTransform(i, childTrans);
    287                 recalculateLocalAabb();
    288         }
     289                updateChildTransform(i, childTrans,false);
     290        }
     291       
    289292        m_localScaling = scaling;
     293        recalculateLocalAabb();
     294
    290295}
    291296
  • code/trunk/src/external/bullet/BulletCollision/CollisionShapes/btCompoundShape.h

    r8351 r8393  
    1414*/
    1515
    16 #ifndef COMPOUND_SHAPE_H
    17 #define COMPOUND_SHAPE_H
     16#ifndef BT_COMPOUND_SHAPE_H
     17#define BT_COMPOUND_SHAPE_H
    1818
    1919#include "btCollisionShape.h"
     
    107107
    108108        ///set a new transform for a child, and update internal data structures (local aabb and dynamic tree)
    109         void    updateChildTransform(int childIndex, const btTransform& newChildTransform);
     109        void    updateChildTransform(int childIndex, const btTransform& newChildTransform, bool shouldRecalculateLocalAabb = true);
    110110
    111111
     
    144144        }
    145145
    146 
    147         btDbvt*                                                 getDynamicAabbTree()
     146        const btDbvt*   getDynamicAabbTree() const
     147        {
     148                return m_dynamicAabbTree;
     149        }
     150       
     151        btDbvt* getDynamicAabbTree()
    148152        {
    149153                return m_dynamicAabbTree;
     
    206210
    207211
    208 #endif //COMPOUND_SHAPE_H
     212#endif //BT_COMPOUND_SHAPE_H
  • code/trunk/src/external/bullet/BulletCollision/CollisionShapes/btConcaveShape.h

    r8351 r8393  
    1414*/
    1515
    16 #ifndef CONCAVE_SHAPE_H
    17 #define CONCAVE_SHAPE_H
     16#ifndef BT_CONCAVE_SHAPE_H
     17#define BT_CONCAVE_SHAPE_H
    1818
    1919#include "btCollisionShape.h"
     
    5858};
    5959
    60 #endif //CONCAVE_SHAPE_H
     60#endif //BT_CONCAVE_SHAPE_H
  • code/trunk/src/external/bullet/BulletCollision/CollisionShapes/btConeShape.cpp

    r8351 r8393  
    132132
    133133
     134void    btConeShape::setLocalScaling(const btVector3& scaling)
     135{
     136        int axis = m_coneIndices[1];
     137        int r1 = m_coneIndices[0];
     138        int r2 = m_coneIndices[2];
     139        m_height *= scaling[axis] / m_localScaling[axis];
     140        m_radius *= (scaling[r1] / m_localScaling[r1] + scaling[r2] / m_localScaling[r2]) / 2;
     141        m_sinAngle = (m_radius / btSqrt(m_radius * m_radius + m_height * m_height));
     142        btConvexInternalShape::setLocalScaling(scaling);
     143}
  • code/trunk/src/external/bullet/BulletCollision/CollisionShapes/btConeShape.h

    r8351 r8393  
    1414*/
    1515
    16 #ifndef CONE_MINKOWSKI_H
    17 #define CONE_MINKOWSKI_H
     16#ifndef BT_CONE_MINKOWSKI_H
     17#define BT_CONE_MINKOWSKI_H
    1818
    1919#include "btConvexInternalShape.h"
     
    8282                        return m_coneIndices[1];
    8383                }
     84
     85        virtual void    setLocalScaling(const btVector3& scaling);
     86
    8487};
    8588
     
    97100                btConeShapeZ(btScalar radius,btScalar height);
    98101};
    99 #endif //CONE_MINKOWSKI_H
     102#endif //BT_CONE_MINKOWSKI_H
    100103
  • code/trunk/src/external/bullet/BulletCollision/CollisionShapes/btConvex2dShape.h

    r8351 r8393  
    2020#include "BulletCollision/BroadphaseCollision/btBroadphaseProxy.h" // for the types
    2121
    22 ///The btConvex2dShape allows to use arbitrary convex shapes are 2d convex shapes, with the Z component assumed to be 0.
     22///The btConvex2dShape allows to use arbitrary convex shapes as 2d convex shapes, with the Z component assumed to be 0.
    2323///For 2d boxes, the btBox2dShape is recommended.
    2424class btConvex2dShape : public btConvexShape
  • code/trunk/src/external/bullet/BulletCollision/CollisionShapes/btConvexHullShape.h

    r8351 r8393  
    1414*/
    1515
    16 #ifndef CONVEX_HULL_SHAPE_H
    17 #define CONVEX_HULL_SHAPE_H
     16#ifndef BT_CONVEX_HULL_SHAPE_H
     17#define BT_CONVEX_HULL_SHAPE_H
    1818
    1919#include "btPolyhedralConvexShape.h"
     
    117117
    118118
    119 #endif //CONVEX_HULL_SHAPE_H
     119#endif //BT_CONVEX_HULL_SHAPE_H
    120120
  • code/trunk/src/external/bullet/BulletCollision/CollisionShapes/btConvexShape.h

    r8351 r8393  
    1414*/
    1515
    16 #ifndef CONVEX_SHAPE_INTERFACE1
    17 #define CONVEX_SHAPE_INTERFACE1
     16#ifndef BT_CONVEX_SHAPE_INTERFACE1
     17#define BT_CONVEX_SHAPE_INTERFACE1
    1818
    1919#include "btCollisionShape.h"
     
    8080
    8181
    82 #endif //CONVEX_SHAPE_INTERFACE1
     82#endif //BT_CONVEX_SHAPE_INTERFACE1
  • code/trunk/src/external/bullet/BulletCollision/CollisionShapes/btConvexTriangleMeshShape.h

    r8351 r8393  
    13133. This notice may not be removed or altered from any source distribution.
    1414*/
    15 #ifndef CONVEX_TRIANGLEMESH_SHAPE_H
    16 #define CONVEX_TRIANGLEMESH_SHAPE_H
     15#ifndef BT_CONVEX_TRIANGLEMESH_SHAPE_H
     16#define BT_CONVEX_TRIANGLEMESH_SHAPE_H
    1717
    1818
     
    7070
    7171
    72 #endif //CONVEX_TRIANGLEMESH_SHAPE_H
     72#endif //BT_CONVEX_TRIANGLEMESH_SHAPE_H
    7373
    7474
  • code/trunk/src/external/bullet/BulletCollision/CollisionShapes/btCylinderShape.cpp

    r8351 r8393  
    4848void    btCylinderShape::calculateLocalInertia(btScalar mass,btVector3& inertia) const
    4949{
    50         //approximation of box shape, todo: implement cylinder shape inertia before people notice ;-)
     50
     51//Until Bullet 2.77 a box approximation was used, so uncomment this if you need backwards compatibility
     52//#define USE_BOX_INERTIA_APPROXIMATION 1
     53#ifndef USE_BOX_INERTIA_APPROXIMATION
     54
     55        /*
     56        cylinder is defined as following:
     57        *
     58        * - principle axis aligned along y by default, radius in x, z-value not used
     59        * - for btCylinderShapeX: principle axis aligned along x, radius in y direction, z-value not used
     60        * - for btCylinderShapeZ: principle axis aligned along z, radius in x direction, y-value not used
     61        *
     62        */
     63
     64        btScalar radius2;       // square of cylinder radius
     65        btScalar height2;       // square of cylinder height
     66        btVector3 halfExtents = getHalfExtentsWithMargin();     // get cylinder dimension
     67        btScalar div12 = mass / 12.f;
     68        btScalar div4 = mass / 4.f;
     69        btScalar div2 = mass / 2.f;
     70        int idxRadius, idxHeight;
     71
     72        switch (m_upAxis)       // get indices of radius and height of cylinder
     73        {
     74                case 0:         // cylinder is aligned along x
     75                        idxRadius = 1;
     76                        idxHeight = 0;
     77                        break;
     78                case 2:         // cylinder is aligned along z
     79                        idxRadius = 0;
     80                        idxHeight = 2;
     81                        break;
     82                default:        // cylinder is aligned along y
     83                        idxRadius = 0;
     84                        idxHeight = 1;
     85        }
     86
     87        // calculate squares
     88        radius2 = halfExtents[idxRadius] * halfExtents[idxRadius];
     89        height2 = btScalar(4.) * halfExtents[idxHeight] * halfExtents[idxHeight];
     90
     91        // calculate tensor terms
     92        btScalar t1 = div12 * height2 + div4 * radius2;
     93        btScalar t2 = div2 * radius2;
     94
     95        switch (m_upAxis)       // set diagonal elements of inertia tensor
     96        {
     97                case 0:         // cylinder is aligned along x
     98                        inertia.setValue(t2,t1,t1);
     99                        break;
     100                case 2:         // cylinder is aligned along z
     101                        inertia.setValue(t1,t1,t2);
     102                        break;
     103                default:        // cylinder is aligned along y
     104                        inertia.setValue(t1,t2,t1);
     105        }
     106#else //USE_BOX_INERTIA_APPROXIMATION
     107        //approximation of box shape
    51108        btVector3 halfExtents = getHalfExtentsWithMargin();
    52109
     
    58115                                        mass/(btScalar(12.0)) * (lx*lx + lz*lz),
    59116                                        mass/(btScalar(12.0)) * (lx*lx + ly*ly));
    60 
     117#endif //USE_BOX_INERTIA_APPROXIMATION
    61118}
    62119
  • code/trunk/src/external/bullet/BulletCollision/CollisionShapes/btCylinderShape.h

    r8351 r8393  
    1414*/
    1515
    16 #ifndef CYLINDER_MINKOWSKI_H
    17 #define CYLINDER_MINKOWSKI_H
     16#ifndef BT_CYLINDER_MINKOWSKI_H
     17#define BT_CYLINDER_MINKOWSKI_H
    1818
    1919#include "btBoxShape.h"
     
    197197
    198198
    199 #endif //CYLINDER_MINKOWSKI_H
    200 
     199#endif //BT_CYLINDER_MINKOWSKI_H
     200
  • code/trunk/src/external/bullet/BulletCollision/CollisionShapes/btEmptyShape.h

    r8351 r8393  
    1414*/
    1515
    16 #ifndef EMPTY_SHAPE_H
    17 #define EMPTY_SHAPE_H
     16#ifndef BT_EMPTY_SHAPE_H
     17#define BT_EMPTY_SHAPE_H
    1818
    1919#include "btConcaveShape.h"
     
    6868
    6969
    70 #endif //EMPTY_SHAPE_H
     70#endif //BT_EMPTY_SHAPE_H
  • code/trunk/src/external/bullet/BulletCollision/CollisionShapes/btHeightfieldTerrainShape.h

    r8351 r8393  
    1414*/
    1515
    16 #ifndef HEIGHTFIELD_TERRAIN_SHAPE_H
    17 #define HEIGHTFIELD_TERRAIN_SHAPE_H
     16#ifndef BT_HEIGHTFIELD_TERRAIN_SHAPE_H
     17#define BT_HEIGHTFIELD_TERRAIN_SHAPE_H
    1818
    1919#include "btConcaveShape.h"
     
    159159};
    160160
    161 #endif //HEIGHTFIELD_TERRAIN_SHAPE_H
     161#endif //BT_HEIGHTFIELD_TERRAIN_SHAPE_H
  • code/trunk/src/external/bullet/BulletCollision/CollisionShapes/btMaterial.h

    r8351 r8393  
    1616/// This file was created by Alex Silverman
    1717
    18 #ifndef MATERIAL_H
    19 #define MATERIAL_H
     18#ifndef BT_MATERIAL_H
     19#define BT_MATERIAL_H
    2020
    2121// Material class to be used by btMultimaterialTriangleMeshShape to store triangle properties
     
    3232};
    3333
    34 #endif // MATERIAL_H
     34#endif // BT_MATERIAL_H
    3535
  • code/trunk/src/external/bullet/BulletCollision/CollisionShapes/btMinkowskiSumShape.h

    r8351 r8393  
    1414*/
    1515
    16 #ifndef MINKOWSKI_SUM_SHAPE_H
    17 #define MINKOWSKI_SUM_SHAPE_H
     16#ifndef BT_MINKOWSKI_SUM_SHAPE_H
     17#define BT_MINKOWSKI_SUM_SHAPE_H
    1818
    1919#include "btConvexInternalShape.h"
     
    5858};
    5959
    60 #endif //MINKOWSKI_SUM_SHAPE_H
     60#endif //BT_MINKOWSKI_SUM_SHAPE_H
  • code/trunk/src/external/bullet/BulletCollision/CollisionShapes/btMultiSphereShape.h

    r8351 r8393  
    1414*/
    1515
    16 #ifndef MULTI_SPHERE_MINKOWSKI_H
    17 #define MULTI_SPHERE_MINKOWSKI_H
     16#ifndef BT_MULTI_SPHERE_MINKOWSKI_H
     17#define BT_MULTI_SPHERE_MINKOWSKI_H
    1818
    1919#include "btConvexInternalShape.h"
     
    9797
    9898
    99 #endif //MULTI_SPHERE_MINKOWSKI_H
     99#endif //BT_MULTI_SPHERE_MINKOWSKI_H
  • code/trunk/src/external/bullet/BulletCollision/CollisionShapes/btMultimaterialTriangleMeshShape.h

    r8351 r8393  
    1616/// This file was created by Alex Silverman
    1717
    18 #ifndef BVH_TRIANGLE_MATERIAL_MESH_SHAPE_H
    19 #define BVH_TRIANGLE_MATERIAL_MESH_SHAPE_H
     18#ifndef BT_BVH_TRIANGLE_MATERIAL_MESH_SHAPE_H
     19#define BT_BVH_TRIANGLE_MATERIAL_MESH_SHAPE_H
    2020
    2121#include "btBvhTriangleMeshShape.h"
     
    3232        BT_DECLARE_ALIGNED_ALLOCATOR();
    3333
    34     btMultimaterialTriangleMeshShape(): btBvhTriangleMeshShape() {m_shapeType = MULTIMATERIAL_TRIANGLE_MESH_PROXYTYPE;}
    3534    btMultimaterialTriangleMeshShape(btStridingMeshInterface* meshInterface, bool useQuantizedAabbCompression, bool buildBvh = true):
    3635        btBvhTriangleMeshShape(meshInterface, useQuantizedAabbCompression, buildBvh)
     
    119118;
    120119
    121 #endif //BVH_TRIANGLE_MATERIAL_MESH_SHAPE_H
     120#endif //BT_BVH_TRIANGLE_MATERIAL_MESH_SHAPE_H
  • code/trunk/src/external/bullet/BulletCollision/CollisionShapes/btOptimizedBvh.h

    r8351 r8393  
    1616///Contains contributions from Disney Studio's
    1717
    18 #ifndef OPTIMIZED_BVH_H
    19 #define OPTIMIZED_BVH_H
     18#ifndef BT_OPTIMIZED_BVH_H
     19#define BT_OPTIMIZED_BVH_H
    2020
    2121#include "BulletCollision/BroadphaseCollision/btQuantizedBvh.h"
     
    6161
    6262
    63 #endif //OPTIMIZED_BVH_H
     63#endif //BT_OPTIMIZED_BVH_H
    6464
    6565
  • code/trunk/src/external/bullet/BulletCollision/CollisionShapes/btPolyhedralConvexShape.cpp

    r8351 r8393  
    1515
    1616#include "BulletCollision/CollisionShapes/btPolyhedralConvexShape.h"
    17 
    18 btPolyhedralConvexShape::btPolyhedralConvexShape() :btConvexInternalShape()
    19 {
    20 
     17#include "btConvexPolyhedron.h"
     18#include "LinearMath/btConvexHullComputer.h"
     19#include <new>
     20
     21btPolyhedralConvexShape::btPolyhedralConvexShape() :btConvexInternalShape(),
     22m_polyhedron(0)
     23{
     24
     25}
     26
     27btPolyhedralConvexShape::~btPolyhedralConvexShape()
     28{
     29        if (m_polyhedron)
     30        {
     31                btAlignedFree(m_polyhedron);
     32        }
     33}
     34
     35bool    btPolyhedralConvexShape::initializePolyhedralFeatures()
     36{
     37        if (m_polyhedron)
     38                btAlignedFree(m_polyhedron);
     39       
     40        void* mem = btAlignedAlloc(sizeof(btConvexPolyhedron),16);
     41        m_polyhedron = new (mem) btConvexPolyhedron;
     42
     43        btAlignedObjectArray<btVector3> tmpVertices;
     44        for (int i=0;i<getNumVertices();i++)
     45        {
     46                btVector3& newVertex = tmpVertices.expand();
     47                getVertex(i,newVertex);
     48        }
     49
     50        btConvexHullComputer conv;
     51        conv.compute(&tmpVertices[0].getX(), sizeof(btVector3),tmpVertices.size(),0.f,0.f);
     52
     53       
     54
     55        btAlignedObjectArray<btVector3> faceNormals;
     56        int numFaces = conv.faces.size();
     57        faceNormals.resize(numFaces);
     58        btConvexHullComputer* convexUtil = &conv;
     59
     60       
     61       
     62        m_polyhedron->m_faces.resize(numFaces);
     63        int numVertices = convexUtil->vertices.size();
     64        m_polyhedron->m_vertices.resize(numVertices);
     65        for (int p=0;p<numVertices;p++)
     66        {
     67                m_polyhedron->m_vertices[p] = convexUtil->vertices[p];
     68        }
     69
     70        for (int i=0;i<numFaces;i++)
     71        {
     72                int face = convexUtil->faces[i];
     73                //printf("face=%d\n",face);
     74                const btConvexHullComputer::Edge*  firstEdge = &convexUtil->edges[face];
     75                const btConvexHullComputer::Edge*  edge = firstEdge;
     76
     77                btVector3 edges[3];
     78                int numEdges = 0;
     79                //compute face normals
     80
     81                btScalar maxCross2 = 0.f;
     82                int chosenEdge = -1;
     83
     84                do
     85                {
     86                       
     87                        int src = edge->getSourceVertex();
     88                        m_polyhedron->m_faces[i].m_indices.push_back(src);
     89                        int targ = edge->getTargetVertex();
     90                        btVector3 wa = convexUtil->vertices[src];
     91
     92                        btVector3 wb = convexUtil->vertices[targ];
     93                        btVector3 newEdge = wb-wa;
     94                        newEdge.normalize();
     95                        if (numEdges<2)
     96                                edges[numEdges++] = newEdge;
     97
     98                        edge = edge->getNextEdgeOfFace();
     99                } while (edge!=firstEdge);
     100
     101                btScalar planeEq = 1e30f;
     102
     103               
     104                if (numEdges==2)
     105                {
     106                        faceNormals[i] = edges[0].cross(edges[1]);
     107                        faceNormals[i].normalize();
     108                        m_polyhedron->m_faces[i].m_plane[0] = -faceNormals[i].getX();
     109                        m_polyhedron->m_faces[i].m_plane[1] = -faceNormals[i].getY();
     110                        m_polyhedron->m_faces[i].m_plane[2] = -faceNormals[i].getZ();
     111                        m_polyhedron->m_faces[i].m_plane[3] = planeEq;
     112
     113                }
     114                else
     115                {
     116                        btAssert(0);//degenerate?
     117                        faceNormals[i].setZero();
     118                }
     119
     120                for (int v=0;v<m_polyhedron->m_faces[i].m_indices.size();v++)
     121                {
     122                        btScalar eq = m_polyhedron->m_vertices[m_polyhedron->m_faces[i].m_indices[v]].dot(faceNormals[i]);
     123                        if (planeEq>eq)
     124                        {
     125                                planeEq=eq;
     126                        }
     127                }
     128                m_polyhedron->m_faces[i].m_plane[3] = planeEq;
     129        }
     130
     131
     132        if (m_polyhedron->m_faces.size() && conv.vertices.size())
     133        {
     134
     135                for (int f=0;f<m_polyhedron->m_faces.size();f++)
     136                {
     137                       
     138                        btVector3 planeNormal(m_polyhedron->m_faces[f].m_plane[0],m_polyhedron->m_faces[f].m_plane[1],m_polyhedron->m_faces[f].m_plane[2]);
     139                        btScalar planeEq = m_polyhedron->m_faces[f].m_plane[3];
     140
     141                        btVector3 supVec = localGetSupportingVertex(-planeNormal);
     142
     143                        if (supVec.dot(planeNormal)<planeEq)
     144                        {
     145                                m_polyhedron->m_faces[f].m_plane[0] *= -1;
     146                                m_polyhedron->m_faces[f].m_plane[1] *= -1;
     147                                m_polyhedron->m_faces[f].m_plane[2] *= -1;
     148                                m_polyhedron->m_faces[f].m_plane[3] *= -1;
     149                                int numVerts = m_polyhedron->m_faces[f].m_indices.size();
     150                                for (int v=0;v<numVerts/2;v++)
     151                                {
     152                                        btSwap(m_polyhedron->m_faces[f].m_indices[v],m_polyhedron->m_faces[f].m_indices[numVerts-1-v]);
     153                                }
     154                        }
     155                }
     156        }
     157
     158       
     159
     160        m_polyhedron->initialize();
     161
     162        return true;
    21163}
    22164
     
    192334}
    193335
     336
     337
     338
  • code/trunk/src/external/bullet/BulletCollision/CollisionShapes/btPolyhedralConvexShape.h

    r8351 r8393  
    1414*/
    1515
    16 #ifndef BU_SHAPE
    17 #define BU_SHAPE
     16#ifndef BT_POLYHEDRAL_CONVEX_SHAPE_H
     17#define BT_POLYHEDRAL_CONVEX_SHAPE_H
    1818
    1919#include "LinearMath/btMatrix3x3.h"
    2020#include "btConvexInternalShape.h"
     21class btConvexPolyhedron;
    2122
    2223
     
    2425class btPolyhedralConvexShape : public btConvexInternalShape
    2526{
     27       
    2628
    2729protected:
    2830       
     31        btConvexPolyhedron* m_polyhedron;
     32
    2933public:
    3034
    3135        btPolyhedralConvexShape();
     36
     37        virtual ~btPolyhedralConvexShape();
     38
     39        ///optional method mainly used to generate multiple contact points by clipping polyhedral features (faces/edges)
     40        virtual bool    initializePolyhedralFeatures();
     41
     42        const btConvexPolyhedron*       getConvexPolyhedron() const
     43        {
     44                return m_polyhedron;
     45        }
    3246
    3347        //brute force implementations
     
    96110};
    97111
    98 #endif //BU_SHAPE
     112#endif //BT_POLYHEDRAL_CONVEX_SHAPE_H
  • code/trunk/src/external/bullet/BulletCollision/CollisionShapes/btScaledBvhTriangleMeshShape.cpp

    r8351 r8393  
    6363        scaledAabbMin[1] = m_localScaling.getY() >= 0. ? aabbMin[1] * invLocalScaling[1] : aabbMax[1] * invLocalScaling[1];
    6464        scaledAabbMin[2] = m_localScaling.getZ() >= 0. ? aabbMin[2] * invLocalScaling[2] : aabbMax[2] * invLocalScaling[2];
     65        scaledAabbMin[3] = 0.f;
    6566       
    6667        scaledAabbMax[0] = m_localScaling.getX() <= 0. ? aabbMin[0] * invLocalScaling[0] : aabbMax[0] * invLocalScaling[0];
    6768        scaledAabbMax[1] = m_localScaling.getY() <= 0. ? aabbMin[1] * invLocalScaling[1] : aabbMax[1] * invLocalScaling[1];
    6869        scaledAabbMax[2] = m_localScaling.getZ() <= 0. ? aabbMin[2] * invLocalScaling[2] : aabbMax[2] * invLocalScaling[2];
     70        scaledAabbMax[3] = 0.f;
    6971       
    7072       
  • code/trunk/src/external/bullet/BulletCollision/CollisionShapes/btScaledBvhTriangleMeshShape.h

    r8351 r8393  
    1414*/
    1515
    16 #ifndef SCALED_BVH_TRIANGLE_MESH_SHAPE_H
    17 #define SCALED_BVH_TRIANGLE_MESH_SHAPE_H
     16#ifndef BT_SCALED_BVH_TRIANGLE_MESH_SHAPE_H
     17#define BT_SCALED_BVH_TRIANGLE_MESH_SHAPE_H
    1818
    1919#include "BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h"
     
    5858        virtual const char*     getName()const {return "SCALEDBVHTRIANGLEMESH";}
    5959
     60        virtual int     calculateSerializeBufferSize() const;
     61
     62        ///fills the dataBuffer and returns the struct name (and 0 on failure)
     63        virtual const char*     serialize(void* dataBuffer, btSerializer* serializer) const;
     64
    6065};
    6166
    62 #endif //BVH_TRIANGLE_MESH_SHAPE_H
     67///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
     68struct  btScaledTriangleMeshShapeData
     69{
     70        btTriangleMeshShapeData m_trimeshShapeData;
     71
     72        btVector3FloatData      m_localScaling;
     73};
     74
     75
     76SIMD_FORCE_INLINE       int     btScaledBvhTriangleMeshShape::calculateSerializeBufferSize() const
     77{
     78        return sizeof(btScaledTriangleMeshShapeData);
     79}
     80
     81
     82///fills the dataBuffer and returns the struct name (and 0 on failure)
     83SIMD_FORCE_INLINE       const char*     btScaledBvhTriangleMeshShape::serialize(void* dataBuffer, btSerializer* serializer) const
     84{
     85        btScaledTriangleMeshShapeData* scaledMeshData = (btScaledTriangleMeshShapeData*) dataBuffer;
     86        m_bvhTriMeshShape->serialize(&scaledMeshData->m_trimeshShapeData,serializer);
     87        scaledMeshData->m_trimeshShapeData.m_collisionShapeData.m_shapeType = SCALED_TRIANGLE_MESH_SHAPE_PROXYTYPE;
     88        m_localScaling.serializeFloat(scaledMeshData->m_localScaling);
     89        return "btScaledTriangleMeshShapeData";
     90}
     91
     92
     93#endif //BT_SCALED_BVH_TRIANGLE_MESH_SHAPE_H
  • code/trunk/src/external/bullet/BulletCollision/CollisionShapes/btShapeHull.h

    r8351 r8393  
    1616///btShapeHull implemented by John McCutchan.
    1717
    18 #ifndef _SHAPE_HULL_H
    19 #define _SHAPE_HULL_H
     18#ifndef BT_SHAPE_HULL_H
     19#define BT_SHAPE_HULL_H
    2020
    2121#include "LinearMath/btAlignedObjectArray.h"
     
    5757};
    5858
    59 #endif //_SHAPE_HULL_H
     59#endif //BT_SHAPE_HULL_H
  • code/trunk/src/external/bullet/BulletCollision/CollisionShapes/btSphereShape.h

    r8351 r8393  
    13133. This notice may not be removed or altered from any source distribution.
    1414*/
    15 #ifndef SPHERE_MINKOWSKI_H
    16 #define SPHERE_MINKOWSKI_H
     15#ifndef BT_SPHERE_MINKOWSKI_H
     16#define BT_SPHERE_MINKOWSKI_H
    1717
    1818#include "btConvexInternalShape.h"
     
    7171
    7272
    73 #endif //SPHERE_MINKOWSKI_H
     73#endif //BT_SPHERE_MINKOWSKI_H
  • code/trunk/src/external/bullet/BulletCollision/CollisionShapes/btStaticPlaneShape.h

    r8351 r8393  
    1414*/
    1515
    16 #ifndef STATIC_PLANE_SHAPE_H
    17 #define STATIC_PLANE_SHAPE_H
     16#ifndef BT_STATIC_PLANE_SHAPE_H
     17#define BT_STATIC_PLANE_SHAPE_H
    1818
    1919#include "btConcaveShape.h"
     
    9898
    9999
    100 #endif //STATIC_PLANE_SHAPE_H
     100#endif //BT_STATIC_PLANE_SHAPE_H
    101101
    102102
  • code/trunk/src/external/bullet/BulletCollision/CollisionShapes/btStridingMeshInterface.cpp

    r8351 r8393  
    8989                                         break;
    9090                                 }
     91                        case PHY_UCHAR:
     92                                 {
     93                                         for (gfxindex=0;gfxindex<numtriangles;gfxindex++)
     94                                         {
     95                                                 unsigned char* tri_indices= (unsigned char*)(indexbase+gfxindex*indexstride);
     96                                                 graphicsbase = (float*)(vertexbase+tri_indices[0]*stride);
     97                                                 triangle[0].setValue(graphicsbase[0]*meshScaling.getX(),graphicsbase[1]*meshScaling.getY(),graphicsbase[2]*meshScaling.getZ());
     98                                                 graphicsbase = (float*)(vertexbase+tri_indices[1]*stride);
     99                                                 triangle[1].setValue(graphicsbase[0]*meshScaling.getX(),graphicsbase[1]*meshScaling.getY(),    graphicsbase[2]*meshScaling.getZ());
     100                                                 graphicsbase = (float*)(vertexbase+tri_indices[2]*stride);
     101                                                 triangle[2].setValue(graphicsbase[0]*meshScaling.getX(),graphicsbase[1]*meshScaling.getY(),    graphicsbase[2]*meshScaling.getZ());
     102                                                 callback->internalProcessTriangleIndex(triangle,part,gfxindex);
     103                                         }
     104                                         break;
     105                                 }
    91106                         default:
    92107                                 btAssert((gfxindextype == PHY_INTEGER) || (gfxindextype == PHY_SHORT));
     
    121136                                                {
    122137                                                        unsigned short int* tri_indices= (unsigned short int*)(indexbase+gfxindex*indexstride);
     138                                                        graphicsbase = (double*)(vertexbase+tri_indices[0]*stride);
     139                                                        triangle[0].setValue((btScalar)graphicsbase[0]*meshScaling.getX(),(btScalar)graphicsbase[1]*meshScaling.getY(),(btScalar)graphicsbase[2]*meshScaling.getZ());
     140                                                        graphicsbase = (double*)(vertexbase+tri_indices[1]*stride);
     141                                                        triangle[1].setValue((btScalar)graphicsbase[0]*meshScaling.getX(),(btScalar)graphicsbase[1]*meshScaling.getY(),  (btScalar)graphicsbase[2]*meshScaling.getZ());
     142                                                        graphicsbase = (double*)(vertexbase+tri_indices[2]*stride);
     143                                                        triangle[2].setValue((btScalar)graphicsbase[0]*meshScaling.getX(),(btScalar)graphicsbase[1]*meshScaling.getY(),  (btScalar)graphicsbase[2]*meshScaling.getZ());
     144                                                        callback->internalProcessTriangleIndex(triangle,part,gfxindex);
     145                                                }
     146                                                break;
     147                                        }
     148                                case PHY_UCHAR:
     149                                        {
     150                                                for (gfxindex=0;gfxindex<numtriangles;gfxindex++)
     151                                                {
     152                                                        unsigned char* tri_indices= (unsigned char*)(indexbase+gfxindex*indexstride);
    123153                                                        graphicsbase = (double*)(vertexbase+tri_indices[0]*stride);
    124154                                                        triangle[0].setValue((btScalar)graphicsbase[0]*meshScaling.getX(),(btScalar)graphicsbase[1]*meshScaling.getY(),(btScalar)graphicsbase[2]*meshScaling.getZ());
     
    267297                                        break;
    268298                                }
     299                                case PHY_UCHAR:
     300                                {
     301                                        if (numtriangles)
     302                                        {
     303                                                btChunk* chunk = serializer->allocate(sizeof(btCharIndexTripletData),numtriangles);
     304                                                btCharIndexTripletData* tmpIndices = (btCharIndexTripletData*)chunk->m_oldPtr;
     305                                                memPtr->m_3indices8 = (btCharIndexTripletData*) serializer->getUniquePointer(tmpIndices);
     306                                                for (gfxindex=0;gfxindex<numtriangles;gfxindex++)
     307                                                {
     308                                                        unsigned char* tri_indices= (unsigned char*)(indexbase+gfxindex*indexstride);
     309                                                        tmpIndices[gfxindex].m_values[0] = tri_indices[0];
     310                                                        tmpIndices[gfxindex].m_values[1] = tri_indices[1];
     311                                                        tmpIndices[gfxindex].m_values[2] = tri_indices[2];
     312                                                }
     313                                                serializer->finalizeChunk(chunk,"btCharIndexTripletData",BT_ARRAY_CODE,(void*)chunk->m_oldPtr);
     314                                        }
     315                                        break;
     316                                }
    269317                        default:
    270318                                {
  • code/trunk/src/external/bullet/BulletCollision/CollisionShapes/btStridingMeshInterface.h

    r8351 r8393  
    1414*/
    1515
    16 #ifndef STRIDING_MESHINTERFACE_H
    17 #define STRIDING_MESHINTERFACE_H
     16#ifndef BT_STRIDING_MESHINTERFACE_H
     17#define BT_STRIDING_MESHINTERFACE_H
    1818
    1919#include "LinearMath/btVector3.h"
     
    117117};
    118118
     119struct  btCharIndexTripletData
     120{
     121        unsigned char m_values[3];
     122        char    m_pad;
     123};
     124
     125
    119126///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
    120127struct  btMeshPartData
     
    125132        btIntIndexData                          *m_indices32;
    126133        btShortIntIndexTripletData      *m_3indices16;
     134        btCharIndexTripletData          *m_3indices8;
    127135
    128136        btShortIntIndexData                     *m_indices16;//backwards compatibility
     
    152160
    153161
    154 #endif //STRIDING_MESHINTERFACE_H
     162#endif //BT_STRIDING_MESHINTERFACE_H
  • code/trunk/src/external/bullet/BulletCollision/CollisionShapes/btTetrahedronShape.h

    r8351 r8393  
    1414*/
    1515
    16 #ifndef BU_SIMPLEX_1TO4_SHAPE
    17 #define BU_SIMPLEX_1TO4_SHAPE
     16#ifndef BT_SIMPLEX_1TO4_SHAPE
     17#define BT_SIMPLEX_1TO4_SHAPE
    1818
    1919
     
    7272};
    7373
    74 #endif //BU_SIMPLEX_1TO4_SHAPE
     74#endif //BT_SIMPLEX_1TO4_SHAPE
  • code/trunk/src/external/bullet/BulletCollision/CollisionShapes/btTriangleCallback.h

    r8351 r8393  
    1414*/
    1515
    16 #ifndef TRIANGLE_CALLBACK_H
    17 #define TRIANGLE_CALLBACK_H
     16#ifndef BT_TRIANGLE_CALLBACK_H
     17#define BT_TRIANGLE_CALLBACK_H
    1818
    1919#include "LinearMath/btVector3.h"
     
    4040
    4141
    42 #endif //TRIANGLE_CALLBACK_H
     42#endif //BT_TRIANGLE_CALLBACK_H
  • code/trunk/src/external/bullet/BulletCollision/CollisionShapes/btTriangleInfoMap.h

    r8351 r8393  
    6262        btScalar        m_equalVertexThreshold; ///used to compute connectivity: if the distance between two vertices is smaller than m_equalVertexThreshold, they are considered to be 'shared'
    6363        btScalar        m_edgeDistanceThreshold; ///used to determine edge contacts: if the closest distance between a contact point and an edge is smaller than this distance threshold it is considered to "hit the edge"
     64        btScalar        m_maxEdgeAngleThreshold; //ignore edges that connect triangles at an angle larger than this m_maxEdgeAngleThreshold
    6465        btScalar        m_zeroAreaThreshold; ///used to determine if a triangle is degenerate (length squared of cross product of 2 triangle edges < threshold)
    6566       
     
    7273                m_edgeDistanceThreshold = btScalar(0.1);
    7374                m_zeroAreaThreshold = btScalar(0.0001)*btScalar(0.0001);
     75                m_maxEdgeAngleThreshold = SIMD_2_PI;
    7476        }
    7577        virtual ~btTriangleInfoMap() {}
  • code/trunk/src/external/bullet/BulletCollision/CollisionShapes/btTriangleMesh.h

    r8351 r8393  
    1414*/
    1515
    16 #ifndef TRIANGLE_MESH_H
    17 #define TRIANGLE_MESH_H
     16#ifndef BT_TRIANGLE_MESH_H
     17#define BT_TRIANGLE_MESH_H
    1818
    1919#include "btTriangleIndexVertexArray.h"
     
    6666};
    6767
    68 #endif //TRIANGLE_MESH_H
     68#endif //BT_TRIANGLE_MESH_H
    6969
  • code/trunk/src/external/bullet/BulletCollision/CollisionShapes/btTriangleMeshShape.h

    r8351 r8393  
    1414*/
    1515
    16 #ifndef TRIANGLE_MESH_SHAPE_H
    17 #define TRIANGLE_MESH_SHAPE_H
     16#ifndef BT_TRIANGLE_MESH_SHAPE_H
     17#define BT_TRIANGLE_MESH_SHAPE_H
    1818
    1919#include "btConcaveShape.h"
     
    8787
    8888
    89 #endif //TRIANGLE_MESH_SHAPE_H
     89#endif //BT_TRIANGLE_MESH_SHAPE_H
  • code/trunk/src/external/bullet/BulletCollision/CollisionShapes/btTriangleShape.h

    r8351 r8393  
    1414*/
    1515
    16 #ifndef OBB_TRIANGLE_MINKOWSKI_H
    17 #define OBB_TRIANGLE_MINKOWSKI_H
     16#ifndef BT_OBB_TRIANGLE_MINKOWSKI_H
     17#define BT_OBB_TRIANGLE_MINKOWSKI_H
    1818
    1919#include "btConvexShape.h"
     
    179179};
    180180
    181 #endif //OBB_TRIANGLE_MINKOWSKI_H
     181#endif //BT_OBB_TRIANGLE_MINKOWSKI_H
    182182
  • code/trunk/src/external/bullet/BulletCollision/CollisionShapes/btUniformScalingShape.cpp

    r8351 r8393  
    6565
    6666        ///getAabb's default implementation is brute force, expected derived classes to implement a fast dedicated version
    67 void btUniformScalingShape::getAabb(const btTransform& t,btVector3& aabbMin,btVector3& aabbMax) const
     67void btUniformScalingShape::getAabb(const btTransform& trans,btVector3& aabbMin,btVector3& aabbMax) const
    6868{
    69         m_childConvexShape->getAabb(t,aabbMin,aabbMax);
    70         btVector3 aabbCenter = (aabbMax+aabbMin)*btScalar(0.5);
    71         btVector3 scaledAabbHalfExtends = (aabbMax-aabbMin)*btScalar(0.5)*m_uniformScalingFactor;
    72 
    73         aabbMin = aabbCenter - scaledAabbHalfExtends;
    74         aabbMax = aabbCenter + scaledAabbHalfExtends;
     69        getAabbSlow(trans,aabbMin,aabbMax);
    7570
    7671}
     
    7873void btUniformScalingShape::getAabbSlow(const btTransform& t,btVector3& aabbMin,btVector3& aabbMax) const
    7974{
    80         m_childConvexShape->getAabbSlow(t,aabbMin,aabbMax);
    81         btVector3 aabbCenter = (aabbMax+aabbMin)*btScalar(0.5);
    82         btVector3 scaledAabbHalfExtends = (aabbMax-aabbMin)*btScalar(0.5)*m_uniformScalingFactor;
     75#if 1
     76        btVector3 _directions[] =
     77        {
     78                btVector3( 1.,  0.,  0.),
     79                btVector3( 0.,  1.,  0.),
     80                btVector3( 0.,  0.,  1.),
     81                btVector3( -1., 0.,  0.),
     82                btVector3( 0., -1.,  0.),
     83                btVector3( 0.,  0., -1.)
     84        };
     85       
     86        btVector3 _supporting[] =
     87        {
     88                btVector3( 0., 0., 0.),
     89                btVector3( 0., 0., 0.),
     90                btVector3( 0., 0., 0.),
     91                btVector3( 0., 0., 0.),
     92                btVector3( 0., 0., 0.),
     93                btVector3( 0., 0., 0.)
     94        };
    8395
    84         aabbMin = aabbCenter - scaledAabbHalfExtends;
    85         aabbMax = aabbCenter + scaledAabbHalfExtends;
     96        for (int i=0;i<6;i++)
     97        {
     98                _directions[i] = _directions[i]*t.getBasis();
     99        }
     100       
     101        batchedUnitVectorGetSupportingVertexWithoutMargin(_directions, _supporting, 6);
     102       
     103        btVector3 aabbMin1(0,0,0),aabbMax1(0,0,0);
     104
     105        for ( int i = 0; i < 3; ++i )
     106        {
     107                aabbMax1[i] = t(_supporting[i])[i];
     108                aabbMin1[i] = t(_supporting[i + 3])[i];
     109        }
     110        btVector3 marginVec(getMargin(),getMargin(),getMargin());
     111        aabbMin = aabbMin1-marginVec;
     112        aabbMax = aabbMax1+marginVec;
     113       
     114#else
     115
     116        btScalar margin = getMargin();
     117        for (int i=0;i<3;i++)
     118        {
     119                btVector3 vec(btScalar(0.),btScalar(0.),btScalar(0.));
     120                vec[i] = btScalar(1.);
     121                btVector3 sv = localGetSupportingVertex(vec*t.getBasis());
     122                btVector3 tmp = t(sv);
     123                aabbMax[i] = tmp[i]+margin;
     124                vec[i] = btScalar(-1.);
     125                sv = localGetSupportingVertex(vec*t.getBasis());
     126                tmp = t(sv);
     127                aabbMin[i] = tmp[i]-margin;
     128        }
     129
     130#endif
    86131}
    87132
  • code/trunk/src/external/bullet/BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.cpp

    r8351 r8393  
    2323#include "btGjkPairDetector.h"
    2424#include "btPointCollector.h"
     25#include "BulletCollision/CollisionShapes/btStaticPlaneShape.h"
    2526
    2627
     
    2930:m_simplexSolver(simplexSolver),
    3031m_penetrationDepthSolver(penetrationDepthSolver),
    31 m_convexA(convexA),m_convexB(convexB)
    32 {
    33 }
     32m_convexA(convexA),m_convexB1(convexB),m_planeShape(0)
     33{
     34}
     35
     36
     37btContinuousConvexCollision::btContinuousConvexCollision( const btConvexShape*  convexA,const btStaticPlaneShape*       plane)
     38:m_simplexSolver(0),
     39m_penetrationDepthSolver(0),
     40m_convexA(convexA),m_convexB1(0),m_planeShape(plane)
     41{
     42}
     43
    3444
    3545/// This maximum should not be necessary. It allows for untested/degenerate cases in production code.
    3646/// You don't want your game ever to lock-up.
    3747#define MAX_ITERATIONS 64
     48
     49void btContinuousConvexCollision::computeClosestPoints( const btTransform& transA, const btTransform& transB,btPointCollector& pointCollector)
     50{
     51        if (m_convexB1)
     52        {
     53                m_simplexSolver->reset();
     54                btGjkPairDetector gjk(m_convexA,m_convexB1,m_convexA->getShapeType(),m_convexB1->getShapeType(),m_convexA->getMargin(),m_convexB1->getMargin(),m_simplexSolver,m_penetrationDepthSolver);               
     55                btGjkPairDetector::ClosestPointInput input;
     56                input.m_transformA = transA;
     57                input.m_transformB = transB;
     58                gjk.getClosestPoints(input,pointCollector,0);
     59        } else
     60        {
     61                //convex versus plane
     62                const btConvexShape* convexShape = m_convexA;
     63                const btStaticPlaneShape* planeShape = m_planeShape;
     64               
     65                bool hasCollision = false;
     66                const btVector3& planeNormal = planeShape->getPlaneNormal();
     67                const btScalar& planeConstant = planeShape->getPlaneConstant();
     68               
     69                btTransform convexWorldTransform = transA;
     70                btTransform convexInPlaneTrans;
     71                convexInPlaneTrans= transB.inverse() * convexWorldTransform;
     72                btTransform planeInConvex;
     73                planeInConvex= convexWorldTransform.inverse() * transB;
     74               
     75                btVector3 vtx = convexShape->localGetSupportingVertex(planeInConvex.getBasis()*-planeNormal);
     76
     77                btVector3 vtxInPlane = convexInPlaneTrans(vtx);
     78                btScalar distance = (planeNormal.dot(vtxInPlane) - planeConstant);
     79
     80                btVector3 vtxInPlaneProjected = vtxInPlane - distance*planeNormal;
     81                btVector3 vtxInPlaneWorld = transB * vtxInPlaneProjected;
     82                btVector3 normalOnSurfaceB = transB.getBasis() * planeNormal;
     83
     84                pointCollector.addContactPoint(
     85                        normalOnSurfaceB,
     86                        vtxInPlaneWorld,
     87                        distance);
     88        }
     89}
    3890
    3991bool    btContinuousConvexCollision::calcTimeOfImpact(
     
    4597{
    4698
    47         m_simplexSolver->reset();
    4899
    49100        /// compute linear and angular velocity for this interval, to interpolate
     
    54105
    55106        btScalar boundingRadiusA = m_convexA->getAngularMotionDisc();
    56         btScalar boundingRadiusB = m_convexB->getAngularMotionDisc();
     107        btScalar boundingRadiusB = m_convexB1?m_convexB1->getAngularMotionDisc():0.f;
    57108
    58109        btScalar maxAngularProjectedVelocity = angVelA.length() * boundingRadiusA + angVelB.length() * boundingRadiusB;
     
    65116
    66117
    67         btScalar radius = btScalar(0.001);
    68118
    69119        btScalar lambda = btScalar(0.);
     
    84134
    85135
    86         btTransform identityTrans;
    87         identityTrans.setIdentity();
    88 
    89         btSphereShape   raySphere(btScalar(0.0));
    90         raySphere.setMargin(btScalar(0.));
    91 
    92 
     136        btScalar radius = 0.001f;
    93137//      result.drawCoordSystem(sphereTr);
    94138
     
    96140
    97141        {
    98                
    99                 btGjkPairDetector gjk(m_convexA,m_convexB,m_convexA->getShapeType(),m_convexB->getShapeType(),m_convexA->getMargin(),m_convexB->getMargin(),m_simplexSolver,m_penetrationDepthSolver);         
    100                 btGjkPairDetector::ClosestPointInput input;
    101142       
    102                 //we don't use margins during CCD
    103         //      gjk.setIgnoreMargin(true);
    104 
    105                 input.m_transformA = fromA;
    106                 input.m_transformB = fromB;
    107                 gjk.getClosestPoints(input,pointCollector1,0);
     143                computeClosestPoints(fromA,fromB,pointCollector1);
    108144
    109145                hasResult = pointCollector1.m_hasResult;
     
    114150        {
    115151                btScalar dist;
    116                 dist = pointCollector1.m_distance;
     152                dist = pointCollector1.m_distance + result.m_allowedPenetration;
    117153                n = pointCollector1.m_normalOnBInWorld;
    118 
    119154                btScalar projectedLinearVelocity = relLinVel.dot(n);
    120                
     155                if ((projectedLinearVelocity+ maxAngularProjectedVelocity)<=SIMD_EPSILON)
     156                        return false;
     157
    121158                //not close enough
    122159                while (dist > radius)
     
    126163                                result.m_debugDrawer->drawSphere(c,0.2f,btVector3(1,1,1));
    127164                        }
    128                         numIter++;
    129                         if (numIter > maxIter)
    130                         {
    131                                 return false; //todo: report a failure
    132                         }
    133165                        btScalar dLambda = btScalar(0.);
    134166
    135167                        projectedLinearVelocity = relLinVel.dot(n);
    136168
    137                         //calculate safe moving fraction from distance / (linear+rotational velocity)
    138                        
    139                         //btScalar clippedDist  = GEN_min(angularConservativeRadius,dist);
    140                         //btScalar clippedDist  = dist;
    141169                       
    142170                        //don't report time of impact for motion away from the contact normal (or causes minor penetration)
     
    183211
    184212                        btPointCollector        pointCollector;
    185                         btGjkPairDetector gjk(m_convexA,m_convexB,m_simplexSolver,m_penetrationDepthSolver);
    186                         btGjkPairDetector::ClosestPointInput input;
    187                         input.m_transformA = interpolatedTransA;
    188                         input.m_transformB = interpolatedTransB;
    189                         gjk.getClosestPoints(input,pointCollector,0);
     213                        computeClosestPoints(interpolatedTransA,interpolatedTransB,pointCollector);
     214
    190215                        if (pointCollector.m_hasResult)
    191216                        {
    192                                 if (pointCollector.m_distance < btScalar(0.))
    193                                 {
    194                                         //degenerate ?!
    195                                         result.m_fraction = lastLambda;
    196                                         n = pointCollector.m_normalOnBInWorld;
    197                                         result.m_normal=n;//.setValue(1,1,1);// = n;
    198                                         result.m_hitPoint = pointCollector.m_pointInWorld;
    199                                         return true;
    200                                 }
     217                                dist = pointCollector.m_distance+result.m_allowedPenetration;
    201218                                c = pointCollector.m_pointInWorld;             
    202219                                n = pointCollector.m_normalOnBInWorld;
    203                                 dist = pointCollector.m_distance;
    204220                        } else
    205221                        {
    206                                 //??
    207                                 return false;
    208                         }
    209                        
    210 
     222                                result.reportFailure(-1, numIter);
     223                                return false;
     224                        }
     225
     226                        numIter++;
     227                        if (numIter > maxIter)
     228                        {
     229                                result.reportFailure(-2, numIter);
     230                                return false;
     231                        }
    211232                }
    212233       
    213                 if ((projectedLinearVelocity+ maxAngularProjectedVelocity)<=result.m_allowedPenetration)//SIMD_EPSILON)
    214                         return false;
    215                        
    216234                result.m_fraction = lambda;
    217235                result.m_normal = n;
     
    222240        return false;
    223241
    224 /*
    225 //todo:
    226         //if movement away from normal, discard result
    227         btVector3 move = transBLocalTo.getOrigin() - transBLocalFrom.getOrigin();
    228         if (result.m_fraction < btScalar(1.))
    229         {
    230                 if (move.dot(result.m_normal) <= btScalar(0.))
    231                 {
    232                 }
    233         }
    234 */
    235 
    236 }
     242}
     243
  • code/trunk/src/external/bullet/BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.h

    r5781 r8393  
    1515
    1616
    17 #ifndef CONTINUOUS_COLLISION_CONVEX_CAST_H
    18 #define CONTINUOUS_COLLISION_CONVEX_CAST_H
     17#ifndef BT_CONTINUOUS_COLLISION_CONVEX_CAST_H
     18#define BT_CONTINUOUS_COLLISION_CONVEX_CAST_H
    1919
    2020#include "btConvexCast.h"
     
    2222class btConvexPenetrationDepthSolver;
    2323class btConvexShape;
     24class btStaticPlaneShape;
    2425
    2526/// btContinuousConvexCollision implements angular and linear time of impact for convex objects.
     
    3233        btConvexPenetrationDepthSolver* m_penetrationDepthSolver;
    3334        const btConvexShape*    m_convexA;
    34         const btConvexShape*    m_convexB;
     35        //second object is either a convex or a plane (code sharing)
     36        const btConvexShape*    m_convexB1;
     37        const btStaticPlaneShape*       m_planeShape;
    3538
     39        void computeClosestPoints( const btTransform& transA, const btTransform& transB,struct btPointCollector& pointCollector);
    3640
    3741public:
    3842
    3943        btContinuousConvexCollision (const btConvexShape*       shapeA,const btConvexShape*     shapeB ,btSimplexSolverInterface* simplexSolver,btConvexPenetrationDepthSolver* penetrationDepthSolver);
     44
     45        btContinuousConvexCollision(const btConvexShape*        shapeA,const btStaticPlaneShape*        plane );
    4046
    4147        virtual bool    calcTimeOfImpact(
     
    4955};
    5056
    51 #endif //CONTINUOUS_COLLISION_CONVEX_CAST_H
    5257
     58#endif //BT_CONTINUOUS_COLLISION_CONVEX_CAST_H
     59
  • code/trunk/src/external/bullet/BulletCollision/NarrowPhaseCollision/btConvexCast.h

    r8351 r8393  
    1515
    1616
    17 #ifndef CONVEX_CAST_H
    18 #define CONVEX_CAST_H
     17#ifndef BT_CONVEX_CAST_H
     18#define BT_CONVEX_CAST_H
    1919
    2020#include "LinearMath/btTransform.h"
     
    4040                virtual void    DebugDraw(btScalar      fraction) {(void)fraction;}
    4141                virtual void    drawCoordSystem(const btTransform& trans) {(void)trans;}
    42 
     42                virtual void    reportFailure(int errNo, int numIterations) {(void)errNo;(void)numIterations;}
    4343                CastResult()
    4444                        :m_fraction(btScalar(BT_LARGE_FLOAT)),
     
    7171};
    7272
    73 #endif //CONVEX_CAST_H
     73#endif //BT_CONVEX_CAST_H
  • code/trunk/src/external/bullet/BulletCollision/NarrowPhaseCollision/btConvexPenetrationDepthSolver.h

    r8351 r8393  
    1515
    1616
    17 #ifndef __CONVEX_PENETRATION_DEPTH_H
    18 #define __CONVEX_PENETRATION_DEPTH_H
     17#ifndef BT_CONVEX_PENETRATION_DEPTH_H
     18#define BT_CONVEX_PENETRATION_DEPTH_H
    1919
    2020class btStackAlloc;
     
    3939
    4040};
    41 #endif //CONVEX_PENETRATION_DEPTH_H
     41#endif //BT_CONVEX_PENETRATION_DEPTH_H
    4242
  • code/trunk/src/external/bullet/BulletCollision/NarrowPhaseCollision/btDiscreteCollisionDetectorInterface.h

    r8351 r8393  
    1515
    1616
    17 #ifndef DISCRETE_COLLISION_DETECTOR1_INTERFACE_H
    18 #define DISCRETE_COLLISION_DETECTOR1_INTERFACE_H
     17#ifndef BT_DISCRETE_COLLISION_DETECTOR1_INTERFACE_H
     18#define BT_DISCRETE_COLLISION_DETECTOR1_INTERFACE_H
     19
    1920#include "LinearMath/btTransform.h"
    2021#include "LinearMath/btVector3.h"
     
    8788};
    8889
    89 #endif //DISCRETE_COLLISION_DETECTOR_INTERFACE1_H
     90#endif //BT_DISCRETE_COLLISION_DETECTOR1_INTERFACE_H
     91
  • code/trunk/src/external/bullet/BulletCollision/NarrowPhaseCollision/btGjkConvexCast.h

    r5781 r8393  
    1616
    1717
    18 #ifndef GJK_CONVEX_CAST_H
    19 #define GJK_CONVEX_CAST_H
     18#ifndef BT_GJK_CONVEX_CAST_H
     19#define BT_GJK_CONVEX_CAST_H
    2020
    2121#include "BulletCollision/CollisionShapes/btCollisionMargin.h"
     
    4848};
    4949
    50 #endif //GJK_CONVEX_CAST_H
     50#endif //BT_GJK_CONVEX_CAST_H
  • code/trunk/src/external/bullet/BulletCollision/NarrowPhaseCollision/btGjkEpa2.h

    r8351 r8393  
    2323GJK-EPA collision solver by Nathanael Presson, 2008
    2424*/
    25 #ifndef _68DA1F85_90B7_4bb0_A705_83B4040A75C6_
    26 #define _68DA1F85_90B7_4bb0_A705_83B4040A75C6_
     25#ifndef BT_GJK_EPA2_H
     26#define BT_GJK_EPA2_H
     27
    2728#include "BulletCollision/CollisionShapes/btConvexShape.h"
    2829
     
    7172};
    7273
    73 #endif
     74#endif //BT_GJK_EPA2_H
     75
  • code/trunk/src/external/bullet/BulletCollision/NarrowPhaseCollision/btGjkPairDetector.cpp

    r8351 r8393  
    255255#endif //
    256256                       
    257                         m_cachedSeparatingAxis = newCachedSeparatingAxis;
    258257
    259258                        //redundant m_simplexSolver->compute_points(pointOnA, pointOnB);
     
    262261                        if (previousSquaredDistance - squaredDistance <= SIMD_EPSILON * previousSquaredDistance)
    263262                        {
    264                                 m_simplexSolver->backup_closest(m_cachedSeparatingAxis);
     263//                              m_simplexSolver->backup_closest(m_cachedSeparatingAxis);
    265264                                checkSimplex = true;
    266265                                m_degenerateSimplex = 12;
     
    268267                                break;
    269268                        }
     269
     270                        m_cachedSeparatingAxis = newCachedSeparatingAxis;
    270271
    271272                          //degeneracy, this is typically due to invalid/uninitialized worldtransforms for a btCollisionObject   
     
    295296                        {
    296297                                //do we need this backup_closest here ?
    297                                 m_simplexSolver->backup_closest(m_cachedSeparatingAxis);
     298//                              m_simplexSolver->backup_closest(m_cachedSeparatingAxis);
    298299                                m_degenerateSimplex = 13;
    299300                                break;
     
    304305                {
    305306                        m_simplexSolver->compute_points(pointOnA, pointOnB);
    306                         normalInB = pointOnA-pointOnB;
     307                        normalInB = m_cachedSeparatingAxis;
    307308                        btScalar lenSqr =m_cachedSeparatingAxis.length2();
    308309                       
  • code/trunk/src/external/bullet/BulletCollision/NarrowPhaseCollision/btGjkPairDetector.h

    r8351 r8393  
    1717
    1818
    19 #ifndef GJK_PAIR_DETECTOR_H
    20 #define GJK_PAIR_DETECTOR_H
     19#ifndef BT_GJK_PAIR_DETECTOR_H
     20#define BT_GJK_PAIR_DETECTOR_H
    2121
    2222#include "btDiscreteCollisionDetectorInterface.h"
     
    101101};
    102102
    103 #endif //GJK_PAIR_DETECTOR_H
     103#endif //BT_GJK_PAIR_DETECTOR_H
  • code/trunk/src/external/bullet/BulletCollision/NarrowPhaseCollision/btManifoldPoint.h

    r8351 r8393  
    1414*/
    1515
    16 #ifndef MANIFOLD_CONTACT_POINT_H
    17 #define MANIFOLD_CONTACT_POINT_H
     16#ifndef BT_MANIFOLD_CONTACT_POINT_H
     17#define BT_MANIFOLD_CONTACT_POINT_H
    1818
    1919#include "LinearMath/btVector3.h"
    2020#include "LinearMath/btTransformUtil.h"
    2121
    22 // Don't change following order of parameters
    23 ATTRIBUTE_ALIGNED16(struct) PfxConstraintRow {
    24         btScalar mNormal[3];
    25         btScalar mRhs;
    26         btScalar mJacDiagInv;
    27         btScalar mLowerLimit;
    28         btScalar mUpperLimit;
    29         btScalar mAccumImpulse;
    30 };
    31 
     22#ifdef PFX_USE_FREE_VECTORMATH
     23        #include "physics_effects/base_level/solver/pfx_constraint_row.h"
     24typedef sce::PhysicsEffects::PfxConstraintRow btConstraintRow;
     25#else
     26        // Don't change following order of parameters
     27        ATTRIBUTE_ALIGNED16(struct) btConstraintRow {
     28                btScalar m_normal[3];
     29                btScalar m_rhs;
     30                btScalar m_jacDiagInv;
     31                btScalar m_lowerLimit;
     32                btScalar m_upperLimit;
     33                btScalar m_accumImpulse;
     34        };
     35        typedef btConstraintRow PfxConstraintRow;
     36#endif //PFX_USE_FREE_VECTORMATH
    3237
    3338
     
    7277                                        m_lifeTime(0)
    7378                        {
    74                                 mConstraintRow[0].mAccumImpulse = 0.f;
    75                                 mConstraintRow[1].mAccumImpulse = 0.f;
    76                                 mConstraintRow[2].mAccumImpulse = 0.f;
     79                                mConstraintRow[0].m_accumImpulse = 0.f;
     80                                mConstraintRow[1].m_accumImpulse = 0.f;
     81                                mConstraintRow[2].m_accumImpulse = 0.f;
    7782                        }
    7883
     
    114119
    115120
    116                         PfxConstraintRow mConstraintRow[3];
     121                        btConstraintRow mConstraintRow[3];
    117122
    118123
     
    151156        };
    152157
    153 #endif //MANIFOLD_CONTACT_POINT_H
     158#endif //BT_MANIFOLD_CONTACT_POINT_H
  • code/trunk/src/external/bullet/BulletCollision/NarrowPhaseCollision/btMinkowskiPenetrationDepthSolver.h

    r8351 r8393  
    1414*/
    1515
    16 #ifndef MINKOWSKI_PENETRATION_DEPTH_SOLVER_H
    17 #define MINKOWSKI_PENETRATION_DEPTH_SOLVER_H
     16#ifndef BT_MINKOWSKI_PENETRATION_DEPTH_SOLVER_H
     17#define BT_MINKOWSKI_PENETRATION_DEPTH_SOLVER_H
    1818
    1919#include "btConvexPenetrationDepthSolver.h"
     
    3737};
    3838
    39 #endif //MINKOWSKI_PENETRATION_DEPTH_SOLVER_H
     39#endif //BT_MINKOWSKI_PENETRATION_DEPTH_SOLVER_H
    4040
  • code/trunk/src/external/bullet/BulletCollision/NarrowPhaseCollision/btPersistentManifold.h

    r8351 r8393  
    1414*/
    1515
    16 #ifndef PERSISTENT_MANIFOLD_H
    17 #define PERSISTENT_MANIFOLD_H
     16#ifndef BT_PERSISTENT_MANIFOLD_H
     17#define BT_PERSISTENT_MANIFOLD_H
    1818
    1919
     
    3333extern ContactProcessedCallback gContactProcessedCallback;
    3434
    35 
     35//the enum starts at 1024 to avoid type conflicts with btTypedConstraint
    3636enum btContactManifoldTypes
    3737{
    38         BT_PERSISTENT_MANIFOLD_TYPE = 1,
    39         MAX_CONTACT_MANIFOLD_TYPE
     38        MIN_CONTACT_MANIFOLD_TYPE = 1024,
     39        BT_PERSISTENT_MANIFOLD_TYPE
    4040};
    4141
     
    147147                        //get rid of duplicated userPersistentData pointer
    148148                        m_pointCache[lastUsedIndex].m_userPersistentData = 0;
    149                         m_pointCache[lastUsedIndex].mConstraintRow[0].mAccumImpulse = 0.f;
    150                         m_pointCache[lastUsedIndex].mConstraintRow[1].mAccumImpulse = 0.f;
    151                         m_pointCache[lastUsedIndex].mConstraintRow[2].mAccumImpulse = 0.f;
     149                        m_pointCache[lastUsedIndex].mConstraintRow[0].m_accumImpulse = 0.f;
     150                        m_pointCache[lastUsedIndex].mConstraintRow[1].m_accumImpulse = 0.f;
     151                        m_pointCache[lastUsedIndex].mConstraintRow[2].m_accumImpulse = 0.f;
    152152
    153153                        m_pointCache[lastUsedIndex].m_appliedImpulse = 0.f;
     
    168168#ifdef MAINTAIN_PERSISTENCY
    169169                int     lifeTime = m_pointCache[insertIndex].getLifeTime();
    170                 btScalar        appliedImpulse = m_pointCache[insertIndex].mConstraintRow[0].mAccumImpulse;
    171                 btScalar        appliedLateralImpulse1 = m_pointCache[insertIndex].mConstraintRow[1].mAccumImpulse;
    172                 btScalar        appliedLateralImpulse2 = m_pointCache[insertIndex].mConstraintRow[2].mAccumImpulse;
     170                btScalar        appliedImpulse = m_pointCache[insertIndex].mConstraintRow[0].m_accumImpulse;
     171                btScalar        appliedLateralImpulse1 = m_pointCache[insertIndex].mConstraintRow[1].m_accumImpulse;
     172                btScalar        appliedLateralImpulse2 = m_pointCache[insertIndex].mConstraintRow[2].m_accumImpulse;
    173173//              bool isLateralFrictionInitialized = m_pointCache[insertIndex].m_lateralFrictionInitialized;
    174174               
     
    185185                m_pointCache[insertIndex].m_appliedImpulseLateral2 = appliedLateralImpulse2;
    186186               
    187                 m_pointCache[insertIndex].mConstraintRow[0].mAccumImpulse =  appliedImpulse;
    188                 m_pointCache[insertIndex].mConstraintRow[1].mAccumImpulse = appliedLateralImpulse1;
    189                 m_pointCache[insertIndex].mConstraintRow[2].mAccumImpulse = appliedLateralImpulse2;
     187                m_pointCache[insertIndex].mConstraintRow[0].m_accumImpulse =  appliedImpulse;
     188                m_pointCache[insertIndex].mConstraintRow[1].m_accumImpulse = appliedLateralImpulse1;
     189                m_pointCache[insertIndex].mConstraintRow[2].m_accumImpulse = appliedLateralImpulse2;
    190190
    191191
     
    200200        bool validContactDistance(const btManifoldPoint& pt) const
    201201        {
    202                 return pt.m_distance1 <= getContactBreakingThreshold();
     202                if (pt.m_lifeTime >1)
     203                {
     204                        return pt.m_distance1 <= getContactBreakingThreshold();
     205                }
     206                return pt.m_distance1 <= getContactProcessingThreshold();
     207       
    203208        }
    204209        /// calculated new worldspace coordinates and depth, and reject points that exceed the collision margin
     
    225230
    226231
    227 #endif //PERSISTENT_MANIFOLD_H
     232#endif //BT_PERSISTENT_MANIFOLD_H
  • code/trunk/src/external/bullet/BulletCollision/NarrowPhaseCollision/btPointCollector.h

    r8351 r8393  
    1414*/
    1515
    16 #ifndef POINT_COLLECTOR_H
    17 #define POINT_COLLECTOR_H
     16#ifndef BT_POINT_COLLECTOR_H
     17#define BT_POINT_COLLECTOR_H
    1818
    1919#include "btDiscreteCollisionDetectorInterface.h"
     
    6161};
    6262
    63 #endif //POINT_COLLECTOR_H
     63#endif //BT_POINT_COLLECTOR_H
    6464
  • code/trunk/src/external/bullet/BulletCollision/NarrowPhaseCollision/btRaycastCallback.cpp

    r5781 r8393  
    125125        m_convexShapeTo = convexShapeTo;
    126126        m_triangleToWorld = triangleToWorld;
    127         m_hitFraction = 1.0;
    128     m_triangleCollisionMargin = triangleCollisionMargin;
     127        m_hitFraction = 1.0f;
     128        m_triangleCollisionMargin = triangleCollisionMargin;
     129        m_allowedPenetration = 0.f;
    129130}
    130131
     
    149150        btConvexCast::CastResult castResult;
    150151        castResult.m_fraction = btScalar(1.);
     152        castResult.m_allowedPenetration = m_allowedPenetration;
    151153        if (convexCaster.calcTimeOfImpact(m_convexShapeFrom,m_convexShapeTo,m_triangleToWorld, m_triangleToWorld, castResult))
    152154        {
  • code/trunk/src/external/bullet/BulletCollision/NarrowPhaseCollision/btRaycastCallback.h

    r5781 r8393  
    1414*/
    1515
    16 #ifndef RAYCAST_TRI_CALLBACK_H
    17 #define RAYCAST_TRI_CALLBACK_H
     16#ifndef BT_RAYCAST_TRI_CALLBACK_H
     17#define BT_RAYCAST_TRI_CALLBACK_H
    1818
    1919#include "BulletCollision/CollisionShapes/btTriangleCallback.h"
     
    5959        btTransform m_triangleToWorld;
    6060        btScalar m_hitFraction;
    61     btScalar m_triangleCollisionMargin;
     61        btScalar m_triangleCollisionMargin;
     62        btScalar m_allowedPenetration;
    6263
    6364        btTriangleConvexcastCallback (const btConvexShape* convexShape, const btTransform& convexShapeFrom, const btTransform& convexShapeTo, const btTransform& triangleToWorld, const btScalar triangleCollisionMargin);
     
    6869};
    6970
    70 #endif //RAYCAST_TRI_CALLBACK_H
     71#endif //BT_RAYCAST_TRI_CALLBACK_H
    7172
  • code/trunk/src/external/bullet/BulletCollision/NarrowPhaseCollision/btSimplexSolverInterface.h

    r5781 r8393  
    1616
    1717
    18 #ifndef SIMPLEX_SOLVER_INTERFACE_H
    19 #define SIMPLEX_SOLVER_INTERFACE_H
     18#ifndef BT_SIMPLEX_SOLVER_INTERFACE_H
     19#define BT_SIMPLEX_SOLVER_INTERFACE_H
    2020
    2121#include "LinearMath/btVector3.h"
     
    6060};
    6161#endif
    62 #endif //SIMPLEX_SOLVER_INTERFACE_H
     62#endif //BT_SIMPLEX_SOLVER_INTERFACE_H
    6363
  • code/trunk/src/external/bullet/BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.h

    r5781 r8393  
    1515
    1616
    17 #ifndef SUBSIMPLEX_CONVEX_CAST_H
    18 #define SUBSIMPLEX_CONVEX_CAST_H
     17#ifndef BT_SUBSIMPLEX_CONVEX_CAST_H
     18#define BT_SUBSIMPLEX_CONVEX_CAST_H
    1919
    2020#include "btConvexCast.h"
     
    4848};
    4949
    50 #endif //SUBSIMPLEX_CONVEX_CAST_H
     50#endif //BT_SUBSIMPLEX_CONVEX_CAST_H
  • code/trunk/src/external/bullet/BulletCollision/NarrowPhaseCollision/btVoronoiSimplexSolver.h

    r8351 r8393  
    1616
    1717
    18 #ifndef btVoronoiSimplexSolver_H
    19 #define btVoronoiSimplexSolver_H
     18#ifndef BT_VORONOI_SIMPLEX_SOLVER_H
     19#define BT_VORONOI_SIMPLEX_SOLVER_H
    2020
    2121#include "btSimplexSolverInterface.h"
     
    176176};
    177177
    178 #endif //VoronoiSimplexSolver
     178#endif //BT_VORONOI_SIMPLEX_SOLVER_H
     179
  • code/trunk/src/external/bullet/BulletDynamics/Character/btCharacterControllerInterface.h

    r8351 r8393  
    1414*/
    1515
    16 #ifndef CHARACTER_CONTROLLER_INTERFACE_H
    17 #define CHARACTER_CONTROLLER_INTERFACE_H
     16#ifndef BT_CHARACTER_CONTROLLER_INTERFACE_H
     17#define BT_CHARACTER_CONTROLLER_INTERFACE_H
    1818
    1919#include "LinearMath/btVector3.h"
     
    4343};
    4444
    45 #endif
     45#endif //BT_CHARACTER_CONTROLLER_INTERFACE_H
     46
  • code/trunk/src/external/bullet/BulletDynamics/Character/btKinematicCharacterController.cpp

    r8351 r8393  
    8585                {
    8686                        ///need to transform normal into worldspace
    87                         hitNormalWorld = m_hitCollisionObject->getWorldTransform().getBasis()*convexResult.m_hitNormalLocal;
     87                        hitNormalWorld = convexResult.m_hitCollisionObject->getWorldTransform().getBasis()*convexResult.m_hitNormalLocal;
    8888                }
    8989
  • code/trunk/src/external/bullet/BulletDynamics/Character/btKinematicCharacterController.h

    r8351 r8393  
    1515
    1616
    17 #ifndef KINEMATIC_CHARACTER_CONTROLLER_H
    18 #define KINEMATIC_CHARACTER_CONTROLLER_H
     17#ifndef BT_KINEMATIC_CHARACTER_CONTROLLER_H
     18#define BT_KINEMATIC_CHARACTER_CONTROLLER_H
    1919
    2020#include "LinearMath/btVector3.h"
     
    160160};
    161161
    162 #endif // KINEMATIC_CHARACTER_CONTROLLER_H
     162#endif // BT_KINEMATIC_CHARACTER_CONTROLLER_H
  • code/trunk/src/external/bullet/BulletDynamics/ConstraintSolver/btConeTwistConstraint.cpp

    r8351 r8393  
    11151115
    11161116
    1117 
     1117void btConeTwistConstraint::setFrames(const btTransform & frameA, const btTransform & frameB)
     1118{
     1119        m_rbAFrame = frameA;
     1120        m_rbBFrame = frameB;
     1121        buildJacobian();
     1122        //calculateTransforms();
     1123}
     1124
     1125 
     1126
     1127
  • code/trunk/src/external/bullet/BulletDynamics/ConstraintSolver/btConeTwistConstraint.h

    r8351 r8393  
    3434
    3535
    36 #ifndef CONETWISTCONSTRAINT_H
    37 #define CONETWISTCONSTRAINT_H
     36#ifndef BT_CONETWISTCONSTRAINT_H
     37#define BT_CONETWISTCONSTRAINT_H
    3838
    3939#include "LinearMath/btVector3.h"
     
    144144
    145145        void    updateRHS(btScalar      timeStep);
     146
    146147
    147148        const btRigidBody& getRigidBodyA() const
     
    245246        bool isPastSwingLimit() { return m_solveSwingLimit; }
    246247
    247 
    248248        void setDamping(btScalar damping) { m_damping = damping; }
    249249
     
    269269        ///If no axis is provided, it uses the default axis for this constraint.
    270270        virtual void setParam(int num, btScalar value, int axis = -1);
     271
     272        virtual void setFrames(const btTransform& frameA, const btTransform& frameB);
     273
     274        const btTransform& getFrameOffsetA() const
     275        {
     276                return m_rbAFrame;
     277        }
     278
     279        const btTransform& getFrameOffsetB() const
     280        {
     281                return m_rbBFrame;
     282        }
     283
     284
    271285        ///return the local value of parameter
    272286        virtual btScalar getParam(int num, int axis = -1) const;
     
    330344
    331345
    332 #endif //CONETWISTCONSTRAINT_H
     346#endif //BT_CONETWISTCONSTRAINT_H
  • code/trunk/src/external/bullet/BulletDynamics/ConstraintSolver/btConstraintSolver.h

    r5781 r8393  
    1414*/
    1515
    16 #ifndef CONSTRAINT_SOLVER_H
    17 #define CONSTRAINT_SOLVER_H
     16#ifndef BT_CONSTRAINT_SOLVER_H
     17#define BT_CONSTRAINT_SOLVER_H
    1818
    1919#include "LinearMath/btScalar.h"
     
    5050
    5151
    52 #endif //CONSTRAINT_SOLVER_H
     52#endif //BT_CONSTRAINT_SOLVER_H
  • code/trunk/src/external/bullet/BulletDynamics/ConstraintSolver/btContactConstraint.cpp

    r8351 r8393  
    6969#include "BulletCollision/NarrowPhaseCollision/btManifoldPoint.h"
    7070
    71 #define ASSERT2 btAssert
    7271
    73 #define USE_INTERNAL_APPLY_IMPULSE 1
     72
     73//response  between two dynamic objects without friction, assuming 0 penetration depth
     74btScalar resolveSingleCollision(
     75        btRigidBody* body1,
     76        btCollisionObject* colObj2,
     77                const btVector3& contactPositionWorld,
     78                const btVector3& contactNormalOnB,
     79        const btContactSolverInfo& solverInfo,
     80                btScalar distance)
     81{
     82        btRigidBody* body2 = btRigidBody::upcast(colObj2);
     83   
     84       
     85    const btVector3& normal = contactNormalOnB;
     86
     87    btVector3 rel_pos1 = contactPositionWorld - body1->getWorldTransform().getOrigin();
     88    btVector3 rel_pos2 = contactPositionWorld - colObj2->getWorldTransform().getOrigin();
     89   
     90    btVector3 vel1 = body1->getVelocityInLocalPoint(rel_pos1);
     91        btVector3 vel2 = body2? body2->getVelocityInLocalPoint(rel_pos2) : btVector3(0,0,0);
     92    btVector3 vel = vel1 - vel2;
     93    btScalar rel_vel;
     94    rel_vel = normal.dot(vel);
     95   
     96    btScalar combinedRestitution = body1->getRestitution() * colObj2->getRestitution();
     97    btScalar restitution = combinedRestitution* -rel_vel;
     98
     99    btScalar positionalError = solverInfo.m_erp *-distance /solverInfo.m_timeStep ;
     100    btScalar velocityError = -(1.0f + restitution) * rel_vel;// * damping;
     101        btScalar denom0 = body1->computeImpulseDenominator(contactPositionWorld,normal);
     102        btScalar denom1 = body2? body2->computeImpulseDenominator(contactPositionWorld,normal) : 0.f;
     103        btScalar relaxation = 1.f;
     104        btScalar jacDiagABInv = relaxation/(denom0+denom1);
     105
     106    btScalar penetrationImpulse = positionalError * jacDiagABInv;
     107    btScalar velocityImpulse = velocityError * jacDiagABInv;
     108
     109    btScalar normalImpulse = penetrationImpulse+velocityImpulse;
     110    normalImpulse = 0.f > normalImpulse ? 0.f: normalImpulse;
     111
     112        body1->applyImpulse(normal*(normalImpulse), rel_pos1);
     113    if (body2)
     114                body2->applyImpulse(-normal*(normalImpulse), rel_pos2);
     115   
     116    return normalImpulse;
     117}
    74118
    75119
     
    84128
    85129        btScalar normalLenSqr = normal.length2();
    86         ASSERT2(btFabs(normalLenSqr) < btScalar(1.1));
     130        btAssert(btFabs(normalLenSqr) < btScalar(1.1));
    87131        if (normalLenSqr > btScalar(1.1))
    88132        {
  • code/trunk/src/external/bullet/BulletDynamics/ConstraintSolver/btContactConstraint.h

    r8351 r8393  
    1414*/
    1515
    16 #ifndef CONTACT_CONSTRAINT_H
    17 #define CONTACT_CONSTRAINT_H
     16#ifndef BT_CONTACT_CONSTRAINT_H
     17#define BT_CONTACT_CONSTRAINT_H
    1818
    1919#include "LinearMath/btVector3.h"
     
    5858};
    5959
     60///very basic collision resolution without friction
     61btScalar resolveSingleCollision(btRigidBody* body1, class btCollisionObject* colObj2, const btVector3& contactPositionWorld,const btVector3& contactNormalOnB, const struct btContactSolverInfo& solverInfo,btScalar distance);
     62
    6063
    6164///resolveSingleBilateral is an obsolete methods used for vehicle friction between two dynamic objects
     
    6669
    6770
    68 #endif //CONTACT_CONSTRAINT_H
     71#endif //BT_CONTACT_CONSTRAINT_H
  • code/trunk/src/external/bullet/BulletDynamics/ConstraintSolver/btContactSolverInfo.h

    r8351 r8393  
    1414*/
    1515
    16 #ifndef CONTACT_SOLVER_INFO
    17 #define CONTACT_SOLVER_INFO
     16#ifndef BT_CONTACT_SOLVER_INFO
     17#define BT_CONTACT_SOLVER_INFO
    1818
    1919enum    btSolverMode
     
    8585};
    8686
    87 #endif //CONTACT_SOLVER_INFO
     87#endif //BT_CONTACT_SOLVER_INFO
  • code/trunk/src/external/bullet/BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.cpp

    r8351 r8393  
    711711        (void)timeStep;
    712712
     713}
     714
     715
     716void btGeneric6DofConstraint::setFrames(const btTransform& frameA, const btTransform& frameB)
     717{
     718        m_frameInA = frameA;
     719        m_frameInB = frameB;
     720        buildJacobian();
     721        calculateTransforms();
    713722}
    714723
     
    10391048        return retVal;
    10401049}
     1050
     1051 
     1052
     1053void btGeneric6DofConstraint::setAxis(const btVector3& axis1,const btVector3& axis2)
     1054{
     1055        btVector3 zAxis = axis1.normalized();
     1056        btVector3 yAxis = axis2.normalized();
     1057        btVector3 xAxis = yAxis.cross(zAxis); // we want right coordinate system
     1058       
     1059        btTransform frameInW;
     1060        frameInW.setIdentity();
     1061        frameInW.getBasis().setValue(   xAxis[0], yAxis[0], zAxis[0],   
     1062                                        xAxis[1], yAxis[1], zAxis[1],
     1063                                       xAxis[2], yAxis[2], zAxis[2]);
     1064       
     1065        // now get constraint frame in local coordinate systems
     1066        m_frameInA = m_rbA.getCenterOfMassTransform().inverse() * frameInW;
     1067        m_frameInB = m_rbB.getCenterOfMassTransform().inverse() * frameInW;
     1068       
     1069        calculateTransforms();
     1070}
  • code/trunk/src/external/bullet/BulletDynamics/ConstraintSolver/btGeneric6DofConstraint.h

    r8351 r8393  
    2525
    2626
    27 #ifndef GENERIC_6DOF_CONSTRAINT_H
    28 #define GENERIC_6DOF_CONSTRAINT_H
     27#ifndef BT_GENERIC_6DOF_CONSTRAINT_H
     28#define BT_GENERIC_6DOF_CONSTRAINT_H
    2929
    3030#include "LinearMath/btVector3.h"
     
    434434        btScalar getRelativePivotPosition(int axis_index) const;
    435435
     436        void setFrames(const btTransform & frameA, const btTransform & frameB);
    436437
    437438        //! Test angular limit.
     
    447448    }
    448449
    449     void        setLinearUpperLimit(const btVector3& linearUpper)
    450     {
    451         m_linearLimits.m_upperLimit = linearUpper;
    452     }
     450        void    getLinearLowerLimit(btVector3& linearLower)
     451        {
     452                linearLower = m_linearLimits.m_lowerLimit;
     453        }
     454
     455        void    setLinearUpperLimit(const btVector3& linearUpper)
     456        {
     457                m_linearLimits.m_upperLimit = linearUpper;
     458        }
     459
     460        void    getLinearUpperLimit(btVector3& linearUpper)
     461        {
     462                linearUpper = m_linearLimits.m_upperLimit;
     463        }
    453464
    454465    void        setAngularLowerLimit(const btVector3& angularLower)
     
    458469    }
    459470
     471        void    getAngularLowerLimit(btVector3& angularLower)
     472        {
     473                for(int i = 0; i < 3; i++)
     474                        angularLower[i] = m_angularLimits[i].m_loLimit;
     475        }
     476
    460477    void        setAngularUpperLimit(const btVector3& angularUpper)
    461478    {
     
    463480                        m_angularLimits[i].m_hiLimit = btNormalizeAngle(angularUpper[i]);
    464481    }
     482
     483        void    getAngularUpperLimit(btVector3& angularUpper)
     484        {
     485                for(int i = 0; i < 3; i++)
     486                        angularUpper[i] = m_angularLimits[i].m_hiLimit;
     487        }
    465488
    466489        //! Retrieves the angular limit informacion
     
    526549        virtual btScalar getParam(int num, int axis = -1) const;
    527550
     551        void setAxis( const btVector3& axis1, const btVector3& axis2);
     552
     553
    528554        virtual int     calculateSerializeBufferSize() const;
    529555
     
    586612
    587613
    588 #endif //GENERIC_6DOF_CONSTRAINT_H
     614#endif //BT_GENERIC_6DOF_CONSTRAINT_H
  • code/trunk/src/external/bullet/BulletDynamics/ConstraintSolver/btGeneric6DofSpringConstraint.cpp

    r8351 r8393  
    2222        : btGeneric6DofConstraint(rbA, rbB, frameInA, frameInB, useLinearReferenceFrameA)
    2323{
     24        m_objectType = D6_SPRING_CONSTRAINT_TYPE;
     25
    2426        for(int i = 0; i < 6; i++)
    2527        {
     
    148150
    149151
     152void btGeneric6DofSpringConstraint::setAxis(const btVector3& axis1,const btVector3& axis2)
     153{
     154        btVector3 zAxis = axis1.normalized();
     155        btVector3 yAxis = axis2.normalized();
     156        btVector3 xAxis = yAxis.cross(zAxis); // we want right coordinate system
     157
     158        btTransform frameInW;
     159        frameInW.setIdentity();
     160        frameInW.getBasis().setValue(   xAxis[0], yAxis[0], zAxis[0],   
     161                                xAxis[1], yAxis[1], zAxis[1],
     162                                xAxis[2], yAxis[2], zAxis[2]);
     163
     164        // now get constraint frame in local coordinate systems
     165        m_frameInA = m_rbA.getCenterOfMassTransform().inverse() * frameInW;
     166        m_frameInB = m_rbB.getCenterOfMassTransform().inverse() * frameInW;
     167
     168  calculateTransforms();
     169}
    150170
    151171
     172
  • code/trunk/src/external/bullet/BulletDynamics/ConstraintSolver/btGeneric6DofSpringConstraint.h

    r8351 r8393  
    1414*/
    1515
    16 #ifndef GENERIC_6DOF_SPRING_CONSTRAINT_H
    17 #define GENERIC_6DOF_SPRING_CONSTRAINT_H
     16#ifndef BT_GENERIC_6DOF_SPRING_CONSTRAINT_H
     17#define BT_GENERIC_6DOF_SPRING_CONSTRAINT_H
    1818
    1919
     
    4949        void setEquilibriumPoint(int index);  // set the current constraint position/orientation as an equilibrium point for given DOF
    5050        void setEquilibriumPoint(int index, btScalar val);
     51
     52        virtual void setAxis( const btVector3& axis1, const btVector3& axis2);
     53
    5154        virtual void getInfo2 (btConstraintInfo2* info);
     55
     56        virtual int     calculateSerializeBufferSize() const;
     57        ///fills the dataBuffer and returns the struct name (and 0 on failure)
     58        virtual const char*     serialize(void* dataBuffer, btSerializer* serializer) const;
     59
    5260};
    5361
    54 #endif // GENERIC_6DOF_SPRING_CONSTRAINT_H
    5562
     63///do not change those serialization structures, it requires an updated sBulletDNAstr/sBulletDNAstr64
     64struct btGeneric6DofSpringConstraintData
     65{
     66        btGeneric6DofConstraintData     m_6dofData;
     67       
     68        int                     m_springEnabled[6];
     69        float           m_equilibriumPoint[6];
     70        float           m_springStiffness[6];
     71        float           m_springDamping[6];
     72};
     73
     74SIMD_FORCE_INLINE       int     btGeneric6DofSpringConstraint::calculateSerializeBufferSize() const
     75{
     76        return sizeof(btGeneric6DofSpringConstraintData);
     77}
     78
     79        ///fills the dataBuffer and returns the struct name (and 0 on failure)
     80SIMD_FORCE_INLINE       const char*     btGeneric6DofSpringConstraint::serialize(void* dataBuffer, btSerializer* serializer) const
     81{
     82        btGeneric6DofSpringConstraintData* dof = (btGeneric6DofSpringConstraintData*)dataBuffer;
     83        btGeneric6DofConstraint::serialize(&dof->m_6dofData,serializer);
     84
     85        int i;
     86        for (i=0;i<6;i++)
     87        {
     88                dof->m_equilibriumPoint[i] = m_equilibriumPoint[i];
     89                dof->m_springDamping[i] = m_springDamping[i];
     90                dof->m_springEnabled[i] = m_springEnabled[i]? 1 : 0;
     91                dof->m_springStiffness[i] = m_springStiffness[i];
     92        }
     93        return "btGeneric6DofConstraintData";
     94}
     95
     96#endif // BT_GENERIC_6DOF_SPRING_CONSTRAINT_H
     97
  • code/trunk/src/external/bullet/BulletDynamics/ConstraintSolver/btHinge2Constraint.h

    r8351 r8393  
    1414*/
    1515
    16 #ifndef HINGE2_CONSTRAINT_H
    17 #define HINGE2_CONSTRAINT_H
     16#ifndef BT_HINGE2_CONSTRAINT_H
     17#define BT_HINGE2_CONSTRAINT_H
    1818
    1919
     
    5555
    5656
    57 #endif // HINGE2_CONSTRAINT_H
     57#endif // BT_HINGE2_CONSTRAINT_H
    5858
  • code/trunk/src/external/bullet/BulletDynamics/ConstraintSolver/btHingeConstraint.cpp

    r8351 r8393  
    4444                                                                         m_useReferenceFrameA(useReferenceFrameA),
    4545                                                                         m_flags(0)
     46#ifdef _BT_USE_CENTER_LIMIT_
     47                                                                        ,m_limit()
     48#endif
    4649{
    4750        m_rbAFrame.getOrigin() = pivotInA;
     
    7679                                                                        rbAxisB1.getZ(),rbAxisB2.getZ(),axisInB.getZ() );
    7780       
     81#ifndef _BT_USE_CENTER_LIMIT_
    7882        //start with free
    7983        m_lowerLimit = btScalar(1.0f);
     
    8387        m_limitSoftness = 0.9f;
    8488        m_solveLimit = false;
     89#endif
    8590        m_referenceSign = m_useReferenceFrameA ? btScalar(-1.f) : btScalar(1.f);
    8691}
     
    9499m_useReferenceFrameA(useReferenceFrameA),
    95100m_flags(0)
     101#ifdef  _BT_USE_CENTER_LIMIT_
     102,m_limit()
     103#endif
    96104{
    97105
     
    118126                                                                        rbAxisB1.getZ(),rbAxisB2.getZ(),axisInB.getZ() );
    119127       
     128#ifndef _BT_USE_CENTER_LIMIT_
    120129        //start with free
    121130        m_lowerLimit = btScalar(1.0f);
     
    125134        m_limitSoftness = 0.9f;
    126135        m_solveLimit = false;
     136#endif
    127137        m_referenceSign = m_useReferenceFrameA ? btScalar(-1.f) : btScalar(1.f);
    128138}
     
    139149m_useReferenceFrameA(useReferenceFrameA),
    140150m_flags(0)
    141 {
     151#ifdef  _BT_USE_CENTER_LIMIT_
     152,m_limit()
     153#endif
     154{
     155#ifndef _BT_USE_CENTER_LIMIT_
    142156        //start with free
    143157        m_lowerLimit = btScalar(1.0f);
     
    147161        m_limitSoftness = 0.9f;
    148162        m_solveLimit = false;
     163#endif
    149164        m_referenceSign = m_useReferenceFrameA ? btScalar(-1.f) : btScalar(1.f);
    150165}                       
     
    160175m_useReferenceFrameA(useReferenceFrameA),
    161176m_flags(0)
     177#ifdef  _BT_USE_CENTER_LIMIT_
     178,m_limit()
     179#endif
    162180{
    163181        ///not providing rigidbody B means implicitly using worldspace for body B
    164182
    165183        m_rbBFrame.getOrigin() = m_rbA.getCenterOfMassTransform()(m_rbAFrame.getOrigin());
    166 
     184#ifndef _BT_USE_CENTER_LIMIT_
    167185        //start with free
    168186        m_lowerLimit = btScalar(1.0f);
     
    172190        m_limitSoftness = 0.9f;
    173191        m_solveLimit = false;
     192#endif
    174193        m_referenceSign = m_useReferenceFrameA ? btScalar(-1.f) : btScalar(1.f);
    175194}
     
    450469        if(getSolveLimit())
    451470        {
    452                 limit_err = m_correction * m_referenceSign;
    453                 limit = (limit_err > btScalar(0.0)) ? 1 : 2;
     471#ifdef  _BT_USE_CENTER_LIMIT_
     472        limit_err = m_limit.getCorrection() * m_referenceSign;
     473#else
     474        limit_err = m_correction * m_referenceSign;
     475#endif
     476        limit = (limit_err > btScalar(0.0)) ? 1 : 2;
     477
    454478        }
    455479        // if the hinge has joint limits or motor, add in the extra row
     
    515539                        }
    516540                        // bounce (we'll use slider parameter abs(1.0 - m_dampingLimAng) for that)
     541#ifdef  _BT_USE_CENTER_LIMIT_
     542                        btScalar bounce = m_limit.getRelaxationFactor();
     543#else
    517544                        btScalar bounce = m_relaxationFactor;
     545#endif
    518546                        if(bounce > btScalar(0.0))
    519547                        {
     
    545573                                }
    546574                        }
     575#ifdef  _BT_USE_CENTER_LIMIT_
     576                        info->m_constraintError[srow] *= m_limit.getBiasFactor();
     577#else
    547578                        info->m_constraintError[srow] *= m_biasFactor;
     579#endif
    548580                } // if(limit)
    549581        } // if angular limit or powered
     
    551583
    552584
    553 
    554 
     585void btHingeConstraint::setFrames(const btTransform & frameA, const btTransform & frameB)
     586{
     587        m_rbAFrame = frameA;
     588        m_rbBFrame = frameB;
     589        buildJacobian();
     590}
    555591
    556592
     
    578614
    579615
    580 #if 0
    581 void btHingeConstraint::testLimit()
    582 {
    583         // Compute limit information
    584         m_hingeAngle = getHingeAngle(); 
    585         m_correction = btScalar(0.);
    586         m_limitSign = btScalar(0.);
    587         m_solveLimit = false;
    588         if (m_lowerLimit <= m_upperLimit)
    589         {
    590                 if (m_hingeAngle <= m_lowerLimit)
    591                 {
    592                         m_correction = (m_lowerLimit - m_hingeAngle);
    593                         m_limitSign = 1.0f;
    594                         m_solveLimit = true;
    595                 }
    596                 else if (m_hingeAngle >= m_upperLimit)
    597                 {
    598                         m_correction = m_upperLimit - m_hingeAngle;
    599                         m_limitSign = -1.0f;
    600                         m_solveLimit = true;
    601                 }
    602         }
    603         return;
    604 }
    605 #else
    606 
    607616
    608617void btHingeConstraint::testLimit(const btTransform& transA,const btTransform& transB)
     
    610619        // Compute limit information
    611620        m_hingeAngle = getHingeAngle(transA,transB);
     621#ifdef  _BT_USE_CENTER_LIMIT_
     622        m_limit.test(m_hingeAngle);
     623#else
    612624        m_correction = btScalar(0.);
    613625        m_limitSign = btScalar(0.);
     
    629641                }
    630642        }
     643#endif
    631644        return;
    632645}
    633 #endif
     646
    634647
    635648static btVector3 vHinge(0, 0, btScalar(1));
     
    662675void btHingeConstraint::setMotorTarget(btScalar targetAngle, btScalar dt)
    663676{
     677#ifdef  _BT_USE_CENTER_LIMIT_
     678        m_limit.fit(targetAngle);
     679#else
    664680        if (m_lowerLimit < m_upperLimit)
    665681        {
     
    669685                        targetAngle = m_upperLimit;
    670686        }
    671 
     687#endif
    672688        // compute angular velocity
    673689        btScalar curAngle  = getHingeAngle(m_rbA.getCenterOfMassTransform(),m_rbB.getCenterOfMassTransform());
     
    840856        if(getSolveLimit())
    841857        {
    842                 limit_err = m_correction * m_referenceSign;
    843                 limit = (limit_err > btScalar(0.0)) ? 1 : 2;
     858#ifdef  _BT_USE_CENTER_LIMIT_
     859        limit_err = m_limit.getCorrection() * m_referenceSign;
     860#else
     861        limit_err = m_correction * m_referenceSign;
     862#endif
     863        limit = (limit_err > btScalar(0.0)) ? 1 : 2;
     864
    844865        }
    845866        // if the hinge has joint limits or motor, add in the extra row
     
    905926                        }
    906927                        // boun