typescript-to-gdscript 0.1.0

package/typings/classes/PlaceholderTexture2D.d.ts

@@ -0,0 +1,11 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Placeholder class for a 2-dimensional texture. */
+declare class PlaceholderTexture2D extends Texture2D {
+  /**
+   * <member name="size" type="Vector2" setter="set_size" getter="get_size" default="Vector2(1, 1)">
+   * The texture's size (in pixels).
+   */
+  resource_local_to_scene: boolean;
+}

package/typings/classes/PlaceholderTexture2DArray.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Placeholder class for a 2-dimensional texture array. */
+declare class PlaceholderTexture2DArray extends PlaceholderTextureLayered {
+}

package/typings/classes/PlaceholderTexture3D.d.ts

@@ -0,0 +1,10 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Placeholder class for a 3-dimensional texture. */
+declare class PlaceholderTexture3D extends Texture3D {
+  /** The texture's size (in pixels). */
+  size: Vector3i;
+  set_size(value: Vector3i | Vector3): void;
+  get_size(): Vector3i;
+}

package/typings/classes/PlaceholderTextureLayered.d.ts

@@ -0,0 +1,13 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Placeholder class for a 2-dimensional texture array. */
+declare class PlaceholderTextureLayered extends TextureLayered {
+  /** The number of layers in the texture array. */
+  layers: int;
+  /** The size of each texture layer (in pixels). */
+  size: Vector2i;
+  set_layers(value: int): void;
+  set_size(value: Vector2i | Vector2): void;
+  get_size(): Vector2i;
+}

package/typings/classes/Plane.d.ts

