@woosh/meep-engine 2.43.17 → 2.43.18

package/core/geom/3d/topology/struct/TopoTriangle.js

@@ -3,63 +3,7 @@ import { array_push_if_unique } from "../../../../collection/array/array_push_if
 import { assert } from "../../../../assert.js";
 import { array_remove_first } from "../../../../collection/array/array_remove_first.js";
 import { vec3 } from "gl-matrix";
-import { v3_length_sqr } from "../../../v3_length_sqr.js";
-
-/**
- *
- * @param {number[]|vec3} result
- * @param {Vector3|Vector3Like|TopoVertex|{x:number,y:number,z:number}} vA
- * @param {Vector3|Vector3Like|TopoVertex|{x:number,y:number,z:number}} vB
- * @param {Vector3|Vector3Like|TopoVertex|{x:number,y:number,z:number}} vC
- */
-export function compute_triangle_normal(result, vA, vB, vC) {
-
-    const vAx = vA.x
-    const vAy = vA.y
-    const vAz = vA.z
-
-    const vBx = vB.x
-    const vBy = vB.y
-    const vBz = vB.z
-
-    const vCx = vC.x
-    const vCy = vC.y
-    const vCz = vC.z
-
-    //compute CB and AB vectors
-    const vCBx = vCx - vBx;
-    const vCBy = vCy - vBy;
-    const vCBz = vCz - vBz;
-
-    const vABx = vAx - vBx;
-    const vABy = vAy - vBy;
-    const vABz = vAz - vBz;
-
-    //compute triangle normal
-    const crossX = vCBy * vABz - vCBz * vABy;
-    const crossY = vCBz * vABx - vCBx * vABz;
-    const crossZ = vCBx * vABy - vCBy * vABx;
-
-    const l_sqr = v3_length_sqr(crossX, crossY, crossZ);
-
-    if (l_sqr === 0) {
-        // degenerate triangle, provide arbitrary invalid result
-        vec3.set(result, 0, 0, 0);
-        return;
-    }
-
-    const l_inv = 1 / Math.sqrt(l_sqr);
-
-    const x = crossX * l_inv;
-    const y = crossY * l_inv;
-    const z = crossZ * l_inv;
-
-
-    vec3.set(
-        result,
-        x, y, z
-    );
-}
+import { compute_triangle_normal } from "../../compute_triangle_normal.js";
 
 let index_counter = 0;
 

package/core/geom/3d/topology/tm_face_normal.js

