@ringozz/godot 0.1.0

package/gen/classes/ViewportTexture.ts

@@ -0,0 +1,35 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Texture2D } from './Texture2D.ts';
+import type { NodePath } from '../heap-types/index.ts';
+
+/**
+ * A {@link ViewportTexture} provides the content of a {@link Viewport} as a dynamic {@link Texture2D}. This can be used to combine the rendering of {@link Control}, {@link Node2D} and {@link Node3D} nodes. For example, you can use this texture to display a 3D scene inside a {@link TextureRect}, or a 2D overlay in a {@link Sprite3D}.
+ * To get a {@link ViewportTexture} in code, use the {@link Viewport.getTexture} method on the target viewport.
+ * **Note:** A {@link ViewportTexture} is always local to its scene (see {@link Resource.resourceLocalToScene}). If the scene root is not ready, it may return incorrect data (see {@link Node.ready}).
+ * **Note:** Instantiating scenes containing a high-resolution {@link ViewportTexture} may cause noticeable stutter.
+ * **Note:** When using a {@link Viewport} with {@link Viewport.useHdr2d} set to `true`, the returned texture will be an HDR image that uses linear encoding. This may look darker than normal when displayed directly on screen. To convert to nonlinear sRGB encoding, you can do the following:
+ *
+ * ```text
+ *
+ * img.convert(Image.FORMAT_RGBA8)
+ * img.linear_to_srgb()
+ *
+ * ```
+ *
+ * **Note:** Some nodes such as {@link Decal}, {@link Light3D}, and {@link PointLight2D} do not support using {@link ViewportTexture} directly. To use texture data from a {@link ViewportTexture} in these nodes, you need to create an {@link ImageTexture} by calling {@link Texture2D.getImage} on the {@link ViewportTexture} and passing the result to {@link ImageTexture.createFromImage}. This conversion is a slow operation, so it should not be performed every frame.
+ */
+export class ViewportTexture extends Texture2D {
+    constructor(name = 834) { super(name); }
+
+    /**
+     * The path to the {@link Viewport} node to display. This is relative to the local scene root (see {@link Resource.getLocalScene}), **not** to the nodes that use this texture.
+     * **Note:** In the editor, this path is automatically updated when the target viewport or one of its ancestors is renamed or moved. At runtime, this path may not automatically update if the scene root cannot be found.
+     */
+    get viewportPath(): NodePath { return _C(this, 7083) as NodePath; }
+    set viewportPath(v: NodePath) { _C(this, 13312, v); }
+
+    static readonly name = _R(834, ViewportTexture);
+}

package/gen/classes/VirtualJoystick.ts

