@driftengine/physics 4.9.0 → 4.11.0

package/dist/clothControl.d.ts

@@ -42,7 +42,8 @@ export declare class ClothControl {
     reset(): void;
     /**
      * Advance by `dt` seconds of the caller's time, in whole fixed steps; how many ran. The remainder
-     * is kept for the next call, and `alpha` says how far into the next step it reaches.
+     * is kept for the next call, and `alpha` says how far into the next step it reaches. At most
+     * `maxSteps` run, reaching the latest pose all the same; the whole steps past them are dropped.
      */
     advance(dt: number): number;
     /** How far the time handed to `advance` reaches into the next step, 0 to 1. */

package/dist/clothControl.js

@@ -63,13 +63,18 @@ export class ClothControl {
     }
     /**
      * Advance by `dt` seconds of the caller's time, in whole fixed steps; how many ran. The remainder
-     * is kept for the next call, and `alpha` says how far into the next step it reaches.
+     * is kept for the next call, and `alpha` says how far into the next step it reaches. At most
+     * `maxSteps` run, reaching the latest pose all the same; the whole steps past them are dropped.
      */
     advance(dt) {
         this.accumulator += dt;
         const step = this.parameters.step;
         /* A millionth of a step of slack, so 1/30 is two steps of 1/60 and not one and a remainder. */
-        const steps = Math.floor((this.accumulator + step * 1e-6) / step);
+        const whole = Math.floor((this.accumulator + step * 1e-6) / step);
+        const steps = Math.min(whole, this.parameters.maxSteps);
+        /* Dropped in one subtraction; the steps that run take theirs one at a time, as they always did. */
+        if (whole > steps)
+            this.accumulator -= (whole - steps) * step;
         for (let k = 0; k < steps; k++) {
             this.accumulator -= step;
             this.stepAt((k + 1) / steps);

package/dist/skinnedClothSetup.d.ts

@@ -77,6 +77,13 @@ export interface ClothCollider {
 export interface SkinnedClothParameters {
     /** The fixed step, in seconds. The solver runs whole steps whatever the frame. Default 1/60. */
     readonly step?: number;
+    /**
+     * The most whole steps one `advance` runs; the time past them is dropped, not owed to the next
+     * frame. Default none, so `advance(1)` is a second of cloth. A caller handing it each frame's time
+     * wants two to four: unbounded, a slow frame's steps make the next frame slower, which hands it
+     * more time again. What it gives up: past the cap the cloth runs slower than the clock.
+     */
+    readonly maxSteps?: number;
     /** Substeps a step. Default 1. */
     readonly substeps?: number;
     /** Constraint passes a substep. Default 4. */
@@ -140,6 +147,7 @@ export interface SkinnedClothSetup {
 /** The parameters with every default filled in. */
 export interface ResolvedClothParameters {
     readonly step: number;
+    readonly maxSteps: number;
     readonly substeps: number;
     readonly iterations: number;
     readonly gravity: readonly [number, number, number];

package/dist/skinnedClothSetup.js

@@ -14,6 +14,7 @@
 export function resolveClothParameters(parameters) {
     return {
         step: parameters.step ?? 1 / 60,
+        maxSteps: Math.max(1, Math.floor(parameters.maxSteps ?? Infinity)),
         substeps: Math.max(1, Math.floor(parameters.substeps ?? 1)),
         iterations: Math.max(1, Math.floor(parameters.iterations ?? 4)),
         gravity: parameters.gravity ?? [0, -9.81, 0],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@driftengine/physics",
-  "version": "4.9.0",
+  "version": "4.11.0",
   "description": "Collision shapes, spatial queries and swept kinematic collision",
   "license": "Apache-2.0",
   "type": "module",

package/src/clothControl.ts

@@ -86,13 +86,17 @@ export class ClothControl {
 
   /**
    * Advance by `dt` seconds of the caller's time, in whole fixed steps; how many ran. The remainder
-   * is kept for the next call, and `alpha` says how far into the next step it reaches.
+   * is kept for the next call, and `alpha` says how far into the next step it reaches. At most
+   * `maxSteps` run, reaching the latest pose all the same; the whole steps past them are dropped.
    */
   advance(dt: number): number {
     this.accumulator += dt;
     const step = this.parameters.step;
     /* A millionth of a step of slack, so 1/30 is two steps of 1/60 and not one and a remainder. */
-    const steps = Math.floor((this.accumulator + step * 1e-6) / step);
+    const whole = Math.floor((this.accumulator + step * 1e-6) / step);
+    const steps = Math.min(whole, this.parameters.maxSteps);
+    /* Dropped in one subtraction; the steps that run take theirs one at a time, as they always did. */
+    if (whole > steps) this.accumulator -= (whole - steps) * step;
     for (let k = 0; k < steps; k++) {
       this.accumulator -= step;
       this.stepAt((k + 1) / steps);

package/src/skinnedClothSetup.ts

@@ -83,6 +83,13 @@ export interface ClothCollider {
 export interface SkinnedClothParameters {
   /** The fixed step, in seconds. The solver runs whole steps whatever the frame. Default 1/60. */
   readonly step?: number;
+  /**
+   * The most whole steps one `advance` runs; the time past them is dropped, not owed to the next
+   * frame. Default none, so `advance(1)` is a second of cloth. A caller handing it each frame's time
+   * wants two to four: unbounded, a slow frame's steps make the next frame slower, which hands it
+   * more time again. What it gives up: past the cap the cloth runs slower than the clock.
+   */
+  readonly maxSteps?: number;
   /** Substeps a step. Default 1. */
   readonly substeps?: number;
   /** Constraint passes a substep. Default 4. */
@@ -148,6 +155,7 @@ export interface SkinnedClothSetup {
 /** The parameters with every default filled in. */
 export interface ResolvedClothParameters {
   readonly step: number;
+  readonly maxSteps: number;
   readonly substeps: number;
   readonly iterations: number;
   readonly gravity: readonly [number, number, number];
@@ -169,6 +177,7 @@ export function resolveClothParameters(
 ): ResolvedClothParameters {
   return {
     step: parameters.step ?? 1 / 60,
+    maxSteps: Math.max(1, Math.floor(parameters.maxSteps ?? Infinity)),
     substeps: Math.max(1, Math.floor(parameters.substeps ?? 1)),
     iterations: Math.max(1, Math.floor(parameters.iterations ?? 4)),
     gravity: parameters.gravity ?? [0, -9.81, 0],