typescript-to-gdscript 0.1.0

package/typings/classes/ViewportTexture.d.ts

@@ -0,0 +1,13 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Provides the content of a {@link Viewport} as a dynamic texture. */
+declare class ViewportTexture extends Texture2D {
+  /**
+   * The path to the {@link Viewport} node to display. This is relative to the local scene root (see {@link Resource.get_local_scene}), **not** to the nodes that use this texture.
+   * **Note:** In the editor, this path is automatically updated when the target viewport or one of its ancestors is renamed or moved. At runtime, this path may not automatically update if the scene root cannot be found.
+   */
+  viewport_path: NodePath;
+  set_viewport_path_in_scene(value: NodePath | string): void;
+  get_viewport_path_in_scene(): NodePath;
+}

package/typings/classes/VirtualJoystick.d.ts

@@ -0,0 +1,94 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A virtual joystick control for touchscreen devices. */
+declare class VirtualJoystick extends Control {
+  /** The action to trigger when the joystick is moved down. */
+  action_down: string;
+  /** The action to trigger when the joystick is moved left. */
+  action_left: string;
+  /** The action to trigger when the joystick is moved right. */
+  action_right: string;
+  /** The action to trigger when the joystick is moved up. */
+  action_up: string;
+  /**
+   * The multiplier applied to the joystick's radius that defines the clamp zone.
+   * This zone limits how far the joystick tip can move from its center before being clamped.
+   * A value of `1.0` means the tip can move up to the edge of the joystick's visual size.
+   * In {@link JOYSTICK_FOLLOWING} mode, this radius also determines how far the finger can move before the joystick base starts following the touch input.
+   */
+  clampzone_ratio: float;
+  /**
+   * The ratio of the joystick size that defines the joystick deadzone. The joystick tip must move beyond this ratio before being considered active.
+   * This deadzone is applied before triggering input actions and affects the joystick's input vector and all related signals.
+   * Note that input actions may also define their own deadzones in the InputMap. If both are set, the joystick deadzone is applied first, followed by the action's deadzone.
+   * By default, this value is `0.0`, meaning the joystick does not apply its own deadzone and relies entirely on the InputMap action deadzones.
+   */
+  deadzone_ratio: float;
+  /**
+   * The initial position of the joystick as a ratio of the control's size. `(0, 0)` is top-left and `(1, 1)` is bottom-right.
+   */
+  initial_offset_ratio: Vector2;
+  /** The joystick mode to use. */
+  joystick_mode: int;
+  /** The size of the joystick in pixels. */
+  joystick_size: float;
+  /** The size of the joystick tip in pixels. */
+  tip_size: float;
+  /** The visibility mode to use. */
+  visibility_mode: int;
+  set_action_down(value: string): void;
+  get_action_down(): string;
+  set_action_left(value: string): void;
+  get_action_left(): string;
+  set_action_right(value: string): void;
+  get_action_right(): string;
+  set_action_up(value: string): void;
+  get_action_up(): string;
+  set_clampzone_ratio(value: float): void;
+  get_clampzone_ratio(): float;
+  set_deadzone_ratio(value: float): void;
+  get_deadzone_ratio(): float;
+  set_initial_offset_ratio(value: Vector2 | Vector2i): void;
+  get_initial_offset_ratio(): Vector2;
+  set_joystick_mode(value: int): void;
+  get_joystick_mode(): int;
+  set_joystick_size(value: float): void;
+  get_joystick_size(): float;
+  set_tip_size(value: float): void;
+  get_tip_size(): float;
+  set_visibility_mode(value: int): void;
+  get_visibility_mode(): int;
+
+  /** Emitted when the tip enters the deadzone after being outside of it. */
+  flick_canceled: Signal<[]>;
+  /**
+   * Emitted when the tip moved outside the deadzone and the joystick is released. The `input_vector` contains the last input direction and strength before release. Its length is between `0.0` and `1.0`.
+   */
+  flicked: Signal<[Vector2]>;
+  /** Emitted when the joystick is pressed. */
+  pressed: Signal<[]>;
+  /**
+   * Emitted when the joystick is released. The `input_vector` is the final input direction and strength, with a length between `0.0` and `1.0`.
+   */
+  released: Signal<[Vector2]>;
+  /** Emitted when the joystick is released without moving the tip. */
+  tapped: Signal<[]>;
+
+  // enum JoystickMode
+  /** The joystick doesn't move. */
+  static readonly JOYSTICK_FIXED: int;
+  /**
+   * The joystick is moved to the initial touch position as long as it's within the joystick's bounds. It moves back to its original position when released.
+   */
+  static readonly JOYSTICK_DYNAMIC: int;
+  /**
+   * The joystick is moved to the initial touch position as long as it's within the joystick's bounds. It will follow the touch input if it goes outside the joystick's range. It moves back to its original position when released.
+   */
+  static readonly JOYSTICK_FOLLOWING: int;
+  // enum VisibilityMode
+  /** The joystick is always visible. */
+  static readonly VISIBILITY_ALWAYS: int;
+  /** The joystick is only visible when being touched. */
+  static readonly VISIBILITY_WHEN_TOUCHED: int;
+}

