@3driseai/3drise-viewer 0.1.28 → 0.1.29

package/dist/utils/skyMoon.d.ts

@@ -0,0 +1,35 @@
+import type { Vector3 } from 'three';
+import type { TimeSettings } from '@3driseai/3drise-core';
+export interface MoonState {
+    /** Unit vector toward the moon (core sunUtils convention). */
+    direction: Vector3;
+    /** Lit fraction of the disc, 0 new … 1 full. */
+    illumination: number;
+}
+/**
+ * Where the moon is, for the key light and the moon disc.
+ *
+ * With time of day on it is the clock's moon — the sun's own arc, `moonPhase`
+ * of a day behind (see SkySystemManager.calculateMoon). With time off there are
+ * no hours to lag by, so it is a full moon opposite the sun: set the sun below
+ * the horizon and the moon stands above it on the other side.
+ *
+ * `sunDirection` is the resolved sun (useCloudSun), so the moon is always
+ * placed against the sun that is actually drawn and lit.
+ */
+export declare function resolveMoon(timeSettings: TimeSettings | undefined, sunDirection: Vector3, out: MoonState): MoonState;
+/** Night tint for moonlight (perceived, not physical — real moonlight is
+ *  slightly red; at night the eye reads it blue). Shared by the key light and
+ *  the water so the moon lights both the same colour. */
+export declare const MOON_LIGHT_COLOR: {
+    readonly r: 0.62;
+    readonly g: 0.72;
+    readonly b: 1;
+};
+/**
+ * 0..1 strength of moonlight: the sun must be down (fades in from −1° to −8°),
+ * the moon up (−1° … 4°), scaled by how much of the disc is lit. The key light
+ * and the ocean's moon glitter both use this, so they come and go together.
+ */
+export declare function moonlightFactor(sunElevationDeg: number, moon: MoonState): number;
+//# sourceMappingURL=skyMoon.d.ts.map

package/dist/utils/skyMoon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skyMoon.d.ts","sourceRoot":"","sources":["../../src/utils/skyMoon.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAErC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAE1D,MAAM,WAAW,SAAS;IACtB,8DAA8D;IAC9D,SAAS,EAAE,OAAO,CAAC;IACnB,gDAAgD;IAChD,YAAY,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,YAAY,EAAE,YAAY,GAAG,SAAS,EAAE,YAAY,EAAE,OAAO,EAAE,GAAG,EAAE,SAAS,GAAG,SAAS,CAWpH;AAED;;yDAEyD;AACzD,eAAO,MAAM,gBAAgB;;;;CAAwC,CAAC;AAOtE;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,eAAe,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,GAAG,MAAM,CAGhF"}

package/dist/utils/skyMoon.js

@@ -0,0 +1,41 @@
+import { skySystemManager } from '@3driseai/3drise-core';
+/**
+ * Where the moon is, for the key light and the moon disc.
+ *
+ * With time of day on it is the clock's moon — the sun's own arc, `moonPhase`
+ * of a day behind (see SkySystemManager.calculateMoon). With time off there are
+ * no hours to lag by, so it is a full moon opposite the sun: set the sun below
+ * the horizon and the moon stands above it on the other side.
+ *
+ * `sunDirection` is the resolved sun (useCloudSun), so the moon is always
+ * placed against the sun that is actually drawn and lit.
+ */
+export function resolveMoon(timeSettings, sunDirection, out) {
+    if (timeSettings?.enabled) {
+        const s = skySystemManager.getState();
+        out.direction.copy(s.moonDirection);
+        out.illumination = s.moonIllumination;
+    }
+    else {
+        out.direction.copy(sunDirection).negate();
+        out.illumination = 1;
+    }
+    return out;
+}
+/** Night tint for moonlight (perceived, not physical — real moonlight is
+ *  slightly red; at night the eye reads it blue). Shared by the key light and
+ *  the water so the moon lights both the same colour. */
+export const MOON_LIGHT_COLOR = { r: 0.62, g: 0.72, b: 1.0 };
+const smooth01 = (edge0, edge1, x) => {
+    const t = Math.max(0, Math.min(1, (x - edge0) / (edge1 - edge0)));
+    return t * t * (3 - 2 * t);
+};
+/**
+ * 0..1 strength of moonlight: the sun must be down (fades in from −1° to −8°),
+ * the moon up (−1° … 4°), scaled by how much of the disc is lit. The key light
+ * and the ocean's moon glitter both use this, so they come and go together.
+ */
+export function moonlightFactor(sunElevationDeg, moon) {
+    const moonElevation = (Math.asin(Math.max(-1, Math.min(1, moon.direction.y))) * 180) / Math.PI;
+    return smooth01(-1, -8, sunElevationDeg) * smooth01(-1, 4, moonElevation) * moon.illumination;
+}

