typescript-to-gdscript 0.1.0

package/typings/classes/Camera2D.d.ts

@@ -0,0 +1,214 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Camera node for 2D scenes. */
+declare class Camera2D extends Node2D {
+  /** The Camera2D's anchor point. */
+  anchor_mode: int;
+  /**
+   * The custom {@link Viewport} node attached to the {@link Camera2D}. If `null` or not a {@link Viewport}, uses the default viewport instead.
+   */
+  custom_viewport: Node | null;
+  /**
+   * Bottom margin needed to drag the camera. A value of `1` makes the camera move only when reaching the bottom edge of the screen.
+   */
+  drag_bottom_margin: float;
+  /**
+   * If `true`, the camera only moves when reaching the horizontal (left and right) drag margins. If `false`, the camera moves horizontally regardless of margins.
+   */
+  drag_horizontal_enabled: boolean;
+  /**
+   * The relative horizontal drag offset of the camera between the right (`-1`) and left (`1`) drag margins.
+   * **Note:** Used to set the initial horizontal drag offset; determine the current offset; or force the current offset. It's not automatically updated when {@link drag_horizontal_enabled} is `true` or the drag margins are changed.
+   */
+  drag_horizontal_offset: float;
+  /**
+   * Left margin needed to drag the camera. A value of `1` makes the camera move only when reaching the left edge of the screen.
+   */
+  drag_left_margin: float;
+  /**
+   * Right margin needed to drag the camera. A value of `1` makes the camera move only when reaching the right edge of the screen.
+   */
+  drag_right_margin: float;
+  /**
+   * Top margin needed to drag the camera. A value of `1` makes the camera move only when reaching the top edge of the screen.
+   */
+  drag_top_margin: float;
+  /**
+   * If `true`, the camera only moves when reaching the vertical (top and bottom) drag margins. If `false`, the camera moves vertically regardless of the drag margins.
+   */
+  drag_vertical_enabled: boolean;
+  /**
+   * The relative vertical drag offset of the camera between the bottom (`-1`) and top (`1`) drag margins.
+   * **Note:** Used to set the initial vertical drag offset; determine the current offset; or force the current offset. It's not automatically updated when {@link drag_vertical_enabled} is `true` or the drag margins are changed.
+   */
+  drag_vertical_offset: float;
+  /** If `true`, draws the camera's drag margin rectangle in the editor. */
+  editor_draw_drag_margin: boolean;
+  /** If `true`, draws the camera's limits rectangle in the editor. */
+  editor_draw_limits: boolean;
+  /** If `true`, draws the camera's screen rectangle in the editor. */
+  editor_draw_screen: boolean;
+  /**
+   * Controls whether the camera can be active or not. If `true`, the {@link Camera2D} will become the main camera when it enters the scene tree and there is no active camera currently (see {@link Viewport.get_camera_2d}).
+   * When the camera is currently active and {@link enabled} is set to `false`, the next enabled {@link Camera2D} in the scene tree will become active.
+   */
+  enabled: boolean;
+  /**
+   * If `true`, the camera's rendered view is not affected by its {@link Node2D.rotation} and {@link Node2D.global_rotation}.
+   */
+  ignore_rotation: boolean;
+  /**
+   * Bottom scroll limit in pixels. The camera stops moving when reaching this value, but {@link offset} can push the view past the limit.
+   */
+  limit_bottom: int;
+  /**
+   * If `true`, the limits will be enabled. Disabling this will allow the camera to focus anywhere, when the four `limit_*` properties will not work.
+   */
+  limit_enabled: boolean;
+  /**
+   * Left scroll limit in pixels. The camera stops moving when reaching this value, but {@link offset} can push the view past the limit.
+   */
+  limit_left: int;
+  /**
+   * Right scroll limit in pixels. The camera stops moving when reaching this value, but {@link offset} can push the view past the limit.
+   */
+  limit_right: int;
+  /**
+   * If `true`, the camera smoothly stops when reaches its limits.
+   * This property has no effect if {@link position_smoothing_enabled} is `false`.
+   * **Note:** To immediately update the camera's position to be within limits without smoothing, even with this setting enabled, invoke {@link reset_smoothing}.
+   */
+  limit_smoothed: boolean;
+  /**
+   * Top scroll limit in pixels. The camera stops moving when reaching this value, but {@link offset} can push the view past the limit.
+   */
+  limit_top: int;
+  /**
+   * The camera's relative offset. Useful for looking around or camera shake animations. The offsetted camera can go past the limits defined in {@link limit_top}, {@link limit_bottom}, {@link limit_left} and {@link limit_right}.
+   */
+  offset: Vector2;
+  /**
+   * If `true`, the camera's view smoothly moves towards its target position at {@link position_smoothing_speed}.
+   */
+  position_smoothing_enabled: boolean;
+  /**
+   * Speed in pixels per second of the camera's smoothing effect when {@link position_smoothing_enabled} is `true`.
+   */
+  position_smoothing_speed: float;
+  /** The camera's process callback. */
+  process_callback: int;
+  /**
+   * If `true`, the camera's view smoothly rotates, via asymptotic smoothing, to align with its target rotation at {@link rotation_smoothing_speed}.
+   * **Note:** This property has no effect if {@link ignore_rotation} is `true`.
+   */
+  rotation_smoothing_enabled: boolean;
+  /**
+   * The angular, asymptotic speed of the camera's rotation smoothing effect when {@link rotation_smoothing_enabled} is `true`.
+   */
+  rotation_smoothing_speed: float;
+  /**
+   * The camera's zoom. Higher values are more zoomed in. For example, a zoom of `Vector2(2.0, 2.0)` will be twice as zoomed in on each axis (the view covers an area four times smaller). In contrast, a zoom of `Vector2(0.5, 0.5)` will be twice as zoomed out on each axis (the view covers an area four times larger). The X and Y components should generally always be set to the same value, unless you wish to stretch the camera view.
+   * **Note:** {@link FontFile.oversampling} does *not* take {@link Camera2D} zoom into account. This means that zooming in/out will cause bitmap fonts and rasterized (non-MSDF) dynamic fonts to appear blurry or pixelated unless the font is part of a {@link CanvasLayer} that makes it ignore camera zoom. To ensure text remains crisp regardless of zoom, you can enable MSDF font rendering by enabling {@link ProjectSettings.gui/theme/default_font_multichannel_signed_distance_field} (applies to the default project font only), or enabling **Multichannel Signed Distance Field** in the import options of a DynamicFont for custom fonts. On system fonts, {@link SystemFont.multichannel_signed_distance_field} can be enabled in the inspector.
+   */
+  zoom: Vector2;
+  set_anchor_mode(value: int): void;
+  get_anchor_mode(): int;
+  set_custom_viewport(value: Node | null): void;
+  get_custom_viewport(): Node | null;
+  set_drag_horizontal_enabled(value: boolean): void;
+  is_drag_horizontal_enabled(): boolean;
+  set_drag_horizontal_offset(value: float): void;
+  get_drag_horizontal_offset(): float;
+  set_drag_vertical_enabled(value: boolean): void;
+  is_drag_vertical_enabled(): boolean;
+  set_drag_vertical_offset(value: float): void;
+  get_drag_vertical_offset(): float;
+  set_margin_drawing_enabled(value: boolean): void;
+  is_margin_drawing_enabled(): boolean;
+  set_limit_drawing_enabled(value: boolean): void;
+  is_limit_drawing_enabled(): boolean;
+  set_screen_drawing_enabled(value: boolean): void;
+  is_screen_drawing_enabled(): boolean;
+  set_enabled(value: boolean): void;
+  is_enabled(): boolean;
+  set_ignore_rotation(value: boolean): void;
+  is_ignoring_rotation(): boolean;
+  set_limit_enabled(value: boolean): void;
+  is_limit_enabled(): boolean;
+  set_limit_smoothing_enabled(value: boolean): void;
+  is_limit_smoothing_enabled(): boolean;
+  set_offset(value: Vector2 | Vector2i): void;
+  get_offset(): Vector2;
+  set_position_smoothing_enabled(value: boolean): void;
+  is_position_smoothing_enabled(): boolean;
+  set_position_smoothing_speed(value: float): void;
+  get_position_smoothing_speed(): float;
+  set_process_callback(value: int): void;
+  get_process_callback(): int;
+  set_rotation_smoothing_enabled(value: boolean): void;
+  is_rotation_smoothing_enabled(): boolean;
+  set_rotation_smoothing_speed(value: float): void;
+  get_rotation_smoothing_speed(): float;
+  set_zoom(value: Vector2 | Vector2i): void;
+  get_zoom(): Vector2;
+
+  /**
+   * Aligns the camera to the tracked node.
+   * **Note:** Calling {@link force_update_scroll} after this method is not required.
+   */
+  align(): void;
+  /** Forces the camera to update scroll immediately. */
+  force_update_scroll(): void;
+  /**
+   * Returns the specified {@link Side}'s margin. See also {@link drag_bottom_margin}, {@link drag_top_margin}, {@link drag_left_margin}, and {@link drag_right_margin}.
+   */
+  get_drag_margin(margin: int): float;
+  /**
+   * Returns the camera limit for the specified {@link Side}. See also {@link limit_bottom}, {@link limit_top}, {@link limit_left}, and {@link limit_right}.
+   */
+  get_limit(margin: int): int;
+  /**
+   * Returns the center of the screen from this camera's point of view, in global coordinates.
+   * **Note:** The exact targeted position of the camera may be different. See {@link get_target_position}.
+   */
+  get_screen_center_position(): Vector2;
+  /**
+   * Returns the current screen rotation from this camera's point of view.
+   * **Note:** The screen rotation can be different from {@link Node2D.global_rotation} if the camera is rotating smoothly due to {@link rotation_smoothing_enabled}.
+   */
+  get_screen_rotation(): float;
+  /**
+   * Returns this camera's target position, in global coordinates.
+   * **Note:** The returned value is not the same as {@link Node2D.global_position}, as it is affected by the drag properties. It is also not the same as the current position if {@link position_smoothing_enabled} is `true` (see {@link get_screen_center_position}).
+   */
+  get_target_position(): Vector2;
+  /** Returns `true` if this {@link Camera2D} is the active camera (see {@link Viewport.get_camera_2d}). */
+  is_current(): boolean;
+  /** Forces this {@link Camera2D} to become the current active one. {@link enabled} must be `true`. */
+  make_current(): void;
+  /**
+   * Sets the camera's position immediately to its current smoothing destination.
+   * This method has no effect if {@link position_smoothing_enabled} is `false`.
+   */
+  reset_smoothing(): void;
+  /**
+   * Sets the specified {@link Side}'s margin. See also {@link drag_bottom_margin}, {@link drag_top_margin}, {@link drag_left_margin}, and {@link drag_right_margin}.
+   */
+  set_drag_margin(margin: int, drag_margin: float): void;
+  /**
+   * Sets the camera limit for the specified {@link Side}. See also {@link limit_bottom}, {@link limit_top}, {@link limit_left}, and {@link limit_right}.
+   */
+  set_limit(margin: int, limit: int): void;
+
+  // enum AnchorMode
+  /** The camera's position is fixed so that the top-left corner is always at the origin. */
+  static readonly ANCHOR_MODE_FIXED_TOP_LEFT: int;
+  /** The camera's position takes into account vertical/horizontal offsets and the screen size. */
+  static readonly ANCHOR_MODE_DRAG_CENTER: int;
+  // enum Camera2DProcessCallback
+  /** The camera updates during physics frames (see {@link Node.NOTIFICATION_INTERNAL_PHYSICS_PROCESS}). */
+  static readonly CAMERA2D_PROCESS_PHYSICS: int;
+  /** The camera updates during process frames (see {@link Node.NOTIFICATION_INTERNAL_PROCESS}). */
+  static readonly CAMERA2D_PROCESS_IDLE: int;
+}