package/typings/classes/VisibleOnScreenEnabler2D.d.ts

@@ -0,0 +1,26 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A rectangular region of 2D space that, when visible on screen, enables a target node. */
+declare class VisibleOnScreenEnabler2D extends VisibleOnScreenNotifier2D {
+  /**
+   * Determines how the target node is enabled. Corresponds to {@link Node.ProcessMode}. When the node is disabled, it always uses {@link Node.PROCESS_MODE_DISABLED}.
+   */
+  enable_mode: int;
+  /**
+   * The path to the target node, relative to the {@link VisibleOnScreenEnabler2D}. The target node is cached; it's only assigned when setting this property (if the {@link VisibleOnScreenEnabler2D} is inside the scene tree) and every time the {@link VisibleOnScreenEnabler2D} enters the scene tree. If the path is empty, no node will be affected. If the path is invalid, an error is also generated.
+   */
+  enable_node_path: NodePath;
+  set_enable_mode(value: int): void;
+  get_enable_mode(): int;
+  set_enable_node_path(value: NodePath | string): void;
+  get_enable_node_path(): NodePath;
+
+  // enum EnableMode
+  /** Corresponds to {@link Node.PROCESS_MODE_INHERIT}. */
+  static readonly ENABLE_MODE_INHERIT: int;
+  /** Corresponds to {@link Node.PROCESS_MODE_ALWAYS}. */
+  static readonly ENABLE_MODE_ALWAYS: int;
+  /** Corresponds to {@link Node.PROCESS_MODE_WHEN_PAUSED}. */
+  static readonly ENABLE_MODE_WHEN_PAUSED: int;
+}

package/typings/classes/VisibleOnScreenEnabler3D.d.ts

@@ -0,0 +1,26 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A box-shaped region of 3D space that, when visible on screen, enables a target node. */
+declare class VisibleOnScreenEnabler3D extends VisibleOnScreenNotifier3D {
+  /**
+   * Determines how the target node is enabled. Corresponds to {@link Node.ProcessMode}. When the node is disabled, it always uses {@link Node.PROCESS_MODE_DISABLED}.
+   */
+  enable_mode: int;
+  /**
+   * The path to the target node, relative to the {@link VisibleOnScreenEnabler3D}. The target node is cached; it's only assigned when setting this property (if the {@link VisibleOnScreenEnabler3D} is inside the scene tree) and every time the {@link VisibleOnScreenEnabler3D} enters the scene tree. If the path is empty, no node will be affected. If the path is invalid, an error is also generated.
+   */
+  enable_node_path: NodePath;
+  set_enable_mode(value: int): void;
+  get_enable_mode(): int;
+  set_enable_node_path(value: NodePath | string): void;
+  get_enable_node_path(): NodePath;
+
+  // enum EnableMode
+  /** Corresponds to {@link Node.PROCESS_MODE_INHERIT}. */
+  static readonly ENABLE_MODE_INHERIT: int;
+  /** Corresponds to {@link Node.PROCESS_MODE_ALWAYS}. */
+  static readonly ENABLE_MODE_ALWAYS: int;
+  /** Corresponds to {@link Node.PROCESS_MODE_WHEN_PAUSED}. */
+  static readonly ENABLE_MODE_WHEN_PAUSED: int;
+}

