@ringozz/godot 0.1.0

package/gen/classes/VoxelGI.ts

@@ -0,0 +1,85 @@
+// 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 { Vector3 } from '../value-types/index.ts';
+import type { CameraAttributes } from './CameraAttributes.ts';
+import type { Node } from './Node.ts';
+import type { VoxelGIData } from './VoxelGIData.ts';
+
+/**
+ * {@link VoxelGI}s are used to provide high-quality real-time indirect light and reflections to scenes. They precompute the effect of objects that emit light and the effect of static geometry to simulate the behavior of complex light in real-time. {@link VoxelGI}s need to be baked before having a visible effect. However, once baked, dynamic objects will receive light from them. Furthermore, lights can be fully dynamic or baked.
+ * **Note:** {@link VoxelGI} is only supported in the Forward+ rendering method, not Mobile or Compatibility.
+ * **Procedural generation:** {@link VoxelGI} can be baked in an exported project, which makes it suitable for procedurally generated or user-built levels as long as all the geometry is generated in advance. For games where geometry is generated at any time during gameplay, SDFGI is more suitable (see {@link Environment.sdfgiEnabled}).
+ * **Performance:** {@link VoxelGI} is relatively demanding on the GPU and is not suited to low-end hardware such as integrated graphics (consider {@link LightmapGI} instead). To improve performance, adjust {@link ProjectSettings.rendering/globalIllumination/voxelGi/quality} and enable {@link ProjectSettings.rendering/globalIllumination/gi/useHalfResolution} in the Project Settings. To provide a fallback for low-end hardware, consider adding an option to disable {@link VoxelGI} in your project's options menus. A {@link VoxelGI} node can be disabled by hiding it.
+ * **Note:** Meshes should have sufficiently thick walls to avoid light leaks (avoid one-sided walls). For interior levels, enclose your level geometry in a sufficiently large box and bridge the loops to close the mesh. To further prevent light leaks, you can also strategically place temporary {@link MeshInstance3D} nodes with their {@link GeometryInstance3D.giMode} set to {@link GeometryInstance3D.GI_MODE_STATIC}. These temporary nodes can then be hidden after baking the {@link VoxelGI} node.
+ */
+export class VoxelGI extends VisualInstance3D {
+    constructor(name = 953) { super(name); }
+
+    /**
+     * Bakes the effect from all {@link GeometryInstance3D}s marked with {@link GeometryInstance3D.GI_MODE_STATIC} and {@link Light3D}s marked with either {@link Light3D.BAKE_STATIC} or {@link Light3D.BAKE_DYNAMIC}. If `createVisualDebug` is `true`, after baking the light, this will generate a {@link MultiMesh} that has a cube representing each solid cell with each cube colored to the cell's albedo color. This can be used to visualize the {@link VoxelGI}'s data and debug any issues that may be occurring.
+     * **Note:** {@link bake} works from the editor and in exported projects. This makes it suitable for procedurally generated or user-built levels. Baking a {@link VoxelGI} node generally takes from 5 to 20 seconds in most scenes. Reducing {@link subdiv} can speed up baking.
+     * **Note:** {@link GeometryInstance3D}s and {@link Light3D}s must be fully ready before {@link bake} is called. If you are procedurally creating those and some meshes or lights are missing from your baked {@link VoxelGI}, use `call_deferred("bake")` instead of calling {@link bake} directly.
+     */
+    bake(fromNode?: Node /* = null */, createVisualDebug?: boolean /* = false */): void { _C(this, 1708, fromNode, createVisualDebug); }
+
+    /**
+     * Calls {@link bake} with `create_visual_debug` enabled.
+     */
+    debugBake(): void { _C(this, 2659); }
+
+    /**
+     * Number of times to subdivide the grid that the {@link VoxelGI} operates on. A higher number results in finer detail and thus higher visual quality, while lower numbers result in better performance.
+     */
+    get subdiv(): Subdiv { return _C(this, 6597) as Subdiv; }
+    set subdiv(v: Subdiv) { _C(this, 12923, v); }
+
+    /**
+     * The size of the area covered by the {@link VoxelGI}. This must be `1.0` or greater on each axis.
+     * **Note:** If you make the size larger without increasing the number of subdivisions with {@link subdiv}, the size of each cell will increase and result in less detailed lighting.
+     */
+    get size(): Vector3 { return _C(this, 6399) as Vector3; }
+    set size(v: Vector3) { _C(this, 12752, v); }
+
+    /**
+     * The {@link CameraAttributes} resource that specifies exposure levels to bake at. Auto-exposure and non exposure properties will be ignored. Exposure settings should be used to reduce the dynamic range present when baking. If exposure is too high, the {@link VoxelGI} will have banding artifacts or may have over-exposure artifacts.
+     */
+    get cameraAttributes(): CameraAttributes { return _C(this, 4063) as CameraAttributes; }
+    set cameraAttributes(v: CameraAttributes) { _C(this, 10785, v); }
+
+    /**
+     * The {@link VoxelGIData} resource that holds the data for this {@link VoxelGI}.
+     */
+    get data(): VoxelGIData { return _C(this, 6018) as VoxelGIData; }
+    set data(v: VoxelGIData) { _C(this, 12421, v); }
+
+    static readonly name = _R(953, VoxelGI);
+}
+
+export const Subdiv = {
+    /**
+     * Use 64 subdivisions. This is the lowest quality setting, but the fastest. Use it if you can, but especially use it on lower-end hardware.
+     */
+    SUBDIV_64: 0,
+    /**
+     * Use 128 subdivisions. This is the default quality setting.
+     */
+    SUBDIV_128: 1,
+    /**
+     * Use 256 subdivisions.
+     */
+    SUBDIV_256: 2,
+    /**
+     * Use 512 subdivisions. This is the highest quality setting, but the slowest. On lower-end hardware, this could cause the GPU to stall.
+     */
+    SUBDIV_512: 3,
+    /**
+     * Represents the size of the {@link Subdiv} enum.
+     */
+    SUBDIV_MAX: 4,
+} as const;
+
+export type Subdiv = (typeof Subdiv)[keyof typeof Subdiv];
+

