@ringozz/godot 0.1.0

package/gen/classes/InputEventMouseMotion.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 { InputEventMouse } from './InputEventMouse.ts';
+import type { Vector2 } from '../value-types/index.ts';
+
+/**
+ * Stores information about a mouse or a pen motion. This includes relative position, absolute position, and velocity. See {@link Node.Input}.
+ * **Note:** By default, this event is only emitted once per frame rendered at most. If you need more precise input reporting, set {@link Input.useAccumulatedInput} to `false` to make events emitted as often as possible. If you use InputEventMouseMotion to draw lines, consider using {@link Geometry2D.bresenhamLine} as well to avoid visible gaps in lines if the user is moving the mouse quickly.
+ * **Note:** This event may be emitted even when the mouse hasn't moved, either by the operating system or by Godot itself. If you really need to know if the mouse has moved (e.g. to suppress displaying a tooltip), you should check that `relative.is_zero_approx()` is `false`.
+ */
+export class InputEventMouseMotion extends InputEventMouse {
+    constructor(name = 359) { super(name); }
+
+    /**
+     * Represents the angles of tilt of the pen. Positive X-coordinate value indicates a tilt to the right. Positive Y-coordinate value indicates a tilt toward the user. Ranges from `-1.0` to `1.0` for both axes.
+     */
+    get tilt(): Vector2 { return _C(this, 6804) as Vector2; }
+    set tilt(v: Vector2) { _C(this, 13079, v); }
+
+    /**
+     * Represents the pressure the user puts on the pen. Ranges from `0.0` to `1.0`.
+     */
+    get pressure(): number { return _C(this, 5996) as number; }
+    set pressure(v: number) { _C(this, 12406, v); }
+
+    /**
+     * Returns `true` when using the eraser end of a stylus pen.
+     * **Note:** This property is implemented on Linux, macOS and Windows.
+     */
+    get penInverted(): boolean { return _C(this, 5874) as boolean; }
+    set penInverted(v: boolean) { _C(this, 12303, v); }
+
+    /**
+     * The mouse position relative to the previous position (position at the last frame).
+     * **Note:** Since {@link InputEventMouseMotion} may only be emitted when the mouse moves, it is not possible to reliably detect when the mouse has stopped moving by checking this property. A separate, short timer may be necessary.
+     * **Note:** {@link relative} is automatically scaled according to the content scale factor, which is defined by the project's stretch mode settings. This means mouse sensitivity will appear different depending on resolution when using {@link relative} in a script that handles mouse aiming with the {@link Input.MOUSE_MODE_CAPTURED} mouse mode. To avoid this, use {@link screenRelative} instead.
+     */
+    get relative(): Vector2 { return _C(this, 6117) as Vector2; }
+    set relative(v: Vector2) { _C(this, 12511, v); }
+
+    /**
+     * The unscaled mouse position relative to the previous position in the coordinate system of the screen (position at the last frame).
+     * **Note:** Since {@link InputEventMouseMotion} may only be emitted when the mouse moves, it is not possible to reliably detect when the mouse has stopped moving by checking this property. A separate, short timer may be necessary.
+     * **Note:** This coordinate is *not* scaled according to the content scale factor or calls to {@link InputEvent.xformedBy}. This should be preferred over {@link relative} for mouse aiming when using the {@link Input.MOUSE_MODE_CAPTURED} mouse mode, regardless of the project's stretch mode.
+     */
+    get screenRelative(): Vector2 { return _C(this, 6262) as Vector2; }
+    set screenRelative(v: Vector2) { _C(this, 12628, v); }
+
+    /**
+     * The mouse velocity in pixels per second.
+     * **Note:** {@link velocity} is automatically scaled according to the content scale factor, which is defined by the project's stretch mode settings. That means mouse sensitivity may appear different depending on resolution.
+     * **Note:** In {@link Input.MOUSE_MODE_CAPTURED} mode, {@link velocity} returns `(0, 0)` because the mouse cursor is hidden and locked. Use {@link screenRelative} for mouse aiming using the {@link Input.MOUSE_MODE_CAPTURED} mouse mode.
+     */
+    get velocity(): Vector2 { return _C(this, 7035) as Vector2; }
+    set velocity(v: Vector2) { _C(this, 13279, v); }
+
+    /**
+     * The unscaled mouse velocity in pixels per second in screen coordinates. This velocity is *not* scaled according to the content scale factor or calls to {@link InputEvent.xformedBy}.
+     * **Note:** In {@link Input.MOUSE_MODE_CAPTURED} mode, {@link screenVelocity} returns `(0, 0)` because the mouse cursor is hidden and locked. Use {@link screenRelative} for mouse aiming using the {@link Input.MOUSE_MODE_CAPTURED} mouse mode.
+     */
+    get screenVelocity(): Vector2 { return _C(this, 6266) as Vector2; }
+    set screenVelocity(v: Vector2) { _C(this, 12630, v); }
+
+    static readonly name = _R(359, InputEventMouseMotion);
+}

