@3driseai/3drise-viewer 0.1.42 → 0.1.43

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

@@ -0,0 +1,100 @@
+import * as THREE from 'three';
+import { applyConfig as applyBuilding } from './building';
+export declare const LIGHTING: string[];
+export declare const STRUCTURAL: string[];
+/** The belt as an instance list. */
+export declare function skylineInstances(c: any): any[];
+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;
+    };
+} & {
+    uWallColor: {
+        value: THREE.Color;
+    };
+    uGlassColor: {
+        value: THREE.Color;
+    };
+    uGlassReflect: {
+        value: number;
+    };
+    uMullionColor: {
+        value: THREE.Color;
+    };
+    uRoofColor: {
+        value: THREE.Color;
+    };
+    uMullionWidth: {
+        value: number;
+    };
+    uLobby: {
+        value: number;
+    };
+    uLightColor: {
+        value: THREE.Color;
+    };
+    uCoolLightColor: {
+        value: THREE.Color;
+    };
+    uLightWarmth: {
+        value: number;
+    };
+    uWindowGlow: {
+        value: number;
+    };
+    uFlicker: {
+        value: number;
+    };
+    uTime: {
+        value: number;
+    };
+};
+export { applyBuilding as applyConfig };
+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=skyline.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"skyline.d.ts","sourceRoot":"","sources":["../../../../src/components/urban/core/skyline.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,EAA+H,WAAW,IAAI,aAAa,EAAoC,MAAM,YAAY,CAAC;AAEzN,eAAO,MAAM,QAAQ,UAA2B,CAAC;AAEjD,eAAO,MAAM,UAAU,UAA6M,CAAC;AAErO,oCAAoC;AACpC,wBAAgB,gBAAgB,CAAC,CAAC,KAAA,SAiCjC;AAED,wBAAgB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAiC;AAC/D,OAAO,EAAE,aAAa,IAAI,WAAW,EAAE,CAAC;AAExC,wBAAgB,KAAK,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA;;;;;;;;;EA4BzB"}

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

