@3driseai/3drise-viewer 0.1.30 → 0.1.32

package/dist/shaders/glsl/terrainCore.glsl.js

@@ -26,8 +26,12 @@
  *    per octave, nine octaves, several evaluations per pixel puts it into the
  *    billions of transcendentals per frame.
  */
-/** Every uniform the height field and the shading read. */
-export const terrainUniforms = /* glsl */ `
+/**
+ * The uniforms the height field and the sun-shadow march read — and nothing else,
+ * so another material (the ocean) can include the field without redeclaring its
+ * own u_curvature, u_exposure, u_roughness… GLSL refuses a uniform declared twice.
+ */
+export const terrainFormUniforms = /* glsl */ `
 uniform int   u_terrainType;
 
 uniform float u_elevation;
@@ -49,6 +53,29 @@ uniform float u_plateau;
 uniform float u_valleyDepth;
 uniform float u_valleyWidth;
 
+// The analytic sun-shadow march (terrainShadow) - shared with the ocean, which
+// marches the same field to put headland shadows on the water.
+uniform float u_sunShadow, u_shadowSoftness;
+uniform float u_shadowDistance;
+uniform int   u_shadowSteps;
+
+// A land object: a bounded patch of this field, placed by its object's transform.
+// Its "terrain space" is metres from the object's origin, unrotated, plus a seed
+// offset; height is above the object's base. See TerrainMaterial's patch vertex.
+#ifdef TERRAIN_PATCH
+uniform vec2  u_patchSize;      // footprint in metres (object scale x / z)
+uniform vec2  u_patchOffset;    // terrain-space centre: the seed's offset into the field
+uniform float u_edgeWidth;      // metres over which the land eases down to its base
+uniform vec3  u_camTerrain;     // the camera, in terrain space
+uniform float u_scaleY;         // object scale y: terrain metres = local y x this
+uniform float u_patchCell;      // metres per grid cell
+#define TERRAIN_CAM u_camTerrain
+#else
+#define TERRAIN_CAM cameraPosition
+#endif
+`;
+/** The terrain surface's own uniforms: shading, lighting, textures. */
+export const terrainSurfaceUniforms = /* glsl */ `
 uniform float u_cellSize;
 uniform float u_curvature;
 
@@ -66,10 +93,8 @@ uniform float u_roughness, u_specular;
 // per pixel removes an acos, a pow and three exps from every fragment.
 uniform vec3  u_skyAmbient;
 uniform vec3  u_groundAmbient;
-uniform float u_ambient, u_bounce, u_sunShadow, u_shadowSoftness;
-uniform float u_shadowDistance;
+uniform float u_ambient, u_bounce;
 uniform float u_fogDensity, u_exposure;
-uniform int   u_shadowSteps;
 
 // Ground textures. The far colour per layer is always set: the flat colour for an
 // untextured layer, the texture's own mean x tint for a textured one, so the
@@ -88,20 +113,6 @@ uniform float u_tDistance;
 uniform float u_tHeightBlend;
 #endif
 
-// A land object: a bounded patch of this field, placed by its object's transform.
-// Its "terrain space" is metres from the object's origin, unrotated, plus a seed
-// offset; height is above the object's base. See TerrainMaterial's patch vertex.
-#ifdef TERRAIN_PATCH
-uniform vec2  u_patchSize;      // footprint in metres (object scale x / z)
-uniform vec2  u_patchOffset;    // terrain-space centre: the seed's offset into the field
-uniform float u_edgeWidth;      // metres over which the land eases down to its base
-uniform vec3  u_camTerrain;     // the camera, in terrain space
-uniform float u_scaleY;         // object scale y: terrain metres = local y x this
-uniform float u_patchCell;      // metres per grid cell
-#define TERRAIN_CAM u_camTerrain
-#else
-#define TERRAIN_CAM cameraPosition
-#endif
 `;
 /**
  * Gradient noise with an analytic derivative.
@@ -515,7 +526,7 @@ float terrainOccluderAt(vec2 p, float lodCell){ return terrainHeightAt(p, lodCel
  * The terminator itself stays per-pixel: `terrainLight` takes N·L from the
  * fragment's own normal, so only the CAST shadow is interpolated.
  */
-export const terrainShading = /* glsl */ `
+export const terrainShadow = /* glsl */ `
 /** 1 lit, 0 shadowed, soft in between. */
 float terrainSunShadow(vec3 p, vec3 n, float lodCell, int steps){
   if (steps < 1 || u_sunShadow <= 0.0) return 1.0;
@@ -585,6 +596,8 @@ float terrainShadowAt(vec3 p, vec3 n, float lodCell, float dist){
   return mix(1.0, terrainSunShadow(p, n, lodCell, steps), fade);
 }
 
+`;
+export const terrainShading = /* glsl */ `
 /**
  * Albedo.
  *
@@ -867,5 +880,13 @@ void terrainSurfaceNear(vec3 wp, vec3 n, vec4 w, TerrainGrads g,
 `;
 /** Everything a surface material needs, in include order. Requires three's
  *  `<common>` and `skyLib` from cloudCore before it. */
