@woosh/meep-engine 2.138.17 → 2.138.19

package/src/engine/graphics/impostors/voxel/util/make_voxel_impostor_geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"make_voxel_impostor_geometry.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/impostors/voxel/util/make_voxel_impostor_geometry.js"],"names":[],"mappings":"AA6CA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qFAFa,uBAAuB,CA4BnC;wCAxFM,OAAO"}

package/src/engine/graphics/impostors/voxel/util/make_voxel_impostor_geometry.js

@@ -0,0 +1,96 @@
+import {
+    BufferAttribute,
+    InstancedBufferGeometry,
+    InstancedInterleavedBuffer,
+    InterleavedBufferAttribute,
+    Sphere,
+    Vector3
+} from "three";
+import {
+    VOXEL_POINT_OFFSET_ALBEDO,
+    VOXEL_POINT_OFFSET_NORMAL,
+    VOXEL_POINT_OFFSET_ORM,
+    VOXEL_POINT_OFFSET_POSITION,
+    VOXEL_POINT_STRIDE
+} from "../VoxelImpostorDescription.js";
+
+
+/**
+ * Unit quad in the XY plane, centred on origin. Each instance picks
+ * one of these four corners; the shader places it in view space at a
+ * world-space offset around the instance's iPosition, producing a
+ * camera-facing billboard.
+ *
+ * @type {Float32Array}
+ */
+const QUAD_POSITIONS = new Float32Array([
+    -0.5, -0.5, 0,
+     0.5, -0.5, 0,
+     0.5,  0.5, 0,
+    -0.5,  0.5, 0,
+]);
+
+const QUAD_UVS = new Float32Array([
+    0, 0,
+    1, 0,
+    1, 1,
+    0, 1,
+]);
+
+const QUAD_INDICES = new Uint16Array([
+    0, 1, 2,
+    0, 2, 3,
+]);
+
+
+/**
+ * InstancedBufferGeometry with one instance per voxel. Each instance is
+ * a unit quad whose vertex shader pushes the quad to a world-space
+ * footprint around the voxel's iPosition. Because the splat's size is
+ * specified in world units, it scales correctly with viewing distance:
+ *
+ *   - At the impostor's design distance (where one voxel projects to
+ *     about one screen pixel), the quad covers a single pixel.
+ *   - Closer in, the quad expands to cover the same voxel cell on
+ *     screen — no holes.
+ *   - Farther out, the quad shrinks below a pixel — no z-fighting.
+ *
+ * This is the camera-facing-billboard reading of the Witcher 4 "voxel
+ * point" — the on-screen size of each voxel is whatever its world-space
+ * cell projects to, not a fixed screen size. Shadows work for free
+ * because the depth caster, rendered with the same shader from the
+ * light's view, also produces world-sized splats in light space.
+ *
+ * The interleaved point buffer is shared across iPosition / iNormal /
+ * iAlbedo / iORM via offsets — one GPU upload covers the lot.
+ *
+ * @param {VoxelImpostorDescription} description
+ * @returns {InstancedBufferGeometry}
+ */
+export function make_voxel_impostor_geometry(description) {
+    const geometry = new InstancedBufferGeometry();
+
+    geometry.setAttribute('position', new BufferAttribute(QUAD_POSITIONS, 3));
+    geometry.setAttribute('uv', new BufferAttribute(QUAD_UVS, 2));
+    geometry.setIndex(new BufferAttribute(QUAD_INDICES, 1));
+
+    const interleaved = new InstancedInterleavedBuffer(description.points, VOXEL_POINT_STRIDE);
+
+    geometry.setAttribute('iPosition', new InterleavedBufferAttribute(interleaved, 3, VOXEL_POINT_OFFSET_POSITION));
+    geometry.setAttribute('iNormal',   new InterleavedBufferAttribute(interleaved, 3, VOXEL_POINT_OFFSET_NORMAL));
+    geometry.setAttribute('iAlbedo',   new InterleavedBufferAttribute(interleaved, 3, VOXEL_POINT_OFFSET_ALBEDO));
+    geometry.setAttribute('iORM',      new InterleavedBufferAttribute(interleaved, 3, VOXEL_POINT_OFFSET_ORM));
+
+    geometry.instanceCount = description.point_count;
+
+    // The point cloud occupies the bake's bounding sphere; each splat
+    // extends at most half a voxel-cell past its centre, which is
+    // already absorbed by the sphere's bake-time radius. Add a small
+    // margin so frustum culling doesn't pop voxels at the edge.
+    geometry.boundingSphere = new Sphere(
+        new Vector3(description.offset[0], description.offset[1], description.offset[2]),
+        description.sphere_radius + description.voxel_size * 0.5
+    );
+
+    return geometry;
+}

