@luminocity/lemonate-engine 15.2.2 → 15.2.3

package/dist/subsystems/particlesystem/ParticleSystem.js

@@ -1,706 +0,0 @@
-// -----------------------------------------------------------------------------------------------------------
-//  __         ______     __    __     ______     __   __     ______     ______   ______
-// /\ \       /\  ___\   /\ "-./  \   /\  __ \   /\ "-.\ \   /\  __ \   /\__  _\ /\  ___\
-// \ \ \____  \ \  __\   \ \ \-./\ \  \ \ \/\ \  \ \ \-.  \  \ \  __ \  \/_/\ \/ \ \  __\
-//  \ \_____\  \ \_____\  \ \_\ \ \_\  \ \_____\  \ \_\\"\_\  \ \_\ \_\    \ \_\  \ \_____\
-//   \/_____/   \/_____/   \/_/  \/_/   \/_____/   \/_/ \/_/   \/_/\/_/     \/_/   \/_____/
-//
-//
-// Copyright 2023- Luminocity AG
-//
-// "I am the one who knocks!" - Far Cry 3: Blood Dragon (2013)
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy of this software
-// and associated documentation files (the “Software”), to deal in the Software without restriction,
-// including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
-// and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
-// subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all copies or substantial
-// portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
-// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-// -----------------------------------------------------------------------------------------------------------
-import { Simulation } from "./Simulation";
-import { Visualization } from "./Visualization";
-import { CubeEmitter } from "./Emitters/CubeEmitter";
-import { SphereEmitter } from "./Emitters/SphereEmitter";
-import { HemiSphereEmitter } from "./Emitters/HemiSphereEmitter";
-import { ConeEmitter } from "./Emitters/ConeEmitter";
-import { TorusEmitter } from "./Emitters/TorusEmitter";
-import { CircleEmitter } from "./Emitters/CircleEmitter";
-import { EdgeEmitter } from "./Emitters/EdgeEmitter";
-import { random } from "../../tools/Random";
-import { Vector3, Vector2, Matrix4, Clock, PerspectiveCamera, OrthographicCamera } from "three";
-import { CurlNoiseTexturePreview } from "./CurlNoiseTexturePreview";
-// Debug mode will add two planes to the container
-// to display the position and velocity particles data texture 
-const DEBUG = false;
-export var VelocityModeEnum;
-(function (VelocityModeEnum) {
-    VelocityModeEnum[VelocityModeEnum["Constant"] = 0] = "Constant";
-    VelocityModeEnum[VelocityModeEnum["Variable"] = 1] = "Variable";
-})(VelocityModeEnum || (VelocityModeEnum = {}));
-export var VelocityFunctionEnum;
-(function (VelocityFunctionEnum) {
-    VelocityFunctionEnum[VelocityFunctionEnum["Linear"] = 0] = "Linear";
-    VelocityFunctionEnum[VelocityFunctionEnum["Exponential"] = 1] = "Exponential";
-    VelocityFunctionEnum[VelocityFunctionEnum["Inverse Exponential"] = 2] = "Inverse Exponential";
-    VelocityFunctionEnum[VelocityFunctionEnum["Ease-in, Ease-out"] = 3] = "Ease-in, Ease-out";
-})(VelocityFunctionEnum || (VelocityFunctionEnum = {}));
-export var ScaleModeEnum;
-(function (ScaleModeEnum) {
-    ScaleModeEnum[ScaleModeEnum["Constant"] = 0] = "Constant";
-    ScaleModeEnum[ScaleModeEnum["Variable"] = 1] = "Variable";
-    ScaleModeEnum[ScaleModeEnum["Velocity"] = 2] = "Velocity";
-})(ScaleModeEnum || (ScaleModeEnum = {}));
-export var ScaleFunctionEnum;
-(function (ScaleFunctionEnum) {
-    ScaleFunctionEnum[ScaleFunctionEnum["Linear"] = 0] = "Linear";
-    ScaleFunctionEnum[ScaleFunctionEnum["Exponential"] = 1] = "Exponential";
-    ScaleFunctionEnum[ScaleFunctionEnum["Inverse Exponential"] = 2] = "Inverse Exponential";
-    ScaleFunctionEnum[ScaleFunctionEnum["Ease-in, Ease-out"] = 3] = "Ease-in, Ease-out";
-})(ScaleFunctionEnum || (ScaleFunctionEnum = {}));
-export var FadeModeEnum;
-(function (FadeModeEnum) {
-    FadeModeEnum[FadeModeEnum["Constant"] = 0] = "Constant";
-    FadeModeEnum[FadeModeEnum["Variable"] = 1] = "Variable";
-})(FadeModeEnum || (FadeModeEnum = {}));
-export var FadeFunctionEnum;
-(function (FadeFunctionEnum) {
-    FadeFunctionEnum[FadeFunctionEnum["Linear"] = 0] = "Linear";
-    FadeFunctionEnum[FadeFunctionEnum["Exponential"] = 1] = "Exponential";
-    FadeFunctionEnum[FadeFunctionEnum["Inverse Exponential"] = 2] = "Inverse Exponential";
-    FadeFunctionEnum[FadeFunctionEnum["Ease-in, Ease-out"] = 3] = "Ease-in, Ease-out";
-})(FadeFunctionEnum || (FadeFunctionEnum = {}));
-export var RotationDirectionEnum;
-(function (RotationDirectionEnum) {
-    RotationDirectionEnum[RotationDirectionEnum["Clockwise"] = 1] = "Clockwise";
-    RotationDirectionEnum[RotationDirectionEnum["Anticlockwise"] = -1] = "Anticlockwise";
-})(RotationDirectionEnum || (RotationDirectionEnum = {}));
-export class ParticleSystem {
-    renderer;
-    container; // TODO what is this container?
-    engine;
-    id;
-    particleCount;
-    width;
-    height;
-    time = new Clock();
-    elapsedTime = 0;
-    timeSinceLastSpawn = 0;
-    isRunning = true;
-    isEmitting = true;
-    isPaused = false;
-    emissionCounter = 0;
-    continuousEmissionFlag = false;
-    simulation;
-    visualization;
-    noiseTexture;
-    duration = -1; // run indefinitely
-    spawnAmount = 250;
-    spawnRate = 2.5; // seconds
-    maxEmission = -1;
-    prewarm = false;
-    prewarmAmount = 0;
-    emitterType = "point";
-    _initialVelocity = new Vector3();
-    _finalVelocity = new Vector3();
-    constructor(container, // TODO
-    renderer, particleCount, engine, id) {
-        this.renderer = renderer;
-        this.container = container;
-        this.engine = engine;
-        this.id = id;
-        this.particleCount = particleCount;
-        this.width = Math.ceil(Math.sqrt(particleCount));
-        this.height = Math.ceil(Math.sqrt(particleCount));
-        // Initialize simulation, visualization, and noise texture
-        this.simulation = new Simulation(this.renderer, this.width, this.height);
-        this.visualization = new Visualization(this.container, this.particleCount, this.simulation, DEBUG);
-        this.noiseTexture = new CurlNoiseTexturePreview(this.renderer, this.engine, this.id);
-        // Seed randomness
-        random.setSeed(123456789);
-    }
-    destroy() {
-        this.simulation.destroy();
-        this.visualization.destroy();
-    }
-    // The maximum size for a gl point is generally 63 pixels but this depends
-    // on the device. It's worthy to check that the given size is between this range
-    // to prevent artifacts
-    get pointSizeRange() {
-        const gl = this.renderer.getContext();
-        return gl.getParameter(gl.ALIASED_POINT_SIZE_RANGE);
-    }
-    get emitter() {
-        // TODO we might want to return it as a json with emitter information for the API
-        return this.simulation.emitter;
-    }
-    get respawnFlag() {
-        return this.simulation.respawn;
-    }
-    set respawnFlag(value) {
-        this.simulation.respawn = value;
-    }
-    get localCoordsFlag() {
-        return this.simulation.useLocalCoords;
-    }
-    set localCoordsFlag(v) {
-        this.simulation.useLocalCoords = v;
-    }
-    get initialVelocity() {
-        return this._initialVelocity;
-    }
-    set initialVelocity(v) {
-        this._initialVelocity = v;
-        this.simulation.initialVelocity = v;
-    }
-    get finalVelocity() { return this.simulation.finalVelocity; }
-    set finalVelocity(v) { this.simulation.finalVelocity = v; }
-    get velocityMode() {
-        const value = this.simulation.velocityMode;
-        return Object.keys(VelocityModeEnum).find((k) => VelocityModeEnum[k] === value);
-    }
-    set velocityMode(v) {
-        if (typeof v === "string") {
-            const enumValue = VelocityModeEnum[v];
-            if (enumValue === undefined) {
-                throw new Error(`Invalid VelocityMode: ${v}`);
-            }
-            this.simulation.velocityMode = enumValue;
-        }
-        else if (typeof v === "number") {
-            this.simulation.velocityMode = v;
-        }
-        else {
-            throw new Error("velocityMode must be a string or number");
-        }
-    }
-    get velocityFunction() {
-        const value = this.simulation.velocityFunction;
-        return Object.keys(VelocityFunctionEnum).find((k) => VelocityFunctionEnum[k] === value);
-    }
-    set velocityFunction(v) {
-        if (typeof v === "string") {
-            const enumValue = VelocityFunctionEnum[v];
-            if (enumValue === undefined) {
-                throw new Error(`Invalid VelocityFunction: ${v}`);
-            }
-            this.simulation.velocityFunction = enumValue;
-        }
-        else if (typeof v === "number") {
-            this.simulation.velocityFunction = v;
-        }
-        else {
-            throw new Error("velocityFunction must be a string or number");
-        }
-    }
-    get finalVelocityApproachValue() {
-        return this.simulation.approachSpeed;
-    }
-    set finalVelocityApproachValue(v) {
-        this.simulation.approachSpeed = v;
-    }
-    get target() {
-        return this.simulation.target;
-    }
-    set target(v) {
-        this.simulation.target = v;
-    }
-    get targetForce() {
-        return this.simulation.targetForce;
-    }
-    set targetForce(v) {
-        this.simulation.targetForce = v;
-    }
-    get targetDeletionThreshold() {
-        return this.simulation.targetDeletionThreshold;
-    }
-    set targetDeletionThreshold(v) {
-        this.simulation.targetDeletionThreshold = v;
-    }
-    get randomVelocity() {
-        return this.simulation.randomVelocityFactor;
-    }
-    set randomVelocity(v) {
-        this.simulation.randomVelocityFactor = v;
-    }
-    get normalVelocity() {
-        return this.simulation.emitter.normalVelocity;
-    }
-    set normalVelocity(v) {
-        this.simulation.emitter.normalVelocity = v;
-    }
-    get spread() {
-        return this.simulation.spread;
-    }
-    set spread(v) {
-        this.simulation.spread = v;
-    }
-    get angularVelocity() {
-        return this.visualization.angularVelocity;
-    }
-    set angularVelocity(v) {
-        this.visualization.angularVelocity = v;
-    }
-    get rotationDirection() {
-        const value = this.visualization.rotationDirection;
-        return Object.keys(RotationDirectionEnum).find(k => RotationDirectionEnum[k] === value);
-    }
-    set rotationDirection(v) {
-        if (typeof v === "string") {
-            const enumValue = RotationDirectionEnum[v];
-            if (enumValue === undefined) {
-                throw new Error(`Invalid RotationDirection: ${v}`);
-            }
-            this.visualization.rotationDirection = enumValue;
-        }
-        else if (typeof v === "number") {
-            this.visualization.rotationDirection = v;
-        }
-        else {
-            throw new Error("rotationDirection must be a string or number");
-        }
-    }
-    get rotationRandomness() {
-        return this.visualization.rotationRandomness;
-    }
-    set rotationRandomness(v) {
-        this.visualization.rotationRandomness = v;
-    }
-    get gravity() {
-        return this.simulation.gravity;
-    }
-    set gravity(v) {
-        this.simulation.gravity = v;
-    }
-    get orbitalVelocity() {
-        return this.simulation.orbitalVelocity;
-    }
-    set orbitalVelocity(v) {
-        this.simulation.orbitalVelocity = v;
-    }
-    get orbitalDecay() {
-        return this.simulation.orbitalDecay;
-    }
-    set orbitalDecay(v) {
-        this.simulation.orbitalDecay = v;
-    }
-    get orbitalCenterPoint() {
-        return this.simulation.orbitalCenterPoint;
-    }
-    set orbitalCenterPoint(v) {
-        this.simulation.orbitalCenterPoint = v;
-    }
-    get orbitalPlane() {
-        return this.simulation.orbitalPlane;
-    }
-    set orbitalPlane(v) {
-        this.simulation.orbitalPlane = v;
-    }
-    get enableBBox() { return this.simulation.enableBBox; }
-    set enableBBox(v) { this.simulation.enableBBox = v; }
-    get bboxMin() { return this.simulation.bboxMin; }
-    set bboxMin(v) { this.simulation.bboxMin = v; }
-    get bboxMax() { return this.simulation.bboxMax; }
-    set bboxMax(v) { this.simulation.bboxMax = v; }
-    get bbox() {
-        return {
-            min: this.simulation.bboxMin,
-            max: this.simulation.bboxMax
-        };
-    }
-    set bbox(box) {
-        this.simulation.bboxMin = box.min;
-        this.simulation.bboxMax = box.max;
-    }
-    get noiseStrength() { return this.simulation.noiseStrength; }
-    set noiseStrength(v) {
-        this.simulation.noiseStrength = v;
-        this.noiseTexture.noiseStrength = v;
-    }
-    get noiseFrequency() { return this.simulation.noiseFrequency; }
-    set noiseFrequency(v) {
-        this.simulation.noiseFrequency = v;
-        this.noiseTexture.noiseFrequency = v;
-    }
-    get noiseOctaves() { return this.simulation.noiseOctaves; }
-    set noiseOctaves(v) {
-        this.simulation.noiseOctaves = v;
-        this.noiseTexture.noiseOctaves = v;
-    }
-    get particleLife() {
-        return this.simulation.emitter.baseLife;
-    }
-    set particleLife(v) {
-        this.simulation.emitter.baseLife = v;
-    }
-    get particleLifeRamdom() {
-        return this.simulation.emitter.lifeRandomness;
-    }
-    set particleLifeRamdom(v) {
-        this.simulation.emitter.lifeRandomness = v;
-    }
-    get particleColor() { return this.visualization.baseColor; }
-    set particleColor(v) { this.visualization.baseColor = v.divideScalar(255); }
-    get particleFinalColor() { return this.visualization.baseFinalColor; }
-    set particleFinalColor(v) { this.visualization.baseFinalColor = v.divideScalar(255); }
-    get randomColorFactor() { return this.visualization.randomColorFactor; }
-    set randomColorFactor(v) { this.visualization.randomColorFactor = v; }
-    get enableFinalColor() { return this.visualization.enableFinalColor; }
-    set enableFinalColor(v) { this.visualization.enableFinalColor = v; }
-    get enableTexture() { return this.visualization.enableTexture; }
-    set enableTexture(v) { this.visualization.enableTexture = v; }
-    get particleTexture() { return this.visualization.particleTexture; }
-    set particleTexture(v) { this.visualization.particleTexture = v; }
-    get enableSpriteFade() { return this.visualization.enableSpriteFade; }
-    set enableSpriteFade(v) { this.visualization.enableSpriteFade = v; }
-    get spriteSpeed() { return this.visualization.spriteSpeed; }
-    set spriteSpeed(v) { this.visualization.spriteSpeed = v; }
-    get rollSpriteWithLife() { return this.visualization.rollSpriteWithLife; }
-    set rollSpriteWithLife(v) { this.visualization.rollSpriteWithLife = v; }
-    get spriteCols() { return this.visualization.spriteCols; }
-    set spriteCols(v) { this.visualization.spriteCols = v; }
-    get spriteRows() { return this.visualization.spriteRows; }
-    set spriteRows(v) { this.visualization.spriteRows = v; }
-    get atlasWidth() { return this.visualization.atlasWidth; }
-    set atlasWidth(v) { this.visualization.atlasWidth = v; }
-    get atlasHeight() { return this.visualization.atlasHeight; }
-    set atlasHeight(v) { this.visualization.atlasHeight = v; }
-    set useCircularMask(value) { this.visualization.maskType = value ? 1 : 0; }
-    ;
-    get maskType() { return this.visualization.maskType; }
-    set maskType(v) { this.visualization.maskType = v; }
-    get flipTextureY() {
-        return this.visualization.flipY;
-    }
-    set flipTextureY(v) {
-        this.visualization.flipY = v;
-    }
-    get textureBlendingFlag() {
-        return this.visualization.textureBlendingFlag;
-    }
-    set textureBlendingFlag(v) {
-        this.visualization.textureBlendingFlag = v;
-    }
-    get blendValue() {
-        return this.visualization.blendValue;
-    }
-    set blendValue(v) {
-        this.visualization.blendValue = v;
-    }
-    get blendingMode() {
-        return this.visualization.blendingMode;
-    }
-    set blendingMode(v) {
-        this.visualization.blendingMode = v;
-    }
-    get opacity() {
-        return this.visualization.opacity;
-    }
-    set opacity(v) {
-        this.visualization.opacity = v;
-    }
-    get preMultiplyAlphaFlag() {
-        return this.visualization.preMultiplyAlphaFlag;
-    }
-    set preMultiplyAlphaFlag(v) {
-        this.visualization.preMultiplyAlphaFlag = v;
-    }
-    get hueShift() {
-        return this.visualization.hueShift;
-    }
-    set hueShift(v) {
-        this.visualization.hueShift = v;
-    }
-    get fadeMode() {
-        const value = this.visualization.fadeMode;
-        return Object.keys(FadeModeEnum).find(k => FadeModeEnum[k] === value);
-    }
-    set fadeMode(v) {
-        if (typeof v === "string") {
-            const enumValue = FadeModeEnum[v];
-            if (enumValue === undefined) {
-                throw new Error(`Invalid FadeMode: ${v}`);
-            }
-            this.visualization.fadeMode = enumValue;
-        }
-        else if (typeof v === "number") {
-            this.visualization.fadeMode = v;
-        }
-        else {
-            throw new Error("fadeMode must be a string or number");
-        }
-    }
-    get fadeFunction() {
-        const value = this.visualization.fadeFunction;
-        return Object.keys(FadeFunctionEnum).find(k => FadeFunctionEnum[k] === value);
-    }
-    set fadeFunction(v) {
-        if (typeof v === "string") {
-            const enumValue = FadeFunctionEnum[v];
-            if (enumValue === undefined) {
-                throw new Error(`Invalid FadeFunction: ${v}`);
-            }
-            this.visualization.fadeFunction = enumValue;
-        }
-        else if (typeof v === "number") {
-            this.visualization.fadeFunction = v;
-        }
-        else {
-            throw new Error("fadeFunction must be a string or number");
-        }
-    }
-    get fadeApproach() {
-        return this.visualization.fadeApproach;
-    }
-    set fadeApproach(v) {
-        this.visualization.fadeApproach = v;
-    }
-    get fadeRange() {
-        return this.visualization.fadeRange;
-    }
-    set fadeRange(v) {
-        this.visualization.fadeRange = v;
-    }
-    get fadeInitialOpacity() {
-        return this.visualization.fadeRange.x;
-    }
-    set fadeInitialOpacity(v) {
-        this.visualization.fadeRange.x = v;
-    }
-    get fadeFinalOpacity() {
-        return this.visualization.fadeRange.y;
-    }
-    set fadeFinalOpacity(v) {
-        this.visualization.fadeRange.y = v;
-    }
-    get particleSize() {
-        const scale = this.visualization.material.uniforms.scale.value;
-        const approach = this.visualization.material.uniforms.approachSize.value;
-        return {
-            minSize: scale.x,
-            maxSize: scale.y,
-            approach
-        };
-    }
-    set particleSize(v) {
-        const uniforms = this.visualization.material.uniforms;
-        uniforms.scale.value = new Vector2(v.minSize, v.maxSize);
-        uniforms.approachSize.value = v.approach;
-    }
-    get scaleFunction() {
-        const value = this.visualization.scaleFunction;
-        return Object.keys(ScaleFunctionEnum).find((k) => ScaleFunctionEnum[k] === value);
-    }
-    set scaleFunction(v) {
-        if (typeof v === "string") {
-            const enumValue = ScaleFunctionEnum[v];
-            if (enumValue === undefined) {
-                throw new Error(`Invalid ScaleFunction: ${v}`);
-            }
-            this.visualization.scaleFunction = enumValue;
-        }
-        else if (typeof v === "number") {
-            this.visualization.scaleFunction = v;
-        }
-        else {
-            throw new Error("scaleFunction must be a string or number");
-        }
-    }
-    get scaleRandomness() { return this.visualization.scaleRandomness; }
-    set scaleRandomness(v) { this.visualization.scaleRandomness = v; }
-    get scaleMode() {
-        // find the enum key by its value
-        const value = this.visualization.scaleMode;
-        return Object.keys(ScaleModeEnum).find((k) => ScaleModeEnum[k] === value);
-    }
-    set scaleMode(v) {
-        if (typeof v === "string") {
-            const enumValue = ScaleModeEnum[v];
-            if (enumValue === undefined) {
-                throw new Error(`Invalid ScaleMode: ${v}`);
-            }
-            this.visualization.scaleMode = enumValue;
-        }
-        else if (typeof v === "number") {
-            this.visualization.scaleMode = v;
-        }
-        else {
-            throw new Error("scaleMode must be a string or number");
-        }
-    }
-    setEmitter(shape, type, config) {
-        const previousEmitter = this.simulation.emitter;
-        const newEmitter = this.createEmitter(shape, config);
-        if (!newEmitter) {
-            console.warn('Unknown geometry type:', shape);
-            return;
-        }
-        // Inherit previous emitter settings
-        if (previousEmitter) {
-            newEmitter.copyFrom(previousEmitter);
-        }
-        newEmitter.emissionType = type;
-        if (config.life !== undefined)
-            newEmitter.baseLife = config.life;
-        if (config.lifeRandomness !== undefined)
-            newEmitter.lifeRandomness = config.lifeRandomness;
-        this.simulation.emitter = newEmitter;
-        this.emitterType = type;
-        this.simulation.setEmitter(newEmitter);
-        this.simulation.updateShaderDefines();
-    }
-    createEmitter(shape, config) {
-        switch (shape) {
-            case 'point':
-                return new SphereEmitter(this.simulation, 0.0001);
-            case 'box':
-                return new CubeEmitter(this.simulation, config.size ?? 1);
-            case 'sphere':
-                return new SphereEmitter(this.simulation, config.radius ?? 1);
-            case 'hemisphere':
-                return new HemiSphereEmitter(this.simulation, config.radius ?? 1);
-            case 'torus':
-                return new TorusEmitter(this.simulation, config.radius ?? 1, config.outerRadius ?? 1);
-            case 'cone':
-                const newEmitter = new ConeEmitter(this.simulation, config.radius ?? 1, config.height ?? 1);
-                if (config.roundTip)
-                    newEmitter.roundedCorners = config.roundTip;
-                return newEmitter;
-            case 'circle':
-                return new CircleEmitter(this.simulation, config.radius ?? 1);
-            case 'edge':
-                return new EdgeEmitter(this.simulation, config.width ?? 1, config.height ?? 1);
-            default:
-                console.warn("Unknown emitter shape:", shape);
-                return null;
-        }
-    }
-    // Set or get whether the emitter uses local coordinates
-    set localCoords(value) {
-        this.simulation.useLocalCoords = value;
-        // Optional: killAllParticles if switching between local/world coordinates
-        // this.killAllParticles();
-    }
-    get localCoords() {
-        return this.simulation.useLocalCoords;
-    }
-    /**
-   * Updates emitter transform.
-   * @param {Vector3} position - World-space position.
-   * @param {Quaternion} rotation - World-space rotation (must be a Quaternion).
-   * @param {Vector3} scale - World-space scale.
-   */
-    updateEmitterTransform({ position, rotation, scale }) {
-        const emitterMatrix = new Matrix4().compose(position, rotation, scale);
-        const emitterInverseMatrix = new Matrix4().copy(emitterMatrix).invert();
-        // Use Simulation setters instead of directly touching uniforms
-        this.simulation.emitterMatrix = emitterMatrix;
-        this.simulation.emitterInverseMatrix = emitterInverseMatrix;
-        // Apply world transform in world space mode
-        if (!this.localCoords) {
-            this.visualization.mesh.matrix.copy(emitterInverseMatrix);
-        }
-        else {
-            this.visualization.mesh.matrix.identity();
-        }
-        this.visualization.mesh.matrixAutoUpdate = false;
-    }
-    async generateNoisePreview() {
-        // Expensive operation; only call when needed
-        this.noiseTexture.render();
-        // Await the promise from getTexture
-        const jpegData = await this.noiseTexture.getTexture();
-        return jpegData;
-    }
-    setSize(width, height) {
-        this.visualization.setSize(width, height);
-    }
-    setCamera(camera) {
-        if (camera instanceof PerspectiveCamera) {
-            this.visualization.setCameraFOV(camera.fov);
-            this.visualization.isCameraPerspective = true;
-        }
-        else if (camera instanceof OrthographicCamera) {
-            this.visualization.setCameraFOV(0);
-            this.visualization.isCameraPerspective = false;
-        }
-        else {
-            console.error("Particle System: Unknown camera mode.");
-        }
-    }
-    restart() {
-        this.killAllParticles();
-        this.resetTimer();
-        if (this.isRunning)
-            this.showParticles();
-    }
-    resetTimer() {
-        this.elapsedTime = 0;
-        this.timeSinceLastSpawn = this.spawnRate; // force spawn at the next update
-        this.emissionCounter = 0;
-        this.time.start(); // reset the simulation clock
-    }
-    killAllParticles() {
-        this.simulation.killAllParticles();
-    }
-    hideParticles() {
-        this.visualization.hideParticles();
-    }
-    showParticles() {
-        this.visualization.showParticles();
-    }
-    emitAllParticles() {
-        // TODO that this emits the maximum number of particles
-        // which is the texture widthxheight and most likely does not
-        // correspond to the one specified by the user! it would be nice to support
-        // non-square texture data for position and velocity to have a better match.
-        this.simulation.writeInitialParticleData();
-        this.simulation.emitNewParticles(this.simulation.maxParticles, false, 0);
-    }
-    emitNewParticles(particleCount = 1, continuous = true) {
-        this.simulation.emitNewParticles(particleCount, continuous, this.spawnRate);
-    }
-    // delta: time difference in seconds
-    render(delta) {
-        if (!this.isRunning || this.isPaused)
-            return;
-        delta ??= this.time.getDelta();
-        if (this.duration !== -1 && this.elapsedTime > this.duration) {
-            this.killAllParticles();
-            this.hideParticles();
-            this.isRunning = false;
-        }
-        this.timeSinceLastSpawn = (this.timeSinceLastSpawn ?? 0) + delta;
-        const shouldEmit = () => {
-            const enoughTimePassed = this.timeSinceLastSpawn >= this.spawnRate && this.isEmitting;
-            const justStarted = this.elapsedTime === 0;
-            const underMaxEmission = this.emissionCounter < this.maxEmission || this.maxEmission === -1;
-            return (enoughTimePassed || justStarted) && underMaxEmission;
-        };
-        if (shouldEmit()) {
-            this.emitNewParticles(this.spawnAmount, this.continuousEmissionFlag);
-            this.timeSinceLastSpawn -= this.spawnRate;
-            this.emissionCounter += 1;
-            if (this.maxEmission !== -1 && this.emissionCounter >= this.maxEmission) {
-                this.isEmitting = false;
-            }
-        }
-        // Delegate simulation update to Simulation class
-        this.simulation.render(this.elapsedTime, delta);
-        // Delegate visual update to Visualization class
-        this.visualization.render(this.elapsedTime, delta);
-        this.elapsedTime += delta;
-        // TODO it would be great to have a way to detect if there are particles alive so we can stop the system
-        // if (this.particlesAlive == 0) {
-        //   this.isRunning = false;
-        // }
-    }
-}
-//# sourceMappingURL=ParticleSystem.js.map