typescript-to-gdscript 0.1.0

package/typings/classes/RefCounted.d.ts

@@ -0,0 +1,23 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Base class for reference-counted objects. */
+declare class RefCounted extends GodotObject {
+  /** Returns the current reference count. */
+  get_reference_count(): int;
+  /**
+   * Initializes the internal reference counter. Use this only if you really know what you are doing.
+   * Returns whether the initialization was successful.
+   */
+  init_ref(): 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;
+  /**
+   * 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;
+}

package/typings/classes/ReferenceRect.d.ts

@@ -0,0 +1,22 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** A rectangular box for designing UIs. */
+declare class ReferenceRect extends Control {
+  /** Sets the border color of the {@link ReferenceRect}. */
+  border_color: Color;
+  /**
+   * Sets the border width of the {@link ReferenceRect}. The border grows both inwards and outwards with respect to the rectangle box.
+   */
+  border_width: float;
+  /**
+   * If `true`, the {@link ReferenceRect} will only be visible while in editor. Otherwise, {@link ReferenceRect} will be visible in the running project.
+   */
+  editor_only: boolean;
+  set_border_color(value: Color): void;
+  get_border_color(): Color;
+  set_border_width(value: float): void;
+  get_border_width(): float;
+  set_editor_only(value: boolean): void;
+  get_editor_only(): boolean;
+}

package/typings/classes/ReflectionProbe.d.ts

@@ -0,0 +1,118 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Captures its surroundings to create fast, accurate reflections from a given point. */
+declare class ReflectionProbe extends VisualInstance3D {
+  /**
+   * The custom ambient color to use within the {@link ReflectionProbe}'s box defined by its {@link size}. Only effective if {@link ambient_mode} is {@link AMBIENT_COLOR}.
+   */
+  ambient_color: Color;
+  /**
+   * The custom ambient color energy to use within the {@link ReflectionProbe}'s box defined by its {@link size}. Only effective if {@link ambient_mode} is {@link AMBIENT_COLOR}.
+   */
+  ambient_color_energy: float;
+  /**
+   * 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}).
+   */
+  ambient_mode: int;
+  /** Defines the distance in meters over which a probe blends into the scene. */
+  blend_distance: float;
+  /**
+   * 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.
+   */
+  box_projection: boolean;
+  /**
+   * 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).
+   */
+  cull_mask: int;
+  /**
+   * 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 update_mode}.
+   */
+  enable_shadows: boolean;
+  /** Defines the reflection intensity. Intensity modulates the strength of the reflection. */
+  intensity: float;
+  /** If `true`, reflections will ignore sky contribution. */
+  interior: boolean;
+  /**
+   * 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 update_mode}.
+   * **Note:** The maximum reflection distance is always at least equal to the probe's extents. This means that decreasing {@link max_distance} will not always cull objects from reflections, especially if the reflection probe's box defined by its {@link size} is already large.
+   */
+  max_distance: float;
+  /**
+   * The automatic LOD bias to use for meshes rendered within the {@link ReflectionProbe} (this is analog to {@link Viewport.mesh_lod_threshold}). 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 mesh_lod_threshold} to improve performance at the cost of geometry detail, especially when using the {@link UPDATE_ALWAYS} {@link update_mode}.
+   * **Note:** {@link mesh_lod_threshold} does not affect {@link GeometryInstance3D} visibility ranges (also known as "manual" LOD or hierarchical LOD).
+   */
+  mesh_lod_threshold: float;
+  /**
+   * Sets the origin offset to be used when this {@link ReflectionProbe} is in {@link box_projection} 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.
+   */
+  origin_offset: Vector3;
+  /**
+   * 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 cull_mask}, which can be used to exclude objects from appearing in the reflection while still making them affected by the {@link ReflectionProbe}.
+   */
+  reflection_mask: int;
+  /**
+   * 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.
+   */
+  size: Vector3;
+  /**
+   * Sets how frequently the {@link ReflectionProbe} is updated. Can be {@link UPDATE_ONCE} or {@link UPDATE_ALWAYS}.
+   */
+  update_mode: int;
+  set_ambient_color(value: Color): void;
+  get_ambient_color(): Color;
+  set_ambient_color_energy(value: float): void;
+  get_ambient_color_energy(): float;
+  set_ambient_mode(value: int): void;
+  get_ambient_mode(): int;
+  set_blend_distance(value: float): void;
+  get_blend_distance(): float;
+  set_enable_box_projection(value: boolean): void;
+  is_box_projection_enabled(): boolean;
+  set_cull_mask(value: int): void;
+  get_cull_mask(): int;
+  set_enable_shadows(value: boolean): void;
+  are_shadows_enabled(): boolean;
+  set_intensity(value: float): void;
+  get_intensity(): float;
+  set_as_interior(value: boolean): void;
+  is_set_as_interior(): boolean;
+  set_max_distance(value: float): void;
+  get_max_distance(): float;
+  set_mesh_lod_threshold(value: float): void;
+  get_mesh_lod_threshold(): float;
+  set_origin_offset(value: Vector3 | Vector3i): void;
+  get_origin_offset(): Vector3;
+  set_reflection_mask(value: int): void;
+  get_reflection_mask(): int;
+  set_size(value: Vector3 | Vector3i): void;
+  get_size(): Vector3;
+  set_update_mode(value: int): void;
+  get_update_mode(): int;
+
+  // enum 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.
+   */
+  static readonly UPDATE_ONCE: int;
+  /**
+   * 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}.
+   */
+  static readonly UPDATE_ALWAYS: int;
+  // enum AmbientMode
+  /**
+   * Do not apply any ambient lighting inside the {@link ReflectionProbe}'s box defined by its {@link size}.
+   */
+  static readonly AMBIENT_DISABLED: int;
+  /**
+   * Apply automatically-sourced environment lighting inside the {@link ReflectionProbe}'s box defined by its {@link size}.
+   */
+  static readonly AMBIENT_ENVIRONMENT: int;
+  /**
+   * Apply custom ambient lighting inside the {@link ReflectionProbe}'s box defined by its {@link size}. See {@link ambient_color} and {@link ambient_color_energy}.
+   */
+  static readonly AMBIENT_COLOR: int;
+}

package/typings/classes/RemoteTransform2D.d.ts

@@ -0,0 +1,33 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * RemoteTransform2D pushes its own {@link Transform2D} to another {@link Node2D} derived node in the scene.
+ */
+declare class RemoteTransform2D extends Node2D {
+  /** The {@link NodePath} to the remote node, relative to the RemoteTransform2D's position in the scene. */
+  remote_path: NodePath;
+  /** If `true`, the remote node's position is updated. */
+  update_position: boolean;
+  /** If `true`, the remote node's rotation is updated. */
+  update_rotation: boolean;
+  /** If `true`, the remote node's scale is updated. */
+  update_scale: boolean;
+  /** If `true`, global coordinates are used. If `false`, local coordinates are used. */
+  use_global_coordinates: boolean;
+  set_remote_node(value: NodePath | string): void;
+  get_remote_node(): NodePath;
+  set_update_position(value: boolean): void;
+  get_update_position(): boolean;
+  set_update_rotation(value: boolean): void;
+  get_update_rotation(): boolean;
+  set_update_scale(value: boolean): void;
+  get_update_scale(): boolean;
+  set_use_global_coordinates(value: boolean): void;
+  get_use_global_coordinates(): boolean;
+
+  /**
+   * {@link RemoteTransform2D} caches the remote node. It may not notice if the remote node disappears; {@link force_update_cache} forces it to update the cache again.
+   */
+  force_update_cache(): void;
+}

package/typings/classes/RemoteTransform3D.d.ts

@@ -0,0 +1,33 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/**
+ * RemoteTransform3D pushes its own {@link Transform3D} to another {@link Node3D} derived Node in the scene.
+ */
+declare class RemoteTransform3D extends Node3D {
+  /** The {@link NodePath} to the remote node, relative to the RemoteTransform3D's position in the scene. */
+  remote_path: NodePath;
+  /** If `true`, the remote node's position is updated. */
+  update_position: boolean;
+  /** If `true`, the remote node's rotation is updated. */
+  update_rotation: boolean;
+  /** If `true`, the remote node's scale is updated. */
+  update_scale: boolean;
+  /** If `true`, global coordinates are used. If `false`, local coordinates are used. */
+  use_global_coordinates: boolean;
+  set_remote_node(value: NodePath | string): void;
+  get_remote_node(): NodePath;
+  set_update_position(value: boolean): void;
+  get_update_position(): boolean;
+  set_update_rotation(value: boolean): void;
+  get_update_rotation(): boolean;
+  set_update_scale(value: boolean): void;
+  get_update_scale(): boolean;
+  set_use_global_coordinates(value: boolean): void;
+  get_use_global_coordinates(): boolean;
+
+  /**
+   * {@link RemoteTransform3D} caches the remote node. It may not notice if the remote node disappears; {@link force_update_cache} forces it to update the cache again.
+   */
+  force_update_cache(): void;
+}

package/typings/classes/RenderData.d.ts

@@ -0,0 +1,20 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Abstract render data object, holds frame data related to rendering a single frame of a viewport. */
+declare class RenderData extends GodotObject {
+  /**
+   * Returns the {@link RID} of the camera attributes object in the {@link RenderingServer} being used to render this viewport.
+   */
+  get_camera_attributes(): RID;
+  /**
+   * Returns the {@link RID} of the environment object in the {@link RenderingServer} being used to render this viewport.
+   */
+  get_environment(): RID;
+  /**
+   * Returns the {@link RenderSceneBuffers} object managing the scene buffers for rendering this viewport.
+   */
+  get_render_scene_buffers(): RenderSceneBuffers | null;
+  /** Returns the {@link RenderSceneData} object managing this frames scene data. */
+  get_render_scene_data(): RenderSceneData | null;
+}

package/typings/classes/RenderDataExtension.d.ts

@@ -0,0 +1,18 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** This class allows for a RenderData implementation to be made in GDExtension. */
+declare class RenderDataExtension extends RenderData {
+  /**
+   * Implement this in GDExtension to return the {@link RID} for the implementation's camera attributes object.
+   */
+  _get_camera_attributes(): RID;
+  /** Implement this in GDExtension to return the {@link RID} of the implementation's environment object. */
+  _get_environment(): RID;
+  /** Implement this in GDExtension to return the implementation's {@link RenderSceneBuffers} object. */
+  _get_render_scene_buffers(): RenderSceneBuffers | null;
+  /**
+   * Implement this in GDExtension to return the implementation's {@link RenderSceneDataExtension} object.
+   */
+  _get_render_scene_data(): RenderSceneData | null;
+}

package/typings/classes/RenderDataRD.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Render data implementation for the RenderingDevice based renderers. */
+declare class RenderDataRD extends RenderData {
+}

package/typings/classes/RenderSceneBuffers.d.ts

@@ -0,0 +1,10 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Abstract scene buffers object, created for each viewport for which 3D rendering is done. */
+declare 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;
+}

