@ringozz/godot 0.1.0

package/gen/classes/PackedScene.ts

@@ -0,0 +1,104 @@
+// 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 { Error } from '../global-enums.ts';
+import type { Node } from './Node.ts';
+import type { SceneState } from './SceneState.ts';
+
+/**
+ * A simplified interface to a scene file. Provides access to operations and checks that can be performed on the scene resource itself.
+ * Can be used to save a node to a file. When saving, the node as well as all the nodes it owns get saved (see {@link Node.owner} property).
+ * **Note:** The node doesn't need to own itself.
+ * **Example:** Load a saved scene:
+ *
+ *
+ * ```gdscript
+ *
+ * # Use load() instead of preload() if the path isn't known at compile-time.
+ * var scene = preload("res://scene.tscn").instantiate()
+ * # Add the node as a child of the node the script is attached to.
+ * add_child(scene)
+ *
+ * ```
+ *
+ *
+ *
+ * **Example:** Save a node with different owners. The following example creates 3 objects: {@link Node2D} (`node`), {@link RigidBody2D} (`body`) and {@link CollisionObject2D} (`collision`). `collision` is a child of `body` which is a child of `node`. Only `body` is owned by `node` and {@link pack} will therefore only save those two nodes, but not `collision`.
+ *
+ *
+ * ```gdscript
+ *
+ * # Create the objects.
+ * var node = Node2D.new()
+ * var body = RigidBody2D.new()
+ * var collision = CollisionShape2D.new()
+ *
+ * # Create the object hierarchy.
+ * body.add_child(collision)
+ * node.add_child(body)
+ *
+ * # Change owner of `body`, but not of `collision`.
+ * body.owner = node
+ * var scene = PackedScene.new()
+ *
+ * # Only `node` and `body` are now packed.
+ * var result = scene.pack(node)
+ * if result == OK:
+ * 	var error = ResourceSaver.save(scene, "res://path/name.tscn")  # Or "user://..."
+ * 	if error != OK:
+ * 		push_error("An error occurred while saving the scene to disk.")
+ *
+ * ```
+ */
+export class PackedScene extends Resource {
+    constructor(name = 537) { super(name); }
+
+    /**
+     * Packs the `path` node, and all owned sub-nodes, into this {@link PackedScene}. Any existing data will be cleared. See {@link Node.owner}.
+     */
+    pack(path: Node): Error { return _C(this, 9256, path) as Error; }
+
+    /**
+     * Instantiates the scene's node hierarchy. Triggers child scene instantiation(s). Triggers a {@link Node.NOTIFICATION_SCENE_INSTANTIATED} notification on the root node.
+     */
+    instantiate(editState?: GenEditState /* = 0 */): Node { return _C(this, 7678, editState) as Node; }
+
+    /**
+     * Returns `true` if the scene file has nodes.
+     */
+    canInstantiate(): boolean { return _C(this, 2013) as boolean; }
+
+    /**
+     * Returns the {@link SceneState} representing the scene file contents.
+     */
+    getState(): SceneState { return _C(this, 6537) as SceneState; }
+
+    static readonly name = _R(537, PackedScene);
+}
+
+export const GenEditState = {
+    /**
+     * If passed to {@link instantiate}, blocks edits to the scene state.
+     */
+    GEN_EDIT_STATE_DISABLED: 0,
+    /**
+     * If passed to {@link instantiate}, provides local scene resources to the local scene.
+     * **Note:** Only available in editor builds.
+     */
+    GEN_EDIT_STATE_INSTANCE: 1,
+    /**
+     * If passed to {@link instantiate}, provides local scene resources to the local scene. Only the main scene should receive the main edit state.
+     * **Note:** Only available in editor builds.
+     */
+    GEN_EDIT_STATE_MAIN: 2,
+    /**
+     * It's similar to {@link GEN_EDIT_STATE_MAIN}, but for the case where the scene is being instantiated to be the base of another one.
+     * **Note:** Only available in editor builds.
+     */
+    GEN_EDIT_STATE_MAIN_INHERITED: 3,
+} as const;
+
+export type GenEditState = (typeof GenEditState)[keyof typeof GenEditState];
+

