@woosh/meep-engine 2.138.17 → 2.138.18

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.17",
+  "version": "2.138.18",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

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

@@ -1 +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"}
+{"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,CA8CrB;0BAzFyB,6CAA6C;wBAJiB,OAAO"}

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

@@ -57,9 +57,10 @@ function heightMap2AOMap(
     const width = resultSize.x;
     const height = resultSize.y;
 
-    // Pre-pass: max-height pyramid for Hi-Z ray traversal
+    // Pre-pass: max-height pyramid for Hi-Z ray traversal.
+    // The pyramid is a DataTexture2DArray; each Hi-Z mip is one layer.
     const pyramid_texture = build_max_height_pyramid(heightMap);
-    const max_mip_level = pyramid_texture.mipmaps.length - 1;
+    const max_mip_level = pyramid_texture.userData.mipCount - 1;
 
     // AO bake
     const shader_ao = AmbientOcclusionShader({ numRays: rayCount });

package/src/engine/graphics/shaders/AmbientOcclusionShader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AmbientOcclusionShader.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/shaders/AmbientOcclusionShader.js"],"names":[],"mappings":";AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH;IAFyB,OAAO,GAArB,MAAM;;;;;;;;;;;;;;;;;;;;;;EA6ShB;wBAhX8B,OAAO"}
+{"version":3,"file":"AmbientOcclusionShader.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/shaders/AmbientOcclusionShader.js"],"names":[],"mappings":";AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH;IAFyB,OAAO,GAArB,MAAM;;;;;;;;;;;;;;;;;;;;;;EA4ThB;wBA/X8B,OAAO"}

package/src/engine/graphics/shaders/AmbientOcclusionShader.js

