mrq/reactphysics3d
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Remove code to update proxy-shape broad-phase state from proxy-shape, move it to broad-phase system

Browse Source
This commit is contained in:
Daniel Chappuis 2019-03-17 22:50:10 +01:00
parent ae076ad815
commit 1d6155aa6c
20 changed files with 184 additions and 141 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
CMakeLists.txt
View File

@ -142,7 +142,7 @@ SET (REACTPHYSICS3D_HEADERS
"src/components/Components.h"
"src/components/BodyComponents.h"
"src/components/TransformComponents.h"
"src/components/ProxyShapesComponents.h"
"src/components/ProxyShapeComponents.h"
"src/collision/CollisionCallback.h"
"src/collision/OverlapCallback.h"
"src/mathematics/mathematics.h"
@ -234,7 +234,7 @@ SET (REACTPHYSICS3D_SOURCES
"src/components/Components.cpp"
"src/components/BodyComponents.cpp"
"src/components/TransformComponents.cpp"
"src/components/ProxyShapesComponents.cpp"
"src/components/ProxyShapeComponents.cpp"
"src/collision/CollisionCallback.cpp"
"src/mathematics/mathematics_functions.cpp"
"src/mathematics/Matrix2x2.cpp"

24
src/body/CollisionBody.cpp
View File

@ -84,7 +84,7 @@ ProxyShape* CollisionBody::addCollisionShape(CollisionShape* collisionShape,
Vector3 localBoundsMax;
// TODO : Maybe this method can directly returns an AABB
collisionShape->getLocalBounds(localBoundsMin, localBoundsMax);
ProxyShapesComponents::ProxyShapeComponent proxyShapeComponent(mEntity, proxyShape, -1,
ProxyShapeComponents::ProxyShapeComponent proxyShapeComponent(mEntity, proxyShape, -1,
AABB(localBoundsMin, localBoundsMax),
transform, collisionShape, decimal(1), 0x0001, 0xFFFF);
mWorld.mProxyShapesComponents.addComponent(proxyShapeEntity, mIsSleeping, proxyShapeComponent);
@ -234,26 +234,8 @@ void CollisionBody::updateBroadPhaseState() const {
const List<Entity>& proxyShapesEntities = mWorld.mBodyComponents.getProxyShapes(mEntity);
for (uint i=0; i < proxyShapesEntities.size(); i++) {
ProxyShape* proxyShape = mWorld.mProxyShapesComponents.getProxyShape(proxyShapesEntities[i]);
// Update the proxy
updateProxyShapeInBroadPhase(proxyShape);
}
}
// Update the broad-phase state of a proxy collision shape of the body
void CollisionBody::updateProxyShapeInBroadPhase(ProxyShape* proxyShape, bool forceReinsert) const {
const Transform& transform = mWorld.mTransformComponents.getTransform(mEntity);
if (proxyShape->getBroadPhaseId() != -1) {
// Recompute the world-space AABB of the collision shape
AABB aabb;
proxyShape->getCollisionShape()->computeAABB(aabb, transform * proxyShape->getLocalToBodyTransform());
// Update the broad-phase state for the proxy collision shape
mWorld.mCollisionDetection.updateProxyCollisionShape(proxyShape, aabb, Vector3(0, 0, 0), forceReinsert) ;
mWorld.mCollisionDetection.updateProxyShape(proxyShapesEntities[i]);
}
}
@ -442,6 +424,8 @@ AABB CollisionBody::getAABB() const {
*/
void CollisionBody::setTransform(const Transform& transform) {
// TODO : Make sure this method is never called from the internal physics engine
// Update the transform of the body
mWorld.mTransformComponents.setTransform(mEntity, transform);

5
src/body/CollisionBody.h
View File

@ -92,10 +92,7 @@ class CollisionBody : public Body {
void removeAllCollisionShapes();
/// Update the broad-phase state for this body (because it has moved for instance)
virtual void updateBroadPhaseState() const;
/// Update the broad-phase state of a proxy collision shape of the body
void updateProxyShapeInBroadPhase(ProxyShape* proxyShape, bool forceReinsert = false) const;
void updateBroadPhaseState() const;
/// Ask the broad-phase to test again the collision shapes of the body for collision
/// (as if the body has moved).

32
src/body/RigidBody.cpp
View File

@ -294,7 +294,7 @@ ProxyShape* RigidBody::addCollisionShape(CollisionShape* collisionShape,
// TODO : Maybe this method can directly returns an AABB
collisionShape->getLocalBounds(localBoundsMin, localBoundsMax);
ProxyShapesComponents::ProxyShapeComponent proxyShapeComponent(mEntity, proxyShape, -1,
ProxyShapeComponents::ProxyShapeComponent proxyShapeComponent(mEntity, proxyShape, -1,
AABB(localBoundsMin, localBoundsMax),
transform, collisionShape, mass, 0x0001, 0xFFFF);
mWorld.mProxyShapesComponents.addComponent(proxyShapeEntity, mIsSleeping, proxyShapeComponent);
@ -576,36 +576,6 @@ void RigidBody::recomputeMassInformation() {
mLinearVelocity += mAngularVelocity.cross(mCenterOfMassWorld - oldCenterOfMass);
}
// Update the broad-phase state for this body (because it has moved for instance)
void RigidBody::updateBroadPhaseState() const {
RP3D_PROFILE("RigidBody::updateBroadPhaseState()", mProfiler);
// TODO : Make sure we compute this in a system
const Transform& transform = mWorld.mTransformComponents.getTransform(mEntity);
DynamicsWorld& world = static_cast<DynamicsWorld&>(mWorld);
const Vector3 displacement = world.mTimeStep * mLinearVelocity;
// For all the proxy collision shapes of the body
const List<Entity>& proxyShapesEntities = mWorld.mBodyComponents.getProxyShapes(mEntity);
for (uint i=0; i < proxyShapesEntities.size(); i++) {
ProxyShape* proxyShape = mWorld.mProxyShapesComponents.getProxyShape(proxyShapesEntities[i]);
if (proxyShape->getBroadPhaseId() != -1) {
// Recompute the world-space AABB of the collision shape
AABB aabb;
proxyShape->getCollisionShape()->computeAABB(aabb, transform * proxyShape->getLocalToBodyTransform());
// Update the broad-phase state for the proxy collision shape
mWorld.mCollisionDetection.updateProxyCollisionShape(proxyShape, aabb, displacement);
}
}
}
#ifdef IS_PROFILING_ACTIVE
// Set the profiler

3
src/body/RigidBody.h
View File

@ -123,9 +123,6 @@ class RigidBody : public CollisionBody {
/// Update the transform of the body after a change of the center of mass
void updateTransformWithCenterOfMass();
/// Update the broad-phase state for this body (because it has moved for instance)
virtual void updateBroadPhaseState() const override;
/// Update the world inverse inertia tensor of the body
void updateInertiaTensorInverseWorld();

8
src/collision/CollisionDetection.cpp
View File

@ -48,9 +48,11 @@ using namespace std;
// Constructor
CollisionDetection::CollisionDetection(CollisionWorld* world, ProxyShapesComponents& proxyShapesComponents, MemoryManager& memoryManager)
: mMemoryManager(memoryManager), mProxyShapesComponents(proxyShapesComponents), mCollisionDispatch(mMemoryManager.getPoolAllocator()), mWorld(world),
mOverlappingPairs(mMemoryManager.getPoolAllocator()), mBroadPhaseSystem(*this, mProxyShapesComponents),
CollisionDetection::CollisionDetection(CollisionWorld* world, ProxyShapeComponents& proxyShapesComponents, TransformComponents &transformComponents,
MemoryManager& memoryManager)
: mMemoryManager(memoryManager), mProxyShapesComponents(proxyShapesComponents), mTransformComponents(transformComponents),
mCollisionDispatch(mMemoryManager.getPoolAllocator()), mWorld(world),
mOverlappingPairs(mMemoryManager.getPoolAllocator()), mBroadPhaseSystem(*this, mProxyShapesComponents, mTransformComponents),
mNoCollisionPairs(mMemoryManager.getPoolAllocator()), mIsCollisionShapesAdded(false),
mNarrowPhaseInput(mMemoryManager.getSingleFrameAllocator()) {

38
src/collision/CollisionDetection.h
View File

@ -35,7 +35,8 @@
#include "collision/narrowphase/CollisionDispatch.h"
#include "containers/Map.h"
#include "containers/Set.h"
#include "components/ProxyShapesComponents.h"
#include "components/ProxyShapeComponents.h"
#include "components/TransformComponents.h"
/// ReactPhysics3D namespace
namespace reactphysics3d {
@ -68,8 +69,11 @@ class CollisionDetection {
/// Memory manager
MemoryManager& mMemoryManager;
/// Reference the the proxy-shapes components
ProxyShapesComponents& mProxyShapesComponents;
/// Reference the proxy-shape components
ProxyShapeComponents& mProxyShapesComponents;
/// Reference the transform components
TransformComponents& mTransformComponents;
/// Collision Detection Dispatch configuration
CollisionDispatch mCollisionDispatch;
@ -149,7 +153,8 @@ class CollisionDetection {
// -------------------- Methods -------------------- //
/// Constructor
CollisionDetection(CollisionWorld* world, ProxyShapesComponents& proxyShapesComponents, MemoryManager& memoryManager);
CollisionDetection(CollisionWorld* world, ProxyShapeComponents& proxyShapesComponents,
TransformComponents& transformComponents, MemoryManager& memoryManager);
/// Destructor
~CollisionDetection() = default;
@ -170,8 +175,10 @@ class CollisionDetection {
void removeProxyCollisionShape(ProxyShape* proxyShape);
/// Update a proxy collision shape (that has moved for instance)
void updateProxyCollisionShape(ProxyShape* shape, const AABB& aabb,
const Vector3& displacement = Vector3(0, 0, 0), bool forceReinsert = false);
void updateProxyShape(Entity proxyShapeEntity);
/// Update all the enabled proxy-shapes
void updateProxyShapes();
/// Add a pair of bodies that cannot collide with each other
void addNoCollisionPair(CollisionBody* body1, CollisionBody* body2);
@ -272,13 +279,6 @@ inline void CollisionDetection::askForBroadPhaseCollisionCheck(ProxyShape* shape
}
}
// Update a proxy collision shape (that has moved for instance)
inline void CollisionDetection::updateProxyCollisionShape(ProxyShape* shape, const AABB& aabb,
const Vector3& displacement, bool forceReinsert) {
mBroadPhaseSystem.updateProxyCollisionShape(shape, aabb, displacement);
}
// Return a pointer to the world
inline CollisionWorld* CollisionDetection::getWorld() {
return mWorld;
@ -289,6 +289,18 @@ inline MemoryManager& CollisionDetection::getMemoryManager() const {
return mMemoryManager;
}
// Update a proxy collision shape (that has moved for instance)
inline void CollisionDetection::updateProxyShape(Entity proxyShapeEntity) {
// Update the proxy-shape component
mBroadPhaseSystem.updateProxyShape(proxyShapeEntity);
}
// Update all the enabled proxy-shapes
inline void CollisionDetection::updateProxyShapes() {
mBroadPhaseSystem.updateProxyShapes();
}
#ifdef IS_PROFILING_ACTIVE
// Set the profiler

5
src/collision/ProxyShape.cpp
View File

@ -105,13 +105,14 @@ void ProxyShape::setCollideWithMaskBits(unsigned short collideWithMaskBits) {
// Set the local to parent body transform
void ProxyShape::setLocalToBodyTransform(const Transform& transform) {
// TODO : Make sure this method is never called by the internal physics engine
//mLocalToBodyTransform = transform;
mBody->mWorld.mProxyShapesComponents.setLocalToBodyTransform(mEntity, transform);
mBody->setIsSleeping(false);
// Notify the body that the proxy shape has to be updated in the broad-phase
mBody->updateProxyShapeInBroadPhase(this, true);
mBody->mWorld.mCollisionDetection.updateProxyShape(mEntity);
int broadPhaseId = mBody->mWorld.mProxyShapesComponents.getBroadPhaseId(mEntity);

7
src/collision/broadphase/DynamicAABBTree.cpp
View File

@ -169,9 +169,8 @@ void DynamicAABBTree::removeObject(int nodeID) {
/// nothing is done. Otherwise, the corresponding node is removed and reinserted into the tree.
/// The method returns true if the object has been reinserted into the tree. The "displacement"
/// argument is the linear velocity of the AABB multiplied by the elapsed time between two
/// frames. If the "forceReinsert" parameter is true, we force a removal and reinsertion of the node
/// (this can be useful if the shape AABB has become much smaller than the previous one for instance).
bool DynamicAABBTree::updateObject(int nodeID, const AABB& newAABB, const Vector3& displacement, bool forceReinsert) {
/// frames.
bool DynamicAABBTree::updateObject(int nodeID, const AABB& newAABB, const Vector3& displacement) {
RP3D_PROFILE("DynamicAABBTree::updateObject()", mProfiler);
@ -180,7 +179,7 @@ bool DynamicAABBTree::updateObject(int nodeID, const AABB& newAABB, const Vector
assert(mNodes[nodeID].height >= 0);
// If the new AABB is still inside the fat AABB of the node
if (!forceReinsert && mNodes[nodeID].aabb.contains(newAABB)) {
if (mNodes[nodeID].aabb.contains(newAABB)) {
return false;
}

2
src/collision/broadphase/DynamicAABBTree.h
View File

@ -225,7 +225,7 @@ class DynamicAABBTree {
void removeObject(int nodeID);
/// Update the dynamic tree after an object has moved.
bool updateObject(int nodeID, const AABB& newAABB, const Vector3& displacement, bool forceReinsert = false);
bool updateObject(int nodeID, const AABB& newAABB, const Vector3& displacement);
/// Return the fat AABB corresponding to a given node ID
const AABB& getFatAABB(int nodeID) const;

8
src/components/Components.h
View File

@ -112,6 +112,9 @@ class Components {
/// Return the number of components
uint32 getNbComponents() const;
/// Return the number of enabled components
uint32 getNbEnabledComponents() const;
};
// Return the number of components
@ -119,6 +122,11 @@ inline uint32 Components::getNbComponents() const {
return mNbComponents;
}
// Return the number of enabled components
inline uint32 Components::getNbEnabledComponents() const {
return mDisabledStartIndex;
}
}
#endif

14
src/components/ProxyShapesComponents.cpp → src/components/ProxyShapeComponents.cpp
View File

@ -24,7 +24,7 @@
********************************************************************************/
// Libraries
#include "ProxyShapesComponents.h"
#include "ProxyShapeComponents.h"
#include "engine/EntityManager.h"
#include "collision/ProxyShape.h"
#include <cassert>
@ -34,7 +34,7 @@
using namespace reactphysics3d;
// Constructor
ProxyShapesComponents::ProxyShapesComponents(MemoryAllocator& allocator)
ProxyShapeComponents::ProxyShapeComponents(MemoryAllocator& allocator)
:Components(allocator, sizeof(Entity) + sizeof(Entity) + sizeof(ProxyShape*) + sizeof(int) + sizeof(AABB) +
sizeof(Transform) + sizeof(CollisionShape*) + sizeof(decimal) + sizeof(unsigned short) +
sizeof(unsigned short)) {
@ -44,7 +44,7 @@ ProxyShapesComponents::ProxyShapesComponents(MemoryAllocator& allocator)
}
// Allocate memory for a given number of components
void ProxyShapesComponents::allocate(uint32 nbComponentsToAllocate) {
void ProxyShapeComponents::allocate(uint32 nbComponentsToAllocate) {
assert(nbComponentsToAllocate > mNbAllocatedComponents);
@ -103,7 +103,7 @@ void ProxyShapesComponents::allocate(uint32 nbComponentsToAllocate) {
}
// Add a component
void ProxyShapesComponents::addComponent(Entity proxyShapeEntity, bool isSleeping, const ProxyShapeComponent& component) {
void ProxyShapeComponents::addComponent(Entity proxyShapeEntity, bool isSleeping, const ProxyShapeComponent& component) {
// Prepare to add new component (allocate memory if necessary and compute insertion index)
uint32 index = prepareAddComponent(isSleeping);
@ -130,7 +130,7 @@ void ProxyShapesComponents::addComponent(Entity proxyShapeEntity, bool isSleepin
// Move a component from a source to a destination index in the components array
// The destination location must contain a constructed object
void ProxyShapesComponents::moveComponentToIndex(uint32 srcIndex, uint32 destIndex) {
void ProxyShapeComponents::moveComponentToIndex(uint32 srcIndex, uint32 destIndex) {
const Entity proxyShapeEntity = mProxyShapesEntities[srcIndex];
@ -158,7 +158,7 @@ void ProxyShapesComponents::moveComponentToIndex(uint32 srcIndex, uint32 destInd
}
// Swap two components in the array
void ProxyShapesComponents::swapComponents(uint32 index1, uint32 index2) {
void ProxyShapeComponents::swapComponents(uint32 index1, uint32 index2) {
// Copy component 1 data
Entity proxyShapeEntity1(mProxyShapesEntities[index1]);
@ -198,7 +198,7 @@ void ProxyShapesComponents::swapComponents(uint32 index1, uint32 index2) {
}
// Destroy a component at a given index
void ProxyShapesComponents::destroyComponent(uint32 index) {
void ProxyShapeComponents::destroyComponent(uint32 index) {
Components::destroyComponent(index);

32
src/components/ProxyShapesComponents.h → src/components/ProxyShapeComponents.h
View File

@ -49,7 +49,7 @@ class ProxyShape;
* different bodies. We also make sure that proxy shapes of sleeping entities (bodies) are
* always stored at the end of the array.
*/
class ProxyShapesComponents : public Components {
class ProxyShapeComponents : public Components {
private:
@ -135,10 +135,10 @@ class ProxyShapesComponents : public Components {
// -------------------- Methods -------------------- //
/// Constructor
ProxyShapesComponents(MemoryAllocator& allocator);
ProxyShapeComponents(MemoryAllocator& allocator);
/// Destructor
virtual ~ProxyShapesComponents() override = default;
virtual ~ProxyShapeComponents() override = default;
/// Add a component
void addComponent(Entity proxyShapeEntity, bool isSleeping, const ProxyShapeComponent& component);
@ -175,10 +175,14 @@ class ProxyShapesComponents : public Components {
/// Set the "collide with" mask bits of a given proxy-shape
void setCollideWithMaskBits(Entity proxyShapeEntity, unsigned short collideWithMaskBits);
// -------------------- Friendship -------------------- //
friend class BroadPhaseSystem;
};
// Return the mass of a proxy-shape
inline decimal ProxyShapesComponents::getMass(Entity proxyShapeEntity) const {
inline decimal ProxyShapeComponents::getMass(Entity proxyShapeEntity) const {
assert(mMapEntityToComponentIndex.containsKey(proxyShapeEntity));
@ -186,7 +190,7 @@ inline decimal ProxyShapesComponents::getMass(Entity proxyShapeEntity) const {
}
// Return a pointer to a given proxy-shape
inline ProxyShape* ProxyShapesComponents::getProxyShape(Entity proxyShapeEntity) const {
inline ProxyShape* ProxyShapeComponents::getProxyShape(Entity proxyShapeEntity) const {
assert(mMapEntityToComponentIndex.containsKey(proxyShapeEntity));
@ -194,7 +198,7 @@ inline ProxyShape* ProxyShapesComponents::getProxyShape(Entity proxyShapeEntity)
}
// Return the local-to-body transform of a proxy-shape
inline const Transform& ProxyShapesComponents::getLocalToBodyTransform(Entity proxyShapeEntity) const {
inline const Transform& ProxyShapeComponents::getLocalToBodyTransform(Entity proxyShapeEntity) const {
assert(mMapEntityToComponentIndex.containsKey(proxyShapeEntity));
@ -202,7 +206,7 @@ inline const Transform& ProxyShapesComponents::getLocalToBodyTransform(Entity pr
}
// Set the local-to-body transform of a proxy-shape
inline void ProxyShapesComponents::setLocalToBodyTransform(Entity proxyShapeEntity, const Transform& transform) {
inline void ProxyShapeComponents::setLocalToBodyTransform(Entity proxyShapeEntity, const Transform& transform) {
assert(mMapEntityToComponentIndex.containsKey(proxyShapeEntity));
@ -210,7 +214,7 @@ inline void ProxyShapesComponents::setLocalToBodyTransform(Entity proxyShapeEnti
}
// Return a pointer to the collision shape of a proxy-shape
inline CollisionShape* ProxyShapesComponents::getCollisionShape(Entity proxyShapeEntity) const {
inline CollisionShape* ProxyShapeComponents::getCollisionShape(Entity proxyShapeEntity) const {
assert(mMapEntityToComponentIndex.containsKey(proxyShapeEntity));
@ -218,7 +222,7 @@ inline CollisionShape* ProxyShapesComponents::getCollisionShape(Entity proxyShap
}
// Return the broad-phase id of a given proxy shape
inline int ProxyShapesComponents::getBroadPhaseId(Entity proxyShapeEntity) const {
inline int ProxyShapeComponents::getBroadPhaseId(Entity proxyShapeEntity) const {
assert(mMapEntityToComponentIndex.containsKey(proxyShapeEntity));
@ -226,7 +230,7 @@ inline int ProxyShapesComponents::getBroadPhaseId(Entity proxyShapeEntity) const
}
// Set the broad-phase id of a given proxy shape
inline void ProxyShapesComponents::setBroadPhaseId(Entity proxyShapeEntity, int broadPhaseId) {
inline void ProxyShapeComponents::setBroadPhaseId(Entity proxyShapeEntity, int broadPhaseId) {
assert(mMapEntityToComponentIndex.containsKey(proxyShapeEntity));
@ -234,7 +238,7 @@ inline void ProxyShapesComponents::setBroadPhaseId(Entity proxyShapeEntity, int
}
// Return the collision category bits of a given proxy-shape
inline unsigned short ProxyShapesComponents::getCollisionCategoryBits(Entity proxyShapeEntity) const {
inline unsigned short ProxyShapeComponents::getCollisionCategoryBits(Entity proxyShapeEntity) const {
assert(mMapEntityToComponentIndex.containsKey(proxyShapeEntity));
@ -242,7 +246,7 @@ inline unsigned short ProxyShapesComponents::getCollisionCategoryBits(Entity pro
}
// Return the "collide with" mask bits of a given proxy-shape
inline unsigned short ProxyShapesComponents::getCollideWithMaskBits(Entity proxyShapeEntity) const {
inline unsigned short ProxyShapeComponents::getCollideWithMaskBits(Entity proxyShapeEntity) const {
assert(mMapEntityToComponentIndex.containsKey(proxyShapeEntity));
@ -250,7 +254,7 @@ inline unsigned short ProxyShapesComponents::getCollideWithMaskBits(Entity proxy
}
// Set the collision category bits of a given proxy-shape
inline void ProxyShapesComponents::setCollisionCategoryBits(Entity proxyShapeEntity, unsigned short collisionCategoryBits) {
inline void ProxyShapeComponents::setCollisionCategoryBits(Entity proxyShapeEntity, unsigned short collisionCategoryBits) {
assert(mMapEntityToComponentIndex.containsKey(proxyShapeEntity));
@ -258,7 +262,7 @@ inline void ProxyShapesComponents::setCollisionCategoryBits(Entity proxyShapeEnt
}
// Set the "collide with" mask bits of a given proxy-shape
inline void ProxyShapesComponents::setCollideWithMaskBits(Entity proxyShapeEntity, unsigned short collideWithMaskBits) {
inline void ProxyShapeComponents::setCollideWithMaskBits(Entity proxyShapeEntity, unsigned short collideWithMaskBits) {
assert(mMapEntityToComponentIndex.containsKey(proxyShapeEntity));

4
src/components/TransformComponents.h
View File

@ -100,6 +100,10 @@ class TransformComponents : public Components {
/// Set the transform of an entity
void setTransform(Entity bodyEntity, const Transform& transform);
// -------------------- Friendship -------------------- //
friend class BroadPhaseSystem;
};
// Return the transform of an entity

2
src/engine/CollisionWorld.cpp
View File

@ -39,7 +39,7 @@ uint CollisionWorld::mNbWorlds = 0;
CollisionWorld::CollisionWorld(const WorldSettings& worldSettings, Logger* logger, Profiler* profiler)
: mConfig(worldSettings), mEntityManager(mMemoryManager.getPoolAllocator()),
mBodyComponents(mMemoryManager.getBaseAllocator()), mTransformComponents(mMemoryManager.getBaseAllocator()),
mProxyShapesComponents(mMemoryManager.getBaseAllocator()), mCollisionDetection(this, mProxyShapesComponents, mMemoryManager),
mProxyShapesComponents(mMemoryManager.getBaseAllocator()), mCollisionDetection(this, mProxyShapesComponents, mTransformComponents, mMemoryManager),
mBodies(mMemoryManager.getPoolAllocator()), mCurrentBodyId(0), mFreeBodiesIds(mMemoryManager.getPoolAllocator()),
mEventListener(nullptr), mName(worldSettings.worldName),
mIsProfilerCreatedByUser(profiler != nullptr),

4
src/engine/CollisionWorld.h
View File

@ -35,7 +35,7 @@
#include "engine/EntityManager.h"
#include "components/BodyComponents.h"
#include "components/TransformComponents.h"
#include "components/ProxyShapesComponents.h"
#include "components/ProxyShapeComponents.h"
/// Namespace reactphysics3d
namespace reactphysics3d {
@ -80,7 +80,7 @@ class CollisionWorld {
TransformComponents mTransformComponents;
/// Proxy-Shapes Components
ProxyShapesComponents mProxyShapesComponents;
ProxyShapeComponents mProxyShapesComponents;
/// Reference to the collision detection
CollisionDetection mCollisionDetection;

6
src/engine/DynamicsWorld.cpp
View File

@ -228,11 +228,11 @@ void DynamicsWorld::updateBodiesState() {
// Update the world inverse inertia tensor of the body
bodies[b]->updateInertiaTensorInverseWorld();
// Update the broad-phase state of the body
bodies[b]->updateBroadPhaseState();
}
}
// Update the proxy-shapes components
mCollisionDetection.updateProxyShapes();
}
// Initialize the bodies velocities arrays for the next simulation step.

69
src/systems/BroadPhaseSystem.cpp
View File

@ -35,9 +35,10 @@
using namespace reactphysics3d;
// Constructor
BroadPhaseSystem::BroadPhaseSystem(CollisionDetection& collisionDetection, ProxyShapesComponents& proxyShapesComponents)
BroadPhaseSystem::BroadPhaseSystem(CollisionDetection& collisionDetection, ProxyShapeComponents& proxyShapesComponents,
TransformComponents& transformComponents)
:mDynamicAABBTree(collisionDetection.getMemoryManager().getPoolAllocator(), DYNAMIC_TREE_AABB_GAP),
mProxyShapesComponents(proxyShapesComponents),
mProxyShapesComponents(proxyShapesComponents), mTransformsComponents(transformComponents),
mMovedShapes(collisionDetection.getMemoryManager().getPoolAllocator()),
mPotentialPairs(collisionDetection.getMemoryManager().getPoolAllocator()),
mCollisionDetection(collisionDetection) {
@ -108,16 +109,32 @@ void BroadPhaseSystem::removeProxyCollisionShape(ProxyShape* proxyShape) {
removeMovedCollisionShape(broadPhaseID);
}
// Update the broad-phase state of a single proxy-shape
void BroadPhaseSystem::updateProxyShape(Entity proxyShapeEntity) {
assert(mProxyShapesComponents.mMapEntityToComponentIndex.containsKey(proxyShapeEntity));
// Get the index of the proxy-shape component in the array
uint32 index = mProxyShapesComponents.mMapEntityToComponentIndex[proxyShapeEntity];
// Update the proxy-shape component
updateProxyShapesComponents(index, index + 1);
}
// Update the broad-phase state of all the enabled proxy-shapes
void BroadPhaseSystem::updateProxyShapes() {
// Update all the enabled proxy-shape components
updateProxyShapesComponents(0, mProxyShapesComponents.getNbEnabledComponents());
}
// Notify the broad-phase that a collision shape has moved and need to be updated
void BroadPhaseSystem::updateProxyCollisionShape(ProxyShape* proxyShape, const AABB& aabb,
const Vector3& displacement, bool forceReinsert) {
void BroadPhaseSystem::updateProxyShapeInternal(int broadPhaseId, const AABB& aabb, const Vector3& displacement) {
int broadPhaseID = proxyShape->getBroadPhaseId();
assert(broadPhaseID >= 0);
assert(broadPhaseId >= 0);
// Update the dynamic AABB tree according to the movement of the collision shape
bool hasBeenReInserted = mDynamicAABBTree.updateObject(broadPhaseID, aabb, displacement, forceReinsert);
bool hasBeenReInserted = mDynamicAABBTree.updateObject(broadPhaseId, aabb, displacement);
// If the collision shape has moved out of its fat AABB (and therefore has been reinserted
// into the tree).
@ -125,7 +142,41 @@ void BroadPhaseSystem::updateProxyCollisionShape(ProxyShape* proxyShape, const A
// Add the collision shape into the array of shapes that have moved (or have been created)
// during the last simulation step
addMovedCollisionShape(broadPhaseID);
addMovedCollisionShape(broadPhaseId);
}
}
// Update the broad-phase state of some proxy-shapes components
void BroadPhaseSystem::updateProxyShapesComponents(uint32 startIndex, uint32 endIndex) {
assert(startIndex <= endIndex);
assert(startIndex < mProxyShapesComponents.getNbComponents());
assert(endIndex <= mProxyShapesComponents.getNbComponents());
// Make sure we do not update disabled components
startIndex = std::min(startIndex, mProxyShapesComponents.getNbEnabledComponents());
endIndex = std::min(endIndex, mProxyShapesComponents.getNbEnabledComponents());
// For each proxy-shape component to update
for (uint32 i = startIndex; i < endIndex; i++) {
const int broadPhaseId = mProxyShapesComponents.mBroadPhaseIds[i];
if (broadPhaseId != -1) {
const Entity& bodyEntity = mProxyShapesComponents.mBodiesEntities[i];
const Transform& transform = mTransformsComponents.getTransform(bodyEntity);
// TODO : Use body linear velocity and compute displacement
const Vector3 displacement = Vector3::zero();
//const Vector3 displacement = world.mTimeStep * mLinearVelocity;
// Recompute the world-space AABB of the collision shape
AABB aabb;
mProxyShapesComponents.mCollisionShapes[i]->computeAABB(aabb, transform * mProxyShapesComponents.mLocalToBodyTransforms[i]);
// Update the broad-phase state for the proxy collision shape
updateProxyShapeInternal(broadPhaseId, aabb, displacement);
}
}
}

26
src/systems/BroadPhaseSystem.h
View File

@ -30,7 +30,8 @@
#include "collision/broadphase/DynamicAABBTree.h"
#include "containers/LinkedList.h"
#include "containers/Set.h"
#include "components/ProxyShapesComponents.h"
#include "components/ProxyShapeComponents.h"
#include "components/TransformComponents.h"
/// Namespace ReactPhysics3D
namespace reactphysics3d {
@ -142,7 +143,10 @@ class BroadPhaseSystem {
DynamicAABBTree mDynamicAABBTree;
/// Reference to the proxy-shapes components
ProxyShapesComponents& mProxyShapesComponents;
ProxyShapeComponents& mProxyShapesComponents;
/// Reference to the transform components
TransformComponents& mTransformsComponents;
/// Set with the broad-phase IDs of all collision shapes that have moved (or have been
/// created) during the last simulation step. Those are the shapes that need to be tested
@ -161,13 +165,21 @@ class BroadPhaseSystem {
Profiler* mProfiler;
#endif
// -------------------- Methods -------------------- //
/// Notify the Dynamic AABB tree that a proxy-shape needs to be updated
void updateProxyShapeInternal(int broadPhaseId, const AABB& aabb, const Vector3& displacement);
/// Update the broad-phase state of some proxy-shapes components
void updateProxyShapesComponents(uint32 startIndex, uint32 endIndex);
public :
// -------------------- Methods -------------------- //
/// Constructor
BroadPhaseSystem(CollisionDetection& collisionDetection, ProxyShapesComponents& proxyShapesComponents);
BroadPhaseSystem(CollisionDetection& collisionDetection, ProxyShapeComponents& proxyShapesComponents,
TransformComponents &transformComponents);
/// Destructor
~BroadPhaseSystem() = default;
@ -184,9 +196,11 @@ class BroadPhaseSystem {
/// Remove a proxy collision shape from the broad-phase collision detection
void removeProxyCollisionShape(ProxyShape* proxyShape);
/// Notify the broad-phase that a collision shape has moved and need to be updated
void updateProxyCollisionShape(ProxyShape* proxyShape, const AABB& aabb,
const Vector3& displacement, bool forceReinsert = false);
/// Update the broad-phase state of a single proxy-shape
void updateProxyShape(Entity proxyShapeEntity);
/// Update the broad-phase state of all the enabled proxy-shapes
void updateProxyShapes();
/// Add a collision shape in the array of shapes that have moved in the last simulation step
/// and that need to be tested again for broad-phase overlapping.

32
test/tests/collision/TestDynamicAABBTree.h
View File

@ -243,10 +243,10 @@ class TestDynamicAABBTree : public Test {
// ---- Update the object AABBs with the initial AABBs (no reinsertion) ----- //
tree.updateObject(object1Id, aabb1, Vector3::zero(), false);
tree.updateObject(object2Id, aabb2, Vector3::zero(), false);
tree.updateObject(object3Id, aabb3, Vector3::zero(), false);
tree.updateObject(object4Id, aabb4, Vector3::zero(), false);
tree.updateObject(object1Id, aabb1, Vector3::zero());
tree.updateObject(object2Id, aabb2, Vector3::zero());
tree.updateObject(object3Id, aabb3, Vector3::zero());
tree.updateObject(object4Id, aabb4, Vector3::zero());
// AABB overlapping nothing
mOverlapCallback.reset();
@ -290,10 +290,10 @@ class TestDynamicAABBTree : public Test {
// ---- Update the object AABBs with the initial AABBs (with reinsertion) ----- //
tree.updateObject(object1Id, aabb1, Vector3::zero(), true);
tree.updateObject(object2Id, aabb2, Vector3::zero(), true);
tree.updateObject(object3Id, aabb3, Vector3::zero(), true);
tree.updateObject(object4Id, aabb4, Vector3::zero(), true);
tree.updateObject(object1Id, aabb1, Vector3::zero());
tree.updateObject(object2Id, aabb2, Vector3::zero());
tree.updateObject(object3Id, aabb3, Vector3::zero());
tree.updateObject(object4Id, aabb4, Vector3::zero());
// AABB overlapping nothing
mOverlapCallback.reset();
@ -438,10 +438,10 @@ class TestDynamicAABBTree : public Test {
// ---- Update the object AABBs with the initial AABBs (no reinsertion) ----- //
tree.updateObject(object1Id, aabb1, Vector3::zero(), false);
tree.updateObject(object2Id, aabb2, Vector3::zero(), false);
tree.updateObject(object3Id, aabb3, Vector3::zero(), false);
tree.updateObject(object4Id, aabb4, Vector3::zero(), false);
tree.updateObject(object1Id, aabb1, Vector3::zero());
tree.updateObject(object2Id, aabb2, Vector3::zero());
tree.updateObject(object3Id, aabb3, Vector3::zero());
tree.updateObject(object4Id, aabb4, Vector3::zero());
// Ray with no hits
mRaycastCallback.reset();
@ -477,10 +477,10 @@ class TestDynamicAABBTree : public Test {
// ---- Update the object AABBs with the initial AABBs (with reinsertion) ----- //
tree.updateObject(object1Id, aabb1, Vector3::zero(), true);
tree.updateObject(object2Id, aabb2, Vector3::zero(), true);
tree.updateObject(object3Id, aabb3, Vector3::zero(), true);
tree.updateObject(object4Id, aabb4, Vector3::zero(), true);
tree.updateObject(object1Id, aabb1, Vector3::zero());
tree.updateObject(object2Id, aabb2, Vector3::zero());
tree.updateObject(object3Id, aabb3, Vector3::zero());
tree.updateObject(object4Id, aabb4, Vector3::zero());
// Ray with no hits
mRaycastCallback.reset();