FluidSurfaceRenderer.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include <glm/glm.hpp>
#include "common/Result.h"
 
#include <cstdint>
#include <memory>
#include <span>
#include <string>
#include <vector>
 
namespace eve::gpgpu {
class ComputeShader;
class Gpgpu;
class GpuBuffer;
class Sequence;
}  // namespace eve::gpgpu
 
namespace eve::graphics {
class Graphics;
class Texture;
}  // namespace eve::graphics
 
namespace eve::fluids {
 
class FluidSimulator;
class VolumeFluid;
class VolumeFluidDiffuse;
 
enum class FluidBlendFactor : int {
    Zero                     = 0,
    One                      = 1,
    DestinationColor         = 2,
    SourceColor              = 3,
    OneMinusDestinationColor = 4,
    SourceAlpha              = 5,
    OneMinusSourceColor      = 6,
    DestinationAlpha         = 7,
    OneMinusDestinationAlpha = 8,
    SourceAlphaSaturate      = 9,
    OneMinusSourceAlpha      = 10,
};
 
struct FluidSurfaceParams {
    glm::vec3 eye{0.f, 0.f, -2.6f};
    glm::vec3 target{0.f};
    glm::vec3 up{0.f, 1.f, 0.f};
    float     fovYDeg          = 55.f;
    bool      orthographic     = false;
    float     orthographicSize = 1.f;
    float     aspect           = 1.f;
    float     nearZ            = 0.05f;
    float     farZ             = 20.f;
    int       width            = 160;
    int       height           = 160;
    float     particleRadius   = 0.05f;
    int       smoothIterations = 2;
    float     depthFalloff     = 0.03f;
    float     thicknessScale   = 1.f;
    int mode = 0;
};
 
struct FluidRendererSettings {
    int   blendSource = 5, blendDestination = 10;
    int   particleBlendSource = 2, particleBlendDestination = 0;
    bool  particleZWrite      = false;
    float thicknessCutoff     = 1.2f;
    int   thicknessDownsample = 2;
    bool  generateSurface     = true;
    float blurRadius          = .02f;
    int   surfaceDownsample   = 1;
    bool  lighting            = true;
    float smoothness = .8f, metalness = 0.f, ambientMultiplier = 1.f;
    bool  generateReflection = true;
    float reflection         = .2f;
    bool  generateRefraction = true;
    float transparency = 1.f, absorption = 5.f, refraction = .01f;
    int   refractionDownsample = 1;
    bool  generateFoam         = true;
    int   foamDownsample       = 1;
};
 
class EVENGINE_API_DOMAINS FluidSurfaceRenderer {
public:
    FluidSurfaceRenderer(const FluidSurfaceParams& params, bool preferGpu);
    ~FluidSurfaceRenderer();
 
    FluidSurfaceRenderer(const FluidSurfaceRenderer&)            = delete;
    FluidSurfaceRenderer& operator=(const FluidSurfaceRenderer&) = delete;
 
    void render(const std::vector<glm::vec3>& positions, float particleRadius);
 
    void render(const FluidSimulator& sim);
    void renderVolume(const VolumeFluid& sim);
    [[nodiscard]] Result<void> renderVolumeInterpolated(const VolumeFluid& sim, float alpha);
    void renderVolumeColorOnly(const VolumeFluid& sim);
    [[nodiscard]] Result<void> renderGasVolume(const VolumeFluid& sim, float absorption = 5.f);
    [[nodiscard]] Result<void> renderVolumeWithoutSurface(const VolumeFluid& sim, float absorption = 5.f);
    [[nodiscard]] Result<void> renderConfiguredVolume(const VolumeFluid& sim);
    [[nodiscard]] Result<void> prepare();
    [[nodiscard]] Result<void> copyToTexture(graphics::Graphics* graphics, graphics::Texture* texture);
    [[nodiscard]] Result<void> renderVolumeColorToTexture(const VolumeFluid& sim, graphics::Graphics* graphics,
                                                          graphics::Texture* texture);
    [[nodiscard]] Result<void> compositeDiffuse(const VolumeFluidDiffuse& pool, float radius, float opacity,
                                                float fadeSeconds);
    [[nodiscard]] Result<void> configureFoam(bool enabled, int downsample = 1);
 
    [[nodiscard]] Result<void> occludeWithSceneDepth(std::span<const float> sceneDepth, float depthBias = 0.001f);
 
    [[nodiscard]] Result<void> compositeSceneRefraction(std::span<const uint8_t> sceneColor, float distortion = 8.f,
                                                        float absorption = 3.f);
    [[nodiscard]] Result<void> configureRefraction(float transparency, float absorption, float coefficient,
                                                   int downsample);
    [[nodiscard]] Result<void> configureRefractionEnabled(bool enabled);
    [[nodiscard]] Result<void> compositeConfiguredSceneRefraction(std::span<const uint8_t> sceneColor);
 