@@ -93,10 +93,15 @@ function AmbientOcclusionShader({ numRays = DEFAULT_NUM_RAYS } = {}) {
 
         fragmentShader: `
             // three.js auto-prefixes float/int precision; declare highp for
-            // the heightmap sampler so R32F reads keep full precision
-            precision highp sampler2D;
+            // the heightmap sampler so R32F reads keep full precision.
+            //
+            // The pyramid is stored as a DataTexture2DArray with one mip per
+            // layer (all at full mip-0 resolution; smaller mips are nearest-
+            // upscaled). This sidesteps a three.js r136 upload bug for
+            // DataTexture custom mipmap chains — see build_max_height_pyramid.
+            precision highp sampler2DArray;
 
-            uniform sampler2D heightMap;
+            uniform sampler2DArray heightMap;
             uniform vec2 worldSize;
             uniform vec2 heightMapSize;
             uniform int maxMipLevel;
@@ -217,8 +222,18 @@ function AmbientOcclusionShader({ numRays = DEFAULT_NUM_RAYS } = {}) {
             //  Heightmap utilities
             // ============================================================
 
+            // Sample mip-0 (the original heightmap) at uv. Layer 0 of the
+            // 2D array holds the un-reduced heightmap data.
             float sample_height(vec2 uv) {
-                return textureLod(heightMap, uv, 0.0).r;
+                return texture(heightMap, vec3(uv, 0.0)).r;
+            }
+
+            // Sample max-height at a specific Hi-Z level. Mip k lives in
+            // layer k, nearest-upscaled to mip-0 resolution. NearestFilter
+            // on the array snaps the layer to integer 'mip' and returns
+            // the underlying mip-k texel containing uv.
+            float sample_max_height(vec2 uv, int mip) {
+                return texture(heightMap, vec3(uv, float(mip))).r;
             }
 
             // Central-difference normal in world space. Faster than building
@@ -293,7 +308,7 @@ function AmbientOcclusionShader({ numRays = DEFAULT_NUM_RAYS } = {}) {
                     float t_exit = min(t_to_boundary.x, t_to_boundary.y) + T_EPS;
 
                     // Max occluder height in this cell at this mip
-                    float max_h = textureLod(heightMap, cell_center, float(mip)).r;
+                    float max_h = sample_max_height(cell_center, mip);
 
                     // Ray height is linear in t, so the minimum across the
                     // cell is at one of the endpoints

package/src/engine/graphics/util/build_max_height_pyramid.d.ts

@@ -1,25 +1,32 @@
 /**
- * Build a max-reduction mipmap pyramid (Hi-Z–style height buffer) from a
- * single-channel float heightmap sampler.
+ * Build a max-reduction Hi-Z height pyramid from a single-channel float
+ * heightmap sampler.
  *
- * Each mip level k holds, per texel, the maximum height across the 2×2 block
- * of level k-1 it covers. A ray trace can then skip whole cells safely: if
- * the ray's height is strictly above the cell's max-height at any mip, the
- * cell can be advanced past without checking any finer level.
+ * Each pyramid level k holds, per texel, the maximum height across the 2×2
+ * block of level k-1 it covers. A ray trace can then skip whole cells
+ * safely: if the ray's height is strictly above the cell's max-height at
+ * any level, the cell can be advanced past without checking any finer level.
  *
- * The returned texture is configured for explicit-LOD sampling
- * (`textureLod(tex, uv, mip)`): NearestMipmapNearestFilter + NearestFilter,
- * generateMipmaps disabled, custom mipmap chain assigned to `tex.mipmaps`.
+ * Storage layout — **DataTexture2DArray, one mip per layer**, all layers at
+ * full mip-0 resolution. Smaller mips are nearest-upscaled into their layer.
+ * The shader samples mip k via `texture(heightMap, vec3(uv, float(k)))`.
  *
- * The level-0 storage is shared (no copy) with `sampler.data`. Higher levels
- * are freshly allocated Float32Array data.
+ * This sidesteps the three.js r136 bug in `WebGLTextures.uploadTexture`
+ * where DataTexture custom mipmap chains are uploaded with `texSubImage2D`
+ * called with level hardcoded to 0 — every "mip" smashes the previous one
+ * into level 0 and the actual mip levels 1..N are left uninitialized. The
+ * 2DArray upload path uses one `texSubImage3D` call to level 0 covering
+ * all layers, so it works correctly.
+ *
+ * Memory cost is (mip_count × W × H × 4) bytes versus (≈ 4/3 × W × H × 4)
+ * for a true mip pyramid — about a 3× overhead, traded for correctness.
  *
  * Non-power-of-two heightmaps are handled by halving with floor and stopping
  * once both dimensions reach 1.
  *
  * @param {Sampler2D} sampler  single-channel Float32 heightmap (itemSize=1)
- * @returns {DataTexture}      R32F texture with custom mipmap chain
+ * @returns {DataTexture2DArray}  R32F array texture; depth = mip count
  */
-export function build_max_height_pyramid(sampler: Sampler2D): DataTexture;
-import { DataTexture } from "three";
+export function build_max_height_pyramid(sampler: Sampler2D): DataTexture2DArray;
+import { DataTexture2DArray } from "three";
 //# sourceMappingURL=build_max_height_pyramid.d.ts.map

package/src/engine/graphics/util/build_max_height_pyramid.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build_max_height_pyramid.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/util/build_max_height_pyramid.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,8DAFa,WAAW,CAsEvB;4BA5FM,OAAO"}
+{"version":3,"file":"build_max_height_pyramid.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/util/build_max_height_pyramid.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,8DAFa,kBAAkB,CA2G9B;mCAxIM,OAAO"}

package/src/engine/graphics/util/build_max_height_pyramid.js

@@ -1,100 +1,143 @@
 import {
     ClampToEdgeWrapping,
-    DataTexture,
+    DataTexture2DArray,
     FloatType,
     NearestFilter,
-    NearestMipmapNearestFilter,
     RedFormat
 } from "three";
 
 /**
- * Build a max-reduction mipmap pyramid (Hi-Z–style height buffer) from a
- * single-channel float heightmap sampler.
+ * Build a max-reduction Hi-Z height pyramid from a single-channel float
+ * heightmap sampler.
  *
- * Each mip level k holds, per texel, the maximum height across the 2×2 block
- * of level k-1 it covers. A ray trace can then skip whole cells safely: if
- * the ray's height is strictly above the cell's max-height at any mip, the
- * cell can be advanced past without checking any finer level.
+ * Each pyramid level k holds, per texel, the maximum height across the 2×2
+ * block of level k-1 it covers. A ray trace can then skip whole cells
+ * safely: if the ray's height is strictly above the cell's max-height at
+ * any level, the cell can be advanced past without checking any finer level.
  *
- * The returned texture is configured for explicit-LOD sampling
- * (`textureLod(tex, uv, mip)`): NearestMipmapNearestFilter + NearestFilter,
- * generateMipmaps disabled, custom mipmap chain assigned to `tex.mipmaps`.
+ * Storage layout — **DataTexture2DArray, one mip per layer**, all layers at
+ * full mip-0 resolution. Smaller mips are nearest-upscaled into their layer.
+ * The shader samples mip k via `texture(heightMap, vec3(uv, float(k)))`.
  *
- * The level-0 storage is shared (no copy) with `sampler.data`. Higher levels
- * are freshly allocated Float32Array data.
+ * This sidesteps the three.js r136 bug in `WebGLTextures.uploadTexture`
+ * where DataTexture custom mipmap chains are uploaded with `texSubImage2D`
+ * called with level hardcoded to 0 — every "mip" smashes the previous one
+ * into level 0 and the actual mip levels 1..N are left uninitialized. The
+ * 2DArray upload path uses one `texSubImage3D` call to level 0 covering
+ * all layers, so it works correctly.
+ *
+ * Memory cost is (mip_count × W × H × 4) bytes versus (≈ 4/3 × W × H × 4)
+ * for a true mip pyramid — about a 3× overhead, traded for correctness.
  *
  * Non-power-of-two heightmaps are handled by halving with floor and stopping
  * once both dimensions reach 1.
  *
  * @param {Sampler2D} sampler  single-channel Float32 heightmap (itemSize=1)
- * @returns {DataTexture}      R32F texture with custom mipmap chain
+ * @returns {DataTexture2DArray}  R32F array texture; depth = mip count
  */
 export function build_max_height_pyramid(sampler) {
     const w0 = sampler.width;
     const h0 = sampler.height;
 
+    // Step 1: build the conventional mip pyramid in JS
     /** @type {Array<{data: Float32Array, width: number, height: number}>} */
-    const mipmaps = [];
-
-    // Level 0: reference original data without copying — the heightmap is the
-    // ground truth and this saves the allocation
-    let prevW = w0;
-    let prevH = h0;
-    let prevData = sampler.data;
-
-    mipmaps.push({ data: prevData, width: prevW, height: prevH });
-
-    while (prevW > 1 || prevH > 1) {
-        const curW = Math.max(1, prevW >> 1);
-        const curH = Math.max(1, prevH >> 1);
-        const curData = new Float32Array(curW * curH);
-
-        // Source rows/cols beyond the last valid index clamp to the edge so
-        // a dimension that hits 1 early (and stays at 1 while the other
-        // shrinks) folds rows together rather than reading garbage
-        const lastSrcX = prevW - 1;
-        const lastSrcY = prevH - 1;
-
-        for (let y = 0; y < curH; y++) {
-            const sy0 = y << 1;
-            const sy1 = Math.min(sy0 + 1, lastSrcY);
-            const row0 = sy0 * prevW;
-            const row1 = sy1 * prevW;
-
-            for (let x = 0; x < curW; x++) {
-                const sx0 = x << 1;
-                const sx1 = Math.min(sx0 + 1, lastSrcX);
-
-                const a = prevData[row0 + sx0];
-                const b = prevData[row0 + sx1];
-                const c = prevData[row1 + sx0];
-                const d = prevData[row1 + sx1];
-
-                let m = a > b ? a : b;
-                if (c > m) m = c;
-                if (d > m) m = d;
-
-                curData[y * curW + x] = m;
+    const mips = [];
+    mips.push({ data: sampler.data, width: w0, height: h0 });
+
+    {
+        let prevW = w0;
+        let prevH = h0;
+        let prevData = sampler.data;
+
+        while (prevW > 1 || prevH > 1) {
+            const curW = Math.max(1, prevW >> 1);
+            const curH = Math.max(1, prevH >> 1);
+            const curData = new Float32Array(curW * curH);
+
+            const lastSrcX = prevW - 1;
+            const lastSrcY = prevH - 1;
+
+            for (let y = 0; y < curH; y++) {
+                const sy0 = y << 1;
+                const sy1 = Math.min(sy0 + 1, lastSrcY);
+                const row0 = sy0 * prevW;
+                const row1 = sy1 * prevW;
+
+                for (let x = 0; x < curW; x++) {
+                    const sx0 = x << 1;
+                    const sx1 = Math.min(sx0 + 1, lastSrcX);
+
+                    const a = prevData[row0 + sx0];
+                    const b = prevData[row0 + sx1];
+                    const c = prevData[row1 + sx0];
+                    const d = prevData[row1 + sx1];
+
+                    let m = a > b ? a : b;
+                    if (c > m) m = c;
+                    if (d > m) m = d;
+
+                    curData[y * curW + x] = m;
+                }
             }
+
+            mips.push({ data: curData, width: curW, height: curH });
+
+            prevW = curW;
+            prevH = curH;
+            prevData = curData;
+        }
+    }
+
+    // Step 2: pack each mip nearest-upscaled to w0 × h0 as a layer of the
+    // array texture. Layer k holds mip k blown up; sampling with NearestFilter
+    // at any uv returns mip k's value at that uv exactly.
+    const depth = mips.length;
+    const layerSize = w0 * h0;
+    const layered = new Float32Array(depth * layerSize);
+
+    for (let k = 0; k < depth; k++) {
+        const mip = mips[k];
+        const mw = mip.width;
+        const mh = mip.height;
+        const mdata = mip.data;
+
+        const layerOffset = k * layerSize;
+
+        if (mw === w0 && mh === h0) {
+            // Level 0 — direct copy
+            layered.set(mdata, layerOffset);
+            continue;
         }
 
-        mipmaps.push({ data: curData, width: curW, height: curH });
+        // Nearest-upscale: dst (x, y) → src (floor(x * mw / w0), floor(y * mh / h0))
+        // Works for both POT and NPO2 reductions.
+        for (let y = 0; y < h0; y++) {
+            const sy = Math.min(mh - 1, ((y * mh) / h0) | 0);
+            const srcRow = sy * mw;
+            const dstRow = layerOffset + y * w0;
 
-        prevW = curW;
-        prevH = curH;
-        prevData = curData;
+            for (let x = 0; x < w0; x++) {
+                const sx = Math.min(mw - 1, ((x * mw) / w0) | 0);
+                layered[dstRow + x] = mdata[srcRow + sx];
+            }
+        }
     }
 
-    const tex = new DataTexture(mipmaps[0].data, w0, h0, RedFormat, FloatType);
-    tex.mipmaps = mipmaps;
-    tex.generateMipmaps = false;
-    tex.minFilter = NearestMipmapNearestFilter;
+    const tex = new DataTexture2DArray(layered, w0, h0, depth);
+    tex.format = RedFormat;
+    tex.type = FloatType;
+    tex.internalFormat = 'R32F';
+    tex.minFilter = NearestFilter;
     tex.magFilter = NearestFilter;
     tex.wrapS = ClampToEdgeWrapping;
     tex.wrapT = ClampToEdgeWrapping;
-    tex.internalFormat = 'R32F';
+    tex.generateMipmaps = false;
     tex.flipY = false;
     tex.needsUpdate = true;
 
+    // Expose the depth so callers can plumb `maxMipLevel` to the shader
+    // without re-deriving it
+    tex.userData.mipCount = depth;
+
     return tex;
 }