@woosh/meep-engine 2.33.20 → 2.33.24

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

@@ -0,0 +1,384 @@
+import { ParticleEmitterFlag } from "../../emitter/ParticleEmitterFlag.js";
+import {
+    PARTICLE_ATTRIBUTE_AGE,
+    PARTICLE_ATTRIBUTE_BLEND,
+    PARTICLE_ATTRIBUTE_COLOR,
+    PARTICLE_ATTRIBUTE_DEATH_AGE,
+    PARTICLE_ATTRIBUTE_LAYER_POSITION,
+    PARTICLE_ATTRIBUTE_POSITION,
+    PARTICLE_ATTRIBUTE_SIZE,
+    PARTICLE_ATTRIBUTE_SIZE_INITIAL,
+    PARTICLE_ATTRIBUTE_VELOCITY
+} from "../../emitter/PARTICLE_ATTRIBUTES.js";
+import { EmissionShapeType } from "../../emitter/EmissionShapeType.js";
+import { computeEmissionFunction } from "../../emitter/computeEmissionFunction.js";
+import { Matrix4 } from "three";
+import { composeMatrix4 } from "../../../../../util/composeMatrix4.js";
+import Quaternion from "../../../../../../../core/geom/Quaternion.js";
+import { ParticleEmitter } from "../../emitter/ParticleEmitter.js";
+import { Transform } from "../../../../../../ecs/transform/Transform.js";
+import EntityBuilder from "../../../../../../ecs/EntityBuilder.js";
+import { vec3 } from "gl-matrix";
+
+/**
+ *
+ * @param {ParticleLayer} layer
+ * @returns {number}
+ */
+function computeLayerVolume(layer) {
+    let base_volume = 0;
+
+    switch (layer.emissionShape) {
+        case EmissionShapeType.Box:
+            base_volume = 1;
+            break;
+        case EmissionShapeType.Sphere:
+            base_volume = 0.5236;
+            break;
+        case EmissionShapeType.Point:
+            base_volume = 0;
+            break;
+    }
+
+    const scale_volume = layer.scale.x * layer.scale.y * layer.scale.z;
+
+    return base_volume * scale_volume;
+}
+
+/**
+ *
+ * @param {ParticleEmitter} emitter
+ * @param {Transform} transform
+ * @returns {number}
+ */
+function computeEmitterVolume(emitter, transform) {
+
+    const layers = emitter.layers;
+    const n = layers.length;
+
+    let layer_volume_sum = 0;
+
+    for (let i = 0; i < n; i++) {
+        const particleLayer = layers.get(i);
+
+        layer_volume_sum += computeLayerVolume(particleLayer);
+    }
+
+    const scale_volume = transform.scale.x * transform.scale.y * transform.scale.z;
+
+    return layer_volume_sum * scale_volume;
+}
+
+export class ParticleVolume {
+
+    constructor() {
+        this.__emitter = new ParticleEmitter();
+
+        this.__emitter.fromJSON({
+            "parameters": [
+                {
+                    "name": "scale",
+                    "itemSize": 1,
+                    "defaultTrackValue": {
+                        "itemSize": 1,
+                        "data": [
+                            1
+                        ],
+                        "positions": [
+                            0
+                        ]
+                    }
+                },
+                {
+                    "name": "color",
+                    "itemSize": 4,
+                    "defaultTrackValue": {
+                        "itemSize": 4,
+                        "data": [
+                            1,
+                            1,
+                            1,
+                            1
+                        ],
+                        "positions": [
+                            0
+                        ]
+                    }
+                }
+            ],
+            "preWarm": false,
+            "readDepth": true,
+            "softDepth": true,
+            "depthSort": false,
+            "velocityAlign": false,
+            "blendingMode": 0,
+            "layers": [
+                {
+                    "imageURL": "data/textures/particle/smokeparticle.png",
+                    "particleLife": {
+                        "min": 6,
+                        "max": 8
+                    },
+                    "particleSize": {
+                        "min": 0.4,
+                        "max": 0.4
+                    },
+                    "particleRotation": {
+                        "min": 0,
+                        "max": 0
+                    },
+                    "particleRotationSpeed": {
+                        "min": 0,
+                        "max": 0
+                    },
+                    "emissionShape": 1,
+                    "emissionFrom": 1,
+                    "emissionRate": 0,
+                    "emissionImmediate": 0,
+                    "parameterTracks": [
+                        {
+                            "name": "color",
+                            "track": {
+                                "itemSize": 4,
+                                "data": [
+                                    0.5764705882352941,
+                                    0.5764705882352941,
+                                    0.5764705882352941,
+                                    0,
+                                    0.803921568627451,
+                                    0.803921568627451,
+                                    0.803921568627451,
+                                    0.28160919540229884,
+                                    0.803921568627451,
+                                    0.803921568627451,
+                                    0.803921568627451,
+                                    0.21264367816091953,
+                                    0.803921568627451,
+                                    0.803921568627451,
+                                    0.803921568627451,
+                                    0
+                                ],
+                                "positions": [
+                                    0,
+                                    0.18085106382978725,
+                                    0.7074468085106383,
+                                    1
+                                ]
+                            }
+                        },
+                        {
+                            "name": "scale",
+                            "track": {
+                                "itemSize": 1,
+                                "data": [
+                                    1
+                                ],
+                                "positions": [
+                                    0
+                                ]
+                            }
+                        }
+                    ],
+                    "position": {
+                        "x": 0,
+                        "y": 0,
+                        "z": 0
+                    },
+                    "scale": {
+                        "x": 1,
+                        "y": 1,
+                        "z": 1
+                    },
+                    "particleVelocityDirection": {
+                        "direction": {
+                            "x": 0,
+                            "y": 1,
+                            "z": 0
+                        },
+                        "angle": 0.1
+                    },
+                    "particleSpeed": {
+                        "min": 0,
+                        "max": 0
+                    },
+                    "steps": []
+                }
+            ]
+        });
+
+        /**
+         *
+         * @type {Transform}
+         * @private
+         */
+        this.__transform = new Transform();
+
+        /**
+         * Particle count per unit of volume
+         * @type {number}
+         * @private
+         */
+        this.__density = 1;
+
+        const eb = new EntityBuilder();
+
+        eb.add(this.__emitter)
+            .add(this.__transform);
+
+        /**
+         *
+         * @type {EntityBuilder}
+         */
+        this.entity = eb;
+    }
+
+    get emitter() {
+        return this.__emitter;
+    }
+
+    get transform() {
+        return this.__transform;
+    }
+
+    from({
+             density = 1,
+             particle_size = 1,
+         }) {
+
+        this.__density = density;
+
+        this.__emitter.layers.get(0).particleSize.set(particle_size, particle_size);
+
+    }
+
+    __ensure_initialized() {
+
+        const emitter = this.__emitter;
+
+        if (!emitter.getFlag(ParticleEmitterFlag.Built)) {
+            //particle pool needs to be set up first
+            emitter.build();
+        }
+
+        if (!emitter.getFlag(ParticleEmitterFlag.Initialized)) {
+            //particles are not initialized, do that
+            emitter.initialize();
+        }
+
+    }
+
+    /**
+     * Distribute particles in the volume
+     * @param {function():number} random
+     * @private
+     */
+    __distribute(random) {
+        const emitter = this.__emitter;
+        const particles = emitter.particles;
+        const particle_count = particles.size();
+
+        const layer = emitter.layers.get(0);
+
+        const volume_sampler = computeEmissionFunction(layer.emissionFrom, layer.emissionShape);
+
+        const m4_transform = new Matrix4();
+
+        const t = this.__transform;
+
+        composeMatrix4(m4_transform, t.position, t.rotation, t.scale);
+
+
+        const m4_layer = new Matrix4();
+
+        composeMatrix4(m4_layer, layer.position, new Quaternion(), layer.scale);
+
+        const v3_position = [];
+
+        const m4_final = new Matrix4();
+
+        m4_final.multiplyMatrices(m4_transform, m4_layer);
+
+        const blending = emitter.blendingMode;
+
+        for (let i = 0; i < particle_count; i++) {
+
+            volume_sampler(random, v3_position, 0);
+
+            vec3.transformMat4(v3_position, v3_position, m4_final.elements);
+
+            particles.writeAttributeScalar(i, PARTICLE_ATTRIBUTE_AGE, 0);
+
+            particles.writeAttributeVector3(i, PARTICLE_ATTRIBUTE_VELOCITY, 0, 0, 0);
+
+            particles.writeAttributeVector3(i, PARTICLE_ATTRIBUTE_POSITION, v3_position[0], v3_position[1], v3_position[2]);
+
+            particles.writeAttributeScalar(i, PARTICLE_ATTRIBUTE_DEATH_AGE, 99999999);
+
+            const size = layer.particleSize.sampleRandom(random);
+
+            particles.writeAttributeScalar(i, PARTICLE_ATTRIBUTE_SIZE_INITIAL, size);
+            particles.writeAttributeScalar(i, PARTICLE_ATTRIBUTE_SIZE, size);
+
+            particles.writeAttributeScalar(i, PARTICLE_ATTRIBUTE_LAYER_POSITION, 0);
+
+            particles.writeAttributeVector4(i, PARTICLE_ATTRIBUTE_COLOR, 1, 1, 1, 1);
+
+            particles.writeAttributeScalar(i, PARTICLE_ATTRIBUTE_BLEND, blending);
+        }
+
+        // request bounds update
+        emitter.setFlag(ParticleEmitterFlag.ParticleBoundsNeedUpdate);
+    }
+
+    build() {
+        const volume_value = computeEmitterVolume(this.__emitter, this.__transform);
+
+        // total particle count
+        const particle_count = Math.max(1, Math.ceil(volume_value * this.__density));
+
+
+        this.__ensure_initialized();
+
+        const particles = this.__emitter.particles;
+
+        // reserve particles
+        particles.setCapacity(particle_count);
+
+        // "spawn" particles to occupy the entire pool
+        particles.occupancy.setRange(0, particle_count - 1);
+
+        // trigger sprite update
+        this.__emitter.setFlag(ParticleEmitterFlag.SpritesNeedUpdate);
+
+        this.__distribute(Math.random);
+    }
+
+    /**
+     *
+     * @param {number} r
+     * @param {number} g
+     * @param {number} b
+     * @param {number} a
+     */
+    setColor(r, g, b, a) {
+
+        this.__ensure_initialized();
+
+        const emitter = this.__emitter;
+
+        const particles = emitter.particles;
+
+        const particle_count = particles.size();
+
+        for (let i = 0; i < particle_count; i++) {
+
+            particles.writeAttributeVector4(i, PARTICLE_ATTRIBUTE_COLOR, r, g, b, a);
+
+        }
+
+        const attribute = particles.attributes[PARTICLE_ATTRIBUTE_COLOR];
+        attribute.needsUpdate = true;
+        attribute.updateRange.count = particle_count;
+        attribute.updateRange.offset = 0;
+    }
+}