package/typings/classes/VisibleOnScreenNotifier2D.d.ts

@@ -0,0 +1,27 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A rectangular region of 2D space that detects whether it is visible on screen. */
+declare class VisibleOnScreenNotifier2D extends Node2D {
+  /** The VisibleOnScreenNotifier2D's bounding rectangle. */
+  rect: Rect2;
+  /**
+   * If `true`, shows the rectangle area of {@link rect} in the editor with a translucent magenta fill. Unlike changing the visibility of the VisibleOnScreenNotifier2D, this does not affect the screen culling detection.
+   */
+  show_rect: boolean;
+  set_rect(value: Rect2 | Rect2i): void;
+  get_rect(): Rect2;
+  set_show_rect(value: boolean): void;
+  is_showing_rect(): boolean;
+
+  /**
+   * If `true`, the bounding rectangle is on the screen.
+   * **Note:** It takes one frame for the {@link VisibleOnScreenNotifier2D}'s visibility to be determined once added to the scene tree, so this method will always return `false` right after it is instantiated, before the draw pass.
+   */
+  is_on_screen(): boolean;
+
+  /** Emitted when the VisibleOnScreenNotifier2D enters the screen. */
+  screen_entered: Signal<[]>;
+  /** Emitted when the VisibleOnScreenNotifier2D exits the screen. */
+  screen_exited: Signal<[]>;
+}

package/typings/classes/VisibleOnScreenNotifier3D.d.ts

@@ -0,0 +1,20 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A box-shaped region of 3D space that detects whether it is visible on screen. */
+declare class VisibleOnScreenNotifier3D extends VisualInstance3D {
+  /** The {@link VisibleOnScreenNotifier3D}'s bounding box. */
+  aabb: AABB;
+  set_aabb(value: AABB): void;
+
+  /**
+   * Returns `true` if the bounding box is on the screen.
+   * **Note:** It takes one frame for the {@link VisibleOnScreenNotifier3D}'s visibility to be assessed once added to the scene tree, so this method will always return `false` right after it is instantiated.
+   */
+  is_on_screen(): boolean;
+
+  /** Emitted when the {@link VisibleOnScreenNotifier3D} enters the screen. */
+  screen_entered: Signal<[]>;
+  /** Emitted when the {@link VisibleOnScreenNotifier3D} exits the screen. */
+  screen_exited: Signal<[]>;
+}

package/typings/classes/VisualInstance3D.d.ts

