@ringozz/godot 0.1.0

package/gen/classes/VisualShaderNodeFloatConstant.ts

@@ -0,0 +1,20 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { VisualShaderNodeConstant } from './VisualShaderNodeConstant.ts';
+
+/**
+ * Translated to {@link code skip-lint}float[/code] in the shader language.
+ */
+export class VisualShaderNodeFloatConstant extends VisualShaderNodeConstant {
+    constructor(name = 865) { super(name); }
+
+    /**
+     * A floating-point constant which represents a state of this node.
+     */
+    get constant(): number { return _C(this, 4283) as number; }
+    set constant(v: number) { _C(this, 10942, v); }
+
+    static readonly name = _R(865, VisualShaderNodeFloatConstant);
+}

package/gen/classes/VisualShaderNodeFloatFunc.ts

@@ -0,0 +1,158 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { VisualShaderNode } from './VisualShaderNode.ts';
+
+/**
+ * Accept a floating-point scalar (`x`) to the input port and transform it according to {@link function}.
+ */
+export class VisualShaderNodeFloatFunc extends VisualShaderNode {
+    constructor(name = 866) { super(name); }
+
+    /**
+     * A function to be applied to the scalar.
+     */
+    get _function(): Function { return _C(this, 4911) as Function; }
+    set _function(v: Function) { _C(this, 11504, v); }
+
+    static readonly name = _R(866, VisualShaderNodeFloatFunc);
+}
+
+export const Function = {
+    /**
+     * Returns the sine of the parameter. Translates to `sin(x)` in the Godot Shader Language.
+     */
+    FUNC_SIN: 0,
+    /**
+     * Returns the cosine of the parameter. Translates to `cos(x)` in the Godot Shader Language.
+     */
+    FUNC_COS: 1,
+    /**
+     * Returns the tangent of the parameter. Translates to `tan(x)` in the Godot Shader Language.
+     */
+    FUNC_TAN: 2,
+    /**
+     * Returns the arc-sine of the parameter. Translates to `asin(x)` in the Godot Shader Language.
+     */
+    FUNC_ASIN: 3,
+    /**
+     * Returns the arc-cosine of the parameter. Translates to `acos(x)` in the Godot Shader Language.
+     */
+    FUNC_ACOS: 4,
+    /**
+     * Returns the arc-tangent of the parameter. Translates to `atan(x)` in the Godot Shader Language.
+     */
+    FUNC_ATAN: 5,
+    /**
+     * Returns the hyperbolic sine of the parameter. Translates to `sinh(x)` in the Godot Shader Language.
+     */
+    FUNC_SINH: 6,
+    /**
+     * Returns the hyperbolic cosine of the parameter. Translates to `cosh(x)` in the Godot Shader Language.
+     */
+    FUNC_COSH: 7,
+    /**
+     * Returns the hyperbolic tangent of the parameter. Translates to `tanh(x)` in the Godot Shader Language.
+     */
+    FUNC_TANH: 8,
+    /**
+     * Returns the natural logarithm of the parameter. Translates to `log(x)` in the Godot Shader Language.
+     */
+    FUNC_LOG: 9,
+    /**
+     * Returns the natural exponentiation of the parameter. Translates to `exp(x)` in the Godot Shader Language.
+     */
+    FUNC_EXP: 10,
+    /**
+     * Returns the square root of the parameter. Translates to `sqrt(x)` in the Godot Shader Language.
+     */
+    FUNC_SQRT: 11,
+    /**
+     * Returns the absolute value of the parameter. Translates to `abs(x)` in the Godot Shader Language.
+     */
+    FUNC_ABS: 12,
+    /**
+     * Extracts the sign of the parameter. Translates to `sign(x)` in the Godot Shader Language.
+     */
+    FUNC_SIGN: 13,
+    /**
+     * Finds the nearest integer less than or equal to the parameter. Translates to `floor(x)` in the Godot Shader Language.
+     */
+    FUNC_FLOOR: 14,
+    /**
+     * Finds the nearest integer to the parameter. Translates to `round(x)` in the Godot Shader Language.
+     */
+    FUNC_ROUND: 15,
+    /**
+     * Finds the nearest integer that is greater than or equal to the parameter. Translates to `ceil(x)` in the Godot Shader Language.
+     */
+    FUNC_CEIL: 16,
+    /**
+     * Computes the fractional part of the argument. Translates to `fract(x)` in the Godot Shader Language.
+     */
+    FUNC_FRACT: 17,
+    /**
+     * Clamps the value between `0.0` and `1.0` using `min(max(x, 0.0), 1.0)`.
+     */
+    FUNC_SATURATE: 18,
+    /**
+     * Negates the `x` using `-(x)`.
+     */
+    FUNC_NEGATE: 19,
+    /**
+     * Returns the arc-hyperbolic-cosine of the parameter. Translates to `acosh(x)` in the Godot Shader Language.
+     */
+    FUNC_ACOSH: 20,
+    /**
+     * Returns the arc-hyperbolic-sine of the parameter. Translates to `asinh(x)` in the Godot Shader Language.
+     */
+    FUNC_ASINH: 21,
+    /**
+     * Returns the arc-hyperbolic-tangent of the parameter. Translates to `atanh(x)` in the Godot Shader Language.
+     */
+    FUNC_ATANH: 22,
+    /**
+     * Convert a quantity in radians to degrees. Translates to `degrees(x)` in the Godot Shader Language.
+     */
+    FUNC_DEGREES: 23,
+    /**
+     * Returns 2 raised by the power of the parameter. Translates to `exp2(x)` in the Godot Shader Language.
+     */
+    FUNC_EXP2: 24,
+    /**
+     * Returns the inverse of the square root of the parameter. Translates to `inversesqrt(x)` in the Godot Shader Language.
+     */
+    FUNC_INVERSE_SQRT: 25,
+    /**
+     * Returns the base 2 logarithm of the parameter. Translates to `log2(x)` in the Godot Shader Language.
+     */
+    FUNC_LOG2: 26,
+    /**
+     * Convert a quantity in degrees to radians. Translates to `radians(x)` in the Godot Shader Language.
+     */
+    FUNC_RADIANS: 27,
+    /**
+     * Finds reciprocal value of dividing 1 by `x` (i.e. `1 / x`).
+     */
+    FUNC_RECIPROCAL: 28,
+    /**
+     * Finds the nearest even integer to the parameter. Translates to `roundEven(x)` in the Godot Shader Language.
+     */
+    FUNC_ROUNDEVEN: 29,
+    /**
+     * Returns a value equal to the nearest integer to `x` whose absolute value is not larger than the absolute value of `x`. Translates to `trunc(x)` in the Godot Shader Language.
+     */
+    FUNC_TRUNC: 30,
+    /**
+     * Subtracts scalar `x` from 1 (i.e. `1 - x`).
+     */
+    FUNC_ONEMINUS: 31,
+    /**
+     * Represents the size of the {@link Function} enum.
+     */
+    FUNC_MAX: 32,
+} as const;
+
+export type Function = (typeof Function)[keyof typeof Function];
+

