@vived/component-abb-6700 1.0.0

package/dist/flowGraphPlaySoundBlock-DjHGrqbC.js

@@ -0,0 +1,32 @@
+import { S as i, aM as r, aS as a, aN as u, aK as h } from "./index-CS3Icp_r.js";
+class n extends i {
+  /**
+   * Constructs a new FlowGraphPlaySoundBlock.
+   * @param config - optional configuration for the block
+   */
+  constructor(t) {
+    super(t), this.sound = this.registerDataInput("sound", r), this.volume = this.registerDataInput("volume", a, 1), this.startOffset = this.registerDataInput("startOffset", a, 0), this.loop = this.registerDataInput("loop", u, !1);
+  }
+  /**
+   * @internal
+   */
+  _execute(t, g) {
+    const s = this.sound.getValue(t);
+    if (!s) {
+      this._reportError(t, "No sound provided"), this.out._activateSignal(t);
+      return;
+    }
+    const e = this.volume.getValue(t), o = this.startOffset.getValue(t), l = this.loop.getValue(t);
+    s.play({ volume: e, startOffset: o, loop: l }), this.out._activateSignal(t);
+  }
+  /**
+   * @returns class name of the block.
+   */
+  getClassName() {
+    return "FlowGraphPlaySoundBlock";
+  }
+}
+h("FlowGraphPlaySoundBlock", n);
+export {
+  n as FlowGraphPlaySoundBlock
+};

package/dist/flowGraphPointerDownEventBlock-qI-H0JST.js

@@ -0,0 +1,31 @@
+import { Q as a, aM as r, aS as n, bp as p, aK as h } from "./index-CS3Icp_r.js";
+class o extends a {
+  /**
+   * Creates a new FlowGraphPointerDownEventBlock.
+   * @param config optional configuration
+   */
+  constructor(e) {
+    super(e), this.type = "PointerDown", this.targetMesh = this.registerDataInput("targetMesh", r, e?.targetMesh), this.pointerId = this.registerDataOutput("pointerId", n), this.pickedMesh = this.registerDataOutput("pickedMesh", r), this.pickedPoint = this.registerDataOutput("pickedPoint", r);
+  }
+  /** @internal */
+  _executeEvent(e, s) {
+    const i = this.targetMesh.getValue(e), t = s.pickInfo?.pickedMesh;
+    return i && !(t === i || t && p(t, i)) ? !0 : (this.pointerId.setValue(s.event.pointerId, e), this.pickedMesh.setValue(t ?? null, e), this.pickedPoint.setValue(s.pickInfo?.pickedPoint ?? null, e), this._execute(e), !this.config?.stopPropagation);
+  }
+  /** @internal */
+  _preparePendingTasks(e) {
+  }
+  /** @internal */
+  _cancelPendingTasks(e) {
+  }
+  /**
+   * @returns the class name of the block.
+   */
+  getClassName() {
+    return "FlowGraphPointerDownEventBlock";
+  }
+}
+h("FlowGraphPointerDownEventBlock", o);
+export {
+  o as FlowGraphPointerDownEventBlock
+};

package/dist/flowGraphPointerMoveEventBlock-DAi4VUyy.js

@@ -0,0 +1,31 @@
+import { Q as a, aM as r, aS as n, bp as o, aK as h } from "./index-CS3Icp_r.js";
+class p extends a {
+  /**
+   * Creates a new FlowGraphPointerMoveEventBlock.
+   * @param config optional configuration
+   */
+  constructor(e) {
+    super(e), this.type = "PointerMove", this.targetMesh = this.registerDataInput("targetMesh", r, e?.targetMesh), this.pointerId = this.registerDataOutput("pointerId", n), this.meshUnderPointer = this.registerDataOutput("meshUnderPointer", r), this.pickedPoint = this.registerDataOutput("pickedPoint", r);
+  }
+  /** @internal */
+  _executeEvent(e, s) {
+    const i = this.targetMesh.getValue(e), t = s.pickInfo?.pickedMesh;
+    return i && !(t === i || t && o(t, i)) ? !0 : (this.pointerId.setValue(s.event.pointerId, e), this.meshUnderPointer.setValue(t ?? null, e), this.pickedPoint.setValue(s.pickInfo?.pickedPoint ?? null, e), this._execute(e), !this.config?.stopPropagation);
+  }
+  /** @internal */
+  _preparePendingTasks(e) {
+  }
+  /** @internal */
+  _cancelPendingTasks(e) {
+  }
+  /**
+   * @returns the class name of the block.
+   */
+  getClassName() {
+    return "FlowGraphPointerMoveEventBlock";
+  }
+}
+h("FlowGraphPointerMoveEventBlock", p);
+export {
+  p as FlowGraphPointerMoveEventBlock
+};

