typescript-to-gdscript 0.1.0

package/typings/classes/Projection.d.ts

@@ -0,0 +1,193 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A 4×4 matrix for 3D projective transformations. */
+declare interface Projection {
+  /** The projection matrix's W vector (column 3). Equivalent to array index `3`. */
+  w: Vector4;
+  /** The projection matrix's X vector (column 0). Equivalent to array index `0`. */
+  x: Vector4;
+  /** The projection matrix's Y vector (column 1). Equivalent to array index `1`. */
+  y: Vector4;
+  /** The projection matrix's Z vector (column 2). Equivalent to array index `2`. */
+  z: Vector4;
+
+  /**
+   * Returns a scalar value that is the signed factor by which areas are scaled by this matrix. If the sign is negative, the matrix flips the orientation of the area.
+   * The determinant can be used to calculate the invertibility of a matrix or solve linear systems of equations involving the matrix, among other applications.
+   */
+  determinant(): float;
+  /** Returns a copy of this {@link Projection} with the signs of the values of the Y column flipped. */
+  flipped_y(): Projection;
+  /** Returns the X:Y aspect ratio of this {@link Projection}'s viewport. */
+  get_aspect(): float;
+  /** Returns the dimensions of the far clipping plane of the projection, divided by two. */
+  get_far_plane_half_extents(): Vector2;
+  /** Returns the horizontal field of view of the projection (in degrees). */
+  get_fov(): float;
+  /** Returns the factor by which the visible level of detail is scaled by this {@link Projection}. */
+  get_lod_multiplier(): float;
+  /**
+   * Returns `for_pixel_width` divided by the viewport's width measured in meters on the near plane, after this {@link Projection} is applied.
+   */
+  get_pixels_per_meter(for_pixel_width: int): int;
+  /**
+   * Returns the clipping plane of this {@link Projection} whose index is given by `plane`.
+   * `plane` should be equal to one of {@link PLANE_NEAR}, {@link PLANE_FAR}, {@link PLANE_LEFT}, {@link PLANE_TOP}, {@link PLANE_RIGHT}, or {@link PLANE_BOTTOM}.
+   */
+  get_projection_plane(plane: int): Plane;
+  /**
+   * Returns the dimensions of the viewport plane that this {@link Projection} projects positions onto, divided by two.
+   */
+  get_viewport_half_extents(): Vector2;
+  /** Returns the distance for this {@link Projection} beyond which positions are clipped. */
+  get_z_far(): float;
+  /** Returns the distance for this {@link Projection} before which positions are clipped. */
+  get_z_near(): float;
+  /**
+   * Returns a {@link Projection} that performs the inverse of this {@link Projection}'s projective transformation.
+   */
+  inverse(): Projection;
+  /** Returns `true` if this {@link Projection} performs an orthogonal projection. */
+  is_orthogonal(): boolean;
+  /**
+   * Returns a {@link Projection} with the X and Y values from the given {@link Vector2} added to the first and second values of the final column respectively.
+   */
+  jitter_offseted(offset: Vector2 | Vector2i): Projection;
+  /**
+   * Returns a {@link Projection} with the near clipping distance adjusted to be `new_znear`.
+   * **Note:** The original {@link Projection} must be a perspective projection.
+   */
+  perspective_znear_adjusted(new_znear: float): Projection;
+
+  // Operator overloads
+  [__ops_ne]: { right: Projection; ret: boolean };
+  [__ops_mul]: { right: Projection; ret: Projection } | { right: Vector4; ret: Vector4 };
+  [__ops_eq]: { right: Projection; ret: boolean };
+
+  [__variant_converts]: Projection | Transform3D;
+
+  // 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 ProjectionConstructor {
+  readonly prototype: Projection;
+  /**
+   * Constructs a default-initialized {@link Projection} identical to {@link IDENTITY}.
+   * **Note:** In C#, this constructs a {@link Projection} identical to {@link ZERO}.
+   */
+  (): Projection;
+  /** Constructs a {@link Projection} as a copy of the given {@link Projection}. */
+  (from_: Projection): Projection;
+  /** Constructs a Projection as a copy of the given {@link Transform3D}. */
+  (from_: Transform3D): Projection;
+  /** Constructs a Projection from four {@link Vector4} values (matrix columns). */
+  (x_axis: Vector4, y_axis: Vector4, z_axis: Vector4, w_axis: Vector4): Projection;
+  /**
+   * Creates a new {@link Projection} that projects positions from a depth range of `-1` to `1` to one that ranges from `0` to `1`, and flips the projected positions vertically, according to `flip_y`.
+   */
+  create_depth_correction(flip_y: boolean): Projection;
+  /**
+   * Creates a new {@link Projection} that scales a given projection to fit around a given {@link AABB} in projection space.
+   */
+  create_fit_aabb(aabb: AABB): Projection;
+  /**
+   * Creates a new {@link Projection} for projecting positions onto a head-mounted display with the given X:Y aspect ratio, distance between eyes, display width, distance to lens, oversampling factor, and depth clipping planes.
+   * `eye` creates the projection for the left eye when set to 1, or the right eye when set to 2.
+   */
+  create_for_hmd(eye: int, aspect: float, intraocular_dist: float, display_width: float, display_to_lens: float, oversample: float, z_near: float, z_far: float): Projection;
+  /**
+   * Creates a new {@link Projection} that projects positions in a frustum with the given clipping planes.
+   */
+  create_frustum(left: float, right: float, bottom: float, top: float, z_near: float, z_far: float): Projection;
+  /**
+   * Creates a new {@link Projection} that projects positions in a frustum with the given size, X:Y aspect ratio, offset, and clipping planes.
+   * `flip_fov` determines whether the projection's field of view is flipped over its diagonal.
+   */
+  create_frustum_aspect(size: float, aspect: float, offset: Vector2 | Vector2i, z_near: float, z_far: float, flip_fov?: boolean): Projection;
+  /** Creates a new {@link Projection} that projects positions into the given {@link Rect2}. */
+  create_light_atlas_rect(rect: Rect2 | Rect2i): Projection;
+  /**
+   * Creates a new {@link Projection} that projects positions using an orthogonal projection with the given clipping planes.
+   */
+  create_orthogonal(left: float, right: float, bottom: float, top: float, z_near: float, z_far: float): Projection;
+  /**
+   * Creates a new {@link Projection} that projects positions using an orthogonal projection with the given size, X:Y aspect ratio, and clipping planes.
+   * `flip_fov` determines whether the projection's field of view is flipped over its diagonal.
+   */
+  create_orthogonal_aspect(size: float, aspect: float, z_near: float, z_far: float, flip_fov?: boolean): Projection;
+  /**
+   * Creates a new {@link Projection} that projects positions using a perspective projection with the given Y-axis field of view (in degrees), X:Y aspect ratio, and clipping planes.
+   * `flip_fov` determines whether the projection's field of view is flipped over its diagonal.
+   */
+  create_perspective(fovy: float, aspect: float, z_near: float, z_far: float, flip_fov?: boolean): Projection;
+  /**
+   * Creates a new {@link Projection} that projects positions using a perspective projection with the given Y-axis field of view (in degrees), X:Y aspect ratio, and clipping distances. The projection is adjusted for a head-mounted display with the given distance between eyes and distance to a point that can be focused on.
+   * `eye` creates the projection for the left eye when set to 1, or the right eye when set to 2.
+   * `flip_fov` determines whether the projection's field of view is flipped over its diagonal.
+   */
+  create_perspective_hmd(fovy: float, aspect: float, z_near: float, z_far: float, flip_fov: boolean, eye: int, intraocular_dist: float, convergence_dist: float): Projection;
+  /**
+   * Returns the vertical field of view of the projection (in degrees) associated with the given horizontal field of view (in degrees) and aspect ratio.
+   * **Note:** Unlike most methods of {@link Projection}, `aspect` is expected to be 1 divided by the X:Y aspect ratio.
+   */
+  get_fovy(fovx: float, aspect: float): float;
+
+  // enum Planes
+  /** The index value of the projection's near clipping plane. */
+  readonly PLANE_NEAR: int;
+  /** The index value of the projection's far clipping plane. */
+  readonly PLANE_FAR: int;
+  /** The index value of the projection's left clipping plane. */
+  readonly PLANE_LEFT: int;
+  /** The index value of the projection's top clipping plane. */
+  readonly PLANE_TOP: int;
+  /** The index value of the projection's right clipping plane. */
+  readonly PLANE_RIGHT: int;
+  /** The index value of the projection bottom clipping plane. */
+  readonly PLANE_BOTTOM: int;
+
+  /**
+   * A {@link Projection} with no transformation defined. When applied to other data structures, no transformation is performed.
+   */
+  readonly IDENTITY: Projection;
+  /**
+   * A {@link Projection} with all values initialized to 0. When applied to other data structures, they will be zeroed.
+   */
+  readonly ZERO: Projection;
+}
+declare const Projection: ProjectionConstructor;

