SoftBodyMotionProperties.h

Go to the documentation of this file.

// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
// SPDX-FileCopyrightText: 2023 Jorrit Rouwe
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include <Jolt/Geometry/AABox.h>
#include <Jolt/Physics/Body/BodyID.h>
#include <Jolt/Physics/Body/MotionProperties.h>
#include <Jolt/Physics/Collision/TransformedShape.h>
#include <Jolt/Physics/SoftBody/SoftBodySharedSettings.h>
#include <Jolt/Physics/SoftBody/SoftBodyVertex.h>
#include <Jolt/Physics/SoftBody/SoftBodyUpdateContext.h>
 
JPH_NAMESPACE_BEGIN
 
class PhysicsSystem;
class BodyInterface;
class BodyLockInterface;
struct PhysicsSettings;
class Body;
class Shape;
class SoftBodyCreationSettings;
class TempAllocator;
#ifdef JPH_DEBUG_RENDERER
class DebugRenderer;
enum class ESoftBodyConstraintColor;
#endif // JPH_DEBUG_RENDERER
 
//
// Based on: XPBD, Extended Position Based Dynamics, Matthias Muller, Ten Minute Physics
// See: https://matthias-research.github.io/pages/tenMinutePhysics/09-xpbd.pdf
class JPH_EXPORT SoftBodyMotionProperties : public MotionProperties
{
public:
    using Vertex = SoftBodyVertex;
    using Edge = SoftBodySharedSettings::Edge;
    using Face = SoftBodySharedSettings::Face;
    using DihedralBend = SoftBodySharedSettings::DihedralBend;
    using Volume = SoftBodySharedSettings::Volume;
    using InvBind = SoftBodySharedSettings::InvBind;
    using SkinWeight = SoftBodySharedSettings::SkinWeight;
    using Skinned = SoftBodySharedSettings::Skinned;
    using LRA = SoftBodySharedSettings::LRA;
 
    void                                Initialize(const SoftBodyCreationSettings &inSettings);
 
    const SoftBodySharedSettings *      GetSettings() const                         { return mSettings; }
 
    const Array<Vertex> &               GetVertices() const                         { return mVertices; }
    Array<Vertex> &                     GetVertices()                               { return mVertices; }
 
    const Vertex &                      GetVertex(uint inIndex) const               { return mVertices[inIndex]; }
    Vertex &                            GetVertex(uint inIndex)                     { return mVertices[inIndex]; }
 
    const PhysicsMaterialList &         GetMaterials() const                        { return mSettings->mMaterials; }
 
    const Array<Face> &                 GetFaces() const                            { return mSettings->mFaces; }
 
    const Face &                        GetFace(uint inIndex) const                 { return mSettings->mFaces[inIndex]; }
 
    uint32                              GetNumIterations() const                    { return mNumIterations; }
    void                                SetNumIterations(uint32 inNumIterations)    { mNumIterations = inNumIterations; }
 
    float                               GetPressure() const                         { return mPressure; }
    void                                SetPressure(float inPressure)               { mPressure = inPressure; }
 
    bool                                GetUpdatePosition() const                   { return mUpdatePosition; }
    void                                SetUpdatePosition(bool inUpdatePosition)    { mUpdatePosition = inUpdatePosition; }
 
    bool                                GetEnableSkinConstraints() const            { return mEnableSkinConstraints; }
    void                                SetEnableSkinConstraints(bool inEnableSkinConstraints) { mEnableSkinConstraints = inEnableSkinConstraints; }
 
    float                               GetSkinnedMaxDistanceMultiplier() const     { return mSkinnedMaxDistanceMultiplier; }
    void                                SetSkinnedMaxDistanceMultiplier(float inSkinnedMaxDistanceMultiplier) { mSkinnedMaxDistanceMultiplier = inSkinnedMaxDistanceMultiplier; }
 
    const AABox &                       GetLocalBounds() const                      { return mLocalBounds; }
 
    float                               GetVolume() const                           { return GetVolumeTimesSix() / 6.0f; }
 
