Cloth3D.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "physics/cloth/ClothModel.h"
#include "physics/backend/SimulationBackend.h"
 
#include <cstdint>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
namespace eve::graphics {
class Graphics;
class Mesh;
}  // namespace eve::graphics
 
namespace eve::physics {
 
class World3D;
 
class EVENGINE_API_DOMAINS Cloth3D : public ISimulationBackend {
public:
    Cloth3D(int cols, int rows, float spacing, float originX, float originY, float originZ);
    explicit Cloth3D(const ClothModel& model);
    ~Cloth3D();
 
    Cloth3D(const Cloth3D&)            = delete;
    Cloth3D& operator=(const Cloth3D&) = delete;
 
    void update(float dt);
 
    [[nodiscard("check the cloth step outcome")]]
    eve::Result<void> step(const eve::SimulationStep& step, const SimulationSettings& settings) override;
    [[nodiscard]] SimulationObservation observation() const noexcept override { return observation_; }
    [[nodiscard]] SimulationBackendKind kind() const noexcept override { return SimulationBackendKind::Cpu; }
    [[nodiscard]] SimulationDeterminism determinism() const noexcept override {
        return SimulationDeterminism::ToleranceBounded;
    }
    [[nodiscard]] std::string getBackendName() const { return "cpu"; }
    [[nodiscard]] bool supportsFeature(const std::string& feature) const;
    [[nodiscard("check cloth observation restore")]]
    eve::Result<void> restoreObservation(const SimulationObservation& observation) override;
 
    void  setGravity(float gx, float gy, float gz);
    float getGravityX() const { return gravityX_; }
    float getGravityY() const { return gravityY_; }
    float getGravityZ() const { return gravityZ_; }
 
    void  setStiffness(float stiffness);
    float getStiffness() const { return stiffness_; }
 
    void setStretchCompliance(float compliance);
    [[nodiscard]] float getStretchCompliance() const;
    void setShearCompliance(float compliance);
    [[nodiscard]] float getShearCompliance() const;
    void setBendCompliance(float compliance);
    [[nodiscard]] float getBendCompliance() const;
 
    void setTetherScale(float scale);
    [[nodiscard]] float getTetherScale() const;
    void setTetherCompliance(float compliance);
    [[nodiscard]] float getTetherCompliance() const;
 
    void setPressure(float pressure);
    [[nodiscard]] float getPressure() const;
    void setVolumeCompliance(float compliance);
    [[nodiscard]] float getVolumeCompliance() const;
    [[nodiscard]] float getCurrentVolume() const;
 
    void setIterations(int iterations);
    int  getIterations() const { return iterations_; }
 
    void  setDamping(float damping);
    float getDamping() const { return damping_; }
 
    void  setParticleSize(float size);
    float getParticleSize() const { return particleSize_; }
 
    void setSelfCollision(bool on);
    bool getSelfCollision() const { return selfCollision_; }
 
    void  setParticleMass(float mass);
    float getParticleMass() const { return particleMass_; }
 
    void  setFoldStiffness(float k);
    float getFoldStiffness() const { return foldStiffness_; }
 
    void  setMaxFoldAngle(float degrees);
    float getMaxFoldAngle() const { return maxFoldAngle_ * 180.f / 3.14159265f; }
 
    void setBounds(float x, float y, float z, float w, float h, float d);
    void clearBounds();
 
    void setCollisionMaterial(float friction, float restitution);
    [[nodiscard]] float getCollisionFriction() const;
    [[nodiscard]] float getCollisionRestitution() const;
    void setCollisionFilter(uint64_t categoryBits, uint64_t maskBits);
    [[nodiscard]] uint64_t getCollisionCategoryBits() const;
    [[nodiscard]] uint64_t getCollisionMaskBits() const;
 
    void setTearThreshold(float strain);
    [[nodiscard]] float getTearThreshold() const;
    void setMaxTearsPerStep(int count);
    [[nodiscard]] int getMaxTearsPerStep() const;
    void tearConstraint(int particleA, int particleB);
    [[nodiscard]] int getTornConstraintCount() const;
 
    void pin(int index);
    void unpin(int index);
    void pinTopRow();
    bool isPinned(int index) const;
    void setParticleInverseMass(int index, float inverseMass);
    [[nodiscard]] float getParticleInverseMass(int index) const;
 