@@ -0,0 +1,53 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Parent of all visual 3D nodes. */
+declare class VisualInstance3D extends Node3D {
+  /**
+   * The render layer(s) this {@link VisualInstance3D} is drawn on.
+   * This object will only be visible for {@link Camera3D}s whose cull mask includes any of the render layers this {@link VisualInstance3D} is set to.
+   * For {@link Light3D}s, this can be used to control which {@link VisualInstance3D}s are affected by a specific light. For {@link GPUParticles3D}, this can be used to control which particles are effected by a specific attractor. For {@link Decal}s, this can be used to control which {@link VisualInstance3D}s are affected by a specific decal.
+   * To adjust {@link layers} more easily using a script, use {@link get_layer_mask_value} and {@link set_layer_mask_value}.
+   * **Note:** {@link VoxelGI}, SDFGI and {@link LightmapGI} will always take all layers into account to determine what contributes to global illumination. If this is an issue, set {@link GeometryInstance3D.gi_mode} to {@link GeometryInstance3D.GI_MODE_DISABLED} for meshes and {@link Light3D.light_bake_mode} to {@link Light3D.BAKE_DISABLED} for lights to exclude them from global illumination.
+   */
+  layers: int;
+  /**
+   * The amount by which the depth of this {@link VisualInstance3D} will be adjusted when sorting by depth. Uses the same units as the engine (which are typically meters). Adjusting it to a higher value will make the {@link VisualInstance3D} reliably draw on top of other {@link VisualInstance3D}s that are otherwise positioned at the same spot. To ensure it always draws on top of other objects around it (not positioned at the same spot), set the value to be greater than the distance between this {@link VisualInstance3D} and the other nearby {@link VisualInstance3D}s.
+   */
+  sorting_offset: float;
+  /**
+   * If `true`, the object is sorted based on the {@link AABB} center. The object will be sorted based on the global position otherwise.
+   * The {@link AABB} center based sorting is generally more accurate for 3D models. The position based sorting instead allows to better control the drawing order when working with {@link GPUParticles3D} and {@link CPUParticles3D}.
+   */
+  sorting_use_aabb_center: boolean;
+  set_layer_mask(value: int): void;
+  get_layer_mask(): int;
+  set_sorting_offset(value: float): void;
+  get_sorting_offset(): float;
+  set_sorting_use_aabb_center(value: boolean): void;
+  is_sorting_use_aabb_center(): boolean;
+
+  _get_aabb(): AABB;
+  /** Returns the {@link AABB} (also known as the bounding box) for this {@link VisualInstance3D}. */
+  get_aabb(): AABB;
+  /**
+   * Returns the RID of the resource associated with this {@link VisualInstance3D}. For example, if the Node is a {@link MeshInstance3D}, this will return the RID of the associated {@link Mesh}.
+   */
+  get_base(): RID;
+  /**
+   * Returns the RID of this instance. This RID is the same as the RID returned by {@link RenderingServer.instance_create}. This RID is needed if you want to call {@link RenderingServer} functions directly on this {@link VisualInstance3D}.
+   */
+  get_instance(): RID;
+  /**
+   * Returns whether or not the specified layer of the {@link layers} is enabled, given a `layer_number` between 1 and 20.
+   */
+  get_layer_mask_value(layer_number: int): boolean;
+  /**
+   * Sets the resource that is instantiated by this {@link VisualInstance3D}, which changes how the engine handles the {@link VisualInstance3D} under the hood. Equivalent to {@link RenderingServer.instance_set_base}.
+   */
+  set_base(base: RID): void;
+  /**
+   * Based on `value`, enables or disables the specified layer in the {@link layers}, given a `layer_number` between 1 and 20.
+   */
+  set_layer_mask_value(layer_number: int, value: boolean): void;
+}

package/typings/classes/VisualShader.d.ts

