@ringozz/godot 0.1.0

package/gen/classes/RefCounted.ts

@@ -0,0 +1,41 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Object } from './Object.ts';
+
+/**
+ * Base class for any object that keeps a reference count. {@link Resource} and many other helper objects inherit this class.
+ * Unlike other {@link Object} types, {@link RefCounted}s keep an internal reference counter so that they are automatically released when no longer in use, and only then. {@link RefCounted}s therefore do not need to be freed manually with {@link Object.free}.
+ * {@link RefCounted} instances caught in a cyclic reference will **not** be freed automatically. For example, if a node holds a reference to instance `A`, which directly or indirectly holds a reference back to `A`, `A`'s reference count will be 2. Destruction of the node will leave `A` dangling with a reference count of 1, and there will be a memory leak. To prevent this, one of the references in the cycle can be made weak with {@link weakref}.
+ * In the vast majority of use cases, instantiating and using {@link RefCounted}-derived types is all you need to do. The methods provided in this class are only for advanced users, and can cause issues if misused.
+ * **Note:** In C#, reference-counted objects will not be freed instantly after they are no longer in use. Instead, garbage collection will run periodically and will free reference-counted objects that are no longer in use. This means that unused ones will remain in memory for a while before being removed.
+ */
+export class RefCounted extends Object {
+    constructor(name = 640) { super(name); }
+
+    /**
+     * Initializes the internal reference counter. Use this only if you really know what you are doing.
+     * Returns whether the initialization was successful.
+     */
+    initRef(): boolean { return _C(this, 7606) as boolean; }
+
+    /**
+     * Increments the internal reference counter. Use this only if you really know what you are doing.
+     * Returns `true` if the increment was successful, `false` otherwise.
+     */
+    reference(): boolean { return _C(this, 9772) as boolean; }
+
+    /**
+     * Decrements the internal reference counter. Use this only if you really know what you are doing.
+     * Returns `true` if the object should be freed after the decrement, `false` otherwise.
+     */
+    unreference(): boolean { return _C(this, 14486) as boolean; }
+
+    /**
+     * Returns the current reference count.
+     */
+    getReferenceCount(): number { return _C(this, 6099) as number; }
+
+    static readonly name = _R(640, RefCounted);
+}

package/gen/classes/ReferenceRect.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 { Control } from './Control.ts';
+import type { Color } from '../value-types/index.ts';
+
+/**
+ * A rectangular box that displays only a colored border around its rectangle (see {@link Control.getRect}). It can be used to visualize the extents of a {@link Control} node, for testing purposes.
+ */
+export class ReferenceRect extends Control {
+    constructor(name = 641) { super(name); }
+
+    /**
+     * Sets the border color of the {@link ReferenceRect}.
+     */
+    get borderColor(): Color { return _C(this, 3986) as Color; }
+    set borderColor(v: Color) { _C(this, 10726, v); }
+
+    /**
+     * Sets the border width of the {@link ReferenceRect}. The border grows both inwards and outwards with respect to the rectangle box.
+     */
+    get borderWidth(): number { return _C(this, 3988) as number; }
+    set borderWidth(v: number) { _C(this, 10728, v); }
+
+    /**
+     * If `true`, the {@link ReferenceRect} will only be visible while in editor. Otherwise, {@link ReferenceRect} will be visible in the running project.
+     */
+    get editorOnly(): boolean { return _C(this, 4605) as boolean; }
+    set editorOnly(v: boolean) { _C(this, 11221, v); }
+
+    static readonly name = _R(641, ReferenceRect);
+}

package/gen/classes/ReflectionProbe.ts

