@woosh/meep-engine 2.138.15 → 2.138.17

package/editor/Editor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Editor.d.ts","sourceRoot":"","sources":["Editor.js"],"names":[],"mappings":";AAwYA;;;;;GAKG;AACH,gCA+MC;;IA9MG,6BAAwC;IACxC,uBAAkC;IAClC,qBAA2B;IAC3B,oCAAwC;IACxC,0CAAyD;IACzD,yBAAoC;IAEpC;;;OAGG;IACH,sBAFU,GAAG,CAAC,GAAG,EAAE,UAAU,CAAC,CAEO;IAIrC,qBAAuC;IAEvC,uCAAkD;IAElD,iBAAgB;IAEhB,kBAAoB;IAsLpB;yBAvBW,aAAa;MAyBvB;IAGL,mBAaC;IANG,uBAAyB;IAEzB,cAAmC;IAGnC,oBAAsB;IAG1B;;;OAGG;IACH,oBAFW,GAAG,QA6Bb;IAED;;;OAGG;IACH,eAFW,MAAM,iBAkDhB;IA3CG,eAAoB;IA6CxB;;;OAGG;IACH,2BAFW,KAAK,QAqBf;IAED,6BAMC;IAED,eA+BC;IAED;;;;OAIG;IACH,uBAHW,GAAG,GACD,OAAO,CAInB;;8BA5sB6B,4BAA4B;uBAEnC,8BAA8B;iBA5DpC,qCAAqC;gCAatB,6CAA6C;oCA8CzC,0BAA0B;4BAFlC,0BAA0B;mBA1CnC,6BAA6B;+BAyCjB,6BAA6B;uBAMrC,sBAAsB"}
+{"version":3,"file":"Editor.d.ts","sourceRoot":"","sources":["Editor.js"],"names":[],"mappings":";AAwYA;;;;;GAKG;AACH,gCA+MC;;IA9MG,6BAAwC;IACxC,uBAAkC;IAClC,qBAA2B;IAC3B,oCAAwC;IACxC,0CAAyD;IACzD,yBAAoC;IAEpC;;;OAGG;IACH,sBAFU,IAAI,GAAG,aAAa,CAEO;IAIrC,qBAAuC;IAEvC,uCAAkD;IAElD,iBAAgB;IAEhB,kBAAoB;IAsLpB;yBAvBW,aAAa;MAyBvB;IAGL,mBAaC;IANG,uBAAyB;IAEzB,cAAmC;IAGnC,oBAAsB;IAG1B;;;OAGG;IACH,+BA2BC;IAED;;;OAGG;IACH,sCAgDC;IA3CG,eAAoB;IA6CxB;;;OAGG;IACH,wCAmBC;IAED,6BAMC;IAED,eA+BC;IAED;;;;OAIG;IACH,6BAFa,OAAO,CAInB;;8BA5sB6B,4BAA4B;uBAEnC,8BAA8B;iBA5DpC,qCAAqC;gCAatB,6CAA6C;oCA8CzC,0BAA0B;4BAFlC,0BAA0B;mBA1CnC,6BAA6B;+BAyCjB,6BAA6B;uBAMrC,sBAAsB"}

package/editor/SelectionVisualizer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SelectionVisualizer.d.ts","sourceRoot":"","sources":["SelectionVisualizer.js"],"names":[],"mappings":"AA8EA;IACI;;;;OAIG;IACH,oBAHW,MAAM,EAoDhB;IAhDG,eAAoB;IAWN,aAAwB;IA4BtC;;;MAGC;IAED,0BAGC;IAGL,gBAQC;IAED,iBASC;CACJ;sBA3JgC,OAAO;8BAEV,4CAA4C"}
+{"version":3,"file":"SelectionVisualizer.d.ts","sourceRoot":"","sources":["SelectionVisualizer.js"],"names":[],"mappings":"AA8EA;IACI;;;;OAIG;IACH,4BAiDC;IAhDG,eAAoB;IAWN,aAAwB;IA4BtC;;;MAGC;IAED,0BAGC;IAGL,gBAQC;IAED,iBASC;CACJ;sBA3JgC,OAAO;8BAEV,4CAA4C"}

package/editor/actions/concrete/ComponentAddAction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ComponentAddAction.d.ts","sourceRoot":"","sources":["ComponentAddAction.js"],"names":[],"mappings":";AAEA;IACI,yCASC;IAPG,YAAoB;IACpB,eAA0B;IAC1B;;;OAGG;IACH,SAFU,sBAAsB,CAEb;IAGvB,kCAqBC;IAED,mCAGC;CACJ;uBAzCsB,0CAA0C"}
+{"version":3,"file":"ComponentAddAction.d.ts","sourceRoot":"","sources":["ComponentAddAction.js"],"names":[],"mappings":";AAEA;IACI,yCASC;IAPG,YAAoB;IACpB,eAA0B;IAC1B;;;OAGG;IACH,gCAAmB;IAGvB,kCAqBC;IAED,mCAGC;CACJ;uBAzCsB,0CAA0C"}

package/editor/actions/concrete/EntityCreateAction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EntityCreateAction.d.ts","sourceRoot":"","sources":["EntityCreateAction.js"],"names":[],"mappings":";AAEA;IACI,cAaC;IAXG;;;OAGG;IACH,QAFU,MAAM,GAAC,IAAI,CAEH;IAElB;;;OAGG;IACH,KAFU,sBAAsB,CAEjB;IAGnB,kCAkBC;IAED,mCAEC;CACJ;uBAzCsB,0CAA0C"}
+{"version":3,"file":"EntityCreateAction.d.ts","sourceRoot":"","sources":["EntityCreateAction.js"],"names":[],"mappings":";AAEA;IACI,cAaC;IAXG;;;OAGG;IACH,QAFU,MAAM,GAAC,IAAI,CAEH;IAElB;;;OAGG;IACH,4BAAe;IAGnB,kCAkBC;IAED,mCAEC;CACJ;uBAzCsB,0CAA0C"}