@@ -0,0 +1,143 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A plane in Hessian normal form. */
+declare interface Plane {
+  /**
+   * The distance from the origin to the plane, expressed in terms of {@link normal} (according to its direction and magnitude). Actual absolute distance from the origin to the plane can be calculated as `abs(d) / normal.length()` (if {@link normal} has zero length then this {@link Plane} does not represent a valid plane).
+   * In the scalar equation of the plane `ax + by + cz = d`, this is [code skip-lint]d[/code], while the `(a, b, c)` coordinates are represented by the {@link normal} property.
+   */
+  d: float;
+  /**
+   * The normal of the plane, typically a unit vector. Shouldn't be a zero vector as {@link Plane} with such {@link normal} does not represent a valid plane.
+   * In the scalar equation of the plane `ax + by + cz = d`, this is the vector `(a, b, c)`, where [code skip-lint]d[/code] is the {@link d} property.
+   */
+  normal: Vector3;
+  /** The X component of the plane's {@link normal} vector. */
+  x: float;
+  /** The Y component of the plane's {@link normal} vector. */
+  y: float;
+  /** The Z component of the plane's {@link normal} vector. */
+  z: float;
+
+  /**
+   * Returns the shortest distance from the plane to the position `point`. If the point is above the plane, the distance will be positive. If below, the distance will be negative.
+   */
+  distance_to(point: Vector3 | Vector3i): float;
+  /** Returns the center of the plane. */
+  get_center(): Vector3;
+  /**
+   * Returns `true` if `point` is inside the plane. Comparison uses a custom minimum `tolerance` threshold.
+   */
+  has_point(point: Vector3 | Vector3i, tolerance?: float): boolean;
+  /**
+   * Returns the intersection point of the three planes `b`, `c` and this plane. If no intersection is found, `null` is returned.
+   */
+  intersect_3(b: Plane, c: Plane): unknown;
+  /**
+   * Returns the intersection point of a ray consisting of the position `from` and the direction normal `dir` with this plane. If no intersection is found, `null` is returned.
+   */
+  intersects_ray(from_: Vector3 | Vector3i, dir: Vector3 | Vector3i): unknown;
+  /**
+   * Returns the intersection point of a segment from position `from` to position `to` with this plane. If no intersection is found, `null` is returned.
+   */
+  intersects_segment(from_: Vector3 | Vector3i, to: Vector3 | Vector3i): unknown;
+  /**
+   * Returns `true` if this plane and `to_plane` are approximately equal, by running {@link @GlobalScope.is_equal_approx} on each component.
+   */
+  is_equal_approx(to_plane: Plane): boolean;
+  /**
+   * Returns `true` if this plane is finite, by calling {@link @GlobalScope.is_finite} on each component.
+   */
+  is_finite(): boolean;
+  /** Returns `true` if `point` is located above the plane. */
+  is_point_over(point: Vector3 | Vector3i): boolean;
+  /**
+   * Returns a copy of the plane, with normalized {@link normal} (so it's a unit vector). Returns `Plane(0, 0, 0, 0)` if {@link normal} can't be normalized (it has zero length).
+   */
+  normalized(): Plane;
+  /** Returns the orthogonal projection of `point` into a point in the plane. */
+  project(point: Vector3 | Vector3i): Vector3;
+
+  // Operator overloads
+  [__ops_ne]: { right: Plane; ret: boolean };
+  [__ops_mul]: { right: Transform3D; ret: Plane };
+  [__ops_eq]: { right: Plane; ret: boolean };
+  [__ops_plus]: { ret: Plane };
+  [__ops_minus]: { ret: Plane };
+
+  [__variant_converts]: Plane;
+
+  // Dictionary method overrides (prevent Object interface leaking)
+  assign: never;
+  clear: never;
+  duplicate: never;
+  duplicate_deep: never;
+  erase: never;
+  find_key: never;
+  get: never;
+  get_or_add: never;
+  get_typed_key_builtin: never;
+  get_typed_key_class_name: never;
+  get_typed_key_script: never;
+  get_typed_value_builtin: never;
+  get_typed_value_class_name: never;
+  get_typed_value_script: never;
+  has: never;
+  has_all: never;
+  hash: never;
+  is_empty: never;
+  is_read_only: never;
+  is_same_typed: never;
+  is_same_typed_key: never;
+  is_same_typed_value: never;
+  is_typed: never;
+  is_typed_key: never;
+  is_typed_value: never;
+  keys: never;
+  make_read_only: never;
+  merge: never;
+  merged: never;
+  recursive_equal: never;
+  set: never;
+  size: never;
+  sort: never;
+  values: never;
+}
+
+declare interface PlaneConstructor {
+  readonly prototype: Plane;
+  /** Constructs a default-initialized {@link Plane} with all components set to `0`. */
+  (): Plane;
+  /** Constructs a {@link Plane} as a copy of the given {@link Plane}. */
+  (from_: Plane): Plane;
+  /**
+   * Creates a plane from the four parameters. The three components of the resulting plane's {@link normal} are `a`, `b` and `c`, and the plane has a distance of `d` from the origin.
+   */
+  (a: float, b: float, c: float, d: float): Plane;
+  /**
+   * Creates a plane from the normal vector. The plane will intersect the origin.
+   * The `normal` of the plane must be a unit vector.
+   */
+  (normal: Vector3): Plane;
+  /**
+   * Creates a plane from the normal vector and the plane's distance from the origin.
+   * The `normal` of the plane must be a unit vector.
+   */
+  (normal: Vector3, d: float): Plane;
+  /**
+   * Creates a plane from the normal vector and a point on the plane.
+   * The `normal` of the plane must be a unit vector.
+   */
+  (normal: Vector3, point: Vector3): Plane;
+  /** Creates a plane from the three points, given in clockwise order. */
+  (point1: Vector3, point2: Vector3, point3: Vector3): Plane;
+
+  /** A plane that extends in the Y and Z axes (normal vector points +X). */
+  readonly PLANE_YZ: Plane;
+  /** A plane that extends in the X and Z axes (normal vector points +Y). */
+  readonly PLANE_XZ: Plane;
+  /** A plane that extends in the X and Y axes (normal vector points +Z). */
+  readonly PLANE_XY: Plane;
+}
+declare const Plane: PlaneConstructor;

package/typings/classes/PlaneMesh.d.ts

@@ -0,0 +1,38 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Class representing a planar {@link PrimitiveMesh}. */
+declare class PlaneMesh extends PrimitiveMesh {
+  /** Offset of the generated plane. Useful for particles. */
+  center_offset: Vector3;
+  /** Direction that the {@link PlaneMesh} is facing. */
+  orientation: int;
+  /** Size of the generated plane. */
+  size: Vector2;
+  /** Number of subdivision along the Z axis. */
+  subdivide_depth: int;
+  /** Number of subdivision along the X axis. */
+  subdivide_width: int;
+  set_center_offset(value: Vector3 | Vector3i): void;
+  get_center_offset(): Vector3;
+  set_orientation(value: int): void;
+  get_orientation(): int;
+  set_size(value: Vector2 | Vector2i): void;
+  get_size(): Vector2;
+  set_subdivide_depth(value: int): void;
+  get_subdivide_depth(): int;
+  set_subdivide_width(value: int): void;
+  get_subdivide_width(): int;
+
+  // enum Orientation
+  /** {@link PlaneMesh} will face the positive X-axis. */
+  static readonly FACE_X: int;
+  /**
+   * {@link PlaneMesh} will face the positive Y-axis. This matches the behavior of the {@link PlaneMesh} in Godot 3.x.
+   */
+  static readonly FACE_Y: int;
+  /**
+   * {@link PlaneMesh} will face the positive Z-axis. This matches the behavior of the QuadMesh in Godot 3.x.
+   */
+  static readonly FACE_Z: int;
+}

