Fluids.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/Module.h"
#include "fluids/FluidMath.h"
#include "fluids/FluidSdf.h"
#include "fluids/FluidSimulation.h"
#include "fluids/FluidSurfaceBinding.h"
#include "fluids/FluidSurfaceRenderer.h"
#include "fluids/SurfaceDropletSimulation.h"
#include "fluids/SurfaceFluidContracts.h"
#include "fluids/SurfaceFluidRenderData.h"
#include "fluids/SurfaceFluidSceneRenderer.h"
#include "fluids/SurfaceWetnessField.h"
#include "fluids/VolumeFluidShadowCaster.h"
#include "physics/backend/SimulationBackend.h"
 
#include <glm/glm.hpp>
 
#include <memory>
#include <vector>
 
namespace eve::gpgpu {
class ComputeShader;
class Gpgpu;
class GpuBuffer;
class Sequence;
}  // namespace eve::gpgpu
 
namespace eve::fluids {
 
class EVENGINE_API_DOMAINS FluidSimulator : public eve::physics::ISimulationBackend {
public:
    FluidSimulator(int maxParticles, const FluidParams& params, bool preferGpu);
    ~FluidSimulator();
 
    FluidSimulator(const FluidSimulator&)            = delete;
    FluidSimulator& operator=(const FluidSimulator&) = delete;
 
    void setSdf(const MeshSdf& sdf);
 
    const MeshSdf& sdf() const { return sim_.sdf(); }
 
    int spawnDrop(const glm::vec3& center, float radius, int count);
 
    void step(float dt);
 
    [[nodiscard("check the fluid step outcome")]]
    eve::Result<void> step(const eve::SimulationStep& step, const eve::physics::SimulationSettings& settings) override;
    [[nodiscard]] eve::physics::SimulationObservation observation() const noexcept override { return observation_; }
    [[nodiscard]] eve::physics::SimulationBackendKind kind() const noexcept override {
        return gpuOk_ ? eve::physics::SimulationBackendKind::Gpu : eve::physics::SimulationBackendKind::Cpu;
    }
    [[nodiscard]] eve::physics::SimulationDeterminism determinism() const noexcept override {
        return eve::physics::SimulationDeterminism::ToleranceBounded;
    }
    [[nodiscard("check fluid observation restore")]]
    eve::Result<void> restoreObservation(const eve::physics::SimulationObservation& observation) override;
 
    [[nodiscard]] bool usedBackendFallback() const noexcept { return backendFallback_; }
    [[nodiscard("inspect fluid backend selection diagnostics")]]
    eve::Status backendSelectionStatus() const {
        return backendSelectionStatus_;
    }
 
    int getParticleCount() const { return sim_.particleCount(); }
 
    int getMaxParticles() const { return sim_.maxParticles(); }
 
    bool usingGpu() const { return gpuOk_; }
 
    void readPositions(std::vector<glm::vec3>& out) const;
 
    void readDensities(std::vector<float>& out) const;
 
    FluidParams& params() { return sim_.params(); }
 
    const FluidParams& params() const { return sim_.params(); }
 
    void setGravity(float x, float y, float z);
 
    void setViscosity(float viscosity);
 
    void setCohesion(float cohesion);
 
    void setAdhesion(float adhesion);
 
    void setPbfIterations(int passes);
 
    void setDamping(float damping);
 
    void setParticleRadius(float radius);
 
    void setSupportRadius(float h);
 
    void setSdfSphere(float cx, float cy, float cz, float radius, int res);
 
private:
    bool ensureGpu();
    void stepSolver(float dt, int substeps);
    void uploadSdf();
    void uploadParticles();
    void downloadParticles();
    void setCommonConstants(gpgpu::ComputeShader* shader, float dt);
 
    FluidSimulation sim_;
    bool            preferGpu_ = false;
    bool            gpuOk_     = false;
    bool                                backendFallback_ = false;
    bool            sdfDirty_  = true;
    eve::physics::SimulationObservation observation_;
    eve::Status                         backendSelectionStatus_ = eve::Status::success();
 
    eve::gpgpu::Gpgpu*         gpgpu_           = nullptr;
    eve::gpgpu::ComputeShader* shClear_         = nullptr;
    eve::gpgpu::ComputeShader* shBuild_         = nullptr;
    eve::gpgpu::ComputeShader* shDensityLambda_ = nullptr;
    eve::gpgpu::ComputeShader* shDelta_         = nullptr;
    eve::gpgpu::ComputeShader* shApply_         = nullptr;
    eve::gpgpu::ComputeShader* shIntegrate_     = nullptr;
    eve::gpgpu::ComputeShader* shAdvance_       = nullptr;
    eve::gpgpu::GpuBuffer*     bufPos_          = nullptr;
    eve::gpgpu::GpuBuffer*     bufVel_          = nullptr;
    eve::gpgpu::GpuBuffer*     bufHead_         = nullptr;
    eve::gpgpu::GpuBuffer*     bufNext_         = nullptr;
    eve::gpgpu::GpuBuffer*     bufDens_         = nullptr;
    eve::gpgpu::GpuBuffer*     bufLambda_       = nullptr;
    eve::gpgpu::GpuBuffer*     bufGrad_         = nullptr;
    eve::gpgpu::GpuBuffer*     bufSdf_          = nullptr;
    eve::gpgpu::GpuBuffer*     stagePos_        = nullptr;
    eve::gpgpu::GpuBuffer*     stageVel_        = nullptr;
    eve::gpgpu::GpuBuffer*     stageDens_       = nullptr;
    eve::gpgpu::Sequence*      seq_             = nullptr;
    SimGrid                    grid_;
};
 
class EVENGINE_API_DOMAINS Fluids : public Module {
public:
    Module_REG(Fluids);
    Fluids();
    ~Fluids() override;
 
    // The two `vector<unique_ptr<...>>` members make the implicit copy operations
    // ill-formed (C2280) the moment a class-level dllexport instantiates them;
    // spell the four out so the export surface stays defined. Semantics unchanged:
    // a module instance was never copyable or assignable in practice.
    Fluids(const Fluids&)            = delete;
    Fluids& operator=(const Fluids&) = delete;
    Fluids(Fluids&&)                 = default;
    Fluids& operator=(Fluids&&)      = default;
 
    FluidSimulator* newSimulator(int maxParticles = 8192);
 
    FluidSurfaceRenderer* newSurfaceRenderer(int width = 160, int height = 160);
 
    int getSimulatorCount() const;
 
    int getRendererCount() const;
 
private:
    std::vector<std::unique_ptr<FluidSimulator>>       simulators_;
    std::vector<std::unique_ptr<FluidSurfaceRenderer>> renderers_;
};
 
}  // namespace eve::fluids