package/gen/classes/InputEventPanGesture.ts

@@ -0,0 +1,22 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { InputEventGesture } from './InputEventGesture.ts';
+import type { Vector2 } from '../value-types/index.ts';
+
+/**
+ * Stores information about pan gestures. A pan gesture is performed when the user swipes the touch screen with two fingers. It's typically used for panning/scrolling.
+ * **Note:** On Android, this requires the {@link ProjectSettings.inputDevices/pointing/android/enablePanAndScaleGestures} project setting to be enabled.
+ */
+export class InputEventPanGesture extends InputEventGesture {
+    constructor(name = 360) { super(name); }
+
+    /**
+     * Panning amount since last pan event.
+     */
+    get delta(): Vector2 { return _C(this, 4461) as Vector2; }
+    set delta(v: Vector2) { _C(this, 11076, v); }
+
+    static readonly name = _R(360, InputEventPanGesture);
+}

package/gen/classes/InputEventScreenDrag.ts

@@ -0,0 +1,71 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { InputEventFromWindow } from './InputEventFromWindow.ts';
+import type { Vector2 } from '../value-types/index.ts';
+
+/**
+ * Stores information about screen drag events. See {@link Node.Input}.
+ */
+export class InputEventScreenDrag extends InputEventFromWindow {
+    constructor(name = 361) { super(name); }
+
+    /**
+     * The drag event index in the case of a multi-drag event.
+     */
+    get index(): number { return _C(this, 5085) as number; }
+    set index(v: number) { _C(this, 11687, v); }
+
+    /**
+     * Represents the angles of tilt of the pen. Positive X-coordinate value indicates a tilt to the right. Positive Y-coordinate value indicates a tilt toward the user. Ranges from `-1.0` to `1.0` for both axes.
+     */
+    get tilt(): Vector2 { return _C(this, 6804) as Vector2; }
+    set tilt(v: Vector2) { _C(this, 13079, v); }
+
+    /**
+     * Represents the pressure the user puts on the pen. Ranges from `0.0` to `1.0`.
+     */
+    get pressure(): number { return _C(this, 5996) as number; }
+    set pressure(v: number) { _C(this, 12406, v); }
+
+    /**
+     * Returns `true` when using the eraser end of a stylus pen.
+     */
+    get penInverted(): boolean { return _C(this, 5874) as boolean; }
+    set penInverted(v: boolean) { _C(this, 12303, v); }
+
+    /**
+     * The drag position in the viewport the node is in, using the coordinate system of this viewport.
+     */
+    get position(): Vector2 { return _C(this, 5973) as Vector2; }
+    set position(v: Vector2) { _C(this, 12381, v); }
+
+    /**
+     * The drag position relative to the previous position (position at the last frame).
+     * **Note:** {@link relative} is automatically scaled according to the content scale factor, which is defined by the project's stretch mode settings. This means touch sensitivity will appear different depending on resolution when using {@link relative} in a script that handles touch aiming. To avoid this, use {@link screenRelative} instead.
+     */
+    get relative(): Vector2 { return _C(this, 6117) as Vector2; }
+    set relative(v: Vector2) { _C(this, 12511, v); }
+
+    /**
+     * The unscaled drag position relative to the previous position in screen coordinates (position at the last frame). This position is *not* scaled according to the content scale factor or calls to {@link InputEvent.xformedBy}. This should be preferred over {@link relative} for touch aiming regardless of the project's stretch mode.
+     */
+    get screenRelative(): Vector2 { return _C(this, 6262) as Vector2; }
+    set screenRelative(v: Vector2) { _C(this, 12628, v); }
+
+    /**
+     * The drag velocity.
+     * **Note:** {@link velocity} is automatically scaled according to the content scale factor, which is defined by the project's stretch mode settings. This means touch sensitivity will appear different depending on resolution when using {@link velocity} in a script that handles touch aiming. To avoid this, use {@link screenVelocity} instead.
+     */
+    get velocity(): Vector2 { return _C(this, 7035) as Vector2; }
+    set velocity(v: Vector2) { _C(this, 13279, v); }
+
+    /**
+     * The unscaled drag velocity in pixels per second in screen coordinates. This velocity is *not* scaled according to the content scale factor or calls to {@link InputEvent.xformedBy}. This should be preferred over {@link velocity} for touch aiming regardless of the project's stretch mode.
+     */
+    get screenVelocity(): Vector2 { return _C(this, 6266) as Vector2; }
+    set screenVelocity(v: Vector2) { _C(this, 12630, v); }
+
+    static readonly name = _R(361, InputEventScreenDrag);
+}

