Add RigidBodyComponents class

CMakeLists.txt

@@ -142,6 +142,7 @@ SET (REACTPHYSICS3D_HEADERS
     "src/systems/BroadPhaseSystem.h"
     "src/components/Components.h"
     "src/components/CollisionBodyComponents.h"
+    "src/components/RigidBodyComponents.h"
     "src/components/TransformComponents.h"
     "src/components/ProxyShapeComponents.h"
     "src/components/DynamicsComponents.h"
@@ -233,6 +234,7 @@ SET (REACTPHYSICS3D_SOURCES
     "src/systems/BroadPhaseSystem.cpp"
     "src/components/Components.cpp"
     "src/components/CollisionBodyComponents.cpp"
+    "src/components/RigidBodyComponents.cpp"
     "src/components/TransformComponents.cpp"
     "src/components/ProxyShapeComponents.cpp"
     "src/components/DynamicsComponents.cpp"

src/body/CollisionBody.cpp

@@ -89,10 +89,10 @@ ProxyShape* CollisionBody::addCollisionShape(CollisionShape* collisionShape, con
     ProxyShapeComponents::ProxyShapeComponent proxyShapeComponent(mEntity, proxyShape, -1,
                                                                   AABB(localBoundsMin, localBoundsMax),
                                                                   transform, collisionShape, decimal(1), 0x0001, 0xFFFF);
-    bool isSleeping = mWorld.mBodyComponents.getIsSleeping(mEntity);
+    bool isActive = mWorld.mCollisionBodyComponents.getIsActive(mEntity);
-    mWorld.mProxyShapesComponents.addComponent(proxyShapeEntity, isSleeping, proxyShapeComponent);
+    mWorld.mProxyShapesComponents.addComponent(proxyShapeEntity, isActive, proxyShapeComponent);
 
-    mWorld.mBodyComponents.addProxyShapeToBody(mEntity, proxyShapeEntity);
+    mWorld.mCollisionBodyComponents.addProxyShapeToBody(mEntity, proxyShapeEntity);
 
 #ifdef IS_PROFILING_ACTIVE
 
@@ -131,7 +131,7 @@ ProxyShape* CollisionBody::addCollisionShape(CollisionShape* collisionShape, con
 * @return The number of proxy-shapes associated with this body
 */
 uint CollisionBody::getNbProxyShapes() const {
-    return static_cast<uint>(mWorld.mBodyComponents.getProxyShapes(mEntity).size());
+    return static_cast<uint>(mWorld.mCollisionBodyComponents.getProxyShapes(mEntity).size());
 }
 
 // Return a const pointer to a given proxy-shape of the body
@@ -142,7 +142,7 @@ const ProxyShape* CollisionBody::getProxyShape(uint proxyShapeIndex) const {
 
     assert(proxyShapeIndex < getNbProxyShapes());
 
-    Entity proxyShapeEntity = mWorld.mBodyComponents.getProxyShapes(mEntity)[proxyShapeIndex];
+    Entity proxyShapeEntity = mWorld.mCollisionBodyComponents.getProxyShapes(mEntity)[proxyShapeIndex];
 
     return mWorld.mProxyShapesComponents.getProxyShape(proxyShapeEntity);
 }
@@ -155,7 +155,7 @@ ProxyShape* CollisionBody::getProxyShape(uint proxyShapeIndex) {
 
     assert(proxyShapeIndex < getNbProxyShapes());
 
-    Entity proxyShapeEntity = mWorld.mBodyComponents.getProxyShapes(mEntity)[proxyShapeIndex];
+    Entity proxyShapeEntity = mWorld.mCollisionBodyComponents.getProxyShapes(mEntity)[proxyShapeIndex];
 
     return mWorld.mProxyShapesComponents.getProxyShape(proxyShapeEntity);
 }
@@ -177,7 +177,7 @@ void CollisionBody::removeCollisionShape(ProxyShape* proxyShape) {
         mWorld.mCollisionDetection.removeProxyCollisionShape(proxyShape);
     }
 
-    mWorld.mBodyComponents.removeProxyShapeFromBody(mEntity, proxyShape->getEntity());
+    mWorld.mCollisionBodyComponents.removeProxyShapeFromBody(mEntity, proxyShape->getEntity());
 
     // Remove the proxy-shape component
     mWorld.mProxyShapesComponents.removeComponent(proxyShape->getEntity());
@@ -194,7 +194,7 @@ void CollisionBody::removeAllCollisionShapes() {
 
     // Look for the proxy shape that contains the collision shape in parameter.
     // Note that we need to copy the list of proxy shapes entities because we are deleting them in a loop.
-    const List<Entity> proxyShapesEntities = mWorld.mBodyComponents.getProxyShapes(mEntity);
+    const List<Entity> proxyShapesEntities = mWorld.mCollisionBodyComponents.getProxyShapes(mEntity);
     for (uint i=0; i < proxyShapesEntities.size(); i++) {
 
         removeCollisionShape(mWorld.mProxyShapesComponents.getProxyShape(proxyShapesEntities[i]));
@@ -217,7 +217,7 @@ const Transform& CollisionBody::getTransform() const {
 void CollisionBody::updateBroadPhaseState() const {
 
     // For all the proxy collision shapes of the body
-    const List<Entity>& proxyShapesEntities = mWorld.mBodyComponents.getProxyShapes(mEntity);
+    const List<Entity>& proxyShapesEntities = mWorld.mCollisionBodyComponents.getProxyShapes(mEntity);
     for (uint i=0; i < proxyShapesEntities.size(); i++) {
 
         // Update the proxy
@@ -232,9 +232,9 @@ void CollisionBody::updateBroadPhaseState() const {
 void CollisionBody::setIsActive(bool isActive) {
 
     // If the state does not change
-    if (mWorld.mBodyComponents.getIsActive(mEntity) == isActive) return;
+    if (mWorld.mCollisionBodyComponents.getIsActive(mEntity) == isActive) return;
 
-    mWorld.mBodyComponents.setIsActive(mEntity, isActive);
+    mWorld.mCollisionBodyComponents.setIsActive(mEntity, isActive);
 
     // If we have to activate the body
     if (isActive) {
@@ -242,7 +242,7 @@ void CollisionBody::setIsActive(bool isActive) {
         const Transform& transform = mWorld.mTransformComponents.getTransform(mEntity);
 
         // For each proxy shape of the body
-        const List<Entity>& proxyShapesEntities = mWorld.mBodyComponents.getProxyShapes(mEntity);
+        const List<Entity>& proxyShapesEntities = mWorld.mCollisionBodyComponents.getProxyShapes(mEntity);
         for (uint i=0; i < proxyShapesEntities.size(); i++) {
 
             ProxyShape* proxyShape = mWorld.mProxyShapesComponents.getProxyShape(proxyShapesEntities[i]);
@@ -258,7 +258,7 @@ void CollisionBody::setIsActive(bool isActive) {
     else {  // If we have to deactivate the body
 
         // For each proxy shape of the body
-        const List<Entity>& proxyShapesEntities = mWorld.mBodyComponents.getProxyShapes(mEntity);
+        const List<Entity>& proxyShapesEntities = mWorld.mCollisionBodyComponents.getProxyShapes(mEntity);
         for (uint i=0; i < proxyShapesEntities.size(); i++) {
 
             ProxyShape* proxyShape = mWorld.mProxyShapesComponents.getProxyShape(proxyShapesEntities[i]);
@@ -281,7 +281,7 @@ void CollisionBody::setIsActive(bool isActive) {
 void CollisionBody::askForBroadPhaseCollisionCheck() const {
 
     // For all the proxy collision shapes of the body
-    const List<Entity>& proxyShapesEntities = mWorld.mBodyComponents.getProxyShapes(mEntity);
+    const List<Entity>& proxyShapesEntities = mWorld.mCollisionBodyComponents.getProxyShapes(mEntity);
     for (uint i=0; i < proxyShapesEntities.size(); i++) {
 
         ProxyShape* proxyShape = mWorld.mProxyShapesComponents.getProxyShape(proxyShapesEntities[i]);
@@ -299,7 +299,7 @@ void CollisionBody::askForBroadPhaseCollisionCheck() const {
 bool CollisionBody::testPointInside(const Vector3& worldPoint) const {
 
     // For each collision shape of the body
-    const List<Entity>& proxyShapesEntities = mWorld.mBodyComponents.getProxyShapes(mEntity);
+    const List<Entity>& proxyShapesEntities = mWorld.mCollisionBodyComponents.getProxyShapes(mEntity);
     for (uint i=0; i < proxyShapesEntities.size(); i++) {
 
         ProxyShape* proxyShape = mWorld.mProxyShapesComponents.getProxyShape(proxyShapesEntities[i]);
@@ -322,13 +322,13 @@ bool CollisionBody::testPointInside(const Vector3& worldPoint) const {
 bool CollisionBody::raycast(const Ray& ray, RaycastInfo& raycastInfo) {
 
     // If the body is not active, it cannot be hit by rays
-    if (!mWorld.mBodyComponents.getIsActive(mEntity)) return false;
+    if (!mWorld.mCollisionBodyComponents.getIsActive(mEntity)) return false;
 
     bool isHit = false;
     Ray rayTemp(ray);
 
     // For each collision shape of the body
-    const List<Entity>& proxyShapesEntities = mWorld.mBodyComponents.getProxyShapes(mEntity);
+    const List<Entity>& proxyShapesEntities = mWorld.mCollisionBodyComponents.getProxyShapes(mEntity);
     for (uint i=0; i < proxyShapesEntities.size(); i++) {
 
         ProxyShape* proxyShape = mWorld.mProxyShapesComponents.getProxyShape(proxyShapesEntities[i]);
@@ -351,7 +351,7 @@ AABB CollisionBody::getAABB() const {
 
     AABB bodyAABB;
 
-    const List<Entity>& proxyShapesEntities = mWorld.mBodyComponents.getProxyShapes(mEntity);
+    const List<Entity>& proxyShapesEntities = mWorld.mCollisionBodyComponents.getProxyShapes(mEntity);
     if (proxyShapesEntities.size() == 0) return bodyAABB;
 
     // TODO : Make sure we compute this in a system
@@ -401,7 +401,7 @@ void CollisionBody::setTransform(const Transform& transform) {
  * @return True if the body currently active and false otherwise
  */
 bool CollisionBody::isActive() const {
-    return mWorld.mBodyComponents.getIsActive(mEntity);
+    return mWorld.mCollisionBodyComponents.getIsActive(mEntity);
 }
 
 // Return a pointer to the user data attached to this body
@@ -409,7 +409,7 @@ bool CollisionBody::isActive() const {
  * @return A pointer to the user data you have attached to the body
  */
 void* CollisionBody::getUserData() const {
-    return mWorld.mBodyComponents.getUserData(mEntity);
+    return mWorld.mCollisionBodyComponents.getUserData(mEntity);
 }
 
 // Attach user data to this body
@@ -417,7 +417,7 @@ void* CollisionBody::getUserData() const {
  * @param userData A pointer to the user data you want to attach to the body
  */
 void CollisionBody::setUserData(void* userData) {
-    mWorld.mBodyComponents.setUserData(mEntity, userData);
+    mWorld.mCollisionBodyComponents.setUserData(mEntity, userData);
 }
 
 // Return the world-space coordinates of a point given the local-space coordinates of the body

src/body/RigidBody.cpp

@@ -171,7 +171,7 @@ void RigidBody::applyForce(const Vector3& force, const Vector3& point) {
     if (mWorld.mDynamicsComponents.getBodyType(mEntity) != BodyType::DYNAMIC) return;
 
     // Awake the body if it was sleeping
-    if (mWorld.mBodyComponents.getIsSleeping(mEntity)) {
+    if (mWorld.mRigidBodyComponents.getIsSleeping(mEntity)) {
         setIsSleeping(false);
     }
 
@@ -223,7 +223,7 @@ void RigidBody::applyForceToCenterOfMass(const Vector3& force) {
     if (mWorld.mDynamicsComponents.getBodyType(mEntity) != BodyType::DYNAMIC) return;
 
     // Awake the body if it was sleeping
-    if (mWorld.mBodyComponents.getIsSleeping(mEntity)) {
+    if (mWorld.mRigidBodyComponents.getIsSleeping(mEntity)) {
         setIsSleeping(false);
     }
 
@@ -408,10 +408,10 @@ ProxyShape* RigidBody::addCollisionShape(CollisionShape* collisionShape,
     ProxyShapeComponents::ProxyShapeComponent proxyShapeComponent(mEntity, proxyShape, -1,
                                                                    AABB(localBoundsMin, localBoundsMax),
                                                                    transform, collisionShape, mass, 0x0001, 0xFFFF);
-    bool isSleeping = mWorld.mBodyComponents.getIsSleeping(mEntity);
+    bool isSleeping = mWorld.mRigidBodyComponents.getIsSleeping(mEntity);
     mWorld.mProxyShapesComponents.addComponent(proxyShapeEntity, isSleeping, proxyShapeComponent);
 
-    mWorld.mBodyComponents.addProxyShapeToBody(mEntity, proxyShapeEntity);
+    mWorld.mCollisionBodyComponents.addProxyShapeToBody(mEntity, proxyShapeEntity);
 
 #ifdef IS_PROFILING_ACTIVE
 
@@ -626,7 +626,7 @@ void RigidBody::recomputeMassInformation() {
     assert(mWorld.mDynamicsComponents.getBodyType(mEntity) == BodyType::DYNAMIC);
 
     // Compute the total mass of the body
-    const List<Entity>& proxyShapesEntities = mWorld.mBodyComponents.getProxyShapes(mEntity);
+    const List<Entity>& proxyShapesEntities = mWorld.mCollisionBodyComponents.getProxyShapes(mEntity);
     for (uint i=0; i < proxyShapesEntities.size(); i++) {
         ProxyShape* proxyShape = mWorld.mProxyShapesComponents.getProxyShape(proxyShapesEntities[i]);
         mWorld.mDynamicsComponents.setInitMass(mEntity, mWorld.mDynamicsComponents.getInitMass(mEntity) + proxyShape->getMass());
@@ -657,7 +657,7 @@ void RigidBody::recomputeMassInformation() {
     if (!mIsInertiaTensorSetByUser) {
 
         // Compute the inertia tensor using all the collision shapes
-        const List<Entity>& proxyShapesEntities = mWorld.mBodyComponents.getProxyShapes(mEntity);
+        const List<Entity>& proxyShapesEntities = mWorld.mCollisionBodyComponents.getProxyShapes(mEntity);
         for (uint i=0; i < proxyShapesEntities.size(); i++) {
 
             ProxyShape* proxyShape = mWorld.mProxyShapesComponents.getProxyShape(proxyShapesEntities[i]);
@@ -739,7 +739,7 @@ void RigidBody::applyTorque(const Vector3& torque) {
     if (mWorld.mDynamicsComponents.getBodyType(mEntity) != BodyType::DYNAMIC) return;
 
     // Awake the body if it was sleeping
-    if (mWorld.mBodyComponents.getIsSleeping(mEntity)) {
+    if (mWorld.mRigidBodyComponents.getIsSleeping(mEntity)) {
         setIsSleeping(false);
     }
 
@@ -751,26 +751,26 @@ void RigidBody::applyTorque(const Vector3& torque) {
 // Set the variable to know whether or not the body is sleeping
 void RigidBody::setIsSleeping(bool isSleeping) {
 
-    bool isBodySleeping = mWorld.mBodyComponents.getIsSleeping(mEntity);
+    bool isBodySleeping = mWorld.mRigidBodyComponents.getIsSleeping(mEntity);
 
     if (isBodySleeping == isSleeping) return;
 
     // If the body is not active, do nothing (it is sleeping)
-    if (!mWorld.mBodyComponents.getIsActive(mEntity)) {
+    if (!mWorld.mCollisionBodyComponents.getIsActive(mEntity)) {
         assert(isBodySleeping);
         return;
     }
 
     if (isSleeping) {
-        mWorld.mBodyComponents.setSleepTime(mEntity, decimal(0.0));
+        mWorld.mRigidBodyComponents.setSleepTime(mEntity, decimal(0.0));
     }
     else {
         if (isBodySleeping) {
-            mWorld.mBodyComponents.setSleepTime(mEntity, decimal(0.0));
+            mWorld.mRigidBodyComponents.setSleepTime(mEntity, decimal(0.0));
         }
     }
 
-    mWorld.mBodyComponents.setIsSleeping(mEntity, isSleeping);
+    mWorld.mRigidBodyComponents.setIsSleeping(mEntity, isSleeping);
 
     // Notify all the components
     mWorld.notifyBodyDisabled(mEntity, isSleeping);
@@ -795,7 +795,7 @@ void RigidBody::setIsSleeping(bool isSleeping) {
  */
 void RigidBody::setIsAllowedToSleep(bool isAllowedToSleep) {
 
-    mWorld.mBodyComponents.setIsAllowedToSleep(mEntity, isAllowedToSleep);
+    mWorld.mRigidBodyComponents.setIsAllowedToSleep(mEntity, isAllowedToSleep);
 
     if (!isAllowedToSleep) setIsSleeping(false);
 
@@ -809,7 +809,7 @@ void RigidBody::setIsAllowedToSleep(bool isAllowedToSleep) {
  * @return True if the body is allowed to sleep and false otherwise
  */
 bool RigidBody::isAllowedToSleep() const {
-    return mWorld.mBodyComponents.getIsAllowedToSleep(mEntity);
+    return mWorld.mRigidBodyComponents.getIsAllowedToSleep(mEntity);
 }
 
 // Return whether or not the body is sleeping
@@ -817,7 +817,7 @@ bool RigidBody::isAllowedToSleep() const {
  * @return True if the body is currently sleeping and false otherwise
  */
 bool RigidBody::isSleeping() const {
-    return mWorld.mBodyComponents.getIsSleeping(mEntity);
+    return mWorld.mRigidBodyComponents.getIsSleeping(mEntity);
 }
 
 // Set whether or not the body is active
@@ -827,7 +827,7 @@ bool RigidBody::isSleeping() const {
 void RigidBody::setIsActive(bool isActive) {
 
     // If the state does not change
-    if (mWorld.mBodyComponents.getIsActive(mEntity) == isActive) return;
+    if (mWorld.mCollisionBodyComponents.getIsActive(mEntity) == isActive) return;
 
     setIsSleeping(!isActive);
 
@@ -842,7 +842,7 @@ void RigidBody::setProfiler(Profiler* profiler) {
 	CollisionBody::setProfiler(profiler);
 
 	// Set the profiler for each proxy shape
-    const List<Entity>& proxyShapesEntities = mWorld.mBodyComponents.getProxyShapes(mEntity);
+    const List<Entity>& proxyShapesEntities = mWorld.mCollisionBodyComponents.getProxyShapes(mEntity);
     for (uint i=0; i < proxyShapesEntities.size(); i++) {
 
         ProxyShape* proxyShape = mWorld.mProxyShapesComponents.getProxyShape(proxyShapesEntities[i]);

src/body/RigidBody.h

@@ -195,6 +195,8 @@ class RigidBody : public CollisionBody {
         virtual void setIsActive(bool isActive) override;
 
         /// Add a collision shape to the body.
+        // TODO : Remove the mass from this parameter so that we can correctly use inheritance here
+        //        The user will then need to call ProxyShape->setMass() to set the mass of the shape
         virtual ProxyShape* addCollisionShape(CollisionShape* collisionShape,
                                               const Transform& transform,
                                               decimal mass);

src/collision/CollisionCallback.cpp

@@ -47,12 +47,12 @@ CollisionCallback::ContactPair::ContactPair(const reactphysics3d::ContactPair& c
 
 // Return a pointer to the first body in contact
 CollisionBody* CollisionCallback::ContactPair::getBody1() const {
-    return static_cast<CollisionBody*>(mWorld.mBodyComponents.getBody(mContactPair.body1Entity));
+    return static_cast<CollisionBody*>(mWorld.mCollisionBodyComponents.getBody(mContactPair.body1Entity));
 }
 
 // Return a pointer to the second body in contact
 CollisionBody* CollisionCallback::ContactPair::getBody2() const {
-    return static_cast<CollisionBody*>(mWorld.mBodyComponents.getBody(mContactPair.body2Entity));
+    return static_cast<CollisionBody*>(mWorld.mCollisionBodyComponents.getBody(mContactPair.body2Entity));
 }
 
 // Return a pointer to the first proxy-shape in contact (in body 1)

src/collision/CollisionDetection.cpp

@@ -243,8 +243,8 @@ void CollisionDetection::computeMiddlePhase(OverlappingPairMap& overlappingPairs
                                             mWorld->mDynamicsComponents.getBodyType(body2Entity) == BodyType::STATIC;
 
             // Check that at least one body is enabled (active and awake) and not static
-            bool isBody1Active = !mWorld->mBodyComponents.getIsEntityDisabled(body1Entity) && !isStaticRigidBody1;
+            bool isBody1Active = !mWorld->mCollisionBodyComponents.getIsEntityDisabled(body1Entity) && !isStaticRigidBody1;
-            bool isBody2Active = !mWorld->mBodyComponents.getIsEntityDisabled(body2Entity) && !isStaticRigidBody2;
+            bool isBody2Active = !mWorld->mCollisionBodyComponents.getIsEntityDisabled(body2Entity) && !isStaticRigidBody2;
             if (!isBody1Active && !isBody2Active) continue;
 
             // Check if the bodies are in the set of bodies that cannot collide between each other
@@ -932,7 +932,7 @@ void CollisionDetection::processPotentialContacts(NarrowPhaseInfoBatch& narrowPh
                     Entity body1Entity = narrowPhaseInfoBatch.overlappingPairs[i]->getShape1()->getBody()->getEntity();
                     Entity body2Entity = narrowPhaseInfoBatch.overlappingPairs[i]->getShape2()->getBody()->getEntity();
 
-                    assert(!mWorld->mBodyComponents.getIsEntityDisabled(body1Entity) || !mWorld->mBodyComponents.getIsEntityDisabled(body2Entity));
+                    assert(!mWorld->mCollisionBodyComponents.getIsEntityDisabled(body1Entity) || !mWorld->mCollisionBodyComponents.getIsEntityDisabled(body2Entity));
 
                     // TODO : We should probably use a single frame allocator here
                     const uint newContactPairIndex = contactPairs->size();

src/collision/OverlapCallback.cpp

@@ -38,12 +38,12 @@ OverlapCallback::OverlapPair::OverlapPair(Pair<Entity, Entity>& overlapPair, Col
 
 // Return a pointer to the first body in contact
 CollisionBody* OverlapCallback::OverlapPair::getBody1() const {
-    return static_cast<CollisionBody*>(mWorld.mBodyComponents.getBody(mOverlapPair.first));
+    return static_cast<CollisionBody*>(mWorld.mCollisionBodyComponents.getBody(mOverlapPair.first));
 }
 
 // Return a pointer to the second body in contact
 CollisionBody* OverlapCallback::OverlapPair::getBody2() const {
-    return static_cast<CollisionBody*>(mWorld.mBodyComponents.getBody(mOverlapPair.second));
+    return static_cast<CollisionBody*>(mWorld.mCollisionBodyComponents.getBody(mOverlapPair.second));
 }
 
 // CollisionCallbackData Constructor

src/collision/ProxyShape.cpp

@@ -119,7 +119,7 @@ void ProxyShape::setLocalToBodyTransform(const Transform& transform) {
 
     RigidBody* rigidBody = static_cast<RigidBody*>(mBody);
     if (rigidBody != nullptr) {
-        mBody->mWorld.mBodyComponents.setIsSleeping(mBody->getEntity(), false);
+        mBody->mWorld.mRigidBodyComponents.setIsSleeping(mBody->getEntity(), false);
     }
 
     mBody->mWorld.mCollisionDetection.updateProxyShape(mEntity);

src/components/CollisionBodyComponents.cpp

@@ -35,8 +35,7 @@ using namespace reactphysics3d;
 // Constructor
 CollisionBodyComponents::CollisionBodyComponents(MemoryAllocator& allocator)
                     :Components(allocator, sizeof(Entity) + sizeof(CollisionBody*) + sizeof(List<Entity>) +
-                                sizeof(bool) + sizeof(bool) + sizeof(bool) + sizeof(decimal) +
+                                sizeof(bool) + sizeof(void*)) {
-                                sizeof(void*)) {
 
     // Allocate memory for the components data
     allocate(INIT_NB_ALLOCATED_COMPONENTS);
@@ -58,11 +57,8 @@ void CollisionBodyComponents::allocate(uint32 nbComponentsToAllocate) {
     Entity* newBodiesEntities = static_cast<Entity*>(newBuffer);
     CollisionBody** newBodies = reinterpret_cast<CollisionBody**>(newBodiesEntities + nbComponentsToAllocate);
     List<Entity>* newProxyShapes = reinterpret_cast<List<Entity>*>(newBodies + nbComponentsToAllocate);
-    bool* newIsAllowedToSleep = reinterpret_cast<bool*>(newProxyShapes + nbComponentsToAllocate);
+    bool* newIsActive = reinterpret_cast<bool*>(newProxyShapes + nbComponentsToAllocate);
-    bool* newIsActive = reinterpret_cast<bool*>(newIsAllowedToSleep + nbComponentsToAllocate);
+    void** newUserData = reinterpret_cast<void**>(newIsActive + nbComponentsToAllocate);
-    bool* newIsSleeping = reinterpret_cast<bool*>(newIsActive + nbComponentsToAllocate);
-    decimal* newSleepTimes = reinterpret_cast<decimal*>(newIsSleeping + nbComponentsToAllocate);
-    void** newUserData = reinterpret_cast<void**>(newIsSleeping + nbComponentsToAllocate);
 
     // If there was already components before
     if (mNbComponents > 0) {
@@ -71,10 +67,7 @@ void CollisionBodyComponents::allocate(uint32 nbComponentsToAllocate) {
         memcpy(newBodiesEntities, mBodiesEntities, mNbComponents * sizeof(Entity));
         memcpy(newBodies, mBodies, mNbComponents * sizeof(CollisionBody*));
         memcpy(newProxyShapes, mProxyShapes, mNbComponents * sizeof(List<Entity>));
-        memcpy(newIsAllowedToSleep, mIsAllowedToSleep, mNbComponents * sizeof(bool));
         memcpy(newIsActive, mIsActive, mNbComponents * sizeof(bool));
-        memcpy(newIsSleeping, mIsSleeping, mNbComponents * sizeof(bool));
-        memcpy(newSleepTimes, mSleepTimes, mNbComponents * sizeof(bool));
         memcpy(newUserData, mUserData, mNbComponents * sizeof(void*));
 
         // Deallocate previous memory
@@ -85,16 +78,13 @@ void CollisionBodyComponents::allocate(uint32 nbComponentsToAllocate) {
     mBodiesEntities = newBodiesEntities;
     mBodies = newBodies;
     mProxyShapes = newProxyShapes;
-    mIsAllowedToSleep = newIsAllowedToSleep;
     mIsActive = newIsActive;
-    mIsSleeping = newIsSleeping;
-    mSleepTimes = newSleepTimes;
     mUserData = newUserData;
     mNbAllocatedComponents = nbComponentsToAllocate;
 }
 
 // Add a component
-void CollisionBodyComponents::addComponent(Entity bodyEntity, bool isSleeping, const BodyComponent& component) {
+void CollisionBodyComponents::addComponent(Entity bodyEntity, bool isSleeping, const CollisionBodyComponent& component) {
 
     // Prepare to add new component (allocate memory if necessary and compute insertion index)
     uint32 index = prepareAddComponent(isSleeping);
@@ -103,10 +93,7 @@ void CollisionBodyComponents::addComponent(Entity bodyEntity, bool isSleeping, c
     new (mBodiesEntities + index) Entity(bodyEntity);
     mBodies[index] = component.body;
     new (mProxyShapes + index) List<Entity>(mMemoryAllocator);
-    mIsAllowedToSleep[index] = true;
     mIsActive[index] = true;
-    mIsSleeping[index] = false;
-    mSleepTimes[index] = decimal(0);
     mUserData[index] = nullptr;
 
     // Map the entity with the new component lookup index
@@ -128,10 +115,7 @@ void CollisionBodyComponents::moveComponentToIndex(uint32 srcIndex, uint32 destI
     new (mBodiesEntities + destIndex) Entity(mBodiesEntities[srcIndex]);
     mBodies[destIndex] = mBodies[srcIndex];
     new (mProxyShapes + destIndex) List<Entity>(mProxyShapes[srcIndex]);
-    mIsAllowedToSleep[destIndex] = mIsAllowedToSleep[srcIndex];
     mIsActive[destIndex] = mIsActive[srcIndex];
-    mIsSleeping[destIndex] = mIsSleeping[srcIndex];
-    mSleepTimes[destIndex] = mSleepTimes[srcIndex];
     mUserData[destIndex] = mUserData[srcIndex];
 
     // Destroy the source component
@@ -152,10 +136,7 @@ void CollisionBodyComponents::swapComponents(uint32 index1, uint32 index2) {
     Entity entity1(mBodiesEntities[index1]);
     CollisionBody* body1 = mBodies[index1];
     List<Entity> proxyShapes1(mProxyShapes[index1]);
-    bool isAllowedToSleep1 = mIsAllowedToSleep[index1];
     bool isActive1 = mIsActive[index1];
-    bool isSleeping1 = mIsSleeping[index1];
-    decimal sleepTime1 = mSleepTimes[index1];
     void* userData1 = mUserData[index1];
 
     // Destroy component 1
@@ -167,9 +148,7 @@ void CollisionBodyComponents::swapComponents(uint32 index1, uint32 index2) {
     new (mBodiesEntities + index2) Entity(entity1);
     new (mProxyShapes + index2) List<Entity>(proxyShapes1);
     mBodies[index2] = body1;
-    mIsAllowedToSleep[index2] = isAllowedToSleep1;
     mIsActive[index2] = isActive1;
-    mIsSleeping[index2] = isSleeping1;
     mUserData[index2] = userData1;
 
     // Update the entity to component index mapping

src/components/CollisionBodyComponents.h

@@ -23,8 +23,8 @@
 *                                                                               *
 ********************************************************************************/
 
-#ifndef REACTPHYSICS3D_BODY_COMPONENTS_H
+#ifndef REACTPHYSICS3D_COLLISION_BODY_COMPONENTS_H
-#define REACTPHYSICS3D_BODY_COMPONENTS_H
+#define REACTPHYSICS3D_COLLISION_BODY_COMPONENTS_H
 
 // Libraries
 #include "mathematics/Transform.h"
@@ -60,18 +60,9 @@ class CollisionBodyComponents : public Components {
         /// Array with the list of proxy-shapes of each body
         List<Entity>* mProxyShapes;
 
-        /// Array of boolean values to know if the body is allowed to go to sleep
-        bool* mIsAllowedToSleep;
-
         /// Array of boolean values to know if the body is active.
         bool* mIsActive;
 
-        /// Array of boolean values to know if the body is sleeping
-        bool* mIsSleeping;
-
-        /// Array with values for elapsed time since the body velocity was below the sleep velocity
-        decimal* mSleepTimes;
-
         /// Array of pointers that can be used to attach user data to the body
         void** mUserData;
 
@@ -91,13 +82,13 @@ class CollisionBodyComponents : public Components {
 
     public:
 
-        /// Structure for the data of a body component
+        /// Structure for the data of a collision body component
-        struct BodyComponent {
+        struct CollisionBodyComponent {
 
             CollisionBody* body;
 
             /// Constructor
-            BodyComponent(CollisionBody* body) : body(body) {
+            CollisionBodyComponent(CollisionBody* body) : body(body) {
 
             }
         };
@@ -111,7 +102,7 @@ class CollisionBodyComponents : public Components {
         virtual ~CollisionBodyComponents() override = default;
 
         /// Add a component
-        void addComponent(Entity bodyEntity, bool isSleeping, const BodyComponent& component);
+        void addComponent(Entity bodyEntity, bool isSleeping, const CollisionBodyComponent& component);
 
         /// Add a proxy-shape to a body component
         void addProxyShapeToBody(Entity bodyEntity, Entity proxyShapeEntity);
@@ -125,30 +116,12 @@ class CollisionBodyComponents : public Components {
         /// Return the list of proxy-shapes of a body
         const List<Entity>& getProxyShapes(Entity bodyEntity) const;
 
-        /// Return true if the body is allowed to sleep
-        bool getIsAllowedToSleep(Entity bodyEntity) const;
-
-        /// Set the value to know if the body is allowed to sleep
-        void setIsAllowedToSleep(Entity bodyEntity, bool isAllowedToSleep) const;
-
         /// Return true if the body is active
         bool getIsActive(Entity bodyEntity) const;
 
         /// Set the value to know if the body is active
         void setIsActive(Entity bodyEntity, bool isActive) const;
 
-        /// Return true if the body is sleeping
-        bool getIsSleeping(Entity bodyEntity) const;
-
-        /// Set the value to know if the body is sleeping
-        void setIsSleeping(Entity bodyEntity, bool isSleeping) const;
-
-        /// Return the sleep time
-        decimal getSleepTime(Entity bodyEntity) const;
-
-        /// Set the sleep time
-        void setSleepTime(Entity bodyEntity, decimal sleepTime) const;
-
         /// Return the user data associated with the body
         void* getUserData(Entity bodyEntity) const;
 
@@ -188,22 +161,6 @@ inline const List<Entity>& CollisionBodyComponents::getProxyShapes(Entity bodyEn
     return mProxyShapes[mMapEntityToComponentIndex[bodyEntity]];
 }
 
-// Return true if the body is allowed to sleep
-inline bool CollisionBodyComponents::getIsAllowedToSleep(Entity bodyEntity) const {
-
-    assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
-
-    return mIsAllowedToSleep[mMapEntityToComponentIndex[bodyEntity]];
-}
-
-// Set the value to know if the body is allowed to sleep
-inline void CollisionBodyComponents::setIsAllowedToSleep(Entity bodyEntity, bool isAllowedToSleep) const {
-
-    assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
-
-    mIsAllowedToSleep[mMapEntityToComponentIndex[bodyEntity]] = isAllowedToSleep;
-}
-
 // Return true if the body is active
 inline bool CollisionBodyComponents::getIsActive(Entity bodyEntity) const {
 
@@ -220,38 +177,6 @@ inline void CollisionBodyComponents::setIsActive(Entity bodyEntity, bool isActiv
     mIsActive[mMapEntityToComponentIndex[bodyEntity]] = isActive;
 }
 
-// Return true if the body is sleeping
-inline bool CollisionBodyComponents::getIsSleeping(Entity bodyEntity) const {
-
-    assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
-
-    return mIsSleeping[mMapEntityToComponentIndex[bodyEntity]];
-}
-
-// Set the value to know if the body is sleeping
-inline void CollisionBodyComponents::setIsSleeping(Entity bodyEntity, bool isSleeping) const {
-
-    assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
-
-    mIsSleeping[mMapEntityToComponentIndex[bodyEntity]] = isSleeping;
-}
-
-// Return the sleep time
-inline decimal CollisionBodyComponents::getSleepTime(Entity bodyEntity) const {
-
-    assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
-
-    return mSleepTimes[mMapEntityToComponentIndex[bodyEntity]];
-}
-
-// Set the sleep time
-inline void CollisionBodyComponents::setSleepTime(Entity bodyEntity, decimal sleepTime) const {
-
-    assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
-
-    mSleepTimes[mMapEntityToComponentIndex[bodyEntity]] = sleepTime;
-}
-
 // Return the user data associated with the body
 inline void* CollisionBodyComponents::getUserData(Entity bodyEntity) const {
 

src/components/RigidBodyComponents.cpp

@@ -0,0 +1,173 @@
+/********************************************************************************
+* ReactPhysics3D physics library, http://www.reactphysics3d.com                 *
+* Copyright (c) 2010-2018 Daniel Chappuis                                       *
+*********************************************************************************
+*                                                                               *
+* 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.    *
+*                                                                               *
+********************************************************************************/
+
+// Libraries
+#include "RigidBodyComponents.h"
+#include "engine/EntityManager.h"
+#include <cassert>
+#include <random>
+
+// We want to use the ReactPhysics3D namespace
+using namespace reactphysics3d;
+
+// Constructor
+RigidBodyComponents::RigidBodyComponents(MemoryAllocator& allocator)
+                    :Components(allocator, sizeof(Entity) + sizeof(RigidBody*) +
+                                sizeof(bool) + sizeof(bool) + sizeof(decimal) ) {
+
+    // Allocate memory for the components data
+    allocate(INIT_NB_ALLOCATED_COMPONENTS);
+}
+
+// Allocate memory for a given number of components
+void RigidBodyComponents::allocate(uint32 nbComponentsToAllocate) {
+
+    assert(nbComponentsToAllocate > mNbAllocatedComponents);
+
+    // Size for the data of a single component (in bytes)
+    const size_t totalSizeBytes = nbComponentsToAllocate * mComponentDataSize;
+
+    // Allocate memory
+    void* newBuffer = mMemoryAllocator.allocate(totalSizeBytes);
+    assert(newBuffer != nullptr);
+
+    // New pointers to components data
+    Entity* newBodiesEntities = static_cast<Entity*>(newBuffer);
+    RigidBody** newBodies = reinterpret_cast<RigidBody**>(newBodiesEntities + nbComponentsToAllocate);
+    bool* newIsAllowedToSleep = reinterpret_cast<bool*>(newBodies + nbComponentsToAllocate);
+    bool* newIsSleeping = reinterpret_cast<bool*>(newIsAllowedToSleep + nbComponentsToAllocate);
+    decimal* newSleepTimes = reinterpret_cast<decimal*>(newIsSleeping + nbComponentsToAllocate);
+
+    // If there was already components before
+    if (mNbComponents > 0) {
+
+        // Copy component data from the previous buffer to the new one
+        memcpy(newBodiesEntities, mBodiesEntities, mNbComponents * sizeof(Entity));
+        memcpy(newBodies, mRigidBodies, mNbComponents * sizeof(RigidBody*));
+        memcpy(newIsAllowedToSleep, mIsAllowedToSleep, mNbComponents * sizeof(bool));
+        memcpy(newIsSleeping, mIsSleeping, mNbComponents * sizeof(bool));
+        memcpy(newSleepTimes, mSleepTimes, mNbComponents * sizeof(bool));
+
+        // Deallocate previous memory
+        mMemoryAllocator.release(mBuffer, mNbAllocatedComponents * mComponentDataSize);
+    }
+
+    mBuffer = newBuffer;
+    mBodiesEntities = newBodiesEntities;
+    mRigidBodies = newBodies;
+    mIsAllowedToSleep = newIsAllowedToSleep;
+    mIsSleeping = newIsSleeping;
+    mSleepTimes = newSleepTimes;
+    mNbAllocatedComponents = nbComponentsToAllocate;
+}
+
+// Add a component
+void RigidBodyComponents::addComponent(Entity bodyEntity, bool isSleeping, const RigidBodyComponent& component) {
+
+    // Prepare to add new component (allocate memory if necessary and compute insertion index)
+    uint32 index = prepareAddComponent(isSleeping);
+
+    // Insert the new component data
+    new (mBodiesEntities + index) Entity(bodyEntity);
+    mRigidBodies[index] = component.body;
+    mIsAllowedToSleep[index] = true;
+    mIsSleeping[index] = false;
+    mSleepTimes[index] = decimal(0);
+
+    // Map the entity with the new component lookup index
+    mMapEntityToComponentIndex.add(Pair<Entity, uint32>(bodyEntity, index));
+
+    mNbComponents++;
+
+    assert(mDisabledStartIndex <= mNbComponents);
+    assert(mNbComponents == static_cast<uint32>(mMapEntityToComponentIndex.size()));
+}
+
+// Move a component from a source to a destination index in the components array
+// The destination location must contain a constructed object
+void RigidBodyComponents::moveComponentToIndex(uint32 srcIndex, uint32 destIndex) {
+
+    const Entity entity = mBodiesEntities[srcIndex];
+
+    // Copy the data of the source component to the destination location
+    new (mBodiesEntities + destIndex) Entity(mBodiesEntities[srcIndex]);
+    mRigidBodies[destIndex] = mRigidBodies[srcIndex];
+    mIsAllowedToSleep[destIndex] = mIsAllowedToSleep[srcIndex];
+    mIsSleeping[destIndex] = mIsSleeping[srcIndex];
+    mSleepTimes[destIndex] = mSleepTimes[srcIndex];
+
+    // Destroy the source component
+    destroyComponent(srcIndex);
+
+    assert(!mMapEntityToComponentIndex.containsKey(entity));
+
+    // Update the entity to component index mapping
+    mMapEntityToComponentIndex.add(Pair<Entity, uint32>(entity, destIndex));
+
+    assert(mMapEntityToComponentIndex[mBodiesEntities[destIndex]] == destIndex);
+}
+
+// Swap two components in the array
+void RigidBodyComponents::swapComponents(uint32 index1, uint32 index2) {
+
+    // Copy component 1 data
+    Entity entity1(mBodiesEntities[index1]);
+    RigidBody* body1 = mRigidBodies[index1];
+    bool isAllowedToSleep1 = mIsAllowedToSleep[index1];
+    bool isSleeping1 = mIsSleeping[index1];
+    decimal sleepTime1 = mSleepTimes[index1];
+
+    // Destroy component 1
+    destroyComponent(index1);
+
+    moveComponentToIndex(index2, index1);
+
+    // Reconstruct component 1 at component 2 location
+    new (mBodiesEntities + index2) Entity(entity1);
+    mRigidBodies[index2] = body1;
+    mIsAllowedToSleep[index2] = isAllowedToSleep1;
+    mIsSleeping[index2] = isSleeping1;
+    mSleepTimes[index2] = sleepTime1;
+
+    // Update the entity to component index mapping
+    mMapEntityToComponentIndex.add(Pair<Entity, uint32>(entity1, index2));
+
+    assert(mMapEntityToComponentIndex[mBodiesEntities[index1]] == index1);
+    assert(mMapEntityToComponentIndex[mBodiesEntities[index2]] == index2);
+    assert(mNbComponents == static_cast<uint32>(mMapEntityToComponentIndex.size()));
+}
+
+// Destroy a component at a given index
+void RigidBodyComponents::destroyComponent(uint32 index) {
+
+    Components::destroyComponent(index);
+
+    assert(mMapEntityToComponentIndex[mBodiesEntities[index]] == index);
+
+    mMapEntityToComponentIndex.remove(mBodiesEntities[index]);
+
+    mBodiesEntities[index].~Entity();
+    mRigidBodies[index] = nullptr;
+}

src/components/RigidBodyComponents.h

@@ -0,0 +1,187 @@
+/********************************************************************************
+* ReactPhysics3D physics library, http://www.reactphysics3d.com                 *
+* Copyright (c) 2010-2018 Daniel Chappuis                                       *
+*********************************************************************************
+*                                                                               *
+* 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.    *
+*                                                                               *
+********************************************************************************/
+
+#ifndef REACTPHYSICS3D_RIGID_BODY_COMPONENTS_H
+#define REACTPHYSICS3D_RIGID_BODY_COMPONENTS_H
+
+// Libraries
+#include "mathematics/Transform.h"
+#include "engine/Entity.h"
+#include "components/Components.h"
+#include "containers/Map.h"
+
+// ReactPhysics3D namespace
+namespace reactphysics3d {
+
+// Class declarations
+class MemoryAllocator;
+class EntityManager;
+class RigidBody;
+
+// Class RigidBodyComponents
+/**
+ * This class represent the component of the ECS that contains data about a rigid body.
+ * The components of the sleeping entities (bodies) are always stored at the end of the array.
+ */
+class RigidBodyComponents : public Components {
+
+    private:
+
+        // -------------------- Attributes -------------------- //
+
+        /// Array of body entities of each component
+        Entity* mBodiesEntities;
+
+        /// Array of pointers to the corresponding rigid bodies
+        RigidBody** mRigidBodies;
+
+        /// Array of boolean values to know if the body is allowed to go to sleep
+        bool* mIsAllowedToSleep;
+
+        /// Array of boolean values to know if the body is sleeping
+        bool* mIsSleeping;
+
+        /// Array with values for elapsed time since the body velocity was below the sleep velocity
+        decimal* mSleepTimes;
+
+        // -------------------- Methods -------------------- //
+
+        /// Allocate memory for a given number of components
+        virtual void allocate(uint32 nbComponentsToAllocate) override;
+
+        /// Destroy a component at a given index
+        virtual void destroyComponent(uint32 index) override;
+
+        /// Move a component from a source to a destination index in the components array
+        virtual void moveComponentToIndex(uint32 srcIndex, uint32 destIndex) override;
+
+        /// Swap two components in the array
+        virtual void swapComponents(uint32 index1, uint32 index2) override;
+
+    public:
+
+        /// Structure for the data of a rigid body component
+        struct RigidBodyComponent {
+
+            RigidBody* body;
+
+            /// Constructor
+            RigidBodyComponent(RigidBody* body) : body(body) {
+
+            }
+        };
+
+        // -------------------- Methods -------------------- //
+
+        /// Constructor
+        RigidBodyComponents(MemoryAllocator& allocator);
+
+        /// Destructor
+        virtual ~RigidBodyComponents() override = default;
+
+        /// Add a component
+        void addComponent(Entity bodyEntity, bool isSleeping, const RigidBodyComponent& component);
+
+        /// Return a pointer to a rigid body
+        RigidBody* getRigidBody(Entity bodyEntity);
+
+        /// Return true if the body is allowed to sleep
+        bool getIsAllowedToSleep(Entity bodyEntity) const;
+
+        /// Set the value to know if the body is allowed to sleep
+        void setIsAllowedToSleep(Entity bodyEntity, bool isAllowedToSleep) const;
+
+        /// Return true if the body is sleeping
+        bool getIsSleeping(Entity bodyEntity) const;
+
+        /// Set the value to know if the body is sleeping
+        void setIsSleeping(Entity bodyEntity, bool isSleeping) const;
+
+        /// Return the sleep time
+        decimal getSleepTime(Entity bodyEntity) const;
+
+        /// Set the sleep time
+        void setSleepTime(Entity bodyEntity, decimal sleepTime) const;
+};
+
+// Return a pointer to a body rigid
+inline RigidBody* RigidBodyComponents::getRigidBody(Entity bodyEntity) {
+
+    assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
+
+    return mRigidBodies[mMapEntityToComponentIndex[bodyEntity]];
+}
+
+// Return true if the body is allowed to sleep
+inline bool RigidBodyComponents::getIsAllowedToSleep(Entity bodyEntity) const {
+
+    assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
+
+    return mIsAllowedToSleep[mMapEntityToComponentIndex[bodyEntity]];
+}
+
+// Set the value to know if the body is allowed to sleep
+inline void RigidBodyComponents::setIsAllowedToSleep(Entity bodyEntity, bool isAllowedToSleep) const {
+
+    assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
+
+    mIsAllowedToSleep[mMapEntityToComponentIndex[bodyEntity]] = isAllowedToSleep;
+}
+
+// Return true if the body is sleeping
+inline bool RigidBodyComponents::getIsSleeping(Entity bodyEntity) const {
+
+    assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
+
+    return mIsSleeping[mMapEntityToComponentIndex[bodyEntity]];
+}
+
+// Set the value to know if the body is sleeping
+inline void RigidBodyComponents::setIsSleeping(Entity bodyEntity, bool isSleeping) const {
+
+    assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
+
+    mIsSleeping[mMapEntityToComponentIndex[bodyEntity]] = isSleeping;
+}
+
+// Return the sleep time
+inline decimal RigidBodyComponents::getSleepTime(Entity bodyEntity) const {
+
+    assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
+
+    return mSleepTimes[mMapEntityToComponentIndex[bodyEntity]];
+}
+
+// Set the sleep time
+inline void RigidBodyComponents::setSleepTime(Entity bodyEntity, decimal sleepTime) const {
+
+    assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
+
+    mSleepTimes[mMapEntityToComponentIndex[bodyEntity]] = sleepTime;
+}
+
+}
+
+#endif

src/engine/CollisionWorld.cpp

@@ -38,8 +38,9 @@ uint CollisionWorld::mNbWorlds = 0;
 // Constructor
 CollisionWorld::CollisionWorld(const WorldSettings& worldSettings, Logger* logger, Profiler* profiler)
                : mConfig(worldSettings), mEntityManager(mMemoryManager.getPoolAllocator()),
-                 mBodyComponents(mMemoryManager.getBaseAllocator()), mTransformComponents(mMemoryManager.getBaseAllocator()),
+                 mCollisionBodyComponents(mMemoryManager.getBaseAllocator()), mRigidBodyComponents(mMemoryManager.getBaseAllocator()),
-                 mProxyShapesComponents(mMemoryManager.getBaseAllocator()), mDynamicsComponents(mMemoryManager.getBaseAllocator()),
+                 mTransformComponents(mMemoryManager.getBaseAllocator()), mProxyShapesComponents(mMemoryManager.getBaseAllocator()),
+                 mDynamicsComponents(mMemoryManager.getBaseAllocator()),
                  mCollisionDetection(this, mProxyShapesComponents, mTransformComponents, mDynamicsComponents, mMemoryManager),
                  mBodies(mMemoryManager.getPoolAllocator()),  mEventListener(nullptr),
                  mName(worldSettings.worldName), mIsProfilerCreatedByUser(profiler != nullptr),
@@ -132,7 +133,7 @@ CollisionWorld::~CollisionWorld() {
 #endif
 
     assert(mBodies.size() == 0);
-    assert(mBodyComponents.getNbComponents() == 0);
+    assert(mCollisionBodyComponents.getNbComponents() == 0);
     assert(mTransformComponents.getNbComponents() == 0);
     assert(mProxyShapesComponents.getNbComponents() == 0);
 }
@@ -157,8 +158,8 @@ CollisionBody* CollisionWorld::createCollisionBody(const Transform& transform) {
     assert(collisionBody != nullptr);
 
     // Add the components
-    CollisionBodyComponents::BodyComponent bodyComponent(collisionBody);
+    CollisionBodyComponents::CollisionBodyComponent bodyComponent(collisionBody);
-    mBodyComponents.addComponent(entity, false, bodyComponent);
+    mCollisionBodyComponents.addComponent(entity, false, bodyComponent);
 
     // Add the collision body to the world
     mBodies.add(collisionBody);
@@ -192,7 +193,7 @@ void CollisionWorld::destroyCollisionBody(CollisionBody* collisionBody) {
     // Remove all the collision shapes of the body
     collisionBody->removeAllCollisionShapes();
 
-    mBodyComponents.removeComponent(collisionBody->getEntity());
+    mCollisionBodyComponents.removeComponent(collisionBody->getEntity());
     mTransformComponents.removeComponent(collisionBody->getEntity());
     mEntityManager.destroyEntity(collisionBody->getEntity());
 
@@ -209,12 +210,13 @@ void CollisionWorld::destroyCollisionBody(CollisionBody* collisionBody) {
 // Notify the world if a body is disabled (sleeping) or not
 void CollisionWorld::notifyBodyDisabled(Entity bodyEntity, bool isDisabled) {
 
-    if (isDisabled == mBodyComponents.getIsEntityDisabled(bodyEntity)) return;
+    if (isDisabled == mCollisionBodyComponents.getIsEntityDisabled(bodyEntity)) return;
 
     // TODO : Make sure we notify all the components here ...
 
     // Notify all the components
-    mBodyComponents.setIsEntityDisabled(bodyEntity, isDisabled);
+    mCollisionBodyComponents.setIsEntityDisabled(bodyEntity, isDisabled);
+    mRigidBodyComponents.setIsEntityDisabled(bodyEntity, isDisabled);
     mTransformComponents.setIsEntityDisabled(bodyEntity, isDisabled);
 
     if (mDynamicsComponents.hasComponent(bodyEntity)) {
@@ -222,7 +224,7 @@ void CollisionWorld::notifyBodyDisabled(Entity bodyEntity, bool isDisabled) {
     }
 
     // For each proxy-shape of the body
-    const List<Entity>& proxyShapesEntities = mBodyComponents.getProxyShapes(bodyEntity);
+    const List<Entity>& proxyShapesEntities = mCollisionBodyComponents.getProxyShapes(bodyEntity);
     for (uint i=0; i < proxyShapesEntities.size(); i++) {
 
         mProxyShapesComponents.setIsEntityDisabled(proxyShapesEntities[i], isDisabled);

src/engine/CollisionWorld.h

@@ -34,6 +34,7 @@
 #include "memory/MemoryManager.h"
 #include "engine/EntityManager.h"
 #include "components/CollisionBodyComponents.h"
+#include "components/RigidBodyComponents.h"
 #include "components/TransformComponents.h"
 #include "components/ProxyShapeComponents.h"
 #include "components/DynamicsComponents.h"
@@ -76,8 +77,11 @@ class CollisionWorld {
         /// Entity Manager for the ECS
         EntityManager mEntityManager;
 
-        /// Body Components
+        /// Collision Body Components
-        CollisionBodyComponents mBodyComponents;
+        CollisionBodyComponents mCollisionBodyComponents;
+
+        /// Rigid Body Components
+        RigidBodyComponents mRigidBodyComponents;
 
         /// Transform Components
         TransformComponents mTransformComponents;

src/engine/DynamicsWorld.cpp

@@ -50,7 +50,7 @@ using namespace std;
 DynamicsWorld::DynamicsWorld(const Vector3& gravity, const WorldSettings& worldSettings, Logger* logger, Profiler* profiler)
               : CollisionWorld(worldSettings, logger, profiler),
                 mIslands(mMemoryManager.getSingleFrameAllocator()),
-                mContactSolver(mMemoryManager, mIslands, mBodyComponents, mDynamicsComponents, mProxyShapesComponents, mConfig),
+                mContactSolver(mMemoryManager, mIslands, mCollisionBodyComponents, mDynamicsComponents, mProxyShapesComponents, mConfig),
                 mConstraintSolver(mIslands, mDynamicsComponents),
                 mNbVelocitySolverIterations(mConfig.defaultVelocitySolverNbIterations),
                 mNbPositionSolverIterations(mConfig.defaultPositionSolverNbIterations), 
@@ -384,8 +384,11 @@ RigidBody* DynamicsWorld::createRigidBody(const Transform& transform) {
                                      sizeof(RigidBody))) RigidBody(transform, *this, entity);
     assert(rigidBody != nullptr);
 
-    CollisionBodyComponents::BodyComponent bodyComponent(rigidBody);
+    CollisionBodyComponents::CollisionBodyComponent bodyComponent(rigidBody);
-    mBodyComponents.addComponent(entity, false, bodyComponent);
+    mCollisionBodyComponents.addComponent(entity, false, bodyComponent);
+
+    RigidBodyComponents::RigidBodyComponent rigidBodyComponent(rigidBody);
+    mRigidBodyComponents.addComponent(entity, false, rigidBodyComponent);
 
     // Add the rigid body to the physics world
     mBodies.add(rigidBody);
@@ -425,7 +428,8 @@ void DynamicsWorld::destroyRigidBody(RigidBody* rigidBody) {
     }
 
     // Destroy the corresponding entity and its components
-    mBodyComponents.removeComponent(rigidBody->getEntity());
+    mCollisionBodyComponents.removeComponent(rigidBody->getEntity());
+    mRigidBodyComponents.removeComponent(rigidBody->getEntity());
     mTransformComponents.removeComponent(rigidBody->getEntity());
     mEntityManager.destroyEntity(rigidBody->getEntity());
 
@@ -678,7 +682,7 @@ void DynamicsWorld::createIslands() {
             mIslands.bodyEntities[islandIndex].add(bodyToVisitEntity);
 
             // TODO : Do not use pointer to rigid body here (maybe move getType() into a component)
-            RigidBody* rigidBodyToVisit = static_cast<RigidBody*>(mBodyComponents.getBody(bodyToVisitEntity));
+            RigidBody* rigidBodyToVisit = static_cast<RigidBody*>(mCollisionBodyComponents.getBody(bodyToVisitEntity));
 
             // Awake the body if it is sleeping
             rigidBodyToVisit->setIsSleeping(false);
@@ -703,8 +707,8 @@ void DynamicsWorld::createIslands() {
 
                     // Get the other body of the contact manifold
                     // TODO : Maybe avoid those casts here
-                    RigidBody* body1 = dynamic_cast<RigidBody*>(mBodyComponents.getBody(pair.body1Entity));
+                    RigidBody* body1 = dynamic_cast<RigidBody*>(mCollisionBodyComponents.getBody(pair.body1Entity));
-                    RigidBody* body2 = dynamic_cast<RigidBody*>(mBodyComponents.getBody(pair.body2Entity));
+                    RigidBody* body2 = dynamic_cast<RigidBody*>(mCollisionBodyComponents.getBody(pair.body2Entity));
 
                     // If the colliding body is a RigidBody (and not a CollisionBody instead)
                     if (body1 != nullptr && body2 != nullptr) {
@@ -801,8 +805,7 @@ void DynamicsWorld::updateSleepingBodies() {
 
             const Entity bodyEntity = mIslands.bodyEntities[i][b];
 
-            // TODO : We should use a RigidBody* type here
+            RigidBody* body = mRigidBodyComponents.getRigidBody(bodyEntity);
-            CollisionBody* body = mBodyComponents.getBody(bodyEntity);
 
             // Skip static bodies
             if (mDynamicsComponents.getBodyType(body->getEntity()) == BodyType::STATIC) continue;
@@ -810,18 +813,18 @@ void DynamicsWorld::updateSleepingBodies() {
             // If the body is velocity is large enough to stay awake
             if (mDynamicsComponents.getLinearVelocity(bodyEntity).lengthSquare() > sleepLinearVelocitySquare ||
                 mDynamicsComponents.getAngularVelocity(bodyEntity).lengthSquare() > sleepAngularVelocitySquare ||
-                !mBodyComponents.getIsAllowedToSleep(body->getEntity())) {
+                !mRigidBodyComponents.getIsAllowedToSleep(body->getEntity())) {
 
                 // Reset the sleep time of the body
-                mBodyComponents.setSleepTime(body->getEntity(), decimal(0.0));
+                mRigidBodyComponents.setSleepTime(body->getEntity(), decimal(0.0));
                 minSleepTime = decimal(0.0);
             }
             else {  // If the body velocity is below the sleeping velocity threshold
 
                 // Increase the sleep time
-                decimal sleepTime = mBodyComponents.getSleepTime(body->getEntity());
+                decimal sleepTime = mRigidBodyComponents.getSleepTime(body->getEntity());
-                mBodyComponents.setSleepTime(body->getEntity(), sleepTime + mTimeStep);
+                mRigidBodyComponents.setSleepTime(body->getEntity(), sleepTime + mTimeStep);
-                sleepTime = mBodyComponents.getSleepTime(body->getEntity());
+                sleepTime = mRigidBodyComponents.getSleepTime(body->getEntity());
                 if (sleepTime < minSleepTime) {
                     minSleepTime = sleepTime;
                 }
@@ -838,7 +841,7 @@ void DynamicsWorld::updateSleepingBodies() {
 
                 // TODO : We should use a RigidBody* type here (remove the cast)
                 const Entity bodyEntity = mIslands.bodyEntities[i][b];
-                RigidBody* body = static_cast<RigidBody*>(mBodyComponents.getBody(bodyEntity));
+                RigidBody* body = static_cast<RigidBody*>(mCollisionBodyComponents.getBody(bodyEntity));
                 body->setIsSleeping(true);
             }
         }

testbed/common/Box.cpp

@@ -160,12 +160,10 @@ void Box::render(openglframework::Shader& shader, const openglframework::Matrix4
     shader.setMatrix3x3Uniform("normalMatrix", normalMatrix, false);
 
     // Set the vertex color
-    rp3d::RigidBody* rigidBody = static_cast<rp3d::RigidBody*>(mBody);
+    rp3d::RigidBody* rigidBody = dynamic_cast<rp3d::RigidBody*>(mBody);
-    if (rigidBody != nullptr) {
+    openglframework::Color currentColor = rigidBody != nullptr && rigidBody->isSleeping() ? mSleepingColor : mColor;
-        openglframework::Color currentColor = rigidBody->isSleeping() ? mSleepingColor : mColor;
     openglframework::Vector4 color(currentColor.r, currentColor.g, currentColor.b, currentColor.a);
     shader.setVector4Uniform("vertexColor", color, false);
-    }
 
     // Bind the VAO
     mVAO.bind();

testbed/common/Capsule.cpp

@@ -141,12 +141,10 @@ void Capsule::render(openglframework::Shader& shader,
     shader.setMatrix3x3Uniform("normalMatrix", normalMatrix, false);
 
     // Set the vertex color
-    rp3d::RigidBody* rigidBody = static_cast<rp3d::RigidBody*>(mBody);
+    rp3d::RigidBody* rigidBody = dynamic_cast<rp3d::RigidBody*>(mBody);
-    if (rigidBody != nullptr) {
+    openglframework::Color currentColor = rigidBody != nullptr && rigidBody->isSleeping() ? mSleepingColor : mColor;
-        openglframework::Color currentColor = rigidBody->isSleeping() ? mSleepingColor : mColor;
     openglframework::Vector4 color(currentColor.r, currentColor.g, currentColor.b, currentColor.a);
     shader.setVector4Uniform("vertexColor", color, false);
-    }
 
     // Bind the VAO
     mVAO.bind();

testbed/common/ConcaveMesh.cpp

@@ -150,12 +150,10 @@ void ConcaveMesh::render(openglframework::Shader& shader,
     shader.setMatrix3x3Uniform("normalMatrix", normalMatrix, false);
 
     // Set the vertex color
-    rp3d::RigidBody* rigidBody = static_cast<rp3d::RigidBody*>(mBody);
+    rp3d::RigidBody* rigidBody = dynamic_cast<rp3d::RigidBody*>(mBody);
-    if (rigidBody != nullptr) {
+    openglframework::Color currentColor = rigidBody != nullptr && rigidBody->isSleeping() ? mSleepingColor : mColor;
-        openglframework::Color currentColor = rigidBody->isSleeping() ? mSleepingColor : mColor;
     openglframework::Vector4 color(currentColor.r, currentColor.g, currentColor.b, currentColor.a);
     shader.setVector4Uniform("vertexColor", color, false);
-    }
 
     // Bind the VAO
     mVAO.bind();

testbed/common/ConvexMesh.cpp

@@ -160,12 +160,10 @@ void ConvexMesh::render(openglframework::Shader& shader,
     shader.setMatrix3x3Uniform("normalMatrix", normalMatrix, false);
 
     // Set the vertex color
-    rp3d::RigidBody* rigidBody = static_cast<rp3d::RigidBody*>(mBody);
+    rp3d::RigidBody* rigidBody = dynamic_cast<rp3d::RigidBody*>(mBody);
-    if (rigidBody != nullptr) {
+    openglframework::Color currentColor = rigidBody != nullptr && rigidBody->isSleeping() ? mSleepingColor : mColor;
-        openglframework::Color currentColor = rigidBody->isSleeping() ? mSleepingColor : mColor;
     openglframework::Vector4 color(currentColor.r, currentColor.g, currentColor.b, currentColor.a);
     shader.setVector4Uniform("vertexColor", color, false);
-    }
 
     // Bind the VAO
     mVAO.bind();

testbed/common/Dumbbell.cpp

@@ -178,12 +178,10 @@ void Dumbbell::render(openglframework::Shader& shader,
     shader.setMatrix3x3Uniform("normalMatrix", normalMatrix, false);
 
     // Set the vertex color
-    rp3d::RigidBody* rigidBody = static_cast<rp3d::RigidBody*>(mBody);
+    rp3d::RigidBody* rigidBody = dynamic_cast<rp3d::RigidBody*>(mBody);
-    if (rigidBody != nullptr) {
+    openglframework::Color currentColor = rigidBody != nullptr && rigidBody->isSleeping() ? mSleepingColor : mColor;
-        openglframework::Color currentColor = rigidBody->isSleeping() ? mSleepingColor : mColor;
     openglframework::Vector4 color(currentColor.r, currentColor.g, currentColor.b, currentColor.a);
     shader.setVector4Uniform("vertexColor", color, false);
-    }
 
     // Bind the VAO
     mVAO.bind();

testbed/common/HeightField.cpp

@@ -132,12 +132,10 @@ void HeightField::render(openglframework::Shader& shader,
     shader.setMatrix3x3Uniform("normalMatrix", normalMatrix, false);
 
     // Set the vertex color
-    rp3d::RigidBody* rigidBody = static_cast<rp3d::RigidBody*>(mBody);
+    rp3d::RigidBody* rigidBody = dynamic_cast<rp3d::RigidBody*>(mBody);
-    if (rigidBody != nullptr) {
+    openglframework::Color currentColor = rigidBody != nullptr && rigidBody->isSleeping() ? mSleepingColor : mColor;
-        openglframework::Color currentColor = rigidBody->isSleeping() ? mSleepingColor : mColor;
     openglframework::Vector4 color(currentColor.r, currentColor.g, currentColor.b, currentColor.a);
     shader.setVector4Uniform("vertexColor", color, false);
-    }
 
     // Bind the VAO
     mVAO.bind();

testbed/common/Sphere.cpp

@@ -140,12 +140,10 @@ void Sphere::render(openglframework::Shader& shader, const openglframework::Matr
     shader.setMatrix3x3Uniform("normalMatrix", normalMatrix, false);
 
     // Set the vertex color
-    rp3d::RigidBody* rigidBody = static_cast<rp3d::RigidBody*>(mBody);
+    rp3d::RigidBody* rigidBody = dynamic_cast<rp3d::RigidBody*>(mBody);
-    if (rigidBody != nullptr) {
+    openglframework::Color currentColor = rigidBody != nullptr && rigidBody->isSleeping() ? mSleepingColor : mColor;
-        openglframework::Color currentColor = rigidBody->isSleeping() ? mSleepingColor : mColor;
     openglframework::Vector4 color(currentColor.r, currentColor.g, currentColor.b, currentColor.a);
     shader.setVector4Uniform("vertexColor", color, false);
-    }
 
     // Bind the VAO
     mVAO.bind();