package/typings/classes/Camera3D.d.ts

@@ -0,0 +1,207 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Camera node, displays from a point of view. */
+declare class Camera3D extends Node3D {
+  /** The {@link CameraAttributes} to use for this camera. */
+  attributes: CameraAttributes | null;
+  /** The {@link Compositor} to use for this camera. */
+  compositor: Compositor | null;
+  /**
+   * The culling mask that describes which {@link VisualInstance3D.layers} are rendered by this camera. By default, all 20 user-visible layers are rendered.
+   * **Note:** Since the {@link cull_mask} allows for 32 layers to be stored in total, there are an additional 12 layers that are only used internally by the engine and aren't exposed in the editor. Setting {@link cull_mask} using a script allows you to toggle those reserved layers, which can be useful for editor plugins.
+   * To adjust {@link cull_mask} more easily using a script, use {@link get_cull_mask_value} and {@link set_cull_mask_value}.
+   * **Note:** {@link VoxelGI}, SDFGI and {@link LightmapGI} will always take all layers into account to determine what contributes to global illumination. If this is an issue, set {@link GeometryInstance3D.gi_mode} to {@link GeometryInstance3D.GI_MODE_DISABLED} for meshes and {@link Light3D.light_bake_mode} to {@link Light3D.BAKE_DISABLED} for lights to exclude them from global illumination.
+   */
+  cull_mask: int;
+  /**
+   * If `true`, the ancestor {@link Viewport} is currently using this camera.
+   * If multiple cameras are in the scene, one will always be made current. For example, if two {@link Camera3D} nodes are present in the scene and only one is current, setting one camera's {@link current} to `false` will cause the other camera to be made current.
+   */
+  current: boolean;
+  /**
+   * If not {@link DOPPLER_TRACKING_DISABLED}, this camera will simulate the Doppler effect (https://en.wikipedia.org/wiki/Doppler_effect) for objects changed in particular `_process` methods.
+   * **Note:** The Doppler effect will only be heard on {@link AudioStreamPlayer3D}s if {@link AudioStreamPlayer3D.doppler_tracking} is not set to {@link AudioStreamPlayer3D.DOPPLER_TRACKING_DISABLED}.
+   */
+  doppler_tracking: int;
+  /** The {@link Environment} to use for this camera. */
+  environment: Environment | null;
+  /**
+   * The distance to the far culling boundary for this camera relative to its local Z axis. Higher values allow the camera to see further away, while decreasing {@link far} can improve performance if it results in objects being partially or fully culled.
+   */
+  far: float;
+  /**
+   * The camera's field of view angle (in degrees). Only applicable in perspective mode. Since {@link keep_aspect} locks one axis, {@link fov} sets the other axis' field of view angle.
+   * For reference, the default vertical field of view value (`75.0`) is equivalent to a horizontal FOV of:
+   * - ~91.31 degrees in a 4:3 viewport
+   * - ~101.67 degrees in a 16:10 viewport
+   * - ~107.51 degrees in a 16:9 viewport
+   * - ~121.63 degrees in a 21:9 viewport
+   */
+  fov: float;
+  /**
+   * The camera's frustum offset. This can be changed from the default to create "tilted frustum" effects such as Y-shearing (https://zdoom.org/wiki/Y-shearing).
+   * **Note:** Only effective if {@link projection} is {@link PROJECTION_FRUSTUM}.
+   */
+  frustum_offset: Vector2;
+  /** The horizontal (X) offset of the camera viewport. */
+  h_offset: float;
+  /**
+   * The axis to lock during {@link fov}/{@link size} adjustments. Can be either {@link KEEP_WIDTH} or {@link KEEP_HEIGHT}.
+   */
+  keep_aspect: int;
+  /**
+   * The distance to the near culling boundary for this camera relative to its local Z axis. Lower values allow the camera to see objects more up close to its origin, at the cost of lower precision across the *entire* range. Values lower than the default can lead to increased Z-fighting.
+   */
+  near: float;
+  /**
+   * The camera's projection mode. In {@link PROJECTION_PERSPECTIVE} mode, objects' Z distance from the camera's local space scales their perceived size.
+   */
+  projection: int;
+  /**
+   * The camera's size in meters measured as the diameter of the width or height, depending on {@link keep_aspect}. Only applicable in orthogonal and frustum modes.
+   */
+  size: float;
+  /** The vertical (Y) offset of the camera viewport. */
+  v_offset: float;
+  set_attributes(value: CameraAttributes | null): void;
+  get_attributes(): CameraAttributes | null;
+  set_compositor(value: Compositor | null): void;
+  get_compositor(): Compositor | null;
+  set_cull_mask(value: int): void;
+  get_cull_mask(): int;
+  set_current(value: boolean): void;
+  is_current(): boolean;
+  set_doppler_tracking(value: int): void;
+  get_doppler_tracking(): int;
+  set_environment(value: Environment | null): void;
+  get_environment(): Environment | null;
+  set_far(value: float): void;
+  get_far(): float;
+  set_fov(value: float): void;
+  get_fov(): float;
+  set_frustum_offset(value: Vector2 | Vector2i): void;
+  get_frustum_offset(): Vector2;
+  set_h_offset(value: float): void;
+  get_h_offset(): float;
+  set_keep_aspect_mode(value: int): void;
+  get_keep_aspect_mode(): int;
+  set_near(value: float): void;
+  get_near(): float;
+  set_projection(value: int): void;
+  get_projection(): int;
+  set_size(value: float): void;
+  get_size(): float;
+  set_v_offset(value: float): void;
+  get_v_offset(): float;
+
+  /**
+   * If this is the current camera, remove it from being current. If `enable_next` is `true`, request to make the next camera current, if any.
+   */
+  clear_current(enable_next?: boolean): void;
+  /**
+   * Returns the projection matrix that this camera uses to render to its associated viewport. The camera must be part of the scene tree to function.
+   */
+  get_camera_projection(): Projection;
+  /** Returns the camera's RID from the {@link RenderingServer}. */
+  get_camera_rid(): RID;
+  /**
+   * Returns the transform of the camera plus the vertical ({@link v_offset}) and horizontal ({@link h_offset}) offsets; and any other adjustments made to the position and orientation of the camera by subclassed cameras such as {@link XRCamera3D}.
+   */
+  get_camera_transform(): Transform3D;
+  /**
+   * Returns whether or not the specified layer of the {@link cull_mask} is enabled, given a `layer_number` between 1 and 20.
+   */
+  get_cull_mask_value(layer_number: int): boolean;
+  /**
+   * Returns the camera's frustum planes in world space units as an array of {@link Plane}s in the following order: near, far, left, top, right, bottom. Not to be confused with {@link frustum_offset}.
+   */
+  get_frustum(): Array<Plane>;
+  /**
+   * Returns the RID of a pyramid shape encompassing the camera's view frustum, ignoring the camera's near plane. The tip of the pyramid represents the position of the camera.
+   */
+  get_pyramid_shape_rid(): RID;
+  /**
+   * Returns `true` if the given position is behind the camera (the blue part of the linked diagram). See this diagram (https://raw.githubusercontent.com/godotengine/godot-docs/master/img/camera3d_position_frustum.png) for an overview of position query methods.
+   * **Note:** A position which returns `false` may still be outside the camera's field of view.
+   */
+  is_position_behind(world_point: Vector3 | Vector3i): boolean;
+  /**
+   * Returns `true` if the given position is inside the camera's frustum (the green part of the linked diagram). See this diagram (https://raw.githubusercontent.com/godotengine/godot-docs/master/img/camera3d_position_frustum.png) for an overview of position query methods.
+   */
+  is_position_in_frustum(world_point: Vector3 | Vector3i): boolean;
+  /**
+   * Makes this camera the current camera for the {@link Viewport} (see class description). If the camera node is outside the scene tree, it will attempt to become current once it's added.
+   */
+  make_current(): void;
+  /**
+   * Returns a normal vector from the screen point location directed along the camera. Orthogonal cameras are normalized. Perspective cameras account for perspective, screen width/height, etc.
+   */
+  project_local_ray_normal(screen_point: Vector2 | Vector2i): Vector3;
+  /**
+   * Returns the 3D point in world space that maps to the given 2D coordinate in the {@link Viewport} rectangle on a plane that is the given `z_depth` distance into the scene away from the camera.
+   */
+  project_position(screen_point: Vector2 | Vector2i, z_depth: float): Vector3;
+  /**
+   * Returns a normal vector in world space, that is the result of projecting a point on the {@link Viewport} rectangle by the inverse camera projection. This is useful for casting rays in the form of (origin, normal) for object intersection or picking.
+   */
+  project_ray_normal(screen_point: Vector2 | Vector2i): Vector3;
+  /**
+   * Returns a 3D position in world space, that is the result of projecting a point on the {@link Viewport} rectangle by the inverse camera projection. This is useful for casting rays in the form of (origin, normal) for object intersection or picking.
+   */
+  project_ray_origin(screen_point: Vector2 | Vector2i): Vector3;
+  /**
+   * Based on `value`, enables or disables the specified layer in the {@link cull_mask}, given a `layer_number` between 1 and 20.
+   */
+  set_cull_mask_value(layer_number: int, value: boolean): void;
+  /**
+   * Sets the camera projection to frustum mode (see {@link PROJECTION_FRUSTUM}), by specifying a `size`, an `offset`, and the `z_near` and `z_far` clip planes in world space units. The `size` parameter represents the size of the near plane, either its width or height depending on the value of {@link keep_aspect}. See also {@link frustum_offset}.
+   */
+  set_frustum(size: float, offset: Vector2 | Vector2i, z_near: float, z_far: float): void;
+  /**
+   * Sets the camera projection to orthogonal mode (see {@link PROJECTION_ORTHOGONAL}), by specifying a `size`, and the `z_near` and `z_far` clip planes in world space units.
+   * As a hint, 3D games that look 2D often use this projection, with `size` specified in pixels.
+   */
+  set_orthogonal(size: float, z_near: float, z_far: float): void;
+  /**
+   * Sets the camera projection to perspective mode (see {@link PROJECTION_PERSPECTIVE}), by specifying a `fov` (field of view) angle in degrees, and the `z_near` and `z_far` clip planes in world space units.
+   */
+  set_perspective(fov: float, z_near: float, z_far: float): void;
+  /**
+   * Returns the 2D coordinate in the {@link Viewport} rectangle that maps to the given 3D point in world space.
+   * **Note:** When using this to position GUI elements over a 3D viewport, use {@link is_position_behind} to prevent them from appearing if the 3D point is behind the camera:
+   */
+  unproject_position(world_point: Vector3 | Vector3i): Vector2;
+
+  // enum ProjectionType
+  /** Perspective projection. Objects on the screen becomes smaller when they are far away. */
+  static readonly PROJECTION_PERSPECTIVE: int;
+  /**
+   * Orthogonal projection, also known as orthographic projection. Objects remain the same size on the screen no matter how far away they are.
+   */
+  static readonly PROJECTION_ORTHOGONAL: int;
+  /**
+   * Frustum projection. This mode allows adjusting {@link frustum_offset} to create "tilted frustum" effects.
+   */
+  static readonly PROJECTION_FRUSTUM: int;
+  // enum KeepAspect
+  /**
+   * Preserves the horizontal aspect ratio; also known as Vert- scaling. This is usually the best option for projects running in portrait mode, as taller aspect ratios will benefit from a wider vertical FOV.
+   */
+  static readonly KEEP_WIDTH: int;
+  /**
+   * Preserves the vertical aspect ratio; also known as Hor+ scaling. This is usually the best option for projects running in landscape mode, as wider aspect ratios will automatically benefit from a wider horizontal FOV.
+   */
+  static readonly KEEP_HEIGHT: int;
+  // enum DopplerTracking
+  /** Disables Doppler effect (https://en.wikipedia.org/wiki/Doppler_effect) simulation (default). */
+  static readonly DOPPLER_TRACKING_DISABLED: int;
+  /**
+   * Simulate Doppler effect (https://en.wikipedia.org/wiki/Doppler_effect) by tracking positions of objects that are changed in `_process`. Changes in the relative velocity of this camera compared to those objects affect how audio is perceived (changing the audio's {@link AudioStreamPlayer3D.pitch_scale}).
+   */
+  static readonly DOPPLER_TRACKING_IDLE_STEP: int;
+  /**
+   * Simulate Doppler effect (https://en.wikipedia.org/wiki/Doppler_effect) by tracking positions of objects that are changed in `_physics_process`. Changes in the relative velocity of this camera compared to those objects affect how audio is perceived (changing the audio's {@link AudioStreamPlayer3D.pitch_scale}).
+   */
+  static readonly DOPPLER_TRACKING_PHYSICS_STEP: int;
+}