package/gen/classes/PacketPeer.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 { RefCounted } from './RefCounted.ts';
+import type { Error } from '../global-enums.ts';
+import type { PackedByteArray, Variant } from '../heap-types/index.ts';
+
+/**
+ * PacketPeer is an abstraction and base class for packet-based protocols (such as UDP). It provides an API for sending and receiving packets both as raw data or variables. This makes it easy to transfer data over a protocol, without having to encode data as low-level bytes or having to worry about network ordering.
+ * **Note:** When exporting to Android, make sure to enable the `INTERNET` permission in the Android export preset before exporting the project or using one-click deploy. Otherwise, network communication of any kind will be blocked by Android.
+ */
+export class PacketPeer extends RefCounted {
+
+    /**
+     * Gets a Variant. If `allowObjects` is `true`, decoding objects is allowed.
+     * Internally, this uses the same decoding mechanism as the {@link bytesToVar} method.
+     * **Warning:** Deserialized objects can contain code which gets executed. Do not use this option if the serialized object comes from untrusted sources to avoid potential security threats such as remote code execution.
+     */
+    getVar(allowObjects?: boolean /* = false */): Variant { return _C(this, 7021, allowObjects) as Variant; }
+
+    /**
+     * Sends a {@link Variant} as a packet. If `fullObjects` is `true`, encoding objects is allowed (and can potentially include code).
+     * Internally, this uses the same encoding mechanism as the {@link varToBytes} method.
+     */
+    putVar(_var: Variant, fullObjects?: boolean /* = false */): Error { return _C(this, 9680, _var, fullObjects) as Error; }
+
+    /**
+     * Gets a raw packet.
+     */
+    getPacket(): PackedByteArray { return _C(this, 5783) as PackedByteArray; }
+
+    /**
+     * Sends a raw packet.
+     */
+    putPacket(buffer: PackedByteArray): Error { return _C(this, 9672, buffer) as Error; }
+
+    /**
+     * Returns the error state of the last packet received (via {@link getPacket} and {@link getVar}).
+     */
+    getPacketError(): Error { return _C(this, 5786) as Error; }
+
+    /**
+     * Returns the number of packets currently available in the ring-buffer.
+     */
+    getAvailablePacketCount(): number { return _C(this, 3851) as number; }
+
+    /**
+     * Maximum buffer size allowed when encoding {@link Variant}s. Raise this value to support heavier memory allocations.
+     * The {@link putVar} method allocates memory on the stack, and the buffer used will grow automatically to the closest power of two to match the size of the {@link Variant}. If the {@link Variant} is bigger than {@link encodeBufferMaxSize}, the method will error out with {@link ERR_OUT_OF_MEMORY}.
+     */
+    get encodeBufferMaxSize(): number { return _C(this, 4659) as number; }
+    set encodeBufferMaxSize(v: number) { _C(this, 11287, v); }
+
+    static readonly name = _R(538, PacketPeer);
+}

package/gen/classes/PacketPeerDTLS.ts

