@3driseai/3drise-viewer 0.1.6 → 0.1.8

package/dist/utils/landscapeUniforms.js

@@ -0,0 +1,61 @@
+import * as THREE from 'three';
+/**
+ * Config units to shader units, once per frame.
+ *
+ * Everything the panel exposes in human units — metres, degrees, world sizes —
+ * is converted here, so the shader only ever sees reciprocals and normalised
+ * values and never divides by a uniform it could have been handed pre-divided.
+ * The same split the clouds and terrain use.
+ */
+const tmpColor = new THREE.Color();
+export function applyLandscapeMaps(uniforms, maps) {
+    uniforms.u_lsHeight.value = maps.height;
+    uniforms.u_lsHeightSize.value.copy(maps.heightSize);
+    uniforms.u_lsField.value = maps.field;
+    uniforms.u_lsGradScale.value = maps.gradScale;
+    uniforms.u_lsFieldTexel.value.set(1 / Math.max(maps.fieldSize.x, 1), 1 / Math.max(maps.fieldSize.y, 1));
+    uniforms.u_lsDiffuse.value = maps.diffuse;
+    uniforms.u_lsNormal.value = maps.normal;
+    uniforms.u_lsSplat0.value = maps.splat0;
+    uniforms.u_lsSplat1.value = maps.splat1;
+    uniforms.u_lsAo.value = maps.ao;
+    const means = uniforms.u_lsSurfMean.value;
+    for (let i = 0; i < means.length; i++) {
+        const mean = maps.means[i];
+        if (mean)
+            means[i].copy(mean);
+    }
+}
+export function applyLandscapeUniforms(uniforms, config, quality) {
+    uniforms.u_lsSmoothness.value = config.smoothness;
+    uniforms.u_lsElevation.value = config.elevationScale;
+    uniforms.u_lsElevationBias.value = config.elevationBias;
+    uniforms.u_lsSize.value = config.size;
+    uniforms.u_lsMacro.value = config.macroVariation;
+    uniforms.u_lsMacroScale.value = 1 / Math.max(config.macroSize, 1);
+    uniforms.u_lsAoIntensity.value = config.aoIntensity;
+    const auto = config.autoSplat;
+    uniforms.u_lsAuto.value.set(auto.bandWidth, auto.slopeStart, auto.slopeEnd, auto.noise);
+    uniforms.u_lsNoiseScale.value = 1 / Math.max(auto.noiseSize, 1);
+    const bands = uniforms.u_lsAutoBands.value;
+    for (let i = 0; i < bands.length; i++) {
+        // A surface with no band of its own is spread evenly through the range,
+        // so adding a layer to a preset does not stack it on top of layer zero.
+        bands[i] = auto.bands[i] ?? (bands.length > 1 ? i / (bands.length - 1) : 0);
+    }
+    const a = uniforms.u_lsSurfA.value;
+    const b = uniforms.u_lsSurfB.value;
+    const c = uniforms.u_lsSurfC.value;
+    for (let i = 0; i < a.length; i++) {
+        const surface = config.surfaces[i];
+        if (!surface)
+            continue;
+        a[i].set(Math.max(surface.repeat, 0.001), surface.normalStrength, THREE.MathUtils.clamp(surface.roughness, 0.04, 1), THREE.MathUtils.clamp(surface.heightBlend, 0, 1));
+        // Tints are authored in sRGB like every other colour in the panel, and
+        // the albedo they multiply has already been converted, so the tint has
+        // to be too — otherwise a mid grey tint darkens the ground by a stop.
+        tmpColor.set(surface.tint || '#ffffff').convertSRGBToLinear();
+        b[i].set(tmpColor.r, tmpColor.g, tmpColor.b, surface.saturation);
+        c[i].set(quality.triplanar && surface.triplanar ? 1 : 0, surface.flipNormalY ? -1 : 1, THREE.MathUtils.clamp(surface.metalness, 0, 1), quality.stochastic && surface.aperiodic ? 1 : 0);
+    }
+}

package/dist/utils/oceanUniforms.d.ts

