babylon.quarks 0.17.2 → 0.17.4

package/dist/types/BatchedRenderer.d.ts

@@ -25,16 +25,35 @@ export interface VFXBatchSettings {
     texture: Texture | null;
     layerMask: number;
 }
+export interface AdaptivePerformanceOptions {
+    targetFrameMs: number;
+    minQuality: number;
+    maxQuality: number;
+    decreaseStep: number;
+    increaseStep: number;
+}
+export interface AdaptivePerformanceState extends AdaptivePerformanceOptions {
+    enabled: boolean;
+    currentQuality: number;
+    lastFrameCpuMs: number;
+}
 export declare class BatchedRenderer extends TransformNode {
     batches: Array<VFXBatch>;
     systemToBatchIndex: Map<IParticleSystem, number>;
     depthTexture: BaseTexture | null;
+    private adaptivePerformanceState;
+    private lastAppliedQuality;
     constructor(name: string, scene: Scene);
+    private static clamp;
     private static equals;
     addSystem(system: IParticleSystem): void;
     deleteSystem(system: IParticleSystem): void;
     updateSystem(system: IParticleSystem): void;
     setDepthTexture(depthTexture: BaseTexture | null): void;
+    configureAdaptivePerformance(options?: Partial<AdaptivePerformanceOptions>): void;
+    disableAdaptivePerformance(resetQuality?: boolean): void;
+    getAdaptivePerformanceState(): AdaptivePerformanceState;
+    private applyAdaptiveQuality;
     update(delta: number): void;
     dispose(): void;
 }

package/dist/types/ParticleSystem.d.ts

