@ringozz/godot 0.1.0

package/gen/classes/VisualShader.ts

@@ -0,0 +1,247 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Shader } from './Shader.ts';
+import type { Error } from '../global-enums.ts';
+import type { GodotArray, GodotDictionary, PackedInt32Array, StringName } from '../heap-types/index.ts';
+import type { Vector2 } from '../value-types/index.ts';
+import type { Mode } from './CSGPolygon3D.ts';
+import type { VisualShaderNode } from './VisualShaderNode.ts';
+
+/**
+ * This class provides a graph-like visual editor for creating a {@link Shader}. Although {@link VisualShader}s do not require coding, they share the same logic with script shaders. They use {@link VisualShaderNode}s that can be connected to each other to control the flow of the shader. The visual shader graph is converted to a script shader behind the scenes.
+ */
+export class VisualShader extends Shader {
+    constructor(name = 841) { super(name); }
+
+    /**
+     * Sets the mode of this shader.
+     */
+    setMode(mode: Mode): void { _C(this, 12073, mode); }
+
+    /**
+     * Adds the specified `node` to the shader.
+     */
+    addNode(type: Type, node: VisualShaderNode, position: Vector2, id: number): void { _C(this, 1257, type, node, position, id); }
+
+    /**
+     * Returns the shader node instance with specified `type` and `id`.
+     */
+    getNode(type: Type, id: number): VisualShaderNode { return _C(this, 5638, type, id) as VisualShaderNode; }
+
+    /**
+     * Sets the position of the specified node.
+     */
+    setNodePosition(type: Type, id: number, position: Vector2): void { _C(this, 12139, type, id, position); }
+
+    /**
+     * Returns the position of the specified node within the shader graph.
+     */
+    getNodePosition(type: Type, id: number): Vector2 { return _C(this, 5657, type, id) as Vector2; }
+
+    /**
+     * Returns the list of all nodes in the shader with the specified type.
+     */
+    getNodeList(type: Type): PackedInt32Array { return _C(this, 5650, type) as PackedInt32Array; }
+
+    /**
+     * Returns next valid node ID that can be added to the shader graph.
+     */
+    getValidNodeId(type: Type): number { return _C(this, 7017, type) as number; }
+
+    /**
+     * Removes the specified node from the shader.
+     */
+    removeNode(type: Type, id: number): void { _C(this, 9937, type, id); }
+
+    /**
+     * Replaces the specified node with a node of new class type.
+     */
+    replaceNode(type: Type, id: number, newClass: StringName): void { _C(this, 10045, type, id, newClass); }
+
+    /**
+     * Returns `true` if the specified node and port connection exist.
+     */
+    isNodeConnection(type: Type, fromNode: number, fromPort: number, toNode: number, toPort: number): boolean { return _C(this, 8134, type, fromNode, fromPort, toNode, toPort) as boolean; }
+
+    /**
+     * Returns `true` if the specified nodes and ports can be connected together.
+     */
+    canConnectNodes(type: Type, fromNode: number, fromPort: number, toNode: number, toPort: number): boolean { return _C(this, 2009, type, fromNode, fromPort, toNode, toPort) as boolean; }
+
+    /**
+     * Connects the specified nodes and ports.
+     */
+    connectNodes(type: Type, fromNode: number, fromPort: number, toNode: number, toPort: number): Error { return _C(this, 2435, type, fromNode, fromPort, toNode, toPort) as Error; }
+
+    /**
+     * Connects the specified nodes and ports.
+     */
+    disconnectNodes(type: Type, fromNode: number, fromPort: number, toNode: number, toPort: number): void { _C(this, 2826, type, fromNode, fromPort, toNode, toPort); }
+
+    /**
+     * Connects the specified nodes and ports, even if they can't be connected. Such connection is invalid and will not function properly.
+     */
+    connectNodesForced(type: Type, fromNode: number, fromPort: number, toNode: number, toPort: number): void { _C(this, 2436, type, fromNode, fromPort, toNode, toPort); }
+
+    /**
+     * Returns the list of connected nodes with the specified type.
+     */
+    getNodeConnections(type: Type): GodotArray<GodotDictionary> { return _C(this, 5642, type) as GodotArray<GodotDictionary>; }
+
+    /**
+     * Attaches the given node to the given frame.
+     */
+    attachNodeToFrame(type: Type, id: number, frame: number): void { _C(this, 1613, type, id, frame); }
+
+    /**
+     * Detaches the given node from the frame it is attached to.
+     */
+    detachNodeFromFrame(type: Type, id: number): void { _C(this, 2762, type, id); }
+
+    /**
+     * Adds a new varying value node to the shader.
+     */
+    addVarying(name: string, mode: VaryingMode, type: VaryingType): void { _C(this, 1334, name, mode, type); }
+
+    /**
+     * Removes a varying value node with the given `name`. Prints an error if a node with this name is not found.
+     */
+    removeVarying(name: string): void { _C(this, 9989, name); }
+
+    /**
+     * Returns `true` if the shader has a varying with the given `name`.
+     */
+    hasVarying(name: string): boolean { return _C(this, 7484, name) as boolean; }
+
+    /**
+     * Deprecated.
+     */
+    get graphOffset(): Vector2 { return _C(this, 4970) as Vector2; }
+    set graphOffset(v: Vector2) { _C(this, 11552, v); }
+
+    /**
+     * Indicates an invalid {@link VisualShader} node.
+     */
+    static readonly NODE_ID_INVALID = -1;
+
+    /**
+     * Indicates an output node of {@link VisualShader}.
+     */
+    static readonly NODE_ID_OUTPUT = 0;
+
+    static readonly name = _R(841, VisualShader);
+}
+
+export const Type = {
+    /**
+     * A vertex shader, operating on vertices.
+     */
+    TYPE_VERTEX: 0,
+    /**
+     * A fragment shader, operating on fragments (pixels).
+     */
+    TYPE_FRAGMENT: 1,
+    /**
+     * A shader for light calculations.
+     */
+    TYPE_LIGHT: 2,
+    /**
+     * A function for the "start" stage of particle shader.
+     */
+    TYPE_START: 3,
+    /**
+     * A function for the "process" stage of particle shader.
+     */
+    TYPE_PROCESS: 4,
+    /**
+     * A function for the "collide" stage (particle collision handler) of particle shader.
+     */
+    TYPE_COLLIDE: 5,
+    /**
+     * A function for the "start" stage of particle shader, with customized output.
+     */
+    TYPE_START_CUSTOM: 6,
+    /**
+     * A function for the "process" stage of particle shader, with customized output.
+     */
+    TYPE_PROCESS_CUSTOM: 7,
+    /**
+     * A shader for 3D environment's sky.
+     */
+    TYPE_SKY: 8,
+    /**
+     * A compute shader that runs for each froxel of the volumetric fog map.
+     */
+    TYPE_FOG: 9,
+    /**
+     * A shader used to process blit calls to a DrawableTexture.
+     */
+    TYPE_TEXTURE_BLIT: 10,
+    /**
+     * Represents the size of the {@link Type} enum.
+     */
+    TYPE_MAX: 11,
+} as const;
+
+export type Type = (typeof Type)[keyof typeof Type];
+
+export const VaryingMode = {
+    /**
+     * Varying is passed from `Vertex` function to `Fragment` and `Light` functions.
+     */
+    VARYING_MODE_VERTEX_TO_FRAG_LIGHT: 0,
+    /**
+     * Varying is passed from `Fragment` function to `Light` function.
+     */
+    VARYING_MODE_FRAG_TO_LIGHT: 1,
+    /**
+     * Represents the size of the {@link VaryingMode} enum.
+     */
+    VARYING_MODE_MAX: 2,
+} as const;
+
+export type VaryingMode = (typeof VaryingMode)[keyof typeof VaryingMode];
+
+export const VaryingType = {
+    /**
+     * Varying is of type {@link float}.
+     */
+    VARYING_TYPE_FLOAT: 0,
+    /**
+     * Varying is of type {@link int}.
+     */
+    VARYING_TYPE_INT: 1,
+    /**
+     * Varying is of type unsigned {@link int}.
+     */
+    VARYING_TYPE_UINT: 2,
+    /**
+     * Varying is of type {@link Vector2}.
+     */
+    VARYING_TYPE_VECTOR_2D: 3,
+    /**
+     * Varying is of type {@link Vector3}.
+     */
+    VARYING_TYPE_VECTOR_3D: 4,
+    /**
+     * Varying is of type {@link Vector4}.
+     */
+    VARYING_TYPE_VECTOR_4D: 5,
+    /**
+     * Varying is of type {@link bool}.
+     */
+    VARYING_TYPE_BOOLEAN: 6,
+    /**
+     * Varying is of type {@link Transform3D}.
+     */
+    VARYING_TYPE_TRANSFORM: 7,
+    /**
+     * Represents the size of the {@link VaryingType} enum.
+     */
+    VARYING_TYPE_MAX: 8,
+} as const;
+
+export type VaryingType = (typeof VaryingType)[keyof typeof VaryingType];
+

