@gg-web-engine/core 0.0.28 → 0.0.30

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

@@ -1,6 +1,6 @@
 import { BehaviorSubject, Observable, Subject } from 'rxjs';
 import { Graph, IEntity, Point3, Point4, TickOrder } from '../../base';
-import { Gg3dWorld } from '../gg-3d-world';
+import { Gg3dWorld, PhysicsTypeDocRepo3D, VisualTypeDocRepo3D } from '../gg-3d-world';
 import { Entity3d } from './entity-3d';
 import { LoadOptions, LoadResultWithProps } from '../loader';
 import { IPositionable3d } from '../interfaces/i-positionable-3d';
@@ -37,7 +37,7 @@ export declare type Gg3dMapGraphEntityOptions = {
     loadDepth: number;
     inertia: number;
 };
-export declare class MapGraph3dEntity extends IRenderable3dEntity {
+export declare class MapGraph3dEntity<VTypeDoc extends VisualTypeDocRepo3D = VisualTypeDocRepo3D, PTypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> extends IRenderable3dEntity<VTypeDoc, PTypeDoc> {
     readonly mapGraph: MapGraph;
     readonly tickOrder = TickOrder.POST_RENDERING;
     readonly loaderCursorEntity$: BehaviorSubject<IPositionable3d | null>;
@@ -46,21 +46,27 @@ export declare class MapGraph3dEntity extends IRenderable3dEntity {
     get initialLoadComplete$(): Observable<boolean>;
     private _nearestDummy$;
     get nearestDummy(): Graph<MapGraphNodeType> | null;
-    protected _chunkLoaded$: Subject<[LoadResultWithProps, {
-        position: Point3;
-        rotation: Point4;
-    }]>;
-    get chunkLoaded$(): Observable<[LoadResultWithProps, {
-        position: Point3;
-        rotation: Point4;
-    }]>;
-    get world(): Gg3dWorld | null;
-    protected _world: Gg3dWorld | null;
+    protected _chunkLoaded$: Subject<[
+        LoadResultWithProps<VTypeDoc, PTypeDoc>,
+        {
+            position: Point3;
+            rotation: Point4;
+        }
+    ]>;
+    get chunkLoaded$(): Observable<[
+        LoadResultWithProps<VTypeDoc, PTypeDoc>,
+        {
+            position: Point3;
+            rotation: Point4;
+        }
+    ]>;
+    get world(): Gg3dWorld<VTypeDoc, PTypeDoc> | null;
+    protected _world: Gg3dWorld<VTypeDoc, PTypeDoc> | null;
     protected readonly mapGraphNodes: MapGraph[];
     protected readonly options: Gg3dMapGraphEntityOptions;
     constructor(mapGraph: MapGraph, options?: Partial<Gg3dMapGraphEntityOptions>);
-    onSpawned(world: Gg3dWorld): void;
+    onSpawned(world: Gg3dWorld<VTypeDoc, PTypeDoc>): void;
     onRemoved(): void;
-    protected loadChunk(node: MapGraphNodeType): Promise<[Entity3d[], LoadResultWithProps]>;
+    protected loadChunk(node: MapGraphNodeType): Promise<[Entity3d<VTypeDoc, PTypeDoc>[], LoadResultWithProps<VTypeDoc, PTypeDoc>]>;
     protected disposeChunk(node: MapGraphNodeType): void;
 }

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

@@ -1,9 +1,9 @@
-import { AxisDirection3, IEntity, Point3, Point4 } from '../../base';
+import { AxisDirection3, Point3, Point4 } from '../../base';
 import { Entity3d } from './entity-3d';
 import { IDisplayObject3dComponent } from '../components/rendering/i-display-object-3d.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';
+import { PhysicsTypeDocRepo3D, VisualTypeDocRepo3D } from '../gg-3d-world';
 export declare type WheelDisplayOptions = {
     displayObject?: IDisplayObject3dComponent;
     wheelObjectDirection?: AxisDirection3;
@@ -39,11 +39,11 @@ export declare type RVEntityProperties = {
     })[];
     sharedWheelOptions?: RVEntitySharedWheelOptions;
 });