package/editor/actions/concrete/SelectionAddAction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SelectionAddAction.d.ts","sourceRoot":"","sources":["SelectionAddAction.js"],"names":[],"mappings":";AAGA;IACI;;;;OAIG;IACH,sBAHW,GAAG,EAAE,EAWf;IANG,cAAoB;IACpB;;;OAGG;IACH,UAFU,GAAG,EAAE,CAES;IAG5B,kCAMC;IAED,mCAEC;CACJ;uBA9BsB,0CAA0C"}
+{"version":3,"file":"SelectionAddAction.d.ts","sourceRoot":"","sources":["SelectionAddAction.js"],"names":[],"mappings":";AAGA;IACI;;;;OAIG;IACH,sBAHW,KAAK,EAWf;IANG,cAAoB;IACpB;;;OAGG;IACH,UAFU,KAAK,CAES;IAG5B,kCAMC;IAED,mCAEC;CACJ;uBA9BsB,0CAA0C"}

package/editor/enableEditor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"enableEditor.d.ts","sourceRoot":"","sources":["enableEditor.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,qCAJW,MAAM,mBACN,CAAS,IAAM,EAAN,MAAM,KAAE,GAAC,GAChB;IAAC,MAAM,WAAU;IAAC,OAAO,WAAW;IAAC,MAAM,WAAW;IAAC,MAAM,EAAE,MAAM,CAAA;CAAC,CAsElF;mBA5EkB,aAAa"}
+{"version":3,"file":"enableEditor.d.ts","sourceRoot":"","sources":["enableEditor.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,qEAHoB,MAAM;;;;YACkD,MAAM;EAsEjF;mBA5EkB,aAAa"}

package/package.json

@@ -5,7 +5,7 @@
   "description": "Pure JavaScript game engine. Fully featured and production ready.",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.138.15",
+  "version": "2.138.17",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/engine/ecs/grid/HeightMap2AOMap.d.ts

@@ -0,0 +1,25 @@
+export default heightMap2AOMap;
+/**
+ * Bake an ambient occlusion / visibility map for a heightfield terrain.
+ *
+ * Pipeline:
+ *   1. Build a max-reduction Hi-Z pyramid from the heightmap (pre-pass).
+ *   2. Run {@link AmbientOcclusionShader} which traces `rayCount`
+ *      cosine-weighted rays per output texel against the pyramid.
+ *   3. Bilateral denoise to clean up Monte Carlo speckle.
+ *
+ * The output is a single-channel visibility map (1 = fully lit, 0 = fully
+ * occluded) packed into a {@link Sampler2D}.
+ *
+ * @param {WebGLRenderer} renderer
+ * @param {Sampler2D} heightMap        single-channel Float32 heightmap
+ * @param {Vector2} resultSize         output AO resolution in texels
+ * @param {Vector2} [worldSize]        terrain XZ extent in world units;
+ *   defaults to heightmap pixel dimensions (= 1 world unit per heightmap texel)
+ * @param {number} [rayCount=64]       Monte Carlo samples per output texel
+ * @returns {Sampler2D}                single-channel Uint8 visibility map
+ */
+declare function heightMap2AOMap(renderer: WebGLRenderer, heightMap: Sampler2D, resultSize: Vector2, worldSize?: Vector2, rayCount?: number): Sampler2D;
+import { Sampler2D } from '../../graphics/texture/sampler/Sampler2D.js';
+import { Vector2 } from 'three';
+//# sourceMappingURL=HeightMap2AOMap.d.ts.map

package/src/engine/ecs/grid/HeightMap2AOMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HeightMap2AOMap.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/grid/HeightMap2AOMap.js"],"names":[],"mappings":";AA6BA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qEAPW,SAAS,cACT,OAAO,cACP,OAAO,aAEP,MAAM,GACJ,SAAS,CA6CrB;0BAxFyB,6CAA6C;wBAJiB,OAAO"}

package/src/engine/ecs/grid/HeightMap2AOMap.js

@@ -0,0 +1,95 @@
+import { ClampToEdgeWrapping, DataTexture, RGBAFormat, UnsignedByteType, Vector2 } from 'three';
+import ImageFilter from '../../graphics/filter/ImageFilter.js';
+import AmbientOcclusionShader from '../../graphics/shaders/AmbientOcclusionShader.js';
+import { DenoiseShader } from "../../graphics/shaders/DenoiseShader.js";
+import { Sampler2D } from '../../graphics/texture/sampler/Sampler2D.js';
+import { build_max_height_pyramid } from "../../graphics/util/build_max_height_pyramid.js";
+
+/**
+ * Wrap a Uint8 buffer as an RGBA8 texture suitable for the denoise pass.
+ *
+ * @param {Uint8Array|Uint8ClampedArray} data
+ * @param {number} width
+ * @param {number} height
+ * @returns {DataTexture}
+ */
+function filter_result_to_texture(data, width, height) {
+    const result = new DataTexture();
+    result.format = RGBAFormat;
+    result.type = UnsignedByteType;
+    result.flipY = false;
+    result.image = { data, width, height };
+    result.wrapS = ClampToEdgeWrapping;
+    result.wrapT = ClampToEdgeWrapping;
+    result.repeat.set(1, 1);
+    result.needsUpdate = true;
+    result.anisotropy = 4;
+    return result;
+}
+
+/**
+ * Bake an ambient occlusion / visibility map for a heightfield terrain.
+ *
+ * Pipeline:
+ *   1. Build a max-reduction Hi-Z pyramid from the heightmap (pre-pass).
+ *   2. Run {@link AmbientOcclusionShader} which traces `rayCount`
+ *      cosine-weighted rays per output texel against the pyramid.
+ *   3. Bilateral denoise to clean up Monte Carlo speckle.
+ *
+ * The output is a single-channel visibility map (1 = fully lit, 0 = fully
+ * occluded) packed into a {@link Sampler2D}.
+ *
+ * @param {WebGLRenderer} renderer
+ * @param {Sampler2D} heightMap        single-channel Float32 heightmap
+ * @param {Vector2} resultSize         output AO resolution in texels
+ * @param {Vector2} [worldSize]        terrain XZ extent in world units;
+ *   defaults to heightmap pixel dimensions (= 1 world unit per heightmap texel)
+ * @param {number} [rayCount=64]       Monte Carlo samples per output texel
+ * @returns {Sampler2D}                single-channel Uint8 visibility map
+ */
+function heightMap2AOMap(
+    renderer,
+    heightMap,
+    resultSize,
+    worldSize = new Vector2(heightMap.width, heightMap.height),
+    rayCount = 64
+) {
+    const width = resultSize.x;
+    const height = resultSize.y;
+
+    // Pre-pass: max-height pyramid for Hi-Z ray traversal
+    const pyramid_texture = build_max_height_pyramid(heightMap);
+    const max_mip_level = pyramid_texture.mipmaps.length - 1;
+
+    // AO bake
+    const shader_ao = AmbientOcclusionShader({ numRays: rayCount });
+    shader_ao.uniforms.heightMap.value = pyramid_texture;
+    shader_ao.uniforms.worldSize.value.set(worldSize.x, worldSize.y);
+    shader_ao.uniforms.heightMapSize.value.set(heightMap.width, heightMap.height);
+    shader_ao.uniforms.maxMipLevel.value = max_mip_level;
+
+    const raw_ao = ImageFilter(renderer, width, height, shader_ao);
+
+    // Denoise: bilateral filter smooths Monte Carlo noise while preserving
+    // visibility edges (cliff bases, ridges)
+    const shader_denoise = new DenoiseShader(2);
+    shader_denoise.uniforms.source.value = filter_result_to_texture(raw_ao.array, width, height);
+    shader_denoise.uniforms.pixelOffset.value.set(1 / width, 1 / height);
+
+    const smooth_ao = ImageFilter(renderer, width, height, shader_denoise);
+
+    // Pack red channel back into a single-channel Uint8 sampler — that's what
+    // the terrain material consumes as aoMap
+    const result = new Sampler2D(new Uint8ClampedArray(width * height), 1, width, height);
+    const size = width * height;
+    for (let i = 0; i < size; i++) {
+        result.data[i] = smooth_ao.array[i * 4];
+    }
+
+    // Free the upload-only pyramid texture
+    pyramid_texture.dispose();
+
+    return result;
+}
+
+export default heightMap2AOMap;

package/src/engine/ecs/terrain/ecs/BuildLightTexture.d.ts

@@ -1,11 +1,19 @@
 /**
+ * Bake a terrain ambient-occlusion / visibility lightmap into `texture`.
  *
- * @param {THREE.DataTexture} texture
- * @param {Vector2} [resolution]
- * @param {Sampler2D} heightSampler
- * @param {number} [rayLength]
- * @param {Vector2} [worldSize]
- * @returns {Promise}
+ * Uses {@link heightMap2AOMap} which traces `rayCount` cosine-weighted rays
+ * per output texel against a Hi-Z height pyramid of the heightmap. See
+ * {@link AmbientOcclusionShader} for the tracer details and trade-offs.
+ *
+ * @param {THREE.DataTexture} texture  target lightmap (red channel written)
+ * @param {Sampler2D} heightSampler    single-channel Float32 heightmap
+ * @param {Vector2} [resolution]       output AO resolution; defaults to
+ *   texture dimensions
+ * @param {Vector2} [worldSize]        terrain XZ extent in world units;
+ *   defaults to the AO resolution (= 1 world unit per output texel)
+ * @param {number} [rayCount=64]       Monte Carlo samples per output texel.
+ *   Higher = less noise, longer bake. Noise falls as 1 / sqrt(rayCount).
+ * @returns {Promise<void>}
  */
-export function buildLightTexture({ texture, heightSampler, resolution, rayLength, worldSize }: THREE.DataTexture): Promise<any>;
+export function buildLightTexture({ texture, heightSampler, resolution, worldSize, rayCount }: THREE.DataTexture): Promise<void>;
 //# sourceMappingURL=BuildLightTexture.d.ts.map

package/src/engine/ecs/terrain/ecs/BuildLightTexture.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BuildLightTexture.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/terrain/ecs/BuildLightTexture.js"],"names":[],"mappings":"AAmEA;;;;;;;;GAQG;AACH,gGAPW,MAAM,WAAW,gBA6B3B"}
+{"version":3,"file":"BuildLightTexture.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/terrain/ecs/BuildLightTexture.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;GAgBG;AACH,+FAVW,MAAM,WAAW,GAQf,QAAQ,IAAI,CAAC,CAuBzB"}

package/src/engine/ecs/terrain/ecs/BuildLightTexture.js

@@ -1,99 +1,44 @@
-import Vector2 from "../../../../core/geom/Vector2.js";
-import { WebGLRendererPool } from "../../../graphics/render/RendererPool.js";
-import { writeSample2DDataToDataTexture } from "../../../graphics/texture/sampler/writeSampler2DDataToDataTexture.js";
-import heightMap2NormalMap from "../../grid/HeightMap2NormalMap.js";
-import normalMap2AOMap from "../../grid/NormalMap2AOMap.js";
-
-/**
- *
- * @param {WebGLRenderer} renderer
- * @param {Sampler2D} sampler
- * @returns {Promise<Sampler2D>}
- */
-function promiseSamplerNormal(renderer, sampler) {
-
-    console.time("generating normal map");
-    const normalSampler = heightMap2NormalMap(renderer, sampler);
-    console.timeEnd("generating normal map");
-
-
-    return Promise.resolve(normalSampler);
-}
-
-/**
- *
- * @param {WebGLRenderer} renderer
- * @param {Promise<Sampler2D>} pSamplerNormal
- * @param {Sampler2D} samplerHeight
- * @param {Vector2} resolution
- * @param {Vector2} [wordSize]
- * @param {number} rayLength
- * @returns {Promise<unknown>}
- */
-function promiseSamplerAO(
-    {
-        renderer,
-        pSamplerNormal,
-        samplerHeight,
-        resolution,
-        wordSize = resolution,
-        rayLength
-    }
-) {
-    return new Promise(function (resolve, reject) {
-        Promise.all([pSamplerNormal]).then(function (values) {
-            const samplerNormal = values[0];
-            console.time("generating AO map");
-            const occlusionSampler = normalMap2AOMap(
-                renderer,
-                samplerHeight,
-                samplerNormal,
-                wordSize,
-                resolution,
-                rayLength
-            );
-            console.timeEnd("generating AO map");
-            //console.info(occlusionSampler);
-            //
-            // paintSamplerOnHTML(samplerHeight, 0, 0, 40, 3);
-            // paintSamplerOnHTML(samplerNormal, 1, 0, 128, 1);
-            // paintSamplerOnHTML(occlusionSampler, 2, 0, 1, 0);
-            //
-            //
-            resolve(occlusionSampler);
-        }, reject);
-    });
-}
-
-/**
- *
- * @param {THREE.DataTexture} texture
- * @param {Vector2} [resolution]
- * @param {Sampler2D} heightSampler
- * @param {number} [rayLength]
- * @param {Vector2} [worldSize]
- * @returns {Promise}
- */
-export function buildLightTexture({
-                                      texture,
-                                      heightSampler,
-                                      resolution = new Vector2(texture.image.width, texture.image.height),
-                                      rayLength = 11,
-                                      worldSize = resolution
-                                  }) {
-
-    return WebGLRendererPool.global.useAsync(async renderer => {
-        const normal = promiseSamplerNormal(renderer, heightSampler);
-
-        const ao = await promiseSamplerAO({
-            renderer: renderer,
-            pSamplerNormal: normal,
-            samplerHeight: heightSampler,
-            resolution: resolution,
-            rayLength: rayLength,
-            worldSize
-        });
-
-        writeSample2DDataToDataTexture(ao, texture);
-    });
-}
+import Vector2 from "../../../../core/geom/Vector2.js";
+import { WebGLRendererPool } from "../../../graphics/render/RendererPool.js";
+import { writeSample2DDataToDataTexture } from "../../../graphics/texture/sampler/writeSampler2DDataToDataTexture.js";
+import heightMap2AOMap from "../../grid/HeightMap2AOMap.js";
+
+/**
+ * Bake a terrain ambient-occlusion / visibility lightmap into `texture`.
+ *
+ * Uses {@link heightMap2AOMap} which traces `rayCount` cosine-weighted rays
+ * per output texel against a Hi-Z height pyramid of the heightmap. See
+ * {@link AmbientOcclusionShader} for the tracer details and trade-offs.
+ *
+ * @param {THREE.DataTexture} texture  target lightmap (red channel written)
+ * @param {Sampler2D} heightSampler    single-channel Float32 heightmap
+ * @param {Vector2} [resolution]       output AO resolution; defaults to
+ *   texture dimensions
+ * @param {Vector2} [worldSize]        terrain XZ extent in world units;
+ *   defaults to the AO resolution (= 1 world unit per output texel)
+ * @param {number} [rayCount=64]       Monte Carlo samples per output texel.
+ *   Higher = less noise, longer bake. Noise falls as 1 / sqrt(rayCount).
+ * @returns {Promise<void>}
+ */
+export function buildLightTexture({
+                                      texture,
+                                      heightSampler,
+                                      resolution = new Vector2(texture.image.width, texture.image.height),
+                                      worldSize = resolution,
+                                      rayCount = 64
+                                  }) {
+
+    return WebGLRendererPool.global.useAsync(async renderer => {
+        console.time("generating AO map");
+        const ao = heightMap2AOMap(
+            renderer,
+            heightSampler,
+            resolution,
+            worldSize,
+            rayCount
+        );
+        console.timeEnd("generating AO map");
+
+        writeSample2DDataToDataTexture(ao, texture);
+    });
+}

package/src/engine/ecs/terrain/ecs/Terrain.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Terrain.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/terrain/ecs/Terrain.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"Terrain.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/terrain/ecs/Terrain.js"],"names":[],"mappings":";AA6CA;IACI;;;OAGG;IACH,aAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,cAAU;IAEV;;;OAGG;IACH,WAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,eAFU,sBAAsB,CAEa;IAE7C;;;OAGG;IACH,mBAFU,MAAM,CAE6B;IAE7C;;;;OAIG;IACH,YAFU,MAAM,CAED;IAEf;;;OAGG;IACH,eAFU,OAAO,CAEQ;IACzB;;;OAGG;IACH,SAFU,cAAc,CAEO;IAC/B;;;OAGG;IACH,gBAFU,YAAY,CAEK;IAE3B;;;OAGG;IACH,iBAFU,aAAa,CAEM;IAE7B;;;OAGG;IACH,oCAAyC;IAEzC;;;OAGG;IACH,cAFU,SAAS,CAEG;IAIlB;;;OAGG;IACH,QAFU,MAAM,CAEU;IAG1B;;;OAGG;IACH,aAFU,MAAM,CAEI;IAGpB;;;OAGG;IACH,eAFU,SAAS,CAE4B;IAE/C;;;OAGG;IACH,eAFU,WAAW,CAE4G;IAejI;;OAEG;IACH,yBAAqC;IAErC;;;;;;;;;OASG;IACH,0CAA+C;IAE/C;;;OAGG;IACH,eAFU,OAAO,CAEQ;IAEzB;;;;OAIG;IACH,2BAAuC;IAGvC;;;OAGG;IACH,SAFU,cAAc,CAEoB;IAE5C;;;;OAIG;IACH,gBAIE;IAMF;;;;OAIG;IACH,uBAA0B;IAE1B;;;OAGG;IACH,oBAAuB;IAEvB;;;;OAIG;IACH,6BAAgC;IAKpC;;;;OAIG;IACH,cAHW,MAAM,GAAC,YAAY,GACjB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,YAAY,GACjB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,YAAY,SACnB,OAAO,QAQjB;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,YAAY,GACjB,OAAO,CAInB;IAoBD,4BAEC;IApBD;;;;;;;;;;;;;OAaG;IACH,yBAEC;IAMD;;;OAGG;IACH,qCA0BC;IAED;;OAEG;IACH,eAyBC;IAED,gBAIC;IAED,mBAmBC;IAED,iCA4BC;IAED,6BAEC;IAED;;;;;;OAMG;IACH,gBANW,MAAM,KACN,MAAM,6EAiBhB;IAED;;;;;;;;;;OAUG;IACH,yBATW,aAAa,WACb,MAAM,WACN,MAAM,WACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,GACJ,OAAO,CAQnB;IAED;;;;;;OAMG;IACH,kCALW,aAAa,KACb,MAAM,KACN,MAAM,GACL,OAAO,CAIlB;IAED;;;;;OAKG;IACH,gCAJW,cAAe,qDAmDzB;IAED;;;;;;OAMG;IACH,wBALW,MAAO,OAAO,CAAC,UACf,SAAS,qDAkBnB;IAED;;;;;OAKG;IACH,sBAJW,MAAM,KACN,MAAM,yBAiBhB;IAED;;;;OAIG;IACH,wCAFW,OAAO,QASjB;IAED;;;OAGG;IACH,gCAsBC;IAED,uBAmCC;IAED;;;OAGG;IACH,iCAIC;IAED;;;OAGG;IACH,8BAEC;IAED;;;OAGG;IACH,sCAyBC;IAED;;;OAGG;IACH,iBAFa,QAAQ,IAAI,CAAC,CAKzB;IAED,4BAiBC;IAED,0BAGC;IAED,oCAUC;IAED,yBAEC;IAED,2BAeC;IAED,uBAkBC;IAED;;;OAGG;IACH,wCAkDC;IArBG;;;;OAIG;IACH,WAHU,uBAAuB,CAGc;IAE/C;;;;OAIG;IACH,QAHU,QAAQ,kBAAkB,CAAC,CAGM;IAW/C;;;OAGG;IACH,gCAEC;IAED;;;OAGG;IACH,iBAYC;IAED;;;;OAIG;IACH,wBAHW,MAAM,GACL,QAAQ,WAAW,CAAC,CAqD/B;IAED;;;;OAIG;IACH;;;;;;;;;;6BAiDC;IAxBG,kBAA4B;IA0BhC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eA/5BA;;;eAGG;;;;;MA26BF;CACJ;;;;uCAp8BsC,6BAA6B;oBAjBhD,kCAAkC;+BAUvB,sBAAsB;6BAQxB,yBAAyB;8BAHxB,2BAA2B;0BAlB/B,yCAAyC;mBAYhD,qBAAqB;0BAJd,gDAAgD;4BAVnE,OAAO;+BAYiB,8BAA8B;6BAYhC,mBAAmB;8BApBlB,2CAA2C;+BAa1C,gCAAgC"}