@@ -0,0 +1,47 @@
+import * as THREE from 'three';
+import type { OceanConfig, OceanQualityConfig } from '../types/oceanConfigs';
+export interface WaveTable {
+    /** (dirX, dirZ, amplitude, wavenumber) */
+    a: THREE.Vector4[];
+    /** (angular frequency, phase, steepness Q, wavelength) */
+    b: THREE.Vector4[];
+    count: number;
+}
+/**
+ * The sea state, from wind and fetch.
+ *
+ * Fully developed Pierson-Moskowitz gives peak wavelength ~0.88 U^2 and
+ * significant height ~0.0246 U^2 for wind speed U in m/s. Fetch scales both
+ * down: the `fetchFactor` here is a fit, not a derivation — the real
+ * fetch-limited JONSWAP relations need dimensionless fetch and a peak
+ * enhancement, and none of that survives contact with a slider labelled "km".
+ * What matters is the behaviour it produces, which is the one thing everybody
+ * gets wrong about lakes: a lake in a gale has small, short, steep waves, not
+ * small oceans.
+ */
+export declare function seaState(windSpeed: number, fetchKm: number): {
+    peakLength: number;
+    significantHeight: number;
+};
+/**
+ * Build the trochoid table for a config.
+ *
+ * Components are spread geometrically from long to short about the spectral
+ * peak, weighted by Pierson-Moskowitz, then renormalised so the significant
+ * wave height is exactly what `seaState` says whatever the component count. That
+ * last step is what stops the sea changing size when somebody drags the wave
+ * count — the discretisation should cost detail, not amplitude.
+ */
+export declare function buildWaveTable(config: OceanConfig, out?: WaveTable): WaveTable;
+/**
+ * Push a config into the material.
+ *
+ * Called every frame with the live overrides merged in, exactly as
+ * `applyTerrainUniforms` is — it is a few dozen assignments and it is what lets
+ * a slider drag reach the renderer without a Redux dispatch per pointer-move.
+ * The wave table is the one thing that is not recomputed blindly: it is rebuilt
+ * only when one of the eight values it depends on changes.
+ */
+export declare function applyOceanUniforms(material: THREE.ShaderMaterial, config: OceanConfig, quality: OceanQualityConfig): void;
+export default applyOceanUniforms;
+//# sourceMappingURL=oceanUniforms.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"oceanUniforms.d.ts","sourceRoot":"","sources":["../../src/utils/oceanUniforms.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AA+B7E,MAAM,WAAW,SAAS;IACtB,0CAA0C;IAC1C,CAAC,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC;IACnB,0DAA0D;IAC1D,CAAC,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;CACjB;AAUD;;;;;;;;;;;GAWG;AACH,wBAAgB,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,iBAAiB,EAAE,MAAM,CAAA;CAAE,CAQ9G;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,GAAE,SAAwB,GAAG,SAAS,CA6F5F;AAqBD;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAC9B,QAAQ,EAAE,KAAK,CAAC,cAAc,EAC9B,MAAM,EAAE,WAAW,EACnB,OAAO,EAAE,kBAAkB,GAC5B,IAAI,CAqDN;AAED,eAAe,kBAAkB,CAAC"}

package/dist/utils/oceanUniforms.js

