@ringozz/godot 0.1.0

package/gen/classes/Node2D.ts

@@ -0,0 +1,150 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { CanvasItem } from './CanvasItem.ts';
+import type { Transform2D, Vector2 } from '../value-types/index.ts';
+import type { Node } from './Node.ts';
+
+/**
+ * A 2D game object, with a transform (position, rotation, and scale). All 2D nodes, including physics objects and sprites, inherit from Node2D. Use Node2D as a parent node to move, scale and rotate children in a 2D project. Also gives control of the node's render order.
+ * **Note:** Since both {@link Node2D} and {@link Control} inherit from {@link CanvasItem}, they share several concepts from the class such as the {@link CanvasItem.zIndex} and {@link CanvasItem.visible} properties.
+ */
+export class Node2D extends CanvasItem {
+    constructor(name = 457) { super(name); }
+
+    /**
+     * Applies a rotation to the node, in radians, starting from its current rotation. This is equivalent to `rotation += radians`.
+     */
+    rotate(radians: number): void { _C(this, 10136, radians); }
+
+    /**
+     * Applies a local translation on the node's X axis with the amount specified in `delta`. If `scaled` is `false`, normalizes the movement to occur independently of the node's {@link scale}.
+     */
+    moveLocalX(delta: number, scaled?: boolean /* = false */): void { _C(this, 8988, delta, scaled); }
+
+    /**
+     * Applies a local translation on the node's Y axis with the amount specified in `delta`. If `scaled` is `false`, normalizes the movement to occur independently of the node's {@link scale}.
+     */
+    moveLocalY(delta: number, scaled?: boolean /* = false */): void { _C(this, 8989, delta, scaled); }
+
+    /**
+     * Translates the node by the given `offset` in local coordinates. This is equivalent to `position += offset`.
+     */
+    translate(offset: Vector2): void { _C(this, 14395, offset); }
+
+    /**
+     * Adds the `offset` vector to the node's global position.
+     */
+    globalTranslate(offset: Vector2): void { _C(this, 7260, offset); }
+
+    /**
+     * Multiplies the current scale by the `ratio` vector.
+     */
+    applyScale(ratio: Vector2): void { _C(this, 1535, ratio); }
+
+    /**
+     * Rotates the node so that its local +X axis points towards the `point`, which is expected to use global coordinates. This method is a combination of both {@link rotate} and {@link getAngleTo}.
+     * `point` should not be the same as the node's position, otherwise the node always looks to the right.
+     */
+    lookAt(point: Vector2): void { _C(this, 8706, point); }
+
+    /**
+     * Returns the angle between the node and the `point` in radians. See also {@link lookAt}.
+     * [Illustration of the returned angle.](https://raw.githubusercontent.com/godotengine/godot-docs/master/img/node2d_get_angle_to.png)
+     */
+    getAngleTo(point: Vector2): number { return _C(this, 3750, point) as number; }
+
+    /**
+     * Transforms the provided global position into a position in local coordinate space. The output will be local relative to the {@link Node2D} it is called on. e.g. It is appropriate for determining the positions of child nodes, but it is not appropriate for determining its own position relative to its parent.
+     */
+    toLocal(globalPoint: Vector2): Vector2 { return _C(this, 14302, globalPoint) as Vector2; }
+
+    /**
+     * Transforms the provided local position into a position in global coordinate space. The input is expected to be local relative to the {@link Node2D} it is called on. e.g. Applying this method to the positions of child nodes will correctly transform their positions into the global coordinate space, but applying it to a node's own position will give an incorrect result, as it will incorporate the node's own transformation into its global position.
+     */
+    toGlobal(localPoint: Vector2): Vector2 { return _C(this, 14296, localPoint) as Vector2; }
+
+    /**
+     * Returns the {@link Transform2D} relative to this node's parent.
+     */
+    getRelativeTransformToParent(parent: Node): Transform2D { return _C(this, 6119, parent) as Transform2D; }
+
+    /**
+     * Position, relative to the node's parent. See also {@link globalPosition}.
+     */
+    get position(): Vector2 { return _C(this, 5973) as Vector2; }
+    set position(v: Vector2) { _C(this, 12381, v); }
+
+    /**
+     * Rotation in radians, relative to the node's parent. See also {@link globalRotation}.
+     * **Note:** This property is edited in the inspector in degrees. If you want to use degrees in a script, use {@link rotationDegrees}.
+     */
+    get rotation(): number { return _C(this, 6204) as number; }
+    set rotation(v: number) { _C(this, 12577, v); }
+
+    /**
+     * Helper property to access {@link rotation} in degrees instead of radians. See also {@link globalRotationDegrees}.
+     */
+    get rotationDegrees(): number { return _C(this, 6209) as number; }
+    set rotationDegrees(v: number) { _C(this, 12582, v); }
+
+    /**
+     * The node's scale, relative to the node's parent. Unscaled value: `(1, 1)`. See also {@link globalScale}.
+     * **Note:** Negative X scales in 2D are not decomposable from the transformation matrix. Due to the way scale is represented with transformation matrices in Godot, negative scales on the X axis will be changed to negative scales on the Y axis and a rotation of 180 degrees when decomposed.
+     */
+    get scale(): Vector2 { return _C(this, 6236) as Vector2; }
+    set scale(v: Vector2) { _C(this, 12608, v); }
+
+    /**
+     * If set to a non-zero value, slants the node in one direction or another. This can be used for pseudo-3D effects. See also {@link globalSkew}.
+     * **Note:** Skew is performed on the X axis only, and *between* rotation and scaling.
+     * **Note:** This property is edited in the inspector in degrees. If you want to use degrees in a script, use `skew = deg_to_rad(value_in_degrees)`.
+     */
+    get skew(): number { return _C(this, 6411) as number; }
+    set skew(v: number) { _C(this, 12762, v); }
+
+    /**
+     * The node's {@link Transform2D}, relative to the node's parent. See also {@link globalTransform}.
+     */
+    get transform(): Transform2D { return _C(this, 6874) as Transform2D; }
+    set transform(v: Transform2D) { _C(this, 13134, v); }
+
+    /**
+     * Global position. See also {@link position}.
+     */
+    get globalPosition(): Vector2 { return _C(this, 4929) as Vector2; }
+    set globalPosition(v: Vector2) { _C(this, 11517, v); }
+
+    /**
+     * Global rotation in radians. See also {@link rotation}.
+     */
+    get globalRotation(): number { return _C(this, 4931) as number; }
+    set globalRotation(v: number) { _C(this, 11518, v); }
+
+    /**
+     * Helper property to access {@link globalRotation} in degrees instead of radians. See also {@link rotationDegrees}.
+     */
+    get globalRotationDegrees(): number { return _C(this, 4932) as number; }
+    set globalRotationDegrees(v: number) { _C(this, 11519, v); }
+
+    /**
+     * Global scale. See also {@link scale}.
+     */
+    get globalScale(): Vector2 { return _C(this, 4933) as Vector2; }
+    set globalScale(v: Vector2) { _C(this, 11520, v); }
+
+    /**
+     * Global skew in radians. See also {@link skew}.
+     */
+    get globalSkew(): number { return _C(this, 4934) as number; }
+    set globalSkew(v: number) { _C(this, 11521, v); }
+
+    /**
+     * Global {@link Transform2D}. See also {@link transform}.
+     */
+    get globalTransform(): Transform2D { return _C(this, 4936) as Transform2D; }
+    set globalTransform(v: Transform2D) { _C(this, 11523, v); }
+
+    static readonly name = _R(457, Node2D);
+}

