babylon.quarks 0.20.0 → 0.23.0

package/src/ParticleSystem.ts

@@ -47,7 +47,7 @@ import {BatchedRenderer, VFXBatchSettings} from './BatchedRenderer';
 import {ensureEnvAtlasFromCube, getCachedEnvAtlas} from './envAtlas';
 import {ensureTriangleIndices} from './geometryUtil';
 import {ParticleEmitter} from './ParticleEmitter';
-import {RenderMode} from './VFXBatch';
+import {MeshLighting, MeshRim, normalizeMeshRim, RenderMode} from './VFXBatch';
 
 export interface BurstParameters {
     time: number;
@@ -62,6 +62,7 @@ type StoreBackedParticle = Particle & {storeIndex: number; setStoreIndex(index:
 
 const UP = new Vector3(0, 0, 1);
 const tempQ = new Quaternion();
+const IDENTITY_QUATERNION = new Quaternion();
 const tempV = new Vector3();
 const tempV2 = new Vector3();
 const PREWARM_FPS = 60;
@@ -75,6 +76,30 @@ const MAX_SIMULATION_STEPS_PER_FRAME = 8;
 // and keeps the well-tested "half a step is no step yet" behavior.
 const ROUND_TIE_BIAS = 1e-9;
 
+/** Built-in behaviors that write a particle's size / colour, and those that touch neither. */
+const SIZE_BEHAVIORS = new Set(['SizeOverLife', 'SizeBySpeed']);
+const COLOR_BEHAVIORS = new Set(['ColorOverLife', 'ColorBySpeed']);
+const INERT_FOR_SIZE_AND_COLOR = new Set([
+    'ApplyForce',
+    'Noise',
+    'TurbulenceField',
+    'GravityForce',
+    'RotationOverLife',
+    'Rotation3DOverLife',
+    'RotationBySpeed',
+    'SpeedOverLife',
+    'FrameOverLife',
+    'ForceOverLife',
+    'VelocityOverLife',
+    'InheritVelocity',
+    'OrbitOverLife',
+    'WidthOverLength',
+    'ChangeEmitDirection',
+    'EmitSubParticleSystem',
+    'LimitSpeedOverLife',
+    'ApplyCollision',
+]);
+
 const DEFAULT_POSITIONS = new Float32Array([-0.5, -0.5, 0, 0.5, -0.5, 0, 0.5, 0.5, 0, -0.5, 0.5, 0]);
 const DEFAULT_UVS = new Float32Array([0, 0, 1, 0, 1, 1, 0, 1]);
 
@@ -142,6 +167,10 @@ export interface ParticleSystemParameters {
     pivot?: Vector3;
     /** Fraction of billboard particles mirrored along U (x) and V (y), see {@link ParticleSystem.flip}. */
     flip?: Vector2;
+    /** How mesh particles are lit, see {@link ParticleSystem.lighting}. Default `'fixed'`. */
+    lighting?: MeshLighting;
+    /** Rim (Fresnel) term on mesh particles, see {@link ParticleSystem.rim}. Default none. */
+    rim?: Partial<MeshRim>;
     scene?: Scene;
 }
 
@@ -259,6 +288,8 @@ export class ParticleSystem implements IParticleSystem {
     private previousEmitterPos?: Vector3;
     private tempEmitterPos: Vector3 = new Vector3();
     private temp: Vector3 = new Vector3();
+    /** Emitter matrix moved along the step's path, see spawnAlongPath. */
+    private pathMatrix: Matrix4 = new Matrix4();
     private normalMatrix: Matrix3 = new Matrix3();
     private memory: GeneratorMemory = [];
     private listeners: {[event: string]: Array<(event: ParticleSystemEvent) => void>} = {};
@@ -271,6 +302,12 @@ export class ParticleSystem implements IParticleSystem {
     /** Behaviors the cached plan was built from, compared by identity. */
     private fusionPlan?: Array<Behavior>;
     private fusionSteps: Array<FusionStep> = [];
+    /**
+     * Whether any behavior in the plan can change a particle's size or colour
+     * after birth. Only then does a step have to snapshot them for the renderer.
+     */
+    private planChangesSize = true;
+    private planChangesColor = true;
     /** @internal **/
     _renderer?: BatchedRenderer;
 
@@ -304,6 +341,9 @@ export class ParticleSystem implements IParticleSystem {
         if (state.burstIndex < this.emissionBursts.length) {
             return true;
         }
+        if (this.hasPendingBurstWaves(state)) {
+            return true;
+        }
         if (state.time >= this.duration) {
             return false;
         }
@@ -400,6 +440,44 @@ export class ParticleSystem implements IParticleSystem {
         this.neededToUpdateRender = true;
     }
 
+    /**
+     * How mesh particles are lit: `'fixed'` (the default — the renderer's
+     * light, see {@link BatchedRenderer.setMeshLighting}), `'unlit'` (texture
+     * times colour, for emissive meshes) or `'scene'` (the scene's first
+     * directional or hemispheric light). Saved with the material in the effect
+     * JSON. Other render modes ignore it.
+     */
+    get lighting(): MeshLighting {
+        return this.rendererSettings.lighting ?? 'fixed';
+    }
+
+    set lighting(lighting: MeshLighting) {
+        this.rendererSettings.lighting = ParticleSystem.validLighting(lighting);
+        this.neededToUpdateRender = true;
+    }
+
+    /**
+     * Rim (Fresnel) term on mesh particles — a glowing edge (`mode: 'add'`) or
+     * an outline (`'mix'`), see {@link MeshRim}. Undefined (the default) draws
+     * none. Fields left out of an assigned rim take their defaults; assign a
+     * new object to change it, editing the returned one does not reach the
+     * renderer. Saved with the material in the effect JSON. Other render modes
+     * ignore it.
+     */
+    get rim(): MeshRim | undefined {
+        return this.rendererSettings.rim;
+    }
+
+    set rim(rim: Partial<MeshRim> | undefined) {
+        this.rendererSettings.rim = normalizeMeshRim(rim);
+        this.neededToUpdateRender = true;
+    }
+
+    /** `lighting` if it is one of the modes, else the default. */
+    private static validLighting(lighting: unknown): MeshLighting {
+        return lighting === 'unlit' || lighting === 'scene' ? lighting : 'fixed';
+    }
+
     private static nonZeroPivot(v: Vector3 | undefined): Vector3 | undefined {
         return v && (v.x !== 0 || v.y !== 0 || v.z !== 0) ? v.clone() : undefined;
     }
@@ -563,6 +641,8 @@ export class ParticleSystem implements IParticleSystem {
             reflectionAtlas: null,
             layerMask: parameters.layerMask ?? 0x0fffffff,
             pivot: ParticleSystem.nonZeroPivot(parameters.pivot),
+            lighting: ParticleSystem.validLighting(parameters.lighting),
+            rim: normalizeMeshRim(parameters.rim),
         };
         this.flip = ParticleSystem.nonZeroFlip(parameters.flip);
         if (this.rendererSettings.renderMode === RenderMode.Mesh && !this.rendererSettings.instancingNormals) {
@@ -821,7 +901,9 @@ export class ParticleSystem implements IParticleSystem {
                 this.startRotation.startGen(particle.memory);
                 if (isMeshMode) {
                     if (!(sprite.rotation instanceof Quaternion)) {
-                        sprite.rotation = new Quaternion();
+                        // Assigning a quaternion gives the particle a row in the
+                        // store's quaternion column; the value is overwritten below.
+                        sprite.rotation = IDENTITY_QUATERNION;
                     }
                     // A recycled particle can still carry the turn of whatever
                     // it was last time; the renderer would draw a fraction of it
@@ -893,6 +975,9 @@ export class ParticleSystem implements IParticleSystem {
             for (let j = 0; j < behaviorCount; j++) {
                 behaviors[j].initialize(particle, this);
             }
+            // Every generator has claimed its slot by now; give the compiled
+            // behavior passes a column copy of the samples.
+            this.store.recordMemory((particle as StoreBackedParticle).storeIndex, particle.memory);
         }
     }
 
@@ -921,6 +1006,7 @@ export class ParticleSystem implements IParticleSystem {
         this.emissionState.isBursting = false;
         this.emissionState.burstIndex = 0;
         this.emissionState.burstWaveIndex = 0;
+        this.emissionState.burstWaves = undefined;
         this.emissionState.time = 0;
         this.emissionState.waitEmiting = 0;
         this.behaviors.forEach((behavior) => behavior.reset());
@@ -1079,6 +1165,22 @@ export class ParticleSystem implements IParticleSystem {
         }
         this.fusionPlan = behaviors.slice();
         this.fusionSteps = planBehaviorFusion(behaviors);
+        let changesSize = false;
+        let changesColor = false;
+        for (let i = 0; i < behaviors.length; i++) {
+            const type = behaviors[i].type;
+            if (SIZE_BEHAVIORS.has(type)) {
+                changesSize = true;
+            } else if (COLOR_BEHAVIORS.has(type)) {
+                changesColor = true;
+            } else if (!INERT_FOR_SIZE_AND_COLOR.has(type)) {
+                // Unknown to this list, so it may write anything.
+                changesSize = true;
+                changesColor = true;
+            }
+        }
+        this.planChangesSize = changesSize;
+        this.planChangesColor = changesColor;
         return this.fusionSteps;
     }
 
@@ -1104,18 +1206,29 @@ export class ParticleSystem implements IParticleSystem {
         // held before, and so is drawn at the emitter instead of jumping.
         const columns = this.store;
         const vector3Rows = particleCount * 3;
+        const steps = this.behaviorSteps();
+        // Size and colour are only snapshotted when some behavior can change
+        // them; otherwise the columns stay what spawn wrote and the renderer
+        // reads them as they are.
+        const snapshotSize = this.planChangesSize;
+        const snapshotColor = this.planChangesColor;
+        columns.useSizeSnapshot(snapshotSize);
+        columns.useColorSnapshot(snapshotColor);
         columns.previousPosition.set(columns.position.subarray(0, vector3Rows));
-        columns.previousSize.set(columns.size.subarray(0, vector3Rows));
+        if (snapshotSize) {
+            columns.previousSize.set(columns.size.subarray(0, vector3Rows));
+        }
         if (stretched) {
             if (columns.keepPreviousVelocity()) {
                 this.rebindParticles();
             }
             columns.previousVelocity.set(columns.velocity.subarray(0, vector3Rows));
         }
-        columns.previousColor.set(columns.color.subarray(0, particleCount * 4));
+        if (snapshotColor) {
+            columns.previousColor.set(columns.color.subarray(0, particleCount * 4));
+        }
 
         this.emitterShape.update(this, delta);
-        const steps = this.behaviorSteps();
         for (let s = 0; s < steps.length; s++) {
             const step = steps[s];
             const stepBehaviors = step.behaviors;
@@ -1129,7 +1242,7 @@ export class ParticleSystem implements IParticleSystem {
                 continue;
             }
             if (step.run !== undefined) {
-                step.run(behaviors, particles, particleCount, delta);
+                step.run(behaviors, particles, particleCount, delta, this.store);
                 continue;
             }
             const behavior = stepBehaviors[0];
@@ -1146,34 +1259,111 @@ export class ParticleSystem implements IParticleSystem {
             }
         }
 
-        // Newborns were snapshotted above with spawn size/color (startSize /
-        // startColor) before SizeOverLife / ColorOverLife ran. That false jump
-        // is then extrapolated by the renderer when simulationResidual is
-        // negative (common with rounded fixed-step) and flashes the start
-        // appearance at the emitter. Collapse it so birth matches t=0 on the
-        // curves. Age is still 0 here — integration below ages them.
+        const notifyDeaths = this.hasListeners('particleDied');
+        const store = this.store;
+        const scalars = store.scalars;
+        const stride = ParticleStore.SCALAR_STRIDE;
+        let liveParticleCount = this.particleNum;
+
+        if (!isTrailMode) {
+            // One pass over the columns does three things the sprite path needs,
+            // none of which touches a particle object until a death:
+            //
+            // Newborns were snapshotted above with their spawn size and colour,
+            // before SizeOverLife / ColorOverLife ran. That false jump would be
+            // extrapolated by the renderer when the residual is negative (common
+            // with the rounded fixed step) and flash the start appearance at the
+            // emitter, so the snapshot is collapsed onto the curves' t=0 value.
+            // Age is still 0 at that point; the same iteration then ages it.
+            //
+            // Position is integrated along the velocity.
+            //
+            // A particle whose age reached its life is swapped with the last live
+            // one, rows included, so slot k always owns row k and the live
+            // particles stay one contiguous range the renderer copies as is. The
+            // survivor moved into the slot has not been visited yet, so the slot
+            // is processed again.
+            const positions = store.position;
+            const velocities = store.velocity;
+            const prevSize = store.previousSize;
+            const curSize = store.size;
+            const prevColor = store.previousColor;
+            const curColor = store.color;
+            const collapseSize = snapshotSize;
+            const collapseColor = snapshotColor;
+            for (let i = 0; i < liveParticleCount; i++) {
+                const scalar = i * stride;
+                let age = scalars[scalar + ParticleStore.AGE];
+                const offset = i * 3;
+                if (age === 0) {
+                    if (collapseSize) {
+                        prevSize[offset] = curSize[offset];
+                        prevSize[offset + 1] = curSize[offset + 1];
+                        prevSize[offset + 2] = curSize[offset + 2];
+                    }
+                    if (collapseColor) {
+                        const o4 = i * 4;
+                        prevColor[o4] = curColor[o4];
+                        prevColor[o4 + 1] = curColor[o4 + 1];
+                        prevColor[o4 + 2] = curColor[o4 + 2];
+                        prevColor[o4 + 3] = curColor[o4 + 3];
+                    }
+                }
+                const step = delta * scalars[scalar + ParticleStore.SPEED_MODIFIER];
+                positions[offset] += velocities[offset] * step;
+                positions[offset + 1] += velocities[offset + 1] * step;
+                positions[offset + 2] += velocities[offset + 2] * step;
+                age += delta;
+                scalars[scalar + ParticleStore.AGE] = age;
+                if (age >= scalars[scalar + ParticleStore.LIFE]) {
+                    const last = liveParticleCount - 1;
+                    const particle = particles[i];
+                    const survivor = particles[last] as StoreBackedParticle;
+                    particles[i] = survivor;
+                    particles[last] = particle;
+                    if (i !== last) {
+                        store.swapRows(i, last);
+                        survivor.setStoreIndex(i);
+                        (particle as StoreBackedParticle).setStoreIndex(last);
+                    }
+                    liveParticleCount--;
+                    i--;
+                    if (notifyDeaths) {
+                        this.fire({type: 'particleDied', particleSystem: this, particle: particle});
+                    }
+                }
+            }
+            this.particleNum = liveParticleCount;
+            this.notifyFinished();
+            return;
+        }
+
+        // Trails: the newborn collapse, then motion, then the trail history,
+        // then removal, each over the particle objects the history lives on.
         if (particleCount > 0) {
             const prevSize = columns.previousSize;
             const curSize = columns.size;
             const prevColor = columns.previousColor;
             const curColor = columns.color;
-            const scalars = columns.scalars;
-            const stride = ParticleStore.SCALAR_STRIDE;
             for (let i = 0, o3 = 0, o4 = 0, s = 0; i < particleCount; i++, o3 += 3, o4 += 4, s += stride) {
                 if (scalars[s + ParticleStore.AGE] !== 0) {
                     continue;
                 }
-                prevSize[o3] = curSize[o3];
-                prevSize[o3 + 1] = curSize[o3 + 1];
-                prevSize[o3 + 2] = curSize[o3 + 2];
-                prevColor[o4] = curColor[o4];
-                prevColor[o4 + 1] = curColor[o4 + 1];
-                prevColor[o4 + 2] = curColor[o4 + 2];
-                prevColor[o4 + 3] = curColor[o4 + 3];
+                if (snapshotSize) {
+                    prevSize[o3] = curSize[o3];
+                    prevSize[o3 + 1] = curSize[o3 + 1];
+                    prevSize[o3 + 2] = curSize[o3 + 2];
+                }
+                if (snapshotColor) {
+                    prevColor[o4] = curColor[o4];
+                    prevColor[o4 + 1] = curColor[o4 + 1];
+                    prevColor[o4 + 2] = curColor[o4 + 2];
+                    prevColor[o4 + 3] = curColor[o4 + 3];
+                }
             }
         }
 
-        const followLocalOrigin = isTrailMode && (this.rendererEmitterSettings as TrailSettings).followLocalOrigin;
+        const followLocalOrigin = (this.rendererEmitterSettings as TrailSettings).followLocalOrigin;
         if (followLocalOrigin) {
             const emitterMatrix = this.emitter.matrixWorld;
             for (let i = 0; i < particleCount; i++) {
@@ -1187,12 +1377,8 @@ export class ParticleSystem implements IParticleSystem {
                 particle.age += delta;
             }
         } else {
-            // Live particles own rows [0, particleNum), so integrate straight
-            // over the columns. Nothing in here touches a particle object.
-            const positions = this.store.position;
-            const velocities = this.store.velocity;
-            const scalars = this.store.scalars;
-            const stride = ParticleStore.SCALAR_STRIDE;
+            const positions = store.position;
+            const velocities = store.velocity;
             for (let i = 0, offset = 0, scalar = 0; i < particleCount; i++, offset += 3, scalar += stride) {
                 const step = delta * scalars[scalar + ParticleStore.SPEED_MODIFIER];
                 positions[offset] += velocities[offset] * step;
@@ -1202,7 +1388,7 @@ export class ParticleSystem implements IParticleSystem {
             }
         }
 
-        if (isTrailMode) {
+        {
             const trailSettings = this.rendererEmitterSettings as TrailSettings;
             const dieWithParticle = trailSettings.dieWithParticle;
             // A world-space system records world positions already.
@@ -1230,23 +1416,15 @@ export class ParticleSystem implements IParticleSystem {
             }
         }
 
-        const notifyDeaths = this.hasListeners('particleDied');
-        const store = this.store;
-        const scalars = store.scalars;
-        const scalarStride = ParticleStore.SCALAR_STRIDE;
-        let liveParticleCount = this.particleNum;
         for (let i = 0; i < liveParticleCount; i++) {
-            const particle = particles[i];
-            const scalar = i * scalarStride;
+            const particle = particles[i] as TrailParticle;
+            const scalar = i * stride;
             const dead = scalars[scalar + ParticleStore.AGE] >= scalars[scalar + ParticleStore.LIFE];
-            if (dead && (!isTrailMode || (particle as TrailParticle).historyCount === 0)) {
+            if (dead && particle.historyCount === 0) {
                 const last = liveParticleCount - 1;
                 const survivor = particles[last] as StoreBackedParticle;
                 particles[i] = survivor;
                 particles[last] = particle;
-                // Move the rows along with the particles so slot k always owns
-                // row k. Live particles then stay one contiguous range, which is
-                // what lets the renderer copy them without gathering.
                 if (i !== last) {
                     store.swapRows(i, last);
                     survivor.setStoreIndex(i);
@@ -1277,11 +1455,142 @@ export class ParticleSystem implements IParticleSystem {
         }
     }
 
+    /** Waves a burst fires per loop: its `cycle`, and never fewer than one. */
+    private static burstWaveCount(burst: BurstParameters): number {
+        return burst.cycle >= 1 ? Math.floor(burst.cycle) : 1;
+    }
+
+    /** Seconds between a burst's waves; a missing or negative interval fires them all at once. */
+    private static burstInterval(burst: BurstParameters): number {
+        return burst.interval > 0 ? burst.interval : 0;
+    }
+
+    /**
+     * Fires the burst waves that are due by `emissionState.time`.
+     *
+     * Wave `w` of a burst is due at `burst.time + w * burst.interval`, and the
+     * burst fires `cycle` of them, each rolling `probability` on its own — the
+     * way Unity repeats a burst. Bursts start in time order, as they always
+     * have; their repeats are tracked per burst so a burst that is still
+     * repeating never holds back a later one. Repeats falling past the
+     * system's duration are dropped (a looping system starts them over on its
+     * next loop), matching Unity, which never emits a burst cycle beyond the
+     * end of the duration.
+     */
+    private emitBursts(emissionState: EmissionState, emitterMatrix: Matrix4): void {
+        const bursts = this.emissionBursts;
+        const burstCount = bursts.length;
+        const time = emissionState.time;
+        const waves = (emissionState.burstWaves ??= []);
+        while (emissionState.burstIndex < burstCount && bursts[emissionState.burstIndex].time <= time) {
+            waves[emissionState.burstIndex] = 0;
+            emissionState.burstIndex++;
+        }
+        const started = emissionState.burstIndex;
+        for (let b = 0; b < started; b++) {
+            const burst = bursts[b];
+            const cycles = ParticleSystem.burstWaveCount(burst);
+            let wave = waves[b] ?? 0;
+            if (wave >= cycles) {
+                continue;
+            }
+            const interval = ParticleSystem.burstInterval(burst);
+            while (wave < cycles) {
+                const waveTime = burst.time + wave * interval;
+                if (wave > 0 && waveTime > this.duration) {
+                    wave = cycles;
+                    break;
+                }
+                if (waveTime > time) {
+                    break;
+                }
+                emissionState.burstWaveIndex = wave;
+                this.fireBurstWave(burst, emissionState, emitterMatrix);
+                wave++;
+            }
+            waves[b] = wave;
+        }
+    }
+
+    /** Spawns one wave of `burst`, if its probability roll passes. */
+    private fireBurstWave(burst: BurstParameters, emissionState: EmissionState, emitterMatrix: Matrix4): void {
+        if (Math.random() >= burst.probability) {
+            return;
+        }
+        const rawCount = burst.count.genValue(this.memory, this.time);
+        const qualityFactor = this.qualityFactor;
+        const count = qualityFactor >= 0.999 ? rawCount : Math.floor(rawCount * qualityFactor);
+        emissionState.isBursting = true;
+        emissionState.burstParticleCount = count;
+        this.spawn(count, emissionState, emitterMatrix);
+        emissionState.isBursting = false;
+    }
+
+    /** True while a burst that has started still has a wave due within the duration. */
+    private hasPendingBurstWaves(state: EmissionState): boolean {
+        const waves = state.burstWaves;
+        if (waves === undefined) {
+            return false;
+        }
+        const bursts = this.emissionBursts;
+        for (let b = 0; b < state.burstIndex && b < bursts.length; b++) {
+            const burst = bursts[b];
+            const wave = waves[b] ?? 0;
+            if (
+                wave < ParticleSystem.burstWaveCount(burst) &&
+                (wave === 0 || burst.time + wave * ParticleSystem.burstInterval(burst) <= this.duration)
+            ) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Spawns `count` particles owed to emission over distance, each where the
+     * emitter crossed its metre mark on the way from `from` to where
+     * `emitterMatrix` has it now, rather than all of them at the end of the
+     * path: a fast emitter then leaves a continuous trail instead of one clump
+     * per step.
+     *
+     * `carried` is how far the emitter had already gone past its last mark
+     * before this step, so the marks keep their spacing across steps. Only the
+     * position is interpolated; the emitter's current rotation and scale are
+     * used for every particle.
+     */
+    private spawnAlongPath(
+        count: number,
+        emissionState: EmissionState,
+        emitterMatrix: Matrix4,
+        from: Vector3,
+        carried: number,
+        spacing: number,
+        length: number
+    ): void {
+        const matrix = this.pathMatrix.copy(emitterMatrix);
+        const target = emitterMatrix.elements;
+        const elements = matrix.elements;
+        const tx = target[12];
+        const ty = target[13];
+        const tz = target[14];
+        for (let k = 1; k <= count; k++) {
+            const travelled = k * spacing - carried;
+            const f = travelled <= 0 ? 0 : travelled >= length ? 1 : travelled / length;
+            elements[12] = from.x + (tx - from.x) * f;
+            elements[13] = from.y + (ty - from.y) * f;
+            elements[14] = from.z + (tz - from.z) * f;
+            this.spawn(1, emissionState, matrix);
+        }
+    }
+
     emit(delta: number, emissionState: EmissionState, emitterMatrix: Matrix4) {
         if (emissionState.time > this.duration) {
             if (this.looping) {
                 emissionState.time -= this.duration;
                 emissionState.burstIndex = 0;
+                if (emissionState.burstWaves !== undefined) {
+                    emissionState.burstWaves.length = 0;
+                }
                 for (let i = 0; i < this.behaviors.length; i++) {
                     this.behaviors[i].reset();
                 }
@@ -1297,39 +1606,41 @@ export class ParticleSystem implements IParticleSystem {
         if (this.worldSpace) {
             this.normalMatrix.getNormalMatrix(emitterMatrix);
         }
-        const emissionBursts = this.emissionBursts;
-        const emissionBurstCount = emissionBursts.length;
+        const emissionBurstCount = this.emissionBursts.length;
         const qualityFactor = this.qualityFactor;
 
-        while (
-            emissionState.burstIndex < emissionBurstCount &&
-            emissionBursts[emissionState.burstIndex].time <= emissionState.time
-        ) {
-            const burst = emissionBursts[emissionState.burstIndex];
-            if (Math.random() < burst.probability) {
-                const rawCount = burst.count.genValue(this.memory, this.time);
-                const count = qualityFactor >= 0.999 ? rawCount : Math.floor(rawCount * qualityFactor);
-                emissionState.isBursting = true;
-                emissionState.burstParticleCount = count;
-                this.spawn(count, emissionState, emitterMatrix);
-                emissionState.isBursting = false;
-            }
-            emissionState.burstIndex++;
+        if (emissionBurstCount > 0) {
+            this.emitBursts(emissionState, emitterMatrix);
         }
 
+        // Particles owed to the distance travelled this step, spawned along it.
+        let pathSpawn = 0;
+        let pathSpacing = 0;
+        let pathCarried = 0;
+        let pathLength = 0;
+        const previousWorldPos = emissionState.previousWorldPos;
         if (!this.emitEnded) {
             const timeRatio = emissionState.time / this.duration;
             emissionState.waitEmiting += delta * this.emissionOverTime.genValue(this.memory, timeRatio) * qualityFactor;
 
-            const previousWorldPos = emissionState.previousWorldPos;
             if (previousWorldPos !== undefined) {
                 this.temp.set(emitterMatrix.elements[12], emitterMatrix.elements[13], emitterMatrix.elements[14]);
-                emissionState.travelDistance += previousWorldPos.distanceTo(this.temp);
+                pathLength = previousWorldPos.distanceTo(this.temp);
+                pathCarried = emissionState.travelDistance;
+                emissionState.travelDistance += pathLength;
                 const emitPerMeter = this.emissionOverDistance.genValue(this.memory, timeRatio) * qualityFactor;
                 if (emissionState.travelDistance * emitPerMeter > 0) {
                     const count = Math.floor(emissionState.travelDistance * emitPerMeter);
                     emissionState.travelDistance -= count / emitPerMeter;
-                    emissionState.waitEmiting += count;
+                    // A world-space particle stays where it is born, so it is born
+                    // where the emitter passed its mark. A local-space one moves
+                    // with the emitter and has no path to be spread along.
+                    if (this.worldSpace && pathLength > 0) {
+                        pathSpawn = count;
+                        pathSpacing = 1 / emitPerMeter;
+                    } else {
+                        emissionState.waitEmiting += count;
+                    }
                 }
             }
         }
@@ -1341,6 +1652,17 @@ export class ParticleSystem implements IParticleSystem {
             this.spawn(totalSpawn, emissionState, emitterMatrix);
             emissionState.waitEmiting -= totalSpawn;
         }
+        if (pathSpawn > 0) {
+            this.spawnAlongPath(
+                pathSpawn,
+                emissionState,
+                emitterMatrix,
+                previousWorldPos!,
+                pathCarried,
+                pathSpacing,
+                pathLength
+            );
+        }
 
         if (emissionState.previousWorldPos === undefined) emissionState.previousWorldPos = new Vector3();
         emissionState.previousWorldPos.set(
@@ -1517,6 +1839,8 @@ export class ParticleSystem implements IParticleSystem {
             layerMask: json.layers,
             pivot: json.pivot ? new Vector3(json.pivot[0] ?? 0, json.pivot[1] ?? 0, json.pivot[2] ?? 0) : undefined,
             flip: json.flip ? new Vector2(json.flip[0] ?? 0, json.flip[1] ?? 0) : undefined,
+            lighting: materialMeta?.lighting,
+            rim: materialMeta?.rim,
         });
         ps.behaviors = (json.behaviors ?? [])
             .map((behaviorJson) => {
@@ -1604,6 +1928,9 @@ export class ParticleSystem implements IParticleSystem {
             texture: textureUUID,
             reflectionAtlas: reflectionAtlasUUID,
             reflectionLevel: this.rendererSettings.reflectionLevel,
+            // Written only when not the default, so existing effects serialise as before.
+            ...(this.lighting !== 'fixed' ? {lighting: this.lighting} : {}),
+            ...(this.rim ? {rim: {...this.rim, color: [...this.rim.color]}} : {}),
             sourceMaterial: this.materialRef ?? undefined,
         };
         return materialUUID;
@@ -1767,6 +2094,8 @@ export class ParticleSystem implements IParticleSystem {
             layerMask: this.rendererSettings.layerMask,
             pivot: this.pivot,
             flip: this.flip,
+            lighting: this.lighting,
+            rim: this.rim,
             scene: this.emitter.getScene(),
         });
     }