@woosh/meep-engine 2.33.23 → 2.33.27

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

@@ -0,0 +1,478 @@
+import { ParticleEmitterFlag } from "../../emitter/ParticleEmitterFlag.js";
+import { PARTICLE_ATTRIBUTE_DEATH_AGE, PARTICLE_ATTRIBUTE_POSITION } from "../../emitter/PARTICLE_ATTRIBUTES.js";
+import { EmissionShapeType } from "../../emitter/EmissionShapeType.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";
+import { AttributeValue } from "./AttributeValue.js";
+import { PARTICULAR_PARTICLE_SPECIFICATION } from "../../emitter/PARTICULAR_PARTICLE_SPECIFICATION.js";
+import { SerializationMetadata } from "../../../../../../ecs/components/SerializationMetadata.js";
+import { UnitCubeShape3D } from "../../../../../../../core/geom/3d/shape/UnitCubeShape3D.js";
+
+/**
+ *
+ * @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;
+}
+
+const DEFAULT_ATTRIBUTE_VALUES = {
+    color: [1, 1, 1, 1],
+    age: [0],
+    velocity: [0, 0, 0],
+    deathAge: [99999999],
+    layerPosition: [0],
+    rotation: [0],
+    rotationSpeed: [0],
+    blending: [0],
+    size: [1],
+    initial_size: [1]
+};
+
+const EXPOSED_ATTRIBUTES = [
+    "color",
+    "size",
+    "blending"
+];
+
+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;
+
+        /**
+         *
+         * @type {AbstractShape3D}
+         * @private
+         */
+        this.__shape = new UnitCubeShape3D();
+
+        const eb = new EntityBuilder();
+
+        eb.add(this.__emitter)
+            .add(SerializationMetadata.Transient)
+            .add(this.__transform);
+
+        /**
+         *
+         * @type {EntityBuilder}
+         */
+        this.entity = eb;
+
+        /**
+         *
+         * @type {Object<AttributeValue>}
+         */
+        this.attributes = {};
+
+        this.init_attributes();
+    }
+
+    get shape() {
+        return this.__shape;
+    }
+
+    /**
+     * @private
+     */
+    init_attributes() {
+        const spec = PARTICULAR_PARTICLE_SPECIFICATION;
+
+        for (let i = 0; i < spec.attributes.length; i++) {
+            const attributeSpec = spec.attributes[i];
+
+            const av = new AttributeValue();
+            av.spec = attributeSpec;
+
+            const attribute_name = attributeSpec.name;
+
+            if (!EXPOSED_ATTRIBUTES.includes(attribute_name)) {
+                // don't expose attribute
+                continue;
+            }
+
+            const default_value = DEFAULT_ATTRIBUTE_VALUES[attribute_name];
+
+            if (default_value !== undefined) {
+                av.write_value(default_value);
+            }
+
+            this.attributes[attribute_name] = av;
+
+            const attribute_index = i;
+
+            av.onValueChange.add(() => {
+                this.__write_attribute(attribute_index);
+            });
+        }
+    }
+
+    get emitter() {
+        return this.__emitter;
+    }
+
+    get transform() {
+        return this.__transform;
+    }
+
+    /**
+     *
+     * @param {number} [density]
+     * @param {number} [particle_size]
+     * @param {AbstractShape3D} [shape]
+     * @param {boolean} sort
+     * @param {string} [sprite]
+     */
+    from({
+             density = 1,
+             particle_size = 1,
+             shape = new UnitCubeShape3D(),
+             sort = false,
+             sprite = "data/textures/particle/smokeparticle.png"
+         } = {}) {
+
+        this.__density = density;
+        this.__shape = shape;
+
+        this.__emitter.writeFlag(ParticleEmitterFlag.DepthSorting, sort);
+        this.__emitter.layers.get(0).imageURL = sprite;
+
+        const attributes = this.attributes;
+
+        attributes.size.write_value_silent([particle_size]);
+    }
+
+    /**
+     *
+     * @private
+     */
+    __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 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);
+
+        for (let i = 0; i < particle_count; i++) {
+
+            this.__shape.sample_random_point_in_volume(v3_position, 0, random);
+
+            vec3.transformMat4(v3_position, v3_position, m4_final.elements);
+
+            particles.writeAttributeVector3(i, PARTICLE_ATTRIBUTE_POSITION, v3_position[0], v3_position[1], v3_position[2]);
+        }
+
+        // request bounds update
+        emitter.setFlag(ParticleEmitterFlag.ParticleBoundsNeedUpdate);
+    }
+
+    /**
+     *
+     * @private
+     */
+    __write_attributes() {
+        this.__ensure_initialized();
+
+        const emitter = this.__emitter;
+        const particles = emitter.particles;
+
+        const attributes = particles.spec.attributes;
+
+        for (let i = 0; i < attributes.length; i++) {
+            const name = attributes[i].name;
+
+            if (this.attributes.hasOwnProperty(name)) {
+                this.__write_attribute(i);
+            }
+        }
+    }
+
+    /**
+     *
+     * @param {number} index
+     * @private
+     */
+    __write_attribute(index) {
+        this.__ensure_initialized();
+
+        const emitter = this.__emitter;
+        const particles = emitter.particles;
+
+        const spec = particles.spec.attributes[index];
+
+        const av = this.attributes[spec.name];
+
+        particles.writeAttributeForAllArray(index, av.__value);
+    }
+
+    build() {
+        const volume_value = this.__shape.volume;
+
+        // 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);
+
+        // set certain defaults
+        particles.writeAttributeForAllArray(PARTICLE_ATTRIBUTE_DEATH_AGE, [99999999]);
+
+        // fill out volume
+        this.__distribute(Math.random);
+
+        // apply attributes
+        this.__write_attributes();
+
+        // trigger sprite update
+        this.__emitter.setFlag(ParticleEmitterFlag.SpritesNeedUpdate);
+    }
+
+    /**
+     *
+     * @param {number} r
+     * @param {number} g
+     * @param {number} b
+     * @param {number} a
+     */
+    setColor(r, g, b, a) {
+        this.attributes.color.write_value([r, g, b, a]);
+    }
+}

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

@@ -0,0 +1,27 @@
+import { Sampler2D } from "../../../../../texture/sampler/Sampler2D.js";
+
+/**
+ *
+ * @param {ParameterLookupTable} lut
+ * @param {number} width
+ * @param {number} height
+ * @returns {Sampler2D}
+ */
+export function lut_to_sampler(lut, width, height) {
+    const sampler = Sampler2D.uint8(4, width, height);
+
+    const s = [];
+
+    for (let i = 0; i < width; i++) {
+
+        lut.sample(i / (width - 1), s);
+        s[3] = 255;
+
+        for (let j = 0; j < height; j++) {
+            sampler.set(i, j, s);
+        }
+
+    }
+
+    return sampler;
+}