@@ -0,0 +1,89 @@
+// Emitted from Claude outputs/urban-lab/skyline.mjs by emit_object.mjs — edit the lab module and re-emit.
+// =============================================================================
+// urban/skyline — a far belt of buildings around the scene, one draw call
+// =============================================================================
+// The cheapest way to put a hero in a city: `count` buildings on a ring (radius ± spread,
+// over an arc) with jittered footprints, heights, facades and tints, all instances of the
+// facade InstancedMesh (building.mjs: box volumes, the facade drawn per fragment with
+// box-filtered anti-aliasing, so it still reads right when a building is a few pixels
+// tall). No lobbies, no parapets, no plot — a silhouette layer, lit like the buildings
+// (sun by day, a share of windows at night) and fogged by the scene. Heights follow a
+// power law so most of the belt is mid-rise with a few towers.
+import * as THREE from 'three';
+import { mulberry32, loadTextureSet } from '../urbanCore.js';
+import { FOOTPRINTS, FACADES, pickMix, addBuilding, buildInstancedBoxes, disposeInstanced, createUniforms as buildingUniforms, applyConfig as applyBuilding, createMaterial as facadeMaterial } from './building.js';
+export const LIGHTING = ['auto', 'day', 'night'];
+export const STRUCTURAL = ['mix', 'radius', 'spread', 'arcStart', 'arcSpan', 'count', 'heightMin', 'heightMax', 'width', 'depth', 'sizeJitter', 'facade', 'facadeMix', 'windowRatio', 'bayWidth', 'texture', 'windowLights', 'seed'];
+/** The belt as an instance list. */
+export function skylineInstances(c) {
+    const rng = mulberry32(c.seed * 4241 + 9);
+    const list = [];
+    const n = Math.max(1, Math.round(c.count));
+    const base = new THREE.Color(c.wallColor);
+    const hsl = { h: 0, s: 0, l: 0 };
+    base.getHSL(hsl);
+    const tmp = new THREE.Color();
+    const floorH = 3.4;
+    for (let i = 0; i < n; i++) {
+        const a = (c.arcStart + ((i + rng() * 0.8) / n) * c.arcSpan) * Math.PI / 180;
+        // Two rows: the inner half of the spread denser than the outer, so the belt has a front.
+        const r = c.radius + (rng() < 0.6 ? (rng() - 0.5) * c.spread * 0.5 : (rng() - 0.5) * c.spread);
+        const x = Math.cos(a) * r, z = Math.sin(a) * r;
+        const j = c.sizeJitter;
+        const w = c.width * (1 + (rng() - 0.5) * 2 * j * 0.6), d = c.depth * (1 + (rng() - 0.5) * 2 * j * 0.6);
+        const h = c.heightMin + (c.heightMax - c.heightMin) * Math.pow(rng(), 2.2);
+        const floors = Math.max(2, Math.round(h / floorH));
+        const mix = c.facadeMix;
+        // A city mix picks footprint, facade and roof; heights stay the belt's own (a skyline is a silhouette).
+        const pick = pickMix(rng, c.mix);
+        const footprint = pick ? pick.footprint : (rng() < mix * 0.35 ? FOOTPRINTS[Math.floor(rng() * FOOTPRINTS.length)] : 'box');
+        const facade = pick ? pick.facade : (rng() < mix * 0.8 ? FACADES[Math.floor(rng() * FACADES.length)] : c.facade);
+        const roof = pick ? pick.roof : 'flat';
+        const windowRatio = Math.min(0.95, Math.max(0.15, c.windowRatio + (rng() - 0.5) * 0.3 * mix));
+        const lights = Math.min(1, Math.max(0, c.windowLights + (rng() - 0.5) * 0.4 * mix));
+        tmp.setHSL((hsl.h + (rng() - 0.5) * 0.08 * mix + 1) % 1, Math.min(1, hsl.s * (1 + (rng() - 0.5) * 0.6 * mix)), Math.min(0.95, Math.max(0.08, hsl.l * (1 + (rng() - 0.5) * 0.7 * mix))));
+        const tint = [tmp.r / Math.max(base.r, 0.02), tmp.g / Math.max(base.g, 0.02), tmp.b / Math.max(base.b, 0.02)].map((v) => Math.min(2.2, Math.max(0.35, v)));
+        // Faces turned roughly toward the centre, with a little scatter.
+        const ry = -a + Math.PI / 2 + (rng() - 0.5) * 0.6;
+        const b = { footprint, width: w, depth: d, floors, floorHeight: floorH, lobby: false, roof, facade, windowRatio, bayWidth: c.bayWidth, windowLights: lights };
+        addBuilding(list, b, x, z, ry, tint, Math.floor(rng() * 1e6));
+    }
+    return list;
+}
+export function createUniforms() { return buildingUniforms(); }
+export { applyBuilding as applyConfig };
+export function build(u, c) {
+    const group = new THREE.Group();
+    const mat = facadeMaterial(u);
+    let mesh = null;
+    const state = { tex: null };
+    const rebuild = (cfg) => {
+        if (mesh) {
+            group.remove(mesh);
+            disposeInstanced(mesh);
+            mesh = null;
+        }
+        mesh = buildInstancedBoxes(skylineInstances(cfg), mat);
+        mesh.castShadow = false; // a horizon layer: shadows from it would never reach the hero
+        group.add(mesh);
+    };
+    const setTexture = (cfg) => {
+        const maps = cfg.texture && cfg.texture.maps;
+        state.tex = maps && maps.color ? loadTextureSet(maps) : null;
+        if (state.tex)
+            state.tex.ready.then(() => applyBuilding(u, cfg, state.tex));
+        applyBuilding(u, cfg, state.tex && state.tex.color ? state.tex : null);
+    };
+    rebuild(c);
+    setTexture(c);
+    return {
+        object: group,
+        materials: [mat],
+        uniformSets: [u],
+        apply(cfg) { applyBuilding(u, cfg, undefined); },
+        rebuild(cfg) { rebuild(cfg); setTexture(cfg); },
+        bounds() { return mesh ? mesh.userData.bounds.clone() : new THREE.Box3(); },
+        update(dt) { u.uTime.value += dt; },
+        dispose() { disposeInstanced(mesh); mat.dispose(); },
+    };
+}

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

@@ -0,0 +1,75 @@
+import * as THREE from 'three';
+export declare const KINDS: string[];
+export declare const LIGHTING: string[];
+export declare const STRUCTURAL: string[];
+export declare function buildKind(kind: any, size: any): THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>;
+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;
+    };
+};
+export declare function applyConfig(u: any, c: any): void;
+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(): THREE.Box3;
+    update(): void;
+    dispose(): void;
+};
+//# sourceMappingURL=streetFurniture.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"streetFurniture.d.ts","sourceRoot":"","sources":["../../../../src/components/urban/core/streetFurniture.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAM/B,eAAO,MAAM,KAAK,UAA0C,CAAC;AAC7D,eAAO,MAAM,QAAQ,UAA2B,CAAC;AAEjD,eAAO,MAAM,UAAU,UAAgC,CAAC;AAMxD,wBAAgB,SAAS,CAAC,IAAI,KAAA,EAAE,IAAI,KAAA,oFA+CnC;AAGD,wBAAgB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAsC;AAEpE,wBAAgB,WAAW,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA,QAK/B;AAGD,wBAAgB,KAAK,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA;;;;;;;;;EA0DzB"}

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