package/typings/classes/PropertyTweener.d.ts

@@ -0,0 +1,38 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Interpolates an {@link Object}'s property over time. */
+declare class PropertyTweener extends Tweener {
+  /**
+   * When called, the final value will be used as a relative value instead.
+   * **Example:** Move the node by `100` pixels to the right.
+   */
+  as_relative(): PropertyTweener;
+  /**
+   * Sets a custom initial value to the {@link PropertyTweener}.
+   * **Example:** Move the node from position `(100, 100)` to `(200, 100)`.
+   */
+  from(value: unknown): PropertyTweener;
+  /**
+   * Makes the {@link PropertyTweener} use the current property value (i.e. at the time of creating this {@link PropertyTweener}) as a starting point. This is equivalent of using {@link from} with the current value. These two calls will do the same:
+   */
+  from_current(): PropertyTweener;
+  /**
+   * Allows interpolating the value with a custom easing function. The provided `interpolator_method` will be called with a value ranging from `0.0` to `1.0` and is expected to return a value within the same range (values outside the range can be used for overshoot). The return value of the method is then used for interpolation between initial and final value. Note that the parameter passed to the method is still subject to the tweener's own easing.
+   */
+  set_custom_interpolator(
+  interpolator_method: (value: float) => float,
+  ): PropertyTweener;
+  /**
+   * Sets the time in seconds after which the {@link PropertyTweener} will start interpolating. By default there's no delay.
+   */
+  set_delay(delay: float): PropertyTweener;
+  /**
+   * Sets the type of used easing from {@link Tween.EaseType}. If not set, the default easing is used from the {@link Tween} that contains this Tweener.
+   */
+  set_ease(ease: int): PropertyTweener;
+  /**
+   * Sets the type of used transition from {@link Tween.TransitionType}. If not set, the default transition is used from the {@link Tween} that contains this Tweener.
+   */
+  set_trans(trans: int): PropertyTweener;
+}

