KHR_interactivity rework

packages/dev/core/src/FlowGraph/Blocks/Data/Math/flowGraphMathBlocks.ts

@@ -316,6 +316,29 @@ export class FlowGraphRandomBlock extends FlowGraphConstantOperationBlock<FlowGr
         const max = this.max.getValue(context);
         return this._getRandomValue() * (max - min) + min;
     }
+
+    /**
+     * Override to use per-execution caching that generates a fresh value for each
+     * new signal execution, while returning the same value when read multiple times
+     * within the same execution (required by the KHR_Interactivity spec).
+     * @param context the graph context
+     */
+    public override _updateOutputs(context: FlowGraphContext) {
+        const cachedExecId = context._getExecutionVariable(this, "_randomExecId", -1);
+        if (cachedExecId === context.executionId) {
+            // Same execution — return the cached random value
+            return;
+        }
+        // New execution — generate a fresh random value
+        const calculatedValue = this._doOperation(context);
+        if (calculatedValue === undefined || calculatedValue === null) {
+            this.isValid.setValue(false, context);
+            return;
+        }
+        context._setExecutionVariable(this, "_randomExecId", context.executionId);
+        this.value.setValue(calculatedValue, context);
+        this.isValid.setValue(true, context);
+    }
 }
 RegisterClass(FlowGraphBlockNames.Random, FlowGraphRandomBlock);
 
@@ -708,6 +731,23 @@ export class FlowGraphMathInterpolationBlock extends FlowGraphTernaryOperationBl
 }
 RegisterClass(FlowGraphBlockNames.MathInterpolation, FlowGraphMathInterpolationBlock);
 
+/**
+ * Spherical linear interpolation between two unit quaternions, matching the
+ * KHR_interactivity `math/quatSlerp` operation. The two inputs are treated as
+ * Babylon `Quaternion` values regardless of their concrete class (the spec
+ * defines them as `float4`), and the output is a `Quaternion`.
+ *
+ * The underlying implementation is `Quaternion.Slerp`, whose algorithm matches
+ * the spec step-for-step (dot product, conditional sign-flip on `b`, sin-based
+ * weighting, and a near-identity short-circuit to a linear blend).
+ */
+export class FlowGraphMathSlerpBlock extends FlowGraphTernaryOperationBlock<Quaternion, Quaternion, number, Quaternion> {
+    constructor(config?: IFlowGraphBlockConfiguration) {
+        super(RichTypeAny, RichTypeAny, RichTypeNumber, RichTypeAny, (a, b, c) => Quaternion.Slerp(a, b, c), FlowGraphBlockNames.MathSlerp, config);
+    }
+}
+RegisterClass(FlowGraphBlockNames.MathSlerp, FlowGraphMathSlerpBlock);
+
 /**
  * Equals block.
  */
@@ -719,14 +759,31 @@ export class FlowGraphEqualityBlock extends FlowGraphBinaryOperationBlock<FlowGr
     private _polymorphicEq(a: FlowGraphMathOperationType, b: FlowGraphMathOperationType) {
         const aClassName = _GetClassNameOf(a);
         const bClassName = _GetClassNameOf(b);
+        if (_AreSameVectorOrQuaternionClass(aClassName, bClassName) || _AreSameMatrixClass(aClassName, bClassName) || _AreSameIntegerClass(aClassName, bClassName)) {
+            return (a as Vector3).equals(b as Vector3);
+        }
+        // Handle mixed number/FlowGraphInteger comparison
+        if (isNumeric(a) && isNumeric(b)) {
+            return getNumericValue(a as FlowGraphNumber) === getNumericValue(b as FlowGraphNumber);
+        }
         if (typeof a !== typeof b) {
             return false;
         }
-        if (_AreSameVectorOrQuaternionClass(aClassName, bClassName) || _AreSameMatrixClass(aClassName, bClassName) || _AreSameIntegerClass(aClassName, bClassName)) {
-            return (a as Vector3).equals(b as Vector3);
-        } else {
-            return a === b;
+        // Both sides are JSON-Pointer-like ref strings ("/foo/0", "/foo/0/", ...).
+        // KHR_interactivity ref/eq is defined as "refers to the same object",
+        // so normalise trailing slashes before comparing — different asset
+        // authors emit refs with and without the trailing slash for the same
+        // object (e.g. /nodes/420 vs /nodes/420/).
+        if (typeof a === "string" && typeof b === "string") {
+            const aStr: string = a;
+            const bStr: string = b;
+            if (aStr.length > 0 && aStr[0] === "/" && bStr.length > 0 && bStr[0] === "/") {
+                const ar = aStr.endsWith("/") ? aStr.slice(0, -1) : aStr;
+                const br = bStr.endsWith("/") ? bStr.slice(0, -1) : bStr;
+                return ar === br;
+            }
         }
+        return a === b;
     }
 }
 RegisterClass(FlowGraphBlockNames.Equality, FlowGraphEqualityBlock);

