@ringozz/godot 4.7.2-583 → 4.7.2-592

package/gen/value-types/Vector3i.ts

@@ -1,202 +1,197 @@
 // 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 { Vector3 } from '../value-types/index.ts';
+import type { Vector3 } from './index.ts';
 
 /**
  * A 3-element structure that can be used to represent 3D grid coordinates or any other triplet of integers.
  * It uses integer coordinates and is therefore preferable to {@link Vector3} when exact precision is required. Note that the values are limited to 32 bits, and unlike {@link Vector3} 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 Vector3i will evaluate to `false` if it's equal to `Vector3i(0, 0, 0)`. Otherwise, a Vector3i will always evaluate to `true`.
  */
-export class Vector3i 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); }
-
-    /**
-     * The vector's Z component. Also accessible by using the index position `[2]`.
-     */
-    get z(): number { return _get(this, 14956) as number; }
-    set z(v: number) { _set(this, 14956, v); }
-
-    constructor();
-    constructor(from: Vector3i);
-    constructor(from: Vector3);
-    constructor(x: number, y: number, z: number);
-    constructor(...args: any[]) { super(10, ...args); }
-
-    /**
-     * Returns the axis of the vector's lowest value. See `AXIS_*` constants. If all components are equal, this method returns {@link AXIS_Z}.
-     */
-    minAxisIndex(): number { return _C(this, 8911) 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 [Euclidean distance](https://en.wikipedia.org/wiki/Euclidean_distance) between this vector and `to`.
-     */
-    distanceTo(to: Vector3i): 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: Vector3i): 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(): Vector3i { return _C(this, 13597) as Vector3i; }
-
-    /**
-     * Returns a new vector with all components in absolute values (i.e. positive).
-     */
-    abs(): Vector3i { return _C(this, 1053) as Vector3i; }
-
-    /**
-     * Returns a new vector with all components clamped between the components of `min` and `max`, by running {@link clamp} on each component.
-     */
-    clamp(min: Vector3i, max: Vector3i): Vector3i { return _C(this, 2202, min, max) as Vector3i; }
-
-    /**
-     * Returns a new vector with all components clamped between `min` and `max`, by running {@link clamp} on each component.
-     */
-    clampi(min: number, max: number): Vector3i { return _C(this, 2206, min, max) as Vector3i; }
-
-    /**
-     * Returns a new vector with each component snapped to the closest multiple of the corresponding component in `step`.
-     */
-    snapped(step: Vector3i): Vector3i { return _C(this, 13674, step) as Vector3i; }
-
-    /**
-     * Returns a new vector with each component snapped to the closest multiple of `step`.
-     */
-    snappedi(step: number): Vector3i { return _C(this, 13676, step) as Vector3i; }
-
-    /**
-     * Returns the component-wise minimum of this and `with`, equivalent to `Vector3i(mini(x, with.x), mini(y, with.y), mini(z, with.z))`.
-     */
-    min(_with: Vector3i): Vector3i { return _C(this, 8910, _with) as Vector3i; }
-
-    /**
-     * Returns the component-wise minimum of this and `with`, equivalent to `Vector3i(mini(x, with), mini(y, with), mini(z, with))`.
-     */
-    mini(_with: number): Vector3i { return _C(this, 8922, _with) as Vector3i; }
-
-    /**
-     * Returns the component-wise maximum of this and `with`, equivalent to `Vector3i(maxi(x, with.x), maxi(y, with.y), maxi(z, with.z))`.
-     */
-    max(_with: Vector3i): Vector3i { return _C(this, 8804, _with) as Vector3i; }
-
-    /**
-     * Returns the component-wise maximum of this and `with`, equivalent to `Vector3i(maxi(x, with), maxi(y, with), maxi(z, with))`.
-     */
-    maxi(_with: number): Vector3i { return _C(this, 8840, _with) as Vector3i; }
-
-    equals(other: Variant | Vector3i): boolean { return _C(this, -1, other) as boolean; }
-
-    notEquals(other: Variant | Vector3i): boolean { return _C(this, -2, other) as boolean; }
-
-    /**
-     * Returns the negative value of the {@link Vector3i}. This is the same as writing `Vector3i(-v.x, -v.y, -v.z)`. This operation flips the direction of the vector while keeping the same magnitude.
-     */
-    neg(): Vector3i { return _C(this, -11, undefined) as Vector3i; }
-
-    /**
-     * Returns the same value as if the `+` was not there. Unary `+` does nothing, but sometimes it can make your code more readable.
-     */
-    pos(): Vector3i { return _C(this, -12, undefined) as Vector3i; }
-
-    not(): boolean { return _C(this, -24, undefined) as boolean; }
-
-    /**
-     * Multiplies each component of the {@link Vector3i} by the given {@link int}.
-     */
-    mul(other: number | Vector3i): Vector3i { return _C(this, -9, other) as Vector3i; }
-
-    /**
-     * Divides each component of the {@link Vector3i} by the given {@link int}.
-     */
-    div(other: number | Vector3i): Vector3i { return _C(this, -10, other) as Vector3i; }
-
-    /**
-     * Gets the remainder of each component of the {@link Vector3i} 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(Vector3i(10, -20, 30) % 7) # Prints (3, -6, 2)
-     *
-     * ```
-     */
-    mod(other: number | Vector3i): Vector3i { return _C(this, -13, other) as Vector3i; }
-
-    /**
-     * Compares two {@link Vector3i} 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, and then with the Z values. This operator is useful for sorting vectors.
-     */
-    lessThan(other: Vector3i): boolean { return _C(this, -3, other) as boolean; }
-
-    /**
-     * Compares two {@link Vector3i} 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, and then with the Z values. This operator is useful for sorting vectors.
-     */
-    lessThanOrEqual(other: Vector3i): boolean { return _C(this, -4, other) as boolean; }
-
-    /**
-     * Compares two {@link Vector3i} 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, and then with the Z values. This operator is useful for sorting vectors.
-     */
-    greaterThan(other: Vector3i): boolean { return _C(this, -5, other) as boolean; }
-
-    /**
-     * Compares two {@link Vector3i} 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, and then with the Z values. This operator is useful for sorting vectors.
-     */
-    greaterThanOrEqual(other: Vector3i): boolean { return _C(this, -6, other) as boolean; }
-
-    /**
-     * Adds each component of the {@link Vector3i} by the components of the given {@link Vector3i}.
-     *
-     * ```text
-     *
-     * print(Vector3i(10, 20, 30) + Vector3i(3, 4, 5)) # Prints (13, 24, 35)
-     *
-     * ```
-     */
-    add(other: Vector3i): Vector3i { return _C(this, -7, other) as Vector3i; }
-
-    /**
-     * Subtracts each component of the {@link Vector3i} by the components of the given {@link Vector3i}.
-     *
-     * ```text
-     *
-     * print(Vector3i(10, 20, 30) - Vector3i(3, 4, 5)) # Prints (7, 16, 25)
-     *
-     * ```
-     */
-    sub(other: Vector3i): Vector3i { return _C(this, -8, other) as Vector3i; }
-
-    contains(other: GodotDictionary | GodotArray): boolean { return _C(this, -25, other) as boolean; }
-
-    static readonly name = _R(10, Vector3i);
-}
+export type Vector3i = [x: number, y: number, z: number];
+
+/**
+ * Returns the axis of the vector's lowest value. See `AXIS_*` constants. If all components are equal, this method returns {@link AXIS_Z}.
+ */
+export function minAxisIndex(self: Vector3i): number { return _V(10, 8911, 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: Vector3i): number { return _V(10, 8806, self) as number; }
+
+/**
+ * Returns the [Euclidean distance](https://en.wikipedia.org/wiki/Euclidean_distance) between this vector and `to`.
+ */
+export function distanceTo(self: Vector3i, to: Vector3i): number { return _V(10, 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: Vector3i, to: Vector3i): number { return _V(10, 2849, self, to) as number; }
+
+/**
+ * Returns the length (magnitude) of this vector.
+ */
+export function length(self: Vector3i): number { return _V(10, 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: Vector3i): number { return _V(10, 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: Vector3i): Vector3i { return _V(10, 13597, self) as Vector3i; }
+
+/**
+ * Returns a new vector with all components in absolute values (i.e. positive).
+ */
+export function abs(self: Vector3i): Vector3i { return _V(10, 1053, self) as Vector3i; }
+
+/**
+ * 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: Vector3i, min: Vector3i, max: Vector3i): Vector3i { return _V(10, 2202, self, min, max) as Vector3i; }
+
+/**
+ * Returns a new vector with all components clamped between `min` and `max`, by running {@link clamp} on each component.
+ */
+export function clampi(self: Vector3i, min: number, max: number): Vector3i { return _V(10, 2206, self, min, max) as Vector3i; }
+
+/**
+ * Returns a new vector with each component snapped to the closest multiple of the corresponding component in `step`.
+ */
+export function snapped(self: Vector3i, step: Vector3i): Vector3i { return _V(10, 13674, self, step) as Vector3i; }
+
+/**
+ * Returns a new vector with each component snapped to the closest multiple of `step`.
+ */
+export function snappedi(self: Vector3i, step: number): Vector3i { return _V(10, 13676, self, step) as Vector3i; }
+
+/**
+ * Returns the component-wise minimum of this and `with`, equivalent to `Vector3i(mini(x, with.x), mini(y, with.y), mini(z, with.z))`.
+ */
+export function min(self: Vector3i, _with: Vector3i): Vector3i { return _V(10, 8910, self, _with) as Vector3i; }
+
+/**
+ * Returns the component-wise minimum of this and `with`, equivalent to `Vector3i(mini(x, with), mini(y, with), mini(z, with))`.
+ */
+export function mini(self: Vector3i, _with: number): Vector3i { return _V(10, 8922, self, _with) as Vector3i; }
+
+/**
+ * Returns the component-wise maximum of this and `with`, equivalent to `Vector3i(maxi(x, with.x), maxi(y, with.y), maxi(z, with.z))`.
+ */
+export function max(self: Vector3i, _with: Vector3i): Vector3i { return _V(10, 8804, self, _with) as Vector3i; }
+
+/**
+ * Returns the component-wise maximum of this and `with`, equivalent to `Vector3i(maxi(x, with), maxi(y, with), maxi(z, with))`.
+ */
+export function maxi(self: Vector3i, _with: number): Vector3i { return _V(10, 8840, self, _with) as Vector3i; }
+
+export function equals(a: Vector3i, b: Variant | Vector3i): boolean { return _V(10, -1, a, b) as boolean; }
+
+export function notEquals(a: Vector3i, b: Variant | Vector3i): boolean { return _V(10, -2, a, b) as boolean; }
+
+/**
+ * Returns the negative value of the {@link Vector3i}. This is the same as writing `Vector3i(-v.x, -v.y, -v.z)`. This operation flips the direction of the vector while keeping the same magnitude.
+ */
+export function neg(self: Vector3i): Vector3i { return _V(10, -11, self, undefined) as Vector3i; }
+
+/**
+ * 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: Vector3i): Vector3i { return _V(10, -12, self, undefined) as Vector3i; }
+
+export function not(self: Vector3i): boolean { return _V(10, -24, self, undefined) as boolean; }
+
+/**
+ * Multiplies each component of the {@link Vector3i} by the given {@link int}.
+ */
+export function mul(a: Vector3i, b: number | Vector3i): Vector3i { return _V(10, -9, a, b) as Vector3i; }
+
+/**
+ * Divides each component of the {@link Vector3i} by the given {@link int}.
+ */
+export function div(a: Vector3i, b: number | Vector3i): Vector3i { return _V(10, -10, a, b) as Vector3i; }
+
+/**
+ * Gets the remainder of each component of the {@link Vector3i} 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(Vector3i(10, -20, 30) % 7) # Prints (3, -6, 2)
+ *
+ * ```
+ */
+export function mod(a: Vector3i, b: number | Vector3i): Vector3i { return _V(10, -13, a, b) as Vector3i; }
+
+/**
+ * Compares two {@link Vector3i} 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, and then with the Z values. This operator is useful for sorting vectors.
+ */
+export function lessThan(a: Vector3i, b: Vector3i): boolean { return _V(10, -3, a, b) as boolean; }
+
+/**
+ * Compares two {@link Vector3i} 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, and then with the Z values. This operator is useful for sorting vectors.
+ */
+export function lessThanOrEqual(a: Vector3i, b: Vector3i): boolean { return _V(10, -4, a, b) as boolean; }
+
+/**
+ * Compares two {@link Vector3i} 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, and then with the Z values. This operator is useful for sorting vectors.
+ */
+export function greaterThan(a: Vector3i, b: Vector3i): boolean { return _V(10, -5, a, b) as boolean; }
+
+/**
+ * Compares two {@link Vector3i} 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, and then with the Z values. This operator is useful for sorting vectors.
+ */
+export function greaterThanOrEqual(a: Vector3i, b: Vector3i): boolean { return _V(10, -6, a, b) as boolean; }
+
+/**
+ * Adds each component of the {@link Vector3i} by the components of the given {@link Vector3i}.
+ *
+ * ```text
+ *
+ * print(Vector3i(10, 20, 30) + Vector3i(3, 4, 5)) # Prints (13, 24, 35)
+ *
+ * ```
+ */
+export function add(a: Vector3i, b: Vector3i): Vector3i { return _V(10, -7, a, b) as Vector3i; }
+
+/**
+ * Subtracts each component of the {@link Vector3i} by the components of the given {@link Vector3i}.
+ *
+ * ```text
+ *
+ * print(Vector3i(10, 20, 30) - Vector3i(3, 4, 5)) # Prints (7, 16, 25)
+ *
+ * ```
+ */
+export function sub(a: Vector3i, b: Vector3i): Vector3i { return _V(10, -8, a, b) as Vector3i; }
+
+export function contains(a: Vector3i, b: GodotDictionary | GodotArray): boolean { return _V(10, -25, a, b) as boolean; }
+
+/**
+ * Constructs a default-initialized {@link Vector3i} with all components set to `0`.
+ */
+export function create(): Vector3i { return _V(10, -4096, 0) as Vector3i; }
+
+/**
+ * Constructs a {@link Vector3i} as a copy of the given {@link Vector3i}.
+ */
+export function fromVector3i(from: Vector3i): Vector3i { return _V(10, -4096, 1, from) as Vector3i; }
+
+/**
+ * Constructs a new {@link Vector3i} from the given {@link Vector3} by truncating components' fractional parts (rounding towards zero). For a different behavior consider passing the result of {@link Vector3.ceil}, {@link Vector3.floor} or {@link Vector3.round} to this constructor instead.
+ */
+export function fromVector3(from: Vector3): Vector3i { return _V(10, -4096, 2, from) as Vector3i; }
+
+/**
+ * Returns a {@link Vector3i} with the given components.
+ */
+export function fromXYZ(x: number, y: number, z: number): Vector3i { return _V(10, -4096, 3, x, y, z) as Vector3i; }
+