package/gen/classes/VisualShaderNodeFloatOp.ts

@@ -0,0 +1,70 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { VisualShaderNode } from './VisualShaderNode.ts';
+
+/**
+ * Applies {@link operator} to two floating-point inputs: `a` and `b`.
+ */
+export class VisualShaderNodeFloatOp extends VisualShaderNode {
+    constructor(name = 867) { super(name); }
+
+    /**
+     * An operator to be applied to the inputs.
+     */
+    get operator(): Operator { return _C(this, 5728) as Operator; }
+    set operator(v: Operator) { _C(this, 12193, v); }
+
+    static readonly name = _R(867, VisualShaderNodeFloatOp);
+}
+
+export const Operator = {
+    /**
+     * Sums two numbers using `a + b`.
+     */
+    OP_ADD: 0,
+    /**
+     * Subtracts two numbers using `a - b`.
+     */
+    OP_SUB: 1,
+    /**
+     * Multiplies two numbers using `a * b`.
+     */
+    OP_MUL: 2,
+    /**
+     * Divides two numbers using `a / b`.
+     */
+    OP_DIV: 3,
+    /**
+     * Calculates the remainder of two numbers. Translates to `mod(a, b)` in the Godot Shader Language.
+     */
+    OP_MOD: 4,
+    /**
+     * Raises the `a` to the power of `b`. Translates to `pow(a, b)` in the Godot Shader Language.
+     */
+    OP_POW: 5,
+    /**
+     * Returns the greater of two numbers. Translates to `max(a, b)` in the Godot Shader Language.
+     */
+    OP_MAX: 6,
+    /**
+     * Returns the lesser of two numbers. Translates to `min(a, b)` in the Godot Shader Language.
+     */
+    OP_MIN: 7,
+    /**
+     * Returns the arc-tangent of the parameters. Translates to `atan(a, b)` in the Godot Shader Language.
+     */
+    OP_ATAN2: 8,
+    /**
+     * Generates a step function by comparing `b`(x) to `a`(edge). Returns 0.0 if `x` is smaller than `edge` and otherwise 1.0. Translates to `step(a, b)` in the Godot Shader Language.
+     */
+    OP_STEP: 9,
+    /**
+     * Represents the size of the {@link Operator} enum.
+     */
+    OP_ENUM_SIZE: 10,
+} as const;
+
+export type Operator = (typeof Operator)[keyof typeof Operator];
+

