102 lines
3 KiB
C++
102 lines
3 KiB
C++
// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
|
|
// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
|
|
// SPDX-License-Identifier: MIT
|
|
|
|
#pragma once
|
|
|
|
#include <Jolt/Core/HashCombine.h>
|
|
|
|
JPH_NAMESPACE_BEGIN
|
|
|
|
/// ID of a body. This is a way of reasoning about bodies in a multithreaded simulation while avoiding race conditions.
|
|
class BodyID
|
|
{
|
|
public:
|
|
JPH_OVERRIDE_NEW_DELETE
|
|
|
|
static constexpr uint32 cInvalidBodyID = 0xffffffff; ///< The value for an invalid body ID
|
|
static constexpr uint32 cBroadPhaseBit = 0x80000000; ///< This bit is used by the broadphase
|
|
static constexpr uint32 cMaxBodyIndex = 0x7fffff; ///< Maximum value for body index (also the maximum amount of bodies supported - 1)
|
|
static constexpr uint8 cMaxSequenceNumber = 0xff; ///< Maximum value for the sequence number
|
|
static constexpr uint cSequenceNumberShift = 23; ///< Number of bits to shift to get the sequence number
|
|
|
|
/// Construct invalid body ID
|
|
BodyID() :
|
|
mID(cInvalidBodyID)
|
|
{
|
|
}
|
|
|
|
/// Construct from index and sequence number combined in a single uint32 (use with care!)
|
|
explicit BodyID(uint32 inID) :
|
|
mID(inID)
|
|
{
|
|
JPH_ASSERT((inID & cBroadPhaseBit) == 0 || inID == cInvalidBodyID); // Check bit used by broadphase
|
|
}
|
|
|
|
/// Construct from index and sequence number
|
|
explicit BodyID(uint32 inID, uint8 inSequenceNumber) :
|
|
mID((uint32(inSequenceNumber) << cSequenceNumberShift) | inID)
|
|
{
|
|
JPH_ASSERT(inID <= cMaxBodyIndex); // Should not overlap with broadphase bit or sequence number
|
|
}
|
|
|
|
/// Get index in body array
|
|
inline uint32 GetIndex() const
|
|
{
|
|
return mID & cMaxBodyIndex;
|
|
}
|
|
|
|
/// Get sequence number of body.
|
|
/// The sequence number can be used to check if a body ID with the same body index has been reused by another body.
|
|
/// It is mainly used in multi threaded situations where a body is removed and its body index is immediately reused by a body created from another thread.
|
|
/// Functions querying the broadphase can (after acquiring a body lock) detect that the body has been removed (we assume that this won't happen more than 128 times in a row).
|
|
inline uint8 GetSequenceNumber() const
|
|
{
|
|
return uint8(mID >> cSequenceNumberShift);
|
|
}
|
|
|
|
/// Returns the index and sequence number combined in an uint32
|
|
inline uint32 GetIndexAndSequenceNumber() const
|
|
{
|
|
return mID;
|
|
}
|
|
|
|
/// Check if the ID is valid
|
|
inline bool IsInvalid() const
|
|
{
|
|
return mID == cInvalidBodyID;
|
|
}
|
|
|
|
/// Equals check
|
|
inline bool operator == (const BodyID &inRHS) const
|
|
{
|
|
return mID == inRHS.mID;
|
|
}
|
|
|
|
/// Not equals check
|
|
inline bool operator != (const BodyID &inRHS) const
|
|
{
|
|
return mID != inRHS.mID;
|
|
}
|
|
|
|
/// Smaller than operator, can be used for sorting bodies
|
|
inline bool operator < (const BodyID &inRHS) const
|
|
{
|
|
return mID < inRHS.mID;
|
|
}
|
|
|
|
/// Greater than operator, can be used for sorting bodies
|
|
inline bool operator > (const BodyID &inRHS) const
|
|
{
|
|
return mID > inRHS.mID;
|
|
}
|
|
|
|
private:
|
|
uint32 mID;
|
|
};
|
|
|
|
JPH_NAMESPACE_END
|
|
|
|
// Create a std::hash/JPH::Hash for BodyID
|
|
JPH_MAKE_HASHABLE(JPH::BodyID, t.GetIndexAndSequenceNumber())
|