@@ -0,0 +1,150 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { Control } from './Control.ts';
+import type { Signal, StringName } from '../heap-types/index.ts';
+import type { Vector2 } from '../value-types/index.ts';
+
+/**
+ * A customizable on-screen joystick control designed for touchscreen devices. It allows users to provide directional input by dragging a virtual tip within a defined circular area.
+ * This control can simulate directional actions (see {@link actionUp}, {@link actionDown}, {@link actionLeft}, and {@link actionRight}), which are triggered when the joystick is moved in the corresponding directions.
+ */
+export class VirtualJoystick extends Control {
+    constructor(name = 835) { super(name); }
+
+    /**
+     * The joystick mode to use.
+     */
+    get joystickMode(): JoystickMode { return _C(this, 5275) as JoystickMode; }
+    set joystickMode(v: JoystickMode) { _C(this, 11848, v); }
+
+    /**
+     * The size of the joystick in pixels.
+     */
+    get joystickSize(): number { return _C(this, 5276) as number; }
+    set joystickSize(v: number) { _C(this, 11849, v); }
+
+    /**
+     * The size of the joystick tip in pixels.
+     */
+    get tipSize(): number { return _C(this, 6828) as number; }
+    set tipSize(v: number) { _C(this, 13098, v); }
+
+    /**
+     * The ratio of the joystick size that defines the joystick deadzone. The joystick tip must move beyond this ratio before being considered active.
+     * This deadzone is applied before triggering input actions and affects the joystick's input vector and all related signals.
+     * Note that input actions may also define their own deadzones in the InputMap. If both are set, the joystick deadzone is applied first, followed by the action's deadzone.
+     * By default, this value is `0.0`, meaning the joystick does not apply its own deadzone and relies entirely on the InputMap action deadzones.
+     */
+    get deadzoneRatio(): number { return _C(this, 4428) as number; }
+    set deadzoneRatio(v: number) { _C(this, 11038, v); }
+
+    /**
+     * The multiplier applied to the joystick's radius that defines the clamp zone.
+     * This zone limits how far the joystick tip can move from its center before being clamped.
+     * A value of `1.0` means the tip can move up to the edge of the joystick's visual size.
+     * In {@link JOYSTICK_FOLLOWING} mode, this radius also determines how far the finger can move before the joystick base starts following the touch input.
+     */
+    get clampzoneRatio(): number { return _C(this, 4149) as number; }
+    set clampzoneRatio(v: number) { _C(this, 10854, v); }
+
+    /**
+     * The initial position of the joystick as a ratio of the control's size. `(0, 0)` is top-left and `(1, 1)` is bottom-right.
+     */
+    get initialOffsetRatio(): Vector2 { return _C(this, 5102) as Vector2; }
+    set initialOffsetRatio(v: Vector2) { _C(this, 11702, v); }
+
+    /**
+     * The action to trigger when the joystick is moved left.
+     */
+    get actionLeft(): StringName { return _C(this, 3680) as StringName; }
+    set actionLeft(v: StringName) { _C(this, 10417, v); }
+
+    /**
+     * The action to trigger when the joystick is moved right.
+     */
+    get actionRight(): StringName { return _C(this, 3684) as StringName; }
+    set actionRight(v: StringName) { _C(this, 10419, v); }
+
+    /**
+     * The action to trigger when the joystick is moved up.
+     */
+    get actionUp(): StringName { return _C(this, 3690) as StringName; }
+    set actionUp(v: StringName) { _C(this, 10424, v); }
+
+    /**
+     * The action to trigger when the joystick is moved down.
+     */
+    get actionDown(): StringName { return _C(this, 3679) as StringName; }
+    set actionDown(v: StringName) { _C(this, 10416, v); }
+
+    /**
+     * The visibility mode to use.
+     */
+    get visibilityMode(): VisibilityMode { return _C(this, 7093) as VisibilityMode; }
+    set visibilityMode(v: VisibilityMode) { _C(this, 13321, v); }
+
+    /**
+     * Emitted when the joystick is pressed.
+     */
+    get pressed(): Signal<() => void> { return _G(this, 9542) as Signal<() => void>; }
+    set pressed(v: (() => void) | null) { _G(this, 9542, v); }
+
+    /**
+     * Emitted when the joystick is released without moving the tip.
+     */
+    get tapped(): Signal<() => void> { return _G(this, 14131) as Signal<() => void>; }
+    set tapped(v: (() => void) | null) { _G(this, 14131, v); }
+
+    /**
+     * Emitted when the joystick is released. The `inputVector` is the final input direction and strength, with a length between `0.0` and `1.0`.
+     */
+    get released(): Signal<(inputVector: Vector2) => void> { return _G(this, 9869) as Signal<(inputVector: Vector2) => void>; }
+    set released(v: ((inputVector: Vector2) => void) | null) { _G(this, 9869, v); }
+
+    /**
+     * Emitted when the tip moved outside the deadzone and the joystick is released. The `inputVector` contains the last input direction and strength before release. Its length is between `0.0` and `1.0`.
+     */
+    get flicked(): Signal<(inputVector: Vector2) => void> { return _G(this, 3327) as Signal<(inputVector: Vector2) => void>; }
+    set flicked(v: ((inputVector: Vector2) => void) | null) { _G(this, 3327, v); }
+
+    /**
+     * Emitted when the tip enters the deadzone after being outside of it.
+     */
+    get flickCanceled(): Signal<() => void> { return _G(this, 3326) as Signal<() => void>; }
+    set flickCanceled(v: (() => void) | null) { _G(this, 3326, v); }
+
+    static readonly name = _R(835, VirtualJoystick);
+}
+
+export const JoystickMode = {
+    /**
+     * The joystick doesn't move.
+     */
+    JOYSTICK_FIXED: 0,
+    /**
+     * The joystick is moved to the initial touch position as long as it's within the joystick's bounds. It moves back to its original position when released.
+     */
+    JOYSTICK_DYNAMIC: 1,
+    /**
+     * The joystick is moved to the initial touch position as long as it's within the joystick's bounds. It will follow the touch input if it goes outside the joystick's range. It moves back to its original position when released.
+     */
+    JOYSTICK_FOLLOWING: 2,
+} as const;
+
+export type JoystickMode = (typeof JoystickMode)[keyof typeof JoystickMode];
+
+export const VisibilityMode = {
+    /**
+     * The joystick is always visible.
+     */
+    VISIBILITY_ALWAYS: 0,
+    /**
+     * The joystick is only visible when being touched.
+     */
+    VISIBILITY_WHEN_TOUCHED: 1,
+} as const;
+
+export type VisibilityMode = (typeof VisibilityMode)[keyof typeof VisibilityMode];
+

