@gg-web-engine/core 0.0.2 → 0.0.4

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

@@ -0,0 +1,105 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CarKeyboardHandlingController = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const direction_keyboard_input_1 = require("../../../../base/inputs/direction.keyboard-input");
+const gg_entity_1 = require("../../../../base/entities/gg-entity");
+// TODO pass as settings
+// TODO smooth y?
+const TICKER_INTERVAL = 16;
+const TICKER_MAX_STEPS = 10;
+class CarKeyboardHandlingController extends gg_entity_1.GgEntity {
+    constructor(keyboard, car, options = { keymap: 'arrows', gearUpDownKeys: ['KeyA', 'KeyZ'] }) {
+        super();
+        this.keyboard = keyboard;
+        this.car = car;
+        this.options = options;
+        this.tickOrder = gg_entity_1.GGTickOrder.INPUT_CONTROLLERS;
+        // emits values -1 - 1; -1 = full turn left; 1 = full turn right
+        this.x$ = new rxjs_1.BehaviorSubject(0);
+        // emits values -1 - 1; -1 = full brake; 1 = full acceleration
+        this.y$ = new rxjs_1.BehaviorSubject(0);
+        this.lastX = 0;
+        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;
+        }))));
+        this.directionsInput = new direction_keyboard_input_1.DirectionKeyboardInput(keyboard, options.keymap);
+    }
+    onSpawned(world) {
+        const _super = Object.create(null, {
+            onSpawned: { get: () => super.onSpawned }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            _super.onSpawned.call(this, world);
+            let moveDirection = {};
+            this.keyboard
+                .bind(this.options.gearUpDownKeys[0])
+                .pipe((0, rxjs_1.takeUntil)(this._onRemoved$), (0, rxjs_1.filter)(x => this.switchingGearsEnabled && !!x))
+                .subscribe(() => {
+                if (this.car && (!this.car.carProperties.transmission.isAuto || this.car.gear <= 0)) {
+                    this.car.gear++;
+                }
+            });
+            this.keyboard
+                .bind(this.options.gearUpDownKeys[1])
+                .pipe((0, rxjs_1.takeUntil)(this._onRemoved$), (0, rxjs_1.filter)(x => this.switchingGearsEnabled && !!x))
+                .subscribe(() => {
+                if (this.car) {
+                    if (this.car.carProperties.transmission.isAuto && this.car.gear > 1) {
+                        this.car.gear = 0;
+                    }
+                    else {
+                        this.car.gear--;
+                    }
+                }
+            });
+            this.directionsInput.output$.pipe((0, rxjs_1.takeUntil)(this._onRemoved$)).subscribe(d => {
+                moveDirection = d;
+            });
+            this.tick$
+                .pipe((0, rxjs_1.takeUntil)(this._onRemoved$), (0, operators_1.map)(() => {
+                const direction = [0, 0];
+                if (moveDirection.leftRight !== undefined)
+                    direction[0] = moveDirection.leftRight ? -1 : 1;
+                if (moveDirection.upDown !== undefined)
+                    direction[1] = moveDirection.upDown ? 1 : -1;
+                return direction;
+            }))
+                .subscribe(([x, y]) => {
+                this.x$.next(x);
+                this.y$.next(y);
+            });
+            (0, rxjs_1.combineLatest)([
+                this.x$.pipe((0, rxjs_1.takeUntil)(this._onRemoved$), (0, operators_1.distinctUntilChanged)(), this.pairTickerPipe),
+                this.y$.pipe((0, rxjs_1.takeUntil)(this._onRemoved$), (0, operators_1.distinctUntilChanged)()),
+            ]).subscribe(([x, y]) => {
+                if (this.car) {
+                    this.car.setXAxisControlValue(x);
+                    this.car.setYAxisControlValue(y);
+                }
+            });
+            yield this.directionsInput.start();
+        });
+    }
+    onRemoved() {
+        const _super = Object.create(null, {
+            onRemoved: { get: () => super.onRemoved }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            yield _super.onRemoved.call(this);
+            yield this.directionsInput.stop();
+        });
+    }
+}
+exports.CarKeyboardHandlingController = CarKeyboardHandlingController;

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