@@ -1,4 +1,4 @@
-import { compute_triangle_normal } from "./struct/TopoTriangle.js";
+import { compute_triangle_normal } from "../compute_triangle_normal.js";
 
 /**
  *

package/core/geom/3d/topology/tm_vertex_compute_normal.js

@@ -1,4 +1,4 @@
-import { compute_triangle_normal } from "./struct/TopoTriangle.js";
+import { compute_triangle_normal } from "../compute_triangle_normal.js";
 //
 
 

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

@@ -30,43 +30,43 @@ export function computeTriangleRayIntersection(
     bx, by, bz,
     cx, cy, cz
 ) {
-    assert.isNumber(ax,'ax');
-    assert.isNumber(ay,'ay');
-    assert.isNumber(az,'az');
+    assert.isNumber(ax, 'ax');
+    assert.isNumber(ay, 'ay');
+    assert.isNumber(az, 'az');
 
-    assert.isNumber(bx,'bx');
-    assert.isNumber(by,'by');
-    assert.isNumber(bz,'bz');
+    assert.isNumber(bx, 'bx');
+    assert.isNumber(by, 'by');
+    assert.isNumber(bz, 'bz');
 
-    assert.isNumber(cx,'cx');
-    assert.isNumber(cy,'cy');
-    assert.isNumber(cz,'cz');
+    assert.isNumber(cx, 'cx');
+    assert.isNumber(cy, 'cy');
+    assert.isNumber(cz, 'cz');
 
     // nan checks
-    assert.notNaN(ax,'ax');
-    assert.notNaN(ay,'ay');
-    assert.notNaN(az,'az');
+    assert.notNaN(ax, 'ax');
+    assert.notNaN(ay, 'ay');
+    assert.notNaN(az, 'az');
 
-    assert.notNaN(bx,'bx');
-    assert.notNaN(by,'by');
-    assert.notNaN(bz,'bz');
+    assert.notNaN(bx, 'bx');
+    assert.notNaN(by, 'by');
+    assert.notNaN(bz, 'bz');
 
-    assert.notNaN(cx,'cx');
-    assert.notNaN(cy,'cy');
-    assert.notNaN(cz,'cz');
+    assert.notNaN(cx, 'cx');
+    assert.notNaN(cy, 'cy');
+    assert.notNaN(cz, 'cz');
 
     // finate number check
-    assert.isFiniteNumber(ax,'ax');
-    assert.isFiniteNumber(ay,'ay');
-    assert.isFiniteNumber(az,'az');
+    assert.isFiniteNumber(ax, 'ax');
+    assert.isFiniteNumber(ay, 'ay');
+    assert.isFiniteNumber(az, 'az');
 
-    assert.isFiniteNumber(bx,'bx');
-    assert.isFiniteNumber(by,'by');
-    assert.isFiniteNumber(bz,'bz');
+    assert.isFiniteNumber(bx, 'bx');
+    assert.isFiniteNumber(by, 'by');
+    assert.isFiniteNumber(bz, 'bz');
 
-    assert.isFiniteNumber(cx,'cx');
-    assert.isFiniteNumber(cy,'cy');
-    assert.isFiniteNumber(cz,'cz');
+    assert.isFiniteNumber(cx, 'cx');
+    assert.isFiniteNumber(cy, 'cy');
+    assert.isFiniteNumber(cz, 'cz');
 
 
     // edge1 = a - b
@@ -157,3 +157,171 @@ export function computeTriangleRayIntersection(
 
     return true;
 }
+
+/**
+ * Compute barycentric coordinates for triangle intersection
+ * Operates on edges, this is optimized for raytracing, as same edges are required to reconstruct various attributes later on
+ * NOTE:  most of the code is inlined for speed to avoid allocation and function calls
+ * @see https://github.com/erich666/jgt-code/blob/master/Volume_02/Number_1/Moller1997a/raytri.c
+ * @source https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm (Möller and Trumbore, « Fast, Minimum Storage Ray-Triangle Intersection », Journal of Graphics Tools, vol. 2,‎ 1997, p. 21–28)
+ * @param {number[]} result
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} direction_x
+ * @param {number} direction_y
+ * @param {number} direction_z
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} az
+ * @param {number} edge1_x
+ * @param {number} edge1_y
+ * @param {number} edge1_z
+ * @param {number} edge2_x
+ * @param {number} edge2_y
+ * @param {number} edge2_z
+ * @return {boolean}
+ */
+export function computeTriangleRayIntersectionBarycentricEdge(result, origin_x, origin_y, origin_z, direction_x, direction_y, direction_z, ax, ay, az, edge1_x, edge1_y, edge1_z, edge2_x, edge2_y, edge2_z) {
+    // begin calculating determinant - also used to calculate U parameter
+
+    // CROSS(pvec, dir, edge2)
+    const pvec_x = direction_y * edge2_z - direction_z * edge2_y;
+    const pvec_y = direction_z * edge2_x - direction_x * edge2_z;
+    const pvec_z = direction_x * edge2_y - direction_y * edge2_x;
+
+    //if determinant is near zero, ray lies in plane of triangle
+    const det = v3_dot(edge1_x, edge1_y, edge1_z, pvec_x, pvec_y, pvec_z);
+
+    if (det <= 0) {
+        // back-face culling
+        return false;
+    }
+
+    // calculate distance from vert0 to ray origin (not really, but okay)
+    const tvec_x = origin_x - ax;
+    const tvec_y = origin_y - ay;
+    const tvec_z = origin_z - az;
+
+    // calculate u
+    let u = v3_dot(tvec_x, tvec_y, tvec_z, pvec_x, pvec_y, pvec_z);
+
+    if (u < 0 || u > det) {
+        // outside of bounds of the triangle
+        return false;
+    }
+
+    // prepare to test V parameter
+    // CROSS(qvec, tvec, edge1)
+    const qvec_x = tvec_y * edge1_z - tvec_z * edge1_y;
+    const qvec_y = tvec_z * edge1_x - tvec_x * edge1_z;
+    const qvec_z = tvec_x * edge1_y - tvec_y * edge1_x;
+
+    // calculate V parameter
+    let v = v3_dot(direction_x, direction_y, direction_z, qvec_x, qvec_y, qvec_z);
+
+    if (v < 0 || u + v > det) {
+        // out of bounds
+        return false;
+    }
+
+
+    const inv_det = 1 / det;
+
+    // calculate t, scale parameter, ray intersects triangle
+    const t = v3_dot(edge2_x, edge2_y, edge2_z, qvec_x, qvec_y, qvec_z) * inv_det;
+
+    u *= inv_det;
+    v *= inv_det;
+
+    result[0] = t;
+    result[1] = u;
+    result[2] = v;
+
+    return true;
+}
+
+/**
+ * Compute barycentric coordinates for triangle intersection
+ * NOTE:  most of the code is inlined for speed to avoid allocation and function calls
+ * @see https://github.com/erich666/jgt-code/blob/master/Volume_02/Number_1/Moller1997a/raytri.c
+ * @source https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm (Möller and Trumbore, « Fast, Minimum Storage Ray-Triangle Intersection », Journal of Graphics Tools, vol. 2,‎ 1997, p. 21–28)
+ * @param {number[]} result [t,u,v, normal_x, normal_y, normal_z] will be written here
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} direction_x
+ * @param {number} direction_y
+ * @param {number} direction_z
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} az
+ * @param {number} bx
+ * @param {number} by
+ * @param {number} bz
+ * @param {number} cx
+ * @param {number} cy
+ * @param {number} cz
+ * @returns {boolean}
+ */
+export function computeTriangleRayIntersectionBarycentric(
+    result,
+    origin_x, origin_y, origin_z,
+    direction_x, direction_y, direction_z,
+    ax, ay, az,
+    bx, by, bz,
+    cx, cy, cz
+) {
+    assert.isNumber(ax, 'ax');
+    assert.isNumber(ay, 'ay');
+    assert.isNumber(az, 'az');
+
+    assert.isNumber(bx, 'bx');
+    assert.isNumber(by, 'by');
+    assert.isNumber(bz, 'bz');
+
+    assert.isNumber(cx, 'cx');
+    assert.isNumber(cy, 'cy');
+    assert.isNumber(cz, 'cz');
+
+    // nan checks
+    assert.notNaN(ax, 'ax');
+    assert.notNaN(ay, 'ay');
+    assert.notNaN(az, 'az');
+
+    assert.notNaN(bx, 'bx');
+    assert.notNaN(by, 'by');
+    assert.notNaN(bz, 'bz');
+
+    assert.notNaN(cx, 'cx');
+    assert.notNaN(cy, 'cy');
+    assert.notNaN(cz, 'cz');
+
+    // finate number check
+    assert.isFiniteNumber(ax, 'ax');
+    assert.isFiniteNumber(ay, 'ay');
+    assert.isFiniteNumber(az, 'az');
+
+    assert.isFiniteNumber(bx, 'bx');
+    assert.isFiniteNumber(by, 'by');
+    assert.isFiniteNumber(bz, 'bz');
+
+    assert.isFiniteNumber(cx, 'cx');
+    assert.isFiniteNumber(cy, 'cy');
+    assert.isFiniteNumber(cz, 'cz');
+
+
+    // find vectors for two edges sharing vert
+
+    // edge1 = a - b
+    const edge1_x = bx - ax;
+    const edge1_y = by - ay;
+    const edge1_z = bz - az;
+
+    // edge2 = c - a
+    const edge2_x = cx - ax;
+    const edge2_y = cy - ay;
+    const edge2_z = cz - az;
+
+    return computeTriangleRayIntersectionBarycentricEdge(result, origin_x, origin_y, origin_z, direction_x, direction_y, direction_z, ax, ay, az, edge1_x, edge1_y, edge1_z, edge2_x, edge2_y, edge2_z);
+}