package/gen/classes/InputEventScreenTouch.ts

@@ -0,0 +1,45 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { InputEventFromWindow } from './InputEventFromWindow.ts';
+import type { Vector2 } from '../value-types/index.ts';
+
+/**
+ * Stores information about multi-touch press/release input events. Supports touch press, touch release and {@link index} for multi-touch count and order.
+ */
+export class InputEventScreenTouch extends InputEventFromWindow {
+    constructor(name = 362) { super(name); }
+
+    /**
+     * The touch index in the case of a multi-touch event. One index = one finger.
+     */
+    get index(): number { return _C(this, 5085) as number; }
+    set index(v: number) { _C(this, 11687, v); }
+
+    /**
+     * The touch position in the viewport the node is in, using the coordinate system of this viewport.
+     */
+    get position(): Vector2 { return _C(this, 5973) as Vector2; }
+    set position(v: Vector2) { _C(this, 12381, v); }
+
+    /**
+     * If `true`, the touch event has been canceled.
+     */
+    get canceled(): boolean { return _C(this, 7814) as boolean; }
+    set canceled(v: boolean) { _C(this, 10792, v); }
+
+    /**
+     * If `true`, the touch's state is pressed. If `false`, the touch's state is released.
+     */
+    get pressed(): boolean { return _C(this, 8199) as boolean; }
+    set pressed(v: boolean) { _C(this, 12404, v); }
+
+    /**
+     * If `true`, the touch's state is a double tap.
+     */
+    get doubleTap(): boolean { return _C(this, 7892) as boolean; }
+    set doubleTap(v: boolean) { _C(this, 11157, v); }
+
+    static readonly name = _R(362, InputEventScreenTouch);
+}

package/gen/classes/InputEventShortcut.ts

@@ -0,0 +1,21 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { InputEvent } from './InputEvent.ts';
+import type { Shortcut } from './Shortcut.ts';
+
+/**
+ * InputEventShortcut is a special event that can be received in {@link Node.Input}, {@link Node.ShortcutInput}, and {@link Node.UnhandledInput}. It is typically sent by the editor's Command Palette to trigger actions, but can also be sent manually using {@link Viewport.pushInput}.
+ */
+export class InputEventShortcut extends InputEvent {
+    constructor(name = 363) { super(name); }
+
+    /**
+     * The {@link Shortcut} represented by this event. Its {@link Shortcut.matchesEvent} method will always return `true` for this event.
+     */
+    get shortcut(): Shortcut { return _C(this, 6377) as Shortcut; }
+    set shortcut(v: Shortcut) { _C(this, 12724, v); }
+
+    static readonly name = _R(363, InputEventShortcut);
+}

package/gen/classes/InputEventWithModifiers.ts

