@ringozz/godot 4.7.2-583 → 4.7.2-592

package/gen/value-types/Rect2.ts

@@ -1,9 +1,9 @@
 // Auto-generated from extension_api.json - DO NOT EDIT
 // Generated by dev/codegen.ts
 
-import { GodotVar, _C, _R, _get, _set } from '../../src/runtime.ts';
+import { _V } from '../../src/runtime.ts';
 import type { GodotArray, GodotDictionary, Variant } from '../heap-types/index.ts';
-import type { Rect2i, Transform2D, Vector2 } from '../value-types/index.ts';
+import type { Rect2i, Transform2D, Vector2 } from './index.ts';
 
 /**
  * The {@link Rect2} built-in {@link Variant} type represents an axis-aligned rectangle in a 2D space. It is defined by its {@link position} and {@link size}, which are {@link Vector2}. It is frequently used for fast overlap tests (see {@link intersects}). Although {@link Rect2} itself is axis-aligned, it can be combined with {@link Transform2D} to represent a rotated or skewed rectangle.
@@ -11,172 +11,170 @@ import type { Rect2i, Transform2D, Vector2 } from '../value-types/index.ts';
  * **Note:** Negative values for {@link size} are not supported. With negative size, most {@link Rect2} methods do not work correctly. Use {@link abs} to get an equivalent {@link Rect2} with a non-negative size.
  * **Note:** In a boolean context, a {@link Rect2} evaluates to `false` if both {@link position} and {@link size} are zero (equal to {@link Vector2.ZERO}). Otherwise, it always evaluates to `true`.
  */
