@gg-web-engine/core 0.0.49 → 0.0.57

package/dist/base/clock/pausable-clock.js

@@ -1,16 +1,11 @@
 import { filter, Subject } from 'rxjs';
 import { map, tap } from 'rxjs/operators';
 import { GgGlobalClock } from './global-clock';
+import { IClock } from './i-clock';
 /**
  * A class providing the ability to track time, fire ticks, provide time elapsed, and tick delta with the ability to suspend/resume it.
  */
-export class PausableClock {
-    /**
-     * Observable stream of ticks, emitting an array containing the current time and the tick delta.
-     */
-    get tick$() {
-        return this._tick$.asObservable();
-    }
+export class PausableClock extends IClock {
     /**
      * Checks if the clock is currently running.
      */
@@ -76,10 +71,10 @@ export class PausableClock {
      * @param parentClock The parent clock to synchronize with. Defaults to GgGlobalClock instance.
      */
     constructor(autoStart = false, parentClock = GgGlobalClock.instance) {
+        super(parentClock);
         this.parentClock = parentClock;
         this.tickSub = null;
         this._internalTick$ = new Subject();
-        this._tick$ = new Subject();
         /**
          * Tick rate limiter. If set to 0 - tick rate is unlimited, 15 means "allow at most 15 ticks per second"
          */
@@ -103,14 +98,6 @@ export class PausableClock {
                 Math.floor((elapsed * this.tickRateLimit) / 1000)), tap(([elapsed]) => (this.lastFiredTickElapsed = elapsed)))
             .subscribe(this._tick$);
     }
-    /**
-     * Creates a child clock.
-     * @param autoStart Indicates whether the child clock should start automatically.
-     * @returns A new instance of PausableClock.
-     */
-    createChildClock(autoStart) {
-        return new PausableClock(autoStart, this);
-    }
     /**
      * Starts the clock.
      */
@@ -170,4 +157,9 @@ export class PausableClock {
         (_a = this.tickSub) === null || _a === void 0 ? void 0 : _a.unsubscribe();
         this.tickSub = null;
     }
+    dispose() {
+        this.stopListeningTicks();
+        this._internalTick$.complete();
+        super.dispose();
+    }
 }

package/dist/base/components/physics/i-body.component.d.ts

@@ -7,12 +7,12 @@ export interface IBodyComponent<D, R, TypeDoc extends PhysicsTypeDocRepo<D, R> =
     position: D;
     rotation: R;
     name: string;
-    get ownCollisionGroups(): CollisionGroup[];
-    set ownCollisionGroups(value: CollisionGroup[] | 'all');
-    get interactWithCollisionGroups(): CollisionGroup[];
-    set interactWithCollisionGroups(value: CollisionGroup[] | 'all');
+    get ownCollisionGroups(): ReadonlyArray<CollisionGroup>;
+    set ownCollisionGroups(value: ReadonlyArray<CollisionGroup> | 'all');
+    get interactWithCollisionGroups(): ReadonlyArray<CollisionGroup>;
+    set interactWithCollisionGroups(value: ReadonlyArray<CollisionGroup> | 'all');
     /** body info for physics debugger view */
-    readonly debugBodySettings: DebugBodySettings;
+    readonly debugBodySettings: DebugBodySettings<any>;
     clone(): IBodyComponent<D, R, TypeDoc>;
     addToWorld(world: GgWorld<D, R, VisualTypeDocRepo<D, R>, TypeDoc>): void;
     removeFromWorld(world: GgWorld<D, R, VisualTypeDocRepo<D, R>, TypeDoc>): void;

package/dist/base/components/physics/i-physics-world.component.d.ts

@@ -2,22 +2,60 @@ import { PhysicsTypeDocRepo } from '../../gg-world';
 import { IComponent } from '../i-component';
 import { CollisionGroup } from '../../models/body-options';
 import { Subject } from 'rxjs';
+/**
+ * Interface representing a physics world component.
+ *
+ * @template D - Data type used for representing physics properties.
+ * @template R - Type representing the physics engine's rigid body.
+ * @template TypeDoc - Physics typings repository.
+ */
 export interface IPhysicsWorldComponent<D, R, TypeDoc extends PhysicsTypeDocRepo<D, R> = PhysicsTypeDocRepo<D, R>> extends IComponent {
+    /**
+     * Factory function for creating physics-related objects.
+     */
     readonly factory: TypeDoc['factory'];
+    /**
+     * The gravity vector affecting the physics world.
+     */
     gravity: D;
-    /** event emitter, emits newly added physics components */
+    /**
+     * Event emitter that emits newly added physics components.
+     */
     readonly added$: Subject<TypeDoc['rigidBody'] | TypeDoc['trigger'] | any>;
-    /** event emitter, emits just removed physics components */
+    /**
+     * Event emitter that emits just removed physics components.
+     */
     readonly removed$: Subject<TypeDoc['rigidBody'] | TypeDoc['trigger'] | any>;
-    /** list of currently added to world physics components */
+    /**
+     * List of currently added physics components in the world.
+     */
     readonly children: (TypeDoc['rigidBody'] | TypeDoc['trigger'] | any)[];
+    /**
+     * The main collision group. All physics bodies have this collision group set by default.
+     */
+    readonly mainCollisionGroup: CollisionGroup;
+    /**
+     * Initializes the physics world component.
+     *
+     * @returns A promise that resolves when initialization is complete.
+     */
     init(): Promise<void>;
     /**
-     * Runs simulation of the physics world.
+     * Runs the simulation of the physics world for the given time step.
      *
-     * @param delta delta time from last tick in milliseconds.
+     * @param delta - The time step in milliseconds since the last update.
      */
     simulate(delta: number): void;
+    /**
+     * Registers and returns a new collision group.
+     *
+     * @returns A newly registered collision group.
+     */
     registerCollisionGroup(): CollisionGroup;
+    /**
+     * Deregisters a previously registered collision group.
+     *
+     * @param group - The collision group to be removed.
+     */
     deregisterCollisionGroup(group: CollisionGroup): void;
 }

package/dist/base/data-structures/bitmask.d.ts

@@ -1,8 +1,9 @@
 /**
  * BitMask class provides static methods to manipulate bits in a number.
- */ /**
-* BitMask class provides static methods to manipulate bits in a number.
-*/
+ */
+/**
+ * BitMask class provides static methods to manipulate bits in a number.
+ */
 export declare class BitMask {
     /**
      * Generates a bitmask with all bits set to 1 upto the provided bit count
@@ -20,7 +21,7 @@ export declare class BitMask {
      * @param bits - The maximum bit index that can be used
      * @throws Will throw an Error if a bit index in `value` is larger than `bits`
      */
-    static pack(value: number[], bits: number): number;
+    static pack(value: number[] | ReadonlyArray<number>, bits: number): number;
     /**
      * Unpacks a bitmask into an array of bit indices
      * @param mask - The bit mask to be unpacked

package/dist/base/data-structures/bitmask.js

@@ -1,8 +1,9 @@
 /**
  * BitMask class provides static methods to manipulate bits in a number.
- */ /**
-* BitMask class provides static methods to manipulate bits in a number.
-*/
+ */
+/**
+ * BitMask class provides static methods to manipulate bits in a number.
+ */
 export class BitMask {
     /**
      * Generates a bitmask with all bits set to 1 upto the provided bit count

package/dist/base/gg-world.d.ts

@@ -1,4 +1,4 @@
-import { IDisplayObjectComponent, IEntity, IPhysicsWorldComponent, IPositionable, IRenderableEntity, IRendererComponent, IRigidBodyComponent, ITriggerComponent, IVisualSceneComponent, KeyboardInput, PausableClock } from '../base';
+import { IDisplayObjectComponent, IEntity, IPhysicsWorldComponent, IPositionable, IRenderableEntity, IRendererComponent, IRendererEntity, IRigidBodyComponent, ITriggerComponent, IVisualSceneComponent, KeyboardInput, PausableClock } from '../base';
 import { Subject } from 'rxjs';
 export type VisualTypeDocRepo<D, R> = {
     factory: unknown;
@@ -16,16 +16,19 @@ export declare abstract class GgWorld<D, R, VTypeDoc extends VisualTypeDocRepo<D
     readonly physicsWorld: PW;
     private static default_name_counter;
     private static _documentWorlds;
+    static readonly worldCreated$: Subject<GgWorld<any, any>>;
     static get documentWorlds(): GgWorld<any, any>[];
     readonly worldClock: PausableClock;
     readonly keyboardInput: KeyboardInput;
     name: string;
     readonly children: IEntity[];
     protected readonly tickListeners: IEntity[];
+    get renderers(): IRendererEntity<D, R>[];
     readonly tickStarted$: Subject<void>;
     readonly tickForwardTo$: Subject<IEntity | 'PHYSICS_WORLD'>;
     readonly tickForwardedTo$: Subject<IEntity | 'PHYSICS_WORLD'>;
     readonly paused$: Subject<boolean>;
+    readonly disposed$: Subject<void>;
     protected constructor(visualScene: VS, physicsWorld: PW);
     init(): Promise<void>;
     start(): void;
@@ -40,4 +43,8 @@ export declare abstract class GgWorld<D, R, VTypeDoc extends VisualTypeDocRepo<D
     position?: D, rotation?: R, material?: unknown): IPositionable<D, R> & IRenderableEntity<D, R, VTypeDoc>;
     addEntity(entity: IEntity): void;
     removeEntity(entity: IEntity, dispose?: boolean): void;
+    private onGgStaticInitialized;
+    protected registerConsoleCommands(ggstatic: {
+        registerConsoleCommand: (world: GgWorld<any, any> | null, command: string, handler: (...args: string[]) => Promise<string>, doc?: string) => void;
+    }): void;
 }

package/dist/base/gg-world.js

@@ -7,17 +7,20 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { GgGlobalClock, IRendererEntity, KeyboardInput, TickOrder, } from '../base';
+import { IRendererEntity, KeyboardInput, PausableClock, TickOrder, } from '../base';
 import { lastValueFrom, Subject, take } from 'rxjs';
 import { PerformanceMeterEntity } from '../dev';
 export class GgWorld {
     static get documentWorlds() {
         return [...GgWorld._documentWorlds];
     }
+    get renderers() {
+        return this.tickListeners.filter(e => e instanceof IRendererEntity);
+    }
     constructor(visualScene, physicsWorld) {
         this.visualScene = visualScene;
         this.physicsWorld = physicsWorld;
-        this.worldClock = GgGlobalClock.instance.createChildClock(false);
+        this.worldClock = new PausableClock(false);
         this.keyboardInput = new KeyboardInput();
         this.name = 'w0x' + (GgWorld.default_name_counter++).toString(16);
         this.children = [];
@@ -28,72 +31,18 @@ export class GgWorld {
         this.tickForwardTo$ = new Subject();
         this.tickForwardedTo$ = new Subject();
         this.paused$ = new Subject();
-        GgWorld._documentWorlds.push(this);
+        this.disposed$ = new Subject();
         this.keyboardInput.start();
         if (window.ggstatic) {
-            window.ggstatic.registerConsoleCommand(this, 'ph_timescale', (...args) => __awaiter(this, void 0, void 0, function* () {
-                this.worldClock.timeScale = +args[0];
-                return JSON.stringify(this.worldClock.timeScale);
-            }), 'args: [float]; change time scale of physics engine. Default value is 1.0');
-            window.ggstatic.registerConsoleCommand(this, 'ls_renderers', () => __awaiter(this, void 0, void 0, function* () {
-                return this.children
-                    .filter(e => e instanceof IRendererEntity)
-                    .map(r => r.name)
-                    .join('\n');
-            }), 'no args; print all renderers in selected world');
-            window.ggstatic.registerConsoleCommand(this, 'dr_drawphysics', (...args) => __awaiter(this, void 0, void 0, function* () {
-                const value = ['1', 'true', '+'].includes(args[0]);
-                const rendererName = args[1];
-                let renderer;
-                if (rendererName) {
-                    renderer = this.children.find(x => x instanceof IRendererEntity && x.name === rendererName);
-                }
-                else {
-                    renderer = this.children.find(x => x instanceof IRendererEntity);
-                }
-                if (renderer) {
-                    renderer.physicsDebugViewActive = value;
-                    return '' + value;
-                }
-                return 'false';
-            }), 'args: [0 or 1] or [0 or 1, string]; turn on/off physics debug view. Second argument expects renderer ' +
-                'name, if not provided first renderer will be picked. Look up for renderer names using command "ls_renderers"');
-            window.ggstatic.registerConsoleCommand(this, 'performance_report', (...args) => __awaiter(this, void 0, void 0, function* () {
-                let mode = 'avg';
-                let samples = 20;
-                for (let i = 0; i < 2; i++) {
-                    if (['avg', 'peak'].includes(args[i])) {
-                        mode = args[i];
-                    }
-                    else if (!isNaN(+args[i])) {
-                        samples = +args[i];
-                    }
-                }
-                const meter = new PerformanceMeterEntity(samples, 250);
-                this.addEntity(meter);
-                yield lastValueFrom(this.worldClock.tick$.pipe(take(samples)));
-                const report = mode === 'avg' ? meter.avgReport : meter.peakReport;
-                this.removeEntity(meter);
-                const renderItems = report.entries.map(([name, value]) => `<span style='color:lightgray;'>${name}:</span>` +
-                    new Array(Math.max(0, 26 - name.length)).join('&nbsp;') +
-                    `${value.toFixed(2)} ms` +
-                    (mode === 'avg' ? ` (${((value * 100) / report.totalTime).toFixed(2)}%)` : ''));
-                let totalColor = 'lightgreen';
-                if (report.totalTime > 12) {
-                    totalColor = report.totalTime < 16 ? 'yellow' : 'red';
-                }
-                const title = `${mode === 'avg' ? 'Average' : 'Peak'} Frame time`;
-                renderItems.unshift(title +
-                    ':' +
-                    new Array(Math.max(0, 26 - title.length)).join('&nbsp;') +
-                    `<span style='color:${totalColor};'>${report.totalTime.toFixed(2)} ms</span>`);
-                renderItems.unshift(`Performance report (${samples} samples)`);
-                return renderItems.join('\n');
-            }), 'args: [int, avg|peak]; [avg|peak, int]; [avg|peak]; [int] or []; measure how much time was spent per ' +
-                'entity in world. Arguments are samples amount (20 by default) and "peak" or "avg" choice, both arguments are ' +
-                'optional. "avg" report sorts entities by average time consumed, "peak" records highest value for each entity');
+            this.registerConsoleCommands(window.ggstatic);
+        }
+        else {
+            this.onGgStaticInitialized = this.onGgStaticInitialized.bind(this);
+            window.addEventListener('ggstatic_added', this.onGgStaticInitialized);
         }
         this.worldClock.paused$.subscribe(this.paused$);
+        GgWorld._documentWorlds.push(this);
+        GgWorld.worldCreated$.next(this);
     }
     init() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -145,12 +94,15 @@ export class GgWorld {
         return this.worldClock.elapsedTime;
     }
     createClock(autoStart) {
-        return this.worldClock.createChildClock(autoStart);
+        return new PausableClock(autoStart, this.worldClock);
     }
     dispose() {
         if (window.ggstatic) {
             window.ggstatic.deregisterWorldCommands(this);
         }
+        else {
+            window.removeEventListener('ggstatic_added', this.onGgStaticInitialized);
+        }
         this.worldClock.stop();
         this.keyboardInput.stop();
         this.tickStarted$.complete();
@@ -164,6 +116,9 @@ export class GgWorld {
         this.tickListeners.splice(0, this.tickListeners.length);
         this.physicsWorld.dispose();
         this.visualScene.dispose();
+        GgWorld._documentWorlds.splice(GgWorld._documentWorlds.indexOf(this), 1);
+        this.disposed$.next();
+        this.disposed$.complete();
     }
     addEntity(entity) {
         if (!!entity.world) {
@@ -188,6 +143,88 @@ export class GgWorld {
             entity.dispose();
         }
     }
+    onGgStaticInitialized() {
+        window.removeEventListener('ggstatic_added', this.onGgStaticInitialized);
+        this.registerConsoleCommands(window.ggstatic);
+    }
+    registerConsoleCommands(ggstatic) {
+        ggstatic.registerConsoleCommand(this, 'timescale', (...args) => __awaiter(this, void 0, void 0, function* () {
+            if (!isNaN(+args[0])) {
+                this.worldClock.timeScale = +args[0];
+            }
+            return this.worldClock.timeScale.toString();
+        }), 'args: [ float? ]; Get current time scale of selected world clock or set it.' +
+            ' Default value is 1.0 (no time scale applied)');
+        ggstatic.registerConsoleCommand(this, 'fps_limit', (...args) => __awaiter(this, void 0, void 0, function* () {
+            if (!isNaN(+args[0])) {
+                this.worldClock.tickRateLimit = +args[0];
+            }
+            return this.worldClock.tickRateLimit.toString();
+        }), 'args: [ int? ]; Get current tick rate limit of selected world clock or set it. 0 means no limit applied');
+        ggstatic.registerConsoleCommand(this, 'renderers', () => __awaiter(this, void 0, void 0, function* () {
+            return this.renderers.map(r => r.name).join('\n');
+        }), 'no args; Print all renderers in selected world');
+        ggstatic.registerConsoleCommand(this, 'debug_view', (...args) => __awaiter(this, void 0, void 0, function* () {
+            let value = 'toggle';
+            let rendererName = undefined;
+            for (let arg of args) {
+                if (['1', '0'].includes(arg)) {
+                    value = arg === '1';
+                }
+                else {
+                    rendererName = arg;
+                }
+            }
+            let renderer = rendererName ? this.renderers.find(x => x.name === rendererName) : this.renderers[0];
+            if (renderer) {
+                renderer.physicsDebugViewActive = value === 'toggle' ? !renderer.physicsDebugViewActive : value;
+                return renderer.physicsDebugViewActive ? '1' : '0';
+            }
+            else if (rendererName) {
+                throw new Error(`Renderer with name "${rendererName}" not found`);
+            }
+            else {
+                throw new Error(`No renderer found`);
+            }
+        }), 'args: [ 0|1?, string? ]; Turn on/off physics debug view, skip first argument to toggle value.' +
+            ' Second argument expects renderer name, if not provided first renderer will be picked.' +
+            ' Use "renderers" to get list of renderers in the world');
+        ggstatic.registerConsoleCommand(this, 'performance', (...args) => __awaiter(this, void 0, void 0, function* () {
+            let mode = 'avg';
+            let samples = 20;
+            for (let arg of args) {
+                if (['avg', 'peak'].includes(arg)) {
+                    mode = arg;
+                }
+                else if (!isNaN(+arg)) {
+                    samples = +arg;
+                }
+            }
+            const meter = new PerformanceMeterEntity(samples, 250);
+            this.addEntity(meter);
+            yield lastValueFrom(this.worldClock.tick$.pipe(take(samples)));
+            const report = mode === 'avg' ? meter.avgReport : meter.peakReport;
+            this.removeEntity(meter);
+            const renderItems = report.entries.map(([name, value]) => `<span style='color:lightgray;'>${name}:</span>` +
+                new Array(Math.max(0, 26 - name.length)).join('&nbsp;') +
+                `${value.toFixed(2)} ms` +
+                (mode === 'avg' ? ` (${((value * 100) / report.totalTime).toFixed(2)}%)` : ''));
+            let totalColor = 'lightgreen';
+            if (report.totalTime > 12) {
+                totalColor = report.totalTime < 16 ? 'yellow' : 'red';
+            }
+            const title = `${mode === 'avg' ? 'Average' : 'Peak'} Frame time`;
+            renderItems.unshift(title +
+                ':' +
+                new Array(Math.max(0, 26 - title.length)).join('&nbsp;') +
+                `<span style='color:${totalColor};'>${report.totalTime.toFixed(2)} ms</span>`);
+            renderItems.unshift(`Performance report (${samples} samples)`);
+            return renderItems.join('\n');
+        }), 'args: [ int?, avg|peak? ]; Measure how much time was spent per ' +
+            'entity in world. Arguments are samples amount (20 by default) and "peak" or "avg" choice, both arguments are ' +
+            'optional. "avg" report sorts entities by average time consumed, "peak" records highest value for each entity');
+    }
 }
 GgWorld.default_name_counter = 0;
 GgWorld._documentWorlds = [];
+GgWorld.worldCreated$ = new Subject();

package/dist/base/inputs/keyboard.input.d.ts

@@ -14,7 +14,7 @@ export declare class KeyboardInput extends IInput {
     /**
      * Which element types should filter key downs when focused
      */
-    externalFocusBlacklist: {
+    static externalFocusBlacklist: {
         new (): HTMLElement;
     }[];
     /**

package/dist/base/inputs/keyboard.input.js

@@ -17,15 +17,6 @@ export class KeyboardInput extends IInput {
          * Flag which disables handling key downs, when document has some "typeable" element focused
          */
         this.skipKeyDownsOnExternalFocus = true;
-        /**
-         * Which element types should filter key downs when focused
-         */
-        this.externalFocusBlacklist = [
-            HTMLInputElement,
-            HTMLTextAreaElement,
-            HTMLSelectElement,
-            HTMLButtonElement,
-        ];
         this.handleKeys = this.handleKeys.bind(this);
         this.resetAllKeys = this.resetAllKeys.bind(this);
         this.onPointerLockChange = this.onPointerLockChange.bind(this);
@@ -127,7 +118,7 @@ export class KeyboardInput extends IInput {
         }
         const pressed = e.type == 'keydown';
         if (pressed && this.skipKeyDownsOnExternalFocus && document.activeElement) {
-            for (const k of this.externalFocusBlacklist) {
+            for (const k of KeyboardInput.externalFocusBlacklist) {
                 if (document.activeElement instanceof k) {
                     return;
                 }
@@ -151,3 +142,12 @@ export class KeyboardInput extends IInput {
         }
     }
 }
+/**
+ * Which element types should filter key downs when focused
+ */
+KeyboardInput.externalFocusBlacklist = [
+    HTMLInputElement,
+    HTMLTextAreaElement,
+    HTMLSelectElement,
+    HTMLButtonElement,
+];

package/dist/base/inputs/mouse.input.js

@@ -156,7 +156,7 @@ export class MouseInput extends IInput {
                 if (this.options.canvas) {
                     this.options.canvas.releasePointerCapture(event.pointerId);
                 }
-                this._element.removeEventListener('pointerup', onPointerUp);
+                window.removeEventListener('pointerup', onPointerUp);
                 this._element.removeEventListener('pointercancel', onPointerUp);
             }
             this._state$.next(pointerLengthsStateMap[Math.min(pointers.length, 2)]);
@@ -169,7 +169,8 @@ export class MouseInput extends IInput {
                     if (this.options.canvas) {
                         this.options.canvas.setPointerCapture(event.pointerId);
                     }
-                    this._element.addEventListener('pointerup', onPointerUp);
+                    // use window instead of this._element to handle case when mouse was released over other element
+                    window.addEventListener('pointerup', onPointerUp);
                     this._element.addEventListener('pointercancel', onPointerUp);
                 }
                 catch (err) {

package/dist/base/math/point2.d.ts

@@ -36,6 +36,8 @@ export declare class Pnt2 {
     static norm(p: Point2): Point2;
     /** scalar multiplication */
     static scalarMult(p: Point2, m: number): Point2;
+    /** dot multiplication */
+    static dot(a: Point2, b: Point2): number;
     /** linear interpolation */
     static lerp(a: Point2, b: Point2, t: number): Point2;
     /** angle between vectors in radians */

package/dist/base/math/point2.js

@@ -78,6 +78,10 @@ export class Pnt2 {
             y: p.y * m,
         };
     }
+    /** dot multiplication */
+    static dot(a, b) {
+        return a.x * b.x + a.y * b.y;
+    }
     /** linear interpolation */
     static lerp(a, b, t) {
         return {
@@ -87,9 +91,8 @@ export class Pnt2 {
     }
     /** angle between vectors in radians */
     static angle(a, b) {
-        const dotProduct = a.x * b.x + a.y * b.y;
-        const magnitudeProduct = Math.sqrt(a.x ** 2 + a.y ** 2) * Math.sqrt(b.x ** 2 + b.y ** 2);
-        return Math.acos(dotProduct / magnitudeProduct);
+        const magnitudeProduct = Pnt2.len(a) * Pnt2.len(b);
+        return Math.acos(Pnt2.dot(a, b) / magnitudeProduct);
     }
     /** rotate point around zero by provided angle */
     static rot(p, angle) {

package/dist/base/math/point3.d.ts

@@ -42,6 +42,8 @@ export declare class Pnt3 {
     static norm(p: Point3): Point3;
     /** scalar multiplication */
     static scalarMult(p: Point3, m: number): Point3;
+    /** dot multiplication */
+    static dot(a: Point3, b: Point3): number;
     /** linear interpolation */
     static lerp(a: Point3, b: Point3, t: number): Point3;
     /** angle between vectors in radians */

package/dist/base/math/point3.js

@@ -102,6 +102,10 @@ export class Pnt3 {
             z: p.z * m,
         };
     }
+    /** dot multiplication */
+    static dot(a, b) {
+        return a.x * b.x + a.y * b.y + a.z * b.z;
+    }
     /** linear interpolation */
     static lerp(a, b, t) {
         return {
@@ -112,9 +116,8 @@ export class Pnt3 {
     }
     /** angle between vectors in radians */
     static angle(a, b) {
-        const dotProduct = a.x * b.x + a.y * b.y + a.z * b.z;
-        const magnitudeProduct = Math.sqrt(a.x ** 2 + a.y ** 2 + a.z ** 2) * Math.sqrt(b.x ** 2 + b.y ** 2 + b.z ** 2);
-        return Math.acos(dotProduct / magnitudeProduct);
+        const magnitudeProduct = Pnt3.len(a) * Pnt3.len(b);
+        return Math.acos(Pnt3.dot(a, b) / magnitudeProduct);
     }
     /** rotate point a with quaternion q */
     static rot(p, q) {

package/dist/base/models/body-options.d.ts

@@ -4,15 +4,33 @@ export interface BodyOptions {
     mass: number;
     restitution: number;
     friction: number;
-    ownCollisionGroups: CollisionGroup[] | 'all';
-    interactWithCollisionGroups: CollisionGroup[] | 'all';
+    ownCollisionGroups: ReadonlyArray<CollisionGroup> | 'all';
+    interactWithCollisionGroups: ReadonlyArray<CollisionGroup> | 'all';
 }
-export type DebugBodySettings = {
-    shape: any;
-    ignoreTransform?: boolean;
-} & ({
-    type: 'RIGID_STATIC' | 'TRIGGER';
+export type DebugBodyType = {
+    type: 'RIGID_STATIC';
+} | {
+    type: 'TRIGGER';
+    activated: () => boolean;
 } | {
     type: 'RIGID_DYNAMIC';
-    sleeping: boolean;
-});
+    sleeping: () => boolean;
+};
+export declare abstract class DebugBodySettings<S> {
+    private _type;
+    private _shape;
+    private _ignoreTransform;
+    private _color;
+    private _revision;
+    get revision(): number;
+    get type(): DebugBodyType;
+    set type(value: DebugBodyType);
+    get shape(): S;
+    set shape(value: S);
+    get ignoreTransform(): boolean;
+    set ignoreTransform(value: boolean);
+    private lastRetrievedColorCache;
+    get color(): number;
+    set color(value: number | undefined);
+    protected constructor(_type: DebugBodyType, _shape: S, _ignoreTransform?: boolean, _color?: number | undefined);
+}