@3driseai/3drise-viewer 0.1.41 → 0.1.43

package/dist/components/urban/core/streetGrid.js

@@ -0,0 +1,422 @@
+// Emitted from Claude outputs/urban-lab/streetGrid.mjs by emit_object.mjs — edit the lab module and re-emit.
+// =============================================================================
+// urban/streetGrid — a whole street grid in one object: junctions, roads, lamps, traffic
+// =============================================================================
+// A layout preset over `road`, `junction` and `traffic`, the way `block` is one over
+// `building`: columns x rows of nodes `pitch` metres apart; every inner node a cross
+// junction, the edge nodes tees facing in and the corners rounded roads (edge 'loop'), or
+// crosses everywhere with short stub arms (edge 'open'); a road between every pair of
+// neighbouring nodes, ending at the junction arms so nothing overlaps; traffic along every
+// avenue and street. The pieces are the road / junction / traffic cores themselves (their
+// shaders, their lamp registration, their chunks), built as children of one group, so one
+// grid is ONE object in the scene tree and a block fills each cell. The road, junction and
+// traffic objects stay for one-off streets (a boulevard, a single T).
+import * as THREE from 'three';
+import * as ROAD from './road.js';
+import * as JUNCTION from './junction.js';
+import { junctionReach } from './junction.js';
+import * as TRAFFIC from './traffic.js';
+import { mergeByMaterial, createLampField, attachLampField, createPavingUniforms, createPavingMaterial, loadTextureSet, applyTextureSet } from '../urbanCore.js';
+import { validateGridLayout, gridLayoutPlan, gridStreetPoints, gridCornerPoints, gridRoundaboutRadius, gridGroundPolygons } from '@3driseai/3drise-core';
+export const EDGES = ['loop', 'open'];
+export const LIGHTING = ['auto', 'day', 'night'];
+export const STRUCTURAL = ['layout', 'groundTexture', 'groundTextures', 'lanes', 'laneWidth', 'armLength', 'cornerRadius', 'signals', 'texture', 'sidewalk', 'kerbHeight', 'sidewalkTexture', 'lamps', 'lampSpacing', 'lampHeight', 'traffic', 'showCars', 'seed'];
+// ---------------------------------------------------------------------------- the child configs
+/** The road knobs of a grid config (points added per segment). */
+function roadCfg(c, points, curve = 0) {
+    // Every knob the road core reads, so no defaults table is needed here (the repo copy has none).
+    return {
+        type: 'road', enabled: true, points, curve, lanes: c.lanes, laneWidth: c.laneWidth,
+        markings: 'dashed', laneLines: true, edgeLines: true, crosswalks: false, lampSide: 'alternate',
+        markingColor: c.markingColor, asphaltColor: c.asphaltColor, wear: c.wear, texture: c.texture,
+        sidewalk: c.sidewalk, kerbHeight: c.kerbHeight, sidewalkColor: c.sidewalkColor, sidewalkTexture: c.sidewalkTexture,
+        lampSpacing: c.lamps ? c.lampSpacing : 0, lampHeight: c.lampHeight, lampPaint: c.lampPaint, lampColor: c.lampColor, lampRadius: c.lampRadius, lampIntensity: c.lampIntensity,
+        lighting: c.lighting, seed: c.seed,
+    };
+}
+function junctionCfg(c, shape, islandRadius = 10) {
+    return {
+        type: 'junction', enabled: true, shape, islandRadius, signalHeight: 4.5, lanes: c.lanes, laneWidth: c.laneWidth, armLength: c.armLength, cornerRadius: c.cornerRadius, crossings: c.crossings,
+        markingColor: c.markingColor, asphaltColor: c.asphaltColor, wear: c.wear, texture: c.texture,
+        sidewalk: c.sidewalk > 0.05, kerbHeight: c.kerbHeight, sidewalkColor: c.sidewalkColor, sidewalkTexture: c.sidewalkTexture,
+        signals: c.signals, signalCycle: c.signalCycle, signalPaint: c.signalPaint,
+        lamps: c.lamps, lampHeight: c.lampHeight, lampPaint: c.lampPaint, lampColor: c.lampColor, lampRadius: c.lampRadius, lampIntensity: c.lampIntensity,
+        lighting: c.lighting, seed: c.seed,
+    };
+}
+function trafficCfg(c, points, curve = 0, lanes = c.lanes) {
+    return { type: 'traffic', enabled: true, points, curve, lanes, laneWidth: c.laneWidth, density: c.traffic, speed: c.speed, jitter: 0.5, headlightColor: '#fff2d6', taillightColor: '#ff2a1a', intensity: 1, size: 1, showCars: c.showCars, lighting: c.lighting, seed: c.seed };
+}
+/**
+ * The pieces of the grid from its layout (config.layout, the GridLayout that `layoutId` names —
+ * the component resolves it; none yet = nothing to build): { junctions: [{ x, z, shape, ry }],
+ * roads: [{ points, curve }], traffic: [{ points, curve }], grounds (core gridGroundPolygons), extent }. Where a street is comes from core's gridLayoutPlan
+ * (the same function the GridCreator editor draws with); this only decides how to build it:
+ *   - a node where 3 or 4 streets meet is a junction (a T turns its missing arm away);
+ *   - streets chain through nodes where 2 meet: straight on, or round a corner (a smooth turn
+ *     of up to 60 m radius), and a road runs from junction arm end to junction arm end;
+ *   - a street's bend bulges only between the arm ends, so the junction arms stay straight;
+ *   - traffic runs straight through junctions and round corners (the outer loop is one stream).
+ * In 'open' mode a border node also has a stub arm pointing out of the grid — core's plan gives it (GridNode.stubs, in arms / degree).
+ */
+export function gridPlan(c) {
+    const layout = c.layout ? validateGridLayout(c.layout).layout : null;
+    if (!layout)
+        return { junctions: [], roads: [], traffic: [], grounds: [], extent: { w: 0, d: 0 }, layout: null };
+    const P = gridLayoutPlan(layout);
+    const nc = layout.columns.length, nr = layout.rows.length;
+    const A = (Math.max(1, Math.round(c.lanes)) * c.laneWidth) / 2 + c.armLength; // junction arm end from its centre
+    const junctions = [], roads = [], traffic = [];
+    // Streets by node and side.
+    const side = new Map();
+    const at = (id) => { let v = side.get(id); if (!v)
+        side.set(id, (v = {})); return v; };
+    for (const st of P.streets) {
+        at(st.from)[st.axis === 'x' ? 'e' : 's'] = st;
+        at(st.to)[st.axis === 'x' ? 'w' : 'n'] = st;
+    }
+    const nodeOf = new Map(P.nodes.map((n) => [n.id, n]));
+    // node id -> how far its junction reaches along each arm (a crossing: A; a roundabout: island + ring + arm)
+    const reach = new Map(), roundabouts = [], cornerR = new Map();
+    for (const n of P.nodes) {
+        if (n.degree === 0)
+            continue;
+        const arms = { ...n.arms };
+        const k = (arms.n ? 1 : 0) + (arms.s ? 1 : 0) + (arms.e ? 1 : 0) + (arms.w ? 1 : 0);
+        if (k >= 3) {
+            // Tee default: bar along x, stem +z, no -z arm; turn the missing arm to where nothing comes in.
+            const ry = k === 4 ? 0 : !arms.n ? 0 : !arms.s ? Math.PI : !arms.e ? -Math.PI / 2 : Math.PI / 2;
+            const round = n.junction && n.junction.kind === 'roundabout';
+            const island = round ? gridRoundaboutRadius(n.junction) : 10;
+            const shape = round ? (k === 4 ? 'roundabout' : 'roundabout3') : (k === 4 ? 'cross' : 'tee');
+            junctions.push({ x: n.x, z: n.z, shape, ry, island });
+            reach.set(n.id, junctionReach(junctionCfg(c, shape, island)));
+            if (round)
+                roundabouts.push({ x: n.x, z: n.z, island });
+        }
+        else if (n.turn)
+            cornerR.set(n.id, n.cornerRadius); // core decides the radius (layout.corners or automatic)
+    }
+    const isJunction = { has: (id) => reach.has(id) };
+    const isRoundabout = new Set(roundabouts.map((r) => `${r.x},${r.z}`));
+    const roundAt = (id) => { const n = nodeOf.get(id); return isRoundabout.has(`${n.x},${n.z}`); };
+    const trim = (id) => reach.get(id) ?? cornerR.get(id) ?? 0;
+    const passes = (id) => !isJunction.has(id) && nodeOf.get(id).degree === 2;
+    // A street's points from node `fromId` (reversed when it runs the other way).
+    const pts = (st, fromId) => {
+        const p = gridStreetPoints(st, trim(st.from), trim(st.to));
+        return st.from === fromId ? p : p.reverse();
+    };
+    const other = (st, id) => (st.from === id ? st.to : st.from);
+    // Walk from street `st` leaving node `id`, following `next(node, cameFrom)`; returns [{ st, from }] and whether it closed.
+    const walk = (st0, id0, next, seen) => {
+        const list = [{ st: st0, from: id0 }];
+        seen.add(st0.id);
+        let st = st0, id = other(st0, id0);
+        for (;;) {
+            if (id === id0)
+                return { list, closed: true };
+            const nx = next(id, st);
+            if (!nx || seen.has(nx.id))
+                return { list, closed: false };
+            seen.add(nx.id);
+            list.push({ st: nx, from: id });
+            st = nx;
+            id = other(nx, id);
+        }
+    };
+    const chainPoints = (list, closed, keepNodes) => {
+        const out = [];
+        const push = (q) => { const l = out[out.length - 1]; if (!l || Math.hypot(l[0] - q[0], l[1] - q[1]) > 0.05)
+            out.push(q); };
+        for (let k = 0; k < list.length; k++) {
+            const { st, from } = list[k];
+            const p = pts(st, from), to = other(st, from);
+            // Drop the node points where the street is trimmed (junction arm / corner), unless traffic keeps the centre.
+            // Traffic keeps a crossing's centre (it drives straight through) but not a roundabout's (it goes round).
+            const cutStart = trim(from) > 0 && !(keepNodes && isJunction.has(from) && !roundAt(from));
+            const cutEnd = trim(to) > 0 && !(keepNodes && isJunction.has(to) && !roundAt(to));
+            const body = p.slice(cutStart ? 1 : 0, cutEnd ? p.length - 1 : p.length);
+            for (const q of body)
+                push(q);
+            // A corner after this street (a chain or loop continues): a quadratic turn through the node.
+            const nextItem = list[k + 1] || (closed ? list[0] : null);
+            if (nextItem && cornerR.has(to)) {
+                // the curving API's corner round (core curveCornerPoints, 10 steps on grids)
+                const n = nodeOf.get(to), q0 = out[out.length - 1], q2 = pts(nextItem.st, to)[1];
+                const round = gridCornerPoints(q0, [n.x, n.z], q2);
+                for (let t = 1; t < round.length - 1; t++)
+                    push(round[t]);
+            }
+        }
+        if (closed && out.length > 1)
+            push(out[0]);
+        return out;
+    };
+    // Roads: chains between junctions / dead ends, through straight and corner nodes.
+    const seenR = new Set();
+    for (const st of P.streets) {
+        if (seenR.has(st.id))
+            continue;
+        const nextR = (id, came) => { const v = side.get(id); return passes(id) ? [v.n, v.s, v.e, v.w].find((s2) => s2 && s2 !== came) : null; };
+        const fwd = walk(st, st.from, nextR, seenR);
+        let list = fwd.list, closed = fwd.closed;
+        if (!closed) {
+            const back = walk(st, st.to, nextR, new Set([...seenR].filter((id) => id !== st.id)));
+            for (const b of back.list)
+                seenR.add(b.st.id);
+            // back runs st -> backwards; flip it to come before st (each street then runs the other way).
+            const before = back.list.slice(1).reverse().map(({ st: s2, from }) => ({ st: s2, from: other(s2, from) }));
+            list = [...before, ...list];
+        }
+        const points = chainPoints(list, closed, false);
+        let len = 0;
+        for (let k = 1; k < points.length; k++)
+            len += Math.hypot(points[k][0] - points[k - 1][0], points[k][1] - points[k - 1][1]);
+        if (len > 2)
+            roads.push({ points, curve: 0 });
+    }
+    // Traffic: straight through junctions, round corners.
+    if (c.traffic > 0.01) {
+        const seenT = new Set();
+        const straight = (id, came) => {
+            if (roundAt(id))
+                return null; // a stream ends at a roundabout's arm; the ring has its own stream
+            const v = side.get(id) || {};
+            const ahead = came.axis === 'x' ? (v.e === came ? v.w : v.e) : (v.s === came ? v.n : v.s);
+            if (ahead)
+                return ahead;
+            return passes(id) ? [v.n, v.s, v.e, v.w].find((s2) => s2 && s2 !== came) : null;
+        };
+        for (const st of P.streets) {
+            if (seenT.has(st.id))
+                continue;
+            const fwd = walk(st, st.from, straight, seenT);
+            let list = fwd.list, closed = fwd.closed;
+            if (!closed) {
+                const back = walk(st, st.to, straight, new Set([...seenT].filter((id) => id !== st.id)));
+                for (const b of back.list)
+                    seenT.add(b.st.id);
+                const before = back.list.slice(1).reverse().map(({ st: s2, from }) => ({ st: s2, from: other(s2, from) }));
+                list = [...before, ...list];
+            }
+            const points = chainPoints(list, closed, true);
+            if (closed && points.length > 2)
+                points.push(points[1]); // close the loop for the stream (as the old ring did)
+            if (points.length > 1)
+                traffic.push({ points, curve: 0 });
+        }
+        // Each roundabout: one lane of traffic going round (anticlockwise seen from above: the path runs
+        // clockwise, a single-lane stream drives it backwards — see traffic.carInstances).
+        for (const r of roundabouts) {
+            const rc = r.island + (Math.max(1, Math.round(c.lanes)) * c.laneWidth) / 2, n = 48, points = [];
+            for (let k = 0; k <= n + 1; k++) {
+                const a = (k / n) * Math.PI * 2;
+                points.push([r.x + Math.cos(a) * rc, r.z + Math.sin(a) * rc]);
+            }
+            traffic.push({ points, curve: 0, lanes: 1 });
+        }
+    }
+    return { junctions, roads, traffic, grounds: gridGroundPolygons(P), extent: { w: P.width, d: P.depth }, layout };
+}
+// ---------------------------------------------------------------------------- grounds
+/** How far a ground sits under the street surface (metres), so the asphalt and pavements cover it. */
+const GROUND_DROP = 0.04;
+const insideXZ = (ring, p) => {
+    let inside = false;
+    for (let k = 0, l = ring.length - 1; k < ring.length; l = k++) {
+        const a = ring[k], b = ring[l];
+        if ((a[2] > p[2]) !== (b[2] > p[2]) && p[0] < ((b[0] - a[0]) * (p[2] - a[2])) / (b[2] - a[2]) + a[0])
+            inside = !inside;
+    }
+    return inside;
+};
+/**
+ * A ground's plane from its outlines (core gridGroundPolygons): each outline triangulated seen
+ * from above with the holes inside it, at the outline's heights; aUV = metres (the paving material).
+ */
+export function groundGeometry(shape) {
+    const outers = shape.outlines.filter((o) => !o.hole), holes = shape.outlines.filter((o) => o.hole);
+    const pos = [], uv = [], idx = [];
+    for (const o of outers) {
+        const rings = [o.points, ...holes.filter((h) => insideXZ(o.points, h.points[0])).map((h) => h.points)];
+        const v2 = rings.map((r) => r.map((p) => new THREE.Vector2(p[0], p[2])));
+        const tris = THREE.ShapeUtils.triangulateShape(v2[0], v2.slice(1));
+        const base = pos.length / 3;
+        for (const r of rings)
+            for (const p of r) {
+                pos.push(p[0], p[1] - GROUND_DROP, p[2]);
+                uv.push(p[0], p[2]);
+            }
+        for (const t of tris)
+            idx.push(base + t[0], base + t[1], base + t[2]);
+    }
+    const g = new THREE.BufferGeometry();
+    g.setAttribute('position', new THREE.Float32BufferAttribute(pos, 3));
+    g.setAttribute('aUV', new THREE.Float32BufferAttribute(uv, 2));
+    // face up: ShapeUtils winds by the 2D (x, z) frame, which is upside down seen from +y
+    if (idx.length >= 3) {
+        const P = (i) => new THREE.Vector3(pos[i * 3], pos[i * 3 + 1], pos[i * 3 + 2]);
+        const n = new THREE.Vector3().subVectors(P(idx[1]), P(idx[0])).cross(new THREE.Vector3().subVectors(P(idx[2]), P(idx[0])));
+        if (n.y < 0)
+            for (let k = 0; k < idx.length; k += 3) {
+                const t = idx[k + 1];
+                idx[k + 1] = idx[k + 2];
+                idx[k + 2] = t;
+            }
+    }
+    g.setIndex(idx);
+    g.computeVertexNormals();
+    return g;
+}
+/** One ground as a piece of the grid: its own paving material (its texture set in its own colours, or a lawn in groundColor), lit by the grid's lamp field. */
+function buildGround(shape, cfg, field) {
+    const u = createPavingUniforms(), mat = createPavingMaterial(u);
+    const ref = (cfg.groundTextures && cfg.groundTextures[shape.id]) || cfg.groundTexture;
+    const maps = ref && ref.maps;
+    const lawn = !(maps && maps.color);
+    u.uGrassMix.value = lawn ? 1 : 0;
+    if (lawn && cfg.groundColor !== undefined)
+        u.uPavColor.value.set(cfg.groundColor);
+    let alive = true;
+    // a texture shows in its own colours (the colour is its mean: albedo = colour × texture / mean)
+    if (!lawn)
+        loadTextureSet(maps).ready.then((t) => { if (!alive)
+            return; applyTextureSet(u, 'uPav', t, ref.tileSize, 0.8); u.uPavColor.value.copy(t.mean); });
+    attachLampField(u, field);
+    const mesh = new THREE.Mesh(groundGeometry(shape), mat);
+    mesh.receiveShadow = true;
+    mesh.name = `ground ${shape.id}`;
+    return {
+        object: mesh, materials: [mat], uniformSets: [u],
+        apply(live) { if (lawn && live.groundColor !== undefined)
+            u.uPavColor.value.set(live.groundColor); },
+        update() { },
+        bounds() { mesh.geometry.computeBoundingBox(); return mesh.geometry.boundingBox.clone(); },
+        dispose() { alive = false; mesh.geometry.dispose(); mat.dispose(); },
+    };
+}
+export function createUniforms() { return ROAD.createUniforms(); }
+export function applyConfig(u, c, tex = undefined) { ROAD.applyConfig(u, roadCfg(c, [[0, 0], [1, 0]]), tex); }
+// ---------------------------------------------------------------------------- lab build
+export function build(u, c) {
+    const group = new THREE.Group();
+    const uJ = JUNCTION.createUniforms();
+    const uT = TRAFFIC.createUniforms();
+    let kids = []; // { inst, kind, pos }
+    // The pieces are built by the road / junction cores, then MERGED by material: every junction
+    // asphalt into one mesh, every pavement into one, every lamp into one InstancedMesh… (≈ 215
+    // meshes -> ≈ 12). A merged mesh draws with the first piece's material; the pieces' knob
+    // uniforms all receive the same config, so any piece's material stands for all of them
+    // (a per-piece difference must live in a vertex attribute — the junction's aTee). The merged
+    // surfaces are lit by one baked lamp field (common.mjs) instead of 48-lamp lists per piece.
+    // The pieces' own objects stay in the group, empty, so their lamp registry entries follow
+    // the grid's transform as before.
+    const field = createLampField();
+    attachLampField(uT, field); // the traffic's cars are lit by the grid's lamps too
+    let merged = [];
+    const unmerge = () => { for (const m of merged) {
+        group.remove(m);
+        m.geometry.dispose();
+    } merged = []; };
+    const clear = () => { unmerge(); for (const k of kids) {
+        group.remove(k.inst.object);
+        k.inst.dispose();
+    } kids = []; };
+    // grounds stay out of the merge: each has its own texture (a merged mesh draws with ONE material)
+    const merge = () => { unmerge(); merged = mergeByMaterial(group, kids.filter((k) => k.kind !== 'traffic' && k.kind !== 'ground').map((k) => k.inst.object), field); };
+    const rebuild = (cfg) => {
+        clear();
+        const plan = gridPlan(cfg);
+        for (const j of plan.junctions) {
+            const inst = JUNCTION.build(uJ, junctionCfg(cfg, j.shape, j.island));
+            inst.object.position.set(j.x, 0, j.z);
+            inst.object.rotation.y = j.ry;
+            group.add(inst.object);
+            kids.push({ inst, kind: 'junction', pos: new THREE.Vector3(j.x, 0, j.z), ry: j.ry });
+        }
+        for (const r of plan.roads) {
+            const inst = ROAD.build(u, roadCfg(cfg, r.points, r.curve));
+            group.add(inst.object);
+            kids.push({ inst, kind: 'road', pos: new THREE.Vector3(), ry: 0 });
+        }
+        for (const t of plan.traffic) {
+            const inst = TRAFFIC.build(uT, trafficCfg(cfg, t.points, t.curve, t.lanes ?? cfg.lanes));
+            group.add(inst.object);
+            kids.push({ inst, kind: 'traffic', pos: new THREE.Vector3(), ry: 0 });
+        }
+        for (const g of plan.grounds) {
+            if (!g.outlines.length)
+                continue;
+            const inst = buildGround(g, cfg, field);
+            group.add(inst.object);
+            kids.push({ inst, kind: 'ground', pos: new THREE.Vector3(), ry: 0 });
+        }
+        merge();
+    };
+    const apply = (cfg) => {
+        // The per-frame knobs, handed to every child as a partial config (each child applies the keys it knows).
+        const live = Object.create(null);
+        if (cfg.asphaltColor !== undefined)
+            live.asphaltColor = cfg.asphaltColor;
+        if (cfg.groundColor !== undefined)
+            live.groundColor = cfg.groundColor;
+        if (cfg.markingColor !== undefined)
+            live.markingColor = cfg.markingColor;
+        if (cfg.wear !== undefined)
+            live.wear = cfg.wear;
+        if (cfg.crossings !== undefined)
+            live.crossings = cfg.crossings;
+        if (cfg.sidewalkColor !== undefined)
+            live.sidewalkColor = cfg.sidewalkColor;
+        if (cfg.signalPaint !== undefined)
+            live.signalPaint = cfg.signalPaint;
+        if (cfg.signalCycle !== undefined)
+            live.signalCycle = cfg.signalCycle;
+        if (cfg.lampPaint !== undefined)
+            live.lampPaint = cfg.lampPaint;
+        if (cfg.lampColor !== undefined)
+            live.lampColor = cfg.lampColor;
+        if (cfg.lampRadius !== undefined)
+            live.lampRadius = cfg.lampRadius;
+        if (cfg.lampIntensity !== undefined)
+            live.lampIntensity = cfg.lampIntensity;
+        if (cfg.speed !== undefined)
+            live.speed = cfg.speed;
+        for (const k of kids)
+            k.inst.apply(live);
+    };
+    rebuild(c);
+    apply(c);
+    const _m = new THREE.Matrix4();
+    return {
+        object: group,
+        get materials() { const out = []; for (const k of kids)
+            out.push(...(k.inst.materials || [])); return out; },
+        get uniformSets() { const out = [u, uJ, uT]; for (const k of kids)
+            for (const s of k.inst.uniformSets || [])
+                if (!out.includes(s))
+                    out.push(s); return out; },
+        /** One lamp target: the baked field over the whole grid (bounds in the grid's own space). */
+        lampTargets() { return [{ field, bounds: this.bounds() }]; },
+        apply,
+        rebuild(cfg) { rebuild(cfg); apply(cfg); },
+        bounds() { const b = new THREE.Box3(); for (const k of kids) {
+            _m.makeRotationY(k.ry).setPosition(k.pos);
+            b.union(k.inst.bounds().applyMatrix4(_m));
+        } return b; },
+        update(dt, camera, renderer = undefined) {
+            // The traffic streams share one uniform set (uTime): tick it once, not once per street.
+            let ticked = false;
+            for (const k of kids) {
+                if (k.kind === 'traffic') {
+                    if (ticked)
+                        continue;
+                    ticked = true;
+                }
+                k.inst.update(dt, camera, renderer);
+            }
+        },
+        dispose() { clear(); field.texture.dispose(); },
+    };
+}

