@woosh/meep-engine 2.138.16 → 2.138.18

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

@@ -0,0 +1,143 @@
+import {
+    ClampToEdgeWrapping,
+    DataTexture2DArray,
+    FloatType,
+    NearestFilter,
+    RedFormat
+} from "three";
+
+/**
+ * Build a max-reduction Hi-Z height pyramid from a single-channel float
+ * heightmap sampler.
+ *
+ * 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.
+ *
+ * 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)))`.
+ *
+ * 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 {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 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;
+        }
+
+        // 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;
+
+            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 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.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/editor/ecs/component/FieldDescriptor.d.ts

@@ -1,27 +0,0 @@
-/**
- * @template T
- */
-export class FieldDescriptor<T> {
-    /**
-     *
-     * @type {string}
-     */
-    name: string;
-    /**
-     * typeof field
-     * @type {Class<T>}
-     */
-    type: Class<T>;
-    /**
-     *
-     * @type {FieldValueAdapter|null}
-     */
-    adapter: FieldValueAdapter | null;
-    /**
-     *
-     * @type {{}|undefined}
-     */
-    schema: {} | undefined;
-    toString(): string;
-}
-//# sourceMappingURL=FieldDescriptor.d.ts.map

package/editor/ecs/component/FieldDescriptor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"FieldDescriptor.d.ts","sourceRoot":"","sources":["FieldDescriptor.js"],"names":[],"mappings":"AAAA;;GAEG;AACH;IAEQ;;;OAGG;IACH,MAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,eAAgB;IAEhB;;;OAGG;IACH,SAFU,oBAAkB,IAAI,CAEb;IAEnB;;;OAGG;IACH,QAFU,EAAE,GAAC,SAAS,CAEC;IAG3B,mBAEC;CACJ"}

package/editor/ecs/component/FieldValueAdapter.d.ts

@@ -1,7 +0,0 @@
-export class FieldValueAdapter {
-    writable: boolean;
-    readable: boolean;
-    read(object: any, field_name: any): any;
-    write(object: any, field_name: any, value: any): void;
-}
-//# sourceMappingURL=FieldValueAdapter.d.ts.map

package/editor/ecs/component/FieldValueAdapter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"FieldValueAdapter.d.ts","sourceRoot":"","sources":["FieldValueAdapter.js"],"names":[],"mappings":"AAEA;IAEQ,kBAAoB;IACpB,kBAAoB;IAIxB,wCAKC;IAED,sDAEC;CACJ"}

package/editor/ecs/component/createFieldEditor.d.ts

@@ -1,9 +0,0 @@
-/**
- * @template CTX
- * @param {Object} object
- * @param {FieldDescriptor} field
- * @param {Map<*, TypeEditor>} registry
- */
-export function createFieldEditor<CTX>(object: any, field: FieldDescriptor, registry: Map<any, TypeEditor>): EmptyView;
-import EmptyView from "../../../src/view/elements/EmptyView.js";
-//# sourceMappingURL=createFieldEditor.d.ts.map

package/editor/ecs/component/createFieldEditor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"createFieldEditor.d.ts","sourceRoot":"","sources":["createFieldEditor.js"],"names":[],"mappings":"AAUA;;;;;GAKG;AACH,sFAFW,oBAAkB,aA6E5B;sBA3FqB,yCAAyC"}

package/editor/ecs/component/createObjectEditor.d.ts

@@ -1,14 +0,0 @@
-/**
- * @param {Object} object
- * @param {Map<*, TypeEditor>} registry
- * @param {FieldDescriptor} [field_descriptor]
- */
-export function buildObjectEditorFromRegistry(object: any, registry: Map<any, TypeEditor>, field_descriptor?: FieldDescriptor<any>): any;
-/**
- * @param {Object} object
- * @param {Map<*, TypeEditor>} registry
- */
-export function createObjectEditor(object: any, registry: Map<any, TypeEditor>): EmptyView;
-import { FieldDescriptor } from "./FieldDescriptor.js";
-import EmptyView from "../../../src/view/elements/EmptyView.js";
-//# sourceMappingURL=createObjectEditor.d.ts.map

