@gg-web-engine/core 0.0.56 → 0.0.58

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

@@ -0,0 +1,96 @@
+import { BodyOptions, IEntity, Point3, Point4 } from '../../base';
+import { Gg3dWorld, Gg3dWorldTypeDocPPatch, PhysicsTypeDocRepo3D } from '../gg-3d-world';
+import { Shape3DDescriptor } from '../models/shapes';
+/**
+ * Represents a function that calculates the surface position and normal
+ * for a given point in 3D space.
+ */
+export type SurfaceFollowFunc = (p: Point3) => {
+    position: Point3;
+    normal: Point3;
+};
+/**
+ * Represents an entity that follows a surface dynamically by adjusting
+ * its position and orientation based on a given surface function.
+ *
+ * @template PTypeDoc - The physics type document repository.
+ */
+export declare class SurfaceFollowingEntity<PTypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> extends IEntity<Point3, Point4, Gg3dWorldTypeDocPPatch<PTypeDoc>> {
+    /** Function that determines surface position and normal. */
+    followFunc: SurfaceFollowFunc;
+    /** Optional body configuration. */
+    protected bodyOptions: Partial<Omit<BodyOptions, 'dynamic' | 'mass' | 'ownCollisionGroups' | 'interactWithCollisionGroups'>>;
+    /**
+     * Determines the execution order for physics simulation.
+     */
+    readonly tickOrder: number;
+    /**
+     * Debugging settings for the surface-following entity.
+     */
+    readonly debugBodySettings: SurfaceFollowingEntityDebugSettings;
+    constructor(
+    /** Function that determines surface position and normal. */
+    followFunc: SurfaceFollowFunc, 
+    /** Optional body configuration. */
+    bodyOptions?: Partial<Omit<BodyOptions, 'dynamic' | 'mass' | 'ownCollisionGroups' | 'interactWithCollisionGroups'>>);
+    /**
+     * Stores colliders and their associated metadata.
+     */
+    private colliders;
+    /**
+     * Sets up a collider by assigning it a collision group and a dynamic plane.
+     *
+     * @param collider - The physics rigid body to configure.
+     */
+    private setupCollider;
+    /**
+     * Adds a collider to the entity, registering it immediately if the entity
+     * is already in a world.
+     *
+     * @param collider - The physics rigid body to add.
+     */
+    addCollider(collider: PTypeDoc['rigidBody']): void;
+    /**
+     * Removes a collider and deregisters its associated collision group.
+     *
+     * @param collider - The physics rigid body to remove.
+     */
+    removeCollider(collider: PTypeDoc['rigidBody']): void;
+    /**
+     * Called when the entity is added to a world.
+     *
+     * @param world - The game world instance.
+     */
+    onSpawned(world: Gg3dWorld<Gg3dWorldTypeDocPPatch<PTypeDoc>>): void;
+    private customGlobalDebugDummyBody;
+    /**
+     * Updates debug visualization if active.
+     */
+    private updateDebugView;
+    /**
+     * Called when the entity is removed from the world.
+     */
+    onRemoved(): void;
+    /**
+     * Positions planes based on the surface-follow function.
+     */
+    protected positionPlanes(): void;
+}
+/**
+ * Stores debug settings for a SurfaceFollowingEntity, allowing customization
+ * of the debug mesh.
+ */
+export declare class SurfaceFollowingEntityDebugSettings {
+    private _hexMeshStepDistance;
+    private _hexMeshDepth;
+    private _customGlobalShape;
+    private _revision;
+    get revision(): number;
+    get hexMeshStepDistance(): number;
+    set hexMeshStepDistance(value: number);
+    get hexMeshDepth(): number;
+    set hexMeshDepth(value: number);
+    get customGlobalShape(): Shape3DDescriptor | null;
+    set customGlobalShape(value: Shape3DDescriptor | null);
+    constructor(_hexMeshStepDistance?: number, _hexMeshDepth?: number, _customGlobalShape?: Shape3DDescriptor | null);
+}

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

