@vived/component-abb-6700 1.0.0

package/dist/flowGraphMathCombineExtractBlocks-QSjGlnoz.js

@@ -0,0 +1,248 @@
+import { F } from "./flowGraphCachedOperationBlock-CP1ZiuIB.js";
+import { aR as l, V as n, aQ as h, U as g, aP as o, ad as V, aX as c, bg as _, aW as D, bf as I, aV as w, be as d, O as G, aS as m, aK as i } from "./index-CS3Icp_r.js";
+class p extends F {
+  /**
+   * Base class for blocks that combine multiple numeric inputs into a single result.
+   * Handles registering data inputs and managing cached outputs.
+   * @param numberOfInputs The number of input values to combine.
+   * @param type The type of the result.
+   * @param config The block configuration.
+   */
+  constructor(t, a, e) {
+    super(a, e);
+    for (let s = 0; s < t; s++)
+      this.registerDataInput(`input_${s}`, m, 0);
+  }
+}
+class r extends G {
+  /**
+   * Creates an instance of FlowGraphMathExtractBlock.
+   *
+   * @param numberOfOutputs - The number of outputs to be extracted from the input.
+   * @param type - The type of the input data.
+   * @param config - Optional configuration for the flow graph block.
+   */
+  constructor(t, a, e) {
+    super(e), this.registerDataInput("input", a);
+    for (let s = 0; s < t; s++)
+      this.registerDataOutput(`output_${s}`, m, 0);
+  }
+}
+class b extends p {
+  constructor(t) {
+    super(2, w, t);
+  }
+  /**
+   * @internal
+   * Combines two floats into a new Vector2
+   */
+  _doOperation(t) {
+    t._hasExecutionVariable(this, "cachedVector") || t._setExecutionVariable(this, "cachedVector", new d());
+    const a = t._getExecutionVariable(this, "cachedVector", null);
+    return a.set(this.getDataInput("input_0").getValue(t), this.getDataInput("input_1").getValue(t)), a;
+  }
+  getClassName() {
+    return "FlowGraphCombineVector2Block";
+  }
+}
+i("FlowGraphCombineVector2Block", b);
+class k extends p {
+  constructor(t) {
+    super(3, D, t);
+  }
+  _doOperation(t) {
+    t._hasExecutionVariable(this, "cachedVector") || t._setExecutionVariable(this, "cachedVector", new I());
+    const a = t._getExecutionVariable(this, "cachedVector", null);
+    return a.set(this.getDataInput("input_0").getValue(t), this.getDataInput("input_1").getValue(t), this.getDataInput("input_2").getValue(t)), a;
+  }
+  getClassName() {
+    return "FlowGraphCombineVector3Block";
+  }
+}
+i("FlowGraphCombineVector3Block", k);
+class B extends p {
+  constructor(t) {
+    super(4, c, t);
+  }
+  _doOperation(t) {
+    t._hasExecutionVariable(this, "cachedVector") || t._setExecutionVariable(this, "cachedVector", new _());
+    const a = t._getExecutionVariable(this, "cachedVector", null);
+    return a.set(this.getDataInput("input_0").getValue(t), this.getDataInput("input_1").getValue(t), this.getDataInput("input_2").getValue(t), this.getDataInput("input_3").getValue(t)), a;
+  }
+  getClassName() {
+    return "FlowGraphCombineVector4Block";
+  }
+}
+i("FlowGraphCombineVector4Block", B);
+class M extends p {
+  constructor(t) {
+    super(16, o, t);
+  }
+  _doOperation(t) {
+    t._hasExecutionVariable(this, "cachedMatrix") || t._setExecutionVariable(this, "cachedMatrix", new V());
+    const a = t._getExecutionVariable(this, "cachedMatrix", null);
+    return this.config?.inputIsColumnMajor ? a.set(this.getDataInput("input_0").getValue(t), this.getDataInput("input_4").getValue(t), this.getDataInput("input_8").getValue(t), this.getDataInput("input_12").getValue(t), this.getDataInput("input_1").getValue(t), this.getDataInput("input_5").getValue(t), this.getDataInput("input_9").getValue(t), this.getDataInput("input_13").getValue(t), this.getDataInput("input_2").getValue(t), this.getDataInput("input_6").getValue(t), this.getDataInput("input_10").getValue(t), this.getDataInput("input_14").getValue(t), this.getDataInput("input_3").getValue(t), this.getDataInput("input_7").getValue(t), this.getDataInput("input_11").getValue(t), this.getDataInput("input_15").getValue(t)) : a.set(this.getDataInput("input_0").getValue(t), this.getDataInput("input_1").getValue(t), this.getDataInput("input_2").getValue(t), this.getDataInput("input_3").getValue(t), this.getDataInput("input_4").getValue(t), this.getDataInput("input_5").getValue(t), this.getDataInput("input_6").getValue(t), this.getDataInput("input_7").getValue(t), this.getDataInput("input_8").getValue(t), this.getDataInput("input_9").getValue(t), this.getDataInput("input_10").getValue(t), this.getDataInput("input_11").getValue(t), this.getDataInput("input_12").getValue(t), this.getDataInput("input_13").getValue(t), this.getDataInput("input_14").getValue(t), this.getDataInput("input_15").getValue(t)), a;
+  }
+  getClassName() {
+    return "FlowGraphCombineMatrixBlock";
+  }
+}
+i("FlowGraphCombineMatrixBlock", M);
+class E extends p {
+  constructor(t) {
+    super(4, h, t);
+  }
+  _doOperation(t) {
+    t._hasExecutionVariable(this, "cachedMatrix") || t._setExecutionVariable(this, "cachedMatrix", new g());
+    const a = t._getExecutionVariable(this, "cachedMatrix", null), e = this.config?.inputIsColumnMajor ? [
+      // column to row-major
+      this.getDataInput("input_0").getValue(t),
+      this.getDataInput("input_2").getValue(t),
+      this.getDataInput("input_1").getValue(t),
+      this.getDataInput("input_3").getValue(t)
+    ] : [
+      this.getDataInput("input_0").getValue(t),
+      this.getDataInput("input_1").getValue(t),
+      this.getDataInput("input_2").getValue(t),
+      this.getDataInput("input_3").getValue(t)
+    ];
+    return a.fromArray(e), a;
+  }
+  getClassName() {
+    return "FlowGraphCombineMatrix2DBlock";
+  }
+}
+i("FlowGraphCombineMatrix2DBlock", E);
+class C extends p {
+  constructor(t) {
+    super(9, l, t);
+  }
+  _doOperation(t) {
+    t._hasExecutionVariable(this, "cachedMatrix") || t._setExecutionVariable(this, "cachedMatrix", new n());
+    const a = t._getExecutionVariable(this, "cachedMatrix", null), e = this.config?.inputIsColumnMajor ? [
+      // column to row major
+      this.getDataInput("input_0").getValue(t),
+      this.getDataInput("input_3").getValue(t),
+      this.getDataInput("input_6").getValue(t),
+      this.getDataInput("input_1").getValue(t),
+      this.getDataInput("input_4").getValue(t),
+      this.getDataInput("input_7").getValue(t),
+      this.getDataInput("input_2").getValue(t),
+      this.getDataInput("input_5").getValue(t),
+      this.getDataInput("input_8").getValue(t)
+    ] : [
+      this.getDataInput("input_0").getValue(t),
+      this.getDataInput("input_1").getValue(t),
+      this.getDataInput("input_2").getValue(t),
+      this.getDataInput("input_3").getValue(t),
+      this.getDataInput("input_4").getValue(t),
+      this.getDataInput("input_5").getValue(t),
+      this.getDataInput("input_6").getValue(t),
+      this.getDataInput("input_7").getValue(t),
+      this.getDataInput("input_8").getValue(t)
+    ];
+    return a.fromArray(e), a;
+  }
+  getClassName() {
+    return "FlowGraphCombineMatrix3DBlock";
+  }
+}
+i("FlowGraphCombineMatrix3DBlock", C);
+class O extends r {
+  constructor(t) {
+    super(2, w, t);
+  }
+  _updateOutputs(t) {
+    let a = this.getDataInput("input")?.getValue(t);
+    a || (a = d.Zero(), this.getDataInput("input").setValue(a, t)), this.getDataOutput("output_0").setValue(a.x, t), this.getDataOutput("output_1").setValue(a.y, t);
+  }
+  getClassName() {
+    return "FlowGraphExtractVector2Block";
+  }
+}
+i("FlowGraphExtractVector2Block", O);
+class f extends r {
+  constructor(t) {
+    super(3, D, t);
+  }
+  _updateOutputs(t) {
+    let a = this.getDataInput("input")?.getValue(t);
+    a || (a = I.Zero(), this.getDataInput("input").setValue(a, t)), this.getDataOutput("output_0").setValue(a.x, t), this.getDataOutput("output_1").setValue(a.y, t), this.getDataOutput("output_2").setValue(a.z, t);
+  }
+  getClassName() {
+    return "FlowGraphExtractVector3Block";
+  }
+}
+i("FlowGraphExtractVector3Block", f);
+class y extends r {
+  constructor(t) {
+    super(4, c, t);
+  }
+  _updateOutputs(t) {
+    let a = this.getDataInput("input")?.getValue(t);
+    a || (a = _.Zero(), this.getDataInput("input").setValue(a, t)), this.getDataOutput("output_0").setValue(a.x, t), this.getDataOutput("output_1").setValue(a.y, t), this.getDataOutput("output_2").setValue(a.z, t), this.getDataOutput("output_3").setValue(a.w, t);
+  }
+  getClassName() {
+    return "FlowGraphExtractVector4Block";
+  }
+}
+i("FlowGraphExtractVector4Block", y);
+class N extends r {
+  constructor(t) {
+    super(16, o, t);
+  }
+  _updateOutputs(t) {
+    let a = this.getDataInput("input")?.getValue(t);
+    a || (a = V.Identity(), this.getDataInput("input").setValue(a, t));
+    for (let e = 0; e < 16; e++)
+      this.getDataOutput(`output_${e}`).setValue(a.m[e], t);
+  }
+  getClassName() {
+    return "FlowGraphExtractMatrixBlock";
+  }
+}
+i("FlowGraphExtractMatrixBlock", N);
+class R extends r {
+  constructor(t) {
+    super(4, h, t);
+  }
+  _updateOutputs(t) {
+    let a = this.getDataInput("input")?.getValue(t);
+    a || (a = new g(), this.getDataInput("input").setValue(a, t));
+    for (let e = 0; e < 4; e++)
+      this.getDataOutput(`output_${e}`).setValue(a.m[e], t);
+  }
+  getClassName() {
+    return "FlowGraphExtractMatrix2DBlock";
+  }
+}
+i("FlowGraphExtractMatrix2DBlock", R);
+class T extends r {
+  constructor(t) {
+    super(9, l, t);
+  }
+  _updateOutputs(t) {
+    let a = this.getDataInput("input")?.getValue(t);
+    a || (a = new n(), this.getDataInput("input").setValue(a, t));
+    for (let e = 0; e < 9; e++)
+      this.getDataOutput(`output_${e}`).setValue(a.m[e], t);
+  }
+  getClassName() {
+    return "FlowGraphExtractMatrix3DBlock";
+  }
+}
+i("FlowGraphExtractMatrix3DBlock", T);
+export {
+  E as FlowGraphCombineMatrix2DBlock,
+  C as FlowGraphCombineMatrix3DBlock,
+  M as FlowGraphCombineMatrixBlock,
+  b as FlowGraphCombineVector2Block,
+  k as FlowGraphCombineVector3Block,
+  B as FlowGraphCombineVector4Block,
+  R as FlowGraphExtractMatrix2DBlock,
+  T as FlowGraphExtractMatrix3DBlock,
+  N as FlowGraphExtractMatrixBlock,
+  O as FlowGraphExtractVector2Block,
+  f as FlowGraphExtractVector3Block,
+  y as FlowGraphExtractVector4Block
+};