@@ -0,0 +1,216 @@
+import * as THREE from 'three';
+import { MAX_WAVES } from '../shaders/glsl/oceanCore.glsl.js';
+/**
+ * Config units to shader units for the ocean, and the wave table itself.
+ *
+ * The counterpart to `terrainUniforms.ts`, with one extra job: the spectrum.
+ * Everything the panel exposes is meteorology — wind speed, fetch, spread — and
+ * what the shader needs is a table of trochoids. The fit between them runs here,
+ * on the CPU, once per change rather than once per vertex.
+ *
+ * ## Why the spectrum is not evaluated in the shader
+ *
+ * Pierson-Moskowitz is an `exp` and two `pow` per component. Evaluated in the
+ * vertex loop that is 60 transcendentals per vertex before a single sine has
+ * been summed, and it produces the same numbers for every vertex in the scene,
+ * every frame, until somebody moves a slider. Baking it is not an optimisation
+ * so much as putting it where it belongs — and it is the shape the FFT phase
+ * needs anyway, where the spectrum is baked into a texture and only the phase
+ * advances per frame.
+ */
+const GRAVITY = 9.81;
+/** Deterministic per-component jitter. Same table every load, so a saved scene
+ *  looks the same tomorrow — a random one re-rolls the sea on every refresh. */
+function hash1(n) {
+    const s = Math.sin(n * 127.1 + 311.7) * 43758.5453123;
+    return s - Math.floor(s);
+}
+function emptyTable() {
+    return {
+        a: Array.from({ length: MAX_WAVES }, () => new THREE.Vector4()),
+        b: Array.from({ length: MAX_WAVES }, () => new THREE.Vector4()),
+        count: 0,
+    };
+}
+/**
+ * The sea state, from wind and fetch.
+ *
+ * Fully developed Pierson-Moskowitz gives peak wavelength ~0.88 U^2 and
+ * significant height ~0.0246 U^2 for wind speed U in m/s. Fetch scales both
+ * down: the `fetchFactor` here is a fit, not a derivation — the real
+ * fetch-limited JONSWAP relations need dimensionless fetch and a peak
+ * enhancement, and none of that survives contact with a slider labelled "km".
+ * What matters is the behaviour it produces, which is the one thing everybody
+ * gets wrong about lakes: a lake in a gale has small, short, steep waves, not
+ * small oceans.
+ */
+export function seaState(windSpeed, fetchKm) {
+    const U = Math.max(windSpeed, 0.01);
+    const fullyDevelopedKm = 0.05 * U * U + 1;
+    const fetchFactor = Math.min(Math.max(Math.pow(Math.max(fetchKm, 0.001) / fullyDevelopedKm, 0.4), 0.08), 1);
+    return {
+        peakLength: Math.max(0.88 * U * U * fetchFactor, 0.12),
+        significantHeight: Math.max(0.0246 * U * U * fetchFactor, 0.0015),
+    };
+}
+/**
+ * Build the trochoid table for a config.
+ *
+ * Components are spread geometrically from long to short about the spectral
+ * peak, weighted by Pierson-Moskowitz, then renormalised so the significant
+ * wave height is exactly what `seaState` says whatever the component count. That
+ * last step is what stops the sea changing size when somebody drags the wave
+ * count — the discretisation should cost detail, not amplitude.
+ */
+export function buildWaveTable(config, out = emptyTable()) {
+    const count = Math.max(1, Math.min(Math.round(config.waveComponents), MAX_WAVES));
+    const { peakLength, significantHeight } = seaState(config.windSpeed, config.fetch);
+    // Swell is energy that has outrun the weather that made it: longer, lower,
+    // and narrower in direction. It extends the long end of the band and
+    // reweights toward it.
+    const swell = Math.min(Math.max(config.swell, 0), 1);
+    const lengthMax = peakLength * (1 + swell * 2.2);
+    const lengthMin = Math.max(peakLength / 24, 0.08);
+    const omegaPeak = Math.sqrt((GRAVITY * 2 * Math.PI) / peakLength);
+    const bearing = (config.windBearing * Math.PI) / 180;
+    const spread = (config.directionalSpread * Math.PI) / 180;
+    const lengths = [];
+    const amps = [];
+    for (let i = 0; i < count; i++) {
+        const t = count === 1 ? 0 : i / (count - 1);
+        const wl = lengthMax * Math.pow(lengthMin / lengthMax, t);
+        const k = (2 * Math.PI) / wl;
+        const omega = Math.sqrt(GRAVITY * k);
+        // Pierson-Moskowitz density, and the band each component stands for.
+        const density = (0.0081 * GRAVITY * GRAVITY) / Math.pow(omega, 5)
+            * Math.exp(-1.25 * Math.pow(omegaPeak / omega, 4));
+        const dOmega = omega * Math.log(lengthMax / lengthMin) / Math.max(count - 1, 1) * 0.5;
+        let amp = Math.sqrt(Math.max(2 * density * dOmega, 0));
+        // Reweight toward the long end for swell.
+        amp *= 1 + swell * 1.6 * Math.pow(wl / lengthMax, 1.5);
+        lengths.push(wl);
+        amps.push(amp);
+    }
+    // Renormalise to the significant height. Hs = 4 * sqrt(sum(A^2 / 2)) for a
+    // sum of sinusoids, which is the definition that makes the number mean what
+    // an oceanographer thinks it means.
+    let variance = 0;
+    for (const a of amps)
+        variance += (a * a) / 2;
+    const sigma = Math.sqrt(Math.max(variance, 1e-12));
+    const scale = (significantHeight / 4) / sigma;
+    const steepness = Math.min(Math.max(config.steepness, 0), 1);
+    const choppiness = Math.max(config.choppiness, 0);
+    for (let i = 0; i < count; i++) {
+        const wl = lengths[i];
+        const amp = amps[i] * scale;
+        const k = (2 * Math.PI) / wl;
+        const omega = Math.sqrt(GRAVITY * k);
+        // Stratified across the spread, so the components never clump the way
+        // independent random draws do, plus a deterministic jitter so the strata
+        // are not visible as a fan of evenly spaced crests.
+        const t = count === 1 ? 0.5 : i / (count - 1);
+        const stratified = count === 1 ? 0 : ((i + 0.5) / count) * 2 - 1;
+        const jitter = (hash1(i * 3.17 + 1.7) * 2 - 1) / count;
+        const shaped = Math.sign(stratified) * Math.pow(Math.abs(stratified), 1.5) + jitter;
+        // Long waves are more directional than short ones — swell arrives as a
+        // train, chop comes from everywhere.
+        const spreadScale = 0.35 + 0.65 * t;
+        const angle = bearing + shaped * spread * spreadScale;
+        // Gerstner folds through itself past Q*A*k = 1, and the budget has to be
+        // shared across the components. Dividing by the count is the safe answer
+        // and it is too safe: the components have independent phases, so their
+        // gradients add like a random walk rather than in lockstep, and the sum
+        // of N of them grows as sqrt(N). Dividing by N therefore leaves the
+        // surface an order of magnitude below the folding limit and no amount of
+        // choppiness ever produces a breaking crest - which means no whitecaps,
+        // because the foam is read off exactly that folding.
+        //
+        // count^0.7 is measured rather than derived: across the four types at
+        // their defaults it lands the minimum Jacobian just above zero, so the
+        // sea is as choppy as it can be without folding, and pushing choppiness
+        // past 1 tips it over into genuine breaking. See the calibration note in
+        // claude/ocean-flow-plan.md.
+        const qLimit = 1 / Math.max(k * amp * Math.pow(count, 0.7), 1e-6);
+        const q = choppiness * qLimit * (0.65 + 0.35 * steepness);
+        out.a[i].set(Math.sin(angle), Math.cos(angle), amp, k);
+        out.b[i].set(omega, hash1(i * 7.31 + 4.2) * Math.PI * 2, Math.min(q, qLimit * 1.6), wl);
+    }
+    for (let i = count; i < MAX_WAVES; i++) {
+        out.a[i].set(0, 0, 0, 1);
+        out.b[i].set(0, 0, 0, 1);
+    }
+    out.count = count;
+    return out;
+}
+/** Everything the table depends on. Rebuilding it costs a few hundred flops, so
+ *  it is cheap — but it also has to be stable, or a live drag on an unrelated
+ *  slider would re-roll every phase and the sea would jump. */
+function tableSignature(c) {
+    return [
+        c.windSpeed, c.windBearing, c.fetch, c.directionalSpread,
+        c.waveComponents, c.choppiness, c.swell, c.steepness,
+    ].join(',');
+}
+const tableCache = new WeakMap();
+const _color = new THREE.Color();
+function setColor(u, key, hex) {
+    if (!u[key])
+        return;
+    u[key].value.copy(_color.set(hex));
+}
+/**
+ * Push a config into the material.
+ *
+ * Called every frame with the live overrides merged in, exactly as
+ * `applyTerrainUniforms` is — it is a few dozen assignments and it is what lets
+ * a slider drag reach the renderer without a Redux dispatch per pointer-move.
+ * The wave table is the one thing that is not recomputed blindly: it is rebuilt
+ * only when one of the eight values it depends on changes.
+ */
+export function applyOceanUniforms(material, config, quality) {
+    const u = material.uniforms;
+    if (!u)
+        return;
+    const signature = tableSignature(config);
+    let cached = tableCache.get(material);
+    if (!cached) {
+        cached = { table: emptyTable(), signature: '' };
+        tableCache.set(material, cached);
+    }
+    if (cached.signature !== signature) {
+        buildWaveTable(config, cached.table);
+        cached.signature = signature;
+        u.u_waveA.value = cached.table.a;
+        u.u_waveB.value = cached.table.b;
+        u.u_waveCount.value = cached.table.count;
+    }
+    u.u_waterLevel.value = config.seaLevel;
+    u.u_choppiness.value = config.choppiness;
+    u.u_amplitudeScale.value = Math.max(config.amplitudeScale, 0);
+    const isBody = config.host === 'object';
+    u.u_bodyHalf.value.set(isBody ? Math.max(config.size[0], 0.01) / 2 : 0, isBody ? Math.max(config.size[1], 0.01) / 2 : 0);
+    u.u_edgeFade.value = config.edgeFade;
+    setColor(u, 'u_deepColor', config.deepColor);
+    setColor(u, 'u_shallowColor', config.shallowColor);
+    setColor(u, 'u_foamColor', config.foamColor);
+    setColor(u, 'u_sssColor', config.sssColor);
+    u.u_absorption.value = config.absorption;
+    u.u_clarity.value = config.clarity;
+    u.u_roughness.value = config.roughness;
+    u.u_specular.value = config.specular;
+    u.u_sssStrength.value = config.sssStrength;
+    u.u_detailStrength.value = config.detailStrength;
+    u.u_detailScale.value = 1 / Math.max(config.detailSize, 0.01);
+    u.u_foamAmount.value = config.foamAmount;
+    u.u_foamDecay.value = config.foamDecay;
+    u.u_foamScale.value = 1 / Math.max(config.foamSize, 0.05);
+    u.u_ambientScale.value = config.ambient;
+    u.u_fogDensity.value = config.aerialPerspective;
+    u.u_exposure.value = config.exposure;
+    u.u_detailFade.value = 1 / Math.max(quality.detailFadeDistance, 1);
+    u.u_curvature.value = quality.curvature;
+    u.u_receiveShadows.value = quality.receiveShadows ? 1 : 0;
+    material.wireframe = !!quality.wireframe;
+}
+export default applyOceanUniforms;

