From 81303fbaebc97683325cca119a8afc165ffcbb0d Mon Sep 17 00:00:00 2001 From: Daniel Chappuis Date: Fri, 17 May 2019 07:29:54 +0200 Subject: [PATCH] Add split velocities into the DynamicsComponents --- src/components/DynamicsComponents.cpp | 21 +++++++++- src/components/DynamicsComponents.h | 57 ++++++++++++++++++++++++--- src/engine/ContactSolver.cpp | 38 ++++++++---------- src/engine/ContactSolver.h | 23 ----------- src/engine/DynamicsWorld.cpp | 32 ++++++++------- src/engine/DynamicsWorld.h | 11 ++---- 6 files changed, 108 insertions(+), 74 deletions(-) diff --git a/src/components/DynamicsComponents.cpp b/src/components/DynamicsComponents.cpp index f02a0728..9a1cbe28 100644 --- a/src/components/DynamicsComponents.cpp +++ b/src/components/DynamicsComponents.cpp @@ -35,7 +35,8 @@ using namespace reactphysics3d; // Constructor DynamicsComponents::DynamicsComponents(MemoryAllocator& allocator) - :Components(allocator, sizeof(Entity) + sizeof(Vector3) + sizeof(Vector3) + sizeof(Vector3) + sizeof(Vector3) + sizeof(bool)) { + :Components(allocator, sizeof(Entity) + sizeof(Vector3) + sizeof(Vector3) + sizeof(Vector3) + sizeof(Vector3) + + sizeof(Vector3) + sizeof(Vector3) + sizeof(bool)) { // Allocate memory for the components data allocate(INIT_NB_ALLOCATED_COMPONENTS); @@ -59,7 +60,9 @@ void DynamicsComponents::allocate(uint32 nbComponentsToAllocate) { Vector3* newAngularVelocities = reinterpret_cast(newLinearVelocities + nbComponentsToAllocate); Vector3* newConstrainedLinearVelocities = reinterpret_cast(newAngularVelocities + nbComponentsToAllocate); Vector3* newConstrainedAngularVelocities = reinterpret_cast(newConstrainedLinearVelocities + nbComponentsToAllocate); - bool* newIsAlreadyInIsland = reinterpret_cast(newConstrainedAngularVelocities + nbComponentsToAllocate); + Vector3* newSplitLinearVelocities = reinterpret_cast(newConstrainedAngularVelocities + nbComponentsToAllocate); + Vector3* newSplitAngularVelocities = reinterpret_cast(newSplitLinearVelocities + nbComponentsToAllocate); + bool* newIsAlreadyInIsland = reinterpret_cast(newSplitAngularVelocities + nbComponentsToAllocate); // If there was already components before if (mNbComponents > 0) { @@ -70,6 +73,8 @@ void DynamicsComponents::allocate(uint32 nbComponentsToAllocate) { memcpy(newAngularVelocities, mAngularVelocities, mNbComponents * sizeof(Vector3)); memcpy(newConstrainedLinearVelocities, mConstrainedLinearVelocities, mNbComponents * sizeof(Vector3)); memcpy(newConstrainedAngularVelocities, mConstrainedAngularVelocities, mNbComponents * sizeof(Vector3)); + memcpy(newSplitLinearVelocities, mSplitLinearVelocities, mNbComponents * sizeof(Vector3)); + memcpy(newSplitAngularVelocities, mSplitAngularVelocities, mNbComponents * sizeof(Vector3)); memcpy(newIsAlreadyInIsland, mIsAlreadyInIsland, mNbComponents * sizeof(bool)); // Deallocate previous memory @@ -82,6 +87,8 @@ void DynamicsComponents::allocate(uint32 nbComponentsToAllocate) { mAngularVelocities = newAngularVelocities; mConstrainedLinearVelocities = newConstrainedLinearVelocities; mConstrainedAngularVelocities = newConstrainedAngularVelocities; + mSplitLinearVelocities = newSplitLinearVelocities; + mSplitAngularVelocities = newSplitAngularVelocities; mIsAlreadyInIsland = newIsAlreadyInIsland; mNbAllocatedComponents = nbComponentsToAllocate; } @@ -98,6 +105,8 @@ void DynamicsComponents::addComponent(Entity bodyEntity, bool isSleeping, const new (mAngularVelocities + index) Vector3(component.angularVelocity); new (mConstrainedLinearVelocities + index) Vector3(0, 0, 0); new (mConstrainedAngularVelocities + index) Vector3(0, 0, 0); + new (mSplitLinearVelocities + index) Vector3(0, 0, 0); + new (mSplitAngularVelocities + index) Vector3(0, 0, 0); mIsAlreadyInIsland[index] = false; // Map the entity with the new component lookup index @@ -121,6 +130,8 @@ void DynamicsComponents::moveComponentToIndex(uint32 srcIndex, uint32 destIndex) new (mAngularVelocities + destIndex) Vector3(mAngularVelocities[srcIndex]); new (mConstrainedLinearVelocities + destIndex) Vector3(mConstrainedLinearVelocities[srcIndex]); new (mConstrainedAngularVelocities + destIndex) Vector3(mConstrainedAngularVelocities[srcIndex]); + new (mSplitLinearVelocities + destIndex) Vector3(mSplitLinearVelocities[srcIndex]); + new (mSplitAngularVelocities + destIndex) Vector3(mSplitAngularVelocities[srcIndex]); mIsAlreadyInIsland[destIndex] = mIsAlreadyInIsland[srcIndex]; // Destroy the source component @@ -146,6 +157,8 @@ void DynamicsComponents::swapComponents(uint32 index1, uint32 index2) { Vector3 angularVelocity1(mAngularVelocities[index1]); Vector3 constrainedLinearVelocity1(mConstrainedLinearVelocities[index1]); Vector3 constrainedAngularVelocity1(mConstrainedAngularVelocities[index1]); + Vector3 splitLinearVelocity1(mSplitLinearVelocities[index1]); + Vector3 splitAngularVelocity1(mSplitAngularVelocities[index1]); bool isAlreadyInIsland1 = mIsAlreadyInIsland[index1]; // Destroy component 1 @@ -159,6 +172,8 @@ void DynamicsComponents::swapComponents(uint32 index1, uint32 index2) { new (mAngularVelocities + index2) Vector3(angularVelocity1); new (mConstrainedLinearVelocities + index2) Vector3(constrainedLinearVelocity1); new (mConstrainedAngularVelocities + index2) Vector3(constrainedAngularVelocity1); + new (mSplitLinearVelocities + index2) Vector3(splitLinearVelocity1); + new (mSplitAngularVelocities + index2) Vector3(splitAngularVelocity1); mIsAlreadyInIsland[index2] = isAlreadyInIsland1; // Update the entity to component index mapping @@ -183,4 +198,6 @@ void DynamicsComponents::destroyComponent(uint32 index) { mAngularVelocities[index].~Vector3(); mConstrainedLinearVelocities[index].~Vector3(); mConstrainedAngularVelocities[index].~Vector3(); + mSplitLinearVelocities[index].~Vector3(); + mSplitAngularVelocities[index].~Vector3(); } diff --git a/src/components/DynamicsComponents.h b/src/components/DynamicsComponents.h index 715e5607..adb23497 100644 --- a/src/components/DynamicsComponents.h +++ b/src/components/DynamicsComponents.h @@ -65,6 +65,12 @@ class DynamicsComponents : public Components { /// Array with the constrained angular velocity of each component Vector3* mConstrainedAngularVelocities; + /// Array with the split linear velocity of each component + Vector3* mSplitLinearVelocities; + + /// Array with the split angular velocity of each component + Vector3* mSplitAngularVelocities; + /// Array with the boolean value to know if the body has already been added into an island bool* mIsAlreadyInIsland; @@ -120,6 +126,12 @@ class DynamicsComponents : public Components { /// Return the constrained angular velocity of an entity const Vector3& getConstrainedAngularVelocity(Entity bodyEntity) const; + /// Return the split linear velocity of an entity + const Vector3& getSplitLinearVelocity(Entity bodyEntity) const; + + /// Return the split angular velocity of an entity + const Vector3& getSplitAngularVelocity(Entity bodyEntity) const; + /// Return true if the entity is already in an island bool getIsAlreadyInIsland(Entity bodyEntity) const; @@ -135,6 +147,12 @@ class DynamicsComponents : public Components { /// Set the constrained angular velocity of an entity void setConstrainedAngularVelocity(Entity bodyEntity, const Vector3& constrainedAngularVelocity); + /// Set the split linear velocity of an entity + void setSplitLinearVelocity(Entity bodyEntity, const Vector3& splitLinearVelocity); + + /// Set the split angular velocity of an entity + void setSplitAngularVelocity(Entity bodyEntity, const Vector3& splitAngularVelocity); + /// Set the value to know if the entity is already in an island bool setIsAlreadyInIsland(Entity bodyEntity, bool isAlreadyInIsland); @@ -185,24 +203,37 @@ inline void DynamicsComponents::setAngularVelocity(Entity bodyEntity, const Vect } // Return the constrained linear velocity of an entity -inline const Vector3 &DynamicsComponents::getConstrainedLinearVelocity(Entity bodyEntity) const { +inline const Vector3& DynamicsComponents::getConstrainedLinearVelocity(Entity bodyEntity) const { assert(mMapEntityToComponentIndex.containsKey(bodyEntity)); - // TODO : DELETE THIS - uint testIndex = mMapEntityToComponentIndex[bodyEntity]; - return mConstrainedLinearVelocities[mMapEntityToComponentIndex[bodyEntity]]; } // Return the constrained angular velocity of an entity -inline const Vector3 &DynamicsComponents::getConstrainedAngularVelocity(Entity bodyEntity) const { +inline const Vector3& DynamicsComponents::getConstrainedAngularVelocity(Entity bodyEntity) const { assert(mMapEntityToComponentIndex.containsKey(bodyEntity)); return mConstrainedAngularVelocities[mMapEntityToComponentIndex[bodyEntity]]; } +// Return the split linear velocity of an entity +inline const Vector3& DynamicsComponents::getSplitLinearVelocity(Entity bodyEntity) const { + + assert(mMapEntityToComponentIndex.containsKey(bodyEntity)); + + return mSplitLinearVelocities[mMapEntityToComponentIndex[bodyEntity]]; +} + +// Return the split angular velocity of an entity +inline const Vector3& DynamicsComponents::getSplitAngularVelocity(Entity bodyEntity) const { + + assert(mMapEntityToComponentIndex.containsKey(bodyEntity)); + + return mSplitAngularVelocities[mMapEntityToComponentIndex[bodyEntity]]; +} + // Set the constrained linear velocity of an entity inline void DynamicsComponents::setConstrainedLinearVelocity(Entity bodyEntity, const Vector3& constrainedLinearVelocity) { @@ -219,6 +250,22 @@ inline void DynamicsComponents::setConstrainedAngularVelocity(Entity bodyEntity, mConstrainedAngularVelocities[mMapEntityToComponentIndex[bodyEntity]] = constrainedAngularVelocity; } +// Set the split linear velocity of an entity +inline void DynamicsComponents::setSplitLinearVelocity(Entity bodyEntity, const Vector3& splitLinearVelocity) { + + assert(mMapEntityToComponentIndex.containsKey(bodyEntity)); + + mSplitLinearVelocities[mMapEntityToComponentIndex[bodyEntity]] = splitLinearVelocity; +} + +// Set the split angular velocity of an entity +inline void DynamicsComponents::setSplitAngularVelocity(Entity bodyEntity, const Vector3& splitAngularVelocity) { + + assert(mMapEntityToComponentIndex.containsKey(bodyEntity)); + + mSplitAngularVelocities[mMapEntityToComponentIndex[bodyEntity]] = splitAngularVelocity; +} + // Return true if the entity is already in an island inline bool DynamicsComponents::getIsAlreadyInIsland(Entity bodyEntity) const { diff --git a/src/engine/ContactSolver.cpp b/src/engine/ContactSolver.cpp index c95b6ffd..20e31f5b 100644 --- a/src/engine/ContactSolver.cpp +++ b/src/engine/ContactSolver.cpp @@ -46,9 +46,7 @@ const decimal ContactSolver::SLOP = decimal(0.01); // Constructor ContactSolver::ContactSolver(MemoryManager& memoryManager, Islands& islands, BodyComponents& bodyComponents, DynamicsComponents& dynamicsComponents, ProxyShapeComponents& proxyShapeComponents, const WorldSettings& worldSettings) - :mMemoryManager(memoryManager), mSplitLinearVelocities(nullptr), - mSplitAngularVelocities(nullptr), mContactConstraints(nullptr), - mContactPoints(nullptr), + :mMemoryManager(memoryManager), mContactConstraints(nullptr), mContactPoints(nullptr), mIslands(islands), mAllContactManifolds(nullptr), mAllContactPoints(nullptr), mBodyComponents(bodyComponents), mDynamicsComponents(dynamicsComponents), mProxyShapeComponents(proxyShapeComponents), mIsSplitImpulseActive(true), mWorldSettings(worldSettings) { @@ -109,8 +107,6 @@ void ContactSolver::initializeForIsland(uint islandIndex) { assert(mIslands.bodyEntities[islandIndex].size() > 0); assert(mIslands.nbContactManifolds[islandIndex] > 0); - assert(mSplitLinearVelocities != nullptr); - assert(mSplitAngularVelocities != nullptr); // For each contact manifold of the island uint contactManifoldsIndex = mIslands.contactManifoldsIndices[islandIndex]; @@ -574,10 +570,10 @@ void ContactSolver::solve() { if (mIsSplitImpulseActive) { // Split impulse (position correction) - const Vector3& v1Split = mSplitLinearVelocities[mContactConstraints[c].indexBody1]; - const Vector3& w1Split = mSplitAngularVelocities[mContactConstraints[c].indexBody1]; - const Vector3& v2Split = mSplitLinearVelocities[mContactConstraints[c].indexBody2]; - const Vector3& w2Split = mSplitAngularVelocities[mContactConstraints[c].indexBody2]; + const Vector3& v1Split = mDynamicsComponents.mSplitLinearVelocities[mContactConstraints[c].dynamicsComponentIndexBody1]; + const Vector3& w1Split = mDynamicsComponents.mSplitAngularVelocities[mContactConstraints[c].dynamicsComponentIndexBody1]; + const Vector3& v2Split = mDynamicsComponents.mSplitLinearVelocities[mContactConstraints[c].dynamicsComponentIndexBody2]; + const Vector3& w2Split = mDynamicsComponents.mSplitAngularVelocities[mContactConstraints[c].dynamicsComponentIndexBody2]; //Vector3 deltaVSplit = v2Split + w2Split.cross(mContactPoints[contactPointIndex].r2) - v1Split - w1Split.cross(mContactPoints[contactPointIndex].r1); Vector3 deltaVSplit(v2Split.x + w2Split.y * mContactPoints[contactPointIndex].r2.z - w2Split.z * mContactPoints[contactPointIndex].r2.y - v1Split.x - @@ -602,22 +598,22 @@ void ContactSolver::solve() { mContactPoints[contactPointIndex].normal.z * deltaLambdaSplit); // Update the velocities of the body 1 by applying the impulse P - mSplitLinearVelocities[mContactConstraints[c].indexBody1].x -= mContactConstraints[c].massInverseBody1 * linearImpulse.x; - mSplitLinearVelocities[mContactConstraints[c].indexBody1].y -= mContactConstraints[c].massInverseBody1 * linearImpulse.y; - mSplitLinearVelocities[mContactConstraints[c].indexBody1].z -= mContactConstraints[c].massInverseBody1 * linearImpulse.z; + mDynamicsComponents.mSplitLinearVelocities[mContactConstraints[c].dynamicsComponentIndexBody1].x -= mContactConstraints[c].massInverseBody1 * linearImpulse.x; + mDynamicsComponents.mSplitLinearVelocities[mContactConstraints[c].dynamicsComponentIndexBody1].y -= mContactConstraints[c].massInverseBody1 * linearImpulse.y; + mDynamicsComponents.mSplitLinearVelocities[mContactConstraints[c].dynamicsComponentIndexBody1].z -= mContactConstraints[c].massInverseBody1 * linearImpulse.z; - mSplitAngularVelocities[mContactConstraints[c].indexBody1].x -= mContactPoints[contactPointIndex].i1TimesR1CrossN.x * deltaLambdaSplit; - mSplitAngularVelocities[mContactConstraints[c].indexBody1].y -= mContactPoints[contactPointIndex].i1TimesR1CrossN.y * deltaLambdaSplit; - mSplitAngularVelocities[mContactConstraints[c].indexBody1].z -= mContactPoints[contactPointIndex].i1TimesR1CrossN.z * deltaLambdaSplit; + mDynamicsComponents.mSplitAngularVelocities[mContactConstraints[c].dynamicsComponentIndexBody1].x -= mContactPoints[contactPointIndex].i1TimesR1CrossN.x * deltaLambdaSplit; + mDynamicsComponents.mSplitAngularVelocities[mContactConstraints[c].dynamicsComponentIndexBody1].y -= mContactPoints[contactPointIndex].i1TimesR1CrossN.y * deltaLambdaSplit; + mDynamicsComponents.mSplitAngularVelocities[mContactConstraints[c].dynamicsComponentIndexBody1].z -= mContactPoints[contactPointIndex].i1TimesR1CrossN.z * deltaLambdaSplit; // Update the velocities of the body 1 by applying the impulse P - mSplitLinearVelocities[mContactConstraints[c].indexBody2].x += mContactConstraints[c].massInverseBody2 * linearImpulse.x; - mSplitLinearVelocities[mContactConstraints[c].indexBody2].y += mContactConstraints[c].massInverseBody2 * linearImpulse.y; - mSplitLinearVelocities[mContactConstraints[c].indexBody2].z += mContactConstraints[c].massInverseBody2 * linearImpulse.z; + mDynamicsComponents.mSplitLinearVelocities[mContactConstraints[c].dynamicsComponentIndexBody2].x += mContactConstraints[c].massInverseBody2 * linearImpulse.x; + mDynamicsComponents.mSplitLinearVelocities[mContactConstraints[c].dynamicsComponentIndexBody2].y += mContactConstraints[c].massInverseBody2 * linearImpulse.y; + mDynamicsComponents.mSplitLinearVelocities[mContactConstraints[c].dynamicsComponentIndexBody2].z += mContactConstraints[c].massInverseBody2 * linearImpulse.z; - mSplitAngularVelocities[mContactConstraints[c].indexBody2].x += mContactPoints[contactPointIndex].i2TimesR2CrossN.x * deltaLambdaSplit; - mSplitAngularVelocities[mContactConstraints[c].indexBody2].y += mContactPoints[contactPointIndex].i2TimesR2CrossN.y * deltaLambdaSplit; - mSplitAngularVelocities[mContactConstraints[c].indexBody2].z += mContactPoints[contactPointIndex].i2TimesR2CrossN.z * deltaLambdaSplit; + mDynamicsComponents.mSplitAngularVelocities[mContactConstraints[c].dynamicsComponentIndexBody2].x += mContactPoints[contactPointIndex].i2TimesR2CrossN.x * deltaLambdaSplit; + mDynamicsComponents.mSplitAngularVelocities[mContactConstraints[c].dynamicsComponentIndexBody2].y += mContactPoints[contactPointIndex].i2TimesR2CrossN.y * deltaLambdaSplit; + mDynamicsComponents.mSplitAngularVelocities[mContactConstraints[c].dynamicsComponentIndexBody2].z += mContactPoints[contactPointIndex].i2TimesR2CrossN.z * deltaLambdaSplit; } contactPointIndex++; diff --git a/src/engine/ContactSolver.h b/src/engine/ContactSolver.h index d39976d2..e130a4ea 100644 --- a/src/engine/ContactSolver.h +++ b/src/engine/ContactSolver.h @@ -291,14 +291,6 @@ class ContactSolver { /// Memory manager MemoryManager& mMemoryManager; - /// Split linear velocities for the position contact solver (split impulse) - // TODO : Use List<> here - Vector3* mSplitLinearVelocities; - - /// Split angular velocities for the position contact solver (split impulse) - // TODO : Use List<> here - Vector3* mSplitAngularVelocities; - /// Current time step decimal mTimeStep; @@ -388,10 +380,6 @@ class ContactSolver { /// Initialize the constraint solver for a given island void initializeForIsland(uint islandIndex); - /// Set the split velocities arrays - void setSplitVelocitiesArrays(Vector3* splitLinearVelocities, - Vector3* splitAngularVelocities); - /// Store the computed impulses to use them to /// warm start the solver at the next iteration void storeImpulses(); @@ -413,17 +401,6 @@ class ContactSolver { #endif }; -// Set the split velocities arrays -inline void ContactSolver::setSplitVelocitiesArrays(Vector3* splitLinearVelocities, - Vector3* splitAngularVelocities) { - - assert(splitLinearVelocities != nullptr); - assert(splitAngularVelocities != nullptr); - - mSplitLinearVelocities = splitLinearVelocities; - mSplitAngularVelocities = splitAngularVelocities; -} - // Return true if the split impulses position correction technique is used for contacts inline bool ContactSolver::isSplitImpulseActive() const { return mIsSplitImpulseActive; diff --git a/src/engine/DynamicsWorld.cpp b/src/engine/DynamicsWorld.cpp index 2f95d942..dd9903f6 100644 --- a/src/engine/DynamicsWorld.cpp +++ b/src/engine/DynamicsWorld.cpp @@ -56,7 +56,7 @@ DynamicsWorld::DynamicsWorld(const Vector3& gravity, const WorldSettings& worldS mNbPositionSolverIterations(mConfig.defaultPositionSolverNbIterations), mIsSleepingEnabled(mConfig.isSleepingEnabled), mRigidBodies(mMemoryManager.getPoolAllocator()), mJoints(mMemoryManager.getPoolAllocator()), mGravity(gravity), mTimeStep(decimal(1.0f / 60.0f)), - mIsGravityEnabled(true), mSplitLinearVelocities(nullptr), mSplitAngularVelocities(nullptr), mConstrainedPositions(nullptr), + mIsGravityEnabled(true), mConstrainedPositions(nullptr), mConstrainedOrientations(nullptr), mSleepLinearVelocity(mConfig.defaultSleepLinearVelocity), mSleepAngularVelocity(mConfig.defaultSleepAngularVelocity), mTimeBeforeSleep(mConfig.defaultTimeBeforeSleep), mFreeJointsIDs(mMemoryManager.getPoolAllocator()), mCurrentJointId(0) { @@ -187,8 +187,8 @@ void DynamicsWorld::integrateRigidBodiesPositions() { // to update the position) if (mContactSolver.isSplitImpulseActive()) { - newLinVelocity += mSplitLinearVelocities[indexArray]; - newAngVelocity += mSplitAngularVelocities[indexArray]; + newLinVelocity += mDynamicsComponents.getSplitLinearVelocity(bodyEntity); + newAngVelocity += mDynamicsComponents.getSplitAngularVelocity(bodyEntity); } // Get current position and orientation of the body @@ -259,16 +259,10 @@ void DynamicsWorld::initVelocityArrays() { assert(mDynamicsComponents.getNbComponents() == nbBodies); - mSplitLinearVelocities = static_cast(mMemoryManager.allocate(MemoryManager::AllocationType::Frame, - nbBodies * sizeof(Vector3))); - mSplitAngularVelocities = static_cast(mMemoryManager.allocate(MemoryManager::AllocationType::Frame, - nbBodies * sizeof(Vector3))); mConstrainedPositions = static_cast(mMemoryManager.allocate(MemoryManager::AllocationType::Frame, nbBodies * sizeof(Vector3))); mConstrainedOrientations = static_cast(mMemoryManager.allocate(MemoryManager::AllocationType::Frame, nbBodies * sizeof(Quaternion))); - assert(mSplitLinearVelocities != nullptr); - assert(mSplitAngularVelocities != nullptr); assert(mConstrainedPositions != nullptr); assert(mConstrainedOrientations != nullptr); @@ -276,13 +270,19 @@ void DynamicsWorld::initVelocityArrays() { uint i = 0; for (List::Iterator it = mRigidBodies.begin(); it != mRigidBodies.end(); ++it) { - mSplitLinearVelocities[i].setToZero(); - mSplitAngularVelocities[i].setToZero(); - (*it)->mArrayIndex = i++; } } +// Reset the split velocities of the bodies +void DynamicsWorld::resetSplitVelocities() { + + for(uint32 i=0; i < mDynamicsComponents.getNbEnabledComponents(); i++) { + mDynamicsComponents.mSplitLinearVelocities[i].setToZero(); + mDynamicsComponents.mSplitAngularVelocities[i].setToZero(); + } +} + // Integrate the velocities of rigid bodies. /// This method only set the temporary velocities but does not update /// the actual velocitiy of the bodies. The velocities updated in this method @@ -295,6 +295,9 @@ void DynamicsWorld::integrateRigidBodiesVelocities() { // Initialize the bodies velocity arrays initVelocityArrays(); + // Reset the split velocities of the bodies + resetSplitVelocities(); + // TODO : We should loop over non-sleeping dynamic components here and not over islands // For each island of the world @@ -309,8 +312,8 @@ void DynamicsWorld::integrateRigidBodiesVelocities() { const uint indexBody = body->mArrayIndex; - assert(mSplitLinearVelocities[indexBody] == Vector3(0, 0, 0)); - assert(mSplitAngularVelocities[indexBody] == Vector3(0, 0, 0)); + assert(mDynamicsComponents.getSplitLinearVelocity(bodyEntity) == Vector3(0, 0, 0)); + assert(mDynamicsComponents.getSplitAngularVelocity(bodyEntity) == Vector3(0, 0, 0)); assert(indexBody < mRigidBodies.size()); // Integrate the external force to get the new velocity of the body @@ -356,7 +359,6 @@ void DynamicsWorld::solveContactsAndConstraints() { RP3D_PROFILE("DynamicsWorld::solveContactsAndConstraints()", mProfiler); // Set the velocities arrays - mContactSolver.setSplitVelocitiesArrays(mSplitLinearVelocities, mSplitAngularVelocities); mConstraintSolver.setConstrainedPositionsArrays(mConstrainedPositions, mConstrainedOrientations); diff --git a/src/engine/DynamicsWorld.h b/src/engine/DynamicsWorld.h index a76c15ca..a1fa3717 100644 --- a/src/engine/DynamicsWorld.h +++ b/src/engine/DynamicsWorld.h @@ -88,14 +88,6 @@ class DynamicsWorld : public CollisionWorld { /// True if the gravity force is on bool mIsGravityEnabled; - // TODO : Move this into dynamic components - /// Split linear velocities for the position contact solver (split impulse) - Vector3* mSplitLinearVelocities; - - // TODO : Move this into dynamic components - /// Split angular velocities for the position contact solver (split impulse) - Vector3* mSplitAngularVelocities; - /// Array of constrained rigid bodies position (for position error correction) Vector3* mConstrainedPositions; @@ -129,6 +121,9 @@ class DynamicsWorld : public CollisionWorld { /// Initialize the bodies velocities arrays for the next simulation step. void initVelocityArrays(); + /// Reset the split velocities of the bodies + void resetSplitVelocities(); + /// Integrate the velocities of rigid bodies. void integrateRigidBodiesVelocities();