@codexo/exojs 0.7.12 → 0.8.0

package/dist/esm/particles/ParticleSystem.js

@@ -1,35 +1,195 @@
-import { Particle } from './Particle.js';
 import { Rectangle } from '../math/Rectangle.js';
 import { Drawable } from '../rendering/Drawable.js';
+import { Texture } from '../rendering/texture/Texture.js';
+import { Spritesheet } from '../rendering/sprite/Spritesheet.js';
+import { ParticleGpuState } from './gpu/ParticleGpuState.js';
 
+/// <reference types="@webgpu/types" />
+const defaultCapacity = 4096;
 /**
- * The central coordinator of the particle triad. `ParticleSystem` is a
- * {@link Drawable} that owns a list of {@link ParticleEmitter} spawners, a
- * list of {@link ParticleAffector} mutators, and the live/graveyard particle
- * pools. Each call to {@link ParticleSystem.update} runs all emitters to
- * spawn new particles, advances every live particle's position and lifetime,
- * retires expired ones to the graveyard for pooling, and runs all affectors
- * on the survivors.
+ * Lazily-initialised 1×1 opaque-white texture used as the default sprite
+ * when a {@link ParticleSystem} is constructed without one. Particles
+ * render as solid color quads (the per-particle `color` channel times
+ * white-with-alpha-1). Shared across systems to avoid wasted texture
+ * allocations.
+ */
+let defaultWhiteTexture = null;
+const getDefaultWhiteTexture = () => {
+    if (defaultWhiteTexture === null) {
+        const canvas = document.createElement('canvas');
+        canvas.width = 1;
+        canvas.height = 1;
+        const ctx = canvas.getContext('2d');
+        if (ctx !== null) {
+            ctx.fillStyle = '#ffffff';
+            ctx.fillRect(0, 0, 1, 1);
+        }
+        defaultWhiteTexture = new Texture(canvas);
+    }
+    return defaultWhiteTexture;
+};
+/**
+ * The central coordinator of the particle pipeline. `ParticleSystem` is a
+ * {@link Drawable} that owns:
+ *
+ * - **SoA particle storage** — one typed array per attribute (position,
+ *   velocity, scale, rotation, color, lifetime, ...), sized to a fixed
+ *   capacity at construction. User code reads/writes via
+ *   `system.posX[slot]`, `system.velX[slot]`, etc.
+ * - **Spawn modules** — write new particles into freshly allocated slots.
+ * - **Update modules** — mutate the live range each frame (forces, color
+ *   blends, scale curves, drag, ...). Built-in modules ship both CPU and
+ *   WGSL implementations; custom modules can opt into GPU acceleration by
+ *   implementing `wgsl()`.
+ * - **Death modules** — fire once per dying particle, before its slot is
+ *   recycled (sub-emitters, event hooks).
+ *
+ * **Auto-routing CPU vs GPU:** at first {@link update}, the system checks:
+ * if a `WebGpuBackend` was supplied AND every registered update module has
+ * `wgsl()`, the GPU path engages — a composite compute pipeline runs
+ * integration plus all module bodies in one dispatch and writes directly
+ * into the renderer's instance buffer (no CPU readback). Otherwise the CPU
+ * path runs the existing per-module `apply()` loops.
  *
- * Rendering reads {@link ParticleSystem.vertices} and
- * {@link ParticleSystem.texCoords} (lazily recomputed on texture-frame
- * changes) plus the live {@link ParticleSystem.particles} array to draw each
- * sprite.
+ * **Per-frame order in {@link update} (CPU mode):**
+ * 1. Run every spawn module.
+ * 2. Integrate position from velocity, rotation from rotationSpeed, advance `elapsed`.
+ * 3. Run every update module on the live range.
+ * 4. Compact: scan `[0, liveCount)` forward, fire death modules on expired
+ *    slots, copy survivors down. `liveCount` shrinks to the survivor count.
+ *
+ * **Per-frame order in {@link update} (GPU mode):**
+ * 1. Run every spawn module (CPU writes initial values into the spawn slot).
+ * 2. Detect expiries on CPU (via `elapsed >= lifetime`); fire death modules;
+ *    set `lifetime[slot] = -1` sentinel + clear `alive[slot]` so the GPU
+ *    shader skips them. **No compaction** — slots are recycled on next spawn.
+ * 3. Dispatch the composite compute pipeline. Integration + update modules
+ *    + pack-instances run in one pass; the instance buffer is written
+ *    directly. CPU SoA stays as-is for spawn writes.
+ *
+ * **Coordinate space:** particle positions are LOCAL to the system. The
+ * system's `getGlobalTransform()` is applied on top during rendering — both
+ * the WebGL2 and WebGPU shaders multiply `projection * translation * rotated`.
+ * Setting world-space positions on individual particles double-translates.
+ * Position the system itself via `system.setPosition(...)` and emit relative
+ * to `(0, 0)`.
+ *
+ * @example
+ * // Backend-agnostic — runs CPU on WebGL2, GPU on WebGPU automatically.
+ * const system = new ParticleSystem(loader.get(Texture, 'spark'), {
+ *     capacity: 8192,
+ *     backend: app.backend,
+ * });
+ *
+ * system.addSpawnModule(new RateSpawn({ rate: new Constant(60), ... }));
+ * system.addUpdateModule(new ApplyForce(0, 980));     // gravity, GPU-eligible
+ * system.addUpdateModule(new ColorOverLifetime(fireGradient));
+ * scene.addChild(system);
  */
 class ParticleSystem extends Drawable {
-    _emitters = [];
-    _affectors = [];
-    _particles = [];
-    _graveyard = [];
+    /** Maximum particle count this system will store. Fixed at construction. */
+    capacity;
+    posX;
+    posY;
+    velX;
+    velY;
+    scaleX;
+    scaleY;
+    rotations;
+    rotationSpeeds;
+    color; // packed 0xAABBGGRR
+    elapsed; // seconds since spawn
+    lifetime; // total seconds before expiry; -1 sentinel for dead in GPU mode
+    textureIndex;
+    /**
+     * Number of currently live particles. In CPU mode this is exact: slots
+     * `[0, liveCount)` are all alive after each `update()`. In GPU mode
+     * this is a high-water mark — slots `[0, liveCount)` may contain dead
+     * holes (filled in by future spawns); use {@link aliveCount} for the
+     * actual alive count.
+     */
+    liveCount = 0;
+    /**
+     * Per-slot alive flag (1 = alive, 0 = dead). Maintained in both CPU
+     * and GPU mode. Custom modules iterating the live range should check
+     * this to skip dead slots in GPU mode.
+     */
+    alive;
+    _spawnModules = [];
+    _updateModules = [];
+    _deathModules = [];
+    _backend = null;
+    _device = null;
+    _gpuState = null;
+    _gpuMode = false;
+    _compiled = false;
+    _spawnHint = 0; // round-robin pointer for first-dead lookup in GPU mode
+    /**
+     * In GPU mode, slots whose CPU SoA values need re-uploading to the GPU
+     * (newly spawned, or just-expired with lifetime sentinel). Cleared
+     * after each compute dispatch. CPU never overwrites integrated GPU
+     * state — only dirty slots flow CPU → GPU.
+     */
+    _gpuDirtySlots = new Set();
     _texture;
+    _frames = [];
     _textureFrame = new Rectangle();
     _vertices = new Float32Array(4);
     _texCoords = new Uint32Array(4);
     _updateTexCoords = true;
     _updateVertices = true;
-    constructor(texture) {
+    constructor(arg1, arg2, arg3) {
         super();
-        this._texture = texture;
+        // Disambiguate the four valid call shapes via instanceof checks.
+        // The TS overloads above already prevent illegal combinations like
+        // `(texture, sheet)` or `(sheet, frames)` at compile time; this
+        // narrowing only sorts out the legal ones.
+        let texture = null;
+        let frames = null;
+        let options = {};
+        if (arg1 instanceof Texture) {
+            texture = arg1;
+            if (Array.isArray(arg2)) {
+                frames = arg2;
+                options = arg3 ?? {};
+            }
+            else {
+                options = arg2 ?? {};
+            }
+        }
+        else if (arg1 instanceof Spritesheet) {
+            texture = arg1.texture;
+            frames = [...arg1.frames.values()];
+            options = arg2 ?? {};
+        }
+        else {
+            options = arg1 ?? {};
+        }
+        const capacity = options.capacity ?? defaultCapacity;
+        if (capacity <= 0 || !Number.isInteger(capacity)) {
+            throw new Error(`ParticleSystem capacity must be a positive integer (got ${capacity}).`);
+        }
+        this.capacity = capacity;
+        this.posX = new Float32Array(capacity);
+        this.posY = new Float32Array(capacity);
+        this.velX = new Float32Array(capacity);
+        this.velY = new Float32Array(capacity);
+        this.scaleX = new Float32Array(capacity);
+        this.scaleY = new Float32Array(capacity);
+        this.rotations = new Float32Array(capacity);
+        this.rotationSpeeds = new Float32Array(capacity);
+        this.color = new Uint32Array(capacity);
+        this.elapsed = new Float32Array(capacity);
+        this.lifetime = new Float32Array(capacity);
+        this.textureIndex = new Uint16Array(capacity);
+        this.alive = new Uint8Array(capacity);
+        this._device = options.device ?? null;
+        this._texture = texture ?? getDefaultWhiteTexture();
+        if (frames !== null) {
+            for (const frame of frames) {
+                this._frames.push(frame.clone());
+            }
+        }
         this.resetTextureFrame();
     }
     get texture() {
@@ -45,11 +205,17 @@ class ParticleSystem extends Drawable {
         this.setTextureFrame(frame);
     }
     /**
-     * Quad corner offsets for the current {@link textureFrame}, in local
-     * space as `[minX, minY, maxX, maxY]`. Recomputed lazily whenever
-     * `textureFrame` changes. Used by the renderer to position each particle
-     * sprite relative to its world position.
+     * Atlas frames declared on this system, or empty when the texture is
+     * used as a single frame. Each particle's `textureIndex[i]` selects
+     * an entry from this list; out-of-range indices are clamped to 0.
      */
+    get frames() {
+        return this._frames;
+    }
+    /** `true` when the system declares more than one atlas frame. */
+    get hasAtlas() {
+        return this._frames.length > 1;
+    }
     get vertices() {
         if (this._updateVertices) {
             const { x, y, width, height } = this._textureFrame;
@@ -63,12 +229,6 @@ class ParticleSystem extends Drawable {
         }
         return this._vertices;
     }
-    /**
-     * Packed UV coordinates for the current {@link textureFrame} as four
-     * `Uint32` values, each encoding a `(u, v)` pair in the upper/lower 16
-     * bits (normalised to 0–65535). Vertex order respects
-     * {@link Texture.flipY}. Recomputed lazily on texture or frame changes.
-     */
     get texCoords() {
         if (this._updateTexCoords) {
             const { width, height } = this._texture;
@@ -93,27 +253,32 @@ class ParticleSystem extends Drawable {
         }
         return this._texCoords;
     }
-    get emitters() {
-        return this._emitters;
+    /** `true` when the system is running on the GPU compute pipeline. */
+    get gpuMode() {
+        return this._gpuMode;
     }
-    get affectors() {
-        return this._affectors;
+    /** GPU-side state, or `null` in CPU mode. */
+    get gpuState() {
+        return this._gpuState;
     }
-    get particles() {
-        return this._particles;
+    /** Actual count of live particles (slots with `alive[i] === 1`). May differ from `liveCount` in GPU mode. */
+    get aliveCount() {
+        let count = 0;
+        for (let i = 0; i < this.liveCount; i++) {
+            if (this.alive[i])
+                count++;
+        }
+        return count;
     }
-    /**
-     * Pool of expired {@link Particle} instances waiting to be recycled.
-     * {@link requestParticle} pops from this array before allocating a new
-     * instance, keeping GC pressure low during sustained emission.
-     */
-    get graveyard() {
-        return this._graveyard;
+    get spawnModules() {
+        return this._spawnModules;
+    }
+    get updateModules() {
+        return this._updateModules;
+    }
+    get deathModules() {
+        return this._deathModules;
     }
-    /**
-     * Replaces the particle sprite texture and resets the texture frame to
-     * cover the full new texture. No-ops if `texture` is the same instance.
-     */
     setTexture(texture) {
         if (this._texture !== texture) {
             this._texture = texture;
@@ -121,11 +286,6 @@ class ParticleSystem extends Drawable {
         }
         return this;
     }
-    /**
-     * Sets the sub-rectangle of the texture used as the particle sprite,
-     * invalidating cached vertices and UV coordinates and updating the system's
-     * local bounds to match the frame dimensions.
-     */
     setTextureFrame(frame) {
         this._textureFrame.copy(frame);
         this._updateTexCoords = true;
@@ -134,121 +294,274 @@ class ParticleSystem extends Drawable {
         this._invalidateBoundsCascade();
         return this;
     }
-    /** Resets the texture frame to the full dimensions of the current texture. */
     resetTextureFrame() {
         return this.setTextureFrame(Rectangle.temp.set(0, 0, this._texture.width, this._texture.height));
     }
-    /** Registers `emitter` to be called each tick during {@link update}. */
-    addEmitter(emitter) {
-        this._emitters.push(emitter);
+    addSpawnModule(mod) {
+        this._spawnModules.push(mod);
         return this;
     }
-    /** Destroys and removes all registered emitters. */
-    clearEmitters() {
-        for (const emitter of this._emitters) {
-            emitter.destroy();
+    addUpdateModule(mod) {
+        if (this._compiled) {
+            throw new Error('Cannot add update modules after the system has been compiled (first update). Register all modules before the first update().');
         }
-        this._emitters.length = 0;
+        this._updateModules.push(mod);
         return this;
     }
-    /** Registers `affector` to run on every live particle each tick during {@link update}. */
-    addAffector(affector) {
-        this._affectors.push(affector);
+    addDeathModule(mod) {
+        this._deathModules.push(mod);
         return this;
     }
-    /** Destroys and removes all registered affectors. */
-    clearAffectors() {
-        for (const affector of this._affectors) {
-            affector.destroy();
-        }
-        this._affectors.length = 0;
+    clearSpawnModules() {
+        for (const mod of this._spawnModules)
+            mod.destroy();
+        this._spawnModules.length = 0;
         return this;
     }
-    /**
-     * Returns a recycled particle from the {@link graveyard}, or allocates a
-     * new one if the pool is empty. Call {@link Particle.applyOptions}
-     * immediately after to reset its state before passing it to
-     * {@link emitParticle}.
-     */
-    requestParticle() {
-        return this._graveyard.pop() || new Particle();
+    clearUpdateModules() {
+        for (const mod of this._updateModules)
+            mod.destroy();
+        this._updateModules.length = 0;
+        return this;
     }
-    /** Adds a fully-configured `particle` to the live pool. Typically called by emitters. */
-    emitParticle(particle) {
-        this._particles.push(particle);
+    clearDeathModules() {
+        for (const mod of this._deathModules)
+            mod.destroy();
+        this._deathModules.length = 0;
         return this;
     }
     /**
-     * Advances a single particle by one `delta` step: increments
-     * `elapsedLifetime`, integrates velocity into position, and applies
-     * `rotationSpeed` to rotation. Called for every live particle by
-     * {@link update} before the affector pass.
+     * Allocates a particle slot and returns its index. Returns `-1` when
+     * the system is at {@link capacity}.
+     *
+     * **CPU mode:** slots are dense in `[0, liveCount)`. `spawn()` returns
+     * the next sequential slot; `liveCount++`.
+     *
+     * **GPU mode:** slots may have dead holes. `spawn()` finds the first
+     * `alive[i] === 0` slot via a round-robin hint pointer (amortised O(1),
+     * worst case O(capacity) on full systems).
      */
-    updateParticle(particle, delta) {
-        const seconds = delta.seconds;
-        particle.elapsedLifetime.addTime(delta);
-        particle.position.add(seconds * particle.velocity.x, seconds * particle.velocity.y);
-        particle.rotation += (seconds * particle.rotationSpeed);
+    spawn() {
+        if (this._gpuMode) {
+            return this._spawnGpu();
+        }
+        return this._spawnCpu();
+    }
+    /** Resets the system to zero live particles without destroying it. */
+    clearParticles() {
+        this.liveCount = 0;
+        this._spawnHint = 0;
+        this.alive.fill(0);
+        this.lifetime.fill(0);
+        this.elapsed.fill(0);
         return this;
     }
     /**
-     * Destroys and removes all particles from both the live pool and the
-     * graveyard. Use when resetting or recycling the entire system.
+     * Engine-side render hook. Captures the active backend on each call so
+     * the next `update()` can compile a GPU pipeline if the backend turned
+     * out to be `WebGpuBackend`. Re-captures and rebuilds when the backend
+     * reference changes (e.g. after device-loss recovery).
      */
-    clearParticles() {
-        for (const particle of this._particles) {
-            particle.destroy();
+    render(backend) {
+        if (this._backend !== backend) {
+            this._backend = backend;
+            if (this._gpuState !== null) {
+                this._gpuState.destroy();
+                this._gpuState = null;
+            }
+            this._gpuMode = false;
+            this._compiled = false;
         }
-        for (const particle of this._graveyard) {
-            particle.destroy();
+        return super.render(backend);
+    }
+    /** Per-frame entry point. Routes to CPU or GPU pipeline based on auto-detection at first call. */
+    update(delta) {
+        if (!this._compiled) {
+            this._compile();
+        }
+        const dt = delta.seconds;
+        // 1. Spawn (CPU writes SoA in both modes).
+        for (let i = 0; i < this._spawnModules.length; i++) {
+            this._spawnModules[i].apply(this, dt);
+        }
+        if (this._gpuMode) {
+            this._updateGpu(dt);
+        }
+        else {
+            this._updateCpu(dt);
         }
-        this._particles.length = 0;
-        this._graveyard.length = 0;
         return this;
     }
-    /**
-     * Advances the full simulation by one `delta` step: runs all emitters,
-     * then for each live particle calls {@link updateParticle}, moves expired
-     * ones to the {@link graveyard}, and runs all affectors on survivors.
-     * The particle array is iterated in reverse to allow in-place splice
-     * without re-indexing.
-     */
-    update(delta) {
-        const emitters = this._emitters;
-        const affectors = this._affectors;
-        const particles = this._particles;
-        const graveyard = this._graveyard;
-        const len = particles.length;
-        for (const emitter of emitters) {
-            emitter.apply(this, delta);
-        }
-        let expireCount = 0;
-        for (let i = len - 1; i >= 0; i--) {
-            this.updateParticle(particles[i], delta);
-            if (particles[i].expired) {
-                graveyard.push(particles[i]);
-                expireCount++;
+    destroy() {
+        super.destroy();
+        this.clearSpawnModules();
+        this.clearUpdateModules();
+        this.clearDeathModules();
+        if (this._gpuState !== null) {
+            this._gpuState.destroy();
+            this._gpuState = null;
+        }
+        for (const frame of this._frames) {
+            frame.destroy();
+        }
+        this._frames.length = 0;
+        this._gpuMode = false;
+        this._compiled = false;
+        this.liveCount = 0;
+        this.alive.fill(0);
+        this._textureFrame.destroy();
+    }
+    _compile() {
+        this._compiled = true;
+        // Duck-typed `instanceof WebGpuBackend` — avoids importing the
+        // backend class (which registers a renderer for ParticleSystem
+        // and would create a circular dependency). WebGl2Backend has no
+        // `device` field, so this naturally falls back to CPU mode.
+        const backendDevice = this._backend?.device ?? null;
+        const device = this._device ?? backendDevice;
+        if (device === null) {
+            return;
+        }
+        const allEligible = this._updateModules.every((m) => typeof m.wgsl === 'function');
+        if (!allEligible) {
+            return;
+        }
+        this._gpuState = new ParticleGpuState(device, this.capacity, this._updateModules, this._frames, this._texture);
+        this._gpuMode = true;
+        // Mark every currently-alive slot dirty so the initial upload
+        // matches CPU state; subsequent frames only push deltas.
+        for (let i = 0; i < this.liveCount; i++) {
+            if (this.alive[i])
+                this._gpuDirtySlots.add(i);
+        }
+    }
+    _spawnCpu() {
+        if (this.liveCount >= this.capacity) {
+            return -1;
+        }
+        const slot = this.liveCount++;
+        this.alive[slot] = 1;
+        this.elapsed[slot] = 0;
+        return slot;
+    }
+    _spawnGpu() {
+        const capacity = this.capacity;
+        const alive = this.alive;
+        const start = this._spawnHint;
+        // Search forward from hint, then wrap.
+        for (let i = start; i < capacity; i++) {
+            if (alive[i] === 0) {
+                alive[i] = 1;
+                this.elapsed[i] = 0;
+                this._spawnHint = i + 1 === capacity ? 0 : i + 1;
+                if (i >= this.liveCount)
+                    this.liveCount = i + 1;
+                this._gpuDirtySlots.add(i);
+                return i;
+            }
+        }
+        for (let i = 0; i < start; i++) {
+            if (alive[i] === 0) {
+                alive[i] = 1;
+                this.elapsed[i] = 0;
+                this._spawnHint = i + 1;
+                if (i >= this.liveCount)
+                    this.liveCount = i + 1;
+                this._gpuDirtySlots.add(i);
+                return i;
+            }
+        }
+        return -1;
+    }
+    _updateCpu(dt) {
+        const { posX, posY, velX, velY, rotations, rotationSpeeds, elapsed } = this;
+        const liveCount = this.liveCount;
+        for (let i = 0; i < liveCount; i++) {
+            posX[i] += velX[i] * dt;
+            posY[i] += velY[i] * dt;
+            rotations[i] += rotationSpeeds[i] * dt;
+            elapsed[i] += dt;
+        }
+        for (let i = 0; i < this._updateModules.length; i++) {
+            this._updateModules[i].apply(this, dt);
+        }
+        // Compact: forward pass, fire death modules on expired, copy survivors down.
+        const lifetime = this.lifetime;
+        const alive = this.alive;
+        const deathModules = this._deathModules;
+        let writeIndex = 0;
+        for (let readIndex = 0; readIndex < this.liveCount; readIndex++) {
+            if (elapsed[readIndex] >= lifetime[readIndex]) {
+                for (let m = 0; m < deathModules.length; m++) {
+                    deathModules[m].onDeath(this, readIndex);
+                }
+                alive[readIndex] = 0;
                 continue;
             }
-            if (expireCount > 0) {
-                particles.splice(i + 1, expireCount);
-                expireCount = 0;
+            if (writeIndex !== readIndex) {
+                this._copySlot(readIndex, writeIndex);
+                alive[writeIndex] = 1;
             }
-            for (const affector of affectors) {
-                affector.apply(particles[i], delta);
+            writeIndex++;
+        }
+        for (let i = writeIndex; i < this.liveCount; i++) {
+            alive[i] = 0;
+        }
+        this.liveCount = writeIndex;
+    }
+    _updateGpu(dt) {
+        // CPU advances its own copy of `elapsed` for expire detection only.
+        // GPU's `timing[idx].x` is advanced independently inside the compute
+        // shader; the two are never synced after spawn. They tick at the
+        // same rate (both add `dt` per frame) so they stay equivalent in
+        // practice (modulo numerical drift).
+        const elapsed = this.elapsed;
+        const lifetime = this.lifetime;
+        const alive = this.alive;
+        const deathModules = this._deathModules;
+        const liveCount = this.liveCount;
+        for (let i = 0; i < liveCount; i++) {
+            if (alive[i] === 0)
+                continue;
+            elapsed[i] += dt;
+            if (elapsed[i] >= lifetime[i]) {
+                for (let m = 0; m < deathModules.length; m++) {
+                    deathModules[m].onDeath(this, i);
+                }
+                alive[i] = 0;
+                lifetime[i] = -1; // sentinel — GPU shader skips
+                this._gpuDirtySlots.add(i); // upload the sentinel so GPU sees the death
             }
         }
-        if (expireCount > 0) {
-            particles.splice(0, expireCount);
+        // Trim trailing dead slots.
+        let newLiveCount = this.liveCount;
+        while (newLiveCount > 0 && alive[newLiveCount - 1] === 0) {
+            newLiveCount--;
         }
-        return this;
+        this.liveCount = newLiveCount;
+        // Push dirty slots (new spawns + just-expired) to GPU. CPU is NOT
+        // the source of truth for integrated position/velocity/etc. after
+        // spawn — uploading the full live range every frame would wipe
+        // out GPU's integrated state.
+        if (this._gpuDirtySlots.size > 0) {
+            this._gpuState.uploadDirty(this, this._gpuDirtySlots);
+            this._gpuDirtySlots.clear();
+        }
+        this._gpuState.dispatch(this, dt);
     }
-    destroy() {
-        super.destroy();
-        this.clearEmitters();
-        this.clearAffectors();
-        this.clearParticles();
-        this._textureFrame.destroy();
+    _copySlot(from, to) {
+        this.posX[to] = this.posX[from];
+        this.posY[to] = this.posY[from];
+        this.velX[to] = this.velX[from];
+        this.velY[to] = this.velY[from];
+        this.scaleX[to] = this.scaleX[from];
+        this.scaleY[to] = this.scaleY[from];
+        this.rotations[to] = this.rotations[from];
+        this.rotationSpeeds[to] = this.rotationSpeeds[from];
+        this.color[to] = this.color[from];
+        this.elapsed[to] = this.elapsed[from];
+        this.lifetime[to] = this.lifetime[from];
+        this.textureIndex[to] = this.textureIndex[from];
     }
 }