Method updateSleepingBodies

src/engine/PhysicsWorld.cpp:874–929

Put bodies to sleep if needed. For each island, if all the bodies have been almost still for a long enough period of time, we put all the bodies of the island to sleep.

/// For each island, if all the bodies have been almost still for a long enough period of
/// time, we put all the bodies of the island to sleep.
void PhysicsWorld::updateSleepingBodies(decimal timeStep) {

    RP3D_PROFILE("PhysicsWorld::updateSleepingBodies()", mProfiler);

    const decimal sleepLinearVelocitySquare = mSleepLinearVelocity * mSleepLinearVelocity;
    const decimal sleepAngularVelocitySquare = mSleepAngularVelocity * mSleepAngularVelocity;

    // For each island of the world
    const uint32 nbIslands = mIslands.getNbIslands();
    for (uint32 i=0; i < nbIslands; i++) {

        decimal minSleepTime = DECIMAL_LARGEST;

        // For each body of the island
        for (uint32 b=0; b < mIslands.nbBodiesInIsland[i]; b++) {

            const Entity bodyEntity = mIslands.bodyEntities[mIslands.startBodyEntitiesIndex[i] + b];
            const uint32 bodyIndex = mRigidBodyComponents.getEntityIndex(bodyEntity);

            // Skip static bodies
            if (mRigidBodyComponents.mBodyTypes[bodyIndex] == BodyType::STATIC) continue;

            // If the body is velocity is large enough to stay awake
            if (mRigidBodyComponents.mLinearVelocities[bodyIndex].lengthSquare() > sleepLinearVelocitySquare ||
                mRigidBodyComponents.mAngularVelocities[bodyIndex].lengthSquare() > sleepAngularVelocitySquare ||
                !mRigidBodyComponents.mIsAllowedToSleep[bodyIndex]) {

                // Reset the sleep time of the body
                mRigidBodyComponents.mSleepTimes[bodyIndex] = decimal(0.0);
                minSleepTime = decimal(0.0);
            }
            else {  // If the body velocity is below the sleeping velocity threshold

                // Increase the sleep time
                mRigidBodyComponents.mSleepTimes[bodyIndex] += timeStep;
                if (mRigidBodyComponents.mSleepTimes[bodyIndex] < minSleepTime) {
                    minSleepTime = mRigidBodyComponents.mSleepTimes[bodyIndex];
                }
            }
        }

        // If the velocity of all the bodies of the island is under the
        // sleeping velocity threshold for a period of time larger than
        // the time required to become a sleeping body
        if (minSleepTime >= mTimeBeforeSleep) {

            // Put all the bodies of the island to sleep
            for (uint32 b=0; b < mIslands.nbBodiesInIsland[i]; b++) {

                const Entity bodyEntity = mIslands.bodyEntities[mIslands.startBodyEntitiesIndex[i] + b];
                RigidBody* body = mRigidBodyComponents.getRigidBody(bodyEntity);
                body->setIsSleeping(true);
            }
        }
    }
}

// Enable/Disable the sleeping technique.