typescript-to-gdscript 0.1.0

package/typings/classes/SpinBox.d.ts

@@ -0,0 +1,60 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** An input field for numbers. */
+declare class SpinBox extends Range {
+  /** Changes the alignment of the underlying {@link LineEdit}. */
+  alignment: int;
+  /**
+   * If `true`, the value will be rounded to a multiple of {@link custom_arrow_step} when interacting with the arrow buttons. Otherwise, increments the value by {@link custom_arrow_step} and then rounds it according to {@link Range.step}.
+   */
+  custom_arrow_round: boolean;
+  /**
+   * If not `0`, sets the step when interacting with the arrow buttons of the {@link SpinBox}.
+   * **Note:** {@link Range.value} will still be rounded to a multiple of {@link Range.step}.
+   */
+  custom_arrow_step: float;
+  /** If `true`, the {@link SpinBox} will be editable. Otherwise, it will be read only. */
+  editable: boolean;
+  /** Adds the specified prefix string before the numerical value of the {@link SpinBox}. */
+  prefix: string;
+  /**
+   * If `true`, the {@link SpinBox} will select the whole text when the {@link LineEdit} gains focus. Clicking the up and down arrows won't trigger this behavior.
+   */
+  select_all_on_focus: boolean;
+  /**
+   * <member name="step" type="float" setter="set_step" getter="get_step" overrides="Range" default="1.0" />
+   * <member name="suffix" type="String" setter="set_suffix" getter="get_suffix" default="&quot;&quot;">
+   * Adds the specified suffix string after the numerical value of the {@link SpinBox}.
+   */
+  size_flags_vertical: int;
+  /**
+   * Sets the value of the {@link Range} for this {@link SpinBox} when the {@link LineEdit} text is *changed* instead of *submitted*. See {@link LineEdit.text_changed} and {@link LineEdit.text_submitted}.
+   * **Note:** If set to `true`, this will interfere with entering mathematical expressions in the {@link SpinBox}. The {@link SpinBox} will try to evaluate the expression as you type, which means symbols like a trailing `+` are removed immediately by the expression being evaluated.
+   */
+  update_on_text_changed: boolean;
+  set_horizontal_alignment(value: int): void;
+  get_horizontal_alignment(): int;
+  set_custom_arrow_round(value: boolean): void;
+  is_custom_arrow_rounding(): boolean;
+  set_custom_arrow_step(value: float): void;
+  get_custom_arrow_step(): float;
+  set_editable(value: boolean): void;
+  is_editable(): boolean;
+  set_prefix(value: string | NodePath): void;
+  get_prefix(): string;
+  set_select_all_on_focus(value: boolean): void;
+  is_select_all_on_focus(): boolean;
+  set_update_on_text_changed(value: boolean): void;
+  get_update_on_text_changed(): boolean;
+
+  /**
+   * Applies the current value of this {@link SpinBox}. This is equivalent to pressing `Enter` while editing the {@link LineEdit} used by the {@link SpinBox}. This will cause {@link LineEdit.text_submitted} to be emitted and its currently contained expression to be evaluated.
+   */
+  apply(): void;
+  /**
+   * Returns the {@link LineEdit} instance from this {@link SpinBox}. You can use it to access properties and methods of {@link LineEdit}.
+   * **Warning:** This is a required internal node, removing and freeing it may cause a crash. If you wish to hide it or any of its children, use their {@link CanvasItem.visible} property.
+   */
+  get_line_edit(): LineEdit;
+}

package/typings/classes/SplineIK3D.d.ts

