GeneratedArtifact.h

浏览该文件的文档.

#pragma once
 
#include "common/ArtifactPublication.h"
#include "common/Generation.h"
#include "common/Identity.h"
#include "common/Result.h"
#include "common/SchemaVersion.h"
#include "common/Snapshot.h"
#include "common/Value.h"
#include "procgen/Grid2D.h"
#include "procgen/MeshBuild.h"
#include "procgen/Params.h"
#include "procgen/PointSet.h"
 
#include <cstdint>
#include <functional>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <unordered_map>
#include <utility>
#include <variant>
#include <vector>
 
namespace eve::procgen {
 
using ArtifactId = eve::ArtifactId;
 
class EVENGINE_API_DOMAINS BuildKey {
public:
    BuildKey() = default;
 
    [[nodiscard]] static std::optional<BuildKey> fromCanonical(std::string_view canonical);
 
    [[nodiscard]] static std::optional<BuildKey> forRecipe(std::string_view recipeId, const Params& params);
 
    [[nodiscard]] bool empty() const noexcept { return value_.empty(); }
    [[nodiscard]] const std::string& format() const noexcept { return value_; }
    friend bool                      operator==(const BuildKey&, const BuildKey&) noexcept = default;
 
private:
    explicit BuildKey(std::string value) : value_(std::move(value)) {}
    std::string value_;
};
 
}  // namespace eve::procgen
 
namespace std {
template <>
struct hash<eve::procgen::BuildKey> {
    size_t operator()(const eve::procgen::BuildKey& key) const noexcept {
        return std::hash<std::string>{}(key.format());
    }
};
}  // namespace std
 
namespace eve::procgen {
 
struct EVENGINE_API_DOMAINS Bounds {
    float minX  = 0.f;
    float minY  = 0.f;
    float minZ  = 0.f;
    float maxX  = 0.f;
    float maxY  = 0.f;
    float maxZ  = 0.f;
    bool  valid = false;
 
    void include(float x, float y, float z) noexcept;
    [[nodiscard]] bool isValid() const noexcept { return valid; }
};
 
enum class ArtifactType : std::uint8_t {
    Grid,
    PointSet,
    MeshData,
    ImageData,
    Collider,
    Composite,
};
 
struct ImageData {
    int                       width    = 0;
    int                       height   = 0;
    int                       channels = 0;
    std::string               format;
    std::vector<std::uint8_t> pixels;
 
    [[nodiscard]] bool isValid() const noexcept;
};
 
struct EVENGINE_API_DOMAINS Collider {
    std::vector<float>         vertices;
    std::vector<std::uint32_t> indices;
    Bounds                     bounds;
    std::string                shape = "triangle_mesh";
 
    [[nodiscard]] bool isValid() const noexcept;
};
 
using MeshData = MeshBuild;
 
using ArtifactLeafPayload = std::variant<Grid2D, PointSet, MeshData, ImageData, Collider>;
 
struct ArtifactPart {
    ArtifactId              id;
    ArtifactType            type = ArtifactType::Grid;
    eve::SchemaVersion      schemaVersion{1};
    BuildKey                buildKey;
    Bounds                  bounds;
    std::vector<ArtifactId> dependencies;
    eve::Value::Object      metadata;
    ArtifactLeafPayload     payload;
    std::string             role;
};
 
struct EVENGINE_API_DOMAINS CompositeArtifact {
    std::vector<ArtifactPart> children;
 
    [[nodiscard]] const ArtifactPart* find(std::string_view role) const noexcept;
    [[nodiscard]] bool has(std::string_view role) const noexcept { return find(role) != nullptr; }
};
 
struct GeneratedArtifact {
    ArtifactId              id;
    ArtifactType            type = ArtifactType::Grid;
    eve::SchemaVersion      schemaVersion{1};
    BuildKey                buildKey;
    Bounds                  bounds;
    std::vector<ArtifactId> dependencies;
    eve::Value::Object      metadata;
    using Payload = std::variant<Grid2D, PointSet, MeshData, ImageData, Collider, CompositeArtifact>;
    Payload payload;
};
 
[[nodiscard]] ArtifactType artifactType(const GeneratedArtifact::Payload& payload) noexcept;
[[nodiscard]] const char* artifactTypeName(ArtifactType type) noexcept;
 
[[nodiscard]] EVENGINE_API_DOMAINS eve::Result<GeneratedArtifact> makeArtifact(
    ArtifactId id, ArtifactType type, eve::SchemaVersion schemaVersion, BuildKey buildKey, Bounds bounds,
    std::vector<ArtifactId> dependencies, eve::Value::Object metadata, GeneratedArtifact::Payload payload);
 
[[nodiscard]] EVENGINE_API_DOMAINS eve::Result<ArtifactPart> makeArtifactPart(
    std::string role, ArtifactId id, ArtifactType type, eve::SchemaVersion schemaVersion, BuildKey buildKey,
    Bounds bounds, std::vector<ArtifactId> dependencies, eve::Value::Object metadata, ArtifactLeafPayload payload);
 
class EVENGINE_API_DOMAINS ArtifactStore {
public:
    [[nodiscard]] eve::Result<ArtifactId> publish(GeneratedArtifact artifact);
 
    [[nodiscard]] eve::Result<std::vector<ArtifactId>> publishBatch(std::vector<GeneratedArtifact> artifacts);
 
    [[nodiscard]] eve::Result<std::unique_ptr<eve::artifact::PreparedPublication>> stagePublish(
        GeneratedArtifact artifact);
 
    [[nodiscard]] eve::Result<eve::Value> snapshotState() const;
 
    [[nodiscard]] eve::Result<void> restoreState(const eve::Value& state);
 
    [[nodiscard]] const GeneratedArtifact* find(ArtifactId id) const noexcept;
    [[nodiscard]] const ArtifactPart* findPart(ArtifactId id) const noexcept;
    [[nodiscard]] std::optional<ArtifactType> typeOf(ArtifactId id) const noexcept;
    [[nodiscard]] std::vector<ArtifactId> findByBuildKey(const BuildKey& key) const;
    [[nodiscard]] eve::Result<void> remove(ArtifactId id);
    void clear() noexcept;
    [[nodiscard]] std::size_t size() const noexcept { return artifacts_.size(); }
    [[nodiscard]] std::size_t partCount() const noexcept;
 
private:
    friend class ArtifactStoreStage;
    void commitStaged(std::vector<GeneratedArtifact> artifacts) noexcept;
    void rollbackStaged() noexcept;
 
    std::unordered_map<ArtifactId, GeneratedArtifact> artifacts_;
    std::unordered_map<ArtifactId, ArtifactId>        partOwners_;
    bool                                              stageActive_ = false;
};
 
[[nodiscard]] EVENGINE_API_DOMAINS eve::Result<GeneratedArtifact> generateHexTerrainArtifact(const Params& params,
                                                                                             ArtifactId    id);
 
[[nodiscard]] EVENGINE_API_DOMAINS eve::Result<GeneratedArtifact> generateCastleArtifact(const Params& params,
                                                                                         ArtifactId    id);
 
[[nodiscard]] EVENGINE_API_DOMAINS eve::Result<GeneratedArtifact> generateRoadNetworkArtifact(const Params& params,
                                                                                              ArtifactId    id);
 
[[nodiscard]] EVENGINE_API_DOMAINS eve::Result<GeneratedArtifact> generateMeshArtifact(std::string_view recipeId,
                                                                                       const Params&    params,
                                                                                       ArtifactId       id);
 
}  // namespace eve::procgen