package/dist/utils/terrainHeight.d.ts

@@ -0,0 +1,4 @@
+import type { TerrainConfig } from '@3driseai/3drise-core';
+/** World height of the terrain surface at world (x, z). */
+export declare function terrainHeightAt(config: TerrainConfig, x: number, z: number, lodCell?: number): number;
+//# sourceMappingURL=terrainHeight.d.ts.map

package/dist/utils/terrainHeight.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terrainHeight.d.ts","sourceRoot":"","sources":["../../src/utils/terrainHeight.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AA6E3D,2DAA2D;AAC3D,wBAAgB,eAAe,CAAC,MAAM,EAAE,aAAa,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,OAAO,SAAI,GAAG,MAAM,CAmFhG"}

package/dist/utils/terrainHeight.js

@@ -0,0 +1,150 @@
+/**
+ * The terrain's height field on the CPU — a line-for-line port of
+ * `terrainHeightAt` in shaders/glsl/terrainCore.glsl.ts.
+ *
+ * Until this existed the shader was the only thing that knew where the ground
+ * was: nothing could stand on the terrain, and the studio camera could sit 200 m
+ * above it (or inside a hill) with no way to tell. Now the panel can put the
+ * camera on the ground and the agent can ask `env.terrain.heightAt(x, z)`.
+ *
+ * KEEP IT IN STEP WITH THE GLSL. Any change to the height field there — an
+ * octave rule, a shaping operator, a constant — must land here too, or a query
+ * and the rendered surface disagree.
+ *
+ * The hash runs through Math.fround so its fract() lands where the GPU's float32
+ * one does; everything else is plain double precision, which differs from the
+ * GPU by far less than a centimetre.
+ *
+ * `lodCell` is the shading cell, as in the shader: octaves finer than about two
+ * cells are faded out. The default is the finest clipmap cell, which is what the
+ * mesh under a camera standing on the ground is built from. Curvature is not
+ * applied — it is a view-relative bend, and is negligible within a kilometre.
+ */
+const f32 = Math.fround;
+const fract = (x) => x - Math.floor(x);
+const clamp = (x, lo, hi) => Math.min(hi, Math.max(lo, x));
+const mix = (a, b, t) => a + (b - a) * t;
+const smoothstep = (e0, e1, x) => {
+    const t = clamp((x - e0) / (e1 - e0), 0, 1);
+    return t * t * (3 - 2 * t);
+};
+/** tHash: Hoskins, float32. Returns two components in [-1, 1]. */
+function tHash(px, py) {
+    let a = f32(fract(f32(px * 0.1031)));
+    let b = f32(fract(f32(py * 0.1030)));
+    let c = f32(fract(f32(px * 0.0973)));
+    const d = f32(f32(a * f32(b + 33.33)) + f32(b * f32(c + 33.33)) + f32(c * f32(a + 33.33)));
+    a = f32(a + d);
+    b = f32(b + d);
+    c = f32(c + d);
+    // fract((p3.xx + p3.yz) * p3.zy)
+    const x = f32(fract(f32(f32(a + b) * c)));
+    const y = f32(fract(f32(f32(a + c) * b)));
+    return [-1 + 2 * x, -1 + 2 * y];
+}
+/** tNoised: gradient noise with derivative. [value, d/dx, d/dy]. */
+function tNoised(x, y) {
+    const ix = Math.floor(x), iy = Math.floor(y);
+    const fx = x - ix, fy = y - iy;
+    const ux = fx * fx * fx * (fx * (fx * 6 - 15) + 10);
+    const uy = fy * fy * fy * (fy * (fy * 6 - 15) + 10);
+    const dux = 30 * fx * fx * (fx * (fx - 2) + 1);
+    const duy = 30 * fy * fy * (fy * (fy - 2) + 1);
+    const ga = tHash(ix, iy);
+    const gb = tHash(ix + 1, iy);
+    const gc = tHash(ix, iy + 1);
+    const gd = tHash(ix + 1, iy + 1);
+    const va = ga[0] * fx + ga[1] * fy;
+    const vb = gb[0] * (fx - 1) + gb[1] * fy;
+    const vc = gc[0] * fx + gc[1] * (fy - 1);
+    const vd = gd[0] * (fx - 1) + gd[1] * (fy - 1);
+    const k = va - vb - vc + vd;
+    const v = va + ux * (vb - va) + uy * (vc - va) + ux * uy * k;
+    const dx = ga[0] + ux * (gb[0] - ga[0]) + uy * (gc[0] - ga[0]) + ux * uy * (ga[0] - gb[0] - gc[0] + gd[0])
+        + dux * (uy * k + vb - va);
+    const dy = ga[1] + ux * (gb[1] - ga[1]) + uy * (gc[1] - ga[1]) + ux * uy * (ga[1] - gb[1] - gc[1] + gd[1])
+        + duy * (ux * k + vc - va);
+    return [v, dx, dy];
+}
+const TYPE_INDEX = { mountains: 0, dunes: 1, hills: 2, canyon: 3 };
+/** World height of the terrain surface at world (x, z). */
+export function terrainHeightAt(config, x, z, lodCell = 2) {
+    const baseScale = 1 / (config.featureSize > 1e-6 ? config.featureSize : 2600);
+    const octaves = Math.round(clamp(config.octaves, 1, 12));
+    const lacunarity = config.lacunarity;
+    const gain = config.gain;
+    const ridge = config.ridgeSharpness;
+    const warpStrength = config.warpStrength;
+    const warpScale = config.warpSize;
+    const erosion = config.erosion;
+    const elevation = Math.max(config.elevation, 0.01);
+    const type = TYPE_INDEX[config.terrainType] ?? 2;
+    let qx = x * baseScale;
+    let qy = z * baseScale;
+    if (warpStrength > 0) {
+        const w0 = tNoised(qx * warpScale + 11.3, qy * warpScale + 5.7)[0];
+        const w1 = tNoised(qx * warpScale - 7.1, qy * warpScale + 19.2)[0];
+        qx += w0 * warpStrength;
+        qy += w1 * warpStrength;
+    }
+    let amp = 1, freq = 1, sum = 0, norm = 0;
+    let sx = 0, sy = 0;
+    let wl = 1 / Math.max(baseScale, 1e-9);
+    for (let i = 0; i < 12; i++) {
+        if (i >= octaves)
+            break;
+        const fade = clamp(wl / Math.max(2 * lodCell, 1e-4) - 1, 0, 1);
+        if (fade <= 0.001)
+            break;
+        const n = tNoised(qx * freq + i * 37.13, qy * freq + i * 61.91);
+        let v = n[0];
+        let gx = n[1], gy = n[2];
+        if (ridge > 0) {
+            const ridgeAmt = ridge * clamp(i * 0.5, 0, 1);
+            const sg = Math.sign(v);
+            const r = 1 - Math.abs(v);
+            v = mix(v, r * r * 2 - 1, ridgeAmt);
+            gx = mix(gx, -4 * r * sg * gx, ridgeAmt);
+            gy = mix(gy, -4 * r * sg * gy, ridgeAmt);
+        }
+        const damp = 1 / (1 + erosion * 1.5 * (sx * sx + sy * sy));
+        sum += amp * damp * fade * v;
+        norm += amp * fade;
+        sx += gx * amp * damp;
+        sy += gy * amp * damp;
+        amp *= gain;
+        freq *= lacunarity;
+        wl /= lacunarity;
+    }
+    const t = (sum / Math.max(norm, 1e-4)) * 3.2;
+    let h = 0.5 + 0.5 * t / Math.sqrt(1 + t * t);
+    if (type === 1) {
+        const a = (config.bearing * Math.PI) / 180;
+        let bx = Math.sin(a), by = Math.cos(a);
+        const bl = Math.hypot(bx, by) || 1;
+        bx /= bl;
+        by /= bl;
+        // d = vec2(bearingDir.y, -bearingDir.x)
+        const duneFreq = (Math.PI * 2) / Math.max(config.duneWavelength, 1);
+        const u = 0.5 + 0.5 * Math.sin((x * by + z * -bx) * duneFreq + 7 * h);
+        const s = Math.pow(Math.max(u, 1e-4), mix(1, 3.2, config.duneAsymmetry));
+        h = mix(0.15 + 0.5 * h, s * (0.45 + 0.55 * h), 0.8);
+    }
+    else if (type === 3) {
+        const om = 1 - h;
+        const mesa = mix(h, 1 - om * om * om, config.plateau);
+        const ch = 1 - Math.abs(tNoised(x * (baseScale * 1.7) + 4.2, z * (baseScale * 1.7) - 9.1)[0]);
+        h = mesa - config.valleyDepth * smoothstep(1 - config.valleyWidth, 1, ch);
+    }
+    const terraces = Math.round(config.terraces);
+    if (terraces >= 0.5) {
+        const n = terraces;
+        const featureSize = 1 / Math.max(baseScale, 1e-9);
+        const soft = clamp((lodCell * n * 8) / featureSize, 0, 1);
+        const w = Math.max(1 - 0.95 * config.terraceSharpness, 0.02);
+        const xh = h * n;
+        const fr = fract(xh);
+        h = (Math.floor(xh) + mix(smoothstep(0, w, fr), fr, soft)) / n;
+    }
+    return config.seaLevel + elevation * h;
+}