package/gen/classes/Node3D.ts

@@ -0,0 +1,404 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { Node } from './Node.ts';
+import type { EulerOrder } from '../global-enums.ts';
+import type { GodotArray, NodePath, Signal } from '../heap-types/index.ts';
+import type { Basis, Quaternion, Transform3D, Vector3 } from '../value-types/index.ts';
+import type { Node3DGizmo } from './Node3DGizmo.ts';
+import type { World3D } from './World3D.ts';
+
+/**
+ * The {@link Node3D} node is the base representation of a node in 3D space. All other 3D nodes inherit from this class.
+ * Affine operations (translation, rotation, scale) are calculated in the coordinate system relative to the parent, unless the {@link Node3D}'s {@link topLevel} is `true`. In this coordinate system, affine operations correspond to direct affine operations on the {@link Node3D}'s {@link transform}. The term *parent space* refers to this coordinate system. The coordinate system that is attached to the {@link Node3D} itself is referred to as object-local coordinate system, or *local space*.
+ * **Note:** Unless otherwise specified, all methods that need angle parameters must receive angles in *radians*. To convert degrees to radians, use {@link degToRad}.
+ * **Note:** In Godot 3 and older, {@link Node3D} was named *Spatial*.
+ */
+export class Node3D extends Node {
+    constructor(name = 458) { super(name); }
+
+    /**
+     * When using physics interpolation, there will be circumstances in which you want to know the interpolated (displayed) transform of a node rather than the standard transform (which may only be accurate to the most recent physics tick).
+     * This is particularly important for frame-based operations that take place in {@link Node.Process}, rather than {@link Node.PhysicsProcess}. Examples include {@link Camera3D}s focusing on a node, or finding where to fire lasers from on a frame rather than physics tick.
+     * **Note:** This function creates an interpolation pump on the {@link Node3D} the first time it is called, which can respond to physics interpolation resets. If you get problems with "streaking" when initially following a {@link Node3D}, be sure to call {@link getGlobalTransformInterpolated} at least once *before* resetting the {@link Node3D} physics interpolation.
+     */
+    getGlobalTransformInterpolated(): Transform3D { return _C(this, 4937) as Transform3D; }
+
+    /**
+     * Returns the parent {@link Node3D} that directly affects this node's {@link globalTransform}. Returns `null` if no parent exists, the parent is not a {@link Node3D}, or {@link topLevel} is `true`.
+     * **Note:** This method is not always equivalent to {@link Node.getParent}, which does not take {@link topLevel} into account.
+     */
+    getParentNode3d(): Node3D | null { return _C(this, 5824) as Node3D | null; }
+
+    /**
+     * If `true`, the node will not receive {@link NOTIFICATION_TRANSFORM_CHANGED} or {@link NOTIFICATION_LOCAL_TRANSFORM_CHANGED}.
+     * It may useful to call this method when handling these notifications to prevent infinite recursion.
+     */
+    setIgnoreTransformNotification(enabled: boolean): void { _C(this, 11669, enabled); }
+
+    /**
+     * If `true`, this node's {@link globalTransform} is automatically orthonormalized. This results in this node not appearing distorted, as if its global scale were set to {@link Vector3.ONE} (or its negative counterpart). See also {@link isScaleDisabled} and {@link orthonormalize}.
+     * **Note:** {@link transform} is not affected by this setting.
+     */
+    setDisableScale(disable: boolean): void { _C(this, 11120, disable); }
+
+    /**
+     * Returns `true` if this node's {@link globalTransform} is automatically orthonormalized. This results in this node not appearing distorted, as if its global scale were set to {@link Vector3.ONE} (or its negative counterpart). See also {@link setDisableScale} and {@link orthonormalize}.
+     * **Note:** {@link transform} is not affected by this setting.
+     */
+    isScaleDisabled(): boolean { return _C(this, 8267) as boolean; }
+
+    /**
+     * Returns the {@link World3D} this node is registered to.
+     * Usually, this is the same as the world used by this node's viewport (see {@link Node.getViewport} and {@link Viewport.findWorld3d}).
+     */
+    getWorld3d(): World3D { return _C(this, 7161) as World3D; }
+
+    /**
+     * Forces the node's {@link globalTransform} to update, by sending {@link NOTIFICATION_TRANSFORM_CHANGED}. Fails if the node is not inside the tree.
+     * **Note:** For performance reasons, transform changes are usually accumulated and applied *once* at the end of the frame. The update propagates through {@link Node3D} children, as well. Therefore, use this method only when you need an up-to-date transform (such as during physics operations).
+     */
+    forceUpdateTransform(): void { _C(this, 3543); }
+
+    /**
+     * Updates all the {@link EditorNode3DGizmo} objects attached to this node. Only works in the editor.
+     */
+    updateGizmos(): void { _C(this, 14515); }
+
+    /**
+     * Attaches the given `gizmo` to this node. Only works in the editor.
+     * **Note:** `gizmo` should be an {@link EditorNode3DGizmo}. The argument type is {@link Node3DGizmo} to avoid depending on editor classes in {@link Node3D}.
+     */
+    addGizmo(gizmo: Node3DGizmo): void { _C(this, 1223, gizmo); }
+
+    /**
+     * Returns all the {@link EditorNode3DGizmo} objects attached to this node. Only works in the editor.
+     */
+    getGizmos(): GodotArray<Node3DGizmo> { return _C(this, 4921) as GodotArray<Node3DGizmo>; }
+
+    /**
+     * Clears all {@link EditorNode3DGizmo} objects attached to this node. Only works in the editor.
+     */
+    clearGizmos(): void { _C(this, 2270); }
+
+    /**
+     * Selects the `gizmo`'s subgizmo with the given `id` and sets its transform. Only works in the editor.
+     * **Note:** The gizmo object would typically be an instance of {@link EditorNode3DGizmo}, but the argument type is kept generic to avoid creating a dependency on editor classes in {@link Node3D}.
+     */
+    setSubgizmoSelection(gizmo: Node3DGizmo, id: number, transform: Transform3D): void { _C(this, 12927, gizmo, id, transform); }
+
+    /**
+     * Deselects all subgizmos for this node. Useful to call when the selected subgizmo may no longer exist after a property change. Only works in the editor.
+     */
+    clearSubgizmoSelection(): void { _C(this, 2299); }
+
+    /**
+     * Returns `true` if this node is inside the scene tree and the {@link visible} property is `true` for this node and all of its {@link Node3D} ancestors *in sequence*. An ancestor of any other type (such as {@link Node} or {@link Node2D}) breaks the sequence. See also {@link Node.getParent}.
+     * **Note:** This method cannot take {@link VisualInstance3D.layers} into account, so even if this method returns `true`, the node may not be rendered.
+     */
+    isVisibleInTree(): boolean { return _C(this, 8451) as boolean; }
+
+    /**
+     * Allows this node to be rendered. Equivalent to setting {@link visible} to `true`. This is the opposite of {@link hide}.
+     */
+    show(): void { _C(this, 13573); }
+
+    /**
+     * Prevents this node from being rendered. Equivalent to setting {@link visible} to `false`. This is the opposite of {@link show}.
+     */
+    hide(): void { _C(this, 7513); }
+
+    /**
+     * If `true`, the node will receive {@link NOTIFICATION_LOCAL_TRANSFORM_CHANGED} whenever {@link transform} changes.
+     * **Note:** Some 3D nodes such as {@link CSGShape3D} or {@link CollisionShape3D} automatically enable this to function correctly.
+     */
+    setNotifyLocalTransform(enable: boolean): void { _C(this, 12153, enable); }
+
+    /**
+     * Returns `true` if the node receives {@link NOTIFICATION_LOCAL_TRANSFORM_CHANGED} whenever {@link transform} changes. This is enabled with {@link setNotifyLocalTransform}.
+     */
+    isLocalTransformNotificationEnabled(): boolean { return _C(this, 8088) as boolean; }
+
+    /**
+     * If `true`, the node will receive {@link NOTIFICATION_TRANSFORM_CHANGED} whenever {@link globalTransform} changes.
+     * **Note:** Most 3D nodes such as {@link VisualInstance3D} or {@link CollisionObject3D} automatically enable this to function correctly.
+     * **Note:** In the editor, nodes will propagate this notification to their children if a gizmo is attached (see {@link addGizmo}).
+     */
+    setNotifyTransform(enable: boolean): void { _C(this, 12154, enable); }
+
+    /**
+     * Returns `true` if the node receives {@link NOTIFICATION_TRANSFORM_CHANGED} whenever {@link globalTransform} changes. This is enabled with {@link setNotifyTransform}.
+     */
+    isTransformNotificationEnabled(): boolean { return _C(this, 8371) as boolean; }
+
+    /**
+     * Rotates this node's {@link basis} around the `axis` by the given `angle`, in radians. This operation is calculated in parent space (relative to the parent) and preserves the {@link position}.
+     */
+    rotate(axis: Vector3, angle: number): void { _C(this, 10136, axis, angle); }
+
+    /**
+     * Rotates this node's {@link globalBasis} around the global `axis` by the given `angle`, in radians. This operation is calculated in global space (relative to the world) and preserves the {@link globalPosition}.
+     */
+    globalRotate(axis: Vector3, angle: number): void { _C(this, 7247, axis, angle); }
+
+    /**
+     * Scales this node's {@link globalBasis} by the given `scale` factor. This operation is calculated in global space (relative to the world) and preserves the {@link globalPosition}.
+     * **Note:** This method is not to be confused with the {@link scale} property.
+     */
+    globalScale(scale: Vector3): void { _C(this, 7250, scale); }
+
+    /**
+     * Adds the given translation `offset` to the node's {@link globalPosition} in global space (relative to the world).
+     */
+    globalTranslate(offset: Vector3): void { _C(this, 7260, offset); }
+
+    /**
+     * Rotates this node's {@link basis} around the `axis` by the given `angle`, in radians. This operation is calculated in local space (relative to this node) and preserves the {@link position}.
+     */
+    rotateObjectLocal(axis: Vector3, angle: number): void { _C(this, 10139, axis, angle); }
+
+    /**
+     * Scales this node's {@link basis} by the given `scale` factor. This operation is calculated in local space (relative to this node) and preserves the {@link position}.
+     */
+    scaleObjectLocal(scale: Vector3): void { _C(this, 10225, scale); }
+
+    /**
+     * Adds the given translation `offset` to the node's position, in local space (relative to this node).
+     */
+    translateObjectLocal(offset: Vector3): void { _C(this, 14396, offset); }
+
+    /**
+     * Rotates this node's {@link basis} around the X axis by the given `angle`, in radians. This operation is calculated in parent space (relative to the parent) and preserves the {@link position}.
+     */
+    rotateX(angle: number): void { _C(this, 10141, angle); }
+
+    /**
+     * Rotates this node's {@link basis} around the Y axis by the given `angle`, in radians. This operation is calculated in parent space (relative to the parent) and preserves the {@link position}.
+     */
+    rotateY(angle: number): void { _C(this, 10142, angle); }
+
+    /**
+     * Rotates this node's {@link basis} around the Z axis by the given `angle`, in radians. This operation is calculated in parent space (relative to the parent) and preserves the {@link position}.
+     */
+    rotateZ(angle: number): void { _C(this, 10143, angle); }
+
+    /**
+     * Adds the given translation `offset` to the node's position, in local space (relative to this node).
+     * **Note:** Prefer using {@link translateObjectLocal}, instead, as this method may be changed in a future release.
+     * **Note:** Despite the naming convention, this operation is **not** calculated in parent space for compatibility reasons. To translate in parent space, add `offset` to the {@link position} (`node_3d.position += offset`).
+     */
+    translate(offset: Vector3): void { _C(this, 14395, offset); }
+
+    /**
+     * Orthonormalizes this node's {@link basis}. This method sets this node's {@link scale} to {@link Vector3.ONE} (or its negative counterpart), but preserves the {@link position} and {@link rotation}. See also {@link Transform3D.orthonormalized}.
+     */
+    orthonormalize(): void { _C(this, 9229); }
+
+    /**
+     * Sets this node's {@link transform} to {@link Transform3D.IDENTITY}, which resets all transformations in parent space ({@link position}, {@link rotation}, and {@link scale}).
+     */
+    setIdentity(): void { _C(this, 11656); }
+
+    /**
+     * Rotates the node so that the local forward axis (-Z, {@link Vector3.FORWARD}) points toward the `target` position. This operation is calculated in global space (relative to the world).
+     * The local up axis (+Y) points as close to the `up` vector as possible while staying perpendicular to the local forward axis. The resulting transform is orthogonal, and the scale is preserved. Non-uniform scaling may not work correctly.
+     * The `target` position cannot be the same as the node's position, the `up` vector cannot be {@link Vector3.ZERO}. Furthermore, the direction from the node's position to the `target` position cannot be parallel to the `up` vector, to avoid an unintended rotation around the local Z axis.
+     * 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).
+     * **Note:** This method fails if the node is not in the scene tree. If necessary, use {@link lookAtFromPosition} instead.
+     */
+    lookAt(target: Vector3, up?: Vector3 /* = Vector3(0, 1, 0) */, useModelFront?: boolean /* = false */): void { _C(this, 8706, target, up, useModelFront); }
+
+    /**
+     * Moves the node to the specified `position`, then rotates the node to point toward the `target` position, similar to {@link lookAt}. This operation is calculated in global space (relative to the world).
+     */
+    lookAtFromPosition(position: Vector3, target: Vector3, up?: Vector3 /* = Vector3(0, 1, 0) */, useModelFront?: boolean /* = false */): void { _C(this, 8707, position, target, up, useModelFront); }
+
+    /**
+     * Returns the `globalPoint` converted from global space to this node's local space. This is the opposite of {@link toGlobal}.
+     */
+    toLocal(globalPoint: Vector3): Vector3 { return _C(this, 14302, globalPoint) as Vector3; }
+
+    /**
+     * Returns the `localPoint` converted from this node's local space to global space. This is the opposite of {@link toLocal}.
+     */
+    toGlobal(localPoint: Vector3): Vector3 { return _C(this, 14296, localPoint) as Vector3; }
+
+    /**
+     * The local transformation of this node, in parent space (relative to the parent node). Contains and represents this node's {@link position}, {@link rotation}, and {@link scale}.
+     */
+    get transform(): Transform3D { return _C(this, 6874) as Transform3D; }
+    set transform(v: Transform3D) { _C(this, 13134, v); }
+
+    /**
+     * The transformation of this node, in global space (relative to the world). Contains and represents this node's {@link globalPosition}, {@link globalRotation}, and global scale.
+     * **Note:** If the node is not inside the tree, getting this property fails and returns {@link Transform3D.IDENTITY}.
+     */
+    get globalTransform(): Transform3D { return _C(this, 4936) as Transform3D; }
+    set globalTransform(v: Transform3D) { _C(this, 11523, v); }
+
+    /**
+     * Position (translation) of this node in parent space (relative to the parent node). This is equivalent to the {@link transform}'s {@link Transform3D.origin}.
+     */
+    get position(): Vector3 { return _C(this, 5973) as Vector3; }
+    set position(v: Vector3) { _C(this, 12381, v); }
+
+    /**
+     * Rotation of this node as [Euler angles](https://en.wikipedia.org/wiki/Euler_angles), in radians and in parent space (relative to the parent node). This value is obtained from {@link basis}'s rotation.
+     * - The {@link Vector3.x} is the angle around the local X axis (pitch);
+     * - The {@link Vector3.y} is the angle around the local Y axis (yaw);
+     * - The {@link Vector3.z} is the angle around the local Z axis (roll).
+     * The order of each consecutive rotation can be changed with {@link rotationOrder} (see {@link EulerOrder} constants). In Godot, Euler angles always use intrinsic order. By default, the intrinsic YXZ convention is used ({@link EULER_ORDER_YXZ}).
+     * **Note:** This property is edited in degrees in the inspector. If you want to use degrees in a script, use {@link rotationDegrees}.
+     */
+    get rotation(): Vector3 { return _C(this, 6204) as Vector3; }
+    set rotation(v: Vector3) { _C(this, 12577, v); }
+
+    /**
+     * The {@link rotation} of this node, in degrees instead of radians.
+     * **Note:** This is **not** the property available in the Inspector dock.
+     */
+    get rotationDegrees(): Vector3 { return _C(this, 6209) as Vector3; }
+    set rotationDegrees(v: Vector3) { _C(this, 12582, v); }
+
+    /**
+     * Rotation of this node represented as a {@link Quaternion} in parent space (relative to the parent node). This value is obtained from {@link basis}'s rotation.
+     * **Note:** Quaternions are much more suitable for 3D math but are less intuitive. Setting this property can be useful for interpolation (see {@link Quaternion.slerp}).
+     */
+    get quaternion(): Quaternion { return _C(this, 6061) as Quaternion; }
+    set quaternion(v: Quaternion) { _C(this, 12460, v); }
+
+    /**
+     * Basis of the {@link transform} property. Represents the rotation, scale, and shear of this node in parent space (relative to the parent node).
+     */
+    get basis(): Basis { return _C(this, 3904) as Basis; }
+    set basis(v: Basis) { _C(this, 10647, v); }
+
+    /**
+     * Scale of this node in local space (relative to this node). This value is obtained from {@link basis}'s scale.
+     * **Note:** The behavior of some 3D node types is not affected by this property. These include {@link Light3D}, {@link Camera3D}, {@link AudioStreamPlayer3D}, and more.
+     * **Warning:** The scale's components must either be all positive or all negative, and **not** exactly `0.0`. Otherwise, it won't be possible to obtain the scale from the {@link basis}. This may cause the intended scale to be lost when reloaded from disk, and potentially other unstable behavior.
+     */
+    get scale(): Vector3 { return _C(this, 6236) as Vector3; }
+    set scale(v: Vector3) { _C(this, 12608, v); }
+
+    /**
+     * How this node's rotation and scale are displayed in the Inspector dock.
+     */
+    get rotationEditMode(): RotationEditMode { return _C(this, 6210) as RotationEditMode; }
+    set rotationEditMode(v: RotationEditMode) { _C(this, 12583, v); }
+
+    /**
+     * The axis rotation order of the {@link rotation} property. In Godot, Euler angles always use intrinsic order, meaning that the final orientation is calculated by rotating around the local axes in this order.
+     */
+    get rotationOrder(): EulerOrder { return _C(this, 6213) as EulerOrder; }
+    set rotationOrder(v: EulerOrder) { _C(this, 12587, v); }
+
+    /**
+     * If `true`, the node does not inherit its transformations from its parent. As such, node transformations will only be in global space, which also means that {@link globalTransform} and {@link transform} will be identical.
+     */
+    get topLevel(): boolean { return _C(this, 8296) as boolean; }
+    set topLevel(v: boolean) { _C(this, 10543, v); }
+
+    /**
+     * Global position (translation) of this node in global space (relative to the world). This is equivalent to the {@link globalTransform}'s {@link Transform3D.origin}.
+     * **Note:** If the node is not inside the tree, getting this property fails and returns {@link Vector3.ZERO}.
+     */
+    get globalPosition(): Vector3 { return _C(this, 4929) as Vector3; }
+    set globalPosition(v: Vector3) { _C(this, 11517, v); }
+
+    /**
+     * Basis of the {@link globalTransform} property. Represents the rotation, scale, and shear of this node in global space (relative to the world).
+     * **Note:** If the node is not inside the tree, getting this property fails and returns {@link Basis.IDENTITY}.
+     */
+    get globalBasis(): Basis { return _C(this, 4923) as Basis; }
+    set globalBasis(v: Basis) { _C(this, 11514, v); }
+
+    /**
+     * Global rotation of this node as [Euler angles](https://en.wikipedia.org/wiki/Euler_angles), in radians and in global space (relative to the world). This value is obtained from {@link globalBasis}'s rotation.
+     * - The {@link Vector3.x} is the angle around the global X axis (pitch);
+     * - The {@link Vector3.y} is the angle around the global Y axis (yaw);
+     * - The {@link Vector3.z} is the angle around the global Z axis (roll).
+     * **Note:** Unlike {@link rotation}, this property always follows the YXZ convention ({@link EULER_ORDER_YXZ}).
+     * **Note:** If the node is not inside the tree, getting this property fails and returns {@link Vector3.ZERO}.
+     */
+    get globalRotation(): Vector3 { return _C(this, 4931) as Vector3; }
+    set globalRotation(v: Vector3) { _C(this, 11518, v); }
+
+    /**
+     * The {@link globalRotation} of this node, in degrees instead of radians.
+     * **Note:** If the node is not inside the tree, getting this property fails and returns {@link Vector3.ZERO}.
+     */
+    get globalRotationDegrees(): Vector3 { return _C(this, 4932) as Vector3; }
+    set globalRotationDegrees(v: Vector3) { _C(this, 11519, v); }
+
+    /**
+     * If `true`, this node can be visible. The node is only rendered when all of its ancestors are visible, as well. That means {@link isVisibleInTree} must return `true`.
+     */
+    get visible(): boolean { return _C(this, 8450) as boolean; }
+    set visible(v: boolean) { _C(this, 13331, v); }
+
+    /**
+     * Path to the visibility range parent for this node and its descendants. The visibility parent must be a {@link GeometryInstance3D}.
+     * Any visual instance will only be visible if the visibility parent (and all of its visibility ancestors) is hidden by being closer to the camera than its own {@link GeometryInstance3D.visibilityRangeBegin}. Nodes hidden via the {@link Node3D.visible} property are essentially removed from the visibility dependency tree, so dependent instances will not take the hidden node or its descendants into account.
+     */
+    get visibilityParent(): NodePath { return _C(this, 7094) as NodePath; }
+    set visibilityParent(v: NodePath) { _C(this, 13322, v); }
+
+    /**
+     * Notification received when this node's {@link globalTransform} changes, if {@link isTransformNotificationEnabled} is `true`. See also {@link setNotifyTransform}.
+     * **Note:** Most 3D nodes such as {@link VisualInstance3D} or {@link CollisionObject3D} automatically enable this to function correctly.
+     * **Note:** In the editor, nodes will propagate this notification to their children if a gizmo is attached (see {@link addGizmo}).
+     */
+    static readonly NOTIFICATION_TRANSFORM_CHANGED = 2000;
+
+    /**
+     * Notification received when this node is registered to a new {@link World3D} (see {@link getWorld3d}).
+     */
+    static readonly NOTIFICATION_ENTER_WORLD = 41;
+
+    /**
+     * Notification received when this node is unregistered from the current {@link World3D} (see {@link getWorld3d}).
+     * This notification is sent in reversed order.
+     */
+    static readonly NOTIFICATION_EXIT_WORLD = 42;
+
+    /**
+     * Notification received when this node's visibility changes (see {@link visible} and {@link isVisibleInTree}).
+     * This notification is received *before* the related {@link visibility_changed} signal.
+     */
+    static readonly NOTIFICATION_VISIBILITY_CHANGED = 43;
+
+    /**
+     * Notification received when this node's {@link transform} changes, if {@link isLocalTransformNotificationEnabled} is `true`. This is not received when a parent {@link Node3D}'s {@link transform} changes. See also {@link setNotifyLocalTransform}.
+     * **Note:** Some 3D nodes such as {@link CSGShape3D} or {@link CollisionShape3D} automatically enable this to function correctly.
+     */
+    static readonly NOTIFICATION_LOCAL_TRANSFORM_CHANGED = 44;
+
+    /**
+     * Emitted when this node's visibility changes (see {@link visible} and {@link isVisibleInTree}).
+     * This signal is emitted *after* the related {@link NOTIFICATION_VISIBILITY_CHANGED} notification.
+     */
+    get visibilityChanged(): Signal<() => void> { return _G(this, 14772) as Signal<() => void>; }
+    set visibilityChanged(v: (() => void) | null) { _G(this, 14772, v); }
+
+    static readonly name = _R(458, Node3D);
+}
+
+export const RotationEditMode = {
+    /**
+     * The rotation is edited using a {@link Vector3} in [Euler angles](https://en.wikipedia.org/wiki/Euler_angles). In Godot, Euler angles always use intrinsic order, meaning that rotation happens around the local axes of the object.
+     */
+    ROTATION_EDIT_MODE_EULER: 0,
+    /**
+     * The rotation is edited using a {@link Quaternion}. Quaternions avoid [gimbal lock]($DOCS_URL/tutorials/3d/using_transforms.html) and having to choose an order of rotation, but are less intuitive. Quaternion rotation is mostly the same as rotors in 3D geometric algebra, except that the numbers are labeled differently.
+     */
+    ROTATION_EDIT_MODE_QUATERNION: 1,
+    /**
+     * The rotation is edited using a {@link Basis}. In this mode, the raw {@link basis}'s axes can be freely modified, but the {@link scale} property is not available.
+     */
+    ROTATION_EDIT_MODE_BASIS: 2,
+} as const;
+
+export type RotationEditMode = (typeof RotationEditMode)[keyof typeof RotationEditMode];
+

