SoftBodySharedSettings.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/Core/Reference.h>
#include <Jolt/Physics/Collision/PhysicsMaterial.h>
#include <Jolt/Core/StreamUtils.h>
 
JPH_NAMESPACE_BEGIN
 
class JPH_EXPORT SoftBodySharedSettings : public RefTarget<SoftBodySharedSettings>
{
public:
    JPH_DECLARE_SERIALIZABLE_NON_VIRTUAL(JPH_EXPORT, SoftBodySharedSettings)
 
    
    enum class EBendType
    {
        None,                                                       
        Distance,                                                   
        Dihedral,                                                   
    };
 
    enum class ELRAType
    {
        None,                                                       
        EuclideanDistance,                                          
        GeodesicDistance,                                           
    };
 
    struct JPH_EXPORT VertexAttributes
    {
                        VertexAttributes() = default;
                        VertexAttributes(float inCompliance, float inShearCompliance, float inBendCompliance, ELRAType inLRAType = ELRAType::None, float inLRAMaxDistanceMultiplier = 1.0f) : mCompliance(inCompliance), mShearCompliance(inShearCompliance), mBendCompliance(inBendCompliance), mLRAType(inLRAType), mLRAMaxDistanceMultiplier(inLRAMaxDistanceMultiplier) { }
 
        float           mCompliance = 0.0f;                         
        float           mShearCompliance = 0.0f;                    
        float           mBendCompliance = FLT_MAX;                  
        ELRAType        mLRAType = ELRAType::None;                  
        float           mLRAMaxDistanceMultiplier = 1.0f;           
    };
 
    void                CreateConstraints(const VertexAttributes *inVertexAttributes, uint inVertexAttributesLength, EBendType inBendType = EBendType::Distance, float inAngleTolerance = DegreesToRadians(8.0f));
 
    void                CalculateEdgeLengths();
 
    void                CalculateLRALengths(float inMaxDistanceMultiplier = 1.0f);
 
    void                CalculateBendConstraintConstants();
 
    void                CalculateVolumeConstraintVolumes();
 
    void                CalculateSkinnedConstraintNormals();
 
    class OptimizationResults
    {
    public:
        Array<uint>     mEdgeRemap;                                 
        Array<uint>     mDihedralBendRemap;                         
    };
 
    void                Optimize(OptimizationResults &outResults);
 
    void                Optimize()                                  { OptimizationResults results; Optimize(results); }
 
    Ref<SoftBodySharedSettings> Clone() const;
 
    void                SaveBinaryState(StreamOut &inStream) const;
 
    void                RestoreBinaryState(StreamIn &inStream);
 
    using SharedSettingsToIDMap = StreamUtils::ObjectToIDMap<SoftBodySharedSettings>;
    using IDToSharedSettingsMap = StreamUtils::IDToObjectMap<SoftBodySharedSettings>;
    using MaterialToIDMap = StreamUtils::ObjectToIDMap<PhysicsMaterial>;
    using IDToMaterialMap = StreamUtils::IDToObjectMap<PhysicsMaterial>;
 
    void                SaveWithMaterials(StreamOut &inStream, SharedSettingsToIDMap &ioSettingsMap, MaterialToIDMap &ioMaterialMap) const;
 
    using SettingsResult = Result<Ref<SoftBodySharedSettings>>;
 
    static SettingsResult sRestoreWithMaterials(StreamIn &inStream, IDToSharedSettingsMap &ioSettingsMap, IDToMaterialMap &ioMaterialMap);
 
    struct JPH_EXPORT Vertex
    {
        JPH_DECLARE_SERIALIZABLE_NON_VIRTUAL(JPH_EXPORT, Vertex)
 
        
                        Vertex() = default;
                        Vertex(const Float3 &inPosition, const Float3 &inVelocity = Float3(0, 0, 0), float inInvMass = 1.0f) : mPosition(inPosition), mVelocity(inVelocity), mInvMass(inInvMass) { }
 
        Float3          mPosition { 0, 0, 0 };                      
        Float3          mVelocity { 0, 0, 0 };                      
        float           mInvMass = 1.0f;                            
    };
 
    struct JPH_EXPORT Face
    {
        JPH_DECLARE_SERIALIZABLE_NON_VIRTUAL(JPH_EXPORT, Face)
 
        
                        Face() = default;
                        Face(uint32 inVertex1, uint32 inVertex2, uint32 inVertex3, uint32 inMaterialIndex = 0) : mVertex { inVertex1, inVertex2, inVertex3 }, mMaterialIndex(inMaterialIndex) { }
 
        bool            IsDegenerate() const                        { return mVertex[0] == mVertex[1] || mVertex[0] == mVertex[2] || mVertex[1] == mVertex[2]; }
 
        uint32          mVertex[3];                                 
        uint32          mMaterialIndex = 0;                         
    };
 
    struct JPH_EXPORT Edge
    {
        JPH_DECLARE_SERIALIZABLE_NON_VIRTUAL(JPH_EXPORT, Edge)
 
        
                        Edge() = default;
                        Edge(uint32 inVertex1, uint32 inVertex2, float inCompliance = 0.0f) : mVertex { inVertex1, inVertex2 }, mCompliance(inCompliance) { }
 
        uint32          GetMinVertexIndex() const                   { return min(mVertex[0], mVertex[1]); }
 
        uint32          mVertex[2];                                 
        float           mRestLength = 1.0f;                         
        float           mCompliance = 0.0f;                         
    };
 
