MeshModifierGraph.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/Result.h"
#include "procgen/MeshBuild.h"
#include "procgen/spline/SplinePath.h"
 
#include <cstdint>
#include <string>
#include <string_view>
#include <unordered_map>
#include <vector>
 
namespace eve::procgen {
 
struct MeshModifierNodeMetric {
    std::string id;
    int         vertexCount   = 0;
    int         triangleCount = 0;
    float       milliseconds  = 0.f;
    bool        cacheHit      = false;
    bool        fused         = false;
};
 
struct SplineProfilePoint {
    float x = 0.f;
    float y = 0.f;
};
 
struct SplineProfile {
    std::vector<SplineProfilePoint> points;
    bool                            closed = true;
};
 
class EVENGINE_API_DOMAINS MeshModifierGraph {
public:
    [[nodiscard]] Result<void> addNode(std::string id, std::string operation);
    [[nodiscard]] Result<void> removeNode(std::string_view id);
    [[nodiscard]] Result<void> connect(std::string_view fromId, std::string_view toId, int inputIndex = 0);
    [[nodiscard]] Result<void> disconnect(std::string_view toId, int inputIndex = 0);
    [[nodiscard]] Result<void> setNodeMesh(std::string_view id, const MeshBuild& mesh);
    [[nodiscard]] Result<void> setNodeSplinePath(std::string_view id, const SplinePath& path);
    [[nodiscard]] Result<void> setNodeSplineProfile(std::string_view id, const SplineProfile& profile);
    [[nodiscard]] Result<void> setNodeFloat(std::string_view id, std::string key, float value);
    [[nodiscard]] Result<void> setNodeInt(std::string_view id, std::string key, int value);
    [[nodiscard]] Result<void> setNodeString(std::string_view id, std::string key, std::string value);
 
    [[nodiscard]] Result<void> validateResult() const;
    [[nodiscard]] Result<MeshBuild> executeResult(std::string_view outputId);
 
    void clearCache();
    [[nodiscard]] std::uint64_t revision() const noexcept { return revision_; }
    [[nodiscard]] std::uint64_t executionPlanBuildCount() const noexcept { return executionPlanBuildCount_; }
    [[nodiscard]] int compiledSegmentCount() const noexcept { return compiledSegmentCount_; }
    [[nodiscard]] int fusedOperationCount() const noexcept { return fusedOperationCount_; }
    [[nodiscard]] const std::vector<MeshModifierNodeMetric>& metrics() const noexcept { return metrics_; }
 
    [[nodiscard]] bool hasNode(std::string_view id) const;
    [[nodiscard]] int nodeCount() const noexcept { return static_cast<int>(nodeOrder_.size()); }
    [[nodiscard]] std::string nodeId(int index) const;
    [[nodiscard]] std::string nodeOperation(std::string_view id) const;
 
    [[nodiscard]] static int operationCount();
    [[nodiscard]] static std::string operationId(int index);
    [[nodiscard]] static int operationInputCount(std::string_view operation);
    [[nodiscard]] static int operationParamCount(std::string_view operation);
    [[nodiscard]] static std::string operationParamKey(std::string_view operation, int index);
    [[nodiscard]] static std::string operationParamKind(std::string_view operation, int index);
    [[nodiscard]] static std::string operationParamDefault(std::string_view operation, int index);
 
private:
    struct Node {
        std::string                                  id;
        std::string                                  operation;
        std::vector<std::string>                     inputs;
        std::unordered_map<std::string, float>       floats;
        std::unordered_map<std::string, int>         ints;
        std::unordered_map<std::string, std::string> strings;
        MeshBuild                                    inputMesh;
        bool                                         hasInputMesh = false;
        SplinePath                                   splinePath;
        bool                                         hasSplinePath = false;
        SplineProfile                                splineProfile;
        bool                                         hasSplineProfile = false;
        MeshBuild                                    cache;
        bool                                         cacheValid = false;
    };
    struct Segment {
        std::vector<std::string> nodes;
        bool                     fusedVertexTraversal = false;
    };
 
    [[nodiscard]] Result<std::vector<Segment>> compilePlan(std::string_view outputId) const;
    [[nodiscard]] Result<MeshBuild> executeNode(const Node&                                       node,
                                                const std::unordered_map<std::string, MeshBuild>& outputs) const;
    [[nodiscard]] Result<MeshBuild> executeFused(const Segment&                                    segment,
                                                 const std::unordered_map<std::string, MeshBuild>& outputs) const;
    [[nodiscard]] Result<void> validateNode(std::string_view id, std::unordered_map<std::string, int>& states) const;
    void                       invalidate();
 
    std::unordered_map<std::string, Node> nodes_;
    std::vector<std::string>              nodeOrder_;
    std::vector<MeshModifierNodeMetric>   metrics_;
    std::uint64_t                         revision_                = 0;
    std::uint64_t                         executionPlanBuildCount_ = 0;
    int                                   compiledSegmentCount_    = 0;
    int                                   fusedOperationCount_     = 0;
};
 
}  // namespace eve::procgen