package/dist/utils/terrainTextureResolver.d.ts

@@ -0,0 +1,18 @@
+import type { TerrainTextures } from '@3driseai/3drise-core';
+/**
+ * Turns texture-set NAMES into map URLs for terrain textures that name a set but
+ * carry no URLs yet (a land object fresh from the catalog, a ground picked before
+ * the files were uploaded).
+ *
+ * The viewer does not know the app's file tree, so the client registers the
+ * resolver (it owns the texture library) and re-registers it when the library
+ * changes; renderers subscribe to the version so they re-resolve. Without one — an
+ * embed, a test harness — the stored URLs are used as they are. Must return the
+ * SAME object when nothing changes, so renderer memos hold.
+ */
+export type TerrainTextureResolver = (textures: TerrainTextures | undefined) => TerrainTextures | undefined;
+export declare function setTerrainTextureResolver(fn: TerrainTextureResolver | null): void;
+export declare function resolveTerrainTextureSets(textures: TerrainTextures | undefined): TerrainTextures | undefined;
+/** Changes whenever the resolver does: a memo dependency for resolved textures. */
+export declare function useTerrainTextureResolverVersion(): number;
+//# sourceMappingURL=terrainTextureResolver.d.ts.map

package/dist/utils/terrainTextureResolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terrainTextureResolver.d.ts","sourceRoot":"","sources":["../../src/utils/terrainTextureResolver.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE7D;;;;;;;;;;GAUG;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,QAAQ,EAAE,eAAe,GAAG,SAAS,KAAK,eAAe,GAAG,SAAS,CAAC;AAM5G,wBAAgB,yBAAyB,CAAC,EAAE,EAAE,sBAAsB,GAAG,IAAI,GAAG,IAAI,CAIjF;AAED,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,eAAe,GAAG,SAAS,GAAG,eAAe,GAAG,SAAS,CAE5G;AAED,mFAAmF;AACnF,wBAAgB,gCAAgC,IAAI,MAAM,CAMzD"}

package/dist/utils/terrainTextureResolver.js

@@ -0,0 +1,17 @@
+import { useSyncExternalStore } from 'react';
+let resolver = null;
+let version = 0;
+const listeners = new Set();
+export function setTerrainTextureResolver(fn) {
+    resolver = fn;
+    version++;
+    for (const l of listeners)
+        l();
+}
+export function resolveTerrainTextureSets(textures) {
+    return resolver ? (resolver(textures) ?? textures) : textures;
+}
+/** Changes whenever the resolver does: a memo dependency for resolved textures. */
+export function useTerrainTextureResolverVersion() {
+    return useSyncExternalStore((l) => { listeners.add(l); return () => { listeners.delete(l); }; }, () => version, () => version);
+}

package/dist/utils/terrainUniforms.d.ts

@@ -1,8 +1,25 @@
 import * as THREE from 'three';
 import type { TerrainConfig, TerrainQualityConfig } from '@3driseai/3drise-core';
+import type { TerrainTextureState } from '../hooks/useTerrainTextures';
 import type { CloudSunState } from '../hooks/useCloudSun';
 export declare function applyTerrainUniforms(material: THREE.ShaderMaterial, config: TerrainConfig, quality: TerrainQualityConfig): void;
 export default applyTerrainUniforms;
+/**
+ * The texture layer uniforms, and the TERRAIN_TEXTURED define.
+ *
+ * Called every frame after `applyTerrainUniforms`, like it, so tile size, tint,
+ * brightness and normal strength are live.
+ *
+ * A textured layer is the set's own colours, brought to the luminance of the
+ * layer's tuned colour, × tint × brightness. Its far colour —
+ * what the near field fades into past the texture distance — is the texture's mean
+ * × the same factors, so the fade has nothing to jump. An untextured layer is its
+ * flat hex colour, near and far.
+ *
+ * The define only flips when the arrays arrive or go, so the recompile happens
+ * once per texture change, never per frame.
+ */
+export declare function applyTerrainTextures(material: THREE.ShaderMaterial, config: TerrainConfig, tex: TerrainTextureState): void;
 /** skyRadiance(rd), in the units the shader returns. */
 export declare function skyRadianceAt(rd: THREE.Vector3, sun: CloudSunState, out: THREE.Color): THREE.Color;
 /**

package/dist/utils/terrainUniforms.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"terrainUniforms.d.ts","sourceRoot":"","sources":["../../src/utils/terrainUniforms.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAe,MAAM,uBAAuB,CAAC;AAC9F,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAoD1D,wBAAgB,oBAAoB,CAChC,QAAQ,EAAE,KAAK,CAAC,cAAc,EAC9B,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,oBAAoB,GAC9B,IAAI,CAwDN;AAED,eAAe,oBAAoB,CAAC;AAiCpC,wDAAwD;AACxD,wBAAgB,aAAa,CAAC,EAAE,EAAE,KAAK,CAAC,OAAO,EAAE,GAAG,EAAE,aAAa,EAAE,GAAG,EAAE,KAAK,CAAC,KAAK,GAAG,KAAK,CAAC,KAAK,CA4BlG;AAMD;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,KAAK,CAAC,cAAc,EAAE,GAAG,EAAE,aAAa,GAAG,IAAI,CAwC5F"}
+{"version":3,"file":"terrainUniforms.d.ts","sourceRoot":"","sources":["../../src/utils/terrainUniforms.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,aAAa,EAAE,oBAAoB,EAAe,MAAM,uBAAuB,CAAC;AAE9F,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AACvE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAoD1D,wBAAgB,oBAAoB,CAChC,QAAQ,EAAE,KAAK,CAAC,cAAc,EAC9B,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,oBAAoB,GAC9B,IAAI,CAwDN;AAED,eAAe,oBAAoB,CAAC;AAUpC;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,oBAAoB,CAChC,QAAQ,EAAE,KAAK,CAAC,cAAc,EAC9B,MAAM,EAAE,aAAa,EACrB,GAAG,EAAE,mBAAmB,GACzB,IAAI,CAyDN;AAiCD,wDAAwD;AACxD,wBAAgB,aAAa,CAAC,EAAE,EAAE,KAAK,CAAC,OAAO,EAAE,GAAG,EAAE,aAAa,EAAE,GAAG,EAAE,KAAK,CAAC,KAAK,GAAG,KAAK,CAAC,KAAK,CA4BlG;AAMD;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,KAAK,CAAC,cAAc,EAAE,GAAG,EAAE,aAAa,GAAG,IAAI,CAwC5F"}

package/dist/utils/terrainUniforms.js

@@ -1,4 +1,5 @@
 import * as THREE from 'three';
+import { TERRAIN_LAYER_KEYS } from '@3driseai/3drise-core';
 /**
  * Config to uniform mapping for the terrain material.
  *
@@ -98,6 +99,89 @@ export function applyTerrainUniforms(material, config, quality) {
 }
 export default applyTerrainUniforms;
 // -----------------------------------------------------------------------------
+// Ground textures
+// -----------------------------------------------------------------------------
+const _flat = new THREE.Color();
+const luma = (r, g, b) => 0.2126 * r + 0.7152 * g + 0.0722 * b;
+const LAYER_COLOR_KEY = ['lowColor', 'midColor', 'rockColor', 'peakColor'];
+/**
+ * The texture layer uniforms, and the TERRAIN_TEXTURED define.
+ *
+ * Called every frame after `applyTerrainUniforms`, like it, so tile size, tint,
+ * brightness and normal strength are live.
+ *
+ * A textured layer is the set's own colours, brought to the luminance of the
+ * layer's tuned colour, × tint × brightness. Its far colour —
+ * what the near field fades into past the texture distance — is the texture's mean
+ * × the same factors, so the fade has nothing to jump. An untextured layer is its
+ * flat hex colour, near and far.
+ *
+ * The define only flips when the arrays arrive or go, so the recompile happens
+ * once per texture change, never per frame.
+ */
+export function applyTerrainTextures(material, config, tex) {
+    const u = material.uniforms;
+    if (!u || !u.u_tFar)
+        return;
+    const textures = config.textures;
+    const far = u.u_tFar.value;
+    const layer = u.u_tLayer.value;
+    const tint = u.u_tTint.value;
+    let any = false;
+    TERRAIN_LAYER_KEYS.forEach((key, i) => {
+        const t = textures?.[key];
+        const textured = !!(tex.ready && tex.textured[i]);
+        any = any || textured;
+        if (textured) {
+            const m = tex.meanColor[i];
+            // Exposure: scans are photographed at any brightness, so a textured
+            // layer is first brought to the LUMINANCE of the layer's tuned colour
+            // (the biome sets it), keeping the scan's own hue and detail. Then the
+            // user's brightness and tint act on top of that.
+            _flat.setStyle(config[LAYER_COLOR_KEY[i]], THREE.SRGBColorSpace);
+            const auto = THREE.MathUtils.clamp(luma(_flat.r, _flat.g, _flat.b) / Math.max(luma(m.x, m.y, m.z), 1e-3), 0.25, 4);
+            _flat.setStyle(t?.tint || '#ffffff', THREE.SRGBColorSpace);
+            const k = Math.max(t?.brightness ?? 1, 0) * auto;
+            tint[i].setRGB(_flat.r * k, _flat.g * k, _flat.b * k);
+            far[i].setRGB(m.x * tint[i].r, m.y * tint[i].g, m.z * tint[i].b);
+        }
+        else {
+            _flat.setStyle(config[LAYER_COLOR_KEY[i]], THREE.SRGBColorSpace);
+            far[i].copy(_flat);
+            tint[i].setRGB(1, 1, 1);
+        }
+        layer[i].set(1 / Math.max(t?.tileSize ?? 3, 0.05), t?.normalStrength ?? 1, textured ? 1 : 0, 0);
+    });
+    if (any) {
+        u.u_tColor.value = tex.color;
+        u.u_tNormal.value = tex.normal;
+        u.u_tOrm.value = tex.orm;
+        const mc = u.u_tMeanC.value;
+        const mn = u.u_tMeanN.value;
+        const mo = u.u_tMeanO.value;
+        for (let i = 0; i < 4; i++) {
+            const c = tex.meanColor[i], n = tex.meanNormal[i], o = tex.meanOrm[i];
+            if (c)
+                mc[i].set(c.x, c.y, c.z, 1);
+            if (n)
+                mn[i].set(n.x, n.y, n.z, 0.5);
+            if (o)
+                mo[i].set(o.x, o.y, o.z, 1);
+        }
+    }
+    u.u_tDistance.value = Math.max(config.textureDistance ?? 1500, 1);
+    u.u_tHeightBlend.value = THREE.MathUtils.clamp(config.textureHeightBlend ?? 0.7, 0, 1);
+    const defines = (material.defines ??= {});
+    const has = 'TERRAIN_TEXTURED' in defines;
+    if (any !== has) {
+        if (any)
+            defines.TERRAIN_TEXTURED = '';
+        else
+            delete defines.TERRAIN_TEXTURED;
+        material.needsUpdate = true;
+    }
+}
+// -----------------------------------------------------------------------------
 // Ambient
 // -----------------------------------------------------------------------------
 /**

package/dist/utils/textureArrays.d.ts

@@ -0,0 +1,29 @@
+import * as THREE from 'three';
+export declare function loadArrayImage(url: string): Promise<HTMLImageElement>;
+/** Loads a URL, or resolves to null for a missing / failing one — a layer with a
+ *  missing map degrades to its fallback rather than taking the whole array down. */
+export declare function loadArrayImageOrNull(url: string | undefined | null): Promise<HTMLImageElement | null>;
+/** Where one output channel of one layer comes from. */
+export interface ChannelSource {
+    image: HTMLImageElement | null;
+    /** Source channel to read, 0..3. Grayscale maps: 0. */
+    channel?: number;
+    /** Byte written when there is no image. */
+    fallback: number;
+}
+/** One layer: four channel sources, R G B A. */
+export type LayerChannels = [ChannelSource, ChannelSource, ChannelSource, ChannelSource];
+export interface ChannelArrayResult {
+    texture: THREE.DataArrayTexture;
+    /** Mean RGB per layer, in the space the shader samples it in: linear for an
+     *  sRGB array, raw 0..1 otherwise. */
+    means: THREE.Vector3[];
+}
+/**
+ * Pack layers into one `DataArrayTexture`, each output channel taken from any
+ * channel of any image. Every image is redrawn at `size` — array layers must
+ * match and source maps never reliably do. An image used by several channels is
+ * read once.
+ */
+export declare function buildChannelArray(layers: LayerChannels[], size: number, colorSpace: THREE.ColorSpace): ChannelArrayResult;
+//# sourceMappingURL=textureArrays.d.ts.map

