@ringozz/godot 4.7.2-583 → 4.7.2-592

package/gen/value-types/Transform3D.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, PackedVector3Array, Variant } from '../heap-types/index.ts';
-import type { AABB, Basis, Plane, Projection, Vector3 } from '../value-types/index.ts';
+import type { AABB, Basis, Plane, Projection, Vector3 } from './index.ts';
 
 /**
  * The {@link Transform3D} built-in {@link Variant} type is a 3×4 matrix representing a transformation in 3D space. It contains a {@link Basis}, which on its own can represent rotation, scale, and shear. Additionally, combined with its own {@link origin}, the transform can also represent a translation.
@@ -11,127 +11,134 @@ import type { AABB, Basis, Plane, Projection, Vector3 } from '../value-types/ind
  * **Note:** Godot uses a [right-handed coordinate system](https://en.wikipedia.org/wiki/Right-hand_rule), which is a common standard. For directions, the convention for built-in types like {@link Camera3D} is for -Z to point forward (+X is right, +Y is up, and +Z is back). Other objects may use different direction conventions. For more information, see the [3D asset direction conventions]($DOCS_URL/tutorials/assets_pipeline/importing_3d_scenes/model_export_considerations.html#d-asset-direction-conventions) tutorial.
  * **Note:** In a boolean context, a Transform3D will evaluate to `false` if it's equal to {@link IDENTITY}. Otherwise, a Transform3D will always evaluate to `true`.
  */