    struct JPH_EXPORT DihedralBend
    {
        JPH_DECLARE_SERIALIZABLE_NON_VIRTUAL(JPH_EXPORT, DihedralBend)
 
        
                        DihedralBend() = default;
                        DihedralBend(uint32 inVertex1, uint32 inVertex2, uint32 inVertex3, uint32 inVertex4, float inCompliance = 0.0f) : mVertex { inVertex1, inVertex2, inVertex3, inVertex4 }, mCompliance(inCompliance) { }
 
        uint32          GetMinVertexIndex() const                   { return min(min(mVertex[0], mVertex[1]), min(mVertex[2], mVertex[3])); }
 
        uint32          mVertex[4];                                 
        float           mCompliance = 0.0f;                         
        float           mInitialAngle = 0.0f;                       
    };
 
    struct JPH_EXPORT Volume
    {
        JPH_DECLARE_SERIALIZABLE_NON_VIRTUAL(JPH_EXPORT, Volume)
 
        
                        Volume() = default;
                        Volume(uint32 inVertex1, uint32 inVertex2, uint32 inVertex3, uint32 inVertex4, float inCompliance = 0.0f) : mVertex { inVertex1, inVertex2, inVertex3, inVertex4 }, mCompliance(inCompliance) { }
 
        uint32          GetMinVertexIndex() const                   { return min(min(mVertex[0], mVertex[1]), min(mVertex[2], mVertex[3])); }
 
        uint32          mVertex[4];                                 
        float           mSixRestVolume = 1.0f;                      
        float           mCompliance = 0.0f;                         
    };
 
    class JPH_EXPORT InvBind
    {
        JPH_DECLARE_SERIALIZABLE_NON_VIRTUAL(JPH_EXPORT, InvBind)
 
    public:
                        InvBind() = default;
                        InvBind(uint32 inJointIndex, Mat44Arg inInvBind) : mJointIndex(inJointIndex), mInvBind(inInvBind) { }
 
        uint32          mJointIndex = 0;                            
        Mat44           mInvBind = Mat44::sIdentity();              
    };
 
    class JPH_EXPORT SkinWeight
    {
        JPH_DECLARE_SERIALIZABLE_NON_VIRTUAL(JPH_EXPORT, SkinWeight)
 
    public:
                        SkinWeight() = default;
                        SkinWeight(uint32 inInvBindIndex, float inWeight) : mInvBindIndex(inInvBindIndex), mWeight(inWeight) { }
 
        uint32          mInvBindIndex = 0;                          
        float           mWeight = 0.0f;                             
    };
 
    class JPH_EXPORT Skinned
    {
        JPH_DECLARE_SERIALIZABLE_NON_VIRTUAL(JPH_EXPORT, Skinned)
 
    public:
                        Skinned() = default;
                        Skinned(uint32 inVertex, float inMaxDistance, float inBackStopDistance, float inBackStopRadius) : mVertex(inVertex), mMaxDistance(inMaxDistance), mBackStopDistance(inBackStopDistance), mBackStopRadius(inBackStopRadius) { }
 
        void            NormalizeWeights()
        {
            // Get the total weight
            float total = 0.0f;
            for (const SkinWeight &w : mWeights)
                total += w.mWeight;
 
            // Normalize
            if (total > 0.0f)
                for (SkinWeight &w : mWeights)
                    w.mWeight /= total;
        }
 
        uint32          mVertex = 0;                                
        SkinWeight      mWeights[4];                                
        float           mMaxDistance = FLT_MAX;                     
        float           mBackStopDistance = FLT_MAX;                
        float           mBackStopRadius = 40.0f;                    
        uint32          mNormalInfo = 0;                            
    };
 
    class JPH_EXPORT LRA
    {
        JPH_DECLARE_SERIALIZABLE_NON_VIRTUAL(JPH_EXPORT, LRA)
 
    public:
                        LRA() = default;
                        LRA(uint32 inVertex1, uint32 inVertex2, float inMaxDistance) : mVertex { inVertex1, inVertex2 }, mMaxDistance(inMaxDistance) { }
 
        uint32          GetMinVertexIndex() const                   { return min(mVertex[0], mVertex[1]); }
 
        uint32          mVertex[2];                                 
        float           mMaxDistance = 0.0f;                        
    };
 
    void                AddFace(const Face &inFace)                 { JPH_ASSERT(!inFace.IsDegenerate()); mFaces.push_back(inFace); }
 
    Array<Vertex>       mVertices;                                  
    Array<Face>         mFaces;                                     
    Array<Edge>         mEdgeConstraints;                           
    Array<DihedralBend> mDihedralBendConstraints;                   
    Array<Volume>       mVolumeConstraints;                         
    Array<Skinned>      mSkinnedConstraints;                        
    Array<InvBind>      mInvBindMatrices;                           
    Array<LRA>          mLRAConstraints;                            
    PhysicsMaterialList mMaterials { PhysicsMaterial::sDefault };   
    float               mVertexRadius = 0.0f;                       
 
private:
    friend class SoftBodyMotionProperties;
 
    struct ClosestKinematic
    {
        uint32          mVertex = 0xffffffff;                       
        float           mDistance = FLT_MAX;                        
    };
 
    void                CalculateClosestKinematic();
 
    uint                GetEdgeGroupSize(uint inGroupIdx) const     { return inGroupIdx == 0? mEdgeGroupEndIndices[0] : mEdgeGroupEndIndices[inGroupIdx] - mEdgeGroupEndIndices[inGroupIdx - 1]; }
 
    Array<ClosestKinematic> mClosestKinematic;                      
    Array<uint>         mEdgeGroupEndIndices;                       
    Array<uint32>       mSkinnedConstraintNormals;                  
};
 
JPH_NAMESPACE_END