@gg-web-engine/core 0.0.38 → 0.0.39

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

@@ -1,5 +1,8 @@
 import { IRigidBodyComponent, Point2 } from '../../../base';
 import { PhysicsTypeDocRepo2D } from '../../gg-2d-world';
+import { DebugBody2DSettings } from '../../models/body-options';
 export interface IRigidBody2dComponent<TypeDoc extends PhysicsTypeDocRepo2D = PhysicsTypeDocRepo2D> extends IRigidBodyComponent<Point2, number, TypeDoc> {
     angularVelocity: number;
+    /** body info for physics debugger view */
+    readonly debugBodySettings: DebugBody2DSettings;
 }

package/dist/2d/components/physics/i-trigger-2d.component.d.ts

@@ -1,7 +1,10 @@
 import { ITriggerComponent, Point2 } from '../../../base';
 import { Observable } from 'rxjs';
 import { PhysicsTypeDocRepo2D } from '../../gg-2d-world';
+import { DebugBody2DSettings } from '../../models/body-options';
 export interface ITrigger2dComponent<TypeDoc extends PhysicsTypeDocRepo2D = PhysicsTypeDocRepo2D> extends ITriggerComponent<Point2, number, TypeDoc> {
+    /** body info for physics debugger view */
+    readonly debugBodySettings: DebugBody2DSettings;
     get onEntityEntered(): Observable<TypeDoc['rigidBody']>;
     get onEntityLeft(): Observable<TypeDoc['rigidBody'] | null>;
 }

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

@@ -1,3 +1,7 @@
-import { BodyOptions } from '../../base';
+import { BodyOptions, DebugBodySettings } from '../../base';
+import { Shape2DDescriptor } from './shapes';
 export interface Body2DOptions extends BodyOptions {
 }
+export declare type DebugBody2DSettings = DebugBodySettings & {
+    shape: Shape2DDescriptor;
+};

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

@@ -1,5 +1,12 @@
 import { IPhysicsWorldComponent, Point3, Point4 } from '../../../base';
 import { PhysicsTypeDocRepo3D } from '../../gg-3d-world';
+import { Subject } from 'rxjs';
 export interface IPhysicsWorld3dComponent<TypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> extends IPhysicsWorldComponent<Point3, Point4, TypeDoc> {
     readonly loader: TypeDoc['loader'];
+    /** event emitter, emits newly added physics components */
+    readonly added$: Subject<TypeDoc['trigger'] | TypeDoc['rigidBody'] | TypeDoc['raycastVehicle'] | any>;
+    /** event emitter, emits just removed physics components */
+    readonly removed$: Subject<TypeDoc['trigger'] | TypeDoc['rigidBody'] | TypeDoc['raycastVehicle'] | any>;
+    /** list of currently added to world physics components */
+    readonly children: (TypeDoc['trigger'] | TypeDoc['rigidBody'] | TypeDoc['raycastVehicle'] | any)[];
 }

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

@@ -1,5 +1,8 @@
 import { IRigidBodyComponent, Point3, Point4 } from '../../../base';
 import { PhysicsTypeDocRepo3D } from '../../gg-3d-world';
+import { DebugBody3DSettings } from '../../models/body-options';
 export interface IRigidBody3dComponent<TypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> extends IRigidBodyComponent<Point3, Point4, TypeDoc> {
     angularVelocity: Point3;
+    /** body info for physics debugger view */
+    readonly debugBodySettings: DebugBody3DSettings;
 }

package/dist/3d/components/physics/i-trigger-3d.component.d.ts

@@ -1,7 +1,10 @@
 import { ITriggerComponent, Point3, Point4 } from '../../../base';
 import { Observable } from 'rxjs';
 import { PhysicsTypeDocRepo3D } from '../../gg-3d-world';
+import { DebugBody3DSettings } from '../../models/body-options';
 export interface ITrigger3dComponent<TypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> extends ITriggerComponent<Point3, Point4, TypeDoc> {
+    /** body info for physics debugger view */
+    readonly debugBodySettings: DebugBody3DSettings;
     get onEntityEntered(): Observable<TypeDoc['rigidBody']>;
     get onEntityLeft(): Observable<TypeDoc['rigidBody'] | null>;
 }

package/dist/3d/entities/controllers/input/car-keyboard-handling.controller.js

