GroupFilterTable.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
 
#include <Jolt/Physics/Collision/GroupFilter.h>
#include <Jolt/Physics/Collision/CollisionGroup.h>
 
JPH_NAMESPACE_BEGIN
 
class JPH_EXPORT GroupFilterTable final : public GroupFilter
{
    JPH_DECLARE_SERIALIZABLE_VIRTUAL(JPH_EXPORT, GroupFilterTable)
 
private:
    using GroupID = CollisionGroup::GroupID;
    using SubGroupID = CollisionGroup::SubGroupID;
 
    int                     GetBit(SubGroupID inSubGroup1, SubGroupID inSubGroup2) const
    {
        JPH_ASSERT(inSubGroup1 != inSubGroup2);
 
        // We store the lower left half only, so swap the inputs when trying to access the top right half
        if (inSubGroup1 > inSubGroup2)
            std::swap(inSubGroup1, inSubGroup2);
 
        JPH_ASSERT(inSubGroup2 < mNumSubGroups);
 
        // Calculate at which bit the entry for this pair resides
        // We use the fact that a row always starts at inSubGroup2 * (inSubGroup2 - 1) / 2
        // (this is the amount of bits needed to store a table of inSubGroup2 entries)
        return (inSubGroup2 * (inSubGroup2 - 1)) / 2 + inSubGroup1;
    }
 
public:
    explicit                GroupFilterTable(uint inNumSubGroups = 0) :
        mNumSubGroups(inNumSubGroups)
    {
        // By default everything collides
        int table_size = ((inNumSubGroups * (inNumSubGroups - 1)) / 2 + 7) / 8;
        mTable.resize(table_size, 0xff);
    }
 
                            GroupFilterTable(const GroupFilterTable &inRHS) : mNumSubGroups(inRHS.mNumSubGroups), mTable(inRHS.mTable) { }
 
    void                    DisableCollision(SubGroupID inSubGroup1, SubGroupID inSubGroup2)
    {
        int bit = GetBit(inSubGroup1, inSubGroup2);
        mTable[bit >> 3] &= (0xff ^ (1 << (bit & 0b111)));
    }
 
    void                    EnableCollision(SubGroupID inSubGroup1, SubGroupID inSubGroup2)
    {
        int bit = GetBit(inSubGroup1, inSubGroup2);
        mTable[bit >> 3] |= 1 << (bit & 0b111);
    }
 
    inline bool             IsCollisionEnabled(SubGroupID inSubGroup1, SubGroupID inSubGroup2) const
    {
        // Test if the bit is set for this group pair
        int bit = GetBit(inSubGroup1, inSubGroup2);
        return (mTable[bit >> 3] & (1 << (bit & 0b111))) != 0;
    }
 
    virtual bool            CanCollide(const CollisionGroup &inGroup1, const CollisionGroup &inGroup2) const override
    {
        // If one of the groups is cInvalidGroup the objects will collide (note that the if following this if will ensure that group2 is not cInvalidGroup)
        if (inGroup1.GetGroupID() == CollisionGroup::cInvalidGroup)
            return true;
 
        // If the objects are in different groups, they collide
        if (inGroup1.GetGroupID() != inGroup2.GetGroupID())
            return true;
 
        // If the collision filters do not match, but they're in the same group we ignore the collision
        if (inGroup1.GetGroupFilter() != inGroup2.GetGroupFilter())
            return false;
 
        // If they are in the same sub group, they don't collide
        if (inGroup1.GetSubGroupID() == inGroup2.GetSubGroupID())
            return false;
 
        // Check the bit table
        return IsCollisionEnabled(inGroup1.GetSubGroupID(), inGroup2.GetSubGroupID());
    }
 
    // See: GroupFilter::SaveBinaryState
    virtual void            SaveBinaryState(StreamOut &inStream) const override;
 
protected:
    // See: GroupFilter::RestoreBinaryState
    virtual void            RestoreBinaryState(StreamIn &inStream) override;
 
private:
    uint                    mNumSubGroups;                                  
    Array<uint8>            mTable;                                         
};
 
JPH_NAMESPACE_END