@@ -0,0 +1,56 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { InputEventFromWindow } from './InputEventFromWindow.ts';
+import type { KeyModifierMask } from '../global-enums.ts';
+
+/**
+ * Stores information about mouse, keyboard, and touch gesture input events. This includes information about which modifier keys are pressed, such as `Shift` or `Alt`. See {@link Node.Input}.
+ * **Note:** Modifier keys are considered modifiers only when used in combination with another key. As a result, their corresponding member variables, such as {@link ctrlPressed}, will return `false` if the key is pressed on its own.
+ */
+export class InputEventWithModifiers extends InputEventFromWindow {
+
+    /**
+     * On macOS, returns `true` if `Meta` (`Cmd`) is pressed.
+     * On other platforms, returns `true` if `Ctrl` is pressed.
+     */
+    isCommandOrControlPressed(): boolean { return _C(this, 7849) as boolean; }
+
+    /**
+     * Returns the keycode combination of modifier keys.
+     */
+    getModifiersMask(): KeyModifierMask { return _C(this, 5575) as KeyModifierMask; }
+
+    /**
+     * Automatically use `Meta` (`Cmd`) on macOS and `Ctrl` on other platforms. If `true`, {@link ctrlPressed} and {@link metaPressed} cannot be set.
+     */
+    get commandOrControlAutoremap(): boolean { return _C(this, 7848) as boolean; }
+    set commandOrControlAutoremap(v: boolean) { _C(this, 10926, v); }
+
+    /**
+     * State of the `Alt` modifier.
+     */
+    get altPressed(): boolean { return _C(this, 7756) as boolean; }
+    set altPressed(v: boolean) { _C(this, 10472, v); }
+
+    /**
+     * State of the `Shift` modifier.
+     */
+    get shiftPressed(): boolean { return _C(this, 8302) as boolean; }
+    set shiftPressed(v: boolean) { _C(this, 12723, v); }
+
+    /**
+     * State of the `Ctrl` modifier.
+     */
+    get ctrlPressed(): boolean { return _C(this, 7861) as boolean; }
+    set ctrlPressed(v: boolean) { _C(this, 10978, v); }
+
+    /**
+     * State of the `Meta` modifier. On Windows and Linux, this represents the Windows key (sometimes called "meta" or "super" on Linux). On macOS, this represents the Command key.
+     */
+    get metaPressed(): boolean { return _C(this, 8102) as boolean; }
+    set metaPressed(v: boolean) { _C(this, 12033, v); }
+
+    static readonly name = _R(364, InputEventWithModifiers);
+}

package/gen/classes/InputMap.ts

@@ -0,0 +1,97 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, GodotVar, _G } from '../../src/runtime.ts';
+import { Object } from './Object.ts';
+import type { GodotArray, Signal, StringName } from '../heap-types/index.ts';
+import type { InputEvent } from './InputEvent.ts';
+
+let _$: any;
+const $ = () => _$ ?? (_$ = _C(null, 40, 365));
+
+/**
+ * Manages all {@link InputEventAction} which can be created/modified from the project settings menu **Project > Project Settings > Input Map** or in code with {@link addAction} and {@link actionAddEvent}. See {@link Node.Input}.
+ */
+export class InputMap extends GodotVar {
+
+    /**
+     * Returns `true` if the {@link InputMap} has a registered action with the given name.
+     */
+    static hasAction(action: StringName): boolean { return _C($(), 7350, action) as boolean; }
+
+    /**
+     * Returns an array of all actions in the {@link InputMap}.
+     */
+    static getActions(): GodotArray<StringName> { return _C($(), 3691) as GodotArray<StringName>; }
+
+    /**
+     * Adds an empty action to the {@link InputMap} with a configurable `deadzone`.
+     * An {@link InputEvent} can then be added to this action with {@link actionAddEvent}.
+     */
+    static addAction(action: StringName, deadzone?: number /* = 0.2 */): void { _C($(), 1177, action, deadzone); }
+
+    /**
+     * Removes an action from the {@link InputMap}.
+     */
+    static eraseAction(action: StringName): void { _C($(), 3155, action); }
+
+    /**
+     * Returns the human-readable description of the given action.
+     */
+    static getActionDescription(action: StringName): string { return _C($(), 3678, action) as string; }
+
+    /**
+     * Sets a deadzone value for the action.
+     */
+    static actionSetDeadzone(action: StringName, deadzone: number): void { _C($(), 1169, action, deadzone); }
+
+    /**
+     * Returns a deadzone value for the action.
+     */
+    static actionGetDeadzone(action: StringName): number { return _C($(), 1159, action) as number; }
+
+    /**
+     * Adds an {@link InputEvent} to an action. This {@link InputEvent} will trigger the action.
+     */
+    static actionAddEvent(action: StringName, event: InputEvent): void { _C($(), 1155, action, event); }
+
+    /**
+     * Returns `true` if the action has the given {@link InputEvent} associated with it.
+     */
+    static actionHasEvent(action: StringName, event: InputEvent): boolean { return _C($(), 1162, action, event) as boolean; }
+
+    /**
+     * Removes an {@link InputEvent} from an action.
+     */
+    static actionEraseEvent(action: StringName, event: InputEvent): void { _C($(), 1157, action, event); }
+
+    /**
+     * Removes all events from an action.
+     */
+    static actionEraseEvents(action: StringName): void { _C($(), 1158, action); }
+
+    /**
+     * Returns an array of {@link InputEvent}s associated with a given action.
+     * **Note:** When used in the editor (e.g. a tool script or {@link EditorPlugin}), this method will return events for the editor action. If you want to access your project's input binds from the editor, read the `input/*` settings from {@link ProjectSettings}.
+     */
+    static actionGetEvents(action: StringName): GodotArray<InputEvent> { return _C($(), 1160, action) as GodotArray<InputEvent>; }
+
+    /**
+     * Returns `true` if the given event is part of an existing action. This method ignores keyboard modifiers if the given {@link InputEvent} is not pressed (for proper release detection). See {@link actionHasEvent} if you don't want this behavior.
+     * If `exactMatch` is `false`, it ignores additional input modifiers for {@link InputEventKey} and {@link InputEventMouseButton} events, and the direction for {@link InputEventJoypadMotion} events.
+     */
+    static eventIsAction(event: InputEvent, action: StringName, exactMatch?: boolean /* = false */): boolean { return _C($(), 3169, event, action, exactMatch) as boolean; }
+
+    /**
+     * Clears all {@link InputEventAction} in the {@link InputMap} and load it anew from {@link ProjectSettings}.
+     */
+    static loadFromProjectSettings(): void { _C($(), 8678); }
+
+    /**
+     * Emitted when the {@link ProjectSettings} {@link InputMap} has been loaded.
+     */
+    static get projectSettingsLoaded(): Signal<() => void> { return _G($(), 9595) as Signal<() => void>; }
+    static set projectSettingsLoaded(v: (() => void) | null) { _G($(), 9595, v); }
+
+    static readonly name = _R(365, InputMap);
+}

