@woosh/meep-engine 2.33.4 → 2.33.9

package/core/process/undo/Mark.js

@@ -8,13 +8,14 @@ export class Mark {
      * @constructor
      */
     constructor(index, description) {
-        assert.typeOf(index, 'number', 'index');
+        assert.isNumber(index, 'index');
 
         /**
          *
          * @type {number}
          */
         this.index = index;
+
         /**
          *
          * @type {D}

package/engine/Engine.d.ts

@@ -8,6 +8,7 @@ import {AssetManager} from "./asset/AssetManager";
 import {EntityManager} from "./ecs/EntityManager";
 import View from "../view/View";
 import Ticker from "./simulation/Ticker";
+import {EnginePluginManager} from "./plugin/EnginePluginManager";
 
 export interface IEngineInitializationOptions {
     entityManager?: EntityManager
@@ -25,6 +26,7 @@ export default class Engine {
     public readonly devices: { keyboard: KeyboardDevice, pointer: PointerDevice }
     public readonly assetManager: AssetManager
     public readonly ticker: Ticker
+    public readonly plugins: EnginePluginManager
 
     public start(): Promise<any>
 

package/engine/EngineHarness.js

@@ -203,10 +203,10 @@ export class EngineHarness {
      *
      * @param {Engine} engine
      * @param {Vector3} [focus]
-     * @param heightMap
-     * @param heightRange
-     * @param pitch
-     * @param yaw
+     * @param [heightMap]
+     * @param [heightRange]
+     * @param [pitch]
+     * @param [yaw]
      * @param {number} [distance]
      * @param {Vector2} [terrainSize]
      * @param {number} [terrainResolution]

package/engine/asset/loaders/material/bitmap2sampler_gl.js

@@ -0,0 +1,19 @@
+/**
+ *
+ * @param {WebGL2RenderingContext} gl
+ * @param {Sampler2D} sampler
+ * @param {ImageBitmap} bitmap
+ */
+export function bitmap2sampler_gl(gl, sampler, bitmap) {
+    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, bitmap);
+    gl.drawBuffers([gl.COLOR_ATTACHMENT0]);
+
+    const w = sampler.width;
+    const h = sampler.height;
+
+    if (sampler.itemSize !== 4) {
+        throw new Error(`Expected sampler.itemSize to be 4, instead was '${sampler.itemSize}'`);
+    }
+
+    gl.readPixels(0, 0, w, h, gl.RGBA, gl.UNSIGNED_BYTE, sampler.data);
+}

package/engine/asset/loaders/material/computeImageBitmapEquality.js

@@ -1,6 +1,7 @@
 import { Sampler2D } from "../../../graphics/texture/sampler/Sampler2D.js";
 import { assert } from "../../../../core/assert.js";
 import { isArrayEqualStrict } from "../../../../core/collection/array/isArrayEqualStrict.js";
+import { bitmap2sampler_gl } from "./bitmap2sampler_gl.js";
 
 /**
  *
@@ -8,23 +9,6 @@ import { isArrayEqualStrict } from "../../../../core/collection/array/isArrayEqu
  */
 const sampler_cache = new WeakMap();
 
-/**
- *
- * @param {WebGL2RenderingContext} gl
- * @param {Sampler2D} sampler
- * @param {ImageBitmap} bitmap
- */
-function bitmap2sampler_gl(gl, sampler, bitmap) {
-    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, bitmap);
-    gl.drawBuffers([gl.COLOR_ATTACHMENT0]);
-
-    const data = new Uint8Array(sampler.width * sampler.height * 4);
-
-    gl.readPixels(0, 0, sampler.width, sampler.height, gl.RGBA, gl.UNSIGNED_BYTE, data);
-
-    sampler.data = data;
-}
-
 /**
  *
  * @param {ImageBitmap} bitmap
@@ -45,7 +29,7 @@ function obtainSampler(bitmap, ctx) {
     const width = bitmap.width;
     const height = bitmap.height;
 
-    const sampler = new Sampler2D(null, 4, width, height);
+    const sampler = Sampler2D.uint8(4, width, height);
 
     bitmap2sampler_gl(ctx, sampler, bitmap);
 
@@ -75,15 +59,19 @@ function obtainCanvasCtx(width, height) {
 
     if (ctx_ref === null || (gl = ctx_ref.deref()) === undefined) {
         const canvas = document.createElement('canvas');
+
         gl = canvas.getContext("webgl2");
         gl.activeTexture(gl.TEXTURE0);
+
         const texture = gl.createTexture();
+
         gl.bindTexture(gl.TEXTURE_2D, texture);
+
         const framebuffer = gl.createFramebuffer();
+
         gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
         gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0);
 
-
         ctx_ref = new WeakRef(gl);
     }
 

package/engine/ecs/foliage/InstancedFoliage.js

@@ -1,9 +1,5 @@
 import { BinaryNode } from "../../../core/bvh2/BinaryNode.js";
-import {
-    deserializeRowFirstTable,
-    RowFirstTable,
-    serializeRowFirstTable
-} from "../../../core/collection/table/RowFirstTable.js";
+import { RowFirstTable } from "../../../core/collection/table/RowFirstTable.js";
 import { InstancedMeshGroup } from "../../graphics/geometry/instancing/InstancedMeshGroup.js";
 import Vector3 from "../../../core/geom/Vector3.js";
 import { LeafNode } from "../../../core/bvh2/LeafNode.js";
@@ -19,6 +15,8 @@ import { traverseBinaryNodeUsingVisitor } from "../../../core/bvh2/traversal/tra
 import { serializeBinaryNodeToBinaryBuffer } from "../../../core/bvh2/serialization/serializeBinaryNodeToBinaryBuffer.js";
 import { deserializeBinaryNodeFromBinaryBuffer } from "../../../core/bvh2/serialization/deserializeBinaryNodeFromBinaryBuffer.js";
 import { computeGeometryBoundingSphereMiniball } from "../../graphics/geometry/buffered/computeGeometryBoundingSphereMiniball.js";
+import { serializeRowFirstTable } from "../../../core/collection/table/serializeRowFirstTable.js";
+import { deserializeRowFirstTable } from "../../../core/collection/table/deserializeRowFirstTable.js";
 
 /**
  * @readonly

package/engine/ecs/fow/serialization/FogOfWarSerializationAdapter.js

@@ -1,6 +1,7 @@
 import { BinaryClassSerializationAdapter } from "../../storage/binary/BinaryClassSerializationAdapter.js";
-import { deserializeRowFirstTable, serializeRowFirstTable } from "../../../../core/collection/table/RowFirstTable.js";
 import { FogOfWar } from "../FogOfWar.js";
+import { serializeRowFirstTable } from "../../../../core/collection/table/serializeRowFirstTable.js";
+import { deserializeRowFirstTable } from "../../../../core/collection/table/deserializeRowFirstTable.js";
 
 export class FogOfWarSerializationAdapter extends BinaryClassSerializationAdapter {
     constructor() {

package/engine/ecs/transform/Transform.js

@@ -6,6 +6,7 @@ import Vector3 from "../../../core/geom/Vector3.js";
 import Quaternion from "../../../core/geom/Quaternion.js";
 import { Matrix4 } from "../../../core/geom/Matrix4.js";
 import { Quaternion as ThreeQuaternion } from "three";
+import { composeMatrix4 } from "../../graphics/util/composeMatrix4.js";
 
 const delta = new Vector3();
 
@@ -175,7 +176,7 @@ export class Transform {
      * @param {Matrix4} matrix
      */
     toThreeMatrix(matrix) {
-        matrix.compose(this.position, this.rotation, this.scale);
+        composeMatrix4(matrix, this.position, this.rotation, this.scale);
     }
 }
 

