Skip to content

TrailView ground plan GP11: looks on the mesh: way faces, ground faces, markings, kerbs, walls and steep faces #3104

Open

Description

@timohueser

Rewritten to the one road model (#3096); the previous body is in this issue's edit history.

Status: approved
Part of #3096. One pull request into ground-plan.
Depends on: #3103 (GP9), #3135 (GP3R: the records' lines), #3113 (GP6: the named steps). Band faces follow GP4's band ownership (#3099) when it lands.

TL;DR

Goal: Every face of a piece draws with today's looks: way faces with a smooth normal and frames that run on through junctions, give-way lines and edge-line gaps at the right mouths and on the right side of the road, kerbs with their top and edging stone, walls in rubble or rock by a table, ground faces that take the terrain's normal, facet and mask where they are the terrain, and steep faces with no stretched texture; the old path stays unchanged.
Problem: The looks read frames (across, along, half, flags) that the sweep makes per station (roads/sweep.ts, roads/marks.ts). The plan has faces, not stations. GP7 section 10 gives each face one frame from its owner, which is not sufficient in a junction, a bend tip or a mouth. ground_colour computes its normal and facet itself, so a mesh face that is not the terrain's triangle cannot match the terrain at the strip. Kerb tops and edging stones are geometry today, but GP4 makes them look. Steep faces stretch (#3092, unmerged).
Decision: The crate gives each face one or more look parts, each with one look word and one frame rule; part borders are mesh constraints inside the face, and the face, its owner and its height rule do not change. In a junction, each guest gets a strip in its own frame, each corner fill the lesser arm's look, the area round the junction point a plain part in the host's frame, gap parts switch off edge lines and fray, and a give-way part has a frame sheared to the host's edge, on the side that the region's traffic rule gives. GP11 extends GP7's look module (mesh/look.rs) and replaces the GP7 rules that it lists. ground_colour takes a GroundShape (normal, facet, road terms, rock and bare shares) from its caller; terrain faces and the strip pass the terrain's own values, and every other ground face passes its own. GP11 ports the face projection of #3092 behind an override that only the new path sets.
Rejected:

  • Face splits for marks (the way GP4 splits zebras): a split adds faces and labels that the records do not hold, so the near look and the far look (GP8) would differ. Look parts keep every face, its label and its height.
  • A per-piece list of marks tested per pixel: a new buffer, a per-pixel loop, the piece's identity in the fragment.
  • One frame per face (GP7 section 10): a guest's ramp and mouth would lose their ruts and lines.
  • Frames blended over a junction face: a blend mixes the stroke metres of different ways.
  • The facet from screen derivatives on the plan's terrain faces: the mesh's triangles differ from the terrain's, so the cliff term differs at the strip (epic, section 10).
  • The terrain's values on slope faces where the slope rule leaves the ground at T: inside a slope band the pages hold height_at (GP8), which is not T there.
  • GP6's blend over any value (blend_of on Heights::z): GP6 has no per-face blend in the one road model. The values at sample ends come from the records' lines (the host line's frame, as GP7 section 10).
  • A shaped zone by class (10 m for a road, 3 m for a path, a select at a half-width): a case distinction that gives a stair where a path leaves a road (shapes/owner2/).
  • A give-way frame with across along the host's edge: the look centres the triangle at across = half/2 (roads/looks.wgsl:240-241), so on an oblique guest the triangle leaves the lane by along · cot θ.
  • A wrap of along with splits: GP7's base per way and piece keeps the phase.
  • Kerb-top and edging faces: under the minimum width (GP4).
  • A concrete wall look now: no step edge at GP11's head asks for it.
    Systems: trailview
    Contracts: none (rule values go into data/trailview/plan.json and data/trailview/regions/world.json; no spec, no device format)
    Size: L (about 700 to 900 crate lines on GP7's look module; ground_colour and its three callers; the piece branch; two materials; the port of ground/face.wgsl; about 16 tests), in three commit series.

Facts

  • The corridor shades a way face by its screen-derivative facet (roads/corridor.wgsl:222-227), builds WayPixel (:228-232), calls way_look (:234), discards all-ground pixels (:235-237) and mixes the ground's share in (:238-240).
  • A face takes its look word from its first vertex (roads/piece.ts:1-3). The word: material 7 bits, surface code 4, flags 5, band priority 3, half-width 9 bits at 0.025 m; across 12 bits signed at 0.0078 m (±16 m); along 20 bits unsigned at 1/64 (roads/piece.ts:9-25, :53; roads/corridor.wgsl:26-37).
  • along is a count from a base that is a multiple of REPEAT = 720, so looks whose periods divide 720 keep their phase (roads/sweep.ts:14-16, :34-43). A railway counts sleepers of 0.6 m (roads/sweep.ts:33, terrain/features.wgsl:45). GP7 section 10 sets the base per way and piece: 720 × floor(the least stroke metres of that way in the piece / 720).
  • Materials and looks: MAT (GROUND 1, KERB 2, SIDEWALK 3, rails 40 to 46, WALL 48, CAP 49), LOOK 15 to 39, flags CF with NO_LEFT_LINE 8, NO_RIGHT_LINE 16 (roads/section.ts:17-26). The band-only flags SAMPLE, MESH, UNDER and the priority have no meaning on the mesh.
  • opens() turns off a side's edge line and its fray by those flags (roads/looks.wgsl:131-135). Lines need half ≥ MARKED_HALF_M 2.75 m (ground/roads.wgsl:34, roads/looks.wgsl:138-169); the widest edge term of markings lies 0.45 m inside the edge (roads/looks.wgsl:144).
  • A junction face today is the way's surface with no edge: across 2 m, half 12 m, mat ASPHALT or GRAVEL; a way of soil has none, so the ground shows (roads/section.ts:46, :81-85).
  • GP3 4.6: a guest's blend part has the guest as material, a corner fill the lesser arm; mouth kinds reach, stop (the host's edge line runs on), join. GP3 4.5: a tip fill has owner Bend(way, dm) and rule Blend.
  • The look fades a shoulder by fixed widths 0.6 m (main) and 0.4 m (road) (roads/looks.wgsl:55-58, :173-191), as SHOULDER_M (terrain/bins.ts:52).
  • Today's kerb is geometry: a 2.5 cm bevel, a top 0.16 m wide, the slab, an edging stone 0.1 m at the back (roads/section.ts:38, :115-122). GP4 makes the kerb top and edging stone look, from d (metres from the kerb line) and w(s) (GP4, "Data that GP4 writes").
  • Zebra: across is metres off the line through the node along the station's normal; stripes 0.35 m off the edges (roads/marks.ts:58-72, roads/looks.wgsl:211-233); the node may lie 2.5 m off the middle (roads/marks.ts:13).
  • Give-way: a minor asphalt road gives way at a roundabout or to a better class of MAIN, unless it is the ring or a one-way that leaves; the line lies 0.4 m back, 0.3 m wide, with a triangle 1.2 m behind it, 1.2 m wide and 2.6 m long; the paint reaches 4.2 m past the 0.4 m (roads/marks.ts:16-25, :74-90; roads/looks.wgsl:38-44, :235-245). Today along and across are the guest's own, and "traffic keeps right" is code (roads/marks.ts:83, :88).
  • Region look rules can take values by country: "zebra": {"ch": …, "*": …} (data/trailview/regions/alps.json:10). No rule holds the traffic side (TrailView roads: what remains after epic #2960 #3005).
  • ground_colour(s, relative, d, altitude, level, pixel, bench) computes the facet from d and the normal from drawn_normal(s) (ground/look.wgsl:650-663); the override BAND turns off the cliff term skirt and the mask paint road_at (:38-40, :666, :672-675); the corridor pipeline sets BAND: 1 (roads/roads.ts:293); the terrain calls it at terrain/terrain.wgsl:122 with overrides DETAIL and HOLES (terrain/terrain.ts:937-938). d also gives footprint and surface_size (:654-659).
  • Inside ground_colour: masonry from the mask's wall term, not in bare rock or woodland: road.wall · (1 − cover) · (1 − barren) · (1 − tree) (:681); the coarse normal on cliffs, skirts, road cuts and path benches (:687-704), a road cut's tufts (:730-739), rock by broad and skirt (:848, :863), the cliff look walled that excludes trees and road paint (:872-925). The ground cell's alpha is barren × 255 (:13).
  • mesh_height finds the drawn triangle by vertex places and morph and returns dot(w, h) (terrain/drawn-mesh.wgsl:109-153). The cell's diagonal is (a, a+n, a+1), (a+1, a+n, a+n+1) (:134).
  • Walls on the mesh today: rubble by along and altitude, a capstone MAT_CAP (roads/details.wgsl:70-86, :109-118); the ground's painted walls use world axes, cross-faded near 45° (ground/look.wgsl:682-684, :832-844).
  • TrailView A8: steep faces without stretched texture #3092 (A8): branch claude/road-a8-steep-look at 58febe615 adds ground/face.wgsl (plan and two side projections by the fine drawn normal), reads it in five ground terms, adds STEEP_CUT (0 ground, 1 bare earth or rock where barren, 2 rock) and face.test.js. It sits on A7 (PR TrailView A7: a derived wall only where the cut has no room #3091, open); neither is in develop.
  • Cut and fill: 0.85 (40°) for roads and tracks; paths cut at 2.1445 (65°) (data/trailview/roads.json).
  • shoot.mjs:61 counts red pixels only for debug=cracks; debug views are an indexed list (view.ts:9); GP9 appends owned (11) and draws pieces with corridor_fragment and PIECE = 1.

Design

Words of this sub-issue

  • Frame: what the look reads at a vertex beside its material: across (m), along, half (m), the surface code and the flags.
  • Stroke frame of a way at point p, with foot f on its middle line: across = signed metres from f, left positive; along = stroke metres at f (sleepers, stroke metres / 0.6, on a railway) minus GP7's base of that way in the piece (720 × floor(least count / 720), in sleepers on a railway); half = the carriageway's half-width at f.
  • Look part: a polygon inside one face, in the cell's i32 frame, with one look word and one frame rule. The parts of a face tile it with no overlap and no gap. A face with one look is one part.
  • Guest strip: the part of a guest's carriageway band (its two offset curves) that lies in a junction's blend face.
  • Gap: a stretch of a way's frame part where a side has no edge line and no fray.
  • Twin: a second vertex with the same position and height bits, for a second look part.
  • Shaped share: 0 where a ground face's height is the terrain's, 1 where a rule shapes it.

Data GP11 reads

  • GP1: the rule reader. GP3: PlanRules. GP5: the request.
  • GP2: Way (class, kind, curve, oneway, junction=roundabout, the stroke metres), Junction (arms, host or guest, heading, end).
  • GP3: faces with owner and surface, the band builder (offset curves at global arc-length parameters, unions of quads), the corner fills and tip fills with arc and tangent points T_a, T_b, the material way of each junction face, the priority table, the sliver function, min_width_m, the mouth kind of each guest.
  • GP4: Face.marking = Zebra { origin, along }; d and w(s) of a sidewalk point; kerb edges.
  • GP3R (TrailView ground plan GP3R: the records of a cell (one source for near and far) #3135): the records of the cell: the label's material, host and other lines, the lines' words (class rank, finish code, half-width, shoulder, verge, the slope reach) and their samples. The production layout has no marked word: whether a line carries markings is a look rule, and GP11 owns it (below).
  • GP6: height_at and height_at_sides with Height.step (the named step of an edge and its higher side). GP1: the terrain height T(p).
  • GP7: the triangulation and its constraint list, vertical faces, the vertex and its normal in the axes of drawn_normal (LOD space), the look module mesh/look.rs. GP7 owns the bytes; GP11 owns what across, along, half and the word mean.

Data GP11 writes

  • Plan.looks: Vec<LookPart>, LookPart { face: FaceId, polygon: Polygon, mat: u8, code: u8, flags: u8, frame: FrameRule }.
  • enum FrameRule { Stroke(WayId), Radial(WayId), BendBlend(WayId), Plain { look: WayId, frame: WayId }, GiveWay { host: WayId, guest: WayId, side: i8, sine: f64 }, Zebra { foot: [i64; 2], along: [f64; 2] }, Walk, Ground(ShapedRule), Vertical }, with enum ShapedRule { Terrain, Shaped, Full }.
  • fn vertex_look(plan: &Plan, part: &LookPart, p: [i32; 2], h: f64) -> VertexLook, VertexLook { word: u32, across: f32, along: f32 }, which GP7's vertex emission calls for each corner of each triangle.
  • LookStats: parts by rule, twins, gaps, give-ways placed and refused by reason, give-ways by traffic side, slivers merged, clamps.

GP7 rules that GP11 replaces

  • Sidewalk MAT.SIDEWALK → MAT_WALK with the Walk frame: the kerb top and the edging stone are look (GP4).
  • A vertical face's along "of the higher face's frame" → 0: the wall looks read world axes, and a frame's along jumps where the higher face changes.
  • A vertical face's material by edge kind in code → the walls block (below).
  • A junction face "the nearest host arm's way" → by part: the guest's own way in its strip, the lesser arm in a fill (as GP7 has it), the first host elsewhere. A nearest-host rule switches frames inside one face, so sett rows jump.
  • across and half from the label's host line (GP7 section 10) → the part's frame rule. Flags 0 → the gap flags.
  • GP7's base per way and piece stays, counted in sleepers on a railway.

The look of each surface

Surface mat code flags frame
carriageway, crossing face lookOf(way) (GP7's port) drawnCode(way) gaps Stroke; Radial past a way's end; BendBlend in a bend tip
shoulder today's rule (roads/section.ts:149): the carriageway's look, ASPHALT, or MAT_GROUND way's as its carriageway Stroke
rail bed LOOK_BALLAST rail code 0 Stroke, along in sleepers
platform MAT_SIDEWALK (paving) 0 0 across 2, half 12
sidewalk (GP4) MAT_WALK (new, 4) 0 0 Walk: across = d, half = w(s), along 0
zebra (GP4 marking) ZEBRA_ON[lookOf] (roads/marks.ts:41) way's 0 Zebra
junction area, corner fill (blend) by parts, see below
verge, bank, bed, seat MAT_GROUND owner's 0 Ground(Full)
slope MAT_GROUND owner's 0 Ground(Shaped)
terrain, strip MAT_GROUND 0 0 Ground(Terrain)
step edge (vertical) by the walls block 0 0 Vertical

half of a ground face is the owner way's half-width (0 for terrain): the look takes a path's bench from it. A deck's faces (GP12) take the rows of their surfaces.

Owner rules of the one road model (evidence on timosPC under /media/timo/OSM1/tmp/ground-plan/one-model/shapes/):

  • One asphalt colour; a junction face takes the material of its highest-class arm.
  • Dirt mouths: past the carriageways of its own lines, a face wears the material of its nearest other line (prototype aa956ed, owner1/ 1). GP8's B writes the same finish into its paint texture, so the hand-over shows one mouth.
  • Shoulders as develop: dusty asphalt on a paved shoulder, else gravel. A paved shoulder is dustier only by the share that an edge line divides it from the carriageway (model_lined_shoulder, owner1/ 4a): round a corner whose arms do not both wear lines, the two asphalts are one. The width comes from the line's shoulder word in the records, not from the fixed 0.6 m and 0.4 m of roads/looks.wgsl.
  • Band faces: band ownership is parked and returns with GP4's sidewalk bands. Until then a band face keeps the current rule; then it takes the material of the way that GP4's ownership gives.

Frame rules

  • Stroke: the foot on the way's curve at global arc-length parameters (GP2), read from the records' line of the way (the host line's frame, as GP7 section 10 and GP8's B). Valid where the foot is unique and well-conditioned.
  • Radial (points past the end of a way's curve, in its end shape): across = sign(a) · hypot(a, q), where a is the offset from the end's tangent line and q ≥ 0 the metres past the end; along = the end's value. Ruts end in an arc, a soil way frays round its end, a centre line stops at the end.
  • BendBlend (a way's tip fill, GP3 4.5): across = σ · (half − min(e, TIP_EDGE_M)), σ the inner side's sign, e the metres to the fill's arc; along from the records: the host line's frame along at the fill's foot on the way's line; half the way's. So the edge line and the fray follow the arc. TIP_EDGE_M = 1.0 m holds every edge term (0.45 m at most) and no middle or lane line (2.7 m or more inside). The way's carriageway part on side σ between the stroke metres of T_a and T_b gets a gap on σ: the legs' lines stop at the tangent points.
  • Plain { look, frame }: across 2, half = 12 m (FACE_HALF_M), along = the Stroke along of frame; mat by the junction surface of look: ASPHALT for an asphalt surface way, GRAVEL for gravel, the way's own look for setts, pavers and concrete (STRIPS gives CONCRETE); for DIRT and TRAIL the part is MAT_GROUND with Ground(Full). frame is always the junction's first host (GP3's priority, then way id), so sett rows and concrete joints run on from the host. ASPHALT has no markings, and 12 m keeps every edge term off.
  • GiveWay: along = metres from the host's carriageway edge along the guest's tangent, (|across_h| − half_h) / sine (≥ 0), with sine = max(sin θ, give_way_least_sine) and θ the angle between the two tangents where the guest's middle line crosses the host's edge; across = side × the guest's Stroke across; half = half_g. Lines of constant along lie parallel to the host's edge, as the host's edge line would. The guest's own across keeps the triangle at across = half/2 in the stopping lane at every along. side makes across positive in the lane that enters J: the left of a way that leaves J where traffic is right, the right where it is left.
  • Zebra: foot = the foot of GP4's origin on the holder's middle line; across = (p − foot) · n, n the left normal of GP4's along; half = the holder's half-width at p; along = Stroke along (setts keep their rows). The stripes keep 0.35 m off both edges even where the node lies off the middle.
  • Walk: d and w(s) from GP4.
  • Ground: across holds the rule: Terrain −1; Full 1; Shaped, the share of GP8's model_ground at the vertex: shaped = max(near, moved), near = smoothstep(0, 1, clamp(−d_slope / SHAPED_FADE_M, 0, 1)) with d_slope the vertex's distance to the slope layer's outer edge (the union of every line's slope reach, from the records) and 1 on the core, moved = smoothstep(0.05 m, 0.15 m) of |h − T(p)| (MOVED_M = 0.1 m). So the zone ends at each line's own slope reach, with no class switch, or where the heights moved the ground (owner rule (c)), and the mesh's ground faces and the far look call one rule. along 0.
  • Vertical: across 0, along 0. Walls take their along from the world (below).

Look parts of a cell, after GP4's overlay and before GP7's mesh

  1. Default: each face is one part with its surface's row of the table.
  2. Host gaps. For each junction J, each guest g whose mouth kind is reach (GP3 4.6 step 2; stop and join leave the host's edge line running on) and each host h: the gap on h's side σ that faces g runs from h's stroke metre of the tangent point of the corner fill between h and g on one side of g to that of the fill on its other side; where a side has no fill, from the point where g's band edge on that side crosses h's edge. Gaps on one side closer than min_width_m join. The gap part is h's carriageway part ∩ the band slab of h between the two stroke metres, offsets ±(half + 1 m); it takes NO_σ_LINE (the union where both sides have gaps).
  3. Guest strips. For each guest g, soil guests too: g's band (offsets ±half_g) ∩ J's blend face is a Stroke(g) part, with g's own look: ruts, fray and lines run to the seam. Its gaps, per side σ where the fill on that side has a paved look: from the seam (g's edge crossing h's edge) to g's stroke metre of that fill's tangent point. Beside a fill of ground, the guest keeps its fray.
  4. Corner fills. Each corner fill of J (GP3's polygon, minus the strips) is a Plain { look: the fill's material way, the lesser arm; frame: the first host } part. A fill whose lesser arm is soil is ground, as the epic says.
  5. Give-way. A guest g gives way (port of givesWay, roads/marks.ts:75-80): g is of the road kind, its look is ASPHALT, MAIN or MOTORWAY, it is not a roundabout ring, it is not a one-way that leaves J; and h is a ring, or h's best class has index m in give_way_to and g's class is not in give_way_to[0..m+2]. Its room is g's stroke metres from the seam to its other end or its next junction. The reach is give_way_reach_m if room > give_way_reach_m + triangle_room_m, else give_way_line_m if room > give_way_line_m + give_way_room_m, else none (counted). The part is h's band between offsets half_h and half_h + reach · sine on g's side ∩ g's band ∩ (J's blend face ∪ g's carriageway faces), minus zebra faces (counted). Frame GiveWay, mat LOOK_GIVE_WAY, code g's. traffic is the cell's.
  6. Plain: the rest of each blend face (outside every strip and fill: the area round the junction point) is Plain { look: first host, frame: first host }. Where one blend face holds close junctions whose first hosts lie on different strokes, the bisector of the two junction points splits it, so each part has one frame.
  7. Bend tips: each tip fill is one BendBlend part; its gaps as in the frame rule.
  8. Priority and order: give-way > gap > strip > fill > plain > default. Each part is its region minus every higher part, by i_overlay on integers.
  9. Slivers: GP3's sliver function runs on the parts of each face: a part thinner than min_width_m merges into its neighbour part of higher priority, and a tip is cut where it reaches that width. Every merge goes to a part whose look is plain there (a give-way part draws asphalt off its line and triangle; a gap only drops a line), so no merge shows.
  10. Hand-off to GP7: the borders between parts of one face are constraints of kind continuous inside it (with GP7's 0.4 m keep-off of grid points). Each triangle lies in one part. Its corners take vertex_look of that part. A point on a border between parts with different looks gets a twin per part, with the position and the height bits of the first: one height per point, so no crack opens.

Vertical faces

GP7's vertical face vertices carry the edge's horizontal unit normal toward the lower side. The word comes from the walls block by GP6's step name (Height.step) and the higher side. Unrelated is a wall too; RailRoad takes the retaining-wall look (owner: the step between a railway and a road is a retaining wall).

Rule blocks (in data/trailview/plan.json beside GP4's walk block, read with GP3's PlanRules; roads.json has no place, as every top-level key there is a class)

marks:

Field Unit Default Why
give_way_to classes motorway, motorway_link, trunk, trunk_link, primary, primary_link, secondary, secondary_link, tertiary, tertiary_link The classes that a minor road gives way to, best first (today's MAIN)
give_way_reach_m m 4.6 Host edge to the triangle's end: 0.4 back, 0.3 line, 1.2 gap, 2.6 triangle, 0.1 (today's 0.4 + 4.2)
give_way_line_m m 0.7 The line alone: 0.4 back, 0.3 line
give_way_room_m m 1.0 A guest needs this past its line (LINE_ROOM_M)
triangle_room_m m 2.0 And this past its triangle (TRIANGLE_ROOM_M)
give_way_least_sine 1 0.3 Caps the stretch of along on an acute guest (as LEAST_SINE)

walls: per edge kind (kerb, wall, headwall, portal, deck_edge) and higher side (way, ground), a look name: kerb (MAT_KERB), rubble (MAT_WALL) or cut (MAT_CUT_WALL, new, 50). Defaults: kerb kerb; wall on the way side rubble, on the ground side cut; headwall, portal and deck edge rubble until GP12 and GP15 add their own names. A test asserts that every name maps to a material id.

traffic (a region look rule in data/trailview/regions/world.json, by place as zebra is): {"gb": "left", "ie": "left", "im": "left", "gg": "left", "je": "left", "mt": "left", "cy": "left", "*": "right"} (places of countries.json). It sets the give-way side. The rules check of planner/trailview-rules accepts it in world.json only (the crate's file).

The place of a cell. GP5's Request gains place (8 ASCII bytes, zero-padded, a place of countries.json): in the viewer the place of the region at the cell's centre (rules.json ids), in the debug tool that of the countries.json ring holding it. GP1's reader resolves traffic, its only value by place, as the viewer's local (place, country, *). One place per cell is sufficient: no land border changes the traffic side (gb and ie drive left, and all of Cyprus does).

A test asserts that give_way_reach_m is at least the sum of GIVE_WAY_BACK_M, GIVE_WAY_M, TRIANGLE_BACK_M and TRIANGLE_LENGTH_M of roads/looks.wgsl.

Reach. GP11's own reach is 6.6 m (give_way_reach_m + triangle_room_m) past its seam; other parts lie in GP3's faces, and the frames read the records' lines of the bin. Its chain, GP3's face reach plus 6.6 m, goes into GP1's reach table, whose reader asserts each chain ≤ 191 m.

The ground look: GroundShape

ground/look.wgsl gains:

struct GroundShape {
    drawn: vec3f,  // the fine normal in LOD-space axes, as drawn_normal returns
    facet: vec3f,  // the drawn triangle's normal in render space, z ≥ 0
    own: f32,      // the share of `drawn` that is the face's own: no coarse normal there
    road: Road,    // the road terms where PAINT is off
    rock: f32,     // a share forced to the cliff look
    bare: f32,     // a share forced to bare earth, rock where barren
}
fn ground_colour(s, relative, d, altitude, level, pixel, shape: GroundShape) -> vec3f
  • override PAINT: bool = true replaces BAND with the inverse meaning: with PAINT, road_at runs inside as today; without it, shape.road stands in. The cliff term skirt reads shape.facet; a caller that wants no skirt passes facet = render_normal(drawn), which gives a difference of exactly 0. skirt *= 1 − road.shaped stays.
  • The coarse-normal mix becomes towards = mix(max(max(cliff, skirt), max(face, road.bench)), road.bench, own): the mesh's own normal is analytic and does not streak; a path's bench keeps today's light.
  • steep = max(…, shape.rock) and walled = max(walled, shape.rock): a forced rock share shows the cliff look whatever the trees. shape.bare mixes in cut_face(bare, bare, …) with bare = mix(dirt, lithology rock, barren) (A8's variant 1).
  • rise of the painted rocks reads shape.drawn.z.
  • Port of TrailView A8: steep faces without stretched texture #3092: ground/face.wgsl from 58febe615 as it is, and the reads of facing_of/face_noise/face_spans/bush_at in ground_colour from that commit, without A7's changes and without STEEP_CUT. override FACES: bool = false: without it facing_of returns the plan alone and cut_face keeps today's body, so the result is today's bit for bit.
  • Callers:
    • terrain (terrain/terrain.wgsl:122): drawn = drawn_normal(in.s), facet from d as today, own 0, rock 0, bare 0; pipeline PAINT: 1, FACES: the switch.
    • corridor (corridor_ground): drawn = drawn_normal(su), facet = render_normal(drawn), own 0, road = Road(0, 0, 0, 0, 1, 1 − bench, bench); pipeline PAINT: 0, FACES: 0. This is today's BAND path bit for bit.
    • pieces: below; pipeline PAINT: 0, FACES: 1.

terrain_facet(s) (new terrain/facet.wgsl)

mesh_height splits into mesh_triangle(s, snapping) -> Triangle { w: vec3f, s: array<vec2f, 3>, h: vec3f } and dot(w, h). terrain_facet(s) takes mesh_triangle(s, false), places its three vertices in render space as vertex_main does (to_render, h − frame.eye, the curvature term), and returns the oriented normal; where a height is unknown, it returns vec3f(0, 0, 1). It reads the terrain's own pages, never GP10's plan layer and never GP9's floor: GP10's hook stays in the function above mesh_triangle. The file needs frame; the terrain and the piece shaders include it.

The piece fragment branch

GP11 fills the PIECE branch of corridor_fragment (GP9). Order: GP10's fade test first; su = lod_space(in.u); d from dpdx/dpdy of relative, outside every branch; level = u32(ceil(lod(su))); mat = word & MAT_BITS.

  • MAT_GROUND, across < 0 (Ground(Terrain): terrain faces and the strip): GroundShape(drawn_normal(su), terrain_facet(su), 0, NO_ROAD, 0, 0). These faces lie outside every non-terrain face, where height_at is T, and the pages hold the same function (GP8), so the page there is T. Such a pixel has the terrain's normal, facet and mask; only footprint and surface_size come from the mesh's own derivatives, and they set the detail fade alone.
  • MAT_GROUND, across ≥ 0 (slope, verge, bank, bed, seat), with t = across and bench = half < PATH_HALF_M: drawn = normalize(in.normal) (the height function's normal), facet from d (the face's own triangle), own = t, road = Road(0, 0, 0, 0, t, t(1 − bench), t · bench). Where t is 0 the face is lit as the terrain, with its own skirt; the skirt fades by road.shaped as on a road cut today. The steep share q = t · (1 − smoothstep(0.66, 0.75, render_normal(drawn).z)) (41° to 49°, A8's band) goes to rock or bare by the owner's choice.
  • Way materials (all but the four below): n = render_normal(normalize(in.normal)); WayPixel as corridor.wgsl:228-232; way_look(…, n.z, …); where l.ground > 0, mix ground_colour with GroundShape(normalize(in.normal), n, 1, Road(0, 0, 0, 0, 1, 1 − bench, bench), 0, 0); no discard (the floored terrain lies under the mesh). LOOK_GIVE_WAY reads along − GIVE_WAY_BACK_M. LOOK_LOG keeps log_lit.
  • MAT_WALK (walk_look in roads/looks.wgsl): with d = across and w = half: granite (slot_kerb, noise as MAT_KERB) for d < min(KERB_TOP_M, w), 10 % darker for d < 0.025 (the bevel); an edging stone (granite × 0.9) for d > w − EDGING_M where w ≥ KERB_TOP_M + EDGING_M + 0.1; paving() between; edges by band() over cw. KERB_TOP_M = 0.16, EDGING_M = 0.1 (roads/section.ts:38, :115-122).
  • MAT_WALL: along = the world axis nearer the wall's direction, world.y where |n.x| > |n.y|, else world.x, cross-faded within 6° of 45° by evaluating rubble twice, as the ground's masonry does; aw from that along's derivatives; way_look → detail_look → rubble.
  • MAT_CUT_WALL: the rubble of MAT_WALL where (1 − barren) · (1 − tree) (today's masonry rule, ground/look.wgsl:681), else ground_colour(…, GroundShape(normal, render normal, 1, Road(0, 0, 0, 0, 1, 0, 0), 1, 0)), the local cliff look in the wall's plane. barren = cell_at(su, level).a / 255, tree from ground_at.
  • MAT_KERB: way_look.
  • frame.debug == 1: the normal in colour, as the terrain does, so a jump at the strip shows.

Line rules of the paint: marked

Whether a line carries markings is a look rule: one function of the line's words (class rank, finish code), ported from today's marked (terrain/bins.ts:174). The production records hold no marked word (GP3R). The mesh (vertex_look) and GP8's B call the same rule, in Rust and WGSL, with a shared vector file.

Steep faces: the owner's choice

The implementer builds three variants of q's target (STEEP_LOOK override, for the comparison only): 0 none (the ground's own look in the face's plane), 1 bare, 2 rock. The owner picks from the pictures. The pull request keeps only the chosen branch and deletes the override before merge.

Debug view facet

DEBUG_VIEWS gains facet (index 12, after GP9's owned). On the terrain: grey, red where the angle between terrain_facet(in.s) and the facet from d exceeds 1°. shoot.mjs counts red pixels for debug=facet as it does for debug=cracks.

Interfaces with the other items

  • GP1, GP3, GP5 give the reader, PlanRules and the request; GP11 adds traffic, marks, walls and place.
  • GP3 gives the band builder, corner and tip fills with arcs and tangent points, the material way of each junction face, the sliver function and the mouth kinds.
  • GP4 gives Marking::Zebra, d and w(s); GP11 draws the stripes, the kerb top and the edging stone.
  • GP3R gives the records' lines; GP11 owns the line rules of the paint (marked).
  • GP4 gives band ownership when it lands: a band face takes the material of the way that GP4's ownership gives. Until then the current rule stays (a band face takes the way of its nearest chain).
  • GP6 gives height_at and the named steps; GP11 changes no height.
  • GP7 gives the mesh and mesh/look.rs; GP11 extends that module, its constraint list (part borders) and its vertex emission (vertex_look, twins), and replaces the rules listed above.
  • GP8 gives model_ground and B's paint fields; GP8's B writes the dirt mouths and the shoulder share by GP11's rules, so near and far paint by one rule. The terrain branch relies on GP8's pages holding height_at.
  • GP9 gives the piece pipeline, vertex stage, fade and PIECE branch; GP11 needs the varyings normal (LOD axes), relative, altitude, word, road, along, u, and adds the missing ones.
  • GP10 hooks the plan layer above mesh_triangle, terrain_facet below it; the second of the two to merge rebases terrain/drawn-mesh.wgsl.
  • GP12, GP14, GP15 take the surface table, walls and the Vertical rule, and add their own names (concrete).
  • GP13 takes the rail bed frame: sleepers lie at whole along counts (stroke metres / 0.6), so near sleepers and the far paint agree.
  • GP16 takes the walls for caps; GP16 and GP17 read traffic too.

Edge cases

  • Cell and tile borders: both cells take each element from its owner tile (GP1), so frames agree; GP7's base is per piece, so check 2 compares along modulo 720. Where the owner tile changes, stroke metres can jump by up to 10 cm (GP1), so a dash or sett row shifts by ≤ 10 cm.
  • Joint: default parts only.
  • Roundabout: the ring is the host; each asphalt arm gives way; the ring's inner edge has no gap.
  • Crossroads: gaps on both sides of the host; two give-way parts.
  • Two hosts on two strokes: Plain takes the first host; the second keeps its frame in its own face.
  • Close junctions in one blend face: strips and give-ways by priority (GP3's, then junction id, then way id); plain parts split by bisector only where the first hosts' strokes differ.
  • Acute guest (10°): the sine is capped at 0.3, so along grows at most 3.3 times as fast as the distance from the host's edge; the paint is shorter along the guest, and the triangle stays in the lane; the long thin corner on the acute side merges into the give-way part by the sliver rule.
  • Short guest: no give-way; counted.
  • Zebra at a mouth: the zebra wins; no give-way part enters a zebra face.
  • Track or path into a road (stop): no host gap, no give-way; the strip keeps its look to the seam.
  • Soil ways at a junction: fills of a soil lesser arm and plain parts of a soil host are ground; a guest strip frays into a ground fill.
  • Bend tighter than the carriageway: BendBlend; the inner edge line follows the arc; the centre line stays in the legs.
  • Dead end: Radial.
  • Frame out of the field: across clamps to ±15.9 m, half to 12.7 m; along stays in GP7's field by the base; a clamp is counted, a NaN fails a hard check.
  • Lowered kerb, taper, ring with r < w: walk_look reads d and w only; a narrow slab is granite.
  • Level-17 pieces, strip at morph 1: level from lod(su).
  • A part that cannot fit (gap, strip, fill, give-way) is left out and counted; the face keeps its default part, which is always valid.

Plan

Commit series, in order; each has its own proof:

  • A (viewer, old path): steps 9 to 11. Proof: the old path's byte-identical shots, face.test.js, debug=facet.
  • B (crate and piece looks): steps 1 to 8 and 12 to 14. Proof: the crate's checks, the looks and viewer pictures.
  • C (steep choice): step 15. Proof: the three variants.
  1. GP7's mesh/look.rs becomes mesh/look/mod.rs (GP7's port, the surface table, LookPart, FrameRule, ShapedRule, VertexLook, LookStats, pub fn look_parts(plan: &Plan, graph: &WayGraph, rules: &MarkRules) -> (Vec<LookPart>, LookStats), pub fn vertex_look(…)), with the GP7 rules above replaced.
  2. mesh/look/frames.rs: Stroke, Radial, BendBlend, Plain, GiveWay, Zebra, Walk, Ground.
  3. mesh/look/junctions.rs: host gaps, guest strips and their gaps, fills, give-way decision and parts, plain parts, bisector split, bend-tip gaps, priority, slivers.
  4. mesh/look/rules.rs and its WGSL twin: marked, the dirt mouth and the shoulder rule, with a vector file that both test.
  5. GP7's mesh: part borders into the constraint list; triangles to parts; vertex_look per corner; twins; vertical face words from walls.
  6. GP1's reader: MarkRules with marks and walls (GP3's PlanRules) and traffic by place; data/trailview/plan.json; data/trailview/regions/world.json; the rules check of planner/trailview-rules. GP5's Request, CellRequest, cellInputs and requests: place.
  7. The debug tool: layer looks (parts by rule, gaps and give-ways hatched, across contours at 0 and ±half, along stripes each metre); --stats prints LookStats.
  8. mesh/look/tests.rs (below).
  9. ground/face.wgsl: create from 58febe615. ground/look.wgsl: GroundShape, PAINT, FACES, the port, rock, bare.
  10. terrain/drawn-mesh.wgsl: mesh_triangle; terrain/facet.wgsl: create terrain_facet; terrain/terrain.wgsl: the caller and the facet view; terrain/terrain.ts: overrides; roads/corridor.wgsl: corridor_ground passes its shape; roads/roads.ts: PAINT: 0, FACES: 0.
  11. view.ts: facet; tests/browser/trailview/shoot.mjs: the red count for it; tests/browser/trailview/face.test.js: from 58febe615; road-views-top.json: i04-markings-top, t-mouth-close-top (as GP0).
  12. roads/looks.wgsl: MAT_WALK, walk_look, KERB_TOP_M, EDGING_M, GIVE_WAY_BACK_M; roads/details.wgsl: MAT_CUT_WALL; roads/section.ts: MAT.WALK = 4, MAT.CUT_WALL = 50.
  13. The PIECE branch of corridor_fragment and GP9's pipeline: the fragment branch, the varyings, PAINT: 0, FACES: 1.
  14. The pins of looks.test.ts.
  15. The steep comparison, the owner's choice, the removal of STEEP_LOOK.

Files

Crate (host/obc-ground-plan/src/): mesh/look/{mod,frames,junctions,rules,tests}.rs (change GP7's mesh/look.rs into this module), GP7's mesh module, GP1's rule reader and its test, the debug tool: change. GP5's transport module, the bridge's CellRequest: change. Data: data/trailview/plan.json (marks, walls), data/trailview/regions/world.json (traffic): change; the rules check of planner/trailview-rules: change.
Viewer (builder/web/src/lib/trailview/): ground/face.wgsl, terrain/facet.wgsl: create. ground/look.wgsl, terrain/drawn-mesh.wgsl, terrain/terrain.wgsl, terrain/terrain.ts, roads/corridor.wgsl, roads/roads.ts, roads/looks.wgsl, roads/details.wgsl, roads/section.ts, GP9's piece pipeline file, GP5's Plan module (cellInputs), view.ts, roads/looks.test.ts (or the nearest looks test): change. builder/web/tests/browser/trailview/shoot.mjs, road-views-top.json: change; face.test.js: create (port).

Verification

  • Checks:
    • obc test -p obc-ground-plan: the unit tests of mesh/look/tests.rs, one per case: a straight road (one Stroke part, across left positive, along the stroke metres less GP7's base); a T of residential into primary (host gap exactly between the fill tangent points on the guest's side, none on the far side; guest gaps from the seam to its tangent points; fills of the lesser arm's look; a give-way part from the host edge to 4.6 m, across 0 on the guest's middle, half = half_g); the same at 60° and at 20° (along constant on lines parallel to the host's edge; the triangle's middle, across = half/2, on the lane's middle at every along; every part ≥ min_width_m); the same junction with the place gb (side flips, the triangle in the other lane; es-ga resolves to *); same class (no give-way); a roundabout arm (give-way); a one-way that leaves (none); a track into a road (no gap, no give-way, a Stroke strip of the track to the seam, a fill in the track's surface); a guest of 3 m (none, counted); a dead end (Radial meets Stroke at the end); a hairpin tip (along equals Stroke on the owner edges; the points with |across| = half − 0.3 lie 0.3 m from the arc; no leg point between the tangent points has an edge line); a zebra 1.5 m off the middle (across 0 on the middle line); ground rules (−1 on terrain and strip, 0 where the slope meets the terrain, 1 on a verge); twins (same position and height bits); a dirt mouth (the lesser way's material past the host's carriageway); a lined and an unlined shoulder; marked against the vector file.
    • The fixture checks of section 14 with GP11's parts: check 1 also over the parts of each face (a partition, none under min_width_m); check 2 with the look attributes (along modulo 720); check 4 with the part constraints. A new hard check look_frames (target 0): a NaN or an out-of-field across, along or half; a give-way part on a soil or non-asphalt guest; a host gap on a stop or join mouth.
    • obc exec cargo clippy -p obc-ground-plan --all-targets -- -D warnings; cargo fmt --all.
    • In builder/web: npx vitest run src/lib/trailview with pins: KERB_TOP_M equals every kerb width of the table; SHOULDER_MAIN_M and SHOULDER_ROAD_M equal the table's shoulders of the classes of their codes; the MAT and LOOK ids of roads/section.ts equal the crate's (the test reads the Rust source); give_way_reach_m covers the look's line and triangle; TIP_EDGE_M is over the widest inside term of markings. npm run check; npm run check:wgsl.
    • obc test affected --base origin/ground-plan (the TrailView suite with face.test.js: plan bit for bit to 30°, density ratio ≥ 1/1.6 on 60° and 75° faces); obc suites check.
    • Old path unchanged: shoot all views of both view files without the switch twice on GP11's base and once on its head; each view whose two base shots are byte-identical (cmp) is byte-identical on the head; the rest go on the slider page.
    • shoot.mjs --gpu --views (both files with &ground=plan&debug=facet appended by jq) prints redPixels: 0 for every view.
  • Measurements (GTX 1660 SUPER, clock held, flock /tmp/trailview-gpu.lock):
    • Frame: flight.mjs --gpu walk and drive with &ground=plan, three runs each, base and head: median and p95 per pass, pieces and terrain apart. Gate: the epic's frame budget (section 15) against GP0's record. Report the share of terrain_facet (an adjacent pair with it replaced by facet = render_normal(drawn)) and of the face projection (FACES 0 and 1).
    • The crate's --stats over the fixture, base and head. Gate: the epic's pools (section 15) hold over each flight.
    • Native cell build time, median and p95 per cell, base and head. Gate: GP7's gates as the owner set them.
  • Pictures: shoot.mjs --gpu --width 1920 --height 960 of both view files, with the switch on GP11's base and head and without it, on one slider page; the implementer looks at each at 2×. The owner looks in particular for:
    • main-road-eye, residential-curve-eye, residential-night: smooth light, no facets; lines as on develop; kerb face, kerb top, edging stone, paving.
    • sett-eye, gravel-eye, dirt-eye, grass-eye, trail-eye, footway-eye, cycleway-eye, alpine-trail-eye: looks as on develop; no line at a face edge.
    • i04-markings, t-mouth-close, junction0-eye, t-tertiary-eye, x-tertiary-eye, j-tt-a, v07-good-junction, v11-two-bad-junctions, v12-good-town-junctions and their -top views: host lines run through; edge lines break only at reach mouths and between the fills' tangent points; a guest's lines stop where its fills start; give-way lines parallel to the host's edge, the triangle in the stopping lane; no line across a track or path mouth, the track's ruts to the seam; sett rows run on through a town junction.
    • zebra-tagged, crossing-close: stripes straight, centred, clear of both kerbs.
    • i01-wall-cap, v04-wall-road-junction, i07-road-up-wall: rubble on fill walls, rock on cuts in bare rock or woodland, stones not stretched.
    • i09-shading, hp-eye, d-hairpin-eye, i07-hairpin-eye: no facets; inner edge lines follow the arcs.
    • path-edge-eye, path-edge-handover: the bench as on develop; no tone seam at the strip or a slope's edge.
    • Steep set, three variants side by side: d-hairpin-15m, side-eye, i07-road-up-wall, worst3, conn-steep-ramp-eye, path-on-cut, v05-slope-artifact, and the cliffs behind trail-eye and alpine-trail-eye: no stretched streaks; ground, earth or rock.
    • debug=1 at v12-good-town-junctions, path-edge-eye: no normal jump at the strip.
    • The debug tool's layer looks at t-tertiary, x-tertiary, junction0, j-tt-a, v07 to v12, zebra-tagged, crossing-close, i07-hairpin, d-hairpin, hp: every part and frame, before and after.

Done when

  • Every check above passes; look_frames and checks 1, 2 and 4 hold at 0 over the fixture.
  • The old path's shots are unchanged as stated.
  • redPixels of debug=facet is 0 for every view.
  • The frame, pool and build-time gates hold, and the pull request has the numbers.
  • The owner chose the steep look; only that branch remains, and STEEP_LOOK is gone.
  • The slider page and the looks pictures are in the pull request; the implementer looked at each.
  • TrailView A8: steep faces without stretched texture #3092 has a comment that GP11 carries its work, with the link to the pull request.

Out of scope

  • The range fade, the far-stamp handover, plan-layer reads, plants off water: GP10.
  • Deck, slab, parapet, abutment and portal looks: GP12. Rails, sleepers, steps, platform edges, level-crossing gear: GP13. Water beds, banks and surfaces: GP14. Headwalls and pipes: GP15. Caps, railings, guardrails: GP16.
  • Faces, heights, mesh: GP3, GP4, GP6, GP7. Ownership, casters, pools: GP9.
  • traffic for sidewalk corners, lamps, posts: GP3, GP16, GP17.
  • A material input to ground_colour for the shore band (TrailView C4: a band of shore along lakes and ponds #3048): the follow-up after GP14 adds it to GroundShape.
  • Docs: GP19.

Questions for the owner

Owner decision: every recommendation in this section is accepted.

  1. Steep slope faces (41° to 49° and steeper): the ground's own look, bare earth (rock where barren), or rock? Recommendation: bare earth, rock where barren: grass does not hold past about 50° (today's cut_face rule), and a rock face on a 45° fill reads as a cliff.
  2. Epic note: GP11 adds no concrete look; GP12 and GP15 add concrete names to walls for portals, deck edges and headwalls.
  3. Epic note: GP11 adds Plan.looks (look parts) beside Face. The epic's table of types has no place for a frame that changes inside one face, and a face split would add labels that the records do not hold.
  4. Epic note: terrain faces and the strip pass the terrain's values; slope faces pass their own (the pages under a slope band hold height_at, not T), and debug=1 shows where they differ.
  5. Cut walls keep today's rule: rock in bare rock and woodland, rubble elsewhere, unless the pictures say otherwise.

Review notes

  • Kept: one pull request for the three series (the epic's rule); each has its own proof.

Activity

  1. timohueser commented on Nov 4, 2026

    @timohueser
    OwnerAuthor

    Deviation from GP4 (#3099, redesigned): what GP11 gets

    • Zebras: there is no Face.marking. A zebra is a face with Surface::Zebra (code 10). Its material is the holder way, also where the zebra lies inside a junction face. GP11 draws the stripes across the holder's tangent at the face.
    • Kerb and edging stone:
      • The kerb stone runs along the Kerb edges, with kerb_top_m from the class. FacePlan.kerbs gives the rise R and step height F along each edge; F < R where the kerb is lowered.
      • The edging stone runs along the sidewalk's back edges: sidewalk edges against shoulder, verge, slope or terrain.
      • Sidewalk faces have Surface::Sidewalk (code 9).
      • A taper ends with round corners and runs tangentially into the kerb.

    Generated by Claude Code

  2. timohueser commented on Nov 5, 2026

    @timohueser
    OwnerAuthor

    Note: the owner's decisions of 2026-11-05 that touch GP11. This note does not change the body. The decisions: #3096 (comment); the round's proposal: #3096 (comment) (GP11 row: keep, edit). Evidence on timosPC under /media/timo/OSM1/tmp/ground-plan/one-model/shapes/ (owner1/, owner2/, mouth/, bands/).

    • One road model. The look parts and their frames come from the label's host lines and the line rules in the records (GP3R, "the records of a cell", being filed). GP8's far look (B) computes the same fields, so near and far paint by one rule. The ground terms are one function for every look (model_ground, GP8 draft section 2); GP11's ground faces call the same rule. The pages under a slope band now hold height_at (GP8), not the approved far stamp, so the rejected item "inside a slope band the pages hold GP8's far stamp, not T" changes its reason; terrain faces and the strip still pass the terrain's own values.
    • Dirt mouths: yes. Rule (owner1/ 1, prototype aa956ed): past the carriageways of its own lines, a face wears the material of its nearest other line. GP11 paints it on the mesh, and GP8 writes the mouth's finish into B's paint texture, so the hand-over shows one mouth.
    • Shoulder paint as develop: yes. Dusty asphalt on a paved shoulder, else gravel. A paved shoulder is dustier only by the share that an edge line divides it from the carriageway (owner1/ 4a, model_lined_shoulder): round a corner whose arms do not both wear lines, the two asphalts are one. The width comes from the band record of its way, not from the fixed 0.6 m and 0.4 m of roads/looks.wgsl.
    • Shaped zone of the cut-face look: (c) the look ends where the heights moved the ground, and also takes develop's distance (owner2/): shaped = max(near, moved); near = 1 − smoothstep(0.75 · shaped_m, shaped_m, core distance), shaped_m 10 m for a road and 3 m for a path; moved = smoothstep(0.05 m, 0.15 m) of |h − T| (MOVED_M = 0.1 m). This replaces the body's share clamp(|h − T(p)| / SHAPED_RAMP_M, 0, 1) with 0.05 m. On the mesh, h and T are known at each vertex. Open (owner2/ "Still wrong"): a texel stair where a road's 10 m and a path's 3 m meet, because the reach is a select by the half-width; a reach that is a smooth function of the half-width is the proposed fix.
    • Band ownership: (a) one band candidate per way and layer, decided like the carriageways (ground-plan: a junction guest wider than every other arm tapers into them (GP3 follow-ups) #3134). A band face's material line is its way, so its look follows that way.
    • Owner rules kept from the round: one asphalt colour; a junction face takes the material of its highest-class arm; the step between a railway and a road is a retaining wall (GP6's named step RailRoad gives it its look).
    • The owner's reshoot notes: the corner band at x-tertiary-eye and valley-junction was the paint (fixed in the prototype by the shoulder rule above); the kink there is open (heights or GP3).

    Generated by Claude Code

  3. timohueser commented on Nov 6, 2026

    @timohueser
    OwnerAuthor

    Note from GP8 (PR #3161, merged): the far look B has no mouths, no shoulder paint and no retaining walls (there is no WALL flag on the new path). Details: #3102 comment 6671786112.


    Generated by Claude Code

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Labels

    No labels
    No labels

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions