@3driseai/3drise-viewer 0.1.28 → 0.1.30

package/dist/utils/renderedSky.js

@@ -0,0 +1,57 @@
+import { Vector3 } from 'three';
+import { sunDirectionFromAngles } from '@3driseai/3drise-core';
+const rendered = new WeakMap();
+export function publishRenderedSky(scene, values) {
+    let out = rendered.get(scene);
+    if (!out) {
+        out = { ...values, sunDirection: new Vector3() };
+        rendered.set(scene, out);
+    }
+    out.turbidity = values.turbidity;
+    out.rayleigh = values.rayleigh;
+    out.mieCoefficient = values.mieCoefficient;
+    out.mieDirectionalG = values.mieDirectionalG;
+    out.elevation = values.elevation;
+    out.azimuth = values.azimuth;
+    sunDirectionFromAngles(values.elevation, values.azimuth, out.sunDirection);
+}
+export function clearRenderedSky(scene) {
+    rendered.delete(scene);
+}
+export function getRenderedSky(scene) {
+    return rendered.get(scene);
+}
+/**
+ * Who owns the sun light. While a sky is active, SkySystem's key light (SunLight)
+ * is the scene's sun; the general lighting rig (LightsManager) keeps its ambient
+ * but turns its own `sun` off, so a scene never has two shadow-casting suns
+ * pointing different ways. A scene with no sky keeps LightsManager's sun as is.
+ *
+ * Counted, not a flag: a remount (the sky mode switching) claims before the old
+ * light releases.
+ */
+const sunClaims = new WeakMap();
+export function claimSceneSun(scene) {
+    sunClaims.set(scene, (sunClaims.get(scene) ?? 0) + 1);
+    let released = false;
+    return () => {
+        if (released)
+            return;
+        released = true;
+        const n = (sunClaims.get(scene) ?? 1) - 1;
+        if (n > 0)
+            sunClaims.set(scene, n);
+        else
+            sunClaims.delete(scene);
+    };
+}
+export function skyOwnsSun(scene) {
+    return (sunClaims.get(scene) ?? 0) > 0;
+}
+/** The scene an object lives in (its top-most ancestor). */
+export function sceneOf(object) {
+    let o = object;
+    while (o.parent)
+        o = o.parent;
+    return o;
+}

package/dist/utils/shapes.d.ts

