C++博客-野猪世界专注图形技术-随笔分类-Bullet

bullet setp 流程

野猪红 — Thu, 10 Jan 2013 12:06:00 GMT

好的
我要开始新篇了
新篇是Bullet的
刚开始看Bullet时代码不熟看后忘前不过怎么说呢那我就每天看草
于是我就明白了
先看看那个step函数：

1void    btDiscreteDynamicsWorld::internalSingleStepSimulation(btScalar timeStep)
2{
3
4    BT_PROFILE("internalSingleStepSimulation");
5
6    if(0 != m_internalPreTickCallback) {
7        (*m_internalPreTickCallback)(this, timeStep);
8    }
9
10    ///apply gravity, predict motion
11    predictUnconstraintMotion(timeStep);
12
13    btDispatcherInfo& dispatchInfo = getDispatchInfo();
14
15    dispatchInfo.m_timeStep = timeStep;
16    dispatchInfo.m_stepCount = 0;
17    dispatchInfo.m_debugDraw = getDebugDrawer();
18
19
20    createPredictiveContacts(timeStep);
21
22    ///perform collision detection
23    performDiscreteCollisionDetection();
24
25    calculateSimulationIslands();
26
27
28    getSolverInfo().m_timeStep = timeStep;
29
30
31
32    ///solve contact and other joint constraints
33    solveConstraints(getSolverInfo());
34
35    ///CallbackTriggers();
36
37    ///integrate transforms
38
39    integrateTransforms(timeStep);
40
41    ///update vehicle simulation
42    updateActions(timeStep);
43
44    updateActivationState( timeStep );
45
46    if(0 != m_internalTickCallback) {
47        (*m_internalTickCallback)(this, timeStep);
48    }
49}
50

看看里面几个重要的函数：
1 predictUnconstraintMotion(timeStep) ：给每个物体加重力作用力
2 createPredictiveContacts(timeStep) ：和ccd有关处理物体在高速运动时的碰撞
3 performDiscreteCollisionDetection()：此函数做碰撞我们来看看

void    btCollisionWorld::performDiscreteCollisionDetection()
{
    BT_PROFILE("performDiscreteCollisionDetection");

    btDispatcherInfo& dispatchInfo = getDispatchInfo();

    updateAabbs();

    computeOverlappingPairs();
* dispatcher = getDispatcher();
    {
        BT_PROFILE("dispatchAllCollisionPairs");
        if (dispatcher)
            dispatcher->dispatchAllCollisionPairs(m_broadphasePairCache->getOverlappingPairCache(),dispatchInfo,m_dispatcher1);
}

}

1)   updateAabbs()：
      把要参加broad碰撞的物体放进paircache，此时没有进行任何碰撞检测，仅仅是把物体加进paircache（addOverlappingPair）同时，放进ghost的paircache里
      if (m_ghostPairCallback)
        m_ghostPairCallback->addOverlappingPair(proxy0,proxy1);
      在这个阶段可以设置一个回调函数，用于过滤一些特定物体

    SIMD_FORCE_INLINE bool needsBroadphaseCollision(btBroadphaseProxy* proxy0,btBroadphaseProxy* proxy1) const
    {
     if (m_overlapFilterCallback)
       return m_overlapFilterCallback->needBroadphaseCollision(proxy0,proxy1);

     bool collides = (proxy0->m_collisionFilterGroup & proxy1->m_collisionFilterMask) != 0;
     collides = collides && (proxy1->m_collisionFilterGroup & proxy0->m_collisionFilterMask);
     return collides;
    }

    m_overlapFilterCallback就是那个回调函数

2)    computeOverlappingPairs()：
       该函数执行broad碰撞，也就是类似于AABB的粗线条碰撞，以此过滤paircache中不用进行narrow碰撞的pair

3)    dispatcher->dispatchAllCollisionPairs(m_broadphasePairCache->getOverlappingPairCache(),dispatchInfo,m_dispatcher1):
       该函数进行narrow碰撞，也就是精确碰撞，在这里，我们也可以设置回调，以过滤掉某些物体的精确碰撞

