ArtifactPublication.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/Identity.h"
#include "common/Result.h"
#include "common/Value.h"
 
#include <cstdint>
#include <memory>
#include <span>
#include <string>
#include <string_view>
 
namespace eve::artifact {
 
enum class PartKind : std::uint8_t {
    Grid,
    PointSet,
    MeshData,
    ImageData,
    Collider,
};
 
struct 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;
};
 
struct Point {
    float x = 0.f;
    float y = 0.f;
    float z = 0.f;
};
 
struct PartView {
    PersistentId                   id;
    std::string_view               role;
    PartKind                       kind          = PartKind::Grid;
    std::uint64_t                  schemaVersion = 1;
    std::string_view               buildKey;
    Bounds                         bounds;
    std::span<const float>         positions;
    std::span<const float>         normals;
    std::span<const float>         uvs;
    std::span<const std::uint32_t> indices;
    std::int32_t                   width  = 0;
    std::int32_t                   height = 0;
    std::span<const std::uint32_t> cells;
    std::span<const Point>         points;
    std::string_view               metadataJson;
};
 
struct PublicationView {
    PersistentId              id;
    std::uint64_t             schemaVersion = 1;
    std::string_view          buildKey;
    Bounds                    bounds;
    std::span<const PartView> parts;
    std::string_view          metadataJson;
};
 
class PreparedPublication {
public:
    virtual ~PreparedPublication() = default;
    virtual void commit() noexcept = 0;
    virtual void rollback() noexcept = 0;
};
 
class EVENGINE_API_FOUNDATION ProviderContract {
public:
    virtual ~ProviderContract() = default;
 
    [[nodiscard]] virtual eve::Result<std::unique_ptr<PreparedPublication>> prepare(
        const PublicationView& publication) = 0;
 
    [[nodiscard]] virtual eve::Result<eve::Value> snapshotState() const;
 
    [[nodiscard]] virtual eve::Result<void> restoreState(const eve::Value& state);
 
    [[nodiscard]] virtual bool emptyState() const noexcept { return true; }
 
    virtual void clearState() noexcept {}
};
 
class ISceneArtifactAdapter : public ProviderContract {
public:
    static constexpr const char* capabilityName = "eve.procgen.ISceneArtifactAdapter";
    ~ISceneArtifactAdapter() override           = default;
};
 
class IMapArtifactAdapter : public ProviderContract {
public:
    static constexpr const char* capabilityName = "eve.procgen.IMapArtifactAdapter";
    ~IMapArtifactAdapter() override             = default;
};
 
class IGraphicsArtifactAdapter : public ProviderContract {
public:
    static constexpr const char* capabilityName = "eve.procgen.IGraphicsArtifactAdapter";
    ~IGraphicsArtifactAdapter() override        = default;
};
 
class IPhysicsArtifactAdapter : public ProviderContract {
public:
    static constexpr const char* capabilityName = "eve.procgen.IPhysicsArtifactAdapter";
    ~IPhysicsArtifactAdapter() override         = default;
};
 
struct PublishOptions {
    bool scene    = false;
    bool graphics = false;
    bool physics  = false;
    bool map = false;
};
 
struct PublishReceipt {
    PersistentId id;
    bool         scenePublished    = false;
    bool         graphicsPublished = false;
    bool         physicsPublished  = false;
    bool         mapPublished      = false;
};
 
}  // namespace eve::artifact