@ringozz/godot 4.7.2-583 → 4.7.2-592

package/gen/value-types/Basis.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 { Quaternion, Vector3 } from '../value-types/index.ts';
+import type { Quaternion, Vector3 } from './index.ts';
 
 /**
  * The {@link Basis} built-in {@link Variant} type is a 3×3 [matrix](https://en.wikipedia.org/wiki/Matrix_(mathematics)) used to represent 3D rotation, scale, and shear. It is frequently used within a {@link Transform3D}.
@@ -19,265 +19,314 @@ import type { Quaternion, Vector3 } from '../value-types/index.ts';
  * **Note:** The basis matrices are exposed as [column-major](https://www.mindcontrol.org/~hplus/graphics/matrix-layout.html) order, which is the same as OpenGL. However, they are stored internally in row-major order, which is the same as DirectX.
  * **Note:** In a boolean context, a basis will evaluate to `false` if it's equal to {@link IDENTITY}. Otherwise, a basis will always evaluate to `true`.
  */
-export class Basis extends GodotVar {
-    /**
-     * The basis's X axis, and the column `0` of the matrix.
-     * On the identity basis, this vector points right ({@link Vector3.RIGHT}).
-     */
-    get x(): Vector3 { return _get(this, 14941) as Vector3; }
-    set x(v: Vector3) { _set(this, 14941, v); }
-
-    /**
-     * The basis's Y axis, and the column `1` of the matrix.
-     * On the identity basis, this vector points up ({@link Vector3.UP}).
-     */
-    get y(): Vector3 { return _get(this, 14952) as Vector3; }
-    set y(v: Vector3) { _set(this, 14952, v); }
-
-    /**
-     * The basis's Z axis, and the column `2` of the matrix.
-     * On the identity basis, this vector points back ({@link Vector3.BACK}).
-     */
-    get z(): Vector3 { return _get(this, 14956) as Vector3; }
-    set z(v: Vector3) { _set(this, 14956, v); }
-
-    constructor();
-    constructor(from: Basis);
-    constructor(from: Quaternion);
-    constructor(axis: Vector3, angle: number);
-    constructor(xAxis: Vector3, yAxis: Vector3, zAxis: Vector3);
-    constructor(...args: any[]) { super(17, ...args); }
-
-    /**
-     * Returns the [inverse of this basis's matrix](https://en.wikipedia.org/wiki/Invertible_matrix).
-     */
-    inverse(): Basis { return _C(this, 7714) as Basis; }
-
-    /**
-     * Returns the transposed version of this basis. This turns the basis matrix's columns into rows, and its rows into columns.
-     *
-     *
-     * ```gdscript
-     *
-     * var my_basis = Basis(
-     * 	Vector3(1, 2, 3),
-     * 	Vector3(4, 5, 6),
-     * 	Vector3(7, 8, 9)
-     * )
-     * my_basis = my_basis.transposed()
-     *
-     * print(my_basis.x) # Prints (1.0, 4.0, 7.0)
-     * print(my_basis.y) # Prints (2.0, 5.0, 8.0)
-     * print(my_basis.z) # Prints (3.0, 6.0, 9.0)
-     *
-     * ```
-     */
-    transposed(): Basis { return _C(this, 14405) as Basis; }
-
-    /**
-     * Returns the orthonormalized version of this basis. 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.
-     * It is often useful to call this method to avoid rounding errors on a rotating basis:
-     *
-     *
-     * ```gdscript
-     *
-     * # Rotate this Node3D every frame.
-     * func _process(delta):
-     * 	basis = basis.rotated(Vector3.UP, TAU * delta)
-     * 	basis = basis.rotated(Vector3.RIGHT, TAU * delta)
-     * 	basis = basis.orthonormalized()
-     *
-     * ```
-     */
-    orthonormalized(): Basis { return _C(this, 9230) as Basis; }
-
-    /**
-     * Returns the [determinant](https://en.wikipedia.org/wiki/Determinant) of this 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 3.
-     */
-    determinant(): number { return _C(this, 2773) as number; }
-
-    /**
-     * Returns a copy of this basis 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.
-     *
-     *
-     * ```gdscript
-     *
-     * var my_basis = Basis.IDENTITY
-     * var angle = TAU / 2
-     *
-     * my_basis = my_basis.rotated(Vector3.UP, angle)    # Rotate around the up axis (yaw).
-     * my_basis = my_basis.rotated(Vector3.RIGHT, angle) # Rotate around the right axis (pitch).
-     * my_basis = my_basis.rotated(Vector3.BACK, angle)  # Rotate around the back axis (roll).
-     *
-     * ```
-     */
-    rotated(axis: Vector3, angle: number): Basis { return _C(this, 10144, axis, angle) as Basis; }
-
-    /**
-     * Returns this basis with each axis's components scaled by the given `scale`'s components.
-     * The basis matrix's rows are multiplied by `scale`'s components. This operation is a global scale (relative to the parent).
-     *
-     *
-     * ```gdscript
-     *
-     * var my_basis = Basis(
-     * 	Vector3(1, 1, 1),
-     * 	Vector3(2, 2, 2),
-     * 	Vector3(3, 3, 3)
-     * )
-     * my_basis = my_basis.scaled(Vector3(0, 2, -2))
-     *
-     * print(my_basis.x) # Prints (0.0, 2.0, -2.0)
-     * print(my_basis.y) # Prints (0.0, 4.0, -4.0)
-     * print(my_basis.z) # Prints (0.0, 6.0, -6.0)
-     *
-     * ```
-     */
-    scaled(scale: Vector3): Basis { return _C(this, 10232, scale) as Basis; }
-
-    /**
-     * Returns this basis with each axis scaled by the corresponding component in the given `scale`.
-     * The basis matrix's columns are multiplied by `scale`'s components. This operation is a local scale (relative to self).
-     *
-     *
-     * ```gdscript
-     *
-     * var my_basis = Basis(
-     *     Vector3(1, 1, 1),
-     *     Vector3(2, 2, 2),
-     *     Vector3(3, 3, 3)
-     * )
-     * my_basis = my_basis.scaled_local(Vector3(0, 2, -2))
-     *
-     * print(my_basis.x) # Prints (0.0, 0.0, 0.0)
-     * print(my_basis.y) # Prints (4.0, 4.0, 4.0)
-     * print(my_basis.z) # Prints (-6.0, -6.0, -6.0)
-     *
-     * ```
-     */
-    scaledLocal(scale: Vector3): Basis { return _C(this, 10233, scale) as Basis; }
-
-    /**
-     * Returns the length of each axis of this basis, as a {@link Vector3}. If the basis is not sheared, this value is the scaling factor. It is not affected by rotation.
-     *
-     *
-     * ```gdscript
-     *
-     * var my_basis = Basis(
-     * 	Vector3(2, 0, 0),
-     * 	Vector3(0, 4, 0),
-     * 	Vector3(0, 0, 8)
-     * )
-     * # Rotating the Basis in any way preserves its scale.
-     * my_basis = my_basis.rotated(Vector3.UP, TAU / 2)
-     * my_basis = my_basis.rotated(Vector3.RIGHT, TAU / 4)
-     *
-     * print(my_basis.get_scale()) # Prints (2.0, 4.0, 8.0)
-     *
-     * ```
-     *
-     *
-     *
-     * **Note:** If the value returned by {@link determinant} is negative, the scale is also negative.
-     */
-    getScale(): Vector3 { return _C(this, 6236) as Vector3; }
-
-    /**
-     * Returns this basis's rotation as a {@link Vector3} of [Euler angles](https://en.wikipedia.org/wiki/Euler_angles), in radians. For the returned value:
-     * - The {@link Vector3.x} contains the angle around the {@link x} axis (pitch);
-     * - The {@link Vector3.y} contains the angle around the {@link y} axis (yaw);
-     * - The {@link Vector3.z} contains the angle around the {@link z} axis (roll).
-     * The order of each consecutive rotation can be changed with `order` (see {@link EulerOrder} constants). In Godot, Euler angles always use intrinsic order. By default, the intrinsic YXZ convention is used ({@link EULER_ORDER_YXZ}): since we are decomposing, local Z (roll) is calculated first, then local X (pitch), and lastly local Y (yaw). When using the opposite method {@link fromEuler} to compose a rotation, this order is reversed.
-     * **Note:** For this method to return correctly, the basis needs to be *orthonormal* (see {@link orthonormalized}).
-     * **Note:** Euler angles are much more intuitive but are not suitable for 3D math. Because of this, consider using the {@link getRotationQuaternion} method instead, which returns a {@link Quaternion}.
-     * **Note:** In the Inspector dock, a basis's rotation is often displayed in Euler angles (in degrees), as is the case with the {@link Node3D.rotation} property.
-     */
-    getEuler(order?: number /* = 2 */): Vector3 { return _C(this, 4689, order) as Vector3; }
-
-    /**
-     * Returns the transposed dot product between `with` and the {@link x} axis (see {@link transposed}).
-     * This is equivalent to `basis.x.dot(vector)`.
-     */
-    tdotx(_with: Vector3): number { return _C(this, 14141, _with) as number; }
-
-    /**
-     * Returns the transposed dot product between `with` and the {@link y} axis (see {@link transposed}).
-     * This is equivalent to `basis.y.dot(vector)`.
-     */
-    tdoty(_with: Vector3): number { return _C(this, 14142, _with) as number; }
-
-    /**
-     * Returns the transposed dot product between `with` and the {@link z} axis (see {@link transposed}).
-     * This is equivalent to `basis.z.dot(vector)`.
-     */
-    tdotz(_with: Vector3): number { return _C(this, 14143, _with) as number; }
-
-    /**
-     * Performs a spherical-linear interpolation with the `to` basis, given a `weight`. Both this basis and `to` should represent a rotation.
-     * **Example:** Smoothly rotate a {@link Node3D} to the target basis over time, with a {@link Tween}:
-     *
-     * ```text
-     *
-     * var start_basis = Basis.IDENTITY
-     * var target_basis = Basis.IDENTITY.rotated(Vector3.UP, TAU / 2)
-     *
-     * func _ready():
-     * 	create_tween().tween_method(interpolate, 0.0, 1.0, 5.0).set_trans(Tween.TRANS_EXPO)
-     *
-     * func interpolate(weight):
-     * 	basis = start_basis.slerp(target_basis, weight)
-     *
-     * ```
-     */
-    slerp(to: Basis, weight: number): Basis { return _C(this, 13656, to, weight) as Basis; }
-
-    /**
-     * Returns `true` if this 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 basis and `b` are approximately equal, by calling {@link isEqualApprox} on all vector components.
-     */
-    isEqualApprox(b: Basis): boolean { return _C(this, 7938, b) as boolean; }
-
-    /**
-     * Returns `true` if this basis is finite, by calling {@link isFinite} on all vector components.
-     */
-    isFinite(): boolean { return _C(this, 7951) as boolean; }
-
-    /**
-     * Returns `true` if this basis is orthonormal. An orthonormal basis is both *orthogonal* (the axes are perpendicular to each other) and *normalized* (the length of every axis is `1.0`). This method can be especially useful during physics calculations.
-     */
-    isOrthonormal(): boolean { return _C(this, 8158) as boolean; }
-
-    /**
-     * Returns this basis's rotation as a {@link Quaternion}.
-     * **Note:** Quaternions are much more suitable for 3D math but are less intuitive. For user interfaces, consider using the {@link getEuler} method, which returns Euler angles.
-     */
-    getRotationQuaternion(): Quaternion { return _C(this, 6214) as Quaternion; }
-
-    equals(other: Variant | Basis): boolean { return _C(this, -1, other) as boolean; }
-
-    notEquals(other: Variant | Basis): boolean { return _C(this, -2, other) as boolean; }
-
-    not(): boolean { return _C(this, -24, undefined) as boolean; }
-
-    /**
-     * Multiplies all components of the {@link Basis} by the given {@link int}. This affects the basis's scale uniformly, resizing all 3 axes by the `right` value.
-     */
-    mul(other: number | Vector3 | Basis): Basis { return _C(this, -9, other) as Basis; }
-
-    /**
-     * Divides all components of the {@link Basis} by the given {@link int}. This affects the basis's scale uniformly, resizing all 3 axes by the `right` value.
-     */
-    div(other: number): Basis { return _C(this, -10, other) as Basis; }
-
-    contains(other: GodotDictionary | GodotArray): boolean { return _C(this, -25, other) as boolean; }
-
-    static readonly name = _R(17, Basis);
-}
+export type Basis = [x: Vector3, y: Vector3, z: Vector3];
+
+/**
+ * Returns the [inverse of this basis's matrix](https://en.wikipedia.org/wiki/Invertible_matrix).
+ */
+export function inverse(self: Basis): Basis { return _V(17, 7714, self) as Basis; }
+
+/**
+ * Returns the transposed version of this basis. This turns the basis matrix's columns into rows, and its rows into columns.
+ *
+ *
+ * ```gdscript
+ *
+ * var my_basis = Basis(
+ * 	Vector3(1, 2, 3),
+ * 	Vector3(4, 5, 6),
+ * 	Vector3(7, 8, 9)
+ * )
+ * my_basis = my_basis.transposed()
+ *
+ * print(my_basis.x) # Prints (1.0, 4.0, 7.0)
+ * print(my_basis.y) # Prints (2.0, 5.0, 8.0)
+ * print(my_basis.z) # Prints (3.0, 6.0, 9.0)
+ *
+ * ```
+ */
+export function transposed(self: Basis): Basis { return _V(17, 14405, self) as Basis; }
+
+/**
+ * Returns the orthonormalized version of this basis. 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.
+ * It is often useful to call this method to avoid rounding errors on a rotating basis:
+ *
+ *
+ * ```gdscript
+ *
+ * # Rotate this Node3D every frame.
+ * func _process(delta):
+ * 	basis = basis.rotated(Vector3.UP, TAU * delta)
+ * 	basis = basis.rotated(Vector3.RIGHT, TAU * delta)
+ * 	basis = basis.orthonormalized()
+ *
+ * ```
+ */
+export function orthonormalized(self: Basis): Basis { return _V(17, 9230, self) as Basis; }
+
+/**
+ * Returns the [determinant](https://en.wikipedia.org/wiki/Determinant) of this 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 3.
+ */
+export function determinant(self: Basis): number { return _V(17, 2773, self) as number; }
+
+/**
+ * Returns a copy of this basis 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.
+ *
+ *
+ * ```gdscript
+ *
+ * var my_basis = Basis.IDENTITY
+ * var angle = TAU / 2
+ *
+ * my_basis = my_basis.rotated(Vector3.UP, angle)    # Rotate around the up axis (yaw).
+ * my_basis = my_basis.rotated(Vector3.RIGHT, angle) # Rotate around the right axis (pitch).
+ * my_basis = my_basis.rotated(Vector3.BACK, angle)  # Rotate around the back axis (roll).
+ *
+ * ```
+ */
+export function rotated(self: Basis, axis: Vector3, angle: number): Basis { return _V(17, 10144, self, axis, angle) as Basis; }
+
+/**
+ * Returns this basis with each axis's components scaled by the given `scale`'s components.
+ * The basis matrix's rows are multiplied by `scale`'s components. This operation is a global scale (relative to the parent).
+ *
+ *
+ * ```gdscript
+ *
+ * var my_basis = Basis(
+ * 	Vector3(1, 1, 1),
+ * 	Vector3(2, 2, 2),
+ * 	Vector3(3, 3, 3)
+ * )
+ * my_basis = my_basis.scaled(Vector3(0, 2, -2))
+ *
+ * print(my_basis.x) # Prints (0.0, 2.0, -2.0)
+ * print(my_basis.y) # Prints (0.0, 4.0, -4.0)
+ * print(my_basis.z) # Prints (0.0, 6.0, -6.0)
+ *
+ * ```
+ */
+export function scaled(self: Basis, scale: Vector3): Basis { return _V(17, 10232, self, scale) as Basis; }
+
+/**
+ * Returns this basis with each axis scaled by the corresponding component in the given `scale`.
+ * The basis matrix's columns are multiplied by `scale`'s components. This operation is a local scale (relative to self).
+ *
+ *
+ * ```gdscript
+ *
+ * var my_basis = Basis(
+ *     Vector3(1, 1, 1),
+ *     Vector3(2, 2, 2),
+ *     Vector3(3, 3, 3)
+ * )
+ * my_basis = my_basis.scaled_local(Vector3(0, 2, -2))
+ *
+ * print(my_basis.x) # Prints (0.0, 0.0, 0.0)
+ * print(my_basis.y) # Prints (4.0, 4.0, 4.0)
+ * print(my_basis.z) # Prints (-6.0, -6.0, -6.0)
+ *
+ * ```
+ */
+export function scaledLocal(self: Basis, scale: Vector3): Basis { return _V(17, 10233, self, scale) as Basis; }
+
+/**
+ * Returns the length of each axis of this basis, as a {@link Vector3}. If the basis is not sheared, this value is the scaling factor. It is not affected by rotation.
+ *
+ *
+ * ```gdscript
+ *
+ * var my_basis = Basis(
+ * 	Vector3(2, 0, 0),
+ * 	Vector3(0, 4, 0),
+ * 	Vector3(0, 0, 8)
+ * )
+ * # Rotating the Basis in any way preserves its scale.
+ * my_basis = my_basis.rotated(Vector3.UP, TAU / 2)
+ * my_basis = my_basis.rotated(Vector3.RIGHT, TAU / 4)
+ *
+ * print(my_basis.get_scale()) # Prints (2.0, 4.0, 8.0)
+ *
+ * ```
+ *
+ *
+ *
+ * **Note:** If the value returned by {@link determinant} is negative, the scale is also negative.
+ */
+export function getScale(self: Basis): Vector3 { return _V(17, 6236, self) as Vector3; }
+
+/**
+ * Returns this basis's rotation as a {@link Vector3} of [Euler angles](https://en.wikipedia.org/wiki/Euler_angles), in radians. For the returned value:
+ * - The {@link Vector3.x} contains the angle around the {@link x} axis (pitch);
+ * - The {@link Vector3.y} contains the angle around the {@link y} axis (yaw);
+ * - The {@link Vector3.z} contains the angle around the {@link z} axis (roll).
+ * The order of each consecutive rotation can be changed with `order` (see {@link EulerOrder} constants). In Godot, Euler angles always use intrinsic order. By default, the intrinsic YXZ convention is used ({@link EULER_ORDER_YXZ}): since we are decomposing, local Z (roll) is calculated first, then local X (pitch), and lastly local Y (yaw). When using the opposite method {@link fromEuler} to compose a rotation, this order is reversed.
+ * **Note:** For this method to return correctly, the basis needs to be *orthonormal* (see {@link orthonormalized}).
+ * **Note:** Euler angles are much more intuitive but are not suitable for 3D math. Because of this, consider using the {@link getRotationQuaternion} method instead, which returns a {@link Quaternion}.
+ * **Note:** In the Inspector dock, a basis's rotation is often displayed in Euler angles (in degrees), as is the case with the {@link Node3D.rotation} property.
+ */
+export function getEuler(self: Basis, order?: number /* = 2 */): Vector3 { return _V(17, 4689, self, order) as Vector3; }
+
+/**
+ * Returns the transposed dot product between `with` and the {@link x} axis (see {@link transposed}).
+ * This is equivalent to `basis.x.dot(vector)`.
+ */
+export function tdotx(self: Basis, _with: Vector3): number { return _V(17, 14141, self, _with) as number; }
+
+/**
+ * Returns the transposed dot product between `with` and the {@link y} axis (see {@link transposed}).
+ * This is equivalent to `basis.y.dot(vector)`.
+ */
+export function tdoty(self: Basis, _with: Vector3): number { return _V(17, 14142, self, _with) as number; }
+
+/**
+ * Returns the transposed dot product between `with` and the {@link z} axis (see {@link transposed}).
+ * This is equivalent to `basis.z.dot(vector)`.
+ */
+export function tdotz(self: Basis, _with: Vector3): number { return _V(17, 14143, self, _with) as number; }
+
+/**
+ * Performs a spherical-linear interpolation with the `to` basis, given a `weight`. Both this basis and `to` should represent a rotation.
+ * **Example:** Smoothly rotate a {@link Node3D} to the target basis over time, with a {@link Tween}:
+ *
+ * ```text
+ *
+ * var start_basis = Basis.IDENTITY
+ * var target_basis = Basis.IDENTITY.rotated(Vector3.UP, TAU / 2)
+ *
+ * func _ready():
+ * 	create_tween().tween_method(interpolate, 0.0, 1.0, 5.0).set_trans(Tween.TRANS_EXPO)
+ *
+ * func interpolate(weight):
+ * 	basis = start_basis.slerp(target_basis, weight)
+ *
+ * ```
+ */
+export function slerp(self: Basis, to: Basis, weight: number): Basis { return _V(17, 13656, self, to, weight) as Basis; }
+
+/**
+ * Returns `true` if this 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: Basis): boolean { return _V(17, 7854, self) as boolean; }
+
+/**
+ * Returns `true` if this basis and `b` are approximately equal, by calling {@link isEqualApprox} on all vector components.
+ */
+export function isEqualApprox(self: Basis, b: Basis): boolean { return _V(17, 7938, self, b) as boolean; }
+
+/**
+ * Returns `true` if this basis is finite, by calling {@link isFinite} on all vector components.
+ */
+export function isFinite(self: Basis): boolean { return _V(17, 7951, self) as boolean; }
+
+/**
+ * Returns `true` if this basis is orthonormal. An orthonormal basis is both *orthogonal* (the axes are perpendicular to each other) and *normalized* (the length of every axis is `1.0`). This method can be especially useful during physics calculations.
+ */
+export function isOrthonormal(self: Basis): boolean { return _V(17, 8158, self) as boolean; }
+
+/**
+ * Returns this basis's rotation as a {@link Quaternion}.
+ * **Note:** Quaternions are much more suitable for 3D math but are less intuitive. For user interfaces, consider using the {@link getEuler} method, which returns Euler angles.
+ */
+export function getRotationQuaternion(self: Basis): Quaternion { return _V(17, 6214, self) as Quaternion; }
+
+/**
+ * Creates a new {@link Basis} with a rotation such that the forward axis (-Z) points towards the `target` position.
+ * By default, the -Z axis (camera forward) is treated as forward (implies +X is right). If `useModelFront` is `true`, the +Z axis (asset front) is treated as forward (implies +X is left) and points toward the `target` position.
+ * The up axis (+Y) points as close to the `up` vector as possible while staying perpendicular to the forward axis. The returned basis is orthonormalized (see {@link orthonormalized}).
+ * The `target` and the `up` cannot be {@link Vector3.ZERO}, and shouldn't be colinear to avoid unintended rotation around local Z axis.
+ */
+export function lookingAt(target: Vector3, up?: Vector3 /* = Vector3(0, 1, 0) */, useModelFront?: boolean /* = false */): Basis { return _V(17, 8708, undefined, target, up, useModelFront) as Basis; }
+
+/**
+ * Constructs a new {@link Basis} that only represents scale, with no rotation or shear, from the given `scale` vector.
+ *
+ *
+ * ```gdscript
+ *
+ * var my_basis = Basis.from_scale(Vector3(2, 4, 8))
+ *
+ * print(my_basis.x) # Prints (2.0, 0.0, 0.0)
+ * print(my_basis.y) # Prints (0.0, 4.0, 0.0)
+ * print(my_basis.z) # Prints (0.0, 0.0, 8.0)
+ *
+ * ```
+ *
+ *
+ *
+ * **Note:** In linear algebra, the matrix of this basis is also known as a [diagonal matrix](https://en.wikipedia.org/wiki/Diagonal_matrix).
+ */
+export function fromScale(scale: Vector3): Basis { return _V(17, 3604, undefined, scale) as Basis; }
+
+/**
+ * Constructs a new {@link Basis} that only represents rotation from the given {@link Vector3} of [Euler angles](https://en.wikipedia.org/wiki/Euler_angles), in radians.
+ * - The {@link Vector3.x} should contain the angle around the {@link x} axis (pitch);
+ * - The {@link Vector3.y} should contain the angle around the {@link y} axis (yaw);
+ * - The {@link Vector3.z} should contain the angle around the {@link z} axis (roll).
+ *
+ *
+ * ```gdscript
+ *
+ * # Creates a Basis whose z axis points down.
+ * var my_basis = Basis.from_euler(Vector3(TAU / 4, 0, 0))
+ *
+ * print(my_basis.z) # Prints (0.0, -1.0, 0.0)
+ *
+ * ```
+ *
+ *
+ *
+ * The order of each consecutive rotation can be changed with `order` (see {@link EulerOrder} constants). In Godot, Euler angles always use intrinsic order. By default, the intrinsic YXZ convention is used ({@link EULER_ORDER_YXZ}): the basis rotates first around the local Y axis (yaw), then local X (pitch), and lastly local Z (roll). When using the opposite method {@link getEuler} to decompose a rotation, this order is reversed.
+ */
+export function fromEuler(euler: Vector3, order?: number /* = 2 */): Basis { return _V(17, 3595, undefined, euler, order) as Basis; }
+
+export function equals(a: Basis, b: Variant | Basis): boolean { return _V(17, -1, a, b) as boolean; }
+
+export function notEquals(a: Basis, b: Variant | Basis): boolean { return _V(17, -2, a, b) as boolean; }
+
+export function not(self: Basis): boolean { return _V(17, -24, self, undefined) as boolean; }
+
+/**
+ * Multiplies all components of the {@link Basis} by the given {@link int}. This affects the basis's scale uniformly, resizing all 3 axes by the `right` value.
+ */
+export function mul(a: Basis, b: number | Vector3 | Basis): Basis { return _V(17, -9, a, b) as Basis; }
+
+/**
+ * Divides all components of the {@link Basis} by the given {@link int}. This affects the basis's scale uniformly, resizing all 3 axes by the `right` value.
+ */
+export function div(a: Basis, b: number): Basis { return _V(17, -10, a, b) as Basis; }
+
+export function contains(a: Basis, b: GodotDictionary | GodotArray): boolean { return _V(17, -25, a, b) as boolean; }
+
+/**
+ * Constructs a {@link Basis} identical to {@link IDENTITY}.
+ * **Note:** In C#, this constructs a {@link Basis} with all of its components set to {@link Vector3.ZERO}.
+ */
+export function create(): Basis { return _V(17, -4096, 0) as Basis; }
+
+/**
+ * Constructs a {@link Basis} as a copy of the given {@link Basis}.
+ */
+export function fromBasis(from: Basis): Basis { return _V(17, -4096, 1, from) as Basis; }
+
+/**
+ * Constructs a {@link Basis} that only represents rotation from the given {@link Quaternion}.
+ * **Note:** Quaternions *only* store rotation, not scale. Because of this, conversions from {@link Basis} to {@link Quaternion} cannot always be reversed.
+ */
+export function fromQuaternion(from: Quaternion): Basis { return _V(17, -4096, 2, from) as Basis; }
+
+/**
+ * Constructs a {@link Basis} that only represents rotation, rotated around the `axis` by the given `angle`, in radians. The axis must be a normalized vector.
+ * **Note:** This is the same as using {@link rotated} on the {@link IDENTITY} basis. With more than one angle consider using {@link fromEuler}, instead.
+ */
+export function fromAxisAngle(axis: Vector3, angle: number): Basis { return _V(17, -4096, 3, axis, angle) as Basis; }
+
+/**
+ * Constructs a {@link Basis} from 3 axis vectors. These are the columns of the basis matrix.
+ */
+export function fromXAxisYAxisZAxis(xAxis: Vector3, yAxis: Vector3, zAxis: Vector3): Basis { return _V(17, -4096, 4, xAxis, yAxis, zAxis) as Basis; }
+