package/dist/flowGraphMatrixMathBlocks-B3D7Cz9p.js

@@ -0,0 +1,117 @@
+import { O as M, aW as u, aT as g, aP as w, ad as m, aN as I, bf as n, aJ as x, bW as e, aS as k, aK as r } from "./index-CS3Icp_r.js";
+import { F as V } from "./flowGraphUnaryOperationBlock-B0Shf-lJ.js";
+import { F as b } from "./flowGraphBinaryOperationBlock-Bj7TANCc.js";
+class D extends V {
+  /**
+   * Creates a new instance of the block.
+   * @param config the configuration of the block
+   */
+  constructor(t) {
+    super(e(
+      t?.matrixType || "Matrix"
+      /* FlowGraphTypes.Matrix */
+    ), e(
+      t?.matrixType || "Matrix"
+      /* FlowGraphTypes.Matrix */
+    ), (a) => a.transpose ? a.transpose() : m.Transpose(a), "FlowGraphTransposeBlock", t);
+  }
+}
+r("FlowGraphTransposeBlock", D);
+class E extends V {
+  /**
+   * Creates a new instance of the block.
+   * @param config the configuration of the block
+   */
+  constructor(t) {
+    super(e(
+      t?.matrixType || "Matrix"
+      /* FlowGraphTypes.Matrix */
+    ), k, (a) => a.determinant(), "FlowGraphDeterminantBlock", t);
+  }
+}
+r("FlowGraphDeterminantBlock", E);
+class _ extends V {
+  /**
+   * Creates a new instance of the inverse block.
+   * @param config the configuration of the block
+   */
+  constructor(t) {
+    super(e(
+      t?.matrixType || "Matrix"
+      /* FlowGraphTypes.Matrix */
+    ), e(
+      t?.matrixType || "Matrix"
+      /* FlowGraphTypes.Matrix */
+    ), (a) => a.inverse ? a.inverse() : m.Invert(a), "FlowGraphInvertMatrixBlock", t);
+  }
+}
+r("FlowGraphInvertMatrixBlock", _);
+class v extends b {
+  /**
+   * Creates a new instance of the multiplication block.
+   * Note - this is similar to the math multiplication if not using matrix per-component multiplication.
+   * @param config the configuration of the block
+   */
+  constructor(t) {
+    super(e(
+      t?.matrixType || "Matrix"
+      /* FlowGraphTypes.Matrix */
+    ), e(
+      t?.matrixType || "Matrix"
+      /* FlowGraphTypes.Matrix */
+    ), e(
+      t?.matrixType || "Matrix"
+      /* FlowGraphTypes.Matrix */
+    ), (a, i) => i.multiply(a), "FlowGraphMatrixMultiplicationBlock", t);
+  }
+}
+r("FlowGraphMatrixMultiplicationBlock", v);
+class O extends M {
+  constructor(t) {
+    super(t), this.input = this.registerDataInput("input", w), this.position = this.registerDataOutput("position", u), this.rotationQuaternion = this.registerDataOutput("rotationQuaternion", g), this.scaling = this.registerDataOutput("scaling", u), this.isValid = this.registerDataOutput("isValid", I, !1);
+  }
+  _updateOutputs(t) {
+    const a = t._getExecutionVariable(this, "executionId", -1), i = t._getExecutionVariable(this, "cachedPosition", null), s = t._getExecutionVariable(this, "cachedRotation", null), h = t._getExecutionVariable(this, "cachedScaling", null);
+    if (a === t.executionId && i && s && h)
+      this.position.setValue(i, t), this.rotationQuaternion.setValue(s, t), this.scaling.setValue(h, t);
+    else {
+      const l = this.input.getValue(t), p = i || new n(), c = s || new x(), d = h || new n(), F = Math.round(l.m[3] * 1e4) / 1e4, G = Math.round(l.m[7] * 1e4) / 1e4, y = Math.round(l.m[11] * 1e4) / 1e4, B = Math.round(l.m[15] * 1e4) / 1e4;
+      if (F !== 0 || G !== 0 || y !== 0 || B !== 1) {
+        this.isValid.setValue(!1, t), this.position.setValue(n.Zero(), t), this.rotationQuaternion.setValue(x.Identity(), t), this.scaling.setValue(n.One(), t);
+        return;
+      }
+      const T = l.decompose(d, c, p);
+      this.isValid.setValue(T, t), this.position.setValue(p, t), this.rotationQuaternion.setValue(c, t), this.scaling.setValue(d, t), t._setExecutionVariable(this, "cachedPosition", p), t._setExecutionVariable(this, "cachedRotation", c), t._setExecutionVariable(this, "cachedScaling", d), t._setExecutionVariable(this, "executionId", t.executionId);
+    }
+  }
+  getClassName() {
+    return "FlowGraphMatrixDecompose";
+  }
+}
+r("FlowGraphMatrixDecompose", O);
+class Q extends M {
+  constructor(t) {
+    super(t), this.position = this.registerDataInput("position", u), this.rotationQuaternion = this.registerDataInput("rotationQuaternion", g), this.scaling = this.registerDataInput("scaling", u), this.value = this.registerDataOutput("value", w);
+  }
+  _updateOutputs(t) {
+    const a = t._getExecutionVariable(this, "executionId", -1), i = t._getExecutionVariable(this, "cachedMatrix", null);
+    if (a === t.executionId && i)
+      this.value.setValue(i, t);
+    else {
+      const s = m.Compose(this.scaling.getValue(t), this.rotationQuaternion.getValue(t), this.position.getValue(t));
+      this.value.setValue(s, t), t._setExecutionVariable(this, "cachedMatrix", s), t._setExecutionVariable(this, "executionId", t.executionId);
+    }
+  }
+  getClassName() {
+    return "FlowGraphMatrixCompose";
+  }
+}
+r("FlowGraphMatrixCompose", Q);
+export {
+  E as FlowGraphDeterminantBlock,
+  _ as FlowGraphInvertMatrixBlock,
+  Q as FlowGraphMatrixComposeBlock,
+  O as FlowGraphMatrixDecomposeBlock,
+  v as FlowGraphMatrixMultiplicationBlock,
+  D as FlowGraphTransposeBlock
+};