package/typings/classes/CameraAttributes.d.ts

@@ -0,0 +1,35 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Parent class for camera settings. */
+declare class CameraAttributes extends Resource {
+  /**
+   * If `true`, enables the tonemapping auto exposure mode of the scene renderer. If `true`, the renderer will automatically determine the exposure setting to adapt to the scene's illumination and the observed light.
+   * **Note:** Auto-exposure is only supported in the Forward+ rendering method, not Mobile or Compatibility.
+   */
+  auto_exposure_enabled: boolean;
+  /** The scale of the auto exposure effect. Affects the intensity of auto exposure. */
+  auto_exposure_scale: float;
+  /**
+   * The speed of the auto exposure effect. Affects the time needed for the camera to perform auto exposure.
+   */
+  auto_exposure_speed: float;
+  /** Multiplier for the exposure amount. A higher value results in a brighter image. */
+  exposure_multiplier: float;
+  /**
+   * Sensitivity of camera sensors, measured in ISO. A higher sensitivity results in a brighter image.
+   * If {@link auto_exposure_enabled} is `true`, this can be used as a method of exposure compensation, doubling the value will increase the exposure value (measured in EV100) by 1 stop.
+   * **Note:** Only available when {@link ProjectSettings.rendering/lights_and_shadows/use_physical_light_units} is enabled.
+   */
+  exposure_sensitivity: float;
+  set_auto_exposure_enabled(value: boolean): void;
+  is_auto_exposure_enabled(): boolean;
+  set_auto_exposure_scale(value: float): void;
+  get_auto_exposure_scale(): float;
+  set_auto_exposure_speed(value: float): void;
+  get_auto_exposure_speed(): float;
+  set_exposure_multiplier(value: float): void;
+  get_exposure_multiplier(): float;
+  set_exposure_sensitivity(value: float): void;
+  get_exposure_sensitivity(): float;
+}