package/core/geom/Vector3.js

@@ -305,6 +305,18 @@ class Vector3 {
         return this;
     }
 
+    /**
+     *
+     * @param {Vector3} first
+     * @param {Vector3} second
+     */
+    crossVectors(first, second) {
+        const ax = first.x, ay = first.y, az = first.z;
+        const bx = second.x, by = second.y, bz = second.z;
+
+        this._crossVectors(ax, ay, az, bx, by, bz);
+    }
+
     /**
      *
      * @param {number} ax
@@ -322,18 +334,6 @@ class Vector3 {
         this.set(x, y, z);
     }
 
-    /**
-     *
-     * @param {Vector3} first
-     * @param {Vector3} second
-     */
-    crossVectors(first, second) {
-        const ax = first.x, ay = first.y, az = first.z;
-        const bx = second.x, by = second.y, bz = second.z;
-
-        this._crossVectors(ax, ay, az, bx, by, bz);
-    }
-
     /**
      * Sets all components of the vector to absolute value (positive)
      * @returns {Vector3}

package/core/math/physics/brdf/D_GGX.js

@@ -0,0 +1,13 @@
+/**
+ * GGX diffuse distribution function
+ * @see https://google.github.io/filament/Filament.md.html#listing_diffusebrdf
+ * @param {number} NoH dot(n,h) where n is surface normal and h is half unit vector between incident light and outgoing light (view vector)
+ * @param {number} roughness
+ * @returns {number}
+ */
+export function D_GGX(NoH, roughness) {
+    const a = NoH * roughness;
+    const k = roughness / (1 - NoH * NoH + a * a);
+
+    return k * k * (1 / Math.PI);
+}

