Cloth.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
#include "physics/backend/SimulationBackend.h"
 
#include <cstdint>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
namespace eve::graphics {
class Graphics;
}
 
namespace eve::physics {
 
class World;
 
class EVENGINE_API_DOMAINS Cloth : public ISimulationBackend {
public:
    Cloth(int cols, int rows, float spacing, float originX, float originY);
    ~Cloth();
 
    Cloth(const Cloth &)            = delete;
    Cloth &operator=(const Cloth &) = 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("check cloth observation restore")]]
    eve::Result<void> restoreObservation(const SimulationObservation &observation) override;
 
    void  setGravity(float gx, float gy);
    float getGravityX() const { return gravityX_; }
    float getGravityY() const { return gravityY_; }
 
    void  setStiffness(float stiffness);
    float getStiffness() const { return stiffness_; }
 
    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  setParticleMass(float mass);
    float getParticleMass() const { return particleMass_; }
 
    void  setSelfCollision(bool on);
    bool  getSelfCollision() const { return selfCollision_; }
 
    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 w, float h);
    void clearBounds();
 
    void pin(int index);
    void unpin(int index);
    void pinTopRow();
    bool isPinned(int index) const;
 
    int  grabAt(float x, float y, float radius = 24.f);
    void moveGrab(float x, float y);
    void releaseGrab();
    bool isGrabbing() const { return grabIndex_ >= 0; }
    int  getGrabIndex() const { return grabIndex_; }
 
    void applyForce(float fx, float fy);
 
    void interactAt(float x, float y, float radius, float strength);
 
    void  setCollideWorld(World *world);
    World *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()); }
    float getParticleX(int index) const;
    float getParticleY(int index) const;
    void  setParticlePosition(int index, float x, float y);
 
    float getSpacing() const { return spacing_; }
    float getOriginX() const { return originX_; }
    float getOriginY() const { return originY_; }
 
    void destroy();
 
private:
    struct Particle {
        float x = 0.f, y = 0.f;
        float px = 0.f, py = 0.f;
        bool  pinned = false;
    };
    struct Link {
        int   a = 0, b = 0;
        float rest = 0.f;
    };
 
    void rebuildLinks();
    void    updateSubsteps(float dt, int substeps);
    void integrate(float dt);
    void solveConstraints();
    void solveFoldConstraint();
    void solveSelfCollision();
    void collideWorld(float dt);
    void collideBounds();
    void rebuildHash();
    void buildLinkKeys();
    bool areLinked(int a, int b) const;
    bool validIndex(int index) const;
    int64_t cellKey(int cx, int cy) const;
 
    int   cols_ = 0;
    int   rows_ = 0;
    float spacing_ = 10.f;
    float originX_ = 0.f;
    float originY_ = 0.f;
 
    float gravityX_ = 0.f;
    float gravityY_ = 980.f;
    float stiffness_ = 0.85f;
    float damping_   = 0.01f;
    int   iterations_ = 4;
    float particleSize_ = 3.f;
    float particleMass_ = 0.1f;
    bool  selfCollision_ = true;
    float foldStiffness_ = 0.5f;
    float maxFoldAngle_ = 90.f * 3.14159265f / 180.f;
 
    bool  hasBounds_ = false;
    float boundX_ = 0.f, boundY_ = 0.f, boundW_ = 0.f, boundH_ = 0.f;
 
    int   grabIndex_ = -1;
    float grabX_ = 0.f, grabY_ = 0.f;
    float forceX_ = 0.f, forceY_ = 0.f;
    float interactX_ = 0.f, interactY_ = 0.f;
    float interactRadius_ = 0.f;
    float interactStrength_ = 0.f;
 
    World *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<Link>     links_;
    std::unordered_set<int64_t> linkKeys_;
    std::unordered_map<int64_t, std::vector<int>> hash_;
};
 
}  // namespace eve::physics