package/gen/classes/VisualShaderNode.ts

@@ -0,0 +1,103 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Resource } from './Resource.ts';
+import type { GodotArray, Variant } from '../heap-types/index.ts';
+
+/**
+ * Visual shader graphs consist of various nodes. Each node in the graph is a separate object and they are represented as a rectangular boxes with title and a set of properties. Each node also has connection ports that allow to connect it to another nodes and control the flow of the shader.
+ */
+export class VisualShaderNode extends Resource {
+
+    /**
+     * Returns the input port which should be connected by default when this node is created as a result of dragging a connection from an existing node to the empty space on the graph.
+     */
+    getDefaultInputPort(type: PortType): number { return _C(this, 4451, type) as number; }
+
+    /**
+     * Sets the default `value` for the selected input `port`.
+     */
+    setInputPortDefaultValue(port: number, value: Variant, prevValue?: Variant /* = null */): void { _C(this, 11718, port, value, prevValue); }
+
+    /**
+     * Returns the default value of the input `port`.
+     */
+    getInputPortDefaultValue(port: number): Variant { return _C(this, 5120, port) as Variant; }
+
+    /**
+     * Removes the default value of the input `port`.
+     */
+    removeInputPortDefaultValue(port: number): void { _C(this, 9921, port); }
+
+    /**
+     * Clears the default input ports value.
+     */
+    clearDefaultInputValues(): void { _C(this, 2259); }
+
+    /**
+     * Sets the output port index which will be showed for preview. If set to `-1` no port will be open for preview.
+     */
+    get outputPortForPreview(): number { return _C(this, 5768) as number; }
+    set outputPortForPreview(v: number) { _C(this, 12221, v); }
+
+    get defaultInputValues(): GodotArray { return _C(this, 4452) as GodotArray; }
+    set defaultInputValues(v: GodotArray) { _C(this, 11065, v); }
+
+    get expandedOutputPorts(): GodotArray { return _C(this, 1007) as GodotArray; }
+    set expandedOutputPorts(v: GodotArray) { _C(this, 1035, v); }
+
+    /**
+     * Represents the index of the frame this node is linked to. If set to `-1` the node is not linked to any frame.
+     */
+    get linkedParentGraphFrame(): number { return _C(this, 4878) as number; }
+    set linkedParentGraphFrame(v: number) { _C(this, 11480, v); }
+
+    static readonly name = _R(842, VisualShaderNode);
+}
+
+export const PortType = {
+    /**
+     * Floating-point scalar. Translated to {@link code skip-lint}float[/code] type in shader code.
+     */
+    PORT_TYPE_SCALAR: 0,
+    /**
+     * Integer scalar. Translated to {@link code skip-lint}int[/code] type in shader code.
+     */
+    PORT_TYPE_SCALAR_INT: 1,
+    /**
+     * Unsigned integer scalar. Translated to {@link code skip-lint}uint[/code] type in shader code.
+     */
+    PORT_TYPE_SCALAR_UINT: 2,
+    /**
+     * 2D vector of floating-point values. Translated to {@link code skip-lint}vec2[/code] type in shader code.
+     */
+    PORT_TYPE_VECTOR_2D: 3,
+    /**
+     * 3D vector of floating-point values. Translated to {@link code skip-lint}vec3[/code] type in shader code.
+     */
+    PORT_TYPE_VECTOR_3D: 4,
+    /**
+     * 4D vector of floating-point values. Translated to {@link code skip-lint}vec4[/code] type in shader code.
+     */
+    PORT_TYPE_VECTOR_4D: 5,
+    /**
+     * Boolean type. Translated to {@link code skip-lint}bool[/code] type in shader code.
+     */
+    PORT_TYPE_BOOLEAN: 6,
+    /**
+     * Transform type. Translated to {@link code skip-lint}mat4[/code] type in shader code.
+     */
+    PORT_TYPE_TRANSFORM: 7,
+    /**
+     * Sampler type. Translated to reference of sampler uniform in shader code. Can only be used for input ports in non-uniform nodes.
+     */
+    PORT_TYPE_SAMPLER: 8,
+    /**
+     * Represents the size of the {@link PortType} enum.
+     */
+    PORT_TYPE_MAX: 9,
+} as const;
+
+export type PortType = (typeof PortType)[keyof typeof PortType];
+

