@woosh/meep-engine 2.33.64 → 2.33.69

package/core/FilePath.js

@@ -1,3 +1,5 @@
+const PATH_SEPARATOR = '/';
+
 /**
  * Strips all directories from the path.
  * @example 'a/b/c' -> 'c'
@@ -9,7 +11,7 @@ function computePathBase(path) {
         throw new Error('path is not a string');
     }
 
-    const lastSlashIndex = path.lastIndexOf('/');
+    const lastSlashIndex = path.lastIndexOf(PATH_SEPARATOR);
 
     if (lastSlashIndex !== -1) {
         return path.substring(lastSlashIndex + 1);
@@ -18,6 +20,30 @@ function computePathBase(path) {
     }
 }
 
+/**
+ * Returns the directory name of a path, similar to the Unix dirname command.
+ * @param {string} path
+ * @return {string}
+ */
+export function computePathDirectory(path) {
+    if (typeof path !== "string") {
+        throw new Error('path is not a string');
+    }
+
+    let lastSlashIndex = path.lastIndexOf(PATH_SEPARATOR);
+
+    //rewind in case of trailing slashes
+    while (lastSlashIndex > 0 && path.charAt(lastSlashIndex - 1) === PATH_SEPARATOR) {
+        lastSlashIndex--;
+    }
+
+    if (lastSlashIndex !== -1) {
+        return path.substring(0, lastSlashIndex);
+    } else {
+        return path;
+    }
+}
+
 /**
  *
  * @param {string} path
@@ -44,4 +70,4 @@ function computeFileExtension(path) {
 export {
     computePathBase,
     computeFileExtension
-};
+};

package/core/binary/BinaryBuffer.js

@@ -57,6 +57,19 @@ BinaryBuffer.prototype.fromArrayBuffer = function (arrayBuffer) {
     this.position = 0;
 };
 
+/**
+ *
+ * @param {ArrayBuffer} v
+ * @return {BinaryBuffer}
+ */
+BinaryBuffer.fromArrayBuffer = function (v) {
+    const r = new BinaryBuffer();
+
+    r.fromArrayBuffer(v);
+
+    return r;
+};
+
 /**
  *
  * @returns {BinaryBuffer}

package/core/geom/2d/quad-tree/QuadTreeNode.js

@@ -315,8 +315,9 @@ export class QuadTreeNode extends AABB2 {
         const x1 = this.x1;
         const y1 = this.y1;
 
-        const xm = (x0 + x1) / 2;
-        const ym = (y0 + y1) / 2;
+        // get center point
+        const xm = (x0 + x1) * 0.5;
+        const ym = (y0 + y1) * 0.5;
 
         for (; i < dataLength; i++) {
             const datum = data[i];

package/core/geom/3d/triangle/computeTriangleRayIntersection.js

@@ -25,15 +25,9 @@ export function computeTriangleRayIntersection(
     result,
     origin_x, origin_y, origin_z,
     direction_x, direction_y, direction_z,
-    ax,
-    ay,
-    az,
-    bx,
-    by,
-    bz,
-    cx,
-    cy,
-    cz
+    ax, ay, az,
+    bx, by, bz,
+    cx, cy, cz
 ) {
 
     // edge1 = a - b

package/engine/asset/AssetManager.js

@@ -231,7 +231,7 @@ AssetManager.prototype.submitRequest = function (path, type, request) {
             for (let i = 0; i < transformer_count; i++) {
                 const transformer = transformers[i];
 
-                const transformed_asset = await transformer.transform(asset);
+                const transformed_asset = await transformer.transform(asset, assetDescription);
 
                 if (typeof transformed_asset !== "object") {
                     console.error('Transformer produced invalid result. Ignoring result.', transformer, assetDescription);

package/engine/asset/AssetTransformer.js

@@ -7,9 +7,10 @@
 export class AssetTransformer {
     /**
      * @param {A} source
+     * @param {AssetDescription} asset_description
      * @returns {A}
      */
-    async transform(source) {
+    async transform(source, asset_description) {
         throw new Error('Not Implemented');
     }
 }

package/engine/asset/loaders/GLTFAssetLoader.js

