@gg-web-engine/core 0.0.2 → 0.0.4

package/dist/2d/entities/controllers/entity-2d-positioning.animator.d.ts

@@ -0,0 +1,16 @@
+import { AnimationFunction, AnimationMixer } from '../../../base/entities/controllers/animation-mixer';
+import { Point2 } from '../../../base/models/points';
+import { Gg2dEntity } from '../gg-2d-entity';
+import { Gg2dWorld } from '../../gg-2d-world';
+declare type Positioning2d = {
+    position: Point2;
+    rotation: number;
+};
+export declare class Entity2dPositioningAnimator<T extends Gg2dEntity = Gg2dEntity> extends AnimationMixer<Positioning2d> {
+    entity: T;
+    protected _animationFunction: AnimationFunction<Positioning2d>;
+    constructor(entity: T, _animationFunction: AnimationFunction<Positioning2d>);
+    onSpawned(world: Gg2dWorld): void;
+    protected applyPositioning(value: Positioning2d): void;
+}
+export {};

package/dist/2d/entities/controllers/entity-2d-positioning.animator.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Entity2dPositioningAnimator = void 0;
+const animation_mixer_1 = require("../../../base/entities/controllers/animation-mixer");
+const rxjs_1 = require("rxjs");
+const point2_1 = require("../../../base/math/point2");
+const numbers_1 = require("../../../base/math/numbers");
+class Entity2dPositioningAnimator extends animation_mixer_1.AnimationMixer {
+    constructor(entity, _animationFunction) {
+        super(_animationFunction, (a, b, t) => ({
+            position: point2_1.Pnt2.lerp(a.position, b.position, t),
+            rotation: (0, numbers_1.lerpNumber)(a.rotation, b.rotation, t),
+        }));
+        this.entity = entity;
+        this._animationFunction = _animationFunction;
+    }
+    onSpawned(world) {
+        super.onSpawned(world);
+        this.value$.pipe((0, rxjs_1.takeUntil)(this._onRemoved$)).subscribe(value => this.applyPositioning(value));
+    }
+    applyPositioning(value) {
+        this.entity.position = value.position;
+        this.entity.rotation = value.rotation;
+    }
+}
+exports.Entity2dPositioningAnimator = Entity2dPositioningAnimator;

package/dist/2d/entities/gg-2d-entity.d.ts

@@ -1,18 +1,24 @@
-import { Subject } from 'rxjs';
 import { GgPositionable2dEntity } from './gg-positionable-2d-entity';
-import { ITickListener } from '../../base/entities/interfaces/i-tick-listener';
 import { Point2 } from '../../base/models/points';
 import { IGg2dBody, IGg2dObject } from '../interfaces';
 import { Gg2dWorld } from '../gg-2d-world';