package/gen/classes/VoxelGIData.ts

@@ -0,0 +1,95 @@
+// 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 { PackedByteArray, PackedInt32Array } from '../heap-types/index.ts';
+import type { AABB, Transform3D, Vector3 } from '../value-types/index.ts';
+
+/**
+ * {@link VoxelGIData} contains baked voxel global illumination for use in a {@link VoxelGI} node. {@link VoxelGIData} also offers several properties to adjust the final appearance of the global illumination. These properties can be adjusted at run-time without having to bake the {@link VoxelGI} node again.
+ * **Note:** To prevent text-based scene files (`.tscn`) from growing too much and becoming slow to load and save, always save {@link VoxelGIData} to an external binary resource file (`.res`) instead of embedding it within the scene. This can be done by clicking the dropdown arrow next to the {@link VoxelGIData} resource, choosing **Edit**, clicking the floppy disk icon at the top of the Inspector then choosing **Save As...**.
+ */
+export class VoxelGIData extends Resource {
+    constructor(name = 954) { super(name); }
+
+    /**
+     * Initializes this {@link VoxelGIData} with the specified data. `octreeCells` must be a multiple of 32. `octreeCells` must be double the size of `dataCells`. The allocated data can be retrieved later using the various getter methods.
+     */
+    allocate(toCellXform: Transform3D, aabb: AABB, octreeSize: Vector3, octreeCells: PackedByteArray, dataCells: PackedByteArray, distanceField: PackedByteArray, levelCounts: PackedInt32Array): void { _C(this, 1409, toCellXform, aabb, octreeSize, octreeCells, dataCells, distanceField, levelCounts); }
+
+    /**
+     * Returns the bounds of the baked voxel data as an {@link AABB}, which should match {@link VoxelGI.size} after being baked (which only contains the size as a {@link Vector3}).
+     * **Note:** If the size was modified without baking the VoxelGI data, then the value of {@link getBounds} and {@link VoxelGI.size} will not match.
+     */
+    getBounds(): AABB { return _C(this, 3997) as AABB; }
+
+    /**
+     * Returns the baked octree size for this {@link VoxelGIData}, which corresponds to the number of subdivisions per axis. This can be viewed in the editor by hovering the **Bake VoxelGI** button at the top of the 3D editor viewport when a {@link VoxelGI} node is selected and looking at the **Subdivisions** field in the tooltip.
+     */
+    getOctreeSize(): Vector3 { return _C(this, 5700) as Vector3; }
+
+    /**
+     * Returns the baked cell transform for this {@link VoxelGIData}.
+     */
+    getToCellXform(): Transform3D { return _C(this, 6836) as Transform3D; }
+
+    /**
+     * Returns the baked octree cell data for this {@link VoxelGIData}.
+     */
+    getOctreeCells(): PackedByteArray { return _C(this, 5699) as PackedByteArray; }
+
+    /**
+     * Returns the baked cell data for this {@link VoxelGIData}.
+     */
+    getDataCells(): PackedByteArray { return _C(this, 4412) as PackedByteArray; }
+
+    /**
+     * Returns the baked level counts for this {@link VoxelGIData}.
+     */
+    getLevelCounts(): PackedInt32Array { return _C(this, 5332) as PackedInt32Array; }
+
+    /**
+     * The dynamic range to use (`1.0` represents a low dynamic range scene brightness). Higher values can be used to provide brighter indirect lighting, at the cost of more visible color banding in dark areas (both in indirect lighting and reflections). To avoid color banding, it's recommended to use the lowest value that does not result in visible light clipping.
+     */
+    get dynamicRange(): number { return _C(this, 4591) as number; }
+    set dynamicRange(v: number) { _C(this, 11205, v); }
+
+    /**
+     * The energy of the indirect lighting and reflections produced by the {@link VoxelGI} node. Higher values result in brighter indirect lighting. If indirect lighting looks too flat, try decreasing {@link propagation} while increasing {@link energy} at the same time. See also {@link useTwoBounces} which influences the indirect lighting's effective brightness.
+     */
+    get energy(): number { return _C(this, 4668) as number; }
+    set energy(v: number) { _C(this, 11295, v); }
+
+    /**
+     * The normal bias to use for indirect lighting and reflections. Higher values reduce self-reflections visible in non-rough materials, at the cost of more visible light leaking and flatter-looking indirect lighting. To prioritize hiding self-reflections over lighting quality, set {@link bias} to `0.0` and {@link normalBias} to a value between `1.0` and `2.0`.
+     */
+    get bias(): number { return _C(this, 3912) as number; }
+    set bias(v: number) { _C(this, 10655, v); }
+
+    /**
+     * The normal bias to use for indirect lighting and reflections. Higher values reduce self-reflections visible in non-rough materials, at the cost of more visible light leaking and flatter-looking indirect lighting. See also {@link bias}. To prioritize hiding self-reflections over lighting quality, set {@link bias} to `0.0` and {@link normalBias} to a value between `1.0` and `2.0`.
+     */
+    get normalBias(): number { return _C(this, 5676) as number; }
+    set normalBias(v: number) { _C(this, 12146, v); }
+
+    /**
+     * The multiplier to use when light bounces off a surface. Higher values result in brighter indirect lighting. If indirect lighting looks too flat, try decreasing {@link propagation} while increasing {@link energy} at the same time. See also {@link useTwoBounces} which influences the indirect lighting's effective brightness.
+     */
+    get propagation(): number { return _C(this, 6048) as number; }
+    set propagation(v: number) { _C(this, 12445, v); }
+
+    /**
+     * If `true`, performs two bounces of indirect lighting instead of one. This makes indirect lighting look more natural and brighter at a small performance cost. The second bounce is also visible in reflections. If the scene appears too bright after enabling {@link useTwoBounces}, adjust {@link propagation} and {@link energy}.
+     */
+    get useTwoBounces(): boolean { return _C(this, 8427) as boolean; }
+    set useTwoBounces(v: boolean) { _C(this, 13245, v); }
+
+    /**
+     * If `true`, {@link Environment} lighting is ignored by the {@link VoxelGI} node. If `false`, {@link Environment} lighting is taken into account by the {@link VoxelGI} node. {@link Environment} lighting updates in real-time, which means it can be changed without having to bake the {@link VoxelGI} node again.
+     */
+    get interior(): boolean { return _C(this, 8035) as boolean; }
+    set interior(v: boolean) { _C(this, 11737, v); }
+
+    static readonly name = _R(954, VoxelGIData);
+}

