@gg-web-engine/core 0.0.57 → 0.0.59

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

@@ -1,4 +1,4 @@
 import { IPhysicsWorldComponent, Point2 } from '../../../base';
 import { PhysicsTypeDocRepo2D } from '../../gg-2d-world';
-export interface IPhysicsWorld2dComponent<TypeDoc extends PhysicsTypeDocRepo2D = PhysicsTypeDocRepo2D> extends IPhysicsWorldComponent<Point2, number, TypeDoc> {
+export interface IPhysicsWorld2dComponent<PTypeDoc extends PhysicsTypeDocRepo2D = PhysicsTypeDocRepo2D> extends IPhysicsWorldComponent<Point2, number, PTypeDoc> {
 }

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

@@ -1,7 +1,7 @@
 import { IRigidBodyComponent, Point2 } from '../../../base';
 import { PhysicsTypeDocRepo2D } from '../../gg-2d-world';
 import { DebugBody2DSettings } from '../../models/body-options';
-export interface IRigidBody2dComponent<TypeDoc extends PhysicsTypeDocRepo2D = PhysicsTypeDocRepo2D> extends IRigidBodyComponent<Point2, number, TypeDoc> {
+export interface IRigidBody2dComponent<PTypeDoc extends PhysicsTypeDocRepo2D = PhysicsTypeDocRepo2D> extends IRigidBodyComponent<Point2, number, PTypeDoc> {
     angularVelocity: number;
     /** body info for physics debugger view */
     readonly debugBodySettings: DebugBody2DSettings;

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

@@ -2,9 +2,9 @@ import { ITriggerComponent, Point2 } from '../../../base';
 import { Observable } from 'rxjs';
 import { PhysicsTypeDocRepo2D } from '../../gg-2d-world';
 import { DebugBody2DSettings } from '../../models/body-options';
-export interface ITrigger2dComponent<TypeDoc extends PhysicsTypeDocRepo2D = PhysicsTypeDocRepo2D> extends ITriggerComponent<Point2, number, TypeDoc> {
+export interface ITrigger2dComponent<PTypeDoc extends PhysicsTypeDocRepo2D = PhysicsTypeDocRepo2D> extends ITriggerComponent<Point2, number, PTypeDoc> {
     /** body info for physics debugger view */
     readonly debugBodySettings: DebugBody2DSettings;
-    get onEntityEntered(): Observable<TypeDoc['rigidBody']>;
-    get onEntityLeft(): Observable<TypeDoc['rigidBody'] | null>;
+    get onEntityEntered(): Observable<PTypeDoc['rigidBody']>;
+    get onEntityLeft(): Observable<PTypeDoc['rigidBody'] | null>;
 }

package/dist/2d/components/rendering/i-camera-2d.component.d.ts

@@ -0,0 +1,5 @@
+import { IDisplayObject2dComponent } from './i-display-object-2d.component';
+import { VisualTypeDocRepo2D } from '../../gg-2d-world';
+export interface ICamera2dComponent<VTypeDoc extends VisualTypeDocRepo2D = VisualTypeDocRepo2D> extends IDisplayObject2dComponent<VTypeDoc> {
+    zoom: number;
+}

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

@@ -1,4 +1,4 @@
 import { IDisplayObjectComponent, Point2 } from '../../../base';
 import { VisualTypeDocRepo2D } from '../../gg-2d-world';
-export interface IDisplayObject2dComponent<TypeDoc extends VisualTypeDocRepo2D = VisualTypeDocRepo2D> extends IDisplayObjectComponent<Point2, number, TypeDoc> {
+export interface IDisplayObject2dComponent<VTypeDoc extends VisualTypeDocRepo2D = VisualTypeDocRepo2D> extends IDisplayObjectComponent<Point2, number, VTypeDoc> {
 }

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

@@ -1,4 +1,4 @@
 import { IRendererComponent, Point2 } from '../../../base';
 import { VisualTypeDocRepo2D } from '../../gg-2d-world';
-export declare abstract class IRenderer2dComponent<TypeDoc extends VisualTypeDocRepo2D = VisualTypeDocRepo2D> extends IRendererComponent<Point2, number, TypeDoc> {
+export declare abstract class IRenderer2dComponent<VTypeDoc extends VisualTypeDocRepo2D = VisualTypeDocRepo2D> extends IRendererComponent<Point2, number, VTypeDoc> {
 }

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

@@ -1,5 +1,4 @@
-import { IVisualSceneComponent, Point2, RendererOptions } from '../../../base';
+import { IVisualSceneComponent, Point2 } from '../../../base';
 import { VisualTypeDocRepo2D } from '../../gg-2d-world';
-export interface IVisualScene2dComponent<TypeDoc extends VisualTypeDocRepo2D = VisualTypeDocRepo2D> extends IVisualSceneComponent<Point2, number, TypeDoc> {
-    createRenderer(canvas?: HTMLCanvasElement, rendererOptions?: Partial<RendererOptions & TypeDoc['rendererExtraOpts']>): TypeDoc['renderer'];
+export interface IVisualScene2dComponent<VTypeDoc extends VisualTypeDocRepo2D = VisualTypeDocRepo2D> extends IVisualSceneComponent<Point2, number, VTypeDoc> {
 }

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

@@ -1,11 +1,11 @@
 import { AnimationFunction, AnimationMixer, Point2 } from '../../../base';
-import { Gg2dWorld, PhysicsTypeDocRepo2D, VisualTypeDocRepo2D } from '../../gg-2d-world';
+import { Gg2dWorld, Gg2dWorldTypeDocRepo } from '../../gg-2d-world';
 import { Entity2d } from '../entity-2d';
 type Positioning2d = {
     position: Point2;
     rotation: number;
 };
-export declare class Entity2dPositioningAnimator<T extends Entity2d = Entity2d> extends AnimationMixer<Positioning2d, Point2, number, VisualTypeDocRepo2D, PhysicsTypeDocRepo2D> {
+export declare class Entity2dPositioningAnimator<T extends Entity2d = Entity2d> extends AnimationMixer<Positioning2d, Point2, number, Gg2dWorldTypeDocRepo> {
     entity: T;
     protected _animationFunction: AnimationFunction<Positioning2d>;
     constructor(entity: T, _animationFunction: AnimationFunction<Positioning2d>);

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

@@ -1,8 +1,8 @@
 import { Point2, TickOrder } from '../../base';
 import { IPositionable2d } from '../interfaces/i-positionable-2d';
 import { IRenderable2dEntity } from './i-renderable-2d.entity';
-import { PhysicsTypeDocRepo2D, VisualTypeDocRepo2D } from '../gg-2d-world';
-export declare class Entity2d<VTypeDoc extends VisualTypeDocRepo2D = VisualTypeDocRepo2D, PTypeDoc extends PhysicsTypeDocRepo2D = PhysicsTypeDocRepo2D> extends IRenderable2dEntity<VTypeDoc, PTypeDoc> implements IPositionable2d {
+import { Gg2dWorldTypeDocRepo } from '../gg-2d-world';
+export declare class Entity2d<TypeDoc extends Gg2dWorldTypeDocRepo = Gg2dWorldTypeDocRepo> extends IRenderable2dEntity<TypeDoc> implements IPositionable2d {
     readonly tickOrder = TickOrder.OBJECTS_BINDING;
     private _position;
     get position(): Point2;
@@ -10,15 +10,15 @@ export declare class Entity2d<VTypeDoc extends VisualTypeDocRepo2D = VisualTypeD
     private _rotation;
     get rotation(): number;
     set rotation(value: number);
-    readonly object2D: VTypeDoc['displayObject'] | null;
-    readonly objectBody: PTypeDoc['rigidBody'] | null;
+    readonly object2D: TypeDoc['vTypeDoc']['displayObject'] | null;
+    readonly objectBody: TypeDoc['pTypeDoc']['rigidBody'] | null;
     updateVisibility(): void;
     /**
      * Synchronize physics body transform with entity (and object2d if defined)
      * */
-    protected runTransformBinding(objectBody: PTypeDoc['rigidBody'], object2D: VTypeDoc['displayObject'] | null): void;
+    protected runTransformBinding(objectBody: TypeDoc['pTypeDoc']['rigidBody'], object2D: TypeDoc['vTypeDoc']['displayObject'] | null): void;
     constructor(options: {
-        object2D?: VTypeDoc['displayObject'];
-        objectBody?: PTypeDoc['rigidBody'];
+        object2D?: TypeDoc['vTypeDoc']['displayObject'];
+        objectBody?: TypeDoc['pTypeDoc']['rigidBody'];
     });
 }

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

@@ -1,6 +1,6 @@
 import { IRenderableEntity, Point2 } from '../../base';
-import { Gg2dWorld, PhysicsTypeDocRepo2D, VisualTypeDocRepo2D } from '../gg-2d-world';
-export declare abstract class IRenderable2dEntity<TypeDoc extends VisualTypeDocRepo2D = VisualTypeDocRepo2D, PTypeDoc extends PhysicsTypeDocRepo2D = PhysicsTypeDocRepo2D> extends IRenderableEntity<Point2, number, TypeDoc, PTypeDoc> {
-    protected _world: Gg2dWorld<TypeDoc, PTypeDoc> | null;
-    get world(): Gg2dWorld<TypeDoc, PTypeDoc> | null;
+import { Gg2dWorld, Gg2dWorldTypeDocRepo } from '../gg-2d-world';
+export declare abstract class IRenderable2dEntity<TypeDoc extends Gg2dWorldTypeDocRepo = Gg2dWorldTypeDocRepo> extends IRenderableEntity<Point2, number, TypeDoc> {
+    protected _world: Gg2dWorld<TypeDoc> | null;
+    get world(): Gg2dWorld<TypeDoc> | null;
 }

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

@@ -1,4 +1,5 @@
 import { IRendererEntity, Point2 } from '../../base';
 import { VisualTypeDocRepo2D } from '../gg-2d-world';
-export declare class Renderer2dEntity<TypeDoc extends VisualTypeDocRepo2D = VisualTypeDocRepo2D> extends IRendererEntity<Point2, number, TypeDoc> {
+import { IPositionable2d } from '../interfaces/i-positionable-2d';
+export declare class Renderer2dEntity<VTypeDoc extends VisualTypeDocRepo2D = VisualTypeDocRepo2D> extends IRendererEntity<Point2, number, VTypeDoc> implements IPositionable2d {
 }

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

@@ -2,12 +2,16 @@ import { Observable } from 'rxjs';
 import { ITrigger2dComponent } from '../components/physics/i-trigger-2d.component';
 import { IEntity, Point2, TickOrder } from '../../base';
 import { IPositionable2d } from '../interfaces/i-positionable-2d';
-import { PhysicsTypeDocRepo2D, VisualTypeDocRepo2D } from '../gg-2d-world';
-export declare class Trigger2dEntity<TypeDoc extends PhysicsTypeDocRepo2D = PhysicsTypeDocRepo2D> extends IEntity<Point2, number, VisualTypeDocRepo2D, TypeDoc> implements IPositionable2d {
+import { Gg2dWorldTypeDocPPatch, Gg2dWorldTypeDocRepo, PhysicsTypeDocRepo2D } from '../gg-2d-world';
+export declare class Trigger2dEntity<PTypeDoc extends PhysicsTypeDocRepo2D = PhysicsTypeDocRepo2D> extends IEntity<Point2, number, Gg2dWorldTypeDocPPatch<PTypeDoc>> implements IPositionable2d {
     readonly objectBody: ITrigger2dComponent;
     readonly tickOrder = TickOrder.OBJECTS_BINDING;
-    get onEntityEntered(): Observable<IEntity<Point2, number, VisualTypeDocRepo2D, TypeDoc> & IPositionable2d>;
-    get onEntityLeft(): Observable<(IEntity<Point2, number, VisualTypeDocRepo2D, TypeDoc> & IPositionable2d) | null>;
+    get onEntityEntered(): Observable<IEntity<Point2, number, Gg2dWorldTypeDocRepo & {
+        pTypeDoc: PTypeDoc;
+    }> & IPositionable2d>;
+    get onEntityLeft(): Observable<(IEntity<Point2, number, Gg2dWorldTypeDocRepo & {
+        pTypeDoc: PTypeDoc;
+    }> & IPositionable2d) | null>;
     private _position;
     get position(): Point2;
     set position(value: Point2);

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

@@ -5,19 +5,19 @@ export type DisplayObject2dOpts<Tex> = {
     color?: number;
     texture?: Tex;
 };
-export declare abstract class IDisplayObject2dComponentFactory<TypeDoc extends VisualTypeDocRepo2D = VisualTypeDocRepo2D> {
-    abstract createPrimitive(descriptor: Shape2DDescriptor, material?: DisplayObject2dOpts<TypeDoc['texture']>): TypeDoc['displayObject'];
+export declare abstract class IDisplayObject2dComponentFactory<VTypeDoc extends VisualTypeDocRepo2D = VisualTypeDocRepo2D> {
+    abstract createPrimitive(descriptor: Shape2DDescriptor, material?: DisplayObject2dOpts<VTypeDoc['texture']>): VTypeDoc['displayObject'];
     randomColor(): number;
-    createSquare(dimensions: Point2, material?: DisplayObject2dOpts<TypeDoc['texture']>): TypeDoc['displayObject'];
-    createCircle(radius: number, material?: DisplayObject2dOpts<TypeDoc['texture']>): TypeDoc['displayObject'];
+    createSquare(dimensions: Point2, material?: DisplayObject2dOpts<VTypeDoc['texture']>): VTypeDoc['displayObject'];
+    createCircle(radius: number, material?: DisplayObject2dOpts<VTypeDoc['texture']>): VTypeDoc['displayObject'];
 }
-export interface IPhysicsBody2dComponentFactory<TypeDoc extends PhysicsTypeDocRepo2D = PhysicsTypeDocRepo2D> {
+export interface IPhysicsBody2dComponentFactory<PTypeDoc extends PhysicsTypeDocRepo2D = PhysicsTypeDocRepo2D> {
     createRigidBody(descriptor: BodyShape2DDescriptor, transform?: {
         position?: Point2;
         rotation?: number;
-    }): TypeDoc['rigidBody'];
+    }): PTypeDoc['rigidBody'];
     createTrigger(descriptor: Shape2DDescriptor, transform?: {
         position?: Point2;
         rotation?: number;
-    }): TypeDoc['trigger'];
+    }): PTypeDoc['trigger'];
 }

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

@@ -1,4 +1,5 @@
 import { GgWorld, Point2, RendererOptions } from '../base';
+import { Gg2dLoader } from './loader';
 import { BodyShape2DDescriptor } from './models/shapes';
 import { Entity2d } from './entities/entity-2d';
 import { IPhysicsWorld2dComponent } from './components/physics/i-physics-world-2d.component';
@@ -7,6 +8,7 @@ import { Renderer2dEntity } from './entities/renderer-2d.entity';
 import { DisplayObject2dOpts, IDisplayObject2dComponentFactory, IPhysicsBody2dComponentFactory } from './factories';
 import { IRenderer2dComponent } from './components/rendering/i-renderer-2d.component';
 import { IDisplayObject2dComponent } from './components/rendering/i-display-object-2d.component';
+import { ICamera2dComponent } from './components/rendering/i-camera-2d.component';
 import { ITrigger2dComponent } from './components/physics/i-trigger-2d.component';
 import { IRigidBody2dComponent } from './components/physics/i-rigid-body-2d.component';
 export type VisualTypeDocRepo2D = {
@@ -14,6 +16,7 @@ export type VisualTypeDocRepo2D = {
     displayObject: IDisplayObject2dComponent;
     renderer: IRenderer2dComponent;
     rendererExtraOpts: {};
+    camera: ICamera2dComponent;
     texture: unknown;
 };
 export type PhysicsTypeDocRepo2D = {
@@ -21,12 +24,41 @@ export type PhysicsTypeDocRepo2D = {
     rigidBody: IRigidBody2dComponent;
     trigger: ITrigger2dComponent;
 };
-export declare class Gg2dWorld<VTypeDoc extends VisualTypeDocRepo2D = VisualTypeDocRepo2D, PTypeDoc extends PhysicsTypeDocRepo2D = PhysicsTypeDocRepo2D, VS extends IVisualScene2dComponent<VTypeDoc> = IVisualScene2dComponent<VTypeDoc>, PW extends IPhysicsWorld2dComponent<PTypeDoc> = IPhysicsWorld2dComponent<PTypeDoc>> extends GgWorld<Point2, number, VTypeDoc, PTypeDoc, VS, PW> {
-    readonly visualScene: VS;
-    readonly physicsWorld: PW;
-    constructor(visualScene: VS, physicsWorld: PW);
-    addPrimitiveRigidBody(descr: BodyShape2DDescriptor, position?: Point2, rotation?: number, material?: DisplayObject2dOpts<VTypeDoc['texture']>): Entity2d<VTypeDoc, PTypeDoc>;
-    addRenderer(canvas?: HTMLCanvasElement, rendererOptions?: Partial<RendererOptions & VTypeDoc['rendererExtraOpts']>): Renderer2dEntity<VTypeDoc>;
+export type Gg2dWorldTypeDocRepo = {
+    vTypeDoc: VisualTypeDocRepo2D;
+    pTypeDoc: PhysicsTypeDocRepo2D;
+};
+export type Gg2dWorldTypeDocVPatch<VTypeDoc extends VisualTypeDocRepo2D> = Omit<Gg2dWorldTypeDocRepo, 'vTypeDoc'> & {
+    vTypeDoc: VTypeDoc;
+};
+export type Gg2dWorldTypeDocPPatch<PTypeDoc extends PhysicsTypeDocRepo2D> = Omit<Gg2dWorldTypeDocRepo, 'pTypeDoc'> & {
+    pTypeDoc: PTypeDoc;
+};
+export type Gg2dWorldSceneTypeRepo<TypeDoc extends Gg2dWorldTypeDocRepo = Gg2dWorldTypeDocRepo> = {
+    visualScene: IVisualScene2dComponent<TypeDoc['vTypeDoc']> | null;
+    physicsWorld: IPhysicsWorld2dComponent<TypeDoc['pTypeDoc']> | null;
+};
+export type Gg2dWorldSceneTypeDocVPatch<VTypeDoc extends VisualTypeDocRepo2D, VS extends IVisualScene2dComponent<VTypeDoc> | null> = Omit<Gg2dWorldSceneTypeRepo, 'visualScene'> & {
+    visualScene: VS;
+};
+export type Gg2dWorldSceneTypeDocPPatch<PTypeDoc extends PhysicsTypeDocRepo2D, PW extends IPhysicsWorld2dComponent<PTypeDoc> | null> = Omit<Gg2dWorldSceneTypeRepo, 'physicsWorld'> & {
+    physicsWorld: PW;
+};
+export type TypedGg2dWorld<VW extends Gg2dWorld<any> | null, PW extends Gg2dWorld<any> | null> = VW extends Gg2dWorld<infer VTD, infer VSTD> | null ? PW extends Gg2dWorld<infer PTD, infer PSTD> | null ? Gg2dWorld<{
+    vTypeDoc: VTD['vTypeDoc'];
+    pTypeDoc: PTD['pTypeDoc'];
+}, {
+    visualScene: VSTD['visualScene'];
+    physicsWorld: PSTD['physicsWorld'];
+}> : never : never;
+export declare class Gg2dWorld<TypeDoc extends Gg2dWorldTypeDocRepo = Gg2dWorldTypeDocRepo, SceneTypeDoc extends Gg2dWorldSceneTypeRepo<TypeDoc> = Gg2dWorldSceneTypeRepo<TypeDoc>> extends GgWorld<Point2, number, TypeDoc, SceneTypeDoc> {
+    readonly loader: Gg2dLoader<TypeDoc>;
+    constructor(args: {
+        visualScene?: SceneTypeDoc['visualScene'];
+        physicsWorld?: SceneTypeDoc['physicsWorld'];
+    });
+    addPrimitiveRigidBody(descr: BodyShape2DDescriptor, position?: Point2, rotation?: number, material?: DisplayObject2dOpts<TypeDoc['vTypeDoc']['texture']>): Entity2d<TypeDoc>;
+    addRenderer(camera: TypeDoc['vTypeDoc']['camera'], canvas?: HTMLCanvasElement, rendererOptions?: Partial<RendererOptions & TypeDoc['vTypeDoc']['rendererExtraOpts']>): Renderer2dEntity<TypeDoc['vTypeDoc']>;
     protected registerConsoleCommands(ggstatic: {
         registerConsoleCommand: (world: GgWorld<any, any> | null, command: string, handler: (...args: string[]) => Promise<string>, doc?: string) => void;
     }): void;

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

@@ -8,44 +8,50 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { GgWorld, Pnt2 } from '../base';
+import { Gg2dLoader } from './loader';
 import { Entity2d } from './entities/entity-2d';
 import { Renderer2dEntity } from './entities/renderer-2d.entity';
 export class Gg2dWorld extends GgWorld {
-    constructor(visualScene, physicsWorld) {
-        super(visualScene, physicsWorld);
-        this.visualScene = visualScene;
-        this.physicsWorld = physicsWorld;
+    constructor(args) {
+        super(args);
+        this.loader = new Gg2dLoader(this);
     }
     addPrimitiveRigidBody(descr, position = Pnt2.O, rotation = 0, material = {}) {
+        var _a, _b;
         const entity = new Entity2d({
-            object2D: this.visualScene.factory.createPrimitive(descr.shape, material),
-            objectBody: this.physicsWorld.factory.createRigidBody(descr),
+            object2D: (_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;
         this.addEntity(entity);
         return entity;
     }
-    addRenderer(canvas, rendererOptions) {
-        const entity = new Renderer2dEntity(this.visualScene.createRenderer(canvas, rendererOptions));
+    addRenderer(camera, canvas, rendererOptions) {
+        if (!this.visualScene) {
+            throw new Error('Cannot add renderer to the world without visual scene');
+        }
+        const entity = new Renderer2dEntity(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', args[0]]; // mean Y axis
-            }
-            if (args.length > 0) {
-                if (isNaN(+args[0]) || isNaN(+args[1])) {
-                    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', args[0]]; // mean Y axis
                 }
-                this.physicsWorld.gravity = { x: +args[0], y: +args[1] };
-            }
-            return JSON.stringify(this.physicsWorld.gravity);
-        }), 'args: [ ?float, ?float ]; Get or set 2D world gravity vector. 1 argument sets' +
-            ' vector {x: 0, y: value}, 2 arguments sets the whole vector.' +
-            ' Default value is "9.82" or "0 9.82"');
+                if (args.length > 0) {
+                    if (isNaN(+args[0]) || isNaN(+args[1])) {
+                        throw new Error('Wrong arguments');
+                    }
+                    this.physicsWorld.gravity = { x: +args[0], y: +args[1] };
+                }
+                return JSON.stringify(this.physicsWorld.gravity);
+            }), 'args: [ ?float, ?float ]; Get or set 2D world gravity vector. 1 argument sets' +
+                ' vector {x: 0, y: value}, 2 arguments sets the whole vector.' +
+                ' Default value is "9.82" or "0 9.82"');
+        }
     }
 }

package/dist/2d/index.d.ts

@@ -1,6 +1,7 @@
 export * from './components/physics/i-rigid-body-2d.component';
 export * from './components/physics/i-trigger-2d.component';
 export * from './components/physics/i-physics-world-2d.component';
+export * from './components/rendering/i-camera-2d.component';
 export * from './components/rendering/i-display-object-2d.component';
 export * from './components/rendering/i-renderer-2d.component';
 export * from './components/rendering/i-visual-scene-2d.component';
@@ -14,3 +15,5 @@ export * from './models/body-options';
 export * from './models/shapes';
 export * from './factories';
 export * from './gg-2d-world';
+export * from './loader';
+export * from './level-loader';

package/dist/2d/index.js

@@ -1,6 +1,7 @@
 export * from './components/physics/i-rigid-body-2d.component';
 export * from './components/physics/i-trigger-2d.component';
 export * from './components/physics/i-physics-world-2d.component';
+export * from './components/rendering/i-camera-2d.component';
 export * from './components/rendering/i-display-object-2d.component';
 export * from './components/rendering/i-renderer-2d.component';
 export * from './components/rendering/i-visual-scene-2d.component';
@@ -14,3 +15,5 @@ export * from './models/body-options';
 export * from './models/shapes';
 export * from './factories';
 export * from './gg-2d-world';
+export * from './loader';
+export * from './level-loader';

package/dist/2d/level-loader.d.ts

@@ -0,0 +1,101 @@
+import { LevelLoader } from '../base/level-loader';
+import { Gg2dWorld, Gg2dWorldTypeDocRepo } from './gg-2d-world';
+import { Point2 } from '../base';
+import { DisplayObject2dOpts } from './factories';
+import { Body2DOptions } from './models/body-options';
+import { Shape2DDescriptor } from './models/shapes';
+/**
+ * Shape names accepted by the built-in `"Primitive"` entity class in a 2D level JSON, via the
+ * sibling `shape` field on the entity (e.g. `{ class: "Primitive", shape: "SQUARE" }`) - the same
+ * `Shape2DDescriptor['shape']` values used at the engine API level, so no translation is needed
+ * between a level JSON and `Gg2dWorld.addPrimitiveRigidBody`.
+ */
+export type Primitive2DShapeName = Shape2DDescriptor['shape'];
+/**
+ * Settings shared by every primitive entity (Square, Circle, ...)
+ */
+export interface PrimitiveSettings {
+    /**
+     * Which primitive shape to construct
+     */
+    shape: Primitive2DShapeName;
+    /**
+     * Position of the primitive
+     */
+    position?: Point2;
+    /**
+     * Rotation of the primitive in radians
+     */
+    rotation?: number;
+    /**
+     * Dimensions of the primitive (for Square)
+     */
+    dimensions?: Point2;
+    /**
+     * Radius of the primitive (for Circle)
+     */
+    radius?: number;
+    /**
+     * Material options for the primitive
+     */
+    material?: DisplayObject2dOpts<any>;
+    /**
+     * Physics body options, merged over sensible defaults
+     */
+    body?: Partial<Body2DOptions>;
+}
+/**
+ * Settings for a trigger entity
+ */
+export interface TriggerSettings {
+    /**
+     * Position of the trigger
+     */
+    position?: Point2;
+    /**
+     * Rotation of the trigger in radians
+     */
+    rotation?: number;
+    /**
+     * Dimensions of the trigger
+     */
+    dimensions: Point2;
+}
+/**
+ * 2D level loader: registers the built-in primitive/trigger entity classes and dispatches
+ * `LevelJson` entities to them (or to custom classes registered via `registerClass`).
+ * @template TypeDoc - The type document repository
+ */
+export declare class Gg2dLevelLoader<TypeDoc extends Gg2dWorldTypeDocRepo = Gg2dWorldTypeDocRepo> extends LevelLoader<Point2, number, TypeDoc> {
+    protected readonly world: Gg2dWorld<TypeDoc>;
+    constructor(world: Gg2dWorld<TypeDoc>);
+    /**
+     * Register the built-in classes for primitives and triggers
+     */
+    private registerDefaultClasses;
+    /**
+     * Turn a `PrimitiveSettings` (`shape` plus shape-specific fields) into the `Shape2DDescriptor`
+     * consumed by `Gg2dWorld.addPrimitiveRigidBody`.
+     * @param settings - The primitive settings, as parsed from a `"Primitive"` entity's `shape` +
+     * `config`
+     * @returns The shape descriptor
+     */
+    private buildShapeDescriptor;
+    /**
+     * Create a primitive entity (both display object and physics body) from a shape descriptor
+     * @param world - The world instance
+     * @param shape - The shape descriptor
+     * @param settings - Position/rotation/material/body settings shared by all primitives
+     * @returns The created entity
+     */
+    private createPrimitive;
+    /**
+     * Create a trigger entity: a `Trigger2dEntity` wrapping the raw physics trigger component, so
+     * the app can subscribe to `onEntityEntered`/`onEntityLeft` without any extra wiring - see the
+     * base `LevelLoader` docs for how it's parented for level-lifecycle cleanup.
+     * @param world - The world instance
+     * @param settings - The trigger settings
+     * @returns The created trigger entity
+     */
+    private createTrigger;
+}

package/dist/2d/level-loader.js

@@ -0,0 +1,88 @@
+import { LevelLoader } from '../base/level-loader';
+import { Trigger2dEntity } from './entities/trigger-2d.entity';
+const defaultBodyOptions = {
+    dynamic: true,
+    mass: 1,
+    restitution: 0.2,
+    friction: 0.5,
+    ownCollisionGroups: 'all',
+    interactWithCollisionGroups: 'all',
+};
+/**
+ * 2D level loader: registers the built-in primitive/trigger entity classes and dispatches
+ * `LevelJson` entities to them (or to custom classes registered via `registerClass`).
+ * @template TypeDoc - The type document repository
+ */
+export class Gg2dLevelLoader extends LevelLoader {
+    constructor(world) {
+        super(world);
+        this.world = world;
+        this.registerDefaultClasses();
+    }
+    /**
+     * Register the built-in classes for primitives and triggers
+     */
+    registerDefaultClasses() {
+        this.registerClass('Primitive', (world, settings) => this.createPrimitive(world, this.buildShapeDescriptor(settings), settings));
+        this.registerClass('Trigger', this.createTrigger.bind(this));
+    }
+    /**
+     * Turn a `PrimitiveSettings` (`shape` plus shape-specific fields) into the `Shape2DDescriptor`
+     * consumed by `Gg2dWorld.addPrimitiveRigidBody`.
+     * @param settings - The primitive settings, as parsed from a `"Primitive"` entity's `shape` +
+     * `config`
+     * @returns The shape descriptor
+     */
+    buildShapeDescriptor(settings) {
+        switch (settings.shape) {
+            case 'SQUARE':
+                if (!settings.dimensions) {
+                    throw new Error('Dimensions are required for SQUARE primitive');
+                }
+                return { shape: 'SQUARE', dimensions: settings.dimensions };
+            case 'CIRCLE':
+                if (settings.radius === undefined) {
+                    throw new Error('Radius is required for CIRCLE primitive');
+                }
+                return { shape: 'CIRCLE', radius: settings.radius };
+            default:
+                throw new Error(`Unknown primitive shape "${settings.shape}"`);
+        }
+    }
+    /**
+     * Create a primitive entity (both display object and physics body) from a shape descriptor
+     * @param world - The world instance
+     * @param shape - The shape descriptor
+     * @param settings - Position/rotation/material/body settings shared by all primitives
+     * @returns The created entity
+     */
+    createPrimitive(world, shape, settings) {
+        const { position, rotation, material, body } = settings;
+        return world.addPrimitiveRigidBody({ shape, body: Object.assign(Object.assign({}, defaultBodyOptions), body) }, position, rotation, material);
+    }
+    /**
+     * Create a trigger entity: a `Trigger2dEntity` wrapping the raw physics trigger component, so
+     * the app can subscribe to `onEntityEntered`/`onEntityLeft` without any extra wiring - see the
+     * base `LevelLoader` docs for how it's parented for level-lifecycle cleanup.
+     * @param world - The world instance
+     * @param settings - The trigger settings
+     * @returns The created trigger entity
+     */
+    createTrigger(world, settings) {
+        var _a;
+        const { position, rotation, dimensions } = settings;
+        const shape = { shape: 'SQUARE', dimensions };
+        const trigger = (_a = world.physicsWorld) === null || _a === void 0 ? void 0 : _a.factory.createTrigger(shape, { position, rotation });
+        if (!trigger) {
+            return undefined;
+        }
+        const entity = new Trigger2dEntity(trigger);
+        if (position !== undefined) {
+            entity.position = position;
+        }
+        if (rotation !== undefined) {
+            entity.rotation = rotation;
+        }
+        return entity;
+    }
+}

package/dist/2d/loader.d.ts

@@ -0,0 +1,11 @@
+import { Gg2dWorldTypeDocRepo } from './gg-2d-world';
+import { Gg2dLevelLoader } from './level-loader';
+/**
+ * Full loader exposed as `Gg2dWorld.loader`, extending `Gg2dLevelLoader` (so
+ * `registerClass`/`loadLevel`/`loadLevelFromUrl`/`getEntityByName` are all available directly on
+ * `world.loader`) - kept as its own class/type so 2D can grow other loading capabilities (the way
+ * `Gg3dLoader` has GLB loading) without a breaking rename.
+ * @template TypeDoc - The type document repository
+ */
+export declare class Gg2dLoader<TypeDoc extends Gg2dWorldTypeDocRepo = Gg2dWorldTypeDocRepo> extends Gg2dLevelLoader<TypeDoc> {
+}

package/dist/2d/loader.js

@@ -0,0 +1,10 @@
+import { Gg2dLevelLoader } from './level-loader';
+/**
+ * Full loader exposed as `Gg2dWorld.loader`, extending `Gg2dLevelLoader` (so
+ * `registerClass`/`loadLevel`/`loadLevelFromUrl`/`getEntityByName` are all available directly on
+ * `world.loader`) - kept as its own class/type so 2D can grow other loading capabilities (the way
+ * `Gg3dLoader` has GLB loading) without a breaking rename.
+ * @template TypeDoc - The type document repository
+ */
+export class Gg2dLoader extends Gg2dLevelLoader {
+}

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

@@ -1,12 +1,12 @@
 import { IPhysicsWorldComponent, Point3, Point4 } from '../../../base';
 import { PhysicsTypeDocRepo3D } from '../../gg-3d-world';
 import { Subject } from 'rxjs';
-export interface IPhysicsWorld3dComponent<TypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> extends IPhysicsWorldComponent<Point3, Point4, TypeDoc> {
-    readonly loader: TypeDoc['loader'];
+export interface IPhysicsWorld3dComponent<PTypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> extends IPhysicsWorldComponent<Point3, Point4, PTypeDoc> {
+    readonly loader: PTypeDoc['loader'];
     /** event emitter, emits newly added physics components */
-    readonly added$: Subject<TypeDoc['trigger'] | TypeDoc['rigidBody'] | TypeDoc['raycastVehicle'] | any>;
+    readonly added$: Subject<PTypeDoc['trigger'] | PTypeDoc['rigidBody'] | PTypeDoc['raycastVehicle'] | any>;
     /** event emitter, emits just removed physics components */
-    readonly removed$: Subject<TypeDoc['trigger'] | TypeDoc['rigidBody'] | TypeDoc['raycastVehicle'] | any>;
+    readonly removed$: Subject<PTypeDoc['trigger'] | PTypeDoc['rigidBody'] | PTypeDoc['raycastVehicle'] | any>;
     /** list of currently added to world physics components */
-    readonly children: (TypeDoc['trigger'] | TypeDoc['rigidBody'] | TypeDoc['raycastVehicle'] | any)[];
+    readonly children: (PTypeDoc['trigger'] | PTypeDoc['rigidBody'] | PTypeDoc['raycastVehicle'] | any)[];
 }

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

@@ -17,7 +17,7 @@ export type WheelOptions = {
     rollInfluence: number;
     maxTravel: number;
 };
-export interface IRaycastVehicleComponent<TypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> extends IRigidBody3dComponent<TypeDoc> {
+export interface IRaycastVehicleComponent<PTypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> extends IRigidBody3dComponent<PTypeDoc> {
     /** Return speed in m/s, calculated by car itself (which should be shown on the speedometer) */
     get wheelSpeed(): number;
     addWheel(options: WheelOptions, suspensionOptions: SuspensionOptions): void;

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

@@ -1,7 +1,7 @@
 import { IRigidBodyComponent, Point3, Point4 } from '../../../base';
 import { PhysicsTypeDocRepo3D } from '../../gg-3d-world';
 import { DebugBody3DSettings } from '../../models/body-options';
-export interface IRigidBody3dComponent<TypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> extends IRigidBodyComponent<Point3, Point4, TypeDoc> {
+export interface IRigidBody3dComponent<PTypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> extends IRigidBodyComponent<Point3, Point4, PTypeDoc> {
     angularVelocity: Point3;
     /** body info for physics debugger view */
     readonly debugBodySettings: DebugBody3DSettings;

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

@@ -2,9 +2,9 @@ import { ITriggerComponent, Point3, Point4 } from '../../../base';
 import { Observable } from 'rxjs';
 import { PhysicsTypeDocRepo3D } from '../../gg-3d-world';
 import { DebugBody3DSettings } from '../../models/body-options';
-export interface ITrigger3dComponent<TypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> extends ITriggerComponent<Point3, Point4, TypeDoc> {
+export interface ITrigger3dComponent<PTypeDoc extends PhysicsTypeDocRepo3D = PhysicsTypeDocRepo3D> extends ITriggerComponent<Point3, Point4, PTypeDoc> {
     /** body info for physics debugger view */
     readonly debugBodySettings: DebugBody3DSettings;
-    get onEntityEntered(): Observable<TypeDoc['rigidBody']>;
-    get onEntityLeft(): Observable<TypeDoc['rigidBody'] | null>;
+    get onEntityEntered(): Observable<PTypeDoc['rigidBody']>;
+    get onEntityLeft(): Observable<PTypeDoc['rigidBody'] | null>;
 }