    void setSkinConstraint(int index, float x, float y, float z, float nx, float ny, float nz, float radius,
                           float backstopDistance = -1.f, float backstopRadius = 0.f, float compliance = 0.f);
    void updateSkinReference(int index, float x, float y, float z, float nx, float ny, float nz);
    void clearSkinConstraint(int index);
    [[nodiscard]] bool hasSkinConstraint(int index) const;
 
    void attachParticle(int index, float x, float y, float z, float compliance = 0.f);
    void updateAttachment(int index, float x, float y, float z);
    void detachParticle(int index);
    [[nodiscard]] bool isAttached(int index) const;
 
    int  grabAt(float x, float y, float z, float radius = 0.3f);
    void moveGrab(float x, float y, float z);
    void releaseGrab();
    bool isGrabbing() const { return grabIndex_ >= 0; }
    int  getGrabIndex() const { return grabIndex_; }
 
    void applyForce(float fx, float fy, float fz);
 
    void setWindVelocity(float vx, float vy, float vz);
    [[nodiscard]] float getWindVelocityX() const;
    [[nodiscard]] float getWindVelocityY() const;
    [[nodiscard]] float getWindVelocityZ() const;
 
    void setAerodynamics(float airDensity, float dragCoefficient, float liftCoefficient);
    [[nodiscard]] float getAirDensity() const;
    [[nodiscard]] float getDragCoefficient() const;
    [[nodiscard]] float getLiftCoefficient() const;
 
    void interactAt(float x, float y, float z, float radius, float strength);
 
    void setCollideWorld(World3D* world);
    World3D* getCollideWorld() const { return world_; }
 
    void reset();
 
    void  setColor(float r, float g, float b, float a = 1.f);
    float getColorR() const { return colorR_; }
    float getColorG() const { return colorG_; }
    float getColorB() const { return colorB_; }
    float getColorA() const { return colorA_; }
 
    void draw(graphics::Graphics* gfx);
 
    int   getCols() const { return cols_; }
    int   getRows() const { return rows_; }
    int   getParticleCount() const { return static_cast<int>(particles_.size()); }
    [[nodiscard]] int getTriangleCount() const;
    [[nodiscard]] int getDistanceConstraintCount() const;
    [[nodiscard]] int getTetherConstraintCount() const;
    [[nodiscard]] int getSkinConstraintCount() const;
    [[nodiscard]] int getAttachmentCount() const { return static_cast<int>(attachments_.size()); }
    float getParticleX(int index) const;
    float getParticleY(int index) const;
    float getParticleZ(int index) const;
    void  setParticlePosition(int index, float x, float y, float z);
 
    float getSpacing() const { return spacing_; }
    float getOriginX() const { return originX_; }
    float getOriginY() const { return originY_; }
    float getOriginZ() const { return originZ_; }
 
    void destroy();
 
private:
    struct Particle {
        float x = 0.f, y = 0.f, z = 0.f;
        float px = 0.f, py = 0.f, pz = 0.f;
        float inverseMass = 1.f;
        bool  pinned = false;
    };
    struct Link {
        int                 a = 0, b = 0;
        float               rest   = 0.f;
        ClothConstraintKind kind   = ClothConstraintKind::Structural;
        float               lambda = 0.f;
    };
    struct Tri {
        int v[3] = {0, 0, 0};
    };
    // Dihedral pair: shared edge (a,b), opposite vertices k (tri 1) and l (tri 2).
    struct FoldPair {
        int a = 0, b = 0, k = 0, l = 0;
    };
    struct Tether {
        int   particle  = 0;
        int   anchor    = 0;
        float maxLength = 0.f;
        float lambda    = 0.f;
    };
    struct SkinConstraint {
        int   particle = 0;
        float x = 0.f, y = 0.f, z = 0.f;
        float nx = 0.f, ny = 1.f, nz = 0.f;
        float radius = 0.f;
        float backstopDistance = -1.f;
        float backstopRadius   = 0.f;
        float compliance       = 0.f;
        float lambda           = 0.f;
    };
    struct Attachment {
        int   particle = 0;
        float x = 0.f, y = 0.f, z = 0.f;
        float compliance = 0.f;
        float lambda     = 0.f;
    };
 
