SurfaceFluidContracts.h

浏览该文件的文档.

#pragma once
 
#include "common/Result.h"
#include "common/Time.h"
#include "fluids/FluidSimulation.h"
#include "fluids/FluidSurfaceBinding.h"
 
#include <glm/glm.hpp>
 
#include <cstdint>
#include <memory>
#include <span>
#include <vector>
 
namespace eve::fluids {
 
class FluidSurfaceRenderer;
struct FluidSurfaceParams;
 
class ISurfaceFluidSimulation {
public:
    virtual ~ISurfaceFluidSimulation() = default;
 
    [[nodiscard("check the surface-fluid step outcome")]]
    virtual eve::Result<void> step(const eve::SimulationStep& step) = 0;
 
    [[nodiscard]] virtual int particleCount() const noexcept = 0;
    [[nodiscard]] virtual std::span<const FluidParticle> particles() const noexcept = 0;
};
 
class ISurfaceConstraint {
public:
    virtual ~ISurfaceConstraint() = default;
 
    [[nodiscard("check surface constraint construction")]]
    virtual eve::Result<void> build(const std::vector<glm::vec3>& positions, const std::vector<std::uint32_t>& indices,
                                    const std::vector<glm::vec2>& uvs = {}) = 0;
 
    [[nodiscard("check surface constraint pose update")]]
    virtual eve::Result<void> setTransform(const glm::mat4& transform) = 0;
 
    [[nodiscard("check surface constraint pose update")]]
    virtual eve::Result<void> setDeformedPositions(const std::vector<glm::vec3>& worldPositions) = 0;
 
    [[nodiscard]] virtual bool isValid() const noexcept = 0;
 
    [[nodiscard("check surface location evaluation")]]
    virtual eve::Result<SurfaceSample> evaluate(const SurfaceLocation& location, eve::Duration poseDelta) const = 0;
 
    [[nodiscard("check surface projection")]]
    virtual eve::Result<SurfaceLocation> project(const glm::vec3& worldPosition, float maxDistance) const = 0;
 
    [[nodiscard("check surface traversal")]]
    virtual eve::Result<SurfaceWalkResult> walk(const SurfaceLocation& start, const glm::vec3& displacement,
                                                int maxCrossings = 16) const = 0;
};
 
class IScreenSpaceSurfaceReconstruction {
public:
    virtual ~IScreenSpaceSurfaceReconstruction() = default;
 
    [[nodiscard("check screen-space reconstruction")]]
    virtual eve::Result<void> reconstruct(std::span<const glm::vec3> positions, float particleRadius) = 0;
 
    [[nodiscard("check scene-depth composition")]]
    virtual eve::Result<void> occlude(std::span<const float> sceneDepth, float depthBias = 0.001f) = 0;
 
    [[nodiscard]] virtual int width() const noexcept = 0;
    [[nodiscard]] virtual int height() const noexcept = 0;
    [[nodiscard]] virtual std::span<const float> depth() const noexcept = 0;
    [[nodiscard]] virtual std::span<const glm::vec3> normals() const noexcept = 0;
    [[nodiscard]] virtual std::span<const float> thickness() const noexcept = 0;
    [[nodiscard]] virtual std::span<const std::uint8_t> color() const noexcept = 0;
    [[nodiscard]] virtual bool usingGpu() const noexcept = 0;
};
 
class FluidSimulationAdapter final : public ISurfaceFluidSimulation {
public:
    explicit FluidSimulationAdapter(FluidSimulation& solver) noexcept : solver_(&solver) {}
 
    [[nodiscard]] eve::Result<void>              step(const eve::SimulationStep& step) override;
    [[nodiscard]] int                            particleCount() const noexcept override;
    [[nodiscard]] std::span<const FluidParticle> particles() const noexcept override;
 
private:
    FluidSimulation*    solver_   = nullptr;
    eve::SimulationTick lastTick_ = eve::SimulationTick::zero();
};
 
class FluidSurfaceConstraintAdapter final : public ISurfaceConstraint {
public:
    explicit FluidSurfaceConstraintAdapter(FluidSurfaceBinding& binding) noexcept : binding_(&binding) {}
 
    [[nodiscard]] eve::Result<void> build(const std::vector<glm::vec3>&     positions,
                                          const std::vector<std::uint32_t>& indices,
                                          const std::vector<glm::vec2>&     uvs = {}) override;
    [[nodiscard]] eve::Result<void> setTransform(const glm::mat4& transform) override;
    [[nodiscard]] eve::Result<void> setDeformedPositions(const std::vector<glm::vec3>& worldPositions) override;
    [[nodiscard]] bool              isValid() const noexcept override;
    [[nodiscard]] eve::Result<SurfaceSample>     evaluate(const SurfaceLocation& location,
                                                          eve::Duration          poseDelta) const override;
    [[nodiscard]] eve::Result<SurfaceLocation>   project(const glm::vec3& worldPosition,
                                                         float            maxDistance) const override;
    [[nodiscard]] eve::Result<SurfaceWalkResult> walk(const SurfaceLocation& start, const glm::vec3& displacement,
                                                      int maxCrossings = 16) const override;
 
private:
    FluidSurfaceBinding* binding_ = nullptr;
};
 
class ScreenSpaceSurfaceReconstructionAdapter final : public IScreenSpaceSurfaceReconstruction {
public:
    ScreenSpaceSurfaceReconstructionAdapter(const FluidSurfaceParams& params, bool preferGpu);
    ~ScreenSpaceSurfaceReconstructionAdapter() override;
 
    ScreenSpaceSurfaceReconstructionAdapter(const ScreenSpaceSurfaceReconstructionAdapter&)            = delete;
    ScreenSpaceSurfaceReconstructionAdapter& operator=(const ScreenSpaceSurfaceReconstructionAdapter&) = delete;
 
    [[nodiscard]] eve::Result<void> reconstruct(std::span<const glm::vec3> positions, float particleRadius) override;
    [[nodiscard]] eve::Result<void> occlude(std::span<const float> sceneDepth, float depthBias = 0.001f) override;
    [[nodiscard]] int               width() const noexcept override;
    [[nodiscard]] int               height() const noexcept override;
    [[nodiscard]] std::span<const float>        depth() const noexcept override;
    [[nodiscard]] std::span<const glm::vec3>    normals() const noexcept override;
    [[nodiscard]] std::span<const float>        thickness() const noexcept override;
    [[nodiscard]] std::span<const std::uint8_t> color() const noexcept override;
    [[nodiscard]] bool                          usingGpu() const noexcept override;
 
private:
    std::unique_ptr<FluidSurfaceRenderer> renderer_;
};
 
}  // namespace eve::fluids