@gg-web-engine/core 0.0.58 → 0.0.60

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-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<VTypeDoc extends VisualTypeDocRepo2D = VisualTypeDocRepo2D> extends IVisualSceneComponent<Point2, number, VTypeDoc> {
-    createRenderer(canvas?: HTMLCanvasElement, rendererOptions?: Partial<RendererOptions & VTypeDoc['rendererExtraOpts']>): VTypeDoc['renderer'];
 }

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<VTypeDoc extends VisualTypeDocRepo2D = VisualTypeDocRepo2D> extends IRendererEntity<Point2, number, VTypeDoc> {
+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/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 = {
@@ -49,12 +52,13 @@ export type TypedGg2dWorld<VW extends Gg2dWorld<any> | null, PW extends Gg2dWorl
     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(canvas?: HTMLCanvasElement, rendererOptions?: Partial<RendererOptions & TypeDoc['vTypeDoc']['rendererExtraOpts']>): Renderer2dEntity<TypeDoc['vTypeDoc']>;
+    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,11 +8,13 @@ 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(args) {
         super(args);
+        this.loader = new Gg2dLoader(this);
     }
     addPrimitiveRigidBody(descr, position = Pnt2.O, rotation = 0, material = {}) {
         var _a, _b;
@@ -25,16 +27,69 @@ export class Gg2dWorld extends GgWorld {
         this.addEntity(entity);
         return entity;
     }
-    addRenderer(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(canvas, rendererOptions));
+        const entity = new Renderer2dEntity(this.visualScene.createRenderer(camera, canvas, rendererOptions));
         this.addEntity(entity);
         return entity;
     }
     registerConsoleCommands(ggstatic) {
         super.registerConsoleCommands(ggstatic);
+        ggstatic.registerConsoleCommand(this, 'set_position', (...args) => __awaiter(this, void 0, void 0, function* () {
+            const [name, x, y] = args;
+            if (!name) {
+                throw new Error('usage: set_position <name> <x> <y>');
+            }
+            const entity = this.getEntityByName(name);
+            if (!('position' in entity)) {
+                throw new Error(`Entity "${name}" (${entity.constructor.name}) has no position`);
+            }
+            if ([x, y].some(v => v === undefined || isNaN(+v))) {
+                throw new Error('usage: set_position <name> <x> <y>');
+            }
+            entity.position = { x: +x, y: +y };
+            return JSON.stringify(entity.position);
+        }), 'args: [ string, float, float ]; Teleport a named entity to world-space coordinates. Use ' +
+            '"entities"/"entity <name>" to find entity names and their current position');
+        ggstatic.registerConsoleCommand(this, 'set_rotation', (...args) => __awaiter(this, void 0, void 0, function* () {
+            const [name, angle] = args;
+            if (!name) {
+                throw new Error('usage: set_rotation <name> <angleRadians>');
+            }
+            const entity = this.getEntityByName(name);
+            if (!('rotation' in entity)) {
+                throw new Error(`Entity "${name}" (${entity.constructor.name}) has no rotation`);
+            }
+            if (angle === undefined || isNaN(+angle)) {
+                throw new Error('usage: set_rotation <name> <angleRadians>');
+            }
+            entity.rotation = +angle;
+            return JSON.stringify(entity.rotation);
+        }), 'args: [ string, float ]; Rotate a named entity to the given angle, in radians');
+        ggstatic.registerConsoleCommand(this, 'spawn', (...args) => __awaiter(this, void 0, void 0, function* () {
+            const [shapeArg, x, y, dynamicArg] = args;
+            if ([x, y].some(v => v === undefined || isNaN(+v))) {
+                throw new Error('usage: spawn <SQUARE|CIRCLE> <x> <y> [dynamic=0|1]');
+            }
+            const dynamic = dynamicArg === undefined ? true : dynamicArg === '1';
+            let shape;
+            switch ((shapeArg || '').toUpperCase()) {
+                case 'SQUARE':
+                    shape = { shape: 'SQUARE', dimensions: { x: 1, y: 1 } };
+                    break;
+                case 'CIRCLE':
+                    shape = { shape: 'CIRCLE', radius: 0.5 };
+                    break;
+                default:
+                    throw new Error(`Unknown shape "${shapeArg}". Use SQUARE|CIRCLE`);
+            }
+            const entity = this.addPrimitiveRigidBody({ shape, body: { dynamic } }, { x: +x, y: +y });
+            return `spawned "${entity.name}" (${shape.shape}) at ${JSON.stringify(entity.position)}`;
+        }), 'args: [ SQUARE|CIRCLE, float, float, 0|1? ]; Spawn a default-sized primitive rigid body at ' +
+            'world-space coordinates, for probing physics. dynamic (last arg) defaults to 1 (falls ' +
+            'under gravity); pass 0 for a static prop');
         if (this.physicsWorld) {
             ggstatic.registerConsoleCommand(this, 'gravity', (...args) => __awaiter(this, void 0, void 0, function* () {
                 if (args.length == 1) {

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/rendering/{i-camera.component.d.ts → i-camera-3d.component.d.ts}

@@ -1,6 +1,6 @@
 import { IDisplayObject3dComponent } from './i-display-object-3d.component';
 import { VisualTypeDocRepo3D } from '../../gg-3d-world';
-export interface ICameraComponent<VTypeDoc extends VisualTypeDocRepo3D = VisualTypeDocRepo3D> extends IDisplayObject3dComponent<VTypeDoc> {
+export interface ICamera3dComponent<VTypeDoc extends VisualTypeDocRepo3D = VisualTypeDocRepo3D> extends IDisplayObject3dComponent<VTypeDoc> {
     get supportsFov(): boolean;
     get fov(): number;
     set fov(f: number);

package/dist/3d/components/rendering/i-camera-3d.component.js

@@ -0,0 +1 @@
+export {};

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

@@ -1,5 +1,4 @@
 import { IRendererComponent, Point3, Point4 } from '../../../base';
 import { VisualTypeDocRepo3D } from '../../gg-3d-world';
 export declare abstract class IRenderer3dComponent<VTypeDoc extends VisualTypeDocRepo3D = VisualTypeDocRepo3D> extends IRendererComponent<Point3, Point4, VTypeDoc> {
-    abstract camera: VTypeDoc['camera'];
 }

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

@@ -1,6 +1,5 @@
-import { IVisualSceneComponent, Point3, Point4, RendererOptions } from '../../../base';
+import { IVisualSceneComponent, Point3, Point4 } from '../../../base';
 import { VisualTypeDocRepo3D } from '../../gg-3d-world';
 export interface IVisualScene3dComponent<VTypeDoc extends VisualTypeDocRepo3D = VisualTypeDocRepo3D> extends IVisualSceneComponent<Point3, Point4, VTypeDoc> {
     readonly loader: VTypeDoc['loader'];
-    createRenderer(camera: VTypeDoc['camera'], canvas?: HTMLCanvasElement, rendererOptions?: Partial<RendererOptions & VTypeDoc['rendererExtraOpts']>): VTypeDoc['renderer'];
 }

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

@@ -0,0 +1,24 @@
+import { IPositionable3d } from '../interfaces/i-positionable-3d';
+import { IEntity, Point3, Point4, TickOrder } from '../../base';
+import { Gg3dWorldTypeDocVPatch, VisualTypeDocRepo3D } from '../gg-3d-world';
+/**
+ * A positioned entity wrapping a camera component (`VTypeDoc['camera']`, e.g. the adapter-specific
+ * camera type an app's `TypedGg3dWorld` uses) - not attached to any renderer/canvas itself (pass
+ * `.camera` to `Gg3dWorld.addRenderer` for that), but addressable in the world/entity trees like
+ * any other entity: `world.addEntity`/`getEntityByName`, `IEntity.getChildEntityByName`,
+ * `removeEntity`.
+ * @template VTypeDoc - The visual type document repository (parametrize this the same way an
+ * app's world type is, e.g. `Camera3dEntity<ThreeVisualTypeDocRepo>`, so `.camera` comes back as
+ * the adapter-specific camera type rather than the unbound base `ICamera3dComponent`)
+ */
+export declare class Camera3dEntity<VTypeDoc extends VisualTypeDocRepo3D = VisualTypeDocRepo3D> extends IEntity<Point3, Point4, Gg3dWorldTypeDocVPatch<VTypeDoc>> implements IPositionable3d {
+    readonly camera: VTypeDoc['camera'];
+    readonly tickOrder = TickOrder.OBJECTS_BINDING;
+    private _position;
+    get position(): Point3;
+    set position(value: Point3);
+    private _rotation;
+    get rotation(): Point4;
+    set rotation(value: Point4);
+    constructor(camera: VTypeDoc['camera']);
+}

package/dist/3d/entities/camera-3d.entity.js

@@ -0,0 +1,35 @@
+import { IEntity, Pnt3, Qtrn, TickOrder } from '../../base';
+/**
+ * A positioned entity wrapping a camera component (`VTypeDoc['camera']`, e.g. the adapter-specific
+ * camera type an app's `TypedGg3dWorld` uses) - not attached to any renderer/canvas itself (pass
+ * `.camera` to `Gg3dWorld.addRenderer` for that), but addressable in the world/entity trees like
+ * any other entity: `world.addEntity`/`getEntityByName`, `IEntity.getChildEntityByName`,
+ * `removeEntity`.
+ * @template VTypeDoc - The visual type document repository (parametrize this the same way an
+ * app's world type is, e.g. `Camera3dEntity<ThreeVisualTypeDocRepo>`, so `.camera` comes back as
+ * the adapter-specific camera type rather than the unbound base `ICamera3dComponent`)
+ */
+export class Camera3dEntity extends IEntity {
+    get position() {
+        return this._position;
+    }
+    set position(value) {
+        this.camera.position = value;
+        this._position = value;
+    }
+    get rotation() {
+        return this._rotation;
+    }
+    set rotation(value) {
+        this.camera.rotation = value;
+        this._rotation = value;
+    }
+    constructor(camera) {
+        super();
+        this.camera = camera;
+        this.tickOrder = TickOrder.OBJECTS_BINDING;
+        this._position = Pnt3.O;
+        this._rotation = Qtrn.O;
+        this.addComponents(this.camera);
+    }
+}

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

@@ -2,9 +2,4 @@ import { IRendererEntity, Point3, Point4 } from '../../base';
 import { IPositionable3d } from '../interfaces/i-positionable-3d';
 import { VisualTypeDocRepo3D } from '../gg-3d-world';
 export declare class Renderer3dEntity<VTypeDoc extends VisualTypeDocRepo3D = VisualTypeDocRepo3D> extends IRendererEntity<Point3, Point4, VTypeDoc> implements IPositionable3d {
-    get position(): Point3;
-    set position(value: Point3);
-    get rotation(): Point4;
-    set rotation(value: Point4);
-    get camera(): VTypeDoc['camera'];
 }

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

@@ -1,18 +1,3 @@
 import { IRendererEntity } from '../../base';
 export class Renderer3dEntity extends IRendererEntity {
-    get position() {
-        return this.renderer.camera.position;
-    }
-    set position(value) {
-        this.renderer.camera.position = value;
-    }
-    get rotation() {
-        return this.renderer.camera.rotation;
-    }
-    set rotation(value) {
-        this.renderer.camera.rotation = value;
-    }
-    get camera() {
-        return this.renderer.camera;
-    }
 }

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

@@ -4,7 +4,7 @@ import { Entity3d } from './entities/entity-3d';
 import { BodyShape3DDescriptor } from './models/shapes';
 import { IVisualScene3dComponent } from './components/rendering/i-visual-scene-3d.component';
 import { Renderer3dEntity } from './entities/renderer-3d.entity';
-import { ICameraComponent } from './components/rendering/i-camera.component';
+import { ICamera3dComponent } from './components/rendering/i-camera-3d.component';
 import { IRenderer3dComponent } from './components/rendering/i-renderer-3d.component';
 import { IPhysicsWorld3dComponent } from './components/physics/i-physics-world-3d.component';
 import { DisplayObject3dOpts, IDisplayObject3dComponentFactory, IPhysicsBody3dComponentFactory } from './factories';
@@ -19,7 +19,7 @@ export type VisualTypeDocRepo3D = {
     displayObject: IDisplayObject3dComponent;
     renderer: IRenderer3dComponent;
     rendererExtraOpts: {};
-    camera: ICameraComponent;
+    camera: ICamera3dComponent;
     texture: unknown;
 };
 export type PhysicsTypeDocRepo3D = {

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

@@ -37,6 +37,79 @@ export class Gg3dWorld extends GgWorld {
     }
     registerConsoleCommands(ggstatic) {
         super.registerConsoleCommands(ggstatic);
+        ggstatic.registerConsoleCommand(this, 'set_position', (...args) => __awaiter(this, void 0, void 0, function* () {
+            const [name, x, y, z] = args;
+            if (!name) {
+                throw new Error('usage: set_position <name> <x> <y> <z>');
+            }
+            const entity = this.getEntityByName(name);
+            if (!('position' in entity)) {
+                throw new Error(`Entity "${name}" (${entity.constructor.name}) has no position`);
+            }
+            if ([x, y, z].some(v => v === undefined || isNaN(+v))) {
+                throw new Error('usage: set_position <name> <x> <y> <z>');
+            }
+            entity.position = { x: +x, y: +y, z: +z };
+            return JSON.stringify(entity.position);
+        }), 'args: [ string, float, float, float ]; Teleport a named entity to world-space coordinates. ' +
+            'Use "entities"/"entity <name>" to find entity names and their current position');
+        ggstatic.registerConsoleCommand(this, 'set_rotation', (...args) => __awaiter(this, void 0, void 0, function* () {
+            const [name, ...rest] = args;
+            if (!name) {
+                throw new Error('usage: set_rotation <name> <x> <y> <z> [w]');
+            }
+            const entity = this.getEntityByName(name);
+            if (!('rotation' in entity)) {
+                throw new Error(`Entity "${name}" (${entity.constructor.name}) has no rotation`);
+            }
+            const nums = rest.map(Number);
+            if (nums.length !== 3 && nums.length !== 4) {
+                throw new Error('usage: set_rotation <name> <x> <y> <z> (euler, radians) OR set_rotation <name> <x> <y> <z> <w> (quaternion)');
+            }
+            if (nums.some(Number.isNaN)) {
+                throw new Error('Wrong arguments');
+            }
+            const rotation = nums.length === 4
+                ? { x: nums[0], y: nums[1], z: nums[2], w: nums[3] }
+                : Qtrn.fromEuler({ x: nums[0], y: nums[1], z: nums[2] });
+            entity.rotation = rotation;
+            return JSON.stringify(entity.rotation);
+        }), 'args: [ string, float, float, float, float? ]; Rotate a named entity. 3 numbers are euler ' +
+            'angles in radians, 4 numbers are a raw quaternion (x y z w)');
+        ggstatic.registerConsoleCommand(this, 'spawn', (...args) => __awaiter(this, void 0, void 0, function* () {
+            const [shapeArg, x, y, z, dynamicArg] = args;
+            if ([x, y, z].some(v => v === undefined || isNaN(+v))) {
+                throw new Error('usage: spawn <BOX|SPHERE|CYLINDER|CONE|CAPSULE|PLANE> <x> <y> <z> [dynamic=0|1]');
+            }
+            const dynamic = dynamicArg === undefined ? true : dynamicArg === '1';
+            let shape;
+            switch ((shapeArg || '').toUpperCase()) {
+                case 'BOX':
+                    shape = { shape: 'BOX', dimensions: { x: 1, y: 1, z: 1 } };
+                    break;
+                case 'SPHERE':
+                    shape = { shape: 'SPHERE', radius: 0.5 };
+                    break;
+                case 'CYLINDER':
+                    shape = { shape: 'CYLINDER', radius: 0.5, height: 1 };
+                    break;
+                case 'CONE':
+                    shape = { shape: 'CONE', radius: 0.5, height: 1 };
+                    break;
+                case 'CAPSULE':
+                    shape = { shape: 'CAPSULE', radius: 0.5, centersDistance: 1 };
+                    break;
+                case 'PLANE':
+                    shape = { shape: 'PLANE' };
+                    break;
+                default:
+                    throw new Error(`Unknown shape "${shapeArg}". Use BOX|SPHERE|CYLINDER|CONE|CAPSULE|PLANE`);
+            }
+            const entity = this.addPrimitiveRigidBody({ shape, body: { dynamic } }, { x: +x, y: +y, z: +z });
+            return `spawned "${entity.name}" (${shape.shape}) at ${JSON.stringify(entity.position)}`;
+        }), 'args: [ BOX|SPHERE|CYLINDER|CONE|CAPSULE|PLANE, float, float, float, 0|1? ]; Spawn a ' +
+            'default-sized primitive rigid body at world-space coordinates, for probing physics. ' +
+            'dynamic (last arg) defaults to 1 (falls under gravity); pass 0 for a static prop');
         if (this.physicsWorld) {
             ggstatic.registerConsoleCommand(this, 'gravity', (...args) => __awaiter(this, void 0, void 0, function* () {
                 if (args.length == 1) {

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

@@ -3,10 +3,11 @@ export * from './components/physics/i-rigid-body-3d.component';
 export * from './components/physics/i-trigger-3d.component';
 export * from './components/physics/i-physics-world-3d.component';
 export * from './components/rendering/i-display-object-3d.component';
-export * from './components/rendering/i-camera.component';
+export * from './components/rendering/i-camera-3d.component';
 export * from './components/rendering/i-renderer-3d.component';
 export * from './components/rendering/i-visual-scene-3d.component';
 export * from './entities/gg-car/gg-car.entity';
+export * from './entities/camera-3d.entity';
 export * from './entities/controllers/animators/camera-3d.animator';
 export * from './entities/controllers/animators/entity-3d-positioning.animator';
 export * from './entities/entity-3d';
@@ -28,3 +29,4 @@ export * from './loaders';
 export * from './factories';
 export * from './gg-3d-world';
 export * from './loader';
+export * from './level-loader';

package/dist/3d/index.js

@@ -3,10 +3,11 @@ export * from './components/physics/i-rigid-body-3d.component';
 export * from './components/physics/i-trigger-3d.component';
 export * from './components/physics/i-physics-world-3d.component';
 export * from './components/rendering/i-display-object-3d.component';
-export * from './components/rendering/i-camera.component';
+export * from './components/rendering/i-camera-3d.component';
 export * from './components/rendering/i-renderer-3d.component';
 export * from './components/rendering/i-visual-scene-3d.component';
 export * from './entities/gg-car/gg-car.entity';
+export * from './entities/camera-3d.entity';
 export * from './entities/controllers/animators/camera-3d.animator';
 export * from './entities/controllers/animators/entity-3d-positioning.animator';
 export * from './entities/entity-3d';
@@ -28,3 +29,4 @@ export * from './loaders';
 export * from './factories';
 export * from './gg-3d-world';
 export * from './loader';
+export * from './level-loader';