@ringozz/godot 0.1.0

package/gen/value-types/Transform2D.ts

@@ -0,0 +1,206 @@
+// 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 type { GodotArray, GodotDictionary, PackedVector2Array, Variant } from '../heap-types/index.ts';
+import type { Rect2, Vector2 } from '../value-types/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.
+ * The {@link x} and {@link y} axes form a 2×2 matrix, known as the transform's **basis**. The length of each axis ({@link Vector2.length}) influences the transform's scale, while the direction of all axes influence the rotation. Usually, both axes are perpendicular to one another. However, when you rotate one axis individually, the transform becomes skewed. Applying a skewed transform to a 2D sprite will make the sprite appear distorted.
+ * For a general introduction, see the [Matrices and transforms]($DOCS_URL/tutorials/math/matrices_and_transforms.html) tutorial.
+ * **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);
+}

package/gen/value-types/Transform3D.ts

@@ -0,0 +1,137 @@
+// 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 type { GodotArray, GodotDictionary, PackedVector3Array, Variant } from '../heap-types/index.ts';
+import type { AABB, Basis, Plane, Projection, Vector3 } from '../value-types/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.
+ * For a general introduction, see the [Matrices and transforms]($DOCS_URL/tutorials/math/matrices_and_transforms.html) tutorial.
+ * **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);
+}