@@ -0,0 +1,112 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A custom shader program with a visual editor. */
+declare class VisualShader extends Shader {
+  /** Deprecated. */
+  graph_offset: Vector2;
+  set_graph_offset(value: Vector2 | Vector2i): void;
+  get_graph_offset(): Vector2;
+
+  /** Adds the specified `node` to the shader. */
+  add_node(type_: int, node: VisualShaderNode, position: Vector2 | Vector2i, id: int): void;
+  /** Adds a new varying value node to the shader. */
+  add_varying(name: string | NodePath, mode: int, type_: int): void;
+  /** Attaches the given node to the given frame. */
+  attach_node_to_frame(type_: int, id: int, frame: int): void;
+  /** Returns `true` if the specified nodes and ports can be connected together. */
+  can_connect_nodes(type_: int, from_node: int, from_port: int, to_node: int, to_port: int): boolean;
+  /** Connects the specified nodes and ports. */
+  connect_nodes(type_: int, from_node: int, from_port: int, to_node: int, to_port: int): int;
+  /**
+   * Connects the specified nodes and ports, even if they can't be connected. Such connection is invalid and will not function properly.
+   */
+  connect_nodes_forced(type_: int, from_node: int, from_port: int, to_node: int, to_port: int): void;
+  /** Detaches the given node from the frame it is attached to. */
+  detach_node_from_frame(type_: int, id: int): void;
+  /** Connects the specified nodes and ports. */
+  disconnect_nodes(type_: int, from_node: int, from_port: int, to_node: int, to_port: int): void;
+  /** Returns the shader node instance with specified `type` and `id`. */
+  get_node(type_: int, id: int): VisualShaderNode | null;
+  /** Returns the list of connected nodes with the specified type. */
+  get_node_connections(type_: int): Array<Dictionary>;
+  /** Returns the list of all nodes in the shader with the specified type. */
+  get_node_list(type_: int): PackedInt32Array;
+  /** Returns the position of the specified node within the shader graph. */
+  get_node_position(type_: int, id: int): Vector2;
+  /** Returns next valid node ID that can be added to the shader graph. */
+  get_valid_node_id(type_: int): int;
+  /** Returns `true` if the shader has a varying with the given `name`. */
+  has_varying(name: string | NodePath): boolean;
+  /** Returns `true` if the specified node and port connection exist. */
+  is_node_connection(type_: int, from_node: int, from_port: int, to_node: int, to_port: int): boolean;
+  /** Removes the specified node from the shader. */
+  remove_node(type_: int, id: int): void;
+  /**
+   * Removes a varying value node with the given `name`. Prints an error if a node with this name is not found.
+   */
+  remove_varying(name: string | NodePath): void;
+  /** Replaces the specified node with a node of new class type. */
+  replace_node(type_: int, id: int, new_class: string): void;
+  /** Sets the mode of this shader. */
+  set_mode(mode: int): void;
+  /** Sets the position of the specified node. */
+  set_node_position(type_: int, id: int, position: Vector2 | Vector2i): void;
+
+  // enum Type
+  /** A vertex shader, operating on vertices. */
+  static readonly TYPE_VERTEX: int;
+  /** A fragment shader, operating on fragments (pixels). */
+  static readonly TYPE_FRAGMENT: int;
+  /** A shader for light calculations. */
+  static readonly TYPE_LIGHT: int;
+  /** A function for the "start" stage of particle shader. */
+  static readonly TYPE_START: int;
+  /** A function for the "process" stage of particle shader. */
+  static readonly TYPE_PROCESS: int;
+  /** A function for the "collide" stage (particle collision handler) of particle shader. */
+  static readonly TYPE_COLLIDE: int;
+  /** A function for the "start" stage of particle shader, with customized output. */
+  static readonly TYPE_START_CUSTOM: int;
+  /** A function for the "process" stage of particle shader, with customized output. */
+  static readonly TYPE_PROCESS_CUSTOM: int;
+  /** A shader for 3D environment's sky. */
+  static readonly TYPE_SKY: int;
+  /** A compute shader that runs for each froxel of the volumetric fog map. */
+  static readonly TYPE_FOG: int;
+  /** A shader used to process blit calls to a DrawableTexture. */
+  static readonly TYPE_TEXTURE_BLIT: int;
+  /** Represents the size of the {@link Type} enum. */
+  static readonly TYPE_MAX: int;
+  // enum VaryingMode
+  /** Varying is passed from `Vertex` function to `Fragment` and `Light` functions. */
+  static readonly VARYING_MODE_VERTEX_TO_FRAG_LIGHT: int;
+  /** Varying is passed from `Fragment` function to `Light` function. */
+  static readonly VARYING_MODE_FRAG_TO_LIGHT: int;
+  /** Represents the size of the {@link VaryingMode} enum. */
+  static readonly VARYING_MODE_MAX: int;
+  // enum VaryingType
+  /** Varying is of type [float]. */
+  static readonly VARYING_TYPE_FLOAT: int;
+  /** Varying is of type [int]. */
+  static readonly VARYING_TYPE_INT: int;
+  /** Varying is of type unsigned [int]. */
+  static readonly VARYING_TYPE_UINT: int;
+  /** Varying is of type {@link Vector2}. */
+  static readonly VARYING_TYPE_VECTOR_2D: int;
+  /** Varying is of type {@link Vector3}. */
+  static readonly VARYING_TYPE_VECTOR_3D: int;
+  /** Varying is of type {@link Vector4}. */
+  static readonly VARYING_TYPE_VECTOR_4D: int;
+  /** Varying is of type [bool]. */
+  static readonly VARYING_TYPE_BOOLEAN: int;
+  /** Varying is of type {@link Transform3D}. */
+  static readonly VARYING_TYPE_TRANSFORM: int;
+  /** Represents the size of the {@link VaryingType} enum. */
+  static readonly VARYING_TYPE_MAX: int;
+
+  /** Indicates an invalid {@link VisualShader} node. */
+  static readonly NODE_ID_INVALID: int;
+  /** Indicates an output node of {@link VisualShader}. */
+  static readonly NODE_ID_OUTPUT: int;
+}