    [[nodiscard]] Result<void> configureSurfaceBlend(int source, int destination);
    [[nodiscard]] Result<void> compositeConfiguredSurfaceBlend(std::span<const uint8_t> sceneColor);
    [[nodiscard]] Result<void> configureParticleBlend(int source, int destination, bool depthWrite);
 
    [[nodiscard]] Result<void> configureSurface(float thicknessScale, float thicknessCutoff, float depthFalloff,
                                                int smoothIterations);
    [[nodiscard]] Result<void> configureSurfaceEnabled(bool enabled);
    [[nodiscard]] Result<void> configureRendererSettings(const FluidRendererSettings& settings);
    [[nodiscard]] FluidRendererSettings rendererSettings() const noexcept;
    [[nodiscard]] Result<void> configureSurfaceBlurRadius(float radius);
    [[nodiscard]] Result<void> configureMaterial(bool lighting, float smoothness, float metalness,
                                                 float ambientMultiplier, float reflection, float opacity);
    [[nodiscard]] Result<void> configureReflection(bool enabled);
    [[nodiscard]] Result<void> configureColors(const glm::vec3& baseColor, const glm::vec3& reflectionColor);
    [[nodiscard]] Result<void> configureAnisotropy(bool enabled);
    [[nodiscard]] Result<void> configureSurfaceDownsample(int factor);
    [[nodiscard]] Result<void> configureThicknessDownsample(int factor);
    [[nodiscard]] Result<void> configureProjection(bool orthographic, float verticalHalfSize = 1.f);
 
    void renderFrom(FluidSimulator* sim);
 
    int getWidth() const { return params_.width; }
    int getHeight() const { return params_.height; }
 
    const std::vector<float>& depth() const { return depth_; }
 
    const std::vector<glm::vec3>& normals() const { return normals_; }
 
    const std::vector<float>& thickness() const { return thickness_; }
 
    const std::vector<uint8_t>& color() const { return color_; }
 
    bool usingGpu() const { return reducedRenderer_ ? reducedRenderer_->usingGpu() : gpuOk_; }
 
    void setMode(int mode) {
        params_.mode = mode;
        resetReducedRenderers();
    }
 
    void setCamera(const glm::vec3& eye, const glm::vec3& target, const glm::vec3& up, float fovYDeg);
 
    void writePpm(const std::string& path) const;
 
private:
    void                       renderInternal(const std::vector<glm::vec3>& positions, float particleRadius);
    void                       renderVolumeInternal(const VolumeFluid& sim, bool colorOnly, float alpha);
    [[nodiscard]] Result<void> renderVolumeCloud(const VolumeFluid& sim, float absorption, bool gasOnly);
    void renderCpu();
    bool ensureGpu();
    bool                       ensureMulticolorGpu();
    bool                       ensureAnisotropyGpu();
    void                       releaseGpu() noexcept;
    void uploadParticles();
    void                       buildAnisotropicSplats();
    void setCommonConstants(gpgpu::ComputeShader* shader, float falloff);
    void                       applyConfiguredShading();
    void                       refreshCustomShadingFlag();
    void                       ensureReducedRenderer();
    void                       expandReducedOutputs(bool colorOnly);
    void                       ensureThicknessRenderer();
    void                       replaceThicknessFromReduced();
    void                       resetReducedRenderers();
    static glm::vec4 blendFluidColor(FluidBlendFactor factor, const glm::vec4& source, const glm::vec4& destination);
 
    FluidSurfaceParams params_;
    bool               preferGpu_ = false;
    bool gpuAttempted_ = false;
    bool gpuOk_        = false;
 