@@ -0,0 +1,65 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { PacketPeer } from './PacketPeer.ts';
+import type { Error } from '../global-enums.ts';
+import type { PacketPeerUDP } from './PacketPeerUDP.ts';
+import type { TLSOptions } from './TLSOptions.ts';
+
+/**
+ * This class represents a DTLS peer connection. It can be used to connect to a DTLS server, and is returned by {@link DTLSServer.takeConnection}.
+ * **Note:** When exporting to Android, make sure to enable the `INTERNET` permission in the Android export preset before exporting the project or using one-click deploy. Otherwise, network communication of any kind will be blocked by Android.
+ * **Warning:** TLS certificate revocation and certificate pinning are currently not supported. Revoked certificates are accepted as long as they are otherwise valid. If this is a concern, you may want to use automatically managed certificates with a short validity period.
+ */
+export class PacketPeerDTLS extends PacketPeer {
+    constructor(name = 539) { super(name); }
+
+    /**
+     * Poll the connection to check for incoming packets. Call this frequently to update the status and keep the connection working.
+     */
+    poll(): void { _C(this, 9471); }
+
+    /**
+     * Connects a `packetPeer` beginning the DTLS handshake using the underlying {@link PacketPeerUDP} which must be connected (see {@link PacketPeerUDP.connectToHost}). You can optionally specify the `clientOptions` to be used while verifying the TLS connections. See {@link TLSOptions.client} and {@link TLSOptions.clientUnsafe}.
+     */
+    connectToPeer(packetPeer: PacketPeerUDP, hostname: string, clientOptions?: TLSOptions /* = null */): Error { return _C(this, 2439, packetPeer, hostname, clientOptions) as Error; }
+
+    /**
+     * Returns the status of the connection.
+     */
+    getStatus(): Status { return _C(this, 6542) as Status; }
+
+    /**
+     * Disconnects this peer, terminating the DTLS session.
+     */
+    disconnectFromPeer(): void { _C(this, 2823); }
+
+    static readonly name = _R(539, PacketPeerDTLS);
+}
+
+export const Status = {
+    /**
+     * A status representing a {@link PacketPeerDTLS} that is disconnected.
+     */
+    STATUS_DISCONNECTED: 0,
+    /**
+     * A status representing a {@link PacketPeerDTLS} that is currently performing the handshake with a remote peer.
+     */
+    STATUS_HANDSHAKING: 1,
+    /**
+     * A status representing a {@link PacketPeerDTLS} that is connected to a remote peer.
+     */
+    STATUS_CONNECTED: 2,
+    /**
+     * A status representing a {@link PacketPeerDTLS} in a generic error state.
+     */
+    STATUS_ERROR: 3,
+    /**
+     * An error status that shows a mismatch in the DTLS certificate domain presented by the host and the domain requested for validation.
+     */
+    STATUS_ERROR_HOSTNAME_MISMATCH: 4,
+} as const;
+
+export type Status = (typeof Status)[keyof typeof Status];
+

package/gen/classes/PacketPeerExtension.ts

@@ -0,0 +1,12 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { PacketPeer } from './PacketPeer.ts';
+import type { Error } from '../global-enums.ts';
+
+export class PacketPeerExtension extends PacketPeer {
+    constructor(name = 540) { super(name); }
+
+    static readonly name = _R(540, PacketPeerExtension);
+}

package/gen/classes/PacketPeerStream.ts

@@ -0,0 +1,28 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { PacketPeer } from './PacketPeer.ts';
+import type { StreamPeer } from './StreamPeer.ts';
+
+/**
+ * PacketStreamPeer provides a wrapper for working using packets over a stream. This allows for using packet based code with StreamPeers. PacketPeerStream implements a custom protocol over the StreamPeer, so the user should not read or write to the wrapped StreamPeer directly.
+ * **Note:** When exporting to Android, make sure to enable the `INTERNET` permission in the Android export preset before exporting the project or using one-click deploy. Otherwise, network communication of any kind will be blocked by Android.
+ */
+export class PacketPeerStream extends PacketPeer {
+    constructor(name = 541) { super(name); }
+
+    get inputBufferMaxSize(): number { return _C(this, 5109) as number; }
+    set inputBufferMaxSize(v: number) { _C(this, 11712, v); }
+
+    get outputBufferMaxSize(): number { return _C(this, 5761) as number; }
+    set outputBufferMaxSize(v: number) { _C(this, 12219, v); }
+
+    /**
+     * The wrapped {@link StreamPeer} object.
+     */
+    get streamPeer(): StreamPeer { return _C(this, 6562) as StreamPeer; }
+    set streamPeer(v: StreamPeer) { _C(this, 12898, v); }
+
+    static readonly name = _R(541, PacketPeerStream);
+}

