@gg-web-engine/core 0.0.57 → 0.0.59

package/dist/3d/loader.js

@@ -8,7 +8,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { Entity3d } from './entities/entity-3d';
-import { Pnt3, Qtrn } from '../base';
+import { GroupEntity, Pnt3, Qtrn } from '../base';
+import { Gg3dLevelLoader } from './level-loader';
 export var CachingStrategy;
 (function (CachingStrategy) {
     CachingStrategy[CachingStrategy["Nothing"] = 0] = "Nothing";
@@ -28,11 +29,38 @@ const cloneLoadResourcesResult = (loadResult) => ({
         body: body && body.clone(),
     })),
 });
-export class Gg3dLoader {
+/**
+ * Flatten a `LoadResultWithProps` (and its recursively-nested `props`) into one flat list of every
+ * `Entity3d` it produced, for the built-in `"Glb"` level entity class to parent under a single
+ * `GroupEntity`.
+ */
+function flattenGlbEntities(result) {
+    var _a;
+    return [...result.entities, ...((_a = result.props) !== null && _a !== void 0 ? _a : []).flatMap(prop => flattenGlbEntities(prop))];
+}
+/**
+ * Full 3D loader exposed as `Gg3dWorld.loader`: GLB+meta asset loading (`loadGgGlb` and friends)
+ * layered on top of `Gg3dLevelLoader`, so `registerClass`/`loadLevel`/`loadLevelFromUrl`/
+ * `getEntityByName` are all available directly on `world.loader`. Also registers a `"Glb"` level
+ * entity class (see `Glb3DSettings`) so a level JSON can place a GLB model declaratively, the same
+ * way it places primitives/triggers/cameras.
+ * @template TypeDoc - The type document repository
+ */
+export class Gg3dLoader extends Gg3dLevelLoader {
     constructor(world) {
-        this.world = world;
+        super(world);
         this.filesCache = new Map();
         this.loadResultCache = new Map();
+        this.registerClass('Glb', (w, settings) => __awaiter(this, void 0, void 0, function* () {
+            if (!settings.path) {
+                throw new Error('Path is required for Glb class');
+            }
+            const { path, position, rotation, cachingStrategy, loadProps, propsPath } = settings;
+            const result = yield this.loadGgGlb(path, Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, (position !== undefined ? { position } : {})), (rotation !== undefined ? { rotation } : {})), (cachingStrategy !== undefined ? { cachingStrategy } : {})), (loadProps !== undefined ? { loadProps } : {})), (propsPath !== undefined ? { propsPath } : {})));
+            const group = new GroupEntity();
+            group.addChildren(...flattenGlbEntities(result));
+            return group;
+        }));
     }
     loadGgGlbFiles(path_1) {
         return __awaiter(this, arguments, void 0, function* (path, useCache = false) {
@@ -57,6 +85,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 +96,21 @@ export class Gg3dLoader {
                 throw new Error('GLB not found');
             }
             const [object, bodies] = yield Promise.all([
-                this.world.visualScene.loader.loadFromGgGlb(glb, meta),
-                this.world.physicsWorld.loader.loadFromGgGlb(glb, meta),
+                (_a = this.world.visualScene) === null || _a === void 0 ? void 0 : _a.loader.loadFromGgGlb(glb, meta),
+                (_b = this.world.physicsWorld) === null || _b === void 0 ? void 0 : _b.loader.loadFromGgGlb(glb, meta),
             ]);
             const result = { resources: [], meta };
             if (!object) {
                 return result;
             }
-            if (bodies.length == 0) {
+            if ((bodies === null || bodies === void 0 ? void 0 : bodies.length) == 0) {
                 result.resources.push({ object3D: object, body: null });
             }
-            else if (bodies.length == 1) {
+            else if ((bodies === null || bodies === void 0 ? void 0 : bodies.length) == 1) {
                 result.resources.push({ object3D: object, body: bodies[0] });
             }
             else {
-                for (const body of bodies) {
+                for (const body of bodies || []) {
                     result.resources.push({ object3D: object.popChild(body.name), body });
                 }
                 if (!object.isEmpty()) {

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

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

package/dist/base/blueprint/blueprint-node.d.ts

@@ -0,0 +1,75 @@
+import { Observable } from 'rxjs';
+import { GgWorld, GgWorldTypeDocRepo } from '../gg-world';
+/**
+ * Whether a {@link BlueprintNode} pin carries an execution pulse ("do this now", no meaningful
+ * payload - e.g. Unreal's white exec pins) or a data value ("here's a value", not itself a
+ * trigger - e.g. Unreal's colored data pins). Purely descriptive for now (introspection/future
+ * editor tooling) - {@link BlueprintNode.trigger} treats every input pin the same way at runtime,
+ * since a node is free to both react to and read a value from the same pin (see
+ * {@link RemoveEntityBlueprintNode}, whose single `"entity"` pin is a data pin that also triggers
+ * the node when fed a value - the same way an Unreal event node's payload pins double as the
+ * thing that fires the node).
+ */
+export type BlueprintPinKind = 'exec' | 'data';
+/**
+ * Declares one named pin a {@link BlueprintNode} exposes - either an input (fed a value via
+ * {@link BlueprintNode.trigger}) or an output (fired via {@link BlueprintNode.output}).
+ */
+export interface BlueprintPinDefinition {
+    name: string;
+    kind: BlueprintPinKind;
+}
+/**
+ * One node in a {@link Blueprint} graph - the engine's analogue of a single Unreal Blueprint graph
+ * node: a small unit of behavior with named input pins that trigger it, named output pins it can
+ * fire in response, and a `settings` bag of static (non-pin) configuration baked in from its
+ * {@link BlueprintNodeJson} (e.g. `RemoveEntity`'s `dispose` flag). Register a concrete subclass's
+ * factory against a type alias via `LevelLoader.registerBlueprintNode` so `Blueprint` can
+ * instantiate it from JSON, the same way `LevelLoader.registerClass` works for entity classes.
+ * @template D - The position type
+ * @template R - The rotation type
+ * @template TypeDoc - The type document repository
+ */
+export declare abstract class BlueprintNode<D = any, R = any, TypeDoc extends GgWorldTypeDocRepo<D, R> = GgWorldTypeDocRepo<D, R>> {
+    protected readonly world: GgWorld<D, R, TypeDoc>;
+    protected readonly settings: Record<string, any>;
+    /**
+     * This node's input pins - see {@link trigger} for how they're fed.
+     */
+    abstract readonly inputs: readonly BlueprintPinDefinition[];
+    /**
+     * This node's output pins - see {@link output} for how to observe them.
+     */
+    abstract readonly outputs: readonly BlueprintPinDefinition[];
+    private readonly outputSubjects;
+    constructor(world: GgWorld<D, R, TypeDoc>, settings: Record<string, any>);
+    private subjectFor;
+    /**
+     * Observe one of this node's output pins firing - what a {@link BlueprintLinkJson} subscribes
+     * to in order to feed a downstream node's input, or what an embedding `Blueprint`'s own
+     * `outputs` entry bubbles up to whatever triggered the blueprint.
+     * @param name - The output pin's name, per {@link outputs}
+     */
+    output(name: string): Observable<unknown>;
+    /**
+     * Fire one of this node's output pins - call from within {@link trigger} once the node has done
+     * whatever that output represents. A no-op if nothing is subscribed.
+     * @param name - The output pin's name, per {@link outputs}
+     * @param value - Payload for a data output pin; omit for a bare exec pulse
+     */
+    protected emit(name: string, value?: unknown): void;
+    /**
+     * Feed a value/pulse into one of this node's input pins (per {@link inputs}), running whatever
+     * behavior that pin represents. Called by `Blueprint` both for external triggers (via its own
+     * `inputs` aliasing) and for links from another node's output pin.
+     * @param inputName - The input pin's name, per {@link inputs}
+     * @param value - Payload carried in on a data pin, if any
+     */
+    abstract trigger(inputName: string, value?: unknown): void;
+    /**
+     * Release anything this node set up outside of its output subjects (timers, subscriptions,
+     * etc). Default no-op - override when a node needs it. `Blueprint.dispose` calls this on every
+     * node in its graph.
+     */
+    dispose(): void;
+}

package/dist/base/blueprint/blueprint-node.js

@@ -0,0 +1,51 @@
+import { Subject } from 'rxjs';
+/**
+ * One node in a {@link Blueprint} graph - the engine's analogue of a single Unreal Blueprint graph
+ * node: a small unit of behavior with named input pins that trigger it, named output pins it can
+ * fire in response, and a `settings` bag of static (non-pin) configuration baked in from its
+ * {@link BlueprintNodeJson} (e.g. `RemoveEntity`'s `dispose` flag). Register a concrete subclass's
+ * factory against a type alias via `LevelLoader.registerBlueprintNode` so `Blueprint` can
+ * instantiate it from JSON, the same way `LevelLoader.registerClass` works for entity classes.
+ * @template D - The position type
+ * @template R - The rotation type
+ * @template TypeDoc - The type document repository
+ */
+export class BlueprintNode {
+    constructor(world, settings) {
+        this.world = world;
+        this.settings = settings;
+        this.outputSubjects = new Map();
+    }
+    subjectFor(name) {
+        let subject = this.outputSubjects.get(name);
+        if (!subject) {
+            subject = new Subject();
+            this.outputSubjects.set(name, subject);
+        }
+        return subject;
+    }
+    /**
+     * Observe one of this node's output pins firing - what a {@link BlueprintLinkJson} subscribes
+     * to in order to feed a downstream node's input, or what an embedding `Blueprint`'s own
+     * `outputs` entry bubbles up to whatever triggered the blueprint.
+     * @param name - The output pin's name, per {@link outputs}
+     */
+    output(name) {
+        return this.subjectFor(name).asObservable();
+    }
+    /**
+     * Fire one of this node's output pins - call from within {@link trigger} once the node has done
+     * whatever that output represents. A no-op if nothing is subscribed.
+     * @param name - The output pin's name, per {@link outputs}
+     * @param value - Payload for a data output pin; omit for a bare exec pulse
+     */
+    emit(name, value) {
+        this.subjectFor(name).next(value);
+    }
+    /**
+     * Release anything this node set up outside of its output subjects (timers, subscriptions,
+     * etc). Default no-op - override when a node needs it. `Blueprint.dispose` calls this on every
+     * node in its graph.
+     */
+    dispose() { }
+}

package/dist/base/blueprint/blueprint.d.ts

@@ -0,0 +1,123 @@
+import { Observable } from 'rxjs';
+import { GgWorld, GgWorldTypeDocRepo } from '../gg-world';
+import { BlueprintNode } from './blueprint-node';
+/**
+ * A function that builds a {@link BlueprintNode} instance from its baked-in settings. Registered
+ * against a node type alias via `LevelLoader.registerBlueprintNode`, the same way
+ * {@link EntityGenerator} is registered against an entity class alias via `registerClass`.
+ * @template D - The position type
+ * @template R - The rotation type
+ * @template TypeDoc - The type document repository
+ */
+export type BlueprintNodeFactory<D, R, TypeDoc extends GgWorldTypeDocRepo<D, R>> = (world: GgWorld<D, R, TypeDoc>, settings: Record<string, any>) => BlueprintNode<D, R, TypeDoc>;
+/**
+ * A reference to one named pin on one node within a {@link BlueprintJson} graph - either end of a
+ * {@link BlueprintLinkJson}, or what a graph's own `inputs`/`outputs` entry aliases.
+ */
+export interface BlueprintPinRef {
+    /**
+     * `id` of the node within the same `BlueprintJson.nodes` array
+     */
+    node: string;
+    /**
+     * Pin name on that node, per its `BlueprintNode.inputs`/`outputs`
+     */
+    pin: string;
+}
+/**
+ * JSON description of a single node instance within a {@link BlueprintJson} graph.
+ */
+export interface BlueprintNodeJson {
+    /**
+     * Identifier for this node instance, unique within the same graph - referenced by
+     * `BlueprintLinkJson`/`BlueprintJson.inputs`/`BlueprintJson.outputs`.
+     */
+    id: string;
+    /**
+     * Node type alias, matching a type registered via `LevelLoader.registerBlueprintNode` (e.g. the
+     * built-in `"RemoveEntity"`).
+     */
+    type: string;
+    /**
+     * Static settings baked into the node (e.g. `RemoveEntity`'s `dispose` flag) - not wired at
+     * runtime, unlike a pin.
+     */
+    settings?: Record<string, any>;
+}
+/**
+ * JSON description of one wire connecting one node's output pin to another node's input pin
+ * within the same {@link BlueprintJson} graph. Whenever `from` fires, `to` is triggered with
+ * whatever value (if any) `from` fired with.
+ */
+export interface BlueprintLinkJson {
+    from: BlueprintPinRef;
+    to: BlueprintPinRef;
+}
+/**
+ * A blueprint graph, serializable as a single JSON document - the engine's analogue of an Unreal
+ * Blueprint event graph. `nodes` are node instances (see {@link BlueprintNodeJson}), `links` wire
+ * one node's output pin to another's input pin, and `inputs`/`outputs` expose named entry/exit
+ * points at the graph's own boundary - each aliasing one node's pin - so embedding code (or, in
+ * the future, another blueprint nesting this one) doesn't need to know internal node ids. A level
+ * JSON references a `BlueprintJson` by name via its top-level `blueprints` map and an entity's
+ * `events` mapping - see `gg-engine-level-json`.
+ */
+export interface BlueprintJson {
+    /**
+     * Node instances in this graph
+     */
+    nodes: BlueprintNodeJson[];
+    /**
+     * Wires wiring one node's output pin to another node's input pin
+     */
+    links?: BlueprintLinkJson[];
+    /**
+     * Named entry points into this graph, each aliasing one node's input pin - e.g.
+     * `{ "in": { "node": "n1", "pin": "entity" } }` lets external code trigger `"n1"`'s `"entity"`
+     * pin by calling `blueprint.trigger("in", value)` without knowing the internal node id. A
+     * blueprint bound to a level JSON entity event is always triggered through the entry named
+     * `"in"` - see `gg-engine-level-json`.
+     */
+    inputs?: Record<string, BlueprintPinRef>;
+    /**
+     * Named exit points out of this graph, each aliasing one node's output pin - for a future
+     * blueprint nested inside a larger graph to bubble one of its own nodes' outputs back out.
+     */
+    outputs?: Record<string, BlueprintPinRef>;
+}
+/**
+ * Runtime instance of a {@link BlueprintJson} graph: builds one {@link BlueprintNode} per
+ * `nodes` entry (via the node type registry passed in), wires every `links` entry as a live
+ * subscription from the source node's output pin to the target node's input pin, and exposes the
+ * graph's own `inputs`/`outputs` boundary. Each binding of a blueprint (e.g. one level JSON entity
+ * event) gets its own `Blueprint` instance - and therefore its own node instances - even when
+ * multiple bindings reference the same `BlueprintJson` by name, so per-node state (a future timer
+ * node's countdown, etc) is never accidentally shared between unrelated bindings.
+ * @template D - The position type
+ * @template R - The rotation type
+ * @template TypeDoc - The type document repository
+ */
+export declare class Blueprint<D = any, R = any, TypeDoc extends GgWorldTypeDocRepo<D, R> = GgWorldTypeDocRepo<D, R>> {
+    private readonly json;
+    private readonly nodes;
+    private readonly linkSubscriptions;
+    constructor(world: GgWorld<D, R, TypeDoc>, json: BlueprintJson, registry: ReadonlyMap<string, BlueprintNodeFactory<D, R, TypeDoc>>);
+    /**
+     * Feed a value/pulse into one of this graph's named entry points (per `BlueprintJson.inputs`).
+     * A no-op (with a console warning) if no such input, or the node it aliases failed to build.
+     * @param inputName - Entry point name, per `BlueprintJson.inputs`
+     * @param value - Payload to hand to the aliased node's input pin, if any
+     */
+    trigger(inputName: string, value?: unknown): void;
+    /**
+     * Observe one of this graph's named exit points (per `BlueprintJson.outputs`) firing.
+     * @param outputName - Exit point name, per `BlueprintJson.outputs`
+     * @throws if no such output is declared, or the node it aliases failed to build
+     */
+    output(outputName: string): Observable<unknown>;
+    /**
+     * Unwire every link and dispose every node in this graph. Idempotent-ish - safe to call once
+     * per `Blueprint` instance, same lifetime contract as `IEntity.dispose`.
+     */
+    dispose(): void;
+}

package/dist/base/blueprint/blueprint.js

@@ -0,0 +1,86 @@
+/**
+ * Runtime instance of a {@link BlueprintJson} graph: builds one {@link BlueprintNode} per
+ * `nodes` entry (via the node type registry passed in), wires every `links` entry as a live
+ * subscription from the source node's output pin to the target node's input pin, and exposes the
+ * graph's own `inputs`/`outputs` boundary. Each binding of a blueprint (e.g. one level JSON entity
+ * event) gets its own `Blueprint` instance - and therefore its own node instances - even when
+ * multiple bindings reference the same `BlueprintJson` by name, so per-node state (a future timer
+ * node's countdown, etc) is never accidentally shared between unrelated bindings.
+ * @template D - The position type
+ * @template R - The rotation type
+ * @template TypeDoc - The type document repository
+ */
+export class Blueprint {
+    constructor(world, json, registry) {
+        var _a, _b;
+        this.json = json;
+        this.nodes = new Map();
+        this.linkSubscriptions = [];
+        for (const nodeJson of json.nodes) {
+            const factory = registry.get(nodeJson.type);
+            if (!factory) {
+                console.warn(`No blueprint node type registered for "${nodeJson.type}" - skipping node "${nodeJson.id}"`);
+                continue;
+            }
+            this.nodes.set(nodeJson.id, factory(world, (_a = nodeJson.settings) !== null && _a !== void 0 ? _a : {}));
+        }
+        for (const link of (_b = json.links) !== null && _b !== void 0 ? _b : []) {
+            const source = this.nodes.get(link.from.node);
+            const target = this.nodes.get(link.to.node);
+            if (!source || !target) {
+                console.warn(`Blueprint link references an unknown node ("${link.from.node}" -> "${link.to.node}") - skipping`);
+                continue;
+            }
+            this.linkSubscriptions.push(source.output(link.from.pin).subscribe(value => target.trigger(link.to.pin, value)));
+        }
+    }
+    /**
+     * Feed a value/pulse into one of this graph's named entry points (per `BlueprintJson.inputs`).
+     * A no-op (with a console warning) if no such input, or the node it aliases failed to build.
+     * @param inputName - Entry point name, per `BlueprintJson.inputs`
+     * @param value - Payload to hand to the aliased node's input pin, if any
+     */
+    trigger(inputName, value) {
+        var _a;
+        const ref = (_a = this.json.inputs) === null || _a === void 0 ? void 0 : _a[inputName];
+        if (!ref) {
+            console.warn(`Blueprint has no declared input named "${inputName}" - ignoring trigger`);
+            return;
+        }
+        const node = this.nodes.get(ref.node);
+        if (!node) {
+            return;
+        }
+        node.trigger(ref.pin, value);
+    }
+    /**
+     * Observe one of this graph's named exit points (per `BlueprintJson.outputs`) firing.
+     * @param outputName - Exit point name, per `BlueprintJson.outputs`
+     * @throws if no such output is declared, or the node it aliases failed to build
+     */
+    output(outputName) {
+        var _a;
+        const ref = (_a = this.json.outputs) === null || _a === void 0 ? void 0 : _a[outputName];
+        if (!ref) {
+            throw new Error(`Blueprint has no declared output named "${outputName}"`);
+        }
+        const node = this.nodes.get(ref.node);
+        if (!node) {
+            throw new Error(`Blueprint output "${outputName}" references unknown node "${ref.node}"`);
+        }
+        return node.output(ref.pin);
+    }
+    /**
+     * Unwire every link and dispose every node in this graph. Idempotent-ish - safe to call once
+     * per `Blueprint` instance, same lifetime contract as `IEntity.dispose`.
+     */
+    dispose() {
+        for (const sub of this.linkSubscriptions) {
+            sub.unsubscribe();
+        }
+        this.linkSubscriptions.splice(0, this.linkSubscriptions.length);
+        for (const node of this.nodes.values()) {
+            node.dispose();
+        }
+    }
+}

package/dist/base/blueprint/nodes/remove-entity.node.d.ts

@@ -0,0 +1,26 @@
+import { GgWorldTypeDocRepo } from '../../gg-world';
+import { BlueprintNode, BlueprintPinDefinition } from '../blueprint-node';
+/**
+ * Settings for the built-in `"RemoveEntity"` blueprint node - baked in from its
+ * {@link BlueprintNodeJson.settings}, not wired at runtime.
+ */
+export interface RemoveEntityNodeSettings {
+    /**
+     * Whether to dispose the entity (release its components/children) as well as remove it from
+     * the world, same as the `dispose` argument of `GgWorld.removeEntity`. Defaults to `false`.
+     */
+    dispose?: boolean;
+}
+/**
+ * Built-in blueprint node: removes an entity from the world - the blueprint analogue of calling
+ * `world.removeEntity(entity, dispose)` directly. Has one input pin, `"entity"` (a data pin that
+ * also acts as this node's trigger - feeding it a value runs the node, same as an Unreal event
+ * node's payload pin doubling as its exec pulse) and no output pins. Whether the removal also
+ * disposes the entity is controlled by the static `dispose` setting, not a pin - see
+ * {@link RemoveEntityNodeSettings}.
+ */
+export declare class RemoveEntityBlueprintNode<D = any, R = any, TypeDoc extends GgWorldTypeDocRepo<D, R> = GgWorldTypeDocRepo<D, R>> extends BlueprintNode<D, R, TypeDoc> {
+    readonly inputs: readonly BlueprintPinDefinition[];
+    readonly outputs: readonly BlueprintPinDefinition[];
+    trigger(inputName: string, value?: unknown): void;
+}

package/dist/base/blueprint/nodes/remove-entity.node.js

@@ -0,0 +1,29 @@
+import { IEntity } from '../../entities/i-entity';
+import { BlueprintNode } from '../blueprint-node';
+/**
+ * Built-in blueprint node: removes an entity from the world - the blueprint analogue of calling
+ * `world.removeEntity(entity, dispose)` directly. Has one input pin, `"entity"` (a data pin that
+ * also acts as this node's trigger - feeding it a value runs the node, same as an Unreal event
+ * node's payload pin doubling as its exec pulse) and no output pins. Whether the removal also
+ * disposes the entity is controlled by the static `dispose` setting, not a pin - see
+ * {@link RemoveEntityNodeSettings}.
+ */
+export class RemoveEntityBlueprintNode extends BlueprintNode {
+    constructor() {
+        super(...arguments);
+        this.inputs = [{ name: 'entity', kind: 'data' }];
+        this.outputs = [];
+    }
+    trigger(inputName, value) {
+        var _a;
+        if (inputName !== 'entity') {
+            return;
+        }
+        if (!(value instanceof IEntity)) {
+            console.warn('RemoveEntity blueprint node triggered without a valid entity reference - ignoring');
+            return;
+        }
+        const settings = this.settings;
+        this.world.removeEntity(value, (_a = settings.dispose) !== null && _a !== void 0 ? _a : false);
+    }
+}

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

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

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

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

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

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

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

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

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

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

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

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