package/editor/tools/v2/prototypeTransformControls.js

@@ -9,6 +9,10 @@ import { Camera } from "../../../engine/graphics/ecs/camera/Camera.js";
 import { TransformAttachmentSystem } from "../../../engine/ecs/transform-attachment/TransformAttachmentSystem.js";
 import InputController from "../../../engine/input/ecs/components/InputController.js";
 import InputControllerSystem from "../../../engine/input/ecs/systems/InputControllerSystem.js";
+import { GLTFAssetLoader } from "../../../engine/asset/loaders/GLTFAssetLoader.js";
+import {
+    three_object_to_entity_composition
+} from "../../../engine/graphics/ecs/mesh-v2/three_object_to_entity_composition.js";
 
 const harness = new EngineHarness();
 
@@ -17,11 +21,13 @@ const harness = new EngineHarness();
  * @param {Engine} engine
  */
 async function main(engine) {
-    EngineHarness.buildBasics({
+    await EngineHarness.buildBasics({
         engine,
         cameraController: false
     });
 
+    const gltf_asset = await engine.assetManager.promise('data/models/sponza-pbr/gltf/sponza.glb', 'gltf');
+
 
     const ecd = engine.entityManager.dataset;
 
@@ -46,9 +52,13 @@ async function main(engine) {
 
     const controls = new TransformControls(camera.component.object, engine.gameView.el);
 
+    const entityNode = three_object_to_entity_composition(gltf_asset.create());
+    entityNode.build(ecd);
+    entityNode.transform.scale.multiplyScalar(0.1);
 
     controls.build(ecd); // add controls to the scene
-    controls.attach(cube_entity); // make controls target the cube
+    // controls.attach(cube_entity); // make controls target the cube
+    controls.attach(entityNode.entity.entity); // make controls target the cube
 
     new EntityBuilder()
         .add(new InputController([{
@@ -76,5 +86,7 @@ harness.initialize({
         config.addSystem(new ShadedGeometrySystem(engine));
         config.addSystem(new TransformAttachmentSystem(engine));
         config.addSystem(new InputControllerSystem(engine.devices));
+
+        config.addLoader('gltf', new GLTFAssetLoader());
     }
 }).then(main);

package/engine/ecs/parent/EntityNode.js

@@ -6,6 +6,9 @@ import { array_push_if_unique } from "../../../core/collection/array/array_push_
 import { Transform } from "../transform/Transform.js";
 import { TransformAttachment, TransformAttachmentFlags } from "../transform-attachment/TransformAttachment.js";
 import Signal from "../../../core/events/signal/Signal.js";
+import { EntityNodeFlags } from "./EntityNodeFlags.js";
+
+const DEFAULT_FLAGS = EntityNodeFlags.LiveManagement;
 
 export class EntityNode {
     /**
@@ -45,6 +48,52 @@ export class EntityNode {
             built: new Signal(),
             destroyed: new Signal()
         };
+
+        /**
+         *
+         * @type {number}
+         */
+        this.flags = DEFAULT_FLAGS;
+    }
+
+    /**
+     *
+     * @param {number|EntityNodeFlags} flag
+     * @returns {void}
+     */
+    setFlag(flag) {
+        this.flags |= flag;
+    }
+
+    /**
+     *
+     * @param {number|EntityNodeFlags} flag
+     * @returns {void}
+     */
+    clearFlag(flag) {
+        this.flags &= ~flag;
+    }
+
+    /**
+     *
+     * @param {number|EntityNodeFlags} flag
+     * @param {boolean} value
+     */
+    writeFlag(flag, value) {
+        if (value) {
+            this.setFlag(flag);
+        } else {
+            this.clearFlag(flag);
+        }
+    }
+
+    /**
+     *
+     * @param {number|EntityNodeFlags} flag
+     * @returns {boolean}
+     */
+    getFlag(flag) {
+        return (this.flags & flag) === flag;
     }
 
     /**
@@ -263,6 +312,28 @@ export class EntityNode {
         return this.__entity.isBuilt;
     }
 
+    attachListeners() {
+        if (this.getFlag(EntityNodeFlags.TransformObserved)) {
+            // already observed
+            return;
+        }
+
+        this.__transform.position.onChanged.add(this.__transform_sync_down, this);
+        this.__transform.scale.onChanged.add(this.__transform_sync_down, this);
+        this.__transform.rotation.onChanged.add(this.__transform_sync_down, this);
+
+        this.setFlag(EntityNodeFlags.TransformObserved);
+    }
+
+    detachListeners() {
+
+        this.__transform.position.onChanged.remove(this.__transform_sync_down, this);
+        this.__transform.scale.onChanged.remove(this.__transform_sync_down, this);
+        this.__transform.rotation.onChanged.remove(this.__transform_sync_down, this);
+
+        this.clearFlag(EntityNodeFlags.TransformObserved);
+    }
+
     /**
      *
      * @param {EntityComponentDataset} ecd
@@ -303,9 +374,9 @@ export class EntityNode {
         this.__transform_sync_down();
 
         // attach listeners
-        this.__transform.position.onChanged.add(this.__transform_sync_down, this);
-        this.__transform.scale.onChanged.add(this.__transform_sync_down, this);
-        this.__transform.rotation.onChanged.add(this.__transform_sync_down, this);
+        if (this.getFlag(EntityNodeFlags.LiveManagement)) {
+            this.attachListeners();
+        }
 
         this.__entity.build(ecd);
 
@@ -321,6 +392,7 @@ export class EntityNode {
         this.on.built.send0();
     }
 
+
     destroy() {
         if (!this.__entity.isBuilt) {
             // not built
@@ -329,10 +401,11 @@ export class EntityNode {
             return;
         }
 
-        // remove listeners
-        this.__transform.position.onChanged.remove(this.__transform_sync_down, this);
-        this.__transform.scale.onChanged.remove(this.__transform_sync_down, this);
-        this.__transform.rotation.onChanged.remove(this.__transform_sync_down, this);
+        if (this.getFlag(EntityNodeFlags.TransformObserved)) {
+
+            // remove listeners
+            this.detachListeners();
+        }
 
         // destroy children first
         const children = this.__children;

package/engine/ecs/parent/EntityNodeFlags.js

@@ -0,0 +1,8 @@
+/**
+ *
+ * @enum {number}
+ */
+export const EntityNodeFlags = {
+    LiveManagement: 1,
+    TransformObserved: 2
+};

package/engine/graphics/geometry/AttributeSpec.js

@@ -3,22 +3,28 @@ import { computeStringHash } from "../../../core/primitives/strings/computeStrin
 import { DataTypeByteSizes } from "../../../core/collection/table/DataTypeByteSizes.js";
 import { assert } from "../../../core/assert.js";
 
+/**
+ * Describes data structure of a single data attribute, such as a scalar, or a vector
+ * This structure is designed to map well to GPU shader formats and is intended for larger datasets, such as meshes or particle clouds
+ */
 export class AttributeSpec {
     constructor() {
         /**
-         *
+         * Typically unique within a given set, used to identify the attribute
          * @type {string}
          */
         this.name = "";
 
         /**
-         *
+         * How the attribute is stored in memory and interpreted
          * @type {DataType}
          */
         this.type = DataType.Float32;
 
         /**
-         *
+         * How many elements the attribute uses. This is cardinality of a vector.
+         * 1 means the attribute is a scalar
+         * must be greater or equal to 1
          * @type {number}
          */
         this.itemSize = 1;
@@ -62,6 +68,15 @@ export class AttributeSpec {
         this.normalized = normalized;
     }
 
+    toJSON() {
+        return {
+            name: this.name,
+            type: this.type,
+            itemSize: this.itemSize,
+            normalized: this.normalized
+        };
+    }
+
     hash() {
         return computeStringHash(this.name);
     }