package/dist/utils/textureArrays.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"textureArrays.d.ts","sourceRoot":"","sources":["../../src/utils/textureArrays.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAyB9B,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAerE;AAED;oFACoF;AACpF,wBAAsB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC,CAQ3G;AA6BD,wDAAwD;AACxD,MAAM,WAAW,aAAa;IAC1B,KAAK,EAAE,gBAAgB,GAAG,IAAI,CAAA;IAC9B,uDAAuD;IACvD,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,2CAA2C;IAC3C,QAAQ,EAAE,MAAM,CAAA;CACnB;AAED,gDAAgD;AAChD,MAAM,MAAM,aAAa,GAAG,CAAC,aAAa,EAAE,aAAa,EAAE,aAAa,EAAE,aAAa,CAAC,CAAA;AAExF,MAAM,WAAW,kBAAkB;IAC/B,OAAO,EAAE,KAAK,CAAC,gBAAgB,CAAA;IAC/B;0CACsC;IACtC,KAAK,EAAE,KAAK,CAAC,OAAO,EAAE,CAAA;CACzB;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC7B,MAAM,EAAE,aAAa,EAAE,EACvB,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,KAAK,CAAC,UAAU,GAC7B,kBAAkB,CAwDpB"}

package/dist/utils/textureArrays.js

