@gg-web-engine/core 0.0.37 → 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/entities/gg-car/gg-car.entity.js

@@ -163,15 +163,17 @@ export class GgCarEntity extends IRenderable3dEntity {
                     }
                 }
                 if (brake === 0) {
-                    this.raycastVehicle.applyTractionForce(force);
+                    this.raycastVehicle.applyTraction('front', force * this.carProperties.tractionBias);
+                    this.raycastVehicle.applyTraction('rear', force * (1 - this.carProperties.tractionBias));
                     this.raycastVehicle.applyBrake('both', 0);
                 }
                 else {
-                    this.raycastVehicle.applyTractionForce(0);
+                    this.raycastVehicle.applyTraction('both', 0);
                     this.raycastVehicle.applyBrake('front', brake * this.carProperties.brake.frontAxleForce);
                     this.raycastVehicle.applyBrake('rear', brake * this.carProperties.brake.rearAxleForce);
                 }
                 if (this.handBrake) {
+                    this.raycastVehicle.applyTraction('rear', 0);
                     this.raycastVehicle.applyBrake('rear', this.carProperties.brake.handbrakeForce);
                 }
             }

package/dist/3d/entities/map-graph-3d.entity.d.ts

@@ -40,7 +40,7 @@ export declare type Gg3dMapGraphEntityOptions = {
 export declare class MapGraph3dEntity<VTypeDoc extends VisualTypeDocRepo3D = VisualTypeDocRepo3D, PTypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> extends IRenderable3dEntity<VTypeDoc, PTypeDoc> {
     readonly mapGraph: MapGraph;
     readonly tickOrder = TickOrder.POST_RENDERING;
-    readonly loaderCursorEntity$: BehaviorSubject<IPositionable3d | null>;
+    readonly loaderCursorEntity$: BehaviorSubject<(IEntity & IPositionable3d) | null>;
     readonly loaded: Map<MapGraphNodeType, (IEntity & IPositionable3d)[]>;
     private _initialLoadComplete$;
     get initialLoadComplete$(): Observable<boolean>;

package/dist/3d/entities/map-graph-3d.entity.js

@@ -7,7 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { BehaviorSubject, NEVER, startWith, Subject, switchMap } from 'rxjs';
+import { BehaviorSubject, NEVER, startWith, Subject, switchMap, takeUntil } from 'rxjs';
 import { distinctUntilChanged, map, tap, throttleTime } from 'rxjs/operators';
 import { Graph, Qtrn, TickOrder } from '../../base';
 import { IRenderable3dEntity } from './i-renderable-3d.entity';
@@ -108,11 +108,10 @@ export class MapGraph3dEntity extends IRenderable3dEntity {
     }
     onSpawned(world) {
         super.onSpawned(world);
-        // TODO takeUntil removed from world?
         this.loaderCursorEntity$
-            .pipe(switchMap(entity => entity
+            .pipe(takeUntil(this._onRemoved$), switchMap(entity => entity
             ? this.tick$.pipe(startWith(null), // map will perform initial loading even if world not started yet. Handy to preload map
-            throttleTime(1000), map(() => entity.position))
+            takeUntil(entity.onRemoved$), throttleTime(1000), map(() => entity.position))
             : NEVER), map(pos => this.mapGraph.getNearestDummy(this.mapGraphNodes, pos)), tap(node => this._nearestDummy$.next(node)), distinctUntilChanged())
             .subscribe(currentChunk => {
             let haveToBeLoaded = new Set();

package/dist/3d/entities/raycast-vehicle-3d.entity.d.ts

@@ -22,8 +22,12 @@ export declare type RVEntityAxleOptions = {
     axlePosition: number;
     axleHeight: number;
 } & RVEntitySharedWheelOptions;
+export declare enum RVEntityTractionBias {
+    FWD = 1,
+    RWD = 0
+}
 export declare type RVEntityProperties = {
-    typeOfDrive: 'RWD' | 'FWD' | '4WD';
+    tractionBias: RVEntityTractionBias | number;
     suspension: SuspensionOptions;
 } & ({
     wheelBase: {
@@ -42,21 +46,20 @@ export declare type RVEntityProperties = {
 export declare class RaycastVehicle3dEntity<VTypeDoc extends VisualTypeDocRepo3D = VisualTypeDocRepo3D, PTypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> extends Entity3d<VTypeDoc, PTypeDoc> {
     readonly carProperties: RVEntityProperties;
     readonly chassis3D: IDisplayObject3dComponent | null;
-    readonly chassisBody: IRaycastVehicleComponent;
+    readonly vehicleComponent: IRaycastVehicleComponent;
     protected readonly wheels: (Entity3d<VTypeDoc, PTypeDoc> | null)[];
     protected readonly wheelLocalRotation: (Point4 | null)[];
     protected readonly frontWheelsIndices: number[];
     protected readonly rearWheelsIndices: number[];
-    protected readonly tractionWheelIndices: number[];
     getSpeed(): number;
     readonly tractionWheelRadius: number;
     private _steeringAngle;
     get steeringAngle(): number;
     set steeringAngle(value: number);
-    applyTractionForce(force: number): void;
+    applyTraction(axle: 'front' | 'rear' | 'both', force: number): void;
     applyBrake(axle: 'front' | 'rear' | 'both', force: number): void;
     /** car mesh and physics body direction has to be pointing: y front, z up*/
-    constructor(carProperties: RVEntityProperties, chassis3D: IDisplayObject3dComponent | null, chassisBody: IRaycastVehicleComponent);
+    constructor(carProperties: RVEntityProperties, chassis3D: IDisplayObject3dComponent | null, vehicleComponent: IRaycastVehicleComponent);
     protected runTransformBinding(objectBody: IRigidBody3dComponent, object3D: IDisplayObject3dComponent): void;
     get isTouchingGround(): boolean;
     resetTo(options?: {

package/dist/3d/entities/raycast-vehicle-3d.entity.js

@@ -1,5 +1,10 @@
 import { Box, Pnt3, Qtrn } from '../../base';
 import { Entity3d } from './entity-3d';
+export var RVEntityTractionBias;
+(function (RVEntityTractionBias) {
+    RVEntityTractionBias[RVEntityTractionBias["FWD"] = 1] = "FWD";
+    RVEntityTractionBias[RVEntityTractionBias["RWD"] = 0] = "RWD";
+})(RVEntityTractionBias || (RVEntityTractionBias = {}));
 const wheeelDefaults = {
     tyreWidth: 0.3,
     tyreRadius: 0.4,
@@ -9,16 +14,15 @@ const wheeelDefaults = {
 };
 export class RaycastVehicle3dEntity extends Entity3d {
     /** car mesh and physics body direction has to be pointing: y front, z up*/
-    constructor(carProperties, chassis3D, chassisBody) {
-        super(chassis3D, chassisBody);
+    constructor(carProperties, chassis3D, vehicleComponent) {
+        super(chassis3D, vehicleComponent);
         this.carProperties = carProperties;
         this.chassis3D = chassis3D;
-        this.chassisBody = chassisBody;
+        this.vehicleComponent = vehicleComponent;
         this.wheels = [];
         this.wheelLocalRotation = [];
         this.frontWheelsIndices = [];
         this.rearWheelsIndices = [];
-        this.tractionWheelIndices = [];
         this._steeringAngle = 0;
         let wheelFullOptions = 'wheelBase' in carProperties
             ? [
@@ -47,15 +51,11 @@ export class RaycastVehicle3dEntity extends Entity3d {
             else {
                 this.rearWheelsIndices.push(i);
             }
-            if (wheelOpts.isFront && this.carProperties.typeOfDrive != 'RWD') {
-                this.tractionWheelIndices.push(i);
-            }
-            if (!wheelOpts.isFront && this.carProperties.typeOfDrive != 'FWD') {
-                this.tractionWheelIndices.push(i);
-            }
-            this.chassisBody.addWheel(wheelOpts, this.carProperties.suspension);
+            this.vehicleComponent.addWheel(wheelOpts, this.carProperties.suspension);
         });
-        this.tractionWheelRadius = wheelFullOptions[this.tractionWheelIndices[0]].tyreRadius;
+        this.tractionWheelRadius =
+            wheelFullOptions[this.frontWheelsIndices[0]].tyreRadius * this.carProperties.tractionBias +
+                wheelFullOptions[this.rearWheelsIndices[0]].tyreRadius * (1 - this.carProperties.tractionBias);
         for (const options of wheelFullOptions) {
             const display = options.display || {};
             if (!display.displayObject) {
@@ -96,11 +96,11 @@ export class RaycastVehicle3dEntity extends Entity3d {
             this.wheels.push(new Entity3d(entity));
         }
         this.addChildren(...this.wheels.filter(x => !!x));
-        this.chassisBody.entity = this;
+        this.vehicleComponent.entity = this;
     }
     // m/s
     getSpeed() {
-        return this.chassisBody.wheelSpeed;
+        return this.vehicleComponent.wheelSpeed;
     }
     get steeringAngle() {
         return this._steeringAngle;
@@ -109,17 +109,22 @@ export class RaycastVehicle3dEntity extends Entity3d {
         if (this._steeringAngle != value) {
             this._steeringAngle = value;
         }
-        this.frontWheelsIndices.forEach(index => this.chassisBody.setSteering(index, value));
+        this.frontWheelsIndices.forEach(index => this.vehicleComponent.setSteering(index, value));
     }
-    applyTractionForce(force) {
-        this.tractionWheelIndices.forEach(index => this.chassisBody.applyEngineForce(index, force));
+    applyTraction(axle, force) {
+        if (axle != 'rear') {
+            this.frontWheelsIndices.forEach(index => this.vehicleComponent.applyEngineForce(index, force));
+        }
+        if (axle != 'front') {
+            this.rearWheelsIndices.forEach(index => this.vehicleComponent.applyEngineForce(index, force));
+        }
     }
     applyBrake(axle, force) {
         if (axle != 'rear') {
-            this.frontWheelsIndices.forEach(index => this.chassisBody.applyBrake(index, force));
+            this.frontWheelsIndices.forEach(index => this.vehicleComponent.applyBrake(index, force));
         }
         if (axle != 'front') {
-            this.rearWheelsIndices.forEach(index => this.chassisBody.applyBrake(index, force));
+            this.rearWheelsIndices.forEach(index => this.vehicleComponent.applyBrake(index, force));
         }
     }
     runTransformBinding(objectBody, object3D) {
@@ -128,7 +133,7 @@ export class RaycastVehicle3dEntity extends Entity3d {
             if (!wheel) {
                 continue;
             }
-            let { position, rotation } = this.chassisBody.getWheelTransform(i);
+            let { position, rotation } = this.vehicleComponent.getWheelTransform(i);
             if (this.wheelLocalRotation[i]) {
                 rotation = Qtrn.combineRotations(rotation, this.wheelLocalRotation[i]);
             }
@@ -138,14 +143,24 @@ export class RaycastVehicle3dEntity extends Entity3d {
     }
     get isTouchingGround() {
         // is at least one traction wheel touches the ground
-        return this.tractionWheelIndices
-            .map(i => this.chassisBody.isWheelTouchesGround(i))
-            .reduce((prev, cur) => cur || prev, false);
+        if (this.carProperties.tractionBias != RVEntityTractionBias.RWD) {
+            if (this.frontWheelsIndices
+                .map(i => this.vehicleComponent.isWheelTouchesGround(i))
+                .reduce((prev, cur) => cur || prev, false)) {
+                return true;
+            }
+        }
+        if (this.carProperties.tractionBias != RVEntityTractionBias.FWD) {
+            if (this.rearWheelsIndices
+                .map(i => this.vehicleComponent.isWheelTouchesGround(i))
+                .reduce((prev, cur) => cur || prev, false)) {
+                return true;
+            }
+        }
+        return false;
     }
     // TODO delete and let game application do all the steps
     resetTo(options = {}) {
-        this.chassisBody.resetMotion();
-        this.chassisBody.resetSuspension();
         if (options.position) {
             this.position = options.position;
         }
@@ -153,5 +168,6 @@ export class RaycastVehicle3dEntity extends Entity3d {
             this.rotation = options.rotation;
         }
         this.steeringAngle = 0;
+        this.vehicleComponent.resetMotion();
     }
 }

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