package/typings/classes/QuadMesh.d.ts

@@ -0,0 +1,8 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Class representing a square mesh facing the camera. */
+declare class QuadMesh extends PlaneMesh {
+  orientation: int;
+  size: Vector2;
+}

package/typings/classes/QuadOccluder3D.d.ts

@@ -0,0 +1,10 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Flat plane shape for use with occlusion culling in {@link OccluderInstance3D}. */
+declare class QuadOccluder3D extends Occluder3D {
+  /** The quad's size in 3D units. */
+  size: Vector2;
+  set_size(value: Vector2 | Vector2i): void;
+  get_size(): Vector2;
+}

package/typings/classes/Quaternion.d.ts

@@ -0,0 +1,188 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A unit quaternion used for representing 3D rotations. */
+declare interface Quaternion {
+  /**
+   * W component of the quaternion. This is the "real" part.
+   * **Note:** Quaternion components should usually not be manipulated directly.
+   */
+  w: float;
+  /**
+   * X component of the quaternion. This is the value along the "imaginary" `i` axis.
+   * **Note:** Quaternion components should usually not be manipulated directly.
+   */
+  x: float;
+  /**
+   * Y component of the quaternion. This is the value along the "imaginary" `j` axis.
+   * **Note:** Quaternion components should usually not be manipulated directly.
+   */
+  y: float;
+  /**
+   * Z component of the quaternion. This is the value along the "imaginary" `k` axis.
+   * **Note:** Quaternion components should usually not be manipulated directly.
+   */
+  z: float;
+
+  /**
+   * Returns the angle between this quaternion and `to`. This is the magnitude of the angle you would need to rotate by to get from one to the other.
+   * **Note:** The magnitude of the floating-point error for this method is abnormally high, so methods such as `is_zero_approx` will not work reliably.
+   */
+  angle_to(to: Quaternion | Basis): float;
+  /**
+   * Returns the dot product between this quaternion and `with`.
+   * This is equivalent to `(quat.x * with.x) + (quat.y * with.y) + (quat.z * with.z) + (quat.w * with.w)`.
+   */
+  dot(with_: Quaternion | Basis): float;
+  /**
+   * Returns the exponential of this quaternion. The rotation axis of the result is the normalized rotation axis of this quaternion, the angle of the result is the length of the vector part of this quaternion.
+   */
+  exp(): Quaternion;
+  /**
+   * Returns the angle of the rotation represented by this quaternion.
+   * **Note:** The quaternion must be normalized.
+   */
+  get_angle(): float;
+  /** Returns the rotation axis of the rotation represented by this quaternion. */
+  get_axis(): Vector3;
+  /**
+   * Returns this quaternion's rotation as a {@link Vector3} of Euler angles (https://en.wikipedia.org/wiki/Euler_angles), in radians.
+   * The order of each consecutive rotation can be changed with `order` (see {@link EulerOrder} constants). By default, the YXZ convention is used ({@link EULER_ORDER_YXZ}): Z (roll) is calculated first, then X (pitch), and lastly Y (yaw). When using the opposite method {@link from_euler}, this order is reversed.
+   */
+  get_euler(order?: int): Vector3;
+  /**
+   * Returns the inverse version of this quaternion, inverting the sign of every component except {@link w}.
+   */
+  inverse(): Quaternion;
+  /**
+   * Returns `true` if this quaternion and `to` are approximately equal, by calling {@link @GlobalScope.is_equal_approx} on each component.
+   */
+  is_equal_approx(to: Quaternion | Basis): boolean;
+  /**
+   * Returns `true` if this quaternion is finite, by calling {@link @GlobalScope.is_finite} on each component.
+   */
+  is_finite(): boolean;
+  /** Returns `true` if this quaternion is normalized. See also {@link normalized}. */
+  is_normalized(): boolean;
+  /** Returns this quaternion's length, also called magnitude. */
+  length(): float;
+  /**
+   * Returns this quaternion's length, squared.
+   * **Note:** This method is faster than {@link length}, so prefer it if you only need to compare quaternion lengths.
+   */
+  length_squared(): float;
+  /**
+   * Returns the logarithm of this quaternion. Multiplies this quaternion's rotation axis by its rotation angle, and stores the result in the returned quaternion's vector part ({@link x}, {@link y}, and {@link z}). The returned quaternion's real part ({@link w}) is always `0.0`.
+   */
+  log(): Quaternion;
+  /**
+   * Returns a copy of this quaternion, normalized so that its length is `1.0`. See also {@link is_normalized}.
+   */
+  normalized(): Quaternion;
+  /**
+   * Performs a spherical-linear interpolation with the `to` quaternion, given a `weight` and returns the result. Both this quaternion and `to` must be normalized.
+   */
+  slerp(to: Quaternion | Basis, weight: float): Quaternion;
+  /**
+   * Performs a spherical-linear interpolation with the `to` quaternion, given a `weight` and returns the result. Unlike {@link slerp}, this method does not check if the rotation path is smaller than 90 degrees. Both this quaternion and `to` must be normalized.
+   */
+  slerpni(to: Quaternion | Basis, weight: float): Quaternion;
+  /**
+   * Performs a spherical cubic interpolation between quaternions `pre_a`, this vector, `b`, and `post_b`, by the given amount `weight`.
+   */
+  spherical_cubic_interpolate(b: Quaternion | Basis, pre_a: Quaternion | Basis, post_b: Quaternion | Basis, weight: float): Quaternion;
+  /**
+   * Performs a spherical cubic interpolation between quaternions `pre_a`, this vector, `b`, and `post_b`, by the given amount `weight`.
+   * It can perform smoother interpolation than {@link spherical_cubic_interpolate} by the time values.
+   */
+  spherical_cubic_interpolate_in_time(b: Quaternion | Basis, pre_a: Quaternion | Basis, post_b: Quaternion | Basis, weight: float, b_t: float, pre_a_t: float, post_b_t: float): Quaternion;
+
+  // Operator overloads
+  [__ops_ne]: { right: Quaternion; ret: boolean };
+  [__ops_mul]: { right: Quaternion; ret: Quaternion } | { right: Vector3; ret: Vector3 } | { right: float; ret: Quaternion } | { right: int; ret: Quaternion };
+  [__ops_add]: { right: Quaternion; ret: Quaternion };
+  [__ops_sub]: { right: Quaternion; ret: Quaternion };
+  [__ops_div]: { right: float; ret: Quaternion } | { right: int; ret: Quaternion };
+  [__ops_eq]: { right: Quaternion; ret: boolean };
+  [__ops_plus]: { ret: Quaternion };
+  [__ops_minus]: { ret: Quaternion };
+
+  [__variant_converts]: Quaternion | Basis;
+
+  // 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 QuaternionConstructor {
+  readonly prototype: Quaternion;
+  /**
+   * Constructs a {@link Quaternion} identical to {@link IDENTITY}.
+   * **Note:** In C#, this constructs a {@link Quaternion} with all of its components set to `0.0`.
+   */
+  (): Quaternion;
+  /** Constructs a {@link Quaternion} as a copy of the given {@link Quaternion}. */
+  (from_: Quaternion): Quaternion;
+  /**
+   * Constructs a {@link Quaternion} representing the shortest arc between `arc_from` and `arc_to`. These can be imagined as two points intersecting a sphere's surface, with a radius of `1.0`.
+   */
+  (arc_from: Vector3, arc_to: Vector3): Quaternion;
+  /**
+   * Constructs a {@link Quaternion} representing rotation around the `axis` by the given `angle`, in radians. The axis must be a normalized vector.
+   */
+  (axis: Vector3, angle: float): Quaternion;
+  /**
+   * Constructs a {@link Quaternion} from the given rotation {@link Basis}.
+   * This constructor is faster than {@link Basis.get_rotation_quaternion}, but the given basis must be *orthonormalized* (see {@link Basis.orthonormalized}). Otherwise, the constructor fails and returns {@link IDENTITY}.
+   */
+  (from_: Basis): Quaternion;
+  /**
+   * Constructs a {@link Quaternion} defined by the given values.
+   * **Note:** Only normalized quaternions represent rotation; if these values are not normalized, the new {@link Quaternion} will not be a valid rotation.
+   */
+  (x: float, y: float, z: float, w: float): Quaternion;
+  /**
+   * Constructs a new {@link Quaternion} from the given {@link Vector3} of Euler angles (https://en.wikipedia.org/wiki/Euler_angles), in radians. This method always uses the YXZ convention ({@link EULER_ORDER_YXZ}).
+   */
+  from_euler(euler: Vector3 | Vector3i): Quaternion;
+
+  /**
+   * The identity quaternion, representing no rotation. This has the same rotation as {@link Basis.IDENTITY}.
+   * If a {@link Vector3} is rotated (multiplied) by this quaternion, it does not change.
+   * **Note:** In GDScript, this constant is equivalent to creating a [constructor Quaternion] without any arguments. It can be used to make your code clearer, and for consistency with C#.
+   */
+  readonly IDENTITY: Quaternion;
+}
+declare const Quaternion: QuaternionConstructor;

