@gg-web-engine/core 0.0.40 → 0.0.49

package/blender_exporter/build_blender_scene.py

@@ -133,7 +133,6 @@ bpy.ops.export_scene.gltf(export_format="GLB",
                           export_normals=True,
                           export_tangents=True,
                           export_materials='$export_materials',
-                          export_colors=True,
                           export_cameras=False,
                           export_lights=True,
                           export_extras=True,

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

@@ -1,7 +1,7 @@
 import { AnimationFunction, AnimationMixer, Point2 } from '../../../base';
 import { Gg2dWorld, PhysicsTypeDocRepo2D, VisualTypeDocRepo2D } from '../../gg-2d-world';
 import { Entity2d } from '../entity-2d';
-declare type Positioning2d = {
+type Positioning2d = {
     position: Point2;
     rotation: number;
 };

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

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

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

@@ -1,17 +1,6 @@
 import { IEntity, Pnt2, TickOrder } from '../../base';
 import { map } from 'rxjs/operators';
 export class Trigger2dEntity extends IEntity {
-    constructor(objectBody) {
-        super();
-        this.objectBody = objectBody;
-        this.tickOrder = TickOrder.OBJECTS_BINDING;
-        this._position = Pnt2.O;
-        this._rotation = 0;
-        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 Trigger2dEntity extends IEntity {
         this.objectBody.rotation = value;
         this._rotation = value;
     }
+    constructor(objectBody) {
+        super();
+        this.objectBody = objectBody;
+        this.tickOrder = TickOrder.OBJECTS_BINDING;
+        this._position = Pnt2.O;
+        this._rotation = 0;
+        this.tick$.subscribe(() => {
+            this.objectBody.checkOverlaps();
+        });
+        this.addComponents(this.objectBody);
+    }
 }

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

@@ -1,7 +1,7 @@
 import { Point2 } from '../base';
 import { BodyShape2DDescriptor, Shape2DDescriptor } from './models/shapes';
 import { PhysicsTypeDocRepo2D, VisualTypeDocRepo2D } from './gg-2d-world';
-export declare type DisplayObject2dOpts<Tex> = {
+export type DisplayObject2dOpts<Tex> = {
     color?: number;
     texture?: Tex;
 };

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

@@ -9,14 +9,14 @@ import { IRenderer2dComponent } from './components/rendering/i-renderer-2d.compo
 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 = {
+export type VisualTypeDocRepo2D = {
     factory: IDisplayObject2dComponentFactory;
     displayObject: IDisplayObject2dComponent;
     renderer: IRenderer2dComponent;
     rendererExtraOpts: {};
     texture: unknown;
 };
-export declare type PhysicsTypeDocRepo2D = {
+export type PhysicsTypeDocRepo2D = {
     factory: IPhysicsBody2dComponentFactory;
     rigidBody: IRigidBody2dComponent;
     trigger: ITrigger2dComponent;
@@ -26,5 +26,5 @@ export declare class Gg2dWorld<VTypeDoc extends VisualTypeDocRepo2D = VisualType
     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>;
+    addRenderer(canvas?: HTMLCanvasElement, rendererOptions?: Partial<RendererOptions & VTypeDoc['rendererExtraOpts']>): Renderer2dEntity<VTypeDoc>;
 }

package/dist/2d/models/body-options.d.ts

@@ -2,6 +2,6 @@ import { BodyOptions, DebugBodySettings } from '../../base';
 import { Shape2DDescriptor } from './shapes';
 export interface Body2DOptions extends BodyOptions {
 }
-export declare type DebugBody2DSettings = DebugBodySettings & {
+export type DebugBody2DSettings = DebugBodySettings & {
     shape: Shape2DDescriptor;
 };

package/dist/2d/models/shapes.d.ts

@@ -1,13 +1,15 @@
 import { Point2 } from '../../base';
 import { Body2DOptions } from './body-options';
-export declare type Shape2DDescriptor = {
+export type Shape2DDescriptor = {
+    collisionMargin?: number;
+} & ({
     shape: 'SQUARE';
     dimensions: Point2;
 } | {
     shape: 'CIRCLE';
     radius: number;
-};
-export declare type BodyShape2DDescriptor = {
+});
+export type BodyShape2DDescriptor = {
     shape: Shape2DDescriptor;
     body: Partial<Body2DOptions>;
 };

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

@@ -1,13 +1,13 @@
 import { Point3, Point4 } from '../../../base';
 import { IRigidBody3dComponent } from './i-rigid-body-3d.component';
 import { PhysicsTypeDocRepo3D } from '../../gg-3d-world';
-export declare type SuspensionOptions = {
+export type SuspensionOptions = {
     stiffness: number;
     damping: number;
     compression: number;
     restLength: number;
 };
-export declare type WheelOptions = {
+export type WheelOptions = {
     isLeft: boolean;
     isFront: boolean;
     tyreWidth: number;

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

@@ -1,7 +1,7 @@
 import { AnimationFunction, AnimationMixer, Point3, Point4 } from '../../../../base';
 import { Gg3dWorld, VisualTypeDocRepo3D } from '../../../gg-3d-world';
 import { Renderer3dEntity } from '../../renderer-3d.entity';
-export declare type Camera3dAnimationArgs = {
+export type Camera3dAnimationArgs = {
     position: Point3;
     target: Point3;
     up?: Point3;

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

@@ -1,7 +1,7 @@
 import { AnimationFunction, AnimationMixer, Point3, Point4 } from '../../../../base';
 import { Gg3dWorld, PhysicsTypeDocRepo3D, VisualTypeDocRepo3D } from '../../../gg-3d-world';
 import { IPositionable3d } from '../../../interfaces/i-positionable-3d';
-declare type Positioning3d = {
+type Positioning3d = {
     position: Point3;
     rotation: Point4;
 };

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

@@ -1,10 +1,10 @@
 import { Observable } from 'rxjs';
 import { DirectionKeyboardInput, DirectionKeyboardKeymap, GgWorld, IEntity, KeyboardInput, TickOrder } from '../../../../base';
-export declare type CarKeyboardControllerOptions = {
+export type CarKeyboardControllerOptions = {
     readonly keymap: DirectionKeyboardKeymap;
     readonly maxSteerDeltaPerSecond: number;
 };
-export declare type CarHandlingOutput = {
+export type CarHandlingOutput = {
     upDown: number;
     leftRight: number;
 };
@@ -12,7 +12,7 @@ export declare class CarKeyboardHandlingController extends IEntity {
     protected readonly keyboard: KeyboardInput;
     protected readonly options: CarKeyboardControllerOptions;
     readonly tickOrder = TickOrder.INPUT_CONTROLLERS;
-    protected readonly directionsInput: DirectionKeyboardInput;
+    readonly directionsInput: DirectionKeyboardInput;
     private _output$;
     get output$(): Observable<CarHandlingOutput>;
     constructor(keyboard: KeyboardInput, options?: CarKeyboardControllerOptions);

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

@@ -10,6 +10,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { combineLatest, filter, Subject, takeUntil } from 'rxjs';
 import { DirectionKeyboardInput, IEntity, TickOrder, } from '../../../../base';
 export class CarKeyboardHandlingController extends IEntity {
+    get output$() {
+        return this._output$.asObservable();
+    }
     constructor(keyboard, options = {
         keymap: 'arrows',
         maxSteerDeltaPerSecond: 12,
@@ -21,9 +24,6 @@ export class CarKeyboardHandlingController extends IEntity {
         this._output$ = new Subject();
         this.directionsInput = new DirectionKeyboardInput(keyboard, options.keymap);
     }
-    get output$() {
-        return this._output$.asObservable();
-    }
     onSpawned(world) {
         const _super = Object.create(null, {
             onSpawned: { get: () => super.onSpawned }

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

@@ -3,26 +3,37 @@ import { Renderer3dEntity } from '../../renderer-3d.entity';
 /**
  * Options for configuring a FreeCameraInput controller.
  */
-export declare type FreeCameraControllerOptions = {
+export type FreeCameraControllerOptions = {
     /**
-     * A keymap for controlling camera movement, where each key corresponds to a movement direction.
+     * A keymap for controlling camera movement, where each key corresponds to a movement direction. 'wasd' by default
      */
     keymap: DirectionKeyboardKeymap;
     /**
-     * Options for configuring camera movement.
+     * The speed of camera movement in meters per second. 20 by default
      */
-    movementOptions: {
-        /**
-         * The speed of camera movement.
-         */
-        speed: number;
-    };
+    cameraLinearSpeed: number;
     /**
-     * Flag to ignore cursor movement if pointer was not locked. By default false
+     * An elasticity factor for camera movement. 0 by default (no elastic motion)
+     */
+    cameraMovementElasticity: number;
+    /**
+     * A linear speed multiplier when user holds shift key. 2.5 by default
+     */
+    cameraBoostMultiplier: number;
+    /**
+     * The speed of camera rotation in radians per 1000px mouse movement. 1 by default
+     */
+    cameraRotationSensitivity: number;
+    /**
+     * An elasticity factor for camera rotation. 0 by default (no elastic motion)
+     */
+    cameraRotationElasticity: number;
+    /**
+     * Flag to ignore cursor movement if pointer was not locked. false by default
      */
     ignoreMouseUnlessPointerLocked: boolean;
     /**
-     * Flag to ignore keyboard events if pointer was not locked. By default false
+     * Flag to ignore keyboard events if pointer was not locked. false by default
      */
     ignoreKeyboardUnlessPointerLocked: boolean;
     /**
@@ -41,11 +52,11 @@ export declare class FreeCameraController extends IEntity {
     /**
      * The mouse input controller used for camera rotation.
      */
-    protected readonly mouseInput: MouseInput;
+    readonly mouseInput: MouseInput;
     /**
      * The keyboard input controller used for camera movement.
      */
-    protected readonly directionsInput: DirectionKeyboardInput;
+    readonly directionsInput: DirectionKeyboardInput;
     /**
      * Creates a new FreeCameraInput instance.
      * @param keyboard The keyboard input controller to use for camera movement.

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

@@ -7,11 +7,16 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { combineLatest, filter, takeUntil } from 'rxjs';
-import { DirectionKeyboardInput, IEntity, MouseInput, Pnt2, Pnt3, Qtrn, TickOrder, } from '../../../../base';
+import { BehaviorSubject, combineLatest, filter, takeUntil } from 'rxjs';
+import { DirectionKeyboardInput, ggElastic, IEntity, MouseInput, Pnt2, Pnt3, Qtrn, TickOrder, } from '../../../../base';
+import { map } from 'rxjs/operators';
 const DEFAULT_FREE_CAMERA_CONTROLLER_OPTIONS = {
     keymap: 'wasd',
-    movementOptions: { speed: 0.5 },
+    cameraLinearSpeed: 20,
+    cameraMovementElasticity: 0,
+    cameraBoostMultiplier: 2.5,
+    cameraRotationSensitivity: 1,
+    cameraRotationElasticity: 0,
     mouseOptions: {},
     ignoreMouseUnlessPointerLocked: false,
     ignoreKeyboardUnlessPointerLocked: false,
@@ -33,9 +38,9 @@ export class FreeCameraController extends IEntity {
         this.tickOrder = TickOrder.INPUT_CONTROLLERS;
         this.options = Object.assign(Object.assign({}, DEFAULT_FREE_CAMERA_CONTROLLER_OPTIONS), options);
         if (options.mouseOptions) {
-            this.options.movementOptions = Object.assign(Object.assign({}, DEFAULT_FREE_CAMERA_CONTROLLER_OPTIONS.movementOptions), options.mouseOptions);
+            this.options.mouseOptions = Object.assign(Object.assign({}, DEFAULT_FREE_CAMERA_CONTROLLER_OPTIONS.mouseOptions), options.mouseOptions);
         }
-        this.mouseInput = new MouseInput(options.mouseOptions);
+        this.mouseInput = new MouseInput(this.options.mouseOptions);
         this.directionsInput = new DirectionKeyboardInput(keyboard, this.options.keymap);
     }
     onSpawned(world) {
@@ -45,61 +50,77 @@ export class FreeCameraController extends IEntity {
         return __awaiter(this, void 0, void 0, function* () {
             yield _super.onSpawned.call(this, world);
             // Subscribe to keyboard input for movement controls
-            let controls = { direction: {}, rest: [] };
             const keys = ['KeyE', 'KeyQ'];
             if (this.camera.camera.supportsFov) {
                 keys.push('KeyZ', 'KeyC');
             }
             keys.push('ShiftLeft');
-            this.directionsInput.output$.pipe(takeUntil(this._onRemoved$)).subscribe(d => {
-                controls.direction = d;
-            });
-            combineLatest(keys.map(c => this.keyboard.bind(c)))
-                .pipe(takeUntil(this._onRemoved$))
-                .subscribe((d) => {
-                controls.rest = d;
-            });
-            // Subscribe to mouse input for camera rotation
-            let rotationDelta = Pnt2.O;
-            let isTouchScreen = MouseInput.isTouchDevice();
-            this.mouseInput.delta$
-                .pipe(takeUntil(this._onRemoved$), filter(() => isTouchScreen || !this.options.ignoreMouseUnlessPointerLocked || this.mouseInput.isPointerLocked))
-                .subscribe(delta => {
-                rotationDelta = Pnt2.add(rotationDelta, delta);
-            });
-            // Setup updating camera position and rotation based on input
-            this.camera.tick$.pipe(takeUntil(this._onRemoved$)).subscribe(() => {
-                let c = controls;
-                if (this.options.ignoreKeyboardUnlessPointerLocked && !this.mouseInput.isPointerLocked) {
-                    c = { direction: {}, rest: [false, false, false, false, false] };
+            let controlsObs = combineLatest([this.directionsInput.output$, ...keys.map(c => this.keyboard.bind(c))]).pipe(takeUntil(this._onRemoved$), map(([direction, ...rest]) => {
+                let c = { direction: {}, rest: [] };
+                if (!this.options.ignoreKeyboardUnlessPointerLocked || this.mouseInput.isPointerLocked) {
+                    c = { direction, rest };
                 }
-                let translateVector = Object.assign({}, Pnt3.O);
+                let translate = Object.assign({}, Pnt3.O);
                 const [u, d, zo, zi, speedBoost] = c.rest;
                 if (c.direction.upDown !== undefined)
-                    translateVector.z = c.direction.upDown ? -1 : 1;
+                    translate.z = c.direction.upDown ? -1 : 1;
                 if (c.direction.leftRight !== undefined)
-                    translateVector.x = c.direction.leftRight ? -1 : 1;
+                    translate.x = c.direction.leftRight ? -1 : 1;
                 if (u != d)
-                    translateVector.y = d ? -1 : 1;
+                    translate.y = d ? -1 : 1;
+                let cameraFovInc = 0;
                 if (zo != zi)
-                    this.camera.camera.fov += zo ? 1 : -1;
-                let speed = this.options.movementOptions.speed;
+                    cameraFovInc = zo ? 1 : -1;
+                translate = Pnt3.norm(translate);
                 if (speedBoost) {
-                    speed *= 2.5;
+                    translate = Pnt3.scalarMult(translate, this.options.cameraBoostMultiplier);
                 }
-                this.camera.position = Pnt3.add(this.camera.position, Pnt3.rot(Pnt3.scalarMult(Pnt3.norm(translateVector), speed), this.camera.rotation));
-                if (rotationDelta.x != 0 || rotationDelta.y != 0) {
-                    const spherical = Pnt3.toSpherical(Pnt3.rot({ x: 0, y: 0, z: -1 }, this.camera.rotation));
-                    spherical.theta -= rotationDelta.x / 300;
-                    spherical.phi += rotationDelta.y / 300;
+                return [translate, cameraFovInc];
+            }));
+            if (this.options.cameraMovementElasticity > 0) {
+                controlsObs = controlsObs.pipe(ggElastic(this.camera.tick$, this.options.cameraMovementElasticity, ([at, _], [bt, bf], f) => [Pnt3.lerp(at, bt, f), bf], ([at, af], [bt, bf]) => af == bf && Pnt3.dist(at, bt) < 0.001));
+            }
+            let translateVector = Pnt3.O;
+            let cameraFovInc = 0;
+            controlsObs.subscribe(([t, f]) => {
+                translateVector = t;
+                cameraFovInc = f;
+            });
+            // Subscribe to mouse input for camera rotation
+            const spherical = Pnt3.toSpherical(Pnt3.rot({ x: 0, y: 0, z: -1 }, this.camera.rotation));
+            let isTouchScreen = MouseInput.isTouchDevice();
+            let mouseDelta$ = this.mouseInput.delta$.pipe(takeUntil(this._onRemoved$), filter(() => isTouchScreen || !this.options.ignoreMouseUnlessPointerLocked || this.mouseInput.isPointerLocked));
+            if (this.options.cameraRotationElasticity > 0) {
+                const s$ = new BehaviorSubject(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.cameraRotationSensitivity) / 1000)),
+                        theta: s.theta - (delta.x * this.options.cameraRotationSensitivity) / 1000,
+                        radius: 1,
+                    });
+                });
+                s$.pipe(takeUntil(this._onRemoved$), ggElastic(this.tick$, this.options.cameraRotationElasticity, (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 => {
+                    spherical.theta = s.theta;
+                    spherical.phi = s.phi;
+                });
+            }
+            else {
+                mouseDelta$.subscribe(delta => {
+                    spherical.theta -= (delta.x * this.options.cameraRotationSensitivity) / 1000;
+                    spherical.phi += (delta.y * this.options.cameraRotationSensitivity) / 1000;
                     spherical.phi = Math.max(0.000001, Math.min(Math.PI - 0.000001, spherical.phi));
-                    this.camera.rotation = Qtrn.lookAt(this.camera.position, Pnt3.add(this.camera.position, Pnt3.fromSpherical(spherical)));
-                    rotationDelta = Pnt2.O;
-                }
+                });
+            }
+            // Setup updating camera position and rotation based on input
+            this.camera.tick$.pipe(takeUntil(this._onRemoved$)).subscribe(([_, delta]) => {
+                this.camera.camera.fov += cameraFovInc;
+                this.camera.position = Pnt3.add(this.camera.position, Pnt3.rot(Pnt3.scalarMult(translateVector, (this.options.cameraLinearSpeed * delta) / 1000), this.camera.rotation));
+                this.camera.rotation = Qtrn.lookAt(this.camera.position, Pnt3.add(this.camera.position, Pnt3.fromSpherical(spherical)));
             });
             // start input
-            yield this.mouseInput.start();
-            yield this.directionsInput.start();
+            this.mouseInput.start();
+            this.directionsInput.start();
         });
     }
     onRemoved() {

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

@@ -1,7 +1,7 @@
 import { GgWorld, IEntity, KeyboardInput, TickOrder } from '../../../../base';
 import { GgCarEntity } from '../../gg-car/gg-car.entity';
 import { CarKeyboardControllerOptions, CarKeyboardHandlingController } from './car-keyboard-handling.controller';
-export declare type GgCarKeyboardControllerOptions = CarKeyboardControllerOptions & {
+export type GgCarKeyboardControllerOptions = CarKeyboardControllerOptions & {
     gearUpDownKeys: [string, string];
     autoReverse: boolean;
     handbrakeKey: string;
@@ -11,7 +11,7 @@ export declare class GgCarKeyboardHandlingController extends IEntity {
     car: GgCarEntity | null;
     protected readonly options: GgCarKeyboardControllerOptions;
     readonly tickOrder = TickOrder.INPUT_CONTROLLERS;
-    protected readonly carHandlingInput: CarKeyboardHandlingController;
+    readonly carHandlingInput: CarKeyboardHandlingController;
     switchingGearsEnabled: boolean;
     constructor(keyboard: KeyboardInput, car: GgCarEntity | null, options?: GgCarKeyboardControllerOptions);
     onSpawned(world: GgWorld<any, any>): Promise<void>;