PointGraph.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/BorrowedRef.h"
#include "procgen/PointSet.h"
#include "procgen/SpatialData.h"
 
#include <cstdint>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <unordered_map>
#include <vector>
 
namespace eve::procgen {
 
class BiomeRules;
class PointCompute;
class ShapeGrammar;
 
struct PointGraphNodeMetric {
    std::string id;
    int         outputCount  = 0;
    float       milliseconds = 0.f;
    bool        cacheHit     = false;
    std::string backend        = "cpu";
    float       minX           = 0.f;
    float       minY           = 0.f;
    float       minZ           = 0.f;
    float       maxX           = 0.f;
    float       maxY           = 0.f;
    float       maxZ           = 0.f;
    float       averageDensity = 0.f;
};
 
struct PointGraphColumnInfo {
    std::string name;
    std::string type;   
    std::string domain; 
};
 
struct PointGraphInspectReport {
    std::string                     nodeId;
    int                             pointCount = 0;
    std::vector<PointGraphColumnInfo> columns;
    std::vector<float>              sampleFloats;
    int                             sampleCount = 0;
};
 
class EVENGINE_API_DOMAINS PointGraph {
public:
    PointGraph();
    bool addNode(const std::string& id, const std::string& operation);
    bool removeNode(const std::string& id);
    bool hasNode(const std::string& id) const;
    int  getNodeCount() const;
    std::string getNodeId(int index) const;
    std::string getNodeOperation(const std::string& id) const;
 
    bool connect(const std::string& fromId, const std::string& toId, int inputIndex = 0);
    bool disconnect(const std::string& toId, int inputIndex = 0);
    std::string getInputNode(const std::string& nodeId, int inputIndex) const;
 
    bool setNodePoints(const std::string& id, PointSet* points);
    bool setNodeSpatial(const std::string& id, SpatialData* spatial);
 
    [[nodiscard]] Result<void> setBindingSpatial(const std::string& name, SpatialData* spatial);
    [[nodiscard]] Result<void> setBindingPoints(const std::string& name, PointSet* points);
    [[nodiscard]] Result<void> clearBinding(const std::string& name);
    void clearBindings();
    int getBindingCount() const;
    std::string getBindingName(int index) const;
    std::string getBindingType(const std::string& name) const;
 
    [[nodiscard]] Result<PointGraphInspectReport> inspectNode(const std::string& id, int sampleLimit = 0) const;
 
    bool setNodeBiomeRules(const std::string& id, BiomeRules* rules);
    bool setNodeShapeGrammar(const std::string& id, ShapeGrammar* grammar);
    bool setNodeFloat(const std::string& id, const std::string& key, float value);
    bool setNodeInt(const std::string& id, const std::string& key, int value);
    bool setNodeString(const std::string& id, const std::string& key, const std::string& value);
    bool exposeParameter(const std::string& name, const std::string& nodeId,
                         const std::string& key);
    int         getParameterCount() const;
    std::string getParameterName(int index) const;
    std::string getParameterKind(const std::string& name) const;
    bool        hasParameterOverride(const std::string& name) const;
    bool        setParameterFloat(const std::string& name, float value);
    bool        setParameterInt(const std::string& name, int value);
    bool        setParameterString(const std::string& name, const std::string& value);
    float       getParameterFloat(const std::string& name, float fallback) const;
    int         getParameterInt(const std::string& name, int fallback) const;
    std::string getParameterString(const std::string& name, const std::string& fallback) const;
    bool        clearParameterOverride(const std::string& name);
    bool setNodeSubgraph(const std::string& id, PointGraph* graph, const std::string& inputNode,
                         const std::string& outputNode);
 
    [[nodiscard]] Result<PointSet> executeResult(std::string_view outputId);
    [[nodiscard]] Result<void> validateResult() const;
    PointSet* execute(const std::string& outputId);
    void setExecutionNodeBudget(int nodes);
    int  getExecutionNodeBudget() const;
    void setMaxNodeOutputPoints(int points);
    int  getMaxNodeOutputPoints() const;
    bool setComputePolicy(const std::string& policy);
    std::string getComputePolicy() const;
    void setComputeMinimumPoints(int points);
    int getComputeMinimumPoints() const;
    void requestCancel();
    void resetCancellation();
    bool wasCancelled() const;
    bool validate();
    std::string getError() const;
    void        clearCache();
    uint64_t    getRevision() const;
    int         getExecutionCount() const;
    int         getCacheHitCount() const;
    int getCompiledSegmentCount() const;
    uint64_t getExecutionPlanBuildCount() const;
 
    int         getMetricCount() const;
    std::string getMetricNodeId(int index) const;
    int         getMetricOutputCount(int index) const;
    float       getMetricMilliseconds(int index) const;
    bool        isMetricCacheHit(int index) const;
    std::string getMetricBackend(int index) const;
    std::string getComputeFallbackReason() const;
    uint64_t getComputeUploadCount() const;
    uint64_t getComputeDispatchCount() const;
    uint64_t getComputeReadbackCount() const;
    uint64_t getComputeBufferReuseCount() const;
    uint64_t getComputePeakBufferBytes() const;
    int getLastFusedTransformCount() const;
    float getMetricMinX(int index) const;
    float getMetricMinY(int index) const;
    float getMetricMinZ(int index) const;
    float getMetricMaxX(int index) const;
    float getMetricMaxY(int index) const;
    float getMetricMaxZ(int index) const;
    float getMetricAverageDensity(int index) const;
    PointSet* getNodeOutput(const std::string& id) const;
    std::string debugReport() const;
    std::string serializeDefinition() const;
    bool deserializeDefinition(const std::string& definition);
    PointGraph* instantiate() const;
 