package/gen/classes/VisualShaderNodeBillboard.ts

@@ -0,0 +1,52 @@
+// 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 output port of this node needs to be connected to `Model View Matrix` port of {@link VisualShaderNodeOutput}.
+ */
+export class VisualShaderNodeBillboard extends VisualShaderNode {
+    constructor(name = 843) { super(name); }
+
+    /**
+     * Controls how the object faces the camera.
+     */
+    get billboardType(): BillboardType { return _C(this, 3914) as BillboardType; }
+    set billboardType(v: BillboardType) { _C(this, 10660, v); }
+
+    /**
+     * If `true`, the shader will keep the scale set for the mesh. Otherwise, the scale is lost when billboarding.
+     */
+    get keepScale(): boolean { return _C(this, 8057) as boolean; }
+    set keepScale(v: boolean) { _C(this, 11863, v); }
+
+    static readonly name = _R(843, VisualShaderNodeBillboard);
+}
+
+export const BillboardType = {
+    /**
+     * Billboarding is disabled and the node does nothing.
+     */
+    BILLBOARD_TYPE_DISABLED: 0,
+    /**
+     * A standard billboarding algorithm is enabled.
+     */
+    BILLBOARD_TYPE_ENABLED: 1,
+    /**
+     * A billboarding algorithm to rotate around Y-axis is enabled.
+     */
+    BILLBOARD_TYPE_FIXED_Y: 2,
+    /**
+     * A billboarding algorithm designed to use on particles is enabled.
+     */
+    BILLBOARD_TYPE_PARTICLES: 3,
+    /**
+     * Represents the size of the {@link BillboardType} enum.
+     */
+    BILLBOARD_TYPE_MAX: 4,
+} as const;
+
+export type BillboardType = (typeof BillboardType)[keyof typeof BillboardType];
+