void btCollisionDispatcher::defaultNearCallback(btBroadphasePair& collisionPair, btCollisionDispatcher& dispatcher, const btDispatcherInfo& dispatchInfo)
{
        btCollisionObject* colObj0 = (btCollisionObject*)collisionPair.m_pProxy0->m_clientObject;
        btCollisionObject* colObj1 = (btCollisionObject*)collisionPair.m_pProxy1->m_clientObject;

        if (dispatcher.needsCollision(colObj0,colObj1))
{
            btCollisionObjectWrapper obj0Wrap(0,colObj0->getCollisionShape(),colObj0,colObj0->getWorldTransform());
            btCollisionObjectWrapper obj1Wrap(0,colObj1->getCollisionShape(),colObj1,colObj1->getWorldTransform());

            //dispatcher will keep algorithms persistent in the collision pair
            if (!collisionPair.m_algorithm)
            {
                collisionPair.m_algorithm = dispatcher.findAlgorithm(&obj0Wrap,&obj1Wrap);
            }

            if (collisionPair.m_algorithm)
            {
                btManifoldResult contactPointResult(&obj0Wrap,&obj1Wrap);

                if (dispatchInfo.m_dispatchFunc ==         btDispatcherInfo::DISPATCH_DISCRETE)
                {
                    //discrete collision detection query

                    collisionPair.m_algorithm->processCollision(&obj0Wrap,&obj1Wrap,dispatchInfo,&contactPointResult);
                } else
                {
                    //continuous collision detection query, time of impact (toi)
                    btScalar toi = collisionPair.m_algorithm->calculateTimeOfImpact(colObj0,colObj1,dispatchInfo,&contactPointResult);
                    if (dispatchInfo.m_timeOfImpact > toi)
                        dispatchInfo.m_timeOfImpact = toi;

                }
            }
        }

}

这个是默认的callback所做的活，正如bulletManual上所说，可以换成我们自己的callback
void setNearCallback(btNearCallback nearCallback)
{
m_nearCallback = nearCallback;
}
另外，还可以重载btCollisionDispatcher，重写其
virtual bool needsCollision(const btCollisionObject* body0,const btCollisionObject* body1);
virtual bool needsResponse(const btCollisionObject* body0,const btCollisionObject* body1);
virtual void dispatchAllCollisionPairs(btOverlappingPairCache* pairCache,const btDispatcherInfo& dispatchInfo,btDispatcher* dispatcher) ;
从而完全定制其行为

好暂时over

野猪红 2013-01-10 20:06 发表评论

bullet 中的stepSimulation和MotionState

野猪红 — Sat, 10 Dec 2011 02:27:00 GMT

最近看bullet，有源码就是看得明白点，有时候文档真的是无法说清的
就比如这个函数：

1 virtual int stepSimulation( btScalar timeStep,int maxSubSteps=1, btScalar fixedTimeStep=btScalar(1.)/btScalar(60.));

非要看看源码才行的
默认情况下，最大执行步骤为1，固定步长为1/60，第一个参数为实际步长
这是一个放大的时间步长：0~2/60，物体在0时间为A状态，1/60为B状态，2/60为C状态
物体状态A 物体状态B          物体状态C
0----------------1/60--------------2/60
       -timeStep //在0~1/60以内，bullet并不执行物理模拟，剩余时间motionstate会进行进一步模拟
                                  -timeStep //在1/60~2/60以内，bullet执行一个物理模拟，bullet中物体处于B状态，但实际上物体应该还要在后面一个时间点，于是剩
                                                   余时间为总时间减去一个固定步长的时间，motionstate会根据这个剩余时间基于状态B进行进一步模拟
所谓进一步模拟看代码注意函数中的timeStep参数该参数就是那个剩余时间：