package/src/engine/ecs/terrain/ecs/Terrain.js

@@ -16,6 +16,7 @@ import Vector2 from '../../../../core/geom/Vector2.js';
 import { clamp } from "../../../../core/math/clamp.js";
 import { GameAssetType } from "../../../asset/GameAssetType.js";
 import { SplatMaterial } from "../../../graphics/material/SplatMaterial.js";
+import { makeTerrainDepthMaterial } from "../../../graphics/material/TerrainDepthMaterial.js";
 import { Sampler2D } from '../../../graphics/texture/sampler/Sampler2D.js';
 import { WHITE_PIXEL_DATA_URL } from "../../../graphics/WHITE_PIXEL_DATA_URL.js";
 import { TerrainOverlay } from '../overlay/TerrainOverlay.js';
@@ -160,6 +161,18 @@ class Terrain {
          */
         this.material = new SplatMaterial({});
 
+        /**
+         * Custom depth material attached to each terrain tile mesh as
+         * `mesh.customDepthMaterial`. Sinks recorded depth into the surface
+         * so the terrain does not self-shadow at creases. See
+         * {@link makeTerrainDepthMaterial} for the trade-off this makes.
+         * The bias strength is exposed via {@link Terrain#shadowBias}.
+         *
+         * @readonly
+         * @type {MeshDepthMaterial}
+         */
+        this.depthMaterial = makeTerrainDepthMaterial();
+
         /**
          * whether or not frustum culling is enabled
          * @type {boolean}
@@ -187,6 +200,7 @@ class Terrain {
          */
         this.__tiles = new TerrainTileManager({
             material: this.material,
+            depthMaterial: this.depthMaterial,
             buildWorker: this.__buildWorker
         });
 
@@ -257,6 +271,28 @@ class Terrain {
         return (this.flags & flag) === flag;
     }
 
+    /**
+     * Object-space distance the terrain is pushed along its negative
+     * geometric normal when it renders into a shadow map. See
+     * {@link makeTerrainDepthMaterial} for the mechanism and trade-off.
+     *
+     * Default ({@link makeTerrainDepthMaterial}) is conservative. Increase
+     * if hairline self-shadow faults are still visible at creases; decrease
+     * if other objects' contact shadows on the terrain look too shrunken.
+     *
+     * The value is in object space, so it scales with the terrain's
+     * transform. With a default 1:1 terrain transform it is also world units.
+     *
+     * @returns {number}
+     */
+    get shadowBias() {
+        return this.depthMaterial.userData.shadowBias.value;
+    }
+
+    set shadowBias(v) {
+        this.depthMaterial.userData.shadowBias.value = v;
+    }
+
     /**
      *
      * @param {GraphicsEngine} graphics

package/src/engine/ecs/terrain/ecs/splat/SplatMapping.d.ts

@@ -8,7 +8,7 @@ export class SplatMapping {
      */
     size: Vector2;
     /**
-     *
+     * number of layers
      * @type {number}
      */
     depth: number;

package/src/engine/ecs/terrain/ecs/splat/SplatMapping.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SplatMapping.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/ecs/terrain/ecs/splat/SplatMapping.js"],"names":[],"mappings":"AAaA;;GAEG;AACH;IAEQ;;;OAGG;IACH,MAFU,OAAO,CAEY;IAE7B;;;OAGG;IACH,OAFU,MAAM,CAEF;IAOd;;;OAGG;IACH,eAFU,kBAAkB,CAEiE;IAUjG;;;;;;;MAQC;IAED;;;;;;;aA6BC;IAED;;;;;OAKG;IACH,8BAJW,SAAS,SACT,MAAM,YACN,MAAM,QAiDhB;IAED;;;;;OAKG;IACH,gCAJW,SAAS,SACT,MAAM,YACN,MAAM,QA2BhB;IAED;;;;;;;OAOG;IACH,wBANW,UAAU,gBACV,MAAM,gBACN,MAAM,eACN,MAAM,gBACN,MAAM,QA2ChB;IAED;;;;;;;OAOG;IACH,4BANW,UAAU,WACV,MAAM,WACN,MAAM,SACN,MAAM,UACN,MAAM,QAuChB;IAED;;;;;;OAMG;IACH,gBALW,MAAM,KACN,MAAM,iBACN,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,6BAHW,MAAM,GACJ,SAAS,CAcrB;IAED;;OAEG;IACH,iDAEC;IAED;;;OAGG;IACH,mDAEC;IAED;;;OAGG;IACH,iCAEC;IAED;;;;OAIG;IACH,gCAHW,UAAU,QAoDpB;IAED,gBAEC;IAED;;;;OAIG;IACH,yBAHW,MAAM,GACJ,OAAO,CAuCnB;IAED;;;;OAIG;IACH,8BAHW,MAAM,SACN,MAAM,QAqBhB;IAED,uBAiBC;IAED;;;;;;OAMG;IACH,cALW,MAAM,UACN,MAAM,SACN,MAAM,cACN,OAAO,QA6DjB;CACJ;oBA7hBmB,qCAAqC;mCALoC,OAAO;0BAU1E,mDAAmD"}
+{"version":3,"file":"SplatMapping.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/ecs/terrain/ecs/splat/SplatMapping.js"],"names":[],"mappings":"AAaA;;GAEG;AACH;IAEQ;;;OAGG;IACH,MAFU,OAAO,CAEY;IAE7B;;;OAGG;IACH,OAFU,MAAM,CAEF;IAOd;;;OAGG;IACH,eAFU,kBAAkB,CAEiE;IAUjG;;;;;;;MAQC;IAED;;;;;;;aA6BC;IAED;;;;;OAKG;IACH,8BAJW,SAAS,SACT,MAAM,YACN,MAAM,QAmDhB;IAED;;;;;OAKG;IACH,gCAJW,SAAS,SACT,MAAM,YACN,MAAM,QA2BhB;IAED;;;;;;;OAOG;IACH,wBANW,UAAU,gBACV,MAAM,gBACN,MAAM,eACN,MAAM,gBACN,MAAM,QA2ChB;IAED;;;;;;;OAOG;IACH,4BANW,UAAU,WACV,MAAM,WACN,MAAM,SACN,MAAM,UACN,MAAM,QAuChB;IAED;;;;;;OAMG;IACH,gBALW,MAAM,KACN,MAAM,iBACN,MAAM,GACJ,MAAM,CAKlB;IAED;;;;OAIG;IACH,6BAHW,MAAM,GACJ,SAAS,CAcrB;IAED;;OAEG;IACH,iDAEC;IAED;;;OAGG;IACH,mDAEC;IAED;;;OAGG;IACH,iCAEC;IAED;;;;OAIG;IACH,gCAHW,UAAU,QAoDpB;IAED,gBAEC;IAED;;;;OAIG;IACH,yBAHW,MAAM,GACJ,OAAO,CAuCnB;IAED;;;;OAIG;IACH,8BAHW,MAAM,SACN,MAAM,QAqBhB;IAED,uBAiBC;IAED;;;;;;OAMG;IACH,cALW,MAAM,UACN,MAAM,SACN,MAAM,cACN,OAAO,QA6DjB;CACJ;oBA/hBmB,qCAAqC;mCALoC,OAAO;0BAU1E,mDAAmD"}