package/typings/classes/RenderSceneBuffersConfiguration.d.ts

@@ -0,0 +1,48 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Configuration object used to setup a {@link RenderSceneBuffers} object. */
+declare class RenderSceneBuffersConfiguration extends RefCounted {
+  /** Level of the anisotropic filter. */
+  anisotropic_filtering_level: int;
+  /** FSR Sharpness applicable if FSR upscaling is used. */
+  fsr_sharpness: float;
+  /** The size of the 3D render buffer used for rendering. */
+  internal_size: Vector2i;
+  /** The MSAA mode we're using for 3D rendering. */
+  msaa_3d: int;
+  /** The render target associated with these buffer. */
+  render_target: RID;
+  /**
+   * The requested scaling mode with which we upscale/downscale if {@link internal_size} and {@link target_size} are not equal.
+   */
+  scaling_3d_mode: int;
+  /** The requested screen space AA applied in post processing. */
+  screen_space_aa: int;
+  /** The target (upscale) size if scaling is used. */
+  target_size: Vector2i;
+  /** Bias applied to mipmaps. */
+  texture_mipmap_bias: float;
+  /** The number of views we're rendering. */
+  view_count: int;
+  set_anisotropic_filtering_level(value: int): void;
+  get_anisotropic_filtering_level(): int;
+  set_fsr_sharpness(value: float): void;
+  get_fsr_sharpness(): float;
+  set_internal_size(value: Vector2i | Vector2): void;
+  get_internal_size(): Vector2i;
+  set_msaa_3d(value: int): void;
+  get_msaa_3d(): int;
+  set_render_target(value: RID): void;
+  get_render_target(): RID;
+  set_scaling_3d_mode(value: int): void;
+  get_scaling_3d_mode(): int;
+  set_screen_space_aa(value: int): void;
+  get_screen_space_aa(): int;
+  set_target_size(value: Vector2i | Vector2): void;
+  get_target_size(): Vector2i;
+  set_texture_mipmap_bias(value: float): void;
+  get_texture_mipmap_bias(): float;
+  set_view_count(value: int): void;
+  get_view_count(): int;
+}

