@ringozz/godot 4.7.2-583 → 4.7.2-592

package/gen/value-types/Vector4i.ts

@@ -1,208 +1,197 @@
 // 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 { Vector4 } from '../value-types/index.ts';
+import type { Vector4 } from './index.ts';
 
 /**
  * A 4-element structure that can be used to represent 4D grid coordinates or any other quadruplet of integers.
  * It uses integer coordinates and is therefore preferable to {@link Vector4} when exact precision is required. Note that the values are limited to 32 bits, and unlike {@link Vector4} this cannot be configured with an engine build option. Use {@link int} or {@link PackedInt64Array} if 64-bit values are needed.
  * **Note:** In a boolean context, a Vector4i will evaluate to `false` if it's equal to `Vector4i(0, 0, 0, 0)`. Otherwise, a Vector4i will always evaluate to `true`.
  */
-export class Vector4i extends GodotVar {
-    /**
-     * The vector's X component. Also accessible by using the index position `[0]`.
-     */
-    get x(): number { return _get(this, 14941) as number; }
-    set x(v: number) { _set(this, 14941, v); }
-
-    /**
-     * The vector's Y component. Also accessible by using the index position `[1]`.
-     */
-    get y(): number { return _get(this, 14952) as number; }
-    set y(v: number) { _set(this, 14952, v); }
-
-    /**
-     * The vector's Z component. Also accessible by using the index position `[2]`.
-     */
-    get z(): number { return _get(this, 14956) as number; }
-    set z(v: number) { _set(this, 14956, v); }
-
-    /**
-     * The vector's W component. Also accessible by using the index position `[3]`.
-     */
-    get w(): number { return _get(this, 14833) as number; }
-    set w(v: number) { _set(this, 14833, v); }
-
-    constructor();
-    constructor(from: Vector4i);
-    constructor(from: Vector4);
-    constructor(x: number, y: number, z: number, w: number);
-    constructor(...args: any[]) { super(13, ...args); }
-
-    /**
-     * Returns the axis of the vector's lowest value. See `AXIS_*` constants. If all components are equal, this method returns {@link AXIS_W}.
-     */
-    minAxisIndex(): number { return _C(this, 8911) as number; }
-
-    /**
-     * Returns the axis of the vector's highest value. See `AXIS_*` constants. If all components are equal, this method returns {@link AXIS_X}.
-     */
-    maxAxisIndex(): number { return _C(this, 8806) as number; }
-
-    /**
-     * Returns the length (magnitude) of this vector.
-     */
-    length(): number { return _C(this, 8546) as number; }
-
-    /**
-     * Returns the squared length (squared magnitude) of this vector.
-     * This method runs faster than {@link length}, so prefer it if you need to compare vectors or need the squared distance for some formula.
-     */
-    lengthSquared(): number { return _C(this, 8547) as number; }
-
-    /**
-     * Returns a new vector with each component set to `1` if it's positive, `-1` if it's negative, and `0` if it's zero. The result is identical to calling {@link sign} on each component.
-     */
-    sign(): Vector4i { return _C(this, 13597) as Vector4i; }
-
-    /**
-     * Returns a new vector with all components in absolute values (i.e. positive).
-     */
-    abs(): Vector4i { return _C(this, 1053) as Vector4i; }
-
-    /**
-     * Returns a new vector with all components clamped between the components of `min` and `max`, by running {@link clamp} on each component.
-     */
-    clamp(min: Vector4i, max: Vector4i): Vector4i { return _C(this, 2202, min, max) as Vector4i; }
-
-    /**
-     * Returns a new vector with all components clamped between `min` and `max`, by running {@link clamp} on each component.
-     */
-    clampi(min: number, max: number): Vector4i { return _C(this, 2206, min, max) as Vector4i; }
-
-    /**
-     * Returns a new vector with each component snapped to the closest multiple of the corresponding component in `step`.
-     */
-    snapped(step: Vector4i): Vector4i { return _C(this, 13674, step) as Vector4i; }
-
-    /**
-     * Returns a new vector with each component snapped to the closest multiple of `step`.
-     */
-    snappedi(step: number): Vector4i { return _C(this, 13676, step) as Vector4i; }
-
-    /**
-     * Returns the component-wise minimum of this and `with`, equivalent to `Vector4i(mini(x, with.x), mini(y, with.y), mini(z, with.z), mini(w, with.w))`.
-     */
-    min(_with: Vector4i): Vector4i { return _C(this, 8910, _with) as Vector4i; }
-
-    /**
-     * Returns the component-wise minimum of this and `with`, equivalent to `Vector4i(mini(x, with), mini(y, with), mini(z, with), mini(w, with))`.
-     */
-    mini(_with: number): Vector4i { return _C(this, 8922, _with) as Vector4i; }
-
-    /**
-     * Returns the component-wise maximum of this and `with`, equivalent to `Vector4i(maxi(x, with.x), maxi(y, with.y), maxi(z, with.z), maxi(w, with.w))`.
-     */
-    max(_with: Vector4i): Vector4i { return _C(this, 8804, _with) as Vector4i; }
-
-    /**
-     * Returns the component-wise maximum of this and `with`, equivalent to `Vector4i(maxi(x, with), maxi(y, with), maxi(z, with), maxi(w, with))`.
-     */
-    maxi(_with: number): Vector4i { return _C(this, 8840, _with) as Vector4i; }
-
-    /**
-     * Returns the [Euclidean distance](https://en.wikipedia.org/wiki/Euclidean_distance) between this vector and `to`.
-     */
-    distanceTo(to: Vector4i): number { return _C(this, 2850, to) as number; }
-
-    /**
-     * Returns the squared [Euclidean distance](https://en.wikipedia.org/wiki/Euclidean_distance) between this vector and `to`.
-     * This method runs faster than {@link distanceTo}, so prefer it if you need to compare vectors or need the squared distance for some formula.
-     */
-    distanceSquaredTo(to: Vector4i): number { return _C(this, 2849, to) as number; }
-
-    equals(other: Variant | Vector4i): boolean { return _C(this, -1, other) as boolean; }
-
-    notEquals(other: Variant | Vector4i): boolean { return _C(this, -2, other) as boolean; }
-
-    /**
-     * Returns the negative value of the {@link Vector4i}. This is the same as writing `Vector4i(-v.x, -v.y, -v.z, -v.w)`. This operation flips the direction of the vector while keeping the same magnitude.
-     */
-    neg(): Vector4i { return _C(this, -11, undefined) as Vector4i; }
-
-    /**
-     * Returns the same value as if the `+` was not there. Unary `+` does nothing, but sometimes it can make your code more readable.
-     */
-    pos(): Vector4i { return _C(this, -12, undefined) as Vector4i; }
-
-    not(): boolean { return _C(this, -24, undefined) as boolean; }
-
-    /**
-     * Multiplies each component of the {@link Vector4i} by the given {@link int}.
-     */
-    mul(other: number | Vector4i): Vector4i { return _C(this, -9, other) as Vector4i; }
-
-    /**
-     * Divides each component of the {@link Vector4i} by the given {@link int}.
-     */
-    div(other: number | Vector4i): Vector4i { return _C(this, -10, other) as Vector4i; }
-
-    /**
-     * Gets the remainder of each component of the {@link Vector4i} with the given {@link int}. This operation uses truncated division, which is often not desired as it does not work well with negative numbers. Consider using {@link posmod} instead if you want to handle negative numbers.
-     *
-     * ```text
-     *
-     * print(Vector4i(10, -20, 30, -40) % 7) # Prints (3, -6, 2, -5)
-     *
-     * ```
-     */
-    mod(other: number | Vector4i): Vector4i { return _C(this, -13, other) as Vector4i; }
-
-    /**
-     * Compares two {@link Vector4i} vectors by first checking if the X value of the left vector is less than the X value of the `right` vector. If the X values are exactly equal, then it repeats this check with the Y values of the two vectors, Z values of the two vectors, and then with the W values. This operator is useful for sorting vectors.
-     */
-    lessThan(other: Vector4i): boolean { return _C(this, -3, other) as boolean; }
-
-    /**
-     * Compares two {@link Vector4i} vectors by first checking if the X value of the left vector is less than or equal to the X value of the `right` vector. If the X values are exactly equal, then it repeats this check with the Y values of the two vectors, Z values of the two vectors, and then with the W values. This operator is useful for sorting vectors.
-     */
-    lessThanOrEqual(other: Vector4i): boolean { return _C(this, -4, other) as boolean; }
-
-    /**
-     * Compares two {@link Vector4i} vectors by first checking if the X value of the left vector is greater than the X value of the `right` vector. If the X values are exactly equal, then it repeats this check with the Y values of the two vectors, Z values of the two vectors, and then with the W values. This operator is useful for sorting vectors.
-     */
-    greaterThan(other: Vector4i): boolean { return _C(this, -5, other) as boolean; }
-
-    /**
-     * Compares two {@link Vector4i} vectors by first checking if the X value of the left vector is greater than or equal to the X value of the `right` vector. If the X values are exactly equal, then it repeats this check with the Y values of the two vectors, Z values of the two vectors, and then with the W values. This operator is useful for sorting vectors.
-     */
-    greaterThanOrEqual(other: Vector4i): boolean { return _C(this, -6, other) as boolean; }
-
-    /**
-     * Adds each component of the {@link Vector4i} by the components of the given {@link Vector4i}.
-     *
-     * ```text
-     *
-     * print(Vector4i(10, 20, 30, 40) + Vector4i(3, 4, 5, 6)) # Prints (13, 24, 35, 46)
-     *
-     * ```
-     */
-    add(other: Vector4i): Vector4i { return _C(this, -7, other) as Vector4i; }
-
-    /**
-     * Subtracts each component of the {@link Vector4i} by the components of the given {@link Vector4i}.
-     *
-     * ```text
-     *
-     * print(Vector4i(10, 20, 30, 40) - Vector4i(3, 4, 5, 6)) # Prints (7, 16, 25, 34)
-     *
-     * ```
-     */
-    sub(other: Vector4i): Vector4i { return _C(this, -8, other) as Vector4i; }
-
-    contains(other: GodotDictionary | GodotArray): boolean { return _C(this, -25, other) as boolean; }
-
-    static readonly name = _R(13, Vector4i);
-}
+export type Vector4i = [x: number, y: number, z: number, w: number];
+
+/**
+ * Returns the axis of the vector's lowest value. See `AXIS_*` constants. If all components are equal, this method returns {@link AXIS_W}.
+ */
+export function minAxisIndex(self: Vector4i): number { return _V(13, 8911, self) as number; }
+
+/**
+ * Returns the axis of the vector's highest value. See `AXIS_*` constants. If all components are equal, this method returns {@link AXIS_X}.
+ */
+export function maxAxisIndex(self: Vector4i): number { return _V(13, 8806, self) as number; }
+
+/**
+ * Returns the length (magnitude) of this vector.
+ */
+export function length(self: Vector4i): number { return _V(13, 8546, self) as number; }
+
+/**
+ * Returns the squared length (squared magnitude) of this vector.
+ * This method runs faster than {@link length}, so prefer it if you need to compare vectors or need the squared distance for some formula.
+ */
+export function lengthSquared(self: Vector4i): number { return _V(13, 8547, self) as number; }
+
+/**
+ * Returns a new vector with each component set to `1` if it's positive, `-1` if it's negative, and `0` if it's zero. The result is identical to calling {@link sign} on each component.
+ */
+export function sign(self: Vector4i): Vector4i { return _V(13, 13597, self) as Vector4i; }
+
+/**
+ * Returns a new vector with all components in absolute values (i.e. positive).
+ */
+export function abs(self: Vector4i): Vector4i { return _V(13, 1053, self) as Vector4i; }
+
+/**
+ * Returns a new vector with all components clamped between the components of `min` and `max`, by running {@link clamp} on each component.
+ */
+export function clamp(self: Vector4i, min: Vector4i, max: Vector4i): Vector4i { return _V(13, 2202, self, min, max) as Vector4i; }
+
+/**
+ * Returns a new vector with all components clamped between `min` and `max`, by running {@link clamp} on each component.
+ */
+export function clampi(self: Vector4i, min: number, max: number): Vector4i { return _V(13, 2206, self, min, max) as Vector4i; }
+
+/**
+ * Returns a new vector with each component snapped to the closest multiple of the corresponding component in `step`.
+ */
+export function snapped(self: Vector4i, step: Vector4i): Vector4i { return _V(13, 13674, self, step) as Vector4i; }
+
+/**
+ * Returns a new vector with each component snapped to the closest multiple of `step`.
+ */
+export function snappedi(self: Vector4i, step: number): Vector4i { return _V(13, 13676, self, step) as Vector4i; }
+
+/**
+ * Returns the component-wise minimum of this and `with`, equivalent to `Vector4i(mini(x, with.x), mini(y, with.y), mini(z, with.z), mini(w, with.w))`.
+ */
+export function min(self: Vector4i, _with: Vector4i): Vector4i { return _V(13, 8910, self, _with) as Vector4i; }
+
+/**
+ * Returns the component-wise minimum of this and `with`, equivalent to `Vector4i(mini(x, with), mini(y, with), mini(z, with), mini(w, with))`.
+ */
+export function mini(self: Vector4i, _with: number): Vector4i { return _V(13, 8922, self, _with) as Vector4i; }
+
+/**
+ * Returns the component-wise maximum of this and `with`, equivalent to `Vector4i(maxi(x, with.x), maxi(y, with.y), maxi(z, with.z), maxi(w, with.w))`.
+ */
+export function max(self: Vector4i, _with: Vector4i): Vector4i { return _V(13, 8804, self, _with) as Vector4i; }
+
+/**
+ * Returns the component-wise maximum of this and `with`, equivalent to `Vector4i(maxi(x, with), maxi(y, with), maxi(z, with), maxi(w, with))`.
+ */
+export function maxi(self: Vector4i, _with: number): Vector4i { return _V(13, 8840, self, _with) as Vector4i; }
+
+/**
+ * Returns the [Euclidean distance](https://en.wikipedia.org/wiki/Euclidean_distance) between this vector and `to`.
+ */
+export function distanceTo(self: Vector4i, to: Vector4i): number { return _V(13, 2850, self, to) as number; }
+
+/**
+ * Returns the squared [Euclidean distance](https://en.wikipedia.org/wiki/Euclidean_distance) between this vector and `to`.
+ * This method runs faster than {@link distanceTo}, so prefer it if you need to compare vectors or need the squared distance for some formula.
+ */
+export function distanceSquaredTo(self: Vector4i, to: Vector4i): number { return _V(13, 2849, self, to) as number; }
+
+export function equals(a: Vector4i, b: Variant | Vector4i): boolean { return _V(13, -1, a, b) as boolean; }
+
+export function notEquals(a: Vector4i, b: Variant | Vector4i): boolean { return _V(13, -2, a, b) as boolean; }
+
+/**
+ * Returns the negative value of the {@link Vector4i}. This is the same as writing `Vector4i(-v.x, -v.y, -v.z, -v.w)`. This operation flips the direction of the vector while keeping the same magnitude.
+ */
+export function neg(self: Vector4i): Vector4i { return _V(13, -11, self, undefined) as Vector4i; }
+
+/**
+ * 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: Vector4i): Vector4i { return _V(13, -12, self, undefined) as Vector4i; }
+
+export function not(self: Vector4i): boolean { return _V(13, -24, self, undefined) as boolean; }
+
+/**
+ * Multiplies each component of the {@link Vector4i} by the given {@link int}.
+ */
+export function mul(a: Vector4i, b: number | Vector4i): Vector4i { return _V(13, -9, a, b) as Vector4i; }
+
+/**
+ * Divides each component of the {@link Vector4i} by the given {@link int}.
+ */
+export function div(a: Vector4i, b: number | Vector4i): Vector4i { return _V(13, -10, a, b) as Vector4i; }
+
+/**
+ * Gets the remainder of each component of the {@link Vector4i} with the given {@link int}. This operation uses truncated division, which is often not desired as it does not work well with negative numbers. Consider using {@link posmod} instead if you want to handle negative numbers.
+ *
+ * ```text
+ *
+ * print(Vector4i(10, -20, 30, -40) % 7) # Prints (3, -6, 2, -5)
+ *
+ * ```
+ */
+export function mod(a: Vector4i, b: number | Vector4i): Vector4i { return _V(13, -13, a, b) as Vector4i; }
+
+/**
+ * Compares two {@link Vector4i} vectors by first checking if the X value of the left vector is less than the X value of the `right` vector. If the X values are exactly equal, then it repeats this check with the Y values of the two vectors, Z values of the two vectors, and then with the W values. This operator is useful for sorting vectors.
+ */
+export function lessThan(a: Vector4i, b: Vector4i): boolean { return _V(13, -3, a, b) as boolean; }
+
+/**
+ * Compares two {@link Vector4i} vectors by first checking if the X value of the left vector is less than or equal to the X value of the `right` vector. If the X values are exactly equal, then it repeats this check with the Y values of the two vectors, Z values of the two vectors, and then with the W values. This operator is useful for sorting vectors.
+ */
+export function lessThanOrEqual(a: Vector4i, b: Vector4i): boolean { return _V(13, -4, a, b) as boolean; }
+
+/**
+ * Compares two {@link Vector4i} vectors by first checking if the X value of the left vector is greater than the X value of the `right` vector. If the X values are exactly equal, then it repeats this check with the Y values of the two vectors, Z values of the two vectors, and then with the W values. This operator is useful for sorting vectors.
+ */
+export function greaterThan(a: Vector4i, b: Vector4i): boolean { return _V(13, -5, a, b) as boolean; }
+
+/**
+ * Compares two {@link Vector4i} vectors by first checking if the X value of the left vector is greater than or equal to the X value of the `right` vector. If the X values are exactly equal, then it repeats this check with the Y values of the two vectors, Z values of the two vectors, and then with the W values. This operator is useful for sorting vectors.
+ */
+export function greaterThanOrEqual(a: Vector4i, b: Vector4i): boolean { return _V(13, -6, a, b) as boolean; }
+
+/**
+ * Adds each component of the {@link Vector4i} by the components of the given {@link Vector4i}.
+ *
+ * ```text
+ *
+ * print(Vector4i(10, 20, 30, 40) + Vector4i(3, 4, 5, 6)) # Prints (13, 24, 35, 46)
+ *
+ * ```
+ */
+export function add(a: Vector4i, b: Vector4i): Vector4i { return _V(13, -7, a, b) as Vector4i; }
+
+/**
+ * Subtracts each component of the {@link Vector4i} by the components of the given {@link Vector4i}.
+ *
+ * ```text
+ *
+ * print(Vector4i(10, 20, 30, 40) - Vector4i(3, 4, 5, 6)) # Prints (7, 16, 25, 34)
+ *
+ * ```
+ */
+export function sub(a: Vector4i, b: Vector4i): Vector4i { return _V(13, -8, a, b) as Vector4i; }
+
+export function contains(a: Vector4i, b: GodotDictionary | GodotArray): boolean { return _V(13, -25, a, b) as boolean; }
+
+/**
+ * Constructs a default-initialized {@link Vector4i} with all components set to `0`.
+ */
+export function create(): Vector4i { return _V(13, -4096, 0) as Vector4i; }
+
+/**
+ * Constructs a {@link Vector4i} as a copy of the given {@link Vector4i}.
+ */
+export function fromVector4i(from: Vector4i): Vector4i { return _V(13, -4096, 1, from) as Vector4i; }
+
+/**
+ * Constructs a new {@link Vector4i} from the given {@link Vector4} by truncating components' fractional parts (rounding towards zero). For a different behavior consider passing the result of {@link Vector4.ceil}, {@link Vector4.floor} or {@link Vector4.round} to this constructor instead.
+ */
+export function fromVector4(from: Vector4): Vector4i { return _V(13, -4096, 2, from) as Vector4i; }
+
+/**
+ * Returns a {@link Vector4i} with the given components.
+ */
+export function fromXYZW(x: number, y: number, z: number, w: number): Vector4i { return _V(13, -4096, 3, x, y, z, w) as Vector4i; }
+

