MapDocument.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "map/editing/MapEditingTypes.h"
 
#include <map>
#include <memory>
#include <string>
#include <vector>
 
namespace eve::map_editing {
 
struct MapLayerRecord {
    StableId    id;
    std::string name;
    std::string kind    = "tile";
    bool        visible = true;
    bool        locked  = false;
    double      opacity = 1.0;
    int         order   = 0;
};
 
struct MapSplinePointRecord {
    StableId id;
    double   x     = 0.0;
    double   y     = 0.0;
    double   z     = 0.0;
    double   width = 4.0;
};
 
struct MapRoadRecord {
    StableId                          id;
    StableId                          layer;
    std::string                       name;
    std::string                       materialAsset;
    bool                              closed = false;
    std::vector<MapSplinePointRecord> points;
};
 
struct MapPlacementRecord {
    StableId    id;
    StableId    layer;
    std::string asset;
    double      x         = 0.0;
    double      y         = 0.0;
    double      z         = 0.0;
    double      rotationX = 0.0;
    double      rotationY = 0.0;
    double      rotationZ = 0.0;
    double      scaleX    = 1.0;
    double      scaleY    = 1.0;
    double      scaleZ    = 1.0;
};
 
struct MapRoadPreviewResult {
    EditorStatus                  status           = EditorStatus::Failed;
    Revision                      documentRevision = 0;
    StableId                      road;
    double                        centerlineLength = 0.0;
    EditorValue                   mesh;
    std::vector<EditorDiagnostic> diagnostics;
};
 
class IMapRoadMeshSink {
public:
    virtual ~IMapRoadMeshSink() = default;
    virtual Result<void> publishRoad(const std::string& document, const StableId& road, Revision revision,
                                           const EditorValue& mesh) = 0;
    virtual Result<void> removeRoad(const std::string& document, const StableId& road) = 0;
};
 
struct MapObjectImportRecord {
    std::string sourceId;
    std::string asset;
    double      x = 0.0, y = 0.0, z = 0.0;
    double      rotationX = 0.0, rotationY = 0.0, rotationZ = 0.0;
    double      scaleX = 1.0, scaleY = 1.0, scaleZ = 1.0;
};
 
struct MapObjectImportPlan {
    EditorStatus                  status           = EditorStatus::Failed;
    Revision                      documentRevision = 0;
    std::vector<DomainOperation>  operations;
    std::vector<EditorDiagnostic> diagnostics;
};
 
class IMapStructureEditTarget {
public:
    virtual ~IMapStructureEditTarget() = default;
    static CapabilityId editorCapabilityId() { return CapabilityId("eve.editor.target.map-structure"); }
    virtual std::vector<MapLayerRecord> mapLayers() const = 0;
    virtual std::vector<MapRoadRecord> mapRoads() const = 0;
    virtual std::vector<MapPlacementRecord> mapPlacements() const = 0;
    virtual Result<DomainOperation> makeCreateLayer(const MapLayerRecord& layer) const = 0;
    virtual Result<DomainOperation> makeDeleteLayer(const StableId& layer) const = 0;
    virtual Result<DomainOperation> makeSetLayer(const MapLayerRecord& layer) const = 0;
    virtual Result<DomainOperation> makeSetRoad(const MapRoadRecord& road) const = 0;
    virtual Result<DomainOperation> makeDeleteRoad(const StableId& road) const = 0;
    virtual Result<DomainOperation> makeSetPlacement(const MapPlacementRecord& placement) const = 0;
    virtual Result<DomainOperation> makeDeletePlacement(const StableId& placement) const = 0;
};
 
class EVENGINE_API_WORLD MapDocumentTarget final : public ::eve::editing::EditableTargetState,
                                                   public virtual IEditableTarget,
                                                   public IDomainOperationTarget,
                                                   public IDomainOperationTargetStaging,
                                                   public IMapStructureEditTarget {
public:
    explicit MapDocumentTarget(std::string id);
    TargetId         targetId() const override { return TargetId(id_); }
    TargetDescriptor describe() const override;
    void*              queryCapability(const CapabilityId& capability) override;
    Result<void> applyDomainOperation(const DomainOperation& operation) override;
    [[nodiscard]] std::unique_ptr<IDomainOperationTarget> cloneDomainState() const override;
    [[nodiscard]] Result<void> commitDomainState(std::unique_ptr<IDomainOperationTarget> candidate) override;
 
    std::vector<MapLayerRecord>     mapLayers() const override;
    std::vector<MapRoadRecord>      mapRoads() const override;
    std::vector<MapPlacementRecord> mapPlacements() const override;
    Result<DomainOperation>   makeCreateLayer(const MapLayerRecord& layer) const override;
    Result<DomainOperation>   makeDeleteLayer(const StableId& layer) const override;
    Result<DomainOperation>   makeSetLayer(const MapLayerRecord& layer) const override;
    Result<DomainOperation>   makeSetRoad(const MapRoadRecord& road) const override;
    Result<DomainOperation>   makeDeleteRoad(const StableId& road) const override;
    Result<DomainOperation>   makeSetPlacement(const MapPlacementRecord& placement) const override;
    Result<DomainOperation>   makeDeletePlacement(const StableId& placement) const override;
 
    std::vector<EditorDiagnostic> validate() const;
    MapRoadPreviewResult previewRoad(const StableId& road, int triangleBudget = 10000) const;
    EditorValue snapshotValue() const;
    Result<void> loadSnapshot(const EditorValue& snapshot);
 
private:
    std::string                            id_;
    std::map<StableId, MapLayerRecord>     layers_;
    std::map<StableId, MapRoadRecord>      roads_;
    std::map<StableId, MapPlacementRecord> placements_;
};
 
class EVENGINE_API_WORLD MapRoadMeshPublisher {
public:
    Result<void> publish(const MapDocumentTarget& document, const StableId& road, Revision expectedRevision,
                               IMapRoadMeshSink& sink, int triangleBudget = 10000) const;
};
 
class EVENGINE_API_WORLD MapObjectImporter {
public:
    MapObjectImportPlan plan(const MapDocumentTarget& document, const StableId& layer,
                             const std::vector<MapObjectImportRecord>& records, const std::string& idPrefix) const;
};
 
}  // namespace eve::map_editing