@ringozz/godot 0.1.0

package/gen/classes/Camera2D.ts

@@ -0,0 +1,266 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Node2D } from './Node2D.ts';
+import type { Vector2 } from '../value-types/index.ts';
+import type { Node } from './Node.ts';
+
+/**
+ * Camera node for 2D scenes. It forces the screen (current layer) to scroll following this node. This makes it easier (and faster) to program scrollable scenes than manually changing the position of {@link CanvasItem}-based nodes.
+ * Cameras register themselves in the nearest {@link Viewport} node (when ascending the tree). Only one camera can be active per viewport. If no viewport is available ascending the tree, the camera will register in the global viewport.
+ * This node is intended to be a simple helper to get things going quickly, but more functionality may be desired to change how the camera works. To make your own custom camera node, inherit it from {@link Node2D} and change the transform of the canvas by setting {@link Viewport.canvasTransform} in {@link Viewport} (you can obtain the current {@link Viewport} by using {@link Node.getViewport}).
+ * Note that the {@link Camera2D} node's {@link Node2D.globalPosition} doesn't represent the actual position of the screen, which may differ due to applied smoothing or limits. You can use {@link getScreenCenterPosition} to get the real position. Same for the node's {@link Node2D.globalRotation} which may be different due to applied rotation smoothing. You can use {@link getScreenRotation} to get the current rotation of the screen.
+ */
+export class Camera2D extends Node2D {
+    constructor(name = 174) { super(name); }
+
+    /**
+     * Forces this {@link Camera2D} to become the current active one. {@link enabled} must be `true`.
+     */
+    makeCurrent(): void { _C(this, 8729); }
+
+    /**
+     * Returns `true` if this {@link Camera2D} is the active camera (see {@link Viewport.getCamera2d}).
+     */
+    isCurrent(): boolean { return _C(this, 7862) as boolean; }
+
+    /**
+     * Returns this camera's target position, in global coordinates.
+     * **Note:** The returned value is not the same as {@link Node2D.globalPosition}, as it is affected by the drag properties. It is also not the same as the current position if {@link positionSmoothingEnabled} is `true` (see {@link getScreenCenterPosition}).
+     */
+    getTargetPosition(): Vector2 { return _C(this, 6702) as Vector2; }
+
+    /**
+     * 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 getTargetPosition}.
+     */
+    getScreenCenterPosition(): Vector2 { return _C(this, 6257) as Vector2; }
+
+    /**
+     * Returns the current screen rotation from this camera's point of view.
+     * **Note:** The screen rotation can be different from {@link Node2D.globalRotation} if the camera is rotating smoothly due to {@link rotationSmoothingEnabled}.
+     */
+    getScreenRotation(): number { return _C(this, 6263) as number; }
+
+    /**
+     * Forces the camera to update scroll immediately.
+     */
+    forceUpdateScroll(): void { _C(this, 3542); }
+
+    /**
+     * Sets the camera's position immediately to its current smoothing destination.
+     * This method has no effect if {@link positionSmoothingEnabled} is `false`.
+     */
+    resetSmoothing(): void { _C(this, 10074); }
+
+    /**
+     * Aligns the camera to the tracked node.
+     * **Note:** Calling {@link forceUpdateScroll} after this method is not required.
+     */
+    align(): void { _C(this, 1403); }
+
+    /**
+     * The camera's relative offset. Useful for looking around or camera shake animations. The offsetted camera can go past the limits defined in {@link limitTop}, {@link limitBottom}, {@link limitLeft} and {@link limitRight}.
+     */
+    get offset(): Vector2 { return _C(this, 5703) as Vector2; }
+    set offset(v: Vector2) { _C(this, 12170, v); }
+
+    /**
+     * The Camera2D's anchor point.
+     */
+    get anchorMode(): AnchorMode { return _C(this, 3746) as AnchorMode; }
+    set anchorMode(v: AnchorMode) { _C(this, 10488, v); }
+
+    /**
+     * If `true`, the camera's rendered view is not affected by its {@link Node2D.rotation} and {@link Node2D.globalRotation}.
+     */
+    get ignoreRotation(): boolean { return _C(this, 8006) as boolean; }
+    set ignoreRotation(v: boolean) { _C(this, 11666, v); }
+
+    /**
+     * 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.getCamera2d}).
+     * 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.
+     */
+    get enabled(): boolean { return _C(this, 7935) as boolean; }
+    set enabled(v: boolean) { _C(this, 11286, v); }
+
+    /**
+     * 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/defaultFontMultichannelSignedDistanceField} (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.multichannelSignedDistanceField} can be enabled in the inspector.
+     */
+    get zoom(): Vector2 { return _C(this, 7185) as Vector2; }
+    set zoom(v: Vector2) { _C(this, 13409, v); }
+
+    /**
+     * The custom {@link Viewport} node attached to the {@link Camera2D}. If `null` or not a {@link Viewport}, uses the default viewport instead.
+     */
+    get customViewport(): Node { return _C(this, 4401) as Node; }
+    set customViewport(v: Node) { _C(this, 11024, v); }
+
+    /**
+     * The camera's process callback.
+     */
+    get processCallback(): Camera2DProcessCallback { return _C(this, 6019) as Camera2DProcessCallback; }
+    set processCallback(v: Camera2DProcessCallback) { _C(this, 12423, v); }
+
+    /**
+     * If `true`, the limits will be enabled. Disabling this will allow the camera to focus anywhere, when the four `limit_*` properties will not work.
+     */
+    get limitEnabled(): boolean { return _C(this, 8071) as boolean; }
+    set limitEnabled(v: boolean) { _C(this, 11908, v); }
+
+    /**
+     * Left scroll limit in pixels. The camera stops moving when reaching this value, but {@link offset} can push the view past the limit.
+     */
+    get limitLeft(): number { return _C(this, 5348, 0) as number; }
+    set limitLeft(v: number) { _C(this, 11905, 0, v); }
+
+    /**
+     * Top scroll limit in pixels. The camera stops moving when reaching this value, but {@link offset} can push the view past the limit.
+     */
+    get limitTop(): number { return _C(this, 5348, 1) as number; }
+    set limitTop(v: number) { _C(this, 11905, 1, v); }
+
+    /**
+     * Right scroll limit in pixels. The camera stops moving when reaching this value, but {@link offset} can push the view past the limit.
+     */
+    get limitRight(): number { return _C(this, 5348, 2) as number; }
+    set limitRight(v: number) { _C(this, 11905, 2, v); }
+
+    /**
+     * Bottom scroll limit in pixels. The camera stops moving when reaching this value, but {@link offset} can push the view past the limit.
+     */
+    get limitBottom(): number { return _C(this, 5348, 3) as number; }
+    set limitBottom(v: number) { _C(this, 11905, 3, v); }
+
+    /**
+     * If `true`, the camera smoothly stops when reaches its limits.
+     * This property has no effect if {@link positionSmoothingEnabled} is `false`.
+     * **Note:** To immediately update the camera's position to be within limits without smoothing, even with this setting enabled, invoke {@link resetSmoothing}.
+     */
+    get limitSmoothed(): boolean { return _C(this, 8072) as boolean; }
+    set limitSmoothed(v: boolean) { _C(this, 11910, v); }
+
+    /**
+     * If `true`, the camera's view smoothly moves towards its target position at {@link positionSmoothingSpeed}.
+     */
+    get positionSmoothingEnabled(): boolean { return _C(this, 8196) as boolean; }
+    set positionSmoothingEnabled(v: boolean) { _C(this, 12384, v); }
+
+    /**
+     * Speed in pixels per second of the camera's smoothing effect when {@link positionSmoothingEnabled} is `true`.
+     */
+    get positionSmoothingSpeed(): number { return _C(this, 5976) as number; }
+    set positionSmoothingSpeed(v: number) { _C(this, 12385, v); }
+
+    /**
+     * If `true`, the camera's view smoothly rotates, via asymptotic smoothing, to align with its target rotation at {@link rotationSmoothingSpeed}.
+     * **Note:** This property has no effect if {@link ignoreRotation} is `true`.
+     */
+    get rotationSmoothingEnabled(): boolean { return _C(this, 8256) as boolean; }
+    set rotationSmoothingEnabled(v: boolean) { _C(this, 12588, v); }
+
+    /**
+     * The angular, asymptotic speed of the camera's rotation smoothing effect when {@link rotationSmoothingEnabled} is `true`.
+     */
+    get rotationSmoothingSpeed(): number { return _C(this, 6215) as number; }
+    set rotationSmoothingSpeed(v: number) { _C(this, 12589, v); }
+
+    /**
+     * If `true`, the camera only moves when reaching the horizontal (left and right) drag margins. If `false`, the camera moves horizontally regardless of margins.
+     */
+    get dragHorizontalEnabled(): boolean { return _C(this, 7895) as boolean; }
+    set dragHorizontalEnabled(v: boolean) { _C(this, 11169, v); }
+
+    /**
+     * 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.
+     */
+    get dragVerticalEnabled(): boolean { return _C(this, 7898) as boolean; }
+    set dragVerticalEnabled(v: boolean) { _C(this, 11176, v); }
+
+    /**
+     * 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 dragHorizontalEnabled} is `true` or the drag margins are changed.
+     */
+    get dragHorizontalOffset(): number { return _C(this, 4558) as number; }
+    set dragHorizontalOffset(v: number) { _C(this, 11170, v); }
+
+    /**
+     * 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 dragVerticalEnabled} is `true` or the drag margins are changed.
+     */
+    get dragVerticalOffset(): number { return _C(this, 4562) as number; }
+    set dragVerticalOffset(v: number) { _C(this, 11177, v); }
+
+    /**
+     * Left margin needed to drag the camera. A value of `1` makes the camera move only when reaching the left edge of the screen.
+     */
+    get dragLeftMargin(): number { return _C(this, 4559, 0) as number; }
+    set dragLeftMargin(v: number) { _C(this, 11171, 0, v); }
+
+    /**
+     * Top margin needed to drag the camera. A value of `1` makes the camera move only when reaching the top edge of the screen.
+     */
+    get dragTopMargin(): number { return _C(this, 4559, 1) as number; }
+    set dragTopMargin(v: number) { _C(this, 11171, 1, v); }
+
+    /**
+     * Right margin needed to drag the camera. A value of `1` makes the camera move only when reaching the right edge of the screen.
+     */
+    get dragRightMargin(): number { return _C(this, 4559, 2) as number; }
+    set dragRightMargin(v: number) { _C(this, 11171, 2, v); }
+
+    /**
+     * Bottom margin needed to drag the camera. A value of `1` makes the camera move only when reaching the bottom edge of the screen.
+     */
+    get dragBottomMargin(): number { return _C(this, 4559, 3) as number; }
+    set dragBottomMargin(v: number) { _C(this, 11171, 3, v); }
+
+    /**
+     * If `true`, draws the camera's screen rectangle in the editor.
+     */
+    get editorDrawScreen(): boolean { return _C(this, 8270) as boolean; }
+    set editorDrawScreen(v: boolean) { _C(this, 12626, v); }
+
+    /**
+     * If `true`, draws the camera's limits rectangle in the editor.
+     */
+    get editorDrawLimits(): boolean { return _C(this, 8070) as boolean; }
+    set editorDrawLimits(v: boolean) { _C(this, 11907, v); }
+
+    /**
+     * If `true`, draws the camera's drag margin rectangle in the editor.
+     */
+    get editorDrawDragMargin(): boolean { return _C(this, 8096) as boolean; }
+    set editorDrawDragMargin(v: boolean) { _C(this, 11970, v); }
+
+    static readonly name = _R(174, Camera2D);
+}
+
+export const AnchorMode = {
+    /**
+     * The camera's position is fixed so that the top-left corner is always at the origin.
+     */
+    ANCHOR_MODE_FIXED_TOP_LEFT: 0,
+    /**
+     * The camera's position takes into account vertical/horizontal offsets and the screen size.
+     */
+    ANCHOR_MODE_DRAG_CENTER: 1,
+} as const;
+
+export type AnchorMode = (typeof AnchorMode)[keyof typeof AnchorMode];
+
+export const Camera2DProcessCallback = {
+    /**
+     * The camera updates during physics frames (see {@link Node.NOTIFICATION_INTERNAL_PHYSICS_PROCESS}).
+     */
+    CAMERA2D_PROCESS_PHYSICS: 0,
+    /**
+     * The camera updates during process frames (see {@link Node.NOTIFICATION_INTERNAL_PROCESS}).
+     */
+    CAMERA2D_PROCESS_IDLE: 1,
+} as const;
+
+export type Camera2DProcessCallback = (typeof Camera2DProcessCallback)[keyof typeof Camera2DProcessCallback];
+