package/dist/flowGraphPointerOutEventBlock-CFtj68aC.js

@@ -0,0 +1,21 @@
+import { Q as n, aS as h, aM as r, bp as i, aK as a } from "./index-CS3Icp_r.js";
+class o extends n {
+  constructor(t) {
+    super(t), this.type = "PointerOut", this.pointerId = this.registerDataOutput("pointerId", h), this.targetMesh = this.registerDataInput("targetMesh", r, t?.targetMesh), this.meshOutOfPointer = this.registerDataOutput("meshOutOfPointer", r);
+  }
+  _executeEvent(t, e) {
+    const s = this.targetMesh.getValue(t);
+    return this.meshOutOfPointer.setValue(e.mesh, t), this.pointerId.setValue(e.pointerId, t), !(e.over && i(e.mesh, s)) && (e.mesh === s || i(e.mesh, s)) ? (this._execute(t), !this.config?.stopPropagation) : !0;
+  }
+  _preparePendingTasks(t) {
+  }
+  _cancelPendingTasks(t) {
+  }
+  getClassName() {
+    return "FlowGraphPointerOutEventBlock";
+  }
+}
+a("FlowGraphPointerOutEventBlock", o);
+export {
+  o as FlowGraphPointerOutEventBlock
+};

package/dist/flowGraphPointerOverEventBlock-VxdHhFuu.js

@@ -0,0 +1,23 @@
+import { Q as h, aS as a, aM as r, bp as n, aK as o } from "./index-CS3Icp_r.js";
+class u extends h {
+  constructor(e) {
+    super(e), this.type = "PointerOver", this.pointerId = this.registerDataOutput("pointerId", a), this.targetMesh = this.registerDataInput("targetMesh", r, e?.targetMesh), this.meshUnderPointer = this.registerDataOutput("meshUnderPointer", r);
+  }
+  _executeEvent(e, t) {
+    const s = this.targetMesh.getValue(e);
+    this.meshUnderPointer.setValue(t.mesh, e);
+    const i = t.out && n(t.out, s);
+    return this.pointerId.setValue(t.pointerId, e), !i && (t.mesh === s || n(t.mesh, s)) ? (this._execute(e), !this.config?.stopPropagation) : !0;
+  }
+  _preparePendingTasks(e) {
+  }
+  _cancelPendingTasks(e) {
+  }
+  getClassName() {
+    return "FlowGraphPointerOverEventBlock";
+  }
+}
+o("FlowGraphPointerOverEventBlock", u);
+export {
+  u as FlowGraphPointerOverEventBlock
+};

package/dist/flowGraphPointerUpEventBlock-DRR1f07q.js

@@ -0,0 +1,31 @@
+import { Q as a, aM as r, aS as p, bp as n, aK as h } from "./index-CS3Icp_r.js";
+class o extends a {
+  /**
+   * Creates a new FlowGraphPointerUpEventBlock.
+   * @param config optional configuration
+   */
+  constructor(e) {
+    super(e), this.type = "PointerUp", this.targetMesh = this.registerDataInput("targetMesh", r, e?.targetMesh), this.pointerId = this.registerDataOutput("pointerId", p), this.pickedMesh = this.registerDataOutput("pickedMesh", r), this.pickedPoint = this.registerDataOutput("pickedPoint", r);
+  }
+  /** @internal */
+  _executeEvent(e, s) {
+    const i = this.targetMesh.getValue(e), t = s.pickInfo?.pickedMesh;
+    return i && !(t === i || t && n(t, i)) ? !0 : (this.pointerId.setValue(s.event.pointerId, e), this.pickedMesh.setValue(t ?? null, e), this.pickedPoint.setValue(s.pickInfo?.pickedPoint ?? null, e), this._execute(e), !this.config?.stopPropagation);
+  }
+  /** @internal */
+  _preparePendingTasks(e) {
+  }
+  /** @internal */
+  _cancelPendingTasks(e) {
+  }
+  /**
+   * @returns the class name of the block.
+   */
+  getClassName() {
+    return "FlowGraphPointerUpEventBlock";
+  }
+}
+h("FlowGraphPointerUpEventBlock", o);
+export {
+  o as FlowGraphPointerUpEventBlock
+};