package/typings/classes/VisualShaderNode.d.ts

@@ -0,0 +1,63 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Base class for {@link VisualShader} nodes. Not related to scene nodes. */
+declare class VisualShaderNode extends Resource {
+  /**
+   * Represents the index of the frame this node is linked to. If set to `-1` the node is not linked to any frame.
+   */
+  linked_parent_graph_frame: int;
+  /**
+   * Sets the output port index which will be showed for preview. If set to `-1` no port will be open for preview.
+   */
+  output_port_for_preview: int;
+  set_frame(value: int): void;
+  get_frame(): int;
+  set_output_port_for_preview(value: int): void;
+  get_output_port_for_preview(): int;
+
+  /** Clears the default input ports value. */
+  clear_default_input_values(): void;
+  /**
+   * 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.
+   */
+  get_default_input_port(type_: int): int;
+  /**
+   * Returns an {@link Array} containing default values for all of the input ports of the node in the form `[index0, value0, index1, value1, ...]`.
+   */
+  get_default_input_values(): Array<unknown>;
+  /** Returns the default value of the input `port`. */
+  get_input_port_default_value(port: int): unknown;
+  /** Removes the default value of the input `port`. */
+  remove_input_port_default_value(port: int): void;
+  /**
+   * Sets the default input ports values using an {@link Array} of the form `[index0, value0, index1, value1, ...]`. For example: `[0, Vector3(0, 0, 0), 1, Vector3(0, 0, 0)]`.
+   */
+  set_default_input_values(values: Array<unknown> | PackedByteArray | PackedColorArray | PackedFloat32Array | PackedFloat64Array | PackedInt32Array | PackedInt64Array | PackedStringArray | PackedVector2Array | PackedVector3Array | PackedVector4Array): void;
+  /** Sets the default `value` for the selected input `port`. */
+  set_input_port_default_value(port: int, value: unknown, prev_value?: unknown): void;
+
+  // enum PortType
+  /** Floating-point scalar. Translated to [code skip-lint]float[/code] type in shader code. */
+  static readonly PORT_TYPE_SCALAR: int;
+  /** Integer scalar. Translated to [code skip-lint]int[/code] type in shader code. */
+  static readonly PORT_TYPE_SCALAR_INT: int;
+  /** Unsigned integer scalar. Translated to [code skip-lint]uint[/code] type in shader code. */
+  static readonly PORT_TYPE_SCALAR_UINT: int;
+  /** 2D vector of floating-point values. Translated to [code skip-lint]vec2[/code] type in shader code. */
+  static readonly PORT_TYPE_VECTOR_2D: int;
+  /** 3D vector of floating-point values. Translated to [code skip-lint]vec3[/code] type in shader code. */
+  static readonly PORT_TYPE_VECTOR_3D: int;
+  /** 4D vector of floating-point values. Translated to [code skip-lint]vec4[/code] type in shader code. */
+  static readonly PORT_TYPE_VECTOR_4D: int;
+  /** Boolean type. Translated to [code skip-lint]bool[/code] type in shader code. */
+  static readonly PORT_TYPE_BOOLEAN: int;
+  /** Transform type. Translated to [code skip-lint]mat4[/code] type in shader code. */
+  static readonly PORT_TYPE_TRANSFORM: int;
+  /**
+   * Sampler type. Translated to reference of sampler uniform in shader code. Can only be used for input ports in non-uniform nodes.
+   */
+  static readonly PORT_TYPE_SAMPLER: int;
+  /** Represents the size of the {@link PortType} enum. */
+  static readonly PORT_TYPE_MAX: int;
+}