package/gen/classes/VisualShaderNodeFloatParameter.ts

@@ -0,0 +1,72 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { VisualShaderNodeParameter } from './VisualShaderNodeParameter.ts';
+
+/**
+ * Translated to `uniform float` in the shader language.
+ */
+export class VisualShaderNodeFloatParameter extends VisualShaderNodeParameter {
+    constructor(name = 868) { super(name); }
+
+    /**
+     * A hint applied to the uniform, which controls the values it can take when set through the Inspector.
+     */
+    get hint(): Hint { return _C(this, 5038) as Hint; }
+    set hint(v: Hint) { _C(this, 11632, v); }
+
+    /**
+     * Maximum value for range hints. Used if {@link hint} is set to {@link HINT_RANGE} or {@link HINT_RANGE_STEP}.
+     */
+    get min(): number { return _C(this, 5537) as number; }
+    set min(v: number) { _C(this, 12048, v); }
+
+    /**
+     * Minimum value for range hints. Used if {@link hint} is set to {@link HINT_RANGE} or {@link HINT_RANGE_STEP}.
+     */
+    get max(): number { return _C(this, 5456) as number; }
+    set max(v: number) { _C(this, 11982, v); }
+
+    /**
+     * Step (increment) value for the range hint with step. Used if {@link hint} is set to {@link HINT_RANGE_STEP}.
+     */
+    get step(): number { return _C(this, 6553) as number; }
+    set step(v: number) { _C(this, 12891, v); }
+
+    /**
+     * Enables usage of the {@link defaultValue}.
+     */
+    get defaultValueEnabled(): boolean { return _C(this, 7874) as boolean; }
+    set defaultValueEnabled(v: boolean) { _C(this, 11070, v); }
+
+    /**
+     * A default value to be assigned within the shader.
+     */
+    get defaultValue(): number { return _C(this, 4456) as number; }
+    set defaultValue(v: number) { _C(this, 11069, v); }
+
+    static readonly name = _R(868, VisualShaderNodeFloatParameter);
+}
+
+export const Hint = {
+    /**
+     * No hint used.
+     */
+    HINT_NONE: 0,
+    /**
+     * A range hint for scalar value, which limits possible input values between {@link min} and {@link max}. Translated to `hint_range(min, max)` in shader code.
+     */
+    HINT_RANGE: 1,
+    /**
+     * A range hint for scalar value with step, which limits possible input values between {@link min} and {@link max}, with a step (increment) of {@link step}). Translated to `hint_range(min, max, step)` in shader code.
+     */
+    HINT_RANGE_STEP: 2,
+    /**
+     * Represents the size of the {@link Hint} enum.
+     */
+    HINT_MAX: 3,
+} as const;
+
+export type Hint = (typeof Hint)[keyof typeof Hint];
+

