RoadNetwork.h

浏览该文件的文档.

#pragma once
 
#include "procgen/road/RoadTypes.h"
 
#include <cstddef>
#include <cstdint>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace eve::procgen::road {
 
class EVENGINE_API_DOMAINS RoadNetwork {
public:
    [[nodiscard]] Result<std::uint32_t> addNode(float x, float y, float z, float junctionRadius = 6.f);
    [[nodiscard]] Result<void> restoreNode(RoadNode node);
    [[nodiscard]] Result<std::uint32_t> addEdge(std::uint32_t from, std::uint32_t to,
                                                std::vector<RoadControlPoint> controlPoints, int lanesForward = 2,
                                                int lanesBackward = 0, RoadStyle style = {});
    [[nodiscard]] Result<void> restoreEdge(RoadEdge edge);
    [[nodiscard]] Result<void> addLaneLink(RoadLaneConnection link);
    [[nodiscard]] Result<void> removeLaneLink(const RoadLaneConnection& link);
    [[nodiscard]] Result<bool> blockLaneLink(RoadLaneConnection link);
    [[nodiscard]] Result<void> unblockLaneLink(const RoadLaneConnection& link);
    [[nodiscard]] Result<int> connectAllTurns(std::uint32_t nodeId);
    [[nodiscard]] Result<void> validate() const;
    [[nodiscard]] Result<void> setNodePosition(std::uint32_t nodeId, float x, float y, float z);
    [[nodiscard]] Result<void> setNodeJunctionRadius(std::uint32_t nodeId, float junctionRadius);
    [[nodiscard]] Result<void> setNodeJunctionControl(std::uint32_t nodeId, RoadJunctionControl control);
    [[nodiscard]] Result<int> mergeNodes(std::uint32_t keepNodeId, std::uint32_t removeNodeId,
                                         float maxDistance);
    [[nodiscard]] Result<void> setEdgeControlPoints(std::uint32_t edgeId, std::vector<RoadControlPoint> controlPoints);
    [[nodiscard]] Result<int> setEdgeLaneCounts(std::uint32_t edgeId, int lanesForward, int lanesBackward);
    [[nodiscard]] Result<void> reverseEdge(std::uint32_t edgeId);
    [[nodiscard]] Result<int> reconnectEdgeEndpoint(std::uint32_t edgeId, bool fromEndpoint,
                                                    std::uint32_t nodeId);
    [[nodiscard]] Result<std::uint32_t> detachEdgeEndpoint(std::uint32_t edgeId, bool fromEndpoint);
    [[nodiscard]] Result<std::uint32_t> detachEdgeEndpoint(std::uint32_t edgeId, bool fromEndpoint,
                                                           std::uint32_t nodeId);
    [[nodiscard]] Result<RoadEdgeSplitResult> splitEdge(std::uint32_t edgeId, std::size_t controlPointIndex,
                                                        float junctionRadius = 6.f);
 
    [[nodiscard]] Result<RoadEdgeSplitResult> splitEdge(std::uint32_t edgeId, std::size_t controlPointIndex,
                                                        float junctionRadius, std::uint32_t nodeId,
                                                        std::uint32_t secondEdgeId);
    [[nodiscard]] Result<RoadEdgeSplitResult> splitEdgeAtPosition(std::uint32_t edgeId, RoadControlPoint position,
                                                                  float maxDistance, float junctionRadius = 6.f);
    [[nodiscard]] Result<RoadEdgeSplitResult> splitEdgeAtPosition(std::uint32_t edgeId, RoadControlPoint position,
                                                                  float maxDistance, float junctionRadius,
                                                                  std::uint32_t nodeId,
                                                                  std::uint32_t secondEdgeId);
    [[nodiscard]] Result<RoadEdgeSplitResult> splitEdgeAtSplineParameter(std::uint32_t edgeId, float parameter,
                                                                         float junctionRadius = 6.f,
                                                                         std::uint32_t nodeId = 0,
                                                                         std::uint32_t secondEdgeId = 0);
    [[nodiscard]] Result<void> setEdgeStyle(std::uint32_t edgeId, RoadStyle style);
    [[nodiscard]] Result<void> removeEdge(std::uint32_t edgeId);
    [[nodiscard]] Result<void> removeNode(std::uint32_t nodeId);
    void clear();
 
