@gg-web-engine/core 0.0.56 → 0.0.57

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

@@ -1,7 +1,7 @@
-import { BodyOptions, DebugBodySettings } from '../../base';
+import { BodyOptions, DebugBodySettings, DebugBodyType } from '../../base';
 import { Shape2DDescriptor } from './shapes';
 export interface Body2DOptions extends BodyOptions {
 }
-export type DebugBody2DSettings = DebugBodySettings & {
-    shape: Shape2DDescriptor;
-};
+export declare class DebugBody2DSettings extends DebugBodySettings<Shape2DDescriptor> {
+    constructor(type: DebugBodyType, shape: Shape2DDescriptor, ignoreTransform?: boolean, color?: number | undefined);
+}

package/dist/2d/models/body-options.js

@@ -1 +1,6 @@
-export {};
+import { DebugBodySettings } from '../../base';
+export class DebugBody2DSettings extends DebugBodySettings {
+    constructor(type, shape, ignoreTransform = false, color = undefined) {
+        super(type, shape, ignoreTransform, color);
+    }
+}

package/dist/3d/entities/surface-following.entity.d.ts

@@ -0,0 +1,96 @@
+import { BodyOptions, IEntity, Point3, Point4 } from '../../base';
+import { Gg3dWorld, PhysicsTypeDocRepo3D, VisualTypeDocRepo3D } from '../gg-3d-world';
+import { Shape3DDescriptor } from '../models/shapes';
+/**
+ * Represents a function that calculates the surface position and normal
+ * for a given point in 3D space.
+ */
+export type SurfaceFollowFunc = (p: Point3) => {
+    position: Point3;
+    normal: Point3;
+};
+/**
+ * Represents an entity that follows a surface dynamically by adjusting
+ * its position and orientation based on a given surface function.
+ *
+ * @template PTypeDoc - The physics type document repository.
+ */
+export declare class SurfaceFollowingEntity<PTypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> extends IEntity<Point3, Point4, VisualTypeDocRepo3D, PTypeDoc> {
+    /** Function that determines surface position and normal. */
+    followFunc: SurfaceFollowFunc;
+    /** Optional body configuration. */
+    protected bodyOptions: Partial<Omit<BodyOptions, 'dynamic' | 'mass' | 'ownCollisionGroups' | 'interactWithCollisionGroups'>>;
+    /**
+     * Determines the execution order for physics simulation.
+     */
+    readonly tickOrder: number;
+    /**
+     * Debugging settings for the surface-following entity.
+     */
+    readonly debugBodySettings: SurfaceFollowingEntityDebugSettings;
+    constructor(
+    /** Function that determines surface position and normal. */
+    followFunc: SurfaceFollowFunc, 
+    /** Optional body configuration. */
+    bodyOptions?: Partial<Omit<BodyOptions, 'dynamic' | 'mass' | 'ownCollisionGroups' | 'interactWithCollisionGroups'>>);
+    /**
+     * Stores colliders and their associated metadata.
+     */
+    private colliders;
+    /**
+     * Sets up a collider by assigning it a collision group and a dynamic plane.
+     *
+     * @param collider - The physics rigid body to configure.
+     */
+    private setupCollider;
+    /**
+     * Adds a collider to the entity, registering it immediately if the entity
+     * is already in a world.
+     *
+     * @param collider - The physics rigid body to add.
+     */
+    addCollider(collider: PTypeDoc['rigidBody']): void;
+    /**
+     * Removes a collider and deregisters its associated collision group.
+     *
+     * @param collider - The physics rigid body to remove.
+     */
+    removeCollider(collider: PTypeDoc['rigidBody']): void;
+    /**
+     * Called when the entity is added to a world.
+     *
+     * @param world - The game world instance.
+     */
+    onSpawned(world: Gg3dWorld<VisualTypeDocRepo3D, PTypeDoc>): void;
+    private customGlobalDebugDummyBody;
+    /**
+     * Updates debug visualization if active.
+     */
+    private updateDebugView;
+    /**
+     * Called when the entity is removed from the world.
+     */
+    onRemoved(): void;
+    /**
+     * Positions planes based on the surface-follow function.
+     */
+    protected positionPlanes(): void;
+}
+/**
+ * Stores debug settings for a SurfaceFollowingEntity, allowing customization
+ * of the debug mesh.
+ */
+export declare class SurfaceFollowingEntityDebugSettings {
+    private _hexMeshStepDistance;
+    private _hexMeshDepth;
+    private _customGlobalShape;
+    private _revision;
+    get revision(): number;
+    get hexMeshStepDistance(): number;
+    set hexMeshStepDistance(value: number);
+    get hexMeshDepth(): number;
+    set hexMeshDepth(value: number);
+    get customGlobalShape(): Shape3DDescriptor | null;
+    set customGlobalShape(value: Shape3DDescriptor | null);
+    constructor(_hexMeshStepDistance?: number, _hexMeshDepth?: number, _customGlobalShape?: Shape3DDescriptor | null);
+}