package/gen/value-types/index.ts

@@ -1,19 +1,19 @@
 // Auto-generated from extension_api.json - DO NOT EDIT
 // Generated by dev/codegen.ts
 
-export * from './Vector2.ts';
-export * from './Vector2i.ts';
-export * from './Rect2.ts';
-export * from './Rect2i.ts';
-export * from './Vector3.ts';
-export * from './Vector3i.ts';
-export * from './Transform2D.ts';
-export * from './Vector4.ts';
-export * from './Vector4i.ts';
-export * from './Plane.ts';
-export * from './Quaternion.ts';
-export * from './AABB.ts';
-export * from './Basis.ts';
-export * from './Transform3D.ts';
-export * from './Projection.ts';
-export * from './Color.ts';
+export type { Vector2 } from './Vector2.ts';
+export type { Vector2i } from './Vector2i.ts';
+export type { Rect2 } from './Rect2.ts';
+export type { Rect2i } from './Rect2i.ts';
+export type { Vector3 } from './Vector3.ts';
+export type { Vector3i } from './Vector3i.ts';
+export type { Transform2D } from './Transform2D.ts';
+export type { Vector4 } from './Vector4.ts';
+export type { Vector4i } from './Vector4i.ts';
+export type { Plane } from './Plane.ts';
+export type { Quaternion } from './Quaternion.ts';
+export type { AABB } from './AABB.ts';
+export type { Basis } from './Basis.ts';
+export type { Transform3D } from './Transform3D.ts';
+export type { Projection } from './Projection.ts';
+export type { Color } from './Color.ts';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ringozz/godot",
   "author": "Vladimir Davidovich",