@@ -0,0 +1,37 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A {@link SkeletonModifier3D} for aligning bones along a {@link Path3D}. */
+declare class SplineIK3D extends ChainIK3D {
+  /** The number of settings. */
+  setting_count: int;
+
+  /** Returns the node path of the {@link Path3D} which is describing the path. */
+  get_path_3d(index: int): NodePath;
+  /**
+   * Returns the tilt interpolation method used between the root bone and the start point of the {@link Curve3D} when they are apart. See also {@link set_tilt_fade_in}.
+   */
+  get_tilt_fade_in(index: int): int;
+  /**
+   * Returns the tilt interpolation method used between the end bone and the end point of the {@link Curve3D} when they are apart. See also {@link set_tilt_fade_out}.
+   */
+  get_tilt_fade_out(index: int): int;
+  /** Returns if the tilt property of the {@link Curve3D} affects the bone twist. */
+  is_tilt_enabled(index: int): boolean;
+  /** Sets the node path of the {@link Path3D} which is describing the path. */
+  set_path_3d(index: int, path_3d: NodePath | string): void;
+  /** Sets if the tilt property of the {@link Curve3D} should affect the bone twist. */
+  set_tilt_enabled(index: int, enabled: boolean): void;
+  /**
+   * If `size` is greater than `0`, the tilt is interpolated between `size` start bones from the start point of the {@link Curve3D} when they are apart.
+   * If `size` is equal `0`, the tilts between the root bone head and the start point of the {@link Curve3D} are unified with a tilt of the start point of the {@link Curve3D}.
+   * If `size` is less than `0`, the tilts between the root bone and the start point of the {@link Curve3D} are `0.0`.
+   */
+  set_tilt_fade_in(index: int, size: int): void;
+  /**
+   * If `size` is greater than `0`, the tilt is interpolated between `size` end bones from the end point of the {@link Curve3D} when they are apart.
+   * If `size` is equal `0`, the tilts between the end bone tail and the end point of the {@link Curve3D} are unified with a tilt of the end point of the {@link Curve3D}.
+   * If `size` is less than `0`, the tilts between the end bone and the end point of the {@link Curve3D} are `0.0`.
+   */
+  set_tilt_fade_out(index: int, size: int): void;
+}

package/typings/classes/SplitContainer.d.ts

