@ringozz/godot 4.7.2-583 → 4.7.2-592

package/gen/value-types/Transform2D.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, PackedVector2Array, Variant } from '../heap-types/index.ts';
-import type { Rect2, Vector2 } from '../value-types/index.ts';
+import type { Rect2, Vector2 } from './index.ts';
 
 /**
  * The {@link Transform2D} built-in {@link Variant} type is a 2×3 [matrix](https://en.wikipedia.org/wiki/Matrix_(mathematics)) representing a transformation in 2D space. It contains three {@link Vector2} values: {@link x}, {@link y}, and {@link origin}. Together, they can represent translation, rotation, scale, and skew.
@@ -12,195 +12,193 @@ import type { Rect2, Vector2 } from '../value-types/index.ts';
  * **Note:** Unlike {@link Transform3D}, there is no 2D equivalent to the {@link Basis} type. All mentions of "basis" refer to the {@link x} and {@link y} components of {@link Transform2D}.
  * **Note:** In a boolean context, a Transform2D will evaluate to `false` if it's equal to {@link IDENTITY}. Otherwise, a Transform2D will always evaluate to `true`.
  */
-export class Transform2D extends GodotVar {
-    /**
-     * The transform basis's X axis, and the column `0` of the matrix. Combined with {@link y}, this represents the transform's rotation, scale, and skew.
-     * On the identity transform, this vector points right ({@link Vector2.RIGHT}).
-     */
-    get x(): Vector2 { return _get(this, 14941) as Vector2; }
-    set x(v: Vector2) { _set(this, 14941, v); }
-
-    /**
-     * The transform basis's Y axis, and the column `1` of the matrix. Combined with {@link x}, this represents the transform's rotation, scale, and skew.
-     * On the identity transform, this vector points down ({@link Vector2.DOWN}).
-     */
-    get y(): Vector2 { return _get(this, 14952) as Vector2; }
-    set y(v: Vector2) { _set(this, 14952, v); }
-
-    /**
-     * The translation offset of this transform, and the column `2` of the matrix. In 2D space, this can be seen as the position.
-     */
-    get origin(): Vector2 { return _get(this, 9217) as Vector2; }
-    set origin(v: Vector2) { _set(this, 9217, v); }
-
-    constructor();
-    constructor(from: Transform2D);
-    constructor(rotation: number, position: Vector2);
-    constructor(rotation: number, scale: Vector2, skew: number, position: Vector2);
-    constructor(xAxis: Vector2, yAxis: Vector2, origin: Vector2);
-    constructor(...args: any[]) { super(11, ...args); }
-
-    /**
-     * Returns the [inverted version of this transform](https://en.wikipedia.org/wiki/Invertible_matrix).
-     * **Note:** For this method to return correctly, the transform's basis needs to be *orthonormal* (see {@link orthonormalized}). That means the basis should only represent a rotation. If it does not, use {@link affineInverse} instead.
-     */
-    inverse(): Transform2D { return _C(this, 7714) as Transform2D; }
-
-    /**
-     * Returns the inverted version of this transform. Unlike {@link inverse}, this method works with almost any basis, including non-uniform ones, but is slower.
-     * **Note:** For this method to return correctly, the transform's basis needs to have a determinant that is not exactly `0.0` (see {@link determinant}).
-     */
-    affineInverse(): Transform2D { return _C(this, 1354) as Transform2D; }
-
-    /**
-     * Returns this transform's rotation (in radians). This is equivalent to {@link x}'s angle (see {@link Vector2.angle}).
-     */
-    getRotation(): number { return _C(this, 6204) as number; }
-
-    /**
-     * Returns this transform's translation. Equivalent to {@link origin}.
-     */
-    getOrigin(): Vector2 { return _C(this, 5739) as Vector2; }
-
-    /**
-     * Returns the length of both {@link x} and {@link y}, as a {@link Vector2}. If this transform's basis is not skewed, this value is the scaling factor. It is not affected by rotation.
-     *
-     *
-     * ```gdscript
-     *
-     * var my_transform = Transform2D(
-     * 	Vector2(2, 0),
-     * 	Vector2(0, 4),
-     * 	Vector2(0, 0)
-     * )
-     * # Rotating the Transform2D in any way preserves its scale.
-     * my_transform = my_transform.rotated(TAU / 2)
-     *
-     * print(my_transform.get_scale()) # Prints (2.0, 4.0)
-     *
-     * ```
-     *
-     *
-     *
-     * **Note:** If the value returned by {@link determinant} is negative, the scale is also negative.
-     */
-    getScale(): Vector2 { return _C(this, 6236) as Vector2; }
-
-    /**
-     * Returns this transform's skew (in radians).
-     */
-    getSkew(): number { return _C(this, 6411) as number; }
-
-    /**
-     * Returns a copy of this transform with its basis orthonormalized. An orthonormal basis is both *orthogonal* (the axes are perpendicular to each other) and *normalized* (the axes have a length of `1.0`), which also means it can only represent a rotation.
-     */
-    orthonormalized(): Transform2D { return _C(this, 9230) as Transform2D; }
-
-    /**
-     * Returns a copy of this transform rotated by the given `angle` (in radians).
-     * If `angle` is positive, the transform is rotated clockwise.
-     * This method is an optimized version of multiplying the given transform `X` with a corresponding rotation transform `R` from the left, i.e., `R * X`.
-     * This can be seen as transforming with respect to the global/parent frame.
-     */
-    rotated(angle: number): Transform2D { return _C(this, 10144, angle) as Transform2D; }
-
-    /**
-     * Returns a copy of the transform rotated by the given `angle` (in radians).
-     * This method is an optimized version of multiplying the given transform `X` with a corresponding rotation transform `R` from the right, i.e., `X * R`.
-     * This can be seen as transforming with respect to the local frame.
-     */
-    rotatedLocal(angle: number): Transform2D { return _C(this, 10145, angle) as Transform2D; }
-
-    /**
-     * Returns a copy of the transform scaled by the given `scale` factor.
-     * This method is an optimized version of multiplying the given transform `X` with a corresponding scaling transform `S` from the left, i.e., `S * X`.
-     * This can be seen as transforming with respect to the global/parent frame.
-     */
-    scaled(scale: Vector2): Transform2D { return _C(this, 10232, scale) as Transform2D; }
-
-    /**
-     * Returns a copy of the transform scaled by the given `scale` factor.
-     * This method is an optimized version of multiplying the given transform `X` with a corresponding scaling transform `S` from the right, i.e., `X * S`.
-     * This can be seen as transforming with respect to the local frame.
-     */
-    scaledLocal(scale: Vector2): Transform2D { return _C(this, 10233, scale) as Transform2D; }
-
-    /**
-     * Returns a copy of the transform translated by the given `offset`.
-     * This method is an optimized version of multiplying the given transform `X` with a corresponding translation transform `T` from the left, i.e., `T * X`.
-     * This can be seen as transforming with respect to the global/parent frame.
-     */
-    translated(offset: Vector2): Transform2D { return _C(this, 14398, offset) as Transform2D; }
-
-    /**
-     * Returns a copy of the transform translated by the given `offset`.
-     * This method is an optimized version of multiplying the given transform `X` with a corresponding translation transform `T` from the right, i.e., `X * T`.
-     * This can be seen as transforming with respect to the local frame.
-     */
-    translatedLocal(offset: Vector2): Transform2D { return _C(this, 14399, offset) as Transform2D; }
-
-    /**
-     * Returns the [determinant](https://en.wikipedia.org/wiki/Determinant) of this transform basis's matrix. For advanced math, this number can be used to determine a few attributes:
-     * - If the determinant is exactly `0.0`, the basis is not invertible (see {@link inverse}).
-     * - If the determinant is a negative number, the basis represents a negative scale.
-     * **Note:** If the basis's scale is the same for every axis, its determinant is always that scale by the power of 2.
-     */
-    determinant(): number { return _C(this, 2773) as number; }
-
-    /**
-     * Returns a copy of the `v` vector, transformed (multiplied) by the transform basis's matrix. Unlike the multiplication operator (`*`), this method ignores the {@link origin}.
-     */
-    basisXform(v: Vector2): Vector2 { return _C(this, 1740, v) as Vector2; }
-
-    /**
-     * Returns a copy of the `v` vector, transformed (multiplied) by the inverse transform basis's matrix (see {@link inverse}). This method ignores the {@link origin}.
-     * **Note:** This method assumes that this transform's basis is *orthonormal* (see {@link orthonormalized}). If the basis is not orthonormal, `transform.affine_inverse().basis_xform(vector)` should be used instead (see {@link affineInverse}).
-     */
-    basisXformInv(v: Vector2): Vector2 { return _C(this, 1741, v) as Vector2; }
-
-    /**
-     * Returns the result of the linear interpolation between this transform and `xform` by the given `weight`.
-     * The `weight` should be between `0.0` and `1.0` (inclusive). Values outside this range are allowed and can be used to perform *extrapolation* instead.
-     */
-    interpolateWith(xform: Transform2D, weight: number): Transform2D { return _C(this, 7694, xform, weight) as Transform2D; }
-
-    /**
-     * Returns `true` if this transform's basis is conformal. A conformal basis is both *orthogonal* (the axes are perpendicular to each other) and *uniform* (the axes share the same length). This method can be especially useful during physics calculations.
-     */
-    isConformal(): boolean { return _C(this, 7854) as boolean; }
-
-    /**
-     * Returns `true` if this transform and `xform` are approximately equal, by running {@link isEqualApprox} on each component.
-     */
-    isEqualApprox(xform: Transform2D): boolean { return _C(this, 7938, xform) as boolean; }
-
-    /**
-     * Returns `true` if this transform is finite, by calling {@link isFinite} on each component.
-     */
-    isFinite(): boolean { return _C(this, 7951) as boolean; }
-
-    /**
-     * Returns a copy of the transform rotated such that the rotated X-axis points towards the `target` position, in global space.
-     */
-    lookingAt(target?: Vector2 /* = Vector2(0, 0) */): Transform2D { return _C(this, 8708, target) as Transform2D; }
-
-    equals(other: Variant | Transform2D): boolean { return _C(this, -1, other) as boolean; }
-
-    notEquals(other: Variant | Transform2D): boolean { return _C(this, -2, other) as boolean; }
-
-    not(): boolean { return _C(this, -24, undefined) as boolean; }
-
-    /**
-     * Multiplies all components of the {@link Transform2D} by the given {@link int}, including the {@link origin}. This affects the transform's scale uniformly.
-     */
-    mul(other: number | Vector2 | Rect2 | Transform2D | PackedVector2Array): Transform2D { return _C(this, -9, other) as Transform2D; }
-
-    /**
-     * Divides all components of the {@link Transform2D} by the given {@link int}, including the {@link origin}. This affects the transform's scale uniformly.
-     */
-    div(other: number): Transform2D { return _C(this, -10, other) as Transform2D; }
-
-    contains(other: GodotDictionary | GodotArray): boolean { return _C(this, -25, other) as boolean; }
-
-    static readonly name = _R(11, Transform2D);
-}
+export type Transform2D = [x: Vector2, y: Vector2, origin: Vector2];
+
+/**
+ * Returns the [inverted version of this transform](https://en.wikipedia.org/wiki/Invertible_matrix).
+ * **Note:** For this method to return correctly, the transform's basis needs to be *orthonormal* (see {@link orthonormalized}). That means the basis should only represent a rotation. If it does not, use {@link affineInverse} instead.
+ */
+export function inverse(self: Transform2D): Transform2D { return _V(11, 7714, self) as Transform2D; }
+
+/**
+ * Returns the inverted version of this transform. Unlike {@link inverse}, this method works with almost any basis, including non-uniform ones, but is slower.
+ * **Note:** For this method to return correctly, the transform's basis needs to have a determinant that is not exactly `0.0` (see {@link determinant}).
+ */
+export function affineInverse(self: Transform2D): Transform2D { return _V(11, 1354, self) as Transform2D; }
+
+/**
+ * Returns this transform's rotation (in radians). This is equivalent to {@link x}'s angle (see {@link Vector2.angle}).
+ */
+export function getRotation(self: Transform2D): number { return _V(11, 6204, self) as number; }
+
+/**
+ * Returns this transform's translation. Equivalent to {@link origin}.
+ */
+export function getOrigin(self: Transform2D): Vector2 { return _V(11, 5739, self) as Vector2; }
+
+/**
+ * Returns the length of both {@link x} and {@link y}, as a {@link Vector2}. If this transform's basis is not skewed, this value is the scaling factor. It is not affected by rotation.
+ *
+ *
+ * ```gdscript
+ *
+ * var my_transform = Transform2D(
+ * 	Vector2(2, 0),
+ * 	Vector2(0, 4),
+ * 	Vector2(0, 0)
+ * )
+ * # Rotating the Transform2D in any way preserves its scale.
+ * my_transform = my_transform.rotated(TAU / 2)
+ *
+ * print(my_transform.get_scale()) # Prints (2.0, 4.0)
+ *
+ * ```
+ *
+ *
+ *
+ * **Note:** If the value returned by {@link determinant} is negative, the scale is also negative.
+ */
+export function getScale(self: Transform2D): Vector2 { return _V(11, 6236, self) as Vector2; }
+
+/**
+ * Returns this transform's skew (in radians).
+ */
+export function getSkew(self: Transform2D): number { return _V(11, 6411, self) as number; }
+
+/**
+ * Returns a copy of this transform with its basis orthonormalized. An orthonormal basis is both *orthogonal* (the axes are perpendicular to each other) and *normalized* (the axes have a length of `1.0`), which also means it can only represent a rotation.
+ */
+export function orthonormalized(self: Transform2D): Transform2D { return _V(11, 9230, self) as Transform2D; }
+
+/**
+ * Returns a copy of this transform rotated by the given `angle` (in radians).
+ * If `angle` is positive, the transform is rotated clockwise.
+ * This method is an optimized version of multiplying the given transform `X` with a corresponding rotation transform `R` from the left, i.e., `R * X`.
+ * This can be seen as transforming with respect to the global/parent frame.
+ */
+export function rotated(self: Transform2D, angle: number): Transform2D { return _V(11, 10144, self, angle) as Transform2D; }
+
+/**
+ * Returns a copy of the transform rotated by the given `angle` (in radians).
+ * This method is an optimized version of multiplying the given transform `X` with a corresponding rotation transform `R` from the right, i.e., `X * R`.
+ * This can be seen as transforming with respect to the local frame.
+ */
+export function rotatedLocal(self: Transform2D, angle: number): Transform2D { return _V(11, 10145, self, angle) as Transform2D; }
+
+/**
+ * Returns a copy of the transform scaled by the given `scale` factor.
+ * This method is an optimized version of multiplying the given transform `X` with a corresponding scaling transform `S` from the left, i.e., `S * X`.
+ * This can be seen as transforming with respect to the global/parent frame.
+ */
+export function scaled(self: Transform2D, scale: Vector2): Transform2D { return _V(11, 10232, self, scale) as Transform2D; }
+
+/**
+ * Returns a copy of the transform scaled by the given `scale` factor.
+ * This method is an optimized version of multiplying the given transform `X` with a corresponding scaling transform `S` from the right, i.e., `X * S`.
+ * This can be seen as transforming with respect to the local frame.
+ */
+export function scaledLocal(self: Transform2D, scale: Vector2): Transform2D { return _V(11, 10233, self, scale) as Transform2D; }
+
+/**
+ * Returns a copy of the transform translated by the given `offset`.
+ * This method is an optimized version of multiplying the given transform `X` with a corresponding translation transform `T` from the left, i.e., `T * X`.
+ * This can be seen as transforming with respect to the global/parent frame.
+ */
+export function translated(self: Transform2D, offset: Vector2): Transform2D { return _V(11, 14398, self, offset) as Transform2D; }
+
+/**
+ * Returns a copy of the transform translated by the given `offset`.
+ * This method is an optimized version of multiplying the given transform `X` with a corresponding translation transform `T` from the right, i.e., `X * T`.
+ * This can be seen as transforming with respect to the local frame.
+ */
+export function translatedLocal(self: Transform2D, offset: Vector2): Transform2D { return _V(11, 14399, self, offset) as Transform2D; }
+
+/**
+ * Returns the [determinant](https://en.wikipedia.org/wiki/Determinant) of this transform basis's matrix. For advanced math, this number can be used to determine a few attributes:
+ * - If the determinant is exactly `0.0`, the basis is not invertible (see {@link inverse}).
+ * - If the determinant is a negative number, the basis represents a negative scale.
+ * **Note:** If the basis's scale is the same for every axis, its determinant is always that scale by the power of 2.
+ */
+export function determinant(self: Transform2D): number { return _V(11, 2773, self) as number; }
+
+/**
+ * Returns a copy of the `v` vector, transformed (multiplied) by the transform basis's matrix. Unlike the multiplication operator (`*`), this method ignores the {@link origin}.
+ */
+export function basisXform(self: Transform2D, v: Vector2): Vector2 { return _V(11, 1740, self, v) as Vector2; }
+
+/**
+ * Returns a copy of the `v` vector, transformed (multiplied) by the inverse transform basis's matrix (see {@link inverse}). This method ignores the {@link origin}.
+ * **Note:** This method assumes that this transform's basis is *orthonormal* (see {@link orthonormalized}). If the basis is not orthonormal, `transform.affine_inverse().basis_xform(vector)` should be used instead (see {@link affineInverse}).
+ */
+export function basisXformInv(self: Transform2D, v: Vector2): Vector2 { return _V(11, 1741, self, v) as Vector2; }
+
+/**
+ * Returns the result of the linear interpolation between this transform and `xform` by the given `weight`.
+ * The `weight` should be between `0.0` and `1.0` (inclusive). Values outside this range are allowed and can be used to perform *extrapolation* instead.
+ */
+export function interpolateWith(self: Transform2D, xform: Transform2D, weight: number): Transform2D { return _V(11, 7694, self, xform, weight) as Transform2D; }
+
+/**
+ * Returns `true` if this transform's basis is conformal. A conformal basis is both *orthogonal* (the axes are perpendicular to each other) and *uniform* (the axes share the same length). This method can be especially useful during physics calculations.
+ */
+export function isConformal(self: Transform2D): boolean { return _V(11, 7854, self) as boolean; }
+
+/**
+ * Returns `true` if this transform and `xform` are approximately equal, by running {@link isEqualApprox} on each component.
+ */
+export function isEqualApprox(self: Transform2D, xform: Transform2D): boolean { return _V(11, 7938, self, xform) as boolean; }
+
+/**
+ * Returns `true` if this transform is finite, by calling {@link isFinite} on each component.
+ */
+export function isFinite(self: Transform2D): boolean { return _V(11, 7951, self) as boolean; }
+
+/**
+ * Returns a copy of the transform rotated such that the rotated X-axis points towards the `target` position, in global space.
+ */
+export function lookingAt(self: Transform2D, target?: Vector2 /* = Vector2(0, 0) */): Transform2D { return _V(11, 8708, self, target) as Transform2D; }
+
+export function equals(a: Transform2D, b: Variant | Transform2D): boolean { return _V(11, -1, a, b) as boolean; }
+
+export function notEquals(a: Transform2D, b: Variant | Transform2D): boolean { return _V(11, -2, a, b) as boolean; }
+
+export function not(self: Transform2D): boolean { return _V(11, -24, self, undefined) as boolean; }
+
+/**
+ * Multiplies all components of the {@link Transform2D} by the given {@link int}, including the {@link origin}. This affects the transform's scale uniformly.
+ */
+export function mul(a: Transform2D, b: number | Vector2 | Rect2 | Transform2D | PackedVector2Array): Transform2D { return _V(11, -9, a, b) as Transform2D; }
+
+/**
+ * Divides all components of the {@link Transform2D} by the given {@link int}, including the {@link origin}. This affects the transform's scale uniformly.
+ */
+export function div(a: Transform2D, b: number): Transform2D { return _V(11, -10, a, b) as Transform2D; }
+
+export function contains(a: Transform2D, b: GodotDictionary | GodotArray): boolean { return _V(11, -25, a, b) as boolean; }
+
+/**
+ * Constructs a {@link Transform2D} identical to {@link IDENTITY}.
+ * **Note:** In C#, this constructs a {@link Transform2D} with all of its components set to {@link Vector2.ZERO}.
+ */
+export function create(): Transform2D { return _V(11, -4096, 0) as Transform2D; }
+
+/**
+ * Constructs a {@link Transform2D} as a copy of the given {@link Transform2D}.
+ */
+export function fromTransform2D(from: Transform2D): Transform2D { return _V(11, -4096, 1, from) as Transform2D; }
+
+/**
+ * Constructs a {@link Transform2D} from a given angle (in radians) and position.
+ */
+export function fromRotationPosition(rotation: number, position: Vector2): Transform2D { return _V(11, -4096, 2, rotation, position) as Transform2D; }
+
+/**
+ * Constructs a {@link Transform2D} from a given angle (in radians), scale, skew (in radians), and position.
+ */
+export function fromRotationScaleSkewPosition(rotation: number, scale: Vector2, skew: number, position: Vector2): Transform2D { return _V(11, -4096, 3, rotation, scale, skew, position) as Transform2D; }
+
+/**
+ * Constructs a {@link Transform2D} from 3 {@link Vector2} values representing {@link x}, {@link y}, and the {@link origin} (the three matrix columns).
+ */
+export function fromXAxisYAxisOrigin(xAxis: Vector2, yAxis: Vector2, origin: Vector2): Transform2D { return _V(11, -4096, 4, xAxis, yAxis, origin) as Transform2D; }
+