@woosh/meep-engine 2.33.62 → 2.33.67

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/ecs/grid/pick.js

@@ -0,0 +1,44 @@
+import { assert } from "../../core/assert.js";
+import Vector3 from "../../core/geom/Vector3.js";
+import { SurfacePoint3 } from "../../core/geom/3d/SurfacePoint3.js";
+import Vector2 from "../../core/geom/Vector2.js";
+
+/**
+ *
+ * @param {number} x
+ * @param {number} y
+ * @param {GraphicsEngine} graphicsEngine
+ * @param {Terrain} terrain
+ * @param {function(gridPosition:Vector2,worldPosition:Vector3,normal:Vector3)} callback
+ */
+export function pick(x, y, graphicsEngine, terrain, callback) {
+
+    assert.isNumber(x, 'x');
+    assert.isNumber(y, 'y');
+
+    assert.defined(terrain, 'terrain');
+    assert.notNull(terrain, 'terrain');
+
+    assert.isFunction(callback, 'callback');
+
+    const vSource = new Vector3(x, y, 0);
+    const vTarget = new Vector3();
+
+    graphicsEngine.normalizeViewportPoint(vSource, vSource);
+    graphicsEngine.viewportProjectionRay(vSource.x, vSource.y, vSource, vTarget);
+
+    const surfacePoint3 = new SurfacePoint3();
+
+    const hitFound = terrain.raycastFirstSync(surfacePoint3, vSource.x, vSource.y, vSource.z, vTarget.x, vTarget.y, vTarget.z);
+
+    if (!hitFound) {
+        // nothing found
+    } else {
+
+        const gridPosition = new Vector2();
+        terrain.mapPointWorld2Grid(surfacePoint3.position, gridPosition);
+        gridPosition._add(0.5, 0.5);
+        callback(gridPosition, surfacePoint3.position, surfacePoint3.normal);
+    }
+
+}

package/editor/tools/GridPaintTool.js

@@ -1,7 +1,6 @@
 import Tool from "./engine/Tool.js";
 import GridPosition from "../../engine/grid/components/GridPosition.js";
 import GridObstacle from "../../engine/grid/components/GridObstacle.js";
-import { pick } from "../../../model/game/util/ScreenGridPicker.js";
 import Vector4 from "../../core/geom/Vector4.js";
 import ObservedValue from "../../core/model/ObservedValue.js";
 import Vector1 from "../../core/geom/Vector1.js";
@@ -12,6 +11,7 @@ import Vector2 from "../../core/geom/Vector2.js";
 import TopDownCameraControllerSystem from "../../engine/graphics/ecs/camera/topdown/TopDownCameraControllerSystem.js";
 import { parseHex } from "../../core/color/parseHex.js";
 import { obtainTerrain } from "../../engine/ecs/terrain/util/obtainTerrain.js";