package/gen/classes/VisibleOnScreenEnabler2D.ts

@@ -0,0 +1,47 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { VisibleOnScreenNotifier2D } from './VisibleOnScreenNotifier2D.ts';
+import type { NodePath } from '../heap-types/index.ts';
+
+/**
+ * {@link VisibleOnScreenEnabler2D} contains a rectangular region of 2D space and a target node. The target node will be automatically enabled (via its {@link Node.processMode} property) when any part of this region becomes visible on the screen, and automatically disabled otherwise. This can for example be used to activate enemies only when the player approaches them.
+ * See {@link VisibleOnScreenNotifier2D} if you only want to be notified when the region is visible on screen.
+ * **Note:** {@link VisibleOnScreenEnabler2D} uses the render culling code to determine whether it's visible on screen, so it won't function unless {@link CanvasItem.visible} is set to `true`.
+ */
+export class VisibleOnScreenEnabler2D extends VisibleOnScreenNotifier2D {
+    constructor(name = 836) { super(name); }
+
+    /**
+     * Determines how the target node is enabled. Corresponds to {@link Node.ProcessMode}. When the node is disabled, it always uses {@link Node.PROCESS_MODE_DISABLED}.
+     */
+    get enableMode(): EnableMode { return _C(this, 4652) as EnableMode; }
+    set enableMode(v: EnableMode) { _C(this, 11279, v); }
+
+    /**
+     * The path to the target node, relative to the {@link VisibleOnScreenEnabler2D}. The target node is cached; it's only assigned when setting this property (if the {@link VisibleOnScreenEnabler2D} is inside the scene tree) and every time the {@link VisibleOnScreenEnabler2D} enters the scene tree. If the path is empty, no node will be affected. If the path is invalid, an error is also generated.
+     */
+    get enableNodePath(): NodePath { return _C(this, 4653) as NodePath; }
+    set enableNodePath(v: NodePath) { _C(this, 11280, v); }
+
+    static readonly name = _R(836, VisibleOnScreenEnabler2D);
+}
+
+export const EnableMode = {
+    /**
+     * Corresponds to {@link Node.PROCESS_MODE_INHERIT}.
+     */
+    ENABLE_MODE_INHERIT: 0,
+    /**
+     * Corresponds to {@link Node.PROCESS_MODE_ALWAYS}.
+     */
+    ENABLE_MODE_ALWAYS: 1,
+    /**
+     * Corresponds to {@link Node.PROCESS_MODE_WHEN_PAUSED}.
+     */
+    ENABLE_MODE_WHEN_PAUSED: 2,
+} as const;
+
+export type EnableMode = (typeof EnableMode)[keyof typeof EnableMode];
+

package/gen/classes/VisibleOnScreenEnabler3D.ts

