@onerjs/core 8.54.4 → 8.54.6

package/FlowGraph/Blocks/Data/Math/flowGraphMathBlocks.pure.d.ts

@@ -1,12 +1,14 @@
 /** This file must only contain pure code and pure imports */
-import { type IFlowGraphBlockConfiguration } from "../../../flowGraphBlock.js";
+import { FlowGraphBlock, type IFlowGraphBlockConfiguration } from "../../../flowGraphBlock.js";
 import { FlowGraphTypes } from "../../../flowGraphRichTypes.pure.js";
 import { FlowGraphBinaryOperationBlock } from "../flowGraphBinaryOperationBlock.js";
 import { FlowGraphConstantOperationBlock } from "../flowGraphConstantOperationBlock.js";
+import { Quaternion } from "../../../../Maths/math.vector.pure.js";
 import { FlowGraphUnaryOperationBlock } from "../flowGraphUnaryOperationBlock.js";
 import { FlowGraphTernaryOperationBlock } from "../flowGraphTernaryOperationBlock.js";
 import { FlowGraphInteger } from "../../../CustomTypes/flowGraphInteger.pure.js";
 import { type FlowGraphDataConnection } from "../../../flowGraphDataConnection.pure.js";
+import { type FlowGraphContext } from "../../../flowGraphContext.js";
 import { type FlowGraphMathOperationType, type FlowGraphNumber } from "../../../utils.js";
 /**
  * A configuration interface for math blocks
@@ -122,6 +124,12 @@ export declare class FlowGraphEBlock extends FlowGraphConstantOperationBlock<num
 export declare class FlowGraphPiBlock extends FlowGraphConstantOperationBlock<number> {
     constructor(config?: IFlowGraphBlockConfiguration);
 }
+/**
+ * Tau constant (2 * Pi), the ratio of a circle's circumference to its radius.
+ */
+export declare class FlowGraphTauBlock extends FlowGraphConstantOperationBlock<number> {
+    constructor(config?: IFlowGraphBlockConfiguration);
+}
 /**
  * Positive inf constant.
  */
@@ -246,6 +254,28 @@ export declare class FlowGraphMathInterpolationBlock extends FlowGraphTernaryOpe
     constructor(config?: IFlowGraphBlockConfiguration);
     private _polymorphicInterpolate;
 }
+/**
+ * Spherical linear interpolation between two unit quaternions, matching the
+ * quaternion slerp 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 declare class FlowGraphMathSlerpBlock extends FlowGraphTernaryOperationBlock<Quaternion, Quaternion, number, Quaternion> {
+    constructor(config?: IFlowGraphBlockConfiguration);
+}
+/**
+ * Smooth-step block, returning the Hermite interpolation coefficient.
+ * Operates component-wise over floatN inputs (the two edges `a`/`b` and the
+ * value `c`).
+ */
+export declare class FlowGraphMathSmoothStepBlock extends FlowGraphTernaryOperationBlock<FlowGraphMathOperationType, FlowGraphMathOperationType, FlowGraphMathOperationType, FlowGraphMathOperationType> {
+    constructor(config?: IFlowGraphBlockConfiguration);
+    private _polymorphicSmoothStep;
+}
 /**
  * Equals block.
  */
@@ -520,6 +550,70 @@ export declare class FlowGraphTrailingZerosBlock extends FlowGraphUnaryOperation
 export declare class FlowGraphOneBitsCounterBlock extends FlowGraphUnaryOperationBlock<FlowGraphInteger, FlowGraphInteger> {
     constructor(config?: IFlowGraphBlockConfiguration);
 }