@@ -0,0 +1,145 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { VisualInstance3D } from './VisualInstance3D.ts';
+import type { Color, Vector3 } from '../value-types/index.ts';
+
+/**
+ * Captures its surroundings as a cubemap, and stores versions of it with increasing levels of blur to simulate different material roughnesses.
+ * The {@link ReflectionProbe} is used to create high-quality reflections at a low performance cost (when {@link updateMode} is {@link UPDATE_ONCE}). {@link ReflectionProbe}s can be blended together and with the rest of the scene smoothly. {@link ReflectionProbe}s can also be combined with {@link VoxelGI}, SDFGI ({@link Environment.sdfgiEnabled}) and screen-space reflections ({@link Environment.ssrEnabled}) to get more accurate reflections in specific areas. {@link ReflectionProbe}s render all objects within their {@link cullMask}, so updating them can be quite expensive. It is best to update them once with the important static objects and then leave them as-is.
+ * **Note:** Unlike {@link VoxelGI} and SDFGI, {@link ReflectionProbe}s only source their environment from a {@link WorldEnvironment} node. If you specify an {@link Environment} resource within a {@link Camera3D} node, it will be ignored by the {@link ReflectionProbe}. This can lead to incorrect lighting within the {@link ReflectionProbe}.
+ * **Note:** When using the Mobile rendering method, only `8` reflection probes can be displayed on each mesh resource, while the Compatibility rendering method only supports up to `2` reflection probes on each mesh. Attempting to display more than `8` reflection probes on a single mesh resource using the Mobile renderer will result in reflection probes flickering in and out as the camera moves, while the Compatibility renderer will not render any additional probes if more than `2` reflection probes are being used.
+ * **Note:** When using the Mobile rendering method, reflection probes will only correctly affect meshes whose visibility AABB intersects with the reflection probe's AABB. If using a shader to deform the mesh in a way that makes it go outside its AABB, {@link GeometryInstance3D.extraCullMargin} must be increased on the mesh. Otherwise, the reflection probe may not be visible on the mesh.
+ */
+export class ReflectionProbe extends VisualInstance3D {
+    constructor(name = 642) { super(name); }
+
+    /**
+     * Sets how frequently the {@link ReflectionProbe} is updated. Can be {@link UPDATE_ONCE} or {@link UPDATE_ALWAYS}.
+     */
+    get updateMode(): UpdateMode { return _C(this, 6960) as UpdateMode; }
+    set updateMode(v: UpdateMode) { _C(this, 13180, v); }
+
+    /**
+     * Defines the reflection intensity. Intensity modulates the strength of the reflection.
+     */
+    get intensity(): number { return _C(this, 5142) as number; }
+    set intensity(v: number) { _C(this, 11733, v); }
+
+    /**
+     * Defines the distance in meters over which a probe blends into the scene.
+     */
+    get blendDistance(): number { return _C(this, 3931) as number; }
+    set blendDistance(v: number) { _C(this, 10676, v); }
+
+    /**
+     * The maximum distance away from the {@link ReflectionProbe} an object can be before it is culled. Decrease this to improve performance, especially when using the {@link UPDATE_ALWAYS} {@link updateMode}.
+     * **Note:** The maximum reflection distance is always at least equal to the probe's extents. This means that decreasing {@link maxDistance} will not always cull objects from reflections, especially if the reflection probe's box defined by its {@link size} is already large.
+     */
+    get maxDistance(): number { return _C(this, 5467) as number; }
+    set maxDistance(v: number) { _C(this, 11992, v); }
+
+    /**
+     * The size of the reflection probe. The larger the size, the more space covered by the probe, which will lower the perceived resolution. It is best to keep the size only as large as you need it.
+     * **Note:** To better fit areas that are not aligned to the grid, you can rotate the {@link ReflectionProbe} node.
+     */
+    get size(): Vector3 { return _C(this, 6399) as Vector3; }
+    set size(v: Vector3) { _C(this, 12752, v); }
+
+    /**
+     * Sets the origin offset to be used when this {@link ReflectionProbe} is in {@link boxProjection} mode. This can be set to a non-zero value to ensure a reflection fits a rectangle-shaped room, while reducing the number of objects that "get in the way" of the reflection.
+     */
+    get originOffset(): Vector3 { return _C(this, 5744) as Vector3; }
+    set originOffset(v: Vector3) { _C(this, 12205, v); }
+
+    /**
+     * If `true`, enables box projection. This makes reflections look more correct in rectangle-shaped rooms by offsetting the reflection center depending on the camera's location.
+     * **Note:** To better fit rectangle-shaped rooms that are not aligned to the grid, you can rotate the {@link ReflectionProbe} node.
+     */
+    get boxProjection(): boolean { return _C(this, 7802) as boolean; }
+    set boxProjection(v: boolean) { _C(this, 11266, v); }
+
+    /**
+     * If `true`, reflections will ignore sky contribution.
+     */
+    get interior(): boolean { return _C(this, 8294) as boolean; }
+    set interior(v: boolean) { _C(this, 10537, v); }
+
+    /**
+     * If `true`, computes shadows in the reflection probe. This makes the reflection probe slower to render; you may want to disable this if using the {@link UPDATE_ALWAYS} {@link updateMode}.
+     */
+    get enableShadows(): boolean { return _C(this, 1547) as boolean; }
+    set enableShadows(v: boolean) { _C(this, 11283, v); }
+
+    /**
+     * Sets the cull mask which determines what objects are drawn by this probe. Every {@link VisualInstance3D} with a layer included in this cull mask will be rendered by the probe. It is best to only include large objects which are likely to take up a lot of space in the reflection in order to save on rendering cost.
+     * This can also be used to prevent an object from reflecting upon itself (for instance, a {@link ReflectionProbe} centered on a vehicle).
+     */
+    get cullMask(): number { return _C(this, 4339) as number; }
+    set cullMask(v: number) { _C(this, 10981, v); }
+
+    /**
+     * Sets the reflection mask which determines what objects have reflections applied from this probe. Every {@link VisualInstance3D} with a layer included in this reflection mask will have reflections applied from this probe. See also {@link cullMask}, which can be used to exclude objects from appearing in the reflection while still making them affected by the {@link ReflectionProbe}.
+     */
+    get reflectionMask(): number { return _C(this, 6108) as number; }
+    set reflectionMask(v: number) { _C(this, 12500, v); }
+
+    /**
+     * The automatic LOD bias to use for meshes rendered within the {@link ReflectionProbe} (this is analog to {@link Viewport.meshLodThreshold}). Higher values will use less detailed versions of meshes that have LOD variations generated. If set to `0.0`, automatic LOD is disabled. Increase {@link meshLodThreshold} to improve performance at the cost of geometry detail, especially when using the {@link UPDATE_ALWAYS} {@link updateMode}.
+     * **Note:** {@link meshLodThreshold} does not affect {@link GeometryInstance3D} visibility ranges (also known as "manual" LOD or hierarchical LOD).
+     */
+    get meshLodThreshold(): number { return _C(this, 5515) as number; }
+    set meshLodThreshold(v: number) { _C(this, 12028, v); }
+
+    /**
+     * The ambient color to use within the {@link ReflectionProbe}'s box defined by its {@link size}. The ambient color will smoothly blend with other {@link ReflectionProbe}s and the rest of the scene (outside the {@link ReflectionProbe}'s box defined by its {@link size}).
+     */
+    get ambientMode(): AmbientMode { return _C(this, 3739) as AmbientMode; }
+    set ambientMode(v: AmbientMode) { _C(this, 10480, v); }
+
+    /**
+     * The custom ambient color to use within the {@link ReflectionProbe}'s box defined by its {@link size}. Only effective if {@link ambientMode} is {@link AMBIENT_COLOR}.
+     */
+    get ambientColor(): Color { return _C(this, 3734) as Color; }
+    set ambientColor(v: Color) { _C(this, 10475, v); }
+
+    /**
+     * The custom ambient color energy to use within the {@link ReflectionProbe}'s box defined by its {@link size}. Only effective if {@link ambientMode} is {@link AMBIENT_COLOR}.
+     */
+    get ambientColorEnergy(): number { return _C(this, 3735) as number; }
+    set ambientColorEnergy(v: number) { _C(this, 10476, v); }
+
+    static readonly name = _R(642, ReflectionProbe);
+}
+
+export const UpdateMode = {
+    /**
+     * Update the probe once on the next frame (recommended for most objects). The corresponding radiance map will be generated over the following six frames. This takes more time to update than {@link UPDATE_ALWAYS}, but it has a lower performance cost and can result in higher-quality reflections. The ReflectionProbe is updated when its transform changes, but not when nearby geometry changes. You can force a {@link ReflectionProbe} update by moving the {@link ReflectionProbe} slightly in any direction.
+     */
+    UPDATE_ONCE: 0,
+    /**
+     * Update the probe every frame. This provides better results for fast-moving dynamic objects (such as cars). However, it has a significant performance cost. Due to the cost, it's recommended to only use one ReflectionProbe with {@link UPDATE_ALWAYS} at most per scene. For all other use cases, use {@link UPDATE_ONCE}.
+     */
+    UPDATE_ALWAYS: 1,
+} as const;
+
+export type UpdateMode = (typeof UpdateMode)[keyof typeof UpdateMode];
+
+export const AmbientMode = {
+    /**
+     * Do not apply any ambient lighting inside the {@link ReflectionProbe}'s box defined by its {@link size}.
+     */
+    AMBIENT_DISABLED: 0,
+    /**
+     * Apply automatically-sourced environment lighting inside the {@link ReflectionProbe}'s box defined by its {@link size}.
+     */
+    AMBIENT_ENVIRONMENT: 1,
+    /**
+     * Apply custom ambient lighting inside the {@link ReflectionProbe}'s box defined by its {@link size}. See {@link ambientColor} and {@link ambientColorEnergy}.
+     */
+    AMBIENT_COLOR: 2,
+} as const;
+
+export type AmbientMode = (typeof AmbientMode)[keyof typeof AmbientMode];
+