@@ -0,0 +1,193 @@
+// Emitted from Claude outputs/urban-lab/streetFurniture.mjs by emit_object.mjs — edit the lab module and re-emit.
+// =============================================================================
+// urban/streetFurniture — lamp, bench, bollard, bus shelter (one `kind` select)
+// =============================================================================
+// Construction. Every kind is a small generative assembly of primitives merged into one
+// geometry and drawn with the shared fixture material (painted metal + an accent colour
+// for wood / glass, sun-lit, with an emissive panel):
+//   lamp     the shared lamp post (tapered pole, swept arm, flat head); the head's underside
+//            is the emissive panel and the lamp is registered in the lamp list so roads,
+//            sidewalks and facades around it light themselves. No THREE light — unless
+//            realLight is on (opt-in, meant for up to ~4 hero lamps in a scene).
+//   bench    two cast frames, five seat slats and three back slats in the accent colour.
+//   bollard  a tapered post with a domed cap and a bright reflector band.
+//   shelter  four posts, a roof slab, a dark glass back and side, a bench, and a lit
+//            advertising panel on the side (emissive, registered as a weak lamp).
+// Base at the origin; `size` scales the whole piece (1 = real-world dimensions).
+import * as THREE from 'three';
+import { buildLampGeometry, createFixtureUniforms, createFixtureMaterial, mergeGeometries, registerLamp, unregisterLamp, touchLamps, setLamps, placeLamps, } from '../urbanCore.js';
+export const KINDS = ['lamp', 'bench', 'bollard', 'shelter'];
+export const LIGHTING = ['auto', 'day', 'night'];
+export const STRUCTURAL = ['kind', 'size', 'realLight'];
+// ---------------------------------------------------------------------------- geometry per kind
+const box = (w, h, d, x, y, z, accent = false, emissive = false) => { const g = new THREE.BoxGeometry(w, h, d); g.translate(x, y, z); g.userData.aAccent = accent ? 1 : 0; g.userData.aEmissive = emissive ? 1 : 0; return g; };
+const cyl = (rt, rb, h, x, y, z, seg = 12, accent = false) => { const g = new THREE.CylinderGeometry(rt, rb, h, seg, 1); g.translate(x, y, z); g.userData.aAccent = accent ? 1 : 0; return g; };
+export function buildKind(kind, size) {
+    const parts = [];
+    let head = null; // emissive source position (for the lamp list)
+    let lampStrength = 1; // share of lampIntensity this kind emits
+    if (kind === 'lamp') {
+        const g = buildLampGeometry({ height: 8, armReach: 1.8 });
+        head = g.userData.head.clone();
+        parts.push(g);
+    }
+    else if (kind === 'bench') {
+        // Cast frames at the ends, slats between them.
+        for (const sx of [-0.8, 0.8]) {
+            parts.push(box(0.08, 0.42, 0.5, sx, 0.21, 0.0));
+            parts.push(box(0.08, 0.45, 0.08, sx, 0.65, -0.24));
+        }
+        for (let i = 0; i < 5; i++)
+            parts.push(box(1.8, 0.04, 0.085, 0, 0.44, -0.22 + i * 0.11, true));
+        for (let i = 0; i < 3; i++)
+            parts.push(box(1.8, 0.085, 0.04, 0, 0.56 + i * 0.12, -0.28, true));
+        lampStrength = 0;
+    }
+    else if (kind === 'bollard') {
+        parts.push(cyl(0.11, 0.14, 0.95, 0, 0.475, 0, 14));
+        const cap = new THREE.SphereGeometry(0.115, 14, 8, 0, Math.PI * 2, 0, Math.PI / 2);
+        cap.translate(0, 0.95, 0);
+        parts.push(cap);
+        const band = new THREE.CylinderGeometry(0.115, 0.115, 0.06, 14, 1, true);
+        band.translate(0, 0.8, 0);
+        band.userData.aEmissive = 1;
+        parts.push(band);
+        lampStrength = 0.08;
+        head = new THREE.Vector3(0, 0.8, 0);
+    }
+    else {
+        // Shelter: 4 x 1.6 m footprint, 2.6 m high.
+        for (const [x, z] of [[-1.9, -0.7], [1.9, -0.7], [-1.9, 0.7], [1.9, 0.7]])
+            parts.push(cyl(0.05, 0.05, 2.5, x, 1.25, z, 10));
+        parts.push(box(4.2, 0.1, 1.8, 0, 2.55, 0)); // roof
+        const back = box(4.0, 2.3, 0.03, 0, 1.3, -0.75, true);
+        back.userData.glass = true;
+        parts.push(back); // back glass
+        const side = box(0.03, 2.3, 1.4, -1.95, 1.3, 0, true);
+        side.userData.glass = true;
+        parts.push(side); // left side glass
+        parts.push(box(1.0, 1.6, 0.08, 2.1, 1.45, 0.2, false, true)); // lit panel on the right side
+        parts.push(box(0.08, 2.3, 0.08, 2.1, 1.25, -0.3)); // its post
+        parts.push(box(2.6, 0.05, 0.4, -0.3, 0.46, -0.35, true)); // bench
+        for (const sx of [-1.4, 0.8])
+            parts.push(box(0.06, 0.44, 0.36, sx, 0.22, -0.35));
+        lampStrength = 0.35;
+        head = new THREE.Vector3(2.1, 1.45, 0.2);
+    }
+    const glassParts = parts.filter((g) => g.userData.glass);
+    const geo = mergeGeometries(parts.filter((g) => !g.userData.glass), [['aEmissive', 1], ['aAccent', 1]]);
+    const glass = glassParts.length ? mergeGeometries(glassParts, [['aEmissive', 1], ['aAccent', 1]]) : null;
+    if (size !== 1) {
+        for (const g of [geo, glass])
+            if (g) {
+                g.scale(size, size, size);
+                g.computeBoundingBox();
+                g.computeBoundingSphere();
+            }
+        if (head)
+            head.multiplyScalar(size);
+    }
+    geo.userData.head = head;
+    geo.userData.lampStrength = lampStrength;
+    geo.userData.glass = glass;
+    return geo;
+}
+// ---------------------------------------------------------------------------- material
+export function createUniforms() { return createFixtureUniforms(); }
+export function applyConfig(u, c) {
+    if (c.paint !== undefined)
+        u.uPaint.value.set(c.paint);
+    if (c.accentColor !== undefined)
+        u.uAccent.value.set(c.accentColor);
+    if (c.lampColor !== undefined)
+        u.uLampColor.value.set(c.lampColor);
+    if (c.lampIntensity !== undefined)
+        u.uLampGlow.value = c.lampIntensity / 2.6;
+}
+// ---------------------------------------------------------------------------- lab build
+export function build(u, c) {
+    const group = new THREE.Group();
+    const mat = createFixtureMaterial(u);
+    const glassMat = createFixtureMaterial(u, true);
+    let mesh = null, glassMesh = null, lamp = null, light = null, headLocal = null;
+    const clear = () => {
+        if (mesh) {
+            group.remove(mesh);
+            mesh.geometry.dispose();
+            mesh = null;
+        }
+        if (glassMesh) {
+            group.remove(glassMesh);
+            glassMesh.geometry.dispose();
+            glassMesh = null;
+        }
+        if (lamp) {
+            unregisterLamp(lamp);
+            lamp = null;
+        }
+        if (light) {
+            group.remove(light);
+            light.dispose();
+            light = null;
+        }
+    };
+    const rebuild = (cfg) => {
+        clear();
+        const geo = buildKind(cfg.kind, cfg.size);
+        mesh = new THREE.Mesh(geo, mat);
+        group.add(mesh);
+        if (geo.userData.glass) {
+            glassMesh = new THREE.Mesh(geo.userData.glass, glassMat);
+            group.add(glassMesh);
+        }
+        headLocal = geo.userData.head;
+        if (headLocal && geo.userData.lampStrength > 0) {
+            lamp = registerLamp({ id: 'furniture', position: headLocal.clone(), color: new THREE.Color(cfg.lampColor), radius: cfg.lampRadius * (cfg.kind === 'lamp' ? 1 : 0.3), intensity: cfg.lampIntensity * geo.userData.lampStrength, on: true, strength: geo.userData.lampStrength });
+            if (cfg.realLight && cfg.kind === 'lamp') {
+                // The opt-in hero light: a point light at the head, no shadows.
+                light = new THREE.PointLight(new THREE.Color(cfg.lampColor), 0, cfg.lampRadius, 2);
+                light.position.copy(headLocal).add(new THREE.Vector3(0, -0.15, 0));
+                group.add(light);
+            }
+        }
+    };
+    const apply = (cfg) => {
+        applyConfig(u, cfg);
+        if (lamp) {
+            setLamps([lamp], cfg.lampColor, cfg.lampIntensity !== undefined ? cfg.lampIntensity * lamp.strength : undefined, cfg.lampRadius !== undefined ? cfg.lampRadius * (lamp.strength === 1 ? 1 : 0.3) : undefined); // bumps only on a real change
+        }
+        if (light) {
+            if (cfg.lampColor !== undefined)
+                light.color.set(cfg.lampColor);
+            if (cfg.lampRadius !== undefined)
+                light.distance = cfg.lampRadius;
+        }
+    };
+    rebuild(c);
+    apply(c);
+    const lastWorld = new THREE.Matrix4();
+    return {
+        object: group,
+        materials: [mat, glassMat],
+        uniformSets: [u],
+        apply,
+        rebuild(cfg) { rebuild(cfg); apply(cfg); },
+        bounds() { const b = new THREE.Box3(); if (mesh) {
+            if (!mesh.geometry.boundingBox)
+                mesh.geometry.computeBoundingBox();
+            b.copy(mesh.geometry.boundingBox);
+        } return b; },
+        update() {
+            group.updateMatrixWorld();
+            if (lamp && !lastWorld.equals(group.matrixWorld)) {
+                lastWorld.copy(group.matrixWorld);
+                placeLamps([lamp], [headLocal], group.matrixWorld); // position, reach and falloff follow the object's scale
+                touchLamps();
+            }
+            // The real light follows the night factor so it is off by day (same curve as the pools).
+            if (light)
+                light.intensity = u.uNight.value * (u.uLampGlow.value * 2.6) * 60;
+        },
+        dispose() { clear(); mat.dispose(); glassMat.dispose(); },
+    };
+}

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