package/gen/classes/Node3DGizmo.ts

@@ -0,0 +1,14 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { RefCounted } from './RefCounted.ts';
+
+/**
+ * This abstract class helps connect the {@link Node3D} scene with the editor-specific {@link EditorNode3DGizmo} class.
+ * {@link Node3DGizmo} by itself has no exposed API, refer to {@link Node3D.addGizmo} and pass it an {@link EditorNode3DGizmo} instance.
+ */
+export class Node3DGizmo extends RefCounted {
+
+    static readonly name = _R(459, Node3DGizmo);
+}

package/gen/classes/Noise.ts

@@ -0,0 +1,67 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Resource } from './Resource.ts';
+import type { GodotArray } from '../heap-types/index.ts';
+import type { Vector2, Vector3 } from '../value-types/index.ts';
+import type { Image } from './Image.ts';
+
+/**
+ * This class defines the interface for noise generation libraries to inherit from.
+ * A default {@link getSeamlessImage} implementation is provided for libraries that do not provide seamless noise. This function requests a larger image from the {@link getImage} method, reverses the quadrants of the image, then uses the strips of extra width to blend over the seams.
+ * Inheriting noise classes can optionally override this function to provide a more optimal algorithm.
+ */
+export class Noise extends Resource {
+
+    /**
+     * Returns the 1D noise value at the given (x) coordinate.
+     */
+    getNoise1d(x: number): number { return _C(this, 5666, x) as number; }
+
+    /**
+     * Returns the 2D noise value at the given position.
+     */
+    getNoise2d(x: number, y: number): number { return _C(this, 5667, x, y) as number; }
+
+    /**
+     * Returns the 2D noise value at the given position.
+     */
+    getNoise2dv(v: Vector2): number { return _C(this, 5668, v) as number; }
+
+    /**
+     * Returns the 3D noise value at the given position.
+     */
+    getNoise3d(x: number, y: number, z: number): number { return _C(this, 5669, x, y, z) as number; }
+
+    /**
+     * Returns the 3D noise value at the given position.
+     */
+    getNoise3dv(v: Vector3): number { return _C(this, 5670, v) as number; }
+
+    /**
+     * Returns an {@link Image} containing 2D noise values.
+     * **Note:** With `normalize` set to `false`, the default implementation expects the noise generator to return values in the range `-1.0` to `1.0`.
+     */
+    getImage(width: number, height: number, invert?: boolean /* = false */, in3dSpace?: boolean /* = false */, normalize?: boolean /* = true */): Image { return _C(this, 5071, width, height, invert, in3dSpace, normalize) as Image; }
+
+    /**
+     * Returns an {@link Image} containing seamless 2D noise values.
+     * **Note:** With `normalize` set to `false`, the default implementation expects the noise generator to return values in the range `-1.0` to `1.0`.
+     */
+    getSeamlessImage(width: number, height: number, invert?: boolean /* = false */, in3dSpace?: boolean /* = false */, skirt?: number /* = 0.1 */, normalize?: boolean /* = true */): Image { return _C(this, 6299, width, height, invert, in3dSpace, skirt, normalize) as Image; }
+
+    /**
+     * Returns an {@link Array} of {@link Image}s containing 3D noise values for use with {@link ImageTexture3D.create}.
+     * **Note:** With `normalize` set to `false`, the default implementation expects the noise generator to return values in the range `-1.0` to `1.0`.
+     */
+    getImage3d(width: number, height: number, depth: number, invert?: boolean /* = false */, normalize?: boolean /* = true */): GodotArray<Image> { return _C(this, 5072, width, height, depth, invert, normalize) as GodotArray<Image>; }
+
+    /**
+     * Returns an {@link Array} of {@link Image}s containing seamless 3D noise values for use with {@link ImageTexture3D.create}.
+     * **Note:** With `normalize` set to `false`, the default implementation expects the noise generator to return values in the range `-1.0` to `1.0`.
+     */
+    getSeamlessImage3d(width: number, height: number, depth: number, invert?: boolean /* = false */, skirt?: number /* = 0.1 */, normalize?: boolean /* = true */): GodotArray<Image> { return _C(this, 6300, width, height, depth, invert, skirt, normalize) as GodotArray<Image>; }
+
+    static readonly name = _R(460, Noise);
+}