@@ -0,0 +1,54 @@
+import { MouseInput, MouseInputOptions } from '../../../../base/inputs/mouse.input';
+import { Gg3dCameraEntity } from '../../gg-3d-camera.entity';
+import { KeyboardInput } from '../../../../base/inputs/keyboard.input';
+import { DirectionKeyboardInput, DirectionKeyboardKeymap } from '../../../../base/inputs/direction.keyboard-input';
+import { GgEntity, GGTickOrder } from '../../../../base/entities/gg-entity';
+import { GgWorld } from '../../../../base/gg-world';
+/**
+ * Options for configuring a FreeCameraInput controller.
+ */
+export declare type FreeCameraControllerOptions = {
+    /**
+     * A keymap for controlling camera movement, where each key corresponds to a movement direction.
+     */
+    keymap: DirectionKeyboardKeymap;
+    /**
+     * Options for configuring camera movement.
+     */
+    movementOptions: {
+        /**
+         * The speed of camera movement.
+         */
+        speed: number;
+    };
+    /**
+     * Options for configuring mouse input.
+     */
+    mouseOptions: MouseInputOptions;
+};
+/**
+ * A controller for a free-moving camera.
+ */
+export declare class FreeCameraController extends GgEntity {
+    protected readonly keyboard: KeyboardInput;
+    protected readonly camera: Gg3dCameraEntity;
+    protected readonly options: FreeCameraControllerOptions;
+    readonly tickOrder = GGTickOrder.INPUT_CONTROLLERS;
+    /**
+     * The mouse input controller used for camera rotation.
+     */
+    protected readonly mouseInput: MouseInput;
+    /**
+     * The keyboard input controller used for camera movement.
+     */
+    protected readonly directionsInput: DirectionKeyboardInput;
+    /**
+     * Creates a new FreeCameraInput instance.
+     * @param keyboard The keyboard input controller to use for camera movement.
+     * @param camera The camera entity to control.
+     * @param options Optional configuration options for the controller.
+     */
+    constructor(keyboard: KeyboardInput, camera: Gg3dCameraEntity, options?: FreeCameraControllerOptions);
+    onSpawned(world: GgWorld<any, any>): Promise<void>;
+    onRemoved(): Promise<void>;
+}

package/dist/3d/entities/controllers/input/free-camera.controller.js