    [[nodiscard]] int nodeCount() const noexcept { return static_cast<int>(nodes_.size()); }
    [[nodiscard]] int edgeCount() const noexcept { return static_cast<int>(edges_.size()); }
    [[nodiscard]] int laneLinkCount() const noexcept { return static_cast<int>(laneLinks_.size()); }
    [[nodiscard]] int blockedLaneLinkCount() const noexcept { return static_cast<int>(blockedLaneLinks_.size()); }
    [[nodiscard]] std::uint64_t revision() const noexcept { return revision_; }
 
    [[nodiscard]] Result<RoadNode> nodeResult(std::uint32_t id) const;
    [[nodiscard]] Result<RoadEdge> edgeResult(std::uint32_t id) const;
    [[nodiscard]] const std::vector<RoadNode>& nodes() const noexcept { return nodes_; }
    [[nodiscard]] const std::vector<RoadEdge>& edges() const noexcept { return edges_; }
    [[nodiscard]] const std::vector<RoadLaneConnection>& laneLinks() const noexcept { return laneLinks_; }
    [[nodiscard]] const std::vector<RoadLaneConnection>& blockedLaneLinks() const noexcept {
        return blockedLaneLinks_;
    }
 
    [[nodiscard]] static Result<RoadNetwork> makeInterchange(float span = 48.f, float bridgeHeight = 8.f, int lanes = 2,
                                                             std::uint32_t seed = 1);
 
    [[nodiscard]] static Result<RoadNetwork> makeStraight(float length = 36.f, int lanes = 2);
    [[nodiscard]] static Result<RoadNetwork> makeCurve(float radius = 18.f, int lanes = 2);
    [[nodiscard]] static Result<RoadNetwork> makeBridge(float length = 36.f, float height = 6.f, int lanes = 2);
    [[nodiscard]] static Result<RoadNetwork> makeCross(float span = 32.f, int lanes = 2);
    [[nodiscard]] static Result<RoadNetwork> makeTee(float span = 32.f, int lanes = 2);
    [[nodiscard]] static Result<RoadNetwork> makeY(float span = 32.f, int lanes = 2);
    [[nodiscard]] static Result<RoadNetwork> makeFan(float span, int lanes, std::vector<float> armAnglesDeg,
                                                     std::vector<bool> intoHub = {});
    [[nodiscard]] static Result<RoadNetwork> makeFork(float span = 32.f, int lanes = 2);
    [[nodiscard]] static Result<RoadNetwork> makeSkew(float span = 32.f, int lanes = 2);
    [[nodiscard]] static Result<RoadNetwork> makeRoundabout(float span = 48.f, int lanes = 1);
 
    [[nodiscard]] static Result<RoadNetwork> makeScene(const std::string& scene, float span = 36.f,
                                                       float bridgeHeight = 6.f, int lanes = 2, std::uint32_t seed = 1);
 
private:
    [[nodiscard]] Result<void> validateStyle(const RoadStyle& style) const;
    [[nodiscard]] int findNodeIndex(std::uint32_t id) const;
    [[nodiscard]] int findEdgeIndex(std::uint32_t id) const;
    [[nodiscard]] Result<void> validateLaneConnection(const RoadLaneConnection& link) const;
 
    std::vector<RoadNode>     nodes_;
    std::vector<RoadEdge>     edges_;
    std::vector<RoadLaneConnection> laneLinks_;
    std::vector<RoadLaneConnection> blockedLaneLinks_;
    std::unordered_map<std::uint32_t, int> nodeIndex_;
    std::unordered_map<std::uint32_t, int> edgeIndex_;
    std::uint32_t nextNodeId_ = 1;
    std::uint32_t nextEdgeId_ = 1;
    std::uint64_t revision_   = 0;
};
 
}  // namespace eve::procgen::road