package/dist/flowGraphMeshPickEventBlock-BBTz-taa.js

@@ -0,0 +1,35 @@
+import { Q as p, aM as r, aW as a, aS as h, aj as n, bp as u, aK as c } from "./index-CS3Icp_r.js";
+class o extends p {
+  constructor(e) {
+    super(e), this.config = e, this.type = "MeshPick", this.asset = this.registerDataInput("asset", r, e?.targetMesh), this.pickedPoint = this.registerDataOutput("pickedPoint", a), this.pickOrigin = this.registerDataOutput("pickOrigin", a), this.pointerId = this.registerDataOutput("pointerId", h), this.pickedMesh = this.registerDataOutput("pickedMesh", r), this.pointerType = this.registerDataInput("pointerType", r, n.POINTERPICK);
+  }
+  _getReferencedMesh(e) {
+    return this.asset.getValue(e);
+  }
+  _executeEvent(e, s) {
+    if (this.pointerType.getValue(e) !== s.type)
+      return !0;
+    const i = this._getReferencedMesh(e), t = s.pickInfo?.pickedMesh;
+    return (i ? !!(t && (t === i || u(t, i) || t.name === i.name)) : !!t) && t ? (this.pointerId.setValue(s.event.pointerId, e), this.pickOrigin.setValue(s.pickInfo.ray?.origin, e), this.pickedPoint.setValue(s.pickInfo.pickedPoint, e), this.pickedMesh.setValue(t, e), this._execute(e), !this.config?.stopPropagation) : (this.pointerId.resetToDefaultValue(e), this.pickOrigin.resetToDefaultValue(e), this.pickedPoint.resetToDefaultValue(e), this.pickedMesh.resetToDefaultValue(e), !0);
+  }
+  /**
+   * @internal
+   */
+  _preparePendingTasks(e) {
+  }
+  /**
+   * @internal
+   */
+  _cancelPendingTasks(e) {
+  }
+  /**
+   * @returns class name of the block.
+   */
+  getClassName() {
+    return "FlowGraphMeshPickEventBlock";
+  }
+}
+c("FlowGraphMeshPickEventBlock", o);
+export {
+  o as FlowGraphMeshPickEventBlock
+};