@@ -0,0 +1,114 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * A container that arranges child controls horizontally or vertically and provides grabbers for adjusting the split ratios between them.
+ */
+declare class SplitContainer extends Container {
+  /**
+   * If `true`, the draggers will be disabled and the children will be sized as if all {@link split_offsets} were `0`.
+   */
+  collapsed: boolean;
+  /**
+   * Highlights the drag area {@link Rect2} so you can see where it is during development. The drag area is gold if {@link dragging_enabled} is `true`, and red if `false`.
+   */
+  drag_area_highlight_in_editor: boolean;
+  /** Reduces the size of the drag area and split bar  at the beginning of the container. */
+  drag_area_margin_begin: int;
+  /** Reduces the size of the drag area and split bar  at the end of the container. */
+  drag_area_margin_end: int;
+  /**
+   * Shifts the drag area in the axis of the container to prevent the drag area from overlapping the {@link ScrollBar} or other selectable {@link Control} of a child node.
+   */
+  drag_area_offset: int;
+  /**
+   * Adds extra draggers at the intersection of the draggers of two SplitContainers to allow dragging both at once. This must be set to `true` for both SplitContainers, and one needs to be a descendant of the other. They also must be orthogonal (their {@link vertical} are different) and the descendant must be next to at least one of the ancestor's draggers (within ).
+   */
+  drag_nested_intersections: boolean;
+  /**
+   * Determines the dragger's visibility. This property does not determine whether dragging is enabled or not. Use {@link dragging_enabled} for that.
+   */
+  dragger_visibility: int;
+  /** Enables or disables split dragging. */
+  dragging_enabled: boolean;
+  /** The first element of {@link split_offsets}. */
+  split_offset: int;
+  /**
+   * Offsets for each dragger in pixels. Each one is the offset of the split between the {@link Control} nodes before and after the dragger, with `0` being the default position. The default position is based on the {@link Control} nodes expand flags and minimum sizes. See {@link Control.size_flags_horizontal}, {@link Control.size_flags_vertical}, and {@link Control.size_flags_stretch_ratio}.
+   * If none of the {@link Control} nodes before the dragger are expanded, the default position will be at the start of the {@link SplitContainer}. If none of the {@link Control} nodes after the dragger are expanded, the default position will be at the end of the {@link SplitContainer}. If the dragger is in between expanded {@link Control} nodes, the default position will be in the middle, based on the {@link Control.size_flags_stretch_ratio}s and minimum sizes.
+   * **Note:** If the split offsets cause {@link Control} nodes to overlap, the first split will take priority when resolving the positions.
+   */
+  split_offsets: PackedInt32Array;
+  /**
+   * If `true`, a touch-friendly drag handle will be enabled for better usability on smaller screens. Unlike the standard grabber, this drag handle overlaps the {@link SplitContainer}'s children and does not affect their minimum separation. The standard grabber will no longer be drawn when this option is enabled.
+   */
+  touch_dragger_enabled: boolean;
+  /**
+   * If `true`, the {@link SplitContainer} will arrange its children vertically, rather than horizontally.
+   * Can't be changed when using {@link HSplitContainer} and {@link VSplitContainer}.
+   */
+  vertical: boolean;
+  set_collapsed(value: boolean): void;
+  is_collapsed(): boolean;
+  set_drag_area_highlight_in_editor(value: boolean): void;
+  is_drag_area_highlight_in_editor_enabled(): boolean;
+  set_drag_area_margin_begin(value: int): void;
+  get_drag_area_margin_begin(): int;
+  set_drag_area_margin_end(value: int): void;
+  get_drag_area_margin_end(): int;
+  set_drag_area_offset(value: int): void;
+  get_drag_area_offset(): int;
+  set_drag_nested_intersections(value: boolean): void;
+  is_dragging_nested_intersections(): boolean;
+  set_dragger_visibility(value: int): void;
+  get_dragger_visibility(): int;
+  set_dragging_enabled(value: boolean): void;
+  is_dragging_enabled(): boolean;
+  set_split_offset(value: int): void;
+  get_split_offset(): int;
+  set_split_offsets(value: PackedInt32Array | Array<unknown>): void;
+  get_split_offsets(): PackedInt32Array;
+  set_touch_dragger_enabled(value: boolean): void;
+  is_touch_dragger_enabled(): boolean;
+  set_vertical(value: boolean): void;
+  is_vertical(): boolean;
+
+  /**
+   * Clamps the {@link split_offsets} values to ensure they are within valid ranges and do not overlap with each other. When overlaps occur, this method prioritizes one split offset (at index `priority_index`) by clamping any overlapping split offsets to it.
+   */
+  clamp_split_offset(priority_index?: int): void;
+  /**
+   * Returns the drag area {@link Control}. For example, you can move a pre-configured button into the drag area {@link Control} so that it rides along with the split bar. Try setting the {@link Button} anchors to `center` prior to the `reparent()` call.
+   * **Note:** The drag area {@link Control} is drawn over the {@link SplitContainer}'s children, so {@link CanvasItem} draw objects called from the {@link Control} and children added to the {@link Control} will also appear over the {@link SplitContainer}'s children. Try setting {@link Control.mouse_filter} of custom children to {@link Control.MOUSE_FILTER_IGNORE} to prevent blocking the mouse from dragging if desired.
+   * **Warning:** This is a required internal node, removing and freeing it may cause a crash.
+   */
+  get_drag_area_control(): Control;
+  /**
+   * Returns an {@link Array} of the drag area {@link Control}s. These are the interactable {@link Control} nodes between each child. For example, this can be used to add a pre-configured button to a drag area {@link Control} so that it rides along with the split bar. Try setting the {@link Button} anchors to `center` prior to the {@link Node.reparent} call.
+   * **Note:** The drag area {@link Control}s are drawn over the {@link SplitContainer}'s children, so {@link CanvasItem} draw objects called from a drag area and children added to it will also appear over the {@link SplitContainer}'s children. Try setting {@link Control.mouse_filter} of custom children to {@link Control.MOUSE_FILTER_IGNORE} to prevent blocking the mouse from dragging if desired.
+   * **Warning:** These are required internal nodes, removing or freeing them may cause a crash.
+   */
+  get_drag_area_controls(): Array<Control>;
+
+  /** Emitted when the user ends dragging. */
+  drag_ended: Signal<[]>;
+  /** Emitted when the user starts dragging. */
+  drag_started: Signal<[]>;
+  /** Emitted when any dragger is dragged by user. */
+  dragged: Signal<[int]>;
+
+  // enum DraggerVisibility
+  /**
+   * The split dragger icon is always visible when  is `false`, otherwise visible only when the cursor hovers it.
+   * The size of the grabber icon determines the minimum .
+   * The dragger icon is automatically hidden if the length of the grabber icon is longer than the split bar.
+   */
+  static readonly DRAGGER_VISIBLE: int;
+  /**
+   * The split dragger icon is never visible regardless of the value of .
+   * The size of the grabber icon determines the minimum .
+   */
+  static readonly DRAGGER_HIDDEN: int;
+  /** The split dragger icon is not visible, and the split bar is collapsed to zero thickness. */
+  static readonly DRAGGER_HIDDEN_COLLAPSED: int;
+}