package/typings/classes/CameraAttributesPhysical.d.ts

@@ -0,0 +1,61 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Physically-based camera settings. */
+declare class CameraAttributesPhysical extends CameraAttributes {
+  /**
+   * The maximum luminance (in EV100) used when calculating auto exposure. When calculating scene average luminance, color values will be clamped to at least this value. This limits the auto-exposure from exposing below a certain brightness, resulting in a cut off point where the scene will remain bright.
+   */
+  auto_exposure_max_exposure_value: float;
+  /**
+   * The minimum luminance (in EV100) used when calculating auto exposure. When calculating scene average luminance, color values will be clamped to at least this value. This limits the auto-exposure from exposing above a certain brightness, resulting in a cut off point where the scene will remain dark.
+   */
+  auto_exposure_min_exposure_value: float;
+  /**
+   * Size of the aperture of the camera, measured in f-stops. An f-stop is a unitless ratio between the focal length of the camera and the diameter of the aperture. A high aperture setting will result in a smaller aperture which leads to a dimmer image and sharper focus. A low aperture results in a wide aperture which lets in more light resulting in a brighter, less-focused image. Default is appropriate for outdoors at daytime (i.e. for use with a default {@link DirectionalLight3D}), for indoor lighting, a value between 2 and 4 is more appropriate.
+   * Only available when {@link ProjectSettings.rendering/lights_and_shadows/use_physical_light_units} is enabled.
+   */
+  exposure_aperture: float;
+  /**
+   * Time for shutter to open and close, evaluated as `1 / shutter_speed` seconds. A higher value will allow less light (leading to a darker image), while a lower value will allow more light (leading to a brighter image).
+   * Only available when {@link ProjectSettings.rendering/lights_and_shadows/use_physical_light_units} is enabled.
+   */
+  exposure_shutter_speed: float;
+  /**
+   * Override value for {@link Camera3D.far}. Used internally when calculating depth of field. When attached to a {@link Camera3D} as its {@link Camera3D.attributes}, it will override the {@link Camera3D.far} property.
+   */
+  frustum_far: float;
+  /**
+   * Distance between camera lens and camera aperture, measured in millimeters. Controls field of view and depth of field. A larger focal length will result in a smaller field of view and a narrower depth of field meaning fewer objects will be in focus. A smaller focal length will result in a wider field of view and a larger depth of field meaning more objects will be in focus. When attached to a {@link Camera3D} as its {@link Camera3D.attributes}, it will override the {@link Camera3D.fov} property and the {@link Camera3D.keep_aspect} property.
+   */
+  frustum_focal_length: float;
+  /**
+   * Distance from camera of object that will be in focus, measured in meters. Internally this will be clamped to be at least 1 millimeter larger than {@link frustum_focal_length}.
+   */
+  frustum_focus_distance: float;
+  /**
+   * Override value for {@link Camera3D.near}. Used internally when calculating depth of field. When attached to a {@link Camera3D} as its {@link Camera3D.attributes}, it will override the {@link Camera3D.near} property.
+   */
+  frustum_near: float;
+  set_auto_exposure_max_exposure_value(value: float): void;
+  get_auto_exposure_max_exposure_value(): float;
+  set_auto_exposure_min_exposure_value(value: float): void;
+  get_auto_exposure_min_exposure_value(): float;
+  set_aperture(value: float): void;
+  get_aperture(): float;
+  set_shutter_speed(value: float): void;
+  get_shutter_speed(): float;
+  set_far(value: float): void;
+  get_far(): float;
+  set_focal_length(value: float): void;
+  get_focal_length(): float;
+  set_focus_distance(value: float): void;
+  get_focus_distance(): float;
+  set_near(value: float): void;
+  get_near(): float;
+
+  /**
+   * Returns the vertical field of view that corresponds to the {@link frustum_focal_length}. This value is calculated internally whenever {@link frustum_focal_length} is changed.
+   */
+  get_fov(): float;
+}

