@babylonjs/core 6.19.0 → 6.20.0

package/FlowGraph/Blocks/Execution/flowGraphTimerBlock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flowGraphTimerBlock.js","sourceRoot":"","sources":["../../../../../../dev/core/src/FlowGraph/Blocks/Execution/flowGraphTimerBlock.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEpD,OAAO,EAAE,4BAA4B,EAAE,MAAM,oCAAoC,CAAC;AAClF,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC1D,OAAO,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAM5C;;;;;GAKG;AACH,MAAM,OAAO,mBAAoB,SAAQ,4BAA4B;IAWjE,YAAY,UAA2C;QACnD,KAAK,EAAE,CAAC;QAER,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,kBAAkB,CAAC,SAAS,EAAE,cAAc,CAAC,CAAC;QAClE,IAAI,CAAA,UAAU,aAAV,UAAU,uBAAV,UAAU,CAAE,OAAO,MAAK,SAAS,EAAE;YACnC,IAAI,CAAC,OAAO,CAAC,KAAK,GAAG,UAAU,CAAC,OAAO,CAAC;SAC3C;QACD,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,qBAAqB,CAAC,aAAa,CAAC,CAAC;IACjE,CAAC;IAEM,oBAAoB,CAAC,OAAyB;QACjD,MAAM,cAAc,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QAEtD,IAAI,cAAc,KAAK,SAAS,IAAI,cAAc,IAAI,CAAC,EAAE;YACrD,MAAM,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC,IAAI,EAAE,eAAe,CAAC,IAAI,EAAE,CAAC;YAC1E,MAAM,KAAK,GAAG,OAAO,CAAC,cAAc,CAAC,KAAK,CAAC;YAC3C,MAAM,KAAK,GAAkB,IAAI,aAAa,CAAC;gBAC3C,OAAO,EAAE,cAAc;gBACvB,iBAAiB,EAAE,KAAK,CAAC,wBAAwB;gBACjD,OAAO,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;aAC/C,CAAC,CAAC;YACH,KAAK,CAAC,KAAK,EAAE,CAAC;YAEd,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YACnB,OAAO,CAAC,qBAAqB,CAAC,IAAI,EAAE,eAAe,EAAE,MAAM,CAAC,CAAC;SAChE;IACL,CAAC;IAED;;OAEG;IACI,QAAQ,CAAC,OAAyB;QACrC,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC;QACjC,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;IACzC,CAAC;IAEO,QAAQ,CAAC,KAAoB,EAAE,OAAyB;QAC5D,MAAM,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC,IAAI,EAAE,eAAe,CAAC,IAAI,EAAE,CAAC;QAC1E,MAAM,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QACpC,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE;YACd,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;SAC3B;aAAM;YACH,KAAK,CAAC,IAAI,CAAC,+EAA+E,CAAC,CAAC;SAC/F;QACD,OAAO,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC;QAClC,IAAI,CAAC,WAAW,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;IAC9C,CAAC;IAEM,mBAAmB,CAAC,OAAyB;QAChD,MAAM,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC,IAAI,EAAE,eAAe,CAAC,IAAI,EAAE,CAAC;QAC1E,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE;YACxB,KAAK,CAAC,OAAO,EAAE,CAAC;SACnB;QACD,OAAO,CAAC,wBAAwB,CAAC,IAAI,EAAE,eAAe,CAAC,CAAC;IAC5D,CAAC;CACJ","sourcesContent":["import type { FlowGraphDataConnection } from \"../../flowGraphDataConnection\";\r\nimport type { FlowGraphSignalConnection } from \"../../flowGraphSignalConnection\";\r\nimport { AdvancedTimer } from \"../../../Misc/timer\";\r\nimport type { FlowGraphContext } from \"../../flowGraphContext\";\r\nimport { FlowGraphAsyncExecutionBlock } from \"../../flowGraphAsyncExecutionBlock\";\r\nimport { RichTypeNumber } from \"../../flowGraphRichTypes\";\r\nimport { Tools } from \"../../../Misc/tools\";\r\n\r\nexport interface IFlowGraphTimerBlockParameters {\r\n    timeout?: number;\r\n}\r\n\r\n/**\r\n * @experimental\r\n * question: is this doc understandable enough? accepting suggestions\r\n * Block that provides two different output flows. One is started immediately once the block is executed,\r\n * and the other is executed after a set time. The timer for this block runs based on the scene's render loop.\r\n */\r\nexport class FlowGraphTimerBlock extends FlowGraphAsyncExecutionBlock {\r\n    /**\r\n     * Input connection: The timeout of the timer.\r\n     */\r\n    public readonly timeout: FlowGraphDataConnection<number>;\r\n    /**\r\n     * Output connection: The signal that is activated when the timer is done.\r\n     * This signal is activated asynchronically.\r\n     */\r\n    public readonly onTimerDone: FlowGraphSignalConnection;\r\n\r\n    constructor(parameters?: IFlowGraphTimerBlockParameters) {\r\n        super();\r\n\r\n        this.timeout = this._registerDataInput(\"timeout\", RichTypeNumber);\r\n        if (parameters?.timeout !== undefined) {\r\n            this.timeout.value = parameters.timeout;\r\n        }\r\n        this.onTimerDone = this._registerSignalOutput(\"onTimerDone\");\r\n    }\r\n\r\n    public _preparePendingTasks(context: FlowGraphContext): void {\r\n        const currentTimeout = this.timeout.getValue(context);\r\n\r\n        if (currentTimeout !== undefined && currentTimeout >= 0) {\r\n            const timers = context._getExecutionVariable(this, \"runningTimers\") || [];\r\n            const scene = context.graphVariables.scene;\r\n            const timer: AdvancedTimer = new AdvancedTimer({\r\n                timeout: currentTimeout,\r\n                contextObservable: scene.onBeforeRenderObservable,\r\n                onEnded: () => this._onEnded(timer, context),\r\n            });\r\n            timer.start();\r\n\r\n            timers.push(timer);\r\n            context._setExecutionVariable(this, \"runningTimers\", timers);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    public _execute(context: FlowGraphContext) {\r\n        this._startPendingTasks(context);\r\n        this.onDone._activateSignal(context);\r\n    }\r\n\r\n    private _onEnded(timer: AdvancedTimer, context: FlowGraphContext) {\r\n        const timers = context._getExecutionVariable(this, \"runningTimers\") || [];\r\n        const index = timers.indexOf(timer);\r\n        if (index !== -1) {\r\n            timers.splice(index, 1);\r\n        } else {\r\n            Tools.Warn(\"FlowGraphTimerBlock: Timer ended but was not found in the running timers list\");\r\n        }\r\n        context._removePendingBlock(this);\r\n        this.onTimerDone._activateSignal(context);\r\n    }\r\n\r\n    public _cancelPendingTasks(context: FlowGraphContext): void {\r\n        const timers = context._getExecutionVariable(this, \"runningTimers\") || [];\r\n        for (const timer of timers) {\r\n            timer.dispose();\r\n        }\r\n        context._deleteExecutionVariable(this, \"runningTimers\");\r\n    }\r\n}\r\n"]}

