@ringozz/godot 4.7.2-583 → 4.7.2-592

package/gen/value-types/Quaternion.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 { Basis, Vector3 } from '../value-types/index.ts';
+import type { Basis, Vector3 } from './index.ts';
 
 /**
  * The {@link Quaternion} built-in {@link Variant} type is a 4D data structure that represents rotation in the form of a [Hamilton convention quaternion](https://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation). Compared to the {@link Basis} type which can store both rotation and scale, quaternions can *only* store rotation.
@@ -13,180 +13,181 @@ import type { Basis, Vector3 } from '../value-types/index.ts';
  * **Note:** Similarly to {@link Vector2} and {@link Vector3}, the components of a quaternion use 32-bit precision by default, unlike {@link float} which is always 64-bit. If double precision is needed, compile the engine with the option `precision=double`.
  * **Note:** In a boolean context, a quaternion will evaluate to `false` if it's equal to {@link IDENTITY}. Otherwise, a quaternion will always evaluate to `true`.
  */
-export class Quaternion extends GodotVar {
-    /**
-     * X component of the quaternion. This is the value along the "imaginary" `i` axis.
-     * **Note:** Quaternion components should usually not be manipulated directly.
-     */
-    get x(): number { return _get(this, 14941) as number; }
-    set x(v: number) { _set(this, 14941, v); }
-
-    /**
-     * Y component of the quaternion. This is the value along the "imaginary" `j` axis.
-     * **Note:** Quaternion components should usually not be manipulated directly.
-     */
-    get y(): number { return _get(this, 14952) as number; }
-    set y(v: number) { _set(this, 14952, v); }
-
-    /**
-     * Z component of the quaternion. This is the value along the "imaginary" `k` axis.
-     * **Note:** Quaternion components should usually not be manipulated directly.
-     */
-    get z(): number { return _get(this, 14956) as number; }
-    set z(v: number) { _set(this, 14956, v); }
-
-    /**
-     * W component of the quaternion. This is the "real" part.
-     * **Note:** Quaternion components should usually not be manipulated directly.
-     */
-    get w(): number { return _get(this, 14833) as number; }
-    set w(v: number) { _set(this, 14833, v); }
-
-    constructor();
-    constructor(from: Quaternion);
-    constructor(from: Basis);
-    constructor(axis: Vector3, angle: number);
-    constructor(arcFrom: Vector3, arcTo: Vector3);
-    constructor(x: number, y: number, z: number, w: number);
-    constructor(...args: any[]) { super(15, ...args); }
-
-    /**
-     * Returns this quaternion's length, also called magnitude.
-     */
-    length(): number { return _C(this, 8546) as number; }
-
-    /**
-     * Returns this quaternion's length, squared.
-     * **Note:** This method is faster than {@link length}, so prefer it if you only need to compare quaternion lengths.
-     */
-    lengthSquared(): number { return _C(this, 8547) as number; }
-
-    /**
-     * Returns a copy of this quaternion, normalized so that its length is `1.0`. See also {@link isNormalized}.
-     */
-    normalized(): Quaternion { return _C(this, 9103) as Quaternion; }
-
-    /**
-     * Returns `true` if this quaternion is normalized. See also {@link normalized}.
-     */
-    isNormalized(): boolean { return _C(this, 8138) as boolean; }
-
-    /**
-     * Returns `true` if this quaternion and `to` are approximately equal, by calling {@link isEqualApprox} on each component.
-     */
-    isEqualApprox(to: Quaternion): boolean { return _C(this, 7938, to) as boolean; }
-
-    /**
-     * Returns `true` if this quaternion is finite, by calling {@link isFinite} on each component.
-     */
-    isFinite(): boolean { return _C(this, 7951) as boolean; }
-
-    /**
-     * Returns the inverse version of this quaternion, inverting the sign of every component except {@link w}.
-     */
-    inverse(): Quaternion { return _C(this, 7714) as Quaternion; }
-
-    /**
-     * Returns the logarithm of this quaternion. Multiplies this quaternion's rotation axis by its rotation angle, and stores the result in the returned quaternion's vector part ({@link x}, {@link y}, and {@link z}). The returned quaternion's real part ({@link w}) is always `0.0`.
-     */
-    log(): Quaternion { return _C(this, 8704) as Quaternion; }
-
-    /**
-     * Returns the exponential of this quaternion. The rotation axis of the result is the normalized rotation axis of this quaternion, the angle of the result is the length of the vector part of this quaternion.
-     */
-    exp(): Quaternion { return _C(this, 3185) as Quaternion; }
-
-    /**
-     * Returns the angle between this quaternion and `to`. This is the magnitude of the angle you would need to rotate by to get from one to the other.
-     * **Note:** The magnitude of the floating-point error for this method is abnormally high, so methods such as `is_zero_approx` will not work reliably.
-     */
-    angleTo(to: Quaternion): number { return _C(this, 1453, to) as number; }
-
-    /**
-     * Returns the dot product between this quaternion and `with`.
-     * This is equivalent to `(quat.x * with.x) + (quat.y * with.y) + (quat.z * with.z) + (quat.w * with.w)`.
-     */
-    dot(_with: Quaternion): number { return _C(this, 2871, _with) as number; }
-
-    /**
-     * Performs a spherical-linear interpolation with the `to` quaternion, given a `weight` and returns the result. Both this quaternion and `to` must be normalized.
-     */
-    slerp(to: Quaternion, weight: number): Quaternion { return _C(this, 13656, to, weight) as Quaternion; }
-
-    /**
-     * Performs a spherical-linear interpolation with the `to` quaternion, given a `weight` and returns the result. Unlike {@link slerp}, this method does not check if the rotation path is smaller than 90 degrees. Both this quaternion and `to` must be normalized.
-     */
-    slerpni(to: Quaternion, weight: number): Quaternion { return _C(this, 13657, to, weight) as Quaternion; }
-
-    /**
-     * Performs a spherical cubic interpolation between quaternions `preA`, this vector, `b`, and `postB`, by the given amount `weight`.
-     */
-    sphericalCubicInterpolate(b: Quaternion, preA: Quaternion, postB: Quaternion, weight: number): Quaternion { return _C(this, 13780, b, preA, postB, weight) as Quaternion; }
-
-    /**
-     * Performs a spherical cubic interpolation between quaternions `preA`, this vector, `b`, and `postB`, by the given amount `weight`.
-     * It can perform smoother interpolation than {@link sphericalCubicInterpolate} by the time values.
-     */
-    sphericalCubicInterpolateInTime(b: Quaternion, preA: Quaternion, postB: Quaternion, weight: number, bT: number, preAT: number, postBT: number): Quaternion { return _C(this, 13781, b, preA, postB, weight, bT, preAT, postBT) as Quaternion; }
-
-    /**
-     * Returns this quaternion's rotation as a {@link Vector3} of [Euler angles](https://en.wikipedia.org/wiki/Euler_angles), in radians.
-     * 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.
-     */
-    getEuler(order?: number /* = 2 */): Vector3 { return _C(this, 4689, order) as Vector3; }
-
-    /**
-     * Returns the rotation axis of the rotation represented by this quaternion.
-     */
-    getAxis(): Vector3 { return _C(this, 3859) as Vector3; }
-
-    /**
-     * Returns the angle of the rotation represented by this quaternion.
-     * **Note:** The quaternion must be normalized.
-     */
-    getAngle(): number { return _C(this, 3749) as number; }
-
-    equals(other: Variant | Quaternion): boolean { return _C(this, -1, other) as boolean; }
-
-    notEquals(other: Variant | Quaternion): boolean { return _C(this, -2, other) as boolean; }
-
-    /**
-     * Returns the negative value of the {@link Quaternion}. This is the same as multiplying all components by `-1`. This operation results in a quaternion that represents the same rotation.
-     */
-    neg(): Quaternion { return _C(this, -11, undefined) as Quaternion; }
-
-    /**
-     * Returns the same value as if the `+` was not there. Unary `+` does nothing, but sometimes it can make your code more readable.
-     */
-    pos(): Quaternion { return _C(this, -12, undefined) as Quaternion; }
-
-    not(): boolean { return _C(this, -24, undefined) as boolean; }
-
-    /**
-     * Multiplies each component of the {@link Quaternion} by the right {@link int} value.
-     * This operation is not meaningful on its own, but it can be used as a part of a larger expression.
-     */
-    mul(other: number | Vector3 | Quaternion): Quaternion { return _C(this, -9, other) as Quaternion; }
-
-    /**
-     * Divides each component of the {@link Quaternion} by the right {@link int} value.
-     * This operation is not meaningful on its own, but it can be used as a part of a larger expression.
-     */
-    div(other: number): Quaternion { return _C(this, -10, other) as Quaternion; }
-
-    /**
-     * Adds each component of the left {@link Quaternion} to the right {@link Quaternion}.
-     * This operation is not meaningful on its own, but it can be used as a part of a larger expression, such as approximating an intermediate rotation between two nearby rotations.
-     */
-    add(other: Quaternion): Quaternion { return _C(this, -7, other) as Quaternion; }
-
-    /**
-     * Subtracts each component of the left {@link Quaternion} by the right {@link Quaternion}.
-     * This operation is not meaningful on its own, but it can be used as a part of a larger expression.
-     */
-    sub(other: Quaternion): Quaternion { return _C(this, -8, other) as Quaternion; }
-
-    contains(other: GodotDictionary | GodotArray): boolean { return _C(this, -25, other) as boolean; }
-
-    static readonly name = _R(15, Quaternion);
-}
+export type Quaternion = [x: number, y: number, z: number, w: number];
+
+/**
+ * Returns this quaternion's length, also called magnitude.
+ */
+export function length(self: Quaternion): number { return _V(15, 8546, self) as number; }
+
+/**
+ * Returns this quaternion's length, squared.
+ * **Note:** This method is faster than {@link length}, so prefer it if you only need to compare quaternion lengths.
+ */
+export function lengthSquared(self: Quaternion): number { return _V(15, 8547, self) as number; }
+
+/**
+ * Returns a copy of this quaternion, normalized so that its length is `1.0`. See also {@link isNormalized}.
+ */
+export function normalized(self: Quaternion): Quaternion { return _V(15, 9103, self) as Quaternion; }
+
+/**
+ * Returns `true` if this quaternion is normalized. See also {@link normalized}.
+ */
+export function isNormalized(self: Quaternion): boolean { return _V(15, 8138, self) as boolean; }
+
+/**
+ * Returns `true` if this quaternion and `to` are approximately equal, by calling {@link isEqualApprox} on each component.
+ */
+export function isEqualApprox(self: Quaternion, to: Quaternion): boolean { return _V(15, 7938, self, to) as boolean; }
+
+/**
+ * Returns `true` if this quaternion is finite, by calling {@link isFinite} on each component.
+ */
+export function isFinite(self: Quaternion): boolean { return _V(15, 7951, self) as boolean; }
+
+/**
+ * Returns the inverse version of this quaternion, inverting the sign of every component except {@link w}.
+ */
+export function inverse(self: Quaternion): Quaternion { return _V(15, 7714, self) as Quaternion; }
+
+/**
+ * Returns the logarithm of this quaternion. Multiplies this quaternion's rotation axis by its rotation angle, and stores the result in the returned quaternion's vector part ({@link x}, {@link y}, and {@link z}). The returned quaternion's real part ({@link w}) is always `0.0`.
+ */
+export function log(self: Quaternion): Quaternion { return _V(15, 8704, self) as Quaternion; }
+
+/**
+ * Returns the exponential of this quaternion. The rotation axis of the result is the normalized rotation axis of this quaternion, the angle of the result is the length of the vector part of this quaternion.
+ */
+export function exp(self: Quaternion): Quaternion { return _V(15, 3185, self) as Quaternion; }
+
+/**
+ * Returns the angle between this quaternion and `to`. This is the magnitude of the angle you would need to rotate by to get from one to the other.
+ * **Note:** The magnitude of the floating-point error for this method is abnormally high, so methods such as `is_zero_approx` will not work reliably.
+ */
+export function angleTo(self: Quaternion, to: Quaternion): number { return _V(15, 1453, self, to) as number; }
+
+/**
+ * Returns the dot product between this quaternion and `with`.
+ * This is equivalent to `(quat.x * with.x) + (quat.y * with.y) + (quat.z * with.z) + (quat.w * with.w)`.
+ */
+export function dot(self: Quaternion, _with: Quaternion): number { return _V(15, 2871, self, _with) as number; }
+
+/**
+ * Performs a spherical-linear interpolation with the `to` quaternion, given a `weight` and returns the result. Both this quaternion and `to` must be normalized.
+ */
+export function slerp(self: Quaternion, to: Quaternion, weight: number): Quaternion { return _V(15, 13656, self, to, weight) as Quaternion; }
+
+/**
+ * Performs a spherical-linear interpolation with the `to` quaternion, given a `weight` and returns the result. Unlike {@link slerp}, this method does not check if the rotation path is smaller than 90 degrees. Both this quaternion and `to` must be normalized.
+ */
+export function slerpni(self: Quaternion, to: Quaternion, weight: number): Quaternion { return _V(15, 13657, self, to, weight) as Quaternion; }
+
+/**
+ * Performs a spherical cubic interpolation between quaternions `preA`, this vector, `b`, and `postB`, by the given amount `weight`.
+ */
+export function sphericalCubicInterpolate(self: Quaternion, b: Quaternion, preA: Quaternion, postB: Quaternion, weight: number): Quaternion { return _V(15, 13780, self, b, preA, postB, weight) as Quaternion; }
+
+/**
+ * Performs a spherical cubic interpolation between quaternions `preA`, this vector, `b`, and `postB`, by the given amount `weight`.
+ * It can perform smoother interpolation than {@link sphericalCubicInterpolate} by the time values.
+ */
+export function sphericalCubicInterpolateInTime(self: Quaternion, b: Quaternion, preA: Quaternion, postB: Quaternion, weight: number, bT: number, preAT: number, postBT: number): Quaternion { return _V(15, 13781, self, b, preA, postB, weight, bT, preAT, postBT) as Quaternion; }
+
+/**
+ * Returns this quaternion's rotation as a {@link Vector3} of [Euler angles](https://en.wikipedia.org/wiki/Euler_angles), in radians.
+ * 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.
+ */
+export function getEuler(self: Quaternion, order?: number /* = 2 */): Vector3 { return _V(15, 4689, self, order) as Vector3; }
+
+/**
+ * Constructs a new {@link Quaternion} from the given {@link Vector3} of [Euler angles](https://en.wikipedia.org/wiki/Euler_angles), in radians. In Godot, Euler angles always use intrinsic order. This method always uses the intrinsic YXZ convention ({@link EULER_ORDER_YXZ}).
+ */
+export function fromEuler(euler: Vector3): Quaternion { return _V(15, 3595, undefined, euler) as Quaternion; }
+
+/**
+ * Returns the rotation axis of the rotation represented by this quaternion.
+ */
+export function getAxis(self: Quaternion): Vector3 { return _V(15, 3859, self) as Vector3; }
+
+/**
+ * Returns the angle of the rotation represented by this quaternion.
+ * **Note:** The quaternion must be normalized.
+ */
+export function getAngle(self: Quaternion): number { return _V(15, 3749, self) as number; }
+
+export function equals(a: Quaternion, b: Variant | Quaternion): boolean { return _V(15, -1, a, b) as boolean; }
+
+export function notEquals(a: Quaternion, b: Variant | Quaternion): boolean { return _V(15, -2, a, b) as boolean; }
+
+/**
+ * Returns the negative value of the {@link Quaternion}. This is the same as multiplying all components by `-1`. This operation results in a quaternion that represents the same rotation.
+ */
+export function neg(self: Quaternion): Quaternion { return _V(15, -11, self, undefined) as Quaternion; }
+
+/**
+ * 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: Quaternion): Quaternion { return _V(15, -12, self, undefined) as Quaternion; }
+
+export function not(self: Quaternion): boolean { return _V(15, -24, self, undefined) as boolean; }
+
+/**
+ * Multiplies each component of the {@link Quaternion} by the right {@link int} value.
+ * This operation is not meaningful on its own, but it can be used as a part of a larger expression.
+ */
+export function mul(a: Quaternion, b: number | Vector3 | Quaternion): Quaternion { return _V(15, -9, a, b) as Quaternion; }
+
+/**
+ * Divides each component of the {@link Quaternion} by the right {@link int} value.
+ * This operation is not meaningful on its own, but it can be used as a part of a larger expression.
+ */
+export function div(a: Quaternion, b: number): Quaternion { return _V(15, -10, a, b) as Quaternion; }
+
+/**
+ * Adds each component of the left {@link Quaternion} to the right {@link Quaternion}.
+ * This operation is not meaningful on its own, but it can be used as a part of a larger expression, such as approximating an intermediate rotation between two nearby rotations.
+ */
+export function add(a: Quaternion, b: Quaternion): Quaternion { return _V(15, -7, a, b) as Quaternion; }
+
+/**
+ * Subtracts each component of the left {@link Quaternion} by the right {@link Quaternion}.
+ * This operation is not meaningful on its own, but it can be used as a part of a larger expression.
+ */
+export function sub(a: Quaternion, b: Quaternion): Quaternion { return _V(15, -8, a, b) as Quaternion; }
+
+export function contains(a: Quaternion, b: GodotDictionary | GodotArray): boolean { return _V(15, -25, a, b) as boolean; }
+
+/**
+ * Constructs a {@link Quaternion} identical to {@link IDENTITY}.
+ * **Note:** In C#, this constructs a {@link Quaternion} with all of its components set to `0.0`.
+ */
+export function create(): Quaternion { return _V(15, -4096, 0) as Quaternion; }
+
+/**
+ * Constructs a {@link Quaternion} as a copy of the given {@link Quaternion}.
+ */
+export function fromQuaternion(from: Quaternion): Quaternion { return _V(15, -4096, 1, from) as Quaternion; }
+
+/**
+ * Constructs a {@link Quaternion} from the given rotation {@link Basis}.
+ * This constructor is faster than {@link Basis.getRotationQuaternion}, but the given basis must be *orthonormalized* (see {@link Basis.orthonormalized}). Otherwise, the constructor fails and returns {@link IDENTITY}.
+ */
+export function fromBasis(from: Basis): Quaternion { return _V(15, -4096, 2, from) as Quaternion; }
+
+/**
+ * Constructs a {@link Quaternion} representing rotation around the `axis` by the given `angle`, in radians. The axis must be a normalized vector.
+ */
+export function fromAxisAngle(axis: Vector3, angle: number): Quaternion { return _V(15, -4096, 3, axis, angle) as Quaternion; }
+
+/**
+ * Constructs a {@link Quaternion} representing the shortest arc between `arcFrom` and `arcTo`. These can be imagined as two points intersecting a sphere's surface, with a radius of `1.0`.
+ */
+export function fromArcFromArcTo(arcFrom: Vector3, arcTo: Vector3): Quaternion { return _V(15, -4096, 4, arcFrom, arcTo) as Quaternion; }
+
+/**
+ * Constructs a {@link Quaternion} defined by the given values.
+ * **Note:** Only normalized quaternions represent rotation; if these values are not normalized, the new {@link Quaternion} will not be a valid rotation.
+ */
+export function fromXYZW(x: number, y: number, z: number, w: number): Quaternion { return _V(15, -4096, 5, x, y, z, w) as Quaternion; }
+