RoadNetworkEditTarget.h

浏览该文件的文档.

#pragma once
 
#include "common/Export.h"
#include "editing/EditingCommandRegistry.h"
#include "editing/EditingGizmo.h"
#include "editing/EditingTargetOperations.h"
#include "procgen/editing/ProcgenEditingTypes.h"
#include "procgen/road/RoadNetwork.h"
 
#include <cstddef>
#include <memory>
#include <string>
#include <vector>
 
namespace eve::procgen_editing {
 
class RoadNetworkEditTarget final : public virtual editing::IEditableTarget,
                                    public editing::IDomainOperationTarget,
                                    public editing::IDomainOperationTargetStaging,
                                    public editing::IEditingSnapshotProvider {
public:
    static constexpr const char* kMoveNode        = "road.node.move.v1";
    static constexpr const char* kSetNodeRadius   = "road.node.set-radius.v1";
    static constexpr const char* kSetNodeControl  = "road.node.set-junction-control.v1";
    static constexpr const char* kSetEdgePoints   = "road.edge.set-control-points.v1";
    static constexpr const char* kSetEdgeStyle    = "road.edge.set-style.v1";
    static constexpr const char* kSetEdgeLanes    = "road.edge.set-lanes.v1";
    static constexpr const char* kReverseEdge     = "road.edge.reverse.v1";
    static constexpr const char* kReconnectEdgeEndpoint = "road.edge.reconnect-endpoint.v1";
    static constexpr const char* kDetachEdgeEndpoint = "road.edge.detach-endpoint.v1";
    static constexpr const char* kReattachEdgeEndpoint = "road.edge.reattach-endpoint.v1";
    static constexpr const char* kSplitEdge       = "road.edge.split.v1";
    static constexpr const char* kSplitEdgeAtPosition = "road.edge.split-at-position.v1";
    static constexpr const char* kUnsplitEdge     = "road.edge.unsplit.v1";
    static constexpr const char* kMergeNodes      = "road.node.merge.v1";
    static constexpr const char* kMergeNodesAndConnect = "road.node.merge-and-connect.v1";
    static constexpr const char* kUnmergeNodes    = "road.node.unmerge.v1";
    static constexpr const char* kConnectNodeAtPosition = "road.node.connect-at-position.v1";
    static constexpr const char* kDisconnectNodeAtPosition = "road.node.disconnect-at-position.v1";
    static constexpr const char* kConnectEdgeIntersection = "road.edge.connect-intersection.v1";
    static constexpr const char* kDisconnectEdgeIntersection = "road.edge.disconnect-intersection.v1";
    static constexpr const char* kRestoreNode     = "road.node.restore.v1";
    static constexpr const char* kRemoveNode      = "road.node.remove.v1";
    static constexpr const char* kRestoreEdge     = "road.edge.restore.v1";
    static constexpr const char* kRemoveEdge      = "road.edge.remove.v1";
    static constexpr const char* kRestoreLaneLink = "road.lane-link.restore.v1";
    static constexpr const char* kRemoveLaneLink  = "road.lane-link.remove.v1";
    static constexpr const char* kBlockLaneLink   = "road.lane-link.block.v1";
    static constexpr const char* kUnblockLaneLink = "road.lane-link.unblock.v1";
    static constexpr const char* kRestoreLaneLinks = "road.lane-links.restore.v1";
    static constexpr const char* kRemoveLaneLinks  = "road.lane-links.remove.v1";
 
    EVENGINE_API_ORCHESTRATION RoadNetworkEditTarget(std::string id, procgen::road::RoadNetwork& network);
    [[nodiscard]] static EVENGINE_API_ORCHESTRATION std::unique_ptr<RoadNetworkEditTarget> createOwned(std::string id);
 
    editing::TargetId         targetId() const override { return editing::TargetId(id_); }
    std::uint64_t             revision() const override { return network_->revision(); }
    editing::EditRegion       dirtyRegion() const override { return dirty_; }
    void                      clearDirtyRegion() override { dirty_.clear(); }
    EVENGINE_API_ORCHESTRATION editing::TargetDescriptor describe() const override;
    EVENGINE_API_ORCHESTRATION void* queryCapability(const editing::CapabilityId& capability) override;
 
    [[nodiscard]] EVENGINE_API_ORCHESTRATION editing::GizmoSnapshot gizmo(std::size_t maximumPrimitives = 4096,
                                                                          bool        showLabels        = true) const;
 
    [[nodiscard]] EVENGINE_API_ORCHESTRATION EditorValue snapshotValue() const override;
    [[nodiscard]] EVENGINE_API_ORCHESTRATION EditorResult<void> loadSnapshot(const EditorValue& snapshot);
 
    [[nodiscard]] EVENGINE_API_ORCHESTRATION EditorResult<void> applyDomainOperation(
        const editing::DomainOperation& operation) override;
    [[nodiscard]] EVENGINE_API_ORCHESTRATION std::unique_ptr<editing::IDomainOperationTarget> cloneDomainState()
        const override;
    [[nodiscard]] EVENGINE_API_ORCHESTRATION EditorResult<void> commitDomainState(
        std::unique_ptr<editing::IDomainOperationTarget> candidate) override;
 
    [[nodiscard]] EVENGINE_API_ORCHESTRATION EditorResult<editing::DomainOperation> makeMoveNode(std::uint32_t nodeId,
                                                                                                 float x, float y,
                                                                                                 float z) const;
    [[nodiscard]] EVENGINE_API_ORCHESTRATION EditorResult<editing::DomainOperation> makeSetNodeJunctionRadius(
        std::uint32_t nodeId, float junctionRadius) const;
    [[nodiscard]] EVENGINE_API_ORCHESTRATION EditorResult<editing::DomainOperation> makeSetNodeJunctionControl(
        std::uint32_t nodeId, procgen::road::RoadJunctionControl control) const;
    [[nodiscard]] EVENGINE_API_ORCHESTRATION EditorResult<editing::DomainOperation> makeMergeNodes(
        std::uint32_t keepNodeId, std::uint32_t removeNodeId, float maxDistance) const;
    [[nodiscard]] EVENGINE_API_ORCHESTRATION EditorResult<editing::DomainOperation> makeMergeNodesAndConnect(
        std::uint32_t keepNodeId, std::uint32_t removeNodeId, float maxDistance) const;
    [[nodiscard]] EVENGINE_API_ORCHESTRATION EditorResult<editing::DomainOperation> makeSetEdgeControlPoints(
        std::uint32_t edgeId, std::vector<procgen::road::RoadControlPoint> points) const;
    [[nodiscard]] EVENGINE_API_ORCHESTRATION EditorResult<editing::DomainOperation> makeSetEdgeStyle(
        std::uint32_t edgeId, procgen::road::RoadStyle style) const;
    [[nodiscard]] EVENGINE_API_ORCHESTRATION EditorResult<editing::DomainOperation> makeSetEdgeLaneCounts(
        std::uint32_t edgeId, int lanesForward, int lanesBackward) const;
    [[nodiscard]] EVENGINE_API_ORCHESTRATION EditorResult<editing::DomainOperation> makeReverseEdge(
        std::uint32_t edgeId) const;
    [[nodiscard]] EVENGINE_API_ORCHESTRATION EditorResult<editing::DomainOperation> makeReconnectEdgeEndpoint(
        std::uint32_t edgeId, bool fromEndpoint, std::uint32_t nodeId) const;
    [[nodiscard]] EVENGINE_API_ORCHESTRATION EditorResult<editing::DomainOperation> makeReconnectEdgeEndpointAndConnect(
        std::uint32_t edgeId, bool fromEndpoint, std::uint32_t nodeId) const;
    [[nodiscard]] EVENGINE_API_ORCHESTRATION EditorResult<editing::DomainOperation> makeSnapEdgeEndpoint(
        std::uint32_t edgeId, bool fromEndpoint, float maxDistance, bool connectTurns = true) const;
    [[nodiscard]] EVENGINE_API_ORCHESTRATION EditorResult<editing::DomainOperation> makeDetachEdgeEndpoint(
        std::uint32_t edgeId, bool fromEndpoint) const;
    [[nodiscard]] EVENGINE_API_ORCHESTRATION EditorResult<editing::DomainOperation> makeSplitEdge(
        std::uint32_t edgeId, std::size_t controlPointIndex, float junctionRadius = 6.f) const;
    [[nodiscard]] EVENGINE_API_ORCHESTRATION EditorResult<editing::DomainOperation> makeSplitEdgeAtPosition(
        std::uint32_t edgeId, procgen::road::RoadControlPoint position, float maxDistance,
        float junctionRadius = 6.f) const;
    [[nodiscard]] EVENGINE_API_ORCHESTRATION EditorResult<editing::DomainOperation> makeConnectNodeAtPosition(
        std::uint32_t sourceNodeId, std::uint32_t edgeId, procgen::road::RoadControlPoint position, float maxDistance,
        float junctionRadius = 6.f, int lanesForward = 1, int lanesBackward = 0,
        procgen::road::RoadStyle style = {}) const;
    [[nodiscard]] EVENGINE_API_ORCHESTRATION EditorResult<editing::DomainOperation> makeConnectEdgeIntersection(
        std::uint32_t firstEdgeId, std::uint32_t secondEdgeId, float maximumHeightDelta = 0.5f,
        float junctionRadius = 6.f) const;
    [[nodiscard]] EVENGINE_API_ORCHESTRATION EditorResult<editing::DomainOperation> makeAddNode(
        float x, float y, float z, float junctionRadius = 6.f) const;
    [[nodiscard]] EVENGINE_API_ORCHESTRATION EditorResult<editing::DomainOperation> makeRemoveNode(
        std::uint32_t nodeId) const;
    [[nodiscard]] EVENGINE_API_ORCHESTRATION EditorResult<editing::DomainOperation> makeAddEdge(
        std::uint32_t from, std::uint32_t to, std::vector<procgen::road::RoadControlPoint> points, int lanesForward = 2,
        int lanesBackward = 0, procgen::road::RoadStyle style = {}) const;
    [[nodiscard]] EVENGINE_API_ORCHESTRATION EditorResult<editing::DomainOperation> makeAddEdgeAndConnect(
        std::uint32_t from, std::uint32_t to, std::vector<procgen::road::RoadControlPoint> points, int lanesForward = 2,
        int lanesBackward = 0, procgen::road::RoadStyle style = {}) const;
    [[nodiscard]] EVENGINE_API_ORCHESTRATION EditorResult<editing::DomainOperation> makeRemoveEdge(
        std::uint32_t edgeId) const;
    [[nodiscard]] EVENGINE_API_ORCHESTRATION EditorResult<editing::DomainOperation> makeAddLaneLink(
        procgen::road::RoadLaneConnection link) const;
    [[nodiscard]] EVENGINE_API_ORCHESTRATION EditorResult<editing::DomainOperation> makeRemoveLaneLink(
        const procgen::road::RoadLaneConnection& link) const;
    [[nodiscard]] EVENGINE_API_ORCHESTRATION EditorResult<editing::DomainOperation> makeBlockLaneLink(
        procgen::road::RoadLaneConnection link) const;
    [[nodiscard]] EVENGINE_API_ORCHESTRATION EditorResult<editing::DomainOperation> makeUnblockLaneLink(
        const procgen::road::RoadLaneConnection& link) const;
    [[nodiscard]] EVENGINE_API_ORCHESTRATION EditorResult<editing::DomainOperation> makeConnectAllTurns(
        std::uint32_t nodeId) const;
 
private:
    RoadNetworkEditTarget(std::string id, std::unique_ptr<procgen::road::RoadNetwork> candidate);
    [[nodiscard]] EditorResult<editing::DomainOperation> makeMergeNodesImpl(std::uint32_t keepNodeId,
                                                                            std::uint32_t removeNodeId,
                                                                            float maxDistance,
                                                                            bool connectTurns) const;
 
    std::string                                 id_;
    std::unique_ptr<procgen::road::RoadNetwork> candidate_;
    procgen::road::RoadNetwork*                 network_ = nullptr;
    editing::EditRegion                         dirty_;
};
 
[[nodiscard]] EVENGINE_API_ORCHESTRATION editing::Result<void> registerRoadNetworkEditingCommands(
    editing::IEditingCommandRegistry& registry);
 
}  // namespace eve::procgen_editing