-export declare class Gg2dEntity extends GgPositionable2dEntity implements ITickListener {
+import { GGTickOrder } from '../../base/entities/gg-entity';
+export declare class Gg2dEntity extends GgPositionable2dEntity {
     readonly object2D: IGg2dObject | null;
     readonly objectBody: IGg2dBody | null;
-    readonly tick$: Subject<[number, number]>;
-    readonly tickOrder = 750;
-    private tickSub;
+    readonly tickOrder = GGTickOrder.OBJECTS_BINDING;
+    get position(): Point2;
     set position(value: Point2);
+    get rotation(): number;
     set rotation(value: number);
+    get scale(): Point2;
     set scale(value: Point2);
+    get visible(): boolean;
+    set visible(value: boolean);
+    /**
+     * Synchronize physics body transform with entity (and object2d if defined)
+     * */
+    protected runTransformBinding(objectBody: IGg2dBody, object2D: IGg2dObject | null): void;
     constructor(object2D: IGg2dObject | null, objectBody: IGg2dBody | null);
     onSpawned(world: Gg2dWorld): void;
     onRemoved(): void;

package/dist/2d/entities/gg-2d-entity.js

@@ -1,34 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Gg2dEntity = void 0;
-const rxjs_1 = require("rxjs");
 const gg_positionable_2d_entity_1 = require("./gg-positionable-2d-entity");
+const gg_entity_1 = require("../../base/entities/gg-entity");
 class Gg2dEntity extends gg_positionable_2d_entity_1.GgPositionable2dEntity {
     constructor(object2D, objectBody) {
         super();
         this.object2D = object2D;
         this.objectBody = objectBody;
-        this.tick$ = new rxjs_1.Subject();
-        this.tickOrder = 750;
-        this.tickSub = null;
-        if (objectBody && object2D) {
-            this.tickSub = this.tick$.subscribe(() => {
-                // bind physics body transform to object transform
-                const pos = objectBody.position;
-                const rot = objectBody.rotation;
-                object2D.position = pos;
-                object2D.rotation = rot;
-                this._position$.next(pos);
-                this._rotation$.next(rot);
+        this.tickOrder = gg_entity_1.GGTickOrder.OBJECTS_BINDING;
+        if (objectBody) {
+            objectBody.entity = this;
+            this.tick$.subscribe(() => {
+                this.runTransformBinding(objectBody, object2D);
             });
+            this.runTransformBinding(objectBody, object2D);
+            this.name = objectBody.name;
         }
-        else if (!objectBody && !object2D) {
-            throw new Error('Cannot create entity without a sprite and a body');
+        else if (object2D) {
+            super.position = object2D.position;
+            super.rotation = object2D.rotation;
+            super.scale = object2D.scale;
+            this.name = object2D.name;
         }
-        if (objectBody) {
-            objectBody.entity = this;
+        else {
+            throw new Error('Cannot create entity without an object2D and a body');
         }
     }
+    get position() {
+        return super.position;
+    }
     set position(value) {
         if (this.object2D) {
             this.object2D.position = value;
@@ -38,6 +39,9 @@ class Gg2dEntity extends gg_positionable_2d_entity_1.GgPositionable2dEntity {
         }
         super.position = value;
     }
+    get rotation() {
+        return super.rotation;
+    }
     set rotation(value) {
         if (this.object2D) {
             this.object2D.rotation = value;
@@ -47,6 +51,9 @@ class Gg2dEntity extends gg_positionable_2d_entity_1.GgPositionable2dEntity {
         }
         super.rotation = value;
     }
+    get scale() {
+        return super.scale;
+    }
     set scale(value) {
         if (this.object2D) {
             this.object2D.scale = value;
@@ -56,6 +63,33 @@ class Gg2dEntity extends gg_positionable_2d_entity_1.GgPositionable2dEntity {
         }
         super.scale = value;
     }
+    get visible() {
+        var _a;
+        return !!((_a = this.object2D) === null || _a === void 0 ? void 0 : _a.visible);
+    }
+    set visible(value) {
+        if (this.object2D) {
+            this.object2D.visible = value;
+        }
+        for (const entity of this._children) {
+            if (entity instanceof Gg2dEntity) {
+                entity.visible = value;
+            }
+        }
+    }
+    /**
+     * Synchronize physics body transform with entity (and object2d if defined)
+     * */
+    runTransformBinding(objectBody, object2D) {
+        const pos = objectBody.position;
+        const quat = objectBody.rotation;
+        if (object2D) {
+            object2D.position = pos;
+            object2D.rotation = quat;
+        }
+        this._position$.next(pos);
+        this._rotation$.next(quat);
+    }
     onSpawned(world) {
         var _a, _b;
         super.onSpawned(world);
@@ -69,10 +103,8 @@ class Gg2dEntity extends gg_positionable_2d_entity_1.GgPositionable2dEntity {
         super.onRemoved();
     }
     dispose() {
-        var _a;
         super.dispose();
-        (_a = this.tickSub) === null || _a === void 0 ? void 0 : _a.unsubscribe();
-        this.tickSub = null;
+        this.tick$.unsubscribe();
         if (this.object2D) {
             this.object2D.dispose();
         }

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

@@ -1,9 +1,12 @@
 import { GgWorld } from '../base/gg-world';
 import { Point2 } from '../base/models/points';
 import { IGg2dPhysicsWorld, IGg2dVisualScene } from './interfaces';
+import { BodyShape2DDescriptor } from './models/shapes';
+import { Gg2dEntity } from './entities/gg-2d-entity';
 export declare class Gg2dWorld<V extends IGg2dVisualScene = IGg2dVisualScene, P extends IGg2dPhysicsWorld = IGg2dPhysicsWorld> extends GgWorld<Point2, number, V, P> {
     readonly visualScene: V;
     readonly physicsWorld: P;
     protected readonly consoleEnabled: boolean;
     constructor(visualScene: V, physicsWorld: P, consoleEnabled?: boolean);
+    addPrimitiveRigidBody(descr: BodyShape2DDescriptor, position?: Point2, rotation?: number): Gg2dEntity;
 }

package/dist/2d/gg-2d-world.js

@@ -11,6 +11,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Gg2dWorld = void 0;
 const gg_world_1 = require("../base/gg-world");
+const gg_2d_entity_1 = require("./entities/gg-2d-entity");
 class Gg2dWorld extends gg_world_1.GgWorld {
     constructor(visualScene, physicsWorld, consoleEnabled = false) {
         super(visualScene, physicsWorld, consoleEnabled);
@@ -30,5 +31,15 @@ class Gg2dWorld extends gg_world_1.GgWorld {
                 '{x: 0, y: value}, 2 arguments set the whole vector. Default value is "9.82" or "0 9.82"');
         }
     }
+    addPrimitiveRigidBody(descr, position = {
+        x: 0,
+        y: 0,
+    }, rotation = 0) {
+        const entity = new gg_2d_entity_1.Gg2dEntity(this.visualScene.factory.createPrimitive(descr.shape), this.physicsWorld.factory.createRigidBody(descr));
+        entity.position = position;
+        entity.rotation = rotation;
+        this.addEntity(entity);
+        return entity;
+    }
 }
 exports.Gg2dWorld = Gg2dWorld;

package/dist/3d/controllers/car-keyboard.controller.d.ts

@@ -1,25 +1,25 @@
-import { BehaviorSubject } from 'rxjs';
+import { BehaviorSubject, Subject } from 'rxjs';
 import { IController } from '../../base/controllers/i-controller';
 import { KeyboardController } from '../../base/controllers/keyboard.controller';
 import { Gg3dRaycastVehicleEntity } from '../entities/gg-3d-raycast-vehicle.entity';
 import { DirectionKeymap } from '../../base/controllers/common';
-declare type CarKeyboardControllerOptions = {
+export declare type CarKeyboardControllerOptions = {
     keymap: DirectionKeymap;
     gearUpDownKeys: [string, string];
 };
 export declare class CarKeyboardController implements IController {
-    private readonly keyboardController;
-    private readonly options;
-    private readonly x$;
-    private readonly y$;
-    private lastX;
-    private readonly stop$;
+    protected readonly keyboardController: KeyboardController;
+    protected readonly options: CarKeyboardControllerOptions;
+    protected readonly x$: BehaviorSubject<number>;
+    protected readonly y$: BehaviorSubject<number>;
+    protected lastX: number;
+    protected readonly stop$: Subject<void>;
     protected readonly car$: BehaviorSubject<Gg3dRaycastVehicleEntity>;
-    pairTickerPipe: import("rxjs").UnaryFunction<import("rxjs").Observable<number>, import("rxjs").Observable<number>>;
     set car(value: Gg3dRaycastVehicleEntity);
     get car(): Gg3dRaycastVehicleEntity;
+    switchingGearsEnabled: boolean;
+    pairTickerPipe: import("rxjs").UnaryFunction<import("rxjs").Observable<number>, import("rxjs").Observable<number>>;
     constructor(keyboardController: KeyboardController, car: Gg3dRaycastVehicleEntity, options?: CarKeyboardControllerOptions);
     start(): Promise<void>;
     stop(): Promise<void>;
 }
-export {};

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

@@ -28,6 +28,7 @@ class CarKeyboardController {
         this.lastX = 0;
         this.stop$ = new rxjs_1.Subject();
         this.car$ = new rxjs_1.BehaviorSubject(null);
+        this.switchingGearsEnabled = true;
         this.pairTickerPipe = (0, rxjs_1.pipe)((0, operators_1.startWith)(0), (0, operators_1.pairwise)(), (0, operators_1.map)(([beforeValue, afterValue]) => [this.lastX, afterValue]), (0, operators_1.switchMap)(([beforeValue, afterValue]) => (0, rxjs_1.interval)(TICKER_INTERVAL).pipe((0, operators_1.take)(TICKER_MAX_STEPS), (0, operators_1.map)(count => ++count), (0, operators_1.map)(count => beforeValue * ((TICKER_MAX_STEPS - count) / TICKER_MAX_STEPS) + afterValue * (count / TICKER_MAX_STEPS)), (0, operators_1.tap)(x => {
             this.lastX = x;
         }))));
@@ -42,6 +43,26 @@ class CarKeyboardController {
     start() {
         return __awaiter(this, void 0, void 0, function* () {
             let moveDirection = {};
+            this.keyboardController
+                .bind(this.options.gearUpDownKeys[0])
+                .pipe((0, rxjs_1.takeUntil)(this.stop$), (0, rxjs_1.filter)(x => this.switchingGearsEnabled && !!x))
+                .subscribe(() => {
+                if (this.car$.getValue() &&
+                    (!this.car$.getValue().carProperties.transmission.isAuto || this.car$.getValue().gear <= 0)) {
+                    this.car$.getValue().gear++;
+                }
+            });
+            this.keyboardController
+                .bind(this.options.gearUpDownKeys[1])
+                .pipe((0, rxjs_1.takeUntil)(this.stop$), (0, rxjs_1.filter)(x => this.switchingGearsEnabled && !!x))
+                .subscribe(() => {
+                if (this.car$.getValue().carProperties.transmission.isAuto && this.car.gear > 1) {
+                    this.car$.getValue().gear = 0;
+                }
+                else {
+                    this.car$.getValue().gear--;
+                }
+            });
             (0, common_1.bindDirectionKeys)(this.keyboardController, this.options.keymap)
                 .pipe((0, rxjs_1.takeUntil)(this.stop$))
                 .subscribe(d => {
@@ -67,26 +88,6 @@ class CarKeyboardController {
                 this.car$.getValue().setXAxisControlValue(x);
                 this.car$.getValue().setYAxisControlValue(y);
             });
-            this.keyboardController
-                .bind(this.options.gearUpDownKeys[0])
-                .pipe((0, rxjs_1.takeUntil)(this.stop$), (0, rxjs_1.filter)(x => !!x))
-                .subscribe(() => {
-                if (this.car$.getValue() &&
-                    (!this.car$.getValue().carProperties.transmission.isAuto || this.car$.getValue().gear <= 0)) {
-                    this.car$.getValue().gear++;
-                }
-            });
-            this.keyboardController
-                .bind(this.options.gearUpDownKeys[1])
-                .pipe((0, rxjs_1.takeUntil)(this.stop$), (0, rxjs_1.filter)(x => !!x))
-                .subscribe(() => {
-                if (this.car$.getValue().carProperties.transmission.isAuto && this.car.gear > 1) {
-                    this.car$.getValue().gear = 0;
-                }
-                else {
-                    this.car$.getValue().gear--;
-                }
-            });
         });
     }
     stop() {

package/dist/3d/controllers/free-camera.controller.d.ts

@@ -1,9 +1,10 @@
 import { IController } from '../../base/controllers/i-controller';
-import { MouseControllerOptions } from '../../base/controllers/mouse.controller';
+import { Subject } from 'rxjs';
+import { MouseController, MouseControllerOptions } from '../../base/controllers/mouse.controller';
 import { Gg3dCameraEntity } from '../entities/gg-3d-camera.entity';
 import { KeyboardController } from '../../base/controllers/keyboard.controller';
 import { DirectionKeymap } from '../../base/controllers/common';
-declare type FreeCameraControllerOptions = {
+export declare type FreeCameraControllerOptions = {
     keymap: DirectionKeymap;
     movementOptions: {
         speed: number;
@@ -11,13 +12,12 @@ declare type FreeCameraControllerOptions = {
     mouseOptions: MouseControllerOptions;
 };
 export declare class FreeCameraController implements IController {
-    private readonly keyboardController;
-    private readonly camera;
-    private readonly options;
-    private readonly mController;
-    private readonly stop$;
+    protected readonly keyboardController: KeyboardController;
+    protected readonly camera: Gg3dCameraEntity;
+    protected readonly options: FreeCameraControllerOptions;
+    protected readonly mController: MouseController;
+    protected readonly stop$: Subject<void>;
     constructor(keyboardController: KeyboardController, camera: Gg3dCameraEntity, options?: FreeCameraControllerOptions);
     start(): Promise<void>;
     stop(unlockPointer?: boolean): Promise<void>;
 }
-export {};

package/dist/3d/entities/controllers/animators/camera-3d.animator.d.ts

@@ -0,0 +1,17 @@
+import { AnimationFunction, AnimationMixer } from '../../../../base/entities/controllers/animation-mixer';
+import { Point3 } from '../../../../base/models/points';
+import { Gg3dWorld } from '../../../gg-3d-world';
+import { Gg3dCameraEntity } from '../../gg-3d-camera.entity';
+export declare type Camera3dAnimationArgs = {
+    position: Point3;
+    target: Point3;
+    up?: Point3;
+    fov?: number;
+};
+export declare class Camera3dAnimator extends AnimationMixer<Camera3dAnimationArgs> {
+    entity: Gg3dCameraEntity;
+    protected _animationFunction: AnimationFunction<Camera3dAnimationArgs>;
+    constructor(entity: Gg3dCameraEntity, _animationFunction: AnimationFunction<Camera3dAnimationArgs>);
+    onSpawned(world: Gg3dWorld): void;
+    protected applyPositioning(value: Camera3dAnimationArgs): void;
+}

package/dist/3d/entities/controllers/animators/camera-3d.animator.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Camera3dAnimator = void 0;
+const animation_mixer_1 = require("../../../../base/entities/controllers/animation-mixer");
+const point3_1 = require("../../../../base/math/point3");
+const quaternion_1 = require("../../../../base/math/quaternion");
+const rxjs_1 = require("rxjs");
+const numbers_1 = require("../../../../base/math/numbers");
+const defaultUp = { x: 0, y: 0, z: 1 };
+const defaultFov = 65;
+class Camera3dAnimator extends animation_mixer_1.AnimationMixer {
+    constructor(entity, _animationFunction) {
+        super(_animationFunction, (a, b, t) => ({
+            position: point3_1.Pnt3.lerp(a.position, b.position, t),
+            target: point3_1.Pnt3.lerp(a.target, b.target, t),
+            up: point3_1.Pnt3.lerp(a.up || defaultUp, b.up || defaultUp, t),
+            fov: (0, numbers_1.lerpNumber)(a.fov || defaultFov, b.fov || defaultFov, t),
+        }));
+        this.entity = entity;
+        this._animationFunction = _animationFunction;
+    }
+    onSpawned(world) {
+        super.onSpawned(world);
+        this.value$.pipe((0, rxjs_1.takeUntil)(this._onRemoved$)).subscribe(value => this.applyPositioning(value));
+    }
+    applyPositioning(value) {
+        this.entity.position = value.position;
+        this.entity.rotation = quaternion_1.Qtrn.lookAt(value.position, value.target, value.up || defaultUp);
+        this.entity.fov = value.fov || defaultFov;
+    }
+}
+exports.Camera3dAnimator = Camera3dAnimator;

package/dist/3d/entities/controllers/animators/entity-3d-positioning.animator.d.ts

@@ -0,0 +1,16 @@
+import { Gg3dEntity } from '../../gg-3d-entity';
+import { AnimationFunction, AnimationMixer } from '../../../../base/entities/controllers/animation-mixer';
+import { Point3, Point4 } from '../../../../base/models/points';
+import { Gg3dWorld } from '../../../gg-3d-world';
+declare type Positioning3d = {
+    position: Point3;
+    rotation: Point4;
+};
+export declare class Entity3dPositioningAnimator<T extends Gg3dEntity = Gg3dEntity> extends AnimationMixer<Positioning3d> {
+    entity: T;
+    protected _animationFunction: AnimationFunction<Positioning3d>;
+    constructor(entity: T, _animationFunction: AnimationFunction<Positioning3d>);
+    onSpawned(world: Gg3dWorld): void;
+    protected applyPositioning(value: Positioning3d): void;
+}
+export {};

package/dist/3d/entities/controllers/animators/entity-3d-positioning.animator.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Entity3dPositioningAnimator = void 0;
+const animation_mixer_1 = require("../../../../base/entities/controllers/animation-mixer");
+const point3_1 = require("../../../../base/math/point3");
+const quaternion_1 = require("../../../../base/math/quaternion");
+const rxjs_1 = require("rxjs");
+class Entity3dPositioningAnimator extends animation_mixer_1.AnimationMixer {
+    constructor(entity, _animationFunction) {
+        super(_animationFunction, (a, b, t) => ({
+            position: point3_1.Pnt3.lerp(a.position, b.position, t),
+            rotation: quaternion_1.Qtrn.slerp(a.rotation, b.rotation, t),
+        }));
+        this.entity = entity;
+        this._animationFunction = _animationFunction;
+    }
+    onSpawned(world) {
+        super.onSpawned(world);
+        this.value$.pipe((0, rxjs_1.takeUntil)(this._onRemoved$)).subscribe(value => this.applyPositioning(value));
+    }
+    applyPositioning(value) {
+        this.entity.position = value.position;
+        this.entity.rotation = value.rotation;
+    }
+}
+exports.Entity3dPositioningAnimator = Entity3dPositioningAnimator;

package/dist/3d/entities/controllers/camera-3d.animator.d.ts

@@ -0,0 +1,17 @@
+import { AnimationFunction, AnimationMixer } from '../../../base/entities/controllers/animation-mixer';
+import { Point3 } from '../../../base/models/points';
+import { Gg3dWorld } from '../../gg-3d-world';
+import { Gg3dCameraEntity } from '../gg-3d-camera.entity';
+export declare type Camera3dAnimationArgs = {
+    position: Point3;
+    target: Point3;
+    up?: Point3;
+    fov?: number;
+};
+export declare class Camera3dAnimator extends AnimationMixer<Camera3dAnimationArgs> {
+    entity: Gg3dCameraEntity;
+    protected _animationFunction: AnimationFunction<Camera3dAnimationArgs>;
+    constructor(entity: Gg3dCameraEntity, _animationFunction: AnimationFunction<Camera3dAnimationArgs>);
+    onSpawned(world: Gg3dWorld): void;
+    protected applyPositioning(value: Camera3dAnimationArgs): void;
+}

package/dist/3d/entities/controllers/camera-3d.animator.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Camera3dAnimator = void 0;
+const animation_mixer_1 = require("../../../base/entities/controllers/animation-mixer");
+const point3_1 = require("../../../base/math/point3");
+const quaternion_1 = require("../../../base/math/quaternion");
+const rxjs_1 = require("rxjs");
+const numbers_1 = require("../../../base/math/numbers");
+const defaultUp = { x: 0, y: 0, z: 1 };
+const defaultFov = 65;
+class Camera3dAnimator extends animation_mixer_1.AnimationMixer {
+    constructor(entity, _animationFunction) {
+        super(_animationFunction, (a, b, t) => ({
+            position: point3_1.Pnt3.lerp(a.position, b.position, t),
+            target: point3_1.Pnt3.lerp(a.target, b.target, t),
+            up: point3_1.Pnt3.lerp(a.up || defaultUp, b.up || defaultUp, t),
+            fov: (0, numbers_1.lerpNumber)(a.fov || defaultFov, b.fov || defaultFov, t),
+        }));
+        this.entity = entity;
+        this._animationFunction = _animationFunction;
+    }
+    onSpawned(world) {
+        super.onSpawned(world);
+        this.value$.pipe((0, rxjs_1.takeUntil)(this.removed$)).subscribe(value => this.applyPositioning(value));
+    }
+    applyPositioning(value) {
+        this.entity.position = value.position;
+        this.entity.rotation = quaternion_1.Qtrn.lookAt(value.position, value.target, value.up || defaultUp);
+        this.entity.fov = value.fov || defaultFov;
+    }
+}
+exports.Camera3dAnimator = Camera3dAnimator;

package/dist/3d/entities/controllers/entity-3d-positioning.animator.d.ts

@@ -0,0 +1,16 @@
+import { Gg3dEntity } from '../gg-3d-entity';
+import { AnimationFunction, AnimationMixer } from '../../../base/entities/controllers/animation-mixer';
+import { Point3, Point4 } from '../../../base/models/points';
+import { Gg3dWorld } from '../../gg-3d-world';
+declare type Positioning3d = {
+    position: Point3;
+    rotation: Point4;
+};
+export declare class Entity3dPositioningAnimator<T extends Gg3dEntity = Gg3dEntity> extends AnimationMixer<Positioning3d> {
+    entity: T;
+    protected _animationFunction: AnimationFunction<Positioning3d>;
+    constructor(entity: T, _animationFunction: AnimationFunction<Positioning3d>);
+    onSpawned(world: Gg3dWorld): void;
+    protected applyPositioning(value: Positioning3d): void;
+}
+export {};

package/dist/3d/entities/controllers/entity-3d-positioning.animator.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Entity3dPositioningAnimator = void 0;
+const animation_mixer_1 = require("../../../base/entities/controllers/animation-mixer");
+const point3_1 = require("../../../base/math/point3");
+const quaternion_1 = require("../../../base/math/quaternion");
+const rxjs_1 = require("rxjs");
+class Entity3dPositioningAnimator extends animation_mixer_1.AnimationMixer {
+    constructor(entity, _animationFunction) {
+        super(_animationFunction, (a, b, t) => ({
+            position: point3_1.Pnt3.lerp(a.position, b.position, t),
+            rotation: quaternion_1.Qtrn.slerp(a.rotation, b.rotation, t),
+        }));
+        this.entity = entity;
+        this._animationFunction = _animationFunction;
+    }
+    onSpawned(world) {
+        super.onSpawned(world);
+        this.value$.pipe((0, rxjs_1.takeUntil)(this.removed$)).subscribe(value => this.applyPositioning(value));
+    }
+    applyPositioning(value) {
+        this.entity.position = value.position;
+        this.entity.rotation = value.rotation;
+    }
+}
+exports.Entity3dPositioningAnimator = Entity3dPositioningAnimator;

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

@@ -0,0 +1,25 @@
+import { BehaviorSubject } from 'rxjs';
+import { KeyboardInput } from '../../../../base/inputs/keyboard.input';
+import { Gg3dRaycastVehicleEntity } from '../../gg-3d-raycast-vehicle.entity';
+import { DirectionKeyboardInput, DirectionKeyboardKeymap } from '../../../../base/inputs/direction.keyboard-input';
+import { GgEntity, GGTickOrder } from '../../../../base/entities/gg-entity';
+import { GgWorld } from '../../../../base/gg-world';
+export declare type CarKeyboardControllerOptions = {
+    keymap: DirectionKeyboardKeymap;
+    gearUpDownKeys: [string, string];
+};
+export declare class CarKeyboardHandlingController extends GgEntity {
+    protected readonly keyboard: KeyboardInput;
+    car: Gg3dRaycastVehicleEntity | null;
+    protected readonly options: CarKeyboardControllerOptions;
+    readonly tickOrder = GGTickOrder.INPUT_CONTROLLERS;
+    protected readonly directionsInput: DirectionKeyboardInput;
+    protected readonly x$: BehaviorSubject<number>;
+    protected readonly y$: BehaviorSubject<number>;
+    protected lastX: number;
+    switchingGearsEnabled: boolean;
+    pairTickerPipe: import("rxjs").UnaryFunction<import("rxjs").Observable<number>, import("rxjs").Observable<number>>;
+    constructor(keyboard: KeyboardInput, car: Gg3dRaycastVehicleEntity | null, options?: CarKeyboardControllerOptions);
+    onSpawned(world: GgWorld<any, any>): Promise<void>;
+    onRemoved(): Promise<void>;
+}