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)
 
    
    void                CalculateEdgeLengths();
 
    void                CalculateVolumeConstraintVolumes();
 
    class OptimizationResults
    {
    public:
        Array<uint>     mEdgeRemap;                                 
    };
 
    void                Optimize(OptimizationResults &outResults);
 
    void                Optimize()                                  { OptimizationResults results; Optimize(results); }
 
    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          mVertex[2];                                 
        float           mRestLength = 1.0f;                         
        float           mCompliance = 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          mVertex[4];                                 
        float           mSixRestVolume = 1.0f;                      
        float           mCompliance = 0.0f;                         
    };
 
    void                AddFace(const Face &inFace)                 { JPH_ASSERT(!inFace.IsDegenerate()); mFaces.push_back(inFace); }
 
    uint                GetEdgeGroupSize(uint inGroupIdx) const     { return inGroupIdx == 0? mEdgeGroupEndIndices[0] : mEdgeGroupEndIndices[inGroupIdx] - mEdgeGroupEndIndices[inGroupIdx - 1]; }
 
    Array<Vertex>       mVertices;                                  
    Array<Face>         mFaces;                                     
    Array<Edge>         mEdgeConstraints;                           
    Array<uint>         mEdgeGroupEndIndices;                       
    Array<Volume>       mVolumeConstraints;                         
    PhysicsMaterialList mMaterials { PhysicsMaterial::sDefault };   
};
 
JPH_NAMESPACE_END