package/dist/flowGraphReceiveCustomEventBlock-B3bwdB66.js

@@ -0,0 +1,52 @@
+import { Q as a, bW as c, P as i, b9 as v, aK as p } from "./index-CS3Icp_r.js";
+class l extends a {
+  constructor(e) {
+    super(e), this.config = e, this.initPriority = 1;
+    for (const t in this.config.eventData) {
+      const s = this.config.eventData[t], o = typeof s.type == "string" ? s.type : s.type?.typeName, r = typeof s.type?.serialize == "function" ? s.type : c(o);
+      s.type = r, this.registerDataOutput(t, r);
+    }
+  }
+  _preparePendingTasks(e) {
+    const t = e.configuration.coordinator.getCustomEventObservable(this.config.eventId);
+    if (t && t.hasObservers() && t.observers.length > i.MaxEventsPerType) {
+      this._reportError(e, `FlowGraphReceiveCustomEventBlock: Too many observers for event ${this.config.eventId}. Max is ${i.MaxEventsPerType}.`);
+      return;
+    }
+    const s = t.add((o) => {
+      const r = Object.keys(o);
+      for (const n of r)
+        this.getDataOutput(n)?.setValue(o[n], e);
+      this._execute(e);
+    });
+    e._setExecutionVariable(this, "_eventObserver", s);
+  }
+  _cancelPendingTasks(e) {
+    const t = e.configuration.coordinator.getCustomEventObservable(this.config.eventId);
+    if (t) {
+      const s = e._getExecutionVariable(this, "_eventObserver", null);
+      t.remove(s);
+    } else
+      v.Warn(`FlowGraphReceiveCustomEventBlock: Missing observable for event ${this.config.eventId}`);
+  }
+  _executeEvent(e, t) {
+    return !0;
+  }
+  serialize(e = {}) {
+    super.serialize(e);
+    const t = {};
+    for (const s in this.config.eventData)
+      t[s] = { type: this.config.eventData[s].type.typeName };
+    e.config.eventData = t;
+  }
+  /**
+   * @returns class name of the block.
+   */
+  getClassName() {
+    return "FlowGraphReceiveCustomEventBlock";
+  }
+}
+p("FlowGraphReceiveCustomEventBlock", l);
+export {
+  l as FlowGraphReceiveCustomEventBlock
+};

package/dist/flowGraphSceneReadyEventBlock-Dy6lDT3j.js

@@ -0,0 +1,23 @@
+import { Q as t, aK as a } from "./index-CS3Icp_r.js";
+class n extends t {
+  constructor() {
+    super(...arguments), this.initPriority = -1, this.type = "SceneReady";
+  }
+  _executeEvent(e, s) {
+    return this._execute(e), !0;
+  }
+  _preparePendingTasks(e) {
+  }
+  _cancelPendingTasks(e) {
+  }
+  /**
+   * @returns class name of the block.
+   */
+  getClassName() {
+    return "FlowGraphSceneReadyEventBlock";
+  }
+}
+a("FlowGraphSceneReadyEventBlock", n);
+export {
+  n as FlowGraphSceneReadyEventBlock
+};

package/dist/flowGraphSceneTickEventBlock-Bl9BF_Xw.js

@@ -0,0 +1,32 @@
+import { Q as a, aS as i, aK as r } from "./index-CS3Icp_r.js";
+class s extends a {
+  constructor() {
+    super(), this.type = "SceneBeforeRender", this.timeSinceStart = this.registerDataOutput("timeSinceStart", i), this.deltaTime = this.registerDataOutput("deltaTime", i);
+  }
+  /**
+   * @internal
+   */
+  _preparePendingTasks(e) {
+  }
+  /**
+   * @internal
+   */
+  _executeEvent(e, t) {
+    return this.timeSinceStart.setValue(t.timeSinceStart, e), this.deltaTime.setValue(t.deltaTime, e), this._execute(e), !0;
+  }
+  /**
+   * @internal
+   */
+  _cancelPendingTasks(e) {
+  }
+  /**
+   * @returns class name of the block.
+   */
+  getClassName() {
+    return "FlowGraphSceneTickEventBlock";
+  }
+}
+r("FlowGraphSceneTickEventBlock", s);
+export {
+  s as FlowGraphSceneTickEventBlock
+};

