@woosh/meep-engine 2.60.1 → 2.62.0

package/src/engine/graphics/particles/ecs/ParticleEmitterSystem.js

@@ -1,14 +1,17 @@
-import { System } from "../../../ecs/System.js";
-import { ParticleEmitter } from "../particular/engine/emitter/ParticleEmitter.js";
-import { ParticularEngine } from "../particular/engine/ParticularEngine.js";
-import { Transform } from "../../../ecs/transform/Transform.js";
-import { ParticleEmitterFlag } from "../particular/engine/emitter/ParticleEmitterFlag.js";
-import { RenderPassType } from "../../render/RenderPassType.js";
-import { ImageRGBADataLoader } from "../../../asset/loaders/image/ImageRGBADataLoader.js";
-import { StandardFrameBuffers } from "../../StandardFrameBuffers.js";
-import { assert } from "../../../../core/assert.js";
-import { ResourceAccessSpecification } from "../../../../core/model/ResourceAccessSpecification.js";
-import { ResourceAccessKind } from "../../../../core/model/ResourceAccessKind.js";
+import {assert} from "../../../../core/assert.js";
+import {
+    bvh_query_user_data_overlaps_frustum
+} from "../../../../core/bvh2/bvh3/query/bvh_query_user_data_overlaps_frustum.js";
+import {ResourceAccessKind} from "../../../../core/model/ResourceAccessKind.js";
+import {ResourceAccessSpecification} from "../../../../core/model/ResourceAccessSpecification.js";
+import {ImageRGBADataLoader} from "../../../asset/loaders/image/ImageRGBADataLoader.js";
+import {System} from "../../../ecs/System.js";
+import {Transform} from "../../../ecs/transform/Transform.js";
+import {RenderPassType} from "../../render/RenderPassType.js";
+import {StandardFrameBuffers} from "../../StandardFrameBuffers.js";
+import {ParticleEmitter} from "../particular/engine/emitter/ParticleEmitter.js";
+import {ParticleEmitterFlag} from "../particular/engine/emitter/ParticleEmitterFlag.js";
+import {ParticularEngine} from "../particular/engine/ParticularEngine.js";
 
 /**
  *
@@ -19,6 +22,7 @@ function extractRenderable(emitter) {
     return emitter.mesh;
 }
 
+const scratch_array = [];
 
 export class ParticleEmitterSystem extends System {
     /**
@@ -63,19 +67,9 @@ export class ParticleEmitterSystem extends System {
          */
         this.renderLayer = null;
 
-        /**
-         *
-         * @type {BinaryNode}
-         */
-        this.bvh = null;
-
         this.__handlers = [];
     }
 