package/gen/classes/VisualShaderNodeBooleanConstant.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 { VisualShaderNodeConstant } from './VisualShaderNodeConstant.ts';
+
+/**
+ * Has only one output port and no inputs.
+ * Translated to {@link code skip-lint}bool[/code] in the shader language.
+ */
+export class VisualShaderNodeBooleanConstant extends VisualShaderNodeConstant {
+    constructor(name = 844) { super(name); }
+
+    /**
+     * A boolean constant which represents a state of this node.
+     */
+    get constant(): boolean { return _C(this, 4283) as boolean; }
+    set constant(v: boolean) { _C(this, 10942, v); }
+
+    static readonly name = _R(844, VisualShaderNodeBooleanConstant);
+}

package/gen/classes/VisualShaderNodeBooleanParameter.ts

@@ -0,0 +1,26 @@
+// 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 bool` in the shader language.
+ */
+export class VisualShaderNodeBooleanParameter extends VisualShaderNodeParameter {
+    constructor(name = 845) { 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(): boolean { return _C(this, 4456) as boolean; }
+    set defaultValue(v: boolean) { _C(this, 11069, v); }
+
+    static readonly name = _R(845, VisualShaderNodeBooleanParameter);
+}

package/gen/classes/VisualShaderNodeClamp.ts

@@ -0,0 +1,54 @@
+// 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';
+
+/**
+ * Constrains a value to lie between `min` and `max` values.
+ */
+export class VisualShaderNodeClamp extends VisualShaderNode {
+    constructor(name = 846) { 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); }
+
+    static readonly name = _R(846, VisualShaderNodeClamp);
+}
+
+export const OpType = {
+    /**
+     * A floating-point scalar.
+     */
+    OP_TYPE_FLOAT: 0,
+    /**
+     * An integer scalar.
+     */
+    OP_TYPE_INT: 1,
+    /**
+     * An unsigned integer scalar.
+     */
+    OP_TYPE_UINT: 2,
+    /**
+     * A 2D vector type.
+     */
+    OP_TYPE_VECTOR_2D: 3,
+    /**
+     * A 3D vector type.
+     */
+    OP_TYPE_VECTOR_3D: 4,
+    /**
+     * A 4D vector type.
+     */
+    OP_TYPE_VECTOR_4D: 5,
+    /**
+     * Represents the size of the {@link OpType} enum.
+     */
+    OP_TYPE_MAX: 6,
+} as const;
+
+export type OpType = (typeof OpType)[keyof typeof OpType];
+