package/editor/ecs/component/createObjectEditor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"createObjectEditor.d.ts","sourceRoot":"","sources":["createObjectEditor.js"],"names":[],"mappings":"AA8QA;;;;GAIG;AACH,qEAHW,oBAAkB,gDA0B5B;AAID;;;GAGG;AACH,0DAFW,oBAAkB,aA0D5B;gCAvW+B,sBAAsB;sBAFhC,yCAAyC"}

package/editor/ecs/component/findNearestRegisteredType.d.ts

@@ -1,8 +0,0 @@
-/**
- *
- * @param {Map<*, TypeEditor>} registry
- * @param {*} value
- * @returns {TypeEditor|void}
- */
-export function findNearestRegisteredType(registry: Map<any, TypeEditor>, value: any): TypeEditor | void;
-//# sourceMappingURL=findNearestRegisteredType.d.ts.map

package/editor/ecs/component/findNearestRegisteredType.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"findNearestRegisteredType.d.ts","sourceRoot":"","sources":["findNearestRegisteredType.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,oDAJW,oBAAkB,eAEhB,aAAW,IAAI,CAsD3B"}

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

@@ -1,10 +0,0 @@
-export default heightMap2NormalMap;
-/**
- *
- * @param {WebGLRenderer} renderer
- * @param {Sampler2D} sampler
- * @returns {Sampler2D}
- */
-declare function heightMap2NormalMap(renderer: WebGLRenderer, sampler: Sampler2D): Sampler2D;
-import { Sampler2D } from '../../graphics/texture/sampler/Sampler2D.js';
-//# sourceMappingURL=HeightMap2NormalMap.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"HeightMap2NormalMap.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/grid/HeightMap2NormalMap.js"],"names":[],"mappings":";AA0CA;;;;;GAKG;AACH,uEAHW,SAAS,GACP,SAAS,CAuBrB;0BAnEyB,6CAA6C"}

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

@@ -1,72 +0,0 @@
-import ImageFilter from '../../graphics/filter/ImageFilter.js';
-import NormalMapShader from '../../graphics/shaders/NormalMapShader2.js';
-import { Sampler2D } from '../../graphics/texture/sampler/Sampler2D.js';
-import { sampler2d_to_float32_texture } from "../../graphics/texture/sampler/sampler2d_to_float32_texture.js";
-
-
-function convertChannel(v) {
-    return (v) / 255 - 0.5;
-}
-
-/**
- *
- * @param {number[]|Uint8Array} source
- * @returns {Float32Array}
- */
-function rgbaArray2RGB(source) {
-    const length = source.length;
-    const numPixels = Math.floor(length / 4);
-    const target = new Float32Array(numPixels * 3);
-    //
-    let h;
-    for (let i = 0; i < numPixels; i++) {
-        const j = i * 4;
-        const k = i * 3;
-        //normalize source to normal vectors
-        let x = convertChannel(source[j]);
-        let y = convertChannel(source[j + 1]);
-        let z = convertChannel(source[j + 2]);
-        //
-        h = Math.sqrt(x * x + y * y + z * z);
-
-        x /= h;
-        y /= h;
-        z /= h;
-        //
-        target[k] = x;
-        target[k + 1] = y;
-        target[k + 2] = z;
-    }
-    return target;
-}
-
-/**
- *
- * @param {WebGLRenderer} renderer
- * @param {Sampler2D} sampler
- * @returns {Sampler2D}
- */
-function heightMap2NormalMap(renderer, sampler) {
-
-    const width = sampler.width;
-    const height = sampler.height;
-
-    const texture = sampler2d_to_float32_texture(sampler);
-
-    //construct shader
-    const shader = new NormalMapShader();
-    shader.uniforms.heightMap.value = texture;
-    shader.uniforms.resolution.value.set(width, height);
-
-    //perform filtering
-    const result = ImageFilter(renderer, width, height, shader);
-
-    //create the sampler
-    const array = result.array;
-    const rgb = rgbaArray2RGB(array);
-
-    //reduce array's alpha component
-    return new Sampler2D(rgb, 3, width, height);
-}
-
-export default heightMap2NormalMap;

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

