@gg-web-engine/core 0.0.57 → 0.0.58

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

@@ -93,6 +93,9 @@ export class SurfaceFollowingEntity extends IEntity {
      * @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);

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/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>>;
 }

package/dist/3d/loader.js

@@ -57,6 +57,7 @@ export class Gg3dLoader {
     }
     loadGgGlbResources(path_1) {
         return __awaiter(this, arguments, void 0, function* (path, cachingStrategy = CachingStrategy.Nothing) {
+            var _a, _b;
             if (cachingStrategy == CachingStrategy.Entities && this.loadResultCache.has(path)) {
                 const cached = this.loadResultCache.get(path);
                 const cachedResult = cached instanceof Promise ? yield cached : cached;
@@ -67,21 +68,21 @@ export class Gg3dLoader {
                 throw new Error('GLB not found');
             }
             const [object, bodies] = yield Promise.all([
-                this.world.visualScene.loader.loadFromGgGlb(glb, meta),
-                this.world.physicsWorld.loader.loadFromGgGlb(glb, meta),
+                (_a = this.world.visualScene) === null || _a === void 0 ? void 0 : _a.loader.loadFromGgGlb(glb, meta),
+                (_b = this.world.physicsWorld) === null || _b === void 0 ? void 0 : _b.loader.loadFromGgGlb(glb, meta),
             ]);
             const result = { resources: [], meta };
             if (!object) {
                 return result;
             }
-            if (bodies.length == 0) {
+            if ((bodies === null || bodies === void 0 ? void 0 : bodies.length) == 0) {
                 result.resources.push({ object3D: object, body: null });
             }
-            else if (bodies.length == 1) {
+            else if ((bodies === null || bodies === void 0 ? void 0 : bodies.length) == 1) {
                 result.resources.push({ object3D: object, body: bodies[0] });
             }
             else {
-                for (const body of bodies) {
+                for (const body of bodies || []) {
                     result.resources.push({ object3D: object.popChild(body.name), body });
                 }
                 if (!object.isEmpty()) {

package/dist/3d/loaders.d.ts

@@ -1,11 +1,11 @@
 import { GgMeta } from './models/gg-meta';
 import { IPhysicsWorld3dComponent } from './components/physics/i-physics-world-3d.component';
 import { PhysicsTypeDocRepo3D, VisualTypeDocRepo3D } from './gg-3d-world';
-export declare abstract class IPhysicsBody3dComponentLoader<TypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> {
+export declare abstract class IPhysicsBody3dComponentLoader<PTypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> {
     protected readonly world: IPhysicsWorld3dComponent;
     protected constructor(world: IPhysicsWorld3dComponent);
-    loadFromGgGlb(glbFile: ArrayBuffer, meta: GgMeta): Promise<TypeDoc['rigidBody'][]>;
+    loadFromGgGlb(glbFile: ArrayBuffer, meta: GgMeta): Promise<PTypeDoc['rigidBody'][]>;
 }
-export interface IDisplayObject3dComponentLoader<TypeDoc extends VisualTypeDocRepo3D = VisualTypeDocRepo3D> {
-    loadFromGgGlb(glbFile: ArrayBuffer, meta: GgMeta): Promise<TypeDoc['displayObject'] | null>;
+export interface IDisplayObject3dComponentLoader<VTypeDoc extends VisualTypeDocRepo3D = VisualTypeDocRepo3D> {
+    loadFromGgGlb(glbFile: ArrayBuffer, meta: GgMeta): Promise<VTypeDoc['displayObject'] | null>;
 }

package/dist/base/components/i-world-component.d.ts

@@ -1,8 +1,8 @@
 import { IEntity } from '../entities/i-entity';
-import { GgWorld, PhysicsTypeDocRepo, VisualTypeDocRepo } from '../gg-world';
-export interface IWorldComponent<D, R, VTypeDoc extends VisualTypeDocRepo<D, R> = VisualTypeDocRepo<D, R>, PTypeDoc extends PhysicsTypeDocRepo<D, R> = PhysicsTypeDocRepo<D, R>> {
+import { GgWorld, GgWorldTypeDocRepo } from '../gg-world';
+import { IComponent } from './i-component';
+export interface IWorldComponent<D, R, TypeDoc extends GgWorldTypeDocRepo<D, R> = GgWorldTypeDocRepo<D, R>> extends IComponent {
     entity: IEntity | null;
-    addToWorld(world: GgWorld<D, R, VTypeDoc, PTypeDoc>): void;
-    removeFromWorld(world: GgWorld<D, R, VTypeDoc, PTypeDoc>, dispose?: boolean): void;
-    dispose(): void;
+    addToWorld(world: GgWorld<D, R, TypeDoc>): void;
+    removeFromWorld(world: GgWorld<D, R, TypeDoc>, dispose?: boolean): void;
 }

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

@@ -1,8 +1,8 @@
 import { IEntity } from '../../entities/i-entity';
 import { IWorldComponent } from '../i-world-component';
-import { GgWorld, PhysicsTypeDocRepo, VisualTypeDocRepo } from '../../gg-world';
+import { GgWorld, GgWorldTypeDocPPatch, PhysicsTypeDocRepo } from '../../gg-world';
 import { CollisionGroup, DebugBodySettings } from '../../models/body-options';
-export interface IBodyComponent<D, R, TypeDoc extends PhysicsTypeDocRepo<D, R> = PhysicsTypeDocRepo<D, R>> extends IWorldComponent<D, R, VisualTypeDocRepo<D, R>, TypeDoc> {
+export interface IBodyComponent<D, R, PTypeDoc extends PhysicsTypeDocRepo<D, R> = PhysicsTypeDocRepo<D, R>> extends IWorldComponent<D, R, GgWorldTypeDocPPatch<D, R, PTypeDoc>> {
     entity: IEntity | null;
     position: D;
     rotation: R;
@@ -13,7 +13,7 @@ export interface IBodyComponent<D, R, TypeDoc extends PhysicsTypeDocRepo<D, R> =
     set interactWithCollisionGroups(value: ReadonlyArray<CollisionGroup> | 'all');
     /** body info for physics debugger view */
     readonly debugBodySettings: DebugBodySettings<any>;
-    clone(): IBodyComponent<D, R, TypeDoc>;
-    addToWorld(world: GgWorld<D, R, VisualTypeDocRepo<D, R>, TypeDoc>): void;
-    removeFromWorld(world: GgWorld<D, R, VisualTypeDocRepo<D, R>, TypeDoc>): void;
+    clone(): IBodyComponent<D, R, PTypeDoc>;
+    addToWorld(world: GgWorld<D, R, GgWorldTypeDocPPatch<D, R, PTypeDoc>>): void;
+    removeFromWorld(world: GgWorld<D, R, GgWorldTypeDocPPatch<D, R, PTypeDoc>>): void;
 }

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

@@ -2,6 +2,7 @@ import { PhysicsTypeDocRepo } from '../../gg-world';
 import { IComponent } from '../i-component';
 import { CollisionGroup } from '../../models/body-options';
 import { Subject } from 'rxjs';
+import { RaycastOptions, RaycastResult } from '../../models/raycasting';
 /**
  * Interface representing a physics world component.
  *
@@ -9,11 +10,11 @@ import { Subject } from 'rxjs';
  * @template R - Type representing the physics engine's rigid body.
  * @template TypeDoc - Physics typings repository.
  */
-export interface IPhysicsWorldComponent<D, R, TypeDoc extends PhysicsTypeDocRepo<D, R> = PhysicsTypeDocRepo<D, R>> extends IComponent {
+export interface IPhysicsWorldComponent<D, R, PTypeDoc extends PhysicsTypeDocRepo<D, R> = PhysicsTypeDocRepo<D, R>> extends IComponent {
     /**
      * Factory function for creating physics-related objects.
      */
-    readonly factory: TypeDoc['factory'];
+    readonly factory: PTypeDoc['factory'];
     /**
      * The gravity vector affecting the physics world.
      */
@@ -21,15 +22,15 @@ export interface IPhysicsWorldComponent<D, R, TypeDoc extends PhysicsTypeDocRepo
     /**
      * Event emitter that emits newly added physics components.
      */
-    readonly added$: Subject<TypeDoc['rigidBody'] | TypeDoc['trigger'] | any>;
+    readonly added$: Subject<PTypeDoc['rigidBody'] | PTypeDoc['trigger'] | any>;
     /**
      * Event emitter that emits just removed physics components.
      */
-    readonly removed$: Subject<TypeDoc['rigidBody'] | TypeDoc['trigger'] | any>;
+    readonly removed$: Subject<PTypeDoc['rigidBody'] | PTypeDoc['trigger'] | any>;
     /**
      * List of currently added physics components in the world.
      */
-    readonly children: (TypeDoc['rigidBody'] | TypeDoc['trigger'] | any)[];
+    readonly children: (PTypeDoc['rigidBody'] | PTypeDoc['trigger'] | any)[];
     /**
      * The main collision group. All physics bodies have this collision group set by default.
      */
@@ -58,4 +59,11 @@ export interface IPhysicsWorldComponent<D, R, TypeDoc extends PhysicsTypeDocRepo
      * @param group - The collision group to be removed.
      */
     deregisterCollisionGroup(group: CollisionGroup): void;
+    /**
+     * Performs a raycast in the physics world.
+     *
+     * @param options - The options for the raycast.
+     * @returns The result of the raycast.
+     */
+    raycast(options: RaycastOptions<D>): RaycastResult<D, PTypeDoc['rigidBody'] | PTypeDoc['trigger']>;
 }

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

@@ -1,9 +1,9 @@
 import { IBodyComponent } from './i-body.component';
 import { PhysicsTypeDocRepo } from '../../gg-world';
-export interface IRigidBodyComponent<D, R, TypeDoc extends PhysicsTypeDocRepo<D, R> = PhysicsTypeDocRepo<D, R>> extends IBodyComponent<D, R, TypeDoc> {
+export interface IRigidBodyComponent<D, R, PTypeDoc extends PhysicsTypeDocRepo<D, R> = PhysicsTypeDocRepo<D, R>> extends IBodyComponent<D, R, PTypeDoc> {
     linearVelocity: D;
     angularVelocity: R | D;
-    clone(): IRigidBodyComponent<D, R, TypeDoc>;
+    clone(): IRigidBodyComponent<D, R, PTypeDoc>;
     /** clear velocities etc. */
     resetMotion(): void;
 }

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

@@ -2,9 +2,9 @@ import { Observable } from 'rxjs';
 import { IRigidBodyComponent } from './i-rigid-body.component';
 import { IBodyComponent } from './i-body.component';
 import { PhysicsTypeDocRepo } from '../../gg-world';
-export interface ITriggerComponent<D, R, TypDoc extends PhysicsTypeDocRepo<D, R> = PhysicsTypeDocRepo<D, R>> extends IBodyComponent<D, R, TypDoc> {
-    get onEntityEntered(): Observable<IRigidBodyComponent<D, R, TypDoc>>;
-    get onEntityLeft(): Observable<IRigidBodyComponent<D, R, TypDoc> | null>;
-    clone(): ITriggerComponent<D, R, TypDoc>;
+export interface ITriggerComponent<D, R, PTypeDoc extends PhysicsTypeDocRepo<D, R> = PhysicsTypeDocRepo<D, R>> extends IBodyComponent<D, R, PTypeDoc> {
+    get onEntityEntered(): Observable<IRigidBodyComponent<D, R, PTypeDoc>>;
+    get onEntityLeft(): Observable<IRigidBodyComponent<D, R, PTypeDoc> | null>;
+    clone(): ITriggerComponent<D, R, PTypeDoc>;
     checkOverlaps(): void;
 }

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

@@ -1,15 +1,15 @@
-import { GgBox, GgWorld, VisualTypeDocRepo } from '../../../base';
+import { GgBox, GgWorld, GgWorldTypeDocVPatch, VisualTypeDocRepo } from '../../../base';
 import { IWorldComponent } from '../i-world-component';
-export interface IDisplayObjectComponent<D, R, TypeDoc extends VisualTypeDocRepo<D, R> = VisualTypeDocRepo<D, R>> extends IWorldComponent<D, R, TypeDoc> {
+export interface IDisplayObjectComponent<D, R, VTypeDoc extends VisualTypeDocRepo<D, R> = VisualTypeDocRepo<D, R>> extends IWorldComponent<D, R, GgWorldTypeDocVPatch<D, R, VTypeDoc>> {
     position: D;
     rotation: R;
     scale: D;
     visible: boolean;
     name: string;
     isEmpty(): boolean;
-    popChild(name: string): IDisplayObjectComponent<D, R, TypeDoc> | null;
+    popChild(name: string): IDisplayObjectComponent<D, R, VTypeDoc> | null;
     getBoundings(): GgBox<D>;
-    clone(): IDisplayObjectComponent<D, R, TypeDoc>;
-    addToWorld(world: GgWorld<D, R, TypeDoc>): void;
-    removeFromWorld(world: GgWorld<D, R, TypeDoc>): void;
+    clone(): IDisplayObjectComponent<D, R, VTypeDoc>;
+    addToWorld(world: GgWorld<D, R, GgWorldTypeDocVPatch<D, R, VTypeDoc>>): void;
+    removeFromWorld(world: GgWorld<D, R, GgWorldTypeDocVPatch<D, R, VTypeDoc>>): void;
 }

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

@@ -1,7 +1,7 @@
 import { Point2 } from '../../models/points';
 import { Observable } from 'rxjs';
 import { IWorldComponent } from '../i-world-component';
-import { GgWorld, VisualTypeDocRepo } from '../../gg-world';
+import { GgWorld, GgWorldTypeDocVPatch, VisualTypeDocRepo } from '../../gg-world';
 import { IEntity } from '../../entities/i-entity';
 import { IVisualSceneComponent } from './i-visual-scene.component';
 /**
@@ -20,7 +20,7 @@ export type RendererOptions = {
     forceResolution?: number;
     antialias: boolean;
 };
-export declare abstract class IRendererComponent<D, R, VTypeDoc extends VisualTypeDocRepo<D, R> = VisualTypeDocRepo<D, R>> implements IWorldComponent<D, R, VTypeDoc> {
+export declare abstract class IRendererComponent<D, R, VTypeDoc extends VisualTypeDocRepo<D, R> = VisualTypeDocRepo<D, R>> implements IWorldComponent<D, R, GgWorldTypeDocVPatch<D, R, VTypeDoc>> {
     readonly scene: IVisualSceneComponent<D, R, VTypeDoc>;
     readonly canvas?: HTMLCanvasElement | undefined;
     entity: IEntity | null;
@@ -35,8 +35,8 @@ export declare abstract class IRendererComponent<D, R, VTypeDoc extends VisualTy
      * Renders the scene.
      */
     abstract render(): void;
-    abstract addToWorld(world: GgWorld<D, R, VTypeDoc>): void;
-    abstract removeFromWorld(world: GgWorld<D, R, VTypeDoc>): void;
+    abstract addToWorld(world: GgWorld<D, R, GgWorldTypeDocVPatch<D, R, VTypeDoc>>): void;
+    abstract removeFromWorld(world: GgWorld<D, R, GgWorldTypeDocVPatch<D, R, VTypeDoc>>): void;
     /**
      * Resizes the renderer to the specified size.
      * @param {Point2} newSize - The new size of the renderer.

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

@@ -1,6 +1,6 @@
 import { IComponent } from '../i-component';
 import { VisualTypeDocRepo } from '../../gg-world';
-export interface IVisualSceneComponent<D, R, TypeDoc extends VisualTypeDocRepo<D, R> = VisualTypeDocRepo<D, R>> extends IComponent {
-    readonly factory: TypeDoc['factory'];
+export interface IVisualSceneComponent<D, R, VTypeDoc extends VisualTypeDocRepo<D, R> = VisualTypeDocRepo<D, R>> extends IComponent {
+    readonly factory: VTypeDoc['factory'];
     init(): Promise<void>;
 }

package/dist/base/entities/controllers/animation-mixer.d.ts

@@ -1,6 +1,6 @@
 import { IEntity } from '../i-entity';
 import { Observable, Subject } from 'rxjs';
-import { GgWorld, PhysicsTypeDocRepo, VisualTypeDocRepo } from '../../gg-world';
+import { GgWorld, GgWorldTypeDocRepo } from '../../gg-world';
 export type AnimationFunction<T> = (elapsed: number, delta: number) => T;
 /**
  * A class that performs property animations for a specific type `T` by using provided animation function.
@@ -8,7 +8,7 @@ export type AnimationFunction<T> = (elapsed: number, delta: number) => T;
  * The current value of the animation can be subscribed to using the `subscribeToValue` property.
  * The animation function can be changed with `transitAnimationFunction` or `transitFromStaticState`.
  */
-export declare class AnimationMixer<T, D = any, R = any, VTypeDoc extends VisualTypeDocRepo<D, R> = VisualTypeDocRepo<D, R>, PTypeDoc extends PhysicsTypeDocRepo<D, R> = PhysicsTypeDocRepo<D, R>> extends IEntity<D, R, VTypeDoc, PTypeDoc> {
+export declare class AnimationMixer<T, D = any, R = any, TypeDoc extends GgWorldTypeDocRepo<D, R> = GgWorldTypeDocRepo<D, R>> extends IEntity<D, R, TypeDoc> {
     protected _animationFunction: AnimationFunction<T>;
     protected _lerp: (a: T, b: T, t: number) => T;
     readonly tickOrder: number;
@@ -71,6 +71,6 @@ export declare class AnimationMixer<T, D = any, R = any, VTypeDoc extends Visual
      * @param easing an easing function for transition
      */
     transitAnimationFunction(newFunc: AnimationFunction<T>, transitionDuration: number, easing?: (t: number) => number): void;
-    onSpawned(world: GgWorld<D, R, VTypeDoc, PTypeDoc>): void;
+    onSpawned(world: GgWorld<D, R, TypeDoc>): void;
     dispose(): void;
 }

package/dist/base/entities/i-entity.d.ts

@@ -1,4 +1,4 @@
-import { GgWorld, PhysicsTypeDocRepo, VisualTypeDocRepo } from '../gg-world';
+import { GgWorld, GgWorldTypeDocRepo } from '../gg-world';
 import { Observable, Subject } from 'rxjs';
 import { IWorldComponent } from '../components/i-world-component';
 /**
@@ -13,7 +13,7 @@ export declare enum TickOrder {
     RENDERING = 1000,
     POST_RENDERING = 1200
 }
-export declare abstract class IEntity<D = any, R = any, VTypeDoc extends VisualTypeDocRepo<D, R> = VisualTypeDocRepo<D, R>, PTypeDoc extends PhysicsTypeDocRepo<D, R> = PhysicsTypeDocRepo<D, R>> {
+export declare abstract class IEntity<D = any, R = any, TypeDoc extends GgWorldTypeDocRepo<D, R> = GgWorldTypeDocRepo<D, R>> {
     private static default_name_counter;
     /**
      * will receive [elapsed time, delta] of each world clock tick
@@ -26,8 +26,8 @@ export declare abstract class IEntity<D = any, R = any, VTypeDoc extends VisualT
     /**
      * a world reference, where this entity was added to
      */
-    protected _world: GgWorld<D, R, VTypeDoc, PTypeDoc> | null;
-    get world(): GgWorld<D, R, VTypeDoc, PTypeDoc> | null;
+    protected _world: GgWorld<D, R, TypeDoc> | null;
+    get world(): GgWorld<D, R, TypeDoc> | null;
     protected _name: string;
     get name(): string;
     set name(value: string);
@@ -43,14 +43,14 @@ export declare abstract class IEntity<D = any, R = any, VTypeDoc extends VisualT
     addChildren(...entities: IEntity[]): void;
     removeChildren(entities: IEntity[], dispose?: boolean): void;
     private _components;
-    get components(): IWorldComponent<D, R, VTypeDoc, PTypeDoc>[];
-    addComponents(...components: IWorldComponent<D, R, VTypeDoc, PTypeDoc>[]): void;
-    removeComponents(components: IWorldComponent<D, R, VTypeDoc, PTypeDoc>[], dispose?: boolean): void;
+    get components(): IWorldComponent<D, R, TypeDoc>[];
+    addComponents(...components: IWorldComponent<D, R, TypeDoc>[]): void;
+    removeComponents(components: IWorldComponent<D, R, TypeDoc>[], dispose?: boolean): void;
     protected _onSpawned$: Subject<void>;
     protected _onRemoved$: Subject<void>;
     get onSpawned$(): Observable<void>;
     get onRemoved$(): Observable<void>;
-    onSpawned(world: GgWorld<D, R, VTypeDoc, PTypeDoc>): void;
+    onSpawned(world: GgWorld<D, R, TypeDoc>): void;
     onRemoved(): void;
     dispose(): void;
 }

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

@@ -1,6 +1,6 @@
 import { IEntity } from './i-entity';
-import { PhysicsTypeDocRepo, VisualTypeDocRepo } from '../gg-world';
-export declare abstract class IRenderableEntity<D = any, R = any, TypeDoc extends VisualTypeDocRepo<D, R> = VisualTypeDocRepo<D, R>, PTypeDoc extends PhysicsTypeDocRepo<D, R> = PhysicsTypeDocRepo<D, R>> extends IEntity<D, R, TypeDoc, PTypeDoc> {
+import { GgWorldTypeDocRepo } from '../gg-world';
+export declare abstract class IRenderableEntity<D = any, R = any, TypeDoc extends GgWorldTypeDocRepo<D, R> = GgWorldTypeDocRepo<D, R>> extends IEntity<D, R, TypeDoc> {
     private _visible;
     get visible(): boolean;
     get worldVisible(): boolean;

package/dist/base/entities/i-renderer.entity.d.ts

@@ -1,5 +1,5 @@
 import { IEntity, TickOrder } from './i-entity';
-import { GgWorld, VisualTypeDocRepo } from '../gg-world';
+import { GgWorld, GgWorldTypeDocVPatch, VisualTypeDocRepo } from '../gg-world';
 import { BehaviorSubject, Observable } from 'rxjs';
 import { Point2 } from '../models/points';
 import { RendererOptions } from '../components/rendering/i-renderer.component';
@@ -7,8 +7,8 @@ import { RendererOptions } from '../components/rendering/i-renderer.component';
  * Represents a base class for a renderer entity.
  * @class
  */
-export declare abstract class IRendererEntity<D, R, TypeDoc extends VisualTypeDocRepo<D, R> = VisualTypeDocRepo<D, R>> extends IEntity<D, R, TypeDoc> {
-    readonly renderer: TypeDoc['renderer'];
+export declare abstract class IRendererEntity<D, R, VTypeDoc extends VisualTypeDocRepo<D, R> = VisualTypeDocRepo<D, R>> extends IEntity<D, R, GgWorldTypeDocVPatch<D, R, VTypeDoc>> {
+    readonly renderer: VTypeDoc['renderer'];
     readonly tickOrder = TickOrder.RENDERING;
     /** Represents the current size of the renderer. */
     protected _rendererSize$: BehaviorSubject<Point2 | null>;
@@ -31,7 +31,7 @@ export declare abstract class IRendererEntity<D, R, TypeDoc extends VisualTypeDo
      Initializes a new instance of the BaseGgRenderer class.
      * @param renderer
      */
-    constructor(renderer: TypeDoc['renderer']);
-    onSpawned(world: GgWorld<D, R, TypeDoc>): void;
+    constructor(renderer: VTypeDoc['renderer']);
+    onSpawned(world: GgWorld<D, R, GgWorldTypeDocVPatch<D, R, VTypeDoc>>): void;
     dispose(): void;
 }