1static void integrateTransform(const btTransform& curTrans,const btVector3& linvel,const btVector3& angvel,btScalar timeStep,btTransform& predictedTransform)
2    {
3        predictedTransform.setOrigin(curTrans.getOrigin() + linvel * timeStep);
4//    #define QUATERNION_DERIVATIVE
5    #ifdef QUATERNION_DERIVATIVE
6        btQuaternion predictedOrn = curTrans.getRotation();
7        predictedOrn += (angvel * predictedOrn) * (timeStep * btScalar(0.5));
8        predictedOrn.normalize();
9    #else
10        //Exponential map
11        //google for "Practical Parameterization of Rotations Using the Exponential Map", F. Sebastian Grassia
12
13        btVector3 axis;
14        btScalar    fAngle = angvel.length();
15        //limit the angular motion
16        if (fAngle*timeStep > ANGULAR_MOTION_THRESHOLD)
17        {
18            fAngle = ANGULAR_MOTION_THRESHOLD / timeStep;
19        }
20
21        if ( fAngle < btScalar(0.001) )
22        {
23            // use Taylor's expansions of sync function
24            axis   = angvel*( btScalar(0.5)*timeStep-(timeStep*timeStep*timeStep)*(btScalar(0.020833333333))*fAngle*fAngle );
25        }
26        else
27        {
28            // sync(fAngle) = sin(c*fAngle)/t
29            axis   = angvel*( btSin(btScalar(0.5)*fAngle*timeStep)/fAngle );
30        }
31        btQuaternion dorn (axis.x(),axis.y(),axis.z(),btCos( fAngle*timeStep*btScalar(0.5) ));
32        btQuaternion orn0 = curTrans.getRotation();
33
34        btQuaternion predictedOrn = dorn * orn0;
35        predictedOrn.normalize();
36    #endif
37        predictedTransform.setRotation(predictedOrn);
38    }

所以，motionstate总是以插值的形态出现，代表物体的实际运动位置，可以用在实际游戏模拟中
靠，现在应该清楚的吧，如果还不清楚，请看源代码
到点了请女人吃饭去了附上相关代码：

1 int    btDiscreteDynamicsWorld::stepSimulation( btScalar timeStep,int maxSubSteps, btScalar fixedTimeStep)
2 {
3     startProfiling(timeStep);
4
5     BT_PROFILE("stepSimulation");
6
7     int numSimulationSubSteps = 0;
8
9     if (maxSubSteps)
10     {
11         //fixed timestep with interpolation
12         m_localTime += timeStep;
13         if (m_localTime >= fixedTimeStep)
14         {
15             numSimulationSubSteps = int( m_localTime / fixedTimeStep);
16             m_localTime -= numSimulationSubSteps * fixedTimeStep;
17         }
18     } else
19     {
20         //variable timestep
21         fixedTimeStep = timeStep;
22         m_localTime = timeStep;
23         if (btFuzzyZero(timeStep))
24         {
25             numSimulationSubSteps = 0;
26             maxSubSteps = 0;
27         } else
28         {
29             numSimulationSubSteps = 1;
30             maxSubSteps = 1;
31         }
32     }
33
34     //process some debugging flags
35     if (getDebugDrawer())
36     {
37         btIDebugDraw* debugDrawer = getDebugDrawer ();
38         gDisableDeactivation = (debugDrawer->getDebugMode() & btIDebugDraw::DBG_NoDeactivation) != 0;
39     }
40     if (numSimulationSubSteps)
41     {
42
43         //clamp the number of substeps, to prevent simulation grinding spiralling down to a halt
44         int clampedSimulationSteps = (numSimulationSubSteps > maxSubSteps)? maxSubSteps : numSimulationSubSteps;
45
46         saveKinematicState(fixedTimeStep*clampedSimulationSteps);
47
48         applyGravity();
49
50
51
52         for (int i=0;i<clampedSimulationSteps;i++)
53         {
54             internalSingleStepSimulation(fixedTimeStep);
55             synchronizeMotionStates();
56         }
57
58     } else
59     {
60         synchronizeMotionStates();
61     }
62
63     clearForces();
64
65 #ifndef BT_NO_PROFILE
66     CProfileManager::Increment_Frame_Counter();
67 #endif //BT_NO_PROFILE
68
69     return numSimulationSubSteps;
70 }
71
72

野猪红 2011-12-10 10:27 发表评论

C++博客-野猪世界 专注图形技术-随笔分类-Bullet

bullet setp 流程

bullet 中的stepSimulation和MotionState

C++博客-野猪世界专注图形技术-随笔分类-Bullet