package/FlowGraph/Blocks/Execution/index.d.ts

@@ -1,2 +1,9 @@
 export * from "./flowGraphForLoopBlock";
 export * from "./flowGraphLogBlock";
+export * from "./flowGraphConditionalBlock";
+export * from "./flowGraphPlayAnimationBlock";
+export * from "./flowGraphSetVariableBlock";
+export * from "./flowGraphSetPropertyBlock";
+export * from "./flowGraphTimerBlock";
+export * from "./flowGraphSendCustomEventBlock";
+export * from "./flowGraphStopAnimationBlock";

package/FlowGraph/Blocks/Execution/index.js

@@ -1,3 +1,10 @@
 export * from "./flowGraphForLoopBlock.js";
 export * from "./flowGraphLogBlock.js";
+export * from "./flowGraphConditionalBlock.js";
+export * from "./flowGraphPlayAnimationBlock.js";
+export * from "./flowGraphSetVariableBlock.js";
+export * from "./flowGraphSetPropertyBlock.js";
+export * from "./flowGraphTimerBlock.js";
+export * from "./flowGraphSendCustomEventBlock.js";
+export * from "./flowGraphStopAnimationBlock.js";
 //# sourceMappingURL=index.js.map

package/FlowGraph/Blocks/Execution/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../dev/core/src/FlowGraph/Blocks/Execution/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,qBAAqB,CAAC","sourcesContent":["export * from \"./flowGraphForLoopBlock\";\r\nexport * from \"./flowGraphLogBlock\";\r\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../dev/core/src/FlowGraph/Blocks/Execution/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,qBAAqB,CAAC;AACpC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,uBAAuB,CAAC;AACtC,cAAc,iCAAiC,CAAC;AAChD,cAAc,+BAA+B,CAAC","sourcesContent":["export * from \"./flowGraphForLoopBlock\";\r\nexport * from \"./flowGraphLogBlock\";\r\nexport * from \"./flowGraphConditionalBlock\";\r\nexport * from \"./flowGraphPlayAnimationBlock\";\r\nexport * from \"./flowGraphSetVariableBlock\";\r\nexport * from \"./flowGraphSetPropertyBlock\";\r\nexport * from \"./flowGraphTimerBlock\";\r\nexport * from \"./flowGraphSendCustomEventBlock\";\r\nexport * from \"./flowGraphStopAnimationBlock\";\r\n"]}

package/FlowGraph/flowGraph.d.ts

@@ -1,5 +1,22 @@
 import type { Scene } from "../scene";
-import type { FlowGraphBlock } from "./flowGraphBlock";
+import type { FlowGraphEventBlock } from "./flowGraphEventBlock";
+import { FlowGraphVariableDefinitions } from "./flowGraphVariableDefinitions";
+import type { FlowGraphContext } from "./flowGraphContext";
+import type { FlowGraphEventCoordinator } from "./flowGraphEventCoordinator";
+/**
+ * @experimental
+ * Parameters used to create a flow graph.
+ */
+export interface FlowGraphParams {
+    /**
+     * The scene that the flow graph belongs to.
+     */
+    scene: Scene;
+    /**
+     * The event coordinator used by the flow graph.
+     */
+    eventCoordinator: FlowGraphEventCoordinator;
+}
 /**
  * @experimental
  * Class used to represent a flow graph.
@@ -8,27 +25,40 @@ import type { FlowGraphBlock } from "./flowGraphBlock";
  * The graph can then be started, which will init and start all of its event blocks.
  */
 export declare class FlowGraph {
-    private _scene;
-    private _blocks;
+    /**
+     * The variables defined for this graph
+     */
+    variableDefinitions: FlowGraphVariableDefinitions;
+    private _eventBlocks;
     private _sceneDisposeObserver;
-    constructor(_scene: Scene);
     /**
      * @internal
-     * @param block
      */
-    _addBlock(block: FlowGraphBlock): void;
+    readonly _scene: Scene;
+    private _eventCoordinator;
+    private _executionContexts;
+    /**
+     * Construct a Flow Graph
+     * @param params construction parameters. currently only the scene
+     */
+    constructor(params: FlowGraphParams);
+    /**
+     * Create a context. A context represents one self contained execution for the graph, with its own variables.
+     * @returns the context, where you can get and set variables
+     */
+    createContext(): FlowGraphContext;
     /**
-     * Finds a block by its name.
-     * @param name
-     * @returns
+     * Add an event block. When the graph is started, it will start listening to events
+     * from the block and execute the graph when they are triggered.
+     * @param block
      */
-    findBlockByName(name: string): FlowGraphBlock | undefined;
+    addEventBlock(block: FlowGraphEventBlock): void;
     /**
-     * Starts the flow graph.
+     * Starts the flow graph. Initializes the event blocks and starts listening to events.
      */
     start(): void;
     /**
-     * Disposes of the flow graph.
+     * Disposes of the flow graph. Cancels any pending tasks and removes all event listeners.
      */
     dispose(): void;
 }

package/FlowGraph/flowGraph.js