+import { pick } from "../../ecs/grid/pick.js";
 
 class GridPaintTool extends Tool {
     constructor() {

package/editor/tools/paint/TerrainPaintTool.js

@@ -3,12 +3,12 @@ import Tool from "../engine/Tool.js";
 import { Color } from "../../../core/color/Color.js";
 import { Sampler2D } from "../../../engine/graphics/texture/sampler/Sampler2D.js";
 import Vector2 from "../../../core/geom/Vector2.js";
-import { pick } from "../../../../model/game/util/ScreenGridPicker.js";
 import convertSampler2D2Canvas from "../../../engine/graphics/texture/sampler/Sampler2D2Canvas.js";
 import ObservedString from "../../../core/model/ObservedString.js";
 import { GameAssetType } from "../../../engine/asset/GameAssetType.js";
 import Vector1 from "../../../core/geom/Vector1.js";
 import { obtainTerrain } from "../../../engine/ecs/terrain/util/obtainTerrain.js";
+import { pick } from "../../../ecs/grid/pick.js";
 
 export class TerrainPaintTool extends Tool {
     constructor() {

package/editor/view/GridPickCoordinateView.js

@@ -1,8 +1,8 @@
 import View from "../../view/View.js";
-import { pick } from "../../../model/game/util/ScreenGridPicker.js";
 import domify from "../../view/DOM.js";
 import { PointerDevice } from "../../engine/input/devices/PointerDevice.js";
 import { obtainTerrain } from "../../engine/ecs/terrain/util/obtainTerrain.js";
+import { pick } from "../../ecs/grid/pick.js";
 
 class GridPickCoordinateView extends View {
     /**

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,8 @@ 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";
+import { deinterleaveBufferGeometry } from "../../graphics/geometry/buffered/deinterleaveBufferGeometry.js";
 
 const animationOptimizer = new AnimationOptimizer();
 const materialCache = StaticMaterialCache.Global;
@@ -130,26 +132,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,6 +294,8 @@ export class GLTFAssetLoader extends AssetLoader {
                 mesh.geometry = geometry;
             }
 
+            mesh.geometry = deinterleaveBufferGeometry(geometry);
+
 
             if (this.__enable_texture_cache) {
                 // replace textures from cache
@@ -387,7 +371,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/attachment/AttachmentSystem.js

@@ -7,38 +7,6 @@ import Mesh from "../../graphics/ecs/mesh/Mesh.js";
 import { BoneAttachmentBinding } from "./BoneAttachmentBinding.js";
 import { TransformAttachmentBinding } from "./TransformAttachmentBinding.js";
 
-/**
- * @readonly
- * @enum {number}
- */
-const WaitingType = {
-    Entity: 0,
-    Socket: 1,
-    Mesh: 2,
-    Transform: 3
-};
-
-class WaitingEntry {
-    /**
-     *
-     * @param {number} entity
-     * @param {WaitingType} type
-     */
-    constructor(entity, type) {
-        /**
-         *
-         * @type {number}
-         */
-        this.entity = entity;
-        /**
-         *
-         * @type {WaitingType}
-         */
-        this.type = type;
-    }
-}
-
-
 export class AttachmentSystem extends System {
     constructor() {
         super();
@@ -315,17 +283,10 @@ export class AttachmentSystem extends System {
         }
     }
 
-    /**
-     *
-     * @param {number} entity
-     * @private
-     */
-    __update_entity(entity) {
-        const bindings = this.parentBindingIndex.get(entity);
+    __updateAll() {
+        for (const [entity, bindings] of this.parentBindingIndex) {
 
-        if (bindings !== undefined) {
             const n = bindings.length;
-
             for (let i = 0; i < n; i++) {
                 const binding = bindings[i];
 
@@ -334,15 +295,6 @@ export class AttachmentSystem extends System {
         }
     }
 
-    /**
-     *
-     * @param {Mesh} mesh
-     * @param {number} entity
-     */
-    visitComponent(mesh, entity) {
-        this.__update_entity(entity);
-    }
-
     update(timeDelta) {
         //process wait queue
         this.processWaiting();
@@ -355,6 +307,6 @@ export class AttachmentSystem extends System {
             return;
         }
 
-        ecd.traverseComponents(Attachment, this.visitComponent, this);
+        this.__updateAll();
     }
 }

package/engine/ecs/fow/FogOfWarRevealerSystem.js

@@ -2,7 +2,7 @@ import { System } from "../System.js";
 import { FogOfWarRevealer } from "./FogOfWarRevealer.js";
 import { SignalBinding } from "../../../core/events/signal/SignalBinding.js";
 import { FogOfWar } from "./FogOfWar.js";
-import Team from "../../../../model/game/ecs/component/Team.js";
+import Team from "../team/Team.js";
 import { Transform } from "../transform/Transform.js";
 import Vector2 from "../../../core/geom/Vector2.js";
 import { obtainTerrain } from "../terrain/util/obtainTerrain.js";

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/team/Team.js

@@ -0,0 +1,82 @@
+/**
+ * Created by Alex on 13/04/2016.
+ */
+import ObservedInteger from "../../../core/model/ObservedInteger.js";
+import { BinaryClassSerializationAdapter } from "../storage/binary/BinaryClassSerializationAdapter.js";
+
+class Team extends ObservedInteger {
+    /**
+     *
+     * @param value
+     * @constructor
+     */
+    constructor(value = 0) {
+        super(value);
+    }
+
+    clone() {
+        return new Team(this.getValue());
+    }
+
+    /**
+     *
+     * @param {object} json
+     * @returns {Team}
+     */
+    static fromJSON(json) {
+        const t = new Team();
+
+        t.fromJSON(json);
+
+        return t;
+    }
+}
+
+Team.typeName = "Team";
+
+
+export default Team;
+
+export class TeamSerializationAdapter extends BinaryClassSerializationAdapter{
+    constructor(){
+        super();
+
+        this.klass = Team;
+        this.version = 0;
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {Team} value
+     */
+    serialize(buffer, value) {
+        const v = value.getValue();
+
+        if (v === Infinity) {
+            buffer.writeInt32(2147483647);
+        } else if (v === -Infinity) {
+            buffer.writeInt32(-2147483648);
+        } else {
+            //TODO it's possible to write encoded Infinity values by accident
+            buffer.writeInt32(v);
+        }
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {Team} value
+     */
+    deserialize(buffer, value) {
+        const v = buffer.readInt32();
+
+        if (v === 2147483647) {
+            value.set(Infinity);
+        } else if (v === -2147483648) {
+            value.set(-Infinity);
+        } else {
+            value.set(v);
+        }
+    }
+}

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;
+}