@thi.ng/timestep 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2023-04-19T09:28:07Z
+- **Last updated**: 2023-04-28T17:22:36Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.
@@ -9,6 +9,19 @@ See [Conventional Commits](https://conventionalcommits.org/) for commit guidelin
 **Note:** Unlisted _patch_ versions only involve non-code or otherwise excluded changes
 and/or version bumps of transitive dependencies.
 
+## [0.2.0](https://github.com/thi-ng/umbrella/tree/@thi.ng/timestep@0.2.0) (2023-04-28)
+
+#### 🚀 Features
+
+- add INotify support, add fixed time field ([b68c0c6](https://github.com/thi-ng/umbrella/commit/b68c0c6))
+- add integrateAll/interpolateAll() helpers ([71087cf](https://github.com/thi-ng/umbrella/commit/71087cf))
+
+### [0.1.1](https://github.com/thi-ng/umbrella/tree/@thi.ng/timestep@0.1.1) (2023-04-25)
+
+#### ♻️ Refactoring
+
+- update AState, expose prev & curr ([8d5356b](https://github.com/thi-ng/umbrella/commit/8d5356b))
+
 ## [0.1.0](https://github.com/thi-ng/umbrella/tree/@thi.ng/timestep@0.1.0) (2023-04-19)
 
 #### 🚀 Features

package/api.d.ts

@@ -36,6 +36,10 @@ export interface IUpdatable {
     interpolate(alpha: number, ctx: ReadonlyTimeStep): void;
 }
 export interface ReadonlyTimeStep {
+    /**
+     * Simulation time since start (resolution {@link ReadonlyTimeStep.dt}).
+     */
+    readonly t: number;
     /**
      * Configured timestep (in seconds)
      */
@@ -88,4 +92,14 @@ export interface TimeStepOpts {
 }
 export type StateUpdate<T> = (curr: T, dt: number, ctx: ReadonlyTimeStep) => T;
 export type StateInterpolation<T> = (prev: T, curr: T, alpha: number, ctx: ReadonlyTimeStep) => T;
+/**
+ * Event ID for {@link TimeStep.addListener} to be notified of individual
+ * {@link IUpdatable.integrate} iterations.
+ */
+export declare const EVENT_INTEGRATE = "integrate";
+/**
+ * Event ID for {@link TimeStep.addListener} to be notified of calls to
+ * {@link TimeStep.update} (triggered at the very end of a frame update).
+ */
+export declare const EVENT_FRAME = "frame";
 //# sourceMappingURL=api.d.ts.map

package/api.js

@@ -1 +1,10 @@
-export {};
+/**
+ * Event ID for {@link TimeStep.addListener} to be notified of individual
+ * {@link IUpdatable.integrate} iterations.
+ */
+export const EVENT_INTEGRATE = "integrate";
+/**
+ * Event ID for {@link TimeStep.addListener} to be notified of calls to
+ * {@link TimeStep.update} (triggered at the very end of a frame update).
+ */
+export const EVENT_FRAME = "frame";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/timestep",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Deterministic fixed timestep simulation updates with state interpolation",
   "type": "module",
   "module": "./index.js",
@@ -35,8 +35,8 @@
   },
   "dependencies": {
     "@thi.ng/api": "^8.8.0",
-    "@thi.ng/math": "^5.4.8",
-    "@thi.ng/vectors": "^7.6.12"
+    "@thi.ng/math": "^5.4.9",
+    "@thi.ng/vectors": "^7.6.13"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.34.4",
@@ -88,5 +88,5 @@
     "status": "alpha",
     "year": 2023
   },
-  "gitHead": "3a56bc490f1e68754762a503d06327b5b34ff7eb\n"
+  "gitHead": "e71e2d061ac0a754ce4899bb59208afb8b3d94b2\n"
 }

package/state.d.ts

@@ -11,8 +11,8 @@ export declare abstract class AState<T> implements IDeref<T>, IUpdatable {
     value: T;
     update: StateUpdate<T>;
     mix: StateInterpolation<T>;
-    protected prev: T;
-    protected curr: T;
+    curr: T;
+    prev: T;
     constructor(value: T, update: StateUpdate<T>, mix: StateInterpolation<T>);
     deref(): T;
     integrate(dt: number, ctx: ReadonlyTimeStep): void;

package/timestep.d.ts

@@ -1,14 +1,21 @@
-import type { IUpdatable, TimeStepOpts } from "./api.js";
-export declare class TimeStep {
-    current: number;
+import { type Event, type INotify, type Listener } from "@thi.ng/api";
+import { type IUpdatable, type ReadonlyTimeStep, type TimeStepOpts } from "./api.js";
+export declare class TimeStep implements INotify {
     start: number;
     dt: number;
     maxFrameTime: number;
     scale: number;
+    t: number;
+    current: number;
     accumulator: number;
     frame: number;
     updates: number;
+    protected __eventIntegrate: Event;
+    protected __eventFrame: Event;
     constructor(opts?: Partial<TimeStepOpts>);
+    addListener(id: string, fn: Listener, scope?: any): boolean;
+    removeListener(id: string, fn: Listener, scope?: any): boolean;
+    notify(event: Event): boolean;
     /**
      * Updates internal time to given new time `now` (in seconds) and performs
      * the required number of fixed timesteps to integrate and interpolate the
@@ -27,4 +34,20 @@ export declare class TimeStep {
     update(now: number, items: IUpdatable[], interpolate?: boolean): void;
 }
 export declare const defTimeStep: (opts?: Partial<TimeStepOpts>) => TimeStep;
+/**
+ * Calls {@link IUpdatable.integrate} for all given items (in given order).
+ *
+ * @param dt
+ * @param ctx
+ * @param items
+ */
+export declare const integrateAll: (dt: number, ctx: ReadonlyTimeStep, ...items: IUpdatable[]) => void;
+/**
+ * Calls {@link IUpdatable.interpolate} for all given items (in given order).
+ *
+ * @param dt
+ * @param ctx
+ * @param items
+ */
+export declare const interpolateAll: (alpha: number, ctx: ReadonlyTimeStep, ...items: IUpdatable[]) => void;
 //# sourceMappingURL=timestep.d.ts.map

package/timestep.js

@@ -1,5 +1,9 @@
-export class TimeStep {
+import { __decorate } from "tslib";
+import { INotifyMixin, } from "@thi.ng/api";
+import { EVENT_FRAME, EVENT_INTEGRATE, } from "./api.js";
+let TimeStep = class TimeStep {
     constructor(opts) {
+        this.t = 0;
         this.current = 0;
         this.accumulator = 0;
         this.frame = 0;
@@ -15,7 +19,18 @@ export class TimeStep {
         this.maxFrameTime = $opts.maxFrameTime;
         this.scale = $opts.scale;
         this.start = $opts.startTime * this.scale;
+        this.__eventIntegrate = Object.freeze({
+            id: EVENT_INTEGRATE,
+            target: this,
+        });
+        this.__eventFrame = Object.freeze({ id: EVENT_FRAME, target: this });
     }
+    // @ts-ignore mixin
+    addListener(id, fn, scope) { }
+    // @ts-ignore mixin
+    removeListener(id, fn, scope) { }
+    // @ts-ignore mixin
+    notify(event) { }
     /**
      * Updates internal time to given new time `now` (in seconds) and performs
      * the required number of fixed timesteps to integrate and interpolate the
@@ -33,8 +48,6 @@ export class TimeStep {
      */
     update(now, items, interpolate = true) {
         now = now * this.scale - this.start;
-        if (this.current < 0)
-            this.current = now;
         this.accumulator += Math.min(now - this.current, this.maxFrameTime);
         this.current = now;
         const n = items.length;
@@ -42,8 +55,10 @@ export class TimeStep {
         while (this.accumulator >= dt) {
             for (let i = 0; i < n; i++)
                 items[i].integrate(dt, this);
+            this.t += dt;
             this.accumulator -= dt;
             this.updates++;
+            this.notify(this.__eventIntegrate);
         }
         if (interpolate) {
             const alpha = this.accumulator / dt;
@@ -51,6 +66,33 @@ export class TimeStep {
                 items[i].interpolate(alpha, this);
         }
         this.frame++;
+        this.notify(this.__eventFrame);
     }
-}
+};
+TimeStep = __decorate([
+    INotifyMixin
+], TimeStep);
+export { TimeStep };
 export const defTimeStep = (opts) => new TimeStep(opts);
+/**
+ * Calls {@link IUpdatable.integrate} for all given items (in given order).
+ *
+ * @param dt
+ * @param ctx
+ * @param items
+ */
+export const integrateAll = (dt, ctx, ...items) => {
+    for (let i = 0, n = items.length; i < n; i++)
+        items[i].integrate(dt, ctx);
+};
+/**
+ * Calls {@link IUpdatable.interpolate} for all given items (in given order).
+ *
+ * @param dt
+ * @param ctx
+ * @param items
+ */
+export const interpolateAll = (alpha, ctx, ...items) => {
+    for (let i = 0, n = items.length; i < n; i++)
+        items[i].interpolate(alpha, ctx);
+};