package/gen/classes/RegEx.ts

@@ -0,0 +1,129 @@
+// 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 { GodotArray, PackedStringArray } from '../heap-types/index.ts';
+import type { RegExMatch } from './RegExMatch.ts';
+
+/**
+ * A regular expression (or regex) is a compact language that can be used to recognize strings that follow a specific pattern, such as URLs, email addresses, complete sentences, etc. For example, a regex of `ab[0-9]` would find any string that is `ab` followed by any number from `0` to `9`. For a more in-depth look, you can easily find various tutorials and detailed explanations on the Internet.
+ * To begin, the RegEx object needs to be compiled with the search pattern using {@link compile} before it can be used. Alternatively, the static method {@link createFromString} can be used to create and compile a RegEx object in a single method call.
+ *
+ * ```text
+ *
+ * var regex = RegEx.new()
+ * regex.compile("\\w-(\\d+)")
+ * # Shorthand to create and compile a regex (used in the examples below):
+ * var regex2 = RegEx.create_from_string("\\w-(\\d+)")
+ *
+ * ```
+ *
+ * The search pattern must be escaped first for GDScript before it is escaped for the expression. For example, `compile("\\d+")` would be read by RegEx as `\d+`. Similarly, `compile("\"(?:\\\\.|[^\"])*\"")` would be read as `"(?:\\.|[^"])*"`. In GDScript, you can also use raw string literals (r-strings). For example, `compile(r'"(?:\\.|[^"])*"')` would be read the same.
+ * Using {@link search}, you can find the pattern within the given text. If a pattern is found, {@link RegExMatch} is returned and you can retrieve details of the results using methods such as {@link RegExMatch.getString} and {@link RegExMatch.getStart}.
+ *
+ * ```text
+ *
+ * var regex = RegEx.create_from_string("\\w-(\\d+)")
+ * var result = regex.search("abc n-0123")
+ * if result:
+ * 	print(result.get_string()) # Prints "n-0123"
+ *
+ * ```
+ *
+ * The results of capturing groups `()` can be retrieved by passing the group number to the various methods in {@link RegExMatch}. Group 0 is the default and will always refer to the entire pattern. In the above example, calling `result.get_string(1)` would give you `0123`.
+ * This version of RegEx also supports named capturing groups, and the names can be used to retrieve the results. If two or more groups have the same name, the name would only refer to the first one with a match.
+ *
+ * ```text
+ *
+ * var regex = RegEx.create_from_string("d(?<digit>[0-9]+)|x(?<digit>[0-9a-f]+)")
+ * var result = regex.search("the number is x2f")
+ * if result:
+ * 	print(result.get_string("digit")) # Prints "2f"
+ *
+ * ```
+ *
+ * If you need to process multiple results, {@link searchAll} generates a list of all non-overlapping results. This can be combined with a `for` loop for convenience.
+ *
+ * ```text
+ *
+ * # Prints "01 03 0 3f 42"
+ * for result in regex.search_all("d01, d03, d0c, x3f and x42"):
+ * 	print(result.get_string("digit"))
+ *
+ * ```
+ *
+ * **Example:** Split a string using a RegEx:
+ *
+ * ```text
+ *
+ * var regex = RegEx.create_from_string("\\S+") # Negated whitespace character class.
+ * var results = []
+ * for result in regex.search_all("One  Two \n\tThree"):
+ * 	results.push_back(result.get_string())
+ * print(results) # Prints ["One", "Two", "Three"]
+ *
+ * ```
+ *
+ * **Note:** Godot's regex implementation is based on the [PCRE2](https://www.pcre.org/) library. You can view the full pattern reference [here](https://www.pcre.org/current/doc/html/pcre2pattern.html).
+ * **Tip:** You can use [Regexr](https://regexr.com/) to test regular expressions online.
+ */
+export class RegEx extends RefCounted {
+    constructor(name = 643) { super(name); }
+
+    /**
+     * Creates and compiles a new {@link RegEx} object. See also {@link compile}.
+     */
+    static createFromString(pattern: string, showError?: boolean /* = true */): RegEx { return _C(643, 2537, pattern, showError) as RegEx; }
+
+    /**
+     * This method resets the state of the object, as if it was freshly created. Namely, it unassigns the regular expression of this object.
+     */
+    clear(): void { _C(this, 2232); }
+
+    /**
+     * Compiles and assign the search pattern to use. Returns {@link OK} if the compilation is successful. If compilation fails, returns {@link FAILED} and when `showError` is `true`, details are printed to standard output.
+     */
+    compile(pattern: string, showError?: boolean /* = true */): Error { return _C(this, 2388, pattern, showError) as Error; }
+
+    /**
+     * Searches the text for the compiled pattern. Returns a {@link RegExMatch} container of the first matching result if found, otherwise `null`.
+     * The region to search within can be specified with `offset` and `end`. This is useful when searching for another match in the same `subject` by calling this method again after a previous success. Note that setting these parameters differs from passing over a shortened string. For example, the start anchor `^` is not affected by `offset`, and the character before `offset` will be checked for the word boundary `\b`.
+     */
+    search(subject: string, offset?: number /* = 0 */, end?: number /* = -1 */): RegExMatch { return _C(this, 10324, subject, offset, end) as RegExMatch; }
+
+    /**
+     * Searches the text for the compiled pattern. Returns an array of {@link RegExMatch} containers for each non-overlapping result. If no results were found, an empty array is returned instead.
+     * The region to search within can be specified with `offset` and `end`. This is useful when searching for another match in the same `subject` by calling this method again after a previous success. Note that setting these parameters differs from passing over a shortened string. For example, the start anchor `^` is not affected by `offset`, and the character before `offset` will be checked for the word boundary `\b`.
+     */
+    searchAll(subject: string, offset?: number /* = 0 */, end?: number /* = -1 */): GodotArray<RegExMatch> { return _C(this, 10325, subject, offset, end) as GodotArray<RegExMatch>; }
+
+    /**
+     * Searches the text for the compiled pattern and replaces it with the specified string. Escapes and backreferences such as `$1` and `$name` are expanded and resolved. By default, only the first instance is replaced, but it can be changed for all instances (global replacement).
+     * The region to search within can be specified with `offset` and `end`. This is useful when searching for another match in the same `subject` by calling this method again after a previous success. Note that setting these parameters differs from passing over a shortened string. For example, the start anchor `^` is not affected by `offset`, and the character before `offset` will be checked for the word boundary `\b`.
+     */
+    sub(subject: string, replacement: string, all?: boolean /* = false */, offset?: number /* = 0 */, end?: number /* = -1 */): string { return _C(this, 13982, subject, replacement, all, offset, end) as string; }
+
+    /**
+     * Returns whether this object has a valid search pattern assigned.
+     */
+    isValid(): boolean { return _C(this, 8432) as boolean; }
+
+    /**
+     * Returns the original search pattern that was compiled.
+     */
+    getPattern(): string { return _C(this, 5867) as string; }
+
+    /**
+     * Returns the number of capturing groups in compiled pattern.
+     */
+    getGroupCount(): number { return _C(this, 4986) as number; }
+
+    /**
+     * Returns an array of names of named capturing groups in the compiled pattern. They are ordered by appearance.
+     */
+    getNames(): PackedStringArray { return _C(this, 5606) as PackedStringArray; }
+
+    static readonly name = _R(643, RegEx);
+}