package/typings/classes/RenderSceneBuffersExtension.d.ts

@@ -0,0 +1,16 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** This class allows for a RenderSceneBuffer implementation to be made in GDExtension. */
+declare class RenderSceneBuffersExtension extends RenderSceneBuffers {
+  /** Implement this in GDExtension to handle the (re)sizing of a viewport. */
+  _configure(config: RenderSceneBuffersConfiguration): void;
+  /** Implement this in GDExtension to change the anisotropic filtering level. */
+  _set_anisotropic_filtering_level(anisotropic_filtering_level: int): void;
+  /** Implement this in GDExtension to record a new FSR sharpness value. */
+  _set_fsr_sharpness(fsr_sharpness: float): void;
+  /** Implement this in GDExtension to change the texture mipmap bias. */
+  _set_texture_mipmap_bias(texture_mipmap_bias: float): void;
+  /** Implement this in GDExtension to react to the debanding flag changing. */
+  _set_use_debanding(use_debanding: boolean): void;
+}

package/typings/classes/RenderSceneBuffersRD.d.ts

@@ -0,0 +1,85 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Render scene buffer implementation for the RenderingDevice based renderers. */
+declare class RenderSceneBuffersRD extends RenderSceneBuffers {
+  /** Frees all buffers related to this context. */
+  clear_context(context: string): void;
+  /**
+   * Create a new texture with the given definition and cache this under the given name. Will return the existing texture if it already exists.
+   */
+  create_texture(context: string, name: string, data_format: int, usage_bits: int, texture_samples: int, size: Vector2i | Vector2, layers: int, mipmaps: int, unique: boolean, discardable: boolean): RID;
+  /**
+   * Create a new texture using the given format and view and cache this under the given name. Will return the existing texture if it already exists.
+   */
+  create_texture_from_format(context: string, name: string, format: RDTextureFormat, view: RDTextureView, unique: boolean): RID;
+  /**
+   * Create a new texture view for an existing texture and cache this under the given `view_name`. Will return the existing texture view if it already exists. Will error if the source texture doesn't exist.
+   */
+  create_texture_view(context: string, name: string, view_name: string, view: RDTextureView): RID;
+  /**
+   * Returns the specified layer from the color texture we are rendering 3D content to.
+   * If `msaa` is `true` and MSAA is enabled, this returns the MSAA variant of the buffer.
+   */
+  get_color_layer(layer: int, msaa?: boolean): RID;
+  /**
+   * Returns the color texture we are rendering 3D content to. If multiview is used this will be a texture array with all views.
+   * If `msaa` is `true` and MSAA is enabled, this returns the MSAA variant of the buffer.
+   */
+  get_color_texture(msaa?: boolean): RID;
+  /**
+   * Returns the specified layer from the depth texture we are rendering 3D content to.
+   * If `msaa` is `true` and MSAA is enabled, this returns the MSAA variant of the buffer.
+   */
+  get_depth_layer(layer: int, msaa?: boolean): RID;
+  /**
+   * Returns the depth texture we are rendering 3D content to. If multiview is used this will be a texture array with all views.
+   * If `msaa` is `true` and MSAA is enabled, this returns the MSAA variant of the buffer.
+   */
+  get_depth_texture(msaa?: boolean): RID;
+  /**
+   * Returns the FSR sharpness value used while rendering the 3D content (if {@link get_scaling_3d_mode} is an FSR mode).
+   */
+  get_fsr_sharpness(): float;
+  /**
+   * Returns the internal size of the render buffer (size before upscaling) with which textures are created by default.
+   */
+  get_internal_size(): Vector2i;
+  /** Returns the applied 3D MSAA mode for this viewport. */
+  get_msaa_3d(): int;
+  /** Returns the render target associated with this buffers object. */
+  get_render_target(): RID;
+  /** Returns the scaling mode used for upscaling. */
+  get_scaling_3d_mode(): int;
+  /** Returns the screen-space antialiasing method applied. */
+  get_screen_space_aa(): int;
+  /** Returns the target size of the render buffer (size after upscaling). */
+  get_target_size(): Vector2i;
+  /** Returns a cached texture with this name. */
+  get_texture(context: string, name: string): RID;
+  /** Returns the texture format information with which a cached texture was created. */
+  get_texture_format(context: string, name: string): RDTextureFormat | null;
+  /** Returns the number of MSAA samples used. */
+  get_texture_samples(): int;
+  /** Returns a specific slice (layer or mipmap) for a cached texture. */
+  get_texture_slice(context: string, name: string, layer: int, mipmap: int, layers: int, mipmaps: int): RID;
+  /** Returns the texture size of a given slice of a cached texture. */
+  get_texture_slice_size(context: string, name: string, mipmap: int): Vector2i;
+  /** Returns a specific view of a slice (layer or mipmap) for a cached texture. */
+  get_texture_slice_view(context: string, name: string, layer: int, mipmap: int, layers: int, mipmaps: int, view: RDTextureView): RID;
+  /** Returns `true` if debanding is enabled. */
+  get_use_debanding(): boolean;
+  /** Returns `true` if TAA is enabled. */
+  get_use_taa(): boolean;
+  /** Returns the specified layer from the velocity texture we are rendering 3D content to. */
+  get_velocity_layer(layer: int, msaa?: boolean): RID;
+  /**
+   * Returns the velocity texture we are rendering 3D content to. If multiview is used this will be a texture array with all views.
+   * If `msaa` is **true** and MSAA is enabled, this returns the MSAA variant of the buffer.
+   */
+  get_velocity_texture(msaa?: boolean): RID;
+  /** Returns the view count for the associated viewport. */
+  get_view_count(): int;
+  /** Returns `true` if a cached texture exists for this name. */
+  has_texture(context: string, name: string): boolean;
+}