package/typings/classes/RDAttachmentFormat.d.ts

@@ -0,0 +1,18 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Attachment format (used by {@link RenderingDevice}). */
+declare class RDAttachmentFormat extends RefCounted {
+  /** The attachment's data format. */
+  format: int;
+  /** The number of samples used when sampling the attachment. */
+  samples: int;
+  /** The attachment's usage flags, which determine what can be done with it. */
+  usage_flags: int;
+  set_format(value: int): void;
+  get_format(): int;
+  set_samples(value: int): void;
+  get_samples(): int;
+  set_usage_flags(value: int): void;
+  get_usage_flags(): int;
+}

package/typings/classes/RDFramebufferPass.d.ts

@@ -0,0 +1,33 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Framebuffer pass attachment description (used by {@link RenderingDevice}). */
+declare class RDFramebufferPass extends RefCounted {
+  /**
+   * Color attachments in order starting from 0. If this attachment is not used by the shader, pass ATTACHMENT_UNUSED to skip.
+   */
+  color_attachments: PackedInt32Array;
+  /** Depth attachment. ATTACHMENT_UNUSED should be used if no depth buffer is required for this pass. */
+  depth_attachment: int;
+  /**
+   * Used for multipass framebuffers (more than one render pass). Converts an attachment to an input. Make sure to also supply it properly in the {@link RDUniform} for the uniform set.
+   */
+  input_attachments: PackedInt32Array;
+  /** Attachments to preserve in this pass (otherwise they are erased). */
+  preserve_attachments: PackedInt32Array;
+  /** If the color attachments are multisampled, non-multisampled resolve attachments can be provided. */
+  resolve_attachments: PackedInt32Array;
+  set_color_attachments(value: PackedInt32Array | Array<unknown>): void;
+  get_color_attachments(): PackedInt32Array;
+  set_depth_attachment(value: int): void;
+  get_depth_attachment(): int;
+  set_input_attachments(value: PackedInt32Array | Array<unknown>): void;
+  get_input_attachments(): PackedInt32Array;
+  set_preserve_attachments(value: PackedInt32Array | Array<unknown>): void;
+  get_preserve_attachments(): PackedInt32Array;
+  set_resolve_attachments(value: PackedInt32Array | Array<unknown>): void;
+  get_resolve_attachments(): PackedInt32Array;
+
+  /** Attachment is unused. */
+  static readonly ATTACHMENT_UNUSED: int;
+}