packages/dev/core/src/FlowGraph/Blocks/Data/Transformers/flowGraphJsonPointerParserBlock.ts

@@ -106,6 +106,10 @@ export class FlowGraphJsonPointerParserBlock<P extends any, O extends FlowGraphA
         if (type.startsWith("Color")) {
             value = ToColor(value as Vector4, type) as unknown as P;
         }
+        // Unwrap FlowGraphInteger to plain number for numeric setters
+        if (typeof (value as any)?.value === "number" && (value as any)?.getClassName?.() === "FlowGraphInteger") {
+            value = (value as any).value as unknown as P;
+        }
         accessorContainer.info.set?.(value, accessorContainer.object);
     }
 

packages/dev/core/src/FlowGraph/Blocks/Data/Transformers/flowGraphTypeToTypeBlocks.ts

@@ -1,6 +1,6 @@
 import { type IFlowGraphBlockConfiguration } from "core/FlowGraph/flowGraphBlock";
 import { FlowGraphUnaryOperationBlock } from "../flowGraphUnaryOperationBlock";
-import { RichTypeBoolean, RichTypeFlowGraphInteger, RichTypeNumber } from "core/FlowGraph/flowGraphRichTypes";
+import { RichTypeAny, RichTypeBoolean, RichTypeFlowGraphInteger, RichTypeNumber } from "core/FlowGraph/flowGraphRichTypes";
 import { FlowGraphBlockNames } from "../../flowGraphBlockNames";
 import { RegisterClass } from "core/Misc/typeStore";
 import { FlowGraphInteger } from "core/FlowGraph/CustomTypes/flowGraphInteger";
@@ -51,10 +51,19 @@ RegisterClass(FlowGraphBlockNames.IntToBoolean, FlowGraphIntToBoolean);
 
 /**
  * A block that converts an integer to a float.
+ *
+ * KHR_interactivity ``type/intToFloat`` is spec-defined to take an ``int``
+ * input. The Babylon FlowGraph runtime represents ``int`` as
+ * ``FlowGraphInteger`` (a wrapper carrying ``.value``). Accept both shapes —
+ * a plain JavaScript ``number`` and a ``FlowGraphInteger`` — so accessors that
+ * return a raw integer (e.g. the ``/nodes/{}/children.length`` pointer/get
+ * accessor in ``objectModelMapping.ts``) interoperate with downstream graph
+ * blocks without producing ``undefined`` (which then poisons math chains
+ * with NaN).
  */
