@ringozz/godot 4.7.2-583 → 4.7.2-592

package/gen/value-types/Vector2i.ts

@@ -1,201 +1,202 @@
 // 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 { Vector2 } from '../value-types/index.ts';
+import type { Vector2 } from './index.ts';
 
 /**
  * A 2-element structure that can be used to represent 2D grid coordinates or any other pair of integers.
  * It uses integer coordinates and is therefore preferable to {@link Vector2} when exact precision is required. Note that the values are limited to 32 bits, and unlike {@link Vector2} this cannot be configured with an engine build option. Use {@link int} or {@link PackedInt64Array} if 64-bit values are needed.
  * **Note:** In a boolean context, a Vector2i will evaluate to `false` if it's equal to `Vector2i(0, 0)`. Otherwise, a Vector2i will always evaluate to `true`.
  */
-export class Vector2i extends GodotVar {
-    /**
-     * The vector's X component. Also accessible by using the index position `[0]`.
-     */
-    get x(): number { return _get(this, 14941) as number; }
-    set x(v: number) { _set(this, 14941, v); }
-
-    /**
-     * The vector's Y component. Also accessible by using the index position `[1]`.
-     */
-    get y(): number { return _get(this, 14952) as number; }
-    set y(v: number) { _set(this, 14952, v); }
-
-    constructor();
-    constructor(from: Vector2i);
-    constructor(from: Vector2);
-    constructor(x: number, y: number);
-    constructor(...args: any[]) { super(6, ...args); }
-
-    /**
-     * Returns the aspect ratio of this vector, the ratio of {@link x} to {@link y}.
-     */
-    aspect(): number { return _C(this, 1602) as number; }
-
-    /**
-     * Returns the axis of the vector's highest value. See `AXIS_*` constants. If all components are equal, this method returns {@link AXIS_X}.
-     */
-    maxAxisIndex(): number { return _C(this, 8806) as number; }
-
-    /**
-     * Returns the axis of the vector's lowest value. See `AXIS_*` constants. If all components are equal, this method returns {@link AXIS_Y}.
-     */
-    minAxisIndex(): number { return _C(this, 8911) as number; }
-
-    /**
-     * Returns the [Euclidean distance](https://en.wikipedia.org/wiki/Euclidean_distance) between this vector and `to`.
-     */
-    distanceTo(to: Vector2i): number { return _C(this, 2850, to) as number; }
-
-    /**
-     * Returns the squared [Euclidean distance](https://en.wikipedia.org/wiki/Euclidean_distance) between this vector and `to`.
-     * This method runs faster than {@link distanceTo}, so prefer it if you need to compare vectors or need the squared distance for some formula.
-     */
-    distanceSquaredTo(to: Vector2i): number { return _C(this, 2849, to) as number; }
-
-    /**
-     * Returns the length (magnitude) of this vector.
-     */
-    length(): number { return _C(this, 8546) as number; }
-
-    /**
-     * Returns the squared length (squared magnitude) of this vector.
-     * This method runs faster than {@link length}, so prefer it if you need to compare vectors or need the squared distance for some formula.
-     */
-    lengthSquared(): number { return _C(this, 8547) as number; }
-
-    /**
-     * Returns a new vector with each component set to `1` if it's positive, `-1` if it's negative, and `0` if it's zero. The result is identical to calling {@link sign} on each component.
-     */
-    sign(): Vector2i { return _C(this, 13597) as Vector2i; }
-
-    /**
-     * Returns a new vector with all components in absolute values (i.e. positive).
-     */
-    abs(): Vector2i { return _C(this, 1053) as Vector2i; }
-
-    /**
-     * Returns a new vector with all components clamped between the components of `min` and `max`, by running {@link clamp} on each component.
-     */
-    clamp(min: Vector2i, max: Vector2i): Vector2i { return _C(this, 2202, min, max) as Vector2i; }
-
-    /**
-     * Returns a new vector with all components clamped between `min` and `max`, by running {@link clamp} on each component.
-     */
-    clampi(min: number, max: number): Vector2i { return _C(this, 2206, min, max) as Vector2i; }
-
-    /**
-     * Returns a new vector with each component snapped to the closest multiple of the corresponding component in `step`.
-     */
-    snapped(step: Vector2i): Vector2i { return _C(this, 13674, step) as Vector2i; }
-
-    /**
-     * Returns a new vector with each component snapped to the closest multiple of `step`.
-     */
-    snappedi(step: number): Vector2i { return _C(this, 13676, step) as Vector2i; }
-
-    /**
-     * Returns the component-wise minimum of this and `with`, equivalent to `Vector2i(mini(x, with.x), mini(y, with.y))`.
-     */
-    min(_with: Vector2i): Vector2i { return _C(this, 8910, _with) as Vector2i; }
-
-    /**
-     * Returns the component-wise minimum of this and `with`, equivalent to `Vector2i(mini(x, with), mini(y, with))`.
-     */
-    mini(_with: number): Vector2i { return _C(this, 8922, _with) as Vector2i; }
-
-    /**
-     * Returns the component-wise maximum of this and `with`, equivalent to `Vector2i(maxi(x, with.x), maxi(y, with.y))`.
-     */
-    max(_with: Vector2i): Vector2i { return _C(this, 8804, _with) as Vector2i; }
-
-    /**
-     * Returns the component-wise maximum of this and `with`, equivalent to `Vector2i(maxi(x, with), maxi(y, with))`.
-     */
-    maxi(_with: number): Vector2i { return _C(this, 8840, _with) as Vector2i; }
-
-    equals(other: Variant | Vector2i): boolean { return _C(this, -1, other) as boolean; }
-
-    notEquals(other: Variant | Vector2i): boolean { return _C(this, -2, other) as boolean; }
-
-    /**
-     * Returns the negative value of the {@link Vector2i}. This is the same as writing `Vector2i(-v.x, -v.y)`. This operation flips the direction of the vector while keeping the same magnitude.
-     */
-    neg(): Vector2i { return _C(this, -11, undefined) as Vector2i; }
-
-    /**
-     * Returns the same value as if the `+` was not there. Unary `+` does nothing, but sometimes it can make your code more readable.
-     */
-    pos(): Vector2i { return _C(this, -12, undefined) as Vector2i; }
-
-    not(): boolean { return _C(this, -24, undefined) as boolean; }
-
-    /**
-     * Multiplies each component of the {@link Vector2i} by the given {@link int}.
-     */
-    mul(other: number | Vector2i): Vector2i { return _C(this, -9, other) as Vector2i; }
-
-    /**
-     * Divides each component of the {@link Vector2i} by the given {@link int}.
-     */
-    div(other: number | Vector2i): Vector2i { return _C(this, -10, other) as Vector2i; }
-
-    /**
-     * Gets the remainder of each component of the {@link Vector2i} with the given {@link int}. This operation uses truncated division, which is often not desired as it does not work well with negative numbers. Consider using {@link posmod} instead if you want to handle negative numbers.
-     *
-     * ```text
-     *
-     * print(Vector2i(10, -20) % 7) # Prints (3, -6)
-     *
-     * ```
-     */
-    mod(other: number | Vector2i): Vector2i { return _C(this, -13, other) as Vector2i; }
-
-    /**
-     * Compares two {@link Vector2i} vectors by first checking if the X value of the left vector is less than the X value of the `right` vector. If the X values are exactly equal, then it repeats this check with the Y values of the two vectors. This operator is useful for sorting vectors.
-     */
-    lessThan(other: Vector2i): boolean { return _C(this, -3, other) as boolean; }
-
-    /**
-     * Compares two {@link Vector2i} vectors by first checking if the X value of the left vector is less than or equal to the X value of the `right` vector. If the X values are exactly equal, then it repeats this check with the Y values of the two vectors. This operator is useful for sorting vectors.
-     */
-    lessThanOrEqual(other: Vector2i): boolean { return _C(this, -4, other) as boolean; }
-
-    /**
-     * Compares two {@link Vector2i} vectors by first checking if the X value of the left vector is greater than the X value of the `right` vector. If the X values are exactly equal, then it repeats this check with the Y values of the two vectors. This operator is useful for sorting vectors.
-     */
-    greaterThan(other: Vector2i): boolean { return _C(this, -5, other) as boolean; }
-
-    /**
-     * Compares two {@link Vector2i} vectors by first checking if the X value of the left vector is greater than or equal to the X value of the `right` vector. If the X values are exactly equal, then it repeats this check with the Y values of the two vectors. This operator is useful for sorting vectors.
-     */
-    greaterThanOrEqual(other: Vector2i): boolean { return _C(this, -6, other) as boolean; }
-
-    /**
-     * Adds each component of the {@link Vector2i} by the components of the given {@link Vector2i}.
-     *
-     * ```text
-     *
-     * print(Vector2i(10, 20) + Vector2i(3, 4)) # Prints (13, 24)
-     *
-     * ```
-     */
-    add(other: Vector2i): Vector2i { return _C(this, -7, other) as Vector2i; }
-
-    /**
-     * Subtracts each component of the {@link Vector2i} by the components of the given {@link Vector2i}.
-     *
-     * ```text
-     *
-     * print(Vector2i(10, 20) - Vector2i(3, 4)) # Prints (7, 16)
-     *
-     * ```
-     */
-    sub(other: Vector2i): Vector2i { return _C(this, -8, other) as Vector2i; }
-
-    contains(other: GodotDictionary | GodotArray): boolean { return _C(this, -25, other) as boolean; }
-
-    static readonly name = _R(6, Vector2i);
-}
+export type Vector2i = [x: number, y: number];
+
+/**
+ * Returns the aspect ratio of this vector, the ratio of {@link x} to {@link y}.
+ */
+export function aspect(self: Vector2i): number { return _V(6, 1602, self) as number; }
+
+/**
+ * Returns the axis of the vector's highest value. See `AXIS_*` constants. If all components are equal, this method returns {@link AXIS_X}.
+ */
+export function maxAxisIndex(self: Vector2i): number { return _V(6, 8806, self) as number; }
+
+/**
+ * Returns the axis of the vector's lowest value. See `AXIS_*` constants. If all components are equal, this method returns {@link AXIS_Y}.
+ */
+export function minAxisIndex(self: Vector2i): number { return _V(6, 8911, self) as number; }
+
+/**
+ * Returns the [Euclidean distance](https://en.wikipedia.org/wiki/Euclidean_distance) between this vector and `to`.
+ */
+export function distanceTo(self: Vector2i, to: Vector2i): number { return _V(6, 2850, self, to) as number; }
+
+/**
+ * Returns the squared [Euclidean distance](https://en.wikipedia.org/wiki/Euclidean_distance) between this vector and `to`.
+ * This method runs faster than {@link distanceTo}, so prefer it if you need to compare vectors or need the squared distance for some formula.
+ */
+export function distanceSquaredTo(self: Vector2i, to: Vector2i): number { return _V(6, 2849, self, to) as number; }
+
+/**
+ * Returns the length (magnitude) of this vector.
+ */
+export function length(self: Vector2i): number { return _V(6, 8546, self) as number; }
+
+/**
+ * Returns the squared length (squared magnitude) of this vector.
+ * This method runs faster than {@link length}, so prefer it if you need to compare vectors or need the squared distance for some formula.
+ */
+export function lengthSquared(self: Vector2i): number { return _V(6, 8547, self) as number; }
+
+/**
+ * Returns a new vector with each component set to `1` if it's positive, `-1` if it's negative, and `0` if it's zero. The result is identical to calling {@link sign} on each component.
+ */
+export function sign(self: Vector2i): Vector2i { return _V(6, 13597, self) as Vector2i; }
+
+/**
+ * Returns a new vector with all components in absolute values (i.e. positive).
+ */
+export function abs(self: Vector2i): Vector2i { return _V(6, 1053, self) as Vector2i; }
+
+/**
+ * Returns a new vector with all components clamped between the components of `min` and `max`, by running {@link clamp} on each component.
+ */
+export function clamp(self: Vector2i, min: Vector2i, max: Vector2i): Vector2i { return _V(6, 2202, self, min, max) as Vector2i; }
+
+/**
+ * Returns a new vector with all components clamped between `min` and `max`, by running {@link clamp} on each component.
+ */
+export function clampi(self: Vector2i, min: number, max: number): Vector2i { return _V(6, 2206, self, min, max) as Vector2i; }
+
+/**
+ * Returns a new vector with each component snapped to the closest multiple of the corresponding component in `step`.
+ */
+export function snapped(self: Vector2i, step: Vector2i): Vector2i { return _V(6, 13674, self, step) as Vector2i; }
+
+/**
+ * Returns a new vector with each component snapped to the closest multiple of `step`.
+ */
+export function snappedi(self: Vector2i, step: number): Vector2i { return _V(6, 13676, self, step) as Vector2i; }
+
+/**
+ * Returns the component-wise minimum of this and `with`, equivalent to `Vector2i(mini(x, with.x), mini(y, with.y))`.
+ */
+export function min(self: Vector2i, _with: Vector2i): Vector2i { return _V(6, 8910, self, _with) as Vector2i; }
+
+/**
+ * Returns the component-wise minimum of this and `with`, equivalent to `Vector2i(mini(x, with), mini(y, with))`.
+ */
+export function mini(self: Vector2i, _with: number): Vector2i { return _V(6, 8922, self, _with) as Vector2i; }
+
+/**
+ * Returns the component-wise maximum of this and `with`, equivalent to `Vector2i(maxi(x, with.x), maxi(y, with.y))`.
+ */
+export function max(self: Vector2i, _with: Vector2i): Vector2i { return _V(6, 8804, self, _with) as Vector2i; }
+
+/**
+ * Returns the component-wise maximum of this and `with`, equivalent to `Vector2i(maxi(x, with), maxi(y, with))`.
+ */
+export function maxi(self: Vector2i, _with: number): Vector2i { return _V(6, 8840, self, _with) as Vector2i; }
+
+export function equals(a: Vector2i, b: Variant | Vector2i): boolean { return _V(6, -1, a, b) as boolean; }
+
+export function notEquals(a: Vector2i, b: Variant | Vector2i): boolean { return _V(6, -2, a, b) as boolean; }
+
+/**
+ * Returns the negative value of the {@link Vector2i}. This is the same as writing `Vector2i(-v.x, -v.y)`. This operation flips the direction of the vector while keeping the same magnitude.
+ */
+export function neg(self: Vector2i): Vector2i { return _V(6, -11, self, undefined) as Vector2i; }
+
+/**
+ * Returns the same value as if the `+` was not there. Unary `+` does nothing, but sometimes it can make your code more readable.
+ */
+export function pos(self: Vector2i): Vector2i { return _V(6, -12, self, undefined) as Vector2i; }
+
+export function not(self: Vector2i): boolean { return _V(6, -24, self, undefined) as boolean; }
+
+/**
+ * Multiplies each component of the {@link Vector2i} by the given {@link int}.
+ */
+export function mul(a: Vector2i, b: number | Vector2i): Vector2i { return _V(6, -9, a, b) as Vector2i; }
+
+/**
+ * Divides each component of the {@link Vector2i} by the given {@link int}.
+ */
+export function div(a: Vector2i, b: number | Vector2i): Vector2i { return _V(6, -10, a, b) as Vector2i; }
+
+/**
+ * Gets the remainder of each component of the {@link Vector2i} with the given {@link int}. This operation uses truncated division, which is often not desired as it does not work well with negative numbers. Consider using {@link posmod} instead if you want to handle negative numbers.
+ *
+ * ```text
+ *
+ * print(Vector2i(10, -20) % 7) # Prints (3, -6)
+ *
+ * ```
+ */
+export function mod(a: Vector2i, b: number | Vector2i): Vector2i { return _V(6, -13, a, b) as Vector2i; }
+
+/**
+ * Compares two {@link Vector2i} vectors by first checking if the X value of the left vector is less than the X value of the `right` vector. If the X values are exactly equal, then it repeats this check with the Y values of the two vectors. This operator is useful for sorting vectors.
+ */
+export function lessThan(a: Vector2i, b: Vector2i): boolean { return _V(6, -3, a, b) as boolean; }
+
+/**
+ * Compares two {@link Vector2i} vectors by first checking if the X value of the left vector is less than or equal to the X value of the `right` vector. If the X values are exactly equal, then it repeats this check with the Y values of the two vectors. This operator is useful for sorting vectors.
+ */
+export function lessThanOrEqual(a: Vector2i, b: Vector2i): boolean { return _V(6, -4, a, b) as boolean; }
+
+/**
+ * Compares two {@link Vector2i} vectors by first checking if the X value of the left vector is greater than the X value of the `right` vector. If the X values are exactly equal, then it repeats this check with the Y values of the two vectors. This operator is useful for sorting vectors.
+ */
+export function greaterThan(a: Vector2i, b: Vector2i): boolean { return _V(6, -5, a, b) as boolean; }
+
+/**
+ * Compares two {@link Vector2i} vectors by first checking if the X value of the left vector is greater than or equal to the X value of the `right` vector. If the X values are exactly equal, then it repeats this check with the Y values of the two vectors. This operator is useful for sorting vectors.
+ */
+export function greaterThanOrEqual(a: Vector2i, b: Vector2i): boolean { return _V(6, -6, a, b) as boolean; }
+
+/**
+ * Adds each component of the {@link Vector2i} by the components of the given {@link Vector2i}.
+ *
+ * ```text
+ *
+ * print(Vector2i(10, 20) + Vector2i(3, 4)) # Prints (13, 24)
+ *
+ * ```
+ */
+export function add(a: Vector2i, b: Vector2i): Vector2i { return _V(6, -7, a, b) as Vector2i; }
+
+/**
+ * Subtracts each component of the {@link Vector2i} by the components of the given {@link Vector2i}.
+ *
+ * ```text
+ *
+ * print(Vector2i(10, 20) - Vector2i(3, 4)) # Prints (7, 16)
+ *
+ * ```
+ */
+export function sub(a: Vector2i, b: Vector2i): Vector2i { return _V(6, -8, a, b) as Vector2i; }
+
+export function contains(a: Vector2i, b: GodotDictionary | GodotArray): boolean { return _V(6, -25, a, b) as boolean; }
+
+/**
+ * Constructs a default-initialized {@link Vector2i} with all components set to `0`.
+ */
+export function create(): Vector2i { return _V(6, -4096, 0) as Vector2i; }
+
+/**
+ * Constructs a {@link Vector2i} as a copy of the given {@link Vector2i}.
+ */
+export function fromVector2i(from: Vector2i): Vector2i { return _V(6, -4096, 1, from) as Vector2i; }
+
+/**
+ * Constructs a new {@link Vector2i} from the given {@link Vector2} by truncating components' fractional parts (rounding towards zero). For a different behavior consider passing the result of {@link Vector2.ceil}, {@link Vector2.floor} or {@link Vector2.round} to this constructor instead.
+ */
+export function fromVector2(from: Vector2): Vector2i { return _V(6, -4096, 2, from) as Vector2i; }
+
+/**
+ * Constructs a new {@link Vector2i} from the given `x` and `y`.
+ */
+export function fromXY(x: number, y: number): Vector2i { return _V(6, -4096, 3, x, y) as Vector2i; }
+