package/gen/classes/WeakRef.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 { Variant } from '../heap-types/index.ts';
+
+/**
+ * A weakref can hold a {@link RefCounted} without contributing to the reference counter. A weakref can be created from an {@link Object} using {@link weakref}. If this object is not a reference, weakref still works, however, it does not have any effect on the object. Weakrefs are useful in cases where multiple classes have variables that refer to each other. Without weakrefs, using these classes could lead to memory leaks, since both references keep each other from being released. Making part of the variables a weakref can prevent this cyclic dependency, and allows the references to be released.
+ */
+export class WeakRef extends RefCounted {
+    constructor(name = 955) { super(name); }
+
+    /**
+     * Returns the {@link Object} this weakref is referring to. Returns `null` if that object no longer exists.
+     */
+    getRef(): Variant | null { return _C(this, 6095) as Variant | null; }
+
+    static readonly name = _R(955, WeakRef);
+}

package/gen/classes/WebRTCDataChannel.ts

@@ -0,0 +1,115 @@
+// 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 WebRTCDataChannel extends PacketPeer {
+
+    /**
+     * Reserved, but not used for now.
+     */
+    poll(): Error { return _C(this, 9471) as Error; }
+
+    /**
+     * Closes this data channel, notifying the other peer.
+     */
+    close(): void { _C(this, 2331); }
+
+    /**
+     * Returns `true` if the last received packet was transferred as text. See {@link writeMode}.
+     */
+    wasStringPacket(): boolean { return _C(this, 14841) as boolean; }
+
+    /**
+     * Returns the current state of this channel.
+     */
+    getReadyState(): ChannelState { return _C(this, 6084) as ChannelState; }
+
+    /**
+     * Returns the label assigned to this channel during creation.
+     */
+    getLabel(): string { return _C(this, 5297) as string; }
+
+    /**
+     * Returns `true` if this channel was created with ordering enabled (default).
+     */
+    isOrdered(): boolean { return _C(this, 8156) as boolean; }
+
+    /**
+     * Returns the ID assigned to this channel during creation (or auto-assigned during negotiation).
+     * If the channel is not negotiated out-of-band the ID will only be available after the connection is established (will return `65535` until then).
+     */
+    getId(): number { return _C(this, 5062) as number; }
+
+    /**
+     * Returns the `maxPacketLifeTime` value assigned to this channel during creation.
+     * Will be `65535` if not specified.
+     */
+    getMaxPacketLifeTime(): number { return _C(this, 5477) as number; }
+
+    /**
+     * Returns the `maxRetransmits` value assigned to this channel during creation.
+     * Will be `65535` if not specified.
+     */
+    getMaxRetransmits(): number { return _C(this, 5484) as number; }
+
+    /**
+     * Returns the sub-protocol assigned to this channel during creation. An empty string if not specified.
+     */
+    getProtocol(): string { return _C(this, 6052) as string; }
+
+    /**
+     * Returns `true` if this channel was created with out-of-band configuration.
+     */
+    isNegotiated(): boolean { return _C(this, 8131) as boolean; }
+
+    /**
+     * Returns the number of bytes currently queued to be sent over this channel.
+     */
+    getBufferedAmount(): number { return _C(this, 4008) as number; }
+
+    /**
+     * The transfer mode to use when sending outgoing packet. Either text or binary.
+     */
+    get writeMode(): WriteMode { return _C(this, 7169) as WriteMode; }
+    set writeMode(v: WriteMode) { _C(this, 13391, v); }
+
+    static readonly name = _R(956, WebRTCDataChannel);
+}
+
+export const WriteMode = {
+    /**
+     * Tells the channel to send data over this channel as text. An external peer (non-Godot) would receive this as a string.
+     */
+    WRITE_MODE_TEXT: 0,
+    /**
+     * Tells the channel to send data over this channel as binary. An external peer (non-Godot) would receive this as array buffer or blob.
+     */
+    WRITE_MODE_BINARY: 1,
+} as const;
+
+export type WriteMode = (typeof WriteMode)[keyof typeof WriteMode];
+
+export const ChannelState = {
+    /**
+     * The channel was created, but it's still trying to connect.
+     */
+    STATE_CONNECTING: 0,
+    /**
+     * The channel is currently open, and data can flow over it.
+     */
+    STATE_OPEN: 1,
+    /**
+     * The channel is being closed, no new messages will be accepted, but those already in queue will be flushed.
+     */
+    STATE_CLOSING: 2,
+    /**
+     * The channel was closed, or connection failed.
+     */
+    STATE_CLOSED: 3,
+} as const;
+
+export type ChannelState = (typeof ChannelState)[keyof typeof ChannelState];
+

