@vectojs/core 1.11.2 → 1.11.3

package/dist/index.js

@@ -179,6 +179,37 @@ var ComputeParticleEntity = (_class = class extends _chunk2Z23LTH3js.Entity {
   }
   render(_r) {
   }
+  /**
+   * True while any live particle still has a visually meaningful velocity or
+   * sits meaningfully away from its spring target.
+   *
+   * The actual per-frame simulation (WebGPU compute pass / {@link updateCPU})
+   * runs through a dedicated Scene-level pre-pass outside the normal
+   * render-tree walk, but this entity is still a normal tree member that
+   * walk visits — without this override, the base `Entity.hasPendingAnimations()`
+   * (always `false`) is what Scene sees, so `renderMode: 'always'`'s idle
+   * auto-throttle drops the WHOLE scene to ~2fps the instant nothing else in
+   * the tree is animating, even while thousands of particles are visibly
+   * drifting or spring-settling. A spring+damping system asymptotically
+   * approaches zero velocity but never reaches it exactly, so this checks
+   * against a small epsilon rather than `!== 0` — otherwise this would
+   * always return `true` and defeat the idle throttle entirely.
+   */
+  hasPendingAnimations() {
+    const EPS_VELOCITY = 0.5;
+    const EPS_DISTANCE = 0.5;
+    for (let i = 0; i < this.maxParticles; i++) {
+      const idx = i * PARTICLE_STRIDE_FLOATS;
+      if (this.particleData[idx + PARTICLE_OFFSET_LIFE] === 0) continue;
+      const vx = this.particleData[idx + PARTICLE_OFFSET_VELOCITY_X];
+      const vy = this.particleData[idx + PARTICLE_OFFSET_VELOCITY_Y];
+      if (vx * vx + vy * vy > EPS_VELOCITY * EPS_VELOCITY) return true;
+      const dx = this.particleData[idx + PARTICLE_OFFSET_POSITION_X] - this.particleData[idx + PARTICLE_OFFSET_ORIGIN_X];
+      const dy = this.particleData[idx + PARTICLE_OFFSET_POSITION_Y] - this.particleData[idx + PARTICLE_OFFSET_ORIGIN_Y];
+      if (dx * dx + dy * dy > EPS_DISTANCE * EPS_DISTANCE) return true;
+    }
+    return this.pendingExplosion !== null;
+  }
   /**
    * Updates particle simulation on the CPU.
    * Handles spring forces, mouse repulsion, explosion impulses, velocity capping, and bounds bouncing/clamping.

package/dist/index.mjs

@@ -179,6 +179,37 @@ var ComputeParticleEntity = class extends Entity {
   }
   render(_r) {
   }
+  /**
+   * True while any live particle still has a visually meaningful velocity or
+   * sits meaningfully away from its spring target.
+   *
+   * The actual per-frame simulation (WebGPU compute pass / {@link updateCPU})
+   * runs through a dedicated Scene-level pre-pass outside the normal
+   * render-tree walk, but this entity is still a normal tree member that
+   * walk visits — without this override, the base `Entity.hasPendingAnimations()`
+   * (always `false`) is what Scene sees, so `renderMode: 'always'`'s idle
+   * auto-throttle drops the WHOLE scene to ~2fps the instant nothing else in
+   * the tree is animating, even while thousands of particles are visibly
+   * drifting or spring-settling. A spring+damping system asymptotically
+   * approaches zero velocity but never reaches it exactly, so this checks
+   * against a small epsilon rather than `!== 0` — otherwise this would
+   * always return `true` and defeat the idle throttle entirely.
+   */
+  hasPendingAnimations() {
+    const EPS_VELOCITY = 0.5;
+    const EPS_DISTANCE = 0.5;
+    for (let i = 0; i < this.maxParticles; i++) {
+      const idx = i * PARTICLE_STRIDE_FLOATS;
+      if (this.particleData[idx + PARTICLE_OFFSET_LIFE] === 0) continue;
+      const vx = this.particleData[idx + PARTICLE_OFFSET_VELOCITY_X];
+      const vy = this.particleData[idx + PARTICLE_OFFSET_VELOCITY_Y];
+      if (vx * vx + vy * vy > EPS_VELOCITY * EPS_VELOCITY) return true;
+      const dx = this.particleData[idx + PARTICLE_OFFSET_POSITION_X] - this.particleData[idx + PARTICLE_OFFSET_ORIGIN_X];
+      const dy = this.particleData[idx + PARTICLE_OFFSET_POSITION_Y] - this.particleData[idx + PARTICLE_OFFSET_ORIGIN_Y];
+      if (dx * dx + dy * dy > EPS_DISTANCE * EPS_DISTANCE) return true;
+    }
+    return this.pendingExplosion !== null;
+  }
   /**
    * Updates particle simulation on the CPU.
    * Handles spring forces, mouse repulsion, explosion impulses, velocity capping, and bounds bouncing/clamping.

package/dist/tree/ComputeParticleEntity.d.ts

@@ -99,6 +99,23 @@ export declare class ComputeParticleEntity extends Entity {
     triggerExplosion(x: number, y: number, force: number): void;
     isPointInside(_x: number, _y: number): boolean;
     render(_r: IRenderer): void;
+    /**
+     * True while any live particle still has a visually meaningful velocity or
+     * sits meaningfully away from its spring target.
+     *
+     * The actual per-frame simulation (WebGPU compute pass / {@link updateCPU})
+     * runs through a dedicated Scene-level pre-pass outside the normal
+     * render-tree walk, but this entity is still a normal tree member that
+     * walk visits — without this override, the base `Entity.hasPendingAnimations()`
+     * (always `false`) is what Scene sees, so `renderMode: 'always'`'s idle
+     * auto-throttle drops the WHOLE scene to ~2fps the instant nothing else in
+     * the tree is animating, even while thousands of particles are visibly
+     * drifting or spring-settling. A spring+damping system asymptotically
+     * approaches zero velocity but never reaches it exactly, so this checks
+     * against a small epsilon rather than `!== 0` — otherwise this would
+     * always return `true` and defeat the idle throttle entirely.
+     */
+    hasPendingAnimations(): boolean;
     /**
      * Updates particle simulation on the CPU.
      * Handles spring forces, mouse repulsion, explosion impulses, velocity capping, and bounds bouncing/clamping.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vectojs/core",
-  "version": "1.11.2",
+  "version": "1.11.3",
   "publishConfig": {
     "access": "public"
   },