-  "version": "4.7.2-583",
+  "version": "4.7.2-592",
   "description": "Node-API bindings for Godot Engine — call Godot classes from JavaScript",
   "publishConfig": {
     "access": "public"
@@ -25,6 +25,22 @@
     "./load": "./src/load.ts",
     "./debug": "./src/debug.ts",
     "./preload": "./src/preload.ts",
+    "./AABB": "./gen/value-types/AABB.ts",
+    "./Basis": "./gen/value-types/Basis.ts",
+    "./Color": "./gen/value-types/Color.ts",
+    "./Plane": "./gen/value-types/Plane.ts",
+    "./Projection": "./gen/value-types/Projection.ts",
+    "./Quaternion": "./gen/value-types/Quaternion.ts",
+    "./Rect2": "./gen/value-types/Rect2.ts",
+    "./Rect2i": "./gen/value-types/Rect2i.ts",
+    "./Transform2D": "./gen/value-types/Transform2D.ts",
+    "./Transform3D": "./gen/value-types/Transform3D.ts",
+    "./Vector2": "./gen/value-types/Vector2.ts",
+    "./Vector2i": "./gen/value-types/Vector2i.ts",
+    "./Vector3": "./gen/value-types/Vector3.ts",
+    "./Vector3i": "./gen/value-types/Vector3i.ts",
+    "./Vector4": "./gen/value-types/Vector4.ts",
+    "./Vector4i": "./gen/value-types/Vector4i.ts",
     "./*": "./gen/classes/*.ts"
   },
   "files": [
@@ -42,9 +58,9 @@
     "precision": "single"
   },
   "optionalDependencies": {
-    "@ringozz/godot-macos-arm64": "^4.7.2-583",
-    "@ringozz/godot-windows-x86_64": "^4.7.2-583",
-    "@ringozz/godot-web-wasm32": "^4.7.2-583"
+    "@ringozz/godot-macos-arm64": "^4.7.2-592",
+    "@ringozz/godot-windows-x86_64": "^4.7.2-592",
+    "@ringozz/godot-web-wasm32": "^4.7.2-592"
   },
   "peerDependencies": {
     "@types/bun": "*"

package/src/debug.ts

@@ -2,7 +2,7 @@
  Copyright (c) Vladimir Davidovich. All rights reserved.
 ***********************************************************************/
 
-import { MouseButton, Rect2, str, varToStr, Vector2, Vector3 } from './index.ts';
+import { MouseButton, str, varToStr } from './index.ts';
 import { CanvasItem } from '../gen/classes/CanvasItem.ts';
 import { ClassDB } from '../gen/classes/ClassDB.ts';
 import { Control } from '../gen/classes/Control.ts';
@@ -14,6 +14,7 @@ import { Node3D } from '../gen/classes/Node3D.ts';
 import { OS } from '../gen/classes/OS.ts';
 import { SceneTree } from '../gen/classes/SceneTree.ts';
 import { Time } from '../gen/classes/Time.ts';
+import type { Vector2 } from '../gen/value-types/Vector2.ts';
 import type { Viewport } from '../gen/classes/Viewport.ts';
 import type { Window } from '../gen/classes/Window.ts';
 
@@ -108,10 +109,10 @@ export function click(path: string): string | null {
     if (!(node instanceof Control)) return null;
     const rect = node.getGlobalRect();
     const scale = root.contentScaleFactor;
-    const position = new Vector2(
-        (rect.position.x + rect.size.x / 2) * scale,
-        (rect.position.y + rect.size.y / 2) * scale,
-    );
+    const position: Vector2 = [
+        (rect[0] + rect[2] / 2) * scale,
+        (rect[1] + rect[3] / 2) * scale,
+    ];
     const press = (down: boolean) => {
         const event = new InputEventMouseButton();
         event.position = position;
@@ -186,9 +187,10 @@ type BoundsCollect = (node: any, push: Push, viewport: Viewport) => void;
 
 /** Affine 2D point mapper from a transform's basis/origin, optionally scaled. */
 function makeAffine(t: any, scale = 1): (x: number, y: number) => [number, number] {
-    const tox = t.origin.x, toy = t.origin.y;
-    const txx = t.x.x, txy = t.x.y;
-    const tyx = t.y.x, tyy = t.y.y;
+    const [tx, ty, to] = t;
+    const tox = to[0], toy = to[1];
+    const txx = tx[0], txy = tx[1];
+    const tyx = ty[0], tyy = ty[1];
     return (x, y) => [(tox + txx * x + tyx * y) * scale, (toy + txy * x + tyy * y) * scale];
 }
 
@@ -215,18 +217,19 @@ function cssBounds(): { add(x: number, y: number): void; rect(): [number, number
 
 /** World-space AABB (min, max) of a local AABB under its global transform, or `null` when degenerate. */
 function worldAabb(aabb: any, gt: any): [number, number, number, number, number, number] | null {
-    if (aabb.size.x === 0 && aabb.size.y === 0 && aabb.size.z === 0) return null;
-    const bx = gt.basis.x, by = gt.basis.y, bz = gt.basis.z;
-    const cx = aabb.position.x + aabb.size.x / 2;
-    const cy = aabb.position.y + aabb.size.y / 2;
-    const cz = aabb.position.z + aabb.size.z / 2;
-    const ex = Math.hypot(bx.x, bx.y, bx.z) * aabb.size.x / 2;
-    const ey = Math.hypot(by.x, by.y, by.z) * aabb.size.y / 2;
-    const ez = Math.hypot(bz.x, bz.y, bz.z) * aabb.size.z / 2;
-    const ox = gt.origin.x, oy = gt.origin.y, oz = gt.origin.z;
-    const wx = ox + bx.x * cx + by.x * cy + bz.x * cz;
-    const wy = oy + bx.y * cx + by.y * cy + bz.y * cz;
-    const wz = oz + bx.z * cx + by.z * cy + bz.z * cz;
+    const [position, size] = aabb;
+    const [bx, by, bz, origin] = gt;
+    if (size[0] === 0 && size[1] === 0 && size[2] === 0) return null;
+    const cx = position[0] + size[0] / 2;
+    const cy = position[1] + size[1] / 2;
+    const cz = position[2] + size[2] / 2;
+    const ex = Math.hypot(bx[0], bx[1], bx[2]) * size[0] / 2;
+    const ey = Math.hypot(by[0], by[1], by[2]) * size[1] / 2;
+    const ez = Math.hypot(bz[0], bz[1], bz[2]) * size[2] / 2;
+    const ox = origin[0], oy = origin[1], oz = origin[2];
+    const wx = ox + bx[0] * cx + by[0] * cy + bz[0] * cz;
+    const wy = oy + bx[1] * cx + by[1] * cy + bz[1] * cz;
+    const wz = oz + bx[2] * cx + by[2] * cy + bz[2] * cz;
     return [wx - ex, wy - ey, wz - ez, wx + ex, wy + ey, wz + ez];
 }
 
@@ -299,14 +302,14 @@ function pushRect(emit: (x: number, y: number) => void, x0: number, y0: number,
 
 const canvasItemBounds: BoundsCollect = (node, push) => {
     if (node instanceof Control) {
-        const rc = node.getGlobalRect();
-        pushRect(push, rc.position.x, rc.position.y, rc.position.x + rc.size.x, rc.position.y + rc.size.y);
+        const [x, y, w, h] = node.getGlobalRect();
+        pushRect(push, x, y, x + w, y + h);
         return;
     }
     if (typeof node.getRect !== 'function') return;
-    const rect = node.getRect() as Rect2;
+    const [x, y, w, h] = node.getRect() as [number, number, number, number];
     const xform = makeAffine(node.getScreenTransform());
-    pushRect((px, py) => push(...xform(px, py)), rect.position.x, rect.position.y, rect.position.x + rect.size.x, rect.position.y + rect.size.y);
+    pushRect((px, py) => push(...xform(px, py)), x, y, x + w, y + h);
 };
 
 const node3dBounds: BoundsCollect = (node, push, viewport) => {
@@ -316,12 +319,12 @@ const node3dBounds: BoundsCollect = (node, push, viewport) => {
     if (!box) return;
     const [minX, minY, minZ, maxX, maxY, maxZ] = box;
     for (let i = 0; i < 8; i++) {
-        const s = camera.unprojectPosition(new Vector3(
+        const s = camera.unprojectPosition([
             i & 1 ? maxX : minX,
             i & 2 ? maxY : minY,
             i & 4 ? maxZ : minZ,
-        ));
-        push(s.x, s.y);
+        ]);
+        push(s[0], s[1]);
     }
 };
 

package/src/index.ts

@@ -3,7 +3,6 @@
 ***********************************************************************/
 
 export * from '../gen/index.ts';
-import * as ValueTypes from '../gen/value-types/index.ts';
 import * as HeapTypes from '../gen/heap-types/index.ts';
 import { Engine } from '../gen/classes/Engine.ts';
 import { GodotInstance } from '../gen/classes/GodotInstance.ts';
@@ -13,7 +12,6 @@ import { gc } from './debug.ts';
 import { cancelAnimationFrame, cleanupHooks, getGodot, requestAnimationFrame } from './runtime.ts';
 
 // ---- make sure these classes are not tree-shaked ----
-void ValueTypes;
 void HeapTypes;
 void GodotInstance;
 void SceneTree;