@@ -0,0 +1,47 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { VisibleOnScreenNotifier3D } from './VisibleOnScreenNotifier3D.ts';
+import type { NodePath } from '../heap-types/index.ts';
+
+/**
+ * {@link VisibleOnScreenEnabler3D} contains a box-shaped region of 3D space and a target node. The target node will be automatically enabled (via its {@link Node.processMode} property) when any part of this region becomes visible on the screen, and automatically disabled otherwise. This can for example be used to activate enemies only when the player approaches them.
+ * See {@link VisibleOnScreenNotifier3D} if you only want to be notified when the region is visible on screen.
+ * **Note:** {@link VisibleOnScreenEnabler3D} uses an approximate heuristic that doesn't take walls and other occlusion into account, unless occlusion culling is used. It also won't function unless {@link Node3D.visible} is set to `true`.
+ */
+export class VisibleOnScreenEnabler3D extends VisibleOnScreenNotifier3D {
+    constructor(name = 837) { super(name); }
+
+    /**
+     * Determines how the target node is enabled. Corresponds to {@link Node.ProcessMode}. When the node is disabled, it always uses {@link Node.PROCESS_MODE_DISABLED}.
+     */
+    get enableMode(): EnableMode { return _C(this, 4652) as EnableMode; }
+    set enableMode(v: EnableMode) { _C(this, 11279, v); }
+
+    /**
+     * The path to the target node, relative to the {@link VisibleOnScreenEnabler3D}. The target node is cached; it's only assigned when setting this property (if the {@link VisibleOnScreenEnabler3D} is inside the scene tree) and every time the {@link VisibleOnScreenEnabler3D} enters the scene tree. If the path is empty, no node will be affected. If the path is invalid, an error is also generated.
+     */
+    get enableNodePath(): NodePath { return _C(this, 4653) as NodePath; }
+    set enableNodePath(v: NodePath) { _C(this, 11280, v); }
+
+    static readonly name = _R(837, VisibleOnScreenEnabler3D);
+}
+
+export const EnableMode = {
+    /**
+     * Corresponds to {@link Node.PROCESS_MODE_INHERIT}.
+     */
+    ENABLE_MODE_INHERIT: 0,
+    /**
+     * Corresponds to {@link Node.PROCESS_MODE_ALWAYS}.
+     */
+    ENABLE_MODE_ALWAYS: 1,
+    /**
+     * Corresponds to {@link Node.PROCESS_MODE_WHEN_PAUSED}.
+     */
+    ENABLE_MODE_WHEN_PAUSED: 2,
+} as const;
+
+export type EnableMode = (typeof EnableMode)[keyof typeof EnableMode];
+

package/gen/classes/VisibleOnScreenNotifier2D.ts

@@ -0,0 +1,48 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { Node2D } from './Node2D.ts';
+import type { Signal } from '../heap-types/index.ts';
+import type { Rect2 } from '../value-types/index.ts';
+
+/**
+ * {@link VisibleOnScreenNotifier2D} represents a rectangular region of 2D space. When any part of this region becomes visible on screen or in a viewport, it will emit a {@link screen_entered} signal, and likewise it will emit a {@link screen_exited} signal when no part of it remains visible.
+ * If you want a node to be enabled automatically when this region is visible on screen, use {@link VisibleOnScreenEnabler2D}.
+ * **Note:** {@link VisibleOnScreenNotifier2D} uses the render culling code to determine whether it's visible on screen, so it won't function unless {@link CanvasItem.visible} is set to `true`.
+ */
+export class VisibleOnScreenNotifier2D extends Node2D {
+    constructor(name = 838) { super(name); }
+
+    /**
+     * If `true`, the bounding rectangle is on the screen.
+     * **Note:** It takes one frame for the {@link VisibleOnScreenNotifier2D}'s visibility to be determined once added to the scene tree, so this method will always return `false` right after it is instantiated, before the draw pass.
+     */
+    isOnScreen(): boolean { return _C(this, 8149) as boolean; }
+
+    /**
+     * The VisibleOnScreenNotifier2D's bounding rectangle.
+     */
+    get rect(): Rect2 { return _C(this, 6092) as Rect2; }
+    set rect(v: Rect2) { _C(this, 12489, v); }
+
+    /**
+     * If `true`, shows the rectangle area of {@link rect} in the editor with a translucent magenta fill. Unlike changing the visibility of the VisibleOnScreenNotifier2D, this does not affect the screen culling detection.
+     */
+    get showRect(): boolean { return _C(this, 8313) as boolean; }
+    set showRect(v: boolean) { _C(this, 12736, v); }
+
+    /**
+     * Emitted when the VisibleOnScreenNotifier2D enters the screen.
+     */
+    get screenEntered(): Signal<() => void> { return _G(this, 10246) as Signal<() => void>; }
+    set screenEntered(v: (() => void) | null) { _G(this, 10246, v); }
+
+    /**
+     * Emitted when the VisibleOnScreenNotifier2D exits the screen.
+     */
+    get screenExited(): Signal<() => void> { return _G(this, 10247) as Signal<() => void>; }
+    set screenExited(v: (() => void) | null) { _G(this, 10247, v); }
+
+    static readonly name = _R(838, VisibleOnScreenNotifier2D);
+}