@@ -0,0 +1,102 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FreeCameraController = void 0;
+const rxjs_1 = require("rxjs");
+const mouse_input_1 = require("../../../../base/inputs/mouse.input");
+const point3_1 = require("../../../../base/math/point3");
+const point2_1 = require("../../../../base/math/point2");
+const quaternion_1 = require("../../../../base/math/quaternion");
+const direction_keyboard_input_1 = require("../../../../base/inputs/direction.keyboard-input");
+const gg_entity_1 = require("../../../../base/entities/gg-entity");
+/**
+ * A controller for a free-moving camera.
+ */
+class FreeCameraController extends gg_entity_1.GgEntity {
+    /**
+     * Creates a new FreeCameraInput instance.
+     * @param keyboard The keyboard input controller to use for camera movement.
+     * @param camera The camera entity to control.
+     * @param options Optional configuration options for the controller.
+     */
+    constructor(keyboard, camera, options = {
+        keymap: 'wasd',
+        movementOptions: { speed: 0.5 },
+        mouseOptions: {},
+    }) {
+        super();
+        this.keyboard = keyboard;
+        this.camera = camera;
+        this.options = options;
+        this.tickOrder = gg_entity_1.GGTickOrder.INPUT_CONTROLLERS;
+        this.mouseInput = new mouse_input_1.MouseInput(options.mouseOptions);
+        this.directionsInput = new direction_keyboard_input_1.DirectionKeyboardInput(keyboard, options.keymap);
+    }
+    onSpawned(world) {
+        const _super = Object.create(null, {
+            onSpawned: { get: () => super.onSpawned }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            yield _super.onSpawned.call(this, world);
+            // Subscribe to keyboard input for movement controls
+            let controls = { direction: {}, rest: [] };
+            const keys = ['KeyE', 'KeyQ'];
+            if (this.camera.object3D.supportsFov) {
+                keys.push('KeyZ', 'KeyC');
+            }
+            this.directionsInput.output$.pipe((0, rxjs_1.takeUntil)(this._onRemoved$)).subscribe(d => {
+                controls.direction = d;
+            });
+            (0, rxjs_1.combineLatest)(keys.map(c => this.keyboard.bind(c)))
+                .pipe((0, rxjs_1.takeUntil)(this._onRemoved$))
+                .subscribe((d) => {
+                controls.rest = d;
+            });
+            // Subscribe to mouse input for camera rotation
+            let rotationDelta = { x: 0, y: 0 };
+            this.mouseInput.delta$.pipe((0, rxjs_1.takeUntil)(this._onRemoved$)).subscribe(delta => {
+                rotationDelta = point2_1.Pnt2.add(rotationDelta, delta);
+            });
+            // Setup updating camera position and rotation based on input
+            this.camera.tick$.pipe((0, rxjs_1.takeUntil)(this._onRemoved$)).subscribe(() => {
+                let translateVector = { x: 0, y: 0, z: 0 };
+                const [u, d, zo, zi] = controls.rest;
+                if (controls.direction.upDown !== undefined)
+                    translateVector.z = controls.direction.upDown ? -1 : 1;
+                if (controls.direction.leftRight !== undefined)
+                    translateVector.x = controls.direction.leftRight ? -1 : 1;
+                if (u != d)
+                    translateVector.y = d ? -1 : 1;
+                if (zo != zi)
+                    this.camera.object3D.fov += zo ? 1 : -1;
+                this.camera.position = point3_1.Pnt3.add(this.camera.position, point3_1.Pnt3.rot(point3_1.Pnt3.scalarMult(point3_1.Pnt3.norm(translateVector), this.options.movementOptions.speed), this.camera.rotation));
+                if (rotationDelta.x != 0 || rotationDelta.y != 0) {
+                    this.camera.rotation = quaternion_1.Qtrn.combineRotations(quaternion_1.Qtrn.fromAngle({ x: 0, y: 0, z: 1 }, -rotationDelta.x / 300), this.camera.rotation, quaternion_1.Qtrn.fromAngle({ x: 1, y: 0, z: 0 }, -rotationDelta.y / 300));
+                    rotationDelta = { x: 0, y: 0 };
+                }
+            });
+            // start input
+            yield this.mouseInput.start();
+            yield this.directionsInput.start();
+        });
+    }
+    onRemoved() {
+        const _super = Object.create(null, {
+            onRemoved: { get: () => super.onRemoved }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            yield _super.onRemoved.call(this);
+            yield this.mouseInput.stop(true);
+            yield this.directionsInput.stop();
+        });
+    }
+}
+exports.FreeCameraController = FreeCameraController;

package/dist/3d/entities/gg-3d-camera.entity.d.ts

@@ -3,5 +3,7 @@ import { Gg3dEntity } from './gg-3d-entity';
 export declare class Gg3dCameraEntity<T extends IGg3dCamera = IGg3dCamera> extends Gg3dEntity {
     readonly object3D: T;
     readonly objectBody: IGg3dBody | null;
+    get fov(): number;
+    set fov(value: number);
     constructor(object3D: T, objectBody?: IGg3dBody | null);
 }

package/dist/3d/entities/gg-3d-camera.entity.js

@@ -8,5 +8,11 @@ class Gg3dCameraEntity extends gg_3d_entity_1.Gg3dEntity {
         this.object3D = object3D;
         this.objectBody = objectBody;
     }
+    get fov() {
+        return this.object3D.fov;
+    }
+    set fov(value) {
+        this.object3D.fov = value;
+    }
 }
 exports.Gg3dCameraEntity = Gg3dCameraEntity;

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

@@ -1,14 +1,12 @@
-import { Subject } from 'rxjs';
 import { GgPositionable3dEntity } from './gg-positionable-3d-entity';
-import { ITickListener } from '../../base/entities/interfaces/i-tick-listener';
 import { Point3, Point4 } from '../../base/models/points';
 import { Gg3dWorld } from '../gg-3d-world';
 import { IGg3dBody, IGg3dObject } from '../interfaces';
