@gg-web-engine/core 0.0.40 → 0.0.49

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

@@ -1,18 +1,37 @@
 import { GgWorld, IEntity, MouseInput, MouseInputOptions, MutableSpherical, Point3, TickOrder } from '../../../../base';
 import { Renderer3dEntity } from '../../renderer-3d.entity';
-export declare type OrbitCameraControllerOptions = {
+export type OrbitCameraControllerOptions = {
+    /**
+     * Options for configuring mouse input.
+     */
     mouseOptions: Partial<MouseInputOptions>;
+    /**
+     * Orbiting options. false disables orbiting, sensitivity fields are the speed in radians per 1000px mouse movement. 1 by default
+     */
     orbiting: {
         sensitivityX: number;
         sensitivityY: number;
     } | false;
+    /**
+     * An elasticity factor for orbiting. 0 by default (no elastic motion)
+     */
+    orbitingElasticity: number;
+    /**
+     * Zooming options. false disables zooming. Enabled by default
+     */
     zooming: {
         sensitivity: number;
     } | false;
+    /**
+     * Panning options. false disables panning. Enabled by default
+     */
     panning: {
         sensitivityX: number;
         sensitivityY: number;
     } | false;
+    /**
+     * Dollying options. false disables dollying. Enabled by default
+     */
     dollying: {
         sensitivity: number;
     } | false;
@@ -21,7 +40,7 @@ export declare class OrbitCameraController extends IEntity {
     protected readonly camera: Renderer3dEntity;
     readonly tickOrder = TickOrder.INPUT_CONTROLLERS;
     protected readonly options: OrbitCameraControllerOptions;
-    protected readonly mouseInput: MouseInput;
+    readonly mouseInput: MouseInput;
     protected spherical: MutableSpherical;
     target: Point3;
     get radius(): number;

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

@@ -7,26 +7,18 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { IEntity, MouseInput, MouseInputState, Pnt3, Qtrn, TickOrder, } from '../../../../base';
-import { filter, takeUntil } from 'rxjs';
+import { ggElastic, IEntity, MouseInput, MouseInputState, Pnt2, Pnt3, Qtrn, TickOrder, } from '../../../../base';
+import { BehaviorSubject, filter, takeUntil } from 'rxjs';
 import { map } from 'rxjs/operators';
 const DEFAULT_OPTIONS = {
     mouseOptions: {},
     orbiting: { sensitivityX: 1, sensitivityY: 1 },
+    orbitingElasticity: 0,
     zooming: { sensitivity: 1 },
     panning: { sensitivityX: 1, sensitivityY: 1 },
     dollying: { sensitivity: 1 },
 };
 export class OrbitCameraController extends IEntity {
-    constructor(camera, options = {}) {
-        super();
-        this.camera = camera;
-        this.tickOrder = TickOrder.INPUT_CONTROLLERS;
-        this.spherical = { phi: 0, radius: 10, theta: 0 };
-        this.target = Pnt3.O;
-        this.options = Object.assign(Object.assign({}, DEFAULT_OPTIONS), options);
-        this.mouseInput = new MouseInput(this.options.mouseOptions);
-    }
     get radius() {
         return this.spherical.radius;
     }
@@ -45,6 +37,15 @@ export class OrbitCameraController extends IEntity {
     set theta(value) {
         this.spherical.theta = value;
     }
+    constructor(camera, options = {}) {
+        super();
+        this.camera = camera;
+        this.tickOrder = TickOrder.INPUT_CONTROLLERS;
+        this.spherical = { phi: 0, radius: 10, theta: 0 };
+        this.target = Pnt3.O;
+        this.options = Object.assign(Object.assign({}, DEFAULT_OPTIONS), options);
+        this.mouseInput = new MouseInput(this.options.mouseOptions);
+    }
     onSpawned(world) {
         const _super = Object.create(null, {
             onSpawned: { get: () => super.onSpawned }
@@ -53,13 +54,29 @@ export class OrbitCameraController extends IEntity {
             yield _super.onSpawned.call(this, world);
             this.spherical = Pnt3.toSpherical(Pnt3.sub(this.camera.position, this.target));
             if (this.options.orbiting) {
-                this.mouseInput.delta$
-                    .pipe(takeUntil(this._onRemoved$), filter(() => this.mouseInput.state == MouseInputState.DRAG))
-                    .subscribe(delta => {
-                    this.spherical.theta -= (delta.x * this.options.orbiting.sensitivityX * Math.PI) / 900;
-                    this.spherical.phi -= (delta.y * this.options.orbiting.sensitivityY * Math.PI) / 900;
-                    this.spherical.phi = Math.max(0.000001, Math.min(Math.PI - 0.000001, this.spherical.phi));
-                });
+                let mouseDelta$ = this.mouseInput.delta$.pipe(takeUntil(this._onRemoved$), filter(() => this.mouseInput.state == MouseInputState.DRAG));
+                if (this.options.orbitingElasticity > 0) {
+                    const s$ = new BehaviorSubject(this.spherical);
+                    mouseDelta$.subscribe(delta => {
+                        const s = s$.getValue();
+                        s$.next({
+                            phi: Math.max(0.000001, Math.min(Math.PI - 0.000001, s.phi - (delta.y * this.options.orbiting.sensitivityY) / 1000)),
+                            theta: s.theta - (delta.x * this.options.orbiting.sensitivityX) / 1000,
+                            radius: 1,
+                        });
+                    });
+                    s$.pipe(takeUntil(this._onRemoved$), ggElastic(this.tick$, this.options.orbitingElasticity, (a, b, f) => ({ phi: a.phi + f * (b.phi - a.phi), theta: a.theta + f * (b.theta - a.theta), radius: 1 }), (a, b) => Pnt2.dist({ x: a.phi, y: a.theta }, { x: b.phi, y: b.theta }) < 0.0001)).subscribe(s => {
+                        this.spherical.theta = s.theta;
+                        this.spherical.phi = s.phi;
+                    });
+                }
+                else {
+                    mouseDelta$.subscribe(delta => {
+                        this.spherical.theta -= (delta.x * this.options.orbiting.sensitivityX) / 1000;
+                        this.spherical.phi -= (delta.y * this.options.orbiting.sensitivityY) / 1000;
+                        this.spherical.phi = Math.max(0.000001, Math.min(Math.PI - 0.000001, this.spherical.phi));
+                    });
+                }
             }
             if (this.options.zooming) {
                 this.mouseInput.wheel$.pipe(takeUntil(this._onRemoved$)).subscribe(delta => {

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

@@ -1,31 +1,6 @@
 import { Pnt3, Qtrn, TickOrder } from '../../base';
 import { IRenderable3dEntity } from './i-renderable-3d.entity';
 export class Entity3d extends IRenderable3dEntity {
-    constructor(object3D, objectBody = null) {
-        super();
-        this.object3D = object3D;
-        this.objectBody = objectBody;
-        this.tickOrder = TickOrder.OBJECTS_BINDING;
-        this._position = Pnt3.O;
-        this._rotation = Qtrn.O;
-        if (objectBody) {
-            this.tick$.subscribe(() => {
-                this.runTransformBinding(objectBody, object3D);
-            });
-            this.runTransformBinding(objectBody, object3D);
-            this.name = objectBody.name;
-        }
-        else if (object3D) {
-            this._position = object3D.position;
-            this._rotation = object3D.rotation;
-            this.name = object3D.name;
-        }
-        else {
-            throw new Error('Cannot create entity without a mesh and a body');
-        }
-        objectBody && this.addComponents(objectBody);
-        object3D && this.addComponents(object3D);
-    }
     get position() {
         return this._position;
     }
@@ -69,4 +44,29 @@ export class Entity3d extends IRenderable3dEntity {
         this._position = pos;
         this._rotation = quat;
     }
+    constructor(object3D, objectBody = null) {
+        super();
+        this.object3D = object3D;
+        this.objectBody = objectBody;
+        this.tickOrder = TickOrder.OBJECTS_BINDING;
+        this._position = Pnt3.O;
+        this._rotation = Qtrn.O;
+        if (objectBody) {
+            this.tick$.subscribe(() => {
+                this.runTransformBinding(objectBody, object3D);
+            });
+            this.runTransformBinding(objectBody, object3D);
+            this.name = objectBody.name;
+        }
+        else if (object3D) {
+            this._position = object3D.position;
+            this._rotation = object3D.rotation;
+            this.name = object3D.name;
+        }
+        else {
+            throw new Error('Cannot create entity without a mesh and a body');
+        }
+        objectBody && this.addComponents(objectBody);
+        object3D && this.addComponents(object3D);
+    }
 }

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

@@ -4,7 +4,7 @@ import { IRenderable3dEntity } from '../i-renderable-3d.entity';
 import { IPositionable3d } from '../../interfaces/i-positionable-3d';
 import { Point3, Point4 } from '../../../base';
 import { BehaviorSubject, Observable } from 'rxjs';
-export declare type GgCarProperties = RVEntityProperties & {
+export type GgCarProperties = RVEntityProperties & {
     mpsToRpmFactor?: number;
     engine: {
         minRpm: number;

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

@@ -3,22 +3,6 @@ import { IRenderable3dEntity } from '../i-renderable-3d.entity';
 import { cubicSplineInterpolation, TickOrder } from '../../../base';
 import { BehaviorSubject, filter, throttleTime } from 'rxjs';
 export class GgCarEntity extends IRenderable3dEntity {
-    constructor(carProperties, chassis3D, chassisBody) {
-        super();
-        this.carProperties = carProperties;
-        this.tickOrder = TickOrder.PHYSICS_SIMULATION - 5;
-        this._rpm$ = new BehaviorSubject(this.carProperties.engine.minRpm);
-        this._tailLightsOn = false;
-        // 0..1
-        this._acceleration$ = new BehaviorSubject(0);
-        // 0..1
-        this._brake$ = new BehaviorSubject(0);
-        this.handBrake$ = new BehaviorSubject(false);
-        this._gear = 0;
-        this._gear$ = new BehaviorSubject(0);
-        this.raycastVehicle = this.createRaycastVehicle(carProperties, chassis3D, chassisBody);
-        this.addChildren(this.raycastVehicle);
-    }
     get position() {
         return this.raycastVehicle.position;
     }
@@ -131,6 +115,22 @@ export class GgCarEntity extends IRenderable3dEntity {
     }
     // TODO remove
     set isHonking(value) { }
+    constructor(carProperties, chassis3D, chassisBody) {
+        super();
+        this.carProperties = carProperties;
+        this.tickOrder = TickOrder.PHYSICS_SIMULATION - 5;
+        this._rpm$ = new BehaviorSubject(this.carProperties.engine.minRpm);
+        this._tailLightsOn = false;
+        // 0..1
+        this._acceleration$ = new BehaviorSubject(0);
+        // 0..1
+        this._brake$ = new BehaviorSubject(0);
+        this.handBrake$ = new BehaviorSubject(false);
+        this._gear = 0;
+        this._gear$ = new BehaviorSubject(0);
+        this.raycastVehicle = this.createRaycastVehicle(carProperties, chassis3D, chassisBody);
+        this.addChildren(this.raycastVehicle);
+    }
     createRaycastVehicle(carProperties, chassis3D, chassisBody) {
         return new RaycastVehicle3dEntity(carProperties, chassis3D, chassisBody);
     }

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

@@ -5,7 +5,7 @@ import { Entity3d } from './entity-3d';
 import { LoadOptions, LoadResultWithProps } from '../loader';
 import { IPositionable3d } from '../interfaces/i-positionable-3d';
 import { IRenderable3dEntity } from './i-renderable-3d.entity';
-export declare type MapGraphNodeType = {
+export type MapGraphNodeType = {
     path: string;
     position: Point3;
     rotation?: Point4;
@@ -33,14 +33,15 @@ export declare class MapGraph extends Graph<MapGraphNodeType> {
     getNearestDummy(thisNodes: Graph<MapGraphNodeType>[], cursor: Point3): Graph<MapGraphNodeType>;
     nodes(): MapGraph[];
 }
-export declare type Gg3dMapGraphEntityOptions = {
+export type Gg3dMapGraphEntityOptions = {
     loadDepth: number;
     inertia: number;
+    maxNodesLoadingPerTick: number;
 };
 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<(IEntity & IPositionable3d) | null>;
+    readonly loaderCursor$: BehaviorSubject<Point3>;
     readonly loaded: Map<MapGraphNodeType, (IEntity & IPositionable3d)[]>;
     private _initialLoadComplete$;
     get initialLoadComplete$(): Observable<boolean>;
@@ -63,6 +64,9 @@ export declare class MapGraph3dEntity<VTypeDoc extends VisualTypeDocRepo3D = Vis
     protected readonly mapGraphNodes: MapGraph[];
     protected readonly options: Gg3dMapGraphEntityOptions;
     protected loadClock: PausableClock | null;
+    private _loadRateLimit;
+    get loadRateLimit(): number;
+    set loadRateLimit(value: number);
     constructor(mapGraph: MapGraph, options?: Partial<Gg3dMapGraphEntityOptions>);
     onSpawned(world: Gg3dWorld<VTypeDoc, PTypeDoc>): void;
     onRemoved(): void;

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

@@ -7,9 +7,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { BehaviorSubject, NEVER, startWith, Subject, switchMap, takeUntil } from 'rxjs';
+import { BehaviorSubject, startWith, Subject, takeUntil } from 'rxjs';
 import { distinctUntilChanged, map, tap } from 'rxjs/operators';
-import { Graph, Qtrn, TickOrder } from '../../base';
+import { Graph, Pnt3, Qtrn, TickOrder } from '../../base';
 import { IRenderable3dEntity } from './i-renderable-3d.entity';
 export class MapGraph extends Graph {
     /**
@@ -79,40 +79,49 @@ export class MapGraph extends Graph {
 const defaultOptions = {
     loadDepth: 5,
     inertia: 0,
+    maxNodesLoadingPerTick: 1,
 };
 export class MapGraph3dEntity extends IRenderable3dEntity {
+    get initialLoadComplete$() {
+        return this._initialLoadComplete$.asObservable();
+    }
+    get nearestDummy() {
+        return this._nearestDummy$.getValue();
+    }
+    get chunkLoaded$() {
+        return this._chunkLoaded$.asObservable();
+    }
+    get loadRateLimit() {
+        return this._loadRateLimit;
+    }
+    set loadRateLimit(value) {
+        this._loadRateLimit = value;
+        if (this.loadClock) {
+            this.loadClock.tickRateLimit = value;
+        }
+    }
     constructor(mapGraph, options = {}) {
         super();
         this.mapGraph = mapGraph;
         this.tickOrder = TickOrder.POST_RENDERING;
-        this.loaderCursorEntity$ = new BehaviorSubject(null);
+        this.loaderCursor$ = new BehaviorSubject(Pnt3.O);
         this.loaded = new Map();
         this._initialLoadComplete$ = new BehaviorSubject(false);
         this._nearestDummy$ = new BehaviorSubject(null);
         this._chunkLoaded$ = new Subject();
         this.loadClock = null;
+        this._loadRateLimit = 1;
         this.options = Object.assign(Object.assign({}, defaultOptions), options);
         this.mapGraphNodes = mapGraph.nodes();
     }
-    get initialLoadComplete$() {
-        return this._initialLoadComplete$.asObservable();
-    }
-    get nearestDummy() {
-        return this._nearestDummy$.getValue();
-    }
-    get chunkLoaded$() {
-        return this._chunkLoaded$.asObservable();
-    }
     onSpawned(world) {
         super.onSpawned(world);
         this.loadClock = world.createClock(true);
-        this.loadClock.tickRateLimit = 1;
-        this.loaderCursorEntity$
-            .pipe(takeUntil(this._onRemoved$), switchMap(entity => entity
-            ? this.loadClock.tick$.pipe(startWith(null), // map will perform initial loading even if world not started yet. Handy to preload map
-            takeUntil(entity.onRemoved$), map(() => entity.position))
-            : NEVER), map(pos => this.mapGraph.getNearestDummy(this.mapGraphNodes, pos)), tap(node => this._nearestDummy$.next(node)), distinctUntilChanged())
-            .subscribe(currentChunk => {
+        this.loadClock.tickRateLimit = this._loadRateLimit;
+        let loadList = [];
+        let unloadList = [];
+        this.loadClock.tick$.pipe(startWith(null), // map will perform initial loading even if world not started yet. Handy to preload map
+        takeUntil(this._onRemoved$), map(() => this.mapGraph.getNearestDummy(this.mapGraphNodes, this.loaderCursor$.getValue())), distinctUntilChanged(), tap(node => this._nearestDummy$.next(node))).subscribe(currentChunk => {
             let haveToBeLoaded = new Set();
             let canBeLoaded;
             if (this.options.inertia > 0) {
@@ -131,13 +140,45 @@ export class MapGraph3dEntity extends IRenderable3dEntity {
             }
             for (const loadedNode of this.loaded.keys()) {
                 if (!canBeLoaded.has(loadedNode)) {
-                    this.disposeChunk(loadedNode);
+                    if (!unloadList.includes(loadedNode)) {
+                        unloadList.push(loadedNode);
+                    }
                 }
                 else {
                     haveToBeLoaded.delete(loadedNode);
                 }
             }
-            Promise.all(Array.from(haveToBeLoaded.keys()).map(n => this.loadChunk(n))).then(() => this._initialLoadComplete$.next(true));
+            for (let n of Array.from(haveToBeLoaded.keys())) {
+                if (!loadList.includes(n)) {
+                    loadList.push(n);
+                }
+            }
+        });
+        this.tick$
+            .pipe(startWith(null), // map will perform initial loading even if world not started yet. Handy to preload map
+        takeUntil(this._onRemoved$))
+            .subscribe(() => {
+            if (unloadList.length) {
+                for (const n of unloadList) {
+                    this.disposeChunk(n);
+                }
+                unloadList = [];
+            }
+            if (loadList.length) {
+                if (this._initialLoadComplete$.value && loadList.length > this.options.maxNodesLoadingPerTick) {
+                    let loadNow = loadList.slice(0, this.options.maxNodesLoadingPerTick);
+                    loadList = loadList.slice(this.options.maxNodesLoadingPerTick);
+                    Promise.all(loadNow.map(n => this.loadChunk(n))).then();
+                }
+                else {
+                    Promise.all(loadList.map(n => this.loadChunk(n))).then(() => {
+                        if (!this._initialLoadComplete$.value) {
+                            this._initialLoadComplete$.next(true);
+                        }
+                    });
+                    loadList = [];
+                }
+            }
         });
     }
     onRemoved() {
@@ -146,7 +187,7 @@ export class MapGraph3dEntity extends IRenderable3dEntity {
             this.loadClock.stop();
             this.loadClock = null;
         }
-        this.loaderCursorEntity$.next(null);
+        this.loaderCursor$.next(Pnt3.O);
     }
     loadChunk(node) {
         return __awaiter(this, void 0, void 0, function* () {

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

@@ -4,12 +4,12 @@ import { IDisplayObject3dComponent } from '../components/rendering/i-display-obj
 import { IRaycastVehicleComponent, SuspensionOptions } from '../components/physics/i-raycast-vehicle.component';
 import { IRigidBody3dComponent } from '../components/physics/i-rigid-body-3d.component';
 import { PhysicsTypeDocRepo3D, VisualTypeDocRepo3D } from '../gg-3d-world';
-export declare type WheelDisplayOptions = {
+export type WheelDisplayOptions = {
     displayObject?: IDisplayObject3dComponent;
     wheelObjectDirection?: AxisDirection3;
     autoScaleMesh?: boolean;
 };
-export declare type RVEntitySharedWheelOptions = {
+export type RVEntitySharedWheelOptions = {
     tyreWidth?: number;
     tyreRadius?: number;
     frictionSlip?: number;
@@ -17,7 +17,7 @@ export declare type RVEntitySharedWheelOptions = {
     maxTravel?: number;
     display?: WheelDisplayOptions;
 };
-export declare type RVEntityAxleOptions = {
+export type RVEntityAxleOptions = {
     halfAxleWidth: number;
     axlePosition: number;
     axleHeight: number;
@@ -26,7 +26,7 @@ export declare enum RVEntityTractionBias {
     FWD = 1,
     RWD = 0
 }
-export declare type RVEntityProperties = {
+export type RVEntityProperties = {
     tractionBias: RVEntityTractionBias | number;
     suspension: SuspensionOptions;
 } & ({

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

@@ -13,6 +13,47 @@ const wheeelDefaults = {
     maxTravel: 0.5,
 };
 export class RaycastVehicle3dEntity extends Entity3d {
+    get name() {
+        return super.name;
+    }
+    set name(value) {
+        const oldName = super.name;
+        super.name = value;
+        for (const w of this.wheels || []) {
+            if (w) {
+                w.name = w.name.replace(oldName, value);
+            }
+        }
+    }
+    // m/s
+    getSpeed() {
+        return this.vehicleComponent.wheelSpeed;
+    }
+    get steeringAngle() {
+        return this._steeringAngle;
+    }
+    set steeringAngle(value) {
+        if (this._steeringAngle != value) {
+            this._steeringAngle = value;
+        }
+        this.frontWheelsIndices.forEach(index => this.vehicleComponent.setSteering(index, value));
+    }
+    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.vehicleComponent.applyBrake(index, force));
+        }
+        if (axle != 'front') {
+            this.rearWheelsIndices.forEach(index => this.vehicleComponent.applyBrake(index, force));
+        }
+    }
     /** car mesh and physics body direction has to be pointing: y front, z up*/
     constructor(carProperties, chassis3D, vehicleComponent) {
         super(chassis3D, vehicleComponent);
@@ -100,47 +141,6 @@ export class RaycastVehicle3dEntity extends Entity3d {
         this.addChildren(...this.wheels.filter(x => !!x));
         this.vehicleComponent.entity = this;
     }
-    get name() {
-        return super.name;
-    }
-    set name(value) {
-        const oldName = super.name;
-        super.name = value;
-        for (const w of this.wheels || []) {
-            if (w) {
-                w.name = w.name.replace(oldName, value);
-            }
-        }
-    }
-    // m/s
-    getSpeed() {
-        return this.vehicleComponent.wheelSpeed;
-    }
-    get steeringAngle() {
-        return this._steeringAngle;
-    }
-    set steeringAngle(value) {
-        if (this._steeringAngle != value) {
-            this._steeringAngle = value;
-        }
-        this.frontWheelsIndices.forEach(index => this.vehicleComponent.setSteering(index, value));
-    }
-    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.vehicleComponent.applyBrake(index, force));
-        }
-        if (axle != 'front') {
-            this.rearWheelsIndices.forEach(index => this.vehicleComponent.applyBrake(index, force));
-        }
-    }
     runTransformBinding(objectBody, object3D) {
         super.runTransformBinding(objectBody, object3D);
         for (const [i, wheel] of (this.wheels || []).entries()) {

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

@@ -1,17 +1,6 @@
 import { IEntity, Pnt3, Qtrn, TickOrder } from '../../base';
 import { map } from 'rxjs/operators';
 export class Trigger3dEntity extends IEntity {
-    constructor(objectBody) {
-        super();
-        this.objectBody = objectBody;
-        this.tickOrder = TickOrder.OBJECTS_BINDING;
-        this._position = Pnt3.O;
-        this._rotation = Qtrn.O;
-        this.tick$.subscribe(() => {
-            this.objectBody.checkOverlaps();
-        });
-        this.addComponents(this.objectBody);
-    }
     get onEntityEntered() {
         return this.objectBody.onEntityEntered.pipe(map(c => c.entity));
     }
@@ -32,4 +21,15 @@ export class Trigger3dEntity extends IEntity {
         this.objectBody.rotation = value;
         this._rotation = value;
     }
+    constructor(objectBody) {
+        super();
+        this.objectBody = objectBody;
+        this.tickOrder = TickOrder.OBJECTS_BINDING;
+        this._position = Pnt3.O;
+        this._rotation = Qtrn.O;
+        this.tick$.subscribe(() => {
+            this.objectBody.checkOverlaps();
+        });
+        this.addComponents(this.objectBody);
+    }
 }

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

@@ -1,7 +1,7 @@
 import { BodyShape3DDescriptor, Shape3DDescriptor, Shape3DMeshDescriptor } from './models/shapes';
 import { Point3, Point4 } from '../base';
 import { PhysicsTypeDocRepo3D, VisualTypeDocRepo3D } from './gg-3d-world';
-export declare type DisplayObject3dOpts<Tex> = {
+export type DisplayObject3dOpts<Tex> = {
     color?: number;
     shading?: 'unlit' | 'standart' | 'phong' | 'wireframe';
     diffuse?: Tex;

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

@@ -13,7 +13,7 @@ import { IRaycastVehicleComponent } from './components/physics/i-raycast-vehicle
 import { IRigidBody3dComponent } from './components/physics/i-rigid-body-3d.component';
 import { ITrigger3dComponent } from './components/physics/i-trigger-3d.component';
 import { IDisplayObject3dComponentLoader, IPhysicsBody3dComponentLoader } from './loaders';
-export declare type VisualTypeDocRepo3D = {
+export type VisualTypeDocRepo3D = {
     factory: IDisplayObject3dComponentFactory;
     loader: IDisplayObject3dComponentLoader;
     displayObject: IDisplayObject3dComponent;
@@ -22,7 +22,7 @@ export declare type VisualTypeDocRepo3D = {
     camera: ICameraComponent;
     texture: unknown;
 };
-export declare type PhysicsTypeDocRepo3D = {
+export type PhysicsTypeDocRepo3D = {
     factory: IPhysicsBody3dComponentFactory;
     loader: IPhysicsBody3dComponentLoader;
     rigidBody: IRigidBody3dComponent;
@@ -35,5 +35,5 @@ export declare class Gg3dWorld<VTypeDoc extends VisualTypeDocRepo3D = VisualType
     readonly loader: Gg3dLoader<VTypeDoc, PTypeDoc>;
     constructor(visualScene: VS, physicsWorld: PW);
     addPrimitiveRigidBody(descr: BodyShape3DDescriptor, position?: Point3, rotation?: Point4, material?: DisplayObject3dOpts<VTypeDoc['texture']>): Entity3d<VTypeDoc, PTypeDoc>;
-    addRenderer(camera: VTypeDoc['camera'], canvas?: HTMLCanvasElement, rendererOptions?: Partial<RendererOptions>): Renderer3dEntity<VTypeDoc>;
+    addRenderer(camera: VTypeDoc['camera'], canvas?: HTMLCanvasElement, rendererOptions?: Partial<RendererOptions & VTypeDoc['rendererExtraOpts']>): Renderer3dEntity<VTypeDoc>;
 }