1001 lines
31 KiB
C++
1001 lines
31 KiB
C++
/*
|
|
Bullet Continuous Collision Detection and Physics Library
|
|
Copyright (c) 2003-2008 Erwin Coumans http://bulletphysics.com
|
|
|
|
This software is provided 'as-is', without any express or implied warranty.
|
|
In no event will the authors be held liable for any damages arising from the use of this software.
|
|
Permission is granted to anyone to use this software for any purpose,
|
|
including commercial applications, and to alter it and redistribute it freely,
|
|
subject to the following restrictions:
|
|
|
|
1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
|
|
2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
|
|
3. This notice may not be removed or altered from any source distribution.
|
|
*/
|
|
|
|
|
|
#include <stdio.h>
|
|
#include "LinearMath/btIDebugDraw.h"
|
|
#include "BulletCollision/CollisionDispatch/btGhostObject.h"
|
|
#include "BulletCollision/CollisionShapes/btMultiSphereShape.h"
|
|
#include "BulletCollision/BroadphaseCollision/btOverlappingPairCache.h"
|
|
#include "BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h"
|
|
#include "BulletCollision/CollisionDispatch/btCollisionWorld.h"
|
|
#include "LinearMath/btDefaultMotionState.h"
|
|
#include "btKinematicCharacterController.h"
|
|
|
|
|
|
// static helper method
|
|
static btVector3
|
|
getNormalizedVector(const btVector3& v)
|
|
{
|
|
btVector3 n(0, 0, 0);
|
|
|
|
if (v.length() > SIMD_EPSILON) {
|
|
n = v.normalized();
|
|
}
|
|
return n;
|
|
}
|
|
|
|
|
|
///@todo Interact with dynamic objects,
|
|
///Ride kinematicly animated platforms properly
|
|
///More realistic (or maybe just a config option) falling
|
|
/// -> Should integrate falling velocity manually and use that in stepDown()
|
|
///Support jumping
|
|
///Support ducking
|
|
class btKinematicClosestNotMeRayResultCallback : public btCollisionWorld::ClosestRayResultCallback
|
|
{
|
|
public:
|
|
btKinematicClosestNotMeRayResultCallback (btCollisionObject* me) : btCollisionWorld::ClosestRayResultCallback(btVector3(0.0, 0.0, 0.0), btVector3(0.0, 0.0, 0.0))
|
|
{
|
|
m_me = me;
|
|
}
|
|
|
|
virtual btScalar addSingleResult(btCollisionWorld::LocalRayResult& rayResult,bool normalInWorldSpace)
|
|
{
|
|
if (rayResult.m_collisionObject == m_me)
|
|
return 1.0;
|
|
|
|
return ClosestRayResultCallback::addSingleResult (rayResult, normalInWorldSpace);
|
|
}
|
|
protected:
|
|
btCollisionObject* m_me;
|
|
};
|
|
|
|
class btKinematicClosestNotMeConvexResultCallback : public btCollisionWorld::ClosestConvexResultCallback
|
|
{
|
|
public:
|
|
btKinematicClosestNotMeConvexResultCallback (btCollisionObject* me, const btVector3& up, btScalar minSlopeDot)
|
|
: btCollisionWorld::ClosestConvexResultCallback(btVector3(0.0, 0.0, 0.0), btVector3(0.0, 0.0, 0.0))
|
|
, m_me(me)
|
|
, m_up(up)
|
|
, m_minSlopeDot(minSlopeDot)
|
|
{
|
|
}
|
|
|
|
virtual btScalar addSingleResult(btCollisionWorld::LocalConvexResult& convexResult,bool normalInWorldSpace)
|
|
{
|
|
if (convexResult.m_hitCollisionObject == m_me)
|
|
return btScalar(1.0);
|
|
|
|
if (!convexResult.m_hitCollisionObject->hasContactResponse())
|
|
return btScalar(1.0);
|
|
|
|
btVector3 hitNormalWorld;
|
|
if (normalInWorldSpace)
|
|
{
|
|
hitNormalWorld = convexResult.m_hitNormalLocal;
|
|
} else
|
|
{
|
|
///need to transform normal into worldspace
|
|
hitNormalWorld = convexResult.m_hitCollisionObject->getWorldTransform().getBasis()*convexResult.m_hitNormalLocal;
|
|
}
|
|
|
|
btScalar dotUp = m_up.dot(hitNormalWorld);
|
|
if (dotUp < m_minSlopeDot) {
|
|
return btScalar(1.0);
|
|
}
|
|
|
|
return ClosestConvexResultCallback::addSingleResult (convexResult, normalInWorldSpace);
|
|
}
|
|
protected:
|
|
btCollisionObject* m_me;
|
|
const btVector3 m_up;
|
|
btScalar m_minSlopeDot;
|
|
};
|
|
|
|
/*
|
|
* Returns the reflection direction of a ray going 'direction' hitting a surface with normal 'normal'
|
|
*
|
|
* from: http://www-cs-students.stanford.edu/~adityagp/final/node3.html
|
|
*/
|
|
btVector3 btKinematicCharacterController::computeReflectionDirection (const btVector3& direction, const btVector3& normal)
|
|
{
|
|
return direction - (btScalar(2.0) * direction.dot(normal)) * normal;
|
|
}
|
|
|
|
/*
|
|
* Returns the portion of 'direction' that is parallel to 'normal'
|
|
*/
|
|
btVector3 btKinematicCharacterController::parallelComponent (const btVector3& direction, const btVector3& normal)
|
|
{
|
|
btScalar magnitude = direction.dot(normal);
|
|
return normal * magnitude;
|
|
}
|
|
|
|
/*
|
|
* Returns the portion of 'direction' that is perpindicular to 'normal'
|
|
*/
|
|
btVector3 btKinematicCharacterController::perpindicularComponent (const btVector3& direction, const btVector3& normal)
|
|
{
|
|
return direction - parallelComponent(direction, normal);
|
|
}
|
|
|
|
btKinematicCharacterController::btKinematicCharacterController (btPairCachingGhostObject* ghostObject,btConvexShape* convexShape,btScalar stepHeight, const btVector3& up)
|
|
{
|
|
m_ghostObject = ghostObject;
|
|
m_up.setValue(0.0f, 0.0f, 1.0f);
|
|
m_jumpAxis.setValue(0.0f, 0.0f, 1.0f);
|
|
m_addedMargin = 0.02;
|
|
m_walkDirection.setValue(0.0,0.0,0.0);
|
|
m_AngVel.setValue(0.0, 0.0, 0.0);
|
|
m_useGhostObjectSweepTest = true;
|
|
m_turnAngle = btScalar(0.0);
|
|
m_convexShape=convexShape;
|
|
m_useWalkDirection = true; // use walk direction by default, legacy behavior
|
|
m_velocityTimeInterval = 0.0;
|
|
m_verticalVelocity = 0.0;
|
|
m_verticalOffset = 0.0;
|
|
m_gravity = 9.8 * 3.0 ; // 3G acceleration.
|
|
m_fallSpeed = 55.0; // Terminal velocity of a sky diver in m/s.
|
|
m_jumpSpeed = 10.0; // ?
|
|
m_SetjumpSpeed = m_jumpSpeed;
|
|
m_wasOnGround = false;
|
|
m_wasJumping = false;
|
|
m_interpolateUp = true;
|
|
m_currentStepOffset = 0.0;
|
|
m_maxPenetrationDepth = 0.2;
|
|
full_drop = false;
|
|
bounce_fix = false;
|
|
m_linearDamping = btScalar(0.0);
|
|
m_angularDamping = btScalar(0.0);
|
|
|
|
setUp(up);
|
|
setStepHeight(stepHeight);
|
|
setMaxSlope(btRadians(45.0));
|
|
}
|
|
|
|
btKinematicCharacterController::~btKinematicCharacterController ()
|
|
{
|
|
}
|
|
|
|
btPairCachingGhostObject* btKinematicCharacterController::getGhostObject()
|
|
{
|
|
return m_ghostObject;
|
|
}
|
|
|
|
bool btKinematicCharacterController::recoverFromPenetration ( btCollisionWorld* collisionWorld)
|
|
{
|
|
// Here we must refresh the overlapping paircache as the penetrating movement itself or the
|
|
// previous recovery iteration might have used setWorldTransform and pushed us into an object
|
|
// that is not in the previous cache contents from the last timestep, as will happen if we
|
|
// are pushed into a new AABB overlap. Unhandled this means the next convex sweep gets stuck.
|
|
//
|
|
// Do this by calling the broadphase's setAabb with the moved AABB, this will update the broadphase
|
|
// paircache and the ghostobject's internal paircache at the same time. /BW
|
|
|
|
btVector3 minAabb, maxAabb;
|
|
m_convexShape->getAabb(m_ghostObject->getWorldTransform(), minAabb,maxAabb);
|
|
collisionWorld->getBroadphase()->setAabb(m_ghostObject->getBroadphaseHandle(),
|
|
minAabb,
|
|
maxAabb,
|
|
collisionWorld->getDispatcher());
|
|
|
|
bool penetration = false;
|
|
|
|
collisionWorld->getDispatcher()->dispatchAllCollisionPairs(m_ghostObject->getOverlappingPairCache(), collisionWorld->getDispatchInfo(), collisionWorld->getDispatcher());
|
|
|
|
m_currentPosition = m_ghostObject->getWorldTransform().getOrigin();
|
|
|
|
// btScalar maxPen = btScalar(0.0);
|
|
for (int i = 0; i < m_ghostObject->getOverlappingPairCache()->getNumOverlappingPairs(); i++)
|
|
{
|
|
m_manifoldArray.resize(0);
|
|
|
|
btBroadphasePair* collisionPair = &m_ghostObject->getOverlappingPairCache()->getOverlappingPairArray()[i];
|
|
|
|
btCollisionObject* obj0 = static_cast<btCollisionObject*>(collisionPair->m_pProxy0->m_clientObject);
|
|
btCollisionObject* obj1 = static_cast<btCollisionObject*>(collisionPair->m_pProxy1->m_clientObject);
|
|
|
|
if ((obj0 && !obj0->hasContactResponse()) || (obj1 && !obj1->hasContactResponse()))
|
|
continue;
|
|
|
|
if (!needsCollision(obj0, obj1))
|
|
continue;
|
|
|
|
if (collisionPair->m_algorithm)
|
|
collisionPair->m_algorithm->getAllContactManifolds(m_manifoldArray);
|
|
|
|
|
|
for (int j=0;j<m_manifoldArray.size();j++)
|
|
{
|
|
btPersistentManifold* manifold = m_manifoldArray[j];
|
|
btScalar directionSign = manifold->getBody0() == m_ghostObject ? btScalar(-1.0) : btScalar(1.0);
|
|
for (int p=0;p<manifold->getNumContacts();p++)
|
|
{
|
|
const btManifoldPoint&pt = manifold->getContactPoint(p);
|
|
|
|
btScalar dist = pt.getDistance();
|
|
|
|
if (dist < -m_maxPenetrationDepth)
|
|
{
|
|
// TODO: cause problems on slopes, not sure if it is needed
|
|
//if (dist < maxPen)
|
|
//{
|
|
// maxPen = dist;
|
|
// m_touchingNormal = pt.m_normalWorldOnB * directionSign;//??
|
|
|
|
//}
|
|
m_currentPosition += pt.m_normalWorldOnB * directionSign * dist * btScalar(0.2);
|
|
penetration = true;
|
|
} else {
|
|
//printf("touching %f\n", dist);
|
|
}
|
|
}
|
|
|
|
//manifold->clearManifold();
|
|
}
|
|
}
|
|
btTransform newTrans = m_ghostObject->getWorldTransform();
|
|
newTrans.setOrigin(m_currentPosition);
|
|
m_ghostObject->setWorldTransform(newTrans);
|
|
// printf("m_touchingNormal = %f,%f,%f\n",m_touchingNormal[0],m_touchingNormal[1],m_touchingNormal[2]);
|
|
return penetration;
|
|
}
|
|
|
|
void btKinematicCharacterController::stepUp ( btCollisionWorld* world)
|
|
{
|
|
btScalar stepHeight = 0.0f;
|
|
if (m_verticalVelocity < 0.0)
|
|
stepHeight = m_stepHeight;
|
|
|
|
// phase 1: up
|
|
btTransform start, end;
|
|
|
|
start.setIdentity ();
|
|
end.setIdentity ();
|
|
|
|
/* FIXME: Handle penetration properly */
|
|
start.setOrigin(m_currentPosition);
|
|
|
|
m_targetPosition = m_currentPosition + m_up * (stepHeight) + m_jumpAxis * ((m_verticalOffset > 0.f ? m_verticalOffset : 0.f));
|
|
m_currentPosition = m_targetPosition;
|
|
|
|
end.setOrigin (m_targetPosition);
|
|
|
|
start.setRotation(m_currentOrientation);
|
|
end.setRotation(m_targetOrientation);
|
|
|
|
btKinematicClosestNotMeConvexResultCallback callback(m_ghostObject, -m_up, m_maxSlopeCosine);
|
|
callback.m_collisionFilterGroup = getGhostObject()->getBroadphaseHandle()->m_collisionFilterGroup;
|
|
callback.m_collisionFilterMask = getGhostObject()->getBroadphaseHandle()->m_collisionFilterMask;
|
|
|
|
if (m_useGhostObjectSweepTest)
|
|
{
|
|
m_ghostObject->convexSweepTest (m_convexShape, start, end, callback, world->getDispatchInfo().m_allowedCcdPenetration);
|
|
}
|
|
else
|
|
{
|
|
world->convexSweepTest(m_convexShape, start, end, callback, world->getDispatchInfo().m_allowedCcdPenetration);
|
|
}
|
|
|
|
if (callback.hasHit() && m_ghostObject->hasContactResponse() && needsCollision(m_ghostObject, callback.m_hitCollisionObject))
|
|
{
|
|
// Only modify the position if the hit was a slope and not a wall or ceiling.
|
|
if (callback.m_hitNormalWorld.dot(m_up) > 0.0)
|
|
{
|
|
// we moved up only a fraction of the step height
|
|
m_currentStepOffset = stepHeight * callback.m_closestHitFraction;
|
|
if (m_interpolateUp == true)
|
|
m_currentPosition.setInterpolate3 (m_currentPosition, m_targetPosition, callback.m_closestHitFraction);
|
|
else
|
|
m_currentPosition = m_targetPosition;
|
|
}
|
|
|
|
btTransform& xform = m_ghostObject->getWorldTransform();
|
|
xform.setOrigin(m_currentPosition);
|
|
m_ghostObject->setWorldTransform(xform);
|
|
|
|
// fix penetration if we hit a ceiling for example
|
|
int numPenetrationLoops = 0;
|
|
m_touchingContact = false;
|
|
while (recoverFromPenetration(world))
|
|
{
|
|
numPenetrationLoops++;
|
|
m_touchingContact = true;
|
|
if (numPenetrationLoops > 4)
|
|
{
|
|
//printf("character could not recover from penetration = %d\n", numPenetrationLoops);
|
|
break;
|
|
}
|
|
}
|
|
m_targetPosition = m_ghostObject->getWorldTransform().getOrigin();
|
|
m_currentPosition = m_targetPosition;
|
|
|
|
if (m_verticalOffset > 0)
|
|
{
|
|
m_verticalOffset = 0.0;
|
|
m_verticalVelocity = 0.0;
|
|
m_currentStepOffset = m_stepHeight;
|
|
}
|
|
} else {
|
|
m_currentStepOffset = stepHeight;
|
|
m_currentPosition = m_targetPosition;
|
|
}
|
|
}
|
|
|
|
bool btKinematicCharacterController::needsCollision(const btCollisionObject* body0, const btCollisionObject* body1)
|
|
{
|
|
bool collides = (body0->getBroadphaseHandle()->m_collisionFilterGroup & body1->getBroadphaseHandle()->m_collisionFilterMask) != 0;
|
|
collides = collides && (body1->getBroadphaseHandle()->m_collisionFilterGroup & body0->getBroadphaseHandle()->m_collisionFilterMask);
|
|
return collides;
|
|
}
|
|
|
|
void btKinematicCharacterController::updateTargetPositionBasedOnCollision (const btVector3& hitNormal, btScalar tangentMag, btScalar normalMag)
|
|
{
|
|
btVector3 movementDirection = m_targetPosition - m_currentPosition;
|
|
btScalar movementLength = movementDirection.length();
|
|
if (movementLength>SIMD_EPSILON)
|
|
{
|
|
movementDirection.normalize();
|
|
|
|
btVector3 reflectDir = computeReflectionDirection (movementDirection, hitNormal);
|
|
reflectDir.normalize();
|
|
|
|
btVector3 parallelDir, perpindicularDir;
|
|
|
|
parallelDir = parallelComponent (reflectDir, hitNormal);
|
|
perpindicularDir = perpindicularComponent (reflectDir, hitNormal);
|
|
|
|
m_targetPosition = m_currentPosition;
|
|
if (0)//tangentMag != 0.0)
|
|
{
|
|
btVector3 parComponent = parallelDir * btScalar (tangentMag*movementLength);
|
|
// printf("parComponent=%f,%f,%f\n",parComponent[0],parComponent[1],parComponent[2]);
|
|
m_targetPosition += parComponent;
|
|
}
|
|
|
|
if (normalMag != 0.0)
|
|
{
|
|
btVector3 perpComponent = perpindicularDir * btScalar (normalMag*movementLength);
|
|
// printf("perpComponent=%f,%f,%f\n",perpComponent[0],perpComponent[1],perpComponent[2]);
|
|
m_targetPosition += perpComponent;
|
|
}
|
|
} else
|
|
{
|
|
// printf("movementLength don't normalize a zero vector\n");
|
|
}
|
|
}
|
|
|
|
void btKinematicCharacterController::stepForwardAndStrafe ( btCollisionWorld* collisionWorld, const btVector3& walkMove)
|
|
{
|
|
// printf("m_normalizedDirection=%f,%f,%f\n",
|
|
// m_normalizedDirection[0],m_normalizedDirection[1],m_normalizedDirection[2]);
|
|
// phase 2: forward and strafe
|
|
btTransform start, end;
|
|
|
|
m_targetPosition = m_currentPosition + walkMove;
|
|
|
|
start.setIdentity ();
|
|
end.setIdentity ();
|
|
|
|
btScalar fraction = 1.0;
|
|
btScalar distance2 = (m_currentPosition-m_targetPosition).length2();
|
|
// printf("distance2=%f\n",distance2);
|
|
|
|
int maxIter = 10;
|
|
|
|
while (fraction > btScalar(0.01) && maxIter-- > 0)
|
|
{
|
|
start.setOrigin (m_currentPosition);
|
|
end.setOrigin (m_targetPosition);
|
|
btVector3 sweepDirNegative(m_currentPosition - m_targetPosition);
|
|
|
|
start.setRotation(m_currentOrientation);
|
|
end.setRotation(m_targetOrientation);
|
|
|
|
btKinematicClosestNotMeConvexResultCallback callback (m_ghostObject, sweepDirNegative, btScalar(0.0));
|
|
callback.m_collisionFilterGroup = getGhostObject()->getBroadphaseHandle()->m_collisionFilterGroup;
|
|
callback.m_collisionFilterMask = getGhostObject()->getBroadphaseHandle()->m_collisionFilterMask;
|
|
|
|
|
|
btScalar margin = m_convexShape->getMargin();
|
|
m_convexShape->setMargin(margin + m_addedMargin);
|
|
|
|
if (!(start == end))
|
|
{
|
|
if (m_useGhostObjectSweepTest)
|
|
{
|
|
m_ghostObject->convexSweepTest(m_convexShape, start, end, callback, collisionWorld->getDispatchInfo().m_allowedCcdPenetration);
|
|
}
|
|
else
|
|
{
|
|
collisionWorld->convexSweepTest(m_convexShape, start, end, callback, collisionWorld->getDispatchInfo().m_allowedCcdPenetration);
|
|
}
|
|
}
|
|
m_convexShape->setMargin(margin);
|
|
|
|
|
|
fraction -= callback.m_closestHitFraction;
|
|
|
|
if (callback.hasHit() && m_ghostObject->hasContactResponse() && needsCollision(m_ghostObject, callback.m_hitCollisionObject))
|
|
{
|
|
// we moved only a fraction
|
|
//btScalar hitDistance;
|
|
//hitDistance = (callback.m_hitPointWorld - m_currentPosition).length();
|
|
|
|
// m_currentPosition.setInterpolate3 (m_currentPosition, m_targetPosition, callback.m_closestHitFraction);
|
|
|
|
updateTargetPositionBasedOnCollision (callback.m_hitNormalWorld);
|
|
btVector3 currentDir = m_targetPosition - m_currentPosition;
|
|
distance2 = currentDir.length2();
|
|
if (distance2 > SIMD_EPSILON)
|
|
{
|
|
currentDir.normalize();
|
|
/* See Quake2: "If velocity is against original velocity, stop ead to avoid tiny oscilations in sloping corners." */
|
|
if (currentDir.dot(m_normalizedDirection) <= btScalar(0.0))
|
|
{
|
|
break;
|
|
}
|
|
} else
|
|
{
|
|
// printf("currentDir: don't normalize a zero vector\n");
|
|
break;
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
m_currentPosition = m_targetPosition;
|
|
}
|
|
}
|
|
}
|
|
|
|
void btKinematicCharacterController::stepDown ( btCollisionWorld* collisionWorld, btScalar dt)
|
|
{
|
|
btTransform start, end, end_double;
|
|
bool runonce = false;
|
|
|
|
// phase 3: down
|
|
/*btScalar additionalDownStep = (m_wasOnGround && !onGround()) ? m_stepHeight : 0.0;
|
|
btVector3 step_drop = m_up * (m_currentStepOffset + additionalDownStep);
|
|
btScalar downVelocity = (additionalDownStep == 0.0 && m_verticalVelocity<0.0?-m_verticalVelocity:0.0) * dt;
|
|
btVector3 gravity_drop = m_up * downVelocity;
|
|
m_targetPosition -= (step_drop + gravity_drop);*/
|
|
|
|
btVector3 orig_position = m_targetPosition;
|
|
|
|
btScalar downVelocity = (m_verticalVelocity<0.f?-m_verticalVelocity:0.f) * dt;
|
|
|
|
if (m_verticalVelocity > 0.0)
|
|
return;
|
|
|
|
if(downVelocity > 0.0 && downVelocity > m_fallSpeed
|
|
&& (m_wasOnGround || !m_wasJumping))
|
|
downVelocity = m_fallSpeed;
|
|
|
|
btVector3 step_drop = m_up * (m_currentStepOffset + downVelocity);
|
|
m_targetPosition -= step_drop;
|
|
|
|
btKinematicClosestNotMeConvexResultCallback callback(m_ghostObject, m_up, m_maxSlopeCosine);
|
|
callback.m_collisionFilterGroup = getGhostObject()->getBroadphaseHandle()->m_collisionFilterGroup;
|
|
callback.m_collisionFilterMask = getGhostObject()->getBroadphaseHandle()->m_collisionFilterMask;
|
|
|
|
btKinematicClosestNotMeConvexResultCallback callback2(m_ghostObject, m_up, m_maxSlopeCosine);
|
|
callback2.m_collisionFilterGroup = getGhostObject()->getBroadphaseHandle()->m_collisionFilterGroup;
|
|
callback2.m_collisionFilterMask = getGhostObject()->getBroadphaseHandle()->m_collisionFilterMask;
|
|
|
|
while (1)
|
|
{
|
|
start.setIdentity ();
|
|
end.setIdentity ();
|
|
|
|
end_double.setIdentity ();
|
|
|
|
start.setOrigin (m_currentPosition);
|
|
end.setOrigin (m_targetPosition);
|
|
|
|
start.setRotation(m_currentOrientation);
|
|
end.setRotation(m_targetOrientation);
|
|
|
|
//set double test for 2x the step drop, to check for a large drop vs small drop
|
|
end_double.setOrigin (m_targetPosition - step_drop);
|
|
|
|
if (m_useGhostObjectSweepTest)
|
|
{
|
|
m_ghostObject->convexSweepTest (m_convexShape, start, end, callback, collisionWorld->getDispatchInfo().m_allowedCcdPenetration);
|
|
|
|
if (!callback.hasHit() && m_ghostObject->hasContactResponse())
|
|
{
|
|
//test a double fall height, to see if the character should interpolate it's fall (full) or not (partial)
|
|
m_ghostObject->convexSweepTest (m_convexShape, start, end_double, callback2, collisionWorld->getDispatchInfo().m_allowedCcdPenetration);
|
|
}
|
|
} else
|
|
{
|
|
collisionWorld->convexSweepTest (m_convexShape, start, end, callback, collisionWorld->getDispatchInfo().m_allowedCcdPenetration);
|
|
|
|
if (!callback.hasHit() && m_ghostObject->hasContactResponse())
|
|
{
|
|
//test a double fall height, to see if the character should interpolate it's fall (large) or not (small)
|
|
collisionWorld->convexSweepTest (m_convexShape, start, end_double, callback2, collisionWorld->getDispatchInfo().m_allowedCcdPenetration);
|
|
}
|
|
}
|
|
|
|
btScalar downVelocity2 = (m_verticalVelocity<0.f?-m_verticalVelocity:0.f) * dt;
|
|
bool has_hit;
|
|
if (bounce_fix == true)
|
|
has_hit = (callback.hasHit() || callback2.hasHit()) && m_ghostObject->hasContactResponse() && needsCollision(m_ghostObject, callback.m_hitCollisionObject);
|
|
else
|
|
has_hit = callback2.hasHit() && m_ghostObject->hasContactResponse() && needsCollision(m_ghostObject, callback2.m_hitCollisionObject);
|
|
|
|
btScalar stepHeight = 0.0f;
|
|
if (m_verticalVelocity < 0.0)
|
|
stepHeight = m_stepHeight;
|
|
|
|
if (downVelocity2 > 0.0 && downVelocity2 < stepHeight && has_hit == true && runonce == false
|
|
&& (m_wasOnGround || !m_wasJumping))
|
|
{
|
|
//redo the velocity calculation when falling a small amount, for fast stairs motion
|
|
//for larger falls, use the smoother/slower interpolated movement by not touching the target position
|
|
|
|
m_targetPosition = orig_position;
|
|
downVelocity = stepHeight;
|
|
|
|
step_drop = m_up * (m_currentStepOffset + downVelocity);
|
|
m_targetPosition -= step_drop;
|
|
runonce = true;
|
|
continue; //re-run previous tests
|
|
}
|
|
break;
|
|
}
|
|
|
|
if ((m_ghostObject->hasContactResponse() && (callback.hasHit() && needsCollision(m_ghostObject, callback.m_hitCollisionObject))) || runonce == true)
|
|
{
|
|
// we dropped a fraction of the height -> hit floor
|
|
btScalar fraction = (m_currentPosition.getY() - callback.m_hitPointWorld.getY()) / 2;
|
|
|
|
//printf("hitpoint: %g - pos %g\n", callback.m_hitPointWorld.getY(), m_currentPosition.getY());
|
|
|
|
if (bounce_fix == true)
|
|
{
|
|
if (full_drop == true)
|
|
m_currentPosition.setInterpolate3 (m_currentPosition, m_targetPosition, callback.m_closestHitFraction);
|
|
else
|
|
//due to errors in the closestHitFraction variable when used with large polygons, calculate the hit fraction manually
|
|
m_currentPosition.setInterpolate3 (m_currentPosition, m_targetPosition, fraction);
|
|
}
|
|
else
|
|
m_currentPosition.setInterpolate3 (m_currentPosition, m_targetPosition, callback.m_closestHitFraction);
|
|
|
|
full_drop = false;
|
|
|
|
m_verticalVelocity = 0.0;
|
|
m_verticalOffset = 0.0;
|
|
m_wasJumping = false;
|
|
} else {
|
|
// we dropped the full height
|
|
|
|
full_drop = true;
|
|
|
|
if (bounce_fix == true)
|
|
{
|
|
downVelocity = (m_verticalVelocity<0.f?-m_verticalVelocity:0.f) * dt;
|
|
if (downVelocity > m_fallSpeed && (m_wasOnGround || !m_wasJumping))
|
|
{
|
|
m_targetPosition += step_drop; //undo previous target change
|
|
downVelocity = m_fallSpeed;
|
|
step_drop = m_up * (m_currentStepOffset + downVelocity);
|
|
m_targetPosition -= step_drop;
|
|
}
|
|
}
|
|
//printf("full drop - %g, %g\n", m_currentPosition.getY(), m_targetPosition.getY());
|
|
|
|
m_currentPosition = m_targetPosition;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void btKinematicCharacterController::setWalkDirection
|
|
(
|
|
const btVector3& walkDirection
|
|
)
|
|
{
|
|
m_useWalkDirection = true;
|
|
m_walkDirection = walkDirection;
|
|
m_normalizedDirection = getNormalizedVector(m_walkDirection);
|
|
}
|
|
|
|
|
|
|
|
void btKinematicCharacterController::setVelocityForTimeInterval
|
|
(
|
|
const btVector3& velocity,
|
|
btScalar timeInterval
|
|
)
|
|
{
|
|
// printf("setVelocity!\n");
|
|
// printf(" interval: %f\n", timeInterval);
|
|
// printf(" velocity: (%f, %f, %f)\n",
|
|
// velocity.x(), velocity.y(), velocity.z());
|
|
|
|
m_useWalkDirection = false;
|
|
m_walkDirection = velocity;
|
|
m_normalizedDirection = getNormalizedVector(m_walkDirection);
|
|
m_velocityTimeInterval += timeInterval;
|
|
}
|
|
|
|
void btKinematicCharacterController::setAngularVelocity(const btVector3& velocity)
|
|
{
|
|
m_AngVel = velocity;
|
|
}
|
|
|
|
const btVector3& btKinematicCharacterController::getAngularVelocity() const
|
|
{
|
|
return m_AngVel;
|
|
}
|
|
|
|
void btKinematicCharacterController::setLinearVelocity(const btVector3& velocity)
|
|
{
|
|
m_walkDirection = velocity;
|
|
|
|
// HACK: if we are moving in the direction of the up, treat it as a jump :(
|
|
if (m_walkDirection.length2() > 0)
|
|
{
|
|
btVector3 w = velocity.normalized();
|
|
btScalar c = w.dot(m_up);
|
|
if (c != 0)
|
|
{
|
|
//there is a component in walkdirection for vertical velocity
|
|
btVector3 upComponent = m_up * (btSin(SIMD_HALF_PI - btAcos(c)) * m_walkDirection.length());
|
|
m_walkDirection -= upComponent;
|
|
m_verticalVelocity = (c < 0.0f ? -1 : 1) * upComponent.length();
|
|
|
|
if (c > 0.0f)
|
|
{
|
|
m_wasJumping = true;
|
|
m_jumpPosition = m_ghostObject->getWorldTransform().getOrigin();
|
|
}
|
|
}
|
|
}
|
|
else
|
|
m_verticalVelocity = 0.0f;
|
|
}
|
|
|
|
btVector3 btKinematicCharacterController::getLinearVelocity() const
|
|
{
|
|
return m_walkDirection + (m_verticalVelocity * m_up);
|
|
}
|
|
|
|
void btKinematicCharacterController::reset ( btCollisionWorld* collisionWorld )
|
|
{
|
|
m_verticalVelocity = 0.0;
|
|
m_verticalOffset = 0.0;
|
|
m_wasOnGround = false;
|
|
m_wasJumping = false;
|
|
m_walkDirection.setValue(0,0,0);
|
|
m_velocityTimeInterval = 0.0;
|
|
|
|
//clear pair cache
|
|
btHashedOverlappingPairCache *cache = m_ghostObject->getOverlappingPairCache();
|
|
while (cache->getOverlappingPairArray().size() > 0)
|
|
{
|
|
cache->removeOverlappingPair(cache->getOverlappingPairArray()[0].m_pProxy0, cache->getOverlappingPairArray()[0].m_pProxy1, collisionWorld->getDispatcher());
|
|
}
|
|
}
|
|
|
|
void btKinematicCharacterController::warp (const btVector3& origin)
|
|
{
|
|
btTransform xform;
|
|
xform.setIdentity();
|
|
xform.setOrigin (origin);
|
|
m_ghostObject->setWorldTransform (xform);
|
|
}
|
|
|
|
|
|
void btKinematicCharacterController::preStep ( btCollisionWorld* collisionWorld)
|
|
{
|
|
m_currentPosition = m_ghostObject->getWorldTransform().getOrigin();
|
|
m_targetPosition = m_currentPosition;
|
|
|
|
m_currentOrientation = m_ghostObject->getWorldTransform().getRotation();
|
|
m_targetOrientation = m_currentOrientation;
|
|
// printf("m_targetPosition=%f,%f,%f\n",m_targetPosition[0],m_targetPosition[1],m_targetPosition[2]);
|
|
}
|
|
|
|
void btKinematicCharacterController::playerStep ( btCollisionWorld* collisionWorld, btScalar dt)
|
|
{
|
|
// printf("playerStep(): ");
|
|
// printf(" dt = %f", dt);
|
|
|
|
if (m_AngVel.length2() > 0.0f)
|
|
{
|
|
m_AngVel *= btPow(btScalar(1) - m_angularDamping, dt);
|
|
}
|
|
|
|
// integrate for angular velocity
|
|
if (m_AngVel.length2() > 0.0f)
|
|
{
|
|
btTransform xform;
|
|
xform = m_ghostObject->getWorldTransform();
|
|
|
|
btQuaternion rot(m_AngVel.normalized(), m_AngVel.length() * dt);
|
|
|
|
btQuaternion orn = rot * xform.getRotation();
|
|
|
|
xform.setRotation(orn);
|
|
m_ghostObject->setWorldTransform(xform);
|
|
|
|
m_currentPosition = m_ghostObject->getWorldTransform().getOrigin();
|
|
m_targetPosition = m_currentPosition;
|
|
m_currentOrientation = m_ghostObject->getWorldTransform().getRotation();
|
|
m_targetOrientation = m_currentOrientation;
|
|
}
|
|
|
|
// quick check...
|
|
if (!m_useWalkDirection && (m_velocityTimeInterval <= 0.0)) {
|
|
// printf("\n");
|
|
return; // no motion
|
|
}
|
|
|
|
m_wasOnGround = onGround();
|
|
|
|
//btVector3 lvel = m_walkDirection;
|
|
//btScalar c = 0.0f;
|
|
|
|
if (m_walkDirection.length2() > 0)
|
|
{
|
|
// apply damping
|
|
m_walkDirection *= btPow(btScalar(1) - m_linearDamping, dt);
|
|
}
|
|
|
|
m_verticalVelocity *= btPow(btScalar(1) - m_linearDamping, dt);
|
|
|
|
// Update fall velocity.
|
|
m_verticalVelocity -= m_gravity * dt;
|
|
if (m_verticalVelocity > 0.0 && m_verticalVelocity > m_jumpSpeed)
|
|
{
|
|
m_verticalVelocity = m_jumpSpeed;
|
|
}
|
|
if (m_verticalVelocity < 0.0 && btFabs(m_verticalVelocity) > btFabs(m_fallSpeed))
|
|
{
|
|
m_verticalVelocity = -btFabs(m_fallSpeed);
|
|
}
|
|
m_verticalOffset = m_verticalVelocity * dt;
|
|
|
|
btTransform xform;
|
|
xform = m_ghostObject->getWorldTransform();
|
|
|
|
// printf("walkDirection(%f,%f,%f)\n",walkDirection[0],walkDirection[1],walkDirection[2]);
|
|
// printf("walkSpeed=%f\n",walkSpeed);
|
|
|
|
stepUp(collisionWorld);
|
|
//todo: Experimenting with behavior of controller when it hits a ceiling..
|
|
//bool hitUp = stepUp (collisionWorld);
|
|
//if (hitUp)
|
|
//{
|
|
// m_verticalVelocity -= m_gravity * dt;
|
|
// if (m_verticalVelocity > 0.0 && m_verticalVelocity > m_jumpSpeed)
|
|
// {
|
|
// m_verticalVelocity = m_jumpSpeed;
|
|
// }
|
|
// if (m_verticalVelocity < 0.0 && btFabs(m_verticalVelocity) > btFabs(m_fallSpeed))
|
|
// {
|
|
// m_verticalVelocity = -btFabs(m_fallSpeed);
|
|
// }
|
|
// m_verticalOffset = m_verticalVelocity * dt;
|
|
|
|
// xform = m_ghostObject->getWorldTransform();
|
|
//}
|
|
|
|
if (m_useWalkDirection) {
|
|
stepForwardAndStrafe (collisionWorld, m_walkDirection);
|
|
} else {
|
|
//printf(" time: %f", m_velocityTimeInterval);
|
|
// still have some time left for moving!
|
|
btScalar dtMoving =
|
|
(dt < m_velocityTimeInterval) ? dt : m_velocityTimeInterval;
|
|
m_velocityTimeInterval -= dt;
|
|
|
|
// how far will we move while we are moving?
|
|
btVector3 move = m_walkDirection * dtMoving;
|
|
|
|
//printf(" dtMoving: %f", dtMoving);
|
|
|
|
// okay, step
|
|
stepForwardAndStrafe(collisionWorld, move);
|
|
}
|
|
stepDown (collisionWorld, dt);
|
|
|
|
//todo: Experimenting with max jump height
|
|
//if (m_wasJumping)
|
|
//{
|
|
// btScalar ds = m_currentPosition[m_upAxis] - m_jumpPosition[m_upAxis];
|
|
// if (ds > m_maxJumpHeight)
|
|
// {
|
|
// // substract the overshoot
|
|
// m_currentPosition[m_upAxis] -= ds - m_maxJumpHeight;
|
|
|
|
// // max height was reached, so potential energy is at max
|
|
// // and kinematic energy is 0, thus velocity is 0.
|
|
// if (m_verticalVelocity > 0.0)
|
|
// m_verticalVelocity = 0.0;
|
|
// }
|
|
//}
|
|
// printf("\n");
|
|
|
|
xform.setOrigin (m_currentPosition);
|
|
m_ghostObject->setWorldTransform (xform);
|
|
|
|
int numPenetrationLoops = 0;
|
|
m_touchingContact = false;
|
|
while (recoverFromPenetration(collisionWorld))
|
|
{
|
|
numPenetrationLoops++;
|
|
m_touchingContact = true;
|
|
if (numPenetrationLoops > 4)
|
|
{
|
|
//printf("character could not recover from penetration = %d\n", numPenetrationLoops);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void btKinematicCharacterController::setFallSpeed (btScalar fallSpeed)
|
|
{
|
|
m_fallSpeed = fallSpeed;
|
|
}
|
|
|
|
void btKinematicCharacterController::setJumpSpeed (btScalar jumpSpeed)
|
|
{
|
|
m_jumpSpeed = jumpSpeed;
|
|
m_SetjumpSpeed = m_jumpSpeed;
|
|
}
|
|
|
|
void btKinematicCharacterController::setMaxJumpHeight (btScalar maxJumpHeight)
|
|
{
|
|
m_maxJumpHeight = maxJumpHeight;
|
|
}
|
|
|
|
bool btKinematicCharacterController::canJump () const
|
|
{
|
|
return onGround();
|
|
}
|
|
|
|
void btKinematicCharacterController::jump(const btVector3& v)
|
|
{
|
|
m_jumpSpeed = v.length2() == 0 ? m_SetjumpSpeed : v.length();
|
|
m_verticalVelocity = m_jumpSpeed;
|
|
m_wasJumping = true;
|
|
|
|
m_jumpAxis = v.length2() == 0 ? m_up : v.normalized();
|
|
|
|
m_jumpPosition = m_ghostObject->getWorldTransform().getOrigin();
|
|
|
|
#if 0
|
|
currently no jumping.
|
|
btTransform xform;
|
|
m_rigidBody->getMotionState()->getWorldTransform (xform);
|
|
btVector3 up = xform.getBasis()[1];
|
|
up.normalize ();
|
|
btScalar magnitude = (btScalar(1.0)/m_rigidBody->getInvMass()) * btScalar(8.0);
|
|
m_rigidBody->applyCentralImpulse (up * magnitude);
|
|
#endif
|
|
}
|
|
|
|
void btKinematicCharacterController::setGravity(const btVector3& gravity)
|
|
{
|
|
if (gravity.length2() > 0) setUpVector(-gravity);
|
|
|
|
m_gravity = gravity.length();
|
|
}
|
|
|
|
btVector3 btKinematicCharacterController::getGravity() const
|
|
{
|
|
return -m_gravity * m_up;
|
|
}
|
|
|
|
void btKinematicCharacterController::setMaxSlope(btScalar slopeRadians)
|
|
{
|
|
m_maxSlopeRadians = slopeRadians;
|
|
m_maxSlopeCosine = btCos(slopeRadians);
|
|
}
|
|
|
|
btScalar btKinematicCharacterController::getMaxSlope() const
|
|
{
|
|
return m_maxSlopeRadians;
|
|
}
|
|
|
|
void btKinematicCharacterController::setMaxPenetrationDepth(btScalar d)
|
|
{
|
|
m_maxPenetrationDepth = d;
|
|
}
|
|
|
|
btScalar btKinematicCharacterController::getMaxPenetrationDepth() const
|
|
{
|
|
return m_maxPenetrationDepth;
|
|
}
|
|
|
|
bool btKinematicCharacterController::onGround () const
|
|
{
|
|
return (fabs(m_verticalVelocity) < SIMD_EPSILON) && (fabs(m_verticalOffset) < SIMD_EPSILON);
|
|
}
|
|
|
|
void btKinematicCharacterController::setStepHeight(btScalar h)
|
|
{
|
|
m_stepHeight = h;
|
|
}
|
|
|
|
btVector3* btKinematicCharacterController::getUpAxisDirections()
|
|
{
|
|
static btVector3 sUpAxisDirection[3] = { btVector3(1.0f, 0.0f, 0.0f), btVector3(0.0f, 1.0f, 0.0f), btVector3(0.0f, 0.0f, 1.0f) };
|
|
|
|
return sUpAxisDirection;
|
|
}
|
|
|
|
void btKinematicCharacterController::debugDraw(btIDebugDraw* debugDrawer)
|
|
{
|
|
}
|
|
|
|
void btKinematicCharacterController::setUpInterpolate(bool value)
|
|
{
|
|
m_interpolateUp = value;
|
|
}
|
|
|
|
void btKinematicCharacterController::setUp(const btVector3& up)
|
|
{
|
|
if (up.length2() > 0 && m_gravity > 0.0f)
|
|
{
|
|
setGravity(-m_gravity * up.normalized());
|
|
return;
|
|
}
|
|
|
|
setUpVector(up);
|
|
}
|
|
|
|
void btKinematicCharacterController::setUpVector(const btVector3& up)
|
|
{
|
|
if (m_up == up)
|
|
return;
|
|
|
|
btVector3 u = m_up;
|
|
|
|
if (up.length2() > 0)
|
|
m_up = up.normalized();
|
|
else
|
|
m_up = btVector3(0.0, 0.0, 0.0);
|
|
|
|
if (!m_ghostObject) return;
|
|
btQuaternion rot = getRotation(m_up, u);
|
|
|
|
//set orientation with new up
|
|
btTransform xform;
|
|
xform = m_ghostObject->getWorldTransform();
|
|
btQuaternion orn = rot.inverse() * xform.getRotation();
|
|
xform.setRotation(orn);
|
|
m_ghostObject->setWorldTransform(xform);
|
|
}
|
|
|
|
btQuaternion btKinematicCharacterController::getRotation(btVector3& v0, btVector3& v1) const
|
|
{
|
|
if (v0.length2() == 0.0f || v1.length2() == 0.0f)
|
|
{
|
|
btQuaternion q;
|
|
return q;
|
|
}
|
|
|
|
return shortestArcQuatNormalize2(v0, v1);
|
|
}
|
|
|