package/gen/classes/VisualShaderNodeFrame.ts

@@ -0,0 +1,58 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { VisualShaderNodeResizableBase } from './VisualShaderNodeResizableBase.ts';
+import type { PackedInt32Array } from '../heap-types/index.ts';
+import type { Color } from '../value-types/index.ts';
+
+/**
+ * A rectangular frame that can be used to group visual shader nodes together to improve organization.
+ * Nodes attached to the frame will move with it when it is dragged and it can automatically resize to enclose all attached nodes.
+ * Its title, description and color can be customized.
+ */
+export class VisualShaderNodeFrame extends VisualShaderNodeResizableBase {
+    constructor(name = 869) { super(name); }
+
+    /**
+     * Adds a node to the list of nodes attached to the frame. Should not be called directly, use the {@link VisualShader.attachNodeToFrame} method instead.
+     */
+    addAttachedNode(node: number): void { _C(this, 1181, node); }
+
+    /**
+     * Removes a node from the list of nodes attached to the frame. Should not be called directly, use the {@link VisualShader.detachNodeFromFrame} method instead.
+     */
+    removeAttachedNode(node: number): void { _C(this, 9887, node); }
+
+    /**
+     * The title of the node.
+     */
+    get title(): string { return _C(this, 6829) as string; }
+    set title(v: string) { _C(this, 13099, v); }
+
+    /**
+     * If `true`, the frame will be tinted with the color specified in {@link tintColor}.
+     */
+    get tintColorEnabled(): boolean { return _C(this, 8365) as boolean; }
+    set tintColorEnabled(v: boolean) { _C(this, 13092, v); }
+
+    /**
+     * The color of the frame when {@link tintColorEnabled} is `true`.
+     */
+    get tintColor(): Color { return _C(this, 6822) as Color; }
+    set tintColor(v: Color) { _C(this, 13091, v); }
+
+    /**
+     * If `true`, the frame will automatically resize to enclose all attached nodes.
+     */
+    get autoshrink(): boolean { return _C(this, 7778) as boolean; }
+    set autoshrink(v: boolean) { _C(this, 10591, v); }
+
+    /**
+     * The list of nodes attached to the frame.
+     */
+    get attachedNodes(): PackedInt32Array { return _C(this, 3805) as PackedInt32Array; }
+    set attachedNodes(v: PackedInt32Array) { _C(this, 10547, v); }
+
+    static readonly name = _R(869, VisualShaderNodeFrame);
+}

package/gen/classes/VisualShaderNodeFresnel.ts

@@ -0,0 +1,14 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { VisualShaderNode } from './VisualShaderNode.ts';
+
+/**
+ * Returns falloff based on the dot product of surface normal and view direction of camera (pass associated inputs to it).
+ */
+export class VisualShaderNodeFresnel extends VisualShaderNode {
+    constructor(name = 870) { super(name); }
+
+    static readonly name = _R(870, VisualShaderNodeFresnel);
+}

package/gen/classes/VisualShaderNodeGlobalExpression.ts

@@ -0,0 +1,14 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { VisualShaderNodeExpression } from './VisualShaderNodeExpression.ts';
+
+/**
+ * Custom Godot Shader Language expression, which is placed on top of the generated shader. You can place various function definitions inside to call later in {@link VisualShaderNodeExpression}s (which are injected in the main shader functions). You can also declare varyings, uniforms and global constants.
+ */
+export class VisualShaderNodeGlobalExpression extends VisualShaderNodeExpression {
+    constructor(name = 871) { super(name); }
+
+    static readonly name = _R(871, VisualShaderNodeGlobalExpression);
+}

package/gen/classes/VisualShaderNodeGroupBase.ts

