@ringozz/godot 0.1.0

package/gen/classes/VisualShaderNodeColorOp.ts

@@ -0,0 +1,144 @@
+// 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 color inputs.
+ */
+export class VisualShaderNodeColorOp extends VisualShaderNode {
+    constructor(name = 849) { 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(849, VisualShaderNodeColorOp);
+}
+
+export const Operator = {
+    /**
+     * Produce a screen effect with the following formula:
+     *
+     * ```text
+     *
+     * result = vec3(1.0) - (vec3(1.0) - a) * (vec3(1.0) - b);
+     *
+     * ```
+     */
+    OP_SCREEN: 0,
+    /**
+     * Produce a difference effect with the following formula:
+     *
+     * ```text
+     *
+     * result = abs(a - b);
+     *
+     * ```
+     */
+    OP_DIFFERENCE: 1,
+    /**
+     * Produce a darken effect with the following formula:
+     *
+     * ```text
+     *
+     * result = min(a, b);
+     *
+     * ```
+     */
+    OP_DARKEN: 2,
+    /**
+     * Produce a lighten effect with the following formula:
+     *
+     * ```text
+     *
+     * result = max(a, b);
+     *
+     * ```
+     */
+    OP_LIGHTEN: 3,
+    /**
+     * Produce an overlay effect with the following formula:
+     *
+     * ```text
+     *
+     * for (int i = 0; i < 3; i++) {
+     * 	float base = a[i];
+     * 	float blend = b[i];
+     * 	if (base < 0.5) {
+     * 		result[i] = 2.0 * base * blend;
+     * 	} else {
+     * 		result[i] = 1.0 - 2.0 * (1.0 - blend) * (1.0 - base);
+     * 	}
+     * }
+     *
+     * ```
+     */
+    OP_OVERLAY: 4,
+    /**
+     * Produce a dodge effect with the following formula:
+     *
+     * ```text
+     *
+     * result = a / (vec3(1.0) - b);
+     *
+     * ```
+     */
+    OP_DODGE: 5,
+    /**
+     * Produce a burn effect with the following formula:
+     *
+     * ```text
+     *
+     * result = vec3(1.0) - (vec3(1.0) - a) / b;
+     *
+     * ```
+     */
+    OP_BURN: 6,
+    /**
+     * Produce a soft light effect with the following formula:
+     *
+     * ```text
+     *
+     * for (int i = 0; i < 3; i++) {
+     * 	float base = a[i];
+     * 	float blend = b[i];
+     * 	if (base < 0.5) {
+     * 		result[i] = base * (blend + 0.5);
+     * 	} else {
+     * 		result[i] = 1.0 - (1.0 - base) * (1.0 - (blend - 0.5));
+     * 	}
+     * }
+     *
+     * ```
+     */
+    OP_SOFT_LIGHT: 7,
+    /**
+     * Produce a hard light effect with the following formula:
+     *
+     * ```text
+     *
+     * for (int i = 0; i < 3; i++) {
+     * 	float base = a[i];
+     * 	float blend = b[i];
+     * 	if (base < 0.5) {
+     * 		result[i] = base * (2.0 * blend);
+     * 	} else {
+     * 		result[i] = 1.0 - (1.0 - base) * (1.0 - 2.0 * (blend - 0.5));
+     * 	}
+     * }
+     *
+     * ```
+     */
+    OP_HARD_LIGHT: 8,
+    /**
+     * Represents the size of the {@link Operator} enum.
+     */
+    OP_MAX: 9,
+} as const;
+
+export type Operator = (typeof Operator)[keyof typeof Operator];
+

package/gen/classes/VisualShaderNodeColorParameter.ts

@@ -0,0 +1,27 @@
+// 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';
+import type { Color } from '../value-types/index.ts';
+
+/**
+ * Translated to `uniform vec4` in the shader language.
+ */
+export class VisualShaderNodeColorParameter extends VisualShaderNodeParameter {
+    constructor(name = 850) { super(name); }
+
+    /**
+     * 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(): Color { return _C(this, 4456) as Color; }
+    set defaultValue(v: Color) { _C(this, 11069, v); }
+
+    static readonly name = _R(850, VisualShaderNodeColorParameter);
+}

package/gen/classes/VisualShaderNodeComment.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 { VisualShaderNodeFrame } from './VisualShaderNodeFrame.ts';
+
+/**
+ * This node was replaced by {@link VisualShaderNodeFrame} and only exists to preserve compatibility. In the {@link VisualShader} editor it behaves exactly like {@link VisualShaderNodeFrame}.
+ */
+export class VisualShaderNodeComment extends VisualShaderNodeFrame {
+    constructor(name = 851) { super(name); }
+
+    /**
+     * This property only exists to preserve data authored in earlier versions of Godot. It has currently no function.
+     */
+    get description(): string { return _C(this, 4484) as string; }
+    set description(v: string) { _C(this, 11096, v); }
+
+    static readonly name = _R(851, VisualShaderNodeComment);
+}

package/gen/classes/VisualShaderNodeCompare.ts

@@ -0,0 +1,124 @@
+// 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';
+
+/**
+ * Compares `a` and `b` of {@link type} by {@link function}. Returns a boolean scalar. Translates to `if` instruction in shader code.
+ */
+export class VisualShaderNodeCompare extends VisualShaderNode {
+    constructor(name = 852) { super(name); }
+
+    /**
+     * The type to be used in the comparison.
+     */
+    get type(): ComparisonType { return _C(this, 4248) as ComparisonType; }
+    set type(v: ComparisonType) { _C(this, 10929, v); }
+
+    /**
+     * A comparison function.
+     */
+    get _function(): Function { return _C(this, 4911) as Function; }
+    set _function(v: Function) { _C(this, 11504, v); }
+
+    /**
+     * Extra condition which is applied if {@link type} is set to {@link CTYPE_VECTOR_3D}.
+     */
+    get condition(): Condition { return _C(this, 4257) as Condition; }
+    set condition(v: Condition) { _C(this, 10934, v); }
+
+    static readonly name = _R(852, VisualShaderNodeCompare);
+}
+
+export const ComparisonType = {
+    /**
+     * A floating-point scalar.
+     */
+    CTYPE_SCALAR: 0,
+    /**
+     * An integer scalar.
+     */
+    CTYPE_SCALAR_INT: 1,
+    /**
+     * An unsigned integer scalar.
+     */
+    CTYPE_SCALAR_UINT: 2,
+    /**
+     * A 2D vector type.
+     */
+    CTYPE_VECTOR_2D: 3,
+    /**
+     * A 3D vector type.
+     */
+    CTYPE_VECTOR_3D: 4,
+    /**
+     * A 4D vector type.
+     */
+    CTYPE_VECTOR_4D: 5,
+    /**
+     * A boolean type.
+     */
+    CTYPE_BOOLEAN: 6,
+    /**
+     * A transform (`mat4`) type.
+     */
+    CTYPE_TRANSFORM: 7,
+    /**
+     * Represents the size of the {@link ComparisonType} enum.
+     */
+    CTYPE_MAX: 8,
+} as const;
+
+export type ComparisonType = (typeof ComparisonType)[keyof typeof ComparisonType];
+
+export const Function = {
+    /**
+     * Comparison for equality (`a == b`).
+     */
+    FUNC_EQUAL: 0,
+    /**
+     * Comparison for inequality (`a != b`).
+     */
+    FUNC_NOT_EQUAL: 1,
+    /**
+     * Comparison for greater than (`a > b`). Cannot be used if {@link type} set to {@link CTYPE_BOOLEAN} or {@link CTYPE_TRANSFORM}.
+     */
+    FUNC_GREATER_THAN: 2,
+    /**
+     * Comparison for greater than or equal (`a >= b`). Cannot be used if {@link type} set to {@link CTYPE_BOOLEAN} or {@link CTYPE_TRANSFORM}.
+     */
+    FUNC_GREATER_THAN_EQUAL: 3,
+    /**
+     * Comparison for less than (`a < b`). Cannot be used if {@link type} set to {@link CTYPE_BOOLEAN} or {@link CTYPE_TRANSFORM}.
+     */
+    FUNC_LESS_THAN: 4,
+    /**
+     * Comparison for less than or equal (`a <= b`). Cannot be used if {@link type} set to {@link CTYPE_BOOLEAN} or {@link CTYPE_TRANSFORM}.
+     */
+    FUNC_LESS_THAN_EQUAL: 5,
+    /**
+     * Represents the size of the {@link Function} enum.
+     */
+    FUNC_MAX: 6,
+} as const;
+
+export type Function = (typeof Function)[keyof typeof Function];
+
+export const Condition = {
+    /**
+     * The result will be `true` if all components in the vector satisfy the comparison condition.
+     */
+    COND_ALL: 0,
+    /**
+     * The result will be `true` if any component in the vector satisfies the comparison condition.
+     */
+    COND_ANY: 1,
+    /**
+     * Represents the size of the {@link Condition} enum.
+     */
+    COND_MAX: 2,
+} as const;
+
+export type Condition = (typeof Condition)[keyof typeof Condition];
+

package/gen/classes/VisualShaderNodeConstant.ts

@@ -0,0 +1,13 @@
+// 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 is an abstract class. See the derived types for descriptions of the possible values.
+ */
+export class VisualShaderNodeConstant extends VisualShaderNode {
+
+    static readonly name = _R(853, VisualShaderNodeConstant);
+}

package/gen/classes/VisualShaderNodeCubemap.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 { VisualShaderNode } from './VisualShaderNode.ts';
+import type { TextureLayered } from './TextureLayered.ts';
+
+/**
+ * Translated to `texture(cubemap, vec3)` in the shader language. Returns a color vector and alpha channel as scalar.
+ */
+export class VisualShaderNodeCubemap extends VisualShaderNode {
+    constructor(name = 854) { super(name); }
+
+    /**
+     * Defines which source should be used for the sampling.
+     */
+    get source(): Source { return _C(this, 6455) as Source; }
+    set source(v: Source) { _C(this, 12812, v); }
+
+    /**
+     * The {@link Cubemap} texture to sample when using {@link SOURCE_TEXTURE} as {@link source}.
+     */
+    get cubeMap(): TextureLayered { return _C(this, 4337) as TextureLayered; }
+    set cubeMap(v: TextureLayered) { _C(this, 10979, v); }
+
+    /**
+     * Defines the type of data provided by the source texture.
+     */
+    get textureType(): TextureType { return _C(this, 6757) as TextureType; }
+    set textureType(v: TextureType) { _C(this, 13049, v); }
+
+    static readonly name = _R(854, VisualShaderNodeCubemap);
+}
+
+export const Source = {
+    /**
+     * Use the {@link Cubemap} set via {@link cubeMap}. If this is set to {@link source}, the `samplerCube` port is ignored.
+     */
+    SOURCE_TEXTURE: 0,
+    /**
+     * Use the {@link Cubemap} sampler reference passed via the `samplerCube` port. If this is set to {@link source}, the {@link cubeMap} texture is ignored.
+     */
+    SOURCE_PORT: 1,
+    /**
+     * Represents the size of the {@link Source} enum.
+     */
+    SOURCE_MAX: 2,
+} as const;
+
+export type Source = (typeof Source)[keyof typeof Source];
+
+export const TextureType = {
+    /**
+     * No hints are added to the uniform declaration.
+     */
+    TYPE_DATA: 0,
+    /**
+     * Adds `source_color` as hint to the uniform declaration for proper conversion from nonlinear sRGB encoding to linear encoding.
+     */
+    TYPE_COLOR: 1,
+    /**
+     * Adds `hint_normal` as hint to the uniform declaration, which internally converts the texture for proper usage as normal map.
+     */
+    TYPE_NORMAL_MAP: 2,
+    /**
+     * Represents the size of the {@link TextureType} enum.
+     */
+    TYPE_MAX: 3,
+} as const;
+
+export type TextureType = (typeof TextureType)[keyof typeof TextureType];
+

package/gen/classes/VisualShaderNodeCubemapParameter.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 { VisualShaderNodeTextureParameter } from './VisualShaderNodeTextureParameter.ts';
+
+/**
+ * Translated to `uniform samplerCube` in the shader language. The output value can be used as port for {@link VisualShaderNodeCubemap}.
+ */
+export class VisualShaderNodeCubemapParameter extends VisualShaderNodeTextureParameter {
+    constructor(name = 855) { super(name); }
+
+    static readonly name = _R(855, VisualShaderNodeCubemapParameter);
+}

package/gen/classes/VisualShaderNodeCurveTexture.ts

@@ -0,0 +1,21 @@
+// 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 { CurveTexture } from './CurveTexture.ts';
+
+/**
+ * Comes with a built-in editor for texture's curves.
+ */
+export class VisualShaderNodeCurveTexture extends VisualShaderNodeResizableBase {
+    constructor(name = 856) { super(name); }
+
+    /**
+     * The source texture.
+     */
+    get texture(): CurveTexture { return _C(this, 6726) as CurveTexture; }
+    set texture(v: CurveTexture) { _C(this, 13024, v); }
+
+    static readonly name = _R(856, VisualShaderNodeCurveTexture);
+}

package/gen/classes/VisualShaderNodeCurveXYZTexture.ts

@@ -0,0 +1,21 @@
+// 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 { CurveXYZTexture } from './CurveXYZTexture.ts';
+
+/**
+ * Comes with a built-in editor for texture's curves.
+ */
+export class VisualShaderNodeCurveXYZTexture extends VisualShaderNodeResizableBase {
+    constructor(name = 857) { super(name); }
+
+    /**
+     * The source texture.
+     */
+    get texture(): CurveXYZTexture { return _C(this, 6726) as CurveXYZTexture; }
+    set texture(v: CurveXYZTexture) { _C(this, 13024, v); }
+
+    static readonly name = _R(857, VisualShaderNodeCurveXYZTexture);
+}

package/gen/classes/VisualShaderNodeCustom.ts

@@ -0,0 +1,38 @@
+// 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';
+import type { GodotArray, PackedStringArray, Variant } from '../heap-types/index.ts';
+import type { Mode } from './CSGPolygon3D.ts';
+import type { Type } from './VisualShader.ts';
+import type { PortType } from './VisualShaderNode.ts';
+
+/**
+ * By inheriting this class you can create a custom {@link VisualShader} script addon which will be automatically added to the Visual Shader Editor. The {@link VisualShaderNode}'s behavior is defined by overriding the provided virtual methods.
+ * In order for the node to be registered as an editor addon, you must use the `@tool` annotation and provide a `class_name` for your custom script. For example:
+ *
+ * ```text
+ *
+ * @tool
+ * extends VisualShaderNodeCustom
+ * class_name VisualShaderNodeNoise
+ *
+ * ```
+ */
+export class VisualShaderNodeCustom extends VisualShaderNode {
+    constructor(name = 858) { super(name); }
+
+    /**
+     * Returns the selected index of the drop-down list option within a graph. You may use this function to define the specific behavior in the {@link _getCode} or {@link _getGlobalCode}.
+     */
+    getOptionIndex(option: number): number { return _C(this, 5731, option) as number; }
+
+    get initialized(): boolean { return _C(this, 1017) as boolean; }
+    set initialized(v: boolean) { _C(this, 1030, v); }
+
+    get properties(): string { return _C(this, 1011) as string; }
+    set properties(v: string) { _C(this, 1041, v); }
+
+    static readonly name = _R(858, VisualShaderNodeCustom);
+}

package/gen/classes/VisualShaderNodeDerivativeFunc.ts

@@ -0,0 +1,100 @@
+// 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 node is only available in `Fragment` and `Light` visual shaders.
+ */
+export class VisualShaderNodeDerivativeFunc extends VisualShaderNode {
+    constructor(name = 859) { super(name); }
+
+    /**
+     * A type of operands and returned value.
+     */
+    get opType(): OpType { return _C(this, 5721) as OpType; }
+    set opType(v: OpType) { _C(this, 12189, v); }
+
+    /**
+     * A derivative function type.
+     */
+    get _function(): Function { return _C(this, 4911) as Function; }
+    set _function(v: Function) { _C(this, 11504, v); }
+
+    /**
+     * Sets the level of precision to use for the derivative function. When using the Compatibility renderer, this setting has no effect.
+     */
+    get precision(): Precision { return _C(this, 5985) as Precision; }
+    set precision(v: Precision) { _C(this, 12393, v); }
+
+    static readonly name = _R(859, VisualShaderNodeDerivativeFunc);
+}
+
+export const OpType = {
+    /**
+     * A floating-point scalar.
+     */
+    OP_TYPE_SCALAR: 0,
+    /**
+     * A 2D vector type.
+     */
+    OP_TYPE_VECTOR_2D: 1,
+    /**
+     * A 3D vector type.
+     */
+    OP_TYPE_VECTOR_3D: 2,
+    /**
+     * A 4D vector type.
+     */
+    OP_TYPE_VECTOR_4D: 3,
+    /**
+     * Represents the size of the {@link OpType} enum.
+     */
+    OP_TYPE_MAX: 4,
+} as const;
+
+export type OpType = (typeof OpType)[keyof typeof OpType];
+
+export const Function = {
+    /**
+     * Sum of absolute derivative in `x` and `y`.
+     */
+    FUNC_SUM: 0,
+    /**
+     * Derivative in `x` using local differencing.
+     */
+    FUNC_X: 1,
+    /**
+     * Derivative in `y` using local differencing.
+     */
+    FUNC_Y: 2,
+    /**
+     * Represents the size of the {@link Function} enum.
+     */
+    FUNC_MAX: 3,
+} as const;
+
+export type Function = (typeof Function)[keyof typeof Function];
+
+export const Precision = {
+    /**
+     * No precision is specified, the GPU driver is allowed to use whatever level of precision it chooses. This is the default option and is equivalent to using `dFdx()` or `dFdy()` in text shaders.
+     */
+    PRECISION_NONE: 0,
+    /**
+     * The derivative will be calculated using the current fragment's neighbors (which may not include the current fragment). This tends to be faster than using {@link PRECISION_FINE}, but may not be suitable when more precision is needed. This is equivalent to using `dFdxCoarse()` or `dFdyCoarse()` in text shaders.
+     */
+    PRECISION_COARSE: 1,
+    /**
+     * The derivative will be calculated using the current fragment and its immediate neighbors. This tends to be slower than using {@link PRECISION_COARSE}, but may be necessary when more precision is needed. This is equivalent to using `dFdxFine()` or `dFdyFine()` in text shaders.
+     */
+    PRECISION_FINE: 2,
+    /**
+     * Represents the size of the {@link Precision} enum.
+     */
+    PRECISION_MAX: 3,
+} as const;
+
+export type Precision = (typeof Precision)[keyof typeof Precision];
+

package/gen/classes/VisualShaderNodeDeterminant.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';
+
+/**
+ * Translates to `determinant(x)` in the shader language.
+ */
+export class VisualShaderNodeDeterminant extends VisualShaderNode {
+    constructor(name = 860) { super(name); }
+
+    static readonly name = _R(860, VisualShaderNodeDeterminant);
+}

package/gen/classes/VisualShaderNodeDistanceFade.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';
+
+/**
+ * The distance fade effect fades out each pixel based on its distance to another object.
+ */
+export class VisualShaderNodeDistanceFade extends VisualShaderNode {
+    constructor(name = 861) { super(name); }
+
+    static readonly name = _R(861, VisualShaderNodeDistanceFade);
+}

package/gen/classes/VisualShaderNodeDotProduct.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';
+
+/**
+ * Translates to `dot(a, b)` in the shader language.
+ */
+export class VisualShaderNodeDotProduct extends VisualShaderNode {
+    constructor(name = 862) { super(name); }
+
+    static readonly name = _R(862, VisualShaderNodeDotProduct);
+}

package/gen/classes/VisualShaderNodeExpression.ts

@@ -0,0 +1,21 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { VisualShaderNodeGroupBase } from './VisualShaderNodeGroupBase.ts';
+
+/**
+ * Custom Godot Shading Language expression, with a custom number of input and output ports.
+ * The provided code is directly injected into the graph's matching shader function (`vertex`, `fragment`, or `light`), so it cannot be used to declare functions, varyings, uniforms, or global constants. See {@link VisualShaderNodeGlobalExpression} for such global definitions.
+ */
+export class VisualShaderNodeExpression extends VisualShaderNodeGroupBase {
+    constructor(name = 863) { super(name); }
+
+    /**
+     * An expression in Godot Shading Language, which will be injected at the start of the graph's matching shader function (`vertex`, `fragment`, or `light`), and thus cannot be used to declare functions, varyings, uniforms, or global constants.
+     */
+    get expression(): string { return _C(this, 4711) as string; }
+    set expression(v: string) { _C(this, 11331, v); }
+
+    static readonly name = _R(863, VisualShaderNodeExpression);
+}

package/gen/classes/VisualShaderNodeFaceForward.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 { VisualShaderNodeVectorBase } from './VisualShaderNodeVectorBase.ts';
+
+/**
+ * Translates to `faceforward(N, I, Nref)` in the shader language. The function has three vector parameters: `N`, the vector to orient, `I`, the incident vector, and `Nref`, the reference vector. If the dot product of `I` and `Nref` is smaller than zero the return value is `N`. Otherwise, `-N` is returned.
+ */
+export class VisualShaderNodeFaceForward extends VisualShaderNodeVectorBase {
+    constructor(name = 864) { super(name); }
+
+    static readonly name = _R(864, VisualShaderNodeFaceForward);
+}