@gg-web-engine/core 0.0.1 → 0.0.3

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.removed$)).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

@@ -9,10 +9,18 @@ export declare class Gg2dEntity extends GgPositionable2dEntity implements ITickL
     readonly objectBody: IGg2dBody | null;
     readonly tick$: Subject<[number, number]>;
     readonly tickOrder = 750;
-    private tickSub;
+    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

@@ -10,25 +10,27 @@ class Gg2dEntity extends gg_positionable_2d_entity_1.GgPositionable2dEntity {
         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);
+        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 +40,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 +52,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 +64,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 +104,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/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/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

@@ -17,7 +17,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

@@ -10,17 +10,22 @@ class Gg3dEntity extends gg_positionable_3d_entity_1.GgPositionable3dEntity {
         this.objectBody = objectBody;
         this.tick$ = new rxjs_1.Subject();
         this.tickOrder = 750;
-        if (objectBody && object3D) {
+        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 +73,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

@@ -7,7 +7,7 @@ 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;
@@ -33,19 +33,21 @@ export declare class Gg3dMapGraphEntity extends GgEntity implements ITickListene
     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

@@ -150,7 +150,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;