package/src/engine/graphics/particles/particular/engine/utils/volume/ParticleVolume.d.ts

@@ -1,29 +1,113 @@
-import Entity from "../../../../../../ecs/Entity";
-import {AbstractShape3D} from "../../../../../../../core/geom/3d/shape/AbstractShape3D";
-import {AttributeValue} from "./AttributeValue";
-import {SamplingFunctionKind} from "./SamplingFunctionKind";
-
-interface Args {
-    density?: number
-    particle_size?: number
-    shape?: AbstractShape3D
-    sort?: boolean
-    sprite?: string,
-    sampling_function?: SamplingFunctionKind
-}
-
-interface Attributes {
-    readonly color: AttributeValue
-}
-
-export class ParticleVolume {
-    readonly entity: Entity
-
-    from(args?: Args): void
-
-    fromJSON(json: any): void
-
-    build(): void
-
-    readonly attributes: Attributes
-}
+export class ParticleVolume {
+    __emitter: ParticleEmitter;
+    /**
+     *
+     * @type {Transform}
+     * @private
+     */
+    private __transform;
+    /**
+     * Particle count per unit of volume
+     * @type {number}
+     * @private
+     */
+    private __density;
+    /**
+     *
+     * @type {AbstractShape3D}
+     * @private
+     */
+    private __shape;
+    /**
+     *
+     * @type {SamplingFunctionKind|number}
+     * @private
+     */
+    private __sampling_function;
+    /**
+     *
+     * @type {Entity}
+     */
+    entity: Entity;
+    /**
+     *
+     * @type {Object<AttributeValue>}
+     */
+    attributes: any;
+    get shape(): AbstractShape3D;
+    /**
+     * @private
+     */
+    private init_attributes;
+    get emitter(): ParticleEmitter;
+    get transform(): Transform;
+    /**
+     *
+     * @param {number} [density]
+     * @param {number} [particle_size]
+     * @param {AbstractShape3D} [shape]
+     * @param {boolean} sort
+     * @param {boolean} lighting
+     * @param {string} [sprite]
+     * @param {SamplingFunctionKind|number} [sampling_function]
+     */
+    from({ density, particle_size, shape, sort, lighting, sprite, sampling_function }?: number): void;
+    /**
+     *
+     * @param {number} density
+     * @param {boolean} [is_density_size_adjusted]
+     * @param {number} [particle_size]
+     * @param {Object} shape
+     * @param {boolean} [is_sorted]
+     * @param {boolean} [is_lit]
+     * @param {string} sprite
+     * @param {Object<Object>} [attributes]
+     * @param {string} [sampling_function]
+     */
+    fromJSON({ density, is_density_size_adjusted, particle_size, shape, is_sorted, is_lit, sprite, attributes, sampling_function }: number): void;
+    /**
+     *
+     * @private
+     */
+    private __ensure_initialized;
+    __distribute_grid(): void;
+    /**
+     *
+     * @param {function} random
+     * @private
+     */
+    private __distribute;
+    /**
+     * Distribute particles in the volume
+     * @param {function():number} random
+     * @private
+     */
+    private __distribute_random;
+    /**
+     *
+     * @private
+     */
+    private __write_attributes;
+    /**
+     *
+     * @param {number} index
+     * @private
+     */
+    private __write_attribute;
+    build(): void;
+    /**
+     *
+     * @param {number} r
+     * @param {number} g
+     * @param {number} b
+     * @param {number} a
+     */
+    setColor(r: number, g: number, b: number, a: number): void;
+}
+export namespace ParticleVolume {
+    let typeName: string;
+}
+import { ParticleEmitter } from "../../emitter/ParticleEmitter.js";
+import Entity from "../../../../../../ecs/Entity.js";
+import { Transform } from "../../../../../../ecs/transform/Transform.js";
+//# sourceMappingURL=ParticleVolume.d.ts.map

