babylon.quarks 0.17.3 → 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.3",
+  "version": "0.17.4",
   "description": "A High-Performance Particle System for Babylon.js",
   "type": "module",
   "types": "./dist/types/index.d.ts",

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;
@@ -1142,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
@@ -1163,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,
             };

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};
     }
 

package/src/geometryUtil.ts

@@ -0,0 +1,15 @@
+/** Sequential 0..N-1 indices for non-indexed triangle-list BufferGeometry (Three.js drawArrays). */
+export function ensureTriangleIndices(
+    positions: Float32Array,
+    indices?: Uint32Array | Uint16Array
+): Uint32Array | Uint16Array {
+    if (indices && indices.length > 0) {
+        return indices;
+    }
+    const vertexCount = positions.length / 3;
+    const out = new Uint32Array(vertexCount);
+    for (let i = 0; i < vertexCount; i++) {
+        out[i] = i;
+    }
+    return out;
+}