EditorAssetDatabase.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "editor/EditorProperty.h"
 
#include <optional>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace eve::editor {
 
enum class AssetStatus { Ready, Scanning, Importing, Stale, MissingSource, MissingArtifact, Warning, Error, Deleted };
 
struct AssetRecord {
    AssetGuid                     guid;
    std::string                   logicalUri;
    std::string                   typeId;
    std::uint32_t                 schemaVersion = 1;
    std::string                   sourceUri;
    std::string                   sourceHash;
    std::string                   importerId;
    std::uint32_t                 importerVersion = 1;
    std::vector<std::string>      artifacts;
    std::vector<std::string>      tags;
    AssetStatus                   status = AssetStatus::Ready;
    EditorValue                   metadata;
    std::vector<EditorDiagnostic> diagnostics;
};
 
enum class DependencyKind { Hard, Soft, EditorOnly, Build, Source };
 
struct AssetDependency {
    AssetGuid      from;
    AssetGuid      to;
    DependencyKind kind = DependencyKind::Hard;
    PropertyPath   sourceProperty;
};
 
struct AssetPublication {
    AssetRecord                  record;
    std::vector<AssetDependency> dependencies;
};
 
struct AssetQuery {
    std::vector<std::string>   typeIds;
    std::vector<std::string>   pathPrefixes;
    std::vector<std::string>   tagsAll;
    std::string                text;
    std::optional<AssetStatus> status;
};
 
template <class T>
struct AssetPage {
    std::vector<T> values;
    std::size_t    nextOffset = 0;
    bool           hasMore    = false;
    std::uint64_t  generation = 0;
};
 
class EVENGINE_API_ORCHESTRATION MemoryAssetDatabase {
public:
    Result<AssetRecord> publish(AssetRecord record, std::vector<AssetDependency> dependencies = {});
    [[nodiscard]] Result<std::vector<AssetRecord>> publishBatch(std::vector<AssetPublication> publications);
    Result<AssetRecord> find(const AssetGuid& guid) const;
    Result<AssetRecord> findByUri(const std::string& logicalUri) const;
    Result<AssetPage<AssetRecord>> query(const AssetQuery& query, std::size_t offset, std::size_t limit,
                                               std::optional<std::uint64_t> generation = std::nullopt) const;
    std::vector<AssetDependency> dependencies(const AssetGuid& guid, bool incoming = false) const;
    std::uint64_t generation() const { return generation_; }
 
private:
    std::unordered_map<AssetGuid, AssetRecord, StrongEditorIdHash<AssetGuid>> records_;
    std::unordered_map<std::string, AssetGuid>                                uriToGuid_;
    std::vector<AssetDependency>                                              dependencies_;
    std::uint64_t                                                             generation_ = 0;
};
 
struct ImportProduct {
    AssetRecord                  record;
    std::vector<AssetDependency> dependencies;
};
 
struct ImportTicket {
    AssetGuid asset;
    std::uint64_t generation = 0;
    std::string sourceHash;
    std::string importerId;
    std::uint32_t importerVersion = 1;
};
 
class EVENGINE_API_ORCHESTRATION ImportCoordinator {
public:
    explicit ImportCoordinator(MemoryAssetDatabase* database) : database_(database) {}
    Result<AssetRecord> publish(ImportProduct product);
    Result<ImportTicket> begin(const AssetGuid& asset, std::string sourceHash,
                                     std::string importerId, std::uint32_t importerVersion);
    Result<AssetRecord> publish(const ImportTicket& ticket, ImportProduct product);
 
private:
    MemoryAssetDatabase* database_ = nullptr;
    std::unordered_map<AssetGuid, std::uint64_t, StrongEditorIdHash<AssetGuid>> generations_;
};
 
}  // namespace eve::editor