@3driseai/3drise-viewer 0.1.42 → 0.1.43

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

@@ -0,0 +1,243 @@
+// Emitted from Claude outputs/urban-lab/plaza.mjs by emit_object.mjs — edit the lab module and re-emit.
+// =============================================================================
+// urban/plaza — a paved area inside a polygon: two paving sets in a pattern, a kerb, lamp-lit
+// =============================================================================
+// Construction. The polygon (config.points, metres in the object's XZ) is sampled like a
+// road path (closed; `curve` rounds the corners), triangulated into one slab (ShapeGeometry)
+// whose UVs are the metres themselves, and a kerb ribbon runs around it (top at kerbHeight,
+// an outer face down to the ground). The slab's fragment shader lays a second paving set
+// over the first along a PATTERN measured in metres — grid, stripes or rings from the
+// centre — anti-aliased with fwidth, both sets normalised to their mean so the two colour
+// knobs decide. Lit by the shared sun block and by the lamp list (street lamps, plaza
+// lamps, bollards, the shelter panel), so a forecourt reads at night without a light.
+import * as THREE from 'three';
+import { createSunUniforms, createLampUniforms, createTextureUniforms, applyTextureSet, glslTextureBlock, GLSL_COMMON, GLSL_FOG_PARS, GLSL_FOG_VERT_PARS, GLSL_OUT, loadTextureSet, createPavingUniforms, createPavingMaterial, samplePath, ribbon, mergeGeometries, SURFACE_DEPTH, } from '../urbanCore.js';
+export const PATTERNS = ['none', 'grid', 'stripes', 'rings', 'checker'];
+export const LIGHTING = ['auto', 'day', 'night'];
+export const STRUCTURAL = ['points', 'curve', 'texture', 'bandTexture', 'kerb', 'kerbHeight', 'seed'];
+// ---------------------------------------------------------------------------- slab material
+export function createUniforms() {
+    return Object.assign(createSunUniforms(), createLampUniforms(), createTextureUniforms('uPav'), createTextureUniforms('uBand'), {
+        uPavColor: { value: new THREE.Color() },
+        uBandColor: { value: new THREE.Color() },
+        uPattern: { value: 1 },
+        uSpacing: { value: 8 },
+        uBandW: { value: 0.6 },
+        uAngle: { value: 0 },
+        uSeed: { value: 1 },
+    });
+}
+export function applyConfig(u, c, tex = undefined, bandTex = undefined) {
+    if (c.color !== undefined)
+        u.uPavColor.value.set(c.color);
+    if (c.bandColor !== undefined)
+        u.uBandColor.value.set(c.bandColor);
+    if (c.pattern !== undefined)
+        u.uPattern.value = PATTERNS.indexOf(c.pattern);
+    if (c.patternSpacing !== undefined)
+        u.uSpacing.value = c.patternSpacing;
+    if (c.patternWidth !== undefined)
+        u.uBandW.value = c.patternWidth;
+    if (c.patternAngle !== undefined)
+        u.uAngle.value = c.patternAngle * Math.PI / 180;
+    if (c.seed !== undefined)
+        u.uSeed.value = c.seed;
+    if (tex !== undefined)
+        applyTextureSet(u, 'uPav', tex, c.texture && c.texture.tileSize, 0.7);
+    if (bandTex !== undefined)
+        applyTextureSet(u, 'uBand', bandTex, c.bandTexture && c.bandTexture.tileSize, 0.7);
+}
+export const VERT = /* glsl */ `
+attribute vec2 aUV;
+varying vec3 vN; varying vec3 vP; varying vec2 vUVm;
+${GLSL_FOG_VERT_PARS}
+void main() {
+    vec4 wp = modelMatrix * vec4(position, 1.0);
+    vP = wp.xyz;
+    vN = normalize(mat3(modelMatrix) * normal);
+    vUVm = aUV;
+    vec4 mvPosition = viewMatrix * wp;
+    gl_Position = projectionMatrix * mvPosition;
+    #include <fog_vertex>
+}`;
+export const FRAG = /* glsl */ `
+precision highp float;
+${GLSL_COMMON}
+${glslTextureBlock('uPav')}
+${glslTextureBlock('uBand')}
+uniform vec3 uPavColor; uniform vec3 uBandColor;
+uniform float uPattern; uniform float uSpacing; uniform float uBandW; uniform float uAngle; uniform float uSeed;
+varying vec3 vN; varying vec3 vP; varying vec2 vUVm;
+${GLSL_FOG_PARS}
+
+// Pattern mask in metres: 1 where the second paving set shows.
+float patternMask(vec2 q) {
+    float s = max(uSpacing, 0.2), w = uBandW;
+    if (uPattern < 0.5) return 0.0;
+    if (uPattern < 1.5) {           // grid: lines centred on the multiples of s
+        vec2 m = abs(mod(q + s * 0.5, s) - s * 0.5);
+        return max(1.0 - bandAA(m.x, w * 0.5, 1e9), 1.0 - bandAA(m.y, w * 0.5, 1e9));
+    }
+    if (uPattern < 2.5) {           // stripes along the pattern angle
+        float m = abs(mod(q.x + s * 0.5, s) - s * 0.5);
+        return 1.0 - bandAA(m, w * 0.5, 1e9);
+    }
+    if (uPattern < 3.5) {           // rings from the centre
+        float m = abs(mod(length(q) + s * 0.5, s) - s * 0.5);
+        return 1.0 - bandAA(m, w * 0.5, 1e9);
+    }
+    // checker: alternate cells of s
+    vec2 cell = floor(q / s);
+    return mod(cell.x + cell.y, 2.0);
+}
+
+void main() {
+    vec3 N = normalize(vN);
+    vec3 V = normalize(cameraPosition - vP);
+    // Both sets sample in metres; the pattern is measured in a frame turned by uAngle.
+    float ca = cos(uAngle), sa = sin(uAngle);
+    vec2 q = vec2(ca * vUVm.x - sa * vUVm.y, sa * vUVm.x + ca * vUVm.y);
+    float roughA, roughB;
+    vec3 Na = N, Nb = N;
+    vec3 T = vec3(1.0, 0.0, 0.0), B = vec3(0.0, 0.0, 1.0);
+    vec3 mulA = uPavSample(vUVm, Na, T, B, roughA);
+    vec3 mulB = uBandSample(q, Nb, T, B, roughB);
+    float mask = patternMask(q);
+    float macro = 0.94 + 0.12 * vnoise21(vUVm / 9.0 + uSeed);
+    vec3 albedo = mix(uPavColor * mulA, uBandColor * mulB, mask) * macro;
+    vec3 Nn = normalize(mix(Na, Nb, mask));
+    float rough = mix(roughA, roughB, mask);
+    vec3 col = shadeSurface(albedo, Nn, vP, V, rough, 1.0);
+${GLSL_OUT}
+}`;
+export function createMaterial(u) {
+    return new THREE.ShaderMaterial({ uniforms: Object.assign(THREE.UniformsUtils.clone(THREE.UniformsLib.fog), u), vertexShader: VERT, fragmentShader: FRAG, fog: true, ...SURFACE_DEPTH });
+}
+// ---------------------------------------------------------------------------- geometry
+/** Signed area of an [x, z] polygon (positive = counter-clockwise seen from above, +y). */
+export function signedArea(pts) {
+    let a = 0;
+    for (let i = 0; i < pts.length; i++) {
+        const p = pts[i], q = pts[(i + 1) % pts.length];
+        a += p[0] * q[1] - q[0] * p[1];
+    }
+    return a * 0.5;
+}
+/** The slab: the sampled outline as a Shape, triangulated, UVs in metres, laid flat at height y. */
+export function slabGeometry(samples, y) {
+    const shape = new THREE.Shape();
+    samples.forEach((s, i) => { if (i === 0)
+        shape.moveTo(s.p.x, s.p.z);
+    else
+        shape.lineTo(s.p.x, s.p.z); });
+    shape.closePath();
+    const g = new THREE.ShapeGeometry(shape, 1);
+    // ShapeGeometry lies in xy with +z up: turn it onto xz with +y up.
+    const pos = g.getAttribute('position');
+    const uv = new Float32Array(pos.count * 2);
+    for (let i = 0; i < pos.count; i++) {
+        const x = pos.getX(i), z = pos.getY(i);
+        pos.setXYZ(i, x, y, z);
+        uv[i * 2] = x;
+        uv[i * 2 + 1] = z;
+    }
+    pos.needsUpdate = true;
+    g.setAttribute('aUV', new THREE.BufferAttribute(uv, 2));
+    // Winding: ShapeGeometry triangles face +z (now -y or +y depending on the outline direction); make them face up.
+    g.computeVertexNormals();
+    const n = g.getAttribute('normal');
+    if (n.getY(0) < 0) {
+        const idx = g.index;
+        for (let i = 0; i < idx.count; i += 3) {
+            const t = idx.getX(i + 1);
+            idx.setX(i + 1, idx.getX(i + 2));
+            idx.setX(i + 2, t);
+        }
+        idx.needsUpdate = true;
+        g.computeVertexNormals();
+    }
+    g.computeBoundingBox();
+    g.computeBoundingSphere();
+    return g;
+}
+// ---------------------------------------------------------------------------- lab build
+export function build(u, c) {
+    const group = new THREE.Group();
+    const slabMat = createMaterial(u);
+    const kerbU = createPavingUniforms();
+    const kerbMat = createPavingMaterial(kerbU);
+    let slab = null, kerb = null;
+    const state = { tex: null, band: null };
+    const clear = () => {
+        for (const m of [slab, kerb])
+            if (m) {
+                group.remove(m);
+                m.geometry.dispose();
+            }
+        slab = kerb = null;
+    };
+    const rebuild = (cfg) => {
+        clear();
+        let pts = (cfg.points || []).filter((p) => Array.isArray(p) && p.length >= 2);
+        if (pts.length < 3)
+            return;
+        // Counter-clockwise seen from above, so the ribbon's "right" side is the outside.
+        if (signedArea(pts) > 0)
+            pts = [...pts].reverse();
+        const samples = samplePath(pts, cfg.curve, true);
+        if (samples.length < 3)
+            return;
+        const kh = cfg.kerb ? Math.max(0.02, cfg.kerbHeight) : 0.02;
+        slab = new THREE.Mesh(slabGeometry(samples, kh), slabMat);
+        slab.frustumCulled = false;
+        group.add(slab);
+        if (cfg.kerb) {
+            // The kerb: a flat top band 0.3 m wide just inside the edge and the outer face down to the ground.
+            const parts = [
+                ribbon(samples, -0.3, 0, kh, kh, false), // top band (inside the outline)
+                ribbon(samples, 0, 0, kh, 0.0, true, 1), // outer face
+            ];
+            kerb = new THREE.Mesh(mergeGeometries(parts, [['aUV', 2]]), kerbMat);
+            kerb.frustumCulled = false;
+            group.add(kerb);
+        }
+    };
+    const setTextures = (cfg) => {
+        const m = cfg.texture && cfg.texture.maps;
+        state.tex = m && m.color ? loadTextureSet(m) : null;
+        const bm = cfg.bandTexture && cfg.bandTexture.maps;
+        state.band = bm && bm.color ? loadTextureSet(bm) : null;
+        const ap = () => {
+            applyConfig(u, cfg, state.tex && state.tex.color ? state.tex : null, state.band && state.band.color ? state.band : null);
+            applyTextureSet(kerbU, 'uPav', state.band && state.band.color ? state.band : null, cfg.bandTexture && cfg.bandTexture.tileSize, 0.7);
+        };
+        if (state.tex)
+            state.tex.ready.then(ap);
+        if (state.band)
+            state.band.ready.then(ap);
+        ap();
+    };
+    const apply = (cfg) => {
+        applyConfig(u, cfg, undefined, undefined);
+        if (cfg.bandColor !== undefined)
+            kerbU.uPavColor.value.set(cfg.bandColor);
+    };
+    rebuild(c);
+    setTextures(c);
+    apply(c);
+    return {
+        object: group,
+        materials: [slabMat, kerbMat],
+        uniformSets: [u, kerbU],
+        apply,
+        rebuild(cfg) { rebuild(cfg); setTextures(cfg); apply(cfg); },
+        bounds() { const b = new THREE.Box3(); for (const m of [slab, kerb])
+            if (m) {
+                if (!m.geometry.boundingBox)
+                    m.geometry.computeBoundingBox();
+                b.union(m.geometry.boundingBox);
+            } return b; },
+        update() { },
+        dispose() { clear(); slabMat.dispose(); kerbMat.dispose(); },
+    };
+}

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