package/dist/flowGraphSendCustomEventBlock-BAR4PGFq.js

@@ -0,0 +1,35 @@
+import { S as s, bW as i, aK as r } from "./index-CS3Icp_r.js";
+class c extends s {
+  constructor(e) {
+    super(e), this.config = e;
+    for (const n in this.config.eventData) {
+      const t = this.config.eventData[n], a = typeof t.type == "string" ? t.type : t.type?.typeName, o = typeof t.type?.serialize == "function" ? t.type : i(a);
+      t.type = o, this.registerDataInput(n, o, t.value);
+    }
+  }
+  _execute(e) {
+    const n = this.config.eventId, t = {};
+    for (const a of this.dataInputs)
+      t[a.name] = a.getValue(e);
+    e.configuration.coordinator.notifyCustomEvent(n, t), this.out._activateSignal(e);
+  }
+  serialize(e = {}) {
+    super.serialize(e);
+    const n = {};
+    for (const t in this.config.eventData) {
+      const a = this.config.eventData[t];
+      n[t] = { type: a.type.typeName }, a.value !== void 0 && (n[t].value = a.value);
+    }
+    e.config.eventData = n;
+  }
+  /**
+   * @returns class name of the block.
+   */
+  getClassName() {
+    return "FlowGraphSendCustomEventBlock";
+  }
+}
+r("FlowGraphSendCustomEventBlock", c);
+export {
+  c as FlowGraphSendCustomEventBlock
+};

package/dist/flowGraphSequenceBlock-veqU32ZZ.js

@@ -0,0 +1,32 @@
+import { R as i, aK as s } from "./index-CS3Icp_r.js";
+class n extends i {
+  constructor(e) {
+    super(e), this.config = e, this.executionSignals = [], this.setNumberOfOutputSignals(this.config.outputSignalCount);
+  }
+  _execute(e) {
+    for (let t = 0; t < this.executionSignals.length; t++)
+      this.executionSignals[t]._activateSignal(e);
+  }
+  /**
+   * Sets the block's output flows. Would usually be passed from the constructor but can be changed afterwards.
+   * @param outputSignalCount the number of output flows
+   */
+  setNumberOfOutputSignals(e = 1) {
+    for (; this.executionSignals.length > e; ) {
+      const t = this.executionSignals.pop();
+      t && (t.disconnectFromAll(), this._unregisterSignalOutput(t.name));
+    }
+    for (; this.executionSignals.length < e; )
+      this.executionSignals.push(this._registerSignalOutput(`out_${this.executionSignals.length}`));
+  }
+  /**
+   * @returns class name of the block.
+   */
+  getClassName() {
+    return "FlowGraphSequenceBlock";
+  }
+}
+s("FlowGraphSequenceBlock", n);
+export {
+  n as FlowGraphSequenceBlock
+};

package/dist/flowGraphSetAngularVelocityBlock-Dj9b-zu6.js

@@ -0,0 +1,31 @@
+import { S as i, aM as a, aW as s, aK as l } from "./index-CS3Icp_r.js";
+class o extends i {
+  /**
+   * Constructs a new FlowGraphSetAngularVelocityBlock.
+   * @param config - optional configuration for the block
+   */
+  constructor(t) {
+    super(t), this.body = this.registerDataInput("body", a), this.velocity = this.registerDataInput("velocity", s);
+  }
+  /**
+   * @internal
+   */
+  _execute(t, c) {
+    const e = this.body.getValue(t);
+    if (!e) {
+      this._reportError(t, "No physics body provided"), this.out._activateSignal(t);
+      return;
+    }
+    e.setAngularVelocity(this.velocity.getValue(t)), this.out._activateSignal(t);
+  }
+  /**
+   * @returns class name of the block.
+   */
+  getClassName() {
+    return "FlowGraphSetAngularVelocityBlock";
+  }
+}
+l("FlowGraphSetAngularVelocityBlock", o);
+export {
+  o as FlowGraphSetAngularVelocityBlock
+};