package/gen/classes/RegExMatch.ts

@@ -0,0 +1,53 @@
+// 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 { GodotDictionary, PackedStringArray, Variant } from '../heap-types/index.ts';
+
+/**
+ * Contains the results of a single {@link RegEx} match returned by {@link RegEx.search} and {@link RegEx.searchAll}. It can be used to find the position and range of the match and its capturing groups, and it can extract its substring for you.
+ */
+export class RegExMatch extends RefCounted {
+    constructor(name = 644) { super(name); }
+
+    /**
+     * Returns the number of capturing groups.
+     */
+    getGroupCount(): number { return _C(this, 4986) as number; }
+
+    /**
+     * Returns the substring of the match from the source string. Capturing groups can be retrieved by providing its group number as an integer or its string name (if it's a named group). The default value of 0 refers to the whole pattern.
+     * Returns an empty string if the group did not match or doesn't exist.
+     */
+    getString(name?: Variant /* = 0 */): string { return _C(this, 6574, name) as string; }
+
+    /**
+     * Returns the starting position of the match within the source string. The starting position of capturing groups can be retrieved by providing its group number as an integer or its string name (if it's a named group). The default value of 0 refers to the whole pattern.
+     * Returns -1 if the group did not match or doesn't exist.
+     */
+    getStart(name?: Variant /* = 0 */): number { return _C(this, 6533, name) as number; }
+
+    /**
+     * Returns the end position of the match within the source string. The end position of capturing groups can be retrieved by providing its group number as an integer or its string name (if it's a named group). The default value of 0 refers to the whole pattern.
+     * Returns -1 if the group did not match or doesn't exist.
+     */
+    getEnd(name?: Variant /* = 0 */): number { return _C(this, 4660, name) as number; }
+
+    /**
+     * The source string used with the search pattern to find this matching result.
+     */
+    get subject(): string { return _C(this, 6601) as string; }
+
+    /**
+     * A dictionary of named groups and its corresponding group number. Only groups that were matched are included. If multiple groups have the same name, that name would refer to the first matching one.
+     */
+    get names(): GodotDictionary { return _C(this, 5606) as GodotDictionary; }
+
+    /**
+     * An {@link Array} of the match and its capturing groups.
+     */
+    get strings(): PackedStringArray { return _C(this, 6583) as PackedStringArray; }
+
+    static readonly name = _R(644, RegExMatch);
+}

