IslandBuilder.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/Body/BodyID.h>
#include <Jolt/Core/NonCopyable.h>
#include <Jolt/Core/Atomics.h>
 
JPH_NAMESPACE_BEGIN
 
class TempAllocator;
 
//#define JPH_VALIDATE_ISLAND_BUILDER
 
class JPH_EXPORT IslandBuilder : public NonCopyable
{
public:
                            ~IslandBuilder();
 
    void                    Init(uint32 inMaxActiveBodies);
 
    void                    PrepareContactConstraints(uint32 inMaxContactConstraints, TempAllocator *inTempAllocator);
 
    void                    PrepareNonContactConstraints(uint32 inNumConstraints, TempAllocator *inTempAllocator);
 
    void                    LinkBodies(uint32 inFirst, uint32 inSecond);
 
    void                    LinkConstraint(uint32 inConstraintIndex, uint32 inFirst, uint32 inSecond);
 
    void                    LinkContact(uint32 inContactIndex, uint32 inFirst, uint32 inSecond);
 
    void                    Finalize(const BodyID *inActiveBodies, uint32 inNumActiveBodies, uint32 inNumContacts, TempAllocator *inTempAllocator);
 
    uint32                  GetNumIslands() const                           { return mNumIslands; }
 
    void                    GetBodiesInIsland(uint32 inIslandIndex, BodyID *&outBodiesBegin, BodyID *&outBodiesEnd) const;
    bool                    GetConstraintsInIsland(uint32 inIslandIndex, uint32 *&outConstraintsBegin, uint32 *&outConstraintsEnd) const;
    bool                    GetContactsInIsland(uint32 inIslandIndex, uint32 *&outContactsBegin, uint32 *&outContactsEnd) const;
 
    void                    SetNumPositionSteps(uint32 inIslandIndex, uint inNumPositionSteps)  { JPH_ASSERT(inIslandIndex < mNumIslands); JPH_ASSERT(inNumPositionSteps < 256); mNumPositionSteps[inIslandIndex] = uint8(inNumPositionSteps); }
    uint                    GetNumPositionSteps(uint32 inIslandIndex) const                     { JPH_ASSERT(inIslandIndex < mNumIslands); return mNumPositionSteps[inIslandIndex]; }
 
#ifdef JPH_TRACK_SIMULATION_STATS
    struct IslandStats
    {
        atomic<uint64>      mVelocityConstraintTicks = 0;
        atomic<uint64>      mPositionConstraintTicks = 0;
        atomic<uint64>      mUpdateBoundsTicks = 0;
        uint8               mNumVelocitySteps = 0;
        uint8               mNumPositionSteps = 0;                                              
        bool                mIsLargeIsland = false;
    };
 
    IslandStats &           GetIslandStats(uint32 inIslandIndex)                                { return mIslandStats[inIslandIndex]; }
#endif
 
    void                    ResetIslands(TempAllocator *inTempAllocator);
 
private:
    uint32                  GetLowestBodyIndex(uint32 inActiveBodyIndex) const;
 
#ifdef JPH_VALIDATE_ISLAND_BUILDER
    void                    ValidateIslands(uint32 inNumActiveBodies) const;
#endif
 
    // Helper functions to build various islands
    void                    BuildBodyIslands(const BodyID *inActiveBodies, uint32 inNumActiveBodies, TempAllocator *inTempAllocator);
    void                    BuildConstraintIslands(const uint32 *inConstraintToBody, uint32 inNumConstraints, uint32 *&outConstraints, uint32 *&outConstraintsEnd, TempAllocator *inTempAllocator) const;
 
    void                    SortIslands(TempAllocator *inTempAllocator);
 
    struct BodyLink
    {
        JPH_OVERRIDE_NEW_DELETE
 
        atomic<uint32>      mLinkedTo;                                      
        uint32              mIslandIndex;                                   
    };
 
    // Intermediate data
    BodyLink *              mBodyLinks = nullptr;                           
    uint32 *                mConstraintLinks = nullptr;                     
    uint32 *                mContactLinks = nullptr;                        
 
    // Final data
    BodyID *                mBodyIslands = nullptr;                         
    uint32 *                mBodyIslandEnds = nullptr;                      
 
    uint32 *                mConstraintIslands = nullptr;                   
    uint32 *                mConstraintIslandEnds = nullptr;                
 
    uint32 *                mContactIslands = nullptr;                      
    uint32 *                mContactIslandEnds = nullptr;                   
 
    uint32 *                mIslandsSorted = nullptr;                       
 
    uint8 *                 mNumPositionSteps = nullptr;                    
 
#ifdef JPH_TRACK_SIMULATION_STATS
    IslandStats *           mIslandStats = nullptr;                         
#endif
 
    // Counters
    uint32                  mMaxActiveBodies;                               
    uint32                  mNumActiveBodies = 0;                           
    uint32                  mNumConstraints = 0;                            
    uint32                  mMaxContacts = 0;                               
    uint32                  mNumContacts = 0;                               
    uint32                  mNumIslands = 0;                                
 
#ifdef JPH_VALIDATE_ISLAND_BUILDER
    struct LinkValidation
    {
        uint32              mFirst;
        uint32              mSecond;
    };
 
    LinkValidation *        mLinkValidation = nullptr;
    atomic<uint32>          mNumLinkValidation;
#endif
};
 
JPH_NAMESPACE_END