package/typings/classes/VisualShaderNodeBillboard.d.ts

@@ -0,0 +1,28 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A node that controls how the object faces the camera to be used within the visual shader graph. */
+declare class VisualShaderNodeBillboard extends VisualShaderNode {
+  /** Controls how the object faces the camera. */
+  billboard_type: int;
+  /**
+   * If `true`, the shader will keep the scale set for the mesh. Otherwise, the scale is lost when billboarding.
+   */
+  keep_scale: boolean;
+  set_billboard_type(value: int): void;
+  get_billboard_type(): int;
+  set_keep_scale_enabled(value: boolean): void;
+  is_keep_scale_enabled(): boolean;
+
+  // enum BillboardType
+  /** Billboarding is disabled and the node does nothing. */
+  static readonly BILLBOARD_TYPE_DISABLED: int;
+  /** A standard billboarding algorithm is enabled. */
+  static readonly BILLBOARD_TYPE_ENABLED: int;
+  /** A billboarding algorithm to rotate around Y-axis is enabled. */
+  static readonly BILLBOARD_TYPE_FIXED_Y: int;
+  /** A billboarding algorithm designed to use on particles is enabled. */
+  static readonly BILLBOARD_TYPE_PARTICLES: int;
+  /** Represents the size of the {@link BillboardType} enum. */
+  static readonly BILLBOARD_TYPE_MAX: int;
+}

package/typings/classes/VisualShaderNodeBooleanConstant.d.ts

@@ -0,0 +1,10 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A boolean constant to be used within the visual shader graph. */
+declare class VisualShaderNodeBooleanConstant extends VisualShaderNodeConstant {
+  /** A boolean constant which represents a state of this node. */
+  constant: boolean;
+  set_constant(value: boolean): void;
+  get_constant(): boolean;
+}

package/typings/classes/VisualShaderNodeBooleanParameter.d.ts

@@ -0,0 +1,14 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A boolean parameter to be used within the visual shader graph. */
+declare class VisualShaderNodeBooleanParameter extends VisualShaderNodeParameter {
+  /** A default value to be assigned within the shader. */
+  default_value: boolean;
+  /** Enables usage of the {@link default_value}. */
+  default_value_enabled: boolean;
+  set_default_value(value: boolean): void;
+  get_default_value(): boolean;
+  set_default_value_enabled(value: boolean): void;
+  is_default_value_enabled(): boolean;
+}

package/typings/classes/VisualShaderNodeClamp.d.ts

@@ -0,0 +1,26 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Clamps a value within the visual shader graph. */
+declare class VisualShaderNodeClamp extends VisualShaderNode {
+  /** A type of operands and returned value. */
+  op_type: int;
+  set_op_type(value: int): void;
+  get_op_type(): int;
+
+  // enum OpType
+  /** A floating-point scalar. */
+  static readonly OP_TYPE_FLOAT: int;
+  /** An integer scalar. */
+  static readonly OP_TYPE_INT: int;
+  /** An unsigned integer scalar. */
+  static readonly OP_TYPE_UINT: int;
+  /** A 2D vector type. */
+  static readonly OP_TYPE_VECTOR_2D: int;
+  /** A 3D vector type. */
+  static readonly OP_TYPE_VECTOR_3D: int;
+  /** A 4D vector type. */
+  static readonly OP_TYPE_VECTOR_4D: int;
+  /** Represents the size of the {@link OpType} enum. */
+  static readonly OP_TYPE_MAX: int;
+}

package/typings/classes/VisualShaderNodeColorConstant.d.ts

@@ -0,0 +1,10 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A {@link Color} constant to be used within the visual shader graph. */
+declare class VisualShaderNodeColorConstant extends VisualShaderNodeConstant {
+  /** A {@link Color} constant which represents a state of this node. */
+  constant: Color;
+  set_constant(value: Color): void;
+  get_constant(): Color;
+}