package/gen/classes/Camera3D.ts

@@ -0,0 +1,275 @@
+// Auto-generated from extension_api.json - DO NOT EDIT
+// Generated by dev/codegen.ts
+
+import { _C, _R } from '../../src/runtime.ts';
+import { Node3D } from './Node3D.ts';
+import type { GodotArray, RID } from '../heap-types/index.ts';
+import type { Plane, Projection, Transform3D, Vector2, Vector3 } from '../value-types/index.ts';
+import type { CameraAttributes } from './CameraAttributes.ts';
+import type { Compositor } from './Compositor.ts';
+import type { Environment } from './Environment.ts';
+
+/**
+ * {@link Camera3D} is a special node that displays what is visible from its current location. Cameras register themselves in the nearest {@link Viewport} node (when ascending the tree). Only one camera can be active per viewport. If no viewport is available ascending the tree, the camera will register in the global viewport. In other words, a camera just provides 3D display capabilities to a {@link Viewport}, and, without one, a scene registered in that {@link Viewport} (or higher viewports) can't be displayed.
+ */
+export class Camera3D extends Node3D {
+    constructor(name = 175) { super(name); }
+
+    /**
+     * 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.
+     */
+    projectRayNormal(screenPoint: Vector2): Vector3 { return _C(this, 9593, screenPoint) as Vector3; }
+
+    /**
+     * 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.
+     */
+    projectLocalRayNormal(screenPoint: Vector2): Vector3 { return _C(this, 9591, screenPoint) as 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.
+     */
+    projectRayOrigin(screenPoint: Vector2): Vector3 { return _C(this, 9594, screenPoint) as Vector3; }
+
+    /**
+     * 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 isPositionBehind} to prevent them from appearing if the 3D point is behind the camera:
+     *
+     * ```text
+     *
+     * # This code block is part of a script that inherits from Node3D.
+     * # `control` is a reference to a node inheriting from Control.
+     * control.visible = not get_viewport().get_camera_3d().is_position_behind(global_transform.origin)
+     * control.position = get_viewport().get_camera_3d().unproject_position(global_transform.origin)
+     *
+     * ```
+     */
+    unprojectPosition(worldPoint: Vector3): Vector2 { return _C(this, 14485, worldPoint) as Vector2; }
+
+    /**
+     * 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.
+     */
+    isPositionBehind(worldPoint: Vector3): boolean { return _C(this, 8192, worldPoint) as boolean; }
+
+    /**
+     * 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 `zDepth` distance into the scene away from the camera.
+     */
+    projectPosition(screenPoint: Vector2, zDepth: number): Vector3 { return _C(this, 9592, screenPoint, zDepth) as Vector3; }
+
+    /**
+     * Sets the camera projection to perspective mode (see {@link PROJECTION_PERSPECTIVE}), by specifying a `fov` (field of view) angle in degrees, and the `zNear` and `zFar` clip planes in world space units.
+     */
+    setPerspective(fov: number, zNear: number, zFar: number): void { _C(this, 12304, fov, zNear, zFar); }
+
+    /**
+     * Sets the camera projection to orthogonal mode (see {@link PROJECTION_ORTHOGONAL}), by specifying a `size`, and the `zNear` and `zFar` clip planes in world space units.
+     * As a hint, 3D games that look 2D often use this projection, with `size` specified in pixels.
+     */
+    setOrthogonal(size: number, zNear: number, zFar: number): void { _C(this, 12210, size, zNear, zFar); }
+
+    /**
+     * Sets the camera projection to frustum mode (see {@link PROJECTION_FRUSTUM}), by specifying a `size`, an `offset`, and the `zNear` and `zFar` 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 keepAspect}. See also {@link frustumOffset}.
+     */
+    setFrustum(size: number, offset: Vector2, zNear: number, zFar: number): void { _C(this, 11501, size, offset, zNear, zFar); }
+
+    /**
+     * 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.
+     */
+    makeCurrent(): void { _C(this, 8729); }
+
+    /**
+     * If this is the current camera, remove it from being current. If `enableNext` is `true`, request to make the next camera current, if any.
+     */
+    clearCurrent(enableNext?: boolean /* = true */): void { _C(this, 2256, enableNext); }
+
+    /**
+     * Returns the transform of the camera plus the vertical ({@link vOffset}) and horizontal ({@link hOffset}) offsets; and any other adjustments made to the position and orientation of the camera by subclassed cameras such as {@link XRCamera3D}.
+     */
+    getCameraTransform(): Transform3D { return _C(this, 4067) as Transform3D; }
+
+    /**
+     * 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.
+     */
+    getCameraProjection(): Projection { return _C(this, 4065) as Projection; }
+
+    /**
+     * 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 frustumOffset}.
+     */
+    getFrustum(): GodotArray<Plane> { return _C(this, 4908) as GodotArray<Plane>; }
+
+    /**
+     * 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.
+     */
+    isPositionInFrustum(worldPoint: Vector3): boolean { return _C(this, 8195, worldPoint) as boolean; }
+
+    /**
+     * Returns the camera's RID from the {@link RenderingServer}.
+     */
+    getCameraRid(): RID { return _C(this, 4066) as RID; }
+
+    /**
+     * 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.
+     */
+    getPyramidShapeRid(): RID { return _C(this, 6058) as RID; }
+
+    /**
+     * Based on `value`, enables or disables the specified layer in the {@link cullMask}, given a `layerNumber` between 1 and 20.
+     */
+    setCullMaskValue(layerNumber: number, value: boolean): void { _C(this, 10982, layerNumber, value); }
+
+    /**
+     * Returns whether or not the specified layer of the {@link cullMask} is enabled, given a `layerNumber` between 1 and 20.
+     */
+    getCullMaskValue(layerNumber: number): boolean { return _C(this, 4340, layerNumber) as boolean; }
+
+    /**
+     * The axis to lock during {@link fov}/{@link size} adjustments. Can be either {@link KEEP_WIDTH} or {@link KEEP_HEIGHT}.
+     */
+    get keepAspect(): KeepAspect { return _C(this, 5282) as KeepAspect; }
+    set keepAspect(v: KeepAspect) { _C(this, 11857, v); }
+
+    /**
+     * 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 cullMask} 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 cullMask} using a script allows you to toggle those reserved layers, which can be useful for editor plugins.
+     * To adjust {@link cullMask} more easily using a script, use {@link getCullMaskValue} and {@link setCullMaskValue}.
+     * **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.giMode} to {@link GeometryInstance3D.GI_MODE_DISABLED} for meshes and {@link Light3D.lightBakeMode} to {@link Light3D.BAKE_DISABLED} for lights to exclude them from global illumination.
+     */
+    get cullMask(): number { return _C(this, 4339) as number; }
+    set cullMask(v: number) { _C(this, 10981, v); }
+
+    /**
+     * The {@link Environment} to use for this camera.
+     */
+    get environment(): Environment { return _C(this, 4678) as Environment; }
+    set environment(v: Environment) { _C(this, 11301, v); }
+
+    /**
+     * The {@link CameraAttributes} to use for this camera.
+     */
+    get attributes(): CameraAttributes { return _C(this, 3816) as CameraAttributes; }
+    set attributes(v: CameraAttributes) { _C(this, 10555, v); }
+
+    /**
+     * The {@link Compositor} to use for this camera.
+     */
+    get compositor(): Compositor { return _C(this, 4250) as Compositor; }
+    set compositor(v: Compositor) { _C(this, 10931, v); }
+
+    /**
+     * The horizontal (X) offset of the camera viewport.
+     */
+    get hOffset(): number { return _C(this, 5001) as number; }
+    set hOffset(v: number) { _C(this, 11586, v); }
+
+    /**
+     * The vertical (Y) offset of the camera viewport.
+     */
+    get vOffset(): number { return _C(this, 7012) as number; }
+    set vOffset(v: number) { _C(this, 13263, v); }
+
+    /**
+     * 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.dopplerTracking} is not set to {@link AudioStreamPlayer3D.DOPPLER_TRACKING_DISABLED}.
+     */
+    get dopplerTracking(): DopplerTracking { return _C(this, 4545) as DopplerTracking; }
+    set dopplerTracking(v: DopplerTracking) { _C(this, 11155, v); }
+
+    /**
+     * The camera's projection mode. In {@link PROJECTION_PERSPECTIVE} mode, objects' Z distance from the camera's local space scales their perceived size.
+     */
+    get projection(): ProjectionType { return _C(this, 6043) as ProjectionType; }
+    set projection(v: ProjectionType) { _C(this, 12442, v); }
+
+    /**
+     * 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.
+     */
+    get current(): boolean { return _C(this, 7862) as boolean; }
+    set current(v: boolean) { _C(this, 10984, v); }
+
+    /**
+     * The camera's field of view angle (in degrees). Only applicable in perspective mode. Since {@link keepAspect} 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
+     */
+    get fov(): number { return _C(this, 4865) as number; }
+    set fov(v: number) { _C(this, 11468, v); }
+
+    /**
+     * The camera's size in meters measured as the diameter of the width or height, depending on {@link keepAspect}. Only applicable in orthogonal and frustum modes.
+     */
+    get size(): number { return _C(this, 6399) as number; }
+    set size(v: number) { _C(this, 12752, v); }
+
+    /**
+     * 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}.
+     */
+    get frustumOffset(): Vector2 { return _C(this, 4909) as Vector2; }
+    set frustumOffset(v: Vector2) { _C(this, 11502, v); }
+
+    /**
+     * 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.
+     */
+    get near(): number { return _C(this, 5616) as number; }
+    set near(v: number) { _C(this, 12124, v); }
+
+    /**
+     * 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.
+     */
+    get far(): number { return _C(this, 4758) as number; }
+    set far(v: number) { _C(this, 11369, v); }
+
+    static readonly name = _R(175, Camera3D);
+}
+
+export const ProjectionType = {
+    /**
+     * Perspective projection. Objects on the screen becomes smaller when they are far away.
+     */
+    PROJECTION_PERSPECTIVE: 0,
+    /**
+     * Orthogonal projection, also known as orthographic projection. Objects remain the same size on the screen no matter how far away they are.
+     */
+    PROJECTION_ORTHOGONAL: 1,
+    /**
+     * Frustum projection. This mode allows adjusting {@link frustumOffset} to create "tilted frustum" effects.
+     */
+    PROJECTION_FRUSTUM: 2,
+} as const;
+
+export type ProjectionType = (typeof ProjectionType)[keyof typeof ProjectionType];
+
+export const 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.
+     */
+    KEEP_WIDTH: 0,
+    /**
+     * 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.
+     */
+    KEEP_HEIGHT: 1,
+} as const;
+
+export type KeepAspect = (typeof KeepAspect)[keyof typeof KeepAspect];
+
+export const DopplerTracking = {
+    /**
+     * Disables [Doppler effect](https://en.wikipedia.org/wiki/Doppler_effect) simulation (default).
+     */
+    DOPPLER_TRACKING_DISABLED: 0,
+    /**
+     * 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.pitchScale}).
+     */
+    DOPPLER_TRACKING_IDLE_STEP: 1,
+    /**
+     * 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.pitchScale}).
+     */
+    DOPPLER_TRACKING_PHYSICS_STEP: 2,
+} as const;
+
+export type DopplerTracking = (typeof DopplerTracking)[keyof typeof DopplerTracking];
+