@@ -0,0 +1,134 @@
+import * as THREE from 'three';
+export declare const EDGES: string[];
+export declare const LIGHTING: string[];
+export declare const STRUCTURAL: string[];
+/**
+ * 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 declare function gridPlan(c: any): {
+    junctions: any[];
+    roads: any[];
+    traffic: any[];
+    grounds: import("@3driseai/3drise-core").GridGroundShape[];
+    extent: {
+        w: number;
+        d: number;
+    };
+    layout: import("@3driseai/3drise-core").GridLayout;
+};
+/**
+ * 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 declare function groundGeometry(shape: any): THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>;
+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;
+    };
+} & {
+    uAsphaltColor: {
+        value: THREE.Color;
+    };
+    uMarkingColor: {
+        value: THREE.Color;
+    };
+    uWidth: {
+        value: number;
+    };
+    uLaneWidth: {
+        value: number;
+    };
+    uLanes: {
+        value: number;
+    };
+    uMarking: {
+        value: number;
+    };
+    uLaneLines: {
+        value: number;
+    };
+    uEdgeLines: {
+        value: number;
+    };
+    uCrosswalks: {
+        value: number;
+    };
+    uWear: {
+        value: number;
+    };
+    uLength: {
+        value: number;
+    };
+    uSeed: {
+        value: number;
+    };
+};
+export declare function applyConfig(u: any, c: any, tex?: any): void;
+export declare function build(u: any, c: any): {
+    object: THREE.Group<THREE.Object3DEventMap>;
+    readonly materials: any[];
+    readonly uniformSets: any[];
+    /** One lamp target: the baked field over the whole grid (bounds in the grid's own space). */
+    lampTargets(): {
+        field: {
+            texture: THREE.DataTexture;
+            rect: THREE.Vector4;
+            acc: any;
+            w: number;
+            h: number;
+        };
+        bounds: any;
+    }[];
+    apply: (cfg: any) => void;
+    rebuild(cfg: any): void;
+    bounds(): THREE.Box3;
+    update(dt: any, camera: any, renderer?: any): void;
+    dispose(): void;
+};
+//# sourceMappingURL=streetGrid.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"streetGrid.d.ts","sourceRoot":"","sources":["../../../../src/components/urban/core/streetGrid.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAQ/B,eAAO,MAAM,KAAK,UAAmB,CAAC;AACtC,eAAO,MAAM,QAAQ,UAA2B,CAAC;AAEjD,eAAO,MAAM,UAAU,UAA2O,CAAC;AA6BnQ;;;;;;;;;;;GAWG;AACH,wBAAgB,QAAQ,CAAC,CAAC,KAAA;;;;;;;;;;EAgIzB;AAaD;;;GAGG;AACH,wBAAgB,cAAc,CAAC,KAAK,KAAA,oFAuBnC;AAyBD,wBAAgB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAoC;AAClE,wBAAgB,WAAW,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA,EAAE,GAAG,MAAY,QAA6D;AAG9G,wBAAgB,KAAK,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA;;;;IAmElB,6FAA6F;;;;;;;;;;;;;;;;EAepG"}