+/** Every uniform the terrain material reads. */
+export const terrainUniforms = [terrainFormUniforms, terrainSurfaceUniforms].join('\n');
 export const terrainField = [terrainUniforms, terrainNoise, terrainHeight].join('\n');
-export const terrainFull = [terrainField, terrainShading].join('\n');
+/**
+ * The height field and its sun-shadow march, with only the uniforms they read.
+ * What another material includes to stand water (or anything else) on the
+ * terrain: the ocean uses it for shoreline depth and headland shadows.
+ */
+export const terrainFieldOnly = [terrainFormUniforms, terrainNoise, terrainHeight, terrainShadow].join('\n');
+export const terrainFull = [terrainField, terrainShadow, terrainShading].join('\n');

package/dist/shaders/ocean/OceanSurfaceMaterial.d.ts

@@ -6,6 +6,40 @@ export interface OceanMaterialUniforms {
 /** Uniform-space defaults. Config units are converted by `applyOceanUniforms`;
  *  these are only what the material holds before anything is applied. */
 export declare const oceanMaterialDefaults: {
+    u_sunDir: THREE.Vector3;
+    u_sunColor: THREE.Color;
+    u_skyAmbient: THREE.Color;
+    u_groundAmbient: THREE.Color;
+    u_sunIntensity: number;
+    u_moonDir: THREE.Vector3;
+    u_moonColor: THREE.Color;
+    u_turbidity: number;
+    u_rayleigh: number;
+    u_mieCoefficient: number;
+    u_mieG: number;
+    u_terrainType: number;
+    u_elevation: number;
+    u_seaLevel: number;
+    u_baseScale: number;
+    u_octaves: number;
+    u_lacunarity: number;
+    u_gain: number;
+    u_ridge: number;
+    u_warpStrength: number;
+    u_warpScale: number;
+    u_erosion: number;
+    u_terraces: number;
+    u_terraceSharp: number;
+    u_bearingDir: THREE.Vector2;
+    u_duneFreq: number;
+    u_duneAsym: number;
+    u_plateau: number;
+    u_valleyDepth: number;
+    u_valleyWidth: number;
+    u_sunShadow: number;
+    u_shadowSoftness: number;
+    u_shadowDistance: number;
+    u_shadowSteps: number;
     u_waveA: THREE.Vector4[];
     u_waveB: THREE.Vector4[];
     u_waveCount: number;
@@ -36,17 +70,8 @@ export declare const oceanMaterialDefaults: {
     u_exposure: number;
     u_curvature: number;
     u_receiveShadows: number;
-    u_sunDir: THREE.Vector3;
-    u_sunColor: THREE.Color;
-    u_skyAmbient: THREE.Color;
-    u_groundAmbient: THREE.Color;
-    u_sunIntensity: number;
-    u_moonDir: THREE.Vector3;
-    u_moonColor: THREE.Color;
-    u_turbidity: number;
-    u_rayleigh: number;
-    u_mieCoefficient: number;
-    u_mieG: number;
+    u_shoreDepth: number;
+    u_shoreFoam: number;
 };
 export declare class OceanSurfaceMaterial extends THREE.ShaderMaterial {
     constructor();

package/dist/shaders/ocean/OceanSurfaceMaterial.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"OceanSurfaceMaterial.d.ts","sourceRoot":"","sources":["../../../src/shaders/ocean/OceanSurfaceMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAC9B,OAAO,EAAU,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAmM9D,MAAM,WAAW,qBAAqB;IAClC,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,CAAC,QAAQ,CAAA;CAChC;AAMD;yEACyE;AACzE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiDjC,CAAA;AAgBD,qBAAa,oBAAqB,SAAQ,KAAK,CAAC,cAAc;;CAa7D;AAID,OAAO,QAAQ,oBAAoB,CAAC;IAChC,UAAU,aAAa;QACnB,oBAAoB,EAAE,YAAY,CAAC,OAAO,oBAAoB,CAAC,CAAA;KAClE;CACJ"}
+{"version":3,"file":"OceanSurfaceMaterial.d.ts","sourceRoot":"","sources":["../../../src/shaders/ocean/OceanSurfaceMaterial.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAC9B,OAAO,EAAU,KAAK,YAAY,EAAE,MAAM,oBAAoB,CAAA;AA0R9D,MAAM,WAAW,qBAAqB;IAClC,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,CAAC,QAAQ,CAAA;CAChC;AAMD;yEACyE;AACzE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuDjC,CAAA;AAgBD,qBAAa,oBAAqB,SAAQ,KAAK,CAAC,cAAc;;CAa7D;AAID,OAAO,QAAQ,oBAAoB,CAAC;IAChC,UAAU,aAAa;QACnB,oBAAoB,EAAE,YAAY,CAAC,OAAO,oBAAoB,CAAC,CAAA;KAClE;CACJ"}

package/dist/shaders/ocean/OceanSurfaceMaterial.js

@@ -2,6 +2,7 @@ import * as THREE from 'three';
 import { extend } from '@react-three/fiber';
 import { skyLib } from '../glsl/cloudCore.glsl.js';
 import { oceanFull, MAX_WAVES } from '../glsl/oceanCore.glsl.js';
+import { terrainFieldOnly } from '../glsl/terrainCore.glsl.js';
 /**
  * The water surface material. Used by both hosts — the world clipmap and a
  * placed body — and by all four water types, which differ in the spectrum the
@@ -44,6 +45,16 @@ const vertex = /* glsl */ `
 ${skyLib}
 ${oceanFull}
 
+// The ground under the water (phase 4 of the ocean plan). Only the height field
+// and its sun-shadow march, with only their own uniforms - the ocean has its own
+// u_curvature, u_exposure... and GLSL refuses a uniform declared twice. Mind the
+// trap in oceanCore: the field's u_seaLevel is the TERRAIN's; the water's level
+// is u_waterLevel.
+#ifdef OCEAN_TERRAIN
+${terrainFieldOnly}
+#endif
+uniform float u_shoreDepth;
+
 /** World size of this vertex's cell. Per-vertex so one material serves every
  *  clipmap ring, and a placed body sets it from its own grid. */
 attribute float aCell;
@@ -59,6 +70,8 @@ varying float vFoam;
 varying float vRelHeight;
 varying float vDist;
 varying float vDepthFactor;
+varying float vShoreDepth;
+varying float vTerrainShadow;
 
 void main(){
   // Geomorph first, waves second. The other order blends two different points on
@@ -85,15 +98,41 @@ void main(){
   bool isBody = u_bodyHalf.x > 0.0;
   vec2 fieldXZ = isBody ? local : wxz;
 
+  // Water depth from the terrain height field under this vertex.
+  //
+  // Waves lose their height as the water shoals and are gone at the waterline.
+  // That is the physics, and it is also the fix for the shoreline: an open-sea
+  // swell heaving a couple of metres up and down a 1:4 beach swept the waterline
+  // ~8 m in and out on every wave, and with the edge being a hard depth-buffer
+  // cut through the rock, that read as jitter. With the amplitude gone at depth
+  // 0, the line sits still where the ground meets the level. Waves get twice the
+  // shore depth to die in, because they need more room than the colour does.
+  float shoal = 1.0;
+  vShoreDepth = 1.0e4;
+  vTerrainShadow = 1.0;
+  #ifdef OCEAN_TERRAIN
+  if (!isBody) {
+    float ground = terrainHeightAt(wxz, max(cellLod, 0.5));
+    vShoreDepth = u_waterLevel - ground;
+    shoal = smoothstep(0.0, max(u_shoreDepth, 0.05) * 2.0, vShoreDepth);
+    // A headland's shadow across the bay: the terrain's own analytic march, from
+    // the flat water level, faded and stepped by distance exactly as on land.
+    vec3 sp = vec3(wxz.x, u_waterLevel, wxz.y);
+    float shadow = terrainShadowAt(sp, vec3(0.0, 1.0, 0.0), cellLod, distance(sp, cameraPosition));
+    vTerrainShadow = mix(1.0, shadow, saturate(u_sunShadow));
+  }
+  #endif
+
   vec3 disp; vec3 nrm; float jac; float rel;
-  oceanWaveSum(fieldXZ, cellLod, u_amplitudeScale * edge, disp, nrm, jac, rel);
+  oceanWaveSum(fieldXZ, cellLod, u_amplitudeScale * edge * shoal, disp, nrm, jac, rel);
 
   vFoam = oceanFoam(jac, rel, vec3(fieldXZ.x, 0.0, fieldXZ.y));
   vRelHeight = rel;
 
-  // Open water until the refraction grab lands; the shoreline reads its depth
-  // from that, and from the terrain field when it is included.
-  vDepthFactor = 1.0;
+  // 1 in open water, ramping to 0 as the bottom comes up (shallow colour). Open
+  // water everywhere without terrain, until the refraction grab gives depth for
+  // anything else standing in the water.
+  vDepthFactor = saturate(vShoreDepth / max(u_shoreDepth, 0.05));
 
   // Displacement is in field space, which for both hosts is object space up to a
   // translation - so it can be added to transformed directly. Deriving it from
@@ -148,6 +187,11 @@ varying float vFoam;
 varying float vRelHeight;
 varying float vDist;
 varying float vDepthFactor;
+varying float vShoreDepth;
+varying float vTerrainShadow;
+
+uniform float u_shoreDepth;
+uniform float u_shoreFoam;
 
 void main(){
   vec3 viewDir = normalize(vWorld - cameraPosition);
@@ -179,7 +223,19 @@ void main(){
     sceneShadow = mix(1.0, getShadowMask(), u_receiveShadows);
   #endif
 
-  vec3 col = oceanLight(vWorld, n, viewDir, vFoam, vRelHeight, sceneShadow, vDepthFactor, roughAA, vec3(0.0));
+  sceneShadow *= vTerrainShadow;
+
+  // Shore foam: a band where the ground comes up through the surface, broken by
+  // drifting noise so it reads as wash rather than a painted outline. It also
+  // covers the hard depth-buffer edge where the water plane meets the rock.
+  float foam = vFoam;
+  if (u_shoreFoam > 0.0 && vShoreDepth < 1.0e3) {
+    float band = 1.0 - smoothstep(0.0, max(u_shoreDepth * 0.35, 0.05), vShoreDepth);
+    float wash = oNoised(vWorld.xz * 0.35 + vec2(u_time * 0.15, -u_time * 0.07)).x * 0.5 + 0.5;
+    foam = max(foam, saturate(band * (0.45 + 0.55 * wash) * u_shoreFoam));
+  }
+
+  vec3 col = oceanLight(vWorld, n, viewDir, foam, vRelHeight, sceneShadow, vDepthFactor, roughAA, vec3(0.0));
   col = oceanAerial(col, viewDir, vDist);
   col *= u_exposure;
 
@@ -190,6 +246,36 @@ void main(){
   #include <fog_fragment>
 }
 `;
+/** The terrain field's uniforms (terrainFormUniforms), at harmless values until
+ *  applyTerrainFieldUniforms fills them. u_sunShadow here is the WATER's
+ *  terrainShadow strength, steps and distance its own quality knobs. */
+function terrainFieldDefaults() {
+    return {
+        u_terrainType: 2,
+        u_elevation: 180,
+        u_seaLevel: 0,
+        u_baseScale: 1 / 2600,
+        u_octaves: 8,
+        u_lacunarity: 2.06,
+        u_gain: 0.46,
+        u_ridge: 0.05,
+        u_warpStrength: 0.35,
+        u_warpScale: 0.6,
+        u_erosion: 0.45,
+        u_terraces: 0,
+        u_terraceSharp: 0.6,
+        u_bearingDir: new THREE.Vector2(0.978, 0.208),
+        u_duneFreq: (2 * Math.PI) / 340,
+        u_duneAsym: 0.62,
+        u_plateau: 0,
+        u_valleyDepth: 0,
+        u_valleyWidth: 0.25,
+        u_sunShadow: 1,
+        u_shadowSoftness: 12,
+        u_shadowDistance: 4000,
+        u_shadowSteps: 10,
+    };
+}
 function emptyWaveTable() {
     return Array.from({ length: MAX_WAVES }, () => new THREE.Vector4());
 }
@@ -226,6 +312,11 @@ export const oceanMaterialDefaults = {
     u_exposure: 1,
     u_curvature: 1 / (2 * 6371000),
     u_receiveShadows: 1,
+    // Shoreline (applyOceanShore). Read with or without terrain; the terrain
+    // field's own uniforms below only when OCEAN_TERRAIN is defined.
+    u_shoreDepth: 3,
+    u_shoreFoam: 1,
+    ...terrainFieldDefaults(),
     // Shared with the cloud and terrain materials, set by the same
     // applySunUniforms() off the same useCloudSun state.
     u_sunDir: new THREE.Vector3(0.35, 0.42, 0.84).normalize(),

package/dist/triggers/hosts/actions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../../src/triggers/hosts/actions.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAG3F,mDAAmD;AACnD,eAAO,MAAM,gBAAgB,GAAI,QAAQ,OAAO,CAAC,cAAc,CAAC,GAAG,IAAI,GAAG,SAAS,KAAG,YAAY,EACrC,CAAC;AAE9D,0EAA0E;AAC1E,eAAO,MAAM,eAAe,GAAI,QAAQ,OAAO,CAAC,cAAc,CAAC,GAAG,IAAI,GAAG,SAAS,KAAG,eAAe,EACY,CAAC;AAEjH,8DAA8D;AAC9D,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,cAAc,EAAE,IAAI,EAAE,OAAO,GAAG,QAAQ,GAAG,IAAI,CAUxF"}
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../../src/triggers/hosts/actions.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAG3F,mDAAmD;AACnD,eAAO,MAAM,gBAAgB,GAAI,QAAQ,OAAO,CAAC,cAAc,CAAC,GAAG,IAAI,GAAG,SAAS,KAAG,YAAY,EACrC,CAAC;AAE9D,0EAA0E;AAC1E,eAAO,MAAM,eAAe,GAAI,QAAQ,OAAO,CAAC,cAAc,CAAC,GAAG,IAAI,GAAG,SAAS,KAAG,eAAe,EACY,CAAC;AAEjH,8DAA8D;AAC9D,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,cAAc,EAAE,IAAI,EAAE,OAAO,GAAG,QAAQ,GAAG,IAAI,CAWxF"}

package/dist/triggers/hosts/actions.js

@@ -14,6 +14,8 @@ export function runActionCommands(action, mode) {
             runCommand({ ...c, command: mode }, { source });
         else if (c.kind === 'action')
             runCommand({ ...c, command: mode }, { source });
+        else if (c.kind === 'change')
+            runCommand({ ...c, command: mode }, { source });
         else if (mode === 'apply')
             runCommand(c, { source });
         else if (c.command === 'play' || c.command === 'toggle')

package/dist/triggers/hosts/timelineCues.js

@@ -16,7 +16,7 @@ ClipsRuntime.setCueRunner((cmd, mode, { effects, host, timelineId, getAction })
     // fire: one-shot — an effect plays (apply), anything else runs its own command
     const run = mode === 'fire'
         ? (cmd.kind === 'effect' ? { ...cmd, command: 'apply' } : cmd)
-        : cmd.kind === 'effect' || cmd.kind === 'effectClip' || cmd.kind === 'action' ? { ...cmd, command: mode } : cmd;
+        : cmd.kind === 'effect' || cmd.kind === 'effectClip' || cmd.kind === 'action' || cmd.kind === 'change' ? { ...cmd, command: mode } : cmd;
     runCommand(run, { source, chain: [], effects, ...(catalog ? { catalog } : {}) });
     return true;
 });

package/dist/triggers/kinds/change.d.ts

@@ -0,0 +1,4 @@
+export declare const changeLayerId: (c: {
+    id: string;
+}) => string;
+//# sourceMappingURL=change.d.ts.map

package/dist/triggers/kinds/change.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"change.d.ts","sourceRoot":"","sources":["../../../src/triggers/kinds/change.ts"],"names":[],"mappings":"AAgBA,eAAO,MAAM,aAAa,GAAI,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,WAAqB,CAAC"}

package/dist/triggers/kinds/change.js

@@ -0,0 +1,50 @@
+// Triggerable: an inline change — an action's targets (element + settings patch) without
+// the action. On lays the patches over the elements as a silent SceneActions layer
+// (`change:<id>`): the elements re-render with them, exactly as with an action, but nothing
+// lists it as an applied action. Off removes the layer. A timeline's Change cue.
+//
+// Collisions: when another action / change / the timeline's switch tracks already set the
+// same settings on an element, it is logged as a clash — not resolved (the last one to
+// change sits on top).
+import { SceneActions } from '@3driseai/3drise-core';
+import { defineTriggerable } from '../registry.js';
+import { logTrigger } from '../log.js';
+import { currentChain } from '../engine.js';
+const ENV = new Set(['camera', 'sky', 'clouds', 'ocean', 'terrain']);
+export const changeLayerId = (c) => `change:${c.id}`;
+const ownerName = (o) => (o.startsWith('layer:change:') ? `change ${o.slice(13)}` : o === 'layer:timeline' ? 'a switch track' : `action ${o}`);
+const patchesOf = (c) => {
+    const out = {};
+    for (const t of c.targets ?? [])
+        if (t?.state && t.patch && Object.keys(t.patch).length)
+            out[t.state] = t.patch;
+    return out;
+};
+defineTriggerable({
+    kind: 'change',
+    commands: ['apply', 'revert', 'toggle'],
+    timeline: 'state',
+    targets: (c) => (c.targets ?? []).map(t => t.state).filter(s => s && !ENV.has(s)),
+    subject: (c) => c.label || `change ${c.id}`,
+    claimKey: (c) => `change:${c.id}`,
+    isOn: (c) => SceneActions.hasLayer(changeLayerId(c)),
+    run: (c, ctx) => {
+        const id = changeLayerId(c);
+        const on = c.command === 'apply' || (c.command === 'toggle' && !SceneActions.hasLayer(id));
+        if (!on) {
+            SceneActions.setLayer(id, null);
+            return;
+        }
+        const patches = patchesOf(c);
+        for (const [state, patch] of Object.entries(patches)) {
+            const others = SceneActions.overlaps(state, patch, `layer:${id}`);
+            if (others.length) {
+                logTrigger({
+                    type: 'clash', kind: 'change', subject: c.label || id, source: ctx.source, chain: currentChain(),
+                    detail: `sets the same settings on ${state} as ${others.map(ownerName).join(', ')} — the last one to change wins`,
+                });
+            }
+        }
+        SceneActions.setLayer(id, patches);
+    },
+});

package/dist/triggers/kinds/index.d.ts

@@ -1,4 +1,5 @@
 import './effects';
 import './action';
 import './animations';
+import './change';
 //# sourceMappingURL=index.d.ts.map

package/dist/triggers/kinds/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/triggers/kinds/index.ts"],"names":[],"mappings":"AACA,OAAO,WAAW,CAAC;AACnB,OAAO,UAAU,CAAC;AAClB,OAAO,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/triggers/kinds/index.ts"],"names":[],"mappings":"AACA,OAAO,WAAW,CAAC;AACnB,OAAO,UAAU,CAAC;AAClB,OAAO,cAAc,CAAC;AACtB,OAAO,UAAU,CAAC"}

package/dist/triggers/kinds/index.js

@@ -2,3 +2,4 @@
 import './effects.js';
 import './action.js';
 import './animations.js';
+import './change.js';

package/dist/utils/CameraSingleton.d.ts

@@ -13,6 +13,10 @@ declare class CameraSingleton {
     animateCameraPosition(position: Vector3Array): Promise<void>;
     setCamera(camera: PerspectiveCamera): void;
     getCamera(): PerspectiveCamera | null;
+    /** The live OrbitControls (registered by CameraController) — controllers drag it directly. */
+    private controls;
+    setControls(controls: any): void;
+    getControls(): any;
     getPosition(): Vector3;
     getRotation(): Euler;
     isSynced(position: Vector3Array, orientation: Vector3Array | [number, number, number, number]): boolean;

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

@@ -1 +1 @@
-{"version":3,"file":"CameraSingleton.d.ts","sourceRoot":"","sources":["../../src/utils/CameraSingleton.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAsB,OAAO,EAAE,KAAK,EAAc,MAAM,OAAO,CAAC;AAC1F,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,OAAO,CAAC;AACpC,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAExF,cAAM,eAAe;IACjB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC;IACxB,OAAO,CAAC,MAAM,CAAQ;IACtB,OAAO,CAAC,SAAS,CAAa;IAC9B,OAAO,CAAC,mBAAmB,CAAa;IACxC,OAAO,CAAC,YAAY,CAAiB;IACrC,OAAO,CAAC,YAAY,CAAe;;IAEnC,MAAM,CAAC,WAAW,IAAI,eAAe;IAMrC,qBAAqB,CAAC,QAAQ,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAuB5D,SAAS,CAAC,MAAM,EAAE,iBAAiB,GAAG,IAAI;IAM1C,SAAS,IAAI,iBAAiB,GAAG,IAAI;IACrC,WAAW,IAAI,OAAO;IACtB,WAAW,IAAI,KAAK;IACpB,QAAQ,CAAC,QAAQ,EAAE,YAAY,EAAE,WAAW,EAAE,YAAY,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO;IAyBvG,iBAAiB,IAAI,OAAO;IAI5B,MAAM,IAAI,MAAM;IAChB,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI;IAI3C,OAAO,CAAC,eAAe;IAGvB,WAAW,IAAI,OAAO;IACtB,mBAAmB,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM;IAG5C,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI;IAM7B,oBAAoB,CAAC,WAAW,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG;QAC9C,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,MAAM,CAAC;KAClB;IAeT,wBAAwB,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG;QAC5B,OAAO,EAAE,OAAO,CAAC;QACjB,QAAQ,EAAE,OAAO,CAAC;QAClB,UAAU,EAAE,OAAO,CAAC;QACpB,WAAW,EAAE,OAAO,CAAC;QACrB,MAAM,EAAE,OAAO,CAAC;KACnB;IAqBT,iBAAiB,CAAC,MAAM,EAAE,cAAc,EAAE,WAAW,GAAE,MAAU,EAAE,MAAM,CAAC,EAAE,YAAY,EAAE,OAAO,GAAE,MAAU,GAAG,OAAO;IA6CvH,YAAY,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,KAAK,KAAK,IAAI,GAAG,MAAM,IAAI;IAIhF,mBAAmB,CAAC,OAAO,GAAE,MAAc,GAAG,OAAO;CAiBxD;AACD,eAAO,MAAM,aAAa,EAAE,eAA+C,CAAC;AAC5E,eAAe,aAAa,CAAC"}
+{"version":3,"file":"CameraSingleton.d.ts","sourceRoot":"","sources":["../../src/utils/CameraSingleton.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAsB,OAAO,EAAE,KAAK,EAAc,MAAM,OAAO,CAAC;AAC1F,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,OAAO,CAAC;AACpC,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAExF,cAAM,eAAe;IACjB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC;IACxB,OAAO,CAAC,MAAM,CAAQ;IACtB,OAAO,CAAC,SAAS,CAAa;IAC9B,OAAO,CAAC,mBAAmB,CAAa;IACxC,OAAO,CAAC,YAAY,CAAiB;IACrC,OAAO,CAAC,YAAY,CAAe;;IAEnC,MAAM,CAAC,WAAW,IAAI,eAAe;IAMrC,qBAAqB,CAAC,QAAQ,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAuB5D,SAAS,CAAC,MAAM,EAAE,iBAAiB,GAAG,IAAI;IAM1C,SAAS,IAAI,iBAAiB,GAAG,IAAI;IACrC,8FAA8F;IAC9F,OAAO,CAAC,QAAQ,CAAa;IAC7B,WAAW,CAAC,QAAQ,EAAE,GAAG,GAAG,IAAI;IAChC,WAAW,IAAI,GAAG;IAClB,WAAW,IAAI,OAAO;IACtB,WAAW,IAAI,KAAK;IACpB,QAAQ,CAAC,QAAQ,EAAE,YAAY,EAAE,WAAW,EAAE,YAAY,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO;IAyBvG,iBAAiB,IAAI,OAAO;IAI5B,MAAM,IAAI,MAAM;IAChB,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI;IAI3C,OAAO,CAAC,eAAe;IAGvB,WAAW,IAAI,OAAO;IACtB,mBAAmB,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM;IAG5C,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI;IAM7B,oBAAoB,CAAC,WAAW,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG;QAC9C,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,MAAM,CAAC;KAClB;IAeT,wBAAwB,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG;QAC5B,OAAO,EAAE,OAAO,CAAC;QACjB,QAAQ,EAAE,OAAO,CAAC;QAClB,UAAU,EAAE,OAAO,CAAC;QACpB,WAAW,EAAE,OAAO,CAAC;QACrB,MAAM,EAAE,OAAO,CAAC;KACnB;IAqBT,iBAAiB,CAAC,MAAM,EAAE,cAAc,EAAE,WAAW,GAAE,MAAU,EAAE,MAAM,CAAC,EAAE,YAAY,EAAE,OAAO,GAAE,MAAU,GAAG,OAAO;IA6CvH,YAAY,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,KAAK,KAAK,IAAI,GAAG,MAAM,IAAI;IAIhF,mBAAmB,CAAC,OAAO,GAAE,MAAc,GAAG,OAAO;CAiBxD;AACD,eAAO,MAAM,aAAa,EAAE,eAA+C,CAAC;AAC5E,eAAe,aAAa,CAAC"}

package/dist/utils/CameraSingleton.js

@@ -43,6 +43,10 @@ class CameraSingleton {
         this.notifyCallbacks();
     }
     getCamera() { return this.camera; }
+    /** The live OrbitControls (registered by CameraController) — controllers drag it directly. */
+    controls = null;
+    setControls(controls) { this.controls = controls; }
+    getControls() { return this.controls; }
     getPosition() { return this.camera ? this.camera.position.clone() : new Vector3(); }
     getRotation() { return this.camera ? this.camera.rotation.clone() : new Euler(); }
     isSynced(position, orientation) {

package/dist/utils/deviceTier.d.ts

@@ -0,0 +1,2 @@
+export declare function isMobileDevice(): boolean;
+//# sourceMappingURL=deviceTier.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"deviceTier.d.ts","sourceRoot":"","sources":["../../src/utils/deviceTier.ts"],"names":[],"mappings":"AAOA,wBAAgB,cAAc,IAAI,OAAO,CAOxC"}

package/dist/utils/deviceTier.js

@@ -0,0 +1,16 @@
+/**
+ * Coarse device tier, for render-time quality caps. A phone or tablet: a coarse
+ * primary pointer on a small screen. Read once — it does not change while a page
+ * is open, and render code must not branch on something that flickers.
+ */
+let cached = null;
+export function isMobileDevice() {
+    if (cached !== null)
+        return cached;
+    if (typeof window === 'undefined' || typeof window.matchMedia !== 'function')
+        return (cached = false);
+    const coarse = window.matchMedia('(pointer: coarse)').matches;
+    const shortSide = Math.min(window.screen?.width ?? 0, window.screen?.height ?? 0);
+    cached = coarse && shortSide > 0 && shortSide < 1000;
+    return cached;
+}

package/dist/utils/environmentDrawOrder.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Draw order of the camera-centred environment surfaces.
+ *
+ * three sorts opaque objects by renderOrder, then by MATERIAL ID, then by depth.
+ * The world ocean and the terrain clipmaps are both centred on the camera, so the
+ * depth tie never helps, and with renderOrder left at 0 the material id decides:
+ * whichever surface was created last draws last. That made the frame cost depend
+ * on mount order — measured 13 ms vs 22-27 ms GPU in the same view — because when
+ * the terrain drew first, every terrain pixel under the sea ran the full terrain
+ * shader (textures, 8 noise octaves) and was then painted over by water.
+ *
+ * Fixed order instead, all below the scene's objects (0):
+ *   1. water, inner rings first   (cheap shader; hides the seabed from the depth test)
+ *   2. terrain, inner rings first (near ground hides far ground: front to back)
+ * Drawing near-to-far is what lets the early depth test throw hidden pixels away
+ * before their shader runs. Wasted water pixels behind land are cheap; wasted
+ * terrain pixels under water were most of the frame.
+ */
+export declare const OCEAN_DRAW_ORDER = -40;
+export declare const TERRAIN_DRAW_ORDER = -20;
+/** Inner ring (level 0) first, then outward. */
+export declare const ringDrawOrder: (base: number, level: number) => number;
+//# sourceMappingURL=environmentDrawOrder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"environmentDrawOrder.d.ts","sourceRoot":"","sources":["../../src/utils/environmentDrawOrder.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,gBAAgB,MAAM,CAAC;AACpC,eAAO,MAAM,kBAAkB,MAAM,CAAC;AAEtC,gDAAgD;AAChD,eAAO,MAAM,aAAa,GAAI,MAAM,MAAM,EAAE,OAAO,MAAM,WAAiB,CAAC"}

package/dist/utils/environmentDrawOrder.js

@@ -0,0 +1,22 @@
+/**
+ * Draw order of the camera-centred environment surfaces.
+ *
+ * three sorts opaque objects by renderOrder, then by MATERIAL ID, then by depth.
+ * The world ocean and the terrain clipmaps are both centred on the camera, so the
+ * depth tie never helps, and with renderOrder left at 0 the material id decides:
+ * whichever surface was created last draws last. That made the frame cost depend
+ * on mount order — measured 13 ms vs 22-27 ms GPU in the same view — because when
+ * the terrain drew first, every terrain pixel under the sea ran the full terrain
+ * shader (textures, 8 noise octaves) and was then painted over by water.
+ *
+ * Fixed order instead, all below the scene's objects (0):
+ *   1. water, inner rings first   (cheap shader; hides the seabed from the depth test)
+ *   2. terrain, inner rings first (near ground hides far ground: front to back)
+ * Drawing near-to-far is what lets the early depth test throw hidden pixels away
+ * before their shader runs. Wasted water pixels behind land are cheap; wasted
+ * terrain pixels under water were most of the frame.
+ */
+export const OCEAN_DRAW_ORDER = -40;
+export const TERRAIN_DRAW_ORDER = -20;
+/** Inner ring (level 0) first, then outward. */
+export const ringDrawOrder = (base, level) => base + level;

package/dist/utils/terrainUniforms.d.ts

@@ -2,6 +2,13 @@ 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';
+/**
+ * The height field's own uniforms (terrainFormUniforms): landform, scale, octaves,
+ * warp, erosion, shaping. Shared by the terrain material and by every material that
+ * includes `terrainFieldOnly` to read the ground — the ocean, for its shoreline —
+ * so the two can never disagree about where the ground is.
+ */
+export declare function applyTerrainFieldUniforms(material: THREE.ShaderMaterial, config: TerrainConfig): void;
 export declare function applyTerrainUniforms(material: THREE.ShaderMaterial, config: TerrainConfig, quality: TerrainQualityConfig): void;
 export default applyTerrainUniforms;
 /**

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;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"}
+{"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;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,KAAK,CAAC,cAAc,EAAE,MAAM,EAAE,aAAa,GAAG,IAAI,CAwBrG;AAED,wBAAgB,oBAAoB,CAChC,QAAQ,EAAE,KAAK,CAAC,cAAc,EAC9B,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,oBAAoB,GAC9B,IAAI,CAqCN;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

@@ -45,9 +45,15 @@ function setColor(uniform, hex) {
         return;
     uniform.value.setStyle(hex, THREE.SRGBColorSpace);
 }
-export function applyTerrainUniforms(material, config, quality) {
+/**
+ * The height field's own uniforms (terrainFormUniforms): landform, scale, octaves,
+ * warp, erosion, shaping. Shared by the terrain material and by every material that
+ * includes `terrainFieldOnly` to read the ground — the ocean, for its shoreline —
+ * so the two can never disagree about where the ground is.
+ */
+export function applyTerrainFieldUniforms(material, config) {
     const u = material.uniforms;
-    if (!u)
+    if (!u || !u.u_terrainType)
         return;
     u.u_terrainType.value = TYPE_INDEX[config.terrainType] ?? 2;
     u.u_elevation.value = Math.max(config.elevation, 0.01);
@@ -68,6 +74,13 @@ export function applyTerrainUniforms(material, config, quality) {
     u.u_plateau.value = config.plateau;
     u.u_valleyDepth.value = config.valleyDepth;
     u.u_valleyWidth.value = config.valleyWidth;
+    u.u_shadowSoftness.value = config.shadowSoftness;
+}
+export function applyTerrainUniforms(material, config, quality) {
+    const u = material.uniforms;
+    if (!u)
+        return;
+    applyTerrainFieldUniforms(material, config);
     setColor(u.u_lowColor, config.lowColor);
     setColor(u.u_midColor, config.midColor);
     setColor(u.u_rockColor, config.rockColor);

package/package.json

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