@woosh/meep-engine 2.43.17 → 2.43.19

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/ecs/mesh-v2/ShadedGeometrySystem.js

@@ -11,7 +11,7 @@ import { ray3_array_compose } from "../../../../core/geom/3d/ray/ray3_array_comp
 import {
     ExplicitBinaryBoundingVolumeHierarchy
 } from "../../../../core/bvh2/bvh3/ExplicitBinaryBoundingVolumeHierarchy.js";
-import { bvh_query_leaves_generic } from "../../../../core/bvh2/bvh3/bvh_query_leaves_generic.js";
+import { bvh_query_leaves_generic } from "../../../../core/bvh2/bvh3/query/bvh_query_leaves_generic.js";
 import { BVHQueryIntersectsRay } from "../../../../core/bvh2/bvh3/query/BVHQueryIntersectsRay.js";
 import Task from "../../../../core/process/task/Task.js";
 import { RuntimeDrawMethodOptimizer } from "./render/optimization/RuntimeDrawMethodOptimizer.js";
@@ -19,7 +19,7 @@ import { TaskSignal } from "../../../../core/process/task/TaskSignal.js";
 import TaskState from "../../../../core/process/task/TaskState.js";
 import {
     bvh_query_user_data_overlaps_frustum
-} from "../../../../core/bvh2/bvh3/bvh_query_user_data_overlaps_frustum.js";
+} from "../../../../core/bvh2/bvh3/query/bvh_query_user_data_overlaps_frustum.js";
 
 
 /**

package/engine/graphics/ecs/mesh-v2/aggregate/SGMesh.js

@@ -7,6 +7,14 @@ export const SGMeshFlags = {
     Loaded: 4
 };
 
+/**
+ * @readonly
+ * @type {number}
+ */
+const DEFAULT_FLAGS = SGMeshFlags.CastShadow
+    | SGMeshFlags.ReceiveShadow
+;
+
 export class SGMesh {
     constructor() {
         /**
@@ -33,7 +41,7 @@ export class SGMesh {
          *
          * @type {number}
          */
-        this.flags = 0;
+        this.flags = DEFAULT_FLAGS;
     }
 
     /**

package/engine/graphics/ecs/mesh-v2/render/ShadedGeometryRendererContext.js

@@ -5,7 +5,7 @@ import { assert } from "../../../../../core/assert.js";
 import { ShadedGeometry } from "../ShadedGeometry.js";
 import {
     bvh_query_user_data_overlaps_frustum
-} from "../../../../../core/bvh2/bvh3/bvh_query_user_data_overlaps_frustum.js";
+} from "../../../../../core/bvh2/bvh3/query/bvh_query_user_data_overlaps_frustum.js";
 import { ShadedGeometryFlags } from "../ShadedGeometryFlags.js";
 
 /**

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

package/engine/graphics/geometry/VertexDataSpec.js

@@ -1,9 +1,19 @@
 import { invokeObjectHash } from "../../../core/model/object/invokeObjectHash.js";
 import { computeHashArray } from "../../../core/collection/array/computeHashArray.js";
 import { isArrayEqual } from "../../../core/collection/array/isArrayEqual.js";
+import { AttributeSpec } from "./AttributeSpec.js";
+import { assert } from "../../../core/assert.js";
 
-const DEFAULT_HASH = 123456;
+/**
+ * @readonly
+ * @type {number}
+ */
+const DEFAULT_HASH = 1234567;
 
+/**
+ * Describes a set of data attributes. A good analogy would be "all data associated with geometry vertex"
+ * @example "uv","position" and "normal" attributes of geometry vertices
+ */
 export class VertexDataSpec {
     constructor() {
         /**
@@ -13,7 +23,7 @@ export class VertexDataSpec {
         this.attributes = [];
 
         /**
-         *
+         * Cached hash for speed
          * @type {number}
          * @private
          */
@@ -92,6 +102,8 @@ export class VertexDataSpec {
      */
     add(attribute) {
 
+        assert.equal(attribute.isAttributeSpec, true, 'attribute.isAttributeSpec !== true');
+
         //check uniqueness of name
         if (this.getAttributeByName(attribute.name) !== undefined) {
             throw new Error(`Attribute named '${attribute.name}' already exists`);
@@ -111,7 +123,19 @@ export class VertexDataSpec {
      * @param {AttributeSpec[]} attributes
      */
     setAttributes(attributes) {
-        this.attributes = attributes;
+
+        this.clear();
+
+        const n = attributes.length;
+
+        for (let i = 0; i < n; i++) {
+            this.add(attributes[i]);
+        }
+
+    }
+
+    clear() {
+        this.attributes.splice(0, this.attributes.length);
 
         // reset hash to trigger hash update
         this.__hash = DEFAULT_HASH;
@@ -142,6 +166,32 @@ export class VertexDataSpec {
         return this.__hash;
     }
 
+    toJSON() {
+        return {
+            attributes: JSON.stringify(this.attributes)
+        };
+    }
+
+    fromJSON({
+                 attributes = []
+             }) {
+
+        this.clear();
+
+        const n = attributes.length;
+
+        for (let i = 0; i < n; i++) {
+
+            const aj = attributes[i];
+
+            const attribute = AttributeSpec.fromJSON(aj);
+
+            this.add(attribute);
+
+        }
+
+    }
+
     /**
      *
      * @returns {number}

package/engine/graphics/micron/format/VirtualGeometry.js

@@ -57,8 +57,15 @@ export class VirtualGeometry {
         this.stats_source_byte_size = 0;
     }
 
+    /**
+     *
+     * @param {number} patch_count how much must be supported
+     * @return {boolean} true if capacity was sufficient, false if had to be resized
+     */
     ensureCapacity(patch_count) {
         if (this.__capacity < patch_count) {
+            // grow capacity
+
             const new_capacity = Math.ceil(max3(
                 patch_count,
                 patch_count * CAPACITY_GROW_FACTOR,

package/engine/graphics/micron/render/VirtualGeometryBuilder.js

@@ -149,7 +149,7 @@ export class VirtualGeometryBuilder {
         output.loolup_geometries[geometry.id] = geometry;
         output.lookup_instance_transforms[instance_id] = transform;
 
-        // build up occurances
+        // build up occurrences
         get_geometry_patch_cut(
             output,
             refinement_spec,

package/engine/graphics/micron/render/refinement/get_geometry_patch_cut.js

@@ -95,11 +95,13 @@ export function get_geometry_patch_cut(
                 for (i = 0; i < child_count; i++) {
                     const child = children[i];
 
-                    if (included_set.getAndSet(child.id)) {
+                    const child_id = child.id;
+
+                    if (included_set.getAndSet(child_id)) {
                         continue;
                     }
 
-                    stack[stack_cursor++] = child.id;
+                    stack[stack_cursor++] = child_id;
                 }
 
                 continue;
@@ -122,6 +124,7 @@ export function get_geometry_patch_cut(
     if (!destination.ensureCapacity(output_patch_cursor)) {
         // redo the work
         get_geometry_patch_cut(destination, spec, geometry, instance_id, transform);
+
     } else {
 
         destination.patch_count = output_patch_cursor;

package/engine/graphics/particles/particular/engine/parameter/sample/RGBA_LUT_HEATMAP_IR.js

@@ -0,0 +1,11 @@
+import { ParameterLookupTable } from "../ParameterLookupTable.js";
+
+export const RGBA_LUT_HEATMAP_IR = new ParameterLookupTable(4);
+RGBA_LUT_HEATMAP_IR.write([
+    0, 0, 255, 10,
+    0, 179, 179, 10,
+    0, 255, 0, 10,
+    255, 255, 0, 10,
+    255, 5, 5, 10
+]);
+RGBA_LUT_HEATMAP_IR.computeUniformPositions();

package/engine/graphics/particles/particular/engine/utils/volume/prototypeParticleVolume.js

@@ -81,6 +81,7 @@ import { pick } from "../../../../../../../ecs/grid/pick.js";
 import { clamp01 } from "../../../../../../../core/math/clamp01.js";
 import { randomFromArray } from "../../../../../../../core/math/random/randomFromArray.js";
 import { SamplingFunctionKind } from "./SamplingFunctionKind.js";
+import { RGBA_LUT_HEATMAP_IR } from "../../parameter/sample/RGBA_LUT_HEATMAP_IR.js";
 
 const engineHarness = new EngineHarness();
 
@@ -168,15 +169,7 @@ async function init(harness) {
 }
 
 
-const heatmap_lut_0 = new ParameterLookupTable(4);
-heatmap_lut_0.write([
-    0, 0, 255, 10,
-    0, 179, 179, 10,
-    0, 255, 0, 10,
-    255, 255, 0, 10,
-    255, 5, 5, 10
-]);
-heatmap_lut_0.computeUniformPositions();
+const heatmap_lut_0 = RGBA_LUT_HEATMAP_IR;
 
 const heatmap_lut_orange_to_red = new ParameterLookupTable(4);
 heatmap_lut_orange_to_red.write([

package/engine/graphics/render/forward_plus/model/DirectionalLight.js

@@ -0,0 +1,40 @@
+import { AbstractLight } from "./AbstractLight.js";
+import Vector3 from "../../../../../core/geom/Vector3.js";
+import { Color } from "../../../../../core/color/Color.js";
+import Vector1 from "../../../../../core/geom/Vector1.js";
+
+export class DirectionalLight extends AbstractLight {
+constructor() {
+    super();
+
+    /**
+     *
+     * @type {Vector3}
+     */
+    this.position = new Vector3();
+
+    /**
+     *
+     * @type {Vector3}
+     */
+    this.direction = new Vector3();
+
+    /**
+     * @readonly
+     * @type {Color}
+     */
+    this.color = new Color(1, 1, 1);
+
+    /**
+     *
+     * @type {Vector1}
+     */
+    this.intensity = new Vector1(1);
+}
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+DirectionalLight.prototype.isDirectionalLight = true;

package/engine/graphics/sh3/README.md

@@ -2,3 +2,4 @@ Path tracing ideas:
 * https://raytracing.github.io/books/RayTracingInOneWeekend.html
 * [smallpt](https://www.kevinbeason.com/smallpt/) (100 line c implementation of path tracer)
 * [three path tracer](https://github.com/gkjohnson/three-gpu-pathtracer)
+* http://blog.hvidtfeldts.net/index.php/2015/01/path-tracing-3d-fractals/