package/gen/classes/VisualShaderNodeColorConstant.ts

@@ -0,0 +1,22 @@
+// 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';
+import type { Color } from '../value-types/index.ts';
+
+/**
+ * Has two output ports representing RGB and alpha channels of {@link Color}.
+ * Translated to `vec3 rgb` and `float alpha` in the shader language.
+ */
+export class VisualShaderNodeColorConstant extends VisualShaderNodeConstant {
+    constructor(name = 847) { super(name); }
+
+    /**
+     * A {@link Color} constant which represents a state of this node.
+     */
+    get constant(): Color { return _C(this, 4283) as Color; }
+    set constant(v: Color) { _C(this, 10942, v); }
+
+    static readonly name = _R(847, VisualShaderNodeColorConstant);
+}

package/gen/classes/VisualShaderNodeColorFunc.ts

@@ -0,0 +1,106 @@
+// 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 {@link Color} to the input port and transform it according to {@link function}.
+ */
+export class VisualShaderNodeColorFunc extends VisualShaderNode {
+    constructor(name = 848) { super(name); }
+
+    /**
+     * A function to be applied to the input color.
+     */
+    get _function(): Function { return _C(this, 4911) as Function; }
+    set _function(v: Function) { _C(this, 11504, v); }
+
+    static readonly name = _R(848, VisualShaderNodeColorFunc);
+}
+
+export const Function = {
+    /**
+     * Converts the color to grayscale using the following formula:
+     *
+     * ```text
+     *
+     * vec3 c = input;
+     * float max1 = max(c.r, c.g);
+     * float max2 = max(max1, c.b);
+     * float max3 = max(max1, max2);
+     * return vec3(max3, max3, max3);
+     *
+     * ```
+     */
+    FUNC_GRAYSCALE: 0,
+    /**
+     * Converts HSV vector to RGB equivalent.
+     */
+    FUNC_HSV2RGB: 1,
+    /**
+     * Converts RGB vector to HSV equivalent.
+     */
+    FUNC_RGB2HSV: 2,
+    /**
+     * Applies sepia tone effect using the following formula:
+     *
+     * ```text
+     *
+     * vec3 c = input;
+     * float r = (c.r * 0.393) + (c.g * 0.769) + (c.b * 0.189);
+     * float g = (c.r * 0.349) + (c.g * 0.686) + (c.b * 0.168);
+     * float b = (c.r * 0.272) + (c.g * 0.534) + (c.b * 0.131);
+     * return vec3(r, g, b);
+     *
+     * ```
+     */
+    FUNC_SEPIA: 3,
+    /**
+     * Converts color from linear encoding to nonlinear sRGB encoding using the following formula:
+     *
+     * ```text
+     *
+     * const vec3 a = vec3(0.055f);
+     * return mix((vec3(1.0f) + a) * pow(c.rgb, vec3(1.0f / 2.4f)) - a, 12.92f * c.rgb, lessThan(c.rgb, vec3(0.0031308f)));
+     *
+     * ```
+     *
+     * The Compatibility renderer uses a simpler formula that may produce undefined behavior with negative input values:
+     *
+     * ```text
+     *
+     * vec3 c = input;
+     * return max(vec3(1.055) * pow(c, vec3(0.416666667)) - vec3(0.055), vec3(0.0));
+     *
+     * ```
+     */
+    FUNC_LINEAR_TO_SRGB: 4,
+    /**
+     * Converts color from nonlinear sRGB encoding to linear encoding using the following formula:
+     *
+     * ```text
+     *
+     * vec3 c = input;
+     * return mix(pow((c.rgb + vec3(0.055)) * (1.0 / (1.0 + 0.055)), vec3(2.4)), c.rgb * (1.0 / 12.92), lessThan(c.rgb, vec3(0.04045)));
+     *
+     * ```
+     *
+     * The Compatibility renderer uses a simpler formula that behaves poorly with negative input values:
+     *
+     * ```text
+     *
+     * vec3 c = input;
+     * return c * (c * (c * 0.305306011 + 0.682171111) + 0.012522878);
+     *
+     * ```
+     */
+    FUNC_SRGB_TO_LINEAR: 5,
+    /**
+     * Represents the size of the {@link Function} enum.
+     */
+    FUNC_MAX: 6,
+} as const;
+
+export type Function = (typeof Function)[keyof typeof Function];
+