@@ -0,0 +1,118 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { VisualShaderNodeResizableBase } from './VisualShaderNodeResizableBase.ts';
+
+/**
+ * Currently, has no direct usage, use the derived classes instead.
+ */
+export class VisualShaderNodeGroupBase extends VisualShaderNodeResizableBase {
+
+    /**
+     * Defines all input ports using a {@link String} formatted as a colon-separated list: `id,type,name;` (see {@link addInputPort}).
+     */
+    setInputs(inputs: string): void { _C(this, 11722, inputs); }
+
+    /**
+     * Returns a {@link String} description of the input ports as a colon-separated list using the format `id,type,name;` (see {@link addInputPort}).
+     */
+    getInputs(): string { return _C(this, 5127) as string; }
+
+    /**
+     * Defines all output ports using a {@link String} formatted as a colon-separated list: `id,type,name;` (see {@link addOutputPort}).
+     */
+    setOutputs(outputs: string): void { _C(this, 12224, outputs); }
+
+    /**
+     * Returns a {@link String} description of the output ports as a colon-separated list using the format `id,type,name;` (see {@link addOutputPort}).
+     */
+    getOutputs(): string { return _C(this, 5772) as string; }
+
+    /**
+     * Returns `true` if the specified port name does not override an existed port name and is valid within the shader.
+     */
+    isValidPortName(name: string): boolean { return _C(this, 8444, name) as boolean; }
+
+    /**
+     * Adds an input port with the specified `type` (see {@link VisualShaderNode.PortType}) and `name`.
+     */
+    addInputPort(id: number, type: number, name: string): void { _C(this, 1238, id, type, name); }
+
+    /**
+     * Removes the specified input port.
+     */
+    removeInputPort(id: number): void { _C(this, 9920, id); }
+
+    /**
+     * Returns the number of input ports in use. Alternative for {@link getFreeInputPortId}.
+     */
+    getInputPortCount(): number { return _C(this, 5119) as number; }
+
+    /**
+     * Returns `true` if the specified input port exists.
+     */
+    hasInputPort(id: number): boolean { return _C(this, 7405, id) as boolean; }
+
+    /**
+     * Removes all previously specified input ports.
+     */
+    clearInputPorts(): void { _C(this, 2276); }
+
+    /**
+     * Adds an output port with the specified `type` (see {@link VisualShaderNode.PortType}) and `name`.
+     */
+    addOutputPort(id: number, type: number, name: string): void { _C(this, 1265, id, type, name); }
+
+    /**
+     * Removes the specified output port.
+     */
+    removeOutputPort(id: number): void { _C(this, 9941, id); }
+
+    /**
+     * Returns the number of output ports in use. Alternative for {@link getFreeOutputPortId}.
+     */
+    getOutputPortCount(): number { return _C(this, 5767) as number; }
+
+    /**
+     * Returns `true` if the specified output port exists.
+     */
+    hasOutputPort(id: number): boolean { return _C(this, 7425, id) as boolean; }
+
+    /**
+     * Removes all previously specified output ports.
+     */
+    clearOutputPorts(): void { _C(this, 2286); }
+
+    /**
+     * Renames the specified input port.
+     */
+    setInputPortName(id: number, name: string): void { _C(this, 11719, id, name); }
+
+    /**
+     * Sets the specified input port's type (see {@link VisualShaderNode.PortType}).
+     */
+    setInputPortType(id: number, type: number): void { _C(this, 11720, id, type); }
+
+    /**
+     * Renames the specified output port.
+     */
+    setOutputPortName(id: number, name: string): void { _C(this, 12222, id, name); }
+
+    /**
+     * Sets the specified output port's type (see {@link VisualShaderNode.PortType}).
+     */
+    setOutputPortType(id: number, type: number): void { _C(this, 12223, id, type); }
+
+    /**
+     * Returns a free input port ID which can be used in {@link addInputPort}.
+     */
+    getFreeInputPortId(): number { return _C(this, 4893) as number; }
+
+    /**
+     * Returns a free output port ID which can be used in {@link addOutputPort}.
+     */
+    getFreeOutputPortId(): number { return _C(this, 4894) as number; }
+
+    static readonly name = _R(872, VisualShaderNodeGroupBase);
+}

package/gen/classes/VisualShaderNodeIf.ts