-export class Transform3D extends GodotVar {
-    /**
-     * The {@link Basis} of this transform. It is composed by 3 axes ({@link Basis.x}, {@link Basis.y}, and {@link Basis.z}). Together, these represent the transform's rotation, scale, and shear.
-     */
-    get basis(): Basis { return _get(this, 1739) as Basis; }
-    set basis(v: Basis) { _set(this, 1739, v); }
-
-    /**
-     * The translation offset of this transform. In 3D space, this can be seen as the position.
-     */
-    get origin(): Vector3 { return _get(this, 9217) as Vector3; }
-    set origin(v: Vector3) { _set(this, 9217, v); }
-
-    constructor();
-    constructor(from: Transform3D);
-    constructor(basis: Basis, origin: Vector3);
-    constructor(xAxis: Vector3, yAxis: Vector3, zAxis: Vector3, origin: Vector3);
-    constructor(from: Projection);
-    constructor(...args: any[]) { super(18, ...args); }
-
-    /**
-     * Returns the [inverted version of this transform](https://en.wikipedia.org/wiki/Invertible_matrix). See also {@link Basis.inverse}.
-     * **Note:** For this method to return correctly, the transform's {@link 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(): Transform3D { return _C(this, 7714) as Transform3D; }
-
-    /**
-     * Returns the inverted version of this transform. Unlike {@link inverse}, this method works with almost any {@link basis}, including non-uniform ones, but is slower. See also {@link Basis.inverse}.
-     * **Note:** For this method to return correctly, the transform's {@link basis} needs to have a determinant that is not exactly `0.0` (see {@link Basis.determinant}).
-     */
-    affineInverse(): Transform3D { return _C(this, 1354) as Transform3D; }
-
-    /**
-     * Returns a copy of this transform with its {@link 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. See also {@link Basis.orthonormalized}.
-     */
-    orthonormalized(): Transform3D { return _C(this, 9230) as Transform3D; }
-
-    /**
-     * Returns a copy of this transform rotated around the given `axis` by the given `angle` (in radians).
-     * The `axis` must be a normalized vector (see {@link Vector3.normalized}). If `angle` is positive, the basis is rotated counter-clockwise around the axis.
-     * 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(axis: Vector3, angle: number): Transform3D { return _C(this, 10144, axis, angle) as Transform3D; }
-
-    /**
-     * Returns a copy of this transform rotated around the given `axis` by the given `angle` (in radians).
-     * The `axis` must be a normalized vector in the transform's local coordinate system. For example, to rotate around the local X-axis, use {@link Vector3.RIGHT}.
-     * 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(axis: Vector3, angle: number): Transform3D { return _C(this, 10145, axis, angle) as Transform3D; }
-
-    /**
-     * Returns a copy of this 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: Vector3): Transform3D { return _C(this, 10232, scale) as Transform3D; }
-
-    /**
-     * Returns a copy of this 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: Vector3): Transform3D { return _C(this, 10233, scale) as Transform3D; }
-
-    /**
-     * Returns a copy of this 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: Vector3): Transform3D { return _C(this, 14398, offset) as Transform3D; }
-
-    /**
-     * Returns a copy of this 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: Vector3): Transform3D { return _C(this, 14399, offset) as Transform3D; }
-
-    /**
-     * Returns a copy of this transform rotated so that the forward axis (-Z) points towards the `target` position.
-     * The up axis (+Y) points as close to the `up` vector as possible while staying perpendicular to the forward axis. The resulting transform is orthonormalized. The existing rotation, scale, and skew information from the original transform is discarded. The `target` and `up` vectors cannot be zero, cannot be parallel to each other, and are defined in global/parent space.
-     * If `useModelFront` is `true`, the +Z axis (asset front) is treated as forward (implies +X is left) and points toward the `target` position. By default, the -Z axis (camera forward) is treated as forward (implies +X is right).
-     */
-    lookingAt(target: Vector3, up?: Vector3 /* = Vector3(0, 1, 0) */, useModelFront?: boolean /* = false */): Transform3D { return _C(this, 8708, target, up, useModelFront) as Transform3D; }
-
-    /**
-     * 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: Transform3D, weight: number): Transform3D { return _C(this, 7694, xform, weight) as Transform3D; }
-
-    /**
-     * Returns `true` if this transform and `xform` are approximately equal, by running {@link isEqualApprox} on each component.
-     */
-    isEqualApprox(xform: Transform3D): 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; }
-
-    equals(other: Variant | Transform3D): boolean { return _C(this, -1, other) as boolean; }
-
-    notEquals(other: Variant | Transform3D): boolean { return _C(this, -2, other) as boolean; }
-
-    not(): boolean { return _C(this, -24, undefined) as boolean; }
-
-    /**
-     * Multiplies all components of the {@link Transform3D} by the given {@link int}, including the {@link origin}. This affects the transform's scale uniformly, scaling the {@link basis}.
-     */
-    mul(other: number | Vector3 | Plane | AABB | Transform3D | PackedVector3Array): Transform3D { return _C(this, -9, other) as Transform3D; }
-
-    /**
-     * Divides all components of the {@link Transform3D} by the given {@link int}, including the {@link origin}. This affects the transform's scale uniformly, scaling the {@link basis}.
-     */
-    div(other: number): Transform3D { return _C(this, -10, other) as Transform3D; }
-
-    contains(other: GodotDictionary | GodotArray): boolean { return _C(this, -25, other) as boolean; }
-
-    static readonly name = _R(18, Transform3D);
-}
+export type Transform3D = [x: Vector3, y: Vector3, z: Vector3, origin: Vector3];
+
+/**
+ * Returns the [inverted version of this transform](https://en.wikipedia.org/wiki/Invertible_matrix). See also {@link Basis.inverse}.
+ * **Note:** For this method to return correctly, the transform's {@link 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: Transform3D): Transform3D { return _V(18, 7714, self) as Transform3D; }
+
+/**
+ * Returns the inverted version of this transform. Unlike {@link inverse}, this method works with almost any {@link basis}, including non-uniform ones, but is slower. See also {@link Basis.inverse}.
+ * **Note:** For this method to return correctly, the transform's {@link basis} needs to have a determinant that is not exactly `0.0` (see {@link Basis.determinant}).
+ */
+export function affineInverse(self: Transform3D): Transform3D { return _V(18, 1354, self) as Transform3D; }
+
+/**
+ * Returns a copy of this transform with its {@link 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. See also {@link Basis.orthonormalized}.
+ */
+export function orthonormalized(self: Transform3D): Transform3D { return _V(18, 9230, self) as Transform3D; }
+
+/**
+ * Returns a copy of this transform rotated around the given `axis` by the given `angle` (in radians).
+ * The `axis` must be a normalized vector (see {@link Vector3.normalized}). If `angle` is positive, the basis is rotated counter-clockwise around the axis.
+ * 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: Transform3D, axis: Vector3, angle: number): Transform3D { return _V(18, 10144, self, axis, angle) as Transform3D; }
+
+/**
+ * Returns a copy of this transform rotated around the given `axis` by the given `angle` (in radians).
+ * The `axis` must be a normalized vector in the transform's local coordinate system. For example, to rotate around the local X-axis, use {@link Vector3.RIGHT}.
+ * 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: Transform3D, axis: Vector3, angle: number): Transform3D { return _V(18, 10145, self, axis, angle) as Transform3D; }
+
+/**
+ * Returns a copy of this 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: Transform3D, scale: Vector3): Transform3D { return _V(18, 10232, self, scale) as Transform3D; }
+
+/**
+ * Returns a copy of this 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: Transform3D, scale: Vector3): Transform3D { return _V(18, 10233, self, scale) as Transform3D; }
+
+/**
+ * Returns a copy of this 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: Transform3D, offset: Vector3): Transform3D { return _V(18, 14398, self, offset) as Transform3D; }
+
+/**
+ * Returns a copy of this 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: Transform3D, offset: Vector3): Transform3D { return _V(18, 14399, self, offset) as Transform3D; }
+
+/**
+ * Returns a copy of this transform rotated so that the forward axis (-Z) points towards the `target` position.
+ * The up axis (+Y) points as close to the `up` vector as possible while staying perpendicular to the forward axis. The resulting transform is orthonormalized. The existing rotation, scale, and skew information from the original transform is discarded. The `target` and `up` vectors cannot be zero, cannot be parallel to each other, and are defined in global/parent space.
+ * If `useModelFront` is `true`, the +Z axis (asset front) is treated as forward (implies +X is left) and points toward the `target` position. By default, the -Z axis (camera forward) is treated as forward (implies +X is right).
+ */
+export function lookingAt(self: Transform3D, target: Vector3, up?: Vector3 /* = Vector3(0, 1, 0) */, useModelFront?: boolean /* = false */): Transform3D { return _V(18, 8708, self, target, up, useModelFront) as Transform3D; }
+
+/**
+ * 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: Transform3D, xform: Transform3D, weight: number): Transform3D { return _V(18, 7694, self, xform, weight) as Transform3D; }
+
+/**
+ * Returns `true` if this transform and `xform` are approximately equal, by running {@link isEqualApprox} on each component.
+ */
+export function isEqualApprox(self: Transform3D, xform: Transform3D): boolean { return _V(18, 7938, self, xform) as boolean; }
+
+/**
+ * Returns `true` if this transform is finite, by calling {@link isFinite} on each component.
+ */
+export function isFinite(self: Transform3D): boolean { return _V(18, 7951, self) as boolean; }
+
+export function equals(a: Transform3D, b: Variant | Transform3D): boolean { return _V(18, -1, a, b) as boolean; }
+
+export function notEquals(a: Transform3D, b: Variant | Transform3D): boolean { return _V(18, -2, a, b) as boolean; }
+
+export function not(self: Transform3D): boolean { return _V(18, -24, self, undefined) as boolean; }
+
+/**
+ * Multiplies all components of the {@link Transform3D} by the given {@link int}, including the {@link origin}. This affects the transform's scale uniformly, scaling the {@link basis}.
+ */
+export function mul(a: Transform3D, b: number | Vector3 | Plane | AABB | Transform3D | PackedVector3Array): Transform3D { return _V(18, -9, a, b) as Transform3D; }
+
+/**
+ * Divides all components of the {@link Transform3D} by the given {@link int}, including the {@link origin}. This affects the transform's scale uniformly, scaling the {@link basis}.
+ */
+export function div(a: Transform3D, b: number): Transform3D { return _V(18, -10, a, b) as Transform3D; }
+
+export function contains(a: Transform3D, b: GodotDictionary | GodotArray): boolean { return _V(18, -25, a, b) as boolean; }
+
+/**
+ * Constructs a {@link Transform3D} identical to {@link IDENTITY}.
+ * **Note:** In C#, this constructs a {@link Transform3D} with its {@link origin} and the components of its {@link basis} set to {@link Vector3.ZERO}.
+ */
+export function create(): Transform3D { return _V(18, -4096, 0) as Transform3D; }
+
+/**
+ * Constructs a {@link Transform3D} as a copy of the given {@link Transform3D}.
+ */
+export function fromTransform3D(from: Transform3D): Transform3D { return _V(18, -4096, 1, from) as Transform3D; }
+
+/**
+ * Constructs a {@link Transform3D} from a {@link Basis} and {@link Vector3}.
+ */
+export function fromBasisOrigin(basis: Basis, origin: Vector3): Transform3D { return _V(18, -4096, 2, basis, origin) as Transform3D; }
+
+/**
+ * Constructs a {@link Transform3D} from four {@link Vector3} values (also called matrix columns).
+ * The first three arguments are the {@link basis}'s axes ({@link Basis.x}, {@link Basis.y}, and {@link Basis.z}).
+ */
+export function fromXAxisYAxisZAxisOrigin(xAxis: Vector3, yAxis: Vector3, zAxis: Vector3, origin: Vector3): Transform3D { return _V(18, -4096, 3, xAxis, yAxis, zAxis, origin) as Transform3D; }
+
+/**
+ * Constructs a {@link Transform3D} from a {@link Projection}. Because {@link Transform3D} is a 3×4 matrix and {@link Projection} is a 4×4 matrix, this operation trims the last row of the projection matrix (`from.x.w`, `from.y.w`, `from.z.w`, and `from.w.w` are not included in the new transform).
+ */
+export function fromProjection(from: Projection): Transform3D { return _V(18, -4096, 4, from) as Transform3D; }
+