    void                                CalculateMassAndInertia();
 
#ifdef JPH_DEBUG_RENDERER
    void                                DrawVertices(DebugRenderer *inRenderer, RMat44Arg inCenterOfMassTransform) const;
    void                                DrawVertexVelocities(DebugRenderer *inRenderer, RMat44Arg inCenterOfMassTransform) const;
    void                                DrawEdgeConstraints(DebugRenderer *inRenderer, RMat44Arg inCenterOfMassTransform, ESoftBodyConstraintColor inConstraintColor) const;
    void                                DrawBendConstraints(DebugRenderer *inRenderer, RMat44Arg inCenterOfMassTransform, ESoftBodyConstraintColor inConstraintColor) const;
    void                                DrawVolumeConstraints(DebugRenderer *inRenderer, RMat44Arg inCenterOfMassTransform, ESoftBodyConstraintColor inConstraintColor) const;
    void                                DrawSkinConstraints(DebugRenderer *inRenderer, RMat44Arg inCenterOfMassTransform, ESoftBodyConstraintColor inConstraintColor) const;
    void                                DrawLRAConstraints(DebugRenderer *inRenderer, RMat44Arg inCenterOfMassTransform, ESoftBodyConstraintColor inConstraintColor) const;
    void                                DrawPredictedBounds(DebugRenderer *inRenderer, RMat44Arg inCenterOfMassTransform) const;
#endif // JPH_DEBUG_RENDERER
 
    void                                SaveState(StateRecorder &inStream) const;
 
    void                                RestoreState(StateRecorder &inStream);
 
    void                                SkinVertices(RMat44Arg inCenterOfMassTransform, const Mat44 *inJointMatrices, uint inNumJoints, bool inHardSkinAll, TempAllocator &ioTempAllocator);
 
    void                                CustomUpdate(float inDeltaTime, Body &ioSoftBody, PhysicsSystem &inSystem);
 
    // FUNCTIONS BELOW THIS LINE ARE FOR INTERNAL USE ONLY
 
    void                                InitializeUpdateContext(float inDeltaTime, Body &inSoftBody, const PhysicsSystem &inSystem, SoftBodyUpdateContext &ioContext);
 
    void                                DetermineCollidingShapes(const SoftBodyUpdateContext &inContext, const PhysicsSystem &inSystem, const BodyLockInterface &inBodyLockInterface);
 
    enum class EStatus
    {
        NoWork  = 1 << 0,               
        DidWork = 1 << 1,               
        Done    = 1 << 2,               
    };
 
    EStatus                             ParallelUpdate(SoftBodyUpdateContext &ioContext, const PhysicsSettings &inPhysicsSettings);
 
    void                                UpdateRigidBodyVelocities(const SoftBodyUpdateContext &inContext, BodyInterface &inBodyInterface);
 
private:
    // SoftBodyManifold needs to have access to CollidingShape
    friend class SoftBodyManifold;
 
    // Information about a leaf shape that we're colliding with
    struct LeafShape
    {
                                        LeafShape() = default;
                                        LeafShape(Mat44Arg inTransform, Vec3Arg inScale, const Shape *inShape) : mTransform(inTransform), mScale(inScale), mShape(inShape) { }
 
        Mat44                           mTransform;                                 
        Vec3                            mScale;                                     
        RefConst<Shape>                 mShape;                                     
    };
 
    // Collect information about the colliding bodies
    struct CollidingShape
    {
        Vec3                            GetPointVelocity(Vec3Arg inPointRelativeToCOM) const
        {
            return mLinearVelocity + mAngularVelocity.Cross(inPointRelativeToCOM);
        }
 
        Mat44                           mCenterOfMassTransform;                     
        Array<LeafShape>                mShapes;                                    
        BodyID                          mBodyID;                                    
        EMotionType                     mMotionType;                                
        float                           mInvMass;                                   
        float                           mFriction;                                  
        float                           mRestitution;                               
        float                           mSoftBodyInvMassScale;                      
        bool                            mUpdateVelocities;                          
        Mat44                           mInvInertia;                                
        Vec3                            mLinearVelocity;                            
        Vec3                            mAngularVelocity;                           
        Vec3                            mOriginalLinearVelocity;                    
        Vec3                            mOriginalAngularVelocity;                   
    };
 