package/src/engine/graphics/render/forward_plus/SPECIFICATION.md

@@ -152,4 +152,4 @@ for(uint i=0u; i < fp_cluster_metadata.y; i++){
 ---
 Author: Alexander Goldring, Company Named Limited
 
-Private and confidential, copyright (c) Company Named Limited, 2022
+Private and confidential, copyright (c) Company Named Limited, 2026

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/texture/sampler/Sampler2D.d.ts

@@ -3,7 +3,7 @@
  * Inspired by OpenGL's glsl sampler2d API
  * @class
  * @author Alex Goldring
- * @copyright Company Named Limited (c) 2025
+ * @copyright Company Named Limited (c) 2026
  */
 export class Sampler2D {
     /**

package/src/engine/graphics/texture/sampler/Sampler2D.js

@@ -24,7 +24,7 @@ import { computeHashFloat } from "../../../../core/primitives/numbers/computeHas
  * Inspired by OpenGL's glsl sampler2d API
  * @class
  * @author Alex Goldring
- * @copyright Company Named Limited (c) 2025
+ * @copyright Company Named Limited (c) 2026
  */
 export class Sampler2D {
     /**

package/src/engine/graphics/texture/sampler/distance/computeSignedDistanceField_NaiveFlood.d.ts

@@ -5,7 +5,7 @@
  * @param {number} emptyValue
  *
  * @author Alex Goldring
- * @copyright Company Named Limited (c) 2025
+ * @copyright Company Named Limited (c) 2026
  */
 export function computeSignedDistanceField_NaiveFlood(source: Sampler2D, destination: Sampler2D, emptyValue: number): void;
 //# sourceMappingURL=computeSignedDistanceField_NaiveFlood.d.ts.map

package/src/engine/graphics/texture/sampler/distance/computeSignedDistanceField_NaiveFlood.js

@@ -8,7 +8,7 @@ import { BitSet } from "../../../../../core/binary/BitSet.js";
  * @param {number} emptyValue
  *
  * @author Alex Goldring
- * @copyright Company Named Limited (c) 2025
+ * @copyright Company Named Limited (c) 2026
  */
 export function computeSignedDistanceField_NaiveFlood(
     source,

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":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,8DAFa,kBAAkB,CA2G9B;mCAxI4F,OAAO"}

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

@@ -1,100 +1,137 @@
-import {
-    ClampToEdgeWrapping,
-    DataTexture,
-    FloatType,
-    NearestFilter,
-    NearestMipmapNearestFilter,
-    RedFormat
-} from "three";
+import { ClampToEdgeWrapping, DataTexture2DArray, FloatType, NearestFilter, 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;
 }

package/src/engine/input/devices/InputDeviceSwitch.js

@@ -4,7 +4,7 @@ import Signal from "../../../core/events/signal/Signal.js";
  * Representation of an input device key/button
  *
  * @author Alex Goldring
- * @copyright Company Named Limited (c) 2025
+ * @copyright Company Named Limited (c) 2026
  */
 export class InputDeviceSwitch {
 

package/src/engine/input/devices/KeyboardDevice.js

@@ -17,7 +17,7 @@ const codeToKeyNameMap = [];
  * For example, if you hold "A" and click over into another application window - A will be forcibly released with appropriate signal.
  *
  * @author Alex Goldring
- * @copyright Company Named Limited (c) 2025
+ * @copyright Company Named Limited (c) 2026
  */
 class KeyboardDevice {
 

package/src/engine/input/devices/PointerDevice.js

@@ -228,7 +228,7 @@ export function readPositionFromMouseEvent(result, event, source = event.target)
  * Abstracts Mouse and Touch interfaces as single "pointer" device.
  *
  * @author Alex Goldring
- * @copyright Company Named Limited (c) 2025
+ * @copyright Company Named Limited (c) 2026
  */
 export class PointerDevice {
 

package/src/engine/intelligence/behavior/Behavior.js

@@ -7,7 +7,7 @@ import { BehaviorStatus } from "./BehaviorStatus.js";
  * @see https://en.wikipedia.org/wiki/Behavior_tree_(artificial_intelligence,_robotics_and_control)
  * @template CTX
  * @author Alex Goldring
- * @copyright Company Named Limited (c) 2025
+ * @copyright Company Named Limited (c) 2026
  */
 export class Behavior {