package/typings/classes/PointLight2D.d.ts

@@ -0,0 +1,22 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Positional 2D light source. */
+declare class PointLight2D extends Light2D {
+  /**
+   * The height of the light. Used with 2D normal mapping. The units are in pixels, e.g. if the height is 100, then it will illuminate an object 100 pixels away at a 45° angle to the plane.
+   */
+  height: float;
+  /** The offset of the light's {@link texture}. */
+  offset: Vector2;
+  /** {@link Texture2D} used for the light's appearance. */
+  texture: Texture2D | null;
+  /** The {@link texture}'s scale factor. */
+  texture_scale: float;
+  set_texture_offset(value: Vector2 | Vector2i): void;
+  get_texture_offset(): Vector2;
+  set_texture(value: Texture2D | null): void;
+  get_texture(): Texture2D | null;
+  set_texture_scale(value: float): void;
+  get_texture_scale(): float;
+}

package/typings/classes/PointMesh.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Mesh with a single point primitive. */
+declare class PointMesh extends PrimitiveMesh {
+}

package/typings/classes/Polygon2D.d.ts

@@ -0,0 +1,101 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A 2D polygon. */
+declare class Polygon2D extends Node2D {
+  /** If `true`, polygon edges will be anti-aliased. */
+  antialiased: boolean;
+  /**
+   * The polygon's fill color. If {@link texture} is set, it will be multiplied by this color. It will also be the default color for vertices not set in {@link vertex_colors}.
+   */
+  color: Color;
+  /** Number of internal vertices, used for UV mapping. */
+  internal_vertex_count: int;
+  /**
+   * Added padding applied to the bounding box when {@link invert_enabled} is set to `true`. Setting this value too small may result in a "Bad Polygon" error.
+   */
+  invert_border: float;
+  /**
+   * If `true`, the polygon will be inverted, containing the area outside the defined points and extending to the {@link invert_border}.
+   */
+  invert_enabled: boolean;
+  /** The offset applied to each vertex. */
+  offset: Vector2;
+  /** The polygon's list of vertices. The final point will be connected to the first. */
+  polygon: PackedVector2Array;
+  /**
+   * The list of polygons, in case more than one is being represented. Every individual polygon is stored as a {@link PackedInt32Array} where each [int] is an index to a point in {@link polygon}. If empty, this property will be ignored, and the resulting single polygon will be composed of all points in {@link polygon}, using the order they are stored in.
+   */
+  polygons: Array<unknown>;
+  /**
+   * Path to a {@link Skeleton2D} node used for skeleton-based deformations of this polygon. If empty or invalid, skeletal deformations will not be used.
+   */
+  skeleton: NodePath;
+  /** The polygon's fill texture. Use {@link uv} to set texture coordinates. */
+  texture: Texture2D | null;
+  /**
+   * Amount to offset the polygon's {@link texture}. If set to `Vector2(0, 0)`, the texture's origin (its top-left corner) will be placed at the polygon's position.
+   */
+  texture_offset: Vector2;
+  /** The texture's rotation in radians. */
+  texture_rotation: float;
+  /**
+   * Amount to multiply the {@link uv} coordinates when using {@link texture}. Larger values make the texture smaller, and vice versa.
+   */
+  texture_scale: Vector2;
+  /**
+   * Texture coordinates for each vertex of the polygon. There should be one UV value per polygon vertex. If there are fewer, undefined vertices will use `Vector2(0, 0)`.
+   */
+  uv: PackedVector2Array;
+  /**
+   * Color for each vertex. Colors are interpolated between vertices, resulting in smooth gradients. There should be one per polygon vertex. If there are fewer, undefined vertices will use {@link color}.
+   */
+  vertex_colors: PackedColorArray;
+  set_antialiased(value: boolean): void;
+  get_antialiased(): boolean;
+  set_color(value: Color): void;
+  get_color(): Color;
+  set_internal_vertex_count(value: int): void;
+  get_internal_vertex_count(): int;
+  set_invert_border(value: float): void;
+  get_invert_border(): float;
+  set_invert_enabled(value: boolean): void;
+  get_invert_enabled(): boolean;
+  set_offset(value: Vector2 | Vector2i): void;
+  get_offset(): Vector2;
+  set_polygon(value: PackedVector2Array | Array<unknown>): void;
+  get_polygon(): PackedVector2Array;
+  set_polygons(value: Array<unknown> | PackedByteArray | PackedColorArray | PackedFloat32Array | PackedFloat64Array | PackedInt32Array | PackedInt64Array | PackedStringArray | PackedVector2Array | PackedVector3Array | PackedVector4Array): void;
+  get_polygons(): Array<unknown>;
+  set_skeleton(value: NodePath | string): void;
+  get_skeleton(): NodePath;
+  set_texture(value: Texture2D | null): void;
+  get_texture(): Texture2D | null;
+  set_texture_offset(value: Vector2 | Vector2i): void;
+  get_texture_offset(): Vector2;
+  set_texture_rotation(value: float): void;
+  get_texture_rotation(): float;
+  set_texture_scale(value: Vector2 | Vector2i): void;
+  get_texture_scale(): Vector2;
+  set_uv(value: PackedVector2Array | Array<unknown>): void;
+  get_uv(): PackedVector2Array;
+  set_vertex_colors(value: PackedColorArray | Array<unknown>): void;
+  get_vertex_colors(): PackedColorArray;
+
+  /** Adds a bone with the specified `path` and `weights`. */
+  add_bone(path: NodePath | string, weights: PackedFloat32Array | Array<unknown>): void;
+  /** Removes all bones from this {@link Polygon2D}. */
+  clear_bones(): void;
+  /** Removes the specified bone from this {@link Polygon2D}. */
+  erase_bone(index: int): void;
+  /** Returns the number of bones in this {@link Polygon2D}. */
+  get_bone_count(): int;
+  /** Returns the path to the node associated with the specified bone. */
+  get_bone_path(index: int): NodePath;
+  /** Returns the weight values of the specified bone. */
+  get_bone_weights(index: int): PackedFloat32Array;
+  /** Sets the path to the node associated with the specified bone. */
+  set_bone_path(index: int, path: NodePath | string): void;
+  /** Sets the weight values for the specified bone. */
+  set_bone_weights(index: int, weights: PackedFloat32Array | Array<unknown>): void;
+}

