diff --git a/src/body/RigidBody.cpp b/src/body/RigidBody.cpp
index 247d64cd..b0fba2e1 100644
--- a/src/body/RigidBody.cpp
+++ b/src/body/RigidBody.cpp
@@ -57,7 +57,7 @@ RigidBody::~RigidBody() {
// Return the type of the body
BodyType RigidBody::getType() const {
- return mWorld.mDynamicsComponents.getBodyType(mEntity);
+ return mWorld.mRigidBodyComponents.getBodyType(mEntity);
}
// Set the type of the body
@@ -75,9 +75,9 @@ BodyType RigidBody::getType() const {
*/
void RigidBody::setType(BodyType type) {
- if (mWorld.mDynamicsComponents.getBodyType(mEntity) == type) return;
+ if (mWorld.mRigidBodyComponents.getBodyType(mEntity) == type) return;
- mWorld.mDynamicsComponents.setBodyType(mEntity, type);
+ mWorld.mRigidBodyComponents.setBodyType(mEntity, type);
// Recompute the total mass, center of mass and inertia tensor
recomputeMassInformation();
@@ -168,7 +168,7 @@ decimal RigidBody::getMass() const {
void RigidBody::applyForce(const Vector3& force, const Vector3& point) {
// If it is not a dynamic body, we do nothing
- if (mWorld.mDynamicsComponents.getBodyType(mEntity) != BodyType::DYNAMIC) return;
+ if (mWorld.mRigidBodyComponents.getBodyType(mEntity) != BodyType::DYNAMIC) return;
// Awake the body if it was sleeping
if (mWorld.mRigidBodyComponents.getIsSleeping(mEntity)) {
@@ -197,7 +197,7 @@ void RigidBody::setInertiaTensorLocal(const Matrix3x3& inertiaTensorLocal) {
mUserInertiaTensorLocalInverse = inertiaTensorLocal.getInverse();
mIsInertiaTensorSetByUser = true;
- if (mWorld.mDynamicsComponents.getBodyType(mEntity) != BodyType::DYNAMIC) return;
+ if (mWorld.mRigidBodyComponents.getBodyType(mEntity) != BodyType::DYNAMIC) return;
// Compute the inverse local inertia tensor
mWorld.mDynamicsComponents.setInverseInertiaTensorLocal(mEntity, mUserInertiaTensorLocalInverse);
@@ -220,7 +220,7 @@ void RigidBody::setInertiaTensorLocal(const Matrix3x3& inertiaTensorLocal) {
void RigidBody::applyForceToCenterOfMass(const Vector3& force) {
// If it is not a dynamic body, we do nothing
- if (mWorld.mDynamicsComponents.getBodyType(mEntity) != BodyType::DYNAMIC) return;
+ if (mWorld.mRigidBodyComponents.getBodyType(mEntity) != BodyType::DYNAMIC) return;
// Awake the body if it was sleeping
if (mWorld.mRigidBodyComponents.getIsSleeping(mEntity)) {
@@ -260,7 +260,7 @@ void RigidBody::setInverseInertiaTensorLocal(const Matrix3x3& inverseInertiaTens
mUserInertiaTensorLocalInverse = inverseInertiaTensorLocal;
mIsInertiaTensorSetByUser = true;
- if (mWorld.mDynamicsComponents.getBodyType(mEntity) != BodyType::DYNAMIC) return;
+ if (mWorld.mRigidBodyComponents.getBodyType(mEntity) != BodyType::DYNAMIC) return;
// Compute the inverse local inertia tensor
mWorld.mDynamicsComponents.setInverseInertiaTensorLocal(mEntity, mUserInertiaTensorLocalInverse);
@@ -283,7 +283,7 @@ void RigidBody::setCenterOfMassLocal(const Vector3& centerOfMassLocal) {
// TODO : Check if we need to update the postion of the body here at the end (transform of the body)
- if (mWorld.mDynamicsComponents.getBodyType(mEntity) != BodyType::DYNAMIC) return;
+ if (mWorld.mRigidBodyComponents.getBodyType(mEntity) != BodyType::DYNAMIC) return;
mIsCenterOfMassSetByUser = true;
@@ -311,7 +311,7 @@ void RigidBody::setCenterOfMassLocal(const Vector3& centerOfMassLocal) {
*/
void RigidBody::setMass(decimal mass) {
- if (mWorld.mDynamicsComponents.getBodyType(mEntity) != BodyType::DYNAMIC) return;
+ if (mWorld.mRigidBodyComponents.getBodyType(mEntity) != BodyType::DYNAMIC) return;
mWorld.mDynamicsComponents.setInitMass(mEntity, mass);
@@ -533,7 +533,7 @@ void RigidBody::setMaterial(const Material& material) {
void RigidBody::setLinearVelocity(const Vector3& linearVelocity) {
// If it is a static body, we do nothing
- if (mWorld.mDynamicsComponents.getBodyType(mEntity) == BodyType::STATIC) return;
+ if (mWorld.mRigidBodyComponents.getBodyType(mEntity) == BodyType::STATIC) return;
// Update the linear velocity of the current body state
mWorld.mDynamicsComponents.setLinearVelocity(mEntity, linearVelocity);
@@ -556,7 +556,7 @@ void RigidBody::setAngularVelocity(const Vector3& angularVelocity) {
// TODO : Make sure this method is not called from the internal physics engine
// If it is a static body, we do nothing
- if (mWorld.mDynamicsComponents.getBodyType(mEntity) == BodyType::STATIC) return;
+ if (mWorld.mRigidBodyComponents.getBodyType(mEntity) == BodyType::STATIC) return;
// Set the angular velocity
mWorld.mDynamicsComponents.setAngularVelocity(mEntity, angularVelocity);
@@ -617,13 +617,13 @@ void RigidBody::recomputeMassInformation() {
const Transform& transform = mWorld.mTransformComponents.getTransform(mEntity);
// If it is a STATIC or a KINEMATIC body
- BodyType type = mWorld.mDynamicsComponents.getBodyType(mEntity);
+ BodyType type = mWorld.mRigidBodyComponents.getBodyType(mEntity);
if (type == BodyType::STATIC || type == BodyType::KINEMATIC) {
mWorld.mDynamicsComponents.setCenterOfMassWorld(mEntity, transform.getPosition());
return;
}
- assert(mWorld.mDynamicsComponents.getBodyType(mEntity) == BodyType::DYNAMIC);
+ assert(mWorld.mRigidBodyComponents.getBodyType(mEntity) == BodyType::DYNAMIC);
// Compute the total mass of the body
const List<Entity>& proxyShapesEntities = mWorld.mCollisionBodyComponents.getProxyShapes(mEntity);
@@ -736,7 +736,7 @@ bool RigidBody::isGravityEnabled() const {
void RigidBody::applyTorque(const Vector3& torque) {
// If it is not a dynamic body, we do nothing
- if (mWorld.mDynamicsComponents.getBodyType(mEntity) != BodyType::DYNAMIC) return;
+ if (mWorld.mRigidBodyComponents.getBodyType(mEntity) != BodyType::DYNAMIC) return;
// Awake the body if it was sleeping
if (mWorld.mRigidBodyComponents.getIsSleeping(mEntity)) {
diff --git a/src/collision/CollisionDetection.cpp b/src/collision/CollisionDetection.cpp
index f4cbf475..490562ce 100644
--- a/src/collision/CollisionDetection.cpp
+++ b/src/collision/CollisionDetection.cpp
@@ -237,10 +237,10 @@ void CollisionDetection::computeMiddlePhase(OverlappingPairMap& overlappingPairs
const Entity body1Entity = body1->getEntity();
const Entity body2Entity = body2->getEntity();
- const bool isStaticRigidBody1 = mWorld->mDynamicsComponents.hasComponent(body1Entity) &&
- mWorld->mDynamicsComponents.getBodyType(body1Entity) == BodyType::STATIC;
- const bool isStaticRigidBody2 = mWorld->mDynamicsComponents.hasComponent(body2Entity) &&
- mWorld->mDynamicsComponents.getBodyType(body2Entity) == BodyType::STATIC;
+ const bool isStaticRigidBody1 = mWorld->mRigidBodyComponents.hasComponent(body1Entity) &&
+ mWorld->mRigidBodyComponents.getBodyType(body1Entity) == BodyType::STATIC;
+ const bool isStaticRigidBody2 = mWorld->mRigidBodyComponents.hasComponent(body2Entity) &&
+ mWorld->mRigidBodyComponents.getBodyType(body2Entity) == BodyType::STATIC;
// Check that at least one body is enabled (active and awake) and not static
bool isBody1Active = !mWorld->mCollisionBodyComponents.getIsEntityDisabled(body1Entity) && !isStaticRigidBody1;
diff --git a/src/components/DynamicsComponents.cpp b/src/components/DynamicsComponents.cpp
index 3af49c75..a0705531 100644
--- a/src/components/DynamicsComponents.cpp
+++ b/src/components/DynamicsComponents.cpp
@@ -39,7 +39,7 @@ DynamicsComponents::DynamicsComponents(MemoryAllocator& allocator)
sizeof(Vector3) + sizeof(Vector3) + sizeof(Vector3) + sizeof(Vector3) + sizeof(decimal) +
sizeof(decimal) + sizeof(decimal) + sizeof(decimal) + sizeof(Matrix3x3) + sizeof(Matrix3x3) +
sizeof(Vector3) + sizeof(Quaternion) + sizeof(Vector3) + sizeof(Vector3) + sizeof(bool) +
- sizeof(bool) + sizeof(BodyType)) {
+ sizeof(bool)) {
// Allocate memory for the components data
allocate(INIT_NB_ALLOCATED_COMPONENTS);
@@ -79,7 +79,6 @@ void DynamicsComponents::allocate(uint32 nbComponentsToAllocate) {
Vector3* newCentersOfMassWorld = reinterpret_cast<Vector3*>(newCentersOfMassLocal + nbComponentsToAllocate);
bool* newIsGravityEnabled = reinterpret_cast<bool*>(newCentersOfMassWorld + nbComponentsToAllocate);
bool* newIsAlreadyInIsland = reinterpret_cast<bool*>(newIsGravityEnabled + nbComponentsToAllocate);
- BodyType* newBodyTypes = reinterpret_cast<BodyType*>(newIsAlreadyInIsland + nbComponentsToAllocate);
// If there was already components before
if (mNbComponents > 0) {
@@ -106,7 +105,6 @@ void DynamicsComponents::allocate(uint32 nbComponentsToAllocate) {
memcpy(newCentersOfMassWorld, mCentersOfMassWorld, mNbComponents * sizeof(Vector3));
memcpy(newIsGravityEnabled, mIsGravityEnabled, mNbComponents * sizeof(bool));
memcpy(newIsAlreadyInIsland, mIsAlreadyInIsland, mNbComponents * sizeof(bool));
- memcpy(newBodyTypes, mBodyTypes, mNbComponents * sizeof(BodyType));
// Deallocate previous memory
mMemoryAllocator.release(mBuffer, mNbAllocatedComponents * mComponentDataSize);
@@ -134,7 +132,6 @@ void DynamicsComponents::allocate(uint32 nbComponentsToAllocate) {
mCentersOfMassWorld = newCentersOfMassWorld;
mIsGravityEnabled = newIsGravityEnabled;
mIsAlreadyInIsland = newIsAlreadyInIsland;
- mBodyTypes = newBodyTypes;
mNbAllocatedComponents = nbComponentsToAllocate;
}
@@ -167,7 +164,6 @@ void DynamicsComponents::addComponent(Entity bodyEntity, bool isSleeping, const
new (mCentersOfMassWorld + index) Vector3(component.worldPosition);
mIsGravityEnabled[index] = true;
mIsAlreadyInIsland[index] = false;
- mBodyTypes[index] = component.bodyType;
// Map the entity with the new component lookup index
mMapEntityToComponentIndex.add(Pair<Entity, uint32>(bodyEntity, index));
@@ -206,7 +202,6 @@ void DynamicsComponents::moveComponentToIndex(uint32 srcIndex, uint32 destIndex)
new (mCentersOfMassWorld + destIndex) Vector3(mCentersOfMassWorld[srcIndex]);
mIsGravityEnabled[destIndex] = mIsGravityEnabled[srcIndex];
mIsAlreadyInIsland[destIndex] = mIsAlreadyInIsland[srcIndex];
- mBodyTypes[destIndex] = mBodyTypes[srcIndex];
// Destroy the source component
destroyComponent(srcIndex);
@@ -247,7 +242,6 @@ void DynamicsComponents::swapComponents(uint32 index1, uint32 index2) {
Vector3 centerOfMassWorld1 = mCentersOfMassWorld[index1];
bool isGravityEnabled1 = mIsGravityEnabled[index1];
bool isAlreadyInIsland1 = mIsAlreadyInIsland[index1];
- BodyType bodyType1 = mBodyTypes[index1];
// Destroy component 1
destroyComponent(index1);
@@ -276,7 +270,6 @@ void DynamicsComponents::swapComponents(uint32 index1, uint32 index2) {
mCentersOfMassWorld[index2] = centerOfMassWorld1;
mIsGravityEnabled[index2] = isGravityEnabled1;
mIsAlreadyInIsland[index2] = isAlreadyInIsland1;
- mBodyTypes[index2] = bodyType1;
// Update the entity to component index mapping
mMapEntityToComponentIndex.add(Pair<Entity, uint32>(entity1, index2));
diff --git a/src/components/DynamicsComponents.h b/src/components/DynamicsComponents.h
index cf6f37a0..f19df426 100644
--- a/src/components/DynamicsComponents.h
+++ b/src/components/DynamicsComponents.h
@@ -126,9 +126,6 @@ class DynamicsComponents : public Components {
/// Array with the boolean value to know if the body has already been added into an island
bool* mIsAlreadyInIsland;
- /// Array with the type of bodies (static, kinematic or dynamic)
- BodyType* mBodyTypes;
-
// -------------------- Methods -------------------- //
/// Allocate memory for a given number of components
@@ -150,11 +147,9 @@ class DynamicsComponents : public Components {
const Vector3& worldPosition;
- BodyType bodyType;
-
/// Constructor
- DynamicsComponent(const Vector3& worldPosition, BodyType bodyType)
- : worldPosition(worldPosition), bodyType(bodyType) {
+ DynamicsComponent(const Vector3& worldPosition)
+ : worldPosition(worldPosition) {
}
};
@@ -290,12 +285,6 @@ class DynamicsComponents : public Components {
/// Set the value to know if the entity is already in an island
void setIsAlreadyInIsland(Entity bodyEntity, bool isAlreadyInIsland);
- /// Return the body type of a body
- BodyType getBodyType(Entity bodyEntity);
-
- /// Set the body type of a body
- void setBodyType(Entity bodyEntity, BodyType bodyType);
-
// -------------------- Friendship -------------------- //
friend class BroadPhaseSystem;
@@ -619,7 +608,7 @@ inline void DynamicsComponents::setIsGravityEnabled(Entity bodyEntity, bool isGr
mIsGravityEnabled[mMapEntityToComponentIndex[bodyEntity]] = isGravityEnabled;
}
-/// Set the value to know if the entity is already in an island
+// Set the value to know if the entity is already in an island
inline void DynamicsComponents::setIsAlreadyInIsland(Entity bodyEntity, bool isAlreadyInIsland) {
assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
@@ -627,22 +616,6 @@ inline void DynamicsComponents::setIsAlreadyInIsland(Entity bodyEntity, bool isA
mIsAlreadyInIsland[mMapEntityToComponentIndex[bodyEntity]] = isAlreadyInIsland;
}
-// Return the body type of a body
-inline BodyType DynamicsComponents::getBodyType(Entity bodyEntity) {
-
- assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
-
- return mBodyTypes[mMapEntityToComponentIndex[bodyEntity]];
-}
-
-// Set the body type of a body
-inline void DynamicsComponents::setBodyType(Entity bodyEntity, BodyType bodyType) {
-
- assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
-
- mBodyTypes[mMapEntityToComponentIndex[bodyEntity]] = bodyType;
-}
-
}
#endif
diff --git a/src/components/RigidBodyComponents.cpp b/src/components/RigidBodyComponents.cpp
index ac4d2346..b71b3ba2 100644
--- a/src/components/RigidBodyComponents.cpp
+++ b/src/components/RigidBodyComponents.cpp
@@ -26,6 +26,7 @@
// Libraries
#include "RigidBodyComponents.h"
#include "engine/EntityManager.h"
+#include "body/RigidBody.h"
#include <cassert>
#include <random>
@@ -35,7 +36,7 @@ using namespace reactphysics3d;
// Constructor
RigidBodyComponents::RigidBodyComponents(MemoryAllocator& allocator)
:Components(allocator, sizeof(Entity) + sizeof(RigidBody*) +
- sizeof(bool) + sizeof(bool) + sizeof(decimal) ) {
+ sizeof(bool) + sizeof(bool) + sizeof(decimal) + sizeof(BodyType)) {
// Allocate memory for the components data
allocate(INIT_NB_ALLOCATED_COMPONENTS);
@@ -59,6 +60,7 @@ void RigidBodyComponents::allocate(uint32 nbComponentsToAllocate) {
bool* newIsAllowedToSleep = reinterpret_cast<bool*>(newBodies + nbComponentsToAllocate);
bool* newIsSleeping = reinterpret_cast<bool*>(newIsAllowedToSleep + nbComponentsToAllocate);
decimal* newSleepTimes = reinterpret_cast<decimal*>(newIsSleeping + nbComponentsToAllocate);
+ BodyType* newBodyTypes = reinterpret_cast<BodyType*>(newSleepTimes + nbComponentsToAllocate);
// If there was already components before
if (mNbComponents > 0) {
@@ -69,6 +71,7 @@ void RigidBodyComponents::allocate(uint32 nbComponentsToAllocate) {
memcpy(newIsAllowedToSleep, mIsAllowedToSleep, mNbComponents * sizeof(bool));
memcpy(newIsSleeping, mIsSleeping, mNbComponents * sizeof(bool));
memcpy(newSleepTimes, mSleepTimes, mNbComponents * sizeof(bool));
+ memcpy(newBodyTypes, mBodyTypes, mNbComponents * sizeof(BodyType));
// Deallocate previous memory
mMemoryAllocator.release(mBuffer, mNbAllocatedComponents * mComponentDataSize);
@@ -81,6 +84,7 @@ void RigidBodyComponents::allocate(uint32 nbComponentsToAllocate) {
mIsSleeping = newIsSleeping;
mSleepTimes = newSleepTimes;
mNbAllocatedComponents = nbComponentsToAllocate;
+ mBodyTypes = newBodyTypes;
}
// Add a component
@@ -95,6 +99,7 @@ void RigidBodyComponents::addComponent(Entity bodyEntity, bool isSleeping, const
mIsAllowedToSleep[index] = true;
mIsSleeping[index] = false;
mSleepTimes[index] = decimal(0);
+ mBodyTypes[index] = component.bodyType;
// Map the entity with the new component lookup index
mMapEntityToComponentIndex.add(Pair<Entity, uint32>(bodyEntity, index));
@@ -117,6 +122,7 @@ void RigidBodyComponents::moveComponentToIndex(uint32 srcIndex, uint32 destIndex
mIsAllowedToSleep[destIndex] = mIsAllowedToSleep[srcIndex];
mIsSleeping[destIndex] = mIsSleeping[srcIndex];
mSleepTimes[destIndex] = mSleepTimes[srcIndex];
+ mBodyTypes[destIndex] = mBodyTypes[srcIndex];
// Destroy the source component
destroyComponent(srcIndex);
@@ -138,6 +144,7 @@ void RigidBodyComponents::swapComponents(uint32 index1, uint32 index2) {
bool isAllowedToSleep1 = mIsAllowedToSleep[index1];
bool isSleeping1 = mIsSleeping[index1];
decimal sleepTime1 = mSleepTimes[index1];
+ BodyType bodyType1 = mBodyTypes[index1];
// Destroy component 1
destroyComponent(index1);
@@ -150,6 +157,7 @@ void RigidBodyComponents::swapComponents(uint32 index1, uint32 index2) {
mIsAllowedToSleep[index2] = isAllowedToSleep1;
mIsSleeping[index2] = isSleeping1;
mSleepTimes[index2] = sleepTime1;
+ mBodyTypes[index2] = bodyType1;
// Update the entity to component index mapping
mMapEntityToComponentIndex.add(Pair<Entity, uint32>(entity1, index2));
diff --git a/src/components/RigidBodyComponents.h b/src/components/RigidBodyComponents.h
index 02cdf6e5..df4641f2 100644
--- a/src/components/RigidBodyComponents.h
+++ b/src/components/RigidBodyComponents.h
@@ -39,6 +39,7 @@ namespace reactphysics3d {
class MemoryAllocator;
class EntityManager;
class RigidBody;
+enum class BodyType;
// Class RigidBodyComponents
/**
@@ -66,6 +67,9 @@ class RigidBodyComponents : public Components {
/// Array with values for elapsed time since the body velocity was below the sleep velocity
decimal* mSleepTimes;
+ /// Array with the type of bodies (static, kinematic or dynamic)
+ BodyType* mBodyTypes;
+
// -------------------- Methods -------------------- //
/// Allocate memory for a given number of components
@@ -86,9 +90,10 @@ class RigidBodyComponents : public Components {
struct RigidBodyComponent {
RigidBody* body;
+ BodyType bodyType;
/// Constructor
- RigidBodyComponent(RigidBody* body) : body(body) {
+ RigidBodyComponent(RigidBody* body, BodyType bodyType) : body(body), bodyType(bodyType) {
}
};
@@ -124,6 +129,13 @@ class RigidBodyComponents : public Components {
/// Set the sleep time
void setSleepTime(Entity bodyEntity, decimal sleepTime) const;
+
+ /// Return the body type of a body
+ BodyType getBodyType(Entity bodyEntity);
+
+ /// Set the body type of a body
+ void setBodyType(Entity bodyEntity, BodyType bodyType);
+
};
// Return a pointer to a body rigid
@@ -182,6 +194,23 @@ inline void RigidBodyComponents::setSleepTime(Entity bodyEntity, decimal sleepTi
mSleepTimes[mMapEntityToComponentIndex[bodyEntity]] = sleepTime;
}
+// Return the body type of a body
+inline BodyType RigidBodyComponents::getBodyType(Entity bodyEntity) {
+
+ assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
+
+ return mBodyTypes[mMapEntityToComponentIndex[bodyEntity]];
+}
+
+// Set the body type of a body
+inline void RigidBodyComponents::setBodyType(Entity bodyEntity, BodyType bodyType) {
+
+ assert(mMapEntityToComponentIndex.containsKey(bodyEntity));
+
+ mBodyTypes[mMapEntityToComponentIndex[bodyEntity]] = bodyType;
+}
+
+
}
#endif
diff --git a/src/engine/DynamicsWorld.cpp b/src/engine/DynamicsWorld.cpp
index 8e32e252..71cb745b 100644
--- a/src/engine/DynamicsWorld.cpp
+++ b/src/engine/DynamicsWorld.cpp
@@ -376,8 +376,7 @@ RigidBody* DynamicsWorld::createRigidBody(const Transform& transform) {
Entity entity = mEntityManager.createEntity();
mTransformComponents.addComponent(entity, false, TransformComponents::TransformComponent(transform));
- mDynamicsComponents.addComponent(entity, false, DynamicsComponents::DynamicsComponent(transform.getPosition(),
- BodyType::DYNAMIC));
+ mDynamicsComponents.addComponent(entity, false, DynamicsComponents::DynamicsComponent(transform.getPosition()));
// Create the rigid body
RigidBody* rigidBody = new (mMemoryManager.allocate(MemoryManager::AllocationType::Pool,
@@ -387,7 +386,7 @@ RigidBody* DynamicsWorld::createRigidBody(const Transform& transform) {
CollisionBodyComponents::CollisionBodyComponent bodyComponent(rigidBody);
mCollisionBodyComponents.addComponent(entity, false, bodyComponent);
- RigidBodyComponents::RigidBodyComponent rigidBodyComponent(rigidBody);
+ RigidBodyComponents::RigidBodyComponent rigidBodyComponent(rigidBody, BodyType::DYNAMIC);
mRigidBodyComponents.addComponent(entity, false, rigidBodyComponent);
// Add the rigid body to the physics world
@@ -660,7 +659,8 @@ void DynamicsWorld::createIslands() {
if (mDynamicsComponents.mIsAlreadyInIsland[b]) continue;
// If the body is static, we go to the next body
- if (mDynamicsComponents.mBodyTypes[b] == BodyType::STATIC) continue;
+ // TODO : Check if we still need this test if we loop over dynamicsComponents and static bodies are not part of them
+ if (mRigidBodyComponents.getBodyType(mDynamicsComponents.mBodies[b]) == BodyType::STATIC) continue;
// Reset the stack of bodies to visit
bodyEntityIndicesToVisit.clear();
@@ -771,7 +771,7 @@ void DynamicsWorld::createIslands() {
// can also be included in the other islands
for (uint j=0; j < mDynamicsComponents.getNbEnabledComponents(); j++) {
- if (mDynamicsComponents.mBodyTypes[j] == BodyType::STATIC) {
+ if (mRigidBodyComponents.getBodyType(mDynamicsComponents.mBodies[j]) == BodyType::STATIC) {
mDynamicsComponents.mIsAlreadyInIsland[j] = false;
}
}
@@ -808,7 +808,7 @@ void DynamicsWorld::updateSleepingBodies() {
RigidBody* body = mRigidBodyComponents.getRigidBody(bodyEntity);
// Skip static bodies
- if (mDynamicsComponents.getBodyType(body->getEntity()) == BodyType::STATIC) continue;
+ if (mRigidBodyComponents.getBodyType(bodyEntity) == BodyType::STATIC) continue;
// If the body is velocity is large enough to stay awake
if (mDynamicsComponents.getLinearVelocity(bodyEntity).lengthSquare() > sleepLinearVelocitySquare ||