RoadTypes.h

浏览该文件的文档.

#pragma once
 
#include "common/Result.h"
 
#include <cstdint>
#include <string>
#include <vector>
 
namespace eve::procgen::road {
 
struct RoadControlPoint {
    float x = 0.f;
    float y = 0.f;
    float z = 0.f;
};
 
struct RoadStyle {
    float laneWidth      = 3.5f;
    float curbWidth      = 0.45f;   
    float curbHeight     = 0.55f;   
    float sidewalkWidth  = 1.5f;
    float sidewalkHeight = 0.14f;
    float deckThickness  = 0.70f;
    float pierWidth      = 1.35f;
    float pierDepth      = 1.35f;
    float pierSpacing    = 11.f;
    float pierClearance  = 1.5f;
    float markingWidth   = 0.22f;
    float dashLength     = 3.5f;
    float dashGap        = 3.f;
    float uvMeters       = 8.f;  
    float speedLimitMps  = 13.8889f;  
    int   trafficPriority = 0;        
    float sideObjectStartOffset = 0.f;  
    float sideObjectEndOffset   = 0.f;  
    bool  sideObjectsLeft       = true;  
    bool  sideObjectsRight      = true;  
};
 
enum class RoadJunctionControl : std::uint8_t {
    Uncontrolled = 0,  
    Yield,             
    Stop,              
    Signal,            
};
 
struct RoadNode {
    std::uint32_t id             = 0;
    float         x              = 0.f;
    float         y              = 0.f;
    float         z              = 0.f;
    float         junctionRadius = 6.f;
    RoadJunctionControl junctionControl = RoadJunctionControl::Uncontrolled;
};
 
struct RoadEdge {
    std::uint32_t                id            = 0;
    std::uint32_t                from          = 0;
    std::uint32_t                to            = 0;
    std::vector<RoadControlPoint> controlPoints;
    int                          lanesForward  = 2;
    int                          lanesBackward = 0;
    RoadStyle                    style;
};
 
struct RoadEdgeSplitResult {
    std::uint32_t nodeId       = 0;
    std::uint32_t firstEdgeId  = 0;  
    std::uint32_t secondEdgeId = 0;  
};
 
enum class RoadLaneDirection : std::uint8_t {
    Forward = 0,  
    Backward,     
};
 
struct RoadLaneConnection {
    std::uint32_t inEdge   = 0;
    int           inLane   = 0;
    std::uint32_t outEdge  = 0;
    int           outLane  = 0;
    RoadLaneDirection inDirection  = RoadLaneDirection::Forward;
    RoadLaneDirection outDirection = RoadLaneDirection::Forward;
};
 
struct RoadPolyline {
    std::vector<float> xyz;  
    float              r = 0.2f, g = 0.85f, b = 1.f, a = 1.f;
    float              width = 0.08f;
    bool               closed = false;
    std::uint32_t      inEdge = 0;
    std::uint32_t      outEdge = 0;
    int                inLane = -1;
    int                outLane = -1;
    RoadLaneDirection  inDirection = RoadLaneDirection::Forward;
    RoadLaneDirection  outDirection = RoadLaneDirection::Forward;
    float              speedLimitMps = 0.f;
    int                trafficPriority = 0;
};
 
struct RoadOverlay {
    std::vector<RoadPolyline> lanes;
    std::vector<RoadPolyline> turns;
};
 
enum class RoadMaterial : std::uint8_t {
    Asphalt = 0,
    Curb,
    Sidewalk,
    Deck,
    Pier,
    Marking,
    MarkingYellow,
    Nav,
};
 
struct RoadProfilePoint {
    float        side     = 0.f;
    float        up       = 0.f;
    RoadMaterial material = RoadMaterial::Asphalt;
};
 
struct RoadProfile {
    std::vector<RoadProfilePoint> points;
    float                         halfWidth = 0.f;
};
 
[[nodiscard]] EVENGINE_API_DOMAINS Result<RoadProfile> makeRoadProfile(const RoadStyle& style, int lanesForward,
                                                                       int lanesBackward);
 
[[nodiscard]] EVENGINE_API_DOMAINS const char* roadMaterialGroup(RoadMaterial material) noexcept;
 
}  // namespace eve::procgen::road