package/dist/flowGraphMultiGateBlock-BhY1y5BG.js

@@ -0,0 +1,50 @@
+import { R as a, aO as l, T as n, aK as u } from "./index-CS3Icp_r.js";
+class o extends a {
+  constructor(t) {
+    super(t), this.config = t, this.outputSignals = [], this.reset = this._registerSignalInput("reset"), this.lastIndex = this.registerDataOutput("lastIndex", l, new n(-1)), this.setNumberOfOutputSignals(t?.outputSignalCount);
+  }
+  _getNextIndex(t) {
+    if (t.includes(!1) || this.config.isLoop && t.fill(!1), this.config.isRandom) {
+      const e = t.map((s, i) => s ? -1 : i).filter((s) => s !== -1);
+      return e.length ? e[Math.floor(Math.random() * e.length)] : -1;
+    } else
+      return t.indexOf(!1);
+  }
+  /**
+   * Sets the block's output signals. Would usually be passed from the constructor but can be changed afterwards.
+   * @param numberOutputSignals the number of output flows
+   */
+  setNumberOfOutputSignals(t = 1) {
+    for (; this.outputSignals.length > t; ) {
+      const e = this.outputSignals.pop();
+      e && (e.disconnectFromAll(), this._unregisterSignalOutput(e.name));
+    }
+    for (; this.outputSignals.length < t; )
+      this.outputSignals.push(this._registerSignalOutput(`out_${this.outputSignals.length}`));
+  }
+  _execute(t, e) {
+    if (t._hasExecutionVariable(this, "indexesUsed") || t._setExecutionVariable(this, "indexesUsed", this.outputSignals.map(() => !1)), e === this.reset) {
+      t._deleteExecutionVariable(this, "indexesUsed"), this.lastIndex.setValue(new n(-1), t);
+      return;
+    }
+    const s = t._getExecutionVariable(this, "indexesUsed", []), i = this._getNextIndex(s);
+    i > -1 && (this.lastIndex.setValue(new n(i), t), s[i] = !0, t._setExecutionVariable(this, "indexesUsed", s), this.outputSignals[i]._activateSignal(t));
+  }
+  /**
+   * @returns class name of the block.
+   */
+  getClassName() {
+    return "FlowGraphMultiGateBlock";
+  }
+  /**
+   * Serializes the block.
+   * @param serializationObject the object to serialize to.
+   */
+  serialize(t) {
+    super.serialize(t), t.config.outputSignalCount = this.config.outputSignalCount, t.config.isRandom = this.config.isRandom, t.config.loop = this.config.isLoop, t.config.startIndex = this.config.startIndex;
+  }
+}
+u("FlowGraphMultiGateBlock", o);
+export {
+  o as FlowGraphMultiGateBlock
+};