package/gen/classes/PacketPeerUDP.ts

@@ -0,0 +1,139 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { PacketPeer } from './PacketPeer.ts';
+import type { Error } from '../global-enums.ts';
+
+/**
+ * UDP packet peer. Can be used to send and receive raw UDP packets as well as {@link Variant}s.
+ * **Example:** Send a packet:
+ *
+ * ```text
+ *
+ * var peer = PacketPeerUDP.new()
+ *
+ * # Optionally, you can select the local port used to send the packet.
+ * peer.bind(4444)
+ *
+ * peer.set_dest_address("1.1.1.1", 4433)
+ * peer.put_packet("hello".to_utf8_buffer())
+ *
+ * ```
+ *
+ * **Example:** Listen for packets:
+ *
+ * ```text
+ *
+ * var peer
+ *
+ * func _ready():
+ * 	peer = PacketPeerUDP.new()
+ * 	peer.bind(4433)
+ *
+ *
+ * func _process(_delta):
+ * 	if peer.get_available_packet_count() > 0:
+ * 		var array_bytes = peer.get_packet()
+ * 		var packet_string = array_bytes.get_string_from_ascii()
+ * 		print("Received message: ", packet_string)
+ *
+ * ```
+ *
+ * **Note:** When exporting to Android, make sure to enable the `INTERNET` permission in the Android export preset before exporting the project or using one-click deploy. Otherwise, network communication of any kind will be blocked by Android.
+ */
+export class PacketPeerUDP extends PacketPeer {
+    constructor(name = 542) { super(name); }
+
+    /**
+     * Binds this {@link PacketPeerUDP} to the specified `port` and `bindAddress` with a buffer size `recvBufSize`, allowing it to receive incoming packets.
+     * If `bindAddress` is set to `"*"` (default), the peer will be bound on all available addresses (both IPv4 and IPv6).
+     * If `bindAddress` is set to `"0.0.0.0"` (for IPv4) or `"::"` (for IPv6), the peer will be bound to all available addresses matching that IP type.
+     * If `bindAddress` is set to any valid address (e.g. `"192.168.1.101"`, `"::1"`, etc.), the peer will only be bound to the interface with that address (or fail if no interface with the given address exists).
+     */
+    bind(port: number, bindAddress?: string /* = "*" */, recvBufSize?: number /* = 65536 */): Error { return _C(this, 1776, port, bindAddress, recvBufSize) as Error; }
+
+    /**
+     * Closes the {@link PacketPeerUDP}'s underlying UDP socket.
+     */
+    close(): void { _C(this, 2331); }
+
+    /**
+     * Waits for a packet to arrive on the bound address. See {@link bind}.
+     * **Note:** {@link wait} can't be interrupted once it has been called. This can be worked around by allowing the other party to send a specific "death pill" packet like this:
+     *
+     *
+     * ```gdscript
+     *
+     * socket = PacketPeerUDP.new()
+     * # Server
+     * socket.set_dest_address("127.0.0.1", 789)
+     * socket.put_packet("Time to stop".to_ascii_buffer())
+     *
+     * # Client
+     * while socket.wait() == OK:
+     * 	var data = socket.get_packet().get_string_from_ascii()
+     * 	if data == "Time to stop":
+     * 		return
+     *
+     * ```
+     */
+    wait(): Error { return _C(this, 14834) as Error; }
+
+    /**
+     * Returns whether this {@link PacketPeerUDP} is bound to an address and can receive packets.
+     */
+    isBound(): boolean { return _C(this, 7801) as boolean; }
+
+    /**
+     * Calling this method connects this UDP peer to the given `host`/`port` pair. UDP is in reality connectionless, so this option only means that incoming packets from different addresses are automatically discarded, and that outgoing packets are always sent to the connected address (future calls to {@link setDestAddress} are not allowed). This method does not send any data to the remote peer, to do that, use {@link PacketPeer.putVar} or {@link PacketPeer.putPacket} as usual. See also {@link UDPServer}.
+     * **Note:** Connecting to the remote peer does not help to protect from malicious attacks like IP spoofing, etc. Think about using an encryption technique like TLS or DTLS if you feel like your application is transferring sensitive information.
+     */
+    connectToHost(host: string, port: number): Error { return _C(this, 2438, host, port) as Error; }
+
+    /**
+     * Returns `true` if the UDP socket is open and has been connected to a remote address. See {@link connectToHost}.
+     */
+    isSocketConnected(): boolean { return _C(this, 8329) as boolean; }
+
+    /**
+     * Returns the IP of the remote peer that sent the last packet(that was received with {@link PacketPeer.getPacket} or {@link PacketPeer.getVar}).
+     */
+    getPacketIp(): string { return _C(this, 5789) as string; }
+
+    /**
+     * Returns the port of the remote peer that sent the last packet(that was received with {@link PacketPeer.getPacket} or {@link PacketPeer.getVar}).
+     */
+    getPacketPort(): number { return _C(this, 5792) as number; }
+
+    /**
+     * Returns the local port to which this peer is bound.
+     */
+    getLocalPort(): number { return _C(this, 5398) as number; }
+
+    /**
+     * Sets the destination address and port for sending packets and variables. A hostname will be resolved using DNS if needed.
+     * **Note:** {@link setBroadcastEnabled} must be enabled before sending packets to a broadcast address (e.g. `255.255.255.255`).
+     */
+    setDestAddress(host: string, port: number): Error { return _C(this, 11100, host, port) as Error; }
+
+    /**
+     * Enable or disable sending of broadcast packets (e.g. `set_dest_address("255.255.255.255", 4343)`. This option is disabled by default.
+     * **Note:** Some Android devices might require the `CHANGE_WIFI_MULTICAST_STATE` permission and this option to be enabled to receive broadcast packets too.
+     */
+    setBroadcastEnabled(enabled: boolean): void { _C(this, 10739, enabled); }
+
+    /**
+     * Joins the multicast group specified by `multicastAddress` using the interface identified by `interfaceName`.
+     * You can join the same multicast group with multiple interfaces. Use {@link IP.getLocalInterfaces} to know which are available.
+     * **Note:** Some Android devices might require the `CHANGE_WIFI_MULTICAST_STATE` permission for multicast to work.
+     */
+    joinMulticastGroup(multicastAddress: string, interfaceName: string): Error { return _C(this, 8475, multicastAddress, interfaceName) as Error; }
+
+    /**
+     * Removes the interface identified by `interfaceName` from the multicast group specified by `multicastAddress`.
+     */
+    leaveMulticastGroup(multicastAddress: string, interfaceName: string): Error { return _C(this, 8543, multicastAddress, interfaceName) as Error; }
+
+    static readonly name = _R(542, PacketPeerUDP);
+}

