ClothGPU.h

浏览该文件的文档.

#pragma once
 
#include "physics/backend/SimulationBackend.h"
 
#include <cstdint>
#include <string>
#include <vector>
 
namespace eve::graphics {
class Graphics;
}
 
namespace eve::gpgpu {
class Gpgpu;
class ComputeShader;
class GpuBuffer;
class Sequence;
}  // namespace eve::gpgpu
 
namespace eve::physics {
 
class EVENGINE_API_DOMAINS ClothGPU : public ISimulationBackend {
public:
    static constexpr int kMaxLinksPerParticle = 16;
 
    ClothGPU(eve::gpgpu::Gpgpu *gpgpu, int cols, int rows, float spacing, float originX,
             float originY);
    ~ClothGPU();
 
    ClothGPU(const ClothGPU &)            = delete;
    ClothGPU &operator=(const ClothGPU &) = delete;
 
    void update(float dt);
 
    [[nodiscard("check the GPU 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::Gpu; }
    [[nodiscard]] SimulationDeterminism determinism() const noexcept override {
        return SimulationDeterminism::ToleranceBounded;
    }
    [[nodiscard]] std::string getBackendName() const { return "gpu"; }
    [[nodiscard]] bool supportsFeature(const std::string &feature) const;
    [[nodiscard("check GPU 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  setSelfCollision(bool on);
    bool  getSelfCollision() const { return selfCollision_; }
 
    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;
 
    void applyForce(float fx, float fy);
 
    void interactAt(float x, float y, float radius, float strength);
 
    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 cols_ * rows_; }
    float getParticleX(int index) const;
    float getParticleY(int index) const;
 
    float getSpacing() const { return spacing_; }
    float getOriginX() const { return originX_; }
    float getOriginY() const { return originY_; }
 
    void reset();
 
    void destroy();
 
private:
    struct Link {
        int   other = -1;
        float rest = 0.f;
    };
 
    void rebuildLinks();
    void uploadInitialState();
    void uploadPinned();
    void ensureHashBuffers();
    eve::Result<void> stepGpu(float dt, int substeps);
 
    eve::gpgpu::Gpgpu *gpgpu_ = nullptr;
    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;
    int   iterations_ = 4;
    float damping_ = 0.01f;
    float particleSize_ = 3.f;
 
    bool  hasBounds_ = false;
    float boundX_ = 0.f, boundY_ = 0.f, boundW_ = 0.f, boundH_ = 0.f;
 
    float forceX_ = 0.f, forceY_ = 0.f;
    float interactX_ = 0.f, interactY_ = 0.f;
    float interactRadius_ = 0.f;
    float interactStrength_ = 0.f;
 
    float colorR_ = 0.75f, colorG_ = 0.82f, colorB_ = 0.95f, colorA_ = 1.f;
 
    bool destroyed_ = false;
    SimulationObservation observation_;
 
    std::vector<Link>   links_;      // particle-major, kMaxLinksPerParticle slots
    std::vector<float>  posCpu_;     // x,y,px,py per particle (readback)
    std::vector<float>  flagsCpu_;   // 1 = pinned
    std::vector<float>  linkCpu_;    // other,rest,0,0 per slot
 
    eve::gpgpu::ComputeShader *shader_ = nullptr;
    eve::gpgpu::Sequence *seq_ = nullptr;
    eve::gpgpu::GpuBuffer *posBuf_ = nullptr;
    eve::gpgpu::GpuBuffer *posBufB_ = nullptr;
    eve::gpgpu::GpuBuffer *linkBuf_ = nullptr;
    eve::gpgpu::GpuBuffer *flagBuf_ = nullptr;
    eve::gpgpu::GpuBuffer *staging_ = nullptr;
    eve::gpgpu::GpuBuffer *cellHeadBuf_ = nullptr;
    eve::gpgpu::GpuBuffer *cellNextBuf_ = nullptr;
    eve::gpgpu::GpuBuffer *cellItemsBuf_ = nullptr;
    eve::gpgpu::GpuBuffer *cellSlotBuf_ = nullptr;
    int hashNx_ = 0;
    int hashNy_ = 0;
    bool selfCollision_ = false;
};
 
}  // namespace eve::physics