+/**
+ * Block that converts a linear sRGB color (r, g, b) to OkLCh (l, c, h). Hue is in radians.
+ */
+export declare class FlowGraphRGBToOkLChBlock extends FlowGraphBlock {
+    /**
+     * Input connection: the linear red component.
+     */
+    readonly r: FlowGraphDataConnection<number>;
+    /**
+     * Input connection: the linear green component.
+     */
+    readonly g: FlowGraphDataConnection<number>;
+    /**
+     * Input connection: the linear blue component.
+     */
+    readonly b: FlowGraphDataConnection<number>;
+    /**
+     * Output connection: the OkLCh lightness.
+     */
+    readonly l: FlowGraphDataConnection<number>;
+    /**
+     * Output connection: the OkLCh chroma.
+     */
+    readonly c: FlowGraphDataConnection<number>;
+    /**
+     * Output connection: the OkLCh hue, in radians.
+     */
+    readonly h: FlowGraphDataConnection<number>;
+    constructor(config?: IFlowGraphBlockConfiguration);
+    _updateOutputs(context: FlowGraphContext): void;
+    getClassName(): string;
+}
+/**
+ * Block that converts an OkLCh color (l, c, h) to linear sRGB (r, g, b). Hue is in radians.
+ */
+export declare class FlowGraphRGBFromOkLChBlock extends FlowGraphBlock {
+    /**
+     * Input connection: the OkLCh lightness.
+     */
+    readonly l: FlowGraphDataConnection<number>;
+    /**
+     * Input connection: the OkLCh chroma.
+     */
+    readonly c: FlowGraphDataConnection<number>;
+    /**
+     * Input connection: the OkLCh hue, in radians.
+     */
+    readonly h: FlowGraphDataConnection<number>;
+    /**
+     * Output connection: the linear red component.
+     */
+    readonly r: FlowGraphDataConnection<number>;
+    /**
+     * Output connection: the linear green component.
+     */
+    readonly g: FlowGraphDataConnection<number>;
+    /**
+     * Output connection: the linear blue component.
+     */
+    readonly b: FlowGraphDataConnection<number>;
+    constructor(config?: IFlowGraphBlockConfiguration);
+    _updateOutputs(context: FlowGraphContext): void;
+    getClassName(): string;
+}
 /**
  * Register side effects for flowGraphMathBlocks.
  * Safe to call multiple times; only the first call has an effect.

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

@@ -1,4 +1,5 @@
 /** This file must only contain pure code and pure imports */
+import { FlowGraphBlock } from "../../../flowGraphBlock.js";
 import { getRichTypeByFlowGraphType, RichTypeAny, RichTypeBoolean, RichTypeFlowGraphInteger, RichTypeNumber } from "../../../flowGraphRichTypes.pure.js";
 import { FlowGraphBinaryOperationBlock } from "../flowGraphBinaryOperationBlock.js";
 import { FlowGraphConstantOperationBlock } from "../flowGraphConstantOperationBlock.js";
@@ -246,6 +247,14 @@ export class FlowGraphPiBlock extends FlowGraphConstantOperationBlock {
         super(RichTypeNumber, () => Math.PI, "FlowGraphPIBlock" /* FlowGraphBlockNames.PI */, config);
     }
 }
+/**
+ * Tau constant (2 * Pi), the ratio of a circle's circumference to its radius.
+ */
+export class FlowGraphTauBlock extends FlowGraphConstantOperationBlock {
+    constructor(config) {
+        super(RichTypeNumber, () => 2 * Math.PI, "FlowGraphTauBlock" /* FlowGraphBlockNames.Tau */, config);
+    }
+}
 /**
  * Positive inf constant.
  */