-    get componentClass() {
-        return ParticleEmitter;
-    }
-
     async startup(entityManager, readyCallback, errorCallback) {
         const am = this.assetManager;
 
@@ -95,7 +89,32 @@ export class ParticleEmitterSystem extends System {
 
         renderLayer.renderPass = RenderPassType.Transparent;
 
-        renderLayer.extractRenderable = extractRenderable;
+        renderLayer.buildVisibleSet = (destination, destination_offset, view) => {
+
+            const ecd = entityManager.dataset;
+
+            if (ecd === null) {
+                return 0;
+            }
+
+            const view_frustum = view.frustum;
+
+            const hit_count = bvh_query_user_data_overlaps_frustum(scratch_array, 0, this.particleEngine.bvh, view_frustum);
+
+            for (let i = 0; i < hit_count; i++) {
+                const id = scratch_array[i];
+
+                /**
+                 * @type {ParticleEmitter}
+                 */
+                const emitter = ecd.getComponent(id, ParticleEmitter);
+
+                destination[destination_offset + i] = emitter.mesh;
+            }
+
+            return hit_count;
+        };
+
         renderLayer.visibleSet.onAdded.add((points) => {
             /**
              *
@@ -121,9 +140,6 @@ export class ParticleEmitterSystem extends System {
             // console.log('Removed', emitter, renderLayer.visibleSet.version);
         });
 
-        this.bvh = renderLayer.bvh;
-        this.bvh.insertNode(this.particleEngine.bvh);
-
 
         const depthBuffer = graphicsEngine.frameBuffers.getById(StandardFrameBuffers.ColorAndDepth);
 
@@ -236,6 +252,8 @@ export class ParticleEmitterSystem extends System {
         //initialize emitter as suspended to prevent needless updates
         emitter.setFlag(ParticleEmitterFlag.Sleeping);
 
+        emitter.id = entity;
+
         // emitter.bvhLeaf.entity = entity; //this line makes emitter selectable via bounding box in editor
 
         this.particleEngine.add(emitter);

package/src/engine/graphics/particles/particular/engine/ParticularEngine.js

@@ -1,267 +1,247 @@
-import { ShaderManager } from "./shader/ShaderManager.js";
-import { BinaryNode } from "../../../../../core/bvh2/BinaryNode.js";
+import {
+    ExplicitBinaryBoundingVolumeHierarchy
+} from "../../../../../core/bvh2/bvh3/ExplicitBinaryBoundingVolumeHierarchy.js";
 import List from "../../../../../core/collection/list/List.js";
-import { ParticleEmitterFlag } from "./emitter/ParticleEmitterFlag.js";
-import { SimulationStepFixedPhysics } from "./simulator/SimulationStepFixedPhysics.js";
-import { SimulationStepCurlNoiseAcceleration } from "./simulator/SimulationStepCurlNoiseAcceleration.js";
-import { SimulationStepApplyForce } from "./simulator/SimulationStepApplyForce.js";
-import { SimulationStepCurlNoiseVelocity } from "./simulator/SimulationStepCurlNoiseVelocity.js";
-
-
-/**
- *
- * @param {AssetManager} assetManager
- * @param {MaterialManager} material_manager
- * @constructor
- */
-function ParticularEngine(assetManager, material_manager) {
-    this.shaderManager = new ShaderManager(assetManager, material_manager);
+import {ParticleEmitterFlag} from "./emitter/ParticleEmitterFlag.js";
+import {ShaderManager} from "./shader/ShaderManager.js";
+import {SimulationStepApplyForce} from "./simulator/SimulationStepApplyForce.js";
+import {SimulationStepCurlNoiseAcceleration} from "./simulator/SimulationStepCurlNoiseAcceleration.js";
+import {SimulationStepCurlNoiseVelocity} from "./simulator/SimulationStepCurlNoiseVelocity.js";
+import {SimulationStepFixedPhysics} from "./simulator/SimulationStepFixedPhysics.js";
 
+
+export class ParticularEngine {
     /**
      *
      * @type {THREE.Camera|null}
      */
-    this.camera = null;
+    camera = null;
 
     /**
      * Managed emitters
      * @type {List.<ParticleEmitter>}
      */
-    this.emitters = new List();
+    emitters = new List();
 
-    this.bvh = new BinaryNode();
-    this.bvh.setNegativelyInfiniteBounds();
+    /**
+     * @readonly
+     * @type {ExplicitBinaryBoundingVolumeHierarchy}
+     */
+    bvh = new ExplicitBinaryBoundingVolumeHierarchy();
 
 
     /**
      *
      * @type {AbstractSimulationStep[]}
      */
-    this.steps = [
+    steps = [
         new SimulationStepFixedPhysics(),
         new SimulationStepCurlNoiseAcceleration(),
         new SimulationStepCurlNoiseVelocity(),
         new SimulationStepApplyForce()
     ];
-}
 
-/**
- *
- * @param {ParticleEmitter} emitter
- */
-ParticularEngine.prototype.add = function (emitter) {
-    if (!emitter.getFlag(ParticleEmitterFlag.Built)) {
-        emitter.build();
+    /**
+     *
+     * @param {AssetManager} assetManager
+     * @param {MaterialManager} material_manager
+     * @constructor
+     */
+    constructor(assetManager, material_manager) {
+        this.shaderManager = new ShaderManager(assetManager, material_manager);
     }
 
-    //mark sprites for update as their UVs might have changed since last usage
-    emitter.setFlag(ParticleEmitterFlag.SpritesNeedUpdate);
-
-    this.emitters.add(emitter);
-
-    this.shaderManager.register(emitter);
+    /**
+     *
+     * @param {ParticleEmitter} emitter
+     */
+    add(emitter) {
+        if (!emitter.getFlag(ParticleEmitterFlag.Built)) {
+            emitter.build();
+        }
 
-    this.bvh.insertNode(emitter.bvhLeaf);
-};
+        //mark sprites for update as their UVs might have changed since last usage
+        emitter.setFlag(ParticleEmitterFlag.SpritesNeedUpdate);
 
-/**
- *
- * @param {ParticleEmitter} emitter
- */
-ParticularEngine.prototype.remove = function (emitter) {
-    const emitters = this.emitters;
+        this.emitters.add(emitter);
 
-    const i = emitters.indexOf(emitter);
+        this.shaderManager.register(emitter);
 
-    if (i !== -1) {
-        emitters.remove(i);
+        emitter.bvh_leaf.link(this.bvh, emitter.id);
     }
 
-    this.shaderManager.deregister(emitter);
-
-    emitter.bvhLeaf.disconnect();
-};
+    /**
+     *
+     * @param {ParticleEmitter} emitter
+     * @returns {boolean}
+     */
+    remove(emitter) {
 
-/**
- *
- * @param {THREE.Camera} camera
- */
-ParticularEngine.prototype.setCamera = function (camera) {
-    this.camera = camera;
-    this.shaderManager.setCamera(camera);
-};
+        const removed = this.emitters.removeOneOf(emitter);
 
-ParticularEngine.prototype.setDepthTexture = function (texture) {
-    this.shaderManager.setDepthTexture(texture);
-};
+        if (!removed) {
+            return false;
+        }
 
-ParticularEngine.prototype.setViewportSize = function (x, y) {
-    this.shaderManager.setViewportSize(x, y);
-};
+        this.shaderManager.deregister(emitter);
 
-/**
- * @private
- * @param {ParticleEmitter} emitter
- * @param {number} timeDelta
- */
-ParticularEngine.prototype.advanceEmitter = function (emitter, timeDelta) {
-    let i, j;
+        emitter.bvh_leaf.unlink();
 
+        return true;
+    }
 
     /**
      *
-     * @type {List<ParticleLayer>}
+     * @param {THREE.Camera} camera
      */
-    const layers = emitter.layers;
+    setCamera(camera) {
+        this.camera = camera;
+        this.shaderManager.setCamera(camera);
+    }
 
-    const layer_count = layers.length;
+    setDepthTexture(texture) {
+        this.shaderManager.setDepthTexture(texture);
+    }
 
-    let step_mask = 0;
+    setViewportSize(x, y) {
+        this.shaderManager.setViewportSize(x, y);
+    }
 
-    const steps = this.steps;
+    /**
+     * @private
+     * @param {ParticleEmitter} emitter
+     * @param {number} timeDelta
+     */
+    advanceEmitter(emitter, timeDelta) {
+        let i, j;
 
-    for (j = 0; j < layer_count; j++) {
-        const particleLayer = layers.get(j);
 
-        const simulationStepDefinitions = particleLayer.steps;
+        /**
+         *
+         * @type {List<ParticleLayer>}
+         */
+        const layers = emitter.layers;
 
-        const n = simulationStepDefinitions.length;
+        const layer_count = layers.length;
 
-        for (i = 0; i < n; i++) {
-            /**
-             *
-             * @type {SimulationStepDefinition}
-             */
-            const stepDefinition = simulationStepDefinitions.get(i);
+        let step_mask = 0;
 
-            const type = stepDefinition.type;
+        const steps = this.steps;
 
-            step_mask |= 1 << type;
+        for (j = 0; j < layer_count; j++) {
+            const particleLayer = layers.get(j);
 
-            const step = steps[type];
+            const simulationStepDefinitions = particleLayer.steps;
 
-            if (step === undefined) {
-                // no step definition
-                continue;
-            }
+            const n = simulationStepDefinitions.length;
 
-            step.emitter = emitter;
-            step.timeDelta = timeDelta;
-            step.particles = emitter.particles;
-            step.layer_parameters[j] = stepDefinition.parameters;
-            step.includeLayer(j);
+            for (i = 0; i < n; i++) {
+                /**
+                 *
+                 * @type {SimulationStepDefinition}
+                 */
+                const stepDefinition = simulationStepDefinitions.get(i);
 
-        }
-    }
-
-    // apply simulation steps
-    const step_index_limit = steps.length;
+                const type = stepDefinition.type;
 
-    for (i = 0; i < step_index_limit; i++) {
-        const m = 1 << i;
-        const is_used = (step_mask & m) !== 0;
+                step_mask |= 1 << type;
 
-        if (is_used) {
-            const step = steps[i];
+                const step = steps[type];
 
-            step.layer_count = layer_count;
+                if (step === undefined) {
+                    // no step definition
+                    continue;
+                }
 
-            step.execute();
+                step.emitter = emitter;
+                step.timeDelta = timeDelta;
+                step.particles = emitter.particles;
+                step.layer_parameters[j] = stepDefinition.parameters;
+                step.includeLayer(j);
 
-            step.clear();
+            }
         }
-    }
 
-    emitter.advance(timeDelta);
+        // apply simulation steps
+        const step_index_limit = steps.length;
 
-};
+        for (i = 0; i < step_index_limit; i++) {
+            const m = 1 << i;
+            const is_used = (step_mask & m) !== 0;
 
-/**
- * @private
- * @param {ParticleEmitter} emitter
- * @param {number} timeDelta
- */
-ParticularEngine.prototype.updateEmitter = function (emitter, timeDelta) {
-    if (emitter.getFlag(ParticleEmitterFlag.Sleeping)) {
-        emitter.sleepTime += timeDelta;
-    } else {
+            if (is_used) {
+                const step = steps[i];
 
-        if (!emitter.getFlag(ParticleEmitterFlag.Initialized)) {
-            emitter.initialize();
-        }
+                step.layer_count = layer_count;
 
-        if (emitter.sleepTime > 0) {
-            //emitter was sleeping, need to catch up the simulation
-            const maxParticleLife = emitter.computeMaxEmittingParticleLife();
+                step.execute();
 
-            let wakingTime = Math.min(emitter.sleepTime, maxParticleLife - timeDelta);
+                step.clear();
+            }
+        }
 
-            const minWakingIncrement = 0.15;
+        emitter.advance(timeDelta);
 
-            const maxWakingSteps = 10;
+    }
 
-            const wakingIncrement = Math.max(wakingTime / maxWakingSteps, minWakingIncrement);
+    /**
+     * @private
+     * @param {ParticleEmitter} emitter
+     * @param {number} timeDelta
+     */
+    updateEmitter(emitter, timeDelta) {
+        if (emitter.getFlag(ParticleEmitterFlag.Sleeping)) {
+            emitter.sleepTime += timeDelta;
+        } else {
 
-            while (wakingTime > 0) {
-                const wakingStep = Math.min(wakingIncrement, wakingTime);
+            if (!emitter.getFlag(ParticleEmitterFlag.Initialized)) {
+                emitter.initialize();
+            }
 
-                this.advanceEmitter(emitter, wakingStep);
+            if (emitter.sleepTime > 0) {
+                //emitter was sleeping, need to catch up the simulation
+                const maxParticleLife = emitter.computeMaxEmittingParticleLife();
 
-                wakingTime -= wakingStep;
-            }
+                let wakingTime = Math.min(emitter.sleepTime, maxParticleLife - timeDelta);
 
-            //consume the sleep time
-            emitter.sleepTime = 0;
-        }
-        //advance simulation
-        this.advanceEmitter(emitter, timeDelta);
+                const minWakingIncrement = 0.15;
 
-        //update bounding box
-        emitter.computeBoundingBox();
-    }
-};
+                const maxWakingSteps = 10;
 
-ParticularEngine.prototype.update = function () {
-    const emitters = this.emitters;
+                const wakingIncrement = Math.max(wakingTime / maxWakingSteps, minWakingIncrement);
 
-    const numEmitters = emitters.length;
+                while (wakingTime > 0) {
+                    const wakingStep = Math.min(wakingIncrement, wakingTime);
 
-    for (let i = 0; i < numEmitters; i++) {
-        const emitter = emitters.get(i);
-        if (!emitter.getFlag(ParticleEmitterFlag.Sleeping)) {
+                    this.advanceEmitter(emitter, wakingStep);
 
-            emitter.update();
-        }
-    }
-};
+                    wakingTime -= wakingStep;
+                }
 
-ParticularEngine.prototype.sortParticles = function () {
-    const emitters = this.emitters;
+                //consume the sleep time
+                emitter.sleepTime = 0;
+            }
 
-    const numEmitters = emitters.length;
+            //advance simulation
+            this.advanceEmitter(emitter, timeDelta);
 
-    for (let i = 0; i < numEmitters; i++) {
-        const emitter = emitters.get(i);
-        if (!emitter.getFlag(ParticleEmitterFlag.Sleeping) && emitter.getFlag(ParticleEmitterFlag.DepthSorting)) {
-            //sort particles by position from camera
-            emitter.sort(this.camera);
+            //update bounding box
+            emitter.computeBoundingBox();
         }
     }
-};
 
-/**
- *
- * @param {number} timeDelta
- */
-ParticularEngine.prototype.advance = function (timeDelta) {
-    const emitters = this.emitters;
+    /**
+     *
+     * @param {number} timeDelta
+     */
+    advance(timeDelta) {
+        const emitters = this.emitters;
 
-    const numEmitters = emitters.length;
+        const numEmitters = emitters.length;
 
-    for (let i = 0; i < numEmitters; i++) {
-        const emitter = emitters.get(i);
-        this.updateEmitter(emitter, timeDelta);
+        for (let i = 0; i < numEmitters; i++) {
+            const emitter = emitters.get(i);
+            this.updateEmitter(emitter, timeDelta);
+        }
     }
-};
-
-export { ParticularEngine };
+}

package/src/engine/graphics/particles/particular/engine/emitter/ParticleEmitter.js

@@ -1,20 +1,23 @@
-import Vector3 from "../../../../../../core/geom/Vector3.js";
+import {Box3, BufferGeometry, Frustum, Points, PointsMaterial} from 'three';
+import {assert} from "../../../../../../core/assert.js";
+import {EBBVHLeafProxy} from "../../../../../../core/bvh2/bvh3/EBBVHLeafProxy.js";
+import {computeHashIntegerArray} from "../../../../../../core/collection/array/computeHashIntegerArray.js";
 import List from "../../../../../../core/collection/list/List.js";
-import { lerp } from "../../../../../../core/math/lerp.js";
-import { max2 } from "../../../../../../core/math/max2.js";
-import { min2 } from "../../../../../../core/math/min2.js";
-import { Box3, BufferGeometry, Frustum, Points, PointsMaterial } from 'three';
-import { ParticlePool } from "./ParticlePool.js";
-import { ParticleParameter } from "../parameter/ParticleParameter.js";
-import { ParameterSet } from "../parameter/ParameterSet.js";
-import { assert } from "../../../../../../core/assert.js";
-import { LeafNode } from "../../../../../../core/bvh2/LeafNode.js";
-import { ParticleLayer } from "./ParticleLayer.js";
-import { ParticleParameters } from "./ParticleParameters.js";
-import { BlendingType } from "../../../../texture/sampler/BlendingType.js";
+import {AABB3} from "../../../../../../core/geom/3d/aabb/AABB3.js";
+import {aabb3_array_combine} from "../../../../../../core/geom/3d/aabb/aabb3_array_combine.js";
+import {compose_matrix4_array} from "../../../../../../core/geom/3d/compose_matrix4_array.js";
 import Quaternion from "../../../../../../core/geom/Quaternion.js";
-import { ParticleEmitterFlag } from "./ParticleEmitterFlag.js";
-import { AABB3 } from "../../../../../../core/geom/3d/aabb/AABB3.js";
+import {v3_dot_array_array} from "../../../../../../core/geom/vec3/v3_dot_array_array.js";
+import Vector3 from "../../../../../../core/geom/Vector3.js";
+import {lerp} from "../../../../../../core/math/lerp.js";
+import {max2} from "../../../../../../core/math/max2.js";
+import {min2} from "../../../../../../core/math/min2.js";
+import {frustum_from_camera} from "../../../../ecs/camera/frustum_from_camera.js";
+import {BlendingType} from "../../../../texture/sampler/BlendingType.js";
+import {ParameterSet} from "../parameter/ParameterSet.js";
+import {ParticleParameter} from "../parameter/ParticleParameter.js";
+import {update_parameters} from "../simulator/update_parameters.js";
+import {computeEmissionFunction} from "./computeEmissionFunction.js";
 import {
     PARTICLE_ATTRIBUTE_AGE,
     PARTICLE_ATTRIBUTE_BLEND,
@@ -28,13 +31,11 @@ import {
     PARTICLE_ATTRIBUTE_UV,
     PARTICLE_ATTRIBUTE_VELOCITY
 } from "./PARTICLE_ATTRIBUTES.js";
-import { update_parameters } from "../simulator/update_parameters.js";
-import { computeEmissionFunction } from "./computeEmissionFunction.js";
-import { PARTICULAR_PARTICLE_SPECIFICATION } from "./PARTICULAR_PARTICLE_SPECIFICATION.js";
-import { computeHashIntegerArray } from "../../../../../../core/collection/array/computeHashIntegerArray.js";
-import { frustum_from_camera } from "../../../../ecs/camera/frustum_from_camera.js";
-import { v3_dot_array_array } from "../../../../../../core/geom/vec3/v3_dot_array_array.js";
-import { compose_matrix4_array } from "../../../../../../core/geom/3d/compose_matrix4_array.js";
+import {ParticleEmitterFlag} from "./ParticleEmitterFlag.js";
+import {ParticleLayer} from "./ParticleLayer.js";
+import {ParticleParameters} from "./ParticleParameters.js";
+import {ParticlePool} from "./ParticlePool.js";
+import {PARTICULAR_PARTICLE_SPECIFICATION} from "./PARTICULAR_PARTICLE_SPECIFICATION.js";
 
 const EMPTY_GEOMETRY = new BufferGeometry();
 
@@ -111,7 +112,13 @@ function write_particle_patch_uv(patch, particles, ref) {
     );
 }
 
+let id_counter = 0;
+
 export class ParticleEmitter {
+    /**
+     * @type {number}
+     */
+    id = id_counter++;
 
     /**
      * @private
@@ -160,13 +167,14 @@ export class ParticleEmitter {
     mesh = null;
 
     /**
-     *
-     * @type {LeafNode}
+     * @readonly
+     * @type {EBBVHLeafProxy}
      */
-    bvhLeaf = new LeafNode(this, 0, 0, 0, 0, 0, 0);
+    bvh_leaf = new EBBVHLeafProxy();
+
 
     /**
-     *
+     * Upper-bound of bounds for an individual particle
      * @type {AABB3}
      */
     particleBounds = new AABB3(Infinity, Infinity, Infinity, -Infinity, -Infinity, -Infinity);
@@ -542,21 +550,9 @@ export class ParticleEmitter {
         const ebb = this.emissionBounds;
         const pbb = this.particleBounds;
 
-        const bounds_x0 = min2(ebb.x0, pbb.x0);
-        const bounds_y0 = min2(ebb.y0, pbb.y0);
-        const bounds_z0 = min2(ebb.z0, pbb.z0);
-
-        const bounds_x1 = max2(ebb.x1, pbb.x1);
-        const bounds_y1 = max2(ebb.y1, pbb.y1);
-        const bounds_z1 = max2(ebb.z1, pbb.z1);
+        aabb3_array_combine(this.bvh_leaf.bounds, ebb, pbb);
 
-        const bvhLeaf = this.bvhLeaf;
-
-        bvhLeaf.setBounds(bounds_x0, bounds_y0, bounds_z0, bounds_x1, bounds_y1, bounds_z1);
-
-        if (bvhLeaf.parentNode !== null) {
-            bvhLeaf.parentNode.bubbleRefit();
-        }
+        this.bvh_leaf.write_bounds();
 
     }
 
@@ -1221,7 +1217,7 @@ ParticleEmitter.SERIALIZABLE_FLAGS = SERIALIZABLE_FLAGS;
 
 const matrix4 = new Float32Array(16);
 
-const defaultPointsMaterial = new PointsMaterial({ color: 0xFFFFFF });
+const defaultPointsMaterial = new PointsMaterial({color: 0xFFFFFF});
 
 const frustum = new Frustum();