package/src/engine/ecs/terrain/ecs/splat/SplatMapping.js

@@ -23,7 +23,7 @@ export class SplatMapping {
         this.size = new Vector2(1, 1);
 
         /**
-         *
+         * number of layers
          * @type {number}
          */
         this.depth = 1;
@@ -141,6 +141,8 @@ export class SplatMapping {
 
         }
 
+        // mark for update
+        this.weightTexture.needsUpdate = true;
     }
 
     /**

package/src/engine/ecs/terrain/tiles/TerrainTileManager.d.ts

@@ -4,9 +4,12 @@ declare class TerrainTileManager {
      *
      * @param {Vector2} [tileSize]
      * @param {Material} [material]
+     * @param {Material} [depthMaterial] applied to each tile mesh as
+     *   `customDepthMaterial` so the shadow caster pass picks it up.
+     *   Omit (null) to let three.js fall back to its default depth material.
      * @param {WorkerProxy} buildWorker
      */
-    constructor({ material, buildWorker }?: Vector2);
+    constructor({ material, depthMaterial, buildWorker }?: Vector2);
     /**
      *
      * @type {TerrainTile[]}
@@ -58,6 +61,14 @@ declare class TerrainTileManager {
      */
     debugTileMaterialRandom: boolean;
     material: ObservedValue;
