GridGraph.h

浏览该文件的文档.

#pragma once
 
#include "common/BorrowedRef.h"
#include "procgen/Grid2D.h"
#include "procgen/PointSet.h"
 
#include <cstdint>
#include <memory>
#include <string>
#include <string_view>
#include <unordered_map>
#include <variant>
#include <vector>
 
namespace eve::procgen {
 
class PointGraph;
 
using GridGraphValue = std::variant<Grid2D, PointSet>;
 
enum class GridGraphValueType : std::uint8_t { Grid, PointSet };
 
class EVENGINE_API_DOMAINS GridGraph {
public:
    [[nodiscard]] Result<void> addNode(std::string id, std::string operation);
    [[nodiscard]] Result<void> connect(std::string_view fromId, std::string_view toId, int inputIndex = 0);
    [[nodiscard]] Result<void> setNodeGrid(std::string_view id, const Grid2D& grid);
    [[nodiscard]] Result<void> setNodeInt(std::string_view id, std::string key, int value);
    [[nodiscard]] Result<void> setNodeFloat(std::string_view id, std::string key, float value);
    [[nodiscard]] Result<void> setNodeString(std::string_view id, std::string key, std::string value);
    [[nodiscard]] Result<void> setNodePointSubgraph(std::string_view id, const PointGraph& graph, std::string inputNode,
                                                    std::string outputNode);
 
    [[nodiscard]] Result<GridGraphValue> execute(std::string_view outputId);
    [[nodiscard]] Result<void> validate(std::string_view outputId) const;
    void clearCache();
    [[nodiscard]] std::uint64_t revision() const noexcept { return revision_; }
    [[nodiscard]] std::string serializeDefinition() const;
    [[nodiscard]] Result<void> deserializeDefinition(std::string_view definition);
 
    [[nodiscard]] static int operationCount();
    [[nodiscard]] static std::string operationId(int index);
    [[nodiscard]] static Result<GridGraphValueType> operationOutputType(std::string_view operation);
 
private:
    struct Node {
        std::string                                  id;
        std::string                                  operation;
        std::string                                  inputs[3];
        std::unordered_map<std::string, int>         ints;
        std::unordered_map<std::string, float>       floats;
        std::unordered_map<std::string, std::string> strings;
        Grid2D                                       inputGrid;
        bool                                         hasInputGrid = false;
        std::shared_ptr<PointGraph>                  pointSubgraph;
        std::string                                  pointInputNode;
        std::string                                  pointOutputNode;
        GridGraphValue                               cache;
        bool                                         cacheValid = false;
    };
 
    [[nodiscard]] ResultRef<const GridGraphValue> evaluate(std::string_view                      id,
                                                           std::unordered_map<std::string, int>& states);
    void                                          invalidateFrom(std::string_view id);
 
    std::unordered_map<std::string, Node> nodes_;
    std::vector<std::string>              order_;
    std::uint64_t                         revision_ = 0;
};
 
}  // namespace eve::procgen