-export declare class RaycastVehicle3dEntity extends Entity3d {
+export declare class RaycastVehicle3dEntity<VTypeDoc extends VisualTypeDocRepo3D = VisualTypeDocRepo3D, PTypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> extends Entity3d<VTypeDoc, PTypeDoc> {
     readonly carProperties: RVEntityProperties;
     readonly chassis3D: IDisplayObject3dComponent | null;
     readonly chassisBody: IRaycastVehicleComponent;
-    protected readonly wheels: ((IEntity & IPositionable3d) | null)[];
+    protected readonly wheels: (Entity3d<VTypeDoc, PTypeDoc> | null)[];
     protected readonly wheelLocalRotation: (Point4 | null)[];
     protected readonly frontWheelsIndices: number[];
     protected readonly rearWheelsIndices: number[];

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

@@ -124,7 +124,6 @@ export class RaycastVehicle3dEntity extends Entity3d {
     }
     runTransformBinding(objectBody, object3D) {
         super.runTransformBinding(objectBody, object3D);
-        const carRotation = this.rotation;
         for (const [i, wheel] of (this.wheels || []).entries()) {
             if (!wheel) {
                 continue;

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

@@ -1,12 +1,10 @@
 import { IRendererEntity, Point3, Point4 } from '../../base';
-import { IRenderer3dComponent } from '../components/rendering/i-renderer-3d.component';
-import { IVisualScene3dComponent } from '../components/rendering/i-visual-scene-3d.component';
-import { ICameraComponent } from '../components/rendering/i-camera.component';
 import { IPositionable3d } from '../interfaces/i-positionable-3d';
-export declare class Renderer3dEntity<VS extends IVisualScene3dComponent = IVisualScene3dComponent, CC extends ICameraComponent<VS> = ICameraComponent<VS>, RC extends IRenderer3dComponent<VS, CC> = IRenderer3dComponent<VS, CC>> extends IRendererEntity<Point3, Point4, VS, RC> implements IPositionable3d {
+import { VisualTypeDocRepo3D } from '../gg-3d-world';
+export declare class Renderer3dEntity<TypeDoc extends VisualTypeDocRepo3D = VisualTypeDocRepo3D> extends IRendererEntity<Point3, Point4, TypeDoc> implements IPositionable3d {
     get position(): Point3;
     set position(value: Point3);
     get rotation(): Point4;
     set rotation(value: Point4);
-    get camera(): CC;
+    get camera(): TypeDoc['camera'];
 }

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

@@ -2,11 +2,12 @@ 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';
-export declare class Trigger3dEntity extends IEntity<Point3, Point4> implements IPositionable3d {
+import { PhysicsTypeDocRepo3D, VisualTypeDocRepo3D } from '../gg-3d-world';
+export declare class Trigger3dEntity<TypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> extends IEntity<Point3, Point4, VisualTypeDocRepo3D, TypeDoc> implements IPositionable3d {
     readonly objectBody: ITrigger3dComponent;
     readonly tickOrder = TickOrder.OBJECTS_BINDING;
-    get onEntityEntered(): Observable<IEntity & IPositionable3d>;
-    get onEntityLeft(): Observable<(IEntity & IPositionable3d) | null>;
+    get onEntityEntered(): Observable<IEntity<Point3, Point4, VisualTypeDocRepo3D, TypeDoc> & IPositionable3d>;
+    get onEntityLeft(): Observable<(IEntity<Point3, Point4, VisualTypeDocRepo3D, TypeDoc> & IPositionable3d) | null>;
     private _position;
     get position(): Point3;
     set position(value: Point3);

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

@@ -1,23 +1,39 @@
 import { BodyShape3DDescriptor, Shape3DDescriptor } from './models/shapes';
 import { Point3, Point4 } from '../base';
-import { IDisplayObject3dComponent } from './components/rendering/i-display-object-3d.component';
-import { ITrigger3dComponent } from './components/physics/i-trigger-3d.component';
-import { IRigidBody3dComponent } from './components/physics/i-rigid-body-3d.component';
-export declare abstract class IDisplayObject3dComponentFactory<DOC extends IDisplayObject3dComponent = IDisplayObject3dComponent> {
-    abstract createPrimitive(descriptor: Shape3DDescriptor, material?: any): DOC;
-    createBox(dimensions: Point3, material?: any): DOC;
-    createCapsule(radius: number, centersDistance: number, material?: any): DOC;
-    createCylinder(radius: number, height: number, material?: any): DOC;
-    createCone(radius: number, height: number, material?: any): DOC;
-    createSphere(radius: number): DOC;
+import { PhysicsTypeDocRepo3D, VisualTypeDocRepo3D } from './gg-3d-world';
+export declare type DisplayObject3dOpts<Tex> = {
+    color?: number;
+    shading?: 'unlit' | 'standart' | 'phong';
+    diffuse?: Tex;
+    castShadow?: boolean;
+    receiveShadow?: boolean;
+};
+export declare abstract class IDisplayObject3dComponentFactory<TypeDoc extends VisualTypeDocRepo3D = VisualTypeDocRepo3D> {
+    abstract createPrimitive(descriptor: Shape3DDescriptor, material?: DisplayObject3dOpts<TypeDoc['texture']>): TypeDoc['displayObject'];
+    abstract createPerspectiveCamera(settings: {
+        fov?: number;
+        aspectRatio?: number;
+        frustrum?: {
+            near: number;
+            far: number;
+        };
+    }): TypeDoc['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'];
 }
-export interface IPhysicsBody3dComponentFactory<T extends IRigidBody3dComponent = IRigidBody3dComponent, K extends ITrigger3dComponent = ITrigger3dComponent> {
+export interface IPhysicsBody3dComponentFactory<TypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> {
     createRigidBody(descriptor: BodyShape3DDescriptor, transform?: {
         position?: Point3;
         rotation?: Point4;
-    }): T;
+    }): TypeDoc['rigidBody'];
     createTrigger(descriptor: Shape3DDescriptor, transform?: {
         position?: Point3;
         rotation?: Point4;
-    }): K;
+    }): TypeDoc['trigger'];
+    createRaycastVehicle(chassis: TypeDoc['rigidBody']): TypeDoc['raycastVehicle'];
 }

package/dist/3d/factories.js

@@ -1,18 +1,24 @@
 export class IDisplayObject3dComponentFactory {
+    randomColor() {
+        return ((Math.floor(Math.random() * 256) << 16) | (Math.floor(Math.random() * 256) << 8) | Math.floor(Math.random() * 256));
+    }
     // shortcuts
-    createBox(dimensions, material) {
+    createPlane(material = {}) {
+        return this.createPrimitive({ shape: 'PLANE' }, material);
+    }
+    createBox(dimensions, material = {}) {
         return this.createPrimitive({ shape: 'BOX', dimensions }, material);
     }
-    createCapsule(radius, centersDistance, material) {
+    createCapsule(radius, centersDistance, material = {}) {
         return this.createPrimitive({ shape: 'CAPSULE', radius, centersDistance }, material);
     }
-    createCylinder(radius, height, material) {
+    createCylinder(radius, height, material = {}) {
         return this.createPrimitive({ shape: 'CYLINDER', radius, height }, material);
     }
-    createCone(radius, height, material) {
+    createCone(radius, height, material = {}) {
         return this.createPrimitive({ shape: 'CONE', radius, height }, material);
     }
-    createSphere(radius) {
-        return this.createPrimitive({ shape: 'SPHERE', radius });
+    createSphere(radius, material = {}) {
+        return this.createPrimitive({ shape: 'SPHERE', radius }, material);
     }
 }

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

@@ -7,11 +7,32 @@ import { Renderer3dEntity } from './entities/renderer-3d.entity';
 import { ICameraComponent } from './components/rendering/i-camera.component';
 import { IRenderer3dComponent } from './components/rendering/i-renderer-3d.component';
 import { IPhysicsWorld3dComponent } from './components/physics/i-physics-world-3d.component';
-export declare class Gg3dWorld<V extends IVisualScene3dComponent = IVisualScene3dComponent, P extends IPhysicsWorld3dComponent = IPhysicsWorld3dComponent> extends GgWorld<Point3, Point4, V, P> {
-    readonly visualScene: V;
-    readonly physicsWorld: P;
-    readonly loader: Gg3dLoader;
-    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>;
+import { DisplayObject3dOpts, IDisplayObject3dComponentFactory, IPhysicsBody3dComponentFactory } from './factories';
+import { IDisplayObject3dComponent } from './components/rendering/i-display-object-3d.component';
+import { IRaycastVehicleComponent } from './components/physics/i-raycast-vehicle.component';
+import { IRigidBody3dComponent } from './components/physics/i-rigid-body-3d.component';
+import { ITrigger3dComponent } from './components/physics/i-trigger-3d.component';
+import { IDisplayObject3dComponentLoader, IPhysicsBody3dComponentLoader } from './loaders';
+export declare type VisualTypeDocRepo3D = {
+    factory: IDisplayObject3dComponentFactory;
+    loader: IDisplayObject3dComponentLoader;
+    displayObject: IDisplayObject3dComponent;
+    renderer: IRenderer3dComponent;
+    camera: ICameraComponent;
+    texture: unknown;
+};
+export declare type PhysicsTypeDocRepo3D = {
+    factory: IPhysicsBody3dComponentFactory;
+    loader: IPhysicsBody3dComponentLoader;
+    rigidBody: IRigidBody3dComponent;
+    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>): Renderer3dEntity<VTypeDoc>;
 }

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

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

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

@@ -1,9 +1,7 @@
-import { Gg3dWorld } from './gg-3d-world';
+import { Gg3dWorld, PhysicsTypeDocRepo3D, VisualTypeDocRepo3D } from './gg-3d-world';
 import { GgMeta } from './models/gg-meta';
 import { Entity3d } from './entities/entity-3d';
 import { Point3, Point4 } from '../base';
-import { IDisplayObject3dComponent } from './components/rendering/i-display-object-3d.component';
-import { IRigidBody3dComponent } from './components/physics/i-rigid-body-3d.component';
 export declare enum CachingStrategy {
     Nothing = 0,
     Files = 1,
@@ -16,26 +14,26 @@ export declare type LoadOptions = {
     loadProps: boolean;
     propsPath?: string;
 };
-export declare type LoadResourcesResult = {
+export declare type LoadResourcesResult<VTypeDoc extends VisualTypeDocRepo3D = VisualTypeDocRepo3D, PTypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> = {
     resources: {
-        object3D: IDisplayObject3dComponent | null;
-        body: IRigidBody3dComponent | null;
+        object3D: VTypeDoc['displayObject'] | null;
+        body: PTypeDoc['rigidBody'] | null;
     }[];
     meta: GgMeta;
 };
-export declare type LoadResult = {
-    entities: Entity3d[];
+export declare type LoadResult<VTypeDoc extends VisualTypeDocRepo3D = VisualTypeDocRepo3D, PTypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> = {
+    entities: Entity3d<VTypeDoc, PTypeDoc>[];
     meta: GgMeta;
 };
-export declare type LoadResultWithProps = LoadResult & {
-    props?: LoadResult[];
+export declare type LoadResultWithProps<VTypeDoc extends VisualTypeDocRepo3D = VisualTypeDocRepo3D, PTypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> = LoadResult<VTypeDoc, PTypeDoc> & {
+    props?: LoadResult<VTypeDoc, PTypeDoc>[];
 };
-export declare class Gg3dLoader {
+export declare class Gg3dLoader<VTypeDoc extends VisualTypeDocRepo3D = VisualTypeDocRepo3D, PTypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> {
     protected readonly world: Gg3dWorld;
     readonly filesCache: Map<string, [ArrayBuffer, GgMeta] | Promise<[ArrayBuffer, GgMeta]>>;
-    readonly loadResultCache: Map<string, LoadResourcesResult | Promise<LoadResourcesResult>>;
+    readonly loadResultCache: Map<string, LoadResourcesResult<VTypeDoc, PTypeDoc> | Promise<LoadResourcesResult<VTypeDoc, PTypeDoc>>>;
     constructor(world: Gg3dWorld);
     loadGgGlbFiles(path: string, useCache?: boolean): Promise<[ArrayBuffer, GgMeta]>;
-    loadGgGlbResources(path: string, cachingStrategy?: CachingStrategy): Promise<LoadResourcesResult>;
-    loadGgGlb(path: string, options?: Partial<LoadOptions>): Promise<LoadResultWithProps>;
+    loadGgGlbResources(path: string, cachingStrategy?: CachingStrategy): Promise<LoadResourcesResult<VTypeDoc, PTypeDoc>>;
+    loadGgGlb(path: string, options?: Partial<LoadOptions>): Promise<LoadResultWithProps<VTypeDoc, PTypeDoc>>;
 }

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

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

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

@@ -1,6 +1,8 @@
 import { Point3, Point4 } from '../../base';
 import { Body3DOptions } from './body-options';
 export declare type Shape3DDescriptor = {
+    shape: 'PLANE';
+} | {
     shape: 'BOX';
     dimensions: Point3;
 } | {

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

@@ -1,10 +1,8 @@
 import { IEntity } from '../entities/i-entity';
-import { GgWorld } from '../gg-world';
-import { IVisualSceneComponent } from './rendering/i-visual-scene.component';
-import { IPhysicsWorldComponent } from './physics/i-physics-world.component';
-export interface IWorldComponent<D, R, V extends IVisualSceneComponent<D, R> = IVisualSceneComponent<D, R>, P extends IPhysicsWorldComponent<D, R> = IPhysicsWorldComponent<D, R>> {
+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>> {
     entity: IEntity | null;
-    addToWorld(world: GgWorld<D, R, V, P>): void;
-    removeFromWorld(world: GgWorld<D, R, V, P>, dispose?: boolean): void;
+    addToWorld(world: GgWorld<D, R, VTypeDoc, PTypeDoc>): void;
+    removeFromWorld(world: GgWorld<D, R, VTypeDoc, PTypeDoc>, dispose?: boolean): void;
     dispose(): void;
 }

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

@@ -1,14 +1,17 @@
 import { IEntity } from '../../entities/i-entity';
-import { IPhysicsWorldComponent } from './i-physics-world.component';
 import { IWorldComponent } from '../i-world-component';
-import { GgWorld } from '../../gg-world';
-import { IVisualSceneComponent } from '../rendering/i-visual-scene.component';
-export interface IBodyComponent<D, R, PW extends IPhysicsWorldComponent<D, R> = IPhysicsWorldComponent<D, R>> extends IWorldComponent<D, R, IVisualSceneComponent<D, R>, PW> {
+import { GgWorld, PhysicsTypeDocRepo, VisualTypeDocRepo } from '../../gg-world';
+import { CollisionGroup } 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> {
     entity: IEntity | null;
     position: D;
     rotation: R;
     name: string;
-    clone(): IBodyComponent<D, R, PW>;
-    addToWorld(world: GgWorld<D, R, IVisualSceneComponent<D, R>, PW>): void;
-    removeFromWorld(world: GgWorld<D, R, IVisualSceneComponent<D, R>, PW>): void;
+    get ownCollisionGroups(): CollisionGroup[];
+    set ownCollisionGroups(value: CollisionGroup[] | 'all');
+    get interactWithCollisionGroups(): CollisionGroup[];
+    set interactWithCollisionGroups(value: CollisionGroup[] | 'all');
+    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;
 }

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

@@ -1,8 +1,9 @@
-import { GgWorld } from '../../gg-world';
+import { GgWorld, PhysicsTypeDocRepo } from '../../gg-world';
 import { IDebugPhysicsDrawer } from '../../interfaces/i-debug-physics-drawer';
 import { IComponent } from '../i-component';
-export interface IPhysicsWorldComponent<D, R> extends IComponent {
-    readonly factory: any;
+import { CollisionGroup } from '../../models/body-options';
+export interface IPhysicsWorldComponent<D, R, TypeDoc extends PhysicsTypeDocRepo<D, R> = PhysicsTypeDocRepo<D, R>> extends IComponent {
+    readonly factory: TypeDoc['factory'];
     gravity: D;
     timeScale: number;
     get physicsDebugViewActive(): boolean;
@@ -13,6 +14,8 @@ export interface IPhysicsWorldComponent<D, R> extends IComponent {
      * @param delta delta time from last tick in milliseconds.
      */
     simulate(delta: number): void;
+    registerCollisionGroup(): CollisionGroup;
+    deregisterCollisionGroup(group: CollisionGroup): void;
     startDebugger(world: GgWorld<D, R>, drawer: IDebugPhysicsDrawer<D, R>): void;
     stopDebugger(world: GgWorld<D, R>): void;
 }

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

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

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

@@ -1,10 +1,10 @@
 import { Observable } from 'rxjs';
 import { IRigidBodyComponent } from './i-rigid-body.component';
-import { IPhysicsWorldComponent } from './i-physics-world.component';
 import { IBodyComponent } from './i-body.component';
-export interface ITriggerComponent<D, R, PW extends IPhysicsWorldComponent<D, R> = IPhysicsWorldComponent<D, R>> extends IBodyComponent<D, R, PW> {
-    get onEntityEntered(): Observable<IRigidBodyComponent<D, R>>;
-    get onEntityLeft(): Observable<IRigidBodyComponent<D, R> | null>;
-    clone(): ITriggerComponent<D, R, PW>;
+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>;
     checkOverlaps(): void;
 }

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

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

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

@@ -1,9 +1,9 @@
 import { Point2 } from '../../models/points';
 import { Observable } from 'rxjs';
-import { IVisualSceneComponent } from './i-visual-scene.component';
 import { IWorldComponent } from '../i-world-component';
-import { GgWorld } from '../../gg-world';
+import { GgWorld, VisualTypeDocRepo } from '../../gg-world';
 import { IEntity } from '../../entities/i-entity';
+import { IVisualSceneComponent } from './i-visual-scene.component';
 /**
  * Represents the options that can be passed to a renderer.
  * @typedef {Object} RendererOptions
@@ -20,19 +20,19 @@ export declare type RendererOptions = {
     forceResolution?: number;
     antialias: boolean;
 };
-export declare abstract class IRendererComponent<D, R, VS extends IVisualSceneComponent<D, R> = IVisualSceneComponent<D, R>> implements IWorldComponent<D, R, VS> {
-    readonly scene: VS;
+export declare abstract class IRendererComponent<D, R, VTypeDoc extends VisualTypeDocRepo<D, R> = VisualTypeDocRepo<D, R>> implements IWorldComponent<D, R, VTypeDoc> {
+    readonly scene: IVisualSceneComponent<D, R, VTypeDoc>;
     readonly canvas?: HTMLCanvasElement | undefined;
     entity: IEntity | null;
     /** Specifies the options for the renderer. */
     readonly rendererOptions: RendererOptions;
-    protected constructor(scene: VS, canvas?: HTMLCanvasElement | undefined, options?: Partial<RendererOptions>);
+    protected constructor(scene: IVisualSceneComponent<D, R, VTypeDoc>, canvas?: HTMLCanvasElement | undefined, options?: Partial<RendererOptions>);
     /**
      * Renders the scene.
      */
     abstract render(): void;
-    abstract addToWorld(world: GgWorld<D, R, VS, any>): void;
-    abstract removeFromWorld(world: GgWorld<D, R, VS, any>): void;
+    abstract addToWorld(world: GgWorld<D, R, VTypeDoc>): void;
+    abstract removeFromWorld(world: GgWorld<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,9 +1,10 @@
 import { IDebugPhysicsDrawer } from '../../interfaces/i-debug-physics-drawer';
 import { IComponent } from '../i-component';
-export interface IVisualSceneComponent<D, R> extends IComponent {
-    readonly factory: any;
+import { VisualTypeDocRepo } from '../../gg-world';
+export interface IVisualSceneComponent<D, R, TypeDoc extends VisualTypeDocRepo<D, R> = VisualTypeDocRepo<D, R>> extends IComponent {
+    readonly factory: TypeDoc['factory'];
     readonly debugPhysicsDrawerClass?: {
-        new (): IDebugPhysicsDrawer<D, R>;
+        new (): IDebugPhysicsDrawer<D, R, TypeDoc>;
     };
     init(): Promise<void>;
 }

package/dist/base/data-structures/bitmask.d.ts

@@ -0,0 +1,30 @@
+/**
+ * BitMask class provides static methods to manipulate bits in a number.
+ */ /**
+* BitMask class provides static methods to manipulate bits in a number.
+*/
+export declare class BitMask {
+    /**
+     * Generates a bitmask with all bits set to 1 upto the provided bit count
+     * @param bits - The number of bits to be set to 1
+     */
+    static full(bits: number): number;
+    /**
+     * Generates an array with elements being consecutive numbers starting from 0 up to the provided number
+     * @param bits - The length of the array to be created
+     */
+    static fullArray(bits: number): number[];
+    /**
+     * Packs an array of bit indices into a single number
+     * @param value - The bit indices to be set to 1
+     * @param bits - The maximum bit index that can be used
+     * @throws Will throw an Error if a bit index in `value` is larger than `bits`
+     */
+    static pack(value: number[], bits: number): number;
+    /**
+     * Unpacks a bitmask into an array of bit indices
+     * @param mask - The bit mask to be unpacked
+     * @param bits - The number of bits to be unpacked from the mask
+     */
+    static unpack(mask: number, bits: number): number[];
+}

package/dist/base/data-structures/bitmask.js

@@ -0,0 +1,55 @@
+/**
+ * BitMask class provides static methods to manipulate bits in a number.
+ */ /**
+* BitMask class provides static methods to manipulate bits in a number.
+*/
+export class BitMask {
+    /**
+     * Generates a bitmask with all bits set to 1 upto the provided bit count
+     * @param bits - The number of bits to be set to 1
+     */
+    static full(bits) {
+        return Math.pow(2, bits) - 1;
+    }
+    /**
+     * Generates an array with elements being consecutive numbers starting from 0 up to the provided number
+     * @param bits - The length of the array to be created
+     */
+    static fullArray(bits) {
+        return new Array(bits).fill(null).map((_, i) => i);
+    }
+    /**
+     * Packs an array of bit indices into a single number
+     * @param value - The bit indices to be set to 1
+     * @param bits - The maximum bit index that can be used
+     * @throws Will throw an Error if a bit index in `value` is larger than `bits`
+     */
+    static pack(value, bits) {
+        let ret = 0;
+        for (const g of value) {
+            if (g >= bits) {
+                throw new Error('Too big bit index');
+            }
+            ret |= 1 << g;
+        }
+        return ret;
+    }
+    /**
+     * Unpacks a bitmask into an array of bit indices
+     * @param mask - The bit mask to be unpacked
+     * @param bits - The number of bits to be unpacked from the mask
+     */
+    static unpack(mask, bits) {
+        // It's better to keep the ret array capacity as there won't be more bits set than the size itself.
+        const ret = new Array(bits);
+        let idx = 0;
+        for (let i = 0; i < bits; i++) {
+            if (mask & (1 << i)) {
+                ret[idx++] = i;
+            }
+        }
+        // Truncate the ret array to include only valid indices.
+        ret.length = idx;
+        return ret;
+    }
+}