package/gen/classes/InstancePlaceholder.ts

@@ -0,0 +1,33 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Node } from './Node.ts';
+import type { GodotDictionary } from '../heap-types/index.ts';
+import type { PackedScene } from './PackedScene.ts';
+
+/**
+ * Turning on the option **Load As Placeholder** for an instantiated scene in the editor causes it to be replaced by an {@link InstancePlaceholder} when running the game, this will not replace the node in the editor. This makes it possible to delay actually loading the scene until calling {@link createInstance}. This is useful to avoid loading large scenes all at once by loading parts of it selectively.
+ * **Note:** Like {@link Node}, {@link InstancePlaceholder} does not have a transform. This causes any child nodes to be positioned relatively to the {@link Viewport} origin, rather than their parent as displayed in the editor. Replacing the placeholder with a scene with a transform will transform children relatively to their parent again.
+ */
+export class InstancePlaceholder extends Node {
+
+    /**
+     * Returns the list of properties that will be applied to the node when {@link createInstance} is called.
+     * If `withOrder` is `true`, a key named `.order` (note the leading period) is added to the dictionary. This `.order` key is an {@link Array} of {@link String} property names specifying the order in which properties will be applied (with index 0 being the first).
+     */
+    getStoredValues(withOrder?: boolean /* = false */): GodotDictionary { return _C(this, 6556, withOrder) as GodotDictionary; }
+
+    /**
+     * Call this method to actually load in the node. The created node will be placed as a sibling *above* the {@link InstancePlaceholder} in the scene tree. The {@link Node}'s reference is also returned for convenience.
+     * **Note:** {@link createInstance} is not thread-safe. Use {@link Object.callDeferred} if calling from a thread.
+     */
+    createInstance(replace?: boolean /* = false */, customScene?: PackedScene /* = null */): Node { return _C(this, 2545, replace, customScene) as Node; }
+
+    /**
+     * Gets the path to the {@link PackedScene} resource file that is loaded by default when calling {@link createInstance}. Not thread-safe. Use {@link Object.callDeferred} if calling from a thread.
+     */
+    getInstancePath(): string { return _C(this, 5136) as string; }
+
+    static readonly name = _R(366, InstancePlaceholder);
+}

package/gen/classes/IntervalTweener.ts

@@ -0,0 +1,15 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Tweener } from './Tweener.ts';
+
+/**
+ * {@link IntervalTweener} is used to make delays in a tweening sequence. See {@link Tween.tweenInterval} for more usage information.
+ * **Note:** {@link Tween.tweenInterval} is the only correct way to create {@link IntervalTweener}. Any {@link IntervalTweener} created manually will not function correctly.
+ */
+export class IntervalTweener extends Tweener {
+    constructor(name = 367) { super(name); }
+
+    static readonly name = _R(367, IntervalTweener);
+}