@@ -0,0 +1,140 @@
+import * as THREE from 'three';
+/**
+ * Texture arrays for splat-textured ground — shared by the terrain surface.
+ *
+ * Moved out of the landscape module (`landscapeTextures.ts`), which keeps its own
+ * copy until it is retired. Two changes on the way:
+ *
+ * - **Packing is per channel.** A layer's RGBA can be assembled from several
+ *   source images — the normal map's RGB with the displacement map's red in
+ *   alpha, or AO and roughness side by side in one ORM layer — so the terrain
+ *   pays for three arrays instead of five.
+ * - **Means are linear.** An sRGB array is decoded to linear by the sampler, so
+ *   the mean the variance-preserving stochastic blend subtracts from those samples
+ *   has to be linear too. The landscape computed it in sRGB, which biases every
+ *   stochastic blend toward a slightly wrong grey.
+ *
+ * Every image is read through a 2D canvas, so it must be CORS-clean: an image
+ * served without `Access-Control-Allow-Origin` taints the canvas and
+ * `getImageData` throws. The texture itself would render fine and only the
+ * packing fails, which is confusing — hence the explicit error.
+ */
+const imageCache = new Map();
+export function loadArrayImage(url) {
+    const cached = imageCache.get(url);
+    if (cached)
+        return cached;
+    const promise = new Promise((resolve, reject) => {
+        const image = new window.Image();
+        image.crossOrigin = 'anonymous';
+        image.onload = () => resolve(image);
+        image.onerror = () => {
+            imageCache.delete(url);
+            reject(new Error(`texture array: failed to load ${url}`));
+        };
+        image.src = url;
+    });
+    imageCache.set(url, promise);
+    return promise;
+}
+/** Loads a URL, or resolves to null for a missing / failing one — a layer with a
+ *  missing map degrades to its fallback rather than taking the whole array down. */
+export async function loadArrayImageOrNull(url) {
+    if (!url)
+        return null;
+    try {
+        return await loadArrayImage(url);
+    }
+    catch (error) {
+        console.warn(String(error));
+        return null;
+    }
+}
+function readPixels(image, size) {
+    const canvas = document.createElement('canvas');
+    canvas.width = size;
+    canvas.height = size;
+    const ctx = canvas.getContext('2d', { willReadFrequently: true });
+    if (!ctx)
+        throw new Error('texture array: no 2d context');
+    ctx.drawImage(image, 0, 0, size, size);
+    try {
+        return ctx.getImageData(0, 0, size, size).data;
+    }
+    catch {
+        throw new Error(`texture array: cannot read pixels from ${image.src} — the canvas is tainted. `
+            + 'The asset host must send Access-Control-Allow-Origin.');
+    }
+}
+/** sRGB byte -> linear float, once. */
+const SRGB_TO_LINEAR = (() => {
+    const lut = new Float32Array(256);
+    for (let i = 0; i < 256; i++) {
+        const c = i / 255;
+        lut[i] = c <= 0.04045 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+    }
+    return lut;
+})();
+/**
+ * Pack layers into one `DataArrayTexture`, each output channel taken from any
+ * channel of any image. Every image is redrawn at `size` — array layers must
+ * match and source maps never reliably do. An image used by several channels is
+ * read once.
+ */
+export function buildChannelArray(layers, size, colorSpace) {
+    const stride = size * size * 4;
+    const data = new Uint8Array(stride * Math.max(layers.length, 1));
+    const means = [];
+    const pixelCache = new Map();
+    const pixelsOf = (image) => {
+        let px = pixelCache.get(image);
+        if (!px) {
+            px = readPixels(image, size);
+            pixelCache.set(image, px);
+        }
+        return px;
+    };
+    const srgb = colorSpace === THREE.SRGBColorSpace;
+    layers.forEach((channels, layer) => {
+        const offset = layer * stride;
+        for (let c = 0; c < 4; c++) {
+            const source = channels[c];
+            if (source.image) {
+                const px = pixelsOf(source.image);
+                const from = source.channel ?? 0;
+                for (let p = 0; p < stride; p += 4)
+                    data[offset + p + c] = px[p + from];
+            }
+            else {
+                for (let p = 0; p < stride; p += 4)
+                    data[offset + p + c] = source.fallback;
+            }
+        }
+        let r = 0, g = 0, b = 0;
+        for (let p = 0; p < stride; p += 4) {
+            if (srgb) {
+                r += SRGB_TO_LINEAR[data[offset + p]];
+                g += SRGB_TO_LINEAR[data[offset + p + 1]];
+                b += SRGB_TO_LINEAR[data[offset + p + 2]];
+            }
+            else {
+                r += data[offset + p] / 255;
+                g += data[offset + p + 1] / 255;
+                b += data[offset + p + 2] / 255;
+            }
+        }
+        const n = size * size || 1;
+        means.push(new THREE.Vector3(r / n, g / n, b / n));
+    });
+    const texture = new THREE.DataArrayTexture(data, size, size, Math.max(layers.length, 1));
+    texture.format = THREE.RGBAFormat;
+    texture.type = THREE.UnsignedByteType;
+    texture.colorSpace = colorSpace;
+    texture.minFilter = THREE.LinearMipMapLinearFilter;
+    texture.magFilter = THREE.LinearFilter;
+    texture.wrapS = THREE.RepeatWrapping;
+    texture.wrapT = THREE.RepeatWrapping;
+    texture.generateMipmaps = true;
+    texture.needsUpdate = true;
+    return { texture, means };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@3driseai/3drise-viewer",
-  "version": "0.1.28",
+  "version": "0.1.29",
   "private": false,
   "type": "module",
   "main": "./dist/index.js",
@@ -39,6 +39,6 @@
   },
   "dependencies": {
     "@3driseai/3drise-common": "^1.0.1",
-    "@3driseai/3drise-core": "^1.0.21"
+    "@3driseai/3drise-core": "^1.0.22"
   }
 }