package/dist/utils/pointsMaterialOwnership.d.ts

@@ -0,0 +1,9 @@
+import type { MaterialSettings } from '@3driseai/3drise-core';
+import type { ShaderEffect } from '@3driseai/3drise-core';
+/** The one particles variant that is built dynamically rather than by the registry. */
+export declare const SHADER_EFFECTS_VARIANT = "3dRiseShader";
+/** True when at least one shader effect is switched on. */
+export declare function hasActiveShaderEffects(effects?: ShaderEffect[] | null): boolean;
+export declare function ownsShaderEffectsMaterial(materialSettings?: MaterialSettings | null, effects?: ShaderEffect[] | null): boolean;
+export default ownsShaderEffectsMaterial;
+//# sourceMappingURL=pointsMaterialOwnership.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pointsMaterialOwnership.d.ts","sourceRoot":"","sources":["../../src/utils/pointsMaterialOwnership.ts"],"names":[],"mappings":"AA0BA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAE1D,uFAAuF;AACvF,eAAO,MAAM,sBAAsB,iBAAiB,CAAC;AAErD,2DAA2D;AAC3D,wBAAgB,sBAAsB,CAAC,OAAO,CAAC,EAAE,YAAY,EAAE,GAAG,IAAI,GAAG,OAAO,CAE/E;AAED,wBAAgB,yBAAyB,CAAC,gBAAgB,CAAC,EAAE,gBAAgB,GAAG,IAAI,EAAE,OAAO,CAAC,EAAE,YAAY,EAAE,GAAG,IAAI,GAAG,OAAO,CAM9H;AAED,eAAe,yBAAyB,CAAC"}