package/dist/flowGraphSetDelayBlock-CMjudtvk.js

@@ -0,0 +1,131 @@
+import { ai as n, N as m, aS as u, aO as v, T as h, a7 as d, aK as T } from "./index-CS3Icp_r.js";
+var _;
+(function(r) {
+  r[r.INIT = 0] = "INIT", r[r.STARTED = 1] = "STARTED", r[r.ENDED = 2] = "ENDED";
+})(_ || (_ = {}));
+class g {
+  /**
+   * Will construct a new advanced timer based on the options provided. Timer will not start until start() is called.
+   * @param options construction options for this advanced timer
+   */
+  constructor(e) {
+    this.onEachCountObservable = new n(), this.onTimerAbortedObservable = new n(), this.onTimerEndedObservable = new n(), this.onStateChangedObservable = new n(), this._observer = null, this._breakOnNextTick = !1, this._tick = (t) => {
+      const a = Date.now();
+      this._timer = a - this._startTime;
+      const s = {
+        startTime: this._startTime,
+        currentTime: a,
+        deltaTime: this._timer,
+        completeRate: this._timer / this._timeToEnd,
+        payload: t
+      }, i = this._breakOnNextTick || this._breakCondition(s);
+      i || this._timer >= this._timeToEnd ? this._stop(s, i) : this.onEachCountObservable.notifyObservers(s);
+    }, this._setState(
+      0
+      /* TimerState.INIT */
+    ), this._contextObservable = e.contextObservable, this._observableParameters = e.observableParameters ?? {}, this._breakCondition = e.breakCondition ?? (() => !1), this._timeToEnd = e.timeout, e.onEnded && this.onTimerEndedObservable.add(e.onEnded), e.onTick && this.onEachCountObservable.add(e.onTick), e.onAborted && this.onTimerAbortedObservable.add(e.onAborted);
+  }
+  /**
+   * set a breaking condition for this timer. Default is to never break during count
+   * @param predicate the new break condition. Returns true to break, false otherwise
+   */
+  set breakCondition(e) {
+    this._breakCondition = e;
+  }
+  /**
+   * Reset ALL associated observables in this advanced timer
+   */
+  clearObservables() {
+    this.onEachCountObservable.clear(), this.onTimerAbortedObservable.clear(), this.onTimerEndedObservable.clear(), this.onStateChangedObservable.clear();
+  }
+  /**
+   * Will start a new iteration of this timer. Only one instance of this timer can run at a time.
+   *
+   * @param timeToEnd how much time to measure until timer ended
+   */
+  start(e = this._timeToEnd) {
+    if (this._state === 1)
+      throw new Error("Timer already started. Please stop it before starting again");
+    this._timeToEnd = e, this._startTime = Date.now(), this._timer = 0, this._observer = this._contextObservable.add(this._tick, this._observableParameters.mask, this._observableParameters.insertFirst, this._observableParameters.scope), this._setState(
+      1
+      /* TimerState.STARTED */
+    );
+  }
+  /**
+   * Will force a stop on the next tick.
+   */
+  stop() {
+    this._state === 1 && (this._breakOnNextTick = !0);
+  }
+  /**
+   * Dispose this timer, clearing all resources
+   */
+  dispose() {
+    this._observer && this._contextObservable.remove(this._observer), this.clearObservables();
+  }
+  _setState(e) {
+    this._state = e, this.onStateChangedObservable.notifyObservers(this._state);
+  }
+  _stop(e, t = !1) {
+    this._contextObservable.remove(this._observer), this._setState(
+      2
+      /* TimerState.ENDED */
+    ), t ? this.onTimerAbortedObservable.notifyObservers(e) : this.onTimerEndedObservable.notifyObservers(e);
+  }
+}
+class l extends m {
+  constructor(e) {
+    super(e), this.cancel = this._registerSignalInput("cancel"), this.duration = this.registerDataInput("duration", u), this.lastDelayIndex = this.registerDataOutput("lastDelayIndex", v, new h(-1));
+  }
+  _preparePendingTasks(e) {
+    const t = this.duration.getValue(e);
+    if (t < 0 || isNaN(t) || !isFinite(t))
+      return this._reportError(e, "Invalid duration in SetDelay block");
+    if (e._getGlobalContextVariable("activeDelays", 0) >= l.MaxParallelDelayCount)
+      return this._reportError(e, "Max parallel delays reached");
+    const s = e._getGlobalContextVariable("lastDelayIndex", -1), i = e._getExecutionVariable(this, "pendingDelays", []), c = e.configuration.scene, o = new g({
+      timeout: t * 1e3,
+      // duration is in seconds
+      contextObservable: c.onBeforeRenderObservable,
+      onEnded: () => this._onEnded(o, e)
+    });
+    o.start();
+    const b = s + 1;
+    this.lastDelayIndex.setValue(new h(b), e), e._setGlobalContextVariable("lastDelayIndex", b), i[b] = o, e._setExecutionVariable(this, "pendingDelays", i), this._updateGlobalTimers(e);
+  }
+  _cancelPendingTasks(e) {
+    const t = e._getExecutionVariable(this, "pendingDelays", []);
+    for (const a of t)
+      a?.dispose();
+    e._deleteExecutionVariable(this, "pendingDelays"), this.lastDelayIndex.setValue(new h(-1), e), this._updateGlobalTimers(e);
+  }
+  _execute(e, t) {
+    if (t === this.cancel) {
+      this._cancelPendingTasks(e);
+      return;
+    } else
+      this._preparePendingTasks(e), this.out._activateSignal(e);
+  }
+  getClassName() {
+    return "FlowGraphSetDelayBlock";
+  }
+  _onEnded(e, t) {
+    const a = t._getExecutionVariable(this, "pendingDelays", []), s = a.indexOf(e);
+    s !== -1 ? a.splice(s, 1) : d.Warn("FlowGraphTimerBlock: Timer ended but was not found in the running timers list"), t._removePendingBlock(this), this.done._activateSignal(t), this._updateGlobalTimers(t);
+  }
+  _updateGlobalTimers(e) {
+    const t = e._getExecutionVariable(this, "pendingDelays", []), a = e._getGlobalContextVariable("pendingDelays", []);
+    for (let s = 0; s < t.length; s++) {
+      if (!t[s])
+        continue;
+      const i = t[s];
+      a[s] && a[s] !== i ? d.Warn("FlowGraphTimerBlock: Timer ended but was not found in the running timers list") : a[s] = i;
+    }
+    e._setGlobalContextVariable("pendingDelays", a);
+  }
+}
+l.MaxParallelDelayCount = 100;
+T("FlowGraphSetDelayBlock", l);
+export {
+  l as FlowGraphSetDelayBlock
+};

