typescript-to-gdscript 0.1.0

package/typings/classes/VisualShaderNodeVec2Constant.d.ts

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

package/typings/classes/VisualShaderNodeVec2Parameter.d.ts

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

package/typings/classes/VisualShaderNodeVec3Constant.d.ts

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

package/typings/classes/VisualShaderNodeVec3Parameter.d.ts

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

package/typings/classes/VisualShaderNodeVec4Constant.d.ts

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

package/typings/classes/VisualShaderNodeVec4Parameter.d.ts

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

package/typings/classes/VisualShaderNodeVectorBase.d.ts

@@ -0,0 +1,20 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A base type for the nodes that perform vector operations within the visual shader graph. */
+declare class VisualShaderNodeVectorBase extends VisualShaderNode {
+  /** A vector type that this operation is performed on. */
+  op_type: int;
+  set_op_type(value: int): void;
+  get_op_type(): int;
+
+  // enum OpType
+  /** 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/VisualShaderNodeVectorCompose.d.ts

@@ -0,0 +1,8 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * Composes a {@link Vector2}, {@link Vector3} or 4D vector (represented as a {@link Quaternion}) from scalars within the visual shader graph.
+ */
+declare class VisualShaderNodeVectorCompose extends VisualShaderNodeVectorBase {
+}

package/typings/classes/VisualShaderNodeVectorDecompose.d.ts

@@ -0,0 +1,8 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * Decomposes a {@link Vector2}, {@link Vector3} or 4D vector (represented as a {@link Quaternion}) into scalars within the visual shader graph.
+ */
+declare class VisualShaderNodeVectorDecompose extends VisualShaderNodeVectorBase {
+}

package/typings/classes/VisualShaderNodeVectorDistance.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Returns the distance between two points. To be used within the visual shader graph. */
+declare class VisualShaderNodeVectorDistance extends VisualShaderNodeVectorBase {
+}

package/typings/classes/VisualShaderNodeVectorFunc.d.ts

@@ -0,0 +1,84 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A vector function to be used within the visual shader graph. */
+declare class VisualShaderNodeVectorFunc extends VisualShaderNodeVectorBase {
+  /** The function to be performed. */
+  function: int;
+  set_function(value: int): void;
+  get_function(): int;
+
+  // enum Function
+  /** Normalizes the vector so that it has a length of `1` but points in the same direction. */
+  static readonly FUNC_NORMALIZE: int;
+  /** Clamps the value between `0.0` and `1.0`. */
+  static readonly FUNC_SATURATE: int;
+  /** Returns the opposite value of the parameter. */
+  static readonly FUNC_NEGATE: int;
+  /** Returns `1/vector`. */
+  static readonly FUNC_RECIPROCAL: int;
+  /** Returns the absolute value of the parameter. */
+  static readonly FUNC_ABS: int;
+  /** Returns the arc-cosine of the parameter. */
+  static readonly FUNC_ACOS: int;
+  /** Returns the inverse hyperbolic cosine of the parameter. */
+  static readonly FUNC_ACOSH: int;
+  /** Returns the arc-sine of the parameter. */
+  static readonly FUNC_ASIN: int;
+  /** Returns the inverse hyperbolic sine of the parameter. */
+  static readonly FUNC_ASINH: int;
+  /** Returns the arc-tangent of the parameter. */
+  static readonly FUNC_ATAN: int;
+  /** Returns the inverse hyperbolic tangent of the parameter. */
+  static readonly FUNC_ATANH: int;
+  /** Finds the nearest integer that is greater than or equal to the parameter. */
+  static readonly FUNC_CEIL: int;
+  /** Returns the cosine of the parameter. */
+  static readonly FUNC_COS: int;
+  /** Returns the hyperbolic cosine of the parameter. */
+  static readonly FUNC_COSH: int;
+  /** Converts a quantity in radians to degrees. */
+  static readonly FUNC_DEGREES: int;
+  /** Base-e Exponential. */
+  static readonly FUNC_EXP: int;
+  /** Base-2 Exponential. */
+  static readonly FUNC_EXP2: int;
+  /** Finds the nearest integer less than or equal to the parameter. */
+  static readonly FUNC_FLOOR: int;
+  /** Computes the fractional part of the argument. */
+  static readonly FUNC_FRACT: int;
+  /** Returns the inverse of the square root of the parameter. */
+  static readonly FUNC_INVERSE_SQRT: int;
+  /** Natural logarithm. */
+  static readonly FUNC_LOG: int;
+  /** Base-2 logarithm. */
+  static readonly FUNC_LOG2: int;
+  /** Converts a quantity in degrees to radians. */
+  static readonly FUNC_RADIANS: int;
+  /** Finds the nearest integer to the parameter. */
+  static readonly FUNC_ROUND: int;
+  /** Finds the nearest even integer to the parameter. */
+  static readonly FUNC_ROUNDEVEN: int;
+  /**
+   * Extracts the sign of the parameter, i.e. returns `-1` if the parameter is negative, `1` if it's positive and `0` otherwise.
+   */
+  static readonly FUNC_SIGN: int;
+  /** Returns the sine of the parameter. */
+  static readonly FUNC_SIN: int;
+  /** Returns the hyperbolic sine of the parameter. */
+  static readonly FUNC_SINH: int;
+  /** Returns the square root of the parameter. */
+  static readonly FUNC_SQRT: int;
+  /** Returns the tangent of the parameter. */
+  static readonly FUNC_TAN: int;
+  /** Returns the hyperbolic tangent of the parameter. */
+  static readonly FUNC_TANH: int;
+  /**
+   * Returns a value equal to the nearest integer to the parameter whose absolute value is not larger than the absolute value of the parameter.
+   */
+  static readonly FUNC_TRUNC: int;
+  /** Returns `1.0 - vector`. */
+  static readonly FUNC_ONEMINUS: int;
+  /** Represents the size of the {@link Function} enum. */
+  static readonly FUNC_MAX: int;
+}

package/typings/classes/VisualShaderNodeVectorLen.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Returns the length of a {@link Vector3} within the visual shader graph. */
+declare class VisualShaderNodeVectorLen extends VisualShaderNodeVectorBase {
+}

package/typings/classes/VisualShaderNodeVectorOp.d.ts

@@ -0,0 +1,42 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A vector operator to be used within the visual shader graph. */
+declare class VisualShaderNodeVectorOp extends VisualShaderNodeVectorBase {
+  /** The operator to be used. */
+  operator: int;
+  set_operator(value: int): void;
+  get_operator(): int;
+
+  // enum Operator
+  /** Adds two vectors. */
+  static readonly OP_ADD: int;
+  /** Subtracts a vector from a vector. */
+  static readonly OP_SUB: int;
+  /** Multiplies two vectors. */
+  static readonly OP_MUL: int;
+  /** Divides vector by vector. */
+  static readonly OP_DIV: int;
+  /** Returns the remainder of the two vectors. */
+  static readonly OP_MOD: int;
+  /**
+   * Returns the value of the first parameter raised to the power of the second, for each component of the vectors.
+   */
+  static readonly OP_POW: int;
+  /** Returns the greater of two values, for each component of the vectors. */
+  static readonly OP_MAX: int;
+  /** Returns the lesser of two values, for each component of the vectors. */
+  static readonly OP_MIN: int;
+  /** Calculates the cross product of two vectors. */
+  static readonly OP_CROSS: int;
+  /** Returns the arc-tangent of the parameters. */
+  static readonly OP_ATAN2: int;
+  /**
+   * Returns the vector that points in the direction of reflection. `a` is incident vector and `b` is the normal vector.
+   */
+  static readonly OP_REFLECT: int;
+  /** Vector step operator. Returns `0.0` if `a` is smaller than `b` and `1.0` otherwise. */
+  static readonly OP_STEP: int;
+  /** Represents the size of the {@link Operator} enum. */
+  static readonly OP_ENUM_SIZE: int;
+}

package/typings/classes/VisualShaderNodeVectorRefract.d.ts

@@ -0,0 +1,8 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * Returns the vector that points in the direction of refraction. For use within the visual shader graph.
+ */
+declare class VisualShaderNodeVectorRefract extends VisualShaderNodeVectorBase {
+}

package/typings/classes/VisualShaderNodeWorldPositionFromDepth.d.ts

@@ -0,0 +1,8 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * A visual shader node that calculates the position of the pixel in world space using the depth texture.
+ */
+declare class VisualShaderNodeWorldPositionFromDepth extends VisualShaderNode {
+}

package/typings/classes/VoxelGI.d.ts

@@ -0,0 +1,54 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Real-time global illumination (GI) probe. */
+declare class VoxelGI extends VisualInstance3D {
+  /**
+   * The {@link CameraAttributes} resource that specifies exposure levels to bake at. Auto-exposure and non exposure properties will be ignored. Exposure settings should be used to reduce the dynamic range present when baking. If exposure is too high, the {@link VoxelGI} will have banding artifacts or may have over-exposure artifacts.
+   */
+  camera_attributes: CameraAttributes | null;
+  /** The {@link VoxelGIData} resource that holds the data for this {@link VoxelGI}. */
+  data: VoxelGIData | null;
+  /**
+   * The size of the area covered by the {@link VoxelGI}. This must be `1.0` or greater on each axis.
+   * **Note:** If you make the size larger without increasing the number of subdivisions with {@link subdiv}, the size of each cell will increase and result in less detailed lighting.
+   */
+  size: Vector3;
+  /**
+   * Number of times to subdivide the grid that the {@link VoxelGI} operates on. A higher number results in finer detail and thus higher visual quality, while lower numbers result in better performance.
+   */
+  subdiv: int;
+  set_camera_attributes(value: CameraAttributes | null): void;
+  get_camera_attributes(): CameraAttributes | null;
+  set_probe_data(value: VoxelGIData | null): void;
+  get_probe_data(): VoxelGIData | null;
+  set_size(value: Vector3 | Vector3i): void;
+  get_size(): Vector3;
+  set_subdiv(value: int): void;
+  get_subdiv(): int;
+
+  /**
+   * Bakes the effect from all {@link GeometryInstance3D}s marked with {@link GeometryInstance3D.GI_MODE_STATIC} and {@link Light3D}s marked with either {@link Light3D.BAKE_STATIC} or {@link Light3D.BAKE_DYNAMIC}. If `create_visual_debug` is `true`, after baking the light, this will generate a {@link MultiMesh} that has a cube representing each solid cell with each cube colored to the cell's albedo color. This can be used to visualize the {@link VoxelGI}'s data and debug any issues that may be occurring.
+   * **Note:** {@link bake} works from the editor and in exported projects. This makes it suitable for procedurally generated or user-built levels. Baking a {@link VoxelGI} node generally takes from 5 to 20 seconds in most scenes. Reducing {@link subdiv} can speed up baking.
+   * **Note:** {@link GeometryInstance3D}s and {@link Light3D}s must be fully ready before {@link bake} is called. If you are procedurally creating those and some meshes or lights are missing from your baked {@link VoxelGI}, use `call_deferred("bake")` instead of calling {@link bake} directly.
+   */
+  bake(from_node?: Node, create_visual_debug?: boolean): void;
+  /** Calls {@link bake} with `create_visual_debug` enabled. */
+  debug_bake(): void;
+
+  // enum Subdiv
+  /**
+   * Use 64 subdivisions. This is the lowest quality setting, but the fastest. Use it if you can, but especially use it on lower-end hardware.
+   */
+  static readonly SUBDIV_64: int;
+  /** Use 128 subdivisions. This is the default quality setting. */
+  static readonly SUBDIV_128: int;
+  /** Use 256 subdivisions. */
+  static readonly SUBDIV_256: int;
+  /**
+   * Use 512 subdivisions. This is the highest quality setting, but the slowest. On lower-end hardware, this could cause the GPU to stall.
+   */
+  static readonly SUBDIV_512: int;
+  /** Represents the size of the {@link Subdiv} enum. */
+  static readonly SUBDIV_MAX: int;
+}

package/typings/classes/VoxelGIData.d.ts

@@ -0,0 +1,70 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Contains baked voxel global illumination data for use in a {@link VoxelGI} node. */
+declare class VoxelGIData extends Resource {
+  /**
+   * The normal bias to use for indirect lighting and reflections. Higher values reduce self-reflections visible in non-rough materials, at the cost of more visible light leaking and flatter-looking indirect lighting. To prioritize hiding self-reflections over lighting quality, set {@link bias} to `0.0` and {@link normal_bias} to a value between `1.0` and `2.0`.
+   */
+  bias: float;
+  /**
+   * The dynamic range to use (`1.0` represents a low dynamic range scene brightness). Higher values can be used to provide brighter indirect lighting, at the cost of more visible color banding in dark areas (both in indirect lighting and reflections). To avoid color banding, it's recommended to use the lowest value that does not result in visible light clipping.
+   */
+  dynamic_range: float;
+  /**
+   * The energy of the indirect lighting and reflections produced by the {@link VoxelGI} node. Higher values result in brighter indirect lighting. If indirect lighting looks too flat, try decreasing {@link propagation} while increasing {@link energy} at the same time. See also {@link use_two_bounces} which influences the indirect lighting's effective brightness.
+   */
+  energy: float;
+  /**
+   * If `true`, {@link Environment} lighting is ignored by the {@link VoxelGI} node. If `false`, {@link Environment} lighting is taken into account by the {@link VoxelGI} node. {@link Environment} lighting updates in real-time, which means it can be changed without having to bake the {@link VoxelGI} node again.
+   */
+  interior: boolean;
+  /**
+   * The normal bias to use for indirect lighting and reflections. Higher values reduce self-reflections visible in non-rough materials, at the cost of more visible light leaking and flatter-looking indirect lighting. See also {@link bias}. To prioritize hiding self-reflections over lighting quality, set {@link bias} to `0.0` and {@link normal_bias} to a value between `1.0` and `2.0`.
+   */
+  normal_bias: float;
+  /**
+   * The multiplier to use when light bounces off a surface. Higher values result in brighter indirect lighting. If indirect lighting looks too flat, try decreasing {@link propagation} while increasing {@link energy} at the same time. See also {@link use_two_bounces} which influences the indirect lighting's effective brightness.
+   */
+  propagation: float;
+  /**
+   * If `true`, performs two bounces of indirect lighting instead of one. This makes indirect lighting look more natural and brighter at a small performance cost. The second bounce is also visible in reflections. If the scene appears too bright after enabling {@link use_two_bounces}, adjust {@link propagation} and {@link energy}.
+   */
+  use_two_bounces: boolean;
+  set_bias(value: float): void;
+  get_bias(): float;
+  set_dynamic_range(value: float): void;
+  get_dynamic_range(): float;
+  set_energy(value: float): void;
+  get_energy(): float;
+  set_interior(value: boolean): void;
+  is_interior(): boolean;
+  set_normal_bias(value: float): void;
+  get_normal_bias(): float;
+  set_propagation(value: float): void;
+  get_propagation(): float;
+  set_use_two_bounces(value: boolean): void;
+  is_using_two_bounces(): boolean;
+
+  /**
+   * Initializes this {@link VoxelGIData} with the specified data. `octree_cells` must be a multiple of 32. `octree_cells` must be double the size of `data_cells`. The allocated data can be retrieved later using the various getter methods.
+   */
+  allocate(to_cell_xform: Transform3D | Projection, aabb: AABB, octree_size: Vector3 | Vector3i, octree_cells: PackedByteArray | Array<unknown>, data_cells: PackedByteArray | Array<unknown>, distance_field: PackedByteArray | Array<unknown>, level_counts: PackedInt32Array | Array<unknown>): void;
+  /**
+   * Returns the bounds of the baked voxel data as an {@link AABB}, which should match {@link VoxelGI.size} after being baked (which only contains the size as a {@link Vector3}).
+   * **Note:** If the size was modified without baking the VoxelGI data, then the value of {@link get_bounds} and {@link VoxelGI.size} will not match.
+   */
+  get_bounds(): AABB;
+  /** Returns the baked cell data for this {@link VoxelGIData}. */
+  get_data_cells(): PackedByteArray;
+  /** Returns the baked level counts for this {@link VoxelGIData}. */
+  get_level_counts(): PackedInt32Array;
+  /** Returns the baked octree cell data for this {@link VoxelGIData}. */
+  get_octree_cells(): PackedByteArray;
+  /**
+   * Returns the baked octree size for this {@link VoxelGIData}, which corresponds to the number of subdivisions per axis. This can be viewed in the editor by hovering the **Bake VoxelGI** button at the top of the 3D editor viewport when a {@link VoxelGI} node is selected and looking at the **Subdivisions** field in the tooltip.
+   */
+  get_octree_size(): Vector3;
+  /** Returns the baked cell transform for this {@link VoxelGIData}. */
+  get_to_cell_xform(): Transform3D;
+}

package/typings/classes/WeakRef.d.ts

@@ -0,0 +1,12 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * Holds an {@link Object}. If the object is {@link RefCounted}, it doesn't update the reference count.
+ */
+declare class WeakRef extends RefCounted {
+  /**
+   * Returns the {@link Object} this weakref is referring to. Returns `null` if that object no longer exists.
+   */
+  get_ref(): unknown;
+}