@@ -1,4 +1,4 @@
-import { FlowGraphEventBlock } from "./flowGraphEventBlock.js";
+import { FlowGraphVariableDefinitions } from "./flowGraphVariableDefinitions.js";
 /**
  * @experimental
  * Class used to represent a flow graph.
@@ -7,46 +7,60 @@ import { FlowGraphEventBlock } from "./flowGraphEventBlock.js";
  * The graph can then be started, which will init and start all of its event blocks.
  */
 export class FlowGraph {
-    constructor(_scene) {
-        this._scene = _scene;
-        this._blocks = [];
+    /**
+     * Construct a Flow Graph
+     * @param params construction parameters. currently only the scene
+     */
+    constructor(params) {
+        /**
+         * The variables defined for this graph
+         */
+        this.variableDefinitions = new FlowGraphVariableDefinitions();
+        this._eventBlocks = [];
+        this._executionContexts = [];
+        this._scene = params.scene;
+        this._eventCoordinator = params.eventCoordinator;
         this._sceneDisposeObserver = this._scene.onDisposeObservable.add(this.dispose.bind(this));
     }
     /**
-     * @internal
-     * @param block
+     * Create a context. A context represents one self contained execution for the graph, with its own variables.
+     * @returns the context, where you can get and set variables
      */
-    _addBlock(block) {
-        this._blocks.push(block);
+    createContext() {
+        const context = this.variableDefinitions.generateContext({ scene: this._scene, eventCoordinator: this._eventCoordinator });
+        this._executionContexts.push(context);
+        return context;
     }
     /**
-     * Finds a block by its name.
-     * @param name
-     * @returns
+     * Add an event block. When the graph is started, it will start listening to events
+     * from the block and execute the graph when they are triggered.
+     * @param block
      */
-    findBlockByName(name) {
-        return this._blocks.find((block) => block.name === name);
+    addEventBlock(block) {
+        this._eventBlocks.push(block);
     }
     /**
-     * Starts the flow graph.
+     * Starts the flow graph. Initializes the event blocks and starts listening to events.
      */
     start() {
-        for (const block of this._blocks) {
-            if (block instanceof FlowGraphEventBlock) {
-                block._startListening();
+        if (this._executionContexts.length === 0) {
+            this.createContext();
+        }
+        for (const context of this._executionContexts) {
+            for (const block of this._eventBlocks) {
+                block._startPendingTasks(context);
             }
         }
     }
     /**
-     * Disposes of the flow graph.
+     * Disposes of the flow graph. Cancels any pending tasks and removes all event listeners.
      */
     dispose() {
-        for (const block of this._blocks) {
-            if (block instanceof FlowGraphEventBlock) {
-                block._stopListening();
-            }
+        for (const context of this._executionContexts) {
+            context._clearPendingBlocks();
         }
-        this._blocks.length = 0;
+        this._executionContexts.length = 0;
+        this._eventBlocks.length = 0;
         this._scene.onDisposeObservable.remove(this._sceneDisposeObserver);
         this._sceneDisposeObserver = null;
     }

package/FlowGraph/flowGraph.js.map

@@ -1 +1 @@
-{"version":3,"file":"flowGraph.js","sourceRoot":"","sources":["../../../../dev/core/src/FlowGraph/flowGraph.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAE5D;;;;;;GAMG;AACH,MAAM,OAAO,SAAS;IAIlB,YAA2B,MAAa;QAAb,WAAM,GAAN,MAAM,CAAO;QAHhC,YAAO,GAAqB,EAAE,CAAC;QAInC,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC,MAAM,CAAC,mBAAmB,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;IAC9F,CAAC;IAED;;;OAGG;IACI,SAAS,CAAC,KAAqB;QAClC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC7B,CAAC;IAED;;;;OAIG;IACI,eAAe,CAAC,IAAY;QAC/B,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;IAC7D,CAAC;IAED;;OAEG;IACI,KAAK;QACR,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,OAAO,EAAE;YAC9B,IAAI,KAAK,YAAY,mBAAmB,EAAE;gBACtC,KAAK,CAAC,eAAe,EAAE,CAAC;aAC3B;SACJ;IACL,CAAC;IAED;;OAEG;IACI,OAAO;QACV,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,OAAO,EAAE;YAC9B,IAAI,KAAK,YAAY,mBAAmB,EAAE;gBACtC,KAAK,CAAC,cAAc,EAAE,CAAC;aAC1B;SACJ;QACD,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC;QACxB,IAAI,CAAC,MAAM,CAAC,mBAAmB,CAAC,MAAM,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC;QACnE,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC;IACtC,CAAC;CACJ","sourcesContent":["import type { Observer } from \"../Misc/observable\";\r\nimport type { Nullable } from \"../types\";\r\nimport type { Scene } from \"../scene\";\r\nimport type { FlowGraphBlock } from \"./flowGraphBlock\";\r\nimport { FlowGraphEventBlock } from \"./flowGraphEventBlock\";\r\n\r\n/**\r\n * @experimental\r\n * Class used to represent a flow graph.\r\n * A flow graph is a graph of blocks that can be used to create complex logic.\r\n * Blocks can be added to the graph and connected to each other.\r\n * The graph can then be started, which will init and start all of its event blocks.\r\n */\r\nexport class FlowGraph {\r\n    private _blocks: FlowGraphBlock[] = [];\r\n    private _sceneDisposeObserver: Nullable<Observer<Scene>>;\r\n\r\n    public constructor(private _scene: Scene) {\r\n        this._sceneDisposeObserver = this._scene.onDisposeObservable.add(this.dispose.bind(this));\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     * @param block\r\n     */\r\n    public _addBlock(block: FlowGraphBlock): void {\r\n        this._blocks.push(block);\r\n    }\r\n\r\n    /**\r\n     * Finds a block by its name.\r\n     * @param name\r\n     * @returns\r\n     */\r\n    public findBlockByName(name: string): FlowGraphBlock | undefined {\r\n        return this._blocks.find((block) => block.name === name);\r\n    }\r\n\r\n    /**\r\n     * Starts the flow graph.\r\n     */\r\n    public start() {\r\n        for (const block of this._blocks) {\r\n            if (block instanceof FlowGraphEventBlock) {\r\n                block._startListening();\r\n            }\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Disposes of the flow graph.\r\n     */\r\n    public dispose() {\r\n        for (const block of this._blocks) {\r\n            if (block instanceof FlowGraphEventBlock) {\r\n                block._stopListening();\r\n            }\r\n        }\r\n        this._blocks.length = 0;\r\n        this._scene.onDisposeObservable.remove(this._sceneDisposeObserver);\r\n        this._sceneDisposeObserver = null;\r\n    }\r\n}\r\n"]}
+{"version":3,"file":"flowGraph.js","sourceRoot":"","sources":["../../../../dev/core/src/FlowGraph/flowGraph.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,4BAA4B,EAAE,MAAM,gCAAgC,CAAC;AAkB9E;;;;;;GAMG;AACH,MAAM,OAAO,SAAS;IAelB;;;OAGG;IACH,YAAmB,MAAuB;QAlB1C;;WAEG;QACI,wBAAmB,GAAiC,IAAI,4BAA4B,EAAE,CAAC;QAEtF,iBAAY,GAA0B,EAAE,CAAC;QAOzC,uBAAkB,GAAuB,EAAE,CAAC;QAOhD,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC;QAC3B,IAAI,CAAC,iBAAiB,GAAG,MAAM,CAAC,gBAAgB,CAAC;QACjD,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC,MAAM,CAAC,mBAAmB,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;IAC9F,CAAC;IAED;;;OAGG;IACI,aAAa;QAChB,MAAM,OAAO,GAAG,IAAI,CAAC,mBAAmB,CAAC,eAAe,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,MAAM,EAAE,gBAAgB,EAAE,IAAI,CAAC,iBAAiB,EAAE,CAAC,CAAC;QAC3H,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACtC,OAAO,OAAO,CAAC;IACnB,CAAC;IAED;;;;OAIG;IACI,aAAa,CAAC,KAA0B;QAC3C,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAClC,CAAC;IAED;;OAEG;IACI,KAAK;QACR,IAAI,IAAI,CAAC,kBAAkB,CAAC,MAAM,KAAK,CAAC,EAAE;YACtC,IAAI,CAAC,aAAa,EAAE,CAAC;SACxB;QACD,KAAK,MAAM,OAAO,IAAI,IAAI,CAAC,kBAAkB,EAAE;YAC3C,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC,YAAY,EAAE;gBACnC,KAAK,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC;aACrC;SACJ;IACL,CAAC;IAED;;OAEG;IACI,OAAO;QACV,KAAK,MAAM,OAAO,IAAI,IAAI,CAAC,kBAAkB,EAAE;YAC3C,OAAO,CAAC,mBAAmB,EAAE,CAAC;SACjC;QACD,IAAI,CAAC,kBAAkB,CAAC,MAAM,GAAG,CAAC,CAAC;QACnC,IAAI,CAAC,YAAY,CAAC,MAAM,GAAG,CAAC,CAAC;QAC7B,IAAI,CAAC,MAAM,CAAC,mBAAmB,CAAC,MAAM,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC;QACnE,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC;IACtC,CAAC;CACJ","sourcesContent":["import type { Observer } from \"../Misc/observable\";\r\nimport type { Nullable } from \"../types\";\r\nimport type { Scene } from \"../scene\";\r\nimport type { FlowGraphEventBlock } from \"./flowGraphEventBlock\";\r\nimport { FlowGraphVariableDefinitions } from \"./flowGraphVariableDefinitions\";\r\nimport type { FlowGraphContext } from \"./flowGraphContext\";\r\nimport type { FlowGraphEventCoordinator } from \"./flowGraphEventCoordinator\";\r\n\r\n/**\r\n * @experimental\r\n * Parameters used to create a flow graph.\r\n */\r\nexport interface FlowGraphParams {\r\n    /**\r\n     * The scene that the flow graph belongs to.\r\n     */\r\n    scene: Scene;\r\n    /**\r\n     * The event coordinator used by the flow graph.\r\n     */\r\n    eventCoordinator: FlowGraphEventCoordinator;\r\n}\r\n/**\r\n * @experimental\r\n * Class used to represent a flow graph.\r\n * A flow graph is a graph of blocks that can be used to create complex logic.\r\n * Blocks can be added to the graph and connected to each other.\r\n * The graph can then be started, which will init and start all of its event blocks.\r\n */\r\nexport class FlowGraph {\r\n    /**\r\n     * The variables defined for this graph\r\n     */\r\n    public variableDefinitions: FlowGraphVariableDefinitions = new FlowGraphVariableDefinitions();\r\n\r\n    private _eventBlocks: FlowGraphEventBlock[] = [];\r\n    private _sceneDisposeObserver: Nullable<Observer<Scene>>;\r\n    /**\r\n     * @internal\r\n     */\r\n    public readonly _scene: Scene;\r\n    private _eventCoordinator: FlowGraphEventCoordinator;\r\n    private _executionContexts: FlowGraphContext[] = [];\r\n\r\n    /**\r\n     * Construct a Flow Graph\r\n     * @param params construction parameters. currently only the scene\r\n     */\r\n    public constructor(params: FlowGraphParams) {\r\n        this._scene = params.scene;\r\n        this._eventCoordinator = params.eventCoordinator;\r\n        this._sceneDisposeObserver = this._scene.onDisposeObservable.add(this.dispose.bind(this));\r\n    }\r\n\r\n    /**\r\n     * Create a context. A context represents one self contained execution for the graph, with its own variables.\r\n     * @returns the context, where you can get and set variables\r\n     */\r\n    public createContext() {\r\n        const context = this.variableDefinitions.generateContext({ scene: this._scene, eventCoordinator: this._eventCoordinator });\r\n        this._executionContexts.push(context);\r\n        return context;\r\n    }\r\n\r\n    /**\r\n     * Add an event block. When the graph is started, it will start listening to events\r\n     * from the block and execute the graph when they are triggered.\r\n     * @param block\r\n     */\r\n    public addEventBlock(block: FlowGraphEventBlock): void {\r\n        this._eventBlocks.push(block);\r\n    }\r\n\r\n    /**\r\n     * Starts the flow graph. Initializes the event blocks and starts listening to events.\r\n     */\r\n    public start() {\r\n        if (this._executionContexts.length === 0) {\r\n            this.createContext();\r\n        }\r\n        for (const context of this._executionContexts) {\r\n            for (const block of this._eventBlocks) {\r\n                block._startPendingTasks(context);\r\n            }\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Disposes of the flow graph. Cancels any pending tasks and removes all event listeners.\r\n     */\r\n    public dispose() {\r\n        for (const context of this._executionContexts) {\r\n            context._clearPendingBlocks();\r\n        }\r\n        this._executionContexts.length = 0;\r\n        this._eventBlocks.length = 0;\r\n        this._scene.onDisposeObservable.remove(this._sceneDisposeObserver);\r\n        this._sceneDisposeObserver = null;\r\n    }\r\n}\r\n"]}

package/FlowGraph/flowGraphAsyncExecutionBlock.d.ts

@@ -0,0 +1,29 @@
+import type { FlowGraphContext } from "./flowGraphContext";
+import { FlowGraphExecutionBlock } from "./flowGraphExecutionBlock";
+import type { FlowGraphSignalConnection } from "./flowGraphSignalConnection";
+/**
+ * An async execution block can start tasks that will be executed asynchronously.
+ * It should also be responsible for clearing it in _cancelPendingTasks.
+ * @experimental
+ */
+export declare abstract class FlowGraphAsyncExecutionBlock extends FlowGraphExecutionBlock {
+    /**
+     * Output connection: The signal that is triggered when the execution of this block is done.
+     */
+    onDone: FlowGraphSignalConnection;
+    constructor();
+    /**
+     * @internal
+     * This function can be overridden to start any
+     * pending tasks this node might have, such as
+     * timeouts and playing animations.
+     * @param context
+     */
+    abstract _preparePendingTasks(context: FlowGraphContext): void;
+    /**
+     * @internal
+     * @param context
+     */
+    _startPendingTasks(context: FlowGraphContext): void;
+    abstract _cancelPendingTasks(context: FlowGraphContext): void;
+}

package/FlowGraph/flowGraphAsyncExecutionBlock.js

@@ -0,0 +1,21 @@
+import { FlowGraphExecutionBlock } from "./flowGraphExecutionBlock.js";
+/**
+ * An async execution block can start tasks that will be executed asynchronously.
+ * It should also be responsible for clearing it in _cancelPendingTasks.
+ * @experimental
+ */
+export class FlowGraphAsyncExecutionBlock extends FlowGraphExecutionBlock {
+    constructor() {
+        super();
+        this.onDone = this._registerSignalOutput("onDone");
+    }
+    /**
+     * @internal
+     * @param context
+     */
+    _startPendingTasks(context) {
+        this._preparePendingTasks(context);
+        context._addPendingBlock(this);
+    }
+}
+//# sourceMappingURL=flowGraphAsyncExecutionBlock.js.map

package/FlowGraph/flowGraphAsyncExecutionBlock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flowGraphAsyncExecutionBlock.js","sourceRoot":"","sources":["../../../../dev/core/src/FlowGraph/flowGraphAsyncExecutionBlock.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AAGpE;;;;GAIG;AACH,MAAM,OAAgB,4BAA6B,SAAQ,uBAAuB;IAM9E;QACI,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,qBAAqB,CAAC,QAAQ,CAAC,CAAC;IACvD,CAAC;IAUD;;;OAGG;IACI,kBAAkB,CAAC,OAAyB;QAC/C,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC,CAAC;QACnC,OAAO,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;IACnC,CAAC;CAGJ","sourcesContent":["import type { FlowGraphContext } from \"./flowGraphContext\";\r\nimport { FlowGraphExecutionBlock } from \"./flowGraphExecutionBlock\";\r\nimport type { FlowGraphSignalConnection } from \"./flowGraphSignalConnection\";\r\n\r\n/**\r\n * An async execution block can start tasks that will be executed asynchronously.\r\n * It should also be responsible for clearing it in _cancelPendingTasks.\r\n * @experimental\r\n */\r\nexport abstract class FlowGraphAsyncExecutionBlock extends FlowGraphExecutionBlock {\r\n    /**\r\n     * Output connection: The signal that is triggered when the execution of this block is done.\r\n     */\r\n    public onDone: FlowGraphSignalConnection;\r\n\r\n    constructor() {\r\n        super();\r\n        this.onDone = this._registerSignalOutput(\"onDone\");\r\n    }\r\n    /**\r\n     * @internal\r\n     * This function can be overridden to start any\r\n     * pending tasks this node might have, such as\r\n     * timeouts and playing animations.\r\n     * @param context\r\n     */\r\n    public abstract _preparePendingTasks(context: FlowGraphContext): void;\r\n\r\n    /**\r\n     * @internal\r\n     * @param context\r\n     */\r\n    public _startPendingTasks(context: FlowGraphContext) {\r\n        this._preparePendingTasks(context);\r\n        context._addPendingBlock(this);\r\n    }\r\n\r\n    public abstract _cancelPendingTasks(context: FlowGraphContext): void;\r\n}\r\n"]}

package/FlowGraph/flowGraphBlock.d.ts

@@ -1,5 +1,6 @@
-import type { FlowGraph } from "./flowGraph";
+import type { FlowGraphContext } from "./flowGraphContext";
 import { FlowGraphDataConnection } from "./flowGraphDataConnection";
+import type { RichType } from "./flowGraphRichTypes";
 /**
  * @experimental
  * A block in a flow graph. The most basic form
@@ -8,9 +9,9 @@ import { FlowGraphDataConnection } from "./flowGraphDataConnection";
  */
 export declare class FlowGraphBlock {
     /**
-     * The name of the block.
+     * A randomly generated GUID for each block.
      */
-    name: string;
+    uniqueId: string;
     /**
      * The data inputs of the block.
      */
@@ -19,15 +20,12 @@ export declare class FlowGraphBlock {
      * The data outputs of the block.
      */
     readonly dataOutputs: FlowGraphDataConnection<any>[];
-    /**
-     * The graph that this block belongs to.
-     */
-    private _graph;
-    protected constructor(graph: FlowGraph);
+    /** Constructor is protected so only subclasses can be instantiated */
+    protected constructor();
     /**
      * @internal
      */
-    _updateOutputs(): void;
-    protected _registerDataInput<T>(name: string, defaultValue: T): FlowGraphDataConnection<T>;
-    protected _registerDataOutput<T>(name: string, defaultValue: T): FlowGraphDataConnection<T>;
+    _updateOutputs(_context: FlowGraphContext): void;
+    protected _registerDataInput<T>(name: string, className: RichType<T>): FlowGraphDataConnection<T>;
+    protected _registerDataOutput<T>(name: string, className: RichType<T>): FlowGraphDataConnection<T>;
 }

package/FlowGraph/flowGraphBlock.js

@@ -1,3 +1,4 @@
+import { RandomGUID } from "../Misc/guid.js";
 import { FlowGraphConnectionType } from "./flowGraphConnection.js";
 import { FlowGraphDataConnection } from "./flowGraphDataConnection.js";
 /**
@@ -7,7 +8,12 @@ import { FlowGraphDataConnection } from "./flowGraphDataConnection.js";
  * data.
  */
 export class FlowGraphBlock {
-    constructor(graph) {
+    /** Constructor is protected so only subclasses can be instantiated */
+    constructor() {
+        /**
+         * A randomly generated GUID for each block.
+         */
+        this.uniqueId = RandomGUID();
         /**
          * The data inputs of the block.
          */
@@ -16,22 +22,20 @@ export class FlowGraphBlock {
          * The data outputs of the block.
          */
         this.dataOutputs = [];
-        this._graph = graph;
-        this._graph._addBlock(this);
     }
     /**
      * @internal
      */
-    _updateOutputs() {
+    _updateOutputs(_context) {
         // empty by default, overriden in data blocks
     }
-    _registerDataInput(name, defaultValue) {
-        const input = new FlowGraphDataConnection(name, FlowGraphConnectionType.Input, this, defaultValue);
+    _registerDataInput(name, className) {
+        const input = new FlowGraphDataConnection(name, FlowGraphConnectionType.Input, this, className);
         this.dataInputs.push(input);
         return input;
     }
-    _registerDataOutput(name, defaultValue) {
-        const output = new FlowGraphDataConnection(name, FlowGraphConnectionType.Output, this, defaultValue);
+    _registerDataOutput(name, className) {
+        const output = new FlowGraphDataConnection(name, FlowGraphConnectionType.Output, this, className);
         this.dataOutputs.push(output);
         return output;
     }

package/FlowGraph/flowGraphBlock.js.map

@@ -1 +1 @@
-{"version":3,"file":"flowGraphBlock.js","sourceRoot":"","sources":["../../../../dev/core/src/FlowGraph/flowGraphBlock.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AAEpE;;;;;GAKG;AACH,MAAM,OAAO,cAAc;IAkBvB,YAAsB,KAAgB;QAbtC;;WAEG;QACa,eAAU,GAAmC,EAAE,CAAC;QAChE;;WAEG;QACa,gBAAW,GAAmC,EAAE,CAAC;QAO7D,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;QACpB,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;IAChC,CAAC;IAED;;OAEG;IACI,cAAc;QACjB,6CAA6C;IACjD,CAAC;IAES,kBAAkB,CAAI,IAAY,EAAE,YAAe;QACzD,MAAM,KAAK,GAAG,IAAI,uBAAuB,CAAI,IAAI,EAAE,uBAAuB,CAAC,KAAK,EAAE,IAAI,EAAE,YAAY,CAAC,CAAC;QACtG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC5B,OAAO,KAAK,CAAC;IACjB,CAAC;IAES,mBAAmB,CAAI,IAAY,EAAE,YAAe;QAC1D,MAAM,MAAM,GAAG,IAAI,uBAAuB,CAAI,IAAI,EAAE,uBAAuB,CAAC,MAAM,EAAE,IAAI,EAAE,YAAY,CAAC,CAAC;QACxG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAC9B,OAAO,MAAM,CAAC;IAClB,CAAC;CACJ","sourcesContent":["import type { FlowGraph } from \"./flowGraph\";\r\nimport { FlowGraphConnectionType } from \"./flowGraphConnection\";\r\nimport { FlowGraphDataConnection } from \"./flowGraphDataConnection\";\r\n\r\n/**\r\n * @experimental\r\n * A block in a flow graph. The most basic form\r\n * of a block has inputs and outputs that contain\r\n * data.\r\n */\r\nexport class FlowGraphBlock {\r\n    /**\r\n     * The name of the block.\r\n     */\r\n    public name: string;\r\n    /**\r\n     * The data inputs of the block.\r\n     */\r\n    public readonly dataInputs: FlowGraphDataConnection<any>[] = [];\r\n    /**\r\n     * The data outputs of the block.\r\n     */\r\n    public readonly dataOutputs: FlowGraphDataConnection<any>[] = [];\r\n    /**\r\n     * The graph that this block belongs to.\r\n     */\r\n    private _graph: FlowGraph;\r\n\r\n    protected constructor(graph: FlowGraph) {\r\n        this._graph = graph;\r\n        this._graph._addBlock(this);\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    public _updateOutputs(): void {\r\n        // empty by default, overriden in data blocks\r\n    }\r\n\r\n    protected _registerDataInput<T>(name: string, defaultValue: T): FlowGraphDataConnection<T> {\r\n        const input = new FlowGraphDataConnection<T>(name, FlowGraphConnectionType.Input, this, defaultValue);\r\n        this.dataInputs.push(input);\r\n        return input;\r\n    }\r\n\r\n    protected _registerDataOutput<T>(name: string, defaultValue: T): FlowGraphDataConnection<T> {\r\n        const output = new FlowGraphDataConnection<T>(name, FlowGraphConnectionType.Output, this, defaultValue);\r\n        this.dataOutputs.push(output);\r\n        return output;\r\n    }\r\n}\r\n"]}
+{"version":3,"file":"flowGraphBlock.js","sourceRoot":"","sources":["../../../../dev/core/src/FlowGraph/flowGraphBlock.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAEhE,OAAO,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AAGpE;;;;;GAKG;AACH,MAAM,OAAO,cAAc;IAcvB,sEAAsE;IACtE;QAdA;;WAEG;QACI,aAAQ,GAAG,UAAU,EAAE,CAAC;QAC/B;;WAEG;QACa,eAAU,GAAmC,EAAE,CAAC;QAChE;;WAEG;QACa,gBAAW,GAAmC,EAAE,CAAC;IAGxC,CAAC;IAE1B;;OAEG;IACI,cAAc,CAAC,QAA0B;QAC5C,6CAA6C;IACjD,CAAC;IAES,kBAAkB,CAAI,IAAY,EAAE,SAAsB;QAChE,MAAM,KAAK,GAAG,IAAI,uBAAuB,CAAC,IAAI,EAAE,uBAAuB,CAAC,KAAK,EAAE,IAAI,EAAE,SAAS,CAAC,CAAC;QAChG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC5B,OAAO,KAAK,CAAC;IACjB,CAAC;IAES,mBAAmB,CAAI,IAAY,EAAE,SAAsB;QACjE,MAAM,MAAM,GAAG,IAAI,uBAAuB,CAAC,IAAI,EAAE,uBAAuB,CAAC,MAAM,EAAE,IAAI,EAAE,SAAS,CAAC,CAAC;QAClG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAC9B,OAAO,MAAM,CAAC;IAClB,CAAC;CACJ","sourcesContent":["import { RandomGUID } from \"../Misc/guid\";\r\nimport { FlowGraphConnectionType } from \"./flowGraphConnection\";\r\nimport type { FlowGraphContext } from \"./flowGraphContext\";\r\nimport { FlowGraphDataConnection } from \"./flowGraphDataConnection\";\r\nimport type { RichType } from \"./flowGraphRichTypes\";\r\n\r\n/**\r\n * @experimental\r\n * A block in a flow graph. The most basic form\r\n * of a block has inputs and outputs that contain\r\n * data.\r\n */\r\nexport class FlowGraphBlock {\r\n    /**\r\n     * A randomly generated GUID for each block.\r\n     */\r\n    public uniqueId = RandomGUID();\r\n    /**\r\n     * The data inputs of the block.\r\n     */\r\n    public readonly dataInputs: FlowGraphDataConnection<any>[] = [];\r\n    /**\r\n     * The data outputs of the block.\r\n     */\r\n    public readonly dataOutputs: FlowGraphDataConnection<any>[] = [];\r\n\r\n    /** Constructor is protected so only subclasses can be instantiated */\r\n    protected constructor() {}\r\n\r\n    /**\r\n     * @internal\r\n     */\r\n    public _updateOutputs(_context: FlowGraphContext): void {\r\n        // empty by default, overriden in data blocks\r\n    }\r\n\r\n    protected _registerDataInput<T>(name: string, className: RichType<T>): FlowGraphDataConnection<T> {\r\n        const input = new FlowGraphDataConnection(name, FlowGraphConnectionType.Input, this, className);\r\n        this.dataInputs.push(input);\r\n        return input;\r\n    }\r\n\r\n    protected _registerDataOutput<T>(name: string, className: RichType<T>): FlowGraphDataConnection<T> {\r\n        const output = new FlowGraphDataConnection(name, FlowGraphConnectionType.Output, this, className);\r\n        this.dataOutputs.push(output);\r\n        return output;\r\n    }\r\n}\r\n"]}

package/FlowGraph/flowGraphConnection.d.ts

@@ -1,4 +1,3 @@
-import type { Nullable } from "../types";
 /**
  * @experimental
  * The type of a connection point - inpput or output.
@@ -11,8 +10,9 @@ export declare enum FlowGraphConnectionType {
  * @experimental
  */
 export interface IConnectable {
-    _connectedPoint: Nullable<IConnectable>;
-    _type: FlowGraphConnectionType;
+    _connectedPoint: Array<IConnectable>;
+    _isSingularConnection(): boolean;
+    _connectionType: FlowGraphConnectionType;
     connectTo(point: IConnectable): void;
 }
 /**
@@ -21,15 +21,25 @@ export interface IConnectable {
  */
 export declare class FlowGraphConnection<BlockT, ConnectedToT extends IConnectable> implements IConnectable {
     name: string;
-    _type: FlowGraphConnectionType;
+    _connectionType: FlowGraphConnectionType;
     protected _ownerBlock: BlockT;
     /** @internal */
-    _connectedPoint: Nullable<ConnectedToT>;
-    constructor(name: string, /** @internal */ _type: FlowGraphConnectionType, _ownerBlock: BlockT);
+    _connectedPoint: Array<ConnectedToT>;
+    constructor(name: string, /** @internal */ _connectionType: FlowGraphConnectionType, _ownerBlock: BlockT);
     /**
      * The type of the connection
      */
-    get type(): FlowGraphConnectionType;
+    get connectionType(): FlowGraphConnectionType;
+    /**
+     * @internal
+     * Override this to indicate if a point can connect to more than one point.
+     */
+    _isSingularConnection(): boolean;
+    /**
+     * Returns if a point is connected to any other point.
+     * @returns boolean indicating if the point is connected.
+     */
+    isConnected(): boolean;
     /**
      * Connects two points together.
      * @param point

package/FlowGraph/flowGraphConnection.js

@@ -12,29 +12,46 @@ export var FlowGraphConnectionType;
  * The base connection class.
  */
 export class FlowGraphConnection {
-    constructor(name, /** @internal */ _type, _ownerBlock) {
+    constructor(name, /** @internal */ _connectionType, _ownerBlock) {
         this.name = name;
-        this._type = _type;
+        this._connectionType = _connectionType;
         this._ownerBlock = _ownerBlock;
         /** @internal */
-        this._connectedPoint = null;
+        this._connectedPoint = [];
     }
     /**
      * The type of the connection
      */
-    get type() {
-        return this._type;
+    get connectionType() {
+        return this._connectionType;
+    }
+    /**
+     * @internal
+     * Override this to indicate if a point can connect to more than one point.
+     */
+    _isSingularConnection() {
+        return true;
+    }
+    /**
+     * Returns if a point is connected to any other point.
+     * @returns boolean indicating if the point is connected.
+     */
+    isConnected() {
+        return this._connectedPoint.length > 0;
     }
     /**
      * Connects two points together.
      * @param point
      */
     connectTo(point) {
-        if (this._type === point._type) {
-            throw new Error(`Cannot connect two points of type ${this.type}`);
+        if (this._connectionType === point._connectionType) {
+            throw new Error(`Cannot connect two points of type ${this.connectionType}`);
+        }
+        if ((this._isSingularConnection() && this._connectedPoint.length > 0) || (point._isSingularConnection() && point._connectedPoint.length > 0)) {
+            throw new Error("Max number of connections for point reached");
         }
-        this._connectedPoint = point;
-        point._connectedPoint = this;
+        this._connectedPoint.push(point);
+        point._connectedPoint.push(this);
     }
 }
 //# sourceMappingURL=flowGraphConnection.js.map

package/FlowGraph/flowGraphConnection.js.map

@@ -1 +1 @@
-{"version":3,"file":"flowGraphConnection.js","sourceRoot":"","sources":["../../../../dev/core/src/FlowGraph/flowGraphConnection.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,MAAM,CAAN,IAAY,uBAGX;AAHD,WAAY,uBAAuB;IAC/B,uEAAK,CAAA;IACL,yEAAM,CAAA;AACV,CAAC,EAHW,uBAAuB,KAAvB,uBAAuB,QAGlC;AAWD;;;GAGG;AACH,MAAM,OAAO,mBAAmB;IAI5B,YAA0B,IAAY,EAAE,gBAAgB,CAAQ,KAA8B,EAAY,WAAmB;QAAnG,SAAI,GAAJ,IAAI,CAAQ;QAA0B,UAAK,GAAL,KAAK,CAAyB;QAAY,gBAAW,GAAX,WAAW,CAAQ;QAH7H,gBAAgB;QACT,oBAAe,GAA2B,IAAI,CAAC;IAE0E,CAAC;IAEjI;;OAEG;IACH,IAAW,IAAI;QACX,OAAO,IAAI,CAAC,KAAK,CAAC;IACtB,CAAC;IAED;;;OAGG;IACI,SAAS,CAAC,KAAmB;QAChC,IAAI,IAAI,CAAC,KAAK,KAAK,KAAK,CAAC,KAAK,EAAE;YAC5B,MAAM,IAAI,KAAK,CAAC,qCAAqC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;SACrE;QACD,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC;QAC7B,KAAK,CAAC,eAAe,GAAG,IAAI,CAAC;IACjC,CAAC;CACJ","sourcesContent":["import type { Nullable } from \"../types\";\r\n\r\n/**\r\n * @experimental\r\n * The type of a connection point - inpput or output.\r\n */\r\nexport enum FlowGraphConnectionType {\r\n    Input,\r\n    Output,\r\n}\r\n\r\n/**\r\n * @experimental\r\n */\r\nexport interface IConnectable {\r\n    _connectedPoint: Nullable<IConnectable>;\r\n    _type: FlowGraphConnectionType;\r\n    connectTo(point: IConnectable): void;\r\n}\r\n\r\n/**\r\n * @experimental\r\n * The base connection class.\r\n */\r\nexport class FlowGraphConnection<BlockT, ConnectedToT extends IConnectable> implements IConnectable {\r\n    /** @internal */\r\n    public _connectedPoint: Nullable<ConnectedToT> = null;\r\n\r\n    public constructor(public name: string, /** @internal */ public _type: FlowGraphConnectionType, protected _ownerBlock: BlockT) {}\r\n\r\n    /**\r\n     * The type of the connection\r\n     */\r\n    public get type() {\r\n        return this._type;\r\n    }\r\n\r\n    /**\r\n     * Connects two points together.\r\n     * @param point\r\n     */\r\n    public connectTo(point: ConnectedToT): void {\r\n        if (this._type === point._type) {\r\n            throw new Error(`Cannot connect two points of type ${this.type}`);\r\n        }\r\n        this._connectedPoint = point;\r\n        point._connectedPoint = this;\r\n    }\r\n}\r\n"]}
+{"version":3,"file":"flowGraphConnection.js","sourceRoot":"","sources":["../../../../dev/core/src/FlowGraph/flowGraphConnection.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,CAAN,IAAY,uBAGX;AAHD,WAAY,uBAAuB;IAC/B,uEAAK,CAAA;IACL,yEAAM,CAAA;AACV,CAAC,EAHW,uBAAuB,KAAvB,uBAAuB,QAGlC;AAYD;;;GAGG;AACH,MAAM,OAAO,mBAAmB;IAI5B,YAA0B,IAAY,EAAE,gBAAgB,CAAQ,eAAwC,EAAY,WAAmB;QAA7G,SAAI,GAAJ,IAAI,CAAQ;QAA0B,oBAAe,GAAf,eAAe,CAAyB;QAAY,gBAAW,GAAX,WAAW,CAAQ;QAHvI,gBAAgB;QACT,oBAAe,GAAwB,EAAE,CAAC;IAEyF,CAAC;IAE3I;;OAEG;IACH,IAAW,cAAc;QACrB,OAAO,IAAI,CAAC,eAAe,CAAC;IAChC,CAAC;IAED;;;OAGG;IACI,qBAAqB;QACxB,OAAO,IAAI,CAAC;IAChB,CAAC;IAED;;;OAGG;IACI,WAAW;QACd,OAAO,IAAI,CAAC,eAAe,CAAC,MAAM,GAAG,CAAC,CAAC;IAC3C,CAAC;IAED;;;OAGG;IACI,SAAS,CAAC,KAAmB;QAChC,IAAI,IAAI,CAAC,eAAe,KAAK,KAAK,CAAC,eAAe,EAAE;YAChD,MAAM,IAAI,KAAK,CAAC,qCAAqC,IAAI,CAAC,cAAc,EAAE,CAAC,CAAC;SAC/E;QACD,IAAI,CAAC,IAAI,CAAC,qBAAqB,EAAE,IAAI,IAAI,CAAC,eAAe,CAAC,MAAM,GAAG,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,qBAAqB,EAAE,IAAI,KAAK,CAAC,eAAe,CAAC,MAAM,GAAG,CAAC,CAAC,EAAE;YAC1I,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC;SAClE;QACD,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACjC,KAAK,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACrC,CAAC;CACJ","sourcesContent":["/**\r\n * @experimental\r\n * The type of a connection point - inpput or output.\r\n */\r\nexport enum FlowGraphConnectionType {\r\n    Input,\r\n    Output,\r\n}\r\n\r\n/**\r\n * @experimental\r\n */\r\nexport interface IConnectable {\r\n    _connectedPoint: Array<IConnectable>;\r\n    _isSingularConnection(): boolean;\r\n    _connectionType: FlowGraphConnectionType;\r\n    connectTo(point: IConnectable): void;\r\n}\r\n\r\n/**\r\n * @experimental\r\n * The base connection class.\r\n */\r\nexport class FlowGraphConnection<BlockT, ConnectedToT extends IConnectable> implements IConnectable {\r\n    /** @internal */\r\n    public _connectedPoint: Array<ConnectedToT> = [];\r\n\r\n    public constructor(public name: string, /** @internal */ public _connectionType: FlowGraphConnectionType, protected _ownerBlock: BlockT) {}\r\n\r\n    /**\r\n     * The type of the connection\r\n     */\r\n    public get connectionType() {\r\n        return this._connectionType;\r\n    }\r\n\r\n    /**\r\n     * @internal\r\n     * Override this to indicate if a point can connect to more than one point.\r\n     */\r\n    public _isSingularConnection(): boolean {\r\n        return true;\r\n    }\r\n\r\n    /**\r\n     * Returns if a point is connected to any other point.\r\n     * @returns boolean indicating if the point is connected.\r\n     */\r\n    public isConnected(): boolean {\r\n        return this._connectedPoint.length > 0;\r\n    }\r\n\r\n    /**\r\n     * Connects two points together.\r\n     * @param point\r\n     */\r\n    public connectTo(point: ConnectedToT): void {\r\n        if (this._connectionType === point._connectionType) {\r\n            throw new Error(`Cannot connect two points of type ${this.connectionType}`);\r\n        }\r\n        if ((this._isSingularConnection() && this._connectedPoint.length > 0) || (point._isSingularConnection() && point._connectedPoint.length > 0)) {\r\n            throw new Error(\"Max number of connections for point reached\");\r\n        }\r\n        this._connectedPoint.push(point);\r\n        point._connectedPoint.push(this);\r\n    }\r\n}\r\n"]}

package/FlowGraph/flowGraphContext.d.ts

@@ -0,0 +1,102 @@
+import type { Scene } from "../scene";
+import type { FlowGraphAsyncExecutionBlock } from "./flowGraphAsyncExecutionBlock";
+import type { FlowGraphBlock } from "./flowGraphBlock";
+import type { FlowGraphEventCoordinator } from "./flowGraphEventCoordinator";
+/**
+ * Construction parameters for the context.
+ * @experimental
+ */
+export interface IFlowGraphGraphVariables {
+    /**
+     * The scene that the flow graph context belongs to.
+     */
+    readonly scene: Scene;
+    /**
+     * The event coordinator used by the flow graph context.
+     */
+    readonly eventCoordinator: FlowGraphEventCoordinator;
+}
+/**
+ * @experimental
+ * The context represents the current state and execution of the flow graph.
+ * It contains both user-defined variables, which are derived from
+ * a more general variable definition, and execution variables that
+ * are set by the blocks.
+ */
+export declare class FlowGraphContext {
+    /**
+     * These are the variables defined by a user.
+     */
+    private _userVariables;
+    /**
+     * These are the variables set by the blocks.
+     */
+    private _executionVariables;
+    /**
+     * These are the variables set by the graph.
+     */
+    private readonly _graphVariables;
+    /**
+     * These are blocks that have currently pending tasks/listeners that need to be cleaned up.
+     */
+    private _pendingBlocks;
+    constructor(params: IFlowGraphGraphVariables);
+    /**
+     * Check if a user-defined variable is defined.
+     * @param name
+     * @returns
+     */
+    hasVariable(name: string): boolean;
+    /**
+     * Set a user-defined variable.
+     * @param name
+     * @param value
+     */
+    setVariable(name: string, value: any): void;
+    /**
+     * Get a user-defined variable.
+     * @param name
+     * @returns
+     */
+    getVariable(name: string): any;
+    private _getBlockPrefixedName;
+    /**
+     * Set an internal execution variable
+     * @internal
+     * @param name
+     * @param value
+     */
+    _setExecutionVariable(block: FlowGraphBlock, name: string, value: any): void;
+    /**
+     * Get an internal execution variable
+     * @internal
+     * @param name
+     * @returns
+     */
+    _getExecutionVariable(block: FlowGraphBlock, name: string): any;
+    _deleteExecutionVariable(block: FlowGraphBlock, name: string): void;
+    /**
+     * Get the graph set variables
+     * @internal
+     * @param name
+     * @param value
+     */
+    get graphVariables(): IFlowGraphGraphVariables;
+    /**
+     * Add a block to the list of blocks that have pending tasks.
+     * @internal
+     * @param block
+     */
+    _addPendingBlock(block: FlowGraphAsyncExecutionBlock): void;
+    /**
+     * Remove a block from the list of blocks that have pending tasks.
+     * @internal
+     * @param block
+     */
+    _removePendingBlock(block: FlowGraphAsyncExecutionBlock): void;
+    /**
+     * Clear all pending blocks.
+     * @internal
+     */
+    _clearPendingBlocks(): void;
+}