package/dist/flowGraphSetLinearVelocityBlock-DVDhhJBd.js

@@ -0,0 +1,31 @@
+import { S as i, aM as a, aW as s, aK as o } from "./index-CS3Icp_r.js";
+class r extends i {
+  /**
+   * Constructs a new FlowGraphSetLinearVelocityBlock.
+   * @param config - optional configuration for the block
+   */
+  constructor(t) {
+    super(t), this.body = this.registerDataInput("body", a), this.velocity = this.registerDataInput("velocity", s);
+  }
+  /**
+   * @internal
+   */
+  _execute(t, c) {
+    const e = this.body.getValue(t);
+    if (!e) {
+      this._reportError(t, "No physics body provided"), this.out._activateSignal(t);
+      return;
+    }
+    e.setLinearVelocity(this.velocity.getValue(t)), this.out._activateSignal(t);
+  }
+  /**
+   * @returns class name of the block.
+   */
+  getClassName() {
+    return "FlowGraphSetLinearVelocityBlock";
+  }
+}
+o("FlowGraphSetLinearVelocityBlock", r);
+export {
+  r as FlowGraphSetLinearVelocityBlock
+};

package/dist/flowGraphSetPhysicsMotionTypeBlock-CL3cxNCO.js

@@ -0,0 +1,36 @@
+import { S as s, aM as e, aS as o, aK as a } from "./index-CS3Icp_r.js";
+class r extends s {
+  /**
+   * Constructs a new FlowGraphSetPhysicsMotionTypeBlock.
+   * @param config - optional configuration for the block
+   */
+  constructor(t) {
+    super(t), this.body = this.registerDataInput("body", e), this.motionType = this.registerDataInput(
+      "motionType",
+      o,
+      2
+      /* PhysicsMotionType.DYNAMIC */
+    );
+  }
+  /**
+   * @internal
+   */
+  _execute(t, h) {
+    const i = this.body.getValue(t);
+    if (!i) {
+      this._reportError(t, "No physics body provided"), this.out._activateSignal(t);
+      return;
+    }
+    i.setMotionType(this.motionType.getValue(t)), this.out._activateSignal(t);
+  }
+  /**
+   * @returns class name of the block.
+   */
+  getClassName() {
+    return "FlowGraphSetPhysicsMotionTypeBlock";
+  }
+}
+a("FlowGraphSetPhysicsMotionTypeBlock", r);
+export {
+  r as FlowGraphSetPhysicsMotionTypeBlock
+};