@@ -162,6 +162,8 @@ export declare class ParticleSystem implements IParticleSystem {
     private listeners;
     private readonly layerMaskProxy;
     private materialRef;
+    private qualityFactor;
+    private useFastTrailHistory;
     /** @internal **/
     _renderer?: BatchedRenderer;
     set time(time: number);
@@ -198,6 +200,12 @@ export declare class ParticleSystem implements IParticleSystem {
     pause(): void;
     play(): void;
     stop(): void;
+    private refreshTrailHistoryMode;
+    private ensureTrailHistoryCapacity;
+    private resetTrailHistory;
+    private getTrailHistoryCount;
+    private updateFastTrailHistory;
+    setQualityFactor(qualityFactor: number): void;
     private spawn;
     endEmit(): void;
     dispose(): void;

package/dist/types/SpriteBatch.d.ts

@@ -27,6 +27,7 @@ export declare class SpriteBatch extends VFXBatch {
     private quaternion3_;
     private rotationMat_;
     private rotationMat2_;
+    private lastStretchedSpeedFactor;
     update(): void;
     dispose(): void;
 }

package/dist/types/TrailBatch.d.ts

@@ -14,6 +14,7 @@ export declare class TrailBatch extends VFXBatch {
     private nextVB;
     private sideVB;
     private widthVB;
+    private getTrailHistoryCount;
     constructor(settings: VFXBatchSettings, scene: Scene);
     setupBuffers(): void;
     expandBuffers(target: number): void;

package/dist/types/geometryUtil.d.ts

@@ -0,0 +1,2 @@
+/** Sequential 0..N-1 indices for non-indexed triangle-list BufferGeometry (Three.js drawArrays). */
+export declare function ensureTriangleIndices(positions: Float32Array, indices?: Uint32Array | Uint16Array): Uint32Array | Uint16Array;

package/dist/types/shaders/local_particle_physics_vert.glsl.d.ts

@@ -1,2 +1,2 @@
-declare const _default: "\nattribute vec3 position;\nattribute vec2 uv;\nattribute vec3 normal;\nattribute vec3 offset;\nattribute vec4 color;\nattribute vec3 size;\nattribute vec4 rotation;\nattribute float uvTile;\n\nuniform mat4 world;\nuniform mat4 view;\nuniform mat4 projection;\n\n#ifdef UV_TILE\nuniform float tileCountX;\nuniform float tileCountY;\n#endif\n\nvarying vec2 vUV;\nvarying vec4 vColor;\nvarying vec3 vNormal;\nvarying vec3 vWorldPos;\n\n#ifdef SOFT_PARTICLES\nvarying vec4 projPosition;\nvarying float linearDepth;\n#endif\n\nvec3 applyQuaternion(vec3 v, vec4 q) {\n    vec3 qVec = q.xyz;\n    float qW = q.w;\n    vec3 t = 2.0 * cross(qVec, v);\n    return v + qW * t + cross(qVec, t);\n}\n\nvoid main() {\n    vec3 scaledPosition = position * size;\n    vec3 rotatedPosition = applyQuaternion(scaledPosition, rotation);\n    vec3 rotatedNormal = normalize(applyQuaternion(normal, rotation));\n    vec3 localPos = rotatedPosition + offset;\n\n    vec4 worldPos = world * vec4(localPos, 1.0);\n    vec4 viewPos = view * worldPos;\n    gl_Position = projection * viewPos;\n\n    vWorldPos = worldPos.xyz;\n    vNormal = normalize((world * vec4(rotatedNormal, 0.0)).xyz);\n\n#ifdef SOFT_PARTICLES\n    projPosition = gl_Position;\n    linearDepth = -viewPos.z;\n#endif\n\n#ifdef UV_TILE\n    vec2 tc = vec2(tileCountX, tileCountY);\n    float tileU = mod(uvTile, tc.x) / tc.x;\n    float tileV = 1.0 - floor(uvTile / tc.x) / tc.y - 1.0 / tc.y;\n    vUV = uv / tc + vec2(tileU, tileV);\n#else\n    vUV = uv;\n#endif\n\n    vColor = color;\n}\n";
+declare const _default: "\nattribute vec3 position;\nattribute vec2 uv;\nattribute vec3 normal;\nattribute vec3 offset;\nattribute vec4 color;\nattribute vec3 size;\nattribute vec4 rotation;\nattribute float uvTile;\n\nuniform mat4 world;\nuniform mat4 view;\nuniform mat4 projection;\n\n#ifdef UV_TILE\nuniform float tileCountX;\nuniform float tileCountY;\n#endif\n\nvarying vec2 vUV;\nvarying vec4 vColor;\nvarying vec3 vNormal;\nvarying vec3 vWorldPos;\n\n#ifdef TILE_BLEND\nvarying vec2 vUV2;\nvarying float vTileBlend;\n#endif\n\n#ifdef SOFT_PARTICLES\nvarying vec4 projPosition;\nvarying float linearDepth;\n#endif\n\nvec3 applyQuaternion(vec3 v, vec4 q) {\n    vec3 qVec = q.xyz;\n    float qW = q.w;\n    vec3 t = 2.0 * cross(qVec, v);\n    return v + qW * t + cross(qVec, t);\n}\n\nvoid main() {\n    vec3 scaledPosition = position * size;\n    vec3 rotatedPosition = applyQuaternion(scaledPosition, rotation);\n    vec3 rotatedNormal = normalize(applyQuaternion(normal, rotation));\n    vec3 localPos = rotatedPosition + offset;\n\n    vec4 worldPos = world * vec4(localPos, 1.0);\n    vec4 viewPos = view * worldPos;\n    gl_Position = projection * viewPos;\n\n    vWorldPos = worldPos.xyz;\n    vNormal = normalize((world * vec4(rotatedNormal, 0.0)).xyz);\n\n#ifdef SOFT_PARTICLES\n    projPosition = gl_Position;\n    linearDepth = -viewPos.z;\n#endif\n\n#ifdef UV_TILE\n    vec2 tc = vec2(tileCountX, tileCountY);\n    float baseTile = floor(uvTile);\n    float tileU = mod(baseTile, tc.x) / tc.x;\n    float tileV = 1.0 - floor(baseTile / tc.x) / tc.y - 1.0 / tc.y;\n    vUV = uv / tc + vec2(tileU, tileV);\n    #ifdef TILE_BLEND\n        float nextTile = ceil(uvTile);\n        float nextU = mod(nextTile, tc.x) / tc.x;\n        float nextV = 1.0 - floor(nextTile / tc.x) / tc.y - 1.0 / tc.y;\n        vUV2 = uv / tc + vec2(nextU, nextV);\n        vTileBlend = fract(uvTile);\n    #endif\n#else\n    vUV = uv;\n#endif\n\n    vColor = color;\n}\n";
 export default _default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "babylon.quarks",
-  "version": "0.17.2",
+  "version": "0.17.4",
   "description": "A High-Performance Particle System for Babylon.js",
   "type": "module",
   "types": "./dist/types/index.d.ts",
@@ -25,6 +25,7 @@
     "build:js": "cross-env NODE_ENV=production rollup -c",
     "build": "npm run clean && npm run build:types && npm run build:js",
     "test": "jest",
+    "test:coverage": "jest --coverage",
     "prettier": "prettier --write --ignore-unknown **/*.ts"
   },
   "repository": {

package/src/BatchedRenderer.ts

@@ -30,15 +30,44 @@ export interface VFXBatchSettings {
     layerMask: number;
 }
 
+export interface AdaptivePerformanceOptions {
+    targetFrameMs: number;
+    minQuality: number;
+    maxQuality: number;
+    decreaseStep: number;
+    increaseStep: number;
+}
+
+export interface AdaptivePerformanceState extends AdaptivePerformanceOptions {
+    enabled: boolean;
+    currentQuality: number;
+    lastFrameCpuMs: number;
+}
+
 export class BatchedRenderer extends TransformNode {
     batches: Array<VFXBatch> = [];
     systemToBatchIndex: Map<IParticleSystem, number> = new Map<IParticleSystem, number>();
     depthTexture: BaseTexture | null = null;
+    private adaptivePerformanceState: AdaptivePerformanceState = {
+        enabled: false,
+        targetFrameMs: 16.7,
+        minQuality: 0.35,
+        maxQuality: 1,
+        decreaseStep: 0.08,
+        increaseStep: 0.02,
+        currentQuality: 1,
+        lastFrameCpuMs: 0,
+    };
+    private lastAppliedQuality = Number.NaN;
 
     constructor(name: string, scene: Scene) {
         super(name, scene);
     }
 
+    private static clamp(value: number, min: number, max: number): number {
+        return Math.max(min, Math.min(max, value));
+    }
+
     private static equals(a: StoredBatchSettings, b: VFXBatchSettings): boolean {
         return (
             a.materialBlendMode === b.materialBlendMode &&
@@ -62,6 +91,9 @@ export class BatchedRenderer extends TransformNode {
 
     addSystem(system: IParticleSystem) {
         (system as unknown as ParticleSystem)._renderer = this;
+        if (this.adaptivePerformanceState.enabled) {
+            (system as any).setQualityFactor?.(this.adaptivePerformanceState.currentQuality);
+        }
         const settings = (system as unknown as ParticleSystem).getRendererSettings();
         for (let i = 0; i < this.batches.length; i++) {
             if (BatchedRenderer.equals(this.batches[i].settings, settings)) {
@@ -115,13 +147,73 @@ export class BatchedRenderer extends TransformNode {
         }
     }
 
+    configureAdaptivePerformance(options: Partial<AdaptivePerformanceOptions> = {}) {
+        const state = this.adaptivePerformanceState;
+        const minQuality = BatchedRenderer.clamp(options.minQuality ?? state.minQuality, 0.05, 1);
+        const maxQuality = BatchedRenderer.clamp(options.maxQuality ?? state.maxQuality, minQuality, 1);
+        state.targetFrameMs = Math.max(options.targetFrameMs ?? state.targetFrameMs, 0.1);
+        state.minQuality = minQuality;
+        state.maxQuality = maxQuality;
+        state.decreaseStep = Math.max(options.decreaseStep ?? state.decreaseStep, 0.001);
+        state.increaseStep = Math.max(options.increaseStep ?? state.increaseStep, 0.001);
+        state.currentQuality = BatchedRenderer.clamp(state.currentQuality, state.minQuality, state.maxQuality);
+        state.enabled = true;
+        this.lastAppliedQuality = Number.NaN;
+    }
+
+    disableAdaptivePerformance(resetQuality = true) {
+        this.adaptivePerformanceState.enabled = false;
+        if (resetQuality) {
+            this.adaptivePerformanceState.currentQuality = this.adaptivePerformanceState.maxQuality;
+            this.applyAdaptiveQuality();
+        }
+    }
+
+    getAdaptivePerformanceState(): AdaptivePerformanceState {
+        return {...this.adaptivePerformanceState};
+    }
+
+    private applyAdaptiveQuality() {
+        const quality = this.adaptivePerformanceState.currentQuality;
+        if (quality === this.lastAppliedQuality) {
+            return;
+        }
+        for (const ps of this.systemToBatchIndex.keys()) {
+            (ps as any).setQualityFactor?.(quality);
+        }
+        this.lastAppliedQuality = quality;
+    }
+
     update(delta: number) {
-        this.systemToBatchIndex.forEach((_value, ps) => {
+        const adaptiveState = this.adaptivePerformanceState;
+        const frameStart = adaptiveState.enabled ? performance.now() : 0;
+        if (adaptiveState.enabled) {
+            this.applyAdaptiveQuality();
+        }
+        for (const ps of this.systemToBatchIndex.keys()) {
             (ps as any).update(delta);
-        });
+        }
         for (let i = 0; i < this.batches.length; i++) {
             this.batches[i].update();
         }
+        if (!adaptiveState.enabled) {
+            return;
+        }
+
+        adaptiveState.lastFrameCpuMs = performance.now() - frameStart;
+        if (adaptiveState.lastFrameCpuMs > adaptiveState.targetFrameMs) {
+            adaptiveState.currentQuality = BatchedRenderer.clamp(
+                adaptiveState.currentQuality - adaptiveState.decreaseStep,
+                adaptiveState.minQuality,
+                adaptiveState.maxQuality
+            );
+        } else {
+            adaptiveState.currentQuality = BatchedRenderer.clamp(
+                adaptiveState.currentQuality + adaptiveState.increaseStep,
+                adaptiveState.minQuality,
+                adaptiveState.maxQuality
+            );
+        }
     }
 
     dispose(): void {

package/src/ParticleSystem.ts

@@ -41,6 +41,7 @@ import {
 import {ParticleEmitter} from './ParticleEmitter';
 import {RenderMode} from './VFXBatch';
 import {BatchedRenderer, VFXBatchSettings} from './BatchedRenderer';
+import {ensureTriangleIndices} from './geometryUtil';
 
 export interface BurstParameters {
     time: number;
@@ -206,6 +207,8 @@ export class ParticleSystem implements IParticleSystem {
     private listeners: {[event: string]: Array<(event: ParticleSystemEvent) => void>} = {};
     private readonly layerMaskProxy: {mask: number};
     private materialRef: any = null;
+    private qualityFactor = 1;
+    private useFastTrailHistory = true;
     /** @internal **/
     _renderer?: BatchedRenderer;
 
@@ -456,6 +459,7 @@ export class ParticleSystem implements IParticleSystem {
 
         this.emissionBursts.forEach((burst) => burst.count.startGen(this.memory));
         this.emissionOverDistance.startGen(this.memory);
+        this.refreshTrailHistoryMode();
 
         this.emitEnded = false;
         this.markForDestroy = false;
@@ -474,6 +478,7 @@ export class ParticleSystem implements IParticleSystem {
             layerMask?: number;
         } = {}
     ) {
+        /* istanbul ignore if -- rendererSettings is always assigned in the constructor before any code path can call this private method */
         if (!this.rendererSettings) {
             return;
         }
@@ -534,17 +539,93 @@ export class ParticleSystem implements IParticleSystem {
     play() { this.paused = false; }
     stop() { this.restart(); this.pause(); }
 
+    private refreshTrailHistoryMode() {
+        this.useFastTrailHistory = !this.behaviors.some((behavior) => (behavior as any).type === 'WidthOverLength');
+    }
+
+    private ensureTrailHistoryCapacity(particle: TrailParticle, capacity: number) {
+        const trailAny = particle as any;
+        if (trailAny._trailHistoryCapacity === capacity && trailAny._trailHistoryPositions) {
+            return;
+        }
+        trailAny._trailHistoryCapacity = capacity;
+        trailAny._trailHistoryPositions = new Float32Array(capacity * 3);
+        trailAny._trailHistorySizes = new Float32Array(capacity);
+        trailAny._trailHistoryColors = new Float32Array(capacity * 4);
+        trailAny._trailHistoryHead = 0;
+        trailAny._trailHistoryCount = 0;
+    }
+
+    private resetTrailHistory(particle: TrailParticle) {
+        const trailAny = particle as any;
+        trailAny._trailHistoryHead = 0;
+        trailAny._trailHistoryCount = 0;
+    }
+
+    private getTrailHistoryCount(particle: TrailParticle): number {
+        const trailAny = particle as any;
+        const fastHistoryCount = trailAny._trailHistoryCount;
+        if (typeof fastHistoryCount === 'number') {
+            return fastHistoryCount;
+        }
+        return particle.previous.length;
+    }
+
+    private updateFastTrailHistory(particle: TrailParticle) {
+        const trailAny = particle as any;
+        const capacity = Math.max(1, Math.ceil(particle.length));
+        this.ensureTrailHistoryCapacity(particle, capacity);
+        let head = trailAny._trailHistoryHead as number;
+        let count = trailAny._trailHistoryCount as number;
+        const positions = trailAny._trailHistoryPositions as Float32Array;
+        const sizes = trailAny._trailHistorySizes as Float32Array;
+        const colors = trailAny._trailHistoryColors as Float32Array;
+
+        if (particle.age <= particle.life) {
+            const posIndex = head * 3;
+            positions[posIndex] = particle.position.x;
+            positions[posIndex + 1] = particle.position.y;
+            positions[posIndex + 2] = particle.position.z;
+            sizes[head] = particle.size.x;
+            const colorIndex = head * 4;
+            colors[colorIndex] = particle.color.x;
+            colors[colorIndex + 1] = particle.color.y;
+            colors[colorIndex + 2] = particle.color.z;
+            colors[colorIndex + 3] = particle.color.w;
+            head = (head + 1) % capacity;
+            if (count < capacity) {
+                count++;
+            }
+        } else if (count > 0) {
+            count--;
+        }
+
+        trailAny._trailHistoryHead = head;
+        trailAny._trailHistoryCount = count;
+    }
+
+    setQualityFactor(qualityFactor: number) {
+        this.qualityFactor = Math.max(0.1, Math.min(1, qualityFactor));
+    }
+
     private spawn(count: number, emissionState: EmissionState, matrix: Matrix4) {
         tempQ.setFromRotationMatrix(matrix);
         const translation = tempV;
         const scale = tempV2;
         matrix.decompose(translation, tempQ, scale);
+        const behaviors = this.behaviors;
+        const behaviorCount = behaviors.length;
+        const renderMode = this.rendererSettings.renderMode;
+        const isTrailMode = renderMode === RenderMode.Trail;
+        const timeRatio = emissionState.time / this.duration;
+        const trailSettings = isTrailMode ? (this.rendererEmitterSettings as TrailSettings) : undefined;
+        const followLocalOrigin = Boolean(trailSettings?.followLocalOrigin);
 
         for (let i = 0; i < count; i++) {
             emissionState.burstParticleIndex = i;
             this.particleNum++;
-            while (this.particles.length < this.particleNum) {
-                if (this.rendererSettings.renderMode === RenderMode.Trail) {
+            if (this.particles.length < this.particleNum) {
+                if (isTrailMode) {
                     this.particles.push(new TrailParticle());
                 } else {
                     this.particles.push(new SpriteParticle());
@@ -557,15 +638,15 @@ export class ParticleSystem implements IParticleSystem {
             this.startColor.genColor(particle.memory, particle.startColor, this.emissionState.time);
             particle.color.copy(particle.startColor);
             this.startSpeed.startGen(particle.memory);
-            particle.startSpeed = this.startSpeed.genValue(particle.memory, emissionState.time / this.duration);
+            particle.startSpeed = this.startSpeed.genValue(particle.memory, timeRatio);
             this.startLife.startGen(particle.memory);
-            particle.life = this.startLife.genValue(particle.memory, emissionState.time / this.duration);
+            particle.life = this.startLife.genValue(particle.memory, timeRatio);
             particle.age = 0;
             this.startSize.startGen(particle.memory);
             if (this.startSize.type === 'vec3function') {
-                (this.startSize as Vector3Generator).genValue(particle.memory, particle.startSize, emissionState.time / this.duration);
+                (this.startSize as Vector3Generator).genValue(particle.memory, particle.startSize, timeRatio);
             } else {
-                const size = (this.startSize as FunctionValueGenerator).genValue(particle.memory, emissionState.time / this.duration);
+                const size = (this.startSize as FunctionValueGenerator).genValue(particle.memory, timeRatio);
                 particle.startSize.set(size, size, size);
             }
             this.startTileIndex.startGen(particle.memory);
@@ -581,33 +662,40 @@ export class ParticleSystem implements IParticleSystem {
             ) {
                 const sprite = particle as SpriteParticle;
                 this.startRotation.startGen(particle.memory);
-                if (this.rendererSettings.renderMode === RenderMode.Mesh) {
+                if (renderMode === RenderMode.Mesh) {
                     if (!(sprite.rotation instanceof Quaternion)) {
                         sprite.rotation = new Quaternion();
                     }
                     if (this.startRotation.type === 'rotation') {
-                        this.startRotation.genValue(particle.memory, sprite.rotation as Quaternion, 1, emissionState.time / this.duration);
+                        this.startRotation.genValue(particle.memory, sprite.rotation as Quaternion, 1, timeRatio);
                     } else {
-                        (sprite.rotation as Quaternion).setFromAxisAngle(UP, this.startRotation.genValue(sprite.memory, emissionState.time / this.duration));
+                        (sprite.rotation as Quaternion).setFromAxisAngle(UP, this.startRotation.genValue(sprite.memory, timeRatio));
                     }
                 } else {
                     if (this.startRotation.type === 'rotation') {
                         sprite.rotation = 0;
                     } else {
-                        sprite.rotation = this.startRotation.genValue(sprite.memory, emissionState.time / this.duration);
+                        sprite.rotation = this.startRotation.genValue(sprite.memory, timeRatio);
                     }
                 }
-            } else if (this.rendererSettings.renderMode === RenderMode.Trail) {
+            } else if (isTrailMode && trailSettings) {
                 const trail = particle as TrailParticle;
-                (this.rendererEmitterSettings as TrailSettings).startLength.startGen(trail.memory);
-                trail.length = (this.rendererEmitterSettings as TrailSettings).startLength.genValue(trail.memory, emissionState.time / this.duration);
+                trailSettings.startLength.startGen(trail.memory);
+                trail.length = trailSettings.startLength.genValue(trail.memory, timeRatio);
+                if (this.useFastTrailHistory) {
+                    this.ensureTrailHistoryCapacity(trail, Math.max(1, Math.ceil(trail.length)));
+                    this.resetTrailHistory(trail);
+                }
             }
 
             this.emitterShape.initialize(particle, emissionState);
 
-            if (this.rendererSettings.renderMode === RenderMode.Trail && (this.rendererEmitterSettings as TrailSettings).followLocalOrigin) {
+            if (isTrailMode && followLocalOrigin) {
                 const trail = particle as TrailParticle;
-                trail.localPosition = new Vector3().copy(trail.position);
+                if (!trail.localPosition) {
+                    trail.localPosition = new Vector3();
+                }
+                trail.localPosition.copy(trail.position);
             }
 
             if (this.worldSpace) {
@@ -624,8 +712,8 @@ export class ParticleSystem implements IParticleSystem {
                 }
             }
 
-            for (let j = 0; j < this.behaviors.length; j++) {
-                this.behaviors[j].initialize(particle, this);
+            for (let j = 0; j < behaviorCount; j++) {
+                behaviors[j].initialize(particle, this);
             }
         }
     }
@@ -697,49 +785,66 @@ export class ParticleSystem implements IParticleSystem {
             this.emit(delta, this.emissionState, this.emitter.matrixWorld);
         }
 
+        const particles = this.particles;
+        const behaviorCount = this.behaviors.length;
+        const particleCount = this.particleNum;
         this.emitterShape.update(this, delta);
-        for (let j = 0; j < this.behaviors.length; j++) {
-            this.behaviors[j].frameUpdate(delta);
-            for (let i = 0; i < this.particleNum; i++) {
-                if (!this.particles[i].died) {
-                    this.behaviors[j].update(this.particles[i], delta);
+        for (let j = 0; j < behaviorCount; j++) {
+            const behavior = this.behaviors[j];
+            behavior.frameUpdate(delta);
+            for (let i = 0; i < particleCount; i++) {
+                const particle = particles[i];
+                if (!particle.died) {
+                    behavior.update(particle, delta);
                 }
             }
         }
 
-        for (let i = 0; i < this.particleNum; i++) {
-            if (
-                (this.rendererEmitterSettings as TrailSettings).followLocalOrigin &&
-                (this.particles[i] as TrailParticle).localPosition
-            ) {
-                this.particles[i].position.copy((this.particles[i] as TrailParticle).localPosition!);
-                if (this.particles[i].parentMatrix) {
-                    this.particles[i].position.applyMatrix4(this.particles[i].parentMatrix!);
+        const followLocalOrigin =
+            this.rendererSettings.renderMode === RenderMode.Trail &&
+            (this.rendererEmitterSettings as TrailSettings).followLocalOrigin;
+        const emitterMatrix = this.emitter.matrixWorld;
+        for (let i = 0; i < particleCount; i++) {
+            const particle = particles[i];
+            if (followLocalOrigin && (particle as TrailParticle).localPosition) {
+                particle.position.copy((particle as TrailParticle).localPosition!);
+                if (particle.parentMatrix) {
+                    particle.position.applyMatrix4(particle.parentMatrix);
                 } else {
-                    this.particles[i].position.applyMatrix4(this.emitter.matrixWorld);
+                    particle.position.applyMatrix4(emitterMatrix);
                 }
             } else {
-                this.particles[i].position.addScaledVector(this.particles[i].velocity, delta * this.particles[i].speedModifier);
+                particle.position.addScaledVector(particle.velocity, delta * particle.speedModifier);
             }
-            this.particles[i].age += delta;
+            particle.age += delta;
         }
 
         if (this.rendererSettings.renderMode === RenderMode.Trail) {
-            for (let i = 0; i < this.particleNum; i++) {
-                (this.particles[i] as TrailParticle).update();
+            for (let i = 0; i < particleCount; i++) {
+                const trailParticle = particles[i] as TrailParticle;
+                if (this.useFastTrailHistory) {
+                    this.updateFastTrailHistory(trailParticle);
+                } else {
+                    trailParticle.update();
+                }
             }
         }
 
-        for (let i = 0; i < this.particleNum; i++) {
-            const particle = this.particles[i];
-            if (particle.died && (!(particle instanceof TrailParticle) || particle.previous.length === 0)) {
-                this.particles[i] = this.particles[this.particleNum - 1];
-                this.particles[this.particleNum - 1] = particle;
-                this.particleNum--;
+        let liveParticleCount = this.particleNum;
+        for (let i = 0; i < liveParticleCount; i++) {
+            const particle = particles[i];
+            if (
+                particle.died &&
+                (!(particle instanceof TrailParticle) || this.getTrailHistoryCount(particle as TrailParticle) === 0)
+            ) {
+                particles[i] = particles[liveParticleCount - 1];
+                particles[liveParticleCount - 1] = particle;
+                liveParticleCount--;
                 i--;
                 this.fire({type: 'particleDied', particleSystem: this, particle: particle});
             }
         }
+        this.particleNum = liveParticleCount;
     }
 
     emit(delta: number, emissionState: EmissionState, emitterMatrix: Matrix4) {
@@ -756,17 +861,22 @@ export class ParticleSystem implements IParticleSystem {
         }
 
         this.normalMatrix.getNormalMatrix(emitterMatrix);
+        const emissionBursts = this.emissionBursts;
+        const emissionBurstCount = emissionBursts.length;
+        const qualityFactor = this.qualityFactor;
 
         const totalSpawn = Math.ceil(emissionState.waitEmiting);
         this.spawn(totalSpawn, emissionState, emitterMatrix);
         emissionState.waitEmiting -= totalSpawn;
 
         while (
-            emissionState.burstIndex < this.emissionBursts.length &&
-            this.emissionBursts[emissionState.burstIndex].time <= emissionState.time
+            emissionState.burstIndex < emissionBurstCount &&
+            emissionBursts[emissionState.burstIndex].time <= emissionState.time
         ) {
-            if (Math.random() < this.emissionBursts[emissionState.burstIndex].probability) {
-                const count = this.emissionBursts[emissionState.burstIndex].count.genValue(this.memory, this.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);
@@ -776,12 +886,14 @@ export class ParticleSystem implements IParticleSystem {
         }
 
         if (!this.emitEnded) {
-            emissionState.waitEmiting += delta * this.emissionOverTime.genValue(this.memory, emissionState.time / this.duration);
+            const timeRatio = emissionState.time / this.duration;
+            emissionState.waitEmiting += delta * this.emissionOverTime.genValue(this.memory, timeRatio) * qualityFactor;
 
-            if (emissionState.previousWorldPos != undefined) {
+            const previousWorldPos = emissionState.previousWorldPos;
+            if (previousWorldPos !== undefined) {
                 this.temp.set(emitterMatrix.elements[12], emitterMatrix.elements[13], emitterMatrix.elements[14]);
-                emissionState.travelDistance += emissionState.previousWorldPos.distanceTo(this.temp);
-                const emitPerMeter = this.emissionOverDistance.genValue(this.memory, emissionState.time / this.duration);
+                emissionState.travelDistance += previousWorldPos.distanceTo(this.temp);
+                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;
@@ -1031,13 +1143,18 @@ export class ParticleSystem implements IParticleSystem {
         uvs?: Float32Array;
         normals?: Float32Array;
     } {
-        if (entry?.positions && entry?.indices) {
+        if (entry?.positions) {
+            const positions =
+                entry.positions instanceof Float32Array ? entry.positions : new Float32Array(entry.positions);
+            const rawIndices =
+                entry.indices instanceof Uint16Array || entry.indices instanceof Uint32Array
+                    ? entry.indices
+                    : entry.indices
+                      ? new Uint32Array(entry.indices)
+                      : undefined;
             return {
-                positions: entry.positions instanceof Float32Array ? entry.positions : new Float32Array(entry.positions),
-                indices:
-                    entry.indices instanceof Uint16Array || entry.indices instanceof Uint32Array
-                        ? entry.indices
-                        : new Uint32Array(entry.indices),
+                positions,
+                indices: ensureTriangleIndices(positions, rawIndices),
                 uvs: entry.uvs
                     ? entry.uvs instanceof Float32Array
                         ? entry.uvs
@@ -1052,11 +1169,16 @@ export class ParticleSystem implements IParticleSystem {
         }
 
         const data = entry?.data ?? entry;
-        if (data?.attributes?.position?.array && data?.index?.array) {
-            const indexType = data.index.type === 'Uint16Array' ? Uint16Array : Uint32Array;
+        if (data?.attributes?.position?.array) {
+            const positions = new Float32Array(data.attributes.position.array);
+            let indices: Uint32Array | Uint16Array | undefined;
+            if (data.index?.array) {
+                const indexType = data.index.type === 'Uint16Array' ? Uint16Array : Uint32Array;
+                indices = new indexType(data.index.array);
+            }
             return {
-                positions: new Float32Array(data.attributes.position.array),
-                indices: new indexType(data.index.array),
+                positions,
+                indices: ensureTriangleIndices(positions, indices),
                 uvs: data.attributes.uv?.array ? new Float32Array(data.attributes.uv.array) : undefined,
                 normals: data.attributes.normal?.array ? new Float32Array(data.attributes.normal.array) : undefined,
             };
@@ -1071,6 +1193,7 @@ export class ParticleSystem implements IParticleSystem {
 
     addBehavior(behavior: Behavior) {
         this.behaviors.push(behavior);
+        this.refreshTrailHistoryMode();
     }
 
     getRendererSettings(): VFXBatchSettings {

package/src/QuarksLoader.ts

@@ -13,6 +13,7 @@ import {
 import {ParticleSystem} from './ParticleSystem';
 import {ParticleEmitter} from './ParticleEmitter';
 import {QuarksPrefab} from './QuarksPrefab';
+import {ensureTriangleIndices} from './geometryUtil';
 
 export interface QuarksLoaderOptions {
     baseUrl?: string;
@@ -219,6 +220,8 @@ export class QuarksLoader {
             }
         }
 
+        indices = ensureTriangleIndices(positions, indices);
+
         return {positions, indices, uvs, normals};
     }