@gg-web-engine/core 0.0.24 → 0.0.28

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

@@ -1,99 +1,66 @@
 import { AxisDirection3, IEntity, Point3, Point4 } from '../../base';
 import { Entity3d } from './entity-3d';
-import { BehaviorSubject, Observable } from 'rxjs';
-import { Gg3dWorld } from '../gg-3d-world';
 import { IDisplayObject3dComponent } from '../components/rendering/i-display-object-3d.component';
-import { IRaycastVehicleComponent, SuspensionOptions, WheelOptions } from '../components/physics/i-raycast-vehicle.component';
+import { IRaycastVehicleComponent, SuspensionOptions } from '../components/physics/i-raycast-vehicle.component';
 import { IRigidBody3dComponent } from '../components/physics/i-rigid-body-3d.component';
 import { IPositionable3d } from '../interfaces/i-positionable-3d';
-export declare type CarProperties = {
+export declare type WheelDisplayOptions = {
+    displayObject?: IDisplayObject3dComponent;
+    wheelObjectDirection?: AxisDirection3;
+    autoScaleMesh?: boolean;
+};
+export declare type RVEntitySharedWheelOptions = {
+    tyreWidth?: number;
+    tyreRadius?: number;
+    frictionSlip?: number;
+    rollInfluence?: number;
+    maxTravel?: number;
+    display?: WheelDisplayOptions;
+};
+export declare type RVEntityAxleOptions = {
+    halfAxleWidth: number;
+    axlePosition: number;
+    axleHeight: number;
+} & RVEntitySharedWheelOptions;
+export declare type RVEntityProperties = {
     typeOfDrive: 'RWD' | 'FWD' | '4WD';
-    wheelOptions: WheelOptions[];
-    mpsToRpmFactor?: number;
-    engine: {
-        minRpm: number;
-        maxRpm: number;
-        torques: {
-            rpm: number;
-            torque: number;
-        }[];
-        maxRpmIncreasePerSecond: number;
-        maxRpmDecreasePerSecond: number;
-    };
-    brake: {
-        frontAxleForce: number;
-        rearAxleForce: number;
-        handbrakeForce: number;
-    };
-    transmission: {
-        isAuto: boolean;
-        reverseGearRatio: number;
-        gearRatios: number[];
-        drivelineEfficiency: number;
-        finalDriveRatio: number;
-        upShifts: number[];
-    };
     suspension: SuspensionOptions;
-};
+} & ({
+    wheelBase: {
+        shared: RVEntitySharedWheelOptions;
+        front: RVEntityAxleOptions;
+        rear: RVEntityAxleOptions;
+    };
+} | {
+    wheelOptions: (RVEntitySharedWheelOptions & {
+        isLeft: boolean;
+        isFront: boolean;
+        position: Point3;
+    })[];
+    sharedWheelOptions?: RVEntitySharedWheelOptions;
+});
 export declare class RaycastVehicle3dEntity extends Entity3d {
-    readonly carProperties: CarProperties;
+    readonly carProperties: RVEntityProperties;
     readonly chassis3D: IDisplayObject3dComponent | null;
     readonly chassisBody: IRaycastVehicleComponent;
-    readonly wheelObject: IDisplayObject3dComponent | null;
-    readonly wheelObjectDirection: AxisDirection3;
     protected readonly wheels: ((IEntity & IPositionable3d) | null)[];
     protected readonly wheelLocalRotation: (Point4 | null)[];
-    protected readonly wheelLocalTranslation: Point3[];
     protected readonly frontWheelsIndices: number[];
     protected readonly rearWheelsIndices: number[];
     protected readonly tractionWheelIndices: number[];
-    readonly tractionWheelRadius: number;
-    protected get dynamicTractionWheelRadius(): number;
-    get engineTorque(): number;
-    get transmissionGearRatio(): number;
-    protected get mpsToRpm(): number;
     getSpeed(): number;
-    calculateRpmFromCarSpeed(): number;
-    getDisplaySpeed(units?: 'ms' | 'kmh' | 'mph'): number;
-    protected readonly _rpm$: BehaviorSubject<number>;
-    get engineRpm$(): Observable<number>;
-    get engineRpm(): number;
-    protected get tractionForce(): number;
-    private readonly _maxSteerVal;
-    get maxSteerVal(): number;
-    private getMaxStableSteerVal;
-    private _tailLightsOn;
-    get tailLightsOn(): boolean;
-    protected setTailLightsOn(value: boolean): void;
-    protected _acceleration$: BehaviorSubject<number>;
-    protected get acceleration(): number;
-    get acceleration$(): Observable<number>;
-    protected set acceleration(value: number);
-    protected brake$: BehaviorSubject<number>;
-    protected get brake(): number;
-    protected set brake(value: number);
-    protected handBrake$: BehaviorSubject<boolean>;
-    get handBrake(): boolean;
-    set handBrake(value: boolean);
-    private _gear;
-    private _gear$;
-    get gear(): number;
-    get gear$(): Observable<number>;
-    set gear(value: number);
-    set isHonking(value: boolean);
-    private _steeringValue;
-    get steeringValue(): number;
-    protected setSteeringValue(value: number): void;
+    readonly tractionWheelRadius: number;
+    private _steeringAngle;
+    get steeringAngle(): number;
+    set steeringAngle(value: number);
+    applyTractionForce(force: number): void;
+    applyBrake(axle: 'front' | 'rear' | 'both', force: number): void;
     /** car mesh and physics body direction has to be pointing: y front, z up*/
-    constructor(carProperties: CarProperties, chassis3D: IDisplayObject3dComponent | null, chassisBody: IRaycastVehicleComponent, wheelObject?: IDisplayObject3dComponent | null, wheelObjectDirection?: AxisDirection3);
-    onSpawned(world: Gg3dWorld): void;
+    constructor(carProperties: RVEntityProperties, chassis3D: IDisplayObject3dComponent | null, chassisBody: IRaycastVehicleComponent);
     protected runTransformBinding(objectBody: IRigidBody3dComponent, object3D: IDisplayObject3dComponent): void;
-    protected get isTouchingGround(): boolean;
-    protected updateEngine(delta: number): void;
+    get isTouchingGround(): boolean;
     resetTo(options?: {
         position?: Point3;
         rotation?: Point4;
     }): void;
-    setXAxisControlValue(value: number): void;
-    setYAxisControlValue(value: number): void;
 }

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