@@ -39,6 +39,10 @@ export interface ShapeOptions {
     tube?: number;
     size?: number;
     text?: string;
+    /** text: packed outline font id, extra letter advance (em), bevel on/off */
+    font?: string;
+    letterSpacing?: number;
+    bevelEnabled?: boolean;
     vertices?: number[];
     indices?: number[];
     normals?: number[];

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

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

package/dist/utils/shapes.js

@@ -1,5 +1,6 @@
 import { BoxGeometry, BufferGeometry, CapsuleGeometry, ConeGeometry, CylinderGeometry, DodecahedronGeometry, ExtrudeGeometry, Float32BufferAttribute, IcosahedronGeometry, OctahedronGeometry, Path, PlaneGeometry, RingGeometry, Shape, ShapeGeometry, SphereGeometry, TetrahedronGeometry, TorusGeometry, } from 'three';
 import { mergeGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
+import { buildTextGeometry, outlineFontSync } from './textShape.js';
 const safeNumber = (value, fallback, min) => {
     const num = typeof value === 'number' && !Number.isNaN(value) ? value : fallback;
     return min !== undefined ? Math.max(num, min) : num;
@@ -175,7 +176,9 @@ export const shapeGenerators = {
     octahedron: ({ radius, detail }) => new OctahedronGeometry(safeNumber(radius, 0.5, 0.0001), safeNumber(detail, 0, 0)),
     tetrahedron: ({ radius, detail }) => new TetrahedronGeometry(safeNumber(radius, 0.5, 0.0001), safeNumber(detail, 0, 0)),
     dodecahedron: ({ radius, detail }) => new DodecahedronGeometry(safeNumber(radius, 0.5, 0.0001), safeNumber(detail, 0, 0)),
-    text: ({ text = 'Hello', size, height }) => new BoxGeometry(text.length * safeNumber(size, 1, 0.0001) * 0.6, safeNumber(size, 1, 0.0001), safeNumber(height, 0.2, 0.0001)),
+    // the string extruded from a packed outline font (utils/textShape); empty until the font has loaded,
+    // GeometryShape re-renders when it lands
+    text: (o) => { const f = outlineFontSync(o.font); return f ? buildTextGeometry(f, o) : new BufferGeometry(); },
     point: ({ size }) => new SphereGeometry(safeNumber(size, 0.1, 0.0001), 16, 16),
     custom: ({ vertices = [], indices = [], normals, uvs }) => {
         const geometry = new BufferGeometry();

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/textShape.d.ts

@@ -0,0 +1,24 @@
+import { BufferGeometry } from 'three';
+export declare const DEFAULT_TEXT_SHAPE_FONT = "inter";
+export declare const isOutlineFontLoaded: (id: string | undefined) => boolean;
+/** The packed outline font when it is already loaded, else null (and the load is started). */
+export declare function outlineFontSync(id: string | undefined): any | null;
+/** Loads (once) and caches a packed outline font. */
+export declare function loadOutlineFont(id: string | undefined): Promise<any>;
+export interface TextShapeOptions {
+    text?: string;
+    font?: string;
+    /** Em size in world units. */
+    size?: number;
+    /** Extrusion depth in world units. */
+    height?: number;
+    /** Extra advance between letters, in em. */
+    letterSpacing?: number;
+    bevelEnabled?: boolean;
+    bevelThickness?: number;
+    bevelSize?: number;
+    bevelSegments?: number;
+}
+/** The string as an extruded, centred geometry. `font` is a loaded packed outline font (outlineFontSync / loadOutlineFont). */
+export declare function buildTextGeometry(font: any, o: TextShapeOptions): BufferGeometry;
+//# sourceMappingURL=textShape.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"textShape.d.ts","sourceRoot":"","sources":["../../src/utils/textShape.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAgC,MAAM,OAAO,CAAC;AAgBrE,eAAO,MAAM,uBAAuB,UAAU,CAAC;AAG/C,eAAO,MAAM,mBAAmB,GAAI,IAAI,MAAM,GAAG,SAAS,KAAG,OAAgC,CAAC;AAE9F,8FAA8F;AAC9F,wBAAgB,eAAe,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,GAAG,GAAG,GAAG,IAAI,CAMlE;AAED,qDAAqD;AACrD,wBAAgB,eAAe,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC,GAAG,CAAC,CAUpE;AAED,MAAM,WAAW,gBAAgB;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,8BAA8B;IAC9B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,sCAAsC;IACtC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,4CAA4C;IAC5C,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,MAAM,CAAC;CAC1B;AAqBD,+HAA+H;AAC/H,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,EAAE,gBAAgB,GAAG,cAAc,CAgChF"}

package/dist/utils/textShape.js

@@ -0,0 +1,102 @@
+import { BufferGeometry, ExtrudeGeometry, Path, Shape } from 'three';
+import { layoutOutline } from '../components/text/engine/glyphs.js';
+import { loadOutline, TEXT_FONT_IDS } from '../components/text/fonts/index.js';
+// =============================================================================
+// Mesh text — the `text` shape of the mesh family: the string extruded into a solid, from the same packed
+// outline fonts the text looks use (components/text/fonts), so one font list serves every text in 3drise.
+//
+// The outline fonts load lazily (one import() per font, a few hundred KB each). Shape generators are
+// synchronous, so a font is read from this cache; the first build of a font yields an empty geometry and
+// starts the load, and GeometryShape re-renders once it lands (useTextShapeFont).
+// =============================================================================
+const fonts = new Map();
+const pending = new Map();
+export const DEFAULT_TEXT_SHAPE_FONT = 'inter';
+const fontId = (id) => (id && TEXT_FONT_IDS.includes(id) ? id : DEFAULT_TEXT_SHAPE_FONT);
+export const isOutlineFontLoaded = (id) => fonts.has(fontId(id));
+/** The packed outline font when it is already loaded, else null (and the load is started). */
+export function outlineFontSync(id) {
+    const k = fontId(id);
+    const f = fonts.get(k);
+    if (f)
+        return f;
+    void loadOutlineFont(k);
+    return null;
+}
+/** Loads (once) and caches a packed outline font. */
+export function loadOutlineFont(id) {
+    const k = fontId(id);
+    const f = fonts.get(k);
+    if (f)
+        return Promise.resolve(f);
+    let p = pending.get(k);
+    if (!p) {
+        p = loadOutline(k).then((font) => { fonts.set(k, font); pending.delete(k); return font; });
+        pending.set(k, p);
+    }
+    return p;
+}
+// even-odd point in polygon (flat [x, y, ...] array)
+function inside(px, py, p) {
+    let c = false;
+    const n = p.length / 2;
+    for (let i = 0, j = n - 1; i < n; j = i++) {
+        const xi = p[2 * i], yi = p[2 * i + 1], xj = p[2 * j], yj = p[2 * j + 1];
+        if (((yi > py) !== (yj > py)) && (px < ((xj - xi) * (py - yi)) / (yj - yi) + xi))
+            c = !c;
+    }
+    return c;
+}
+const pathOf = (pts, P, s) => {
+    // layoutOutline closes every contour by repeating its first point: drop it, Shape closes itself
+    const n = pts.length / 2 - 1;
+    P.moveTo(pts[0] * s, pts[1] * s);
+    for (let i = 1; i < n; i++)
+        P.lineTo(pts[2 * i] * s, pts[2 * i + 1] * s);
+    P.closePath();
+    return P;
+};
+/** The string as an extruded, centred geometry. `font` is a loaded packed outline font (outlineFontSync / loadOutlineFont). */
+export function buildTextGeometry(font, o) {
+    const size = Math.max(1e-4, o.size ?? 1), depth = Math.max(1e-4, o.height ?? 0.2);
+    const text = String(o.text ?? 'Hello');
+    const layout = layoutOutline(font, text.length ? text : ' ', { align: 'center', letterSpacing: o.letterSpacing ?? 0 });
+    const shapes = [];
+    // contours come per glyph, outer first then counters (layoutOutline sorts them so); a counter belongs to the
+    // outer contour of its glyph that contains it
+    const byGlyph = new Map();
+    for (const s of layout.strokes) {
+        let g = byGlyph.get(s.glyph);
+        if (!g) {
+            g = { outers: [], holes: [] };
+            byGlyph.set(s.glyph, g);
+        }
+        if (s.hole)
+            g.holes.push(s.pts);
+        else {
+            const shape = pathOf(s.pts, new Shape(), size);
+            g.outers.push({ pts: s.pts, shape });
+            shapes.push(shape);
+        }
+    }
+    for (const g of byGlyph.values()) {
+        if (!g.outers.length)
+            continue;
+        for (const h of g.holes) {
+            const owner = g.outers.find((oc) => inside(h[0], h[1], oc.pts.subarray(0, oc.pts.length - 2))) ?? g.outers[0];
+            owner.shape.holes.push(pathOf(h, new Path(), size));
+        }
+    }
+    if (!shapes.length)
+        return new BufferGeometry();
+    const bevel = !!o.bevelEnabled;
+    const geo = new ExtrudeGeometry(shapes, {
+        depth, curveSegments: 1, bevelEnabled: bevel,
+        bevelThickness: bevel ? Math.max(0, o.bevelThickness ?? 0.03) : 0,
+        bevelSize: bevel ? Math.max(0, o.bevelSize ?? 0.02) : 0,
+        bevelOffset: 0,
+        bevelSegments: bevel ? Math.max(1, Math.round(o.bevelSegments ?? 3)) : 1,
+    });
+    geo.center();
+    return geo;
+}