@@ -0,0 +1,17 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { VisualShaderNode } from './VisualShaderNode.ts';
+
+/**
+ * This visual shader node has six input ports:
+ * - Port **1** and **2** provide the two floating-point numbers `a` and `b` that will be compared.
+ * - Port **3** is the tolerance, which allows similar floating-point numbers to be considered equal.
+ * - Ports **4**, **5**, and **6** are the possible outputs, returned if `a == b`, `a > b`, or `a < b` respectively.
+ */
+export class VisualShaderNodeIf extends VisualShaderNode {
+    constructor(name = 873) { super(name); }
+
+    static readonly name = _R(873, VisualShaderNodeIf);
+}

package/gen/classes/VisualShaderNodeInput.ts

@@ -0,0 +1,32 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { VisualShaderNode } from './VisualShaderNode.ts';
+import type { Signal } from '../heap-types/index.ts';
+
+/**
+ * Gives access to input variables (built-ins) available for the shader. See the shading reference for the list of available built-ins for each shader type (check `Tutorials` section for link).
+ */
+export class VisualShaderNodeInput extends VisualShaderNode {
+    constructor(name = 874) { super(name); }
+
+    /**
+     * Returns a translated name of the current constant in the Godot Shader Language. E.g. `"ALBEDO"` if the {@link inputName} equal to `"albedo"`.
+     */
+    getInputRealName(): string { return _C(this, 5124) as string; }
+
+    /**
+     * One of the several input constants in lower-case style like: "vertex" (`VERTEX`) or "point_size" (`POINT_SIZE`).
+     */
+    get inputName(): string { return _C(this, 5116) as string; }
+    set inputName(v: string) { _C(this, 11716, v); }
+
+    /**
+     * Emitted when input is changed via {@link inputName}.
+     */
+    get inputTypeChanged(): Signal<() => void> { return _G(this, 7629) as Signal<() => void>; }
+    set inputTypeChanged(v: (() => void) | null) { _G(this, 7629, v); }
+
+    static readonly name = _R(874, VisualShaderNodeInput);
+}

package/gen/classes/VisualShaderNodeIntConstant.ts

@@ -0,0 +1,20 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { VisualShaderNodeConstant } from './VisualShaderNodeConstant.ts';
+
+/**
+ * Translated to {@link code skip-lint}int[/code] in the shader language.
+ */
+export class VisualShaderNodeIntConstant extends VisualShaderNodeConstant {
+    constructor(name = 875) { super(name); }
+
+    /**
+     * An integer constant which represents a state of this node.
+     */
+    get constant(): number { return _C(this, 4283) as number; }
+    set constant(v: number) { _C(this, 10942, v); }
+
+    static readonly name = _R(875, VisualShaderNodeIntConstant);
+}

package/gen/classes/VisualShaderNodeIntFunc.ts

@@ -0,0 +1,46 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { VisualShaderNode } from './VisualShaderNode.ts';
+
+/**
+ * Accept an integer scalar (`x`) to the input port and transform it according to {@link function}.
+ */
+export class VisualShaderNodeIntFunc extends VisualShaderNode {
+    constructor(name = 876) { super(name); }
+
+    /**
+     * A function to be applied to the scalar.
+     */
+    get _function(): Function { return _C(this, 4911) as Function; }
+    set _function(v: Function) { _C(this, 11504, v); }
+
+    static readonly name = _R(876, VisualShaderNodeIntFunc);
+}
+
+export const Function = {
+    /**
+     * Returns the absolute value of the parameter. Translates to `abs(x)` in the Godot Shader Language.
+     */
+    FUNC_ABS: 0,
+    /**
+     * Negates the `x` using `-(x)`.
+     */
+    FUNC_NEGATE: 1,
+    /**
+     * Extracts the sign of the parameter. Translates to `sign(x)` in the Godot Shader Language.
+     */
+    FUNC_SIGN: 2,
+    /**
+     * Returns the result of bitwise `NOT` operation on the integer. Translates to `~a` in the Godot Shader Language.
+     */
+    FUNC_BITWISE_NOT: 3,
+    /**
+     * Represents the size of the {@link Function} enum.
+     */
+    FUNC_MAX: 4,
+} as const;
+
+export type Function = (typeof Function)[keyof typeof Function];
+