@woosh/meep-engine 2.33.24 → 2.33.28

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

@@ -0,0 +1,141 @@
+import Signal from "../../../../../../../core/events/signal/Signal.js";
+import { DataType2TypedArrayConstructorMapping } from "../../../../../../../core/collection/table/DataType2TypedArrayConstructorMapping.js";
+import { array_copy } from "../../../../../../../core/collection/array/copyArray.js";
+import { min2 } from "../../../../../../../core/math/min2.js";
+import { assert } from "../../../../../../../core/assert.js";
+
+export class AttributeValue {
+    constructor() {
+        /**
+         * Attribute spec
+         * @type {AttributeSpec}
+         */
+        this.__spec = null;
+
+        /**
+         *
+         * @type {number[]}
+         */
+        this.__value = [];
+
+        /**
+         *
+         * @type {ParameterLookupTable}
+         * @private
+         */
+        this.__lut = null;
+
+        /**
+         *
+         * @type {Signal}
+         */
+        this.onValueChange = new Signal();
+    }
+
+    /**
+     * @param {AttributeSpec} s
+     */
+    set spec(s) {
+        this.__spec = s;
+        this.init();
+    }
+
+    /**
+     *
+     * @returns {AttributeSpec}
+     */
+    get spec() {
+        return this.__spec;
+    }
+
+    /**
+     * Will generate actual typed value storage
+     */
+    init() {
+        const spec = this.__spec;
+
+        const TAC = DataType2TypedArrayConstructorMapping[spec.type];
+
+        const new_storage = new TAC(spec.itemSize);
+
+        array_copy(this.__value, 0, new_storage, 0, min2(this.__value.length, new_storage.length));
+
+        this.__value = new_storage;
+    }
+
+    /**
+     * @param {ParameterLookupTable} v
+     */
+    set lookup(v) {
+        this.__lut = v;
+    }
+
+    /**
+     *
+     * @returns {ParameterLookupTable}
+     */
+    get lookup() {
+        return this.__lut;
+    }
+
+    /**
+     *
+     * @param {number} v
+     */
+    write_lookup_value(v) {
+        assert.isNumber(v, 'v');
+
+        if (this.__lut === null) {
+            throw new Error('No lookup table attached');
+        }
+
+        const r = [];
+
+        this.__lut.sample(v, r);
+
+        this.write_value(r);
+    }
+
+    /**
+     *
+     * @param {number[]} v
+     */
+    write_value_silent(v) {
+        this.onValueChange.mute();
+        this.write_value(v);
+        this.onValueChange.unmute();
+    }
+
+    /**
+     *
+     * @param {number[]} v
+     */
+    write_value(v) {
+        let change_flag = false;
+
+        const itemSize = this.__spec.itemSize;
+
+        for (let i = 0; i < itemSize; i++) {
+            const old = this.__value[i];
+
+            this.__value[i] = v[i];
+
+            if (this.__value[i] !== old) {
+                // stored value has changed
+                change_flag = true;
+            }
+        }
+
+        if (change_flag) {
+            this.onValueChange.send0();
+        }
+    }
+
+    /**
+     *
+     * @param {number[]} destination
+     */
+    read_value(destination) {
+        array_copy(this.__value, 0, destination, 0, this.spec.itemSize);
+    }
+}

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

@@ -1,17 +1,6 @@
 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 { PARTICLE_ATTRIBUTE_DEATH_AGE, PARTICLE_ATTRIBUTE_POSITION } 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";
@@ -19,6 +8,10 @@ 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";
 
 /**
  *
@@ -69,6 +62,25 @@ function computeEmitterVolume(emitter, transform) {
     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() {
@@ -220,9 +232,17 @@ export class ParticleVolume {
          */
         this.__density = 1;
 
+        /**
+         *
+         * @type {AbstractShape3D}
+         * @private
+         */
+        this.__shape = new UnitCubeShape3D();
+
         const eb = new EntityBuilder();
 
         eb.add(this.__emitter)
+            .add(SerializationMetadata.Transient)
             .add(this.__transform);
 
         /**
@@ -230,6 +250,53 @@ export class ParticleVolume {
          * @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() {
@@ -240,17 +307,37 @@ export class ParticleVolume {
         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.layers.get(0).particleSize.set(particle_size, particle_size);
+        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;
@@ -279,8 +366,6 @@ export class ParticleVolume {
 
         const layer = emitter.layers.get(0);
 
-        const volume_sampler = computeEmissionFunction(layer.emissionFrom, layer.emissionShape);
-
         const m4_transform = new Matrix4();
 
         const t = this.__transform;
@@ -298,40 +383,60 @@ export class ParticleVolume {
 
         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);
+            this.__shape.sample_random_point_in_volume(v3_position, 0, random);
 
             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);
+        // request bounds update
+        emitter.setFlag(ParticleEmitterFlag.ParticleBoundsNeedUpdate);
+    }
 
-            const size = layer.particleSize.sampleRandom(random);
+    /**
+     *
+     * @private
+     */
+    __write_attributes() {
+        this.__ensure_initialized();
 
-            particles.writeAttributeScalar(i, PARTICLE_ATTRIBUTE_SIZE_INITIAL, size);
-            particles.writeAttributeScalar(i, PARTICLE_ATTRIBUTE_SIZE, size);
+        const emitter = this.__emitter;
+        const particles = emitter.particles;
 
-            particles.writeAttributeScalar(i, PARTICLE_ATTRIBUTE_LAYER_POSITION, 0);
+        const attributes = particles.spec.attributes;
 
-            particles.writeAttributeVector4(i, PARTICLE_ATTRIBUTE_COLOR, 1, 1, 1, 1);
+        for (let i = 0; i < attributes.length; i++) {
+            const name = attributes[i].name;
 
-            particles.writeAttributeScalar(i, PARTICLE_ATTRIBUTE_BLEND, blending);
+            if (this.attributes.hasOwnProperty(name)) {
+                this.__write_attribute(i);
+            }
         }
+    }
 
-        // request bounds update
-        emitter.setFlag(ParticleEmitterFlag.ParticleBoundsNeedUpdate);
+    /**
+     *
+     * @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 = computeEmitterVolume(this.__emitter, this.__transform);
+        const volume_value = this.__shape.volume;
 
         // total particle count
         const particle_count = Math.max(1, Math.ceil(volume_value * this.__density));
@@ -347,10 +452,17 @@ export class ParticleVolume {
         // "spawn" particles to occupy the entire pool
         particles.occupancy.setRange(0, particle_count - 1);
 
-        // trigger sprite update
-        this.__emitter.setFlag(ParticleEmitterFlag.SpritesNeedUpdate);
+        // 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);
     }
 
     /**
@@ -361,24 +473,6 @@ export class ParticleVolume {
      * @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;
+        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;
+}