@@ -1,300 +1,125 @@
 import { Box, Pnt3, Qtrn } from '../../base';
 import { Entity3d } from './entity-3d';
-import { BehaviorSubject, filter } from 'rxjs';
-import { throttleTime } from 'rxjs/operators';
+const wheeelDefaults = {
+    tyreWidth: 0.3,
+    tyreRadius: 0.4,
+    frictionSlip: 1000,
+    rollInfluence: 0.2,
+    maxTravel: 0.5,
+};
 export class RaycastVehicle3dEntity extends Entity3d {
     /** car mesh and physics body direction has to be pointing: y front, z up*/
-    constructor(carProperties, chassis3D, chassisBody, wheelObject = null, wheelObjectDirection = 'x') {
+    constructor(carProperties, chassis3D, chassisBody) {
         super(chassis3D, chassisBody);
         this.carProperties = carProperties;
         this.chassis3D = chassis3D;
         this.chassisBody = chassisBody;
-        this.wheelObject = wheelObject;
-        this.wheelObjectDirection = wheelObjectDirection;
         this.wheels = [];
         this.wheelLocalRotation = [];
-        this.wheelLocalTranslation = [];
         this.frontWheelsIndices = [];
         this.rearWheelsIndices = [];
         this.tractionWheelIndices = [];
-        this._rpm$ = new BehaviorSubject(this.carProperties.engine.minRpm);
-        // TODO should be parameters
-        this._maxSteerVal = 0.35;
-        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._steeringValue = 0;
-        this.carProperties.wheelOptions.forEach((x, i) => {
-            if (x.isFront) {
+        this._steeringAngle = 0;
+        let wheelFullOptions = 'wheelBase' in carProperties
+            ? [
+                carProperties.wheelBase.front,
+                carProperties.wheelBase.front,
+                carProperties.wheelBase.rear,
+                carProperties.wheelBase.rear,
+            ].map((a, i) => {
+                var _a;
+                return (Object.assign(Object.assign(Object.assign(Object.assign({}, wheeelDefaults), (carProperties.wheelBase.shared || {})), a), { isFront: i < 2, isLeft: i % 2 === 0, position: {
+                        x: a.halfAxleWidth * (i % 2 === 0 ? 1 : -1),
+                        y: a.axlePosition,
+                        z: a.axleHeight,
+                    }, display: Object.assign(Object.assign({}, (((_a = carProperties.wheelBase.shared) === null || _a === void 0 ? void 0 : _a.display) || {})), (a.display || {})) }));
+            })
+            : carProperties.wheelOptions.map((x, i) => {
+                var _a;
+                return (Object.assign(Object.assign(Object.assign(Object.assign({}, wheeelDefaults), (carProperties.sharedWheelOptions || {})), x), { display: Object.assign(Object.assign({}, (((_a = carProperties.sharedWheelOptions) === null || _a === void 0 ? void 0 : _a.display) || {})), (x.display || {})) }));
+            });
+        // TODO perform this in a parent application
+        // chassisBody.setDamping(0.02, 0.02); // TODO imitates air resistance. calculate from properties
+        wheelFullOptions.forEach((wheelOpts, i) => {
+            if (wheelOpts.isFront) {
                 this.frontWheelsIndices.push(i);
             }
             else {
                 this.rearWheelsIndices.push(i);
             }
-            if (x.isFront && this.carProperties.typeOfDrive != 'RWD') {
+            if (wheelOpts.isFront && this.carProperties.typeOfDrive != 'RWD') {
                 this.tractionWheelIndices.push(i);
             }
-            if (!x.isFront && this.carProperties.typeOfDrive != 'FWD') {
+            if (!wheelOpts.isFront && this.carProperties.typeOfDrive != 'FWD') {
                 this.tractionWheelIndices.push(i);
             }
-        });
-        this.tractionWheelRadius = this.carProperties.wheelOptions[this.tractionWheelIndices[0]].tyre_radius;
-        // TODO perform this in a parent application
-        // chassisBody.setDamping(0.02, 0.02); // TODO imitates air resistance. calculate from properties
-        this.carProperties.wheelOptions.forEach(wheelOpts => {
             this.chassisBody.addWheel(wheelOpts, this.carProperties.suspension);
         });
-        if (this.wheelObject) {
-            for (let i = 0; i < this.carProperties.wheelOptions.length; i++) {
-                const options = this.carProperties.wheelOptions[i];
-                if (!options.wheelObject && !this.wheelObject) {
-                    this.wheels.push(null);
-                    this.wheelLocalRotation.push(null);
-                    continue;
-                }
-                const entity = options.wheelObject || this.wheelObject.clone();
-                const localTranslation = { x: options.tyre_width * (options.isLeft ? 1 : -1), y: 0, z: 0 };
+        this.tractionWheelRadius = wheelFullOptions[this.tractionWheelIndices[0]].tyreRadius;
+        for (const options of wheelFullOptions) {
+            const display = options.display || {};
+            if (!display.displayObject) {
+                this.wheels.push(null);
+                this.wheelLocalRotation.push(null);
+                continue;
+            }
+            const entity = display.displayObject.clone();
+            if (display.autoScaleMesh) {
                 const boundingBox = Box.expandByPoint(entity.getBoundings(), Pnt3.O);
                 const scale = Object.assign({}, Pnt3.O);
+                const wheelObjectDirection = display.wheelObjectDirection || 'x';
                 for (const dir of ['x', 'y', 'z']) {
-                    const wheelObjectDirection = options.wheelObjectDirection || this.wheelObjectDirection;
                     const isNormal = wheelObjectDirection.includes(dir);
                     scale[dir] = isNormal
-                        ? options.tyre_width / (boundingBox.max[dir] - boundingBox.min[dir])
-                        : (options.tyre_radius * 2) / (boundingBox.max[dir] - boundingBox.min[dir]);
-                    if (isNormal) {
-                        localTranslation.x +=
-                            (wheelObjectDirection.startsWith('-') ? boundingBox.max[dir] : boundingBox.min[dir]) *
-                                scale[dir] *
-                                (options.isLeft ? 1 : -1);
-                    }
+                        ? options.tyreWidth / (boundingBox.max[dir] - boundingBox.min[dir])
+                        : (options.tyreRadius * 2) / (boundingBox.max[dir] - boundingBox.min[dir]);
                 }
                 entity.scale = scale;
-                const direction = options.wheelObjectDirection || this.wheelObjectDirection;
-                const flip = direction.includes('-') ? !options.isLeft : options.isLeft;
-                let localRotation = null;
-                if (direction.includes('x')) {
-                    // rotate PI around Z if opposite position (x is correct for right wheel, -x is correct for left wheel)
-                    if (flip)
-                        localRotation = { x: 0, y: 0, z: 1, w: 0 };
-                }
-                else if (direction.includes('y')) {
-                    // rotate PI/2 around Z
-                    localRotation = { x: 0, y: 0, z: 0.707107 * (flip ? 1 : -1), w: 0.707107 };
-                }
-                else if (direction.includes('z')) {
-                    // rotate PI/2 around Y
-                    localRotation = { x: 0, y: 0.707107 * (flip ? -1 : 1), z: 0, w: 0.707107 };
-                }
-                this.wheelLocalTranslation.push(localTranslation);
-                this.wheelLocalRotation.push(localRotation);
-                this.wheels.push(new Entity3d(entity));
             }
+            const direction = display.wheelObjectDirection || 'x';
+            const flip = direction.includes('-') ? !options.isLeft : options.isLeft;
+            let localRotation = null;
+            if (direction.includes('x')) {
+                // rotate PI around Z if opposite position (x is correct for right wheel, -x is correct for left wheel)
+                if (flip)
+                    localRotation = { x: 0, y: 0, z: 1, w: 0 };
+            }
+            else if (direction.includes('y')) {
+                // rotate PI/2 around Z
+                localRotation = { x: 0, y: 0, z: 0.707107 * (flip ? 1 : -1), w: 0.707107 };
+            }
+            else if (direction.includes('z')) {
+                // rotate PI/2 around Y
+                localRotation = { x: 0, y: 0.707107 * (flip ? -1 : 1), z: 0, w: 0.707107 };
+            }
+            this.wheelLocalRotation.push(localRotation);
+            this.wheels.push(new Entity3d(entity));
         }
         this.addChildren(...this.wheels.filter(x => !!x));
         this.chassisBody.entity = this;
     }
-    get dynamicTractionWheelRadius() {
-        // The dynamic wheel radius [m] is the radius of the wheel when the vehicle is in motion. It is smaller than the static wheel radius rws because the tire is slightly compressed during vehicle motion.
-        return 0.98 * this.tractionWheelRadius;
-    }
-    get engineTorque() {
-        const currentRPM = this.engineRpm;
-        const maxMapTorque = this.carProperties.engine.torques[this.carProperties.engine.torques.length - 1].rpm;
-        if (currentRPM >= maxMapTorque) {
-            return (Math.pow(Math.max(0, 1 - (currentRPM - maxMapTorque) / (this.carProperties.engine.maxRpm - maxMapTorque)), 2) *
-                this.carProperties.engine.torques[this.carProperties.engine.torques.length - 1].torque);
-        }
-        let index = 0;
-        let factor = 0;
-        for (let i = 0; i < this.carProperties.engine.torques.length; i++) {
-            if (this.carProperties.engine.torques[i].rpm < currentRPM) {
-                index = i;
-                continue;
-            }
-            factor = Math.max(0, (currentRPM - this.carProperties.engine.torques[index].rpm) /
-                (this.carProperties.engine.torques[index + 1].rpm - this.carProperties.engine.torques[index].rpm));
-            break;
-        }
-        if (factor === 0) {
-            return this.carProperties.engine.torques[index].torque;
-        }
-        else {
-            return (this.carProperties.engine.torques[index].torque +
-                factor * (this.carProperties.engine.torques[index + 1].torque - this.carProperties.engine.torques[index].torque));
-        }
-    }
-    get transmissionGearRatio() {
-        if (this._gear == -1) {
-            return this.carProperties.transmission.reverseGearRatio;
-        }
-        return this.carProperties.transmission.gearRatios[this._gear - 1] || 0;
-    }
-    get mpsToRpm() {
-        return (this.carProperties.mpsToRpmFactor ||
-            (30 * this.carProperties.transmission.finalDriveRatio) / (Math.PI * this.dynamicTractionWheelRadius));
-    }
     // m/s
     getSpeed() {
         return this.chassisBody.wheelSpeed;
     }
-    calculateRpmFromCarSpeed() {
-        return this.getSpeed() * this.mpsToRpm * this.transmissionGearRatio;
+    get steeringAngle() {
+        return this._steeringAngle;
     }
-    // TODO remove from here, end application should do this work
-    getDisplaySpeed(units = 'ms') {
-        if (units === 'ms') {
-            return this.getSpeed();
-        }
-        const kmh = this.getSpeed() * 3.6;
-        if (units === 'mph') {
-            return kmh * 0.621371192;
+    set steeringAngle(value) {
+        if (this._steeringAngle != value) {
+            this._steeringAngle = value;
         }
-        return kmh;
-    }
-    get engineRpm$() {
-        return this._rpm$.asObservable();
-    }
-    get engineRpm() {
-        return this._rpm$.getValue();
+        this.frontWheelsIndices.forEach(index => this.chassisBody.setSteering(index, value));
     }
-    get tractionForce() {
-        return ((this.engineTorque *
-            this.transmissionGearRatio *
-            this.carProperties.transmission.finalDriveRatio *
-            this.carProperties.transmission.drivelineEfficiency) /
-            this.dynamicTractionWheelRadius);
+    applyTractionForce(force) {
+        this.tractionWheelIndices.forEach(index => this.chassisBody.applyEngineForce(index, force));
     }
-    get maxSteerVal() {
-        return this._maxSteerVal;
-    }
-    getMaxStableSteerVal() {
-        const speed = this.getSpeed() * 3.6;
-        if (speed < 40) {
-            return this.maxSteerVal;
+    applyBrake(axle, force) {
+        if (axle != 'rear') {
+            this.frontWheelsIndices.forEach(index => this.chassisBody.applyBrake(index, force));
         }
-        const mult = Math.pow((340 - speed) / 300, 2);
-        return this.maxSteerVal * Math.max(mult, 0.06);
-    }
-    get tailLightsOn() {
-        return this._tailLightsOn;
-    }
-    setTailLightsOn(value) {
-        if (this._tailLightsOn != value) {
-            this._tailLightsOn = value;
-        }
-    }
-    get acceleration() {
-        return this._acceleration$.getValue();
-    }
-    get acceleration$() {
-        return this._acceleration$.asObservable();
-    }
-    set acceleration(value) {
-        this._acceleration$.next(value);
-    }
-    get brake() {
-        return this.brake$.getValue();
-    }
-    set brake(value) {
-        this.brake$.next(value);
-    }
-    get handBrake() {
-        return this.handBrake$.getValue();
-    }
-    set handBrake(value) {
-        this.handBrake$.next(value);
-    }
-    get gear() {
-        return this._gear;
-    }
-    get gear$() {
-        return this._gear$.asObservable();
-    }
-    set gear(value) {
-        value = Math.max(-1, Math.min(this.carProperties.transmission.gearRatios.length, value));
-        if (value === this._gear) {
-            return;
-        }
-        this._gear = value;
-        this._gear$.next(value);
-    }
-    // TODO remove
-    set isHonking(value) { }
-    get steeringValue() {
-        return this._steeringValue;
-    }
-    setSteeringValue(value) {
-        if (this._steeringValue != value) {
-            this._steeringValue = value;
-        }
-    }
-    onSpawned(world) {
-        super.onSpawned(world);
-        this.tick$.subscribe(([_, delta]) => {
-            this.updateEngine(delta);
-            if (this.isTouchingGround) {
-                // TODO 1 - R (1000 rpm) quick switch with acceleration pedal should have the same speed as without acceleration pedal
-                let force = 0;
-                let brake = this.brake;
-                const calculatedRpm = this.calculateRpmFromCarSpeed();
-                if (this.gear !== 0 && calculatedRpm > this.carProperties.engine.maxRpm) {
-                    // engine brake, this is related to clutch, better clutch condition - bigger force
-                    force = this.gear > 0 ? -12000 : 12000;
-                }
-                else {
-                    force =
-                        this.acceleration > 0
-                            ? this.tractionForce * this.acceleration // apply torque
-                            : 0.5 * (this.carProperties.engine.minRpm - calculatedRpm) * (this.gear > 0 ? 1 : -1); // released, use engine brake
-                    // this functionality makes car stay still (parking gear) when speed is low
-                    const speedThreshold = 3;
-                    if (Math.abs(this.getSpeed()) < speedThreshold && (this.gear == 0 || this.acceleration <= 0)) {
-                        brake = Math.max(brake, (0.3 * (speedThreshold - this.getSpeed())) / speedThreshold);
-                        force = 0;
-                    }
-                }
-                this.tractionWheelIndices.forEach(index => this.chassisBody.applyEngineForce(index, force));
-                this.frontWheelsIndices.forEach(index => this.chassisBody.applyBrake(index, brake * this.carProperties.brake.frontAxleForce));
-                this.rearWheelsIndices.forEach(index => this.chassisBody.applyBrake(index, brake * this.carProperties.brake.rearAxleForce));
-                if (this.handBrake) {
-                    this.rearWheelsIndices.forEach(index => this.chassisBody.applyBrake(index, this.carProperties.brake.handbrakeForce));
-                }
-            }
-        });
-        if (this.carProperties.transmission.isAuto) {
-            this.tick$
-                .pipe(throttleTime(50), filter(() => this.isTouchingGround))
-                .subscribe(() => {
-                let gear = this.gear;
-                let upshifted = false;
-                if (gear > 0) {
-                    let rpm = this.engineRpm;
-                    while (rpm >= this.carProperties.transmission.upShifts[gear - 1]) {
-                        rpm *=
-                            this.carProperties.transmission.gearRatios[gear] / this.carProperties.transmission.gearRatios[gear - 1];
-                        gear++;
-                        upshifted = true;
-                    }
-                    if (!upshifted) {
-                        while (gear > 1) {
-                            rpm *=
-                                this.carProperties.transmission.gearRatios[gear - 2] /
-                                    this.carProperties.transmission.gearRatios[gear - 1];
-                            if (rpm > this.carProperties.transmission.upShifts[gear - 2]) {
-                                break;
-                            }
-                            gear--;
-                        }
-                    }
-                    this.gear = gear;
-                }
-            });
+        if (axle != 'front') {
+            this.rearWheelsIndices.forEach(index => this.chassisBody.applyBrake(index, force));
         }
     }
     runTransformBinding(objectBody, object3D) {
@@ -308,7 +133,6 @@ export class RaycastVehicle3dEntity extends Entity3d {
             if (this.wheelLocalRotation[i]) {
                 rotation = Qtrn.combineRotations(rotation, this.wheelLocalRotation[i]);
             }
-            position = Pnt3.add(position, Pnt3.rot(this.wheelLocalTranslation[i], carRotation));
             wheel.position = position;
             wheel.rotation = rotation;
         }
@@ -319,31 +143,6 @@ export class RaycastVehicle3dEntity extends Entity3d {
             .map(i => this.chassisBody.isWheelTouchesGround(i))
             .reduce((prev, cur) => cur || prev, false);
     }
-    updateEngine(delta) {
-        delta = delta / 1000; // ms -> s
-        const acceleration = this._acceleration$.getValue();
-        let rpm = this.engineRpm;
-        // TODO here I will take perioud between gears and drift into account someday :)
-        const gripKoeff = this.gear === 0 || !this.isTouchingGround ? 0 : 1;
-        if (gripKoeff == 0) {
-            rpm +=
-                (acceleration * 2 - 1) *
-                    (acceleration > 0.5
-                        ? this.carProperties.engine.maxRpmIncreasePerSecond
-                        : this.carProperties.engine.maxRpmDecreasePerSecond) *
-                    delta;
-        }
-        else {
-            const rpmFromSpeed = this.calculateRpmFromCarSpeed();
-            if (rpmFromSpeed > rpm) {
-                rpm = Math.min(rpmFromSpeed, rpm + this.carProperties.engine.maxRpmIncreasePerSecond * delta);
-            }
-            else {
-                rpm = Math.max(rpmFromSpeed, rpm - this.carProperties.engine.maxRpmDecreasePerSecond * delta);
-            }
-        }
-        this._rpm$.next(Math.max(this.carProperties.engine.minRpm, Math.min(this.carProperties.engine.maxRpm, rpm)));
-    }
     // TODO delete and let game application do all the steps
     resetTo(options = {}) {
         this.chassisBody.resetMotion();
@@ -354,26 +153,6 @@ export class RaycastVehicle3dEntity extends Entity3d {
         if (options.rotation) {
             this.rotation = options.rotation;
         }
-        this._steeringValue = 0;
-        this.gear = 0;
-        this._rpm$.next(this.carProperties.engine.minRpm);
-    }
-    // TODO refactor: control has to be in control service, here we receive separately braking, acceleration, steering
-    setXAxisControlValue(value) {
-        const steering = this.getMaxStableSteerVal() * value;
-        this.frontWheelsIndices.forEach(index => this.chassisBody.setSteering(index, -steering));
-        this.setSteeringValue(-steering);
-    }
-    // TODO refactor: control has to be in control service, here we receive separately braking, acceleration, steering
-    setYAxisControlValue(value) {
-        if (value > 0) {
-            this.acceleration = value;
-            this.brake = 0;
-        }
-        else {
-            this.acceleration = 0;
-            this.brake = -value;
-        }
-        this.setTailLightsOn(value < 0);
+        this.steeringAngle = 0;
     }
 }

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

@@ -10,9 +10,8 @@ import { IPhysicsWorld3dComponent } from './components/physics/i-physics-world-3
 export declare class Gg3dWorld<V extends IVisualScene3dComponent = IVisualScene3dComponent, P extends IPhysicsWorld3dComponent = IPhysicsWorld3dComponent> 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);
+    constructor(visualScene: V, physicsWorld: P);
     addPrimitiveRigidBody(descr: BodyShape3DDescriptor, position?: Point3, rotation?: Point4): Entity3d<V, P>;
     addRenderer<CC extends ICameraComponent<V> = ICameraComponent<V>, RC extends IRenderer3dComponent<V, CC> = IRenderer3dComponent<V, CC>>(camera: CC, canvas?: HTMLCanvasElement, rendererOptions?: Partial<RendererOptions>): Renderer3dEntity<V, CC, RC>;
 }

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

@@ -12,14 +12,13 @@ import { Gg3dLoader } from './loader';
 import { Entity3d } from './entities/entity-3d';
 import { Renderer3dEntity } from './entities/renderer-3d.entity';
 export class Gg3dWorld extends GgWorld {
-    constructor(visualScene, physicsWorld, consoleEnabled = false) {
-        super(visualScene, physicsWorld, consoleEnabled);
+    constructor(visualScene, physicsWorld) {
+        super(visualScene, physicsWorld);
         this.visualScene = visualScene;
         this.physicsWorld = physicsWorld;
-        this.consoleEnabled = consoleEnabled;
         this.loader = new Gg3dLoader(this);
-        if (consoleEnabled) {
-            this.registerConsoleCommand('ph_gravity', (...args) => __awaiter(this, void 0, void 0, function* () {
+        if (window.ggstatic) {
+            window.ggstatic.registerConsoleCommand(this, 'ph_gravity', (...args) => __awaiter(this, void 0, void 0, function* () {
                 if (args.length == 1) {
                     args = ['0', '0', '' + -+args[0]]; // mean -Z axis
                 }

package/dist/3d/index.d.ts

@@ -6,6 +6,7 @@ export * from './components/rendering/i-display-object-3d.component';
 export * from './components/rendering/i-camera.component';
 export * from './components/rendering/i-renderer-3d.component';
 export * from './components/rendering/i-visual-scene-3d.component';
+export * from './entities/gg-car/gg-car.entity';
 export * from './entities/controllers/animators/camera-3d.animator';
 export * from './entities/controllers/animators/entity-3d-positioning.animator';
 export * from './entities/entity-3d';
@@ -15,6 +16,7 @@ export * from './entities/trigger-3d.entity';
 export * from './entities/renderer-3d.entity';
 export * from './entities/i-renderable-3d.entity';
 export * from './entities/controllers/input/car-keyboard-handling.controller';
+export * from './entities/controllers/input/gg-car-keyboard-handling.controller';
 export * from './entities/controllers/input/free-camera.controller';
 export * from './entities/controllers/input/orbit-camera.controller';
 export * from './interfaces/i-positionable-3d';

package/dist/3d/index.js

@@ -6,6 +6,7 @@ export * from './components/rendering/i-display-object-3d.component';
 export * from './components/rendering/i-camera.component';
 export * from './components/rendering/i-renderer-3d.component';
 export * from './components/rendering/i-visual-scene-3d.component';
+export * from './entities/gg-car/gg-car.entity';
 export * from './entities/controllers/animators/camera-3d.animator';
 export * from './entities/controllers/animators/entity-3d-positioning.animator';
 export * from './entities/entity-3d';
@@ -15,6 +16,7 @@ export * from './entities/trigger-3d.entity';
 export * from './entities/renderer-3d.entity';
 export * from './entities/i-renderable-3d.entity';
 export * from './entities/controllers/input/car-keyboard-handling.controller';
+export * from './entities/controllers/input/gg-car-keyboard-handling.controller';
 export * from './entities/controllers/input/free-camera.controller';
 export * from './entities/controllers/input/orbit-camera.controller';
 export * from './interfaces/i-positionable-3d';