package/typings/classes/VisualShaderNodeColorFunc.d.ts

@@ -0,0 +1,32 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A {@link Color} function to be used within the visual shader graph. */
+declare class VisualShaderNodeColorFunc extends VisualShaderNode {
+  /** A function to be applied to the input color. */
+  function: int;
+  set_function(value: int): void;
+  get_function(): int;
+
+  // enum Function
+  /** Converts the color to grayscale using the following formula: */
+  static readonly FUNC_GRAYSCALE: int;
+  /** Converts HSV vector to RGB equivalent. */
+  static readonly FUNC_HSV2RGB: int;
+  /** Converts RGB vector to HSV equivalent. */
+  static readonly FUNC_RGB2HSV: int;
+  /** Applies sepia tone effect using the following formula: */
+  static readonly FUNC_SEPIA: int;
+  /**
+   * Converts color from linear encoding to nonlinear sRGB encoding using the following formula:
+   * The Compatibility renderer uses a simpler formula that may produce undefined behavior with negative input values:
+   */
+  static readonly FUNC_LINEAR_TO_SRGB: int;
+  /**
+   * Converts color from nonlinear sRGB encoding to linear encoding using the following formula:
+   * The Compatibility renderer uses a simpler formula that behaves poorly with negative input values:
+   */
+  static readonly FUNC_SRGB_TO_LINEAR: int;
+  /** Represents the size of the {@link Function} enum. */
+  static readonly FUNC_MAX: int;
+}

package/typings/classes/VisualShaderNodeColorOp.d.ts

@@ -0,0 +1,32 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A {@link Color} operator to be used within the visual shader graph. */
+declare class VisualShaderNodeColorOp extends VisualShaderNode {
+  /** An operator to be applied to the inputs. */
+  operator: int;
+  set_operator(value: int): void;
+  get_operator(): int;
+
+  // enum Operator
+  /** Produce a screen effect with the following formula: */
+  static readonly OP_SCREEN: int;
+  /** Produce a difference effect with the following formula: */
+  static readonly OP_DIFFERENCE: int;
+  /** Produce a darken effect with the following formula: */
+  static readonly OP_DARKEN: int;
+  /** Produce a lighten effect with the following formula: */
+  static readonly OP_LIGHTEN: int;
+  /** Produce an overlay effect with the following formula: */
+  static readonly OP_OVERLAY: int;
+  /** Produce a dodge effect with the following formula: */
+  static readonly OP_DODGE: int;
+  /** Produce a burn effect with the following formula: */
+  static readonly OP_BURN: int;
+  /** Produce a soft light effect with the following formula: */
+  static readonly OP_SOFT_LIGHT: int;
+  /** Produce a hard light effect with the following formula: */
+  static readonly OP_HARD_LIGHT: int;
+  /** Represents the size of the {@link Operator} enum. */
+  static readonly OP_MAX: int;
+}

package/typings/classes/VisualShaderNodeColorParameter.d.ts

@@ -0,0 +1,14 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A {@link Color} parameter to be used within the visual shader graph. */
+declare class VisualShaderNodeColorParameter extends VisualShaderNodeParameter {
+  /** A default value to be assigned within the shader. */
+  default_value: Color;
+  /** Enables usage of the {@link default_value}. */
+  default_value_enabled: boolean;
+  set_default_value(value: Color): void;
+  get_default_value(): Color;
+  set_default_value_enabled(value: boolean): void;
+  is_default_value_enabled(): boolean;
+}

package/typings/classes/VisualShaderNodeComment.d.ts

@@ -0,0 +1,12 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Only exists for compatibility. Use {@link VisualShaderNodeFrame} as a replacement. */
+declare class VisualShaderNodeComment extends VisualShaderNodeFrame {
+  /**
+   * This property only exists to preserve data authored in earlier versions of Godot. It has currently no function.
+   */
+  description: string;
+  set_description(value: string | NodePath): void;
+  get_description(): string;
+}