@@ -0,0 +1,113 @@
+import * as THREE from 'three';
+export declare const MARKINGS: string[];
+export declare const LAMP_SIDES: string[];
+export declare const LIGHTING: string[];
+export declare const STRUCTURAL: string[];
+export declare function roadWidth(c: any): number;
+/** Where the lamps stand: [{ x, z, ry, side }] in object space (head arm turned toward the road). */
+export declare function lampPositions(c: any, samples: 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;
+    };
+} & {
+    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 const VERT = "\nattribute vec2 aUV;\nvarying vec3 vN; varying vec3 vP; varying vec2 vST;\n#include <fog_pars_vertex>\nvoid main() {\n    vec4 wp = modelMatrix * vec4(position, 1.0);\n    vP = wp.xyz;\n    vN = normalize(mat3(modelMatrix) * normal);\n    vST = aUV;\n    vec4 mvPosition = viewMatrix * wp;\n    gl_Position = projectionMatrix * mvPosition;\n    #include <fog_vertex>\n}";
+export declare const FRAG: string;
+export declare function createMaterial(u: any): THREE.ShaderMaterial;
+/**
+ * build(u, c) -> { object, materials, apply, rebuild, update, dispose, bounds, lamps }
+ * `u` is the asphalt uniforms; the paving and fixture uniforms are created here and share
+ * the sun / lamp values through applySun on all three (the component does the same).
+ */
+export declare const CHUNK_M = 120;
+export declare function build(u: any, c: any): {
+    object: THREE.Group<THREE.Object3DEventMap>;
+    readonly materials: THREE.ShaderMaterial[];
+    /** The shared uniform sets (sun goes here once; the chunks reference the same objects). */
+    uniformSets: any[];
+    /** Lamp gathering targets: each chunk's asphalt and paving with its local bounds. */
+    lampTargets(): any[];
+    apply: (cfg: any) => void;
+    rebuild(cfg: any): void;
+    /** Local-space bounds (the caller applies the object's world matrix). */
+    bounds(): THREE.Box3;
+    /** Keep the registry's world positions in step with the object's transform. */
+    update(): void;
+    dispose(): void;
+};
+//# sourceMappingURL=road.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"road.d.ts","sourceRoot":"","sources":["../../../../src/components/urban/core/road.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAQ/B,eAAO,MAAM,QAAQ,UAAwC,CAAC;AAC9D,eAAO,MAAM,UAAU,UAAiD,CAAC;AACzE,eAAO,MAAM,QAAQ,UAA2B,CAAC;AAEjD,eAAO,MAAM,UAAU,UAAqJ,CAAC;AAG7K,wBAAgB,SAAS,CAAC,CAAC,KAAA,UAA4D;AAEvF,qGAAqG;AACrG,wBAAgB,aAAa,CAAC,CAAC,KAAA,EAAE,OAAO,KAAA,SAsBvC;AAGD,wBAAgB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAe7B;AAED,wBAAgB,WAAW,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA,EAAE,GAAG,MAAY,QAWhD;AAED,eAAO,MAAM,IAAI,uXAYf,CAAC;AAEH,eAAO,MAAM,IAAI,QAmEf,CAAC;AAEH,wBAAgB,cAAc,CAAC,CAAC,KAAA,wBAE/B;AAGD;;;;GAIG;AACH,eAAO,MAAM,OAAO,MAAM,CAAC;AAE3B,wBAAgB,KAAK,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA;;;IAyGlB,2FAA2F;;IAE3F,qFAAqF;;;;IAIrF,yEAAyE;;IAEzE,+EAA+E;;;EAWtF"}