package/dist/utils/pointsMaterialOwnership.js

@@ -0,0 +1,14 @@
+/** The one particles variant that is built dynamically rather than by the registry. */
+export const SHADER_EFFECTS_VARIANT = '3dRiseShader';
+/** True when at least one shader effect is switched on. */
+export function hasActiveShaderEffects(effects) {
+    return Array.isArray(effects) && effects.some((effect) => effect?.enabled);
+}
+export function ownsShaderEffectsMaterial(materialSettings, effects) {
+    // Effects only exist inside the shell, so their presence decides ownership.
+    if (hasActiveShaderEffects(effects))
+        return true;
+    const variant = materialSettings?.materialVariant;
+    return !variant || variant === SHADER_EFFECTS_VARIANT;
+}
+export default ownsShaderEffectsMaterial;

package/dist/utils/rtin.d.ts

@@ -0,0 +1,63 @@
+/**
+ * RTIN — Right-Triangulated Irregular Networks.
+ *
+ * Vendored from Mapbox's MARTINI (https://github.com/mapbox/martini, ISC), which
+ * implements Evans, Kirkpatrick & Townsend, *Right-triangulated irregular
+ * networks* (2001). Rewritten in TypeScript with the two bugs the reference
+ * project's copy carries fixed, and with the winding flipped for a Y-up mesh.
+ *
+ * ## Why vendored rather than depended on
+ *
+ * `packages/*` reach the client as a hand-copied `dist`, and a fresh `npm i`
+ * wipes that copy — so every runtime dependency of this package is one more
+ * thing that has to exist in the client's `node_modules` at the right version.
+ * 250 lines with the source named is cheaper than that.
+ *
+ * ## What it does
+ *
+ * Given a square heightfield of size 2^n+1, it builds an error map over the
+ * implicit binary tree of right triangles: for every triangle, the height error
+ * introduced by *not* splitting it. `getMesh(maxError)` then walks that tree and
+ * emits only the triangles whose error exceeds the budget — dense over cliffs,
+ * nearly empty over flats, and crack-free by construction because a split is
+ * always a split of both children.
+ *
+ * The error map is the expensive half and depends only on the heightfield, so a
+ * `Tile` is built once per heightmap and `getMesh` is re-run whenever the error
+ * budget changes.
+ */
+export interface RtinMesh {
+    /** Grid coordinates, 2 per vertex, in [0, size-1]. */
+    vertices: Uint16Array;
+    /** Triangle indices, 3 per face. */
+    triangles: Uint32Array;
+}
+export declare class Rtin {
+    readonly gridSize: number;
+    readonly numTriangles: number;
+    readonly numParentTriangles: number;
+    readonly indices: Uint32Array;
+    readonly coords: Uint16Array;
+    constructor(gridSize?: number);
+    createTile(terrain: Float32Array): RtinTile;
+}
+export declare class RtinTile {
+    readonly terrain: Float32Array;
+    readonly rtin: Rtin;
+    readonly errors: Float32Array;
+    constructor(terrain: Float32Array, rtin: Rtin);
+    /** Build the error map, smallest triangles first, so a parent can take the
+     *  max of its own error and its two children's. */
+    private update;
+    /**
+     * Emit the mesh for an error budget, in the same units as the heightfield.
+     *
+     * Two passes over the same traversal: the first counts vertices and
+     * triangles so both arrays can be allocated exactly (the reference
+     * over-allocates from the maximum-resolution mesh and leaves the tail full
+     * of zeros); the second fills them.
+     */
+    getMesh(maxError?: number): RtinMesh;
+}
+export default Rtin;
+//# sourceMappingURL=rtin.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rtin.d.ts","sourceRoot":"","sources":["../../src/utils/rtin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,MAAM,WAAW,QAAQ;IACrB,sDAAsD;IACtD,QAAQ,EAAE,WAAW,CAAA;IACrB,oCAAoC;IACpC,SAAS,EAAE,WAAW,CAAA;CACzB;AAED,qBAAa,IAAI;IACb,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAA;IACnC,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAA;IAC7B,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAA;gBAEhB,QAAQ,SAAM;IAoD1B,UAAU,CAAC,OAAO,EAAE,YAAY,GAAG,QAAQ;CAG9C;AAED,qBAAa,QAAQ;IACjB,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAA;IAC9B,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAA;IACnB,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAA;gBAEjB,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,IAAI;IAW7C;uDACmD;IACnD,OAAO,CAAC,MAAM;IAmCd;;;;;;;OAOG;IACH,OAAO,CAAC,QAAQ,SAAI,GAAG,QAAQ;CAkElC;AAED,eAAe,IAAI,CAAA"}