package/typings/classes/SpotLight3D.d.ts

@@ -0,0 +1,28 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A spotlight, such as a reflector spotlight or a lantern. */
+declare class SpotLight3D extends Light3D {
+  /**
+   * <member name="shadow_bias" type="float" setter="set_param" getter="get_param" overrides="Light3D" default="0.03" />
+   * <member name="shadow_normal_bias" type="float" setter="set_param" getter="get_param" overrides="Light3D" default="1.0" />
+   * <member name="spot_angle" type="float" setter="set_param" getter="get_param" default="45.0">
+   * The spotlight's angle in degrees. This is the angular radius, meaning the angle from the -Z axis, the cone's center, to the edge of the cone. The default angular radius of 45 degrees corresponds to a cone with an angular diameter of 90 degrees.
+   * **Note:** {@link spot_angle} is not affected by {@link Node3D.scale} (the light's scale or its parent's scale).
+   */
+  light_specular: float;
+  /** The spotlight's *angular* attenuation curve. See also {@link spot_attenuation}. */
+  spot_angle_attenuation: float;
+  /**
+   * Controls the distance attenuation function for spotlights.
+   * A value of `0.0` will maintain a constant brightness through most of the range, but smoothly attenuate the light at the edge of the range. Use a value of `2.0` for physically accurate lights as it results in the proper inverse square attenutation.
+   * **Note:** Setting attenuation to `2.0` or higher may result in distant objects receiving minimal light, even within range. For example, with a range of `4096`, an object at `100` units is attenuated by a factor of `0.0001`. With a default brightness of `1`, the light would not be visible at that distance.
+   * **Note:** Using negative or values higher than `10.0` may lead to unexpected results.
+   */
+  spot_attenuation: float;
+  /**
+   * The maximal range that can be reached by the spotlight. Note that the effectively lit area may appear to be smaller depending on the {@link spot_attenuation} in use. No matter the {@link spot_attenuation} in use, the light will never reach anything outside this range.
+   * **Note:** {@link spot_range} is not affected by {@link Node3D.scale} (the light's scale or its parent's scale).
+   */
+  spot_range: float;
+}

package/typings/classes/SpringArm3D.d.ts

@@ -0,0 +1,47 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A 3D raycast that dynamically moves its children near the collision point. */
+declare class SpringArm3D extends Node3D {
+  /**
+   * The layers against which the collision check will be done. See Collision layers and masks ($DOCS_URL/tutorials/physics/physics_introduction.html#collision-layers-and-masks) in the documentation for more information.
+   */
+  collision_mask: int;
+  /**
+   * When the collision check is made, a candidate length for the SpringArm3D is given.
+   * The margin is then subtracted to this length and the translation is applied to the child objects of the SpringArm3D.
+   * This margin is useful for when the SpringArm3D has a {@link Camera3D} as a child node: without the margin, the {@link Camera3D} would be placed on the exact point of collision, while with the margin the {@link Camera3D} would be placed close to the point of collision.
+   */
+  margin: float;
+  /**
+   * The {@link Shape3D} to use for the SpringArm3D.
+   * When the shape is set, the SpringArm3D will cast the {@link Shape3D} on its z axis instead of performing a ray cast.
+   */
+  shape: Shape3D | null;
+  /**
+   * The maximum extent of the SpringArm3D. This is used as a length for both the ray and the shape cast used internally to calculate the desired position of the SpringArm3D's child nodes.
+   * To know more about how to perform a shape cast or a ray cast, please consult the {@link PhysicsDirectSpaceState3D} documentation.
+   */
+  spring_length: float;
+  set_collision_mask(value: int): void;
+  get_collision_mask(): int;
+  set_margin(value: float): void;
+  get_margin(): float;
+  set_shape(value: Shape3D | null): void;
+  get_shape(): Shape3D | null;
+  set_length(value: float): void;
+  get_length(): float;
+
+  /**
+   * Adds the {@link PhysicsBody3D} object with the given {@link RID} to the list of {@link PhysicsBody3D} objects excluded from the collision check.
+   */
+  add_excluded_object(RID: RID): void;
+  /** Clears the list of {@link PhysicsBody3D} objects excluded from the collision check. */
+  clear_excluded_objects(): void;
+  /** Returns the spring arm's current length. */
+  get_hit_length(): float;
+  /**
+   * Removes the given {@link RID} from the list of {@link PhysicsBody3D} objects excluded from the collision check.
+   */
+  remove_excluded_object(RID: RID): boolean;
+}