package/engine/graphics/GraphicsEngine.js

@@ -4,16 +4,11 @@
 
 
 import {
-    CubeTextureLoader,
     Group,
     LinearEncoding,
     NoToneMapping,
-    PMREMGenerator,
     Raycaster as ThreeRaycaster,
     Scene as ThreeScene,
-    sRGBEncoding,
-    TextureLoader,
-    UnsignedByteType,
     Vector3 as ThreeVector3,
     VSMShadowMap,
     WebGLRenderer,
@@ -38,29 +33,13 @@ import { renderTextureToScreenQuad } from "./render/utils/renderTextureToScreenQ
 import { globalMetrics } from "../metrics/GlobalMetrics.js";
 import { MetricsCategory } from "../metrics/MetricsCategory.js";
 import Vector1 from "../../core/geom/Vector1.js";
-import { noop } from "../../core/function/Functions.js";
 import { NormalFrameBuffer } from "./render/buffer/buffers/NormalFrameBuffer.js";
 import { MaterialManager } from "./material/manager/MaterialManager.js";
 import { CoalesceTextures } from "./material/manager/compilers/CoalesceTextures.js";
 import { ShadowMapRenderer } from "./shadows/ShadowMapRenderer.js";
 import { CameraViewManager } from "./render/view/CameraViewManager.js";
 import { StandardFrameBuffers } from "./StandardFrameBuffers.js";
-import { computeFileExtension } from "../../core/FilePath.js";
-import { EXRLoader } from "three/examples/jsm/loaders/EXRLoader.js";
-
-/**
- *
- * @param {String} path
- * @param {String} format
- * @returns {String[]}
- */
-export function buildCubeURLs(path, format) {
-    return [
-        path + "posx" + format, path + "negx" + format,
-        path + "posy" + format, path + "negy" + format,
-        path + "posz" + format, path + "negz" + format
-    ];
-}
+import { load_environment_map } from "./texture/cubemap/load_environment_map.js";
 
 /**
  *
@@ -261,56 +240,6 @@ GraphicsEngine.prototype.getRenderer = function () {
     return this.renderer;
 };
 
-/**
- *
- * @param {string[]|string} paths
- * @return {Promise<THREE.CubeTexture>}
- */
-function load_cube_texture(paths) {
-    // piece-wise cubemap, a collection of images for each face
-    const cubeTextureLoader = new CubeTextureLoader();
-    return new Promise((resolve, reject) => {
-        cubeTextureLoader.load(
-            paths,
-            texture => {
-                resolve(texture);
-            },
-            noop,
-            reject
-        );
-    });
-}
-
-/**
- *
- * @param {string} path
- * @return {Promise<THREE.Texture>}
- */
-function load_exr_texture(path) {
-    return new Promise((resolve, reject) => {
-        new EXRLoader()
-            .setDataType(UnsignedByteType)
-            .load(path, texture => {
-                resolve(texture);
-            }, noop, reject);
-    })
-}
-
-/**
- *
- * @param {string} path
- * @return {Promise<THREE.Texture>}
- */
-function load_standard_texture(path) {
-    return new Promise((resolve, reject) => {
-        new TextureLoader()
-            .load(path, texture => {
-                texture.encoding = sRGBEncoding;
-                resolve(texture);
-            }, noop, reject);
-    })
-}
-
 /**
  *
  * @param {string[]|string} paths URLs to faces of the cubemap
@@ -318,52 +247,16 @@ function load_standard_texture(path) {
  */
 GraphicsEngine.prototype.loadEnvironmentMap = async function (paths) {
 
-    const pmremGenerator = new PMREMGenerator(this.renderer);
-    let cube_rt;
-
-    if (Array.isArray(paths)) {
-        /**
-         *
-         * @type {THREE.CubeTexture}
-         */
-        const cube_texture = await load_cube_texture(paths);
-
-        cube_texture.encoding = sRGBEncoding;
-
-        // generate pre-filtered cubemap
-        pmremGenerator.compileCubemapShader();
-
-        cube_rt = pmremGenerator.fromCubemap(cube_texture);
-
-        // cleanup
-        cube_texture.dispose();
-    } else if (typeof paths === 'string') {
-        // single cubemap
-        const extension = computeFileExtension(paths).toLowerCase();
-        let texture;
-        if (extension === 'exr') {
-            texture = await load_exr_texture(paths);
-        } else if (extension === 'jpg') {
-            texture = await load_standard_texture(paths);
-        } else {
-            // unsupported extension
-            throw new Error(`Unsupported cube map texture extension '${extension}'`);
-        }
-        cube_rt = pmremGenerator.fromEquirectangular(texture);
-
-        texture.dispose();
-    } else {
-        throw new Error(`Unsupported parameter format: '${paths}'`);
-    }
-
-    pmremGenerator.dispose();
-
-    // assign environment
-    const t = cube_rt.texture;
-    this.scene.environment = t;
+    const { filtered } = await load_environment_map({
+        path: paths,
+        renderer: this.renderer,
+        original: false,
+        filtered: true
+    });
 
+    this.scene.environment = filtered;
 
-    return t;
+    return filtered;
 }
 
 GraphicsEngine.prototype.updateSize = function () {

package/engine/graphics/ecs/mesh/updateNodeByTransformAndBBB.js

@@ -1,7 +1,5 @@
-import { max2 } from "../../../../core/math/max2.js";
-import { min2 } from "../../../../core/math/min2.js";
-import { composeMatrix4 } from "../../util/composeMatrix4.js";
 import { Matrix4 as ThreeMatrix4 } from "three";
+import { aabb3_matrix4_project_by_corners } from "../../../../core/geom/3d/aabb/aabb3_matrix4_project_by_corners.js";
 
 
 const matrix4 = new ThreeMatrix4();
@@ -13,6 +11,12 @@ const matrix4 = new ThreeMatrix4();
  */
 const corners = new Float64Array(24);
 
+/**
+ *
+ * @type {Float32Array}
+ */
+const scratch_aabb = new Float32Array(6);
+
 /**
  *
  * @param {LeafNode} bvh
@@ -20,20 +24,7 @@ const corners = new Float64Array(24);
  * @param {Transform} transform
  */
 export function updateNodeByTransformAndBBB(bvh, boundingBox, transform) {
-    const position = transform.position;
-    const scale = transform.scale;
-    const rotation = transform.rotation;
-
-    composeMatrix4(matrix4, position, rotation, scale);
-
-    let x0 = Infinity,
-        y0 = Infinity,
-        z0 = Infinity,
-        x1 = -Infinity,
-        y1 = -Infinity,
-        z1 = -Infinity;
-
-    boundingBox.getCorners(corners);
+    transform.toThreeMatrix(matrix4);
 
     /**
      * Shortcut elements for faster access
@@ -41,29 +32,23 @@ export function updateNodeByTransformAndBBB(bvh, boundingBox, transform) {
      */
     const e = matrix4.elements;
 
-    for (let j = 0; j < 24; j += 3) {
-        const x = corners[j];
-        const y = corners[j + 1];
-        const z = corners[j + 2];
-
-        // perform matrix transform on corners
-
-        const w = 1 / (e[3] * x + e[7] * y + e[11] * z + e[15]);
+    updateNodeByMatrix4AndBBB(bvh, boundingBox, e);
+}
 
-        const _x = (e[0] * x + e[4] * y + e[8] * z + e[12]) * w;
-        const _y = (e[1] * x + e[5] * y + e[9] * z + e[13]) * w;
-        const _z = (e[2] * x + e[6] * y + e[10] * z + e[14]) * w;
+/**
+ *
+ * @param {LeafNode} bvh
+ * @param {AABB3} boundingBox
+ * @param {number[]} matrix4
+ */
+export function updateNodeByMatrix4AndBBB(bvh, boundingBox, matrix4) {
+    boundingBox.getCorners(corners);
 
-        // update AABB bounds
 
-        x0 = min2(x0, _x);
-        y0 = min2(y0, _y);
-        z0 = min2(z0, _z);
+    aabb3_matrix4_project_by_corners(scratch_aabb, corners, matrix4);
 
-        x1 = max2(x1, _x);
-        y1 = max2(y1, _y);
-        z1 = max2(z1, _z);
-    }
+    bvh.readFromArray(scratch_aabb, 0);
 
-    bvh.resize(x0, y0, z0, x1, y1, z1);
+    bvh.bubbleRefit();
 }
+

package/engine/graphics/ecs/mesh-v2/ShadedGeometry.js

@@ -0,0 +1,155 @@
+import { Mesh, Quaternion } from "three";
+import { updateNodeByMatrix4AndBBB } from "../mesh/updateNodeByTransformAndBBB.js";
+import { LeafNode } from "../../../../core/bvh2/LeafNode.js";
+import { AABB3 } from "../../../../core/bvh2/aabb3/AABB3.js";
+
+const _q = new Quaternion();
+const _aabb3 = new AABB3();
+
+export class ShadedGeometry {
+    constructor() {
+        /**
+         *
+         * @type {THREE.BufferGeometry|null}
+         */
+        this.geometry = null;
+        /**
+         *
+         * @type {THREE.Material|null}
+         */
+        this.material = null;
+
+        /**
+         *
+         * @type {THREE.Object3D|null}
+         * @private
+         */
+        this.__cached_object = null;
+
+        /**
+         *
+         * @type {LeafNode<ShadedGeometry>}
+         * @private
+         */
+        this.__bvh_leaf = new LeafNode(this, 0, 0, 0, 0, 0, 0);
+    }
+
+    get bvh() {
+        return this.__bvh_leaf;
+    }
+
+    /**
+     *
+     * @param {THREE.BufferGeometry} geometry
+     * @param {THREE.Material} material
+     */
+    from(geometry, material) {
+        this.geometry = geometry;
+        this.material = material;
+
+        // ensure that geometry has a bounding box
+        if (geometry.boundingBox === null) {
+            geometry.computeBoundingBox();
+        }
+
+        if (this.__cached_object === null) {
+            this.__cached_object = new Mesh(geometry, material);
+        } else {
+            this.__cached_object.material = material;
+            this.__cached_object.geometry = geometry;
+        }
+    }
+
+    /**
+     *
+     * @param geometry
+     * @param material
+     * @return {ShadedGeometry}
+     */
+    static from(geometry, material) {
+        const r = new ShadedGeometry();
+
+        r.from(geometry, material);
+
+        return r;
+    }
+
+    updateTransform() {
+        // update matrix
+        this.__cached_object.updateMatrix();
+
+        // update bounds
+
+        const gbb = this.geometry.boundingBox;
+
+        _aabb3.setBounds(
+            gbb.min.x,
+            gbb.min.y,
+            gbb.min.z,
+            gbb.max.x,
+            gbb.max.y,
+            gbb.max.z
+        );
+
+        updateNodeByMatrix4AndBBB(this.__bvh_leaf, _aabb3, this.__cached_object.matrix.elements);
+    }
+
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     */
+    setPositionByComponents(x, y, z) {
+
+        this.__cached_object.position.set(x, y, z);
+
+        this.updateTransform();
+    }
+
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @param {number} w
+     */
+    setRotationByComponents(x, y, z, w) {
+
+        _q.set(x, y, z, w);
+
+        this.__cached_object.rotation.setFromQuaternion(_q);
+
+        this.updateTransform();
+    }
+
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     */
+    setScaleByComponents(x, y, z) {
+        this.__cached_object.scale.set(x, y, z);
+
+        this.updateTransform();
+    }
+
+    /**
+     *
+     * @param {Transform} t
+     */
+    applyTransform(t) {
+        // TODO this can be optimized quite a lot
+        const position = t.position;
+        this.setPositionByComponents(position.x, position.y, position.z);
+
+        const rotation = t.rotation;
+        this.setRotationByComponents(rotation.x, rotation.y, rotation.z, rotation.w);
+
+        const scale = t.scale;
+        this.setScaleByComponents(scale.x, scale.y, scale.z);
+
+        this.updateTransform();
+    }
+}

package/engine/graphics/ecs/mesh-v2/ShadedGeometrySystem.js

@@ -0,0 +1,68 @@
+import { ShadedGeometry } from "./ShadedGeometry.js";
+import { Transform } from "../../../ecs/transform/Transform.js";
+import { System } from "../../../ecs/System.js";
+
+export class ShadedGeometrySystem extends System {
+    /**
+     *
+     * @param {Engine} engine
+     */
+    constructor(engine) {
+        super();
+        this.dependencies = [ShadedGeometry, Transform];
+
+        /**
+         *s
+         * @type {Engine}
+         * @private
+         */
+        this.__engine = engine;
+
+        /**
+         *
+         * @type {RenderLayer|null}
+         * @private
+         */
+        this.__render_layer = null;
+    }
+
+    async startup(entityManager, readyCallback, errorCallback) {
+
+        const engine = this.__engine;
+
+        this.__render_layer = engine.graphics.layers.create('shaded-geometry');
+        this.__render_layer.extractRenderable = (sg) => sg.__cached_object;
+
+        readyCallback();
+    }
+
+    /**
+     *
+     * @param {ShadedGeometry} sg
+     * @param {Transform} t
+     * @param {number} entity
+     */
+    link(sg, t, entity) {
+        t.position.onChanged.add(sg.setPositionByComponents, sg);
+        t.rotation.onChanged.add(sg.setRotationByComponents, sg);
+        t.scale.onChanged.add(sg.setScaleByComponents, sg);
+
+        sg.applyTransform(t);
+
+        this.__render_layer.bvh.insertNode(sg.bvh);
+    }
+
+    /**
+     *
+     * @param {ShadedGeometry} sg
+     * @param {Transform} t
+     * @param {number} entity
+     */
+    unlink(sg, t, entity) {
+        t.position.onChanged.remove(sg.setPositionByComponents, sg);
+        t.rotation.onChanged.remove(sg.setRotationByComponents, sg);
+        t.scale.onChanged.remove(sg.setScaleByComponents, sg);
+
+        sg.bvh.disconnect();
+    }
+}

package/engine/graphics/ecs/mesh-v2/prototypeShadedGeometry.js

@@ -0,0 +1,31 @@
+import { EngineHarness } from "../../../EngineHarness.js";
+import { ShadedGeometrySystem } from "./ShadedGeometrySystem.js";
+import EntityBuilder from "../../../ecs/EntityBuilder.js";
+import { Transform } from "../../../ecs/transform/Transform.js";
+import { ShadedGeometry } from "./ShadedGeometry.js";
+import { BoxBufferGeometry, MeshBasicMaterial } from "three";
+
+const eh = new EngineHarness();
+
+/**
+ *
+ * @param {Engine} engine
+ */
+async function main(engine) {
+
+    await engine.entityManager.addSystem(new ShadedGeometrySystem(engine));
+
+    EngineHarness.buildBasics({ engine })
+
+
+    const ecd = engine.entityManager.dataset;
+
+    new EntityBuilder()
+        .add(new Transform())
+        .add(ShadedGeometry.from(new BoxBufferGeometry(), new MeshBasicMaterial({
+            color: 0xFFFFFF
+        })))
+        .build(ecd);
+}
+
+eh.initialize().then(main);