@@ -7,7 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { combineLatest, Subject, takeUntil } from 'rxjs';
+import { combineLatest, filter, Subject, takeUntil } from 'rxjs';
 import { DirectionKeyboardInput, IEntity, TickOrder, } from '../../../../base';
 export class CarKeyboardHandlingController extends IEntity {
     constructor(keyboard, options = {
@@ -32,7 +32,7 @@ export class CarKeyboardHandlingController extends IEntity {
             _super.onSpawned.call(this, world);
             let input = { upDown: 0, leftRight: 0 };
             combineLatest([this.directionsInput.output$, this.tick$])
-                .pipe(takeUntil(this._onRemoved$))
+                .pipe(filter(() => this.active), takeUntil(this._onRemoved$))
                 .subscribe(([d, [_, dt]]) => {
                 const direction = { upDown: 0, leftRight: 0 };
                 if (d.leftRight !== undefined)

package/dist/3d/entities/controllers/input/gg-car-keyboard-handling.controller.js

@@ -64,7 +64,7 @@ export class GgCarKeyboardHandlingController extends IEntity {
             });
             this.keyboard
                 .bind(this.options.gearUpDownKeys[0])
-                .pipe(takeUntil(this._onRemoved$), filter(x => this.switchingGearsEnabled && !!x))
+                .pipe(takeUntil(this._onRemoved$), filter(x => this.active && this.switchingGearsEnabled && !!x))
                 .subscribe(() => {
                 if (this.car && (!this.car.carProperties.transmission.isAuto || this.car.gear <= 0)) {
                     this.car.gear++;
@@ -72,7 +72,7 @@ export class GgCarKeyboardHandlingController extends IEntity {
             });
             this.keyboard
                 .bind(this.options.gearUpDownKeys[1])
-                .pipe(takeUntil(this._onRemoved$), filter(x => this.switchingGearsEnabled && !!x))
+                .pipe(takeUntil(this._onRemoved$), filter(x => this.active && this.switchingGearsEnabled && !!x))
                 .subscribe(() => {
                 if (this.car) {
                     if (this.car.carProperties.transmission.isAuto && this.car.gear > 1) {
@@ -85,7 +85,7 @@ export class GgCarKeyboardHandlingController extends IEntity {
             });
             this.keyboard
                 .bind(this.options.handbrakeKey)
-                .pipe(takeUntil(this._onRemoved$))
+                .pipe(takeUntil(this._onRemoved$), filter(() => this.active))
                 .subscribe(isKeyDown => {
                 if (this.car) {
                     this.car.handBrake = isKeyDown;

package/dist/3d/factories.d.ts

@@ -1,15 +1,15 @@
-import { BodyShape3DDescriptor, Shape3DDescriptor } from './models/shapes';
+import { BodyShape3DDescriptor, Shape3DDescriptor, Shape3DMeshDescriptor } from './models/shapes';
 import { Point3, Point4 } from '../base';
 import { PhysicsTypeDocRepo3D, VisualTypeDocRepo3D } from './gg-3d-world';
 export declare type DisplayObject3dOpts<Tex> = {
     color?: number;
-    shading?: 'unlit' | 'standart' | 'phong';
+    shading?: 'unlit' | 'standart' | 'phong' | 'wireframe';
     diffuse?: Tex;
     castShadow?: boolean;
     receiveShadow?: boolean;
 };
 export declare abstract class IDisplayObject3dComponentFactory<TypeDoc extends VisualTypeDocRepo3D = VisualTypeDocRepo3D> {
-    abstract createPrimitive(descriptor: Shape3DDescriptor, material?: DisplayObject3dOpts<TypeDoc['texture']>): TypeDoc['displayObject'];
+    abstract createPrimitive(descriptor: Shape3DMeshDescriptor, material?: DisplayObject3dOpts<TypeDoc['texture']>): TypeDoc['displayObject'];
     abstract createPerspectiveCamera(settings: {
         fov?: number;
         aspectRatio?: number;

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

@@ -1,3 +1,7 @@
-import { BodyOptions } from '../../base';
+import { BodyOptions, DebugBodySettings } from '../../base';
+import { Shape3DDescriptor } from './shapes';
 export interface Body3DOptions extends BodyOptions {
 }
+export declare type DebugBody3DSettings = DebugBodySettings & {
+    shape: Shape3DDescriptor;
+};

package/dist/3d/models/shapes.d.ts

@@ -1,4 +1,4 @@
-import { Point3, Point4 } from '../../base';
+import { Point2, Point3, Point4 } from '../../base';
 import { Body3DOptions } from './body-options';
 export declare type Shape3DDescriptor = {
     shape: 'PLANE';
@@ -31,6 +31,46 @@ export declare type Shape3DDescriptor = {
     vertices: Point3[];
     faces: [number, number, number][];
 };
+export declare type Shape3DMeshDescriptor = {
+    shape: 'PLANE';
+    dimensions?: Point2;
+    segments?: Point2;
+} | {
+    shape: 'BOX';
+    dimensions: Point3;
+    segments?: Point3;
+} | {
+    shape: 'CONE' | 'CYLINDER';
+    radius: number;
+    height: number;
+    radialSegments?: number;
+    heightSegments?: number;
+} | {
+    shape: 'CAPSULE';
+    radius: number;
+    centersDistance: number;
+    capSegments?: number;
+    radialSegments?: number;
+} | {
+    shape: 'SPHERE';
+    radius: number;
+    widthSegments?: number;
+    heightSegments?: number;
+} | {
+    shape: 'COMPOUND';
+    children: {
+        position?: Point3;
+        rotation?: Point4;
+        shape: Shape3DMeshDescriptor;
+    }[];
+} | {
+    shape: 'CONVEX_HULL';
+    vertices: Point3[];
+} | {
+    shape: 'MESH';
+    vertices: Point3[];
+    faces: [number, number, number][];
+};
 export declare type BodyShape3DDescriptor = {
     shape: Shape3DDescriptor;
     body: Partial<Body3DOptions>;

package/dist/base/clock/pausable-clock.d.ts

@@ -1,25 +1,80 @@
 import { Observable } from 'rxjs';
 import { IClock } from './i-clock';
 /**
- * A class, providing ability to track time, fire ticks, provide time elapsed + tick delta with ability to suspend/resume it.
+ * A class providing the ability to track time, fire ticks, provide time elapsed, and tick delta with the ability to suspend/resume it.
  */
 export declare class PausableClock implements IClock {
     protected readonly parentClock: IClock;
     private tickSub;
     private readonly _tick$;
+    /**
+     * Observable stream of ticks, emitting an array containing the current time and the tick delta.
+     */
     get tick$(): Observable<[number, number]>;
+    /**
+     * Checks if the clock is currently running.
+     */
     get isRunning(): boolean;
+    /**
+     * Checks if the clock is currently paused.
+     */
     get isPaused(): boolean;
+    /**
+     * Checks if the clock is stopped.
+     */
+    get isStopped(): boolean;
+    /**
+     * Gets the time scale of the clock.
+     */
+    get timeScale(): number;
+    /**
+     * Sets the time scale of the clock.
+     */
+    set timeScale(value: number);
+    /**
+     * Gets the elapsed time since the clock started.
+     */
     get elapsedTime(): number;
     private startedAt;
     private oldRelativeTime;
     private pausedAt;
+    private lastStopElapsed;
+    private _timeScale;
+    private pausedByTimescale;
+    /**
+     * Constructs a new PausableClock instance.
+     * @param autoStart Indicates whether the clock should start automatically upon creation.
+     * @param parentClock The parent clock to synchronize with. Defaults to GgGlobalClock instance.
+     */
     constructor(autoStart?: boolean, parentClock?: IClock);
+    /**
+     * Creates a child clock.
+     * @param autoStart Indicates whether the child clock should start automatically.
+     * @returns A new instance of PausableClock.
+     */
     createChildClock(autoStart: boolean): PausableClock;
+    /**
+     * Starts the clock.
+     */
     start(): void;
+    /**
+     * Stops the clock.
+     */
     stop(): void;
+    /**
+     * Pauses the clock.
+     */
     pause(): void;
+    /**
+     * Resumes the clock.
+     */
     resume(): void;
+    /**
+     * Starts listening for ticks from the parent clock.
+     */
     protected startListeningTicks(): void;
+    /**
+     * Stops listening for ticks from the parent clock.
+     */
     protected stopListeningTicks(): void;
 }

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

@@ -2,39 +2,105 @@ import { Subject } from 'rxjs';
 import { map, tap } from 'rxjs/operators';
 import { GgGlobalClock } from './global-clock';
 /**
- * A class, providing ability to track time, fire ticks, provide time elapsed + tick delta with ability to suspend/resume it.
+ * 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 {
+    /**
+     * Constructs a new PausableClock instance.
+     * @param autoStart Indicates whether the clock should start automatically upon creation.
+     * @param parentClock The parent clock to synchronize with. Defaults to GgGlobalClock instance.
+     */
     constructor(autoStart = false, parentClock = GgGlobalClock.instance) {
         this.parentClock = parentClock;
         this.tickSub = null;
         this._tick$ = new Subject();
-        // state
+        // State variables
         this.startedAt = -1;
         this.oldRelativeTime = 0; // "elapsed", emitted on last tick
         this.pausedAt = -1;
+        this.lastStopElapsed = 0;
+        this._timeScale = 1;
+        this.pausedByTimescale = false;
         if (autoStart) {
             this.start();
         }
     }
+    /**
+     * Observable stream of ticks, emitting an array containing the current time and the tick delta.
+     */
     get tick$() {
         return this._tick$.pipe(map(([oldTime, newTime]) => [newTime, newTime - oldTime]));
     }
+    /**
+     * Checks if the clock is currently running.
+     */
     get isRunning() {
         return !!this.tickSub;
     }
+    /**
+     * Checks if the clock is currently paused.
+     */
     get isPaused() {
         return this.pausedAt !== -1;
     }
+    /**
+     * Checks if the clock is stopped.
+     */
+    get isStopped() {
+        return this.startedAt === -1;
+    }
+    /**
+     * Gets the time scale of the clock.
+     */
+    get timeScale() {
+        return this._timeScale;
+    }
+    /**
+     * Sets the time scale of the clock.
+     */
+    set timeScale(value) {
+        if (value === this._timeScale && !(this.pausedByTimescale && value !== 0))
+            return;
+        if (value === 0) {
+            if (!this.isPaused) {
+                this.pause();
+                this.pausedByTimescale = true;
+            }
+            return;
+        }
+        if (this.isPaused && this.pausedByTimescale) {
+            this.resume();
+            this.pausedByTimescale = false;
+        }
+        if (!this.isStopped) {
+            const cur = this.isPaused ? this.pausedAt : this.parentClock.elapsedTime;
+            this.startedAt = cur - ((cur - this.startedAt) * this.timeScale) / value;
+        }
+        this._timeScale = value;
+    }
+    /**
+     * Gets the elapsed time since the clock started.
+     */
     get elapsedTime() {
+        if (this.isStopped) {
+            return this.lastStopElapsed;
+        }
         if (this.isPaused) {
-            return this.pausedAt - this.startedAt;
+            return this._timeScale * (this.pausedAt - this.startedAt);
         }
-        return this.parentClock.elapsedTime - this.startedAt;
+        return this._timeScale * (this.parentClock.elapsedTime - this.startedAt);
     }
+    /**
+     * 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.
+     */
     start() {
         if (this.isRunning) {
             return;
@@ -43,14 +109,25 @@ export class PausableClock {
         this.startedAt = this.parentClock.elapsedTime;
         this.startListeningTicks();
     }
+    /**
+     * Stops the clock.
+     */
     stop() {
         this.stopListeningTicks();
+        this.lastStopElapsed = this.elapsedTime;
         this.startedAt = this.pausedAt = -1;
     }
+    /**
+     * Pauses the clock.
+     */
     pause() {
         this.stopListeningTicks();
         this.pausedAt = this.parentClock.elapsedTime;
+        this.pausedByTimescale = false;
     }
+    /**
+     * Resumes the clock.
+     */
     resume() {
         if (this.isRunning || this.pausedAt == -1) {
             return;
@@ -59,14 +136,20 @@ export class PausableClock {
         this.pausedAt = -1;
         this.startListeningTicks();
     }
+    /**
+     * Starts listening for ticks from the parent clock.
+     */
     startListeningTicks() {
         if (this.tickSub) {
             throw new Error('Clock is already ticking!');
         }
         this.tickSub = this.parentClock.tick$
-            .pipe(map(([parentElapsed, _]) => [this.oldRelativeTime, parentElapsed - this.startedAt]), tap(([_, cur]) => (this.oldRelativeTime = cur)))
+            .pipe(map(([_, d]) => [this.oldRelativeTime, this.oldRelativeTime + d * this.timeScale]), tap(([_, cur]) => (this.oldRelativeTime = cur)))
             .subscribe(this._tick$);
     }
+    /**
+     * Stops listening for ticks from the parent clock.
+     */
     stopListeningTicks() {
         var _a;
         (_a = this.tickSub) === null || _a === void 0 ? void 0 : _a.unsubscribe();

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

@@ -1,7 +1,7 @@
 import { IEntity } from '../../entities/i-entity';
 import { IWorldComponent } from '../i-world-component';
 import { GgWorld, PhysicsTypeDocRepo, VisualTypeDocRepo } from '../../gg-world';
-import { CollisionGroup } from '../../models/body-options';
+import { CollisionGroup, DebugBodySettings } from '../../models/body-options';
 export interface IBodyComponent<D, R, TypeDoc extends PhysicsTypeDocRepo<D, R> = PhysicsTypeDocRepo<D, R>> extends IWorldComponent<D, R, VisualTypeDocRepo<D, R>, TypeDoc> {
     entity: IEntity | null;
     position: D;
@@ -11,6 +11,8 @@ export interface IBodyComponent<D, R, TypeDoc extends PhysicsTypeDocRepo<D, R> =
     set ownCollisionGroups(value: CollisionGroup[] | 'all');
     get interactWithCollisionGroups(): CollisionGroup[];
     set interactWithCollisionGroups(value: CollisionGroup[] | 'all');
+    /** body info for physics debugger view */
+    readonly debugBodySettings: DebugBodySettings;
     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

@@ -1,12 +1,16 @@
-import { GgWorld, PhysicsTypeDocRepo } from '../../gg-world';
-import { IDebugPhysicsDrawer } from '../../interfaces/i-debug-physics-drawer';
+import { PhysicsTypeDocRepo } from '../../gg-world';
 import { IComponent } from '../i-component';
 import { CollisionGroup } from '../../models/body-options';
+import { Subject } from 'rxjs';
 export interface IPhysicsWorldComponent<D, R, TypeDoc extends PhysicsTypeDocRepo<D, R> = PhysicsTypeDocRepo<D, R>> extends IComponent {
     readonly factory: TypeDoc['factory'];
     gravity: D;
-    timeScale: number;
-    get physicsDebugViewActive(): boolean;
+    /** event emitter, emits newly added physics components */
+    readonly added$: Subject<TypeDoc['rigidBody'] | TypeDoc['trigger'] | any>;
+    /** event emitter, emits just removed physics components */
+    readonly removed$: Subject<TypeDoc['rigidBody'] | TypeDoc['trigger'] | any>;
+    /** list of currently added to world physics components */
+    readonly children: (TypeDoc['rigidBody'] | TypeDoc['trigger'] | any)[];
     init(): Promise<void>;
     /**
      * Runs simulation of the physics world.
@@ -16,6 +20,4 @@ export interface IPhysicsWorldComponent<D, R, TypeDoc extends PhysicsTypeDocRepo
     simulate(delta: number): void;
     registerCollisionGroup(): CollisionGroup;
     deregisterCollisionGroup(group: CollisionGroup): void;
-    startDebugger(world: GgWorld<D, R>, drawer: IDebugPhysicsDrawer<D, R>): void;
-    stopDebugger(world: GgWorld<D, R>): void;
 }

package/dist/base/components/rendering/i-renderer.component.d.ts

@@ -26,6 +26,10 @@ export declare abstract class IRendererComponent<D, R, VTypeDoc extends VisualTy
     entity: IEntity | null;
     /** Specifies the options for the renderer. */
     readonly rendererOptions: RendererOptions;
+    /** get flag whether renderer shows physics debugger view */
+    abstract get physicsDebugViewActive(): boolean;
+    /** turns on/off physics debugger view for this renderer */
+    abstract set physicsDebugViewActive(value: boolean);
     protected constructor(scene: IVisualSceneComponent<D, R, VTypeDoc>, canvas?: HTMLCanvasElement | undefined, options?: Partial<RendererOptions>);
     /**
      * Renders the scene.

package/dist/base/components/rendering/i-visual-scene.component.d.ts

@@ -1,10 +1,6 @@
-import { IDebugPhysicsDrawer } from '../../interfaces/i-debug-physics-drawer';
 import { IComponent } from '../i-component';
 import { VisualTypeDocRepo } from '../../gg-world';
 export interface IVisualSceneComponent<D, R, TypeDoc extends VisualTypeDocRepo<D, R> = VisualTypeDocRepo<D, R>> extends IComponent {
     readonly factory: TypeDoc['factory'];
-    readonly debugPhysicsDrawerClass?: {
-        new (): IDebugPhysicsDrawer<D, R, TypeDoc>;
-    };
     init(): Promise<void>;
 }

package/dist/base/entities/i-entity.d.ts

@@ -34,7 +34,7 @@ export declare abstract class IEntity<D = any, R = any, VTypeDoc extends VisualT
     /**
      * The flag whether entity should listen to ticks. If set to false, ticks will not be propagated to this entity
      * */
-    protected _active: boolean;
+    protected _selfActive: boolean;
     get active(): boolean;
     set active(value: boolean);
     parent: IEntity | null;

package/dist/base/entities/i-entity.js

@@ -26,7 +26,7 @@ export class IEntity {
         /**
          * The flag whether entity should listen to ticks. If set to false, ticks will not be propagated to this entity
          * */
-        this._active = true;
+        this._selfActive = true;
         this.parent = null;
         this._children = [];
         this._components = [];
@@ -43,10 +43,10 @@ export class IEntity {
         this._name = value;
     }
     get active() {
-        return this._active;
+        return this._selfActive && (!this.parent || this.parent.active);
     }
     set active(value) {
-        this._active = value;
+        this._selfActive = value;
     }
     get children() {
         return [...this._children];

package/dist/base/entities/i-renderer.entity.d.ts

@@ -23,6 +23,10 @@ export declare abstract class IRendererEntity<D, R, TypeDoc extends VisualTypeDo
      */
     get rendererSize(): Point2 | null;
     get rendererOptions(): RendererOptions;
+    /** get flag whether renderer shows physics debugger view */
+    get physicsDebugViewActive(): boolean;
+    /** turns on/off physics debugger view for this renderer */
+    set physicsDebugViewActive(value: boolean);
     /**
      Initializes a new instance of the BaseGgRenderer class.
      * @param renderer

package/dist/base/entities/i-renderer.entity.js

@@ -38,6 +38,14 @@ export class IRendererEntity extends IEntity {
     get rendererOptions() {
         return this.renderer.rendererOptions;
     }
+    /** get flag whether renderer shows physics debugger view */
+    get physicsDebugViewActive() {
+        return this.renderer.physicsDebugViewActive;
+    }
+    /** turns on/off physics debugger view for this renderer */
+    set physicsDebugViewActive(value) {
+        this.renderer.physicsDebugViewActive = value;
+    }
     onSpawned(world) {
         this._rendererSize$.next(null);
         if (this.rendererOptions.size == 'fullscreen' || typeof this.rendererOptions.size === 'function') {

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

@@ -34,6 +34,4 @@ 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;
-    get physicsDebugViewActive(): boolean;
-    set physicsDebugViewActive(value: boolean);
 }

package/dist/base/gg-world.js

@@ -7,7 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { GgGlobalClock, KeyboardInput, TickOrder, } from '../base';
+import { GgGlobalClock, IRendererEntity, KeyboardInput, TickOrder, } from '../base';
 export class GgWorld {
     constructor(visualScene, physicsWorld) {
         this.visualScene = visualScene;
@@ -30,13 +30,32 @@ export class GgWorld {
                 return '' + window.ggstatic.showStats;
             }), 'args: [0 or 1]; turn on/off stats. Default value is 0');
             window.ggstatic.registerConsoleCommand(this, 'ph_timescale', (...args) => __awaiter(this, void 0, void 0, function* () {
-                this.physicsWorld.timeScale = +args[0];
-                return JSON.stringify(this.physicsWorld.timeScale);
+                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* () {
-                this.physicsDebugViewActive = ['1', 'true', '+'].includes(args[0]);
-                return '' + this.physicsWorld.physicsDebugViewActive;
-            }), 'args: [0 or 1]; turn on/off physics debug view. Default value is 0');
+                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"');
         }
     }
     static get documentWorlds() {
@@ -56,7 +75,7 @@ export class GgWorld {
                         this.tickListeners[i].tick$.next([elapsed, delta]);
                     }
                 }
-                // run phycics simulation
+                // run physics simulation
                 this.physicsWorld.simulate(delta);
                 // emit tick to all remained entities
                 for (i; i < this.tickListeners.length; i++) {
@@ -126,24 +145,6 @@ export class GgWorld {
             entity.dispose();
         }
     }
-    get physicsDebugViewActive() {
-        return this.physicsWorld.physicsDebugViewActive;
-    }
-    set physicsDebugViewActive(value) {
-        if (this.physicsDebugViewActive === value) {
-            return;
-        }
-        if (value) {
-            const cls = this.visualScene.debugPhysicsDrawerClass;
-            if (!cls) {
-                throw new Error('Debug drawer is not available');
-            }
-            this.physicsWorld.startDebugger(this, new cls());
-        }
-        else {
-            this.physicsWorld.stopDebugger(this);
-        }
-    }
 }
 GgWorld.default_name_counter = 0;
 GgWorld._documentWorlds = [];

package/dist/base/index.d.ts

@@ -21,7 +21,6 @@ export * from './inputs/direction.keyboard.input';
 export * from './inputs/i-input';
 export * from './inputs/keyboard.input';
 export * from './inputs/mouse.input';
-export * from './interfaces/i-debug-physics-drawer';
 export * from './interfaces/i-positionable';
 export * from './models/axis-directions';
 export * from './models/body-options';

package/dist/base/index.js

@@ -21,7 +21,6 @@ export * from './inputs/direction.keyboard.input';
 export * from './inputs/i-input';
 export * from './inputs/keyboard.input';
 export * from './inputs/mouse.input';
-export * from './interfaces/i-debug-physics-drawer';
 export * from './interfaces/i-positionable';
 export * from './models/axis-directions';
 export * from './models/body-options';

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

@@ -7,3 +7,12 @@ export interface BodyOptions {
     ownCollisionGroups: CollisionGroup[] | 'all';
     interactWithCollisionGroups: CollisionGroup[] | 'all';
 }
+export declare type DebugBodySettings = {
+    shape: any;
+    ignoreTransform?: boolean;
+} & ({
+    type: 'RIGID_STATIC' | 'TRIGGER';
+} | {
+    type: 'RIGID_DYNAMIC';
+    sleeping: boolean;
+});

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

@@ -67,31 +67,39 @@ List of available commands: `.replace(/ /g, '&nbsp;') + `<span style="color:yell
         };
         document.getElementById('gg-console-close-icon').onmousedown = () => this.destroyUI();
         this.elements.input.onkeydown = event => {
-            if ((event === null || event === void 0 ? void 0 : event.keyCode) === 13) {
+            var _a;
+            if ((event === null || event === void 0 ? void 0 : event.code) === 'Enter') {
                 event.preventDefault();
                 this.onInput().then();
             }
-            else if ((event === null || event === void 0 ? void 0 : event.keyCode) === 38) {
+            else if ((event === null || event === void 0 ? void 0 : event.code) === 'ArrowUp') {
                 event.preventDefault();
                 this.onUsePreviousCommand();
             }
-            else if ((event === null || event === void 0 ? void 0 : event.keyCode) === 40) {
+            else if ((event === null || event === void 0 ? void 0 : event.code) === 'ArrowDown') {
                 event.preventDefault();
                 this.onUseNextCommand();
             }
+            else if ((event === null || event === void 0 ? void 0 : event.code) === 'Backspace') {
+                let input = (_a = this.elements) === null || _a === void 0 ? void 0 : _a.input;
+                if (input) {
+                    let value = input.value || '';
+                    // backspace pressed while input had completion selected.
+                    // Native logic will remove selected text (completion part), we remove one additional character
+                    if ((input.selectionStart || value.length) < value.length && input.selectionEnd == value.length) {
+                        this.elements.input.value = value.substring(0, input.selectionStart || value.length - 1);
+                    }
+                }
+            }
         };
         this.elements.input.oninput = event => {
             var _a;
             let value = ((_a = this.elements) === null || _a === void 0 ? void 0 : _a.input.value) || '';
-            // backspace
-            if (value.length > 0 && event.data === null) {
-                value = value.substring(0, value.length - 1);
-            }
             if (value.trim() === '') {
                 return;
             }
             let autocompletion = window.ggstatic.availableCommands.find((c) => c[0].startsWith(value));
-            if (autocompletion) {
+            if (autocompletion && autocompletion[0].length > value.length) {
                 this.elements.input.value = autocompletion[0];
                 this.elements.input.setSelectionRange(value.length, this.elements.input.value.length);
             }

package/dist/dev/gg-debugger.ui.d.ts

@@ -6,6 +6,10 @@ export declare class GgDebuggerUI {
     private currentWorld;
     setShowStats(selectedWorld: GgWorld<any, any>, value: boolean): void;
     private debugControlsRemoved$;
+    private viewUpdated$;
     get showDebugControls(): boolean;
     setShowDebugControls(selectedWorld: GgWorld<any, any>, value: boolean): void;
+    private snapshot;
+    private makeSnapshot;
+    private renderControls;
 }

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

@@ -1,6 +1,22 @@
-import { createInlineTickController } from '../base';
-import { fromEvent, Subject, takeUntil } from 'rxjs';
+import { createInlineTickController, IRendererEntity } from '../base';
+import { animationFrameScheduler, fromEvent, of, Subject, takeUntil } from 'rxjs';
 import Stats from 'stats.js';
+import { repeat } from 'rxjs/operators';
+const snapshotEqual = (a, b) => {
+    if (a.timeScale !== b.timeScale)
+        return false;
+    if (a.renderers.length !== b.renderers.length)
+        return false;
+    for (let i = 0; i < a.renderers.length; i++) {
+        if (a.renderers[i].name !== b.renderers[i].name)
+            return false;
+        if (a.renderers[i].entity !== b.renderers[i].entity)
+            return false;
+        if (a.renderers[i].physicsDebugViewActive !== b.renderers[i].physicsDebugViewActive)
+            return false;
+    }
+    return true;
+};
 export class GgDebuggerUI {
     constructor() {
         this.ui = {
@@ -10,6 +26,11 @@ export class GgDebuggerUI {
         this.statsRemoved$ = new Subject();
         this.currentWorld = null;
         this.debugControlsRemoved$ = new Subject();
+        this.viewUpdated$ = new Subject();
+        this.snapshot = {
+            timeScale: 1,
+            renderers: [],
+        };
     }
     get showStats() {
         return !!this.ui.stats;
@@ -64,48 +85,78 @@ export class GgDebuggerUI {
         this.currentWorld = selectedWorld;
         if (value) {
             const debugControlsContainer = document.createElement('div');
+            document.body.appendChild(debugControlsContainer);
             this.ui.debugControlsContainer = debugControlsContainer;
-            const debugLabelCss = "style='display:flex;align-items:center;margin:0.25rem;'";
             debugControlsContainer.style.cssText =
                 'position:fixed;top:48px;right:0;opacity:0.9;z-index:9999;background-color:#333;color:white;display:flex;flex-direction:column';
-            debugControlsContainer.innerHTML = `
+            this.snapshot = this.makeSnapshot();
+            this.renderControls(debugControlsContainer);
+            of(undefined, animationFrameScheduler)
+                .pipe(repeat(), takeUntil(this.debugControlsRemoved$))
+                .subscribe(() => {
+                const newSnapshot = this.makeSnapshot();
+                if (!snapshotEqual(this.snapshot, newSnapshot)) {
+                    this.snapshot = newSnapshot;
+                    this.renderControls(debugControlsContainer);
+                }
+            });
+        }
+        else {
+            this.debugControlsRemoved$.next();
+            document.body.removeChild(this.ui.debugControlsContainer);
+            this.ui.debugControlsContainer = null;
+        }
+    }
+    makeSnapshot() {
+        return {
+            timeScale: this.currentWorld.worldClock.timeScale,
+            renderers: this.currentWorld.children
+                .filter(x => x instanceof IRendererEntity)
+                .map(r => ({
+                name: r.name,
+                entity: r,
+                physicsDebugViewActive: r.physicsDebugViewActive,
+            })),
+        };
+    }
+    renderControls(debugControlsContainer) {
+        const debugLabelCss = "style='display:flex;align-items:center;margin:0.25rem;'";
+        let html = '';
+        for (const { entity, physicsDebugViewActive } of this.snapshot.renderers) {
+            html += `
       <div ${debugLabelCss}>
-        <input type='checkbox' name='checkbox' id='physics_debugger_checkbox_id' value='1'${this.currentWorld.physicsWorld.physicsDebugViewActive ? ' checked' : ''}>
-        <label for='physics_debugger_checkbox_id' style='user-select: none;'>Show physics bodies in scene</label>
+        <input type='checkbox' name='checkbox' id='physics_debugger_checkbox_id_${entity.name}' value='1'${physicsDebugViewActive ? ' checked' : ''}>
+        <label for='physics_debugger_checkbox_id_${entity.name}' style='user-select: none;'>Physics debugger${this.snapshot.renderers.length > 1 ? ' (' + entity.name + ')' : ''}</label>
       </div>`;
-            // <div ${debugLabelCss}>
-            //   <input id="time_scale_slider" type="range" min="0" max="10" step="0.1" style="flex-grow:1" value="${
-            //      this.currentWorld.physicsWorld.timeScale
-            //   }"/>
-            //   <label for="time_scale_slider" style="user-select: none;">Time scale</label>
-            // </div>`;
-            document.body.appendChild(debugControlsContainer);
-            fromEvent(document.getElementById('physics_debugger_checkbox_id'), 'change')
-                .pipe(takeUntil(this.debugControlsRemoved$))
+        }
+        html += `
+      <div ${debugLabelCss}>
+        <input id='time_scale_slider' type='range' min='0' max='5' step='0.01' style='flex-grow:1' value='${this.snapshot.timeScale}'/>
+        <label for='time_scale_slider' style='user-select: none;'>Time scale</label>
+      </div>`;
+        debugControlsContainer.innerHTML = html;
+        this.viewUpdated$.next();
+        for (const { entity } of this.snapshot.renderers) {
+            fromEvent(document.getElementById('physics_debugger_checkbox_id_' + entity.name), 'change')
+                .pipe(takeUntil(this.debugControlsRemoved$), takeUntil(this.viewUpdated$))
                 .subscribe(e => {
                 try {
-                    this.currentWorld.physicsDebugViewActive = e.target.checked;
+                    entity.physicsDebugViewActive = e.target.checked;
                 }
                 catch (err) {
                     console.error(err);
                 }
-                e.target.checked = this.currentWorld.physicsDebugViewActive;
             });
-            // fromEvent(document.getElementById('time_scale_slider')! as HTMLInputElement, 'change')
-            //   .pipe(takeUntil(this.debugControlsRemoved$))
-            //   .subscribe(e => {
-            //     try {
-            //        this.currentWorld.physicsWorld.timeScale = +(e.target as HTMLInputElement).value;
-            //     } catch (err) {
-            //       console.error(err);
-            //     }
-            //     (e.target as HTMLInputElement).value = '' + ( this.currentWorld.physicsWorld.timeScale || 1);
-            //   });
-        }
-        else {
-            this.debugControlsRemoved$.next();
-            document.body.removeChild(this.ui.debugControlsContainer);
-            this.ui.debugControlsContainer = null;
         }
+        fromEvent(document.getElementById('time_scale_slider'), 'change')
+            .pipe(takeUntil(this.debugControlsRemoved$), takeUntil(this.viewUpdated$))
+            .subscribe(e => {
+            try {
+                this.currentWorld.worldClock.timeScale = +e.target.value;
+            }
+            catch (err) {
+                console.error(err);
+            }
+        });
     }
 }

package/dist/dev/gg-static.d.ts

@@ -1,6 +1,5 @@
 import { GgWorld } from '../base';
 export declare class GgStatic {
-    private static _instance;
     static get instance(): GgStatic;
     private readonly debuggerUI;
     private readonly consoleUI;

package/dist/dev/gg-static.js

@@ -51,10 +51,10 @@ export class GgStatic {
         }), 'args: [string]; select world by name');
     }
     static get instance() {
-        if (!GgStatic._instance) {
-            GgStatic._instance = new GgStatic();
+        if (!window.ggstatic) {
+            window.ggstatic = new GgStatic();
         }
-        return GgStatic._instance;
+        return window.ggstatic;
     }
     get devConsoleEnabled() {
         return this._devConsoleEnabled;
@@ -138,4 +138,3 @@ export class GgStatic {
         });
     }
 }
-window.ggstatic = GgStatic.instance;

package/package.json

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

package/dist/base/interfaces/i-debug-physics-drawer.d.ts

@@ -1,8 +0,0 @@
-import { IDisplayObjectComponent } from '../components/rendering/i-display-object.component';
-import { Point3 } from '../models/points';
-import { VisualTypeDocRepo } from '../gg-world';
-export interface IDebugPhysicsDrawer<D, R, TypeDoc extends VisualTypeDocRepo<D, R> = VisualTypeDocRepo<D, R>> extends IDisplayObjectComponent<D, R, TypeDoc> {
-    drawContactPoint(point: D, normal: D, color?: Point3): void;
-    drawLine(from: D, to: D, color?: Point3): void;
-    update(): void;
-}

package/dist/base/interfaces/i-debug-physics-drawer.js

@@ -1 +0,0 @@
-export {};