package/gen/classes/Panel.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 { Control } from './Control.ts';
+
+/**
+ * {@link Panel} is a GUI control that displays a {@link StyleBox}. See also {@link PanelContainer}.
+ */
+export class Panel extends Control {
+    constructor(name = 543) { super(name); }
+
+    static readonly name = _R(543, Panel);
+}

package/gen/classes/PanelContainer.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 { Container } from './Container.ts';
+
+/**
+ * A container that keeps its child controls within the area of a {@link StyleBox}. Useful for giving controls an outline.
+ */
+export class PanelContainer extends Container {
+    constructor(name = 544) { super(name); }
+
+    static readonly name = _R(544, PanelContainer);
+}

package/gen/classes/PanoramaSkyMaterial.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 { Material } from './Material.ts';
+import type { Texture2D } from './Texture2D.ts';
+
+/**
+ * A resource referenced in a {@link Sky} that is used to draw a background. {@link PanoramaSkyMaterial} functions similar to skyboxes in other engines, except it uses an equirectangular sky map instead of a {@link Cubemap}.
+ * Using an HDR panorama is strongly recommended for accurate, high-quality reflections. Godot supports the Radiance HDR (`.hdr`) and OpenEXR (`.exr`) image formats for this purpose.
+ * You can use [this tool](https://danilw.github.io/GLSL-howto/cubemap_to_panorama_js/cubemap_to_panorama.html) to convert a cubemap to an equirectangular sky map.
+ */
+export class PanoramaSkyMaterial extends Material {
+    constructor(name = 545) { super(name); }
+
+    /**
+     * {@link Texture2D} to be applied to the {@link PanoramaSkyMaterial}.
+     */
+    get panorama(): Texture2D { return _C(this, 5804) as Texture2D; }
+    set panorama(v: Texture2D) { _C(this, 12244, v); }
+
+    /**
+     * A boolean value to determine if the background texture should be filtered or not.
+     */
+    get filter(): boolean { return _C(this, 7949) as boolean; }
+    set filter(v: boolean) { _C(this, 11395, v); }
+
+    /**
+     * The sky's overall brightness multiplier. Higher values result in a brighter sky.
+     */
+    get energyMultiplier(): number { return _C(this, 4669) as number; }
+    set energyMultiplier(v: number) { _C(this, 11296, v); }
+
+    static readonly name = _R(545, PanoramaSkyMaterial);
+}