package/typings/classes/RenderSceneData.d.ts

@@ -0,0 +1,29 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Abstract render data object, holds scene data related to rendering a single frame of a viewport. */
+declare class RenderSceneData extends GodotObject {
+  /**
+   * Returns the camera projection used to render this frame.
+   * **Note:** If more than one view is rendered, this will return a combined projection.
+   */
+  get_cam_projection(): Projection;
+  /**
+   * Returns the camera transform used to render this frame.
+   * **Note:** If more than one view is rendered, this will return a centered transform.
+   */
+  get_cam_transform(): Transform3D;
+  /** Return the {@link RID} of the uniform buffer containing the scene data as a UBO. */
+  get_uniform_buffer(): RID;
+  /** Returns the number of views being rendered. */
+  get_view_count(): int;
+  /**
+   * Returns the eye offset per view used to render this frame. This is the offset between our camera transform and the eye transform.
+   */
+  get_view_eye_offset(view: int): Vector3;
+  /**
+   * Returns the view projection per view used to render this frame.
+   * **Note:** If a single view is rendered, this returns the camera projection. If more than one view is rendered, this will return a projection for the given view including the eye offset.
+   */
+  get_view_projection(view: int): Projection;
+}

package/typings/classes/RenderSceneDataExtension.d.ts

@@ -0,0 +1,20 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** This class allows for a RenderSceneData implementation to be made in GDExtension. */
+declare class RenderSceneDataExtension extends RenderSceneData {
+  /** Implement this in GDExtension to return the camera {@link Projection}. */
+  _get_cam_projection(): Projection;
+  /** Implement this in GDExtension to return the camera {@link Transform3D}. */
+  _get_cam_transform(): Transform3D;
+  /**
+   * Implement this in GDExtension to return the {@link RID} of the uniform buffer containing the scene data as a UBO.
+   */
+  _get_uniform_buffer(): RID;
+  /** Implement this in GDExtension to return the view count. */
+  _get_view_count(): int;
+  /** Implement this in GDExtension to return the eye offset for the given `view`. */
+  _get_view_eye_offset(view: int): Vector3;
+  /** Implement this in GDExtension to return the view {@link Projection} for the given `view`. */
+  _get_view_projection(view: int): Projection;
+}

package/typings/classes/RenderSceneDataRD.d.ts

@@ -0,0 +1,6 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Render scene data implementation for the RenderingDevice based renderers. */
+declare class RenderSceneDataRD extends RenderSceneData {
+}