package/dist/components/urban/core/traffic.d.ts

@@ -0,0 +1,125 @@
+import * as THREE from 'three';
+export declare const LIGHTING: string[];
+export declare const STRUCTURAL: string[];
+export declare function createUniforms(): {
+    uSunDir: {
+        value: THREE.Vector3;
+    };
+    uSunColor: {
+        value: THREE.Color;
+    };
+    uSkyAmbient: {
+        value: THREE.Color;
+    };
+    uGroundAmbient: {
+        value: THREE.Color;
+    };
+    uNight: {
+        value: number;
+    };
+} & {
+    uLamps: {
+        value: any[];
+    };
+    uLampColors: {
+        value: any[];
+    };
+    uLampAims: {
+        value: any[];
+    };
+    uLampCount: {
+        value: number;
+    };
+    uLampTop: {
+        value: number;
+    };
+    uLampField: {
+        value: any;
+    };
+    uLampFieldRect: {
+        value: THREE.Vector4;
+    };
+    uLampFieldOn: {
+        value: number;
+    };
+} & {
+    uPaint: {
+        value: THREE.Color;
+    };
+    uAccent: {
+        value: THREE.Color;
+    };
+    uLampColor: {
+        value: THREE.Color;
+    };
+    uLampGlow: {
+        value: number;
+    };
+    uRough: {
+        value: number;
+    };
+    uPath: {
+        value: any;
+    };
+    uPathLength: {
+        value: number;
+    };
+    uTime: {
+        value: number;
+    };
+    uSpeed: {
+        value: number;
+    };
+    uLaneWidth: {
+        value: number;
+    };
+    uWidth: {
+        value: number;
+    };
+    uHead: {
+        value: THREE.Color;
+    };
+    uTail: {
+        value: THREE.Color;
+    };
+    uIntensity: {
+        value: number;
+    };
+    uSize: {
+        value: number;
+    };
+};
+export declare function applyConfig(u: any, c: any): void;
+export declare const VERT = "\nattribute vec2 corner;        // quad corner -1..1\nattribute float aLane;        // lane centre offset across the road (metres, signed)\nattribute float aDir;         // +1 along the path, -1 against\nattribute float aPhase;       // 0..1 the car's start along the path\nattribute float aKind;        // 0 head, 1 tail\nattribute float aSide;        // -1 left lamp, +1 right lamp\nuniform float uSize; uniform float uNight;\nvarying vec2 vUv; varying float vKind;\n#include <fog_pars_vertex>\n\nuniform sampler2D uPath; uniform float uPathLength; uniform float uTime; uniform float uSpeed;\nconst float CAR_HALF = 2.3;\nvec3 pathAt(float s, float lane) {\n    float f = clamp(s / uPathLength, 0.0, 1.0);\n    vec3 p = texture2D(uPath, vec2(f, 0.25)).xyz;\n    vec3 t = normalize(texture2D(uPath, vec2(f, 0.75)).xyz);\n    return p + vec3(-t.z, 0.0, t.x) * lane;              // to the lane: right of the path's +s direction\n}\nbool carFrame(float phase, float dir, float lane, out vec3 head, out vec3 tail) {\n    float c = phase * uPathLength + dir * uSpeed * uTime;\n    c = mod(mod(c, uPathLength) + uPathLength, uPathLength);\n    if (c < CAR_HALF || c > uPathLength - CAR_HALF) return false;\n    vec3 centre = pathAt(c, lane);\n    vec3 t = texture2D(uPath, vec2(clamp(c / uPathLength, 0.0, 1.0), 0.75)).xyz;\n    vec3 fx = normalize(vec3(t.x, 0.0, t.z) * dir);       // the car's forward (flat)\n    head = centre + fx * CAR_HALF;\n    tail = centre - fx * CAR_HALF;\n    return true;\n}\nvoid main() {\n    vUv = corner; vKind = aKind;\n    vec3 head, tail;\n    if (!carFrame(aPhase, aDir, aLane, head, tail)) { gl_Position = vec4(0.0, 0.0, 2.0, 1.0); return; }   // past the path's end: clipped\n    // the lamp pair at the car's end, 0.75 m either side of its axis, at lamp height\n    vec3 fx = normalize(vec3(head.x - tail.x, 0.0, head.z - tail.z));\n    vec3 fz = vec3(-fx.z, 0.0, fx.x);\n    vec3 p = (aKind < 0.5 ? head : tail) + fz * (aSide * 0.75) + vec3(0.0, 0.65, 0.0);\n    vec4 mvPosition = modelViewMatrix * vec4(p, 1.0);\n    // Camera-facing quad with a constant size on screen: px pixels on a 900 px tall viewport\n    // (bigger for head lamps). projectionMatrix[1][1] is 1 / tan(fov / 2), so the half-size in\n    // view space at depth d is px / 900 * d / P11. Clamped below so a close lamp stays a lamp.\n    // The floor scales with the object (a city scaled down keeps its lamps lamp-sized).\n    float sc = length(modelMatrix[0].xyz);\n    float px = (aKind < 0.5 ? 11.0 : 7.0) * uSize;\n    float d = max(-mvPosition.z, 0.5 * sc);\n    float h = max(px / 900.0 * d / projectionMatrix[1][1], 0.09 * sc);\n    mvPosition.xy += corner * h;\n    gl_Position = projectionMatrix * mvPosition;\n    #include <fog_vertex>\n}";
+export declare const FRAG = "\nprecision highp float;\nuniform vec3 uHead; uniform vec3 uTail; uniform float uIntensity; uniform float uNight;\nvarying vec2 vUv; varying float vKind;\n#include <fog_pars_fragment>\nvoid main() {\n    float r = length(vUv);\n    if (r > 1.0) discard;\n    // A hot core with a soft halo; premultiplied, so it adds light without a square.\n    float core = 1.0 / exp(r * r * 9.0);\n    float halo = 1.0 / exp(r * 2.2) * 0.35;\n    float a = clamp(core + halo, 0.0, 1.0);\n    vec3 c = mix(uHead, uTail, vKind) * (vKind < 0.5 ? 2.4 : 1.6) * uIntensity * uNight;\n    vec3 col = c * (core * 1.0 + halo);\n    gl_FragColor = vec4(col, a * uNight);\n    #include <tonemapping_fragment>\n    #include <colorspace_fragment>\n    #include <fog_fragment>\n}";
+export declare const CAR_VERT = "\nattribute float aEmissive; attribute float aAccent;\nattribute float aLane; attribute float aDir; attribute float aPhase; attribute vec3 aPaint;\nvarying vec3 vN; varying vec3 vP; varying float vE; varying float vA; varying vec3 vIC;\n#include <fog_pars_vertex>\n\nuniform sampler2D uPath; uniform float uPathLength; uniform float uTime; uniform float uSpeed;\nconst float CAR_HALF = 2.3;\nvec3 pathAt(float s, float lane) {\n    float f = clamp(s / uPathLength, 0.0, 1.0);\n    vec3 p = texture2D(uPath, vec2(f, 0.25)).xyz;\n    vec3 t = normalize(texture2D(uPath, vec2(f, 0.75)).xyz);\n    return p + vec3(-t.z, 0.0, t.x) * lane;              // to the lane: right of the path's +s direction\n}\nbool carFrame(float phase, float dir, float lane, out vec3 head, out vec3 tail) {\n    float c = phase * uPathLength + dir * uSpeed * uTime;\n    c = mod(mod(c, uPathLength) + uPathLength, uPathLength);\n    if (c < CAR_HALF || c > uPathLength - CAR_HALF) return false;\n    vec3 centre = pathAt(c, lane);\n    vec3 t = texture2D(uPath, vec2(clamp(c / uPathLength, 0.0, 1.0), 0.75)).xyz;\n    vec3 fx = normalize(vec3(t.x, 0.0, t.z) * dir);       // the car's forward (flat)\n    head = centre + fx * CAR_HALF;\n    tail = centre - fx * CAR_HALF;\n    return true;\n}\nvoid main() {\n    vE = aEmissive; vA = aAccent; vIC = aPaint; vN = vec3(0.0, 1.0, 0.0); vP = vec3(0.0);\n    vec3 head, tail;\n    if (!carFrame(aPhase, aDir, aLane, head, tail)) { gl_Position = vec4(0.0, 0.0, 2.0, 1.0); return; }   // past the path's end: clipped\n    // the body between its lamps: centred on them, facing from tail to head (so a turn bends both alike)\n    vec3 fx = normalize(vec3(head.x - tail.x, 0.0, head.z - tail.z));\n    vec3 fz = vec3(-fx.z, 0.0, fx.x);\n    vec3 c = (head + tail) * 0.5;\n    vec3 local = fx * position.x + vec3(0.0, position.y, 0.0) + fz * position.z;\n    vec4 wp = modelMatrix * vec4(c + local, 1.0);\n    vP = wp.xyz;\n    vN = normalize(mat3(modelMatrix) * (fx * normal.x + vec3(0.0, normal.y, 0.0) + fz * normal.z));\n    vec4 mvPosition = viewMatrix * wp;\n    gl_Position = projectionMatrix * mvPosition;\n    #include <fog_vertex>\n}";
+export declare function createCarMaterial(u: any): THREE.ShaderMaterial;
+export declare function createMaterial(u: any): THREE.ShaderMaterial;
+/** The path as a 2-row float texture: positions and tangents sampled uniformly over the arc length. */
+export declare function pathTexture(samples: any): THREE.DataTexture;
+/** The cars as instance attributes: per lane, density x length / 100 cars with jittered spacing; 4 sprites each. */
+export declare function carInstances(c: any, length: any): {
+    lane: any[];
+    dir: any[];
+    phase: any[];
+    kind: any[];
+    side: any[];
+    count: number;
+    car: {
+        lane: any[];
+        dir: any[];
+        phase: any[];
+        paint: any[];
+    };
+};
+export declare function build(u: any, c: any): {
+    object: THREE.Group<THREE.Object3DEventMap>;
+    materials: THREE.ShaderMaterial[];
+    uniformSets: any[];
+    apply(cfg: any): void;
+    rebuild(cfg: any): void;
+    bounds(): any;
+    update(dt: any): void;
+    dispose(): void;
+};
+//# sourceMappingURL=traffic.d.ts.map

package/dist/components/urban/core/traffic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traffic.d.ts","sourceRoot":"","sources":["../../../../src/components/urban/core/traffic.ts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAG/B,eAAO,MAAM,QAAQ,UAA2B,CAAC;AAEjD,eAAO,MAAM,UAAU,UAAqF,CAAC;AAE7G,wBAAgB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmB7B;AAED,wBAAgB,WAAW,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA,QAO/B;AA6BD,eAAO,MAAM,IAAI,wsFA+Bf,CAAC;AAEH,eAAO,MAAM,IAAI,ovBAkBf,CAAC;AAGH,eAAO,MAAM,QAAQ,mnEAqBnB,CAAC;AACH,wBAAgB,iBAAiB,CAAC,CAAC,KAAA,wBAElC;AAED,wBAAgB,cAAc,CAAC,CAAC,KAAA,wBAK/B;AAED,uGAAuG;AACvG,wBAAgB,WAAW,CAAC,OAAO,KAAA,qBAalC;AAED,oHAAoH;AACpH,wBAAgB,YAAY,CAAC,CAAC,KAAA,EAAE,MAAM,KAAA;;;;;;;;;;;;;EAmBrC;AAED,wBAAgB,KAAK,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA;;;;;;;;;EAiEzB"}