package/dist/3d/entities/surface-following.entity.js

@@ -0,0 +1,296 @@
+import { takeUntil } from 'rxjs';
+import { IEntity, Pnt2, Pnt3, Qtrn, TickOrder } from '../../base';
+/**
+ * Represents an entity that follows a surface dynamically by adjusting
+ * its position and orientation based on a given surface function.
+ *
+ * @template PTypeDoc - The physics type document repository.
+ */
+export class SurfaceFollowingEntity extends IEntity {
+    constructor(
+    /** Function that determines surface position and normal. */
+    followFunc, 
+    /** Optional body configuration. */
+    bodyOptions = {}) {
+        super();
+        this.followFunc = followFunc;
+        this.bodyOptions = bodyOptions;
+        /**
+         * Determines the execution order for physics simulation.
+         */
+        this.tickOrder = TickOrder.PHYSICS_SIMULATION - 1;
+        /**
+         * Debugging settings for the surface-following entity.
+         */
+        this.debugBodySettings = new SurfaceFollowingEntityDebugSettings();
+        /**
+         * Stores colliders and their associated metadata.
+         */
+        this.colliders = new Map();
+        this.customGlobalDebugDummyBody = null;
+    }
+    /**
+     * Sets up a collider by assigning it a collision group and a dynamic plane.
+     *
+     * @param collider - The physics rigid body to configure.
+     */
+    setupCollider(collider) {
+        if (!this.world) {
+            throw new Error('Cannot setup collider if not added to the world');
+        }
+        let cg = this.world.physicsWorld.registerCollisionGroup();
+        collider.ownCollisionGroups = [...collider.ownCollisionGroups, cg];
+        collider.interactWithCollisionGroups = [...collider.ownCollisionGroups, cg];
+        let plane = this.world.physicsWorld.factory.createRigidBody({
+            shape: { shape: 'PLANE' },
+            body: Object.assign(Object.assign({}, this.bodyOptions), { dynamic: false, ownCollisionGroups: [cg], interactWithCollisionGroups: [cg] }),
+        });
+        if (this.debugBodySettings.customGlobalShape) {
+            plane.debugBodySettings.shape = { shape: 'SPHERE', radius: 0.25 };
+        }
+        else {
+            plane.debugBodySettings.ignoreTransform = true;
+        }
+        this.addComponents(plane);
+        this.colliders.set(collider, [cg, plane, {}]);
+    }
+    /**
+     * Adds a collider to the entity, registering it immediately if the entity
+     * is already in a world.
+     *
+     * @param collider - The physics rigid body to add.
+     */
+    addCollider(collider) {
+        if (this.world) {
+            this.setupCollider(collider);
+        }
+        else {
+            this.colliders.set(collider, null);
+        }
+    }
+    /**
+     * Removes a collider and deregisters its associated collision group.
+     *
+     * @param collider - The physics rigid body to remove.
+     */
+    removeCollider(collider) {
+        if (!this.colliders.has(collider)) {
+            return;
+        }
+        const item = this.colliders.get(collider);
+        if (item) {
+            const [cg, plane] = item;
+            this.removeComponents([plane], true);
+            collider.ownCollisionGroups = collider.ownCollisionGroups.filter(g => g !== cg);
+            collider.interactWithCollisionGroups = collider.interactWithCollisionGroups.filter(g => g !== cg);
+            this.world.physicsWorld.deregisterCollisionGroup(cg);
+        }
+        this.colliders.delete(collider);
+    }
+    /**
+     * Called when the entity is added to a world.
+     *
+     * @param world - The game world instance.
+     */
+    onSpawned(world) {
+        super.onSpawned(world);
+        for (const [collider] of this.colliders.entries()) {
+            this.setupCollider(collider);
+        }
+        world.physicsWorld.removed$.pipe(takeUntil(this.onRemoved$)).subscribe(c => {
+            if (this.colliders.has(c)) {
+                this.removeCollider(c);
+            }
+        });
+        this.tick$.pipe(takeUntil(this.onRemoved$)).subscribe(() => {
+            this.positionPlanes();
+            this.updateDebugView();
+        });
+        this.positionPlanes();
+        this.updateDebugView();
+    }
+    /**
+     * Updates debug visualization if active.
+     */
+    updateDebugView() {
+        const updateDebugView = !!this.world.renderers.find(r => r.physicsDebugViewActive);
+        if (updateDebugView) {
+            if (this.debugBodySettings.customGlobalShape) {
+                if (!this.customGlobalDebugDummyBody) {
+                    this.customGlobalDebugDummyBody = this.world.physicsWorld.factory.createRigidBody({
+                        shape: { shape: 'BOX', dimensions: Pnt3.O },
+                        body: { dynamic: false },
+                    });
+                    this.customGlobalDebugDummyBody.ownCollisionGroups = [];
+                    this.customGlobalDebugDummyBody.interactWithCollisionGroups = [];
+                    this.customGlobalDebugDummyBody.debugBodySettings.type = { type: 'RIGID_STATIC' };
+                    this.customGlobalDebugDummyBody.debugBodySettings.shape = this.debugBodySettings.customGlobalShape;
+                    this.addComponents(this.customGlobalDebugDummyBody);
+                    for (const item of this.colliders.values()) {
+                        if (item) {
+                            let [_, plane] = item;
+                            plane.debugBodySettings.shape = { shape: 'SPHERE', radius: 0.25 };
+                            plane.debugBodySettings.ignoreTransform = false;
+                        }
+                    }
+                }
+                else {
+                    this.customGlobalDebugDummyBody.debugBodySettings.shape = this.debugBodySettings.customGlobalShape;
+                }
+            }
+            else {
+                if (this.customGlobalDebugDummyBody) {
+                    this.removeComponents([this.customGlobalDebugDummyBody], true);
+                    this.customGlobalDebugDummyBody = null;
+                    // reset caches
+                    for (const item of this.colliders.values()) {
+                        if (item) {
+                            item[2] = {};
+                        }
+                    }
+                }
+                for (const [collider, item] of this.colliders.entries()) {
+                    let [_, plane, debugCache] = item;
+                    const { position, normal } = this.followFunc(collider.position);
+                    let xThreshold = this.debugBodySettings.hexMeshStepDistance;
+                    let yThreshold = this.debugBodySettings.hexMeshStepDistance * Math.sqrt(3);
+                    let zThreshold = this.debugBodySettings.hexMeshStepDistance * 2;
+                    let hexMeshStartPosition = {
+                        x: Math.round(position.x / xThreshold) * xThreshold,
+                        y: Math.round(position.y / yThreshold) * yThreshold,
+                        z: Math.round(position.z / zThreshold) * zThreshold,
+                    };
+                    if (debugCache.lastDebugSettingsRev != this.debugBodySettings.revision ||
+                        !debugCache.lastDebugStartPos ||
+                        Pnt3.dist(debugCache.lastDebugStartPos, hexMeshStartPosition) > 1) {
+                        let { vertices, faces } = buildHexMeshAlongSurface(hexMeshStartPosition, this.followFunc, this.debugBodySettings.hexMeshDepth, this.debugBodySettings.hexMeshStepDistance);
+                        plane.debugBodySettings.shape = {
+                            shape: 'MESH',
+                            vertices,
+                            faces,
+                        };
+                        plane.debugBodySettings.ignoreTransform = true;
+                        debugCache.lastDebugStartPos = hexMeshStartPosition;
+                        debugCache.lastDebugSettingsRev = this.debugBodySettings.revision;
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Called when the entity is removed from the world.
+     */
+    onRemoved() {
+        for (const [collider, item] of this.colliders) {
+            if (item) {
+                const [cg, plane] = item;
+                this.removeComponents([plane], true);
+                collider.ownCollisionGroups = collider.ownCollisionGroups.filter(g => g !== cg);
+                collider.interactWithCollisionGroups = collider.interactWithCollisionGroups.filter(g => g !== cg);
+                this.world.physicsWorld.deregisterCollisionGroup(cg);
+            }
+        }
+        this.colliders.clear();
+        super.onRemoved();
+    }
+    /**
+     * Positions planes based on the surface-follow function.
+     */
+    positionPlanes() {
+        if (!this.world) {
+            return;
+        }
+        for (const [collider, item] of this.colliders.entries()) {
+            let [_, plane] = item;
+            const { position, normal } = this.followFunc(collider.position);
+            plane.position = position;
+            plane.rotation = Qtrn.lookAt(normal, Pnt3.O);
+        }
+    }
+}
+/**
+ * Stores debug settings for a SurfaceFollowingEntity, allowing customization
+ * of the debug mesh.
+ */
+export class SurfaceFollowingEntityDebugSettings {
+    get revision() {
+        return this._revision;
+    }
+    get hexMeshStepDistance() {
+        return this._hexMeshStepDistance;
+    }
+    set hexMeshStepDistance(value) {
+        this._hexMeshStepDistance = value;
+        this._revision++;
+    }
+    get hexMeshDepth() {
+        return this._hexMeshDepth;
+    }
+    set hexMeshDepth(value) {
+        this._hexMeshDepth = value;
+        this._revision++;
+    }
+    get customGlobalShape() {
+        return this._customGlobalShape;
+    }
+    set customGlobalShape(value) {
+        this._customGlobalShape = value;
+        this._revision++;
+    }
+    constructor(_hexMeshStepDistance = 4, _hexMeshDepth = 6, _customGlobalShape = null) {
+        this._hexMeshStepDistance = _hexMeshStepDistance;
+        this._hexMeshDepth = _hexMeshDepth;
+        this._customGlobalShape = _customGlobalShape;
+        this._revision = 0;
+    }
+}
+const buildHexMeshAlongSurface = (start, surfaceFunc, depth, stepDistance) => {
+    let startPoint = surfaceFunc(start);
+    const vertices = [startPoint.position];
+    const faces = [];
+    let lastLoop = [
+        {
+            position: startPoint.position,
+            normal: startPoint.normal,
+            vertexIndex: 0,
+        },
+    ];
+    const traverse = (point, angle) => {
+        let pnt2 = Pnt2.rot(Pnt2.scalarMult(Pnt2.X, stepDistance), angle);
+        let snorm = Pnt3.toSpherical(point.normal);
+        let spnt = Pnt3.toSpherical(Object.assign(Object.assign({}, pnt2), { z: 0 }));
+        return Pnt3.add(point.position, Pnt3.fromSpherical(Object.assign(Object.assign({}, spnt), { phi: spnt.phi + Math.cos(snorm.theta - spnt.theta) * snorm.phi })));
+    };
+    for (let i = 0; i < depth; i++) {
+        let newLoop = [];
+        if (i == 0) {
+            for (let j = 0; j < 6; j++) {
+                let point = surfaceFunc(traverse(startPoint, (j * Math.PI) / 3));
+                newLoop.push(Object.assign(Object.assign({}, point), { vertexIndex: j + 1 }));
+                faces.push([0, j + 1, j < 5 ? j + 2 : 1]);
+            }
+        }
+        else {
+            for (let j = 0; j < lastLoop.length; j++) {
+                let startPoint = lastLoop[j];
+                let angle = (Math.floor((j * 6) / lastLoop.length) * Math.PI) / 3;
+                let rightNeighbour = lastLoop[j < lastLoop.length - 1 ? j + 1 : 0];
+                if (j % (lastLoop.length / 6) == 0) {
+                    // hex corner vertex, add new vertex in this loop. Each next loop has +6 vertices
+                    let pointF = surfaceFunc(traverse(startPoint, angle));
+                    let vi = vertices.length + newLoop.length;
+                    newLoop.push(Object.assign(Object.assign({}, pointF), { vertexIndex: vi }));
+                    faces.push([startPoint.vertexIndex, j > 0 ? vi - 1 : vi + lastLoop.length + 5, vi]);
+                }
+                let pointR = surfaceFunc(Pnt3.avg(traverse(startPoint, angle + Math.PI / 3), traverse(rightNeighbour, angle)));
+                let vi = vertices.length + newLoop.length;
+                newLoop.push(Object.assign(Object.assign({}, pointR), { vertexIndex: vi }));
+                faces.push([startPoint.vertexIndex, vi - 1, vi]);
+                faces.push([rightNeighbour.vertexIndex, startPoint.vertexIndex, vi]);
+            }
+        }
+        vertices.push(...newLoop.map(({ position }) => position));
+        lastLoop = newLoop;
+    }
+    return { vertices, faces };
+};

package/dist/3d/index.d.ts

@@ -19,6 +19,7 @@ export * from './entities/controllers/input/car-keyboard-handling.controller';
 export * from './entities/controllers/input/gg-car-keyboard-handling.controller';
 export * from './entities/controllers/input/free-camera.controller';
 export * from './entities/controllers/input/orbit-camera.controller';
+export * from './entities/surface-following.entity';
 export * from './interfaces/i-positionable-3d';
 export * from './models/body-options';
 export * from './models/gg-meta';

package/dist/3d/index.js

@@ -19,6 +19,7 @@ export * from './entities/controllers/input/car-keyboard-handling.controller';
 export * from './entities/controllers/input/gg-car-keyboard-handling.controller';
 export * from './entities/controllers/input/free-camera.controller';
 export * from './entities/controllers/input/orbit-camera.controller';
+export * from './entities/surface-following.entity';
 export * from './interfaces/i-positionable-3d';
 export * from './models/body-options';
 export * from './models/gg-meta';

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

@@ -1,7 +1,7 @@
-import { BodyOptions, DebugBodySettings } from '../../base';
+import { BodyOptions, DebugBodySettings, DebugBodyType } from '../../base';
 import { Shape3DDescriptor } from './shapes';
 export interface Body3DOptions extends BodyOptions {
 }
-export type DebugBody3DSettings = DebugBodySettings & {
-    shape: Shape3DDescriptor;
-};
+export declare class DebugBody3DSettings extends DebugBodySettings<Shape3DDescriptor> {
+    constructor(type: DebugBodyType, shape: Shape3DDescriptor, ignoreTransform?: boolean, color?: number | undefined);
+}

package/dist/3d/models/body-options.js

@@ -1 +1,6 @@
-export {};
+import { DebugBodySettings } from '../../base';
+export class DebugBody3DSettings extends DebugBodySettings {
+    constructor(type, shape, ignoreTransform = false, color = undefined) {
+        super(type, shape, ignoreTransform, color);
+    }
+}

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;
@@ -23,6 +23,7 @@ export declare abstract class GgWorld<D, R, VTypeDoc extends VisualTypeDocRepo<D
     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'>;

package/dist/base/gg-world.js

@@ -14,6 +14,9 @@ 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;
@@ -159,10 +162,7 @@ export class GgWorld {
             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.children
-                .filter(e => e instanceof IRendererEntity)
-                .map(r => r.name)
-                .join('\n');
+            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';
@@ -175,7 +175,7 @@ export class GgWorld {
                     rendererName = arg;
                 }
             }
-            let renderer = this.children.find(x => x instanceof IRendererEntity && (!rendererName || x.name === rendererName));
+            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';

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

package/dist/base/models/body-options.js

@@ -1 +1,65 @@
-export {};
+export class DebugBodySettings {
+    get revision() {
+        // force check of color
+        let _ = this.color;
+        return this._revision;
+    }
+    get type() {
+        return this._type;
+    }
+    set type(value) {
+        this._type = value;
+        this._revision++;
+    }
+    get shape() {
+        return this._shape;
+    }
+    set shape(value) {
+        this._shape = value;
+        this._revision++;
+    }
+    get ignoreTransform() {
+        return this._ignoreTransform;
+    }
+    set ignoreTransform(value) {
+        this._ignoreTransform = value;
+        this._revision++;
+    }
+    get color() {
+        let color = 0;
+        if (this._color !== undefined) {
+            color = this._color;
+        }
+        else {
+            switch (this.type.type) {
+                case 'RIGID_DYNAMIC':
+                    color = this.type.sleeping() ? 0x0000ff : 0xff0000;
+                    break;
+                case 'RIGID_STATIC':
+                    color = 0x00ff00;
+                    break;
+                case 'TRIGGER':
+                    color = this.type.activated() ? 0xff9900 : 0xffff00;
+                    break;
+            }
+        }
+        if (color !== this.lastRetrievedColorCache) {
+            this._revision++;
+            this.lastRetrievedColorCache = color;
+        }
+        return color;
+    }
+    set color(value) {
+        this._color = value;
+    }
+    constructor(_type, _shape, _ignoreTransform = false, _color = undefined) {
+        this._type = _type;
+        this._shape = _shape;
+        this._ignoreTransform = _ignoreTransform;
+        this._color = _color;
+        // this value changes on each change inside the settings.
+        // Debug view skips updating anything if value stays the same
+        this._revision = 0;
+        this.lastRetrievedColorCache = 0;
+    }
+}

package/dist/dev/gg-debugger.ui.js

@@ -1,4 +1,4 @@
-import { createInlineTickController, IRendererEntity } from '../base';
+import { createInlineTickController } from '../base';
 import { animationFrameScheduler, fromEvent, of, Subject, takeUntil } from 'rxjs';
 import Stats from 'stats.js';
 import { repeat } from 'rxjs/operators';
@@ -139,19 +139,11 @@ export class GgDebuggerUI {
         }
     }
     makeSnapshot() {
-        var _a, _b;
-        const renderers = [];
-        let performanceMeter = null;
-        for (const e of ((_a = this.currentWorld) === null || _a === void 0 ? void 0 : _a.children) || []) {
-            if (e instanceof IRendererEntity) {
-                renderers.push(e);
-            }
-            else if (e instanceof PerformanceMeterEntity) {
-                performanceMeter = e;
-            }
-        }
+        var _a, _b, _c;
+        const renderers = ((_a = this.currentWorld) === null || _a === void 0 ? void 0 : _a.renderers) || [];
+        let performanceMeter = (((_b = this.currentWorld) === null || _b === void 0 ? void 0 : _b.children) || []).find(e => e instanceof PerformanceMeterEntity);
         return {
-            timeScale: ((_b = this.currentWorld) === null || _b === void 0 ? void 0 : _b.worldClock.timeScale) || NaN,
+            timeScale: ((_c = this.currentWorld) === null || _c === void 0 ? void 0 : _c.worldClock.timeScale) || NaN,
             renderers: renderers.map(r => ({
                 name: r.name,
                 entity: r,

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.0.56";
+export declare const VERSION = "0.0.57";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '0.0.56';
+export const VERSION = '0.0.57';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gg-web-engine/core",
-  "version": "0.0.56",
+  "version": "0.0.57",
   "description": "An attempt to create open source game engine for browser",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",