Remove the PairManager class
This commit is contained in:
Daniel Chappuis
parent
5f7af61593
commit
5d2cf593b5
|
|
@ -1,289 +0,0 @@
|
|||
/********************************************************************************
|
||||
* ReactPhysics3D physics library, http://code.google.com/p/reactphysics3d/ *
|
||||
* Copyright (c) 2010-2013 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 "PairManager.h"
|
||||
#include "../CollisionDetection.h"
|
||||
#include <cassert>
|
||||
#include <cstring>
|
||||
|
||||
using namespace reactphysics3d;
|
||||
|
||||
// Initialization of static variables
|
||||
bodyindex PairManager::INVALID_INDEX = std::numeric_limits<reactphysics3d::bodyindex>::max();
|
||||
|
||||
// Constructor of PairManager
|
||||
PairManager::PairManager(CollisionDetection& collisionDetection)
|
||||
: mCollisionDetection(collisionDetection) {
|
||||
mHashTable = NULL;
|
||||
mOverlappingPairs = NULL;
|
||||
mOffsetNextPair = NULL;
|
||||
mNbOverlappingPairs = 0;
|
||||
mHashMask = 0;
|
||||
mNbElementsHashTable = 0;
|
||||
}
|
||||
|
||||
// Destructor of PairManager
|
||||
PairManager::~PairManager() {
|
||||
|
||||
// Release the allocated memory
|
||||
free(mOffsetNextPair);
|
||||
free(mOverlappingPairs);
|
||||
free(mHashTable);
|
||||
}
|
||||
|
||||
// Add a pair of bodies in the pair manager and returns a pointer to that pair.
|
||||
/// If the pair to add does not already exist in the set of
|
||||
/// overlapping pairs, it will be created and if it already exists, we only
|
||||
/// return a pointer to that pair.
|
||||
BodyPair* PairManager::addPair(CollisionBody* body1, CollisionBody* body2) {
|
||||
|
||||
// Sort the bodies to have the body with smallest ID first
|
||||
sortBodiesUsingID(body1, body2);
|
||||
|
||||
// Get the bodies IDs
|
||||
bodyindex id1 = body1->getID();
|
||||
bodyindex id2 = body2->getID();
|
||||
|
||||
// Compute the hash value of the two bodies
|
||||
uint hashValue = computeHashBodies(id1, id2) & mHashMask;
|
||||
|
||||
// Try to find the pair in the current overlapping pairs.
|
||||
BodyPair* pair = findPairWithHashValue(id1, id2, hashValue);
|
||||
|
||||
// If the pair is already in the set of overlapping pairs
|
||||
if (pair) {
|
||||
// We only return a pointer to that pair
|
||||
return pair;
|
||||
}
|
||||
|
||||
// If we need to allocate more pairs in the set of overlapping pairs
|
||||
if (mNbOverlappingPairs >= mNbElementsHashTable) {
|
||||
// Increase the size of the hash table (always a power of two)
|
||||
mNbElementsHashTable = computeNextPowerOfTwo(mNbOverlappingPairs + 1);
|
||||
|
||||
// Compute the new hash mask with the new hash size
|
||||
mHashMask = mNbElementsHashTable - 1;
|
||||
|
||||
// Reallocate more pairs
|
||||
reallocatePairs();
|
||||
|
||||
// Compute the new hash value (using the new hash size and hash mask)
|
||||
hashValue = computeHashBodies(id1, id2) & mHashMask;
|
||||
}
|
||||
|
||||
// Create the new overlapping pair
|
||||
BodyPair* newPair = &mOverlappingPairs[mNbOverlappingPairs];
|
||||
newPair->body1 = body1;
|
||||
newPair->body2 = body2;
|
||||
|
||||
// Put the new pair as the initial pair with this hash value
|
||||
mOffsetNextPair[mNbOverlappingPairs] = mHashTable[hashValue];
|
||||
mHashTable[hashValue] = mNbOverlappingPairs++;
|
||||
|
||||
// Notify the collision detection about this new overlapping pair
|
||||
mCollisionDetection.broadPhaseNotifyOverlappingPair(newPair);
|
||||
|
||||
// Return a pointer to the new created pair
|
||||
return newPair;
|
||||
}
|
||||
|
||||
// Remove a pair of bodies from the pair manager.
|
||||
/// This method returns true if the pair has been found and removed.
|
||||
bool PairManager::removePair(bodyindex id1, bodyindex id2) {
|
||||
|
||||
// Sort the bodies IDs
|
||||
sortIDs(id1, id2);
|
||||
|
||||
// Compute the hash value of the pair to remove
|
||||
const uint hashValue = computeHashBodies(id1, id2) & mHashMask;
|
||||
|
||||
// Find the pair to remove
|
||||
BodyPair* pair = findPairWithHashValue(id1, id2, hashValue);
|
||||
|
||||
// If we have not found the pair
|
||||
if (pair == NULL) {
|
||||
return false;
|
||||
}
|
||||
|
||||
assert(pair->body1->getID() == id1);
|
||||
assert(pair->body2->getID() == id2);
|
||||
|
||||
// Notify the collision detection about this removed overlapping pair
|
||||
mCollisionDetection.broadPhaseNotifyRemovedOverlappingPair(pair);
|
||||
|
||||
// Remove the pair from the set of overlapping pairs
|
||||
removePairWithHashValue(id1, id2, hashValue, computePairOffset(pair));
|
||||
|
||||
// Try to shrink the memory used by the pair manager
|
||||
shrinkMemory();
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
// Internal method to remove a pair from the set of overlapping pair
|
||||
void PairManager::removePairWithHashValue(bodyindex id1, bodyindex id2, luint hashValue,
|
||||
bodyindex indexPair) {
|
||||
|
||||
// Get the initial offset of the pairs with
|
||||
// the corresponding hash value
|
||||
bodyindex offset = mHashTable[hashValue];
|
||||
assert(offset != INVALID_INDEX);
|
||||
|
||||
// Look for the pair in the set of overlapping pairs
|
||||
bodyindex previousPair = INVALID_INDEX;
|
||||
while(offset != indexPair) {
|
||||
previousPair = offset;
|
||||
offset = mOffsetNextPair[offset];
|
||||
}
|
||||
|
||||
// If the pair was the first one with this hash
|
||||
// value in the hash table
|
||||
if (previousPair == INVALID_INDEX) {
|
||||
// Replace the pair to remove in the
|
||||
// hash table by the next one
|
||||
mHashTable[hashValue] = mOffsetNextPair[indexPair];
|
||||
}
|
||||
else { // If the pair was not the first one
|
||||
// Replace the pair to remove in the
|
||||
// hash table by the next one
|
||||
assert(mOffsetNextPair[previousPair] == indexPair);
|
||||
mOffsetNextPair[previousPair] = mOffsetNextPair[indexPair];
|
||||
}
|
||||
|
||||
const bodyindex indexLastPair = mNbOverlappingPairs - 1;
|
||||
|
||||
// If the pair to remove is the last one in the list
|
||||
if (indexPair == indexLastPair) {
|
||||
|
||||
// We simply decrease the number of overlapping pairs
|
||||
mNbOverlappingPairs--;
|
||||
}
|
||||
else { // If the pair to remove is in the middle of the list
|
||||
|
||||
// Now, we want to move the last pair into the location that is
|
||||
// now free because of the pair we want to remove
|
||||
|
||||
// Get the last pair
|
||||
const BodyPair* lastPair = &mOverlappingPairs[indexLastPair];
|
||||
const uint lastPairHashValue = computeHashBodies(lastPair->body1->getID(),
|
||||
lastPair->body2->getID()) & mHashMask;
|
||||
|
||||
// Compute the initial offset of the last pair
|
||||
bodyindex offset = mHashTable[lastPairHashValue];
|
||||
assert(offset != INVALID_INDEX);
|
||||
|
||||
// Go through the pairs with the same hash value
|
||||
// and find the offset of the last pair
|
||||
bodyindex previous = INVALID_INDEX;
|
||||
while(offset != indexLastPair) {
|
||||
previous = offset;
|
||||
offset = mOffsetNextPair[offset];
|
||||
}
|
||||
|
||||
// If the last pair is not the first one with this hash value
|
||||
if (previous != INVALID_INDEX) {
|
||||
|
||||
// Remove the offset of the last pair in the "nextOffset" array
|
||||
assert(mOffsetNextPair[previous] == indexLastPair);
|
||||
mOffsetNextPair[previous] = mOffsetNextPair[indexLastPair];
|
||||
}
|
||||
else { // If the last pair is the first offset with this hash value
|
||||
|
||||
// Remove the offset of the last pair in the "nextOffset" array
|
||||
mHashTable[lastPairHashValue] = mOffsetNextPair[indexLastPair];
|
||||
}
|
||||
|
||||
// Replace the pair to remove by the last pair in
|
||||
// the overlapping pairs array
|
||||
mOverlappingPairs[indexPair] = mOverlappingPairs[indexLastPair];
|
||||
mOffsetNextPair[indexPair] = mHashTable[lastPairHashValue];
|
||||
mHashTable[lastPairHashValue] = indexPair;
|
||||
|
||||
mNbOverlappingPairs--;
|
||||
}
|
||||
}
|
||||
|
||||
// Look for a pair in the set of overlapping pairs
|
||||
BodyPair* PairManager::lookForAPair(bodyindex id1, bodyindex id2, luint hashValue) const {
|
||||
|
||||
// Look for the pair in the set of overlapping pairs
|
||||
bodyindex offset = mHashTable[hashValue];
|
||||
while (offset != INVALID_INDEX && isDifferentPair(mOverlappingPairs[offset], id1, id2)) {
|
||||
offset = mOffsetNextPair[offset];
|
||||
}
|
||||
|
||||
// If the pair has not been found in the overlapping pairs
|
||||
if (offset == INVALID_INDEX) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
assert(offset < mNbOverlappingPairs);
|
||||
|
||||
// The pair has been found in the set of overlapping pairs, then
|
||||
// we return a pointer to it
|
||||
return &mOverlappingPairs[offset];
|
||||
}
|
||||
|
||||
// Reallocate more pairs
|
||||
void PairManager::reallocatePairs() {
|
||||
|
||||
// Reallocate the hash table and initialize it
|
||||
free(mHashTable);
|
||||
mHashTable = (bodyindex*) malloc(mNbElementsHashTable * sizeof(bodyindex));
|
||||
assert(mHashTable != NULL);
|
||||
for (bodyindex i=0; i<mNbElementsHashTable; i++) {
|
||||
mHashTable[i] = INVALID_INDEX;
|
||||
}
|
||||
|
||||
// Reallocate the overlapping pairs
|
||||
BodyPair* newOverlappingPairs = (BodyPair*) malloc(mNbElementsHashTable * sizeof(BodyPair));
|
||||
bodyindex* newOffsetNextPair = (bodyindex*) malloc(mNbElementsHashTable * sizeof(bodyindex));
|
||||
|
||||
assert(newOverlappingPairs != NULL);
|
||||
assert(newOffsetNextPair != NULL);
|
||||
|
||||
// If there is already some overlapping pairs
|
||||
if (mNbOverlappingPairs) {
|
||||
// Copy the pairs to the new location
|
||||
memcpy(newOverlappingPairs, mOverlappingPairs, mNbOverlappingPairs * sizeof(BodyPair));
|
||||
}
|
||||
|
||||
// Recompute the hash table with the new hash values
|
||||
for (bodyindex i=0; i<mNbOverlappingPairs; i++) {
|
||||
const uint newHashValue = computeHashBodies(mOverlappingPairs[i].body1->getID(),
|
||||
mOverlappingPairs[i].body2->getID()) & mHashMask;
|
||||
newOffsetNextPair[i] = mHashTable[newHashValue];
|
||||
mHashTable[newHashValue] = i;
|
||||
}
|
||||
|
||||
// Delete the old pairs
|
||||
free(mOffsetNextPair);
|
||||
free(mOverlappingPairs);
|
||||
|
||||
// Replace by the new data
|
||||
mOverlappingPairs = newOverlappingPairs;
|
||||
mOffsetNextPair = newOffsetNextPair;
|
||||
}
|
||||
|
|
@ -1,333 +0,0 @@
|
|||
/********************************************************************************
|
||||
* ReactPhysics3D physics library, http://code.google.com/p/reactphysics3d/ *
|
||||
* Copyright (c) 2010-2013 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_PAIR_MANAGER_H
|
||||
#define REACTPHYSICS3D_PAIR_MANAGER_H
|
||||
|
||||
// TODO : REMOVE THE PAIR MANAGER CLASS
|
||||
|
||||
// Libraries
|
||||
#include "../../body/CollisionBody.h"
|
||||
#include <utility>
|
||||
|
||||
|
||||
/// Namespace ReactPhysics3D
|
||||
namespace reactphysics3d {
|
||||
|
||||
// Declaration
|
||||
class CollisionDetection;
|
||||
|
||||
// Structure BodyPair
|
||||
/**
|
||||
* This structure represents a pair of bodies
|
||||
* during the broad-phase collision detection.
|
||||
*/
|
||||
struct BodyPair {
|
||||
|
||||
public:
|
||||
|
||||
/// Pointer to the first body
|
||||
CollisionBody* body1;
|
||||
|
||||
/// Pointer to the second body
|
||||
CollisionBody* body2;
|
||||
|
||||
/// Return the pair of bodies index
|
||||
bodyindexpair getBodiesIndexPair() const {
|
||||
|
||||
// Construct the pair of body index
|
||||
bodyindexpair indexPair = body1->getID() < body2->getID() ?
|
||||
std::make_pair(body1->getID(), body2->getID()) :
|
||||
std::make_pair(body2->getID(), body1->getID());
|
||||
|
||||
assert(indexPair.first != indexPair.second);
|
||||
return indexPair;
|
||||
}
|
||||
};
|
||||
|
||||
// Class PairManager
|
||||
/**
|
||||
* This class is a data-structure contains the pairs of bodies that
|
||||
* are overlapping during the broad-phase collision detection.
|
||||
* This class implements the pair manager described by Pierre Terdiman
|
||||
* in www.codercorner.com/SAP.pdf.
|
||||
*/
|
||||
class PairManager {
|
||||
|
||||
private :
|
||||
|
||||
// -------------------- Attributes -------------------- //
|
||||
|
||||
/// Number of elements in the hash table
|
||||
bodyindex mNbElementsHashTable;
|
||||
|
||||
/// Hash mask for the hash function
|
||||
uint mHashMask;
|
||||
|
||||
/// Number of overlapping pairs
|
||||
bodyindex mNbOverlappingPairs;
|
||||
|
||||
/// Hash table that contains the offset of the first pair of the list of
|
||||
/// pairs with the same hash value in the "overlappingPairs" array
|
||||
bodyindex* mHashTable;
|
||||
|
||||
/// Array that contains for each offset, the offset of the next pair with
|
||||
/// the same hash value for a given same hash value
|
||||
bodyindex* mOffsetNextPair;
|
||||
|
||||
/// Array that contains the overlapping pairs
|
||||
BodyPair* mOverlappingPairs;
|
||||
|
||||
/// Invalid ID
|
||||
static bodyindex INVALID_INDEX;
|
||||
|
||||
/// Reference to the collision detection
|
||||
CollisionDetection& mCollisionDetection;
|
||||
|
||||
// -------------------- Methods -------------------- //
|
||||
|
||||
/// Private copy-constructor
|
||||
PairManager(const PairManager& pairManager);
|
||||
|
||||
/// Private assignment operator
|
||||
PairManager& operator=(const PairManager& pairManager);
|
||||
|
||||
/// Sort the bodies according to their IDs (smallest ID first)
|
||||
void sortBodiesUsingID(CollisionBody*& body1, CollisionBody*& body2) const;
|
||||
|
||||
/// Sort the IDs (smallest ID first)
|
||||
void sortIDs(bodyindex& id1, bodyindex& id2) const;
|
||||
|
||||
/// Return true if pair1 and pair2 are the same
|
||||
bool isDifferentPair(const BodyPair& pair1, bodyindex pair2ID1, bodyindex pair2ID2) const;
|
||||
|
||||
/// Compute the hash value of two bodies using their IDs
|
||||
uint computeHashBodies(uint id1, uint id2) const;
|
||||
|
||||
/// This method returns an hash value for a 32 bits key.
|
||||
int computeHash32Bits(int key) const;
|
||||
|
||||
/// Reallocate memory for more pairs
|
||||
void reallocatePairs();
|
||||
|
||||
/// Shrink the allocated memory
|
||||
void shrinkMemory();
|
||||
|
||||
/// Compute the offset of a given pair
|
||||
bodyindex computePairOffset(const BodyPair* pair) const;
|
||||
|
||||
/// Look for a pair in the set of overlapping pairs
|
||||
BodyPair* lookForAPair(bodyindex id1, bodyindex id2, luint hashValue) const;
|
||||
|
||||
/// Find a pair given two body IDs and an hash value.
|
||||
BodyPair* findPairWithHashValue(bodyindex id1, bodyindex id2, luint hashValue) const;
|
||||
|
||||
/// Remove a pair from the set of active pair
|
||||
void removePairWithHashValue(bodyindex id1, bodyindex id2, luint hashValue,
|
||||
bodyindex indexPair);
|
||||
|
||||
public :
|
||||
|
||||
// ----- Methods ----- //
|
||||
|
||||
/// Constructor
|
||||
PairManager(CollisionDetection& collisionDetection);
|
||||
|
||||
/// Destructor
|
||||
~PairManager();
|
||||
|
||||
/// Return the number of active pairs
|
||||
bodyindex getNbOverlappingPairs() const;
|
||||
|
||||
/// Add a pair of bodies in the pair manager and returns a pointer to that pair.
|
||||
BodyPair* addPair(CollisionBody* body1, CollisionBody* body2);
|
||||
|
||||
/// Remove a pair of bodies from the pair manager.
|
||||
bool removePair(bodyindex id1, bodyindex id2);
|
||||
|
||||
/// Find a pair given two body IDs
|
||||
BodyPair* findPair(bodyindex id1, bodyindex id2) const;
|
||||
|
||||
/// Return the next power of two
|
||||
static luint computeNextPowerOfTwo(luint number);
|
||||
|
||||
/// Return a pointer to the first overlapping pair (used to
|
||||
/// iterate over the active pairs).
|
||||
BodyPair* beginOverlappingPairsPointer() const;
|
||||
|
||||
/// Return a pointer to the last overlapping pair (used to
|
||||
/// iterate over the active pairs).
|
||||
BodyPair* endOverlappingPairsPointer() const;
|
||||
|
||||
/// Register a callback function (using a function pointer) that will be
|
||||
/// called when a new overlapping pair is added in the pair manager.
|
||||
void registerAddedOverlappingPairCallback(void (CollisionDetection::*callbackFunction)
|
||||
(const BodyPair* addedActivePair));
|
||||
|
||||
/// Unregister the callback function that will be called
|
||||
/// when a new active pair is added in the pair manager
|
||||
void unregisterAddedOverlappingPairCallback();
|
||||
|
||||
/// Register a callback function (using a function pointer)
|
||||
/// that will be called when an overlapping pair is removed from the pair manager
|
||||
void registerRemovedOverlappingPairCallback(void (CollisionDetection::*callbackFunction)
|
||||
(const BodyPair* removedActivePair));
|
||||
|
||||
/// Unregister a callback function that will be called
|
||||
/// when a active pair is removed from the pair manager
|
||||
void unregisterRemovedOverlappingPairCallback();
|
||||
};
|
||||
|
||||
// Return the number of overlapping pairs
|
||||
inline bodyindex PairManager::getNbOverlappingPairs() const {
|
||||
return mNbOverlappingPairs;
|
||||
}
|
||||
|
||||
// Compute the hash value of two bodies
|
||||
inline uint PairManager::computeHashBodies(uint id1, uint id2) const {
|
||||
return computeHash32Bits(id1 | (id2 << 16));
|
||||
}
|
||||
|
||||
// Return true if pair1 and pair2 are the same
|
||||
inline bool PairManager::isDifferentPair(const BodyPair& pair1, bodyindex pair2ID1,
|
||||
bodyindex pair2ID2) const {
|
||||
return (pair2ID1 != pair1.body1->getID() || pair2ID2 != pair1.body2->getID());
|
||||
}
|
||||
|
||||
// Return the next power of two of a 32bits integer using a SWAR algorithm
|
||||
inline luint PairManager::computeNextPowerOfTwo(luint number) {
|
||||
number |= (number >> 1);
|
||||
number |= (number >> 2);
|
||||
number |= (number >> 4);
|
||||
number |= (number >> 8);
|
||||
number |= (number >> 16);
|
||||
return number+1;
|
||||
}
|
||||
|
||||
// Sort the bodies according to their IDs (smallest ID first)
|
||||
inline void PairManager::sortBodiesUsingID(CollisionBody*& body1, CollisionBody*& body2) const {
|
||||
|
||||
// If the ID of body1 is larger than the ID of body 2
|
||||
if (body1->getID() > body2->getID()) {
|
||||
|
||||
// Swap the two bodies pointers
|
||||
CollisionBody* temp = body2;
|
||||
body2 = body1;
|
||||
body1 = temp;
|
||||
}
|
||||
}
|
||||
|
||||
// Sort the IDs (smallest ID first)
|
||||
inline void PairManager::sortIDs(bodyindex &id1, bodyindex &id2) const {
|
||||
if (id1 > id2) {
|
||||
bodyindex temp = id2;
|
||||
id2 = id1;
|
||||
id1 = temp;
|
||||
}
|
||||
}
|
||||
|
||||
// This method returns an hash value for a 32 bits key.
|
||||
/// using Thomas Wang's hash technique.
|
||||
/// This hash function can be found at :
|
||||
/// http://www.concentric.net/~ttwang/tech/inthash.htm
|
||||
inline int PairManager::computeHash32Bits(int key) const {
|
||||
key += ~(key << 15);
|
||||
key ^= (key >> 10);
|
||||
key += (key << 3);
|
||||
key ^= (key >> 6);
|
||||
key += ~(key << 11);
|
||||
key ^= (key >> 16);
|
||||
return key;
|
||||
}
|
||||
|
||||
// Find a pair given two body IDs
|
||||
inline BodyPair* PairManager::findPair(bodyindex id1, bodyindex id2) const {
|
||||
|
||||
// Check if the hash table has been allocated yet
|
||||
if (mHashTable == NULL) return NULL;
|
||||
|
||||
// Sort the IDs
|
||||
sortIDs(id1, id2);
|
||||
|
||||
// Compute the hash value of the pair to find
|
||||
uint hashValue = computeHashBodies(id1, id2) & mHashMask;
|
||||
|
||||
// Look for the pair in the set of overlapping pairs
|
||||
return lookForAPair(id1, id2, hashValue);
|
||||
}
|
||||
|
||||
// Find a pair given two body IDs and an hash value.
|
||||
/// This internal version is used to avoid computing multiple times in the
|
||||
/// caller method
|
||||
inline BodyPair* PairManager::findPairWithHashValue(bodyindex id1, bodyindex id2,
|
||||
luint hashValue) const {
|
||||
|
||||
// Check if the hash table has been allocated yet
|
||||
if (mHashTable == NULL) return NULL;
|
||||
|
||||
// Look for the pair in the set of overlapping pairs
|
||||
return lookForAPair(id1, id2, hashValue);
|
||||
}
|
||||
|
||||
// Try to reduce the allocated memory by the pair manager
|
||||
inline void PairManager::shrinkMemory() {
|
||||
|
||||
// Check if the allocated memory can be reduced
|
||||
const bodyindex correctNbElementsHashTable = computeNextPowerOfTwo(mNbOverlappingPairs);
|
||||
if (mNbElementsHashTable == correctNbElementsHashTable) return;
|
||||
|
||||
// Reduce the allocated memory
|
||||
mNbElementsHashTable = correctNbElementsHashTable;
|
||||
mHashMask = mNbElementsHashTable - 1;
|
||||
reallocatePairs();
|
||||
}
|
||||
|
||||
// Compute the offset of a given pair in the array of overlapping pairs
|
||||
inline bodyindex PairManager::computePairOffset(const BodyPair* pair) const {
|
||||
return ((bodyindex)((size_t(pair) - size_t(mOverlappingPairs))) / sizeof(BodyPair));
|
||||
}
|
||||
|
||||
// Return a pointer to the first overlapping pair (used to iterate over the overlapping pairs) or
|
||||
// returns 0 if there is no overlapping pairs.
|
||||
inline BodyPair* PairManager::beginOverlappingPairsPointer() const {
|
||||
return &mOverlappingPairs[0];
|
||||
}
|
||||
|
||||
// Return a pointer to the last overlapping pair (used to iterate over the overlapping pairs) or
|
||||
// returns 0 if there is no overlapping pairs.
|
||||
inline BodyPair* PairManager::endOverlappingPairsPointer() const {
|
||||
if (mNbOverlappingPairs > 0) {
|
||||
return &mOverlappingPairs[mNbOverlappingPairs-1];
|
||||
}
|
||||
else {
|
||||
return &mOverlappingPairs[0];
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
|
@ -29,7 +29,6 @@
|
|||
// Libraries
|
||||
#include "body/Body.h"
|
||||
#include "constraint/ContactPoint.h"
|
||||
#include "collision/broadphase/PairManager.h"
|
||||
#include "memory/MemoryAllocator.h"
|
||||
#include "engine/OverlappingPair.h"
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user