@gg-web-engine/core 0.0.56 → 0.0.58

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/3d/models/body-options.d.ts

@@ -1,7 +1,7 @@
-import { BodyOptions, DebugBodySettings } from '../../base';
+import { BodyOptions, DebugBodySettings, DebugBodyType } from '../../base';
 import { Shape3DDescriptor } from './shapes';
 export interface Body3DOptions extends BodyOptions {
 }
-export type DebugBody3DSettings = DebugBodySettings & {
-    shape: Shape3DDescriptor;
-};
+export declare class DebugBody3DSettings extends DebugBodySettings<Shape3DDescriptor> {
+    constructor(type: DebugBodyType, shape: Shape3DDescriptor, ignoreTransform?: boolean, color?: number | undefined);
+}

package/dist/3d/models/body-options.js

@@ -1 +1,6 @@
-export {};
+import { DebugBodySettings } from '../../base';
+export class DebugBody3DSettings extends DebugBodySettings {
+    constructor(type, shape, ignoreTransform = false, color = undefined) {
+        super(type, shape, ignoreTransform, color);
+    }
+}

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,19 +1,19 @@
 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;
     name: string;
-    get ownCollisionGroups(): CollisionGroup[];
-    set ownCollisionGroups(value: CollisionGroup[] | 'all');
-    get interactWithCollisionGroups(): CollisionGroup[];
-    set interactWithCollisionGroups(value: CollisionGroup[] | 'all');
+    get ownCollisionGroups(): ReadonlyArray<CollisionGroup>;
+    set ownCollisionGroups(value: ReadonlyArray<CollisionGroup> | 'all');
+    get interactWithCollisionGroups(): ReadonlyArray<CollisionGroup>;
+    set interactWithCollisionGroups(value: ReadonlyArray<CollisionGroup> | 'all');
     /** body info for physics debugger view */
-    readonly debugBodySettings: DebugBodySettings;
-    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;
+    readonly debugBodySettings: DebugBodySettings<any>;
+    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,22 +2,68 @@ import { PhysicsTypeDocRepo } from '../../gg-world';
 import { IComponent } from '../i-component';
 import { CollisionGroup } from '../../models/body-options';
 import { Subject } from 'rxjs';