package/typings/classes/CameraAttributesPractical.d.ts

@@ -0,0 +1,64 @@
+// AUTO-GENERATED from Godot class documentation.
+// Manual overrides applied from typings-overrides/*.d.ts
+
+/** Camera settings in an easy to use format. */
+declare class CameraAttributesPractical extends CameraAttributes {
+  /**
+   * The maximum sensitivity (in ISO) used when calculating auto exposure. When calculating scene average luminance, color values will be clamped to at least this value. This limits the auto-exposure from exposing below a certain brightness, resulting in a cut off point where the scene will remain bright.
+   */
+  auto_exposure_max_sensitivity: float;
+  /**
+   * The minimum sensitivity (in ISO) used when calculating auto exposure. When calculating scene average luminance, color values will be clamped to at least this value. This limits the auto-exposure from exposing above a certain brightness, resulting in a cut off point where the scene will remain dark.
+   */
+  auto_exposure_min_sensitivity: float;
+  /**
+   * Sets the maximum amount of blur. When using physically-based blur amounts, will instead act as a multiplier. High values lead to an increased amount of blurriness, but can be much more expensive to calculate. It is best to keep this as low as possible for a given art style.
+   */
+  dof_blur_amount: float;
+  /**
+   * Objects further from the {@link Camera3D} by this amount will be blurred by the depth of field effect. Measured in meters.
+   */
+  dof_blur_far_distance: float;
+  /**
+   * Enables depth of field blur for objects further than {@link dof_blur_far_distance}. Strength of blur is controlled by {@link dof_blur_amount} and modulated by {@link dof_blur_far_transition}.
+   * **Note:** Depth of field blur is only supported in the Forward+ and Mobile rendering methods, not Compatibility.
+   * **Note:** Depth of field blur is not supported on viewports that have a transparent background (where {@link Viewport.transparent_bg} is `true`).
+   */
+  dof_blur_far_enabled: boolean;
+  /**
+   * When positive, distance over which (starting from {@link dof_blur_far_distance}) blur effect will scale from 0 to {@link dof_blur_amount}. When negative, uses physically-based scaling so depth of field effect will scale from 0 at {@link dof_blur_far_distance} and will increase in a physically accurate way as objects get further from the {@link Camera3D}.
+   */
+  dof_blur_far_transition: float;
+  /**
+   * Objects closer from the {@link Camera3D} by this amount will be blurred by the depth of field effect. Measured in meters.
+   */
+  dof_blur_near_distance: float;
+  /**
+   * Enables depth of field blur for objects closer than {@link dof_blur_near_distance}. Strength of blur is controlled by {@link dof_blur_amount} and modulated by {@link dof_blur_near_transition}.
+   * **Note:** Depth of field blur is only supported in the Forward+ and Mobile rendering methods, not Compatibility.
+   * **Note:** Depth of field blur is not supported on viewports that have a transparent background (where {@link Viewport.transparent_bg} is `true`).
+   */
+  dof_blur_near_enabled: boolean;
+  /**
+   * When positive, distance over which blur effect will scale from 0 to {@link dof_blur_amount}, ending at {@link dof_blur_near_distance}. When negative, uses physically-based scaling so depth of field effect will scale from 0 at {@link dof_blur_near_distance} and will increase in a physically accurate way as objects get closer to the {@link Camera3D}.
+   */
+  dof_blur_near_transition: float;
+  set_auto_exposure_max_sensitivity(value: float): void;
+  get_auto_exposure_max_sensitivity(): float;
+  set_auto_exposure_min_sensitivity(value: float): void;
+  get_auto_exposure_min_sensitivity(): float;
+  set_dof_blur_amount(value: float): void;
+  get_dof_blur_amount(): float;
+  set_dof_blur_far_distance(value: float): void;
+  get_dof_blur_far_distance(): float;
+  set_dof_blur_far_enabled(value: boolean): void;
+  is_dof_blur_far_enabled(): boolean;
+  set_dof_blur_far_transition(value: float): void;
+  get_dof_blur_far_transition(): float;
+  set_dof_blur_near_distance(value: float): void;
+  get_dof_blur_near_distance(): float;
+  set_dof_blur_near_enabled(value: boolean): void;
+  is_dof_blur_near_enabled(): boolean;
+  set_dof_blur_near_transition(value: float): void;
+  get_dof_blur_near_transition(): float;
+}