    // Collect information about the colliding sensors
    struct CollidingSensor
    {
        Mat44                           mCenterOfMassTransform;                     
        Array<LeafShape>                mShapes;                                    
        BodyID                          mBodyID;                                    
        bool                            mHasContact;                                
    };
 
    // Information about the state of all skinned vertices
    struct SkinState
    {
        Vec3                            mPreviousPosition = Vec3::sZero();          
        Vec3                            mPosition = Vec3::sNaN();                   
        Vec3                            mNormal = Vec3::sNaN();                     
    };
 
    void                                DetermineCollisionPlanes(uint inVertexStart, uint inNumVertices);
 
    void                                DetermineSensorCollisions(CollidingSensor &ioSensor);
 
    void                                ApplyPressure(const SoftBodyUpdateContext &inContext);
 
    void                                IntegratePositions(const SoftBodyUpdateContext &inContext);
 
    void                                ApplyDihedralBendConstraints(const SoftBodyUpdateContext &inContext, uint inStartIndex, uint inEndIndex);
 
    void                                ApplyVolumeConstraints(const SoftBodyUpdateContext &inContext, uint inStartIndex, uint inEndIndex);
 
    void                                ApplySkinConstraints(const SoftBodyUpdateContext &inContext, uint inStartIndex, uint inEndIndex);
 
    void                                ApplyEdgeConstraints(const SoftBodyUpdateContext &inContext, uint inStartIndex, uint inEndIndex);
 
    void                                ApplyLRAConstraints(uint inStartIndex, uint inEndIndex);
 
    void                                ApplyCollisionConstraintsAndUpdateVelocities(const SoftBodyUpdateContext &inContext);
 
    void                                UpdateSoftBodyState(SoftBodyUpdateContext &ioContext, const PhysicsSettings &inPhysicsSettings);
 
    void                                StartFirstIteration(SoftBodyUpdateContext &ioContext);
 
    void                                StartNextIteration(const SoftBodyUpdateContext &ioContext);
 
    EStatus                             ParallelDetermineCollisionPlanes(SoftBodyUpdateContext &ioContext);
 
    EStatus                             ParallelDetermineSensorCollisions(SoftBodyUpdateContext &ioContext);
 
    EStatus                             ParallelApplyConstraints(SoftBodyUpdateContext &ioContext, const PhysicsSettings &inPhysicsSettings);
 
    void                                ProcessGroup(const SoftBodyUpdateContext &ioContext, uint inGroupIndex);
 
    float                               GetVolumeTimesSix() const;
 
#ifdef JPH_DEBUG_RENDERER
    template <typename GetEndIndex, typename DrawConstraint>
        inline void                     DrawConstraints(ESoftBodyConstraintColor inConstraintColor, const GetEndIndex &inGetEndIndex, const DrawConstraint &inDrawConstraint, ColorArg inBaseColor) const;
 
    RMat44                              mSkinStateTransform = RMat44::sIdentity();  
#endif // JPH_DEBUG_RENDERER
 
    RefConst<SoftBodySharedSettings>    mSettings;                                  
    Array<Vertex>                       mVertices;                                  
    Array<CollidingShape>               mCollidingShapes;                           
    Array<CollidingSensor>              mCollidingSensors;                          
    Array<SkinState>                    mSkinState;                                 
    AABox                               mLocalBounds;                               
    AABox                               mLocalPredictedBounds;                      
    uint32                              mNumIterations;                             
    float                               mPressure;                                  
    float                               mSkinnedMaxDistanceMultiplier = 1.0f;       
    bool                                mUpdatePosition;                            
    bool                                mNeedContactCallback = false;                       
    bool                                mEnableSkinConstraints = true;              
    bool                                mSkinStatePreviousPositionValid = false;    
};
 
JPH_NAMESPACE_END