package/gen/classes/RemoteTransform2D.ts

@@ -0,0 +1,51 @@
+// 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 { NodePath } from '../heap-types/index.ts';
+
+/**
+ * RemoteTransform2D pushes its own {@link Transform2D} to another {@link Node2D} derived node (called the remote node) in the scene.
+ * It can be set to update another node's position, rotation and/or scale. It can use either global or local coordinates.
+ */
+export class RemoteTransform2D extends Node2D {
+    constructor(name = 645) { super(name); }
+
+    /**
+     * {@link RemoteTransform2D} caches the remote node. It may not notice if the remote node disappears; {@link forceUpdateCache} forces it to update the cache again.
+     */
+    forceUpdateCache(): void { _C(this, 3540); }
+
+    /**
+     * The {@link NodePath} to the remote node, relative to the RemoteTransform2D's position in the scene.
+     */
+    get remotePath(): NodePath { return _C(this, 6126) as NodePath; }
+    set remotePath(v: NodePath) { _C(this, 12517, v); }
+
+    /**
+     * If `true`, global coordinates are used. If `false`, local coordinates are used.
+     */
+    get useGlobalCoordinates(): boolean { return _C(this, 6978) as boolean; }
+    set useGlobalCoordinates(v: boolean) { _C(this, 13217, v); }
+
+    /**
+     * If `true`, the remote node's position is updated.
+     */
+    get updatePosition(): boolean { return _C(this, 6962) as boolean; }
+    set updatePosition(v: boolean) { _C(this, 13182, v); }
+
+    /**
+     * If `true`, the remote node's rotation is updated.
+     */
+    get updateRotation(): boolean { return _C(this, 6963) as boolean; }
+    set updateRotation(v: boolean) { _C(this, 13183, v); }
+
+    /**
+     * If `true`, the remote node's scale is updated.
+     */
+    get updateScale(): boolean { return _C(this, 6964) as boolean; }
+    set updateScale(v: boolean) { _C(this, 13184, v); }
+
+    static readonly name = _R(645, RemoteTransform2D);
+}

