@babylonjs/core 6.33.1 → 6.34.0-alpha.0

package/FlowGraph/Blocks/Data/Math/flowGraphMathBlocks.js

@@ -0,0 +1,758 @@
+import { RegisterClass } from "../../../../Misc/typeStore.js";
+import { RichTypeAny, RichTypeBoolean, RichTypeNumber, RichTypeVector2, RichTypeVector3 } from "../../../flowGraphRichTypes.js";
+import { FlowGraphBinaryOperationBlock } from "../flowGraphBinaryOperationBlock.js";
+import { FlowGraphConstantOperationBlock } from "../flowGraphConstantOperationBlock.js";
+import { Matrix, Vector2, Vector3, Vector4 } from "../../../../Maths/math.vector.js";
+import { FlowGraphUnaryOperationBlock } from "../flowGraphUnaryOperationBlock.js";
+import { FlowGraphTernaryOperationBlock } from "../flowGraphTernaryOperationBlock.js";
+/**
+ * @internal
+ * @param v
+ * @returns
+ */
+function _getClassNameOf(v) {
+    if (v.getClassName) {
+        return v.getClassName();
+    }
+    return "";
+}
+/**
+ * @internal
+ * @param className
+ * @param className2
+ * @returns
+ */
+function _areSameVectorClass(className, className2) {
+    return (className === "Vector2" && className2 === "Vector2") || (className === "Vector3" && className2 === "Vector3") || (className === "Vector4" && className2 === "Vector4");
+}
+/**
+ * @experimental
+ * Polymorphic add block.
+ */
+export class FlowGraphAddBlock extends FlowGraphBinaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeAny, RichTypeAny, (a, b) => this._polymorphicAdd(a, b), FlowGraphAddBlock.ClassName, config);
+    }
+    _polymorphicAdd(a, b) {
+        const aClassName = _getClassNameOf(a);
+        const bClassName = _getClassNameOf(b);
+        if (_areSameVectorClass(aClassName, bClassName)) {
+            return a.add(b);
+        }
+        else {
+            return a + b;
+        }
+    }
+    getClassName() {
+        return FlowGraphAddBlock.ClassName;
+    }
+}
+FlowGraphAddBlock.ClassName = "FGAddBlock";
+RegisterClass(FlowGraphAddBlock.ClassName, FlowGraphAddBlock);
+/**
+ * @experimental
+ * Polymorphic add block.
+ */
+export class FlowGraphSubtractBlock extends FlowGraphBinaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeAny, RichTypeAny, (a, b) => this._polymorphicAdd(a, b), FlowGraphSubtractBlock.ClassName, config);
+    }
+    _polymorphicAdd(a, b) {
+        const aClassName = _getClassNameOf(a);
+        const bClassName = _getClassNameOf(b);
+        if (_areSameVectorClass(aClassName, bClassName)) {
+            return a.subtract(b);
+        }
+        else {
+            return a - b;
+        }
+    }
+    getClassName() {
+        return FlowGraphSubtractBlock.ClassName;
+    }
+}
+FlowGraphSubtractBlock.ClassName = "FGSubBlock";
+RegisterClass(FlowGraphSubtractBlock.ClassName, FlowGraphSubtractBlock);
+export class FlowGraphMultiplyBlock extends FlowGraphBinaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeAny, RichTypeAny, (a, b) => this._polymorphicMultiply(a, b), FlowGraphMultiplyBlock.ClassName, config);
+    }
+    _polymorphicMultiply(a, b) {
+        const aClassName = _getClassNameOf(a);
+        const bClassName = _getClassNameOf(b);
+        if (_areSameVectorClass(aClassName, bClassName)) {
+            return a.multiply(b);
+        }
+        else {
+            return a * b;
+        }
+    }
+}
+FlowGraphMultiplyBlock.ClassName = "FGMultiplyBlock";
+RegisterClass(FlowGraphMultiplyBlock.ClassName, FlowGraphMultiplyBlock);
+export class FlowGraphDivideBlock extends FlowGraphBinaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeAny, RichTypeAny, (a, b) => this._polymorphicDivide(a, b), FlowGraphDivideBlock.ClassName, config);
+    }
+    _polymorphicDivide(a, b) {
+        const aClassName = _getClassNameOf(a);
+        const bClassName = _getClassNameOf(b);
+        if (_areSameVectorClass(aClassName, bClassName)) {
+            return a.divide(b);
+        }
+        else {
+            return a / b;
+        }
+    }
+}
+FlowGraphDivideBlock.ClassName = "FGDivideBlock";
+RegisterClass(FlowGraphDivideBlock.ClassName, FlowGraphDivideBlock);
+export class FlowGraphRandomBlock extends FlowGraphConstantOperationBlock {
+    constructor(config) {
+        super(RichTypeNumber, () => Math.random(), FlowGraphRandomBlock.ClassName, config);
+    }
+}
+FlowGraphRandomBlock.ClassName = "FGRandomBlock";
+RegisterClass(FlowGraphRandomBlock.ClassName, FlowGraphRandomBlock);
+export class FlowGraphDotBlock extends FlowGraphBinaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeAny, RichTypeNumber, (a, b) => this._polymorphicDot(a, b), FlowGraphDotBlock.ClassName, config);
+    }
+    _polymorphicDot(a, b) {
+        const className = _getClassNameOf(a);
+        switch (className) {
+            case "Vector2":
+                return Vector2.Dot(a, b);
+            case "Vector3":
+                return Vector3.Dot(a, b);
+            case "Vector4":
+                return Vector4.Dot(a, b);
+            default:
+                throw new Error(`Cannot get dot product of ${a} and ${b}`);
+        }
+    }
+}
+FlowGraphDotBlock.ClassName = "FGDotBlock";
+RegisterClass(FlowGraphDotBlock.ClassName, FlowGraphDotBlock);
+export class FlowGraphEBlock extends FlowGraphConstantOperationBlock {
+    constructor(config) {
+        super(RichTypeNumber, () => Math.E, FlowGraphEBlock.ClassName, config);
+    }
+}
+FlowGraphEBlock.ClassName = "FGEBlock";
+RegisterClass(FlowGraphEBlock.ClassName, FlowGraphEBlock);
+export class FlowGraphPiBlock extends FlowGraphConstantOperationBlock {
+    constructor(config) {
+        super(RichTypeNumber, () => Math.PI, FlowGraphPiBlock.ClassName, config);
+    }
+}
+FlowGraphPiBlock.ClassName = "FGPIBlock";
+RegisterClass(FlowGraphPiBlock.ClassName, FlowGraphPiBlock);
+export class FlowGraphInfBlock extends FlowGraphConstantOperationBlock {
+    constructor(config) {
+        super(RichTypeNumber, () => Number.POSITIVE_INFINITY, FlowGraphInfBlock.ClassName, config);
+    }
+}
+FlowGraphInfBlock.ClassName = "FGInfBlock";
+RegisterClass(FlowGraphInfBlock.ClassName, FlowGraphInfBlock);
+export class FlowGraphNaNBlock extends FlowGraphConstantOperationBlock {
+    constructor(config) {
+        super(RichTypeNumber, () => Number.NaN, FlowGraphNaNBlock.ClassName, config);
+    }
+}
+FlowGraphNaNBlock.ClassName = "FGNaNBlock";
+RegisterClass(FlowGraphNaNBlock.ClassName, FlowGraphNaNBlock);
+function _componentWiseUnaryOperation(a, op) {
+    const aClassName = _getClassNameOf(a);
+    switch (aClassName) {
+        case "Vector2":
+            return new Vector2(op(a.x), op(a.y));
+        case "Vector3":
+            return new Vector3(op(a.x), op(a.y), op(a.z));
+        case "Vector4":
+            return new Vector4(op(a.x), op(a.y), op(a.z), op(a.w));
+        default:
+            return op(a);
+    }
+}
+export class FlowGraphAbsBlock extends FlowGraphUnaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeAny, (a) => this._polymorphicAbs(a), FlowGraphAbsBlock.ClassName, config);
+    }
+    _polymorphicAbs(a) {
+        return _componentWiseUnaryOperation(a, Math.abs);
+    }
+}
+FlowGraphAbsBlock.ClassName = "FGAbsBlock";
+RegisterClass(FlowGraphAbsBlock.ClassName, FlowGraphAbsBlock);
+export class FlowGraphSignBlock extends FlowGraphUnaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeAny, (a) => this._polymorphicSign(a), FlowGraphSignBlock.ClassName, config);
+    }
+    _polymorphicSign(a) {
+        return _componentWiseUnaryOperation(a, Math.sign);
+    }
+}
+FlowGraphSignBlock.ClassName = "FGSignBlock";
+RegisterClass(FlowGraphSignBlock.ClassName, FlowGraphSignBlock);
+export class FlowGraphTruncBlock extends FlowGraphUnaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeAny, (a) => this._polymorphicTrunc(a), FlowGraphTruncBlock.ClassName, config);
+    }
+    _polymorphicTrunc(a) {
+        return _componentWiseUnaryOperation(a, Math.trunc);
+    }
+}
+FlowGraphTruncBlock.ClassName = "FGTruncBlock";
+RegisterClass(FlowGraphTruncBlock.ClassName, FlowGraphTruncBlock);
+export class FlowGraphFloorBlock extends FlowGraphUnaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeAny, (a) => this._polymorphicFloor(a), FlowGraphFloorBlock.ClassName, config);
+    }
+    _polymorphicFloor(a) {
+        return _componentWiseUnaryOperation(a, Math.floor);
+    }
+}
+FlowGraphFloorBlock.ClassName = "FGFloorBlock";
+RegisterClass(FlowGraphFloorBlock.ClassName, FlowGraphFloorBlock);
+export class FlowGraphCeilBlock extends FlowGraphUnaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeAny, (a) => this._polymorphicCeiling(a), FlowGraphCeilBlock.ClassName, config);
+    }
+    _polymorphicCeiling(a) {
+        return _componentWiseUnaryOperation(a, Math.ceil);
+    }
+}
+FlowGraphCeilBlock.ClassName = "FGCeilBlock";
+RegisterClass(FlowGraphCeilBlock.ClassName, FlowGraphCeilBlock);
+export class FlowGraphFractBlock extends FlowGraphUnaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeAny, (a) => this._polymorphicFract(a), FlowGraphFractBlock.ClassName, config);
+    }
+    _polymorphicFract(a) {
+        return _componentWiseUnaryOperation(a, (a) => a - Math.floor(a));
+    }
+}
+FlowGraphFractBlock.ClassName = "FGFractBlock";
+RegisterClass(FlowGraphFractBlock.ClassName, FlowGraphFractBlock);
+export class FlowGraphNegBlock extends FlowGraphUnaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeAny, (a) => this._polymorphicNeg(a), FlowGraphNegBlock.ClassName, config);
+    }
+    _polymorphicNeg(a) {
+        return _componentWiseUnaryOperation(a, (a) => -a);
+    }
+}
+FlowGraphNegBlock.ClassName = "FGNegBlock";
+RegisterClass(FlowGraphNegBlock.ClassName, FlowGraphNegBlock);
+function _componentWiseBinaryOperation(a, b, op) {
+    const aClassName = _getClassNameOf(a);
+    switch (aClassName) {
+        case "Vector2":
+            return new Vector2(op(a.x, b.x), op(a.y, b.y));
+        case "Vector3":
+            return new Vector3(op(a.x, b.x), op(a.y, b.y), op(a.z, b.z));
+        case "Vector4":
+            return new Vector4(op(a.x, b.x), op(a.y, b.y), op(a.z, b.z), op(a.w, b.w));
+        default:
+            return op(a, b);
+    }
+}
+export class FlowGraphRemainderBlock extends FlowGraphBinaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeAny, RichTypeAny, (a, b) => this._polymorphicRemainder(a, b), FlowGraphRemainderBlock.ClassName, config);
+    }
+    _polymorphicRemainder(a, b) {
+        return _componentWiseBinaryOperation(a, b, (a, b) => a % b);
+    }
+}
+FlowGraphRemainderBlock.ClassName = "FGRemainderBlock";
+RegisterClass(FlowGraphRemainderBlock.ClassName, FlowGraphRemainderBlock);
+export class FlowGraphMinBlock extends FlowGraphBinaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeAny, RichTypeAny, (a, b) => this._polymorphicMin(a, b), FlowGraphMinBlock.ClassName, config);
+    }
+    _polymorphicMin(a, b) {
+        return _componentWiseBinaryOperation(a, b, Math.min);
+    }
+}
+FlowGraphMinBlock.ClassName = "FGMinBlock";
+RegisterClass(FlowGraphMinBlock.ClassName, FlowGraphMinBlock);
+export class FlowGraphMaxBlock extends FlowGraphBinaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeAny, RichTypeAny, (a, b) => this._polymorphicMax(a, b), FlowGraphMaxBlock.ClassName, config);
+    }
+    _polymorphicMax(a, b) {
+        return _componentWiseBinaryOperation(a, b, Math.max);
+    }
+}
+FlowGraphMaxBlock.ClassName = "FGMaxBlock";
+RegisterClass(FlowGraphMaxBlock.ClassName, FlowGraphMaxBlock);
+function _clamp(a, b, c) {
+    return Math.min(Math.max(a, b), c);
+}
+function _componentWiseTernaryOperation(a, b, c, op) {
+    const aClassName = _getClassNameOf(a);
+    switch (aClassName) {
+        case "Vector2":
+            return new Vector2(op(a.x, b.x, c.x), op(a.y, b.y, c.y));
+        case "Vector3":
+            return new Vector3(op(a.x, b.x, c.x), op(a.y, b.y, c.y), op(a.z, b.z, c.z));
+        case "Vector4":
+            return new Vector4(op(a.x, b.x, c.x), op(a.y, b.y, c.y), op(a.z, b.z, c.z), op(a.w, b.w, c.w));
+        default:
+            return op(a, b, c);
+    }
+}
+export class FlowGraphClampBlock extends FlowGraphTernaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeAny, RichTypeAny, RichTypeAny, (a, b, c) => this._polymorphicClamp(a, b, c), FlowGraphClampBlock.ClassName, config);
+    }
+    _polymorphicClamp(a, b, c) {
+        return _componentWiseTernaryOperation(a, b, c, _clamp);
+    }
+}
+FlowGraphClampBlock.ClassName = "FGClampBlock";
+RegisterClass(FlowGraphClampBlock.ClassName, FlowGraphClampBlock);
+export class FlowGraphSaturateBlock extends FlowGraphUnaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeAny, (a) => this._polymorphicSaturate(a), FlowGraphSaturateBlock.ClassName, config);
+    }
+    _polymorphicSaturate(a) {
+        return _componentWiseUnaryOperation(a, (a) => _clamp(a, 0, 1));
+    }
+}
+FlowGraphSaturateBlock.ClassName = "FGSaturateBlock";
+RegisterClass(FlowGraphSaturateBlock.ClassName, FlowGraphSaturateBlock);
+export class FlowGraphInterpolateBlock extends FlowGraphTernaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeAny, RichTypeAny, RichTypeAny, (a, b, c) => this._polymorphicInterpolate(a, b, c), FlowGraphInterpolateBlock.ClassName, config);
+    }
+    _interpolate(a, b, c) {
+        return (1 - c) * a + c * b;
+    }
+    _polymorphicInterpolate(a, b, c) {
+        return _componentWiseTernaryOperation(a, b, c, this._interpolate);
+    }
+}
+FlowGraphInterpolateBlock.ClassName = "FGInterpolateBlock";
+RegisterClass(FlowGraphInterpolateBlock.ClassName, FlowGraphInterpolateBlock);
+export class FlowGraphEqBlock extends FlowGraphBinaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeAny, RichTypeBoolean, (a, b) => this._polymorphicEq(a, b), FlowGraphEqBlock.ClassName, config);
+    }
+    _polymorphicEq(a, b) {
+        const aClassName = _getClassNameOf(a);
+        const bClassName = _getClassNameOf(b);
+        if (_areSameVectorClass(aClassName, bClassName)) {
+            return a.equals(b);
+        }
+        else {
+            return a === b;
+        }
+    }
+}
+FlowGraphEqBlock.ClassName = "FGEqBlock";
+RegisterClass(FlowGraphEqBlock.ClassName, FlowGraphEqBlock);
+export class FlowGraphLessThanBlock extends FlowGraphBinaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeAny, RichTypeBoolean, (a, b) => this._polymorphicLessThan(a, b), FlowGraphLessThanBlock.ClassName, config);
+    }
+    _polymorphicLessThan(a, b) {
+        const aClassName = _getClassNameOf(a);
+        switch (aClassName) {
+            case "Vector2":
+                return a.x < b.x && a.y < b.y;
+            case "Vector3":
+                return a.x < b.x && a.y < b.y && a.z < b.z;
+            case "Vector4":
+                return a.x < b.x && a.y < b.y && a.z < b.z && a.w < b.w;
+            default:
+                return a < b;
+        }
+    }
+}
+FlowGraphLessThanBlock.ClassName = "FGLessThanBlock";
+RegisterClass(FlowGraphLessThanBlock.ClassName, FlowGraphLessThanBlock);
+export class FlowGraphLessThanOrEqualBlock extends FlowGraphBinaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeAny, RichTypeBoolean, (a, b) => this._polymorphicLessThanOrEqual(a, b), FlowGraphLessThanOrEqualBlock.ClassName, config);
+    }
+    _polymorphicLessThanOrEqual(a, b) {
+        const aClassName = _getClassNameOf(a);
+        switch (aClassName) {
+            case "Vector2":
+                return a.x <= b.x && a.y <= b.y;
+            case "Vector3":
+                return a.x <= b.x && a.y <= b.y && a.z <= b.z;
+            case "Vector4":
+                return a.x <= b.x && a.y <= b.y && a.z <= b.z && a.w <= b.w;
+            default:
+                return a <= b;
+        }
+    }
+}
+FlowGraphLessThanOrEqualBlock.ClassName = "FGLessThanOrEqualBlock";
+export class FlowGraphGreaterThanBlock extends FlowGraphBinaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeAny, RichTypeBoolean, (a, b) => this._polymorphicGreaterThan(a, b), FlowGraphGreaterThanBlock.ClassName, config);
+    }
+    _polymorphicGreaterThan(a, b) {
+        const aClassName = _getClassNameOf(a);
+        switch (aClassName) {
+            case "Vector2":
+                return a.x > b.x && a.y > b.y;
+            case "Vector3":
+                return a.x > b.x && a.y > b.y && a.z > b.z;
+            case "Vector4":
+                return a.x > b.x && a.y > b.y && a.z > b.z && a.w > b.w;
+            default:
+                return a > b;
+        }
+    }
+}
+FlowGraphGreaterThanBlock.ClassName = "FGGreaterThanBlock";
+RegisterClass(FlowGraphGreaterThanBlock.ClassName, FlowGraphGreaterThanBlock);
+export class FlowGraphGreaterThanOrEqualBlock extends FlowGraphBinaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeAny, RichTypeBoolean, (a, b) => this._polymorphicGreaterThanOrEqual(a, b), FlowGraphGreaterThanOrEqualBlock.ClassName, config);
+    }
+    _polymorphicGreaterThanOrEqual(a, b) {
+        const aClassName = _getClassNameOf(a);
+        switch (aClassName) {
+            case "Vector2":
+                return a.x >= b.x && a.y >= b.y;
+            case "Vector3":
+                return a.x >= b.x && a.y >= b.y && a.z >= b.z;
+            case "Vector4":
+                return a.x >= b.x && a.y >= b.y && a.z >= b.z && a.w >= b.w;
+            default:
+                return a >= b;
+        }
+    }
+}
+FlowGraphGreaterThanOrEqualBlock.ClassName = "FGGreaterThanOrEqualBlock";
+RegisterClass(FlowGraphGreaterThanOrEqualBlock.ClassName, FlowGraphGreaterThanOrEqualBlock);
+export class FlowGraphIsNanBlock extends FlowGraphUnaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeBoolean, (a) => this._polymorphicIsNan(a), FlowGraphIsNanBlock.ClassName, config);
+    }
+    _polymorphicIsNan(a) {
+        const aClassName = _getClassNameOf(a);
+        switch (aClassName) {
+            case "Vector2":
+                return isNaN(a.x) || isNaN(a.y);
+            case "Vector3":
+                return isNaN(a.x) || isNaN(a.y) || isNaN(a.z);
+            case "Vector4":
+                return isNaN(a.x) || isNaN(a.y) || isNaN(a.z) || isNaN(a.w);
+            default:
+                return isNaN(a);
+        }
+    }
+}
+FlowGraphIsNanBlock.ClassName = "FGIsNanBlock";
+RegisterClass(FlowGraphIsNanBlock.ClassName, FlowGraphIsNanBlock);
+export class FlowGraphIsInfBlock extends FlowGraphUnaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeBoolean, (a) => this._polymorphicIsInf(a), FlowGraphIsInfBlock.ClassName, config);
+    }
+    _polymorphicIsInf(a) {
+        const aClassName = _getClassNameOf(a);
+        switch (aClassName) {
+            case "Vector2":
+                return !isFinite(a.x) || !isFinite(a.y);
+            case "Vector3":
+                return !isFinite(a.x) || !isFinite(a.y) || !isFinite(a.z);
+            case "Vector4":
+                return !isFinite(a.x) || !isFinite(a.y) || !isFinite(a.z) || !isFinite(a.w);
+            default:
+                return !isFinite(a);
+        }
+    }
+}
+FlowGraphIsInfBlock.ClassName = "FGIsInfBlock";
+export class FlowGraphDegToRadBlock extends FlowGraphUnaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeAny, (a) => this._polymorphicDegToRad(a), FlowGraphDegToRadBlock.ClassName, config);
+    }
+    _degToRad(a) {
+        return (a * Math.PI) / 180;
+    }
+    _polymorphicDegToRad(a) {
+        return _componentWiseUnaryOperation(a, this._degToRad);
+    }
+}
+FlowGraphDegToRadBlock.ClassName = "FGDegToRadBlock";
+RegisterClass(FlowGraphDegToRadBlock.ClassName, FlowGraphDegToRadBlock);
+export class FlowGraphRadToDegBlock extends FlowGraphUnaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeAny, (a) => this._polymorphicRadToDeg(a), FlowGraphRadToDegBlock.ClassName, config);
+    }
+    _radToDeg(a) {
+        return (a * 180) / Math.PI;
+    }
+    _polymorphicRadToDeg(a) {
+        return _componentWiseUnaryOperation(a, this._radToDeg);
+    }
+}
+FlowGraphRadToDegBlock.ClassName = "FGRadToDegBlock";
+RegisterClass(FlowGraphRadToDegBlock.ClassName, FlowGraphRadToDegBlock);
+export class FlowGraphSinBlock extends FlowGraphUnaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeAny, (a) => this._polymorphicSin(a), FlowGraphSinBlock.ClassName, config);
+    }
+    _polymorphicSin(a) {
+        return _componentWiseUnaryOperation(a, Math.sin);
+    }
+}
+FlowGraphSinBlock.ClassName = "FGSinBlock";
+RegisterClass(FlowGraphSinBlock.ClassName, FlowGraphSinBlock);
+export class FlowGraphCosBlock extends FlowGraphUnaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeAny, (a) => this._polymorphicCos(a), FlowGraphCosBlock.ClassName, config);
+    }
+    _polymorphicCos(a) {
+        return _componentWiseUnaryOperation(a, Math.cos);
+    }
+}
+FlowGraphCosBlock.ClassName = "FGCosBlock";
+RegisterClass(FlowGraphCosBlock.ClassName, FlowGraphCosBlock);
+export class FlowGraphTanBlock extends FlowGraphUnaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeAny, (a) => this._polymorphicTan(a), FlowGraphTanBlock.ClassName, config);
+    }
+    _polymorphicTan(a) {
+        return _componentWiseUnaryOperation(a, Math.tan);
+    }
+}
+FlowGraphTanBlock.ClassName = "FGTanBlock";
+RegisterClass(FlowGraphTanBlock.ClassName, FlowGraphTanBlock);
+export class FlowGraphAsinBlock extends FlowGraphUnaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeAny, (a) => this._polymorphicAsin(a), FlowGraphAsinBlock.ClassName, config);
+    }
+    _polymorphicAsin(a) {
+        return _componentWiseUnaryOperation(a, Math.asin);
+    }
+}
+FlowGraphAsinBlock.ClassName = "FGAsinBlock";
+RegisterClass(FlowGraphAsinBlock.ClassName, FlowGraphAsinBlock);
+export class FlowGraphAcosBlock extends FlowGraphUnaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeAny, (a) => this._polymorphicAcos(a), FlowGraphAcosBlock.ClassName, config);
+    }
+    _polymorphicAcos(a) {
+        return _componentWiseUnaryOperation(a, Math.acos);
+    }
+}
+FlowGraphAcosBlock.ClassName = "FGAcosBlock";
+RegisterClass(FlowGraphAcosBlock.ClassName, FlowGraphAcosBlock);
+export class FlowGraphAtanBlock extends FlowGraphUnaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeAny, (a) => this._polymorphicAtan(a), FlowGraphAtanBlock.ClassName, config);
+    }
+    _polymorphicAtan(a) {
+        return _componentWiseUnaryOperation(a, Math.atan);
+    }
+}
+FlowGraphAtanBlock.ClassName = "FGAtanBlock";
+RegisterClass(FlowGraphAtanBlock.ClassName, FlowGraphAtanBlock);
+export class FlowGraphAtan2Block extends FlowGraphBinaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeAny, RichTypeAny, (a, b) => this._polymorphicAtan2(a, b), FlowGraphAtan2Block.ClassName, config);
+    }
+    _polymorphicAtan2(a, b) {
+        return _componentWiseBinaryOperation(a, b, Math.atan2);
+    }
+}
+FlowGraphAtan2Block.ClassName = "FGAtan2Block";
+RegisterClass(FlowGraphAtan2Block.ClassName, FlowGraphAtan2Block);
+export class FlowGraphSinhBlock extends FlowGraphUnaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeAny, (a) => this._polymorphicSinh(a), FlowGraphSinhBlock.ClassName, config);
+    }
+    _polymorphicSinh(a) {
+        return _componentWiseUnaryOperation(a, Math.sinh);
+    }
+}
+FlowGraphSinhBlock.ClassName = "FGSinhBlock";
+RegisterClass(FlowGraphSinhBlock.ClassName, FlowGraphSinhBlock);
+export class FlowGraphCoshBlock extends FlowGraphUnaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeAny, (a) => this._polymorphicCosh(a), FlowGraphCoshBlock.ClassName, config);
+    }
+    _polymorphicCosh(a) {
+        return _componentWiseUnaryOperation(a, Math.cosh);
+    }
+}
+FlowGraphCoshBlock.ClassName = "FGCoshBlock";
+RegisterClass(FlowGraphCoshBlock.ClassName, FlowGraphCoshBlock);
+export class FlowGraphTanhBlock extends FlowGraphUnaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeAny, (a) => this._polymorphicTanh(a), FlowGraphTanhBlock.ClassName, config);
+    }
+    _polymorphicTanh(a) {
+        return _componentWiseUnaryOperation(a, Math.tanh);
+    }
+}
+FlowGraphTanhBlock.ClassName = "FGTanhBlock";
+RegisterClass(FlowGraphTanhBlock.ClassName, FlowGraphTanhBlock);
+export class FlowGraphAsinhBlock extends FlowGraphUnaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeNumber, (a) => this._polymorphicAsinh(a), FlowGraphAsinhBlock.ClassName, config);
+    }
+    _polymorphicAsinh(a) {
+        return _componentWiseUnaryOperation(a, Math.asinh);
+    }
+}
+FlowGraphAsinhBlock.ClassName = "FGAsinhBlock";
+RegisterClass(FlowGraphAsinhBlock.ClassName, FlowGraphAsinhBlock);
+export class FlowGraphAcoshBlock extends FlowGraphUnaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeNumber, (a) => this._polymorphicAcosh(a), FlowGraphAcoshBlock.ClassName, config);
+    }
+    _polymorphicAcosh(a) {
+        return _componentWiseUnaryOperation(a, Math.acosh);
+    }
+}
+FlowGraphAcoshBlock.ClassName = "FGAcoshBlock";
+RegisterClass(FlowGraphAcoshBlock.ClassName, FlowGraphAcoshBlock);
+export class FlowGraphAtanhBlock extends FlowGraphUnaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeNumber, (a) => this._polymorphicAtanh(a), FlowGraphAtanhBlock.ClassName, config);
+    }
+    _polymorphicAtanh(a) {
+        return _componentWiseUnaryOperation(a, Math.atanh);
+    }
+}
+FlowGraphAtanhBlock.ClassName = "FGAtanhBlock";
+RegisterClass(FlowGraphAtanhBlock.ClassName, FlowGraphAtanhBlock);
+export class FlowGraphExpBlock extends FlowGraphUnaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeNumber, (a) => this._polymorphicExp(a), FlowGraphExpBlock.ClassName, config);
+    }
+    _polymorphicExp(a) {
+        return _componentWiseUnaryOperation(a, Math.exp);
+    }
+}
+FlowGraphExpBlock.ClassName = "FGExpBlock";
+RegisterClass(FlowGraphExpBlock.ClassName, FlowGraphExpBlock);
+export class FlowGraphLogBlock extends FlowGraphUnaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeNumber, (a) => this._polymorphicLog(a), FlowGraphLogBlock.ClassName, config);
+    }
+    _polymorphicLog(a) {
+        return _componentWiseUnaryOperation(a, Math.log);
+    }
+}
+FlowGraphLogBlock.ClassName = "FGLogBlock";
+RegisterClass(FlowGraphLogBlock.ClassName, FlowGraphLogBlock);
+export class FlowGraphLog2Block extends FlowGraphUnaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeNumber, (a) => this._polymorphicLog2(a), FlowGraphLog2Block.ClassName, config);
+    }
+    _polymorphicLog2(a) {
+        return _componentWiseUnaryOperation(a, Math.log2);
+    }
+}
+FlowGraphLog2Block.ClassName = "FGLog2Block";
+RegisterClass(FlowGraphLog2Block.ClassName, FlowGraphLog2Block);
+export class FlowGraphLog10Block extends FlowGraphUnaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeNumber, (a) => this._polymorphicLog10(a), FlowGraphLog10Block.ClassName, config);
+    }
+    _polymorphicLog10(a) {
+        return _componentWiseUnaryOperation(a, Math.log10);
+    }
+}
+FlowGraphLog10Block.ClassName = "FGLog10Block";
+RegisterClass(FlowGraphLog10Block.ClassName, FlowGraphLog10Block);
+export class FlowGraphSqrtBlock extends FlowGraphUnaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeNumber, (a) => this._polymorphicSqrt(a), FlowGraphSqrtBlock.ClassName, config);
+    }
+    _polymorphicSqrt(a) {
+        return _componentWiseUnaryOperation(a, Math.sqrt);
+    }
+}
+FlowGraphSqrtBlock.ClassName = "FGSqrtBlock";
+RegisterClass(FlowGraphSqrtBlock.ClassName, FlowGraphSqrtBlock);
+export class FlowGraphCubeRootBlock extends FlowGraphUnaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeNumber, (a) => this._polymorphicCubeRoot(a), FlowGraphCubeRootBlock.ClassName, config);
+    }
+    _polymorphicCubeRoot(a) {
+        return _componentWiseUnaryOperation(a, Math.cbrt);
+    }
+}
+FlowGraphCubeRootBlock.ClassName = "FGCubeRootBlock";
+RegisterClass(FlowGraphCubeRootBlock.ClassName, FlowGraphCubeRootBlock);
+export class FlowGraphPowBlock extends FlowGraphBinaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeNumber, RichTypeNumber, (a, b) => this._polymorphicPow(a, b), FlowGraphPowBlock.ClassName, config);
+    }
+    _polymorphicPow(a, b) {
+        return _componentWiseBinaryOperation(a, b, Math.pow);
+    }
+}
+FlowGraphPowBlock.ClassName = "FGPowBlock";
+RegisterClass(FlowGraphPowBlock.ClassName, FlowGraphPowBlock);
+export class FlowGraphLengthBlock extends FlowGraphUnaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeNumber, (a) => this._polymorphicLength(a), FlowGraphLengthBlock.ClassName, config);
+    }
+    _polymorphicLength(a) {
+        const aClassName = _getClassNameOf(a);
+        switch (aClassName) {
+            case "Vector2":
+            case "Vector3":
+            case "Vector4":
+                return a.length();
+            default:
+                throw new Error(`Cannot compute length of value ${a}`);
+        }
+    }
+}
+FlowGraphLengthBlock.ClassName = "FGLengthBlock";
+RegisterClass(FlowGraphLengthBlock.ClassName, FlowGraphLengthBlock);
+export class FlowGraphNormalizeBlock extends FlowGraphUnaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeAny, (a) => this._polymorphicNormalize(a), FlowGraphNormalizeBlock.ClassName, config);
+    }
+    _polymorphicNormalize(a) {
+        const aClassName = _getClassNameOf(a);
+        switch (aClassName) {
+            case "Vector2":
+            case "Vector3":
+            case "Vector4":
+                return a.normalize();
+            default:
+                throw new Error(`Cannot normalize value ${a}`);
+        }
+    }
+}
+FlowGraphNormalizeBlock.ClassName = "FGNormalizeBlock";
+RegisterClass(FlowGraphNormalizeBlock.ClassName, FlowGraphNormalizeBlock);
+export class FlowGraphCrossBlock extends FlowGraphBinaryOperationBlock {
+    constructor(config) {
+        super(RichTypeVector3, RichTypeVector3, RichTypeVector3, (a, b) => Vector3.Cross(a, b), FlowGraphCrossBlock.ClassName, config);
+    }
+}
+FlowGraphCrossBlock.ClassName = "FGCrossBlock";
+RegisterClass(FlowGraphCrossBlock.ClassName, FlowGraphCrossBlock);
+export class FlowGraphRotate2DBlock extends FlowGraphBinaryOperationBlock {
+    constructor(config) {
+        super(RichTypeVector2, RichTypeNumber, RichTypeVector2, (a, b) => Vector2.Transform(a, Matrix.RotationZ(b)), FlowGraphRotate2DBlock.ClassName, config);
+    }
+}
+FlowGraphRotate2DBlock.ClassName = "FGRotate2DBlock";
+RegisterClass(FlowGraphRotate2DBlock.ClassName, FlowGraphRotate2DBlock);
+export class FlowGraphRotate3DBlock extends FlowGraphTernaryOperationBlock {
+    constructor(config) {
+        super(RichTypeVector3, RichTypeVector3, RichTypeNumber, RichTypeVector3, (a, b, c) => Vector3.TransformCoordinates(a, Matrix.RotationAxis(b, c)), FlowGraphRotate3DBlock.ClassName, config);
+    }
+}
+FlowGraphRotate3DBlock.ClassName = "FGRotate3DBlock";
+RegisterClass(FlowGraphRotate3DBlock.ClassName, FlowGraphRotate3DBlock);
+//# sourceMappingURL=flowGraphMathBlocks.js.map