EditorSurfaceFluidPreview.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "fluids/editor/EditorSurfaceFluidTarget.h"
#include "graphics/editor/EditorOffscreenPreview.h"
 
#include <array>
#include <cstdint>
#include <vector>
 
namespace eve::editor {
 
struct SurfaceFluidPreviewSeed {
    std::uint32_t         triangle = 0;
    std::array<double, 3> barycentric{1.0, 0.0, 0.0};
    double                volume = 1.0;
    std::array<double, 3> velocity{0.0, 0.0, 0.0};
    auto                  operator<=>(const SurfaceFluidPreviewSeed&) const = default;
};
 
struct SurfaceFluidPreviewRequest {
    StableId                             previewId;
    Revision                             documentRevision = 0;
    int                                  width            = 512;
    int                                  height           = 512;
    double                               seconds          = 0.0;
    double                               fixedStep        = 1.0 / 60.0;
    std::vector<std::array<double, 3>>   positions;
    std::vector<std::uint32_t>           indices;
    std::vector<std::array<double, 2>>   uvs;
    std::vector<SurfaceFluidPreviewSeed> seeds;
    std::size_t                          maximumVertices = 1000000;
    std::size_t                          maximumDroplets = 100000;
    std::size_t                          maximumSteps    = 1000000;
};
 
struct SurfaceFluidPreviewDroplet {
    std::uint64_t         id = 0;
    std::array<double, 3> position{};
    std::array<double, 3> normal{};
    std::array<double, 3> majorAxis{};
    std::array<double, 3> minorAxis{};
    double                capHeight                                            = 0.0;
    double                wetness                                              = 0.0;
    auto                  operator<=>(const SurfaceFluidPreviewDroplet&) const = default;
};
 
struct SurfaceFluidPreviewSnapshot {
    EditorStatus                            status           = EditorStatus::Failed;
    Revision                                documentRevision = 0;
    double                                  simulatedSeconds = 0.0;
    std::vector<SurfaceFluidPreviewDroplet> droplets;
    std::vector<double>                     vertexWetness;
    std::vector<EditorDiagnostic>           diagnostics;
};
 
class EVENGINE_API_EDITORS SurfaceFluidPreviewService {
public:
    SurfaceFluidPreviewSnapshot build(const SurfaceFluidTarget&         target,
                                      const SurfaceFluidPreviewRequest& request) const;
};
 
class ISurfaceFluidPreviewRenderer {
public:
    virtual ~ISurfaceFluidPreviewRenderer() = default;
    virtual Result<void> draw(const SurfaceFluidPreviewSnapshot& snapshot) = 0;
};
 
class EVENGINE_API_EDITORS SurfaceFluidOffscreenPreviewService {
public:
    SurfaceFluidOffscreenPreviewService(GraphicsOffscreenPreviewService* previews,
                                        ISurfaceFluidPreviewRenderer*    renderer)
        : previews_(previews), renderer_(renderer) {}
    Result<OffscreenPreviewArtifact> render(const SurfaceFluidTarget&         target,
                                                  const SurfaceFluidPreviewRequest& request) const;
 
private:
    GraphicsOffscreenPreviewService* previews_ = nullptr;
    ISurfaceFluidPreviewRenderer*    renderer_ = nullptr;
};
 
}  // namespace eve::editor