package/gen/classes/RemoteTransform3D.ts

@@ -0,0 +1,51 @@
+// 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 { NodePath } from '../heap-types/index.ts';
+
+/**
+ * RemoteTransform3D pushes its own {@link Transform3D} to another {@link Node3D} derived Node (called the remote node) in the scene.
+ * It can be set to update another Node's position, rotation and/or scale. It can use either global or local coordinates.
+ */
+export class RemoteTransform3D extends Node3D {
+    constructor(name = 646) { super(name); }
+
+    /**
+     * {@link RemoteTransform3D} caches the remote node. It may not notice if the remote node disappears; {@link forceUpdateCache} forces it to update the cache again.
+     */
+    forceUpdateCache(): void { _C(this, 3540); }
+
+    /**
+     * The {@link NodePath} to the remote node, relative to the RemoteTransform3D's position in the scene.
+     */
+    get remotePath(): NodePath { return _C(this, 6126) as NodePath; }
+    set remotePath(v: NodePath) { _C(this, 12517, v); }
+
+    /**
+     * If `true`, global coordinates are used. If `false`, local coordinates are used.
+     */
+    get useGlobalCoordinates(): boolean { return _C(this, 6978) as boolean; }
+    set useGlobalCoordinates(v: boolean) { _C(this, 13217, v); }
+
+    /**
+     * If `true`, the remote node's position is updated.
+     */
+    get updatePosition(): boolean { return _C(this, 6962) as boolean; }
+    set updatePosition(v: boolean) { _C(this, 13182, v); }
+
+    /**
+     * If `true`, the remote node's rotation is updated.
+     */
+    get updateRotation(): boolean { return _C(this, 6963) as boolean; }
+    set updateRotation(v: boolean) { _C(this, 13183, v); }
+
+    /**
+     * If `true`, the remote node's scale is updated.
+     */
+    get updateScale(): boolean { return _C(this, 6964) as boolean; }
+    set updateScale(v: boolean) { _C(this, 13184, v); }
+
+    static readonly name = _R(646, RemoteTransform3D);
+}

