@gg-web-engine/core 0.0.28 → 0.0.30

package/dist/2d/components/physics/i-physics-world-2d.component.d.ts

@@ -1,5 +1,4 @@
 import { IPhysicsWorldComponent, Point2 } from '../../../base';
-import { IPhysicsBody2dComponentFactory } from '../../factories';
-export interface IPhysicsWorld2dComponent extends IPhysicsWorldComponent<Point2, number> {
-    readonly factory: IPhysicsBody2dComponentFactory;
+import { PhysicsTypeDocRepo2D } from '../../gg-2d-world';
+export interface IPhysicsWorld2dComponent<TypeDoc extends PhysicsTypeDocRepo2D = PhysicsTypeDocRepo2D> extends IPhysicsWorldComponent<Point2, number, TypeDoc> {
 }

package/dist/2d/components/physics/i-rigid-body-2d.component.d.ts

@@ -1,5 +1,5 @@
 import { IRigidBodyComponent, Point2 } from '../../../base';
-import { IPhysicsWorld2dComponent } from './i-physics-world-2d.component';
-export interface IRigidBody2dComponent<PW extends IPhysicsWorld2dComponent = IPhysicsWorld2dComponent> extends IRigidBodyComponent<Point2, number, PW> {
+import { PhysicsTypeDocRepo2D } from '../../gg-2d-world';
+export interface IRigidBody2dComponent<TypeDoc extends PhysicsTypeDocRepo2D = PhysicsTypeDocRepo2D> extends IRigidBodyComponent<Point2, number, TypeDoc> {
     angularVelocity: number;
 }

package/dist/2d/components/physics/i-trigger-2d.component.d.ts

@@ -1,8 +1,7 @@
 import { ITriggerComponent, Point2 } from '../../../base';
 import { Observable } from 'rxjs';
-import { IPhysicsWorld2dComponent } from './i-physics-world-2d.component';
-import { IRigidBody2dComponent } from './i-rigid-body-2d.component';
-export interface ITrigger2dComponent<PW extends IPhysicsWorld2dComponent = IPhysicsWorld2dComponent> extends ITriggerComponent<Point2, number, PW> {
-    get onEntityEntered(): Observable<IRigidBody2dComponent>;
-    get onEntityLeft(): Observable<IRigidBody2dComponent | null>;
+import { PhysicsTypeDocRepo2D } from '../../gg-2d-world';
+export interface ITrigger2dComponent<TypeDoc extends PhysicsTypeDocRepo2D = PhysicsTypeDocRepo2D> extends ITriggerComponent<Point2, number, TypeDoc> {
+    get onEntityEntered(): Observable<TypeDoc['rigidBody']>;
+    get onEntityLeft(): Observable<TypeDoc['rigidBody'] | null>;
 }

package/dist/2d/components/rendering/i-display-object-2d.component.d.ts

@@ -1,4 +1,4 @@
 import { IDisplayObjectComponent, Point2 } from '../../../base';
-import { IVisualScene2dComponent } from './i-visual-scene-2d.component';
-export interface IDisplayObject2dComponent<VS extends IVisualScene2dComponent = IVisualScene2dComponent> extends IDisplayObjectComponent<Point2, number, VS> {
+import { VisualTypeDocRepo2D } from '../../gg-2d-world';
+export interface IDisplayObject2dComponent<TypeDoc extends VisualTypeDocRepo2D = VisualTypeDocRepo2D> extends IDisplayObjectComponent<Point2, number, TypeDoc> {
 }

package/dist/2d/components/rendering/i-renderer-2d.component.d.ts

@@ -1,4 +1,4 @@
 import { IRendererComponent, Point2 } from '../../../base';
-import { IVisualScene2dComponent } from './i-visual-scene-2d.component';
-export declare abstract class IRenderer2dComponent<VS extends IVisualScene2dComponent = IVisualScene2dComponent> extends IRendererComponent<Point2, number, VS> {
+import { VisualTypeDocRepo2D } from '../../gg-2d-world';
+export declare abstract class IRenderer2dComponent<TypeDoc extends VisualTypeDocRepo2D = VisualTypeDocRepo2D> extends IRendererComponent<Point2, number, TypeDoc> {
 }

package/dist/2d/components/rendering/i-visual-scene-2d.component.d.ts

@@ -1,7 +1,5 @@
 import { IVisualSceneComponent, Point2, RendererOptions } from '../../../base';
-import { IGg2dObjectFactory } from '../../factories';
-import { IRenderer2dComponent } from './i-renderer-2d.component';
-export interface IVisualScene2dComponent extends IVisualSceneComponent<Point2, number> {
-    readonly factory: IGg2dObjectFactory;
-    createRenderer(canvas?: HTMLCanvasElement, rendererOptions?: Partial<RendererOptions>): IRenderer2dComponent;
+import { VisualTypeDocRepo2D } from '../../gg-2d-world';
+export interface IVisualScene2dComponent<TypeDoc extends VisualTypeDocRepo2D = VisualTypeDocRepo2D> extends IVisualSceneComponent<Point2, number, TypeDoc> {
+    createRenderer(canvas?: HTMLCanvasElement, rendererOptions?: Partial<RendererOptions>): TypeDoc['renderer'];
 }

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

@@ -1,11 +1,11 @@
 import { AnimationFunction, AnimationMixer, Point2 } from '../../../base';
-import { Gg2dWorld } from '../../gg-2d-world';
+import { Gg2dWorld, PhysicsTypeDocRepo2D, VisualTypeDocRepo2D } from '../../gg-2d-world';
 import { Entity2d } from '../entity-2d';
 declare type Positioning2d = {
     position: Point2;
     rotation: number;
 };
-export declare class Entity2dPositioningAnimator<T extends Entity2d = Entity2d> extends AnimationMixer<Positioning2d> {
+export declare class Entity2dPositioningAnimator<T extends Entity2d = Entity2d> extends AnimationMixer<Positioning2d, Point2, number, VisualTypeDocRepo2D, PhysicsTypeDocRepo2D> {
     entity: T;
     protected _animationFunction: AnimationFunction<Positioning2d>;
     constructor(entity: T, _animationFunction: AnimationFunction<Positioning2d>);

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

@@ -1,13 +1,10 @@
 import { Point2, TickOrder } from '../../base';
-import { IRigidBody2dComponent } from '../components/physics/i-rigid-body-2d.component';
-import { IDisplayObject2dComponent } from '../components/rendering/i-display-object-2d.component';
 import { IPositionable2d } from '../interfaces/i-positionable-2d';
 import { IRenderable2dEntity } from './i-renderable-2d.entity';
-import { IVisualScene2dComponent } from '../components/rendering/i-visual-scene-2d.component';
-import { IPhysicsWorld2dComponent } from '../components/physics/i-physics-world-2d.component';
-export declare class Entity2d<VS extends IVisualScene2dComponent = IVisualScene2dComponent, PW extends IPhysicsWorld2dComponent = IPhysicsWorld2dComponent> extends IRenderable2dEntity<VS, PW> implements IPositionable2d {
-    readonly object2D: IDisplayObject2dComponent | null;
-    readonly objectBody: IRigidBody2dComponent | null;
+import { PhysicsTypeDocRepo2D, VisualTypeDocRepo2D } from '../gg-2d-world';
+export declare class Entity2d<VTypeDoc extends VisualTypeDocRepo2D = VisualTypeDocRepo2D, PTypeDoc extends PhysicsTypeDocRepo2D = PhysicsTypeDocRepo2D> extends IRenderable2dEntity<VTypeDoc, PTypeDoc> implements IPositionable2d {
+    readonly object2D: VTypeDoc['displayObject'] | null;
+    readonly objectBody: PTypeDoc['rigidBody'] | null;
     readonly tickOrder = TickOrder.OBJECTS_BINDING;
     private _position;
     get position(): Point2;
@@ -19,6 +16,6 @@ export declare class Entity2d<VS extends IVisualScene2dComponent = IVisualScene2
     /**
      * Synchronize physics body transform with entity (and object2d if defined)
      * */
-    protected runTransformBinding(objectBody: IRigidBody2dComponent, object2D: IDisplayObject2dComponent | null): void;
-    constructor(object2D: IDisplayObject2dComponent | null, objectBody: IRigidBody2dComponent | null);
+    protected runTransformBinding(objectBody: PTypeDoc['rigidBody'], object2D: VTypeDoc['displayObject'] | null): void;
+    constructor(object2D: VTypeDoc['displayObject'] | null, objectBody: PTypeDoc['rigidBody'] | null);
 }

package/dist/2d/entities/i-renderable-2d.entity.d.ts

@@ -1,5 +1,4 @@
 import { IRenderableEntity, Point2 } from '../../base';
-import { IVisualScene2dComponent } from '../components/rendering/i-visual-scene-2d.component';
-import { IPhysicsWorld2dComponent } from '../components/physics/i-physics-world-2d.component';
-export declare abstract class IRenderable2dEntity<VS extends IVisualScene2dComponent = IVisualScene2dComponent, PW extends IPhysicsWorld2dComponent = IPhysicsWorld2dComponent> extends IRenderableEntity<Point2, number, VS, PW> {
+import { PhysicsTypeDocRepo2D, VisualTypeDocRepo2D } from '../gg-2d-world';
+export declare abstract class IRenderable2dEntity<TypeDoc extends VisualTypeDocRepo2D = VisualTypeDocRepo2D, PTypeDoc extends PhysicsTypeDocRepo2D = PhysicsTypeDocRepo2D> extends IRenderableEntity<Point2, number, TypeDoc, PTypeDoc> {
 }

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

@@ -1,5 +1,4 @@
 import { IRendererEntity, Point2 } from '../../base';
-import { IRenderer2dComponent } from '../components/rendering/i-renderer-2d.component';
-import { IVisualScene2dComponent } from '../components/rendering/i-visual-scene-2d.component';
-export declare class Renderer2dEntity<RC extends IRenderer2dComponent = IRenderer2dComponent> extends IRendererEntity<Point2, number, IVisualScene2dComponent, RC> {
+import { VisualTypeDocRepo2D } from '../gg-2d-world';
+export declare class Renderer2dEntity<TypeDoc extends VisualTypeDocRepo2D = VisualTypeDocRepo2D> extends IRendererEntity<Point2, number, TypeDoc> {
 }

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

@@ -2,11 +2,12 @@ import { Observable } from 'rxjs';
 import { ITrigger2dComponent } from '../components/physics/i-trigger-2d.component';
 import { IEntity, Point2, TickOrder } from '../../base';
 import { IPositionable2d } from '../interfaces/i-positionable-2d';
-export declare class Trigger2dEntity extends IEntity<Point2, number> implements IPositionable2d {
+import { PhysicsTypeDocRepo2D, VisualTypeDocRepo2D } from '../gg-2d-world';
+export declare class Trigger2dEntity<TypeDoc extends PhysicsTypeDocRepo2D = PhysicsTypeDocRepo2D> extends IEntity<Point2, number, VisualTypeDocRepo2D, TypeDoc> implements IPositionable2d {
     readonly objectBody: ITrigger2dComponent;
     readonly tickOrder = TickOrder.OBJECTS_BINDING;
-    get onEntityEntered(): Observable<IEntity & IPositionable2d>;
-    get onEntityLeft(): Observable<(IEntity & IPositionable2d) | null>;
+    get onEntityEntered(): Observable<IEntity<Point2, number, VisualTypeDocRepo2D, TypeDoc> & IPositionable2d>;
+    get onEntityLeft(): Observable<(IEntity<Point2, number, VisualTypeDocRepo2D, TypeDoc> & IPositionable2d) | null>;
     private _position;
     get position(): Point2;
     set position(value: Point2);

package/dist/2d/factories.d.ts

@@ -1,20 +1,23 @@
 import { Point2 } from '../base';
 import { BodyShape2DDescriptor, Shape2DDescriptor } from './models/shapes';
-import { IRigidBody2dComponent } from './components/physics/i-rigid-body-2d.component';
-import { ITrigger2dComponent } from './components/physics/i-trigger-2d.component';
-import { IDisplayObject2dComponent } from './components/rendering/i-display-object-2d.component';
-export declare abstract class IGg2dObjectFactory<T extends IDisplayObject2dComponent = IDisplayObject2dComponent> {
-    abstract createPrimitive(descriptor: Shape2DDescriptor): T;
-    createSquare(dimensions: Point2): T;
-    createCircle(radius: number): T;
+import { PhysicsTypeDocRepo2D, VisualTypeDocRepo2D } from './gg-2d-world';
+export declare type DisplayObject2dOpts<Tex> = {
+    color?: number;
+    texture?: Tex;
+};
+export declare abstract class IDisplayObject2dComponentFactory<TypeDoc extends VisualTypeDocRepo2D = VisualTypeDocRepo2D> {
+    abstract createPrimitive(descriptor: Shape2DDescriptor, material?: DisplayObject2dOpts<TypeDoc['texture']>): TypeDoc['displayObject'];
+    randomColor(): number;
+    createSquare(dimensions: Point2, material?: DisplayObject2dOpts<TypeDoc['texture']>): TypeDoc['displayObject'];
+    createCircle(radius: number, material?: DisplayObject2dOpts<TypeDoc['texture']>): TypeDoc['displayObject'];
 }
-export interface IPhysicsBody2dComponentFactory<T extends IRigidBody2dComponent = IRigidBody2dComponent, K extends ITrigger2dComponent = ITrigger2dComponent> {
+export interface IPhysicsBody2dComponentFactory<TypeDoc extends PhysicsTypeDocRepo2D = PhysicsTypeDocRepo2D> {
     createRigidBody(descriptor: BodyShape2DDescriptor, transform?: {
         position?: Point2;
         rotation?: number;
-    }): T;
+    }): TypeDoc['rigidBody'];
     createTrigger(descriptor: Shape2DDescriptor, transform?: {
         position?: Point2;
         rotation?: number;
-    }): K;
+    }): TypeDoc['trigger'];
 }

package/dist/2d/factories.js

@@ -1,9 +1,12 @@
-export class IGg2dObjectFactory {
+export class IDisplayObject2dComponentFactory {
+    randomColor() {
+        return ((Math.floor(Math.random() * 256) << 16) | (Math.floor(Math.random() * 256) << 8) | Math.floor(Math.random() * 256));
+    }
     // shortcuts
-    createSquare(dimensions) {
-        return this.createPrimitive({ shape: 'SQUARE', dimensions });
+    createSquare(dimensions, material = {}) {
+        return this.createPrimitive({ shape: 'SQUARE', dimensions }, material);
     }
-    createCircle(radius) {
-        return this.createPrimitive({ shape: 'CIRCLE', radius });
+    createCircle(radius, material = {}) {
+        return this.createPrimitive({ shape: 'CIRCLE', radius }, material);
     }
 }

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

@@ -4,10 +4,26 @@ import { Entity2d } from './entities/entity-2d';
 import { IPhysicsWorld2dComponent } from './components/physics/i-physics-world-2d.component';
 import { IVisualScene2dComponent } from './components/rendering/i-visual-scene-2d.component';
 import { Renderer2dEntity } from './entities/renderer-2d.entity';
-export declare class Gg2dWorld<V extends IVisualScene2dComponent = IVisualScene2dComponent, P extends IPhysicsWorld2dComponent = IPhysicsWorld2dComponent> extends GgWorld<Point2, number, V, P> {
-    readonly visualScene: V;
-    readonly physicsWorld: P;
-    constructor(visualScene: V, physicsWorld: P);
-    addPrimitiveRigidBody(descr: BodyShape2DDescriptor, position?: Point2, rotation?: number): Entity2d<V, P>;
-    addRenderer(canvas?: HTMLCanvasElement, rendererOptions?: Partial<RendererOptions>): Renderer2dEntity;
+import { DisplayObject2dOpts, IDisplayObject2dComponentFactory, IPhysicsBody2dComponentFactory } from './factories';
+import { IRenderer2dComponent } from './components/rendering/i-renderer-2d.component';
+import { IDisplayObject2dComponent } from './components/rendering/i-display-object-2d.component';
+import { ITrigger2dComponent } from './components/physics/i-trigger-2d.component';
+import { IRigidBody2dComponent } from './components/physics/i-rigid-body-2d.component';
+export declare type VisualTypeDocRepo2D = {
+    factory: IDisplayObject2dComponentFactory;
+    displayObject: IDisplayObject2dComponent;
+    renderer: IRenderer2dComponent;
+    texture: unknown;
+};
+export declare type PhysicsTypeDocRepo2D = {
+    factory: IPhysicsBody2dComponentFactory;
+    rigidBody: IRigidBody2dComponent;
+    trigger: ITrigger2dComponent;
+};
+export declare class Gg2dWorld<VTypeDoc extends VisualTypeDocRepo2D = VisualTypeDocRepo2D, PTypeDoc extends PhysicsTypeDocRepo2D = PhysicsTypeDocRepo2D, VS extends IVisualScene2dComponent<VTypeDoc> = IVisualScene2dComponent<VTypeDoc>, PW extends IPhysicsWorld2dComponent<PTypeDoc> = IPhysicsWorld2dComponent<PTypeDoc>> extends GgWorld<Point2, number, VTypeDoc, PTypeDoc, VS, PW> {
+    readonly visualScene: VS;
+    readonly physicsWorld: PW;
+    constructor(visualScene: VS, physicsWorld: PW);
+    addPrimitiveRigidBody(descr: BodyShape2DDescriptor, position?: Point2, rotation?: number, material?: DisplayObject2dOpts<VTypeDoc['texture']>): Entity2d<VTypeDoc, PTypeDoc>;
+    addRenderer(canvas?: HTMLCanvasElement, rendererOptions?: Partial<RendererOptions>): Renderer2dEntity<VTypeDoc>;
 }

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

@@ -28,8 +28,8 @@ export class Gg2dWorld extends GgWorld {
                 '{x: 0, y: value}, 2 arguments set the whole vector. Default value is "9.82" or "0 9.82"');
         }
     }
-    addPrimitiveRigidBody(descr, position = Pnt2.O, rotation = 0) {
-        const entity = new Entity2d(this.visualScene.factory.createPrimitive(descr.shape), this.physicsWorld.factory.createRigidBody(descr));
+    addPrimitiveRigidBody(descr, position = Pnt2.O, rotation = 0, material = {}) {
+        const entity = new Entity2d(this.visualScene.factory.createPrimitive(descr.shape, material), this.physicsWorld.factory.createRigidBody(descr));
         entity.position = position;
         entity.rotation = rotation;
         this.addEntity(entity);

package/dist/3d/components/physics/i-physics-world-3d.component.d.ts

@@ -1,7 +1,5 @@
 import { IPhysicsWorldComponent, Point3, Point4 } from '../../../base';
-import { IPhysicsBody3dComponentFactory } from '../../factories';
-import { IPhysicsBody3dComponentLoader } from '../../loaders';
-export interface IPhysicsWorld3dComponent extends IPhysicsWorldComponent<Point3, Point4> {
-    readonly factory: IPhysicsBody3dComponentFactory;
-    readonly loader: IPhysicsBody3dComponentLoader;
+import { PhysicsTypeDocRepo3D } from '../../gg-3d-world';
+export interface IPhysicsWorld3dComponent<TypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> extends IPhysicsWorldComponent<Point3, Point4, TypeDoc> {
+    readonly loader: TypeDoc['loader'];
 }

package/dist/3d/components/physics/i-raycast-vehicle.component.d.ts

@@ -1,6 +1,6 @@
 import { Point3, Point4 } from '../../../base';
 import { IRigidBody3dComponent } from './i-rigid-body-3d.component';
-import { IPhysicsWorld3dComponent } from './i-physics-world-3d.component';
+import { PhysicsTypeDocRepo3D } from '../../gg-3d-world';
 export declare type SuspensionOptions = {
     stiffness: number;
     damping: number;
@@ -17,7 +17,7 @@ export declare type WheelOptions = {
     rollInfluence: number;
     maxTravel: number;
 };
-export interface IRaycastVehicleComponent<PW extends IPhysicsWorld3dComponent = IPhysicsWorld3dComponent> extends IRigidBody3dComponent<PW> {
+export interface IRaycastVehicleComponent<TypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> extends IRigidBody3dComponent<TypeDoc> {
     /** Return speed in m/s, calculated by car itself (which should be shown on the speedometer) */
     get wheelSpeed(): number;
     addWheel(options: WheelOptions, suspensionOptions: SuspensionOptions): void;
@@ -33,4 +33,5 @@ export interface IRaycastVehicleComponent<PW extends IPhysicsWorld3dComponent =
         rotation: Point4;
     };
     resetSuspension(): void;
+    clone(): IRaycastVehicleComponent;
 }

package/dist/3d/components/physics/i-rigid-body-3d.component.d.ts

@@ -1,5 +1,5 @@
 import { IRigidBodyComponent, Point3, Point4 } from '../../../base';
-import { IPhysicsWorld3dComponent } from './i-physics-world-3d.component';
-export interface IRigidBody3dComponent<PW extends IPhysicsWorld3dComponent = IPhysicsWorld3dComponent> extends IRigidBodyComponent<Point3, Point4, PW> {
+import { PhysicsTypeDocRepo3D } from '../../gg-3d-world';
+export interface IRigidBody3dComponent<TypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> extends IRigidBodyComponent<Point3, Point4, TypeDoc> {
     angularVelocity: Point3;
 }

package/dist/3d/components/physics/i-trigger-3d.component.d.ts

@@ -1,8 +1,7 @@
 import { ITriggerComponent, Point3, Point4 } from '../../../base';
 import { Observable } from 'rxjs';
-import { IPhysicsWorld3dComponent } from './i-physics-world-3d.component';
-import { IRigidBody3dComponent } from './i-rigid-body-3d.component';
-export interface ITrigger3dComponent<PW extends IPhysicsWorld3dComponent = IPhysicsWorld3dComponent> extends ITriggerComponent<Point3, Point4, PW> {
-    get onEntityEntered(): Observable<IRigidBody3dComponent>;
-    get onEntityLeft(): Observable<IRigidBody3dComponent | null>;
+import { PhysicsTypeDocRepo3D } from '../../gg-3d-world';
+export interface ITrigger3dComponent<TypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> extends ITriggerComponent<Point3, Point4, TypeDoc> {
+    get onEntityEntered(): Observable<TypeDoc['rigidBody']>;
+    get onEntityLeft(): Observable<TypeDoc['rigidBody'] | null>;
 }

package/dist/3d/components/rendering/i-camera.component.d.ts

@@ -1,6 +1,6 @@
 import { IDisplayObject3dComponent } from './i-display-object-3d.component';
-import { IVisualScene3dComponent } from './i-visual-scene-3d.component';
-export interface ICameraComponent<VS extends IVisualScene3dComponent = IVisualScene3dComponent> extends IDisplayObject3dComponent<VS> {
+import { VisualTypeDocRepo3D } from '../../gg-3d-world';
+export interface ICameraComponent<TypeDoc extends VisualTypeDocRepo3D = VisualTypeDocRepo3D> extends IDisplayObject3dComponent<TypeDoc> {
     get supportsFov(): boolean;
     get fov(): number;
     set fov(f: number);

package/dist/3d/components/rendering/i-display-object-3d.component.d.ts

@@ -1,4 +1,4 @@
 import { IDisplayObjectComponent, Point3, Point4 } from '../../../base';
-import { IVisualScene3dComponent } from './i-visual-scene-3d.component';
-export interface IDisplayObject3dComponent<VS extends IVisualScene3dComponent = IVisualScene3dComponent> extends IDisplayObjectComponent<Point3, Point4, VS> {
+import { VisualTypeDocRepo3D } from '../../gg-3d-world';
+export interface IDisplayObject3dComponent<TypeDoc extends VisualTypeDocRepo3D = VisualTypeDocRepo3D> extends IDisplayObjectComponent<Point3, Point4, TypeDoc> {
 }

package/dist/3d/components/rendering/i-renderer-3d.component.d.ts

@@ -1,6 +1,5 @@
 import { IRendererComponent, Point3, Point4 } from '../../../base';
-import { IVisualScene3dComponent } from './i-visual-scene-3d.component';
-import { ICameraComponent } from './i-camera.component';
-export declare abstract class IRenderer3dComponent<VS extends IVisualScene3dComponent = IVisualScene3dComponent, CC extends ICameraComponent = ICameraComponent> extends IRendererComponent<Point3, Point4, VS> {
-    abstract camera: CC;
+import { VisualTypeDocRepo3D } from '../../gg-3d-world';
+export declare abstract class IRenderer3dComponent<TypeDoc extends VisualTypeDocRepo3D = VisualTypeDocRepo3D> extends IRendererComponent<Point3, Point4, TypeDoc> {
+    abstract camera: TypeDoc['camera'];
 }

package/dist/3d/components/rendering/i-visual-scene-3d.component.d.ts

@@ -1,10 +1,6 @@
 import { IVisualSceneComponent, Point3, Point4, RendererOptions } from '../../../base';
-import { IDisplayObject3dComponentFactory } from '../../factories';
-import { ICameraComponent } from './i-camera.component';
-import { IRenderer3dComponent } from './i-renderer-3d.component';
-import { IDisplayObject3dComponentLoader } from '../../loaders';
-export interface IVisualScene3dComponent extends IVisualSceneComponent<Point3, Point4> {
-    readonly factory: IDisplayObject3dComponentFactory;
-    readonly loader: IDisplayObject3dComponentLoader;
-    createRenderer(camera: ICameraComponent, canvas?: HTMLCanvasElement, rendererOptions?: Partial<RendererOptions>): IRenderer3dComponent;
+import { VisualTypeDocRepo3D } from '../../gg-3d-world';
+export interface IVisualScene3dComponent<TypeDoc extends VisualTypeDocRepo3D = VisualTypeDocRepo3D> extends IVisualSceneComponent<Point3, Point4, TypeDoc> {
+    readonly loader: TypeDoc['loader'];
+    createRenderer(camera: TypeDoc['camera'], canvas?: HTMLCanvasElement, rendererOptions?: Partial<RendererOptions>): TypeDoc['renderer'];
 }

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

@@ -1,5 +1,5 @@
-import { AnimationFunction, AnimationMixer, Point3 } from '../../../../base';
-import { Gg3dWorld } from '../../../gg-3d-world';
+import { AnimationFunction, AnimationMixer, Point3, Point4 } from '../../../../base';
+import { Gg3dWorld, VisualTypeDocRepo3D } from '../../../gg-3d-world';
 import { Renderer3dEntity } from '../../renderer-3d.entity';
 export declare type Camera3dAnimationArgs = {
     position: Point3;
@@ -7,10 +7,10 @@ export declare type Camera3dAnimationArgs = {
     up?: Point3;
     fov?: number;
 };
-export declare class Camera3dAnimator extends AnimationMixer<Camera3dAnimationArgs> {
-    entity: Renderer3dEntity;
+export declare class Camera3dAnimator<VTypeDoc extends VisualTypeDocRepo3D = VisualTypeDocRepo3D> extends AnimationMixer<Camera3dAnimationArgs, Point3, Point4, VTypeDoc> {
+    entity: Renderer3dEntity<VTypeDoc>;
     protected _animationFunction: AnimationFunction<Camera3dAnimationArgs>;
-    constructor(entity: Renderer3dEntity, _animationFunction: AnimationFunction<Camera3dAnimationArgs>);
-    onSpawned(world: Gg3dWorld): void;
+    constructor(entity: Renderer3dEntity<VTypeDoc>, _animationFunction: AnimationFunction<Camera3dAnimationArgs>);
+    onSpawned(world: Gg3dWorld<VTypeDoc>): void;
     protected applyPositioning(value: Camera3dAnimationArgs): void;
 }

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

@@ -1,11 +1,11 @@
 import { AnimationFunction, AnimationMixer, Point3, Point4 } from '../../../../base';
-import { Gg3dWorld } from '../../../gg-3d-world';
+import { Gg3dWorld, PhysicsTypeDocRepo3D, VisualTypeDocRepo3D } from '../../../gg-3d-world';
 import { IPositionable3d } from '../../../interfaces/i-positionable-3d';
 declare type Positioning3d = {
     position: Point3;
     rotation: Point4;
 };
-export declare class Entity3dPositioningAnimator<T extends IPositionable3d = IPositionable3d> extends AnimationMixer<Positioning3d> {
+export declare class Entity3dPositioningAnimator<T extends IPositionable3d = IPositionable3d> extends AnimationMixer<Positioning3d, Point3, Point4, VisualTypeDocRepo3D, PhysicsTypeDocRepo3D> {
     entity: T;
     protected _animationFunction: AnimationFunction<Positioning3d>;
     constructor(entity: T, _animationFunction: AnimationFunction<Positioning3d>);

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

@@ -1,4 +1,4 @@
-import { DirectionKeyboardInput, DirectionKeyboardKeymap, IEntity, TickOrder, GgWorld, KeyboardInput, MouseInput, MouseInputOptions } from '../../../../base';
+import { DirectionKeyboardInput, DirectionKeyboardKeymap, GgWorld, IEntity, KeyboardInput, MouseInput, MouseInputOptions, TickOrder } from '../../../../base';
 import { Renderer3dEntity } from '../../renderer-3d.entity';
 /**
  * Options for configuring a FreeCameraInput controller.

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

@@ -8,7 +8,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { combineLatest, filter, takeUntil } from 'rxjs';
-import { DirectionKeyboardInput, IEntity, TickOrder, MouseInput, Pnt2, Pnt3, Qtrn, } from '../../../../base';
+import { DirectionKeyboardInput, IEntity, MouseInput, Pnt2, Pnt3, Qtrn, TickOrder, } from '../../../../base';
 /**
  * A controller for a free-moving camera.
  */

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

@@ -1,4 +1,4 @@
-import { IEntity, TickOrder, GgWorld, MouseInput, MouseInputOptions, MutableSpherical, Point3 } from '../../../../base';
+import { GgWorld, IEntity, MouseInput, MouseInputOptions, MutableSpherical, Point3, TickOrder } from '../../../../base';
 import { Renderer3dEntity } from '../../renderer-3d.entity';
 export declare type OrbitCameraControllerOptions = {
     mouseOptions: Partial<MouseInputOptions>;

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

@@ -7,7 +7,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { IEntity, TickOrder, MouseInput, MouseInputState, Pnt3, Qtrn, } from '../../../../base';
+import { IEntity, MouseInput, MouseInputState, Pnt3, Qtrn, TickOrder, } from '../../../../base';
 import { filter, takeUntil } from 'rxjs';
 import { map } from 'rxjs/operators';
 const DEFAULT_OPTIONS = {

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

@@ -3,11 +3,10 @@ import { IRigidBody3dComponent } from '../components/physics/i-rigid-body-3d.com
 import { IDisplayObject3dComponent } from '../components/rendering/i-display-object-3d.component';
 import { IPositionable3d } from '../interfaces/i-positionable-3d';
 import { IRenderable3dEntity } from './i-renderable-3d.entity';
-import { IVisualScene3dComponent } from '../components/rendering/i-visual-scene-3d.component';
-import { IPhysicsWorld3dComponent } from '../components/physics/i-physics-world-3d.component';
-export declare class Entity3d<VS extends IVisualScene3dComponent = IVisualScene3dComponent, PW extends IPhysicsWorld3dComponent = IPhysicsWorld3dComponent> extends IRenderable3dEntity<VS, PW> implements IPositionable3d {
-    readonly object3D: IDisplayObject3dComponent | null;
-    readonly objectBody: IRigidBody3dComponent | null;
+import { PhysicsTypeDocRepo3D, VisualTypeDocRepo3D } from '../gg-3d-world';
+export declare class Entity3d<VTypeDoc extends VisualTypeDocRepo3D = VisualTypeDocRepo3D, PTypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> extends IRenderable3dEntity<VTypeDoc, PTypeDoc> implements IPositionable3d {
+    readonly object3D: VTypeDoc['displayObject'] | null;
+    readonly objectBody: PTypeDoc['rigidBody'] | null;
     readonly tickOrder = TickOrder.OBJECTS_BINDING;
     private _position;
     get position(): Point3;
@@ -20,5 +19,5 @@ export declare class Entity3d<VS extends IVisualScene3dComponent = IVisualScene3
      * Synchronize physics body transform with entity (and mesh if defined)
      * */
     protected runTransformBinding(objectBody: IRigidBody3dComponent, object3D: IDisplayObject3dComponent | null): void;
-    constructor(object3D: IDisplayObject3dComponent | null, objectBody?: IRigidBody3dComponent | null);
+    constructor(object3D: VTypeDoc['displayObject'] | null, objectBody?: PTypeDoc['rigidBody'] | null);
 }

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

@@ -1,10 +1,9 @@
 import { RaycastVehicle3dEntity, RVEntityProperties } from '../raycast-vehicle-3d.entity';
-import { IRenderableEntity, Point3, Point4 } from '../../../base';
+import { Gg3dWorld, PhysicsTypeDocRepo3D, VisualTypeDocRepo3D } from '../../gg-3d-world';
+import { IRenderable3dEntity } from '../i-renderable-3d.entity';
 import { IPositionable3d } from '../../interfaces/i-positionable-3d';
+import { Point3, Point4 } from '../../../base';
 import { BehaviorSubject, Observable } from 'rxjs';
-import { Gg3dWorld } from '../../gg-3d-world';
-import { IDisplayObject3dComponent } from '../../components/rendering/i-display-object-3d.component';
-import { IRaycastVehicleComponent } from '../../components/physics/i-raycast-vehicle.component';
 export declare type GgCarProperties = RVEntityProperties & {
     mpsToRpmFactor?: number;
     engine: {
@@ -33,7 +32,7 @@ export declare type GgCarProperties = RVEntityProperties & {
     };
     maxSteerAngle: number;
 };
-export declare class GgCarEntity extends IRenderableEntity<Point3, Point4> implements IPositionable3d {
+export declare class GgCarEntity<VTypeDoc extends VisualTypeDocRepo3D = VisualTypeDocRepo3D, PTypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D, RVEntity extends RaycastVehicle3dEntity<VTypeDoc, PTypeDoc> = RaycastVehicle3dEntity<VTypeDoc, PTypeDoc>> extends IRenderable3dEntity<VTypeDoc, PTypeDoc> implements IPositionable3d {
     readonly carProperties: GgCarProperties;
     readonly tickOrder: number;
     get position(): Point3;
@@ -59,6 +58,7 @@ export declare class GgCarEntity extends IRenderableEntity<Point3, Point4> imple
     get brake(): number;
     set brake(value: number);
     set steeringFactor(value: number);
+    get steeringFactor(): number;
     protected handBrake$: BehaviorSubject<boolean>;
     get handBrake(): boolean;
     set handBrake(value: boolean);
@@ -68,9 +68,10 @@ export declare class GgCarEntity extends IRenderableEntity<Point3, Point4> imple
     get gear$(): Observable<number>;
     set gear(value: number);
     set isHonking(value: boolean);
-    readonly raycastVehicle: RaycastVehicle3dEntity;
-    constructor(carProperties: GgCarProperties, chassis3D: IDisplayObject3dComponent | null, chassisBody: IRaycastVehicleComponent);
-    onSpawned(world: Gg3dWorld): void;
+    readonly raycastVehicle: RVEntity;
+    constructor(carProperties: GgCarProperties, chassis3D: VTypeDoc['displayObject'] | null, chassisBody: PTypeDoc['raycastVehicle']);
+    protected createRaycastVehicle(carProperties: GgCarProperties, chassis3D: VTypeDoc['displayObject'] | null, chassisBody: PTypeDoc['raycastVehicle']): RVEntity;
+    onSpawned(world: Gg3dWorld<VTypeDoc, PTypeDoc>): void;
     protected updateEngine(delta: number): void;
     resetTo(options?: {
         position?: Point3;

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

@@ -1,8 +1,8 @@
 import { RaycastVehicle3dEntity } from '../raycast-vehicle-3d.entity';
-import { cubicSplineInterpolation, IRenderableEntity, TickOrder } from '../../../base';
-import { BehaviorSubject, filter } from 'rxjs';
-import { throttleTime } from 'rxjs/operators';
-export class GgCarEntity extends IRenderableEntity {
+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;
@@ -16,7 +16,7 @@ export class GgCarEntity extends IRenderableEntity {
         this.handBrake$ = new BehaviorSubject(false);
         this._gear = 0;
         this._gear$ = new BehaviorSubject(0);
-        this.raycastVehicle = new RaycastVehicle3dEntity(carProperties, chassis3D, chassisBody);
+        this.raycastVehicle = this.createRaycastVehicle(carProperties, chassis3D, chassisBody);
         this.addChildren(this.raycastVehicle);
     }
     get position() {
@@ -106,6 +106,9 @@ export class GgCarEntity extends IRenderableEntity {
     set steeringFactor(value) {
         this.raycastVehicle.steeringAngle = value * this.carProperties.maxSteerAngle;
     }
+    get steeringFactor() {
+        return this.raycastVehicle.steeringAngle / this.carProperties.maxSteerAngle;
+    }
     get handBrake() {
         return this.handBrake$.getValue();
     }
@@ -128,6 +131,9 @@ export class GgCarEntity extends IRenderableEntity {
     }
     // TODO remove
     set isHonking(value) { }
+    createRaycastVehicle(carProperties, chassis3D, chassisBody) {
+        return new RaycastVehicle3dEntity(carProperties, chassis3D, chassisBody);
+    }
     onSpawned(world) {
         super.onSpawned(world);
         this.tick$.subscribe(([_, delta]) => {
@@ -156,9 +162,15 @@ export class GgCarEntity extends IRenderableEntity {
                         }
                     }
                 }
-                this.raycastVehicle.applyTractionForce(force);
-                this.raycastVehicle.applyBrake('front', brake * this.carProperties.brake.frontAxleForce);
-                this.raycastVehicle.applyBrake('rear', brake * this.carProperties.brake.rearAxleForce);
+                if (brake === 0) {
+                    this.raycastVehicle.applyTractionForce(force);
+                    this.raycastVehicle.applyBrake('both', 0);
+                }
+                else {
+                    this.raycastVehicle.applyTractionForce(0);
+                    this.raycastVehicle.applyBrake('front', brake * this.carProperties.brake.frontAxleForce);
+                    this.raycastVehicle.applyBrake('rear', brake * this.carProperties.brake.rearAxleForce);
+                }
                 if (this.handBrake) {
                     this.raycastVehicle.applyBrake('rear', this.carProperties.brake.handbrakeForce);
                 }

package/dist/3d/entities/i-renderable-3d.entity.d.ts

@@ -1,5 +1,4 @@
 import { IRenderableEntity, Point3, Point4 } from '../../base';
-import { IVisualScene3dComponent } from '../components/rendering/i-visual-scene-3d.component';
-import { IPhysicsWorld3dComponent } from '../components/physics/i-physics-world-3d.component';
-export declare abstract class IRenderable3dEntity<VS extends IVisualScene3dComponent = IVisualScene3dComponent, PW extends IPhysicsWorld3dComponent = IPhysicsWorld3dComponent> extends IRenderableEntity<Point3, Point4, VS, PW> {
+import { PhysicsTypeDocRepo3D, VisualTypeDocRepo3D } from '../gg-3d-world';
+export declare abstract class IRenderable3dEntity<TypeDoc extends VisualTypeDocRepo3D = VisualTypeDocRepo3D, PTypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> extends IRenderableEntity<Point3, Point4, TypeDoc, PTypeDoc> {
 }