package/dist/flowGraphPauseAnimationBlock-CHZZXMbg.js

@@ -0,0 +1,19 @@
+import { S as t, aM as e, aK as i } from "./index-CS3Icp_r.js";
+class o extends t {
+  constructor(a) {
+    super(a), this.animationToPause = this.registerDataInput("animationToPause", e);
+  }
+  _execute(a) {
+    this.animationToPause.getValue(a).pause(), this.out._activateSignal(a);
+  }
+  /**
+   * @returns class name of the block.
+   */
+  getClassName() {
+    return "FlowGraphPauseAnimationBlock";
+  }
+}
+i("FlowGraphPauseAnimationBlock", o);
+export {
+  o as FlowGraphPauseAnimationBlock
+};

package/dist/flowGraphPauseSoundBlock-B7hMmJ0c.js

@@ -0,0 +1,31 @@
+import { S as e, aM as t, aK as o } from "./index-CS3Icp_r.js";
+class u extends e {
+  /**
+   * Constructs a new FlowGraphPauseSoundBlock.
+   * @param config - optional configuration for the block
+   */
+  constructor(s) {
+    super(s), this.sound = this.registerDataInput("sound", t);
+  }
+  /**
+   * @internal
+   */
+  _execute(s, i) {
+    const a = this.sound.getValue(s);
+    if (!a) {
+      this._reportError(s, "No sound provided"), this.out._activateSignal(s);
+      return;
+    }
+    a.state === 5 ? a.resume() : (a.state === 2 || a.state === 3) && a.pause(), this.out._activateSignal(s);
+  }
+  /**
+   * @returns class name of the block.
+   */
+  getClassName() {
+    return "FlowGraphPauseSoundBlock";
+  }
+}
+o("FlowGraphPauseSoundBlock", u);
+export {
+  u as FlowGraphPauseSoundBlock
+};