    void    rebuildLinks();
    void    initializeFromModel(const ClothModel& model);
    void    updateSubsteps(float dt, int substeps);
    void    rebuildTriangles();
    void    buildLinkKeys();
    bool    areLinked(int a, int b) const;
    void    integrate(float dt);
    void    accumulateAerodynamicAcceleration(float dt, std::vector<float>& accelerations) const;
    void    solveConstraints(float dt);
    void    solveTetherConstraints(float dt);
    void    solveVolumeConstraint(float dt);
    void    solveSkinConstraints(float dt);
    void    solveAttachments(float dt);
    void    applyAutomaticTearing();
    void    tearLink(size_t linkIndex);
    void    rebuildFoldPairsFromTriangles();
    void    solveFoldConstraint();
    void    solveSelfCollision();
    void    solveSelfCollisionTriangles();
    void    collideWorld(float dt);
    void    collideBounds();
    void    rebuildHash();
    bool    validIndex(int index) const;
    int64_t cellKey(int cx, int cy, int cz) const;
 
    int   cols_    = 0;
    int   rows_    = 0;
    float spacing_ = 0.4f;
    float originX_ = 0.f, originY_ = 0.f, originZ_ = 0.f;
 
    float gravityX_          = 0.f;
    float gravityY_          = -9.8f;
    float gravityZ_          = 0.f;
    float stiffness_         = 0.85f;
    float stretchCompliance_ = 0.f;
    float shearCompliance_   = 0.f;
    float bendCompliance_    = 0.f;
    float tetherScale_       = 0.f;
    float tetherCompliance_  = 0.f;
    float pressure_          = 0.f;
    float volumeCompliance_  = 0.f;
    float restVolume_        = 0.f;
    float volumeLambda_      = 0.f;
    float damping_           = 0.01f;
    int   iterations_        = 4;
    float particleSize_      = 0.1f;
    float particleMass_      = 0.1f;
    bool  selfCollision_     = true;
    float foldStiffness_     = 0.5f;
    float maxFoldAngle_      = 120.f * 3.14159265f / 180.f;
    float collisionFriction_    = 0.2f;
    float collisionRestitution_ = 0.15f;
    uint64_t collisionCategoryBits_ = ~uint64_t{0};
    uint64_t collisionMaskBits_     = ~uint64_t{0};
    float tearThreshold_ = 0.f;
    int   maxTearsPerStep_ = 1;
    int   tornConstraintCount_ = 0;
 
    bool  hasBounds_ = false;
    float boundX_ = 0.f, boundY_ = 0.f, boundZ_ = 0.f;
    float boundW_ = 0.f, boundH_ = 0.f, boundD_ = 0.f;
 
    int   grabIndex_ = -1;
    float grabX_ = 0.f, grabY_ = 0.f, grabZ_ = 0.f;
    float forceX_ = 0.f, forceY_ = 0.f, forceZ_ = 0.f;
    float windVelocityX_ = 0.f, windVelocityY_ = 0.f, windVelocityZ_ = 0.f;
    float airDensity_      = 1.225f;
    float dragCoefficient_ = 0.f;
    float liftCoefficient_ = 0.f;
    float interactX_ = 0.f, interactY_ = 0.f, interactZ_ = 0.f;
    float interactRadius_   = 0.f;
    float interactStrength_ = 0.f;
 
    World3D* world_ = nullptr;
 
    float colorR_ = 0.75f, colorG_ = 0.82f, colorB_ = 0.95f, colorA_ = 1.f;
 
    bool                  destroyed_ = false;
    SimulationObservation observation_;
 
    std::vector<Particle>                         particles_;
    std::vector<Particle>                         restParticles_;
    std::vector<Link>                             links_;
    std::vector<Tri>                              triangles_;
    std::vector<FoldPair>                         foldPairs_;
    std::vector<Tether>                           tethers_;
    std::vector<SkinConstraint>                    skinConstraints_;
    std::vector<Attachment>                        attachments_;
    std::unordered_set<int64_t>                   linkKeys_;
    std::unordered_map<int64_t, std::vector<int>> hash_;
 
    graphics::Mesh* mesh_            = nullptr;
    int             meshVertexCount_ = 0;
    int             meshIndexCount_  = 0;
};
 
}  // namespace eve::physics