package/gen/classes/VisibleOnScreenNotifier3D.ts

@@ -0,0 +1,42 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { VisualInstance3D } from './VisualInstance3D.ts';
+import type { Signal } from '../heap-types/index.ts';
+import type { AABB } from '../value-types/index.ts';
+
+/**
+ * {@link VisibleOnScreenNotifier3D} represents a box-shaped region of 3D space. When any part of this region becomes visible on screen or in a {@link Camera3D}'s view, it will emit a {@link screen_entered} signal, and likewise it will emit a {@link screen_exited} signal when no part of it remains visible.
+ * If you want a node to be enabled automatically when this region is visible on screen, use {@link VisibleOnScreenEnabler3D}.
+ * **Note:** {@link VisibleOnScreenNotifier3D} uses an approximate heuristic that doesn't take walls and other occlusion into account, unless occlusion culling is used. It also won't function unless {@link Node3D.visible} is set to `true`.
+ */
+export class VisibleOnScreenNotifier3D extends VisualInstance3D {
+    constructor(name = 839) { super(name); }
+
+    /**
+     * Returns `true` if the bounding box is on the screen.
+     * **Note:** It takes one frame for the {@link VisibleOnScreenNotifier3D}'s visibility to be assessed once added to the scene tree, so this method will always return `false` right after it is instantiated.
+     */
+    isOnScreen(): boolean { return _C(this, 8149) as boolean; }
+
+    /**
+     * The {@link VisibleOnScreenNotifier3D}'s bounding box.
+     */
+    get aabb(): AABB { return _C(this, 3659) as AABB; }
+    set aabb(v: AABB) { _C(this, 10395, v); }
+
+    /**
+     * Emitted when the {@link VisibleOnScreenNotifier3D} enters the screen.
+     */
+    get screenEntered(): Signal<() => void> { return _G(this, 10246) as Signal<() => void>; }
+    set screenEntered(v: (() => void) | null) { _G(this, 10246, v); }
+
+    /**
+     * Emitted when the {@link VisibleOnScreenNotifier3D} exits the screen.
+     */
+    get screenExited(): Signal<() => void> { return _G(this, 10247) as Signal<() => void>; }
+    set screenExited(v: (() => void) | null) { _G(this, 10247, v); }
+
+    static readonly name = _R(839, VisibleOnScreenNotifier3D);
+}

package/gen/classes/VisualInstance3D.ts