-export declare class Gg3dEntity extends GgPositionable3dEntity implements ITickListener {
+import { GGTickOrder } from '../../base/entities/gg-entity';
+export declare class Gg3dEntity extends GgPositionable3dEntity {
     readonly object3D: IGg3dObject | null;
     readonly objectBody: IGg3dBody | null;
-    readonly tick$: Subject<[number, number]>;
-    readonly tickOrder = 750;
+    readonly tickOrder = GGTickOrder.OBJECTS_BINDING;
     get position(): Point3;
     set position(value: Point3);
     get rotation(): Point4;
@@ -17,7 +15,10 @@ export declare class Gg3dEntity extends GgPositionable3dEntity implements ITickL
     set scale(value: Point3);
     get visible(): boolean;
     set visible(value: boolean);
-    protected runTransformBinding(objectBody: IGg3dBody, object3D: IGg3dObject): void;
+    /**
+     * Synchronize physics body transform with entity (and mesh if defined)
+     * */
+    protected runTransformBinding(objectBody: IGg3dBody, object3D: IGg3dObject | null): void;
     constructor(object3D: IGg3dObject | null, objectBody?: IGg3dBody | null);
     onSpawned(world: Gg3dWorld): void;
     onRemoved(): void;

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

@@ -1,26 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Gg3dEntity = void 0;
-const rxjs_1 = require("rxjs");
 const gg_positionable_3d_entity_1 = require("./gg-positionable-3d-entity");
+const gg_entity_1 = require("../../base/entities/gg-entity");
 class Gg3dEntity extends gg_positionable_3d_entity_1.GgPositionable3dEntity {
     constructor(object3D, objectBody = null) {
         super();
         this.object3D = object3D;
         this.objectBody = objectBody;
-        this.tick$ = new rxjs_1.Subject();
-        this.tickOrder = 750;
-        if (objectBody && object3D) {
+        this.tickOrder = gg_entity_1.GGTickOrder.OBJECTS_BINDING;
+        if (objectBody) {
+            objectBody.entity = this;
             this.tick$.subscribe(() => {
                 this.runTransformBinding(objectBody, object3D);
             });
             this.runTransformBinding(objectBody, object3D);
+            this.name = objectBody.name;
         }
-        else if (!objectBody && !object3D) {
-            throw new Error('Cannot create entity without a mesh and a body');
+        else if (object3D) {
+            super.position = object3D.position;
+            super.rotation = object3D.rotation;
+            super.scale = object3D.scale;
+            this.name = object3D.name;
         }
-        if (objectBody) {
-            objectBody.entity = this;
+        else {
+            throw new Error('Cannot create entity without a mesh and a body');
         }
     }
     get position() {
@@ -68,17 +72,21 @@ class Gg3dEntity extends gg_positionable_3d_entity_1.GgPositionable3dEntity {
             this.object3D.visible = value;
         }
         for (const entity of this._children) {
-            if (entity instanceof Gg3dEntity && entity.object3D) {
-                entity.object3D.visible = value;
+            if (entity instanceof Gg3dEntity) {
+                entity.visible = value;
             }
         }
     }
+    /**
+     * Synchronize physics body transform with entity (and mesh if defined)
+     * */
     runTransformBinding(objectBody, object3D) {
-        // bind physics body transform to mesh transform
         const pos = objectBody.position;
         const quat = objectBody.rotation;
-        object3D.position = pos;
-        object3D.rotation = quat;
+        if (object3D) {
+            object3D.position = pos;
+            object3D.rotation = quat;
+        }
         this._position$.next(pos);
         this._rotation$.next(quat);
     }

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

@@ -1,13 +1,12 @@
 import { BehaviorSubject, Observable, Subject } from 'rxjs';
 import { Point3, Point4 } from '../../base/models/points';
 import { Graph } from '../../base/data-structures/graph';
-import { GgEntity } from '../../base/entities/gg-entity';
-import { ITickListener } from '../../base/entities/interfaces/i-tick-listener';
+import { GgEntity, GGTickOrder } from '../../base/entities/gg-entity';
 import { GgPositionable3dEntity } from './gg-positionable-3d-entity';
 import { Gg3dWorld } from '../gg-3d-world';
 import { Gg3dEntity } from './gg-3d-entity';
 import { LoadOptions, LoadResultWithProps } from '../loader';
-declare type MapGraphNodeType = {
+export declare type MapGraphNodeType = {
     path: string;
     position: Point3;
     rotation?: Point4;
@@ -23,29 +22,30 @@ export declare type Gg3dMapGraphEntityOptions = {
     loadDepth: number;
     inertia: number;
 };
-export declare class Gg3dMapGraphEntity extends GgEntity implements ITickListener {
+export declare class Gg3dMapGraphEntity extends GgEntity {
     readonly mapGraph: MapGraph;
-    readonly tick$: Subject<[number, number]>;
-    readonly tickOrder = 1500;
+    readonly tickOrder = GGTickOrder.POST_RENDERING;
     readonly loaderCursorEntity$: BehaviorSubject<GgPositionable3dEntity | null>;
     readonly loaded: Map<MapGraphNodeType, GgPositionable3dEntity[]>;
     private _initialLoadComplete$;
     get initialLoadComplete$(): Observable<boolean>;
     private _nearestDummy$;
     get nearestDummy(): Graph<MapGraphNodeType> | null;
-    private _chunkLoaded$;
+    protected _chunkLoaded$: Subject<[LoadResultWithProps, {
+        position: Point3;
+        rotation: Point4;
+    }]>;
     get chunkLoaded$(): Observable<[LoadResultWithProps, {
         position: Point3;
         rotation: Point4;
     }]>;
     get world(): Gg3dWorld | null;
     protected _world: Gg3dWorld | null;
-    private readonly mapGraphNodes;
+    protected readonly mapGraphNodes: MapGraph[];
     protected readonly options: Gg3dMapGraphEntityOptions;
     constructor(mapGraph: MapGraph, options?: Partial<Gg3dMapGraphEntityOptions>);
     onSpawned(world: Gg3dWorld): void;
     onRemoved(): void;
-    protected loadChunk(node: MapGraphNodeType): Promise<Gg3dEntity[]>;
+    protected loadChunk(node: MapGraphNodeType): Promise<[Gg3dEntity[], LoadResultWithProps]>;
     protected disposeChunk(node: MapGraphNodeType): void;
 }
-export {};

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

@@ -69,8 +69,7 @@ class Gg3dMapGraphEntity extends gg_entity_1.GgEntity {
     constructor(mapGraph, options = {}) {
         super();
         this.mapGraph = mapGraph;
-        this.tick$ = new rxjs_1.Subject();
-        this.tickOrder = 1500;
+        this.tickOrder = gg_entity_1.GGTickOrder.POST_RENDERING;
         this.loaderCursorEntity$ = new rxjs_1.BehaviorSubject(null);
         this.loaded = new Map();
         this._initialLoadComplete$ = new rxjs_1.BehaviorSubject(false);
@@ -150,7 +149,7 @@ class Gg3dMapGraphEntity extends gg_entity_1.GgEntity {
                 loaded,
                 { position: node.position, rotation: node.rotation || { x: 0, y: 0, z: 0, w: 1 } },
             ]);
-            return entities;
+            return [entities, loaded];
         });
     }
     disposeChunk(node) {

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

@@ -2,6 +2,7 @@ import { Point3, Point4 } from '../../base/models/points';
 import { Gg3dEntity } from './gg-3d-entity';
 import { IGg3dBody, IGg3dObject, IGg3dRaycastVehicle } from '../interfaces';
 import { BehaviorSubject, Observable } from 'rxjs';
+import { GgPositionable3dEntity } from './gg-positionable-3d-entity';
 import { Gg3dWorld } from '../gg-3d-world';
 import { AxisDirection3 } from '../../base/models/axis-directions';
 export declare type WheelOptions = {
@@ -52,9 +53,9 @@ export declare class Gg3dRaycastVehicleEntity extends Gg3dEntity {
     readonly chassisBody: IGg3dRaycastVehicle;
     readonly wheelObject: IGg3dObject | null;
     readonly wheelObjectDirection: AxisDirection3;
-    private readonly wheels;
-    private readonly wheelLocalRotation;
-    private readonly wheelLocalTranslation;
+    protected readonly wheels: (GgPositionable3dEntity | null)[];
+    protected readonly wheelLocalRotation: (Point4 | null)[];
+    protected readonly wheelLocalTranslation: Point3[];
     protected readonly frontWheelsIndices: number[];
     protected readonly tractionWheelIndices: number[];
     readonly tractionWheelRadius: number;
@@ -96,8 +97,8 @@ export declare class Gg3dRaycastVehicleEntity extends Gg3dEntity {
     constructor(carProperties: CarProperties, chassis3D: IGg3dObject | null, chassisBody: IGg3dRaycastVehicle, wheelObject?: IGg3dObject | null, wheelObjectDirection?: AxisDirection3);
     onSpawned(world: Gg3dWorld): void;
     protected runTransformBinding(objectBody: IGg3dBody, object3D: IGg3dObject): void;
-    private get isTouchingGround();
-    private updateEngine;
+    protected get isTouchingGround(): boolean;
+    protected updateEngine(delta: number): void;
     resetTo(options?: {
         position?: Point3;
         rotation?: Point4;

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

@@ -2,10 +2,13 @@ import { GgWorld } from '../base/gg-world';
 import { Point3, Point4 } from '../base/models/points';
 import { IGg3dPhysicsWorld, IGg3dVisualScene } from './interfaces';
 import { Gg3dLoader } from './loader';
+import { Gg3dEntity } from './entities/gg-3d-entity';
+import { BodyShape3DDescriptor } from './models/shapes';
 export declare class Gg3dWorld<V extends IGg3dVisualScene = IGg3dVisualScene, P extends IGg3dPhysicsWorld = IGg3dPhysicsWorld> extends GgWorld<Point3, Point4, V, P> {
     readonly visualScene: V;
     readonly physicsWorld: P;
     protected readonly consoleEnabled: boolean;
     readonly loader: Gg3dLoader;
     constructor(visualScene: V, physicsWorld: P, consoleEnabled?: boolean);
+    addPrimitiveRigidBody(descr: BodyShape3DDescriptor, position?: Point3, rotation?: Point4): Gg3dEntity;
 }

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

@@ -12,6 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Gg3dWorld = void 0;
 const gg_world_1 = require("../base/gg-world");
 const loader_1 = require("./loader");
+const gg_3d_entity_1 = require("./entities/gg-3d-entity");
 class Gg3dWorld extends gg_world_1.GgWorld {
     constructor(visualScene, physicsWorld, consoleEnabled = false) {
         super(visualScene, physicsWorld, consoleEnabled);
@@ -32,5 +33,16 @@ class Gg3dWorld extends gg_world_1.GgWorld {
                 '{x: 0, y: 0, z: -value}, 3 arguments set the whole vector. Default value is "9.82" or "0 0 -9.82"');
         }
     }
+    addPrimitiveRigidBody(descr, position = {
+        x: 0,
+        y: 0,
+        z: 0,
+    }, rotation = { x: 0, y: 0, z: 0, w: 1 }) {
+        const entity = new gg_3d_entity_1.Gg3dEntity(this.visualScene.factory.createPrimitive(descr.shape), this.physicsWorld.factory.createRigidBody(descr));
+        entity.position = position;
+        entity.rotation = rotation;
+        this.addEntity(entity);
+        return entity;
+    }
 }
 exports.Gg3dWorld = Gg3dWorld;

package/dist/3d/inputs/car-keyboard.input.d.ts

@@ -0,0 +1,25 @@
+import { BehaviorSubject } from 'rxjs';
+import { Input } from '../../base/inputs/input';
+import { KeyboardInput } from '../../base/inputs/keyboard.input';
+import { Gg3dRaycastVehicleEntity } from '../entities/gg-3d-raycast-vehicle.entity';
+import { DirectionKeyboardInput, DirectionKeyboardKeymap } from '../../base/inputs/direction.keyboard-input';
+export declare type CarKeyboardControllerOptions = {
+    keymap: DirectionKeyboardKeymap;
+    gearUpDownKeys: [string, string];
+};
+export declare class CarKeyboardInput extends Input {
+    protected readonly keyboard: KeyboardInput;
+    protected readonly options: CarKeyboardControllerOptions;
+    protected readonly directionsInput: DirectionKeyboardInput;
+    protected readonly x$: BehaviorSubject<number>;
+    protected readonly y$: BehaviorSubject<number>;
+    protected lastX: number;
+    protected readonly car$: BehaviorSubject<Gg3dRaycastVehicleEntity>;
+    set car(value: Gg3dRaycastVehicleEntity);
+    get car(): Gg3dRaycastVehicleEntity;
+    switchingGearsEnabled: boolean;
+    pairTickerPipe: import("rxjs").UnaryFunction<import("rxjs").Observable<number>, import("rxjs").Observable<number>>;
+    constructor(keyboard: KeyboardInput, car: Gg3dRaycastVehicleEntity, options?: CarKeyboardControllerOptions);
+    protected startInternal(): Promise<void>;
+    protected stopInternal(): Promise<void>;
+}

package/dist/3d/inputs/car-keyboard.input.js

@@ -0,0 +1,100 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CarKeyboardInput = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const input_1 = require("../../base/inputs/input");
+const direction_keyboard_input_1 = require("../../base/inputs/direction.keyboard-input");
+// TODO pass as settings
+// TODO smooth y?
+const TICKER_INTERVAL = 16;
+const TICKER_MAX_STEPS = 10;
+class CarKeyboardInput extends input_1.Input {
+    constructor(keyboard, car, options = { keymap: 'arrows', gearUpDownKeys: ['KeyA', 'KeyZ'] }) {
+        super();
+        this.keyboard = keyboard;
+        this.options = options;
+        // emits values -1 - 1; -1 = full turn left; 1 = full turn right
+        this.x$ = new rxjs_1.BehaviorSubject(0);
+        // emits values -1 - 1; -1 = full brake; 1 = full acceleration
+        this.y$ = new rxjs_1.BehaviorSubject(0);
+        this.lastX = 0;
+        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;
+        }))));
+        this.car$.next(car);
+        this.directionsInput = new direction_keyboard_input_1.DirectionKeyboardInput(keyboard, options.keymap);
+    }
+    set car(value) {
+        this.car$.next(value);
+    }
+    get car() {
+        return this.car$.getValue();
+    }
+    startInternal() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let moveDirection = {};
+            this.keyboard
+                .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.keyboard
+                .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--;
+                }
+            });
+            this.directionsInput.output$.pipe((0, rxjs_1.takeUntil)(this.stop$)).subscribe(d => {
+                moveDirection = d;
+            });
+            this.car$
+                .pipe((0, rxjs_1.takeUntil)(this.stop$), (0, operators_1.switchMap)(c => c.tick$), (0, rxjs_1.takeUntil)(this.stop$), (0, operators_1.map)(() => {
+                const direction = [0, 0];
+                if (moveDirection.leftRight !== undefined)
+                    direction[0] = moveDirection.leftRight ? -1 : 1;
+                if (moveDirection.upDown !== undefined)
+                    direction[1] = moveDirection.upDown ? 1 : -1;
+                return direction;
+            }))
+                .subscribe(([x, y]) => {
+                this.x$.next(x);
+                this.y$.next(y);
+            });
+            (0, rxjs_1.combineLatest)([
+                this.x$.pipe((0, rxjs_1.takeUntil)(this.stop$), (0, operators_1.distinctUntilChanged)(), this.pairTickerPipe),
+                this.y$.pipe((0, rxjs_1.takeUntil)(this.stop$), (0, operators_1.distinctUntilChanged)()),
+            ]).subscribe(([x, y]) => {
+                this.car$.getValue().setXAxisControlValue(x);
+                this.car$.getValue().setYAxisControlValue(y);
+            });
+            yield this.directionsInput.start();
+        });
+    }
+    stopInternal() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.directionsInput.stop();
+        });
+    }
+}
+exports.CarKeyboardInput = CarKeyboardInput;