package/gen/classes/Parallax2D.ts

@@ -0,0 +1,78 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Node2D } from './Node2D.ts';
+import type { Vector2 } from '../value-types/index.ts';
+
+/**
+ * A {@link Parallax2D} is used to create a parallax effect. It can move at a different speed relative to the camera movement using {@link scrollScale}. This creates an illusion of depth in a 2D game. If manual scrolling is desired, the {@link Camera2D} position can be ignored with {@link ignoreCameraScroll}.
+ * **Note:** Any changes to this node's position made after it enters the scene tree will be overridden if {@link ignoreCameraScroll} is `false` or {@link screenOffset} is modified.
+ */
+export class Parallax2D extends Node2D {
+    constructor(name = 546) { super(name); }
+
+    /**
+     * Multiplier to the final {@link Parallax2D}'s offset. Can be used to simulate distance from the camera.
+     * For example, a value of `1` scrolls at the same speed as the camera. A value greater than `1` scrolls faster, making objects appear closer. Less than `1` scrolls slower, making objects appear further, and a value of `0` stops the objects completely.
+     */
+    get scrollScale(): Vector2 { return _C(this, 6283) as Vector2; }
+    set scrollScale(v: Vector2) { _C(this, 12642, v); }
+
+    /**
+     * The {@link Parallax2D}'s offset. Similar to {@link screenOffset} and {@link Node2D.position}, but will not be overridden.
+     * **Note:** Values will loop if {@link repeatSize} is set higher than `0`.
+     */
+    get scrollOffset(): Vector2 { return _C(this, 6281) as Vector2; }
+    set scrollOffset(v: Vector2) { _C(this, 12640, v); }
+
+    /**
+     * Repeats the {@link Texture2D} of each of this node's children and offsets them by this value. When scrolling, the node's position loops, giving the illusion of an infinite scrolling background if the values are larger than the screen size. If an axis is set to `0`, the {@link Texture2D} will not be repeated.
+     */
+    get repeatSize(): Vector2 { return _C(this, 6144) as Vector2; }
+    set repeatSize(v: Vector2) { _C(this, 12526, v); }
+
+    /**
+     * Velocity at which the offset scrolls automatically, in pixels per second.
+     */
+    get autoscroll(): Vector2 { return _C(this, 3845) as Vector2; }
+    set autoscroll(v: Vector2) { _C(this, 10590, v); }
+
+    /**
+     * Overrides the amount of times the texture repeats. Each texture copy spreads evenly from the original by {@link repeatSize}. Useful for when zooming out with a camera.
+     */
+    get repeatTimes(): number { return _C(this, 6145) as number; }
+    set repeatTimes(v: number) { _C(this, 12527, v); }
+
+    /**
+     * Top-left limits for scrolling to begin. If the camera is outside of this limit, the {@link Parallax2D} stops scrolling. Must be lower than {@link limitEnd} minus the viewport size to work.
+     */
+    get limitBegin(): Vector2 { return _C(this, 5349) as Vector2; }
+    set limitBegin(v: Vector2) { _C(this, 11906, v); }
+
+    /**
+     * Bottom-right limits for scrolling to end. If the camera is outside of this limit, the {@link Parallax2D} will stop scrolling. Must be higher than {@link limitBegin} and the viewport size combined to work.
+     */
+    get limitEnd(): Vector2 { return _C(this, 5350) as Vector2; }
+    set limitEnd(v: Vector2) { _C(this, 11909, v); }
+
+    /**
+     * If `true`, this {@link Parallax2D} is offset by the current camera's position. If the {@link Parallax2D} is in a {@link CanvasLayer} separate from the current camera, it may be desired to match the value with {@link CanvasLayer.followViewportEnabled}.
+     */
+    get followViewport(): boolean { return _C(this, 4844) as boolean; }
+    set followViewport(v: boolean) { _C(this, 11450, v); }
+
+    /**
+     * If `true`, {@link Parallax2D}'s position is not affected by the position of the camera.
+     */
+    get ignoreCameraScroll(): boolean { return _C(this, 8002) as boolean; }
+    set ignoreCameraScroll(v: boolean) { _C(this, 11661, v); }
+
+    /**
+     * Offset used to scroll this {@link Parallax2D}. This value is updated automatically unless {@link ignoreCameraScroll} is `true`.
+     */
+    get screenOffset(): Vector2 { return _C(this, 6260) as Vector2; }
+    set screenOffset(v: Vector2) { _C(this, 12627, v); }
+
+    static readonly name = _R(546, Parallax2D);
+}