package/typings/classes/PolygonOccluder3D.d.ts

@@ -0,0 +1,13 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Flat 2D polygon shape for use with occlusion culling in {@link OccluderInstance3D}. */
+declare class PolygonOccluder3D extends Occluder3D {
+  /**
+   * The polygon to use for occlusion culling. The polygon can be convex or concave, but it should have as few points as possible to maximize performance.
+   * The polygon must *not* have intersecting lines. Otherwise, triangulation will fail (with an error message printed).
+   */
+  polygon: PackedVector2Array;
+  set_polygon(value: PackedVector2Array | Array<unknown>): void;
+  get_polygon(): PackedVector2Array;
+}

package/typings/classes/PolygonPathFinder.d.ts

@@ -0,0 +1,18 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+declare class PolygonPathFinder extends Resource {
+  find_path(from_: Vector2 | Vector2i, to: Vector2 | Vector2i): PackedVector2Array;
+  get_bounds(): Rect2;
+  get_closest_point(point: Vector2 | Vector2i): Vector2;
+  get_intersections(from_: Vector2 | Vector2i, to: Vector2 | Vector2i): PackedVector2Array;
+  get_point_penalty(idx: int): float;
+  /** Returns `true` if `point` falls inside the polygon area. */
+  is_point_inside(point: Vector2 | Vector2i): boolean;
+  set_point_penalty(idx: int, penalty: float): void;
+  /**
+   * Sets up {@link PolygonPathFinder} with an array of points that define the vertices of the polygon, and an array of indices that determine the edges of the polygon.
+   * The length of `connections` must be even, returns an error if odd.
+   */
+  setup(points: PackedVector2Array | Array<unknown>, connections: PackedInt32Array | Array<unknown>): void;
+}

package/typings/classes/Popup.d.ts

@@ -0,0 +1,18 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Base class for contextual windows and panels with fixed position. */
+declare class Popup extends Window {
+  borderless: boolean;
+  maximize_disabled: boolean;
+  minimize_disabled: boolean;
+  popup_window: boolean;
+  popup_wm_hint: boolean;
+  transient: boolean;
+  unresizable: boolean;
+  visible: boolean;
+  wrap_controls: boolean;
+
+  /** Emitted when the popup is hidden. */
+  popup_hide: Signal<[]>;
+}