package/gen/classes/WebRTCDataChannelExtension.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 { WebRTCDataChannel } from './WebRTCDataChannel.ts';
+import type { Error } from '../global-enums.ts';
+import type { ChannelState } from './WebRTCDataChannel.ts';
+import type { WriteMode } from './WebSocketPeer.ts';
+
+export class WebRTCDataChannelExtension extends WebRTCDataChannel {
+    constructor(name = 957) { super(name); }
+
+    static readonly name = _R(957, WebRTCDataChannelExtension);
+}

package/gen/classes/WebRTCMultiplayerPeer.ts

@@ -0,0 +1,63 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { MultiplayerPeer } from './MultiplayerPeer.ts';
+import type { Error } from '../global-enums.ts';
+import type { GodotArray, GodotDictionary } from '../heap-types/index.ts';
+import type { WebRTCPeerConnection } from './WebRTCPeerConnection.ts';
+
+/**
+ * This class constructs a full mesh of {@link WebRTCPeerConnection} (one connection for each peer) that can be used as a {@link MultiplayerAPI.multiplayerPeer}.
+ * You can add each {@link WebRTCPeerConnection} via {@link addPeer} or remove them via {@link removePeer}. Peers must be added in {@link WebRTCPeerConnection.STATE_NEW} state to allow it to create the appropriate channels. This class will not create offers nor set descriptions, it will only poll them, and notify connections and disconnections.
+ * When creating the peer via {@link createClient} or {@link createServer} the {@link MultiplayerPeer.isServerRelaySupported} method will return `true` enabling peer exchange and packet relaying when supported by the {@link MultiplayerAPI} implementation.
+ * **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 WebRTCMultiplayerPeer extends MultiplayerPeer {
+    constructor(name = 958) { super(name); }
+
+    /**
+     * Initialize the multiplayer peer as a server (with unique ID of `1`). This mode enables {@link MultiplayerPeer.isServerRelaySupported}, allowing the upper {@link MultiplayerAPI} layer to perform peer exchange and packet relaying.
+     * You can optionally specify a `channelsConfig` array of {@link MultiplayerPeer.TransferMode} which will be used to create extra channels (WebRTC only supports one transfer mode per channel).
+     */
+    createServer(channelsConfig?: GodotArray /* = [] */): Error { return _C(this, 2568, channelsConfig) as Error; }
+
+    /**
+     * Initialize the multiplayer peer as a client with the given `peerId` (must be between 2 and 2147483647). In this mode, you should only call {@link addPeer} once and with `peerId` of `1`. This mode enables {@link MultiplayerPeer.isServerRelaySupported}, allowing the upper {@link MultiplayerAPI} layer to perform peer exchange and packet relaying.
+     * You can optionally specify a `channelsConfig` array of {@link MultiplayerPeer.TransferMode} which will be used to create extra channels (WebRTC only supports one transfer mode per channel).
+     */
+    createClient(peerId: number, channelsConfig?: GodotArray /* = [] */): Error { return _C(this, 2512, peerId, channelsConfig) as Error; }
+
+    /**
+     * Initialize the multiplayer peer as a mesh (i.e. all peers connect to each other) with the given `peerId` (must be between 1 and 2147483647).
+     */
+    createMesh(peerId: number, channelsConfig?: GodotArray /* = [] */): Error { return _C(this, 2552, peerId, channelsConfig) as Error; }
+
+    /**
+     * Add a new peer to the mesh with the given `peerId`. The {@link WebRTCPeerConnection} must be in state {@link WebRTCPeerConnection.STATE_NEW}.
+     * Three channels will be created for reliable, unreliable, and ordered transport. The value of `unreliableLifetime` will be passed to the `"maxPacketLifetime"` option when creating unreliable and ordered channels (see {@link WebRTCPeerConnection.createDataChannel}).
+     */
+    addPeer(peer: WebRTCPeerConnection, peerId: number, unreliableLifetime?: number /* = 1 */): Error { return _C(this, 1268, peer, peerId, unreliableLifetime) as Error; }
+
+    /**
+     * Remove the peer with given `peerId` from the mesh. If the peer was connected, and {@link MultiplayerPeer.peer_connected} was emitted for it, then {@link MultiplayerPeer.peer_disconnected} will be emitted.
+     */
+    removePeer(peerId: number): void { _C(this, 9945, peerId); }
+
+    /**
+     * Returns `true` if the given `peerId` is in the peers map (it might not be connected though).
+     */
+    hasPeer(peerId: number): boolean { return _C(this, 7429, peerId) as boolean; }
+
+    /**
+     * Returns a dictionary representation of the peer with given `peerId` with three keys. `"connection"` containing the {@link WebRTCPeerConnection} to this peer, `"channels"` an array of three {@link WebRTCDataChannel}, and `"connected"` a boolean representing if the peer connection is currently connected (all three channels are open).
+     */
+    getPeer(peerId: number): GodotDictionary { return _C(this, 5870, peerId) as GodotDictionary; }
+
+    /**
+     * Returns a dictionary which keys are the peer ids and values the peer representation as in {@link getPeer}.
+     */
+    getPeers(): GodotDictionary { return _C(this, 5873) as GodotDictionary; }
+
+    static readonly name = _R(958, WebRTCMultiplayerPeer);
+}

