Add split velocities into the DynamicsComponents

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<Vector3*>(newLinearVelocities + nbComponentsToAllocate);
     Vector3* newConstrainedLinearVelocities = reinterpret_cast<Vector3*>(newAngularVelocities + nbComponentsToAllocate);
     Vector3* newConstrainedAngularVelocities = reinterpret_cast<Vector3*>(newConstrainedLinearVelocities + nbComponentsToAllocate);
-    bool* newIsAlreadyInIsland = reinterpret_cast<bool*>(newConstrainedAngularVelocities + nbComponentsToAllocate);
+    Vector3* newSplitLinearVelocities = reinterpret_cast<Vector3*>(newConstrainedAngularVelocities + nbComponentsToAllocate);
+    Vector3* newSplitAngularVelocities = reinterpret_cast<Vector3*>(newSplitLinearVelocities + nbComponentsToAllocate);
+    bool* newIsAlreadyInIsland = reinterpret_cast<bool*>(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();
 }

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 {
 

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),
+              :mMemoryManager(memoryManager), mContactConstraints(nullptr), mContactPoints(nullptr),
-               mSplitAngularVelocities(nullptr), 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& v1Split = mDynamicsComponents.mSplitLinearVelocities[mContactConstraints[c].dynamicsComponentIndexBody1];
-                const Vector3& w1Split = mSplitAngularVelocities[mContactConstraints[c].indexBody1];
+                const Vector3& w1Split = mDynamicsComponents.mSplitAngularVelocities[mContactConstraints[c].dynamicsComponentIndexBody1];
-                const Vector3& v2Split = mSplitLinearVelocities[mContactConstraints[c].indexBody2];
+                const Vector3& v2Split = mDynamicsComponents.mSplitLinearVelocities[mContactConstraints[c].dynamicsComponentIndexBody2];
-                const Vector3& w2Split = mSplitAngularVelocities[mContactConstraints[c].indexBody2];
+                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;
+                mDynamicsComponents.mSplitLinearVelocities[mContactConstraints[c].dynamicsComponentIndexBody1].x -= mContactConstraints[c].massInverseBody1 * linearImpulse.x;
-                mSplitLinearVelocities[mContactConstraints[c].indexBody1].y -= mContactConstraints[c].massInverseBody1 * linearImpulse.y;
+                mDynamicsComponents.mSplitLinearVelocities[mContactConstraints[c].dynamicsComponentIndexBody1].y -= mContactConstraints[c].massInverseBody1 * linearImpulse.y;
-                mSplitLinearVelocities[mContactConstraints[c].indexBody1].z -= mContactConstraints[c].massInverseBody1 * linearImpulse.z;
+                mDynamicsComponents.mSplitLinearVelocities[mContactConstraints[c].dynamicsComponentIndexBody1].z -= mContactConstraints[c].massInverseBody1 * linearImpulse.z;
 
-                mSplitAngularVelocities[mContactConstraints[c].indexBody1].x -= mContactPoints[contactPointIndex].i1TimesR1CrossN.x * deltaLambdaSplit;
+                mDynamicsComponents.mSplitAngularVelocities[mContactConstraints[c].dynamicsComponentIndexBody1].x -= mContactPoints[contactPointIndex].i1TimesR1CrossN.x * deltaLambdaSplit;
-                mSplitAngularVelocities[mContactConstraints[c].indexBody1].y -= mContactPoints[contactPointIndex].i1TimesR1CrossN.y * deltaLambdaSplit;
+                mDynamicsComponents.mSplitAngularVelocities[mContactConstraints[c].dynamicsComponentIndexBody1].y -= mContactPoints[contactPointIndex].i1TimesR1CrossN.y * deltaLambdaSplit;
-                mSplitAngularVelocities[mContactConstraints[c].indexBody1].z -= mContactPoints[contactPointIndex].i1TimesR1CrossN.z * 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;
+                mDynamicsComponents.mSplitLinearVelocities[mContactConstraints[c].dynamicsComponentIndexBody2].x += mContactConstraints[c].massInverseBody2 * linearImpulse.x;
-                mSplitLinearVelocities[mContactConstraints[c].indexBody2].y += mContactConstraints[c].massInverseBody2 * linearImpulse.y;
+                mDynamicsComponents.mSplitLinearVelocities[mContactConstraints[c].dynamicsComponentIndexBody2].y += mContactConstraints[c].massInverseBody2 * linearImpulse.y;
-                mSplitLinearVelocities[mContactConstraints[c].indexBody2].z += mContactConstraints[c].massInverseBody2 * linearImpulse.z;
+                mDynamicsComponents.mSplitLinearVelocities[mContactConstraints[c].dynamicsComponentIndexBody2].z += mContactConstraints[c].massInverseBody2 * linearImpulse.z;
 
-                mSplitAngularVelocities[mContactConstraints[c].indexBody2].x += mContactPoints[contactPointIndex].i2TimesR2CrossN.x * deltaLambdaSplit;
+                mDynamicsComponents.mSplitAngularVelocities[mContactConstraints[c].dynamicsComponentIndexBody2].x += mContactPoints[contactPointIndex].i2TimesR2CrossN.x * deltaLambdaSplit;
-                mSplitAngularVelocities[mContactConstraints[c].indexBody2].y += mContactPoints[contactPointIndex].i2TimesR2CrossN.y * deltaLambdaSplit;
+                mDynamicsComponents.mSplitAngularVelocities[mContactConstraints[c].dynamicsComponentIndexBody2].y += mContactPoints[contactPointIndex].i2TimesR2CrossN.y * deltaLambdaSplit;
-                mSplitAngularVelocities[mContactConstraints[c].indexBody2].z += mContactPoints[contactPointIndex].i2TimesR2CrossN.z * deltaLambdaSplit;
+                mDynamicsComponents.mSplitAngularVelocities[mContactConstraints[c].dynamicsComponentIndexBody2].z += mContactPoints[contactPointIndex].i2TimesR2CrossN.z * deltaLambdaSplit;
             }
 
             contactPointIndex++;

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;

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];
+                newLinVelocity += mDynamicsComponents.getSplitLinearVelocity(bodyEntity);
-                newAngVelocity += mSplitAngularVelocities[indexArray];
+                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<Vector3*>(mMemoryManager.allocate(MemoryManager::AllocationType::Frame,
-                                                                           nbBodies * sizeof(Vector3)));
-    mSplitAngularVelocities = static_cast<Vector3*>(mMemoryManager.allocate(MemoryManager::AllocationType::Frame,
-                                                                            nbBodies * sizeof(Vector3)));
     mConstrainedPositions = static_cast<Vector3*>(mMemoryManager.allocate(MemoryManager::AllocationType::Frame,
                                                                           nbBodies * sizeof(Vector3)));
     mConstrainedOrientations = static_cast<Quaternion*>(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<RigidBody*>::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(mDynamicsComponents.getSplitLinearVelocity(bodyEntity) == Vector3(0, 0, 0));
-            assert(mSplitAngularVelocities[indexBody] == 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);
 

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();