package/typings/classes/RDPipelineColorBlendState.d.ts

@@ -0,0 +1,22 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Pipeline color blend state (used by {@link RenderingDevice}). */
+declare class RDPipelineColorBlendState extends RefCounted {
+  /** The attachments that are blended together. */
+  attachments: Array<RDPipelineColorBlendStateAttachment>;
+  /** The constant color to blend with. See also {@link RenderingDevice.draw_list_set_blend_constants}. */
+  blend_constant: Color;
+  /** If `true`, performs the logic operation defined in {@link logic_op}. */
+  enable_logic_op: boolean;
+  /** The logic operation to perform for blending. Only effective if {@link enable_logic_op} is `true`. */
+  logic_op: int;
+  set_attachments(value: Array<RDPipelineColorBlendStateAttachment>): void;
+  get_attachments(): Array<RDPipelineColorBlendStateAttachment>;
+  set_blend_constant(value: Color): void;
+  get_blend_constant(): Color;
+  set_enable_logic_op(value: boolean): void;
+  get_enable_logic_op(): boolean;
+  set_logic_op(value: int): void;
+  get_logic_op(): int;
+}

package/typings/classes/RDPipelineColorBlendStateAttachment.d.ts

@@ -0,0 +1,61 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Pipeline color blend state attachment (used by {@link RenderingDevice}). */
+declare class RDPipelineColorBlendStateAttachment extends RefCounted {
+  /** The blend mode to use for the alpha channel. */
+  alpha_blend_op: int;
+  /** The blend mode to use for the red/green/blue color channels. */
+  color_blend_op: int;
+  /**
+   * Controls how the blend factor for the alpha channel is determined based on the destination's fragments.
+   */
+  dst_alpha_blend_factor: int;
+  /**
+   * Controls how the blend factor for the color channels is determined based on the destination's fragments.
+   */
+  dst_color_blend_factor: int;
+  /**
+   * If `true`, performs blending between the source and destination according to the factors defined in {@link src_color_blend_factor}, {@link dst_color_blend_factor}, {@link src_alpha_blend_factor} and {@link dst_alpha_blend_factor}. The blend modes {@link color_blend_op} and {@link alpha_blend_op} are also taken into account, with {@link write_r}, {@link write_g}, {@link write_b} and {@link write_a} controlling the output.
+   */
+  enable_blend: boolean;
+  /** Controls how the blend factor for the alpha channel is determined based on the source's fragments. */
+  src_alpha_blend_factor: int;
+  /** Controls how the blend factor for the color channels is determined based on the source's fragments. */
+  src_color_blend_factor: int;
+  /** If `true`, writes the new alpha channel to the final result. */
+  write_a: boolean;
+  /** If `true`, writes the new blue color channel to the final result. */
+  write_b: boolean;
+  /** If `true`, writes the new green color channel to the final result. */
+  write_g: boolean;
+  /** If `true`, writes the new red color channel to the final result. */
+  write_r: boolean;
+  set_alpha_blend_op(value: int): void;
+  get_alpha_blend_op(): int;
+  set_color_blend_op(value: int): void;
+  get_color_blend_op(): int;
+  set_dst_alpha_blend_factor(value: int): void;
+  get_dst_alpha_blend_factor(): int;
+  set_dst_color_blend_factor(value: int): void;
+  get_dst_color_blend_factor(): int;
+  set_enable_blend(value: boolean): void;
+  get_enable_blend(): boolean;
+  set_src_alpha_blend_factor(value: int): void;
+  get_src_alpha_blend_factor(): int;
+  set_src_color_blend_factor(value: int): void;
+  get_src_color_blend_factor(): int;
+  set_write_a(value: boolean): void;
+  get_write_a(): boolean;
+  set_write_b(value: boolean): void;
+  get_write_b(): boolean;
+  set_write_g(value: boolean): void;
+  get_write_g(): boolean;
+  set_write_r(value: boolean): void;
+  get_write_r(): boolean;
+
+  /**
+   * Convenience method to perform standard mix blending with straight (non-premultiplied) alpha. This sets {@link enable_blend} to `true`, {@link src_color_blend_factor} to {@link RenderingDevice.BLEND_FACTOR_SRC_ALPHA}, {@link dst_color_blend_factor} to {@link RenderingDevice.BLEND_FACTOR_ONE_MINUS_SRC_ALPHA}, {@link src_alpha_blend_factor} to {@link RenderingDevice.BLEND_FACTOR_SRC_ALPHA} and {@link dst_alpha_blend_factor} to {@link RenderingDevice.BLEND_FACTOR_ONE_MINUS_SRC_ALPHA}.
+   */
+  set_as_mix(): void;
+}