+    /**
+     * Optional custom depth material for the shadow caster pass. When
+     * non-null it is assigned to each tile mesh's `customDepthMaterial`
+     * field. See {@link TerrainTileManager#assignTileMaterial}.
+     *
+     * @type {Material|null}
+     */
+    depthMaterial: Material | null;
     /**
      *
      * @type {WorkerProxy}

package/src/engine/ecs/terrain/tiles/TerrainTileManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TerrainTileManager.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/terrain/tiles/TerrainTileManager.js"],"names":[],"mappings":";AA4BA;IA6DI;;;;;OAKG;IACH,wCAJW,OAAO,EA8BjB;IA5FD;;;OAGG;IACH,OAFU,WAAW,EAAE,CAEZ;IAEX;;;MAGE;IAEF;;;OAGG;IACH,UAFU,OAAO,CAEc;IAE/B;;;OAGG;IACH,WAFU,OAAO,CAEa;IAC9B;;;OAGG;IACH,YAFU,eAAe,CAEW;IAEpC;;;OAGG;IACH,OAFU,OAAO,CAES;IAG1B;;;;OAIG;IACH,oBAAmC;IAEnC;;;OAGG;IACH,cAFU,GAAG,CAEG;IAEhB;;;OAGG;IACH,aAFU,eAAe,CAEe;IAExC;;;OAGG;IACH,yBAFU,OAAO,CAEe;IAqB5B,wBAA2C;IAG3C;;;OAGG;IACH,yBAA8B;IAQlC,iCAWC;IAED,8BAEC;IAED;;;;OAIG;IACH,2BAHW,MAAM,cACN,MAAM,QAiChB;IAED,mBAIC;IAED;;;OAGG;IACH,yBAFW,WAAW,QAerB;IAED;;;;OAIG;IACH,6CASC;IAED,qBAqBC;IAED;;OAEG;IACH,gBAIC;IAED;;;;;;OAMG;IACH,qBALW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAuBhB;IAGD;;;;;;;OAOG;IACH,oCANW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,WAAW,EAAE,CAgCzB;IAED,wBAgDC;IAED;;;;;OAKG;IACH,oBAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAYlB;IAED;;;;;OAKG;IACH,UAJW,MAAM,KACN,MAAM,GACJ,WAAW,GAAC,SAAS,CAiBjC;IAED;;;;;OAKG;IACH,wBAJW,MAAM,KACN,MAAM,GACJ,WAAW,CAavB;IAED;;;;;OAKG;IACH,4BAJW,MAAM,KACN,MAAM,GACL,WAAW,GAAC,SAAS,CAahC;IAED;;;;;OAKG;IACH,+BAJW,MAAM,KACN,MAAM,GACJ,QAAQ,WAAW,CAAC,CAYhC;IAED;;;;;;OAMG;IACH,UALW,MAAM,KACN,MAAM,GACJ,QAAQ,WAAW,CAAC,CA4BhC;IAED;;;OAGG;IACH,cAFW,WAAW,QAcrB;IAED,gBASC;IAED;;;;;;OAMG;IACH,cAJW,MAAM,KACN,MAAM,QACN,WAAW,QAsCrB;IAED;;;;;;;;;;OAUG;IACH,yBATW,aAAa,WACb,MAAM,WACN,MAAM,WACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,GACJ,OAAO,CAuDnB;IAED;;;;;;OAMG;IACH,kCALW,aAAa,KACb,MAAM,KACN,MAAM,GACL,OAAO,CAOlB;IAED;;;;;;OAMG;IACH,SALW,MAAM,KACN,MAAM,mCAuFhB;CACJ;wBAztBuB,kBAAkB;mBAVvB,0CAA0C;oBAGzC,kCAAkC;4BAG1B,2CAA2C;oBAVnD,mCAAmC;gCAQvB,mDAAmD;0BAGzD,yCAAyC;8BALrC,2CAA2C"}
+{"version":3,"file":"TerrainTileManager.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/terrain/tiles/TerrainTileManager.js"],"names":[],"mappings":";AA4BA;IA6DI;;;;;;;;OAQG;IACH,uDAPW,OAAO,EA2CjB;IAzGD;;;OAGG;IACH,OAFU,WAAW,EAAE,CAEZ;IAEX;;;MAGE;IAEF;;;OAGG;IACH,UAFU,OAAO,CAEc;IAE/B;;;OAGG;IACH,WAFU,OAAO,CAEa;IAC9B;;;OAGG;IACH,YAFU,eAAe,CAEW;IAEpC;;;OAGG;IACH,OAFU,OAAO,CAES;IAG1B;;;;OAIG;IACH,oBAAmC;IAEnC;;;OAGG;IACH,cAFU,GAAG,CAEG;IAEhB;;;OAGG;IACH,aAFU,eAAe,CAEe;IAExC;;;OAGG;IACH,yBAFU,OAAO,CAEe;IAyB5B,wBAA2C;IAE3C;;;;;;OAMG;IACH,eAFU,WAAS,IAAI,CAEW;IAGlC;;;OAGG;IACH,yBAA8B;IAQlC,iCAWC;IAED,8BAEC;IAED;;;;OAIG;IACH,2BAHW,MAAM,cACN,MAAM,QAiChB;IAED,mBAIC;IAED;;;OAGG;IACH,yBAFW,WAAW,QAuBrB;IAED;;;;OAIG;IACH,6CASC;IAED,qBAqBC;IAED;;OAEG;IACH,gBAIC;IAED;;;;;;OAMG;IACH,qBALW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAuBhB;IAGD;;;;;;;OAOG;IACH,oCANW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,WAAW,EAAE,CAgCzB;IAED,wBAgDC;IAED;;;;;OAKG;IACH,oBAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAYlB;IAED;;;;;OAKG;IACH,UAJW,MAAM,KACN,MAAM,GACJ,WAAW,GAAC,SAAS,CAiBjC;IAED;;;;;OAKG;IACH,wBAJW,MAAM,KACN,MAAM,GACJ,WAAW,CAavB;IAED;;;;;OAKG;IACH,4BAJW,MAAM,KACN,MAAM,GACL,WAAW,GAAC,SAAS,CAahC;IAED;;;;;OAKG;IACH,+BAJW,MAAM,KACN,MAAM,GACJ,QAAQ,WAAW,CAAC,CAYhC;IAED;;;;;;OAMG;IACH,UALW,MAAM,KACN,MAAM,GACJ,QAAQ,WAAW,CAAC,CA4BhC;IAED;;;OAGG;IACH,cAFW,WAAW,QAcrB;IAED,gBASC;IAED;;;;;;OAMG;IACH,cAJW,MAAM,KACN,MAAM,QACN,WAAW,QAsCrB;IAED;;;;;;;;;;OAUG;IACH,yBATW,aAAa,WACb,MAAM,WACN,MAAM,WACN,MAAM,cACN,MAAM,cACN,MAAM,cACN,MAAM,GACJ,OAAO,CAuDnB;IAED;;;;;;OAMG;IACH,kCALW,aAAa,KACb,MAAM,KACN,MAAM,GACL,OAAO,CAOlB;IAED;;;;;;OAMG;IACH,SALW,MAAM,KACN,MAAM,mCAuFhB;CACJ;wBA9uBuB,kBAAkB;mBAVvB,0CAA0C;oBAGzC,kCAAkC;4BAG1B,2CAA2C;oBAVnD,mCAAmC;gCAQvB,mDAAmD;0BAGzD,yCAAyC;8BALrC,2CAA2C"}

package/src/engine/ecs/terrain/tiles/TerrainTileManager.js

@@ -91,11 +91,15 @@ class TerrainTileManager {
      *
      * @param {Vector2} [tileSize]
      * @param {Material} [material]
+     * @param {Material} [depthMaterial] applied to each tile mesh as
+     *   `customDepthMaterial` so the shadow caster pass picks it up.
+     *   Omit (null) to let three.js fall back to its default depth material.
      * @param {WorkerProxy} buildWorker
      */
     constructor(
         {
             material,
+            depthMaterial = null,
             buildWorker
         }
     ) {
@@ -108,6 +112,15 @@ class TerrainTileManager {
 
         this.material = new ObservedValue(material);
 
+        /**
+         * Optional custom depth material for the shadow caster pass. When
+         * non-null it is assigned to each tile mesh's `customDepthMaterial`
+         * field. See {@link TerrainTileManager#assignTileMaterial}.
+         *
+         * @type {Material|null}
+         */
+        this.depthMaterial = depthMaterial;
+
 
         /**
          *
@@ -198,6 +211,14 @@ class TerrainTileManager {
         tile.material = material;
         if (tile.mesh !== null) {
             tile.mesh.material = material;
+
+            // route shadow-caster rendering through the terrain-specific
+            // depth material so the recorded depth is inset into the surface
+            // (see TerrainDepthMaterial). Leaving as undefined when none was
+            // supplied falls back to three.js's default depth material.
+            if (this.depthMaterial !== null) {
+                tile.mesh.customDepthMaterial = this.depthMaterial;
+            }
         }
     }
 

package/src/engine/graphics/impostors/octahedral/shader/ImpostorShaderDepthV0.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ImpostorShaderDepthV0.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/impostors/octahedral/shader/ImpostorShaderDepthV0.js"],"names":[],"mappings":"AA+VA;;;;GAIG;AACH;IACI,cAoCC;CACJ;kCArYM,OAAO"}
+{"version":3,"file":"ImpostorShaderDepthV0.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/impostors/octahedral/shader/ImpostorShaderDepthV0.js"],"names":[],"mappings":"AA0WA;;;;GAIG;AACH;IACI,cAoCC;CACJ;kCArZ6D,OAAO"}

package/src/engine/graphics/impostors/octahedral/shader/ImpostorShaderDepthV0.js

@@ -1,9 +1,4 @@
-import {
-    GLSL3,
-    NoBlending,
-    RawShaderMaterial,
-    Vector3
-} from "three";
+import { GLSL3, NoBlending, RawShaderMaterial, Vector3 } from "three";
 
 // Shadow-pass depth material that matches ImpostorShaderV0's surface so the
 // shadow caster silhouette agrees with what the colour pass draws. We need
@@ -155,12 +150,28 @@ const shader_vx = `
         // camera in object space is therefore the LIGHT's position in
         // object space, so the impostor card naturally orients to face the
         // light — exactly what we want for a shadow caster.
-        vec3 cameraPos_OS = (inverse(modelViewMatrix) * vec4(0.0, 0.0, 0.0, 1.0)).xyz;
-        // Atlas lookup must be relative to the bounding-sphere centre
-        // (uOffset), since the bake's D_frame is measured from the centre,
-        // not from the object origin. In the shadow pass "camera" is the
-        // light, so this is the direction from the centre to the light.
-        vec3 pivotToCameraRay = normalize(cameraPos_OS - uOffset);
+        // For a directional light's ORTHOGRAPHIC shadow camera, three.js
+        // positions the shadow camera at the light entity's world
+        // position — which is independent of the light's actual ray
+        // direction. Using "cameraPos_OS - uOffset" would index the atlas
+        // by "direction to shadow camera position", which generally does
+        // NOT equal the parallel light-ray direction (in our scene the
+        // light sits at (30, 70, 30) but rays travel along (0.17, -1, 0.17),
+        // which puts the camera position on the +X,+Z side while the
+        // light arrives from -X,-Z — i.e. mirrored on X and Z). The
+        // receiver (lit shader) uses the actual light direction for its
+        // shadow coord, so we have to match it on the caster side too.
+        //
+        // Row 2 of modelViewMatrix encodes the camera's +Z axis in OS,
+        // which for a three.js camera is "away from the looking direction"
+        // — i.e. the direction OPPOSITE the way the light travels, which
+        // is what we want for atlas indexing (the bake's D_frame =
+        // direction-from-centre-to-bake-camera = -look-direction).
+        vec3 pivotToCameraRay = normalize(vec3(
+            modelViewMatrix[0][2],
+            modelViewMatrix[1][2],
+            modelViewMatrix[2][2]
+        ));
 
         vec2 framesMinusOne = vec2(uFrames - 1.0);
         vec2 octahedral_uv = clamp(VectorToGrid(pivotToCameraRay) * 0.5 + 0.5, 0.0, 1.0);

package/src/engine/graphics/impostors/octahedral/shader/ImpostorShaderLitV0.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ImpostorShaderLitV0.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/impostors/octahedral/shader/ImpostorShaderLitV0.js"],"names":[],"mappings":"AA4sBA;;;;;;;;GAQG;AACH;IACI,cA6BC;CACJ;+BA9uBM,OAAO"}
+{"version":3,"file":"ImpostorShaderLitV0.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/impostors/octahedral/shader/ImpostorShaderLitV0.js"],"names":[],"mappings":"AAssBA;;;;;;;;GAQG;AACH;IACI,cA6BC;CACJ;+BA9uB0E,OAAO"}

package/src/engine/graphics/impostors/octahedral/shader/ImpostorShaderLitV0.js

@@ -1,10 +1,4 @@
-import {
-    Color,
-    ShaderMaterial,
-    UniformsLib,
-    UniformsUtils,
-    Vector3
-} from "three";
+import { Color, ShaderMaterial, UniformsLib, UniformsUtils, Vector3 } from "three";
 
 // Lit variant of ImpostorShaderV0 — runs three.js's STANDARD (physical) shading
 // model so the impostor responds to scene lights and shadow maps.

package/src/engine/graphics/impostors/octahedral/shader/ImpostorShaderNormalsV0.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ImpostorShaderNormalsV0.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/impostors/octahedral/shader/ImpostorShaderNormalsV0.js"],"names":[],"mappings":"AA+VA;;;;;;;GAOG;AACH;IACI,cAkBC;CACJ;kCAtXM,OAAO"}
+{"version":3,"file":"ImpostorShaderNormalsV0.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/impostors/octahedral/shader/ImpostorShaderNormalsV0.js"],"names":[],"mappings":"AA0VA;;;;;;;GAOG;AACH;IACI,cAkBC;CACJ;kCAtX6D,OAAO"}

package/src/engine/graphics/impostors/octahedral/shader/ImpostorShaderNormalsV0.js

@@ -1,9 +1,4 @@
-import {
-    GLSL3,
-    NoBlending,
-    RawShaderMaterial,
-    Vector3
-} from "three";
+import { GLSL3, NoBlending, RawShaderMaterial, Vector3 } from "three";
 
 // Debug-viz variant: outputs the parallax-corrected world-space surface
 // normal as RGB, mapped (-1..+1) -> (0..1). Use this side-by-side with