-export interface IPhysicsWorldComponent<D, R, TypeDoc extends PhysicsTypeDocRepo<D, R> = PhysicsTypeDocRepo<D, R>> extends IComponent {
-    readonly factory: TypeDoc['factory'];
+import { RaycastOptions, RaycastResult } from '../../models/raycasting';
+/**
+ * Interface representing a physics world component.
+ *
+ * @template D - Data type used for representing physics properties.
+ * @template R - Type representing the physics engine's rigid body.
+ * @template TypeDoc - Physics typings repository.
+ */
+export interface IPhysicsWorldComponent<D, R, PTypeDoc extends PhysicsTypeDocRepo<D, R> = PhysicsTypeDocRepo<D, R>> extends IComponent {
+    /**
+     * Factory function for creating physics-related objects.
+     */
+    readonly factory: PTypeDoc['factory'];
+    /**
+     * The gravity vector affecting the physics world.
+     */
     gravity: D;
-    /** event emitter, emits newly added physics components */
-    readonly added$: Subject<TypeDoc['rigidBody'] | TypeDoc['trigger'] | any>;
-    /** event emitter, emits just removed physics components */
-    readonly removed$: Subject<TypeDoc['rigidBody'] | TypeDoc['trigger'] | any>;
-    /** list of currently added to world physics components */
-    readonly children: (TypeDoc['rigidBody'] | TypeDoc['trigger'] | any)[];
+    /**
+     * Event emitter that emits newly added physics components.
+     */
+    readonly added$: Subject<PTypeDoc['rigidBody'] | PTypeDoc['trigger'] | any>;
+    /**
+     * Event emitter that emits just removed physics components.
+     */
+    readonly removed$: Subject<PTypeDoc['rigidBody'] | PTypeDoc['trigger'] | any>;
+    /**
+     * List of currently added physics components in the world.
+     */
+    readonly children: (PTypeDoc['rigidBody'] | PTypeDoc['trigger'] | any)[];
+    /**
+     * The main collision group. All physics bodies have this collision group set by default.
+     */
+    readonly mainCollisionGroup: CollisionGroup;
+    /**
+     * Initializes the physics world component.
+     *
+     * @returns A promise that resolves when initialization is complete.
+     */
     init(): Promise<void>;
     /**
-     * Runs simulation of the physics world.
+     * Runs the simulation of the physics world for the given time step.
      *
-     * @param delta delta time from last tick in milliseconds.
+     * @param delta - The time step in milliseconds since the last update.
      */
     simulate(delta: number): void;
+    /**
+     * Registers and returns a new collision group.
+     *
+     * @returns A newly registered collision group.
+     */
     registerCollisionGroup(): CollisionGroup;
+    /**
+     * Deregisters a previously registered collision group.
+     *
+     * @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/data-structures/bitmask.d.ts

@@ -1,8 +1,9 @@
 /**
  * BitMask class provides static methods to manipulate bits in a number.
- */ /**
-* 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
@@ -20,7 +21,7 @@ export declare class BitMask {
      * @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;
+    static pack(value: number[] | ReadonlyArray<number>, bits: number): number;
     /**
      * Unpacks a bitmask into an array of bit indices
      * @param mask - The bit mask to be unpacked

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

@@ -1,8 +1,9 @@
 /**
  * BitMask class provides static methods to manipulate bits in a number.
- */ /**
-* 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

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

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

@@ -1,5 +1,6 @@
-import { IDisplayObjectComponent, IEntity, IPhysicsWorldComponent, IPositionable, IRenderableEntity, IRendererComponent, IRigidBodyComponent, ITriggerComponent, IVisualSceneComponent, KeyboardInput, PausableClock } from '../base';
+import { IDisplayObjectComponent, IEntity, IPhysicsWorldComponent, IPositionable, IRenderableEntity, IRendererComponent, IRendererEntity, IRigidBodyComponent, ITriggerComponent, IVisualSceneComponent, KeyboardInput, PausableClock } from '../base';
 import { Subject } from 'rxjs';
+import { IVisualScene2dComponent, VisualTypeDocRepo2D } from '../2d';
 export type VisualTypeDocRepo<D, R> = {
     factory: unknown;
     displayObject: IDisplayObjectComponent<D, R>;
@@ -11,24 +12,48 @@ export type PhysicsTypeDocRepo<D, R> = {
     rigidBody: IRigidBodyComponent<D, R>;
     trigger: ITriggerComponent<D, R>;
 };
-export declare abstract class GgWorld<D, R, VTypeDoc extends VisualTypeDocRepo<D, R> = VisualTypeDocRepo<D, R>, PTypeDoc extends PhysicsTypeDocRepo<D, R> = PhysicsTypeDocRepo<D, R>, VS extends IVisualSceneComponent<D, R, VTypeDoc> = IVisualSceneComponent<D, R, VTypeDoc>, PW extends IPhysicsWorldComponent<D, R, PTypeDoc> = IPhysicsWorldComponent<D, R, PTypeDoc>> {
-    readonly visualScene: VS;
-    readonly physicsWorld: PW;
+export type GgWorldTypeDocRepo<D, R> = {
+    vTypeDoc: VisualTypeDocRepo<D, R>;
+    pTypeDoc: PhysicsTypeDocRepo<D, R>;
+};
+export type GgWorldTypeDocVPatch<D, R, VTypeDoc extends VisualTypeDocRepo<D, R>> = Omit<GgWorldTypeDocRepo<D, R>, 'vTypeDoc'> & {
+    vTypeDoc: VTypeDoc;
+};
+export type GgWorldTypeDocPPatch<D, R, PTypeDoc extends PhysicsTypeDocRepo<D, R>> = Omit<GgWorldTypeDocRepo<D, R>, 'pTypeDoc'> & {
+    pTypeDoc: PTypeDoc;
+};
+export type GgWorldSceneTypeRepo<D, R, TypeDoc extends GgWorldTypeDocRepo<D, R> = GgWorldTypeDocRepo<D, R>> = {
+    visualScene: IVisualSceneComponent<D, R, TypeDoc['vTypeDoc']> | null;
+    physicsWorld: IPhysicsWorldComponent<D, R, TypeDoc['pTypeDoc']> | null;
+};
+export type GgWorldSceneTypeDocVPatch<D, R, VTypeDoc extends VisualTypeDocRepo2D, VS extends IVisualScene2dComponent<VTypeDoc> | null> = Omit<GgWorldSceneTypeRepo<D, R>, 'visualScene'> & {
+    visualScene: VS;
+};
+export type GgWorldSceneTypeDocPPatch<D, R, PTypeDoc extends PhysicsTypeDocRepo<D, R>, PW extends IPhysicsWorldComponent<D, R, PTypeDoc> | null> = Omit<GgWorldSceneTypeRepo<D, R>, 'physicsWorld'> & {
+    physicsWorld: PW;
+};
+export declare abstract class GgWorld<D, R, TypeDoc extends GgWorldTypeDocRepo<D, R> = GgWorldTypeDocRepo<D, R>, SceneTypeDoc extends GgWorldSceneTypeRepo<D, R, TypeDoc> = GgWorldSceneTypeRepo<D, R, TypeDoc>> {
     private static default_name_counter;
     private static _documentWorlds;
     static readonly worldCreated$: Subject<GgWorld<any, any>>;
     static get documentWorlds(): GgWorld<any, any>[];
+    readonly visualScene: SceneTypeDoc['visualScene'];
+    readonly physicsWorld: SceneTypeDoc['physicsWorld'];
     readonly worldClock: PausableClock;
     readonly keyboardInput: KeyboardInput;
     name: string;
     readonly children: IEntity[];
     protected readonly tickListeners: IEntity[];
+    get renderers(): IRendererEntity<D, R>[];
     readonly tickStarted$: Subject<void>;
     readonly tickForwardTo$: Subject<IEntity | 'PHYSICS_WORLD'>;
     readonly tickForwardedTo$: Subject<IEntity | 'PHYSICS_WORLD'>;
     readonly paused$: Subject<boolean>;
     readonly disposed$: Subject<void>;
-    protected constructor(visualScene: VS, physicsWorld: PW);
+    protected constructor(args: {
+        visualScene?: SceneTypeDoc['visualScene'];
+        physicsWorld?: SceneTypeDoc['physicsWorld'];
+    });
     init(): Promise<void>;
     start(): void;
     pauseWorld(): void;
@@ -39,7 +64,7 @@ export declare abstract class GgWorld<D, R, VTypeDoc extends VisualTypeDocRepo<D
     createClock(autoStart: boolean): PausableClock;
     dispose(): void;
     abstract addPrimitiveRigidBody(descr: unknown, // type defined in subclasses
-    position?: D, rotation?: R, material?: unknown): IPositionable<D, R> & IRenderableEntity<D, R, VTypeDoc>;
+    position?: D, rotation?: R, material?: unknown): IPositionable<D, R> & IRenderableEntity<D, R, TypeDoc>;
     addEntity(entity: IEntity): void;
     removeEntity(entity: IEntity, dispose?: boolean): void;
     private onGgStaticInitialized;

package/dist/base/gg-world.js

@@ -14,9 +14,10 @@ export class GgWorld {
     static get documentWorlds() {
         return [...GgWorld._documentWorlds];
     }
-    constructor(visualScene, physicsWorld) {
-        this.visualScene = visualScene;
-        this.physicsWorld = physicsWorld;
+    get renderers() {
+        return this.tickListeners.filter(e => e instanceof IRendererEntity);
+    }
+    constructor(args) {
         this.worldClock = new PausableClock(false);
         this.keyboardInput = new KeyboardInput();
         this.name = 'w0x' + (GgWorld.default_name_counter++).toString(16);
@@ -29,6 +30,8 @@ export class GgWorld {
         this.tickForwardedTo$ = new Subject();
         this.paused$ = new Subject();
         this.disposed$ = new Subject();
+        this.visualScene = args.visualScene || null;
+        this.physicsWorld = args.physicsWorld || null;
         this.keyboardInput.start();
         if (window.ggstatic) {
             this.registerConsoleCommands(window.ggstatic);
@@ -43,7 +46,14 @@ export class GgWorld {
     }
     init() {
         return __awaiter(this, void 0, void 0, function* () {
-            yield Promise.all([this.physicsWorld.init(), this.visualScene.init()]);
+            const initPromises = [];
+            if (this.visualScene) {
+                initPromises.push(this.visualScene.init());
+            }
+            if (this.physicsWorld) {
+                initPromises.push(this.physicsWorld.init());
+            }
+            yield Promise.all(initPromises);
             const forwardTick = (listener, elapsed, delta) => {
                 if (listener.active) {
                     this.tickForwardTo$.next(listener);
@@ -62,9 +72,11 @@ export class GgWorld {
                     forwardTick(this.tickListeners[i], elapsed, delta);
                 }
                 // run physics simulation
-                this.tickForwardTo$.next('PHYSICS_WORLD');
-                this.physicsWorld.simulate(delta);
-                this.tickForwardedTo$.next('PHYSICS_WORLD');
+                if (this.physicsWorld) {
+                    this.tickForwardTo$.next('PHYSICS_WORLD');
+                    this.physicsWorld.simulate(delta);
+                    this.tickForwardedTo$.next('PHYSICS_WORLD');
+                }
                 // emit tick to all remained entities
                 for (i; i < this.tickListeners.length; i++) {
                     forwardTick(this.tickListeners[i], elapsed, delta);
@@ -111,8 +123,12 @@ export class GgWorld {
         }
         this.children.splice(0, this.children.length);
         this.tickListeners.splice(0, this.tickListeners.length);
-        this.physicsWorld.dispose();
-        this.visualScene.dispose();
+        if (this.physicsWorld) {
+            this.physicsWorld.dispose();
+        }
+        if (this.visualScene) {
+            this.visualScene.dispose();
+        }
         GgWorld._documentWorlds.splice(GgWorld._documentWorlds.indexOf(this), 1);
         this.disposed$.next();
         this.disposed$.complete();
@@ -159,10 +175,7 @@ export class GgWorld {
             return this.worldClock.tickRateLimit.toString();
         }), 'args: [ int? ]; Get current tick rate limit of selected world clock or set it. 0 means no limit applied');
         ggstatic.registerConsoleCommand(this, 'renderers', () => __awaiter(this, void 0, void 0, function* () {
-            return this.children
-                .filter(e => e instanceof IRendererEntity)
-                .map(r => r.name)
-                .join('\n');
+            return this.renderers.map(r => r.name).join('\n');
         }), 'no args; Print all renderers in selected world');
         ggstatic.registerConsoleCommand(this, 'debug_view', (...args) => __awaiter(this, void 0, void 0, function* () {
             let value = 'toggle';
@@ -175,7 +188,7 @@ export class GgWorld {
                     rendererName = arg;
                 }
             }
-            let renderer = this.children.find(x => x instanceof IRendererEntity && (!rendererName || x.name === rendererName));
+            let renderer = rendererName ? this.renderers.find(x => x.name === rendererName) : this.renderers[0];
             if (renderer) {
                 renderer.physicsDebugViewActive = value === 'toggle' ? !renderer.physicsDebugViewActive : value;
                 return renderer.physicsDebugViewActive ? '1' : '0';

package/dist/base/index.d.ts

@@ -26,6 +26,7 @@ export * from './models/axis-directions';
 export * from './models/body-options';
 export * from './models/geometry-nodes';
 export * from './models/points';
+export * from './models/raycasting';
 export * from './math/box';
 export * from './math/point2';
 export * from './math/point3';

package/dist/base/index.js

@@ -26,6 +26,7 @@ export * from './models/axis-directions';
 export * from './models/body-options';
 export * from './models/geometry-nodes';
 export * from './models/points';
+export * from './models/raycasting';
 export * from './math/box';
 export * from './math/point2';
 export * from './math/point3';

package/dist/base/math/numbers.d.ts

@@ -1,2 +1,3 @@
-export declare const averageAngle: (angleA: number, angleB: number, factor?: number) => number;
+export declare const averageAngle: (angleA: number, angleB: number) => number;
+export declare const lerpAngle: (angleA: number, angleB: number, factor: number) => number;
 export declare const lerpNumber: (a: number, b: number, t: number) => number;