SubShapeID.h

Go to the documentation of this file.

// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
// SPDX-License-Identifier: MIT
 
#pragma once
 
JPH_NAMESPACE_BEGIN
 
class SubShapeID
{
public:
    JPH_OVERRIDE_NEW_DELETE
 
    using Type = uint32;
 
    using BiggerType = uint64;
 
    static_assert(sizeof(BiggerType) > sizeof(Type), "The calculation below assumes BiggerType is a bigger type than Type");
 
    static constexpr uint MaxBits = 8 * sizeof(Type);
 
                        SubShapeID() = default;
 
    Type                PopID(uint inBits, SubShapeID &outRemainder) const
    {
        Type mask_bits = Type((BiggerType(1) << inBits) - 1);
        Type fill_bits = Type(BiggerType(cEmpty) << (MaxBits - inBits)); // Fill left side bits with 1 so that if there's no remainder all bits will be set, note that we do this using a BiggerType since on intel 0xffffffff << 32 == 0xffffffff
        Type v = mValue & mask_bits;
        outRemainder = SubShapeID(Type(BiggerType(mValue) >> inBits) | fill_bits);
        return v;
    }
 
    inline Type         GetValue() const
    {
        return mValue;
    }
 
    inline void         SetValue(Type inValue)
    {
        mValue = inValue;
    }
 
    inline bool         IsEmpty() const
    {
        return mValue == cEmpty;
    }
 
    inline bool         operator == (const SubShapeID &inRHS) const
    {
        return mValue == inRHS.mValue;
    }
 
    inline bool         operator != (const SubShapeID &inRHS) const
    {
        return mValue != inRHS.mValue;
    }
 
private:
    friend class SubShapeIDCreator;
 
    static constexpr Type cEmpty = ~Type(0);
 
    explicit            SubShapeID(const Type &inValue) : mValue(inValue) { }
 
    void                PushID(Type inValue, uint inFirstBit, uint inBits)
    {
        // First clear the bits
        mValue &= ~(Type((BiggerType(1) << inBits) - 1) << inFirstBit);
 
        // Then set them to the new value
        mValue |= inValue << inFirstBit;
    }
 
    Type                mValue = cEmpty;
};
 
class SubShapeIDCreator
{
public:
    SubShapeIDCreator   PushID(uint inValue, uint inBits) const
    {
        JPH_ASSERT(inValue < (SubShapeID::BiggerType(1) << inBits));
        SubShapeIDCreator copy = *this;
        copy.mID.PushID(inValue, mCurrentBit, inBits);
        copy.mCurrentBit += inBits;
        JPH_ASSERT(copy.mCurrentBit <= SubShapeID::MaxBits);
        return copy;
    }
 
    // Get the resulting sub shape ID
    const SubShapeID &  GetID() const
    {
        return mID;
    }
 
    inline uint         GetNumBitsWritten() const
    {
        return mCurrentBit;
    }
 
private:
    SubShapeID          mID;
    uint                mCurrentBit = 0;
};
 
JPH_NAMESPACE_END