-export class Rect2 extends GodotVar {
-    /**
-     * The origin point. This is usually the top-left corner of the rectangle.
-     */
-    get position(): Vector2 { return _get(this, 9504) as Vector2; }
-    set position(v: Vector2) { _set(this, 9504, v); }
-
-    /**
-     * The rectangle's width and height, starting from {@link position}. Setting this value also affects the {@link end} point.
-     * **Note:** It's recommended setting the width and height to non-negative values, as most methods in Godot assume that the {@link position} is the top-left corner, and the {@link end} is the bottom-right corner. To get an equivalent rectangle with non-negative size, use {@link abs}.
-     */
-    get size(): Vector2 { return _get(this, 13608) as Vector2; }
-    set size(v: Vector2) { _set(this, 13608, v); }
-
-    /**
-     * The ending point. This is usually the bottom-right corner of the rectangle, and is equivalent to `position + size`. Setting this point affects the {@link size}.
-     */
-    get end(): Vector2 { return _get(this, 3093) as Vector2; }
-    set end(v: Vector2) { _set(this, 3093, v); }
-
-    constructor();
-    constructor(from: Rect2);
-    constructor(from: Rect2i);
-    constructor(position: Vector2, size: Vector2);
-    constructor(x: number, y: number, width: number, height: number);
-    constructor(...args: any[]) { super(7, ...args); }
-
-    /**
-     * Returns the center point of the rectangle. This is the same as `position + (size / 2.0)`.
-     */
-    getCenter(): Vector2 { return _C(this, 4121) as Vector2; }
-
-    /**
-     * Returns the rectangle's area. This is equivalent to `size.x * size.y`. See also {@link hasArea}.
-     */
-    getArea(): number { return _C(this, 3789) as number; }
-
-    /**
-     * Returns `true` if this rectangle has positive width and height. See also {@link getArea}.
-     */
-    hasArea(): boolean { return _C(this, 7358) as boolean; }
-
-    /**
-     * Returns `true` if the rectangle contains the given `point`. By convention, points on the right and bottom edges are **not** included.
-     * **Note:** This method is not reliable for {@link Rect2} with a *negative* {@link size}. Use {@link abs} first to get a valid rectangle.
-     */
-    hasPoint(point: Vector2): boolean { return _C(this, 7430, point) as boolean; }
-
-    /**
-     * Returns `true` if this rectangle and `rect` are approximately equal, by calling {@link Vector2.isEqualApprox} on the {@link position} and the {@link size}.
-     */
-    isEqualApprox(rect: Rect2): boolean { return _C(this, 7938, rect) as boolean; }
-
-    /**
-     * Returns `true` if this rectangle's values are finite, by calling {@link Vector2.isFinite} on the {@link position} and the {@link size}.
-     */
-    isFinite(): boolean { return _C(this, 7951) as boolean; }
-
-    /**
-     * Returns `true` if this rectangle overlaps with the `b` rectangle. The edges of both rectangles are excluded, unless `includeBorders` is `true`.
-     */
-    intersects(b: Rect2, includeBorders?: boolean /* = false */): boolean { return _C(this, 7707, b, includeBorders) as boolean; }
-
-    /**
-     * Returns `true` if this rectangle *completely* encloses the `b` rectangle.
-     */
-    encloses(b: Rect2): boolean { return _C(this, 3077, b) as boolean; }
-
-    /**
-     * Returns the intersection between this rectangle and `b`. If the rectangles do not intersect, returns an empty {@link Rect2}.
-     *
-     *
-     * ```gdscript
-     *
-     * var rect1 = Rect2(0, 0, 5, 10)
-     * var rect2 = Rect2(2, 0, 8, 4)
-     *
-     * var a = rect1.intersection(rect2) # a is Rect2(2, 0, 3, 4)
-     *
-     * ```
-     *
-     *
-     *
-     * **Note:** If you only need to know whether two rectangles are overlapping, use {@link intersects}, instead.
-     */
-    intersection(b: Rect2): Rect2 { return _C(this, 7705, b) as Rect2; }
-
-    /**
-     * Returns a {@link Rect2} that encloses both this rectangle and `b` around the edges. See also {@link encloses}.
-     */
-    merge(b: Rect2): Rect2 { return _C(this, 8850, b) as Rect2; }
-
-    /**
-     * Returns a copy of this rectangle expanded to align the edges with the given `to` point, if necessary.
-     *
-     *
-     * ```gdscript
-     *
-     * var rect = Rect2(0, 0, 5, 2)
-     *
-     * rect = rect.expand(Vector2(10, 0)) # rect is Rect2(0, 0, 10, 2)
-     * rect = rect.expand(Vector2(-5, 5)) # rect is Rect2(-5, 0, 15, 5)
-     *
-     * ```
-     */
-    expand(to: Vector2): Rect2 { return _C(this, 3187, to) as Rect2; }
-
-    /**
-     * Returns the vertex's position of this rect that's the farthest in the given direction. This point is commonly known as the support point in collision detection algorithms.
-     */
-    getSupport(direction: Vector2): Vector2 { return _C(this, 6612, direction) as Vector2; }
-
-    /**
-     * Returns a copy of this rectangle extended on all sides by the given `amount`. A negative `amount` shrinks the rectangle instead. See also {@link growIndividual} and {@link growSide}.
-     *
-     *
-     * ```gdscript
-     *
-     * var a = Rect2(4, 4, 8, 8).grow(4) # a is Rect2(0, 0, 16, 16)
-     * var b = Rect2(0, 0, 8, 4).grow(2) # b is Rect2(-2, -2, 12, 8)
-     *
-     * ```
-     */
-    grow(amount: number): Rect2 { return _C(this, 7304, amount) as Rect2; }
-
-    /**
-     * Returns a copy of this rectangle with its `side` extended by the given `amount` (see {@link Side} constants). A negative `amount` shrinks the rectangle, instead. See also {@link grow} and {@link growIndividual}.
-     */
-    growSide(side: number, amount: number): Rect2 { return _C(this, 7311, side, amount) as Rect2; }
-
-    /**
-     * Returns a copy of this rectangle with its `left`, `top`, `right`, and `bottom` sides extended by the given amounts. Negative values shrink the sides, instead. See also {@link grow} and {@link growSide}.
-     */
-    growIndividual(left: number, top: number, right: number, bottom: number): Rect2 { return _C(this, 7309, left, top, right, bottom) as Rect2; }
-
-    /**
-     * Returns a {@link Rect2} equivalent to this rectangle, with its width and height modified to be non-negative values, and with its {@link position} being the top-left corner of the rectangle.
-     *
-     *
-     * ```gdscript
-     *
-     * var rect = Rect2(25, 25, -100, -50)
-     * var absolute = rect.abs() # absolute is Rect2(-75, -25, 100, 50)
-     *
-     * ```
-     *
-     *
-     *
-     * **Note:** It's recommended to use this method when {@link size} is negative, as most other methods in Godot assume that the {@link position} is the top-left corner, and the {@link end} is the bottom-right corner.
-     */
-    abs(): Rect2 { return _C(this, 1053) as Rect2; }
-
-    equals(other: Variant | Rect2): boolean { return _C(this, -1, other) as boolean; }
-
-    notEquals(other: Variant | Rect2): boolean { return _C(this, -2, other) as boolean; }
-
-    not(): boolean { return _C(this, -24, undefined) as boolean; }
-
-    /**
-     * Inversely transforms (multiplies) the {@link Rect2} by the given {@link Transform2D} transformation matrix, under the assumption that the transformation basis is orthonormal (i.e. rotation/reflection is fine, scaling/skew is not).
-     * `rect * transform` is equivalent to `transform.inverse() * rect`. See {@link Transform2D.inverse}.
-     * For transforming by inverse of an affine transformation (e.g. with scaling) `transform.affine_inverse() * rect` can be used instead. See {@link Transform2D.affineInverse}.
-     */
-    mul(other: Transform2D): Rect2 { return _C(this, -9, other) as Rect2; }
-
-    contains(other: GodotDictionary | GodotArray): boolean { return _C(this, -25, other) as boolean; }
-
-    static readonly name = _R(7, Rect2);
-}
+export type Rect2 = [x: number, y: number, w: number, h: number];
+
+/**
+ * Returns the center point of the rectangle. This is the same as `position + (size / 2.0)`.
+ */
+export function getCenter(self: Rect2): Vector2 { return _V(7, 4121, self) as Vector2; }
+
+/**
+ * Returns the rectangle's area. This is equivalent to `size.x * size.y`. See also {@link hasArea}.
+ */
+export function getArea(self: Rect2): number { return _V(7, 3789, self) as number; }
+
+/**
+ * Returns `true` if this rectangle has positive width and height. See also {@link getArea}.
+ */
+export function hasArea(self: Rect2): boolean { return _V(7, 7358, self) as boolean; }
+
+/**
+ * Returns `true` if the rectangle contains the given `point`. By convention, points on the right and bottom edges are **not** included.
+ * **Note:** This method is not reliable for {@link Rect2} with a *negative* {@link size}. Use {@link abs} first to get a valid rectangle.
+ */
+export function hasPoint(self: Rect2, point: Vector2): boolean { return _V(7, 7430, self, point) as boolean; }
+
+/**
+ * Returns `true` if this rectangle and `rect` are approximately equal, by calling {@link Vector2.isEqualApprox} on the {@link position} and the {@link size}.
+ */
+export function isEqualApprox(self: Rect2, rect: Rect2): boolean { return _V(7, 7938, self, rect) as boolean; }
+
+/**
+ * Returns `true` if this rectangle's values are finite, by calling {@link Vector2.isFinite} on the {@link position} and the {@link size}.
+ */
+export function isFinite(self: Rect2): boolean { return _V(7, 7951, self) as boolean; }
+
+/**
+ * Returns `true` if this rectangle overlaps with the `b` rectangle. The edges of both rectangles are excluded, unless `includeBorders` is `true`.
+ */
+export function intersects(self: Rect2, b: Rect2, includeBorders?: boolean /* = false */): boolean { return _V(7, 7707, self, b, includeBorders) as boolean; }
+
+/**
+ * Returns `true` if this rectangle *completely* encloses the `b` rectangle.
+ */
+export function encloses(self: Rect2, b: Rect2): boolean { return _V(7, 3077, self, b) as boolean; }
+
+/**
+ * Returns the intersection between this rectangle and `b`. If the rectangles do not intersect, returns an empty {@link Rect2}.
+ *
+ *
+ * ```gdscript
+ *
+ * var rect1 = Rect2(0, 0, 5, 10)
+ * var rect2 = Rect2(2, 0, 8, 4)
+ *
+ * var a = rect1.intersection(rect2) # a is Rect2(2, 0, 3, 4)
+ *
+ * ```
+ *
+ *
+ *
+ * **Note:** If you only need to know whether two rectangles are overlapping, use {@link intersects}, instead.
+ */
+export function intersection(self: Rect2, b: Rect2): Rect2 { return _V(7, 7705, self, b) as Rect2; }
+
+/**
+ * Returns a {@link Rect2} that encloses both this rectangle and `b` around the edges. See also {@link encloses}.
+ */
+export function merge(self: Rect2, b: Rect2): Rect2 { return _V(7, 8850, self, b) as Rect2; }
+
+/**
+ * Returns a copy of this rectangle expanded to align the edges with the given `to` point, if necessary.
+ *
+ *
+ * ```gdscript
+ *
+ * var rect = Rect2(0, 0, 5, 2)
+ *
+ * rect = rect.expand(Vector2(10, 0)) # rect is Rect2(0, 0, 10, 2)
+ * rect = rect.expand(Vector2(-5, 5)) # rect is Rect2(-5, 0, 15, 5)
+ *
+ * ```
+ */
+export function expand(self: Rect2, to: Vector2): Rect2 { return _V(7, 3187, self, to) as Rect2; }
+
+/**
+ * Returns the vertex's position of this rect that's the farthest in the given direction. This point is commonly known as the support point in collision detection algorithms.
+ */
+export function getSupport(self: Rect2, direction: Vector2): Vector2 { return _V(7, 6612, self, direction) as Vector2; }
+
+/**
+ * Returns a copy of this rectangle extended on all sides by the given `amount`. A negative `amount` shrinks the rectangle instead. See also {@link growIndividual} and {@link growSide}.
+ *
+ *
+ * ```gdscript
+ *
+ * var a = Rect2(4, 4, 8, 8).grow(4) # a is Rect2(0, 0, 16, 16)
+ * var b = Rect2(0, 0, 8, 4).grow(2) # b is Rect2(-2, -2, 12, 8)
+ *
+ * ```
+ */
+export function grow(self: Rect2, amount: number): Rect2 { return _V(7, 7304, self, amount) as Rect2; }
+
+/**
+ * Returns a copy of this rectangle with its `side` extended by the given `amount` (see {@link Side} constants). A negative `amount` shrinks the rectangle, instead. See also {@link grow} and {@link growIndividual}.
+ */
+export function growSide(self: Rect2, side: number, amount: number): Rect2 { return _V(7, 7311, self, side, amount) as Rect2; }
+
+/**
+ * Returns a copy of this rectangle with its `left`, `top`, `right`, and `bottom` sides extended by the given amounts. Negative values shrink the sides, instead. See also {@link grow} and {@link growSide}.
+ */
+export function growIndividual(self: Rect2, left: number, top: number, right: number, bottom: number): Rect2 { return _V(7, 7309, self, left, top, right, bottom) as Rect2; }
+
+/**
+ * Returns a {@link Rect2} equivalent to this rectangle, with its width and height modified to be non-negative values, and with its {@link position} being the top-left corner of the rectangle.
+ *
+ *
+ * ```gdscript
+ *
+ * var rect = Rect2(25, 25, -100, -50)
+ * var absolute = rect.abs() # absolute is Rect2(-75, -25, 100, 50)
+ *
+ * ```
+ *
+ *
+ *
+ * **Note:** It's recommended to use this method when {@link size} is negative, as most other methods in Godot assume that the {@link position} is the top-left corner, and the {@link end} is the bottom-right corner.
+ */
+export function abs(self: Rect2): Rect2 { return _V(7, 1053, self) as Rect2; }
+
+export function equals(a: Rect2, b: Variant | Rect2): boolean { return _V(7, -1, a, b) as boolean; }
+
+export function notEquals(a: Rect2, b: Variant | Rect2): boolean { return _V(7, -2, a, b) as boolean; }
+
+export function not(self: Rect2): boolean { return _V(7, -24, self, undefined) as boolean; }
+
+/**
+ * Inversely transforms (multiplies) the {@link Rect2} by the given {@link Transform2D} transformation matrix, under the assumption that the transformation basis is orthonormal (i.e. rotation/reflection is fine, scaling/skew is not).
+ * `rect * transform` is equivalent to `transform.inverse() * rect`. See {@link Transform2D.inverse}.
+ * For transforming by inverse of an affine transformation (e.g. with scaling) `transform.affine_inverse() * rect` can be used instead. See {@link Transform2D.affineInverse}.
+ */
+export function mul(a: Rect2, b: Transform2D): Rect2 { return _V(7, -9, a, b) as Rect2; }
+
+export function contains(a: Rect2, b: GodotDictionary | GodotArray): boolean { return _V(7, -25, a, b) as boolean; }
+
+/**
+ * Constructs a {@link Rect2} with its {@link position} and {@link size} set to {@link Vector2.ZERO}.
+ */
+export function create(): Rect2 { return _V(7, -4096, 0) as Rect2; }
+
+/**
+ * Constructs a {@link Rect2} as a copy of the given {@link Rect2}.
+ */
+export function fromRect2(from: Rect2): Rect2 { return _V(7, -4096, 1, from) as Rect2; }
+
+/**
+ * Constructs a {@link Rect2} from a {@link Rect2i}.
+ */
+export function fromRect2i(from: Rect2i): Rect2 { return _V(7, -4096, 2, from) as Rect2; }
+
+/**
+ * Constructs a {@link Rect2} by `position` and `size`.
+ */
+export function fromPositionSize(position: Vector2, size: Vector2): Rect2 { return _V(7, -4096, 3, position, size) as Rect2; }
+
+/**
+ * Constructs a {@link Rect2} by setting its {@link position} to (`x`, `y`), and its {@link size} to (`width`, `height`).
+ */
+export function fromXYWidthHeight(x: number, y: number, width: number, height: number): Rect2 { return _V(7, -4096, 4, x, y, width, height) as Rect2; }
+