@@ -0,0 +1,69 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Node3D } from './Node3D.ts';
+import type { RID } from '../heap-types/index.ts';
+import type { AABB } from '../value-types/index.ts';
+
+/**
+ * The {@link VisualInstance3D} is used to connect a resource to a visual representation. All visual 3D nodes inherit from the {@link VisualInstance3D}. In general, you should not access the {@link VisualInstance3D} properties directly as they are accessed and managed by the nodes that inherit from {@link VisualInstance3D}. {@link VisualInstance3D} is the node representation of the {@link RenderingServer} instance.
+ */
+export class VisualInstance3D extends Node3D {
+    constructor(name = 840) { super(name); }
+
+    /**
+     * Sets the resource that is instantiated by this {@link VisualInstance3D}, which changes how the engine handles the {@link VisualInstance3D} under the hood. Equivalent to {@link RenderingServer.instanceSetBase}.
+     */
+    setBase(base: RID): void { _C(this, 10640, base); }
+
+    /**
+     * Returns the RID of the resource associated with this {@link VisualInstance3D}. For example, if the Node is a {@link MeshInstance3D}, this will return the RID of the associated {@link Mesh}.
+     */
+    getBase(): RID { return _C(this, 3892) as RID; }
+
+    /**
+     * Returns the RID of this instance. This RID is the same as the RID returned by {@link RenderingServer.instanceCreate}. This RID is needed if you want to call {@link RenderingServer} functions directly on this {@link VisualInstance3D}.
+     */
+    getInstance(): RID { return _C(this, 5128) as RID; }
+
+    /**
+     * Based on `value`, enables or disables the specified layer in the {@link layers}, given a `layerNumber` between 1 and 20.
+     */
+    setLayerMaskValue(layerNumber: number, value: boolean): void { _C(this, 11877, layerNumber, value); }
+
+    /**
+     * Returns whether or not the specified layer of the {@link layers} is enabled, given a `layerNumber` between 1 and 20.
+     */
+    getLayerMaskValue(layerNumber: number): boolean { return _C(this, 5317, layerNumber) as boolean; }
+
+    /**
+     * Returns the {@link AABB} (also known as the bounding box) for this {@link VisualInstance3D}.
+     */
+    getAabb(): AABB { return _C(this, 3659) as AABB; }
+
+    /**
+     * The render layer(s) this {@link VisualInstance3D} is drawn on.
+     * This object will only be visible for {@link Camera3D}s whose cull mask includes any of the render layers this {@link VisualInstance3D} is set to.
+     * For {@link Light3D}s, this can be used to control which {@link VisualInstance3D}s are affected by a specific light. For {@link GPUParticles3D}, this can be used to control which particles are effected by a specific attractor. For {@link Decal}s, this can be used to control which {@link VisualInstance3D}s are affected by a specific decal.
+     * To adjust {@link layers} more easily using a script, use {@link getLayerMaskValue} and {@link setLayerMaskValue}.
+     * **Note:** {@link VoxelGI}, SDFGI and {@link LightmapGI} will always take all layers into account to determine what contributes to global illumination. If this is an issue, set {@link GeometryInstance3D.giMode} to {@link GeometryInstance3D.GI_MODE_DISABLED} for meshes and {@link Light3D.lightBakeMode} to {@link Light3D.BAKE_DISABLED} for lights to exclude them from global illumination.
+     */
+    get layers(): number { return _C(this, 5316) as number; }
+    set layers(v: number) { _C(this, 11876, v); }
+
+    /**
+     * The amount by which the depth of this {@link VisualInstance3D} will be adjusted when sorting by depth. Uses the same units as the engine (which are typically meters). Adjusting it to a higher value will make the {@link VisualInstance3D} reliably draw on top of other {@link VisualInstance3D}s that are otherwise positioned at the same spot. To ensure it always draws on top of other objects around it (not positioned at the same spot), set the value to be greater than the distance between this {@link VisualInstance3D} and the other nearby {@link VisualInstance3D}s.
+     */
+    get sortingOffset(): number { return _C(this, 6454) as number; }
+    set sortingOffset(v: number) { _C(this, 12810, v); }
+
+    /**
+     * If `true`, the object is sorted based on the {@link AABB} center. The object will be sorted based on the global position otherwise.
+     * The {@link AABB} center based sorting is generally more accurate for 3D models. The position based sorting instead allows to better control the drawing order when working with {@link GPUParticles3D} and {@link CPUParticles3D}.
+     */
+    get sortingUseAabbCenter(): boolean { return _C(this, 8330) as boolean; }
+    set sortingUseAabbCenter(v: boolean) { _C(this, 12811, v); }
+
+    static readonly name = _R(840, VisualInstance3D);
+}