-export class FlowGraphIntToFloat extends FlowGraphUnaryOperationBlock<FlowGraphInteger, number> {
+export class FlowGraphIntToFloat extends FlowGraphUnaryOperationBlock<FlowGraphInteger | number, number> {
     constructor(config?: IFlowGraphBlockConfiguration) {
-        super(RichTypeFlowGraphInteger, RichTypeNumber, (a) => a.value, FlowGraphBlockNames.IntToFloat, config);
+        super(RichTypeAny, RichTypeNumber, (a) => (typeof a === "number" ? a : a?.value), FlowGraphBlockNames.IntToFloat, config);
     }
 }
 

packages/dev/core/src/FlowGraph/Blocks/Data/Utils/flowGraphArrayIndexBlock.ts

@@ -44,7 +44,27 @@ export class FlowGraphArrayIndexBlock<T = any> extends FlowGraphBlock {
      */
     public override _updateOutputs(context: FlowGraphContext): void {
         const array = this.array.getValue(context);
-        const index = getNumericValue(this.index.getValue(context));
+        const rawIndex = this.index.getValue(context);
+        // KHR_interactivity opaque-reference values feed in here as JSON-Pointer
+        // ref strings (e.g. "/animations/0/") instead of plain integers. Extract
+        // the trailing numeric segment as the index in that case. Undefined /
+        // unconnected inputs short-circuit to a null output instead of crashing
+        // ``getNumericValue`` on a missing ``.value`` property.
+        let index: number;
+        if (rawIndex === undefined || rawIndex === null) {
+            this.value.setValue(null, context);
+            return;
+        }
+        if (typeof rawIndex === "string") {
+            const parsed = _ParseRefIndex(rawIndex);
+            if (parsed === undefined) {
+                this.value.setValue(null, context);
+                return;
+            }
+            index = parsed;
+        } else {
+            index = getNumericValue(rawIndex);
+        }
         if (array && index >= 0 && index < array.length) {
             this.value.setValue(array[index], context);
         } else {
@@ -66,3 +86,28 @@ export class FlowGraphArrayIndexBlock<T = any> extends FlowGraphBlock {
 }
 
 RegisterClass(FlowGraphBlockNames.ArrayIndex, FlowGraphArrayIndexBlock);
+
+/**
+ * Extract the trailing numeric segment from a JSON-Pointer-shaped ref string,
+ * e.g. ``/animations/0/`` → 0, ``/nodes/12`` → 12. Returns ``undefined`` if the
+ * string does not match the expected ``/<container>/<index>(/?)`` shape.
+ * @param ref the ref string to parse.
+ * @returns the trailing integer segment, or ``undefined`` when the input is
+ *          not a JSON-Pointer-shaped ref ending in an integer.
+ */
+function _ParseRefIndex(ref: string): number | undefined {
+    if (ref.length === 0 || ref[0] !== "/") {
+        return undefined;
+    }
+    const trimmed = ref.endsWith("/") ? ref.slice(0, -1) : ref;
+    const lastSlash = trimmed.lastIndexOf("/");
+    if (lastSlash < 0) {
+        return undefined;
+    }
+    const tail = trimmed.substring(lastSlash + 1);
+    if (tail.length === 0) {
+        return undefined;
+    }
+    const parsed = Number(tail);
+    return Number.isFinite(parsed) && Number.isInteger(parsed) ? parsed : undefined;
+}

packages/dev/core/src/FlowGraph/Blocks/Event/flowGraphReceiveCustomEventBlock.ts

@@ -47,7 +47,8 @@ export class FlowGraphReceiveCustomEventBlock extends FlowGraphEventBlock {
             const typeKey = typeof entry.type === "string" ? entry.type : entry.type?.typeName;
             const richType = typeof entry.type?.serialize === "function" ? entry.type : getRichTypeByFlowGraphType(typeKey);
             entry.type = richType;
-            this.registerDataOutput(key, richType);
+            // Pass default value from event data schema so outputs have the correct initial value
+            this.registerDataOutput(key, richType, (entry as any).value);
         }
     }
 

packages/dev/core/src/FlowGraph/Blocks/Execution/Animation/flowGraphPlayAnimationBlock.ts

@@ -126,6 +126,31 @@ export class FlowGraphPlayAnimationBlock extends FlowGraphAsyncExecutionBlock {
             const from = this.from.getValue(context) ?? 0;
             // not accepting 0
             const to = this.to.getValue(context) || animationGroupToUse.to;
+
+            // Validate duration for interpolation animations: non-finite or negative values trigger the error flow.
+            // Only validate when animation is provided (interpolation case), not for general animation/start
+            // where the AnimationGroup's default to value may legitimately be negative.
+            if (!isFinite(to) || !isFinite(from)) {
+                return this._reportError(context, "Invalid animation duration");
+            }
+            if (animation && to < 0) {
+                return this._reportError(context, "Invalid animation duration");
+            }
+
+            // Validate easing function: NaN bezier control points trigger the error flow
+            if (animation) {
+                const animationsArray = Array.isArray(animation) ? animation : [animation];
+                for (const anim of animationsArray) {
+                    const easing = anim.getEasingFunction?.();
+                    if (easing && "x1" in easing) {
+                        const bezier = easing as unknown as { x1: number; y1: number; x2: number; y2: number };
+                        if (isNaN(bezier.x1) || isNaN(bezier.y1) || isNaN(bezier.x2) || isNaN(bezier.y2)) {
+                            return this._reportError(context, "Invalid bezier curve control points");
+                        }
+                    }
+                }
+            }
+
             const loop = !isFinite(to) || this.loop.getValue(context);
             this.currentAnimationGroup.setValue(animationGroupToUse, context);
 

packages/dev/core/src/FlowGraph/Blocks/flowGraphBlockFactory.ts

@@ -96,6 +96,8 @@ export function blockFactory(blockName: FlowGraphBlockNames | string): () => Pro
             return async () => (await import("./Data/Math/flowGraphMathBlocks")).FlowGraphSaturateBlock;
         case FlowGraphBlockNames.MathInterpolation:
             return async () => (await import("./Data/Math/flowGraphMathBlocks")).FlowGraphMathInterpolationBlock;
+        case FlowGraphBlockNames.MathSlerp:
+            return async () => (await import("./Data/Math/flowGraphMathBlocks")).FlowGraphMathSlerpBlock;
         case FlowGraphBlockNames.Equality:
             return async () => (await import("./Data/Math/flowGraphMathBlocks")).FlowGraphEqualityBlock;
         case FlowGraphBlockNames.LessThan:

packages/dev/core/src/FlowGraph/Blocks/flowGraphBlockNames.ts

@@ -44,6 +44,7 @@ export const enum FlowGraphBlockNames {
     Clamp = "FlowGraphClampBlock",
     Saturate = "FlowGraphSaturateBlock",
     MathInterpolation = "FlowGraphMathInterpolationBlock",
+    MathSlerp = "FlowGraphMathSlerpBlock",
     Equality = "FlowGraphEqualityBlock",
     LessThan = "FlowGraphLessThanBlock",
     LessThanOrEqual = "FlowGraphLessThanOrEqualBlock",