@3driseai/3drise-viewer 0.1.41 → 0.1.43

package/dist/components/urban/urbanCore.d.ts

@@ -0,0 +1,262 @@
+import * as THREE from 'three';
+export declare const MAX_LAMPS = 48;
+export declare function mulberry32(a: any): () => number;
+export declare const clamp01: (x: any) => number;
+export declare const lampRegistry: {
+    lamps: any[];
+    version: number;
+};
+export declare function registerLamp(lamp: any): any;
+export declare function unregisterLamp(lamp: any): void;
+export declare function touchLamps(): void;
+export declare function setLamps(lamps: any, color?: any, intensity?: any, radius?: any): boolean;
+/**
+ * Place lamps through an object's world matrix: each lamp at its local head (`locals[i]`), its reach
+ * and falloff scaled by the matrix's scale. Call when the matrix changed, then touchLamps().
+ */
+export declare function placeLamps(lamps: any, locals: any, matrixWorld: any): void;
+export declare function createLampUniforms(): {
+    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;
+    };
+};
+/**
+ * Fill a surface's lamp uniforms with the registry lamps whose pool reaches `bounds`
+ * (a world Box3), nearest first when more than MAX_LAMPS qualify. Positions are WORLD
+ * space, like the shaders' vP (pass invWorld only for a shader that lights in local space).
+ */
+export declare function gatherLamps(u: any, bounds: any, invWorld?: any): number;
+export declare function createLampField(): {
+    texture: THREE.DataTexture;
+    rect: THREE.Vector4;
+    acc: any;
+    w: number;
+    h: number;
+};
+/** Point a material's lamp uniforms at a field (the uniforms take the field's texture and rect objects). */
+export declare function attachLampField(u: any, field: any): void;
+/** Bake every registry lamp whose pool reaches `bounds` (world Box3) into the field. Same falloff as lampLight, receiver facing up. */
+export declare function bakeLampField(field: any, bounds: any): void;
+export declare function createSunUniforms(): {
+    uSunDir: {
+        value: THREE.Vector3;
+    };
+    uSunColor: {
+        value: THREE.Color;
+    };
+    uSkyAmbient: {
+        value: THREE.Color;
+    };
+    uGroundAmbient: {
+        value: THREE.Color;
+    };
+    uNight: {
+        value: number;
+    };
+};
+/** Night factor from the sun: lights come on through civil dusk (sun 2 deg above to 6 deg below). */
+export declare function nightFromSun(sunDirY: any): number;
+/**
+ * sun = { direction, color, skyAmbient, groundAmbient } (the useCloudSun state) and the
+ * object's lighting mode: 'auto' follows the sun, 'day' / 'night' force it.
+ */
+export declare function applySun(u: any, sun: any, lighting?: string): void;
+export declare const GLSL_COMMON = "\nuniform vec3 uSunDir;\nuniform vec3 uSunColor;\nuniform vec3 uSkyAmbient;\nuniform vec3 uGroundAmbient;\nuniform float uNight;\nuniform vec4 uLamps[48];\nuniform vec4 uLampColors[48];\nuniform vec4 uLampAims[48];\nuniform int uLampCount;\nuniform float uLampTop;\nuniform sampler2D uLampField;\nuniform vec4 uLampFieldRect;\nuniform float uLampFieldOn;\n\nfloat hash11(float p) { p = fract(p * 0.1031); p *= p + 33.33; p *= p + p; return fract(p); }\nfloat hash21(vec2 p) { vec3 p3 = fract(vec3(p.xyx) * 0.1031); p3 += dot(p3, p3.yzx + 33.33); return fract((p3.x + p3.y) * p3.z); }\nfloat vnoise21(vec2 p) { vec2 i = floor(p), f = fract(p); f = f * f * (3.0 - 2.0 * f); return mix(mix(hash21(i), hash21(i + vec2(1.0, 0.0)), f.x), mix(hash21(i + vec2(0.0, 1.0)), hash21(i + vec2(1.0, 1.0)), f.x), f.y); }\nfloat hash31(vec3 p) { p = fract(p * 0.1031); p += dot(p, p.zyx + 31.32); return fract((p.x + p.y) * p.z); }\n\n// Irradiance from the gathered lamps. Each lamp is a downward-facing head: a smooth\n// window to its radius, inverse-square falloff softened near the head, a cosine cone so\n// it pools on the ground and only grazes walls, Lambert on the receiver. Scaled by the\n// night factor so pools fade in with dusk.\nvec3 lampLight(vec3 P, vec3 N) {\n    vec3 acc = vec3(0.0);\n    if (uNight < 0.002) return acc;\n    // A baked lamp field (a street grid): the ground's light at this xz, decoded; walls take a share.\n    if (uLampFieldOn > 0.5) {\n        vec3 e = texture2D(uLampField, (P.xz - uLampFieldRect.xy) / uLampFieldRect.zw).rgb;\n        return e * e * 4.0 * (0.3 + 0.7 * max(N.y, 0.0)) * uNight;\n    }\n    // Above the reach of every gathered lamp (most of a facade) the loop is skipped.\n    if (P.y > uLampTop) return acc;\n    for (int i = 0; i < 48; i++) {\n        if (i >= uLampCount) break;\n        vec4 L = uLamps[i];\n        vec3 d = L.xyz - P;\n        float r2 = dot(d, d);\n        float r = sqrt(r2);\n        vec3 l = d / max(r, 1e-3);\n        float x = r / L.w;\n        float win = clamp(1.0 - x * x * x * x, 0.0, 1.0);\n        win *= win;\n        float ndl = max(dot(N, l), 0.0);\n        vec4 A = uLampAims[i];\n        if (A.w > 0.0) {\n            // a projector: an aimed beam (soft edge from the outer cone in), throw nearly flat over its\n            // reach, so a few towers light a whole stadium evenly; walls facing it take light too\n            float spot = smoothstep(A.w, mix(A.w, 1.0, 0.45), dot(-l, A.xyz));\n            acc += uLampColors[i].rgb * (uLampColors[i].a * win * spot * (0.35 + 0.65 * ndl) * 4.0 / (1.0 + x * x * 3.0));\n            continue;\n        }\n        float cone = smoothstep(0.1, 0.7, l.y);\n        float ls = A.w < 0.0 ? -A.w : 1.0;   // the lamp's object scale: falloff over its own metres\n        // Intensity 1 puts ~0.75 irradiance on the ground under an 8 m head, a tenth of that\n        // 14 m along the kerb: street-lamp contrast, not a wash.\n        acc += uLampColors[i].rgb * (uLampColors[i].a * win * ndl * cone * 4.0 / (1.0 + r2 * 0.06 / (ls * ls)));\n    }\n    return acc * uNight;\n}\n\n// Sun + sky + ground + lamps on a rough dielectric. Radiance units: a 0.5 albedo at noon\n// lands near 0.9, so NoToneMapping keeps it under 1.\nvec3 shadeSurface(vec3 albedo, vec3 N, vec3 P, vec3 V, float rough, float ao) {\n    float ndl = max(dot(N, uSunDir), 0.0);\n    vec3 sky = uSkyAmbient * (0.55 + 0.45 * N.y);\n    vec3 gnd = uGroundAmbient * (0.5 - 0.5 * N.y);\n    vec3 col = albedo * (uSunColor * ndl + (sky + gnd) * ao);\n    vec3 H = normalize(uSunDir + V);\n    float spec = pow(max(dot(N, H), 0.0), mix(90.0, 6.0, rough)) * (1.0 - rough) * 0.35 * ndl;\n    col += uSunColor * spec;\n    col += albedo * lampLight(P, N);\n    return col;\n}\n\n// Box-filtered coverage of the band [a, b] over this pixel's footprint on x: exact\n// anti-aliasing at the edge AND the right average when the band is thinner than a pixel\n// (a far facade blends to the mean of glass and spandrel instead of sparkling).\nfloat bandAA(float x, float a, float b) {\n    float w = max(fwidth(x), 1e-5);\n    float lo = max(a, x - 0.5 * w), hi = min(b, x + 0.5 * w);\n    return clamp((hi - lo) / w, 0.0, 1.0);\n}\n";
+export declare const GLSL_FOG_PARS = "#include <fog_pars_fragment>";
+export declare const GLSL_FOG_VERT_PARS = "#include <fog_pars_vertex>";
+/** Shared tail: output in the viewer's convention (NoToneMapping, sRGB out, scene fog). */
+export declare const GLSL_OUT = "\n    gl_FragColor = vec4(col, 1.0);\n    #include <tonemapping_fragment>\n    #include <colorspace_fragment>\n    #include <fog_fragment>\n";
+/**
+ * maps: { color?, normal?, roughness?, ao? } URLs (a library set's maps). Returns
+ * { color, normal, roughness, ao, mean: THREE.Color, ready: Promise }. Textures repeat;
+ * the colour map is sRGB. `mean` is the colour map's linear mean, filled when it loads.
+ */
+export declare function loadTextureSet(maps: any): any;
+export declare function createTextureUniforms(prefix: any): {};
+/** Point a texture-uniform block at a loaded set (or clear it when `set` is null). */
+export declare function applyTextureSet(u: any, prefix: any, set: any, tile?: number, normalStrength?: number): void;
+/** GLSL for one texture block: sampleTex_<prefix>(uv, N, T, B) -> albedo multiplier, bumped normal, roughness. */
+export declare function glslTextureBlock(prefix: any): string;
+/** Sample the polyline: [{ p: Vector3, t: Vector3 (tangent), n: Vector3 (right), s }] */
+/**
+ * Sample a polyline ([x, z] metres) into frames every ~1.5 m: [{ p, t (tangent), n (right), s }].
+ * `curve` 0 keeps the corners, 1 rounds the path (Catmull-Rom tension); `closed` loops it.
+ */
+export declare function samplePath(points: any, curve?: number, closed?: boolean): any[];
+/** A ribbon between offsets ta..tb (across) at heights ya..yb along the sampled path; uv = (s, t) or (s, y) for faces. */
+export declare function ribbon(samples: any, ta: any, tb: any, ya: any, yb: any, vertical?: boolean, facing?: number): THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>;
+/**
+ * Merge indexed or non-indexed geometries into one (position, normal + the named float/vec
+ * attributes, missing ones filled with `fill[name]` or 0). Disposes the inputs.
+ */
+export declare function mergeGeometries(list: any, attrs?: any[], fill?: any): THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>;
+/**
+ * Merge every mesh under `roots` into as few meshes as there are materials (instanced meshes of
+ * the same geometry into one InstancedMesh), added to `group` in its local space, lit by a baked
+ * lamp `field`. Used by objects built from other variants' cores (a street grid, a block's
+ * streets): ~200 pieces become ~10 draw calls. A merged mesh draws with the FIRST piece's
+ * material — the pieces' knob uniforms all receive the same config, so any one stands for all;
+ * a per-piece difference must be a vertex attribute (the junction's aTee / aRound), never a
+ * uniform. A material can keep itself apart with material.userData.mergeKey (a lawn island).
+ * The originals leave the scene graph; their cores still own and dispose them. Returns the
+ * merged meshes (dispose their geometry; the materials are the pieces').
+ */
+export declare function mergeByMaterial(group: any, roots: any, field: any): any[];
+/**
+ * A street lamp as one BufferGeometry: tapered pole, a curved arm, a flat head whose
+ * underside is the emissive panel. Attributes: position, normal, aEmissive (1 on the panel).
+ * Base at the origin, head at (armReach, height, 0) facing -y. Pure function of its params.
+ */
+export declare function buildLampGeometry(p: any): THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>;
+export declare function createPavingUniforms(): {
+    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;
+    };
+} & {
+    uPavColor: {
+        value: THREE.Color;
+    };
+    uPavRoughness: {
+        value: number;
+    };
+    uGrassMix: {
+        value: number;
+    };
+};
+export declare const PAVING_VERT = "\nattribute vec2 aUV;\nvarying vec3 vN; varying vec3 vP; varying vec2 vUVm; varying vec3 vLocalN;\n#include <fog_pars_vertex>\nvoid main() {\n    #ifdef USE_INSTANCING\n    mat4 m = modelMatrix * instanceMatrix;\n    #else\n    mat4 m = modelMatrix;\n    #endif\n    vec4 wp = m * vec4(position, 1.0);\n    vP = wp.xyz;\n    vN = normalize(mat3(m) * normal);\n    vLocalN = normal;\n    vUVm = aUV;\n    vec4 mvPosition = viewMatrix * wp;\n    gl_Position = projectionMatrix * mvPosition;\n    #include <fog_vertex>\n}";
+export declare const PAVING_FRAG: string;
+/**
+ * Depth options for the family's flat ground surfaces (asphalt, paving, plaza slabs). They sit
+ * centimetres above the scene's terrain or a ground plane; without an offset the depth buffer
+ * cannot tell them apart at distance and they flicker as the camera moves (z-fighting).
+ * A polygon offset pulls them toward the camera in depth only — nothing moves on screen.
+ */
+export declare const SURFACE_DEPTH: {
+    polygonOffset: boolean;
+    polygonOffsetFactor: number;
+    polygonOffsetUnits: number;
+};
+export declare function createPavingMaterial(u: any): THREE.ShaderMaterial;
+export declare function createFixtureUniforms(): {
+    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 const FIXTURE_VERT = "\nattribute float aEmissive;\nattribute float aAccent;\nvarying vec3 vN; varying vec3 vP; varying float vE; varying float vA; varying vec3 vIC;\n#include <fog_pars_vertex>\nvoid main() {\n    vec3 n = normal;\n    #ifdef USE_INSTANCING\n    mat4 m = modelMatrix * instanceMatrix;\n    #else\n    mat4 m = modelMatrix;\n    #endif\n    // Per-instance paint (InstancedMesh.instanceColor): cars in a parking lot, else white.\n    vIC = vec3(1.0);\n    #ifdef USE_INSTANCING_COLOR\n    vIC = instanceColor;\n    #endif\n    vec4 wp = m * vec4(position, 1.0);\n    vP = wp.xyz;\n    vN = normalize(mat3(m) * n);\n    vE = aEmissive;\n    vA = aAccent;\n    vec4 mvPosition = viewMatrix * wp;\n    gl_Position = projectionMatrix * mvPosition;\n    #include <fog_vertex>\n}";
+export declare const FIXTURE_FRAG = "\nprecision highp float;\n\nuniform vec3 uSunDir;\nuniform vec3 uSunColor;\nuniform vec3 uSkyAmbient;\nuniform vec3 uGroundAmbient;\nuniform float uNight;\nuniform vec4 uLamps[48];\nuniform vec4 uLampColors[48];\nuniform vec4 uLampAims[48];\nuniform int uLampCount;\nuniform float uLampTop;\nuniform sampler2D uLampField;\nuniform vec4 uLampFieldRect;\nuniform float uLampFieldOn;\n\nfloat hash11(float p) { p = fract(p * 0.1031); p *= p + 33.33; p *= p + p; return fract(p); }\nfloat hash21(vec2 p) { vec3 p3 = fract(vec3(p.xyx) * 0.1031); p3 += dot(p3, p3.yzx + 33.33); return fract((p3.x + p3.y) * p3.z); }\nfloat vnoise21(vec2 p) { vec2 i = floor(p), f = fract(p); f = f * f * (3.0 - 2.0 * f); return mix(mix(hash21(i), hash21(i + vec2(1.0, 0.0)), f.x), mix(hash21(i + vec2(0.0, 1.0)), hash21(i + vec2(1.0, 1.0)), f.x), f.y); }\nfloat hash31(vec3 p) { p = fract(p * 0.1031); p += dot(p, p.zyx + 31.32); return fract((p.x + p.y) * p.z); }\n\n// Irradiance from the gathered lamps. Each lamp is a downward-facing head: a smooth\n// window to its radius, inverse-square falloff softened near the head, a cosine cone so\n// it pools on the ground and only grazes walls, Lambert on the receiver. Scaled by the\n// night factor so pools fade in with dusk.\nvec3 lampLight(vec3 P, vec3 N) {\n    vec3 acc = vec3(0.0);\n    if (uNight < 0.002) return acc;\n    // A baked lamp field (a street grid): the ground's light at this xz, decoded; walls take a share.\n    if (uLampFieldOn > 0.5) {\n        vec3 e = texture2D(uLampField, (P.xz - uLampFieldRect.xy) / uLampFieldRect.zw).rgb;\n        return e * e * 4.0 * (0.3 + 0.7 * max(N.y, 0.0)) * uNight;\n    }\n    // Above the reach of every gathered lamp (most of a facade) the loop is skipped.\n    if (P.y > uLampTop) return acc;\n    for (int i = 0; i < 48; i++) {\n        if (i >= uLampCount) break;\n        vec4 L = uLamps[i];\n        vec3 d = L.xyz - P;\n        float r2 = dot(d, d);\n        float r = sqrt(r2);\n        vec3 l = d / max(r, 1e-3);\n        float x = r / L.w;\n        float win = clamp(1.0 - x * x * x * x, 0.0, 1.0);\n        win *= win;\n        float ndl = max(dot(N, l), 0.0);\n        vec4 A = uLampAims[i];\n        if (A.w > 0.0) {\n            // a projector: an aimed beam (soft edge from the outer cone in), throw nearly flat over its\n            // reach, so a few towers light a whole stadium evenly; walls facing it take light too\n            float spot = smoothstep(A.w, mix(A.w, 1.0, 0.45), dot(-l, A.xyz));\n            acc += uLampColors[i].rgb * (uLampColors[i].a * win * spot * (0.35 + 0.65 * ndl) * 4.0 / (1.0 + x * x * 3.0));\n            continue;\n        }\n        float cone = smoothstep(0.1, 0.7, l.y);\n        float ls = A.w < 0.0 ? -A.w : 1.0;   // the lamp's object scale: falloff over its own metres\n        // Intensity 1 puts ~0.75 irradiance on the ground under an 8 m head, a tenth of that\n        // 14 m along the kerb: street-lamp contrast, not a wash.\n        acc += uLampColors[i].rgb * (uLampColors[i].a * win * ndl * cone * 4.0 / (1.0 + r2 * 0.06 / (ls * ls)));\n    }\n    return acc * uNight;\n}\n\n// Sun + sky + ground + lamps on a rough dielectric. Radiance units: a 0.5 albedo at noon\n// lands near 0.9, so NoToneMapping keeps it under 1.\nvec3 shadeSurface(vec3 albedo, vec3 N, vec3 P, vec3 V, float rough, float ao) {\n    float ndl = max(dot(N, uSunDir), 0.0);\n    vec3 sky = uSkyAmbient * (0.55 + 0.45 * N.y);\n    vec3 gnd = uGroundAmbient * (0.5 - 0.5 * N.y);\n    vec3 col = albedo * (uSunColor * ndl + (sky + gnd) * ao);\n    vec3 H = normalize(uSunDir + V);\n    float spec = pow(max(dot(N, H), 0.0), mix(90.0, 6.0, rough)) * (1.0 - rough) * 0.35 * ndl;\n    col += uSunColor * spec;\n    col += albedo * lampLight(P, N);\n    return col;\n}\n\n// Box-filtered coverage of the band [a, b] over this pixel's footprint on x: exact\n// anti-aliasing at the edge AND the right average when the band is thinner than a pixel\n// (a far facade blends to the mean of glass and spandrel instead of sparkling).\nfloat bandAA(float x, float a, float b) {\n    float w = max(fwidth(x), 1e-5);\n    float lo = max(a, x - 0.5 * w), hi = min(b, x + 0.5 * w);\n    return clamp((hi - lo) / w, 0.0, 1.0);\n}\n\nuniform vec3 uPaint; uniform vec3 uAccent; uniform vec3 uLampColor; uniform float uLampGlow; uniform float uRough;\nvarying vec3 vN; varying vec3 vP; varying float vE; varying float vA; varying vec3 vIC;\n#include <fog_pars_fragment>\nvoid main() {\n    vec3 N = normalize(vN);\n    vec3 V = normalize(cameraPosition - vP);\n    vec3 base = mix(uPaint * vIC, uAccent, vA);\n    vec3 col = shadeSurface(base, N, vP, V, mix(uRough, 0.8, vA), 1.0);\n    // The panel: dim diffuser by day, a bright warm disc at night (over 1.0 on purpose, for bloom).\n    vec3 panel = mix(uPaint * 1.6, uLampColor * (1.0 + 2.2 * uLampGlow), uNight);\n    col = mix(col, panel, vE);\n    float alpha = 1.0;\n    #ifdef GLASS\n    // Shelter glass: a faint tint plus a Fresnel sky reflection, mostly see-through.\n    float fres = 0.04 + 0.96 * pow(1.0 - abs(dot(N, V)), 5.0);\n    col = uAccent * 0.08 * (uSkyAmbient + uSunColor * 0.3) + (uSkyAmbient * 2.0 + uSunColor * 0.1) * fres * 0.8;\n    alpha = 0.18 + 0.7 * fres;\n    #endif\n    gl_FragColor = vec4(col, alpha);\n    #include <tonemapping_fragment>\n    #include <colorspace_fragment>\n    #include <fog_fragment>\n}";
+export declare const CAR_PALETTE: string[];
+/** A low-poly car as one geometry, facing +x, base at y = 0: body, cabin (accent = dark glass), four wheels (accent). */
+export declare function buildCarGeometry(): THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>;
+export declare function createFixtureMaterial(u: any, glass?: boolean): THREE.ShaderMaterial;
+//# sourceMappingURL=urbanCore.d.ts.map

package/dist/components/urban/urbanCore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"urbanCore.d.ts","sourceRoot":"","sources":["../../../src/components/urban/urbanCore.ts"],"names":[],"mappings":"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"}