package/gen/classes/RenderData.ts

@@ -0,0 +1,37 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Object } from './Object.ts';
+import type { RID } from '../heap-types/index.ts';
+import type { RenderSceneBuffers } from './RenderSceneBuffers.ts';
+import type { RenderSceneData } from './RenderSceneData.ts';
+
+/**
+ * Abstract render data object, exists for the duration of rendering a single viewport. See also {@link RenderDataRD}, {@link RenderSceneData}, and {@link RenderSceneDataRD}.
+ * **Note:** This is an internal rendering server object. Do not instantiate this class from a script.
+ */
+export class RenderData extends Object {
+
+    /**
+     * Returns the {@link RenderSceneBuffers} object managing the scene buffers for rendering this viewport.
+     */
+    getRenderSceneBuffers(): RenderSceneBuffers { return _C(this, 6132) as RenderSceneBuffers; }
+
+    /**
+     * Returns the {@link RenderSceneData} object managing this frames scene data.
+     */
+    getRenderSceneData(): RenderSceneData { return _C(this, 6133) as RenderSceneData; }
+
+    /**
+     * Returns the {@link RID} of the environment object in the {@link RenderingServer} being used to render this viewport.
+     */
+    getEnvironment(): RID { return _C(this, 4678) as RID; }
+
+    /**
+     * Returns the {@link RID} of the camera attributes object in the {@link RenderingServer} being used to render this viewport.
+     */
+    getCameraAttributes(): RID { return _C(this, 4063) as RID; }
+
+    static readonly name = _R(647, RenderData);
+}

