@woosh/meep-engine 2.41.0 → 2.42.0

package/core/geom/3d/apply_mat4_transform_to_v3_array.js

@@ -6,11 +6,9 @@
  * @param {number[]|Float32Array|Float64Array} destination
  * @param {number} destination_offset
  * @param {number} count
- * @param {THREE.Matrix4} matrix
+ * @param {mat4|number[]|Float32Array} mat4
  */
-export function apply_mat4_transform_to_v3_array(source, source_offset, destination, destination_offset, count, matrix) {
-
-    const mat4 = matrix.elements;
+export function apply_mat4_transform_to_v3_array(source, source_offset, destination, destination_offset, count, mat4) {
 
     const a0 = mat4[0];
     const a1 = mat4[1];

package/core/geom/3d/sphere/sphere_radius_sqr_from_v3_array_transformed.js

@@ -0,0 +1,28 @@
+/**
+ *
+ * @param {number[]|ArrayLike<number>} input
+ * @param {number} input_length
+ * @param {ArrayLike<number>|number[]|Float32Array} e 4x4 transformation matrix
+ * @returns {number}
+ */
+export function sphere_radius_sqr_from_v3_array_transformed(input, input_length, e) {
+    let result = 0;
+
+    for (let i = 0; i < input_length; i += 3) {
+        const x = input[i];
+        const y = input[i + 1];
+        const z = input[i + 2];
+
+        const _x = e[0] * x + e[4] * y + e[8] * z + e[12];
+        const _y = e[1] * x + e[5] * y + e[9] * z + e[13];
+        const _z = e[2] * x + e[6] * y + e[10] * z + e[14];
+
+        const l2 = _x * _x + _y * _y + _z * _z;
+
+        if (l2 > result) {
+            result = l2;
+        }
+    }
+
+    return result;
+}

package/core/geom/Quaternion.js

@@ -1705,6 +1705,20 @@ class Quaternion {
         return result;
     }
 
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @returns {Quaternion}
+     */
+    static fromEulerAngles(x, y, z) {
+        const r = new Quaternion();
+
+        r.fromEulerAnglesXYZ(x, y, z);
+
+        return r;
+    }
 
     /**
      * Behaves similarly to Unity's Quaternion `RotateToward` method

package/engine/EngineHarness.js

@@ -153,6 +153,7 @@ export class EngineHarness {
      * @param {boolean} [autoClip]
      * @param {number} [distanceMin]
      * @param {number} [distanceMax]
+     * @param {number} [fieldOfView] in degrees
      * @returns {EntityBuilder}
      */
     static buildCamera(
@@ -163,9 +164,10 @@ export class EngineHarness {
             distance = 10,
             pitch = 1.4,
             yaw = 0,
-            autoClip = true,
+            autoClip = false,
             distanceMin = 0,
-            distanceMax = 1000
+            distanceMax = 1000,
+            fieldOfView = 45
         }
     ) {
         const em = engine.entityManager;
@@ -199,6 +201,7 @@ export class EngineHarness {
 
         camera.active.set(true);
         camera.autoClip = autoClip;
+        camera.fov.set(fieldOfView);
 
         const entityBuilder = new EntityBuilder();
 
@@ -229,6 +232,7 @@ export class EngineHarness {
      * @param {boolean} [enableWater]
      * @param {boolean} [enableTerrain]
      * @param {boolean} [enableLights=true]
+     * @param {number} [cameraFieldOfView]
      * @param {boolean} [cameraController=true]
      */
     static async buildBasics({
@@ -244,6 +248,7 @@ export class EngineHarness {
                                  enableWater = true,
                                  enableTerrain = true,
                                  enableLights = true,
+                                 cameraFieldOfView,
                                  cameraController = true
                              }) {
 
@@ -256,7 +261,8 @@ export class EngineHarness {
             target: focus,
             pitch,
             yaw,
-            distance
+            distance,
+            fieldOfView: cameraFieldOfView
         });
 
         const cameraEntity = camera.entity;

package/engine/ecs/transform/Transform.js

@@ -63,9 +63,29 @@ export class Transform {
         this.flags = FLAGS_DEFAULT;
 
         // watch changes
-        this.position.onChanged.add(this.__handle_component_change, this);
-        this.rotation.onChanged.add(this.__handle_component_change, this);
-        this.scale.onChanged.add(this.__handle_component_change, this);
+        this.subscribeAllChanges(this.__handle_component_change, this);
+    }
+
+    /**
+     *
+     * @param {function} handler
+     * @param {*} [thisArg]
+     */
+    subscribeAllChanges(handler, thisArg) {
+        this.position.onChanged.add(handler, thisArg);
+        this.rotation.onChanged.add(handler, thisArg);
+        this.scale.onChanged.add(handler, thisArg);
+    }
+
+    /**
+     *
+     * @param {function} handler
+     * @param {*} [thisArg]
+     */
+    unsubscribeAllChanges(handler, thisArg) {
+        this.position.onChanged.remove(handler, thisArg);
+        this.rotation.onChanged.remove(handler, thisArg);
+        this.scale.onChanged.scale(handler, thisArg);
     }
 
     /**

package/engine/graphics/ecs/decal/v2/Decal.d.ts

@@ -0,0 +1,11 @@
+export class Decal {
+    /**
+     * Path to image
+     */
+    uri: string
+
+    /**
+     * Draw order, higher values will be drawn on top of lower values when there's an overlap
+     */
+    priority: number
+}

package/engine/graphics/ecs/decal/v2/Decal.js

@@ -0,0 +1,50 @@
+export class Decal {
+    constructor() {
+        /**
+         * Asset URL
+         * @type {string}
+         */
+        this.uri = "";
+
+        /**
+         * Controls draw order
+         * @type {number}
+         */
+        this.priority = 0;
+
+        /**
+         * Internal transient reference to loaded asset
+         * @type {Sampler2D|null}
+         * @private
+         */
+        this.__cached_sampler = null;
+        /**
+         *
+         * @type {String|null}
+         * @private
+         */
+        this.__cached_uri = null;
+    }
+
+    toJSON() {
+        return {
+            uri: this.uri,
+            priority: this.priority
+        };
+    }
+
+    fromJSON({
+                 uri, priority = 0
+             }) {
+        this.uri = uri;
+        this.priority = priority;
+
+        if (uri !== this.__cached_uri) {
+            // reset sampler
+            this.__cached_sampler = null;
+            this.__cached_uri = null;
+        }
+    }
+}
+
+Decal.typeName = 'Decal';

package/engine/graphics/ecs/decal/v2/FPDecalSystem.d.ts

@@ -0,0 +1,8 @@
+import {System} from "../../../../ecs/System";
+import {Decal} from "./Decal";
+import {Transform} from "../../../../ecs/transform/Transform";
+import Engine from "../../../../Engine";
+
+export class FPDecalSystem extends System<Decal, Transform> {
+    constructor(engine: Engine)
+}

package/engine/graphics/ecs/decal/v2/FPDecalSystem.js

@@ -0,0 +1,213 @@
+import { AbstractContextSystem } from "../../../../ecs/system/AbstractContextSystem.js";
+import { SystemEntityContext } from "../../../../ecs/system/SystemEntityContext.js";
+import { Decal } from "./Decal.js";
+import { Transform } from "../../../../ecs/transform/Transform.js";
+import { ForwardPlusRenderingPlugin } from "../../../render/forward_plus/plugin/ForwardPlusRenderingPlugin.js";
+import { Reference } from "../../../../reference/v2/Reference.js";
+import { Decal as FPDecal } from '../../../render/forward_plus/model/Decal.js';
+import { AssetManager } from "../../../../asset/AssetManager.js";
+import { Sampler2D } from "../../../texture/sampler/Sampler2D.js";
+import { GameAssetType } from "../../../../asset/GameAssetType.js";
+
+const placeholder_texture = Sampler2D.uint8(4, 1, 1);
+placeholder_texture.data.fill(255);
+
+class Context extends SystemEntityContext {
+    constructor() {
+        super();
+
+        /**
+         *
+         * @type {FPDecal|null}
+         * @private
+         */
+        this.__fp_decal = null;
+    }
+
+    /**
+     * @return {ForwardPlusRenderingPlugin}
+     * @private
+     */
+    getPlugin() {
+        return this.system.__fp_plugin.getValue();
+    }
+
+    /**
+     *
+     * @returns {Transform}
+     */
+    getTransform() {
+        return this.components[1];
+    }
+
+    __update_transform() {
+        /**
+         *
+         * @type {Transform}
+         */
+        const transform = this.getTransform();
+
+        this.__fp_decal.setTransform(transform.matrix);
+    }
+
+    async __load_texture() {
+
+        /**
+         *
+         * @type {Decal}
+         */
+        const decal_spec = this.components[0];
+
+        const _uri = decal_spec.uri;
+
+        if (decal_spec.__cached_sampler !== null && decal_spec.__cached_uri === _uri) {
+            // cached asset is still relevant
+            return;
+        }
+
+
+        const loaded_texture = await this.system.internal_loadTexture(_uri);
+
+        decal_spec.__cached_sampler = loaded_texture;
+        decal_spec.__cached_uri = _uri;
+    }
+
+    link() {
+        const plugin = this.getPlugin();
+
+        const lm = plugin.getLightManager();
+
+        const fpDecal = new FPDecal();
+
+        this.__fp_decal = fpDecal;
+
+
+        this.__update_transform();
+
+        const transform = this.getTransform();
+        transform.subscribeAllChanges(this.__update_transform, this);
+
+        /**
+         *
+         * @type {Decal}
+         */
+        const decal_spec = this.components[0];
+
+        this.__load_texture().then(() => {
+
+            if (!this.__is_linked) {
+                // not linked anymore
+                return;
+            }
+
+            const sampler = decal_spec.__cached_sampler;
+
+            if (sampler === null) {
+                return;
+            }
+
+            fpDecal.texture_diffuse = sampler;
+
+            if (this.__fp_decal === fpDecal) {
+                lm.addLight(fpDecal);
+            }
+        });
+
+
+        super.link();
+    }
+
+    unlink() {
+
+        this.getPlugin()
+            .getLightManager()
+            .removeLight(this.__fp_decal);
+
+        this.__fp_decal = null;
+
+        const transform = this.getTransform();
+        transform.subscribeAllChanges(this.__update_transform, this);
+
+        super.unlink();
+    }
+}
+
+export class FPDecalSystem extends AbstractContextSystem {
+    /**
+     *
+     * @param {Engine} engine
+     */
+    constructor(engine) {
+        super(Context);
+
+        this.dependencies = [Decal, Transform];
+
+        /**
+         *
+         * @type {Map<string, Sampler2D>}
+         * @private
+         */
+        this.__texture_cache = new Map();
+
+        /**
+         *
+         * @type {AssetManager}
+         * @private
+         */
+        this.__assets = engine.assetManager;
+
+        /**
+         *
+         * @type {Engine}
+         * @private
+         */
+        this.__engine = engine;
+
+        /**
+         *
+         * @type {Reference<ForwardPlusRenderingPlugin>|null}
+         * @private
+         */
+        this.__fp_plugin = Reference.NULL;
+    }
+
+    /**
+     *
+     * @param {string} uri
+     * @returns {Promise<void>}
+     */
+    async internal_loadTexture(uri) {
+        const cached = this.__texture_cache.get(uri);
+
+        if (cached !== undefined) {
+            return cached;
+        }
+
+        const asset = await this.__assets.promise(uri, GameAssetType.Image);
+
+        // check cache again, in case another request has succeeded
+        const cached_v2 = this.__texture_cache.get(uri);
+
+        if (cached_v2 !== undefined) {
+            return cached_v2;
+        }
+
+        const sampler = asset.create();
+
+        this.__texture_cache.set(uri, sampler);
+
+        return sampler;
+    }
+
+    async startup(em, ready_callback, error_callback) {
+        this.__fp_plugin = await this.__engine.plugins.acquire(ForwardPlusRenderingPlugin);
+
+        super.startup(em, ready_callback, error_callback);
+    }
+
+    shutdown(em, ready_callback, error_callback) {
+        this.__fp_plugin.release();
+
+        super.shutdown(em, ready_callback, error_callback);
+    }
+}