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/SoftBody/SoftBodySharedSettings.h>
#include <Jolt/Physics/SoftBody/SoftBodyVertex.h>
#include <Jolt/Physics/SoftBody/SoftBodyUpdateContext.h>
 
JPH_NAMESPACE_BEGIN
 
class PhysicsSystem;
struct PhysicsSettings;
class Body;
class Shape;
class SoftBodyCreationSettings;
#ifdef JPH_DEBUG_RENDERER
class DebugRenderer;
#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 Volume = SoftBodySharedSettings::Volume;
 
    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; }
 
    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                                DrawEdgeConstraints(DebugRenderer *inRenderer, RMat44Arg inCenterOfMassTransform) const;
    void                                DrawVolumeConstraints(DebugRenderer *inRenderer, RMat44Arg inCenterOfMassTransform) const;
    void                                DrawPredictedBounds(DebugRenderer *inRenderer, RMat44Arg inCenterOfMassTransform) const;
#endif // JPH_DEBUG_RENDERER
 
    void                                SaveState(StateRecorder &inStream) const;
 
    void                                RestoreState(StateRecorder &inStream);
 
    void                                InitializeUpdateContext(float inDeltaTime, Body &inSoftBody, const PhysicsSystem &inSystem, SoftBodyUpdateContext &ioContext);
 
    void                                DetermineCollidingShapes(const SoftBodyUpdateContext &inContext, const PhysicsSystem &inSystem);
 
    enum class EStatus
    {
        NoWork  = 1 << 0,               
        DidWork = 1 << 1,               
        Done    = 1 << 2,               
    };
 
    EStatus                             ParallelUpdate(SoftBodyUpdateContext &ioContext, const PhysicsSettings &inPhysicsSettings);
 
    void                                UpdateRigidBodyVelocities(const SoftBodyUpdateContext &inContext, PhysicsSystem &inSystem);
 
private:
    // Collect information about the colliding bodies
    struct CollidingShape
    {
        Vec3            GetPointVelocity(Vec3Arg inPointRelativeToCOM) const
        {
            return mLinearVelocity + mAngularVelocity.Cross(inPointRelativeToCOM);
        }
 
        Mat44                           mCenterOfMassTransform;                     
        RefConst<Shape>                 mShape;                                     
        BodyID                          mBodyID;                                    
        EMotionType                     mMotionType;                                
        float                           mInvMass;                                   
        float                           mFriction;                                  
        float                           mRestitution;                               
        bool                            mUpdateVelocities;                          
        Mat44                           mInvInertia;                                
        Vec3                            mLinearVelocity;                            
        Vec3                            mAngularVelocity;                           
        Vec3                            mOriginalLinearVelocity;                    
        Vec3                            mOriginalAngularVelocity;                   
    };
 
    void                                DetermineCollisionPlanes(const SoftBodyUpdateContext &inContext, uint inVertexStart, uint inNumVertices);
 
    void                                ApplyPressure(const SoftBodyUpdateContext &inContext);
 
    void                                IntegratePositions(const SoftBodyUpdateContext &inContext);
 
    void                                ApplyVolumeConstraints(const SoftBodyUpdateContext &inContext);
 
    void                                ApplyEdgeConstraints(const SoftBodyUpdateContext &inContext, uint inStartIndex, uint inEndIndex);
 
    void                                ApplyCollisionConstraintsAndUpdateVelocities(const SoftBodyUpdateContext &inContext);
 
    void                                UpdateSoftBodyState(SoftBodyUpdateContext &ioContext, const PhysicsSettings &inPhysicsSettings);
 
    void                                StartNextIteration(const SoftBodyUpdateContext &ioContext);
 
    EStatus                             ParallelDetermineCollisionPlanes(SoftBodyUpdateContext &ioContext);
 
    EStatus                             ParallelApplyEdgeConstraints(SoftBodyUpdateContext &ioContext, const PhysicsSettings &inPhysicsSettings);
 
    float                               GetVolumeTimesSix() const;
 
    RefConst<SoftBodySharedSettings>    mSettings;                                  
    Array<Vertex>                       mVertices;                                  
    Array<CollidingShape>               mCollidingShapes;                           
    AABox                               mLocalBounds;                               
    AABox                               mLocalPredictedBounds;                      
    uint32                              mNumIterations;                             
    float                               mPressure;                                  
    bool                                mUpdatePosition;                            
};
 
JPH_NAMESPACE_END