@@ -525,6 +534,25 @@ export class FlowGraphSaturateBlock extends FlowGraphUnaryOperationBlock {
 function Interpolate(a, b, c) {
     return (1 - c) * a + c * b;
 }
+/**
+ * Smooth step (Hermite interpolation) coefficient.
+ * Given the edges `a`/`b` and the value `c`, computes the smooth interpolation
+ * coefficient `t * t * (3 - 2 * t)` where `t = saturate((c - min(a, b)) / |b - a|)`.
+ * Note that this returns the coefficient in [0, 1]; it does not interpolate between `a` and `b`.
+ * @param a first edge
+ * @param b second edge
+ * @param c value to interpolate
+ * @returns the smooth-step interpolation coefficient
+ */
+function SmoothStep(a, b, c) {
+    // Degenerate edges: with a === b the transition is instantaneous, so return a step rather than
+    // dividing by zero (which would yield NaN and poison downstream math).
+    if (a === b) {
+        return c < a ? 0 : 1;
+    }
+    const t = Saturate((c - Math.min(a, b)) / Math.abs(b - a));
+    return t * t * (3 - 2 * t);
+}
 /**
  * Interpolate block.
  */
@@ -536,6 +564,34 @@ export class FlowGraphMathInterpolationBlock extends FlowGraphTernaryOperationBl
         return ComponentWiseTernaryOperation(a, b, c, Interpolate);
     }
 }
+/**
+ * Spherical linear interpolation between two unit quaternions, matching the
+ * quaternion slerp 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 {
+    constructor(config) {
+        super(RichTypeAny, RichTypeAny, RichTypeNumber, RichTypeAny, (a, b, c) => Quaternion.Slerp(a, b, c), "FlowGraphMathSlerpBlock" /* FlowGraphBlockNames.MathSlerp */, config);
+    }
+}
+/**
+ * Smooth-step block, returning the Hermite interpolation coefficient.
+ * Operates component-wise over floatN inputs (the two edges `a`/`b` and the
+ * value `c`).
+ */
+export class FlowGraphMathSmoothStepBlock extends FlowGraphTernaryOperationBlock {
+    constructor(config) {
+        super(RichTypeAny, RichTypeAny, RichTypeAny, RichTypeAny, (a, b, c) => this._polymorphicSmoothStep(a, b, c), "FlowGraphSmoothStepBlock" /* FlowGraphBlockNames.SmoothStep */, config);
+    }
+    _polymorphicSmoothStep(a, b, c) {
+        return ComponentWiseTernaryOperation(a, b, c, SmoothStep);
+    }
+}
 /**
  * Equals block.
  */