package/gen/classes/RenderDataExtension.ts

@@ -0,0 +1,17 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { RenderData } from './RenderData.ts';
+import type { RID } from '../heap-types/index.ts';
+import type { RenderSceneBuffers } from './RenderSceneBuffers.ts';
+import type { RenderSceneData } from './RenderSceneData.ts';
+
+/**
+ * This class allows for a RenderData implementation to be made in GDExtension.
+ */
+export class RenderDataExtension extends RenderData {
+    constructor(name = 648) { super(name); }
+
+    static readonly name = _R(648, RenderDataExtension);
+}

package/gen/classes/RenderDataRD.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 { RenderData } from './RenderData.ts';
+
+/**
+ * This object manages all render data for the {@link RenderingDevice}-based renderers. See also {@link RenderData}, {@link RenderSceneData}, and {@link RenderSceneDataRD}.
+ * **Note:** This is an internal rendering server object. Do not instantiate this class from a script.
+ */
+export class RenderDataRD extends RenderData {
+    constructor(name = 649) { super(name); }
+
+    static readonly name = _R(649, RenderDataRD);
+}

package/gen/classes/RenderSceneBuffers.ts

@@ -0,0 +1,20 @@
+// 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 { RenderSceneBuffersConfiguration } from './RenderSceneBuffersConfiguration.ts';
+
+/**
+ * Abstract scene buffers object, created for each viewport for which 3D rendering is done. It manages any additional buffers used during rendering and will discard buffers when the viewport is resized. See also {@link RenderSceneBuffersRD}.
+ * **Note:** This is an internal rendering server object. Do not instantiate this class from a script.
+ */
+export class RenderSceneBuffers extends RefCounted {
+
+    /**
+     * This method is called by the rendering server when the associated viewport's configuration is changed. It will discard the old buffers and recreate the internal buffers used.
+     */
+    configure(config: RenderSceneBuffersConfiguration): void { _C(this, 2430, config); }
+
+    static readonly name = _R(650, RenderSceneBuffers);
+}