Struct TerrainRoadTool 

pub struct TerrainRoadTool {

    pub state: TerrainRoadToolState,
    pub terrain: TerrainHeightMap,
    pub segments: HashMap<u32, RoadSegment>,
    pub intersections: HashMap<u32, Intersection>,
    pub network: RoadNetwork,
    pub erosion: RoadErosionState,
    pub undo_stack: UndoStack,
    pub city_nodes: Vec<CityNode>,
    pub rng: SimpleRng,
    pub next_segment_id: u32,
    pub next_intersection_id: u32,
    pub profiles: HashMap<RoadType, RoadProfile>,
    pub elevation_profile_cache: Option<ElevationProfile>,
    pub traffic_sims: HashMap<u32, TrafficFlowSim>,
    pub build_pending_actions: Vec<RoadEditAction>,
}

Fields

state: TerrainRoadToolState

terrain: TerrainHeightMap

segments: HashMap<u32, RoadSegment>

intersections: HashMap<u32, Intersection>

network: RoadNetwork

erosion: RoadErosionState

undo_stack: UndoStack

city_nodes: Vec<CityNode>

rng: SimpleRng

next_segment_id: u32

next_intersection_id: u32

profiles: HashMap<RoadType, RoadProfile>

elevation_profile_cache: Option<ElevationProfile>

traffic_sims: HashMap<u32, TrafficFlowSim>

build_pending_actions: Vec<RoadEditAction>

Implementations

impl TerrainRoadTool

pub fn new(terrain_width: usize, terrain_height: usize, cell_size: f32) -> Self

pub fn with_sample_terrain(seed: u64) -> Self

pub fn add_road_segment( &mut self, from: Vec3, to: Vec3, road_type: RoadType, ) -> u32

pub fn remove_road_segment(&mut self, id: u32) -> bool

pub fn segment_count(&self) -> usize

pub fn step_traffic_sims(&mut self, dt: f32)

pub fn add_road_point(&mut self, _pt: Vec3)

pub fn add_city_node( &mut self, _pos: Vec3, _node_type: RoadNodeType, _population: u32, )

pub fn begin_road_placement(&mut self, _road_type: RoadType)

pub fn finish_road_placement(&mut self)

pub fn generate_procedural_roads(&mut self)

pub fn place_roundabout(&mut self, _center: Vec3, _arms: Vec<Vec3>)

pub fn run_erosion_simulation(&mut self, _steps: usize)

pub fn step_traffic_simulation(&mut self, _dt: f32)

pub fn statistics(&self) -> RoadNetworkStats

pub fn serialize(&self) -> Vec<u8>

pub fn deserialize(&mut self, _data: &[u8])