package/dist/utils/rtin.js

@@ -0,0 +1,202 @@
+/**
+ * RTIN — Right-Triangulated Irregular Networks.
+ *
+ * Vendored from Mapbox's MARTINI (https://github.com/mapbox/martini, ISC), which
+ * implements Evans, Kirkpatrick & Townsend, *Right-triangulated irregular
+ * networks* (2001). Rewritten in TypeScript with the two bugs the reference
+ * project's copy carries fixed, and with the winding flipped for a Y-up mesh.
+ *
+ * ## Why vendored rather than depended on
+ *
+ * `packages/*` reach the client as a hand-copied `dist`, and a fresh `npm i`
+ * wipes that copy — so every runtime dependency of this package is one more
+ * thing that has to exist in the client's `node_modules` at the right version.
+ * 250 lines with the source named is cheaper than that.
+ *
+ * ## What it does
+ *
+ * Given a square heightfield of size 2^n+1, it builds an error map over the
+ * implicit binary tree of right triangles: for every triangle, the height error
+ * introduced by *not* splitting it. `getMesh(maxError)` then walks that tree and
+ * emits only the triangles whose error exceeds the budget — dense over cliffs,
+ * nearly empty over flats, and crack-free by construction because a split is
+ * always a split of both children.
+ *
+ * The error map is the expensive half and depends only on the heightfield, so a
+ * `Tile` is built once per heightmap and `getMesh` is re-run whenever the error
+ * budget changes.
+ */
+export class Rtin {
+    gridSize;
+    numTriangles;
+    numParentTriangles;
+    indices;
+    coords;
+    constructor(gridSize = 257) {
+        this.gridSize = gridSize;
+        const tileSize = gridSize - 1;
+        if (tileSize & (tileSize - 1)) {
+            throw new Error(`Expected grid size to be 2^n+1, got ${gridSize}.`);
+        }
+        this.numTriangles = tileSize * tileSize * 2 - 2;
+        this.numParentTriangles = this.numTriangles - tileSize * tileSize;
+        this.indices = new Uint32Array(gridSize * gridSize);
+        this.coords = new Uint16Array(this.numTriangles * 4);
+        // Triangle coordinates recovered from the index in the implicit binary
+        // tree: descend from the root pair, halving the hypotenuse each step.
+        for (let i = 0; i < this.numTriangles; i++) {
+            let id = i + 2;
+            let ax = 0;
+            let ay = 0;
+            let bx = 0;
+            let by = 0;
+            let cx = 0;
+            let cy = 0;
+            if (id & 1) {
+                bx = by = cx = tileSize;
+            }
+            else {
+                ax = ay = cy = tileSize;
+            }
+            while ((id >>= 1) > 1) {
+                const mx = (ax + bx) >> 1;
+                const my = (ay + by) >> 1;
+                if (id & 1) {
+                    bx = ax;
+                    by = ay;
+                    ax = cx;
+                    ay = cy;
+                }
+                else {
+                    ax = bx;
+                    ay = by;
+                    bx = cx;
+                    by = cy;
+                }
+                cx = mx;
+                cy = my;
+            }
+            const k = i * 4;
+            this.coords[k + 0] = ax;
+            this.coords[k + 1] = ay;
+            this.coords[k + 2] = bx;
+            this.coords[k + 3] = by;
+        }
+    }
+    createTile(terrain) {
+        return new RtinTile(terrain, this);
+    }
+}
+export class RtinTile {
+    terrain;
+    rtin;
+    errors;
+    constructor(terrain, rtin) {
+        const size = rtin.gridSize;
+        if (terrain.length !== size * size) {
+            throw new Error(`Expected terrain data of length ${size * size}, got ${terrain.length}.`);
+        }
+        this.terrain = terrain;
+        this.rtin = rtin;
+        this.errors = new Float32Array(terrain.length);
+        this.update();
+    }
+    /** Build the error map, smallest triangles first, so a parent can take the
+     *  max of its own error and its two children's. */
+    update() {
+        const { numTriangles, numParentTriangles, coords, gridSize: size } = this.rtin;
+        const { terrain, errors } = this;
+        for (let i = numTriangles - 1; i >= 0; i--) {
+            const k = i * 4;
+            const ax = coords[k + 0];
+            const ay = coords[k + 1];
+            const bx = coords[k + 2];
+            const by = coords[k + 3];
+            const mx = (ax + bx) >> 1;
+            const my = (ay + by) >> 1;
+            const cx = mx + my - ay;
+            const cy = my + ax - mx;
+            // Error at the midpoint of the hypotenuse: what interpolating across
+            // it would get wrong.
+            const interpolated = (terrain[ay * size + ax] + terrain[by * size + bx]) / 2;
+            const middleIndex = my * size + mx;
+            const middleError = Math.abs(interpolated - terrain[middleIndex]);
+            errors[middleIndex] = Math.max(errors[middleIndex], middleError);
+            if (i < numParentTriangles) {
+                const leftChild = ((ay + cy) >> 1) * size + ((ax + cx) >> 1);
+                const rightChild = ((by + cy) >> 1) * size + ((bx + cx) >> 1);
+                errors[middleIndex] = Math.max(errors[middleIndex], errors[leftChild], errors[rightChild]);
+            }
+        }
+    }
+    /**
+     * Emit the mesh for an error budget, in the same units as the heightfield.
+     *
+     * Two passes over the same traversal: the first counts vertices and
+     * triangles so both arrays can be allocated exactly (the reference
+     * over-allocates from the maximum-resolution mesh and leaves the tail full
+     * of zeros); the second fills them.
+     */
+    getMesh(maxError = 0) {
+        const { gridSize: size, indices } = this.rtin;
+        const { errors } = this;
+        const max = size - 1;
+        let numVertices = 0;
+        let numTriangles = 0;
+        indices.fill(0);
+        const countElements = (ax, ay, bx, by, cx, cy) => {
+            const mx = (ax + bx) >> 1;
+            const my = (ay + by) >> 1;
+            if (Math.abs(ax - cx) + Math.abs(ay - cy) > 1 && errors[my * size + mx] > maxError) {
+                countElements(cx, cy, ax, ay, mx, my);
+                countElements(bx, by, cx, cy, mx, my);
+            }
+            else {
+                indices[ay * size + ax] = indices[ay * size + ax] || ++numVertices;
+                indices[by * size + bx] = indices[by * size + bx] || ++numVertices;
+                indices[cy * size + cx] = indices[cy * size + cx] || ++numVertices;
+                numTriangles++;
+            }
+        };
+        countElements(0, 0, max, max, max, 0);
+        countElements(max, max, 0, 0, 0, max);
+        const vertices = new Uint16Array(numVertices * 2);
+        const triangles = new Uint32Array(numTriangles * 3);
+        let triIndex = 0;
+        const processTriangle = (ax, ay, bx, by, cx, cy) => {
+            const mx = (ax + bx) >> 1;
+            const my = (ay + by) >> 1;
+            if (Math.abs(ax - cx) + Math.abs(ay - cy) > 1 && errors[my * size + mx] > maxError) {
+                processTriangle(cx, cy, ax, ay, mx, my);
+                processTriangle(bx, by, cx, cy, mx, my);
+            }
+            else {
+                const a = indices[ay * size + ax] - 1;
+                const b = indices[by * size + bx] - 1;
+                const c = indices[cy * size + cx] - 1;
+                vertices[2 * a] = ax;
+                vertices[2 * a + 1] = ay;
+                vertices[2 * b] = bx;
+                vertices[2 * b + 1] = by;
+                vertices[2 * c] = cx;
+                vertices[2 * c + 1] = cy;
+                // Winding is emitted as RTIN produces it, and that is correct
+                // for grid Y mapped to world +Z. Reasoning about the handedness
+                // flip on paper gives the opposite answer and it is wrong: the
+                // first version reversed each triangle here, and the tile was
+                // then visible only from BELOW because every face was a
+                // backface. Found by rendering it, not by reading it. The
+                // reference project reverses the whole index array in place
+                // instead, which mutates the tile's own buffer and flips back
+                // the second time it runs.
+                triangles[triIndex++] = a;
+                triangles[triIndex++] = b;
+                triangles[triIndex++] = c;
+            }
+        };
+        processTriangle(0, 0, max, max, max, 0);
+        processTriangle(max, max, 0, 0, 0, max);
+        return { vertices, triangles };
+    }
+}
+export default Rtin;

package/dist/utils/terrainUniforms.d.ts

@@ -0,0 +1,14 @@
+import * as THREE from 'three';
+import type { TerrainConfig, TerrainQualityConfig } from '../types/terrainConfigs';
+import type { CloudSunState } from '../hooks/useCloudSun';
+export declare function applyTerrainUniforms(material: THREE.ShaderMaterial, config: TerrainConfig, quality: TerrainQualityConfig): void;
+export default applyTerrainUniforms;
+/** skyRadiance(rd), in the units the shader returns. */
+export declare function skyRadianceAt(rd: THREE.Vector3, sun: CloudSunState, out: THREE.Color): THREE.Color;
+/**
+ * Sets the two ambient uniforms. Call after `applySunUniforms`, which fills them
+ * from the cloud curve — this overwrites that with the sky the terrain is actually
+ * standing under.
+ */
+export declare function applyTerrainAmbient(material: THREE.ShaderMaterial, sun: CloudSunState): void;
+//# sourceMappingURL=terrainUniforms.d.ts.map

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

@@ -0,0 +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,yBAAyB,CAAC;AAChG,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"}