package/gen/classes/WebRTCPeerConnection.ts

@@ -0,0 +1,220 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R, _G } from '../../src/runtime.ts';
+import { RefCounted } from './RefCounted.ts';
+import type { Error } from '../global-enums.ts';
+import type { GodotDictionary, Signal, StringName } from '../heap-types/index.ts';
+import type { WebRTCDataChannel } from './WebRTCDataChannel.ts';
+
+/**
+ * A WebRTC connection between the local computer and a remote peer. Provides an interface to connect, maintain, and monitor the connection.
+ * Setting up a WebRTC connection between two peers may not seem a trivial task, but it can be broken down into 3 main steps:
+ * - The peer that wants to initiate the connection (`A` from now on) creates an offer and sends it to the other peer (`B` from now on).
+ * - `B` receives the offer, generates an answer, and sends it to `A`.
+ * - `A` and `B` then generate and exchange ICE candidates with each other.
+ * After these steps, the connection should be established. Refer to the linked tutorials for details.
+ */
+export class WebRTCPeerConnection extends RefCounted {
+    constructor(name = 959) { super(name); }
+
+    /**
+     * Sets the `extensionClass` as the default {@link WebRTCPeerConnectionExtension} returned when creating a new {@link WebRTCPeerConnection}.
+     */
+    static setDefaultExtension(extensionClass: StringName): void { _C(959, 11062, extensionClass); }
+
+    /**
+     * Re-initialize this peer connection, closing any previously active connection, and going back to state {@link STATE_NEW}. A dictionary of `configuration` options can be passed to configure the peer connection.
+     * Valid `configuration` options are:
+     *
+     * ```text
+     *
+     * {
+     * 	"iceServers": [
+     * 		{
+     * 			"urls": [ "stun:stun.example.com:3478" ], # One or more STUN servers.
+     * 		},
+     * 		{
+     * 			"urls": [ "turn:turn.example.com:3478" ], # One or more TURN servers.
+     * 			"username": "a_username", # Optional username for the TURN server.
+     * 			"credential": "a_password", # Optional password for the TURN server.
+     * 		}
+     * 	]
+     * }
+     *
+     * ```
+     */
+    initialize(configuration?: GodotDictionary /* = {} */): Error { return _C(this, 7614, configuration) as Error; }
+
+    /**
+     * Returns a new {@link WebRTCDataChannel} (or `null` on failure) with given `label` and optionally configured via the `options` dictionary. This method can only be called when the connection is in state {@link STATE_NEW}.
+     * There are two ways to create a working data channel: either call {@link createDataChannel} on only one of the peer and listen to {@link data_channel_received} on the other, or call {@link createDataChannel} on both peers, with the same values, and the `"negotiated"` option set to `true`.
+     * Valid `options` are:
+     *
+     * ```text
+     *
+     * {
+     * 	"negotiated": true, # When set to true (default off), means the channel is negotiated out of band. "id" must be set too. "data_channel_received" will not be called.
+     * 	"id": 1, # When "negotiated" is true this value must also be set to the same value on both peer.
+     *
+     * 	# Only one of maxRetransmits and maxPacketLifeTime can be specified, not both. They make the channel unreliable (but also better at real time).
+     * 	"maxRetransmits": 1, # Specify the maximum number of attempt the peer will make to retransmits packets if they are not acknowledged.
+     * 	"maxPacketLifeTime": 100, # Specify the maximum amount of time before giving up retransmitions of unacknowledged packets (in milliseconds).
+     * 	"ordered": true, # When in unreliable mode (i.e. either "maxRetransmits" or "maxPacketLifetime" is set), "ordered" (true by default) specify if packet ordering is to be enforced.
+     *
+     * 	"protocol": "my-custom-protocol", # A custom sub-protocol string for this channel.
+     * }
+     *
+     * ```
+     *
+     * **Note:** You must keep a reference to channels created this way, or it will be closed.
+     */
+    createDataChannel(label: string, options?: GodotDictionary /* = {} */): WebRTCDataChannel | null { return _C(this, 2516, label, options) as WebRTCDataChannel | null; }
+
+    /**
+     * Creates a new SDP offer to start a WebRTC connection with a remote peer. At least one {@link WebRTCDataChannel} must have been created before calling this method.
+     * If this functions returns {@link OK}, {@link session_description_created} will be called when the session is ready to be sent.
+     */
+    createOffer(): Error { return _C(this, 2556) as Error; }
+
+    /**
+     * Sets the SDP description of the local peer. This should be called in response to {@link session_description_created}.
+     * After calling this function the peer will start emitting {@link ice_candidate_created} (unless an {@link Error} different from {@link OK} is returned).
+     */
+    setLocalDescription(type: string, sdp: string): Error { return _C(this, 11939, type, sdp) as Error; }
+
+    /**
+     * Sets the SDP description of the remote peer. This should be called with the values generated by a remote peer and received over the signaling server.
+     * If `type` is `"offer"` the peer will emit {@link session_description_created} with the appropriate answer.
+     * If `type` is `"answer"` the peer will start emitting {@link ice_candidate_created}.
+     */
+    setRemoteDescription(type: string, sdp: string): Error { return _C(this, 12516, type, sdp) as Error; }
+
+    /**
+     * Add an ice candidate generated by a remote peer (and received over the signaling server). See {@link ice_candidate_created}.
+     */
+    addIceCandidate(media: string, index: number, name: string): Error { return _C(this, 1227, media, index, name) as Error; }
+
+    /**
+     * Call this method frequently (e.g. in {@link Node.Process} or {@link Node.PhysicsProcess}) to properly receive signals.
+     */
+    poll(): Error { return _C(this, 9471) as Error; }
+
+    /**
+     * Close the peer connection and all data channels associated with it.
+     * **Note:** You cannot reuse this object for a new connection unless you call {@link initialize}.
+     */
+    close(): void { _C(this, 2331); }
+
+    /**
+     * Returns the connection state.
+     */
+    getConnectionState(): ConnectionState { return _C(this, 4277) as ConnectionState; }
+
+    /**
+     * Returns the ICE {@link GatheringState} of the connection. This lets you detect, for example, when collection of ICE candidates has finished.
+     */
+    getGatheringState(): GatheringState { return _C(this, 4916) as GatheringState; }
+
+    /**
+     * Returns the signaling state on the local end of the connection while connecting or reconnecting to another peer.
+     */
+    getSignalingState(): SignalingState { return _C(this, 6392) as SignalingState; }
+
+    /**
+     * Emitted after a successful call to {@link createOffer} or {@link setRemoteDescription} (when it generates an answer). The parameters are meant to be passed to {@link setLocalDescription} on this object, and sent to the remote peer over the signaling server.
+     */
+    get sessionDescriptionCreated(): Signal<(type: string, sdp: string) => void> { return _G(this, 10381) as Signal<(type: string, sdp: string) => void>; }
+    set sessionDescriptionCreated(v: ((type: string, sdp: string) => void) | null) { _G(this, 10381, v); }
+
+    /**
+     * Emitted when a new ICE candidate has been created. The three parameters are meant to be passed to the remote peer over the signaling server.
+     */
+    get iceCandidateCreated(): Signal<(media: string, index: number, name: string) => void> { return _G(this, 7549) as Signal<(media: string, index: number, name: string) => void>; }
+    set iceCandidateCreated(v: ((media: string, index: number, name: string) => void) | null) { _G(this, 7549, v); }
+
+    /**
+     * Emitted when a new in-band channel is received, i.e. when the channel was created with `negotiated: false` (default).
+     * The object will be an instance of {@link WebRTCDataChannel}. You must keep a reference of it or it will be closed automatically. See {@link createDataChannel}.
+     */
+    get dataChannelReceived(): Signal<(channel: WebRTCDataChannel) => void> { return _G(this, 2654) as Signal<(channel: WebRTCDataChannel) => void>; }
+    set dataChannelReceived(v: ((channel: WebRTCDataChannel) => void) | null) { _G(this, 2654, v); }
+
+    static readonly name = _R(959, WebRTCPeerConnection);
+}
+
+export const ConnectionState = {
+    /**
+     * The connection is new, data channels and an offer can be created in this state.
+     */
+    STATE_NEW: 0,
+    /**
+     * The peer is connecting, ICE is in progress, none of the transports has failed.
+     */
+    STATE_CONNECTING: 1,
+    /**
+     * The peer is connected, all ICE transports are connected.
+     */
+    STATE_CONNECTED: 2,
+    /**
+     * At least one ICE transport is disconnected.
+     */
+    STATE_DISCONNECTED: 3,
+    /**
+     * One or more of the ICE transports failed.
+     */
+    STATE_FAILED: 4,
+    /**
+     * The peer connection is closed (after calling {@link close} for example).
+     */
+    STATE_CLOSED: 5,
+} as const;
+
+export type ConnectionState = (typeof ConnectionState)[keyof typeof ConnectionState];
+
+export const GatheringState = {
+    /**
+     * The peer connection was just created and hasn't done any networking yet.
+     */
+    GATHERING_STATE_NEW: 0,
+    /**
+     * The ICE agent is in the process of gathering candidates for the connection.
+     */
+    GATHERING_STATE_GATHERING: 1,
+    /**
+     * The ICE agent has finished gathering candidates. If something happens that requires collecting new candidates, such as a new interface being added or the addition of a new ICE server, the state will revert to gathering to gather those candidates.
+     */
+    GATHERING_STATE_COMPLETE: 2,
+} as const;
+
+export type GatheringState = (typeof GatheringState)[keyof typeof GatheringState];
+
+export const SignalingState = {
+    /**
+     * There is no ongoing exchange of offer and answer underway. This may mean that the {@link WebRTCPeerConnection} is new ({@link STATE_NEW}) or that negotiation is complete and a connection has been established ({@link STATE_CONNECTED}).
+     */
+    SIGNALING_STATE_STABLE: 0,
+    /**
+     * The local peer has called {@link setLocalDescription}, passing in SDP representing an offer (usually created by calling {@link createOffer}), and the offer has been applied successfully.
+     */
+    SIGNALING_STATE_HAVE_LOCAL_OFFER: 1,
+    /**
+     * The remote peer has created an offer and used the signaling server to deliver it to the local peer, which has set the offer as the remote description by calling {@link setRemoteDescription}.
+     */
+    SIGNALING_STATE_HAVE_REMOTE_OFFER: 2,
+    /**
+     * The offer sent by the remote peer has been applied and an answer has been created and applied by calling {@link setLocalDescription}. This provisional answer describes the supported media formats and so forth, but may not have a complete set of ICE candidates included. Further candidates will be delivered separately later.
+     */
+    SIGNALING_STATE_HAVE_LOCAL_PRANSWER: 3,
+    /**
+     * A provisional answer has been received and successfully applied in response to an offer previously sent and established by calling {@link setLocalDescription}.
+     */
+    SIGNALING_STATE_HAVE_REMOTE_PRANSWER: 4,
+    /**
+     * The {@link WebRTCPeerConnection} has been closed.
+     */
+    SIGNALING_STATE_CLOSED: 5,
+} as const;
+
+export type SignalingState = (typeof SignalingState)[keyof typeof SignalingState];
+

package/gen/classes/WebRTCPeerConnectionExtension.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 { WebRTCPeerConnection } from './WebRTCPeerConnection.ts';
+import type { Error } from '../global-enums.ts';
+import type { GodotDictionary } from '../heap-types/index.ts';
+import type { WebRTCDataChannel } from './WebRTCDataChannel.ts';
+import type { ConnectionState, GatheringState, SignalingState } from './WebRTCPeerConnection.ts';
+
+export class WebRTCPeerConnectionExtension extends WebRTCPeerConnection {
+    constructor(name = 960) { super(name); }
+
+    static readonly name = _R(960, WebRTCPeerConnectionExtension);
+}