package/gen/classes/ParallaxBackground.ts

@@ -0,0 +1,52 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { CanvasLayer } from './CanvasLayer.ts';
+import type { Vector2 } from '../value-types/index.ts';
+
+/**
+ * A ParallaxBackground uses one or more {@link ParallaxLayer} child nodes to create a parallax effect. Each {@link ParallaxLayer} can move at a different speed using {@link ParallaxLayer.motionOffset}. This creates an illusion of depth in a 2D game. If not used with a {@link Camera2D}, you must manually calculate the {@link scrollOffset}.
+ * **Note:** Each {@link ParallaxBackground} is drawn on one specific {@link Viewport} and cannot be shared between multiple {@link Viewport}s, see {@link CanvasLayer.customViewport}. When using multiple {@link Viewport}s, for example in a split-screen game, you need create an individual {@link ParallaxBackground} for each {@link Viewport} you want it to be drawn on.
+ */
+export class ParallaxBackground extends CanvasLayer {
+    constructor(name = 547) { super(name); }
+
+    /**
+     * The ParallaxBackground's scroll value. Calculated automatically when using a {@link Camera2D}, but can be used to manually manage scrolling when no camera is present.
+     */
+    get scrollOffset(): Vector2 { return _C(this, 6281) as Vector2; }
+    set scrollOffset(v: Vector2) { _C(this, 12640, v); }
+
+    /**
+     * The base position offset for all {@link ParallaxLayer} children.
+     */
+    get scrollBaseOffset(): Vector2 { return _C(this, 6278) as Vector2; }
+    set scrollBaseOffset(v: Vector2) { _C(this, 12634, v); }
+
+    /**
+     * The base motion scale for all {@link ParallaxLayer} children.
+     */
+    get scrollBaseScale(): Vector2 { return _C(this, 6279) as Vector2; }
+    set scrollBaseScale(v: Vector2) { _C(this, 12635, v); }
+
+    /**
+     * Top-left limits for scrolling to begin. If the camera is outside of this limit, the background will stop scrolling. Must be lower than {@link scrollLimitEnd} to work.
+     */
+    get scrollLimitBegin(): Vector2 { return _C(this, 5349) as Vector2; }
+    set scrollLimitBegin(v: Vector2) { _C(this, 11906, v); }
+
+    /**
+     * Bottom-right limits for scrolling to end. If the camera is outside of this limit, the background will stop scrolling. Must be higher than {@link scrollLimitBegin} to work.
+     */
+    get scrollLimitEnd(): Vector2 { return _C(this, 5350) as Vector2; }
+    set scrollLimitEnd(v: Vector2) { _C(this, 11909, v); }
+
+    /**
+     * If `true`, elements in {@link ParallaxLayer} child aren't affected by the zoom level of the camera.
+     */
+    get scrollIgnoreCameraZoom(): boolean { return _C(this, 8003) as boolean; }
+    set scrollIgnoreCameraZoom(v: boolean) { _C(this, 11662, v); }
+
+    static readonly name = _R(547, ParallaxBackground);
+}

