diff --git a/src/features/editScene/AGENTS.md b/src/features/editScene/AGENTS.md index 7eb2c2a..067fe8e 100644 --- a/src/features/editScene/AGENTS.md +++ b/src/features/editScene/AGENTS.md @@ -1240,9 +1240,18 @@ Per-terrain procedural roads (`RoadGraph` component, geometry built by "Smooth A–B–C" action (`RoadGraph::smoothNode`, position relaxation — no graph mutation). - **Lane counts (0 = unset)**: `RoadEdge::lanesAtoB/lanesBtoA` of 0 mean - "unset" and resolve to `RoadConfig::lanesPerDirection` per side - (`RoadGraph::resolveLaneCounts()`) — never "no lanes". A 0+0 edge - builds as a full default road, not a placeholder path. + "unset" and resolve to `RoadConfig::defaultLanesAtoB/defaultLanesBtoA` + per direction (0 there falls back to the legacy symmetric + `RoadConfig::lanesPerDirection`; `RoadGraph::resolveLaneCounts()`) — + never "no lanes". A 0+0 edge builds as a full default road, not a + placeholder path. +- **Multi-edge selection / batch editing**: ctrl+click edges in the + list or in the 3D view toggles membership in + `RoadSystem::m_selectedEdgeIndices` (plain click single-selects and + replaces the set); "Select Connected" flood-fills the component, + node rows have "Sel. Path" (BFS shortest path to the selected node). + The Batch Edit Selection panel applies lanes A→B/B→A and sidewalk + left/right modes (each with a "keep" choice) to the whole set. - **Roadside prefabs**: three fixed slots per edge (`prefabLeft`, `prefabRight`, `prefabMid` — anchors at left curb / right curb / centerline). Spawning is per edge (`RoadSystem::m_edgePrefabs`, keyed by @@ -1255,7 +1264,10 @@ Per-terrain procedural roads (`RoadGraph` component, geometry built by see `ProceduralRoadGeometry.md` §15); terrain compliance starts its falloff at the sidewalk outer edge. Per edge side the tri-state `RoadEdge::sidewalkLeftMode/RightMode` (Inherit/On/Off) can override - the global switch either way; the geometry builders fold modes + + the per-side config defaults + (`RoadConfig::defaultSidewalkLeftMode/defaultSidewalkRightMode`, + themselves tri-states falling back to the legacy global + `sidewalkEnabled`); the geometry builders fold modes + global themselves (`RoadGraph::edgeSidewalkEnabled()`), while `resolveSidewalkModes()` caches the resolved `sidewalkLeft/Right` bools for terrain compliance and the editor UI. @@ -1347,7 +1359,13 @@ Per-terrain procedural roads (`RoadGraph` component, geometry built by rejection via a height sampler) stamped with `generatedGroupId` — the editor refuses Remove/Split on grouped nodes/edges, a group is removed wholesale (`RoadSystem::clearGenerated`) and hooks into a - manual road via `connectGroupToNode()`. Editor UI: terrain panel + manual road via `connectGroupToNode()`. Per-generation road make-up + (`GridParams::lanesAtoB/lanesBtoA`, `sidewalkLeftMode/ + sidewalkRightMode`; 0/Inherit = leave unset, config defaults apply) + is stamped on every edge the generation creates — two settlements in + one map can differ without touching the RoadConfig defaults, and + `splitEdge()` copies the whole `RoadEdge` so crossing-resolution + splits preserve the values. Editor UI: terrain panel "Road Network Generator" section (`RoadSystem::generateRoadNetwork` — terrain heights + `WaterPhysics` water level — and `resolveCrossingsNow`), with a "Pick Origin on Terrain" button that @@ -1449,8 +1467,13 @@ Per-terrain procedural roads (`RoadGraph` component, geometry built by library. **Town areas** (phase 4.5 item 4): `RoadGraph::townAreas` (`RoadTownArea`: name, square/circle XZ scope, district, seed, densityScale) scope generation per settlement — - `TownGen::generateTown()` filters lots by centroid containment with - first-match-wins over overlapping areas before any RNG draws; + `TownGen::generateTown()` filters lots by centroid containment before + any RNG draws, and a contested lot (inside 2+ areas) belongs to + exactly one area via `RoadNetworkGen::ownerAreaIndex()` — smallest + containing coverage, tie-break lower seed then name; stable under + `townAreas` reordering. The Town Areas block has an "Area Ownership + Preview" checkbox coloring each lot by its owning area in road edit + mode (with a per-area legend and contested-lot X markers); `TownGenSystem::generateAreas()` builds one `"TownGen "` container per area (the unscoped `generate()` stays for single-settlement scenes and `--generate-town`). Areas persist diff --git a/src/features/editScene/ProceduralRoadGeometry.md b/src/features/editScene/ProceduralRoadGeometry.md index 0e177b1..4ba9da7 100644 --- a/src/features/editScene/ProceduralRoadGeometry.md +++ b/src/features/editScene/ProceduralRoadGeometry.md @@ -13,7 +13,9 @@ > **Lane counts — the 0-is-unset rule.** `RoadEdge::lanesAtoB` and > `RoadEdge::lanesBtoA` are per-edge overrides; **0 means "unset"** and -> resolves to the global `RoadConfig::lanesPerDirection` (default 1) for +> resolves to `RoadConfig::defaultLanesAtoB` / `defaultLanesBtoA` +> (per-direction defaults; 0 there falls back to the legacy symmetric +> `RoadConfig::lanesPerDirection`, default 1) for > that side — it never means "no lanes". An edge stored as 0+0 therefore > builds as a full default road (1+1 lanes with the shipped config), not > as a path/placeholder; there is currently no way to express a true @@ -1091,8 +1093,11 @@ bands stay open where a future wedge would connect. Each edge controls its sidewalk per side via the tri-state `RoadEdge::sidewalkLeftMode` / `sidewalkRightMode` (`RoadSidewalkMode`: -**Inherit** — the default — follows the global -`RoadConfig::sidewalkEnabled`, **On** forces the side even when sidewalks +**Inherit** — the default — follows the per-side config defaults +`RoadConfig::defaultSidewalkLeftMode` / `defaultSidewalkRightMode`, +which are themselves tri-states whose Inherit falls back to the legacy +global `RoadConfig::sidewalkEnabled`; **On** forces the side even when +sidewalks are globally off, **Off** suppresses it even when globally on). `RoadGraph::resolveSidewalkModes()` folds modes + global switch into the resolved `RoadEdge::sidewalkLeft` / `sidewalkRight` bools (called by @@ -1518,11 +1523,20 @@ crossings, which is how a settlement hooks into a hand-authored road. Editor integration: the terrain panel's "Road Network Generator" section (origin, block counts/sizes, jitter, seed, avoid-water, max -slope, crossing resolution; Generate / Resolve Crossings Now / -per-group Remove buttons) wraps `RoadSystem::generateRoadNetwork()` -(heights from `TerrainSystem::getHeightAt`, water level from the -scene's `WaterPhysics` entity), `RoadSystem::resolveCrossingsNow()` -and `RoadSystem::clearGenerated()`. "Pick Origin on Terrain" arms a +slope, crossing resolution, per-generation road make-up; Generate / +Resolve Crossings Now / per-group Remove buttons) wraps +`RoadSystem::generateRoadNetwork()` (heights from +`TerrainSystem::getHeightAt`, water level from the scene's +`WaterPhysics` entity), `RoadSystem::resolveCrossingsNow()` +and `RoadSystem::clearGenerated()`. The per-generation make-up +(`GridParams::lanesAtoB/lanesBtoA` and +`sidewalkLeftMode/sidewalkRightMode`, phase 5.9 follow-up) is stamped on +every edge the generation creates, so two settlements in one map can +differ without touching the `RoadConfig` defaults; 0 lanes / Inherit +leave the edge fields unset (the config defaults apply at resolve +time), and `RoadGraph::splitEdge()` copies the whole `RoadEdge`, so the +crossing resolution's splits preserve the stamped values. "Pick Origin +on Terrain" arms a one-shot terrain click (`RoadSystem::armOriginPick` / `takePickedOrigin`; `EditorUISystem::handleRoadEditClick` consumes the click before any road tool) that fills the origin fields. The @@ -1539,7 +1553,8 @@ Headless coverage: `road_geometry_overlap_test` probes untouched, `runLotProbe` 2-block grid + spur rejection, `runStreetProbe` naming/reassignment/JSON round trip/unique addresses + unnamed fallback, `runGeneratorProbe` determinism, counts, water and -slope rejection, two settlements in one graph, group connect/remove). +slope rejection, two settlements in one graph, group connect/remove, +per-generation lanes/sidewalk stamping + split survival). ## 20. Procedural Town Generation (taxi demo phase 4) @@ -2079,8 +2094,11 @@ struct RoadTownArea { `TownGen` filters lots per area by **centroid containment** (simple, deterministic; a lot straddling the boundary belongs to the area -containing its centroid — overlapping areas resolve first-match-wins -and are flagged in the editor). Lots inside NO area generate nothing +containing its centroid — overlapping areas resolve through +`RoadNetworkGen::ownerAreaIndex`: smallest containing coverage wins, +ties break by lower seed then lexicographic name, so the owner is +stable under `townAreas` reordering; contested lots are marked in the +editor's area-ownership preview). Lots inside NO area generate nothing (areas are the only generation scope; the old global generate becomes a one-click "create area around origin" convenience). Each area generates into its own `"TownGen "` container. Persistence @@ -2095,8 +2113,17 @@ the unscoped `TownGenSystem::generate()` stays as-is (area filtering is opt-in via the trailing `areas`/`areaIndex` parameters of `TownGen::generateTown()`, so the single-town button, the `--generate-town` headless check and all existing probes are -unaffected), and overlapping areas are NOT flagged in the editor — -first-match-wins applies silently. `RoadTownArea` lives in +unaffected). Overlapping areas were originally first-match-wins and +NOT flagged in the editor; the phase 5.9 follow-up replaced that with +the order-independent `RoadNetworkGen::ownerAreaIndex()` rule +(smallest containing coverage, then lower seed, then name) shared by +generation and the editor, and added an "Area Ownership Preview" +checkbox in the Town Areas block: `RoadSystem::buildLotOutlines()` +then colors every `findLots()` lot by its owning area (color hashed +from the area name, stable under reordering), draws area bounds in +matching colors, marks contested lots with an X in the winner's +color, and a legend lists per-area owned/contested lot counts. +`RoadTownArea` lives in `components/RoadGraph.hpp` with its own `RoadTownDistrict` enum (Village..CityCenter, no Inherit, value-compatible with `TownGen::District`, static_asserted in TownGenSystem.cpp); @@ -2105,8 +2132,8 @@ generateAreas()` shares the terrain/water/sampler setup with `generate()` (extracted `setupTownRun`), requires a non-empty `townAreas`, clears once and builds one `"TownGen "` container per area through the extracted `createTownContainer()` -tail. Filtering runs before any RNG draws (centroid inside the -area, not inside any earlier area), so per-area towns are +tail. Filtering runs before any RNG draws (owner check via +`ownerAreaIndex`), so per-area towns are deterministic. Serialization: `RoadNetworkGen::townAreasToJson/ FromJson`, inline `townAreas` in the scene JSON next to `streets` (non-streaming), `roads/towns.json` via @@ -2119,10 +2146,14 @@ the two picks don't steal each other's click —, halfSize/radius, district, seed, densityScale, Remove), with Add Area (Square/Circle) and Generate All Areas buttons; `RoadSystem::buildLotOutlines()` draws area outlines in dark blue (0.1,0.1,0.3) next to the dark grey -lot loops. Probes in `runTownGenProbe()`: two overlapping areas on -the 2x2-block grid (west square 4 lots, east circle 4 lots after -first-match-wins, 4 lots outside all areas build nothing), per-area -determinism, disjoint lot sets, and the townAreas json round trip. +lot loops (or per-area colors when the ownership preview is on). +Probes in `runTownGenProbe()`: two overlapping areas on +the 2x2-block grid (west square 4 lots — it is the smaller coverage +and owns the contested lots —, east circle 4 lots, 4 lots outside all +areas build nothing), per-area +determinism, disjoint lot sets, ownership identical under reversed +area order, `ownerAreaIndex` containment/coverage/seed/name +tie-break unit probes, and the townAreas json round trip. ### 21.6 Implementation order diff --git a/src/features/editScene/components/RoadGraph.hpp b/src/features/editScene/components/RoadGraph.hpp index 35fb4d1..0740fcf 100644 --- a/src/features/editScene/components/RoadGraph.hpp +++ b/src/features/editScene/components/RoadGraph.hpp @@ -31,6 +31,26 @@ static const float ROAD_SIDEWALK_WALL_GAP = 0.002f; * road network owned by a single TerrainComponent. These values are * serialized with the scene and edited through the terrain editor. */ +/** + * Per-edge-side sidewalk tri-state. + * + * RoadEdge::sidewalkLeft/Right used to be plain enables ANDed with the + * global RoadConfig::sidewalkEnabled, which made it impossible to give a + * single edge a sidewalk while the global switch was off. The tri-state + * replaces that: Inherit follows the global switch, On/Off force the side + * regardless of it. The resolved value is cached in the legacy bools by + * RoadGraph::resolveSidewalkModes() for the geometry builders. + * + * Declared before RoadConfig: the config's per-side default sidewalk + * modes use it as a member type. + */ +enum class RoadSidewalkMode : int { + Inherit = 0, /**< Follow RoadConfig::defaultSidewalk*Mode, then + * RoadConfig::sidewalkEnabled. */ + On = 1, /**< Sidewalk on this side even if globally disabled. */ + Off = 2 /**< No sidewalk on this side even if globally enabled. */ +}; + struct RoadConfig { /** * Ogre mesh template used to build each unit-length road segment. @@ -62,6 +82,15 @@ struct RoadConfig { */ int lanesPerDirection = 1; + /** + * Per-direction default lane counts (phase 5.9 follow-up). + * + * An edge's lanesAtoB/lanesBtoA (0 = default) resolve against these; + * a 0 here falls back to the legacy symmetric lanesPerDirection. + */ + int defaultLanesAtoB = 0; + int defaultLanesBtoA = 0; + /** * Vertical thickness of the road surface. * @@ -101,6 +130,17 @@ struct RoadConfig { float sidewalkThickness = 0.3f; std::string sidewalkMeshTemplate; + /** + * Per-side default sidewalk modes (phase 5.9 follow-up). + * + * An edge's sidewalkLeftMode/sidewalkRightMode Inherit resolves + * against these; Inherit here falls back to the legacy symmetric + * sidewalkEnabled switch. Sides follow the edge convention: + * looking from nodeA toward nodeB, left is UNIT_Y x dir. + */ + RoadSidewalkMode defaultSidewalkLeftMode = RoadSidewalkMode::Inherit; + RoadSidewalkMode defaultSidewalkRightMode = RoadSidewalkMode::Inherit; + /** * Entry aprons (M5.18). When enabled, a thin sloped band is * generated along every road outer curb: it starts at the road top @@ -314,22 +354,6 @@ struct RoadSidewalkPass { float width = 6.0f; }; -/** - * Per-edge-side sidewalk tri-state. - * - * RoadEdge::sidewalkLeft/Right used to be plain enables ANDed with the - * global RoadConfig::sidewalkEnabled, which made it impossible to give a - * single edge a sidewalk while the global switch was off. The tri-state - * replaces that: Inherit follows the global switch, On/Off force the side - * regardless of it. The resolved value is cached in the legacy bools by - * RoadGraph::resolveSidewalkModes() for the geometry builders. - */ -enum class RoadSidewalkMode : int { - Inherit = 0, /**< Follow RoadConfig::sidewalkEnabled. */ - On = 1, /**< Sidewalk on this side even if globally disabled. */ - Off = 2 /**< No sidewalk on this side even if globally enabled. */ -}; - /** * Per-edge road-marking tri-state (phase 2.5). * @@ -564,7 +588,8 @@ struct RoadEdge { /** * Number of lanes traveling from nodeA to nodeB. * - * 0 means "use RoadConfig::lanesPerDirection". Positive values + * 0 means "use RoadConfig::defaultLanesAtoB" (which itself falls + * back to RoadConfig::lanesPerDirection when 0). Positive values * override the global default for this direction only. Asymmetric * roads are allowed (e.g. lanesAtoB = 2, lanesBtoA = 1). */ @@ -573,7 +598,8 @@ struct RoadEdge { /** * Number of lanes traveling from nodeB to nodeA. * - * 0 means "use RoadConfig::lanesPerDirection". See lanesAtoB for + * 0 means "use RoadConfig::defaultLanesBtoA" (falling back to + * RoadConfig::lanesPerDirection). See lanesAtoB for * asymmetric-lane semantics. */ int lanesBtoA = 0; @@ -865,6 +891,9 @@ struct RoadGraph { { RoadSidewalkMode m = left ? e.sidewalkLeftMode : e.sidewalkRightMode; + if (m == RoadSidewalkMode::Inherit) + m = left ? config.defaultSidewalkLeftMode : + config.defaultSidewalkRightMode; return m == RoadSidewalkMode::On || (m == RoadSidewalkMode::Inherit && config.sidewalkEnabled); @@ -1015,9 +1044,11 @@ struct RoadGraph { lb = edge.lanesPerDirectionOverride; } if (la == 0) - la = config.lanesPerDirection; + la = config.defaultLanesAtoB > 0 ? config.defaultLanesAtoB : + config.lanesPerDirection; if (lb == 0) - lb = config.lanesPerDirection; + lb = config.defaultLanesBtoA > 0 ? config.defaultLanesBtoA : + config.lanesPerDirection; if (fromNodeId == edge.nodeA) { outLanesFrom = la; diff --git a/src/features/editScene/demos/demo-taxi/PLAN.md b/src/features/editScene/demos/demo-taxi/PLAN.md index 7e4137d..23f9393 100644 --- a/src/features/editScene/demos/demo-taxi/PLAN.md +++ b/src/features/editScene/demos/demo-taxi/PLAN.md @@ -3095,6 +3095,50 @@ control for towns, areas and layouts: moved to **Phase 8.5** (they depend on furniture in 6.5, beds/interiors in 8 and the 4.7 population/schedule systems). +**Follow-up requirements (added 2026-10-23, implemented same day)** — +road-editing UX and town-area ownership: + +1. **Road defaults + batch edge editing.** `RoadConfig` gained + per-direction defaults — `defaultLanesAtoB`/`defaultLanesBtoA` + (0 falls back to legacy `lanesPerDirection`) and tri-state + `defaultSidewalkLeftMode`/`defaultSidewalkRightMode` (Inherit falls + back to legacy `sidewalkEnabled`) — serialized in the scene + roadConfig with full backward compatibility, hashed into the road + content signature, editable in the Road Config UI; inheriting edges + (0 / Inherit) follow them automatically. Multi-edge selection: + ctrl+click in the edge list or the 3D view toggles + `RoadSystem::m_selectedEdgeIndices` (plain click single-selects), + "Select Connected" flood-fills the component, node rows have + "Sel. Path" (BFS shortest path), all selected edges highlight in + the 3D view; the Batch Edit Selection panel applies lanes A→B/B→A + and sidewalk left/right modes (with per-field "keep") to the whole + selection. +2. **Town-area preview + order-independent lot ownership.** New + `RoadNetworkGen::ownerAreaIndex()`: among areas containing the lot + centroid the smallest coverage wins (circle πr² vs square + 4·halfSize²), ties break by lower seed then name — content-keyed, + stable under `townAreas` reordering. `TownGen::generateTown()` + uses it instead of first-match-wins. Editor: "Area Ownership + Preview" checkbox in the Town Areas block colors every lot by its + owning area (`areaPreviewColor`, name-hash hue), draws area bounds + in matching colors, marks contested lots with an X in the winner's + color, and shows a per-area legend with owned/contested lot counts. + New headless probes: ownership identical under reversed area order, + ownerAreaIndex containment/coverage/seed/name tie-breaks + (`road_geometry_overlap_test` PASSED). +3. **Per-generation road make-up (2026-10-23).** `GridParams` gained + `lanesAtoB`/`lanesBtoA` (0 = leave the edge field unset, the + `RoadConfig` defaults apply at resolve time) and + `sidewalkLeftMode`/`sidewalkRightMode` (Inherit = unset); the Road + Network Generator UI sets them per generation run, so two + settlements in one map can have different lane counts/sidewalks + without touching the config defaults. `generateGrid()` stamps them + on every edge it creates; `RoadGraph::splitEdge()` copies the whole + `RoadEdge`, so crossing-resolution splits preserve the values. + Headless probes: params stamped on all generated edges, default + params leave edges unset, split survival + (`runGeneratorProbe`, `road_geometry_overlap_test` PASSED). + ### Phase 6 — Foot traffic NPCs This part concerns asset pipeline in assets/blender/characters in addition to the code. diff --git a/src/features/editScene/demos/demo-taxi/demo_scene_exterior.json b/src/features/editScene/demos/demo-taxi/demo_scene_exterior.json index 50719c2..a05cd1c 100644 --- a/src/features/editScene/demos/demo-taxi/demo_scene_exterior.json +++ b/src/features/editScene/demos/demo-taxi/demo_scene_exterior.json @@ -1495,15 +1495,15 @@ }, "transform": { "position": { - "x": 3992.816650390625, - "y": 10.998796463012695, - "z": 3959.3525390625 + "x": 3991.31494140625, + "y": 10.990023612976074, + "z": 3959.019775390625 }, "rotation": { - "w": 0.9888275265693665, - "x": -0.0022681253030896187, - "y": -0.14902545511722565, - "z": 0.0025473441928625107 + "w": 0.9888135194778442, + "x": -0.00225599086843431, + "y": -0.1491188406944275, + "z": 0.0025476780720055103 }, "scale": { "x": 1.0, @@ -1900,15 +1900,15 @@ }, "transform": { "position": { - "x": 4009.110107421875, - "y": 11.092273712158203, - "z": 3966.238525390625 + "x": 4007.2353515625, + "y": 11.077539443969727, + "z": 3966.094970703125 }, "rotation": { - "w": 0.7900381684303284, - "x": -0.004521117080003023, - "y": 0.6130222082138062, - "z": 0.004806817974895239 + "w": 0.8054168224334717, + "x": -0.004673945717513561, + "y": 0.5926746129989624, + "z": 0.004342386499047279 }, "scale": { "x": 1.0, @@ -2122,6 +2122,10 @@ "crossingHeightThreshold": 10.0, "crossingSnapDistance": 5.0, "decalMaterialName": "RoadDecalMaterial", + "defaultLanesAtoB": 0, + "defaultLanesBtoA": 0, + "defaultSidewalkLeftMode": 0, + "defaultSidewalkRightMode": 0, "laneWidth": 5.0, "lanesPerDirection": 1, "markingDashGap": 3.0, @@ -2254,7 +2258,7 @@ 0.800000011920929 ], "sunSphereSize": 5.0, - "timeOfDay": 10.760608673095703, + "timeOfDay": 20.96595573425293, "timeSpeed": 0.12999999523162842 }, "transform": { diff --git a/src/features/editScene/demos/demo-taxi/heightmaps/4242424300000001/roads/2_1.json b/src/features/editScene/demos/demo-taxi/heightmaps/4242424300000001/roads/2_1.json index bd1e343..655cbb9 100644 --- a/src/features/editScene/demos/demo-taxi/heightmaps/4242424300000001/roads/2_1.json +++ b/src/features/editScene/demos/demo-taxi/heightmaps/4242424300000001/roads/2_1.json @@ -1,33 +1,12 @@ { - "edges": [ - { - "lanesAtoB": 2, - "lanesBtoA": 2, - "lanesPerDirectionOverride": 0, - "nodeA": 61, - "nodeB": 62, - "roadLevelA": 0.0, - "roadLevelB": 0.0, - "sidewalkLeft": true, - "sidewalkLeftMode": 1, - "sidewalkRight": true, - "sidewalkRightMode": 1 - } - ], + "edges": [], "nodes": [ { - "id": 61, + "id": 1, "verticalOffset": 0.1762075424194336, "x": 3910.80126953125, "y": 7.148712158203125, "z": 2962.83984375 - }, - { - "id": 62, - "verticalOffset": 0.22691726684570313, - "x": 3951.0302734375, - "y": 9.944311141967773, - "z": 3000.0 } ], "page": [ diff --git a/src/features/editScene/demos/demo-taxi/heightmaps/4242424300000001/roads/2_2.json b/src/features/editScene/demos/demo-taxi/heightmaps/4242424300000001/roads/2_2.json index f372948..d2aadc3 100644 --- a/src/features/editScene/demos/demo-taxi/heightmaps/4242424300000001/roads/2_2.json +++ b/src/features/editScene/demos/demo-taxi/heightmaps/4242424300000001/roads/2_2.json @@ -8,28 +8,18 @@ "buildable": 0, "densityScale": -1.0, "district": -1, + "inhabited": 0, "layout": "(let ((w 20) (d 25))\n(shell w d :floors 1 :empty)\n(floor 0\n (room corridor1 (rect 0 0 0.2 1))\n (room livingroom1 (rect 0.2 0 1 0.35))\n (room bedroom1 (rect 0.2 0.65 1 1))\n (connect corridor1 livingroom1)\n (connect corridor1 bedroom1)\n (door front -8)\n (windows all))\n(roof normal 0 0 w d))\n", "maxFloors": 0, "maxFootprint": 0.0, "maxFrontage": 0.0, + "maxHousehold": 0, "minFloors": 0, "minFootprint": 0.0, + "minHousehold": 0, "roofType": -1, "setback": -1.0 }, - "nodeA": 1, - "nodeB": 2, - "roadLevelA": 0.0, - "roadLevelB": 0.0, - "sidewalkLeft": false, - "sidewalkLeftMode": 0, - "sidewalkRight": false, - "sidewalkRightMode": 0 - }, - { - "lanesAtoB": 2, - "lanesBtoA": 2, - "lanesPerDirectionOverride": 0, "nodeA": 2, "nodeB": 3, "roadLevelA": 0.0, @@ -78,12 +68,25 @@ "sidewalkRight": false, "sidewalkRightMode": 0 }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 6, + "nodeB": 7, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": false, + "sidewalkLeftMode": 0, + "sidewalkRight": false, + "sidewalkRightMode": 0 + }, { "lanesAtoB": 0, "lanesBtoA": 0, "lanesPerDirectionOverride": 0, - "nodeA": 8, - "nodeB": 9, + "nodeA": 9, + "nodeB": 10, "roadLevelA": 0.0, "roadLevelB": 0.0, "sidewalkLeft": false, @@ -95,19 +98,6 @@ "lanesAtoB": 2, "lanesBtoA": 2, "lanesPerDirectionOverride": 0, - "nodeA": 10, - "nodeB": 11, - "roadLevelA": 0.0, - "roadLevelB": 0.0, - "sidewalkLeft": false, - "sidewalkLeftMode": 0, - "sidewalkRight": false, - "sidewalkRightMode": 0 - }, - { - "lanesAtoB": 0, - "lanesBtoA": 0, - "lanesPerDirectionOverride": 0, "nodeA": 11, "nodeB": 12, "roadLevelA": 0.0, @@ -144,8 +134,8 @@ "sidewalkRightMode": 0 }, { - "lanesAtoB": 3, - "lanesBtoA": 3, + "lanesAtoB": 0, + "lanesBtoA": 0, "lanesPerDirectionOverride": 0, "nodeA": 14, "nodeB": 15, @@ -170,11 +160,11 @@ "sidewalkRightMode": 0 }, { - "lanesAtoB": 0, - "lanesBtoA": 0, + "lanesAtoB": 3, + "lanesBtoA": 3, "lanesPerDirectionOverride": 0, - "nodeA": 18, - "nodeB": 19, + "nodeA": 16, + "nodeB": 17, "roadLevelA": 0.0, "roadLevelB": 0.0, "sidewalkLeft": false, @@ -291,7 +281,7 @@ "lanesBtoA": 0, "lanesPerDirectionOverride": 0, "nodeA": 27, - "nodeB": 1, + "nodeB": 28, "roadLevelA": 0.0, "roadLevelB": 0.0, "sidewalkLeft": false, @@ -304,7 +294,7 @@ "lanesBtoA": 0, "lanesPerDirectionOverride": 0, "nodeA": 28, - "nodeB": 17, + "nodeB": 2, "roadLevelA": 0.0, "roadLevelB": 0.0, "sidewalkLeft": false, @@ -316,8 +306,8 @@ "lanesAtoB": 2, "lanesBtoA": 2, "lanesPerDirectionOverride": 0, - "nodeA": 31, - "nodeB": 30, + "nodeA": 32, + "nodeB": 31, "roadLevelA": 0.0, "roadLevelB": 0.0, "sidewalkLeft": false, @@ -329,34 +319,8 @@ "lanesAtoB": 0, "lanesBtoA": 0, "lanesPerDirectionOverride": 0, - "nodeA": 17, - "nodeB": 32, - "roadLevelA": 0.0, - "roadLevelB": 0.0, - "sidewalkLeft": false, - "sidewalkLeftMode": 0, - "sidewalkRight": false, - "sidewalkRightMode": 0 - }, - { - "lanesAtoB": 2, - "lanesBtoA": 2, - "lanesPerDirectionOverride": 0, - "nodeA": 33, - "nodeB": 18, - "roadLevelA": 0.0, - "roadLevelB": 0.0, - "sidewalkLeft": false, - "sidewalkLeftMode": 0, - "sidewalkRight": false, - "sidewalkRightMode": 0 - }, - { - "lanesAtoB": 2, - "lanesBtoA": 2, - "lanesPerDirectionOverride": 0, - "nodeA": 6, - "nodeB": 34, + "nodeA": 18, + "nodeB": 33, "roadLevelA": 0.0, "roadLevelB": 0.0, "sidewalkLeft": false, @@ -369,7 +333,7 @@ "lanesBtoA": 2, "lanesPerDirectionOverride": 0, "nodeA": 34, - "nodeB": 7, + "nodeB": 19, "roadLevelA": 0.0, "roadLevelB": 0.0, "sidewalkLeft": false, @@ -407,7 +371,7 @@ "lanesAtoB": 2, "lanesBtoA": 2, "lanesPerDirectionOverride": 0, - "nodeA": 9, + "nodeA": 8, "nodeB": 36, "roadLevelA": 0.0, "roadLevelB": 0.0, @@ -421,7 +385,20 @@ "lanesBtoA": 2, "lanesPerDirectionOverride": 0, "nodeA": 36, - "nodeB": 10, + "nodeB": 9, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": false, + "sidewalkLeftMode": 0, + "sidewalkRight": false, + "sidewalkRightMode": 0 + }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 10, + "nodeB": 37, "roadLevelA": 0.0, "roadLevelB": 0.0, "sidewalkLeft": false, @@ -434,7 +411,20 @@ "lanesBtoA": 2, "lanesPerDirectionOverride": 0, "nodeA": 37, - "nodeB": 17, + "nodeB": 11, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": false, + "sidewalkLeftMode": 0, + "sidewalkRight": false, + "sidewalkRightMode": 0 + }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 38, + "nodeB": 18, "roadLevelA": 0.0, "roadLevelB": 0.0, "sidewalkLeft": false, @@ -456,11 +446,11 @@ "sidewalkRightMode": 0 }, { - "lanesAtoB": 2, - "lanesBtoA": 2, + "lanesAtoB": 0, + "lanesBtoA": 0, "lanesPerDirectionOverride": 0, - "nodeA": 38, - "nodeB": 37, + "nodeA": 30, + "nodeB": 56, "roadLevelA": 0.0, "roadLevelB": 0.0, "sidewalkLeft": false, @@ -472,7 +462,20 @@ "lanesAtoB": 0, "lanesBtoA": 0, "lanesPerDirectionOverride": 0, - "nodeA": 29, + "nodeA": 56, + "nodeB": 32, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": false, + "sidewalkLeftMode": 0, + "sidewalkRight": false, + "sidewalkRightMode": 0 + }, + { + "lanesAtoB": 0, + "lanesBtoA": 0, + "lanesPerDirectionOverride": 0, + "nodeA": 33, "nodeB": 39, "roadLevelA": 0.0, "roadLevelB": 0.0, @@ -498,7 +501,7 @@ "lanesAtoB": 0, "lanesBtoA": 0, "lanesPerDirectionOverride": 0, - "nodeA": 32, + "nodeA": 31, "nodeB": 40, "roadLevelA": 0.0, "roadLevelB": 0.0, @@ -512,7 +515,7 @@ "lanesBtoA": 0, "lanesPerDirectionOverride": 0, "nodeA": 40, - "nodeB": 30, + "nodeB": 34, "roadLevelA": 0.0, "roadLevelB": 0.0, "sidewalkLeft": false, @@ -521,13 +524,325 @@ "sidewalkRightMode": 0 }, { - "lanesAtoB": 0, - "lanesBtoA": 0, + "lanesAtoB": 2, + "lanesBtoA": 2, "lanesPerDirectionOverride": 0, - "nodeA": 30, + "nodeA": 21, + "nodeB": 44, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": true, + "sidewalkLeftMode": 1, + "sidewalkRight": true, + "sidewalkRightMode": 1 + }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 21, "nodeB": 41, "roadLevelA": 0.0, "roadLevelB": 0.0, + "sidewalkLeft": true, + "sidewalkLeftMode": 1, + "sidewalkRight": true, + "sidewalkRightMode": 1 + }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 41, + "nodeB": 45, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": true, + "sidewalkLeftMode": 1, + "sidewalkRight": true, + "sidewalkRightMode": 1 + }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 41, + "nodeB": 42, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": true, + "sidewalkLeftMode": 1, + "sidewalkRight": true, + "sidewalkRightMode": 1 + }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 42, + "nodeB": 46, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": true, + "sidewalkLeftMode": 1, + "sidewalkRight": true, + "sidewalkRightMode": 1 + }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 42, + "nodeB": 43, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": true, + "sidewalkLeftMode": 1, + "sidewalkRight": true, + "sidewalkRightMode": 1 + }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 43, + "nodeB": 47, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": true, + "sidewalkLeftMode": 1, + "sidewalkRight": true, + "sidewalkRightMode": 1 + }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 44, + "nodeB": 48, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": true, + "sidewalkLeftMode": 1, + "sidewalkRight": true, + "sidewalkRightMode": 1 + }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 44, + "nodeB": 45, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": true, + "sidewalkLeftMode": 1, + "sidewalkRight": true, + "sidewalkRightMode": 1 + }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 45, + "nodeB": 49, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": true, + "sidewalkLeftMode": 1, + "sidewalkRight": true, + "sidewalkRightMode": 1 + }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 45, + "nodeB": 46, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": true, + "sidewalkLeftMode": 1, + "sidewalkRight": true, + "sidewalkRightMode": 1 + }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 46, + "nodeB": 50, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": true, + "sidewalkLeftMode": 1, + "sidewalkRight": true, + "sidewalkRightMode": 1 + }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 46, + "nodeB": 47, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": true, + "sidewalkLeftMode": 1, + "sidewalkRight": true, + "sidewalkRightMode": 1 + }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 47, + "nodeB": 51, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": true, + "sidewalkLeftMode": 1, + "sidewalkRight": true, + "sidewalkRightMode": 1 + }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 48, + "nodeB": 52, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": true, + "sidewalkLeftMode": 1, + "sidewalkRight": true, + "sidewalkRightMode": 1 + }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 48, + "nodeB": 49, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": true, + "sidewalkLeftMode": 1, + "sidewalkRight": true, + "sidewalkRightMode": 1 + }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 49, + "nodeB": 53, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": true, + "sidewalkLeftMode": 1, + "sidewalkRight": true, + "sidewalkRightMode": 1 + }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 49, + "nodeB": 50, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": false, + "sidewalkLeftMode": 2, + "sidewalkRight": false, + "sidewalkRightMode": 2 + }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 50, + "nodeB": 54, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": true, + "sidewalkLeftMode": 1, + "sidewalkRight": true, + "sidewalkRightMode": 1 + }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 50, + "nodeB": 51, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": false, + "sidewalkLeftMode": 2, + "sidewalkRight": false, + "sidewalkRightMode": 2 + }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 51, + "nodeB": 55, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": true, + "sidewalkLeftMode": 1, + "sidewalkRight": true, + "sidewalkRightMode": 1 + }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 52, + "nodeB": 53, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": true, + "sidewalkLeftMode": 1, + "sidewalkRight": true, + "sidewalkRightMode": 1 + }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 53, + "nodeB": 54, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": true, + "sidewalkLeftMode": 1, + "sidewalkRight": true, + "sidewalkRightMode": 1 + }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 54, + "nodeB": 55, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": true, + "sidewalkLeftMode": 1, + "sidewalkRight": true, + "sidewalkRightMode": 1 + }, + { + "lanesAtoB": 0, + "lanesBtoA": 0, + "lanesPerDirectionOverride": 0, + "nodeA": 29, + "nodeB": 56, + "roadLevelA": 0.0, + "roadLevelB": 0.0, "sidewalkLeft": false, "sidewalkLeftMode": 0, "sidewalkRight": false, @@ -537,8 +852,346 @@ "lanesAtoB": 0, "lanesBtoA": 0, "lanesPerDirectionOverride": 0, - "nodeA": 41, - "nodeB": 33, + "nodeA": 56, + "nodeB": 18, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": false, + "sidewalkLeftMode": 0, + "sidewalkRight": false, + "sidewalkRightMode": 0 + }, + { + "lanesAtoB": 0, + "lanesBtoA": 0, + "lanesPerDirectionOverride": 0, + "nodeA": 58, + "nodeB": 12, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": false, + "sidewalkLeftMode": 0, + "sidewalkRight": false, + "sidewalkRightMode": 0 + }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 61, + "nodeB": 65, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": true, + "sidewalkLeftMode": 1, + "sidewalkRight": true, + "sidewalkRightMode": 1 + }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 61, + "nodeB": 62, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": true, + "sidewalkLeftMode": 1, + "sidewalkRight": true, + "sidewalkRightMode": 1 + }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 62, + "nodeB": 66, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": true, + "sidewalkLeftMode": 1, + "sidewalkRight": true, + "sidewalkRightMode": 1 + }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 62, + "nodeB": 63, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": true, + "sidewalkLeftMode": 1, + "sidewalkRight": true, + "sidewalkRightMode": 1 + }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 63, + "nodeB": 67, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": true, + "sidewalkLeftMode": 1, + "sidewalkRight": true, + "sidewalkRightMode": 1 + }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 63, + "nodeB": 64, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": true, + "sidewalkLeftMode": 1, + "sidewalkRight": true, + "sidewalkRightMode": 1 + }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 64, + "nodeB": 68, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": true, + "sidewalkLeftMode": 1, + "sidewalkRight": true, + "sidewalkRightMode": 1 + }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 65, + "nodeB": 69, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": true, + "sidewalkLeftMode": 1, + "sidewalkRight": true, + "sidewalkRightMode": 1 + }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 65, + "nodeB": 66, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": true, + "sidewalkLeftMode": 1, + "sidewalkRight": true, + "sidewalkRightMode": 1 + }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 66, + "nodeB": 70, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": true, + "sidewalkLeftMode": 1, + "sidewalkRight": true, + "sidewalkRightMode": 1 + }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 66, + "nodeB": 67, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": true, + "sidewalkLeftMode": 1, + "sidewalkRight": true, + "sidewalkRightMode": 1 + }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 67, + "nodeB": 71, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": true, + "sidewalkLeftMode": 1, + "sidewalkRight": true, + "sidewalkRightMode": 1 + }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 67, + "nodeB": 68, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": true, + "sidewalkLeftMode": 1, + "sidewalkRight": true, + "sidewalkRightMode": 1 + }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 68, + "nodeB": 72, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": true, + "sidewalkLeftMode": 1, + "sidewalkRight": true, + "sidewalkRightMode": 1 + }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 69, + "nodeB": 70, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": true, + "sidewalkLeftMode": 1, + "sidewalkRight": true, + "sidewalkRightMode": 1 + }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 70, + "nodeB": 74, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": true, + "sidewalkLeftMode": 1, + "sidewalkRight": true, + "sidewalkRightMode": 1 + }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 70, + "nodeB": 71, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": true, + "sidewalkLeftMode": 1, + "sidewalkRight": true, + "sidewalkRightMode": 1 + }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 71, + "nodeB": 75, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": true, + "sidewalkLeftMode": 1, + "sidewalkRight": true, + "sidewalkRightMode": 1 + }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 71, + "nodeB": 72, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": true, + "sidewalkLeftMode": 1, + "sidewalkRight": true, + "sidewalkRightMode": 1 + }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 72, + "nodeB": 76, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": true, + "sidewalkLeftMode": 1, + "sidewalkRight": true, + "sidewalkRightMode": 1 + }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 77, + "nodeB": 74, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": true, + "sidewalkLeftMode": 1, + "sidewalkRight": true, + "sidewalkRightMode": 1 + }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 74, + "nodeB": 75, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": true, + "sidewalkLeftMode": 1, + "sidewalkRight": true, + "sidewalkRightMode": 1 + }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 75, + "nodeB": 76, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": true, + "sidewalkLeftMode": 1, + "sidewalkRight": true, + "sidewalkRightMode": 1 + }, + { + "lanesAtoB": 2, + "lanesBtoA": 2, + "lanesPerDirectionOverride": 0, + "nodeA": 69, + "nodeB": 77, + "roadLevelA": 0.0, + "roadLevelB": 0.0, + "sidewalkLeft": true, + "sidewalkLeftMode": 1, + "sidewalkRight": true, + "sidewalkRightMode": 1 + }, + { + "lanesAtoB": 0, + "lanesBtoA": 0, + "lanesPerDirectionOverride": 0, + "nodeA": 58, + "nodeB": 77, "roadLevelA": 0.0, "roadLevelB": 0.0, "sidewalkLeft": false, @@ -549,291 +1202,545 @@ ], "nodes": [ { - "id": 1, + "id": 2, "verticalOffset": 0.3522453308105469, "x": 3437.880615234375, "y": 6.855459213256836, "z": 3358.8037109375 }, { - "id": 2, + "id": 3, "verticalOffset": 0.4837055206298828, "x": 3488.8173828125, "y": 10.034442901611328, "z": 3473.101806640625 }, { - "id": 3, + "id": 4, "verticalOffset": 0.2371206283569336, "x": 3488.9677734375, "y": 10.145283699035645, "z": 3508.753173828125 }, { - "id": 4, + "id": 5, "verticalOffset": 0.18480968475341797, "x": 3516.337158203125, "y": 10.394560813903809, "z": 3492.816650390625 }, { - "id": 5, + "id": 6, "verticalOffset": 0.13015079498291016, "x": 3536.501708984375, "y": 10.364045143127441, "z": 3560.5615234375 }, { - "id": 6, + "id": 7, "verticalOffset": 0.19904804229736328, "x": 3574.39404296875, "y": 10.21535587310791, "z": 3567.400146484375 }, { - "id": 7, + "id": 8, "verticalOffset": 0.2288074493408203, "x": 3634.218994140625, "y": 9.091591835021973, "z": 3683.373291015625 }, { - "id": 8, + "id": 9, "verticalOffset": 0.16122817993164063, "x": 3690.21337890625, "y": 8.126683235168457, "z": 3682.84912109375 }, { - "id": 9, + "id": 10, "verticalOffset": 0.15660953521728516, "x": 3709.55029296875, "y": 8.210295677185059, "z": 3758.01171875 }, { - "id": 10, + "id": 11, "verticalOffset": 0.15831708908081055, "x": 3777.022705078125, "y": 7.6839118003845215, "z": 3773.858642578125 }, { - "id": 11, - "verticalOffset": 0.22203826904296875, + "id": 12, + "verticalOffset": 0.21181869506835938, "x": 3826.70166015625, - "y": 8.479028701782227, + "y": 8.546716690063477, "z": 3890.883544921875 }, { - "id": 12, + "id": 13, "verticalOffset": 0.1051626205444336, "x": 3866.435302734375, "y": 8.584627151489258, "z": 3870.297607421875 }, { - "id": 13, + "id": 14, "verticalOffset": 0.11966419219970703, "x": 3890.07421875, "y": 9.139593124389648, "z": 3926.133544921875 }, { - "id": 14, + "id": 15, "verticalOffset": 0.14722442626953125, "x": 3954.381591796875, "y": 9.767667770385742, "z": 3962.66162109375 }, - { - "id": 15, - "verticalOffset": 0.17846393585205078, - "x": 3999.156982421875, - "y": 10.088912010192871, - "z": 3974.06689453125 - }, { "id": 16, - "verticalOffset": 0.12070465087890625, - "x": 3999.489501953125, - "y": 10.111948013305664, - "z": 3994.31982421875 + "verticalOffset": 0.17846393585205078, + "x": 4014.615234375, + "y": 10.12037467956543, + "z": 3974.89892578125 }, { "id": 17, + "verticalOffset": -0.0165252685546875, + "x": 3999.489501953125, + "y": 9.97471809387207, + "z": 3994.31982421875 + }, + { + "id": 18, "verticalOffset": 1.0833749771118164, "x": 4100.32763671875, "y": 10.909321784973145, "z": 3899.1240234375 }, { - "id": 18, + "id": 19, "verticalOffset": 0.18778038024902344, "x": 4261.37451171875, "y": 10.495306015014648, "z": 3797.348388671875 }, { - "id": 19, + "id": 20, "verticalOffset": 0.107818603515625, "x": 4400.6689453125, "y": 7.444511413574219, "z": 3667.895263671875 }, { - "id": 20, - "verticalOffset": 0.11748790740966797, - "x": 4476.7509765625, - "y": 6.342728614807129, - "z": 3578.485107421875 + "id": 21, + "verticalOffset": 0.20190143585205078, + "x": 4481.0166015625, + "y": 6.502612113952637, + "z": 3583.87939453125 }, { - "id": 21, + "id": 22, "verticalOffset": 0.12587261199951172, "x": 4409.72119140625, "y": 6.288962364196777, "z": 3547.438720703125 }, { - "id": 22, + "id": 23, "verticalOffset": 0.18752622604370117, "x": 4368.40380859375, "y": 6.48817777633667, "z": 3506.48388671875 }, { - "id": 23, + "id": 24, "verticalOffset": 2.613924026489258, "x": 4139.119140625, "y": 12.095186233520508, "z": 3374.61328125 }, { - "id": 24, + "id": 25, "verticalOffset": 0.3590993881225586, "x": 3862.39013671875, "y": 12.950423240661621, "z": 3324.991455078125 }, { - "id": 25, + "id": 26, "verticalOffset": 1.1305389404296875, "x": 3647.916015625, "y": 11.456146240234375, "z": 3279.907958984375 }, { - "id": 26, + "id": 27, "verticalOffset": 0.38730812072753906, "x": 3554.84130859375, "y": 8.29277229309082, "z": 3223.057861328125 }, { - "id": 27, + "id": 28, "verticalOffset": 0.25848913192749023, "x": 3483.183349609375, "y": 7.502370357513428, "z": 3311.11962890625 }, { - "id": 28, + "id": 29, "verticalOffset": 1.4497308731079102, "x": 4314.044921875, "y": 8.320108413696289, "z": 4401.56787109375 }, { - "id": 29, + "id": 30, "verticalOffset": 0.11907100677490234, "x": 4288.50341796875, "y": 6.832488059997559, "z": 4423.93359375 }, { - "id": 30, + "id": 31, "verticalOffset": 0.3729572296142578, "x": 4180.63525390625, "y": 10.775619506835938, "z": 3848.372802734375 }, { - "id": 31, + "id": 32, "verticalOffset": 0.27489757537841797, "x": 4234.53076171875, "y": 9.887567520141602, "z": 4135.94775390625 }, { - "id": 32, + "id": 33, "verticalOffset": 0.1316070556640625, "x": 4140.05859375, "y": 11.124691009521484, "z": 3874.015625 }, { - "id": 33, + "id": 34, "verticalOffset": 0.193603515625, "x": 4221.21142578125, "y": 11.040815353393555, "z": 3822.72998046875 }, { - "id": 34, + "id": 35, "verticalOffset": 0.2789726257324219, "x": 3604.193359375, "y": 9.662496566772461, "z": 3625.1669921875 }, { - "id": 35, + "id": 36, "verticalOffset": 0.2532939910888672, "x": 3662.2177734375, "y": 8.661474227905273, "z": 3683.111328125 }, { - "id": 36, + "id": 37, "verticalOffset": 0.26088714599609375, "x": 3743.623291015625, "y": 7.966800689697266, "z": 3766.01416015625 }, { - "id": 37, + "id": 38, "verticalOffset": 0.1768960952758789, "x": 4049.66357421875, "y": 10.331364631652832, "z": 3946.953369140625 }, - { - "id": 38, - "verticalOffset": 0.13515758514404297, - "x": 4024.940185546875, - "y": 10.135685920715332, - "z": 3970.29345703125 - }, { "id": 39, - "verticalOffset": 0.2591848373413086, - "x": 4261.4248046875, - "y": 9.288487434387207, - "z": 4279.44921875 - }, - { - "id": 40, "verticalOffset": 0.25733470916748047, "x": 4160.3466796875, "y": 11.07775592803955, "z": 3861.1943359375 }, { - "id": 41, + "id": 40, "verticalOffset": 0.17667102813720703, "x": 4200.92333984375, "y": 11.115194320678711, "z": 3835.55126953125 + }, + { + "generatedGroupId": 3, + "id": 41, + "verticalOffset": 0.28754520416259766, + "x": 4486.15283203125, + "y": 7.785621643066406, + "z": 3688.250244140625 + }, + { + "generatedGroupId": 3, + "id": 42, + "verticalOffset": 0.2938508987426758, + "x": 4486.15283203125, + "y": 8.786837577819824, + "z": 3788.250244140625 + }, + { + "generatedGroupId": 3, + "id": 43, + "verticalOffset": 0.2992687225341797, + "x": 4486.15283203125, + "y": 9.662212371826172, + "z": 3888.250244140625 + }, + { + "generatedGroupId": 3, + "id": 44, + "verticalOffset": 0.5164494514465332, + "x": 4586.15283203125, + "y": 7.796427249908447, + "z": 3588.250244140625 + }, + { + "generatedGroupId": 3, + "id": 45, + "verticalOffset": 0.5543937683105469, + "x": 4586.15283203125, + "y": 9.898271560668945, + "z": 3688.250244140625 + }, + { + "generatedGroupId": 3, + "id": 46, + "verticalOffset": 0.4682044982910156, + "x": 4586.15283203125, + "y": 11.012107849121094, + "z": 3788.250244140625 + }, + { + "generatedGroupId": 3, + "id": 47, + "verticalOffset": 0.34177398681640625, + "x": 4586.15283203125, + "y": 11.384183883666992, + "z": 3888.250244140625 + }, + { + "generatedGroupId": 3, + "id": 48, + "verticalOffset": 0.6620044708251953, + "x": 4686.15283203125, + "y": 9.59457778930664, + "z": 3588.250244140625 + }, + { + "generatedGroupId": 3, + "id": 49, + "verticalOffset": 0.512944221496582, + "x": 4686.15283203125, + "y": 12.531098365783691, + "z": 3688.250244140625 + }, + { + "generatedGroupId": 3, + "id": 50, + "verticalOffset": 0.2771034240722656, + "x": 4686.15283203125, + "y": 13.455036163330078, + "z": 3788.250244140625 + }, + { + "generatedGroupId": 3, + "id": 51, + "verticalOffset": 0.26450252532958984, + "x": 4686.15283203125, + "y": 13.02420711517334, + "z": 3888.250244140625 + }, + { + "generatedGroupId": 3, + "id": 52, + "verticalOffset": 0.5630559921264648, + "x": 4786.15283203125, + "y": 10.546149253845215, + "z": 3588.250244140625 + }, + { + "generatedGroupId": 3, + "id": 53, + "verticalOffset": 0.26700401306152344, + "x": 4786.15283203125, + "y": 13.466880798339844, + "z": 3688.250244140625 + }, + { + "generatedGroupId": 3, + "id": 54, + "verticalOffset": 0.1942157745361328, + "x": 4786.15283203125, + "y": 13.968050003051758, + "z": 3788.250244140625 + }, + { + "generatedGroupId": 3, + "id": 55, + "verticalOffset": 0.32894039154052734, + "x": 4786.15283203125, + "y": 12.614607810974121, + "z": 3888.250244140625 + }, + { + "id": 56, + "verticalOffset": 1.3604907989501953, + "x": 4261.7109375, + "y": 9.119579315185547, + "z": 4279.3271484375 + }, + { + "id": 58, + "verticalOffset": 0.1935586929321289, + "x": 3670.687255859375, + "y": 10.84511661529541, + "z": 3971.63818359375 + }, + { + "id": 59, + "verticalOffset": 0.0, + "x": 3665.564697265625, + "y": 10.596302032470703, + "z": 3960.1875 + }, + { + "generatedGroupId": 4, + "id": 61, + "verticalOffset": 0.4770660400390625, + "x": 3250.81591796875, + "y": 19.61433982849121, + "z": 4075.4189453125 + }, + { + "generatedGroupId": 4, + "id": 62, + "verticalOffset": 0.3129310607910156, + "x": 3250.81591796875, + "y": 21.974468231201172, + "z": 4175.4189453125 + }, + { + "generatedGroupId": 4, + "id": 63, + "verticalOffset": 0.35047149658203125, + "x": 3250.81591796875, + "y": 21.929183959960938, + "z": 4275.4189453125 + }, + { + "generatedGroupId": 4, + "id": 64, + "verticalOffset": 0.39209938049316406, + "x": 3250.81591796875, + "y": 19.683149337768555, + "z": 4375.4189453125 + }, + { + "generatedGroupId": 4, + "id": 65, + "verticalOffset": 0.49384307861328125, + "x": 3350.81591796875, + "y": 19.948095321655273, + "z": 4075.4189453125 + }, + { + "generatedGroupId": 4, + "id": 66, + "verticalOffset": 0.3379402160644531, + "x": 3350.81591796875, + "y": 22.054378509521484, + "z": 4175.4189453125 + }, + { + "generatedGroupId": 4, + "id": 67, + "verticalOffset": 0.11642074584960938, + "x": 3350.81591796875, + "y": 22.36197280883789, + "z": 4275.4189453125 + }, + { + "generatedGroupId": 4, + "id": 68, + "verticalOffset": 0.32201194763183594, + "x": 3350.81591796875, + "y": 21.752782821655273, + "z": 4375.4189453125 + }, + { + "generatedGroupId": 4, + "id": 69, + "verticalOffset": 0.6426296234130859, + "x": 3450.81591796875, + "y": 18.4489688873291, + "z": 4075.4189453125 + }, + { + "generatedGroupId": 4, + "id": 70, + "verticalOffset": 0.5670394897460938, + "x": 3450.81591796875, + "y": 20.38597297668457, + "z": 4175.4189453125 + }, + { + "generatedGroupId": 4, + "id": 71, + "verticalOffset": 0.36499786376953125, + "x": 3450.81591796875, + "y": 21.65410804748535, + "z": 4275.4189453125 + }, + { + "generatedGroupId": 4, + "id": 72, + "verticalOffset": 0.20295333862304688, + "x": 3450.81591796875, + "y": 22.530685424804688, + "z": 4375.4189453125 + }, + { + "generatedGroupId": 4, + "id": 74, + "verticalOffset": 0.6102733612060547, + "x": 3550.81591796875, + "y": 17.73395347595215, + "z": 4175.4189453125 + }, + { + "generatedGroupId": 4, + "id": 75, + "verticalOffset": 0.5240287780761719, + "x": 3550.81591796875, + "y": 20.049325942993164, + "z": 4275.4189453125 + }, + { + "generatedGroupId": 4, + "id": 76, + "verticalOffset": 0.3935375213623047, + "x": 3550.81591796875, + "y": 22.264745712280273, + "z": 4375.4189453125 + }, + { + "id": 77, + "verticalOffset": 0.4192390441894531, + "x": 3539.1728515625, + "y": 15.721473693847656, + "z": 4073.6611328125 } ], "page": [ diff --git a/src/features/editScene/demos/demo-taxi/heightmaps/4242424300000001/roads/2_3.json b/src/features/editScene/demos/demo-taxi/heightmaps/4242424300000001/roads/2_3.json index e770d5f..de15fa4 100644 --- a/src/features/editScene/demos/demo-taxi/heightmaps/4242424300000001/roads/2_3.json +++ b/src/features/editScene/demos/demo-taxi/heightmaps/4242424300000001/roads/2_3.json @@ -3,7 +3,7 @@ "nodes": [ { "generatedGroupId": 2, - "id": 42, + "id": 57, "verticalOffset": 0.0, "x": 4048.19775390625, "y": 7.354270935058594, diff --git a/src/features/editScene/demos/demo-taxi/heightmaps/4242424300000001/roads/towns.json b/src/features/editScene/demos/demo-taxi/heightmaps/4242424300000001/roads/towns.json index b19dd7f..bc20bf5 100644 --- a/src/features/editScene/demos/demo-taxi/heightmaps/4242424300000001/roads/towns.json +++ b/src/features/editScene/demos/demo-taxi/heightmaps/4242424300000001/roads/towns.json @@ -16,6 +16,51 @@ "village" ], "radius": 500.0, + "seed": 1, + "town": "Pensville" + }, + { + "center": [ + 4664.90185546875, + 11.98272705078125, + 3714.66748046875 + ], + "circular": false, + "densityScale": 1.0, + "district": 0, + "halfSize": 250.0, + "name": "Area 2", + "preferredTypes": [ + "house", + "village" + ], + "radius": 500.0, + "seed": 1, + "town": "Pensville" + }, + { + "center": [ + 3401.02001953125, + 21.564054489135742, + 4221.458984375 + ], + "circular": false, + "densityScale": 1.0, + "district": 0, + "halfSize": 250.0, + "name": "Area 3", + "preferredTypes": [ + "shop", + "commercial" + ], + "radius": 500.0, + "seed": 1, + "town": "Pensville" + } + ], + "towns": [ + { + "name": "Pensville", "seed": 1 } ] diff --git a/src/features/editScene/demos/demo-taxi/heightmaps/4242424300000001/terrain_fixup/x2_z2.bin b/src/features/editScene/demos/demo-taxi/heightmaps/4242424300000001/terrain_fixup/x2_z2.bin index 1acb269..7302e69 100644 --- a/src/features/editScene/demos/demo-taxi/heightmaps/4242424300000001/terrain_fixup/x2_z2.bin +++ b/src/features/editScene/demos/demo-taxi/heightmaps/4242424300000001/terrain_fixup/x2_z2.bin @@ -1,2 +1,3 @@ -ٶA#AhBAA#A_A*)A AjA_AA` A¨A]AAA` A` AAAAA `A%AjA7A%A - AyNAiAAb$AlAFARA*AAaAFA$AAAAg7A3nA,yAAA,yA,yAcAcA!A!AcA3AAA!A!A3A;A9xAPAAAACRASjA3ACRAX_AAAvA::A=A +A)A)AF&A1&A?AAsAA +A A)A)AA&A"/&A AxAMAAv+A9 +AD*A*Aۇ%AK%Am@m@N,@N,@'A'A4(A4(A!A!A4A4A#%Ax&%A#4A4Ay$AN$A@܇@܇@3@:@.@@v@.@@4@_@UA)*A]hA]hAfAAAeAlAoAeAEBAa A AaA`A+Aʗ+A$A{DAEU AD A`Ah\Au+AT+A!NA#AA-A_A,A%AACA[IA[AA-A &A,AfARAAԌAA͟ArZADAxDA1A@A AAAAA@@@@IAoIA>IA+IAןIAtIA|HAoHAVFA?FA/%GA;GAvIAlIAVIACHAtIADAfHHAHAFAaFA:GA'FAK;A.;A?AT>A7AAAAEAEATA'SA{;A;A#>A>AAA=AdEAEA TAgTAt`)A)A!&Am&A=Aǜ=A$AAAA~1FAEAsJAzJA OANA)A%AǤ$A<$Aג=AK=AAAJAAEAܧCANmJAfJAOAGOA@@ A AUA{A*@*@ A A{A{A AYAڿAYA \ No newline at end of file +%AA5AQ5AAA$A$A|A{A@h@^A܃A*G@@ +A AAA A&AZAr"AٶA#AhBAA#A_A*)A AjA_AA` A¨A]AAA` A` AAA܈AAvAAAA `A%AA#BAA}AjA7A%A + AyNAiAAb$AlAFARA*AAaAFA$AAAAg7A@ALALA*A}AC}A;A=AAA#}A%|AAݗA+AJAAAtAutAA|Ac*A>-AAaAhtAtA3nA,yAAA,yA,yAcAcA!A!AcA3AAA!A!A3A;A9xAPAAAACRASjA3ACRAX_AAAvA::A=A +A)A)AF&A1&AJArJA)GACGA?AAsAA +A A)A)AA&A"/&AJA!JACGAFA AxAMAAv+A9 +AD*A*Aۇ%AK%APAOAwNAQKAJAJAm@m@N,@N,@'A'A4(A4(A!A!A NA NAQKAQKAEJAEJA4A4A#%Ax&%A#4A4Ay$AN$A^A^A^A\A/^A^A,]A]A^A^AIP]AIP]AZYA YA YAO~XA@܇@OAOA܇@3@OANA:@.@@v@.@@4@_@Q@@@@9@fO@:@e:@UA)*A]hA]hAfAAAeAlAoAeAEBAa A AaA`A+Aʗ+A$A{DAEU AD A`Ah\Au+AT+A!NA#AA-A_A,A%AACA[IA[AA-A &A,AfARAAԌAA͟ArZADAxDA1A@A AAAAA@@@@IAoIA>IA+IAןIAtIA|HAoHAVFA?FA/%GA;GAvIAlIAVIACHAtIADAfHHAHAFAaFA:GA'FAK;A.;A>AJn>A7AAAAEAEATA'SA{;A;AZ>A6>AAA=AdEAEA TAgTAt`)A)A!&Am&A5=A=AHAAAAEA;XEAsJAzJA OANA)A%AǤ$A<$A=AX&=A$@A@A;XEACANmJAfJAOAGOA@@ A AUA{A*@*@ A A{A{A AYAڿAYA \ No newline at end of file diff --git a/src/features/editScene/roadlib/RoadNetworkGen.cpp b/src/features/editScene/roadlib/RoadNetworkGen.cpp index 9b4dfde..f27b8a3 100644 --- a/src/features/editScene/roadlib/RoadNetworkGen.cpp +++ b/src/features/editScene/roadlib/RoadNetworkGen.cpp @@ -924,7 +924,17 @@ uint32_t generateGrid(RoadGraph &graph, const GridParams ¶ms, if (run < 1e-4f || rise / run > params.maxSlope) return; /* too steep */ } - graph.addEdge(a, b); + int ei = graph.addEdge(a, b); + if (ei >= 0) { + /* Stamp this generation's road make-up (phase 5.9 + * follow-up); 0/Inherit leave the edge fields unset so + * the RoadConfig defaults apply. */ + RoadEdge &e = graph.edges[(size_t)ei]; + e.lanesAtoB = params.lanesAtoB; + e.lanesBtoA = params.lanesBtoA; + e.sidewalkLeftMode = params.sidewalkLeftMode; + e.sidewalkRightMode = params.sidewalkRightMode; + } }; for (int i = 0; i <= params.blocksX; ++i) for (int j = 0; j <= params.blocksZ; ++j) { @@ -1193,4 +1203,37 @@ uint32_t effectiveAreaSeed(const RoadGraph &graph, const RoadTownArea &area) return area.seed; } +int ownerAreaIndex(const std::vector &areas, + float x, float z) +{ + int best = -1; + double bestCoverage = 0.0; + for (size_t i = 0; i < areas.size(); ++i) { + const RoadTownArea &a = areas[i]; + if (!a.contains(x, z)) + continue; + double coverage = a.circular ? + 3.14159265358979323846 * (double)a.radius * + (double)a.radius : + 4.0 * (double)a.halfSize * (double)a.halfSize; + if (best < 0 || coverage < bestCoverage) { + best = (int)i; + bestCoverage = coverage; + continue; + } + if (coverage > bestCoverage) + continue; + /* Exact coverage tie: lower seed, then name. */ + const RoadTownArea &b = areas[best]; + if (a.seed != b.seed) { + if (a.seed < b.seed) + best = (int)i; + continue; + } + if (a.name < b.name) + best = (int)i; + } + return best; +} + } /* namespace RoadNetworkGen */ diff --git a/src/features/editScene/roadlib/RoadNetworkGen.hpp b/src/features/editScene/roadlib/RoadNetworkGen.hpp index 70d1bca..c62f9de 100644 --- a/src/features/editScene/roadlib/RoadNetworkGen.hpp +++ b/src/features/editScene/roadlib/RoadNetworkGen.hpp @@ -200,6 +200,21 @@ struct GridParams { float maxSlope = 0.35f; /** Run resolveAllCrossings after generating. */ bool runCrossingResolution = true; + + /** + * Per-generation road make-up (phase 5.9 follow-up): the lanes and + * sidewalk modes stamped on every edge THIS generation creates, so + * two grids in one map can differ without touching the RoadConfig + * defaults. A lane count of 0 leaves the edge field unset (it + * inherits RoadConfig::defaultLanesAtoB/lanesPerDirection at resolve + * time); a sidewalk mode of Inherit leaves the edge mode unset. + * RoadGraph::splitEdge copies the whole RoadEdge, so the crossing + * resolution's splits preserve the stamped values. + */ + int lanesAtoB = 0; + int lanesBtoA = 0; + RoadSidewalkMode sidewalkLeftMode = RoadSidewalkMode::Inherit; + RoadSidewalkMode sidewalkRightMode = RoadSidewalkMode::Inherit; }; /** Terrain height sampler: render-space (x, z) -> surface Y. */ @@ -274,6 +289,40 @@ void townAreasFromJson(RoadGraph &graph, const nlohmann::json &j); uint32_t effectiveAreaSeed(const RoadGraph &graph, const RoadTownArea &area); +/** + * Owning area of a lot centroid (phase 5.9 follow-up): a lot belongs + * to exactly ONE area. Among the areas containing (x, z) the owner + * is the one with the smallest coverage (circle pi*r^2, square + * 4*halfSize^2 — the most specific area wins); ties break by lower + * seed, then by lexicographic name. All keys are area content, so + * the result is stable under townAreas list reordering + * (order-independent). Note: a full (coverage, seed) tie makes the + * choice name-dependent, so give areas distinct seeds. + * + * Returns the index into areas, or -1 when no area contains the + * point. TownGen::generateTown() and the editor area-ownership + * preview both go through this so they never disagree. + */ +int ownerAreaIndex(const std::vector &areas, + float x, float z); + +/** + * Deterministic preview color for an area (editor area-ownership + * preview): FNV-1a hash of the area name mapped to an HSB hue, so the + * color is stable under townAreas list reordering. + */ +inline Ogre::ColourValue areaPreviewColor(const std::string &name) +{ + uint32_t h = 2166136261u; + for (char c : name) { + h ^= (uint8_t)c; + h *= 16777619u; + } + Ogre::ColourValue col; + col.setHSB((float)(h % 256) / 255.0f, 0.75f, 1.0f); + return col; +} + } /* namespace RoadNetworkGen */ #endif /* EDITSCENE_ROADNETWORKGEN_HPP */ diff --git a/src/features/editScene/roadlib/TownGen.cpp b/src/features/editScene/roadlib/TownGen.cpp index b9fe872..0dd63a7 100644 --- a/src/features/editScene/roadlib/TownGen.cpp +++ b/src/features/editScene/roadlib/TownGen.cpp @@ -368,25 +368,18 @@ TownResult generateTown(const RoadGraph &graph, const TownParams ¶ms, streetNumbers.clear(); } - /* Phase 4.5 item 4: town-area scoping. The lot belongs - * to the area containing its centroid (first-match-wins - * over overlapping areas); only that area's run builds - * it. No RNG draws happen before this point, so - * filtering does not disturb determinism. */ + /* Phase 4.5 item 4 / phase 5.9 follow-up: town-area + * scoping. The lot belongs to exactly one area — the + * deterministic ownerAreaIndex() winner (smallest + * containing coverage, then lower seed, then name; + * order-independent). Only the owner's run builds it. + * No RNG draws happen before this point, so filtering + * does not disturb determinism. */ if (areas && areaIndex >= 0 && areaIndex < (int)areas->size()) { - if (!(*areas)[areaIndex].contains(lot.centroid.x, - lot.centroid.z)) - continue; - bool ownedEarlier = false; - for (int k = 0; k < areaIndex; ++k) { - if ((*areas)[k].contains(lot.centroid.x, - lot.centroid.z)) { - ownedEarlier = true; - break; - } - } - if (ownedEarlier) + if (RoadNetworkGen::ownerAreaIndex( + *areas, lot.centroid.x, + lot.centroid.z) != areaIndex) continue; } diff --git a/src/features/editScene/systems/EditorUISystem.cpp b/src/features/editScene/systems/EditorUISystem.cpp index a7565aa..2bcc938 100644 --- a/src/features/editScene/systems/EditorUISystem.cpp +++ b/src/features/editScene/systems/EditorUISystem.cpp @@ -2528,8 +2528,15 @@ void EditorUISystem::handleRoadEditClick(const Ogre::Ray &mouseRay) int edgeIdx = pickRoadEdge(hit); if (edgeIdx >= 0) { - rs->setSelectedEdgeIndex(edgeIdx); - rs->setSelectedNodeId(-1); + /* Ctrl+click toggles the edge in the batch multi-selection + * (phase 5.9 follow-up); plain click single-selects. */ + if (ImGui::GetIO().KeyCtrl) { + rs->setSelectedNodeId(-1); + rs->toggleEdgeSelected(edgeIdx); + } else { + rs->setSelectedEdgeIndex(edgeIdx); + rs->setSelectedNodeId(-1); + } m_roadGizmo->setVisible(false); return; } diff --git a/src/features/editScene/systems/RoadSystem.cpp b/src/features/editScene/systems/RoadSystem.cpp index 4243fdd..05fa665 100644 --- a/src/features/editScene/systems/RoadSystem.cpp +++ b/src/features/editScene/systems/RoadSystem.cpp @@ -218,12 +218,130 @@ void RoadSystem::setSelectedNodeId(int id) void RoadSystem::setSelectedEdgeIndex(int idx) { - if (m_selectedEdgeIndex != idx) { + bool setChanged = false; + if (idx >= 0) + setChanged = m_selectedEdgeIndices != std::set{ idx }; + else + setChanged = !m_selectedEdgeIndices.empty(); + if (m_selectedEdgeIndex != idx || setChanged) { m_selectedEdgeIndex = idx; + m_selectedEdgeIndices.clear(); + if (idx >= 0) + m_selectedEdgeIndices.insert(idx); rebuildVisualAids(); } } +void RoadSystem::toggleEdgeSelected(int idx) +{ + if (idx < 0) + return; + if (m_selectedEdgeIndices.count(idx)) { + m_selectedEdgeIndices.erase(idx); + if (m_selectedEdgeIndex == idx) + m_selectedEdgeIndex = m_selectedEdgeIndices.empty() ? + -1 : *m_selectedEdgeIndices.rbegin(); + } else { + m_selectedEdgeIndices.insert(idx); + m_selectedEdgeIndex = idx; + } + rebuildVisualAids(); +} + +void RoadSystem::clearEdgeSelection() +{ + if (m_selectedEdgeIndices.empty() && m_selectedEdgeIndex < 0) + return; + m_selectedEdgeIndices.clear(); + m_selectedEdgeIndex = -1; + rebuildVisualAids(); +} + +int RoadSystem::selectConnectedComponent(int edgeIdx) +{ + flecs::entity terrain = getTerrainEntity(); + if (!terrain.is_alive() || !terrain.has()) + return 0; + const RoadGraph &rg = terrain.get().roadGraph; + if (edgeIdx < 0 || edgeIdx >= (int)rg.edges.size()) + return 0; + + std::unordered_map> byNode; + for (size_t i = 0; i < rg.edges.size(); ++i) { + byNode[rg.edges[i].nodeA].push_back((int)i); + byNode[rg.edges[i].nodeB].push_back((int)i); + } + + std::set visited; + std::vector queue; + queue.push_back(edgeIdx); + visited.insert(edgeIdx); + while (!queue.empty()) { + int ei = queue.back(); + queue.pop_back(); + const RoadEdge &e = rg.edges[ei]; + const int endNodes[2] = { e.nodeA, e.nodeB }; + for (int n : endNodes) { + for (int next : byNode[n]) { + if (visited.insert(next).second) + queue.push_back(next); + } + } + } + + m_selectedEdgeIndices = visited; + m_selectedEdgeIndex = *visited.rbegin(); + rebuildVisualAids(); + return (int)visited.size(); +} + +int RoadSystem::selectPathBetweenNodes(int nodeA, int nodeB) +{ + flecs::entity terrain = getTerrainEntity(); + if (!terrain.is_alive() || !terrain.has()) + return 0; + const RoadGraph &rg = terrain.get().roadGraph; + if (nodeA == nodeB || !rg.findNodeById(nodeA) || + !rg.findNodeById(nodeB)) + return 0; + + /* node -> (neighbor node, edge index) adjacency */ + std::unordered_map>> adj; + for (size_t i = 0; i < rg.edges.size(); ++i) { + adj[rg.edges[i].nodeA].push_back( + std::make_pair(rg.edges[i].nodeB, (int)i)); + adj[rg.edges[i].nodeB].push_back( + std::make_pair(rg.edges[i].nodeA, (int)i)); + } + + /* BFS shortest path by edge count, parent map per node. */ + std::unordered_map> parent; + std::vector queue; + queue.push_back(nodeA); + parent[nodeA] = std::make_pair(-1, -1); + size_t head = 0; + while (head < queue.size() && parent.find(nodeB) == parent.end()) { + int cur = queue[head++]; + for (const auto &next : adj[cur]) { + if (parent.find(next.first) != parent.end()) + continue; + parent[next.first] = std::make_pair(cur, next.second); + queue.push_back(next.first); + } + } + if (parent.find(nodeB) == parent.end()) + return 0; + + std::set path; + for (int n = nodeB; parent[n].first >= 0; n = parent[n].first) + path.insert(parent[n].second); + + m_selectedEdgeIndices = path; + m_selectedEdgeIndex = *path.rbegin(); + rebuildVisualAids(); + return (int)path.size(); +} + void RoadSystem::setDebugWedgeEnabled(bool v) { if (m_debugWedgeEnabled != v) { @@ -1274,8 +1392,12 @@ uint64_t RoadSystem::computePageSignature(uint64_t key) const const RoadConfig &cfg = graph.config; fnvHashPod(h, cfg.laneWidth); fnvHashPod(h, cfg.lanesPerDirection); + fnvHashPod(h, cfg.defaultLanesAtoB); + fnvHashPod(h, cfg.defaultLanesBtoA); fnvHashPod(h, cfg.roadThickness); fnvHashPod(h, cfg.sidewalkEnabled); + fnvHashPod(h, cfg.defaultSidewalkLeftMode); + fnvHashPod(h, cfg.defaultSidewalkRightMode); fnvHashPod(h, cfg.sidewalkWidth); fnvHashPod(h, cfg.sidewalkHeight); fnvHashPod(h, cfg.sidewalkThickness); @@ -2326,7 +2448,7 @@ void RoadSystem::buildEdgeLines() if (!na || !nb) continue; - bool selected = ((int)i == m_selectedEdgeIndex); + bool selected = m_selectedEdgeIndices.count((int)i) != 0; Ogre::ColourValue color = selected ? Ogre::ColourValue(1.0f, 0.0f, 1.0f) : Ogre::ColourValue(0.0f, 1.0f, 1.0f); @@ -2350,15 +2472,32 @@ void RoadSystem::buildLotOutlines() /* Potential building lots (RoadNetworkGen::findLots with the * default 45 m / 8-edge filter and edge-fallback squares) drawn as * dark grey outline loops, lifted slightly above the road surface - * like the other helper geometry. */ + * like the other helper geometry. With the area-ownership preview + * enabled (phase 5.9 follow-up) each lot instead takes its owning + * area's color (ownerAreaIndex: smallest containing coverage, then + * seed, then name), and contested lots (inside >= 2 areas) get an + * X marker at the centroid in the winner's color. */ std::vector lots = RoadNetworkGen::findLots(rg); m_lotOutlines->begin("Ogre/AxisGizmo", Ogre::RenderOperation::OT_LINE_LIST); - m_lotOutlines->colour(Ogre::ColourValue(0.1f, 0.1f, 0.1f)); for (const RoadNetworkGen::RoadLot &lot : lots) { + int owner = -1; + int containers = 0; + if (m_areaOwnershipPreview && !rg.townAreas.empty()) { + owner = RoadNetworkGen::ownerAreaIndex( + rg.townAreas, lot.centroid.x, lot.centroid.z); + for (const RoadTownArea &area : rg.townAreas) + if (area.contains(lot.centroid.x, + lot.centroid.z)) + ++containers; + } + m_lotOutlines->colour(owner >= 0 ? + RoadNetworkGen::areaPreviewColor( + rg.townAreas[owner].name) : + Ogre::ColourValue(0.1f, 0.1f, 0.1f)); size_t n = lot.polygon.size(); for (size_t i = 0; i < n; ++i) { Ogre::Vector3 a = lot.polygon[i]; @@ -2368,12 +2507,25 @@ void RoadSystem::buildLotOutlines() m_lotOutlines->position(a); m_lotOutlines->position(b); } + if (containers >= 2 && owner >= 0) { + /* Contested lot: X marker at the centroid in the + * winner's color. */ + Ogre::Vector3 c = lot.centroid + Ogre::Vector3(0, 0.4f, 0); + const float r = 1.5f; + m_lotOutlines->position(c + Ogre::Vector3(-r, 0, -r)); + m_lotOutlines->position(c + Ogre::Vector3(r, 0, r)); + m_lotOutlines->position(c + Ogre::Vector3(-r, 0, r)); + m_lotOutlines->position(c + Ogre::Vector3(r, 0, -r)); + } } /* Town generation areas (phase 4.5 item 4): dark blue loops, - * squares as 4 corners, circles as 64-segment polylines. */ - m_lotOutlines->colour(Ogre::ColourValue(0.1f, 0.1f, 0.3f)); + * squares as 4 corners, circles as 64-segment polylines — or the + * area's preview color when the ownership preview is on. */ for (const RoadTownArea &area : rg.townAreas) { + m_lotOutlines->colour(m_areaOwnershipPreview ? + RoadNetworkGen::areaPreviewColor(area.name) : + Ogre::ColourValue(0.1f, 0.1f, 0.3f)); if (area.circular) { const int segs = 64; for (int i = 0; i < segs; ++i) { @@ -2467,6 +2619,17 @@ void RoadSystem::buildSelectionHighlight() m_selectionHighlight->position(pos + Ogre::Vector3(0, 2.0f, 0)); } + /* Multi-edge selection (phase 5.9 follow-up): full lines over every + * selected edge, plus the direction arrow on the primary edge. */ + m_selectionHighlight->colour(Ogre::ColourValue(1.0f, 0.0f, 1.0f)); + for (int ei : m_selectedEdgeIndices) { + Ogre::Vector3 a, b; + if (!getEdgePositions(ei, a, b)) + continue; + m_selectionHighlight->position(a + Ogre::Vector3(0, 0.4f, 0)); + m_selectionHighlight->position(b + Ogre::Vector3(0, 0.4f, 0)); + } + if (m_selectedEdgeIndex >= 0) { Ogre::Vector3 a, b; if (getEdgePositions(m_selectedEdgeIndex, a, b)) { diff --git a/src/features/editScene/systems/RoadSystem.hpp b/src/features/editScene/systems/RoadSystem.hpp index d682e27..096143b 100644 --- a/src/features/editScene/systems/RoadSystem.hpp +++ b/src/features/editScene/systems/RoadSystem.hpp @@ -141,6 +141,56 @@ public: int getSelectedEdgeIndex() const { return m_selectedEdgeIndex; } void setSelectedEdgeIndex(int idx); + /** + * Area-ownership preview (phase 5.9 follow-up): when enabled the + * lot-outline overlay colors every findLots() lot by its owning + * town area (RoadNetworkGen::ownerAreaIndex), draws area bounds in + * matching colors and marks contested lots (inside >= 2 areas) + * with an X in the winner's color. + */ + bool getAreaOwnershipPreview() const + { + return m_areaOwnershipPreview; + } + void setAreaOwnershipPreview(bool v) + { + if (m_areaOwnershipPreview != v) { + m_areaOwnershipPreview = v; + rebuildVisualAids(); + } + } + + /** + * Multi-edge selection for batch editing (phase 5.9 follow-up). + * + * selectedEdgeIndex remains the "primary" edge whose inspector the + * panel shows; the set is what batch operations apply to. Plain + * setSelectedEdgeIndex() replaces the set with the single edge (or + * clears it for -1); toggleEdgeSelected() ctrl-click style adds or + * removes one edge and makes it the primary when added. + */ + const std::set &getSelectedEdgeIndices() const + { + return m_selectedEdgeIndices; + } + bool isEdgeSelected(int idx) const + { + return m_selectedEdgeIndices.count(idx) != 0; + } + void toggleEdgeSelected(int idx); + void clearEdgeSelection(); + /** + * Select every edge reachable from edgeIdx via shared nodes (BFS). + * Returns the number of edges selected. + */ + int selectConnectedComponent(int edgeIdx); + /** + * Select the edges of the shortest path (by edge count, BFS) + * between two nodes. Returns the number of edges selected, 0 when + * no path exists. + */ + int selectPathBetweenNodes(int nodeA, int nodeB); + /** * Last connectNodes failure from the 3D Connect tool. The terrain * editor panel consumes it with takeConnectError() and shows it as @@ -627,6 +677,11 @@ private: bool m_visualAidsVisible = true; int m_selectedNodeId = -1; int m_selectedEdgeIndex = -1; + /* Multi-edge selection (phase 5.9 follow-up); always contains + * m_selectedEdgeIndex when that is >= 0. */ + std::set m_selectedEdgeIndices; + /* Area-ownership preview toggle (phase 5.9 follow-up). */ + bool m_areaOwnershipPreview = false; uint64_t m_lastGraphVersion = 0; std::string m_connectError; bool m_connectErrorPending = false; diff --git a/src/features/editScene/systems/SceneSerializer.cpp b/src/features/editScene/systems/SceneSerializer.cpp index 252f7c3..69c93ac 100644 --- a/src/features/editScene/systems/SceneSerializer.cpp +++ b/src/features/editScene/systems/SceneSerializer.cpp @@ -4838,6 +4838,8 @@ nlohmann::json SceneSerializer::serializeTerrain(flecs::entity entity) roadConfigJson["roadMeshTemplate"] = tc.roadGraph.config.roadMeshTemplate; roadConfigJson["laneWidth"] = tc.roadGraph.config.laneWidth; roadConfigJson["lanesPerDirection"] = tc.roadGraph.config.lanesPerDirection; + roadConfigJson["defaultLanesAtoB"] = tc.roadGraph.config.defaultLanesAtoB; + roadConfigJson["defaultLanesBtoA"] = tc.roadGraph.config.defaultLanesBtoA; roadConfigJson["roadThickness"] = tc.roadGraph.config.roadThickness; roadConfigJson["roadLodDistance"] = tc.roadGraph.config.roadLodDistance; roadConfigJson["roadVisibilityDistance"] = @@ -4850,6 +4852,10 @@ nlohmann::json SceneSerializer::serializeTerrain(flecs::entity entity) tc.roadGraph.config.sidewalkThickness; roadConfigJson["sidewalkMeshTemplate"] = tc.roadGraph.config.sidewalkMeshTemplate; + roadConfigJson["defaultSidewalkLeftMode"] = + (int)tc.roadGraph.config.defaultSidewalkLeftMode; + roadConfigJson["defaultSidewalkRightMode"] = + (int)tc.roadGraph.config.defaultSidewalkRightMode; roadConfigJson["apronEnabled"] = tc.roadGraph.config.apronEnabled; roadConfigJson["apronWidth"] = tc.roadGraph.config.apronWidth; roadConfigJson["apronDrop"] = tc.roadGraph.config.apronDrop; @@ -5085,6 +5091,10 @@ void SceneSerializer::deserializeTerrain(flecs::entity entity, tc.roadGraph.config.laneWidth = rcj.value("laneWidth", 3.0f); tc.roadGraph.config.lanesPerDirection = rcj.value("lanesPerDirection", 1); + tc.roadGraph.config.defaultLanesAtoB = + rcj.value("defaultLanesAtoB", 0); + tc.roadGraph.config.defaultLanesBtoA = + rcj.value("defaultLanesBtoA", 0); tc.roadGraph.config.roadThickness = rcj.value("roadThickness", 0.3f); tc.roadGraph.config.roadLodDistance = rcj.value("roadLodDistance", 200.0f); tc.roadGraph.config.roadVisibilityDistance = @@ -5101,6 +5111,10 @@ void SceneSerializer::deserializeTerrain(flecs::entity entity, rcj.value("sidewalkThickness", 0.3f); tc.roadGraph.config.sidewalkMeshTemplate = rcj.value("sidewalkMeshTemplate", ""); + tc.roadGraph.config.defaultSidewalkLeftMode = + (RoadSidewalkMode)rcj.value("defaultSidewalkLeftMode", 0); + tc.roadGraph.config.defaultSidewalkRightMode = + (RoadSidewalkMode)rcj.value("defaultSidewalkRightMode", 0); tc.roadGraph.config.apronEnabled = rcj.value("apronEnabled", false); tc.roadGraph.config.apronWidth = rcj.value("apronWidth", 1.0f); diff --git a/src/features/editScene/tests/road_geometry_overlap_test.cpp b/src/features/editScene/tests/road_geometry_overlap_test.cpp index f7c2904..724e156 100644 --- a/src/features/editScene/tests/road_geometry_overlap_test.cpp +++ b/src/features/editScene/tests/road_geometry_overlap_test.cpp @@ -4785,7 +4785,9 @@ static bool runTownGenProbe() } /* Phase 4.5 item 4: town areas scope generation by lot centroid, - * first-match-wins over overlapping areas. */ + * deterministic owner over overlapping areas (phase 5.9 + * follow-up: RoadNetworkGen::ownerAreaIndex — smallest containing + * coverage, then lower seed, then name; order-independent). */ { RoadGraph graph; buildTown(graph); @@ -4815,8 +4817,10 @@ static bool runTownGenProbe() /* A: left enclosed pair + left fallback pair = 4 lots. * B's circle overlaps A on the (50,*) enclosed lots but - * loses them first-match-wins: right enclosed pair + - * right fallback pair = 4 lots. The top/bottom fallback + * loses them — A's square (coverage 4*60^2 = 14400) is + * smaller than B's circle (pi*120^2 ~= 45239), so A owns + * the contested lots: right enclosed pair + right + * fallback pair = 4 lots. The top/bottom fallback * squares lie outside both areas and build nothing. */ if (resA.buildings.size() != 4 || resB.buildings.size() != 4) { printf(" *** town areas: A=%zu B=%zu, want 4/4 ***\n", @@ -4839,8 +4843,9 @@ static bool runTownGenProbe() } } - /* First-match-wins: the two area runs own disjoint lot - * sets (the overlap lots belong to A). */ + /* Disjoint ownership: the two area runs own disjoint lot + * sets (the contested lots belong to A, the smaller + * containing area). */ std::set lotsA, lotsB; for (const TownGen::TownBuilding &b : resA.buildings) lotsA.insert(b.lotIndex); @@ -4857,6 +4862,87 @@ static bool runTownGenProbe() ok = false; } + /* Phase 5.9 follow-up: ownership is order-independent. + * Reversing townAreas must swap the per-area indices but + * keep each area's lot set identical. */ + { + RoadGraph graphRev = graph; + std::reverse(graphRev.townAreas.begin(), + graphRev.townAreas.end()); + TownGen::TownResult resAr = + TownGen::generateTown(graphRev, cc, flat, + nullptr, + &graphRev.townAreas, 1); + TownGen::TownResult resBr = + TownGen::generateTown(graphRev, cc, flat, + nullptr, + &graphRev.townAreas, 0); + std::set lotsAr, lotsBr; + for (const TownGen::TownBuilding &b : + resAr.buildings) + lotsAr.insert(b.lotIndex); + for (const TownGen::TownBuilding &b : + resBr.buildings) + lotsBr.insert(b.lotIndex); + if (lotsAr != lotsA || lotsBr != lotsB) { + printf(" *** town areas: ownership changed " + "under reorder (A %zu->%zu, B %zu->%zu) " + "***\n", + lotsA.size(), lotsAr.size(), + lotsB.size(), lotsBr.size()); + ok = false; + } + } + + /* ownerAreaIndex unit probes: containment, smallest- + * coverage win, seed and name tie-breaks — all + * independent of list order. */ + { + const std::vector &areas = + graph.townAreas; + using RoadNetworkGen::ownerAreaIndex; + /* (50,100): inside A (square) and B (circle) — + * A is smaller. (-30,100): A only. + * (250,100): B only. (500,500): none. */ + if (ownerAreaIndex(areas, 50.0f, 100.0f) != 0 || + ownerAreaIndex(areas, -30.0f, 100.0f) != 0 || + ownerAreaIndex(areas, 250.0f, 100.0f) != 1 || + ownerAreaIndex(areas, 500.0f, 500.0f) != -1) { + printf(" *** ownerAreaIndex: containment/" + "coverage ***\n"); + ok = false; + } + /* Seed tie-break: identical squares, lower seed + * wins regardless of order. */ + RoadTownArea s1, s2; + s1.name = "s1"; + s2.name = "s2"; + s1.center = s2.center = Vector3(0, 0, 0); + s1.halfSize = s2.halfSize = 50.0f; + s1.seed = 7; + s2.seed = 3; + std::vector v1 = { s1, s2 }; + std::vector v2 = { s2, s1 }; + int o1 = ownerAreaIndex(v1, 0.0f, 0.0f); + int o2 = ownerAreaIndex(v2, 0.0f, 0.0f); + if (o1 != 1 || o2 != 0 || + v1[o1].name != "s2" || v2[o2].name != "s2") { + printf(" *** ownerAreaIndex: seed " + "tie-break ***\n"); + ok = false; + } + /* Name tie-break: identical coverage and seed, + * lexicographically smaller name wins. */ + s2.seed = s1.seed; + std::vector v3 = { s2, s1 }; + int o3 = ownerAreaIndex(v3, 0.0f, 0.0f); + if (o3 < 0 || v3[o3].name != "s1") { + printf(" *** ownerAreaIndex: name " + "tie-break ***\n"); + ok = false; + } + } + /* townAreas json round trip (phase 5.9: towns + preferred * types included). */ { @@ -6434,6 +6520,67 @@ static bool runGeneratorProbe() } } + /* Per-generation lanes/sidewalk stamping (phase 5.9 follow-up): + * the params land on every edge this generation creates, and + * crossing-resolution splits preserve them (splitEdge copies the + * whole RoadEdge). */ + { + GridParams ps = p; + ps.jitter = 0.0f; + ps.lanesAtoB = 2; + ps.lanesBtoA = 1; + ps.sidewalkLeftMode = RoadSidewalkMode::On; + ps.sidewalkRightMode = RoadSidewalkMode::Off; + RoadGraph gStamp; + generateGrid(gStamp, ps, HeightSampler(), nullptr); + bool stamped = !gStamp.edges.empty(); + for (const RoadEdge &e : gStamp.edges) { + if (e.lanesAtoB != 2 || e.lanesBtoA != 1 || + e.sidewalkLeftMode != RoadSidewalkMode::On || + e.sidewalkRightMode != RoadSidewalkMode::Off) { + stamped = false; + break; + } + } + if (!stamped) { + printf(" *** stamping: generated edges lack the " + "params ***\n"); + ok = false; + } + /* Defaults (0/Inherit) leave the edge fields unset so the + * RoadConfig defaults apply. */ + bool unset = true; + for (const RoadEdge &e : g1.edges) { + if (e.lanesAtoB != 0 || e.lanesBtoA != 0 || + e.sidewalkLeftMode != RoadSidewalkMode::Inherit || + e.sidewalkRightMode != RoadSidewalkMode::Inherit) { + unset = false; + break; + } + } + if (!unset) { + printf(" *** stamping: default params dirtied the " + "edges ***\n"); + ok = false; + } + /* Split survival: split a stamped edge, both halves must + * keep the stamped values. */ + int splitId = gStamp.splitEdge(0, 0.5f); + bool splitOk = splitId > 0; + for (const RoadEdge &e : gStamp.edges) { + if (e.lanesAtoB != 2 || e.lanesBtoA != 1 || + e.sidewalkLeftMode != RoadSidewalkMode::On || + e.sidewalkRightMode != RoadSidewalkMode::Off) { + splitOk = false; + break; + } + } + if (!splitOk) { + printf(" *** stamping: split lost the params ***\n"); + ok = false; + } + } + printf(" %s\n", ok ? "passed" : "FAILURES above"); return ok; } diff --git a/src/features/editScene/ui/TerrainEditor.hpp b/src/features/editScene/ui/TerrainEditor.hpp index b17c8b7..1eeedc8 100644 --- a/src/features/editScene/ui/TerrainEditor.hpp +++ b/src/features/editScene/ui/TerrainEditor.hpp @@ -1319,6 +1319,24 @@ private: cfgChanged |= ImGui::SliderInt( "Lanes Per Direction", &rg.config.lanesPerDirection, 1, 8); + cfgChanged |= ImGui::SliderInt( + "Default Lanes A->B", + &rg.config.defaultLanesAtoB, 0, 8); + if (ImGui::IsItemHovered()) + ImGui::SetTooltip( + "Default lane count for the edge A->B " + "direction (0 = use Lanes Per " + "Direction). Edges with Lanes A->B = 0 " + "inherit this."); + cfgChanged |= ImGui::SliderInt( + "Default Lanes B->A", + &rg.config.defaultLanesBtoA, 0, 8); + if (ImGui::IsItemHovered()) + ImGui::SetTooltip( + "Default lane count for the edge B->A " + "direction (0 = use Lanes Per " + "Direction). Edges with Lanes B->A = 0 " + "inherit this."); cfgChanged |= ImGui::SliderFloat( "Road Thickness", &rg.config.roadThickness, 0.05f, 1.0f, "%.2f"); @@ -1342,7 +1360,45 @@ private: ImGui::SeparatorText("Sidewalks"); cfgChanged |= ImGui::Checkbox( "Sidewalks Enabled", &rg.config.sidewalkEnabled); - if (rg.config.sidewalkEnabled) { + { + /* Per-side defaults (phase 5.9 follow-up): edges + * whose sidewalk mode is Inherit resolve against + * these; Inherit here falls back to the legacy + * "Sidewalks Enabled" switch. */ + const char *swModes[3] = { "Inherit", "On", + "Off" }; + int dl = (int)rg.config.defaultSidewalkLeftMode; + if (ImGui::Combo("Default Sidewalk Left", &dl, + swModes, 3)) { + rg.config.defaultSidewalkLeftMode = + (RoadSidewalkMode)dl; + cfgChanged = true; + } + if (ImGui::IsItemHovered()) + ImGui::SetTooltip( + "Default for the left side (looking " + "from node A to node B) of edges in " + "Inherit mode; Inherit here uses " + "Sidewalks Enabled."); + int dr = (int)rg.config.defaultSidewalkRightMode; + if (ImGui::Combo("Default Sidewalk Right", &dr, + swModes, 3)) { + rg.config.defaultSidewalkRightMode = + (RoadSidewalkMode)dr; + cfgChanged = true; + } + if (ImGui::IsItemHovered()) + ImGui::SetTooltip( + "Default for the right side (looking " + "from node A to node B) of edges in " + "Inherit mode; Inherit here uses " + "Sidewalks Enabled."); + } + if (rg.config.sidewalkEnabled || + rg.config.defaultSidewalkLeftMode == + RoadSidewalkMode::On || + rg.config.defaultSidewalkRightMode == + RoadSidewalkMode::On) { cfgChanged |= ImGui::SliderFloat( "Sidewalk Width", &rg.config.sidewalkWidth, 0.5f, 5.0f); @@ -1453,6 +1509,11 @@ private: static bool s_pickArmed = false; static bool s_preview = false; static std::string s_genResult; + /* Per-generation road make-up (phase 5.9 follow-up): + * stamped on the edges this generation creates, not + * the RoadConfig defaults. 0 lanes = inherit config. */ + static int s_genLanesAtoB = 0, s_genLanesBtoA = 0; + static int s_genSidewalkLeft = 0, s_genSidewalkRight = 0; bool paramsChanged = ImGui::InputFloat2("Origin XZ", s_origin); @@ -1510,6 +1571,28 @@ private: 1.0f, "%.2f"); ImGui::Checkbox("Resolve Crossings", &s_resolve); + /* Lanes/sidewalks stamped on THIS generation's edges + * (0/Inherit leave the edge fields unset so the + * RoadConfig defaults apply at resolve time). */ + paramsChanged |= ImGui::SliderInt("Lanes A->B##gen", + &s_genLanesAtoB, 0, 8); + paramsChanged |= ImGui::SliderInt("Lanes B->A##gen", + &s_genLanesBtoA, 0, 8); + const char *genSideItems[3] = { "Inherit", "On", "Off" }; + paramsChanged |= ImGui::Combo("Sidewalk Left##gen", + &s_genSidewalkLeft, + genSideItems, 3); + paramsChanged |= ImGui::Combo("Sidewalk Right##gen", + &s_genSidewalkRight, + genSideItems, 3); + if (ImGui::IsItemHovered()) + ImGui::SetTooltip( + "Road make-up for the edges this generation " + "creates. 0 lanes / Inherit sidewalk leave the " + "edge fields unset so the RoadConfig defaults " + "apply; nonzero/On/Off stamp every generated " + "edge (survives crossing-resolution splits)."); + auto buildParams = [&]() { RoadNetworkGen::GridParams p; p.origin = Ogre::Vector3(s_origin[0], 0.0f, @@ -1523,6 +1606,12 @@ private: p.avoidWater = s_avoidWater; p.maxSlope = s_maxSlope; p.runCrossingResolution = s_resolve; + p.lanesAtoB = s_genLanesAtoB; + p.lanesBtoA = s_genLanesBtoA; + p.sidewalkLeftMode = + (RoadSidewalkMode)s_genSidewalkLeft; + p.sidewalkRightMode = + (RoadSidewalkMode)s_genSidewalkRight; return p; }; @@ -1831,11 +1920,101 @@ private: ImGui::Separator(); /* Phase 4.5 item 4: town areas — named square/circular * generation scopes carried by the road graph. A lot is - * built by the area containing its centroid - * (first-match-wins over overlapping areas). + * built by the area owning its centroid + * (RoadNetworkGen::ownerAreaIndex — smallest + * containing coverage, then seed, then name; + * order-independent). * "Generate All Areas" builds one "TownGen " * container per area. */ ImGui::TextUnformatted("Town Areas"); + /* Area-ownership preview (phase 5.9 follow-up): + * viewport overlay coloring each lot by its owning + * area, plus a legend with per-area lot counts. */ + { + bool ownPreview = rs->getAreaOwnershipPreview(); + if (ImGui::Checkbox("Area Ownership Preview", + &ownPreview)) + rs->setAreaOwnershipPreview(ownPreview); + if (ImGui::IsItemHovered()) + ImGui::SetTooltip( + "Color every lot by the area that " + "owns it and draw area bounds in " + "matching colors. Lots inside 2+ " + "areas get an X marker in the " + "winning area's color."); + if (ownPreview && !rg.townAreas.empty()) { + static uint64_t s_ownVersion = ~0ull; + static size_t s_ownAreaCount = 0; + static std::vector s_ownLots; + static std::vector s_ownContested; + if (s_ownVersion != rg.version || + s_ownAreaCount != + rg.townAreas.size()) { + s_ownVersion = rg.version; + s_ownAreaCount = + rg.townAreas.size(); + s_ownLots.assign( + rg.townAreas.size(), 0); + s_ownContested.assign( + rg.townAreas.size(), 0); + std::vector + lots = RoadNetworkGen:: + findLots(rg); + for (const auto &lot : lots) { + int own = RoadNetworkGen:: + ownerAreaIndex( + rg.townAreas, + lot.centroid + .x, + lot.centroid + .z); + if (own < 0) + continue; + s_ownLots[own]++; + int cont = 0; + for (const auto &a : + rg.townAreas) + if (a.contains( + lot.centroid + .x, + lot.centroid + .z)) + ++cont; + if (cont >= 2) + s_ownContested + [own]++; + } + } + for (size_t ai = 0; + ai < rg.townAreas.size(); ++ai) { + const RoadTownArea &a = + rg.townAreas[ai]; + Ogre::ColourValue c = + RoadNetworkGen:: + areaPreviewColor( + a.name); + /* Unique ID scope per legend row: + * without it every row's color + * button shares "##owncolor" and + * ImGui flags an ID conflict. */ + ImGui::PushID((int)ai); + ImGui::ColorButton( + "##owncolor", + ImVec4(c.r, c.g, c.b, + 1.0f), + ImGuiColorEditFlags_NoTooltip, + ImVec2(16, 16)); + ImGui::SameLine(); + ImGui::Text( + "%s: %d lots (%d contested)", + a.name.c_str(), + s_ownLots[ai], + s_ownContested[ai]); + ImGui::PopID(); + } + } + } static int s_areaPick = -1; const char *shapes[] = { "Square", "Circle" }; int removeArea = -1; @@ -2680,8 +2859,9 @@ private: float rowWidth = ImGui::GetContentRegionAvail().x; if (showConnect) rowWidth -= ImGui::CalcTextSize("Connect").x + - ImGui::GetStyle().FramePadding.x * 2.0f + - ImGui::GetStyle().ItemSpacing.x; + ImGui::CalcTextSize("Sel. Path").x + + (ImGui::GetStyle().FramePadding.x * 2.0f + + ImGui::GetStyle().ItemSpacing.x) * 2.0f; ImGui::PushID(n.id); if (ImGui::Selectable(label.c_str(), selected, 0, ImVec2(std::max(20.0f, rowWidth), @@ -2711,6 +2891,16 @@ private: "Road Connect Failed"); } } + ImGui::SameLine(); + if (ImGui::SmallButton("Sel. Path")) + rs->selectPathBetweenNodes(selectedNodeId, + n.id); + if (ImGui::IsItemHovered()) + ImGui::SetTooltip( + "Select the edges of the shortest " + "path between node %d and this " + "node (batch editing).", + selectedNodeId); } ImGui::PopID(); } @@ -2718,11 +2908,32 @@ private: /* Edge list. Same sizing rule as the node list: keep the * selectable clear of the row buttons. Every row has a Split * button (splitting does not require selecting the edge - * first); Remove only appears on the selected row. */ + * first); Remove only appears on the primary selected row. + * Ctrl+click toggles the edge in the multi-selection used by + * the batch panel below; plain click keeps single-select. */ ImGui::Text("Edges: %zu", rg.edges.size()); + { + const std::set &sel = rs->getSelectedEdgeIndices(); + if (!sel.empty()) { + ImGui::Text("Selected: %zu", sel.size()); + ImGui::SameLine(); + if (ImGui::SmallButton("Select Connected")) + rs->selectConnectedComponent( + rs->getSelectedEdgeIndex()); + if (ImGui::IsItemHovered()) + ImGui::SetTooltip( + "Extend the selection to every edge " + "reachable from the primary edge via " + "shared nodes."); + ImGui::SameLine(); + if (ImGui::SmallButton("Clear Selection")) + rs->clearEdgeSelection(); + } + } for (size_t i = 0; i < rg.edges.size(); ++i) { const auto &e = rg.edges[i]; - bool selected = ((int)i == rs->getSelectedEdgeIndex()); + bool inSelection = rs->isEdgeSelected((int)i); + bool primary = ((int)i == rs->getSelectedEdgeIndex()); std::string label = "Edge " + std::to_string(i) + ": " + std::to_string(e.nodeA) + " <-> " + std::to_string(e.nodeB); @@ -2736,16 +2947,21 @@ private: rowWidth -= ImGui::CalcTextSize("Split").x + ImGui::GetStyle().FramePadding.x * 2.0f + ImGui::GetStyle().ItemSpacing.x; - if (selected) + if (primary) rowWidth -= ImGui::CalcTextSize("Remove").x + ImGui::GetStyle().FramePadding.x * 2.0f + ImGui::GetStyle().ItemSpacing.x; ImGui::PushID((int)i); - if (ImGui::Selectable(label.c_str(), selected, 0, + if (ImGui::Selectable(label.c_str(), inSelection, 0, ImVec2(std::max(20.0f, rowWidth), 0))) { - rs->setSelectedEdgeIndex((int)i); - rs->setSelectedNodeId(-1); + if (ImGui::GetIO().KeyCtrl) { + rs->setSelectedNodeId(-1); + rs->toggleEdgeSelected((int)i); + } else { + rs->setSelectedEdgeIndex((int)i); + rs->setSelectedNodeId(-1); + } } ImGui::SameLine(); ImGui::BeginDisabled(eGrouped); @@ -2763,7 +2979,7 @@ private: rs->setSelectedNodeId(newId); rs->setSelectedEdgeIndex(-1); } - if (selected) { + if (primary) { ImGui::SameLine(); if (ImGui::SmallButton("Remove")) { rg.removeEdge(i); @@ -2781,6 +2997,87 @@ private: ImGui::PopID(); } + /* Batch edit (phase 5.9 follow-up): applies lanes/sidewalk + * modes to every edge in the multi-selection. Each field + * has a "keep" choice that leaves that property untouched. */ + if (!rs->getSelectedEdgeIndices().empty()) { + ImGui::SeparatorText("Batch Edit Selection"); + static int s_batchLanesAtoB = -1; /* -1 = keep */ + static int s_batchLanesBtoA = -1; + static int s_batchSidewalkLeft = 0; /* 0 keep,1 inherit, + 2 on, 3 off */ + static int s_batchSidewalkRight = 0; + /* Field edits only stage the batch; nothing touches the + * graph until Apply. */ + ImGui::SliderInt( + "Lanes A->B##batch", &s_batchLanesAtoB, -1, 8, + s_batchLanesAtoB < 0 ? "keep" : "%d"); + ImGui::SliderInt( + "Lanes B->A##batch", &s_batchLanesBtoA, -1, 8, + s_batchLanesBtoA < 0 ? "keep" : "%d"); + const char *keepModes[4] = { "keep", "Inherit", "On", + "Off" }; + ImGui::Combo("Sidewalk Left##batch", + &s_batchSidewalkLeft, + keepModes, 4); + ImGui::Combo("Sidewalk Right##batch", + &s_batchSidewalkRight, + keepModes, 4); + bool canApply = s_batchLanesAtoB >= 0 || + s_batchLanesBtoA >= 0 || + s_batchSidewalkLeft > 0 || + s_batchSidewalkRight > 0; + ImGui::BeginDisabled(!canApply); + if (ImGui::Button("Apply to Selected Edges")) { + bool any = false; + for (int ei : rs->getSelectedEdgeIndices()) { + if (ei < 0 || + (size_t)ei >= rg.edges.size()) + continue; + RoadEdge &e = rg.edges[(size_t)ei]; + if (s_batchLanesAtoB >= 0) { + e.lanesAtoB = s_batchLanesAtoB; + any = true; + } + if (s_batchLanesBtoA >= 0) { + e.lanesBtoA = s_batchLanesBtoA; + any = true; + } + if (s_batchSidewalkLeft > 0) { + e.sidewalkLeftMode = + (RoadSidewalkMode)( + s_batchSidewalkLeft - + 1); + any = true; + } + if (s_batchSidewalkRight > 0) { + e.sidewalkRightMode = + (RoadSidewalkMode)( + s_batchSidewalkRight - + 1); + any = true; + } + } + if (any) + rg.bumpVersion(); + } + ImGui::EndDisabled(); + if (ImGui::IsItemHovered( + ImGuiHoveredFlags_AllowWhenDisabled)) + ImGui::SetTooltip( + "Apply the non-\"keep\" fields to all " + "%zu selected edges. Ctrl+click edges in " + "the list or in the 3D view to extend " + "the selection.", + rs->getSelectedEdgeIndices().size()); + if (ImGui::SmallButton("Reset Batch Fields")) { + s_batchLanesAtoB = -1; + s_batchLanesBtoA = -1; + s_batchSidewalkLeft = 0; + s_batchSidewalkRight = 0; + } + } + /* Connect failures (from the 3D Connect tool via RoadSystem, * or the node-list Connect buttons above) are shown as a * modal. Placed after the lists so OpenPopup calls from the