@@ -1,15 +0,0 @@
-export default normalMap2OcclusionMap;
-/**
- *
- * @param {WebGLRenderer} renderer
- * @param {Sampler2D} heightMap
- * @param {Sampler2D} normalMap
- * @param {Vector2} resultSize
- * @param worldSize
- * @param {number} [rayLength]
- * @returns {Sampler2D}
- */
-declare function normalMap2OcclusionMap(renderer: WebGLRenderer, heightMap: Sampler2D, normalMap: Sampler2D, resultSize: Vector2, worldSize?: Vector2, rayLength?: number): Sampler2D;
-import { Sampler2D } from '../../graphics/texture/sampler/Sampler2D.js';
-import { Vector2 } from 'three';
-//# sourceMappingURL=NormalMap2AOMap.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"NormalMap2AOMap.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/grid/NormalMap2AOMap.js"],"names":[],"mappings":";AA2BA;;;;;;;;;GASG;AACH,4EAPW,SAAS,aACT,SAAS,cACT,OAAO,mCAEP,MAAM,GACJ,SAAS,CA4CrB;0BA3EyB,6CAA6C;wBAJiB,OAAO"}

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

@@ -1,82 +0,0 @@
-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 { sampler2d_to_float32_texture } from "../../graphics/texture/sampler/sampler2d_to_float32_texture.js";
-
-function filterResult2Texture(data, width, height) {
-    const result = new DataTexture();
-    result.format = RGBAFormat;
-
-
-    result.type = UnsignedByteType;
-    result.flipY = false;
-    result.image = { data: data, width: width, height: height };
-
-    result.wrapS = ClampToEdgeWrapping;
-    result.wrapT = ClampToEdgeWrapping;
-
-    result.repeat.set(1, 1);
-    result.needsUpdate = true;
-
-    result.anisotropy = 4;
-
-    return result;
-}
-
-/**
- *
- * @param {WebGLRenderer} renderer
- * @param {Sampler2D} heightMap
- * @param {Sampler2D} normalMap
- * @param {Vector2} resultSize
- * @param worldSize
- * @param {number} [rayLength]
- * @returns {Sampler2D}
- */
-function normalMap2OcclusionMap(
-    renderer,
-    heightMap,
-    normalMap,
-    resultSize,
-    worldSize = new Vector2(heightMap.width, heightMap.width),
-    rayLength = 17
-) {
-    const width = resultSize.x;
-    const height = resultSize.y;
-    //
-    const normalTexture = sampler2d_to_float32_texture(normalMap);
-
-    const heightTexture = sampler2d_to_float32_texture(heightMap);
-
-
-    //construct shader
-    const shaderAO = new AmbientOcclusionShader();
-    shaderAO.uniforms.heightMap.value = heightTexture;
-    shaderAO.uniforms.normalMap.value = normalTexture;
-    shaderAO.uniforms.world_size.value.set(worldSize.x, worldSize.y);
-    shaderAO.uniforms.rayLength.value = rayLength;
-    //perform filtering
-    const rawAO = ImageFilter(renderer, width, height, shaderAO);
-
-    const shaderDenoise = new DenoiseShader(2);
-    shaderDenoise.uniforms.source.value = filterResult2Texture(rawAO.array, width, height);
-    shaderDenoise.uniforms.pixelOffset.value.set(1 / width, 1 / height);
-
-    const smoothAO = ImageFilter(renderer, width, height, shaderDenoise);
-
-    //create the sampler
-    const result = new Sampler2D(new Uint8ClampedArray(width * height), 1, width, height);
-
-    //populate samples
-    const size = width * height;
-
-    for (let i = 0; i < size; i++) {
-        result.data[i] = smoothAO.array[i * 4];
-    }
-
-    return result;
-}
-
-export default normalMap2OcclusionMap;