@@ -546,15 +602,24 @@ export class FlowGraphEqualityBlock extends FlowGraphBinaryOperationBlock {
     _polymorphicEq(a, b) {
         const aClassName = _GetClassNameOf(a);
         const bClassName = _GetClassNameOf(b);
-        if (typeof a !== typeof b) {
-            return false;
+        // A rotation may arrive either as a Quaternion or as a four-component vector, so treat Quaternion and
+        // Vector4 (both four-component) as comparable so that, for example, a decomposed rotation can be compared
+        // against a float4 literal.
+        const isFourComponent = (className) => className === "Vector4" /* FlowGraphTypes.Vector4 */ || className === "Quaternion" /* FlowGraphTypes.Quaternion */;
+        if (isFourComponent(aClassName) && isFourComponent(bClassName)) {
+            return a.equals(b);
         }
         if (_AreSameVectorOrQuaternionClass(aClassName, bClassName) || _AreSameMatrixClass(aClassName, bClassName) || _AreSameIntegerClass(aClassName, bClassName)) {
             return a.equals(b);
         }
-        else {
-            return a === b;
+        // Handle mixed number/FlowGraphInteger comparison
+        if (isNumeric(a) && isNumeric(b)) {
+            return getNumericValue(a) === getNumericValue(b);
+        }
+        if (typeof a !== typeof b) {
+            return false;
         }
+        return a === b;
     }
 }
 function ComparisonOperators(a, b, op) {
@@ -1029,6 +1094,101 @@ export class FlowGraphOneBitsCounterBlock extends FlowGraphUnaryOperationBlock {
         super(RichTypeFlowGraphInteger, RichTypeFlowGraphInteger, (a) => new FlowGraphInteger(CountOnes(a.value)), "FlowGraphOneBitsCounterBlock" /* FlowGraphBlockNames.OneBitsCounter */, config);
     }
 }
+/**
+ * Converts a linear sRGB color to OkLCh (the polar form of the Oklab color space).
+ * Uses Ottosson's original single-precision matrices.
+ * The RGB inputs are treated as linear; hue is returned in radians.
+ * @param r linear red component
+ * @param g linear green component
+ * @param b linear blue component
+ * @returns the OkLCh lightness (l), chroma (c) and hue (h, radians)
+ */
+function RgbToOkLch(r, g, b) {
+    // Linear sRGB -> LMS cone responses.
+    const long = 0.4122214708 * r + 0.5363325363 * g + 0.0514459929 * b;
+    const medium = 0.2119034982 * r + 0.6806995451 * g + 0.1073969566 * b;
+    const short = 0.0883024619 * r + 0.2817188376 * g + 0.6299787005 * b;
+    // Non-linearity (cube root) then LMS' -> Oklab.
+    const lRoot = Math.cbrt(long);
+    const mRoot = Math.cbrt(medium);
+    const sRoot = Math.cbrt(short);
+    const okL = 0.2104542553 * lRoot + 0.793617785 * mRoot - 0.0040720468 * sRoot;
+    const okA = 1.9779984951 * lRoot - 2.428592205 * mRoot + 0.4505937099 * sRoot;
+    const okB = 0.0259040371 * lRoot + 0.7827717662 * mRoot - 0.808675766 * sRoot;
+    // Oklab -> OkLCh (polar form).
+    return { l: okL, c: Math.hypot(okA, okB), h: Math.atan2(okB, okA) };
+}
+/**
+ * Converts an OkLCh color to linear sRGB. Inverse of {@link RgbToOkLch}; hue is in radians.
+ * @param l OkLCh lightness
+ * @param c OkLCh chroma
+ * @param h OkLCh hue in radians
+ * @returns the linear sRGB red (r), green (g) and blue (b) components
+ */
+function OkLchToRgb(l, c, h) {
+    // OkLCh -> Oklab.
+    const okA = c * Math.cos(h);
+    const okB = c * Math.sin(h);
+    // Oklab -> LMS' then cube to LMS.
+    const lPrime = l + 0.3963377774 * okA + 0.2158037573 * okB;
+    const mPrime = l - 0.1055613458 * okA - 0.0638541728 * okB;
+    const sPrime = l - 0.0894841775 * okA - 1.291485548 * okB;
+    const long = lPrime * lPrime * lPrime;
+    const medium = mPrime * mPrime * mPrime;
+    const short = sPrime * sPrime * sPrime;
+    // LMS -> linear sRGB.
+    return {
+        r: 4.0767416621 * long - 3.3077115913 * medium + 0.2309699292 * short,
+        g: -1.2684380046 * long + 2.6097574011 * medium - 0.3413193965 * short,
+        b: -0.0041960863 * long - 0.7034186147 * medium + 1.707614701 * short,
+    };
+}
+/**
+ * Block that converts a linear sRGB color (r, g, b) to OkLCh (l, c, h). Hue is in radians.
+ */
+export class FlowGraphRGBToOkLChBlock extends FlowGraphBlock {
+    constructor(config) {
+        super(config);
+        this.r = this.registerDataInput("r", RichTypeNumber, 0);
+        this.g = this.registerDataInput("g", RichTypeNumber, 0);
+        this.b = this.registerDataInput("b", RichTypeNumber, 0);
+        this.l = this.registerDataOutput("l", RichTypeNumber, 0);
+        this.c = this.registerDataOutput("c", RichTypeNumber, 0);
+        this.h = this.registerDataOutput("h", RichTypeNumber, 0);
+    }
+    _updateOutputs(context) {
+        const { l, c, h } = RgbToOkLch(this.r.getValue(context), this.g.getValue(context), this.b.getValue(context));
+        this.l.setValue(l, context);
+        this.c.setValue(c, context);
+        this.h.setValue(h, context);
+    }
+    getClassName() {
+        return "FlowGraphRGBToOkLChBlock" /* FlowGraphBlockNames.RGBToOkLCh */;
+    }
+}
+/**
+ * Block that converts an OkLCh color (l, c, h) to linear sRGB (r, g, b). Hue is in radians.
+ */
+export class FlowGraphRGBFromOkLChBlock extends FlowGraphBlock {
+    constructor(config) {
+        super(config);
+        this.l = this.registerDataInput("l", RichTypeNumber, 0);
+        this.c = this.registerDataInput("c", RichTypeNumber, 0);
+        this.h = this.registerDataInput("h", RichTypeNumber, 0);
+        this.r = this.registerDataOutput("r", RichTypeNumber, 0);
+        this.g = this.registerDataOutput("g", RichTypeNumber, 0);
+        this.b = this.registerDataOutput("b", RichTypeNumber, 0);
+    }
+    _updateOutputs(context) {
+        const { r, g, b } = OkLchToRgb(this.l.getValue(context), this.c.getValue(context), this.h.getValue(context));
+        this.r.setValue(r, context);
+        this.g.setValue(g, context);
+        this.b.setValue(b, context);
+    }
+    getClassName() {
+        return "FlowGraphRGBFromOkLChBlock" /* FlowGraphBlockNames.RGBFromOkLCh */;
+    }
+}
 let _Registered = false;
 /**
  * Register side effects for flowGraphMathBlocks.
@@ -1046,6 +1206,7 @@ export function RegisterFlowGraphMathBlocks() {
     RegisterClass("FlowGraphRandomBlock" /* FlowGraphBlockNames.Random */, FlowGraphRandomBlock);
     RegisterClass("FlowGraphEBlock" /* FlowGraphBlockNames.E */, FlowGraphEBlock);
     RegisterClass("FlowGraphPIBlock" /* FlowGraphBlockNames.PI */, FlowGraphPiBlock);
+    RegisterClass("FlowGraphTauBlock" /* FlowGraphBlockNames.Tau */, FlowGraphTauBlock);
     RegisterClass("FlowGraphInfBlock" /* FlowGraphBlockNames.Inf */, FlowGraphInfBlock);
     RegisterClass("FlowGraphNaNBlock" /* FlowGraphBlockNames.NaN */, FlowGraphNaNBlock);
     RegisterClass("FlowGraphAbsBlock" /* FlowGraphBlockNames.Abs */, FlowGraphAbsBlock);
@@ -1062,6 +1223,10 @@ export function RegisterFlowGraphMathBlocks() {
     RegisterClass("FlowGraphClampBlock" /* FlowGraphBlockNames.Clamp */, FlowGraphClampBlock);
     RegisterClass("FlowGraphSaturateBlock" /* FlowGraphBlockNames.Saturate */, FlowGraphSaturateBlock);
     RegisterClass("FlowGraphMathInterpolationBlock" /* FlowGraphBlockNames.MathInterpolation */, FlowGraphMathInterpolationBlock);
+    RegisterClass("FlowGraphMathSlerpBlock" /* FlowGraphBlockNames.MathSlerp */, FlowGraphMathSlerpBlock);
+    RegisterClass("FlowGraphSmoothStepBlock" /* FlowGraphBlockNames.SmoothStep */, FlowGraphMathSmoothStepBlock);
+    RegisterClass("FlowGraphRGBToOkLChBlock" /* FlowGraphBlockNames.RGBToOkLCh */, FlowGraphRGBToOkLChBlock);
+    RegisterClass("FlowGraphRGBFromOkLChBlock" /* FlowGraphBlockNames.RGBFromOkLCh */, FlowGraphRGBFromOkLChBlock);
     RegisterClass("FlowGraphEqualityBlock" /* FlowGraphBlockNames.Equality */, FlowGraphEqualityBlock);
     RegisterClass("FlowGraphLessThanBlock" /* FlowGraphBlockNames.LessThan */, FlowGraphLessThanBlock);
     RegisterClass("FlowGraphLessThanOrEqualBlock" /* FlowGraphBlockNames.LessThanOrEqual */, FlowGraphLessThanOrEqualBlock);