package/dist/flowGraphSetPropertyBlock-D3sWL3Ss.js

@@ -0,0 +1,47 @@
+import { S as p, aM as o, aU as l, aK as c } from "./index-CS3Icp_r.js";
+class h extends p {
+  constructor(t) {
+    super(t), this.config = t, this.object = this.registerDataInput("object", o, t.target), this.value = this.registerDataInput("value", o), this.propertyName = this.registerDataInput("propertyName", l, t.propertyName), this.customSetFunction = this.registerDataInput("customSetFunction", o);
+  }
+  _execute(t, s) {
+    try {
+      const a = this.object.getValue(t), e = this.value.getValue(t), i = this.propertyName.getValue(t);
+      this._stopRunningAnimations(t, a, i);
+      const r = this.customSetFunction.getValue(t);
+      r ? r(a, i, e, t) : this._setPropertyValue(a, i, e);
+    } catch (a) {
+      this._reportError(t, a);
+    }
+    this.out._activateSignal(t);
+  }
+  _stopRunningAnimations(t, s, a) {
+    const e = t._getGlobalContextVariable("currentlyRunningAnimationGroups", []);
+    for (const i of e) {
+      const r = t.assetsContext.animationGroups.find((n) => n.uniqueId === i);
+      if (r) {
+        for (const n of r.targetedAnimations)
+          if (n.target === s && n.animation.targetProperty === a) {
+            r.stop(!0), r.dispose();
+            const u = e.indexOf(i);
+            u !== -1 && (e.splice(u, 1), t._setGlobalContextVariable("currentlyRunningAnimationGroups", e));
+          }
+      }
+    }
+  }
+  _setPropertyValue(t, s, a) {
+    const e = s.split(".");
+    let i = t;
+    for (let r = 0; r < e.length - 1; r++) {
+      const n = e[r];
+      i[n] === void 0 && (i[n] = {}), i = i[n];
+    }
+    i[e[e.length - 1]] = a;
+  }
+  getClassName() {
+    return "FlowGraphSetPropertyBlock";
+  }
+}
+c("FlowGraphSetPropertyBlock", h);
+export {
+  h as FlowGraphSetPropertyBlock
+};

package/dist/flowGraphSetSoundVolumeBlock-CxVk45yR.js

@@ -0,0 +1,32 @@
+import { S as s, aM as a, aS as u, aK as l } from "./index-CS3Icp_r.js";
+class i extends s {
+  /**
+   * Constructs a new FlowGraphSetSoundVolumeBlock.
+   * @param config - optional configuration for the block
+   */
+  constructor(e) {
+    super(e), this.sound = this.registerDataInput("sound", a), this.volume = this.registerDataInput("volume", u, 1);
+  }
+  /**
+   * @internal
+   */
+  _execute(e, n) {
+    const o = this.sound.getValue(e);
+    if (!o) {
+      this._reportError(e, "No sound provided"), this.out._activateSignal(e);
+      return;
+    }
+    const t = this.volume.getValue(e);
+    o.volume = t, this.out._activateSignal(e);
+  }
+  /**
+   * @returns class name of the block.
+   */
+  getClassName() {
+    return "FlowGraphSetSoundVolumeBlock";
+  }
+}
+l("FlowGraphSetSoundVolumeBlock", i);
+export {
+  i as FlowGraphSetSoundVolumeBlock
+};