package/dist/flowGraphPhysicsCollisionEventBlock-CxoPpT-q.js

@@ -0,0 +1,56 @@
+import { Q as a, aM as l, aW as o, aS as r, aK as h } from "./index-CS3Icp_r.js";
+class n extends a {
+  /**
+   * Constructs a new FlowGraphPhysicsCollisionEventBlock.
+   * @param config - optional configuration for the block
+   */
+  constructor(s) {
+    super(s), this.config = s, this.body = this.registerDataInput("body", l), this.otherBody = this.registerDataOutput("otherBody", l), this.point = this.registerDataOutput("point", o), this.normal = this.registerDataOutput("normal", o), this.impulse = this.registerDataOutput("impulse", r), this.distance = this.registerDataOutput("distance", r);
+  }
+  /**
+   * @internal
+   */
+  _preparePendingTasks(s) {
+    const i = this.body.getValue(s);
+    if (!i) {
+      this._reportError(s, "No physics body provided for collision event");
+      return;
+    }
+    i.setCollisionCallbackEnabled(!0);
+    const e = i.getCollisionObservable().add((t) => {
+      this._onCollision(s, t);
+    });
+    s._setExecutionVariable(this, "_collisionObserver", e), s._setExecutionVariable(this, "_subscribedBody", i);
+  }
+  _onCollision(s, i) {
+    const e = this.body.getValue(s), t = i.collider === e ? i.collidedAgainst : i.collider;
+    this.otherBody.setValue(t, s), i.point && this.point.setValue(i.point, s), i.normal && this.normal.setValue(i.normal, s), this.impulse.setValue(i.impulse, s), this.distance.setValue(i.distance, s), this._execute(s);
+  }
+  /**
+   * @internal
+   */
+  _executeEvent(s, i) {
+    return !0;
+  }
+  /**
+   * @internal
+   */
+  _cancelPendingTasks(s) {
+    const i = s._getExecutionVariable(this, "_collisionObserver", null), e = s._getExecutionVariable(this, "_subscribedBody", null);
+    if (i && e) {
+      const t = e.getCollisionObservable();
+      t.remove(i), t.hasObservers() || e.setCollisionCallbackEnabled(!1);
+    }
+    s._setExecutionVariable(this, "_collisionObserver", null), s._setExecutionVariable(this, "_subscribedBody", null);
+  }
+  /**
+   * @returns class name of the block.
+   */
+  getClassName() {
+    return "FlowGraphPhysicsCollisionEventBlock";
+  }
+}
+h("FlowGraphPhysicsCollisionEventBlock", n);
+export {
+  n as FlowGraphPhysicsCollisionEventBlock
+};