    std::vector<glm::vec3> positions_;
    std::vector<glm::vec4> volumeColors_;
    glm::vec4 uniformVolumeColor_{0.f};
    bool      uniformVolumeGpuShade_    = false;
    bool      multicolorVolumeGpuShade_ = false;
    bool      multicolorGpuReady_       = false;
    bool auxiliaryCurrent_ = false;
    bool residentColorCurrent_ = false;
    bool                                  skipHostColorReadback_ = false;
    bool                                  customShading_         = false;
    bool                                  anisotropyEnabled_     = false;
    bool                                  anisotropicFrame_      = false;
    int                                   surfaceDownsample_     = 1;
    int                                   thicknessDownsample_   = 1;
    std::unique_ptr<FluidSurfaceRenderer> reducedRenderer_;
    std::unique_ptr<FluidSurfaceRenderer> thicknessRenderer_;
    float                                 thicknessCutoff_ = 0.f;
    bool                                  surfaceEnabled_  = true;
    float            surfaceBlurRadius_ = -1.f;
    bool             lighting_          = true;
    float            smoothness_        = .8f;
    float            metalness_         = 0.f;
    float            ambientMultiplier_ = .55f;
    float            reflection_        = .75f;
    bool             reflectionEnabled_ = true;
    float            opacity_           = .35f;
    glm::vec3        baseColor_{.05f, .32f, .72f};
    glm::vec3        reflectionColor_{.55f, .72f, 1.f};
    float            refractionTransparency_   = 1.f;
    bool             refractionEnabled_        = true;
    float            refractionAbsorption_     = 5.f;
    float            refractionCoefficient_    = .01f;
    int              refractionDownsample_     = 1;
    FluidBlendFactor surfaceBlendSource_       = FluidBlendFactor::SourceAlpha;
    FluidBlendFactor surfaceBlendDestination_  = FluidBlendFactor::OneMinusSourceAlpha;
    FluidBlendFactor particleBlendSource_      = FluidBlendFactor::DestinationColor;
    FluidBlendFactor particleBlendDestination_ = FluidBlendFactor::Zero;
    bool             particleDepthWrite_       = false;
    bool             particleBlendConfigured_  = false;
    std::vector<uint8_t>   refractionScratch_;
    std::vector<glm::vec4> volumeTint_;
    std::vector<float>     volumeTintWeights_;
    std::vector<glm::vec4> gasTintScratch_;
    std::vector<float>     gasDensityScratch_;
    struct GasSplat {
        float cx = 0.f, cy = 0.f, r = 0.f, z = 0.f;
        int   x0 = 0, x1 = -1, y0 = 0, y1 = -1;
    };
    std::vector<GasSplat> gasSplats_;
    std::vector<float> gpuParticles_;
    std::vector<float>     anisotropicSplats_;
    std::vector<glm::vec3> particleRadii_;
    std::vector<glm::vec4> particleOrientations_;
    std::vector<glm::vec4> gpuNormals_;
    std::vector<float>     depth_;
    std::vector<float>     depthScratch_;
    std::vector<float>     thickness_;
    std::vector<glm::vec3> normals_;
    std::vector<uint8_t>   color_;
    std::vector<glm::vec4> diffuseParticles_;
    bool                   foamEnabled_    = true;
    int                    foamDownsample_ = 1;
    std::vector<float> foamCoverageScratch_;
    struct DiffuseSplat {
        float x = 0.f, y = 0.f, r = 0.f, z = 0.f, alpha = 0.f;
        int   x0 = 0, x1 = -1, y0 = 0, y1 = -1;
    };
    std::vector<DiffuseSplat> diffuseSplats_;
 
    eve::gpgpu::Gpgpu*         gpgpu_               = nullptr;
    eve::gpgpu::ComputeShader* shClear_             = nullptr;
    eve::gpgpu::ComputeShader* shSplat_             = nullptr;
    eve::gpgpu::ComputeShader* shAnisotropicSplat_  = nullptr;
    eve::gpgpu::ComputeShader* shSmooth_            = nullptr;
    eve::gpgpu::ComputeShader* shNormal_            = nullptr;
    eve::gpgpu::ComputeShader* shShade_             = nullptr;
    eve::gpgpu::ComputeShader* shColorClear_        = nullptr;
    eve::gpgpu::ComputeShader* shColorSplat_        = nullptr;
    eve::gpgpu::GpuBuffer*     bufParts_            = nullptr;
    eve::gpgpu::GpuBuffer*     bufAnisotropicParts_ = nullptr;
    eve::gpgpu::GpuBuffer*     bufDepthA_           = nullptr;
    eve::gpgpu::GpuBuffer*     bufDepthB_           = nullptr;
    eve::gpgpu::GpuBuffer*     bufThick_            = nullptr;
    eve::gpgpu::GpuBuffer*     bufNormal_           = nullptr;
    eve::gpgpu::GpuBuffer*     bufColor_            = nullptr;
    eve::gpgpu::GpuBuffer*     bufParticleColors_   = nullptr;
    eve::gpgpu::GpuBuffer*     bufColorAccum_       = nullptr;
    eve::gpgpu::GpuBuffer*     stDepth_             = nullptr;
    eve::gpgpu::GpuBuffer*     stThick_             = nullptr;
    eve::gpgpu::GpuBuffer*     stNormal_            = nullptr;
    eve::gpgpu::GpuBuffer*     stColor_             = nullptr;
    eve::gpgpu::Sequence*      seq_                 = nullptr;
};
 
}  // namespace eve::fluids