@woosh/meep-engine 2.45.2 → 2.46.0

package/src/engine/graphics/particles/particular/engine/emitter/serde/ParameterLookupTableSerializationAdapter.js

@@ -0,0 +1,105 @@
+import {
+    BinaryClassSerializationAdapter
+} from "../../../../../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
+import { ParameterLookupTable } from "../../parameter/ParameterLookupTable.js";
+
+export class ParameterLookupTableSerializationAdapter extends BinaryClassSerializationAdapter {
+    constructor() {
+        super();
+
+        this.klass = ParameterLookupTable;
+        this.version = 0;
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {ParameterLookupTable} value
+     */
+    serialize(buffer, value) {
+
+        const itemCount = value.positions.length;
+
+        const itemCountBitSize = Math.log2(itemCount);
+
+        let itemCountByteSize;
+
+        if (itemCountBitSize <= 8) {
+            itemCountByteSize = 1;
+        } else if (itemCountBitSize <= 16) {
+            itemCountByteSize = 2;
+        } else if (itemCountBitSize <= 32) {
+            itemCountByteSize = 4;
+        } else {
+            throw new Error(`Item count is too high`);
+        }
+
+        const itemSize = value.itemSize;
+        const header = itemSize | (itemCountByteSize << 4);
+
+        buffer.writeUint8(header);
+
+
+        //
+        if (itemCountByteSize === 1) {
+            buffer.writeUint8(itemCount);
+        } else if (itemCountByteSize === 2) {
+            buffer.writeUint16(itemCount);
+        } else if (itemCountByteSize === 4) {
+            buffer.writeUint32(itemCount);
+        }
+
+        const dataLength = itemCount * itemSize;
+
+        let i;
+
+        for (i = 0; i < dataLength; i++) {
+            buffer.writeFloat32(value.data[i]);
+        }
+
+        for (i = 0; i < itemCount; i++) {
+            buffer.writeFloat32(value.positions[i]);
+        }
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {ParameterLookupTable} value
+     */
+    deserialize(buffer, value) {
+        const header = buffer.readUint8();
+
+        value.itemSize = header & 0xF;
+
+        const itemCountByteSize = (header >> 4) & 0xF;
+
+        let itemCount;
+
+        if (itemCountByteSize === 1) {
+            itemCount = buffer.readUint8();
+        } else if (itemCountByteSize === 2) {
+            itemCount = buffer.readUint16();
+        } else if (itemCountByteSize === 4) {
+            itemCount = buffer.readUint32();
+        } else {
+            throw new Error(`Unsupported itemCountByteSize '${itemCountByteSize}'`);
+        }
+
+        const dataLength = itemCount * value.itemSize;
+
+        /**
+         * Reserve a continuous chunk of memory for faster access
+         * @type {ArrayBuffer}
+         */
+        const array_buffer = new ArrayBuffer((dataLength + itemCount) * 4);
+
+        const data = new Float32Array(array_buffer, itemCount * 4, dataLength);
+        buffer.readFloat32Array(data, 0, dataLength);
+
+        const positions = new Float32Array(array_buffer, 0, itemCount);
+        buffer.readFloat32Array(positions, 0, itemCount);
+
+        value.write(data, positions);
+    }
+}

package/src/engine/graphics/particles/particular/engine/emitter/serde/ParticleEmitterSerializationAdapter.js

@@ -0,0 +1,165 @@
+import {
+    BinaryClassSerializationAdapter
+} from "../../../../../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
+import { ParticleEmitter } from "../ParticleEmitter.js";
+import { ParticleLayer } from "../ParticleLayer.js";
+import { ParticleEmitterFlag } from "../ParticleEmitterFlag.js";
+import { SimulationStepDefinition } from "../../simulator/SimulationStepDefinition.js";
+
+export class ParticleEmitterSerializationAdapter extends BinaryClassSerializationAdapter {
+    constructor() {
+        super();
+
+        this.klass = ParticleEmitter;
+        this.version = 1;
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {ParticleEmitter} value
+     */
+    serialize(buffer, value) {
+        value.parameters.toBinaryBuffer(buffer);
+
+        //pack flags
+        buffer.writeUint32(value.flags & ParticleEmitter.SERIALIZABLE_FLAGS);
+
+        buffer.writeUint8(value.blendingMode);
+
+        const layers = value.layers;
+
+        const layer_count = layers.length;
+
+        buffer.writeUint32(layer_count);
+
+        for (let i = 0; i < layer_count; i++) {
+
+            /**
+             *
+             * @type {ParticleLayer}
+             */
+            const particleLayer = layers.get(i);
+
+            buffer.writeUTF8String(particleLayer.imageURL);
+            particleLayer.particleLife.toBinaryBuffer(buffer);
+            particleLayer.particleSize.toBinaryBuffer(buffer);
+            particleLayer.particleRotation.toBinaryBuffer(buffer);
+            particleLayer.particleRotationSpeed.toBinaryBuffer(buffer);
+            buffer.writeUint8(particleLayer.emissionShape);
+            buffer.writeUint8(particleLayer.emissionFrom);
+            buffer.writeFloat64(particleLayer.emissionRate);
+            buffer.writeUintVar(particleLayer.emissionImmediate);
+            particleLayer.parameterTracks.toBinaryBuffer(buffer);
+            particleLayer.position.toBinaryBufferFloat32(buffer);
+            particleLayer.scale.toBinaryBufferFloat32(buffer);
+            particleLayer.particleVelocityDirection.toBinaryBuffer(buffer);
+            particleLayer.particleSpeed.toBinaryBuffer(buffer);
+
+            // write simulation settings
+            const steps = particleLayer.steps;
+
+            const num_steps = steps.length;
+
+            buffer.writeUintVar(num_steps);
+
+            for (let j = 0; j < num_steps; j++) {
+                const simulationStepDefinition = steps.get(j);
+
+                buffer.writeUintVar(simulationStepDefinition.type);
+
+                const parameters = simulationStepDefinition.parameters;
+
+                const parameter_count = parameters.length;
+
+                buffer.writeUintVar(parameter_count);
+
+                for (let k = 0; k < parameter_count; k++) {
+
+                    const parameter_value = parameters[k];
+
+                    buffer.writeFloat64(parameter_value);
+
+                }
+            }
+        }
+
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {ParticleEmitter} value
+     */
+    deserialize(buffer, value) {
+        value.parameters.fromBinaryBuffer(buffer);
+
+        //read flags
+        const serializedFlags = buffer.readUint32();
+
+        //clear serializable flags
+        value.flags &= (~ParticleEmitter.SERIALIZABLE_FLAGS);
+
+        //write serialized flags
+        value.flags |= serializedFlags;
+
+        value.blendingMode = buffer.readUint8();
+
+        value.layers.reset();
+
+        const layer_count = buffer.readUint32();
+
+        for (let i = 0; i < layer_count; i++) {
+            const layer = new ParticleLayer();
+
+            layer.imageURL = buffer.readUTF8String();
+            layer.particleLife.fromBinaryBuffer(buffer);
+            layer.particleSize.fromBinaryBuffer(buffer);
+            layer.particleRotation.fromBinaryBuffer(buffer);
+            layer.particleRotationSpeed.fromBinaryBuffer(buffer);
+            layer.emissionShape = buffer.readUint8();
+            layer.emissionFrom = buffer.readUint8();
+            layer.emissionRate = buffer.readFloat64();
+            layer.emissionImmediate = buffer.readUintVar();
+            layer.parameterTracks.fromBinaryBuffer(buffer);
+            layer.position.fromBinaryBufferFloat32(buffer);
+            layer.scale.fromBinaryBufferFloat32(buffer);
+            layer.particleVelocityDirection.fromBinaryBuffer(buffer);
+            layer.particleSpeed.fromBinaryBuffer(buffer);
+
+            // read simulation parameters
+            const simulation_step_count = buffer.readUintVar();
+
+
+            layer.steps.reset();
+
+            for (let j = 0; j < simulation_step_count; j++) {
+                const simulation_step_id = buffer.readUintVar();
+
+                const definition = new SimulationStepDefinition();
+                definition.type = simulation_step_id;
+
+                const attribute_count = buffer.readUintVar();
+
+                for (let k = 0; k < attribute_count; k++) {
+                    definition.parameters[k] = buffer.readFloat64();
+                }
+
+                layer.steps.add(definition);
+
+            }
+
+            //reset bounds attributes
+            layer.scaledSpriteHalfSize = -1;
+
+            value.layers.add(layer);
+        }
+
+
+        value.writeFlag(ParticleEmitterFlag.Built, false);
+        value.setFlag(ParticleEmitterFlag.Emitting);
+
+        //register loaded layers
+        value.registerLayerParameters();
+    }
+}

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

@@ -0,0 +1,201 @@
+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";
+import { ParameterLookupTable } from "../../parameter/ParameterLookupTable.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;
+    }
+
+    set lookup_value(v) {
+        this.write_lookup_value(v);
+    }
+
+    /**
+     *
+     * @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);
+    }
+
+    /**
+     *
+     * @param {number[]} [value]
+     * @param {Object} [lookup]
+     * @param {number} [lookup_value]
+     */
+    fromJSON({
+                 value,
+                 lookup,
+                 lookup_value
+             }) {
+
+        if (value !== undefined) {
+            if (Array.isArray(value)) {
+
+                if (lookup !== undefined) {
+                    console.warn("Both 'lookup' and 'value' were specified, expected one or the other. Ignoring the value attribute.");
+                } else {
+                    this.write_value(value);
+                }
+
+            } else {
+                throw new Error(`Expected 'value' to be an array, instead got something else (=${value})`);
+            }
+        } else {
+            // retain current value
+        }
+
+        if (lookup !== undefined) {
+            const lut = new ParameterLookupTable();
+
+            lut.fromJSON(lookup);
+
+            this.lookup = lut;
+        } else {
+            this.lookup = null;
+        }
+
+        if (lookup_value !== undefined) {
+            assert.isNumber(lookup_value, 'lookup_value');
+            assert.isFiniteNumber(lookup_value, 'lookup_value');
+
+            if (lookup === undefined) {
+                console.warn("found 'lookup_value' attribute, but no 'lookup' table. Ignoring lookup value");
+            } else {
+                this.lookup_value = lookup_value;
+            }
+        } else if (lookup !== undefined) {
+            // supply a default lookup value
+            this.lookup_value = 0;
+        }
+    }
+}