    static int         getOperationCount();
    static std::string getOperationId(int index);
    static int         getOperationInputCount(const std::string& operation);
    static int         getOperationParamCount(const std::string& operation);
    static std::string getOperationParamKey(const std::string& operation, int index);
    static std::string getOperationParamKind(const std::string& operation, int index);
    static std::string getOperationParamDefault(const std::string& operation, int index);
 
private:
    struct Node {
        std::string id;
        std::string operation;
        std::string inputs[2];
        std::unordered_map<std::string, float>       floats;
        std::unordered_map<std::string, int>         ints;
        std::unordered_map<std::string, std::string> strings;
        PointSet                                    points;
        bool                                        hasPoints = false;
        std::shared_ptr<SpatialData>                 spatial;
        std::shared_ptr<BiomeRules>                  biomeRules;
        std::shared_ptr<ShapeGrammar>                shapeGrammar;
        std::shared_ptr<PointGraph>                  subgraph;
        std::string                                  subgraphInput;
        std::string                                  subgraphOutput;
        PointSet                                    cache;
        PointGraphNodeMetric                        cacheMetric;
        bool                                        cacheValid = false;
        bool                                         deferredTransformValid = false;
    };
 
    struct GraphBinding {
        std::shared_ptr<SpatialData> spatial;
        std::shared_ptr<PointSet>    points;
        bool                         isSpatial = false;
    };
    struct ParameterBinding {
        std::string nodeId;
        std::string key;
        std::string kind;
    };
    struct ExecutionSegment {
        std::vector<std::string> nodes;
        bool                     gpuTransformChain = false;
    };
    struct ExecutionPlan {
        std::vector<std::string>                     topologicalOrder;
        std::vector<ExecutionSegment>                segments;
        std::unordered_map<std::string, std::size_t> segmentByOutput;
    };
 
    [[nodiscard]] ResultRef<const PointSet>           evaluate(const std::string&                    id,
                                                               std::unordered_map<std::string, int>& states);
    [[nodiscard]] Result<OptionalRef<const PointSet>> evaluateTransformSegment(
        const std::string& id, std::unordered_map<std::string, int>& states);
    PointSet*       materializeNodeOutput(const std::string& id) const;
    [[nodiscard]] Result<void> validateNode(const std::string& id, std::unordered_map<std::string, int>& states) const;
    void            invalidate();
    void            invalidateFrom(const std::string& id);
    void            invalidateTopology(const std::string& changedNode);
    [[nodiscard]] Result<void> compileExecutionPlan(const std::string& outputId);
    float           floatValue(const Node& node, const std::string& key, float fallback) const;
    int             intValue(const Node& node, const std::string& key, int fallback) const;
    std::string     stringValue(const Node& node, const std::string& key,
                                const std::string& fallback = {}) const;
    [[nodiscard]] Result<std::shared_ptr<SpatialData>> resolveNodeSpatial(const Node& node) const;
    [[nodiscard]] Result<std::shared_ptr<PointSet>>    resolveBindingPoints(const std::string& name) const;
 
 
 
    std::unordered_map<std::string, GraphBinding> bindings_;
    std::vector<std::string>                      bindingOrder_;
    std::unordered_map<std::string, Node>             nodes_;
    std::vector<std::string>                          nodeOrder_;
    std::unordered_map<std::string, ParameterBinding> parameters_;
    std::vector<std::string>                          parameterOrder_;
    std::unordered_map<std::string, float>            floatOverrides_;
    std::unordered_map<std::string, int>              intOverrides_;
    std::unordered_map<std::string, std::string>      stringOverrides_;
    std::vector<PointGraphNodeMetric>                 metrics_;
    std::string                                       error_;
    int                                               executionCount_      = 0;
    int                                               cacheHitCount_       = 0;
    uint64_t                                          revision_            = 0;
    uint64_t                                                              executionPlanBuildCount_ = 0;
    std::shared_ptr<const ExecutionPlan>                                  executionPlan_;
    std::unordered_map<std::string, std::shared_ptr<const ExecutionPlan>> executionPlans_;
    std::vector<std::string>                                              executionPlanRecency_;
    int                                               executionNodeBudget_ = 0;
    int                                               maxNodeOutputPoints_ = 0;
    std::string                                       computePolicy_        = "auto";
    int                                               computeMinimumPoints_ = 1024;
    std::string                                       computeFallbackReason_;
    std::shared_ptr<PointCompute>                     pointCompute_;
    int                                               evaluatedNodes_      = 0;
    bool                                              cancelRequested_     = false;
    bool                                              lastCancelled_       = false;
};
 
}  // namespace eve::procgen