@@ -0,0 +1,299 @@
+import { takeUntil } from 'rxjs';
+import { IEntity, Pnt2, Pnt3, Qtrn, TickOrder } from '../../base';
+/**
+ * Represents an entity that follows a surface dynamically by adjusting
+ * its position and orientation based on a given surface function.
+ *
+ * @template PTypeDoc - The physics type document repository.
+ */
+export class SurfaceFollowingEntity extends IEntity {
+    constructor(
+    /** Function that determines surface position and normal. */
+    followFunc, 
+    /** Optional body configuration. */
+    bodyOptions = {}) {
+        super();
+        this.followFunc = followFunc;
+        this.bodyOptions = bodyOptions;
+        /**
+         * Determines the execution order for physics simulation.
+         */
+        this.tickOrder = TickOrder.PHYSICS_SIMULATION - 1;
+        /**
+         * Debugging settings for the surface-following entity.
+         */
+        this.debugBodySettings = new SurfaceFollowingEntityDebugSettings();
+        /**
+         * Stores colliders and their associated metadata.
+         */
+        this.colliders = new Map();
+        this.customGlobalDebugDummyBody = null;
+    }
+    /**
+     * Sets up a collider by assigning it a collision group and a dynamic plane.
+     *
+     * @param collider - The physics rigid body to configure.
+     */
+    setupCollider(collider) {
+        if (!this.world) {
+            throw new Error('Cannot setup collider if not added to the world');
+        }
+        let cg = this.world.physicsWorld.registerCollisionGroup();
+        collider.ownCollisionGroups = [...collider.ownCollisionGroups, cg];
+        collider.interactWithCollisionGroups = [...collider.ownCollisionGroups, cg];
+        let plane = this.world.physicsWorld.factory.createRigidBody({
+            shape: { shape: 'PLANE' },
+            body: Object.assign(Object.assign({}, this.bodyOptions), { dynamic: false, ownCollisionGroups: [cg], interactWithCollisionGroups: [cg] }),
+        });
+        if (this.debugBodySettings.customGlobalShape) {
+            plane.debugBodySettings.shape = { shape: 'SPHERE', radius: 0.25 };
+        }
+        else {
+            plane.debugBodySettings.ignoreTransform = true;
+        }
+        this.addComponents(plane);
+        this.colliders.set(collider, [cg, plane, {}]);
+    }
+    /**
+     * Adds a collider to the entity, registering it immediately if the entity
+     * is already in a world.
+     *
+     * @param collider - The physics rigid body to add.
+     */
+    addCollider(collider) {
+        if (this.world) {
+            this.setupCollider(collider);
+        }
+        else {
+            this.colliders.set(collider, null);
+        }
+    }
+    /**
+     * Removes a collider and deregisters its associated collision group.
+     *
+     * @param collider - The physics rigid body to remove.
+     */
+    removeCollider(collider) {
+        if (!this.colliders.has(collider)) {
+            return;
+        }
+        const item = this.colliders.get(collider);
+        if (item) {
+            const [cg, plane] = item;
+            this.removeComponents([plane], true);
+            collider.ownCollisionGroups = collider.ownCollisionGroups.filter(g => g !== cg);
+            collider.interactWithCollisionGroups = collider.interactWithCollisionGroups.filter(g => g !== cg);
+            this.world.physicsWorld.deregisterCollisionGroup(cg);
+        }
+        this.colliders.delete(collider);
+    }
+    /**
+     * Called when the entity is added to a world.
+     *
+     * @param world - The game world instance.
+     */
+    onSpawned(world) {
+        if (!world.physicsWorld) {
+            throw new Error('Cannot add surface following entity to the world without physics');
+        }
+        super.onSpawned(world);
+        for (const [collider] of this.colliders.entries()) {
+            this.setupCollider(collider);
+        }
+        world.physicsWorld.removed$.pipe(takeUntil(this.onRemoved$)).subscribe(c => {
+            if (this.colliders.has(c)) {
+                this.removeCollider(c);
+            }
+        });
+        this.tick$.pipe(takeUntil(this.onRemoved$)).subscribe(() => {
+            this.positionPlanes();
+            this.updateDebugView();
+        });
+        this.positionPlanes();
+        this.updateDebugView();
+    }
+    /**
+     * Updates debug visualization if active.
+     */
+    updateDebugView() {
+        const updateDebugView = !!this.world.renderers.find(r => r.physicsDebugViewActive);
+        if (updateDebugView) {
+            if (this.debugBodySettings.customGlobalShape) {
+                if (!this.customGlobalDebugDummyBody) {
+                    this.customGlobalDebugDummyBody = this.world.physicsWorld.factory.createRigidBody({
+                        shape: { shape: 'BOX', dimensions: Pnt3.O },
+                        body: { dynamic: false },
+                    });
+                    this.customGlobalDebugDummyBody.ownCollisionGroups = [];
+                    this.customGlobalDebugDummyBody.interactWithCollisionGroups = [];
+                    this.customGlobalDebugDummyBody.debugBodySettings.type = { type: 'RIGID_STATIC' };
+                    this.customGlobalDebugDummyBody.debugBodySettings.shape = this.debugBodySettings.customGlobalShape;
+                    this.addComponents(this.customGlobalDebugDummyBody);
+                    for (const item of this.colliders.values()) {
+                        if (item) {
+                            let [_, plane] = item;
+                            plane.debugBodySettings.shape = { shape: 'SPHERE', radius: 0.25 };
+                            plane.debugBodySettings.ignoreTransform = false;
+                        }
+                    }
+                }
+                else {
+                    this.customGlobalDebugDummyBody.debugBodySettings.shape = this.debugBodySettings.customGlobalShape;
+                }
+            }
+            else {
+                if (this.customGlobalDebugDummyBody) {
+                    this.removeComponents([this.customGlobalDebugDummyBody], true);
+                    this.customGlobalDebugDummyBody = null;
+                    // reset caches
+                    for (const item of this.colliders.values()) {
+                        if (item) {
+                            item[2] = {};
+                        }
+                    }
+                }
+                for (const [collider, item] of this.colliders.entries()) {
+                    let [_, plane, debugCache] = item;
+                    const { position, normal } = this.followFunc(collider.position);
+                    let xThreshold = this.debugBodySettings.hexMeshStepDistance;
+                    let yThreshold = this.debugBodySettings.hexMeshStepDistance * Math.sqrt(3);
+                    let zThreshold = this.debugBodySettings.hexMeshStepDistance * 2;
+                    let hexMeshStartPosition = {
+                        x: Math.round(position.x / xThreshold) * xThreshold,
+                        y: Math.round(position.y / yThreshold) * yThreshold,
+                        z: Math.round(position.z / zThreshold) * zThreshold,
+                    };
+                    if (debugCache.lastDebugSettingsRev != this.debugBodySettings.revision ||
+                        !debugCache.lastDebugStartPos ||
+                        Pnt3.dist(debugCache.lastDebugStartPos, hexMeshStartPosition) > 1) {
+                        let { vertices, faces } = buildHexMeshAlongSurface(hexMeshStartPosition, this.followFunc, this.debugBodySettings.hexMeshDepth, this.debugBodySettings.hexMeshStepDistance);
+                        plane.debugBodySettings.shape = {
+                            shape: 'MESH',
+                            vertices,
+                            faces,
+                        };
+                        plane.debugBodySettings.ignoreTransform = true;
+                        debugCache.lastDebugStartPos = hexMeshStartPosition;
+                        debugCache.lastDebugSettingsRev = this.debugBodySettings.revision;
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Called when the entity is removed from the world.
+     */
+    onRemoved() {
+        for (const [collider, item] of this.colliders) {
+            if (item) {
+                const [cg, plane] = item;
+                this.removeComponents([plane], true);
+                collider.ownCollisionGroups = collider.ownCollisionGroups.filter(g => g !== cg);
+                collider.interactWithCollisionGroups = collider.interactWithCollisionGroups.filter(g => g !== cg);
+                this.world.physicsWorld.deregisterCollisionGroup(cg);
+            }
+        }
+        this.colliders.clear();
+        super.onRemoved();
+    }
+    /**
+     * Positions planes based on the surface-follow function.
+     */
+    positionPlanes() {
+        if (!this.world) {
+            return;
+        }
+        for (const [collider, item] of this.colliders.entries()) {
+            let [_, plane] = item;
+            const { position, normal } = this.followFunc(collider.position);
+            plane.position = position;
+            plane.rotation = Qtrn.lookAt(normal, Pnt3.O);
+        }
+    }
+}
+/**
+ * Stores debug settings for a SurfaceFollowingEntity, allowing customization
+ * of the debug mesh.
+ */
+export class SurfaceFollowingEntityDebugSettings {
+    get revision() {
+        return this._revision;
+    }
+    get hexMeshStepDistance() {
+        return this._hexMeshStepDistance;
+    }
+    set hexMeshStepDistance(value) {
+        this._hexMeshStepDistance = value;
+        this._revision++;
+    }
+    get hexMeshDepth() {
+        return this._hexMeshDepth;
+    }
+    set hexMeshDepth(value) {
+        this._hexMeshDepth = value;
+        this._revision++;
+    }
+    get customGlobalShape() {
+        return this._customGlobalShape;
+    }
+    set customGlobalShape(value) {
+        this._customGlobalShape = value;
+        this._revision++;
+    }
+    constructor(_hexMeshStepDistance = 4, _hexMeshDepth = 6, _customGlobalShape = null) {
+        this._hexMeshStepDistance = _hexMeshStepDistance;
+        this._hexMeshDepth = _hexMeshDepth;
+        this._customGlobalShape = _customGlobalShape;
+        this._revision = 0;
+    }
+}
+const buildHexMeshAlongSurface = (start, surfaceFunc, depth, stepDistance) => {
+    let startPoint = surfaceFunc(start);
+    const vertices = [startPoint.position];
+    const faces = [];
+    let lastLoop = [
+        {
+            position: startPoint.position,
+            normal: startPoint.normal,
+            vertexIndex: 0,
+        },
+    ];
+    const traverse = (point, angle) => {
+        let pnt2 = Pnt2.rot(Pnt2.scalarMult(Pnt2.X, stepDistance), angle);
+        let snorm = Pnt3.toSpherical(point.normal);
+        let spnt = Pnt3.toSpherical(Object.assign(Object.assign({}, pnt2), { z: 0 }));
+        return Pnt3.add(point.position, Pnt3.fromSpherical(Object.assign(Object.assign({}, spnt), { phi: spnt.phi + Math.cos(snorm.theta - spnt.theta) * snorm.phi })));
+    };
+    for (let i = 0; i < depth; i++) {
+        let newLoop = [];
+        if (i == 0) {
+            for (let j = 0; j < 6; j++) {
+                let point = surfaceFunc(traverse(startPoint, (j * Math.PI) / 3));
+                newLoop.push(Object.assign(Object.assign({}, point), { vertexIndex: j + 1 }));
+                faces.push([0, j + 1, j < 5 ? j + 2 : 1]);
+            }
+        }
+        else {
+            for (let j = 0; j < lastLoop.length; j++) {
+                let startPoint = lastLoop[j];
+                let angle = (Math.floor((j * 6) / lastLoop.length) * Math.PI) / 3;
+                let rightNeighbour = lastLoop[j < lastLoop.length - 1 ? j + 1 : 0];
+                if (j % (lastLoop.length / 6) == 0) {
+                    // hex corner vertex, add new vertex in this loop. Each next loop has +6 vertices
+                    let pointF = surfaceFunc(traverse(startPoint, angle));
+                    let vi = vertices.length + newLoop.length;
+                    newLoop.push(Object.assign(Object.assign({}, pointF), { vertexIndex: vi }));
+                    faces.push([startPoint.vertexIndex, j > 0 ? vi - 1 : vi + lastLoop.length + 5, vi]);
+                }
+                let pointR = surfaceFunc(Pnt3.avg(traverse(startPoint, angle + Math.PI / 3), traverse(rightNeighbour, angle)));
+                let vi = vertices.length + newLoop.length;
+                newLoop.push(Object.assign(Object.assign({}, pointR), { vertexIndex: vi }));
+                faces.push([startPoint.vertexIndex, vi - 1, vi]);
+                faces.push([rightNeighbour.vertexIndex, startPoint.vertexIndex, vi]);
+            }
+        }
+        vertices.push(...newLoop.map(({ position }) => position));
+        lastLoop = newLoop;
+    }
+    return { vertices, faces };
+};

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

@@ -2,12 +2,16 @@ import { Observable } from 'rxjs';
 import { ITrigger3dComponent } from '../components/physics/i-trigger-3d.component';
 import { IPositionable3d } from '../interfaces/i-positionable-3d';
 import { IEntity, Point3, Point4, TickOrder } from '../../base';
-import { PhysicsTypeDocRepo3D, VisualTypeDocRepo3D } from '../gg-3d-world';
-export declare class Trigger3dEntity<TypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> extends IEntity<Point3, Point4, VisualTypeDocRepo3D, TypeDoc> implements IPositionable3d {
+import { Gg3dWorldTypeDocPPatch, Gg3dWorldTypeDocRepo, PhysicsTypeDocRepo3D } from '../gg-3d-world';
+export declare class Trigger3dEntity<PTypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> extends IEntity<Point3, Point4, Gg3dWorldTypeDocPPatch<PTypeDoc>> implements IPositionable3d {
     readonly objectBody: ITrigger3dComponent;
     readonly tickOrder = TickOrder.OBJECTS_BINDING;
-    get onEntityEntered(): Observable<IEntity<Point3, Point4, VisualTypeDocRepo3D, TypeDoc> & IPositionable3d>;
-    get onEntityLeft(): Observable<(IEntity<Point3, Point4, VisualTypeDocRepo3D, TypeDoc> & IPositionable3d) | null>;
+    get onEntityEntered(): Observable<IEntity<Point3, Point4, Gg3dWorldTypeDocRepo & {
+        pTypeDoc: PTypeDoc;
+    }> & IPositionable3d>;
+    get onEntityLeft(): Observable<(IEntity<Point3, Point4, Gg3dWorldTypeDocRepo & {
+        pTypeDoc: PTypeDoc;
+    }> & IPositionable3d) | null>;
     private _position;
     get position(): Point3;
     set position(value: Point3);

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

@@ -8,32 +8,32 @@ export type DisplayObject3dOpts<Tex> = {
     castShadow?: boolean;
     receiveShadow?: boolean;
 };
-export declare abstract class IDisplayObject3dComponentFactory<TypeDoc extends VisualTypeDocRepo3D = VisualTypeDocRepo3D> {
-    abstract createPrimitive(descriptor: Shape3DMeshDescriptor, material?: DisplayObject3dOpts<TypeDoc['texture']>): TypeDoc['displayObject'];
-    abstract createPerspectiveCamera(settings: {
+export declare abstract class IDisplayObject3dComponentFactory<VTypeDoc extends VisualTypeDocRepo3D = VisualTypeDocRepo3D> {
+    abstract createPrimitive(descriptor: Shape3DMeshDescriptor, material?: DisplayObject3dOpts<VTypeDoc['texture']>): VTypeDoc['displayObject'];
+    abstract createPerspectiveCamera(settings?: {
         fov?: number;
         aspectRatio?: number;
         frustrum?: {
             near: number;
             far: number;
         };
-    }): TypeDoc['camera'];
+    }): VTypeDoc['camera'];
     randomColor(): number;
-    createPlane(material?: DisplayObject3dOpts<TypeDoc['texture']>): TypeDoc['displayObject'];
-    createBox(dimensions: Point3, material?: DisplayObject3dOpts<TypeDoc['texture']>): TypeDoc['displayObject'];
-    createCapsule(radius: number, centersDistance: number, material?: DisplayObject3dOpts<TypeDoc['texture']>): TypeDoc['displayObject'];
-    createCylinder(radius: number, height: number, material?: DisplayObject3dOpts<TypeDoc['texture']>): TypeDoc['displayObject'];
-    createCone(radius: number, height: number, material?: DisplayObject3dOpts<TypeDoc['texture']>): TypeDoc['displayObject'];
-    createSphere(radius: number, material?: DisplayObject3dOpts<TypeDoc['texture']>): TypeDoc['displayObject'];
+    createPlane(material?: DisplayObject3dOpts<VTypeDoc['texture']>): VTypeDoc['displayObject'];
+    createBox(dimensions: Point3, material?: DisplayObject3dOpts<VTypeDoc['texture']>): VTypeDoc['displayObject'];
+    createCapsule(radius: number, centersDistance: number, material?: DisplayObject3dOpts<VTypeDoc['texture']>): VTypeDoc['displayObject'];
+    createCylinder(radius: number, height: number, material?: DisplayObject3dOpts<VTypeDoc['texture']>): VTypeDoc['displayObject'];
+    createCone(radius: number, height: number, material?: DisplayObject3dOpts<VTypeDoc['texture']>): VTypeDoc['displayObject'];
+    createSphere(radius: number, material?: DisplayObject3dOpts<VTypeDoc['texture']>): VTypeDoc['displayObject'];
 }
-export interface IPhysicsBody3dComponentFactory<TypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> {
+export interface IPhysicsBody3dComponentFactory<PTypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> {
     createRigidBody(descriptor: BodyShape3DDescriptor, transform?: {
         position?: Point3;
         rotation?: Point4;
-    }): TypeDoc['rigidBody'];
+    }): PTypeDoc['rigidBody'];
     createTrigger(descriptor: Shape3DDescriptor, transform?: {
         position?: Point3;
         rotation?: Point4;
-    }): TypeDoc['trigger'];
-    createRaycastVehicle(chassis: TypeDoc['rigidBody']): TypeDoc['raycastVehicle'];
+    }): PTypeDoc['trigger'];
+    createRaycastVehicle(chassis: PTypeDoc['rigidBody']): PTypeDoc['raycastVehicle'];
 }

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

@@ -29,13 +29,41 @@ export type PhysicsTypeDocRepo3D = {
     trigger: ITrigger3dComponent;
     raycastVehicle: IRaycastVehicleComponent;
 };
-export declare class Gg3dWorld<VTypeDoc extends VisualTypeDocRepo3D = VisualTypeDocRepo3D, PTypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D, VS extends IVisualScene3dComponent<VTypeDoc> = IVisualScene3dComponent<VTypeDoc>, PW extends IPhysicsWorld3dComponent<PTypeDoc> = IPhysicsWorld3dComponent<PTypeDoc>> extends GgWorld<Point3, Point4, VTypeDoc, PTypeDoc, VS, PW> {
-    readonly visualScene: VS;
-    readonly physicsWorld: PW;
-    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 & VTypeDoc['rendererExtraOpts']>): Renderer3dEntity<VTypeDoc>;
+export type Gg3dWorldTypeDocRepo = {
+    vTypeDoc: VisualTypeDocRepo3D;
+    pTypeDoc: PhysicsTypeDocRepo3D;
+};
+export type Gg3dWorldTypeDocVPatch<VTypeDoc extends VisualTypeDocRepo3D> = Omit<Gg3dWorldTypeDocRepo, 'vTypeDoc'> & {
+    vTypeDoc: VTypeDoc;
+};
+export type Gg3dWorldTypeDocPPatch<PTypeDoc extends PhysicsTypeDocRepo3D> = Omit<Gg3dWorldTypeDocRepo, 'pTypeDoc'> & {
+    pTypeDoc: PTypeDoc;
+};
+export type Gg3dWorldSceneTypeRepo<TypeDoc extends Gg3dWorldTypeDocRepo = Gg3dWorldTypeDocRepo> = {
+    visualScene: IVisualScene3dComponent<TypeDoc['vTypeDoc']> | null;
+    physicsWorld: IPhysicsWorld3dComponent<TypeDoc['pTypeDoc']> | null;
+};
+export type Gg3dWorldSceneTypeDocVPatch<VTypeDoc extends VisualTypeDocRepo3D, VS extends IVisualScene3dComponent<VTypeDoc> | null> = Omit<Gg3dWorldSceneTypeRepo, 'visualScene'> & {
+    visualScene: VS;
+};
+export type Gg3dWorldSceneTypeDocPPatch<PTypeDoc extends PhysicsTypeDocRepo3D, PW extends IPhysicsWorld3dComponent<PTypeDoc> | null> = Omit<Gg3dWorldSceneTypeRepo, 'physicsWorld'> & {
+    physicsWorld: PW;
+};
+export type TypedGg3dWorld<VW extends Gg3dWorld<any> | null, PW extends Gg3dWorld<any> | null> = VW extends Gg3dWorld<infer VTD, infer VSTD> | null ? PW extends Gg3dWorld<infer PTD, infer PSTD> | null ? Gg3dWorld<{
+    vTypeDoc: VTD['vTypeDoc'];
+    pTypeDoc: PTD['pTypeDoc'];
+}, {
+    visualScene: VSTD['visualScene'];
+    physicsWorld: PSTD['physicsWorld'];
+}> : never : never;
+export declare class Gg3dWorld<TypeDoc extends Gg3dWorldTypeDocRepo = Gg3dWorldTypeDocRepo, SceneTypeDoc extends Gg3dWorldSceneTypeRepo<TypeDoc> = Gg3dWorldSceneTypeRepo<TypeDoc>> extends GgWorld<Point3, Point4, TypeDoc, SceneTypeDoc> {
+    readonly loader: Gg3dLoader<TypeDoc>;
+    constructor(args: {
+        visualScene?: SceneTypeDoc['visualScene'];
+        physicsWorld?: SceneTypeDoc['physicsWorld'];
+    });
+    addPrimitiveRigidBody(descr: BodyShape3DDescriptor, position?: Point3, rotation?: Point4, material?: DisplayObject3dOpts<TypeDoc['vTypeDoc']['texture']>): Entity3d<TypeDoc>;
+    addRenderer(camera: TypeDoc['vTypeDoc']['camera'], canvas?: HTMLCanvasElement, rendererOptions?: Partial<RendererOptions & TypeDoc['vTypeDoc']['rendererExtraOpts']>): Renderer3dEntity<TypeDoc['vTypeDoc']>;
     protected registerConsoleCommands(ggstatic: {
         registerConsoleCommand: (world: GgWorld<any, any> | null, command: string, handler: (...args: string[]) => Promise<string>, doc?: string) => void;
     }): void;

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

@@ -12,16 +12,15 @@ 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) {
-        super(visualScene, physicsWorld);
-        this.visualScene = visualScene;
-        this.physicsWorld = physicsWorld;
+    constructor(args) {
+        super(args);
         this.loader = new Gg3dLoader(this);
     }
     addPrimitiveRigidBody(descr, position = Pnt3.O, rotation = Qtrn.O, material = {}) {
+        var _a, _b;
         const entity = new Entity3d({
-            object3D: this.visualScene.factory.createPrimitive(descr.shape, material),
-            objectBody: this.physicsWorld.factory.createRigidBody(descr),
+            object3D: (_a = this.visualScene) === null || _a === void 0 ? void 0 : _a.factory.createPrimitive(descr.shape, material),
+            objectBody: (_b = this.physicsWorld) === null || _b === void 0 ? void 0 : _b.factory.createRigidBody(descr),
         });
         entity.position = position;
         entity.rotation = rotation;
@@ -29,25 +28,30 @@ export class Gg3dWorld extends GgWorld {
         return entity;
     }
     addRenderer(camera, canvas, rendererOptions) {
+        if (!this.visualScene) {
+            throw new Error('Cannot add renderer to the world without visual scene');
+        }
         const entity = new Renderer3dEntity(this.visualScene.createRenderer(camera, canvas, rendererOptions));
         this.addEntity(entity);
         return entity;
     }
     registerConsoleCommands(ggstatic) {
         super.registerConsoleCommands(ggstatic);
-        ggstatic.registerConsoleCommand(this, 'gravity', (...args) => __awaiter(this, void 0, void 0, function* () {
-            if (args.length == 1) {
-                args = ['0', '0', '' + -+args[0]]; // mean -Z axis
-            }
-            if (args.length > 0) {
-                if (isNaN(+args[0]) || isNaN(+args[1]) || isNaN(+args[2])) {
-                    throw new Error('Wrong arguments');
+        if (this.physicsWorld) {
+            ggstatic.registerConsoleCommand(this, 'gravity', (...args) => __awaiter(this, void 0, void 0, function* () {
+                if (args.length == 1) {
+                    args = ['0', '0', '' + -+args[0]]; // mean -Z axis
                 }
-                this.physicsWorld.gravity = { x: +args[0], y: +args[1], z: +args[2] };
-            }
-            return JSON.stringify(this.physicsWorld.gravity);
-        }), 'args: [ ?float, ?float, ?float ]; Get or set 3D world gravity vector. 1 argument sets ' +
-            'vector {x: 0, y: 0, z: -value}, 3 arguments set the whole vector.' +
-            ' Default value is "9.82" or "0 0 -9.82"');
+                if (args.length > 0) {
+                    if (isNaN(+args[0]) || isNaN(+args[1]) || isNaN(+args[2])) {
+                        throw new Error('Wrong arguments');
+                    }
+                    this.physicsWorld.gravity = { x: +args[0], y: +args[1], z: +args[2] };
+                }
+                return JSON.stringify(this.physicsWorld.gravity);
+            }), 'args: [ ?float, ?float, ?float ]; Get or set 3D world gravity vector. 1 argument sets ' +
+                'vector {x: 0, y: 0, z: -value}, 3 arguments set the whole vector.' +
+                ' Default value is "9.82" or "0 0 -9.82"');
+        }
     }
 }

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

@@ -19,6 +19,7 @@ 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 './entities/surface-following.entity';
 export * from './interfaces/i-positionable-3d';
 export * from './models/body-options';
 export * from './models/gg-meta';

package/dist/3d/index.js

@@ -19,6 +19,7 @@ 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 './entities/surface-following.entity';
 export * from './interfaces/i-positionable-3d';
 export * from './models/body-options';
 export * from './models/gg-meta';

package/dist/3d/loader.d.ts

@@ -1,4 +1,4 @@
-import { Gg3dWorld, PhysicsTypeDocRepo3D, VisualTypeDocRepo3D } from './gg-3d-world';
+import { Gg3dWorld, Gg3dWorldTypeDocRepo } from './gg-3d-world';
 import { GgMeta } from './models/gg-meta';
 import { Entity3d } from './entities/entity-3d';
 import { Point3, Point4 } from '../base';
@@ -14,26 +14,26 @@ export type LoadOptions = {
     loadProps: boolean;
     propsPath?: string;
 };
-export type LoadResourcesResult<VTypeDoc extends VisualTypeDocRepo3D = VisualTypeDocRepo3D, PTypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> = {
+export type LoadResourcesResult<TypeDoc extends Gg3dWorldTypeDocRepo = Gg3dWorldTypeDocRepo> = {
     resources: {
-        object3D: VTypeDoc['displayObject'] | null;
-        body: PTypeDoc['rigidBody'] | null;
+        object3D: TypeDoc['vTypeDoc']['displayObject'] | null;
+        body: TypeDoc['pTypeDoc']['rigidBody'] | null;
     }[];
     meta: GgMeta;
 };
-export type LoadResult<VTypeDoc extends VisualTypeDocRepo3D = VisualTypeDocRepo3D, PTypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> = {
-    entities: Entity3d<VTypeDoc, PTypeDoc>[];
+export type LoadResult<TypeDoc extends Gg3dWorldTypeDocRepo = Gg3dWorldTypeDocRepo> = {
+    entities: Entity3d<TypeDoc>[];
     meta: GgMeta;
 };
-export type LoadResultWithProps<VTypeDoc extends VisualTypeDocRepo3D = VisualTypeDocRepo3D, PTypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> = LoadResult<VTypeDoc, PTypeDoc> & {
-    props?: LoadResult<VTypeDoc, PTypeDoc>[];
+export type LoadResultWithProps<TypeDoc extends Gg3dWorldTypeDocRepo = Gg3dWorldTypeDocRepo> = LoadResult<TypeDoc> & {
+    props?: LoadResult<TypeDoc>[];
 };
-export declare class Gg3dLoader<VTypeDoc extends VisualTypeDocRepo3D = VisualTypeDocRepo3D, PTypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> {
+export declare class Gg3dLoader<TypeDoc extends Gg3dWorldTypeDocRepo = Gg3dWorldTypeDocRepo> {
     protected readonly world: Gg3dWorld;
     readonly filesCache: Map<string, [ArrayBuffer, GgMeta] | Promise<[ArrayBuffer, GgMeta]>>;
-    readonly loadResultCache: Map<string, LoadResourcesResult<VTypeDoc, PTypeDoc> | Promise<LoadResourcesResult<VTypeDoc, PTypeDoc>>>;
+    readonly loadResultCache: Map<string, LoadResourcesResult<TypeDoc> | Promise<LoadResourcesResult<TypeDoc>>>;
     constructor(world: Gg3dWorld);
     loadGgGlbFiles(path: string, useCache?: boolean): Promise<[ArrayBuffer, GgMeta]>;
-    loadGgGlbResources(path: string, cachingStrategy?: CachingStrategy): Promise<LoadResourcesResult<VTypeDoc, PTypeDoc>>;
-    loadGgGlb(path: string, options?: Partial<LoadOptions>): Promise<LoadResultWithProps<VTypeDoc, PTypeDoc>>;
+    loadGgGlbResources(path: string, cachingStrategy?: CachingStrategy): Promise<LoadResourcesResult<TypeDoc>>;
+    loadGgGlb(path: string, options?: Partial<LoadOptions>): Promise<LoadResultWithProps<TypeDoc>>;
 }