package/gen/classes/ParallaxLayer.ts

@@ -0,0 +1,38 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Node2D } from './Node2D.ts';
+import type { Vector2 } from '../value-types/index.ts';
+
+/**
+ * A ParallaxLayer must be the child of a {@link ParallaxBackground} node. Each ParallaxLayer can be set to move at different speeds relative to the camera movement or the {@link ParallaxBackground.scrollOffset} value.
+ * This node's children will be affected by its scroll offset.
+ * **Note:** Any changes to this node's position and scale made after it enters the scene will be ignored.
+ */
+export class ParallaxLayer extends Node2D {
+    constructor(name = 548) { super(name); }
+
+    /**
+     * Multiplies the ParallaxLayer's motion. If an axis is set to `0`, it will not scroll.
+     */
+    get motionScale(): Vector2 { return _C(this, 5583) as Vector2; }
+    set motionScale(v: Vector2) { _C(this, 12090, v); }
+
+    /**
+     * The ParallaxLayer's offset relative to the parent ParallaxBackground's {@link ParallaxBackground.scrollOffset}.
+     */
+    get motionOffset(): Vector2 { return _C(this, 5581) as Vector2; }
+    set motionOffset(v: Vector2) { _C(this, 12088, v); }
+
+    /**
+     * The interval, in pixels, at which the {@link ParallaxLayer} is drawn repeatedly. Useful for creating an infinitely scrolling background. If an axis is set to `0`, the {@link ParallaxLayer} will be drawn only once along that direction.
+     * **Note:** If you want the repetition to pixel-perfect match a {@link Texture2D} displayed by a child node, you should account for any scale applied to the texture when defining this interval. For example, if you use a child {@link Sprite2D} scaled to `0.5` to display a 600x600 texture, and want this sprite to be repeated continuously horizontally, you should set the mirroring to `Vector2(300, 0)`.
+     * **Note:** If the length of the viewport axis is bigger than twice the repeated axis size, it will not repeat infinitely, as the parallax layer only draws 2 instances of the layer at any given time. The visibility window is calculated from the parent {@link ParallaxBackground}'s position, not the layer's own position. So, if you use mirroring, **do not** change the {@link ParallaxLayer} position relative to its parent. Instead, if you need to adjust the background's position, set the {@link CanvasLayer.offset} property in the parent {@link ParallaxBackground}.
+     * **Note:** Despite the name, the layer will not be mirrored, it will only be repeated.
+     */
+    get motionMirroring(): Vector2 { return _C(this, 5562) as Vector2; }
+    set motionMirroring(v: Vector2) { _C(this, 12067, v); }
+
+    static readonly name = _R(548, ParallaxLayer);
+}