package/dist/flowGraphPlayAnimationBlock-DVAvIFux.js

@@ -0,0 +1,99 @@
+import { N as f, aS as u, aN as _, aM as l, aK as b } from "./index-CS3Icp_r.js";
+import { AnimationGroup as y } from "./animationGroup-BhNThqQe.js";
+class V extends f {
+  constructor(i) {
+    super(i, ["animationLoop", "animationEnd", "animationGroupLoop"]), this.config = i, this.speed = this.registerDataInput("speed", u), this.loop = this.registerDataInput("loop", _), this.from = this.registerDataInput("from", u, 0), this.to = this.registerDataInput("to", u), this.currentFrame = this.registerDataOutput("currentFrame", u), this.currentTime = this.registerDataOutput("currentTime", u), this.currentAnimationGroup = this.registerDataOutput("currentAnimationGroup", l), this.animationGroup = this.registerDataInput("animationGroup", l, i?.animationGroup), this.animation = this.registerDataInput("animation", l), this.object = this.registerDataInput("object", l);
+  }
+  /**
+   * @internal
+   * @param context
+   */
+  _preparePendingTasks(i) {
+    const t = this.animationGroup.getValue(i), r = this.animation.getValue(i);
+    if (!t && !r)
+      return this._reportError(i, "No animation or animation group provided");
+    {
+      const a = this.currentAnimationGroup.getValue(i);
+      a && a !== t && a.dispose();
+      let n = t;
+      if (r && !n) {
+        const o = this.object.getValue(i);
+        if (!o)
+          return this._reportError(i, "No target object provided");
+        const h = Array.isArray(r) ? r : [r], G = h[0].name;
+        n = new y("flowGraphAnimationGroup-" + G + "-" + o.name, i.configuration.scene);
+        let g = !1;
+        const A = i._getGlobalContextVariable("interpolationAnimations", []);
+        for (const c of h)
+          n.addTargetedAnimation(c, o), A.indexOf(c.uniqueId) !== -1 && (g = !0);
+        g && this._checkInterpolationDuplications(i, h, o);
+      }
+      const s = this.speed.getValue(i) || 1, e = this.from.getValue(i) ?? 0, p = this.to.getValue(i) || n.to, d = !isFinite(p) || this.loop.getValue(i);
+      this.currentAnimationGroup.setValue(n, i);
+      const m = i._getGlobalContextVariable("currentlyRunningAnimationGroups", []);
+      m.indexOf(n.uniqueId) !== -1 && n.stop();
+      try {
+        n.start(d, s, e, p), n.onAnimationGroupEndObservable.add(() => this._onAnimationGroupEnd(i)), n.onAnimationEndObservable.add(() => this._eventsSignalOutputs.animationEnd._activateSignal(i)), n.onAnimationLoopObservable.add(() => this._eventsSignalOutputs.animationLoop._activateSignal(i)), n.onAnimationGroupLoopObservable.add(() => this._eventsSignalOutputs.animationGroupLoop._activateSignal(i)), m.push(n.uniqueId), i._setGlobalContextVariable("currentlyRunningAnimationGroups", m);
+      } catch (o) {
+        this._reportError(i, o);
+      }
+    }
+  }
+  _reportError(i, t) {
+    super._reportError(i, t), this.currentFrame.setValue(-1, i), this.currentTime.setValue(-1, i);
+  }
+  /**
+   * @internal
+   */
+  _executeOnTick(i) {
+    const t = this.currentAnimationGroup.getValue(i);
+    t && (this.currentFrame.setValue(t.getCurrentFrame(), i), this.currentTime.setValue(t.animatables[0]?.elapsedTime ?? 0, i));
+  }
+  _execute(i) {
+    this._startPendingTasks(i);
+  }
+  _onAnimationGroupEnd(i) {
+    this._removeFromCurrentlyRunning(i, this.currentAnimationGroup.getValue(i)), this._resetAfterCanceled(i), this.done._activateSignal(i);
+  }
+  /**
+   * The idea behind this function is to check every running animation group and check if the targeted animations it uses are interpolation animations.
+   * If they are, we want to see that they don't collide with the current interpolation animations that are starting to play.
+   * If they do, we want to stop the already-running animation group.
+   * @internal
+   */
+  _checkInterpolationDuplications(i, t, r) {
+    const a = i._getGlobalContextVariable("currentlyRunningAnimationGroups", []);
+    for (const n of a) {
+      const s = i.assetsContext.animationGroups.find((e) => e.uniqueId === n);
+      if (s)
+        for (const e of s.targetedAnimations)
+          for (const p of t)
+            e.animation.targetProperty === p.targetProperty && e.target === r && this._stopAnimationGroup(i, s);
+    }
+  }
+  _stopAnimationGroup(i, t) {
+    t.stop(!0), t.name.startsWith("flowGraphAnimationGroup-") && t.dispose(), this._removeFromCurrentlyRunning(i, t);
+  }
+  _removeFromCurrentlyRunning(i, t) {
+    const r = i._getGlobalContextVariable("currentlyRunningAnimationGroups", []), a = r.indexOf(t.uniqueId);
+    a !== -1 && (r.splice(a, 1), i._setGlobalContextVariable("currentlyRunningAnimationGroups", r));
+  }
+  /**
+   * @internal
+   * Stop any currently running animations.
+   */
+  _cancelPendingTasks(i) {
+    const t = this.currentAnimationGroup.getValue(i);
+    t && this._stopAnimationGroup(i, t);
+  }
+  /**
+   * @returns class name of the block.
+   */
+  getClassName() {
+    return "FlowGraphPlayAnimationBlock";
+  }
+}
+b("FlowGraphPlayAnimationBlock", V);
+export {
+  V as FlowGraphPlayAnimationBlock
+};