package/typings/classes/SpringBoneCollision3D.d.ts

@@ -0,0 +1,25 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A base class of the collision that interacts with {@link SpringBoneSimulator3D}. */
+declare class SpringBoneCollision3D extends Node3D {
+  /** The index of the attached bone. */
+  bone: int;
+  /** The name of the attached bone. */
+  bone_name: string;
+  /** The offset of the position from {@link Skeleton3D}'s {@link bone} pose position. */
+  position_offset: Vector3;
+  /** The offset of the rotation from {@link Skeleton3D}'s {@link bone} pose rotation. */
+  rotation_offset: Quaternion;
+  set_bone(value: int): void;
+  get_bone(): int;
+  set_bone_name(value: string | NodePath): void;
+  get_bone_name(): string;
+  set_position_offset(value: Vector3 | Vector3i): void;
+  get_position_offset(): Vector3;
+  set_rotation_offset(value: Quaternion | Basis): void;
+  get_rotation_offset(): Quaternion;
+
+  /** Get parent {@link Skeleton3D} node of the parent {@link SpringBoneSimulator3D} if found. */
+  get_skeleton(): Skeleton3D | null;
+}

package/typings/classes/SpringBoneCollisionCapsule3D.d.ts

@@ -0,0 +1,30 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A capsule shape collision that interacts with {@link SpringBoneSimulator3D}. */
+declare class SpringBoneCollisionCapsule3D extends SpringBoneCollision3D {
+  /**
+   * The capsule's full height, including the hemispheres.
+   * **Note:** The {@link height} of a capsule must be at least twice its {@link radius}. Otherwise, the capsule becomes a sphere. If the {@link height} is less than twice the {@link radius}, the properties adjust to a valid value.
+   */
+  height: float;
+  /** If `true`, the collision acts to trap the joint within the collision. */
+  inside: boolean;
+  /**
+   * The capsule's height, excluding the hemispheres. This is the height of the central cylindrical part in the middle of the capsule, and is the distance between the centers of the two hemispheres. This is a wrapper for {@link height}.
+   */
+  mid_height: float;
+  /**
+   * The capsule's radius.
+   * **Note:** The {@link radius} of a capsule cannot be greater than half of its {@link height}. Otherwise, the capsule becomes a sphere. If the {@link radius} is greater than half of the {@link height}, the properties adjust to a valid value.
+   */
+  radius: float;
+  set_height(value: float): void;
+  get_height(): float;
+  set_inside(value: boolean): void;
+  is_inside(): boolean;
+  set_mid_height(value: float): void;
+  get_mid_height(): float;
+  set_radius(value: float): void;
+  get_radius(): float;
+}

package/typings/classes/SpringBoneCollisionPlane3D.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** An infinite plane collision that interacts with {@link SpringBoneSimulator3D}. */
+declare class SpringBoneCollisionPlane3D extends SpringBoneCollision3D {
+}

package/typings/classes/SpringBoneCollisionSphere3D.d.ts

@@ -0,0 +1,14 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A sphere shape collision that interacts with {@link SpringBoneSimulator3D}. */
+declare class SpringBoneCollisionSphere3D extends SpringBoneCollision3D {
+  /** If `true`, the collision acts to trap the joint within the collision. */
+  inside: boolean;
+  /** The sphere's radius. */
+  radius: float;
+  set_inside(value: boolean): void;
+  is_inside(): boolean;
+  set_radius(value: float): void;
+  get_radius(): float;
+}