@field/cascade 0.5.1 → 0.6.0

package/dist/runtime/builtins/math/definitions.d.ts

@@ -0,0 +1,845 @@
+import type { NodeExecutionContext } from "@field/cascade/contracts";
+import type { DefinitionNodeRegistration } from "../../types.js";
+/**
+ * Division and modulo by zero give **zero**, not `Infinity` or `NaN`.
+ *
+ * Both choices hide something, so this is the lesser one. A non-finite number
+ * flows downstream into a position and the geometry silently vanishes — a
+ * blank frame with no error anywhere, which is the hardest thing to diagnose
+ * here. And a zero divisor is almost always a parameter nobody set yet rather
+ * than an intent, so zero is also the likelier thing to have meant.
+ */
+declare function divide(a: number, b: number): number;
+declare const BINARY: {
+    readonly add: (a: number, b: number) => number;
+    readonly subtract: (a: number, b: number) => number;
+    readonly multiply: (a: number, b: number) => number;
+    readonly divide: typeof divide;
+    readonly power: (a: number, b: number) => number;
+    readonly modulo: (a: number, b: number) => number;
+    readonly min: (a: number, b: number) => number;
+    readonly max: (a: number, b: number) => number;
+    readonly atan2: (a: number, b: number) => number;
+};
+declare const UNARY: {
+    readonly abs: (x: number) => number;
+    readonly negate: (a: number) => number;
+    readonly floor: (x: number) => number;
+    readonly ceil: (x: number) => number;
+    readonly round: (x: number) => number;
+    readonly sqrt: (a: number) => number;
+    readonly sign: (x: number) => number;
+    readonly sin: (x: number) => number;
+    readonly cos: (x: number) => number;
+    readonly tan: (x: number) => number;
+    readonly asin: (a: number) => number;
+    readonly acos: (a: number) => number;
+    readonly exp: (x: number) => number;
+    readonly log: (a: number) => number;
+    readonly radians: (a: number) => number;
+    readonly degrees: (a: number) => number;
+    /** The fractional part, always positive — `fract(-0.25)` is `0.75`, which is
+     *  what a repeating pattern wants and what GLSL's `fract` does. */
+    readonly fract: (a: number) => number;
+};
+declare const COMPARE: {
+    readonly greater: (a: number, b: number) => boolean;
+    readonly "greater-or-equal": (a: number, b: number) => boolean;
+    readonly less: (a: number, b: number) => boolean;
+    readonly "less-or-equal": (a: number, b: number) => boolean;
+    readonly equal: (a: number, b: number) => boolean;
+    readonly "not-equal": (a: number, b: number) => boolean;
+};
+export declare const binaryDefinition: {
+    readonly apiVersion: 1;
+    readonly label: "Binary Math";
+    readonly description: "Two values, one operation. Component-wise, and a scalar broadcasts against a vector.";
+    readonly icon: "Plus";
+    readonly runsOn: "portable";
+    readonly inputs: {
+        readonly a: {
+            readonly kind: "data";
+            readonly type: "any";
+            readonly default: 0;
+            readonly description: "First value.";
+        };
+        readonly b: {
+            readonly kind: "data";
+            readonly type: "any";
+            readonly default: 0;
+            readonly description: "Second value.";
+        };
+    };
+    readonly outputs: {
+        readonly value: {
+            readonly kind: "data";
+            readonly type: "any";
+        };
+    };
+    readonly props: {
+        readonly operation: {
+            readonly type: "string";
+            readonly default: "add";
+            readonly control: "select";
+            readonly options: {
+                value: string;
+                label: string;
+            }[];
+            readonly label: "Operation";
+        };
+    };
+};
+export declare function executeBinary(context: NodeExecutionContext<typeof binaryDefinition>): void;
+export declare const unaryDefinition: {
+    readonly apiVersion: 1;
+    readonly label: "Unary Math";
+    readonly description: "One value, one operation. Trigonometry is in radians.";
+    readonly icon: "FunctionSquare";
+    readonly runsOn: "portable";
+    readonly inputs: {
+        readonly value: {
+            readonly kind: "data";
+            readonly type: "any";
+            readonly default: 0;
+        };
+    };
+    readonly outputs: {
+        readonly value: {
+            readonly kind: "data";
+            readonly type: "any";
+        };
+    };
+    readonly props: {
+        readonly operation: {
+            readonly type: "string";
+            readonly default: "abs";
+            readonly control: "select";
+            readonly options: {
+                value: string;
+                label: string;
+            }[];
+            readonly label: "Operation";
+        };
+    };
+};
+export declare function executeUnary(context: NodeExecutionContext<typeof unaryDefinition>): void;
+export declare const clampDefinition: {
+    readonly apiVersion: 1;
+    readonly label: "Clamp";
+    readonly description: "Hold a value between two bounds.";
+    readonly icon: "Brackets";
+    readonly runsOn: "portable";
+    readonly inputs: {
+        readonly value: {
+            readonly kind: "data";
+            readonly type: "any";
+            readonly default: 0;
+        };
+        readonly min: {
+            readonly kind: "data";
+            readonly type: "any";
+            readonly default: 0;
+        };
+        readonly max: {
+            readonly kind: "data";
+            readonly type: "any";
+            readonly default: 1;
+        };
+    };
+    readonly outputs: {
+        readonly value: {
+            readonly kind: "data";
+            readonly type: "any";
+        };
+    };
+    readonly props: {};
+};
+export declare function executeClamp(context: NodeExecutionContext<typeof clampDefinition>): void;
+export declare const mixDefinition: {
+    readonly apiVersion: 1;
+    readonly label: "Mix";
+    readonly description: "Blend between two values. Houdini's lerp.";
+    readonly icon: "Blend";
+    readonly runsOn: "portable";
+    readonly inputs: {
+        readonly a: {
+            readonly kind: "data";
+            readonly type: "any";
+            readonly default: 0;
+            readonly description: "The value at 0.";
+        };
+        readonly b: {
+            readonly kind: "data";
+            readonly type: "any";
+            readonly default: 1;
+            readonly description: "The value at 1.";
+        };
+        readonly bias: {
+            readonly kind: "data";
+            readonly type: "float";
+            readonly default: 0.5;
+            readonly min: 0;
+            readonly max: 1;
+            readonly step: 0.01;
+            readonly description: "Not clamped: past 0..1 this extrapolates, which is useful.";
+        };
+    };
+    readonly outputs: {
+        readonly value: {
+            readonly kind: "data";
+            readonly type: "any";
+        };
+    };
+    readonly props: {};
+};
+export declare function executeMix(context: NodeExecutionContext<typeof mixDefinition>): void;
+export declare const compareDefinition: {
+    readonly apiVersion: 1;
+    readonly label: "Compare";
+    readonly description: "Test two values. Outputs a bool, for a Switch.";
+    readonly icon: "Equal";
+    readonly runsOn: "portable";
+    readonly inputs: {
+        readonly a: {
+            readonly kind: "data";
+            readonly type: "float";
+            readonly default: 0;
+        };
+        readonly b: {
+            readonly kind: "data";
+            readonly type: "float";
+            readonly default: 0;
+        };
+    };
+    readonly outputs: {
+        readonly result: {
+            readonly kind: "data";
+            readonly type: "bool";
+        };
+    };
+    readonly props: {
+        readonly operation: {
+            readonly type: "string";
+            readonly default: "greater";
+            readonly control: "select";
+            readonly options: {
+                value: string;
+                label: string;
+            }[];
+            readonly label: "Test";
+        };
+        /**
+         * Scalars only, unlike the rest of this namespace.
+         *
+         * "Is this vector greater than that one" has no single right answer — all
+         * components, any component, or the length — and a node that picked one
+         * silently would be wrong for the other two readings. A comparison feeding
+         * a `Switch` wants one boolean, so the input is a `float` and the question
+         * does not arise.
+         */
+        readonly tolerance: {
+            readonly type: "float";
+            readonly default: 0;
+            readonly min: 0;
+            readonly label: "Tolerance";
+            readonly description: "Slack for Equal and Not Equal. Floating point rarely lands on exactly equal.";
+        };
+    };
+};
+export declare function executeCompare(context: NodeExecutionContext<typeof compareDefinition>): void;
+export declare const binaryRegistration: {
+    kind: "definition-v1";
+    moduleId: string;
+    definition: {
+        readonly apiVersion: 1;
+        readonly label: "Binary Math";
+        readonly description: "Two values, one operation. Component-wise, and a scalar broadcasts against a vector.";
+        readonly icon: "Plus";
+        readonly runsOn: "portable";
+        readonly inputs: {
+            readonly a: {
+                readonly kind: "data";
+                readonly type: "any";
+                readonly default: 0;
+                readonly description: "First value.";
+            };
+            readonly b: {
+                readonly kind: "data";
+                readonly type: "any";
+                readonly default: 0;
+                readonly description: "Second value.";
+            };
+        };
+        readonly outputs: {
+            readonly value: {
+                readonly kind: "data";
+                readonly type: "any";
+            };
+        };
+        readonly props: {
+            readonly operation: {
+                readonly type: "string";
+                readonly default: "add";
+                readonly control: "select";
+                readonly options: {
+                    value: string;
+                    label: string;
+                }[];
+                readonly label: "Operation";
+            };
+        };
+    };
+    loadExecute: () => Promise<(context: NodeExecutionContext<{
+        readonly apiVersion: 1;
+        readonly label: "Binary Math";
+        readonly description: "Two values, one operation. Component-wise, and a scalar broadcasts against a vector.";
+        readonly icon: "Plus";
+        readonly runsOn: "portable";
+        readonly inputs: {
+            readonly a: {
+                readonly kind: "data";
+                readonly type: "any";
+                readonly default: 0;
+                readonly description: "First value.";
+            };
+            readonly b: {
+                readonly kind: "data";
+                readonly type: "any";
+                readonly default: 0;
+                readonly description: "Second value.";
+            };
+        };
+        readonly outputs: {
+            readonly value: {
+                readonly kind: "data";
+                readonly type: "any";
+            };
+        };
+        readonly props: {
+            readonly operation: {
+                readonly type: "string";
+                readonly default: "add";
+                readonly control: "select";
+                readonly options: {
+                    value: string;
+                    label: string;
+                }[];
+                readonly label: "Operation";
+            };
+        };
+    }>) => void>;
+};
+export declare const unaryRegistration: {
+    kind: "definition-v1";
+    moduleId: string;
+    definition: {
+        readonly apiVersion: 1;
+        readonly label: "Unary Math";
+        readonly description: "One value, one operation. Trigonometry is in radians.";
+        readonly icon: "FunctionSquare";
+        readonly runsOn: "portable";
+        readonly inputs: {
+            readonly value: {
+                readonly kind: "data";
+                readonly type: "any";
+                readonly default: 0;
+            };
+        };
+        readonly outputs: {
+            readonly value: {
+                readonly kind: "data";
+                readonly type: "any";
+            };
+        };
+        readonly props: {
+            readonly operation: {
+                readonly type: "string";
+                readonly default: "abs";
+                readonly control: "select";
+                readonly options: {
+                    value: string;
+                    label: string;
+                }[];
+                readonly label: "Operation";
+            };
+        };
+    };
+    loadExecute: () => Promise<(context: NodeExecutionContext<{
+        readonly apiVersion: 1;
+        readonly label: "Unary Math";
+        readonly description: "One value, one operation. Trigonometry is in radians.";
+        readonly icon: "FunctionSquare";
+        readonly runsOn: "portable";
+        readonly inputs: {
+            readonly value: {
+                readonly kind: "data";
+                readonly type: "any";
+                readonly default: 0;
+            };
+        };
+        readonly outputs: {
+            readonly value: {
+                readonly kind: "data";
+                readonly type: "any";
+            };
+        };
+        readonly props: {
+            readonly operation: {
+                readonly type: "string";
+                readonly default: "abs";
+                readonly control: "select";
+                readonly options: {
+                    value: string;
+                    label: string;
+                }[];
+                readonly label: "Operation";
+            };
+        };
+    }>) => void>;
+};
+export declare const clampRegistration: {
+    kind: "definition-v1";
+    moduleId: string;
+    definition: {
+        readonly apiVersion: 1;
+        readonly label: "Clamp";
+        readonly description: "Hold a value between two bounds.";
+        readonly icon: "Brackets";
+        readonly runsOn: "portable";
+        readonly inputs: {
+            readonly value: {
+                readonly kind: "data";
+                readonly type: "any";
+                readonly default: 0;
+            };
+            readonly min: {
+                readonly kind: "data";
+                readonly type: "any";
+                readonly default: 0;
+            };
+            readonly max: {
+                readonly kind: "data";
+                readonly type: "any";
+                readonly default: 1;
+            };
+        };
+        readonly outputs: {
+            readonly value: {
+                readonly kind: "data";
+                readonly type: "any";
+            };
+        };
+        readonly props: {};
+    };
+    loadExecute: () => Promise<(context: NodeExecutionContext<{
+        readonly apiVersion: 1;
+        readonly label: "Clamp";
+        readonly description: "Hold a value between two bounds.";
+        readonly icon: "Brackets";
+        readonly runsOn: "portable";
+        readonly inputs: {
+            readonly value: {
+                readonly kind: "data";
+                readonly type: "any";
+                readonly default: 0;
+            };
+            readonly min: {
+                readonly kind: "data";
+                readonly type: "any";
+                readonly default: 0;
+            };
+            readonly max: {
+                readonly kind: "data";
+                readonly type: "any";
+                readonly default: 1;
+            };
+        };
+        readonly outputs: {
+            readonly value: {
+                readonly kind: "data";
+                readonly type: "any";
+            };
+        };
+        readonly props: {};
+    }>) => void>;
+};
+export declare const mixRegistration: {
+    kind: "definition-v1";
+    moduleId: string;
+    definition: {
+        readonly apiVersion: 1;
+        readonly label: "Mix";
+        readonly description: "Blend between two values. Houdini's lerp.";
+        readonly icon: "Blend";
+        readonly runsOn: "portable";
+        readonly inputs: {
+            readonly a: {
+                readonly kind: "data";
+                readonly type: "any";
+                readonly default: 0;
+                readonly description: "The value at 0.";
+            };
+            readonly b: {
+                readonly kind: "data";
+                readonly type: "any";
+                readonly default: 1;
+                readonly description: "The value at 1.";
+            };
+            readonly bias: {
+                readonly kind: "data";
+                readonly type: "float";
+                readonly default: 0.5;
+                readonly min: 0;
+                readonly max: 1;
+                readonly step: 0.01;
+                readonly description: "Not clamped: past 0..1 this extrapolates, which is useful.";
+            };
+        };
+        readonly outputs: {
+            readonly value: {
+                readonly kind: "data";
+                readonly type: "any";
+            };
+        };
+        readonly props: {};
+    };
+    loadExecute: () => Promise<(context: NodeExecutionContext<{
+        readonly apiVersion: 1;
+        readonly label: "Mix";
+        readonly description: "Blend between two values. Houdini's lerp.";
+        readonly icon: "Blend";
+        readonly runsOn: "portable";
+        readonly inputs: {
+            readonly a: {
+                readonly kind: "data";
+                readonly type: "any";
+                readonly default: 0;
+                readonly description: "The value at 0.";
+            };
+            readonly b: {
+                readonly kind: "data";
+                readonly type: "any";
+                readonly default: 1;
+                readonly description: "The value at 1.";
+            };
+            readonly bias: {
+                readonly kind: "data";
+                readonly type: "float";
+                readonly default: 0.5;
+                readonly min: 0;
+                readonly max: 1;
+                readonly step: 0.01;
+                readonly description: "Not clamped: past 0..1 this extrapolates, which is useful.";
+            };
+        };
+        readonly outputs: {
+            readonly value: {
+                readonly kind: "data";
+                readonly type: "any";
+            };
+        };
+        readonly props: {};
+    }>) => void>;
+};
+export declare const compareRegistration: {
+    kind: "definition-v1";
+    moduleId: string;
+    definition: {
+        readonly apiVersion: 1;
+        readonly label: "Compare";
+        readonly description: "Test two values. Outputs a bool, for a Switch.";
+        readonly icon: "Equal";
+        readonly runsOn: "portable";
+        readonly inputs: {
+            readonly a: {
+                readonly kind: "data";
+                readonly type: "float";
+                readonly default: 0;
+            };
+            readonly b: {
+                readonly kind: "data";
+                readonly type: "float";
+                readonly default: 0;
+            };
+        };
+        readonly outputs: {
+            readonly result: {
+                readonly kind: "data";
+                readonly type: "bool";
+            };
+        };
+        readonly props: {
+            readonly operation: {
+                readonly type: "string";
+                readonly default: "greater";
+                readonly control: "select";
+                readonly options: {
+                    value: string;
+                    label: string;
+                }[];
+                readonly label: "Test";
+            };
+            /**
+             * Scalars only, unlike the rest of this namespace.
+             *
+             * "Is this vector greater than that one" has no single right answer — all
+             * components, any component, or the length — and a node that picked one
+             * silently would be wrong for the other two readings. A comparison feeding
+             * a `Switch` wants one boolean, so the input is a `float` and the question
+             * does not arise.
+             */
+            readonly tolerance: {
+                readonly type: "float";
+                readonly default: 0;
+                readonly min: 0;
+                readonly label: "Tolerance";
+                readonly description: "Slack for Equal and Not Equal. Floating point rarely lands on exactly equal.";
+            };
+        };
+    };
+    loadExecute: () => Promise<(context: NodeExecutionContext<{
+        readonly apiVersion: 1;
+        readonly label: "Compare";
+        readonly description: "Test two values. Outputs a bool, for a Switch.";
+        readonly icon: "Equal";
+        readonly runsOn: "portable";
+        readonly inputs: {
+            readonly a: {
+                readonly kind: "data";
+                readonly type: "float";
+                readonly default: 0;
+            };
+            readonly b: {
+                readonly kind: "data";
+                readonly type: "float";
+                readonly default: 0;
+            };
+        };
+        readonly outputs: {
+            readonly result: {
+                readonly kind: "data";
+                readonly type: "bool";
+            };
+        };
+        readonly props: {
+            readonly operation: {
+                readonly type: "string";
+                readonly default: "greater";
+                readonly control: "select";
+                readonly options: {
+                    value: string;
+                    label: string;
+                }[];
+                readonly label: "Test";
+            };
+            /**
+             * Scalars only, unlike the rest of this namespace.
+             *
+             * "Is this vector greater than that one" has no single right answer — all
+             * components, any component, or the length — and a node that picked one
+             * silently would be wrong for the other two readings. A comparison feeding
+             * a `Switch` wants one boolean, so the input is a `float` and the question
+             * does not arise.
+             */
+            readonly tolerance: {
+                readonly type: "float";
+                readonly default: 0;
+                readonly min: 0;
+                readonly label: "Tolerance";
+                readonly description: "Slack for Equal and Not Equal. Floating point rarely lands on exactly equal.";
+            };
+        };
+    }>) => void>;
+};
+export declare const mathNodeRegistrations: readonly DefinitionNodeRegistration[];
+/** `[moduleId, definition]` pairs, the shape a host's palette builder wants. */
+export declare const mathNodeDefinitions: readonly [readonly ["cascade.math.Binary", {
+    readonly apiVersion: 1;
+    readonly label: "Binary Math";
+    readonly description: "Two values, one operation. Component-wise, and a scalar broadcasts against a vector.";
+    readonly icon: "Plus";
+    readonly runsOn: "portable";
+    readonly inputs: {
+        readonly a: {
+            readonly kind: "data";
+            readonly type: "any";
+            readonly default: 0;
+            readonly description: "First value.";
+        };
+        readonly b: {
+            readonly kind: "data";
+            readonly type: "any";
+            readonly default: 0;
+            readonly description: "Second value.";
+        };
+    };
+    readonly outputs: {
+        readonly value: {
+            readonly kind: "data";
+            readonly type: "any";
+        };
+    };
+    readonly props: {
+        readonly operation: {
+            readonly type: "string";
+            readonly default: "add";
+            readonly control: "select";
+            readonly options: {
+                value: string;
+                label: string;
+            }[];
+            readonly label: "Operation";
+        };
+    };
+}], readonly ["cascade.math.Unary", {
+    readonly apiVersion: 1;
+    readonly label: "Unary Math";
+    readonly description: "One value, one operation. Trigonometry is in radians.";
+    readonly icon: "FunctionSquare";
+    readonly runsOn: "portable";
+    readonly inputs: {
+        readonly value: {
+            readonly kind: "data";
+            readonly type: "any";
+            readonly default: 0;
+        };
+    };
+    readonly outputs: {
+        readonly value: {
+            readonly kind: "data";
+            readonly type: "any";
+        };
+    };
+    readonly props: {
+        readonly operation: {
+            readonly type: "string";
+            readonly default: "abs";
+            readonly control: "select";
+            readonly options: {
+                value: string;
+                label: string;
+            }[];
+            readonly label: "Operation";
+        };
+    };
+}], readonly ["cascade.math.Clamp", {
+    readonly apiVersion: 1;
+    readonly label: "Clamp";
+    readonly description: "Hold a value between two bounds.";
+    readonly icon: "Brackets";
+    readonly runsOn: "portable";
+    readonly inputs: {
+        readonly value: {
+            readonly kind: "data";
+            readonly type: "any";
+            readonly default: 0;
+        };
+        readonly min: {
+            readonly kind: "data";
+            readonly type: "any";
+            readonly default: 0;
+        };
+        readonly max: {
+            readonly kind: "data";
+            readonly type: "any";
+            readonly default: 1;
+        };
+    };
+    readonly outputs: {
+        readonly value: {
+            readonly kind: "data";
+            readonly type: "any";
+        };
+    };
+    readonly props: {};
+}], readonly ["cascade.math.Mix", {
+    readonly apiVersion: 1;
+    readonly label: "Mix";
+    readonly description: "Blend between two values. Houdini's lerp.";
+    readonly icon: "Blend";
+    readonly runsOn: "portable";
+    readonly inputs: {
+        readonly a: {
+            readonly kind: "data";
+            readonly type: "any";
+            readonly default: 0;
+            readonly description: "The value at 0.";
+        };
+        readonly b: {
+            readonly kind: "data";
+            readonly type: "any";
+            readonly default: 1;
+            readonly description: "The value at 1.";
+        };
+        readonly bias: {
+            readonly kind: "data";
+            readonly type: "float";
+            readonly default: 0.5;
+            readonly min: 0;
+            readonly max: 1;
+            readonly step: 0.01;
+            readonly description: "Not clamped: past 0..1 this extrapolates, which is useful.";
+        };
+    };
+    readonly outputs: {
+        readonly value: {
+            readonly kind: "data";
+            readonly type: "any";
+        };
+    };
+    readonly props: {};
+}], readonly ["cascade.math.Compare", {
+    readonly apiVersion: 1;
+    readonly label: "Compare";
+    readonly description: "Test two values. Outputs a bool, for a Switch.";
+    readonly icon: "Equal";
+    readonly runsOn: "portable";
+    readonly inputs: {
+        readonly a: {
+            readonly kind: "data";
+            readonly type: "float";
+            readonly default: 0;
+        };
+        readonly b: {
+            readonly kind: "data";
+            readonly type: "float";
+            readonly default: 0;
+        };
+    };
+    readonly outputs: {
+        readonly result: {
+            readonly kind: "data";
+            readonly type: "bool";
+        };
+    };
+    readonly props: {
+        readonly operation: {
+            readonly type: "string";
+            readonly default: "greater";
+            readonly control: "select";
+            readonly options: {
+                value: string;
+                label: string;
+            }[];
+            readonly label: "Test";
+        };
+        /**
+         * Scalars only, unlike the rest of this namespace.
+         *
+         * "Is this vector greater than that one" has no single right answer — all
+         * components, any component, or the length — and a node that picked one
+         * silently would be wrong for the other two readings. A comparison feeding
+         * a `Switch` wants one boolean, so the input is a `float` and the question
+         * does not arise.
+         */
+        readonly tolerance: {
+            readonly type: "float";
+            readonly default: 0;
+            readonly min: 0;
+            readonly label: "Tolerance";
+            readonly description: "Slack for Equal and Not Equal. Floating point rarely lands on exactly equal.";
+        };
+    };
+}]];
+export { BINARY, UNARY, COMPARE };
+//# sourceMappingURL=definitions.d.ts.map