@@ -25,6 +25,7 @@ import { computeGeometryEquality } from "./geometry/geometry/computeGeometryEqua
 import { traverseThreeObject } from "../../graphics/ecs/highlight/renderer/traverseThreeObject.js";
 import { computeTextureHash } from "./material/computeTextureHash.js";
 import { computeTextureEquality } from "./material/computeTextureEquality.js";
+import { async_traverse_three_object } from "./async_traverse_three_object.js";
 
 const animationOptimizer = new AnimationOptimizer();
 const materialCache = StaticMaterialCache.Global;
@@ -130,26 +131,6 @@ function buildDracoDecoderPath() {
     return `${pathname}/libs/draco/`;
 }
 
-/**
- *
- * @param {THREE.Object3D} object
- * @param {function} callback
- * @param {*} [thisArg]
- */
-async function async_traverse(object, callback, thisArg) {
-    await callback.call(thisArg, object);
-
-    const children = object.children;
-    const n = children.length;
-
-    for (let i = 0; i < n; i++) {
-        const child = children[i];
-
-        // TODO we can parallelize this if necessary
-        await async_traverse(child, callback, thisArg);
-    }
-}
-
 export class GLTFAssetLoader extends AssetLoader {
 
     constructor() {
@@ -312,7 +293,6 @@ export class GLTFAssetLoader extends AssetLoader {
                 mesh.geometry = geometry;
             }
 
-
             if (this.__enable_texture_cache) {
                 // replace textures from cache
                 replace_material_textures_from_cache(mesh.material, texture_cache);
@@ -387,7 +367,7 @@ export class GLTFAssetLoader extends AssetLoader {
             }
 
 
-            await async_traverse(root, process_object);
+            await async_traverse_three_object(root, process_object);
 
 
             // compute object bounding sphere

package/engine/asset/loaders/async_traverse_three_object.js

@@ -0,0 +1,24 @@
+/**
+ *
+ * @param {THREE.Object3D} object
+ * @param {function} callback
+ * @param {*} [thisArg]
+ * @param {*} [ctx]
+ */
+export async function async_traverse_three_object(object, callback, thisArg, ctx) {
+    await callback.call(thisArg, object, ctx);
+
+    const children = object.children;
+    const n = children.length;
+
+    const child_promises = [];
+
+    for (let i = 0; i < n; i++) {
+        const child = children[i];
+
+        child_promises.push(async_traverse_three_object(child, callback, thisArg, ctx));
+    }
+
+    // wait for all children at the same time
+    await Promise.all(child_promises);
+}

package/engine/ecs/fow/shader/screenSpaceFogOfWarShader.js

@@ -1,4 +1,5 @@
 import { Matrix4, NormalBlending, ShaderMaterial, Vector2, Vector4 } from "three";
+import { FULL_SCREEN_QUAD_VERTEX_SHADER } from "../../../graphics/FULL_SCREEN_QUAD_VERTEX_SHADER.js";
 
 /**
  Shader for drawing fog of war as a screen-space post-process effect
@@ -6,16 +7,7 @@ import { Matrix4, NormalBlending, ShaderMaterial, Vector2, Vector4 } from "three
  */
 export function buildScreenSpaceFogOfWarShader() {
     function vertexShader() {
-        return `        
-        varying vec2 vUv;
-
-        void main() {
-
-            vUv = uv;
-                
-            gl_Position = vec4( (uv - 0.5)*2.0, 0.0, 1.0 );
-            
-        }`;
+        return FULL_SCREEN_QUAD_VERTEX_SHADER;
     }
 
     function fragmentShader() {

package/engine/ecs/grid/NormalMap2AOMap.js

@@ -5,11 +5,10 @@
 
 import { ClampToEdgeWrapping, DataTexture, RGBAFormat, UnsignedByteType, Vector2 } from 'three';
 import { Sampler2D } from '../../graphics/texture/sampler/Sampler2D.js';
-import sampler2D2Texture from '../../graphics/texture/sampler/Sampler2D2Texture.js';
 import AmbientOcclusionShader from '../../graphics/shaders/AmbientOcclusionShader.js';
-import GaussianBlurShader from '../../graphics/shaders/GaussianBlurShader.js';
 import ImageFilter from '../../graphics/filter/ImageFilter.js';
 import { sampler2DtoFloat32Texture } from "../../graphics/texture/sampler/sampler2DToFloat32Texture.js";
+import { DenoiseShader } from "../../graphics/shaders/DenoiseShader.js";
 
 function filterResult2Texture(data, width, height) {
     const result = new DataTexture();
@@ -37,6 +36,7 @@ function filterResult2Texture(data, width, height) {
  * @param {Sampler2D} heightMap
  * @param {Sampler2D} normalMap
  * @param {Vector2} resultSize
+ * @param worldSize
  * @param {number} [rayLength]
  * @returns {Sampler2D}
  */
@@ -45,13 +45,13 @@ function normalMap2OcclusionMap(
     heightMap,
     normalMap,
     resultSize,
+    worldSize = new Vector2(heightMap.width, heightMap.width),
     rayLength = 17
 ) {
     const width = resultSize.x;
     const height = resultSize.y;
-    const resolution = new Vector2(heightMap.width, heightMap.height);
     //
-    const normalTexture = sampler2D2Texture(normalMap, 255, 0.5);
+    const normalTexture = sampler2DtoFloat32Texture(normalMap);
 
     const heightTexture = sampler2DtoFloat32Texture(heightMap);
 
@@ -60,17 +60,16 @@ function normalMap2OcclusionMap(
     const shaderAO = new AmbientOcclusionShader();
     shaderAO.uniforms.heightMap.value = heightTexture;
     shaderAO.uniforms.normalMap.value = normalTexture;
-    shaderAO.uniforms.resolution.value = resolution;
+    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 shaderBlur = new GaussianBlurShader();
-    shaderBlur.uniforms.resolution.value = resolution;
-    shaderBlur.uniforms.tDiffuse.value = filterResult2Texture(rawAO.array, width, height);
-    shaderBlur.uniforms.sigma.value.set(1.3, 1.3);
+    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, shaderBlur);
+    const smoothAO = ImageFilter(renderer, width, height, shaderDenoise);
 
     //create the sampler
     const result = new Sampler2D(new Uint8ClampedArray(width * height), 1, width, height);
@@ -79,9 +78,7 @@ function normalMap2OcclusionMap(
     const size = width * height;
 
     for (let i = 0; i < size; i++) {
-        const i4 = i * 4;
-
-        result.data[i] = smoothAO.array[i4];
+        result.data[i] = smoothAO.array[i * 4];
     }
 
     return result;

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

@@ -0,0 +1,106 @@
+import normalMap2AOMap from "../../grid/NormalMap2AOMap.js";
+import heightMap2NormalMap from "../../grid/HeightMap2NormalMap.js";
+import { WebGLRendererPool } from "../../../graphics/render/RendererPool.js";
+import Vector2 from "../../../../core/geom/Vector2.js";
+import { writeSample2DDataToDataTexture } from "../../../graphics/texture/sampler/writeSampler2DDataToDataTexture.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
+                                  }) {
+
+    const renderer = WebGLRendererPool.global.get();
+
+    const normal = promiseSamplerNormal(renderer, heightSampler);
+    const ao = promiseSamplerAO({
+        renderer: renderer,
+        pSamplerNormal: normal,
+        samplerHeight: heightSampler,
+        resolution: resolution,
+        rayLength: rayLength,
+        worldSize
+    });
+
+    const promise = ao.then(sampler => {
+        writeSample2DDataToDataTexture(sampler, texture);
+    });
+
+    Promise.all([normal, ao]).finally(() => {
+        WebGLRendererPool.global.release(renderer);
+    });
+
+    return promise;
+}

package/engine/ecs/terrain/ecs/PromiseSamplerHeight.js

@@ -0,0 +1,59 @@
+import { BinaryBuffer } from "../../../../core/binary/BinaryBuffer.js";
+import { deserializeTexture } from "../../../graphics/texture/sampler/TextureBinaryBufferSerializer.js";
+import { Sampler2D } from "../../../graphics/texture/sampler/Sampler2D.js";
+import { GameAssetType } from "../../../asset/GameAssetType.js";
+import rgbaData2valueSampler2D from "../../../graphics/texture/sampler/rgbaData2valueSampler2D.js";
+
+/**
+ *
+ * @param zRange
+ * @param heightMapURL
+ * @param {AssetManager} assetManager
+ * @returns {Promise<any>}
+ */
+export function promiseSamplerHeight(zRange, heightMapURL, assetManager) {
+    return new Promise(function (fulfill, reject) {
+
+        function assetObtained(asset) {
+            const array = asset.create();
+
+            const binaryBuffer = new BinaryBuffer();
+            //
+            // binaryBuffer.writeUint32(2560);
+            // binaryBuffer.writeUint32(2560);
+            //
+            // binaryBuffer.writeUint8(1);
+            //
+            // binaryBuffer.writeUint8(6);
+
+            binaryBuffer.writeBytes(new Uint8Array(array), 0, array.length);
+
+            binaryBuffer.position = 0;
+
+            const sampler2D = deserializeTexture(binaryBuffer);
+            fulfill(sampler2D);
+        }
+
+
+        if (heightMapURL === undefined) {
+            console.warn('Height map is not specified');
+            const defaultSampler = new Sampler2D(new Uint8Array(1), 1, 1, 1);
+            fulfill(defaultSampler);
+        } else if (heightMapURL.endsWith('.bin')) {
+            //load texture from a binary file
+            assetManager.get(heightMapURL, GameAssetType.ArrayBuffer, assetObtained, reject);
+        } else {
+            assetManager.get(heightMapURL, GameAssetType.Image, function (asset) {
+                const image = asset.create();
+
+                // plane
+                const imgWidth = image.width;
+                const imgHeight = image.height;
+
+                const samplerHeight = rgbaData2valueSampler2D(image.data, imgWidth, imgHeight, zRange, -zRange / 2);
+
+                fulfill(samplerHeight);
+            }, reject);
+        }
+    });
+}

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

@@ -14,9 +14,6 @@ import {
 } from 'three';
 import { clamp } from "../../../../core/math/clamp.js";
 import { Sampler2D } from '../../../graphics/texture/sampler/Sampler2D.js';
-import heightMap2NormalMap from '../../grid/HeightMap2NormalMap.js';
-import normalMap2AOMap from '../../grid/NormalMap2AOMap.js';
-import rgbaData2valueSampler2D from '../../../graphics/texture/sampler/rgbaData2valueSampler2D.js';
 import { BinaryNode } from '../../../../core/bvh2/BinaryNode.js';
 import Vector2 from '../../../../core/geom/Vector2.js';
 import { TerrainOverlay } from '../overlay/TerrainOverlay.js';
@@ -24,13 +21,9 @@ import { TerrainOverlay } from '../overlay/TerrainOverlay.js';
 import Clouds from '../TerrainClouds.js';
 
 import TerrainTileManager from '../tiles/TerrainTileManager.js';
-import { WebGLRendererPool } from "../../../graphics/render/RendererPool.js";
-import { deserializeTexture } from "../../../graphics/texture/sampler/TextureBinaryBufferSerializer.js";
-import { BinaryBuffer } from "../../../../core/binary/BinaryBuffer.js";
 import { TerrainPreview } from "../TerrainPreview.js";
 import { assert } from "../../../../core/assert.js";
 import { GameAssetType } from "../../../asset/GameAssetType.js";
-import { writeSample2DDataToDataTexture } from "../../../graphics/texture/sampler/writeSampler2DDataToDataTexture.js";
 import { TerrainLayers } from "./layers/TerrainLayers.js";
 import { SplatMaterial } from "../../../graphics/material/SplatMaterial.js";
 import { loadLegacyTerrainSplats, SplatMapping } from "./splat/SplatMapping.js";
@@ -41,147 +34,8 @@ import { MeepSettings } from "../../../MeepSettings.js";
 import { loadLegacyTerrainLayers } from "./layers/loadLegacyTerrainLayers.js";
 import { TerrainFlags } from "./TerrainFlags.js";
 import { IllegalStateException } from "../../../../core/fsm/exceptions/IllegalStateException.js";
-
-/**
- *
- * @param zRange
- * @param heightMapURL
- * @param {AssetManager} assetManager
- * @returns {Promise<any>}
- */
-function promiseSamplerHeight(zRange, heightMapURL, assetManager) {
-    return new Promise(function (fulfill, reject) {
-
-        function assetObtained(asset) {
-            const array = asset.create();
-
-            const binaryBuffer = new BinaryBuffer();
-            //
-            // binaryBuffer.writeUint32(2560);
-            // binaryBuffer.writeUint32(2560);
-            //
-            // binaryBuffer.writeUint8(1);
-            //
-            // binaryBuffer.writeUint8(6);
-
-            binaryBuffer.writeBytes(new Uint8Array(array), 0, array.length);
-
-            binaryBuffer.position = 0;
-
-            const sampler2D = deserializeTexture(binaryBuffer);
-            fulfill(sampler2D);
-        }
-
-
-        if (heightMapURL === undefined) {
-            console.warn('Height map is not specified');
-            const defaultSampler = new Sampler2D(new Uint8Array(1), 1, 1, 1);
-            fulfill(defaultSampler);
-        } else if (heightMapURL.endsWith('.bin')) {
-            //load texture from a binary file
-            assetManager.get(heightMapURL, GameAssetType.ArrayBuffer, assetObtained, reject);
-        } else {
-            assetManager.get(heightMapURL, GameAssetType.Image, function (asset) {
-                const image = asset.create();
-
-                // plane
-                const imgWidth = image.width;
-                const imgHeight = image.height;
-
-                const samplerHeight = rgbaData2valueSampler2D(image.data, imgWidth, imgHeight, zRange, -zRange / 2);
-
-                fulfill(samplerHeight);
-            }, reject);
-        }
-    });
-}
-
-/**
- *
- * @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 {number} rayLength
- * @returns {Promise<unknown>}
- */
-function promiseSamplerAO(
-    renderer,
-    pSamplerNormal,
-    samplerHeight,
-    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,
-                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 {DataTexture} texture
- * @param {Vector2} resolution
- * @param {Sampler2D} heightSampler
- * @param {number} heightRange
- * @param {number} [rayLength]
- * @returns {Promise}
- */
-function buildLightTexture({ texture, heightSampler, resolution, rayLength = 17 }) {
-
-    const renderer = WebGLRendererPool.global.get();
-
-    if (resolution === undefined) {
-        resolution = new Vector2(texture.image.width, texture.image.height);
-    }
-
-    const normal = promiseSamplerNormal(renderer, heightSampler);
-    const ao = promiseSamplerAO(renderer, normal, heightSampler, resolution, rayLength);
-
-    const promise = ao.then(sampler => {
-        writeSample2DDataToDataTexture(sampler, texture);
-    });
-
-    Promise.all([normal, ao]).finally(() => {
-        WebGLRendererPool.global.release(renderer);
-    });
-
-    return promise;
-}
+import { buildLightTexture } from "./BuildLightTexture.js";
+import { promiseSamplerHeight } from "./PromiseSamplerHeight.js";
 
 let idCounter = 0;
 
@@ -903,13 +757,13 @@ class Terrain {
         this.updateWorkerHeights();
     }
 
-    updateWorkerHeights() {
+    async updateWorkerHeights() {
         const s = this.samplerHeight;
         const worker = this.buildWorker;
 
-        worker.setHeightSampler(s.data, s.itemSize, s.width, s.height);
+        await worker.setHeightSampler(s.data, s.itemSize, s.width, s.height);
 
-       return worker.computeHeightRange()
+        return await worker.computeHeightRange()
             .then(({ min, max }) => {
                 this.tiles.setHeightRange(min, max);
             });
@@ -1012,7 +866,12 @@ class Terrain {
         this.setFlag(TerrainFlags.Built);
     }
 
-    buildLightMap() {
+    /**
+     *
+     * @param {number} quality resolution in texels per grid cell (4 = 4x4 light map texels per single grid cell)
+     * @return {Promise<DataTexture>}
+     */
+    buildLightMap(quality = 4) {
 
 
         const size_x = this.size.x;
@@ -1035,7 +894,9 @@ class Terrain {
 
         const promise = buildLightTexture({
             texture,
-            heightSampler: this.samplerHeight
+            heightSampler: this.samplerHeight,
+            worldSize: new Vector2(size_x * this.gridScale, size_y * this.gridScale),
+            resolution: new Vector2(size_x * quality, size_y *quality)
         });