package/gen/classes/CameraAttributes.ts

@@ -0,0 +1,50 @@
+// 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';
+
+/**
+ * Controls camera-specific attributes such as depth of field and exposure override.
+ * When used in a {@link WorldEnvironment} it provides default settings for exposure, auto-exposure, and depth of field that will be used by all cameras without their own {@link CameraAttributes}, including the editor camera. When used in a {@link Camera3D} it will override any {@link CameraAttributes} set in the {@link WorldEnvironment}. When used in {@link VoxelGI} or {@link LightmapGI}, only the exposure settings will be used.
+ * See also {@link Environment} for general 3D environment settings.
+ * This is a pure virtual class that is inherited by {@link CameraAttributesPhysical} and {@link CameraAttributesPractical}.
+ */
+export class CameraAttributes extends Resource {
+    constructor(name = 176) { super(name); }
+
+    /**
+     * Sensitivity of camera sensors, measured in ISO. A higher sensitivity results in a brighter image.
+     * If {@link autoExposureEnabled} 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/lightsAndShadows/usePhysicalLightUnits} is enabled.
+     */
+    get exposureSensitivity(): number { return _C(this, 4710) as number; }
+    set exposureSensitivity(v: number) { _C(this, 11330, v); }
+
+    /**
+     * Multiplier for the exposure amount. A higher value results in a brighter image.
+     */
+    get exposureMultiplier(): number { return _C(this, 4709) as number; }
+    set exposureMultiplier(v: number) { _C(this, 11329, v); }
+
+    /**
+     * 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.
+     */
+    get autoExposureEnabled(): boolean { return _C(this, 7773) as boolean; }
+    set autoExposureEnabled(v: boolean) { _C(this, 10570, v); }
+
+    /**
+     * The scale of the auto exposure effect. Affects the intensity of auto exposure.
+     */
+    get autoExposureScale(): number { return _C(this, 3836) as number; }
+    set autoExposureScale(v: number) { _C(this, 10575, v); }
+
+    /**
+     * The speed of the auto exposure effect. Affects the time needed for the camera to perform auto exposure.
+     */
+    get autoExposureSpeed(): number { return _C(this, 3837) as number; }
+    set autoExposureSpeed(v: number) { _C(this, 10576, v); }
+
+    static readonly name = _R(176, CameraAttributes);
+}